Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

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

Wenn Sie eine containerisierte Anwendung in einem Google Kubernetes Engine Autopilot-Cluster sicher mit einer AlloyDB for PostgreSQL-Instanz verbinden möchten, können Sie den AlloyDB Auth-Proxy als Sidecar-Container über eine private IP-Netzwerkverbindung bereitstellen.

AlloyDB ist ein vollständig verwalteter, PostgreSQL-kompatibler Datenbankdienst in Google Cloud. Mit der Google Kubernetes Engine können Sie Kubernetes-Arbeitslasten automatisch bereitstellen, skalieren und verwalten.

Ziele

Docker-Image für AlloyDB erstellen
Anwendung in der 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 einfach 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 diese Anleitung erforderlich sind.
Aktivieren Sie die Cloud APIs, die zum Erstellen von AlloyDB und zum Herstellen einer Verbindung 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
Hinweis: Wenn Sie eine oder alle dieser APIs bereits aktiviert haben, werden sie hier nicht aufgeführt.

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 diese Anleitung erforderlich sind.

Verwenden Sie für diese Anleitung die Beispiel-Webanwendung gke-alloydb-app, die Stimmen sammelt.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen der Aufgaben in dieser Anleitung benötigen:

Datenbankadministrator (roles/iam.databasesAdmin)
Kubernetes Engine-Cluster-Administrator (roles/container.clusterAdmin)
Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
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

Führen Sie die folgenden Schritte aus, um Cloud Shell zu starten.

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

Führen Sie die folgenden Schritte aus, um Cloud Shell zu starten.
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.

Legen Sie zum Initialisieren der Umgebung 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 von AlloyDB for PostgreSQL und zum Herstellen einer Verbindung 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 die zugehörige 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, eine interne IP-Adresse 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 das Standard-VPC-Netzwerk, um Abfragen von einer Anwendung auszuführen, die in einem GKE-Cluster bereitgestellt ist.

Console

Zur Clusterseite.

Zu den Clustern
Geben Sie im Bereich Cluster konfigurieren im Feld Cluster-ID eine ID für den 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 für den Standarddatenbanknutzer postgres beim Erstellen des Clusters verwendet werden soll.
Wählen Sie im Feld Datenbankversion die Hauptversion von 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 folgende 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. Konfigurieren Sie die Verbindung für den Zugriff auf private Dienste, um sicherzustellen, dass dem Dienst-Peering ein IP-Bereich zugewiesen ist:
  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 Dienst-Peering zugewiesen ist:
```
gcloud services vpc-peerings list --network=default
```
Überspringen Sie den nächsten Schritt, wenn Ihre Ausgabe in etwa 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. Sie können ihn 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 Ihren 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 mit dem 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 die 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 Standard-PostgreSQL-Version
  - 18, für die 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:
- 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.
- 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

So erstellen Sie eine Datenbank und einen Datenbanknutzer auf Ihrer primären Instanz:

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 die folgenden 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 Passwort CLUSTER_PASSWORD ein, das Sie unter AlloyDB-Cluster und zugehörige 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 im Tab Editor 1 die folgenden Schritte aus:
1. Erstellen Sie eine AlloyDB-Datenbank:
```
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 die folgenden 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 Passwort CLUSTER_PASSWORD ein, das Sie unter AlloyDB-Cluster und zugehörige 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 im 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 unter 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 gewähren möchten, müssen Sie eine Verbindung zum Cluster herstellen und SQL-Befehle ausführen. Verwenden Sie in Cloud Shell den psql-Client, um eine Verbindung zu Ihrer Instanz herzustellen.

Hinweis: Wenn Sie über die 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 unter 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 im Feld Name auf der Seite Clustergrundlagen einen GKE_CLUSTER_ID für Ihren Autopilot-Cluster an, z. B. ap-cluster.
Wählen Sie im Feld Region eine 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 über den AlloyDB Auth-Proxy herstellen

Wir empfehlen, den AlloyDB Auth-Proxy zu verwenden, um eine Verbindung zu AlloyDB herzustellen. 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.

Artifact Registry Zugriff auf das Compute Engine-Standarddienstkonto gewähren

Weisen Sie dem Compute Engine-Standarddienstkonto die Rolle „Artifact Registry-Leser“ (roles/artifactregistry.reader) zu, damit Ihre Google Kubernetes Engine-Knoten Container-Images aus Artifact Registry abrufen 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 Compute-Standarddienstkonto 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 die Drop-down-Liste 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.
Klicken Sie auf Rolle auswählen, wählen Sie unter Nach Produkt oder Dienst die Option Artifact Registry und unter Rollen die Option Artifact Registry Reader aus, um die Rolle roles/artifactregistry.reader zuzuweisen.
Klicken Sie auf Speichern. Dem Hauptkonto wird die Rolle zugewiesen.

gcloud

Weisen Sie dem Compute Engine-Standarddienstkonto die Rolle „Artifact Registry-Leser“ (roles/artifactregistry.reader) für das Projekt zu:

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

Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

Workload Identity Federation for GKE für die Beispielanwendung konfigurieren

Konfigurieren Sie Google Kubernetes Engine für die Authentifizierung des AlloyDB Auth-Proxys mithilfe der Workload Identity-Föderation für GKE. Mit der Workload Identity-Föderation für GKE erstellen Sie ein Kubernetes-ServiceAccount für Ihre Anwendung im Google Kubernetes Engine-Cluster und weisen diesem Kubernetes-ServiceAccount IAM-Rollen zu. Erstellen Sie ein Kubernetes-ServiceAccount, das für jede Anwendung eindeutig ist, damit Sie die Berechtigungen pro Anwendung einschränken können.

Console

Führen Sie die folgenden Schritte aus, um Cloud Shell zu starten.
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, zum Beispiel:
```
nano service-account.yaml
```
2. Fügen Sie im Editor den folgenden Inhalt ein:
```
apiVersion: v1
kind: ServiceAccount
metadata:
  name: KUBERNETES_SERVICEACCOUNT
```
  Ersetzen Sie KUBERNETES_SERVICEACCOUNT durch den Namen des Kubernetes-Dienstkontos, z. B. alloydb-sa.
3. Drücken Sie Strg + O und dann die Eingabetaste, um die Änderungen zu speichern. Drücken Sie dann Strg + X, um den Editor zu beenden.
Erstellen Sie ein Kubernetes-ServiceAccount für Ihre Beispielanwendung:
```
kubectl apply -f service-account.yaml
```
So weisen Sie dem Kubernetes-ServiceAccount IAM-Rollen in der Google Cloud Console zu:
1. Rufen Sie in der Google Cloud Console die Seite IAM auf.
  
  IAM aufrufen
2. Wählen Sie Ihr Projekt aus.
3. Klicken Sie auf Zugriff erlauben.
4. Geben Sie im Feld Neue Hauptkonten Folgendes ein:
  
  principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/default/sa/KUBERNETES_SERVICEACCOUNT
  
  Ersetzen Sie Folgendes:
  - PROJECT_NUMBER: Ihre Projektnummer.
  - PROJECT_ID: Ihre Projekt-ID.
  - KUBERNETES_SERVICEACCOUNT: der Name des Kubernetes-ServiceAccount, z. B. alloydb-sa.
5. Wählen Sie in der Liste Rolle auswählen die Option AlloyDB for PostgreSQL > AlloyDB-Client aus, um die Rolle roles/alloydb.client zuzuweisen.
6. Klicken Sie auf Weitere Rolle hinzufügen.
7. Wählen Sie in der Liste Rolle auswählen die Option Service Usage > Service Usage Consumer aus, um die Rolle roles/serviceusage.serviceUsageConsumer zuzuweisen.
8. Klicken Sie auf Speichern.

gcloud

Öffnen Sie in der Google Cloud Console Cloud Shell.

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, zum Beispiel:
```
nano service-account.yaml
```
2. Fügen Sie im Editor den folgenden Inhalt ein:
```
apiVersion: v1
kind: ServiceAccount
metadata:
  name: KUBERNETES_SERVICEACCOUNT
```
  Ersetzen Sie KUBERNETES_SERVICEACCOUNT durch den Namen des Kubernetes-Dienstkontos, z. B. alloydb-sa.
3. Drücken Sie Strg + O und dann die Eingabetaste, um die Änderungen zu speichern. Drücken Sie dann Strg + X, um den Editor zu beenden.
Erstellen Sie ein Kubernetes-ServiceAccount für Ihre Beispielanwendung:
```
kubectl apply -f service-account.yaml
```

Weisen Sie dem Kubernetes-Dienstkonto die Rollen „AlloyDB-Client“ (roles/alloydb.client) und „Service Usage-Nutzer“ (roles/serviceusage.serviceUsageConsumer) für das Projekt zu:

PROJECT_ID="PROJECT_ID"
KUBERNETES_SERVICEACCOUNT="KUBERNETES_SERVICEACCOUNT"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/$KUBERNETES_SERVICEACCOUNT" \
    --role="roles/alloydb.client" \
    --condition=None
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/$KUBERNETES_SERVICEACCOUNT" \
    --role="roles/serviceusage.serviceUsageConsumer" \
    --condition=None

Ersetzen Sie Folgendes:

PROJECT_ID: Ihre Projekt-ID.
KUBERNETES_SERVICEACCOUNT: der Name des Kubernetes-ServiceAccount, z. B. alloydb-sa.

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 in ein Repository zu übertragen.

Console

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

Zu Artifact Registry
Klicken Sie auf , um ein Repository zu erstellen.
Geben Sie im Feld Name einen REPOSITORY_ID ein, z. B. gke-alloydb-sample-app.
Wählen Sie im Bereich Format die Option Docker aus.
Wählen Sie im Abschnitt Standorttyp die Option Region und dann REGION aus, z. B. us-central1.
Klicken Sie auf Erstellen.
Führen Sie die folgenden Schritte aus, um das Image der Beispielanwendung zu erstellen und Cloud Shell zu starten.
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 gke-alloydb-app-Beispielanwendungscode 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 Beispiel-gke-alloydb-app-Anwendungscode aus 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 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.

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.

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.
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 Ihre containerisierte Anwendung im GKE-Cluster bereit.

Console

In dieser Anleitung stellen Sie die Beispiel-Webanwendung gke-alloydb-app zur Abstimmung bereit, die AlloyDB als Datastore verwendet.

Rufen Sie den Verbindungs-URI (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 in der Spalte Ressourcenname auf den Namen Ihres Clusters, um die Übersichtsseite des Clusters aufzurufen.
3. Suchen Sie im Abschnitt Instanzen in Ihrem Cluster nach Ihrer primären Instanz und rufen Sie den Abschnitt Verbindung auf oder klicken Sie auf Verbindungskonfiguration ansehen.
4. Klicken Sie im Feld Verbindungs-URI auf den Button In Zwischenablage kopieren .
Sie geben diese INSTANCE_URI in der Definitionsdatei proxy_sidecar_deployment.yaml 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 den folgenden Inhalt ein:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KUBERNETES_SERVICEACCOUNT
      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 KUBERNETES_SERVICEACCOUNT durch den Namen Ihres Kubernetes-ServiceAccount und INSTANCE_URI durch den Pfad, den Sie in Schritt 1 kopiert haben.

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

Wenden Sie die Definitionsdatei an, um die Anwendung gke-alloydb-app bereitzustellen:
```
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 der Bereitstellung gke-alloydb OK lautet.
Führen Sie die folgenden Schritte in der geöffneten Cloud Shell aus, um über einen externen Load Balancer eine Verbindung zur Beispielanwendung herzustellen:
1. Rufen Sie service.yaml auf:
```
nano service.yaml
```
2. Fügen Sie 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 Anwendung, z. B. gke-alloydb-app.
3. Speichern Sie die Datei, beenden Sie den Editor und wenden Sie den Dienst an:
```
kubectl apply -f service.yaml
```
Rufen Sie in der Google Cloud Console die Seite Dienste und Ingress auf, um die externe IP-Adresse Ihrer Anwendung abzurufen:

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 zur Abstimmung bereit, die AlloyDB als Datastore verwendet.

Rufen Sie den Instanzverbindungs-INSTANCE_URI für die primäre AlloyDB-Instanz ab, zu 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 Schritt 2b dieses Abschnitts in der Definitionsdatei proxy_sidecar_deployment.yaml angeben.

Führen Sie in einem 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 den folgenden Inhalt ein:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KUBERNETES_SERVICEACCOUNT
      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 KUBERNETES_SERVICEACCOUNT durch den Namen Ihres Kubernetes-ServiceAccount und 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 und dann die Eingabetaste, um die Änderungen zu speichern. Drücken Sie dann Strg + X, um den Editor zu beenden.

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

Prüfen Sie, ob der Status für beide Container im Pod running lautet:

kubectl get pods

Beispielausgabe:

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

Wenn Sie eine Verbindung zur Beispielanwendung gke-alloydb-app herstellen möchten, 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, zum Beispiel:
```
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 Beispiel-Webanwendung, z. B. gke-alloydb-app.
3. Drücken Sie Strg + O und dann die Eingabetaste, um die Änderungen zu speichern. Drücken Sie dann Strg + X, um den Editor zu beenden.
Wenden Sie die Datei service.yaml an, um die Anwendung gke-alloydb-app des Dienstes bereitzustellen:
```
 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 den Wert der externen IP-Adresse aus dem vorherigen Schritt, um unter der folgenden URL auf die Beispielanwendung zuzugreifen:
```
http://EXTERNAL-IP
```

Beispielkonfigurationsdateien

proxy_sidecar_deployment.yaml

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:5432"
        - 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

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

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 Ihre 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 die zugehörige 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 über den AlloyDB Auth-Proxy herstellen

Artifact Registry Zugriff auf das Compute Engine-Standarddienstkonto gewähren

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

Beispielkonfigurationsdateien

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