Hinweis:

Dieses Tutorial ist in einer von Oracle bereitgestellten kostenlosen Übungsumgebung verfügbar.
Es verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, -Mandanten und -Compartments. Ersetzen Sie diese Werte nach Abschluss der Übung durch Werte, die für Ihre Cloud-Umgebung spezifisch sind.

Virtuelle KVM-Maschinen mit Oracle Linux Automation Manager verwalten

Einführung

Die community.libvirt-Collection stellt libvirt-Module und -Plug-ins bereit, die von der Ansible libvirt-Community unterstützt werden. Diese Module und Plug-ins helfen bei der Verwaltung virtueller Maschinen (VMs) und Container mit der libvirt-API.

Ziele

In diesem Tutorial erfahren Sie, wie Sie:

Erstellen Sie ein Playbook, das die Sammlung community.libvirt verwendet
Zugangsdaten für Ansible Galaxy konfigurieren
Jobvorlage erstellen
Führen Sie den Job aus

Voraussetzungen

Ein System mit installiertem Oracle Linux Automation Manager
Zugriff auf ein Git-Repository
Ein Oracle Linux-System mit installiertem KVM

Hinweis: Einzelheiten zum Installieren von Oracle Linux Automation Manager oder KVM finden Sie in den Links am Ende dieser Übung.

Oracle Linux Automation Manager bereitstellen

Hinweis: Wenn Sie in Ihrem eigenen Mandanten ausgeführt werden, lesen Sie das Projekt linux-virt-labs GitHub README.md, und schließen Sie die Voraussetzungen ab, bevor Sie die Übungsumgebung bereitstellen.

Öffnen Sie ein Terminal auf dem Luna Desktop.

Klonen Sie das Projekt linux-virt-labs GitHub.

git clone https://github.com/oracle-devrel/linux-virt-labs.git

Wechseln Sie in das Arbeitsverzeichnis.
```
cd linux-virt-labs/olam
```

Installieren Sie die erforderlichen Sammlungen.

ansible-galaxy collection install -r requirements.yml

Aktualisieren Sie die Oracle Linux-Instanzkonfiguration.

cat << EOF | tee instances.yml > /dev/null
compute_instances:
  1:
    instance_name: "olam-node"
    type: "control"
  2:
    instance_name: "git-server"
    type: "server"
  3:
    instance_name: "kvm-server"
    type: "server"
passwordless_ssh: true
use_git: true
use_kvm: true
EOF

Stellen Sie die Übungsumgebung bereit.
```
ansible-playbook create_instance.yml -e ansible_python_interpreter="/usr/bin/python3.6" -e "@instances.yml"
```
Für die kostenlose Übungsumgebung ist die zusätzliche Variable ansible_python_interpreter erforderlich, weil das RPM-Package für das Oracle Cloud Infrastructure-SDK für Python installiert wird. Der Speicherort für die Installation dieses Pakets befindet sich unter den python3.6-Modulen.

Die Standard-Deployment-Ausprägung verwendet die AMD-CPU und Oracle Linux 8. Um eine Intel-CPU oder Oracle Linux 9 zu verwenden, fügen Sie dem Deployment-Befehl -e instance_shape="VM.Standard3.Flex" oder -e os_version="9" hinzu.

Wichtig: Warten Sie, bis die Arbeitsmappe erfolgreich ausgeführt wurde, und erreichen Sie die Aufgabe "Unterbrechen". Die Installation von Oracle Linux Automation Manager ist in dieser Phase des Spiels abgeschlossen, und die Instanzen sind bereit. Beachten Sie die vorherige Wiedergabe, in der die öffentlichen und privaten IP-Adressen der bereitgestellten Knoten gedruckt werden.

Playbook erstellen

Öffnen Sie ein neues Terminalfenster.
Legen Sie eine Variable für die Remote-Git-Server-Instanz fest.
```
export REMOTE=<ip_address_of_instance>
```
Erstellen Sie das Projektverzeichnis.
```
mkdir ~/olamkvm
```
Erstellen Sie eine Anforderungsdatei.

Oracle Linux Automation Engine verwendet die Anforderungsdatei, um alle erforderlichen Collections oder Rollen zur Laufzeit in das Projekt abzurufen.
```
cat << EOF > ~/olamkvm/requirements.yml 
---
collections:
  - name: community.libvirt
  - name: community.general
  - name: community.crypto
EOF
```

Erstellen Sie eine Variablendatei.

In der Datei werden Variablen und deren Standardwerte gespeichert. Das Playbook importiert diese Datei zur Laufzeit.

Erstellen Sie ein Verzeichnis zum Speichern der Datei.
```
mkdir ~/olamkvm/vars
```

Erstellen Sie die Datei.

cat << EOF > ~/olamkvm/vars/defaults.yml
---
username: oracle
base_image_name: OL9U5_x86_64-kvm-b253.qcow2
base_image_url: https://yum.oracle.com/templates/OracleLinux/OL9/u5/x86_64/
base_image_sha: 3b00bbbefc8e78dd28d9f538834fb9e2a03d5ccdc2cadf2ffd0036c0a8f02021
libvirt_pool_dir: "/var/lib/libvirt/images"
vm_name: ol9-dev
vm_vcpus: 2
vm_ram_mb: 2048
vm_net: default
vm_root_pass: 
cleanup_tmp: no 
EOF

Erstellen Sie die cloud-init-Vorlagen.

Diese Vorlagen erstellen die Metadaten und die Benutzerdaten-Dateien, um die VM-Konfiguration über cloud-init bereitzustellen.
1. Erstellen Sie ein Verzeichnis zum Speichern der Vorlagen.
```
mkdir ~/olamkvm/templates
```
2. Erstellen Sie die Metadatenvorlage.
```
cat << EOF > ~/olamkvm/templates/meta-data.j2
instance-id: iid-local01
local-hostname: 
EOF
```
3. Erstellen Sie die Benutzerdatenvorlage.
```
cat << EOF > ~/olamkvm/templates/user-data.j2
#cloud-config

system_info:
  default_user:
    name: opc

ssh_authorized_keys:
  - 
EOF
```

Erstellen Sie die libvirt-VM-Definitionsvorlage.

cat << EOF > ~/olamkvm/templates/vm-template.xml.j2
<domain type="kvm">
  <name></name>
  <memory unit='MiB'></memory>
  <vcpu placement='static'></vcpu>
  <os>
    <type arch="x86_64" machine="q35">hvm</type>
    <boot dev="hd"/>
  </os>
  <features>
    <acpi/>
    <apic/>
  </features>
  <cpu mode="host-model"/>
  <clock offset="utc">
    <timer name="rtc" tickpolicy="catchup"/>
    <timer name="pit" tickpolicy="delay"/>
    <timer name="hpet" present="no"/>
  </clock>
  <pm>
    <suspend-to-mem enabled="no"/>
    <suspend-to-disk enabled="no"/>
  </pm>
  <devices>
    <emulator>/usr/libexec/qemu-kvm</emulator>
    <disk type="file" device="disk">
      <driver name="qemu" type="qcow2"/>
      <source file="/.qcow"/>
      <target dev="vda" bus="virtio"/>
    </disk>
    <disk type="file" device="cdrom">
      <driver name="qemu" type="raw"/>
      <source file="/.iso"/>
      <target dev="sda" bus="sata"/>
      <readonly/>
    </disk>
    <controller type="usb" model="qemu-xhci" ports="15"/>
    <interface type="network">
      <source network=""/>
      <model type="virtio"/>
    </interface>
    <console type="pty"/>
    <channel type="unix">
      <source mode="bind"/>
      <target type="virtio" name="org.qemu.guest_agent.0"/>
    </channel>
    <memballoon model="virtio"/>
    <rng model="virtio">
      <backend model="random">/dev/urandom</backend>
    </rng>
  </devices>
</domain>
EOF

Erstellen Sie ein Playbook.

Dieses Playbook fragt den KVM-Server nach vorhandenen VMs ab und stellt dann ein neues Oracle Linux Cloud-Image bereit.

cat << EOF > ~/olamkvm/create_vm.yml
---
- name: Create vm with community.libvirt collection
  hosts: kvm
  become: true

  vars_files:
    - vars/defaults.yml

  tasks:

  - name: Add python lxml module required by libvirt ansible module
    ansible.builtin.dnf:
      name: python3-lxml
      state: present

  - name: Get list of existing VMs
    community.libvirt.virt:
      command: list_vms
    register: existing_vms
    changed_when: false

  - name: Print list of existing VMs
    ansible.builtin.debug:
      var: existing_vms

  - name: Create VM when not exist
    when: ( vm_name not in existing_vms.list_vms )
    block:

    - name: Download base image
      ansible.builtin.get_url:
        url: ""
        dest: "/tmp/"
        checksum: "sha256:"
        mode: "0664"

    - name: Copy base image to libvirt directory
      ansible.builtin.copy:
        dest: "/.qcow"
        src: "/tmp/"
        force: false
        remote_src: true 
        owner: qemu
        group: qemu
        mode: "0660"
      register: copy_results

    - name: Generate a vm ssh keypair
      community.crypto.openssh_keypair:
        path: ~/.ssh/id_rsa
        size: 2048
        comment: vm ssh keypair
      register: vm_ssh_keypair
      become: true
      become_user: ""

    - name: Create vm meta-data
      ansible.builtin.template:
        src: templates/meta-data.j2
        dest: "~/meta-data"
        mode: "0664"
      become_user: ""

    - name: Read the vm ssh private key
      ansible.builtin.slurp:
        src: "~/.ssh/id_rsa.pub"
      register: vm_ssh_private_key
      become: true
      become_user: ""

    - name: Create var for private key
      ansible.builtin.set_fact:
        vm_private_key: ""

    - name: Create vm user-data
      ansible.builtin.template:
        src: templates/user-data.j2
        dest: ~/user-data
        mode: "0664"
      become: true
      become_user: ""

    - name: Generate iso containing cloud-init configuration
      ansible.builtin.shell: |
        genisoimage -output /tmp/.iso -volid cidata -joliet -rock ~/user-data ~/meta-data
      become: true
      become_user: ""
      register: generate_iso
      changed_when: generate_iso.rc == 0

    - name: Copy vm iso image to libvirt directory
      ansible.builtin.copy:
        dest: "/.iso"
        src: "/tmp/.iso"
        force: false
        remote_src: true 
        owner: qemu
        group: qemu
        mode: "0660"

    - name: Remove vm iso image from tmp
      ansible.builtin.file:
        path: "/tmp/.iso"
        state: absent

    - name: Define the vm
      community.libvirt.virt:
        command: define
        xml: ""

  - name: Start the vm
    community.libvirt.virt:
      name: ""
      state: running
    register: vm_start_results
    until: "vm_start_results is success"
    retries: 15
    delay: 2

  - name: Remove the temporary file
    ansible.builtin.file:
      path: "/tmp/"
      state: absent
    when: cleanup_tmp | bool
EOF

Projekt zu Versionskontrolle hinzufügen

Initialisieren Sie das Arbeitsverzeichnis des Projekts in einem Git-Repository.

Bevor Sie das Repository initialisieren, müssen Sie einige Git-Setupschritte ausführen.
1. Legen Sie den Standardverzweigungsnamen fest, der bei der Initialisierung eines Projekts verwendet wird.
```
git config --global init.defaultBranch main
```
2. Legen Sie Ihre Identität fest.
  
  Die E-Mail und der Name sind Beispiele in diesem Tutorial. Verwenden Sie Ihre E-Mail-Adresse und Ihren Namen, wenn Sie an Ihren Projekten arbeiten, da diese Informationen unveränderlich in jeden Commit eingebettet werden.
```
git config --global user.email johndoe@example.com
git config --global user.name "John Doe"
```
3. Wechseln Sie in das Arbeitsverzeichnis des Projekts.
```
cd ~/olamkvm
```
4. Initialisieren Sie das Verzeichnis als lokales Git-Repository.
```
git init
```
  Der Befehl gibt zurück, dass er das leere Git-Repository initialisiert hat.
Prüfen Sie den Status des Arbeitsverzeichnisses und der Projekt-Staging Area.
```
git status
```
Der Status des lokalen Repositorys gibt die beiden nicht verfolgten Dateien create_vm.yml und requirements.yml sowie die Verzeichnisse vars und templates an.
Fügen Sie die neuen Dateien in der Staging Area hinzu, und verfolgen Sie sie.
```
git add --all
```
Mit der Option --all werden alle nicht verfolgten und geänderten Dateien zur Staging Area hinzugefügt.
Schreiben Sie die Änderungen fest, die sich derzeit in der Staging Area befinden.
```
git commit -m 'initial commit'
```
Mit der Option -m können Sie den festgeschriebenen Änderungen einen Kommentar hinzufügen.
Erstellen und initialisieren Sie das Remote-Git-Repository.

Ein Remote Repository ist ein freigegebenes Repository, das von allen Projektbeitragenden verwendet und in einem Code-Hosting-Service wie GitHub oder einem selbst gehosteten Server gespeichert wird.
```
ssh git@$REMOTE "git init -b main --bare /git-server/repos/olamkvm.git"
```
Die Option -b stellt die Initialisierung des Remote Repositorys mit einer Verzweigung namens main sicher.
Akzeptieren Sie den ECDSA-Schlüsselfingerprint, indem Sie yes eingeben.
Fügen Sie den neuen Remote Repository-Verbindungsdatensatz hinzu.

Wenn Sie die Remoteverbindung zum lokalen Repository hinzufügen, können Sie sie als benannte Verknüpfung in Git-Befehlen verwenden.
```
git remote add origin git@$REMOTE:/git-server/repos/olamkvm.git
```
Der Pfad nach dem Doppelpunkt ist das Verzeichnis des Repositorys auf dem Remote-Git-Server.
Prüfen Sie den neu hinzugefügten Verbindungsdatensatz.
```
git remote -v
```
Die Ausgabe zeigt den Verbindungsdatensatz origin an, der auf den Remote-Git-Repository-Speicherort für die Befehle git fetch und git push verweist.
Übertragen Sie die lokalen Repository-Änderungen an das Remote Repository.
```
git push origin main
```
Die Verwendung der olamkvm-Quelle in einem Oracle Linux Automation Manager-Projekt ist jetzt möglich.

Ansible Galaxy-Zugangsdaten erstellen

Mit diesen Zugangsdaten kann Oracle Linux Automation Manager die OCI-Ansible-Sammlung aus dem öffentlichen Ansible Galaxy Hub abrufen.

Öffnen Sie ein neues Terminalfenster, und konfigurieren Sie einen SSH-Tunnel zur olam-node-Instanz.
```
ssh -L 8444:localhost:443 oracle@<ip_address_of_instance>
```
Öffnen Sie einen Webbrowser, und geben Sie die URL ein.
```
https://localhost:8444
```
Hinweis: Genehmigen Sie die Sicherheitswarnung basierend auf dem verwendeten Browser. Klicken Sie für den Chrome-Browser auf die Schaltfläche Erweitert und dann auf den Link Weiter zu localhost (unsicher).
Melden Sie sich bei Oracle Linux Automation Manager WebUI an. Verwenden Sie den Benutzernamen admin und das Kennwort admin, die beim automatisierten Deployment erstellt wurden.
Die WebUI wird nach einer erfolgreichen Anmeldung angezeigt.
Klicken Sie im Navigationsmenü im Abschnitt Ressourcen auf Zugangsdaten.
Klicken Sie auf die Schaltfläche Hinzufügen.
Geben Sie die folgenden Werte in die entsprechenden Felder ein, oder wählen Sie sie aus.

Bei Feldern mit einer Suche oder Werteliste können Sie den angeforderten Wert eingeben und dann auswählen.
- Name: My Ansible Galaxy
- Organisation: Default
- Zugangsdatentyp: Ansible Galaxy/Automation Hub-API-Token
Oracle Linux Automation Manager verwendet die Ansible Galaxy-Zugangsdaten, um das Herunterladen von Rollen und Collections mit dem Befehl ansible-galaxy zu ermöglichen.
- Galaxyserver-URL: https://galaxy.ansible.com
Prüfen Sie die Einträge, und klicken Sie auf die Schaltfläche Speichern.
Klicken Sie im Navigationsmenü im Abschnitt Zugriff auf Organisationen.

Wenn Sie die Ansible Galaxy-Zugangsdaten innerhalb der Organisation zuweisen, können Sie die Oracle Linux Infrastructure-Ansible-Sammlung aus dem Git-Projekt herunterladen.
Klicken Sie auf die Organisation Standard und dann auf die Schaltfläche Bearbeiten.
Wählen Sie die Suchoption im Feld Galaxiezugangsdaten aus.
Wählen Sie im Popup-Dialogfeld Galaxie-Zugangsdaten auswählen die Option Mein Ansible-Galaxie aus, und klicken Sie auf die Schaltfläche Auswählen.
Prüfen Sie, und klicken Sie auf Speichern.

Rechnerzugangsdaten erstellen

Mit diesen Zugangsdaten kann Oracle Linux Automation Manager über SSH eine Verbindung zum KVM-Virtualisierungssystem herstellen.

Klicken Sie im Navigationsmenü unter Ressourcen auf Zugangsdaten.
Klicken Sie auf die Schaltfläche Hinzufügen.
Geben Sie die folgenden Werte in die entsprechenden Felder ein, oder wählen Sie sie aus.

Bei Feldern mit einer Suche oder Werteliste können Sie den angeforderten Wert eingeben und dann auswählen.
- Name: My KVM Server
- Organisation: Default
- Zugangsdatentyp: Maschine
Oracle Linux Automation Manager verwendet die Rechnerzugangsdaten, um die Informationen festzulegen, die beim Herstellen einer SSH-Verbindung zu einem Host erforderlich sind.

Die Seite wird aktualisiert und fordert die Typdetails an.
Geben Sie den Benutzernamen ein.
- Benutzername: oracle
Klicken Sie auf die Schaltfläche Durchsuchen für den SSH-Private Key.

In einem Dialogfeld wird das Fenster "Datei öffnen" angezeigt.
Klicken Sie mit der rechten Maustaste in den mittleren Bereich des Fensters "Datei öffnen", und wählen Sie im Popup-Dialogfeld die Option Ausgeblendete Dateien anzeigen aus.
Klicken Sie auf eine beliebige Stelle im mittleren Fensterbereich, um das Dialogfeld zu schließen.
Klicken Sie im Navigationsmenü auf der linken Seite des Fensters "Datei öffnen" auf den Speicherort Home.
Doppelklicken Sie in der Liste auf den Ordner .ssh, und doppelklicken Sie dann auf die Datei id_rsa.

Mit dieser Aktion wird der Inhalt der Datei id_rsa in das Feld SSH-Private Key kopiert.
Prüfen Sie die Einträge, scrollen Sie dann nach unten, und klicken Sie auf die Schaltfläche Speichern.

Bestand erstellen

Klicken Sie im Navigationsmenü auf Bestände.
Klicken Sie auf die Schaltfläche Hinzufügen, und wählen Sie Bestand hinzufügen aus der Dropdown-Werteliste.
Geben Sie die folgenden Werte in die entsprechenden Felder ein, oder wählen Sie sie aus.
- Name: KVM Servers
- Instanzgruppen: Controlplane
Prüfen Sie, und klicken Sie auf Speichern.

Gruppe zu einem Bestand hinzufügen

Eine Gruppe innerhalb eines Bestands ist eine Klassifizierung von Hosts oder anderen Gruppen, mit denen eine Gruppe von Hosts für eine bestimmte Aufgabe gesteuert werden kann.

Klicken Sie auf der Seite Details der KVM-Server auf die Registerkarte Gruppen.
Klicken Sie auf die Schaltfläche Hinzufügen.
Geben Sie die folgenden Werte in die entsprechenden Felder ein, oder wählen Sie sie aus.
- Name: kvm
Prüfen Sie, und klicken Sie auf Speichern.

Host zur Bestandsgruppe hinzufügen

Klicken Sie auf der kvm-Seite Gruppendetails auf die Registerkarte Hosts.
Klicken Sie auf die Schaltfläche Hinzufügen, und wählen Sie Neuen Host hinzufügen aus der Dropdown-Werteliste.
Geben Sie die folgenden Werte in die entsprechenden Felder ein, oder wählen Sie sie aus.
- Name: Verwenden Sie die öffentliche IP-Adresse des kvm-server-Hosts.
Prüfen Sie, und klicken Sie auf Speichern.

Bestandsgruppe pingen

Mit dem ping-Modul können Sie prüfen, ob Oracle Linux Automation eine Verbindung zum Host in der Bestandsgruppe herstellen kann.

Verwenden Sie die Navigationspfade, und klicken Sie auf KVM-Server.
Klicken Sie auf das Register Gruppen.
Aktivieren Sie das Kontrollkästchen neben der Gruppe kvm, und klicken Sie auf die Schaltfläche Befehl ausführen.

Das Popup-Dialogfeld Befehl ausführen wird angezeigt.
Wählen Sie das ping-Modul, und klicken Sie auf die Schaltfläche Weiter.
Wählen Sie die Ausführungsumgebung OLAM EE (2.2) aus, und klicken Sie auf die Schaltfläche Weiter.
Wählen Sie die Rechnerzugangsdaten Mein KVM-Server aus, und klicken Sie auf die Schaltfläche Weiter.
Prüfen Sie, und klicken Sie auf die Schaltfläche Start.

Ein Job wird gestartet und zeigt die Ausgabe des ping-Moduls an.

Source Control-Zugangsdaten hinzufügen

Klicken Sie im Navigationsmenü auf Zugangsdaten.
Klicken Sie auf die Schaltfläche Hinzufügen.
Geben Sie die folgenden Werte in die entsprechenden Felder ein, oder wählen Sie sie aus.
- Name: Git Server
- Organisation: Default
- Zugangsdatentyp: Quellkontrolle
Die Seite wird aktualisiert und fordert die Typdetails an.
Geben Sie den Benutzernamen ein.
- Benutzername: git
Geben Sie den SCM-Private Key ein

Klicken Sie auf die Schaltfläche Durchsuchen, und doppelklicken Sie auf die Datei id_rsa. Mit dieser Aktion wird der Schlüsselinhalt in das Feld SCM-Private Key kopiert.
Prüfen Sie, und klicken Sie auf Speichern.

Projekt erstellen

Klicken Sie im Navigationsmenü auf Projekte.
Klicken Sie auf die Schaltfläche Hinzufügen.
Geben Sie die folgenden Werte in die entsprechenden Felder ein, oder wählen Sie sie aus.
- Name: My Project
- Ausführungsumgebung: OLAM EE (2.2)
- Zugangsdatenart für Quellkontrolle: Git
Die Seite wird aktualisiert und fordert die Typdetails an.
Geben Sie die Remote-URL des Git-Servers ein.
- Quellkontroll-URL: git@<ip_address_of_instance>:/git-server/repos/olamkvm.git
Wählen Sie Git-Server als Quellkontrollzugangsdaten aus.
Prüfen Sie, und klicken Sie auf Speichern.
Prüfen Sie den Synchronisierungsstatus des Projekts.

Nach der Projekterstellung zeigt das Projekt seinen Status in der Übersicht Details an, sobald die Synchronisierung beginnt. Der Status geht von Wird ausgeführt in Erfolgreich über, wenn die Konfiguration korrekt ist und der Git-Server erreichbar ist.

Jobvorlage erstellen

Klicken Sie im Navigationsmenü auf Vorlagen.
Klicken Sie auf die Schaltfläche Hinzufügen, und wählen Sie Jobvorlage hinzufügen aus der Dropdown-Werteliste aus.
Geben Sie die erforderlichen Werte ein.
- Name: My Template
- Jobtyp: Ausführen
- Lager: KVM-Server
- Projekt: Mein Projekt
- Ausführungsumgebung: OLAM EE (2.2)
- Playbook: create_vm.yml
- Zugangsdaten: Mein KVM-Server
Prüfen Sie, scrollen Sie nach unten, und klicken Sie auf die Schaltfläche Speichern.
Starten Sie die Vorlage.

Starten Sie einen Job auf der Vorlagenübersichtsseite, indem Sie auf die Schaltfläche Starten klicken.

Wenn der Job erfolgreich war, wird er gestartet und zeigt die Ausgabe aus der Vorlage an. Die Standardausgabe zeigt das laufende Spielbuch und gibt die Ergebnisse des Spielbuchs aus.

Erstellung der virtuellen Maschine prüfen

Öffnen Sie ein Terminal und verbinden Sie sich über ssh mit dem kvm-server-Knoten.
```
ssh oracle@<ip_address_of_instance>
```

Rufen Sie eine Liste der ausgeführten VMs ab.

sudo virsh list

Beispielausgabe:

[oracle@kvm-server ~]$ sudo virsh list
 Id   Name      State
-------------------------
 1    ol9-dev   running

Rufen Sie die IP-Adresse der ol9-dev-VM ab.

sudo virsh net-dhcp-leases default

Beispielausgabe:

[oracle@kvm-server ~]$ sudo virsh net-dhcp-leases default
 Expiry Time           MAC address         Protocol   IP address           Hostname   Client ID or DUID
------------------------------------------------------------------------------------------------------------
 2023-04-06 18:59:33   52:54:00:6e:93:07   ipv4       192.168.122.167/24   ol9-dev    01:52:54:00:6e:93:07

Melden Sie sich bei der VM an.
```
ssh opc@$(sudo virsh -q domifaddr ol9-dev | awk '{print substr($4, 1, length($4)-3)}')
```
Der -q entfernt den Header aus der Ausgabe der virsh-Befehle. Die awk ruft die vierte Spalte aus dem Befehl virsh domifaddr ab, und die substr() entfernt die letzten drei Zeichen.
Trennen Sie die Verbindung zur VM.
```
exit
```

(Optional) Weitere virtuelle Maschine erstellen

In der Arbeitsmappe können Sie eine weitere VM erstellen, indem Sie die Variable vm_name ändern.

Wechseln Sie zum Browserfenster mit Oracle Linux Automation Manager WebUI, und melden Sie sich gegebenenfalls an.
Klicken Sie im Navigationsmenü auf Vorlagen.
Klicken Sie auf das Symbol Vorlage bearbeiten für Meine Vorlage.
Fügen Sie die Variable vm_name mit dem Wert ol9-new zum Abschnitt Variablen hinzu.
Scrollen Sie nach unten, und klicken Sie auf Speichern.
Starten Sie die Vorlage.
Wiederholen Sie die Schritte zur Verifizierung der virtuellen Maschine, und stellen Sie eine Verbindung zur neu erstellten VM her.

Nächste Schritte

Die erfolgreiche Jobausgabe von Oracle Linux Automation Manager und die Möglichkeit, eine SSH-Verbindung zur virtuellen Maschine herzustellen, bestätigen, dass alles funktioniert. Experimentieren Sie weiter mit der Sammlung community.libvirt und dem Erstellen virtueller Maschinen in Oracle Linux KVM, um Ihre Infrastruktur zu erweitern. Versuchen Sie dann, diese virtuellen Maschinen mit zusätzlichen Playbooks bereitzustellen. Sehen Sie sich unsere zusätzlichen Schulungen an der Oracle Linux-Schulungsstation an.

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie im Oracle Learning YouTube-Channel auf weitere kostenlose Lerninhalte zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Manage KVM Virtual Machines using Oracle Linux Automation Manager

G32912-01