SDK de Databricks para Go

Artículo
10/10/2024

En este artículo, aprenderá a automatizar las operaciones de Azure Databricks y a acelerar el desarrollo con el SDK de Databricks para Go. Este artículo sirve de complemento al archivo LÉAME, la referencia de API y los ejemplos del SDK de Databricks para Go.

Nota:

Esta característica está en fase beta y es posible usarla en producción.

Durante el período beta, Databricks recomienda anclar una dependencia de la versión secundaria específica del SDK de Databricks para Go de la que depende el código, por ejemplo, en un archivo de go.mod del proyecto. Para obtener más información sobre cómo anclar las dependencias, consulte Administración de dependencias.

Antes de empezar

Antes de empezar a usar el SDK de Databricks para Go, la máquina de desarrollo debe cumplir con lo siguiente:

Debe tener instalado Go.
Debe tener configurada la autenticación de Azure Databricks.

Introducción al SDK de Databricks para Go

En una máquina de desarrollo con Go ya instalado, un proyecto de código de Go existente ya creado y la autenticación de Azure Databricks ya configurada, cree un archivo go.mod para hacer seguimiento de las dependencias del código de Go mediante la ejecución del comando go mod init; por ejemplo:
```
go mod init sample
```
Para tomar una dependencia del paquete del SDK de Databricks para Go, ejecute el comando go mod edit -require y reemplace 0.8.0 por la versión más reciente del paquete del SDK de Databricks para Go, que se muestra en CHANGELOG:
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
Ahora, el aspecto del archivo go.mod será parecido a este:
```
module sample

go 1.18

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

En el proyecto, cree un archivo de código de Go que importe el SDK de Databricks para Go. En el ejemplo siguiente, en un archivo denominado main.go con el contenido siguiente, se enumeran todos los clústeres del área de trabajo de Azure 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)
  }
}

Ejecute el comando go mod tidy para agregar cualquier dependencia de módulo faltante:
```
go mod tidy
```
Nota:

Si recibe el error go: warning: "all" matched no packages, se debe a que se le olvidó agregar un archivo de código de Go que importa el SDK de Databricks para Go.
Ejecute el comando main para obtener copias de todos los paquetes que se necesitan para admitir compilaciones y pruebas de paquetes en el módulo go mod vendor:
```
go mod vendor
```
Configure la máquina de desarrollo para la autenticación de Azure Databricks.
Ejecute el comando main.go para ejecutar el archivo de código de Go (suponiendo que un archivo se denomina go run):
```
go run main.go
```
Nota:

Si no se establece *databricks.Config como argumento en la llamada anterior a w := databricks.Must(databricks.NewWorkspaceClient()), el SDK de Databricks para Go usa su proceso predeterminado para intentar la autenticación de Azure Databricks. Si desea invalidar este compartimiento predeterminado, consulte Autenticación del SDK de Databricks para Go con su cuenta o área de trabajo de Azure Databricks.

Actualizar el SDK de Databricks para Go

Para actualizar el proyecto de Go para usar uno de los paquetes del SDK de Databricks para Go, como se muestra en CHANGELOG, haga lo siguiente:

Ejecute el comando go get desde la raíz del proyecto, especificando la marca -u para realizar una actualización y proporcionando el nombre y el número de versión de destino del paquete del SDK de Databricks para Go. Por ejemplo, para actualizar a la versión 0.12.0, ejecute el siguiente comando:
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Añada y actualice las dependencias de módulos que falten o que no estén actualizadas ejecutando el comando go mod tidy:
```
go mod tidy
```
Ejecute el comando main para obtener copias de todos los paquetes nuevos y actualizados que se necesitan para admitir compilaciones y pruebas de paquetes en el módulo go mod vendor:
```
go mod vendor
```

Autenticación del SDK de Databricks para Go con su cuenta o área de trabajo de Azure Databricks

El SDK de Databricks para Go implementa el estándar de autenticación unificada del cliente de Databricks, un enfoque arquitectónico y programático consolidado y coherente para la autenticación. Este enfoque ayuda a configurar y automatizar la autenticación con Azure Databricks de manera más centralizada y predecible. Permite configurar la autenticación de Databricks una vez y, a continuación, usar esa configuración en varias herramientas y SDK de Databricks sin cambios adicionales en la configuración de autenticación. Para obtener más información, incluidos ejemplos de código más completos en Go, consulte Autenticación unificada del cliente de Databricks.

Entre los patrones de codificación disponibles para inicializar la autenticación de Databricks con el SDK de Databricks para Go se incluyen los siguientes:

Para usar la autenticación predeterminada de Databricks, siga uno de estos procedimientos:
- Cree o identifique un perfil de configuración de Databricks personalizado con los campos necesarios para el tipo de autenticación de Databricks de destino. Luego establezca la variable de entorno DATABRICKS_CONFIG_PROFILE con el nombre del perfil de configuración personalizado.
- Establezca las variables de entorno necesarias para el tipo de autenticación de Databricks de destino.
A continuación, cree una instancia de un objeto WorkspaceClient, por ejemplo, con la autenticación predeterminada de Databricks como se indica a continuación:
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
Aunque se admite la codificación rígida de los campos obligatorios, no se recomienda porque se corre el riesgo de exponer información confidencial en el código, como los tokens de acceso personal de Azure Databricks. En el ejemplo siguiente se integran como parte del código los valores de host y token de acceso de Azure Databricks para la autenticación de tokens de 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 también Autenticación en el archivo LÉAME del SDK de Databricks para Go.

Ejemplos

En los ejemplos de código siguientes se muestra cómo usar el SDK de Databricks para Go para crear y eliminar clústeres, ejecutar trabajos y enumerar los usuarios de la cuenta. Estos ejemplos de código utilizan el proceso de autenticación predeterminado de Azure Databricks del SDK de Databricks para Go.

Para más ejemplos de código, consulte la carpeta de ejemplos del repositorio del SDK de Databricks para Go en GitHub.

Crear un clúster
Eliminación permanente de un clúster
Ejecución de un trabajo
Administración de archivos en volúmenes del Unity Catalog
Enumerar los usuarios de la cuenta

Crear un clúster

En este ejemplo de código, se crea un clúster con la versión de soporte técnico a largo plazo (LTS) de Databricks Runtime más reciente y el tipo de nodo de clúster más pequeño disponible con un disco local. Este clúster tiene un trabajo y el clúster se finalizará automáticamente después un tiempo de inactividad de 15 minutos. La llamada de método CreateAndWait pausa el código hasta que el clúster nuevo se ejecute en el área de trabajo.

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
}

Eliminación permanente de un usuario

En este ejemplo de código, se elimina permanentemente el clúster con el identificador de clúster especificado del área de trabajo.

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

Ejecución de un trabajo

En este ejemplo de código, se crea un trabajo de Azure Databricks que ejecuta el cuaderno especificado en el clúster especificado. A medida que se ejecuta el código, obtiene la ruta de acceso del cuaderno existente, el identificador de clúster existente y la configuración del trabajo relacionado del usuario en el terminal. La llamada de método RunNowAndWait pausa el código hasta que el trabajo nuevo se termine de ejecutar en el área de trabajo.

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

Administración de archivos en volúmenes del Unity Catalog

En este ejemplo de código se muestran varias llamadas a files funcionalidad dentro de WorkspaceClient para acceder a un volumen de 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,
    },
  )
}

Enumerar los usuarios de la cuenta

Con el siguiente ejemplo de código se enumeran los usuarios disponibles en una cuenta de Azure 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 adicionales

Para más información, consulte:

Archivo LÉAME del SDK de Databricks para Go
Referencia de API del SDK de Databricks para Go
Ejemplos de código adicionales
Registro
Pruebas:
Operaciones de larga duración
Respuestas paginadas

Compartir a través de

SDK de Databricks para Go

Antes de empezar

Introducción al SDK de Databricks para Go

Actualizar el SDK de Databricks para Go

Autenticación del SDK de Databricks para Go con su cuenta o área de trabajo de Azure Databricks

Ejemplos

Crear un clúster

Eliminación permanente de un usuario

Ejecución de un trabajo

Administración de archivos en volúmenes del Unity Catalog

Enumerar los usuarios de la cuenta

Recursos adicionales

Comentarios

Recursos adicionales