Cómo crear pipelines de CI/CD con Jenkins en Tech260

Aprender a crear pipelines de CI/CD con Jenkins en Tech260 te permitirá automatizar todo el proceso de integración y despliegue de tus aplicaciones, eliminando tareas manuales y reduciendo errores. En esta guía, configurarás desde cero un pipeline declarativo con etapas de build, test y deploy, integrando tu repositorio de GitHub mediante webhooks para que cada push dispare automáticamente la ejecución. También resolverás problemas comunes como fallos de conexión, permisos y timeouts, y entenderás cuándo conviene usar sintaxis declarativa frente a la scripted. Todo el tutorial está pensado para completarse en unos 45 minutos, asumiendo que ya tienes Jenkins instalado y acceso a Tech260, junto con conocimientos básicos de Git y Groovy. (ver también: Cómo instalar y configurar un VPN en tu router)

Acceso a la instancia de Jenkins en Tech260 y credenciales de administrador

Para comenzar, lo primero es acceder a tu instancia de Jenkins. Sigue estos pasos:

1. Obtén la URL de tu instancia: En el panel de Tech260, busca la IP pública o el nombre de dominio asignado a tu servidor Jenkins. Normalmente aparece como http://[IP]:8080.
2. Conéctate por primera vez: Abre esa URL en tu navegador. Verás una pantalla solicitando la contraseña inicial de administrador.
3. Recupera la contraseña: Accede por SSH a tu servidor Tech260 y ejecuta: sudo cat /var/lib/jenkins/secrets/initialAdminPassword. Copia el código que aparece.
4. Ingresa la contraseña: Pégala en el campo de Jenkins y haz clic en "Continuar".
5. Configura el administrador: El asistente te guiará para instalar plugins sugeridos y crear tu primer usuario administrador. Usa un correo válido y una contraseña segura.

Riesgo: No compartas la contraseña inicial ni las credenciales de administrador. Si pierdes acceso, tendrás que reiniciar la configuración desde el archivo de contraseñas en el servidor.

Una vez configurado, ya tienes acceso completo. Recuerda que estas credenciales son la puerta de entrada a todo tu flujo.

Repositorio de código fuente conectado (GitHub, GitLab o Bitbucket)

El primer paso es conectar tu repositorio de código fuente. Jenkins necesita acceso directo a tu código para detectar cambios y ejecutar las tareas automáticas.

1. Genera un token de acceso personal en tu plataforma (GitHub, GitLab o Bitbucket). Ve a Configuración > Tokens y crea uno con permisos de repo y webhook.
2. En Jenkins, ve a Administrar Jenkins > Configurar sistema. Busca la sección «GitHub» o «GitLab» y agrega tu servidor. Pega el token que generaste y prueba la conexión.
3. Crea un nuevo trabajo (Pipeline) y en la sección «Pipeline» selecciona «Pipeline script from SCM». Elige Git como SCM y pega la URL de tu repositorio.
4. Configura las credenciales: selecciona el token que agregaste en el paso 2. Si usas Bitbucket, asegúrate de usar un usuario con acceso al repositorio.
5. Define la rama (por ejemplo, main o develop) y la ruta del archivo Jenkinsfile (normalmente en la raíz del proyecto).

Riesgo: Si el token expira o tiene permisos insuficientes, Jenkins no podrá clonar el repositorio ni recibir notificaciones de cambios. Siempre verifica que el token tenga alcance de webhook.

Herramientas instaladas: Docker, Node.js y Maven (según el proyecto)

Necesitas tener instaladas y configuradas las siguientes herramientas según los requerimientos de tu proyecto. Asegúrate de contar con estos elementos antes de comenzar:

• Docker: Versión 20.10 o superior. Necesario para contenerizar aplicaciones y ejecutar agentes de Jenkins de forma aislada.
• Node.js: Versión 18 LTS o 20 LTS. Indispensable si tu proyecto usa JavaScript, TypeScript o frameworks como React o Angular.
• Maven: Versión 3.9 o superior. Requerido para proyectos Java que compilan con este gestor de dependencias.
• Git: Versión 2.30 o superior. Para clonar repositorios y gestionar ramas dentro del pipeline.
• Jenkins: Versión 2.440 o superior, con los plugins de Pipeline, Git y Docker instalados.
• Java JDK: Versión 11 o 17. Necesario para ejecutar Jenkins y compilar proyectos Java con Maven.

Además, necesitas conocimientos básicos de administración de Jenkins, manejo de archivos Jenkinsfile y familiaridad con la terminal de tu sistema operativo. Si tu proyecto usa otras herramientas como Gradle o Python, ajusta los requisitos según corresponda. El flujo funciona mejor cuando validas las versiones antes de empezar.

Plugin de Jenkins para integración continua (Pipeline, Git y Docker)

Necesitas los plugins correctos para la integración continua con Git y Docker.

1. Instalar Pipeline Plugin: Ve a "Administrar Jenkins" > "Administrar Plugins". Busca e instala "Pipeline". Esto te permite definir tu flujo de trabajo como código en un Jenkinsfile.
2. Agregar Git Plugin: Instala "Git Plugin" para que Jenkins pueda clonar repositorios desde GitHub, GitLab o Bitbucket. Configura tus credenciales SSH o token en "Credenciales".
3. Configurar Docker Pipeline: Instala "Docker Pipeline Plugin". Esto te permite construir y ejecutar contenedores dentro de tu pipeline. Asegúrate de que el agente de Jenkins tenga Docker instalado.
4. Crear un Pipeline simple: En tu proyecto, selecciona "Pipeline" como tipo. En el Jenkinsfile, define etapas como checkout (Git), build (Docker) y test.

Riesgo: Si no configuras correctamente los permisos del agente para Docker, el pipeline fallará con errores de "permiso denegado". Asegúrate de que el usuario de Jenkins esté en el grupo docker.

Con estos plugins, el proceso se vuelve ágil y repetible. Recuerda versionar tu Jenkinsfile junto con el código para mantener la consistencia.

Paso 1: Configurar el proyecto y el agente de Jenkins en Tech260

El primer paso es preparar tu proyecto y el agente de ejecución. Sigue estos sub-pasos con cuidado:

1. Inicia sesión en Tech260 y dirígete al panel de control de Jenkins. Haz clic en "Nueva tarea" (New Item) en el menú lateral izquierdo.
2. Nombra tu proyecto (ej: "mi-pipeline-ci-cd") y selecciona la opción "Pipeline". Luego presiona "OK" para confirmar.
3. Configura el agente (nodo): En la sección "General", marca la casilla "Restringir dónde se puede ejecutar este proyecto". En el campo "Etiqueta de expresión", escribe tech260-agent (o el nombre del agente que hayas creado previamente en Tech260).
4. Define el repositorio: Baja a "Pipeline" y en "Definición" elige "Pipeline script desde SCM". Selecciona "Git" y pega la URL de tu repositorio (ej: https://github.com/tu-usuario/mi-app.git).
5. Especifica la rama: En "Branches to build", escribe */main.

Crear un nuevo trabajo (Job) tipo Pipeline desde el panel de Jenkins

El primer paso es configurar un trabajo desde el panel principal. Sigue estas instrucciones:

1. Accede al panel de Jenkins y haz clic en «Nuevo elemento» en el menú izquierdo.
2. Asigna un nombre a tu proyecto (por ejemplo, «mi-pipeline-tech260»).
3. Selecciona la opción «Pipeline» como tipo de proyecto y haz clic en «Aceptar».
4. En la sección «Pipeline», elige la definición «Pipeline script from SCM» si tu código está en un repositorio, o «Pipeline script» para escribir el script directamente.
5. Si usas SCM, selecciona Git, ingresa la URL del repositorio y especifica la rama (por ejemplo, main).
6. En «Script Path», asegúrate de que apunte a tu archivo Jenkinsfile (por defecto es Jenkinsfile).
7. Guarda el trabajo haciendo clic en «Guardar».

Riesgo: Si el repositorio es privado, asegúrate de configurar las credenciales en Jenkins antes de continuar. De lo contrario, el pipeline fallará al intentar clonar el código.

Vincular el repositorio de código fuente usando credenciales SSH o HTTPS

El primer paso es conectar tu repositorio de código fuente. Jenkins necesita acceso para clonar el código y ejecutar las etapas del pipeline. Puedes hacerlo mediante SSH o HTTPS, dependiendo de tu configuración.

1. Genera tus credenciales: Si usas SSH, genera un par de llaves (pública y privada) en tu máquina local. Para HTTPS, necesitarás un token de acceso personal desde tu proveedor de Git (GitHub, GitLab, etc.).
2. Agrega las credenciales en Jenkins: Ve a «Administrar Jenkins» > «Administrar Credenciales» > «Global» > «Agregar Credenciales». Selecciona «SSH Username with private key» o «Username with password» (para HTTPS con token). Pega la llave privada o el token.
3. Configura el repositorio en tu pipeline: En tu archivo Jenkinsfile o en la configuración del proyecto, usa la URL del repositorio (ej. git@github.com:usuario/repo.git para SSH o https://github.com/usuario/repo.git para HTTPS). Asigna el ID de la credencial que creaste.

Riesgo: Nunca incluyas contraseñas o tokens directamente en el código del pipeline. Siempre usa el sistema de credenciales de Jenkins para evitar exponer información sensible. Si compartes el repositorio, cualquiera podría acceder a tus claves.

Con esto, tu Jenkins podrá acceder al código sin problemas.

Definir el agente de ejecución (nodo Tech260 o contenedor Docker)

El primer paso es definir dónde se ejecutará tu pipeline. Tienes dos opciones principales: usar un nodo dedicado (como el propio servidor Tech260) o un contenedor Docker. Aquí te explicamos cómo configurarlo.

1. Accede a la configuración del pipeline: Desde el panel de Jenkins, abre tu pipeline y ve a la sección "Pipeline Syntax" o directamente al archivo Jenkinsfile.
2. Define el agente: En el bloque agent, especifica el nodo o contenedor. Por ejemplo:
   • Para usar el nodo Tech260: agent label 'tech260-node'. Asegúrate de que el nodo esté etiquetado correctamente en "Manage Jenkins" > "Manage Nodes".
   • Para usar Docker: agent { docker image 'node:18' }. Esto ejecutará el pipeline dentro de un contenedor con Node.js 18.
3. Verifica la conectividad: Si eliges Docker, Jenkins debe tener acceso al demonio de Docker. En Tech260, instala el plugin "Docker Pipeline" y configura la ruta del socket en "Manage Jenkins" > "Configure System".

Riesgo: Si usas Docker sin permisos adecuados, el pipeline fallará con errores de conexión al socket. Asegúrate de que el usuario de Jenkins tenga permisos en /var/run/docker.sock.

Paso 2: Escribir el archivo Jenkinsfile para el pipeline de CI/CD

1. Accede al repositorio de tu proyecto en Tech260 y crea un archivo llamado Jenkinsfile en la raíz. Este archivo define todo el flujo.
2. Define la estructura del pipeline usando la sintaxis declarativa. Escribe el bloque pipeline {} y dentro especifica el agente con agent any.
3. Agrega las etapas (stages) necesarias. Por ejemplo:
   • Checkout: usa checkout scm para clonar el código.
   • Build: ejecuta comandos como sh 'mvn clean compile' (si usas Maven) o sh 'npm install' (para Node.js).
   • Test: corre pruebas unitarias con sh 'mvn test'.
   • Deploy: despliega a un servidor o contenedor, por ejemplo sh 'docker push ...'.
4. Configura los post-build actions dentro de post {} para manejar resultados: success ..., failure ....
5. Guarda el archivo y haz commit al repositorio. Jenkins detectará automáticamente el Jenkinsfile al configurar el pipeline desde SCM.

Estructura básica del Jenkinsfile con etapas de Build, Test y Deploy

El primer paso es estructurar correctamente tu Jenkinsfile. Este archivo define todo el flujo de trabajo. Aquí tienes la base con las tres etapas esenciales: Build, Test y Deploy.

1. Definir el pipeline: Usa la directiva pipeline y especifica un agente, por ejemplo agent any.
2. Etapa de Build: Dentro de stages, agrega un bloque stage('Build'). Aquí compila tu código, por ejemplo con sh 'mvn clean compile'.
3. Etapa de Test: Crea stage('Test') y ejecuta pruebas unitarias, como sh 'mvn test'. Esto asegura que el código funcione antes de avanzar.
4. Etapa de Deploy: Finaliza con stage('Deploy'). Aquí despliegas el artefacto, por ejemplo copiándolo a un servidor o usando Docker.

Riesgo común: Si una etapa falla, el pipeline se detiene. Siempre agrega un bloque post para manejar errores, como enviar notificaciones o limpiar recursos temporales.

El flujo se vuelve más claro cuando pruebas este Jenkinsfile básico. Ajusta los comandos según tu stack.

Uso de Pipeline as Code: declarar etapas con sintaxis declarativa o scripted

La clave está en usar Pipeline as Code. Jenkins te permite definir todo el proceso de integración y despliegue directamente en un archivo Jenkinsfile. Esto asegura que la configuración esté versionada y sea reproducible. Te encontrarás con dos enfoques principales: la sintaxis declarativa y la scripted.

1. Elige la sintaxis declarativa (recomendada): Es más simple y estructurada. Define tu pipeline dentro de un bloque pipeline. Por ejemplo:

pipeline {
agent any stages { stage('Build') { steps { echo 'Compilando...' } } stage('Test') { steps { echo 'Ejecutando pruebas...' } } stage('Deploy') { steps { echo 'Desplegando...' } } } }

2. O usa la sintaxis scripted (más flexible): Ideal para pipelines complejos. Se basa en Groovy y usa bloques node. Aquí controlas el flujo con lógica condicional y bucles.

Riesgo: La sintaxis scripted puede volverse difícil de mantener si no se maneja con cuidado. Para la mayoría de los casos en Tech260, la declarativa es más segura y legible.

Al final, ambos métodos te permiten automatizar tareas.

Incorporar pasos de Docker para contenerizar la aplicación en Tech260

Para completar la integración de Docker en tu pipeline, sigue estos pasos clave.

1. Agregar la etapa de construcción de la imagen:
   1. En tu archivo Jenkinsfile, dentro del bloque stage('Build Docker Image'), agrega el paso sh 'docker build -t tu-app:latest .'.
   2. Verifica que el Dockerfile esté en la raíz del repositorio. Si no, ajusta la ruta en el comando.
2. Configurar el registro de imágenes:
   1. Antes del build, añade sh 'docker login -u $DOCKER_USER -p $DOCKER_PASS' usando credenciales de Jenkins (tipo "Username with password").
   2. Etiqueta la imagen: sh 'docker tag tu-app:latest tu-registro/tu-app:latest'.
3. Subir la imagen al registro:
   1. Agrega el paso sh 'docker push tu-registro/tu-app:latest'.
   2. Para versionado, usa sh 'docker push tu-registro/tu-app:$BUILD_NUMBER'.

Disparar la ejecución manual del pipeline y monitorear registros de salida

Una vez que hayas configurado tu pipeline, es momento de ejecutarlo manualmente y revisar los registros. Sigue estos pasos para asegurarte de que todo funcione correctamente.

1. Accede al pipeline: Desde el panel de Jenkins, busca el proyecto que creaste. Haz clic en su nombre.
2. Inicia la ejecución: En el menú lateral izquierdo, presiona el botón «Construir ahora». Esto disparará el pipeline de inmediato.
3. Monitorea el progreso: Verás un nuevo número de build en la sección «Historial de construcciones». Haz clic en el número para abrir la vista detallada.
4. Revisa los registros: Dentro del build, selecciona «Salida de la consola» en el menú izquierdo. Aquí verás cada paso del pipeline en tiempo real, incluyendo errores o confirmaciones de éxito.

Riesgo común: Si el pipeline falla, revisa los registros en busca de mensajes en rojo. Errores típicos incluyen credenciales mal configuradas o rutas de archivos incorrectas. Siempre verifica que el entorno de Tech260 esté activo antes de ejecutar.

Con estos pasos, dominarás la ejecución manual y el monitoreo. Practica con builds pequeños para identificar problemas.

Configurar disparadores automáticos (Webhook de repositorio o polling SCM)

Para automatizar tus builds al subir cambios al repositorio, configura disparadores automáticos en Jenkins. Esto evita ejecutar manualmente el pipeline cada vez. Sigue estos pasos:

1. Accede a la configuración del pipeline: Desde el panel de Jenkins, selecciona tu proyecto y haz clic en Configurar.
2. Habilita el disparador por webhook: En la sección Disparadores de construcción, marca la opción Disparar construcción remotamente. Copia el token de autenticación que se genera.
3. Configura el webhook en tu repositorio: Ve a la configuración de tu repositorio (GitHub, GitLab, etc.) y agrega un nuevo webhook. La URL debe ser: http://[TU-JENKINS-URL]/project/[NOMBRE-DEL-PROYECTO] y pega el token como secreto.
4. Alternativa: Polling SCM: Si no puedes usar webhooks, marca Poll SCM y define un cron, por ejemplo H/5 para revisar cambios cada 5 minutos.

Riesgo: Si usas polling SCM con intervalos muy cortos (menos de 1 minuto), puedes saturar el servidor. Prefiere siempre webhooks para una ejecución inmediata y eficiente.

Con estos pasos, tu pipeline se activará automáticamente.

Agregar notificaciones de estado (correo o Slack) al finalizar el pipeline

Una vez que hayas completado el proceso, el siguiente paso lógico es configurar notificaciones automáticas para mantener a tu equipo informado. Al finalizar el pipeline, Jenkins puede enviar alertas por correo electrónico o a un canal de Slack. Para configurarlo, ve a la sección de configuración del pipeline y agrega un paso de post-acción. En el bloque post, define condiciones como success, failure o unstable, y dentro de cada una, usa el plugin de Slack o el de Email Extension. Por ejemplo, para Slack, instala el plugin, genera un token en tu espacio de trabajo y agrega slackSend (channel: '#tu-canal', message: 'Pipeline completado: $currentBuild.result').

El resultado esperado es que, tras ejecutar el pipeline, recibas un mensaje directo en el canal de Slack o en tu bandeja de entrada con el estado final. Para verificarlo, corre el pipeline manualmente desde la interfaz de Jenkins y revisa el canal o tu correo. Si ves el mensaje con el resultado (éxito o fallo), la integración funciona. Recuerda que estos detalles de notificación son clave para la colaboración en equipo y la detección temprana de errores.

Aplicación compilada, probada y desplegada automáticamente en el entorno Tech260

Una vez que tu código está listo, el pipeline se encarga del resto. En esta fase, la aplicación se compila, se prueban sus componentes y se despliega automáticamente en el entorno Tech260. Sigue estos pasos para configurarlo:

1. Compilación automática: Jenkins clona el repositorio y ejecuta el comando de compilación (por ejemplo, mvn clean install o npm run build). Asegúrate de que el agente de Jenkins tenga las herramientas necesarias instaladas.
2. Ejecución de pruebas: El pipeline corre las pruebas unitarias y de integración. Si alguna falla, el proceso se detiene y recibirás una notificación.
3. Despliegue en Tech260: Si las pruebas pasan, Jenkins transfiere los artefactos al servidor Tech260 usando SSH o un plugin como Publish Over SSH. Luego, reinicia el servicio para aplicar los cambios.

Riesgo: Si el servidor Tech260 no tiene suficiente espacio en disco o las credenciales SSH son incorrectas, el despliegue fallará. Verifica estos puntos antes de ejecutar el pipeline.

Dominar este proceso te permite automatizar todo el ciclo, desde el commit hasta la puesta en producción. Recuerda monitorear los logs para detectar errores temprano.

Log de ejecución con etapas exitosas y tiempos de cada paso

Para verificar que tu pipeline funciona correctamente, revisa el log de ejecución con etapas exitosas y tiempos de cada paso. Sigue estos pasos:

1. Accede al panel de Jenkins en Tech260 y selecciona tu proyecto de pipeline.
2. Haz clic en el número de build (por ejemplo, "#1") en la columna "Última ejecución".
3. Revisa la vista "Stage View":
   1. En la parte superior, verás una tabla con las etapas (Checkout, Build, Test, Deploy).
   2. Observa los íconos verdes (éxito) o rojos (fallo) junto a cada etapa.
   3. Haz clic en "Log" de cada etapa para ver detalles de tiempo y comandos ejecutados.
4. Identifica los tiempos: En la misma tabla, cada etapa muestra su duración en segundos o minutos (ejemplo: "2s 300ms").
5. Verifica el log completo: Haz clic en "Console Output" en el menú izquierdo para ver el historial completo con marcas de tiempo.

⚠️ Advertencia: Si ves un ícono rojo en alguna etapa, revisa el log específico. Un error común es que el paso "Deploy" falle por credenciales incorrectas. Asegúrate de que las variables de entorno estén configuradas en Jenkins.

Este proceso es clave para dominar la herramienta.

Pipeline reutilizable para futuros commits sin intervención manual

Para que tu flujo de trabajo sea realmente eficiente, el objetivo es que el pipeline se ejecute solo con cada nuevo commit, sin que tengas que tocarlo. Aquí te explico cómo lograrlo en Tech

Fuentes y recursos de referencia

• creación de pipelines en Jenkins
• configurar un pipeline CI/CD

En Tech260 entendemos la importancia de automatizar tus despliegues, por eso te enseñamos cómo crear pipelines de CI/CD con Jenkins, paso a paso. Domina la integración y entrega continua para acelerar tus proyectos sin complicaciones.

Si quieres conocer otros artículos parecidos a Cómo crear pipelines de CI/CD con Jenkins en Tech260 puedes visitar la categoría Tutoriales.