Vous en avez assez de cliquer à répétition dans l’interface du portail Azure pour créer des machines virtuelles, des comptes de stockage et des services applicatifs ? Vous cherchez une méthode fiable pour créer le même environnement à plusieurs reprises ? Les modèles ARM sont faits pour vous !
ARM est le sigle d’Azure Resource Manager, le service de déploiement et de gestion de Microsoft pour Azure. La couche de gestion ARM vous permet de créer, de mettre à jour et de supprimer des ressources Azure. Cet article vous présente les modèles ARM, leurs composants essentiels et la méthode pour les déployer avec PowerShell.
En quoi consistent les modèles ARM ?
Les modèles ARM sont une forme d’infrastructure as code, un concept qui vous permet de définir l’infrastructure que vous souhaitez déployer. Ils vous évitent de cliquer à répétition dans l’interface du portail pour créer des machines virtuelles ou de programmer des scripts de déploiement pour un compte de stockage. Le modèle définit les ressources, et la couche de gestion Azure ARM se charge de créer l’infrastructure voulue.
Ce concept est appelé « syntaxe déclarative ». Elle vous permet d’indiquer les ressources que vous voulez créer sans programmer la séquence de commandes nécessaire à sa création. Par exemple, il est facile d’écrire un script à l’aide de la ligne de commande Azure ou Azure PowerShell pour créer une machine virtuelle. Mais vous devez y inclure beaucoup de logique et de contrôles d’erreurs afin de traiter tous les cas de figure.
La création d’un modèle déclaratif définit l’état final de l’environnement ; Azure utilise le modèle comme entrée et crée l’environnement pour vous. La couche de gestion ARM crée une ressource si elle n’existe pas encore, ou modifie une ressource existante pour l’adapter au modèle.
Microsoft a mis en place un nouveau langage d’infrastructure as code appelé Bicep. Pour en savoir plus sur la prise en main de Bicep, consultez l’article Azure Bicep : premiers pas et guide pratique.
Avantages de l’utilisation des modèles ARM
Le recours aux modèles ARM pour gérer votre environnement Azure présente de nombreux avantages. Comme nous l’avons déjà dit, l’utilisation de la syntaxe déclarative évite d’écrire des scripts complexes pour gérer de nombreux scénarios de déploiement.
Les modèles ARM fournissent également des résultats reproductibles et idempotents, ce qui signifie que vous pouvez programmer et déployer le même modèle à plusieurs reprises pour obtenir le même résultat. Vous pouvez réutiliser le modèle qui vous a permis de créer l’infrastructure de développement pour déployer l’environnement de production. En utilisant le même modèle, vous avez la garantie que les ressources et les paramètres sont identiques.
Azure Resource Manager se charge également de l’ordre des opérations pour le déploiement. Ainsi, ARM déploie les ressources présentant des dépendances dans le bon ordre et, si possible, effectue les déploiements en parallèle afin d’aller plus vite. Vous pouvez aussi compléter les modèles avec un script de déploiement écrit dans PowerShell ou Bash pour obtenir une configuration d’environnement de bout en bout.
Principes fondamentaux des modèles ARM
Maintenant vous avez une idée de ce que sont les modèles ARM, il est temps d’en apprendre les principes fondamentaux pour écrire votre premier modèle. Les modèles utilisent la syntaxe JavaScript Object Notation (JSON), qui comprend aussi des fonctionnalités avancées. Voici un modèle ARM vierge :
- {
- "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
- "contentVersion": "1.0.0.0",
- "parameters": {},
- "functions": [],
- "variables": {},
- "resources": [],
- "outputs": {}
- }
Paramètres
Les paramètres vous permettent de transmettre au modèle ARM différentes valeurs, qui seront utilisées pendant le déploiement. Parmi les exemples courants, citons le nom des ressources ou la région Azure qui les hébergera. Grâce aux paramètres, vos modèles sont plus dynamiques et peuvent être utilisés dans différents environnements.
Au minimum, les paramètres doivent compter un nom et un type. Il existe différents types de paramètres : chaîne, tableau, objet, nombre entier, valeur booléenne ou chaîne sécurisée (comme un mot de passe). En outre, le paramètre peut éventuellement contenir une description qui explique comment l’utiliser. Vous pouvez indiquer des valeurs par défaut, pour ne pas avoir à le faire au moment de l’exécution ; vous pouvez aussi définir un ensemble de valeurs autorisées. Vous limitez ainsi les valeurs dont l’utilisateur peut se servir pour le paramètre. Cette configuration est utile si vous voulez restreindre les SKU ou les emplacements qu’une personne peut utiliser pour déployer des ressources.
Les exemples suivants présentent différentes mises en œuvre des paramètres. Le paramètre VMName permet d’utiliser n’importe quelle chaîne pour nommer la machine virtuelle. Le paramètre VMAdmin accepte également tout type de valeur et possède une valeur par défaut ; ainsi l’utilisateur du modèle n’a pas à fournir de valeur pour ce paramètre.
VMAdminPassword est une chaîne sécurisée, ce qui signifie qu’Azure ne stocke pas sa valeur dans l’historique de déploiement. Enfin, VMSize est également une chaîne, mais permet uniquement d’utiliser des SKU spécifiques pour la machine virtuelle.
- "parameters": {
- "VMName": {
- "type": "string",
- "metadata": {
- "description": "Nom de la machine virtuelle"
- }
- },
- "VMAdmin": {
- "type": "string",
- "metadata": {
- "description": "Nom du compte administrateur sur la machine virtuelle locale"
- },
- "defaultValue": "local_admin"
- },
- "VMAdminPassword": {
- "type": "securestring",
- "metadata": {
- "description": "Mot de passe du compte administrateur sur la machine virtuelle locale"
- }
- },
- "VMSize": {
- "type": "string",
- "metadata": {
- "description": "Taille de la machine virtuelle"
- },
- "allowedValues": [
- "Standard_D2_v4",
- "Standard_D4_v4",
- "Standard_D8_v4",
- "Standard_D16_v4"
- ]
- }
- }
Pour fournir des valeurs de paramètre, vous pouvez transmettre les valeurs en ligne lors de la création du déploiement de ressource. Un exemple vous est proposé plus loin dans cet article.
Une autre solution consiste à créer un fichier de paramètres qui contient les valeurs. Ce fichier utilise également la syntaxe JSON. Il est également doté de fonctionnalités avancées, comme la connexion à Azure Key Vault pour extraire les informations sensibles, comme les mots de passe, les clés SSH ou les certificats.
Bien qu’ils ne soient pas obligatoires, les fichiers de paramètres pour modèle ARM suivent généralement une convention de dénomination qui ajoute parameters au nom du modèle. Par exemple, si votre modèle ARM se nomme machine_virtuelle.json, le nom du fichier de paramètres est machine_virtuelle.parameters.json. Si vous réutilisez un modèle pour déployer différents environnements, indiquez le nom de chaque environnement dans le fichier des paramètres. Voici quelques exemples de noms de fichier : machine_virtuelle.parameters-dev.json ou machine_virtuelle.parameters-prod.json.
Voici un exemple de fichier nommé virtualMachine.parameters.json avec des valeurs pour les paramètres définis précédemment dans cette section. Notez que le paramètre VMAdmin est techniquement facultatif puisqu’il possède une valeur par défaut. Si vous ne l’incluez pas dans ce fichier, le modèle utilise la valeur par défaut spécifiée.
- {
- "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
- "contentVersion": "1.0.0.0",
- "parameters": {
- "VMName": {
- "value": "webapp01"
- },
- "VMAdmin": {
- "value": "svr_admin"
- },
- "VMAdminPassword": {
- "value": "N0t@Rea!P@ss0wrd"
- },
- "VMSize": {
- "value": "Standard_D4_v4"
- }
- }
- }
Fonctions
La section suivante dans le modèle ARM concerne les fonctions. Les fonctions permettent de créer des expressions complexes que vous ne souhaitez pas répéter tout au long du modèle. Les fonctions de modèle ARM reprennent de nombreuses fonctions des autres langages de programmation. Vous les appelez quand vous avez besoin de les exécuter, et vous pouvez leur transmettre des informations et obtenir une valeur en retour.
Admettons par exemple que vous ayez besoin de créer des noms uniques pour les ressources. Au lieu de copier et coller le même code pour générer un nom unique, vous pouvez créer une fonction qui s’en charge. Voici une fonction nommée uniqueName, avec un paramètre nommé prefix, qui renvoie un nom unique en reprenant l’identifiant du groupe de ressources.
Notez la valeur namespace, que vous pouvez définir librement. Les fonctions nécessitent une valeur namespace différente pour éviter tout conflit de noms avec les fonctions de modèle standard.
- "functions": [
- {
- "namespace": "varonis",
- "members": {
- "uniqueName": {
- "parameters": [
- {
- "name": "prefix",
- "type": "string"
- }
- ],
- "output": {
- "type": "string",
- "value": "[concat(toLower(parameters('prefix')), uniqueString(resourceGroup().id))]"
- }
- }
- }
- }
- ]
L’exemple ci-dessous illustre l’appel de la fonction uniqueName transmettant la valeur prodwebapp pour le paramètre prefix. Au lieu de transmettre la chaîne, vous pouvez aussi indiquer un paramètre du modèle ou une valeur variable.
- "name": "[varonis.uniqueName('prodwebapp')]"
Variables
Dans les modèles ARM, les variables sont très similaires à celles utilisées dans les autres langages de programmation. Elles contiennent les valeurs qui sont utilisées à plusieurs reprises dans le modèle. Comme avec les fonctions, vous pouvez utiliser des variables pour créer des expressions complexes, ce qui vous évite de les répéter dans le modèle.
Les variables utilisent les mêmes types de données que les paramètres : chaîne, objet, nombre entier, etc. Pour les définir, vous utilisez deux points comme opérateur d’attribution. Par exemple, au lieu de transmettre la région Azure sous forme de paramètre, vous pouvez la définir comme variable :
- "variables": {
- "location": "westus2"
- }
Pour appeler une variable par la suite, utilisez la fonction variable() avec le même nom de variable, comme ceci :
- "location": "[variables('location')]"
Ressources
Voici pour finir ce qui constitue sans doute l’essentiel du modèle ARM : les ressources. La section des ressources définit les ressources Azure qui doivent être déployées avec le modèle. Elles peuvent être très variées : simple groupe de sécurité réseau, machines virtuelles, compte de stockage ou fonctions Azure.
La plupart des ressources présentent un jeu de propriétés communes. Voici un modèle de définition de ressource, suivi d’une explication pour chaque partie.
- "name": “<resource name>”,
- "type": "Microsoft.<resource provider>/<resource type>",
- "apiVersion": "<api version>",
- "tags": {
- "key": "value"
- },
- "location": "<location>",
- "dependsOn": [ ],
- "properties": { }
- Name : Nom de la ressource. Cette valeur peut être définie sous forme de paramètre, de variable ou manuellement.
- Type : Type de ressource à déployer. L’élément <resource provider> renvoie à la famille principale de ressources à déployer ; par exemple : Microsoft.Compute, Microsoft.Storage et Microsoft.Network. L’élément <resource type> décrit plus précisément la ressource à déployer. Par exemple, Microsoft.Compute contient des ressources liées à l’infrastructure de calcul, comme les machines virtuelles, les disques et les jeux de disponibilité. Les éléments « resource provider » et « resource type » sont séparés par une barre oblique (/).
- ApiVersion : Version de l’API ; détermine les propriétés disponibles pour configurer la ressource. À mesure qu’Azure se développe, Microsoft ajoute souvent de nouvelles fonctions ou de nouveaux paramètres aux ressources. La version de l’API, combinée au type de ressource, détermine ce que vous pouvez configurer. La version de l’API suit le format AAAA-MM-JJ.
- Tags : Vous pouvez attribuer des balises à vos ressources, comme vous le faites lorsque vous les créez sur le portail Azure. Les balises, qui permettent d’organiser les ressources, sont constituées d’une paire clé-valeur. Par exemple, vous pouvez utiliser une balise pour indiquer l’environnement de la ressource (développement ou production).
- Location : Il s’agit de la région Azure où la ressource doit être déployée. En général, les ressources sont déployées dans le même groupe de ressources lorsque vous créez un déploiement (une démonstration vous est proposée plus loin). Pour définir automatiquement l’emplacement correspondant à celui du groupe de ressources, utilisez la fonction resourceGroup() et la propriété location, comme ceci :
- “location”: "[resourceGroup().location]"
- DependsOn : Contrairement aux autres langages d’infrastructure as code, comme Terraform, les modèles ARM nécessitent de créer des dépendances de ressources. Ces dépendances déterminent l’ordre dans lequel Azure doit déployer les ressources. Par exemple, si le modèle ARM déploie un réseau virtuel et une machine virtuelle, le réseau virtuel doit exister avant que la machine virtuelle ne soit créée.
- Properties : La section des propriétés contient des informations de configuration pour la ressource déployée. Par exemple, les réseaux virtuels ont des propriétés telles que l’espace d’adressage et les sous-réseaux. Les comptes de stockage ont un niveau d’accès et une version TLS minimale autorisée.
Sorties
La section « outputs » définit les valeurs et informations renvoyées lors du déploiement. Les sorties sont utiles pour les données qu’Azure génère de manière dynamique au cours du déploiement, comme une adresse IP publique.
Dans cet exemple, la section « outputs » affiche les terminaux de connexion pour un compte de stockage qui vient d’être créé. Le modèle ARM génère un nom de compte de stockage avec la variable stgAccountName.
- "outputs": {
- "endpoints": {
- "type": "object",
- "value": "[reference(variables('stgAcctName')).primaryEndpoints]"
- }
- }
Voici le résultat du déploiement effectué avec le modèle ARM via PowerShell ; il répertorie la liste des terminaux principaux.
Déployer des modèles ARM via PowerShell
Bien qu’il existe plusieurs manières de déployer des ressources Azure avec des modèles ARM, ce tutoriel se concentre sur l’utilisation de PowerShell pour déployer un compte de stockage. Pour suivre ce tutoriel, il vous faut :
- PowerShell version 5.1 ou supérieure. Ce tutoriel utilise la version 7.1.3.
- Le module Azure (Az) PowerShell. Ce tutoriel utilise la version 6.0.0.
- Un compte administrateur Azure avec les autorisations suffisantes pour créer des ressources (Propriétaire ou Contributeur).
Pour savoir comment établir une connexion à d’autres services cloud Microsoft, consultez Comment se connecter à Office 365 avec PowerShell : modules Azure AD.
1. Se connecter à Azure
Pour utiliser les commandes du module Az PowerShell, vous devez d’abord vous connecter à Azure avec un compte authentifié. Utilisez la commande Connect-AzAccount ; PowerShell ouvre une fenêtre de navigateur pour terminer l’authentification.
2. Créer un groupe de ressources
Ensuite, créez un groupe de ressources qui contiendra les ressources de modèle ARM. Utilisez la commande New-AzResourceGroup et attribuez un nom et une région Azure au groupe de ressources. Enregistrez le résultat de la commande dans une variable nommée $rg, pour pouvoir référencer le groupe de ressources par la suite. Dans notre cas, le nom du groupe de ressource est « armdemo-rg » et la région « WestUs2 ».
- $rg = New-AzResourceGroup -Name armdemo-rg -Location WestUs2
3. Créer un modèle ARM
Pour créer la ressource, il vous faut un modèle ARM dans lequel est défini un compte de stockage. Voici un modèle ARM simple avec un seul paramètre appelé StorageAccountName, pour définir le nom du compte de stockage. Enregistrez ce code dans un fichier nommé storageAccount.json.
- {
- "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
- "contentVersion": "1.0.0.0",
- "parameters": {
- "StorageAccountName": {
- "type": "string"
- }
- },
- "functions": [],
- "variables": {},
- "resources": [
- {
- "name": "[parameters('StorageAccountName')]",
- "type": "Microsoft.Storage/storageAccounts",
- "apiVersion": "2021-01-01",
- "tags": {},
- "location": "[resourceGroup().location]",
- "kind": "StorageV2",
- "sku": {
- "name": "Standard_LRS",
- "tier": "Standard"
- },
- "properties": {}
- }
- ],
- "outputs": {}
- }
Vous pouvez également télécharger ce modèle ARM à partir de ce référentiel GitHub.
4. Déployer le modèle ARM
Lorsque le modèle ARM est prêt, vous pouvez déployer le compte de stockage dans votre environnement Azure. Pour commencer, utilisez la commande New-AzResourceGroupDeployment et spécifiez le groupe de ressources cible ($rg.ResourceGroupName), ainsi que le chemin du fichier modèle storageAccount.json. Pour afficher la progression du déploiement du groupe de ressources, ajoutez le paramètre -Verbose.
Comme le modèle ARM utilise un paramètre, vous pouvez spécifier la valeur comme pour n’importe quel paramètre PowerShell. Ajoutez le paramètre -StorageAccountName à la commande et saisissez un nom de compte de stockage valide. Le nom du compte de stockage doit être unique dans tout l’environnement Azure et exclusivement formé de minuscules et de chiffres. Dans notre cas, le nom du compte de stockage est varonisarmtemplatedemo.
- New-AzResourceGroupDeployment `
- -ResourceGroupName $rg.ResourceGroupName `
- -TemplateFile .\storageAccount.json `
- -StorageAccountName ‘varonisarmtemplatedemo’ `
- -Verbose
5. Réaliser le déploiement avec un fichier de paramètres (facultatif)
Bien que vous puissiez spécifier les paramètres du modèle ARM dans le cadre de la commande de déploiement PowerShell, cette méthode peut être fastidieuse s’il y a beaucoup de paramètres. Vous pouvez donc utiliser un fichier de paramètres pour spécifier la valeur.
Créez un nouveau fichier nommé storageAccount.parameters.json dans le même répertoire que le modèle ARM, avec le contenu suivant. Remplacez le nom du compte de stockage par le nom de votre choix. Pour ce tutoriel, nous utilisons le nom varonisarmtemplatedemo2.
- {
- "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
- "contentVersion": "1.0.0.0",
- "parameters": {
- "StorageAccountName": {
- "type": "string"
- }
- },
- "functions": [],
- "variables": {},
- "resources": [
- {
- "name": "[parameters('StorageAccountName')]",
- "type": "Microsoft.Storage/storageAccounts",
- "apiVersion": "2021-01-01",
- "tags": {},
- "location": "[resourceGroup().location]",
- "kind": "StorageV2",
- "sku": {
- "name": "Standard_LRS",
- "tier": "Standard"
- },
- "properties": {}
- }
- ],
- "outputs": {}
- }
Reprenez la commande utilisée à l’étape 4 et ajoutez le paramètre -TemplateParameterFile avec comme valeur le nouveau fichier de paramètres.
- New-AzResourceGroupDeployment `
- -ResourceGroupName $rg.ResourceGroupName `
- -TemplateFile .\storageAccount.json `
- -TemplateParameterFile .\storageAccount.parameters.json `
- -Verbose
Modes de déploiement ARM
Les déploiements ARM offrent deux modes différents : incrémentiel et complet. Ces deux modes se distinguent par la manière dont le service Resource Manager traite les ressources existantes qui ne sont pas définies dans le modèle.
Dans les deux modes, le service Resource Manager essaie de créer l’ensemble des ressources du modèle. Si la ressource existe déjà et correspond à la ressource définie dans le modèle, la ressource Azure reste inchangée. Si vous exécutiez à nouveau les commandes de la section précédente, Azure n’effectuerait aucune opération.
Si vous modifiez une ou plusieurs valeurs de propriété dans une ressource, Azure met à jour la ressource avec la ou les nouvelles valeurs. Par exemple, dans le cas de notre compte de stockage, vous pourriez remplacer le SKU de stockage Standard_LRS par Standard_GRS et Azure mettrait à jour la ressource.
Déploiement en mode incrémentiel
Pour les déploiements de modèles ARM, le mode incrémentiel s’applique par défaut. Cela signifie qu’Azure déploie les ressources du modèle et ne touche pas aux ressources non spécifiées dans le modèle. Le tutoriel précédent illustre ce fonctionnement : vous avez déployé un seul compte de stockage à l’aide du modèle, puis un autre compte de stockage avec un nom différent dans le même groupe de ressources.
En résumé, le mode incrémentiel déploie (ou met à jour) les ressources dans le groupe de ressources, mais ne touche pas aux ressources existantes. Bien que le mode incrémentiel soit implicite par défaut, vous pouvez utiliser le paramètre -Mode Incremental dans les commandes précédentes afin de définir le mode de déploiement de manière explicite.
Déploiement en mode complet
Le mode complet adopte un comportement tout à fait différent, et potentiellement destructeur. Dans ce mode, le service Resource Manager supprime toutes les ressources du groupe de ressources spécifié dans le modèle ARM.
Examinons un exemple. Pour commencer, modifiez le nom du compte de stockage dans le fichier de paramètres créé à l’étape 5, en le remplaçant par varonisarmtemplatedemo3. Ensuite, exécutez de nouveau la commande de déploiement en ajoutant -Mode Complete.
- New-AzResourceGroupDeployment `
- -ResourceGroupName $rg.ResourceGroupName `
- -TemplateFile .\storageAccount.json `
- -TemplateParameterFile .\storageAccount.parameters.json `
- -Mode Complete `
- -Verbose
Azure vous demande de confirmer que vous souhaitez continuer en mode complet puisque le service Resource Manager risque de supprimer des ressources. Saisissez Y pour poursuivre le déploiement.
Lorsque le déploiement est terminé, vérifiez le groupe de ressources sur le portail Azure. À présent, vous devriez uniquement voir le compte de stockage du dernier déploiement. En effet, le service Resource Manager a supprimé les autres comptes de stockage puisqu’ils n’étaient pas définis dans le modèle ARM.
En résumé, le mode complet est destructeur si vous ne définissez pas toutes les ressources dans le modèle ARM. Par conséquent, veillez à bien examiner l’avertissement PowerShell lorsque vous effectuez un déploiement en mode complet, et vérifiez que toutes les ressources que vous souhaitez conserver sont définies dans le modèle ARM.
Bonnes pratiques concernant les modèles ARM
À mesure que vous avancez dans le développement de modèles ARM, un certain nombre de bonnes pratiques sont à observer.
Vous devez limiter la taille du modèle à 4 Mo. Cette limite concerne la taille du modèle après que Resource Manager a ajouté au fichier les déploiements de ressource itératifs et les valeurs des variables et paramètres. Vous devez aussi respecter d’autres limites :
- 256 paramètres
- 256 variables
- 800 ressources (y compris le nombre de copies)
- 64 valeurs de sortie
- 24 576 caractères dans une expression de modèle
Pour les paramètres, pensez à réduire au maximum leur nombre et utilisez à la place des variables ou des valeurs littérales pour les propriétés qui n’ont pas besoin d’être spécifiées lors du déploiement. Utilisez des paramètres pour les éléments de configuration qui changent en fonction de l’environnement, par exemple, les SKU, la taille des ressources ou leur capacité. Fournissez toujours des métadonnées pour le paramètre, et utilisez des valeurs par défaut pour faciliter les déploiements. Ces valeurs servent également d’exemple pour les autres utilisateurs du modèle.
Créez des variables lorsqu’une valeur est utilisée plusieurs fois dans un modèle. Si vous créez une propriété de ressource à partir d’une expression complexe, envisagez d’utiliser une variable pour faciliter la lecture du reste du modèle.
Codez systématiquement en dur la version du modèle et de l’API de ressource, et utilisez la version la plus récente de l’API lorsque vous créez un autre modèle. Si le modèle fonctionne comme prévu, continuez d’utiliser la même version d’API pour ne pas avoir à vous soucier des changements apparaissant dans les versions ultérieures.
Ressources pour les modèles ARM
Microsoft Learn fournit des modules de formation sur les modèles ARM, notamment sur le développement et le déploiement d’environnements plus complexes. Consultez le parcours d’apprentissage Déployer et gérer des ressources dans Azure en utilisant des modèles ARM, qui propose des modules d’approfondissement sur le développement des modèles ARM.
Microsoft Visual Studio Code (VS Code) comprend des extensions qui aident à écrire des modèles ARM. Consultez ce tutoriel de prise en main sur l’écriture des modèles ARM. Il existe également de nombreuses extensions Microsoft et tierces qui permettent de gagner beaucoup de temps sur l’écriture des modèles ARM.
Questions fréquentes sur les modèles ARM
Qu’est-ce qu’Azure Resource Manager (ARM) ?
ARM est le sigle d’Azure Resource Manager, le service de déploiement et de gestion de Microsoft pour Azure. La couche de gestion ARM vous permet de créer, de mettre à jour et de supprimer des ressources Azure.
Que sont les modèles ARM ?
Les modèles ARM sont une forme d’infrastructure as code, un concept qui vous permet de définir l’infrastructure à déployer. Ils s’appuient sur une syntaxe déclarative, c’est-à-dire que vous pouvez définir des ressources à déployer par Azure sans spécifier la manière dont elles seront créées.
Quels sont les principaux avantages des modèles ARM ?
Les modèles ARM vous permettent de définir et créer des ressources dans Azure de manière rapide. Comme vous définissez les ressources sous forme de code, vous pouvez rapidement déployer plusieurs environnements de développement, de test et de production.
Conclusion
Le recours au code pour définir l’infrastructure Azure offre de nombreux avantages, notamment en termes de réutilisation et de normalisation. Vous pouvez utiliser les modèles ARM non seulement pour le déploiement initial des ressources, mais également pour leur gestion en continu. En passant par l’infrastructure as code, vous pouvez ensuite introduire d’autres éléments d’automatisation ; par exemple utiliser Azure DevOps or GitHub pour déployer automatiquement les changements d’infrastructure.
