Codelab zu Trusted Space

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 Trusted Space, einem Angebot, das eine starke Operator-Isolation und Unterstützung von Beschleunigern 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, indem dafür gesorgt wird, dass Ihre Arbeitslasten in einer sicheren, vertrauenswürdigen Umgebung ausgeführt werden, auf die nicht einmal der Arbeitslastoperator Zugriff hat.

Das bietet Trusted Space:

• Höherer Datenschutz und mehr Sicherheit:Trusted Space bietet eine vertrauenswürdige Ausführungsumgebung, in der Ihre vertraulichen Assets (z.B. Modelle, wertvolle Daten und Schlüssel) durch kryptografische Beweise geschützt bleiben.
• Operator-Isolation:Beseitigen Sie Bedenken hinsichtlich der Einmischung von Mitarbeitenden. Mit Trusted Space haben auch Ihre Arbeitslastoperatoren keinen Zugriff. Sie können also keine SSH-Verbindung herstellen, auf Daten zugreifen, Software installieren oder Ihren Code manipulieren.
• Unterstützung von Beschleunigern:Trusted Space ist für die nahtlose Zusammenarbeit mit einer Vielzahl von Hardwarebeschleunigern konzipiert, darunter GPUs wie H100, A100, T4 und L4. So wird sichergestellt, dass Ihre leistungsrelevanten KI-/ML-Anwendungen reibungslos ausgeführt werden.

Lerninhalte

• Sie lernen die wichtigsten Funktionen von Trusted Space kennen.
• Hier erfahren Sie, wie Sie eine Trusted Space-Umgebung bereitstellen und konfigurieren, um wertvolle Assets Ihrer KI-/ML-Arbeitslast zu schützen.

Voraussetzungen

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

Schutz sensibler Prompts zur Codegenerierung mit Primus Company

In diesem Codelab schlüpfen wir in die Rolle von Primus, einem Unternehmen, das den Schutz und die Sicherheit der Daten seiner Mitarbeiter in den Vordergrund stellt. Primus möchte ein Modell zur Code-Generierung bereitstellen, um seine Entwickler bei ihren Programmieraufgaben zu unterstützen. Sie möchten jedoch die Vertraulichkeit der von ihren Mitarbeitern eingereichten Prompts schützen, da diese häufig vertrauliche Code-Snippets, interne Projektdetails oder proprietäre Algorithmen enthalten.

Warum vertraut die Primus Company dem Operator nicht?

Primus Corp ist in einem hart umkämpften Markt tätig. Ihre Codebasis enthält wertvolles geistiges Eigentum, darunter proprietäre Algorithmen und sensible Code-Snippets, die einen Wettbewerbsvorteil bieten. Sie befürchten, dass Arbeitslastbetreiber Betriebsspionage betreiben könnten. Außerdem können Mitarbeiter-Prompts vertrauliche „Need-to-know“-Teile des Codes 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, die Daten entschlüsseln und auf den Nur-Text-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 Beispielclientanwendung mit Umschlagverschlüsselung.
• Operator Isolation:Nur der Inferenzserver, der in einer Trusted Space-Umgebung ausgeführt wird, hat Zugriff auf den für die Verschlüsselung verwendeten Schlüssel 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 Arbeitslastbetreiber auf den für die Verschlüsselung verwendeten Schlüssel und die entschlüsselten Inhalte zugreifen.
• Sichere Inferenz mit Beschleunigern: Der Inferenzserver wird auf einer Shielded VM gestartet (im Rahmen der Einrichtung des vertrauenswürdigen Bereichs). So wird sichergestellt, 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 aus 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 Skripts 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 Umgebungsvariablen für das Projekt wie unten gezeigt festgelegt haben. Weitere Informationen zum Einrichten eines GCP-Projekts finden Sie in diesem Codelab. Hier finden Sie weitere Informationen dazu, 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 auch vorhandene Ressourcen verwenden, sofern sie bereits erstellt wurden. (z. B. export PRIMUS_SERVICE_ACCOUNT='my-service-account')

1. Sie können die folgenden Variablen mit vorhandenen Cloud-Ressourcennamen 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. Dies sind die unterstützten Variablen für Ressourcennamen:

$PRIMUS_PROJECT_REGION	Region, unter der regionale Ressourcen für das Primus-Unternehmen erstellt werden.
$PRIMUS_SERVICE_LOCATION	Standort, an dem Ressourcen für das Unternehmen Primus erstellt werden.
$PRIMUS_PROJECT_ZONE	Zone, in der zonale Ressourcen für das Unternehmen Primus erstellt werden.
$PRIMUS_WORKLOAD_IDENTITY_POOL	Workload Identity-Pool von Primus zum Schutz der Cloud-Ressourcen.
$PRIMUS_WIP_PROVIDER	Der Anbieter des Workload Identity-Pools von Primus, der die Autorisierungsbedingung für die Verwendung von Tokens enthält, 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 sie die Berechtigung, die im Bucket $PRIMUS_INPUT_STORAGE_BUCKET gespeicherten Kundendaten anzusehen.
$PRIMUS_ENC_KEY	Der KMS-Schlüssel wird verwendet, um die von Mitarbeitern des Unternehmens Primus bereitgestellten Prompts zu verschlüsseln.
$PRIMUS_ENC_KEYRING	Der KMS-Schlüsselbund, der zum Erstellen des Verschlüsselungsschlüssels $PRIMUS_ENC_KEY für das Unternehmen Primus verwendet 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 übertragen wird.
$PRIMUS_PROJECT_REPOSITORY_REGION	Die Region für das Artefakt-Repository, in dem das veröffentlichte Docker-Image für die Arbeitslast gespeichert wird.
$WORKLOAD_VM	Name der Arbeitslast-VM.
$WORKLOAD_IMAGE_NAME	Name des Docker-Images für die Arbeitslast.
$WORKLOAD_IMAGE_TAG	Tag des Arbeitslastcontainer-Images.
$WORKLOAD_SERVICEACCOUNT	Das Dienstkonto, das die Berechtigung hat, auf die Confidential VM zuzugreifen, 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 vom $CLIENT_VM verwendete Dienstkonto

• Sie benötigen die Rollen „Storage-Administrator“, „Artifact Registry-Administrator“, „Cloud KMS-Administrator“, „Dienstkonto-Administrator“ und „IAM Workload Identity-Pooladministrator“ für das Projekt $PRIMUS_PROJECT_ID. In dieser Anleitung erfahren Sie, wie Sie IAM-Rollen über die GCP Console zuweisen.
• Führen Sie für $PRIMUS_PROJECT_ID das folgende Skript aus, um die verbleibenden Variablennamen auf Werte basierend auf Ihrer Projekt-ID für Ressourcennamen festzulegen.

source config_env.sh

Hinweis:Für eine nahtlose Nutzung empfiehlt es sich, Cloud Shell für dieses Codelab zu verwenden. Wenn Sie ein reguläres Terminal verwenden, müssen Sie diesen Schritt noch einmal ausführen, wenn Sie das Terminal schließen und sich wieder anmelden. Cloud Shell stellt automatisch wieder eine Verbindung her.

Primus Company-Ressourcen 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 Skriptausfü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) zum Validieren von Ansprüchen basierend auf Attributbedingungen, die unter dem zugehörigen Anbieter konfiguriert sind.
• Das Dienstkonto ($PRIMUS_SERVICE_ACCOUNT), das dem oben genannten Workload Identity-Pool ($PRIMUS_WORKLOAD_IDENTITY_POOL) zugeordnet ist, hat Zugriff zum Entschlüsseln von Daten mit dem KMS-Schlüssel (mit der Rolle roles/cloudkms.cryptoKeyDecrypter), zum Verschlüsseln von Daten mit dem KMS-Schlüssel (mit der Rolle roles/cloudkms.cryptoKeyEncrypter), zum Lesen von Daten aus dem Cloud Storage-Bucket (mit der Rolle objectViewer) und zum Verbinden des Dienstkontos mit dem Workload Identity-Pool (mit der Rolle roles/iam.workloadIdentityUser).

./setup_primus_resources.sh

Hinweis:Wenn Sie dieses Codelab noch einmal ausführen und bei der Erstellung von KMS-Schlüssel oder Workload Identity-Pools Fehler wie ALREADY_EXISTS auftreten, liegt das wahrscheinlich daran, dass Ressourcen aus früheren Ausführungen vorläufig gelöscht wurden. Da diese Ressourcen 30 Tage lang nicht wiederverwendet werden können, müssen Sie sie mit anderen Namen erstellen.

Verwenden Sie dazu die folgenden Befehle, um neue Namen für den Workload Identity-Pool und den KMS-Schlüssel festzulegen:

export PRIMUS_WORKLOAD_IDENTITY_POOL=<new name of Workload Identity Pool>

export PRIMUS_ENC_KEY=<new name of KMS Key>

Führen Sie dann das Skript ./setup_primus_resources.sh wie zuvor beschrieben noch einmal aus.

3. Arbeitslast erstellen

Dienstkonto für Arbeitslast erstellen

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

Dieses Dienstkonto für Arbeitslasten ($WORKLOAD_SERVICEACCOUNT) hat die folgenden Rollen:

• confidentialcomputing.workloadUser, um ein Attestierungstoken zu erhalten
• logging.logWriter, um Logs 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 von 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. Bei der Ausführung des Workloads wird das CodeGemma-Modell geladen und der Inferenzserver gestartet, der die Codegenerierungsanfragen der Entwickler von Primus verarbeitet.

Bei der Anfrage zur Codegenerierung erhält die Arbeitslast den umschlossenen DEK zusammen mit einem verschlüsselten Prompt. Die Arbeitslast führt dann den KMS-API-Aufruf zum Entschlüsseln des DEK aus und entschlüsselt dann 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 zum Autorisieren der Arbeitslast ausführlicher beschrieben. Sobald der Inferenzserver den entschlüsselten Prompt erhalten hat, generiert er den Code mithilfe eines geladenen Modells und gibt die Antwort zurück.

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

• Erstelle eine Artifact Registry($PRIMUS_ARTIFACT_REGISTRY), die Primus gehört.
• Aktualisieren Sie den Arbeitslastcode mit den erforderlichen Ressourcennamen.
• Erstellen Sie die Inferenzserver-Arbeitslast und erstellen Sie ein Dockerfile zum Erstellen eines Docker-Images des Arbeitslastcodes. Hier finden Sie das Dockerfile, das für dieses Codelab verwendet wird.
• Erstellen Sie das Docker-Image und veröffentlichen Sie es 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

Zur Information finden Sie hier die generate()-Methode der Arbeitslast, die in diesem Codelab erstellt und verwendet wird. Den gesamten Arbeitslastcode 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 autorisieren, auf den KMS-Schlüssel zuzugreifen, der für die Prompt-Verschlüsselung verwendet wird. Die Autorisierung soll auf Attributen der folgenden Ressourcen basieren:

• Was: Code, der überprüft wird
• Wo: Eine sichere Umgebung
• Wer: Ein vertrauenswürdiger Betreiber

Primus verwendet die Workload Identity-Föderation, um eine Zugriffsrichtlinie basierend auf diesen Anforderungen zu erzwingen. Mit der Workload Identity-Föderation können Sie Attributbedingungen angeben. Mit diesen Bedingungen wird eingeschränkt, welche Identitäten sich mit dem Workload Identity-Pool (WIP) authentifizieren können. Sie können den Attestation Verifier Service dem WIP als Workload Identity-Poolanbieter hinzufügen, um Messungen zu präsentieren und die Richtlinie zu erzwingen.

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

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

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 geprüft, ob die Arbeitslast in einer vertrauenswürdigen Umgebung 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 Zusicherungen wie image_digest und image_reference, um die Sicherheit zu erhöhen und die Integrität der ausgeführten Arbeitslast zu gewährleisten.

Arbeitslast ausführen

In diesem Schritt führen wir die Arbeitslast in der Trusted Space-VM aus, an die ein Beschleuniger angehängt ist. Erforderliche TEE-Argumente werden mit dem Metadaten-Flag übergeben. Argumente für den Arbeitslastcontainer werden über den Teil „tee-cmd“ des Flags übergeben. Um die VM für den Arbeitslast 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 einfügen, 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"

Hinweis:Sie können zwei Images für die Instanz verwenden: confidential-space-0-gpupreview-796705b und confidential-space-debug-0-gpupreview-796705b. Sie können eine der beiden verwenden. Der Hauptunterschied besteht darin, dass in confidential-space-0-gpupreview-796705b Dienste deaktiviert sind, sodass der Bediener nicht in die Arbeitslast eingreifen kann. In confidential-space-debug-0-gpupreview-796705b ist SSH aktiviert und der Bediener kann eine SSH-Verbindung zur VM herstellen. So kann der Betreiber Fehler beheben. Der Attestierungsdienst vermerkt jedoch im Attestierungstoken, dass der Debugging-Status aktiviert ist. Sie müssen die VM jedoch anschließend manuell herunterfahren.

Inferenzabfrage ausführen

Nachdem der Inferenzserver für die Arbeitslast erfolgreich gestartet wurde, können Mitarbeiter von Primus Anfragen zur Codeerstellung an den Inferenzserver senden.

Hinweis:Es dauert etwa 8–10 Minuten, bis der Inferenzserver gestartet wird. Warten Sie, bis der Server vollständig bereit ist, bevor Sie die folgenden Befehle ausführen.

In diesem Codelab verwenden wir das folgende Script, um die Clientanwendung einzurichten, die mit dem Inferenzserver interagiert. Führen Sie dieses Skript 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 Beispielclientanwendung in einer virtuellen Python-Umgebung ausführen. In dieser Beispielanwendung wird die Umschlagverschlüsselung mit der Fernet-Bibliothek verwendet. Die spezifischen 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 auf der Client-VM zu aktivieren und die Clientanwendung auszuführen.

source venv/bin/activate

python3 inference_client.py

In der Ausgabe dieser Beispielclientanwendung werden die verschlüsselten und Klartext-Promptanfragen sowie die entsprechenden verschlüsselten und entschlüsselten Antworten angezeigt.

5. Bereinigen

Hier finden Sie das Skript, mit dem die Ressourcen bereinigt werden können, die wir im Rahmen dieses Codelabs erstellt haben. Im Rahmen dieser Bereinigung werden die folgenden Ressourcen gelöscht:

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

./cleanup.sh

Wenn Sie 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.