Verwalten von Git-Ordnern mit Azure Databricks mithilfe von Terraform

Verwalten Sie Azure Databricks Git-Ordner in einer vollständig automatisierten Umgebung mithilfe von Terraform und dem Databricks Terraform-Anbieter.

In diesem Thema werden zwei Authentifizierungsansätze behandelt:

  • Authentifizierung für persönliche Zugriffstoken (PERSONAL Access Token, PAT): Verwendet persönliche Git-Zugriffstoken für den Repositoryzugriff
  • Dienstprinzipal mit Verbundanmeldeinformationen: Verwendet Azure-Dienstprinzipale mit OpenID Connect (OIDC)-Token für sichere, tokenlose Authentifizierung für Azure DevOps-Repositorys

Authentifizierung mit persönlichen Zugriffstoken

Bei diesem Ansatz werden Git-Persönliche Zugriffstokens zur Repository-Authentifizierung mit einem Dienstprinzipal verwendet.

Terraform wertet Anbieterkonfigurationen aus, bevor Ressourcen erstellt werden, sodass Sie innerhalb eines Anbieterblocks derselben Terraform-Konfiguration nicht auf einen Ressourcenwert (z. B. ein OBO-Token) verweisen können. Um diese Einschränkung zu umgehen, teilen Sie das Setup in zwei separate Konfigurationen auf:

  • Teil 1: Erstellen des Dienstprinzipals: Erstellt den Dienstprinzipal und generiert ein OBO-Token.
  • Teil 2: Konfigurieren von Git-Anmeldeinformationen: Verwendet das OBO-Token, um sich als Dienstprinzipal zu authentifizieren, konfiguriert dann Git-Anmeldeinformationen und erstellt den Git-Ordner.

Teil 1: Erstellen des Dienstprinzipals

Erstellen Sie ein setup/ Verzeichnis mit einer main.tf Datei.

Schritt 1: Deklarieren des Anbieters und der Variablen

terraform {
  required_providers {
    databricks = {
      source = "databricks/databricks"
    }
  }
}

variable "databricks_host" {}

variable "databricks_admin_token" {
  sensitive = true
}

variable "service_principal_name" {}

provider "databricks" {
  host  = var.databricks_host
  token = var.databricks_admin_token
}

Schritt 2: Erstellen des Dienstprinzipals

Wählen Sie einen Anzeigenamen für den Dienstprinzipal aus. Terraform erstellt es mit diesem Namen.

resource "databricks_service_principal" "sp" {
  display_name = var.service_principal_name
}

Schritt 3: Erstellen und Exportieren des Autorisierungstokens

Generieren Sie ein OBO-Token für den Dienstprinzipal, und exportieren Sie es für die Verwendung in der nächsten Konfiguration.

resource "databricks_obo_token" "this" {
  application_id   = databricks_service_principal.sp.application_id
  comment          = "PAT on behalf of ${databricks_service_principal.sp.display_name}"
  lifetime_seconds = 3600
}

output "obo_token_value" {
  value     = databricks_obo_token.this.token_value
  sensitive = true
}

Schritt 4: Anwenden der Konfiguration

Initialisieren, Anwenden und Abrufen des Tokens aus dem setup/ Verzeichnis:

terraform init
terraform apply
terraform output -raw obo_token_value

Schritt 5: Vorbereiten von Variablen für Teil 2

Erstellen Sie eine terraform.tfvars Datei im git-credentials/ Verzeichnis mit dem OBO-Token und anderen erforderlichen Werten:

databricks_host           = "https://<your-workspace>.cloud.databricks.com"
obo_token_value           = "<token from previous step>"
git_username              = "<your-git-username>"
git_provider              = "<gitHub|gitLab|azureDevOpsServices|...>"
git_personal_access_token = "<your-git-PAT>"
repo_url                  = "https://github.com/<your-org>/<your-repo>.git"

Note

Fügen Sie terraform.tfvars Ihrer .gitignore Datei hinzu, um zu vermeiden, dass vertrauliche Werte in die Versionskontrolle gelangen. Terraform liest diese Datei automatisch, wenn Sie terraform apply ausführen.

Teil 2: Konfigurieren von Git-Anmeldeinformationen

Erstellen Sie ein separates git-credentials/ Verzeichnis mit einer eigenen main.tf Datei.

Schritt 1: Deklarieren des Anbieters und der Variablen

Übergeben Sie das OBO-Token aus der Konfigurationsausgabe obo_token_value, um sich als setup/ Service Principal zu authentifizieren.

terraform {
  required_providers {
    databricks = {
      source = "databricks/databricks"
    }
  }
}

variable "databricks_host" {}

variable "obo_token_value" {
  sensitive = true
}

variable "git_username" {}
variable "git_provider" {}

variable "git_personal_access_token" {
  sensitive = true
}

variable "repo_url" {}

provider "databricks" {
  alias = "sp"
  host  = var.databricks_host
  token = var.obo_token_value
}

Schritt 2: Konfigurieren von Git-Anmeldeinformationen

Legen Sie die Git-Anmeldeinformationen fest, die der Service Principal für den Zugriff auf Ihr Git-Repository verwendet.

resource "databricks_git_credential" "sp" {
  provider              = databricks.sp
  git_username          = var.git_username
  git_provider          = var.git_provider
  personal_access_token = var.git_personal_access_token
}

Schritt 3: Erstellen des Git-Ordners

resource "databricks_repo" "this" {
  provider   = databricks.sp
  url        = var.repo_url
  depends_on = [databricks_git_credential.sp]
}

Schritt 4: Anwenden der Konfiguration von Git-Anmeldeinformationen

Initialisieren und anwenden Sie aus dem git-credentials/ Verzeichnis:

terraform init
terraform apply

Authentifizierung mit einem Dienstkonto und Verbundanmeldeinformationen

Bei Azure DevOps Repositorys können Sie sich mit Verbundidentitätsanmeldeinformationen authentifizieren, ohne langlebige geheime Schlüssel zu speichern. Bei diesem Ansatz wird ein Dienstprinzipal mit einem von Azure DevOps Pipelines ausgestellten OIDC-Token verwendet, wodurch die Notwendigkeit von persönlichen Zugriffstoken beseitigt wird.

Voraussetzungen

Konfigurieren Sie vor dem Einrichten der Verbundidentitätsauthentifizierung für Azure Databricks Git-Ordner die folgenden Komponenten:

Schritt 1: Konfigurieren von Variablen

Geben Sie Werte für die folgenden Variablen in einer terraform.tfvars Datei an:

  • databricks_host: Die URL Ihres Azure Databricks-Arbeitsbereichs, z. B. https://adb-123417477717.17.azuredatabricks.net
  • entra_client_id: Die Client-ID des Azure-Dienstprinzipals
  • entra_client_secret: Der geheime Clientschlüssel für den Azure-Dienstprinzipal
  • entra_tenant_id: Die Microsoft Entra-ID, in der der Dienstprinzipal registriert ist
  • ado_repo_url: Die HTTPS-URL des Git-Repositorys in Azure DevOps

Step 2: Konfigurieren des Azure Databricks Anbieters

Verwenden Sie in Ihrer Terraform-Konfiguration den offiziellen databricks Provider. Die Authentifizierung für den Anbieter kann die Standardmethode Ihrer Organisation verwenden, z. B. Umgebungsvariablen in fortlaufender Integration (CI) oder einen Dienstprinzipal, wenn Terraform von einer sicheren Arbeitsstation ausgeführt wird.

terraform {
  required_providers {
    databricks = {
      source = "databricks/databricks"
    }
  }
}

provider "databricks" {
  host                = var.databricks_host
  azure_client_id     = var.entra_client_id
  azure_client_secret = var.entra_client_secret
  azure_tenant_id     = var.entra_tenant_id
}

Schritt 3: Erstellen einer federierten Git-Anmeldeinformation für Azure DevOps

Diese Authentifizierungsdaten sagen Azure Databricks, dass es den Microsoft Entra ID-gestützten Verbund für Azure DevOps verwenden soll.

resource "databricks_git_credential" "sp_ado" {
  git_provider            = "azureDevOpsServicesAad"
  is_default_for_provider = true
}

Step 4: Verweisen sie auf einen Git-Ordner in Ihrem Azure DevOps Repository

Erstellen oder aktualisieren Sie den Git-Ordner, um Ihre Azure DevOps-Repository-URL zu verwenden.

resource "databricks_repo" "this" {
  url        = var.ado_repo_url
  depends_on = [databricks_git_credential.sp_ado]
}
  • Last updated on