SDK do Databricks para Go

Neste artigo, o senhor aprenderá a automatizar Databricks operações e a acelerar o desenvolvimento com o Databricks SDK for Go. Este artigo complementa o Databricks SDK for Go README, a referênciaAPI e os exemplos.

Observação

Esse recurso está em versão Beta e pode ser usado na produção.

Durante o período Beta, o Databricks recomenda que você pin uma dependência na versão secundária específica do SDK do Databricks para Go da qual seu código depende, por exemplo, no arquivo go.mod de um projeto. Para obter mais informações sobre fixação de dependências, consulte Gerenciando dependências.

Antes de começar

Antes de começar a usar o SDK do Databricks para Go, sua máquina de desenvolvimento deve ter:

Vá instalado.
Autenticação do Databricks configurada.

Comece a usar o Databricks SDK for Go

Em sua máquina de desenvolvimento com o Go já instalado, um projeto de código Go existente já criado e a autenticação do Databricks configurada, crie um arquivo go.mod para rastrear as dependências do código Go executando o comando go mod init , por exemplo:
```
go mod init sample
```
Tome uma dependência do pacote Databricks SDK for Go executando o comando go mod edit -require , substituindo 0.8.0 pela versão mais recente do pacote Databricks SDK for Go conforme listado no CHANGELOG:
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
Seu arquivo go.mod agora deve ter esta aparência:
```
module sample

go 1.18

require github.com/databricks/databricks-sdk-go v0.8.0
```

Em seu projeto, crie um arquivo de código Go que importe o Databricks SDK for Go. O exemplo a seguir, em um arquivo chamado main.go com o seguinte conteúdo, lista todos os clusters em seu workspace do Databricks:

package main

import (
  "context"

  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/service/compute"
)

func main() {
  w := databricks.Must(databricks.NewWorkspaceClient())
  all, err := w.Clusters.ListAll(context.Background(), compute.ListClustersRequest{})
  if err != nil {
    panic(err)
  }
  for _, c := range all {
    println(c.ClusterName)
  }
}

Adicione quaisquer dependências de módulo ausentes executando o comando go mod tidy :
```
go mod tidy
```
Observação

Se você receber o erro go: warning: "all" matched no packages, você esqueceu de adicionar um arquivo de código Go que importa o SDK do Databricks para Go.
Obtenha cópias de todos os pacotes necessários para oferecer suporte a compilações e testes de pacotes em seu módulo main , executando o comando go mod vendor :
```
go mod vendor
```
Configure sua máquina de desenvolvimento para autenticação Databricks.
execute seu arquivo de código Go, assumindo um arquivo chamado main.go, executando o comando go run :
```
go run main.go
```
Observação

Ao não definir *databricks.Config como um argumento na chamada anterior para w := databricks.Must(databricks.NewWorkspaceClient()), o SDK do Databricks para Go usa seu processo default para tentar executar a autenticação do Databricks. Para substituir esse comportamento default , consulte Authenticate the Databricks SDK for Go with your Databricks account or workspace.

Atualize o SDK do Databricks para Go

Para atualizar seu projeto Go para usar um dos pacotes Databricks SDK for Go conforme listado em CHANGELOG, faça o seguinte:

execute o comando go get da raiz do seu projeto, especificando o sinalizador -u para fazer uma atualização e fornecendo o nome e o número da versão de destino do pacote Databricks SDK for Go. Por exemplo, para atualizar para a versão 0.12.0, execute o seguinte comando:
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Adicione e atualize quaisquer dependências de módulo ausentes e desatualizadas executando o comando go mod tidy :
```
go mod tidy
```
Obtenha cópias de todos os pacotes novos e atualizados necessários para oferecer suporte a compilações e testes de pacotes em seu módulo main , executando o comando go mod vendor :
```
go mod vendor
```

Autentique o SDK do Databricks para Go com sua conta ou espaço de trabalho do Databricks

O Databricks SDK for Go implementa o padrão de autenticação unificada do cliente Databricks, uma abordagem arquitetônica e programática consolidada e consistente para autenticação. Essa abordagem ajuda a tornar a configuração e a automatização da autenticação com o Databricks mais centralizada e previsível. Ele permite que o senhor configure a autenticação do Databricks uma vez e, em seguida, use essa configuração em várias ferramentas e SDKs do Databricks sem outras alterações na configuração da autenticação. Para obter mais informações, incluindo exemplos de código mais completos em Go, consulte Databricks client unified authentication.

Alguns dos padrões de codificação disponíveis para inicializar a autenticação do Databricks com o SDK do Databricks para Go incluem:

Use a autenticação default do Databricks seguindo um destes procedimentos:
- Crie ou identifique um perfil de configuração do Databricks personalizado com os campos obrigatórios para o tipo de autenticação desejada do Databricks. Em seguida, defina a variável de ambiente DATABRICKS_CONFIG_PROFILE com o nome do perfil de configuração personalizado.
- Defina a variável de ambiente necessária para o tipo de autenticação Databricks de destino.
Em seguida, instancie, por exemplo, um objeto WorkspaceClient com autenticação default do Databricks da seguinte maneira:
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
A codificação dos campos obrigatórios tem suporte, mas não é recomendada, pois corre o risco de expor informações confidenciais em seu código, como access token pessoal do Databricks. O exemplo a seguir codifica os valores access tokens do Databricks para autenticação tokens do Databricks:
```
import (
  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/config"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient(&databricks.Config{
  Host:  "https://...",
  Token: "...",
}))
```

Consulte também Autenticação no SDK do Databricks para Go README.

Exemplos

Os exemplos de código a seguir demonstram como usar o Databricks SDK para Go para criar e excluir clusters, execução Job e listar usuários account . Esses exemplos de código usam o processo de autenticação Databricks default doDatabricks SDK for Go.

Para obter exemplos de código adicionais, consulte a pasta de exemplos no repositório Databricks SDK for Go no GitHub.

Criar um cluster
Excluir permanentemente um clusters
execução de um Job
Gerenciar arquivos em Unity Catalog volumes
Listar usuários account

Criar um clusters

Este exemplo de código cria um clusters com a versão mais recente disponível do Databricks Runtime Long Term Support (LTS) e o menor tipo de nó clusters disponível com um disco local. Esses clusters têm um worker e os clusters serão encerrados automaticamente após 15 minutos de tempo de parada. A chamada do método CreateAndWait faz com que o código seja pausado até que os novos clusters sejam executados no workspace.

package main

import (
  "context"
  "fmt"

  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/service/compute"
)

func main() {
  const clusterName            = "my-cluster"
  const autoTerminationMinutes = 15
  const numWorkers             = 1

  w   := databricks.Must(databricks.NewWorkspaceClient())
  ctx := context.Background()

  // Get the full list of available Spark versions to choose from.
  sparkVersions, err := w.Clusters.SparkVersions(ctx)

  if err != nil {
    panic(err)
  }

  // Choose the latest Long Term Support (LTS) version.
  latestLTS, err := sparkVersions.Select(compute.SparkVersionRequest{
    Latest:          true,
    LongTermSupport: true,
  })

  if err != nil {
    panic(err)
  }

  // Get the list of available cluster node types to choose from.
  nodeTypes, err := w.Clusters.ListNodeTypes(ctx)

  if err != nil {
    panic(err)
  }

  // Choose the smallest available cluster node type.
  smallestWithLocalDisk, err := nodeTypes.Smallest(clusters.NodeTypeRequest{
    LocalDisk: true,
  })

  if err != nil {
    panic(err)
  }

  fmt.Println("Now attempting to create the cluster, please wait...")

  runningCluster, err := w.Clusters.CreateAndWait(ctx, compute.CreateCluster{
    ClusterName:            clusterName,
    SparkVersion:           latestLTS,
    NodeTypeId:             smallestWithLocalDisk,
    AutoterminationMinutes: autoTerminationMinutes,
    NumWorkers:             numWorkers,
  })

  if err != nil {
    panic(err)
  }

  switch runningCluster.State {
  case compute.StateRunning:
    fmt.Printf("The cluster is now ready at %s#setting/clusters/%s/configuration\n",
      w.Config.Host,
      runningCluster.ClusterId,
    )
  default:
    fmt.Printf("Cluster is not running or failed to create. %s", runningCluster.StateMessage)
  }

  // Output:
  //
  // Now attempting to create the cluster, please wait...
  // The cluster is now ready at <workspace-host>#setting/clusters/<cluster-id>/configuration
}

Excluir permanentemente um clusters

Este exemplo de código exclui permanentemente os clusters com o ID clusters especificado do workspace.

package main

import (
  "context"

  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/service/clusters"
)

func main() {
  // Replace with your cluster's ID.
  const clusterId = "1234-567890-ab123cd4"

  w   := databricks.Must(databricks.NewWorkspaceClient())
  ctx := context.Background()

  err := w.Clusters.PermanentDelete(ctx, compute.PermanentDeleteCluster{
    ClusterId: clusterId,
  })

  if err != nil {
    panic(err)
  }
}

execução de um Job

Este exemplo de código cria um Job do Databricks que executa o Notebook especificado nos clusters especificados. Como a execução do código, ele obtém o caminho do Notebookexistente, o ID clusters existentes e as configurações Job relacionadas do usuário no terminal. A chamada do método RunNowAndWait faz com que o código seja pausado até que o novo Job termine de ser executado no workspace.

package main

import (
  "bufio"
  "context"
  "fmt"
  "os"
  "strings"

  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/service/jobs"
)

func main() {
  w   := databricks.Must(databricks.NewWorkspaceClient())
  ctx := context.Background()

  nt := jobs.NotebookTask{
    NotebookPath: askFor("Workspace path of the notebook to run:"),
  }

  jobToRun, err := w.Jobs.Create(ctx, jobs.CreateJob{
    Name: askFor("Some short name for the job:"),
    Tasks: []jobs.JobTaskSettings{
      {
        Description:       askFor("Some short description for the job:"),
        TaskKey:           askFor("Some key to apply to the job's tasks:"),
        ExistingClusterId: askFor("ID of the existing cluster in the workspace to run the job on:"),
        NotebookTask:      &nt,
      },
    },
  })

  if err != nil {
    panic(err)
  }

  fmt.Printf("Now attempting to run the job at %s/#job/%d, please wait...\n",
    w.Config.Host,
    jobToRun.JobId,
  )

  runningJob, err := w.Jobs.RunNow(ctx, jobs.RunNow{
    JobId: jobToRun.JobId,
  })

  if err != nil {
    panic(err)
  }

  jobRun, err := runningJob.Get()

  if err != nil {
    panic(err)
  }

  fmt.Printf("View the job run results at %s/#job/%d/run/%d\n",
    w.Config.Host,
    jobRun.JobId,
    jobRun.RunId,
  )

  // Output:
  //
  // Now attempting to run the job at <workspace-host>/#job/<job-id>, please wait...
  // View the job run results at <workspace-host>/#job/<job-id>/run/<run-id>
}

// Get job settings from the user.
func askFor(prompt string) string {
  var s string
  r := bufio.NewReader(os.Stdin)
  for {
    fmt.Fprint(os.Stdout, prompt+" ")
    s, _ = r.ReadString('\n')
    if s != "" {
      break
    }
  }
  return strings.TrimSpace(s)
}

Gerenciar arquivos em Unity Catalog volumes

Este exemplo de código demonstra várias chamadas para a funcionalidade files dentro de WorkspaceClient para acessar um volume do Unity Catalog.

package main

import (
  "context"
  "io"
  "os"

  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/service/files"
)

func main() {
  w := databricks.Must(databricks.NewWorkspaceClient())

  catalog          := "main"
  schema           := "default"
  volume           := "my-volume"
  volumePath       := "/Volumes/" + catalog + "/" + schema + "/" + volume // /Volumes/main/default/my-volume
  volumeFolder     := "my-folder"
  volumeFolderPath := volumePath + "/" + volumeFolder // /Volumes/main/default/my-volume/my-folder
  volumeFile       := "data.csv"
  volumeFilePath   := volumeFolderPath + "/" + volumeFile // /Volumes/main/default/my-volume/my-folder/data.csv
  uploadFilePath   := "./data.csv"

  // Create an empty folder in a volume.
  err := w.Files.CreateDirectory(
    context.Background(),
    files.CreateDirectoryRequest{DirectoryPath: volumeFolderPath},
  )
  if err != nil {
    panic(err)
  }

  // Upload a file to a volume.
  fileUpload, err := os.Open(uploadFilePath)
  if err != nil {
    panic(err)
  }
  defer fileUpload.Close()

  w.Files.Upload(
    context.Background(),
    files.UploadRequest{
      Contents:  fileUpload,
      FilePath:  volumeFilePath,
      Overwrite: true,
    },
  )

  // List the contents of a volume.
  items := w.Files.ListDirectoryContents(
    context.Background(),
    files.ListDirectoryContentsRequest{DirectoryPath: volumePath},
  )

  for {
    if items.HasNext(context.Background()) {
      item, err := items.Next(context.Background())
      if err != nil {
        break
      }
      println(item.Path)

    } else {
      break
    }
  }

  // List the contents of a folder in a volume.
  itemsFolder := w.Files.ListDirectoryContents(
    context.Background(),
    files.ListDirectoryContentsRequest{DirectoryPath: volumeFolderPath},
  )

  for {
    if itemsFolder.HasNext(context.Background()) {
      item, err := itemsFolder.Next(context.Background())
      if err != nil {
        break
      }
      println(item.Path)
    } else {
      break
    }
  }

  // Print the contents of a file in a volume.
  file, err := w.Files.DownloadByFilePath(
    context.Background(),
    volumeFilePath,
  )
  if err != nil {
    panic(err)
  }

  bufDownload := make([]byte, file.ContentLength)

  for {
    file, err := file.Contents.Read(bufDownload)
    if err != nil && err != io.EOF {
      panic(err)
    }
    if file == 0 {
      break
    }

    println(string(bufDownload[:file]))
  }

  // Delete a file from a volume.
  w.Files.DeleteByFilePath(
    context.Background(),
    volumeFilePath,
  )

  // Delete a folder from a volume.
  w.Files.DeleteDirectory(
    context.Background(),
    files.DeleteDirectoryRequest{
      DirectoryPath: volumeFolderPath,
    },
  )
}

Listar usuários da conta

Este exemplo de código lista os usuários disponíveis em uma account do Databricks.

package main

import (
  "context"

  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/service/iam"
)

func main() {
  a := databricks.Must(databricks.NewAccountClient())
  all, err := a.Users.ListAll(context.Background(), iam.ListAccountUsersRequest{})
  if err != nil {
    panic(err)
  }
  for _, u := range all {
    println(u.UserName)
  }
}

Recursos adicionais

Para mais informações, consulte:

SDK do Databricks para Go README
Referência da APIdo SDK do Databricks para Go
Exemplos de código adicionais
Registros
Testes
Operações de longa duração
Respostas paginadas