GNU/Linux >> Tutoriales Linux >  >> Linux

Cómo alojar múltiples sitios de WordPress en el mismo servidor con Docker

Instalar WordPress no es gran cosa. Puede instalarlo utilizando el servidor LAMP para el desarrollo local. También puede implementarlo para el mundo real en un servidor Linux público adecuado.

Los servidores en la nube como Linode, DigitalOcean, etc. también brindan la opción de implementar un nuevo servidor Linux preconfigurado con WordPress. Aún más fácil, ¿verdad?

Pero, ¿qué sucede si desea instalar más de un WordPress en un solo servidor?

Una forma fácil sería utilizar un servicio como ServerPilot. No solo actualiza su servidor automáticamente, sino que también le permite implementar fácilmente varias instancias de WordPress en el mismo servidor.

Eso le costaría un poco más de dinero y, si no lo desea, puede usar Docker para implementar varias instancias de WordPress.

A través de esta guía, aprenderá cómo configurar fácilmente una configuración dual de WordPress que se ejecuta desde sus contenedores individuales y agregar más instancias.

Requisitos

No es obligatorio, pero el tutorial te resultará mucho más fácil de seguir si tienes:

  • Conocimiento de los comandos básicos de Linux
  • Algunos conocimientos de Docker
  • Comprensión de Docker Compose

Implementará WordPress detrás de un contenedor de proxy inverso, con dominio y subdominios habilitados para SSL.

Además de los conocimientos temáticos mencionados anteriormente, necesitará los siguientes requisitos de infraestructura:

  • Un servidor Ubuntu Linux de cara al público . Puede utilizar un proveedor de servicios en la nube como Linode. Un servidor Nano con 1 GB de RAM será suficiente para esta implementación. Pero si planea hospedar más instancias de WordPress, considere actualizarlo.
  • Acceso a sus dominios/subdominios y su configuración de DNS
  • Docker y Docker Compose instalados en su servidor Linux.

Si necesita ayuda, puede seguir nuestras guías en:

  • Instalación de Docker en Ubuntu
  • Instalación de composición de Docker en Ubuntu
  • Configuración de ventana acoplable de proxy inverso

En todos nuestros otros tutoriales basados ​​en aplicaciones web autohospedadas con Docker, analicé la implementación de contenedores Nginx y contenedores de aplicaciones web por separado. Esta vez, sin embargo, usaré Docker Compose para configurar varios contenedores de WordPress, todos basados ​​en un solo archivo yml.

Así que este también es un ejemplo para mostrarle cómo puede integrar una configuración de Nginx con una aplicación web que considere implementar, a través de un único archivo Docker Compose.

Usaré domain.com como ejemplo para el primer blog de WordPress y wordpress.domain.com como el segundo blog autohospedado. Al final, también describiré cómo agregar más instancias de WordPress en función de la configuración que voy a analizar aquí.

Configurar un directorio de trabajo para todos los servicios relacionados con WordPress

Cree un directorio y actívelo. Llamémoslo multi-wordpress .

mkdir multi-wordpress

Y luego cambie a este directorio recién creado usando el comando cd:

cd multi-wordpress

Establezca el límite de carga de archivos de WordPress en 512 MB

Dentro de este directorio, almacenaremos nuestro uploads.ini archivo que tiene la configuración de carga necesaria para cargar archivos de hasta 512 MB de tamaño. Ingrese el siguiente comando en la terminal:

[email protected]:~/multi-wordpress$ printf "file_uploads = On\nmemory_limit = 512M\nupload_max_filesize = 512M\npost_max_size = 512M\nmax_execution_time = 600" > uploads.ini

Establecer un límite de carga de archivos para Nginx

Como medida adicional, cree también un archivo llamado client_max_upload_size.conf y guárdelo en el mismo directorio para montarlo en el contenedor Nginx. Por el bien de eso, lo configuré en 1 GB. Esto es útil para configurar otras aplicaciones en el futuro.

[email protected]:~/multi-wordpress$ printf "client_max_body_size 1G;" > client_max_upload_size.conf

Redirección de WWW a través de Nginx (no se requiere actualizar CNAME)

Si desea usar una redirección que no sea de www a www con WordPress, puede configurar el redireccionador con el comando cat en su servidor Linux:

[email protected]:~/multi-wordpress$ cat >> domain.com
rewrite ^/(.*)$ https://www.domain.com/$1 permanent;

Presiona enter y luego Ctrl+D para guardarlo. No usamos printf aquí porque $1 no se guardará en el archivo como se muestra arriba. Esto podría generar problemas futuros con las URL, ya que queremos que la redirección funcione en todos los casos. Por ejemplo, domain.com/test siempre debe redirigir a www.domain.com/test .

Redirección no WWW a través de Nginx (no se requiere actualizar CNAME)

Si desea utilizar la redirección de www a no www, repita pasos similares para hacer lo contrario:

[email protected]:~/multi-wordpress$ cat >> www.domain.com
rewrite ^/(.*)$ https://domain.com/$1 permanent;

Crea una red Docker externa

Usaré una red llamada net para este tutorial. Por lo tanto, lo creo con el siguiente comando:

docker network create net

Preparación de un único archivo Docker Compose listo para su implementación

Con la siguiente configuración dentro de un solo docker-compose.yml archivo, puede configurar todo de una sola vez con los seis contenedores que sirven para su propósito, desde el proxy inverso hasta el último contenedor de WordPress. Mirémoslos servicio por servicio antes de finalmente fusionarlos todos en un solo archivo:

Contenedor de proxy inverso de Nginx

Monte ambos archivos client_max_upload_size.conf y www.domain.com en modo de solo lectura y especifique la red net que se creó manualmente.

  nginx-proxy:
    image: jwilder/nginx-proxy
    container_name: nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - html:/usr/share/nginx/html
      - dhparam:/etc/nginx/dhparam
      - vhost:/etc/nginx/vhost.d
      - certs:/etc/nginx/certs:ro
      - /var/run/docker.sock:/tmp/docker.sock:ro
      - ./client_max_upload_size.conf:/etc/nginx/conf.d/client_max_upload_size.conf:ro
      - ./www.domain.com:/etc/nginx/vhost.d/www.domain.com:ro
    labels:
      - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy"
    restart: always
    networks:
      - net

Contenedor Let's Encrypt para certificados SSL

Tenga en cuenta que uso rw para los certs volumen, a diferencia de ro en la sección anterior. Esto es esencial para crear los certificados SSL y actualizar el volumen en consecuencia a medida que se generan. Además, configure el correo electrónico predeterminado para las notificaciones de Let's Encrypt y especifique el mismo "net ” red.

  letsencrypt:
    image: jrcs/letsencrypt-nginx-proxy-companion
    container_name: lets-encrypt-proxy-companion
    depends_on:
      - "nginx-proxy"
    volumes:
      - certs:/etc/nginx/certs:rw
      - vhost:/etc/nginx/vhost.d
      - html:/usr/share/nginx/html
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      DEFAULT_EMAIL: [email protected]
    restart: always
    networks:
      - net

Contenedor de base de datos para el primer sitio de WordPress

Según la configuración oficial de WordPress Docker Compose, establezca las variables de entorno necesarias como se muestra a continuación y especifique una red interna (visto como mysqldb0 aquí, utilizado también para el nombre del servicio y el nombre del volumen).

Esta red será visible solo para el contenedor de la base de datos y su correspondiente contenedor de WordPress. Cuando lo implemente, se creará una base de datos MySQL con las credenciales que se muestran a continuación:

  mysqldb0:
    image: mysql:5.7
    environment:
      MYSQL_DATABASE: db0
      MYSQL_USER: db0user
      MYSQL_PASSWORD: secret
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - 'mysqldb0:/var/lib/mysql'
    restart: always
    networks:
      - mysqldb0

Primer contenedor de WordPress

Cuando implemente el contenedor de WordPress, utilizará la configuración de la base de datos especificada en la sección anterior. Tenga en cuenta que además de la misma red interna vista por la base de datos (mysqldb0 ), este servicio de WordPress también debe ver la red Nginx llamada net ya que es la aplicación frontend para el mundo exterior.

  wordpress0:
    image: wordpress:5.8.0-php8.0-apache
    environment:
      WORDPRESS_DB_HOST: mysqldb0
      WORDPRESS_DB_USER: db0user
      WORDPRESS_DB_PASSWORD: secret
      WORDPRESS_DB_NAME: db0
      WORDPRESS_CONFIG_EXTRA: |
        define('AUTOMATIC_UPDATER_DISABLED', true);
      VIRTUAL_HOST: domain.com,www.domain.com
      LETSENCRYPT_HOST: domain.com,www.domain.com
    volumes:
      - 'wordpress0:/var/www/html/wp-content'
      - './uploads.ini:/usr/local/etc/php/conf.d/uploads.ini'
    restart: always
    depends_on:
      - mysqldb0
    networks:
      - mysqldb0
      - net

En este punto, tiene la configuración para configurar una única instancia de WordPress. Para configurar más, repite los pasos 3 y 4 con nuevos nombres.

Aquí tienes:

Contenedor de base de datos para el segundo sitio de WordPress

  mysqldb1:
    image: mysql:5.7
    environment:
      MYSQL_DATABASE: db1
      MYSQL_USER: db1user
      MYSQL_PASSWORD: secret
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - 'mysqldb1:/var/lib/mysql'
    restart: always
    networks:
      - mysqldb1

Segundo contenedor de WordPress

  wordpress1:
    image: wordpress:5.8.0-php8.0-apache
    environment:
      WORDPRESS_DB_HOST: mysqldb1
      WORDPRESS_DB_USER: db1user
      WORDPRESS_DB_PASSWORD: secret
      WORDPRESS_DB_NAME: db1
      WORDPRESS_CONFIG_EXTRA: |
        define('AUTOMATIC_UPDATER_DISABLED', true);
      VIRTUAL_HOST: wordpress.domain.com
      LETSENCRYPT_HOST: wordpress.domain.com
    volumes:
      - 'wordpress1:/var/www/html/wp-content'
      - './uploads.ini:/usr/local/etc/php/conf.d/uploads.ini'
    restart: always
    depends_on:
      - mysqldb1
    networks:
      - mysqldb1
      - net

Con su editor favorito, cree un docker-compose.yml archivo con todo el contenido discutido hasta este punto (más abajo se han incluido parámetros adicionales). Deberá editar los nombres de dominio y otros datos de credenciales en consecuencia. Toma, he usado Nano.

nano docker-compose.yml

version: '3.7'
services:
  nginx-proxy:
    image: jwilder/nginx-proxy
    container_name: nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - html:/usr/share/nginx/html
      - dhparam:/etc/nginx/dhparam
      - vhost:/etc/nginx/vhost.d
      - certs:/etc/nginx/certs:ro
      - /var/run/docker.sock:/tmp/docker.sock:ro
      - ./client_max_upload_size.conf:/etc/nginx/conf.d/client_max_upload_size.conf
      - ./www.domain.com:/etc/nginx/vhost.d/www.domain.com
    labels:
      - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy"
    restart: always
    networks:
      - net

  letsencrypt:
    image: jrcs/letsencrypt-nginx-proxy-companion
    container_name: lets-encrypt-proxy-companion
    depends_on:
      - "nginx-proxy"
    volumes:
      - certs:/etc/nginx/certs:rw
      - vhost:/etc/nginx/vhost.d
      - html:/usr/share/nginx/html
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      DEFAULT_EMAIL: [email protected]
    restart: always
    networks:
      - net

  mysqldb0:
    image: mysql:5.7
    environment:
      MYSQL_DATABASE: db0
      MYSQL_USER: db0user
      MYSQL_PASSWORD: secret
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - 'mysqldb0:/var/lib/mysql'
    restart: always
    networks:
      - mysqldb0


  wordpress0:
    image: wordpress:5.8.0-php8.0-apache
    environment:
      WORDPRESS_DB_HOST: mysqldb0
      WORDPRESS_DB_USER: db0user
      WORDPRESS_DB_PASSWORD: secret
      WORDPRESS_DB_NAME: db0
      WORDPRESS_CONFIG_EXTRA: |
        define('AUTOMATIC_UPDATER_DISABLED', true);
      VIRTUAL_HOST: domain.com,www.domain.com
      LETSENCRYPT_HOST: domain.com,www.domain.com
    volumes:
      - 'wordpress0:/var/www/html/wp-content'
      - './uploads.ini:/usr/local/etc/php/conf.d/uploads.ini'
    restart: always
    depends_on:
      - mysqldb0
    networks:
      - mysqldb0
      - net

  mysqldb1:
    image: mysql:5.7
    environment:
      MYSQL_DATABASE: db1
      MYSQL_USER: db1user
      MYSQL_PASSWORD: secret
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - 'mysqldb1:/var/lib/mysql'
    restart: always
    networks:
      - mysqldb1


  wordpress1:
    image: wordpress:5.8.0-php8.0-apache
    environment:
      WORDPRESS_DB_HOST: mariadb1
      WORDPRESS_DB_USER: db1user   
      WORDPRESS_DB_PASSWORD: secret
      WORDPRESS_DB_NAME: db1
      WORDPRESS_CONFIG_EXTRA: |
        define('AUTOMATIC_UPDATER_DISABLED', true);
      VIRTUAL_HOST: wordpress.linuxhindi.com
      LETSENCRYPT_HOST: wordpress.linuxhindi.com
    volumes:
      - 'wordpress1:/var/www/html/wp-content'
      - './uploads.ini:/usr/local/etc/php/conf.d/uploads.ini'
    restart: always
    depends_on:
      - mysqldb1
    networks:
      - mysqldb1
      - net

volumes:
  certs:
  html:
  vhost:
  dhparam:
  mysqldb0:
  wordpress0:
  mysqldb1:
  wordpress1:

networks:
  mysqldb0:
    internal: true
  mysqldb1:
    internal: true
  net:
    external: true

Tenga en cuenta que he asignado redes internas específicas solo para cada base de datos y su contenedor de WordPress correspondiente. Los contenedores de la base de datos no necesitan ver la net de Nginx red. net solo se requiere para los contenedores frontend de WordPress.

En nuestro artículo anterior sobre Discourse, utilicé el --volumes-from bandera para usar el nginx-proxy volúmenes del contenedor con letsencrypt . De la misma manera, el equivalente para la misma bandera fue volumes_from , eliminado por Docker hace bastante tiempo. Por lo tanto, he especificado explícitamente los volúmenes comunes para los contenedores Nginx y Let's Encrypt dentro de docker-compose.yml archivo, a saber, certificados , html , host virtual y /var/run/docker.sock .

Ahora, implemente la configuración con el siguiente docker-compose comando desde el mismo multi-wordpress directorio que creamos al principio:

docker-compose up -d

Obtendrá las siguientes confirmaciones:

Creating network "multi-wordpress_mysqldb0" with the default driver
Creating network "multi-wordpress_mysqldb1" with the default driver
Creating volume "multi-wordpress_certs" with default driver
Creating volume "multi-wordpress_html" with default driver
Creating volume "multi-wordpress_vhost" with default driver
Creating volume "multi-wordpress_dhparam" with default driver
Creating volume "multi-wordpress_mysqldb0" with default driver
Creating volume "multi-wordpress_wordpress0" with default driver
Creating volume "multi-wordpress_mysqldb1" with default driver
Creating volume "multi-wordpress_wordpress1" with default driver
Creating multi-wordpress_mysqldb0_1   ... done
Creating nginx-proxy                  ... done
Creating multi-wordpress_mysqldb1_1 ... done
Creating multi-wordpress_wordpress1_1 ... done
Creating multi-wordpress_wordpress0_1 ... done
Creating lets-encrypt-proxy-companion ... done

Los dos primeros son las redes internas, seguidos de los volúmenes y finalmente los contenedores. Nuestra red externa net ya existe, ya que lo creé manualmente al principio de este tutorial.

Espere unos momentos. Abra su navegador de Internet y escriba www.domain.com . Se redirigirá a domain.com y verá el asistente de configuración de WordPress esperándolo:

Seleccione su idioma preferido, haga clic en continuar y proceda con la reclamación de la administración de su sitio.

Para wordpress.domain.com , obtendrías el mismo resultado. Puede agregar más sitios de WordPress repitiendo los pasos 5 (servicio de base de datos) y 6 (servicio de WordPress), de acuerdo con la sintaxis similar que se muestra para los contenedores existentes. Además, no olvide revisar los volumes y networks sección en el archivo YAML en consecuencia.

Para cada nuevo sitio, se crearía un nuevo contenedor de WordPress y su correspondiente contenedor de base de datos MySQL. Si desea conocer los equivalentes de la línea de comandos del archivo docker-compose.yml anterior, puede explorarlo aquí.

Consejos para mantener sus instancias de WordPress autoalojadas

Aquí hay algunos consejos que lo ayudarán a mantener sus instancias de WordPress a largo plazo:

Supervise los registros de WordPress en tiempo real

Si desea verificar los registros de un contenedor de WordPress (digamos el primero descrito en este tutorial) mientras se implementa en tiempo real, puede ejecutar:

docker logs -f multi-wordpress_wordpress0_1

En caso de que desee solucionar problemas o saber qué sucede dentro de cualquier otro contenedor relevante para esta implementación, el uso eficiente de Docker Logs puede ser crucial:

Copia de seguridad y restauración de volúmenes de WordPress sin tiempo de inactividad

Usando un enfoque de nube + local, puede hacer una copia de seguridad y restaurar sus volúmenes de WordPress sin tiempo de inactividad.

Actualizar contenedores de WordPress sin tiempo de inactividad

Con la --scale flag en Docker Compose, puede crear un nuevo contenedor basado en la última versión de WordPress. Cuando haya terminado, puede eliminar el anterior. Esto da como resultado un tiempo de inactividad cero.

Espero que hayas encontrado útil este artículo. Si tiene alguna idea, comentario o sugerencia para compartir, háganoslo saber en los comentarios a continuación.


Linux

  1. Cómo configurar varios sitios web con el servidor web Apache

  2. Cómo instalar WordPress con Docker en Ubuntu

  3. Cómo implementar un servidor DNS dinámico con Docker en Debian 10

  4. ¿Cómo redirijo subdominios a un puerto diferente en el mismo servidor?

  5. múltiples interfaces físicas con IP en la misma subred

Cómo ejecutar diferentes versiones de PHP en el mismo servidor

Cómo instalar WordPress con Docker en Ubuntu 16.04 LTS

Cómo instalar varios contenedores de discursos en el mismo servidor

Cómo implementar el servidor de conferencias Jitsi Meet con Ubuntu 22.04

Cómo:Introducción a los contenedores de Windows y Docker

Cómo instalar WordPress en un servidor CentOS 8