Creare macchine virtuali Linux in Azure con Ansible

Articolo
08/15/2024

Questo articolo presenta un playbook ansible di esempio per la configurazione di una macchina virtuale Linux.

In questo articolo vengono illustrate le operazioni seguenti:

Creare un gruppo di risorse
Creare una rete virtuale
Creare un indirizzo IP pubblico
Creare un gruppo di sicurezza di rete
Creare una scheda di interfaccia di rete virtuale
Creare una macchina virtuale

1. Configurare l'ambiente

Sottoscrizione di Azure: se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Installare Ansible: eseguire una delle opzioni seguenti:
- Installare e configurare Ansible in una macchina virtuale Linux
- Configurare Azure Cloud Shell

2. Creare una coppia di chiavi SSH

Esegui il comando seguente: Quando richiesto, specificare i file da creare nella directory seguente: /home/azureuser/.ssh/authorized_keys.
```
ssh-keygen -m PEM -t rsa -b 4096
```
Copiare il contenuto del file di chiave pubblica. Per impostazione predefinita, il file di chiave pubblica è denominato id_rsa.pub. Il valore è una stringa lunga che inizia con "ssh-rsa". Questo valore sarà necessario nel passaggio successivo.

3. Implementare il playbook ansible

Creare una directory in cui testare ed eseguire il codice Ansible di esempio e impostarla come directory corrente.

Creare un file denominato main.yml e inserire il codice seguente. Sostituire il <key_data> segnaposto con il valore della chiave pubblica del passaggio precedente.

- name: Create Azure VM
  hosts: localhost
  connection: local
  tasks:
  - name: Create resource group
    azure_rm_resourcegroup:
      name: myResourceGroup
      location: eastus
  - name: Create virtual network
    azure_rm_virtualnetwork:
      resource_group: myResourceGroup
      name: myVnet
      address_prefixes: "10.0.0.0/16"
  - name: Add subnet
    azure_rm_subnet:
      resource_group: myResourceGroup
      name: mySubnet
      address_prefix: "10.0.1.0/24"
      virtual_network: myVnet
  - name: Create public IP address
    azure_rm_publicipaddress:
      resource_group: myResourceGroup
      allocation_method: Static
      name: myPublicIP
    register: output_ip_address
  - name: Public IP of VM
    debug:
      msg: "The public IP is {{ output_ip_address.state.ip_address }}."
  - name: Create Network Security Group that allows SSH
    azure_rm_securitygroup:
      resource_group: myResourceGroup
      name: myNetworkSecurityGroup
      rules:
        - name: SSH
          protocol: Tcp
          destination_port_range: 22
          access: Allow
          priority: 1001
          direction: Inbound
  - name: Create virtual network interface card
    azure_rm_networkinterface:
      resource_group: myResourceGroup
      name: myNIC
      virtual_network: myVnet
      subnet: mySubnet
      public_ip_name: myPublicIP
      security_group: myNetworkSecurityGroup
  - name: Create VM
    azure_rm_virtualmachine:
      resource_group: myResourceGroup
      name: myVM
      vm_size: Standard_DS1_v2
      admin_username: azureuser
      ssh_password_enabled: false
      ssh_public_keys:
        - path: /home/azureuser/.ssh/authorized_keys
          key_data: "<key_data>"
      network_interfaces: myNIC
      image:
        offer: 0001-com-ubuntu-server-jammy
        publisher: Canonical
        sku: 22_04-lts
        version: latest

4. Eseguire il playbook

Eseguire ansible-playbook per eseguire il playbook ansible.

ansible-playbook main.yml

5. Verificare i risultati

Eseguire az vm list per verificare che la macchina virtuale sia stata creata.

az vm list -d -o table --query "[?name=='myVM']"

6. Connettersi alla macchina virtuale

Eseguire il comando SSH per connettersi alla nuova macchina virtuale Linux. Sostituire il <segnaposto ip-address> con l'indirizzo IP del passaggio precedente.

ssh azureuser@<ip_address> -i /home/azureuser/.ssh/authorized_keys/id_rsa

Pulire le risorse

Salvare il codice seguente come delete_rg.yml.

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

Eseguire il playbook usando il comando ansible-playbook. Sostituire il segnaposto con il nome del gruppo di risorse da eliminare. Tutte le risorse presenti nel gruppo di risorse verranno eliminate.
```
ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"
```
Punti principali:
- A causa della variabile e debug della register sezione del playbook, i risultati vengono visualizzati al termine del comando.

Eseguire az group delete per eliminare il gruppo di risorse. Tutte le risorse presenti nel gruppo di risorse verranno eliminate.
```
az group delete --name <resource_group>
```
Verificare che il gruppo di risorse sia stato eliminato usando az group show.
```
az group show --name <resource_group>
```

Eseguire Remove-AzResourceGroup per eliminare il gruppo di risorse. Tutte le risorse presenti nel gruppo di risorse verranno eliminate.
```
Remove-AzResourceGroup -Name <resource_group>
```
Verificare se il gruppo di risorse è stato eliminato usando Get-AzResourceGroup.
```
Get-AzResourceGroup -Name <resource_group>
```

Passaggi successivi

Gestire una macchina virtuale Linux in Azure con Ansible

Condividi tramite