Automisons l'installation de WordPress avec NGINX Unit et Ubuntu

Il existe de nombreux matériaux sur l'installation de WordPress, une recherche sur Google avec les mots-clés "installation WordPress" donnera environ un demi-million de résultats. Cependant, parmi eux, il y a très peu de guides valables qui permettent d'installer et de configurer WordPress et le système d'exploitation sous-jacent de manière à ce qu'ils soient capables de soutenir un fonctionnement à long terme. Il est possible que les bonnes configurations dépendent fortement des besoins spécifiques, ou que cela soit lié au fait qu'une explication détaillée rend l'article difficile à lire.

Dans cet article, nous essaierons de rassembler le meilleur des deux approches, en fournissant un script Bash pour l'installation automatique de WordPress sur Ubuntu, tout en l'expliquant, en précisant ce que fait chaque morceau et quels compromis nous avons faits dans son développement. Si vous êtes un utilisateur expérimenté, vous pouvez passer le texte de l'article et simplement prendre le script à modifier et à utiliser dans vos environnements. Le script produit une installation personnalisable de WordPress avec un support Lets Encrypt, fonctionnant sur NGINX Unit et adaptée à un usage industriel.

L'architecture développée pour déployer WordPress avec NGINX Unit est décrite dans un ancien article, nous allons également configurer des éléments supplémentaires qui n'ont pas été couverts (comme dans de nombreux autres guides) :

• WordPress CLI
• Let’s Encrypt et certificats TLS
• Mise à jour automatique des certificats
• Mise en cache NGINX
• Compression NGINX
• Support HTTPS et HTTP/2
• Automatisation du processus

L'article décrira une installation sur un seul serveur, où seront hébergés simultanément le serveur de traitement statique, le serveur PHP et la base de données. L'installation avec support de plusieurs hôtes virtuels et services est un sujet potentiel pour l'avenir. Si vous souhaitez que nous écrivions sur autre chose qui n'est pas abordé dans ces articles, n'hésitez pas à nous le faire savoir dans les commentaires.

Exigences

• Conteneur de serveur (LXC ou LXD), machine virtuelle, ou serveur physique ordinaire, avec au moins 512 Mo de RAM et une Ubuntu 18.04 ou plus récente installée.
• Ports 80 et 443 accessibles depuis Internet
• Nom de domaine associé à l'adresse IP publique de ce serveur
• Accès avec des droits root (sudo).

Vue d'ensemble de l'architecture

L'architecture est la même que celle décrite précédemment, une application web à trois niveaux. Elle se compose de scripts PHP exécutés sur le gestionnaire PHP et de fichiers statiques traités par le serveur web.

Principes généraux

• De nombreuses commandes de configuration dans le script sont encapsulées dans des conditions (if) pour assurer l'idempotence : le script peut être exécuté plusieurs fois sans risque de modifier des paramètres déjà configurés.
• Le script tend à installer des logiciels à partir des dépôts, ce qui vous permet d'appliquer les mises à jour système en une seule commande (apt upgrade pour Ubuntu).
• Les commandes essaient de déterminer si elles sont exécutées dans un conteneur afin d'ajuster leurs paramètres en conséquence.
• Pour définir le nombre de processus/threads lancés dans la configuration, le script essaie de deviner les paramètres d'automatisation appropriés pour fonctionner dans des conteneurs, des machines virtuelles ou des serveurs physiques.
• Lors de la description des paramètres, nous pensons tout d'abord à l'automatisation, qui, nous l'espérons, formera la base de votre propre infrastructure en tant que code.
• Toutes les commandes sont exécutées par l'utilisateur root, car elles modifient les paramètres système fondamentaux, mais WordPress fonctionne en tant qu'utilisateur standard.

Configuration des variables d'environnement

Définissez les variables d'environnement suivantes avant d'exécuter le script :

• WORDPRESS_DB_PASSWORD — mot de passe de la base de données WordPress
• WORDPRESS_ADMIN_USER — nom de l'administrateur WordPress
• WORDPRESS_ADMIN_PASSWORD — mot de passe de l'administrateur WordPress
• WORDPRESS_ADMIN_EMAIL — e-mail de l'administrateur WordPress
• WORDPRESS_URL — URL complète du site WordPress, commençant par https://.
• LETS_ENCRYPT_STAGING — par défaut vide, mais en définissant la valeur sur 1, vous utiliserez les serveurs de staging de Let’s Encrypt, nécessaires pour les demandes fréquentes de certificats lors de la vérification de vos paramètres, sinon Let’s Encrypt peut temporairement bloquer votre adresse IP en raison d'un trop grand nombre de demandes.

Le script vérifie que ces variables liées à WordPress sont définies et se termine si elles ne le sont pas.
Les lignes 572-576 du script vérifient la valeur LETS_ENCRYPT_STAGING.

Configuration des variables d'environnement dérivées

Le script aux lignes 55-61 définit les variables d'environnement suivantes, soit à une valeur fixe, soit en utilisant une valeur obtenue des variables définies dans la section précédente :

• DEBIAN_FRONTEND="noninteractive" — informe les applications qu'elles sont lancées dans un script et qu'il n'est pas possible d'interagir avec l'utilisateur.
• WORDPRESS_CLI_VERSION="2.4.0" — version de l'application WordPress CLI.
• WORDPRESS_CLI_MD5= "dedd5a662b80cda66e9e25d44c23b25c" — somme de contrôle du fichier exécutable WordPress CLI 2.4.0 (la version est indiquée dans la variable WORDPRESS_CLI_VERSION). Le script à la ligne 162 utilise cette valeur pour vérifier que le fichier WordPress CLI correct a été téléchargé.
• UPLOAD_MAX_FILESIZE="16M" — taille maximale des fichiers pouvant être téléchargés dans WordPress. Ce paramètre est utilisé à plusieurs endroits, il est donc plus simple de le définir à un seul endroit.
• TLS_HOSTNAME= "$(echo ${WORDPRESS_URL} | cut -d'\/ ' -f3)" — nom d'hôte du système, extrait de la variable WORDPRESS_URL. Utilisé pour obtenir les certificats TLS/SSL correspondants de Let’s Encrypt, ainsi que pour la vérification interne de WordPress.
• NGINX_CONF_DIR="\/etc\/nginx" — chemin vers le répertoire des paramètres NGINX, y compris le fichier principal nginx.conf.
• CERT_DIR="\/etc\/letsencrypt\/live\/${TLS_HOSTNAME}" — chemin vers les certificats Let’s Encrypt pour le site WordPress, obtenu à partir de la variable TLS_HOSTNAME.

Affectation du nom d'hôte au serveur WordPress

Le script définit le nom d'hôte du serveur afin que la valeur corresponde au nom de domaine du site. Ce n'est pas obligatoire, mais cela facilite l'envoi d'e-mails sortants via SMTP lors de la configuration d'un serveur unique, comme cela est configuré par le script.

code du 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

Ajout du nom d'hôte dans \/etc\/hosts

Module complémentaire WP‑Cron est utilisé pour exécuter des tâches périodiques, nécessitant que WordPress puisse accéder à lui-même via HTTP. Pour s'assurer que WP-Cron fonctionne correctement dans tous les environnements, le script ajoute une ligne au fichier /etc/hosts, afin que WordPress puisse s'accéder lui-même via l'interface loopback :

code du 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

Installation des outils nécessaires pour les étapes suivantes

Le reste du script nécessite certains programmes et suppose que les dépôts sont à jour. Nous mettons à jour la liste des dépôts, puis installons les outils nécessaires :

code du 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

Ajout des dépôts NGINX Unit et NGINX

Le script installe NGINX Unit et NGINX à code source ouvert à partir des dépôts officiels de NGINX, afin de s'assurer que les versions avec les dernières mises à jour de sécurité et correctifs de bugs sont utilisées.

Le script ajoute le dépôt NGINX Unit, puis le dépôt NGINX, ajoutant la clé des dépôts et les fichiers de configuration apt, définissant l'accès aux dépôts via Internet.

L'installation réelle de NGINX Unit et de NGINX se déroule dans la section suivante. Nous ajoutons au préalable des dépôts afin de ne pas mettre à jour les métadonnées plusieurs fois, ce qui rend l'installation plus rapide.

code du 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

Installation de NGINX, NGINX Unit, PHP MariaDB, Certbot (Let’s Encrypt) et de leurs dépendances

Une fois tous les dépôts ajoutés, nous mettons à jour les métadonnées et installons les applications. Les paquets installés par le script comprennent également les extensions PHP recommandées lors du démarrage de WordPress.org.

code du script

echo " Mise à jour des métadonnées du dépôt"
apt-get -qq update

# Installer PHP avec les dépendances et NGINX Unit
echo " Installation de PHP, NGINX Unit, NGINX, Certbot et 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

Configuration de PHP pour utilisation avec NGINX Unit et WordPress

Le script crée un fichier de configuration dans le répertoire conf.d. Ici, la taille maximale des fichiers téléchargés pour PHP est définie, l'affichage des erreurs PHP dans STDERR est activé, afin qu'elles soient enregistrées dans le journal de NGINX Unit, et NGINX Unit est également redémarré.

code du 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

Configuration des paramètres de la base de données MariaDB pour WordPress

Nous avons choisi MariaDB au lieu de MySQL, car elle a une communauté plus active, et de plus, elle peut offrir de meilleures performances par défaut. (Probablement, c'est plus simple ici : pour installer MySQL, il faut ajouter un autre dépôt, note du traducteur).

Le script crée une nouvelle base de données et génère des identifiants d'accès pour WordPress via l'interface loopback :

code du 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;"

Installation du programme WordPress CLI

À cette étape, le script installe le programme WP-CLI. Grâce à lui, il est possible d'installer et de gérer les réglages de WordPress sans avoir à modifier manuellement des fichiers, mettre à jour la base ou se connecter au panneau de contrôle. Il permet également d'installer des thèmes et des extensions et de mettre à jour WordPress.

code du script

if [ ! -f /usr/local/bin/wp ]; then
  # Installer l'outil WordPress CLI
  echo " Installation de l'outil WordPress CLI"
  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

Installation et configuration de WordPress

Le script installe la dernière version de WordPress dans le répertoire /var/www/wordpress, et modifie également les réglages :

• La connexion à la base de données fonctionne via le socket de domaine unix au lieu de TCP sur loopback pour réduire le trafic TCP.
• WordPress ajoute un préfixe. https:// à l'URL, si les clients se connectent à NGINX via le protocole HTTPS, et envoie l'hôte distant (comme le fournit NGINX) à PHP. Nous appliquons un petit bout de code pour le configurer.
• WordPress a besoin de HTTPS pour se connecter.
• La structure d'URL par défaut est basée sur les ressources.
• Les bons droits sont appliqués au système de fichiers pour le répertoire WordPress.

code du script

if [ ! -d /var/www/wordpress ]; then
  # Créer les répertoires WordPress
  mkdir -p /var/www/wordpress
  chown -R www-data:www-data /var/www

  # Télécharger WordPress en utilisant la CLI WordPress
  echo " Installation de 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}""

  # Cet extrait est injecté dans le fichier wp-config.php lorsqu'il est créé ;
  # il informe WordPress que nous sommes derrière un proxy inverse et, en tant que tel,
  # lui permet de générer des liens en utilisant HTTPS
  cat > /tmp/wp_forwarded_for.php << 'EOM'
/* Activer HTTPS 'si' HTTP_X_FORWARDED_PROTO correspond à '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

  # Créer la configuration WordPress
  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

  # Installer 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

  # Définir la structure de permalien à une valeur par défaut sensée qui n'est pas dans l'UI
  su -s /bin/sh -p -c "wp --path=/var/www/wordpress option update permalink_structure '/%year%/%monthnum%/%postname%/'" www-data

  # Supprimer le fichier d'exemple parce que c'est un ordure et pourrait poser un problème de sécurité
  rm /var/www/wordpress/wp-config-sample.php

  # S'assurer que les permissions WordPress sont correctes
  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

Configuration de NGINX Unit

Le script configure NGINX Unit pour exécuter PHP et traiter les chemins WordPress, en isolant l'espace de noms des processus PHP et en optimisant les réglages de performance. Voici trois fonctions à noter :

• Le support des espaces de noms est défini par une condition, basé sur la vérification du lancement du script dans le conteneur. Cela est nécessaire car la plupart des réglages de conteneur ne supportent pas le lancement imbriqué de conteneurs.
• Si le support des espaces de noms est présent, l'espace de noms est désactivé. réseau. Cela est nécessaire pour permettre à WordPress de se connecter simultanément aux endpoints et d'être accessible sur Internet.
• Le nombre maximum de processus est déterminé comme suit : (Mémoire disponible pour les instances MariaDB et NGINX Uniy) / (limite de mémoire allouée en PHP + 5)
  Cette valeur est configurée dans les paramètres de NGINX Unit.

Cette valeur suppose également qu’il y a toujours au moins deux processus PHP en cours d'exécution, ce qui est important car WordPress effectue de nombreuses requêtes asynchrones sur lui-même. Sans processus supplémentaires, le lancement, par exemple, de WP-Cron échouera. Vous voudrez peut-être ajuster ces limites en fonction de vos paramètres locaux, car les configurations créées ici sont conservatrices. La plupart des systèmes de production se situent entre 10 et 100.

code du 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 " Nombre maximum de processus PHP calculé comme ${MAX_PHP_PROCESSES}. Vous voudrez peut-être ajuster cette valeur en raison des variations dans votre configuration. Il n'est pas rare de voir des valeurs comprises entre 10 et 100 dans les configurations de production."

echo " Configuration de NGINX Unit pour utiliser PHP et 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

Configuration de NGINX

Configuration des paramètres principaux de NGINX

Le script crée un répertoire pour le cache NGINX, puis crée le fichier de configuration principal. nginx.conf. Veuillez prêter attention au nombre de processus manipulateurs et à la définition de la taille maximale du fichier à télécharger. Il y a aussi une ligne qui connecte un fichier de configuration de compression, défini dans la section suivante, suivie des paramètres de mise en cache.

code du 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

Configuration de la compression NGINX

La compression du contenu à la volée avant de l'envoyer aux clients est un excellent moyen d'améliorer la performance du site, à condition que la compression soit correctement configurée. Cette section du script est basée sur les paramètres d'ici.

code du script

cat > ${NGINX_CONF_DIR}\/gzip_compression.conf << 'EOM'
# Crédit : https://github.com/h5bp/server-configs-nginx/
# ----------------------------------------------------------------------
# | Compression                                                        |
# ----------------------------------------------------------------------
# https://nginx.org/en/docs/http/ngx_http_gzip_module.html
# Activez la compression gzip.
# Par défaut : désactivé
gzip on;
# Niveau de compression (1-9).
# 5 est un bon compromis entre taille et utilisation CPU, offrant environ 75%
# de réduction pour la plupart des fichiers ASCII (presque identique au niveau 9).
# Par défaut : 1
gzip_comp_level 6;
# Ne compressez rien qui soit déjà petit et peu susceptible de réduire beaucoup si
# du tout (la valeur par défaut est 20 octets, ce qui est mauvais car cela mène souvent à des fichiers plus gros après compression gzip).
# Par défaut : 20
gzip_min_length 256;
# Compresser les données même pour les clients qui se connectent via des proxies,
# identifiés par l'en-tête "Via" (nécessaire pour CloudFront).
# Par défaut : désactivé
gzip_proxied any;
# Dites aux proxies de mettre en cache à la fois la version gzippée et la version régulière d'une ressource
# chaque fois que l'en-tête des capacités Accept-Encoding du client varie ;
# Évite le problème où un client non compatible gzip (qui est extrêmement rare aujourd'hui)
# afficherait des caractères inintelligibles si leur proxy leur donnait la version gzippée.
# Par défaut : désactivé
gzip_vary on;
# Compresser toutes les sorties étiquetées avec l'un des types MIME suivants.
# `text/html` est toujours compressé par le module gzip.
# Par défaut : 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

Configuration NGINX pour WordPress

Ensuite, le script crée un fichier de configuration pour WordPress default.conf dans le répertoire conf.d. Ici, vous pouvez paramétrer :

• Activation des certificats TLS obtenus auprès de Let's Encrypt via Certbot (sa configuration sera dans la section suivante)
• Configuration des paramètres de sécurité TLS, basée sur les recommandations de Let's Encrypt
• Activation de la mise en cache des requêtes passantes par défaut pendant 1 heure
• Désactivation de la journalisation des accès, ainsi que de la journalisation des erreurs, si le fichier n'est pas trouvé, pour deux fichiers fréquemment demandés : favicon.ico et robots.txt
• Interdiction d'accès aux fichiers cachés et à certains fichiers .php, pour empêcher tout accès non autorisé ou tout démarrage accidentel
• Désactiver la journalisation d'accès pour les fichiers statiques et les fichiers de polices
• Définir l'en-tête Access-Control-Allow-Origin pour les fichiers de polices
• Ajouter du routage pour index.php et d'autres fichiers statiques.

code du 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 utilisé par Certbot pour 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\/;
    # Configuration de Let's Encrypt
    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;
    # Cache proxy
    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;
    }

    # Refuser toutes les tentatives d'accès aux fichiers cachés tels que .htaccess, .htpasswd,
    # .DS_Store (Mac)
    # Garder un journal des requêtes pour les analyser plus tard (ou pour passer à des utilitaires de pare-feu
    # tels que fail2ban)
    location ~ \/. {
        deny all;
    }
    # Refuser l'accès à tous les fichiers avec une extension .php dans le répertoire uploads;
    # fonctionne dans les installations de sous-répertoire et aussi dans le réseau multisite.
    # Garder un journal des requêtes pour les analyser plus tard (ou pour passer à des utilitaires de pare-feu
    # tels que fail2ban).
    location ~* \/(?:uploads|files)\/.php$ {
        deny all;
    }
    # WordPress : refuser l'accès aux fichiers PHP de wp-content, wp-includes
    location ~* ^\/(?:wp-content|wp-includes)\/.php$ {
        deny all;
    }
    # Refuser l'accès public à wp-config.php
    location ~* wp-config.php {
        deny all;
    }
    # Ne pas journaliser l'accès aux ressources statiques, médias
    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

Configuration de Certbot pour les certificats de Let's Encrypt et leur renouvellement automatique

Certbot est un outil gratuit de l'Electronic Frontier Foundation (EFF) permettant d'obtenir et de renouveler automatiquement des certificats TLS de Let's Encrypt. Le script effectue les actions suivantes pour configurer Certbot afin de gérer les certificats de Let's Encrypt dans NGINX :

• Arrête NGINX
• Télécharge les paramètres TLS recommandés
• Lance Certbot pour obtenir des certificats pour le site
• Redémarre NGINX pour utiliser les certificats
• Configure l'exécution quotidienne de Certbot à 3h24 du matin pour vérifier la nécessité de renouveler les certificats, ainsi que, si nécessaire, pour télécharger de nouveaux certificats et redémarrer NGINX.

code du script

echo " Arrêt de NGINX pour configurer 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 " Téléchargement des paramètres TLS recommandés"
  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 "Impossible de télécharger le dernier options-ssl-nginx.conf"
fi

if [ ! -f ${NGINX_CONF_DIR}/ssl-dhparams.pem ]; then
  echo " Téléchargement des paramètres DH TLS recommandés"
  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 "Impossible de télécharger le dernier ssl-dhparams.pem"
fi

# Si tls_certs_init.sh n'a pas été exécuté auparavant, supprimer les certificats auto-signés
if [ ! -d "/etc/letsencrypt/accounts" ]; then
  echo " Suppression des certificats auto-signés"
  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 " Génération des certificats avec Let's Encrypt"
  certbot certonly --standalone 
         -m "${WORDPRESS_ADMIN_EMAIL}" 
         ${CERTBOT_STAGING_FLAG} 
         --agree-tos --force-renewal --non-interactive 
         -d "${TLS_HOSTNAME}"
fi

echo " Lancement de NGINX pour utiliser la nouvelle configuration"
service nginx start

# Écriture du crontab pour le renouvellement périodique des certificats Let's Encrypt
if [ "$(crontab -l | grep -m1 'certbot renew')" == "" ]; then
  echo " Ajout de certbot au crontab pour le renouvellement automatique de Let's Encrypt"
  (crontab -l 2>/dev/null; echo "24 3 * * * certbot renew --nginx --post-hook 'service nginx reload'" ) | crontab -
fi

Configuration supplémentaire de votre site

Nous avons expliqué ci-dessus comment notre script configure NGINX et NGINX Unit pour servir un site prêt pour le déploiement avec TLS SSL activé. Vous pouvez également, en fonction de vos besoins, ajouter à l'avenir :

• Support Brotli, compression améliorée à la volée via HTTPS
• ModSecurity avec règles pour WordPress, afin de prévenir les attaques automatiques sur votre site
• Sauvegarde pour WordPress, adapté à vos besoins
• Protection à l'aide de AppArmor (sur Ubuntu)
• Postfix ou msmtp pour que WordPress puisse envoyer des emails
• Vérifications de votre site pour que vous sachiez combien de trafic il peut supporter

Pour des performances encore meilleures de votre site, nous vous recommandons de mettre à niveau vers NGINX Plus, notre produit commercial de niveau entreprise, basé sur NGINX open source. Ses abonnés bénéficieront d'un module Brotli chargé dynamiquement, ainsi que (en supplément) NGINX ModSecurity WAF. Nous proposons également NGINX App Protect, un module WAF pour NGINX Plus basé sur une technologie de sécurité de premier plan dans l'industrie, de F5.

N.B. Pour le soutien d'un site à fort trafic, vous pouvez contacter des spécialistes Southbridge. Nous assurerons le bon fonctionnement rapide et fiable de votre site ou service sous n'importe quelle charge.

Source : habr.com