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 GKE Autopilot-Cluster (Google Kubernetes Engine) 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
Verbindung zu einer AlloyDB-Instanz über den AlloyDB Auth-Proxy und eine interne IP-Adresse 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.

Hinweis

Console

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

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 role (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 role (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.

Prüfen Sie, ob Sie die Berechtigungen haben, die für dieses Tutorial erforderlich sind.
Aktivieren Sie die Cloud APIs, die zum Erstellen einer Verbindung zu AlloyDB erforderlich sind.

APIs aktivieren

Klicken Sie im Schritt Projekt bestätigen auf Weiter, um den Namen des Projekts zu bestätigen, an dem Sie Änderungen vornehmen möchten.
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

gcloud

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 role (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 role (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.

Prüfen Sie, ob Sie die Berechtigungen haben, die für dieses Tutorial erforderlich sind.

In dieser Anleitung verwenden Sie die Beispiel-Webanwendung gke-alloydb-app, mit der Stimmen gesammelt werden.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, damit Sie die nötigen Berechtigungen für die Aufgaben in dieser Anleitung haben:

Databases Admin (roles/iam.databasesAdmin)
Administrator für Kubernetes Engine-Cluster (roles/container.clusterAdmin)
Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
Dienstkontoadministrator(roles/iam.serviceAccountAdmin)
Kubernetes Engine-Administrator(roles/container.admin)
Artifact Registry-Administrator(roles/artifactregistry.admin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

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:

Zur Google Cloud Console.

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.

gcloud

So starten Sie Cloud Shell:
Aktivieren Sie Cloud Shell in der Google Cloud Console.

Cloud Shell aktivieren

Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

Um die Umgebung zu initialisieren, 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.

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

gcloud services enable alloydb.googleapis.com \
    compute.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudbuild.googleapis.com \
    containerregistry.googleapis.com \
    servicenetworking.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com

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 verhindern, dass die Datenbank im öffentlichen Internet zugänglich ist.

Wenn Sie von außerhalb der konfigurierten VPC eine Verbindung zu einem AlloyDB for 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.

Console

Zur Clusterseite.

Zu den Clustern
Geben Sie im Bereich Cluster konfigurieren im Feld Cluster-ID eine ID für Ihren Cluster ein. Sie muss mit einem Kleinbuchstaben beginnen und darf Kleinbuchstaben, Ziffern und Bindestriche enthalten, z. B. alloydb-cluster.
Geben Sie im Feld Passwort das CLUSTER_PASSWORD ein, das beim Erstellen des Clusters für den Standarddatenbanknutzer postgres verwendet werden soll.
Wählen Sie im Feld Datenbankversion die Hauptversion POSTGRES_VERSION für Ihren neuen AlloyDB-Cluster aus.
Wählen Sie eine REGION für Ihren Cluster aus, z. B. us-central1.
Führen Sie im Abschnitt Primäre Instanz konfigurieren die folgenden Schritte aus:
1. Geben Sie im Feld Instanz-ID die INSTANCE_ID für Ihre primäre Instanz ein, z. B. alloydb-primary.
2. Wählen Sie eine Maschinenserie aus, z. B. N2.
3. Wählen Sie einen Maschinentyp aus und geben Sie die Anzahl der virtuellen Verarbeitungseinheiten NUM_CPU an, z. B. 2.
4. Damit dem Dienst-Peering ein IP-Bereich zugewiesen wird, konfigurieren Sie die Verbindung für den Zugriff auf private Dienste:
  1. Wählen Sie in der Liste Netzwerk die Option default aus.
  2. Wenn ein IP-Bereich wie default-ip-range bereits reserviert ist, wählen Sie ihn aus der Liste Zugewiesener IP-Bereich aus.
  3. Wenn kein IP-Bereich zugewiesen ist, klicken Sie auf Benutzerdefinierten IP-Bereich zuweisen, um einen neuen internen IP_RANGE_NAME zuzuweisen und die Verbindung zu konfigurieren.
Klicken Sie auf Cluster erstellen.

Warten Sie, bis die AlloyDB-Instanz erstellt wurde. Dieser Vorgang kann einige Minuten dauern.

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. Sie muss mit einem Kleinbuchstaben beginnen und darf 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 Kompatibilität mit PostgreSQL 14
  - 15: für die Kompatibilität mit PostgreSQL 15
  - 16: für die Kompatibilität mit PostgreSQL 16
  - 17: für die Kompatibilität mit PostgreSQL 17, der unterstützten Standardversion von PostgreSQL
  - 18, zur Kompatibilität mit PostgreSQL 18
- 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:
- Ersetzen Sie INSTANCE_ID durch den Namen der gewünschten AlloyDB-Instanz, z. B. alloydb-primary.
- Ersetzen Sie 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 AlloyDB-Nutzer erstellen

Führen Sie die folgenden Schritte aus, um eine Datenbank und einen Datenbanknutzer in Ihrer primären Instanz zu 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.
Gehen Sie auf der Seite In AlloyDB Studio anmelden so vor:
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 in 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. AlloyDB-Datenbanknutzer und ‑Passwort erstellen:
```
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.
Gehen Sie auf der Seite In AlloyDB Studio anmelden so vor:
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 in 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. Gewähren Sie dem AlloyDB-Datenbanknutzer Berechtigungen für das öffentliche Schema:
```
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.

gcloud

Führen Sie in der Cloud Shell den folgenden Befehl aus, um einen AlloyDB-Datenbanknutzer zu erstellen:
```
gcloud alloydb users create USERNAME \
    --cluster=CLUSTER_ID \
    --region=REGION \
    --password=DATABASE_PASSWORD
```
Ersetzen Sie Folgendes:
- USERNAME: Der Name des AlloyDB-Nutzers, z. B. tutorial_user.
- CLUSTER_ID: Die ID des Clusters, z. B. alloydb-cluster.
- REGION: Die Region, in der sich der Cluster befindet, z. B. us-central1.
- DATABASE_PASSWORD: Das Passwort für Ihre AlloyDB-Datenbank, z. B. tutorial.
Wenn Sie eine Datenbank erstellen und Berechtigungen erteilen möchten, müssen Sie eine Verbindung zum Cluster herstellen und SQL-Befehle ausführen. Stellen Sie in Cloud Shell mit dem psql-Client eine Verbindung zur Instanz her.

Hinweis :Wenn Sie über Cloud Shell eine Verbindung zu einer AlloyDB-Instanz herstellen möchten, müssen Sie den AlloyDB Auth-Proxy verwenden. Für eine einfachere Einrichtung können Sie diese Schritte mit AlloyDB Studio in der Google Cloud Console ausführen.
Nachdem Sie als postgres-Nutzer eine Verbindung zu Ihrer Instanz hergestellt haben, erstellen Sie die Datenbank:
```
CREATE DATABASE DATABASE_NAME;
```
Ersetzen Sie DATABASE_NAME durch einen Namen Ihrer Wahl, z. B. tutorial_db.
Gewähren Sie dem AlloyDB-Datenbanknutzer alle Berechtigungen für die neue Datenbank:
```
GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";
```
Stellen Sie eine Verbindung zur neuen Datenbank her und gewähren Sie Berechtigungen für das Schema public:
```
\c DATABASE_NAME
GRANT CREATE ON SCHEMA public TO "USERNAME";
```
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 zu einem Teil des Clusters zu machen. 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 im Feld Name auf der Seite Clustergrundlagen 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 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 Abschnitt 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 Cloud AlloyDB unter Nach Produkt oder Dienst 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.

Console

So starten Sie Cloud Shell:
Aktivieren Sie Cloud Shell in der Google Cloud Console.

Cloud Shell aktivieren

Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

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-Cluster 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
```
Führen Sie die folgenden Schritte in der Google Cloud -Konsole aus, um das Kubernetes-Dienstkonto an das Google-Dienstkonto zu binden:
1. Rufen Sie in der Google Cloud Console die Seite Dienstkonten auf.
  
  Zur Seite „Dienstkonten“
2. Wählen Sie Ihr Projekt aus.
3. Klicken Sie auf den Namen des Google-Dienstkontos GSA_NAME.
4. Klicken Sie auf den Tab Berechtigungen.
5. Klicken Sie auf Zugriff erlauben.
6. Geben Sie im Feld Neue Hauptkonten Folgendes ein:
  
  serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]
7. Wählen Sie in der Liste Rolle auswählen die Option IAM > Workload Identity-Nutzer aus.
8. Klicken Sie auf Speichern.
Fügen Sie in Cloud Shell dem Kubernetes-Dienstkonto unter Verwendung der E-Mail-Adresse des Google-Dienstkontos die Annotation iam.gke.io/gcp-service-account hinzu:
```
kubectl annotate serviceaccount \
  KSA_NAME \
  iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
```

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-Cluster 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

Führen Sie die folgenden Schritte aus, um ein Container-Image der Beispielanwendung zu erstellen und per Push in ein Repository zu übertragen.

Console

Rufen Sie in der Google Cloud Console die Seite Artifact Registry auf.

Zu Artifact Registry
Klicken Sie zum Erstellen eines Repositorys auf .
Geben Sie im Feld Name REPOSITORY_ID ein, z. B. gke-alloydb-sample-app.
Wählen Sie im Bereich Format die Option Docker aus.
Wählen Sie im Bereich Standorttyp die Option Region und dann REGION aus, z. B. us-central1.
Klicken Sie auf Erstellen.
So erstellen Sie das Image der Beispielanwendung: Starten Sie Cloud Shell und führen Sie die folgenden Schritte aus.
Aktivieren Sie Cloud Shell in der Google Cloud Console.

Cloud Shell aktivieren

Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

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

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

Klicken Sie im Dialogfeld Cloud Shell autorisieren auf Autorisieren. Diese Aufforderung wird nicht angezeigt, wenn Sie diesen Schritt bereits ausgeführt haben.
Führen Sie den folgenden Befehl aus, um den Docker-Container zu erstellen und in der 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.

gcloud

Verwenden Sie in Cloud Shell den folgenden Befehl, um das Repository mit dem Beispielcode für die gke-alloydb-app-Anwendung von GitHub zu klonen:
```
 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 eine AlloyDB-Datenbank und einen Nutzer erstellen dieser Anleitung angegeben wurden. Weitere Informationen finden Sie unter Secrets.

Console

Verwenden Sie in der geöffneten Cloud Shell 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

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.
So wird ein Single Point of Failure verhindert. 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.

Console

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

Rufen Sie die Instanzverbindung INSTANCE_URI für die primäre AlloyDB-Instanz ab:
1. Rufen Sie in der Google Cloud Console die Seite Cluster auf.
  
  Zu den Clustern
2. Klicken Sie auf den Clusternamen, um die Übersichtsseite des Clusters aufzurufen.
3. Klicken Sie in der Tabelle Instanzen auf den Namen Ihrer primären Instanz.
4. Klicken Sie auf der Seite Übersicht im Feld Instanz-URI auf In die Zwischenablage kopieren.
Sie geben diese INSTANCE_URI in der proxy_sidecar_deployment.yaml-Definitionsdatei in Schritt 2b dieses Abschnitts an.

Führen Sie in der geöffneten Cloud Shell 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"
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        - 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
      - name: alloydb-proxy
        # This uses the latest version of the 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
          - "INSTANCE_URI "
        securityContext:
          runAsNonRoot: true
        resources:
          requests:
            memory: "2Gi"
            cpu:    "1"

Ersetzen Sie INSTANCE_URI durch den Pfad, den Sie in Schritt 1 kopiert haben.

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 Definitionsdatei an:
```
kubectl apply -f proxy_sidecar_deployment.yaml
```
Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf, um zu prüfen, ob die Anwendung ausgeführt wird:

Zu Arbeitslasten

Prüfen Sie, ob der Status für die gke-alloydb-Bereitstellung OK lautet.
So stellen Sie über einen externen Load Balancer eine Verbindung zur Beispielanwendung her:
1. Rufen Sie service.yaml auf:
```
nano service.yaml
```
2. Fügen Sie Folgendes 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 Anwendung, z. B. gke-alloydb-app.
3. Speichern Sie die Datei und beenden Sie den Editor. Wenden Sie dann den Dienst an:
```
kubectl apply -f service.yaml
```
Wenn Sie die externe IP-Adresse Ihrer Anwendung abrufen möchten, rufen Sie in der Google Cloud Console die Seite Dienste & Ingress auf:

Zu "Dienste & Ingress"
Verwenden Sie den Wert in der Spalte Externe Endpunkte, um über die folgende URL auf die Anwendung zuzugreifen:

http://EXTERNAL_IP

gcloud

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

Rufen Sie die Instanzverbindung INSTANCE_URI für die primäre AlloyDB-Instanz ab, zu 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 des Clusters, 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

Hinweis

Console

gcloud

Erforderliche Rollen

Cloud Shell starten

Console

gcloud

AlloyDB-Cluster und primäre Instanz erstellen

Console

gcloud

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

Console

gcloud

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

Console

gcloud

Artifact Registry mit einem Image der Beispielanwendung füllen

Console

gcloud

Kubernetes-Secret erstellen

Console

gcloud

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

Console

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