Databricks SDK voor Go

Artikel
08/20/2024

In dit artikel leert u hoe u bewerkingen in Azure Databricks-accounts, werkruimten en gerelateerde resources automatiseert met de Databricks SDK voor Go. Dit artikel is een aanvulling op de Databricks SDK voor Go README, API-verwijzing en voorbeelden.

Notitie

Deze functie is in bèta en is in orde om te gebruiken in productie.

Tijdens de bètaperiode raadt Databricks u aan een afhankelijkheid vast te maken van de specifieke secundaire versie van de Databricks SDK voor Go waarvan uw code afhankelijk is, bijvoorbeeld in het bestand van go.mod een project. Zie Afhankelijkheden beheren voor meer informatie over het vastmaken van afhankelijkheden.

Voordat u begint

Voordat u begint met het gebruik van de Databricks SDK voor Go, moet uw ontwikkelcomputer over het volgende beschikken:

Go geïnstalleerd.
Azure Databricks-verificatie geconfigureerd.

Aan de slag met de Databricks SDK voor Go

Maak op uw ontwikkelcomputer waarop Go al is geïnstalleerd, een bestaand Go-codeproject dat al is gemaakt en Azure Databricks-verificatie is geconfigureerd, een go.mod bestand om de afhankelijkheden van uw Go-code bij te houden door de go mod init opdracht uit te voeren, bijvoorbeeld:
```
go mod init sample
```
Neem een afhankelijkheid van het Databricks SDK voor Go-pakket door de go mod edit -require opdracht uit te voeren, waarbij 0.8.0 u de nieuwste versie van het Databricks SDK voor Go-pakket vervangt zoals vermeld in het CHANGELOG:
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
Uw go.mod bestand moet er nu als volgt uitzien:
```
module sample

go 1.18

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

Maak in uw project een Go-codebestand waarmee de Databricks SDK voor Go wordt geïmporteerd. In het volgende voorbeeld, in een bestand met de naam main.go met de volgende inhoud, worden alle clusters in uw Azure Databricks-werkruimte vermeld:

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

Voeg ontbrekende moduleafhankelijkheden toe door de opdracht uit te go mod tidy voeren:
```
go mod tidy
```
Notitie

Als u de fout go: warning: "all" matched no packageskrijgt, bent u vergeten een Go-codebestand toe te voegen waarmee de Databricks SDK voor Go wordt geïmporteerd.
Pak kopieën van alle pakketten die nodig zijn om builds en tests van pakketten in uw main module te ondersteunen door de go mod vendor opdracht uit te voeren:
```
go mod vendor
```
Stel uw ontwikkelcomputer in voor Azure Databricks-verificatie.
Voer het Go-codebestand uit, uitgaande van een bestand met de naam main.go, door de opdracht uit te go run voeren:
```
go run main.go
```
Notitie

Door in de voorgaande aanroep geen argument in te w := databricks.Must(databricks.NewWorkspaceClient())stellen*databricks.Config, gebruikt de Databricks SDK voor Go het standaardproces voor het uitvoeren van Azure Databricks-verificatie. Zie De Databricks SDK voor Go verifiëren met uw Azure Databricks-account of -werkruimte om dit standaardgedrag te overschrijven.

De Databricks SDK voor Go bijwerken

Ga als volgt te werk om uw Go-project bij te werken voor het gebruik van een van de Databricks SDK voor Go-pakketten zoals vermeld in changelog:

Voer de go get opdracht uit vanuit de hoofdmap van uw project, waarbij u de -u vlag opgeeft om een update uit te voeren en de naam en het doelversienummer van het Databricks SDK voor Go-pakket op te geven. Als u bijvoorbeeld wilt bijwerken naar versie 0.12.0, voert u de volgende opdracht uit:
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Voeg ontbrekende en verouderde moduleafhankelijkheden toe en werk deze bij door de opdracht uit te go mod tidy voeren:
```
go mod tidy
```
Pak kopieën van alle nieuwe en bijgewerkte pakketten die nodig zijn om builds en tests van pakketten in uw main module te ondersteunen door de go mod vendor opdracht uit te voeren:
```
go mod vendor
```

De Databricks SDK voor Go verifiëren met uw Azure Databricks-account of -werkruimte

De Databricks SDK voor Go implementeert de geïntegreerde verificatiestandaard van de Databricks-client, een geconsolideerde en consistente architectuur en programmatische benadering van verificatie. Deze aanpak helpt bij het instellen en automatiseren van verificatie met Azure Databricks gecentraliseerder en voorspelbaarder. Hiermee kunt u Databricks-verificatie eenmaal configureren en deze configuratie vervolgens gebruiken voor meerdere Databricks-hulpprogramma's en SDK's zonder verdere verificatieconfiguratiewijzigingen. Zie voor meer informatie, waaronder meer volledige codevoorbeelden in Go, geïntegreerde verificatie van Databricks-client.

Enkele van de beschikbare coderingspatronen voor het initialiseren van Databricks-verificatie met de Databricks SDK voor Go zijn onder andere:

Gebruik databricks-standaardverificatie door een van de volgende handelingen uit te voeren:
- Maak of identificeer een aangepast Databricks-configuratieprofiel met de vereiste velden voor het doelverificatietype Databricks. Stel vervolgens de DATABRICKS_CONFIG_PROFILE omgevingsvariabele in op de naam van het aangepaste configuratieprofiel.
- Stel de vereiste omgevingsvariabelen in voor het doelverificatietype Databricks.
Maak vervolgens als volgt een instantie van een WorkspaceClient object met databricks-standaardverificatie:
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
Het hard coderen van de vereiste velden wordt ondersteund, maar wordt niet aanbevolen, omdat het risico loopt dat gevoelige informatie in uw code wordt weergegeven, zoals persoonlijke toegangstokens van Azure Databricks. In het volgende voorbeeld worden azure Databricks-host- en toegangstokenwaarden vastgelegd voor databricks-tokenverificatie:
```
import (
  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/config"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient(&databricks.Config{
  Host:  "https://...",
  Token: "...",
}))
```

Zie ook verificatie in de Databricks SDK voor Go README.

Voorbeelden

In de volgende codevoorbeelden ziet u hoe u de Databricks SDK voor Go gebruikt om clusters te maken en te verwijderen, taken uit te voeren en accountgebruikers weer te geven. In deze codevoorbeelden wordt gebruikgemaakt van de Databricks SDK voor het standaardverificatieproces van Azure Databricks van Go.

Zie de map Met voorbeelden in de Databricks SDK voor Go-opslagplaats in GitHub voor aanvullende codevoorbeelden.

Een cluster maken
Een cluster definitief verwijderen
Een taak uitvoeren
Bestanden beheren in Unity Catalog-volumes
Accountgebruikers vermelden

Een cluster maken

In dit codevoorbeeld wordt een cluster gemaakt met de meest recente versie van Databricks Runtime Long Term Support (LTS) en het kleinste beschikbare clusterknooppunttype met een lokale schijf. Dit cluster heeft één werkrol en het cluster wordt na 15 minuten niet-actieve tijd automatisch beëindigd. De CreateAndWait methodeaanroep zorgt ervoor dat de code wordt onderbroken totdat het nieuwe cluster wordt uitgevoerd in de werkruimte.

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
}

Een cluster definitief verwijderen

In dit codevoorbeeld wordt het cluster definitief verwijderd met de opgegeven cluster-id uit de werkruimte.

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

Een taak uitvoeren

In dit codevoorbeeld wordt een Azure Databricks-taak gemaakt waarmee het opgegeven notebook op het opgegeven cluster wordt uitgevoerd. Wanneer de code wordt uitgevoerd, worden het pad van het bestaande notebook, de bestaande cluster-id en de gerelateerde taakinstellingen van de gebruiker in de terminal opgehaald. De RunNowAndWait methodeaanroep zorgt ervoor dat de code wordt onderbroken totdat de nieuwe taak is uitgevoerd in de werkruimte.

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

Bestanden beheren in Unity Catalog-volumes

In dit codevoorbeeld ziet u verschillende aanroepen naar files functionaliteit binnen WorkspaceClient om toegang te krijgen tot een Unity Catalog-volume.

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

Accountgebruikers vermelden

In dit codevoorbeeld worden de beschikbare gebruikers in een Azure Databricks-account weergegeven.

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

Aanvullende bronnen

Zie voor meer informatie:

Databricks SDK voor Go README
Naslaginformatie voor Databricks SDK voor Go-API
Aanvullende codevoorbeelden
Logboekregistratie
Testen.
Langlopende bewerkingen
Gepagineerde antwoorden

Delen via