GCP-Databricks- und HashiCorp-Vault-Integration
Warum Databricks auf GCP ein Tool wie HashiCorp Vault braucht
Die moderne Datenlandschaft stellt komplexe Sicherheitsherausforderungen, die anspruchsvolle Lösungen für das Secrets-Management erfordern. Databricks auf der Google Cloud Platform bietet zwar leistungsstarke Datenverarbeitungsfähigkeiten, doch Organisationen stehen vor erheblichen Hürden beim Credential-Management, die Tools wie HashiCorp Vault für umfassende Sicherheit verlangen.
Die Herausforderung des Credential-Managements
Databricks-Umgebungen auf GCP schaffen einen perfekten Sturm für die Komplexität des Secrets-Managements. Organisationen verwalten typischerweise Hunderte oder Tausende sensibler Credentials über mehrere Umgebungen hinweg – Development, Staging und Produktion –, die jeweils Zugriff auf verschiedene externe Dienste benötigen. Das führt zu Secrets-Sprawl, bei dem sensible Daten über verschiedene Plattformen verstreut sind und sich nur schwer nachverfolgen, sichern und wirksam verwalten lassen.
Der kollaborative Charakter von Databricks verschärft diese Herausforderungen. Data Engineers, Data Scientists und Analysten teilen häufig Notebooks und Code, was das Risiko einer versehentlichen Credential-Preisgabe erhöht. Ohne geeignete Schutzmaßnahmen können sensible Informationen wie API-Schlüssel, Datenbankpasswörter und Service-Account-Tokens leicht über geteilte Repositories oder kollaborative Workspaces durchsickern.
Sicherheitslücken in Standardkonfigurationen
Aktuelle Sicherheitsforschung hat kritische Schwachstellen in Databricks-Plattformkonfigurationen offengelegt. Forscher entdeckten, dass Nutzer mit geringen Rechten die Cluster-Isolation durchbrechen und Remote Code Execution auf allen Clustern eines Workspace erlangen konnten. Solche Angriffe können zu Credential-Diebstahl führen – bis hin zur Möglichkeit, Administrator-API-Tokens abzugreifen und Berechtigungen auf Workspace-Administrator-Ebene zu eskalieren.
Die Standardkonfiguration des Databricks File System (DBFS) birgt besondere Risiken, da es für jeden Nutzer eines Workspace zugänglich ist – wodurch alle gespeicherten Dateien für jeden mit Zugriff sichtbar sind. Das eröffnet böswilligen Akteuren die Möglichkeit, Cluster-Initialisierungsskripte zu verändern und dauerhaften Zugriff auf sensible Credentials zu etablieren.
Grenzen des nativen Databricks-Secrets-Managements
Databricks auf Google Cloud bietet zwar Secret-Speicherung als Databricks Scoped Secrets oder Databricks Secrets, gestützt auf GCP secret manager/ Azure KeyVault als native Lösung an, doch diese hat erhebliche Grenzen, wenn sie in komplexe Databricks-Workflows integriert wird. Der GCP Secret Manager ist eng an das GCP-Ökosystem gekoppelt, was ein konsistentes Secrets-Management über Multi-Cloud- oder Hybrid-Umgebungen hinweg erschwert. Organisationen, die Databricks nutzen, müssen oft mit diversen externen Diensten, Datenbanken und APIs integrieren, die nicht Google-Cloud-nativ sind. Zudem ist er über ein öffentliches Netzwerk erreichbar. Auch feingranularer Zugriff ist eine Herausforderung.
Und warum sollten Sie Azure KeyVault überhaupt mit GCP-Databricks integrieren wollen, wenn Sie auf GCP sind 😀.
HashiCorp Vault: die strategische Lösung
HashiCorp Vault begegnet diesen Herausforderungen mit mehreren Kernfähigkeiten, die für Databricks auf GCP besonders wertvoll sind:
Dynamische Secrets-Generierung
Die Google-Cloud-Secrets-Engine von Vault generiert temporäre, kurzlebige GCP-IAM-Credentials, die automatisch ablaufen. Das beseitigt die Sicherheitsrisiken langlebiger statischer Credentials und verkleinert das Zeitfenster für möglichen Credential-Missbrauch erheblich. Für KI-Workloads auf GCP, einschließlich solcher auf Databricks, ist dieser dynamische Ansatz entscheidend, um Sicherheit zu wahren und zugleich automatisierte Datenverarbeitung zu ermöglichen.
Zentralisiertes Secrets-Management
Vault bietet eine einheitliche Control Plane für die Verwaltung von Secrets über verschiedene Umgebungen und Plattformen hinweg. Diese Zentralisierung löst das Secrets-Sprawl-Problem, indem alle sensiblen Daten an einem einzigen, sicheren Ort mit umfassenden Zugriffskontrollen gespeichert werden. Entwicklungsteams können Secrets programmatisch abrufen, ohne sie in Notebooks oder Konfigurationsdateien hartzukodieren.
Erweiterte Zugriffskontrolle und Auditing
Vault implementiert feingranulare Zugriffsrichtlinien, die sich nach Rollen, Umgebungen und konkreten Anwendungsfällen anpassen lassen. Jeder Secret-Zugriff wird protokolliert und ist auditierbar und liefert die forensische Spur, die für Compliance und die Reaktion auf Sicherheitsvorfälle nötig ist. Das ist besonders wichtig in Databricks-Umgebungen, in denen Data Governance und regulatorische Compliance zentrale Anforderungen sind.
Unterstützung für Workload Identity Federation (optional)
Vault unterstützt nun Workload Identity Federation (WIF) mit Google Cloud und ermöglicht eine sichere Authentifizierung, ohne langlebige Service-Account-Credentials zu benötigen. Diese Integration minimiert Credential-Sprawl und etabliert eine Vertrauensbeziehung zwischen Vault und GCP-Diensten, was Sicherheitsbedenken im Zusammenhang mit manuell erstellten Service Accounts reduziert.
Implementierung
Legen wir los: Hier habe ich die Konfiguration in Terraform und Bash-CLI bereitgestellt – Sie können aber auch jede andere Methode verwenden.
Hinweis: Shared Databricks-Cluster werden nicht unterstützt, nur dedizierte Cluster wie Personal- oder Job-Cluster.
Schritt 1: Konfigurationen auf GCP: Erstellen Sie einen SA und vergeben Sie die Berechtigungen project.viewer und serviceaccount.admin
$ export GCP_PROJECT=<Your GCP project>
$ gcloud services enable --project "${GCP_PROJECT}" \
cloudresourcemanager.googleapis.com \
iam.googleapis.com
$ gcloud iam service-accounts create sa-vault \
--display-name "Vault Authenticator SA" \
--project "${GCP_PROJECT}"
$ gcloud projects add-iam-policy-binding \
"${GCP_PROJECT}" --member \
"serviceAccount:sa-vault@${GCP_PROJECT}.iam.gserviceaccount.com" \
--role "roles/viewer"
$ gcloud projects add-iam-policy-binding \
"${GCP_PROJECT}" --member \
"serviceAccount:sa-vault@${GCP_PROJECT}.iam.gserviceaccount.com" \
--role "roles/iam.serviceAccountKeyAdmin"
$ gcloud projects add-iam-policy-binding \
"${GCP_PROJECT}" --member \
"serviceAccount:sa-vault@${GCP_PROJECT}.iam.gserviceaccount.com" \
--role "roles/iam.serviceAccountTokenCreator"
$ gcloud iam service-accounts keys create sa-vault.json \
--iam-account "sa-vault@${GCP_PROJECT}.iam.gserviceaccount.com"Schritt 2: Konfigurationen auf Vault: Ich habe Terraform verwendet, Sie können aber auch Bash/CLI nutzen.
terraform {
required_providers {
vault = {
source = "hashicorp/vault"
version = "~> 5.0.0"
}
}
}
provider "vault" {
address = "Your vault address"
# This is the configuration to run it locally with azuread auth - it will
# automatically login using a browser
# You can use some other auth method for vault as well
auth_login_oidc {
role = "azuread"
mount = "azuread"
}
}
variable "gcp_sa_admins" {
description = "List of GCP Sevice accounts for Vault admin role"
type = list(string)
default = [ "" ]
}
variable "gcp_sa_contributors" {
description = "List of GCP Sevice accounts for Vault contributor role"
type = list(string)
default = [ "" ]
}
variable "gcp_databricks_project" {
description = "List of GCP Sevice accounts for Vault contributor role"
type = list(string)
default = [ "" ]
}
resource "vault_gcp_auth_backend" "gcp" {
credentials = sa-vault.json
#Using all defaults, but you can customize
}
resource "vault_mount" "gcp" {
path = "gcp"
type = "kv"
options = { version = "2" }
}
resource "vault_kv_secret_backend_v2" "gcp" {
mount = vault_mount.gcp.path
max_versions = 0
delete_version_after = 0
cas_required = false
}
resource "vault_kv_secret_v2" "example_secret" {
mount = vault_mount.gcp.path
name = "common/example"
data_json = jsonencode({
"example_secret" = "some-value"
})
}
resource "vault_policy" "admin" {
name = "admin"
policy = <<-EOF
path "*" {
capabilities = ["create", "read", "update", "delete", "list", "sudo"]
}
EOF
}
resource "vault_gcp_auth_backend_role" "gce" {
role = "gcp-vault-admin"
type = "iam"
backend = vault_gcp_auth_backend.gcp.path
bound_service_accounts = var.gcp_sa_admins
token_policies = [vault_policy.admin.name]
max_jwt_exp = "30m"
}
resource "vault_policy" "vault_contributors" {
for_each = var.use_cases
name = "gcp/policies/gcp/databricks/contributors"
policy = <<EOF
path "gcp/data/databricks/*" {
capabilities = ["create", "read", "update", "delete", "list"]
}
path "gcp/metadata/databricks/*" {
capabilities = ["list"]
}
path "gcp/metadata/" {
capabilities = ["list"]
}
EOF
}
resource "vault_gcp_auth_backend_role" "gce" {
role = "vault-databrick-contributors"
type = "gce"
bound_projects = var.gcp_databricks_project
backend = vault_auth_backend.gcp.path
bound_service_accounts = var.gcp_sa_contributors
token_policies = [vault_policy.vault_contributors.name]
} Schritt 3: Konfiguration am Databricks-Cluster: Legen Sie den Google Service Account am Databricks-Cluster fest
- Über die UI : Navigieren Sie beim Erstellen des Clusters zu Compute → New compute → Advanced Settings → Google Service Account → <Geben Sie Ihren GCP Service Account ein>
Über Terraform
variable "gcp_sa_contributors" {
description = "List of GCP Sevice accounts for Vault contributor role"
type = list(string)
default = [ "" ]
}
data "databricks_node_type" "smallest" {
local_disk = true
}
data "databricks_spark_version" "latest_lts" {
long_term_support = true
}
resource "databricks_cluster" "shared_autoscaling" {
cluster_name = "Shared Autoscaling"
spark_version = data.databricks_spark_version.latest_lts.id
node_type_id = data.databricks_node_type.smallest.id
autotermination_minutes = 20
autoscale {
min_workers = 1
max_workers = 10
}
gcp_attributes {
google_service_account = var.gcp_sa_contributors
}
}Schritt 4: Zugriff auf Secrets aus Vault – aus einem Databricks-Notebook oder -Job, der mit einem dedizierten Cluster verbunden ist
Unten sehen Sie einen Beispiel-Python-Notebook-Code für den Zugriff auf Secrets; ich empfehle, eine Python-Bibliothek zu schreiben, um die Nutzung zu optimieren.
pip install hvac requests import requests
import hvac
def login_to_vault_with_gcp(role, vault_url):
# GCP metadata endpoint for the service account token
metadata_url = "http://metadata/computeMetadata/v1/instance/service-accounts/default/identity"
# Request the JWT token from the metadata server
headers = {"Metadata-Flavor": "Google"}
params = {"audience": f"http://vault/{role}", "format": "full"}
try:
jwt_token = requests.get(metadata_url, headers=headers, params=params).text
except requests.RequestException as e:
raise Exception(f"Failed to get JWT token: {e}")
# Log into Vault using the GCP method
client = hvac.Client(url=vault_url)
login_response = client.auth.gcp.login(role=role, jwt=jwt_token)
if 'auth' in login_response and 'client_token' in login_response['auth']:
print("Login successful")
client.token = login_response['auth']['client_token']
return client
else:
print("Login failed:", login_response)
return None
def list_secrets(client, path):
try:
list_response = client.secrets.kv.v2.list_secrets(mount_point=mount, path=path)
list_response = client.secrets.kv.v2.list_secrets(mount_point=mount, path=path)
print('The following paths and secrets are available under the path prefix: {keys}'.format(
keys=','.join(list_response['data']['keys']),
))
except hvac.exceptions.InvalidRequest as e:
print(f"Invalid request: {e}")
except hvac.exceptions.Forbidden as e:
print(f"Access denied: {e}")
except Exception as e:
print(f"An error occurred: {e}")
def create_secrets(client,mount, path,secretname):
try:
client.secrets.kv.v2.create_or_update_secret(mount_point=mount, path=path+"/"+secretname,secret=dict(mysecretkey='mysecretvalue'))
except hvac.exceptions.InvalidRequest as e:
print(f"Invalid request: {e}")
except hvac.exceptions.Forbidden as e:
print(f"Access denied: {e}")
except Exception as e:
print(f"An error occurred: {e}")
if __name__ == "__main__":
vault_url = "https://vault.com" # Replace with your vault hostname
role = "vault-databrick-contributors"
mount= "gcp" # Base path
path = "databricks" # Specify the path to list secrets
secretname = "test1"
# Log in to Vault and get the client
client = login_to_vault_with_gcp(role, vault_url)
print(client.token)
if client:
create_secrets(client,mount,path,secretname)
list_secrets(client, path)Fazit: Die Zukunft sicherer Datenplattformen
Die Integration von HashiCorp Vault mit Databricks auf GCP steht für eine entscheidende Evolution der Sicherheit von Datenplattformen. Da Organisationen mit zunehmend raffinierten Bedrohungen und strengen Compliance-Anforderungen konfrontiert sind, reichen traditionelle Ansätze des Credential-Managements nicht mehr aus.
HCP Vault Secrets und fortschrittliche Funktionen wie Vault Radar erweitern die Fähigkeiten des Security-Lifecycle-Managements und ermöglichen es Organisationen, nicht verwaltete Secrets über ihre gesamte IT-Landschaft hinweg aufzuspüren, zu beheben und zu verhindern. Diese Tools helfen, Credentials aufzufinden und abzusichern, die Entwickler oft unsicher in Quellcode, Konfigurationsdateien und Kollaborationsplattformen ablegen.
Die in dieser Implementierung gezeigten Architekturmuster bieten ein Fundament für sichere, skalierbare Datenoperationen, die mit den Anforderungen Ihrer Organisation wachsen können. Durch die Einführung dynamischer Secrets, zentralisierter Verwaltung und umfassenden Auditings können sich Teams darauf konzentrieren, Wert aus ihren Daten zu ziehen, statt Sicherheitslücken zu verwalten.
Der sichere Weg wird zum einfachen Weg, wenn Organisationen in geeignetes Tooling und Architekturmuster investieren. Während sich Cloud-Datenplattformen weiterentwickeln, wird die Integration von Secrets-Management auf Enterprise-Niveau nicht nur zur Best Practice, sondern zur grundlegenden Anforderung für jeden ernsthaften Datenbetrieb.
Schreiben Sie uns gerne eine Nachricht an support@insight42.com, wenn Sie Fragen oder Anmerkungen haben.