Introducción a Jenkins Pipelines

Introducción

Bienvenido a este laboratorio sobre los fundamentos de Jenkins Pipelines. Jenkins Pipeline es una característica potente que te permite definir todo tu proceso de compilación, prueba y despliegue como código. Esta definición se almacena en un archivo de texto llamado Jenkinsfile, que normalmente se versiona junto con el código fuente de tu aplicación. Esta práctica se conoce como "Pipeline-as-Code".

En este laboratorio, te centrarás en la sintaxis Declarative Pipeline, que ofrece una forma estructurada y fácil de usar para crear pipelines. Al final de este laboratorio, serás capaz de:

• Crear un nuevo proyecto Pipeline en la interfaz web de Jenkins.
• Escribir un Jenkinsfile básico utilizando la sintaxis Declarative.
• Configurar un proyecto para usar un Jenkinsfile de un repositorio Git local.
• Ejecutar un pipeline e inspeccionar su salida.
• Organizar un pipeline en múltiples etapas (stages).
• Utilizar variables de entorno para gestionar la configuración.

Ya hay una instancia de Jenkins ejecutándose en un contenedor para ti. Empecemos.

Crear un Proyecto de Pipeline en Jenkins

Su primer paso es crear un nuevo proyecto de tipo Pipeline en Jenkins. Este tipo de proyecto está diseñado específicamente para ejecutar pipelines definidos en un Jenkinsfile.

1. Abra el navegador Firefox desde la interfaz de escritorio. El navegador se abrirá automáticamente en http://localhost:8080, por lo que no necesita introducir la URL manualmente. No se requiere iniciar sesión.
2. En el panel de control (dashboard) de Jenkins, haga clic en New Item (Nuevo Elemento) en el menú de la izquierda.
3. En el campo Enter an item name (Introducir un nombre de elemento), escriba my-first-pipeline.
4. Seleccione Pipeline de la lista de tipos de proyecto.
5. Haga clic en el botón OK en la parte inferior de la página.

8. Será dirigido a la página de configuración del proyecto. Por ahora, dejaremos la configuración tal cual. Desplácese hasta el final y haga clic en Save (Guardar).

Ahora ha creado un proyecto de Pipeline vacío. En el siguiente paso, creará un Jenkinsfile y configurará este proyecto para que lo utilice.

Configurar SCM para Usar Repositorio Remoto

Ahora configurarás tu proyecto Jenkins para obtener su definición de pipeline de un repositorio Git remoto. Usaremos un repositorio de demostración que contiene un Jenkinsfile preconfigurado y una aplicación de ejemplo.

El repositorio de demostración se encuentra en: https://github.com/labex-labs/jenkins-demo

Examinemos el Jenkinsfile que utilizaremos desde el repositorio remoto:

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                sh 'echo "Compiling source code..."'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing the application...'
                sh 'echo "Running unit tests..."'
            }
        }
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Este script Declarative Pipeline incluye múltiples etapas y demuestra conceptos clave:

• pipeline { ... }: El bloque principal que define todo el pipeline.
• agent any: Indica a Jenkins que ejecute este pipeline en cualquier agente disponible.
• environment { ... }: Define variables de entorno que se pueden usar en todo el pipeline.
• stages { ... }: Un contenedor para todas las etapas del pipeline.
• stage('...') { ... }: Define etapas específicas. Las etapas ayudan a visualizar el flujo de trabajo.
• steps { ... }: Contiene los comandos reales que se ejecutarán en una etapa.
• echo '...': Un paso que imprime un mensaje en el log de compilación.
• sh '...': Un paso que ejecuta comandos de shell.

Ahora, configura tu proyecto Jenkins para usar este repositorio remoto:

1. Regresa a la interfaz de usuario de Jenkins en tu navegador y navega a la página del proyecto my-first-pipeline.
2. Haz clic en Configure en el menú de la izquierda.
3. Desplázate hacia abajo hasta la sección Pipeline.
4. Cambia el menú desplegable Definition de "Pipeline script" a Pipeline script from SCM.
5. En el menú desplegable SCM que aparece, selecciona Git.
6. En el campo Repository URL, introduce: https://github.com/labex-labs/jenkins-demo
7. En el campo Script Path, introduce: introduction-to-pipelines/Jenkinsfile
8. Haz clic en Save.

Tu proyecto ahora está configurado para ejecutar el pipeline definido en el repositorio remoto de GitHub.

Ejecutar el Pipeline y Comprobar la Salida

Con tu proyecto configurado, es hora de ejecutar el pipeline y verlo en acción.

1. En la página del proyecto para my-first-pipeline, haz clic en Build Now en el menú de la izquierda.

2. Se programará una nueva compilación y aparecerá en el panel Build History a la izquierda. Debajo del historial, la Stage View mostrará la etapa "Build" ejecutándose y luego poniéndose verde al completarse.

   

3. Para ver la salida detallada, haz clic en el número de compilación (por ejemplo, #1) en el Build History.

4. En la página de resumen de la compilación, haz clic en Console Output en el menú de la izquierda.

   

5. Desplázate por el log. Encontrarás los mensajes de los pasos de tu pipeline, confirmando que tu pipeline se ejecutó correctamente.

...
[Pipeline] { (Build)
[Pipeline] echo
Building the application...
[Pipeline] sh
+ echo Compiling source code...
Compiling source code...
[Pipeline] } // stage
[Pipeline] { (Test)
[Pipeline] echo
Testing the application...
[Pipeline] sh
+ echo Running unit tests...
Running unit tests...
[Pipeline] } // stage
[Pipeline] { (Deploy)
[Pipeline] echo
Deploying the application to staging...
[Pipeline] sh
+ echo Application deployed successfully!
Application deployed successfully!
[Pipeline] } // stage
...
Finished: SUCCESS

Has ejecutado con éxito tu primer pipeline y verificado su salida. Observa cómo el pipeline ejecutó automáticamente las tres etapas (Build, Test, Deploy) que se definieron en el Jenkinsfile del repositorio remoto.

Comprender Múltiples Etapas en el Pipeline

Los pipelines del mundo real se componen de múltiples etapas, como la compilación, prueba y despliegue de una aplicación. El Jenkinsfile del repositorio remoto ya incluye estas etapas distintas, demostrando este importante concepto.

Examinemos cómo está estructurado el pipeline con múltiples etapas:

stages {
    stage('Build') {
        steps {
            echo 'Building the application...'
            sh 'echo "Compiling source code..."'
        }
    }
    stage('Test') {
        steps {
            echo 'Testing the application...'
            sh 'echo "Running unit tests..."'
        }
    }
    stage('Deploy') {
        steps {
            echo "Deploying the application to ${env.DEPLOY_TARGET}..."
            sh 'echo "Application deployed successfully!"'
        }
    }
}

1. Regresa a la interfaz de usuario de Jenkins para el proyecto my-first-pipeline y haz clic en Build Now para ejecutar el pipeline nuevamente si aún no lo has hecho.

2. Observa la Stage View en el panel del proyecto. Verás tres columnas que representan tus etapas "Build", "Test" y "Deploy". Jenkins visualiza el progreso a medida que la compilación avanza a través de cada una.

   

3. Haz clic en cualquier etapa en la Stage View para ver los logs detallados de esa etapa específica.

4. Observa cómo cada etapa se ejecuta secuencialmente: Jenkins espera a que una etapa se complete con éxito antes de pasar a la siguiente.

Al estructurar tu pipeline con etapas, creas un flujo de trabajo claro y mantenible que es fácil de monitorear. Cada etapa representa una fase lógica en tu proceso de CI/CD, lo que facilita la identificación de dónde ocurren los problemas y la visualización del progreso de tus compilaciones.

Comprender Variables de Entorno en un Pipeline

En este paso final, aprenderás sobre las variables de entorno. La directiva environment te permite definir variables que se pueden usar en todo tu pipeline, lo cual es ideal para gestionar configuraciones sin codificarlas directamente en tus pasos.

El Jenkinsfile del repositorio remoto ya demuestra este concepto con una variable de entorno que especifica un objetivo de despliegue.

Examinemos cómo se definen y utilizan las variables de entorno:

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        // ... other stages ...
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Puntos clave sobre las variables de entorno en Jenkins Pipelines:

• El bloque environment { ... } define variables que están disponibles en todo el pipeline.
• Las variables se acceden utilizando la sintaxis ${env.VARIABLE_NAME}.
• Es crucial usar comillas dobles (") para las cadenas con interpolación de variables, ya que la interpolación de variables de Groovy solo funciona dentro de cadenas entre comillas dobles.
• Las variables de entorno hacen que tus pipelines sean más flexibles y fáciles de mantener.

1. Si aún no lo has hecho, activa una nueva compilación en Jenkins haciendo clic en Build Now.

2. Después de que la compilación se complete, revisa la Console Output de la compilación. En el log de la etapa "Deploy", verás que la variable fue sustituida correctamente:

...
[Pipeline] { (Deploy)
[Pipeline] echo
Deploying the application to staging...
[Pipeline] sh
+ echo Application deployed successfully!
Application deployed successfully!
[Pipeline] } // stage
...
Finished: SUCCESS

3. Observa cómo el valor de la variable de entorno DEPLOY_TARGET, staging, fue sustituido automáticamente en la declaración echo.

Las variables de entorno son esenciales para crear pipelines flexibles que puedan configurarse fácilmente para diferentes entornos (desarrollo, staging, producción) sin modificar el código del pipeline en sí.

Resumen

¡Felicitaciones! Has completado con éxito esta introducción a Jenkins Pipelines. Has aprendido los conceptos centrales de definir un flujo de trabajo de CI/CD como código.

En este laboratorio, has practicado cómo:

• Crear un proyecto de Pipeline en la interfaz de usuario de Jenkins.
• Configurar un proyecto para usar un Jenkinsfile desde un repositorio Git remoto (SCM).
• Comprender la estructura de un Declarative Pipeline con múltiples etapas.
• Ejecutar un pipeline e inspeccionar su salida de consola.
• Observar cómo los pipelines se estructuran en etapas lógicas para mayor claridad y organización.
• Comprender cómo se definen y utilizan las variables de entorno para hacer los pipelines más dinámicos.

Estas habilidades fundamentales son esenciales para construir pipelines de automatización sofisticados. Ahora estás listo para explorar temas más avanzados, como el uso de parámetros, la gestión de credenciales y la integración con diversas herramientas de compilación y despliegue.