Databricks SDK 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.

nota

Esse recurso está na versão beta e não pode ser usado na produção.

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

Antes de começar

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

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

Comece a usar o site 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 seu código Go executando o comando go mod init, por exemplo:
Bash
```
go mod init sample
```
Dependa 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:
Bash
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
Seu arquivo go.mod agora deve ter a seguinte aparência:
Go
```
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 site Databricks workspace:

Go
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 as dependências de módulo ausentes executando o comando go mod tidy:
Bash
```
go mod tidy
```

nota

Se receber o erro go: warning: "all" matched no packages, o senhor esqueceu de adicionar um arquivo de código Go que importa o Databricks SDK for Go.

Obtenha cópias de todo o pacote necessário para dar suporte a compilações e testes do pacote em seu módulo main, executando o comando go mod vendor:
Bash
```
go mod vendor
```
Configure sua máquina de desenvolvimento para a autenticação do Databricks.
Execute seu arquivo de código Go, supondo que seja um arquivo chamado main.go, executando o comando go run:
Bash
```
go run main.go
```

nota

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

Atualizar o SDK da Databricks para Go

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

Execute o comando go get a partir 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:
Bash
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Adicione e atualize as dependências de módulo ausentes e desatualizadas executando o comando go mod tidy:
Go
```
go mod tidy
```
Obtenha cópias de todos os pacotes novos e atualizados necessários para dar suporte a compilações e testes do pacote em seu módulo main, executando o comando go mod vendor:
Go
```
go mod vendor
```

Autentique o Databricks SDK for Go com seu Databricks account ou workspace

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 a 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 da Databricks com o SDK da Databricks para Go incluem:

Use a autenticação padrão do Databricks seguindo um destes procedimentos:
- Crie ou identifique um perfil de configuração personalizado do Databricks com os campos necessários para o tipo de autenticação de destino do Databricks. Em seguida, defina a variável de ambiente DATABRICKS_CONFIG_PROFILE com o nome do perfil de configuração personalizado.
- Defina as variáveis de ambiente necessárias para o tipo de autenticação do Databricks de destino.
Em seguida, instancie, por exemplo, um objeto WorkspaceClient com autenticação default do Databricks da seguinte maneira:
Go
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
Embora seja possível codificar diretamente os campos necessários, não é aconselhável, pois isso pode expor informações confidenciais em seu código, como access tokens pessoais do Databricks. O exemplo a seguir codifica o host do Databricks e valores de access token para autenticação de token do Databricks:
Go
```
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 Authentication (Autenticação ) no LEIAME do Databricks SDK for Go.

Exemplos

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

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

Criar um cluster
Excluir permanentemente um cluster
execução de um trabalho
Gerenciar arquivos em volumes do Unity Catalog
Lista de usuários account

Criar um clustering

Este exemplo de código cria um clustering com a versão mais recente disponível do Databricks Runtime Long Term Support (LTS) e o menor tipo de nó de clustering disponível com um disco local. Esse clustering tem um worker, e o clustering será encerrado automaticamente após 15 minutos de tempo parado. A chamada do método CreateAndWait faz com que o código entre em pausa até que o novo clustering esteja em execução no site workspace.

Go
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 clustering

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

Go
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 trabalho

Este exemplo de código cria um trabalho Databricks que executa o Notebook especificado no clustering especificado. À medida que o código é executado, ele obtém o caminho do Notebook existente, o ID de clustering existente e as configurações de trabalho relacionadas do usuário no terminal. A chamada do método RunNowAndWait faz com que o código entre em pausa até que o novo Job termine de ser executado no site workspace.

Go
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 em WorkspaceClient para acessar um volume do Unity Catalog.

Go
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,
    },
  )
}

Lista de usuários account

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

Go
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)
  }
}

Recurso adicional

Para saber mais, consulte:

LEIAME doDatabricks SDK para Go
Referência da APIdo Databricks SDK for Go
Outros exemplos de código
Registros
Testes
Operações de longa duração
Respostas paginadas

Antes de começar​

Comece a usar o site Databricks SDK for Go​

Atualizar o SDK da Databricks para Go​

Autentique o Databricks SDK for Go com seu Databricks account ou workspace​

Exemplos​

Criar um clustering​

Excluir permanentemente um clustering​

execução de um trabalho​

Gerenciar arquivos em Unity Catalog volumes​

Lista de usuários account​

Recurso adicional​

Antes de começar

Comece a usar o site Databricks SDK for Go

Atualizar o SDK da Databricks para Go

Autentique o Databricks SDK for Go com seu Databricks account ou workspace

Exemplos

Criar um clustering

Excluir permanentemente um clustering

execução de um trabalho

Gerenciar arquivos em Unity Catalog volumes

Lista de usuários account

Recurso adicional