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"
use_olae_only: true
EOF

  6. Despliegue el entorno de prácticas.

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

    El entorno de prácticas gratuito necesita la variable adicional local_python_interpreter, que define ansible_python_interpreter para las reproducciones que se ejecutan en localhost. Esta variable es necesaria porque el entorno instala el paquete de RPM para el SDK para Python de Oracle Cloud Infrastructure, ubicado 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. En esta etapa del manual, la instalación de Oracle Linux está completa 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 y cualquier otra información de despliegue necesaria durante la ejecución del laboratorio.

Escribir el manual de configuración inicial

Muchos cuadernos de estrategias aprovechan variables y archivos 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 manual incluye las variables durante el tiempo de ejecución, donde sus valores se convierten en parte de las jugadas al ejecutar tareas.

Oracle Linux Automation Engine permite definir estas variables en varias ubicaciones, cada una con un orden de prioridad. 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 jugada, 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 mediante SSH al sistema ol-control-node.

    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 denominado 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 las incorporaciones.

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 directorio de proyecto de archivo de inventario.

    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 se debe ejecutar correctamente, mostrando 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 mediante SSH al sistema ol-host.

    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 proporciona una plataforma segura, ampliable y fiable donde puede desplegar las 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 de los muchos repositorios diferentes que proporciona 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: 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'
EOF

    Este manual agrega dos tareas dentro del juego definido. La primera agrega el repositorio de EPEL a los repositorios de software existentes en la instancia de Oracle Linux. Mientras tanto, la segunda reproducción 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 con éxito, mostrando algunas advertencias que podemos ignorar. El manual informa las tareas completadas correctamente con el 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 solo 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 directory, que crea la ruta de directorio si aún no está presente, y 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, presentamos la funcionalidad de escalada de privilegios become: para ejecutar una tarea como 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 usuario oracle en el archivo vars/defaults.yml. Por lo tanto, esta tarea se ejecuta como 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 de un sistema, es posible que necesite crear varios archivos dentro de un directorio. En lugar de utilizar tareas individuales, puede crear varios archivos en un directorio como una 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 en la que se realizará un bucle durante la ejecución de esta tarea. Si bien este ejemplo solo utiliza cuatro nombres de archivo, puede hacer la lista el tiempo que necesite.

  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 some updated text that was added later.
      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 manual. La segunda tarea de depuración muestra una forma de limitar la salida a solo una parte concreta 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. Confirme la creación del nuevo archivo y la adición del 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 y dejar el sistema en el mismo estado que cuando empezamos. Estas tareas utilizan primero el parámetro state: establecido en absent para eliminar la lista de archivos y, a continuación, el directorio. La segunda tarea maneja la eliminación de los archivos en un solo paso junto con el directorio. Sin embargo, incluimos la primera tarea para obtener 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 recursivamente un directorio y cualquier contenido mediante la segunda tarea mostrada. La primera tarea, eliminar los archivos individualmente, está presente en caso de que solo desee eliminar archivos. Si desea suprimir archivos y 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 el directorio especificado y los archivos creados durante este tutorial han desaparecido.

Pasos Siguientes

Felicitaciones por llegar tan lejos. En este tutorial se presentaron varias formas en que Oracle Linux Automation Engine hace posible la realización de tareas rutinarias en Oracle Linux mediante la automatización, como la instalación de paquetes, la creación, la actualización y la supresión de archivos y directorios, y la adición de cuentas de usuario a Oracle Linux. También mostramos cómo utilizar el módulo ansible.builtin.debug de Oracle Linux Automation Engine para devolver información al terminal mientras se ejecuta un manual. Con estas habilidades, tienes una ventaja para aventurarte hacia adelante y escribir tus propios manuales.

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.