Verbindung zu Cloud SQL for MySQL mit Google Kubernetes Engine herstellen

MySQL | PostgreSQL | SQL Server

Auf dieser Seite wird beschrieben, wie Sie eine Beispielanwendung in Google Kubernetes Engine (GKE) bereitstellen, die über die Google Cloud Console und eine Clientanwendung mit einer MySQL-Instanz verbunden ist. Die in dieser Kurzanleitung erstellten Ressourcen kosten in der Regel weniger als einen Dollar (USD), vorausgesetzt, Sie führen die Schritte einschließlich der Bereinigung zeitnah aus.

Hinweis

Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch 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.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Aktivieren Sie die Google Cloud APIs, die zum Ausführen einer Cloud SQL-Beispielanwendung in GKE erforderlich sind.
Console

Klicken Sie auf APIs aktivieren, um die für diese Kurzanleitung erforderlichen APIs zu aktivieren.

APIs aktivieren

Dadurch werden die folgenden APIs aktiviert:
- Compute Engine API
- Cloud SQL Admin API
- Google Kubernetes Engine API
- Artifact Registry API
- Cloud Build API
gcloud

Klicken Sie auf die folgende Schaltfläche, um Cloud Shell zu öffnen, die Befehlszeilenzugriff auf Ihre Google Cloud-Ressourcen direkt über den Browser bietet. Mit Cloud Shell können Sie die in dieser Kurzanleitung vorgestellten gcloud-Befehle ausführen.

Cloud Shell öffnen

Führen Sie den folgenden gcloud services enable-Befehl mit Cloud Shell aus, um die für diese Kurzanleitung erforderlichen APIs zu aktivieren:
```
gcloud services enable compute.googleapis.com sqladmin.googleapis.com \
     container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com
```
Mit diesem Befehl werden die folgenden APIs aktiviert:
- Compute Engine API
- Cloud SQL Admin API
- GKE API
- Artifact Registry API
- Cloud Build API

Cloud SQL einrichten

Cloud SQL-Instanz erstellen

Öffentliche IP-Adresse

Console

Instanz mit öffentlicher IP-Adresse erstellen

Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.

Cloud SQL-Instanzen aufrufen
Klicken Sie auf Instanz erstellen.
Klicken Sie auf MySQL.
Geben Sie unter Instanz-ID quickstart-instance ein.
Geben Sie ein Passwort für den Root-Nutzer ein. Speichern Sie dieses Passwort zur späteren Verwendung.
Klicken Sie für Region und zonale Verfügbarkeit auswählen auf Einzelne Zone.
Klicken Sie auf den Abschnitt Konfigurationen anzeigen und maximieren Sie ihn.
Wählen Sie im Drop-down-Menü Maschinentyp die Option Einfach aus.
Klicken Sie auf Instanz erstellen und warten Sie, bis die Instanz initialisiert und gestartet wurde.

gcloud

Instanz mit öffentlicher IP-Adresse erstellen

Bevor Sie den Befehl gcloud sql instances create ausführen, ersetzen Sie DB_ROOT_PASSWORD durch das Passwort Ihres Datenbanknutzers.

Ändern Sie optional die Werte für die folgenden Parameter:

--database_version: der Typ und die Version des Datenbankmoduls. Falls nicht angegeben, wird der API-Standard verwendet. Die derzeit verfügbaren Versionen finden Sie in der Dokumentation zu gcloud-Datenbankversionen.
--cpu: Die Anzahl der in der Maschine gewünschten Kerne.
--memory: Ganzzahliger Wert, der angibt, wie viel Arbeitsspeicher in der Maschine gewünscht ist. Es sollte eine Größeneinheit angegeben werden (z. B. 3.072 MB oder 9 GB). Wenn keine Einheiten angegeben sind, wird von GB ausgegangen.
--region: Regionaler Standort der Instanz, z. B. asia-east1, us-east1. Wenn nichts anderes angegeben ist, wird standardmäßig us-central verwendet. Eine vollständige Liste der Regionen finden Sie in diesem Artikel.

Führen Sie den Befehl gcloud sql instances create aus, um eine Cloud SQL-Instanz zu erstellen.

gcloud sql instances create quickstart-instance \
--database-version=MYSQL_8_0 \
--cpu=1 \
--memory=4GB \
--region=us-central1 \
--root-password=DB_ROOT_PASSWORD

Private IP-Adresse

Console

Instanz mit aktivierter privater IP-Adresse und SSL erstellen

Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.

Cloud SQL-Instanzen aufrufen
Klicken Sie auf Instanz erstellen.
Klicken Sie auf MySQL.
Geben Sie unter Instanz-ID quickstart-instance ein.
Geben Sie ein Passwort für den Root-Nutzer ein. Speichern Sie dieses Passwort zur späteren Verwendung.
Klicken Sie für Region und zonale Verfügbarkeit auswählen auf Einzelne Zone.
Klicken Sie auf Konfigurationsoptionen einblenden und maximieren Sie sie.
Wählen Sie für Maschinentyp die Option Einfach aus.
Wählen Sie unter Verbindungen die Option Private IP aus.
Wählen Sie im Drop-down-Menü Netzwerk die Option Standard aus.
Wenn das Dialogfeld Verbindung für privaten Zugriff auf Dienste erforderlich angezeigt wird, klicken Sie auf die Schaltfläche Verbindung einrichten.

Klicken Sie im Dialogfeld Service Networking API aktivieren auf die Schaltfläche API aktivieren.
Wählen Sie im Dialogfeld IP-Bereich zuweisen die Option Automatisch zugewiesenen IP-Bereich verwenden aus und klicken Sie auf Weiter.
Klicken Sie im Dialogfeld Verbindung erstellen auf Verbindung erstellen.

Entfernen Sie das Häkchen aus dem Kästchen Öffentliche IP-Adressen, um nur eine Instanz mit einer privaten IP-Adresse zu erstellen.
Klicken Sie auf Instanz erstellen und warten Sie, bis die Instanz initialisiert und gestartet wurde.
Klicken Sie auf Verbindungen.
Wählen Sie im Abschnitt Sicherheit die Option Nur SSL-Verbindungen zulassen aus, um SSL-Verbindungen zu aktivieren.
Klicken Sie im Dialogfeld SSL aktivieren auf Aktivieren und neu starten und warten Sie, bis die Instanz neu gestartet wurde.

gcloud

Instanz mit aktivierter privater IP-Adresse und SSL erstellen

Zum Erstellen einer Instanz mit einer privaten IP-Adresse muss nur der Zugriff auf private Dienste konfiguriert werden, um Verbindungen von anderen Google Cloud-Diensten wie GKE zu ermöglichen.

Führen Sie den Befehl gcloud compute addresses create aus, um einer Verbindung für den Zugriff auf private Dienste einen IP-Bereich zuzuweisen:

gcloud compute addresses create google-managed-services-default \
--global \
--purpose=VPC_PEERING \
--prefix-length=16 \
--description="peering range for Google" \
--network=default

Führen Sie den Befehl gcloud services vpc-peerings connect aus, um die Verbindung für den Zugriff auf private Dienste zu erstellen:

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

Bevor Sie den Befehl gcloud sql instances create ausführen, um eine Instanz zu erstellen, ersetzen Sie DB_ROOT_PASSWORD durch das Passwort Ihres Datenbanknutzers.

Ändern Sie optional die Werte für die folgenden Parameter:

--database_version: der Typ und die Version des Datenbankmoduls. Falls nicht angegeben, wird der API-Standard verwendet. Eine Liste der derzeit verfügbaren Versionen finden Sie unter gcloud-Datenbankversionen.
--cpu: Die Anzahl der Kerne in der Maschine.
--memory: Eine ganze Zahl, die angibt, wie viel Arbeitsspeicher in die Maschine eingebaut werden soll. Es kann eine Größeneinheit angegeben werden (z. B. 3072 MB oder 9 GB). Wenn keine Einheiten angegeben sind, wird von GB ausgegangen.
--region: Der regionale Standort der Instanz, z. B. asia-east1, us-east1. Falls nicht angegeben, wird standardmäßig us-central1 verwendet. Eine vollständige Liste der Regionen finden Sie in diesem Artikel.

Führen Sie den Befehl gcloud sql instances create aus, um eine Cloud SQL-Instanz mit einer privaten IP-Adresse zu erstellen.

 gcloud beta sql instances create quickstart-instance \
--database-version=MYSQL_8_0 \
--cpu=1 \
--memory=4GB \
--region=us-central1 \
--root-password=DB_ROOT_PASSWORD \
--no-assign-ip \
--network=default

Führen Sie den Befehl gcloud sql instances patch aus, um nur SSL-Verbindungen für die Instanz zuzulassen.

gcloud sql instances patch quickstart-instance --require-ssl

Datenbank erstellen

Console

Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.

Cloud SQL-Instanzen aufrufen
Wählen Sie quickstart-instance aus.
Wählen Sie im SQL-Navigationsmenü die Option Datenbanken aus.
Klicken Sie auf Create database (Datenbank erstellen).

Geben Sie im Feld Datenbankname des Dialogfelds Datenbank erstellen quickstart-db ein. Behalten Sie die Werte für den Zeichensatz und die Sortierung bei.
Klicken Sie auf Erstellen.

gcloud

Führen Sie den Befehl gcloud sql databases create aus, um eine Datenbank zu erstellen.

gcloud sql databases create quickstart-db --instance=quickstart-instance

Nutzer erstellen

Console

Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.

Cloud SQL-Instanzen aufrufen
Klicken Sie auf den Instanznamen, um die Seite Übersicht einer Instanz zu öffnen.
Wählen Sie im SQL-Navigationsmenü die Option Nutzer aus.
Klicken Sie auf Nutzerkonto hinzufügen.

Geben Sie auf der Seite Nutzerkonto zur Instanz Instanzname hinzufügen die folgenden Informationen ein:
- Nutzername: Legen Sie quickstart-user fest.
- Passwort: Geben Sie ein Passwort für Ihren Datenbanknutzer an. Notieren Sie dies zur Verwendung in einem späteren Schritt dieser Kurzanleitung.
- Die Standardeinstellung im Abschnitt Hostnamen lautet Beliebigen Host zulassen. Das bedeutet, dass der Nutzer von jeder IP-Adresse aus eine Verbindung herstellen kann.
  Optional können Sie Host anhand von IP-Adresse oder Adressbereich einschränken auswählen und im Abschnitt Host eine IP-Adresse oder einen Adressbereich eingeben. Der Nutzer kann dann nur von den angegebenen IP-Adressen aus eine Verbindung herstellen.

Klicken Sie auf Add.

gcloud

Ersetzen Sie vor der Ausführung des Befehls DB_PASS durch ein Passwort für den Datenbanknutzer. Notieren Sie dies zur Verwendung in einem späteren Schritt dieser Kurzanleitung.

Führen Sie den Befehl gcloud sql users create aus, um den Nutzer zu erstellen.

gcloud sql users create quickstart-user \
--instance=quickstart-instance \
--password=DB_PASS

Für Cloud SQL gelten dieselben Längenbeschränkungen für Nutzernamen wie für lokales MySQL; 32 Zeichen für MySQL 8.0, 16 Zeichen für frühere Versionen

GKE-Cluster erstellen

Console

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

Zur Seite "Google Kubernetes Engine"
Klicken Sie auf Erstellen.
Klicken Sie für GKE Autopilot auf Konfigurieren.
Geben Sie für Name den Clusternamen als gke-cloud-sql-quickstart an.
Klicken Sie auf Erstellen.

gcloud

Führen Sie den Befehl gcloud container clusters create-auto aus, um den Cluster zu erstellen.

gcloud container clusters create-auto gke-cloud-sql-quickstart \
    --region us-central1

Cloud SQL-Beispielanwendung in Cloud Shell-Editor klonen

Mit einer Cloud SQL-Instanz, einer Datenbank und einem GKE-Cluster können Sie jetzt eine Beispielanwendung klonen und konfigurieren, um eine Verbindung zu Ihrer Cloud SQL-Instanz herzustellen. Für die verbleibenden Schritte in dieser Kurzanleitung müssen die gcloud- und kubectl-Befehlszeilentools verwendet werden. Beide Tools sind in Cloud Shell vorinstalliert.

Go

Öffnen Sie im Cloud Shell-Editor den Quellcode der Beispielanwendung.
Cloud Shell-Editor öffnen
Klicken Sie im Dialog Open in Cloud Shell auf Bestätigen, um den Beispielanwendungscode herunterzuladen und das Beispielanwendungsverzeichnis im Cloud Shell-Editor zu öffnen.

Java

Öffnen Sie im Cloud Shell-Editor den Quellcode der Beispielanwendung.
Cloud Shell-Editor öffnen
Klicken Sie im Dialog Open in Cloud Shell auf Bestätigen, um den Beispielanwendungscode herunterzuladen und das Beispielanwendungsverzeichnis im Cloud Shell-Editor zu öffnen.

Node.js

Öffnen Sie im Cloud Shell-Editor den Quellcode der Beispielanwendung.
Cloud Shell-Editor öffnen
Klicken Sie im Dialog Open in Cloud Shell auf Bestätigen, um den Beispielanwendungscode herunterzuladen und das Beispielanwendungsverzeichnis im Cloud Shell-Editor zu öffnen.

Python

Öffnen Sie im Cloud Shell-Editor den Quellcode der Beispielanwendung.
Cloud Shell-Editor öffnen
Klicken Sie im Dialog Open in Cloud Shell auf Bestätigen, um den Beispielanwendungscode herunterzuladen und das Beispielanwendungsverzeichnis im Cloud Shell-Editor zu öffnen.

GKE-Cluster aktivieren

Aktivieren Sie den gerade erstellten GKE-Cluster als Standardcluster, der für die verbleibenden Befehle in dieser Kurzanleitung verwendet werden soll.

Führen Sie den Befehl gcloud container clusters get-credentials so aus, um den GKE-Cluster zu aktivieren.

gcloud container clusters get-credentials gke-cloud-sql-quickstart \
  --region us-central1

Dienstkonto einrichten

Erstellen und konfigurieren Sie ein Google Cloud-Dienstkonto, das von GKE verwendet werden soll, damit es die Rolle Cloud SQL-Client mit Berechtigungen zum Herstellen einer Verbindung zu Cloud SQL hat.

Führen Sie den Befehl gcloud iam service-accounts create so aus, um ein neues Dienstkonto zu erstellen:

gcloud iam service-accounts create gke-quickstart-service-account \
  --display-name="GKE Quickstart Service Account"

Führen Sie den gcloud projects add-iam-policy-binding-Befehl so aus, um dem Google Cloud-Dienstkonto, das Sie gerade erstellt haben, die Rolle Cloud SQL-Client hinzuzufügen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
  --member="serviceAccount:gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/cloudsql.client"
```
Die Beispielanwendung verwendet Logging. Führen Sie daher den Befehl gcloud projects add-iam-policy-binding wie unten beschrieben aus, um die Rolle Logautor dem soeben erstellten Google Cloud-Dienstkonto hinzuzufügen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
  --member="serviceAccount:gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/logging.logWriter"
```

Erstellen Sie ein Kubernetes-Dienstkonto, das für den Zugriff auf Cloud SQL konfiguriert ist. Binden Sie es dazu mithilfe von Workload Identity an das Google Cloud-Dienstkonto.

Erstellen Sie ein Kubernetes-Dienstkonto:
1. Aktualisieren Sie die Datei service-account.yaml im Cloud Shell-Editor. Ersetzen Sie <YOUR-KSA-NAME> durch ksa-cloud-sql.
2. Führen Sie den Befehl kubectl apply in Cloud Shell so aus:
```
kubectl apply -f service-account.yaml
```
Führen Sie den Befehl gcloud iam service-accounts add-iam-policy-binding so aus, um die IAM-Bindung des Google Cloud-Dienstkontos und des Kubernetes-Dienstkontos zu aktivieren. Ersetzen Sie die folgenden Werte:
- YOUR_PROJECT_ID durch die Projekt-ID.
- YOUR_K8S_NAMESPACE durch default, dem Standard-Namespace für in GKE erstellte Cluster.
- YOUR_KSA_NAME mit ksa-cloud-sql.
```
gcloud iam service-accounts add-iam-policy-binding \
  --role="roles/iam.workloadIdentityUser" \
  --member="serviceAccount:YOUR_PROJECT_ID.svc.id.goog[YOUR_K8S_NAMESPACE/YOUR_KSA_NAME]" \
  gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com
```
Führen Sie den Befehl kubectl annotate so aus, um das Kubernetes-Dienstkonto mit IAM-Bindung zu annotieren. Ersetzen Sie die folgenden Werte:
- YOUR_KSA_NAME mit ksa-cloud-sql.
- YOUR_PROJECT_ID durch die Projekt-ID.
```
kubectl annotate serviceaccount \
  YOUR_KSA_NAME  \
  iam.gke.io/gcp-service-account=gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com
```

Secrets konfigurieren

Führen Sie den Befehl kubectl create secret generic so aus, um Kubernetes-Secrets für die Datenbank, den Nutzer und das Nutzerpasswort zu erstellen, die von der Beispielanwendung verwendet werden sollen. Die Werte der einzelnen Secrets basieren auf den Werten, die in den vorherigen Schritten dieser Kurzanleitung angegeben wurden. Ersetzen Sie DB_PASS durch das Passwort des quickstart-user, den Sie im vorherigen Schritt Nutzer erstellen erstellt haben.

kubectl create secret generic gke-cloud-sql-secrets \
  --from-literal=database=quickstart-db \
  --from-literal=username=quickstart-user \
  --from-literal=password=DB_PASS

Beispiel-App erstellen

Go

Führen Sie in Cloud Shell den folgenden gcloud artifacts repositories create-Befehl aus, um in der Artifact Registry mit dem Namen gke-cloud-sql-repo in derselben Region wie Ihr Cluster ein Repository zu erstellen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
Führen Sie den Befehl gcloud builds submit in Cloud Shell so aus, um einen Docker-Container zu erstellen und in der Artifact Registry zu veröffentlichen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

Java

Führen Sie in Cloud Shell den folgenden gcloud artifacts repositories create-Befehl aus, um in der Artifact Registry mit dem Namen gke-cloud-sql-repo in derselben Region wie Ihr Cluster ein Repository zu erstellen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```

Führen Sie den Befehl mvn in Cloud Shell so aus, um einen Docker-Container zu erstellen und in der Artifact Registry zu veröffentlichen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.

mvn clean package com.google.cloud.tools:jib-maven-plugin:2.8.0:build \
  -Dimage=us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql \
  -DskipTests -Djib.to.credHelper=gcloud

Node.js

Führen Sie in Cloud Shell den folgenden gcloud artifacts repositories create-Befehl aus, um in der Artifact Registry mit dem Namen gke-cloud-sql-repo in derselben Region wie Ihr Cluster ein Repository zu erstellen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
Führen Sie den Befehl gcloud builds submit in Cloud Shell so aus, um einen Docker-Container zu erstellen und in der Artifact Registry zu veröffentlichen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

Python

Führen Sie in Cloud Shell den folgenden gcloud artifacts repositories create-Befehl aus, um in der Artifact Registry mit dem Namen gke-cloud-sql-repo in derselben Region wie Ihr Cluster ein Repository zu erstellen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
Führen Sie den Befehl gcloud builds submit in Cloud Shell so aus, um einen Docker-Container zu erstellen und in der Artifact Registry zu veröffentlichen. Ersetzen Sie YOUR_PROJECT_ID durch die Projekt-ID.
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

Beispiel-App bereitstellen

Öffentliche IP-Adresse

Mit der Konfiguration der Beispiel-App können Sie jetzt die Beispiel-App bereitstellen.

Go

Die bereitgestellte Beispielanwendung stellt über den Cloud SQL-Proxy, der in einem Kubernetes-Sidecar-Muster ausgeführt wird, eine Verbindung zu Ihrer Cloud SQL-Instanz her. Das Sidecar-Muster wird erreicht, indem eine Arbeitslast mit einem zusätzlichen Container bereitgestellt wird, der denselben Kubernetes-Pod verwendet wie der Container der Beispielanwendung.

Rufen Sie den Namen der Cloud SQL-Instanzverbindung mit dem Befehl gcloud sql instances describe ab:
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Aktualisieren Sie die Datei deployment.yaml im Cloud Shell-Editor. Ersetzen Sie die folgenden Werte:

<YOUR_KSA_NAME> mit ksa-cloud-sql.
<LOCATION> mit us-central1.
<YOUR_PROJECT_ID> durch die Projekt-ID.
<YOUR-DB-SECRET> mit gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> durch den Verbindungsnamen der Cloud SQL-Instanz, der aus dem Befehl gcloud im vorherigen Schritt abgerufen wurde. Das Format ist project_id:region:instance_name. Der Instanzverbindungsname wird auch auf der Seite Übersicht der Cloud SQL-Instanz angezeigt.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-cloud-sql-quickstart
spec:
  selector:
    matchLabels:
      app: gke-cloud-sql-app
  template:
    metadata:
      labels:
        app: gke-cloud-sql-app
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      - name: gke-cloud-sql-app
        # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
        # Replace <YOUR_PROJECT_ID> with your project ID.
        image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
        # 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_CONNECTION_NAME (proj:region:instance)
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "3306"
        # For Automatic IAM Authentication with the Go Connector
        # use DB_IAM_USER instead of DB_USER (recommended)
        # You may also remove the DB_PASS environment variable if
        # you use Automatic IAM Authentication
        - 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
      # If you are using the Go Connector (recommended), you can
      # remove cloud-sql-proxy (everything below this line)
      - name: cloud-sql-proxy
        # This uses the latest version of the Cloud SQL Proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy
        image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
        args:
          # If connecting from a VPC-native GKE cluster, you can use the
          # following flag to have the proxy connect over private IP
          # - "--private-ip"

          # If you are not connecting with Automatic IAM, you can delete
          # the following flag.
          - "--auto-iam-authn"

          # tcp should be set to the port the proxy should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - "--port=3306"
          - "<INSTANCE_CONNECTION_NAME>"
        securityContext:
          # The default Cloud SQL proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true

Führen Sie den Befehl kubectl apply in Cloud Shell so aus, um die Beispielanwendung bereitzustellen:
```
kubectl apply -f deployment.yaml
```
Führen Sie den Befehl kubectl apply so aus, um einen Load-Balancer vor der Bereitstellung hinzuzufügen, damit Sie über das Internet darauf zugreifen können:
```
kubectl apply -f service.yaml
```
Führen Sie den Befehl kubectl get so aus, um die Dienstdetails abzurufen:
```
kubectl get services
```
Kopieren Sie die externe IP-Adresse, sobald sie in den Dienstdetails verfügbar ist. Dies kann einige Minuten dauern.
Sehen Sie sich die bereitgestellte Beispielanwendung an. Öffnen Sie ein Browserfenster und rufen Sie die externe IP-Adresse des Dienstes auf.

Java

Die bereitgestellte Beispielanwendung stellt über den Cloud SQL-Java-Connector eine Verbindung zu Ihrer Cloud SQL-Instanz her.

Rufen Sie den Namen der Cloud SQL-Instanzverbindung mit dem Befehl gcloud sql instances describe ab:
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Aktualisieren Sie die Datei deployment.yaml im Cloud Shell-Editor. Ersetzen Sie die folgenden Werte:

<YOUR_KSA_NAME> mit ksa-cloud-sql.
<LOCATION> mit us-central1.
<YOUR_PROJECT_ID> durch die Projekt-ID.
<YOUR-DB-SECRET> mit gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> durch den Verbindungsnamen der Cloud SQL-Instanz, der aus dem Befehl gcloud im vorherigen Schritt abgerufen wurde. Das Format ist project_id:region:instance_name. Der Instanzverbindungsname wird auch auf der Seite Übersicht der Cloud SQL-Instanz angezeigt.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-cloud-sql-quickstart
spec:
  selector:
    matchLabels:
      app: gke-cloud-sql-app
  template:
    metadata:
      labels:
        app: gke-cloud-sql-app
    spec:
      # For more information about using Kubernetes service accounts see:
      # https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts
      serviceAccountName: <YOUR-KSA-NAME> # TODO(developer): replace this value.
      containers:
      - name: gke-cloud-sql-app
        # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
        # Replace <YOUR_PROJECT_ID> with your project ID.
        image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        - name: INSTANCE_CONNECTION_NAME
          value: <INSTANCE_CONNECTION_NAME>
        - name: DB_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "3306"
        - 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

Führen Sie den Befehl kubectl apply in Cloud Shell so aus, um die Beispielanwendung bereitzustellen:
```
kubectl apply -f deployment.yaml
```
Führen Sie den Befehl kubectl apply so aus, um einen Load-Balancer vor der Bereitstellung hinzuzufügen, damit Sie über das Internet darauf zugreifen können:
```
kubectl apply -f service.yaml
```
Führen Sie den Befehl kubectl get so aus, um die Dienstdetails abzurufen:
```
kubectl get services
```
Kopieren Sie die externe IP-Adresse, sobald sie in den Dienstdetails verfügbar ist. Dies kann einige Minuten dauern.
Sehen Sie sich die bereitgestellte Beispielanwendung an. Öffnen Sie ein Browserfenster und rufen Sie die externe IP-Adresse des Dienstes auf.

Node.js

Rufen Sie den Namen der Cloud SQL-Instanzverbindung mit dem Befehl gcloud sql instances describe ab:
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Aktualisieren Sie die Datei deployment.yaml im Cloud Shell-Editor. Ersetzen Sie die folgenden Werte:

<YOUR_KSA_NAME> mit ksa-cloud-sql.
<LOCATION> mit us-central1.
<YOUR_PROJECT_ID> durch die Projekt-ID.
<YOUR-DB-SECRET> mit gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> durch den Verbindungsnamen der Cloud SQL-Instanz, der aus dem Befehl gcloud im vorherigen Schritt abgerufen wurde. Das Format ist project_id:region:instance_name. Der Instanzverbindungsname wird auch auf der Seite Übersicht der Cloud SQL-Instanz angezeigt.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-cloud-sql-quickstart
spec:
  selector:
    matchLabels:
      app: gke-cloud-sql-app
  template:
    metadata:
      labels:
        app: gke-cloud-sql-app
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      - name: gke-cloud-sql-app
        # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
        # Replace <YOUR_PROJECT_ID> with your project ID.
        image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
        # 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: "3306"
        - 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
      - name: cloud-sql-proxy
        # This uses the latest version of the Cloud SQL proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy
        image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
        args:
          # If connecting from a VPC-native GKE cluster, you can use the
          # following flag to have the proxy connect over private IP
          # - "--private-ip"

          # If you are not connecting with Automatic IAM, you can delete
          # the following flag.
          - "--auto-iam-authn"

          # tcp should be set to the port the proxy should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - "--port=3306"
          - "<INSTANCE_CONNECTION_NAME>"
        securityContext:
          # The default Cloud SQL proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true

Führen Sie den Befehl kubectl apply in Cloud Shell so aus, um die Beispielanwendung bereitzustellen:
```
kubectl apply -f deployment.yaml
```
Führen Sie den Befehl kubectl apply so aus, um einen Load-Balancer vor der Bereitstellung hinzuzufügen, damit Sie über das Internet darauf zugreifen können:
```
kubectl apply -f service.yaml
```
Führen Sie den Befehl kubectl get so aus, um die Dienstdetails abzurufen:
```
kubectl get services
```
Kopieren Sie die externe IP-Adresse, sobald sie in den Dienstdetails verfügbar ist. Dies kann einige Minuten dauern.
Sehen Sie sich die bereitgestellte Beispielanwendung an. Öffnen Sie ein Browserfenster und rufen Sie die externe IP-Adresse des Dienstes auf.

cloud-sql/mysql/mysql/deployment.yaml

Python

Rufen Sie den Namen der Cloud SQL-Instanzverbindung mit dem Befehl gcloud sql instances describe ab:
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Aktualisieren Sie die Datei deployment.yaml im Cloud Shell-Editor. Ersetzen Sie die folgenden Werte:

<YOUR_KSA_NAME> mit ksa-cloud-sql.
<LOCATION> mit us-central1.
<YOUR_PROJECT_ID> durch die Projekt-ID.
<YOUR-DB-SECRET> mit gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> durch den Verbindungsnamen der Cloud SQL-Instanz, der aus dem Befehl gcloud im vorherigen Schritt abgerufen wurde. Das Format ist project_id:region:instance_name. Der Instanzverbindungsname wird auch auf der Seite Übersicht der Cloud SQL-Instanz angezeigt.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-cloud-sql-quickstart
spec:
  selector:
    matchLabels:
      app: gke-cloud-sql-app
  template:
    metadata:
      labels:
        app: gke-cloud-sql-app
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      - name: gke-cloud-sql-app
        # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
        # Replace <YOUR_PROJECT_ID> with your project ID.
        image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
        # 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 Python Connector (recommended) - use INSTANCE_CONNECTION_NAME (proj:region:instance)
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "3306"
        # For Automatic IAM Authentication with the Python Connector
        # use DB_IAM_USER instead of DB_USER (recommended)
        # You may also remove the DB_PASS environment variable if
        # you use Automatic IAM Authentication
        - 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
      # If you are using the Python Connector (recommended), you can
      # remove cloud-sql-proxy (everything below this line)
      - name: cloud-sql-proxy
        # This uses the latest version of the Cloud SQL Proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy
        image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
        args:
          # If connecting from a VPC-native GKE cluster, you can use the
          # following flag to have the proxy connect over private IP
          # - "--private-ip"

          # If you are not connecting with Automatic IAM, you can delete
          # the following flag.
          - "--auto-iam-authn"

          # tcp should be set to the port the proxy should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - "--port=3306"
          - "<INSTANCE_CONNECTION_NAME>"
        securityContext:
          # The default Cloud SQL proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true

Führen Sie den Befehl kubectl apply in Cloud Shell so aus, um die Beispielanwendung bereitzustellen:
```
kubectl apply -f deployment.yaml
```
Führen Sie den Befehl kubectl apply so aus, um einen Load-Balancer vor der Bereitstellung hinzuzufügen, damit Sie über das Internet darauf zugreifen können:
```
kubectl apply -f service.yaml
```
Führen Sie den Befehl kubectl get so aus, um die Dienstdetails abzurufen:
```
kubectl get services
```
Kopieren Sie die externe IP-Adresse, sobald sie in den Dienstdetails verfügbar ist. Dies kann einige Minuten dauern.
Sehen Sie sich die bereitgestellte Beispielanwendung an. Öffnen Sie ein Browserfenster und rufen Sie die externe IP-Adresse des Dienstes auf.

Private IP-Adresse

Mit der Konfiguration der Beispiel-App können Sie jetzt die Beispiel-App bereitstellen.

Go

Rufen Sie den Namen der Cloud SQL-Instanzverbindung mit dem Befehl gcloud sql instances describe ab:
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Aktualisieren Sie die Datei deployment.yaml im Cloud Shell-Editor. Nehmen Sie die folgenden Ersetzungen und Änderungen vor:

Ersetzen Sie <YOUR_KSA_NAME> durch ksa-cloud-sql.
Ersetzen Sie <LOCATION> durch us-central1.
Ersetzen Sie <YOUR_PROJECT_ID> durch die Projekt-ID.
Ersetzen Sie <YOUR-DB-SECRET> durch gke-cloud-sql-secrets.
Ersetzen Sie <INSTANCE_CONNECTION_NAME> durch den Verbindungsnamen der Cloud SQL-Instanz, der aus dem Befehl gcloud im vorherigen Schritt abgerufen wurde. Das Format ist project_id:region:instance_name. Der Instanzverbindungsname wird auch auf der Seite Übersicht der Cloud SQL-Instanz angezeigt.
Aktivieren Sie den Cloud SQL-Authentifizierungsproxy, um über seine private IP-Adresse eine Verbindung zu Ihrer Cloud SQL-Instanz herzustellen. Entfernen Sie das Kommentarzeichen des Flags "-ip_address_types=PRIVATE". Entfernen Sie dazu das Kommentarsymbol # und das nachgestellte Leerzeichen. Das Flag, bei dem das Kommentarzeichen entfernt wurde, sollte so aussehen:
```
- "-ip_address_types=PRIVATE"
```

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-cloud-sql-quickstart
spec:
  selector:
    matchLabels:
      app: gke-cloud-sql-app
  template:
    metadata:
      labels:
        app: gke-cloud-sql-app
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      - name: gke-cloud-sql-app
        # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
        # Replace <YOUR_PROJECT_ID> with your project ID.
        image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
        # 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_CONNECTION_NAME (proj:region:instance)
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "3306"
        # For Automatic IAM Authentication with the Go Connector
        # use DB_IAM_USER instead of DB_USER (recommended)
        # You may also remove the DB_PASS environment variable if
        # you use Automatic IAM Authentication
        - 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
      # If you are using the Go Connector (recommended), you can
      # remove cloud-sql-proxy (everything below this line)
      - name: cloud-sql-proxy
        # This uses the latest version of the Cloud SQL Proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy
        image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
        args:
          # If connecting from a VPC-native GKE cluster, you can use the
          # following flag to have the proxy connect over private IP
          # - "--private-ip"

          # If you are not connecting with Automatic IAM, you can delete
          # the following flag.
          - "--auto-iam-authn"

          # tcp should be set to the port the proxy should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - "--port=3306"
          - "<INSTANCE_CONNECTION_NAME>"
        securityContext:
          # The default Cloud SQL proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true

Führen Sie den Befehl kubectl apply in Cloud Shell so aus, um die Beispielanwendung bereitzustellen:
```
kubectl apply -f deployment.yaml
```
Führen Sie den Befehl kubectl apply so aus, um einen Load-Balancer vor der Bereitstellung hinzuzufügen, damit Sie über das Internet darauf zugreifen können:
```
kubectl apply -f service.yaml
```
Führen Sie den Befehl kubectl get so aus, um die Dienstdetails abzurufen:
```
kubectl get services
```
Kopieren Sie die externe IP-Adresse, sobald sie in den Dienstdetails verfügbar ist. Dies kann einige Minuten dauern.
Sehen Sie sich die bereitgestellte Beispielanwendung an. Öffnen Sie ein Browserfenster und rufen Sie die externe IP-Adresse des Dienstes auf.

Java

Die bereitgestellte Beispielanwendung stellt über den Cloud SQL-Java-Connector eine Verbindung zu Ihrer Cloud SQL-Instanz her.

Rufen Sie den Namen der Cloud SQL-Instanzverbindung mit dem Befehl gcloud sql instances describe ab:
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Aktualisieren Sie die Datei deployment.yaml im Cloud Shell-Editor. Ersetzen Sie die folgenden Werte:

<YOUR_KSA_NAME> mit ksa-cloud-sql.
<LOCATION> mit us-central1.
<YOUR_PROJECT_ID> durch die Projekt-ID.
<YOUR-DB-SECRET> mit gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> durch den Verbindungsnamen der Cloud SQL-Instanz, der aus dem Befehl gcloud im vorherigen Schritt abgerufen wurde. Das Format ist project_id:region:instance_name. Der Instanzverbindungsname wird auch auf der Seite Übersicht der Cloud SQL-Instanz angezeigt.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-cloud-sql-quickstart
spec:
  selector:
    matchLabels:
      app: gke-cloud-sql-app
  template:
    metadata:
      labels:
        app: gke-cloud-sql-app
    spec:
      # For more information about using Kubernetes service accounts see:
      # https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts
      serviceAccountName: <YOUR-KSA-NAME> # TODO(developer): replace this value.
      containers:
      - name: gke-cloud-sql-app
        # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
        # Replace <YOUR_PROJECT_ID> with your project ID.
        image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        - name: INSTANCE_CONNECTION_NAME
          value: <INSTANCE_CONNECTION_NAME>
        - name: DB_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "3306"
        - 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

Führen Sie den Befehl kubectl apply in Cloud Shell so aus, um die Beispielanwendung bereitzustellen:
```
kubectl apply -f deployment.yaml
```
Führen Sie den Befehl kubectl apply so aus, um einen Load-Balancer vor der Bereitstellung hinzuzufügen, damit Sie über das Internet darauf zugreifen können:
```
kubectl apply -f service.yaml
```
Führen Sie den Befehl kubectl get so aus, um die Dienstdetails abzurufen:
```
kubectl get services
```
Kopieren Sie die externe IP-Adresse, sobald sie in den Dienstdetails verfügbar ist. Dies kann einige Minuten dauern.
Sehen Sie sich die bereitgestellte Beispielanwendung an. Öffnen Sie ein Browserfenster und rufen Sie die externe IP-Adresse des Dienstes auf.

Node.js

Rufen Sie den Namen der Cloud SQL-Instanzverbindung mit dem Befehl gcloud sql instances describe ab:
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Aktualisieren Sie die Datei deployment.yaml im Cloud Shell-Editor. Nehmen Sie die folgenden Ersetzungen und Änderungen vor:

Ersetzen Sie <YOUR_KSA_NAME> durch ksa-cloud-sql.
Ersetzen Sie <LOCATION> durch us-central1.
Ersetzen Sie <YOUR_PROJECT_ID> durch die Projekt-ID.
Ersetzen Sie <YOUR-DB-SECRET> durch gke-cloud-sql-secrets.
Ersetzen Sie <INSTANCE_CONNECTION_NAME> durch den Verbindungsnamen der Cloud SQL-Instanz, der aus dem Befehl gcloud im vorherigen Schritt abgerufen wurde. Das Format ist project_id:region:instance_name. Der Instanzverbindungsname wird auch auf der Seite Übersicht der Cloud SQL-Instanz angezeigt.
Aktivieren Sie den Cloud SQL-Authentifizierungsproxy, um über seine private IP-Adresse eine Verbindung zu Ihrer Cloud SQL-Instanz herzustellen. Entfernen Sie das Kommentarzeichen des Flags "-ip_address_types=PRIVATE". Entfernen Sie dazu das Kommentarsymbol # und das nachgestellte Leerzeichen. Das Flag, bei dem das Kommentarzeichen entfernt wurde, sollte so aussehen:
```
- "-ip_address_types=PRIVATE"
```

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-cloud-sql-quickstart
spec:
  selector:
    matchLabels:
      app: gke-cloud-sql-app
  template:
    metadata:
      labels:
        app: gke-cloud-sql-app
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      - name: gke-cloud-sql-app
        # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
        # Replace <YOUR_PROJECT_ID> with your project ID.
        image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
        # 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: "3306"
        - 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
      - name: cloud-sql-proxy
        # This uses the latest version of the Cloud SQL proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy
        image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
        args:
          # If connecting from a VPC-native GKE cluster, you can use the
          # following flag to have the proxy connect over private IP
          # - "--private-ip"

          # If you are not connecting with Automatic IAM, you can delete
          # the following flag.
          - "--auto-iam-authn"

          # tcp should be set to the port the proxy should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - "--port=3306"
          - "<INSTANCE_CONNECTION_NAME>"
        securityContext:
          # The default Cloud SQL proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true

Führen Sie den Befehl kubectl apply in Cloud Shell so aus, um die Beispielanwendung bereitzustellen:
```
kubectl apply -f deployment.yaml
```
Führen Sie den Befehl kubectl apply so aus, um einen Load-Balancer vor der Bereitstellung hinzuzufügen, damit Sie über das Internet darauf zugreifen können:
```
kubectl apply -f service.yaml
```
Führen Sie den Befehl kubectl get so aus, um die Dienstdetails abzurufen:
```
kubectl get services
```
Kopieren Sie die externe IP-Adresse, sobald sie in den Dienstdetails verfügbar ist. Dies kann einige Minuten dauern.
Sehen Sie sich die bereitgestellte Beispielanwendung an. Öffnen Sie ein Browserfenster und rufen Sie die externe IP-Adresse des Dienstes auf.

cloud-sql/mysql/mysql/deployment.yaml

Python

Rufen Sie den Namen der Cloud SQL-Instanzverbindung mit dem Befehl gcloud sql instances describe ab:
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Aktualisieren Sie die Datei deployment.yaml im Cloud Shell-Editor. Nehmen Sie die folgenden Ersetzungen und Änderungen vor:

Ersetzen Sie <YOUR_KSA_NAME> durch ksa-cloud-sql.
Ersetzen Sie <LOCATION> durch us-central1.
Ersetzen Sie <YOUR_PROJECT_ID> durch die Projekt-ID.
Ersetzen Sie <YOUR-DB-SECRET> durch gke-cloud-sql-secrets.
Ersetzen Sie <INSTANCE_CONNECTION_NAME> durch den Verbindungsnamen der Cloud SQL-Instanz, der aus dem Befehl gcloud im vorherigen Schritt abgerufen wurde. Das Format ist project_id:region:instance_name. Der Instanzverbindungsname wird auch auf der Seite Übersicht der Cloud SQL-Instanz angezeigt.
Aktivieren Sie den Cloud SQL-Authentifizierungsproxy, um über seine private IP-Adresse eine Verbindung zu Ihrer Cloud SQL-Instanz herzustellen. Entfernen Sie das Kommentarzeichen des Flags "-ip_address_types=PRIVATE". Entfernen Sie dazu das Kommentarsymbol # und das nachgestellte Leerzeichen. Das Flag, bei dem das Kommentarzeichen entfernt wurde, sollte so aussehen:
```
- "-ip_address_types=PRIVATE"
```

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-cloud-sql-quickstart
spec:
  selector:
    matchLabels:
      app: gke-cloud-sql-app
  template:
    metadata:
      labels:
        app: gke-cloud-sql-app
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      - name: gke-cloud-sql-app
        # Replace <LOCATION> with your Artifact Registry location (e.g., us-central1).
        # Replace <YOUR_PROJECT_ID> with your project ID.
        image: <LOCATION>-docker.pkg.dev/<YOUR_PROJECT_ID>/gke-cloud-sql-repo/gke-sql:latest
        # 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 Python Connector (recommended) - use INSTANCE_CONNECTION_NAME (proj:region:instance)
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        # To use Unix, use INSTANCE_UNIX_SOCKET (e.g., /cloudsql/proj:region:instance)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "3306"
        # For Automatic IAM Authentication with the Python Connector
        # use DB_IAM_USER instead of DB_USER (recommended)
        # You may also remove the DB_PASS environment variable if
        # you use Automatic IAM Authentication
        - 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
      # If you are using the Python Connector (recommended), you can
      # remove cloud-sql-proxy (everything below this line)
      - name: cloud-sql-proxy
        # This uses the latest version of the Cloud SQL Proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/cloudsql-proxy
        image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:latest
        args:
          # If connecting from a VPC-native GKE cluster, you can use the
          # following flag to have the proxy connect over private IP
          # - "--private-ip"

          # If you are not connecting with Automatic IAM, you can delete
          # the following flag.
          - "--auto-iam-authn"

          # tcp should be set to the port the proxy should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - "--port=3306"
          - "<INSTANCE_CONNECTION_NAME>"
        securityContext:
          # The default Cloud SQL proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true

Führen Sie den Befehl kubectl apply in Cloud Shell so aus, um die Beispielanwendung bereitzustellen:
```
kubectl apply -f deployment.yaml
```
Führen Sie den Befehl kubectl apply so aus, um einen Load-Balancer vor der Bereitstellung hinzuzufügen, damit Sie über das Internet darauf zugreifen können:
```
kubectl apply -f service.yaml
```
Führen Sie den Befehl kubectl get so aus, um die Dienstdetails abzurufen:
```
kubectl get services
```
Kopieren Sie die externe IP-Adresse, sobald sie in den Dienstdetails verfügbar ist. Dies kann einige Minuten dauern.
Sehen Sie sich die bereitgestellte Beispielanwendung an. Öffnen Sie ein Browserfenster und rufen Sie die externe IP-Adresse des Dienstes auf.

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.

Cloud SQL-Instanzen aufrufen
Wählen Sie die Instanz quickstart-instance aus, um die Seite Instanzendetails zu öffnen.
Klicken Sie oben auf der Seite in der Symbolleiste auf Löschen.
Geben Sie im Dialogfeld Instanz löschen quickstart-instance ein und klicken Sie dann auf Löschen, um die Instanz zu löschen.
Rufen Sie in der Google Cloud Console die Seite Google Kubernetes Engine auf.

Zur Seite "Google Kubernetes Engine"
Klicken Sie auf das Kästchen neben dem Dienstnamen gke-cloud-sql-quickstart.
Klicken Sie oben auf der Seite von Google Kubernetes Engine auf die Schaltfläche Löschen.

Optionale Bereinigungsschritte

Wenn Sie nicht das Google Cloud-Dienstkonto verwenden, das Sie für diese Kurzanleitung erstellt haben, können Sie es entfernen.

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

IAM aufrufen
Klicken Sie auf das Kästchen für das IAM-Konto mit dem Namen gke-quickstart-service-account.
Klicken Sie auf Entfernen, um das Entfernen zu bestätigen.

Wenn Sie die APIs, die im Rahmen dieser Kurzanleitung aktiviert wurden, nicht verwenden, können Sie sie deaktivieren.

APIs, die in dieser Kurzanleitung aktiviert wurden:
- Compute Engine API
- Cloud SQL Admin API
- Google Kubernetes Engine API
- Artifact Registry API
- Cloud Build API

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

Zu „APIs“
Wählen Sie eine API aus, die Sie deaktivieren möchten, und klicken Sie dann auf die Schaltfläche API deaktivieren.

Nächste Schritte

Je nach Bedarf können Sie sich eingehender über das Erstellen von Cloud SQL-Instanzen informieren.

Informationen zum Anlegen von MySQL-Nutzern und -Datenbanken für Ihre Cloud SQL-Instanz erhalten Sie unter MySQL-Nutzer erstellen und verwalten und MySQL-Datenbanken erstellen und verwalten.

Sehen Sie sich auch Cloud SQL für MySQL – Preise an.

Mehr zu folgenden Themen:

Alle Verbindungsoptionen in Cloud SQL
Cloud SQL-Instanz mit einer öffentlichen IP-Adresse konfigurieren
Cloud SQL-Instanz mit einer privaten IP-Adresse konfigurieren

Außerdem erfahren Sie, wie Sie von anderen Google Cloud-Anwendungen aus eine Verbindung zu einer Cloud SQL-Instanz herstellen können: