Déployer des machines virtuelles Azure avec Terraform pour économiser de l'argent

La plupart d'entre nous l'ont fait: déployer des machines virtuelles temporaires sur Azure. Beaucoup d'entre nous ont également oublié de supprimer les ressources attachées à ces machines virtuelles lors de leur suppression. Cela peut entraîner des coûts indésirables pouvant atteindre des milliers de dollars si vous ne faites pas attention.

Dans cet article, nous allons apprendre à déployer des machines virtuelles sur Azure et à supprimer toute trace d'entre elles lorsque nous aurons terminé en utilisant Terraform.

Conditions préalables

Vous devez remplir quelques conditions préalables pour pouvoir suivre cet article:

• Ayez Azure CLI installé.
• Soyez un administrateur sur un abonnement Azure (ou similaire), ce qui vous permet de l'utiliser pour créer des groupes de ressources et des ressources.

Avec ces éléments à l'écart, commençons par télécharger et installer Terraform.

Installation de Terraform

Terraform peut être installé de différentes manières. Sous Windows, la manière la plus simple est d'utiliser choco:

choco install terraform

Sur un Macintosh, il est disponible en utilisant Brew:

brew install terraform

Plus d'informations sur l'installation de Terraform sont disponibles dans la documentation Terraform.

En supposant que tout s'est bien passé avec l'installation, vous pouvez confirmer que cela fonctionne en exécutant la commande terraform version.

Maintenant que vous avez confirmé que terraform fonctionne sur votre machine, il est temps de vous authentifier auprès de l'abonnement Azure via Azure CLI.

Authentification

Pour authentifier et définir l'abonnement dans Azure CLI, vous devez vous connecter. Ouvrez un terminal et saisissez:

az login

Et puis, après authentification, listez tous vos abonnements en entrant:

az account list

Si vous disposez de plusieurs abonnements, copiez l'ID d'abonnement du bon et entrez:

az account set --subscription="COPIED_SUBSCRIPTION_ID"

Vous avez maintenant configuré l'Azure CLI pour utiliser votre abonnement. (Il s'agit de l'abonnement que terraform utilisera également plus tard.) Il est maintenant temps de créer le modèle terraform que nous utiliserons pour déployer notre machine virtuelle.

Création du modèle Terraform

Le modèle Terraform est un simple fichier texte avec la fin du fichier .tf. Il a une syntaxe de type JSON et peut être lu et généré facilement. Le modèle se compose principalement de deux parties: les fournisseurs (qui gèrent la communication avec le service dans lequel vous souhaitez déployer) et les ressources que le fournisseur crée.

Nous commençons par créer un fichier appelé vm.tf dans un répertoire vide. Terraform aura besoin d'un répertoire vide pour pouvoir écrire ultérieurement l'état de la configuration.

Maintenant, ouvrez ce fichier avec votre éditeur de texte préféré et ajoutez le fournisseur:

provider "azurerm" {
  version   = "=2.11.0"
	features {}  
}

Cela indiquera à Terraform que vous souhaitez utiliser le fournisseur AzureRM (pour créer des ressources azur) et qu'il devrait être de la version 2.11. Il est important de spécifier le numéro de version car les fonctionnalités entre les différentes versions peuvent varier considérablement.

Après avoir écrit cela dans le fichier texte, il est temps d'ajouter notre groupe de ressources Azure. Terraform considère également cela comme une ressource:

resource "azurerm_resource_group" "resourcegroup" {
        name = "test-vm"
        location = "westus"
        tags = {
            project = "some_test_project"
        }
}

Le code ci-dessus crée un groupe de ressources nommé «test-vm» qui est situé dans la région ouest des États-Unis. Il ajoute également une balise avec le nom du projet.

Pour exécuter une VM avec succès, nous avons également besoin d'un réseau. Et comme Terraform est conçu pour Infrastructure as Code (IaC), il est également disponible en tant que ressource:

resource "azurerm_virtual_network" "network" {
    name                = "${azurerm_resource_group.resourcegroup.name}-network"
    address_space       = ("10.0.0.0/16")
    location            = azurerm_resource_group.resourcegroup.location
    resource_group_name = azurerm_resource_group.resourcegroup.name

    tags = azurerm_resource_group.resourcegroup.tags
}

Cela crée un réseau virtuel. Il utilise également une variable dans le Nom paramètre. Si vous regardez attentivement, vous verrez qu'il fait référence au groupe de ressources que nous avons défini ci-dessus:

"${azurerm_resource_group.resourcegroup.name}-network"

Cela signifie que le réseau virtuel recevra le nom test-vm-network. Nous faisons de même pour l'emplacement, le nom du groupe de ressources et les balises.

Ensuite, il est temps de définir le sous-réseau dans lequel nous allons placer la machine virtuelle, en utilisant les mêmes méthodes en utilisant des variables que précédemment:

resource "azurerm_subnet" "subnet" {
    name                 = "${azurerm_resource_group.resourcegroup.name}-subnet"
    resource_group_name  = azurerm_resource_group.resourcegroup.name
    virtual_network_name = azurerm_virtual_network.network.name
    address_prefix       = "10.0.2.0/24"
}

Cela crée un sous-réseau appelé test-vm-subnet.

Maintenant, définissons la carte réseau que la machine virtuelle va également utiliser:

resource "azurerm_network_interface" "vm1-nic" {
    name                        = "vm1-NIC"
    location                    = azurerm_resource_group.resourcegroup.location
    resource_group_name         = azurerm_resource_group.resourcegroup.name

    ip_configuration {
        name                          = "vm1-NicConfiguration"
        subnet_id                     = "${azurerm_subnet.subnet.id}"
        private_ip_address_allocation = "static"
        private_ip_address            = "10.0.2.4"
    }

    tags = azurerm_resource_group.resourcegroup.tags
}

Dans ce cas, nous utiliserons une adresse IP statique, faisant référence au sous-réseau à l'aide d'une variable.

Et, enfin et surtout, la définition de la VM elle-même:

resource "azurerm_virtual_machine" "vm-1" {
  name                  = "vm1"
  location              = "${azurerm_resource_group.resourcegroup.location}"
  resource_group_name   = "${azurerm_resource_group.resourcegroup.name}"
  network_interface_ids = ("${azurerm_network_interface.vm1-nic.id}")
  vm_size               = "Standard_B1ms"

  delete_os_disk_on_termination = true

  storage_image_reference {
    publisher = "MicrosoftWindowsServer"
    offer     = "WindowsServer"
    sku       = "2019-Datacenter"
    version   = "latest"
  }
  storage_os_disk {
    name              = "vm1-osdisk"
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
  }
  os_profile {
    computer_name  = "vm-1"
    admin_username = "demoadmin"
    admin_password = "$om3s3cretPassWord"
  }

  os_profile_windows_config {
      enable_automatic_upgrades = "true"
      provision_vm_agent = "true"
  }

  tags = azurerm_resource_group.resourcegroup.tags
}

Le code ci-dessus fournira une machine virtuelle Azure exécutant Windows Server 2019, en utilisant les ressources que nous avons définies précédemment. Il aura un administrateur avec le nom d'utilisateur "demoadmin" qui a le mot de passe «$ Om3s3cretPassWord». Les autres paramètres sont assez explicites et vous pouvez en trouver beaucoup plus dans la documentation Terraform AzureRM.

Maintenant, tout ce qui reste est de sauver le .tf-fichier en déployant ce modèle sur Azure à l'aide de TerraForm!

Lancement et déploiement avec TerraForm

Maintenant que le modèle est en ordre, ouvrez un terminal et accédez au répertoire dans lequel vous avez enregistré le .tf-fichier à:

cd c:tempterraform

Nous devons maintenant lancer TerraForm. Cela va télécharger le module de ressources pour AzureRM et traiter les erreurs dans le .tf-fichier:

Une fois l'initialisation terminée, vous êtes prêt à appliquer le modèle en exécutant terraform apply.

terraform apply

TerraForm va maintenant créer un nouveau groupe de ressources dans Azure, les réseaux, les sous-réseaux et, éventuellement, la machine virtuelle elle-même. L'état et toutes les ressources qu'il a créées sont stockés dans le .terraform dossier de votre répertoire actuel. Donc, ne supprimez pas ce dossier si vous souhaitez supprimer les ressources proprement plus tard!

Une fois que vous avez terminé votre test vm et que vous souhaitez le détruire, exécutez simplement:

terraform destroy

Cela supprimera tous les disques, cartes réseau, sous-réseaux, groupes de ressources et tels qu'ils ont été créés lors de l'exécution. terraform apply, et vous n'avez pas à vous soucier d'oublier de supprimer les fragments restants en termes de ressources Azure.

Conclusion

Utiliser TerraForm uniquement pour des tâches mineures comme celle-ci est incroyablement soigné. Cela prouve que vous n'avez pas besoin d'avoir une infrastructure sous forme de code (IaC) entièrement implémentée pour l'utiliser de manière productive. Il réduit également le coût en supprimant les ressources inutilisées dans Azure. J'espère que cela vous a été utile et a même commencé votre voyage vers l'IaC!