Automatizzare l'installazione di WordPress con NGINX Unit e Ubuntu

Esistono molti tutorial su come installare WordPress, una ricerca su Google per "WordPress install" produrrà circa mezzo milione di risultati. Tuttavia, in realtà, ci sono pochissime buone guide tra loro, secondo le quali è possibile installare e configurare WordPress e il sistema operativo sottostante in modo che siano in grado di supportare per un lungo periodo di tempo. Forse le impostazioni corrette dipendono fortemente da esigenze specifiche, oppure ciò è dovuto al fatto che una spiegazione dettagliata rende l'articolo di difficile lettura.

In questo articolo, proveremo a combinare il meglio dei due mondi fornendo uno script bash per installare automaticamente WordPress su Ubuntu, oltre a esaminarlo, spiegando cosa fa ogni pezzo, nonché i compromessi che abbiamo fatto per svilupparlo . Se sei un utente avanzato, puoi saltare il testo dell'articolo e basta prendi la sceneggiatura per la modifica e l'utilizzo nei vostri ambienti. L'output dello script è un'installazione WordPress personalizzata con supporto Lets Encrypt, in esecuzione su NGINX Unit e adatta per l'uso in produzione.

L'architettura sviluppata per la distribuzione di WordPress utilizzando l'unità NGINX è descritta in articolo più vecchio, ora configureremo ulteriormente anche le cose che non erano trattate lì (come in molti altri tutorial):

• CLI di WordPress
• Let's Encrypt e certificati TLSSSL
• Rinnovo automatico dei certificati
• Cache NGINX
• Compressione NGINX
• Supporto HTTPS e HTTP/2
• Automazione del processo

L'articolo descriverà l'installazione su un server, che ospiterà contemporaneamente un server di elaborazione statico, un server di elaborazione PHP e un database. Un'installazione che supporti più host e servizi virtuali è un potenziale argomento per il futuro. Se vuoi che scriviamo di qualcosa che non è in questi articoli, scrivi nei commenti.

Requisiti

• Server contenitore (LXC o LXD), una macchina virtuale o un normale server Iron con almeno 512 MB di RAM e Ubuntu 18.04 o più recente installato.
• Porte accessibili da Internet 80 e 443
• Nome di dominio associato all'indirizzo IP pubblico di questo server
• Accesso root (sudo).

Panoramica dell'architettura

L'architettura è la stessa descritta prima, un'applicazione Web a tre livelli. Consiste in script PHP che vengono eseguiti sul motore PHP e file statici che vengono elaborati dal server web.

Principi generali

• Molti comandi di configurazione in uno script sono racchiusi in condizioni if ​​per idempotenza: lo script può essere eseguito più volte senza il rischio di modificare le impostazioni già presenti.
• Lo script tenta di installare il software dai repository, quindi puoi applicare gli aggiornamenti di sistema in un comando (apt upgrade per Ubuntu).
• I comandi tentano di rilevare che sono in esecuzione in un contenitore in modo da poter modificare le impostazioni di conseguenza.
• Per impostare il numero di processi thread da avviare nelle impostazioni, lo script tenta di indovinare le impostazioni automatiche per lavorare in contenitori, macchine virtuali e server hardware.
• Quando descriviamo le impostazioni, pensiamo sempre prima di tutto all'automazione, che, speriamo, diventerà la base per creare la tua infrastruttura come codice.
• Tutti i comandi vengono eseguiti come utente radice, perché modificano le impostazioni di base del sistema, ma direttamente WordPress funziona come un normale utente.

Impostazione delle variabili d'ambiente

Impostare le seguenti variabili di ambiente prima di eseguire lo script:

• WORDPRESS_DB_PASSWORD - Password del database WordPress
• WORDPRESS_ADMIN_USER - Nome dell'amministratore di WordPress
• WORDPRESS_ADMIN_PASSWORD - Password dell'amministratore di WordPress
• WORDPRESS_ADMIN_EMAIL - E-mail dell'amministratore di WordPress
• WORDPRESS_URL è l'URL completo del sito WordPress, a partire da https://.
• LETS_ENCRYPT_STAGING - vuoto per impostazione predefinita, ma impostando il valore su 1, utilizzerai i server di staging di Let's Encrypt, necessari per richiedere frequentemente i certificati durante il test delle tue impostazioni, altrimenti Let's Encrypt potrebbe bloccare temporaneamente il tuo indirizzo IP a causa di un numero elevato di richieste .

Lo script controlla che queste variabili relative a WordPress siano impostate ed esce in caso contrario.
Le righe di script 572-576 controllano il valore LETS_ENCRYPT_STAGING.

Impostazione delle variabili di ambiente derivate

Lo script alle righe 55-61 imposta le seguenti variabili d'ambiente, su un valore codificato o utilizzando un valore ottenuto dalle variabili impostate nella sezione precedente:

• DEBIAN_FRONTEND="noninteractive" - Indica alle applicazioni che sono in esecuzione in uno script e che non è possibile l'interazione dell'utente.
• WORDPRESS_CLI_VERSION="2.4.0" è la versione dell'applicazione CLI di WordPress.
• WORDPRESS_CLI_MD5= "dedd5a662b80cda66e9e25d44c23b25c" — checksum del file eseguibile di WordPress CLI 2.4.0 (la versione è specificata nella variabile WORDPRESS_CLI_VERSION). Lo script alla riga 162 utilizza questo valore per verificare che sia stato scaricato il file CLI di WordPress corretto.
• UPLOAD_MAX_FILESIZE="16M" - la dimensione massima del file che può essere caricato in WordPress. Questa impostazione viene utilizzata in più posizioni, quindi è più semplice impostarla in un'unica posizione.
• TLS_HOSTNAME= "$(echo ${WORDPRESS_URL} | cut -d'/' -f3)" - nome host del sistema, recuperato dalla variabile WORDPRESS_URL. Utilizzato per ottenere i certificati TLS/SSL appropriati da Let's Encrypt e per la verifica interna di WordPress.
• NGINX_CONF_DIR="/etc/nginx" - percorso della directory con le impostazioni NGINX, incluso il file principale nginx.conf.
• CERT_DIR="/etc/letsencrypt/live/${TLS_HOSTNAME}" — il percorso dei certificati Let's Encrypt per il sito WordPress, ottenuto dalla variabile TLS_HOSTNAME.

Assegnazione di un nome host a un server WordPress

Lo script imposta il nome host del server in modo che corrisponda al nome di dominio del sito. Questo non è richiesto, ma è più conveniente inviare la posta in uscita tramite SMTP quando si imposta un singolo server, come configurato dallo script.

codice di script

# Change the hostname to be the same as the WordPress hostname
if [ ! "$(hostname)" == "${TLS_HOSTNAME}" ]; then
  echo " Changing hostname to ${TLS_HOSTNAME}"
  hostnamectl set-hostname "${TLS_HOSTNAME}"
fi

Aggiunta del nome host a /etc/hosts

Aggiunta WP-Cron utilizzato per eseguire attività periodiche, richiede che WordPress sia in grado di accedere a se stesso tramite HTTP. Per assicurarsi che WP-Cron funzioni correttamente su tutti gli ambienti, lo script aggiunge una riga al file / Etc / hostsin modo che WordPress possa accedere a se stesso tramite l'interfaccia di loopback:

codice di script

# Add the hostname to /etc/hosts
if [ "$(grep -m1 "${TLS_HOSTNAME}" /etc/hosts)" = "" ]; then
  echo " Adding hostname ${TLS_HOSTNAME} to /etc/hosts so that WordPress can ping itself"
  printf "::1 %sn127.0.0.1 %sn" "${TLS_HOSTNAME}" "${TLS_HOSTNAME}" >> /etc/hosts
fi

Installazione degli strumenti necessari per i passaggi successivi

Il resto dello script richiede alcuni programmi e presuppone che i repository siano aggiornati. Aggiorniamo l'elenco dei repository, dopodiché installiamo gli strumenti necessari:

codice di script

# Make sure tools needed for install are present
echo " Installing prerequisite tools"
apt-get -qq update
apt-get -qq install -y 
  bc 
  ca-certificates 
  coreutils 
  curl 
  gnupg2 
  lsb-release

Aggiunta di unità NGINX e repository NGINX

Lo script installa NGINX Unit e NGINX open source dai repository NGINX ufficiali per assicurarsi che vengano utilizzate le versioni con le patch di sicurezza e le correzioni di bug più recenti.

Lo script aggiunge il repository NGINX Unit e quindi il repository NGINX, aggiungendo la chiave del repository e i file di configurazione apt, definendo l'accesso ai depositi via Internet.

L'effettiva installazione dell'unità NGINX e di NGINX avviene nella sezione successiva. Pre-aggiungiamo i repository in modo da non dover aggiornare i metadati più volte, il che rende l'installazione più veloce.

codice di script

# Install the NGINX Unit repository
if [ ! -f /etc/apt/sources.list.d/unit.list ]; then
  echo " Installing NGINX Unit repository"
  curl -fsSL https://nginx.org/keys/nginx_signing.key | apt-key add -
  echo "deb https://packages.nginx.org/unit/ubuntu/ $(lsb_release -cs) unit" > /etc/apt/sources.list.d/unit.list
fi

# Install the NGINX repository
if [ ! -f /etc/apt/sources.list.d/nginx.list ]; then
  echo " Installing NGINX repository"
  curl -fsSL https://nginx.org/keys/nginx_signing.key | apt-key add -
  echo "deb https://nginx.org/packages/mainline/ubuntu $(lsb_release -cs) nginx" > /etc/apt/sources.list.d/nginx.list
fi

Installazione di NGINX, NGINX Unit, PHP MariaDB, Certbot (Let's Encrypt) e relative dipendenze

Una volta aggiunti tutti i repository, aggiorna i metadati e installa le applicazioni. I pacchetti installati dallo script includono anche le estensioni PHP consigliate durante l'esecuzione di WordPress.org

codice di script

echo " Updating repository metadata"
apt-get -qq update

# Install PHP with dependencies and NGINX Unit
echo " Installing PHP, NGINX Unit, NGINX, Certbot, and MariaDB"
apt-get -qq install -y --no-install-recommends 
  certbot 
  python3-certbot-nginx 
  php-cli 
  php-common 
  php-bcmath 
  php-curl 
  php-gd 
  php-imagick 
  php-mbstring 
  php-mysql 
  php-opcache 
  php-xml 
  php-zip 
  ghostscript 
  nginx 
  unit 
  unit-php 
  mariadb-server

Configurazione di PHP per l'utilizzo con NGINX Unit e WordPress

Lo script crea un file delle impostazioni nella directory conf. Imposta la dimensione massima per i caricamenti PHP, attiva l'output degli errori PHP su STDERR in modo che vengano scritti nel registro dell'unità NGINX e riavvia l'unità NGINX.

codice di script

# Find the major and minor PHP version so that we can write to its conf.d directory
PHP_MAJOR_MINOR_VERSION="$(php -v | head -n1 | cut -d' ' -f2 | cut -d'.' -f1,2)"

if [ ! -f "/etc/php/${PHP_MAJOR_MINOR_VERSION}/embed/conf.d/30-wordpress-overrides.ini" ]; then
  echo " Configuring PHP for use with NGINX Unit and WordPress"
  # Add PHP configuration overrides
  cat > "/etc/php/${PHP_MAJOR_MINOR_VERSION}/embed/conf.d/30-wordpress-overrides.ini" << EOM
; Set a larger maximum upload size so that WordPress can handle
; bigger media files.
upload_max_filesize=${UPLOAD_MAX_FILESIZE}
post_max_size=${UPLOAD_MAX_FILESIZE}
; Write error log to STDERR so that error messages show up in the NGINX Unit log
error_log=/dev/stderr
EOM
fi

# Restart NGINX Unit because we have reconfigured PHP
echo " Restarting NGINX Unit"
service unit restart

Specifica delle impostazioni del database MariaDB per WordPress

Abbiamo scelto MariaDB su MySQL in quanto ha più attività della comunità ed è anche probabile che lo faccia fornisce prestazioni migliori per impostazione predefinita (probabilmente qui è tutto più semplice: per installare MySQL è necessario aggiungere un altro repository, ca. traduttore).

Lo script crea un nuovo database e crea le credenziali per accedere a WordPress tramite l'interfaccia di loopback:

codice di script

# Set up the WordPress database
echo " Configuring MariaDB for WordPress"
mysqladmin create wordpress || echo "Ignoring above error because database may already exist"
mysql -e "GRANT ALL PRIVILEGES ON wordpress.* TO "wordpress"@"localhost" IDENTIFIED BY "$WORDPRESS_DB_PASSWORD"; FLUSH PRIVILEGES;"

Installazione del programma CLI di WordPress

A questo punto, lo script installa il programma WP-CLI. Con esso, puoi installare e gestire le impostazioni di WordPress senza dover modificare manualmente i file, aggiornare il database o accedere al pannello di controllo. Può anche essere utilizzato per installare temi e componenti aggiuntivi e aggiornare WordPress.

codice di script

if [ ! -f /usr/local/bin/wp ]; then
  # Install the WordPress CLI
  echo " Installing the WordPress CLI tool"
  curl --retry 6 -Ls "https://github.com/wp-cli/wp-cli/releases/download/v${WORDPRESS_CLI_VERSION}/wp-cli-${WORDPRESS_CLI_VERSION}.phar" > /usr/local/bin/wp
  echo "$WORDPRESS_CLI_MD5 /usr/local/bin/wp" | md5sum -c -
  chmod +x /usr/local/bin/wp
fi

Installazione e configurazione WordPress

Lo script installa l'ultima versione di WordPress in una directory /var/www/wordpresse cambia anche le impostazioni:

• La connessione al database funziona su un socket di dominio unix anziché su TCP in loopback per ridurre il traffico TCP.
• WordPress aggiunge un prefisso https:// all'URL se i client si connettono a NGINX tramite HTTPS e invia anche il nome host remoto (come fornito da NGINX) a PHP. Usiamo un pezzo di codice per impostare questo.
• WordPress ha bisogno di HTTPS per il login
• La struttura dell'URL predefinita è basata sulle risorse
• Imposta le autorizzazioni corrette sul file system per la directory di WordPress.

codice di script

if [ ! -d /var/www/wordpress ]; then
  # Create WordPress directories
  mkdir -p /var/www/wordpress
  chown -R www-data:www-data /var/www

  # Download WordPress using the WordPress CLI
  echo " Installing WordPress"
  su -s /bin/sh -c 'wp --path=/var/www/wordpress core download' www-data

  WP_CONFIG_CREATE_CMD="wp --path=/var/www/wordpress config create --extra-php --dbname=wordpress --dbuser=wordpress --dbhost="localhost:/var/run/mysqld/mysqld.sock" --dbpass="${WORDPRESS_DB_PASSWORD}""

  # This snippet is injected into the wp-config.php file when it is created;
  # it informs WordPress that we are behind a reverse proxy and as such
  # allows it to generate links using HTTPS
  cat > /tmp/wp_forwarded_for.php << 'EOM'
/* Turn HTTPS 'on' if HTTP_X_FORWARDED_PROTO matches 'https' */
if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && strpos($_SERVER['HTTP_X_FORWARDED_PROTO'], 'https') !== false) {
    $_SERVER['HTTPS'] = 'on';
}
if (isset($_SERVER['HTTP_X_FORWARDED_HOST'])) {
    $_SERVER['HTTP_HOST'] = $_SERVER['HTTP_X_FORWARDED_HOST'];
}
EOM

  # Create WordPress configuration
  su -s /bin/sh -p -c "cat /tmp/wp_forwarded_for.php | ${WP_CONFIG_CREATE_CMD}" www-data
  rm /tmp/wp_forwarded_for.php
  su -s /bin/sh -p -c "wp --path=/var/www/wordpress config set 'FORCE_SSL_ADMIN' 'true'" www-data

  # Install WordPress
  WP_SITE_INSTALL_CMD="wp --path=/var/www/wordpress core install --url="${WORDPRESS_URL}" --title="${WORDPRESS_SITE_TITLE}" --admin_user="${WORDPRESS_ADMIN_USER}" --admin_password="${WORDPRESS_ADMIN_PASSWORD}" --admin_email="${WORDPRESS_ADMIN_EMAIL}" --skip-email"
  su -s /bin/sh -p -c "${WP_SITE_INSTALL_CMD}" www-data

  # Set permalink structure to a sensible default that isn't in the UI
  su -s /bin/sh -p -c "wp --path=/var/www/wordpress option update permalink_structure '/%year%/%monthnum%/%postname%/'" www-data

  # Remove sample file because it is cruft and could be a security problem
  rm /var/www/wordpress/wp-config-sample.php

  # Ensure that WordPress permissions are correct
  find /var/www/wordpress -type d -exec chmod g+s {} ;
  chmod g+w /var/www/wordpress/wp-content
  chmod -R g+w /var/www/wordpress/wp-content/themes
  chmod -R g+w /var/www/wordpress/wp-content/plugins
fi

Configurazione dell'unità NGINX

Lo script configura l'unità NGINX per eseguire PHP ed elaborare percorsi WordPress, isolando lo spazio dei nomi del processo PHP e ottimizzando le impostazioni delle prestazioni. Ci sono tre caratteristiche da tenere d'occhio qui:

• Il supporto per gli spazi dei nomi è determinato dalla condizione, in base alla verifica che lo script sia in esecuzione in un contenitore. Ciò è necessario perché la maggior parte delle configurazioni dei contenitori non supporta l'avvio nidificato dei contenitori.
• Se esiste il supporto per gli spazi dei nomi, disabilitare lo spazio dei nomi Rete. Questo per consentire a WordPress di connettersi a entrambi gli endpoint ed essere disponibile sul Web contemporaneamente.
• Il numero massimo di processi è definito come segue: (Memoria disponibile per l'esecuzione di MariaDB e NGINX Uniy)/(Limite RAM in PHP + 5)
  Questo valore è impostato nelle impostazioni dell'unità NGINX.

Questo valore implica anche che ci sono sempre almeno due processi PHP in esecuzione, il che è importante perché WordPress effettua molte richieste asincrone a se stesso e senza processi aggiuntivi, l'esecuzione, ad esempio, di WP-Cron si interromperà. Potresti voler aumentare o diminuire questi limiti in base alle tue impostazioni locali, perché le impostazioni create qui sono prudenti. Sulla maggior parte dei sistemi di produzione, le impostazioni sono comprese tra 10 e 100.

codice di script

if [ "${container:-unknown}" != "lxc" ] && [ "$(grep -m1 -a container=lxc /proc/1/environ | tr -d '')" == "" ]; then
  NAMESPACES='"namespaces": {
        "cgroup": true,
        "credential": true,
        "mount": true,
        "network": false,
        "pid": true,
        "uname": true
    }'
else
  NAMESPACES='"namespaces": {}'
fi

PHP_MEM_LIMIT="$(grep 'memory_limit' /etc/php/7.4/embed/php.ini | tr -d ' ' | cut -f2 -d= | numfmt --from=iec)"
AVAIL_MEM="$(grep MemAvailable /proc/meminfo | tr -d ' kB' | cut -f2 -d: | numfmt --from-unit=K)"
MAX_PHP_PROCESSES="$(echo "${AVAIL_MEM}/${PHP_MEM_LIMIT}+5" | bc)"
echo " Calculated the maximum number of PHP processes as ${MAX_PHP_PROCESSES}. You may want to tune this value due to variations in your configuration. It is not unusual to see values between 10-100 in production configurations."

echo " Configuring NGINX Unit to use PHP and WordPress"
cat > /tmp/wordpress.json << EOM
{
  "settings": {
    "http": {
      "header_read_timeout": 30,
      "body_read_timeout": 30,
      "send_timeout": 30,
      "idle_timeout": 180,
      "max_body_size": $(numfmt --from=iec ${UPLOAD_MAX_FILESIZE})
    }
  },
  "listeners": {
    "127.0.0.1:8080": {
      "pass": "routes/wordpress"
    }
  },
  "routes": {
    "wordpress": [
      {
        "match": {
          "uri": [
            "*.php",
            "*.php/*",
            "/wp-admin/"
          ]
        },
        "action": {
          "pass": "applications/wordpress/direct"
        }
      },
      {
        "action": {
          "share": "/var/www/wordpress",
          "fallback": {
            "pass": "applications/wordpress/index"
          }
        }
      }
    ]
  },
  "applications": {
    "wordpress": {
      "type": "php",
      "user": "www-data",
      "group": "www-data",
      "processes": {
        "max": ${MAX_PHP_PROCESSES},
        "spare": 1
      },
      "isolation": {
        ${NAMESPACES}
      },
      "targets": {
        "direct": {
          "root": "/var/www/wordpress/"
        },
        "index": {
          "root": "/var/www/wordpress/",
          "script": "index.php"
        }
      }
    }
  }
}
EOM

curl -X PUT --data-binary @/tmp/wordpress.json --unix-socket /run/control.unit.sock http://localhost/config

Configurazione di NGINX

Configurazione delle impostazioni di base di NGINX

Lo script crea una directory per la cache NGINX e quindi crea il file di configurazione principale nginx.conf. Prestare attenzione al numero di processi del gestore e all'impostazione della dimensione massima del file per il caricamento. C'è anche una riga che include il file delle impostazioni di compressione definito nella sezione successiva, seguito dalle impostazioni di memorizzazione nella cache.

codice di script

# Make directory for NGINX cache
mkdir -p /var/cache/nginx/proxy

echo " Configuring NGINX"
cat > ${NGINX_CONF_DIR}/nginx.conf << EOM
user nginx;
worker_processes auto;
error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;
events {
    worker_connections  1024;
}
http {
    include       ${NGINX_CONF_DIR}/mime.types;
    default_type  application/octet-stream;
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;
    sendfile        on;
    client_max_body_size ${UPLOAD_MAX_FILESIZE};
    keepalive_timeout  65;
    # gzip settings
    include ${NGINX_CONF_DIR}/gzip_compression.conf;
    # Cache settings
    proxy_cache_path /var/cache/nginx/proxy
        levels=1:2
        keys_zone=wp_cache:10m
        max_size=10g
        inactive=60m
        use_temp_path=off;
    include ${NGINX_CONF_DIR}/conf.d/*.conf;
}
EOM

Impostazione della compressione NGINX

Comprimere i contenuti al volo prima di inviarli ai client è un ottimo modo per migliorare le prestazioni del sito, ma solo se la compressione è configurata correttamente. Questa sezione dello script è basata sulle impostazioni quindi.

codice di script

cat > ${NGINX_CONF_DIR}/gzip_compression.conf << 'EOM'
# Credit: https://github.com/h5bp/server-configs-nginx/
# ----------------------------------------------------------------------
# | Compression                                                        |
# ----------------------------------------------------------------------
# https://nginx.org/en/docs/http/ngx_http_gzip_module.html
# Enable gzip compression.
# Default: off
gzip on;
# Compression level (1-9).
# 5 is a perfect compromise between size and CPU usage, offering about 75%
# reduction for most ASCII files (almost identical to level 9).
# Default: 1
gzip_comp_level 6;
# Don't compress anything that's already small and unlikely to shrink much if at
# all (the default is 20 bytes, which is bad as that usually leads to larger
# files after gzipping).
# Default: 20
gzip_min_length 256;
# Compress data even for clients that are connecting to us via proxies,
# identified by the "Via" header (required for CloudFront).
# Default: off
gzip_proxied any;
# Tell proxies to cache both the gzipped and regular version of a resource
# whenever the client's Accept-Encoding capabilities header varies;
# Avoids the issue where a non-gzip capable client (which is extremely rare
# today) would display gibberish if their proxy gave them the gzipped version.
# Default: off
gzip_vary on;
# Compress all output labeled with one of the following MIME-types.
# `text/html` is always compressed by gzip module.
# Default: text/html
gzip_types
  application/atom+xml
  application/geo+json
  application/javascript
  application/x-javascript
  application/json
  application/ld+json
  application/manifest+json
  application/rdf+xml
  application/rss+xml
  application/vnd.ms-fontobject
  application/wasm
  application/x-web-app-manifest+json
  application/xhtml+xml
  application/xml
  font/eot
  font/otf
  font/ttf
  image/bmp
  image/svg+xml
  text/cache-manifest
  text/calendar
  text/css
  text/javascript
  text/markdown
  text/plain
  text/xml
  text/vcard
  text/vnd.rim.location.xloc
  text/vtt
  text/x-component
  text/x-cross-domain-policy;
EOM

Configurazione di NGINX per WordPress

Successivamente, lo script crea un file di configurazione per WordPress predefinito.conf nel catalogo conf. È configurato qui:

• Attivare i certificati TLS ricevuti da Let's Encrypt tramite Certbot (l'impostazione sarà nella sezione successiva)
• Configurazione delle impostazioni di sicurezza TLS in base ai consigli di Let's Encrypt
• Abilita la memorizzazione nella cache delle richieste di salto per 1 ora per impostazione predefinita
• Disabilita la registrazione degli accessi, così come la registrazione degli errori se il file non viene trovato, per due file richiesti comuni: favicon.ico e robots.txt
• Impedisci l'accesso ai file nascosti e ad alcuni file . Phpper impedire l'accesso illegale o l'avvio involontario
• Disabilita la registrazione degli accessi per file statici e font
• Impostazione dell'intestazione Accesso-Controllo-Consenti-Origine per i file dei caratteri
• Aggiunta di routing per index.php e altre statistiche.

codice di script

cat > ${NGINX_CONF_DIR}/conf.d/default.conf << EOM
upstream unit_php_upstream {
    server 127.0.0.1:8080;
    keepalive 32;
}
server {
    listen 80;
    listen [::]:80;
    # ACME-challenge used by Certbot for Let's Encrypt
    location ^~ /.well-known/acme-challenge/ {
      root /var/www/certbot;
    }
    location / {
      return 301 https://${TLS_HOSTNAME}$request_uri;
    }
}
server {
    listen      443 ssl http2;
    listen [::]:443 ssl http2;
    server_name ${TLS_HOSTNAME};
    root        /var/www/wordpress/;
    # Let's Encrypt configuration
    ssl_certificate         ${CERT_DIR}/fullchain.pem;
    ssl_certificate_key     ${CERT_DIR}/privkey.pem;
    ssl_trusted_certificate ${CERT_DIR}/chain.pem;
    include ${NGINX_CONF_DIR}/options-ssl-nginx.conf;
    ssl_dhparam ${NGINX_CONF_DIR}/ssl-dhparams.pem;
    # OCSP stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    # Proxy caching
    proxy_cache wp_cache;
    proxy_cache_valid 200 302 1h;
    proxy_cache_valid 404 1m;
    proxy_cache_revalidate on;
    proxy_cache_background_update on;
    proxy_cache_lock on;
    proxy_cache_use_stale error timeout http_500 http_502 http_503 http_504;
    location = /favicon.ico {
        log_not_found off;
        access_log off;
    }
    location = /robots.txt {
        allow all;
        log_not_found off;
        access_log off;
    }

    # Deny all attempts to access hidden files such as .htaccess, .htpasswd,
    # .DS_Store (Mac)
    # Keep logging the requests to parse later (or to pass to firewall utilities
    # such as fail2ban)
    location ~ /. {
        deny all;
    }
    # Deny access to any files with a .php extension in the uploads directory;
    # works in subdirectory installs and also in multi-site network.
    # Keep logging the requests to parse later (or to pass to firewall utilities
    # such as fail2ban).
    location ~* /(?:uploads|files)/.*.php$ {
        deny all;
    }
    # WordPress: deny access to wp-content, wp-includes PHP files
    location ~* ^/(?:wp-content|wp-includes)/.*.php$ {
        deny all;
    }
    # Deny public access to wp-config.php
    location ~* wp-config.php {
        deny all;
    }
    # Do not log access for static assets, media
    location ~* .(?:css(.map)?|js(.map)?|jpe?g|png|gif|ico|cur|heic|webp|tiff?|mp3|m4a|aac|ogg|midi?|wav|mp4|mov|webm|mpe?g|avi|ogv|flv|wmv)$ {
        access_log off;
    }
    location ~* .(?:svgz?|ttf|ttc|otf|eot|woff2?)$ {
        add_header Access-Control-Allow-Origin "*";
        access_log off;
    }
    location / {
        try_files $uri @index_php;
    }
    location @index_php {
        proxy_socket_keepalive on;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $host;
        proxy_pass       http://unit_php_upstream;
    }
    location ~* .php$ {
        proxy_socket_keepalive on;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $host;
        try_files        $uri =404;
        proxy_pass       http://unit_php_upstream;
    }
}
EOM

Impostazione di Certbot per i certificati da Let's Encrypt e rinnovo automatico

Certbot è uno strumento gratuito della Electronic Frontier Foundation (EFF) che consente di ottenere e rinnovare automaticamente certificati TLS da Let's Encrypt. Lo script esegue le seguenti operazioni per configurare Certbot per elaborare i certificati da Let's Encrypt in NGINX:

• Arresta NGINX
• Scarica le impostazioni TLS consigliate
• Esegue Certbot per ottenere i certificati per il sito
• Riavvia NGINX per usare i certificati
• Configura Certbot per l'esecuzione giornaliera alle 3:24 per verificare se i certificati devono essere rinnovati e, se necessario, scaricare nuovi certificati e riavviare NGINX.

codice di script

echo " Stopping NGINX in order to set up Let's Encrypt"
service nginx stop

mkdir -p /var/www/certbot
chown www-data:www-data /var/www/certbot
chmod g+s /var/www/certbot

if [ ! -f ${NGINX_CONF_DIR}/options-ssl-nginx.conf ]; then
  echo " Downloading recommended TLS parameters"
  curl --retry 6 -Ls -z "Tue, 14 Apr 2020 16:36:07 GMT" 
    -o "${NGINX_CONF_DIR}/options-ssl-nginx.conf" 
    "https://raw.githubusercontent.com/certbot/certbot/master/certbot-nginx/certbot_nginx/_internal/tls_configs/options-ssl-nginx.conf" 
    || echo "Couldn't download latest options-ssl-nginx.conf"
fi

if [ ! -f ${NGINX_CONF_DIR}/ssl-dhparams.pem ]; then
  echo " Downloading recommended TLS DH parameters"
  curl --retry 6 -Ls -z "Tue, 14 Apr 2020 16:49:18 GMT" 
    -o "${NGINX_CONF_DIR}/ssl-dhparams.pem" 
    "https://raw.githubusercontent.com/certbot/certbot/master/certbot/certbot/ssl-dhparams.pem" 
    || echo "Couldn't download latest ssl-dhparams.pem"
fi

# If tls_certs_init.sh hasn't been run before, remove the self-signed certs
if [ ! -d "/etc/letsencrypt/accounts" ]; then
  echo " Removing self-signed certificates"
  rm -rf "${CERT_DIR}"
fi

if [ "" = "${LETS_ENCRYPT_STAGING:-}" ] || [ "0" = "${LETS_ENCRYPT_STAGING}" ]; then
  CERTBOT_STAGING_FLAG=""
else
  CERTBOT_STAGING_FLAG="--staging"
fi

if [ ! -f "${CERT_DIR}/fullchain.pem" ]; then
  echo " Generating certificates with Let's Encrypt"
  certbot certonly --standalone 
         -m "${WORDPRESS_ADMIN_EMAIL}" 
         ${CERTBOT_STAGING_FLAG} 
         --agree-tos --force-renewal --non-interactive 
         -d "${TLS_HOSTNAME}"
fi

echo " Starting NGINX in order to use new configuration"
service nginx start

# Write crontab for periodic Let's Encrypt cert renewal
if [ "$(crontab -l | grep -m1 'certbot renew')" == "" ]; then
  echo " Adding certbot to crontab for automatic Let's Encrypt renewal"
  (crontab -l 2>/dev/null; echo "24 3 * * * certbot renew --nginx --post-hook 'service nginx reload'") | crontab -
fi

Personalizzazione aggiuntiva del tuo sito

Abbiamo parlato sopra di come il nostro script configura NGINX e NGINX Unit per servire un sito pronto per la produzione con TLSSSL abilitato. Puoi anche, a seconda delle tue esigenze, aggiungere in futuro:

• Sostegno Brotli, compressione al volo migliorata su HTTPS
• ModSecurity с regole per wordpressper prevenire attacchi automatici al tuo sito
• di riserva per WordPress che fa per te
• Protezione via AppArmor (su Ubuntu)
• Postfix o msmtp in modo che WordPress possa inviare posta
• Controllando il tuo sito per capire quanto traffico può gestire

Per prestazioni del sito ancora migliori, ti consigliamo di eseguire l'aggiornamento a NGINX Plus, il nostro prodotto commerciale di livello aziendale basato su NGINX open source. I suoi abbonati riceveranno un modulo Brotli caricato dinamicamente, nonché (a un costo aggiuntivo) NGINX ModSecurity WAF. Offriamo anche Protezione dell'app NGINX, un modulo WAF per NGINX Plus basato sulla tecnologia di sicurezza leader del settore di F5.

NB Per il supporto di un sito altamente caricato, puoi contattare gli esperti Southbridge. Garantiremo un funzionamento rapido e affidabile del tuo sito Web o servizio sotto qualsiasi carico.

Fonte: habr.com