Come ospitare autonomamente più siti WordPress sullo stesso server con Docker

Installare WordPress non è un grosso problema. Puoi installarlo utilizzando il server LAMP per lo sviluppo locale. Puoi anche distribuirlo per il mondo reale su un vero server Linux rivolto al pubblico.

I server cloud come Linode, DigitalOcean ecc. offrono anche la possibilità di implementare un nuovissimo server Linux preconfigurato con WordPress. Ancora più facile, vero?

Ma cosa succede se si desidera installare più di un WordPress su un singolo server?

Un modo semplice sarebbe utilizzare un servizio come ServerPilot. Non solo aggiorna automaticamente il tuo server, ma ti consente anche di distribuire facilmente più istanze di WordPress sullo stesso server.

Ciò ti costerebbe un po' più di denaro e, se non lo desideri, puoi utilizzare Docker per distribuire più istanze di WordPress.

Attraverso questa guida imparerai come configurare facilmente una doppia configurazione di WordPress in esecuzione dai loro contenitori individuali e aggiungere più istanze!

Prerequisiti

Non è obbligatorio, ma il tutorial sarà molto più facile da seguire se hai:

• Conoscenza dei comandi di base di Linux
• Una certa conoscenza di Docker
• Comprensione di Docker Compose

Distribuirai WordPress dietro un container proxy inverso, con dominio e sottodomini abilitati SSL.

Oltre alle suddette conoscenze di attualità, avrai bisogno dei seguenti requisiti di infrastruttura:

• Un server Ubuntu Linux rivolto al pubblico . Puoi utilizzare un provider di servizi cloud come Linode. Un server Nano con 1 GB di RAM sarà sufficiente per questa distribuzione. Ma se prevedi di ospitare autonomamente più istanze di WordPress, valuta la possibilità di aggiornarlo.
• Accesso ai tuoi domini/sottodomini e alle relative impostazioni DNS
• Docker e Docker Compose installati sul tuo server Linux.

Se hai bisogno di aiuto, puoi seguire le nostre guide su:

• Installazione di Docker su Ubuntu
• Installazione di Docker Compose su Ubuntu
• Configurazione della finestra mobile del proxy inverso

In tutti gli altri nostri tutorial basati su applicazioni Web self-hosting con Docker, ho discusso della distribuzione di contenitori Nginx e contenitori di app Web separatamente. Questa volta, tuttavia, utilizzerò Docker Compose per configurare più contenitori di WordPress, tutti basati su un singolo file yml.

Quindi questo è anche un esempio per mostrarti come integrare una configurazione Nginx con un'app Web che consideri di implementare, tramite un unico file Docker Compose.

Utilizzerò domain.com come esempio per il primo blog WordPress e wordpress.domain.com come il secondo blog self-hosted. Alla fine, descriverò anche come aggiungere più istanze di WordPress in base alla configurazione di cui parlerò qui.

Imposta una directory di lavoro per tutti i servizi correlati a WordPress

Crea una directory e rendila attiva. Chiamiamolo multi-wordpress .

mkdir multi-wordpress

E poi passa a questa directory appena creata usando il comando cd:

cd multi-wordpress

Imposta il limite di caricamento dei file WordPress su 512 MB

All'interno di questa directory, memorizzeremo il nostro uploads.ini file con la configurazione di caricamento necessaria per caricare file di dimensioni fino a 512 MB. Immettere il seguente comando sul terminale:

[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

Imposta un limite di caricamento file per Nginx

Come misura aggiuntiva, crea anche un file chiamato client_max_upload_size.conf e salvalo nella stessa directory per il montaggio nel contenitore Nginx. Per il gusto di farlo, l'ho impostato come 1 GB. Questo è utile per configurare altre app in futuro.

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

Reindirizzamento WWW tramite Nginx (aggiornamento CNAME non richiesto)

Se desideri utilizzare il reindirizzamento da non www a www con WordPress, puoi impostare il redirector con il comando cat sul tuo server Linux:

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

Premi Invio e poi Ctrl+D per salvarlo. Non abbiamo utilizzato printf qui perché $1 non verrà salvato nel file come mostrato sopra. Ciò potrebbe causare problemi futuri con gli URL, poiché desideriamo che il reindirizzamento funzioni in tutti i casi. Ad esempio, domain.com/test dovrebbe sempre reindirizzare a www.domain.com/test .

Reindirizzamento non WWW tramite Nginx (aggiornamento CNAME non richiesto)

Se desideri utilizzare il reindirizzamento da www a non www, ripeti passaggi simili per fare il contrario:

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

Crea una rete Docker esterna

Userò una rete chiamata net per questo tutorial. Pertanto, lo creo con il seguente comando:

docker network create net

Preparazione di un singolo file Docker Compose pronto per la distribuzione

Con la seguente configurazione all'interno di un singolo docker-compose.yml file, puoi configurare tutto in una volta con tutti e sei i contenitori che servono al tuo scopo, a partire dal proxy inverso all'ultimo contenitore di WordPress. Esaminiamoli servizio per servizio prima di unirli finalmente tutti in un unico file:

Contenitore proxy inverso Nginx

Monta entrambi i file client_max_upload_size.conf e www.domain.com in modalità di sola lettura e specificare la rete net che è stato creato 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

Crittografia contenitore per certificati SSL

Nota che uso rw per i certs volume, a differenza di ro nella sezione precedente. Ciò è essenziale per creare i certificati SSL e aggiornare il volume di conseguenza man mano che vengono generati. Inoltre, imposta l'e-mail predefinita per le notifiche da Let's Encrypt e specifica lo stesso “net ” rete.

  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

Contenitore di database per il primo sito WordPress

Sulla base della configurazione ufficiale di WordPress Docker Compose, imposta le variabili di ambiente necessarie come mostrato di seguito e specifica una rete interna (vista come mysqldb0 qui, utilizzato anche per il nome del servizio e il nome del volume).

Questa rete sarà visibile solo al contenitore del database e al relativo contenitore WordPress. Quando lo distribuisci, verrà creato un database MySQL con le credenziali mostrate come sotto:

  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

Primo container WordPress

Quando distribuisci il container WordPress, utilizzerà la configurazione del database specificata nella sezione precedente sopra. Nota che oltre alla stessa rete interna vista dal database (mysqldb0 ), questo servizio WordPress deve anche vedere la rete Nginx chiamata net poiché è l'applicazione frontend per il mondo esterno.

  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

A questo punto, hai la configurazione per configurare una singola istanza di WordPress. Per impostarne di più, replica i passaggi 3 e 4 con nuovi nomi.

Ecco a te:

Contenitore di database per il secondo sito 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

Secondo contenitore 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 il tuo editor preferito, crea un docker-compose.yml file con tutto il contenuto discusso fino a questo punto (di seguito sono stati inclusi parametri aggiuntivi). Dovresti modificare di conseguenza i nomi di dominio e altri dati delle credenziali. Qui ho usato 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

Nota che ho assegnato reti interne specifiche solo per ciascun database e il relativo contenitore WordPress. I contenitori del database non devono vedere Nginx net Rete. net è richiesto solo per i contenitori di WordPress frontend.

Nel nostro precedente articolo su Discourse, ho usato il --volumes-from flag per utilizzare il nginx-proxy volumi del contenitore con letsencrypt . Allo stesso modo, l'equivalente per lo stesso flag era volumes_from , rimosso da Docker parecchio tempo fa. Pertanto, ho specificato esplicitamente i volumi comuni per i contenitori Nginx e Let's Encrypt all'interno di docker-compose.yml file, ovvero certs , html , host virtuale e /var/run/docker.sock .

Ora, distribuisci la configurazione con il seguente docker-compose comando dallo stesso multi-wordpress directory che abbiamo creato all'inizio:

docker-compose up -d

Riceverai le seguenti conferme:

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

Le prime due sono le reti interne, seguite dai volumi e infine dai container. La nostra rete esterna net esiste già, poiché l'ho creato manualmente all'inizio di questo tutorial.

Aspetta qualche istante. Apri il tuo browser Internet e digita www.domain.com . Verrà reindirizzato a domain.com e vedrai la procedura guidata di configurazione di WordPress che ti aspetta:

Seleziona la tua lingua preferita, clicca su continua e procedi con la rivendicazione dell'amministrazione del tuo sito.

Per wordpress.domain.com , otterresti lo stesso risultato. Puoi aggiungere più siti WordPress ripetendo i passaggi 5 (servizio database) e 6 (servizio WordPress), secondo la sintassi simile a quella mostrata per i contenitori esistenti. Inoltre, non dimenticare di rivedere i volumes e networks sezione nel file YAML di conseguenza.

Per ogni nuovo sito, verrebbe creato un nuovo contenitore WordPress e il corrispondente contenitore del database MySQL. Se vuoi conoscere gli equivalenti della riga di comando del file docker-compose.yml sopra, puoi esplorarlo qui.

Suggerimenti per la manutenzione delle istanze WordPress self-hosted

Ecco alcuni suggerimenti che ti aiuteranno a mantenere le tue istanze WordPress a lungo termine:

Monitoraggio dei log di WordPress in tempo reale

Se vuoi controllare i log di un container WordPress (diciamo il primo descritto in questo tutorial) mentre è distribuito in tempo reale, puoi eseguire:

docker logs -f multi-wordpress_wordpress0_1

Nel caso in cui desideri risolvere i problemi o scoprire cosa sta succedendo all'interno di ogni altro container rilevante per questa distribuzione, l'utilizzo efficiente dei Docker Log può essere fondamentale:

Backup e ripristino dei volumi di WordPress senza tempi di inattività

Utilizzando un approccio cloud + locale, puoi eseguire il backup e il ripristino dei tuoi volumi WordPress senza tempi di inattività.

Aggiorna i contenitori di WordPress senza tempi di inattività

Con il --scale flag su Docker Compose, puoi creare un nuovo contenitore basato sull'ultima versione di WordPress. Al termine, puoi rimuovere quello vecchio. Ciò si traduce in zero tempi di inattività.

Spero che tu abbia trovato utile questo articolo. Se hai pensieri, feedback o suggerimenti da condividere, faccelo sapere nei commenti qui sotto.