Recientemente he impartido un curso de Python para devops y para ello he creado una imagen docker en dockerhub https://hub.docker.com/r/fortinux/jenkins-ansible configurada con Jenkins https://www.jenkins.io/, Ansible https://www.ansible.com/, Docker https://www.docker.com, y Python https://www.python.org/.

Luego he creado un repositorio público en Github https://github.com/fortinux/ejemplo_ansible_jenkins con un ejemplo de integración de Ansible con Jenkins: El servidor Jenkins leerá una pipeline con dos stages que contienen comandos de Ansible y un playbook.

¿Que es Jenkins?

Jenkins es una herramienta de CI que ayuda a automatizar el proceso completo, disminuye el trabajo de un desarrollador y verifica el avance en cada progresión del desarrollo de software. Como servidor de automatización extensible, Jenkins se utiliza como servidor básico o se transforma en el centro de entrega continua para cualquier proyecto empresarial.
Fuente: Rizvi, Syeda & Mamatha, G.. (2021). Automated Continuous Integration (ACI) Scheme Based on Jenkins. 10.1007/978-981-15-9647-6_72.

Recursos:

Documentación de Jenkins: https://www.jenkins.io/doc/.
Videos: https://www.cloudbees.com/videos.
Stackoverflow https://stackoverflow.com/search?q=Jenkins.

Arquitectura de Jenkins

Jenkins se compone de una arquitectura distribuida (Distributed Builds Architecture) que integra mediante un controlador (controller) nodos (nodes), agentes (agents), y ejecutores (executors).
El controller es el servicio mismo de Jenkins.
Es el servidor web que decide cómo, cuando y donde ejecutar las tareas.
También gestiona las tareas de configuración, autorización y autenticación.
Los nodos son las "máquinas" donde se ejecutan los agentes.
Jenkins controla el espacio en disco libre, espacio temporal libre, memoria swap libre, la sincronización del reloj y el tiempo de respuesta.
Si algún nodo supera los parámetros establecidos en la configuración se deshabilita.
El controller mismo se ejecuta en un nodo especial.
Los agentes administran la ejecución de la tarea en nombre del controlador de Jenkins mediante el uso de ejecutores.
Un agente es un proceso de cliente Java con su propio PID (Identificador de proceso) que se conecta a un controlador Jenkins y se supone que no es confiable.
Utiliza cualquier sistema operativo compatible con Java y las herramientas necesarias para compilaciones y pruebas se instalan en el nodo donde se ejecuta el agente; aunque se pueden instalar directamente o dentro de un contenedor (Docker o utilizando Kubernetes).
En la práctica, los nodos y los agentes son esencialmente lo mismo, pero es bueno recordar que son conceptualmente distintos.
Un ejecutor es un espacio para la ejecución de tareas; es decir, es un hilo en el agente.
El número de ejecutores en un nodo define el número de tareas simultáneas que se pueden ejecutar en ese nodo a la vez.
Fuente: https://www.jenkins.io/doc/book/managing/nodes/.

Jenkins dashboard

Desde el panel de jenkins se pueden crear también tareas (jobs) con la opción New item.
Las opciones son: Freestyle project, Maven project, Pipeline, Multi-configuration project, Folder, Multibranch pipeline y Organization folder.
Se puede desde allí también hacer una copia de un proyecto existente con la opción Copy from.
Ejemplo: Crear un proyecto libre denominado Ejemplo shellscript donde se utilizara la sigiente configuración:
- Description: Ejecutar un comando shellscript.
- Build steps: Execute shell. El comando:

cat /etc/hostname; id; set

Al ejecutarlo, mostrará:
- El nombre de la máquina (hostname),
- los identificadores de los usuarios del sistema (uid), y
- las variables de ambiente.

Pipelines

Mediante una pipeline se pueden establecer los estadios o stages que realizará una tarea de Jenkins.
Cada estadio podrá tener uno o más pasos (steps).
La estructura de una tubería o pipeline básica es la siguiente:

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Construyendo ...'
            }
        }
        stage('Test') {
            steps {
                echo 'Testeando ...'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Desplegando ...'
            }
        }
    }
}

Una tubería se puede crear de las siguientes formas:
- Utilizando BlueOcean: Ayuda a crear el fichero Jenkinsfile y hacer el commit al cvs.
- Utilizando la interfaz de Jenkins.
- En SCM escribiendo un fichero Jenkinsfile manualmente.
Fuente: https://www.jenkins.io/doc/book/pipeline/getting-started/.

Jenkins con Ansible

Las instrucciones para seguir el tutorial son las siguientes:
El servidor Jenkins leerá el fichero Jenkinsfile del repositorio https://github.com/fortinux/ejemplo_ansible_jenkins para ejecutar la pipeline.
Si no tenéis un servidor Jenkins disponible podéis descargar la imagen de dockerhub ya configurada y lista para usar. Las instrucciones para descargarla y ejecutarla están en https://hub.docker.com/r/fortinux/jenkins-ansible.

Pasos del tutorial

En Jenkins se crea una nueva pipeline donde se selecciona Pipeline script from SCM, se agrega la dirección de este repositorio y se modifica a main la opción Branch specified.
Finalmente se ejecuta la tarea.

# Fichero Jenkinsfile
pipeline {
  agent any
  stages {
    stage('fetch') {
      steps {
        sh '''
          ansible --version
          ansible-playbook --version
        '''
      }
    }
    stage('install') {
      steps {
        ansiblePlaybook installation: 'ansible', inventory: 'hosts', playbook: 'playbook_instalar.yml'
      }
    }
  }
}

# Fichero hosts 
[local]
localhost

# Fichero playbook_instalar.yml
---

- hosts: all
  connection: local
  become: yes
  become_user: root
  tasks:
  - name: Install sysstat
    apt:
      name: sysstat
      state: latest
      update_cache: yes

Bibliografía del curso

Kim, G., Behr, K., & Spafford, G. (2014). The Phoenix project: A novel about IT, DevOps, and helping your business win. It Revolution Press.
Kim, G., Debois, P., Willis, J., & Humble, J. (2015). The DevOps handbook: How to create world-class speed, reliability, and security in technology organizations. It Revolution Press.
Marzal Varó, A., Gracia Luengo, I., García Sevilla, Pedro. Introducción a la programación con Python 3. (2014).
Recuperado de http://repositori.uji.es/xmlui/handle/10234/102653
Shaw, Z. A., Learn Python 3 the Hard Way. (2016).
Recuperado de https://learnpythonthehardway.org/
Van Rossum, G. and the Python development team. Documentación de Python en español. (2020).
Recuperado de https://python-docs-es.readthedocs.io/_/downloads/es/pdf/pdf/

Si buscas un formador para realizar este curso u otra actividad formativa (webinar, workshops, bootcamps, etc.) en tu organización, me puedes ubicar a través de la página de contacto. Muchas gracias.

Este blog no contiene publicidad. Si te ha gustado el artículo puedes ayudarme haciendo una donación con criptomonedas. Gracias!!!

Donar con criptomoneda

Imagen de portada: James Harrison on Unsplash

Jenkins con Ansible en Docker