Comment auto-héberger plusieurs sites WordPress sur le même serveur avec Docker

L'installation de WordPress n'est pas un gros problème. Vous pouvez l'installer en utilisant le serveur LAMP pour le développement local. Vous pouvez également le déployer pour le monde réel sur un serveur Linux public approprié.

Les serveurs cloud comme Linode, DigitalOcean, etc. offrent également la possibilité de déployer un tout nouveau serveur Linux préconfiguré avec WordPress. Encore plus simple, non ?

Mais que se passe-t-il si vous souhaitez installer plus d'un WordPress sur un seul serveur ?

Un moyen simple serait d'utiliser un service comme ServerPilot. Non seulement il met à jour votre serveur automatiquement, mais il vous permet également de déployer facilement plusieurs instances WordPress sur le même serveur.

Cela vous coûterait un peu plus d'argent et si vous ne le souhaitez pas, vous pouvez utiliser Docker pour déployer plusieurs instances WordPress.

Grâce à ce guide, vous apprendrez à configurer facilement une configuration WordPress double fonctionnant à partir de leurs conteneurs individuels et à ajouter d'autres instances !

Prérequis

Ce n'est pas obligatoire, mais le tutoriel vous sera beaucoup plus facile à suivre si vous avez :

Connaissance des commandes Linux de base
Connaissance de Docker
Compréhension de Docker Compose

Vous allez déployer WordPress derrière un conteneur de proxy inverse, avec un domaine et des sous-domaines compatibles SSL.

Outre les connaissances thématiques susmentionnées, vous aurez besoin des exigences d'infrastructure suivantes :

Un serveur Ubuntu Linux accessible au public . Vous pouvez utiliser un fournisseur de services cloud comme Linode. Un serveur Nano avec 1 Go de RAM suffira pour ce déploiement. Mais si vous prévoyez d'héberger vous-même plus d'instances WordPress, envisagez de le mettre à niveau.
Accès à vos domaines/sous-domaines et à leurs paramètres DNS
Docker et Docker Compose installés sur votre serveur Linux.

Si vous avez besoin d'aide, vous pouvez suivre nos guides sur :

Installer Docker sur Ubuntu
Installer Docker Compose sur Ubuntu
Configuration du docker proxy inverse

Dans tous nos autres tutoriels basés sur les applications Web auto-hébergées avec Docker, j'ai discuté du déploiement des conteneurs Nginx et des conteneurs d'applications Web séparément. Cette fois, cependant, j'utiliserai Docker Compose pour configurer plusieurs conteneurs WordPress, tous basés sur un seul fichier yml.

Il s'agit donc également d'un exemple pour vous montrer comment vous pouvez intégrer une configuration Nginx à une application Web que vous envisagez de déployer, via un seul fichier Docker Compose.

J'utiliserai domain.com comme exemple pour le premier blog WordPress et wordpress.domain.com en tant que deuxième blog auto-hébergé. À la fin, je décrirai également comment ajouter d'autres instances WordPress en fonction de la configuration dont je vais parler ici.

Créez un répertoire et rendez-le actif. Appelons-le multi-wordpress .

mkdir multi-wordpress

Et puis basculez vers ce répertoire nouvellement créé à l'aide de la commande cd :

cd multi-wordpress

Définir la limite de téléchargement de fichiers WordPress à 512 Mo

Dans ce répertoire, nous stockerons notre uploads.ini fichier qui a la configuration de téléchargement nécessaire pour télécharger des fichiers d'une taille maximale de 512 Mo. Saisissez la commande suivante sur le 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

Définir une limite de téléchargement de fichiers pour Nginx

Comme mesure supplémentaire, créez également un fichier appelé client_max_upload_size.conf et enregistrez-le dans le même répertoire pour le montage dans le conteneur Nginx. Pour le plaisir, je l'ai défini sur 1 Go. Ceci est utile pour configurer d'autres applications à l'avenir.

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

Redirection WWW via Nginx (mise à jour CNAME non requise)

Si vous souhaitez utiliser une redirection autre que www vers www avec WordPress, vous pouvez définir le redirecteur avec la commande cat sur votre serveur Linux :

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

Appuyez sur Entrée puis sur Ctrl+D pour l'enregistrer. Nous n'avons pas utilisé printf ici parce que $1 ne sera pas enregistré dans le fichier comme indiqué ci-dessus. Cela pourrait entraîner de futurs problèmes avec les URL, car nous voulons que la redirection fonctionne dans tous les cas. Par exemple, domain.com/test doit toujours rediriger vers www.domain.com/test .

redirection non-WWW via Nginx (mise à jour de CNAME non requise)

Si vous souhaitez utiliser la redirection www vers non-www, répétez les étapes similaires pour faire le contraire :

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

Créer un réseau Docker externe

J'utiliserai un réseau appelé net pour ce tutoriel. Par conséquent, je le crée avec la commande suivante :

docker network create net

Préparation d'un seul fichier Docker Compose prêt pour le déploiement

Avec la configuration suivante dans un seul docker-compose.yml fichier, vous pouvez tout configurer en une seule fois avec les six conteneurs qui servent votre objectif, en commençant par le proxy inverse jusqu'au dernier conteneur WordPress. Examinons-les service par service avant de finalement tous les fusionner en un seul fichier :

Conteneur de proxy inverse Nginx

Montez les deux fichiers client_max_upload_size.conf et www.domain.com en lecture seule et indiquez le réseau net qui a été créé manuellement.

  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

Chiffrons le conteneur pour les certificats SSL

Notez que j'utilise rw pour les certs volume, contrairement à ro dans la section précédente. Ceci est essentiel pour créer les certificats SSL et mettre à jour le volume en conséquence au fur et à mesure qu'ils sont générés. Définissez également l'e-mail par défaut pour les notifications de Let's Encrypt et spécifiez le même "net ” réseau.

  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

Conteneur de base de données pour le premier site WordPress

Sur la base de la configuration officielle de WordPress Docker Compose, définissez les variables d'environnement nécessaires comme indiqué ci-dessous et spécifiez un réseau interne (vu comme mysqldb0 ici, utilisé pour le nom du service et le nom du volume également).

Ce réseau ne sera visible que pour le conteneur de base de données et son conteneur WordPress correspondant. Lorsque vous le déployez, une base de données MySQL sera créée avec les informations d'identification indiquées ci-dessous :

  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

Premier conteneur WordPress

Lorsque vous déployez le conteneur WordPress, il utilise la configuration de base de données spécifiée dans la section précédente ci-dessus. Notez qu'en plus du même réseau interne vu par la base de données (mysqldb0 ), ce service WordPress doit également voir le réseau Nginx appelé net puisqu'il s'agit de l'application frontale pour le monde extérieur.

  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

À ce stade, vous avez la configuration pour configurer une seule instance WordPress. Pour en configurer davantage, répliquez les étapes 3 et 4 avec de nouveaux noms.

Voilà :

Conteneur de base de données pour le deuxième site 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

Deuxième conteneur 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

Avec votre éditeur préféré, créez un docker-compose.yml fichier avec tout le contenu discuté jusqu'à présent (des paramètres supplémentaires ont été inclus ci-dessous). Vous auriez besoin de modifier les noms de domaine et d'autres données d'identification en conséquence. Ici, j'ai utilisé 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

Notez que j'ai attribué des réseaux internes spécifiques uniquement pour chaque base de données et son conteneur WordPress correspondant. Les conteneurs de base de données n'ont pas besoin de voir le net Nginx réseau. net est requis uniquement pour les conteneurs WordPress frontaux.

Dans notre précédent article sur Discourse, j'ai utilisé le --volumes-from flag pour utiliser le nginx-proxy volumes du conteneur avec letsencrypt . De la même manière, l'équivalent pour le même drapeau était volumes_from , supprimé par Docker il y a un certain temps. Par conséquent, j'ai explicitement spécifié les volumes communs pour les conteneurs Nginx et Let's Encrypt dans le docker-compose.yml fichier - à savoir, certs , html , hôte virtuel et /var/run/docker.sock .

Maintenant, déployez la configuration avec le docker-compose suivant commande du même multi-wordpress répertoire que nous avons créé au début :

docker-compose up -d

Vous obtiendrez les confirmations suivantes :

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

Les deux premiers sont les réseaux internes, suivis des volumes et enfin des conteneurs. Notre réseau externe net existe déjà, car je l'ai créé manuellement au début de ce tutoriel.

Attendez quelques instants. Ouvrez votre navigateur Internet et tapez www.domain.com . Il redirigera vers domain.com et vous verrez l'assistant de configuration de WordPress qui vous attend :

Sélectionnez votre langue préférée, cliquez sur Continuer et continuez à réclamer l'administration de votre site.

Pour wordpress.domain.com , vous obtiendriez le même résultat. Vous pouvez ajouter d'autres sites WordPress en répétant les étapes 5 (service de base de données) et 6 (service WordPress), selon la syntaxe similaire à celle indiquée pour les conteneurs existants. N'oubliez pas non plus de réviser les volumes et networks section dans le fichier YAML en conséquence.

Pour chaque nouveau site, un nouveau conteneur WordPress et son conteneur de base de données MySQL correspondant seraient créés. Si vous souhaitez connaître les équivalents en ligne de commande du fichier docker-compose.yml ci-dessus, vous pouvez l'explorer ici.

Conseils pour maintenir vos instances WordPress auto-hébergées

Voici quelques conseils qui vous aideront à maintenir vos instances WordPress sur le long terme :

Surveiller les journaux WordPress en temps réel

Si vous souhaitez vérifier les journaux d'un conteneur WordPress (disons le premier décrit dans ce tutoriel) pendant son déploiement en temps réel, vous pouvez exécuter :

docker logs -f multi-wordpress_wordpress0_1

Si vous souhaitez dépanner ou savoir ce qui se passe dans tous les autres conteneurs pertinents pour ce déploiement, l'utilisation efficace de Docker Logs peut être cruciale :

Sauvegarder et restaurer des volumes WordPress sans temps d'arrêt

En utilisant une approche cloud + locale, vous pouvez sauvegarder et restaurer vos volumes WordPress sans temps d'arrêt.

Mettre à jour les conteneurs WordPress sans temps d'arrêt

Avec le --scale flag sur Docker Compose, vous pouvez créer un nouveau conteneur basé sur la dernière version de WordPress. Lorsque c'est fait, vous pouvez supprimer l'ancien. Cela se traduit par zéro temps d'arrêt.

J'espère que vous avez trouvé cet article utile. Si vous avez des idées, des commentaires ou des suggestions à partager, veuillez nous en informer dans les commentaires ci-dessous.