¡Lánzate al pipeline de CI/CD: tu primer paso concreto hoy!

CI CD Pipeline: lo esencial en un artículo — código real, diagramas y pasos concretos, extractos de un curso de 20 lecciones.

¡Lánzate al pipeline de CI/CD: tu primer paso concreto hoy!

La mejor forma de aprender CI CD Pipeline es practicando. Este artículo te da un empujón con extractos prácticos extraídos de un curso de 20 lecciones — lo suficiente para obtener un primer resultado hoy mismo.

tl;dr
  • Introducción a CICD
  • Integración Continua
  • Calidad del Código
  • Optimización del Pipeline
  • Despliegue Continuo
~$ cat ./parcours.md # CI CD Pipeline — 6 capítulos
01
Introducción al CICD
→ Capítulo 00.1 — Filosofía CI/CD : ¿Por qué automatizar?→ Capítulo 00.2 — El ecosistema de herramientas CI/CD+ 1 más lecciones
02
Integración Continua
→ Capítulo 01.1 — Estrategias de ramas Git→ Capítulo 01.2 — Builds automatizados y pipelines YAML avanzados+ 1 más lecciones
03
Calidad del Código
→ Capítulo 02.1 — Análisis estático con SonarQube→ Capítulo 02.2 — Seguridad en el CI/CD : SAST, DAST y dependencias+ 1 más lecciones
04
Optimización del Pipeline
→ Capítulo 03.1 — Optimización del Pipeline : Caché, Paralelización y Matrices→ Capítulo 03.2 — Optimización de builds Docker+ 1 más lecciones
05
Despliegue Continuo
→ Capítulo 04.1 — Estrategias de despliegue avanzadas→ Capítulo 04.2 — Entornos, Secretos y Rollback+ 1 más leçons
06
Monitorización y Observabilidad
→ Capítulo 05.1 — Monitorización y Observabilidad post-despliegue→ Capítulo 05.2 — SLO, SLA y Métricas DORA
🏁
Proyecto final
→ Te vas con un proyecto concreto y demostrable

Cobertura de código y umbrales de calidad

Capítulo 02 • Lección 03 • Duración : 45 min

NOTE🎯 Objetivos
  • Comprender qué es la cobertura de código y sus límites
  • Medir la cobertura con las herramientas estándar (pytest-cov, jest, JaCoCo)
  • Definir umbrales inteligentes (línea, rama, mutación)
  • Bloquear un PR si la cobertura baja
  • Visualizar los informes en Codecov o SonarQube

1. ¿Qué es la cobertura de código?

La cobertura de código mide el porcentaje de líneas (o de ramas, condiciones, funciones) ejecutadas por tus pruebas automatizadas.

TipoMedidaEjemplo
Line Coverage% de líneas ejecutadas80 % = 80 líneas de 100 son alcanzadas
Branch Coverage% de ramas condicionales probadasif/else, switch — ambos caminos deben pasar
Function Coverage% de funciones llamadas¿Todas las funciones exportadas están probadas?
Statement Coverage% de instrucciones ejecutadasCercano a line coverage
Mutation Coverage% de mutaciones detectadas por las pruebasMás fiable pero costoso (mutation testing)
WARNING⚠️ Trampa clásica

El 100 % de cobertura NO significa 100 % de calidad. Se puede tener 100 % de líneas ejecutadas sin verificar los resultados. assert es igual de importante que ejecutar el código.

2. Cobertura en Python con pytest-cov

output
pip install pytest pytest-cov

# Ejecutar las pruebas con coverage
pytest --cov=mon_module --cov-report=term --cov-report=html

# Salida por consola :
# Name            Stmts   Miss  Cover
# -------------------------------------
# mon_module.py     50      5    90%
# -------------------------------------
# TOTAL             50      5    90%

# Informe HTML interactivo en htmlcov/index.html

Configuración vía pyproject.toml

output
[tool.pytest.ini_options]
addopts = "--cov=src --cov-report=term-missing --cov-report=xml --cov-fail-under=80"

[tool.coverage.run]
source = ["src"]
omit = [
    "*/tests/*",
    "*/migrations/*",
    "*/__init__.py"
]

[tool.coverage.report]
exclude_lines = [
    "pragma: no cover",
    "raise NotImplementedError",
    "if __name__ == .__main__.:",
]
fail_under = 80
show_missing = true

3. Cobertura en JavaScript con Jest

output
npm install --save-dev jest

# package.json
{
  "scripts": {
    "test": "jest",
    "test:coverage": "jest --coverage"
  },
  "jest": {
    "collectCoverageFrom": [
      "src/**/*.{js,ts}",
      "!src/**/*.d.ts",
      "!src/index.ts"
    ],
    "coverageThreshold": {
      "global": {
        "branches": 75,
        "functions": 80,
        "lines": 80,
        "statements": 80
      }
    },
    "coverageReporters": ["text", "lcov", "html", "cobertura"]
  }
}

# Ejecutar
npm run test:coverage

# Si no se alcanza el umbral :
# Jest: "global" coverage threshold for lines (80%) not met: 73.5%
# → Build FALLA

4. Cobertura en Java con JaCoCo

output
<!-- pom.xml -->
<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.11</version>
  <executions>
    <execution>
      <goals><goal>prepare-agent</goal></goals>
    </execution>
    <execution>
      <id>report</id>
      <phase>test</phase>
      <goals><goal>report</goal></goals>
    </execution>
    <execution>
      <id>jacoco-check</id>
      <goals><goal>check</goal></goals>
      <configuration>
        <rules>
          <rule>
            <element>BUNDLE</element>
            <limits>
              <limit>
                <counter>LINE</counter>
                <value>COVEREDRATIO</value>
                <minimum>0.80</minimum>
              </limit>
            </limits>
          </rule>
        </rules>
      </configuration>
    </execution>
  </executions>
</plugin>

mvn clean test
# Informe en target/site/jacoco/index.html

5. Definir umbrales inteligentes

Tipo de proyectoUmbral recomendado
Critical (banking, healthcare, aerospace)90-95 %
SaaS / Web app production80-85 %
Backend API75-85 %
Frontend (UI logic)60-70 %
Prototype / MVP40-60 %
Script utilitario0-30 % (a menudo innecesario)
TIP💡 Estrategia realista

En lugar de un umbral absoluto, exija que la cobertura no baje respecto a la rama main. Codecov y SonarQube lo hacen de forma nativa.

6. Integración GitHub Actions

output
name: CI with Coverage

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      
      - name: Install
        run: pip install -e ".[dev]"
      
      - name: Tests + coverage
        run: pytest --cov --cov-report=xml --cov-report=term --cov-fail-under=80
      
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v4
        with:
          file: ./coverage.xml
          token: ${{ secrets.CODECOV_TOKEN }}
          fail_ci_if_error: true

7. Codecov : visualizar y comparar

codecov.yml para personalizar

output
coverage:
  status:
    project:
      default:
        target: 80%
        threshold: 1%
    patch:
      default:
        target: 90%
        threshold: 5%

comment:
  layout: "header, diff, flags, files"
  behavior: default
  require_changes: false

ignore:
  - "tests/**"
  - "**/__init__.py"
  - "migrations/**"

Gestión de artifacts y registries

Capítulo 03 • Lección 03 • Duración : 45 min

NOTE🎯 Objetivos
  • Comprender qué es un artifact y un registry
  • Almacenar y compartir artifacts (zip, jar, wheel) en GitHub Actions
  • Enviar imágenes Docker a Docker Hub, GHCR, AWS ECR
  • Gestionar el versionado semántico de los artifacts
  • Establecer reglas de retención para evitar la explosión de costes

1. ¿Qué es un artifact?

Un artifact es cualquier archivo producido por un build y destinado a ser utilizado más tarde :

Tipo de artifactEjemploRegistry típico
Image containerdevforge-api:1.2.3 (Docker)Docker Hub, GHCR, ECR, Quay
Package Pythonmy-lib-1.0.0.whlPyPI, AWS CodeArtifact, GitHub Packages
Package npmmy-lib-1.0.0.tgznpm registry, GitHub Packages
JAR Javamy-app-1.0.jarMaven Central, Nexus, JFrog Artifactory
Binario compiladomy-cli-linux-amd64GitHub Releases, S3
Helm chartmy-chart-1.0.0.tgzChartMuseum, OCI registries
Fichero ZIP genéricobuild-output.zipGitHub Actions Artifacts, S3

2. Artifacts GitHub Actions (intra-workflow)

Subir un artifact

output
- name: Build wheel
  run: python -m build

- name: Upload wheel as artifact
  uses: actions/upload-artifact@v4
  with:
    name: python-wheel
    path: dist/*.whl
    retention-days: 30

Descargar en un job siguiente

output
deploy:
  needs: build
  runs-on: ubuntu-latest
  steps:
    - name: Download wheel
      uses: actions/download-artifact@v4
      with:
        name: python-wheel
        path: ./dist
    
    - name: Install
      run: pip install dist/*.whl
TIP

Los artifacts de GitHub son gratuitos hasta 500 MB por repo público, y expiran por defecto después de 90 días.

3. Container registries comparados

RegistryCosteVentajasInconvenientes
Docker HubGratis (público) / 5 $/user (privado)El más popular, amplio ecosistemaRate limits en los pulls
GHCR (GitHub)Gratis (público) / incluido en GitHubIntegración nativa con GitHubMenos conocido
AWS ECR0.10 $/Go/mesSeguridad IAM, escaneo automático, integrado con ECS/EKSEspecífico de región
GCR / Artifact Registry0.10 $/Go/mesIntegrado con GCP, multi-formatoLock-in GCP
Azure ACRBasic 5 $/mesIntegrado con AzureLock-in Azure
Quay.ioGratis (público) / de pago (privado)Fuerte detector de vulnerabilidadesMenos soporte
Harbor (self-hosted)Gratis (pero ops)Sin dependencia externa, control totalHay que mantenerlo uno mismo

4. Push hacia Docker Hub desde GitHub Actions

output
- name: Login Docker Hub
  uses: docker/login-action@v3
  with:
    username: ${{ secrets.DOCKERHUB_USERNAME }}
    password: ${{ secrets.DOCKERHUB_TOKEN }}

- name: Build and push
  uses: docker/build-push-action@v5
  with:
    context: .
    push: true
    tags: |
      myuser/myapp:latest
      myuser/myapp:${{ github.sha }}
      myuser/myapp:${{ github.ref_name }}
    platforms: linux/amd64,linux/arm64
    cache-from: type=gha
    cache-to: type=gha,mode=max

5. Push hacia GHCR (GitHub Container Registry)

output
- name: Login to GHCR
  uses: docker/login-action@v3
  with:
    registry: ghcr.io
    username: ${{ github.actor }}
    password: ${{ secrets.GITHUB_TOKEN }}

- name: Build and push
  uses: docker/build-push-action@v5
  with:
    push: true
    tags: |
      ghcr.io/${{ github.repository }}:latest
      ghcr.io/${{ github.repository }}:${{ github.sha }}
TIP

GHCR no requiere ningún secret adicional : el GITHUB_TOKEN autogenerado es suficiente.

6. Push hacia AWS ECR

output
- name: Configure AWS credentials
  uses: aws-actions/configure-aws-credentials@v4
  with:
    role-to-assume: arn:aws:iam::123456789012:role/github-actions-ecr
    aws-region: eu-west-3

- name: Login to ECR
  id: ecr
  uses: aws-actions/amazon-ecr-login@v2

- name: Build and push
  uses: docker/build-push-action@v5
  with:
    push: true
    tags: |
      ${{ steps.ecr.outputs.registry }}/myapp:latest
      ${{ steps.ecr.outputs.registry }}/myapp:${{ github.sha }}

7. Versionado semántico de las imágenes

Convención SemVer : MAJOR.MINOR.PATCH

TagCuándo usarlo
1.2.3Versión exacta inmutable (producción estricta)
1.2Último parche de la menor 1.2
1Última menor de la mayor 1
latestLa más reciente (¡evitar en prod!)
sha-abc1234Tag basado en el commit de Git
main / developÚltima de la rama
pr-42Específico de una Pull Request
v1.2.3-rc.1Release candidate

Con docker/metadata-action

output
- name: Generate tags
  id: meta
  uses: docker/metadata-action@v5
  with:
    images: myuser/myapp
    tags: |
      type=ref,event=branch
      type=ref,event=pr
      type=semver,pattern={{version}}
      type=semver,pattern={{major}}.{{minor}}
      type=semver,pattern={{major}}
      type=sha,prefix=sha-,format=short
      type=raw,value=latest,enable={{is_default_branch}}

# Salida automática según el contexto :
# - en main : latest, sha-abc1234, main
# - en tag v1.2.3 : 1.2.3, 1.2, 1, sha-abc1234
# - en PR #42 : pr-42, sha-abc1234

Capítulo 00.1 — Filosofía CI/CD : ¿Por qué automatizar?

NOTEObjetivo de esta lección — Comprender los problemas del desarrollo de software tradicional, descubrir por qué la automatización CI/CD se ha vuelto imprescindible, y aprender los principios fundamentales que guían un pipeline moderno.

1. El mundo antes de CI/CD — La «Integration Hell»

Antes de adoptar las prácticas CI/CD, los equipos de desarrollo trabajaban en silos durante semanas o meses en ramas separadas. Cuando intentaban integrar su código, el resultado solía ser catastrófico. A este fenómeno se le llamaba Integration Hell (infierno de la integración).

🔴 Antes de CI/CD

🟢 Con CI/CD

WARNINGEstadística impactante — Según el informe DORA 2023, los equipos «elite» despliegan varias veces al día con una tasa de fallo de despliegue inferior al 5 %, frente a una vez al mes o menos para los equipos «low performers».

2. El coste del bug — La regla del «Shift Left»

El principio «Shift Left» (desplazar a la izquierda) significa que hay que detectar y corregir los problemas lo antes posible en el ciclo de desarrollo. Cuanto más tarde se detecta un bug, más caro resulta corregirlo.

CI/CD permite detectar los problemas desde el commit, reduciendo drásticamente el coste de corrección. Las pruebas automatizadas, el análisis estático del código y los escaneos de seguridad se ejecutan en cada push, mucho antes de que el código llegue a producción.

3. Los tres pilares : CI, CD (Entrega) y CD (Despliegue)

🔵 CI — Integración Continua

Los desarrolladores integran su código en una rama común varias veces al día. En cada integración se lanza un pipeline automatizado : compilación, pruebas unitarias, análisis de código.

Objetivo : detectar conflictos y bugs rápidamente.

🟡 CD — Entrega Continua

El código siempre está en un estado desplegable. Tras la CI, el pipeline prepara automáticamente una release (paquete, imagen Docker) lista para desplegarse en cualquier entorno.

Objetivo : poder desplegar en cualquier momento, con aprobación humana posible.

🟢 CD — Despliegue Continuo

Todo commit que pasa las pruebas se despliega automáticamente en producción, sin intervención humana. Es el nivel máximo de automatización, utilizado por Netflix, Amazon, Google.

Objetivo : eliminar cualquier retraso entre el código y el valor para el usuario.

PrácticaFrecuencia de despliegueAprobación humanaNivel de confianza requerido
ManualTrimestral / AnualSiempreBajo (proceso)
CI solamenteSemanal / MensualSiempreMedio (pruebas básicas)
CI + CD EntregaDiaria / SemanalOpcionalAlto (pruebas completas)
CI + CD DespliegueVarias veces/díaNuncaMuy alto (pruebas + monitorización)

4. El pipeline CI/CD — Vista general

Un pipeline CI/CD es una cadena de pasos automatizados que transforma un commit de código en una aplicación desplegada en producción.

PasoDescripciónHerramientas habitualesDuración típica
CodeEl desarrollador sube código a GitGit, GitHub, GitLab
BuildCompilación, resolución de dependenciasMaven, npm, Gradle, Docker1–5 min
Test unitarioPruebas rápidas a nivel de funcionesJUnit, Jest, pytest1–3 min
Análisis de calidadCobertura de código, linting, seguridadSonarQube, ESLint, Snyk2–5 min
PackageCreación de un artifact desplegableDocker, JAR, ZIP, Helm2–10 min
Test de integraciónPruebas en un entorno completoPostman, Cypress, k65–15 min
Deploy StagingDespliegue en entorno de pruebasKubernetes, ECS, Heroku2–5 min
Deploy ProdDespliegue en producciónRolling, Blue/Green, Canary2–10 min
MonitorVigilancia y alertas post-desplieguePrometheus, Grafana, DatadogContinuo

5. Las métricas DORA — Medir el rendimiento DevOps

El proyecto DORA (DevOps Research and Assessment) identificó cuatro métricas clave que miden la eficacia de una organización DevOps. Estas métricas permiten situar a tu equipo y definir objetivos de mejora.

📈 Deployment Frequency

va-plus-loin

Este artículo cubre los extractos más útiles — el curso completo CI CD Pipeline (7 capítulos, 20 lecciones, ejercicios corregidos y proyecto final) te lleva hasta el final.

./acceder-al-curso-completo curso gratuito : Dominar Claude Code

FAQ

¿Cuánto tiempo se tarda en aprender CI CD Pipeline?
Con una progresión estructurada (7 capítulos, 20 lecciones cortas y prácticas), se alcanza un nivel operativo en pocas semanas a razón de 30 a 60 minutos al día. Lo importante es practicar cada noción inmediatamente.
¿Se necesitan requisitos previos?
Con nociones básicas de informática basta. Si sabes usar un terminal y leer código sencillo, estás listo.
¿Por dónde empezar de forma concreta?
Reproduce los comandos de este artículo, luego sigue el curso completo CI CD Pipeline : encadena las 20 lecciones en orden, con ejercicios y proyecto final.

📬 ¿Quieres recibir este tipo de guía cada semana? Suscríbete gratis — código real, cero paja.