从 Google Kubernetes Engine 连接到 Cloud SQL for SQL Server

MySQL | PostgreSQL | SQL Server

本页面介绍如何使用 Google Cloud 控制台和客户端应用在连接到 SQL Server 实例的 Google Kubernetes Engine (GKE) 上部署示例应用。如果您及时完成本快速入门中的步骤（包括清理），那么在此期间所创建资源的费用通常不会超过 1 美元。

准备工作

登录您的 Google Cloud 账号。如果您是 Google Cloud新手，请创建一个账号来评估我们的产品在实际场景中的表现。新客户还可获享 $300 赠金，用于运行、测试和部署工作负载。

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that you have the permissions required to complete this guide.

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry, Cloud Build, Cloud SQL Admin, Compute Engine, Kubernetes Engine, Service Networking APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

安装 gcloud CLI。

注意：如果您之前安装了 gcloud CLI，请确保通过运行 gcloud components update 来获得最新版本。

如果您使用的是外部身份提供方 (IdP)，则必须先使用联合身份登录 gcloud CLI。

如需初始化 gcloud CLI，请运行以下命令：

gcloud init

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that you have the permissions required to complete this guide.

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry, Cloud Build, Cloud SQL Admin, Compute Engine, Kubernetes Engine, Service Networking APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

安装 gcloud CLI。

注意：如果您之前安装了 gcloud CLI，请确保通过运行 gcloud components update 来获得最新版本。

如果您使用的是外部身份提供方 (IdP)，则必须先使用联合身份登录 gcloud CLI。

如需初始化 gcloud CLI，请运行以下命令：

gcloud init

所需的角色

如需获得完成本快速入门中所述任务所需的权限，请让您的管理员为您授予快速入门项目的以下 IAM 角色：

创建、更新或删除所有 Cloud SQL 实例、数据库和用户：
- Cloud SQL Admin (roles/cloudsql.admin)
- Compute Viewer (roles/compute.viewer)
创建具有专用 IP 的 Cloud SQL 实例（专用服务访问通道连接）： Compute 网络管理员 (roles/compute.networkadmin)
创建和管理 Google Kubernetes Engine 集群： Kubernetes Engine Admin (roles/container.admin)
为项目创建和管理服务账号：
- Project IAM Admin (roles/resourcemanager.projectIamAdmin)
- Service Account Admin (roles/serviceAccountAdmin)
在 Artifact Registry 中为项目创建制品库： Artifact Registry Administrator (roles/artifactregistry.admin)
在 Cloud Build 中提交和构建应用：
- Cloud Build Editor (roles/cloudbuilds.builds.editor)
- Storage Object Creator (roles/storage.objectCreator)
- Storage Bucket Viewer (roles/storage.bucketViewer)
- Service Account User (roles/iam.serviceAccountUser)
- Logs Viewer (roles/logging.viewer)

如需详细了解如何授予角色，请参阅管理对项目、文件夹和组织的访问权限。

您也可以通过自定义角色或其他预定义角色来获取所需的权限。

设置 Cloud SQL

创建 Cloud SQL 实例

公共 IP

控制台

创建具有公共 IP 地址的实例

在 Google Cloud 控制台中，前往 Cloud SQL 实例页面。

转到“Cloud SQL 实例”
点击创建实例。
点击 SQL Server。
在实例 ID 部分输入 quickstart-instance。
为 sqlserver 用户输入密码。保存此密码以供将来使用。
在选择区域和地区可用性中点击单个区域选项。
点击并展开显示配置部分。
在机器类型下拉菜单中，选择轻量级。
点击创建实例，然后等待实例初始化并启动。

gcloud

创建具有公共 IP 地址的实例

按照以下方式运行 gcloud sql instances create 命令之前，请将 DB_ROOT_PASSWORD 替换为数据库用户的密码。

（可选）修改以下参数的值：

--database_version：数据库引擎类型和版本。如果未指定，则使用 API 默认值。请参阅 gcloud 数据库版本文档，以查看当前可用版本。
--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=SQLSERVER_2019_STANDARD \
--cpu=1 \
--memory=4GB \
--region=us-central \
--root-password=DB_ROOT_PASSWORD

专用 IP

控制台

创建具有专用 IP 地址且启用了 SSL 的实例

在 Google Cloud 控制台中，前往 Cloud SQL 实例页面。

转到“Cloud SQL 实例”
点击创建实例。
点击 SQL Server。
在实例 ID 部分输入 quickstart-instance。
为 sqlserver 用户输入密码。保存此密码以供将来使用。
在选择区域和地区可用性中点击单个区域选项。
点击并展开显示配置选项。
对于机器类型，选择轻量级。
在连接中，选择专用 IP。
在网络下拉菜单中，选择默认。
如果您看到显示需要专用服务访问通道连接的对话框，请点击设置连接按钮。

在启用 Service Networking API 对话框中，点击启用 API 按钮。
在分配 IP 范围对话框中，选择使用自动分配的 IP 范围，然后点击继续。
在创建连接对话框中，点击创建连接。

取消选中公共 IP 复选框以创建仅使用专用 IP 地址的实例。
点击创建实例，然后等待实例初始化并启动。
点击连接。
在安全性部分中，选择仅允许 SSL 连接以启用 SSL 连接。
在仅允许 SSL 连接对话框中，点击保存并重启，然后等待实例重启。

gcloud

创建具有专用 IP 地址且启用了 SSL 的实例

创建具有专用 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 数据库版本。
--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=SQLSERVER_2017_STANDARD \
 --cpu=1 \
 --memory=4GB \
 --region=us-central \
 --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 实例页面。

转到“Cloud SQL 实例”
选择 quickstart-instance。
从 SQL 导航菜单中选择数据库。
点击创建数据库。

在新建数据库对话框的数据库名称字段中，输入 quickstart-db。
点击创建。

gcloud

运行 gcloud sql databases create 命令以创建数据库。

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

创建 GKE 集群

控制台

在 Google Cloud 控制台中，前往 Google Kubernetes Engine 页面。

转到 Google Kubernetes Engine
点击创建。
点击 GKE Autopilot 的配置。
对于名称，请将集群名称指定为 gke-cloud-sql-quickstart。
点击创建。

gcloud

运行 gcloud container clusters create-auto 命令以创建集群。

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

使用 Cloud Shell 从 GitHub 克隆 Cloud SQL 示例应用

创建好 Cloud SQL 实例、数据库和 GKE 集群后，您现在可以克隆和配置连接到 Cloud SQL 实例的示例应用。示例应用存储在 GitHub 中。本快速入门中的其余步骤需要使用 Cloud Shell、gcloud 和 kubectl。 gcloud 和 kubectl 工具已预安装在 Cloud Shell 中。

Go

在 Cloud Shell Editor 中，打开示例应用的源代码。
打开 Cloud Shell Editor
在“Open in Cloud Shell”对话框中，点击确认下载示例应用代码，然后在 Cloud Shell Editor 中打开示例应用目录。

Java

在 Cloud Shell Editor 中，打开示例应用的源代码。
打开 Cloud Shell Editor
在“Open in Cloud Shell”对话框中，点击确认下载示例应用代码，然后在 Cloud Shell Editor 中打开示例应用目录。

Node.js

在 Cloud Shell Editor 中，打开示例应用的源代码。
打开 Cloud Shell Editor
在“Open in Cloud Shell”对话框中，点击确认下载示例应用代码，然后在 Cloud Shell Editor 中打开示例应用目录。

Python

在 Cloud Shell Editor 中，打开示例应用的源代码。
打开 Cloud Shell Editor
在“Open in Cloud Shell”对话框中，点击确认下载示例应用代码，然后在 Cloud Shell Editor 中打开示例应用目录。

启用 GKE 集群

启用您刚刚创建的 GKE 集群并将其设置为默认集群，以用于本快速入门中的其余命令。

按照以下方式运行 gcloud container clusters get-credentials 命令以启用 GKE 集群。

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

设置服务账号

创建并配置 Google Cloud 服务账号以供 GKE 使用，使其具有有权连接到 Cloud SQL 的 Cloud SQL Client 角色。

按照以下方式运行 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 角色添加到您刚刚创建的 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 命令，以将 Log Writer 角色添加到您刚刚创建的 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 Editor 中更新 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
```

配置 Secret

按照以下方式运行 kubectl create secret generic 命令，为示例应用要使用的数据库、用户和用户密码创建 Kubernetes Secret。每个 Secret 的值均基于本快速入门前面的步骤中指定的值。将 DB_PASS 替换为在创建 Cloud SQL 实例步骤中创建的 sqlserver 根用户的密码。

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

构建示例应用

Go

返回 Cloud Shell 编辑器，然后点击打开终端以打开 Cloud Shell 提示符。
在 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"
```
将目录更改为您之前从 GitHub 克隆 Cloud SQL 示例应用的位置。示例应用目录包含示例应用的 Dockerfile。例如，如需将目录更改为示例应用的目录，您可以运行如下命令：
```
cd ~/cloudshell_open/golang-samples/cloud-sql/sqlserver/database-sql
  
```
按照以下方式运行 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 编辑器，然后点击打开终端以打开 Cloud Shell 提示符。
在 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"
```
将目录更改为您之前从 GitHub 克隆 Cloud SQL 示例应用的位置。示例应用目录包含示例应用的 pom.xml。例如，如需将目录更改为示例应用的目录，您可以运行如下命令：
```
cd ~/cloudshell_open/java-docs-samples/cloud-sql/sqlserver/servlet
  
```

按照以下方式运行 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 编辑器，然后点击打开终端以打开 Cloud Shell 提示符。
在 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"
```
将目录更改为您之前从 GitHub 克隆 Cloud SQL 示例应用的位置。示例应用目录包含示例应用的 Dockerfile。例如，如需将目录更改为示例应用的目录，您可以运行如下命令：
```
cd ~/cloudshell_open/nodejs-docs-samples/cloud-sql/sqlserver/mssql
  
```
按照以下方式运行 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 编辑器，然后点击打开终端以打开 Cloud Shell 提示符。
在 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"
```
将目录更改为您之前从 GitHub 克隆 Cloud SQL 示例应用的位置。示例应用目录包含示例应用的 Dockerfile。例如，如需将目录更改为示例应用的目录，您可以运行如下命令：
```
cd ~/cloudshell_open/python-docs-samples/cloud-sql/sql-server/sqlalchemy
  
```
按照以下方式运行 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 代理连接到 Cloud SQL 实例。Sidecar 模式的实现方式是使用一个额外的容器来部署工作负载，该容器与示例应用的容器共享同一个 Kubernetes pod。

通过运行 gcloud sql instances describe 命令获取 Cloud SQL 实例连接名称：

gcloud sql instances describe quickstart-instance --format='value(connectionName)'

在 Cloud Shell Editor 中更新 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: "1433"
        - 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"

          # 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=1433"
          - "<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 地址在服务详细信息中变得可用之后，复制该地址，这可能需要几分钟的时间。
查看已部署的示例应用。打开一个浏览器窗口并访问 Service 的外部 IP 地址。

Java

已部署的示例应用使用 Cloud SQL Java 连接器连接到您的 Cloud SQL 实例。

通过运行 gcloud sql instances describe 命令获取 Cloud SQL 实例连接名称：

gcloud sql instances describe quickstart-instance --format='value(connectionName)'

在 Cloud Shell Editor 中更新 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: "1433"  
        - 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 地址在服务详细信息中变得可用之后，复制该地址，这可能需要几分钟的时间。
查看已部署的示例应用。打开一个浏览器窗口并访问 Service 的外部 IP 地址。

Node.js

通过运行 gcloud sql instances describe 命令获取 Cloud SQL 实例连接名称：

gcloud sql instances describe quickstart-instance --format='value(connectionName)'

在 Cloud Shell Editor 中更新 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: "1433"  
        - 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"

          # 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=1433"
          - "<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 地址在服务详细信息中变得可用之后，复制该地址，这可能需要几分钟的时间。
查看已部署的示例应用。打开一个浏览器窗口并访问 Service 的外部 IP 地址。

Python

通过运行 gcloud sql instances describe 命令获取 Cloud SQL 实例连接名称：

gcloud sql instances describe quickstart-instance --format='value(connectionName)'

在 Cloud Shell Editor 中更新 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)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "1433"
        # If connecting from 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
          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"

          # 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=1433"
          - "<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 地址在服务详细信息中变得可用之后，复制该地址，这可能需要几分钟的时间。
查看已部署的示例应用。打开一个浏览器窗口并访问 Service 的外部 IP 地址。

专用 IP

示例应用配置完成后，您现在可以部署示例应用。

Go

通过运行 gcloud sql instances describe 命令获取 Cloud SQL 实例连接名称：

gcloud sql instances describe quickstart-instance --format='value(connectionName)'

在 Cloud Shell Editor 中更新 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 身份验证代理以使用其专用 IP 地址连接到您的 Cloud SQL 实例。通过移除 # 注释符号及其尾随空格来取消注释 "--private-ip" 标志。未注释的标志应如下所示：
```
- "--private-ip"
```

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

          # 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=1433"
          - "<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 地址在服务详细信息中变得可用之后，复制该地址，这可能需要几分钟的时间。
查看已部署的示例应用。打开一个浏览器窗口并访问 Service 的外部 IP 地址。

Java

已部署的示例应用使用 Cloud SQL Java 连接器连接到您的 Cloud SQL 实例。

通过运行 gcloud sql instances describe 命令获取 Cloud SQL 实例连接名称：

gcloud sql instances describe quickstart-instance --format='value(connectionName)'

在 Cloud Shell Editor 中更新 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: "1433"  
        - 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 地址在服务详细信息中变得可用之后，复制该地址，这可能需要几分钟的时间。
查看已部署的示例应用。打开一个浏览器窗口并访问 Service 的外部 IP 地址。

Node.js

通过运行 gcloud sql instances describe 命令获取 Cloud SQL 实例连接名称：

gcloud sql instances describe quickstart-instance --format='value(connectionName)'

在 Cloud Shell Editor 中更新 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 身份验证代理以使用其专用 IP 地址连接到您的 Cloud SQL 实例。通过移除 # 注释符号及其尾随空格来取消注释 "--private-ip" 标志。未注释的标志应如下所示：
```
- "--private-ip"
```

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

          # 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=1433"
          - "<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 地址在服务详细信息中变得可用之后，复制该地址，这可能需要几分钟的时间。
查看已部署的示例应用。打开一个浏览器窗口并访问 Service 的外部 IP 地址。

Python

通过运行 gcloud sql instances describe 命令获取 Cloud SQL 实例连接名称：

gcloud sql instances describe quickstart-instance --format='value(connectionName)'

在 Cloud Shell Editor 中更新 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 身份验证代理以使用其专用 IP 地址连接到您的 Cloud SQL 实例。通过移除 # 注释符号及其尾随空格来取消注释 "--private-ip" 标志。未注释的标志应如下所示：
```
- "--private-ip"
```
移除 # 注释符号和尾随空格，以取消注释 - name: CLOUD_SQL_AUTH_PROXY_IP_ADDRESS_TYPE 环境变量及其值。取消注释的环境变量和值应如下所示：
```
 - 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>
      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)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "1433"
        # If connecting from 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
          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"

          # 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=1433"
          - "<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 地址在服务详细信息中变得可用之后，复制该地址，这可能需要几分钟的时间。
查看已部署的示例应用。打开一个浏览器窗口并访问 Service 的外部 IP 地址。

清理

为避免因本页中使用的资源导致您的 Google Cloud 账号产生费用，请按照以下步骤操作。

在 Google Cloud 控制台中，前往 Cloud SQL 实例页面。

转到“Cloud SQL 实例”
选择 quickstart-instance 实例以打开实例详情页面。
在页面顶部的图标栏中，点击删除。
在删除实例对话框中，输入 quickstart-instance，然后点击删除以删除该实例。
在 Google Cloud 控制台中，前往 Google Kubernetes Engine 页面。

转到 Google Kubernetes Engine
点击 gke-cloud-sql-quickstart 服务名称旁边的复选框。
点击 Google Kubernetes Engine 页面顶部的删除按钮。

可选的清理步骤

如果您没有使用为本快速入门创建的 Google Cloud 服务账号，则可以将其移除。

在 Google Cloud 控制台中，打开服务账号页面。

进入 IAM
选中名为 gke-quickstart-service-account 的 IAM 账号对应的复选框。
点击移除，然后确认移除。

如果您没有使用在本快速入门中启用的 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 实例创建 SQL Server 用户和数据库。

另请参阅 Cloud SQL 价格信息。

详细了解以下内容：

Cloud SQL 中的所有连接选项。
使用公共 IP 地址配置 Cloud SQL 实例。
使用专用 IP 地址配置 Cloud SQL 实例。

此外，您还可以了解如何从其他 Google Cloud 应用连接到 Cloud SQL 实例：