GSP233

Présentation

Dans Terraform, un fournisseur désigne l'abstraction logique d'une API en amont. Dans cet atelier, vous allez découvrir comment configurer un cluster Kubernetes et y déployer un service NGINX de type équilibreur de charge.

Objectifs

Dans cet atelier, vous allez apprendre à :

• déployer un cluster Kubernetes ainsi qu'un service à l'aide de Terraform.

Prérequis

Cet atelier suppose :

• une bonne connaissance des services Kubernetes ;
• une bonne connaissance de la CLI kubectl.

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google. L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue Se connecter. Cliquez sur Suivant.

4. Copiez le mot de passe inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue de bienvenue. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis dans le panneau de gauche. Ne saisissez pas vos identifiants Google Cloud Skills Boost. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

5. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas aux essais offerts.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Vous pouvez afficher le menu qui contient la liste des produits et services Google Cloud en cliquant sur le menu de navigation en haut à gauche.

Activer Cloud Shell

Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Le résultat contient une ligne qui déclare YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

2. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

3. Cliquez sur Autoriser.

4. Vous devez à présent obtenir le résultat suivant :

Résultat :

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = <ID_Projet>

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Services Kubernetes

Un service est un groupe de pods qui s'exécutent sur le cluster. Du fait de leur faible coût, les services peuvent être déployés en grande quantité dans le cluster. Les services Kubernetes contribuent sensiblement à la puissance d'une architecture de microservices.

Les services offrent d'importantes fonctionnalités qui sont uniformisées dans l'ensemble du cluster, comme l'équilibrage de charge, la détection de services entre applications et la gestion des déploiements d'applications sans aucun temps d'arrêt.

Chaque service comporte une requête d'étiquette de pod définissant les pods qui traiteront les données pour le service. Cette requête d'étiquette met fréquemment en correspondance les pods créés par un ou plusieurs contrôleurs de réplication. Vous pouvez mettre en œuvre des scénarios de routage élaborés en mettant à jour la requête d'étiquette d'un service via l'API Kubernetes avec un logiciel de déploiement.

Pourquoi utiliser Terraform ?

Bien que vous puissiez gérer l'ensemble des ressources Kubernetes décrites dans les fichiers YAML à l'aide de kubectl ou d'autres outils d'interface de ligne de commande mappés à des appels d'API, l'orchestration avec Terraform présente plusieurs avantages :

• Un seul langage : vous pouvez utiliser le même langage de configuration pour provisionner l'infrastructure Kubernetes et y déployer des applications.
• Détection des dérives : la commande terraform plan vous indique toujours la différence entre la configuration active à un moment précis et celle que vous prévoyez d'appliquer.
• Gestion de l'ensemble du cycle de vie : Terraform ne se limite pas à créer les ressources initiales. Il vous permet de créer, de mettre à jour et de supprimer les ressources suivies à l'aide d'une seule commande, sans avoir à inspecter l'API pour les identifier.
• Retour synchrone : bien qu'un comportement asynchrone soit souvent utile, il se révèle parfois contre-productif, car c'est à l'utilisateur d'identifier le résultat d'une opération (échecs ou détails de la ressource créée). Par exemple, vous ne disposez pas de l'adresse IP/du nom d'hôte de l'équilibreur de charge avant la fin de son provisionnement. Vous ne pouvez donc créer aucun enregistrement DNS pointant vers lui.
• Graphique des relations : Terraform comprend les relations entre les ressources, ce qui peut faciliter la planification. Par exemple, Terraform n'essaie pas de créer un service dans un cluster Kubernetes tant que ce cluster n'existe pas.

Tâche 1 : Cloner l'exemple de code

1. Dans Cloud Shell, commencez par cloner l'exemple de code :

gsutil -m cp -r gs://spls/gsp233/* .

2. Accédez au répertoire tf-gke-k8s-service-lb :

cd tf-gke-k8s-service-lb

Tâche 2 : Comprendre le code

1. Examinez le contenu du fichier main.tf :

cat main.tf

Exemple de résultat :

... variable "region" { type = string description = "Region for the resource." } variable "location" { type = string description = "Location represents region/zone for the resource." } variable "network_name" { default = "tf-gke-k8s" } provider "google" { region = var.region } resource "google_compute_network" "default" { name = var.network_name auto_create_subnetworks = false } resource "google_compute_subnetwork" "default" { name = var.network_name ip_cidr_range = "10.127.0.0/20" network = google_compute_network.default.self_link region = var.region private_ip_google_access = true } ...

• Ce fichier définit des variables pour les éléments region, zone et network_name. Ces variables serviront à créer le cluster Kubernetes.
• Nous créerons des ressources dans ce projet à l'aide du fournisseur Google Cloud.
• Plusieurs ressources sont définies pour la création du réseau et du cluster appropriés.
• À la fin, vous pouvez voir certains des résultats que vous obtiendrez après avoir exécuté la commande terraform apply.

2. Examinez le contenu du fichier k8s.tf :

cat k8s.tf

Exemple de résultat :

provider "kubernetes" { version = "~> 1.10.0" host = google_container_cluster.default.endpoint token = data.google_client_config.current.access_token client_certificate = base64decode( google_container_cluster.default.master_auth[0].client_certificate, ) client_key = base64decode(google_container_cluster.default.master_auth[0].client_key) cluster_ca_certificate = base64decode( google_container_cluster.default.master_auth[0].cluster_ca_certificate, ) } resource "kubernetes_namespace" "staging" { metadata { name = "staging" } } resource "google_compute_address" "default" { name = var.network_name region = var.region } resource "kubernetes_service" "nginx" { metadata { namespace = kubernetes_namespace.staging.metadata[0].name name = "nginx" } spec { selector = { run = "nginx" } session_affinity = "ClientIP" port { protocol = "TCP" port = 80 target_port = 80 } type = "LoadBalancer" load_balancer_ip = google_compute_address.default.address } } resource "kubernetes_replication_controller" "nginx" { metadata { name = "nginx" namespace = kubernetes_namespace.staging.metadata[0].name labels = { run = "nginx" } } spec { selector = { run = "nginx" } template { container { image = "nginx:latest" name = "nginx" resources { limits { cpu = "0.5" memory = "512Mi" } requests { cpu = "250m" memory = "50Mi" } } } } } } output "load-balancer-ip" { value = google_compute_address.default.address }

• Ce script configure un fournisseur Kubernetes avec Terraform, puis crée un service, un espace de noms et une ressource de contrôleur de réplication.
• Il renvoie l'adresse IP du service nginx comme résultat.

Tâche 3 : Initialiser et installer les dépendances

La commande terraform init permet d'initialiser un répertoire de travail contenant les fichiers de configuration Terraform.

Cette commande exécute plusieurs étapes d'initialisation en vue de préparer le répertoire de travail à utiliser. Vous pouvez l'exécuter à plusieurs reprises pour actualiser ce répertoire en fonction des modifications apportées à la configuration :

1. Exécutez terraform init :

terraform init

Exemple de résultat :

... * provider.google: version = "~> 3.8.0" * provider.kubernetes: version = "~> 1.10.0" Terraform has been successfully initialized! You may now begin working with Terraform. Try running `terraform plan` to see any changes that are required for your infrastructure. All Terraform commands should now work. If you ever set or change modules or backend configuration for Terraform, rerun this command to reinitialize your working directory. If you forget, other commands will detect it and remind you to do so if necessary.

2. Exécutez la commande terraform apply pour appliquer les modifications nécessaires pour obtenir l'état de configuration souhaité :

terraform apply -var="region={{{ project_0.default_region | "Region to be allocated" }}}" -var="location={{{ project_0.default_zone | "Zone to be allocated" }}}"

3. Passez en revue les actions que Terraform exécutera et inspectez les ressources qui seront créées.

4. Lorsque vous êtes prêt, saisissez yes pour lancer les actions de Terraform.

Une fois les actions terminées, le résultat doit ressembler à ceci :

Exemple de résultat :

Apply complete! Resources: 7 added, 0 changed, 0 destroyed. Outputs: cluster_name = tf-gke-k8s cluster_region = "{{{project_0.default_region|REGION}}}" cluster_zone = "{{{project_0.default_region|ZONE}}}" load-balancer-ip = 35.233.177.223 network = https://www.googleapis.com/compute/beta/projects/qwiklabs-gcp-5438ad3a5e852e4a/global/networks/tf-gke-k8s subnetwork_name = tf-gke-k8s

Vérifier les ressources créées par Terraform

1. Dans la console, accédez au menu de navigation > Kubernetes Engine.
2. Cliquez sur le cluster tf-gke-k8s et vérifiez sa configuration.
3. Dans le panneau de gauche, cliquez sur Services et entrées et vérifiez l'état du service nginx.
4. Cliquez sur l'adresse IP sous Points de terminaison pour ouvrir la page Welcome to nginx! (Bienvenue dans nginx) dans un nouvel onglet du navigateur.

Cliquez sur Vérifier ma progression pour vérifier la tâche exécutée. Si vous avez réussi à déployer l'infrastructure avec Terraform, vous recevez une note d'évaluation.

Déployer l'infrastructure avec Terraform

Félicitations !

Dans cet atelier, vous avez utilisé Terraform pour initialiser, planifier et déployer un cluster Kubernetes ainsi qu'un service.

Terminer votre quête

Cet atelier d'auto-formation fait partie des quêtes Managing Cloud Infrastructure with Terraform et DevOps Essentials. Une quête est une série d'ateliers associés qui constituent un parcours de formation. Si vous terminez une quête, vous obtenez un badge attestant de votre réussite. Vous pouvez rendre publics les badges que vous recevez et ajouter leur lien dans votre CV en ligne ou sur vos comptes de réseaux sociaux. Inscrivez-vous à n'importe quelle quête contenant cet atelier pour obtenir immédiatement les crédits associés. Découvrez toutes les quêtes disponibles dans le catalogue Google Cloud Skills Boost.

Atelier suivant

Continuez sur votre lancée en suivant l'atelier Équilibreur de charge HTTPS basé sur le contenu avec Terraform, ou consultez nos suggestions de ressources :

• Équilibrage de charge modulaire avec Terraform – Équilibreur de charge régional

Étapes suivantes et informations supplémentaires

Découvrez les conseils d'autres utilisateurs dans la communauté Terraform.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 28 septembre 2023

Dernier test de l'atelier : 28 septembre 2023

Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.