Points de contrôle
Provision infrastructure
/ 50
Upload files to the bucket
/ 50
Interagir avec les modules Terraform
Nous avons développé cet atelier avec notre partenaire HashiCorp. Vos informations personnelles pourront être partagées avec HashiCorp, le sponsor de nos ateliers, si vous avez accepté de recevoir des actualités sur les produits, des annonces et des offres sur la page de profil de votre compte.
GSP751
Présentation
Gérer une infrastructure avec Terraform implique la création de configurations de plus en plus complexes. La complexité d'un répertoire ou d'un fichier de configuration Terraform n'a pas de limite intrinsèque. Vous pouvez donc continuer à écrire et à mettre à jour des fichiers de configuration dans un seul répertoire. Cependant, si vous procédez ainsi, un ou plusieurs des problèmes suivants pourront se poser :
- Vous aurez de plus en plus de difficultés à comprendre et à parcourir les fichiers de configuration.
- La mise à jour de la configuration deviendra plus risquée, puisque la mise à jour d'un bloc pourrait avoir des conséquences inattendues sur les autres blocs de la configuration.
- La duplication de blocs de configuration similaires peut augmenter, par exemple, lorsque vous configurez des environnements de développement/préproduction/production séparés. La mise à jour de ces parties de la configuration représentera donc une charge de travail de plus en plus lourde.
- Si vous souhaitez partager des parties de la configuration avec d'autres projets ou équipes, vous risquez de faire des erreurs en coupant et collant des blocs de configuration d'un projet dans un autre. Cette manipulation est par ailleurs difficile à gérer.
Dans cet atelier, vous allez voir comment les modules permettent de faire face à ces problèmes. Vous découvrirez également la structure d'un module Terraform, ainsi que les bonnes pratiques à adopter lorsque vous utilisez et créez des modules.
À quoi servent les modules ?
Les modules peuvent vous aider à résoudre les problèmes listés ci-dessus de différentes façons :
-
Organiser la configuration : les modules permettent de parcourir, comprendre et mettre à jour plus facilement la configuration, en regroupant des parties connexes de celle-ci. Même pour implémenter une infrastructure moyennement complexe, il peut falloir des centaines ou des milliers de lignes de configuration. Grâce aux modules, vous pouvez organiser la configuration en composants logiques.
-
Encapsuler la configuration : un autre avantage de l'utilisation de modules est que ceux-ci permettent d'encapsuler la configuration en composants logiques distincts. L'encapsulation permet d'éviter des conséquences inattendues (par exemple, modifier accidentellement d'autres infrastructures en modifiant une partie de la configuration) et réduit le risque de commettre des erreurs simples comme utiliser le même nom pour deux ressources différentes.
-
Réutiliser la configuration : écrire toute la configuration sans utiliser de code existant peut être chronophage et source d'erreurs. Lorsque vous vous servez de modules, vous gagnez du temps et réduisez le nombre d'erreurs coûteuses, car vous réutilisez une configuration écrite par vous-même, par des membres de votre équipe ou par d'autres utilisateurs de Terraform qui ont publié des modules que vous pouvez utiliser. Vous avez également la possibilité de partager avec votre équipe ou avec le grand public des modules que vous avez rédigés et de les faire bénéficier du fruit de votre travail.
-
Assurer la cohérence et garantir de bonnes pratiques : les modules permettent également d'assurer la cohérence dans vos configurations. De cette façon, non seulement les configurations complexes sont plus faciles à comprendre, mais vous êtes aussi en mesure d'appliquer les bonnes pratiques dans toute la configuration. Par exemple, les fournisseurs cloud proposent de nombreuses options pour configurer des services de stockage d'objets, comme Amazon S3 (Simple Storage Service) ou les buckets Cloud Storage de Google. De nombreux incidents de sécurité médiatisés impliquaient un stockage d'objets mal sécurisé. En raison du nombre d'options de configuration complexes disponibles, il est facile de se tromper et de mal configurer ces services.
L'utilisation de modules peut contribuer à réduire ces erreurs. Par exemple, vous pouvez en créer un pour décrire la configuration de tous les buckets du site Web public de votre organisation et un autre pour les buckets privés que les applications de journalisation utilisent. Par ailleurs, vous pouvez également vous servir d'un module si vous avez besoin de mettre à jour la configuration d'un type de ressource à un seul endroit et appliquer cette mise à jour partout où vous utilisez le module concerné.
Objectifs
Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :
- Utiliser un module du registre
- Créer un module
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) ;
- vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.
Démarrer l'atelier et se connecter à la console Google Cloud
-
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 Cloud
- Le temps restant
- Les identifiants temporaires que vous devez utiliser pour cet atelier
- Des informations complémentaires vous permettant d'effectuer l'atelier
-
Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).
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. -
Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.
{{{user_0.username | "Username"}}} Vous trouverez également le nom d'utilisateur dans le panneau Détails concernant l'atelier.
-
Cliquez sur Suivant.
-
Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.
{{{user_0.password | "Password"}}} Vous trouverez également le mot de passe dans le panneau Détails concernant l'atelier.
-
Cliquez sur Suivant.
Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés. -
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 à des essais gratuits.
Après quelques instants, la console Cloud s'ouvre dans cet onglet.
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.
- 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 :
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.
- (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :
-
Cliquez sur Autoriser.
-
Vous devez à présent obtenir le résultat suivant :
Résultat :
- (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :
Résultat :
Exemple de résultat :
gcloud
, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.
Qu'est-ce qu'un module Terraform ?
Un module Terraform est un ensemble de fichiers de configuration Terraform situés dans un seul répertoire. Même une configuration simple composée d'un répertoire unique contenant un ou plusieurs fichiers .tf
est un module. Lorsque vous exécutez des commandes Terraform directement à partir d'un tel répertoire, il est considéré comme le module racine. En ce sens, chaque configuration Terraform fait donc partie d'un module. Vous pouvez avoir un ensemble de fichiers de configuration Terraform très simple, comme celui-ci :
Dans ce cas, lorsque vous exécutez des commandes Terraform à partir du répertoire minimal-module
, son contenu est considéré comme le module racine.
Appeler des modules
Les commandes Terraform n'utilisent directement les fichiers de configuration que d'un seul répertoire, qui est généralement le répertoire de travail actuel. Cependant, votre configuration peut se servir de blocs "module" pour appeler des modules qui se trouvent dans d'autres répertoires. Lorsque Terraform rencontre un bloc "module", il charge et traite les fichiers de configuration de ce module.
Un module appelé par une autre configuration est parfois désigné comme étant le "module enfant" de cette configuration.
Modules locaux et distants
Les modules peuvent être chargés soit depuis le système de fichiers local, soit depuis une source distante. Terraform est compatible avec plusieurs sources distantes, telles que le registre Terraform, la plupart des systèmes de contrôle des versions, les URL HTTP, ainsi que les registres de modules privés Terraform Cloud ou Terraform Enterprise.
Bonnes pratiques concernant les modules
Par bien des aspects, les modules Terraform sont semblables aux concepts de bibliothèques, de packages ou de modules que l'on trouve dans la plupart des langages de programmation. De plus, ils présentent un grand nombre de leurs avantages. Comme presque tout programme informatique important, les configurations Terraform en conditions réelles devraient presque toujours utiliser des modules afin d'apporter les avantages mentionnés précédemment.
Nous recommandons à tous les utilisateurs de Terraform de se servir des modules en respectant ces bonnes pratiques :
-
Écrivez votre configuration en pensant aux modules. Même pour les configurations Terraform légèrement complexes gérées par une seule personne, les avantages des modules l'emportent sur le temps nécessaire pour apprendre à les utiliser correctement.
-
Servez-vous de modules locaux pour organiser et encapsuler le code. Même si vous n'utilisez pas ni ne publiez de modules distants, organiser votre configuration en modules dès le départ facilitera considérablement les tâches de gestion et de mise à jour de la configuration à mesure que votre infrastructure deviendra plus complexe.
-
Utilisez le registre Terraform public pour trouver des modules utiles. Ainsi, vous pouvez implémenter votre configuration rapidement et en toute confiance en bénéficiant du travail d'autres utilisateurs.
-
Publiez vos modules et partagez-les avec votre équipe. La plupart des infrastructures sont gérées par une équipe. Les modules peuvent être un atout important pour les équipes chargées de créer et de gérer une infrastructure. Comme nous l'avons évoqué précédemment, vous pouvez publier des modules en mode public ou privé. Vous découvrirez comment procéder dans un prochain atelier de cette série.
Tâche 1. Utiliser des modules du registre
Dans cette section, vous allez utiliser des modules du registre Terraform pour provisionner un exemple d'environnement dans Google Cloud. Les concepts que vous utiliserez ici s'appliqueront à tous les modules de n'importe quelle source.
- Ouvrez la page du registre Terraform consacrée au module Terraform "network" dans un nouvel onglet ou une nouvelle fenêtre. La page se présente comme suit :
Cette page comporte des informations sur le module, ainsi qu'un lien vers le dépôt source. À droite de la page, vous trouverez un menu déroulant permettant de sélectionner la version du module et les instructions pour provisionner l'infrastructure à l'aide du module.
Lorsque vous appelez un module, vous devez indiquer l'argument source
. Dans cet exemple, Terraform va rechercher un module dans le registre Terraform correspondant à la chaîne en question. Vous pourriez aussi utiliser une URL ou un chemin d'accès à un fichier local pour spécifier la source de vos modules. Consultez la documentation Terraform pour connaître la liste des sources de modules possibles.
L'autre argument qui apparaît ici est la version
. Pour les sources compatibles, vous pouvez définir la ou les versions du module qui seront chargées grâce à l'argument version. Dans cet atelier, vous allez spécifier un numéro de version précis pour les modules que vous utiliserez. Pour découvrir d'autres façons de préciser les versions, consultez la documentation sur les modules.
Les autres arguments des blocs "module" sont traités comme des variables d'entrée des modules.
Créer une configuration Terraform
- Pour commencer, exécutez les commandes suivantes dans Cloud Shell pour cloner l'exemple de projet simple qui se trouve dans le dépôt GitHub contenant les modules Terraform pour Google et accédez à la branche
v6.0.1
:
Vous êtes ainsi sûr d'utiliser la bonne version.
-
Dans la barre d'outils Cloud Shell, cliquez sur Ouvrir l'éditeur. Pour passer de Cloud Shell à l'éditeur de code et vice versa, cliquez sur Ouvrir l'éditeur ou Ouvrir le terminal selon les besoins, ou cliquez sur Ouvrir dans une nouvelle fenêtre pour laisser l'éditeur ouvert dans un autre onglet.
-
Dans l'éditeur, accédez à
terraform-google-network/examples/simple_project
, puis ouvrez le fichiermain.tf
. Votre configurationmain.tf
doit se présenter comme suit :
Cette configuration comporte un bloc important :
- Le bloc
module "test-vpc-module"
définit un cloud privé virtuel (VPC), qui fournira des services de mise en réseau au reste de l'infrastructure.
Définir les valeurs des variables d'entrée du module
Certaines variables d'entrée sont obligatoires, ce qui signifie que le module ne fournit pas de valeur par défaut. Vous devez indiquer une valeur explicite pour que Terraform s'exécute correctement.
-
Dans le bloc du module
"test-vpc-module"
, vérifiez les variables d'entrée que vous définissez. Chacune de ces variables d'entrée est décrite dans le registre Terraform. Pour ce module, les variables d'entrée requises sont les suivantes :-
network_name
: le nom du réseau créé -
project_id
: l'ID du projet dans lequel le VPC sera créé -
subnets
: la liste des sous-réseaux créés
-
Pour pouvoir utiliser la plupart des modules, vous devez transmettre des variables d'entrée à la configuration des modules. C'est à la configuration qui appelle un module de définir ses valeurs d'entrée, qui sont transmises en tant qu'arguments au bloc "module". À part source
et version
, la plupart des arguments d'un bloc "module" définissent des valeurs de variables.
Sur la page du registre Terraform consacrée au module Google Cloud "network", un onglet "Inputs" (Entrées) contient la description de toutes les variables d'entrée compatibles avec ce module.
Définir les variables d'entrée racines
L'utilisation de variables d'entrée avec les modules est très semblable à l'utilisation de variables dans n'importe quelle configuration Terraform. Une pratique courante consiste à identifier les variables d'entrée du module que vous pourriez vouloir modifier par la suite, puis à créer des variables correspondantes dans le fichier variables.tf
de la configuration avec des valeurs par défaut adaptées. Ces variables peuvent ensuite être transmises au bloc "module" en tant qu'arguments.
- Pour récupérer l'ID du projet, exécutez la commande suivante dans Cloud Shell :
-
Dans l'éditeur, toujours dans le même répertoire, accédez à
variables.tf
. -
Dans la variable
project_id
, indiquez la valeur de sortie de la commande précédente. Vous devez respecter le format ci-dessous et définir la valeurdefault
pour cette variable :
- Dans
variables.tf
, ajoutez la variablenetwork_name
. Vous pouvez utiliserexample-vpc
comme nom ou tout autre nom de votre choix. Vous devez respecter le format ci-dessous et définir la valeurdefault
pour cette variable :
- Dans le fichier
main.tf
, remplacez la valeur du paramètrenetwork_name
parvar.network_name
afin d'utiliser la variable que vous venez de définir.
- Dans le fichier
main.tf
, remplacez la régionus-west1
des sous-réseaux aux lignes 35, 40 et 47 par. Ainsi, les sous-réseaux seront créés dans la région autorisée pour votre projet. Votre module doit ressembler à ce qui suit :
Définir les valeurs de sortie racines
Les modules comportent également des valeurs de sortie, qui sont définies dans le module à l'aide du mot clé output
. Vous pouvez y accéder en vous reportant à module.<MODULE NAME>.<OUTPUT NAME>
. Tout comme les variables d'entrée, les valeurs de sortie du module sont listées dans l'onglet Outputs
du registre Terraform.
Généralement, les valeurs de sortie des modules sont soit transmises à d'autres parties de la configuration, soit définies comme sorties dans le module racine. Nous nous intéresserons aux deux utilisations dans cet atelier.
- Accédez au fichier
outputs.tf
dans le répertoire de votre configuration. Vérifiez que le fichier contient ce code :
Provisionner l'infrastructure
- Dans Cloud Shell, accédez au répertoire
simple_project
:
- Initialisez la configuration Terraform :
- Créez votre VPC :
- Pour appliquer les modifications et continuer, répondez yes à l'invite.
Parfait ! Vous venez d'utiliser votre premier module. Vous devriez obtenir le résultat suivant pour votre configuration :
Comprendre le fonctionnement des modules
Lorsque vous utilisez un module pour la première fois, vous devez exécuter terraform init
ou terraform get
pour l'installer. Quand vous exécutez l'une de ces commandes, Terraform installe le nouveau module dans le répertoire .terraform/modules
du répertoire de travail de la configuration. Pour les modules locaux, Terraform crée un lien symbolique vers le répertoire du module. C'est pourquoi toute modification apportée aux modules locaux s'appliquera immédiatement, sans que vous ayez besoin de réexécuter terraform get
.
Nettoyer votre infrastructure
Vous savez maintenant utiliser des modules du registre Terraform, les configurer à l'aide de variables d'entrée et récupérer leurs valeurs de sortie.
- Détruisez l'infrastructure que vous avez créée :
-
Répondez
yes
à l'invite. Terraform détruira l'infrastructure que vous avez créée. -
Une fois vos ressources détruites, supprimez le dossier
terraform-google-network
.
Cliquez sur Vérifier ma progression pour valider l'objectif.
Tâche 2. Créer un module
Lors de la dernière tâche, vous avez créé un réseau VPC dans Google Cloud à l'aide d'un module du registre Terraform. Bien qu'il soit important de savoir utiliser des modules Terraform existants, être capable d'en créer constitue un avantage pour tout utilisateur de Terraform. Nous vous recommandons de créer chaque configuration Terraform en partant du principe qu'elle pourra servir de module. Ainsi, vous concevrez des configurations flexibles, réutilisables et composables.
Comme vous le savez peut-être déjà, Terraform traite chaque configuration comme un module. Lorsque vous exécutez des commandes terraform
, ou si vous utilisez Terraform Cloud ou Terraform Enterprise pour exécuter Terraform à distance, le répertoire cible contenant la configuration Terraform est considéré comme le module racine.
Dans cette tâche, vous allez créer un module pour gérer des buckets Compute Storage servant à héberger des sites Web statiques.
Structure du module
Terraform traite tout répertoire local référencé dans l'argument source
d'un bloc module
comme un module. Voici une structure de fichiers classique pour un nouveau module :
.tf
ou avoir recours à n'importe quelle autre structure de fichiers qui vous convient.
Chacun de ces fichiers a une fonction précise :
-
LICENSE
contient la licence sous laquelle le module sera distribué. Lorsque vous partagez un module, le fichier LICENSE informe les utilisateurs des conditions de mise à disposition de ce module. Terraform ne se sert pas de ce fichier. -
README.md
contient la documentation au format Markdown expliquant comment se servir du module. Terraform n'utilise pas ce fichier, mais des services comme le registre Terraform et GitHub afficheront son contenu pour que les utilisateurs qui accèdent au registre Terraform ou à la page GitHub de votre module puissent le consulter. -
main.tf
contient l'ensemble de configurations principal du module. Vous pouvez également créer d'autres fichiers de configuration et les organiser de façon logique pour votre projet. -
variables.tf
contient les définitions des variables du module. Lorsque d'autres utilisateurs se serviront de votre module, les variables seront configurées en tant qu'arguments dans le bloc "module". Étant donné que toutes les valeurs Terraform doivent être définies, les variables n'ayant pas de valeur par défaut deviendront des arguments obligatoires. Une variable ayant une valeur par défaut peut également être fournie sous forme d'argument du module, remplaçant ainsi la valeur par défaut. -
outputs.tf
contient les définitions des sorties du module. Ces sorties sont mises à disposition de la configuration qui l'utilise. Elles servent donc souvent à transmettre des informations sur les parties de l'infrastructure définies par le module aux autres parties de la configuration.
Tenez compte de ces fichiers et veillez à ne pas les distribuer avec votre module :
- Les fichiers
terraform.tfstate
etterraform.tfstate.backup
contiennent votre état Terraform et permettent à Terraform de suivre la relation entre votre configuration et l'infrastructure qu'elle provisionne. - Le répertoire
.terraform
inclut les modules et plug-ins utilisés pour provisionner votre infrastructure. Ces fichiers sont propres à une instance individuelle de Terraform lorsque l'infrastructure est provisionnée. Ils ne correspondent pas à la configuration de l'infrastructure qui est définie dans les fichiers.tf
. - Vous n'avez pas besoin de distribuer les fichiers
*.tfvars
avec votre module, sauf si vous l'utilisez aussi comme configuration Terraform autonome, puisque les variables d'entrée du module sont définies via des arguments du bloc "module" de la configuration.
Créer un module
Accédez à votre répertoire d'accueil et créez le module racine en créant un fichier de configuration main.tf
. Ensuite, créez un répertoire nommé modules contenant un autre dossier intitulé gcs-static-website-bucket
. Vous allez travailler avec trois fichiers de configuration Terraform dans le répertoire gcs-static-website-bucket
: website.tf
, variables.tf
et outputs.tf
.
- Créez le répertoire du nouveau module :
- Accédez au répertoire du module et exécutez les commandes suivantes pour créer trois fichiers vides :
- Dans le répertoire
gcs-static-website-bucket
, exécutez la commande suivante pour créer un fichier nomméREADME.md
avec le contenu suivant :
- Créez un autre fichier nommé
LICENSE
et ajoutez-y le contenu suivant :
Voici à quoi doit maintenant ressembler la structure actuelle du répertoire de votre module :
- Ajoutez cette ressource de bucket Cloud Storage au fichier
website.tf
du répertoiremodules/gcs-static-website-bucket
:
Accédez à GitHub pour consulter la documentation du fournisseur.
- Accédez au fichier
variables.tf
du module et ajoutez-y le code suivant :
- Ajoutez une sortie à votre module dans le fichier
outputs.tf
:
Tout comme les variables, les sorties des modules ont la même fonction que dans le module racine, mais elles ne sont pas accessibles de la même façon. Les sorties du module sont accessibles en tant qu'attributs en lecture seule de l'objet du module. Cet objet se trouve dans la configuration qui appelle le module.
- Retournez dans le fichier
main.tf
du répertoire racine et ajoutez une référence au nouveau module :
- Dans votre répertoire racine, créez un fichier
outputs.tf
pour le module racine :
- Ajoutez le code suivant au fichier
outputs.tf
:
- Dans votre répertoire racine, créez un fichier
variables.tf
:
- Ajoutez le code suivant au fichier
variables.tf
. Définissez les valeurs par défaut des variablesproject_id
etname
sur l'ID de votre projet :.
Installer le module local
Chaque fois que vous ajoutez un module à une configuration, Terraform doit d'abord installer le module avant de pouvoir l'utiliser. Les commandes terraform get
et terraform init
permettent d'installer et de mettre à jour des modules. La commande terraform init
permet également d'initialiser les backends et d'installer des plug-ins.
- Installez le module :
- Provisionnez votre bucket :
- Répondez yes à l'invite. Votre bucket et vos autres ressources sont alors provisionnés.
Importer des fichiers dans le bucket
Vous avez maintenant configuré et utilisé votre propre module pour créer un site Web statique. Vous pourriez vouloir accéder à ce site Web statique. Pour l'instant, votre bucket est vide. Il n'y a donc rien à voir sur le site. Pour qu'il affiche des contenus, vous devez importer des objets dans le bucket. Vous pouvez importer le contenu du répertoire www
du dépôt GitHub.
- Téléchargez les exemples de contenus dans votre répertoire d'accueil :
- Copiez les fichiers dans le bucket et remplacez
YOUR-BUCKET-NAME
par le nom de votre bucket de stockage :
- Dans un nouvel onglet de votre navigateur, accédez au site
https://storage.cloud.google.com/YOUR-BUCKET-NAME/index.html
(remplacezYOUR-BUCKET-NAME
par le nom de votre bucket de stockage).
Vous devriez voir une page Web HTML de base indiquant Aucun élément à afficher.
Cliquez sur Vérifier ma progression pour valider l'objectif.
Nettoyer le site Web et l'infrastructure
Pour terminer, vous allez nettoyer votre projet en détruisant l'infrastructure que vous venez de créer.
- Détruisez vos ressources Terraform :
Lorsque vous répondez yes
à l'invite, Terraform détruit toutes les ressources que vous avez créées pendant cet atelier.
Félicitations !
Dans cet atelier, vous avez découvert les bases des modules Terraform et appris à utiliser un module préexistant du registre. Vous avez ensuite créé votre propre module pour concevoir un site Web statique hébergé dans un bucket Cloud Storage. Pour cela, vous avez défini des entrées, des sorties et des variables pour vos fichiers de configuration. Vous avez également appris les bonnes pratiques à suivre pour créer des modules.
Étapes suivantes et informations supplémentaires
Pour continuer à vous entraîner à utiliser Terraform, consultez ces liens :
- HashiCorp sur Google Cloud Marketplace
- HashiCorp Learn
- Communauté Terraform
- Exemples d'utilisation de Terraform avec Google
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 : 26 janvier 2024
Dernier test de l'atelier : 11 décembre 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.