Codelab zu Trusted Space

Informationen zu diesem Codelab

Zuletzt aktualisiert: März 7, 2025

Verfasst von Meetrajsinh Vala

1. Übersicht

Möchten Sie die Sicherheit und den Datenschutz Ihrer GPU-beschleunigten Arbeitslasten verbessern? In diesem Codelab erfahren Sie mehr über die Funktionen von Confidential Space, einem Angebot, das eine starke Operatorisolation und Beschleunigerunterstützung für Ihre sensiblen KI-/ML-Arbeitslasten bietet.

Der Schutz wertvoller Daten, Modelle und Schlüssel ist wichtiger denn je. Trusted Space bietet eine Lösung, da Ihre Arbeitslasten in einer sicheren, vertrauenswürdigen Umgebung ausgeführt werden, auf die nicht einmal der Arbeitslastoperator zugreifen kann.

Das bietet Trusted Space:

Erweiterter Datenschutz und mehr Sicherheit: Trusted Space bietet eine vertrauenswürdige Ausführungsumgebung, in der Ihre sensiblen Assets (z.B. Modelle, wertvolle Daten und Schlüssel) durch kryptografische Nachweise geschützt bleiben.
Bedienerisolation:Beseitigt Bedenken hinsichtlich Einmischung durch den Betreiber. Mit Trusted Space haben nicht einmal Ihre Arbeitslastbearbeiter Zugriff. Sie können also nicht per SSH darauf zugreifen, auf Daten zugreifen, Software installieren oder Ihren Code manipulieren.
Beschleunigerunterstützung:Trusted Space ist für die nahtlose Zusammenarbeit mit einer Vielzahl von Hardwarebeschleunigern konzipiert, einschließlich GPUs wie H100, A100, T4 und L4. So wird sichergestellt, dass Ihre leistungskritischen KI/ML-Anwendungen reibungslos funktionieren.

Aufgaben in diesem Lab

Informationen zu den wichtigsten Angeboten von Trusted Space
Informationen zum Bereitstellen und Konfigurieren einer Trusted Space-Umgebung zum Schützen wertvoller Assets Ihrer KI-/ML-Arbeitslast

Voraussetzungen

Google Cloud Platform-Projekt
Grundlegende Kenntnisse der Google Compute Engine und Beschleuniger
Grundlegende Kenntnisse zu Dienstkonten, Schlüsselverwaltung, Workload Identity-Föderation und Attributbedingungen.
Grundlegende Kenntnisse zu Containern und Artifact Registry

Sensible Codegenerierungsaufforderungen mit Primus Company schützen

In diesem Codelab schlüpfen wir in die Rolle von Primus, einem Unternehmen, das den Datenschutz und die Sicherheit der Daten seiner Mitarbeiter priorisiert. Primus möchte ein Codegenerierungsmodell bereitstellen, um seine Entwickler bei ihren Programmieraufgaben zu unterstützen. Sie ist jedoch besorgt, die Vertraulichkeit der von ihren Mitarbeitern eingereichten Vorschläge zu schützen, da diese oft vertrauliche Code-Snippets, interne Projektdetails oder proprietäre Algorithmen enthalten.

Warum vertraut das Primus-Unternehmen dem Betreiber nicht?

Primus Corp. agiert in einem hart umkämpften Markt. Die Codebasis enthält wertvolles geistiges Eigentum, einschließlich proprietärer Algorithmen und sensibler Code-Snippets, die einen Wettbewerbsvorteil bieten. Sie befürchten, dass die Arbeitslast von Personen manipuliert werden könnte, die Spionage betreiben. Außerdem können Mitarbeiteraufforderungen vertrauliche Codeteile mit dem Vermerk „Nur für den internen Gebrauch“ enthalten, die Primus Corp schützen möchte.

Um dieses Problem zu beheben, nutzt Primus Corp. Trusted Space, um den Inferenzserver zu isolieren, auf dem das Modell für die Codegenerierung ausgeführt wird. So funktionierts:

Prompt-Verschlüsselung: Bevor ein Prompt an den Inferenzserver gesendet wird, verschlüsselt jeder Mitarbeiter ihn mit einem KMS-Schlüssel, der von Primus Corp in Google Cloud verwaltet wird. So wird sichergestellt, dass nur die Trusted Space-Umgebung, in der der entsprechende Entschlüsselungsschlüssel verfügbar ist, ihn entschlüsseln und auf den Klartext-Prompt zugreifen kann. In der Praxis kann die clientseitige Verschlüsselung von den verfügbaren Bibliotheken (z.B. tink) übernommen werden. In diesem Codelab verwenden wir diese Beispiel-Clientanwendung mit Umschlagverschlüsselung.
Bedienerisolation: Nur der Inferenzserver, der in einer Trusted Space-Umgebung ausgeführt wird, hat Zugriff auf den Schlüssel, der für die Verschlüsselung verwendet wird, und kann den Prompt in einer vertrauenswürdigen Umgebung entschlüsseln. Der Zugriff auf den Verschlüsselungsschlüssel wird durch den Workload Identity-Pool geschützt. Aufgrund der Isolationsgarantien von Trusted Space kann nicht einmal der Arbeitslast-Betreiber auf den für die Verschlüsselung verwendeten Schlüssel und die entschlüsselten Inhalte zugreifen.
Sichere Inferenz mit Accelerators: Der Inferenzserver wird auf einer Shielded VM gestartet (als Teil der Einrichtung des Trusted Space), wodurch sichergestellt wird, dass die Arbeitslastinstanz nicht durch Malware oder Rootkits auf Boot- oder Kernelebene manipuliert wurde. Dieser Server entschlüsselt den Prompt in der Trusted Space-Umgebung, führt die Inferenz mit dem Modell zur Codegenerierung durch und gibt den generierten Code an den Mitarbeiter zurück.

2. Cloud-Ressourcen einrichten

Hinweis

Klonen Sie dieses Repository mit dem folgenden Befehl, um die erforderlichen Scripts zu erhalten, die in diesem Codelab verwendet werden.

git clone https://github.com/GoogleCloudPlatform/confidential-space.git

Wechseln Sie in das Verzeichnis für dieses Codelab.

cd confidential-space/codelabs/trusted_space_codelab/scripts

Achten Sie darauf, dass Sie die erforderlichen Projektumgebungsvariablen wie unten gezeigt festgelegt haben. Weitere Informationen zum Einrichten eines GCP-Projekts finden Sie in diesem Codelab. In diesem Artikel erfahren Sie, wie Sie die Projekt-ID abrufen und wie sie sich von Projektnamen und Projektnummer unterscheidet.

export PRIMUS_PROJECT_ID=<GCP project id of Primus>

Aktivieren Sie die Abrechnung für Ihre Projekte.
Aktivieren Sie die Confidential Computing API und die folgenden APIs für beide Projekte.

gcloud services enable \
    cloudapis.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudkms.googleapis.com \
    cloudshell.googleapis.com \
    container.googleapis.com \
    containerregistry.googleapis.com \
    iam.googleapis.com \
    confidentialcomputing.googleapis.com

Weisen Sie den Variablen für die oben angegebenen Ressourcennamen mit dem folgenden Befehl Werte zu. Mit diesen Variablen können Sie die Ressourcennamen nach Bedarf anpassen und vorhandene Ressourcen verwenden, falls diese bereits erstellt wurden. (z. B. export PRIMUS_SERVICE_ACCOUNT='my-service-account')

Sie können die folgenden Variablen mit vorhandenen Namen von Cloud-Ressourcen im Primus-Projekt festlegen. Wenn die Variable festgelegt ist, wird die entsprechende vorhandene Cloud-Ressource aus dem Primus-Projekt verwendet. Wenn die Variable nicht festgelegt ist, wird der Name der Cloud-Ressource aus dem Projektnamen generiert und eine neue Cloud-Ressource mit diesem Namen erstellt. Im Folgenden finden Sie die unterstützten Variablen für Ressourcennamen:

`$PRIMUS_PROJECT_REGION`	Region, in der regionale Ressourcen für das Unternehmen Primus erstellt werden.
`$PRIMUS_SERVICE_LOCATION`	Ort, an dem Ressourcen für das Primus-Unternehmen erstellt werden.
`$PRIMUS_PROJECT_ZONE`	Zone, unter der zonale Ressourcen für das Unternehmen Primus erstellt werden.
`$PRIMUS_WORKLOAD_IDENTITY_POOL`	Der Workload Identity-Pool des Unternehmens Primus zum Schutz der Cloud-Ressourcen.
`$PRIMUS_WIP_PROVIDER`	Der Workload Identity-Pool-Anbieter des Primus-Unternehmens, einschließlich der Autorisierungsbedingung für Tokens, die vom Attestation Verifier Service signiert wurden.
`$PRIMUS_SERVICEACCOUNT`	Das Dienstkonto des Unternehmens Primus, das `$PRIMUS_WORKLOAD_IDENTITY_POOL` für den Zugriff auf die geschützten Ressourcen verwendet. In diesem Schritt hat es die Berechtigung, die Kundendaten aufzurufen, die im Bucket `$PRIMUS_INPUT_STORAGE_BUCKET` gespeichert sind.
`$PRIMUS_ENC_KEY`	Der KMS-Schlüssel wird verwendet, um die Prompts zu verschlüsseln, die von Mitarbeitern des Unternehmens Primus bereitgestellt werden.
`$PRIMUS_ENC_KEYRING`	Der KMS-Schlüsselbund, mit dem der Verschlüsselungsschlüssel `$PRIMUS_ENC_KEY` für das Unternehmen Primus erstellt wird.
`$PRIMUS_ENC_KEYVERSION`	Die KMS-Schlüsselversion des Verschlüsselungsschlüssels `$PRIMUS_ENC_KEY`. Der Standardwert ist 1. Aktualisieren Sie diesen Wert, wenn Sie einen vorhandenen Schlüssel verwenden, der in der Vergangenheit rotiert wurde und dessen Version aktualisiert wurde.
`$PRIMUS_ARTIFACT_REPOSITORY`	Das Artefakt-Repository, in das das Docker-Image der Arbeitslast gepusht wird.
`$PRIMUS_PROJECT_REPOSITORY_REGION`	Die Region für das Artefakte-Repository, das das veröffentlichte Docker-Image der Arbeitslast enthält.
`$WORKLOAD_VM`	Name der Arbeitslast-VM.
`$WORKLOAD_IMAGE_NAME`	Name des Docker-Images der Arbeitslast.
`$WORKLOAD_IMAGE_TAG`	Tag des Arbeitslastcontainer-Images.
`$WORKLOAD_SERVICEACCOUNT`	Das Dienstkonto, das auf die vertrauliche VM zugreifen darf, auf der die Arbeitslast ausgeführt wird.
`$CLIENT_VM`	Name der Client-VM, auf der die Clientanwendung des Inferenzservers ausgeführt wird.
`$CLIENT_SERVICEACCOUNT`	Das Dienstkonto, das vom `$CLIENT_VM` verwendet wird

Sie benötigen die Rollen „Speicheradministrator“, „Artifact Registry Administrator“, „Cloud KMS Admin“, „Dienstkontoadministrator“ und „IAM Workload Identity Pool Admin“ für das Projekt $PRIMUS_PROJECT_ID. In dieser Anleitung erfahren Sie, wie Sie IAM-Rollen über die GCP Console gewähren.
Führen Sie für $PRIMUS_PROJECT_ID das folgende Script aus, um die verbleibenden Variablennamen auf Werte basierend auf Ihrer Projekt-ID für Ressourcennamen festzulegen.

source config_env.sh

Primus-Unternehmensressourcen einrichten

In diesem Schritt richten Sie die erforderlichen Cloud-Ressourcen für Primus ein. Führen Sie das folgende Script aus, um die Ressourcen für Primus einzurichten. Im Rahmen der Scriptausführung werden die folgenden Ressourcen erstellt:

Verschlüsselungsschlüssel ($PRIMUS_ENC_KEY) und Schlüsselbund ($PRIMUS_ENC_KEYRING) in KMS zum Verschlüsseln der Kundendatendatei des Unternehmens Primus.
Workload Identity-Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) zur Validierung von Ansprüchen basierend auf Attributebedingungen, die beim Anbieter konfiguriert wurden.
Das Dienstkonto ($PRIMUS_SERVICE_ACCOUNT), das mit dem oben genannten Workload Identity Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) verknüpft ist, hat Zugriff auf die Entschlüsselung von Daten mit dem KMS-Schlüssel (Rolle roles/cloudkms.cryptoKeyDecrypter), die Verschlüsselung von Daten mit dem KMS-Schlüssel (Rolle roles/cloudkms.cryptoKeyEncrypter), das Lesen von Daten aus dem Cloud Storage-Bucket (Rolle objectViewer) und die Verknüpfung des Dienstkontos mit dem Workload Identity Pool (Rolle roles/iam.workloadIdentityUser).

./setup_primus_resources.sh

3. Arbeitslast erstellen

Dienstkonto für Arbeitslast erstellen

Jetzt erstellen Sie ein Dienstkonto für die Arbeitslast mit den erforderlichen Rollen und Berechtigungen. Führen Sie das folgende Script aus, um ein Arbeitslastdienstkonto im Primus-Projekt zu erstellen. Dieses Dienstkonto wird von der VM verwendet, auf der der Inferenzserver ausgeführt wird.

Dieses Workload-Dienstkonto ($WORKLOAD_SERVICEACCOUNT) hat die folgenden Rollen:

confidentialcomputing.workloadUser, um ein Attestierungstoken zu erhalten
logging.logWriter, um Protokolle in Cloud Logging zu schreiben.

./create_workload_service_account.sh

Arbeitslast erstellen

In diesem Schritt erstellen Sie ein Docker-Image für die Arbeitslast. Die Arbeitslast wird vom Unternehmen Primus erstellt. Die in diesem Codelab verwendete Arbeitslast ist Python-Code, der das Codegemma-Modell aus dem öffentlich verfügbaren GCS-Bucket (des Vertex Model Garden) verwendet. Der Workload lädt das Codegemma-Modell und startet den Inferenzserver, der die Codegenerierungsanfragen der Entwickler von Primus bedienen würde.

Bei der Codegenerierungsanfrage erhält Workload die verpackte DEK zusammen mit einem verschlüsselten Prompt. Der Workload ruft dann die KMS API zum Entschlüsseln des DEK auf und entschlüsselt den Prompt mit diesem DEK. Verschlüsselungsschlüssel (für DEK) werden über den Workload Identity-Pool geschützt und der Zugriff wird den Arbeitslasten gewährt, die die Attributbedingungen erfüllen. Diese Attributbedingungen werden im nächsten Abschnitt zur Autorisierung der Arbeitslast ausführlicher beschrieben. Sobald der Inferenzserver den entschlüsselten Prompt hat, generiert er den Code mit einem geladenen Modell und gibt die Antwort zurück.

Führen Sie das folgende Script aus, um eine Arbeitslast zu erstellen, in der die folgenden Schritte ausgeführt werden:

Erstellen Sie eine Artifact Registry($PRIMUS_ARTIFACT_REGISTRY), deren Inhaber Primus ist.
Aktualisieren Sie den Arbeitslastcode mit den Namen der erforderlichen Ressourcen.
Erstellen Sie die Inferenzserver-Arbeitslast und ein Dockerfile zum Erstellen eines Docker-Images des Arbeitslastcodes. Hier finden Sie das Dockerfile, das für dieses Codelab verwendet wird.
Erstellen und veröffentlichen Sie das Docker-Image in der Artifact Registry ($PRIMUS_ARTIFACT_REGISTRY) von Primus.
Gewähren Sie $WORKLOAD_SERVICEACCOUNT die Leseberechtigung für $PRIMUS_ARTIFACT_REGISTRY. Dies ist erforderlich, damit der Arbeitslastcontainer das Docker-Image der Arbeitslast aus der Artifact Registry abrufen kann.

./create_workload.sh

Hier ist zur Information die Methode „generate()“ der Arbeitslast, die in diesem Codelab erstellt und verwendet wird. Den gesamten Code der Arbeitslast finden Sie hier.

def generate():
  try:
    data = request.get_json()
    ciphertext = base64.b64decode(data["ciphertext"])
    wrapped_dek = base64.b64decode(data["wrapped_dek"])
    unwrapped_dek_response = kms_client.decrypt(
        request={"name": key_name, "ciphertext": wrapped_dek}
    )
    unwrapped_dek = unwrapped_dek_response.plaintext
    f = Fernet(unwrapped_dek)
    plaintext = f.decrypt(ciphertext)
    prompt = plaintext.decode("utf-8")
    tokens = tokenizer(prompt, return_tensors="pt")
    outputs = model.generate(**tokens, max_new_tokens=128)
    generated_code = tokenizer.decode(outputs[0])
    generated_code_bytes = generated_code.encode("utf-8")

    response = f.encrypt(generated_code_bytes)
    ciphertext_base64 = base64.b64encode(response).decode("utf-8")
    response = {"generated_code_ciphertext": ciphertext_base64}
    return jsonify(response)

  except (ValueError, TypeError, KeyError) as e:
    return jsonify({"error": str(e)}), 500

4. Arbeitslast autorisieren und ausführen

Arbeitslast autorisieren

Primus möchte Arbeitslasten basierend auf Attributen der folgenden Ressourcen autorisieren, auf ihren KMS-Schlüssel zuzugreifen, der für die sofortige Verschlüsselung verwendet wird:

Was: Code, der bestätigt wurde
Wo: Eine sichere Umgebung
Wer: Ein vertrauenswürdiger Betreiber

Primus verwendet die Workload Identity-Föderation, um eine Zugriffsrichtlinie auf der Grundlage dieser Anforderungen durchzusetzen. Mit der Workload Identity-Föderation können Sie Attributbedingungen angeben. Mit diesen Bedingungen wird eingeschränkt, welche Identitäten sich beim Workload Identity-Pool (WIP) authentifizieren können. Sie können den Attestation Verifier Service dem WIP als Workload Identity-Pool-Anbieter hinzufügen, um Messungen vorzulegen und die Richtlinie durchzusetzen.

Der Workload Identity-Pool wurde bereits im Rahmen der Einrichtung der Cloud-Ressourcen erstellt. Primus erstellt jetzt einen neuen OIDC-Workload Identity-Pool-Anbieter. Die angegebene --attribute-condition autorisiert den Zugriff auf den Arbeitslastcontainer. Dafür sind erforderlich:

Was: Letzte $WORKLOAD_IMAGE_NAME, die in das $PRIMUS_ARTIFACT_REPOSITORY-Repository hochgeladen wurde.
Wo: Die vertrauenswürdige Ausführungsumgebung von Confidential Space wird auf dem vollständig unterstützten VM-Image von Confidential Space ausgeführt.
Wer: Primus-$WORKLOAD_SERVICE_ACCOUNT-Dienstkonto

export WORKLOAD_IMAGE_DIGEST=$(gcloud artifacts docker images describe ${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG  --format="value(image_summary.digest)" --project ${PRIMUS_PROJECT_ID})

gcloud iam workload-identity-pools providers create-oidc $PRIMUS_WIP_PROVIDER \
  --location="global" \
  --project="$PRIMUS_PROJECT_ID" \
  --workload-identity-pool="$PRIMUS_WORKLOAD_IDENTITY_POOL" \
  --issuer-uri="https://confidentialcomputing.googleapis.com/" \
  --allowed-audiences="https://sts.googleapis.com" \
  --attribute-mapping="google.subject='assertion.sub'" \
  --attribute-condition="assertion.swname == 'HARDENED_SHIELDED' && assertion.hwmodel == 'GCP_SHIELDED_VM' && 
assertion.submods.container.image_digest == '${WORKLOAD_IMAGE_DIGEST}' &&
 assertion.submods.container.image_reference == '${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/$PRIMUS_PROJECT_ID/$PRIMUS_ARTIFACT_REPOSITORY/$WORKLOAD_IMAGE_NAME:$WORKLOAD_IMAGE_TAG' && 
'$WORKLOAD_SERVICEACCOUNT@$PRIMUS_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts"

Mit dem obigen Befehl wird überprüft, ob die Arbeitslast in einer Umgebung mit vertrauenswürdigen Bereichen ausgeführt wird. Dazu wird geprüft, ob hwmodel auf „GCP_SHIELDED_VM“ und swname auf „HARDENED_SHIELDED“ festgelegt ist. Außerdem enthält es arbeitslastspezifische Behauptungen wie image_digest und image_reference, um die Sicherheit zu erhöhen und die Integrität der laufenden Arbeitslast zu gewährleisten.

Arbeitslast ausführen

In diesem Schritt führen wir die Arbeitslast in der VM des Trusted Space aus, an die ein Beschleuniger angeschlossen ist. Erforderliche TEE-Argumente werden mit dem Metadata-Flag übergeben. Argumente für den Arbeitslastcontainer werden über den Teil „tee-cmd“ des Flags übergeben. Um die Arbeitslast-VM mit einer Nvidia Tesla T4-GPU auszustatten, verwenden wir das Flag --accelerator=type=nvidia-tesla-t4,count=1. Dadurch wird eine GPU an die VM angehängt. Außerdem müssen wir tee-install-gpu-driver=true in die Metadaten-Flags aufnehmen, um die Installation des entsprechenden GPU-Treibers auszulösen.

gcloud compute instances create ${WORKLOAD_VM} \
  --accelerator=type=nvidia-tesla-t4,count=1 \
  --machine-type=n1-standard-16 \
  --shielded-secure-boot \
  --image-project=conf-space-images-preview \
  --image=confidential-space-0-gpupreview-796705b \
  --zone=${PRIMUS_PROJECT_ZONE} \
  --maintenance-policy=TERMINATE \
  --boot-disk-size=40 \
  --scopes=cloud-platform \
  --service-account=${WORKLOAD_SERVICEACCOUNT}@${PRIMUS_PROJECT_ID}.iam.gserviceaccount.com \
  --metadata="^~^tee-image-reference=${PRIMUS_PROJECT_REPOSITORY_REGION}-docker.pkg.dev/${PRIMUS_PROJECT_ID}/${PRIMUS_ARTIFACT_REPOSITORY}/${WORKLOAD_IMAGE_NAME}:${WORKLOAD_IMAGE_TAG}~tee-install-gpu-driver=true~tee-restart-policy=Never"

Inferenzabfrage ausführen

Nachdem der Inferenzserver für die Arbeitslast erfolgreich gestartet wurde, können Mitarbeiter des Unternehmens Primus jetzt Codegenerierungsanfragen an den Inferenzserver senden.

Im Rahmen dieses Codelabs verwenden wir das folgende Script, um die Clientanwendung einzurichten, die mit dem Inferenzserver interagiert. Führen Sie dieses Script aus, um die Client-VM einzurichten.

./setup_client.sh

In den folgenden Schritten wird gezeigt, wie Sie eine SSH-Verbindung zur Client-VM herstellen und eine Beispiel-Clientanwendung in einer virtuellen Python-Umgebung ausführen. In dieser Beispielanwendung wird die Umschlagverschlüsselung mit der Fernet-Bibliothek verwendet. Die jeweiligen Verschlüsselungsbibliotheken können jedoch an verschiedene Anwendungsfälle angepasst werden.

gcloud compute ssh ${CLIENT_VM} --zone=${PRIMUS_PROJECT_ZONE}

Führen Sie die folgenden Befehle aus, um die virtuelle Python-Umgebung in der Client-VM zu aktivieren und die Clientanwendung auszuführen.

source venv/bin/activate

python3 inference_client.py

Die Ausgabe dieser Beispiel-Clientanwendung zeigt die Verschlüsselungs- und Klartext-Promptanfragen sowie die entsprechenden verschlüsselten und entschlüsselten Antworten.

5. Bereinigen

Hier finden Sie das Script, mit dem Sie die im Rahmen dieses Codelabs erstellten Ressourcen bereinigen können. Im Rahmen dieser Bereinigung werden die folgenden Ressourcen gelöscht:

Primus-Dienstkonto ($PRIMUS_SERVICEACCOUNT)
Primus-Verschlüsselungsschlüssel ($PRIMUS_ENC_KEY)
Artifact-Repository von Primus ($PRIMUS_ARTIFACT_REPOSITORY).
Primus-Workload Identity-Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) mit seinem Anbieter.
Arbeitslastdienstkonto von Primus ($WORKLOAD_SERVICEACCOUNT)
Arbeitslast-VM ($WORKLOAD_VM) und Client-VM ($CLIENT_VM)

./cleanup.sh

Wenn Sie mit der explorativen Datenanalyse fertig sind, sollten Sie Ihr Projekt löschen.

Rufen Sie die Cloud Platform Console auf.
Wählen Sie das Projekt aus, das Sie beenden möchten, und klicken Sie oben auf „Löschen“. Das Projekt wird dann zum Löschen geplant.

Fehler melden