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

Parcours de formation : Applications évolutives – Créer un cluster

Autopilot

Cet ensemble de tutoriels est destiné aux administrateurs et aux opérateurs informatiques qui souhaitent déployer, exécuter et gérer des environnements d'applications modernes exécutés sur Google Kubernetes Engine (GKE). Au fur et à mesure que vous progresserez dans cette série de tutoriels, vous allez apprendre à configurer la surveillance et les alertes, à effectuer le scaling des charges de travail et à simuler des défaillances, le tout en utilisant l'exemple d'application de microservices Cymbal Bank :

Créer un cluster et déployer un exemple d'application (ce tutoriel)
Surveiller avec Google Cloud Managed Service pour Prometheus
Effectuer le scaling des charges de travail
Simuler une défaillance

Présentation et objectifs

Cymbal Bank utilise Python et Java pour exécuter les différents services et inclut un backend PostgreSQL. Vous n'avez pas besoin d'expérience avec ces langages ou cette plate-forme de base de données pour suivre la série de tutoriels, car Cymbal Bank n'est qu'un exemple d'application pour montrer comment GKE peut répondre aux besoins de votre entreprise.

Dans ce tutoriel, vous allez apprendre à créer un seul cluster GKE et à déployer un exemple d'application basée sur des microservices, nommée Cymbal Bank, sur un cluster GKE. Vous allez apprendre à effectuer les tâches suivantes :

Créer un cluster GKE qui utilise Autopilot.
Déployer un exemple d'application basée sur des microservices nommé Cymbal Bank.
Utiliser la console Google Cloud pour explorer les ressources GKE utilisées par l'exemple d'application Cymbal Bank.

Coûts

L'activation de GKE et le déploiement de l'exemple d'application Cymbal Bank pour cette série de tutoriels entraînent des frais par cluster pour GKE sur Google Cloud, comme indiqué sur notre Page des tarifs, jusqu'à ce que vous désactiviez GKE ou que vous supprimiez le projet.

Vous êtes également responsable des autres coûts Google Cloud engendrés par l'exécution de l'exemple d'application Cymbal Bank, tels que les frais pour les VM et les équilibreurs de charge Compute Engine.

Avant de commencer

Dans ce premier tutoriel de la série, avant de commencer, suivez toutes les étapes de configuration de la section "Avant de commencer". Vous n'avez besoin de suivre les étapes "Avant de commencer" suivantes qu'une seule fois.

Configurer votre shell et vos outils

Dans cette série de tutoriels, vous allez utiliser les outils suivants pour déployer et gérer votre environnement :

gcloud CLI : permet de créer et de gérer des clusters et des parcs GKE, ainsi que d'autres services Google Cloud.
kubectl : gérez Kubernetes, le système d'orchestration de clusters utilisé par GKE.

Pour exécuter les commandes sur cette page, configurez la Google Cloud CLI et kubectl dans l'un des environnements de développement suivants :

Cloud Shell

Pour utiliser un terminal en ligne avec la gcloud CLI et kubectl déjà configurés, activez Cloud Shell :

En bas de la page, une session Cloud Shell démarre et affiche une invite de ligne de commande. L'initialisation de la session peut prendre quelques secondes.

Interface système locale

Pour utiliser un environnement de développement local, procédez comme suit :

Installez la gcloud CLI.
Initialisez la gcloud CLI.
Installez kubectl la gcloud CLI :
```
gcloud components install kubectl
```

Configurer votre projet

Suivez les étapes ci-dessous pour configurer un projet Google Cloud, y compris l'activation de la facturation et des services GKE. Il s'agit du projet dans lequel vous allez activer GKE.

Vous aurez peut-être besoin qu'un administrateur Google Cloud de votre organisation vous accorde l'accès pour créer ou utiliser un projet et activer les API.

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

Accéder à la page Google Kubernetes Engine
Créer ou sélectionner un projet Il s'agit du projet dans lequel vous activez GKE.
Si vous y êtes invité, activez l'API GKE.
Patientez le temps de l'activation de l'API et des services associés. Cette opération peut prendre plusieurs minutes.
Make sure that billing is enabled for your Google Cloud project.

Accorder des rôles IAM

Si vous êtes le propriétaire du projet (par exemple, si vous l'avez créé vous-même), vous disposez déjà de toutes les autorisations nécessaires pour suivre ces tutoriels. Si vous n'êtes pas le propriétaire, assurez-vous que votre compte Google Cloud dispose des rôles IAM requis pour le projet sélectionné pour cet ensemble de tutoriels. Là encore, vous aurez peut-être besoin d'un administrateur Google Cloud de votre organisation pour vous aider à attribuer les rôles requis.

Dans les commandes suivantes, remplacez PROJECT_ID par l'ID généré automatiquement du projet que vous avez créé ou sélectionné dans la section précédente. L'ID du projet est souvent différent du nom du projet. Par exemple, votre projet peut être scalable-apps, mais votre ID de projet peut être scalable-apps-567123.

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/resourcemanager.projectIamAdmin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/serviceusage.serviceUsageAdmin, roles/container.admin, roles/logging.logWriter, roles/gkehub.admin, roles/viewer, roles/monitoring.viewer

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:myemail@example.com.
Replace ROLE with each individual role.

Cloner l'exemple d'application

Clonez le dépôt Git qui inclut tous les exemples de fichiers manifestes pour Cymbal Bank :

  git clone https://github.com/GoogleCloudPlatform/bank-of-anthos
  cd bank-of-anthos/

Créer un cluster

Une fois toutes les étapes préalables des sections précédentes terminées, vous pouvez commencer à créer un cluster GKE et à déployer un exemple d'application.

GKE est un service Kubernetes géré que vous pouvez utiliser pour déployer et exploiter des applications conteneurisées. Un environnement GKE est constitué de nœuds, qui sont des machines virtuelles (VM) Compute Engine, regroupées pour former un cluster.

Créez un cluster GKE que vous utiliserez dans les autres tutoriels de cette série :
```
gcloud container clusters create-auto scalable-apps \
  --project=PROJECT_ID \
  --region=REGION
```
Remplacez les éléments suivants :
- PROJECT_ID par l'ID généré automatiquement pour le projet que vous avez créé dans la section précédente. L'ID du projet est souvent différent du nom du projet. Par exemple, votre projet peut être scalable-apps, mais votre ID de projet peut être scalable-apps-567123.
- REGION par la région dans laquelle vous souhaitez créer votre cluster, par exemple us-central1.
Quelques minutes sont nécessaires pour créer le cluster et vérifier que tout fonctionne correctement.

Dans cet ensemble de tutoriels, vous allez utiliser des clusters en mode Autopilot et certaines plages d'adresses IP par défaut lorsque vous créez des clusters. Un déploiement en production de vos propres applications nécessite une planification plus minutieuse des adresses IP. En mode Autopilot, Google gère la configuration de votre cluster, y compris l'autoscaling, la sécurité et d'autres paramètres préconfigurés. Les clusters en mode Autopilot sont optimisés pour exécuter la plupart des charges de travail de production et provisionner des ressources de calcul en fonction de vos fichiers manifestes Kubernetes.

Déployer Cymbal Bank

Vous empaquetez les applications (également appelées charges de travail) dans des conteneurs. Vous déployez des ensembles de conteneurs en tant que pods sur vos nœuds.

Dans cette série de tutoriels, vous allez déployer un exemple d'application basée sur des microservices nommé Cymbal Bank sur un ou plusieurs clusters GKE. Cymbal Bank utilise Python et Java pour exécuter les différents services et inclut un backend PostgreSQL. Vous n'avez pas besoin d'expérience avec ces langages ou cette plate-forme de base de données pour suivre la série de tutoriels. Cymbal Bank n'est qu'un exemple d'application pour montrer comment GKE peut répondre aux besoins de votre entreprise.

Lorsque vous utilisez Cymbal Bank dans le cadre de cet ensemble de tutoriels, les services suivants sont déployés dans votre cluster GKE :

Service	Langage	Description
`frontend`	Python	Expose un serveur HTTP pour diffuser le site Web. Contient la page de connexion, la page d'inscription et la page d'accueil.
`ledger-writer`	Java	Accepte et valide les transactions entrantes avant de les écrire dans le registre.
`balance-reader`	Java	Fournit un cache lisible et efficace du solde utilisateur, tel que lu à partir de `ledger-db`.
`transaction-history`	Java	Fournit un cache lisible et efficace des transactions passées, telles que lues à partir de `ledger-db`.
`ledger-db`	PostgreSQL	Registre de toutes les transactions. Option permettant de préremplir avec des transactions pour les utilisateurs de démonstration.
`user-service`	Python	Gère les comptes utilisateur et l'authentification. Il signe les jetons JWT utilisés pour l'authentification par d'autres services.
`contacts`	Python	Stocke la liste des autres comptes associés à un utilisateur. Utilisé dans les formulaires "Envoyer un paiement" et "Dépôt".
`accounts-db`	PostgreSQL	Base de données pour les comptes utilisateur et les données associées. Option permettant de préremplir les données avec les utilisateurs de démonstration.
`loadgenerator`	Python/Locust	Envoie en continu des requêtes imitant des utilisateurs à l'interface. Crée régulièrement de nouveaux comptes et simule des transactions entre eux.

Pour déployer Cymbal Bank dans votre cluster GKE, procédez comme suit :

Cymbal Bank utilise des jetons Web JSON (JWT) pour gérer l'authentification des utilisateurs. Les jetons JWT utilisent des paires de clés asymétriques pour signer et valider les jetons. Dans Cymbal Bank, userservice crée et signe des jetons avec une clé privée RSA lorsqu'un utilisateur se connecte, et les autres services utilisent la clé publique correspondante pour valider l'utilisateur.

Créez un jeton JWT RS256 d'une force de 4 096 bits :
```
openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
```
Si nécessaire, téléchargez et installez les outils OpenSSL pour votre plate-forme.
Un secret Kubernetes peut stocker des données sensibles telles que des clés ou des mots de passe. Les charges de travail exécutées dans votre cluster peuvent ensuite accéder au secret pour obtenir les données sensibles au lieu de les coder en dur dans l'application.

Créez un secret Kubernetes à partir du fichier de clé que vous avez créé à l'étape précédente afin que Cymbal Bank l'utilise avec les requêtes d'authentification :
```
kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
```

Déployez Cymbal Bank sur votre cluster. La commande suivante déploie tous les fichiers manifestes dans le répertoire kubernetes-manifests. Chaque fichier manifeste déploie et configure l'un des services :

kubectl apply -f kubernetes-manifests/accounts-db.yaml
kubectl apply -f kubernetes-manifests/balance-reader.yaml
kubectl apply -f kubernetes-manifests/config.yaml
kubectl apply -f kubernetes-manifests/contacts.yaml
kubectl apply -f extras/postgres-hpa/kubernetes-manifests/frontend.yaml
kubectl apply -f kubernetes-manifests/ledger-db.yaml
kubectl apply -f kubernetes-manifests/ledger-writer.yaml
kubectl apply -f extras/postgres-hpa/loadgenerator.yaml
kubectl apply -f kubernetes-manifests/transaction-history.yaml
kubectl apply -f kubernetes-manifests/userservice.yaml

Il est possible que des messages s'affichent dans la sortie kubectl lorsque les fichiers manifestes sont appliqués à votre cluster concernant les limites d'Autopilot. Autopilot utilise les requêtes de ressources que vous spécifiez dans la configuration de votre charge de travail pour configurer les nœuds qui les exécutent. Autopilot applique des requêtes de ressources minimales et maximales en fonction de la classe de calcul ou de la configuration matérielle utilisée par vos charges de travail. Si vous ne spécifiez pas de requêtes pour certains conteneurs, Autopilot attribue des valeurs par défaut pour permettre à ces conteneurs de s'exécuter correctement.

Examinez l'exemple de fichier manifeste suivant pour le service frontend :

# 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
#
#     https://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:
  labels:
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  name: frontend
spec:
  ports:
    - name: http
      port: 80
      targetPort: 8080
  selector:
    app: frontend
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  name: frontend
spec:
  selector:
    matchLabels:
      app: frontend
      application: bank-of-anthos
      environment: development
      team: frontend
      tier: web
  template:
    metadata:
      annotations:
        proxy.istio.io/config: '{ "holdApplicationUntilProxyStarts": true }'
      labels:
        app: frontend
        application: bank-of-anthos
        environment: development
        team: frontend
        tier: web
    spec:
      containers:
        - env:
            - name: VERSION
              value: v0.6.5
            - name: PORT
              value: "8080"
            - name: ENABLE_TRACING
              value: "true"
            - name: SCHEME
              value: http
            - name: LOG_LEVEL
              value: info
            - name: DEFAULT_USERNAME
              valueFrom:
                configMapKeyRef:
                  key: DEMO_LOGIN_USERNAME
                  name: demo-data-config
            - name: DEFAULT_PASSWORD
              valueFrom:
                configMapKeyRef:
                  key: DEMO_LOGIN_PASSWORD
                  name: demo-data-config
            - name: REGISTERED_OAUTH_CLIENT_ID
              valueFrom:
                configMapKeyRef:
                  key: DEMO_OAUTH_CLIENT_ID
                  name: oauth-config
                  optional: true
            - name: ALLOWED_OAUTH_REDIRECT_URI
              valueFrom:
                configMapKeyRef:
                  key: DEMO_OAUTH_REDIRECT_URI
                  name: oauth-config
                  optional: true
          envFrom:
            - configMapRef:
                name: environment-config
            - configMapRef:
                name: service-api-config
          image: us-central1-docker.pkg.dev/bank-of-anthos-ci/bank-of-anthos/frontend:v0.6.5@sha256:d72050f70d12383e4434ad04d189b681dc625f696087ddf0b5df641645c9dafa
          livenessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 60
            periodSeconds: 15
            timeoutSeconds: 30
          name: front
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 5
            timeoutSeconds: 10
          resources:
            limits:
              cpu: 250m
              memory: 128Mi
            requests:
              cpu: 100m
              memory: 64Mi
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop:
                - all
            privileged: false
            readOnlyRootFilesystem: true
          volumeMounts:
            - mountPath: /tmp
              name: tmp
            - mountPath: /tmp/.ssh
              name: publickey
              readOnly: true
      securityContext:
        fsGroup: 1000
        runAsGroup: 1000
        runAsNonRoot: true
        runAsUser: 1000
      serviceAccountName: bank-of-anthos
      terminationGracePeriodSeconds: 5
      volumes:
        - emptyDir: {}
          name: tmp
        - name: publickey
          secret:
            items:
              - key: jwtRS256.key.pub
                path: publickey
            secretName: jwt-key

Ce fichier manifeste pour le service frontend demande 100m du processeur et 64Mi, et définit des limites de 250m du processeur et de 128Mi par pod.

Lorsque vous déployez une charge de travail dans un cluster Autopilot, GKE valide la configuration de la charge de travail par rapport aux valeurs minimales et maximales autorisées pour la classe de calcul sélectionnée ou la configuration matérielle (tels que les GPU). Si les requêtes sont inférieures au minimum, Autopilot modifie automatiquement la configuration de votre charge de travail pour que les requêtes soient comprises dans la plage autorisée. Ces messages indiquent que les limites appropriées sont attribuées automatiquement.

Attendez que les pods soient prêts. Exécutez la commande kubectl pour vérifier l'état des pods :

kubectl get pods

La colonne STATUS passe de Pending à ContainerCreating. Il faut quelques minutes pour que tous les pods soient à l'état Running, comme indiqué dans l'exemple de résultat suivant :

NAME                                  READY   STATUS    RESTARTS   AGE
accounts-db-6f589464bc-6r7b7          1/1     Running   0          99s
balancereader-797bf6d7c5-8xvp6        1/1     Running   0          99s
contacts-769c4fb556-25pg2             1/1     Running   0          98s
frontend-7c96b54f6b-zkdbz             1/1     Running   0          98s
ledger-db-5b78474d4f-p6xcb            1/1     Running   0          98s
ledgerwriter-84bf44b95d-65mqf         1/1     Running   0          97s
loadgenerator-559667b6ff-4zsvb        1/1     Running   0          97s
transactionhistory-5569754896-z94cn   1/1     Running   0          97s
userservice-78dc876bff-pdhtl          1/1     Running   0          96s

Lorsque tous les pods sont à l'état Running, passez à l'étape suivante. De nouveau, il faut quelques minutes pour que tous les pods soient à l'état Running. Il est normal que certains pods indiquent l'état READY de 0/1 jusqu'à ce que Cymbal Bank soit prêt à diffuser correctement le trafic.

Le service frontend expose un serveur HTTP pour diffuser le site Web de Cymbal Bank, y compris la page de connexion, la page d'inscription et la page d'accueil. Un objet Ingress définit les règles de routage du trafic HTTP(S) vers des applications exécutées dans un cluster à l'aide d'un équilibreur de charge HTTP(S) Google Cloud.

Récupérez l'adresse IP externe de l'objet Ingress frontend :
```
kubectl get ingress frontend | awk '{print $4}'
```
Dans une fenêtre de navigateur Web, ouvrez l'adresse IP affichée dans le résultat de la commande kubectl get ingress pour accéder à votre instance de Cymbal Bank.

Les identifiants par défaut sont renseignés automatiquement. Vous pouvez donc vous connecter à l'application et explorer certains exemples de transactions et de soldes. Vous n'avez rien à faire, si ce n'est vérifier que Cymbal Bank s'exécute correctement. La communication correcte de tous les services et la connexion à votre service peuvent prendre une ou deux minutes.

Explorer votre déploiement

Après avoir créé un cluster GKE et déployé des charges de travail, vous devrez peut-être modifier des paramètres ou examiner les performances de votre application. Dans cette section, vous allez apprendre à utiliser la console Google Cloud pour examiner les ressources faisant partie de votre cluster et l'exemple d'application Cymbal Bank.

Clusters

Dans ce tutoriel, vous avez créé un cluster GKE et déployé les charges de travail Cymbal Bank.

Sur la page Google Kubernetes Engine de la console Google Cloud, accédez à la page Clusters.

Accéder à la page "Clusters"
Cliquez sur le cluster scalable-apps qui vient d'être déployé. Sur la page "Détails du cluster" qui s'affiche, vous pouvez afficher les détails de base du cluster, ainsi que ses configurations réseau et de sécurité. Vous pouvez également voir quelles fonctionnalités GKE sont activées dans ce cluster dans la section Fonctionnalités.

Observabilité

Vous pouvez afficher des métriques de base sur l'état et les performances de votre cluster. Dans le tutoriel suivant de cette série, vous activerez Google Cloud Managed Service pour Prometheus pour une surveillance et une observabilité plus précises.

Sélectionnez votre cluster sur la page Clusters Google Kubernetes Engine de la console Google Cloud, puis accédez à l'onglet Observabilité.
Examinez certains graphiques de métriques pour des éléments tels que le processeur et la mémoire. Cette vue vous permet de surveiller les performances des différentes parties des charges de travail de votre cluster sans avoir à déployer de fonctionnalités de surveillance supplémentaires.
Pour afficher les journaux diffusés depuis votre cluster, sélectionnez l'onglet Journaux. Vous pouvez filtrer les journaux par Gravité, ou créer vos propres filtres pour afficher des espaces de noms, des services ou des pods spécifiques. Comme pour les avertissements et les événements de pod, cette vue classée des journaux de votre cluster peut vous aider à résoudre rapidement des problèmes à l'aide de la console Google Cloud.

Il est normal de voir les entrées de journal, car Cymbal Bank est déployé pour la première fois lorsque certains services ne peuvent pas encore communiquer.
Sélectionnez l'onglet Erreurs de l'application. À mesure que vos charges de travail s'exécutent, vous pouvez afficher les avertissements et les événements classés dans la console Google Cloud. Cette approche permet de déboguer des problèmes sans avoir à vous connecter individuellement au cluster, aux nœuds ou aux pods.

Encore une fois, il est normal que les événements soient enregistrés lorsque Cymbal Bank est déployé pour la première fois lorsque certains services ne peuvent pas encore communiquer.

Charges de travail

La page GKE de la console Google Cloud comporte une section Charges de travail qui affiche une vue agrégée des charges de travail exécutées sur tous vos clusters GKE.

Sur la page Google Kubernetes Engine de la console Google Cloud, accédez à la page Charges de travail.

Accéder à la page "Charges de travail"

L'onglet Présentation affiche la liste des charges de travail et des espaces de noms du cluster GKE. Vous pouvez filtrer par espace de noms pour afficher les charges de travail qui s'exécutent dans chaque espace de noms.

Services & Ingress

La vue Services et entrées affiche les ressources "Service" et "Entrée" du projet. Un Service expose un ensemble de pods en tant que service réseau avec un point de terminaison, tandis qu'un Ingress gère l'accès externe aux services dans un cluster.

Sur la page Google Kubernetes Engine de la console Google Cloud, accédez à la page Passerelles, services et Ingress.

Accéder à la page "Passerelles, Services et Ingress"
Pour trouver l'entrée Cymbal Bank, cliquez sur l'onglet Ingress et recherchez l'entrée nommée frontend. Une entrée gère le trafic entrant pour votre application. Vous pouvez afficher des informations sur l'équilibreur de charge, les ports et les points de terminaison externes.
Cliquez sur l'adresse IP pour l'entrée frontend, par exemple 198.51.100.143:80. Cette adresse s'ouvre dans l'interface Web de Cymbal Bank.

Effectuer un nettoyage

L'ensemble de tutoriels pour Cymbal Bank est conçu pour être suivi les uns après les autres. Au fil de votre progression dans les tutoriels, vous apprendrez de nouvelles compétences et utilisez d'autres produits et services Google Cloud.

Si vous souhaitez faire une pause avant de passer au tutoriel suivant et éviter que des frais ne soient facturés sur votre compte Google Cloud pour les ressources utilisées dans ce tutoriel, supprimez le projet que vous avez créé.

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.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Étape suivante

Découvrez comment surveiller vos charges de travail dans GKE à l'aide de Google Cloud Managed Service for Prometheus et de Cloud Monitoring dans le tutoriel suivant.