Samouczek: aktualizowanie niestandardowego obrazu zestawów skalowania maszyn wirtualnych platformy Azure przy użyciu rozwiązania Ansible

Zestawy skalowania maszyn wirtualnych platformy Azure to funkcja platformy Azure, która umożliwia skonfigurowanie grupy identycznych maszyn wirtualnych o zrównoważonym obciążeniu. Zestawy skalowania nie mają dodatkowych kosztów i są tworzone na podstawie maszyn wirtualnych. Płacisz tylko za bazowe zasoby obliczeniowe, takie jak wystąpienia maszyn wirtualnych, moduły równoważenia obciążenia lub magazyn dysków zarządzanych. Zestawy skalowania udostępniają warstwy zarządzania i automatyzacji do uruchamiania i skalowania Twoich aplikacji. Zamiast tego można ręcznie tworzyć poszczególne maszyny wirtualne i zarządzać nimi. Istnieją jednak dwie kluczowe korzyści wynikające z używania zestawów skalowania. Są one wbudowane na platformie Azure i automatycznie skalują maszyny wirtualne zgodnie z potrzebami aplikacji.

Po wdrożeniu maszyny wirtualnej należy skonfigurować maszynę wirtualną przy użyciu oprogramowania wymaganego przez aplikację. Zamiast wykonywać to zadanie konfiguracji dla każdej maszyny wirtualnej, można utworzyć obraz niestandardowy. Obraz niestandardowy to migawka istniejącej maszyny wirtualnej, która zawiera dowolne zainstalowane oprogramowanie. Podczas konfigurowania zestawu skalowania należy określić obraz do użycia dla maszyn wirtualnych tego zestawu skalowania. Przy użyciu obrazu niestandardowego każde wystąpienie maszyny wirtualnej jest identycznie skonfigurowane dla aplikacji. Czasami może być konieczne zaktualizowanie niestandardowego obrazu zestawu skalowania. To zadanie koncentruje się na tym samouczku.

W tym artykule omówiono sposób wykonywania następujących zadań:

Wymagania wstępne

• Subskrypcja platformy Azure: jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

• Zainstaluj oprogramowanie Ansible: Wykonaj jedną z następujących opcji:

  • Instalowanie i konfigurowanie rozwiązania Ansible na maszynie wirtualnej z systemem Linux
  • Skonfiguruj usługę Azure Cloud Shell i — jeśli nie masz dostępu do maszyny wirtualnej z systemem Linux — utwórz maszynę wirtualną za pomocą rozwiązania Ansible.

Konfigurowanie dwóch maszyn wirtualnych

Kod podręcznika w tej sekcji tworzy dwie maszyny wirtualne z zainstalowanym protokołem HTTPD na obu.

Na index.html stronie dla każdej maszyny wirtualnej jest wyświetlany ciąg testowy:

• Pierwsza maszyna wirtualna wyświetla wartość Image A
• Druga maszyna wirtualna wyświetla wartość Image B

Ten ciąg jest przeznaczony do naśladowania konfigurowania każdej maszyny wirtualnej przy użyciu innego oprogramowania.

Istnieją dwa sposoby pobrania przykładowego podręcznika:

• Pobierz podręcznik i zapisz go w pliku create_vms.yml.

• Utwórz nowy plik o nazwie create_vms.yml. Wstaw następujący kod do nowego pliku.

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

Uruchom podręcznik przy użyciu ansible-playbook polecenia , zastępując myrg ciąg nazwą grupy zasobów:

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

Ze względu na debug sekcje podręcznika ansible-playbook polecenie wyświetli adres IP każdej maszyny wirtualnej. Skopiuj te adresy IP do późniejszego użycia.

Nawiązywanie połączenia z dwiema maszynami wirtualnymi

W tej sekcji nawiąż połączenie z każdą maszyną wirtualną. Jak wspomniano w poprzedniej sekcji, ciągi Image A i Image B naśladują dwie odrębne maszyny wirtualne z różnymi konfiguracjami.

Korzystając z adresów IP z poprzedniej sekcji, otwórz przeglądarkę i połącz się z każdą maszyną wirtualną.

Tworzenie obrazów na podstawie każdej maszyny wirtualnej

W tym momencie masz dwie maszyny wirtualne z nieco różnymi konfiguracjami (ich index.html plikami).

Kod podręcznika w tej sekcji tworzy obraz niestandardowy dla każdej maszyny wirtualnej:

• image_vmforimageA — Obraz niestandardowy utworzony dla maszyny wirtualnej, która jest wyświetlana Image A na swojej stronie głównej.
• image_vmforimageB — Obraz niestandardowy utworzony dla maszyny wirtualnej, która jest wyświetlana Image B na swojej stronie głównej.

Istnieją dwa sposoby pobrania przykładowego podręcznika:

• Pobierz podręcznik i zapisz go w pliku capture-images.yml.

• Utwórz nowy plik o nazwie capture-images.yml. Wstaw następujący kod do nowego pliku:

- 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

Uruchom podręcznik przy użyciu ansible-playbook polecenia , zastępując myrg ciąg nazwą grupy zasobów:

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

Tworzenie zestawu skalowania przy użyciu obrazu A

W tej sekcji podręcznik służy do konfigurowania następujących zasobów platformy Azure:

• Publiczny adres IP
• Moduł równoważenia obciążenia
• Zestaw skalowania odwołujący się do image_vmforimageA

Istnieją dwa sposoby pobrania przykładowego podręcznika:

• Pobierz podręcznik i zapisz go w pliku create-vmss.yml.

• Utwórz nowy plik o nazwie create-vmss.yml. Wstaw następujący kod do nowego pliku:

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

Uruchom podręcznik przy użyciu ansible-playbook polecenia , zastępując myrg ciąg nazwą grupy zasobów:

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

Ze względu na sekcję debug podręcznika ansible-playbook polecenie wyświetli adres IP zestawu skalowania. Skopiuj ten adres IP do późniejszego użycia.

Nawiązywanie połączenia z zestawem skalowania

Używając adresu IP z poprzedniej sekcji, połącz się z zestawem skalowania.

Jak wspomniano w poprzedniej sekcji, ciągi Image A i Image B naśladują dwie odrębne maszyny wirtualne z różnymi konfiguracjami.

Zestaw skalowania odwołuje się do obrazu niestandardowego o nazwie image_vmforimageA. Obraz image_vmforimageA niestandardowy został utworzony na podstawie maszyny wirtualnej, której strona główna wyświetla Image A.

W rezultacie zostanie wyświetlona strona główna z wyświetlonym Image Akomunikatem .

Pozostaw otwarte okno przeglądarki, kontynuuj pracę z następną sekcją.

Zmienianie obrazu niestandardowego w zestawie skalowania i uaktualnianiu wystąpień

Kod podręcznika w tej sekcji zmienia obraz zestawu skalowania — z image_vmforimageA na image_vmforimageB. Ponadto wszystkie bieżące maszyny wirtualne wdrożone przez zestaw skalowania są aktualizowane.

Istnieją dwa sposoby pobrania przykładowego podręcznika:

• Pobierz podręcznik i zapisz go w pliku update-vmss-image.yml.

• Utwórz nowy plik o nazwie update-vmss-image.yml. Wstaw następujący kod do nowego pliku:

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

Uruchom podręcznik przy użyciu ansible-playbook polecenia , zastępując myrg ciąg nazwą grupy zasobów:

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

Wróć do przeglądarki i odśwież stronę, aby zobaczyć, że podstawowy obraz niestandardowy maszyny wirtualnej jest aktualizowany.

Czyszczenie zasobów

Następne kroki