Provisionnement des ressources Azure avec Terraform à l’aide de VS Code Devcontainer Box / Blogs / Perficient

Qu’est-ce que Terraform ?
Terraform est un outil IAC, utilisé pour automatiser diverses tâches d’infrastructure. Le provisionnement de ressources cloud est l’un des principaux cas d’utilisation de Terraform. Il s’agit d’un outil de provisionnement open source écrit en langage Go et créé par HashiCorp.
Terraform vous permet de décrire votre infrastructure complète sous forme de code. Même si vos serveurs proviennent de différents fournisseurs tels qu’AWS ou Azure, terraform vous aide à créer et à gérer ces ressources en parallèle sur plusieurs fournisseurs.
Les avantages de l’infrastructure en tant que code sont la rapidité, la simplicité, la réduction des erreurs et la collaboration en équipe, la reprise après sinistre et une sécurité améliorée.

Nous pouvons déployer des ressources de différentes manières, ici nous pouvons cibler avec VS code Dev Container et le démon Docker.
Étapes à suivre pour configurer VS Code Dev Container avec Docker Engine :
Étape 1: Installer le bureau Docker [from here](https://www.docker.com).
Étape 2: Installer VS Code [from here](https://code.visualstudio.com).
Étape 3: Téléchargez le package wsl_update_x64 et installez-le là où nous avons installé Docker et VS Code.
Étape 4: Pour installer wsl, suivez ce lien. https://learn.microsoft.com/en-us/windows/wsl/install-manual.
Étape 5 : Dans VS Code, installez l’extension * Dev Containers and Remote Development* de Microsoft.

Étape 6 : Ouvrez le dossier du code source de l’infrastructure qui est cloné à partir du référentiel Plans-Terraform. Ou nous pouvons écrire l’Infra Code avec devcontainer.json dans Visual Studio.

1. Créez un devcontainer.json, qui décrit comment VS Code doit démarrer le conteneur et quoi faire après sa connexion.
2. Pour créer devcontainer.json, nous devons d’abord créer un dossier appelé .devcontainer, dans ce dossier, nous pouvons créer devcontainer.json et des fichiers spécifiques à l’environnement comme devcontainer.dev.env.
3. Dans devcontainer.json, définira les détails de configuration ci-dessous

{
    "image": "mcr.microsoft.com/vscode/devcontainers/typescript-node:0-18",

    "name": "My-Project",

    "features": {
        "ghcr.io/devcontainers/features/azure-cli:1": {},
        "ghcr.io/devcontainers/features/terraform:1": {},
        "ghcr.io/devcontainers/features/git:1": {},
        "ghcr.io/devcontainers/features/sshd:1": {}
    },
    "runArgs": ["--init", "--env-file",".devcontainer/devcontainer.dev.env"],
    "remoteEnv": {
        // Sets environment variables required for terrafom remote backend
        "TF_B_SUBSCRIPTION_ID": "${containerEnv:TF_B_SUBSCRIPTION_ID}",
        "TF_B_RESOURCE_GROUP" : "${containerEnv:TF_B_RESOURCE_GROUP}",
        "TF_B_LOCATION": "${containerEnv:TF_B_LOCATION}",
        "TF_B_STORAGE_ACCOUNT" : "${containerEnv:TF_B_STORAGE_ACCOUNT}",                
        "TF_B_CONFIG_FILE_PATH" : "${containerEnv:TF_B_CONFIG_FILE_PATH}",
        "TF_PLAN_VARIABLES_FILE_PATH" : "${containerEnv:TF_PLAN_VARIABLES_FILE_PATH}",
        "TF_PR_SUBSCRIPTION_ID" : "${containerEnv:TF_PR_SUBSCRIPTION_ID}"
    },
    "customizations": {
        "vscode": {
            "extensions": ["dbaeumer.vscode-eslint"]
        }
    },
    "postCreateCommand": "sudo chmod +x ./utils/*; sudo cp ./utils/* /usr/local/bin ",
    "forwardPorts": [3000]
}

3.1) nous pouvons utiliser une image comme point de départ pour votre devcontainer.json. Une image est comme un mini-lecteur de disque avec divers outils et un système d’exploitation préinstallé. Vous pouvez extraire des images d’un registre de conteneurs, qui est un ensemble de référentiels stockant des images.

3.2) Dans le « bloc de fonctionnalités », nous pouvons définir les outils nécessaires pour effectuer les tâches Terraform.

3.3) dans « runArgs », passez les arguments.

3.4) dans « remoteEnv », nous pouvons définir les variables nécessaires lors de l’exécution du conteneur.

3.5) installez les extensions de code VS.

3.6) définir postCreateCommand et forwardPorts [3000] une fois le conteneur créé

4. Créez un fichier dev.env, dans lequel nous devons définir les variables d’abonnement, où se trouve le compte de stockage sauvegardé, le groupe de ressources où le compte de stockage sauvegardé doit être créé, la région où le groupe de ressources doit être créé. Et définissez le nom du compte de stockage et la configuration spécifique à l’environnement.

# the id of the subscription where the backend storage account is located
# Data Core Management
TF_SUBSCRIPTION_ID=**********************

# the name of the resource group where the storage account for the backend should be created
TF_B_RESOURCE_GROUP=MY-RG

# the region where the resource group for the backend should be created
TF_B_LOCATION=eastus

# the name of the storage account for the backend
TF_B_STORAGE_ACCOUNT=mytfsa2

# environment specific configuration
TF_B_CONFIG_FILE_PATH=./backend/my.dev.tfconfig
TF_PLAN_VARIABLES_FILE_PATH=./env/my.dev.tfvars
TF_PR_SUBSCRIPTION_ID=**********************

5. Créez un conteneur de développement supplémentaire pour l’environnement de test afin de cibler l’environnement de test. Faites la même chose pour d’autres environnements.

6. Créez un dossier Backend et créez. tfconfig (backend/my.dev.tfconfig) en fonction des environnements et spécifiez les détails sauvegardés dans ce fichier.

subscription_id      = "*************"
resource_group_name  = "MY-RG"
storage_account_name = "mytfsa2"
container_name       = "terraform"
key                  = "dev.terraform.tfstate"

7. Créez un dossier Env et créez. tfvars (env/ dev.tfvars) avec les environnements respectifs et spécifiez les détails de l’environnement.

location            = "eastus"
subscription_id     = “***************"

tags = {
  "my:environment" = "dev"
  "my:department"  = "**"
  "my:owner"       = "*****@mail.com"
  "my:deployment"  = "terraform"
}
environment         = "dev"

Dans ce fichier, nous pouvons ajouter les détails de la chaîne de connexion, les URL et autres valeurs nécessaires à l’environnement spécifique si elles ne sont pas communes à tous les environnements.

8. Créez un dossier de module et créez un module enfant pour les ressources, comme si vous souhaitez créer un service d’application, nous avons besoin d’une ressource de plan de service pour déployer l’application Web. Nous devrions donc créer deux dossiers de modules enfants pour le plan de service et pour l’application Web.
9. Dans ces dossiers, nous devons créer les fichiers de configuration main.tf, varaibales.tf et output.tf basés sur la création des ressources.
10. Dans cet article, nous allons déployer un service Azure App afin de voir comment nous pouvons les déployer à l’aide de TF From Local.
11. Nous avons créé le dossier du plan App Service sous le module et écrit les fichiers main.tf, variables.tf et output.tf sous le dossier du plan App Service. Main.tf contient les détails de création de ressources et le fichier variables.tf contient les noms et les valeurs (code réutilisable) qui sont transmis à main.tf et output.tf contient les valeurs de sortie de la ressource.
main.tf

resource "azurerm_service_plan" "App_plan" {
  name                = var.name
  resource_group_name= var.resource_group_name
  location = var.location
  
  zone_balancing_enabled = var.zone_balancing_enabled
  os_type = var.os_type
  sku_name   = var.sku_name
 tags = var.tags
}

Variables.tf

variable "name" {
  type        = string
  description = "App Service plan name"
}

variable "resource_group_name" {
  type = string
  description = "App service Resource group name"
}

variable "location" {
  type = string
  description = "app service location"
}

variable "per_site_scale_enabled" {
  type = bool
  default = false
  description = "Should per site scaling be enabled"
}

variable "zone_balancing_enabled" {
  type = bool
  default = false
  description = "Should zone balancing to be enabled"
}

variable "os_type" {
  type = string
  description = "app service plan OS type"
}

variable "sku_name" {
  type = string
  description = "app service sku name select based on requirement"
}

variable "tags" {
  type = map(string)
  description = "my tags"
  default = {}
}

12. Ensuite, nous devons créer un dossier pour le dossier Windowsappservices sous le module et écrire le dossier main.tf, variables.tf et output.tf Windowsappservices.

main.tf

resource "azurerm_windows_web_app" "demo_webapp" {
  name = var.name
  resource_group_name = var.resource_group_name
  location = var.location
  service_plan_id = var.service_plan_id

https_only = false

site_config {
    vnet_route_all_enabled = false
    always_on = false

    application_stack {
        current_stack = "dotnet"
        dotnet_version = var.dotnet_version
    }

}

app_settings = {
    "ASPNETCORE_DETAILEDERRORS" = "true"
}
tags= merge(var.tags,
{
  "myproject:resource" = var.name  
})
}

variables.tf

variable "name" {
  type = string
  description = "App Service  name"
}

variable "resource_group_name" {
  type = string
  description = "App Service  resource group"
}


variable "location" {
  type        = string
  description = "App Servicelocation"
}

variable "service_plan_id" {
  type = string
  description = "Id of the service plan hosting the app service"
}

variable "dotnet_version" {
  type        = string
  description = "The version of the .NET stack to use"
  default     = "v6.0"
}

variable "tags" {
  type        = map(string)
  description = "mytags"
  default     = {}
}

13. Ajoutez/Créez un fichier Locals.tf, dans ce fichier nous écrirons le nom des ressources et qui peuvent être attribuées et utilisées dans notre code.
locaux.tf

locals {
  appservice_plan_name = join("-", compact([var.resource_prefix, var.location, var.environment, var.resource_slug, "demo", "asp" ]))
  appservice_name = join("-", compact([var.resource_prefix, var.location, var.environment, var.resource_slug, var.resource_prefix, "as2"]))
  resource_group_name = "MY-RG"
}

14. Créez un fichier main.tf dans le répertoire racine appelé module racine. Dans ce fichier, nous pouvons définir des blocs de ressources pour les ressources que vous souhaitez déployer, ou nous pouvons définir des blocs de modules pour la création de ressources, appeler les modules enfants et attribuer les valeurs. .
main.tf

data "azurerm_client_config" "current" {}

data "azurerm_resource_group" "k8_rg" {
  name = local.resource_group_name

}

module "app_service_plan" {
  source = "./modules/AppServiceplan"
  name = local.appservice_plan_name
  resource_group_name = data.azurerm_resource_group.k8_rg.name
  location =  var.location
  os_type = "Windows"
  sku_name = "F1"
  tags = var.tags
} 

module "demo_webapp" {
  source = "./modules/windowsAppServices/demoappservice"
  name =  local.appservice_name
  resource_group_name = data.azurerm_resource_group.k8_rg.name
  location = var.location
  service_plan_id = module.app_service_plan.app_service_planId
  tags = var.tags
}

15. Créez le fichier fournisseurs.tf, nous devons écrire le bloc fournisseur dans ce fichier avec le fournisseur de cloud respectif et cela nous permettra d’interagir avec le fournisseur de cloud Azure puisque nous travaillons sur Azure Cloud.
fournisseurs.tf

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = ">=3.12.0"
    }
  }
  backend "azurerm" {}
}

provider "azurerm" {
  features {}

16. Créez un dossier utils et créez des fichiers .sh pour exécuter les commandes Terraform. Nous pouvons écrire un script pour la connexion et l’accès au compte de stockage et aux appels, ainsi que définir les chemins d’abonnement et de configuration des fichiers.

Configurer.sh

#!/bin/bash
az login >> /dev/null
echo "Setting backend subscription id to $TF_B_SUBSCRIPTION_ID"
az account set --subscription $TF_B_SUBSCRIPTION_ID
az account show
echo "Setting state storage account access key"
ACCOUNT_KEY=$(az storage account keys list --resource-group $TF_B_RESOURCE_GROUP --account-name $TF_B_STORAGE_ACCOUNT --query '[0].value' -o tsv)
ARM_ACCESS_KEY=$ACCOUNT_KEY
echo "ARM_ACCESS_KEY set to $ARM_ACCESS_KEY"

init.sh

#!/bin/bash
echo "Initializing local state"
echo "Setting backend subscription id to $TF_B_SUBSCRIPTION_ID"
az account set --subscription $TF_B_SUBSCRIPTION_ID
az account show
terraform init --backend-config=$TF_B_CONFIG_FILE_PATH --migrate-state
echo "Terraform ready to provision."

Plan.sh

#!/bin/bash
echo "Setting provisioning subscription id to $TF_PROVISION_SUBSCRIPTION_ID"
#az account set --subscription "baa4ddad-a723-40a0-929d-0c7bc9f2a3f5"
az account set --subscription  $TF_PR_SUBSCRIPTION_ID
az account show
terraform plan --var-file=$TF_PLAN_VARIABLES_FILE_PATH --out tfplan

appliquer.sh

#!/bin/bash
echo "Setting provisioning subscription id to $TF_PR_SUBSCRIPTION_ID"
az account set --subscription $TF_PR_SUBSCRIPTION_ID
az account show
terraform apply tfplan

Étape 7 : Déployer : dans le shell du conteneur, utilisez les scripts suivants pour initialiser terraform, créer des plans et les appliquer.

1) Exécutez le . ./utils/configure.sh. Cela vous connecte à Azure CLI et obtient/définit un jeton d’accès pour le compte de stockage dans Azure qui contient l’état Terraform.
2) Exécutez le . ./utils/init.sh pour synchroniser votre environnement local avec l’état distant.
3) Courez. ./utils/plan.sh pour générer un plan d’exécution Terraform. Cela affichera un aperçu de la sortie, indiquant quelles ressources peuvent être ajoutées, mises à jour ou supprimées.

4) Appliquez-le en utilisant . ./utils/apply.sh cela appliquera les changements

5) Une fois les commandes Terraform terminées, vérifiez la sortie dans la console et vérifiez également que les modifications sont mises à jour ou non dans Azure Cloud.