Curso de CI / CD para tu equipo de DevOps y despliegues

Diseñar una estrategia de ramas compatible con velocidad de entrega, calidad y control de riesgos.

Comparar trunk-based development, Git Flow, GitHub Flow y modelos híbridos corporativos.

Definir reglas de protección de ramas principales, revisiones obligatorias y checks automáticos.

Integrar pull requests o merge requests como punto de control técnico, funcional y de seguridad.

Asociar cada cambio con issue, historia, ticket, versión, release o cambio aprobado.

Evitar ramas largas, merges masivos, conflictos recurrentes y releases imposibles de auditar.

Usar tags, versiones semánticas y convenciones de commits para automatizar releases.

Definir políticas de squash, merge commit, rebase y cherry-pick según el contexto del equipo.

Crear checklist de revisión antes de fusionar cambios en ramas protegidas.

Realizar ejercicio de flujo Git completo con rama, revisión, checks y merge controlado.

Comprender qué significa definir pipelines como código versionado junto al repositorio.

Diseñar la estructura básica de un pipeline con stages, jobs, steps, dependencias y condiciones.

Trabajar con YAML en GitHub Actions, GitLab CI/CD, Azure DevOps o herramientas equivalentes.

Revisar el enfoque `Jenkinsfile` para pipelines declarativos o scripted en Jenkins.

Separar lógica de pipeline, scripts auxiliares, configuración del proyecto y plantillas corporativas.

Crear plantillas reutilizables para evitar duplicidad entre equipos y repositorios.

Usar condiciones por rama, tag, evento, path, variable, entorno o aprobación manual.

Evitar pipelines monolíticos difíciles de leer, depurar y mantener.

Documentar cada stage con propósito, entrada, salida, owner y criterio de fallo.

Realizar ejercicio de creación de un pipeline inicial como código con fases mínimas.

Diseñar builds que puedan repetirse en runners limpios sin depender de configuración manual.

Fijar versiones de runtime, SDK, paquetes, plugins, herramientas y dependencias críticas.

Usar lockfiles, repositorios internos, cachés controladas y mirrors corporativos cuando proceda.

Separar dependencias de desarrollo, test, build, runtime y despliegue.

Detectar builds frágiles por versiones flotantes, scripts locales, rutas absolutas o credenciales embebidas.

Configurar caches de dependencias sin comprometer seguridad ni reproducibilidad.

Publicar logs de build claros, artefactos intermedios y errores accionables.

Comparar builds para backend, frontend, librerías, microservicios y monorepos.

Definir criterios para invalidar caché, limpiar workspace y repetir builds fallidos.

Realizar ejercicio de build reproducible con dependencias bloqueadas y caché controlada.

Integrar pruebas unitarias como primera barrera automática ante cada cambio.

Añadir pruebas de integración con servicios simulados, contenedores remotos o entornos preparados.

Diseñar pruebas de contrato para APIs, eventos, colas y comunicación entre servicios.

Incorporar pruebas E2E cuando aportan valor sin bloquear innecesariamente todo el flujo.

Separar tests rápidos, tests lentos, tests críticos, tests nocturnos y tests previos a release.

Gestionar datos de prueba, fixtures, mocks, stubs y entornos efímeros.

Publicar reportes de test legibles para desarrollo, QA y responsables técnicos.

Detectar flaky tests, aislarlos y tratarlos como deuda técnica prioritaria.

Definir umbrales de cobertura útiles sin convertir la cobertura en métrica vacía.

Realizar ejercicio de pipeline con test unitario, integración, reporte y política de fallo.

Integrar linters, formateadores, análisis estático y reglas de estilo dentro del pipeline.

Configurar quality gates para bloquear cambios con errores críticos, duplicidad o deuda excesiva.

Diferenciar errores bloqueantes, advertencias, deuda técnica aceptada y mejoras recomendadas.

Incorporar análisis de complejidad, cobertura, duplicación, vulnerabilidades de código y estándares internos.

Evitar quality gates imposibles de cumplir en proyectos legacy sin plan de adopción incremental.

Definir criterios por tipo de proyecto: API, frontend, librería, servicio crítico o componente interno.

Publicar resultados de calidad en pull requests y dashboards técnicos.

Crear excepciones justificadas, temporales y trazables cuando un bloqueo no puede resolverse al momento.

Medir evolución de calidad por release, equipo, repositorio o aplicación.

Realizar ejercicio de configuración de quality gate con criterios realistas.

Incorporar escaneo de dependencias y vulnerabilidades desde fases tempranas del pipeline.

Añadir SAST para detectar patrones inseguros antes de fusionar código.

Revisar secretos expuestos en commits, variables, logs, artefactos y configuración.

Generar SBOM cuando el contexto corporativo lo requiere.

Aplicar firma, verificación o control de procedencia de artefactos en entornos críticos.

Configurar permisos mínimos para tokens, runners, repositorios, entornos y despliegues.

Separar secretos por entorno y evitar credenciales compartidas entre equipos.

Integrar controles de seguridad sin bloquear innecesariamente entregas de bajo riesgo.

Crear política de severidades, SLA de remediación y excepciones temporales.

Realizar ejercicio de pipeline DevSecOps con escaneo, secretos, reporte y decisión de bloqueo.

Diferenciar código fuente, build output, paquete, artefacto, imagen, release y despliegue.

Publicar artefactos en repositorios internos como Nexus, Artifactory, GitHub Packages, GitLab Package Registry o equivalentes.

Versionar librerías, APIs, imágenes y releases con criterios semánticos o corporativos.

Etiquetar artefactos con commit, rama, build number, fecha, entorno y metadatos de trazabilidad.

Evitar reconstruir artefactos distintos para cada entorno cuando debe promocionarse el mismo binario.

Gestionar retención, limpieza, caducidad y almacenamiento de artefactos antiguos.

Crear comprobaciones de integridad, firma o hash cuando la criticidad lo requiere.

Separar artefactos snapshot, release candidate, hotfix y producción.

Documentar qué artefacto se desplegó, dónde, cuándo, por quién y con qué resultado.

Realizar ejercicio de publicación y promoción de artefactos versionados.

Diseñar separación clara entre desarrollo, integración, QA, preproducción y producción.

Gestionar variables de entorno sin mezclar configuración técnica, secretos y parámetros funcionales.

Proteger secretos en stores corporativos, variables seguras o integraciones autorizadas.

Evitar que credenciales aparezcan en logs, scripts, artefactos o mensajes de error.

Definir aprobaciones manuales para entornos sensibles sin romper la trazabilidad.

Crear matrices de despliegue por rama, tag, entorno o tipo de release.

Documentar propietarios, permisos y criterios de acceso a cada entorno.

Evitar divergencias de configuración que hacen que el software funcione solo en un entorno.

Validar configuración antes del despliegue con checks automáticos.

Realizar ejercicio de promoción de una versión entre entornos con variables y secretos seguros.

Diferenciar despliegue automático, entrega continua y despliegue continuo a producción.

Aplicar estrategias rolling, blue-green, canary, shadow deployment y feature flags según el riesgo.

Definir criterios de avance, pausa, reversión y aprobación durante un release.

Preparar rollback técnico y funcional antes de desplegar cambios críticos.

Separar rollback de código, rollback de configuración, rollback de base de datos y desactivación funcional.

Integrar smoke tests y health checks después del despliegue.

Detectar señales tempranas de fallo: errores, latencia, saturación, logs y métricas de negocio.

Evitar despliegues irreversibles sin plan de migración o compatibilidad hacia atrás.

Documentar release notes, evidencia de despliegue y resultado final.

Realizar ejercicio de despliegue controlado con validación posterior y plan de rollback.

Comprender cómo CI/CD cambia cuando la aplicación se empaqueta como imagen de contenedor.

Construir imágenes reproducibles, ligeras, seguras y compatibles con políticas corporativas.

Escanear imágenes para detectar vulnerabilidades, secretos y configuraciones inseguras.

Etiquetar imágenes con versión, commit, rama y metadatos de build.

Diferenciar manifiestos Kubernetes, Helm charts, Kustomize, operadores y plantillas corporativas.

Entender GitOps como modelo donde Git representa el estado deseado del despliegue.

Usar Argo CD o herramientas equivalentes para sincronizar entornos desde repositorios declarativos.

Separar pipeline de CI, repositorio de artefactos y pipeline de CD/GitOps.

Validar cambios de manifiestos antes de aplicarlos a entornos superiores.

Realizar ejercicio conceptual de flujo CI/CD con imagen, manifiestos y promoción GitOps.

Integrar logs, métricas, trazas y eventos como parte del ciclo CI/CD.

Definir checks automáticos posteriores al despliegue para validar salud de la aplicación.

Conectar pipelines con herramientas de observabilidad como Prometheus, Grafana, OpenTelemetry, Dynatrace, Datadog o equivalentes.

Detectar degradaciones tras release mediante error rate, latencia, saturación y volumetría.

Crear dashboards de release para desarrollo, QA, DevOps y responsables técnicos.

Automatizar notificaciones con contexto útil: versión, commit, entorno, resultado y enlaces.

Integrar postmortems y aprendizajes en mejoras del pipeline.

Evitar considerar exitoso un despliegue solo porque el job terminó en verde.

Medir lead time, deployment frequency, change failure rate y mean time to recovery.

Realizar ejercicio de validación post-release con métricas, logs y decisión de continuidad.

Medir duración por job, stage, cola, runner, descarga de dependencias, build, test y despliegue.

Identificar cuellos de botella en pipelines lentos o inestables.

Aplicar paralelización, matrices, caché, artefactos intermedios y ejecución condicional.

Separar checks obligatorios de checks diferidos o programados.

Reducir consumo de runners evitando trabajos duplicados, entornos innecesarios y builds repetidos.

Gestionar flaky tests, timeouts, retries y fallos intermitentes con criterios técnicos.

Evitar optimizaciones que reducen tiempo a costa de perder calidad, seguridad o trazabilidad.

Crear métricas de salud del pipeline por repositorio, equipo o aplicación.

Documentar mejoras y validar impacto antes/después.

Realizar ejercicio de reducción de tiempo de pipeline manteniendo controles críticos.

Definir estándares mínimos de CI/CD para todos los repositorios corporativos.

Crear plantillas compartidas para builds, tests, seguridad, artefactos, despliegue y rollback.

Establecer ownership de pipelines, runners, secretos, plantillas, dashboards y entornos.

Crear catálogo de patrones por tecnología: Java, .NET, Node.js, Python, frontend, librerías y contenedores.

Diseñar golden paths para que los equipos entreguen software sin reinventar pipelines desde cero.

Incorporar políticas de auditoría, trazabilidad, permisos, aprobaciones y compliance técnico.

Revisar pipelines obsoletos, duplicados, inseguros o sin mantenimiento.

Definir proceso de cambios sobre plantillas compartidas sin romper equipos consumidores.

Crear documentación viva con ejemplos, errores frecuentes, decisiones y buenas prácticas.

Realizar ejercicio de diseño de estándar corporativo CI/CD para una organización técnica.

Diseñar un flujo CI/CD completo para una aplicación corporativa de referencia.

Crear estrategia de ramas, pull requests, revisiones, checks obligatorios y protección de rama principal.

Definir pipeline como código con stages de validación, build, testing, calidad, seguridad, artefactos y despliegue.

Incorporar build reproducible con dependencias fijadas, caché controlada y logs accionables.

Añadir pruebas unitarias, integración, contrato o E2E según el contexto de la aplicación.

Configurar quality gates con reglas realistas de calidad, cobertura, estilo y deuda técnica.

Integrar escaneo de dependencias, detección de secretos y análisis de seguridad.

Publicar artefacto versionado con metadatos de commit, rama, build y release candidate.

Diseñar promoción entre desarrollo, QA, preproducción y producción con aprobaciones controladas.

Definir variables, secretos y configuración segura por entorno.

Diseñar estrategia de despliegue: rolling, blue-green, canary, feature flags o GitOps según el caso.

Preparar plan de rollback técnico y funcional con criterios de activación.

Crear validación post-despliegue con smoke tests, métricas, logs, trazas y señales de salud.

Optimizar el pipeline reduciendo duración sin eliminar controles críticos.

Documentar estándares, owners, riesgos, excepciones, decisiones y mantenimiento futuro.

Crear dashboard o informe de salud del pipeline con tiempos, fallos, frecuencia y calidad.

Preparar checklist de release para equipos de desarrollo, QA, seguridad y plataforma.

Simular una incidencia de pipeline o despliegue fallido y ejecutar recuperación controlada.

Presentar la solución final con arquitectura, evidencias, pipeline, seguridad, despliegue y gobierno.

Entregar una guía de adopción CI/CD para equipos corporativos con próximos pasos y recomendaciones.