Tutorial: Atualizar a imagem personalizada dos conjuntos de dimensionamento de máquinas virtuais do Azure usando o Ansible

Os conjuntos de dimensionamento de máquinas virtuais do Azure são um recurso do Azure que permite configurar um grupo de VMs idênticas e com balanceamento de carga. Não há custo adicional para conjuntos de escalonamento, 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. Com conjuntos de escalas, são fornecidas camadas de gerenciamento e automação para executar e dimensionar seus aplicativos. Em vez disso, você pode criar e gerenciar VMs individuais manualmente. No entanto, há dois benefícios fundamentais para o uso de conjuntos de dimensionamento. Eles são integrados ao Azure e dimensionam automaticamente suas máquinas virtuais para atender às necessidades do aplicativo.

Depois que uma VM é implantada, você configura a VM com o software de que seu aplicativo precisa. Em vez de fazer essa tarefa de configuração para cada VM, você pode criar uma imagem personalizada. Uma imagem personalizada é um instantâneo de uma VM existente que inclui qualquer software instalado. Ao configurar um conjunto de dimensionamento, especifique a imagem a ser usada para as VMs desse conjunto de dimensionamento. Usando uma imagem personalizada, cada instância de VM é configurada de forma idêntica para seu aplicativo. Às vezes, talvez seja necessário atualizar a imagem personalizada do conjunto de dimensionamento. Essa tarefa é o foco deste tutorial.

Neste artigo, você aprenderá a:

Pré-requisitos

• Assinatura do Azure: Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

• Instalar 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 duas VMs

O código do guia estratégico nesta seção cria duas máquinas virtuais com HTTPD instalado em ambas.

A index.html página de cada VM exibe uma cadeia de caracteres de teste:

• A primeira VM exibe o valor Image A
• A segunda VM exibe o valor Image B

Essa cadeia de caracteres destina-se a imitar a configuração de cada VM com software diferente.

Há duas maneiras de obter o guia estratégico de exemplo:

• Baixe o guia estratégico e salve-o em create_vms.yml.

• Crie um arquivo chamado create_vms.yml. Insira o código a seguir no novo arquivo.

- name: Create two VMs (A and B) with HTTPS
  hosts: localhost
  connection: local
  vars:
    vm_name: vmforimage
    admin_username: testuser
    admin_password: Pass123$$$abx!
    location: eastus
  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: "{{ vm_name }}"
      address_prefixes: "10.0.0.0/16"

  - name: Create subnets for VM A and B
    azure_rm_subnet:
      resource_group: "{{ resource_group }}"
      virtual_network: "{{ vm_name }}"
      name: "{{ vm_name }}"
      address_prefix: "10.0.1.0/24"

  - name: Create Network Security Group that allows HTTP
    azure_rm_securitygroup:
      resource_group: "{{ resource_group }}"
      name: "{{ vm_name }}"
      rules:
        - name: HTTP
          protocol: Tcp
          destination_port_range: 80
          access: Allow
          priority: 1002
          direction: Inbound

  - name: Create public IP addresses for VM A and B
    azure_rm_publicipaddress:
      resource_group: "{{ resource_group }}"
      allocation_method: Static
      name: "{{ vm_name }}_{{ item }}"
    loop:
      - A
      - B
    register: pip_output

  - name: Create virtual network interface cards for VM A and B
    azure_rm_networkinterface:
      resource_group: "{{ resource_group }}"
      name: "{{ vm_name }}_{{ item }}"
      virtual_network: "{{ vm_name }}"
      subnet: "{{ vm_name }}"
      public_ip_name: "{{ vm_name }}_{{ item }}"
      security_group: "{{ vm_name }}"
    loop:
      - A
      - B

  - name: Create VM A and B
    azure_rm_virtualmachine:
      resource_group: "{{ resource_group }}"
      name: "{{ vm_name }}{{ item }}"
      admin_username: "{{ admin_username }}"
      admin_password: "{{ admin_password }}"
      vm_size: Standard_B1ms
      network_interfaces: "{{ vm_name }}_{{ item }}"
      image:
        offer: UbuntuServer
        publisher: Canonical
        sku: 16.04-LTS
        version: latest
    loop:
      - A
      - B

  - name: Create VM Extension
    azure_rm_virtualmachineextension:
      resource_group: "{{ resource_group }}"
      name: testVMExtension
      virtual_machine_name: "{{ vm_name }}{{ item }}"
      publisher: Microsoft.Azure.Extensions
      virtual_machine_extension_type: CustomScript
      type_handler_version: 2.0
      auto_upgrade_minor_version: true
      settings: {"commandToExecute": "sudo apt-get -y install apache2"}
    loop:
      - A
      - B

  - name: Create VM Extension
    azure_rm_virtualmachineextension:
      resource_group: "{{ resource_group }}"
      name: testVMExtension
      virtual_machine_name: "{{ vm_name }}{{ item }}"
      publisher: Microsoft.Azure.Extensions
      virtual_machine_extension_type: CustomScript
      type_handler_version: 2.0
      auto_upgrade_minor_version: true
      settings: {"commandToExecute": "printf '<html><body><h1>Image {{ item }}</h1></body></html>' >> index.html; sudo cp index.html /var/www/html/"}
    loop:
      - A
      - B

  - debug:
      msg: "Public IP Address A: {{ pip_output.results[0].state.ip_address }}"

  - debug:
      msg: "Public IP Address B: {{ pip_output.results[1].state.ip_address }}"

Execute o guia estratégico usando o ansible-playbook comando, substituindo myrg pelo nome do grupo de recursos:

ansible-playbook create-vms.yml --extra-vars "resource_group=myrg"

Devido às debug seções do guia estratégico, o ansible-playbook comando imprimirá o endereço IP de cada VM. Copie esses endereços IP para uso posterior.

Conectar-se às duas VMs

Nesta seção, você se conectará a cada VM. Conforme mencionado na seção anterior, as cadeias de caracteres Image A e Image B imitam ter duas VMs distintas com configurações diferentes.

Usando os endereços IP da seção anterior, abra um navegador e conecte-se a cada VM.

Criar imagens de cada VM

Neste ponto, você tem duas VMs com configurações ligeiramente diferentes (seus index.html arquivos).

O código do guia estratégico nesta seção cria uma imagem personalizada para cada VM:

• image_vmforimageA - Imagem personalizada criada para a VM que é exibida na sua página inicial.
• image_vmforimageB - Imagem personalizada criada para a VM que é exibida em sua página inicial Image B.

Há duas maneiras de obter o guia estratégico de exemplo:

• Baixe o guia estratégico e salve-o em capture-images.yml.

• Crie um arquivo chamado capture-images.yml. Insira o seguinte código no novo arquivo:

- name: Capture VM Images
  hosts: localhost
  connection: local
  vars:
    vm_name: vmforimage
  tasks:

  - name: Stop and generalize VMs
    azure_rm_virtualmachine:
      resource_group: "{{ resource_group }}"
      name: "{{ vm_name }}{{ item }}"
      generalized: yes
    loop:
      - A
      - B

  - name: Create an images from a VMs
    azure_rm_image:
      resource_group: "{{ resource_group }}"
      name: "image_{{ vm_name }}{{ item }}"
      source: "{{ vm_name }}{{ item }}"
    loop:
      - A
      - B

Execute o guia estratégico usando o ansible-playbook comando, substituindo myrg pelo nome do grupo de recursos:

ansible-playbook capture-images.yml --extra-vars "resource_group=myrg"

Criar conjunto de escalas usando a Imagem A

Nesta seção, um guia estratégico é usado para configurar os seguintes recursos do Azure:

• Endereço IP público
• Balanceador de carga
• Conjunto de dimensionamento que faz referência image_vmforimageA

Há duas maneiras de obter o guia estratégico de exemplo:

• Baixe o guia estratégico e salve-o em create-vmss.yml.

• Crie um arquivo chamado create-vmss.yml. Insira o seguinte código no novo arquivo:

---
- hosts: localhost
  vars:
    vmss_name: vmsstest
    location: eastus
    admin_username: vmssadmin
    admin_password: User123!!!abc
    vm_name: vmforimage
    image_name: "image_vmforimageA"

  tasks:

    - name: Create public IP address
      azure_rm_publicipaddress:
        resource_group: "{{ resource_group }}"
        allocation_method: Static
        name: "{{ vmss_name }}"
      register: pip_output

    - name: Create a load balancer
      azure_rm_loadbalancer:
        name: "{{ vmss_name }}lb"
        location: "{{ location }}"
        resource_group: "{{ resource_group }}"
        public_ip: "{{ vmss_name }}"
        probe_protocol: Tcp
        probe_port: 80
        probe_interval: 10
        probe_fail_count: 3
        protocol: Tcp
        load_distribution: Default
        frontend_port: 80
        backend_port: 80
        idle_timeout: 4
        natpool_frontend_port_start: 50000
        natpool_frontend_port_end: 50040
        natpool_backend_port: 22
        natpool_protocol: Tcp

    - name: Create a scale set
      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: "{{ vm_name }}"
        subnet_name: "{{ vm_name }}"
        upgrade_policy: Manual
        tier: Standard
        managed_disk_type: Standard_LRS
        os_disk_caching: ReadWrite
        image:
          name: "{{ image_name }}"
          resource_group: "{{ resource_group }}"
        load_balancer: "{{ vmss_name }}lb"

    - debug:
        msg: "Scale set public IP address: {{ pip_output.state.ip_address }}"

Execute o guia estratégico usando o ansible-playbook comando, substituindo myrg pelo nome do grupo de recursos:

ansible-playbook create-vmss.yml --extra-vars "resource_group=myrg"

Devido à debug seção do manual de operações, o comando ansible-playbook imprimirá o endereço IP do conjunto de escalonamento. Copie este endereço IP para uso posterior.

Conectar-se ao conjunto de escalas

Usando o endereço IP da seção anterior, conecte-se ao conjunto de escalas.

Conforme mencionado na seção anterior, as cadeias de caracteres Image A e Image B imitam ter duas VMs distintas com configurações diferentes.

O conjunto de dimensionamento faz referência à imagem personalizada chamada image_vmforimageA. A imagem image_vmforimageA personalizada foi criada a partir da VM cuja home page exibe Image A.

Como resultado, você verá uma página inicial exibida Image A.

Deixe a janela do navegador aberta enquanto você continua para a próxima seção.

Alterar a imagem personalizada no conjunto de escalas e atualizar instâncias

O código do guia estratégico nesta seção altera a imagem do conjunto de dimensionamento – de image_vmforimageA para image_vmforimageB. Além disso, todas as máquinas virtuais atuais implantadas pelo conjunto de escalas são atualizadas.

Há duas maneiras de obter o guia estratégico de exemplo:

• Baixe o guia estratégico e salve-o em update-vmss-image.yml.

• Crie um arquivo chamado update-vmss-image.yml. Insira o seguinte código no novo arquivo:

- name: Update scale set image reference
  hosts: localhost
  connection: local
  vars:
    vmss_name: vmsstest
    image_name: image_vmforimageB
    admin_username: vmssadmin
    admin_password: User123!!!abc
  tasks:

  - name: Update scale set - second image
    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: 3
      virtual_network_name: "{{ vmss_name }}"
      subnet_name: "{{ vmss_name }}"
      upgrade_policy: Manual
      tier: Standard
      managed_disk_type: Standard_LRS
      os_disk_caching: ReadWrite
      image:
        name: "{{ image_name }}"
        resource_group: "{{ resource_group }}"
      load_balancer: "{{ vmss_name }}lb"

  - name: List all of the instances
    azure_rm_virtualmachinescalesetinstance_facts:
      resource_group: "{{ resource_group }}"
      vmss_name: "{{ vmss_name }}"
    register: instances

  - debug:
      var: instances

  - name: manually upgrade all the instances 
    azure_rm_virtualmachinescalesetinstance:
      resource_group: "{{ resource_group }}"
      vmss_name: "{{ vmss_name }}"
      instance_id: "{{ item.instance_id }}"
      latest_model: yes
    with_items: "{{ instances.instances }}"

Execute o guia estratégico usando o ansible-playbook comando, substituindo myrg pelo nome do grupo de recursos:

ansible-playbook update-vmss-image.yml --extra-vars "resource_group=myrg"

Retorne ao navegador e atualize a página para ver se a imagem personalizada subjacente da máquina virtual está atualizada.

Limpar os recursos

Próximas etapas