Diese Seite wurde von der Cloud Translation API übersetzt.

Anwendung mit GKE Autopilot und Cloud Spanner bereitstellen

In dieser Anleitung wird beschrieben, wie Sie eine containerisierte Webanwendung in einem GKE Autopilot-Cluster (Google Kubernetes Engine) bereitstellen und eine Google Spanner-Datenbank im Backend zum Speichern von Daten verwenden. Die Beispielanwendung verwaltet eine Tabelle mit Spielern. Sie können Spieler über die grafische Benutzeroberfläche (GUI) der App hinzufügen und löschen.

Spanner ist ein vollständig verwalteter, global verteilter, horizontal skalierbarer, relationaler Datenbankdienst, der ACID-Transaktionen und SQL-Semantik bietet, ohne Leistung und Hochverfügbarkeit zu beeinträchtigen.

Machen Sie sich vor dem Lesen dieser Seite mit Kubernetes vertraut.

Vorteile von GKE und Spanner

Als Entwickler möchten Sie vielleicht keine Zeit damit verbringen, die Menge an Speicher- und Rechenressourcen zu ermitteln, die Ihre Anwendung benötigt, oder den RAM- und CPU-Verbrauch in Zeiten schwankender Anforderungen vorherzusagen oder sich Sorgen über Anwendungsausfälle bei Spitzenbelastungen zu machen.

Wenn Sie GKE Autopilot als vollständig verwalteten Kubernetes-Dienst und Spanner als vollständig verwalteten Datenbankdienst verwenden, können Sie Apps schneller auf einer stabilen Infrastruktur entwickeln und bereitstellen, die die Konfiguration und Verwaltung von Ressourcen vereinfacht. GKE Autopilot konfiguriert und skaliert die Infrastruktur zum Hosten Ihrer Anwendung, indem Knoten entsprechend den Anforderungen zur Laufzeit zum Cluster hinzugefügt oder entfernt werden. Ebenso kann Spanner dynamisch skaliert werden, ohne dass viel manueller Eingriff erforderlich ist, wenn sich die Speicher- oder Rechenanforderungen ändern.

Nehmen wir an, Sie bringen den nächsten Spiele-Blockbuster auf den Markt, von dem Sie erwarten, dass er sich viral verbreitet und daher in der Einführungswoche viel Traffic erzeugt. Cloud Spanner kann Sie bei diesem rasanten Anstieg des Durchsatzes unterstützen, indem er die Rechenressourcen sofort erhöht, verringert oder neu zuweist und dabei mit GKE Autopilot die maximale Anwendungsverfügbarkeit aufrechterhält.

Spanner konfigurieren

Um Spanner zu konfigurieren, müssen Sie eine Spanner-Instanz und eine Spanner-Datenbank erstellen.

Spanner-Instanz erstellen

Eine Spanner-Instanz ist eine Zuordnung von Ressourcen, die von den in dieser Instanz erstellten Spanner-Datenbanken verwendet werden.

Erstellen Sie eine Spanner-Instanz namens hello-instance mit einer regionalen Konfiguration und einer Rechenkapazität von 100 Verarbeitungseinheiten.

gcloud spanner instances create hello-instance \
    --config=regional-COMPUTE_REGION \
    --description="Spanner sample instance" \
    --processing-units=100

Ersetzen Sie COMPUTE_REGION durch us-west1 für diese Anleitung.

Spanner-Datenbank erstellen

Eine Spanner-Datenbank enthält Ihre Tabellen, Ansichten und Indexe. Eine Datenbank übernimmt Attribute von der übergeordneten Instanz, z. B. Konfiguration (regional oder multiregional), verfügbare Rechenkapazität und Speicher.

Erstellen Sie mit dem GoogleSQL-Dialekt eine Spanner-Datenbank mit dem Namen hello-database und eine Tabelle mit dem Namen Players. Führen Sie die folgende Abfrage in Cloud Shell aus:

gcloud spanner databases create hello-database \
    --instance=hello-instance \
    --database-dialect=GOOGLE_STANDARD_SQL \
    --ddl="CREATE TABLE Players (
        PlayerUuid STRING(36) NOT NULL,
        FirstName STRING(1024),
        LastName STRING(1024),
        BirthDate DATE) PRIMARY KEY(PlayerUuid)"

Erstellen Sie einen GKE Autopilot-Cluster

Nachdem Sie Cloud Spanner konfiguriert haben, erstellen Sie einen Autopilot-Cluster und verwenden die Identitätsföderation für Arbeitslasten für GKE, um auf sichere und verwaltbare Weise auf Ihre Datenbank zuzugreifen.

Erstellen Sie einen Autopilot-Cluster mit dem Namen hello-cluster. Für Autopilot-Cluster ist die Identitätsförderung von Arbeitslasten für GKE standardmäßig aktiviert.

gcloud container clusters create-auto CLUSTER_NAME \
  --location=CONTROL_PLANE_LOCATION

Ersetzen Sie Folgendes:

CLUSTER_NAME: hello-cluster
CONTROL_PLANE_LOCATION: die Compute Engine-Region der Steuerungsebene des Clusters. Verwenden Sie für diese Anleitung dieselbe Region (us-west1), in der Sie die Spanner-Instanz erstellt haben. Wir empfehlen, die Spanner-Instanz und den GKE Autopilot-Cluster in derselben Region zu erstellen, um die Latenz zu reduzieren.

Das Erstellen des Clusters kann bis zu 8–10 Minuten dauern.

Die Ausgabe sieht in etwa so aus:

NAME: hello-cluster
LOCATION: us-west1
MASTER_VERSION: 1.26.5-gke.1200
MASTER_IP: 192.0.2.1
MACHINE_TYPE: e2-medium
NODE_VERSION: 1.26.5-gke.1200
NUM_NODES: 3
STATUS: RUNNING

Cluster für die Verwendung der Identitätsföderation von Arbeitslasten für GKE konfigurieren

Konfigurieren Sie Ihren Cluster für die Authentifizierung bei Google Cloud mit der Identitätsföderation von Arbeitslasten für GKE, bevor Sie die App bereitstellen.

Anmeldedaten abrufen, um auf Ihren Cluster zuzugreifen:
```
gcloud container clusters get-credentials CLUSTER_NAME \
  --location=CONTROL_PLANE_LOCATION
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: hello-cluster
- CONTROL_PLANE_LOCATION: us-west1
Dadurch wird eine kubeconfig-Datei mit den entsprechenden Anmeldedaten und Endpunktinformationen aktualisiert, damit kubectl auf Ihren Cluster verweist.
Erstellen Sie einen Namespace, der für das Kubernetes-Dienstkonto verwendet werden soll. Sie können auch den Standard-Namespace oder einen vorhandenen Namespace verwenden.
```
kubectl create namespace NAMESPACE
```
Ersetzen Sie NAMESPACE durch hello-namespace, den Namen des neuen Namespace, den Sie erstellen.
Erstellen Sie ein Kubernetes-Dienstkonto für die Anwendung:
```
kubectl create serviceaccount KSA_NAME \
  --namespace NAMESPACE
```
Ersetzen Sie Folgendes:
- KSA_NAME: ksa-helloapp ist der Name des neuen Kubernetes-Dienstkontos, das Sie erstellen.
- NAMESPACE: hello-namespace
Erstellen Sie ein IAM-Dienstkonto für Ihre Anwendung:
```
gcloud iam service-accounts create GSA_NAME \
  --project=GSA_PROJECT
```
Ersetzen Sie Folgendes:
- GSA_NAME: gsa-helloapp ist der Name des neuen IAM-Dienstkontos, das Sie erstellen.
- GSA_PROJECT: Ihre Google CloudProjekt-ID. In dieser Anleitung erstellen Sie das IAM-Dienstkonto im selben Google Cloud Projekt, in dem Sie die Beispielanwendung bereitstellen. Daher sind GSA_PROJECT undGoogle Cloud PROJECT_ID identisch.

Fügen Sie eine IAM-Richtlinienbindung für Ihr IAM-Dienstkonto zum Lesen und Schreiben in Spanner hinzu:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member "serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Ersetzen Sie Folgendes:

PROJECT_ID: Ihre Google Cloud Projekt-ID
GSA_NAME: gsa-helloapp

Beispiel:

gcloud projects add-iam-policy-binding my-gcp-project \
  --member "serviceAccount:gsa-helloapp@my-gcp-project.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Erlauben Sie dem Kubernetes-Dienstkonto, die Identität des IAM-Dienstkontos zu übernehmen. Fügen Sie dazu eine IAM-Richtlinienbindung zwischen den beiden Dienstkonten hinzu. Durch diese Bindung kann das Kubernetes-Dienstkonto als IAM-Dienstkonto verwendet werden, sodass das Kubernetes-Dienstkonto Daten in Spanner lesen und schreiben kann.
```
gcloud iam service-accounts add-iam-policy-binding GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"
```
Ersetzen Sie Folgendes:
- GSA_NAME: gsa-helloapp
- GSA_PROJECT: Ihre Google Cloud Projekt-ID
- PROJECT_ID: Ihre Google Cloud Projekt-ID
- NAMESPACE: hello-namespace
- KSA_NAME: ksa-helloapp
Beispiel:
```
gcloud iam service-accounts add-iam-policy-binding gsa-helloapp@my-gcp-project.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:my-gcp-project.svc.id.goog[hello-namespace/ksa-helloapp]"
```
Kennzeichnen Sie das Kubernetes-Dienstkonto mit der E-Mail-Adresse des IAM-Dienstkontos. Dadurch weiß Ihre Beispielanwendung, welches Dienstkonto für den Zugriff auf Google Cloud -Dienste verwendet werden soll. Wenn die App also Google API-Clientbibliotheken für den Zugriff auf Google Cloud -Dienste verwendet, verwendet sie dieses IAM-Dienstkonto.
```
kubectl annotate serviceaccount KSA_NAME \
  --namespace NAMESPACE \
  iam.gke.io/gcp-service-account=GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com
```
Ersetzen Sie Folgendes:
- KSA_NAME: ksa-helloapp
- NAMESPACE: hello-namespace
- GSA_NAME: gsa-helloapp
- GSA_PROJECT: Ihre Google Cloud Projekt-ID
Beispiel:
```
kubectl annotate serviceaccount ksa-helloapp \
  --namespace hello-namespace \
  iam.gke.io/gcp-service-account=gsa-helloapp@my-gcp-project.iam.gserviceaccount.com
```
Hinweis: Wenn die IAM-Bindung nicht vorhanden ist, gewährt diese Annotation allein keinen Zugriff auf den Pod, um die Identität des IAM-Dienstkontos anzunehmen.

Beispielanwendung im Cluster bereitstellen

Nachdem Sie GKE und Spanner mit den erforderlichen Diensten und der Authentifizierung eingerichtet haben, können Sie die Beispielanwendung hello-app-cloud-spanner bereitstellen.

Klonen Sie die Beispielanwendung aus dem GitHub-Repository in Cloud Shell:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

Starten Sie den Cloud Shell-Editor, indem Sie in der Symbolleiste des Terminalfensters auf Editor öffnen klicken.

Weitere Informationen finden Sie unter Übersicht über die Benutzeroberfläche des Cloud Shell-Editors.
Öffnen Sie den Explorer-Bereich des Cloud Shell-Editors und rufen Sie das Verzeichnis kubernetes-engine-samples/databases/hello-app-cloud-spanner/k8s auf.
Öffnen Sie die Datei deployment.yaml und aktualisieren Sie das Feld serviceAccountName, indem Sie <KSA_NAME> durch ksa-helloapp ersetzen, den Namen Ihres Kubernetes-Dienstkontos.

Abbildung 1. Aktualisieren Sie den Namen des Kubernetes-Dienstkontos in der Bereitstellungsdatei.
Schließen Sie den Cloud Shell-Editor und kehren Sie zum Cloud Shell-Terminal zurück.
Wechseln Sie im Cloud Shell-Terminal zum Verzeichnis hello-app-cloud-spanner:
```
cd kubernetes-engine-samples/databases/hello-app-cloud-spanner
```
Stellen Sie die Anwendung bereit:
```
kubectl apply -f k8s/deployment.yaml -n=NAMESPACE
```
Ersetzen Sie NAMESPACE durch hello-namespace.

Warten Sie, bis die Anwendung mit STATUS als Running bereitgestellt wird:

kubectl get pods -n=NAMESPACE --watch

Ersetzen Sie NAMESPACE durch hello-namespace.