本頁面由 Cloud Translation API 翻譯而成。

從 Google Kubernetes Engine 連線至 MySQL 適用的 Cloud SQL

本頁說明如何使用 Google Cloud 控制台和用戶端應用程式，在 Google Kubernetes Engine (GKE) 上部署連結至 MySQL 執行個體的範例應用程式。假設您及時完成所有步驟 (包括清除作業)，本快速入門導覽課程建立的資源通常不會超過一美元。

事前準備

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.

啟用必要的 Google Cloud API，以便在 GKE 上執行 Cloud SQL 範例應用程式。
控制台

按一下「Enable APIs」(啟用 API)，啟用本快速入門所需的 API。

啟用 API

這會啟用下列 API：
- Compute Engine API
- Cloud SQL Admin API
- Google Kubernetes Engine API
- Artifact Registry API
- Cloud Build API
gcloud

按一下下列按鈕開啟 Cloud Shell，直接在瀏覽器中使用指令列存取 Google Cloud 資源。您可以使用 Cloud Shell 執行本快速入門導覽課程中的 gcloud 指令。

開啟 Cloud Shell

使用 Cloud Shell 執行下列 gcloud services enable 指令，啟用本快速入門導覽課程所需的 API：
gcloud services enable compute.googleapis.com sqladmin.googleapis.com \ container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com
這個指令會啟用下列 API：
- Compute Engine API
- Cloud SQL Admin API
- GKE API
- Artifact Registry API
- Cloud Build API

設定 Cloud SQL

建立 Cloud SQL 執行個體

公開 IP

控制台

建立具有公開 IP 位址的執行個體

前往 Google Cloud 控制台的「Cloud SQL Instances」頁面。

前往 Cloud SQL 執行個體
點選「建立執行個體」。
按一下 [MySQL]。
在「Instance ID」(執行個體 ID) 中輸入 quickstart-instance。
輸入超級使用者的密碼。請儲存這個密碼，以供日後使用。
在「選擇區域和可用區供應情形」部分，點選「單一可用區」選項。
按一下並展開「顯示設定」部分。
在「Machine Type」(機器類型) 下拉式選單中，選取「Lightweight」(輕量)。
按一下「建立執行個體」，然後等待執行個體初始化並啟動。

gcloud

建立具有公開 IP 位址的執行個體

執行下列 gcloud sql instances create 指令前，請將 DB_ROOT_PASSWORD 替換為資料庫使用者的密碼。

視需要修改下列參數的值：

--database_version：資料庫引擎類型和版本。如未指定，系統會使用 API 預設值。如要查看目前可用的版本，請參閱 gcloud database versions 說明文件。
--cpu：機器中所需的核心數量。
--memory：整數值，表示機器所需的記憶體量。請提供大小單位 (例如 3072MB 或 9GB)。如未指定單位，系統會假設您使用的是 GB。
--region：執行個體所在的區域位置 (例如 asia-east1、us-east1)。如未指定，系統會使用預設的 us-central。查看完整區域清單。

執行 gcloud sql instances create 指令，建立 Cloud SQL 執行個體。

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

私人 IP

控制台

建立啟用 SSL 的私人 IP 位址執行個體

前往 Google Cloud 控制台的「Cloud SQL Instances」頁面。

前往 Cloud SQL 執行個體
點選「建立執行個體」。
按一下 [MySQL]。
在「Instance ID」(執行個體 ID) 中輸入 quickstart-instance。
輸入超級使用者的密碼。請儲存這個密碼，以供日後使用。
在「選擇區域和可用區供應情形」部分，點選「單一可用區」選項。
按一下並展開「顯示設定選項」。
在「機器類型」部分，選取「輕量」。
在「連線」部分，選取「私人 IP」。
在「網路」下拉式選單中選取「預設」。
如果看到「必須使用私人服務連線」對話方塊，請按一下「設定連線」按鈕。

在「啟用 Service Networking API」對話方塊中，按一下「啟用 API」按鈕。
在「Allocate an IP range」(分配 IP 範圍) 對話方塊中，選取「Use an automatically allocated IP range」(使用系統自動分配的 IP 範圍)，然後按一下「繼續」。
在「建立連線」對話方塊中，按一下「建立連線」。

取消勾選「公開 IP」核取方塊，即可建立僅使用私人 IP 的執行個體。
按一下「建立執行個體」，然後等待執行個體初始化並啟動。
按一下「連線」。
在「安全性」部分，選取「僅允許 SSL 連線」即可啟用 SSL 連線。
在「啟用 SSL」對話方塊中，按一下「啟用並重新啟動」，然後等待執行個體重新啟動。

gcloud

建立啟用 SSL 的私人 IP 位址執行個體

如要建立僅具備私人 IP 位址的執行個體，只需設定私人服務存取權，即可啟用來自其他 Google Cloud 服務 (例如 GKE) 的連線。

執行 gcloud compute addresses create 指令，為私人服務存取連線分配 IP 範圍：

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

執行 gcloud services vpc-peerings connect 指令，建立私人服務存取連線：

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

如要執行 gcloud sql instances create 指令來建立執行個體，請先將 DB_ROOT_PASSWORD 替換為資料庫使用者的密碼。

視需要修改下列參數的值：

--database_version：資料庫引擎類型和版本。如未指定，系統會使用 API 預設值。如要查看目前可用的版本清單，請參閱 gcloud database versions。
--cpu：機器中的核心數量。
--memory：整數，表示要納入機器的記憶體量。可以提供大小單位 (例如 3072MB 或 9GB)。如未指定單位，系統會假設您使用的是 GB。
--region：執行個體所在的區域位置 (例如 asia-east1、us-east1)。如未指定，系統會使用預設的 us-central1。查看完整區域清單。

執行 gcloud sql instances create 指令，建立使用私人 IP 位址的 Cloud SQL 執行個體。

 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

執行 gcloud sql instances patch 指令，僅允許執行個體使用 SSL 連線。

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

建立資料庫

控制台

前往 Google Cloud 控制台的「Cloud SQL Instances」頁面。

前往 Cloud SQL 執行個體
選取「quickstart-instance」。
在 SQL 導覽選單中，選取「資料庫」。
按一下 [Create database] (建立資料庫)。

在「Create a database」(建立資料庫) 對話方塊的「Database name」(資料庫名稱) 欄位中，輸入 quickstart-db。保留字元集和定序的值。
點選「建立」。

gcloud

執行 gcloud sql databases create 指令來建立資料庫。

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

新增使用者

控制台

前往 Google Cloud 控制台的「Cloud SQL Instances」頁面。

前往 Cloud SQL 執行個體
如要開啟執行個體的「總覽」頁面，請按一下執行個體名稱。
在 SQL 導覽選單中選取「使用者」。
按一下「新增使用者帳戶」。

在「Add a user account to instance instance_name」(在執行個體「instance_name」中新增使用者帳戶) 頁面中，新增下列資訊：
- 使用者名稱：設為 quickstart-user
- 密碼：指定資料庫使用者的密碼。請記下這個值，本快速入門導覽課程的後續步驟會用到。
- 在「主機名稱」部分，預設為「允許任何主機」，表示使用者可以從任何 IP 位址連線。
  (選用) 選取「依 IP 位址或位址範圍限制主機」，然後在「主機」區段中輸入 IP 位址或位址範圍。使用者只能從指定的 IP 位址或位址連線。

按一下「新增」。

gcloud

執行下列指令前，請先將 DB_PASS 替換為資料庫使用者的密碼。請記下這個值，本快速入門導覽課程稍後會用到。

執行 gcloud sql users create 指令來建立使用者。

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

Cloud SQL 的使用者名稱長度限制與地端 MySQL 相同：MySQL 8.0 以上版本為 32 個字元，舊版則為 16 個字元。

建立 GKE 叢集

控制台

在 Google Cloud 控制台中，前往「Google Kubernetes Engine」頁面。

前往「Google Kubernetes Engine」
點選「建立」。
按一下 GKE Autopilot 的「設定」。
在「Name」(名稱) 中，將叢集名稱指定為 gke-cloud-sql-quickstart。
點選「建立」。

gcloud

執行 gcloud container clusters create-auto 指令來建立叢集。

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

將 Cloud SQL 範例應用程式複製到 Cloud Shell 編輯器

有了 Cloud SQL 執行個體、資料庫和 GKE 叢集，您現在可以複製及設定範例應用程式，連線至 Cloud SQL 執行個體。本快速入門導覽課程的其餘步驟需要使用 gcloud 和 kubectl 指令列工具。Cloud Shell 中已預先安裝這兩項工具。

Go

在 Cloud Shell 編輯器中開啟範例應用程式的原始碼。
開啟 Cloud Shell 編輯器
在 Open in Cloud Shell 對話方塊中，按一下「確認」，下載範例應用程式程式碼，並在 Cloud Shell 編輯器中開啟範例應用程式目錄。

Java

在 Cloud Shell 編輯器中開啟範例應用程式的原始碼。
開啟 Cloud Shell 編輯器
在 Open in Cloud Shell 對話方塊中，按一下「確認」，下載範例應用程式程式碼，並在 Cloud Shell 編輯器中開啟範例應用程式目錄。

Node.js

在 Cloud Shell 編輯器中開啟範例應用程式的原始碼。
開啟 Cloud Shell 編輯器
在 Open in Cloud Shell 對話方塊中，按一下「確認」，下載範例應用程式程式碼，並在 Cloud Shell 編輯器中開啟範例應用程式目錄。

Python

在 Cloud Shell 編輯器中開啟範例應用程式的原始碼。
開啟 Cloud Shell 編輯器
在 Open in Cloud Shell 對話方塊中，按一下「確認」，下載範例應用程式程式碼，並在 Cloud Shell 編輯器中開啟範例應用程式目錄。

啟用 GKE 叢集

啟用您剛建立的 GKE 叢集，做為本快速入門導覽課程中其餘指令使用的預設叢集。

執行 gcloud container clusters get-credentials 指令，啟用 GKE 叢集。

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

設定服務帳戶

建立及設定供 GKE 使用的 Google Cloud 服務帳戶，並指派「Cloud SQL 用戶端」角色，授予連線至 Cloud SQL 的權限。

執行下列 gcloud iam service-accounts create 指令，建立新的服務帳戶：

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

執行下列 gcloud projects add-iam-policy-binding 指令，將「Cloud SQL Client」(Cloud SQL 用戶端) 角色新增至您剛建立的 Google Cloud 服務帳戶。將 YOUR_PROJECT_ID 替換為專案 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"
```
範例應用程式會使用記錄功能，因此請執行下列 gcloud projects add-iam-policy-binding 指令，將「記錄寫入者」角色新增至您剛建立的 Google Cloud 服務帳戶。將 YOUR_PROJECT_ID 替換為專案 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"
```
服務帳戶必須能夠從 Artifactory 存放區提取映像檔，因此請執行
gcloud projects add-iam-policy-binding 指令，將「Artifact Registry Reader」角色新增至服務帳戶。將 YOUR_PROJECT_ID 替換為專案 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"
```

建立 Kubernetes 服務帳戶，並使用 Workload Identity Federation for GKE 將該帳戶繫結至 Google Cloud 服務帳戶，藉此設定帳戶的 Cloud SQL 存取權。

建立 Kubernetes 服務帳戶。
1. 在 Cloud Shell 編輯器中更新 service-account.yaml 檔案。將 <YOUR-KSA-NAME> 替換為 ksa-cloud-sql。
2. 在 Cloud Shell 中執行 kubectl apply 指令，如下所示：
```
kubectl apply -f service-account.yaml
```
執行下列 gcloud iam service-accounts add-iam-policy-binding 指令，啟用 Google Cloud 服務帳戶和 Kubernetes 服務帳戶的 IAM 繫結。進行下列替換：
- 將 YOUR_PROJECT_ID 替換為專案 ID。
- YOUR_K8S_NAMESPACE，default 是在 GKE 中建立叢集的預設命名空間。
- YOUR_KSA_NAME 搭配 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
```
執行下列 kubectl annotate 指令，使用 IAM 繫結註解 Kubernetes 服務帳戶。進行下列替換：
- YOUR_KSA_NAME 搭配 ksa-cloud-sql。
- 將 YOUR_PROJECT_ID 替換為專案 ID。
```
kubectl annotate serviceaccount \
  YOUR_KSA_NAME  \
  iam.gke.io/gcp-service-account=gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com
```

設定密鑰

執行下列 kubectl create secret generic 指令，為範例應用程式使用的資料庫、使用者和使用者密碼建立 Kubernetes 密鑰。每個密鑰的值都以本快速入門導覽先前步驟中指定的值為準。將 DB_PASS 替換為您在上一個「建立使用者」快速入門步驟中建立的 quickstart-user 密碼。

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

建構範例應用程式

Go

在 Cloud Shell 中執行下列 gcloud artifacts repositories create 指令，在 Artifact Registry 中建立名為 gke-cloud-sql-repo 的存放區，並與叢集位於相同區域。將 YOUR_PROJECT_ID 替換為專案 ID。
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
在 Cloud Shell 中執行下列 gcloud builds submit 指令，建構 Docker 容器並發布至 Artifact Registry。將 YOUR_PROJECT_ID 替換為專案 ID。
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

Java

在 Cloud Shell 中執行下列 gcloud artifacts repositories create 指令，在 Artifact Registry 中建立名為 gke-cloud-sql-repo 的存放區，並與叢集位於相同區域。將 YOUR_PROJECT_ID 替換為專案 ID。
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```

在 Cloud Shell 中執行下列 mvn 指令，建構 Docker 容器並發布至 Artifact Registry。將 YOUR_PROJECT_ID 替換為專案 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

在 Cloud Shell 中執行下列 gcloud artifacts repositories create 指令，在 Artifact Registry 中建立名為 gke-cloud-sql-repo 的存放區，並與叢集位於相同區域。將 YOUR_PROJECT_ID 替換為專案 ID。
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
在 Cloud Shell 中執行下列 gcloud builds submit 指令，建構 Docker 容器並發布至 Artifact Registry。將 YOUR_PROJECT_ID 替換為專案 ID。
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

Python

在 Cloud Shell 中執行下列 gcloud artifacts repositories create 指令，在 Artifact Registry 中建立名為 gke-cloud-sql-repo 的存放區，並與叢集位於相同區域。將 YOUR_PROJECT_ID 替換為專案 ID。
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
在 Cloud Shell 中執行下列 gcloud builds submit 指令，建構 Docker 容器並發布至 Artifact Registry。將 YOUR_PROJECT_ID 替換為專案 ID。
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

部署範例應用程式

公開 IP

設定範例應用程式後，您現在可以部署範例應用程式。

Go

部署的範例應用程式會使用 Kubernetes Sidecar 模式執行的 Cloud SQL Proxy，連線至 Cloud SQL 執行個體。如要採用 Sidecar 模式，請部署工作負載，並新增一個容器，與範例應用程式的容器共用同一個 Kubernetes Pod。

執行 gcloud sql instances describe 指令，取得 Cloud SQL 執行個體連線名稱：
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

在 Cloud Shell 編輯器中更新 deployment.yaml 檔案。進行下列替換：

<YOUR_KSA_NAME> 搭配 ksa-cloud-sql。
<LOCATION> 搭配 us-central1。
將 <YOUR_PROJECT_ID> 替換為專案 ID。
<YOUR-DB-SECRET> 搭配 gke-cloud-sql-secrets。
<INSTANCE_CONNECTION_NAME>，並將其替換為上一步中透過 gcloud 指令擷取的 Cloud SQL 執行個體連線名稱。格式為 project_id:region:instance_name。您也可以在 Cloud SQL 執行個體的「總覽」頁面中，看到執行個體連線名稱。

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

在 Cloud Shell 中執行下列 kubectl apply 指令，部署範例應用程式：
```
kubectl apply -f deployment.yaml
```
執行下列 kubectl apply 指令，在部署作業前方新增負載平衡器，以便透過網際網路存取：
```
kubectl apply -f service.yaml
```
執行下列 kubectl get 指令，取得服務詳細資料：
```
kubectl get services
```
服務詳細資料中會顯示「外部 IP」位址，複製該位址。這可能需要幾分鐘的時間。
查看已部署的範例應用程式。開啟瀏覽器視窗，然後前往服務的「外部 IP」位址。

Java

部署的範例應用程式會使用 Cloud SQL Java 連接器連線至 Cloud SQL 執行個體。

執行 gcloud sql instances describe 指令，取得 Cloud SQL 執行個體連線名稱：
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

在 Cloud Shell 編輯器中更新 deployment.yaml 檔案。進行下列替換：

<YOUR_KSA_NAME> 搭配 ksa-cloud-sql。
<LOCATION> 搭配 us-central1。
將 <YOUR_PROJECT_ID> 替換為專案 ID。
<YOUR-DB-SECRET> 搭配 gke-cloud-sql-secrets。
<INSTANCE_CONNECTION_NAME>，並將其替換為上一步中透過 gcloud 指令擷取的 Cloud SQL 執行個體連線名稱。格式為 project_id:region:instance_name。您也可以在 Cloud SQL 執行個體的「總覽」頁面中，看到執行個體連線名稱。

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

在 Cloud Shell 中執行下列 kubectl apply 指令，部署範例應用程式：
```
kubectl apply -f deployment.yaml
```
執行下列 kubectl apply 指令，在部署作業前方新增負載平衡器，以便透過網際網路存取：
```
kubectl apply -f service.yaml
```
執行下列 kubectl get 指令，取得服務詳細資料：
```
kubectl get services
```
服務詳細資料中會顯示「外部 IP」位址，複製該位址。這可能需要幾分鐘的時間。
查看已部署的範例應用程式。開啟瀏覽器視窗，然後前往服務的「外部 IP」位址。

Node.js

執行 gcloud sql instances describe 指令，取得 Cloud SQL 執行個體連線名稱：
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

在 Cloud Shell 編輯器中更新 deployment.yaml 檔案。進行下列替換：

<YOUR_KSA_NAME> 搭配 ksa-cloud-sql。
<LOCATION> 搭配 us-central1。
將 <YOUR_PROJECT_ID> 替換為專案 ID。
<YOUR-DB-SECRET> 搭配 gke-cloud-sql-secrets。
<INSTANCE_CONNECTION_NAME>，並將其替換為上一步中透過 gcloud 指令擷取的 Cloud SQL 執行個體連線名稱。格式為 project_id:region:instance_name。您也可以在 Cloud SQL 執行個體的「總覽」頁面中，看到執行個體連線名稱。

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

在 Cloud Shell 中執行下列 kubectl apply 指令，部署範例應用程式：
```
kubectl apply -f deployment.yaml
```
執行下列 kubectl apply 指令，在部署作業前方新增負載平衡器，以便透過網際網路存取：
```
kubectl apply -f service.yaml
```
執行下列 kubectl get 指令，取得服務詳細資料：
```
kubectl get services
```
服務詳細資料中會顯示「外部 IP」位址，複製該位址。這可能需要幾分鐘的時間。
查看已部署的範例應用程式。開啟瀏覽器視窗，然後前往服務的「外部 IP」位址。

cloud-sql/mysql/mysql/deployment.yaml

Python

執行 gcloud sql instances describe 指令，取得 Cloud SQL 執行個體連線名稱：
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

在 Cloud Shell 編輯器中更新 deployment.yaml 檔案。進行下列替換：

<YOUR_KSA_NAME> 搭配 ksa-cloud-sql。
<LOCATION> 搭配 us-central1。
將 <YOUR_PROJECT_ID> 替換為專案 ID。
<YOUR-DB-SECRET> 搭配 gke-cloud-sql-secrets。
<INSTANCE_CONNECTION_NAME>，並將其替換為上一步中透過 gcloud 指令擷取的 Cloud SQL 執行個體連線名稱。格式為 project_id:region:instance_name。您也可以在 Cloud SQL 執行個體的「總覽」頁面中，看到執行個體連線名稱。

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

在 Cloud Shell 中執行下列 kubectl apply 指令，部署範例應用程式：
```
kubectl apply -f deployment.yaml
```
執行下列 kubectl apply 指令，在部署作業前方新增負載平衡器，以便透過網際網路存取：
```
kubectl apply -f service.yaml
```
執行下列 kubectl get 指令，取得服務詳細資料：
```
kubectl get services
```
服務詳細資料中會顯示「外部 IP」位址，複製該位址。這可能需要幾分鐘的時間。
查看已部署的範例應用程式。開啟瀏覽器視窗，然後前往服務的「外部 IP」位址。

私人 IP

設定範例應用程式後，您現在可以部署範例應用程式。

Go

執行 gcloud sql instances describe 指令，取得 Cloud SQL 執行個體連線名稱：
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

在 Cloud Shell 編輯器中更新 deployment.yaml 檔案。進行下列替換和編輯：

將 <YOUR_KSA_NAME> 替換為 ksa-cloud-sql。
將 <LOCATION> 替換為 us-central1。
將 <YOUR_PROJECT_ID> 替換為專案 ID。
將 <YOUR-DB-SECRET> 替換為 gke-cloud-sql-secrets。
將 <INSTANCE_CONNECTION_NAME> 改成從上一步的 gcloud 指令擷取的 Cloud SQL 執行個體連線名稱。格式為 project_id:region:instance_name。您也可以在 Cloud SQL 執行個體的「總覽」頁面中，看到執行個體連線名稱。
啟用 Cloud SQL Auth Proxy，使用私人 IP 位址連線至 Cloud SQL 執行個體。移除 # 註解符號和結尾的空格，取消註解 "-ip_address_types=PRIVATE" 標記。未註解的旗標應如下所示：
```
- "-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

在 Cloud Shell 中執行下列 kubectl apply 指令，部署範例應用程式：
```
kubectl apply -f deployment.yaml
```
執行下列 kubectl apply 指令，在部署作業前方新增負載平衡器，以便透過網際網路存取：
```
kubectl apply -f service.yaml
```
執行下列 kubectl get 指令，取得服務詳細資料：
```
kubectl get services
```
服務詳細資料中會顯示「外部 IP」位址，複製該位址。這可能需要幾分鐘的時間。
查看已部署的範例應用程式。開啟瀏覽器視窗，然後前往服務的「外部 IP」位址。

Java

部署的範例應用程式會使用 Cloud SQL Java 連接器連線至 Cloud SQL 執行個體。

執行 gcloud sql instances describe 指令，取得 Cloud SQL 執行個體連線名稱：
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

在 Cloud Shell 編輯器中更新 deployment.yaml 檔案。進行下列替換：

<YOUR_KSA_NAME> 搭配 ksa-cloud-sql。
<LOCATION> 搭配 us-central1。
將 <YOUR_PROJECT_ID> 替換為專案 ID。
<YOUR-DB-SECRET> 搭配 gke-cloud-sql-secrets。
<INSTANCE_CONNECTION_NAME>，並將其替換為上一步中透過 gcloud 指令擷取的 Cloud SQL 執行個體連線名稱。格式為 project_id:region:instance_name。您也可以在 Cloud SQL 執行個體的「總覽」頁面中，看到執行個體連線名稱。

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

在 Cloud Shell 中執行下列 kubectl apply 指令，部署範例應用程式：
```
kubectl apply -f deployment.yaml
```
執行下列 kubectl apply 指令，在部署作業前方新增負載平衡器，以便透過網際網路存取：
```
kubectl apply -f service.yaml
```
執行下列 kubectl get 指令，取得服務詳細資料：
```
kubectl get services
```
服務詳細資料中會顯示「外部 IP」位址，複製該位址。這可能需要幾分鐘的時間。
查看已部署的範例應用程式。開啟瀏覽器視窗，然後前往服務的「外部 IP」位址。

Node.js

執行 gcloud sql instances describe 指令，取得 Cloud SQL 執行個體連線名稱：
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

在 Cloud Shell 編輯器中更新 deployment.yaml 檔案。進行下列替換和編輯：

將 <YOUR_KSA_NAME> 替換為 ksa-cloud-sql。
將 <LOCATION> 替換為 us-central1。
將 <YOUR_PROJECT_ID> 替換為專案 ID。
將 <YOUR-DB-SECRET> 替換為 gke-cloud-sql-secrets。
將 <INSTANCE_CONNECTION_NAME> 改成從上一步的 gcloud 指令擷取的 Cloud SQL 執行個體連線名稱。格式為 project_id:region:instance_name。您也可以在 Cloud SQL 執行個體的「總覽」頁面中，看到執行個體連線名稱。
啟用 Cloud SQL Auth Proxy，使用私人 IP 位址連線至 Cloud SQL 執行個體。移除 # 註解符號和結尾的空格，取消註解 "-ip_address_types=PRIVATE" 標記。未註解的旗標應如下所示：
```
- "-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

在 Cloud Shell 中執行下列 kubectl apply 指令，部署範例應用程式：
```
kubectl apply -f deployment.yaml
```
執行下列 kubectl apply 指令，在部署作業前方新增負載平衡器，以便透過網際網路存取：
```
kubectl apply -f service.yaml
```
執行下列 kubectl get 指令，取得服務詳細資料：
```
kubectl get services
```
服務詳細資料中會顯示「外部 IP」位址，複製該位址。這可能需要幾分鐘的時間。
查看已部署的範例應用程式。開啟瀏覽器視窗，然後前往服務的「外部 IP」位址。

cloud-sql/mysql/mysql/deployment.yaml

Python

執行 gcloud sql instances describe 指令，取得 Cloud SQL 執行個體連線名稱：
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

在 Cloud Shell 編輯器中更新 deployment.yaml 檔案。進行下列替換和編輯：

將 <YOUR_KSA_NAME> 替換為 ksa-cloud-sql。
將 <LOCATION> 替換為 us-central1。
將 <YOUR_PROJECT_ID> 替換為專案 ID。
將 <YOUR-DB-SECRET> 替換為 gke-cloud-sql-secrets。
將 <INSTANCE_CONNECTION_NAME> 改成從上一步的 gcloud 指令擷取的 Cloud SQL 執行個體連線名稱。格式為 project_id:region:instance_name。您也可以在 Cloud SQL 執行個體的「總覽」頁面中，看到執行個體連線名稱。
啟用 Cloud SQL Auth Proxy，使用私人 IP 位址連線至 Cloud SQL 執行個體。移除 # 註解符號和結尾的空格，取消註解 "-ip_address_types=PRIVATE" 標記。未註解的旗標應如下所示：
```
- "-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

在 Cloud Shell 中執行下列 kubectl apply 指令，部署範例應用程式：
```
kubectl apply -f deployment.yaml
```
執行下列 kubectl apply 指令，在部署作業前方新增負載平衡器，以便透過網際網路存取：
```
kubectl apply -f service.yaml
```
執行下列 kubectl get 指令，取得服務詳細資料：
```
kubectl get services
```
服務詳細資料中會顯示「外部 IP」位址，複製該位址。這可能需要幾分鐘的時間。
查看已部署的範例應用程式。開啟瀏覽器視窗，然後前往服務的「外部 IP」位址。

清除所用資源

如要避免系統向您的 Google Cloud 帳戶收取本頁所用資源的費用，請按照下列步驟操作。

前往 Google Cloud 控制台的「Cloud SQL Instances」頁面。

前往 Cloud SQL 執行個體
選取 quickstart-instance 執行個體，開啟「Instance details」(執行個體詳細資料) 頁面。
在頁面頂端的圖示列中，按一下 [刪除]。
在「Delete instance」(刪除執行個體) 對話方塊中輸入 quickstart-instance，然後按一下「Delete」(刪除) 以刪除執行個體。
在 Google Cloud 控制台中，前往「Google Kubernetes Engine」頁面。

前往「Google Kubernetes Engine」
按一下「gke-cloud-sql-quickstart」服務名稱旁邊的核取方塊。
按一下 Google Kubernetes Engine 頁面頂端的「刪除」按鈕。

選用清除步驟

如果您未使用為本快速入門指南建立的 Google Cloud 服務帳戶，可以將其移除。

前往 Google Cloud 控制台的「IAM」頁面。

前往「IAM」頁面
選取名為「gke-quickstart-service-account」的 IAM 帳戶核取方塊。
按一下「移除」並確認移除。

如果您未使用本快速入門導覽課程啟用的 API，可以停用這些 API。

本快速入門導覽課程中啟用的 API：
- Compute Engine API
- Cloud SQL Admin API
- Google Kubernetes Engine API
- Artifact Registry API
- Cloud Build API

前往 Google Cloud 控制台的「API」頁面。

前往 API 頁面
選取要停用的 API，然後按一下「停用 API」按鈕。

後續步驟

您可以根據需求，進一步瞭解如何建立 Cloud SQL 執行個體。

您也可以瞭解如何建立 Cloud SQL 執行個體的 MySQL 使用者和資料庫。

另請參閱 Cloud SQL 定價資訊。

請點選下列連結瞭解更多資訊：

Cloud SQL 中的所有連線選項。
使用公開 IP 位址設定 Cloud SQL 執行個體。
為 Cloud SQL 執行個體設定私人 IP 位址。

此外，您也可以瞭解如何從其他 Google Cloud 應用程式連線至 Cloud SQL 執行個體：