Parametrizar Compilaciones y Usar Scripts

Introducción

En los pipelines (tuberías) modernos de CI/CD, la flexibilidad y la automatización son clave. Codificar valores de forma rígida (hardcoding) en los trabajos de compilación (build jobs) los hace inflexibles y difíciles de gestionar. Jenkins le permite superar esto parametrizando sus compilaciones y ejecutando scripts como parte del proceso de compilación.

En este laboratorio, aprenderá a crear un trabajo de Jenkins flexible. Comenzará añadiendo parámetros para permitir la entrada del usuario en el momento de la compilación. Luego, aprenderá a ejecutar scripts de shell como un paso de compilación, pasar los parámetros a esos scripts y configurar acciones posteriores a la compilación (post-build actions) que respondan condicionalmente al éxito o fracaso de la compilación. Estas son habilidades fundamentales para crear flujos de trabajo de automatización robustos y dinámicos en Jenkins.

Ya hay una instancia de Jenkins ejecutándose en su entorno. Puede acceder a la interfaz web de Jenkins abriendo el navegador Firefox en el escritorio. El navegador se abrirá automáticamente en http://localhost:8080, por lo que no necesita introducir la URL manualmente. No se requiere inicio de sesión (login).

Crear y Parametrizar un Proyecto Freestyle

En este paso, crearás un nuevo proyecto Freestyle de Jenkins y le añadirás parámetros. Los parámetros hacen que tus trabajos sean interactivos, permitiéndote proporcionar entradas cada vez que se desencadena una compilación (build).

Primero, creemos el trabajo.

1. Abre el navegador Firefox desde la interfaz de escritorio. El navegador se abrirá automáticamente en http://localhost:8080, por lo que no necesitas introducir la URL manualmente. No se requiere iniciar sesión.
2. En el panel de control (dashboard) de Jenkins, haz clic en New Item (Nuevo Elemento) en el menú de la izquierda.
3. Introduce parameterized-script-job como nombre del elemento.
4. Selecciona Freestyle project y haz clic en OK.

Serás dirigido a la página de configuración del trabajo. Ahora, añadamos parámetros.

1. En la sección General, marca la casilla This project is parameterized (Este proyecto está parametrizado).

   

2. Haz clic en el menú desplegable Add Parameter (Añadir Parámetro) y selecciona String Parameter.

   • Name (Nombre): GREETING_NAME
   • Default Value (Valor Predeterminado): World
   • Description (Descripción): Enter a name to be greeted.

3. Haz clic de nuevo en el menú desplegable Add Parameter y selecciona Choice Parameter.

   • Name (Nombre): ENVIRONMENT

   • Choices (Opciones): (Introduce cada opción en una nueva línea)

     DEV
     STAGING
     PROD

   • Description (Descripción): Select the deployment environment.

Estos parámetros estarán disponibles para su uso en los pasos de compilación posteriores.

Finalmente, desplázate hasta el final y haz clic en Save (Guardar). Serás redirigido a la página principal del trabajo, donde ahora verás una opción Build with Parameters (Compilar con Parámetros) en lugar de "Build Now" (Compilar Ahora).

Añadir un Paso de Compilación con Script de Shell

En este paso, añadirás un script de shell al proceso de construcción (build) de tu trabajo (job). Esta es una forma común de realizar tareas como compilar código, ejecutar pruebas o desplegar aplicaciones.

1. Navega al panel de control (dashboard) de parameterized-script-job en Jenkins.
2. Haz clic en Configure (Configurar) en el menú de la izquierda.
3. Desplázate hacia abajo hasta la sección Build Steps (Pasos de Construcción).
4. Haz clic en el menú desplegable Add build step (Añadir paso de construcción) y selecciona Execute shell (Ejecutar shell).
5. En el área de texto Command (Comando), introduce el siguiente script. Este script creará una estructura de directorio del proyecto dentro del espacio de trabajo (workspace) de Jenkins y listará su contenido.

echo "--- Starting Build Step ---"
echo "Current directory:"
pwd
echo "Creating project directory structure:"
mkdir -p my-app
echo "Version 1.0" > my-app/version.txt
echo "Listing files in the project directory:"
ls -la my-app
echo "--- Build Step Finished ---"

6. Haz clic en Save (Guardar) para aplicar los cambios.

Ahora, ejecutemos el trabajo para ver el script en acción.

1. En la página del trabajo, haz clic en Build with Parameters (Construir con Parámetros).
2. Deja los valores de parámetro predeterminados y haz clic en el botón Build (Construir).
3. Aparecerá una nueva construcción en el Build History (Historial de Construcción) a la izquierda. Haz clic en el número de la construcción (ej. #1).
4. Haz clic en Console Output (Salida de Consola) para ver los registros (logs).

Deberías ver la salida de tu script de shell, incluyendo la lista de archivos.

Started by user admin
Running as SYSTEM
Building in workspace /var/jenkins_home/workspace/parameterized-script-job
[parameterized-script-job] $ /bin/sh -xe /tmp/jenkins15539247300321029374.sh
+ echo --- Starting Build Step ---
--- Starting Build Step ---
+ echo Current directory:
Current directory:
+ pwd
/var/jenkins_home/workspace/parameterized-script-job
+ echo Creating project directory structure:
Creating project directory structure:
+ mkdir -p my-app
+ echo Version 1.0
+ echo Listing files in the project directory:
Listing files in the project directory:
+ ls -la my-app
total 12
drwxr-xr-x 2 jenkins jenkins 4096 Aug 22 01:56 .
drwxr-xr-x 3 jenkins jenkins 4096 Aug 22 01:56 ..
-rw-r--r-- 1 jenkins jenkins   12 Aug 22 01:56 version.txt
+ echo --- Build Step Finished ---
--- Build Step Finished ---
Finished: SUCCESS

Pasar Parámetros al Script de Shell

En este paso, aprenderás a utilizar los parámetros que definiste en el Paso 1 dentro de tu script de shell. Jenkins expone los parámetros de compilación como variables de entorno, a las cuales puedes acceder en tu script utilizando la sintaxis $NOMBRE_DE_VARIABLE.

1. Vuelve a la página Configure (Configurar) de tu parameterized-script-job.
2. Desplázate hacia abajo hasta la sección Build Steps (Pasos de Compilación) y busca el cuadro de comando Execute shell (Ejecutar shell).
3. Reemplaza el script existente con el siguiente:

echo "--- Starting Parameterized Build Step ---"
echo "Hello, $GREETING_NAME!"
echo "Deploying to the $ENVIRONMENT environment."

## Create project structure if not exists and read the version from the file
mkdir -p my-app
echo "Version 1.0" > my-app/version.txt
APP_VERSION=$(cat my-app/version.txt)
echo "Application version is: $APP_VERSION"
echo "--- Parameterized Build Step Finished ---"

Observa cómo $GREETING_NAME y $ENVIRONMENT se utilizan directamente en los comandos echo. Cuando el trabajo se ejecute, Jenkins los sustituirá por los valores seleccionados por el usuario.

4. Haz clic en Save (Guardar).

Ahora, ejecutemos la compilación con parámetros personalizados.

1. Haz clic en Build with Parameters (Compilar con Parámetros).
2. Cambia GREETING_NAME a LabEx.
3. Selecciona STAGING en el desplegable ENVIRONMENT.
4. Haz clic en Build (Compilar).
5. Revisa la Console Output (Salida de Consola) de la nueva compilación.

La salida debería reflejar ahora los valores personalizados que proporcionaste.

--- Starting Parameterized Build Step ---
+ echo Hello, LabEx!
Hello, LabEx!
+ echo Deploying to the STAGING environment.
Deploying to the STAGING environment.
+ mkdir -p my-app
+ echo Version 1.0
+ cat my-app/version.txt
+ APP_VERSION=Version 1.0
+ echo Application version is: Version 1.0
Application version is: Version 1.0
+ echo --- Parameterized Build Step Finished ---
--- Parameterized Build Step Finished ---

Gestionar Fallos de Compilación con Pasos Condicionales

En este paso, simularemos un fallo de construcción y utilizaremos una Acción Post-construcción (Post-build Action) para ejecutar un script de limpieza o notificación solo cuando la construcción falle. Esto es crucial para crear pipelines resilientes.

Instalar el Plugin Post-build Task

Antes de poder usar la acción de tarea post-construcción (Post-build task action), necesitamos instalar el plugin requerido.

1. En Jenkins, haga clic en el icono de engranaje en la esquina superior derecha para acceder al panel de administración de Jenkins, luego haga clic en Plugins.
2. Haga clic en la pestaña Available plugins.
3. Haga clic en Check now para actualizar la lista de plugins.
4. En el cuadro de búsqueda, busque Post build task.
5. Marque la casilla junto al plugin y haga clic en Install without restart.
6. Espere a que la instalación se complete.

Modificar el Script para Simular un Fallo

Ahora, modifiquemos el script para que falle bajo una condición específica.

1. Vaya a la página Configure de su parameterized-script-job.
2. En el cuadro de comando Execute shell, reemplace el script con el siguiente:

echo "Deploying to the $ENVIRONMENT environment."

if [ "$ENVIRONMENT" = "PROD" ]; then
  echo "Error: Production deployment is not allowed!"
  exit 1
fi

echo "Deployment to $ENVIRONMENT was successful."

Este script comprueba el parámetro ENVIRONMENT. Si se establece en PROD, imprime un error y sale con un código de estado de 1. En el scripting de shell, cualquier código de salida distinto de cero indica un fallo.

Ahora, agreguemos una acción post-construcción que se active ante un fallo.

Añadir Acción Post-construcción

1. Desplácese hacia abajo hasta la sección Post-build Actions.
2. Haga clic en Add post-build action y seleccione Post-build task.
3. En el campo Log text, ingrese Error:. Esto le indica al plugin que busque este texto específico en el log de construcción.
4. En el campo Script, ingrese el siguiente comando:

echo "FAILURE DETECTED! Sending notification..."

5. Haga clic en Save.

Probar la Condición de Fallo

Ahora, probemos la condición de fallo.

1. Haga clic en Build with Parameters.
2. Seleccione PROD para el ENVIRONMENT y haga clic en Build.
3. La construcción fallará, lo cual se indicará con un icono rojo en el Historial de Construcciones (Build History).
4. Revise la Console Output. Verá el mensaje de error de su script principal y el mensaje de su tarea post-construcción.

Deploying to the PROD environment.
+ [ PROD = PROD ]
+ echo Error: Production deployment is not allowed!
Error: Production deployment is not allowed!
+ exit 1
Build step 'Execute shell' marked build as failure
Performing Post build task...
Match found for :Error: : True
Logical operation result is TRUE
Running script  : echo "FAILURE DETECTED! Sending notification..."
[parameterized-script-job] $ /bin/sh -xe /tmp/jenkins14011006354379294736.sh
+ echo FAILURE DETECTED! Sending notification...
FAILURE DETECTED! Sending notification...
POST BUILD TASK : SUCCESS
END OF POST BUILD TASK : 0
Finished: FAILURE

Si ejecuta la construcción nuevamente con DEV o STAGING, tendrá éxito y la tarea post-construcción no se ejecutará.

Resumen

¡Felicitaciones! Has creado con éxito un trabajo de Jenkins flexible y robusto.

En este laboratorio, has aprendido a:

• Crear un trabajo de Jenkins parametrizado utilizando parámetros de String y Choice.
• Ejecutar scripts de shell como parte de un proceso de compilación.
• Acceder y utilizar parámetros de compilación como variables de entorno dentro de tus scripts.
• Implementar lógica condicional en un script para controlar el resultado de la compilación.
• Configurar acciones post-compilación que se activan según el contenido del registro de compilación, lo que te permite manejar fallos de compilación de manera elegante.

Estas habilidades son esenciales para construir pipelines de CI/CD sofisticados que puedan adaptarse a diferentes entradas y manejar errores de manera inteligente. Ahora puedes aplicar estos conceptos para automatizar tus propios flujos de trabajo de desarrollo y despliegue.