Se connecter à Cloud SQL pour SQL Server depuis Google Kubernetes Engine

MySQL | PostgreSQL | SQL Server

Cette page explique comment déployer un exemple d'application sur Google Kubernetes Engine (GKE) connecté à une instance SQL Server à l'aide de Google Cloud Console et d'une application cliente. Les ressources créées dans ce guide de démarrage rapide coûtent généralement moins d'un dollar (USD), en supposant que vous effectuiez les étapes, y compris le nettoyage, en temps opportun.

Avant de commencer

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.

Activer les API Google Cloud nécessaires à l'exécution d'un exemple d'application Cloud SQL sur GKE
Console

Cliquez sur Activer les API pour activer les API requises dans ce guide de démarrage rapide.

Activer les API

Cela aura pour effet d'activer les API suivantes :
- API Compute Engine
- API Cloud SQL Admin
- API Google Kubernetes Engine
- API Artifact Registry
- API Cloud Build
gcloud

Cliquez sur le bouton suivant pour ouvrir Cloud Shell, qui fournit un accès en ligne de commande à vos ressources Google Cloud directement depuis le navigateur. Cloud Shell peut être utilisé pour exécuter les commandes gcloud présentées dans ce guide de démarrage rapide.

Ouvrir Cloud Shell

Exécutez la commande gcloud services enable comme suit à l'aide de Cloud Shell pour activer les API requises pour ce guide de démarrage rapide :
gcloud services enable compute.googleapis.com sqladmin.googleapis.com \ container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com
Cette commande active les API suivantes :
- API Compute Engine
- API Cloud SQL Admin
- API GKE
- API Artifact Registry
- API Cloud Build

Configurer Cloud SQL

Créer une instance Cloud SQL

Adresse IP publique

Console

Créer une instance avec une adresse IP publique

Dans Google Cloud Console, accédez à la page Instances Cloud SQL.

Accéder à la page Instances Cloud SQL
Cliquez sur Create Instance (Créer une instance).
Cliquez sur SQL Server.
Dans le champ ID d'instance, saisissez quickstart-instance.
Saisissez un mot de passe pour l'utilisateur sqlserver. Enregistrez ce mot de passe pour une utilisation ultérieure.
Sous Choisir la disponibilité régionale et zonale, cliquez sur l'option Zone unique.
Cliquez et développez la section Afficher les configurations.
Dans le menu déroulant Type de machine, sélectionnez Configuration légère.
Cliquez sur Créer une instance et attendez que l'instance s'initialise et démarre.

gcloud

Créer une instance avec une adresse IP publique

Avant d'exécuter la commande gcloud sql instances create comme suit, remplacez DB_ROOT_PASSWORD par le mot de passe de votre utilisateur de base de données.

Vous pouvez également modifier les valeurs des paramètres suivants :

--database_version : type et version du moteur de base de données. Si aucune valeur n'est spécifiée, la valeur par défaut de l'API est utilisée. Consultez la documentation de gcloud database versions pour afficher les versions actuellement disponibles.
--cpu : nombre de cœurs souhaités dans la machine.
--memory : nombre entier indiquant la quantité de mémoire souhaitée sur la machine. Une unité de taille doit être fournie (par exemple, 3072 Mo ou 9 Go). Si aucune unité n'est spécifiée, la valeur par défaut est Go.
--region : emplacement régional de l'instance (par exemple, asia-east1, us-east1). Si aucune opération n'est spécifiée, la valeur par défaut us-central est utilisée. Consultez la liste complète des régions.

Exécutez la commande gcloud sql instances create pour créer une instance 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

Adresse IP privée

Console

Créer une instance avec une adresse IP privée et SSL activé

Dans Google Cloud Console, accédez à la page Instances Cloud SQL.

Accéder à la page Instances Cloud SQL
Cliquez sur Créer une instance.
Cliquez sur SQL Server.
Dans le champ ID d'instance, saisissez quickstart-instance.
Saisissez un mot de passe pour l'utilisateur sqlserver. Enregistrez ce mot de passe pour une utilisation ultérieure.
Sous Choisir la disponibilité régionale et zonale, cliquez sur l'option Zone unique.
Cliquez pour développer la section Afficher les options de configuration.
Dans le champ Type de machine, sélectionnez Léger.
Dans Connexions, sélectionnez Adresse IP privée.
Sélectionnez Par défaut dans le menu déroulant Réseau.
Si une boîte de dialogue indiquant Connexion d'accès aux services privés requise s'affiche, cliquez sur le bouton Configurer la connexion.

Dans la boîte de dialogue Activer l'API Service Networking, cliquez sur le bouton Activer l'API.
Dans la boîte de dialogue Allouer une plage d'adresses IP, sélectionnez Utiliser une plage d'adresses IP automatiquement allouée et cliquez sur Continuer.
Dans la boîte de dialogue Créer une connexion, cliquez sur Créer une connexion.

Décochez la case Adresse IP publique pour créer une instance qui dispose uniquement d'une adresse IP privée.
Cliquez sur Créer une instance, puis attendez que l'instance s'initialise et démarre.
Cliquez sur Connexions.
Dans la section Sécurité, sélectionnez Autoriser uniquement les connexions SSL pour activer les connexions SSL.
Dans la boîte de dialogue Autoriser uniquement les connexions SSL, cliquez sur Enregistrer et redémarrer, puis attendez que l'instance redémarre.

gcloud

Créer une instance avec une adresse IP privée et SSL activé

Pour créer une instance avec une adresse IP privée, il vous suffit de configurer l'accès aux services privés afin d'activer les connexions à partir d'autres services Google Cloud, tels que GKE.

Exécutez la commande gcloud compute addresses create pour allouer une plage d'adresses IP à une connexion d'accès aux services privés :

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

Exécutez la commande gcloud services vpc-peerings connect pour créer la connexion d'accès aux services privés :

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

Avant d'exécuter la commande gcloud sql instances create pour créer une instance comme suit, remplacez DB_ROOT_PASSWORD par le mot de passe de votre utilisateur de base de données.

Vous pouvez également modifier les valeurs des paramètres suivants :

--database_version : type et version du moteur de base de données. Si aucune valeur n'est spécifiée, la valeur par défaut de l'API est utilisée. Consultez la documentation de gcloud database versions pour répertorier les versions actuellement disponibles.
--cpu : nombre de cœurs dans la machine.
--memory : nombre entier indiquant la quantité de mémoire souhaitée sur la machine. Une unité de taille peut être fournie (par exemple, 3072 Mo ou 9 Go). Si aucune unité n'est spécifiée, la valeur par défaut est Go.
--region : emplacement régional de l'instance (par exemple, asia-east1, us-east1). Si aucune opération n'est spécifiée, la valeur par défaut (us-central1) est utilisée. Consultez la liste complète des régions.

Exécutez la commande gcloud sql instances create pour créer une instance Cloud SQL avec une adresse IP privée.

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

Exécutez la commande gcloud sql instances patch afin d'autoriser uniquement les connexions SSL pour l'instance.

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

Créer une base de données

Console

Dans Google Cloud Console, accédez à la page Instances Cloud SQL.

Accéder à la page Instances Cloud SQL
Sélectionnez quickstart-instance.
Dans le menu de navigation SQL, sélectionnez Bases de données.
Cliquez sur Créer une base de données.

Dans le champ Nom de la base de données de la boîte de dialogue Nouvelle base de données, saisissez quickstart-db.
Cliquez sur Créer.

gcloud

Exécutez la commande gcloud sql databases create pour créer une base de données.

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

Créer un cluster GKE

Console

Dans Google Cloud Console, accédez à la page Google Kubernetes Engine.

Accéder à Google Kubernetes Engine
Cliquez sur Créer.
Cliquez sur Configure (Configurer) pour GKE Autopilot.
Dans le champ Name (Nom), spécifiez le nom du cluster comme gke-cloud-sql-quickstart.
Cliquez sur Créer.

gcloud

Exécutez la commande gcloud container clusters create-auto pour créer le cluster.

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

Cloner une application exemple Cloud SQL dans l'éditeur Cloud Shell

Avec une instance Cloud SQL, une base de données et un cluster GKE, vous pouvez maintenant cloner et configurer un exemple d'application pour se connecter à votre instance Cloud SQL. Les étapes restantes de ce guide de démarrage rapide nécessitent l'utilisation des outils de ligne de commande gcloud et kubectl. Ces deux outils sont préinstallés dans Cloud Shell.

Go

Dans l'éditeur Cloud Shell, ouvrez le code source de l'exemple d'application.
Ouvrir l'éditeur Cloud Shell
Dans la boîte de dialogue Open in Cloud Shell, cliquez sur Confirmer pour télécharger le code de l'exemple d'application et ouvrir le répertoire de l'exemple d'application dans l'éditeur Cloud Shell.

Java

Dans l'éditeur Cloud Shell, ouvrez le code source de l'exemple d'application.
Ouvrir l'éditeur Cloud Shell
Dans la boîte de dialogue Open in Cloud Shell, cliquez sur Confirmer pour télécharger le code de l'exemple d'application et ouvrir le répertoire de l'exemple d'application dans l'éditeur Cloud Shell.

Node.js

Dans l'éditeur Cloud Shell, ouvrez le code source de l'exemple d'application.
Ouvrir l'éditeur Cloud Shell
Dans la boîte de dialogue Open in Cloud Shell, cliquez sur Confirmer pour télécharger le code de l'exemple d'application et ouvrir le répertoire de l'exemple d'application dans l'éditeur Cloud Shell.

Python

Dans l'éditeur Cloud Shell, ouvrez le code source de l'exemple d'application.
Ouvrir l'éditeur Cloud Shell
Dans la boîte de dialogue Open in Cloud Shell, cliquez sur Confirmer pour télécharger le code de l'exemple d'application et ouvrir le répertoire de l'exemple d'application dans l'éditeur Cloud Shell.

Activer le cluster GKE

Activez le cluster GKE que vous venez de créer comme cluster par défaut à utiliser pour les commandes restantes dans ce guide de démarrage rapide.

Exécutez la commande gcloud container clusters get-credentials comme suit pour activer le cluster GKE :

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

Configurer un compte de service

Créez et configurez un compte de service Google Cloud pour GKE afin qu'il dispose du rôle Client Cloud SQL avec les autorisations nécessaires pour se connecter à Cloud SQL.

Exécutez la commande gcloud iam service-accounts create comme suit pour créer un compte de service :

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

Exécutez la commande gcloud projects add-iam-policy-binding comme suit pour ajouter le rôle Client Cloud SQL au compte de service Google Cloud que vous venez de créer. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
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"
```
L'exemple d'application utilise la journalisation. Exécutez donc la commande gcloud projects add-iam-policy-binding comme décrit ci-dessous pour ajouter le rôle Rédacteur de journal au compte de service Google Cloud que vous venez de créer. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
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"
```
Le compte de service doit être en mesure d'extraire des images du dépôt d'artefacts. Par conséquent, exécutez la commande
gcloud projects add-iam-policy-binding comme suit pour ajouter le rôle Lecteur Artifact Registry au compte de service. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
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"
```

Créez un compte de service Kubernetes configuré pour accéder à Cloud SQL en le liant au compte de service Google Cloud à l'aide de la Workload Identity Federation for GKE.

Créez un compte de service Kubernetes.
1. Mettez à jour le fichier service-account.yaml dans l'éditeur Cloud Shell. Remplacez <YOUR-KSA-NAME> par ksa-cloud-sql.
2. Exécutez la commande kubectl apply comme suit dans Cloud Shell :
```
kubectl apply -f service-account.yaml
```
Exécutez la commande gcloud iam service-accounts add-iam-policy-binding comme suit pour activer la liaison IAM du compte de service Google Cloud et du compte de service Kubernetes. Effectuez les remplacements suivants :
- YOUR_PROJECT_ID par l'ID du projet.
- YOUR_K8S_NAMESPACE par default, qui est l'espace de noms par défaut pour les clusters créés dans GKE.
- YOUR_KSA_NAME correspond à 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
```
Exécutez la commande kubectl annotate comme suit pour annoter le compte de service Kubernetes avec une liaison IAM. Effectuez les remplacements suivants :
- YOUR_KSA_NAME correspond à ksa-cloud-sql.
- YOUR_PROJECT_ID par l'ID du projet.
```
kubectl annotate serviceaccount \
  YOUR_KSA_NAME  \
  iam.gke.io/gcp-service-account=gke-quickstart-service-account@YOUR_PROJECT_ID.iam.gserviceaccount.com
```

Configurer les secrets

Exécutez la commande kubectl create secret generic suivante afin de créer des secrets Kubernetes pour la base de données, l'utilisateur et le mot de passe de l'utilisateur que l'exemple d'application doit utiliser. Les valeurs de chaque secret sont basées sur les valeurs spécifiées dans les étapes précédentes de ce guide de démarrage rapide. Remplacez DB_PASS par le mot de passe de l'utilisateur racine sqlserver que vous avez créé à l'étape Créer une instance Cloud SQL.

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

Créer l'application exemple

Go

Exécutez la commande gcloud artifacts repositories create suivante dans Cloud Shell pour créer un dépôt dans Artifact Registry nommé gke-cloud-sql-repo dans la même région que votre cluster. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
Exécutez la commande gcloud builds submit comme suit dans Cloud Shell pour créer un conteneur Docker et le publier dans Artifact Registry. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

Java

Exécutez la commande gcloud artifacts repositories create suivante dans Cloud Shell pour créer un dépôt dans Artifact Registry nommé gke-cloud-sql-repo dans la même région que votre cluster. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```

Exécutez la commande mvn comme suit dans Cloud Shell pour créer un conteneur Docker et le publier dans Artifact Registry. Remplacez YOUR_PROJECT_ID par l'ID du projet.

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

Exécutez la commande gcloud artifacts repositories create suivante dans Cloud Shell pour créer un dépôt dans Artifact Registry nommé gke-cloud-sql-repo dans la même région que votre cluster. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
Exécutez la commande gcloud builds submit comme suit dans Cloud Shell pour créer un conteneur Docker et le publier dans Artifact Registry. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

Python

Exécutez la commande gcloud artifacts repositories create suivante dans Cloud Shell pour créer un dépôt dans Artifact Registry nommé gke-cloud-sql-repo dans la même région que votre cluster. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
gcloud artifacts repositories create gke-cloud-sql-repo \
  --project=YOUR_PROJECT_ID \
  --repository-format=docker \
  --location=us-central1 \
  --description="GKE Quickstart sample app"
```
Exécutez la commande gcloud builds submit comme suit dans Cloud Shell pour créer un conteneur Docker et le publier dans Artifact Registry. Remplacez YOUR_PROJECT_ID par l'ID du projet.
```
gcloud builds submit \
  --tag us-central1-docker.pkg.dev/YOUR_PROJECT_ID/gke-cloud-sql-repo/gke-sql .
```

Déployer l'exemple d'application

Adresse IP publique

Une fois la configuration de l'exemple d'application en place, vous pouvez déployer l'exemple d'application.

Go

L'exemple d'application déployé se connecte à votre instance Cloud SQL à l'aide du proxy Cloud SQL exécuté dans un modèle side-car Kubernetes. Le modèle side-car est réalisé en déployant une charge de travail avec un conteneur supplémentaire qui partage le même pod Kubernetes que celui de l'exemple d'application.

Obtenez le nom de connexion de l'instance Cloud SQL en exécutant la commande gcloud sql instances describe :
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Mettez à jour le fichier deployment.yaml dans l'éditeur Cloud Shell. Effectuez les remplacements suivants :

<YOUR_KSA_NAME> correspond à ksa-cloud-sql.
<LOCATION> correspond à us-central1.
<YOUR_PROJECT_ID> par l'ID du projet.
<YOUR-DB-SECRET> correspond à gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> par le nom de connexion de l'instance Cloud SQL récupéré à l'aide de la commande gcloud à l'étape précédente. Le format est project_id:region:instance_name. Le nom de connexion de l'instance est également visible sur la page Présentation de l'instance 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<
      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

Exécutez la commande kubectl apply comme suit dans Cloud Shell pour déployer l'exemple d'application :
```
kubectl apply -f deployment.yaml
```
Exécutez la commande kubectl apply comme suit pour ajouter un équilibreur de charge devant le déploiement, afin de pouvoir y accéder via Internet :
```
kubectl apply -f service.yaml
```
Exécutez la commande kubectl get comme suit pour obtenir les détails du service :
```
kubectl get services
```
Copiez l'adresse IP externe une fois qu'elle devient disponible dans les détails du service. Cette opération peut prendre quelques minutes.
Afficher l'exemple d'application déployé. Ouvrez une fenêtre de navigateur et accédez à l'adresse IP externe du service.

Java

L'exemple d'application déployé se connecte à votre instance Cloud SQL à l'aide du connecteur Java Cloud SQL.

Obtenez le nom de connexion de l'instance Cloud SQL en exécutant la commande gcloud sql instances describe :
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Mettez à jour le fichier deployment.yaml dans l'éditeur Cloud Shell. Effectuez les remplacements suivants :

<YOUR_KSA_NAME> correspond à ksa-cloud-sql.
<LOCATION> correspond à us-central1.
<YOUR_PROJECT_ID> par l'ID du projet.
<YOUR-DB-SECRET> correspond à gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> par le nom de connexion de l'instance Cloud SQL récupéré à l'aide de la commande gcloud à l'étape précédente. Le format est project_id:region:instance_name. Le nom de connexion de l'instance est également visible sur la page Présentation de l'instance 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(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<>

Exécutez la commande kubectl apply comme suit dans Cloud Shell pour déployer l'exemple d'application :
```
kubectl apply -f deployment.yaml
```
Exécutez la commande kubectl apply comme suit pour ajouter un équilibreur de charge devant le déploiement, afin de pouvoir y accéder via Internet :
```
kubectl apply -f service.yaml
```
Exécutez la commande kubectl get comme suit pour obtenir les détails du service :
```
kubectl get services
```
Copiez l'adresse IP externe une fois qu'elle devient disponible dans les détails du service. Cette opération peut prendre quelques minutes.
Afficher l'exemple d'application déployé. Ouvrez une fenêtre de navigateur et accédez à l'adresse IP externe du service.

Node.js

Obtenez le nom de connexion de l'instance Cloud SQL en exécutant la commande gcloud sql instances describe :
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Mettez à jour le fichier deployment.yaml dans l'éditeur Cloud Shell. Effectuez les remplacements suivants :

<YOUR_KSA_NAME> correspond à ksa-cloud-sql.
<LOCATION> correspond à us-central1.
<YOUR_PROJECT_ID> par l'ID du projet.
<YOUR-DB-SECRET> correspond à gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> par le nom de connexion de l'instance Cloud SQL récupéré à l'aide de la commande gcloud à l'étape précédente. Le format est project_id:region:instance_name. Le nom de connexion de l'instance est également visible sur la page Présentation de l'instance 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<
      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

Exécutez la commande kubectl apply comme suit dans Cloud Shell pour déployer l'exemple d'application :
```
kubectl apply -f deployment.yaml
```
Exécutez la commande kubectl apply comme suit pour ajouter un équilibreur de charge devant le déploiement, afin de pouvoir y accéder via Internet :
```
kubectl apply -f service.yaml
```
Exécutez la commande kubectl get comme suit pour obtenir les détails du service :
```
kubectl get services
```
Copiez l'adresse IP externe une fois qu'elle devient disponible dans les détails du service. Cette opération peut prendre quelques minutes.
Afficher l'exemple d'application déployé. Ouvrez une fenêtre de navigateur et accédez à l'adresse IP externe du service.

Python

Obtenez le nom de connexion de l'instance Cloud SQL en exécutant la commande gcloud sql instances describe :
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Mettez à jour le fichier deployment.yaml dans l'éditeur Cloud Shell. Effectuez les remplacements suivants :

<YOUR_KSA_NAME> correspond à ksa-cloud-sql.
<LOCATION> correspond à us-central1.
<YOUR_PROJECT_ID> par l'ID du projet.
<YOUR-DB-SECRET> correspond à gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> par le nom de connexion de l'instance Cloud SQL récupéré à l'aide de la commande gcloud à l'étape précédente. Le format est project_id:region:instance_name. Le nom de connexion de l'instance est également visible sur la page Présentation de l'instance 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<
      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"

Exécutez la commande kubectl apply comme suit dans Cloud Shell pour déployer l'exemple d'application :
```
kubectl apply -f deployment.yaml
```
Exécutez la commande kubectl apply comme suit pour ajouter un équilibreur de charge devant le déploiement, afin de pouvoir y accéder via Internet :
```
kubectl apply -f service.yaml
```
Exécutez la commande kubectl get comme suit pour obtenir les détails du service :
```
kubectl get services
```
Copiez l'adresse IP externe une fois qu'elle devient disponible dans les détails du service. Cette opération peut prendre quelques minutes.
Afficher l'exemple d'application déployé. Ouvrez une fenêtre de navigateur et accédez à l'adresse IP externe du service.

Adresse IP privée

Une fois la configuration de l'exemple d'application en place, vous pouvez déployer l'exemple d'application.

Go

Obtenez le nom de connexion de l'instance Cloud SQL en exécutant la commande gcloud sql instances describe :
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Mettez à jour le fichier deployment.yaml dans l'éditeur Cloud Shell. Apportez les modifications et remplacements suivants :

Remplacez <YOUR_KSA_NAME> par ksa-cloud-sql.
Remplacez <LOCATION> par us-central1.
Remplacez <YOUR_PROJECT_ID> par l'ID du projet.
Remplacez <YOUR-DB-SECRET> par gke-cloud-sql-secrets.
Remplacez <INSTANCE_CONNECTION_NAME> par le nom de connexion de l'instance Cloud SQL récupéré à l'aide de la commande gcloud à l'étape précédente. Le format est project_id:region:instance_name. Le nom de connexion de l'instance est également visible sur la page Présentation de l'instance Cloud SQL.
Autorisez le proxy d'authentification Cloud SQL à se connecter à l'instance Cloud SQL à l'aide de son adresse IP privée. Annulez la mise en commentaire de l'option "-ip_address_types=PRIVATE" en supprimant le symbole de commentaire # et l'espace blanc final. L'indicateur sans commentaire doit ressembler à ceci :
```
- "-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

Exécutez la commande kubectl apply comme suit dans Cloud Shell pour déployer l'exemple d'application :
```
kubectl apply -f deployment.yaml
```
Exécutez la commande kubectl apply comme suit pour ajouter un équilibreur de charge devant le déploiement, afin de pouvoir y accéder via Internet :
```
kubectl apply -f service.yaml
```
Exécutez la commande kubectl get comme suit pour obtenir les détails du service :
```
kubectl get services
```
Copiez l'adresse IP externe une fois qu'elle devient disponible dans les détails du service. Cette opération peut prendre quelques minutes.
Afficher l'exemple d'application déployé. Ouvrez une fenêtre de navigateur et accédez à l'adresse IP externe du service.

Java

L'exemple d'application déployé se connecte à votre instance Cloud SQL à l'aide du connecteur Java Cloud SQL.

Obtenez le nom de connexion de l'instance Cloud SQL en exécutant la commande gcloud sql instances describe :
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Mettez à jour le fichier deployment.yaml dans l'éditeur Cloud Shell. Effectuez les remplacements suivants :

<YOUR_KSA_NAME> correspond à ksa-cloud-sql.
<LOCATION> correspond à us-central1.
<YOUR_PROJECT_ID> par l'ID du projet.
<YOUR-DB-SECRET> correspond à gke-cloud-sql-secrets.
<INSTANCE_CONNECTION_NAME> par le nom de connexion de l'instance Cloud SQL récupéré à l'aide de la commande gcloud à l'étape précédente. Le format est project_id:region:instance_name. Le nom de connexion de l'instance est également visible sur la page Présentation de l'instance 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(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<>

Exécutez la commande kubectl apply comme suit dans Cloud Shell pour déployer l'exemple d'application :
```
kubectl apply -f deployment.yaml
```
Exécutez la commande kubectl apply comme suit pour ajouter un équilibreur de charge devant le déploiement, afin de pouvoir y accéder via Internet :
```
kubectl apply -f service.yaml
```
Exécutez la commande kubectl get comme suit pour obtenir les détails du service :
```
kubectl get services
```
Copiez l'adresse IP externe une fois qu'elle devient disponible dans les détails du service. Cette opération peut prendre quelques minutes.
Afficher l'exemple d'application déployé. Ouvrez une fenêtre de navigateur et accédez à l'adresse IP externe du service.

Node.js

Obtenez le nom de connexion de l'instance Cloud SQL en exécutant la commande gcloud sql instances describe :
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Mettez à jour le fichier deployment.yaml dans l'éditeur Cloud Shell. Apportez les modifications et remplacements suivants :

Remplacez <YOUR_KSA_NAME> par ksa-cloud-sql.
Remplacez <LOCATION> par us-central1.
Remplacez <YOUR_PROJECT_ID> par l'ID du projet.
Remplacez <YOUR-DB-SECRET> par gke-cloud-sql-secrets.
Remplacez <INSTANCE_CONNECTION_NAME> par le nom de connexion de l'instance Cloud SQL récupéré à l'aide de la commande gcloud à l'étape précédente. Le format est project_id:region:instance_name. Le nom de connexion de l'instance est également visible sur la page Présentation de l'instance Cloud SQL.
Autorisez le proxy d'authentification Cloud SQL à se connecter à l'instance Cloud SQL à l'aide de son adresse IP privée. Annulez la mise en commentaire de l'option "-ip_address_types=PRIVATE" en supprimant le symbole de commentaire # et l'espace blanc final. L'indicateur sans commentaire doit ressembler à ceci :
```
- "-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

Exécutez la commande kubectl apply comme suit dans Cloud Shell pour déployer l'exemple d'application :
```
kubectl apply -f deployment.yaml
```
Exécutez la commande kubectl apply comme suit pour ajouter un équilibreur de charge devant le déploiement, afin de pouvoir y accéder via Internet :
```
kubectl apply -f service.yaml
```
Exécutez la commande kubectl get comme suit pour obtenir les détails du service :
```
kubectl get services
```
Copiez l'adresse IP externe une fois qu'elle devient disponible dans les détails du service. Cette opération peut prendre quelques minutes.
Afficher l'exemple d'application déployé. Ouvrez une fenêtre de navigateur et accédez à l'adresse IP externe du service.

Python

Obtenez le nom de connexion de l'instance Cloud SQL en exécutant la commande gcloud sql instances describe :
```
gcloud sql instances describe quickstart-instance --format='value(connectionName)'
```

Mettez à jour le fichier deployment.yaml dans l'éditeur Cloud Shell. Apportez les modifications et remplacements suivants :

Remplacez <YOUR_KSA_NAME> par ksa-cloud-sql.
Remplacez <LOCATION> par us-central1.
Remplacez <YOUR_PROJECT_ID> par l'ID du projet.
Remplacez <YOUR-DB-SECRET> par gke-cloud-sql-secrets.
Remplacez <INSTANCE_CONNECTION_NAME> par le nom de connexion de l'instance Cloud SQL récupéré à l'aide de la commande gcloud à l'étape précédente. Le format est project_id:region:instance_name. Le nom de connexion de l'instance est également visible sur la page Présentation de l'instance Cloud SQL.
Autorisez le proxy d'authentification Cloud SQL à se connecter à l'instance Cloud SQL à l'aide de son adresse IP privée. Annulez la mise en commentaire de l'option "-ip_address_types=PRIVATE" en supprimant le symbole de commentaire # et l'espace blanc final. L'indicateur sans commentaire doit ressembler à ceci :
```
- "-ip_address_types=PRIVATE"
```
Annulez la mise en commentaire de la variable d'environnement - name: CLOUD_SQL_AUTH_PROXY_IP_ADDRESS_TYPE et sa valeur en supprimant les symboles de commentaire # et l'espace blanc final. La variable d'environnement sans commentaire et sa valeur devraient se présenter comme suit :
```
 - 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"

Exécutez la commande kubectl apply comme suit dans Cloud Shell pour déployer l'exemple d'application :
```
kubectl apply -f deployment.yaml
```
Exécutez la commande kubectl apply comme suit pour ajouter un équilibreur de charge devant le déploiement, afin de pouvoir y accéder via Internet :
```
kubectl apply -f service.yaml
```
Exécutez la commande kubectl get comme suit pour obtenir les détails du service :
```
kubectl get services
```
Copiez l'adresse IP externe une fois qu'elle devient disponible dans les détails du service. Cette opération peut prendre quelques minutes.
Afficher l'exemple d'application déployé. Ouvrez une fenêtre de navigateur et accédez à l'adresse IP externe du service.

Effectuer un nettoyage

Pour éviter que les ressources utilisées sur cette page soient facturées sur votre compte Google Cloud, procédez comme suit :

Dans Google Cloud Console, accédez à la page Instances Cloud SQL.

Accéder à la page Instances Cloud SQL
Sélectionnez l'instance quickstart-instance pour ouvrir la page Détails de l'instance.
Dans la barre d'icônes en haut de la page, cliquez sur Supprimer.
Dans la boîte de dialogue Supprimer l'instance, saisissez quickstart-instance puis cliquez sur Supprimer pour supprimer l'instance.
Dans Google Cloud Console, accédez à la page Google Kubernetes Engine.

Accéder à Google Kubernetes Engine
Cochez la case à côté du nom du service gke-cloud-sql-quickstart.
Cliquez sur le bouton Supprimer en haut de la page Google Kubernetes Engine.

Étapes de nettoyage facultatives

Si vous n'utilisez pas le compte de service Google Cloud que vous avez créé pour ce démarrage rapide, vous pouvez le supprimer.

Dans la console Google Cloud, accédez à la page IAM.

Accéder à IAM
Cochez la case correspondant au compte IAM nommé gke-quickstart-service-account.
Cliquez sur Supprimer, puis confirmez la suppression.

Si vous n'utilisez pas les API activées dans le cadre de ce démarrage rapide, vous pouvez les désactiver.

API activées dans ce guide de démarrage rapide :
- API Compute Engine
- API Cloud SQL Admin
- API Google Kubernetes Engine
- API Artifact Registry
- API Cloud Build

Dans Google Cloud Console, accédez à la page API.

Accéder aux API
Sélectionnez l'API que vous souhaitez désactiver, puis cliquez sur le bouton Désactiver l'API.

Étape suivante

En fonction de vos besoins, vous pouvez en apprendre plus sur la création d'instances Cloud SQL.

Vous pouvez également découvrir comment créer des utilisateurs et des bases de données SQL Server pour votre instance Cloud SQL.

Consultez également les informations tarifaires de Cloud SQL.

En savoir plus :

Toutes les options de connectivité dans Cloud SQL.
Configurez votre instance Cloud SQL avec une adresse IP publique.
Configurez votre instance Cloud SQL avec une adresse IP privée.

Vous pouvez également en savoir plus sur la connexion à une instance Cloud SQL à partir d'autres applications Google Cloud :