Databricks SDK für Go

In diesem Artikel erfahren Sie, wie Sie Vorgänge in Azure Databricks-Konten, -Arbeitsbereichen und zugehörigen Ressourcen mit dem Databricks SDK für Go automatisieren können. Dieser Artikel ergänzt das Databricks SDK für Go README, API-Referenzund Beispiele.

Hinweis

Dieses Feature befindet sich in der Betaphase und kann in der Produktion verwendet werden.

Während des Betazeitraums empfiehlt Databricks, dass Sie eine Abhängigkeit von der spezifischen Nebenversion des Databricks SDK für Go anheften, von der Ihr Code abhängt, zum Beispiel in der go.mod Datei eines Projekts. Weitere Informationen zum Anheften von Abhängigkeiten finden Sie unter Verwalten von Abhängigkeiten.

Voraussetzungen

Zur Verwendung des Databricks SDK für Go muss Ihr Entwicklungscomputer die folgenden Voraussetzungen erfüllen:

• Go ist installiert.
• Die Azure Databricks-Authentifizierung ist konfiguriert.

Erste Schritte mit dem Databricks SDK für Go

1. Erstellen Sie auf Ihrem Entwicklungscomputer, auf dem bereits Go installiert, ein Go-Codeprojekt erstellt und die Azure Databricks-Authentifizierung konfiguriert wurde, eine go.mod-Datei, um die Abhängigkeiten Ihres Go-Codes nachzuverfolgen. Führen Sie dazu den Befehl go mod init aus:

   go mod init sample
   

2. Erstellen Sie eine Abhängigkeit auf dem Databricks-SDK für Go-Paket, indem Sie den Befehl go mod edit -require ausführen und 0.8.0 durch die neueste Version des Databricks SDK für Go-Pakets ersetzen, wie im CHANGELOG aufgeführt:

   go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
   

   Die Datei go.mod sollte jetzt wie folgt aussehen:

   module sample
   
   go 1.18
   
   require github.com/databricks/databricks-sdk-go v0.8.0
   

3. Erstellen Sie in Ihrem Projekt eine Go-Codedatei, die das Databricks SDK für Go importiert. Im folgenden Beispiel werden in der Datei mit Namen main.go mit folgendem Inhalt alle Cluster in Ihrem Azure Databricks-Arbeitsbereich aufgelistet:

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

4. Fügen Sie alle fehlenden Modulabhängigkeiten hinzu, indem Sie den Befehl go mod tidy ausführen:

   go mod tidy
   

   Hinweis

   Wenn Sie den Fehler go: warning: "all" matched no packages erhalten, haben Sie vergessen, eine Go-Codedatei hinzuzufügen, die das Databricks SDK für Go importiert.

5. Rufen Sie Kopien aller Pakete ab, die zur Unterstützung von Builds und Tests der Pakete in Ihrem main-Modul benötigt werden, indem Sie den Befehl go mod vendor ausführen:

   go mod vendor
   

6. Richten Sie Ihren Entwicklungscomputer für die Azure Databricks-Authentifizierung ein.

7. Führen Sie Ihre Go-Codedatei aus, wobei Sie von einer Datei namens main.go ausgehen, indem Sie den Befehl go run ausführen:

   go run main.go
   

   Hinweis

   Wenn Sie *databricks.Config nicht als Argument im obigen w := databricks.Must(databricks.NewWorkspaceClient())-Aufruf angeben, verwendet das Databricks SDK für Go den Standardprozess zur Durchführung der Azure Databricks-Authentifizierung. Informationen zum Außerkraftsetzen dieses Standardverhaltens finden Sie unter Authentifizieren des Databricks SDK für Go bei Ihrem Azure Databricks-Konto oder -Arbeitsbereich.

Aktualisieren des Databricks SDK für Go

Gehen Sie wie folgt vor, um Ihr Go-Projekt so zu aktualisieren, dass es eines der im CHANGELOG aufgeführten Databricks SDK für Go-Pakete verwendet:

1. Führen Sie den Befehl go get im Stammverzeichnis Ihres Projekts aus. Geben Sie dabei das -u-Flag an, um eine Aktualisieren durchzuführen, sowie den Namen und die Zielversionsnummer des Databricks SDK für Go-Pakets. Führen Sie beispielsweise den folgenden Befehl aus, um eine Aktualisierung auf die Version 0.12.0 durchzuführen:

   go get -u github.com/databricks/databricks-sdk-go@v0.12.0
   

2. Fügen Sie alle fehlenden und veralteten Modulabhängigkeiten hinzu und aktualisieren Sie sie, indem Sie den Befehl go mod tidy ausführen:

   go mod tidy
   

3. Rufen Sie Kopien aller neuen und aktualisierten Pakete ab, die zur Unterstützung von Builds und Tests der Pakete in Ihrem main-Modul benötigt werden, indem Sie den Befehl go mod vendor ausführen:

   go mod vendor
   

Authentifizieren des Databricks SDK für Go bei Ihrem Azure Databricks-Konto oder -Arbeitsbereich

Das Databricks-SDK für Go implementiert den Standard für die einheitliche Databricks-Clientauthentifizierung, einen konsolidierten und konsistenten architektonischen und programmgesteuerten Ansatz für die Authentifizierung. Dieser Ansatz trägt dazu bei, die Einrichtung und Automatisierung der Authentifizierung mit Azure Databricks zentralisierter und vorhersagbarer zu gestalten. Er ermöglicht Ihnen, die Databricks-Authentifizierung einmal zu konfigurieren und diese Konfiguration dann für mehrere Databricks-Tools und -SDKs ohne weitere Änderungen an der Authentifizierungskonfiguration zu verwenden. Weitere Informationen, einschließlich umfassenderer Codebeispiele in Go, finden Sie unter Einheitliche Databricks-Clientauthentifizierung.

Einige der verfügbaren Codierungsmuster zur Initialisierung der Databricks-Authentifizierung mit dem Databricks-SDK für Go umfassen:

• Verwenden Sie die Databricks-Standardauthentifizierung, indem Sie eine der folgenden Aktionen ausführen:

  • Erstellen oder identifizieren Sie ein benutzerdefiniertes Databricks-Konfigurationsprofil mit den erforderlichen Feldern für den Databricks-Zielauthentifizierungstyp. Legen Sie dann die DATABRICKS_CONFIG_PROFILE-Umgebungsvariable auf den Namen des benutzerdefinierten Konfigurationsprofils fest.
  • Legen Sie die erforderlichen Umgebungsvariablen für den Databricks-Zielauthentifizierungstyp fest.

  Instanziieren Sie dann z. B. ein WorkspaceClient-Objekt mit Databricks-Standardauthentifizierung wie folgt:

  import (
    "github.com/databricks/databricks-sdk-go"
  )
  // ...
  w := databricks.Must(databricks.NewWorkspaceClient())
  

• Das harte Codieren der erforderlichen Felder wird unterstützt, aber nicht empfohlen, da dadurch vertrauliche Informationen in Ihrem Code verfügbar gemacht werden könnten, z. B. persönliche Azure Databricks-Zugriffstoken. Im folgenden Beispiel werden Azure Databricks-Host- und Zugriffstokenwerte für die Databricks-Tokenauthentifizierung hart codiert:

  import (
    "github.com/databricks/databricks-sdk-go"
    "github.com/databricks/databricks-sdk-go/config"
  )
  // ...
  w := databricks.Must(databricks.NewWorkspaceClient(&databricks.Config{
    Host:  "https://...",
    Token: "...",
  }))
  

Siehe auch Authentifizierung im Databricks SDK für Go README.

Beispiele

Die folgenden Codebeispiele veranschaulichen die Verwendung des Databricks-SDK für Go zum Erstellen und Löschen von Clustern, Ausführen von Aufträgen und Auflisten von Kontobenutzern. In diesen Codebeispielen wird der standardmäßige Azure Databricks-Authentifizierungsprozess des Databricks SDK für Go verwendet.

Weitere Beispiele finden Sie im Ordner examples im Databricks SDK für Go-Repository auf GitHub.

• Erstellen eines Clusters
• Dauerhaftes Löschen eines Clusters
• Ausführen eines Auftrags
• Verwalten von Dateien in Unity Catalog-Volumes
• Auflisten der Kontobenutzer

Erstellen eines Clusters

In diesem Codebeispiel wird ein Cluster mit der neuesten verfügbaren Databricks Runtime LTS-Version (Long Term Support) und dem kleinsten verfügbaren Clusterknotentyp mit einem lokalen Datenträger erstellt. Dieser Cluster umfasst einen Worker, und der Cluster wird nach 15 Minuten Leerlauf automatisch beendet. Der Aufruf der Methode CreateAndWait bewirkt, dass der Code angehalten wird, bis der neue Cluster im Arbeitsbereich ausgeführt wird.

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
}

Dauerhaftes Löschen eines Clusters

In diesem Codebeispiel wird der Cluster mit der angegebenen Cluster-ID dauerhaft aus dem Arbeitsbereich gelöscht.

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

Ausführen eines Auftrags

In diesem Codebeispiel wird ein Azure Databricks-Auftrag erstellt, der das angegebene Notebook im angegebenen Cluster ausführt. Bei Ausführung des Codes werden der Pfad des vorhandenen Notebooks, die ID des vorhandenen Clusters und die zugehörigen Auftragseinstellungen vom Benutzer am Terminal abgerufen. Der Aufruf der Methode RunNowAndWait bewirkt, dass der Code angehalten wird, bis die Ausführung des neuen Auftrags im Arbeitsbereich abgeschlossen ist.

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

Verwalten von Dateien in Unity Catalog-Volumes

In diesem Codebeispiel werden verschiedene Aufrufe von files-Funktionen innerhalb von WorkspaceClient den Zugriff auf ein Unity Catalog-Volume veranschaulicht.

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

Auflisten von Kontobenutzern

In diesem Codebeispiel werden die verfügbaren Benutzer in einem Azure Databricks-Konto aufgelistet.

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

Zusätzliche Ressourcen

Weitere Informationen finden Sie unter:

• Databricks SDK für Go README
• Databricks SDK für Go API-Referenz
• Zusätzliche Codebeispiele
• Logging
• Testen
• Vorgänge mit langer Ausführung
• Paginierte Antworten