🥇Automatiseerime WordPressi installimise NGINX Unit ja Ubuntu abil

WordPressi installimise kohta on palju materjale, Google'i otsing võtmesõnadega "WordPress install" annab umbes pool miljonit tulemust. Siiski on nende seas väga vähe korralikke juhendeid, mis aitaksid WordPressi ja alussüsteemi installida ja seadistada nii, et need saaksid pikaajalist toetust. Õiged seadistused võivad olenevalt konkreetsetest vajadustest oluliselt erineda, või võib-olla on see tingitud sellest, et detailsed selgitused muudavad artikli raskesti loetavaks.

Selles artiklis püüame ühendada kaks lähenemist, pakkudes bash skripti WordPressi automaatseks installimiseks Ubuntu süsteemile ning selgitades seejuures, mida iga skriptiosa teeb ja millistele kompromissidele me tema väljatöötamisel läksime. Kui olete kogenud kasutaja, võite artikli teksti vahele jätta ja lihtsalt võtta skripti muudatuste tegemiseks ja kasutamiseks oma keskkondades. Skripti tulemuseks on kohandatav WordPressi installatsioon Lets Encrypti toega, mis töötab NGINX Unit'il ja on tööstuslikuks kasutamiseks sobiv.

WordPressi juurutamiseks mõeldud arhitektuur NGINX Unity abil on kirjeldatud vanemas artiklis, nüüd seadistame täiendavalt ka asju, mida seal ei käsitletud (nagu paljudes teistes giidides):

WordPress CLI
Let’s Encrypt ja TLS/SSL sertifikaatid
Sertifikaatide automaatne uuendamine
NGINX vahemälu
NGINX tihendamine
HTTPS ja HTTP/2 tugi
Protsessi automatiseerimine

Artiklis käsitletakse paigaldust ühel serveril, kus samal ajal on olemas staatilise sisu server, PHP töötlemise server ja andmebaas. Mitme virtuaalse hosti ja teenuse toetava installatsiooni teema on tuleviku võimalus. Kui soovite, et kirjutaksime millestki, mida nende artiklite seas ei ole, andke meile kommentaarides teada.

Nõuded

Konteineriserver (LXC või LXD), virtuaalmasin või tavaline füüsiline server, millel on vähemalt 512 MB RAM-i ja installitud Ubuntu 18.04 või uuem versioon.
Interneti kaudu kergesti ligipääsetavad portid 80 ja 443
Domeen, mis on seotud selle serveri avaliku IP-aadressiga
Root (sudo) õigustega ligipääs.

Arhitektuuri ülevaade

Arhitektuur on sama, nagu oli kirjeldatud oleme teada saanud, kolme tasemi veebirakendus. See koosneb PHP skriptidest, mis käivitatakse PHP töötlejas, ja staatilistest failidest, mida töötleb veebiserver.

Üldised printsiibid

Paljud skripti seaded on mähitud tingimustesse (if), et tagada idempotentsus: skripti saab mitu korda käivitada ilma riskita muuta juba valmis seadistusi.
Skript püüab installida tarkvara hoidlatest, et saaksite rakendada süsteemi uuendusi ühe käsuga (apt upgrade Ubuntu jaoks).
Käsud püüavad kindlaks teha, et nad käivitatakse konteineris, et muuta oma seadistusi vastavalt.
Käivitamisprotsesside (töötajate) arvu seadmiseks proovib skript ära arvata automaatseid seadistusparameetreid, et töötada konteinerites, virtuaalmasinates ja füüsilistes serverites.
Seadiste kirjeldamisel mõtleme alati kõigepealt automatiseerimisele, mis, nagu me loodame, saab aluseks teie enda infrastruktuuri loomisele koodina.
Kõik käsud käivituvad kasutaja poolt root, sest need muudavad põhitoimingute seadistusi, kuid WordPress töötab tavalise kasutaja alt.

Keskkonna muutujate seadistamine

Seadke järgmised keskkonnamuutujad enne skripti käivitamist:

WORDPRESS_DB_PASSWORD — WordPressi andmebaasi parool
WORDPRESS_ADMIN_USER — WordPressi administraatori nimi
WORDPRESS_ADMIN_PASSWORD — WordPressi administraatori parool
WORDPRESS_ADMIN_EMAIL — WordPressi administraatori meiliaadress
WORDPRESS_URL — WordPressi saidi täielik URL, alustades https://.
LETS_ENCRYPT_STAGING — vaikimisi tühi, kuid kui seadistate väärtuse 1, kasutate Let’s Encrypti stseeniserverit, mis on vajalik sertifikaatide sagedase nõudmise testimiseks, vastasel juhul võib Let’s Encrypt ajutiselt blokeerida teie IP-aadressi suure arvu päringute tõttu.

Skript kontrollib, et need WordPressiga seotud muutujad on seadistatud, ja lõpetab töö, kui ei ole.
Skripti read 572-576 kontrollivad väärtust LETS_ENCRYPT_STAGING.

Tüvi muude keskkonnamuutujate seadistamine

Skript ridadel 55-61 seadistab järgmised keskkonnamuutujad, kas mingi kindla väärtusega või kasutades eelmisest osast saadud muutujate väärtusi:

DEBIAN_FRONTEND="noninteractive" — teatab rakendustele, et neid käivitatakse skriptis ja kasutajaga suhtlemise võimalust ei ole.
WORDPRESS_CLI_VERSION="2.4.0" — WordPress CLI rakenduse versioon.
WORDPRESS_CLI_MD5= "dedd5a662b80cda66e9e25d44c23b25c" — WordPress CLI 2.4.0 käivitatava faili kontrollsumma (versioon on määratud muutuja WORDPRESS_CLI_VERSION). Skriptis, mida on 162. real, kasutatakse seda väärtust, et kontrollida, kas WordPress CLI õige fail on alla laaditud.
UPLOAD_MAX_FILESIZE="16M" — maksimaalne failisuurus, mida saab WordPressi üles laadida. Seda seadet kasutatakse mitmes kohas, seega on lihtsam see ühes kohas määrata.
TLS_HOSTNAME= "$(echo ${WORDPRESS_URL} | cut -d'/' -f3)" — süsteemi hostname, mis on saadud muutuja WORDPRESS_URL põhjal. Seda kasutatakse sobivate TLS/SSL sertifikaatide saamiseks Let’s Encryptilt ning ka WordPressi sisemiste kontrollide jaoks.
NGINX_CONF_DIR="/etc/nginx" — tee NGINX seadete katalooge, sealhulgas põhifail. nginx.conf.
CERT_DIR="/etc/letsencrypt/live/${TLS_HOSTNAME}" — tee Let’s Encrypt sertifikaatide jaoks WordPressi saidile, saadud muutuja TLS_HOSTNAME.

WordPressi serverile hostname määramine.

Skript määrab serveri hostname, et väärtus vastaks saidi domeeninimele. See ei ole kohustuslik, kuid see muudab väljamineva e-postiga SMTP kaudu saatmise lihtsamaks, kui seadistus on tehtud ühele serverile, nagu skriptis seadistatakse.

skripti kood

# 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

Hostname'i lisamine failile \/etc\/hosts

Täiendamine WP‑Cron kasutatakse perioodiliste ülesannete käivitamiseks, nõuab, et WordPress saaks iseendaga HTTP kaudu ühendust võtta. WP-Croni õigeks toimimiseks kõikides keskkondades lisab skript faili rea /etc/hosts, et WordPress saaks iseendaga loopback-liidese kaudu ühendust võtta:

skripti kood

# 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

Nõutavate tööriistade installeerimine järgmisteks sammudeks

Skripti järgmine osa vajab mitmeid programme ja eeldab, et hoidlad on ajakohased. Uuendame hoidlate loendit, seejärel installime vajalikud tööriistad:

skripti kood

# 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

NGINX Uniti ja NGINX'i hoidlate lisamine

Skript installib NGINX Uniti ja avatud lähtekoodiga NGINX'i ametlikest NGINX'i hoidlatest, et tagada, et kasutatakse uusimate turvauuenduste ja vea parandustega versioone.

Skript lisab NGINX Uniti hoidla, seejärel — NGINX'i hoidla, lisades hoidlate võtme ja seadefailid apt, mis määratlevad juurdepääsu hoidlatele internetis.

NGINX Unit ja NGINX tegelik installatsioon toimub järgmises jaotises. Eelnevalt lisame hoidlad, et vältida metateabe mitu korda uuendamist, mis muudab installatsiooni kiiremaks.

skripti kood

# 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

NGINXi, NGINX Uniti, PHP MariaDB, Certboti (Let’s Encrypt) ja nende sõltuvuste installimine

Kui kõik hoidlad on lisatud, värskendame metateavet ja installime rakendused. Skripti poolt installitavad paketid hõlmavad ka PHP laiendusi, mis on soovitatavad WordPress.org käivitamisel.

skripti kood

echo " Väärskendame hoidlate metateavet"
apt-get -qq update

# Installi PHP koos sõltuvustega ja NGINX Unit
echo " Installin PHP, NGINX Uniti, NGINXi, Certboti ja 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

PHP seadistamine NGINX Uniti ja WordPressi kasutamiseks

Skript loob seadistusfaili kaustas conf.d. Siin määratakse PHP jaoks üleslaadimise maksimaalne failisuurus, lubatakse PHP veateated STDERR-is, nii et need registreeritakse NGINX Uniti logisse, samuti taaskäivitatakse NGINX Unit.

skripti kood

# 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

MariaDB andmebaasi seadistamine WordPressi jaoks

Oleme valinud MariaDB MySQLi asemel, kuna sellel on aktiivsem kogukond ja see on võib-olla... pakub parem jõudlust vaikimisi (ilmselt on siin kõik lihtsam: MySQL-i installimiseks tuleb lisada veel üks hoidla, tõlkija märk.).

Skript loob uue andmebaasi ja loob WordPressi ligipääsu andmed läbi loopbacki liidese:

skripti kood

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

WordPress CLI programmi installimine

Sellel sammul skript installib programmi WP-CLI. Selle abil saab installida ja hallata WordPressi seadistusi ilma faili käsitsi parandamiseta, andmebaasi värskendamiseta või juhtpaneeli sisenemiseta. Samuti saab selle abil installida teemasid ja lisandeid ning teostada WordPressi värskendusi.

skripti kood

if [ ! -f /usr/local/bin/wp ]; then
  # Installige WordPress CLI
  echo " WordPress CLI tööriista installimine"
  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

WordPressi installimine ja seadistamine

Skript installib kõige uuema WordPressi versiooni katalooge /var/www/wordpress, samuti muudab seadeid:

Andmebaasi ühendus töötab läbi unix domain socket'i, mitte TCP loopback'i kaudu, et vähendada TCP liiklust.
WordPress lisab eesliite https:// URL-ile, kui kliendid ühenduvad NGINX-iga HTTPS-protokolli kaudu, ja saadab ka kaug-hostinime (nagu NGINX seda pakub) PHP-sse. Me rakendame väikest koodilõiku, et see seadistada.
WordPress vajab sisselogimiseks HTTPS-i
URL-i struktuur põhineb vaikimisi ressurssidel
WordPressi katalooge koheldakse õigesti failisüsteemis.

skripti kood

kui [ ! -d /var/www/wordpress ]; siis
  # Loo WordPressi kataloogid
  mkdir -p /var/www/wordpress
  chown -R www-data:www-data /var/www

  # Laadi WordPress alla WordPress CLI abil
  echo "Installin WordPressi"
  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}'"

  # See koodijupp sisestatakse wp-config.php faili selle loomise ajal;
  # see teavitab WordPressi, et oleme tagasipöörduva proxi taga ja seega
  # võimaldab tal genereerida linke HTTPS-i abil
  cat > /tmp/wp_forwarded_for.php << 'EOM'
/* Lülita HTTPS 'sisse', kui HTTP_X_FORWARDED_PROTO vastab 'https'-le */
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

  # Loo WordPressi konfiguratsioon
  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

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

  # Muuda permalinkide struktuur mõistlikuks vaikeväärtuseks, mis ei ole kasutajas
  su -s /bin/sh -p -c "wp --path=/var/www/wordpress option update permalink_structure '/%year%/%monthnum%/%postname%/'" www-data

  # Eemalda näidisdokument, kuna see on rämps ja võib olla turbeprobleem
  rm /var/www/wordpress/wp-config-sample.php

  # Veendu, et WordPressi õigused oleksid õiged
  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

NGINX Unit seadistamine

Skripti eesmärk on seadistada NGINX Unit PHP käitamiseks ja WordPressi teede töötlemiseks, isolides PHP protsesside nimespaciaid ja optimeerides jõudlust. On kolm funktsiooni, millele tasub tähelepanu pöörata:

Nimespaci toetust määratletakse tingimuse alusel, mis põhineb skripti käitamise kontrollimisel konteineris. See on vajalik, kuna enamik konteineriseadeid ei toeta sisemist konteinerite käivitamist.
Kui nimespaci tugi on olemas, lülitatakse nimespaci välja network. See on vajalik, et võimaldada WordPressil samal ajal ühenduda lõpp-punktide ja olla internetis kättesaadav.
Protsesside maksimaalne arv määratakse järgmiselt: (Vaba mälu käivitatud MariaDB ja NGINX Unit jaoks) / (PHP mälu piir + 5)
See väärtus seatakse NGINX Unit seadetes.

See väärtus tähendab ka, et alati on käimas vähemalt kaks PHP-protsessi, mis on oluline, kuna WordPress teeb palju asünkroonseid päringuid iseendale, ja ilma täiendavate protsessideta, näiteks WP-Cron, ei tööta korralikult. Võite soovida neid limiteerimisi suurendada või vähendada, tuginedes oma lokaalsetele seadistustele, kuna siin määratud seadistused on konservatiivsed. Enamiku tootmissüsteemide puhul on seadistused vahemikus 10 kuni 100.

skripti kood

kui [ "${container:-unknown}" != "lxc" ] && [ "$(grep -m1 -a container=lxc /proc/1/environ | tr -d ' ')" == "" ]; siis
  NAMESPACES='"namespaces": {
        "cgroup": true,
        "credential": true,
        "mount": true,
        "network": false,
        "pid": true,
        "uname": true
    }'
eelse
  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 " Maksimaalne PHP protsesside arv on ${MAX_PHP_PROCESSES}. Soovitame seda väärtust vastavalt teie seadistustele kohandada. Tootmiskeskkondades on tavaliselt väärtuste vahemik 10–100."

echo " Konfigureerin NGINX Unit'i PHP ja WordPress'i kasutamiseks"
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

NGINX seadistamine

NGINX põhinäitaja seadistamine

Skript loob NGINX-i vahemälu jaoks kausta ja seejärel lihtsalt põhikonfiguratsioonifaili nginx.conf. Pange tähele töötlemisprotsesside arvu ja maksimaalse faili suuruse seadistamist. Samuti on olemas rida, mis ühendab järgmises jaotises määratletud tihendamise seadistuse faili, millele järgneb vahemälu seadistus.

skripti kood

# 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

NGINX tihendamine

Sisu tihendamine reaalajas enne selle edastamist klientidele on suurepärane viis saidi jõudluse parandamiseks, kuid ainult siis, kui tihendamine on õigesti seadistatud. See skripti jaotis põhineb seadistustel siit.

skripti kood

cat > ${NGINX_CONF_DIR}/gzip_compression.conf << 'EOM'
# Autor: https://github.com/h5bp/server-configs-nginx/
# ----------------------------------------------------------------------
# | Kompressioon                                                        |
# ----------------------------------------------------------------------
# https://nginx.org/en/docs/http/ngx_http_gzip_module.html
# Lülita sisse gzip kompressioon.
# Vaikimisi: välja
gzip on;
# Kompressiooni tase (1-9).
# 5 on suurepärane kompromiss suuruse ja CPU kasutuse vahel, pakkudes umbes 75%
# vähendust enamikule ASCII failidele (peaaegu identne tasemega 9).
# Vaikimisi: 1
gzip_comp_level 6;
# Ära kompressi midagi, mis on juba väike ja tõenäoliselt ei kahane palju,
# kui üldse (vaikimisi on 20 baiti, mis on halb, kuna see viib tavaliselt suuremate
# failideni pärast gzippingut).
# Vaikimisi: 20
gzip_min_length 256;
# Kompressi andmeid isegi klientide jaoks, kes ühenduvad meiega kaudu vahendite,
# mida tuvastatakse "Via" päise kaudu (kui CloudFront on vajalik).
# Vaikimisi: välja
gzip_proxied any;
# Ütle vahenditele, et salvestada nii gzipped kui tavaline versioon resursist
# iga kord, kui kliendi Accept-Encodingi võimaluste päis varieerub;
# Vältida, et mitte-gzipi võimekusega klient (mida on tänapäeval äärmiselt harva)
# kuvaks segadust, kui nende vahend väljastab neile gzipped versiooni.
# Vaikimisi: välja
gzip_vary on;
# Kompressi kõik väljundid, millel on üks järgmistest MIME-tüüpidest.
# `text/html` on alati gzip mooduli poolt kompressitud.
# Vaikimisi: 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

NGINX seadistamine WordPressile

Järgmisena loob skript konfiguratsioonifaili WordPressi jaoks default.conf kaustas conf.d. Siin seadistatakse:

TLS sertifikaatide aktiveerimine, mis on saadud Let’s Encrypt'ilt läbi Certboti (selle seadistus käsitletakse järgmisena)
TLS turvaparametrite seadistamine, mis põhineb Let’s Encrypt'i soovitustel
Vaikimisi vahemälu seadmine ülekantud päringutele üheks tunniks
Ligipääsu logimise keelamine, samuti logimise keelamine, kui fail ei ole leitud, kahe üldiselt küsitud faili puhul: favicon.ico ja robots.txt
Ligipääsu keeld peidetud failidele ja mõnedele failidele .php, et vältida ebaseaduslikku juurdepääsu või tahtmatut käivitamist
Statistika ja fontide failide ligipääsu logimise keelamine
Pealkirja seadmine Access-Control-Allow-Origin fontide failide jaoks
Index.php ja muu staatika marsruutimise lisamine.

skripti kood

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-kutse, mida kasutab Certbot 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 konfiguratsioon
    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;
    }

    # Keela kõik katsed pääseda peidetud failide juurde nagu .htaccess, .htpasswd,
    # .DS_Store (Mac)
    # Jätka logide pidamist päringute hiljem töötlemiseks (või firewalli utiliitidele
    # nagu fail2ban)
    location ~ /\. {
        deny all;
    }
    # Keela juurdepääs kõigile failidele, millel on .php laiend üleslaadimise kataloogis;
    # töötab alamkaustade installides ja ka mitme saidi võrgu korral.
    # Jätka logide pidamist päringute hiljem töötlemiseks (või firewalli utiliitidele
    # nagu fail2ban).
    location ~* /(?:uploads|files)/.*\.php$ {
        deny all;
    }
    # WordPress: keela juurdepääs wp-content, wp-includes PHP failidele
    location ~* ^/(?:wp-content|wp-includes)/.*\.php$ {
        deny all;
    }
    # Keela avalik juurdepääs wp-config.php
    location ~* wp-config.php {
        deny all;
    }
    # Ära logi juurdepääsu staatilistele varadele, meedia
    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

Certboti seadistamine Let’s Encrypti sertifikaatide jaoks ja nende automaatne pikendamine

Certbot — tasuta tööriist Electronic Frontier Foundationilt (EFF), mis võimaldab saada ja automaatselt uuendada Let’s Encrypti TLS-sertifikaate. Skript täidab järgmised toimingud, mis seavad Certboti ette Let’s Encrypti sertifikaatide käitlemiseks NGINX-is:

Peatab NGINX-i
Laeb alla soovitatud TLS-i seaded
Käivitab Certboti, et saada veebisaidi jaoks sertifikaate
Taaskäivitab NGINX-i, et kasutada sertifikaate
Seab igapäevaselt käivituma Certboti kell 3:24 öösel, et kontrollida sertifikaatide värskendamise vajadust ning vajadusel uute sertifikaatide allalaadimist ja NGINX-i taaskäivitamist.

skripti kood

echo "Peatun NGINX, et seadistada 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 "Laadimine soovitatavad TLS parameetrid"
  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 "Ei suutnud alla laadida uusimat options-ssl-nginx.conf"
fi

if [ ! -f ${NGINX_CONF_DIR}/ssl-dhparams.pem ]; then
  echo "Laadimine soovitatavad TLS DH parameetrid"
  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 "Ei suutnud alla laadida uusimat ssl-dhparams.pem"
fi

# Kui tls_certs_init.sh pole varem käivitatud, eemalda iseeneslikud sertifikaadid
if [ ! -d "/etc/letsencrypt/accounts" ]; then
  echo "Eemaldamine iseeneslikud sertifikaadid"
  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 "Sertifikaatide genereerimine Let's Encryptiga"
  certbot certonly --standalone 
         -m "${WORDPRESS_ADMIN_EMAIL}" 
         ${CERTBOT_STAGING_FLAG} 
         --agree-tos --force-renewal --non-interactive 
         -d "${TLS_HOSTNAME}"
fi

echo "Alustamine NGINX uue seadistusega"
service nginx start

# Kirjuta crontab Let's Encrypt sertifikaadi perioodiliseks uuendamiseks
if [ "$(crontab -l | grep -m1 'certbot renew')" == "" ]; then
  echo "Lisamine certbot crontab automaatseks Let's Encrypt uuendamiseks"
  (crontab -l 2>/dev/null; echo "24 3 * * * certbot renew --nginx --post-hook 'service nginx reload'") | crontab -
fi

Teie veebisaidi lisaseaded

Oleme juba rääkinud, kuidas meie skript konfigureerib NGINX ja NGINX Unit, et teenindada tööstuslikuks kasutamiseks valmis veebisaiti, kus on sisse lülitatud TLS/SSL. Samuti võite tulevikus vastavalt oma vajadustele lisada:

Tugi Brotli, täiustatud surumistehnika HTTPS-i kaudu
ModSecurity koos reeglitega WordPressi jaoks, et vältida automaatseid rünnakuid teie saidile
Varukoopiad WordPressile, mis teile sobib
Kaitse kasutades AppArmor (Ubuntu süsteemis)
Postfix või msmtp, et WordPress saaks e-kirju saata
Teie saidi kontrollimine, et mõista, kui palju liiklust see taluda suudab

Vähemalt veel parema veebilehe jõudluse saavutamiseks soovitame uuendada NGINX Plus, meie ettevõtte taseme kaubanduslik toode, mis põhineb avatud lähtekoodiga NGINX-l. Selle tellijad saavad dünaamiliselt laaditava Brotli mooduli ja (lisatasu eest) NGINX ModSecurity WAF. Pakume ka NGINX App Protect, NGINX Plus jaoks mõeldud WAF moodul, mis põhineb F5 juhtivatel turvatehnoloogiatel.

N.B. Külasta meid kõrge koormusega veebisaidi toe jaoks Southbridge. Tagame teie veebisaidi või teenuse kiire ja usaldusväärse töö igasugustes koormustes.

Allikas: habr.com