Por Mid 
Ansible Kubernetes es la combinación perfecta para automatizar la gestión de clusters de contenedores en 2025. Si buscas orquestar aplicaciones containerizadas con la potencia de Ansible, esta guía te mostrará cómo integrar ambas tecnologías para lograr automatización completa de despliegues, configuración de RBAC y políticas de red.
¿Qué es Ansible Kubernetes y Por Qué Usarlo?
Ansible Kubernetes representa la integración entre Ansible, la herramienta de automatización de configuración, y Kubernetes, el orquestador de contenedores líder del mercado. Mientras Kubernetes gestiona el ciclo de vida de contenedores a escala, Ansible proporciona capacidades de gestión de configuración que van más allá de lo que Kubernetes ofrece nativamente.
Esta combinación permite a los equipos de DevOps automatizar desde la preparación de infraestructura hasta el despliegue de aplicaciones, pasando por la configuración de seguridad y políticas de acceso. En 2025, las organizaciones adoptan esta solución para gestionar entornos híbridos y multi-cloud con mayor eficiencia.
Ansible Kubernetes: Beneficios de la Integración
La integración ofrece ventajas significativas sobre el uso de Kubernetes de forma aislada:
- Preparación de infraestructura automatizada: Ansible provisiona recursos en cloud y prepara nodos antes del despliegue de Kubernetes
- Gestión multi-entorno: Trabaja en infraestructuras diversas mientras Kubernetes orquesta contenedores dentro de clusters
- Configuración declarativa avanzada: Combina la configuración de sistemas con la orquestación de aplicaciones containerizadas
- Estrategias híbridas y multi-cloud: Aprovecha el enfoque agentless de Ansible entre diferentes plataformas
- Automatización end-to-end: Desde el aprovisionamiento de VMs hasta la configuración de políticas de red en K8s
Si ya trabajas con Ansible Docker Deployment, entenderás que esta integración lleva esa automatización al siguiente nivel, permitiendo gestionar clusters completos en lugar de contenedores individuales.
Requisitos Previos para Ansible Kubernetes
Antes de implementar la solución, necesitas preparar tu entorno con los siguientes componentes:
Software Requerido
- Ansible: Versión 2.16.0 o superior (ansible-core)
- Python: Versión 3.8 o superior
- kubectl: Cliente de línea de comandos de Kubernetes
- Cluster Kubernetes: Puede ser local (minikube, kind) o en cloud (EKS, GKE, AKS)
Instalación de kubernetes.core Collection
La colección kubernetes.core es fundamental para trabajar con Ansible Kubernetes. Instálala con el siguiente comando:
ansible-galaxy collection install kubernetes.coreEsta colección incluye 21 módulos especializados para gestionar recursos de Kubernetes, incluyendo despliegues, servicios, ConfigMaps, Secrets, RBAC y mucho más.
Dependencias Python
Instala las bibliotecas Python necesarias:
pip install kubernetes openshift PyYAML jsonpatchPlaybook Básico de Ansible Kubernetes
Comenzaremos con un playbook básico que demuestra cómo desplegar una aplicación Nginx con tres réplicas:
---
- name: Despliegue de aplicación con Ansible Kubernetes
hosts: localhost
gather_facts: false
collections:
- kubernetes.core
tasks:
- name: Crear namespace para aplicación
k8s:
state: present
definition:
apiVersion: v1
kind: Namespace
metadata:
name: ansible-demo
labels:
managed-by: ansible
- name: Desplegar aplicación Nginx
k8s:
state: present
definition:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
namespace: ansible-demo
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.25
ports:
- containerPort: 80
name: http
resources:
requests:
cpu: 100m
memory: 128Mi
limits:
cpu: 250m
memory: 256Mi
- name: Crear Service para Nginx
k8s:
state: present
definition:
apiVersion: v1
kind: Service
metadata:
name: nginx-service
namespace: ansible-demo
spec:
selector:
app: nginx
ports:
- port: 80
targetPort: 80
protocol: TCP
type: LoadBalancer
- name: Verificar estado del deployment
k8s_info:
kind: Deployment
namespace: ansible-demo
name: nginx-deployment
register: deployment_status
- name: Mostrar información del deployment
debug:
msg: "Deployment tiene {{ deployment_status.resources[0].status.availableReplicas }} réplicas disponibles"Este playbook crea un namespace, despliega una aplicación Nginx con recursos limitados, expone un servicio LoadBalancer y verifica el estado del despliegue.
Configuración de RBAC con Ansible Kubernetes
La seguridad es crítica en cualquier cluster. La automatización permite configurar RBAC (Role-Based Access Control) para implementar el principio de mínimo privilegio:
---
- name: Configuración de RBAC con Ansible Kubernetes
hosts: localhost
gather_facts: false
collections:
- kubernetes.core
tasks:
- name: Crear ServiceAccount para aplicación
k8s:
state: present
definition:
apiVersion: v1
kind: ServiceAccount
metadata:
name: app-service-account
namespace: ansible-demo
- name: Crear Role con permisos limitados
k8s:
state: present
definition:
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: app-role
namespace: ansible-demo
rules:
- apiGroups: [""]
resources: ["pods", "services", "configmaps"]
verbs: ["get", "list", "watch"]
- apiGroups: ["apps"]
resources: ["deployments"]
verbs: ["get", "list"]
- name: Crear RoleBinding
k8s:
state: present
definition:
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: app-rolebinding
namespace: ansible-demo
subjects:
- kind: ServiceAccount
name: app-service-account
namespace: ansible-demo
roleRef:
kind: Role
name: app-role
apiGroup: rbac.authorization.k8s.io
- name: Crear ClusterRole para acceso a recursos globales
k8s:
state: present
definition:
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: node-reader
rules:
- apiGroups: [""]
resources: ["nodes"]
verbs: ["get", "list", "watch"]
- name: Vincular ClusterRole a ServiceAccount
k8s:
state: present
definition:
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: node-reader-binding
subjects:
- kind: ServiceAccount
name: app-service-account
namespace: ansible-demo
roleRef:
kind: ClusterRole
name: node-reader
apiGroup: rbac.authorization.k8s.ioEste playbook implementa una configuración RBAC completa con ServiceAccount, Role, RoleBinding, ClusterRole y ClusterRoleBinding, siguiendo las mejores prácticas de seguridad de 2025.
Network Policies con Ansible Kubernetes
Las políticas de red son esenciales para segmentar el tráfico entre pods. La automatización permite configurarlas de forma declarativa:
---
- name: Configurar Network Policies con Ansible Kubernetes
hosts: localhost
gather_facts: false
collections:
- kubernetes.core
tasks:
- name: Denegar todo el tráfico por defecto
k8s:
state: present
definition:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-all
namespace: ansible-demo
spec:
podSelector: {}
policyTypes:
- Ingress
- Egress
- name: Permitir tráfico interno entre pods de la aplicación
k8s:
state: present
definition:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-internal-traffic
namespace: ansible-demo
spec:
podSelector:
matchLabels:
app: nginx
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: nginx
ports:
- protocol: TCP
port: 80
- name: Permitir tráfico desde ingress controller
k8s:
state: present
definition:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-ingress-traffic
namespace: ansible-demo
spec:
podSelector:
matchLabels:
app: nginx
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchLabels:
name: ingress-nginx
ports:
- protocol: TCP
port: 80
- name: Permitir salida a DNS y servicios externos
k8s:
state: present
definition:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-dns-egress
namespace: ansible-demo
spec:
podSelector: {}
policyTypes:
- Egress
egress:
- to:
- namespaceSelector:
matchLabels:
name: kube-system
ports:
- protocol: UDP
port: 53
- to:
- podSelector: {}
ports:
- protocol: TCP
port: 443Este enfoque implementa el modelo de seguridad «deny by default» y luego permite selectivamente el tráfico necesario, mejorando significativamente la postura de seguridad del cluster.
Gestión de Secrets con Ansible Kubernetes y Vault
La gestión segura de secretos es crítica en 2025. La integración con HashiCorp Vault permite mantener credenciales fuera del código:
---
- name: Gestión de Secrets con Ansible Kubernetes y Vault
hosts: localhost
gather_facts: false
collections:
- kubernetes.core
vars:
vault_addr: "https://vault.example.com:8200"
vault_token: "{{ lookup('env', 'VAULT_TOKEN') }}"
tasks:
- name: Obtener credenciales de base de datos desde Vault
set_fact:
db_credentials: "{{ lookup('hashi_vault', 'secret=secret/data/database token={{ vault_token }} url={{ vault_addr }}') }}"
- name: Crear Secret de Kubernetes con credenciales
k8s:
state: present
definition:
apiVersion: v1
kind: Secret
metadata:
name: database-credentials
namespace: ansible-demo
type: Opaque
stringData:
username: "{{ db_credentials.username }}"
password: "{{ db_credentials.password }}"
host: "{{ db_credentials.host }}"
port: "{{ db_credentials.port }}"
- name: Desplegar aplicación que usa el Secret
k8s:
state: present
definition:
apiVersion: apps/v1
kind: Deployment
metadata:
name: app-with-db
namespace: ansible-demo
spec:
replicas: 2
selector:
matchLabels:
app: backend
template:
metadata:
labels:
app: backend
spec:
containers:
- name: backend
image: myapp:latest
env:
- name: DB_USERNAME
valueFrom:
secretKeyRef:
name: database-credentials
key: username
- name: DB_PASSWORD
valueFrom:
secretKeyRef:
name: database-credentials
key: password
- name: DB_HOST
valueFrom:
secretKeyRef:
name: database-credentials
key: host
- name: DB_PORT
valueFrom:
secretKeyRef:
name: database-credentials
key: portEsta integración con Vault elimina la necesidad de almacenar secretos en texto plano o en repositorios Git, cumpliendo con las mejores prácticas de seguridad.
Ansible Kubernetes: Automatización de Backups
El backup de recursos es esencial para la continuidad del negocio. La automatización puede gestionar backups utilizando herramientas como Velero. Si necesitas una solución completa de backup, consulta nuestra guía sobre Velero Kubernetes.
Un playbook básico para programar backups sería:
---
- name: Configurar backups automáticos
hosts: localhost
gather_facts: false
collections:
- kubernetes.core
tasks:
- name: Crear CronJob para backup periódico
k8s:
state: present
definition:
apiVersion: batch/v1
kind: CronJob
metadata:
name: backup-job
namespace: ansible-demo
spec:
schedule: "0 2 * * *"
successfulJobsHistoryLimit: 3
failedJobsHistoryLimit: 3
jobTemplate:
spec:
template:
spec:
serviceAccountName: backup-sa
containers:
- name: backup
image: bitnami/kubectl:latest
command:
- /bin/bash
- -c
- |
kubectl get all -n ansible-demo -o yaml > /backup/backup-$(date +%Y%m%d-%H%M%S).yaml
# Subir a S3 o storage externo
volumeMounts:
- name: backup-volume
mountPath: /backup
volumes:
- name: backup-volume
persistentVolumeClaim:
claimName: backup-pvc
restartPolicy: OnFailureMonitorización con Ansible Kubernetes
La automatización también puede desplegar soluciones de monitorización como Prometheus y Grafana:
---
- name: Desplegar stack de monitorización
hosts: localhost
gather_facts: false
collections:
- kubernetes.core
tasks:
- name: Crear namespace de monitorización
k8s:
state: present
definition:
apiVersion: v1
kind: Namespace
metadata:
name: monitoring
- name: Desplegar Prometheus
k8s:
state: present
definition:
apiVersion: apps/v1
kind: Deployment
metadata:
name: prometheus
namespace: monitoring
spec:
replicas: 1
selector:
matchLabels:
app: prometheus
template:
metadata:
labels:
app: prometheus
spec:
containers:
- name: prometheus
image: prom/prometheus:latest
ports:
- containerPort: 9090
volumeMounts:
- name: config
mountPath: /etc/prometheus
volumes:
- name: config
configMap:
name: prometheus-config
- name: Crear ConfigMap de configuración Prometheus
k8s:
state: present
definition:
apiVersion: v1
kind: ConfigMap
metadata:
name: prometheus-config
namespace: monitoring
data:
prometheus.yml: |
global:
scrape_interval: 15s
scrape_configs:
- job_name: 'kubernetes-pods'
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
action: keep
regex: trueCasos de Uso Avanzados de Ansible Kubernetes
En 2025, las organizaciones usan esta solución para escenarios complejos:
Multi-Cluster Management
La herramienta permite gestionar múltiples clusters simultáneamente usando diferentes contextos de kubeconfig. Esto es ideal para estrategias multi-región o multi-cloud.
GitOps y CI/CD
Integra playbooks en pipelines de CI/CD para automatizar despliegues continuos. Herramientas como Jenkins, GitLab CI o GitHub Actions pueden invocar playbooks de Ansible para actualizar aplicaciones.
Disaster Recovery
Automatiza procedimientos de recuperación ante desastres, incluyendo la restauración de namespaces completos, configuraciones y datos persistentes.
Compliance y Auditoría
Ejecuta auditorías automatizadas para verificar cumplimiento con políticas de seguridad, generar reportes de configuración y aplicar remediaciones automáticas cuando se detectan desviaciones.
Mejores Prácticas de Ansible Kubernetes en 2025
Para aprovechar al máximo la solución, sigue estas recomendaciones:
- Usa roles modulares: Organiza tus playbooks en roles reutilizables para facilitar el mantenimiento
- Implementa idempotencia: Asegúrate de que tus playbooks puedan ejecutarse múltiples veces sin efectos adversos
- Gestiona secretos adecuadamente: Nunca almacenes credenciales en texto plano, usa Ansible Vault o integraciones con gestores externos
- Aplica least privilege: Configura RBAC con permisos mínimos necesarios para cada ServiceAccount
- Versionado en Git: Mantén todos tus playbooks en control de versiones
- Testing antes de producción: Prueba cambios en entornos de staging antes de aplicarlos a producción
- Documentación inline: Usa comentarios descriptivos en tus playbooks para facilitar el entendimiento del equipo
- Monitorización continua: Implementa logging y monitoring para detectar problemas rápidamente
Si trabajas con contenedores individuales, revisa nuestro artículo sobre Dockge Docker Compose para gestionar stacks Docker con interfaces visuales.
Troubleshooting Común en Ansible Kubernetes
Al trabajar con la integración, pueden surgir problemas comunes. Aquí las soluciones:
Error de Autenticación
Si recibes errores de autenticación, verifica que tu kubeconfig esté correctamente configurado:
kubectl config view
kubectl config current-contextMódulos No Encontrados
Si Ansible no encuentra los módulos de Kubernetes, reinstala la colección:
ansible-galaxy collection install kubernetes.core --forceTimeouts en Operaciones
Para operaciones que toman tiempo, ajusta el timeout en tus tareas:
- name: Despliegue con timeout extendido
k8s:
state: present
definition: "{{ deployment_manifest }}"
wait: true
wait_timeout: 300Recursos Adicionales para Ansible Kubernetes
Para profundizar en la tecnología, consulta estos recursos oficiales:
- Documentación oficial de kubernetes.core collection
- Documentación oficial de Kubernetes
- Red Hat: Ansible vs Kubernetes
Si buscas soluciones complementarias de automatización, explora nuestros artículos sobre Home Assistant Docker Compose para automatización del hogar.
Preguntas Frecuentes sobre Ansible Kubernetes
¿Puedo usar Ansible Kubernetes sin conocimientos previos?
Es recomendable tener conocimientos básicos de Kubernetes antes de usar la integración. Entender conceptos como Pods, Deployments, Services y Namespaces te ayudará a crear playbooks más efectivos.
¿Ansible Kubernetes funciona con todos los proveedores de cloud?
Sí, la solución funciona con cualquier cluster de Kubernetes, independientemente del proveedor: AWS EKS, Google GKE, Azure AKS, clusters on-premise, o distribuciones como OpenShift, Rancher o k3s.
¿Cuál es la diferencia entre Helm y Ansible Kubernetes?
Helm es un gestor de paquetes específico para Kubernetes, mientras que Ansible Kubernetes es una solución de automatización más amplia que puede gestionar tanto infraestructura como aplicaciones. De hecho, Ansible incluye módulos para gestionar charts de Helm, permitiendo combinar ambas herramientas.
¿Cómo gestiono múltiples entornos con Ansible Kubernetes?
Utiliza inventarios diferentes y variables específicas por entorno. Puedes tener archivos de variables separados para desarrollo, staging y producción, cambiando el comportamiento de tus playbooks según el entorno objetivo.
¿Es seguro usar Ansible Kubernetes en producción?
Sí, la integración es segura para producción cuando sigues las mejores prácticas: gestión adecuada de secretos, implementación de RBAC, uso de service accounts específicos, y testing exhaustivo antes de despliegues. Muchas organizaciones enterprise usan esta combinación.
Conclusión: El Poder de Ansible Kubernetes
Ansible Kubernetes representa la evolución natural de la automatización de infraestructura, combinando la flexibilidad de Ansible con la potencia de orquestación de Kubernetes. En 2025, esta integración es fundamental para equipos DevOps que buscan gestionar aplicaciones containerizadas a escala.
Desde la configuración de RBAC hasta la implementación de network policies, pasando por la gestión segura de secretos con Vault, esta solución proporciona un framework completo para automatizar todo el ciclo de vida de tus aplicaciones en clusters de contenedores.
Comienza con los playbooks básicos de esta guía y evoluciona hacia casos de uso más complejos como multi-cluster management o disaster recovery. La inversión en aprender esta tecnología se traducirá en mayor eficiencia operativa y mejor postura de seguridad para tu infraestructura.