Tutorial: Atualizar a imagem personalizada dos conjuntos de escala de máquina virtual do Azure usando o Ansible

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.

Depois que uma VM é implantada, você configura a VM com o software de que seu aplicativo precisa. Em vez de executar 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 escalas, você especifica a imagem a ser usada para as VMs desse conjunto de escalas. Usando uma imagem personalizada, cada instância de VM é configurada de forma idêntica para seu aplicativo. Às vezes, pode ser necessário atualizar a imagem personalizada do conjunto de escalas. Essa tarefa é o foco deste tutorial.

Neste artigo, vai aprender a:

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

O código do playbook 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

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

Há duas maneiras de obter o manual de exemplo:

• Faça o download do playbook e salve-o em create_vms.yml.

• Crie um novo ficheiro com o nome create_vms.yml. Insira o seguinte código 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 inteface 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 playbook usando o comando, substituindo myrg pelo nome do ansible-playbook grupo de recursos:

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

Devido às debug seções do playbook, 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 conecta a cada VM. Como mencionado na seção anterior, as cadeias de caracteres e Image B imitam ter duas VMs distintas Image A 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 playbook nesta seção cria uma imagem personalizada para cada VM:

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

Há duas maneiras de obter o manual de exemplo:

• Faça o download do playbook e salve-o em capture-images.yml.

• Crie um novo ficheiro com o nome 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 playbook usando o comando, substituindo myrg pelo nome do ansible-playbook 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 manual é usado para configurar os seguintes recursos do Azure:

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

Há duas maneiras de obter o manual de exemplo:

• Faça o download do playbook e salve-o em create-vmss.yml.

• Crie um novo ficheiro com o nome 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 playbook usando o comando, substituindo myrg pelo nome do ansible-playbook grupo de recursos:

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

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

Conecte-se ao conjunto de escalas

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

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

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

Como resultado, você verá uma home page que exibe Image Ao .

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

Alterar imagem personalizada em dimensionamento, conjunto e instâncias de atualização

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

Há duas maneiras de obter o manual de exemplo:

• Faça o download do playbook e salve-o em update-vmss-image.yml.

• Crie um novo ficheiro com o nome 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 playbook usando o comando, substituindo myrg pelo nome do ansible-playbook 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.

Clean up resources (Limpar recursos)

Próximos passos