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

Dans ce tutoriel, nous partons du principe que vous disposez des connaissances de base sur Kubernetes.

Pourquoi 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éployer 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é lors de la création d'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 les besoins de ce tutoriel, nous vous recommandons de créer des ressources afin de les supprimer facilement et sans risque après le déploiement de 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 :

Instances Compute Engine utilisées par GKE
Spanner
Cloud Load Balancing

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.

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

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

Accéder au sélecteur de projet

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

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

Accéder au sélecteur de projet

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

Activer les API

Activer les API Artifact Registry, Compute Engine, GKE, and IAM Service Account Credentials.

Activer les API

Configurer Cloud Shell

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

Dans la console Google Cloud, activez Cloud Shell.

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

Attribuez des rôles à votre compte Google. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants : 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:EMAIL_ADDRESS" --role=ROLE

en remplaçant PROJECT_ID par l'ID de votre projet :
Remplacez EMAIL_ADDRESS par votre adresse e-mail.
Remplacez ROLE par chaque rôle individuel.

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 est une allocation de 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, 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 pour 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
Cela permet de mettre à jour un fichier kubeconfig avec les identifiants et les informations de point de terminaison appropriés pour faire pointer kubectl 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 allez créer le compte de service IAM dans le projet Google Cloud dans lequel vous déployez l'exemple d'application. Par conséquent, vos fichiers GSA_PROJECT et Google Cloud PROJECT_ID 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:gsa-helloapp@my-gcp-project.iam.gserviceaccount.com" \
  --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, de sorte 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 gsa-helloapp@my-gcp-project.iam.gserviceaccount.com \
  --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 "Explorateur" de l'éditeur Cloud Shell et 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, 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'interface utilisateur graphique de l'application pour créer ou supprimer des enregistrements de joueurs. Ils sont enregistrés dans la base de données Spanner.

Figure 2. Créez ou supprimez 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 aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez é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.

Supprimez un projet Google Cloud :

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.