Diese Seite wurde von der Cloud Translation API übersetzt.

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

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

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

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

Lernziele

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

Kosten

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

AlloyDB
Google Kubernetes Engine
Artifact Registry

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

Hinweise

Console

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

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

Go to project selector

Make sure 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.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Aktivieren Sie die Cloud APIs, die zum Erstellen von AlloyDB for PostgreSQL und zum Herstellen einer Verbindung zu dieser Instanz 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

Verwenden Sie für diese Anleitung die Beispiel-Webanwendung zum Erfassen von Stimmen mit dem Namen gke-alloydb-app.

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 ist 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:

Öffnen Sie die 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.

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 mit Ihrem neuen Cluster. Wir empfehlen, einen internen IP-Zugriff zu verwenden, um die Datenbank nicht dem öffentlichen Internet auszusetzen.

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

gcloud

Prüfen Sie in Cloud Shell, ob der Bereich der nicht verwendeten IP-Adressen (IPv4) bereits dem 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. Diesen können Sie als IP_RANGE_NAME verwenden, um in Schritt 3 eine private Verbindung zu erstellen.
(Überspringen, wenn Sie den Standardwert reservedPeeringRanges verwenden) Um nicht verwendete IP-Adressen im VPC zuzuweisen, verwenden Sie den folgenden Befehl:
```
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 den 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, der unterstützten Standard-PostgreSQL-Version
  - 16: für die Kompatibilität mit PostgreSQL 16 (Vorabversion)
    
    Weitere Informationen zu den Einschränkungen bei der Verwendung von PostgreSQL 16 in der Vorabversion finden Sie unter Kompatibilität von PostgreSQL 16 in der Vorabversion.
- CLUSTER_PASSWORD: Das Passwort für den Standardnutzer von 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 zum Bereitstellen der primären AlloyDB-Instanz Folgendes aus:
```
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 mit der ID Ihres Google Cloud -Projekts.
- REGION durch den Namen der Region ersetzen, 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 zu Ihrer primären Instanz herstellen und eine AlloyDB-Datenbank und einen Nutzer erstellen

Console

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

Zu den Clustern
Klicken Sie auf den Clusternamen CLUSTER_ID, um die Übersichtsseite des Clusters aufzurufen.
Klicken Sie im Navigationsmenü auf AlloyDB Studio.
Führen Sie auf der Seite In AlloyDB Studio anmelden die folgenden Schritte aus:
1. Wählen Sie in der Liste Datenbank 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 die 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. So 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 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 die 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 Namen der Datenbank, 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 auf der Seite Clustergrundlagen im Feld Name einen Namen für Ihren Autopilot-Cluster an, z. B. ap-cluster.GKE_CLUSTER_ID
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 für die Verbindung zu AlloyDB zu verwenden. Der AlloyDB Auth-Proxy bietet eine starke Verschlüsselung und Authentifizierung mithilfe von 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. Dadurch kann die Anwendung über localhost eine Verbindung zum AlloyDB Auth-Proxy herstellen und so die Sicherheit und Leistung erhöhen.

Rollen für Google-Dienstkonten erstellen und zuweisen

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

Wenn Sie den AlloyDB Auth-Proxy in der Google Kubernetes Engine ausführen möchten, 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

Öffnen Sie in der Google Cloud Console die Seite IAM.

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

So rufen Sie die PROJECT_NUMBER ab, eine automatisch generierte eindeutige Kennung für Ihr Projekt:
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 Karte Projektinformationen des Projekt-Dashboards angezeigt.
Klicken Sie auf Weitere Rolle hinzufügen.
Wenn Sie die Rolle roles/artifactregistry.reader zuweisen möchten, klicken Sie auf Rolle auswählen und wählen Sie Artifact Registry unter Nach Produkt oder Dienstleistung und Artifact Registry Reader unter Rollen aus.
Klicken Sie auf Speichern. Dem Hauptkonto wird die Rolle zugewiesen.
Rufen Sie die Seite Dienstkonten auf, um ein Dienstkonto für die GKE-Beispielanwendung zu erstellen. 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 auf der Seite Dienstkonto erstellen im Abschnitt Dienstkontodetails im Feld Name des Dienstkontos einen Namen ein, z. B. gke-alloydb-gsa.GSA_NAME
Klicken Sie auf Erstellen und fortfahren.

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

gcloud

Führen Sie den folgenden Befehl aus, um dem Standarddienstkonto von Google die erforderlichen Berechtigungen zu erteilen, damit die Compute Engine Daten 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"

Wenn Sie ein Google-Dienstkonto für Ihre Anwendung erstellen möchten, erstellen Sie ein IAM-Dienstkonto:
```
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 der GSA Ihrer Anwendung 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"

Identitätsföderation von Arbeitslasten für GKE für die Beispielanwendung konfigurieren

Sie müssen GKE so konfigurieren, dass das Dienstkonto mithilfe der Funktion Workload Identity Federation for GKE für den AlloyDB Auth-Proxy 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.

Die Workload Identity-Föderation für GKE bindet ein Kubernetes-Dienstkonto an ein Google-Dienstkonto. Durch diese Bindung werden alle Bereitstellungen mit diesem Kubernetes-Dienstkonto bei Interaktionen mit Google Cloudals Google-Dienstkonto authentifiziert.

gcloud

Öffnen Sie Cloud Shell in der Google Cloud Console.

Cloud Shell öffnen
Rufen Sie in Cloud Shell die Anmeldedaten für Ihren Cluster ab:
```
gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID
```
Mit diesem Befehl wird kubectl für die Verwendung des von Ihnen erstellten GKE-Cluster konfiguriert.
Führen Sie in Ihrem Editor die folgenden Schritte aus:
1. Öffnen Sie service-account.yaml mit Nano, z. B. so:
```
nano service-account.yaml
```
2. Fügen Sie im Editor den folgenden Inhalt 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, die Identität des Google-Dienstkontos anzunehmen. Erstellen Sie dazu eine IAM-Richtlinienbindung zwischen den beiden Dienstkonten:

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

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

Artifact Registry mit einem Image der Beispielanwendung füllen

gcloud

Klonen Sie in Cloud Shell mit dem folgenden Befehl das Repository mit dem Beispielcode der gke-alloydb-app-Anwendung von GitHub:
```
 git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go
```
Erstellen Sie in Artifact Registry ein Repository für Docker-Images:
```
gcloud artifacts repositories create REPOSITORY_ID --location REGION --repository-format=docker --project PROJECT_ID
```
Ersetzen Sie Folgendes:
- PROJECT_ID: die Projekt-ID.
- REPOSITORY_ID: der Name Ihres Repositorys, z. B. gke-alloydb-sample-app.
Klicken Sie im Dialogfeld Cloud Shell autorisieren auf Autorisieren. Diese Aufforderung wird nicht angezeigt, wenn Sie diesen Schritt bereits ausgeführt haben.
Verwenden Sie den folgenden Befehl, um einen Docker-Container zu erstellen und in 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.

gcloud

Verwenden Sie einen Kubernetes-SECRET wie 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.
Hiermit können Sie Ihre Anwendung so 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.

gcloud

In dieser Anleitung stellen Sie die Beispiel-Webanwendung gke-alloydb-app zum Erfassen von Stimmen bereit, die AlloyDB als Datenspeicher verwendet.

Rufen Sie die Instanzverbindung 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 der Instanz, z. B. alloydb-primary.
- CLUSTER_ID: Name des Clusters, z. B. alloydb-cluster.
Die Ausgabe enthält die INSTANCE_URI, die Sie in Schritt 2.b dieses Abschnitts in der Definitiondatei proxy_sidecar_deployment.yaml angegeben haben.

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

Öffnen Sie proxy_sidecar_deployment.yaml mit einem 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: 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 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

Verwenden Sie einen Dienst, z. B. einen externen HTTP-Load Balancer, um eine Verbindung zur Beispielanwendung gke-alloydb-app herzustellen. Gehen Sie in Ihrem bevorzugten Editor so vor:
1. Öffnen Sie service.yaml mit Nano, z. B. so:
```
nano service.yaml
```
2. Fügen Sie im Nano-Editor 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 Beispiel-Webanwendung, 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 Dienstanwendung gke-alloydb-app bereitzustellen, wenden Sie die Datei service.yaml an:
```
 kubectl apply -f service.yaml
```

Mit dem folgenden Befehl können Sie die Dienstdetails einschließlich der externen IP-Adresse des Dienstes abrufen:

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

Lernziele

Kosten

Hinweise

Console

Cloud Shell starten

Console

AlloyDB-Cluster und primäre Instanz erstellen

gcloud

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

Console

Erstellen Sie einen GKE Autopilot-Cluster

Console

gcloud

Verbindung zu AlloyDB über den AlloyDB Auth-Proxy herstellen

Rollen für Google-Dienstkonten erstellen und zuweisen

Console

gcloud

Identitätsföderation von Arbeitslasten für GKE für die Beispielanwendung konfigurieren

gcloud

Artifact Registry mit einem Image der Beispielanwendung füllen

gcloud

Kubernetes-Secret erstellen

gcloud

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

gcloud

Musterkonfigurationsdateien

proxy_sidecar_deployment.yaml

service.yaml

service-account.yaml

Bereinigen

Projekt löschen

Nächste Schritte