Zelfstudie: De aangepaste installatiekopieën van virtuele-machineschaalsets van Azure bijwerken met Ansible

Belangrijk

Ansible 2.8 (of hoger) is vereist om de voorbeeldplaybooks in dit artikel uit te voeren.

Virtuele-machineschaalsets van Azure is een Azure-functie waarmee u een groep identieke vm's met gelijke taakverdeling kunt configureren. Er zijn geen extra kosten verbonden aan schaalsets en ze zijn gebouwd op basis van virtuele machines. U betaalt alleen voor de onderliggende rekenresources, zoals de VM-exemplaren, load balancers of Managed Disk-opslag. Met schaalsets beschikt u automatisch over de beheer- en automatiseringslagen voor het uitvoeren en schalen van uw toepassingen. U kunt in plaats daarvan handmatig afzonderlijke VM's maken en beheren. Er zijn echter twee belangrijke voordelen voor het gebruik van schaalsets. Ze zijn ingebouwd in Azure en ze schalen uw virtuele machines automatisch om te voldoen aan de toepassingsbehoeften.

Nadat een VIRTUELE machine is geïmplementeerd, configureert u de VM met de software die uw app nodig heeft. In plaats van deze configuratietaak voor elke VIRTUELE machine uit te voeren, kunt u een aangepaste installatiekopieën maken. Een aangepaste installatiekopie is een momentopname van een bestaande VM met geïnstalleerde software. Wanneer u een schaalset configureert, geeft u de installatiekopieën op die moeten worden gebruikt voor de VM's van die schaalset. Met behulp van een aangepaste installatiekopieën is elk VM-exemplaar identiek geconfigureerd voor uw app. Soms moet u mogelijk de aangepaste installatiekopieën van uw schaalset bijwerken. Deze taak is de focus van deze zelfstudie.

In dit artikel leert u het volgende:

• Twee VM's configureren met HTTPD
• Een aangepaste installatiekopieën maken op basis van een bestaande VM
• Een schaalset maken op basis van een installatiekopieën
• De aangepaste installatiekopieën bijwerken

Vereisten

• Azure-abonnement: als u nog geen abonnement op Azure hebt, maakt u een gratis Azure-account aan voordat u begint.

• Ansible installeren: Voer een van de volgende opties uit:

  • Ansible installeren en configureren op een virtuele Linux-machine
  • Configureer Azure Cloud Shell en maak een virtuele machine met Ansible als u geen toegang hebt tot een virtuele Linux-machine.

Twee VM's configureren

Met de playbookcode in deze sectie worden twee virtuele machines gemaakt waarop HTTPD is geïnstalleerd op beide.

Op index.html de pagina voor elke VM wordt een testtekenreeks weergegeven:

• Eerste VM geeft de waarde weer Image A
• Tweede VM geeft de waarde weer Image B

Deze tekenreeks is bedoeld om elke VIRTUELE machine met verschillende software na te bootsen.

Er zijn twee manieren om het voorbeeldplaybook op te halen:

• Download het playbook en sla het op in create_vms.yml.

• Maak een nieuw bestand met de naam create_vms.yml. Voeg de volgende code in het nieuwe bestand in.

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

Voer het playbook uit met behulp van de ansible-playbook opdracht, waarbij u myrg de naam van de resourcegroep vervangt:

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

Vanwege de debug secties van het playbook wordt met de ansible-playbook opdracht het IP-adres van elke VIRTUELE machine afgedrukt. Kopieer deze IP-adressen voor later gebruik.

Verbinding maken met de twee VM's

In deze sectie maakt u verbinding met elke VIRTUELE machine. Zoals vermeld in de vorige sectie, zijn de tekenreeksen Image A en Image B nabootsen twee afzonderlijke VM's met verschillende configuraties.

Open een browser met behulp van de IP-adressen uit de vorige sectie en maak verbinding met elke virtuele machine.

Installatiekopieën maken van elke VIRTUELE machine

Op dit moment hebt u twee VM's met iets andere configuraties (hun index.html bestanden).

Met de playbookcode in deze sectie maakt u een aangepaste installatiekopieën voor elke VIRTUELE machine:

• image_vmforimageA - Aangepaste installatiekopieën die zijn gemaakt voor de virtuele machine die wordt weergegeven Image A op de startpagina.
• image_vmforimageB - Aangepaste installatiekopieën die zijn gemaakt voor de virtuele machine die wordt weergegeven Image B op de startpagina.

Er zijn twee manieren om het voorbeeldplaybook op te halen:

• Download het playbook en sla het op in capture-images.yml.

• Maak een nieuw bestand met de naam capture-images.yml. Voeg de volgende code in het nieuwe bestand in:

- 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

Voer het playbook uit met behulp van de ansible-playbook opdracht, waarbij u myrg de naam van de resourcegroep vervangt:

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

Schaalset maken met afbeelding A

In deze sectie wordt een playbook gebruikt om de volgende Azure-resources te configureren:

• Openbaar IP-adres
• Load balancer
• Schaalset die verwijst naar image_vmforimageA

Er zijn twee manieren om het voorbeeldplaybook op te halen:

• Download het playbook en sla het op in create-vmss.yml.

• Maak een nieuw bestand met de naam create-vmss.yml. Voeg de volgende code in het nieuwe bestand in:

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

Voer het playbook uit met behulp van de ansible-playbook opdracht, waarbij u myrg de naam van de resourcegroep vervangt:

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

Vanwege de debug sectie van het playbook wordt met de ansible-playbook opdracht het IP-adres van de schaalset afgedrukt. Kopieer dit IP-adres voor later gebruik.

Verbinding maken met de schaalset

Maak verbinding met de schaalset met behulp van het IP-adres uit de vorige sectie.

Zoals vermeld in de vorige sectie, zijn de tekenreeksen Image A en Image B nabootsen twee afzonderlijke VM's met verschillende configuraties.

De schaalset verwijst naar de aangepaste installatiekopieën met de naam image_vmforimageA. Aangepaste installatiekopieën image_vmforimageA zijn gemaakt op basis van de virtuele machine waarvan de startpagina wordt weergegeven Image A.

Als gevolg hiervan ziet u een startpagina die wordt weergegeven Image A.

Laat het browservenster geopend terwijl u doorgaat naar de volgende sectie.

Aangepaste installatiekopieën wijzigen in schaalset en upgrade-exemplaren

De playbookcode in deze sectie wijzigt de afbeelding van de schaalset , van image_vmforimageA naar image_vmforimageB. Ook worden alle huidige virtuele machines die door de schaalset zijn geïmplementeerd, bijgewerkt.

Er zijn twee manieren om het voorbeeldplaybook op te halen:

• Download het playbook en sla het op in update-vmss-image.yml.

• Maak een nieuw bestand met de naam update-vmss-image.yml. Voeg de volgende code in het nieuwe bestand in:

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

Voer het playbook uit met behulp van de ansible-playbook opdracht, waarbij u myrg de naam van de resourcegroep vervangt:

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

Ga terug naar de browser en vernieuw de pagina om te zien dat de onderliggende aangepaste installatiekopieën van de virtuele machine worden bijgewerkt.

Resources opschonen

Ansible

1. Sla de volgende code op als delete_rg.yml.

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

2. Voer het playbook uit met behulp van de ansible-playbook-opdracht . Vervang de tijdelijke aanduiding door de naam van de resourcegroep die u wilt verwijderen. Alle resources in de resourcegroep worden verwijderd.

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

   Belangrijkste punten:

   • Vanwege de register variabele en debug sectie van het playbook worden de resultaten weergegeven wanneer de opdracht is voltooid.

Azure-CLI

1. Voer az group delete uit om de resourcegroep te verwijderen. Alle resources in de resourcegroep worden verwijderd.

   az group delete --name <resource_group>
   

2. Controleer of de resourcegroep is verwijderd met behulp van az group show.

   az group show --name <resource_group>
   

Azure PowerShell

1. Voer Remove-AzResourceGroup uit om de resourcegroep te verwijderen. Alle resources in de resourcegroep worden verwijderd.

   Remove-AzResourceGroup -Name <resource_group>
   

2. Controleer of de resourcegroep is verwijderd met behulp van Get-AzResourceGroup.

   Get-AzResourceGroup -Name <resource_group>
   

Volgende stappen

Ansible in Azure