Verbindung zu Cloud SQL for SQL Server mit Google Kubernetes Engine herstellen

MySQL | PostgreSQL | SQL Server

Auf dieser Seite wird beschrieben, wie Sie eine Beispielanwendung in Google Kubernetes Engine bereitstellen, die über die Google Cloud Console und eine Clientanwendung mit einer SQL Server-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

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 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 SQL Server.
Geben Sie unter Instanz-ID quickstart-instance ein.
Geben Sie ein Passwort für den sqlserver-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=SQLSERVER_2019_STANDARD \
--cpu=1 \
--memory=4GB \
--region=us-central \
--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 SQL Server.
Geben Sie unter Instanz-ID quickstart-instance ein.
Geben Sie ein Passwort für den sqlserver-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 Nur SSL-Verbindungen zulassen auf Speichern 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=SQLSERVER_2017_STANDARD \
 --cpu=1 \
 --memory=4GB \
 --region=us-central \
 --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 Neue Datenbank quickstart-db ein.
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

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"
```
Das Dienstkonto muss Images aus dem Artifactory-Repository abrufen können. Führen Sie daher den folgenden Befehl aus:
gcloud projects add-iam-policy-binding wie unten beschrieben, um die Artifact Registry-Leser Rolle dem 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/artifactregistry.reader"
```

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 Root-Nutzers sqlserver, der im Schritt Cloud SQL-Instanz erstellen erstellt wurde.

kubectl create secret generic gke-cloud-sql-secrets \
  --from-literal=database=quickstart-db \
  --from-literal=username=sqlserver \
  --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<
      contai>ners:
      - name: gke-cloud-sql-app
        # Replace LOCATION with yo<ur Artif>act Registry location (e.g., us-central1).
        # Replace YOUR_PROJECT_ID w<ith your projec>t ID.
        image: LOCATION-docker.pk<g.dev/YO>UR_PROJECT_ID/gk<e-cloud-sql-rep>o/gke-sql:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: 8080
        - name: INS"TANC"E_HOST
          value: 127.0.0.1
        - name: "DB_PORT
 "         value: 1433
        - name: DB_USER"
   "       valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key<: username
   >     - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: pas<sword
        >- 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

          # tcp should be set to the p"ort the prox"y should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - --port=1433
          - INSTANCE_CONNECTION_NAME
        "securityCon"text:
        "<  # The default Cloud SQ>"L proxy image runs as the
          # nonroot user and group (uid: 65532) by default.
          run"AsNonRo"ot: 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(develop>er): replace this value.
      containers:
      - name: gke-cloud-sql-app
        # Replace LOCATION with your< Artifac>t Registry location (e.g., us-central1).
        # Replace YOUR_PROJECT_ID wit<h 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: INSTA"NCE_"CONNECTION_NAME
          value: INSTANCE_CONNECTION_NAME
   <     - name: DB_HOST
   >       value: 127.0.0.1
        - name: DB_P"ORT
     "     value: 1433  
        - name: DB_USER
 "    "     valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: us<ername
       > - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: passwor<d
        - na>me: 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<
      contai>ners:
      - name: gke-cloud-sql-app
        # Replace LOCATION with yo<ur Artif>act Registry location (e.g., us-central1).
        # Replace YOUR_PROJECT_ID w<ith your projec>t ID.
        image: LOCATION-docker.pk<g.dev/YO>UR_PROJECT_ID/gk<e-cloud-sql-rep>o/gke-sql:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: 8080
        - name: INS"TANC"E_HOST
          value: 127.0.0.1
        - name: "DB_PORT
 "         value: 1433  
        - name: DB_US"ER
 "         valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key<: username
   >     - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: pas<sword
        >- 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

          # tcp should be set to the p"ort the prox"y should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - --port=1433
          - INSTANCE_CONNECTION_NAME
        "securityCon"text:
        "<  # The default Cloud SQ>"L proxy image runs as the
          # nonroot user and group (uid: 65532) by default.
          run"AsNonRo"ot: 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.

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<
      contai>ners:
      - name: gke-cloud-sql-app
        # Replace LOCATION with yo<ur Artif>act Registry location (e.g., us-central1).
        # Replace YOUR_PROJECT_ID w<ith your projec>t ID.
        image: LOCATION-docker.pk<g.dev/YO>UR_PROJECT_ID/gk<e-cloud-sql-rep>o/gke-sql:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: 8080
        # This proj"ect "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)
        - name: INSTANCE_HOST
          value: 127.0.0.1
        - name: DB_P"ORT
     "     value: 1433
        # If connecting fro"m a "VPC-native GKE cluster, you can use the
        # following environment variable to have the proxy connect over private IP
        # - name: CLOUD_SQL_AUTH_PROXY_IP_ADDRESS_TYPE
        #   value: PRIVATE
        - name: DB_USER
    "      v"alueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: userna<me
        - n>ame: DB_PASS
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: password
  <      - name: >DB_NAME
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: database
      #< If you are us>ing 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

          # tcp should be set to the port the pr"oxy should l"isten on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - --port=1433
          - INSTANCE_CONNECTION_NAME
        securityCo"ntext:
    "      # The de"<fault Cloud SQL proxy im>"age 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<
      contai>ners:
      - name: gke-cloud-sql-app
        # Replace LOCATION with yo<ur Artif>act Registry location (e.g., us-central1).
        # Replace YOUR_PROJECT_ID w<ith your projec>t ID.
        image: LOCATION-docker.pk<g.dev/YO>UR_PROJECT_ID/gk<e-cloud-sql-rep>o/gke-sql:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: 8080
        - name: INS"TANC"E_HOST
          value: 127.0.0.1
        - name: "DB_PORT
 "         value: 1433
        - name: DB_USER"
   "       valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key<: username
   >     - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: pas<sword
        >- 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

          # tcp should be set to the p"ort the prox"y should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - --port=1433
          - INSTANCE_CONNECTION_NAME
        "securityCon"text:
        "<  # The default Cloud SQ>"L proxy image runs as the
          # nonroot user and group (uid: 65532) by default.
          run"AsNonRo"ot: 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(develop>er): replace this value.
      containers:
      - name: gke-cloud-sql-app
        # Replace LOCATION with your< Artifac>t Registry location (e.g., us-central1).
        # Replace YOUR_PROJECT_ID wit<h 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: INSTA"NCE_"CONNECTION_NAME
          value: INSTANCE_CONNECTION_NAME
   <     - name: DB_HOST
   >       value: 127.0.0.1
        - name: DB_P"ORT
     "     value: 1433  
        - name: DB_USER
 "    "     valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: us<ername
       > - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: passwor<d
        - na>me: 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<
      contai>ners:
      - name: gke-cloud-sql-app
        # Replace LOCATION with yo<ur Artif>act Registry location (e.g., us-central1).
        # Replace YOUR_PROJECT_ID w<ith your projec>t ID.
        image: LOCATION-docker.pk<g.dev/YO>UR_PROJECT_ID/gk<e-cloud-sql-rep>o/gke-sql:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: 8080
        - name: INS"TANC"E_HOST
          value: 127.0.0.1
        - name: "DB_PORT
 "         value: 1433  
        - name: DB_US"ER
 "         valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key<: username
   >     - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: pas<sword
        >- 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

          # tcp should be set to the p"ort the prox"y should listen on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - --port=1433
          - INSTANCE_CONNECTION_NAME
        "securityCon"text:
        "<  # The default Cloud SQ>"L proxy image runs as the
          # nonroot user and group (uid: 65532) by default.
          run"AsNonRo"ot: 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.

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"
```
Entfernen Sie die Kommentarzeichen für die Umgebungsvariable - name: CLOUD_SQL_AUTH_PROXY_IP_ADDRESS_TYPE und ihren Wert. Entfernen Sie dazu die Kommentarsymbole # und die nachgestellten Leerzeichen. Die Umgebungsvariable mit entfernten Kommentarzeichen und der Wert sollten so aussehen:
```
 - name: CLOUD_SQL_AUTH_PROXY_IP_ADDRESS_TYPE
   value: "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<
      contai>ners:
      - name: gke-cloud-sql-app
        # Replace LOCATION with yo<ur Artif>act Registry location (e.g., us-central1).
        # Replace YOUR_PROJECT_ID w<ith your projec>t ID.
        image: LOCATION-docker.pk<g.dev/YO>UR_PROJECT_ID/gk<e-cloud-sql-rep>o/gke-sql:latest
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: 8080
        # This proj"ect "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)
        - name: INSTANCE_HOST
          value: 127.0.0.1
        - name: DB_P"ORT
     "     value: 1433
        # If connecting fro"m a "VPC-native GKE cluster, you can use the
        # following environment variable to have the proxy connect over private IP
        # - name: CLOUD_SQL_AUTH_PROXY_IP_ADDRESS_TYPE
        #   value: PRIVATE
        - name: DB_USER
    "      v"alueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: userna<me
        - n>ame: DB_PASS
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: password
  <      - name: >DB_NAME
          valueFrom:
            secretKeyRef:
              name: YOUR-DB-SECRET
              key: database
      #< If you are us>ing 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

          # tcp should be set to the port the pr"oxy should l"isten on
          # and should match the DB_PORT value set above.
          # Defaults: MySQL: 3306, Postgres: 5432, SQLServer: 1433
          - --port=1433
          - INSTANCE_CONNECTION_NAME
        securityCo"ntext:
    "      # The de"<fault Cloud SQL proxy im>"age 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.

Sie können sich auch über das Erstellen von SQL Server-Nutzern und -Datenbanken für Ihre Cloud SQL-Instanz informieren.

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: