Tutorial: Configurar conjuntos de dimensionamento de máquina virtual no Azure usando o Ansible

Artigo
10/23/2023

Importante

O Ansible 2.9 (ou posterior) é necessário para executar os playbooks de exemplo neste artigo.

Os conjuntos de dimensionamento de máquina virtual do Azure são um recurso do Azure que permite configurar um grupo de VMs idênticas com balanceamento de carga. Não há custo adicional para dimensionar conjuntos e eles são criados a partir de máquinas virtuais. Você paga apenas pelos recursos de computação subjacentes, como instâncias de VM, balanceadores de carga ou armazenamento em disco gerenciado. Nos conjuntos de dimensionamento, as camadas de gestão e automatização são fornecidas para executar e dimensionar as suas aplicações. Em vez disso, você pode criar e gerenciar manualmente VMs individuais. No entanto, há dois benefícios principais no uso de conjuntos de escalas. Eles são incorporados ao Azure e dimensionam automaticamente suas máquinas virtuais para atender às necessidades do aplicativo.

Neste artigo, vai aprender a:

Configurar os recursos para uma VM
Configurar um conjunto de escalas
Dimensione a escala definida aumentando suas instâncias de VM

Pré-requisitos

Subscrição do Azure: se não tem uma subscrição do Azure, crie uma conta gratuita antes de começar.

Instale o Ansible: execute uma das seguintes opções:
- Instalar e configurar o Ansible em uma máquina virtual Linux
- Configure o Azure Cloud Shell e, se você não tiver acesso a uma máquina virtual Linux, crie uma máquina virtual com o Ansible.

Configurar um conjunto de escalas

O código do playbook nesta seção define os seguintes recursos:

Grupo de recursos no qual todos os seus recursos serão implantados.
Rede virtual no espaço de endereços: 10.0.0.0/16
Sub-rede dentro da rede virtual
Endereço IP público que lhe permite aceder aos recursos na internet
Grupo de segurança de rede que controla o fluxo de tráfego de rede dentro e fora do seu conjunto de escala
Balanceador de carga que distribui o tráfego por um conjunto de VMs definidas através das regras do balanceador de carga
Conjunto de dimensionamento de máquinas virtuais que utiliza todos os recursos criados

Há duas maneiras de obter o manual de exemplo:

Baixe o playbook e salve o arquivo como vmss-create.yml.
Crie um novo ficheiro com o nome vmss-create.yml. Insira o seguinte código no novo arquivo:

- 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

Antes de executar o playbook, consulte as seguintes notas:

vars Na seção, substitua o espaço reservado {{ admin_password }} por sua própria senha.

Execute o playbook usando o ansible-playbook

ansible-playbook vmss-create.yml

Depois de executar o playbook, você verá uma saída semelhante aos seguintes resultados:

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

Exibir o número de instâncias de VM

O conjunto de escala configurado atualmente tem duas instâncias. As etapas a seguir são usadas para confirmar esse valor:

Inicie sessão no portal do Azure.
Navegue até o conjunto de escala que você configurou.
Você vê o nome do conjunto de escala com o número de instâncias entre parênteses: Standard_DS1_v2 (2 instances)
Você também pode verificar o número de instâncias com o Azure Cloud Shell executando o seguinte comando:
```
az vmss show -n myScaleSet -g myResourceGroup --query '{"capacity":sku.capacity}' 
```
Os resultados da execução do comando da CLI do Azure no Cloud Shell mostram que existem duas instâncias:
```
{
  "capacity": 2,
}
```

Dimensionar um conjunto de escalas

O código do playbook nesta seção recupera informações sobre o conjunto de escalas e altera sua capacidade de dois para três.

Há duas maneiras de obter o manual de exemplo:

Faça o download do playbook e salve-o em vmss-scale-out.yml.
Crie um novo ficheiro com o nome vmss-scale-out.yml. Insira o seguinte código no novo arquivo:

---
- 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 }}"

Execute o playbook usando o ansible-playbook

ansible-playbook vmss-scale-out.yml

Depois de executar o playbook, você verá uma saída semelhante aos seguintes resultados:

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

Verificar os resultados

Verifique os resultados do seu trabalho através do portal do Azure:

Inicie sessão no portal do Azure.
Navegue até o conjunto de escala que você configurou.
Você vê o nome do conjunto de escala com o número de instâncias entre parênteses: Standard_DS1_v2 (3 instances)
Também pode verificar a alteração com o Azure Cloud Shell, executando o seguinte comando:
```
az vmss show -n myScaleSet -g myResourceGroup --query '{"capacity":sku.capacity}' 
```
Os resultados da execução do comando da CLI do Azure no Cloud Shell mostram que agora existem três instâncias:
```
{
  "capacity": 3,
}
```

Próximos passos

Tutorial: Implementar aplicações em conjuntos de dimensionamento de máquinas virtuais no Azure com o Ansible

Partilhar via