Zelfstudie: Apps implementeren in schaalsets voor virtuele machines in Azure met behulp van Ansible

Artikel
08/14/2024

Belangrijk

Ansible 2.7 (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.

In dit artikel leert u het volgende:

Hostgegevens ophalen voor een groep Virtuele Azure-machines
De voorbeeld-app klonen en bouwen
De JRE (Java Runtime Environment) installeren op een schaalset
De Java-toepassing implementeren in een schaalset

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.

Virtuele-machineschaalset: Als u nog geen schaalset hebt, kunt u een schaalset configureren met Ansible.

Met git - git wordt een Java-voorbeeld gedownload dat in deze zelfstudie wordt gebruikt.
JDK (Java SE Development Kit): de JDK wordt gebruikt om het Java-voorbeeldproject te maken.
Apache Maven - Apache Maven wordt gebruikt om het Java-voorbeeldproject te bouwen.

Hostgegevens ophalen

De playbookcode in deze sectie haalt hostgegevens op voor een groep virtuele machines. De code haalt de openbare IP-adressen en load balancer op binnen een opgegeven resourcegroep en maakt een hostgroep met de naam scalesethosts in de inventaris.

Sla het volgende voorbeeld-playbook op als get-hosts-tasks.yml:

- name: Get facts for all Public IPs within a resource groups
  azure_rm_publicipaddress_info:
    resource_group: "{{ resource_group }}"
  register: output_ip_address

- name: Get loadbalancer info
  azure_rm_loadbalancer_info:
    resource_group: "{{ resource_group }}"
    name: "{{ loadbalancer_name }}"
  register: output

- name: Add all hosts
  add_host:
    groups: scalesethosts
    hostname: "{{ output_ip_address.publicipaddresses[0].ip_address }}_{{ item.properties.frontendPort }}"
    ansible_host: "{{ output_ip_address.publicipaddresses[0].ip_address }}"
    ansible_port: "{{ item.properties.frontendPort }}"
    ansible_ssh_user: "{{ admin_username }}"
    ansible_ssh_pass: "{{ admin_password }}"
  with_items:
    - "{{ output.ansible_info.azure_loadbalancers[0].properties.inboundNatRules }}"

Een toepassing voorbereiden voor implementatie

De playbookcode in deze sectie gebruikt git om een Java-voorbeeldproject te klonen vanuit GitHub en het project te bouwen.

Sla het volgende playbook op als app.yml:

- hosts: localhost
  vars:
    repo_url: https://github.com/spring-guides/gs-spring-boot.git
    workspace: ~/src/helloworld

  tasks:
  - name: Git Clone sample app
    git:
      repo: "{{ repo_url }}"
      dest: "{{ workspace }}"

  - name: Build sample app
    shell: mvn package chdir="{{ workspace }}/complete"

Voer het voorbeeld-Ansible-playbook uit met de volgende opdracht:

ansible-playbook app.yml

Nadat u het playbook hebt uitgevoerd, ziet u uitvoer die vergelijkbaar is met de volgende resultaten:

PLAY [localhost] 

TASK [Gathering Facts] 
ok: [localhost]

TASK [Git Clone sample app] 
changed: [localhost]

TASK [Build sample app] 
changed: [localhost]

PLAY RECAP 
localhost                  : ok=3    changed=2    unreachable=0    failed=0

De toepassing implementeren in een schaalset

De playbookcode in deze sectie wordt gebruikt voor het volgende:

De JRE installeren op een hostgroep met de naam saclesethosts
De Java-toepassing implementeren in een hostgroep met de naam saclesethosts

Er zijn twee manieren om het voorbeeldplaybook op te halen:

Download het playbook en sla het op in vmss-setup-deploy.yml.
Maak een nieuw bestand met de naam vmss-setup-deploy.yml. Voeg de volgende code in het nieuwe bestand in:

- hosts: localhost
  vars:
    resource_group: myResourceGroup
    scaleset_name: myScaleSet
    loadbalancer_name: myScaleSetLb
    admin_username: azureuser
    admin_password: "{{ admin_password }}"
  tasks:
  - include: get-hosts-tasks.yml

- name: Install JRE on a scale set
  hosts: scalesethosts
  become: yes
  vars:
    workspace: ~/src/helloworld
    admin_username: azureuser

  tasks:
  - name: Install JRE
    apt:
      name: default-jre
      update_cache: yes

  - name: Copy app to Azure VM
    copy:
      src: "{{ workspace }}/complete/target/gs-spring-boot-0.1.0.jar"
      dest: "/home/{{ admin_username }}/helloworld.jar"
      force: yes
      mode: 0755

  - name: Start the application
    shell: java -jar "/home/{{ admin_username }}/helloworld.jar" >/dev/null 2>&1 &
    async: 5000
    poll: 0

Zie de volgende notities voordat u het playbook uitvoert:

Vervang in de vars sectie de {{ admin_password }} tijdelijke aanduiding door uw eigen wachtwoord.
Als u het ssh-verbindingstype met wachtwoorden wilt gebruiken, installeert u het sshpass-programma:

Ubuntu:
```
apt-get install sshpass
```
In sommige omgevingen ziet u mogelijk een foutmelding over het gebruik van een SSH-wachtwoord in plaats van een sleutel. Als u deze fout ontvangt, kunt u controle van hostsleutels uitschakelen door de volgende regel toe te voegen aan /etc/ansible/ansible.cfg of ~/.ansible.cfg:
```
[defaults]
host_key_checking = False
```

Voer het playbook uit met de volgende opdracht:

ansible-playbook vmss-setup-deploy.yml

De uitvoer van het uitvoeren van de opdracht ansible-playbook geeft aan dat de Java-voorbeeldtoepassing is geïnstalleerd in de hostgroep van de schaalset:

PLAY [localhost]

TASK [Gathering Facts]
ok: [localhost]

TASK [Get facts for all Public IPs within a resource groups]
ok: [localhost]

TASK [Get loadbalancer info]
ok: [localhost]

TASK [Add all hosts]
changed: [localhost] ...

PLAY [Install JRE on scale set]

TASK [Gathering Facts]
ok: [40.114.30.145_50000]
ok: [40.114.30.145_50003]

TASK [Copy app to Azure VM]
changed: [40.114.30.145_50003]
changed: [40.114.30.145_50000]

TASK [Start the application]
changed: [40.114.30.145_50000]
changed: [40.114.30.145_50003]

PLAY RECAP
40.114.30.145_50000        : ok=4    changed=3    unreachable=0    failed=0
40.114.30.145_50003        : ok=4    changed=3    unreachable=0    failed=0
localhost                  : ok=4    changed=1    unreachable=0    failed=0

De resultaten controleren

Controleer de resultaten van uw werk door te navigeren naar de URL van de load balancer voor uw schaalset:

Java-app die wordt uitgevoerd in een schaalset in Azure.

Volgende stappen

Zelfstudie: Virtuele-machineschaalsets automatisch schalen in Azure met ansible

Delen via