Se connecter à Cloud SQL pour MySQL 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 MySQL à 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

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud.

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 MySQL.
Dans le champ ID d'instance, saisissez quickstart-instance.
Entrez un mot de passe pour l'utilisateur racine. 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=MYSQL_8_0 \
--cpu=1 \
--memory=4GB \
--region=us-central1 \
--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 Create instance (Créer une instance).
Cliquez sur MySQL.
Dans le champ ID d'instance, saisissez quickstart-instance.
Entrez un mot de passe pour l'utilisateur racine. 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 Activer SSL, cliquez sur Activer 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=MYSQL_8_0 \
--cpu=1 \
--memory=4GB \
--region=us-central1 \
--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 Créer une base de données, saisissez quickstart-db. Conservez les valeurs du jeu de caractères et du classement.
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 compte utilisateur

Console

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

Accéder à la page Instances Cloud SQL
Pour ouvrir la page Présentation d'une instance, cliquez sur son nom.
Dans le menu de navigation SQL, sélectionnez Utilisateurs.
Cliquez sur Ajouter un compte utilisateur.

Sur la page Ajouter un compte utilisateur à l'instance instance_name, ajoutez les informations suivantes :
- Nom d'utilisateur : défini sur quickstart-user
- Mot de passe : spécifiez un mot de passe pour votre utilisateur de base de données. Notez-le pour l'utiliser dans une étape ultérieure de ce guide de démarrage rapide.
- Dans la section Nom d'hôte, la valeur par défaut est Autoriser tous les hôtes, ce qui signifie que l'utilisateur peut se connecter depuis n'importe quelle adresse IP.
  Vous pouvez également sélectionner Restreindre l'hôte par adresse IP ou plage d'adresses, puis saisir une adresse IP ou une plage d'adresses dans la section Hôte. L'utilisateur peut alors se connecter uniquement à partir de l'adresse IP ou des adresses spécifiées.

Cliquez sur Ajouter.

gcloud

Avant d'exécuter la commande comme suit, remplacez DB_PASS par un mot de passe pour votre utilisateur de base de données. Notez-le pour l'utiliser dans une étape ultérieure de ce guide de démarrage rapide.

Exécutez la commande gcloud sql users create pour créer l'utilisateur.

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

Les limites de longueur des noms d'utilisateur sont identiques pour Cloud SQL et pour MySQL sur site : 32 caractères pour MySQL 8.0, 16 caractères pour les versions antérieures.

Créer un cluster GKE

Console

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

Accéder à Google Kubernetes Engine
Cliquez sur Create (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 Create (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"
```

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 Workload Identity.

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 du quickstart-user que vous avez créé à l'étape précédente Créer un utilisateur de ce guide de démarrage rapide.

kubectl create secret generic gke-cloud-sql-secrets \
  --from-literal=database=quickstart-db \
  --from-literal=username=quickstart-user \
  --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>
      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

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(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

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>
      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

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.

cloud-sql/mysql/mysql/deployment.yaml

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>
      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

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 qui suit. 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>
      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

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(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

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 qui suit. 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>
      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

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.

cloud-sql/mysql/mysql/deployment.yaml

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 qui suit. 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>
      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

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 Google Cloud Console, 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 MySQL 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 :