Il existe de nombreux tutoriels sur la façon d'installer WordPress, une recherche Google pour « Installation WordPress » donnera environ un demi-million de résultats. Cependant, en fait, il existe très peu de bons guides parmi eux, selon lesquels vous pouvez installer et configurer WordPress et le système d'exploitation sous-jacent afin qu'ils soient capables de prendre en charge pendant une longue période. Peut-être que les paramètres corrects dépendent fortement de besoins spécifiques, ou cela est dû au fait qu'une explication détaillée rend l'article difficile à lire.
Dans cet article, nous allons essayer de combiner le meilleur des deux mondes en fournissant un script bash pour installer automatiquement WordPress sur Ubuntu, ainsi que le parcourir en expliquant le rôle de chaque élément, ainsi que les compromis que nous avons faits lors de son développement. . Si vous êtes un utilisateur avancé, vous pouvez ignorer le texte de l'article et simplement pour modification et utilisation dans vos environnements. Le résultat du script est une installation WordPress personnalisée avec prise en charge Lets Encrypt, exécutée sur NGINX Unit et adaptée à une utilisation en production.
L'architecture développée pour le déploiement de WordPress à l'aide de l'unité NGINX est décrite dans , nous allons maintenant également configurer davantage des éléments qui n'y étaient pas abordés (comme dans de nombreux autres tutoriels) :
- Interface de ligne de commande WordPress
- Let's Encrypt et les certificats TLSSSL
- Renouvellement automatique des certificats
- Mise en cache NGINX
- Compression NGINX
- Prise en charge HTTPS et HTTP/2
- Automatisation des processus
L'article décrira l'installation sur un serveur, qui hébergera simultanément un serveur de traitement statique, un serveur de traitement PHP et une base de données. L'installation avec prise en charge de plusieurs hôtes et services virtuels est un sujet potentiel pour l'avenir. Si vous souhaitez que nous écrivions sur quelque chose qui ne figure pas dans ces articles, écrivez dans les commentaires.
Exigences
- Serveur de conteneur ( ou ), une machine virtuelle ou un serveur Iron standard avec au moins 512 Mo de RAM et Ubuntu 18.04 ou plus récent installé.
- Ports accessibles par Internet 80 et 443
- Nom de domaine associé à l'adresse IP publique de ce serveur
- Accès root (sudo).
Présentation de l'architecture
L'architecture est la même que celle décrite , une application Web à trois niveaux. Il se compose de scripts PHP exécutés sur le moteur PHP et de fichiers statiques traités par le serveur Web.
Principes généraux
- De nombreuses commandes de configuration dans un script sont enveloppées dans des conditions d'idempotence : le script peut être exécuté plusieurs fois sans risque de modifier les paramètres déjà en place.
- Le script tente d'installer des logiciels à partir de référentiels afin que vous puissiez appliquer les mises à jour du système en une seule commande (
apt upgradepour Ubuntu). - Les commandes tentent de détecter qu'elles s'exécutent dans un conteneur afin de pouvoir modifier leurs paramètres en conséquence.
- Afin de définir le nombre de processus de thread à démarrer dans les paramètres, le script essaie de deviner les paramètres automatiques pour travailler dans les conteneurs, les machines virtuelles et les serveurs matériels.
- Lorsque nous décrivons les paramètres, nous pensons toujours en premier lieu à l'automatisation, qui, nous l'espérons, deviendra la base pour créer votre propre infrastructure sous forme de code.
- Toutes les commandes s'exécutent en tant qu'utilisateur racine, car ils modifient les paramètres de base du système, mais WordPress lui-même fonctionne en tant qu'utilisateur régulier.
Définition 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 WordPressWORDPRESS_ADMIN_USER- Nom de l'administrateur WordPressWORDPRESS_ADMIN_PASSWORD- Mot de passe administrateur WordPressWORDPRESS_ADMIN_EMAIL- E-mail de l'administrateur WordPressWORDPRESS_URL– URL complète du site WordPress, commençant parhttps://.LETS_ENCRYPT_STAGING— vide par défaut, mais en définissant la valeur sur 1, vous utiliserez les serveurs intermédiaires de Let's Encrypt, qui sont nécessaires pour demander fréquemment des certificats lors du test de vos paramètres, sinon Let's Encrypt pourrait bloquer temporairement votre adresse IP en raison du grand nombre de requêtes.
Le script vérifie que ces variables liées à WordPress sont définies et se ferme sinon.
Les lignes de script 572 à 576 vérifient la valeur LETS_ENCRYPT_STAGING.
Définition de variables d'environnement dérivées
Le script des lignes 55 à 61 définit les variables d'environnement suivantes, soit sur une valeur codée en dur, soit en utilisant une valeur obtenue à partir des variables définies dans la section précédente :
DEBIAN_FRONTEND="noninteractive"- indique aux applications qu'elles s'exécutent dans un script et qu'il n'y a aucune possibilité d'interaction avec l'utilisateur.WORDPRESS_CLI_VERSION="2.4.0"est la 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 variableWORDPRESS_CLI_VERSION). Le script de la ligne 162 utilise cette valeur pour vérifier que le bon fichier WordPress CLI a été téléchargé.UPLOAD_MAX_FILESIZE="16M"- la taille maximale du fichier pouvant être téléchargé dans WordPress. Ce paramètre est utilisé à plusieurs endroits, il est donc plus facile de le définir au même endroit.TLS_HOSTNAME= "$(echo ${WORDPRESS_URL} | cut -d'/' -f3)"- nom d'hôte du système, récupéré de la variable WORDPRESS_URL. Utilisé pour obtenir les certificats TLS/SSL appropriés de Let's Encrypt ainsi que la vérification interne de WordPress.NGINX_CONF_DIR="/etc/nginx"- chemin d'accès au répertoire avec les paramètres NGINX, y compris le fichier principalnginx.conf.CERT_DIR="/etc/letsencrypt/live/${TLS_HOSTNAME}"— le chemin d'accès aux certificats Let's Encrypt pour le site WordPress, obtenu à partir de la variableTLS_HOSTNAME.
Attribuer un nom d'hôte à un serveur WordPress
Le script définit le nom d'hôte du serveur pour qu'il corresponde au nom de domaine du site. Ce n'est pas obligatoire, mais il est plus pratique d'envoyer du courrier sortant via SMTP lors de la configuration d'un seul serveur, tel que configuré par le script.
code de 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}"
fiAjout du nom d'hôte à /etc/hosts
Addition utilisé pour exécuter des tâches périodiques, nécessite que WordPress puisse y accéder via HTTP. Pour s'assurer que WP-Cron fonctionne correctement sur tous les environnements, le script ajoute une ligne au fichier / Etc / hostspour que WordPress puisse accéder à lui-même via l'interface de bouclage :
code de 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
fiInstallation des outils requis pour les prochaines étapes
Le reste du script nécessite quelques programmes et suppose que les référentiels sont à jour. Nous mettons à jour la liste des référentiels, après quoi nous installons les outils nécessaires :
code de 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-releaseAjout d'une unité NGINX et de référentiels NGINX
Le script installe NGINX Unit et NGINX open source à partir des référentiels officiels NGINX pour garantir que les versions avec les derniers correctifs de sécurité et corrections de bogues sont utilisées.
Le script ajoute le référentiel NGINX Unit puis le référentiel NGINX, en ajoutant la clé du référentiel et les fichiers de configuration apt, définissant l'accès aux référentiels via Internet.
L'installation proprement dite de NGINX Unit et de NGINX se déroule dans la section suivante. Nous pré-ajoutons les référentiels afin de ne pas avoir à mettre à jour les métadonnées plusieurs fois, ce qui accélère l'installation.
code de 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
fiInstallation de NGINX, NGINX Unit, PHP MariaDB, Certbot (Let's Encrypt) et leurs dépendances
Une fois tous les référentiels ajoutés, mettez à jour les métadonnées et installez les applications. Les packages installés par le script incluent également les extensions PHP recommandées lors de l'exécution de WordPress.org
code de 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-serverConfiguration de PHP pour une utilisation avec NGINX Unit et WordPress
Le script crée un fichier de paramètres dans le répertoire conf.d. Cela définit la taille maximale des téléchargements PHP, active la sortie d'erreur PHP sur STDERR afin qu'ils soient écrits dans le journal de l'unité NGINX et redémarre l'unité NGINX.
code de 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 restartSpécification des paramètres de la base de données MariaDB pour WordPress
Nous avons choisi MariaDB plutôt que MySQL car elle a plus d'activité communautaire et peut également (Probablement, tout est plus simple ici : pour installer MySQL, vous devez ajouter un autre référentiel, environ. traducteur).
Le script crée une nouvelle base de données et crée des informations d'identification pour accéder à WordPress via l'interface de bouclage :
code de 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
A cette étape, le script installe le programme . Avec lui, vous pouvez installer et gérer les paramètres de WordPress sans avoir à modifier manuellement les fichiers, à mettre à jour la base de données ou à vous connecter au panneau de configuration. Il peut également être utilisé pour installer des thèmes et des modules complémentaires et mettre à jour WordPress.
code de 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
fiInstallation et configuration de WordPress
Le script installe la dernière version de WordPress dans un répertoire /var/www/wordpresset modifie également les paramètres :
- La connexion à la base de données fonctionne sur un socket de domaine Unix au lieu de TCP lors du bouclage pour réduire le trafic TCP.
- WordPress ajoute un préfixe https:// à l'URL si les clients se connectent à NGINX via HTTPS, et envoie également le nom d'hôte distant (tel que fourni par NGINX) à PHP. Nous utilisons un morceau de code pour configurer cela.
- WordPress a besoin de HTTPS pour se connecter
- La structure d'URL par défaut est basée sur les ressources
- Définit les autorisations correctes sur le système de fichiers pour le répertoire WordPress.
code de 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
fiConfiguration de l'unité NGINX
Le script configure l'unité NGINX pour exécuter PHP et traiter les chemins WordPress, isolant l'espace de noms du processus PHP et optimisant les paramètres de performances. Il y a trois fonctionnalités à surveiller ici :
- La prise en charge des espaces de noms est déterminée par condition, en fonction de la vérification que le script est exécuté dans un conteneur. Cela est nécessaire car la plupart des configurations de conteneurs ne prennent pas en charge le lancement imbriqué de conteneurs.
- S'il existe une prise en charge des espaces de noms, désactivez l'espace de noms réseau et. Cela permet à WordPress de se connecter aux deux points de terminaison et d’être disponible sur le Web en même temps.
- Le nombre maximum de processus est déterminé comme suit : (Mémoire disponible pour exécuter MariaDB et NGINX Uniy)/(Limite RAM en PHP + 5)
Cette valeur est définie dans les paramètres de l'unité NGINX.
Cette valeur implique également qu'il y a toujours au moins deux processus PHP en cours d'exécution, ce qui est important car WordPress se fait beaucoup de requêtes asynchrones, et sans processus supplémentaires en cours d'exécution, par exemple, WP-Cron tombera en panne. Vous souhaiterez peut-être augmenter ou diminuer ces limites en fonction de vos paramètres locaux, car les paramètres créés ici sont conservateurs. Sur la plupart des systèmes de production, les paramètres sont compris entre 10 et 100.
code de 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/configConfiguration de NGINX
Configuration des paramètres NGINX de base
Le script crée un répertoire pour le cache NGINX puis crée le fichier de configuration principal nginx.conf. Faites attention au nombre de processus de gestion et au paramètre de taille maximale du fichier à télécharger. Il existe également une ligne qui inclut le fichier de paramètres de compression défini dans la section suivante, suivi des paramètres de mise en cache.
code de 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;
}
EOMConfiguration de la compression NGINX
Compresser le contenu à la volée avant de l'envoyer aux clients est un excellent moyen d'améliorer les performances du site, mais uniquement si la compression est correctement configurée. Cette section du script est basée sur les paramètres .
code de 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;
EOMConfiguration de NGINX pour WordPress
Ensuite, le script crée un fichier de configuration pour WordPress par défaut.conf dans le catalogue conf.d. Ici, il est configuré :
- Activation des certificats TLS reçus de Let's Encrypt via Certbot (la configuration sera dans la section suivante)
- Configuration des paramètres de sécurité TLS en fonction des recommandations de Let's Encrypt
- Activer la mise en cache des requêtes ignorées pendant 1 heure par défaut
- Désactivez la journalisation des accès, ainsi que la journalisation des erreurs si le fichier est introuvable, pour deux fichiers fréquemment demandés : favicon.ico et robots.txt.
- Empêcher l'accès aux fichiers cachés et à certains fichiers .phppour empêcher tout accès illégal ou tout démarrage involontaire
- Désactiver la journalisation des accès pour les fichiers statiques et de polices
- Paramétrage de l'en-tête pour les fichiers de polices
- Ajout de routage pour index.php et autres statistiques.
code de 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;
}
}
EOMConfigurer Certbot pour les certificats Let's Encrypt et les renouveler automatiquement
est un outil gratuit de l'Electronic Frontier Foundation (EFF) qui vous permet d'obtenir et de renouveler automatiquement les certificats TLS de Let's Encrypt. Le script effectue les opérations suivantes pour configurer Certbot afin qu'il traite les certificats de Let's Encrypt dans NGINX :
- Arrête NGINX
- Télécharge les paramètres TLS recommandés
- Exécute Certbot pour obtenir des certificats pour le site
- Redémarre NGINX pour utiliser les certificats
- Configure Certbot pour qu'il s'exécute quotidiennement à 3 h 24 pour vérifier si les certificats doivent être renouvelés et, si nécessaire, télécharger de nouveaux certificats et redémarrer NGINX.
code de 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 -
fiPersonnalisation supplémentaire de votre site
Nous avons expliqué ci-dessus comment notre script configure NGINX et NGINX Unit pour servir un site Web prêt pour la production avec TLSSSL activé. Vous pourrez également, selon vos besoins, ajouter à l'avenir :
- Soutenir , compression à la volée améliorée via HTTPS
- с pour empêcher les attaques automatisées sur votre site
- pour WordPress qui vous convient
- par (sur Ubuntu)
- Postfix ou msmtp pour que WordPress puisse envoyer du courrier
- Vérifier votre site pour comprendre le trafic qu'il peut gérer
Pour des performances de site encore meilleures, nous vous recommandons de passer à , notre produit commercial de niveau entreprise basé sur NGINX open source. Ses abonnés recevront un module Brotli chargé dynamiquement, ainsi que (moyennant des frais supplémentaires) . Nous proposons également , un module WAF pour NGINX Plus basé sur la technologie de sécurité de pointe de F5.
NB Pour la prise en charge d'un site très chargé, vous pouvez contacter les experts . Nous garantirons un fonctionnement rapide et fiable de votre site Web ou de votre service, quelle que soit la charge.
Source: habr.com