Een virtuele Linux-machine maken in Azure met Ansible

Artikel
08/15/2024

Dit artikel bevat een voorbeeld van een Ansible-playbook voor het configureren van een virtuele Linux-machine.

In dit artikel leert u het volgende:

Een brongroep maken
Een virtueel netwerk maken
Een openbaar IP-adres maken
Een netwerkbeveiligingsgroep maken
Een virtuele netwerkinterfacekaart maken
Maak een virtuele machine

1. Uw omgeving configureren

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
- Azure Cloud Shell configureren

2. Een SSH-sleutelpaar maken

Voer de volgende opdracht uit. Geef de bestanden op die moeten worden gemaakt in de volgende map: /home/azureuser/.ssh/authorized_keys
```
ssh-keygen -m PEM -t rsa -b 4096
```
Kopieer de inhoud van het openbare-sleutelbestand. Standaard heeft het openbare-sleutelbestand de naam id_rsa.pub. De waarde is een lange tekenreeks die begint met 'ssh-rsa'. U hebt deze waarde nodig in de volgende stap.

3. Het Ansible-playbook implementeren

Maak een map waarin u de voorbeeldcode van Ansible wilt testen en uitvoeren en deze de huidige map kunt maken.

Maak een bestand met de naam main.yml en voeg de volgende code in. Vervang de <key_data> tijdelijke aanduiding door de waarde van de openbare sleutel uit de vorige stap.

- 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. Voer het playbook uit

Voer ansible-playbook uit om het Ansible-playbook uit te voeren.

ansible-playbook main.yml

5. Controleer de resultaten

Voer az vm list uit om te controleren of de virtuele machine is gemaakt.

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

6. Verbinding maken met de VIRTUELE machine

Voer de SSH-opdracht uit om verbinding te maken met uw nieuwe Linux-VM. Vervang de tijdelijke aanduiding voor ip-adressen <> door het IP-adres uit de vorige stap.

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

Resources opschonen

Sla de volgende code op als delete_rg.yml.

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

Voer het playbook uit met behulp van de ansible-playbook-opdracht . Vervang de tijdelijke aanduiding door de naam van de resourcegroep die u wilt verwijderen. Alle resources in de resourcegroep worden verwijderd.
```
ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"
```
Belangrijkste punten:
- Vanwege de register variabele en debug sectie van het playbook worden de resultaten weergegeven wanneer de opdracht is voltooid.

Voer az group delete uit om de resourcegroep te verwijderen. Alle resources in de resourcegroep worden verwijderd.
```
az group delete --name <resource_group>
```
Controleer of de resourcegroep is verwijderd met behulp van az group show.
```
az group show --name <resource_group>
```

Voer Remove-AzResourceGroup uit om de resourcegroep te verwijderen. Alle resources in de resourcegroep worden verwijderd.
```
Remove-AzResourceGroup -Name <resource_group>
```
Controleer of de resourcegroep is verwijderd met behulp van Get-AzResourceGroup.
```
Get-AzResourceGroup -Name <resource_group>
```

Volgende stappen

Een virtuele Linux-machine in Azure beheren met Ansible

Delen via