Curso de GitOps (Git Operations)

Profundizar en el principio declarativo: describir el estado esperado en lugar de ejecutar pasos manuales.

Entender por qué el estado deseado debe estar versionado, revisado, inmutable y auditable.

Analizar el modelo pull-based frente al modelo push-based en despliegues.

Comprender la reconciliación continua como comparación entre estado deseado y estado real.

Relacionar GitOps con Kubernetes, controllers, operators y control loops.

Diferenciar configuración declarativa, scripts imperativos y automatizaciones procedurales.

Revisar cómo GitOps permite rollback mediante revert, commit anterior o promoción controlada.

Entender drift detection y por qué un cambio manual en el clúster debe detectarse y corregirse.

Identificar límites de GitOps cuando el sistema no puede expresarse bien de forma declarativa.

Taller: transformar un despliegue manual en definición declarativa versionada.

Comparar pipelines CI/CD que empujan cambios al clúster con agentes GitOps que tiran del estado desde Git.

Separar responsabilidades entre CI y CD: construir artefactos frente a reconciliar entornos.

Diseñar pipelines donde CI genera imágenes, ejecuta tests y actualiza referencias declarativas.

Evitar que el pipeline tenga permisos excesivos sobre producción.

Analizar ventajas del pull model en seguridad, auditoría y control de acceso.

Revisar cómo GitOps mejora trazabilidad del cambio, revisión y rollback.

Diferenciar despliegue de código, despliegue de configuración y promoción de versiones.

Identificar cuándo sigue siendo necesario un pipeline CI clásico.

Evitar duplicar lógica de despliegue entre pipeline y herramienta GitOps.

Taller: rediseñar un pipeline push clásico hacia un modelo CI + GitOps.

Revisar componentes de una arquitectura GitOps: repositorio, agente, clúster, manifests, secrets y observabilidad.

Entender cómo Argo CD o Flux monitorizan repositorios y aplican cambios al clúster.

Diseñar separación entre repositorios de aplicación, repositorios de configuración y repositorios de plataforma.

Organizar entornos: desarrollo, integración, staging, preproducción y producción.

Gestionar aplicaciones, namespaces, charts, overlays, políticas y configuración de cluster.

Definir ownership por equipo, aplicación, entorno y componente.

Diseñar modelo multi-cluster con repositorios compartidos o específicos por clúster.

Revisar dependencias entre componentes: CRDs, controllers, ingress, certificados, secrets y workloads.

Evitar arquitecturas GitOps centralizadas que se convierten en cuello de botella.

Taller: dibujar arquitectura GitOps para una plataforma Kubernetes empresarial.

Comparar mono-repo, multi-repo, repo por aplicación, repo por entorno y repo por plataforma.

Diseñar estructura de carpetas para aplicaciones, entornos, overlays, namespaces y componentes compartidos.

Separar código de aplicación de configuración de despliegue cuando el modelo organizativo lo requiere.

Definir convenciones de nombres para clústeres, entornos, aplicaciones, charts, overlays y recursos.

Gestionar cambios mediante ramas, pull requests, revisiones y protección de ramas.

Diseñar repositorios que permitan auditoría clara de quién cambió qué y por qué.

Evitar duplicación excesiva entre entornos usando Kustomize, Helm values o generación controlada.

Establecer propietarios de rutas mediante CODEOWNERS o mecanismos equivalentes.

Documentar decisiones del repositorio para que nuevos equipos puedan trabajar sin fricción.

Taller: crear estructura de repositorio GitOps para tres aplicaciones y tres entornos.

Revisar manifests Kubernetes como representación del estado deseado de una aplicación.

Gestionar deployments, services, ingress, configmaps, secrets, jobs y service accounts.

Definir recursos, límites, probes, afinidad, tolerations y estrategias de actualización.

Controlar labels y annotations para trazabilidad, observabilidad y ownership.

Evitar manifiestos incompletos que funcionan en pruebas pero fallan en producción.

Parametrizar diferencias entre entornos sin duplicar todo el YAML.

Validar manifests antes de hacer merge usando herramientas de linting y dry-run.

Detectar configuraciones peligrosas: imágenes latest, recursos sin límites o pods privilegiados.

Documentar qué recursos pertenecen a cada aplicación y qué recursos son de plataforma.

Taller: preparar manifests Kubernetes listos para GitOps con buenas prácticas.

Entender Helm como sistema de empaquetado y parametrización de aplicaciones Kubernetes.

Diseñar charts internos para aplicaciones corporativas.

Gestionar values por entorno, cliente, región, tenant o tipo de despliegue.

Controlar versiones de charts y versiones de aplicación.

Usar Helm desde Argo CD o Flux sin convertir los values en un caos difícil de auditar.

Validar charts con helm lint, helm template y políticas adicionales.

Gestionar dependencias de charts y repositorios Helm externos.

Evitar charts demasiado genéricos que ocultan decisiones críticas.

Controlar secretos, valores sensibles y overrides de producción.

Taller: desplegar aplicación mediante Helm con values diferenciados por entorno.

Entender Kustomize como herramienta para componer y transformar manifiestos sin plantillas complejas.

Diseñar bases reutilizables y overlays por entorno.

Aplicar patches para diferencias de recursos, réplicas, imágenes, ingress o configuración.

Gestionar configMapGenerator, secretGenerator y transformaciones.

Comparar Kustomize con Helm y decidir cuándo usar cada herramienta.

Evitar overlays difíciles de seguir por exceso de parches.

Mantener coherencia entre entornos sin copiar manifests completos.

Integrar Kustomize con Argo CD y Flux.

Revisar errores habituales: paths rotos, patches ambiguos o diferencias no documentadas.

Taller: crear base y overlays para desarrollo, staging y producción.

Revisar qué es Argo CD y cómo funciona como controlador GitOps para Kubernetes.

Entender conceptos: Application, Project, Repository, Sync, Health, OutOfSync y Desired State.

Instalar Argo CD en un clúster de laboratorio.

Conectar repositorios Git y configurar credenciales de acceso.

Crear aplicaciones desde manifests, Helm o Kustomize.

Explorar interfaz web, CLI y estado de sincronización.

Analizar diferencias entre estado deseado y estado real.

Ejecutar sync manual y revisar resultado.

Gestionar errores de sincronización, recursos bloqueados y dependencias.

Taller: desplegar una aplicación completa con Argo CD desde Git.

Usar AppProjects para segmentar equipos, repositorios, destinos y permisos.

Configurar sync manual, automático, prune y self-heal.

Entender riesgos de self-heal y auto-prune en entornos críticos.

Aplicar sync waves y hooks para ordenar despliegues con dependencias.

Diseñar patrón App of Apps para gestionar plataformas completas.

Usar ApplicationSet para escenarios multi-cluster, multi-entorno o generación dinámica.

Gestionar ignore differences cuando algunos campos son mutados por controladores externos.

Controlar RBAC, SSO, permisos y auditoría dentro de Argo CD.

Revisar métricas, logs y estado operativo de Argo CD.

Taller: crear modelo App of Apps para plataforma con varias aplicaciones.

Revisar qué es Flux y cómo se compone mediante controladores especializados.

Entender GitRepository, Kustomization, HelmRepository, HelmRelease y Image Automation.

Ejecutar bootstrap de Flux contra un repositorio Git.

Desplegar una aplicación usando Kustomize y reconciliación automática.

Gestionar Helm releases desde Flux.

Revisar reconciliación, eventos, estado y errores mediante CLI.

Usar intervalos, dependsOn, pruning y health checks.

Entender el enfoque modular del GitOps Toolkit.

Comparar operación diaria con Argo CD y criterios de elección.

Taller: desplegar aplicación con Flux usando Kustomize y Helm.

Automatizar actualización de imágenes mediante ImageRepository, ImagePolicy e ImageUpdateAutomation.

Controlar qué versiones pueden promocionarse mediante políticas semánticas.

Gestionar multi-tenancy con permisos, namespaces y repositorios separados.

Diseñar dependencias entre Kustomizations para ordenar instalación de componentes.

Gestionar secretos y credenciales de repositorios.

Revisar alertas y notificaciones de reconciliación.

Integrar Flux con plataformas cloud gestionadas y clústeres corporativos.

Controlar drift, errores de reconciliación y recursos eliminados.

Evitar automatizar versiones sin pruebas previas o controles de calidad.

Taller: configurar actualización automatizada de imagen con aprobación por Git.

Diseñar estrategia de promoción desde desarrollo a staging y producción.

Comparar promoción por ramas, carpetas, tags, releases, pull requests o repositorios.

Evitar que producción apunte a imágenes no probadas o a tags mutables.

Gestionar versiones de aplicación, chart, configuración y dependencias.

Usar pull requests como mecanismo de aprobación y trazabilidad.

Incorporar validaciones automáticas antes de promover.

Diseñar gates manuales solo donde aporten control real.

Crear rollback mediante revert o promoción de versión anterior.

Documentar cambios y evidencias de prueba antes de producción.

Taller: promocionar una aplicación desde staging a producción con GitOps.

Revisar rolling update, recreate, blue/green, canary y progressive delivery.

Integrar GitOps con Argo Rollouts, Flagger o herramientas equivalentes.

Diseñar despliegues canary basados en métricas, errores o tráfico.

Automatizar rollback cuando fallan health checks o SLOs.

Controlar migraciones de base de datos y cambios incompatibles.

Gestionar feature flags para desacoplar despliegue y activación funcional.

Revisar riesgos de auto-sync en producción con cambios sensibles.

Registrar evidencias de despliegue, versión, métrica y decisión.

Diseñar runbooks para fallos de sync, rollback y degradación.

Taller: desplegar versión canary y simular rollback por error.

Analizar por qué no deben almacenarse secretos en claro dentro de Git.

Comparar Sealed Secrets, External Secrets Operator, SOPS, Vault y secret managers cloud.

Diseñar flujo para cifrar, revisar, aplicar y rotar secretos.

Gestionar secretos por entorno, namespace, aplicación y tenant.

Controlar permisos de lectura, escritura, rotación y auditoría.

Evitar filtrar secretos en logs, pull requests, pipelines o manifests.

Automatizar sincronización de secretos desde gestores externos.

Diseñar estrategia de emergencia ante exposición accidental de secretos.

Integrar secretos con Helm, Kustomize, Argo CD y Flux.

Taller: gestionar secretos cifrados y sincronizados sin exponer valores reales.

Diseñar RBAC de Kubernetes alineado con equipos, namespaces, aplicaciones y entornos.

Controlar permisos de Argo CD, Flux, service accounts y pipelines.

Aplicar políticas como código con OPA Gatekeeper, Kyverno, Conftest o herramientas equivalentes.

Validar imágenes, recursos, privilegios, capabilities, hostPath, ingress, etiquetas y configuración.

Bloquear despliegues inseguros antes de llegar al clúster.

Integrar escaneo de manifests, Helm charts, contenedores y dependencias en CI.

Gestionar excepciones documentadas y temporales.

Auditar cambios aplicados desde Git y detectar modificaciones manuales.

Evitar que un controlador GitOps tenga permisos globales innecesarios.

Taller: crear política que impida despliegues inseguros y validarla en pull request.

Separar pipeline de build/test del pipeline de entrega declarativa.

Construir imágenes inmutables con tags trazables basados en commit o versión.

Publicar artefactos en registry con escaneo y firma.

Actualizar manifiestos, Helm values o Kustomize images mediante automatización controlada.

Abrir pull requests automáticos para promover versiones.

Integrar GitHub Actions, GitLab CI, Jenkins, Azure DevOps u otras herramientas.

Validar manifests antes del merge con lint, tests y políticas.

Evitar que CI tenga acceso directo a producción si GitOps puede reconciliar desde el clúster.

Registrar trazabilidad entre commit de código, imagen, manifest y despliegue.

Taller: construir pipeline CI que actualiza repositorio GitOps y dispara reconciliación.

Monitorizar estado de aplicaciones: Synced, OutOfSync, Healthy, Degraded, Suspended o Failed.

Crear dashboards de sincronización, errores, drift, reconciliaciones y tiempo de despliegue.

Revisar logs de Argo CD, Flux, controllers y eventos Kubernetes.

Alertar por aplicaciones degradadas, sync fallido, drift persistente o reconciliación bloqueada.

Relacionar cambios en Git con incidentes, métricas y trazas de aplicación.

Medir lead time, frecuencia de despliegue, fallos de cambio y tiempo de recuperación.

Crear auditoría de despliegues y cambios por equipo, entorno y aplicación.

Integrar notificaciones con Slack, Teams, email, PagerDuty o ITSM.

Evitar alertas ruidosas por estados transitorios o sincronizaciones esperadas.

Taller: diseñar dashboard de salud GitOps para operación diaria.

Entender qué es drift y por qué rompe la confianza en Git como fuente de verdad.

Detectar cambios manuales realizados con kubectl, consola cloud o scripts fuera de Git.

Analizar diferencias entre estado vivo y estado deseado.

Configurar self-heal cuando procede corregir drift automáticamente.

Definir cuándo un cambio manual puede ser aceptado temporalmente y cómo regularizarlo en Git.

Evitar drift causado por controladores que modifican campos gestionados.

Usar ignore differences con criterio para no ocultar problemas reales.

Auditar cambios fuera de Git y revisar permisos que los permiten.

Crear proceso de emergencia para hotfixes sin destruir gobernanza.

Taller: provocar drift controlado, detectarlo y corregirlo mediante GitOps.

Diseñar GitOps para múltiples clústeres, regiones, nubes o sedes.

Separar entornos críticos de entornos de desarrollo y pruebas.

Gestionar tenants, equipos, namespaces y permisos en plataformas compartidas.

Diseñar repositorios comunes y específicos por clúster.

Usar ApplicationSet o Flux Kustomizations para despliegues repetibles.

Gestionar diferencias por región, capacidad, cumplimiento o cliente.

Evitar copiar configuración de forma incontrolada entre clústeres.

Controlar despliegues globales, parciales, progresivos o por oleadas.

Diseñar observabilidad centralizada de estado GitOps multi-cluster.

Taller: desplegar la misma aplicación en varios entornos con diferencias controladas.

Gestionar recursos de plataforma mediante GitOps: ingress, cert-manager, service mesh, monitoring y policies.

Integrar IaC con GitOps para separar infraestructura cloud y recursos Kubernetes.

Coordinar Terraform/OpenTofu con Argo CD o Flux sin solapamientos peligrosos.

Gestionar CRDs, operators y componentes base del clúster.

Diseñar bootstrap de clúster con controladores GitOps y configuración inicial.

Automatizar instalación de add-ons corporativos.

Controlar versiones de componentes de plataforma y dependencias.

Evitar eliminar recursos críticos por prune mal configurado.

Documentar ownership de recursos compartidos.

Taller: diseñar bootstrap GitOps de un clúster desde cero.

Diseñar despliegue GitOps de microservicios independientes.

Gestionar configuración por servicio, entorno, versión y dependencia.

Coordinar cambios entre APIs, workers, colas, jobs y bases de datos.

Aplicar health checks, probes, recursos y estrategias de despliegue.

Gestionar dependencias entre servicios sin crear despliegues frágiles.

Organizar repositorios para equipos con múltiples servicios.

Integrar secrets, configmaps, ingress y observabilidad por aplicación.

Trazar qué versión está desplegada en cada entorno.

Preparar rollback por servicio sin afectar toda la plataforma.

Taller: desplegar arquitectura de microservicios mediante GitOps.

Aplicar GitOps a pipelines de datos, jobs, notebooks productivos, servicios ML y modelos.

Gestionar manifests de entrenamiento, inferencia, batch jobs y servicios de features.

Versionar configuración de modelos, recursos, endpoints, escalado y secretos.

Controlar promoción de modelos entre entornos.

Integrar validaciones de calidad, seguridad y coste antes de despliegue.

Gestionar RAG, bases vectoriales, workers de ingesta y servicios de embeddings con enfoque declarativo.

Observar latencia, coste, errores, consumo de GPU/CPU y calidad de inferencia.

Evitar que artefactos pesados o datasets se almacenen directamente en Git.

Separar GitOps de gestión de artefactos, modelos y datasets.

Taller: diseñar GitOps para servicio de inferencia IA y pipeline de datos.

Usar Git como fuente para reconstruir estado deseado de aplicaciones y plataforma.

Diseñar bootstrap de clúster desde cero tras fallo grave.

Separar configuración GitOps de datos persistentes, backups y secretos.

Planificar restauración de CRDs, operators, namespaces, workloads y configuración.

Validar que los repositorios contienen suficiente información para reconstruir entornos.

Gestionar recuperación de secretos y credenciales desde gestores seguros.

Probar restauraciones periódicas en clústeres de laboratorio.

Documentar RTO, RPO y dependencias de recuperación.

Evitar falsa sensación de seguridad si los datos no están respaldados.

Taller: diseñar plan de recuperación GitOps para plataforma Kubernetes.

Definir ownership por aplicación, repositorio, entorno, clúster, chart, pipeline y política.

Crear normas de ramas, pull requests, aprobaciones, revisiones y merges.

Definir qué cambios requieren aprobación de plataforma, seguridad, negocio o responsable técnico.

Establecer convenciones de naming, etiquetas, annotations y documentación.

Crear catálogo de aplicaciones y dependencias con estado GitOps.

Revisar periódicamente repositorios, aplicaciones abandonadas, recursos huérfanos y permisos.

Gestionar excepciones, hotfixes, cambios urgentes y ventanas de mantenimiento.

Medir adopción: aplicaciones GitOps, cambios por PR, drift, rollback y errores.

Crear comité ligero de plataforma para evolucionar estándares.

Taller: diseñar modelo de gobierno GitOps para una empresa multi-equipo.

Usar GitOps solo como botón de despliegue sin cambiar el modelo operativo.

Guardar secretos en claro en repositorios.

Dar permisos excesivos al controlador GitOps.

Mezclar código, configuración, datos, secretos y artefactos sin criterio.

Sincronizar automáticamente producción sin pruebas, revisiones ni gates.

Crear repositorios tan complejos que nadie entiende cómo promover cambios.

Ignorar drift porque “la aplicación funciona”.

Usar tags mutables como latest en producción.

Instalar herramientas GitOps sin observabilidad ni alerting.

Taller: analizar antipatrones y corregirlos con controles concretos.

Evaluar madurez actual de Kubernetes, CI/CD, Git, seguridad, observabilidad y cultura de revisión.

Seleccionar primer caso piloto con bajo riesgo y valor claro.

Definir estándares mínimos antes de incorporar aplicaciones críticas.

Diseñar repositorios, permisos, estrategia de entornos y herramientas base.

Formar a desarrolladores, plataforma, seguridad y responsables de operación.

Migrar aplicaciones progresivamente desde despliegue manual o pipeline push.

Medir beneficios: reducción de drift, trazabilidad, rollback, frecuencia de despliegue y errores.

Ajustar el modelo según feedback de equipos y problemas reales.

Escalar a multi-cluster, plataforma, políticas, observabilidad y autoservicio.

Taller: construir roadmap GitOps a 30, 60, 90 y 180 días.

Definir una organización con clústeres Kubernetes, aplicaciones, equipos, entornos, pipelines y requisitos de seguridad.

Diseñar arquitectura GitOps con repositorios, ramas, carpetas, entornos, herramientas y ownership.

Crear manifiestos base con Kubernetes, Helm o Kustomize para una aplicación corporativa.

Configurar conceptualmente Argo CD o Flux para reconciliación, sincronización, drift detection y rollback.

Diseñar pipeline CI que construye imagen, ejecuta pruebas, escanea seguridad y actualiza repo GitOps.

Preparar estrategia de promoción entre desarrollo, staging y producción mediante pull requests.

Incorporar gestión de secretos, RBAC, políticas como código y validaciones previas al merge.

Definir observabilidad, alertas, dashboards, auditoría, métricas DORA y seguimiento de sincronización.

Crear modelo de gobierno con naming, permisos, revisiones, hotfixes, owners, excepciones y roadmap.

Presentar el modelo final justificando arquitectura, herramientas, seguridad, riesgos, operación y plan de adopción.