Databricks SDK pro Go

Článek
08/20/2024

V tomto článku se dozvíte, jak automatizovat operace v účtech, pracovních prostorech a souvisejících prostředcích Azure Databricks pomocí sady Databricks SDK for Go. Tento článek doplňuje sadu Databricks SDK for Go README, reference k rozhraní API a příklady.

Poznámka:

Tato funkce je v beta verzi a je v pořádku používat v produkčním prostředí.

Během beta období doporučuje Databricks připnout závislost na konkrétní podverzi sady Databricks SDK pro Go, na které váš kód závisí, například v souboru projektu go.mod . Další informace o připnutí závislostí najdete v tématu Správa závislostí.

Než začnete

Než začnete používat sadu Databricks SDK for Go, váš vývojový počítač musí mít:

Go installed.
Nakonfigurované ověřování Azure Databricks

Začínáme se sadou Databricks SDK for Go

Na vývojovém počítači s go už nainstalovaným existujícím projektem kódu Go a nakonfigurovaným ověřováním Azure Databricks vytvořte go.mod soubor pro sledování závislostí kódu Go spuštěním go mod init příkazu, například:
```
go mod init sample
```
Spuštěním příkazu zapněte go mod edit -require závislost na balíčku Databricks SDK for Go a nahraďte 0.8.0 nejnovější verzí balíčku Databricks SDK for Go, jak je uvedeno v protokolu CHANGELOG:
```
go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
```
Soubor go.mod by teď měl vypadat takto:
```
module sample

go 1.18

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

V projektu vytvořte soubor kódu Go, který naimportuje sadu Databricks SDK for Go. Následující příklad v souboru s následujícím main.go obsahem obsahuje seznam všech clusterů v pracovním prostoru 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)
  }
}

Spuštěním go mod tidy příkazu přidejte všechny chybějící závislosti modulu:
```
go mod tidy
```
Poznámka:

Pokud se zobrazí chyba go: warning: "all" matched no packages, zapomněli jste přidat soubor kódu Go, který importuje sadu Databricks SDK pro Go.
Spuštěním go mod vendor příkazu získejte main kopie všech balíčků potřebných k podpoře sestavení a testů balíčků v modulu:
```
go mod vendor
```
Nastavte svůj vývojový počítač pro ověřování Azure Databricks.
Spuštěním příkazu spusťte soubor kódu Go za předpokladugo run, že soubor s názvem main.go:
```
go run main.go
```
Poznámka:

Když v předchozím volání w := databricks.Must(databricks.NewWorkspaceClient())nenastavíte *databricks.Config jako argument , sada Databricks SDK for Go použije výchozí proces pro pokus o ověření Azure Databricks. Pokud chcete toto výchozí chování přepsat, přečtěte si téma Ověření sady Databricks SDK for Go pomocí účtu nebo pracovního prostoru Azure Databricks.

Aktualizace sady Databricks SDK pro Go

Pokud chcete aktualizovat projekt Go tak, aby používal jeden z balíčků Databricks SDK for Go, jak je uvedeno v protokolu CHANGELOG, postupujte takto:

go get Spusťte příkaz z kořenového adresáře projektu, zadejte -u příznak, který má provést aktualizaci, a zadejte název a číslo cílové verze balíčku Databricks SDK for Go. Pokud chcete například aktualizovat verzi 0.12.0, spusťte následující příkaz:
```
go get -u github.com/databricks/databricks-sdk-go@v0.12.0
```
Spuštěním go mod tidy příkazu přidejte a aktualizujte všechny chybějící a zastaralé závislosti modulů:
```
go mod tidy
```
Spuštěním go mod vendor příkazu získejte main kopie všech nových a aktualizovaných balíčků potřebných k podpoře sestavení a testů balíčků v modulu:
```
go mod vendor
```

Ověření sady Databricks SDK for Go pomocí účtu nebo pracovního prostoru Azure Databricks

Sada Databricks SDK for Go implementuje jednotný ověřovací standard klienta Databricks, konsolidovaný a konzistentní přístup k ověřování s architekturou a programovým přístupem. Tento přístup pomáhá zajistit centralizovanější a předvídatelnější nastavení a automatizaci ověřování pomocí Azure Databricks. Umožňuje konfigurovat ověřování Databricks jednou a pak tuto konfiguraci používat napříč několika nástroji a sadami SDK Databricks bez dalších změn konfigurace ověřování. Další informace, včetně kompletních příkladů kódu v Go, najdete v tématu Jednotné ověřování klienta Databricks.

Mezi dostupné vzory kódování pro inicializaci ověřování Databricks pomocí sady Databricks SDK pro Go patří:

Výchozí ověřování Databricks můžete použít jedním z následujících způsobů:
- Vytvořte nebo identifikujte vlastní konfigurační profil Databricks s požadovanými poli pro cílový typ ověřování Databricks. Potom nastavte proměnnou DATABRICKS_CONFIG_PROFILE prostředí na název vlastního konfiguračního profilu.
- Nastavte požadované proměnné prostředí pro cílový typ ověřování Databricks.
Pak vytvořte instanci objektu WorkspaceClient s výchozím ověřováním Databricks následujícím způsobem:
```
import (
  "github.com/databricks/databricks-sdk-go"
)
// ...
w := databricks.Must(databricks.NewWorkspaceClient())
```
Požadovaná pole se pevně zakódují, ale nedoporučuje se, protože riskuje zveřejnění citlivých informací v kódu, jako jsou osobní přístupové tokeny Azure Databricks. Následující příklad pevně kóduje hodnoty hostitele Azure Databricks a přístupového tokenu pro ověřování tokenů 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: "...",
}))
```

Viz také Ověřování v sadě Databricks SDK for Go README.

Příklady

Následující příklady kódu ukazují, jak pomocí sady Databricks SDK for Go vytvářet a odstraňovat clustery, spouštět úlohy a vypisovat uživatele účtu. Tyto příklady kódu používají výchozí proces ověřování Azure Databricks SDK pro Go.

Další příklady kódu najdete ve složce s příklady v úložišti Databricks SDK for Go na GitHubu.

Vytvoření clusteru
Trvalé odstranění clusteru
Spuštění úlohy
Správa souborů ve svazcích katalogu Unity
Zobrazení seznamu uživatelů účtu

Vytvoření clusteru

Tento příklad kódu vytvoří cluster s nejnovější dostupnou verzí dlouhodobé podpory Databricks Runtime (LTS) a nejmenším dostupným typem uzlu clusteru s místním diskem. Tento cluster má jeden pracovní proces a cluster se automaticky ukončí po 15 minutách nečinnosti. Volání CreateAndWait metody způsobí, že se kód pozastaví, dokud v pracovním prostoru neběží nový cluster.

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
}

Trvalé odstranění clusteru

Tento příklad kódu trvale odstraní cluster se zadaným ID clusteru z pracovního prostoru.

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

Spuštění úlohy

Tento příklad kódu vytvoří úlohu Azure Databricks, která spustí zadaný poznámkový blok v zadaném clusteru. Při spuštění kódu získá cestu existujícího poznámkového bloku, id existujícího clusteru a související nastavení úlohy od uživatele v terminálu. Volání RunNowAndWait metody způsobí pozastavení kódu, dokud se nová úloha nedokončí v pracovním prostoru.

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

Správa souborů ve svazcích katalogu Unity

Tento příklad kódu ukazuje různá volání files funkcí v rámci WorkspaceClient přístupu ke svazku katalogu 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,
    },
  )
}

Zobrazení seznamu uživatelů účtu

Tento příklad kódu obsahuje seznam dostupných uživatelů v rámci účtu 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)
  }
}

Další materiály

Další informace naleznete v tématu:

Databricks SDK for Go README
Referenční informace k rozhraní API sady Databricks SDK for Go
Další příklady kódu
Protokolování
Testování
Dlouhotrvající operace
Stránkované odpovědi

Sdílet prostřednictvím

Databricks SDK pro Go

Než začnete

Začínáme se sadou Databricks SDK for Go

Aktualizace sady Databricks SDK pro Go

Ověření sady Databricks SDK for Go pomocí účtu nebo pracovního prostoru Azure Databricks

Příklady

Vytvoření clusteru

Trvalé odstranění clusteru

Spuštění úlohy

Správa souborů ve svazcích katalogu Unity

Zobrazení seznamu uživatelů účtu

Další materiály

Váš názor

Další materiály