Databricks SDK för Go

Artikel
08/20/2024

I den här artikeln får du lära dig hur du automatiserar åtgärder i Azure Databricks-konton, arbetsytor och relaterade resurser med Databricks SDK för Go. Den här artikeln kompletterar Databricks SDK för Go README, API-referens och exempel.

Kommentar

Den här funktionen är i Beta och är okej att använda i produktion.

Under betaperioden rekommenderar Databricks att du fäster ett beroende på den specifika delversionen av Databricks SDK för Go som koden är beroende av, till exempel i ett projekts go.mod fil. Mer information om hur du fäster beroenden finns i Hantera beroenden.

Innan du börjar

Innan du börjar använda Databricks SDK för Go måste utvecklingsdatorn ha:

Go installerat.
Azure Databricks-autentisering har konfigurerats.

Kom igång med Databricks SDK för Go

På utvecklingsdatorn med Go redan installerat, ett befintligt Go-kodprojekt som redan har skapats och Azure Databricks-autentisering konfigurerat, skapar du en go.mod fil för att spåra Go-kodens beroenden genom att köra go mod init kommandot, till exempel:
```
go mod init sample
```
Ta ett beroende av Databricks SDK för Go-paketet genom att köra go mod edit -require kommandot och ersätta 0.8.0 med den senaste versionen av Databricks SDK för Go-paketet enligt listan i CHANGELOG:
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
Filen go.mod bör nu se ut så här:
```
module sample

go 1.18

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

I projektet skapar du en Go-kodfil som importerar Databricks SDK för Go. I följande exempel, i en fil med namnet main.go med följande innehåll, visas alla kluster på din Azure Databricks-arbetsyta:

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

Lägg till eventuella modulberoenden som saknas genom att go mod tidy köra kommandot:
```
go mod tidy
```
Kommentar

Om du får felet go: warning: "all" matched no packageshar du glömt att lägga till en Go-kodfil som importerar Databricks SDK för Go.
Hämta kopior av alla paket som behövs för att stödja versioner och tester av paket i modulen main genom att go mod vendor köra kommandot:
```
go mod vendor
```
Konfigurera utvecklingsdatorn för Azure Databricks-autentisering.
Kör din Go-kodfil, förutsatt att en fil med namnet main.go, genom att go run köra kommandot:
```
go run main.go
```
Kommentar

Genom att inte ange *databricks.Config som ett argument i föregående anrop till w := databricks.Must(databricks.NewWorkspaceClient())använder Databricks SDK för Go sin standardprocess för att försöka utföra Azure Databricks-autentisering. Information om hur du åsidosätter det här standardbeteendet finns i Autentisera Databricks SDK för Go med ditt Azure Databricks-konto eller din arbetsyta.

Uppdatera Databricks SDK för Go

Gör följande om du vill uppdatera Go-projektet så att det använder något av Databricks SDK för Go-paketen enligt listan i CHANGELOG:

go get Kör kommandot från roten i projektet, ange -u flaggan för att göra en uppdatering och ange namnet och målversionsnumret för Databricks SDK för Go-paketet. Om du till exempel vill uppdatera till version 0.12.0kör du följande kommando:
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Lägg till och uppdatera eventuella saknade och inaktuella modulberoenden genom att go mod tidy köra kommandot:
```
go mod tidy
```
Hämta kopior av alla nya och uppdaterade paket som behövs för att stödja versioner och tester av paket i modulen main go mod vendor genom att köra kommandot:
```
go mod vendor
```

Autentisera Databricks SDK för Go med ditt Azure Databricks-konto eller din arbetsyta

Databricks SDK för Go implementerar databricks-klientens enhetliga autentiseringsstandard, en konsoliderad och konsekvent arkitektur- och programmeringsmetod för autentisering. Med den här metoden kan du konfigurera och automatisera autentisering med Azure Databricks mer centraliserad och förutsägbar. Det gör att du kan konfigurera Databricks-autentisering en gång och sedan använda den konfigurationen över flera Databricks-verktyg och SDK:er utan ytterligare autentiseringskonfigurationsändringar. Mer information, inklusive fler kompletta kodexempel i Go, finns i Databricks-klientens enhetliga autentisering.

Några av de tillgängliga kodningsmönstren för att initiera Databricks-autentisering med Databricks SDK för Go är:

Använd Databricks standardautentisering genom att göra något av följande:
- Skapa eller identifiera en anpassad Databricks-konfigurationsprofil med de obligatoriska fälten för databricks-målautentiseringstypen. Ange DATABRICKS_CONFIG_PROFILE sedan miljövariabeln till namnet på den anpassade konfigurationsprofilen.
- Ange nödvändiga miljövariabler för databricks-målautentiseringstypen.
Instansiera till exempel ett WorkspaceClient objekt med Databricks standardautentisering på följande sätt:
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
Hårdkodning av obligatoriska fält stöds men rekommenderas inte, eftersom det riskerar att exponera känslig information i koden, till exempel personliga åtkomsttoken för Azure Databricks. I följande exempel hårdkodas Värden för Azure Databricks och åtkomsttokenvärden för Databricks-tokenautentisering:
```
import (
  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/config"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient(&databricks.Config{
  Host:  "https://...",
  Token: "...",
}))
```

Se även Autentisering i Databricks SDK för Go README.

Exempel

Följande kodexempel visar hur du använder Databricks SDK för Go för att skapa och ta bort kluster, köra jobb och lista kontoanvändare. De här kodexemplen använder Databricks SDK för Gos standardprocess för Azure Databricks-autentisering.

Ytterligare kodexempel finns i exempelmappen i Databricks SDK för Go-lagringsplatsen i GitHub.

Skapa ett kluster
Ta bort ett kluster permanent
Köra ett jobb
Hantera filer i Unity Catalog-volymer
Lista kontoanvändare

Skapa ett kluster

Det här kodexemplet skapar ett kluster med den senaste tillgängliga versionen av Databricks Runtime Long Term Support (LTS) och den minsta tillgängliga klusternodtypen med en lokal disk. Det här klustret har en arbetare och klustret avslutas automatiskt efter 15 minuters inaktivitetstid. Metodanropet CreateAndWait gör att koden pausas tills det nya klustret körs på arbetsytan.

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
}

Ta bort ett kluster permanent

Det här kodexemplet tar bort klustret permanent med det angivna kluster-ID:t från arbetsytan.

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

Köra ett jobb

Det här kodexemplet skapar ett Azure Databricks-jobb som kör den angivna notebook-filen i det angivna klustret. När koden körs hämtar den den befintliga notebook-filens sökväg, det befintliga kluster-ID:t och relaterade jobbinställningar från användaren i terminalen. Metodanropet RunNowAndWait gör att koden pausas tills det nya jobbet har körts på arbetsytan.

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

Hantera filer i Unity Catalog-volymer

Det här kodexemplet visar olika anrop till files funktioner i WorkspaceClient för att få åtkomst till en Unity Catalog-volym.

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

Lista kontoanvändare

I det här kodexemplet visas tillgängliga användare i ett Azure Databricks-konto.

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

Ytterligare resurser

Mer information finns i:

Databricks SDK för Go README
Referens för Databricks SDK för Go API
Ytterligare kodexempel
Loggning
Test
Tidskrävande åtgärder
Sidnumrerade svar

Dela via

Databricks SDK för Go

Innan du börjar

Kom igång med Databricks SDK för Go

Uppdatera Databricks SDK för Go

Autentisera Databricks SDK för Go med ditt Azure Databricks-konto eller din arbetsyta

Exempel

Skapa ett kluster

Ta bort ett kluster permanent

Köra ett jobb

Hantera filer i Unity Catalog-volymer

Lista kontoanvändare

Ytterligare resurser

Feedback

Ytterligare resurser