Automatizujeme instalaci WordPress s NGINX Unit a Ubuntu

Existuje mnoho materiálů k instalaci WordPressu, vyhledávání na Googlu pomocí klíčových slov "instalace WordPressu" vrátí kolem půl milionu výsledků. Přesto však mezi nimi je velmi málo kvalitních návodů, podle kterých lze instalovat a nakonfigurovat WordPress a podkladový operační systém tak, aby byly schopny dlouhodobé podpory. Možná, že správná nastavení se velmi liší podle konkrétních potřeb, nebo to může být způsobeno tím, že podrobné vysvětlení dělá článek těžko čitelným.

V tomto článku se pokusíme spojit to nejlepší z obou přístupů, poskytneme skript na bash pro automatickou instalaci WordPressu na Ubuntu a také projdeme skript, vysvětlíme, co dělá každá jeho část, a na jaké kompromisy jsme šli při jeho vývoji. Pokud jste zkušený uživatel — můžete přeskočit text článku a jednoduše vzít skript k modifikaci a používání ve vašem prostředí. Výstupem skriptu je konfigurovatelná instalace WordPressu s podporou Lets Encrypt, fungující na NGINX Unit a vhodná pro průmyslové použití.

Architektura navržená pro nasazení WordPressu s využitím NGINX Unit je popsána v starším článku, nyní také dále nastavíme věci, které tam nebyly pokryty (jak v mnoha dalších průvodcích):

• WordPress CLI
• Let’s Encrypt a TLS/SSL certifikáty
• Automatické obnovování certifikátů
• Caching NGINX
• Komprese NGINX
• Podpora HTTPS a HTTP/2
• Automatizace procesu

V článku bude popsána instalace na jednom serveru, na kterém budou současně umístěny server pro zpracování statiky, server pro zpracování PHP a databáze. Instalace s podporou více virtuálních hostitelů a služeb je potenciálním tématem do budoucna. Pokud chcete, abychom napsali o něčem, co v těchto článcích není, napište do komentářů.

Požadavky

• Server kontejner (LXC nebo LXD), virtuální stroj nebo běžný fyzický server s alespoň 512 MB operační paměti a nainstalovaným Ubuntu 18.04 nebo novější.
• Internetově dostupné porty 80 a 443
• Doménové jméno spojené s veřejnou IP adresou tohoto serveru
• Přístup s právy root (sudo).

Přehled architektury

Architektura je stejná, jak bylo popsáno dříve, třístupňová webová aplikace. Skládá se ze skriptů PHP, prováděných PHP zpracovatelem, a statických souborů, které zpracovává webový server.

Obecné zásady

• Mnoho příkazů pro konfiguraci ve skriptu je obaleno do podmínek (if) pro idempotentnost: skript lze spustit několikrát bez rizika změny nastavení, která již byla připravena.
• Skript se snaží instalovat software z repozitářů, takže můžete aktualizace systému aplikovat jedním příkazem (apt upgrade pro Ubuntu).
• Příkazy se snaží určit, že běží v kontejneru, aby podle toho změnily svá nastavení.
• Aby bylo možné stanovit počet spouštěných procesů/threads v nastavení, skript se pokouší uhodnout automatické parametry konfigurace pro práci v kontejnerech, virtuálních strojích a „fyzických“ serverech.
• Při popisování nastavení vždy přemýšlíme nejprve o automatizaci, která, jak doufáme, se stane základem pro vytvoření vaší vlastní infrastruktury jako kódu.
• Všechny příkazy se spouští jako uživatel root, protože mění základní systémová nastavení, ale samotný WordPress běží jako běžný uživatel.

Nastavení proměnných prostředí

Před spuštěním skriptu nastavte následující proměnné prostředí:

• WORDPRESS_DB_PASSWORD — heslo k databázi WordPressu
• WORDPRESS_ADMIN_USER — uživatelské jméno administrátora WordPressu
• WORDPRESS_ADMIN_PASSWORD — heslo administrátora WordPressu
• WORDPRESS_ADMIN_EMAIL — e-mail administrátora WordPressu
• WORDPRESS_URL — kompletní URL adresa webu WordPress, počínaje https://.
• LETS_ENCRYPT_STAGING — ve výchozím nastavení prázdné, ale pokud nastavíte hodnotu na 1, budete používat staging servery Let’s Encrypt, což je nezbytné pro časté požadavky na certifikáty při testování vašich nastavení, jinak může Let’s Encrypt dočasně zablokovat vaši IP adresu kvůli vysokému počtu požadavků.

Skript kontroluje, zda jsou tyto proměnné spojené s WordPressem nastaveny, a ukončí běh, pokud nejsou.
Řádky skriptu 572-576 kontrolují hodnotu LETS_ENCRYPT_STAGING.

Nastavení odvozených proměnných prostředí

Skript na řádcích 55-61 nastavuje následující proměnné prostředí, buď na nějakou pevně danou hodnotu, nebo pomocí hodnoty získané z proměnných nastavených v předchozí části:

• DEBIAN_FRONTEND="noninteractive" — informuje aplikace, že se spouštějí ve skriptu a není možné interagovat s uživatelským rozhraním.
• WORDPRESS_CLI_VERSION="2.4.0" — verze aplikace WordPress CLI.
• WORDPRESS_CLI_MD5= "dedd5a662b80cda66e9e25d44c23b25c" — kontrolní součet spustitelného souboru WordPress CLI 2.4.0 (verze je uvedena v proměnné WORDPRESS_CLI_VERSION). Skript na 162. řádku používá tuto hodnotu k ověření, že byl stažen správný soubor WordPress CLI.
• UPLOAD_MAX_FILESIZE="16M" — maximální velikost souboru, který může být nahrán do WordPressu. Toto nastavení se používá na několika místech, takže je jednodušší ho stanovit na jednom místě.
• TLS_HOSTNAME= "$(echo ${WORDPRESS_URL} | cut -d'\/' -f3)" — hostname systému, extrahovaný z proměnné WORDPRESS_URL. Používá se pro získání odpovídajících TLS/SSL certifikátů od Let’s Encrypt, a také pro interní ověření WordPressu.
• NGINX_CONF_DIR="\/etc\/nginx" — cesta k adresáři s nastaveními NGINX, včetně hlavního souboru nginx.conf.
• CERT_DIR="\/etc\/letsencrypt\/live\/${TLS_HOSTNAME}" — cesta k certifikátům Let’s Encrypt pro WordPress, získávaná z proměnné TLS_HOSTNAME.

Přiřazení hostname WordPress serveru

Skript nastavuje hostname serveru tak, aby hodnota odpovídala doménovému jménu webu. Není to nutné, ale usnadňuje to odesílání odchozí pošty prostřednictvím SMTP při nastavování jediného serveru, jak to konfiguruje skript.

kód skriptu

# 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

Přidání hostname do \/etc\/hosts

Doplnění WP‑Cron se používá pro spuštění periodických úloh, vyžaduje, aby WordPress mohl získat přístup sám k sobě pomocí HTTP. Aby se zajistilo, že WP-Cron funguje správně ve všech prostředích, skript přidává řádek do souboru /etc/hosts, aby WordPress mohl získat přístup k sobě prostřednictvím rozhraní loopback:

kód skriptu

# 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

Instalace nástrojů potřebných pro následující kroky

Zbytek skriptu vyžaduje některé programy a předpokládá, že repozitáře jsou aktuální. Aktualizujeme seznam repozitářů a poté nainstalujeme potřebné nástroje:

kód skriptu

# 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

Přidání repozitářů NGINX Unit a NGINX

Skript instaluje NGINX Unit a NGINX s otevřeným zdrojovým kódem z oficiálních repozitářů NGINX, aby se zajistilo, že se používají verze s nejnovějšími bezpečnostními aktualizacemi a opravami chyb.

Skript přidá repozitář NGINX Unit a poté repozitář NGINX, přidávající klíč repozitářů a konfigurační soubory apt, které zajišťují přístup k repozitářům přes internet.

Skutečná instalace NGINX Unit a NGINX probíhá v následující sekci. Nejprve přidáme repozitáře, abychom nemusela několikrát aktualizovat metadata, což zrychlí instalaci.

kód skriptu

# 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

Instalace NGINX, NGINX Unit, PHP, MariaDB, Certbot (Let’s Encrypt) a jejich závislostí

Jakmile jsou všechny repozitáře přidány, aktualizujeme metadata a nainstalujeme aplikace. Balíčky nainstalované skriptem také zahrnují PHP rozšíření doporučená při spuštění WordPress.org

kód skriptu

echo " Aktualizuji metadata repozitáře"
apt-get -qq update

# Instalace PHP se závislostmi a NGINX Unit
echo " Instalace PHP, NGINX Unit, NGINX, Certbot a 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

Nastavení PHP pro použití s NGINX Unit a WordPress

Skript vytváří konfigurační soubor v adresáři conf.d. Zde se nastavuje maximální velikost nahrávaných souborů pro PHP, aktivuje se výstup chyb PHP do STDERR, takže budou zapsány do protokolu NGINX Unit, a také se restartuje NGINX Unit.

kód skriptu

# 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

Nastavení databázových nastavení MariaDB pro WordPress

Zvolili jsme MariaDB místo MySQL, protože má větší aktivitu komunity, kromě toho, že možná poskytuje výkonnější výkon výchozí (pravděpodobně je to jednodušší: pro instalaci MySQL je třeba přidat další repo, pozn. překladatele).

Skript vytváří novou databázi a vytváří přihlašovací údaje pro přístup WordPress prostřednictvím smyčky:

kód skriptu

# 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;"

Instalace programu WordPress CLI

V tomto kroku skript instaluje program WP-CLI. Pomocí něj můžete instalovat a spravovat nastavení WordPress bez nutnosti ručně editovat soubory, aktualizovat databázi nebo vstupovat do administračního panelu. Také můžete nainstalovat šablony a pluginy a provést aktualizaci WordPress.

kód skriptu

if [ ! -f /usr/local/bin/wp ]; then
  # Instalace nástroje WordPress CLI
  echo " Instalace nástroje 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

Instalace a nastavení WordPress

Skript instaluje nejnovější verzi WordPress do adresáře /var/www/wordpress, a také mění nastavení:

• Připojení k databázi funguje přes unixový doménový socket místo TCP na loopback, aby se snížil TCP provoz.
• WordPress přidává prefix https:// k URL, pokud se klienti připojují k NGINX pomocí protokolu HTTPS, a také odesílá vzdálený hostname (jak to poskytuje NGINX) do PHP. Používáme k tomu úryvek kódu, abychom to nastavili.
• WordPress potřebuje HTTPS pro přihlášení
• Struktura URL je podle defaultu založena na zdrojích
• Jsou nastaveny správná oprávnění na souborovém systému pro adresář WordPress.

kód skriptu

if [ ! -d /var/www/wordpress ]; then
  # Vytvořte adresáře pro WordPress
  mkdir -p /var/www/wordpress
  chown -R www-data:www-data /var/www

  # Stáhněte WordPress pomocí WordPress CLI
  echo " Instalace 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}""

  # Tento úryvek je vkládán do souboru wp-config.php při jeho vytváření;
  # informuje WordPress, že jsme za reverzním proxy a tedy
  # umožňuje mu generovat odkazy pomocí HTTPS
  cat > /tmp/wp_forwarded_for.php << 'EOM'
/* Zapněte HTTPS 'on', pokud HTTP_X_FORWARDED_PROTO odpovídá '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

  # Vytvořte konfiguraci 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

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

  # Nastavte strukturu permalinku na rozumný výchozí formát, který není v UI
  su -s /bin/sh -p -c "wp --path=/var/www/wordpress option update permalink_structure '/%year%/%monthnum%/%postname%/'" www-data

  # Odstraňte ukázkový soubor, protože je zbytečný a mohl by být bezpečnostním problémem
  rm /var/www/wordpress/wp-config-sample.php

  # Zajistěte správná oprávnění pro WordPress
  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

Nastavení NGINX Unit

Skript nastavuje NGINX Unit pro spuštění PHP a zpracování cest WordPress, izoluje prostor jmenných procesů PHP a optimalizuje nastavení výkonu. Zde jsou tři funkce, na které byste měli dávat pozor:

• Podpora jmenných prostorů je stanovena podle podmínky a je založena na kontrole spuštění skriptu v kontejneru. To je potřeba, protože většina nastavení kontejnerů nepodporuje vnořené spouštění kontejnerů.
• Pokud je podpora jmenných prostorů, je prostor jmenný deaktivován síť. Je to potřeba, aby WordPress mohl současně připojovat a být přístupný na internetu.
• Maximální počet procesů se určuje následujícím způsobem: (Dostupná paměť pro spuštěné MariaDB a NGINX Uniy) / (limit podle operační paměti v PHP + 5)
  Tato hodnota se nastavuje v konfiguracích NGINX Unit.

Tato hodnota také předpokládá, že je vždy spuštěno alespoň dvě PHP procesy, což je důležité, protože WordPress provádí mnoho asynchronních dotazů na sebe, a bez dalších procesů se spuštění, například WP-Cron, rozbije. Možná budete chtít tyto limity zvýšit nebo snížit na základě vašich místních nastavení, protože zde vytvořené nastavení je konzervativní. Většina výrobních systémů má nastavení mezi 10 a 100.

kód skriptu

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 " Vypočítal maximální počet PHP procesů jako ${MAX_PHP_PROCESSES}. Možná budete chtít tuto hodnotu upravit kvůli variacím ve vaší konfiguraci. Není neobvyklé vidět hodnoty mezi 10-100 v produkčních konfiguracích."

echo " Konfigurace NGINX Unit k použití PHP a 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

Konfigurace NGINX

Nastavení základních parametrů NGINX

Skript vytváří adresář pro cache NGINX a poté vytváří hlavní konfigurační soubor nginx.conf. Všimněte si počtu zpracovatelských procesů a nastavení maximální velikosti souboru pro načítání. Dále je zde řádek, na kterém se připojuje konfigurační soubor pro kompresi, definovaný v následující části, a poté následují nastavení kešování.

kód skriptu

# 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

Nastavení komprese NGINX

Kompresní obsah za letu před jeho odesláním klientům je skvělý způsob, jak zlepšit výkon webu, ale pouze pokud je komprese správně nastavena. Tato část skriptu je založena na nastaveních odsud.

kód skriptu

cat > ${NGINX_CONF_DIR}/gzip_compression.conf << 'EOM'
# Credit: https://github.com/h5bp/server-configs-nginx/
# ----------------------------------------------------------------------
# | Komprese                                                        |
# ----------------------------------------------------------------------
# https://nginx.org/en/docs/http/ngx_http_gzip_module.html
# Povolit gzip kompresi.
# Výchozí: vypnuto
gzip on;
# Úroveň komprese (1-9).
# 5 je dokonalý kompromis mezi velikostí a využitím CPU, nabízející zhruba 75%
# snížení pro většinu ASCII souborů (téměř identické s úrovní 9).
# Výchozí: 1
gzip_comp_level 6;
# Nebuďte zkomprimováni nic, co je již malé a pravděpodobně se moc nezmenší,
# (výchozí je 20 bajtů, což je špatné, protože to obvykle vede k větším
# souborům po zkomprimování).
# Výchozí: 20
gzip_min_length 256;
# Komprimovat data i pro klienty, kteří se k nám připojují přes proxy,
# identifikované pomocí hlavičky "Via" (požadováno pro CloudFront).
# Výchozí: vypnuto
gzip_proxied any;
# Řekněte proxy, aby ukládaly do cache jak zkomprimovanou, tak běžnou verzi zdroje
# whenever client's Accept-Encoding capabilities header varies;
# Vyhýbá se problému, kdy by klient, který není schopný gzip (což je dnes velmi vzácné)
# zobrazuje nesmysly, když mu jeho proxy poskytne zkomprimovanou verzi.
# Výchozí: vypnuto
gzip_vary on;
# Komprimovat veškerý výstup označený jednou z následujících MIME typů.
# `text/html` je vždy komprimován gzip modulem.
# Výchozí: 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

Nastavení NGINX pro WordPress

Dále skript vytváří konfigurační soubor pro WordPress default.conf ve složce conf.d. Zde se nastavuje:

• Aktivace certifikátů TLS, získaných od Let’s Encrypt přes Certbot (jeho nastavení bude v následující části)
• Nastavení parametrů zabezpečení TLS, založené na doporučeních od Let’s Encrypt
• Připojení kešování přicházejících požadavků na 1 hodinu ve výchozím nastavení
• Zrušení protokolování přístupu a také protokolování chyb, pokud soubor nebyl nalezen, pro dva obecně požadované soubory: favicon.ico a robots.txt
• Zákaz přístupu k skrytým souborům a některým souborům .php, aby se zabránilo nelegálnímu přístupu nebo neúmyslnému spuštění
• Vypnutí protokolování přístupu pro statiku a fonty
• Nastavení hlavičky Access-Control-Allow-Origin pro fonty
• Přidání routování pro index.php a další statické soubory.

kód skriptu

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 používaný Certbotem pro 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\/;
    # Konfigurace 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;
    # 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;
    }

    # Zákaz všech pokusů o přístup k skrytým souborům, jako jsou .htaccess, .htpasswd,
    # .DS_Store (Mac)
    # Zachovat protokolování požadavků pro pozdější analýzu (nebo pro předání firewallovým nástrojům
    # jako fail2ban)
    location ~ \/. {
        deny all;
    }
    # Zákaz přístupu k jakýmkoliv souborům s příponou .php v adresáři uploads;
    # funguje v instalacích subdirectory a také v multi-site síti.
    # Zachovat protokolování požadavků pro pozdější analýzu (nebo pro předání firewallovým nástrojům
    # jako fail2ban).
    location ~* \/(?:uploads|files)\/.php$ {
        deny all;
    }
    # WordPress: zákaz přístupu k PHP souborům wp-content, wp-includes
    location ~* ^\/(?:wp-content|wp-includes)\/.php$ {
        deny all;
    }
    # Zákaz veřejného přístupu k wp-config.php
    location ~* wp-config.php {
        deny all;
    }
    # Nezapisovat přístup pro statické prostředky, média
    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

Nastavení Certbotu pro certifikáty od Let's Encrypt a jejich automatické prodlužování

Certbot je bezplatný nástroj od Electronic Frontier Foundation (EFF), který umožňuje získávat a automaticky obnovovat certifikáty TLS od Let's Encrypt. Skript provádí následující kroky, které vedou k nastavení Certbotu pro zpracování certifikátů od Let's Encrypt v NGINX:

• Zastaví NGINX
• Stáhne doporučené parametry TLS
• Spustí Certbot, aby získal certifikáty pro web
• Restartuje NGINX, aby používal certifikáty
• Nastaví denní spuštění Certbotu ve 3:24 v noci pro kontrolu potřeby obnovení certifikátů a, pokud je to nutné, pro stažení nových certifikátů a restartování NGINX.

kód skriptu

echo " Zastavuji NGINX, abych nastavil 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 " Stahuji doporučené TLS parametry"
  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 "Nepodařilo se stáhnout nejnovější options-ssl-nginx.conf"
fi

if [ ! -f ${NGINX_CONF_DIR}/ssl-dhparams.pem ]; then
  echo " Stahuji doporučené TLS DH parametry"
  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 "Nepodařilo se stáhnout nejnovější ssl-dhparams.pem"
fi

# Pokud nebyl skript tls_certs_init.sh spuštěn předtím, odstraní se certifikáty se samostatným podpisem
if [ ! -d "/etc/letsencrypt/accounts" ]; then
  echo " Odstraňuji certifikáty se samostatným podpisem"
  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 " Generuji certifikáty s Let's Encrypt"
  certbot certonly --standalone 
         -m "${WORDPRESS_ADMIN_EMAIL}" 
         ${CERTBOT_STAGING_FLAG} 
         --agree-tos --force-renewal --non-interactive 
         -d "${TLS_HOSTNAME}"
fi

echo " Spouštím NGINX, abych použil novou konfiguraci"
service nginx start

# Zapisuje crontab pro periodické obnovení certifikátu Let's Encrypt
if [ "$(crontab -l | grep -m1 'certbot renew')" == "" ]; then
  echo " Přidávám certbot do crontabu pro automatické obnovení Let's Encrypt"
  (crontab -l 2>/dev/null; echo "24 3 * * * certbot renew --nginx --post-hook 'service nginx reload'") | crontab -
fi

Další nastavení vašeho webu

Výše jsme popisovali, jak náš skript nastavuje NGINX a NGINX Unit pro obsluhu webu připraveného k průmyslovému nasazení s aktivním TLSSSL. Můžete však v závislosti na svých potřebách do budoucna přidat:

• Podporu Brotli, vylepšené komprimace v reálném čase přes HTTPS
• ModSecurity s pravidly pro WordPress, aby se zabránilo automatickým útokům na váš web
• Zálohování pro WordPress, které vám vyhovují
• Ochranu prostřednictvím AppArmor (na Ubuntu)
• Postfix nebo msmtp, aby WordPress mohl posílat e-maily
• Kontroly vašeho webu, abyste pochopili, kolik provozu může zvládnout

Pro ještě lepší výkon webu doporučujeme přejít na NGINX Plus, náš komerční produkt podnikové úrovně založený na open-source NGINX. Jeho předplatitelé získají dynamicky načítaný modul Brotli a také (za extra poplatek) NGINX ModSecurity WAF. Nabízíme také NGINX App Protect, modul WAF pro NGINX Plus, založený na průmyslově vedoucí bezpečnostní technologii od F5.

N.B. O podporu vysoce zatíženého webu se můžete obrátit na odborníky Southbridge. Zajistíme rychlý a spolehlivý chod vašeho webu nebo služby při jakékoli zátěži.

Zdroj: habr.com