Come installare Nginx con PHP e MySQL (LEMP Stack) su Ubuntu 22.04

Il stack software LEMP è un gruppo di software open-source che consente a un server di ospitare siti web e app dinamiche scritte in PHP. È un acronimo per L inux, Nginx (pronunciato come E ngine-X), M ySQL e P HP.

Questa guida ti mostrerà come installare un LEMP Stack su un server Ubuntu 22.04. Imparerai anche a installare applicazioni come phpMyAdmin.

Prerequisiti

• Un server che esegue Ubuntu 22.04.
• Un utente non root con privilegi sudo.
• Uncomplicated Firewall(UFW) è abilitato e in esecuzione.
• Tutto è aggiornato. $ sudo apt update && sudo apt upgrade

Passo 1 - Configurare il Firewall

Il primo passo prima di installare qualsiasi pacchetto è configurare il firewall per consentire connessioni HTTP e HTTPS.

Controlla lo stato del firewall.

$ sudo ufw status

Dovresti vedere qualcosa di simile al seguente.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Consenti le porte HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Controlla di nuovo lo stato per confermare.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443/tcp                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443/tcp (v6)               ALLOW       Anywhere (v6)

Passo 2 - Installare PHP

Ubuntu 22.04 viene fornito con PHP 8.1 per impostazione predefinita. Puoi installarlo eseguendo il seguente comando.

$ sudo apt install php-fpm php-cli php-mysqlnd php-mbstring php-xml php-gd

Abbiamo installato le estensioni MySQL, CLI, GD, Mbstring e XML di PHP. Puoi installare eventuali estensioni aggiuntive in base alle tue esigenze.

Per rimanere sempre sull’ultima versione di PHP o se desideri installare più versioni di PHP, aggiungi il repository PHP di Ondrej.

Aggiungi il repository PHP di Ondrej.

$ sudo add-apt-repository ppa:ondrej/php

Ora puoi installare qualsiasi versione di PHP.

$ sudo apt install php8.0-fpm php8.0-cli

Controlla la versione di PHP installata.

$ php --version
PHP 8.1.2 (cli) (built: Jun 13 2022 13:52:54) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
    with Zend OPcache v8.1.2, Copyright (c), by Zend Technologies

Passo 3 - Installare MySQL

Ubuntu 22.04 viene fornito con l’ultima versione di MySQL. Puoi installarlo con un singolo comando.

$ sudo apt install mysql-server

Controlla la versione di MySQL.

$ mysql --version
mysql  Ver 8.0.29-0ubuntu0.22.04.2 for Linux on x86_64 ((Ubuntu))

Questo passaggio è necessario per le versioni di MySQL 8.0.28 e superiori. Accedi alla shell di MySQL.

$ sudo mysql

Esegui il seguente comando per impostare la password per il tuo utente root. Assicurati che abbia un mix di numeri, lettere maiuscole, minuscole e caratteri speciali.

mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'YourPassword12!';

Esci dalla shell.

mysql> exit

Esegui lo script di installazione sicura di MySQL.

$ sudo mysql_secure_installation

Ti verrà chiesto di installare il componente di validazione della password. Controlla la forza delle password utilizzate in MySQL. Premi Y per installarlo.

Successivamente, ti verrà chiesto di impostare il livello della politica di validazione della password. Scegli 2 poiché è il più forte.

Successivamente, inserisci la tua password root. Premi N per rifiutare di cambiarla.

Premi Y per rimuovere gli utenti anonimi, vietare gli accessi remoti come root, rimuovere il database di test e ricaricare le tabelle dei privilegi.

Passo 4 - Configurare MySQL

Accedi alla shell di MySQL. Inserisci la tua password root quando richiesto.

$ sudo mysql -u root -p

Crea un database di esempio.

mysql> CREATE DATABASE exampledb;

Crea un account utente SQL.

mysql> CREATE USER 'exampleuser'@'localhost' IDENTIFIED BY 'YourPassword2!';

Concedi tutti i privilegi sul database all’utente.

mysql> GRANT ALL PRIVILEGES ON exampledb.* TO 'exampleuser'@'localhost';

Flush dei privilegi utente.

mysql> FLUSH PRIVILEGES;

Esci dalla shell.

mysql> exit

Accediamo di nuovo alla shell di MySQL utilizzando il nuovo utente creato.

$ sudo mysql -u exampleuser -p

Crea una tabella di test.

mysql> CREATE TABLE exampledb.name_list ( sno INT AUTO_INCREMENT, content VARCHAR(255), PRIMARY KEY(sno) );

Inserisci dati di test.

mysql> INSERT INTO exampledb.name_list (content) VALUES ('Navjot');

Ripeti il comando sopra separatamente per aggiungere ulteriori voci. Esegui il seguente comando per controllare i contenuti della tabella.

mysql> SELECT * FROM exampledb.name_list;

Riceverai il seguente output.

+-----+---------+
| sno | content |
+-----+---------+
|   1 | Navjot  |
|   2 | Adam    |
|   3 | Josh    |
|   4 | Peter   |
+-----+---------+
4 rows in set (0.00 sec)

Esci dalla shell di MySQL.

mysql> exit

Passo 5 - Installare Nginx

Ubuntu 22.04 viene fornito con una versione più vecchia di Nginx. Per installare l’ultima versione, devi scaricare il repository ufficiale di Nginx.

Importa la chiave di firma di Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Aggiungi il repository per la versione stabile di Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verifica l’installazione.

$ nginx -v
nginx version: nginx/1.22.0

Passo 6 - Configurare PHP-FPM

Apri php.ini per la modifica.

$ sudo nano /etc/php/8.1/fpm/php.ini

Per impostare le dimensioni di upload dei file, modifica i valori delle variabili upload_max_filesize e post_max_size.

upload_max_filesize = 50M
...
post_max_size = 50M

Configura il limite di memoria di PHP in base alle risorse e ai requisiti del tuo server.

memory_limit = 256M

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Apri il file /etc/php/8.0/fpm/pool.d/www.conf.

$ sudo nano /etc/php/8.0/fpm/pool.d/www.conf

Dobbiamo impostare l’utente/gruppo Unix dei processi PHP su nginx. Trova le righe user=www-data e group=www-data nel file e cambiale in nginx.

...
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
user = nginx
group = nginx
...

Inoltre, trova le righe listen.owner=www-data e listen.group=www-data nel file e cambiale in nginx.

listen.owner = nginx
listen.group = nginx

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavvia il processo PHP-fpm.

$ sudo systemctl restart php8.1-fpm

Passo 7 - Installare phpMyAdmin

Scarica il file di archivio di phpMyAdmin per la lingua inglese.

$ wget https://files.phpmyadmin.net/phpMyAdmin/5.2.0/phpMyAdmin-5.2.0-english.tar.gz

Crea una directory pubblica per il sito.

$ sudo mkdir /var/www/html/example.com -p

Estrai l’archivio nella directory pubblica.

$ sudo tar -xzvf phpMyAdmin-5.2.0-english.tar.gz -C /var/www/example.com

Passa alla directory pubblica.

$ cd /var/www/html/example.com

Rinomina la directory estratta in qualcosa di oscuro per migliorare la sicurezza.

$ sudo mv phpMyAdmin-5.2.0-english sm175

Passo 8 - Configurare phpMyAdmin

Copia il file di configurazione di esempio.

$ sudo cp sm175/config.sample.inc.php sm175/config.inc.php

Apri il file di configurazione per la modifica.

$ sudo nano sm175/config.inc.php

Trova la riga $cfg['blowfish_secret'] = ''; e inserisci una stringa casuale di 32 caratteri per l’autenticazione basata su cookie.

Puoi utilizzare il generatore di blowfish online di phpSolved o farlo tramite la riga di comando.

Copia il valore e incollalo come mostrato.

$cfg['blowfish_secret'] = 'Tc/HfLPBOAPxJ-rhQP}HJoZEK69c3j:m';

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Cambia la proprietà del sito e di phpMyAdmin al server Nginx.

$ sudo chown -R nginx:nginx /var/www/html/example.com

Elimina la directory di setup di phpMyAdmin.

$ sudo rm -rf /var/www/html/example.com/sm175/setup

Passo 9 - Configurare Opcache

Opcache è il sistema di caching di PHP. Funziona salvando il bytecode degli script precompilati nella memoria, quindi ogni volta che un utente visita una pagina, si carica più velocemente. Opcache è installato per impostazione predefinita. Per verificare, controlla la versione di PHP.

$ php --version
PHP 8.1.2 (cli) (built: Jun 13 2022 13:52:54) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
    with Zend OPcache v8.1.2, Copyright (c), by Zend Technologies

Questo ci dice che Opcache è installato e disponibile. Nel caso non venga visualizzato qui, puoi installarlo manualmente eseguendo il seguente comando.

$ sudo apt install php-opcache

Per modificare le impostazioni di Opcache, apri il file /etc/php/8.1/fpm/conf.d/10-opcache.ini per la modifica.

$ sudo nano /etc/php/8.1/fpm/conf.d/10-opcache.ini

Le seguenti impostazioni dovrebbero aiutarti a iniziare a utilizzare Opcache e sono generalmente raccomandate per buone prestazioni. Puoi abilitare una configurazione decommentandola rimuovendo il punto e virgola davanti ad essa.

opcache.enable_cli=1
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=4000
opcache.revalidate_freq=60

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Passo 10 - Installare Certbot per SSL

Dobbiamo installare Certbot per generare certificati SSL gratuiti offerti da Let’s Encrypt.

Puoi installare Certbot utilizzando il repository di Ubuntu o ottenere l’ultima versione utilizzando lo strumento Snapd. Useremo la versione Snapd.

Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.

$ sudo snap install core
$ sudo snap refresh core

Installa Certbot.

$ sudo snap install --classic certbot

Usa il seguente comando per assicurarti che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Passo 11 - Testare un sito demo

Crea il sito

Crea e apri una pagina di test per la modifica.

$ sudo nano /var/www/html/example.com/index.php

Incolla il seguente codice in essa.

Members List
"; 
    foreach($db->query("SELECT content FROM $table") as $row) {
        echo "
" . $row['content'] . "
";
    }
    echo "
";
}   catch (PDOException $e) {
    print "Error!: " . $e->getMessage() . "
";
    die();
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Crea un certificato SSL

Esegui il seguente comando per generare un certificato SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com

Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/example.com sul tuo server.

Genera un certificato di gruppo Diffie-Hellman.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096

Apri il file /etc/letsencrypt/renewal/example.com.conf per la modifica.

$ sudo nano /etc/letsencrypt/renewal/example.com.conf

Incolla il seguente codice in fondo.

pre_hook = systemctl stop nginx
post_hook = systemctl start nginx

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Abbiamo generato il certificato SSL utilizzando l’opzione standalone di Certbot. Esegue il proprio server web per creare il certificato, il che significa che Nginx dovrebbe essere spento durante il rinnovo. I comandi pre_hook e post_hook vengono eseguiti prima e dopo il rinnovo per spegnere e riavviare automaticamente il server Nginx, richiedendo quindi nessun intervento manuale.

Per controllare se il rinnovo SSL funziona correttamente, esegui un test del processo.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Configura Nginx

Crea e apri il file /etc/nginx/conf.d/example.conf per la modifica.

$ sudo nano /etc/nginx/conf.d/example.conf

Incolla il seguente codice in esso.

server {
    listen       443 ssl http2;
    listen       [::]:443 ssl http2;
    server_name  example.com;

    access_log  /var/log/nginx/example.com.access.log;
    error_log   /var/log/nginx/example.com.error.log;

    ssl_certificate      /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;

    ssl_session_timeout  5m;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    root /var/www/html/example.com;

    index index.php index.html;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    # Pass PHP Scripts To FastCGI Server
    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/run/php/php8.1-fpm.sock;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~ /\.(?!well-known).* {
        deny all;
    }
}

# enforce HTTPS
server {
    listen       80;
    listen       [::]:80;
    server_name  example.com;
    return 301   https://$host$request_uri;
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la tua configurazione Nginx.

$ sudo nginx -t

Se non vedi errori, significa che sei a posto. Avvia il server Nginx.

$ sudo systemctl start nginx

Carica il tuo sito visitando https://example.com nel tuo browser e vedrai la seguente pagina.

Puoi accedere alla tua installazione di phpMyAdmin visitando l’URL https://example.com/sm175 nel tuo browser. Puoi inserire il tuo utente root o l’utente creato in precedenza per accedere.

Conclusione

Questo conclude il nostro tutorial in cui hai imparato come configurare un stack LEMP su un server Ubuntu 22.04 e creare un sito demo. Se hai domande, pubblicale nei commenti qui sotto.