Erstellen von virtuellen Linux-Computern in Azure mit Ansible

Artikel
08/19/2024

Dieser Artikel enthält ein Ansible-Beispielplaybook für die Konfiguration eines virtuellen Linux-Computers.

In diesem Artikel werden folgende Vorgehensweisen behandelt:

Erstellen einer Ressourcengruppe
Erstellen eines virtuellen Netzwerks
Erstellen einer öffentlichen IP-Adresse
Erstellen Sie eine Netzwerksicherheitsgruppe.
Erstellen einer virtuellen Netzwerkadapterkarte
Erstellen eines virtuellen Computers

1. Konfigurieren Ihrer Umgebung

Azure-Abonnement: Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Installieren von Ansible: Verwenden Sie eine der folgenden Optionen:
- Installieren und Konfigurieren von Ansible auf einem virtuellen Linux-Computer
- Konfigurieren von Azure Cloud Shell

2. Erstellen eines SSH-Schlüsselpaars

Führen Sie den folgenden Befehl aus. Geben Sie bei entsprechender Aufforderung die zu erstellenden Dateien im folgenden Verzeichnis an: /home/azureuser/.ssh/authorized_keys.
```
ssh-keygen -m PEM -t rsa -b 4096
```
Kopieren Sie den Inhalt der Datei mit dem öffentlichen Schlüssel. Standardmäßig hat die Datei mit dem öffentlichen Schlüssel den Namen id_rsa.pub. Der Wert ist eine lange Zeichenfolge, die mit „ssh-rsa“ beginnt. Sie benötigen diesen Wert im nächsten Schritt.

3. Implementieren des Ansible-Playbooks

Erstellen Sie ein Verzeichnis, in dem der Ansible-Beispielcode getestet und ausgeführt werden soll, und legen Sie es als aktuelles Verzeichnis fest.

Erstellen Sie eine Datei namens main.yml, und fügen Sie den folgenden Code ein: Ersetzen Sie den Platzhalter <key_data> durch den Wert des öffentlichen Schlüssels aus dem vorherigen Schritt.

- 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. Ausführen des Playbooks

Führen Sie das Ansible-Playbook mithilfe von ansible-playbook aus.

ansible-playbook main.yml

5. Überprüfen der Ergebnisse

Führen Sie az vm list aus, um sich zu vergewissern, dass die VM erstellt wurde.

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

6. Herstellen einer Verbindung mit der VM

Führen Sie den SSH-Befehl aus, um eine Verbindung mit Ihrer neuen Linux-VM herzustellen. Ersetzen Sie den Platzhalter <ip-address>> durch die IP-Adresse aus dem vorherigen Schritt.

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

Bereinigen von Ressourcen

Speichern Sie den folgenden Code als delete_rg.yml.

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

Führen Sie das Playbook mithilfe des Befehls ansible-playbook aus. Ersetzen Sie den Platzhalter durch den Namen der zu löschenden Ressourcengruppe. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
ansible-playbook delete_rg.yml --extra-vars "name=<resource_group>"
```
Die wichtigsten Punkte:
- Aufgrund der Variablen register und des Abschnitts debug des Playbooks werden die Ergebnisse angezeigt, wenn der Befehl abgeschlossen ist.

Führen Sie az group delete aus, um die Ressourcengruppe zu löschen. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
az group delete --name <resource_group>
```
Überprüfen Sie mithilfe von az group show, ob die Ressourcengruppe gelöscht wurde.
```
az group show --name <resource_group>
```

Führen Sie Remove-AzResourceGroup aus, um die Ressourcengruppe zu löschen. Alle Ressourcen innerhalb der Ressourcengruppe werden gelöscht.
```
Remove-AzResourceGroup -Name <resource_group>
```
Überprüfen Sie mithilfe von Get-AzResourceGroup, ob die Ressourcengruppe gelöscht wurde.
```
Get-AzResourceGroup -Name <resource_group>
```

Nächste Schritte

Verwalten eines virtuellen Linux-Computers in Azure mithilfe von Ansible

Freigeben über