Migration de Jenkins a GitLab CI: Guía paso a paso

Por qué Migrar de Jenkins a GitLab CI

Jenkins ha sido durante años el estándar de facto para CI/CD, pero GitLab CI ofrece ventajas significativas:

Ventajas de GitLab CI

1. Integración Nativa con Git

   • Un solo lugar para código, CI/CD y revisiones
   • Configuración como código (.gitlab-ci.yml)
   • Triggers automáticos sin configuración adicional

2. Simplicidad

   • No más plugins que mantener
   • Configuración declarativa
   • UI más moderna e intuitiva

3. Auto-scaling de Runners

   • Kubernetes native
   • Docker built-in
   • Cloud-ready desde el inicio

4. Costo

   • Tier gratuito generoso
   • Menos overhead de infraestructura
   • Runners compartidos disponibles

Planificación de la Migración

Fase 1: Inventario

Documenta todo lo que tienes en Jenkins:

• Número de jobs
• Plugins utilizados
• Integraciones externas
• Credenciales y secretos
• Artifacts y storage
• Notificaciones configuradas

Fase 2: Mapeo

Crea una tabla de equivalencias:

Fase 3: Priorización

Ordena tus pipelines por:

1. Complejidad: Empieza con los simples
2. Criticidad: Deja los críticos para cuando tengas experiencia
3. Frecuencia: Migra primero los más usados para ganar confianza

Migración Técnica

Ejemplo 1: Pipeline Simple

Jenkins (Jenkinsfile):

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'npm install'
                sh 'npm run build'
            }
        }
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }
    }
}

GitLab CI (.gitlab-ci.yml):

stages:
  - build
  - test

build:
  stage: build
  script:
    - npm install
    - npm run build
  artifacts:
    paths:
      - dist/

test:
  stage: test
  script:
    - npm test

Ejemplo 2: Pipeline con Docker

Jenkins:

pipeline {
    agent {
        docker {
            image 'node:16'
        }
    }
    stages {
        stage('Build') {
            steps {
                sh 'npm install'
            }
        }
    }
}

GitLab CI:

build:
  image: node:16
  script:
    - npm install
  cache:
    paths:
      - node_modules/

Ejemplo 3: Pipeline con Secrets

Jenkins: Credenciales en Jenkins UI

GitLab CI:

deploy:
  script:
    - echo "Deploying with $API_KEY"
  variables:
    API_KEY: $CI_API_KEY  # Set in GitLab CI/CD Settings
  only:
    - main

Características Avanzadas

Parallel Execution

test:
  parallel:
    matrix:
      - NODE_VERSION: ["14", "16", "18"]
  image: node:${NODE_VERSION}
  script:
    - npm test

Conditional Pipelines

deploy_staging:
  script:
    - ./deploy.sh staging
  rules:
    - if: '$CI_COMMIT_BRANCH == "develop"'

deploy_production:
  script:
    - ./deploy.sh production
  rules:
    - if: '$CI_COMMIT_BRANCH == "main"'
      when: manual

Artifacts y Dependencies

build:
  script:
    - npm run build
  artifacts:
    paths:
      - dist/
    expire_in: 1 week

deploy:
  script:
    - cp dist/* /var/www/
  dependencies:
    - build

Migración de Plugins Comunes

GitHub Plugin → Native

GitLab CI tiene integración nativa con GitLab repos

Email Extension → Email Service

notify:
  script:
    - 'curl -X POST [email service] -d "Build failed"'
  when: on_failure

Slack Notification → GitLab Integration

Configura en Settings → Integrations → Slack

Credentials Binding → CI/CD Variables

Settings → CI/CD → Variables

Kubernetes Plugin → GitLab Kubernetes Integration

Settings → Kubernetes → Add cluster

Runners: De Jenkins Agents a GitLab Runners

Opción 1: Shared Runners

• Más fácil para empezar
• Gratis en gitlab.com
• Limitaciones de tiempo de ejecución

Opción 2: Specific Runners

• Control total
• Tu propia infraestructura
• Sin limitaciones

Instalación de Runner

# Linux
sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64
sudo chmod +x /usr/local/bin/gitlab-runner
sudo gitlab-runner install
sudo gitlab-runner start

# Register
sudo gitlab-runner register

Runner con Docker

docker run -d --name gitlab-runner --restart always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v gitlab-runner-config:/etc/gitlab-runner \
  gitlab/gitlab-runner:latest

Troubleshooting Común

Problema 1: Job Timeout

Síntoma: Pipeline se detiene después de 1 hora

Solución:

job:
  timeout: 3h
  script:
    - long-running-task

Problema 2: Artifacts No Se Pasan

Síntoma: Job siguiente no encuentra archivos

Solución: Verifica paths y dependencies

build:
  artifacts:
    paths:
      - dist/**/*  # Asegúrate de incluir subdirectorios

deploy:
  dependencies:
    - build  # Explícitamente declara la dependencia

Problema 3: Variables No Disponibles

Síntoma: $VARIABLE está vacía

Solución:

• Verifica que esté definida en Settings → CI/CD
• Chequea que sea visible en el job (protected vs non-protected)
• Usa echo $VARIABLE para debug

Mejores Prácticas

1. Usa Templates

.deploy_template:
  script:
    - ./deploy.sh $ENVIRONMENT
  rules:
    - if: '$CI_COMMIT_BRANCH == $BRANCH'

deploy_staging:
  extends: .deploy_template
  variables:
    ENVIRONMENT: staging
    BRANCH: develop

deploy_production:
  extends: .deploy_template
  variables:
    ENVIRONMENT: production
    BRANCH: main

2. Cache Inteligente

variables:
  CACHE_KEY: ${CI_COMMIT_REF_SLUG}

build:
  cache:
    key: $CACHE_KEY
    paths:
      - node_modules/
      - .npm/
    policy: pull-push

test:
  cache:
    key: $CACHE_KEY
    paths:
      - node_modules/
    policy: pull

3. Validación Local

# Valida sintaxis antes de commit
gitlab-ci-lint < .gitlab-ci.yml

4. Stages Bien Definidos

stages:
  - validate    # Lint, format check
  - build       # Compilar código
  - test        # Unit tests
  - integrate   # Integration tests
  - security    # Security scans
  - deploy      # Deployment
  - verify      # Smoke tests

Migración Gradual

Estrategia Híbrida

1. Fase 1: Nuevos proyectos en GitLab CI
2. Fase 2: Proyectos no críticos migrados
3. Fase 3: Proyectos críticos con testing paralelo
4. Fase 4: Desactivar Jenkins

Testing Paralelo

Mantén ambos pipelines corriendo:

• Jenkins como principal
• GitLab CI en modo shadow
• Compara resultados
• Switchea cuando tengas confianza

Métricas de Éxito

Monitorea estas métricas post-migración:

1. Pipeline Duration: Debe ser igual o menor
2. Success Rate: Mantener o mejorar
3. Developer Satisfaction: Encuestas al equipo
4. Time to Fix: Tiempo para arreglar pipelines rotos
5. Infrastructure Cost: Comparar costos Jenkins vs GitLab

Conclusión

La migración de Jenkins a GitLab CI puede parecer desalentadora, pero con planificación adecuada y ejecución gradual, los beneficios superan ampliamente el esfuerzo:

• 50% menos tiempo en configuración de pipelines
• 80% menos mantenimiento (no más plugins rotos)
• 100% más felicidad del equipo con UI moderna

¿Listo para migrar? Empieza con un proyecto piloto esta semana.