Note:

• Este tutorial está disponible en un entorno de prácticas gratuito proporcionado por Oracle.
• Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar la práctica, sustituya estos valores por otros específicos de su entorno en la nube.

Gestión de máquinas virtuales KVM con Oracle Linux Automation Manager

Introducción

La recopilación community.libvirt proporciona módulos libvirt y plugins admitidos por la comunidad libvirt de Ansible. Estos módulos y plugins ayudan a gestionar máquinas virtuales (VM) y contenedores mediante la API libvirt.

Objetivos

En este tutorial, aprenderá a:

• Crea un cuaderno de estrategias que utilice la colección community.libvirt
• Configurar credenciales para Ansible Galaxy
• Creación de una plantilla de trabajo
• Ejecute el trabajo

Requisitos

• Un sistema con Oracle Linux Automation Manager instalado
• Acceso a un repositorio de Git
• Un sistema Oracle Linux con KVM instalado

Nota: Para obtener más información sobre la instalación de Oracle Linux Automation Manager o KVM, consulte los enlaces al final de este laboratorio.

Despliegue de Oracle Linux Automation Manager

Nota: Si se ejecuta en su propio arrendamiento, lea el proyecto linux-virt-labs GitHub README.md y complete los requisitos antes de desplegar el entorno de prácticas.

1. Abra un terminal en el escritorio Luna.

2. Clone el proyecto linux-virt-labs GitHub.

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

3. Cambie al directorio de trabajo.

   cd linux-virt-labs/olam
   

4. Instale las recopilaciones necesarias.

   ansible-galaxy collection install -r requirements.yml
   

5. Actualice la configuración de la instancia de 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. Despliegue el entorno de prácticas.

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

   El entorno de prácticas gratuito necesita la variable adicional ansible_python_interpreter porque instala el paquete de RPM para el SDK para Python de Oracle Cloud Infrastructure. La ubicación de la instalación de este paquete está en los módulos python3.6.

   La unidad de despliegue por defecto utiliza la CPU AMD y Oracle Linux 8. Para utilizar una CPU de Intel u Oracle Linux 9, agregue -e instance_shape="VM.Standard3.Flex" o -e os_version="9" al comando de despliegue.

   Importante: Espere a que el cuaderno de estrategias se ejecute correctamente y alcance la tarea de pausa. La instalación de Oracle Linux Automation Manager se ha completado en esta etapa del manual y las instancias están listas. Tome nota de la reproducción anterior, que imprime las direcciones IP públicas y privadas de los nodos que despliega.

Crear un cuaderno de estrategias

1. Abra una ventana de terminal nueva.

2. Defina una variable en la instancia remota de git-server.

   export REMOTE=<ip_address_of_instance>
   

3. Cree el directorio del proyecto.

   mkdir ~/olamkvm
   

4. Cree un archivo de requisitos.

   Oracle Linux Automation Engine utiliza el archivo de requisitos para extraer las recopilaciones o roles necesarios en el proyecto en tiempo de ejecución.

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

5. Cree un archivo de variables.

   El archivo almacena variables y sus valores por defecto. El manual importa este archivo en tiempo de ejecución.

   1. Cree un directorio para almacenar el archivo.

      mkdir ~/olamkvm/vars
      

   2. Cree el archivo.

      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. Cree las plantillas de cloud-init.

   Estas plantillas crean los archivos meta-data y user-data para aprovisionar la configuración de VM mediante cloud-init.

   1. Cree un directorio para almacenar las plantillas.

      mkdir ~/olamkvm/templates
      

   2. Cree la plantilla de metadatos.

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

   3. Cree la plantilla de datos de usuario.

      cat << EOF > ~/olamkvm/templates/user-data.j2
      #cloud-config
      
      system_info:
        default_user:
          name: opc
      
      ssh_authorized_keys:
        - 
      EOF
      

7. Cree la plantilla de definición de VM de 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. Crear un libro de estrategias.

   En este manual, se consulta al servidor KVM para las máquinas virtuales existentes y, a continuación, se despliega una nueva imagen de Oracle Linux Cloud.

   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
   

Adición del proyecto al control de origen

1. Inicialice el directorio de trabajo del proyecto en un repositorio de Git.

   Antes de inicializar el repositorio, debe realizar algunos pasos de configuración de Git por primera vez.

   1. Defina el nombre de rama por defecto utilizado al inicializar un proyecto.

      git config --global init.defaultBranch main
      

   2. Defina su identidad.

      El correo electrónico y el nombre son ejemplos de este tutorial. Utilice su correo electrónico y nombre al trabajar en sus proyectos, ya que esta información se integra inmutablemente en cada compromiso.

      git config --global user.email [e-mail]
      git config --global user.name "John Doe"
      

   3. Cambie al directorio de trabajo del proyecto.

      cd ~/olamkvm
      

   4. Inicialice el directorio como repositorio de Git local.

      git init
      

      El comando devuelve que inicializó el repositorio de Git vacío.

2. Compruebe el estado del directorio de trabajo y del área temporal del proyecto.

   git status
   

   El estado del repositorio local indica dos archivos sin seguimiento, create_vm.yml y requirements.yml, y los directorios vars y templates.

3. Agregue y realice un seguimiento de los nuevos archivos en el área temporal.

   git add --all
   

   La opción --all agrega todos los archivos sin seguimiento y modificados al área temporal.

4. Confirme los cambios actualmente en el área temporal.

   git commit -m 'initial commit'
   

   La opción -m permite agregar un comentario a los cambios confirmados.

5. Cree e inicialice el repositorio de Git remoto.

   Un repositorio remoto es un repositorio compartido utilizado por todos los contribuyentes de proyectos y almacenado en un servicio de alojamiento de código como GitHub o un servidor autoalojado.

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

   La opción -b garantiza la inicialización del repositorio remoto mediante una rama denominada main.

6. Acepte la huella de clave de ECDSA escribiendo yes.

7. Agregue el nuevo registro de conexión de repositorio remoto.

   Agregar la conexión remota al repositorio local le permite utilizarla como un acceso directo con nombre en los comandos de Git.

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

   La ruta después de los dos puntos es la ubicación del directorio del repositorio en el servidor Git remoto.

8. Verifique el registro de conexión recién agregado.

   git remote -v
   

   La salida muestra el registro de conexión origin que apunta a la ubicación del repositorio de Git remoto para los comandos git fetch y git push.

9. Transfiera los cambios del repositorio local al repositorio remoto.

   git push origin main
   

   Ahora es posible usar el origen olamkvm dentro de un proyecto de Oracle Linux Automation Manager.

Crear credenciales de Galaxy de Ansible

Estas credenciales permiten a Oracle Linux Automation Manager extraer la recopilación de OCI Ansible del Galaxy Hub público de Ansible.

1. Abra una nueva ventana de terminal y configure un túnel SSH a la instancia del nodo olam.

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

2. Abra un explorador web e introduzca la URL.

   https://localhost:8444
   

   Nota: Apruebe la advertencia de seguridad según el explorador utilizado. Para el explorador Chrome, haga clic en el botón Advanced (Avanzado) y, a continuación, en el enlace Proceed to localhost (unsafe) (Continuar con el host local [no seguro]).

3. Conéctese a Oracle Linux Automation Manager WebUI. Utilice el nombre de usuario admin y la contraseña admin creados durante el despliegue automatizado.

   

4. WebUI se muestra después de una conexión correcta.

   

5. Haga clic en Credenciales en la sección Recursos del menú de navegación.

6. Haga clic en el botón Agregar.

7. Introduzca o seleccione los siguientes valores en los campos específicos.

   Para los campos con una búsqueda o lista de valores, podemos comenzar a escribir el valor solicitado y luego seleccionarlo.

   • Name: My Ansible Galaxy
   • Organización: Default
   • Tipo de credencial: Token de API de Ansible Galaxy/Automation Hub

   Oracle Linux Automation Manager utiliza las credenciales de Ansible Galaxy para permitir la descarga de roles y recopilaciones mediante el comando ansible-galaxy.

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

   

8. Revise las entradas y haga clic en el botón Save (Guardar).

9. Haga clic en Organizations (Organizaciones) en la sección Access (Acceso) del menú de navegación.

   La asignación de la credencial de Ansible Galaxy dentro de la organización permite la descarga de la recopilación de Ansible de infraestructura de Oracle Linux desde el proyecto de git.

10. Haga clic en la organización Default (Por defecto) y haga clic en el botón Edit (Editar).

11. Seleccione la opción de búsqueda en el campo Credenciales de Galaxy.

12. Seleccione My Ansible Galaxy en el cuadro de diálogo emergente Select Galaxy Credentials y haga clic en el botón Select (Seleccionar).

13. Revise y haga clic en el botón Guardar.

    

Crear credenciales de máquina

Estas credenciales permiten a Oracle Linux Automation Manager conectarse al sistema de virtualización KVM a través de SSH.

1. Haga clic en Credenciales en Recursos en el menú de navegación.

2. Haga clic en el botón Agregar.

3. Introduzca o seleccione los siguientes valores en los campos específicos.

   Para los campos con una búsqueda o lista de valores, podemos comenzar a escribir el valor solicitado y luego seleccionarlo.

   • Name: My KVM Server
   • Organización: Default
   • Tipo de credencial: Máquina

   Oracle Linux Automation Manager utiliza las credenciales de máquina para definir la información necesaria al establecer una conexión SSH a un host.

   La página se refresca y solicita los detalles de tipo.

4. Introduzca el Usuario.

   • Nombre de usuario: oracle

   

5. Haga clic en el botón Browse (Examinar) para la clave privada SSH.

   Aparece un cuadro de diálogo que muestra la ventana Abrir archivo.

6. Haga clic con el botón derecho en el panel central de la ventana Abrir archivo y seleccione Mostrar archivos ocultos en el cuadro de diálogo emergente.

   

7. Haga clic en cualquier parte del panel central para descartar el cuadro de diálogo.

8. Haga clic en la ubicación Home (Inicio) en el menú de navegación ubicado en la parte izquierda de la ventana Open File (Abrir archivo).

9. Haga doble clic en la carpeta .ssh de la lista y, a continuación, haga doble clic en el archivo id_rsa.

   Esta acción copia el contenido del archivo id_rsa en el campo SSH Private Key.

10. Revise las entradas y, a continuación, desplácese hasta la parte inferior y haga clic en el botón Guardar.

Creación de un inventario

1. Haga clic en Inventarios en el menú de navegación.

2. Haga clic en el botón Agregar y seleccione Agregar inventario en la lista desplegable de valores.

3. Introduzca o seleccione los siguientes valores en los campos específicos.

   • Name: KVM Servers
   • Grupos de instancias: controlplane

4. Revise y haga clic en el botón Guardar.

   

Adición de un Grupo a un Inventario

Un grupo dentro de un inventario es una clasificación de hosts u otros grupos que permiten controlar un juego de hosts para una tarea determinada.

1. Haga clic en el separador Grupos de la página Detalles de los servidores de KVM.

   

2. Haga clic en el botón Agregar.

3. Introduzca o seleccione los siguientes valores en los campos específicos.

   • Name: kvm

4. Revise y haga clic en el botón Guardar.

   

Adición de un Host al Grupo de Inventario

1. Haga clic en el separador Hosts (Hosts) de la página Group details (Detalles de grupo) de kvm.

   

2. Haga clic en el botón Add (Agregar) y seleccione Add new host (Agregar nuevo host) en la lista desplegable de valores.

3. Introduzca o seleccione los siguientes valores en los campos específicos.

   • Nombre: utilice la dirección IP pública del host kvm-server.

4. Revise y haga clic en el botón Guardar.

   

Hacer ping en el grupo de inventario

Utilice el módulo ping para verificar que Oracle Linux Automation se pueda conectar al host dentro del grupo de inventario.

1. Utilice las rutas de navegación y haga clic en Servidores KVM.

2. Haga clic en el separador Grupos.

3. Marque la casilla junto al grupo kvm y haga clic en el botón Run Command (Ejecutar comando).

   Aparece el cuadro de diálogo emergente Run Command (Ejecutar comando).

4. Seleccione el módulo ping y haga clic en el botón Next (Siguiente).

5. Seleccione el entorno de ejecución de OLAM EE (2.2) y haga clic en el botón Siguiente.

6. Seleccione la credencial de máquina de My KVM Server y haga clic en el botón Next (Siguiente).

7. Revise y haga clic en el botón Iniciar.

   Un trabajo se inicia y muestra la salida del módulo ping.

   

Agregar credencial de control de origen

1. Haga clic en Credenciales en el menú de navegación.

2. Haga clic en el botón Agregar.

3. Introduzca o seleccione los siguientes valores en los campos específicos.

   • Name: Git Server
   • Organización: Default
   • Tipo de credencial: Control de origen

   

   La página se refresca y solicita los detalles de tipo.

4. Introduzca el Usuario.

   • Username: git

5. Introduzca la clave privada de SCM.

   Haga clic en el botón Examinar y haga doble clic en el archivo id_rsa. Esta acción copia el contenido de la clave en el campo Clave privada de SCM.

   

6. Revise y haga clic en el botón Guardar.

   

Crear proyecto

1. Haga clic en Projects (Proyectos) en el menú de navegación.

2. Haga clic en el botón Agregar.

3. Introduzca o seleccione los siguientes valores en los campos específicos.

   • Name: My Project
   • Entorno de ejecución: OLAM EE (2.2)
   • Source Control Credential Type (Tipo de credencial de control de origen): Git

   

   La página se refresca y solicita los detalles de tipo.

4. Introduzca la URL remota del servidor git.

   • URL de control de origen: git@<ip_address_of_instance>:/git-server/repos/olamkvm.git

5. Seleccione Servidor de Git para la Credencial de Control de Origen.

6. Revise y haga clic en el botón Guardar.

   

7. Revise el estado de sincronización del proyecto.

   Después de la creación del proyecto, el proyecto mostrará su estado en el resumen Detalles a medida que comience la sincronización. El estado pasa de Running a Successful si la configuración es correcta y se puede acceder al servidor de Git.

   

Creación de una plantilla de trabajo

1. Haga clic en Templates (Plantillas) en el menú de navegación.

2. Haga clic en el botón Agregar y seleccione Agregar plantilla de trabajo en la lista desplegable de valores.

3. Introduzca los valores necesarios.

   • Name: My Template
   • Tipo de trabajo: Ejecutar
   • Inventario: servidores KVM
   • Proyecto: Mi proyecto
   • Entorno de ejecución: OLAM EE (2.2)
   • Libro de reproducción: create_vm.yml
   • Credenciales: Mi servidor KVM

   

4. Revise, desplácese hacia abajo y haga clic en el botón Guardar.

   

5. Inicie la plantilla.

   Inicie un trabajo desde la página de resumen de plantilla haciendo clic en el botón Iniciar.

   

   Si se realiza correctamente, el trabajo se inicia y muestra la salida de la plantilla. La salida estándar muestra el cuaderno de estrategias en ejecución y muestra los resultados del cuaderno de estrategias.

   

Verificar creación de máquina virtual

1. Abra un terminal y conéctese mediante ssh al nodo kvm-server.

   ssh oracle@<ip_address_of_instance>
   

2. Obtenga una lista de las máquinas virtuales en ejecución.

   sudo virsh list
   

   Salida de ejemplo:

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

3. Obtenga la dirección IP de la VM ol9-dev.

   sudo virsh net-dhcp-leases default
   

   Salida de ejemplo:

   [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. Conexión a la máquina virtual.

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

   -q elimina la cabecera de la salida de los comandos virsh. awk extrae la cuarta columna del comando virsh domifaddr y substr() extrae los últimos tres caracteres.

5. Desconéctese de la VM.

   exit
   

(Opcional) Crear otra máquina virtual

El manual permite la creación de otra máquina virtual cambiando la variable vm_name.

1. Cambie a la ventana del explorador que contiene Oracle Linux Automation Manager WebUI y conéctese si es necesario.

2. Haga clic en Templates (Plantillas) en el menú de navegación.

3. Haga clic en el icono Editar Plantilla de Mi Plantilla.

   

4. Agregue la variable vm_name con un valor de ol9-new a la sección Variables.

   

5. Desplácese hacia abajo y haga clic en el botón Guardar.

6. Inicie la plantilla.

7. Repita los pasos de verificación de la máquina virtual y conéctese a la máquina virtual recién creada.

Pasos Siguientes

La salida correcta del trabajo de Oracle Linux Automation Manager y la capacidad de utilizar SSH en la máquina virtual confirman que todo funciona. Experimente aún más con la recopilación community.libvirt y cree máquinas virtuales en Oracle Linux KVM para ampliar su infraestructura. A continuación, intente aprovisionar esas máquinas virtuales con manuales adicionales. Consulte nuestra formación adicional en Oracle Linux Training Station.

Enlaces relacionados

• Documentación de Oracle Linux Automation Manager
• Guía de instalación de Oracle Linux Automation Manager
• Formación sobre Oracle Linux Automation Manager
• Creación de máquinas virtuales con KVM en Oracle Linux
• Oracle Linux Training Station

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de formación gratuita en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en un explorador de Oracle Learning.

Para obtener documentación sobre el producto, visite Oracle Help Center.

---

Título e Información de Copyright

Manage KVM Virtual Machines using Oracle Linux Automation Manager

G32913-01

Copyright ©2023, Oracle and/or its affiliates.