Kit SDK Databricks pour Go

Dans cet article, vous allez apprendre à automatiser les opérations Azure Databricks et à accélérer le développement 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 go.mod projet. 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 avec Go déjà installé, un projet de code Go existant déjà créé et l’authentification Azure Databricks configurée, créez un go.mod fichier pour suivre les dépendances de votre code Go en exécutant la go mod init commande, par 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
```
Remarque

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 main.go dans l’hypothèse d’un fichier nommé go run :
```
go run main.go
```
Remarque

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 SDK Databricks pour Go implémente la norme d’authentification unifiée Databricks, une approche architecturale, programmatique et cohérente de 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 l’authentification unifiée 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 utilisent le sdk Databricks pour le processus d’authentification Azure Databricks par défaut de 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é. Lorsque le code s’exécute, il obtient le chemin d’accès du notebook existant, l’ID de cluster existant et les paramètres de travail associés de l’utilisateur au niveau du 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)
  }
}

Résolution des problèmes

Cette section décrit les solutions aux problèmes courants liés au Kit de développement logiciel (SDK) Databricks pour Go.

Pour signaler des problèmes ou tout autre commentaire, créez un problème GitHub pour le Kit de développement logiciel (SDK) Databricks pour Go.

Erreur : Impossible d’analyser la réponse

Si vous recevez l’erreur suivante lors de la tentative d’utilisation du Kit de développement logiciel (SDK) Databricks pour Go, il indique presque toujours un problème avec votre configuration d’authentification.

Error: unable to parse response. This is likely a bug in the Databricks SDK for Go or the underlying REST API.

Si vous rencontrez cette erreur, vérifiez ce qui suit :

Vérifiez que votre hôte Databricks est correctement défini.
Vérifiez que la méthode d’authentification dispose des autorisations requises pour l’opération d’API que vous essayez d’effectuer.
Si vous êtes derrière un pare-feu d’entreprise, veillez à ne pas bloquer ou rediriger le trafic d’API.

Une cause courante de cette erreur est le lien privé qui redirige le Kit de développement logiciel (SDK) vers une page de connexion, que le SDK ne peut pas traiter. Cela se produit généralement lors de la tentative d’accès à un espace de travail avec liaison privée configuré sans accès Internet public à partir d’un réseau différent de celui auquel appartient le point de terminaison DU VPC.

Pour plus d’informations, consultez :

Authentification unifiée Databricks

Configurez la connectivité privée de back-end pour Azure Databricks.

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
Journalisation
Test
Opérations de longue durée
Réponses paginées

Rétroaction

Cette page a-t-elle été utile ?

Last updated on 2025-10-05