Tutorial: Aktualisieren des benutzerdefinierten Images von Azure-VM-Skalierungsgruppen mithilfe von Ansible

Artikel
08/13/2024

Wichtig

Für die Ausführung der Beispielplaybooks in diesem Artikel ist mindestens Ansible 2.8 erforderlich.

Azure-VM-Skalierungsgruppen sind eine Azure-Funktion, mit der Sie eine Gruppe von identischen virtuellen Computern mit Lastenausgleich konfigurieren können. Durch Skalierungsgruppen entstehen keine zusätzlichen Kosten, und sie werden aus virtuellen Computern erstellt. Sie zahlen nur für die zugrunde liegenden Computeressourcen, z. B. die VM-Instanzen, den Lastenausgleich oder den Speicher für verwaltete Datenträger. Mit Skalierungsgruppen werden die Verwaltungs- und Automatisierungsebenen für die Ausführung und Skalierung Ihrer Anwendungen bereitgestellt. Sie können stattdessen einzelne virtuelle Computer manuell erstellen und verwalten. Die Verwendung von Skalierungsgruppen bietet jedoch zwei wesentliche Vorteile. Sie sind in Azure integriert und skalieren Ihre virtuellen Computer automatisch entsprechend den Anwendungsanforderungen.

Nach der Bereitstellung eines virtuellen Computers konfigurieren Sie ihn mit der für Ihre App erforderlichen Software. Anstatt diese Konfigurationsaufgabe für jeden virtuellen Computer durchzuführen, können Sie ein benutzerdefiniertes Image erstellen. Ein benutzerdefiniertes Image ist eine Momentaufnahme eines vorhandenen virtuellen Computers, welche die gesamte installierte Software enthält. Beim Konfigurieren einer Skalierungsgruppe geben Sie das Image an, das für die virtuellen Computer dieser Skalierungsgruppe verwendet werden soll. Durch die Verwendung eines benutzerdefinierten Images wird jede VM-Instanz für Ihre App identisch konfiguriert. Bisweilen müssen Sie das benutzerdefinierte Image Ihrer Skalierungsgruppe aktualisieren. Um diese Aufgabe geht es in diesem Tutorial.

In diesem Artikel werden folgende Vorgehensweisen behandelt:

Konfigurieren von zwei virtuellen Computern mit HTTPD
Erstellen eines benutzerdefinierten Image von einem vorhandenen virtuellen Computer
Erstellen einer Skalierungsgruppe aus einem Image
Aktualisieren des benutzerdefinierten Image

Voraussetzungen

Azure-Abonnement: Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Installieren von Ansible: Verwenden Sie eine der folgenden Optionen:
- Installieren und Konfigurieren von Ansible auf einem virtuellen Linux-Computer
- Konfigurieren Sie Azure Cloud Shell. Sollten Sie keinen Zugriff auf einen virtuellen Linux-Computer haben, können Sie mit Ansible einen virtuellen Computer erstellen.

Konfigurieren von zwei virtuellen Computern

Mit dem Playbookcode in diesem Abschnitt werden zwei virtuelle Computer erstellt, auf denen jeweils HTTPD installiert ist.

Die Seite index.html zeigt für jeden virtuellen Computer eine Testzeichenfolge an:

Der erste virtuelle Computer zeigt den Wert Image A an.
Der zweite virtuelle Computer zeigt den Wert Image B an.

Mit diese Zeichenfolge soll das Konfigurieren der virtuellen Computer mit jeweils anderer Software imitiert werden.

Es gibt zwei Möglichkeiten, das Beispielplaybook abzurufen:

Laden Sie das Playbook herunter, und speichern Sie es als create_vms.yml.
Erstelle eine neue Datei mit dem Namen create_vms.yml. Fügen Sie den folgenden Code in die neue Datei ein:

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

Führen Sie das Playbook mit dem Befehl ansible-playbook aus, und ersetzen Sie dabei myrg durch den Namen Ihrer Ressourcengruppe:

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

Aufgrund der debug-Abschnitte des Playbooks gibt der Befehl ansible-playbook die IP-Adressen der einzelnen virtuellen Computer aus. Kopieren Sie diese IP-Adressen für die spätere Verwendung.

Herstellen einer Verbindung mit den beiden virtuellen Computern

In diesem Abschnitt stellen Sie eine Verbindung mit beiden virtuellen Computern her. Wie im vorherigen Abschnitt erwähnt, imitieren die Zeichenfolgen Image A und Image B zwei verschiedene virtuelle Computer mit unterschiedlichen Konfigurationen.

Öffnen Sie mithilfe der IP-Adressen aus dem vorherigen Abschnitt einen Browser, und stellen Sie eine Verbindung mit den einzelnen virtuellen Computern her.

Erstellen von Images von jedem virtuellen Computer

An dieser Stelle haben Sie zwei virtuelle Computer mit geringfügig unterschiedlichen Konfigurationen (ihre index.html-Dateien).

Mit dem Playbookcode in diesem Abschnitt wird für jeden virtuellen Computer ein benutzerdefiniertes Image erstellt.

image_vmforimageA: benutzerdefiniertes Images für den virtuellen Computer, auf dessen Startseite Image A angezeigt wird
image_vmforimageB: benutzerdefiniertes Images für den virtuellen Computer, auf dessen Startseite Image B angezeigt wird

Es gibt zwei Möglichkeiten, das Beispielplaybook abzurufen:

Laden Sie das Playbook herunter, und speichern Sie es als capture-images.yml.
Erstelle eine neue Datei mit dem Namen capture-images.yml. Fügen Sie den folgenden Code in die neue Datei ein:

- 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

Führen Sie das Playbook mit dem Befehl ansible-playbook aus, und ersetzen Sie dabei myrg durch den Namen Ihrer Ressourcengruppe:

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

Erstellen der Skalierungsgruppe mit Image A

In diesem Abschnitt wird ein Playbook verwendet, um die folgenden Azure-Ressourcen zu konfigurieren:

Öffentliche IP-Adresse
Load Balancer
Skalierungsgruppe, die auf image_vmforimageA verweist

Es gibt zwei Möglichkeiten, das Beispielplaybook abzurufen:

Laden Sie das Playbook herunter, und speichern Sie es als create-vmss.yml.
Erstelle eine neue Datei mit dem Namen create-vmss.yml. Fügen Sie den folgenden Code in die neue Datei ein:

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

Führen Sie das Playbook mit dem Befehl ansible-playbook aus, und ersetzen Sie dabei myrg durch den Namen Ihrer Ressourcengruppe:

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

Aufgrund des debug-Abschnitts des Playbooks gibt der Befehl ansible-playbook die IP-Adressen der Skalierungsgruppe aus. Kopieren Sie diese IP-Adresse für die spätere Verwendung.

Herstellen einer Verbindung mit der Skalierungsgruppe

Verwenden Sie die IP-Adresse aus dem vorherigen Abschnitt, um eine Verbindung mit der Skalierungsgruppe herzustellen:

Wie im vorherigen Abschnitt erwähnt, imitieren die Zeichenfolgen Image A und Image B zwei verschiedene virtuelle Computer mit unterschiedlichen Konfigurationen.

Die Skalierungsgruppe verweist auf das benutzerdefinierte Image namens image_vmforimageA. Das benutzerdefinierte Image image_vmforimageA wurde aus dem virtuellen Computer erstellt, auf dessen Startseite Image A angezeigt wird.

Daher sehen Sie eine Startseite, die Image A anzeigt.

Lassen Sie das Browserfenster geöffnet, während Sie mit dem nächsten Abschnitt fortfahren.

Ändern des benutzerdefinierte Image in der Skalierungsgruppe und Aktualisieren von Instanzen

Mit dem Playbookcode in diesem Abschnitt wird das Image der Skalierungsgruppe von image_vmforimageA in image_vmforimageB geändert. Außerdem werden alle derzeit bereitgestellten virtuellen Computer von der Skalierungsgruppe aktualisiert.

Es gibt zwei Möglichkeiten, das Beispielplaybook abzurufen:

Laden Sie das Playbook herunter, und speichern Sie es als update-vmss-image.yml.
Erstelle eine neue Datei mit dem Namen update-vmss-image.yml. Fügen Sie den folgenden Code in die neue Datei ein:

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

Führen Sie das Playbook mit dem Befehl ansible-playbook aus, und ersetzen Sie dabei myrg durch den Namen Ihrer Ressourcengruppe:

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

Kehren Sie zum Browser zurück, und aktualisieren Sie die Seite. Sie stellen fest, dass das zugrunde liegende benutzerdefinierte Image des virtuellen Computers aktualisiert wird.

Bereinigen von Ressourcen

Speichern Sie den folgenden Code als delete_rg.yml.

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

Führen Sie das Playbook mithilfe des Befehls ansible-playbook aus. Ersetzen Sie den Platzhalter durch den Namen der zu löschenden Ressourcengruppe. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"
```
Die wichtigsten Punkte:
- Aufgrund der Variablen register und des Abschnitts debug des Playbooks werden die Ergebnisse angezeigt, wenn der Befehl abgeschlossen ist.

Führen Sie az group delete aus, um die Ressourcengruppe zu löschen. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
az group delete --name <resource_group>
```
Überprüfen Sie mithilfe von az group show, ob die Ressourcengruppe gelöscht wurde.
```
az group show --name <resource_group>
```

Führen Sie Remove-AzResourceGroup aus, um die Ressourcengruppe zu löschen. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
Remove-AzResourceGroup -Name <resource_group>
```
Überprüfen Sie mithilfe von Get-AzResourceGroup, ob die Ressourcengruppe gelöscht wurde.
```
Get-AzResourceGroup -Name <resource_group>
```

Nächste Schritte

Ansible unter Azure

Freigeben über

Tutorial: Aktualisieren des benutzerdefinierten Images von Azure-VM-Skalierungsgruppen mithilfe von Ansible

Voraussetzungen

Konfigurieren von zwei virtuellen Computern

Herstellen einer Verbindung mit den beiden virtuellen Computern

Erstellen von Images von jedem virtuellen Computer

Erstellen der Skalierungsgruppe mit Image A

Herstellen einer Verbindung mit der Skalierungsgruppe

Ändern des benutzerdefinierte Image in der Skalierungsgruppe und Aktualisieren von Instanzen

Bereinigen von Ressourcen

Nächste Schritte

Feedback

Zusätzliche Ressourcen