Se connecter à AlloyDB pour PostgreSQL depuis Google Kubernetes Engine (GKE)

Ce tutoriel explique comment configurer une connexion à partir d'une application exécutée dans un cluster Google Kubernetes Engine Autopilot vers une instance AlloyDB.

AlloyDB est un service de base de données entièrement géré et compatible avec PostgreSQL dans Google Cloud.

Google Kubernetes Engine vous aide à déployer, faire évoluer et gérer automatiquement Kubernetes.

Objectifs

  • Créer une image Docker pour AlloyDB
  • Exécutez une application dans Google Kubernetes Engine.
  • Connectez-vous à une instance AlloyDB à l'aide du proxy d'authentification AlloyDB et d'une adresse IP interne.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, y compris:

  • AlloyDB
  • Google Kubernetes Engine
  • Artifact Registry

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Avant de commencer

Console

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

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

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

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

    Go to project selector

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Activez les APIs Cloud nécessaires pour créer et vous connecter à AlloyDB pour PostgreSQL.

    Activer les API

    1. À l'étape Confirmer le projet, cliquez sur Suivant pour confirmer le nom du projet que vous allez modifier.

    2. À l'étape Activer les API, cliquez sur Activer pour activer les éléments suivants:

      • API AlloyDB
      • API Artifact Registry
      • API Compute Engine
      • API Cloud Resource Manager
      • API Cloud Build
      • API Container Registry
      • API Kubernetes Engine
      • API Service Networking

Pour les besoins de ce tutoriel, utilisez l'exemple d'application Web de collecte de votes nommée gke-alloydb-app.

Lancer Cloud Shell

Cloud Shell est un environnement shell permettant de gérer les ressources hébergées surGoogle Cloud.

Cloud Shell est préinstallé avec les outils de ligne de commande Google Cloud CLI et kubectl. La gcloud CLI fournit l'interface de ligne de commande principale pour Google Cloud. kubectl fournit l'interface de ligne de commande principale permettant d'exécuter des commandes sur les clusters Kubernetes.

Console

Pour lancer Cloud Shell, procédez comme suit :

  1. Accédez à Google Cloud Console.

    Google Cloud Console

  2. Cliquez sur Activer le bouton Cloud Shell Activer Cloud Shell en haut de la console Google Cloud.

  3. Dans la boîte de dialogue Autoriser Cloud Shell, cliquez sur Autoriser.

    Une session Cloud Shell s'ouvre dans un cadre situé en bas de la console. Utilisez cette interface système pour exécuter les commandes gcloud et kubectl.

    1. Avant d'exécuter des commandes, définissez votre projet par défaut dans Google Cloud CLI à l'aide de la commande suivante:

      gcloud config set project PROJECT_ID

      Remplacez PROJECT_ID par votre ID du projet

Créer un cluster AlloyDB et son instance principale

Votre cluster AlloyDB comprend un certain nombre de nœuds dans un cloud privé virtuel (VPC) Google. Lorsque vous créez un cluster, vous configurez également l'accès aux services privés entre l'un de vos VPC et le VPC géré par Google contenant votre nouveau cluster. Nous vous recommandons d'utiliser un accès par adresse IP interne pour éviter que la base de données ne soit exposée à l'Internet public.

Pour vous connecter à un cluster AlloyDB pour PostgreSQL en dehors de son VPC configuré, vous devez configurer l'accès au service privé dans le VPC pour AlloyDB et utiliser le réseau VPC par défaut pour exécuter des requêtes à partir d'une application déployée sur un cluster GKE.

gcloud

  1. Dans Cloud Shell, vérifiez si la plage d'adresses IP (IPv4) inutilisées est déjà attribuée à l'appairage de services:

    gcloud services vpc-peerings list --network=default

    Passez à l'étape suivante si votre résultat ressemble à ceci:

    network: projects/493573376485/global/networks/default
peering: servicenetworking-googleapis-com
reservedPeeringRanges:
- default-ip-range
service: services/servicenetworking.googleapis.com

    Dans cette sortie, la valeur de reservedPeeringRanges est default-ip-range, que vous pouvez utiliser comme IP_RANGE_NAME pour créer une connexion privée à l'étape 3.

  2. (Ignorez cette étape si vous utilisez la valeur par défaut reservedPeeringRanges) Pour allouer des adresses IP inutilisées dans le VPC, utilisez la commande suivante:

    gcloud compute addresses create IP_RANGE_NAME \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=16 \
    --description="VPC private service access" \
    --network=default

    Remplacez IP_RANGE_NAME par votre nom pour les adresses IP internes disponibles dans un sous-réseau AlloyDB, par exemple alloydb-gke-psa-01.

  3. Pour configurer l'accès au service à l'aide de la plage d'adresses IP allouée, exécutez la commande suivante:

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

  4. Pour déployer le cluster AlloyDB, exécutez la commande suivante:

    gcloud alloydb clusters create CLUSTER_ID \
    --database-version=POSTGRES_VERSION \
    --password=CLUSTER_PASSWORD \
    --network=default \
    --region=REGION \
    --project=PROJECT_ID

    Remplacez les éléments suivants :

    • CLUSTER_ID: ID du cluster que vous créez. Il doit commencer par une lettre minuscule et peut contenir des lettres minuscules, des chiffres et des traits d'union, par exemple alloydb-cluster.

    • VERSION: version majeure de PostgreSQL avec laquelle vous souhaitez que les serveurs de base de données du cluster soient compatibles. Choisissez l'une des options suivantes :

      • 14: pour la compatibilité avec PostgreSQL 14

      • 15: pour la compatibilité avec PostgreSQL 15, qui est la version PostgreSQL par défaut prise en charge

      • 16: pour la compatibilité avec PostgreSQL 16 (Preview)

        Pour en savoir plus sur les restrictions qui s'appliquent à l'utilisation de PostgreSQL 16 en version Preview, consultez la page Compatibilité de PostgreSQL 16 en version Preview.

    • CLUSTER_PASSWORD: mot de passe à utiliser pour l'utilisateur postgres par défaut.

    • PROJECT_ID: ID de votre projet Google Cloud dans lequel vous souhaitez placer le cluster.

    • REGION: nom de la région dans laquelle le cluster AlloyDB est créé, par exemple us-central1.

  5. Pour déployer l'instance principale AlloyDB, exécutez la commande suivante:

    gcloud alloydb instances create INSTANCE_ID \
    --instance-type=PRIMARY \
    --cpu-count=NUM_CPU \
    --region=REGION \
    --cluster=CLUSTER_ID \
    --project=PROJECT_ID

    Remplacez les éléments suivants :

    • INSTANCE_ID par le nom de l'instance AlloyDB de votre choix, par exemple alloydb-primary.
    • CLUSTER_ID par le nom du cluster AlloyDB, par exemple alloydb-cluster.
    • NUM_CPU par le nombre d'unités de traitement virtuelles, telles que 2.
    • PROJECT_ID avec l'ID de votre projet Google Cloud .
    • REGION avec le nom de la région dans laquelle le cluster AlloyDB est créé, par exemple us-central1.

    Attendez que l'instance AlloyDB soit créée. Cette opération peut prendre plusieurs minutes.

Se connecter à votre instance principale, et créer une base de données et un utilisateur AlloyDB

Console

  1. Si vous n'êtes pas sur la page Présentation de votre cluster nouvellement créé, accédez à la page Clusters (Clusters) dans la console Google Cloud.

    accéder aux clusters

  2. Pour afficher la page Présentation du cluster, cliquez sur le nom du cluster CLUSTER_ID.

  3. Dans le menu de navigation, cliquez sur AlloyDB Studio.

  4. Sur la page Se connecter à AlloyDB Studio, procédez comme suit:

    1. Dans la liste Base de données, sélectionnez postgres.

    2. Dans la liste Utilisateur, sélectionnez postgres.

    3. Dans le champ Mot de passe, saisissez CLUSTER_PASSWORD que vous avez créé dans Créer un cluster AlloyDB et son instance principale.

    4. Cliquez sur Authentifier. Le volet Explorateur affiche la liste des objets de votre base de données.

  5. Dans l'onglet Éditeur 1, procédez comme suit:

    1. Créez une base de données AlloyDB:

      CREATE DATABASE DATABASE_NAME;

      Remplacez DATABASE_NAME par le nom de votre choix, par exemple tutorial_db.

    2. Cliquez sur Exécuter. Attendez que le message Statement executed successfully s'affiche dans le volet Résultats.

    3. Cliquez sur Effacer.

    4. Créez un utilisateur et un mot de passe de base de données AlloyDB:

      CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

      Remplacez les éléments suivants :

      • USERNAME: nom de l'utilisateur AlloyDB, par exemple tutorial_user.

      • DATABASE_PASSWORD: mot de passe de votre base de données AlloyDB, par exemple tutorial.

    5. Cliquez sur Exécuter. Attendez que le message Statement executed successfully s'affiche dans le volet Résultats.

  6. Dans le volet Explorer d'AlloyDB Studio, cliquez sur Changer d'utilisateur/de base de données.

  7. Sur la page Se connecter à AlloyDB Studio, procédez comme suit:

    1. Dans la liste Base de données, sélectionnez DATABASE_NAME, par exemple tutorial_db.

    2. Dans la liste Utilisateur, sélectionnez postgres.

    3. Dans le champ Mot de passe, saisissez CLUSTER_PASSWORD que vous avez créé dans Créer un cluster AlloyDB et son instance principale.

    4. Cliquez sur Authentifier. Le volet Explorateur affiche la liste des objets de votre base de données.

  8. Dans l'onglet Éditeur 1, procédez comme suit:

    1. Accordez toutes les autorisations à l'utilisateur de la base de données AlloyDB:

      GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";

    2. Cliquez sur Exécuter. Attendez que le message Statement executed successfully s'affiche dans le volet Résultats.

    3. Cliquez sur Effacer.

    4. Accordez des autorisations à l'utilisateur de la base de données AlloyDB sur le schéma public:

      GRANT CREATE ON SCHEMA public TO "USERNAME";

    5. Cliquez sur Exécuter. Attendez que le message Statement executed successfully s'affiche dans le volet Résultats.

  9. Notez le nom de la base de données, le nom d'utilisateur et le mot de passe. Vous utiliserez ces informations dans la section Créer un secret Kubernetes.

Créer un cluster GKE Autopilot

Un cluster contient au moins un système de plan de contrôle de cluster et plusieurs systèmes de calcul appelés nœuds. Les nœuds sont des instances de machines virtuelles (VM) Compute Engine qui exécutent les processus Kubernetes requis pour les intégrer au cluster. Vous déployez les applications sur des clusters, et ces applications s'exécutent sur les nœuds.

Console

  1. Dans la console Google Cloud, accédez à la page des clusters Kubernetes.

    Accéder à la page Clusters Kubernetes

  2. Cliquez sur Créer.

  3. Spécifiez GKE_CLUSTER_ID pour votre cluster Autopilot dans le champ Name (Nom) de la page Cluster Basics (Principes de base du cluster), par exemple ap-cluster.

  4. Dans le champ Région, sélectionnez REGION, par exemple us-central1.

  5. Cliquez sur Créer.

    Attendez que le cluster GKE soit créé. Cette opération peut prendre plusieurs minutes.

gcloud

Créez un cluster Autopilot :

gcloud container clusters create-auto GKE_CLUSTER_ID \
    --location=REGION

Remplacez les éléments suivants :

  • GKE_CLUSTER_ID: nom du cluster Autopilot, par exemple ap-cluster.
  • REGION: nom de la région dans laquelle le cluster GKE est déployé, par exemple us-central1.

Attendez que le cluster GKE soit créé. Cette opération peut prendre plusieurs minutes.

Se connecter à AlloyDB à l'aide du proxy d'authentification AlloyDB

Nous vous recommandons d'utiliser le proxy d'authentification AlloyDB pour vous connecter à AlloyDB. Le proxy d'authentification AlloyDB assure un chiffrement et une authentification sécurisés à l'aide d'IAM (Identity and Access Management), ce qui contribue à sécuriser votre base de données.

Lorsque vous vous connectez à l'aide du proxy d'authentification AlloyDB, celui-ci est ajouté à votre pod à l'aide du modèle de conteneur sidecar. Le conteneur du proxy d'authentification AlloyDB se trouve dans le même pod que l'application, ce qui permet à celle-ci de se connecter au proxy d'authentification AlloyDB via localhost, améliorant ainsi la sécurité et les performances.

Créer et attribuer des rôles à des comptes de service Google

Dans Google Cloud, les applications utilisent des comptes de service pour effectuer des appels d'API autorisés en s'authentifiant en tant que compte de service. Lorsqu'une application s'authentifie en tant que compte de service, elle a accès à toutes les ressources auxquelles le compte de service est autorisé à accéder.

Pour exécuter le proxy d'authentification AlloyDB dans Google Kubernetes Engine, vous devez créer un compte de service Google pour représenter votre application. Nous vous recommandons de créer un compte de service unique pour chaque application plutôt que d'utiliser le même compte de service partout. Ce modèle est plus sécurisé, car il vous permet de limiter les autorisations par application.

Console

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

    Accéder à IAM

  2. Sur la page Autorisations pour le projet "PROJECT_ID", recherchez la ligne contenant le compte de service Compute par défaut PROJECT_NUMBER-compute@developer.gserviceaccount.com, puis cliquez sur Modifier le compte principal sur cette ligne.

    Pour obtenir l'PROJECT_NUMBER, qui est un identifiant unique généré automatiquement pour votre projet, procédez comme suit:

    1. Accédez à la page Tableau de bord de la console Google Cloud.

      Accéder à Google Dashboard

    2. Cliquez sur la liste déroulante de sélection du projet située en haut de la page. Sélectionnez votre projet dans la fenêtre Sélectionner qui s'affiche.

    L'PROJECT_NUMBER s'affiche sur la fiche Informations sur le projet du tableau de bord du projet.

  3. Cliquez sur Ajouter un autre rôle.

  4. Pour accorder le rôle roles/artifactregistry.reader, cliquez sur Sélectionner un rôle, puis choisissez Artifact Registry dans Par produit ou service, puis Artifact Registry Reader dans Rôles.

  5. Cliquez sur Enregistrer. Le rôle est attribué au compte principal.

  6. Pour créer un compte de service pour l'application exemple GKE, accédez à la page Comptes de service. Accéder à "Comptes de service"

  7. Sélectionnez votre projet.

  8. Sur la page Comptes de service pour le projet "PROJECT_ID", cliquez sur Créer un compte de service.

  9. Dans la section Détails des comptes de service de la page Créer un compte de service, saisissez GSA_NAME dans le champ Nom du compte de service, par exemple gke-alloydb-gsa.

  10. Cliquez sur Créer et continuer.

    La section Autoriser ce compte de service à accéder au projet (facultatif) de la page Créer un compte de service s'affiche.

  11. Pour accorder le rôle roles/alloydb.client, procédez comme suit:

    1. Cliquez sur Select a role (Sélectionner un rôle).
    2. Sélectionnez Cloud AlloyDB dans Par produit ou service.
    3. Sélectionnez Cloud AlloyDB Client dans Rôles.

  12. Cliquez sur Ajouter un autre rôle.

  13. Pour accorder le rôle roles/serviceusage.serviceUsageConsumer, cliquez sur Sélectionner un rôle, puis choisissez Service Usage dans Par produit ou service, puis Service Usage Consumer dans Rôles.

  14. Cliquez sur OK. Des rôles sont attribués au compte de service Google.

gcloud

  1. Pour accorder les autorisations requises au compte de service Google par défaut afin que Compute Engine puisse lire Artifact Registry, exécutez la commande suivante:

    PROGECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding PROJECT_ID  --member="serviceAccount:$PROGECT_NUM-compute@developer.gserviceaccount.com"  --role="roles/artifactregistry.reader"

  2. Pour créer un compte de service Google pour votre application, créez un compte de service IAM:

    gcloud iam service-accounts create GSA_NAME \
--display-name="gke-tutorial-service-account"

    Remplacez GSA_NAME par le nom de votre nouveau compte de service IAM, par exemple gke-alloydb-gsa.

  3. Pour accorder les rôles alloydb.client et serviceusage.serviceUsageConsumer au GSA de votre application, utilisez les commandes suivantes:

    gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/alloydb.client"
gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/serviceusage.serviceUsageConsumer"

Configurer la fédération d'identité de charge de travail pour GKE pour l'application exemple

Vous devez configurer GKE pour fournir le compte de service au proxy d'authentification AlloyDB à l'aide de la fonctionnalité Workload Identity Federation for GKE (Fédération d'identité de charge de travail pour GKE). Cette méthode vous permet d'associer un compte de service Kubernetes à un compte de service Google. Le compte de service Google devient alors accessible aux applications qui utilisent le compte de service Kubernetes correspondant.

Un compte de service Google est une identité IAM qui représente votre application dans Google Cloud. Un compte de service Kubernetes est une identité qui représente votre application dans un cluster Google Kubernetes Engine.

La fédération d'identité de charge de travail pour GKE associe un compte de service Kubernetes à un compte de service Google. Cette liaison entraîne l'authentification des déploiements avec ce compte de service Kubernetes en tant que compte de service Google dans leurs interactions avec Google Cloud.

gcloud

  1. Dans la console Google Cloud, ouvrez Cloud Shell.

    Ouvrir Cloud Shell

  2. Dans Cloud Shell, obtenez les identifiants de votre cluster:

    gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID

    Cette commande configure kubectl pour l'utilisation du cluster GKE que vous avez créé.

  3. Dans l'éditeur de votre choix, procédez comme suit:

    1. Ouvrez service-account.yaml avec nano, par exemple:

      nano service-account.yaml

    2. Dans l'éditeur, collez le contenu suivant:

        apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: KSA_NAME

      Remplacez KSA_NAME par le nom du compte de service (par exemple, ksa-alloydb).

    3. Appuyez sur Ctrl+O, sur Entrée pour enregistrer les modifications, puis sur Ctrl+X pour quitter l'éditeur.

  4. Créez un compte de service Kubernetes pour votre application exemple:

    kubectl apply -f service-account.yaml

  5. Accordez des autorisations à votre compte de service Kubernetes pour qu'il puisse usurper l'identité du compte de service Google en créant une liaison de stratégie IAM entre les deux comptes de service:

    gcloud iam service-accounts add-iam-policy-binding \
   --role="roles/iam.workloadIdentityUser" \
   --member="serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]" \
   GSA_NAME@PROJECT_ID.iam.gserviceaccount.com

  6. Ajoutez l'annotation iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID au compte de service Kubernetes à l'aide de l'adresse e-mail du compte de service Google:

    kubectl annotate serviceaccount \
  KSA_NAME \
  iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com

Renseigner Artifact Registry avec une image de l'application exemple

gcloud

  1. Dans Cloud Shell, utilisez la commande suivante pour cloner le dépôt avec l'exemple de code d'application gke-alloydb-app à partir de GitHub:

     git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go

  2. Créez un dépôt dans Artifact Registry pour les images Docker:

    gcloud artifacts repositories create REPOSITORY_ID --location REGION --repository-format=docker --project PROJECT_ID

    Remplacez les éléments suivants :

    • PROJECT_ID : par l'ID du projet.
    • REPOSITORY_ID: nom de votre dépôt, par exemple gke-alloydb-sample-app.

  3. Dans la boîte de dialogue Autoriser Cloud Shell, cliquez sur Autoriser. Cette invite ne s'affiche pas si vous avez déjà effectué cette étape.

  4. Pour créer un conteneur Docker et le publier dans Artifact Registry, utilisez la commande suivante:

     gcloud builds submit --tag  REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID

    Remplacez les éléments suivants :

    • PROJECT_ID : par l'ID du projet.
    • REPOSITORY_ID: nom de votre dépôt, par exemple gke-alloydb-sample-app.
    • SAMPLE_APPLICATION: nom de votre application Web exemple, par exemple gke-alloydb-app.

Créer un secret Kubernetes

Vous créez 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 celles spécifiées à l'étape Se connecter à votre instance principale et créer une base de données et un utilisateur AlloyDB de ce tutoriel. Pour en savoir plus, consultez la section Secrets.

gcloud

Utilisez un SECRET Kubernetes, tel que gke-alloydb-secret, pour stocker les informations de connexion:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

Déployer et exécuter le proxy AlloyDB dans un modèle side-car

Nous vous recommandons d'exécuter le proxy AlloyDB dans un modèle sidecar en tant que conteneur supplémentaire partageant un pod avec votre application pour les raisons suivantes:

  • Empêche l'exposition locale de votre trafic SQL. Le proxy AlloyDB assure le chiffrement des connexions sortantes, mais vous devez limiter l'exposition des connexions entrantes.
  • Évite les points de défaillance uniques. L'accès de chaque application à votre base de données est indépendant des autres, ce qui rend l'ensemble plus résilient.
  • Limiter l'accès au proxy AlloyDB, ce qui vous permet d'utiliser les autorisations IAM par application plutôt que d'exposer la base de données à l'ensemble du cluster.
  • Vous permet de définir plus précisément la portée des demandes de ressources. Comme le proxy AlloyDB consomme les ressources de façon linéaire, ce modèle vous permet de définir plus précisément la portée et les demandes des ressources pour les adapter à vos applications.
  • Permet de configurer votre application pour qu'elle se connecte à l'aide de 127.0.0.1 sur le DB_PORT que vous avez spécifié dans la section de commande.

Après avoir créé un cluster GKE et créé une image de conteneur pour votre application, déployez votre application conteneurisée sur le cluster GKE.

gcloud

Dans ce tutoriel, vous allez déployer l'exemple d'application Web de collecte de votes, gke-alloydb-app, qui utilise AlloyDB comme datastore.

  1. Obtenez la connexion INSTANCE_URI de l'instance principale AlloyDB à laquelle vous souhaitez que le proxy AlloyDB se connecte:

       gcloud alloydb instances describe INSTANCE_ID \
   --cluster=CLUSTER_ID \
   --region=REGION \
   --format="value(name)"

    Remplacez les éléments suivants :

    • INSTANCE_ID: nom de l'instance, par exemple alloydb-primary.
    • CLUSTER_ID: nom du cluster, par exemple alloydb-cluster.

    La sortie contient le INSTANCE_URI que vous spécifiez dans le fichier de définition proxy_sidecar_deployment.yaml à l'étape 2.b de cette section.

  2. Dans l'éditeur de votre choix, par exemple nano, procédez comme suit:

    1. Ouvrez proxy_sidecar_deployment.yaml à l'aide de l'éditeur de votre choix, par exemple nano:

      nano proxy_sidecar_deployment.yaml

    2. Dans l'éditeur, collez le contenu suivant:

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KSA_NAME
      containers:
      - name: SAMPLE_APPLICATION
        # Replace <PROJECT_ID> and <REGION> with your project ID and region.
        image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
        imagePullPolicy: Always
        # 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 NAME 
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        # To use Automatic IAM Authentication (recommended)
        # use DB_IAM_USER instead of DB_USER
        # you may also remove the DB_PASS environment variable
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: username
        - name: DB_PASS
          valueFrom:
           secretKeyRef:
              name: SECRET
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: database
     # If you are using the Go connector (recommended), you can
      # remove alloydb-proxy (everything below this line)
      - name: alloydb-proxy
        # This uses the latest version of the AlloyDB Auth proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/alloydb-auth-proxy
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        command:
          - "/alloydb-auth-proxy"
          #AlloyDB instance name as parameter for the AlloyDB proxy
          # Use <INSTANCE_URI> 
          - "INSTANCE_URI"
        securityContext:
          # The default AlloyDB Auth proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

      Remplacez INSTANCE_URI par le chemin d'accès à votre instance principale AlloyDB de l'étape 1, par exemple projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_ID/instances/INSTANCE_ID.

    3. Appuyez sur Ctrl+O, sur Entrée pour enregistrer les modifications, puis sur Ctrl+X pour quitter l'éditeur.

  3. Pour déployer l'application gke-alloydb-app, appliquez le fichier de définition proxy_sidecar_deployment.yaml que vous avez créé à l'étape précédente:

    kubectl apply -f proxy_sidecar_deployment.yaml

  4. Vérifiez que l'état des deux conteneurs du pod est running:

    kubectl get pods

    Exemple de résultat :

     NAME                          READY   STATUS    RESTARTS   AGE
 gke-alloydb-8d59bb4cc-62xgh   2/2     Running   0          2m53s

  5. Pour vous connecter à l'exemple d'application gke-alloydb-app, utilisez un service, par exemple un équilibreur de charge HTTP externe. Dans l'éditeur de votre choix, procédez comme suit:

    1. Ouvrez service.yaml avec nano, par exemple:

      nano service.yaml

    2. Dans l'éditeur nano, collez le contenu suivant:

      apiVersion: v1
kind: Service
metadata:
  name: SAMPLE_APPLICATION
spec:
  type: LoadBalancer
  selector:
    app: SAMPLE_APPLICATION
  ports:
  - port: 80
    targetPort: 8080

      Remplacez SAMPLE_APPLICATION par le nom de votre application Web exemple, par exemple gke-alloydb-app.

    3. Appuyez sur Ctrl+O, sur Entrée pour enregistrer les modifications, puis sur Ctrl+X pour quitter l'éditeur.

  6. Pour déployer l'application gke-alloydb-app du service, appliquez le fichier service.yaml:

     kubectl apply -f service.yaml

  7. Pour obtenir les détails du service, y compris son adresse IP externe, exécutez la commande suivante:

    kubectl get service

    Exemple de résultat :

    NAME              TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
gke-alloydb-app   LoadBalancer   34.118.229.246   35.188.16.172   80:32712/TCP   45s
kubernetes        ClusterIP      34.118.224.1     <none>          443/TCP        85m

  8. Utilisez la valeur de l'adresse IP externe de l'étape précédente pour accéder à l'application exemple à l'URL suivante: 

    http://EXTERNAL-IP

Exemples de fichiers de configuration

proxy_sidecar_deployment.yaml 

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <YOUR-DEPLOYMENT-NAME>
spec:
  selector:
    matchLabels:
      app: <YOUR-APPLICATION-NAME>
  template:
    metadata:
      labels:
        app: <YOUR-APPLICATION-NAME>
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      # Your application container goes here.
      - name: <YOUR-APPLICATION-NAME>
        image: <YOUR-APPLICATION-IMAGE-URL>
        env:
        - name: DB_HOST
          # The port value here (5432) should match the --port flag below.
          value: "localhost:5342"
        - 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
      # The Auth Proxy sidecar goes here.
      - name: alloydb-auth-proxy
        # Make sure you have automation that upgrades this version regularly.
        # A new version of the Proxy is released monthly with bug fixes,
        # security updates, and new features.
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        args:
          # If you're connecting over public IP, enable this flag.
          # - "--public-ip"

          # If you're connecting with PSC, enable this flag:
          # - "--psc"

          # If you're using auto IAM authentication, enable this flag:
          # - "--auto-iam-authn"

          # Enable structured logging with Google's LogEntry format:
          - "--structured-logs"

          # Listen on localhost:5432 by default.
          - "--port=5432"
          # Specify your instance URI, e.g.,
          # "projects/myproject/locations/us-central1/clusters/mycluster/instances/myinstance"
          - "<INSTANCE-URI>"

        securityContext:
          # The default AlloyDB Auth Proxy image runs as the "nonroot" user and
          # group (uid: 65532) by default.
          runAsNonRoot: true
        # You should use resource requests/limits as a best practice to prevent
        # pods from consuming too many resources and affecting the execution of
        # other pods. You should adjust the following values based on what your
        # application needs. For details, see
        # https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

service.yaml 

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: v1
kind: Service
metadata:
  name: <YOUR-SERVICE-NAME>
spec:
  type: LoadBalancer
  selector:
    app: <YOUR-APPLICATION-NAME>
  ports:
  - port: 80
    targetPort: 8080

service-account.yaml 

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: v1
kind: ServiceAccount
metadata:
  name: <YOUR-KSA-NAME> # TODO(developer): replace this value

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud , supprimez le projet contenant les ressources, ou conservez le projet et supprimez chaque ressource individuellement.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

  1. Dans la console Google Cloud, accédez à la page Gérer les ressources.

    Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.

  3. Dans la boîte de dialogue, saisissez votre PROJECT_ID, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante