Nota

Gestisci le virtual machine KVM utilizzando Oracle Linux Automation Manager

Introduzione

La raccolta community.libvirt fornisce moduli e plugin libvirt supportati dalla comunità libvirt di Ansible. Questi moduli e plugin aiutano a gestire le virtual machine (VM) e i contenitori utilizzando l'API libvirt.

Obiettivi

In questo tutorial imparerai come:

Prerequisiti

Nota: per i dettagli sull'installazione di Oracle Linux Automation Manager o KVM, vedere i collegamenti alla fine di questo laboratorio.

Distribuisci Oracle Linux Automation Manager

Nota: se è in esecuzione nella propria tenancy, leggere il progetto linux-virt-labs GitHub README.md e completare i prerequisiti prima di distribuire l'ambiente di esercitazione pratica.

  1. Aprire un terminale sul Luna Desktop.

  2. Duplica il progetto linux-virt-labs GitHub.

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

  3. Passare alla directory di lavoro.

    cd linux-virt-labs/olam

  4. Installare le raccolte richieste.

    ansible-galaxy collection install -r requirements.yml

  5. Aggiornare la configurazione dell'istanza Oracle Linux.

    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

  6. Implementa l'ambiente di laboratorio.

    ansible-playbook create_instance.yml -e ansible_python_interpreter="/usr/bin/python3.6" -e "@instances.yml"

    L'ambiente di laboratorio gratuito richiede la variabile aggiuntiva ansible_python_interpreter perché installa il pacchetto RPM per l'SDK Oracle Cloud Infrastructure per Python. La posizione dell'installazione di questo pacchetto si trova sotto i moduli python3.6.

    La forma di distribuzione predefinita utilizza la CPU AMD e Oracle Linux 8. Per utilizzare una CPU Intel o Oracle Linux 9, aggiungere -e instance_shape="VM.Standard3.Flex" o -e os_version="9" al comando di distribuzione.

    Importante: attendere la corretta esecuzione della guida e raggiungere il task di sospensione. L'installazione di Oracle Linux Automation Manager è stata completata in questa fase del playbook e le istanze sono pronte. Prendi nota della riproduzione precedente, che stampa gli indirizzi IP pubblici e privati dei nodi che distribuisce.

Crea un Playbook

  1. Aprire una nuova finestra del terminale.

  2. Impostare una variabile sull'istanza remota di git-server.

    export REMOTE=<ip_address_of_instance>

  3. Creare la directory del progetto.

    mkdir ~/olamkvm

  4. Creare un file dei requisiti.

    Oracle Linux Automation Engine utilizza il file dei requisiti per inserire nel progetto le raccolte o i ruoli necessari in fase di esecuzione.

    cat << EOF > ~/olamkvm/requirements.yml 
---
collections:
  - name: community.libvirt
  - name: community.general
  - name: community.crypto
EOF

  5. Creare un file di variabili.

    Il file memorizza le variabili e i relativi valori predefiniti. La playbook importa questo file in fase di esecuzione.

    1. Creare una directory per memorizzare il file.

      mkdir ~/olamkvm/vars

    2. Creare il file.

      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

  6. Creare i modelli cloud-init.

    Questi modelli creano i file meta-data e user-data per eseguire il provisioning della configurazione VM tramite cloud-init.

    1. Creare una directory in cui memorizzare i modelli.

      mkdir ~/olamkvm/templates

    2. Creare il modello di metadati.

      cat << EOF > ~/olamkvm/templates/meta-data.j2
instance-id: iid-local01
local-hostname: 
EOF

    3. Creare il modello dati utente.

      cat << EOF > ~/olamkvm/templates/user-data.j2
#cloud-config

system_info:
  default_user:
    name: opc

ssh_authorized_keys:
  - 
EOF

  7. Creare il modello di definizione VM libvirt.

    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

  8. Crea una guida.

    Questa guida esegue una query sul server KVM per le VM esistenti, quindi distribuisce una nuova immagine cloud Oracle Linux.

    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

Aggiunta del progetto al controllo versione

  1. Inizializzare la directory di lavoro del progetto in un repository Git.

    Prima di inizializzare il repository, è necessario eseguire alcuni passi di impostazione iniziale di Git.

    1. Impostare il nome diramazione predefinito utilizzato durante l'inizializzazione di un progetto.

      git config --global init.defaultBranch main

    2. Imposta la tua identità.

      L'e-mail e il nome sono esempi in questa esercitazione. Utilizza la tua email e il tuo nome quando lavori ai tuoi progetti, poiché queste informazioni vengono immutabilmente inserite in ogni commit.

      git config --global user.email johndoe@example.com
git config --global user.name "John Doe"

    3. Passare alla directory di lavoro del progetto.

      cd ~/olamkvm

    4. Inizializzare la directory come repository Git locale.

      git init

      Il comando restituisce che ha inizializzato il repository Git vuoto.

  2. Controllare lo stato della directory di lavoro e dell'area intermedia del progetto.

    git status

    Lo stato del repository locale indica due file non controllati, create_vm.yml e requirements.yml, e le directory vars e templates.

  3. Aggiungere e tenere traccia dei nuovi file nell'area intermedia.

    git add --all

    L'opzione --all consente di aggiungere all'area intermedia tutti i file non tracciati e modificati.

  4. Eseguire il commit delle modifiche attualmente nell'area intermedia.

    git commit -m 'initial commit'

    L'opzione -m consente di aggiungere un commento alle modifiche di cui è stato eseguito il commit.

  5. Creare e inizializzare il repository Git remoto.

    Un repository remoto è un repository condiviso utilizzato da tutti i collaboratori del progetto e memorizzato in un servizio di code-hosting come GitHub o in un server self-hosted.

    ssh git@$REMOTE "git init -b main --bare /git-server/repos/olamkvm.git"

    L'opzione -b garantisce l'inizializzazione del repository remoto utilizzando una diramazione denominata main.

  6. Accettare l'impronta digitale del tasto ECDSA digitando yes.

  7. Aggiungere il nuovo record di connessione al repository remoto.

    L'aggiunta della connessione remota al repository locale consente di utilizzarla come collegamento denominato nei comandi Git.

    git remote add origin git@$REMOTE:/git-server/repos/olamkvm.git

    Il percorso dopo i due punti è la posizione della directory del repository sul server Git remoto.

  8. Verificare il record di connessione appena aggiunto.

    git remote -v

    L'output mostra il record di connessione origin che punta alla posizione del repository Git remoto sia per i comandi git fetch che per i comandi git push.

  9. Esegue il push delle modifiche del repository locale nel repository remoto.

    git push origin main

    È ora possibile utilizzare l'origine olamkvm all'interno di un progetto Oracle Linux Automation Manager.

Crea credenziali Galaxy Ansible

Queste credenziali consentono a Oracle Linux Automation Manager di estrarre la raccolta Ansible OCI dall'hub Galaxy Ansible pubblico.

  1. Aprire una nuova finestra del terminale e configurare un tunnel SSH per l'istanza olam-node.

    ssh -L 8444:localhost:443 oracle@<ip_address_of_instance>

  2. Aprire un browser Web e immettere l'URL.

    https://localhost:8444

    Nota: approvare l'avvertenza di sicurezza in base al browser utilizzato. Per il browser Chrome, fare clic sul pulsante Avanzate, quindi sul collegamento Procedi a localhost (non sicuro).

  3. Eseguire il login a Oracle Linux Automation Manager WebUI. Utilizzare il nome utente admin e la password admin creati durante la distribuzione automatica.

    olam2: login

  4. Il valore WebUI viene visualizzato dopo un login riuscito.

    olam2-webui

  5. Fare clic su Credenziali nella sezione Risorse del menu di navigazione.

  6. Fare clic sul pulsante Aggiungi.

  7. Immettere o selezionare i seguenti valori nei campi specifici.

    Per i campi con una ricerca o un elenco di valori, è possibile iniziare a digitare il valore richiesto e quindi selezionarlo.

    • Nome: My Ansible Galaxy
    • Organizzazione: Default
    • Tipo di credenziale: token API Ansible Galaxy/Automation Hub

    Oracle Linux Automation Manager utilizza le credenziali Ansible Galaxy per consentire il download di ruoli e raccolte mediante il comando ansible-galaxy.

    • URL di Galaxy Server: https://galaxy.ansible.com

    olam2-ansible-galaxy-creds

  8. Rivedere le voci e fare clic sul pulsante Salva.

  9. Fare clic su Organizzazioni nella sezione Accesso del menu di navigazione.

    L'assegnazione della credenziale Ansible Galaxy all'interno dell'organizzazione consente di scaricare la raccolta Ansible dell'infrastruttura Oracle Linux dall'interno del progetto git.

  10. Fare clic sull'organizzazione Predefinita e fare clic sul pulsante Modifica.

  11. Selezionare l'opzione di ricerca nel campo Credenziali galassie.

  12. Selezionare Il mio Galaxy Ansible nella finestra di dialogo popup Seleziona credenziali Galaxy e fare clic sul pulsante Seleziona.

  13. Rivedere e fare clic sul pulsante Salva.

    olam2-ansible-galaxy-org

Crea credenziali computer

Queste credenziali consentono a Oracle Linux Automation Manager di connettersi al sistema di virtualizzazione KVM tramite SSH.

  1. Fare clic su Credenziali in Risorse nel menu di navigazione.

  2. Fare clic sul pulsante Aggiungi.

  3. Immettere o selezionare i seguenti valori nei campi specifici.

    Per i campi con una ricerca o un elenco di valori, è possibile iniziare a digitare il valore richiesto e quindi selezionarlo.

    • Nome: My KVM Server
    • Organizzazione: Default
    • Tipo di credenziale: computer

    Oracle Linux Automation Manager utilizza le credenziali del computer per impostare le informazioni necessarie quando si stabilisce una connessione SSH a un host.

    La pagina viene aggiornata, richiedendo i dettagli del tipo.

  4. Immettere il nome utente.

    • Nome utente: oracle

    olam2-machine-creds

  5. Fare clic sul pulsante Sfoglia per la chiave privata SSH.

    Viene visualizzata una finestra di dialogo in cui è visualizzata la finestra Open File (Apri file).

  6. Fare clic con il pulsante destro del mouse nel pannello centrale della finestra Apri file e selezionare Mostra file nascosti nella finestra di dialogo popup.

    olam2-file-apertura

  7. Fare clic in un punto qualsiasi del pannello centrale per chiudere la finestra di dialogo.

  8. Fare clic sulla posizione Home nel menu di navigazione sul lato sinistro della finestra Open File.

  9. Fare doppio clic sulla cartella .ssh nell'elenco, quindi fare doppio clic sul file id_rsa.

    Questa azione copia il contenuto del file id_rsa nel campo Chiave privata SSH.

  10. Rivedere le voci, quindi scorrere fino alla parte inferiore e fare clic sul pulsante Salva.

Creare un inventario

  1. Fare clic su Inventari nel menu di navigazione.

  2. Fare clic sul pulsante Aggiungi e selezionare Aggiungi magazzino dall'elenco a discesa di valori.

  3. Immettere o selezionare i seguenti valori nei campi specifici.

    • Nome: KVM Servers
    • Gruppi di istanze: piano di controllo

  4. Rivedere e fare clic sul pulsante Salva.

    olam2-inv

Aggiungi un gruppo a un magazzino

Un gruppo all'interno di un inventario è una classificazione di host o altri gruppi che consentono di controllare un set di host per un determinato task.

  1. Fare clic sulla scheda Gruppi nella pagina Dettagli dei server KVM.

    olam2-inv-kvm-dettagli

  2. Fare clic sul pulsante Aggiungi.

  3. Immettere o selezionare i seguenti valori nei campi specifici.

    • Nome: kvm

  4. Rivedere e fare clic sul pulsante Salva.

    olam2-kvm-group-details

Aggiungere un host al gruppo di magazzino

  1. Fare clic sulla scheda Host nella pagina Dettagli gruppo kvm.

    olam2-kvm-group-details

  2. Fare clic sul pulsante Aggiungi e selezionare Aggiungi nuovo host dall'elenco a discesa dei valori.

  3. Immettere o selezionare i seguenti valori nei campi specifici.

    • Nome: utilizzare l'indirizzo IP pubblico dell'host kvm-server.

  4. Rivedere e fare clic sul pulsante Salva.

    olam2-grp-nuovo-host

Ping del gruppo di magazzino

Utilizzare il modulo ping per verificare che Oracle Linux Automation possa connettersi all'host all'interno del gruppo di inventario.

  1. Utilizzare gli indicatori di percorso e fare clic su Server KVM.

  2. Fare clic sulla scheda Gruppi.

  3. Selezionare la casella accanto al gruppo kvm e fare clic sul pulsante Esegui comando.

    Viene visualizzata la finestra di dialogo popup Run Command.

  4. Selezionare il modulo ping e fare clic sul pulsante Successivo.

  5. Selezionare l'ambiente di esecuzione OLAM EE (2.2) e fare clic sul pulsante Successivo.

  6. Selezionare la credenziale computer My KVM Server e fare clic sul pulsante Next.

  7. Rivedere e fare clic sul pulsante Esegui.

    Un job viene avviato e viene visualizzato l'output del modulo ping.

    olam2-kvm-grp-ping

Aggiungi credenziale di controllo dell'origine

  1. Fare clic su Credenziali nel menu di navigazione.

  2. Fare clic sul pulsante Aggiungi.

  3. Immettere o selezionare i seguenti valori nei campi specifici.

    • Nome: Git Server
    • Organizzazione: Default
    • Tipo di credenziale: Controllo origine

    olam2-git-cred1

    La pagina viene aggiornata, richiedendo i dettagli del tipo.

  4. Immettere il nome utente.

    • Nome utente: git

  5. Immettere la chiave privata SCM

    Fare clic sul pulsante Sfoglia e fare doppio clic sul file id_rsa. Questa azione copia il contenuto della chiave nel campo Chiave privata SCM.

    olam2-git-cred2

  6. Rivedere e fare clic sul pulsante Salva.

    olam2-git-cred3

Crea un progetto

  1. Fare clic su Progetti nel menu di navigazione.

  2. Fare clic sul pulsante Aggiungi.

  3. Immettere o selezionare i seguenti valori nei campi specifici.

    • Nome: My Project
    • Ambiente di esecuzione: OLAM EE (2.2)
    • Tipo di credenziale di controllo origine: Git

    olam2-proj1

    La pagina viene aggiornata, richiedendo i dettagli del tipo.

  4. Immettere l'URL remoto di git-server.

    • URL controllo origine: git@<ip_address_of_instance>:/git-server/repos/olamkvm.git

  5. Selezionare Server Git per la Credenziale di controllo origine.

  6. Rivedere e fare clic sul pulsante Salva.

    olam2-proj2

  7. Rivedere lo stato di sincronizzazione del progetto.

    Dopo la creazione del progetto, il relativo stato verrà visualizzato nel riepilogo Dettagli all'inizio della sincronizzazione. Lo stato passa da In esecuzione a Riuscito se la configurazione è corretta e il server Git è raggiungibile.

    olam2-sincronizzazione-prog

Crea un modello di job

  1. Fare clic su Modelli nel menu di navigazione.

  2. Fare clic sul pulsante Aggiungi e selezionare Aggiungi modello di job dall'elenco a discesa dei valori.

  3. Immettere i valori obbligatori.

    • Nome: My Template
    • Tipo di job: Esegui
    • Inventario: server KVM
    • Progetto: Progetto personale
    • Ambiente di esecuzione: OLAM EE (2.2)
    • Playbook: create_vm.yml
    • Credenziali: il mio server KVM

    olam2-temp1

  4. Rivedere, scorrere verso il basso e fare clic sul pulsante Salva.

    olam2-temp2

  5. Avviare il modello.

    Avviare un job dalla pagina di riepilogo del modello facendo clic sul pulsante Avvia.

    olam2-avvio-temp

    In caso di esito positivo, il job viene avviato e viene visualizzato l'output del modello. L'output standard mostra il playbook in esecuzione e restituisce i risultati del playbook.

    olam2-output-temp

Verifica creazione virtual machine

  1. Aprire un terminale e connettersi tramite ssh al nodo kvm-server.

    ssh oracle@<ip_address_of_instance>

  2. Ottenere una lista di VM in esecuzione.

    sudo virsh list

    Output di esempio:

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

  3. Ottenere l'indirizzo IP della VM ol9-dev.

    sudo virsh net-dhcp-leases default

    Output di esempio:

    [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

  4. Connettersi alla VM.

    ssh opc@$(sudo virsh -q domifaddr ol9-dev | awk '{print substr($4, 1, length($4)-3)}')

    Il comando -q rimuove l'intestazione dall'output dei comandi virsh. Il comando awk estrae la quarta colonna dal comando virsh domifaddr e il comando substr() rimuove gli ultimi tre caratteri.

  5. Disconnettersi dalla VM.

    exit

(Facoltativo) Creare un'altra virtual machine

La guida consente di creare un'altra VM modificando la variabile vm_name.

  1. Passare alla finestra del browser contenente Oracle Linux Automation Manager WebUI ed effettuare il login, se necessario.

  2. Fare clic su Modelli nel menu di navigazione.

  3. Fare clic sull'icona Modifica modello per Modello personale.

    olam2-temp-edit

  4. Aggiungere la variabile vm_name con il valore ol9-new alla sezione Variabili.

    olam2-vars-temp

  5. Scorrere verso il basso e fare clic sul pulsante Salva.

  6. Avviare il modello.

  7. Ripetere i passi di verifica della virtual machine e connettersi alla VM appena creata.

Passi successivi

L'output del job di successo di Oracle Linux Automation Manager e la possibilità di accedere tramite SSH alla virtual machine confermano che tutto funziona. Scopri di più sulla raccolta community.libvirt e sulla creazione di virtual machine all'interno di Oracle Linux KVM per espandere la tua infrastruttura. Quindi, prova a eseguire il provisioning di tali macchine virtuali con playbook aggiuntivi. Dai un'occhiata alla nostra formazione aggiuntiva presso Oracle Linux Training Station.

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare un Oracle Learning Explorer.

Per la documentazione del prodotto, visita l'Oracle Help Center.