Tutoriel : Utiliser Azure Key Vault avec une machine virtuelle Linux dans AnsibleTutorial: Use Azure Key Vault with a Linux virtual machine in Ansible

Important

Ansible 2.9 (ou version ultérieure) est nécessaire pour exécuter les exemples de playbooks dans cet article.Ansible 2.9 (or later) is required to run the sample playbooks in this article.

Ce tutoriel vous montre comment utiliser la collection Ansible pour les modules Azure à l’aide de Azure Key Vault.This tutorial shows you how to use the Ansible collection for Azure modules in using Azure Key Vault. Azure Key Vault vous permet de centraliser le stockage des informations d’identification, telles que les secrets d’application, les clés et les certificats.Azure Key Vault allows you to centralize the storage of credentials such as application secrets, keys, and certificates. Le découplage des informations d’identification et du code d’application aide votre système à gagner en sécurité.The decoupling of credentials and application code helps your system become more secure. Par ailleurs, l’implémentation d’un modèle de gestion des informations d’identification rotatif avec des dates d’expiration automatiques devient plus gérable.Also, implementing a rotating credentials-management pattern with auto expiry dates becomes much more manageable.

  • Utiliser Azure CLI pour récupérer les valeurs de l’abonnement Azure et du principal du serviceUse the Azure CLI to get Azure subscription and service principal values
  • Stocker des valeurs de clé en tant que variables d’environnement LinuxStore key values as Linux environment variables
  • Récupérer des variables d’environnement Linux à partir d’un playbook AnsibleGet Linux environment variables from an Ansible playbook
  • Création d’un coffre de clésCreate a key vault
  • Définir une stratégie d’accès pour un coffre de clésSet an access policy for a key vault
  • Utiliser le Portail Azure pour ajouter une stratégie d’accès à un coffre de clésUse the Azure portal to add an access policy to a key vault
  • Créer un secret Key VaultCreate a key vault secret
  • Utiliser le module d’interpréteur de commandes Ansible pour obtenir un secret de coffre de clésUse the Ansible shell module to get a key vault secret
  • Créer une machine virtuelle avec tous ses composants constitutifsCreate a virtual machine along with all of its constituent components

PrérequisPrerequisites

  • Abonnement Azure : si vous n’avez pas d’abonnement Azure, créez un compte Azure gratuit avant de commencer.Azure subscription: If you don't have an Azure subscription, create a free account before you begin.
  • Configurer une collection Azure : Exécutez la commande suivante à partir d’une fenêtre de terminal pour installer la collection Azure.Configure Azure collection: Run the following command from a terminal window to install the Azure collection. Si la collection Azure est déjà installée, l’indicateur --force la met à jour vers la version la plus récente.If the Azure collection is already installed, the --force flag will update it to the most recent version.

    ansible-galaxy collection install azure.azcollection --force
    

Télécharger les informations d’abonnement AzureGet Azure subscription info

Utilisez Azure CLI pour obtenir les informations d’abonnement Azure nécessaires à l’utilisation des modules Ansible pour Azure.Use the Azure CLI to get the necessary Azure subscription information needed when using the Ansible modules for Azure.

  1. Récupérez l’ID d’abonnement Azure et l’ID de locataire d’abonnement Azure à l’aide de la commande az account show.Get the Azure subscription ID and Azure subscription tenant ID using the az account show command. Pour l’espace réservé <Subscription>, spécifiez le nom de l’abonnement Azure ou l’ID d’abonnement Azure.For the <Subscription> placeholder, specify either the Azure subscription name or Azure subscription ID. La commande affiche la plupart des valeurs de clé associées à l’abonnement Azure par défaut.The command will display many of the key values associated with the default Azure subscription. Si vous avez plusieurs abonnements, vous devrez peut-être définir l’abonnement actuel via la commande az account set.If you have multiple subscriptions, you might need to set the current subscription via the az account set command. À partir de la sortie de la commande, prenez note des valeurs ID et tenantID .From the command's output, make note of both the ID and tenantID values.

    az account show --subscription "<Subscription>" --query tenantId
    
  2. Si vous n’avez pas de principal de service pour l’abonnement Azure.If you don't have a service principal for the Azure subscription. Créez un principal du service Azure à l’aide d’Azure CLI.create an Azure service principal with the Azure CLI. À partir de la sortie de la commande, prenez note de la valeur appId .From the command's output, make note of the appId value.

  3. Récupérez l’ID d’objet du principal de service à l’aide de la commande az ad sp show.Get the object ID of the service principal using the az ad sp show command. Pour l’espace réservé <ApplicationID>, spécifiez l’appId du principal du service.For the <ApplicationID> placeholder, specify the service principal appId. Le paramètre --query indique la valeur à imprimer sur stdout .The --query parameter indicates which value to print to stdout . Dans ce cas, il s’agit de l’ID d’objet du principal de service.In this case, it's the service principal object ID.

    az ad sp show --id <ApplicationID> --query objectId
    
  4. Stockez les valeurs suivantes en tant que variables d’environnement : ID d’abonnement Azure, ID de locataire de l’abonnement Azure et ID d’objet du principal du service.Store the following values as environment variables: Azure subscription ID, Azure subscription tenant ID, and service principal object ID. La façon dont vous exécutez le playbook, l’endroit où vous stockez les valeurs d’abonnement et d’abonnement et la façon dont vous récupérez ces valeurs sont basées sur votre environnement particulier.How you run the playbook, where you store subscription and credential values, and how you retrieve those values is based on your particular environment. Dans le cadre de cette démonstration, j’ai utilisé Azure Cloud Shell et stocké les valeurs Azure nécessaires dans ~/.bashrc en ajoutant les lignes suivantes à la fin du fichier :For purposes of this demo, I used Azure Cloud Shell and stored the necessary Azure values in ~/.bashrc by adding the following lines to the end of the file:

    export AZ_SUBSCRIPTION_ID="<subscriptionID>"
    export AZ_TENANT_ID="<tenantID>"
    export AZ_OBJECT_ID="<objectID>"
    export AZ_CLIENT_ID="<appID>"
    

Déclarer la collection AzureDeclare the Azure collection

Une fois que vous avez téléchargé la dernière collection Azure, spécifiez son utilisation à l’aide de la clé collections.After downloading the latest Azure collection, specify its use via the collections key.

- hosts: all
  collections:
    - azure.azcollection

Créer un groupe de ressources Azure pour le coffre de clésCreate Azure resource group for the key vault

L’extrait de code de playbook suivant crée un groupe de ressources nommé de façon unique où le coffre de clés sera créé.The following playbook snippet creates a uniquely named resource group into which the key vault will be created.

---
- hosts: localhost
  tasks:
    - name: Prepare random postfix
      set_fact:
        rpfx: "{{ 10000 | random }}"
      run_once: yes
      
- hosts: localhost
  vars:
    kv_rg: kv_rg_{{ rpfx }}
    kv_rg_loc: eastus

  tasks:
    - name: Set facts
      set_fact:
        az_sub_id: "{{ lookup('env', 'AZ_SUBSCRIPTION_ID') }}"

    - name: Create a resource group to hold the key vault
      azure_rm_resourcegroup:
        subscription_id: "{{ az_sub_id }}"
        name: "{{ kv_rg }}"
        location: "{{ kv_rg_loc }}"

    - debug:
        msg: "New resource group = {{ kv_rg }}"

Remarques :Notes:

  • Dans cette démonstration, le coffre de clés est créé comme unique ressource dans un groupe de ressources.In this demo, the key vault is created as the sole resource in a resource group. Il est courant de séparer le coffre de clés des ressources qui l’utilisent.It's common practice to separate the key vault from the resources that use it. Ce modèle permet d’éviter la suppression accidentelle du coffre de clés lors de la suppression d’autres ressources.This pattern helps to prevent accidental deletion of the key vault when deleting other resources.
  • Étant donné que le nom du coffre de clés doit être unique dans Azure, la démonstration crée une valeur de suffixe aléatoire.Since the key vault name must be unique in Azure, the demo creates a random postfix value. Cette valeur est ajoutée au nom du groupe de ressources du coffre de clés et du coffre de clés (créé dans la section suivante).This value is appended to the name of the key vault resource group and the key vault (created in the next section). Le code de la tâche Prepare random postfix génère la valeur de suffixe aléatoire qui est assignée à la variable rpfx.The code in the task Prepare random postfix generates the random postfix value that is assigned to the rpfx variable.
  • Dans la tâche Set facts, la commande lookup est utilisée pour récupérer l’ID d’abonnement Azure qui est stocké en tant que variable d’environnement.In the task Set facts, the lookup command is used to retrieve the Azure subscription ID that is stored as an environment variable.
  • Le module azure_rm_resourcegroup est utilisé pour créer le groupe de ressources.The azure_rm_resourcegroup module is used to create the new resource group.
  • Une tâche debug à la fin du playbook affiche le nom du nouveau groupe de ressources.A debug task at the end of the playbook displays the name of the new resource group.

Création d’un coffre de clésCreate a key vault

Comme mentionné dans la section précédente, le nom du coffre de clés doit être unique dans Azure.As mentioned in the previous section, the key vault name must be unique across Azure. Par conséquent, l’extrait de code de playbook suivant affecte à la variable kv la concaténation du littéral kv et de la valeur rpfx.As such, the following playbook snippet assigns to the kv variable the concatenation of the literal kv and rpfxvalue.

vars:
  kv: "kv{{ rpfx }}"
  kv_rg: "kv_rg_{{ rpfx }}"

tasks:
  - name: Set facts
    set_fact:
      az_object_id: "{{ lookup('env', 'AZ_OBJECT_ID') }}"
      az_tenant_id: "{{ lookup('env', 'AZ_TENANT_ID') }}"

  - name: Create a key vault
    azure_rm_keyvault:
      subscription_id: "{{ az_sub_id }}"
      resource_group: "{{ kv_rg }}"
      vault_name: "{{ kv }}"
      vault_tenant: "{{ az_tenant_id }}"
      enabled_for_deployment: yes
      sku:
        name: standard
        family: A
      access_policies:
        - object_id: "{{ az_object_id }}"
          tenant_id: "{{ az_tenant_id }}"
          secrets:
            - get
            - list
            - set
  - debug:
      msg: "New key vault name = {{ kv }} within the {{ kv_rg }} resource group"

Remarques :Notes:

  • Le module azure_rm_keyvault est utilisé pour créer le coffre de clés.The azure_rm_keyvault module is used to create the key vault.
  • Lors de la création de la stratégie d’accès dans le coffre de clés, un ID d’objet et un ID de locataire ont été fournis.When creating the access policy as part of the key vault, an object ID and tenant ID were supplied. Ces valeurs définissent une stratégie d’accès pour un principal de service spécifique (associé à un abonnement Azure).These values define an access policy for a specific service principal (that is associated with an Azure subscription). Toutefois, l’accès au Portail Azure et la tentative d’affichage des secrets du coffre de clés peuvent entraîner des messages d’erreur.However, browsing to the Azure portal and attempting to view the key vault's secrets might result in error messages. Ces messages peuvent être semblables à « La liste des opérations n’est pas activée dans la stratégie d’accès de ce coffre de clés. »These messages might be similar to "The operation "List" is not enabled in this key vault's access policy." et « Vous n’êtes pas autorisé à afficher ces contenus. »and "You are unauthorized to view these contents." La réception de ces messages indique que vous-même, en tant qu’utilisateur Active Directory, n’avez pas accès.Receiving these messages indicates that you - as an Active Directory user - don't have access. La section suivante vous montre comment ajouter une stratégie d’accès au coffre de clés pour vous.The next section shows you how to add an access policy for yourself to the key vault.
  • Une tâche debug à la fin du playbook affiche le nom du nouveau coffre de clés.A debug task at the end of the playbook displays the name of the new key vault.

Vous ajouter à une stratégie d’accès au coffre de clésAdd yourself to key vault access policy

Si vous souhaitez afficher les secrets du coffre de clés ou si vous suivez les étapes de la démonstration, vous devez ajouter une stratégie d’accès pour votre ID Azure Active Directory.If you want to view the key vault's secrets or if you're working through the demo steps, you need to add an access policy for your Azure Active Directory ID. Les étapes suivantes vous guident tout au long de l’ajout d’une stratégie d’accès à un coffre de clés en tant qu’utilisateur :The following steps walk you through adding to the key vault an access policy for yourself as a user:

  1. Accédez au portail Azure.Browse to the Azure portal.

  2. Dans la zone de recherche principale de la page, entrez key vaults, puis sous Services , sélectionnez Coffres de clés .In the page's main search box, enter key vaults, and under Services , select Key vaults .

  3. Sélectionnez le coffre de clés créé dans la section précédente.Select the key vault created in the previous section. (Le nom a été imprimé dans stdout à partir du playbook.)(The name was printed to stdout from the playbook.)

  4. Sélectionnez Stratégies d’accès .Select Access policies .

  5. Une stratégie d’accès unique s’affiche avec votre ID Azure Active Directory qui représente le principal de service spécifié.A single access policy is displayed with your Azure Active Directory ID that represents your specified service principal.

  6. Sélectionnez Ajouter une stratégie d’accès .Select Add Access Policy .

  7. Sélectionnez Sélectionner le principal .Select Select principal .

  8. Sous l’onglet Principal , dans la zone de recherche, entrez votre adresse e-mail.In the Principal tab, in the search box, enter your email address.

  9. Dans la liste filtrée, sélectionnez l’entrée appropriée.From the filtered list, select the appropriate entry.

  10. Les informations de l’utilisateur sélectionné sont copiées dans la liste Membre sélectionné .The information for the selected user is copied to the Selected member list. Sélectionnez Sélectionner .Select Select .

  11. Sélectionnez les options appropriées pour Autorisations de clé , Autorisations du secret et Autorisations de certificat .Select the appropriate options for Key permissions , Secret permissions , and Certificate permissions . Pour cette démonstration, il suffit de sélectionner Autorisations du secret , puis Get , List et Set .For this demo, it's enough to select Secret permissions and then Get , List , and Set .

  12. Sélectionnez Ajouter .Select Add .

  13. La nouvelle stratégie d’accès de l’utilisateur sélectionné s’affiche à présent dans la page Stratégies d’accès .The new access policy for the selected user now displays on the Access policies page.

  14. Sélectionnez Enregistrer .Select Save .

  15. Sélectionnez Notifications dans le coin supérieur droit du portail.Select the Notifications in the upper right corner of the portal. Attendez la mise à jour de la stratégie d’accès avant de passer à l’étape suivante.Wait until the access policy has been updated before continuing to the next step.

Créer un secret Key VaultCreate a key vault secret

L’extrait de code de playbook Ansible suivant montre comment créer un secret de coffre de clés :The following Ansible playbook snippet shows how to create a key vault secret:

  vars:
    kv_secret_name: testsecret
    kv_secret_value: MySecret007$

  tasks:
    - name: Set facts
      set_fact:
        az_client_id: "{{ lookup('env', 'AZ_CLIENT_ID') }}"

    - name: Create a secret
      azure_rm_keyvaultsecret:
        subscription_id: "{{ az_sub_id }}"
        client_id: "{{ az_client_id }}"
        keyvault_uri: "{{ kv_uri }}"
        secret_name: "{{ kv_secret_name }}"
        secret_value: "{{ kv_secret_value }}"

Remarques :Notes:

  • Le module azure_rm_keyvaultsecret est utilisé pour créer le secret du coffre de clés.The azure_rm_keyvaultsecret module is used to create the key vault secret.
  • Pour plus de simplicité, la démonstration inclut secret_name et secret_value.For simplicity, the demo includes the secret_name and secret_value. Toutefois, les playbooks sont des fichiers d’infrastructure en tant que code (IaC) comme n’importe quel code source pour votre projet.However, playbooks are infrastructure-as-code (IaC) files just like any source code for your project. Par conséquent, les valeurs telles que celles-ci ne doivent pas être stockées dans des fichiers en texte clair lorsqu’elles sont utilisées dans des environnements de production.As such, values such as these shouldn't be stored in plaintext files when used in production environments.
  • Après l’exécution de ce code, l’onglet Secrets pour le coffre de clés répertorie le secret que vous venez d’ajouter nommé testsecret.After running this code, the Secrets tab for the key vault lists the newly added secret named testsecret. Pour l’afficher, sélectionnez le secret, sélectionnez la version actuelle et sélectionnez Afficher la valeur du secret .To view it, select the secret, select the current version, and select Show Secret Value .

Obtenir un secret de coffre de clésGet a key vault secret

L’extrait de code de playbook Ansible suivant montre comment obtenir la dernière version d’un secret de coffre de clés :The following Ansible playbook snippet shows how to get the latest version of a key vault secret:

  vars:
    kv_secret_name: testsecret
    kv_secret_value: MySecret007$

tasks:
    - name: Get latest version of a secret
      azure_rm_keyvaultsecret_info:
        vault_uri: "{{ kv_uri }}"
        name: "{{ kv_secret_name }}"
      register: output
    - debug:
        var: output['secrets'][0]['secret']

Remarques :Notes:

  • Le module azure_rm_keyvaultsecret_info est utilisé pour obtenir le secret du coffre de clés.The azure_rm_keyvaultsecret_info module is used to get the key vault secret. Ce module est disponible uniquement si vous utilisez la collection Ansible pour les modules Azure.This module is only available if using the Ansible collection for Azure modules.
  • Si vous recevez une erreur lors de l’exécution de cet extrait de code, vérifiez que vous avez suivi toutes les instructions de la section Conditions préalables.If you receive an error running this snippet, ensure that you've followed all the instructions in the Prerequisites section.
  • Pour plus de simplicité, la démonstration inclut secret_name et secret_value.For simplicity, the demo includes the secret_name and secret_value. Toutefois, les playbooks sont des fichiers d’infrastructure en tant que code (IaC) comme n’importe quel code source pour votre projet.However, playbooks are infrastructure-as-code (IaC) files just like any source code for your project. Par conséquent, les valeurs telles que celles-ci ne doivent pas être stockées dans des fichiers en texte clair lorsqu’elles sont utilisées dans des environnements de production.As such, values such as these shouldn't be stored in plaintext files when used in production environments.

Exécuter le playbook completRun the complete playbook

Une fois que vous avez créé le coffre de clés et son secret, vous pouvez utiliser ces informations lors de la protection de ressources Azure telles que les machines virtuelles.Once you have the key vault and its secret established, you can use that information when protecting Azure resources such as virtual machines. Le playbook Ansible suivant effectue les tâches présentées dans ce tutoriel et crée une machine virtuelle complète.The following Ansible playbook performs the tasks shown throughout this tutorial and creates a complete virtual machine.

---
- hosts: localhost
  tasks:
    - name: Prepare random postfix
      set_fact:
        rpfx: "{{ 10000 | random }}"
      run_once: yes
      
- hosts: localhost
  collections:
    - azure.azcollection
  vars:
    kv_rg: kv_rg_{{ rpfx }}
    kv_rg_loc: eastus
    kv: "kv{{ rpfx }}"
    kv_uri: "https://{{ kv }}.vault.azure.net"
    kv_secret_name: testsecret
    kv_secret_value: MySecret007$

    # Test VM vars
    test_vm_rg: kv_test_vm_rg
    test_vm_rg_loc: eastus
    test_vm: kvtestvm
    test_vm_vnet: "kv_test_vm_vnet"
    test_vm_subnet: kv_test_vm_subnet
    test_vm_public_ip: kv_test_vm_public_ip
    test_vm_nsg: kv_test_vm_nsg
    test_vm_nsg_list: 
      - name: Allow-SSH
        access: Allow
        protocol: Tcp
        direction: Inbound
        priority: 300
        port: 22 
        source_address_prefix: Internet
      - name: Allow-HTTP
        access: Allow
        protocol: Tcp
        direction: Inbound
        priority: 100
        port: 80
        source_address_prefix: Internet 
    test_vm_nic: kv_test_vnic
    admin_username: testadmin

  tasks:
    - name: Set facts
      set_fact:
        az_sub_id: "{{ lookup('env', 'AZ_SUBSCRIPTION_ID') }}"
        az_object_id: "{{ lookup('env', 'AZ_OBJECT_ID') }}"
        az_tenant_id: "{{ lookup('env', 'AZ_TENANT_ID') }}"
        az_client_id: "{{ lookup('env', 'AZ_CLIENT_ID') }}"

    - name: Create a resource group to hold the Key Vault instance
      azure_rm_resourcegroup:
        subscription_id: "{{ az_sub_id }}"
        name: "{{ kv_rg }}"
        location: "{{ kv_rg_loc }}"

    - debug:
        msg: "New resource group = {{ kv_rg }}"

    - name: Create instance of Key Vault
      azure_rm_keyvault:
        subscription_id: "{{ az_sub_id }}"
        resource_group: "{{ kv_rg }}"
        vault_name: "{{ kv }}"
        vault_tenant: "{{ az_tenant_id }}"
        enabled_for_deployment: yes
        sku:
          name: standard
          family: A
        access_policies:
          - object_id: "{{ az_object_id }}"
            tenant_id: "{{ az_tenant_id }}"
            secrets:
              - get
              - list
              - set

    - debug:
        msg: "New Key Vault instance name = {{ kv }} within the {{ kv_rg }} resource group"

    - name: Create a secret
      azure_rm_keyvaultsecret:
        subscription_id: "{{ az_sub_id }}"
        client_id: "{{ az_client_id }}"
        keyvault_uri: "{{ kv_uri }}"
        secret_name: "{{ kv_secret_name }}"
        secret_value: "{{ kv_secret_value }}"

    - name: Register Key Vault provider.
      shell:
        az provider register -n Microsoft.KeyVault

    - name: Get latest version of a secret
      azure_rm_keyvaultsecret_info:
        vault_uri: "{{ kv_uri }}"
        name: "{{ kv_secret_name }}"
      register: output
    - debug:
        var: output['secrets'][0]['secret']

    - name: Create resource group for test VM.
      azure_rm_resourcegroup:
        subscription_id: "{{ az_sub_id }}"
        name: "{{ test_vm_rg }}"
        location: "{{ test_vm_rg_loc }}"

    - name: Create virtual network.
      azure_rm_virtualnetwork:
        subscription_id: "{{ az_sub_id }}"
        resource_group: "{{ test_vm_rg }}"
        name: "{{ test_vm_vnet }}"
        address_prefixes: "172.16.0.0/16"

    - name: Create subset within virtual network.
      azure_rm_subnet:
        subscription_id: "{{ az_sub_id }}"
        resource_group: "{{ test_vm_rg }}"
        virtual_network_name: "{{ test_vm_vnet }}"
        name: "{{ test_vm_subnet }}"
        address_prefix_cidr:  "172.16.10.0/24"

    - name: Create public IP address.
      azure_rm_publicipaddress:
        subscription_id: "{{ az_sub_id }}"
        resource_group: "{{ test_vm_rg }}"
        allocation_method: Static
        name: "{{ test_vm_public_ip }}"

    - name: Create Network Security Group and rules.
      azure_rm_securitygroup:
        subscription_id: "{{ az_sub_id }}"
        resource_group: "{{ test_vm_rg }}"
        name: "{{ test_vm_nsg}}"
        rules:
          - name: "{{ item.name }}"
            access: "{{ item.access }}"
            protocol: "{{ item.protocol }}"
            direction: "{{ item.direction }}"
            destination_port_range: "{{ item.port }}"
            priority: "{{ item.priority }}"
            source_address_prefix: "{{ item.source_address_prefix }}"
      loop: "{{ test_vm_nsg_list }}"

    - name: Create virtual network interface card (NIC).
      azure_rm_networkinterface:
        subscription_id: "{{ az_sub_id }}"
        resource_group: "{{ test_vm_rg }}"
        name: "{{ test_vm_nic }}"
        virtual_network: "{{ test_vm_vnet }}"
        subnet: "{{ test_vm_subnet }}"
        ip_configurations:
          - name: ipconfig
            public_ip_address_name: "{{ test_vm_public_ip }}"
            primary: yes
        security_group: "{{ test_vm_nsg }}"

    - name: Create virtual machine.
      azure_rm_virtualmachine:
        subscription_id: "{{ az_sub_id }}"
        resource_group: "{{ test_vm_rg }}"
        name: "{{ test_vm }}"
        admin_username: " {{ admin_username }} "
        admin_password: " {{ output['secrets'][0]['secret'] }}"
        vm_size: Standard_B1ms
        network_interfaces: "{{ test_vm_nic }}"
        image:
          offer: UbuntuServer
          publisher: Canonical
          sku: 16.04-LTS
          version: latest

Remarques :Notes:

Nettoyer les ressourcesClean up resources

Lorsque vous n’en avez plus besoin, supprimez les ressources créées dans cet article.When no longer needed, delete the resources created in this article. Remplacez l’espace réservé <kv_rg> par le groupe de ressources utilisé pour contenir le coffre de clés de démonstration.Replace the <kv_rg> placeholder with the resource group used to hold the demo key vault.

- hosts: localhost  
  vars: 
    kv_rg: <kv_rg>  
    test_vm_rg: kv_test_vm_rg   
  tasks:    
    - name: Delete the key vault resource group 
      azure_rm_resourcegroup:   
        name: "{{ kv_rg }}" 
        force_delete_nonempty: yes  
        state: absent   
    - name: Delete the test vm resource group   
      azure_rm_resourcegroup:   
        name: "{{ test_vm_rg }}"    
        force_delete_nonempty: yes  
        state: absent

Étapes suivantesNext steps