Comment déployer du code Terraform dans un pipeline Azure DevOps

Conditions préalables

Pour suivre ce tutoriel pas à pas, vous devez disposer des éléments suivants :

• un compte Azure ;
• une organisation et un projet Azure DevOps ;
• Terraform installé et une connaissance de cet outil à un niveau débutant ou intermédiaire ;
• un compte de stockage dans Azure où vous conserverez les fichiers Terraform ;
• un éditeur de texte.

Le tutoriel utilise Microsoft Visual Studio Code (VS Code) comme éditeur de texte. VS Code n’est pas obligatoire, mais recommandé.

Créer un dépôt dans Azure Repos

Commencez par créer dans Azure Repos un dépôt qui permettra de centraliser et de contrôler la source du code Terraform. Non seulement le dépôt assure un contrôle approprié de la source, mais nous pouvons bâtir le code dans le pipeline Azure DevOps à partir de la source pour ne pas avoir à créer des artefacts de build et un pipeline distinct pour le processus d’intégration continue (CI).

Connectez-vous au portail Azure DevOps, puis choisissez une organisation et un projet dans lequel travailler.

Accédez à Repos > Files pour créer un dépôt destiné au code Terraform.

Cliquez sur le dépôt par défaut et choisissez + New repository. Le dépôt par défaut que vous voyez affiché n’est pas le même que celui de la capture d’écran.

Dans la section Repository name, saisissez TerraformCode. Ce nom n’est pas obligatoire, mais c’est celui que nous allons utiliser tout au long de ce tutoriel. Lorsque vous avez terminé, cliquez sur le bouton Create bleu.

Pour travailler avec le dépôt, clonez-le en local. Cliquez sur le bouton Clone gris et copiez l’URL HTTPS.

Ouvrez un terminal, accédez par la commande cd au poste de travail sur lequel vous pouvez cloner le dépôt et exécutez la commande suivante :

git clone URL_HTTPS

Vous venez de créer et cloner le dépôt. Dans la section suivante du tutoriel, nous allons rédiger le code Terraform à utiliser avec Azure DevOps.

Écrire le code Terraform

Maintenant que vous avez créé et cloné un dépôt Git à partir d’Azure Repos, vous pouvez implémenter du code avec Terraform au lieu de créer des comptes de stockage Azure manuellement. Ce tutoriel s’intéresse à trois fichiers de configuration Terraform : le fichier de configuration principal, celui des variables et celui des variables d’exécution. Les variables servent à garantir que le code sera réutilisable dans n’importe quel environnement.

Créez les fichiers de configuration dans l’éditeur de texte de votre choix. Dans VS Code, faites File > Open et ouvrez le dépôt TerraformCode.

Créez un dossier appelé StorageAccount-Terraform, ou choisissez une convention de dénomination décrivant ce que vous souhaitez faire. Ajoutez trois fichiers de configuration Terraform dans le dossier StorageAccount-Terraform :

• main.tf -- Fichier de configuration principal où résident toutes les ressources à créer dans Azure.
• variables.tf -- Noms et types (chaînes, entiers, etc.) des variables.
• terraform.tfvars -- Variables transmises lors de l’exécution.

Configuration de variables.tf. Un compte de stockage Azure nécessite certaines informations pour que la ressource fonctionne. Commençons par les variables obligatoires.

Ouvrez le fichier de configuration variables.tf et placez-y les variables suivantes, dont Terraform a besoin pour la ressource de création du compte de stockage :

• resourceGroupName -- Groupe de ressources dans lequel le compte de stockage va résider.
• location -- Région d’Azure dans laquelle le compte de stockage va résider.

variable "resourceGroupName" {

    type = string

    description = "Resource group name for the storage account to reside in"

}

variable "location" {

    type = string

    description = "Region that the storage account will reside in"

} 

L’instruction type indique l’attribut des données (chaîne de caractères, entiers, etc.) de la variable, tandis que l’instruction description décrit brièvement la variable en métadonnées.

Comme le montre la capture d’écran, les variables sont maintenant ajoutées au fichier de configuration variables.tf.

Configuration de terraform.tfvars. Une fois les variables définies pour la création d’un compte de stockage Azure, spécifiez les valeurs de ces variables.

Pour spécifier les valeurs que prendront les variables à l’exécution, ouvrez le fichier de configuration terraform.tfvars et écrivez les paires clé-valeur. L’extrait de code ci-dessous contient un exemple de paire clé-valeur dans lequel dev2 désigne le groupe de ressources et eastus, le lieu.

Voici à quoi ressemblent les variables tfvars dans VS Code :

resourceGroupName = "dev2"

location = "eastus"

Configuration de main.tf. Après avoir configuré les variables et leurs valeurs, rédigez la configuration de main.tf. Ouvrez ce fichier pour y ajouter le code nécessaire section par section afin de créer un compte de stockage dans Azure.

La première section couvre le back-end Terraform. Le fichier de configuration tfstate de Terraform stocke les métadonnées qui vont permettre la création, la mise à jour et la modification d’un environnement. S’il n’existe pas de configuration tfstate, Terraform tente de recréer toute la configuration de la ressource au lieu de la mettre à jour.

La première section ressemble donc au contenu ci-dessous :

terraform {

  backend "azurerm" {

    resource_group_name = "dev2"

    storage_account_name = "storemfwmw3heqnyuk"

    container_name = "testcontainer"

    key = "terraform.state"

    }

}

La deuxième section concerne le fournisseur azurerm, qui connecte Terraform à Azure. Un fournisseur Terraform effectue des appels API au fournisseur spécifié, dans ce cas Azure. L’exemple ci-dessous provient de Terraform version 2.0.0.

provider "azurerm" {

  version = "2.0.0"

  features {}

}

La dernière partie de la configuration main.tf consiste à créer la ressource dont le nom dépend du type de ressource que vous créez avec Terraform. Ainsi, la ressource permettant de créer un compte de stockage s’appelle azurerm_storage_account.

Le nom TechTargetSG indiqué ici est une métadonnée servant à identifier la ressource. Choisissez pour cette métadonnée un nom qui ait du sens dans votre organisation.

Les instructions, telles que name et resource_group_name, sont les valeurs qui permettent de créer le compte de stockage. Comme vous le voyez, resource_group_name et location utilisent les variables identifiées au paragraphe précédent sur terraform.tfvars.

resource "azurerm_storage_account" "TechTargetSG" {

Name	= "ttstorage92"
resource_group_name	= var.resourceGroupName
Location	=	var.location
account_tier	=	"Standard"

account_replication_type = "GRS"

tags = {

environment = "development"
}

La capture d’écran montre toute la configuration dans main.tf.

Valider le code Terraform

Après avoir écrit le code Terraform pour le compte de stockage Azure, vous pouvez le valider par un commit dans le dépôt TerraformCode d’Azure Repos. Ouvrez un terminal dans VS Code et exécutez les trois commandes suivantes :

• add . -- Organise un dépôt Git avec les nouvelles modifications ajoutées.
• commit -m -- Crée un message de validation qui est affiché sur le dépôt.
• push -- Envoie le code du dépôt git local à Azure Repos.

git add .

git commit -m "Adding Terraform code to Azure Repos"

git push origin master

La sortie du terminal devrait ressembler à la capture d’écran ci-dessous.

Créer le pipeline de déploiement YAML

Maintenant que le code de configuration Terraform est prêt, créez un pipeline YAML pour le déployer. Le langage YAML est un outil permettant de formater du code. Un pipeline YAML codifie la création de pipelines. Au lieu de passer par une interface utilisateur pour créer des tâches dans un pipeline release, vous créez un pipeline YAML unique pour les opérations build et release.

Ouvrez le portail Azure DevOps et allez dans Pipelines. Cliquez sur le bouton New pipeline bleu.

Dans la section Where is your code?, choisissez Azure Repos Git. Azure Repos est un service dans lequel vous créez le dépôt hébergeant le code Terraform après commit.

Choisissez le Starter pipeline pour pouvoir le personnaliser à votre guise.

Sur la page Review your pipeline YAML, supprimez les lignes 13 à 19, qui ne contiennent que du code factice pour afficher Hello World.

Ajoutez les informations suivantes sous steps. Ces valeurs sont nécessaires pour le pipeline YAML :

• votre abonnement ;
• le nom du groupe de ressources dans lequel le compte de stockage Azure doit résider ;
• le nom du conteneur dans lequel le fichier de configuration tfstate de Terraform doit résider.

Le code du pipeline YAML contient deux termes que les équipes DevOps doivent comprendre :

• task -- L’appel API que Terraform envoie à Azure pour créer les ressources.
• inputs -- Toutes les valeurs qui sont transmises, que ce soit pour l’initialisation ou pour la création. Vous remarquerez le workingDirectory. Il s’agit du répertoire que vous avez créé pour le code Terraform plus haut dans ce tutoriel.

task : Terraform
TaskV1@0 
inputs :
     provider : 'azurerm'

     command: 'init'

     workingDirectory: 'StorageAccount-Terraform'

     backendServiceArm: 'your_subscription'

     backendAzureRmResourceGroupName: 'your_resource_group_name'

     backendAzureRmStorageAccountName: 'your_storage_account_name'

     backendAzureRmContainerName: 'your_container_name'

     backendAzureRmKey: 'tf/terraform.tfstate'

task: Terraform
TaskV1@0 
inputs:
     provider: 'azurerm'

     command: 'apply'

     workingDirectory: 'StorageAccount-Terraform'

     environmentServiceNameAzureRM : 'your_subscription'

La capture d’écran montre ce à quoi devrait ressembler le pipeline YAML.

Exécuter le pipeline

À présent que le pipeline YAML est prêt, exécutez-le pour créer le compte de stockage.

Cliquez sur le bouton Save and run bleu. Dans cet écran, conservez les valeurs par défaut pour autoriser la validation directe du code YAML dans la branche principale. Cette configuration implique qu’à chaque validation de code dans la branche principale, le pipeline YAML est automatiquement exécuté. Cliquez sur le bouton Save and run bleu.

L’exécution du pipeline démarre. Cliquez sur le bouton Job pour afficher sa progression.

Une fois terminée, la tâche devrait ressembler à la capture d’écran ci-dessous.

Vous venez de créer un déploiement Terraform d’Infrastructure as Code avec Azure DevOps. Continuez à apprendre et à essayer de nouvelles techniques. Votre prochain défi sera de faire la même chose, mais en utilisant GitHub au lieu d’Azure Repos.