Diese Seite wurde von der Cloud Translation API übersetzt.

Verbindung von der Google Kubernetes Engine (GKE) zu AlloyDB for PostgreSQL herstellen

In dieser Anleitung wird beschrieben, wie Sie eine Verbindung von einer in einem Google Kubernetes Engine Autopilot-Cluster ausgeführten Anwendung zu einer AlloyDB-Instanz einrichten.

AlloyDB ist ein vollständig verwalteter, PostgreSQL-kompatibler Datenbankdienst in Google Cloud.

Mit Google Kubernetes Engine können Sie Kubernetes automatisch bereitstellen, skalieren und verwalten.

Ziele

Docker-Image für AlloyDB erstellen
Eine Anwendung in Google Kubernetes Engine ausführen
Mit dem AlloyDB Auth-Proxy und einer internen IP-Adresse eine Verbindung zu einer AlloyDB-Instanz herstellen

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloudverwendet, darunter:

AlloyDB
Google Kubernetes Engine
Artifact Registry

Sie können mithilfe des Preisrechners die Kosten für Ihre voraussichtliche Nutzung kalkulieren.

Hinweise

Console

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Aktivieren Sie die Cloud APIs, die zum Erstellen einer Verbindung zu AlloyDB for PostgreSQL erforderlich sind.

APIs aktivieren
1. Klicken Sie im Schritt Projekt bestätigen auf Weiter, um den Namen des Projekts zu bestätigen, an dem Sie Änderungen vornehmen möchten.
2. Klicken Sie im Schritt APIs aktivieren auf Aktivieren, um Folgendes zu aktivieren:
  - AlloyDB API
  - Artifact Registry API
  - Compute Engine API
  - Cloud Resource Manager API
  - Cloud Build API
  - Container Registry API
  - Kubernetes Engine API
  - Service Networking API

Für diese Anleitung verwenden Sie die Beispiel-Webanwendung gke-alloydb-app, mit der Stimmen gesammelt werden.

Cloud Shell starten

Cloud Shell ist eine Shell-Umgebung für die Verwaltung von Ressourcen, die inGoogle Cloudgehostet werden.

Die Google Cloud CLI und das kubectl-Befehlszeilentool sind in Cloud Shell vorinstalliert. Die gcloud CLI bietet die primäre Befehlszeile für Google Cloud. kubectl ist die primäre Befehlszeile zum Ausführen von Befehlen für Kubernetes-Cluster.

Console

So starten Sie Cloud Shell:

Rufen Sie die Google Cloud Console auf.

Google Cloud Console
Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren.
Klicken Sie im Dialogfeld Cloud Shell autorisieren auf Autorisieren.

In einem Frame im unteren Teil der Console wird eine Cloud Shell-Sitzung geöffnet. Verwenden Sie diese Shell zum Ausführen von gcloud- und kubectl-Befehlen.
1. Bevor Sie Befehle ausführen, legen Sie Ihr Standardprojekt in der Google Cloud CLI mit dem folgenden Befehl fest:
```
gcloud config set project PROJECT_ID
```
  Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

AlloyDB-Cluster und primäre Instanz erstellen

Ihr AlloyDB-Cluster besteht aus mehreren Knoten in einer Google Virtual Private Cloud (VPC). Wenn Sie einen Cluster erstellen, konfigurieren Sie auch den Zugriff auf private Dienste zwischen einer Ihrer VPCs und der von Google verwalteten VPC, die Ihren neuen Cluster enthält. Wir empfehlen, einen internen IP-Zugriff zu verwenden, um zu vermeiden, dass die Datenbank im öffentlichen Internet zugänglich ist.

Wenn Sie von außerhalb der konfigurierten VPC eine Verbindung zu einem AlloyDB für PostgreSQL-Cluster herstellen möchten, konfigurieren Sie den Zugriff auf private Dienste in der VPC für AlloyDB und verwenden Sie das Standard-VPC-Netzwerk, um Abfragen von einer Anwendung auszuführen, die in einem GKE-Cluster bereitgestellt wird.

gcloud

Prüfen Sie in Cloud Shell, ob der Bereich der nicht verwendeten IP-Adressen (IPv4) bereits dem Service-Peering zugewiesen ist:
```
gcloud services vpc-peerings list --network=default
```
Überspringen Sie den nächsten Schritt, wenn Ihre Ausgabe so aussieht:
```
network: projects/493573376485/global/networks/default
peering: servicenetworking-googleapis-com
reservedPeeringRanges:
- default-ip-range
service: services/servicenetworking.googleapis.com
```
In dieser Ausgabe ist der Wert von reservedPeeringRanges default-ip-range. Diesen Wert können Sie als IP_RANGE_NAME verwenden, um in Schritt 3 eine private Verbindung zu erstellen.
(Überspringen Sie diesen Schritt, wenn Sie den Standardwert reservedPeeringRanges verwenden.) Verwenden Sie den folgenden Befehl, um nicht verwendete IP-Adressen in der VPC zuzuweisen:
```
gcloud compute addresses create IP_RANGE_NAME \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=16 \
    --description="VPC private service access" \
    --network=default
```
Ersetzen Sie IP_RANGE_NAME durch einen Namen für verfügbare interne IP-Adressen in einem AlloyDB-Subnetz, z. B. alloydb-gke-psa-01.

Führen Sie den folgenden Befehl aus, um den Dienstzugriff über den zugewiesenen IP-Bereich zu konfigurieren:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=IP_RANGE_NAME \
    --network=default

Führen Sie den folgenden Befehl aus, um den AlloyDB-Cluster bereitzustellen:
```
gcloud alloydb clusters create CLUSTER_ID \
    --database-version=POSTGRES_VERSION \
    --password=CLUSTER_PASSWORD \
    --network=default \
    --region=REGION \
    --project=PROJECT_ID
```
Ersetzen Sie Folgendes:
- CLUSTER_ID: die ID des Clusters, den Sie erstellen. Er muss mit einem Kleinbuchstaben beginnen und kann Kleinbuchstaben, Ziffern und Bindestriche enthalten, z. B. alloydb-cluster.
- VERSION: die Hauptversion von PostgreSQL, mit der die Datenbankserver des Clusters kompatibel sein sollen. Wählen Sie eine der folgenden Optionen aus:
  - 14: für die Kompatibilität mit PostgreSQL 14
  - 15: für die Kompatibilität mit PostgreSQL 15
  - 16: zur Kompatibilität mit PostgreSQL 16, der unterstützten Standardversion von PostgreSQL.
  - 17: für die Kompatibilität mit PostgreSQL 17
- CLUSTER_PASSWORD: Das Passwort für den Standardnutzer postgres.
- PROJECT_ID: die ID Ihres Google Cloud Projekts, in dem Sie den Cluster platzieren möchten.
- REGION: Der Name der Region, in der der AlloyDB-Cluster erstellt wird, z. B. us-central1.
Führen Sie den folgenden Befehl aus, um die primäre AlloyDB-Instanz bereitzustellen:
```
gcloud alloydb instances create INSTANCE_ID \
    --instance-type=PRIMARY \
    --cpu-count=NUM_CPU \
    --region=REGION \
    --cluster=CLUSTER_ID \
    --project=PROJECT_ID
```
Ersetzen Sie Folgendes:
- INSTANCE_ID durch den Namen der AlloyDB-Instanz Ihrer Wahl, z. B. alloydb-primary.
- CLUSTER_ID durch den Namen des AlloyDB-Clusters, z. B. alloydb-cluster.
- NUM_CPU durch die Anzahl der virtuellen Verarbeitungseinheiten, z. B. 2.
- PROJECT_ID durch die ID Ihres Google Cloud -Projekts.
- Ersetzen Sie REGION durch den Namen der Region, in der der AlloyDB-Cluster erstellt wird, z. B. us-central1.
Warten Sie, bis die AlloyDB-Instanz erstellt wurde. Dieser Vorgang kann einige Minuten dauern.

Verbindung zur primären Instanz herstellen und eine AlloyDB-Datenbank und einen Nutzer erstellen

Console

Wenn Sie sich nicht auf der Seite Übersicht des neu erstellten Clusters befinden, rufen Sie in der Google Cloud Console die Seite Cluster auf.

Zu den Clustern
Klicken Sie auf den Clusternamen CLUSTER_ID, um die Übersichtsseite des Clusters aufzurufen.
Klicken Sie im Navigationsmenü auf AlloyDB Studio.
Führen Sie auf der Seite In AlloyDB Studio anmelden folgende Schritte aus:
1. Wählen Sie in der Liste Datenbank die Option postgres aus.
2. Wählen Sie in der Liste Nutzer die Option postgres aus.
3. Geben Sie im Feld Passwort das CLUSTER_PASSWORD ein, das Sie unter AlloyDB-Cluster und primäre Instanz erstellen erstellt haben.
4. Klicken Sie auf Authentifizieren. Im Bereich Explorer wird eine Liste der Objekte in Ihrer Datenbank angezeigt.
Führen Sie auf dem Tab Editor 1 die folgenden Schritte aus:
1. AlloyDB-Datenbank erstellen:
```
CREATE DATABASE DATABASE_NAME;
```
  Ersetzen Sie DATABASE_NAME durch einen Namen Ihrer Wahl, z. B. tutorial_db.
2. Klicken Sie auf Ausführen. Warten Sie, bis die Meldung Statement executed successfully im Bereich Ergebnisse angezeigt wird.
3. Klicken Sie auf Löschen.
4. Erstellen Sie einen AlloyDB-Datenbanknutzer und ein Passwort:
```
CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';
```
  Ersetzen Sie Folgendes:
  - USERNAME: der Name des AlloyDB-Nutzers, z. B. tutorial_user.
  - DATABASE_PASSWORD: Das Passwort für Ihre AlloyDB-Datenbank, z. B. tutorial.
5. Klicken Sie auf Ausführen. Warten Sie, bis die Meldung Statement executed successfully im Bereich Ergebnisse angezeigt wird.
Klicken Sie im Bereich Explorer von AlloyDB Studio auf Nutzer/Datenbank wechseln.
Führen Sie auf der Seite In AlloyDB Studio anmelden folgende Schritte aus:
1. Wählen Sie in der Liste Datenbank die Option DATABASE_NAME aus, z. B. tutorial_db.
2. Wählen Sie in der Liste Nutzer die Option postgres aus.
3. Geben Sie im Feld Passwort das CLUSTER_PASSWORD ein, das Sie unter AlloyDB-Cluster und primäre Instanz erstellen erstellt haben.
4. Klicken Sie auf Authentifizieren. Im Bereich Explorer wird eine Liste der Objekte in Ihrer Datenbank angezeigt.
Führen Sie auf dem Tab Editor 1 die folgenden Schritte aus:
1. Gewähren Sie dem AlloyDB-Datenbanknutzer alle Berechtigungen:
```
GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";
```
2. Klicken Sie auf Ausführen. Warten Sie, bis die Meldung Statement executed successfully im Bereich Ergebnisse angezeigt wird.
3. Klicken Sie auf Löschen.
4. Berechtigungen für den AlloyDB-Datenbanknutzer für das öffentliche Schema erteilen:
```
GRANT CREATE ON SCHEMA public TO "USERNAME";
```
5. Klicken Sie auf Ausführen. Warten Sie, bis die Meldung Statement executed successfully im Bereich Ergebnisse angezeigt wird.
Notieren Sie sich den Datenbanknamen, den Nutzernamen und das Passwort. Sie verwenden diese Informationen in Kubernetes-Secret erstellen.

Erstellen Sie einen GKE Autopilot-Cluster

Ein Cluster enthält mindestens eine Maschine mit der Cluster-Steuerungsebene und mehrere Worker-Maschinen, die Knoten genannt werden. Knoten sind Compute Engine-VM-Instanzen, auf denen die erforderlichen Kubernetes-Prozesse ausgeführt werden, um die Knoten in den Cluster einzubinden. In diesem Fall stellen Sie Anwendungen für Cluster bereit und die Anwendungen werden auf den Knoten ausgeführt.

Console

Rufen Sie in der Google Cloud Console die Seite Kubernetes-Cluster auf.

Zu „Kubernetes-Cluster“
Klicken Sie auf Erstellen.
Geben Sie für Ihren Autopilot-Cluster auf der Seite Clustergrundlagen im Feld Name GKE_CLUSTER_ID an, z. B. ap-cluster.
Wählen Sie im Feld Region die Option REGION aus, z. B. us-central1.
Klicken Sie auf Erstellen.

Warten Sie, bis der GKE-Cluster erstellt wurde. Dieser Vorgang kann einige Minuten dauern.

gcloud

Autopilot-Cluster erstellen:

gcloud container clusters create-auto GKE_CLUSTER_ID \
    --location=REGION

Ersetzen Sie Folgendes:

GKE_CLUSTER_ID: Der Name des Autopilot-Clusters, z. B. ap-cluster.
REGION: Der Name der Region, in der der GKE-Cluster bereitgestellt wird, z. B. us-central1.

Warten Sie, bis der GKE-Cluster erstellt wurde. Dieser Vorgang kann einige Minuten dauern.

Verbindung zu AlloyDB mit dem AlloyDB Auth-Proxy herstellen

Wir empfehlen, für die Verbindung zu AlloyDB den AlloyDB Auth-Proxy zu verwenden. Der AlloyDB Auth-Proxy bietet eine starke Verschlüsselung und Authentifizierung mit Identity and Access Management (IAM), wodurch die Sicherheit Ihrer Datenbank gewährleistet werden kann.

Wenn Sie eine Verbindung über den AlloyDB Auth-Proxy herstellen, wird er mithilfe des Containermusters sidecar zu Ihrem Pod hinzugefügt. Der AlloyDB Auth-Proxy-Container befindet sich im selben Pod wie Ihre Anwendung, sodass die Anwendung mithilfe von localhost eine Verbindung zum AlloyDB Auth-Proxy herstellen kann, wodurch Sicherheit und Leistung erhöht werden.

Rollen für Google-Dienstkonten erstellen und zuweisen

In Google Cloudverwenden Anwendungen Dienstkonten für autorisierte API-Aufrufe, indem sie sich als Dienstkonto selbst authentifizieren. Wenn sich eine Anwendung als Dienstkonto authentifiziert, hat sie Zugriff auf alle Ressourcen, auf die das Dienstkonto Zugriff hat.

Um den AlloyDB Auth-Proxy in Google Kubernetes Engine auszuführen, erstellen Sie ein Google-Dienstkonto für Ihre Anwendung. Wir empfehlen, für jede Anwendung ein eigenes Dienstkonto zu erstellen, anstatt überall dasselbe Dienstkonto zu verwenden. Dieses Modell ist sicherer, da Sie damit Berechtigungen auf Anwendungsbasis beschränken können.

Console

Rufen Sie in der Google Cloud Console die Seite IAM auf.

IAM aufrufen
Suchen Sie auf der Seite Berechtigungen für Projekt „PROJECT_ID“ die Zeile mit dem Standarddienstkonto von Compute PROJECT_NUMBER-compute@developer.gserviceaccount.com und klicken Sie in dieser Zeile auf Hauptkonto bearbeiten.

So rufen Sie die PROJECT_NUMBER ab, die eine automatisch generierte eindeutige Kennung für Ihr Projekt ist:
1. Rufen Sie in der Google Cloud Console die Seite Dashboard auf.
  
  Zum Dashboard
2. Klicken Sie oben auf der Seite auf das Drop-down Auswählen aus. Wählen Sie im angezeigten Fenster Auswählen aus Ihr Projekt aus.
Die PROJECT_NUMBER wird auf der Dashboard-Karte Projektinformationen des Projekts angezeigt.
Klicken Sie auf Weitere Rolle hinzufügen.
Wenn Sie die Rolle roles/artifactregistry.reader zuweisen möchten, klicken Sie auf Rolle auswählen, wählen Sie Artifact Registry unter Nach Produkt oder Dienst und Artifact Registry Reader unter Rollen aus.
Klicken Sie auf Speichern. Dem Hauptkonto wird die Rolle zugewiesen.
Wenn Sie ein Dienstkonto für die GKE-Beispielanwendung erstellen möchten, rufen Sie die Seite Dienstkonten auf. Zur Seite „Dienstkonten“
Wählen Sie Ihr Projekt aus.
Klicken Sie auf der Seite Dienstkonten für das Projekt „PROJECT_ID“ auf Dienstkonto erstellen.
Geben Sie im Abschnitt Dienstkontodetails der Seite Dienstkonto erstellen im Feld Name des Dienstkontos GSA_NAME ein, z. B. gke-alloydb-gsa.
Klicken Sie auf Erstellen und fortfahren.

Der Bereich Diesem Dienstkonto Zugriff auf das Projekt gewähren (optional) der Seite Dienstkonto erstellen wird angezeigt.
So weisen Sie die Rolle roles/alloydb.client zu:
1. Klicken Sie auf Rolle auswählen.
2. Wählen Sie unter Nach Produkt oder Dienst die Option Cloud AlloyDB aus.
3. Wählen Sie unter Rollen die Option Cloud AlloyDB Client aus.
Klicken Sie auf Weitere Rolle hinzufügen.
Wenn Sie die Rolle roles/serviceusage.serviceUsageConsumer zuweisen möchten, klicken Sie auf Rolle auswählen, wählen Sie Service Usage unter Nach Produkt oder Dienst und Service Usage Consumer unter Rollen aus.
Klicken Sie auf Fertig. Dem Google-Dienstkonto werden Rollen zugewiesen.

gcloud

Führen Sie Folgendes aus, um dem Standarddienstkonto von Google die erforderlichen Berechtigungen zu erteilen, damit Compute Engine aus der Artifact Registry lesen kann:

PROGECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding PROJECT_ID  --member="serviceAccount:$PROGECT_NUM-compute@developer.gserviceaccount.com"  --role="roles/artifactregistry.reader"

So erstellen Sie ein Google-Dienstkonto für Ihre Anwendung:
```
gcloud iam service-accounts create GSA_NAME \
--display-name="gke-tutorial-service-account"
```
Ersetzen Sie GSA_NAME durch den Namen Ihres neuen IAM-Dienstkontos, z. B. gke-alloydb-gsa.

Verwenden Sie die folgenden Befehle, um Ihrem Anwendungs-GSA die Rollen alloydb.client und serviceusage.serviceUsageConsumer zuzuweisen:

gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/alloydb.client"
gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/serviceusage.serviceUsageConsumer"

Workload Identity Federation for GKE für die Beispielanwendung konfigurieren

Sie müssen GKE so konfigurieren, dass das Dienstkonto für den AlloyDB Auth-Proxy über die Funktion Workload Identity Federation for GKE bereitgestellt wird. Mit dieser Methode können Sie ein Kubernetes-Dienstkonto an ein Google-Dienstkonto binden. Das Google-Dienstkonto ist dann für Anwendungen zugänglich, die das entsprechende Kubernetes-Dienstkonto verwenden.

Ein Google-Dienstkonto ist eine IAM-Identität, die Ihre Anwendung in Google Clouddarstellt. Ein Kubernetes-Dienstkonto ist eine Identität, die Ihre Anwendung in einem Google Kubernetes Engine-Cluster darstellt.

Mit der Workload Identity-Föderation für GKE wird ein Kubernetes-Dienstkonto an ein Google-Dienstkonto gebunden. Durch diese Bindung werden alle Bereitstellungen mit diesem Kubernetes-Dienstkonto bei der Interaktion mit Google Cloudals Google-Dienstkonto authentifiziert.

gcloud

Öffnen Sie Cloud Shell in der Google Cloud Console.

Cloud Shell öffnen
Rufen Sie in Cloud Shell die Anmeldedaten für Ihren Cluster ab:
```
gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID
```
Mit diesem Befehl wird kubectl für die Verwendung des von Ihnen erstellten GKE-Clusters konfiguriert.
Führen Sie im Editor Ihrer Wahl die folgenden Schritte aus:
1. Öffnen Sie service-account.yaml mit Nano, z. B.:
```
nano service-account.yaml
```
2. Fügen Sie im Editor Folgendes ein:
```
  apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: KSA_NAME
```
  Ersetzen Sie KSA_NAME durch den Namen des Dienstkontos, z. B. ksa-alloydb.
3. Drücken Sie Strg + O, die EINGABETASTE, um die Änderungen zu speichern, und dann Strg + X, um den Editor zu beenden.
Erstellen Sie ein Kubernetes-Dienstkonto für Ihre Beispielanwendung:
```
kubectl apply -f service-account.yaml
```

Gewähren Sie Ihrem Kubernetes-Dienstkonto Berechtigungen, um die Identität des Google-Dienstkontos anzunehmen. Erstellen Sie dazu eine IAM-Richtlinienbindung zwischen den beiden Dienstkonten:

gcloud iam service-accounts add-iam-policy-binding \
   --role="roles/iam.workloadIdentityUser" \
   --member="serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]" \
   GSA_NAME@PROJECT_ID.iam.gserviceaccount.com

Fügen Sie dem Kubernetes-Dienstkonto unter Verwendung der E-Mail-Adresse des Google-Dienstkontos die Annotation iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID hinzu:
```
kubectl annotate serviceaccount \
  KSA_NAME \
  iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
```

Artifact Registry mit einem Image der Beispielanwendung füllen

gcloud

Klonen Sie in Cloud Shell das Repository mit dem Beispielcode für die gke-alloydb-app-Anwendung von GitHub:

 git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go

Erstellen Sie in Artifact Registry ein Repository für Docker-Images:
```
gcloud artifacts repositories create REPOSITORY_ID --location REGION --repository-format=docker --project PROJECT_ID
```
Ersetzen Sie Folgendes:
- PROJECT_ID: die Projekt-ID.
- REPOSITORY_ID: der Name Ihres Repositorys, z. B. gke-alloydb-sample-app.
Klicken Sie im Dialogfeld Cloud Shell autorisieren auf Autorisieren. Diese Aufforderung wird nicht angezeigt, wenn Sie diesen Schritt bereits ausgeführt haben.
Verwenden Sie den folgenden Befehl, um einen Docker-Container zu erstellen und in Artifact Registry zu veröffentlichen:
```
 gcloud builds submit --tag  REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID
```
Ersetzen Sie Folgendes:
- PROJECT_ID: die Projekt-ID.
- REPOSITORY_ID: der Name Ihres Repositorys, z. B. gke-alloydb-sample-app.
- SAMPLE_APPLICATION: Der Name Ihrer Beispiel-Webanwendung, z. B. gke-alloydb-app.

Kubernetes-Secret erstellen

Sie erstellen Kubernetes-Secrets für die Datenbank, den Nutzer und das Nutzerpasswort, die von der Beispielanwendung verwendet werden sollen. Die Werte der einzelnen Secrets basieren auf den Werten, die im Schritt Verbindung zur primären Instanz herstellen und AlloyDB-Datenbank und -Nutzer erstellen dieser Anleitung angegeben wurden. Weitere Informationen finden Sie unter Secrets.

gcloud

Verwenden Sie ein Kubernetes-SECRET, z. B. gke-alloydb-secret, um die Verbindungsinformationen zu speichern:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

AlloyDB-Proxy in einem Sidecar-Muster bereitstellen und ausführen

Wir empfehlen, den AlloyDB-Proxy in einem sidecar-Muster als zusätzlichen Container auszuführen, der einen Pod mit Ihrer Anwendung teilt. Das hat folgende Gründe:

Verhindert, dass SQL-Traffic lokal verfügbar gemacht wird. Der AlloyDB-Proxy bietet die Möglichkeit, ausgehende Verbindungen zu verschlüsseln, aber Sie sollten die Sichtbarkeit für eingehende Verbindungen einschränken.
Verhindert einen Single Point of Failure. Der Zugriff jeder Anwendung auf Ihre Datenbank ist unabhängig von den anderen, was die Ausfallsicherheit erhöht.
Beschränkt den Zugriff auf den AlloyDB-Proxy, sodass Sie IAM-Berechtigungen pro Anwendung verwenden können, anstatt die Datenbank für den gesamten Cluster freizugeben.
Ermöglicht eine genauere Bestimmung von Ressourcenanfragen. Da der AlloyDB-Proxy Ressourcen linear zur Nutzung verbraucht, können Sie mit diesem Muster Ressourcen genauer bestimmen und entsprechend der Skalierung Ihrer Anwendungen anfordern.
Ermöglicht es Ihnen, Ihre Anwendung so zu konfigurieren, dass eine Verbindung über 127.0.0.1 auf dem DB_PORT hergestellt wird, den Sie im Befehlsbereich angegeben haben.

Nachdem Sie einen GKE-Cluster erstellt und ein Container-Image für Ihre Anwendung erstellt haben, stellen Sie die containerisierte Anwendung im GKE-Cluster bereit.

gcloud

In dieser Anleitung stellen Sie die Beispiel-Webanwendung gke-alloydb-app bereit, mit der Stimmen gesammelt werden. AlloyDB wird dabei als Datenspeicher verwendet.

Rufen Sie die Instanzverbindung INSTANCE_URI für die primäre AlloyDB-Instanz ab, mit der der AlloyDB-Proxy eine Verbindung herstellen soll:
```
   gcloud alloydb instances describe INSTANCE_ID \
   --cluster=CLUSTER_ID \
   --region=REGION \
   --format="value(name)"
```
Ersetzen Sie Folgendes:
- INSTANCE_ID: Name für die Instanz, z. B. alloydb-primary.
- CLUSTER_ID: Name für den Cluster, z. B. alloydb-cluster.
Die Ausgabe enthält die INSTANCE_URI, die Sie in der proxy_sidecar_deployment.yaml-Definitionsdatei in Schritt 2b dieses Abschnitts angeben.

Führen Sie im Editor Ihrer Wahl, z. B. nano, die folgenden Schritte aus:

Öffnen Sie proxy_sidecar_deployment.yaml mit dem Editor Ihrer Wahl, z. B. nano:
```
nano proxy_sidecar_deployment.yaml
```

Fügen Sie im Editor Folgendes ein:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KSA_NAME
      containers:
      - name: SAMPLE_APPLICATION
        # Replace <PROJECT_ID> and <REGION> with your project ID and region.
        image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
        imagePullPolicy: Always
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        # This project uses environment variables to determine
        # how you would like to run your application
        # To use the Go connector (recommended) - use INSTANCE NAME 
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        # To use Automatic IAM Authentication (recommended)
        # use DB_IAM_USER instead of DB_USER
        # you may also remove the DB_PASS environment variable
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: username
        - name: DB_PASS
          valueFrom:
           secretKeyRef:
              name: SECRET
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: database
     # If you are using the Go connector (recommended), you can
      # remove alloydb-proxy (everything below this line)
      - name: alloydb-proxy
        # This uses the latest version of the AlloyDB Auth proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/alloydb-auth-proxy
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        command:
          - "/alloydb-auth-proxy"
          #AlloyDB instance name as parameter for the AlloyDB proxy
          # Use <INSTANCE_URI> 
          - "INSTANCE_URI"
        securityContext:
          # The default AlloyDB Auth proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

Ersetzen Sie INSTANCE_URI durch den Pfad zu Ihrer primären AlloyDB-Instanz aus Schritt 1, z. B. projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_ID/instances/INSTANCE_ID.

Drücken Sie Strg + O, die EINGABETASTE, um die Änderungen zu speichern, und dann Strg + X, um den Editor zu beenden.

Um die gke-alloydb-app-Anwendung bereitzustellen, wenden Sie die proxy_sidecar_deployment.yaml-Definitionsdatei an, die Sie im vorherigen Schritt erstellt haben:
```
kubectl apply -f proxy_sidecar_deployment.yaml
```

Prüfen Sie, ob der Status beider Container im Pod running lautet:

kubectl get pods

Beispielausgabe:

 NAME                          READY   STATUS    RESTARTS   AGE
 gke-alloydb-8d59bb4cc-62xgh   2/2     Running   0          2m53s

Um eine Verbindung zur gke-alloydb-app-Beispielanwendung herzustellen, verwenden Sie einen Dienst, z. B. einen externen HTTP-Load-Balancer. Gehen Sie im Editor Ihrer Wahl so vor:
1. Öffnen Sie service.yaml mit Nano, z. B.:
```
nano service.yaml
```
2. Fügen Sie im Nano-Editor den folgenden Inhalt ein:
```
apiVersion: v1
kind: Service
metadata:
  name: SAMPLE_APPLICATION
spec:
  type: LoadBalancer
  selector:
    app: SAMPLE_APPLICATION
  ports:
  - port: 80
    targetPort: 8080
```
  Ersetzen Sie SAMPLE_APPLICATION durch den Namen Ihrer Beispielwebanwendung, z. B. gke-alloydb-app.
3. Drücken Sie Strg + O, die EINGABETASTE, um die Änderungen zu speichern, und dann Strg + X, um den Editor zu beenden.
Um die gke-alloydb-app-Anwendung des Dienstes bereitzustellen, wenden Sie die service.yaml-Datei an:
```
 kubectl apply -f service.yaml
```

Verwenden Sie den folgenden Befehl, um die Dienstdetails einschließlich der externen IP-Adresse des Dienstes abzurufen:

kubectl get service

Beispielausgabe:

NAME              TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
gke-alloydb-app   LoadBalancer   34.118.229.246   35.188.16.172   80:32712/TCP   45s
kubernetes        ClusterIP      34.118.224.1     <none>          443/TCP        85m

Verwenden Sie die externe IP-Adresse aus dem vorherigen Schritt, um über die folgende URL auf die Beispielanwendung zuzugreifen:
```
http://EXTERNAL-IP
```

Musterkonfigurationsdateien

proxy_sidecar_deployment.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <YOUR-DEPLOYMENT-NAME>
spec:
  selector:
    matchLabels:
      app: <YOUR-APPLICATION-NAME>
  template:
    metadata:
      labels:
        app: <YOUR-APPLICATION-NAME>
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      # Your application container goes here.
      - name: <YOUR-APPLICATION-NAME>
        image: <YOUR-APPLICATION-IMAGE-URL>
        env:
        - name: DB_HOST
          # The port value here (5432) should match the --port flag below.
          value: "localhost:5342"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: username
        - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: database
      # The Auth Proxy sidecar goes here.
      - name: alloydb-auth-proxy
        # Make sure you have automation that upgrades this version regularly.
        # A new version of the Proxy is released monthly with bug fixes,
        # security updates, and new features.
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        args:
          # If you're connecting over public IP, enable this flag.
          # - "--public-ip"

          # If you're connecting with PSC, enable this flag:
          # - "--psc"

          # If you're using auto IAM authentication, enable this flag:
          # - "--auto-iam-authn"

          # Enable structured logging with Google's LogEntry format:
          - "--structured-logs"

          # Listen on localhost:5432 by default.
          - "--port=5432"
          # Specify your instance URI, e.g.,
          # "projects/myproject/locations/us-central1/clusters/mycluster/instances/myinstance"
          - "<INSTANCE-URI>"

        securityContext:
          # The default AlloyDB Auth Proxy image runs as the "nonroot" user and
          # group (uid: 65532) by default.
          runAsNonRoot: true
        # You should use resource requests/limits as a best practice to prevent
        # pods from consuming too many resources and affecting the execution of
        # other pods. You should adjust the following values based on what your
        # application needs. For details, see
        # https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

service.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: v1
kind: Service
metadata:
  name: <YOUR-SERVICE-NAME>
spec:
  type: LoadBalancer
  selector:
    app: <YOUR-APPLICATION-NAME>
  ports:
  - port: 80
    targetPort: 8080

service-account.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: v1
kind: ServiceAccount
metadata:
  name: <YOUR-KSA-NAME> # TODO(developer): replace this value

Bereinigen

Damit Ihrem Google Cloud -Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, können Sie entweder das Projekt löschen, das die Ressourcen enthält, oder das Projekt beibehalten und die einzelnen Ressourcen löschen.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten durch Löschen des für die Anleitung erstellten Projekts.

So löschen Sie das Projekt:

Wechseln Sie in der Google Cloud -Console zur Seite Ressourcen verwalten.

Ressourcen verwalten
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie auf Löschen.
Geben Sie im Dialogfeld PROJECT_ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.

Verbindung von der Google Kubernetes Engine (GKE) zu AlloyDB for PostgreSQL herstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Ziele

Kosten

Hinweise

Console

Cloud Shell starten

Console

AlloyDB-Cluster und primäre Instanz erstellen

gcloud

Verbindung zur primären Instanz herstellen und eine AlloyDB-Datenbank und einen Nutzer erstellen

Console

Erstellen Sie einen GKE Autopilot-Cluster

Console

gcloud

Verbindung zu AlloyDB mit dem AlloyDB Auth-Proxy herstellen

Rollen für Google-Dienstkonten erstellen und zuweisen

Console

gcloud

Workload Identity Federation for GKE für die Beispielanwendung konfigurieren

gcloud

Artifact Registry mit einem Image der Beispielanwendung füllen

gcloud

Kubernetes-Secret erstellen

gcloud

AlloyDB-Proxy in einem Sidecar-Muster bereitstellen und ausführen

gcloud

Musterkonfigurationsdateien

proxy_sidecar_deployment.yaml

service.yaml

service-account.yaml

Bereinigen

Projekt löschen

Nächste Schritte

Verbindung von der Google Kubernetes Engine (GKE) zu AlloyDB for PostgreSQL herstellen