Gestire le cartelle Git di Azure Databricks con Terraform

Gestire Azure Databricks cartelle Git in un ambiente completamente automatizzato usando Terraform e il provider Databricks Terraform.

Questo argomento illustra due approcci di autenticazione:

  • Autenticazione del token di accesso personale (PAT): Usa i token di accesso personale Git per l'accesso al repository
  • Entità servizio con credenziali federate: Usa le entità servizio di Azure con token OpenID Connect (OIDC) per l'autenticazione sicura senza token nei repository Di Azure DevOps

Autenticazione con token di accesso personali

Questo approccio utilizza i token di accesso personalizzato Git per l'autenticazione del repository con un servizio principale.

Terraform valuta le configurazioni del provider prima di creare qualsiasi risorsa, quindi non è possibile fare riferimento a un valore di risorsa (ad esempio un token su mandato (OBO)) in un blocco del provider all'interno della stessa Configurazione di Terraform. Per ovviare a questa limitazione, suddividere l'installazione in due configurazioni separate:

  • Parte 1: Creare il principale del servizio: Crea il principale del servizio e genera un token OBO.
  • Parte 2: Configurare le credenziali Git: usa il token OBO per l'autenticazione come entità servizio, quindi configura le credenziali Git e crea la cartella Git.

Parte 1: Creare l'entità servizio principale

Creare una setup/ directory con un main.tf file.

Passaggio 1: Dichiarare il provider e le variabili

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
}

Passaggio 2: Crea il principale del servizio

Scegliere un nome da visualizzare per il principale del servizio. Terraform lo crea usando questo nome.

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

Passaggio 3: Creare ed esportare il token di autorizzazione

Generare un token OBO per il principale del servizio ed esportarlo per l'utilizzo nella configurazione successiva.

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
}

Passaggio 4: Applicare la configurazione

Dalla directory setup/, inizializza, applica e recupera il token:

terraform init
terraform apply
terraform output -raw obo_token_value

Passaggio 5: Preparare le variabili per la parte 2

Creare un terraform.tfvars file nella git-credentials/ directory con il token OBO e altri valori obbligatori:

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

Aggiungi terraform.tfvars al file .gitignore per evitare di eseguire il commit di valori sensibili al controllo di versione. Terraform legge automaticamente questo file quando si esegue terraform apply.

Parte 2: Configurare le credenziali Git

Creare una directory separata git-credentials/ con il relativo file main.tf.

Passaggio 1: Dichiarare il provider e le variabili

Fornire il token OBO dall'output di configurazione come obo_token_value per autenticare come entità servizio.

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
}

Passaggio 2: Configurare le credenziali Git

Configura le credenziali Git che l'entità del servizio utilizzerà per accedere al tuo repository Git.

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
}

Passaggio 3: Creare la cartella Git

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

Passaggio 4: Applicare la configurazione delle credenziali Git

Dalla directory git-credentials/, inizializza e applica:

terraform init
terraform apply

Autenticazione con un service principal e credenziali federate

Per Azure DevOps repository, le credenziali di identità federate consentono di eseguire l'autenticazione senza archiviare segreti di lunga durata. Questo approccio usa un'entità servizio con un token OIDC rilasciato dalle pipeline di Azure DevOps, eliminando la necessità di token di accesso personali.

Prerequisiti

Prima di configurare l'autenticazione dell'identità federata per Azure Databricks cartelle Git, configurare i componenti seguenti:

Passaggio 1: Configurare le variabili

Specificare i valori per le variabili seguenti in un terraform.tfvars file:

  • databricks_host: URL dell'area di lavoro di Azure Databricks, ad esempio https://adb-123417477717.17.azuredatabricks.net
  • entra_client_id: ID del client principale del servizio Azure
  • entra_client_secret: segreto del client per il principale del servizio di Azure
  • entra_tenant_id: ID Microsoft Entra in cui è registrata l'entità servizio
  • ado_repo_url: URL HTTPS del Git repository in Azure DevOps

P 2: Configurare il provider di Azure Databricks

Nella configurazione di Terraform usare il provider ufficiale databricks . L'autenticazione per il provider può usare il metodo standard dell'organizzazione, ad esempio le variabili di ambiente nell'integrazione continua (CI) o un'entità servizio quando si esegue Terraform da una workstation sicura.

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
}

P 3: Creare una credenziale Git federata per Azure DevOps

Questa credenziale indica Azure Databricks di usare la federazione supportata da Microsoft Entra ID per Azure DevOps.

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

Fase 4: Puntare una cartella Git su il repository Azure DevOps

Creare o aggiornare la cartella Git per usare l'URL del repository Azure DevOps.

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