Zestaw SDK usługi Databricks dla języka Go

Z tego artykułu dowiesz się, jak zautomatyzować operacje usługi Azure Databricks i przyspieszyć programowanie przy użyciu zestawu SDK usługi Databricks dla języka Go. Ten artykuł uzupełnia zestaw SDK usługi Databricks dla języka Go README, dokumentacja interfejsu API i przykłady.

Uwaga

Ta funkcja jest dostępna w wersji beta i jest w porządku do użycia w środowisku produkcyjnym.

W okresie beta usługa Databricks zaleca przypięcie zależności od określonej pomocniczej wersji zestawu SDK usługi Databricks dla języka Go, od której zależy twój kod, na przykład w pliku projektu go.mod . Aby uzyskać więcej informacji na temat przypinania zależności, zobacz Zarządzanie zależnościami.

Zanim rozpoczniesz

Przed rozpoczęciem korzystania z zestawu SDK usługi Databricks dla języka Go maszyna deweloperna musi mieć następujące elementy:

• Go zainstalowany.
• Skonfigurowane uwierzytelnianie usługi Azure Databricks.

Wprowadzenie do zestawu SDK usługi Databricks dla języka Go

1. Na maszynie deweloperskiej z już zainstalowanym językiem Go, gdy masz już istniejący projekt w Go i skonfigurowane uwierzytelnienie w Azure Databricks, utwórz plik w celu śledzenia zależności kodu w Go, uruchamiając polecenie, na przykład:

   go mod init sample
   

2. Dodaj zależność do pakietu SDK usługi Databricks dla języka Go, uruchamiając polecenie go mod edit -require, zastępując 0.8.0 najnowszą wersją pakietu SDK usługi Databricks dla języka Go, jak wymieniono w pliku CHANGELOG.

   go mod edit -require github.com/databricks/databricks-sdk-go@v0.8.0
   

   Plik go.mod powinien teraz wyglądać następująco:

   module sample
   
   go 1.18
   
   require github.com/databricks/databricks-sdk-go v0.8.0
   

3. W projekcie utwórz plik kodu języka Go, który importuje zestaw SDK usługi Databricks dla języka Go. Poniższy przykład w pliku o nazwie o następującej main.go zawartości zawiera listę wszystkich klastrów w obszarze roboczym usługi 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)
     }
   }
   

4. Dodaj wszystkie brakujące zależności modułu go mod tidy , uruchamiając polecenie :

   go mod tidy
   

   Uwaga

   Jeśli wystąpi błąd go: warning: "all" matched no packages, nie pamiętasz dodania pliku kodu języka Go, który importuje zestaw SDK usługi Databricks dla języka Go.

5. Pobierz kopie wszystkich pakietów wymaganych do obsługi kompilacji i testów pakietów w main module, uruchamiając go mod vendor polecenie :

   go mod vendor
   

6. Skonfiguruj maszynę dewelopera na potrzeby uwierzytelniania usługi Azure Databricks.

7. Aby uruchomić plik kodu w języku Go, zakładając, że plik nosi nazwę main.go, wykonaj polecenie go run.

   go run main.go
   

   Uwaga

   Nie ustawiając *databricks.Config jako argumentu w poprzednim wywołaniu metody w := databricks.Must(databricks.NewWorkspaceClient()), zestaw SDK usługi Databricks dla języka Go używa domyślnego procesu do próby przeprowadzenia uwierzytelniania w usłudze Azure Databricks. Aby zastąpić to domyślne zachowanie, zobacz Uwierzytelnianie zestawu SDK usługi Databricks dla języka Go przy użyciu konta lub obszaru roboczego usługi Azure Databricks.

Aktualizowanie zestawu SDK usługi Databricks dla języka Go

Aby zaktualizować projekt napisany w Go do wykorzystania jednego z pakietów SDK Databricks dla Go, wymienionych w CHANGELOG, wykonaj następujące czynności:

1. Uruchom polecenie go get z katalogu głównego projektu, określając flagę -u aby wykonać aktualizację, oraz podając nazwę i numer docelowej wersji pakietu Databricks SDK dla Go. Na przykład, aby zaktualizować do wersji 0.12.0, uruchom następujące polecenie:

   go get -u github.com/databricks/databricks-sdk-go@v0.12.0
   

2. Dodaj i zaktualizuj wszystkie brakujące i nieaktualne zależności modułu go mod tidy , uruchamiając polecenie :

   go mod tidy
   

3. Pobierz kopie wszystkich nowych i zaktualizowanych pakietów potrzebnych do obsługi kompilacji i testów pakietów w main module, uruchamiając go mod vendor polecenie:

   go mod vendor
   

Uwierzytelnianie zestawu SDK usługi Databricks dla języka Go przy użyciu konta lub obszaru roboczego usługi Azure Databricks

Zestaw SDK usługi Databricks dla języka Go implementuje ujednolicony standard uwierzytelniania usługi Databricks , skonsolidowane i spójne podejście architektoniczne i programowe do uwierzytelniania. Takie podejście pomaga w bardziej scentralizowanym i przewidywalnym konfigurowaniu oraz automatyzacji uwierzytelniania z użyciem usługi Azure Databricks. Umożliwia ona skonfigurowanie uwierzytelniania usługi Databricks raz, a następnie użycie tej konfiguracji w wielu narzędziach i zestawach SDK usługi Databricks bez dalszych zmian konfiguracji uwierzytelniania. Aby uzyskać więcej informacji, w tym bardziej kompletne przykłady kodu w języku Go, zobacz Ujednolicone uwierzytelnianie usługi Databricks.

Niektóre z dostępnych wzorców kodowania do inicjowania uwierzytelniania usługi Databricks przy użyciu zestawu SDK usługi Databricks dla języka Go obejmują:

• Użyj domyślnego uwierzytelniania usługi Databricks, wykonując jedną z następujących czynności:

  • Utwórz lub zidentyfikuj niestandardowy profil konfiguracji usługi Databricks z wymaganymi polami dla docelowego typu uwierzytelniania usługi Databricks. Następnie ustaw zmienną środowiskową DATABRICKS_CONFIG_PROFILE na nazwę niestandardowego profilu konfiguracji.
  • Ustaw wymagane zmienne środowiskowe dla docelowego typu uwierzytelniania usługi Databricks.

  Następnie utwórz, na przykład, obiekt WorkspaceClient z domyślnym uwierzytelnianiem usługi Databricks w następujący sposób:

  import (
    "github.com/databricks/databricks-sdk-go"
  )
  // ...
  w := databricks.Must(databricks.NewWorkspaceClient())
  

• Kodowanie na stałe wymaganych pól jest obsługiwane, ale nie jest zalecane, ponieważ ryzykuje ujawnienie poufnych informacji w kodzie, takich jak osobiste tokeny dostępu usługi Azure Databricks. Poniższy przykład zawiera wartości na sztywno zakodowane dla hosta i tokenu dostępu Azure Databricks, potrzebne do uwierzytelniania za pomocą tokenu 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: "...",
  }))
  

Zobacz również artykuł Authentication in the Databricks SDK for Go README (Uwierzytelnianie w zestawie SDK usługi Databricks dla języka Go README).

Przykłady

W poniższych przykładach kodu pokazano, jak używać zestawu SDK usługi Databricks dla języka Go do tworzenia i usuwania klastrów, uruchamiania zadań i wyświetlania listy użytkowników kont. Te przykłady kodu używają zestawu SDK usługi Databricks do domyślnego procesu uwierzytelniania usługi Azure Databricks w języku Go.

Aby uzyskać dodatkowe przykłady kodu, zobacz katalog examples w repozytorium Zestawu SDK dla języka Go usługi Databricks w usłudze GitHub.

• Tworzenie klastra
• Trwałe usuwanie klastra
• Uruchamianie zadania
• Zarządzanie plikami w zasobach Unity Catalog
• Wyświetlanie listy użytkowników kont

Tworzenie klastra

Ten przykładowy kod tworzy klaster z najnowszą dostępną wersją środowiska Databricks Runtime Long Term Support (LTS) i najmniejszym dostępnym typem węzła klastra z dyskiem lokalnym. Ten klaster ma jeden węzeł roboczy, a klaster zostanie automatycznie wyłączony po upływie 15 minut bezczynności. Wywołanie CreateAndWait metody powoduje wstrzymanie kodu do momentu uruchomienia nowego klastra w obszarze roboczym.

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
}

Trwałe usuwanie klastra

Ten przykład kodu trwale usuwa klaster z określonym identyfikatorem klastra z obszaru roboczego.

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

Uruchamianie zadania

Ten przykładowy kod tworzy zadanie usługi Azure Databricks, które uruchamia określony notes w określonym klastrze. Podczas wykonywania kodu, pobiera on ścieżkę istniejącego notesu, istniejący identyfikator klastra oraz powiązane ustawienia zadania od użytkownika korzystającego z terminalu. Wywołanie RunNowAndWait metody powoduje wstrzymanie kodu do momentu zakończenia nowego zadania w obszarze roboczym.

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

Zarządzanie plikami w wolumenach Unity Catalog

W tym przykładzie kodu pokazano różne wywołania funkcji w , aby uzyskać dostęp do woluminukatalogu 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,
    },
  )
}

Lista użytkowników konta

Ten przykładowy kod zawiera listę dostępnych użytkowników na koncie usługi 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)
  }
}

Rozwiązywanie problemów

W tej sekcji opisano rozwiązania typowych problemów z zestawem SDK usługi Databricks dla języka Go.

Aby zgłosić problemy lub inne opinie, utwórz zgłoszenie w GitHubie dla SDK Databricks dla Go.

Błąd: Nie można przeanalizować odpowiedzi

Jeśli podczas próby użycia zestawu SDK usługi Databricks dla języka Go wystąpi następujący błąd, prawie zawsze wskazuje to problem z konfiguracją uwierzytelniania.

Error: unable to parse response. This is likely a bug in the Databricks SDK for Go or the underlying REST API.

Jeśli wystąpi ten błąd, sprawdź następujące kwestie:

• Upewnij się, że host usługi Databricks jest poprawnie ustawiony.
• Upewnij się, że metoda uwierzytelniania ma wymagane uprawnienia do operacji interfejsu API, którą próbujesz wykonać.
• Jeśli znajdujesz się za firmową zaporą, upewnij się, że nie blokuje ani nie przekierowuje ruchu interfejsu API.

Częstą przyczyną tego błędu jest przekierowanie zestawu SDK na stronę logowania, której zestaw SDK nie potrafi przetworzyć. Dzieje się tak zwykle w przypadku próby uzyskania dostępu do obszaru roboczego z włączonym łączem prywatnym, skonfigurowanego bez dostępu do publicznego Internetu, z innej sieci niż ta, do której należy punkt końcowy VPC.

Aby uzyskać więcej informacji, zobacz:

• Ujednolicone uwierzytelnianie Databricks

• Skonfiguruj prywatną łączność klasycznej płaszczyzny obliczeniowej z usługą Azure Databricks.

Dodatkowe zasoby

Aby uzyskać więcej informacji, zobacz:

• Zestaw SDK usługi Databricks dla języka Go README
• Dokumentacja interfejsu API Databricks SDK języka Go
• Dodatkowe przykłady kodu
• Rejestrowanie
• Testowanie
• Długotrwałe operacje
• Odpowiedzi podzielone na strony