Criar máquinas virtuais do Linux no Azure usando o Ansible

Artigo
08/19/2024

Este artigo apresenta um guia estratégico de exemplo do Ansible para configurar máquinas virtuais do Linux.

Neste artigo, você aprenderá como:

Criar um grupo de recursos
Criar uma rede virtual
Criar um endereço IP público
Criar um grupo de segurança de rede
Criar uma placa de adaptador de rede virtual
Criar uma máquina virtual

1. Configurar seu ambiente

Assinatura do Azure: caso você não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar.

Instalar o Ansible: escolha uma das seguintes opções:
- Instalar e configurar o Ansible em uma máquina virtual do Linux
- Configurar o Azure Cloud Shell

2. Criar um par de chaves SSH

Execute o comando a seguir. Quando solicitado, especifique os arquivos a serem criados no seguinte diretório: /home/azureuser/.ssh/authorized_keys.
```
ssh-keygen -m PEM -t rsa -b 4096
```
Copie o conteúdo do arquivo de chave pública. Por padrão, o arquivo de chave pública é chamado id_rsa.pub. O valor é uma cadeia de caracteres longa que começa com "ssh-rsa". Esse valor será necessário na próxima etapa.

3. Implementar o guia estratégico do Ansible

Crie um diretório no qual testar e executar o código de exemplo do Ansible e transforme ele no diretório atual.

Crie um arquivo chamado main.yml, depois insira o código a seguir. Substitua o texto do espaço reservado <key_data> pelo valor da chave pública da etapa anterior.

- 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. Executar o guia estratégico

Execute ansible-playbook para executar o guia estratégico do Ansible.

ansible-playbook main.yml

5. Verificar os resultados

Execute az vm list para verificar se a VM foi criada.

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

6. Conecte-se à VM

Execute o comando SSH para se conectar à nova VM do Linux. Substitua o espaço reservado <ip-address> pelo endereço IP da etapa anterior.

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

Limpar os recursos

Salve o código a seguir como delete_rg.yml.

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

Execute o guia estratégico usando o comando ansible-playbook. Substitua o espaço reservado pelo nome do grupo de recursos a ser excluído. Todos os recursos dentro do grupo de recursos serão excluídos.
```
ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"
```
Pontos principais:
- Devido à variável register e à seção debug do guia estratégico, os resultados são exibidos quando o comando é concluído.

Execute az group delete para excluir o grupo de recursos. Todos os recursos dentro do grupo de recursos serão excluídos.
```
az group delete --name <resource_group>
```
Verifique se o grupo de recursos foi excluído usando az group show.
```
az group show --name <resource_group>
```

Execute Remove-AzResourceGroup para excluir o grupo de recursos. Todos os recursos dentro do grupo de recursos serão excluídos.
```
Remove-AzResourceGroup -Name <resource_group>
```
Verifique se o grupo de recursos foi excluído usando Get-AzResourceGroup.
```
Get-AzResourceGroup -Name <resource_group>
```

Próximas etapas

Gerenciar uma máquina virtual do Linux no Azure usando o Ansible

Compartilhar via