Ansible es una poderosa herramienta de automatización de TI que simplifica la gestión de la infraestructura. En este laboratorio práctico, aprenderá a usar Ansible para crear archivos con contenido específico en sistemas objetivo. Al final de este laboratorio, comprenderá los conceptos básicos de la gestión de archivos con Ansible y podrá implementar la creación automatizada de archivos en su propia infraestructura.
Antes de que podamos comenzar a usar Ansible para crear archivos, necesitamos instalarlo y configurarlo en nuestro sistema. Configuremos nuestro entorno:
Primero, actualizaremos las listas de paquetes e instalaremos Ansible en nuestro sistema Ubuntu 22.04:
sudo apt update
sudo apt install -y ansibleDespués de ejecutar estos comandos, debería ver una salida que indica que Ansible se ha instalado correctamente. Verifiquemos la instalación:
ansible --versionDebería ver una salida similar a esta:
ansible [core 2.12.0]
config file = /etc/ansible/ansible.cfg
configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
ansible python module location = /usr/lib/python3/dist-packages/ansible
ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
executable location = /usr/bin/ansible
python version = 3.10.x (default, ...) [GCC 11.2.0]
jinja version = 3.0.3
libyaml = TrueAnsible utiliza un archivo de inventario para definir los hosts que gestionará. Para este laboratorio, crearemos un inventario local que incluye nuestra propia máquina:
mkdir -p ~/project/ansible-files
cd ~/project/ansible-files~/project/ansible-filesinventory[local]
localhost ansible_connection=localEste archivo de inventario le dice a Ansible que ejecute comandos en la máquina local sin usar SSH.
ansible.cfg simple en el mismo directorio:
~/project/ansible-filesansible.cfg[defaults]
inventory = ./inventory
host_key_checking = Falsecd ~/project/ansible-files
ansible local -m pingDebería ver una salida similar a:
localhost | SUCCESS => {
"changed": false,
"ping": "pong"
}Esto confirma que Ansible está correctamente instalado y configurado para ejecutar comandos en su máquina local.
Ahora que tenemos Ansible configurado, aprendamos a crear archivos con contenido. Ansible proporciona varios módulos para la gestión de archivos, y nos centraremos en el módulo copy en este paso.
Los Playbooks de Ansible son archivos YAML que describen un conjunto de tareas a ejecutar en los hosts objetivo. Cada tarea utiliza un módulo específico de Ansible para realizar una acción.
Creemos nuestro primer playbook para crear un archivo con contenido:
~/project/ansible-files:
create_file.yml---
- name: Create a file with content
hosts: local
tasks:
- name: Create a simple text file
copy:
dest: "~/project/hello.txt"
content: |
Hello from Ansible!
This file was created using the Ansible copy module.
Current date: {{ ansible_date_time.date }}Entendamos qué hace este playbook:
hosts: local especifica que este playbook se ejecutará en los hosts del grupo local de nuestro inventario.tasks contiene una lista de tareas a ejecutar.copy se utiliza para crear un archivo con contenido.dest especifica la ruta de destino para el archivo.content contiene el contenido de texto que se escribirá en el archivo.{{ ansible_date_time.date }} es una variable que se reemplazará con la fecha actual cuando se ejecute el playbook.cd ~/project/ansible-files
ansible-playbook create_file.ymlDebería ver una salida similar a:
PLAY [Create a file with content] ***********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create a simple text file] ***********************************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0cat ~/project/hello.txtDebería ver una salida similar a:
Hello from Ansible!
This file was created using the Ansible copy module.
Current date: 2023-08-15La fecha reflejará la fecha actual cuando ejecute el playbook.
La idempotencia es una característica clave de Ansible: ejecutar el mismo playbook varias veces debería producir el mismo resultado. Ejecutemos el playbook nuevamente para ver la idempotencia en acción:
ansible-playbook create_file.ymlEsta vez, debería ver que el conteo de "changed" es 0:
PLAY [Create a file with content] ***********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create a simple text file] ***********************************************
ok: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=2 changed=0 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0Esto muestra que Ansible reconoce que el archivo ya existe con el contenido correcto, por lo que no lo modifica de nuevo.
En este paso, exploraremos cómo usar variables y plantillas para crear archivos más dinámicos con Ansible.
Las variables hacen que sus playbooks sean más flexibles y reutilizables. Creemos un playbook que use variables para crear un archivo de configuración:
~/project/ansible-files:
variables_demo.yml---
- name: Create files using variables
hosts: local
vars:
app_name: "MyApplication"
app_version: "1.0.0"
port_number: 8080
log_level: "INFO"
tasks:
- name: Create config file with variables
copy:
dest: "~/project/app_config.ini"
content: |
## Configuration for {{ app_name }}
## Generated by Ansible
[application]
name = {{ app_name }}
version = {{ app_version }}
[server]
port = {{ port_number }}
log_level = {{ log_level }}En este playbook:
vars define variables que se pueden usar en todo el playbook.{{ variable_name }}.copy se utiliza para crear un archivo con contenido que incluye estas variables.cd ~/project/ansible-files
ansible-playbook variables_demo.ymlDebería ver una salida similar a:
PLAY [Create files using variables] ********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create config file with variables] ***************************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0cat ~/project/app_config.iniDebería ver una salida similar a:
## Configuration for MyApplication
## Generated by Ansible
[application]
name = MyApplication
version = 1.0.0
[server]
port = 8080
log_level = INFOPara un contenido de archivo más complejo, Ansible admite plantillas Jinja2. Creemos un archivo de plantilla y lo usemos en un playbook:
mkdir -p ~/project/ansible-files/templates~/project/ansible-files/templatesweb_config.j2## Web Server Configuration
## Generated by Ansible on {{ ansible_date_time.date }}
server {
listen {{ web_port }};
server_name {{ server_name }};
location / {
root {{ doc_root }};
index index.html;
}
{% if enable_ssl %}
## SSL Configuration
ssl_certificate {{ ssl_cert }};
ssl_certificate_key {{ ssl_key }};
{% endif %}
}~/project/ansible-filestemplate_demo.yml---
- name: Create files using templates
hosts: local
vars:
web_port: 80
server_name: "example.com"
doc_root: "/var/www/html"
enable_ssl: true
ssl_cert: "/etc/ssl/certs/example.com.crt"
ssl_key: "/etc/ssl/private/example.com.key"
tasks:
- name: Create web server config from template
template:
src: templates/web_config.j2
dest: ~/project/web_server.confEn este playbook:
template se utiliza en lugar de copy.src apunta a nuestro archivo de plantilla.dest especifica dónde crear el archivo de salida.vars se usarán en la plantilla.cd ~/project/ansible-files
ansible-playbook template_demo.ymlDebería ver una salida similar a:
PLAY [Create files using templates] ********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create web server config from template] **********************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0cat ~/project/web_server.confDebería ver una salida similar a:
## Web Server Configuration
## Generated by Ansible on 2023-08-15
server {
listen 80;
server_name example.com;
location / {
root /var/www/html;
index index.html;
}
## SSL Configuration
ssl_certificate /etc/ssl/certs/example.com.crt;
ssl_certificate_key /etc/ssl/private/example.com.key;
}Observe cómo la plantilla Jinja2 se representó con nuestras variables, y la sección condicional para SSL se incluyó porque enable_ssl se configuró en true.
En este paso final, exploraremos algunas técnicas avanzadas de gestión de archivos con Ansible, incluyendo permisos de archivos, creación condicional de archivos y el uso de múltiples módulos relacionados con archivos.
Al crear archivos, a menudo necesita establecer permisos y propiedad específicos. Creemos un playbook que demuestre esto:
~/project/ansible-filesfile_permissions.yml---
- name: Manage file permissions and ownership
hosts: local
tasks:
- name: Create a script file with execute permissions
copy:
dest: ~/project/script.sh
content: |
#!/bin/bash
echo "This script was created by Ansible"
echo "Current user: $(whoami)"
echo "Current directory: $(pwd)"
mode: "0755"
- name: Create a read-only configuration file
copy:
dest: ~/project/readonly.conf
content: |
## This is a read-only configuration file
setting1 = value1
setting2 = value2
mode: "0444"En este playbook:
mode se utiliza para establecer los permisos del archivo.0755 significa lectura, escritura y ejecución para el propietario, y lectura y ejecución para el grupo y otros.0444 significa solo lectura para todos.cd ~/project/ansible-files
ansible-playbook file_permissions.ymlDebería ver una salida similar a:
PLAY [Manage file permissions and ownership] **********************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create a script file with execute permissions] **************************
changed: [localhost]
TASK [Create a read-only configuration file] **********************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=3 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0ls -l ~/project/script.sh ~/project/readonly.confDebería ver una salida similar a:
-rwxr-xr-x 1 labex labex 118 Aug 15 12:34 /home/labex/project/script.sh
-r--r--r-- 1 labex labex 73 Aug 15 12:34 /home/labex/project/readonly.conf~/project/script.shDebería ver una salida similar a:
This script was created by Ansible
Current user: labex
Current directory: /home/labex/project/ansible-filesA veces, necesita crear archivos solo cuando se cumplen ciertas condiciones. Creemos un playbook que demuestre la creación condicional de archivos:
~/project/ansible-filesconditional_file.yml---
- name: Conditional file creation
hosts: local
vars:
environment: "development"
create_debug_file: true
create_backup: false
tasks:
- name: Create environment-specific configuration
copy:
dest: "~/project/{{ environment }}_config.yml"
content: |
## Configuration for {{ environment }} environment
debug: {{ 'enabled' if environment == 'development' else 'disabled' }}
log_level: {{ 'DEBUG' if environment == 'development' else 'INFO' }}
- name: Create debug log file
copy:
dest: ~/project/debug.log
content: |
## Debug log file
## Created: {{ ansible_date_time.iso8601 }}
mode: "0644"
when: create_debug_file
- name: Create backup directory
file:
path: ~/project/backup
state: directory
mode: "0755"
when: create_backupEn este playbook:
when se utiliza para la ejecución condicional de tareas.file se utiliza para crear un directorio.cd ~/project/ansible-files
ansible-playbook conditional_file.ymlDebería ver una salida similar a:
PLAY [Conditional file creation] **********************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create environment-specific configuration] ******************************
changed: [localhost]
TASK [Create debug log file] **************************************************
changed: [localhost]
TASK [Create backup directory] ************************************************
skipped: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=3 changed=2 unreachable=0 failed=0 skipped=1 rescued=0 ignored=0Observe que la tarea "Create backup directory" se omitió porque create_backup se configuró en false.
cat ~/project/development_config.yml
cat ~/project/debug.log
ls -la ~/project/ | grep backupDebería ver el contenido de los dos archivos que se crearon y confirmar que no se creó ningún directorio de respaldo.
Ansible proporciona varios módulos para la gestión de archivos. Creemos un playbook que demuestre el uso de múltiples módulos relacionados con archivos:
~/project/ansible-filesfile_modules.yml---
- name: Demonstrate file-related modules
hosts: local
tasks:
- name: Create a directory
file:
path: ~/project/ansible_demo
state: directory
mode: "0755"
- name: Create a file using the copy module
copy:
dest: ~/project/ansible_demo/copied.txt
content: "This file was created using the copy module.\n"
- name: Create a symbolic link
file:
src: ~/project/ansible_demo/copied.txt
dest: ~/project/ansible_demo/link_to_copied.txt
state: link
- name: Create a file with blockinfile module
blockinfile:
path: ~/project/ansible_demo/block.txt
create: true
block: |
This is a block of text
that will be inserted
as a single unit.
marker: "## {mark} ANSIBLE MANAGED BLOCK"En este playbook:
file se utiliza con state: directory para crear un directorio.file se utiliza con state: link para crear un enlace simbólico.blockinfile se utiliza para crear un archivo con un bloque de texto rodeado de comentarios de marcador.cd ~/project/ansible-files
ansible-playbook file_modules.ymlDebería ver una salida similar a:
PLAY [Demonstrate file-related modules] ***************************************
TASK [Gathering Facts] *********************************************************
ok: [localhost]
TASK [Create a directory] *****************************************************
changed: [localhost]
TASK [Create a file using the copy module] ************************************
changed: [localhost]
TASK [Create a symbolic link] *************************************************
changed: [localhost]
TASK [Create a file with blockinfile module] **********************************
changed: [localhost]
PLAY RECAP *********************************************************************
localhost : ok=5 changed=4 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0ls -la ~/project/ansible_demo/
cat ~/project/ansible_demo/copied.txt
cat ~/project/ansible_demo/link_to_copied.txt
cat ~/project/ansible_demo/block.txtDebería ver:
ansible_democopied.txt con el contenido especificadolink_to_copied.txt que apunta a copied.txtblock.txt con un bloque de texto rodeado de comentarios de marcadorLa salida del último comando debería ser similar a:
## BEGIN ANSIBLE MANAGED BLOCK
This is a block of text
that will be inserted
as a single unit.
## END ANSIBLE MANAGED BLOCKEsto demuestra la versatilidad de las capacidades de gestión de archivos de Ansible.
Felicitaciones por completar este laboratorio de gestión de archivos de Ansible. Ha aprendido varios conceptos y técnicas importantes:
copyEstas habilidades forman una base sólida para automatizar las tareas de gestión de archivos en su infraestructura. Con Ansible, puede garantizar un contenido de archivo consistente en múltiples servidores, aplicar cambios de manera controlada y mantener un registro auditable de su configuración.
Para continuar su viaje de aprendizaje de Ansible, considere explorar temas más avanzados como roles, organización de playbooks e integración de Ansible con otras herramientas de DevOps.
