DevOps Básico

CI/CD

Continuous Integration y Continuous Delivery/Deployment. Prácticas de desarrollo que automatizan la integración de código y su entrega a producción.

Pronunciación

/siː aɪ siː diː/
"si-ai-si-di"
Escuchar en: Forvo

Qué es

CI/CD son dos prácticas complementarias:

  • CI (Continuous Integration): Integrar código frecuentemente al repositorio principal, con tests automáticos
  • CD (Continuous Delivery/Deployment): Entregar automáticamente el código a producción o staging

Juntas, permiten entregar software de forma rápida, confiable y frecuente.

Pronunciación

IPA: /siː aɪ siː diː/

Suena como: “si-ai-si-di” - cada letra por separado

Errores comunes:

  • ❌ “cicd” (no es una palabra, son siglas)
  • ❌ “ce-i-ce-de” (usar pronunciación inglesa)

CI vs CD: La diferencia

┌─────────────────────────────────────────────────────────┐
│                    FLUJO CI/CD                           │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   ┌─────────┐    ┌─────────┐    ┌─────────┐            │
│   │  Código │ →  │  Build  │ →  │  Tests  │            │
│   │  Push   │    │         │    │         │            │
│   └─────────┘    └─────────┘    └─────────┘            │
│        │                              │                 │
│        └──────── CI ──────────────────┘                 │
│                                       │                 │
│                                       ▼                 │
│                              ┌─────────────────┐        │
│                              │ Tests pasaron?  │        │
│                              └────────┬────────┘        │
│                                       │                 │
│                          Sí ──────────┴────────── No    │
│                          │                        │     │
│                          ▼                        ▼     │
│                    ┌───────────┐            ┌────────┐  │
│                    │  Deploy   │            │ Falla  │  │
│                    │  Staging  │            │        │  │
│                    └─────┬─────┘            └────────┘  │
│                          │                              │
│                          ▼                              │
│                    ┌───────────┐                        │
│                    │  Deploy   │                        │
│                    │Production │ ← Continuous Delivery  │
│                    └───────────┘                        │
│                          │                              │
│        └──────── CD ─────┘                              │
│                                                          │
└─────────────────────────────────────────────────────────┘

Continuous Integration (CI)

¿Qué incluye?

PrácticaDescripción
Commits frecuentesIntegrar código varias veces al día
Build automatizadoCompilar código automáticamente
Tests automáticosEjecutar tests en cada push
Feedback rápidoSaber en minutos si algo falló

Ejemplo de Pipeline CI

# .github/workflows/ci.yml
name: CI Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout código
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Instalar dependencias
        run: npm ci

      - name: Lint
        run: npm run lint

      - name: Tests unitarios
        run: npm test

      - name: Build
        run: npm run build

Continuous Delivery vs Deployment

AspectoContinuous DeliveryContinuous Deployment
AutomatizaciónHasta stagingHasta producción
Aprobación humanaSí, para producciónNo
RiesgoMenorMayor (requiere más tests)
VelocidadRápidoMuy rápido

Continuous Delivery

Código → CI → Tests → Build → Staging → [Aprobación Manual] → Producción

Continuous Deployment

Código → CI → Tests → Build → Staging → Tests más → Producción (automático)

Ejemplo Completo: Pipeline CD

# .github/workflows/cd.yml
name: CD Pipeline

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm test

  deploy-staging:
    needs: test
    runs-on: ubuntu-latest
    environment: staging
    steps:
      - uses: actions/checkout@v4
      - name: Deploy a Staging
        run: |
          npm ci
          npm run build
          # Deploy a servidor staging
          rsync -avz ./dist/ staging-server:/var/www/app/

  deploy-production:
    needs: deploy-staging
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4
      - name: Deploy a Producción
        run: |
          npm ci
          npm run build
          # Deploy a servidor producción
          rsync -avz ./dist/ prod-server:/var/www/app/

Herramientas Populares de CI/CD

HerramientaTipoIdeal para
GitHub ActionsCloudProyectos en GitHub
GitLab CICloud/Self-hostedProyectos en GitLab
JenkinsSelf-hostedControl total
CircleCICloudVelocidad
Azure DevOpsCloudEcosistema Microsoft
AWS CodePipelineCloudEcosistema AWS

Beneficios de CI/CD

Para desarrolladores

Sin CI/CD:
"¿Funciona en mi máquina?" → Merge → 😱 Producción rota

Con CI/CD:
Push → Tests automáticos → ✅ o ❌ → Feedback inmediato

Para el negocio

MétricaSin CI/CDCon CI/CD
Frecuencia de deploySemanal/MensualDiario/Múltiples por día
Tiempo de feedbackHoras/DíasMinutos
Bugs en producciónFrecuentesRaros
RollbackManual, lentoAutomático, rápido

Caso Práctico: Configurar CI/CD desde Cero

Paso 1: Estructura del proyecto

mi-proyecto/
├── src/
├── tests/
├── package.json
└── .github/
    └── workflows/
        └── ci-cd.yml

Paso 2: Pipeline básico

name: CI/CD

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  # CI - Se ejecuta en cada push/PR
  ci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install
        run: npm ci

      - name: Lint
        run: npm run lint

      - name: Test
        run: npm test -- --coverage

      - name: Build
        run: npm run build

  # CD - Solo en push a main
  cd:
    needs: ci
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Deploy
        env:
          DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }}
        run: |
          npm ci
          npm run build
          npm run deploy

Mejores Prácticas

PrácticaPor qué
Tests rápidos primeroFeedback temprano
Builds reproduciblesMismos resultados siempre
Secrets segurosNunca en código
Rollback automáticoRecuperación rápida
Monitoreo post-deployDetectar problemas

Términos relacionados

  • [[Deploy]] - Proceso de poner código en producción
  • [[Testing]] - Pruebas automáticas del código
  • [[Docker]] - Contenedores para builds consistentes
  • [[Git]] - Control de versiones

Recuerda: CI/CD no es solo herramientas, es una cultura. Empieza con CI básico y evoluciona hacia CD conforme tu equipo gane confianza en los tests y el proceso.

Todos los términos