Curso de DevOps para tu equipo — Automatización y CI/CD

Uso de Git como base de trazabilidad, colaboración, revisión y automatización de cambios en código, infraestructura y configuración.

Diseño de estrategias de ramas: trunk-based development, GitFlow simplificado, feature branches, release branches y hotfixes.

Aplicación de pull requests como mecanismo de revisión técnica, calidad, seguridad, documentación y transferencia de conocimiento.

Creación de políticas de protección de ramas, revisores obligatorios, checks automáticos y validación previa al merge.

Gestión de commits claros, convenciones de mensajes, squash, rebase, merge y resolución de conflictos.

Organización de repositorios mono-repo, multi-repo y repositorios separados para infraestructura, aplicaciones y configuración.

Uso de tags, releases y versionado semántico para controlar entregables.

Integración de Git con issues, boards, pipelines, documentación y despliegue.

Prevención de secretos en repositorios mediante escaneo, hooks y políticas.

Ejercicio práctico: preparar un flujo Git corporativo con ramas, PRs, reglas de protección y versión inicial.

Comprensión de CI como práctica para validar cambios de forma temprana mediante build, test, análisis estático y generación de artefactos.

Creación de workflows YAML en GitHub Actions con triggers por push, pull request, tags, schedule y ejecución manual.

Uso de jobs, steps, runners, actions reutilizables, matrices, variables, secrets, environments y artefactos.

Implementación de pipelines de build y test para aplicaciones backend, frontend o servicios contenerizados.

Separación de validaciones rápidas en pull request y validaciones completas en ramas principales.

Gestión de cachés de dependencias para reducir tiempos de pipeline.

Creación de quality gates que bloquean merges con tests fallidos, vulnerabilidades críticas o baja calidad.

Comparación conceptual con GitLab CI/CD, Azure DevOps Pipelines, Jenkins y otros motores CI/CD.

Revisión de GitHub Actions como plataforma de CI/CD que permite automatizar build, test y deployment directamente desde el repositorio.

Ejercicio práctico: crear un pipeline CI completo con build, test, análisis y artefacto versionado.

Diferenciación entre continuous integration, continuous delivery y continuous deployment.

Diseño de pipelines de entrega con promoción entre entornos: development, staging, preproducción y producción.

Creación de artefactos inmutables que se construyen una vez y se despliegan en distintos entornos.

Implementación de approvals, environments, gates y validaciones manuales cuando el riesgo lo exige.

Uso de estrategias de despliegue: rolling update, blue/green, canary, feature flags y shadow traffic.

Preparación de rollback y roll-forward como parte del diseño, no como reacción improvisada.

Gestión de versiones, changelog, notas de release y trazabilidad de cambios.

Coordinación entre despliegues, migraciones de base de datos y compatibilidad hacia atrás.

Medición de lead time, frecuencia de despliegue, tasa de fallo y tiempo de recuperación.

Ejercicio práctico: diseñar una estrategia de release para una aplicación crítica con despliegue gradual y rollback.

Integración de pruebas unitarias, integración, contrato, end-to-end, smoke, regresión y performance dentro del ciclo DevOps.

Diseño de pirámide de testing equilibrada para evitar pipelines lentos, frágiles o insuficientes.

Creación de datos de prueba seguros, reproducibles y aislados.

Uso de tests de contrato para reducir roturas entre microservicios y APIs.

Ejecución de pruebas rápidas en pull request y pruebas completas antes de despliegue.

Incorporación de análisis estático, linters, formateo, cobertura y calidad de código.

Gestión de tests flaky con aislamiento, cuarentena, métricas y corrección.

Creación de informes de calidad accesibles para desarrollo, QA y responsables técnicos.

Integración de QA en el flujo continuo sin convertirlo en cuello de botella final.

Ejercicio práctico: añadir quality gates y estrategia de testing a un pipeline existente.

Comprensión de los contenedores como unidad portable de empaquetado, ejecución y despliegue de aplicaciones.

Creación de Dockerfiles seguros, eficientes y mantenibles con imágenes base adecuadas.

Uso de multi-stage builds para reducir tamaño, superficie de ataque y tiempo de despliegue.

Gestión de variables de entorno, volúmenes, redes, puertos y configuración runtime.

Creación de imágenes reproducibles y etiquetadas por commit, versión y entorno.

Escaneo de imágenes para detectar vulnerabilidades y dependencias obsoletas.

Optimización de capas, caché, permisos y usuario no root.

Uso de Docker Compose para laboratorios locales con aplicación, base de datos, colas y servicios auxiliares.

Publicación de imágenes en GitHub Container Registry, Docker Hub, Amazon ECR, Azure Container Registry o registros equivalentes.

Ejercicio práctico: contenerizar una aplicación y publicarla en un registry con pipeline automatizado.

Comprensión de Kubernetes como plataforma para desplegar, escalar y operar aplicaciones contenerizadas; la documentación oficial lo define como motor open source para automatizar despliegue, escalado y gestión de aplicaciones contenerizadas.

Creación de Deployments, Services, ConfigMaps, Secrets, Ingress, Jobs, CronJobs y PersistentVolumeClaims.

Gestión de readiness probes, liveness probes y startup probes para mejorar disponibilidad.

Diseño de recursos requests, limits, autoscaling y tolerancia a fallos.

Organización de namespaces, labels, annotations y convenciones de naming.

Gestión de rolling updates, rollback, revision history y estrategias de despliegue.

Integración de aplicaciones con bases de datos, colas, almacenamiento y servicios externos.

Uso de kubectl para diagnóstico, logs, eventos, exec, port-forward y troubleshooting.

Revisión de prácticas de seguridad: RBAC, service accounts, network policies, security contexts y secrets.

Ejercicio práctico: desplegar una aplicación completa en Kubernetes con configuración, servicio, ingress y estrategia de actualización.

Comprensión de Helm como gestor de paquetes para Kubernetes y herramienta de estandarización de despliegues.

Creación de charts con templates, values, helpers, dependencies y convenciones de versión.

Separación de configuración por entorno mediante archivos values.

Gestión de releases, upgrades, rollbacks y diffs.

Diseño de charts reutilizables para aplicaciones internas.

Prevención de charts rígidos, difíciles de mantener o demasiado acoplados a un entorno.

Uso de repositorios Helm internos o externos.

Validación de plantillas con lint, dry-run y pruebas de despliegue.

Integración de Helm en pipelines CI/CD.

Ejercicio práctico: crear un Helm chart corporativo para una aplicación con configuración por entorno.

Comprensión de Terraform como herramienta de infraestructura como código para construir, cambiar y versionar infraestructura de forma segura y eficiente.

Creación de configuraciones con providers, resources, variables, outputs, locals y data sources.

Gestión del estado de Terraform, backends remotos, locking y separación por entorno.

Diseño de módulos reutilizables para redes, clusters, bases de datos, buckets, DNS, IAM y registros.

Uso de `terraform fmt`, `validate`, `plan`, `apply`, `destroy` e importación de recursos existentes.

Organización de repositorios IaC con módulos, entornos, workspaces o estructura por carpetas.

Gestión de secretos y variables sensibles sin exponer credenciales.

Integración de Terraform en pipelines con validaciones, plan review y approvals.

Prevención de drift mediante revisiones periódicas y políticas de cambio.

Ejercicio práctico: provisionar infraestructura de laboratorio con Terraform y pipeline de validación.

Comprensión de GitOps como modelo donde Git actúa como fuente de verdad declarativa para infraestructura y aplicaciones.

Diferenciación entre pipelines que empujan despliegues y controladores que sincronizan estado desde Git.

Implementación conceptual con Argo CD o Flux para clusters Kubernetes.

Organización de repositorios GitOps por aplicación, entorno, cluster y equipo.

Gestión de sincronización, drift, health checks y rollback.

Uso de Kustomize o Helm dentro de flujos GitOps.

Separación entre configuración sensible, manifiestos públicos y secretos cifrados.

Preparación de promoción entre entornos mediante pull requests.

Revisión de riesgos: cambios no revisados, auto-sync mal configurado, secretos, permisos excesivos y loops.

Ejercicio práctico: diseñar flujo GitOps para desplegar una aplicación en varios entornos.

Comparación de servicios cloud habituales para DevOps: compute, contenedores, Kubernetes, networking, IAM, storage, bases de datos, logs y registries.

Diseño de arquitecturas portables evitando acoplarse innecesariamente a un único proveedor.

Uso de servicios gestionados como EKS, AKS, GKE, ECS, App Service, Cloud Run, Container Apps, RDS, Cloud SQL o equivalentes.

Gestión de identidades, roles, service principals, IAM policies y permisos mínimos.

Diseño de entornos cloud separados por cuenta, suscripción, proyecto, región o workload.

Automatización de aprovisionamiento con Terraform.

Control de costes mediante tagging, presupuestos, alertas y dimensionamiento.

Integración de cloud con CI/CD, registros de contenedores, secretos y observabilidad.

Preparación de estrategia multi-cloud o híbrida solo cuando haya justificación real.

Ejercicio práctico: diseñar arquitectura DevOps cloud para una aplicación empresarial.

Identificación de secretos críticos: tokens, claves API, certificados, contraseñas, claves SSH, credenciales cloud y connection strings.

Gestión de secretos en GitHub Actions, Kubernetes Secrets, external secrets, Vault, AWS Secrets Manager, Azure Key Vault o Google Secret Manager.

Prevención de secretos en repositorios, logs, imágenes, variables no cifradas o mensajes de error.

Rotación de secretos y revocación de credenciales comprometidas.

Uso de OIDC entre CI/CD y cloud para evitar claves estáticas cuando sea posible.

Diseño de permisos mínimos para pipelines, runners, workloads y operadores.

Separación de identidades humanas, cuentas de servicio y workloads.

Auditoría de accesos y trazabilidad de acciones críticas.

Gestión de secretos en entornos locales, staging y producción.

Ejercicio práctico: eliminar credenciales estáticas de un pipeline y usar secretos gestionados.

Integración de seguridad desde el diseño, repositorio, pipeline, contenedor, infraestructura, runtime y operación.

Uso de SAST, SCA, secret scanning, container scanning, IaC scanning y policy as code.

Generación y revisión de SBOM para conocer componentes y dependencias del software.

Gestión de vulnerabilidades por criticidad, explotación, exposición y contexto de negocio.

Automatización de controles sin bloquear entregas por falsos positivos constantes.

Seguridad en imágenes: base images, usuarios no root, permisos, paquetes mínimos y actualización.

Seguridad en Kubernetes: RBAC, network policies, admission control, security contexts y escaneo de manifests.

Integración de seguridad con alertas, tickets, dashboards y responsabilidad de equipo.

Preparación de respuesta ante CVEs críticas en dependencias o imágenes.

Ejercicio práctico: añadir controles DevSecOps a un pipeline y resolver vulnerabilidades priorizadas.

Comprensión de policy as code como forma de automatizar reglas de seguridad, calidad y cumplimiento.

Uso conceptual de OPA, Gatekeeper, Kyverno, Conftest o herramientas equivalentes.

Validación de manifests Kubernetes, Terraform, Dockerfiles y configuraciones antes de desplegar.

Creación de políticas para bloquear contenedores privilegiados, imágenes sin tag, secretos inseguros o recursos sin límites.

Integración de políticas en CI/CD y admission controllers.

Gestión de excepciones documentadas y temporales.

Creación de evidencias de cumplimiento para auditorías.

Control de cambios con pull requests, approvals y trazabilidad.

Prevención de burocracia manual mediante automatización de controles.

Ejercicio práctico: diseñar un conjunto de políticas mínimas para Kubernetes y Terraform.

Diseño de observabilidad como capacidad para entender comportamiento de sistemas, no solo almacenar logs.

Integración de métricas, logs y trazas para detectar, diagnosticar y resolver incidentes.

Uso de Prometheus, Grafana, Loki, Tempo, Jaeger, OpenTelemetry o stacks equivalentes.

Definición de indicadores RED, USE, Golden Signals, SLI y SLO.

Instrumentación de aplicaciones y plataformas con OpenTelemetry cuando proceda.

Creación de dashboards útiles por servicio, infraestructura, pipeline y experiencia de usuario.

Diseño de alertas accionables que reduzcan ruido y tengan propietario claro.

Correlación entre despliegues, errores, latencia y cambios recientes.

Gestión de retención, costes, cardinalidad y privacidad de telemetría.

Ejercicio práctico: instrumentar una aplicación y crear dashboard con métricas, logs y trazas básicas.

Comprensión de SRE como práctica complementaria a DevOps centrada en fiabilidad, automatización, SLOs y reducción de toil.

Definición de SLIs, SLOs, error budgets y prioridades operativas.

Gestión de incidentes con roles, severidades, comunicación, mitigación, resolución y postmortem.

Creación de runbooks y playbooks para incidencias recurrentes.

Automatización de tareas repetitivas de operación.

Análisis de postmortems sin culpa para extraer mejoras sistémicas.

Gestión de guardias, escalado y fatiga de alertas.

Preparación de ejercicios GameDay y simulaciones de fallo.

Integración de SRE con observabilidad, CI/CD y planificación de producto.

Ejercicio práctico: simular un incidente, usar observabilidad y redactar postmortem accionable.

Diseño de entornos locales, desarrollo, integración, staging, preproducción y producción.

Separación de configuración por entorno mediante variables, secrets, ConfigMaps, Helm values o herramientas cloud.

Gestión de feature flags para desacoplar despliegue y activación funcional.

Creación de entornos efímeros para pull requests o pruebas temporales.

Control de configuración para evitar diferencias invisibles entre entornos.

Gestión de migraciones de base de datos entre entornos.

Estrategias para datos de prueba seguros y representativos.

Automatización de creación y destrucción de entornos.

Documentación de dependencias y requisitos de cada entorno.

Ejercicio práctico: crear estrategia de entornos para una aplicación con CI/CD y Kubernetes.

Diseño de aplicaciones preparadas para despliegue continuo, escalado, observabilidad y recuperación ante fallos.

Revisión de patrones de microservicios, APIs, eventos, colas, workers, gateways y service discovery.

Gestión de compatibilidad entre versiones y despliegues independientes.

Diseño de health checks, timeouts, retries, circuit breakers y graceful shutdown.

Prevención de arquitecturas distribuidas innecesariamente complejas.

Gestión de contratos API y pruebas de contrato.

Observabilidad de dependencias entre servicios.

Control de configuración, secretos y escalado por servicio.

Preparación de aplicaciones para ejecución en Kubernetes.

Ejercicio práctico: revisar una arquitectura y proponer mejoras de operabilidad DevOps.

Integración de cambios de base de datos en pipelines de entrega.

Uso de herramientas de migración como Flyway, Liquibase o equivalentes.

Diseño de migraciones compatibles hacia atrás para evitar cortes durante despliegues.

Separación entre cambios de esquema, datos de referencia y datos productivos.

Gestión de backups, restore, pruebas de recuperación y entornos de datos.

Prevención de despliegues que rompen compatibilidad entre aplicación y base de datos.

Automatización de validaciones de migraciones en CI.

Control de permisos y credenciales de base de datos.

Observabilidad de rendimiento, queries lentas y errores de conexión.

Ejercicio práctico: diseñar estrategia de migración segura para una release.

Diferenciación entre runners gestionados y self-hosted runners.

Diseño de runners para cargas Linux, Windows, contenedores, Kubernetes y entornos aislados.

Gestión de permisos, redes, secretos y acceso a infraestructura desde pipelines.

Prevención de riesgos en pull requests de forks, acciones de terceros y scripts no revisados.

Escalado de runners según carga y tiempos de espera.

Uso de contenedores como entornos de ejecución reproducibles.

Limpieza de workspace, cachés y secretos tras ejecuciones.

Monitorización de runners, fallos, tiempos y consumo.

Diseño de pools por criticidad, entorno o equipo.

Ejercicio práctico: diseñar estrategia de runners segura para una organización.

Gestión de artefactos: paquetes, binarios, imágenes, charts, SBOMs y manifiestos.

Uso de registries de contenedores y repositorios de paquetes internos.

Versionado y promoción de artefactos entre entornos.

Firma de imágenes y verificación de procedencia cuando aplique.

Control de dependencias de terceros y acciones externas en pipelines.

Prevención de sustitución de artefactos, tags mutables y builds no reproducibles.

Gestión de retention policies y limpieza de artefactos antiguos.

Integración de SBOM y escaneo de vulnerabilidades en la cadena de suministro.

Documentación de trazabilidad desde commit hasta producción.

Ejercicio práctico: crear cadena de artefactos con imagen versionada, SBOM y despliegue.

Comprensión de platform engineering como evolución para ofrecer capacidades DevOps reutilizables y autoservicio interno.

Diseño de paved roads o golden paths para que equipos desplieguen con seguridad y menor fricción.

Creación de plantillas de repositorio, pipelines, Helm charts, Terraform modules y documentación estándar.

Definición de servicios internos: CI/CD, observabilidad, secretos, entornos, despliegue, logs, DNS, certificados y bases de datos.

Medición de developer experience, tiempo de onboarding y fricción operativa.

Uso de catálogos internos de servicios e IDPs como Backstage o alternativas.

Gobernanza de plataforma sin convertirse en cuello de botella.

Coordinación entre plataforma, seguridad, desarrollo y operaciones.

Priorización de capacidades según necesidades reales de los equipos.

Ejercicio práctico: diseñar un golden path DevOps para nuevos servicios.

Identificación de tareas repetitivas de operación que deben automatizarse: reinicios, escalados, backups, reportes, limpieza, provisión y diagnóstico.

Creación de scripts seguros y versionados para tareas operativas.

Uso de pipelines, cronjobs, runbooks automatizados y herramientas de orquestación.

Diseño de automatizaciones con aprobación humana para acciones sensibles.

Gestión de logs, alertas y evidencias de automatizaciones operativas.

Prevención de automatizaciones peligrosas sin límites ni observabilidad.

Medición de toil antes y después de automatizar.

Integración con herramientas de tickets, chatops y notificaciones.

Creación de catálogos internos de automatizaciones aprobadas.

Ejercicio práctico: automatizar una tarea operativa recurrente con control y trazabilidad.

Uso de canales de comunicación como Teams, Slack o Discord para coordinar despliegues, incidentes y operaciones.

Integración de pipelines, alertas y aprobaciones con herramientas de comunicación.

Diseño de comandos controlados para consultar estado, lanzar tareas o crear incidencias.

Prevención de operaciones inseguras desde chat sin permisos ni auditoría.

Creación de mensajes automáticos claros para despliegues, fallos, releases y alertas.

Gestión de incidentes desde canales dedicados con roles y timeline.

Integración con runbooks, dashboards y documentación.

Reducción de ruido en notificaciones operativas.

Mejora de transparencia entre desarrollo, sistemas y negocio.

Ejercicio práctico: diseñar flujo ChatOps para despliegues e incidentes.

Comprensión de las métricas DORA: deployment frequency, lead time for changes, change failure rate y time to restore service.

Uso de métricas como herramienta de mejora y no como mecanismo punitivo.

Recopilación de datos desde repositorios, pipelines, incidentes y herramientas de observabilidad.

Creación de dashboards de rendimiento de entrega y estabilidad.

Interpretación de métricas por contexto: tamaño de equipo, tipo de producto, criticidad y restricciones regulatorias.

Identificación de cuellos de botella en revisión, testing, despliegue, aprobación o recuperación.

Diseño de experimentos de mejora incremental.

Comunicación de resultados a dirección con foco en valor, riesgo y aprendizaje.

Alineación con el modelo de investigación DORA sobre capacidades que impulsan entrega y operaciones.

Ejercicio práctico: crear un cuadro de métricas DevOps y plan de mejora de 90 días.

Identificación de fuentes de coste en DevOps: runners, builds, storage, clusters, logs, métricas, tráfico, backups y entornos no usados.

Aplicación de tags, presupuestos, alertas y reporting de coste por equipo, producto o entorno.

Optimización de clusters, nodos, requests, autoscaling y recursos infrautilizados.

Control de costes de observabilidad por cardinalidad, retención y volumen.

Gestión de entornos efímeros para evitar gasto permanente.

Análisis de coste de pipelines largos, runners sobredimensionados o cachés mal gestionadas.

Integración de FinOps con decisiones de arquitectura y plataforma.

Creación de políticas de apagado, limpieza y retención.

Comunicación de coste técnico a equipos de producto.

Ejercicio práctico: auditar costes de un entorno DevOps y proponer ahorros.

Uso de IA generativa para acelerar documentación, scripts, análisis de logs, generación de pruebas, revisión de pipelines y troubleshooting.

Creación de prompts seguros para pedir ayuda sobre YAML, Dockerfiles, Terraform, Helm, Kubernetes o errores de CI/CD.

Revisión crítica de código o configuración generada por IA antes de aplicarla.

Uso de IA para resumir incidentes, preparar postmortems, analizar patrones de fallos y generar runbooks.

Integración responsable de IA en workflows DevOps sin exponer secretos, logs sensibles o infraestructura crítica.

Evaluación de riesgos de automatizar cambios con IA sin revisión humana.

Creación de asistentes internos con conocimiento de plataforma, documentación y procedimientos.

Uso de IA en developer experience para onboarding y resolución de dudas.

Control de calidad, seguridad y trazabilidad en outputs generados por IA.

Ejercicio práctico: usar IA para mejorar un pipeline defectuoso y validar manualmente cada cambio.

Evaluación de capacidades DevOps por dominios: cultura, Git, CI/CD, testing, IaC, contenedores, Kubernetes, seguridad, observabilidad y operación.

Identificación de gaps técnicos y organizativos que impiden entrega fiable.

Revisión de pipelines, repositorios, despliegues, permisos, secretos, dashboards y procesos de incidentes.

Priorización de mejoras por impacto, riesgo, esfuerzo y dependencia.

Creación de roadmap DevOps realista por fases.

Preparación de recomendaciones para dirección técnica y negocio.

Medición de evolución con métricas DORA, calidad, seguridad y fiabilidad.

Evitación de transformaciones demasiado ambiciosas sin base operativa.

Diseño de comunidades de práctica y estándares internos.

Ejercicio práctico: auditar una organización ficticia y proponer plan DevOps de 6 meses.

Diseño de una arquitectura DevOps completa para una aplicación empresarial con repositorio Git, pipeline CI/CD, contenedores, Kubernetes e infraestructura como código.

Creación de estrategia de ramas, pull requests, protección de rama y versionado.

Construcción de pipeline con build, tests, análisis de calidad, escaneo de seguridad, generación de imagen y publicación en registry.

Aprovisionamiento de infraestructura con Terraform y separación de entornos.

Despliegue en Kubernetes mediante Helm y estrategia de release controlada.

Incorporación de secretos, políticas, observabilidad, dashboards, alertas y runbooks.

Diseño de rollback, recuperación, postmortem e indicadores DORA.

Preparación de documentación técnica y guía de uso para equipos.

Evaluación de seguridad, costes, madurez y escalabilidad del diseño.

Presentación final defendiendo decisiones, riesgos, métricas, automatización, seguridad y plan de evolución.