Kit SDK Databricks pour Go

Article
08/20/2024

Dans cet article, vous allez apprendre à automatiser les opérations dans les comptes Azure Databricks, les espaces de travail et les ressources associées avec le kit de développement logiciel (SDK) Databricks pour Go. Cet article complète le Kit de développement logiciel (SDK) Databricks pour Go README, référence d’APIet exemples.

Remarque

Cette fonctionnalité est en version bêta et peut être utilisée en production.

Pendant la période bêta, Databricks vous recommande d’épingler une dépendance à la version mineure spécifique du Kit de développement logiciel (SDK) Databricks pour Go dont dépend votre code, par exemple dans le fichier d’un projet go.mod. Pour plus d’informations sur l’épinglage des dépendances, consultez Gestion des dépendances.

Avant de commencer

Avant de commencer à utiliser le kit SDK Databricks pour Go, assurez-vous que votre ordinateur de développement dispose des éléments suivants :

Go installé
L’authentification Azure Databricks configurée

Prise en main du kit SDK Databricks pour Go

Sur votre ordinateur de développement (sur lequel vous avez déjà installé Go, créé un projet de code Go et configuré l’authentification Azure Databricks), créez un fichier go.mod pour suivre les dépendances de votre code Go en exécutant la commande go mod init. Voici un exemple :
```
go mod init sample
```
Prenez une dépendance sur le kit SDK Databricks pour Go en exécutant la commande go mod edit -require, en remplaçant 0.8.0 par la dernière version du kit SDK Databricks pour Go, comme indiqué dans le journal des modifications :
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
Votre fichier go.mod doit maintenant ressembler à ceci :
```
module sample

go 1.18

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

Dans votre projet, créez un fichier de code Go qui importe le kit SDK Databricks pour Go. L’exemple suivant, qui se trouve dans un fichier nommé main.go avec le contenu suivant, dresse la liste de tous les clusters de l’espace de travail 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)
  }
}

Ajoutez les dépendances de module manquantes en exécutant la commande go mod tidy :
```
go mod tidy
```
Notes

Si vous obtenez l’erreur go: warning: "all" matched no packages, cela signifie que vous avez oublié d’ajouter un fichier de code Go qui importe le kit SDK Databricks pour Go.
Récupérez des copies de tous les packages nécessaires pour prendre en charge les builds et les tests de packages dans votre module main, en exécutant la commande go mod vendor :
```
go mod vendor
```
Configurez votre ordinateur de développement pour l’authentification Azure Databricks.
Exécutez votre fichier de code Go, en exécutant la commande go run dans l’hypothèse d’un fichier nommé main.go :
```
go run main.go
```
Notes

Si vous ne définissez pas *databricks.Config comme argument dans l’appel précédent de w := databricks.Must(databricks.NewWorkspaceClient()), le kit SDK Databricks pour Go utilise son processus par défaut pour essayer d’effectuer l’authentification Azure Databricks. Pour remplacer ce comportement par défaut, consultez Authentification du kit SDK Databricks pour Go avec un compte ou un espace de travail Azure Databricks.

Mettre à jour le Kit de développement logiciel (SDK) Databricks pour Go

Pour mettre à jour votre projet Go afin d’utiliser l’un des packages du Kit de développement logiciel (SDK) Databricks pour Go, comme indiqué dans CHANGELOG, procédez comme suit :

Exécutez la commande go get à partir de la racine de votre projet, en spécifiant l’indicateur -u pour effectuer une mise à jour et en fournissant le nom et le numéro de version cible du package du Kit de développement logiciel (SDK) Databricks pour Go. Par exemple, pour mettre à jour vers la version 0.12.0, exécutez la commande suivante :
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Ajoutez les dépendances de module manquantes et celles qui sont obsolètes en exécutant la commande go mod tidy :
```
go mod tidy
```
Récupérez des copies de tous les packages mis à jour ou nouveaux nécessaires pour prendre en charge des builds et des tests de packages dans votre module main, en exécutant la commande go mod vendor :
```
go mod vendor
```

Authentification du kit SDK Databricks pour Go avec un compte ou un espace de travail Azure Databricks

Le kit SDK Databricks pour Go implémente la norme d’authentification unifiée du client Databricks, une approche architecturale et programmatique consolidée et cohérente pour l’authentification. Cette approche permet de rendre la configuration et l’automatisation de l’authentification avec Azure Databricks plus centralisées et prévisibles. Elle vous permet de configurer une fois l’authentification Databricks, puis d’utiliser cette configuration sur plusieurs outils Databricks et kits de développement logiciel sans modifier la configuration de l’authentification. Pour plus d’informations, notamment des exemples de code plus complets dans Go, consultez Authentification unifiée du client Databricks.

Voici quelques-uns des modèles de codage disponibles pour initialiser l’authentification Databricks avec le kit SDK Databricks pour Go :

Utilisez l’authentification par défaut de Databricks en effectuant l’une des opérations suivantes :
- Créez ou identifiez un profil de configuration Databricks personnalisé avec les champs requis pour le type d’authentification Databricks cible. Ensuite, définissez la variable d’environnement DATABRICKS_CONFIG_PROFILE sur le nom du profil de configuration personnalisé.
- Définissez les variables d’environnement requises pour le type d’authentification Databricks cible.
Instanciez ensuite un objet WorkspaceClient avec l’authentification par défaut Databricks comme suit :
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
Le codage des champs requis effectué de manière irréversible est pris en charge, mais non recommandé, car il risque d’exposer des informations sensibles dans votre code, telles que les jetons d’accès personnels Azure Databricks. L’exemple suivant montre le codage de l’hôte Azure Databricks et des valeurs de jeton d’accès effectué de manière irréversible pour l’authentification par jeton 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: "...",
}))
```

Consultez également l’authentification dans le Kit de développement logiciel (SDK) Databricks pour Go README.

Exemples

Les exemples de code suivants montrent comment utiliser le kit SDK Databricks pour Go afin de créer et supprimer des clusters, exécuter des travaux et répertorier les utilisateurs de comptes. Ces exemples de code portent sur le processus d’authentification Azure Databricks par défaut du kit SDK Databricks pour Go.

Pour obtenir d’autres exemples de code, consultez le dossier Exemples du référentiel du kit SDK Databricks pour Go sur GitHub.

Créer un cluster
Supprimer définitivement un cluster
Exécuter une tâche
Gérer les fichiers dans les volumes de catalogue Unity
Répertorier les utilisateurs du compte

Créer un cluster

Cet exemple de code crée un cluster en utilisant la dernière version LTS (Long-Term Support) disponible de Databricks Runtime et le plus petit type de nœud de cluster possible avec un disque local. Ce cluster possède un Worker et s’arrête automatiquement après 15 minutes de temps d’inactivité. L’appel de méthode CreateAndWait entraîne la suspension du code jusqu’à ce que le nouveau cluster s’exécute dans l’espace de travail.

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
}

Supprimer définitivement un cluster

Cet exemple de code supprime définitivement de l’espace de travail le cluster possédant l’ID spécifié.

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

Exécuter une tâche

Cet exemple de code crée une tâche Azure Databricks qui exécute le notebook spécifié sur le cluster spécifié. Il récupère le chemin du notebook existant, l’ID de cluster existant et les paramètres de travail associés auprès de l’utilisateur sur le terminal. L’appel de méthode RunNowAndWait entraîne la suspension du code jusqu’à ce que le nouveau travail ait fini de s’exécuter dans l’espace de travail.

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

Gérer les fichiers dans les volumes de catalogue Unity

Cet exemple de code illustre différents appels aux files fonctionnalités au sein WorkspaceClient pour accéder à un volume de catalogue Unity.

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

Répertorier les utilisateurs de compte

Cet exemple de code répertorie les utilisateurs disponibles dans un compte 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)
  }
}

Ressources supplémentaires

Pour plus d'informations, consultez les pages suivantes :

Kit de développement logiciel (SDK) Databricks pour Go README
Kit de développement logiciel (SDK) Databricks pour Go API reference
Exemples de code supplémentaires
Logging
Test
Opérations de longue durée
Réponses paginées

Partager via

Kit SDK Databricks pour Go

Avant de commencer

Prise en main du kit SDK Databricks pour Go

Mettre à jour le Kit de développement logiciel (SDK) Databricks pour Go

Authentification du kit SDK Databricks pour Go avec un compte ou un espace de travail Azure Databricks

Exemples

Créer un cluster

Supprimer définitivement un cluster

Exécuter une tâche

Gérer les fichiers dans les volumes de catalogue Unity

Répertorier les utilisateurs de compte

Ressources supplémentaires

Commentaires

Ressources supplémentaires