🎨 Sysprovider Code
Sysprovider LogoWiki
🇪🇸Hosting español para ecommerce

Automatización de Despliegues en WordPress con CI/CD y Git

Actualizado el 22 de noviembre de 2025

Imagina que cada cambio en tu sitio WordPress, ya sea un plugin actualizado, un tema modificado o un parche de seguridad crítico, requiere una conexión FTP manual, clics en interfaces de administración y la angustia de que algo se rompa en producción. Esa pesadilla termina hoy. La automatización de despliegues con CI/CD (Integración Continua y Entrega Continua) transforma este caos en un proceso reproducible, auditable y seguro.

Este artículo es una guía técnica completa para implementar pipelines de CI/CD en WordPress. Exploraremos desde la estructura de repositorio hasta las configuraciones específicas con GitHub Actions y Jenkins, sin olvidar las mejores prácticas de DevOps adaptadas a este CMS.

¿Por Qué Automatizar el Despliegue de WordPress?

Antes de sumergirnos en el código, entendamos el valor real de la automatización. No se trata solo de "subir archivos más rápido". Se trata de eliminar el error humano y garantizar consistencia.

Beneficios clave:

  • Reproducibilidad: Cada despliegue sigue exactamente los mismos pasos. Adiós al "en mi máquina funciona".
  • Seguridad: Eliminas credenciales FTP en texto plano. Las claves SSH se gestionan mediante secretos del pipeline.
  • Rollback rápido: Si algo falla, el pipeline puede revertir al commit anterior en segundos.
  • Pruebas automáticas: Puedes ejecutar linters, pruebas de plugins y análisis de seguridad antes de tocar producción.

[INFO] La automatización no es opcional para sitios con tráfico medio-alto o equipos de más de una persona. Es una necesidad operativa.

Arquitectura de un Pipeline CI/CD para WordPress

Un pipeline típico consta de tres fases: Integración, Entrega y Despliegue. En el contexto de WordPress, debemos considerar que el CMS en sí mismo (core) no debe versionarse, pero sí los temas, plugins personalizados y configuraciones.

Estructura de Repositorio Recomendada

mi-proyecto-wordpress/
├── .github/
│   └── workflows/
│       └── deploy.yml
├── themes/
│   └── mi-tema-personalizado/
│       ├── style.css
│       ├── functions.php
│       └── ...
├── plugins/
│   └── mi-plugin-personalizado/
│       ├── mi-plugin.php
│       └── ...
├── mu-plugins/
├── uploads/           # Solo para estructura de ejemplo, no versionar contenido
├── .gitignore
├── composer.json      # Gestión de dependencias PHP
└── package.json       # Assets (CSS/JS) si aplica

Punto crítico: El archivo wp-config.php con credenciales de base de datos nunca debe estar en el repositorio. Se genera en tiempo de despliegue mediante variables de entorno.

GitHub Actions: El Pipeline Moderno para WordPress

GitHub Actions es la opción más accesible para equipos que ya usan GitHub. Su ecosistema de acciones preconstruidas acelera la configuración.

Workflow Básico de Despliegue por SFTP

Creamos un archivo .github/workflows/deploy.yml:

name: Deploy WordPress

on:
  push:
    branches:
      - main
      - staging

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.1'

      - name: Validate composer
        run: composer validate --strict

      - name: Install dependencies
        run: composer install --no-dev --optimize-autoloader

      - name: Deploy via SFTP
        uses: SamKirkland/FTP-Deploy-Action@v4.3.4
        with:
          server: ${{ secrets.FTP_SERVER }}
          username: ${{ secrets.FTP_USERNAME }}
          password: ${{ secrets.FTP_PASSWORD }}
          server-dir: /public_html/wp-content/themes/mi-tema/
          local-dir: ./themes/mi-tema/
          exclude: |
            .git*
            node_modules/
            tests/

[TIP] Usa exclude para evitar subir archivos de desarrollo. Incluye siempre node_modules/ y .git/.

Workflow Avanzado con Pruebas y Notificaciones

Para equipos serios, añadimos análisis de calidad de código:

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: PHPCS
        uses: chekalsky/phpcs-action@v1
        with:
          standard: WordPress
          paths: 'themes/mi-tema/ plugins/mi-plugin/'

  security:
    runs-on: ubuntu-latest
    steps:
      - name: Plugin Security Check
        uses: 10up/wp-plugin-security-checker@v1
        with:
          path: ./plugins/mi-plugin/

  deploy:
    needs: [lint, security]
    runs-on: ubuntu-latest
    steps:
      # ... pasos de despliegue anteriores

Jenkins: El Caballo de Batalla Empresarial

Jenkins sigue siendo la opción preferida en entornos corporativos donde se requiere control granular, plugins personalizados y autenticación LDAP. Su flexibilidad es su mayor fortaleza, pero también su complejidad.

Configuración de Pipeline Declarativo con Jenkinsfile

Creamos un Jenkinsfile en la raíz del proyecto:

pipeline {
    agent any
    
    environment {
        WP_SITE_URL = 'https://midominio.com'
        DEPLOY_PATH = '/var/www/html/wp-content'
        SSH_KEY = credentials('ssh-key-produccion')
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Composer Install') {
            steps {
                sh 'composer install --no-dev --optimize-autoloader'
            }
        }
        
        stage('Build Assets') {
            steps {
                sh 'npm ci'
                sh 'npm run build'
            }
        }
        
        stage('Deploy to Staging') {
            when {
                branch 'develop'
            }
            steps {
                sshagent(['ssh-key-staging']) {
                    sh """
                        rsync -avz --delete --exclude='.git' --exclude='node_modules' \
                        themes/ user@staging-server:${DEPLOY_PATH}/themes/
                    """
                }
            }
        }
        
        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            input {
                message "¿Desplegar a producción?"
                ok "Sí, desplegar"
            }
            steps {
                sshagent(['ssh-key-produccion']) {
                    sh """
                        rsync -avz --delete --exclude='.git' --exclude='node_modules' \
                        themes/ user@prod-server:${DEPLOY_PATH}/themes/
                    """
                }
            }
        }
    }
    
    post {
        failure {
            emailext (
                to: 'devops@midominio.com',
                subject: "Fallo en despliegue de WordPress: ${env.BUILD_TAG}",
                body: "El pipeline falló en el stage ${env.STAGE_NAME}. Ver logs."
            )
        }
    }
}

[WARNING] Jenkins requiere mantenimiento constante. Asegúrate de tener un equipo dedicado para gestionar actualizaciones de plugins, parches de seguridad y limpieza de builds antiguos.

DevOps WordPress: Buenas Prácticas Esenciales

La automatización no es solo tecnología; es cultura. Aquí tienes prácticas que marcan la diferencia.

Gestión de Entornos con Archivos de Configuración

Usa un enfoque de entornos múltiples con archivos .env:

# .env.production
DB_NAME=wp_prod
DB_USER=wp_user_prod
DB_PASSWORD=secret_prod_123
WP_HOME=https://midominio.com
WP_SITEURL=https://midominio.com/wp

# .env.staging
DB_NAME=wp_staging
DB_USER=wp_user_staging
DB_PASSWORD=secret_staging_456
WP_HOME=https://staging.midominio.com

En el pipeline, carga el archivo correspondiente según la rama:

- name: Load environment config
  run: |
    if [ "${GITHUB_REF##*/}" = "main" ]; then
      cp .env.production .env
    else
      cp .env.staging .env
    fi

Estrategia de Ramas

Recomiendo el modelo Git Flow simplificado:

  • main → Producción. Despliegue automático tras aprobación manual.
  • staging → Pre-producción. Despliegue automático.
  • develop → Desarrollo. Despliegue a entorno de pruebas.
  • feature/* → Ramas temporales. No despliegan.

Seguridad en el Pipeline

  • Nunca almacenes claves SSH o contraseñas en el repositorio.
  • Usa secretos de GitHub o credenciales en Jenkins.
  • Rota las claves cada 90 días.
  • Implementa firmado de commits para garantizar trazabilidad.

Automatización de Plugins y Temas con Composer

WordPress se beneficia enormemente de Composer para gestionar dependencias. Tu composer.json podría verse así:

{
    "name": "mi-agencia/wordpress-project",
    "require": {
        "php": ">=8.0",
        "wpackagist-plugin/wordfence": "^7.5",
        "wpackagist-plugin/yoast-seo": "^20.0"
    },
    "extra": {
        "installer-paths": {
            "plugins/{$name}": ["type:wordpress-plugin"],
            "themes/{$name}": ["type:wordpress-theme"]
        }
    }
}

En el pipeline, ejecutas composer install y todos los plugins de terceros se descargan automáticamente en la versión correcta.

Monitoreo Post-Despliegue

La automatización no termina cuando los archivos están en el servidor. Implementa comprobaciones de salud:

- name: Health Check
  run: |
    curl -s -o /dev/null -w "%{http_code}" ${{ secrets.SITE_URL }}/wp-admin/upgrade.php
    if [ $? -ne 200 ]; then
      echo "Error: WordPress no responde correctamente"
      exit 1
    fi

También puedes integrar herramientas como New Relic o Datadog para monitorear el rendimiento después de cada despliegue.

Conclusión: El Futuro es Automatizado

La automatización de despliegues en WordPress con CI/CD y Git no es un lujo, es una necesidad para cualquier proyecto profesional. Ya sea que elijas GitHub Actions por su simplicidad o Jenkins por su potencia, el principio es el mismo: repetibilidad, seguridad y velocidad.

Pasos inmediatos para empezar:

  1. Configura un repositorio Git con la estructura correcta.
  2. Aísla tus temas y plugins personalizados.
  3. Escribe tu primer pipeline (empieza con GitHub Actions, es más rápido).
  4. Implementa un entorno de staging.
  5. Automatiza las pruebas básicas antes de tocar producción.

[INFO] El mayor error es intentar automatizar todo de golpe. Empieza con un solo tema o plugin, mide los resultados y escala gradualmente.

La era del FTP manual ha terminado. Bienvenido al DevOps WordPress. Tu servidor, tu equipo y tu tranquilidad te lo agradecerán.

¿Necesitas ayuda?Son dos de nuestros técnicos, Agustín y Mikel, y están disponibles para resolver cualquier problema.

Hablar con ellos ahora
Agustín y Mikel