Curso de Podman

Entender la arquitectura daemonless y cómo Podman lanza contenedores sin servicio central permanente.

Revisar el papel de libpod en la gestión de contenedores, pods, imágenes y volúmenes.

Diferenciar runtime OCI, imagen OCI, contenedor, pod, capa, volumen, red y namespace.

Entender cómo Podman interactúa con `conmon`, runtimes OCI y almacenamiento local.

Analizar diferencias entre modo rootful y rootless en rutas, permisos, red y storage.

Revisar dónde se guardan imágenes, contenedores, volúmenes y configuración según usuario.

Entender el impacto operativo de no tener daemon central en seguridad, recursos y troubleshooting.

Identificar componentes del ecosistema: Podman, Buildah, Skopeo, CRI-O, registries y systemd.

Evitar trasladar hábitos de Docker sin revisar diferencias reales de arquitectura.

Taller: inspeccionar paths, storage, procesos y metadatos de un contenedor Podman.

Instalar Podman en distribuciones Linux habituales y validar paquetes requeridos.

Configurar registries, policy, storage, cgroups, red y opciones globales.

Preparar configuración por usuario y configuración del sistema.

Revisar diferencias de instalación en servidores, estaciones de desarrollo, WSL, macOS y Windows con máquina virtual.

Configurar entorno rootless con subuid, subgid y requisitos de user namespaces.

Validar compatibilidad con systemd, cgroups v2, SELinux y firewall.

Crear estándares de instalación para equipos técnicos.

Evitar versiones desalineadas entre desarrollo, CI y servidores.

Documentar configuración base y comandos de verificación.

Taller: preparar una máquina Linux lista para ejecutar Podman rootless y rootful.

Ejecutar contenedores con `podman run` usando nombre, imagen, comandos, puertos y variables.

Listar contenedores activos e históricos con filtros útiles.

Inspeccionar configuración, mounts, red, estado, proceso y metadatos.

Detener, iniciar, reiniciar, pausar, matar y eliminar contenedores.

Usar `exec` para diagnóstico dentro del contenedor sin convertirlo en práctica permanente.

Revisar logs y salida estándar con criterios de operación.

Copiar archivos de forma controlada entre host y contenedor.

Gestionar nombres, labels y convenciones internas.

Evitar contenedores huérfanos, imágenes sin uso y recursos acumulados.

Taller: operar una aplicación contenerizada completa desde comandos básicos.

Entender qué es una imagen, capa, manifest, tag, digest y arquitectura.

Descargar imágenes desde registries públicos o privados.

Inspeccionar imágenes con metadatos, labels, historial, entrypoint, cmd y configuración.

Etiquetar imágenes de forma coherente para desarrollo, staging, producción y releases.

Eliminar imágenes locales y limpiar almacenamiento sin borrar recursos necesarios.

Diferenciar tag mutable y digest inmutable para despliegues reproducibles.

Validar arquitectura de imagen para x86_64, arm64 u otras plataformas.

Crear política de uso de imágenes base permitidas.

Evitar desplegar imágenes por `latest` en entornos productivos.

Taller: auditar una imagen, etiquetarla correctamente y preparar promoción a registry.

Crear Containerfiles claros, mantenibles y seguros.

Diferenciar `FROM`, `RUN`, `COPY`, `ADD`, `ENV`, `ARG`, `USER`, `WORKDIR`, `EXPOSE`, `ENTRYPOINT` y `CMD`.

Diseñar builds multi-stage para reducir tamaño y superficie de ataque.

Aplicar buenas prácticas de caché, orden de capas y minimización de dependencias.

Evitar ejecutar aplicaciones como root dentro del contenedor si no es necesario.

Crear imágenes reproducibles con versiones fijadas.

Gestionar secrets de build sin dejarlos en capas.

Añadir labels OCI para trazabilidad.

Probar imagen localmente antes de publicar.

Taller: crear imagen optimizada de una API backend con build multi-stage.

Entender cuándo usar `podman build` y cuándo usar Buildah directamente.

Crear imágenes mediante flujos scriptables sin depender de un Docker daemon.

Manipular contenedores de build, capas, commits y montaje de rootfs.

Diseñar builds más controlados para pipelines CI/CD.

Separar build de runtime con usuarios, permisos y dependencias mínimas.

Firmar o etiquetar imágenes tras construcción cuando aplica.

Evitar scripts de build difíciles de reproducir.

Integrar Buildah con registries y escaneo.

Comparar tiempos y trazabilidad frente a builds tradicionales.

Taller: construir imagen con Buildah y publicarla en un registry de laboratorio.

Inspeccionar imágenes remotas sin descargarlas al host.

Copiar imágenes entre registries, namespaces, formatos o entornos.

Sincronizar imágenes para entornos aislados o air-gapped.

Validar digest, arquitectura, labels y metadatos antes de promoción.

Evitar promociones basadas solo en tags mutables.

Usar Skopeo en pipelines de seguridad y release.

Diseñar flujo de dev a staging y producción con trazabilidad.

Revisar políticas de firma y verificación cuando aplica.

Documentar origen, destino, digest y fecha de copia.

Taller: promover imagen entre dos registries usando Skopeo y validación por digest.

Autenticarse contra registries públicos y privados con credenciales seguras.

Configurar búsqueda de imágenes y registries permitidos.

Gestionar credenciales por usuario, entorno y pipeline.

Evitar credenciales en scripts, repositorios, logs o imágenes.

Definir política de pull/push para imágenes corporativas.

Usar mirrors, registries internos o cachés cuando la organización lo requiere.

Controlar nombres, namespaces, tags, digest y retención.

Gestionar errores de autenticación, certificados, proxy y TLS.

Auditar qué imágenes se descargan y desde dónde.

Taller: configurar registry privado y publicar una imagen versionada.

Entender qué significa ejecutar contenedores sin privilegios root en el host.

Configurar subuid y subgid para usuarios rootless.

Revisar limitaciones de puertos privilegiados, red, mounts, cgroups y capacidades.

Analizar ventajas de seguridad al reducir privilegios.

Diseñar servicios rootless para aplicaciones corporativas.

Gestionar rutas de storage y configuración por usuario.

Evitar confundir root dentro del contenedor con root real del host.

Diagnosticar errores típicos de rootless.

Comparar rootless y rootful según caso de uso.

Taller: desplegar una aplicación rootless con volumen, puerto y logs.

Entender cómo user namespaces mapean usuarios del contenedor al host.

Revisar implicaciones de propietarios de archivos en volúmenes.

Gestionar UID/GID en imágenes y contenedores.

Solucionar problemas de permisos en bind mounts rootless.

Aplicar `:U`, `:Z` y opciones de volumen según caso.

Evitar montar directorios del host sin entender propietario y seguridad.

Diseñar imágenes que funcionan correctamente con usuarios no root.

Preparar estrategia para logs, uploads, datos persistentes y cachés.

Documentar UID/GID esperados por aplicación.

Taller: corregir errores de permisos en volumen rootless con SELinux activo.

Aplicar principio de mínimo privilegio en usuarios, capabilities y mounts.

Ejecutar contenedores con usuario no root y filesystem de solo lectura cuando procede.

Limitar capabilities, dispositivos, sysctls y privilegios.

Evitar `--privileged` salvo casos muy justificados y documentados.

Usar labels, seccomp, AppArmor o SELinux según entorno.

Revisar exposición de sockets, certificados, secretos y rutas sensibles.

Controlar variables de entorno con información confidencial.

Analizar superficie de ataque de imágenes y servicios.

Crear checklist de hardening de contenedores Podman.

Taller: endurecer un contenedor vulnerable y documentar mitigaciones.

Entender cómo SELinux protege accesos de contenedores a recursos del host.

Interpretar errores de permisos relacionados con labels.

Usar opciones `:z` y `:Z` en volúmenes con criterio.

Evitar desactivar SELinux como solución rápida.

Revisar contextos, booleans y logs de auditoría cuando hay bloqueos.

Diferenciar problemas de UID/GID y problemas de etiqueta SELinux.

Diseñar rutas persistentes compatibles con SELinux.

Documentar decisiones de etiquetado para operación.

Crear procedimientos de troubleshooting.

Taller: resolver acceso denegado a volumen por SELinux sin relajar seguridad global.

Entender redes bridge, host, none, pasta, slirp4netns y configuraciones rootless.

Exponer puertos y mapearlos de forma controlada.

Crear redes personalizadas para separar servicios.

Resolver nombres entre contenedores dentro de una misma red.

Analizar diferencias de red en rootless frente a rootful.

Evitar publicar puertos innecesarios al host.

Configurar DNS, aliases y comunicación entre servicios.

Diagnosticar fallos de conectividad, firewall, escucha y resolución.

Documentar topología de red por aplicación.

Taller: desplegar API, base de datos y worker en red Podman controlada.

Diferenciar volúmenes gestionados por Podman y bind mounts del host.

Crear, inspeccionar, usar, respaldar y eliminar volúmenes.

Diseñar persistencia para bases de datos, uploads, configuración y logs.

Evitar almacenar datos críticos solo en capas efímeras del contenedor.

Gestionar permisos y SELinux en mounts.

Separar datos persistentes, configuración, secretos y artefactos temporales.

Crear estrategia de backup y restauración de volúmenes.

Usar mounts de solo lectura cuando procede.

Documentar rutas, propietarios, retención y responsabilidades.

Taller: desplegar PostgreSQL o servicio equivalente con volumen persistente y backup.

Gestionar variables de entorno sin exponer información sensible.

Usar secrets de Podman cuando encajan en el caso.

Separar configuración por entorno: desarrollo, staging y producción.

Evitar meter credenciales en imágenes, Containerfiles o repositorios.

Montar archivos de configuración de forma controlada.

Rotar secretos y credenciales sin reconstruir imágenes innecesariamente.

Validar configuración al arrancar la aplicación.

Documentar contratos de configuración de cada contenedor.

Integrar secrets con pipelines o gestores corporativos cuando aplica.

Taller: sustituir credenciales en variables por secrets y mounts controlados.

Entender el concepto de pod y su relación con Kubernetes.

Crear pods con contenedores que comparten red, namespace y ciclo de vida.

Diseñar pods para patrones sidecar, proxy, logger, init auxiliar o servicios acoplados.

Exponer puertos a nivel de pod.

Gestionar logs y estado de contenedores dentro del pod.

Evitar meter en un pod servicios que deben escalar o versionarse por separado.

Comparar varios contenedores independientes frente a pod multi-contenedor.

Inspeccionar infraestructura del pod y contenedores asociados.

Crear scripts de operación de pods.

Taller: desplegar pod con API, sidecar y contenedor auxiliar.

Generar YAML de Kubernetes desde pods o contenedores existentes.

Ejecutar workloads locales con `podman kube play`.

Detener y limpiar recursos creados desde YAML.

Entender qué partes del YAML Kubernetes son compatibles con Podman y cuáles no.

Usar YAML para documentar y reproducir despliegues locales.

Preparar transición conceptual desde Podman hacia Kubernetes.

Evitar asumir que todo YAML de un cluster funcionará igual en Podman.

Gestionar volúmenes, puertos, variables y pods desde manifiestos.

Integrar YAML en repositorio Git.

Taller: convertir pod Podman en YAML y recrearlo con `podman kube play`.

Entender Quadlet como forma declarativa de gestionar contenedores, pods, volúmenes, redes e imágenes con systemd.

Crear archivos `.container`, `.pod`, `.volume`, `.network` e `.image`.

Diferenciar unidades de sistema y unidades de usuario.

Definir dependencias, reinicio, variables, volúmenes, puertos y redes desde Quadlet.

Evitar scripts manuales de arranque cuando systemd puede gestionar el ciclo de vida.

Usar `systemctl --user` para servicios rootless.

Validar generación de unidades systemd a partir de Quadlet.

Documentar ubicación de archivos y convención de nombres.

Preparar servicios reproducibles y versionables.

Taller: desplegar aplicación rootless con Quadlet y systemd de usuario.

Ejecutar contenedores como servicios gestionados por systemd.

Configurar reinicios automáticos, orden de arranque, dependencias y límites.

Gestionar servicios rootful y rootless.

Usar `loginctl enable-linger` cuando procede para servicios de usuario.

Consultar estado, logs, errores y reinicios con `systemctl` y `journalctl`.

Evitar ejecutar servicios productivos con comandos manuales no persistentes.

Preparar unidades robustas para mantenimiento y soporte.

Integrar healthchecks y políticas de reinicio.

Documentar runbooks de operación.

Taller: convertir contenedor manual en servicio systemd con reinicio automático.

Definir healthchecks adecuados para aplicaciones contenerizadas.

Consultar logs de contenedores, pods y servicios systemd.

Diferenciar fallo de aplicación, fallo de contenedor, fallo de red y fallo de host.

Usar `podman inspect`, `podman events`, `podman top`, `podman stats` y herramientas del sistema.

Evitar diagnosticar desde dentro del contenedor sin revisar host, mounts y red.

Crear mensajes de error útiles en aplicaciones.

Centralizar logs cuando el entorno lo requiere.

Diseñar alertas básicas para servicios gestionados.

Preparar checklist de troubleshooting por capas.

Taller: resolver una incidencia completa de contenedor que reinicia en bucle.

Entender auto-update de Podman para contenedores gestionados.

Configurar políticas de actualización con labels o Quadlet.

Diferenciar actualización por tag frente a digest y sus riesgos.

Evitar actualizaciones automáticas sin pruebas, rollback y control de cambios.

Diseñar ventanas de mantenimiento y estrategia de promoción de imágenes.

Integrar actualización con systemd timers cuando procede.

Registrar versión anterior, nueva versión, resultado y errores.

Preparar rollback ante fallo de imagen nueva.

Auditar servicios que se actualizan automáticamente.

Taller: configurar auto-update controlado con imagen versionada y rollback documentado.

Comparar comandos Docker y Podman en operaciones habituales.

Usar alias o compatibilidad CLI con criterio.

Revisar diferencias en daemon, rootless, networking, compose, volumes, sockets y permisos.

Migrar Dockerfiles a Containerfiles sin cambios innecesarios.

Evaluar compatibilidad de scripts, pipelines, Makefiles y herramientas.

Detectar dependencias del Docker socket y sustituirlas por patrones seguros.

Revisar equivalencias y límites de Docker Compose frente a Podman Compose o Kubernetes YAML.

Crear plan de migración progresiva por equipos y aplicaciones.

Medir impacto en seguridad, operación y soporte.

Taller: migrar una aplicación Docker local a Podman con ajustes documentados.

Revisar cuándo Podman Desktop aporta valor a desarrolladores y equipos no administradores.

Gestionar máquinas Podman en Windows o macOS cuando no se trabaja en Linux nativo.

Explorar contenedores, imágenes, pods, volúmenes y registros desde interfaz gráfica.

Integrar experiencia local con Kubernetes y extensiones cuando aplica.

Evitar depender de una GUI para procedimientos productivos no documentados.

Crear guías de onboarding para nuevos desarrolladores.

Diagnosticar diferencias entre Linux nativo y máquinas virtuales de escritorio.

Configurar recursos, almacenamiento y redes de la máquina Podman.

Validar compatibilidad con herramientas de desarrollo.

Taller: preparar entorno de desarrollo con Podman Desktop y aplicación backend.

Analizar opciones para aplicaciones multicontenedor: pods, scripts, Quadlet, Kubernetes YAML y herramientas Compose.

Entender cuándo conviene usar pods frente a varios contenedores independientes.

Revisar compatibilidad y límites de `podman-compose` o alternativas similares.

Evitar trasladar `docker-compose.yml` sin validar comportamiento real.

Diseñar entornos locales reproducibles para desarrolladores.

Separar configuración de desarrollo, test e integración.

Gestionar redes, volúmenes y variables en stacks multicontenedor.

Preparar scripts de arranque y limpieza.

Documentar decisiones de orquestación local.

Taller: levantar stack de API, base de datos, cache y worker con enfoque Podman.

Diseñar pipeline para construir, probar, etiquetar, escanear y publicar imágenes.

Ejecutar builds rootless en runners compatibles.

Usar Buildah para construcción sin daemon y Skopeo para promoción.

Evitar pipelines que requieren Docker privileged sin justificación.

Gestionar cache de build, credenciales de registry y secretos de pipeline.

Publicar imágenes con tags y digests trazables.

Ejecutar pruebas de contenedor antes de push.

Generar SBOM o metadatos cuando la organización lo requiere.

Integrar escaneo de vulnerabilidades y políticas de aprobación.

Taller: crear pipeline CI/CD completo para imagen OCI con Podman/Buildah/Skopeo.

Analizar riesgos de imágenes base, dependencias, capas y registries no confiables.

Integrar escaneo de vulnerabilidades en build y promoción.

Revisar CVEs, severidad, fix available y falsos positivos.

Firmar imágenes o verificar procedencia según política corporativa.

Usar digests para despliegues reproducibles.

Generar y conservar metadatos de build.

Evitar desplegar imágenes sin trazabilidad.

Crear política de imágenes permitidas y bloqueadas.

Documentar excepciones de seguridad.

Taller: escanear, evaluar y promover una imagen con criterios de seguridad.

Configurar Podman en entornos con proxy corporativo.

Gestionar certificados internos y registries con TLS privado.

Diagnosticar errores de pull/push por proxy, CA o DNS.

Configurar variables y archivos de confianza sin relajar seguridad global.

Evitar desactivar TLS verification como solución permanente.

Documentar configuración de red corporativa para desarrolladores y servidores.

Revisar firewalls, puertos y rutas permitidas.

Preparar imágenes base disponibles en registry interno.

Coordinar con IT, seguridad y redes.

Taller: resolver acceso a registry corporativo con CA interna y proxy.

Limitar CPU, memoria, procesos y recursos de contenedores.

Medir consumo con `podman stats`, herramientas Linux y systemd.

Evitar contenedores sin límites en servidores compartidos.

Ajustar ulimits, memoria, swap y prioridades cuando procede.

Analizar impacto de storage driver, I/O, volúmenes y logging.

Optimizar imágenes para arranque rápido y menor tamaño.

Detectar fugas de memoria o consumo anómalo.

Documentar dimensionamiento por servicio.

Preparar pruebas de carga básicas.

Taller: limitar recursos de una aplicación y analizar comportamiento bajo carga.

Ejecutar bases de datos en contenedores para desarrollo, pruebas o servicios controlados.

Diseñar volúmenes persistentes, backups, restores y actualizaciones.

Evitar tratar servicios stateful productivos como contenedores efímeros sin estrategia.

Gestionar variables, secrets, usuarios, puertos y healthchecks.

Aplicar políticas de seguridad en mounts y usuarios.

Crear scripts de inicialización reproducibles.

Separar datos de configuración y logs.

Evaluar cuándo conviene usar servicio gestionado o instalación nativa.

Documentar procedimientos de recuperación.

Taller: desplegar PostgreSQL, MariaDB o Redis con Podman y backup restaurable.

Crear entornos de desarrollo consistentes para equipos.

Contenerizar dependencias como bases de datos, colas, caches y servicios externos.

Evitar que cada desarrollador instale manualmente versiones distintas.

Preparar scripts `make`, shell o task runners para operaciones comunes.

Gestionar datos de prueba y seeds reproducibles.

Usar pods o redes para simular stacks locales.

Documentar onboarding técnico con Podman.

Controlar diferencias entre entorno local, CI y producción.

Evitar credenciales reales en entornos locales.

Taller: crear entorno local completo para una aplicación backend con dependencias.

Desplegar aplicaciones contenerizadas en servidores sin Kubernetes.

Gestionar servicios con Quadlet/systemd, logs, reinicios, healthchecks y actualizaciones.

Diseñar estructura de directorios para configs, datos, secrets, states y scripts.

Separar usuarios de servicio y permisos.

Publicar puertos detrás de reverse proxy cuando procede.

Integrar con firewall, TLS, backups y monitorización.

Evitar despliegues manuales sin trazabilidad.

Crear runbook de despliegue, rollback y diagnóstico.

Comparar despliegue Podman en servidor frente a Kubernetes.

Taller: desplegar API productiva simulada con Podman, systemd y reverse proxy.

Recoger métricas de contenedores, pods, servicios systemd y host.

Diseñar logs estructurados y centralización cuando aplica.

Integrar healthchecks y alertas operativas.

Monitorizar uso de CPU, memoria, disco, red, reinicios y errores.

Evitar depender solo de “el contenedor está running”.

Crear dashboards básicos para aplicaciones Podman.

Relacionar eventos de Podman con incidencias de aplicación.

Definir SLOs simples para servicios contenerizados.

Preparar procedimientos de respuesta.

Taller: crear panel de salud para stack Podman con logs y métricas.

Identificar qué debe respaldarse: volúmenes, configs, Quadlets, scripts, datos y registry.

Crear backups de volúmenes y bases de datos con procedimientos verificables.

Evitar backups de directorios incorrectos o con datos inconsistentes.

Probar restauración en entorno aislado.

Documentar RPO, RTO y responsables.

Gestionar snapshots, dumps y copias externas según criticidad.

Incluir imágenes y digests necesarios para reconstruir servicio.

Preparar recuperación de servicio systemd/Quadlet.

Automatizar pruebas de restore cuando procede.

Taller: restaurar servicio Podman stateful desde backup y validar funcionamiento.

Diagnosticar fallos de arranque, permisos, red, DNS, SELinux, volúmenes, imagen y aplicación.

Usar `podman inspect`, `logs`, `events`, `exec`, `mount`, `unshare` y herramientas Linux.

Interpretar errores rootless y diferencias frente a rootful.

Resolver problemas de puertos ocupados, procesos zombie, locks y almacenamiento corrupto.

Diagnosticar fallos de registry, certificados, proxy y autenticación.

Analizar contenedores que reinician por systemd.

Evitar soluciones destructivas como prune masivo sin entender impacto.

Crear árboles de decisión para incidencias recurrentes.

Documentar causa raíz y acción preventiva.

Taller: resolver laboratorio de incidencias Podman preparado con fallos múltiples.

Crear baseline de seguridad para hosts que ejecutan contenedores.

Separar usuarios, grupos, permisos, directorios y servicios.

Revisar actualizaciones de sistema, Podman, runtimes, kernels y dependencias.

Limitar exposición de puertos y servicios.

Aplicar firewall, SELinux, auditoría y logging.

Controlar imágenes permitidas, registries y políticas de firma.

Evitar sockets expuestos y elevación de privilegios.

Revisar backups, secrets y accesos SSH.

Crear checklist de puesta en producción.

Taller: auditar un servidor Podman y aplicar hardening priorizado.

Automatizar instalación, configuración y despliegue de Podman con Ansible o scripts controlados.

Crear tareas para paquetes, usuarios, registries, directorios, Quadlets y servicios.

Evitar automatización frágil basada en comandos manuales no idempotentes.

Gestionar variables por entorno y secretos con herramientas corporativas.

Desplegar servicios mediante archivos declarativos.

Verificar estado tras la automatización.

Crear rollback y validaciones.

Documentar playbooks y scripts.

Integrar automatización con CI/CD.

Taller: crear playbook para desplegar servicio Podman rootless con Quadlet.

Entender qué conceptos comparten Podman y Kubernetes: imágenes, pods, YAML, probes, volumes y ports.

Diferenciar operación local o en servidor frente a orquestación en cluster.

Usar Podman para validar imágenes antes de desplegarlas en Kubernetes.

Generar YAML como documentación o punto de partida.

Evitar asumir equivalencia completa entre Podman y Kubernetes.

Diseñar aplicaciones más preparadas para orquestación futura.

Revisar patrones de sidecar, init, config, secrets y healthchecks.

Usar Podman en workflows de desarrolladores Kubernetes.

Preparar transición gradual desde servidor Podman a cluster.

Taller: convertir una app Podman en manifiesto base para Kubernetes.

Crear entorno local de desarrollo para backend con API, base de datos y cache.

Desplegar servicio rootless en servidor Linux con Quadlet y systemd.

Construir imagen segura con usuario no root y multi-stage build.

Publicar imagen en registry interno y promoverla por digest.

Crear pod con sidecar y comunicación interna.

Configurar volumen persistente con SELinux y permisos correctos.

Crear pipeline CI/CD con Buildah y Skopeo.

Ejecutar `podman kube play` con YAML versionado.

Monitorizar logs, healthchecks y recursos del servicio.

Taller: seleccionar tres casos y resolverlos con enfoque de producción.

Usar `--privileged` para resolver cualquier problema de permisos.

Desactivar SELinux en lugar de corregir labels y mounts.

Desplegar imágenes `latest` sin digest, pruebas ni rollback.

Ejecutar contenedores productivos con comandos manuales no persistentes.

Montar directorios sensibles del host sin control.

Ignorar diferencias rootless/rootful hasta que fallan los servicios.

Crear pipelines dependientes de Docker daemon cuando no es necesario.

No procesar logs, healthchecks ni métricas de servicios críticos.

Mezclar datos persistentes con capas efímeras.

Taller: auditar una plataforma Podman mal diseñada y corregirla.

Evaluar madurez actual: Docker, Linux, CI/CD, registries, seguridad, Kubernetes, systemd y operación.

Identificar quick wins: desarrollo local, builds sin daemon, servidores rootless, pipelines o migración de servicios simples.

Priorizar aplicaciones por criticidad, estado, dependencias, datos, puertos, seguridad y facilidad de contenerización.

Definir estándares: Containerfile, tags, digest, registries, rootless, Quadlet, logs, secrets y backups.

Preparar laboratorio piloto con aplicación representativa.

Crear guías para desarrolladores, administradores, DevOps y seguridad.

Medir impacto en seguridad, reproducibilidad, tiempos de despliegue y reducción de incidencias.

Ajustar procedimientos antes de escalar.

Crear plan a 30, 60, 90 y 180 días.

Taller: construir roadmap corporativo de adopción o migración a Podman.

Definir una aplicación corporativa con API, base de datos, worker, persistencia, configuración, secrets y necesidad de despliegue Linux.

Crear Containerfile multi-stage con usuario no root, labels OCI, dependencias mínimas y configuración por entorno.

Construir imagen con Podman o Buildah, etiquetarla correctamente y publicarla en registry de laboratorio.

Inspeccionar y promover imagen con Skopeo usando digest, metadatos y trazabilidad.

Crear red, volumen, secrets y pod multi-contenedor con comunicación interna y puertos controlados.

Configurar despliegue rootless con Quadlet y systemd, incluyendo reinicio, logs, dependencias y autoarranque.

Aplicar hardening: SELinux, permisos, capabilities, usuario no root, mounts controlados y puertos mínimos.

Crear pipeline CI/CD con build, test, escaneo, push, promoción y despliegue controlado.

Añadir observabilidad, healthchecks, backup, restore, troubleshooting y runbook operativo.

Presentar arquitectura final con decisiones técnicas, riesgos, mitigaciones, costes, mantenimiento y roadmap de mejora.