Ricerca nel sito web

Come installare WordPress con Docker Compose

Questo tutorial esiste per queste versioni del sistema operativo

  • Ubuntu 22.04 (Jammy Jellyfish)
  • Ubuntu 16.04 (Xenial Xerus)

Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall
  3. Passaggio 2 - Installa Docker e Docker Compose
  4. Passaggio 3 - Crea il file Docker Compose per WordPress
  5. Passaggio 4 - Aggiorna Docker Compose per Nginx
  6. Passaggio 5 - Aggiorna Docker Compose per SSL
  7. Passaggio 6: avvia e installa WordPress
  8. Passaggio 7 - Accedi a PhpMyAdmin
  9. Passaggio 8 - Accedi a WP-CLI
  10. Passaggio 9 - Backup di WordPress
  11. Passaggio 10 - Aggiorna WordPress
  12. Conclusione

WordPress è la piattaforma di blogging più popolare al mondo. Esistono molti modi per installare WordPress, inclusi i comandi Shell, l'installazione manuale utilizzando gli script o utilizzando un programma di installazione Web fornito da host Web popolari. L'esecuzione di WordPress comporta l'installazione di uno stack LAMP (Linux, Apache, MySQL e PHP) o LEMP (Linux, Nginx, MySQL e PHP).

Questo tutorial ti insegnerà come installare WordPress usando Docker/Docker Compose. Utilizzando Docker, il processo di installazione dello stack preferito diventa molto più semplice. Puoi utilizzare la stessa configurazione per installare rapidamente WordPress su più server. Installeremo anche lo strumento phpMyAdmin per la gestione dei database insieme al server proxy Nginx per servire il sito tramite SSL.

Prerequisiti

  • A Linux server with a non-root user having sudo privileges. We are using a server running Ubuntu 22.04 for our tutorial.

  • A fully qualified domain name (FQDN) pointing to your server. For our purposes, we will use example.com as the domain name for the WordPress site and phpmyadmin.example.com for the phpMyAdmin website.

  • Make sure everything is updated. 

    $ sudo apt update

  • Install basic utility packages. Some of them may already be installed. 

    $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

Passaggio 1: configurare il firewall

Il primo passo è configurare il firewall. Ubuntu viene fornito con ufw (Uncomplicated Firewall) per impostazione predefinita.

Controlla se il firewall è in esecuzione.

$ sudo ufw status

Dovresti ottenere il seguente output.

Status: inactive

Consenti porta SSH in modo che il firewall non interrompa la connessione corrente attivandola.

$ sudo ufw allow OpenSSH

Consenti anche porte HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Abilita il firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Controlla di nuovo lo stato del firewall.

$ sudo ufw status

Dovresti vedere un output simile.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Passaggio 2: installa Docker e Docker Compose

Ubuntu 22.04 viene fornito con una versione precedente di Docker. Per installare la versione più recente, importa innanzitutto la chiave GPG di Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Crea un file di repository Docker.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aggiorna l'elenco dei repository di sistema.

$ sudo apt update

Installa l'ultima versione di Docker.

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Verificare che sia in esecuzione.

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Mon 2023-01-09 13:19:16 UTC; 9s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 1863 (dockerd)
      Tasks: 7
     Memory: 20.5M
        CPU: 278ms
     CGroup: /system.slice/docker.service
             ??1863 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Per impostazione predefinita, Docker richiede i privilegi di root. Se vuoi evitare di usare sudo ogni volta che esegui il comando docker, aggiungi il tuo nome utente alla docker gruppo.

$ sudo usermod -aG docker $(whoami)

Sarà necessario disconnettersi dal server e riconnettersi come lo stesso utente per abilitare questa modifica o utilizzare il seguente comando.

$ su - ${USER}

Verifica che il tuo utente sia stato aggiunto al gruppo Docker.

$ groups
navjot wheel docker

Passaggio 3: crea il file Docker Compose per WordPress

Crea una directory per la configurazione di WordPress.

$ mkdir wordpress

Passa alla rubrica.

$ cd wordpress

Crea e apri il file di composizione Docker per la modifica.

$ nano docker-compose.yml

Incolla il seguente codice al suo interno.

version: '3.9'

services:
  wp:
    image: wordpress:latest
    container_name: wordpress-app
    restart: unless-stopped
    expose:
      - 8080
    volumes:
      - ./config/php.conf.ini:/usr/local/etc/php/conf.d/conf.ini
      - ./wp-app:/var/www/html
      #- ./plugin-name/trunk/:/var/www/html/wp-content/plugins/plugin-name # Plugin development
      #- ./theme-name/trunk/:/var/www/html/wp-content/themes/theme-name # Theme development
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_NAME: "${DB_NAME}"
      WORDPRESS_DB_USER: "${DB_USER_NAME}"
      WORDPRESS_DB_PASSWORD: "${DB_USER_PASSWORD}"
      VIRTUAL_HOST: example.com
      LETSENCRYPT_HOST: example.com
    depends_on:
      - db
    links:
      - db

  wpcli:
    image: wordpress:cli
    container_name: wpcli_app
    volumes:
      - ./config/php.conf.ini:/usr/local/etc/php/conf.d/conf.ini
      - ./wp-app:/var/www/html
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_NAME: "${DB_NAME}"
      WORDPRESS_DB_USER: "${DB_USER_NAME}"
      WORDPRESS_DB_PASSWORD: "${DB_USER_PASSWORD}"
    depends_on:
      - db
      - wp

  pma:
    image: phpmyadmin/phpmyadmin
    container_name: pma
    restart: unless-stopped
    environment:
      # https://docs.phpmyadmin.net/en/latest/setup.html#docker-environment-variables
      PMA_HOST: db
      PMA_PORT: 3306
      MYSQL_ROOT_PASSWORD: "${DB_ROOT_PASSWORD}"
      UPLOAD_LIMIT: 50M
      VIRTUAL_HOST: phpmyadmin.example.com
      LETSENCRYPT_HOST: phpmyadmin.example.com
    expose:
      - 8081
    links:
      - db:db

  db:
    image: mysql:latest
    container_name: wordpressdb
    restart: unless-stopped
    command: [
        '--default_authentication_plugin=mysql_native_password',
        '--character-set-server=utf8mb4',
        '--collation-server=utf8mb4_unicode_ci'
    ]
    volumes:
      - ./wp-data:/docker-entrypoint-initdb.d
      - db_data:/var/lib/mysql
    environment:
      MYSQL_DATABASE: "${DB_NAME}"
      MYSQL_ROOT_PASSWORD: "${DB_ROOT_PASSWORD}"
      MYSQL_USER: "${DB_USER_NAME}"
      MYSQL_PASSWORD: "${DB_USER_PASSWORD}"

volumes:
  db_data:

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Ci sono due immagini di WordPress che stiamo estraendo. Uno è per il sito Web e uno è per lo strumento WP-CLI. Entrambe le immagini dipendono dall'immagine docker di MySQL 8.0. Qui impostiamo le variabili di ambiente per le credenziali del database. Abbiamo creato due volumi per entrambi i contenitori, uno dei quali punta ai file pubblici per il sito WordPress e il secondo punta alla posizione PHP.ini personalizzata. Abbiamo anche definito le variabili di ambiente per il dominio host virtuale Nginx e il dominio SSL Lets encrypt per il sito WordPress.

Puoi aggiungere più variabili di ambiente e aggiungere dati wp-config.php personalizzati al file Docker. Puoi conoscere le variabili di ambiente aggiuntive dalla pagina DockerHub di WordPress.

L'immagine successiva è per phpMyAdmin che dipende dalla stessa immagine MySQL e la connette utilizzando la password di root. Ha un limite di caricamento di 50 MB. Puoi cambiarlo in base alle tue esigenze e alle dimensioni del tuo database. Come per il sito WordPress, abbiamo definito il dominio host virtuale Nginx e crittografiamo il nome di dominio SSL per il sito phpMyAdmin.

L'ultima immagine è per il database MySQL. Gli abbiamo passato alcuni comandi per impostare il metodo di autenticazione predefinito e il set di caratteri. Abbiamo anche creato un paio di volumi per l'archiviazione dei dati. Abbiamo anche impostato le variabili di ambiente per le credenziali del database.

Il passaggio successivo consiste nel creare il file di ambiente per le variabili utilizzate nel file di composizione. Crea e apri il file dell'ambiente per la modifica.

$ sudo nano .env

Incolla il seguente codice al suo interno.

DB_NAME=wordpress
DB_USER_NAME=username
DB_USER_PASSWORD=userpassword
DB_ROOT_PASSWORD=password

Salva il file premendo Ctrl + X e immettendo Y quando richiesto. Sostituisci le variabili con il nome utente e la password di tua scelta.

È possibile personalizzare la configurazione PHP utilizzando un file php.ini personalizzato.

Crea una cartella per la configurazione PHP.

$ mkdir config

Crea e apri il file php.conf.ini per la modifica.

$ nano config/php.conf.ini

Incolla il seguente codice al suo interno. Regola i valori in base alle tue esigenze. Il limite di caricamento per il contenitore PhpMyadmin è indipendente dai valori utilizzati in questo file.

file_uploads = On
memory_limit = 500M
upload_max_filesize = 30M
post_max_size = 30M
max_execution_time = 600

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Passaggio 4: aggiorna Docker Compose per Nginx

Crea la directory per la configurazione di Nginx.

$ mkdir nginx

Crea una directory per gli host virtuali all'interno di quella directory.

$ mkdir nginx/vhost

Crea e apri nginx/vhost/wordpress.example.com per la modifica.

$ nano nginx/vhost/wordpress.example.com

Incolla il seguente codice al suo interno.

server_tokens off;
client_max_body_size 30m;

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Fai lo stesso per il file nginx/vhost/phpmyadmin.example.com.

$ nano nginx/vhost/phpmyadmin.example.com

Incolla il seguente codice al suo interno.

server_tokens off;
client_max_body_size 50m;

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Apri di nuovo il file di composizione della finestra mobile.

$ nano docker-compose.yml

Incolla il seguente codice prima della riga volumes: db_data:.

nginx:
    container_name: nginx
    image: nginxproxy/nginx-proxy
    restart: unless-stopped
    ports:
        - 80:80
        - 443:443
    volumes:
        - /var/run/docker.sock:/tmp/docker.sock:ro
        - ./nginx/html:/usr/share/nginx/html
        - ./nginx/certs:/etc/nginx/certs
        - ./nginx/vhost:/etc/nginx/vhost.d
    logging:
        options:
            max-size: "10m"
            max-file: "3"

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Nel codice sopra, estraiamo l'immagine Docker del proxy Nginx ed esponiamo le porte 80 e 443 al contenitore host che verrà utilizzato per connettersi al mondo esterno. Abbiamo anche creato volumi per la pagina HTML Nginx, una directory in cui verranno archiviati tutti i certificati SSL e la directory per gli host virtuali che è quella che abbiamo usato sopra per aggiungere ulteriore configurazione nginx. Qui abbiamo configurato la dimensione di caricamento del file per i siti WordPress e phpMyAdmin. Il nome di dominio per i siti viene scelto dalle variabili di ambiente che abbiamo definito nel passaggio precedente.

Passaggio 5: aggiornare Docker Compose per SSL

Apri il file di composizione della finestra mobile per la modifica.

$ nano docker-compose.yml

Incolla il seguente codice prima della riga volumes: db_data:.

acme-companion:
    container_name: acme-companion
    image: nginxproxy/acme-companion
    restart: unless-stopped
    volumes_from:
        - nginx
    volumes:
        - /var/run/docker.sock:/var/run/docker.sock
        - ./nginx/acme:/etc/acme.sh
    environment:
        DEFAULT_EMAIL:

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Qui stiamo estraendo l'immagine Docker del compagno Acme che funziona insieme al proxy Nginx. Estrae i volumi dal contenitore Nginx. Definiamo anche un volume per lo strumento acme.sh che memorizza tutta la configurazione relativa a Lets encrypt SSL. Infine, definiamo una variabile di ambiente per registrare il certificato SSL con Lets Encrypt.

Passaggio 6: avvia e installa WordPress

Ora che tutti i nostri file di configurazione sono completi, è il momento di avviare e lanciare i contenitori.

$ docker compose up -d

Attendi un paio di minuti e controlla lo stato dei contenitori.

$ docker ps
CONTAINER ID   IMAGE                       COMMAND                  CREATED          STATUS          PORTS                                                                      NAMES
c1e8a9b5169d   nginxproxy/acme-companion   "/bin/bash /app/entr…"   14 seconds ago   Up 7 seconds                                                                               acme-companion
8a37c78ff790   wordpress:latest            "docker-entrypoint.s…"   14 seconds ago   Up 7 seconds    80/tcp, 8080/tcp                                                           wordpress-app
4f9c777c97c2   phpmyadmin/phpmyadmin       "/docker-entrypoint.…"   14 seconds ago   Up 7 seconds    80/tcp, 8081/tcp                                                           pma
1b1dede46b07   nginxproxy/nginx-proxy      "/app/docker-entrypo…"   14 seconds ago   Up 11 seconds   0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   nginx
b9cf64a2f4a3   mysql:latest                "docker-entrypoint.s…"   14 seconds ago   Up 11 seconds   3306/tcp, 33060/tcp                                                        wordpressdb

Apri l'URL https://example.com per avviare il programma di installazione di WordPress.

Seleziona la lingua e fai clic sul pulsante Continua per passare alla pagina successiva.

Compila i dettagli del sito, scegli il nome utente, la password e l'indirizzo e-mail e fai clic sul pulsante Installa WordPress per avviare l'installazione.

Verrai indirizzato alla pagina di successo dell'installazione. Fare clic sul pulsante Accedi per accedere alla pagina di accesso.

Inserisci i tuoi dati di accesso e fai clic sul pulsante Accedi per aprire la dashboard di WordPress.

Puoi iniziare a utilizzare WordPress ora.

Passaggio 7: accedi a PhpMyAdmin

Puoi accedere a phpMyAdmin tramite l'URL https://phpmyadmin.example.com.

Inserisci root come nome utente e password root e fai clic su Accedi per aprire la dashboard.

Puoi iniziare a utilizzare phpMyAdmin ora.

Passaggio 8: accedere a WP-CLI

È possibile accedere a WP-CLI utilizzando il seguente comando.

$ docker compose run --rm wpcli cli version

Otterrai il seguente output.

[+] Running 2/0
 ? Container wordpressdb    Running                                                                                0.0s
 ? Container wordpress-app  Running                                                                                0.0s
WP-CLI 2.7.1

Per evitare di digitare ogni volta un comando così lungo, possiamo utilizzare la funzione alias di Linux.

$ alias wp="docker compose -f ~/wordpress/docker-compose.yml run --rm wpcli"

Ora puoi digitare il seguente comando da qualsiasi punto del tuo contenitore.

$ wp cli version

Gli alias in Linux sono temporanei. Per rendere permanente l'alias, devi modificare il file ~/.bashrc. Aprilo per la modifica.

$ nano ~/.bashrc

Incolla la seguente riga alla fine del file.

# Custom aliases
alias wp="docker compose -f ~/wordpress/docker-compose.yml run --rm wpcli"

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Originare il file per ricaricare la configurazione.

$ source ~/.bashrc

Puoi iniziare a usare WP-CLI.

Passaggio 9: eseguire il backup di WordPress

Esistono diversi modi per eseguire il backup di WordPress. Il modo più semplice è usare un plugin. Ci sono diversi plugin disponibili per questo. Puoi anche utilizzare phpMyAdmin per creare un backup.

Puoi anche utilizzare la riga di comando per eseguire il backup del database di WordPress. Passa alla directory di WordPress.

$ cd ~/wordpress

Utilizzare il seguente comando per eseguire il backup del database di WordPress. Ti verrà chiesta la tua password di root MySQL.

$ docker compose exec db sh -c "exec mysqldump wordpress -uroot -p" | sudo tee wp-data/data_`date +%d-%m-%Y"_"%H_%M_%S`.sql >/dev/null
Enter password: password

Il comando precedente creerà il backup SQL nella directory ~/wordpress/wp-data.

Controlla il contenuto della directory.

$ ls -al wp-data
total 908
drwxr-xr-x 2 root   root     4096 Jan 11 10:15 ./
drwxrwxr-x 6 navjot navjot   4096 Jan 11 10:05 ../
-rw-r--r-- 1 root   root   919814 Jan 11 10:14 data_11-01-2023_10_14_40.sql

Puoi vedere il backup del database nella directory. Puoi ripristinare questo database utilizzando lo strumento phpMyAdmin o utilizzando il seguente comando.

$ docker compose exec db sh -c "exec mysql -uroot -p" < wp-data/data_11-01-2023_10_14_40.sql

È possibile creare un processo cron per eseguire il backup del database a intervalli regolari.

Crea lo script di backup nella directory /etc/cron.daily e aprilo per modificarlo.

$ sudo nano /etc/cron.daily/wpbackup.sh

Incolla il seguente codice al suo interno.

#!/bin/bash
docker compose exec db sh -c "exec mysqldump wordpress -uroot -p" | tee wp-data/data_`date +%d-%m-%Y"_"%H_%M_%S`.sql >/dev/null

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Rendere eseguibile lo script.

$ sudo chmod +x /etc/cron.daily/wpbackup.sh

Ora, il backup del tuo database verrà eseguito quotidianamente.

Passaggio 10: aggiorna WordPress

Il modo più semplice per aggiornare WordPress è utilizzare il programma di aggiornamento integrato. Puoi anche aggiornarlo utilizzando Docker. Il primo passaggio è eseguire il backup del database di WordPress utilizzando il comando del passaggio 9.

Quindi, passa alla directory.

$ cd ~/wordpress

Fermare i container.

$ docker compose down --remove-orphans

Estrai le ultime immagini del contenitore.

$ docker compose pull

Apporta eventuali modifiche in docker-compose.yml se lo desideri.

Riavvia i contenitori di WordPress.

$ docker compose up -d

Conclusione

Questo conclude il nostro tutorial sull'installazione di WordPress utilizzando Docker Compose, phpMyAdmin e WP-CLI. Se hai domande, pubblicale nei commenti qui sotto.