Cette page a été traduite par l'API Cloud Translation.

Déployer une application à l'aide de GKE Autopilot et de Spanner

Autopilot

Ce tutoriel explique comment déployer une application Web conteneurisée sur un cluster Google Kubernetes Engine (GKE) Autopilot, et comment utiliser une base de données Google Spanner dans le backend pour stocker des données. L'exemple d'application gère une table de joueurs. Vous pouvez ajouter et supprimer des joueurs via l'interface utilisateur graphique (IUG) de l'application.

Spanner est un service de base de données relationnelle entièrement géré, distribué à l'échelle mondiale et à évolutivité horizontale qui fournit des transactions ACID et une sémantique SQL sans compromis sur les performances et la haute disponibilité.

Avant de lire ce document, assurez-vous de connaître Kubernetes.

Pourquoi utiliser GKE et Spanner ?

En tant que développeur, vous ne souhaitez peut-être pas consacrer du temps à déterminer la quantité de ressources de stockage et de calcul dont votre application a besoin, ni à prédire la consommation de RAM et de processeur lors des périodes de demandes variables, ou à vous soucier de la défaillance de l'application lors de la charge maximale.

En utilisant GKE Autopilot en tant que service Kubernetes entièrement géré, et Spanner en tant que service de base de données entièrement géré, vous pouvez développer et déployer des applications plus rapidement sur une infrastructure stable, qui simplifie la configuration et la gestion des ressources. GKE Autopilot gère la configuration et le scaling de l'infrastructure permettant d'héberger votre application en ajoutant des nœuds au cluster, ou en en supprimant de celui-ci, en fonction des exigences lors de l'exécution. De même, Spanner peut être soumis à un scaling vertical ou horizontal de manière dynamique, en ne nécessitant qu'une intervention manuelle minime, à mesure que les exigences de stockage ou de calcul évoluent.

Par exemple, imaginons que vous commercialisez le prochain jeu à succès, qui est susceptible de devenir viral et donc de provoquer un pic de trafic pendant sa semaine de lancement. Spanner peut vous aider à gérer ce débit soudain en vous permettant d'augmenter, de réduire ou de redistribuer instantanément des ressources de calcul, tout en maintenant une disponibilité maximale pour votre application grâce à GKE Autopilot.

Objectifs

Dans ce tutoriel, vous allez apprendre à effectuer les opérations suivantes :

Créer une base de données Spanner qui stocke un registre de joueurs
Déployez un exemple d'application Web appelée hello-app-cloud-spanner, avec une interface utilisateur graphique.

Le tableau suivant décrit les ressources Google Cloud que vous créez ou utilisez, les variables avec lesquelles elles sont identifiées et les valeurs qui leur sont recommandées pour les besoins de ce tutoriel :

Ressource	Variable	Valeur
ID de projet Google Cloud	`PROJECT_ID`	ID du projet généré lorsque vous créez un projet. Exemple : `my-gcp-project`
Région de calcul	`COMPUTE_REGION`	Région Compute Engine dans laquelle vous souhaitez créer l'instance Spanner et le cluster GKE. Nous vous recommandons de choisir la région la plus proche de l'emplacement géographique de vos clients. Cependant, pour ce tutoriel, utilisez `us-west1`.
Instance Spanner	-	`hello-instance`
Base de données Spanner	-	`hello-database`
Cluster GKE Autopilot	`CLUSTER_NAME`	`hello-cluster`
Espace de noms Kubernetes	`NAMESPACE`	`hello-namespace`
Compte de service Kubernetes	`KSA_NAME`	`ksa-helloapp`
Compte de service IAM	`GSA_NAME`	`gsa-helloapp`
ID de projet du compte de service IAM	`GSA_PROJECT`	Votre `PROJECT_ID` Google Cloud.

Pour ce tutoriel, nous vous recommandons de créer des ressources, ce qui vous permet de les supprimer facilement et sans risque après avoir déployé l'exemple d'application. Toutefois, si vous disposez d'espaces de noms, de comptes de service IAM et de comptes de service Kubernetes existants, vous pouvez les utiliser.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Assurez-vous de remplir les conditions préalables suivantes :

Sélectionner ou créer un projet

Vous pouvez utiliser un projet existant ou en créer un pour ce tutoriel.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

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

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

Go to project selector

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

Activer les API

Enable the Artifact Registry, Compute Engine, GKE, and IAM Service Account Credentials APIs.

Enable the APIs

Configurer Cloud Shell

Dans ce tutoriel, vous utilisez Cloud Shell pour exécuter des commandes gcloud et kubectl. Cloud Shell est un environnement shell permettant de gérer les ressources hébergées sur Google Cloud. Il est doté de Google Cloud CLI et de l'outil de ligne de commande kubectl.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

Une session Cloud Shell s'ouvre dans un cadre situé en bas de la console.

Avant d'exécuter des commandes dans ce tutoriel, assurez-vous que votre projet par défaut est défini sur l'ID du projet dans lequel vous souhaitez déployer l'exemple d'application. Si ce n'est pas déjà fait, exécutez la commande suivante dans Cloud Shell :

gcloud config set project PROJECT_ID

Remplacez PROJECT_ID par votre ID du projet

Accorder des rôles IAM

Assurez-vous que votre compte Google Cloud dispose des rôles IAM requis pour ce tutoriel.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/iam.serviceAccountAdmin, roles/serviceusage.serviceUsageConsumer, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/spanner.admin, roles/container.admin

gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

Replace PROJECT_ID with your project ID.
Replace USER_IDENTIFIER with the identifier for your user account. For example, user:[email protected].
Replace ROLE with each individual role.

Configurer Spanner

Pour configurer Spanner, vous devez créer une instance Spanner et une base de données Spanner.

Créer une instance Spanner

Une instance Spanner alloue les ressources utilisées par les bases de données Spanner créées dans cette instance.

Créez une instance Spanner appelée hello-instance avec une configuration régionale et une capacité de calcul de 100 unités de traitement.

gcloud spanner instances create hello-instance \
    --config=regional-COMPUTE_REGION \
    --description="Spanner sample instance" \
    --processing-units=100

Remplacez COMPUTE_REGION par us-west1 pour ce tutoriel.

Créer une base de données Spanner

Une base de données Spanner inclut vos tables, vos vues et vos index. Une base de données hérite des propriétés de son instance parente, comme par exemple sa configuration (régionale ou multirégionale), sa capacité de calcul disponible et son stockage.

Créez une base de données Spanner appelée hello-database avec une table nommée Players à l'aide du dialecte GoogleSQL. Exécutez la requête suivante dans Cloud Shell :

gcloud spanner databases create hello-database \
    --instance=hello-instance \
    --database-dialect=GOOGLE_STANDARD_SQL \
    --ddl="CREATE TABLE Players (
        PlayerUuid STRING(36) NOT NULL,
        FirstName STRING(1024),
        LastName STRING(1024),
        BirthDate DATE) PRIMARY KEY(PlayerUuid)"

Créer un cluster GKE Autopilot

Une fois que vous avez configuré Spanner, créez un cluster Autopilot et utilisez la fédération d'identité de charge de travail pour GKE afin d'accéder à votre base de données de manière sécurisée et gérable.

Créez un cluster Autopilot nommé hello-cluster. La fédération d'identité de charge de travail pour GKE est activée par défaut sur les clusters Autopilot.

gcloud container clusters create-auto CLUSTER_NAME \
  --region=COMPUTE_REGION

Remplacez les éléments suivants :

CLUSTER_NAME : hello-cluster
COMPUTE_REGION : région Compute Engine de votre cluster. Pour ce tutoriel, utilisez la même région, us-west1, que celle où vous avez créé l'instance Spanner. Nous vous recommandons de créer l'instance Spanner et le cluster GKE Autopilot dans la même région afin de réduire la latence.

La création du cluster peut prendre entre 8 et 10 minutes.

Le résultat ressemble à ce qui suit :

NAME: hello-cluster
LOCATION: us-west1
MASTER_VERSION: 1.26.5-gke.1200
MASTER_IP: 192.0.2.1
MACHINE_TYPE: e2-medium
NODE_VERSION: 1.26.5-gke.1200
NUM_NODES: 3
STATUS: RUNNING

Configurer le cluster afin qu'il utilise la fédération d'identité de charge de travail pour GKE

Configurez votre cluster afin qu'il s'authentifie auprès de Google Cloud à l'aide de la fédération d'identité de charge de travail pour GKE avant de déployer l'application.

Obtenez des identifiants pour accéder à votre cluster :
```
gcloud container clusters get-credentials CLUSTER_NAME \
  --region=COMPUTE_REGION
```
Remplacez les éléments suivants :
- CLUSTER_NAME : hello-cluster
- COMPUTE_REGION : us-west1
Cette commande met à jour un fichier kubeconfig avec les identifiants et les informations sur les points de terminaison appropriés pour que kubectl pointe vers votre cluster.
Créez un espace de noms à utiliser pour le compte de service Kubernetes. Vous pouvez également utiliser l'espace de noms par défaut ou tout espace de noms existant.
```
kubectl create namespace NAMESPACE
```
Remplacez NAMESPACE par hello-namespace, le nom du nouvel espace de noms que vous créez.
Créez un compte de service Kubernetes que votre application pourra utiliser.
```
kubectl create serviceaccount KSA_NAME \
  --namespace NAMESPACE
```
Remplacez les éléments suivants :
- KSA_NAME : ksa-helloapp, nom du nouveau compte de service Kubernetes que vous créez.
- NAMESPACE : hello-namespace
Créez un compte de service IAM pour votre application :
```
gcloud iam service-accounts create GSA_NAME \
  --project=GSA_PROJECT
```
Remplacez les éléments suivants :
- GSA_NAME : gsa-helloapp, nom du nouveau compte de service IAM que vous créez.
- GSA_PROJECT : ID de votre projet Google Cloud. Dans ce tutoriel, vous créez le compte de service IAM dans le même projet Google Cloud que celui dans lequel vous déployez l'exemple d'application. Par conséquent, votre GSA_PROJECT et votre PROJECT_ID Google Cloud sont identiques.

Ajoutez une liaison de stratégie IAM pour votre compte de service IAM afin de lire et d'écrire dans Spanner :

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member "serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud
GSA_NAME : gsa-helloapp

Exemple :

gcloud projects add-iam-policy-binding my-gcp-project \
  --member "serviceAccount:[email protected]" \
  --role "roles/spanner.admin"

Autorisez le compte de service Kubernetes à emprunter l'identité du compte de service IAM en ajoutant une liaison de stratégie IAM entre les deux comptes de service. Cette liaison permet au compte de service Kubernetes d'agir en tant que compte de service IAM, afin que le compte de service Kubernetes puisse lire et écrire dans Spanner.
```
gcloud iam service-accounts add-iam-policy-binding GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"
```
Remplacez les éléments suivants :
- GSA_NAME : gsa-helloapp
- GSA_PROJECT : ID de votre projet Google Cloud
- PROJECT_ID : ID de votre projet Google Cloud
- NAMESPACE : hello-namespace
- KSA_NAME : ksa-helloapp
Exemple :
```
gcloud iam service-accounts add-iam-policy-binding [email protected] \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:my-gcp-project.svc.id.goog[hello-namespace/ksa-helloapp]"
```
Annotez le compte de service Kubernetes avec l'adresse e-mail du compte de service IAM. Cela permet à votre exemple d'application d'identifier le compte de service à utiliser pour accéder aux services Google Cloud. Ainsi, lorsque l'application utilise des bibliothèques clientes d'API Google standards pour accéder aux services Google Cloud, elle utilise ce compte de service IAM.
```
kubectl annotate serviceaccount KSA_NAME \
  --namespace NAMESPACE \
  iam.gke.io/gcp-service-account=GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com
```
Remplacez les éléments suivants :
- KSA_NAME : ksa-helloapp
- NAMESPACE : hello-namespace
- GSA_NAME : gsa-helloapp
- GSA_PROJECT : ID de votre projet Google Cloud
Exemple :
```
kubectl annotate serviceaccount ksa-helloapp \
  --namespace hello-namespace \
  iam.gke.io/gcp-service-account=gsa-helloapp@my-gcp-project.iam.gserviceaccount.com
```
Remarque : Si la liaison IAM n'existe pas, cette annotation n'accorde pas à elle seule l'accès au pod afin d'emprunter l'identité du compte de service IAM.

Déployer l'application exemple sur le cluster

Maintenant que vous avez configuré GKE et Spanner avec les services et l'authentification nécessaires, vous êtes prêt à déployer l'exemple d'application hello-app-cloud-spanner.

Clonez l'exemple d'application depuis le dépôt GitHub vers Cloud Shell :

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

Lancez l'éditeur Cloud Shell en cliquant sur Ouvrir l'éditeur dans la barre d'outils de la fenêtre de terminal.

Pour en savoir plus, consultez la présentation de l'interface de l'éditeur Cloud Shell.
Ouvrez le volet "Explorer" de l'éditeur Cloud Shell, puis accédez au répertoire kubernetes-engine-samples/databases/hello-app-cloud-spanner/k8s.
Ouvrez le fichier deployment.yaml et mettez à jour le champ serviceAccountName en remplaçant <KSA_NAME> par ksa-helloapp, qui est le nom de votre compte de service Kubernetes.

Figure 1. Mettez à jour le nom du compte de service Kubernetes dans le fichier de déploiement.
Fermez l'éditeur Cloud Shell, puis revenez au terminal Cloud Shell.
Dans le terminal Cloud Shell, accédez au répertoire hello-app-cloud-spanner :
```
cd kubernetes-engine-samples/databases/hello-app-cloud-spanner
```
Pour déployer l'application, procédez comme suit :
```
kubectl apply -f k8s/deployment.yaml -n=NAMESPACE
```
Remplacez NAMESPACE par hello-namespace.

Attendez que l'application soit déployée avec STATUS en tant que Running :

kubectl get pods -n=NAMESPACE --watch

Remplacez NAMESPACE par hello-namespace.

Le résultat ressemble à ce qui suit :

NAME                                       READY   STATUS              RESTARTS   AGE
hello-app-cloud-spanner-765c9b8779-lfcrc   0/1     ContainerCreating   0          87s
hello-app-cloud-spanner-765c9b8779-lfcrc   1/1     Running             0          3m15s

Appuyez sur les touches Ctrl+C de votre clavier pour revenir à l'invite de commande et exécuter d'autres commandes.

Exposer l'application exemple sur Internet

Pour exposer un service Kubernetes en dehors du cluster, créez un service de LoadBalancer. Ce type de service génère une adresse IP d'équilibreur de charge externe pour vos pods, accessible via Internet.

Déployez l'équilibreur de charge :
```
kubectl apply -f k8s/service.yaml -n=NAMESPACE
```
Remplacez NAMESPACE par hello-namespace.
Recherchez une adresse IP externe à attribuer :
```
kubectl get service -n=NAMESPACE --watch
```
Remplacez NAMESPACE par hello-namespace.
Une fois l'opération terminée, copiez l'EXTERNAL-IP (par exemple, 203.0.113.0) et ouvrez-la dans un navigateur. Une interface Web s'ouvre, qui affiche et gère la base de données des joueurs.
Vous pouvez utiliser l'IUG de l'application pour créer ou supprimer des enregistrements de joueur. Ceux-ci seront enregistrés dans la base de données Spanner.

Figure 2. Créer ou supprimer des joueurs dans le registre

Exécutez la requête suivante pour vérifier si la base de données Spanner a été mise à jour avec vos entrées :
```
gcloud spanner databases execute-sql hello-database \
  --instance=hello-instance \
  --sql="SELECT * FROM Players LIMIT 10"
```
Le résultat ressemble à ce qui suit :
```
PlayerUuid: a1f34bbf-929c-498d-8b16-39bbb29d70e3
FirstName: John
LastName: Smith
BirthDate: 1997-07-12

PlayerUuid: d634e157-96ea-45f2-be3f-fb907ced188e
FirstName: Jane
LastName: Doe
BirthDate: 2013-07-12
```

Nettoyer

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 les ressources individuelles.

Supprimer votre projet

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

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Si vous avez supprimé le projet, le nettoyage est terminé. Si vous n'avez pas supprimé le projet, suivez les étapes ci-après afin de supprimer les ressources GKE et Spanner.

Supprimer les ressources GKE

Supprimez le service. Cette étape annule l'allocation de l'équilibreur de charge Google Cloud créé pour le service :
```
kubectl delete service hello-app-cloud-spanner -n=NAMESPACE
```
Remplacez NAMESPACE par hello-namespace.
Supprimez le cluster GKE. Cela supprime les ressources qui constituent un cluster, telles que les instances de calcul, les disques et les ressources réseau :
```
gcloud container clusters delete CLUSTER_NAME --region=COMPUTE_REGION
```
Remplacez les éléments suivants :
- CLUSTER_NAME : hello-cluster
- COMPUTE_REGION : us-west1

Supprimer les ressources Spanner

Supprimez la base de données Spanner :

gcloud spanner databases delete hello-database --instance=hello-instance

Supprimez l'instance Spanner :

Attention : La suppression définitive d'une instance supprime également toutes ses bases de données.
```
gcloud spanner instances delete hello-instance
```

Étapes suivantes

Découvrez comment créer un cluster GKE pour votre installation Agones.
Découvrez les bonnes pratiques pour utiliser Spanner en tant que base de données de gaming.
Apprenez à déployer sur GKE une base de données PostgreSQL à disponibilité élevée.
Découvrez les bonnes pratiques pour le déploiement de bases de données sur GKE.