Déployer des machines virtuelles Azure avec Terraform pour économiser de l'argent
Liens rapides
- Conditions préalables
- Installation de Terraform
- Authentification
- Création du modèle Terraform
- Lancement et déploiement avec TerraForm
- Conclusion
La plupart d'entre nous l'ont fait - déployé 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 apprendrons comment déployer des machines virtuelles sur Azure et en supprimer toute trace lorsque nous aurons fini d'utiliser Terraform.
Conditions préalables
Vous devez remplir quelques prérequis pour pouvoir suivre cet article :
- Installez Azure CLI.
- Soyez administrateur d’un abonnement Azure (ou similaire), ce qui vous permet de l’utiliser pour créer des groupes de ressources et des ressources.
Ceci étant réglé, commençons par télécharger et installer Terraform.
Installation de Terraform
Terraform peut être installé de différentes manières. Sous Windows, le plus simple est d'utiliser choco :
choco install terraform
Sur 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é lors de 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 tapez :
az login
Et puis, après vous être authentifié, listez tous vos abonnements en saisissant :
az account list
Si vous avez plusieurs abonnements disponibles, copiez l'identifiant d'abonnement du bon et saisissez :
az account set --subscription="COPIED_SUBSCRIPTION_ID"
Vous avez maintenant configuré Azure CLI pour utiliser votre abonnement. (C'est 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 VM.
Création du modèle Terraform
Le modèle Terraform est un simple fichier texte dont le fichier se termine par .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 créées par le fournisseur.
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 l'état de la configuration ultérieurement.
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 Azure) et qu'il doit être de 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. Ceci est également considéré par Terraform 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 » 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 paramètre name. Si vous regardez bien, 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 placerons la VM, en utilisant les mêmes méthodes 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 également la carte réseau que la VM va 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, 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 provisionnera 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" et le mot de passe "$om3s3cretPassWord". Le reste des paramètres est assez explicite et vous pouvez en trouver beaucoup plus dans la documentation Terraform AzureRM.
Il ne reste plus qu'à enregistrer le fichier .tf en déployant ce modèle sur Azure à l'aide de TerraForm !
Lancement et déploiement avec TerraForm
Maintenant que nous avons le modèle en ordre, ouvrez un terminal et accédez au répertoire dans lequel vous avez enregistré le fichier .tf :
cd c:tempterraform
Il faut maintenant lancer TerraForm. Cela téléchargera le module de ressources pour AzureRM et recherchera les erreurs dans le fichier .tf :
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, des réseaux, des 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 dossier .terraform de votre répertoire actuel. Alors, ne supprimez pas ce dossier si vous souhaitez supprimer les ressources proprement plus tard !
Une fois que vous avez terminé avec votre machine virtuelle de test et que vous souhaitez la détruire, exécutez simplement :
terraform destroy
Cela supprimera tous les disques, cartes réseau, sous-réseaux, groupes de ressources et autres créés lors de l'exécution de terraform apply, et vous n'aurez 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 intéressant. Cela prouve qu'il n'est pas nécessaire de disposer d'une infrastructure en tant que code (IaC) entièrement implémentée pour l'utiliser de manière productive. Cela réduit également les coûts 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 !