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

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 sont une fonctionnalité Azure qui vous permet de configurer un groupe de machines virtuelles identiques à charge équilibrée. Il n’existe aucun coût supplémentaire pour les ensembles de mise à l'échelle et ils sont construits à partir de machines virtuelles. Vous payez uniquement pour les ressources de calcul sous-jacentes telles que les instances de machine virtuelle, les équilibreurs de charge ou le stockage sur disque managé. Avec les jeux de mise à l'échelle, les couches de gestion et d’automatisation sont fournies pour exécuter et mettre à l’échelle vos applications. Vous pouvez à la place créer et gérer manuellement des machines virtuelles individuelles. Toutefois, il y a deux avantages clés à l’utilisation des ensembles de mise à l'échelle. Ils sont intégrés à Azure et mettent automatiquement à l'échelle vos machines virtuelles pour répondre aux besoins des applications.

Dans cet article, vous allez apprendre à :

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

Prerequisites

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

Installez Ansible : Effectuez l’une des options suivantes :
- Installer et configurer 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.

Paramétrer un jeu d'échelons

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

Groupe de ressources dans lequel toutes vos 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 sur Internet
Groupe de sécurité réseau qui contrôle le flux de trafic réseau entrant et sortant de votre ensemble de machines
Équilibreur de charge qui distribue le trafic sur un ensemble de machines virtuelles définies à l’aide de règles d’équilibreur de charge
Groupe de machines virtuelles identiques qui utilise toutes les ressources créées

Il existe deux méthodes pour obtenir l’exemple de playbook :

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 manuel, lisez les notes suivantes :

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

Exécuter le playbook à l’aide d’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

Afficher le nombre d’instances de machine virtuelle

Le ensemble d'échelles configuré comporte actuellement deux instances. Les étapes suivantes sont utilisées pour confirmer cette valeur :

Connectez-vous au portail Azure.
Accédez au groupe de mise à l'échelle que vous avez configuré.
Vous voyez le nom du jeu d'échelles 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}' 
```
Les résultats de l’exécution de la commande Azure CLI dans Cloud Shell montrent que deux instances existent :
```
{
  "capacity": 2,
}
```

Effectuer une mise à l'échelle horizontale d'un ensemble de mises à l'échelle.

Le code du playbook de cette section récupère des informations sur l'ensemble de machines virtuelles et augmente sa capacité de deux à trois.

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

Téléchargez le playbook et sauvegardez-le dans 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écuter le playbook avec Ansible-playbook

ansible-playbook vmss-scale-out.yml

Après avoir exécuté le playbook, vous voyez un résultat 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 les résultats de votre travail via le portail Azure :

Connectez-vous au portail Azure.
Accédez à l'ensemble de machines virtuelles que vous avez configuré.
Vous voyez le nom de l'ensemble de machines virtuelles 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}' 
```
Les résultats de l’exécution de la commande Azure CLI dans Cloud Shell montrent que trois instances existent maintenant :
```
{
  "capacity": 3,
}
```

Étapes suivantes

Tutoriel : Déployer des applications sur des groupes de machines virtuelles identiques dans Azure à l’aide d’Ansible

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-10-10