Tutoriel : Configurer des groupes de machines virtuelles identiques dans Azure à l’aide d’Ansible

Article
06/08/2023

Important

Ansible 2.9 (ou version ultérieure) est nécessaire pour exécuter les exemples de playbooks dans cet article.

Les groupes de machines virtuelles identiques Azure constituent une fonctionnalité Azure qui vous permet de configurer un groupe de machines virtuelles identiques à charge équilibrée. Les groupes identiques n’engendrent pas de coût supplémentaire et sont générés à partir des machines virtuelles. Vous payez uniquement les ressources de calcul sous-jacentes telles que les instances de machine virtuelle, un équilibreur de charge ou un stockage par disque managé. Avec les groupes identiques, les couches d’automatisation et de gestion sont fournies pour exécuter et faire évoluer vos applications. Vous pouvez à la place créer et gérer manuellement des machines virtuelles individuelles. Toutefois, l’utilisation de groupes identiques présente deux avantages principaux. Ils sont intégrés à Azure et appliquent automatiquement une mise à l’échelle à vos machines virtuelles pour répondre aux besoins des applications.

Dans cet article, vous apprendrez comment :

Configurer les ressources d’une machine virtuelle
Configurer un groupe identique
Mettre à l’échelle le groupe identique en augmentant ses instances de machines virtuelles

Prérequis

Abonnement Azure : Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Installer Ansible. Pour cela, choisissez l’une des options suivantes :
- Installez et configurez Ansible sur une machine virtuelle Linux
- Configurez Azure Cloud Shell et, si vous n’avez pas accès à une machine virtuelle Linux, créez une machine virtuelle avec Ansible.

Configurer un groupe identique

Le code de playbook dans cette section définit les ressources suivantes :

Groupe de ressources dans lequel toutes les ressources seront déployées
Réseau virtuel dans l’espace d’adressage 10.0.0.0/16
Sous-réseau au sein du réseau virtuel
Adresse IP publique qui vous permet d’accéder aux ressources via Internet
Groupe de sécurité réseau qui contrôle le flux du trafic réseau en direction et en provenance du groupe identique
Équilibreur de charge qui répartit le trafic sur un ensemble de machines virtuelles définies en utilisant des règles d’équilibreur de charge.
Groupe de machines virtuelles identiques qui utilise toutes les ressources créées

Il existe deux façons d’obtenir le playbook de l’exemple :

Téléchargez le playbook et enregistrez le fichier sous vmss-create.yml.
Créez un nouveau fichier appelé vmss-create.yml. Insérez le code suivant dans le nouveau fichier :

- hosts: localhost
  vars:
    resource_group: myResourceGroup
    vmss_name: myvmscalesetname
    vmss_lb_name: myScaleSetLb
    location: eastus
    admin_username: azureuser
    admin_password: "{{ admin_password }}"

  tasks:
    - name: Create a resource group
      azure_rm_resourcegroup:
        name: "{{ resource_group }}"
        location: "{{ location }}"
    - name: Create virtual network
      azure_rm_virtualnetwork:
        resource_group: "{{ resource_group }}"
        name: "{{ vmss_name }}"
        address_prefixes: "10.0.0.0/16"
    - name: Add subnet
      azure_rm_subnet:
        resource_group: "{{ resource_group }}"
        name: "{{ vmss_name }}"
        address_prefix: "10.0.1.0/24"
        virtual_network: "{{ vmss_name }}"
    - name: Create public IP address
      azure_rm_publicipaddress:
        resource_group: "{{ resource_group }}"
        allocation_method: Static
        name: "{{ vmss_name }}"
    - name: Create Network Security Group that allows SSH
      azure_rm_securitygroup:
        resource_group: "{{ resource_group }}"
        name: "{{ vmss_name }}"
        rules:
          - name: SSH
            protocol: Tcp
            destination_port_range: 22
            access: Allow
            priority: 1001
            direction: Inbound

    - name: Create a load balancer
      azure_rm_loadbalancer:
        resource_group: "{{ resource_group }}"
        name: "{{ vmss_name }}lb"
        location: "{{ location }}"
        frontend_ip_configurations:
          - name: "{{ vmss_name }}front-config"
            public_ip_address: "{{ vmss_name }}"
        backend_address_pools:
          - name: "{{ vmss_name }}backend-pool"
        probes:
          - name: "{{ vmss_name }}prob0"
            port: 8080
            interval: 10
            fail_count: 3
        inbound_nat_pools:
          - name: "{{ vmss_name }}nat-pool"
            frontend_ip_configuration_name: "{{ vmss_name }}front-config"
            protocol: Tcp
            frontend_port_range_start: 50000
            frontend_port_range_end: 50040
            backend_port: 22
        load_balancing_rules:
          - name: "{{ vmss_name }}lb-rules"
            frontend_ip_configuration: "{{ vmss_name }}front-config"
            backend_address_pool: "{{ vmss_name }}backend-pool"
            frontend_port: 80
            backend_port: 8080
            load_distribution: Default
            probe: "{{ vmss_name }}prob0"

    - name: Create VMSS
      no_log: true
      azure_rm_virtualmachinescaleset:
        resource_group: "{{ resource_group }}"
        name: "{{ vmss_name }}"
        vm_size: Standard_DS1_v2
        admin_username: "{{ admin_username }}"
        admin_password: "{{ admin_password }}"
        ssh_password_enabled: true
        capacity: 2
        virtual_network_name: "{{ vmss_name }}"
        subnet_name: "{{ vmss_name }}"
        upgrade_policy: Manual
        tier: Standard
        managed_disk_type: Standard_LRS
        os_disk_caching: ReadWrite
        image:
          offer: UbuntuServer
          publisher: Canonical
          sku: 16.04-LTS
          version: latest
        load_balancer: "{{ vmss_name }}lb"
        data_disks:
          - lun: 0
            disk_size_gb: 20
            managed_disk_type: Standard_LRS
            caching: ReadOnly
          - lun: 1
            disk_size_gb: 30
            managed_disk_type: Standard_LRS
            caching: ReadOnly

Avant d’exécuter le playbook, consultez les notes suivantes :

Dans la section vars, remplacez l’espace réservé {{ admin_password }} par votre propre mot de passe.

Exécutez le playbook en utilisant ansible-playbook

ansible-playbook vmss-create.yml

Après avoir exécuté le playbook, vous voyez une sortie similaire aux résultats suivants :

PLAY [localhost] 

TASK [Gathering Facts] 
ok: [localhost]

TASK [Create a resource group] 
changed: [localhost]

TASK [Create virtual network] 
changed: [localhost]

TASK [Add subnet] 
changed: [localhost]

TASK [Create public IP address] 
changed: [localhost]

TASK [Create Network Security Group that allows SSH] 
changed: [localhost]

TASK [Create a load balancer] 
changed: [localhost]

TASK [Create Scale Set] 
changed: [localhost]

PLAY RECAP 
localhost                  : ok=8    changed=7    unreachable=0    failed=0

Voir le nombre d’instances de machines virtuelles

Le groupe identique configuré comporte actuellement deux instances. Suivez les étapes ci-dessous pour vérifier cette valeur :

Connectez-vous au portail Azure.
Accédez au groupe identique que vous avez configuré.
Le nom du groupe identique apparaît avec le nombre d’instances entre parenthèses : Standard_DS1_v2 (2 instances).
Vous pouvez également vérifier le nombre d’instances avec Azure Cloud Shell en exécutant la commande suivante :
```
az vmss show -n myScaleSet -g myResourceGroup --query '{"capacity":sku.capacity}' 
```
La commande Azure CLI dans Cloud Shell montre qu’il existe deux instances :
```
{
  "capacity": 2,
}
```

Effectuer un scale-out d’un groupe identique

Le code du playbook de cette section récupère des informations sur le groupe identique et fait passer sa capacité de deux à trois.

Il existe deux façons d’obtenir le playbook de l’exemple :

Téléchargez le manifeste et enregistrez-le sous vmss-scale-out.yml.
Créez un nouveau fichier appelé vmss-scale-out.yml. Insérez le code suivant dans le nouveau fichier :

---
- hosts: localhost
  gather_facts: false
  
  vars:
    resource_group: myTestRG
    vmss_name: myTestVMSS
  
  tasks:

    - name: Get scaleset info
      azure_rm_virtualmachine_scaleset_facts:
        resource_group: "{{ resource_group }}"
        name: "{{ vmss_name }}"
        format: curated
      register: output_scaleset

    - name: set image fact
      set_fact:
        vmss_image: "{{ output_scaleset.vmss[0].image }}"

    - name: Create VMSS
      no_log: true
      azure_rm_virtualmachinescaleset:
        resource_group: "{{ resource_group }}"
        name: "{{ vmss_name }}"
        capacity: 3
        image: "{{ vmss_image }}"

Exécutez le playbook en utilisant ansible-playbook

ansible-playbook vmss-scale-out.yml

Après avoir exécuté le playbook, vous voyez une sortie similaire aux résultats suivants :

PLAY [localhost] 

TASK [Gathering Facts] 
ok: [localhost]

TASK [Get scaleset info] 
ok: [localhost]

TASK [Set image fact] 
ok: [localhost]

TASK [Change VMSS capacity] 
changed: [localhost]

PLAY RECAP 
localhost                  : ok=3    changed=1    unreachable=0    failed=0

Vérifier les résultats

Vérifiez le résultat de votre travail sur le Portail Azure :

Connectez-vous au portail Azure.
Accédez au groupe identique que vous avez configuré.
Le nom du groupe identique apparaît avec le nombre d’instances entre parenthèses : Standard_DS1_v2 (3 instances).
Vous pouvez également vérifier la modification avec Azure Cloud Shell en exécutant la commande suivante :
```
az vmss show -n myScaleSet -g myResourceGroup --query '{"capacity":sku.capacity}' 
```
La commande Azure CLI dans Cloud Shell montre qu’il existe maintenant trois instances :
```
{
  "capacity": 3,
}
```

Étapes suivantes

Tutoriel : Déployer des applications sur des groupes de machines virtuelles identiques dans Azure avec Ansible

Partage via