Databricks SDK per Go

Articolo
08/20/2024

Questo articolo illustra come automatizzare le operazioni in account, aree di lavoro e risorse correlate di Azure Databricks con Databricks SDK per Go. Questo articolo integra Databricks SDK per Go README, informazioni di riferimento sulle API ed esempi.

Nota

Questa funzionalità è in versione beta e può essere usata nell'ambiente di produzione.

Durante il periodo beta, Databricks consiglia di aggiungere una dipendenza dalla versione secondaria specifica di Databricks SDK per Go da cui dipende il codice, ad esempio, nel file di go.mod un progetto. Per altre informazioni sull'aggiunta delle dipendenze, vedere Gestione delle dipendenze.

Operazioni preliminari

Prima di iniziare a usare Databricks SDK for Go, il computer di sviluppo deve avere:

Andare installato.
Autenticazione di Azure Databricks configurata.

Introduzione a Databricks SDK per Go

Nel computer di sviluppo con Go già installato, un progetto di codice Go esistente già creato e l'autenticazione di Azure Databricks configurata, creare un go.mod file per tenere traccia delle dipendenze del codice Go eseguendo il go mod init comando, ad esempio:
```
go mod init sample
```
Usare una dipendenza dal pacchetto Databricks SDK for Go eseguendo il go mod edit -require comando, sostituendo 0.8.0 con la versione più recente del pacchetto Databricks SDK for Go, come indicato in CHANGELOG:
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
Il file go.mod dovrà risultare simile al seguente:
```
module sample

go 1.18

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

All'interno del progetto creare un file di codice Go che importa Databricks SDK per Go. L'esempio seguente, in un file denominato main.go con il contenuto seguente, elenca tutti i cluster nell'area di lavoro di 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)
  }
}

Aggiungere eventuali dipendenze del modulo mancanti eseguendo il comando go mod tidy:
```
go mod tidy
```
Nota

Se viene visualizzato l'errore go: warning: "all" matched no packages, si è dimenticato di aggiungere un file di codice Go che importa Databricks SDK per Go.
Acquisire copie di tutti i pacchetti necessari per supportare compilazioni e test di pacchetti nel main modulo eseguendo il go mod vendor comando :
```
go mod vendor
```
Configurare il computer di sviluppo per l'autenticazione di Azure Databricks.
Eseguire il file di codice Go, presupponendo che un file denominato main.go, eseguendo il comando go run:
```
go run main.go
```
Nota

Non impostando *databricks.Config come argomento nella chiamata precedente a w := databricks.Must(databricks.NewWorkspaceClient()), Databricks SDK for Go usa il processo predefinito per tentare di eseguire l'autenticazione di Azure Databricks. Per eseguire l'override di questo comportamento predefinito, vedere Autenticare Databricks SDK per Go con l'account o l'area di lavoro di Azure Databricks.

Aggiornare Databricks SDK per Go

Per aggiornare il progetto Go per usare uno dei pacchetti Databricks SDK per Go, come indicato in CHANGELOG, eseguire le operazioni seguenti:

Eseguire il go get comando dalla radice del progetto, specificando il -u flag per eseguire un aggiornamento e specificando il nome e il numero di versione di destinazione del pacchetto Databricks SDK per Go. Ad esempio, per eseguire l'aggiornamento alla versione 0.12.0, eseguire il comando seguente:
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Aggiungere e aggiornare eventuali dipendenze del modulo mancanti e obsolete eseguendo il go mod tidy comando :
```
go mod tidy
```
Acquisire copie di tutti i pacchetti nuovi e aggiornati necessari per supportare compilazioni e test di pacchetti nel main modulo eseguendo il go mod vendor comando :
```
go mod vendor
```

Autenticare Databricks SDK for Go con l'account o l'area di lavoro di Azure Databricks

Databricks SDK per Go implementa lo standard di autenticazione unificata del client Databricks, un approccio architetturale e programmatico consolidato e coerente all'autenticazione. Questo approccio consente di configurare e automatizzare l'autenticazione con Azure Databricks più centralizzato e prevedibile. Consente di configurare l'autenticazione di Databricks una sola volta e quindi di usarla tra più strumenti e SDK di Databricks senza ulteriori modifiche alla configurazione dell'autenticazione. Per altre informazioni, inclusi esempi di codice più completi in Go, vedere Autenticazione unificata del client Databricks.

Alcuni dei modelli di codifica disponibili per inizializzare l'autenticazione di Databricks con Databricks SDK per Go includono:

Usare l'autenticazione predefinita di Databricks eseguendo una delle operazioni seguenti:
- Creare o identificare un profilo di configurazione di Databricks personalizzato con i campi obbligatori per il tipo di autenticazione databricks di destinazione. Impostare quindi la variabile di ambiente DATABRICKS_CONFIG_PROFILE sul nome del profilo di configurazione personalizzato.
- Impostare le variabili di ambiente necessarie per il tipo di autenticazione di Databricks di destinazione.
Creare quindi un'istanza di un oggetto WorkspaceClient con l'autenticazione predefinita di Databricks come indicato di seguito:
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
L’hardcoded dei campi obbligatori è supportato ma non consigliato, perché rischia di esporre informazioni riservate nel codice, ad esempio i token di accesso personale di Azure Databricks. L'esempio seguente imposta come hardcoded Azure Databricks host e valori dei token di accesso per l'autenticazione del token di 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: "...",
}))
```

Vedere anche Autenticazione in Databricks SDK per Go README.

Esempi

Gli esempi di codice seguenti illustrano come usare Databricks SDK per Go per creare ed eliminare cluster, eseguire processi ed elencare gli utenti degli account. Questi esempi di codice usano databricks SDK per il processo di autenticazione predefinito di Azure Databricks di Go.

Per altri esempi di codice, vedere la cartella examples nel repository Databricks SDK for Go in GitHub.

Creare un cluster
Eliminare in modo definitivo un cluster
Eseguire un processo
Gestisce i file nei volumi nel catalogo Unity
Elencare gli utenti dell'account

Creare un cluster

Questo esempio di codice crea un cluster con la versione più recente disponibile di Databricks Runtime Long Term Support (LTS) e il tipo di nodo del cluster più piccolo disponibile con un disco locale. Questo cluster ha un ruolo di lavoro e il cluster terminerà automaticamente dopo 15 minuti di inattività. La CreateAndWait chiamata al metodo fa sì che il codice venga sospeso fino a quando il nuovo cluster non viene eseguito nell'area di lavoro.

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
}

Eliminare in modo definitivo un cluster

Questo esempio di codice elimina definitivamente il cluster con l'ID cluster specificato dall'area di lavoro.

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

Eseguire un processo

Questo esempio di codice crea un processo di Azure Databricks che esegue il notebook specificato nel cluster specificato. Durante l'esecuzione del codice, ottiene il percorso del notebook esistente, l'ID cluster esistente e le impostazioni del processo correlate dall'utente nel terminale. La RunNowAndWait chiamata al metodo causa la sospensione del codice fino al termine dell'esecuzione del nuovo processo nell'area di lavoro.

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

Gestisce i file nei volumi nel catalogo Unity

Questo esempio di codice illustra varie chiamate alle funzionalità filesall'interno di WorkspaceClient per accedere a un volume del catalogo 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,
    },
  )
}

Elencare gli utenti dell'account

Questo esempio di codice elenca gli utenti disponibili all'interno di un account 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)
  }
}

Risorse aggiuntive

Per altre informazioni, vedi:

Databricks SDK per Go README
Informazioni di riferimento su Databricks SDK per l'API Go
Esempi di codice aggiuntivi
Registrazione
Test
Operazioni a esecuzione prolungata
Risposte impaginate

Condividi tramite

Databricks SDK per Go

Operazioni preliminari

Introduzione a Databricks SDK per Go

Aggiornare Databricks SDK per Go

Autenticare Databricks SDK for Go con l'account o l'area di lavoro di Azure Databricks

Esempi

Creare un cluster

Eliminare in modo definitivo un cluster

Eseguire un processo

Gestisce i file nei volumi nel catalogo Unity

Elencare gli utenti dell'account

Risorse aggiuntive

Commenti e suggerimenti

Risorse aggiuntive