Databricks SDK for Go

Cikk
08/20/2024

Ebből a cikkből megtudhatja, hogyan automatizálhatja az Azure Databricks-fiókok, -munkaterületek és kapcsolódó erőforrások műveleteit a Databricks SDK for Go használatával. Ez a cikk kiegészíti a Databricks SDK for Go README-t, az API-referenciákat és példákat.

Feljegyzés

Ez a funkció bétaverzióban érhető el, és éles környezetben is használható.

A bétaidőszakban a Databricks azt javasolja, hogy rögzítse a Databricks SDK for Go adott alverziójának függőségét, amelytől a kód függ, például egy projekt fájljában go.mod . A függőségek rögzítésével kapcsolatos további információkért lásd : Függőségek kezelése.

Mielőtt elkezdené

A Databricks SDK for Go használatának megkezdése előtt a fejlesztőgépnek a következőkkel kell rendelkeznie:

Ugrás a telepítésre.
Azure Databricks-hitelesítés konfigurálva.

A Databricks SDK for Go használatának első lépései

A Go már telepítve van a fejlesztői gépen, már létrehozott egy meglévő Go-kódprojektet, és konfigurálta az Azure Databricks-hitelesítést, és hozzon létre egy go.mod fájlt a Go-kód függőségeinek nyomon követéséhez a go mod init parancs futtatásával, például:
```
go mod init sample
```
A Parancs futtatásával go mod edit -require függjön a Databricks SDK for Go csomagtól, és cserélje le 0.8.0 a Databricks SDK for Go csomag legújabb verzióját a CHANGELOG-ban felsoroltak szerint:
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
A go.mod fájlnak így kell kinéznie:
```
module sample

go 1.18

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

A projekten belül hozzon létre egy Go-kódfájlt, amely importálja a Databricks SDK for Go-t. Az alábbi példa egy, a következő tartalommal elnevezett main.go fájlban felsorolja az Azure Databricks-munkaterület összes fürtjének listáját:

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

Adja hozzá a hiányzó modulfüggőségeket a go mod tidy parancs futtatásával:
```
go mod tidy
```
Feljegyzés

Ha a hibaüzenet go: warning: "all" matched no packagesjelenik meg, elfelejtette hozzáadni a Go-hoz készült Databricks SDK-t importáló Go-kódfájlt.
Szerezze be a modulban lévő main csomagok buildjeinek és tesztjeinek támogatásához szükséges összes csomag másolatát a go mod vendor parancs futtatásával:
```
go mod vendor
```
Állítsa be a fejlesztői gépet az Azure Databricks-hitelesítéshez.
Futtassa a Go-kódfájlt, feltéve, hogy a következő nevű fájlt main.gofuttatja:go run
```
go run main.go
```
Feljegyzés

Ha nem állít be *databricks.Config argumentumot az előző hívásban w := databricks.Must(databricks.NewWorkspaceClient()), a Databricks SDK for Go az alapértelmezett folyamatot használja az Azure Databricks-hitelesítés végrehajtására. Az alapértelmezett viselkedés felülbírálásához lásd : A Databricks SDK for Go hitelesítése az Azure Databricks-fiókkal vagy -munkaterülettel.

A Databricks SDK for Go frissítése

Ha frissíteni szeretné a Go-projektet a ChangeLOG-ban felsorolt Databricks SDK for Go-csomagok egyikének használatára, tegye a következőket:

Futtassa a parancsot a go get projekt gyökeréből, adja meg a -u frissítéshez szükséges jelzőt, és adja meg a Databricks SDK for Go csomag nevét és célverziószámát. Ha például verzióra 0.12.0szeretne frissíteni, futtassa a következő parancsot:
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Adja hozzá és frissítse a hiányzó és elavult modulfüggőségeket a go mod tidy parancs futtatásával:
```
go mod tidy
```
Szerezze be a modulban lévő main csomagok buildjeinek és tesztjeinek támogatásához szükséges összes új és frissített csomag másolatát a go mod vendor parancs futtatásával:
```
go mod vendor
```

A Databricks SDK for Go hitelesítése az Azure Databricks-fiókkal vagy -munkaterülettel

A Databricks SDK for Go implementálja a Databricks-ügyfél egységes hitelesítési szabványát, amely a hitelesítés egységes és egységes architekturális és programozott megközelítése. Ez a megközelítés segít központosítottabbá és kiszámíthatóbbá tenni az Azure Databricks-hitelesítés beállítását és automatizálását. Lehetővé teszi a Databricks-hitelesítés egyszeri konfigurálását, majd ezt a konfigurációt több Databricks-eszközön és SDK-ban is használhatja további hitelesítési konfigurációmódosítások nélkül. További információkért, beleértve a Go-ban található teljesebb kód példákat, tekintse meg a Databricks-ügyfél egységes hitelesítését.

A Databricks-hitelesítés és a Databricks SDK for Go inicializálásához rendelkezésre álló kódolási minták közé tartoznak a következők:

Használja a Databricks alapértelmezett hitelesítését az alábbiak egyikével:
- Egyéni Databricks-konfigurációs profil létrehozása vagy azonosítása a cél Databricks-hitelesítési típushoz szükséges mezőkkel. Ezután állítsa a DATABRICKS_CONFIG_PROFILE környezeti változót az egyéni konfigurációs profil nevére.
- Adja meg a cél Databricks-hitelesítési típushoz szükséges környezeti változókat.
Ezután példányosíthat például egy WorkspaceClient objektumot a Databricks alapértelmezett hitelesítésével az alábbiak szerint:
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
A szükséges mezők szigorú kódolása támogatott, de nem ajánlott, mivel a kód bizalmas adatainak, például az Azure Databricks személyes hozzáférési jogkivonatainak felfedését kockáztatja. Az alábbi, a Databricks-jogkivonat-hitelesítéshez használt Azure Databricks-gazda- és hozzáférési jogkivonat-értékek a következő példa:
```
import (
  "github.com/databricks/databricks-sdk-go"
  "github.com/databricks/databricks-sdk-go/config"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient(&databricks.Config{
  Host:  "https://...",
  Token: "...",
}))
```

Lásd még : Hitelesítés a Databricks SDK for Go README-ben.

Példák

Az alábbi példakód bemutatja, hogyan használhatja a Databricks SDK for Go-t fürtök létrehozására és törlésére, feladatok futtatására és fiókfelhasználók listázására. Ezek a példakódok a Databricks SDK for Go alapértelmezett Azure Databricks-hitelesítési folyamatát használják.

További kódpéldákat a GitHub Databricks SDK for Go adattárában talál.

Fürt létrehozása
Fürt végleges törlése
Feladat futtatása
Fájlok kezelése Unity Catalog-kötetekben
Fiókfelhasználók listázása

Fürt létrehozása

Ez a példakód létrehoz egy fürtöt, amely a legújabb rendelkezésre álló Databricks Runtime Long Term Support (LTS) verzióval és a legkisebb elérhető fürtcsomóponttípussal rendelkezik egy helyi lemezzel. Ez a fürt egy feldolgozóval rendelkezik, és a fürt 15 perc tétlenség után automatikusan leáll. A CreateAndWait metódushívás hatására a kód addig szünetel, amíg az új fürt nem fut a munkaterületen.

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
}

Fürt végleges törlése

Ez a példakód véglegesen törli a megadott fürtazonosítóval rendelkező fürtöt a munkaterületről.

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

Feladat futtatása

Ez a példakód létrehoz egy Azure Databricks-feladatot, amely a megadott jegyzetfüzetet futtatja a megadott fürtön. A kód futtatásakor lekéri a meglévő jegyzetfüzet elérési útját, a meglévő fürtazonosítót és a kapcsolódó feladatbeállításokat a terminál felhasználójától. A RunNowAndWait metódushívás hatására a kód addig szünetel, amíg az új feladat nem fut a munkaterületen.

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

Fájlok kezelése Unity Catalog-kötetekben

Ez a példakód bemutatja a files Unity-katalógus köteteihez való hozzáféréshez szükséges funkciók WorkspaceClient különböző hívásait.

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

Fiókfelhasználók listázása

Ez a példakód az Azure Databricks-fiókban elérhető felhasználókat sorolja fel.

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

További erőforrások

További információk:

Megosztás a következőn keresztül: