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éez une image Docker pour AlloyDB.
Exécuter 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 fait appel à des composants payants 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

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 sans frais pour exécuter, tester et déployer des charges de travail.

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

Roles required to select or create a project

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

Go to project selector

Verify that 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.

Roles required to select or create a project

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

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Vérifiez que vous disposez des autorisations requises pour suivre ce tutoriel.
Activez les APIs Cloud nécessaires pour créer une instance AlloyDB et vous y connecter.

Activer les API

À l'étape Confirmer le projet, cliquez sur Suivant pour confirmer le nom du projet que vous allez modifier.
À 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

gcloud

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

Roles required to select or create a project

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

Go to project selector

Verify that 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.

Roles required to select or create a project

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

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Vérifiez que vous disposez des autorisations requises pour suivre ce tutoriel.

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

Rôles requis

Pour obtenir les autorisations nécessaires pour effectuer les tâches de ce tutoriel, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Administrateur de bases de données (roles/iam.databasesAdmin)
Administrateur de cluster Kubernetes Engine (roles/container.clusterAdmin)
Administrateur de projet IAM (roles/resourcemanager.projectIamAdmin)
Administrateur de compte de service(roles/iam.serviceAccountAdmin)
Administrateur Kubernetes Engine(roles/container.admin)
Administrateur Artifact Registry(roles/artifactregistry.admin)

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

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

Accédez à la console Google Cloud .

ConsoleGoogle Cloud
Cliquez sur Activer Cloud Shell en haut de la console Google Cloud .
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

gcloud

Pour lancer Cloud Shell, procédez comme suit :
Dans la console Google Cloud , activez Cloud Shell.

Activer Cloud Shell

En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

Pour initialiser l'environnement, 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

Activez les API Cloud nécessaires pour créer une instance AlloyDB pour PostgreSQL et vous y connecter.

gcloud services enable alloydb.googleapis.com \
    compute.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudbuild.googleapis.com \
    containerregistry.googleapis.com \
    servicenetworking.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com

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 IP interne pour éviter d'exposer la base de données à l'Internet public.

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

Console

Accédez à la page Clusters.

accéder aux clusters
Dans la section Configurer le cluster, dans le champ ID du cluster, saisissez un ID pour votre cluster. Il doit commencer par une lettre minuscule et peut contenir des lettres minuscules, des chiffres et des traits d'union, comme alloydb-cluster.
Dans le champ Mot de passe, saisissez le CLUSTER_PASSWORD à utiliser pour l'utilisateur de base de données postgres par défaut lors de la création du cluster.
Dans le champ Version de la base de données, sélectionnez la version majeure POSTGRES_VERSION pour votre nouveau cluster AlloyDB.
Sélectionnez un REGION pour votre cluster, par exemple us-central1.
Dans la section Configurer votre instance principale, procédez comme suit :
1. Dans le champ ID d'instance, saisissez le INSTANCE_ID de votre instance principale, par exemple alloydb-primary.
2. Sélectionnez une série de machines, par exemple N2.
3. Sélectionnez un type de machine et spécifiez le nombre d'unités de traitement virtuelles NUM_CPU, par exemple 2.
4. Pour vous assurer qu'une plage d'adresses IP est attribuée à l'appairage de services, configurez la connexion Accès aux services privés (PSA) :
  1. Dans la liste Réseau, sélectionnez default.
  2. Si une plage d'adresses IP comme default-ip-range est déjà réservée, sélectionnez-la dans la liste Plage d'adresses IP attribuée.
  3. Si aucune plage d'adresses IP n'est attribuée, cliquez sur Allouer une plage d'adresses IP personnalisée pour allouer une nouvelle adresse IP interne IP_RANGE_NAME et configurer la connexion.
Cliquez sur Créer un cluster.

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

gcloud

Dans Cloud Shell, vérifiez si la plage d'adresses IP (IPv4) non utilisé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 à ce qui suit :
```
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.
(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 le nom que vous souhaitez donner aux adresses IP internes disponibles dans un sous-réseau AlloyDB, par exemple alloydb-gke-psa-01.

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

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, comme 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
  - 16 : pour la compatibilité avec PostgreSQL 16
  - 17 : pour la compatibilité avec PostgreSQL 17, qui est la version PostgreSQL par défaut acceptée
  - 18, pour la compatibilité avec PostgreSQL 18
- CLUSTER_PASSWORD : mot de passe à utiliser pour l'utilisateur postgres par défaut.
- PROJECT_ID : ID de votre Google Cloud projet dans lequel vous souhaitez placer le cluster.
- REGION : nom de la région dans laquelle le cluster AlloyDB est créé, par exemple us-central1.
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.
- Remplacez CLUSTER_ID par le nom du cluster AlloyDB, par exemple alloydb-cluster.
- NUM_CPU par le nombre d'unités de traitement virtuelles, par exemple 2.
- PROJECT_ID par l'ID de votre projet Google Cloud ;
- Remplacez REGION par 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

Pour créer une base de données et un utilisateur de base de données sur votre instance principale, procédez comme suit :

Console

Si vous n'êtes pas sur la page Présentation du cluster que vous venez de créer, accédez à la page Clusters dans la console Google Cloud .

accéder aux clusters
Pour afficher la page Présentation du cluster, cliquez sur le nom du cluster CLUSTER_ID.
Dans le menu de navigation, cliquez sur AlloyDB Studio.
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.
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 pour la base de données AlloyDB :
```
CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';
```
  Remplacez les éléments suivants :
  - USERNAME : nom de l'utilisateur AlloyDB, tel que tutorial_user.
  - DATABASE_PASSWORD : mot de passe de votre base de données AlloyDB, tel que tutorial.
5. Cliquez sur Exécuter. Attendez que le message Statement executed successfully s'affiche dans le volet Résultats.
Dans le volet Explorateur d'AlloyDB Studio, cliquez sur Changer d'utilisateur/de base de données.
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.
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 les autorisations liées au schéma public à l'utilisateur de la base de données AlloyDB :
```
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.
Notez le nom, le nom d'utilisateur et le mot de passe de la base de données. Vous utiliserez ces informations dans Créer un secret Kubernetes.

gcloud

Pour créer un utilisateur de base de données AlloyDB, exécutez la commande suivante dans Cloud Shell :
```
gcloud alloydb users create USERNAME \
    --cluster=CLUSTER_ID \
    --region=REGION \
    --password=DATABASE_PASSWORD
```
Remplacez les éléments suivants :
- USERNAME : nom de l'utilisateur AlloyDB, tel que tutorial_user.
- CLUSTER_ID : ID du cluster, tel que alloydb-cluster.
- REGION : région où se trouve le cluster, par exemple us-central1.
- DATABASE_PASSWORD : mot de passe de votre base de données AlloyDB, tel que tutorial.
Pour créer une base de données et accorder des autorisations, vous devez vous connecter au cluster et exécuter des commandes SQL. Dans Cloud Shell, utilisez le client psql pour vous connecter à votre instance.

Remarque : Pour vous connecter à une instance AlloyDB depuis Cloud Shell, vous devez utiliser le proxy d'authentification AlloyDB. Pour une configuration plus simple, vous pouvez suivre ces étapes à l'aide d'AlloyDB Studio dans la console Google Cloud .
Une fois connecté à votre instance en tant qu'utilisateur postgres, créez la base de données :
```
CREATE DATABASE DATABASE_NAME;
```
Remplacez DATABASE_NAME par le nom de votre choix, par exemple tutorial_db.
Accordez toutes les autorisations à l'utilisateur de la base de données AlloyDB sur la nouvelle base de données :
```
GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";
```
Connectez-vous à la nouvelle base de données et accordez les autorisations sur le schéma public :
```
\c DATABASE_NAME
GRANT CREATE ON SCHEMA public TO "USERNAME";
```
Notez le nom, le nom d'utilisateur et le mot de passe de la base de données. Vous utiliserez ces informations dans 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 nécessaires pour faire partie du cluster. Vous déployez les applications sur des clusters, et ces applications s'exécutent sur les nœuds.

Console

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

Accéder à la page Clusters Kubernetes
Cliquez sur Créer.
Spécifiez GKE_CLUSTER_ID pour votre cluster Autopilot dans le champ Nom de la page Paramètres de base du cluster, par exemple ap-cluster.
Dans le champ Région, sélectionnez REGION, par exemple us-central1.
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, tel que 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'Identity and Access Management (IAM), 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 à l'aide de localhost, améliorant ainsi la sécurité et les performances.

Créer et attribuer des rôles aux 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

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

Accéder à IAM
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 le 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 dans 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. Dans la fenêtre Sélectionner qui s'affiche, sélectionnez votre projet.
Le PROJECT_NUMBER est affiché sur la fiche Informations sur le projet du tableau de bord du projet.
Cliquez sur Ajouter un autre rôle.
Pour accorder le rôle roles/artifactregistry.reader, cliquez sur Sélectionner un rôle, puis sélectionnez Artifact Registry dans Par produit ou service et Artifact Registry Reader dans Rôles.
Cliquez sur Enregistrer. Le rôle est attribué au compte principal.
Pour créer un compte de service pour l'application exemple GKE, accédez à la page Comptes de service. Accéder à la page "Comptes de service"
Sélectionnez votre projet.
Sur la page Comptes de service pour le projet "PROJECT_ID", cliquez sur Créer un compte de service.
Dans la section Détails du compte 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.
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.
Pour accorder le rôle roles/alloydb.client, procédez comme suit :
1. Cliquez sur Sélectionner un rôle.
2. Sélectionnez Cloud AlloyDB dans Par produit ou service.
3. Sélectionnez Cloud AlloyDB Client dans Rôles.
Cliquez sur Ajouter un autre rôle.
Pour accorder le rôle roles/serviceusage.serviceUsageConsumer, cliquez sur Sélectionner un rôle, puis sélectionnez Service Usage dans Par produit ou service et Service Usage Consumer dans Rôles.
Cliquez sur OK. Des rôles sont attribués au compte de service Google.

gcloud

Pour accorder les autorisations requises au compte de service Google par défaut afin que Compute Engine puisse lire les données d'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"

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.

Pour attribuer les rôles alloydb.client et serviceusage.serviceUsageConsumer au système 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. 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 utilisant 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.

Workload Identity Federation pour GKE associe un compte de service Kubernetes à un compte de service Google. Cette liaison permet à tous les déploiements associés à ce compte de service Kubernetes de s'authentifier en tant que compte de service Google lors de leurs interactions avec Google Cloud.

Console

Pour lancer Cloud Shell, procédez comme suit :
Dans la console Google Cloud , activez Cloud Shell.

Activer Cloud Shell

En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

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éé.
Dans l'éditeur de votre choix, procédez comme suit :
1. Ouvrez service-account.yaml à l'aide de 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, puis sur ENTRÉE pour enregistrer les modifications. Appuyez ensuite sur Ctrl+X pour quitter l'éditeur.
Créez un compte de service Kubernetes pour votre exemple d'application :
```
kubectl apply -f service-account.yaml
```
Pour associer le compte de service Kubernetes au compte de service Google, procédez comme suit dans la console Google Cloud :
1. Dans la console Google Cloud , accédez à la page Comptes de service.
  
  Accéder à la page "Comptes de service"
2. Sélectionnez votre projet.
3. Cliquez sur le nom du compte de service Google GSA_NAME.
4. Cliquez sur l'onglet Autorisations.
5. Cliquez sur Accorder l'accès.
6. Dans le champ Nouveaux comptes principaux, saisissez les identités suivantes :
  
  serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]
7. Dans la liste Sélectionner un rôle, sélectionnez IAM > Utilisateur de l'identité de charge de travail.
8. Cliquez sur Enregistrer.
Dans Cloud Shell, ajoutez l'annotation iam.gke.io/gcp-service-account 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
```

gcloud

Dans la console Google Cloud , ouvrez Cloud Shell.

Ouvrir Cloud Shell
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éé.
Dans l'éditeur de votre choix, procédez comme suit :
1. Ouvrez service-account.yaml à l'aide de 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, puis sur ENTRÉE pour enregistrer les modifications. Appuyez ensuite sur Ctrl+X pour quitter l'éditeur.
Créez un compte de service Kubernetes pour votre exemple d'application :
```
kubectl apply -f service-account.yaml
```

Accordez à votre compte de service Kubernetes les autorisations nécessaires pour emprunter 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

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

Renseignez Artifact Registry avec une image de l'exemple d'application.

Pour créer une image de conteneur de l'exemple d'application et la transférer vers un dépôt, procédez comme suit.

Console

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

Accéder à Artifact Registry
Pour créer un dépôt, cliquez sur .
Dans le champ Nom, saisissez REPOSITORY_ID, par exemple gke-alloydb-sample-app.
Dans la section Format, sélectionnez Docker.
Dans la section Type d'emplacement, sélectionnez Région, puis choisissez REGION, par exemple us-central1.
Cliquez sur Créer.
Pour créer l'image de l'exemple d'application, lancez Cloud Shell et procédez comme suit.
Dans la console Google Cloud , activez Cloud Shell.

Activer Cloud Shell

En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

Dans Cloud Shell, clonez le dépôt avec l'exemple de code d'application gke-alloydb-app depuis GitHub :

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

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.
Pour créer le conteneur Docker et le publier dans Artifact Registry, exécutez 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, tel que gke-alloydb-sample-app.
- SAMPLE_APPLICATION : nom de votre exemple d'application Web, tel que gke-alloydb-app.

gcloud

Dans Cloud Shell, utilisez la commande suivante pour cloner le dépôt avec l'exemple de code d'application gke-alloydb-app depuis GitHub :
```
 git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go
```
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, tel que gke-alloydb-sample-app.
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.
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, tel que gke-alloydb-sample-app.
- SAMPLE_APPLICATION : nom de votre exemple d'application Web, tel que gke-alloydb-app.

Créer un secret Kubernetes

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 les valeurs 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 Secrets.

Console

Dans votre fenêtre Cloud Shell ouverte, 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

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 AlloyDB Proxy 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 aux connexions entrantes.
Cela permet d'éviter un point de défaillance unique. 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.
Vous permet de configurer votre application pour qu'elle se connecte à l'aide de 127.0.0.1 sur la valeur DB_PORT spécifiée dans la section de commande.

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

Console

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

Obtenez la chaîne de connexion INSTANCE_URI pour l'instance principale AlloyDB :
1. Dans la console Google Cloud , accédez à la page Clusters.
  
  accéder aux clusters
2. Pour afficher la page Présentation du cluster, cliquez sur son nom.
3. Dans le tableau Instances, cliquez sur le nom de votre instance principale.
4. Dans le champ URI de l'instance de la page Présentation, cliquez sur Copier dans le presse-papiers.
Vous spécifiez cette INSTANCE_URI dans le fichier de définition proxy_sidecar_deployment.yaml à l'étape 2.b de cette section.

Dans Cloud Shell, procédez comme suit :

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

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"
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        - 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
      - name: alloydb-proxy
        # This uses the latest version of the 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
          - "INSTANCE_URI "
        securityContext:
          runAsNonRoot: true
        resources:
          requests:
            memory: "2Gi"
            cpu:    "1"

Remplacez INSTANCE_URI par le chemin d'accès que vous avez copié à l'étape 1.

Appuyez sur Ctrl+O, puis sur ENTRÉE pour enregistrer les modifications. Appuyez ensuite sur Ctrl+X pour quitter l'éditeur.

Pour déployer l'application gke-alloydb-app, appliquez le fichier de définition :
```
kubectl apply -f proxy_sidecar_deployment.yaml
```
Pour vérifier que l'application est en cours d'exécution, accédez à la page Charges de travail de la console Google Cloud :

Accéder à la page Charges de travail

Vérifiez que l'état du déploiement gke-alloydb est OK.
Pour vous connecter à l'application exemple à l'aide d'un équilibreur de charge externe, procédez comme suit dans Cloud Shell :
1. Ouvrez service.yaml :
```
nano service.yaml
```
2. 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, par exemple gke-alloydb-app.
3. Enregistrez et quittez l'éditeur, puis appliquez le service :
```
kubectl apply -f service.yaml
```
Pour obtenir l'adresse IP externe de votre application, accédez à la page Services et entrées de la console Google Cloud :

Accéder à la page Services et entrées
Utilisez la valeur de la colonne Points de terminaison externes pour accéder à l'application à l'URL suivante :

http://EXTERNAL_IP

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.

Obtenez la chaîne de 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, tel que alloydb-primary.
- CLUSTER_ID : nom du cluster, tel que 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.

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

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

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.

Appuyez sur Ctrl+O, puis sur ENTRÉE pour enregistrer les modifications. Appuyez ensuite sur Ctrl+X pour quitter l'éditeur.

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

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

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 à l'aide de 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 exemple d'application Web, tel que gke-alloydb-app.
3. Appuyez sur Ctrl+O, puis sur ENTRÉE pour enregistrer les modifications. Appuyez ensuite sur Ctrl+X pour quitter l'éditeur.
Pour déployer l'application de service gke-alloydb-app, appliquez le fichier service.yaml :
```
 kubectl apply -f service.yaml
```

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

Utilisez la valeur de l'adresse IP externe de l'étape précédente pour accéder à l'exemple d'application à 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 dans ce tutoriel ne soient facturées sur votre compte Google Cloud , supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

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 :

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

Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez PROJECT_ID, puis cliquez sur Arrêter pour supprimer le projet.

Se connecter à AlloyDB pour PostgreSQL depuis Google Kubernetes Engine (GKE) Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Objectifs

Coûts

Avant de commencer

Console

gcloud

Rôles requis

Lancer Cloud Shell

Console

gcloud

Créer un cluster AlloyDB et son instance principale

Console

gcloud

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

Console

gcloud

Créer un cluster GKE Autopilot

Console

gcloud

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

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

Console

gcloud

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

Console

gcloud

Renseignez Artifact Registry avec une image de l'exemple d'application.

Console

gcloud

Créer un secret Kubernetes

Console

gcloud

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

Console

gcloud

Exemples de fichiers de configuration

proxy_sidecar_deployment.yaml

service.yaml

service-account.yaml

Effectuer un nettoyage

Supprimer le projet

Étapes suivantes

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