Note:

Ejecución de tareas de Oracle Linux con Oracle Linux Automation Engine

Introducción

Oracle Linux Automation Engine permite a los administradores automatizar la configuración inicial de Oracle Linux y ejecutar otros trabajos administrativos mediante una herramienta de gestión de configuración de infraestructura como código (IaC) a través de una serie de manuales y tareas.

Objetivos

En este tutorial, aprenderá a:

Requisitos

Despliegue de Oracle Linux Automation Engine

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: "ol-control-node"
    type: "control"
  2:
    instance_name: "ol-host"
    type: "remote"
olam_type: olae
EOF

  6. Cree un archivo de inventario.

    cat << EOF | tee hosts > /dev/null
localhost ansible_connection=local ansible_connection=local ansible_python_interpreter=/usr/bin/python3.6
EOF

  7. Despliegue el entorno de prácticas.

    ansible-playbook create_instance.yml -i hosts -e "@instances.yml"

    El entorno de prácticas gratuitas necesita la variable adicional ansible_python_interpreter para localhost porque instala el paquete RPM para el SDK para Python de Oracle Cloud Infrastructure. La ubicación para instalar este paquete se encuentra en los módulos de Python por defecto del sistema según la versión de Oracle Linux. El uso de una variable de inventario evita que las reproducciones se ejecuten en hosts que no sean localeshost.

    La unidad de despliegue por defecto utiliza la CPU de AMD. Puede cambiar la unidad de las instancias transfiriendo una nueva definición de variable de unidad en la línea de comandos.

    Por ejemplo: -e instance_shape="VM.Standard3.Flex"

    Del mismo modo, la versión por defecto de la imagen de Oracle Linux utiliza la variable os_version definida en el archivo `default_vars.yml. Puede modificar este valor transfiriendo la versión principal de Oracle Linux en la línea de comandos.

    Por ejemplo: -e os_version="9"

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

Escribir el manual de configuración inicial

Muchos cuadernos de estrategias aprovechan variables y archivos de variables que contienen pares clave-valor, lo que permite que las tareas reales del cuaderno de estrategias sean dinámicas mientras el código permanece estático. Un cuaderno de estrategias incluye variables que pasan a formar parte de las jugadas durante el tiempo de ejecución, donde el cuaderno de estrategias utiliza sus valores al ejecutar tareas.

Oracle Linux Automation Engine permite definir estas variables en varias ubicaciones, cada una con un orden de prioridad específico. Las variables de nivel de cuaderno de estrategias se definen en el cuaderno de estrategias mediante la directiva vars o vars_files. La directiva vars especifica las variables como parte de la reproducción, mientras que la directiva vars_files incluye un archivo externo que contiene las variables. Los desarrolladores pueden crear estas variables de forma dinámica o estática a partir de otra reproducción, como haremos en este ejemplo, que define la configuración del sistema antes de ejecutar el manual.

  1. Abra un nuevo terminal y conéctese al sistema ol-control-node mediante SSH.

    ssh oracle@<ip_address_of_instance>

  2. Verifique que el comando de Oracle Linux Automation Engine esté disponible.

    ansible --version

  3. Cree un directorio de proyecto de trabajo.

    mkdir -p ~/ol-playbook

  4. Cree un directorio de variables y un archivo para el proyecto.

    mkdir ~/ol-playbook/vars

    touch ~/ol-playbook/vars/defaults.yml

  5. Agregue las variables y los valores al archivo.

       
cat << EOF | tee ~/ol-playbook/vars/defaults.yml > /dev/null
---
username: oracle
user_default_password: oracle
ssh_key_file: id_rsa
ssh_private_key_file: "{{ lookup('file', lookup('env','HOME') + '/.ssh/' + ssh_key_file + '.pub') }}"
additional_packages: ['git']
EOF

    Esta información explica cada variable y cómo la utilizaremos:

    • username: nombre del usuario sudo creado al ejecutar el cuaderno de estrategias. Para este ejemplo, el nombre del usuario será oracle.
    • user_default_password: contraseña por defecto para el usuario oracle cuando se crea. La contraseña es necesaria al ejecutar los comandos sudo.
    • ssh_key_file: define el nombre del par de claves SSH del usuario.
    • ssh_private_key_file: copia la clave pública SSH del usuario en el archivo authorized_key del usuario remoto en la ruta especificada. El ejemplo utiliza el plugin lookup para buscar la clave pública id_rsa.pub en el directorio $HOME/.ssh/ de los usuarios locales.
    • additional_packages: agregue el nombre de los paquetes adicionales que desea instalar en formato de matriz. Cada paquete de la matriz debe estar entre comillas simples y separado por una coma. Si instala un módulo de appstream como container-tools, la matriz tendría el aspecto ['git',' @container-tools:ol8'].

  6. Cree el archivo del libro de estrategias.

       
cat << EOF | tee ~/ol-playbook/setup.yml > /dev/null
---
- hosts: all
  become: yes
  vars_files:
    - vars/defaults.yml

  tasks:

  - name: Generate new ssh keypair
    community.crypto.openssh_keypair:
      path: "~/.ssh/{{ ssh_key_file }}"
      size: 2048
      comment: olam ssh keypair
    become: true
    become_user: "{{ username }}"
    delegate_to: localhost

  - name: Add a user account with access to sudo
    ansible.builtin.user:
      name: "{{ username }}"
      password: "{{ user_default_password | password_hash('sha512') }}"
      comment: Default Oracle user
      groups: wheel
      append: yes
      update_password: on_create

  - name: Set the authorized key for the user using a local public key file
    ansible.posix.authorized_key:
      user: "{{ username }}"
      state: present
      key: "{{ ssh_private_key_file }}"

  - name: install additional packages
    ansible.builtin.dnf:
      name: "{{ additional_packages }}"
      state: latest
EOF

    Las tareas específicas de un manual y los nombres de los módulos tienen como objetivo hacer que el manual se autodocumente. Estos elementos indican dónde y quién ejecuta las obras:

    • hosts: all: esta línea especifica qué hosts del inventario ejecutarán las tareas.
    • become: yes: indica a las tareas de esta sección que se ejecuten con el privilegio sudo por defecto.
    • vars_files" Esta directiva carga el archivo de variables que contiene la configuración del manual de este tutorial.

Instalar las recopilaciones necesarias

El paquete ansible-core contiene un juego mínimo de módulos para gestionar hosts, organizados en la recopilación ansible.builtin. Una recopilación es un método para distribuir cuadernos de estrategias, roles, módulos o plugins que realizan una tarea dirigida. ansible-core requiere la descarga e instalación de los módulos o recopilaciones necesarios fuera de los elementos incorporados.

Como el manual anterior utiliza la colección ansible.posix, necesitamos instalar esta colección y otras. La forma más sencilla de hacerlo es creando un archivo de requisitos que contenga todas las dependencias.

  1. Cree un archivo de requisitos.

    cat << 'EOF' | tee ~/ol-playbook/requirements.yml > /dev/null
---
collections:
  - name: ansible.posix
  - name: community.crypto
EOF

  2. Instale la recopilación.

    ansible-galaxy collection install -r ~/ol-playbook/requirements.yml

    La salida muestra el proceso de recuperar el archivo de almacenamiento comprimido del sitio Galaxy y, a continuación, instalarlo en el directorio raíz en .ansible/collections.

    Nota: Si la salida muestra ERROR: Ansible requires the locale encoding to be UTF-8; Detected None., indica un valor de configuración regional incorrecto para ansible. Corrija el problema definiendo estas dos variables de entorno:

    export LC_ALL="en_US.UTF-8"
export LC_CTYPE="en_US.UTF-8"

Ejecutar el manual

Antes de ejecutar el cuaderno de estrategias, debemos crear un archivo de inventario para este proyecto que apunte a la instancia remota de Oracle Linux que tenemos previsto gestionar.

  1. Asigne la dirección IP del ol-host a una variable para nuestro sistema remoto.

    Esta variable facilita la creación de scripts en el archivo de inventario.

    export REMOTE=<ip_address_of_instance>

  2. Cree un nuevo archivo de inventario en el directorio del proyecto.

    cat << EOF | tee ~/ol-playbook/inventory > /dev/null
[production]
ol-host ansible_host=$REMOTE
EOF

  3. Cambie al directorio de trabajo del proyecto.

    cd ~/ol-playbook

  4. Pruebe la conexión con el comando ad hoc ping.

    ansible ol-host -i ~/ol-playbook/inventory -m ping -u opc
    • -u: transfiere el nombre de usuario para la conexión ssh. En el entorno de prácticas gratuitas, utilizamos el usuario opc, el usuario por defecto proporcionado en las instancias de Oracle Linux en Oracle Cloud Infrastructure (OCI). Apruebe la huella de clave de ECDSA escribiendo yes en el indicador para continuar.

    El comando se ejecuta correctamente con resultados similares a los mostrados.

    Ejemplo de salida:

    ol-host | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python"
    },
    "changed": false,
    "ping": "pong"
}

  5. Ejecute el manual.

    ansible-playbook -i inventory setup.yml -u opc

    El comando debe ejecutarse correctamente y mostrar el resultado changed de cada reproducción.

Conectar al Host Remoto

Si el manual se ejecuta correctamente, podemos conectar al sistema remoto con el usuario, como se define en la variable username.

  1. Conéctese al sistema ol-host mediante SSH.

    ssh oracle@$REMOTE

    Si ha cambiado el valor de la variable ssh_key_file, tendría que transferir la opción `-i' a ssh, apuntando al archivo de clave privada del par especificado.

    Por ejemplo:

    ssh -i ~/.ssh/<local_ssh_private_key> <username>@<ip_address_of_host>

  2. Verifique la instalación de los paquetes solicitados.

    Después de iniciar sesión, puede verificar que el cuaderno de estrategias haya instalado el paquete git.

    git --version

  3. Desconéctese del host remoto.

    exit

Adición de un repositorio

Oracle Linux ofrece una plataforma segura, escalable y fiable para desplegar sus aplicaciones esenciales. La adición de un repositorio adicional se utiliza para instalar un nuevo producto de Oracle o una aplicación de terceros. Oracle Linux proporciona paquetes adicionales que gestionan el aprovisionamiento de estos repositorios adicionales.

El servidor YUM de Oracle Linux proporciona detalles sobre los numerosos repositorios que ofrece Oracle.

  1. Agregue estas tareas adicionales al archivo de cuaderno de estrategias existente.

    cat << EOF | tee -a setup.yml > /dev/null
  - name: Add the EPEL repository
    ansible.builtin.dnf:
      name: oracle-epel-release-el8
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '8'

  - name: Add the EPEL repository
    ansible.builtin.dnf:
      name: oracle-epel-release-el9
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '9'

  - name: Install the htop utility package
    ansible.builtin.dnf:
      name: htop
      enablerepo: ol8_developer_EPEL
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '8'

  - name: Install the htop utility package
    ansible.builtin.dnf:
      name: htop
      enablerepo: ol9_developer_EPEL
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '9'
EOF

    Este manual agrega varias tareas dentro de la reproducción definida. El primer juego agrega el repositorio EPEL a los repositorios de software existentes en la instancia de Oracle Linux. Mientras tanto, el segundo conjunto de reproducciones instala el paquete htop en la misma instancia de host de destino.

    Parámetros que vale la pena destacar:

    • state: present: garantiza que el paquete al que se hace referencia ya está en el sistema o se instala mediante dnf.
    • enablerepo: activa el repositorio específico (si está desactivado) solo durante la duración de la tarea actual.

  2. Vuelva a ejecutar el manual para realizar las tareas adicionales.

    ansible-playbook -i inventory setup.yml -u opc

    El manual termina correctamente y muestra algunas advertencias durante la ejecución. Puede ignorar estas advertencias por ahora, ya que no afectan al manual de estrategias actual. El manual informa las tareas que se completaron correctamente con un estado ok o changed. El estado changed indica que el manual modificó el host agregando el paquete htop o actualizando la caché dnf al solicitar la última versión de un paquete en lugar de simplemente comprobar si está presente. Un ok indica la finalización de la tarea y no requiere ninguna acción.

  3. Verifique la instalación del repositorio y el paquete.

    ssh oracle@$REMOTE which htop

  4. Ejecute el comando htop.

    ssh oracle@$REMOTE -t htop

    La opción -t del comando SSH fuerza una asignación TTY, ya que htop requiere un shell interactivo.

  5. Salga del programa htop escribiendo q.

Agregar, actualizar y suprimir archivos y directorios

  1. Cree un directorio y un archivo agregando lo siguiente al archivo de libro de estrategias existente.

       
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Create an example directory (if it does not already exist)
    ansible.builtin.file:
      path: "/home/{{ username }}/example"
      state: directory
      mode: '0755'
    become_user: "{{ username }}"

  - name: Create an empty file
    ansible.builtin.file:
      path: "/home/{{ username }}/example/test.txt"
      state: touch
      # mode: u=rw,g=r,o=r
    become_user: "{{ username }}"
EOF

    Este manual agrega dos tareas dentro del juego definido. El primero crea un nuevo directorio denominado example en el directorio principal del usuario remoto y el segundo crea un archivo vacío denominado test.txt en el directorio example recién creado.

    Parámetros adicionales que vale la pena destacar:

    • state:: el módulo ansible.builtin.file admite los siguientes parámetros: absent, directory, file, hard, link y touch. Estas tareas utilizan el directorio, que crea la ruta del directorio si aún no está presente, y el touch, que crea un archivo vacío si aún no está presente.
    • mode: define los permisos del sistema de archivos para el objeto creado. Al utilizar la línea de comandos, puede utilizar los modos octal 0644 o simbólico u=rw,g=r,o=r. El modo predeterminado del sistema se aplica si omite el parámetro mode:.
    • become_user: "": utiliza la funcionalidad de escalada de privilegios de Oracle Linux Automation Engine para ejecutar una tarea. En tutoriales anteriores, hemos introducido la funcionalidad de escalada de privilegios become: para ejecutar una tarea como usuario root. En este ejemplo, se muestra cómo utilizar una funcionalidad similar para ejecutar una tarea como otro usuario. Definimos el usuario como la variable "", que predefinimos como el usuario oracle en el archivo vars/defaults.yml. Por lo tanto, esta tarea se ejecuta como el usuario oracle y hereda los valores predeterminados de ese usuario.

  2. Ejecute el cuaderno de estrategias para realizar las tareas adicionales.

    ansible-playbook -i inventory setup.yml -u opc

  3. Confirme que el nuevo directorio y archivo existen en el host remoto.

    ssh oracle@$REMOTE ls -al example

    La salida confirma la creación de un nuevo directorio y el archivo vacío. Tenga en cuenta que el archivo test.txt tiene cero bytes y que el usuario oracle lo posee.

  4. Agregar varios archivos.

    Durante la configuración del sistema, puede que necesite crear varios archivos dentro de un directorio. En lugar de utilizar tareas individuales, puede crear varios archivos en un directorio como una única operación atómica.

       
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Add multiple files
    ansible.builtin.file:
      path: "/home/{{ username }}/example/{{ item }}"
      state: touch
    with_items:
    - file01.txt
    - file02.txt
    - file03.txt
    - file04.txt
    become_user: "{{ username }}"
EOF

    Esta tarea utiliza un bucle para crear varios archivos vacíos de una lista.

    • path:: define la ubicación en el sistema remoto para escribir los archivos. Oracle Linux Automation Engine sustituye la variable `` por cada item del parámetro with_items durante el tiempo de ejecución.
    • with_items:: este parámetro indica la lista de items para realizar un bucle durante la ejecución de esta tarea. Si bien en este ejemplo solo se utilizan cuatro nombres de archivo, puede crear la lista el tiempo que sea necesario.

  5. Ejecute el cuaderno de estrategias para realizar las tareas adicionales.

    ansible-playbook -i inventory setup.yml -u opc

  6. Confirme que el nuevo directorio y archivo existen en el host remoto.

    ssh oracle@$REMOTE ls -al example

    La salida muestra el archivo test.txt original y los nuevos.

  7. Agregue una sola línea de contenido a un archivo.

       
cat << 'EOF' | tee -a setup.yml > /dev/null     

  - name: Insert some text into the test.txt file
    ansible.builtin.lineinfile:
      path: "/home/{{ username }}/example/test.txt"
      line: This is a test
      create: True
      owner: "{{ username }}"
      group: "{{ username }}"
      mode: '0644'

  - name: Add an extra line after the line just inserted
    ansible.builtin.lineinfile:
      path: "/home/{{ username }}/example/test.txt"
      regexp: '^a test'
      insertafter: 'This is a test'
      line: This is an additional test.
      create: True
      owner: "{{ username }}"
      group: "{{ username }}"
      mode: '0644'

  - name: Get the contents of the test.txt file
    ansible.builtin.command: cat ~/example/test.txt
    register: command_output
    become_user: "{{ username }}"

  - name: Print the results of the cat command
    ansible.builtin.debug:
      msg: "{{ command_output }}"

  - name: Print only the lines added to the text file
    ansible.builtin.debug:
      msg: "{{ command_output.stdout_lines }}"
EOF

    • Las dos primeras tareas utilizan ansible.builtin.lineinfile para agregar y actualizar líneas únicas en el archivo.

    • Las tareas restantes muestran un método para confirmar los cambios. En primer lugar, el manual utiliza ansible.builtin.command para mostrar el contenido del archivo actualizado en stdout y guardarlo en la memoria en una variable register. A continuación, utiliza el módulo ansible.builtin.debug para imprimir ese contenido en la pantalla como parte de la salida del cuaderno de estrategias. La segunda tarea de depuración muestra un método para limitar la salida a una parte específica de la salida de JSON de la tarea anterior.

  8. Ejecute el cuaderno de estrategias para realizar las tareas adicionales.

    ansible-playbook -i inventory setup.yml -u opc

    La última tarea del manual imprime el contenido del archivo mediante el módulo debug.

  9. Agregue varias líneas de contenido a un archivo.

       
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Add two lines into test.txt
    ansible.builtin.blockinfile:
      path: "/home/{{ username }}/example/test.txt"
      insertafter: 'This is some updated text that was added later.'
      block: |
        "Welcome to {{ ansible_hostname }}"
        "Last updated on {{ ansible_date_time.iso8601 }}"

  - name: Create a new file and insert content into it
    ansible.builtin.copy:
      content: |
        === The text below was added by Oracle Linux Automation Engine ==========

        Hello from the ansible.builtin.copy module.
        This task is an example of inserting multiple lines into a text file.
        You can insert more lines if you want.

        === The text above was added by Oracle Linux Automation Engine ===========
      dest: "/home/{{ username }}/example/testing.txt"
      mode: '0644'
    become_user: "{{ username }}"
EOF

  10. Ejecute el cuaderno de estrategias para realizar las tareas adicionales.

    ansible-playbook -i inventory setup.yml -u opc

  11. Confirme que hay dos líneas nuevas en el archivo.

    ssh oracle@$REMOTE cat example/test.txt

    La salida muestra el contenido agregado e interpreta los valores variables de la tarea en función de la recopilación automática de hechos realizada por el cuaderno de estrategias en el host remoto durante el tiempo de ejecución.

  12. Confirmar la creación del nuevo archivo y la adición de nuestro contenido.

    ssh oracle@$REMOTE cat example/testing.txt

  13. Suprimir archivos y directorios.

    Además de crear archivos y directorios y agregar texto, Oracle Linux Automation Engine también puede suprimir estos elementos. Vamos a eliminar el directorio y todos los archivos que este manual crea, dejando el sistema en el mismo estado que cuando comenzamos. En primer lugar, estas tareas utilizan el parámetro state: establecido en absent para eliminar la lista de archivos y, luego, el directorio. La segunda tarea gestiona la eliminación de los archivos y el directorio en un solo paso. Sin embargo, incluimos la primera tarea para una demostración adicional de las funciones de Oracle Linux Automation Engine.

        
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Delete multiple files
    ansible.builtin.file:
      path: '{{ item }}'
      state: absent
    with_items:
      - "/home/{{ username }}/example/test.txt"
      - "/home/{{ username }}/example/file01.txt"
      - "/home/{{ username }}/example/file02.txt"
      - "/home/{{ username }}/example/file03.txt"
      - "/home/{{ username }}/example/file04.txt"
      - "/home/{{ username }}/example/testing.txt"

  - name: Recursively remove directory
    ansible.builtin.file:
      path: "/home/{{ username }}/example"
      state: absent
EOF

    Es posible suprimir de forma recursiva un directorio y cualquier contenido mediante la segunda tarea que se muestra. La primera tarea, eliminar archivos individualmente, está disponible si solo desea eliminar archivos específicos. Si desea suprimir archivos, archivos y directorios, la segunda tarea es más eficaz.

  14. Ejecute el cuaderno de estrategias para realizar las tareas adicionales.

    ansible-playbook -i inventory setup.yml -u opc

  15. Compruebe que se haya eliminado el directorio especificado.

    ssh oracle@$REMOTE ls

    La falta de salida confirma que el directorio especificado y los archivos creados durante este tutorial ya no están presentes.

Pasos Siguientes

Felicidades por llegar tan lejos. En este tutorial se presentaron varias formas en que Oracle Linux Automation Engine permite la automatización de tareas rutinarias en Oracle Linux, incluida la instalación de paquetes, la creación, la actualización y la supresión de archivos y directorios, así como la adición de cuentas de usuario a Oracle Linux. También demostramos cómo utilizar el módulo ansible.builtin.debug de Oracle Linux Automation Engine para mostrar información al terminal mientras se ejecutaba un Playbook. Con estas habilidades, tienes una ventaja inicial para aventurarte y escribir tus libros de estrategias.

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.