Crear y ejecutar una Pipeline básica en Jenkins

Introducción

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

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

Crear un nuevo proyecto de tipo Pipeline en la interfaz web de Jenkins.
Escribir un Jenkinsfile básico utilizando la sintaxis declarativa.
Configurar un proyecto para utilizar un Jenkinsfile desde un repositorio Git local.
Ejecutar una pipeline e inspeccionar su salida.
Organizar una 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. Comencemos.

Crear un proyecto de Pipeline en Jenkins

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

Abre el navegador Firefox desde la interfaz de escritorio. El navegador se abrirá automáticamente en http://localhost:8080, por lo que no necesitas ingresar la URL manualmente. No se requiere inicio de sesión.
En el panel de control de Jenkins, haz clic en New Item (Nuevo elemento) en el menú de la izquierda.
En el campo Enter an item name (Ingresar un nombre de elemento), escribe my-first-pipeline.
Selecciona Pipeline en la lista de tipos de proyecto.
Haz clic en el botón OK en la parte inferior de la página.

Crear proyecto de Pipeline

Serás redirigido a la página de configuración del proyecto. Por ahora, deja la configuración tal como está. Desplázate hasta el final y haz clic en Save (Guardar).

Ahora has creado un proyecto de Pipeline vacío. En el siguiente paso, crearás un Jenkinsfile y configurarás este proyecto para utilizarlo.

Configurar SCM para utilizar un repositorio Git local

Ahora configurarás tu proyecto de Jenkins para obtener su definición de pipeline desde un repositorio Git local alojado dentro del contenedor de Jenkins. Esto mantiene el laboratorio independiente de la disponibilidad de la red externa, mientras sigues utilizando el flujo de trabajo real de Pipeline script from SCM.

El repositorio de demostración se encuentra en: git://localhost/pipeline-demo.git

Examinemos el Jenkinsfile que Jenkins cargará desde este repositorio:

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 de Declarative Pipeline incluye múltiples etapas y demuestra conceptos clave:

pipeline { ... }: El bloque principal que define toda la pipeline.
agent any: Indica a Jenkins que ejecute esta pipeline en cualquier agente disponible.
environment { ... }: Define variables de entorno que pueden utilizarse en toda la pipeline.
stages { ... }: Un contenedor para todas las etapas de la 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 registro de compilación (build log).
sh '...': Un paso que ejecuta comandos de shell.

Ahora, configura tu proyecto de Jenkins para utilizar este repositorio:

Regresa a la interfaz de Jenkins en tu navegador y navega a la página del proyecto my-first-pipeline.
Haz clic en Configure en el menú de la izquierda.
Desplázate hacia abajo hasta la sección Pipeline.
Cambia el menú desplegable Definition de "Pipeline script" a Pipeline script from SCM.
En el menú desplegable SCM que aparece, selecciona Git.
En el campo Repository URL, ingresa: git://localhost/pipeline-demo.git
En el campo Script Path, ingresa: Jenkinsfile
Haz clic en Save.

Configuración de SCM para Pipeline

Tu proyecto ahora está configurado para ejecutar la pipeline definida en el repositorio Git local.

Ejecutar la Pipeline y verificar la salida

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

En la página del proyecto my-first-pipeline, haz clic en Build Now en el menú de la izquierda.
Se programará una nueva compilación que aparecerá en el panel Build History (Historial de compilaciones) a la izquierda. Debajo del historial, la Stage View (Vista de etapas) mostrará la etapa "Build" ejecutándose y luego volviéndose verde al finalizar.
Para ver la salida detallada, haz clic en el número de compilación (por ejemplo, #1) en el historial.
En la página de resumen de la compilación, haz clic en Console Output (Salida de consola) en el menú de la izquierda.
Revisa el registro. Encontrarás los mensajes de los pasos de tu pipeline, confirmando que 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 primera pipeline y verificado su salida. Observa cómo la pipeline ejecutó automáticamente las tres etapas (Build, Test, Deploy) definidas en el Jenkinsfile del repositorio.

Comprender las múltiples etapas en la Pipeline

Las pipelines del mundo real se componen de múltiples etapas, como compilar, probar y desplegar una aplicación. El Jenkinsfile del repositorio local ya incluye estas etapas diferenciadas, demostrando este concepto importante.

Examinemos cómo está estructurada la 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!"'
        }
    }
}

Regresa a la interfaz de Jenkins para el proyecto my-first-pipeline y haz clic en Build Now para ejecutar la pipeline nuevamente si aún no lo has hecho.
Observa la Stage View en el panel de control 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.
Haz clic en cualquier etapa en la Stage View para ver los registros detallados de esa etapa específica.
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 identificar dónde ocurren los problemas y visualizar el progreso de tus compilaciones.

Comprender las variables de entorno en una Pipeline

En este paso final, aprenderás sobre las variables de entorno. La directiva environment te permite definir variables que pueden utilizarse en toda tu pipeline, lo cual es ideal para gestionar configuraciones sin tener que escribirlas directamente en tus pasos (hard-coding).

El Jenkinsfile del repositorio local 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 {
        // ... otras etapas ...
        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 toda la pipeline.
Las variables se acceden utilizando la sintaxis ${env.VARIABLE_NAME}.
Es crucial utilizar comillas dobles (") para cadenas con interpolación de variables, ya que la interpolación de variables de Groovy solo funciona dentro de cadenas entrecomilladas dobles.
Las variables de entorno hacen que tus pipelines sean más flexibles y fáciles de mantener.

Si aún no lo has hecho, activa una nueva compilación en Jenkins haciendo clic en Build Now.
Después de que la compilación se complete, verifica la Console Output de la compilación. En el registro de la etapa "Deploy", verás que la variable se sustituyó correctamente:

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

Observa cómo el valor staging de la variable de entorno DEPLOY_TARGET se sustituyó automáticamente en la instrucción echo.

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

Resumen

¡Felicidades! Has completado con éxito esta introducción a Jenkins Pipelines. Has aprendido los conceptos fundamentales 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 Jenkins.
Configurar un proyecto para utilizar un Jenkinsfile desde un repositorio Git local servido a Jenkins.
Comprender la estructura de una Declarative Pipeline con múltiples etapas.
Ejecutar una pipeline e inspeccionar su salida de consola.
Observar cómo las 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 que las pipelines sean más dinámicas.

Estas habilidades fundamentales son esenciales para construir pipelines de automatización sofisticadas. 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.

Introducción a Jenkins Pipelines