Självstudie: Distribuera program till skalningsuppsättningar för virtuella datorer i Azure med Ansible

Artikel
08/14/2024

Viktigt!

Ansible 2.7 (eller senare) krävs för att köra exempelspelböckerna i den här artikeln.

Skalningsuppsättningar för virtuella Azure-datorer är en Azure-funktion som gör att du kan konfigurera en grupp med identiska, belastningsutjämningade virtuella datorer. Det finns ingen extra kostnad för skalningsuppsättningar och de skapas från virtuella datorer. Du betalar bara för underliggande beräkningsresurser, till exempel VM-instanser, lastbalanserare eller managed disk-lagring. Med skalningsuppsättningar tillhandahålls hantering och automatiseringsnivåer för körning och skalning av dina program. Du kan i stället skapa och hantera enskilda virtuella datorer manuellt. Det finns dock två viktiga fördelar med att använda skalningsuppsättningar. De är inbyggda i Azure och de skalar automatiskt dina virtuella datorer efter programbehov.

I den här artikeln kan du se hur du:

Hämta värdinformation för en grupp virtuella Azure-datorer
Klona och skapa exempelappen
Installera JRE (Java Runtime Environment) på en skalningsuppsättning
Distribuera Java-programmet till en skalningsuppsättning

Förutsättningar

Azure-prenumeration: Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

Installera Ansible: Gör något av följande alternativ:
- Installera och konfigurera Ansible på en virtuell Linux-dator
- Konfigurera Azure Cloud Shell och – om du inte har åtkomst till en virtuell Linux-dator – skapa en virtuell dator med Ansible.

Vm-skalningsuppsättning: Om du inte redan har en skalningsuppsättning kan du konfigurera en skalningsuppsättning med Ansible.

git - git används för att ladda ned ett Java-exempel som används in den här självstudien.
Java SE Development Kit (JDK) – JDK används till att skapa Java-exempelprojektet.
Apache Maven - Apache Maven används för att skapa Java-exempelprojektet.

Hämta värdinformation

Spelbokskoden i det här avsnittet hämtar värdinformation för en grupp virtuella datorer. Koden hämtar de offentliga IP-adresserna och lastbalanseraren i en angiven resursgrupp och skapar en värdgrupp med namnet scalesethosts i inventeringen.

Spara följande exempelspelbok som 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 }}"

Förbereda ett program för distribution

Spelbokskoden i det här avsnittet använder git för att klona ett Java-exempelprojekt från GitHub och skapar projektet.

Spara följande spelbok som 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"

Kör Ansible-spelboksexemplet med följande kommando:

ansible-playbook app.yml

När du har kört spelboken visas utdata som liknar följande resultat:

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

Distribuera programmet till en skalningsuppsättning

Spelbokskoden i det här avsnittet används för att:

Installera JRE på en värdgrupp med namnet saclesethosts
Distribuera Java-programmet till en värdgrupp med namnet saclesethosts

Det finns två sätt att hämta exempelspelboken:

Ladda ned spelboken och spara den i vmss-setup-deploy.yml.
Skapa en ny fil med namnet vmss-setup-deploy.yml. Infoga följande kod i den nya filen:

- 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

Se följande anteckningar innan du kör spelboken:

I avsnittet vars ersätter du {{ admin_password }} platshållaren med ditt eget lösenord.
Om du vill använda ssh-anslutningstypen med lösenord installerar du sshpass-programmet:

Ubuntu:
```
apt-get install sshpass
```
I vissa miljöer kan det uppstå ett fel om att använda ett SSH-lösenord i stället för en nyckel. Om du får det felet kan du inaktivera kontrollen av värdnyckeln genom att lägga till följande rad i /etc/ansible/ansible.cfg eller ~/.ansible.cfg:
```
[defaults]
host_key_checking = False
```

Kör spelboken med följande kommando:

ansible-playbook vmss-setup-deploy.yml

Utdata från körningen av kommandot ansible-playbook anger att Java-exempelprogrammet har installerats i värdgruppen för skalningsuppsättningen:

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

Verifiera resultatet

Kontrollera resultatet av ditt arbete genom att gå till URL:en för lastbalanseraren för din skalningsuppsättning:

Java-appen körs i en skalningsuppsättning i Azure.

Nästa steg

Självstudie: Autoskalning av vm-skalningsuppsättningar i Azure med Ansible

Dela via