Microservicios WordPress con Docker y Kubernetes 2025

Imagina tu WordPress como un monolito de hormigón: cualquier grieta lo inutiliza por completo. Ahora piensa en un ecosistema de microservicios: cada pieza es independiente, escalable y tolerante a fallos. Docker y Kubernetes te permiten transformar ese monolito en un conjunto de contenedores orquestados, llevando la alta disponibilidad WordPress y la flexibilidad a un nivel que los servidores compartidos ni siquiera pueden soñar.

Este artículo es una guía técnica para SysAdmins que quieren romper el molde del WordPress tradicional y adentrarse en la orquestación contenedores WordPress con herramientas de producción real.

¿Por qué Microservicios en WordPress?

WordPress, por defecto, es una aplicación monolítica: PHP, MySQL, Apache/Nginx y archivos estáticos viven juntos. Esto funciona, pero en entornos de alto tráfico o con requisitos de escalado dinámico, se convierte en un cuello de botella.

La gestión de microservicios en WordPress con Docker y Kubernetes desacopla cada componente:

Contenedor PHP-FPM: Ejecuta el core de WordPress y los plugins.
Contenedor Nginx: Sirve como proxy inverso y maneja el caché de página.
Contenedor MySQL / MariaDB: Base de datos transaccional.
Contenedor Redis: Caché de objetos y sesiones.
Contenedor de archivos estáticos (o NFS/Cloud): Almacenamiento externo para wp-content/uploads.

Cada uno de estos contenedores puede escalar de forma independiente. Si tu sitio recibe un pico de tráfico, escalas los pods de PHP, no toda la aplicación.

[INFO] El objetivo no es solo migrar WordPress a contenedores, sino diseñar una arquitectura donde cada servicio tenga su propio ciclo de vida, actualización y escalado.

Docker WordPress: El Primer Paso

Antes de Kubernetes, necesitas tener una imagen Docker sólida y un docker-compose.yml que refleje la separación de servicios.

Estructura del Proyecto

wordpress-microservices/
├── docker-compose.yml
├── nginx/
│   └── default.conf
├── php/
│   └── Dockerfile
├── wordpress/
│   └── wp-content/
└── .env

Ejemplo de docker-compose.yml

version: '3.8'

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf
      - ./wordpress:/var/www/html
    depends_on:
      - php
    networks:
      - wp-network

  php:
    build: ./php
    volumes:
      - ./wordpress:/var/www/html
    environment:
      - WORDPRESS_DB_HOST=db
    depends_on:
      - db
    networks:
      - wp-network

  db:
    image: mariadb:10.11
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: wordpress
    networks:
      - wp-network

  redis:
    image: redis:alpine
    networks:
      - wp-network

volumes:
  db_data:

networks:
  wp-network:
    driver: bridge

[TIP] Para entornos de producción, nunca expongas MySQL directamente. Usa una red interna y un proxy como ProxySQL o un sidecar de Kubernetes.

Kubernetes WordPress: Orquestación Real

Kubernetes añade la capa de orquestación que Docker Compose no puede ofrecer: autoescalado, balanceo de carga, actualizaciones sin caída (rolling updates) y tolerancia a fallos. Aquí es donde la alta disponibilidad WordPress se convierte en una realidad.

Componentes Clave en Kubernetes

Deployments: Para PHP-FPM, Nginx y Redis.
StatefulSets: Para MySQL (o usa un operador como KubeDB).
Services: Para exponer cada capa internamente.
Ingress: Para el tráfico externo hacia WordPress.
PersistentVolumeClaims (PVC): Para almacenar archivos estáticos y la base de datos.
ConfigMaps y Secrets: Para configuraciones y credenciales.

Manifiesto de Deployment para PHP-FPM

apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress-php
spec:
  replicas: 3
  selector:
    matchLabels:
      app: wordpress
      tier: php
  template:
    metadata:
      labels:
        app: wordpress
        tier: php
    spec:
      containers:
      - name: php-fpm
        image: tu-registro/wordpress-php:latest
        ports:
        - containerPort: 9000
        env:
        - name: WORDPRESS_DB_HOST
          value: mysql-service
        - name: WORDPRESS_DB_USER
          valueFrom:
            secretKeyRef:
              name: wp-secrets
              key: db-user
        - name: WORDPRESS_DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: wp-secrets
              key: db-password
        volumeMounts:
        - name: wp-content
          mountPath: /var/www/html/wp-content
      volumes:
      - name: wp-content
        persistentVolumeClaim:
          claimName: wp-content-pvc

[WARNING] No almacenes wp-content/uploads dentro del contenedor. Usa un PVC o un volumen externo (como NFS, EFS o un bucket S3 montado) para que todos los pods compartan los mismos archivos.

Ingress para el Tráfico Externo

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: wordpress-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  rules:
  - host: tudominio.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80
  tls:
  - hosts:
    - tudominio.com
    secretName: wordpress-tls

Alta Disponibilidad WordPress con Kubernetes

La alta disponibilidad WordPress se consigue con tres pilares:

1. Escalado Horizontal Automático (HPA)

Configura un HorizontalPodAutoscaler para los pods de PHP-FPM:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: wordpress-php-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: wordpress-php
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

2. Caché Distribuida con Redis

Redis no solo acelera el sitio, sino que reduce la carga en la base de datos. Instala el plugin Redis Object Cache en WordPress y configura el Service de Redis en Kubernetes.

apiVersion: v1
kind: Service
metadata:
  name: redis-service
spec:
  selector:
    app: redis
  ports:
  - port: 6379

3. Base de Datos Tolerante a Fallos

Para producción, no uses un simple Deployment de MySQL. Considera:

StatefulSet con replicación: Un primario y varios secundarios.
Operador de MariaDB (mariadb-operator): Gestiona backups, failover y escalado.
Base de datos externa: Amazon RDS, Google Cloud SQL o Azure Database for MySQL, conectada desde Kubernetes.

Orquestación Contenedores WordPress: Buenas Prácticas

La orquestación contenedores WordPress no es solo lanzar pods. Requiere planificación.

Separación de Archivos Estáticos

Los archivos subidos por los usuarios (wp-content/uploads) deben vivir fuera del contenedor. Usa:

NFS como volumen persistente.
S3 (MinIO, AWS S3) con el plugin WP Offload Media.
PVC con ReadWriteMany (RWX) si tu cluster lo soporta.

Actualizaciones Sin Caída (Rolling Updates)

Kubernetes lo hace por defecto, pero debes configurar maxSurge y maxUnavailable en tus Deployments para evitar downtime.

strategy:
  type: RollingUpdate
  rollingUpdate:
    maxSurge: 1
    maxUnavailable: 0

Gestión de Configuraciones

Usa ConfigMaps para wp-config.php y Secrets para credenciales. Nunca hardcodees contraseñas en las imágenes.

apiVersion: v1
kind: ConfigMap
metadata:
  name: wp-config
data:
  WP_HOME: "https://tudominio.com"
  WP_SITEURL: "https://tudominio.com"
  WP_CACHE: "true"

Monitorización y Logging

Sin visibilidad, la orquestación es ciega. Implementa:

Prometheus + Grafana: Métricas de CPU, memoria, peticiones por segundo.
Loki + Promtail: Logs centralizados de todos los contenedores.
Kubernetes Dashboard o Lens: Visión general del cluster.

[INFO] Instala el plugin de Prometheus para WordPress (como prometheus_wordpress) para exportar métricas específicas de WP: consultas a BD, tiempo de carga, número de usuarios activos.

Despliegue Paso a Paso (Resumen)

Construye la imagen Docker de PHP-FPM con tu wp-content y plugins necesarios.
Sube la imagen a un registro (Docker Hub, ECR, GCR).
Crea los manifiestos de Kubernetes para Nginx, PHP, MySQL, Redis y el Ingress.
Configura los PVCs para almacenamiento persistente.
Aplica los manifiestos con kubectl apply -f ./k8s/.
Configura el DNS para que apunte al Ingress Controller.
Instala y configura los plugins de caché (Redis Object Cache, WP Super Cache).
Prueba el escalado automático simulando tráfico con herramientas como hey o k6.

Retos y Consideraciones

No todo es perfecto. La gestión de microservicios en WordPress presenta desafíos:

Persistencia de sesiones: Si usas sesiones PHP (poco recomendado en WP moderno), necesitas un almacén compartido (Redis) o configurar session.save_handler en PHP.
Plugins incompatibles: Algunos plugins esperan un entorno monolítico. Prueba exhaustivamente en staging.
Complejidad operativa: Kubernetes no es trivial. Necesitas un equipo con conocimientos de contenedores y orquestación.
Costo: Más servicios (Redis, balanceadores, almacenamiento externo) pueden incrementar el costo mensual.

[WARNING] No migres un WordPress con plugins obsoletos o mal escritos a Kubernetes. Los microservicios amplifican los problemas de rendimiento y seguridad. Primero limpia tu instalación.

Conclusión

La gestión de microservicios en WordPress con Docker y Kubernetes es el camino para sitios que necesitan escalar sin límites, actualizar sin miedo y dormir tranquilos sabiendo que si un contenedor falla, otro toma el relevo. No es una solución para un blog personal, pero sí para medios digitales, e-commerce y plataformas SaaS basadas en WordPress.

Empieza con Docker Compose para entender el flujo, luego migra a Kubernetes en un cluster de pruebas (Minikube, Kind). Cuando domines los conceptos, despliega en producción con un proveedor cloud (EKS, GKE, AKS) o en tu propio bare-metal con kubeadm.

La alta disponibilidad WordPress ya no es un lujo, es una arquitectura que puedes construir hoy con herramientas open source. El monolito está muerto, larga vida a los contenedores.