Parametrización de compilaciones y uso de scripts

Introducción

En los pipelines de CI/CD modernos, la flexibilidad y la automatización son fundamentales. Codificar valores directamente en los trabajos de compilación los hace rígidos 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 que respondan de forma condicional al éxito o fallo de la misma. 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 ingresar la URL manualmente. No se requiere inicio de sesión.

Crear y parametrizar un proyecto Freestyle

En este paso, creará un nuevo proyecto Freestyle de Jenkins y le añadirá parámetros. Los parámetros hacen que sus trabajos sean interactivos, permitiéndole proporcionar información cada vez que se activa una compilación.

Primero, creemos el trabajo.

1. Abra el navegador Firefox desde la interfaz del escritorio. El navegador se abrirá automáticamente en http://localhost:8080, por lo que no necesita ingresar la URL manualmente. No se requiere inicio de sesión.
2. En el panel de control de Jenkins, haga clic en New Item (Nuevo elemento) en el menú de la izquierda.
3. Ingrese parameterized-script-job como nombre del elemento.
4. Seleccione Freestyle project y haga clic en OK.

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

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

   

2. Haga clic en el menú desplegable Add Parameter (Añadir parámetro) y seleccione String Parameter (Parámetro de cadena).

   • Name: GREETING_NAME
   • Default Value: World
   • Description: Enter a name to be greeted.

3. Haga clic nuevamente en el menú desplegable Add Parameter y seleccione Choice Parameter (Parámetro de elección).

   • Name: ENVIRONMENT

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

     DEV
     STAGING
     PROD
     

   • Description: Select the deployment environment.

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

Finalmente, desplácese hasta la parte inferior y haga clic en Save (Guardar). Será redirigido a la página principal del trabajo, donde ahora verá una opción Build with Parameters (Compilar con parámetros) en lugar de "Build Now".

Añadir un paso de compilación de script de shell

En este paso, añadirá un script de shell al proceso de compilación de su trabajo. Esta es una forma común de realizar tareas como compilar código, ejecutar pruebas o desplegar aplicaciones.

1. Navegue al panel de control de parameterized-script-job en Jenkins.
2. Haga clic en Configure (Configurar) en el menú de la izquierda.
3. Desplácese hacia abajo hasta la sección Build Steps (Pasos de compilación).
4. Haga clic en el menú desplegable Add build step (Añadir paso de compilación) y seleccione Execute shell (Ejecutar shell).
5. En el área de texto Command (Comando), ingrese el siguiente script. Este script creará una estructura de directorios del proyecto dentro del espacio de trabajo 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. Haga clic en Save para aplicar los cambios.

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

1. En la página del trabajo, haga clic en Build with Parameters.
2. Deje los valores de los parámetros predeterminados y haga clic en el botón Build.
3. Aparecerá una nueva compilación en el Build History (Historial de compilaciones) a la izquierda. Haga clic en el número de compilación (por ejemplo, #1).
4. Haga clic en Console Output (Salida de consola) para ver los registros.

Debería ver la salida de su script de shell, incluyendo el listado de archivos.

Started by user unknown or anonymous
Running as SYSTEM
Building in workspace /var/jenkins_home/workspace/parameterized-script-job
[parameterized-script-job] $ /bin/sh -xe /tmp/jenkins....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 ... .
drwxr-xr-x 3 jenkins jenkins 4096 ... ..
-rw-r--r-- 1 jenkins jenkins   12 ... version.txt
+ echo --- Build Step Finished ---
--- Build Step Finished ---
Finished: SUCCESS

Pasar parámetros al script de shell

En este paso, aprenderá a utilizar los parámetros que definió en el Paso 1 dentro de su script de shell. Jenkins expone los parámetros de compilación como variables de entorno, a las que puede acceder en su script utilizando la sintaxis $VARIABLE_NAME.

1. Regrese a la página Configure de su parameterized-script-job.
2. Desplácese hacia abajo hasta la sección Build Steps y busque el cuadro de comando Execute shell.
3. Reemplace 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 ---"

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

4. Haga clic en Save.

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

1. Haga clic en Build with Parameters.
2. Cambie GREETING_NAME a LabEx.
3. Seleccione STAGING en el menú desplegable ENVIRONMENT.
4. Haga clic en Build.
5. Verifique la Console Output de la nueva compilación.

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

--- 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 condiciones de shell

En este paso, simulará un fallo de compilación directamente en el script de shell. Esta es una forma fiable de hacer que un trabajo Freestyle se detenga cuando se viola una regla de despliegue.

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 lo siguiente:

echo "Deploying to the $ENVIRONMENT environment."

if [ "$ENVIRONMENT" = "PROD" ]; then
  echo "Error: Production deployment is not allowed!"
  echo "Failure handled by shell condition."
  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 1. En los scripts de shell, cualquier código de salida distinto de cero indica un fallo a Jenkins.

3. 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 ENVIRONMENT y haga clic en Build.
3. La compilación fallará, lo que se indicará con un icono rojo en el Build History.
4. Verifique la Console Output. Verá el mensaje de error de su script y el estado final de la compilación de Jenkins.

Deploying to the PROD environment.
+ [ PROD = PROD ]
+ echo Error: Production deployment is not allowed!
Error: Production deployment is not allowed!
+ echo Failure handled by shell condition.
Failure handled by shell condition.
+ exit 1
Build step 'Execute shell' marked build as failure
Finished: FAILURE

Si vuelve a ejecutar la compilación con DEV o STAGING, tendrá éxito porque no se activa la condición de fallo.

Resumen

¡Felicidades! Ha creado con éxito un trabajo de Jenkins flexible y robusto.

En este laboratorio, ha aprendido a:

• Crear un trabajo de Jenkins parametrizado utilizando parámetros de cadena (String) y de elección (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 sus scripts.
• Implementar lógica condicional en un script para controlar el resultado de la compilación.
• Utilizar condiciones de shell y códigos de salida para controlar si una compilación tiene éxito o falla.

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