Condividi tramite

Esercitazione: Aggiornare l'immagine personalizzata dei set di scalabilità di macchine virtuali di Azure usando Ansible

Importante

Ansible 2.8 (o versione successiva) è necessario per eseguire i playbook di esempio in questo articolo.

I set di scalabilità di macchine virtuali di Azure sono una funzionalità di Azure che consente di configurare un gruppo di macchine virtuali identiche con bilanciamento del carico. Non sono previsti costi aggiuntivi per i set di scalabilità e vengono creati da macchine virtuali. Si paga solo per le risorse di calcolo sottostanti, ad esempio le istanze di macchina virtuale, i servizi di bilanciamento del carico o l'archiviazione su disco gestito. Con i set di scalabilità, i livelli di gestione e automazione vengono forniti per l'esecuzione e la scalabilità delle applicazioni. È invece possibile creare e gestire manualmente singole macchine virtuali. Esistono tuttavia due vantaggi principali per l'uso dei set di scalabilità. Sono integrati in Azure e ridimensionano automaticamente le macchine virtuali per soddisfare le esigenze dell'applicazione.

Dopo aver distribuito una macchina virtuale, configurare la macchina virtuale con il software necessario per l'app. Anziché eseguire questa attività di configurazione per ogni macchina virtuale, è possibile creare un'immagine personalizzata. Un'immagine personalizzata è uno snapshot di una macchina virtuale esistente che include qualsiasi software installato. Quando si configura un set di scalabilità, si specifica l'immagine da usare per le macchine virtuali del set di scalabilità. Usando un'immagine personalizzata, ogni istanza di macchina virtuale è configurata in modo identico per l'app. In alcuni casi, potrebbe essere necessario aggiornare l'immagine personalizzata del set di scalabilità. Questa attività è l'obiettivo di questa esercitazione.

In questo articolo vengono illustrate le operazioni seguenti:

  • Configurare due macchine virtuali con HTTPD
  • Creare un'immagine personalizzata da una macchina virtuale esistente
  • Creare un set di scalabilità da un'immagine
  • Aggiornare l'immagine personalizzata

Prerequisiti

  • Sottoscrizione di Azure: se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Configurare due macchine virtuali

Il codice del playbook in questa sezione crea due macchine virtuali con HTTPD installato in entrambi.

La index.html pagina per ogni macchina virtuale visualizza una stringa di test:

  • La prima macchina virtuale visualizza il valore Image A
  • La seconda macchina virtuale visualizza il valore Image B

Questa stringa è destinata a simulare la configurazione di ogni macchina virtuale con software diverso.

Esistono due modi per ottenere il playbook di esempio:

  • Scarica il playbook e salvalo in create_vms.yml.

  • Creare un file denominato create_vms.yml. Inserire il codice seguente nel nuovo file.

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

Eseguire il playbook usando il comando ansible-playbook e sostituendo myrg con il nome del gruppo di risorse.

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

A causa delle debug sezioni del playbook, il ansible-playbook comando stamperà l'indirizzo IP di ogni macchina virtuale. Copiare questi indirizzi IP per usarli in un secondo momento.

Connettersi alle due macchine virtuali

In questa sezione ci si connette a ogni macchina virtuale. Come accennato nella sezione precedente, le stringhe Image A e Image B simulano la presenza di due macchine virtuali distinte con configurazioni diverse.

Usando gli indirizzi IP della sezione precedente, aprire un browser e connettersi a ogni macchina virtuale.

Creare immagini da ogni macchina virtuale

A questo punto, sono disponibili due macchine virtuali con configurazioni leggermente diverse (i relativi index.html file).

Il codice del playbook in questa sezione crea un'immagine personalizzata per ogni macchina virtuale:

  • image_vmforimageA - Immagine personalizzata creata per la macchina virtuale visualizzata Image A nella home page.
  • image_vmforimageB - Immagine personalizzata creata per la macchina virtuale visualizzata Image B nella home page.

Esistono due modi per ottenere il playbook di esempio:

  • Scarica il playbook e salvalo in capture-images.yml.

  • Creare un file denominato capture-images.yml. Inserire il codice seguente nel nuovo file:

- 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

Eseguire il playbook utilizzando il comando ansible-playbook, sostituendo myrg con il nome del gruppo di risorse:

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

Creare un set di dimensionamento utilizzando l'immagine A

In questa sezione viene usato un playbook per configurare le risorse di Azure seguenti:

  • Indirizzo IP pubblico
  • Bilanciamento del carico
  • Set di scalabilità che fa riferimento image_vmforimageA

Esistono due modi per ottenere il playbook di esempio:

  • Scarica il playbook e salvalo in create-vmss.yml.

  • Creare un file denominato create-vmss.yml. Inserire il codice seguente nel nuovo file:

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

Eseguire il playbook usando il comando ansible-playbook, sostituendo myrg con il nome del gruppo di risorse:

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

A causa della debug sezione del playbook, il ansible-playbook comando stamperà l'indirizzo IP del set di scalabilità. Copiare questo indirizzo IP per usarlo in un secondo momento.

Connettersi al set di scalabilità

Usando l'indirizzo IP della sezione precedente, connettersi al set di scalabilità.

Come accennato nella sezione precedente, le stringhe Image A e Image B simulano la presenza di due macchine virtuali distinte con configurazioni diverse.

Il set di scalabilità fa riferimento all'immagine personalizzata denominata image_vmforimageA. L'immagine image_vmforimageA personalizzata è stata creata dalla macchina virtuale la cui home page visualizza Image A.

Di conseguenza, viene visualizzata una home page che visualizza Image A.

Lasciare aperta la finestra del browser mentre si continua con la sezione successiva.

Modificare l'immagine personalizzata nei set di scalabilità e aggiornare le istanze

Il codice del playbook in questa sezione cambia l'immagine del set di scalabilità da image_vmforimageA a image_vmforimageB. Inoltre, tutte le macchine virtuali correnti distribuite dal set di scalabilità vengono aggiornate.

Esistono due modi per ottenere il playbook di esempio:

  • Scarica il playbook e salvalo in update-vmss-image.yml.

  • Creare un file denominato update-vmss-image.yml. Inserire il codice seguente nel nuovo file:

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

Eseguire il playbook usando il comando ansible-playbook e sostituendo myrg con il nome del gruppo di risorse.

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

Tornare al browser e aggiornare la pagina per verificare che l'immagine personalizzata sottostante della macchina virtuale sia aggiornata.

Pulire le risorse

  1. Salvare il codice seguente come delete_rg.yml.

    ---
- hosts: localhost
  tasks:
    - name: Deleting resource group - "{{ name }}"
      azure_rm_resourcegroup:
        name: "{{ name }}"
        state: absent
      register: rg
    - debug:
        var: rg

  2. Esegui il playbook usando il comando ansible-playbook. Sostituire il segnaposto con il nome del gruppo di risorse da eliminare. Tutte le risorse all'interno del gruppo di risorse verranno eliminate.

    ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"

    Punti chiave:

    • A causa della variabile register e della sezione debug del playbook, i risultati vengono visualizzati al termine del comando.

Passaggi successivi

Ansible in Azure

  • Last updated on