Setup manuale stack LAMP su Windows 11 con WSL2, servizi web nativi, VS Code e Ubuntu 22.04 (senza Microsoft Store)

Ultimo aggiornamento: 04/09/2023. Versione target Ubuntu: 22.04.03

Questa guida illustrerà come installare il supporto al sottosistema Linux nativo di Windows (WSL2), installare Ubuntu 22.04 (senza dover utilizzare il Microsoft Store), creare uno stack LAMP multi-PHP (con servizi nativi tramite systemd) e agganciare Visual Studio Code da Windows 11, per sviluppare e debuggare direttamente sulla macchina virtuale.

Requisiti

1. Computer con Windows 11, preferibilmente aggiornato tramite Windows Update
2. 16GB di RAM
3. Almeno 50GB di spazio libero su C:\ (conterrà il disco virtuale di Ubuntu 22.04)
4. Un SSD (meglio se NVMe) come disco principale di Windows
5. Una conoscenza di medio livello del terminale Linux (come usare e cosa sono comandi di base come cd, cp, mv, sudo, nano, etc.)
6. Il vostro computer dovrebbe essere protetto da password, usare BitLocker, e disporre di supporto a TPM 2.0 per evitare che malintenzionati possano accedere ad informazioni sensibili, se entrassero in possesso del vostro dispositivo. Questo è particolarmente importante se intendete maneggiare informazioni per conto terzi (lavoro). Le vostre politiche di sicurezza sulla rete e i dispositivi che utilizzate dovrebbero essere consone al tipo di uso del PC che intendete effettuare. In linea generale, se usate il vostro PC per lavoro, bisogna porre massima attenzione alla protezione. Prevenire è meglio che curare.

Lo stack LAMP che andremo a configurare supporta https (con certificati autofirmati con scadenza a 30 anni), protocollo http/2 e compressione brotli. Per quanto riguarda la parte PHP, useremo PHP-FPM perchè è più performante e più versatile nella configurazione delle impostazioni per-virtualhost. Per capire le differenze tra l'utilizzo di PHP con Apache in modalità PHP-CGI piuttosto che PHP-FPM, si rimanda a questa guida: https://www.basezap.com/difference-php-cgi-php-fpm/

Installare Ubuntu 22.04 LTS su Windows in virtualizzazione WSL2

Per installare Ubuntu 22.04 su Windows 11, useremo solo la PowerShell di Windows, senza ricorrere al Microsoft Store. Importante: assicurarsi di avviare la powershell in modalità amministratore.

Per prima cosa, scaricare ed installare https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi. Questo è importante. E' un pacchetto aggiuntivo che installa l'aggiornamento Linux Kernel Update, necessario per compatibilità con WSL2.

Dopodichè, eseguire su una PowerShell elevata a privilegi di amministratore questi comandi:

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
Restart-Computer -Force

Attendere il riavvio del PC, dopodichè eseguire su una PowerShell elevata a privilegi di amministratore questi comandi:

wsl --update --web-download
wsl --set-default-version 2
wsl --version
wsl --list --online

Il comando wsl --version ritornerà le informazioni sulla versione del sottosistema linux per windows. Qui un esempio di output aggiornato ad Agosto 2023:

Versione WSL: 1.2.5.0
Versione kernel: 5.15.90.1
Versione WSLg: 1.0.51
Versione MSRDC: 1.2.3770
Versione Direct3D: 1.608.2-61064218
Versione DXCore: 10.0.25131.1002-220531-1700.rs-onecore-base2-hyp
Versione di Windows: 10.0.22621.2134

Dobbiamo assicurarci che la versione WSL sia maggiore o uguale alla 0.67.6. Nell'esempio sopra riportato, è tutto OK.

Il comando wsl --list --online ritornerà le distribuzioni installabili. Qui un esempio di output aggiornato ad Agosto 2023:

NAME                                   FRIENDLY NAME
Ubuntu                                 Ubuntu
Debian                                 Debian GNU/Linux
kali-linux                             Kali Linux Rolling
Ubuntu-18.04                           Ubuntu 18.04 LTS
Ubuntu-20.04                           Ubuntu 20.04 LTS
Ubuntu-22.04                           Ubuntu 22.04 LTS
OracleLinux_7_9                        Oracle Linux 7.9
OracleLinux_8_7                        Oracle Linux 8.7
OracleLinux_9_1                        Oracle Linux 9.1
openSUSE-Leap-15.5                     openSUSE Leap 15.5
SUSE-Linux-Enterprise-Server-15-SP4    SUSE Linux Enterprise Server 15 SP4
SUSE-Linux-Enterprise-15-SP5           SUSE Linux Enterprise 15 SP5
openSUSE-Tumbleweed                    openSUSE Tumbleweed

Noi siamo interessati alla distribuzione Ubuntu-22.04. Quindi, eseguire questo comando su una PowerShell elevata a privilegi di amministratore:

wsl --install -d Ubuntu-22.04

Al termine dell'installazione, in assenza di errori, verrà automaticamente aperta l'istanza della macchina Ubuntu appena installata. Il sistema Ubuntu richiederà di impostare un nome utente (occhio, serve sotto ed è importante) -- consiglio di usare una singola parola corta digitata tutta in minuscolo -- e di specificare una password per questo utente -- consiglio di usare una sola lettera, per comodità quando si eseguiranno comandi da sudoer --

Modificare il resolver DNS di Ubuntu

Per risolvere permanentemente il problema della risoluzione nomi dominio DNS di Ubuntu via WSL2, seguire queste istruzioni. La procedura richiederà sia l'utilizzo della bash di Ubuntu, sia una PowerShell elevata a privilegi di amministratore:

Su Ubuntu 22.04

sudo su -
echo "[network]" | tee /etc/wsl.conf
echo "generateResolvConf = false" | tee -a /etc/wsl.conf

Su Windows, Powershell

wsl --terminate Ubuntu-22.04

Su Ubuntu 22.04 (da avviare nuovamente, perchè il comando precedente lo avrà terminato)

sudo su -
rm -f /etc/resolv.conf
echo "nameserver 9.9.9.9" | tee /etc/resolv.conf
echo "nameserver 1.1.1.1" | tee -a /etc/resolv.conf
echo "nameserver 216.87.84.211" | tee -a /etc/resolv.conf
echo "nameserver 208.67.222.222" | tee -a /etc/resolv.conf
chattr +i /etc/resolv.conf

Su Windows, Powershell

wsl --terminate Ubuntu-22.04
Get-NetAdapter

Ora, leggere l'output del comando Get-NetAdapter. Questo comando listerà tutte le interfacce di rete del PC. Noi siamo interessati alla interfacce che si collegano ad internet.

Ecco un esempio di output:

Name                      InterfaceDescription                    ifIndex Status       MacAddress             LinkSpeed
----                      --------------------                    ------- ------       ----------             ---------
Wi-Fi                     Intel(R) Wi-Fi 6E AX210 160MHz               15 Up           4C-77-CB-79-06-03       1.7 Gbps
Connessione di rete Bl... Bluetooth Device (Personal Area Netw...      12 Disconnected 4C-77-CB-79-06-07         3 Mbps
Ethernet                  Intel(R) Ethernet Connection (14) I2...       9 Disconnected A0-29-19-0B-74-1E          0 bps

Nell'esempio sopra, l'intefaccia utilizzata per collegarsi ad internet è Intel(R) Wi-Fi 6E AX210 160MHz, il cui ifIndex è 15.

Quindi, prendere nota del ifIndex corretto, ed eseguire una PowerShell elevata a privilegi di amministratore:

Set-NetIPInterface -InterfaceIndex [NUMERO_IFINDEX] -InterfaceMetric 6000

Con queste istruzioni la macchina Ubuntu 22.04 non dovrebbe avere nessun problema di risoluzione nomi a dominio.

Abilitare systemd su WSL2

Systemd è una suite di elementi costitutivi di base per un sistema Linux. Fornisce un gestore di sistema e servizi che viene eseguito come PID 1 e avvia il resto del sistema.
Molte distribuzioni popolari eseguono systemd per impostazione predefinita, come Ubuntu e Debian. Questa modifica significa che WSL sarà ancora più simile all'utilizzo delle tue distribuzioni Linux preferite su una macchina bare metal e ti consentirà di utilizzare software che dipende dal supporto systemd.

Abilitare systemd è relativamente semplice. Basterà lanciare questo comando su Ubuntu:

sudo su -
echo "[boot]" | tee -a /etc/wsl.conf
echo "systemd = true" | tee -a /etc/wsl.conf

Su Windows, Powershell

wsl --shutdown

Dopodichè, riavviare la macchina Ubuntu.

Step 1 - Configurare l'ambiente LAMP su Ubuntu

Qui andremo ad installare tutti i servizi e gli eseguibili di sistema per abilitare il supporto a PHP versioni 5.6, 7.0, 7.1, 7.2, 7.3, 7.4, 8.0, 8.1 e 8.2. Abiliteremo anche il web server Apache e il server Mysql.

Perchè installare tante versioni di PHP? E' importante per due motivi:

1. avere a disposizione un ambiente di sviluppo che consenta, con facilità, di testare la propria applicazione con svariate versioni di PHP. Questo agevolerà il lavoro in caso di constraint specifici sui server di produzione dove andremo ad installare le applicazioni create.
2. in caso un Cliente o un progetto specifico vi richieda di mantenere e/o modificare una vecchia base di codice funzionante su una specifica versione di PHP, non avrete difficoltà a rendere funzionante l'ambiente di dev&test in locale.

Si presume che la versione di default di PHP che si vorrà utilizzare nel sistema sia la 8.2. Questo è modificabile tramite le righe update-alternatives --set php*** che si troveranno nella lista qui sotto. Ad esempio, se si desidera che la versione di PHP di default (quella che verrà utilizzata digitando semplicemente il comando php e non la sua versione "versionata" es php7.4) basterà specificare update-alternatives --set php /usr/bin/php7.4. (Ad ogni modo, questo comportamento verrà in ogni caso modificato con i Bash Alias che andremo a configurare più tardi)

IMPORTANTE: Lanciare tutti questi comando come l'utente root su Ubuntu (il comando sudo su -). IMPORTANTE: Escludere le linee che iniziano con # in quanto servono solo a differenziare i vari blocchi.

# APACHE + Multi-PHP-FPM + Redis
sudo su -
apt update && apt upgrade
apt install -y net-tools zip unzip git redis-server lsb-release ca-certificates apt-transport-https software-properties-common
LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php
LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/apache2
apt update && apt upgrade
PHPVERS="8.2 8.1 8.0 7.4 7.3 7.2 7.1 7.0 5.6"
PHPMODS="cli fpm common bcmath bz2 curl gd intl mbstring mcrypt mysql opcache sqlite3 redis xml zip"
APTPACKS=$(for VER in $PHPVERS; do echo -n "libapache2-mod-php$VER php$VER "; for MOD in $PHPMODS; do echo -n "php$VER-$MOD "; done; done)
apt install -y apache2 brotli openssl libapache2-mod-fcgid $APTPACKS
a2dismod $(for VER in $PHPVERS; do echo -n "php$VER "; done) mpm_prefork
a2enconf $(for VER in $PHPVERS; do echo -n "php$VER-fpm "; done)
a2enmod actions fcgid alias proxy_fcgi setenvif rewrite headers ssl http2 mpm_event brotli
a2dissite 000-default
systemctl enable apache2.service
systemctl restart apache2.service
systemctl enable redis-server.service
systemctl start redis-server.service
update-alternatives --set php /usr/bin/php8.2
update-alternatives --set phar /usr/bin/phar8.2
update-alternatives --set phar.phar /usr/bin/phar.phar8.2

# MYSQL
sudo su -
apt install mariadb-server
systemctl enable mariadb.service
systemctl start mariadb.service
mysql_secure_installation
[digitare questa sequenza di risposte: ENTER + n + Y + "YOUR-ROOT-PASS" + "YOUR-ROOT-PASS" + Y + Y + Y + Y]
mysql -u root -p
DIGITARE "YOUR-ROOT-PASS"
> GRANT ALL ON *.* TO 'admin'@'localhost' IDENTIFIED BY 'YOUR-ADMIN-PASS' WITH GRANT OPTION;
> GRANT ALL ON *.* TO 'admin'@'127.0.0.1' IDENTIFIED BY 'YOUR-ADMIN-PASS' WITH GRANT OPTION;
> FLUSH PRIVILEGES;
> exit

Eseguiti questi comandi, saranno installati tutti i servizi e gli eseguibili necessari per realizzare uno stack LAMP (Linux, Apache, Mysql, PHP) in modalità multi-PHP (multiple versioni di PHP) con PHP-FPM per incrementare le performance.

Nota: le query mysql relative allo username e password (admin e YOUR-ADMIN-PASS) da creare come utente privilegiato possono essere modificate a piacimento.
Nell'esempio sopra riportato viene creato un utente con username admin e password YOUR-ADMIN-PASS. C'è da dire che stiamo configurando un ambiente di sviluppo locale, e fintanto che questo ambiente non viene esposto in internet, non dobbiamo preoccuparci di usare policy particolari riguardanti i nomi utente e la complessità delle password.
Tuttavia, tengo a precisare che usare nomi utente "facilmente guessabili" e password "ben note" è una bad practice.

Step 2 - Configurare l'ambiente LAMP su Ubuntu

Qui andremo a modificare le configurazioni di base di Apache e Mysql per poter lavorare localmente.

Si riporta il nome del file da modificare, e il contenuto modificato e commentato. Ogni modifica a questi file deve essere eseguita con sudo nano NOME_FILE. E' richiesta dimestichezza con lo strumento nano. In alternativa, usare l'editor di testo più comodo.

A. Modificare gli envvars di Apache

Nome file: /etc/apache2/envvars

Sintesi: modificare APACHE_RUN_USER e APACHE_RUN_GROUP settandoli, al posto che www-data, con il proprio nome utente (dove c'è scritto IL_TUO_NOME_UTENTE)

Contenuto:

# envvars - default environment variables for apache2ctl

# this won't be correct after changing uid
unset HOME

# for supporting multiple apache2 instances
if [ "${APACHE_CONFDIR##/etc/apache2-}" != "${APACHE_CONFDIR}" ] ; then
    SUFFIX="-${APACHE_CONFDIR##/etc/apache2-}"
else
    SUFFIX=
fi

# Since there is no sane way to get the parsed apache2 config in scripts, some
# settings are defined via environment variables and then used in apache2ctl,
# /etc/init.d/apache2, /etc/logrotate.d/apache2, etc.
export APACHE_RUN_USER=IL_TUO_NOME_UTENTE
export APACHE_RUN_GROUP=IL_TUO_NOME_UTENTE

B. Modificare le Porte di Apache

Nome file: /etc/apache2/ports.conf

Sintesi: modificare ogni occorrenza di Listen con Listen 127.0.0.1 (indirizzo ip di loopback + porta: 127.0.0.1:80 127.0.0.1:443)

Contenuto:

# If you just change the port or add more ports here, you will likely also
# have to change the VirtualHost statement in
# /etc/apache2/sites-enabled/000-default.conf

Listen 127.0.0.1:80

<IfModule ssl_module>
    Listen 127.0.0.1:443
</IfModule>

<IfModule mod_gnutls.c>
    Listen 127.0.0.1:443
</IfModule>

C. Modificare la configurazione di Mysql

Nome file: /etc/mysql/mariadb.conf.d/99-custom.cnf

Sintesi: adattare la configurazione di Mysql in modo da usare l'autenticazione nativa, una collation di default adeguata, e una modalità di esecuzione delle query "che non dia problemi di compatibilità" (riferimento: https://dev.mysql.com/doc/refman/8.0/en/sql-mode.html#sqlmode_no_engine_substitution).
Inoltre, imposteremo alcune configurazioni specifiche per aumentare le performance in lettura/scrittura (attenzione: bisogna avere un quantitativo adeguato di RAM a disposizione)

Contenuto:

[mysqld]

bind-address = 127.0.0.1
skip-external-locking
skip-name-resolve
max-allowed-packet = 256M
max-connect-errors = 1000000
default-authentication-plugin=mysql_native_password
sql_mode=NO_ENGINE_SUBSTITUTION
collation-server = utf8_unicode_ci
character-set-server = utf8

# === InnoDB Settings ===
default_storage_engine          = InnoDB
innodb_buffer_pool_instances    = 4
innodb_buffer_pool_size         = 4G
innodb_file_per_table           = 1
innodb_flush_log_at_trx_commit  = 0
innodb_flush_method             = O_DIRECT
innodb_log_buffer_size          = 16M
innodb_log_file_size            = 1G
innodb_sort_buffer_size         = 4M
innodb_stats_on_metadata        = 0
innodb_read_io_threads          = 64
innodb_write_io_threads         = 64

# === MyISAM Settings ===
query_cache_limit               = 4M
query_cache_size                = 64M
query_cache_type                = 1
key_buffer_size                 = 24M
low_priority_updates            = 1
concurrent_insert               = 2

# === Connection Settings ===
max_connections                 = 20
back_log                        = 512
thread_cache_size               = 100
thread_stack                    = 192K
interactive_timeout             = 180
wait_timeout                    = 180

# === Buffer Settings ===
join_buffer_size                = 4M
read_buffer_size                = 3M
read_rnd_buffer_size            = 4M
sort_buffer_size                = 4M

# === Table Settings ===
table_definition_cache          = 40000
table_open_cache                = 40000
open_files_limit                = 60000
max_heap_table_size             = 128M 
tmp_table_size                  = 128M

# === Binary Logging ===
disable_log_bin                 = 1

[mysqldump]
quick
quote_names
max_allowed_packet              = 1024M

D. Riavviare i servizi

Una volta completate le modifiche alle configurazioni di Apache e MariaDB, possiamo riavviare i servizi

sudo su -
systemctl restart apache2.service
systemctl restart mariadb.service

Step 3 - Configurare l'ambiente PHP con Composer e HTE-Cli

Adesso che abbiamo creato e configurato lo stack LAMP, non ce ne facciamo nulla se non creiamo dei VirtualHost per svilupare o testare applicazioni web sulle diverse versioni di PHP installate sul sistema.

Per creare dei VirtualHost utilizzeremo HTE-Cli, un tool di mia creazione pensato per agevolare la configurazione di environment di test su nomi dominio fittizi via modifica del file hosts di Windows.

Il tool HTE-Cli si occuperà di auto-configurare quello che serve sulla base di alcune informazioni basilari per il progetto che vogliamo svlippare o testare.

Inoltre, nel prosieguo del nostro lavoro avremo anche a che fare con Composer. In questa parte andremo a configurare Composer per sfruttarlo non solo per HTE-Cli, ma anche per PHP Code Sniffer e PHP CS Fixer, che ci serviranno per lo sviluppo con VS Code.

NOTA : per saperne di più su HTE-Cli, leggere il README dedicato di HTE-Cli

Installazione di Composer 2 e Composer 1

Per installare l'ultima versione stabile (2.x) di Composer globalmente, eseguire questo comando:

wget -O composer.phar https://getcomposer.org/download/latest-stable/composer.phar && sudo mkdir -p /usr/local/bin && sudo mv composer.phar /usr/local/bin/composer && sudo chmod +x /usr/local/bin/composer

ATTENZIONE : Composer 2 non è compatibile con versioni di PHP minori della 7.2.5. Per usare Composer su progetti che richiedono PHP 7.2, 7.1, 7.0 o 5.6 sarà quindi necessario utilizzare il vecchio binario di Composer 1

Per installare l'ultima versione del vecchio Composer 1.x, (compatibile su PHP 7.2, 7.1, 7.0 e 5.6), eseguire questo comando:

wget -O composer-oldstable.phar https://getcomposer.org/download/latest-1.x/composer.phar && sudo mkdir -p /usr/local/bin && sudo mv composer-oldstable.phar /usr/local/bin/composer1 && sudo chmod +x /usr/local/bin/composer1

NOTA : per mantenere questi binari aggiornati, sarà sufficiente eseguire sudo /usr/local/bin/composer self-update && sudo /usr/local/bin/composer1 self-update

Installare il supporto per HTE-Cli, PHP Code Sniffer e PHP CS Fixer

Per installare il supporto a questi tool, eseguire questi comandi:

composer global require --dev friendsofphp/php-cs-fixer
composer global require --dev "squizlabs/php_codesniffer=*"
composer global require "mfonte/hte-cli=*"
echo 'export PATH="$(composer config -g home)/vendor/bin:$PATH"' >> ~/.bashrc

NOTA : per mantenere questi pacchetti aggiornati, sarà sufficiente eseguire composer global update
ATTENZIONE : la directory di installazione dei pacchetti su Ubuntu 22.04 sarà ~/.config/composer e non ~/.composer come ci si potrebbe aspettare: qui la spiegazione

Configurare gli Alias Bash

Ora che abbiamo installato tutto, non ci resta che creare dei Bash Aliases che velocizzino il lavoro.

Lanciare quindi nano .bash_aliases (oppure vim .bash_aliases) e incollare questi alias:

alias hte="sudo /usr/bin/php8.2 -d allow_url_fopen=1 -d memory_limit=1024M ~/.config/composer/vendor/bin/hte-cli create"
alias hte-create="sudo /usr/bin/php8.2 -d allow_url_fopen=1 -d memory_limit=1024M ~/.config/composer/vendor/bin/hte-cli create"
alias hte-remove="sudo /usr/bin/php8.2 -d allow_url_fopen=1 -d memory_limit=1024M ~/.config/composer/vendor/bin/hte-cli remove"
alias hte-details="sudo /usr/bin/php8.2 -d allow_url_fopen=1 -d memory_limit=1024M ~/.config/composer/vendor/bin/hte-cli details"
alias composer-self-update="sudo /usr/local/bin/composer self-update && sudo /usr/local/bin/composer1 self-update"
alias composer-packages-update="composer global update"
alias composer="/usr/bin/php8.2 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer"
alias composer82="/usr/bin/php8.1 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer"
alias composer81="/usr/bin/php8.1 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer"
alias composer80="/usr/bin/php8.0 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer"
alias composer74="/usr/bin/php7.4 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer"
alias composer73="/usr/bin/php7.3 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer"
alias composer72="/usr/bin/php7.2 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer"
alias 1composer72="/usr/bin/php7.2 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer1"
alias 1composer71="/usr/bin/php7.1 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer1"
alias 1composer70="/usr/bin/php7.0 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer1"
alias 1composer56="/usr/bin/php5.6 -d allow_url_fopen=1 -d memory_limit=1024M /usr/local/bin/composer1"
alias php="/usr/bin/php8.2 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php82="/usr/bin/php8.2 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php81="/usr/bin/php8.1 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php80="/usr/bin/php8.0 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php74="/usr/bin/php7.4 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php73="/usr/bin/php7.3 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php72="/usr/bin/php7.2 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php71="/usr/bin/php7.1 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php70="/usr/bin/php7.0 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php56="/usr/bin/php5.6 -d allow_url_fopen=1 -d memory_limit=1024M"
alias wslrestart="history -a && cmd.exe /C wsl --shutdown"

Una volta finito l'editing del file .bash_aliases, eseguire

source ~/.bash_aliases

Con questa configurazione di .bash_aliases abbiamo:

1. Aliasato il tool HTE-Cli (che, ricordo, serve per gestire i VirtualHost sul sistema) con 4 differenti comandi: hte, hte-create, hte-remove, hte-details
2. Creato un alias per aggiornare i binari di Composer (installati come binari di sistema su /usr/local/bin) con il comando composer-self-update. Questo alias aggiornerà sia Composer 2 sia Composer 1 in una volta sola.
3. Creato un alias per aggiornare i pacchetti di Composer installati globalmente con il comando composer-packages-update
4. Creato svariati alias per i flavour di utilizzo di Composer corrispondenti alle versioni target di PHP che sono installate sul sistema. In sintesi, il comando composer utilizzerà PHP 8.2, composer81 utilizzerà PHP 8.1, composer80 utilizzerà PHP 8.0, e così via fino a composer72 che utilizzerà PHP 7.2. Parimenti, per utilizzare il vecchio Composer 1 per sviluppare su progetti datati, basterà usare 1composer72, oppure 1composer71, oppure 1composer70, oppure 1composer56
5. Creato svariati alias per richiamare il binario di PHP su tutte le versioni installate sul sistema, quindi php utilizzerà PHP 8.2, php81 utilizzerà PHP 8.1, e così via fino a php56 che utilizzerà PHP 5.6
6. Fatto in modo che sia gli alias riguardanti composer sia gli alias riguardanti php lavorino con due configurazioni specifiche: allow_url_fopen settato su 1, cioè attivo, e memory_limit settato su 1024M.
7. Creato un alias per fare il reset della macchina virtuale Ubuntu con il comando wslrestart

Perchè impostare un limite di memoria per gli alias di PHP e Composer? Perchè di default il limite di memoria sarebbe "nessun limite". Questo è pericoloso, perchè oscura eventuali potenziali problematiche sul binario di Composer stesso, e più in generale sui comandi che lanciamo via command line. Avere un limite di memoria non infinito per l'esecuzione è sempre buona prassi, perchè evita brutte sorprese poi in produzione.

Testare la configurazione creando un VirtualHost per PhpMyAdmin

A mero titolo esemplificativo, verrà mostrata l'intera procedura di creazione di un VirtualHost funzionante, che esponga l'applicativo PhpMyAdmin sulla macchina locale. Questa installazione potrà essere di aiuto nel caso in cui si decida di continuare ad utilizzarla per navigare tra i Database Mysql presenti sul sistema, e i dati contenuti all'interno di essi.

cd ~/
mkdir opt && cd opt/
wget https://files.phpmyadmin.net/phpMyAdmin/5.2.1/phpMyAdmin-5.2.1-all-languages.zip
unzip phpMyAdmin-5.2.1-all-languages.zip && rm -f phpMyAdmin-5.2.1-all-languages.zip && mv phpMyAdmin-5.2.1-all-languages phpmyadmin

Ora abbiamo creato la directory radice per l'installazione di PhpMyAdmin. Non resta che configurare un VirtualHost funzionante.

IMPORTANTE : le istruzioni che seguono si applicano a tutti gli ambienti di staging/test locali che si vorranno abilitare sul sistema tramite il tool HTE-Cli

maurizio:~ $ hte-create
[sudo] password for maurizio:
   __ __ ______ ____      _____ __ _
  / // //_  __// __/____ / ___// /(_)
 / _  /  / /  / _/ /___// /__ / // /
/_//_/  /_/  /___/      \___//_//_/

[H]andle [T]est [E]nvironment Cli Tool version 1.0.5 by Maurizio Fonte
WARNING: THIS TOOL IS *NOT* INTENDED FOR LIVE SERVERS. Use it only on local/firewalled networks.

 ? Enter a valid local Domain Name (suggested .test TLD, as "jane.local.test") []:
 > local.phpmyadmin.test

 ? Enter a valid directory in the filesystem for the DocumentRoot [/home/maurizio]:
 > /home/maurizio/opt/phpmyadmin/

 ? Enter a valid PHP version for PHP-FPM (5.6, 7.0, 7.1, 7.2, 7.3, 7.4, 8.0, 8.1, 8.2) [8.2]:
 > 8.2

 ? Do you need HTTPS support? ["yes", "no", "y" or "n"] [y]:
 > y

 ? Do you want to force HTTPS? ["yes", "no", "y" or "n"] [y]:
 > y

⏳ VirtualHost configuration for local.phpmyadmin.test created at /etc/apache2/sites-available/008-local.phpmyadmin.test.conf
⏳ PHP8.2-FPM configuration for local.phpmyadmin.test created at /etc/php/8.2/fpm/pool.d/local.phpmyadmin.test.conf
⏳ Self-signed SSL certificate script for local.phpmyadmin.test created at /tmp/sscert_local.phpmyadmin.testnPwhL6
?️ Executing the self-signed SSL certificate script for local.phpmyadmin.test...
 > Removing existing previous self-signed certs with pattern local.phpmyadmin.test.*
 > Generating certs for local.phpmyadmin.test
 > Generating RSA private key, 2048 bit long modulus
 > Writing info to /etc/apache2/certs-selfsigned/local.phpmyadmin.test.info
 > Protecting the key with chmod 400 /etc/apache2/certs-selfsigned/local.phpmyadmin.test.key
 > Removing the temporary config file /tmp/openssl.cnf.r60k8l
⏳ Enabling local.phpmyadmin.test on config 008-local.phpmyadmin.test...
⚡ Restarting Apache2...
⚡ Restarting PHP8.2-FPM...
✅ VirtualHost local.phpmyadmin.test created successfully!

Ora, bisogna modificare il file hosts di Windows per inserire il puntamento locale al dominio local.phpmyadmin.test.

Per modificare il file hosts su Windows 11, possiamo:

1. Usare i PowerToys. Per l'installazione e l'utilizzo, si rimanda alla guida ufficiale di Microsoft
2. Modificare il file C:\Windows\System32\drivers\etc\hosts (consiglio di utilizzare Notepad++)

Dopodichè, aprire una command line di Windows in modalità privilegiata e lanciare ipconfig /flushdns

Finito!

Complimenti! Se sei arrivato fino a questo punto, hai tutto quello che ti serve per lavorare, ed è possibile navigare sul proprio browser all'indirizzo https://local.phpmyadmin.test/setup/ per proseguire il setup di PhpMyAdmin.

Per creare altri VirtualHost per altri progetti, utilizzare sempre le stesse istruzioni seguite per il setup di PhpMyAdmin. Basterà far puntare il VirtualHost alla directory giusta del proprio progetto, e definire un nome di dominio fittizio che sarà reindirizzato dal file hosts verso 127.0.0.1

NOTE : per eliminare i VirtualHost creati tramite HTE-Cli, utilizzare il comando (Alias) hte-remove.
Per listare tutti i VirtualHost creati tramite HTE-Cli, utilizzare il comando (Alias) hte-details

Step 4 - Installare una shell custom, NVM, e ottimizzare l'esperienza utente (opzionale)

Questi step sono opzionali e servono ad ottimizzare l'esperienza utente sulla console dei comandi di Linux (secondo le mie personali preferenze), oltre che ad installare nvm (Node Version Manager, per lavorare con Node, React, etc).

1. Seguire le istruzioni di installazione di https://github.com/slomkowski/bash-full-of-colors (o installare ZSH, o qualunque altra shell di gradimento: io mi trovo bene con questa bash colorata super minimale, mia opinione personale è che avere meno aiuto possibile sulla bash sia un ottimo modo per non staccare la testa). Riporto un one-liner per installare Bash full of colors cd ~/ ; git clone https://github.com/slomkowski/bash-full-of-colors.git .bash-full-of-colors ; [ -f .bashrc ] && mv -v .bashrc bashrc.old ; [ -f .bash_profile ] && mv -v .bash_profile bash_profile.old ; [ -f .bash_aliases ] && mv -v .bash_aliases bash_aliases.old ; [ -f .bash_logout ] && mv -v .bash_logout bash_logout.old ; ln -s .bash-full-of-colors/bashrc.sh .bashrc ; ln -s .bash-full-of-colors/bash_profile.sh .bash_profile ; ln -s .bash-full-of-colors/bash_aliases.sh .bash_aliases ; ln -s .bash-full-of-colors/bash_logout.sh .bash_logout ; rm -f bash_logout.old ; rm -f bashrc.old ; rm -f bash_aliases.old
2. Lanciare wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.4/install.sh | bash per installare NVM (per sviluppo NodeJS/React)
3. Creare una coppia di chiavi pubblica/privata con il comando ssh-keygen -o -a 100 -t ed25519 -f ~/.ssh/nome_chiave -C "utente@computer" (comunicare il contenuto della chiave pubblica ~/.ssh/nome_chiave.pubal proprio team, che la userà per esempio per abilitare l'accesso ad un repository GIT privato.)
4. Creare un collegamento alla home directory di Ubuntu raggiungibile dal proprio Desktop per visualizzare la home di Ubuntu tramite l'Esplora risorse di Windows: per farlo, cliccare sul Desktop con il tasto destro del Mouse, Selezionare Nuovo > Collegamento, e immettere nel percorso del collegamento la stringa \\wsl$\Ubuntu-22.04\home\NOME_UTENTE, dove NOME_UTENTE è il nome utente usato su Ubuntu. Opzionale : modificare l'icona del collegamento (consiglio questa: ubuntu-drive-icon.ico)
5. Creare un collegamento alla Bash di Ubuntu raggiungibile dal proprio Desktop per avviare un nuovo terminale: per farlo, cliccare sul Desktop con il tasto destro del Mouse, Selezionare Nuovo > Collegamento, e immettere nel percorso del collegamento la stringa C:\Windows\System32\wsl.exe -d Ubuntu-22.04 bash -c "cd /home/NOME_UTENTE && bash", dove NOME_UTENTE è il nome utente usato su Ubuntu. Opzionale : modificare l'icona del collegamento (consiglio questa: ubuntu-icon.ico)

Step 5 - Installare VS Code per accedere ai file di progetto su WSL2

VS Code è totalmente integrato e compatibile con WSL2, nativamente.

Questo incrementa la produttività e semplifica tantissimo lo sviluppo.

Per installare e configurare VS Code con WSL2 è sufficiente:

1. Installare VS Code scaricandolo da https://code.visualstudio.com/
2. Aprire VS Code e premere la combinazione di comandi CTRL + SHIFT + x
3. Installare l'estensione Remote - WSL
4. Riavviare VS Code
5. Aprire una console di Ubuntu, e portarsi su una directory a piacere, ad esempio ~/opt/ oppure ~/.config/composer
6. Lanciare il comando code . e lasciare che il sistema installi quello che gli serve
7. Fatto! Da questo momento sarà possibile modificare i file presenti su Ubuntu direttamente da VS Code installato su Windows.

Step 6 - Ottimizzare, con le estensioni consigliate, lo sviluppo web su VS Code

Qui riporto un elenco di plugin e configurazioni utili per lo sviluppo PHP su VS Code.

E' molto importante che la lista dei plugin che segue venga installata durante una sessione WSL all'interno di VS Code.
Per farlo, portarsi su una directory qualsiasi di Ubuntu, ad esempio ~/opt/ oppure ~/.config/composer, e lanciare il comando code .
Così facendo, si aprirà VS Code in una sessione WSL e i plugin (e le relative configurazioni di Environment di VS Code) verranno applicate a WSL2, e non su Windows.

Per ogni plugin, è sufficiente premere CTRL + SHIFT + x e digitare il nome del plugin da cercare.

1. Cercare php cs fixer e installare la versione del plugin di junstyle https://github.com/junstyle/vscode-php-cs-fixer.git
2. Cercare GitLens e installare la versione del plugin di Eric Amodio https://github.com/eamodio/vscode-gitlens
3. Cercare Git History e installare la versione del plugin di Don Jayamanne, https://github.com/DonJayamanne/gitHistoryVSCode
4. Cercare PHP Intelephense e installare la versione del plugin di Ben Mewburn, https://github.com/bmewburn/vscode-intelephense
5. Cercare Prettier - Code Formatter e installare la versione del plugin di Prettier, https://github.com/prettier/prettier-vscode
6. Cercare PHP DocBlocker e installare la versione del plugin di Nail Brayfield, https://github.com/neild3r/vscode-php-docblocker
7. Cercare markdownlint e installare la versione del plugin di David Anson, https://github.com/DavidAnson/vscode-markdownlint
8. Cercare Material Icon Theme e installare la versione del plugin di Philipp Kief, https://github.com/PKief/vscode-material-icon-theme

Una volta installati tutti i plugin, premere la combinazione di tasti CTRL + SHIFT + p, digitare JSON, e selezionare su Preferenze: Apri Impostazioni Remote (JSON) (WSL: Ubuntu-22.04) (se la lingua di VS Code è inglese, bisognerà selezionare Preferences: Open Remote Settings (JSON) (WSL: Ubuntu-22.04))

A questo punto, copia-incollare la configurazione JSON riportata nello snippet vscode.json, modificando la variabile ##LINUX_USERNAME## con il nome utente utilizzato su Ubuntu.

Questa configurazione contiene sia impostazioni di mia preferenza personale, sia impostazioni dedicate a far funzionare i vari formattatori e php cs fixer.

NOTA : la configurazione consigliata su vscode.json richiede l'installazione dei font Roboto Sans e Source Code Pro
Il font Roboto Sans viene utilizzato per l'output sul terminale integrato, mentre il font Source Code Pro sarà il font utilizzato per il codice sorgente, file markdown, readme, insomma tutti gli editor di testo.
Si omettono istruzioni precise e puntuali per l'installazione dei font su Windows. Tuttavia, è sufficiente scaricare i file ttf dei font, aprirli con Windows, e cliccare su Installa.

Negli ultimi anni, la presenza online è diventata di vitale importanza per qualsiasi azienda, organizzazione o individuo che voglia raggiungere il pubblico in modo efficace.
Una presenza online di successo richiede una combinazione di diversi fattori, tra cui un sito web funzionale, ben progettato e facilmente accessibile. In questo contesto, l'infrastruttura web e le ottimizzazioni consigliate da Google PageSpeed Insights possono fare una grande differenza.

In questo articolo, esploreremo l'importanza di:

1. avere una infrastruttura web efficiente;
2. capire quali sono le aree di intervento consigliate da Google PageSpeed Insights;
3. perchè queste ottimizzazioni devono essere realizzate e implementate da un tecnico esperto e competente in materia.

Che cos'è una "infrastruttura web"?

Con "infrastruttura web" ci si riferisce all'insieme di tecnologie e servizi che rendono possibile la fruizione e l'accesso ai siti web.
Ad esempio, hosting, Content Management System (come Wordpress) e linguaggi di programmazione utilizzati per la realizzazione dei siti web.
L'infrastruttura web è fondamentale per garantire che i siti web siano accessibili e funzionino correttamente per gli utenti.
Per semplificare, una "infrastruttura web" è, oltre che il sito web stesso, tutto il dietro le quinte di quello che "che vede l'utente": esistono infatti tutta una serie di fattori tecnici critici che possono farlo funzionare bene (come si auspica), benino, o ancora peggio, proprio male.

Perché è importante avere un sito web efficiente?

Innanzitutto, con efficiente si intende veloce, sicuro, privo di bug, facilmente accessibile da qualsiasi dispositivo, e facile da capire per l'utente finale.
Quando un sito web è lento o non è disponibile, gli utenti possono diventare frustrati e abbandonare il sito. Ciò può danneggiare l'immagine dell'azienda o dell'organizzazione che possiede il sito e ridurre le opportunità di business.

Inoltre, un sito web efficiente può migliorare l'esperienza dell'utente. Quando i siti web sono veloci e reattivi, gli utenti sono più inclini a rimanere sul sito e ad esplorare i contenuti. Ciò può aumentare l'engagement dell'utente e migliorare la percezione dell'azienda o dell'organizzazione che possiede il sito.

Infine, un sito web web efficiente può migliorare la visibilità sui motori di ricerca come Google. Infatti, i motori di ricerca considerano la velocità di caricamento del sito web come un fattore importante per il posizionamento nei risultati di ricerca. Ciò significa che un sito web più veloce e reattivo ha maggiori probabilità di apparire in alto nei risultati di ricerca e, di conseguenza, di attirare un traffico maggiore.

Perchè Google PageSpeed Insights?

Dalla sua nascita, il 4 settembre 1998, Google ha subìto notevoli variazioni e migliorie che l'hanno portato ad essere il motore di ricerca più utilizzato. Per ottenere questo risultato, gli Ingegneri di Google hanno dovuto, nel corso delle varie evoluzioni tecniche, trovare nuovi fattori che identificassero un risultato come "più pertinente" rispetto ad un altro, a parità di parola chiave.
E' per questo che Google ha iniziato dal 2010 a prioritizzare i siti web più reattivi, ma è dal 2021, con l'introduzione di Google Page Experience, che i fattori di ranking di Google PageSpeed Insights hanno iniziato a diventare di primaria importanza sia per la fruibilità dei siti web, sia come mero fattore di ranking.

Che cos'è Google PageSpeed Insights?

Google PageSpeed Insights è uno strumento di analisi delle prestazioni dei siti web fornito da Google. L'obiettivo di PageSpeed Insights è quello di aiutare gli sviluppatori a migliorare la velocità e le prestazioni del proprio sito web.

PageSpeed Insights valuta il sito web in base a una serie di criteri, di cui se ne citano alcuni:

• la velocità di caricamento
• la dimensione della pagina
• l'ottimizzazione delle immagini
• la presenza di Content Delivery Network e i criteri di caching
• i fogli di stile e la complessità degli stessi
• i bottleneck di implementazione su javascript

In base ai risultati, PageSpeed Insights fornisce una valutazione della velocità del sito web e suggerimenti specifici per migliorare le prestazioni. PageSpeed Insights fonda il suo cuore sui Core Web Vitals, ovvero, metriche ben definite di "come risponde" un sito web agli occhi di un essere umano.
Le principali metriche di misurazione sono il Largest Contentful Paint (LCP), First Input Delay (FID), e il Cumulative Layout Shift (CLS)

Cosa sono LCP, FID e CLS?

Sono tutte metriche utilizzate per misurare le prestazioni di un sito web, dal punto di vista del visitatore. Sono metriche basate sui tempi di reazione del sito, che in ultima battuta sintetizzano "la fruibilità reale" di un sito web e permettono a Google di discernere tra un "sito web fatto bene" e un "sito web fatto male".

• LCP: tempo necessario per caricare il contenuto più grande e significativo del sito web. In altre parole, LCP misura il tempo necessario per rendere visibile al visitatore il contenuto principale della pagina web. Un LCP basso indica che il sito web è veloce e reattivo. Un sito web fatto bene ha un LCP basso rispetto alla concorrenza.
• FID: misura il tempo necessario per l'interazione con la pagina web. Ad esempio, se un utente fa clic su un pulsante sul sito web, FID misura il tempo che passa tra il clic e la risposta del sito web. Un FID basso indica che il sito web risponde rapidamente alle azioni dell'utente.
• CLS: si riferisce al cambiamento del layout della pagina web mentre questa viene caricata. Ad esempio, se un banner pubblicitario appare sulla pagina web dopo che l'utente ha iniziato a leggere il testo, il testo si sposterà verso il basso. Un CLS basso indica che il layout del sito web è stabile e che gli elementi non si spostano in modo inatteso. Il CLS, oltre ad essere visivamente fastidioso, è un problema che talvolta fa "cliccare sul posto sbagliato": la pagina, infatti, "trasla" di qualche pixel in basso o in alto. Se questo avviene, e il nostro intento era di cliccare esattamente in un punto, potrebbe infatti capitare che quel click in realtà faccia partire un'altra azione - perchè nel frattempo la pagina è stata traslata.

Perché è importante adottare le ottimizzazioni consigliate da Google PageSpeed Insights?

Adottare le ottimizzazioni consigliate da Google PageSpeed Insights è importante per diversi motivi:

1. la velocità del sito web è un fattore importante per il posizionamento nei risultati di ricerca di Google. Adottare le ottimizzazioni consigliate da PageSpeed Insights può quindi aiutare il sito web a posizionarsi meglio nei risultati di ricerca e ad attirare un traffico maggiore.
2. un sito web più veloce e reattivo può migliorare l'esperienza dell'utente. Quando un sito web è veloce, gli utenti possono navigare facilmente tra le pagine e accedere ai contenuti senza dover attendere troppo tempo per il caricamento. Ciò può aumentare l'engagement dell'utente e migliorare la percezione dell'azienda o dell'organizzazione che possiede il sito.
3. adottare le ottimizzazioni consigliate da PageSpeed Insights può aiutare a ridurre i costi di gestione del sito web. Quando un sito web è ottimizzato per la velocità e le prestazioni, richiede meno risorse del server per funzionare correttamente. Ciò significa che l'azienda o l'organizzazione che possiede il sito può risparmiare sui costi di hosting e gestione del sito.

Come adottare le ottimizzazioni consigliate da Google PageSpeed Insights?

Implementare le ottimizzazioni consigliate da Google PageSpeed Insights può sembrare una semplice operazione, ma richiede una conoscenza tecnica approfondita e una profonda comprensione delle diverse tecniche di ottimizzazione che possono essere utilizzate per migliorare la velocità e la performance del sito web.

Quindi, come implementare le ottimizzazioni consigliate di Google PageSpeed Insights?

Per farlo, è consigliato affidarsi ad un professionista esperto, come un programmatore PHP freelance, che possa analizzare la situazione, definire un progetto tecnico di intervento, ed infine occuparsi delle modifiche e ottimizzazioni necessarie.

Perchè è consigliabile far fare ad un esperto programmatore PHP freelance? Per diverse ragioni:

1. un programmatore PHP freelance con anni di esperienza, ha la opportune competenze tecniche necessarie per comprendere le diverse tecniche di ottimizzazione e scegliere quelle più adatte al sito web in questione. Ogni sito web ha le proprie caratteristiche e peculiarità specifiche che richiedono un approccio personalizzato per garantire la migliore ottimizzazione possibile. Un programmatore esperto può analizzare il sito web e identificare le aree che richiedono maggiore attenzione per migliorare la velocità e la performance.
2. un Ingegnere programmatore PHP ha la capacità di implementare le ottimizzazioni in modo corretto e sicuro, con sicuro inteso nel senso stretto, cioè, esente da bug di sicurezza. Implementare in modo errato le ottimizzazioni consigliate da Google PageSpeed Insights può portare a problemi come il malfunzionamento del sito web, la perdita di dati o l'aumento del tempo di caricamento. Un programmatore PHP freelance sa esattamente come implementare le ottimizzazioni in modo sicuro e minimizzare il rischio di errori.
3. un programmatore PHP freelance può monitorare costantemente il sito web per garantire che le ottimizzazioni implementate continuino a funzionare correttamente. Le ottimizzazioni non sono permanenti e devono essere costantemente monitorate e aggiornate per garantire la massima efficienza del sito web. Un programmatore PHP freelance può monitorare costantemente il sito web e apportare eventuali modifiche o aggiornamenti necessari per garantire la massima efficienza, e può offrire supporto tecnico e assistenza in caso di problemi tecnici. Se si verificano problemi tecnici durante l'implementazione delle ottimizzazioni, un programmatore PHP freelance può offrire supporto tecnico e assistenza per risolvere i problemi in modo tempestivo ed efficiente.

Per riassumere ...

Una infrastruttura web efficiente e l'adozione delle ottimizzazioni consigliate da Google PageSpeed Insights sono fondamentali per garantire un sito web veloce, reattivo e accessibile. Un sito web più veloce e reattivo può migliorare l'esperienza dell'utente, aumentare l'engagement e migliorare la percezione dell'azienda o dell'organizzazione che possiede il sito. Inoltre, un sito web veloce può aiutare a posizionarsi meglio nei risultati di ricerca di Google, attirando un traffico maggiore e migliorando il ROI.

È importante tenere presente che i risultati tecnici ottenuti dopo la messa in opera dei consigli di Google PageSpeed Insights non sono permanenti. È infatti necessario monitorare costantemente il sito web e apportare regolarmente modifiche per mantenere alte le prestazioni.
Inoltre, è importante ricordare che l'esperienza dell'utente deve essere sempre al centro delle decisioni prese per ottimizzare il sito web. Ciò significa che la velocità e le prestazioni del sito web devono sempre essere bilanciate con la qualità dei contenuti e la facilità d'uso.

Laravel è un framework PHP che adotta il pattern Model-View-Controller (MVC) per facilitare e velocizzare lo sviluppo di applicazioni web. Fondato 12 anni fa, il framweork Laravel ha dovuto lavorare sodo per recuperare il terreno perso rispetto a brand più consolidati.
Ora, con l'aumentare dell'uso del linguaggio PHP come scelta per lo sviluppo, i framework basati su PHP come Laravel stanno guadagnando popolarità e riconoscimento. Per un ingegnere backend PHP senior, che ha bisogno di un ambiente di sviluppo flessibile ma robusto, Laravel offre una gamma di vantaggi che esploreremo in dettaglio in questo articolo.

Perché Laravel anziché un CMS Generico?

Personalizzazione e Controllo del Codice Sorgente

WordPress e altri CMS possono sembrare opportuni per piccoli progetti, ma quando si tratta di implementare logiche di business complesse, un ingegnere backend senior può facilmente raggiungere i limiti di questi sistemi. Laravel, al contrario, fornisce un ambiente completamente personalizzabile, un fattore cruciale per un ingegnere con un'elevata competenza in PHP.

L'Inferno degli Hack Sporchi

L'adozione di un CMS generico come WordPress spesso richiede l'uso di "hack sporchi" per implementare funzionalità non native. Questo non solo rende il codice meno leggibile ma mette anche a rischio la sicurezza dell'intera applicazione.

Laravel e il Mercato di PHP

Statistiche ed Impatto di Laravel sul Mercato

"Laravel è il più forte contendente nell'ecosistema PHP semplicemente perché include le funzionalità necessarie per costruire applicazioni web moderne", queste sono le parole di Taylor Otwell, CEO di Laravel. Secondo i dati di BuiltWith, Laravel è attualmente utilizzato da 1.723.068 siti web, sia in esercizio che storici. Inoltre, nel solo 2023, 44.323 aziende hanno adottato Laravel per i loro nuovi progetti.

Demografia e Trend nel Tempo

Laravel ha visto la sua adozione in una gamma diversificata di industrie, dalla tecnologia alle arti e all'intrattenimento. Secondo le previsioni di SimilarTech, Laravel detiene una quota di mercato del 35,87%, battendo framework storici e affermati come Yii e CodeIgniter.

L'Importanza dell'Esperienza per un Ingegnere Backend Senior

L'Arte dell'Analisi e della Pianificazione

Un ingegnere backend PHP senior ha le competenze e l'esperienza per utilizzare al meglio i potenti strumenti offerti da Laravel. La sua architettura ben progettata facilita l'analisi e la pianificazione, consentendo la creazione di applicazioni robuste e moderne.

Sicurezza e Manutenibilità del Codice

Un ingegnere con anni di esperienza sa quanto sia vitale scrivere codice che sia non solo funzionale ma anche sicuro e manutenibile. Laravel viene fornito con una serie di funzionalità di sicurezza integrate che solo un ingegnere esperto può sfruttare per costruire applicazioni a prova di futuro.

Storie di Successo e Altri Numeri

Casistiche di Successo

Grandi nomi come Pfizer e BBC hanno scelto Laravel per lo sviluppo di siti web e applicazioni. Altre piattaforme di successo, come Invoice Ninja, Alison, Barchart, TourRadar e MyRank, hanno anche beneficiato dell'uso di questo framework versatile e robusto.

Statistiche e Trend di Laravel

Laravel, come PHP, continua a vedere una crescita costante. Infatti, il 79,2% dei siti web in tutto il mondo utilizza ancora PHP nel 2023, e questo è un segnale molto positivo per il futuro di Laravel e dei suoi utilizzatori, specialmente quelli con una profonda esperienza in PHP.

Perché Laravel è la Scelta Giusta per un Ingegnere Backend Senior in PHP

Con una presenza sempre più forte nel mercato, una comunità in crescita e una serie di potenti funzionalità, Laravel emerge come una scelta eccellente per un ingegnere backend PHP senior. L'ampia gamma di funzionalità che Laravel offre permette agli sviluppatori di scrivere codice che è sia robusto che altamente manutenibile. Le imponenti statistiche e il dominio crescente nel panorama dei framework PHP solidificano ulteriormente la sua posizione come una piattaforma di sviluppo web ideale.

Dal 1995, data della sua prima introduzione, ad oggi, il linguaggio PHP ha visto una crescente adozione globale ed è stato utilizzato per creare una vasta gamma di applicazioni web, dal semplice blog personale alle più complesse soluzioni per imprese.
Si tratta di un linguaggio di programmazione che, oltre alla sua versione “di base”, prevede anche numerosi framework PHP, ovvero dei sistemi che consentono di estendere le funzionalità del linguaggio di programmazione su cui è basato, fornendo allo sviluppatore una struttura coerente ed efficace che semplifica lo sviluppo di applicazioni web complesse, di cui, tra i più popolari, WordPress, Laravel, CodeIgniter, Magento, PrestaShop e WooCommerce.

Qualche statistica su PHP e sui Framework più popolari che utilizzano PHP.

Secondo le statistiche del sito web W3Techs, PHP è utilizzato come linguaggio di programmazione su poco meno dell’80% dei siti web dinamici attivi su Internet.
Ciò fa di PHP uno dei linguaggi di programmazione web più utilizzati al mondo e la sua adozione continua a crescere.

WordPress: il CMS più usato al mondo.

Chi non conosce WordPress, sistema di gestione dei contenuti (CMS - Content Management System) che viene utilizzato per creare siti web e blog, anch’esso basato su PHP? Le stesse statistiche citate sopra ci dicono che è alla base di circa il 40% dei siti web dinamici attivi su Internet, il che lo rende il CMS più popolare al mondo. WordPress è gratuito e open source, il che significa che gli sviluppatori possono utilizzarlo liberamente e personalizzarlo secondo le esigenze. WordPress, inoltre, ha migliaia di plugin e temi disponibili che permettono agli sviluppatori di estendere le funzionalità in modo semplice ed efficace.

Laravel: moderno, robusto e facile da usare.

Più recente, e meno noto agli hobbyisti di Internet, è Laravel, un framework PHP moderno e robusto, introdotto nel 2011.
È stato progettato per semplificare lo sviluppo di applicazioni web complesse e offre funzionalità come il routing, l'ORM, la gestione delle sessioni, la crittografia e la gestione della cache. Laravel è anche noto per la sua documentazione chiara e dettagliata, che lo rende facile da imparare e utilizzare, tanto che nel 2015 si è guadagnato il riconoscimento di SitePoint come migliore framework PHP.

Consiglio: se hai in mente un progetto Cloud-Based, o se hai già una applicazione basata su Laravel, e hai bisogno di un Senior PHP Backend Engineer, contattami senza impegno.

CodeIgniter: veloce e sicuro.

Nel 2006 è stato introdotto anche CodeIgniter. Si tratta di un framework PHP leggero e veloce che è stato progettato per essere facile da imparare e utilizzare. Offre funzionalità come la gestione dei modelli, il routing, la validazione dei form e la gestione delle sessioni. È anche molto affidabile grazie alle sue capacità di crittografia e decrittografia. Dispone di filtro XSS, della gestione delle password e della convalida dei dati di input, che lo rendono molto efficace nella protezione delle applicazioni web.

Consiglio: non basare il tuo progetto su Code Igniter: il framework Laravel è decisamente superiore

Magento: funzionalità avanzate per l’e-commerce.

Per la gestione dei cataloghi, degli ordini, dei pagamenti e delle spedizioni dei siti e-commerce Magento è un framework PHP molto efficiente e dalle funzionalità avanzate.
È stato rilasciato definitivamente nel 2008 e, secondo BuiltWith, Magento è utilizzato su oltre il 7% dei siti web di e-commerce attivi su Internet.

PrestaShop: semplice e completamente personalizzabile.

Anche PrestaShop è un framework PHP utilizzato per creare siti web di e-commerce. Introdotto nel 2007, anch’esso offre funzionalità come la gestione del catalogo, la gestione degli ordini, la gestione dei pagamenti e la gestione delle spedizioni. Ma la sua caratteristica più apprezzata è la facilità con cui si può personalizzare completamente.
Secondo le statistiche di BuiltWith, PrestaShop è utilizzato su oltre l'1% dei siti web di e-commerce attivi su Internet.

WooCommerce: l’ecommerce per WordPress.

Si tratta di un plugin per WordPress che permette agli utenti di creare un sito web di e-commerce. WooCommerce offre funzionalità come la gestione del catalogo, la gestione degli ordini, la gestione dei pagamenti e la gestione delle spedizioni, appoggiandosi direttamente al CMS WordPress il che lo rende, secondo i dati di WebTribunal, aggiornati a marzo 2023, il framework PHP per l’e-commerce più utilizzato, su oltre il 28% dei siti web di e-commerce attivi su Internet.

Perchè PHP è così popolare?

La ragione principale della popolarità di PHP è duplice: è un linguaggio di programmazione open source con una grossa community, e sul mercato sono presenti numerose soluzioni che rendono possibile lo sviluppo e messa online di siti web, come quelle sommarizzate in questo articolo, soluzioni che sono tutte egualmente valide, affermate, e con una grossa community di sviluppatori alle spalle.
Inoltre, il fatto che sia un linguaggio open source ha fatto sì che il supporto a questo linguaggio su ambienti server Linux sia pressochè onnipresente su tutte le distribuzioni e architetture.

La comunità open source di sviluppatori PHP è molto attiva e utilizza lo strumento Composer per gestire le parti che restano in comunque, come le dipendenze delle librerie di terze parti.
Composer semplifica la gestione delle dipendenze e consente agli sviluppatori di integrare facilmente librerie esterne nei loro progetti. Questo ha contribuito ad arricchire il sistema e a creare un ecosistema solido di librerie PHP open source, tra cui framework, librerie per l'accesso ai database, librerie per l'autenticazione, librerie per l'elaborazione di immagini e molto altro ancora.

Grazie alla sua facilità d’uso, alla vasta gamma di funzionalità offerte e alla sua scalabilità PHP è stato ampiamente adottato dalla grande comunità di sviluppatori ed è diventato uno dei linguaggi di programmazione web più affidabili e robusti disponibili. Inoltre, poiché è stato utilizzato per così tanto tempo, ci sono molte risorse online disponibili per gli sviluppatori che iniziano a lavorare con PHP o utili anche ai più esperti per risolvere problemi specifici.

Queste sue caratteristiche hanno fatto sì che PHP sia stato utilizzato anche per sviluppare applicazioni web di successo, come Facebook, Wikipedia, Yahoo e WordPress e che, grazie alla grande attività della comunità degli sviluppatori, si siano sviluppati i framework che abbiamo visto sopra e anche numerosi pacchetti open source per essi.

PHP verrà mai dismesso o diventerà obsoleto?

Molti esperti di tecnologia credono che PHP sia un linguaggio di programmazione che non verrà mai dismesso, nonostante l'introduzione di nuovi linguaggi di programmazione web come Python e JavaScript. Vediamo sulla base di quali motivazioni.

In primo luogo, PHP è molto utilizzato, anche da grossi portali e social network. Il fatto che sia in uso da così tanto tempo, ha fatto sì che sia stato testato a fondo e i problemi noti sono stati risolti da tempo. Inoltre, la grande community di sviluppatori continua ad ampliare e migliorare il linguaggio in modo da affrontare e risolvere velocemente anche nuove problematiche.

In secondo luogo, PHP è supportato su qualsiasi sistema operativo. Nativamente, PHP è progettato per funzionare su ambienti Linux, ma sono disponibili delle build per qualsiasi tipo di sistema operativo o device.

Infine, PHP è molto flessibile. Ci sono molte librerie e strumenti disponibili che permettono agli sviluppatori di creare una vasta gamma di applicazioni web, dalle più semplici alle più complesse. Inoltre è supportato da molti provider di hosting web, il che lo rende facile da utilizzare per creare applicazioni web. Senza dimenticare che, come abbiamo visto in precedenza, le applicazioni e le piattaforme più diffuse sul web, come Facebook e WordPress, sono basate proprio sul linguaggio PHP cosa che lo rende praticamente insostituibile.

Se pensi di avere bisogno di un Senior PHP Backend Engineer per gestire i tuoi server, modificare o ampliare i tuoi progetti, contattami senza impegno.

Stack di sviluppo LAMP su Windows 10 con WSL2 e Visual Studio Code

Questa guida illustrerà come installare il supporto al sottosistema Linux nativo di Windows (WSL2), creare uno stack LAMP al suo interno, e agganciare Visual Studio Code per lo sviluppo direttamente su filesystem Linux.

La guida è aggiornata ad Agosto 2022 e necessita di questi prerequisiti:

1. Computer con Windows 10, aggiornato all'ultima release disponibile
2. 16GB di RAM
3. 30GB di spazio libero su C:\ (conterrà il disco virtuale di Ubuntu)
4. Un SSD (meglio NVMe) come disco di avvio di Windows (migliori performance con Mysql)
5. Una conoscenza di base del terminale Linux (cd, cp, mv, sudo, nano, etc.)

Lo stack LAMP che andremo a configurare supporta https (con certificati autofirmati con scadenza a 10 anni), protocollo http/2 e compressione brotli. Per quanto riguarda la parte PHP, useremo PHP-FPM perchè è più performante e più versatile nella configurazione delle impostazioni per-virtualhost. Per capire le differenze tra l'utilizzo di PHP con Apache in modalità PHP-CGI piuttosto che PHP-FPM, si rimanda a questa guida: https://www.basezap.com/difference-php-cgi-php-fpm/

Installare Ubuntu 20.04 LTS su Windows

1. Leggere il warning sotto (La versione di WSL deve essere la 2).
2. Abilitare "Sottosistema Linux" da "Programmi e funzionalità"
3. Cercare "Ubuntu" nel Windows Store e installare UBUNTU 20.04 LTS
4. Avviare la macchina, attendere l'installazione, scegliere un nome utente (occhio, serve sotto ed è importante) composto da una singola parola corta tutta in minuscolo + la relativa password (corta, 1 sola lettera per comodità)
5. Creare un collegamento desktop alla macchina Linux
6. Creare un collegamento desktop alla directory home dell'utente, esempio: \\wsl$\Ubuntu-20.04\home\maurizio

WARNING: la versione di WSL DEVE essere la 2

Questo è molto importante. Se non è installato WSL2, non funziona nulla.

Per questo motivo, leggere https://aka.ms/wsl2-install. SI CONSIGLIA DI FARE QUESTA OPERAZIONE PRIMA DI INSTALLARE UBUNTU SUL SISTEMA.

Se necessario abilitare WSL2 (perchè non già abilitato), bisognerà aprire una PowerShell con privilegi elevati e usare questi comandi:

Installare questo pacchetto: https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
Restart-Computer                    # bisogna riavviare
wsl --set-version Ubuntu-20.04 2    # IMPORTANTE: questo è necessario solo se si è installato ubuntu prima di abilitare WSL2
wsl --set-default-version 2

Modificare il resolver DNS di WSL2

Guida copiata da: https://superuser.com/questions/1533291/how-do-i-change-the-dns-settings-for-wsl2

A) Turn off generation of /etc/resolv.conf

Using your Linux prompt, (I'm using Ubuntu), modify (or create) /etc/wsl.conf with the following content

[network]
generateResolvConf = false

(Apparently there's a bug in the current release where any trailing whitespace on these lines will trip things up.)

B) Restart the WSL2 Virtual Machine

Exit all of your Linux prompts and run the following Powershell command

wsl --shutdown

C) Create a custom /etc/resolv.conf

Open a new Linux prompt and cd to /etc

If resolv.conf is soft linked to another file, remove the link with rm resolv.conf (originally it is linked to ../run/resolvconf/resolv.conf)

Create a new resolv.conf with the following content

nameserver 1.1.1.1

Configurare l'ambiente LAMP su Ubuntu - Step 1

Qui andremo ad installare tutti i pacchetti di PHP in tutte le versioni dalla 5.6 alla 8.1, nonchè il web server Apache e il server Mysql.

Perchè installare tante versioni di PHP? Perchè è importante avere a disposizione un ambiente di sviluppo che consenta, con facilità, di testare la propria applicazione con svariate versioni di PHP. Questo agevolerà il lavoro in caso di constraint specifici sui server di produzione dove andremo ad installare le applicazioni create.

Si presume che la versione di default di PHP che si vorrà utilizzare nel sistema sia la 8.1. Questo è modificabile tramite le righe update-alternatives --set php*** che si troveranno nella lista qui sotto. Ad esempio, se si desidera che la versione di PHP di default (quella che verrà utilizzata digitando semplicemente il comando php e non la sua versione "versionata" es php7.4) basterà specificare update-alternatives --set php /usr/bin/php7.4.

IMPORTANTE: Lanciare tutti questi comando come l'utente root. IMPORTANTE: Escludere le linee che iniziano con ### in quanto servono solo a differenziare i vari blocchi.

# APT UPGRADE & INSTALL OF PHP + APACHE
apt update && apt upgrade
apt install net-tools unzip git lsb-release ca-certificates apt-transport-https software-properties-common -y
add-apt-repository ppa:ondrej/php
add-apt-repository ppa:ondrej/apache2
apt install openssl apache2 brotli libapache2-mod-fcgid libapache2-mod-php8.1 php8.1 php8.1-cli php8.1-fpm php8.1-common php8.1-bcmath php8.1-bz2 php8.1-curl php8.1-gd php8.1-intl php8.1-mbstring php8.1-mcrypt php8.1-mysql php8.1-xml php8.1-zip libapache2-mod-php8.0 php8.0 php8.0-cli php8.0-fpm php8.0-common php8.0-bcmath php8.0-bz2 php8.0-curl php8.0-gd php8.0-intl php8.0-mbstring php8.0-mcrypt php8.0-mysql php8.0-xml php8.0-zip libapache2-mod-php7.4 php7.4 php7.4-cli php7.4-fpm php7.4-common php7.4-bcmath php7.4-bz2 php7.4-curl php7.4-gd php7.4-intl php7.4-json php7.4-mbstring php7.4-mcrypt php7.4-mysql php7.4-xml php7.4-zip libapache2-mod-php7.3 php7.3 php7.3-cli php7.3-fpm php7.3-common php7.3-bcmath php7.3-bz2 php7.3-curl php7.3-gd php7.3-intl php7.3-json php7.3-mbstring php7.3-mcrypt php7.3-mysql php7.3-xml php7.3-zip libapache2-mod-php7.2 php7.2 php7.2-cli php7.2-fpm php7.2-common php7.2-bcmath php7.2-bz2 php7.2-curl php7.2-gd php7.2-intl php7.2-json php7.2-mbstring php7.2-mcrypt php7.2-mysql php7.2-xml php7.2-zip libapache2-mod-php7.1 php7.1 php7.1-cli php7.1-fpm php7.1-common php7.1-bcmath php7.1-bz2 php7.1-curl php7.1-gd php7.1-intl php7.1-json php7.1-mbstring php7.1-mcrypt php7.1-mysql php7.1-xml php7.1-zip libapache2-mod-php7.0 php7.0 php7.0-cli php7.0-fpm php7.0-common php7.0-bcmath php7.0-bz2 php7.0-curl php7.0-gd php7.0-intl php7.0-json php7.0-mbstring php7.0-mcrypt php7.0-mysql php7.0-xml php7.0-zip libapache2-mod-php5.6 php5.6 php5.6-cli php5.6-fpm php5.6-common php5.6-bcmath php5.6-bz2 php5.6-curl php5.6-gd php5.6-intl php5.6-json php5.6-mbstring php5.6-mcrypt php5.6-mysql php5.6-xml php5.6-zip
update-alternatives --set php /usr/bin/php8.1
update-alternatives --set phar /usr/bin/phar8.1
update-alternatives --set phar.phar /usr/bin/phar.phar8.1
update-alternatives --set phpize /usr/bin/phpize8.1
update-alternatives --set php-config /usr/bin/php-config8.1
### OPTIONAL SQLITE3 SUPPORT
apt install php5.6-sqlite3 php7.0-sqlite3 php7.1-sqlite3 php7.2-sqlite3 php7.3-sqlite3 php7.4-sqlite3 php8.0-sqlite3 php8.1-sqlite3
### OPTIONAL REDIS SUPPORT
sudo apt install redis-server php5.6-redis php7.0-redis php7.1-redis php7.2-redis php7.3-redis php7.4-redis php8.0-redis php8.1-redis
# APACHE HTTP2 + PHP-FPM + SSL + REWRITE + BROTLI
a2dismod php5.6 php7.0 php7.1 php7.2 php7.3 php7.4 php8.0 php8.1 mpm_prefork
a2enconf php5.6-fpm php7.0-fpm php7.1-fpm php7.2-fpm php7.3-fpm php7.4-fpm php8.0-fpm php8.1-fpm
a2enmod actions fcgid alias proxy_fcgi rewrite ssl http2 mpm_event brotli
# INSTALL MYSQL
apt install mysql-client-8.0 mysql-server-8.0

Configurare l'ambiente LAMP su Ubuntu - Step 2

Qui andremo a modificare le configurazioni di base di Apache e Mysql per poter lavorare localmente.

1. Aprire il file /etc/apache2/envvars con nano e modificare APACHE_RUN_USER e APACHE_RUN_GROUP settandoli, al posto che www-data, con il proprio nome utente
2. Aprire il file /etc/apache2/ports.conf con nano e modificare ogni occorrenza di Listen con Listen 127.0.0.1 (esempio: 127.0.0.1:80 127.0.0.1:443)
3. Lanciare service apache2 restart per applicare le modifiche alla config di Apache.
4. Aprire il file /etc/mysql/mysql.conf.d/mysqld.cnf e aggiungere queste righe (sostituisci [LF] con delle andate a capo) nella sezione [mysqld], (per intenderci, sotto la riga # datadir = /var/lib/mysql) : bind-address = 127.0.0.1 [LF] skip-networking [LF] sql_mode=NO_ENGINE_SUBSTITUTION [LF] default-authentication-plugin=mysql_native_password [LF] collation-server = utf8_unicode_ci [LF] character-set-server = utf8
5. (opzionale) Per completezza, al fondo di questo file è presente una configurazione di fine-tuning per un sistema con almeno 16GB di RAM. Volendo, si può direttamente copia-incollare quella configurazione.
6. Lanciare service mysql restart per applicare le modifiche alla config di Mysql.
7. Lanciare mysql_secure_installation per creare la password di root per mysql (usare qualcosa di semplice, perchè serve solo localmente), rimuovere l'accesso per gli utenti anonimi, le tabelle temporanee, e disabilitare il login remoto al demone Mysql.
8. Eseguire mysql -u root e lanciare i comandi di seguito:
9. CREATE USER 'admin'@'%' IDENTIFIED BY 'x';
10. GRANT ALL PRIVILEGES ON *.* TO 'admin'@'%' WITH GRANT OPTION;
11. FLUSH PRIVILEGES;

Ovviamente, le query mysql relative allo username e password da creare come utente privilegiato possono essere modificate. Nell'esempio sopra riportato viene creato un utente con username admin e password x. Ricordarsi che stiamo configurando un ambiente di sviluppo locale, e fintanto che non viene "aperto" al mondo esterno, non dobbiamo preoccuparci di usare politiche corrette per la sicurezza.

Creare dei VirtualHost funzionanti sulla propria installazione locale - Step 3

Per creare dei VirtualHost è sufficiente utilizzare questi due script che velocizzano la configurazione.

Come fase esemplificativa, verrà mostrato come creare un VirtualHost specifico per PhpMyAdmin, che comunque è necessario per poter lavorare.

A questo punto, se ancora loggati come l'utente root, uscire dall'utente root e tornare in modalità utente.

sudo mkdir /etc/apache2/certs2/
cd ~/
mkdir utils
cd utils/
nano create-staging-environment.php (copiare da sotto il contenuto del file)
nano create-ssl-cert.sh (copiare da sotto il contenuto del file)
chmod +x create-ssl-cert.sh
cd ~/
nano lamp.sh (copiare da sotto il contenuto del file)
chmod +x lamp.sh
wget https://files.phpmyadmin.net/phpMyAdmin/5.1.1/phpMyAdmin-5.1.1-all-languages.zip
unzip phpMyAdmin-5.1.1-all-languages.zip
rm -f phpMyAdmin-5.1.1-all-languages.zip
mv phpMyAdmin-5.1.1-all-languages phpmyadmin

Ora abbiamo creato la directory radice per l'installazione di phpmyadmin. Non resta che configurare un VirtualHost funzionante.

Lanciare quindi il comando sudo php create-staging-environment.php e seguire le istruzioni. Queste istruzioni si applicano a tutti i progetti web che si vogliono installare sul sistema.

Nell'esempio, il virtualhost per PhpMyAdmin verrà settato come local.phpmyadmin.biz. Ovviamente, modificare le risposte seguendo il proprio nome utente. Rispondere alle domande dello script come segue:

maurizio@FISSO:~$ cd ~/utils/
maurizio@FISSO:~/utils$ sudo php create-staging-environment.php
### STAGING ENVIRONMENT CREATOR ###
Enter a valid local domain name: local.phpmyadmin.biz
Enter a valid directory in the filesystem for the DocumentRoot: /home/maurizio/phpmyadmin/
Enter a valid PHP version (5.6, 7.1, 7.2, 7.3, 7.4, 8.0 or 8.1): 7.4
Do you need HTTPS support (yes/no/y/n) ? y

Ora, bisogna modificare il file hosts di Windows per inserire il puntamento locale al dominio local.phpmyadmin.biz. Per farlo, modificare il file C:\Windows\System32\drivers\etc\hosts aggiungendo la regola 127.0.0.1 local.phpmyadmin.biz.

Dopodichè, aprire una command line di Windows in modalità privilegiata e lanciare ipconfig /flushdns

Fatto! Ora è possibile navigare sul proprio browser all'indirizzo https://local.phpmyadmin.biz/setup/ per proseguire il setup go PhpMyAdmin.

Per creare altri VirtualHost per altri progetti, utilizzare sempre le stesse istruzioni seguite per il setup di PhpMyAdmin. Basterà far puntare il VirtualHost alla directory giusta del proprio progetto, e definire un nome di dominio fittizio che sarà reindirizzato via HOSTS verso 127.0.0.1

Ottimizzare l'esperienza Linux - Step 4

Per ottimizzare l'installazione LAMP e l'esperienza utente sulla console dei comandi di Linux, seguire questi passaggi:

1. Seguire le istruzioni di installazione di https://github.com/slomkowski/bash-full-of-colors
2. Lanciare wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash per installare NVM (per sviluppo NodeJS/React)
3. Lanciare cd ~/utils/ && php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');" && php composer-setup.php && php -r "unlink('composer-setup.php');" per installare una versione locale di composer all'interno della directory /utils/
4. Creare una coppia di chiavi pubblica/privata con il comando ssh-keygen -o -a 100 -t ed25519 -f ~/.ssh/nome_chiave -C "utente@computer"
5. Comunicare il contenuto della chiave pubblica al proprio team, che la userà per esempio per abilitare l'accesso ad un repository GIT privato.
6. Copia-incollare il contenuto dello snippet bash_local all'interno di ~/.bash_local modificando la variabile $NOME_UTENTE con il nome dell'utente scelto

Note importanti:

1. E' possibile fare il reset della macchina Linux con il comando wslrestart che è stato aliasato in ~/.bash_local. Così facendo si resetta completamente il sottosistema WSL2.
2. Ogni volta che si esegue il login alla macchina virtuale, bisognerà lanciare il comando ~/lamp.sh per avviare i servizi Apache, PHP-FPM e Mysql. Questo è necessario perchè l'ambiente LAMP non è stato installato come servizio di sistema (per intenderci, con systemd).

Installare VS Code per accedere ai file di progetto su WSL2 - Step 5

VS Code è totalmente integrato e compatibile con WSL2, nativamente.

Questo incrementa la produttività e semplifica tantissimo lo sviluppo.

Per installare e configurare VS Code con WSL2 è sufficiente:

1. Installare VS Code scaricandolo da https://code.visualstudio.com/
2. Aprire VS Code e premere la combinazione di comandi CTRL + SHIFT + x
3. Installare l'estensione Remote - WSL
4. Riavviare VS Code
5. Aprire una console di Ubuntu, e portarsi su una directory a piacere, ad esempio ~/utils/
6. Lanciare il comando code . e lasciare che il sistema installi quello che gli serve
7. Voilà, ora è possibile modificare i file presenti su Ubuntu direttamente da VS Code!

Ottimizzare lo sviluppo web con le estensioni giuste di VS Code - Step 6

Portarsi su una console di Ubuntu e lanciare questi comandi:

1. cd ~/
2. mkdir .composer && cd .composer/
3. nano composer.json e inserire questo contenuto all'interno:

{
	"require": {
		"squizlabs/php_codesniffer": "^3.5",
		"friendsofphp/php-cs-fixer": "^2.16"
	}
}

1. Lanciare composer install
2. Ora abbiamo a disposizione i binari di php-cs-fixer e php codesniffer, ci serviranno per la config di VS Code
3. Aprire VS Code, e portarsi su un progetto residente dentro Ubuntu per rimanere in "modalità WSL2"
4. Premere CTRL + SHIFT + x, cercare php cs fixer e installare la versione del plugin di junstyle (https://github.com/junstyle/vscode-php-cs-fixer.git)
5. Installare le seguenti estensioni: GitLens (Eric Amodio, https://github.com/eamodio/vscode-gitlens), Git History (Don Jayamanne, https://github.com/DonJayamanne/gitHistoryVSCode), PHP Intelephense (Ben Mewburn, https://github.com/bmewburn/vscode-intelephense), Prettier - Code Formatter (Prettier, https://github.com/prettier/prettier-vscode), PHP DocBlocker (Nail Brayfield, https://github.com/neild3r/vscode-php-docblocker), Twig Language (mblode, https://github.com/mblode/vscode-twig-language), markdownlint (David Anson, https://github.com/DavidAnson/vscode-markdownlint)
6. Installare il seguente pacchetto icone: Material Icon Theme (Philipp Kief, https://github.com/PKief/vscode-material-icon-theme)
7. Premere la combinazione di tasti CTRL + SHIFT + p, digitare preferenze, e cliccare su Preferenze: Apri Impostazioni (JSON)
8. Copia-incollare la configurazione riportata nello snippet vscode-json-config

Contenuto dello snippet "vscode-json-config"

Ovviamente bisogna modificare la path di php-cs-fixer.executablePath secondo il proprio nome utente.

{
	"window.menuBarVisibility": "toggle",
	"window.zoomLevel": 0.2,
	"explorer.confirmDelete": false,
	"explorer.confirmDragAndDrop": false,
	"workbench.iconTheme": "material-icon-theme",
	"workbench.colorTheme": "Quiet Light",
	"workbench.colorCustomizations": {
		"editorCursor.foreground": "#444"
	},
	"workbench.editor.showTabs": true,
	"terminal.integrated.fontFamily": "monospace",
	"terminal.integrated.lineHeight": 0.8,
	"terminal.integrated.enableBell": false,
	"terminal.integrated.letterSpacing": -0.1,
	"terminal.integrated.fontSize": 16,
	"editor.fontWeight": "600",
	"editor.cursorStyle": "line",
	"editor.cursorBlinking": "phase",
	"editor.rulers": [130],
	"editor.formatOnSave": true,
	"editor.minimap.enabled": false,
	"editor.wordWrap": "on",
	"editor.insertSpaces": true,
	"editor.tabSize": 4,
	"html.format.contentUnformatted": "pre,code,textarea",
	"html.format.endWithNewline": false,
	"html.format.extraLiners": "head, body, /html",
	"html.format.indentHandlebars": false,
	"html.format.indentInnerHtml": false,
	"html.format.maxPreserveNewLines": null,
	"html.format.preserveNewLines": true,
	"html.format.wrapLineLength": 130,
	"html.format.wrapAttributes": "auto",
	"telemetry.enableCrashReporter": false,
	"telemetry.enableTelemetry": false,
	"prettier.trailingComma": "all",
	"prettier.endOfLine": "auto",
	"prettier.singleQuote": true,
	"prettier.useTabs": true,
	"prettier.tabWidth": 4,
	"prettier.printWidth": 130,
	"prettier.jsxBracketSameLine": true,
	"prettier.semi": false,
	"[php]": {
		"editor.formatOnSave": true,
		"editor.defaultFormatter": "junstyle.php-cs-fixer"
	},
	"[js]": {
		"editor.formatOnSave": true,
		"editor.defaultFormatter": "esbenp.prettier-vscode"
	},
	"[javascript]": {
		"editor.formatOnSave": true,
		"editor.defaultFormatter": "esbenp.prettier-vscode"
	},
	"[css]": {
		"editor.formatOnSave": true,
		"editor.defaultFormatter": "esbenp.prettier-vscode"
	},
	"[jsx]": {
		"editor.formatOnSave": true,
		"editor.defaultFormatter": "esbenp.prettier-vscode"
	},
	"[twig]": {
		"editor.formatOnSave": true,
		"editor.defaultFormatter": "mblode.twig-language"
	},
	"php.suggest.basic": false,
	"php.validate.enable": true,
	"typescript.updateImportsOnFileMove.enabled": "never",
	"git.enableSmartCommit": true,
	"git.autofetch": true,
	"git.confirmSync": false,
	"php-cs-fixer.executablePath": "/home/$NOME_UTENTE/.composer/vendor/bin/php-cs-fixer",
	"php-cs-fixer.executablePathWindows": "", //eg: php-cs-fixer.bat
	"php-cs-fixer.onsave": false,
	"php-cs-fixer.rules": "@PSR2",
	"php-cs-fixer.config": ".php_cs;.php_cs.dist",
	"php-cs-fixer.allowRisky": false,
	"php-cs-fixer.pathMode": "override",
	"php-cs-fixer.exclude": [],
	"php-cs-fixer.autoFixByBracket": true,
	"php-cs-fixer.autoFixBySemicolon": false,
	"php-cs-fixer.formatHtml": false,
	"php-cs-fixer.documentFormattingProvider": true,
	"php-cs-fixer.lastDownload": 0,
	"[html]": {
		"editor.defaultFormatter": "esbenp.prettier-vscode"
	},
	"php-docblocker.returnGap": true,
	"php-docblocker.qualifyClassNames": true,
	"php-docblocker.author": {
		"name": "NOME SVILUPPATORE",
		"email": "EMAIL@SVILUPPATORE.BIZ"
	},
	"diffEditor.ignoreTrimWhitespace": false
}

Contenuto dello snippet ".bash_local"

alias casa="cd /home/$NOME_UTENTE"
alias composer="/usr/bin/php7.4 -d allow_url_fopen=1 /home/$NOME_UTENTE/utils/composer.phar"
alias php="/usr/bin/php7.4 -d allow_url_fopen=1 -d memory_limit=1024M"
alias php74="/usr/bin/php7.4 -d allow_url_fopen=1 -d memory_limit=1024M"
alias apt="sudo apt-get"
alias ls="ls -lash --color=auto --group-directories-first"
alias cd..="cd .."
alias ..="cd ../../"
alias ...="cd ../../../"
alias ....="cd ../../../../"
alias .....="cd ../../../../"
alias .4="cd ../../../../"
alias .5="cd ../../../../.."
alias ports="sudo netstat -tulanp"
alias wslrestart="history -a && cmd.exe /C wsl --shutdown"
alias tic="git"
alias npmclean="npm ci"
alias npmcheck="ncu"

gitremove() {
    git branch -d "$@"
    git push origin --delete "$@"
}

hugefiles() {
    du -a "$@" | sort -n -r | head -n 100
}

hugedirs() {
    cd "$@" && du -hsx -- * | sort -rh | head -100
}

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion

Contenuto dello script "lamp.sh"

#!/usr/bin/env bash
echo "### Starting MYSQL 8 ..."
sudo service mysql start
echo "### Starting PHP-FPM 5.6, 7.*, 8.*"
[ -d /var/run/php/ ] || sudo mkdir /var/run/php/
sudo service php5.6-fpm start
sudo service php7.0-fpm start
sudo service php7.1-fpm start
sudo service php7.2-fpm start
sudo service php7.3-fpm start
sudo service php7.4-fpm start
sudo service php8.0-fpm start
sudo service php8.1-fpm start
echo "### Starting Apache Server ..."
sudo service apache2 start

Contenuto dello script "create-staging-environment.php"

IMPORTANTE: Dopo il copia-incolla in create-staging-environment.php, ricordarsi di modificare le stringhe ##NOME_UTENTE## in modo che contengano il nome utente scelto in fase di setup di Ubuntu..

<?php

if (php_sapi_name() !== "cli") {
    message('ERROR: This script can only be run from the CLI.', 'e');
    exit();
}

if (posix_getuid() !== 0) {
    message('ERROR: This script can only be run as ROOT or sudo.', 'e');
    exit();
}

if (!is_dir('/etc/apache2/certs2/')) {
    message('ERROR: You need to create the directory /etc/apache2/certs2/ as root prior of executing this script.', 'e');
    exit();
}

define('APACHE_SITES_AVAILABLE_DIR', '/etc/apache2/sites-available/');
define('APACHE_CERTS_DIR', '/etc/apache2/certs2/');
define('APACHE_CERT_SELFSIGNED_SCRIPT', './create-ssl-cert.sh');
define('PHP_FPM_CONFIG_DIR', '/etc/php/#VER#/fpm/pool.d/');
define('APACHE_MAX_CONF_INDEX', getApacheSitesAvailableMaxIndex());

message('### STAGING ENVIRONMENT CREATOR ###');

// 1. ask for the local domain name
$work = true;
while ($work) {
    $domain = readline('Enter a valid local domain name: ');
    $domain = strtolower(str_replace(['http://', 'https://', 'www.'], '', $domain));
    if (filter_var('http://' . $domain, FILTER_VALIDATE_URL)) {
        $work = false;
        define('DOMAIN', $domain);
    } else {
        message('Error. Retry.', 'e');
    }
}

// 2. ask for the local directory that will be served as the DocumentRoot
$work = true;
while ($work) {
    $document_root = readline('Enter a valid directory in the filesystem for the DocumentRoot: ');
    if (is_dir($document_root)) {
        $work = false;
        define('DOCUMENT_ROOT', rtrim($document_root, '/'));
    } else {
        message('Error. Retry.', 'e');
    }
}

// 3. ask for the PHP version for PHP-FPM
$work = true;
while ($work) {
    $php_version = readline('Enter a valid PHP version (5.6, 7.0, 7.1, 7.2, 7.3, 7.4, 8.0 or 8.1): ');
    if (in_array($php_version, ['5.6', '7.0', '7.1', '7.2', '7.3', '7.4', '8.0', '8.1'])) {
        $work = false;
        define('PHPVER', $php_version);
    } else {
        message('Error. Retry.', 'e');
    }
}

// 4. ask for HTTPS support
$work = true;
while ($work) {
    $https_support = readline('Do you need HTTPS support (yes/no/y/n) ? ');
    if (in_array(strtolower($https_support), ['yes', 'no', 'y', 'n'])) {
        $work = false;
        if (in_array(strtolower($https_support), ['yes', 'y'])) {
            define('HTTPS_SUPPORT', true);
        } else {
            define('HTTPS_SUPPORT', false);
        }
    } else {
        message('Error. Retry.', 'e');
    }
}

// 5. perform actions
$apache_conf_stream = getApacheConf();
$php_fpm_conf_stream = getPhpFpmConf();
$apache_conf_file = APACHE_SITES_AVAILABLE_DIR . APACHE_MAX_CONF_INDEX . '-' . DOMAIN . '.conf';
$php_fpm_conf_file = str_replace('#VER#', PHPVER, PHP_FPM_CONFIG_DIR) . DOMAIN . '.conf';

if (file_put_contents($apache_conf_file, $apache_conf_stream)) {
    message('Apache configuration written correctly, going to enable the website', 's');
    exec('a2ensite ' . basename($apache_conf_file));

    if (file_put_contents($php_fpm_conf_file, $php_fpm_conf_stream)) {
        message('PHP-FPM configuration written successfully', 's');

        if (HTTPS_SUPPORT) {
            message('Going to CD into ' . APACHE_CERTS_DIR);
            exec('cd ' . APACHE_CERTS_DIR);
            message('Going to call the self-signed cert script ' . APACHE_CERT_SELFSIGNED_SCRIPT . ' with domain "' . DOMAIN . '"');
            exec(APACHE_CERT_SELFSIGNED_SCRIPT . ' ' . DOMAIN);
        }

        message('Going to exec "service apache2 force-reload"');
        exec('service apache2 force-reload');
        message('Going to exec "service php' . PHPVER . '-fpm restart"');
        exec('service php' . PHPVER . '-fpm restart');
    } else {
        message('Cannot write PHP-FPM configuration', 'e');
    }
} else {
    message('Cannot write Apache configuration', 'e');
}

function message(string $string, string $type = 'i')
{
    switch ($type) {
        case 'e': //error
            echo "\033[31m$string \033[0m\n";
        break;
        case 's': //success
            echo "\033[32m$string \033[0m\n";
        break;
        case 'w': //warning
            echo "\033[33m$string \033[0m\n";
        break;
        case 'i': //info
            echo "\033[36m$string \033[0m\n";
        break;
        default:
            echo "$string\n";
        break;
    }
}

function getApacheSitesAvailableMaxIndex() : string
{
    $files = glob(APACHE_SITES_AVAILABLE_DIR . '*.conf');
    if ($files && count($files) > 0) {
        $max_index = 0;
        foreach ($files as $file) {
            $file = basename($file);
            if (preg_match('/^([0-9]+).*\.conf$/ui', $file, $matches)) {
                $index = intval($matches[1]);
                if ($index >= $max_index) {
                    $max_index = $index;
                }
            }
        }

        return str_pad($max_index + 1, 3, '0', STR_PAD_LEFT);
    }

    return '001';
}

function getApacheConf()
{
    $domain = DOMAIN;
    $document_root = DOCUMENT_ROOT;
    $phpver = PHPVER;
    $newline = "\\n";

    $conf_http = <<<HTML
<VirtualHost 127.0.0.1:80>
    ServerName $domain
    ServerAlias www.$domain
    DocumentRoot $document_root
    ServerAdmin admin@localhost.net
    UseCanonicalName Off
    Options -ExecCGI -Includes
    RemoveHandler cgi-script .cgi .pl .plx .ppl .perl
    CustomLog \${APACHE_LOG_DIR}/$domain combined
    CustomLog \${APACHE_LOG_DIR}/$domain-bytes_log "%{%s}t %I .$newline%{%s}t %O ."

    # Enable HTTP2
    Protocols h2 http/1.1

    <FilesMatch \.php$>
        # Apache 2.4.10+ can proxy to unix socket
        SetHandler "proxy:unix:/var/run/php/php$phpver-fpm-$domain.sock|fcgi://localhost/"
    </FilesMatch>

    <IfModule mod_brotli.c>
        AddOutputFilterByType BROTLI_COMPRESS text/html text/plain text/xml text/css text/javascript application/x-javascript application/javascript application/json application/x-font-ttf application/vnd.ms-fontobject image/x-icon
    </IfModule>

    <Directory $document_root/>
        Options -Indexes +FollowSymLinks
        AllowOverride All
        order allow,deny
        allow from all
        Require all granted
    </Directory>

    ##AUTOREWRITE##
</VirtualHost>

HTML;

    $conf_https = <<<HTML
<IfModule mod_ssl.c>
    <VirtualHost 127.0.0.1:443>
        ServerName $domain
        ServerAlias www.$domain
        DocumentRoot $document_root
        ServerAdmin admin@localhost.net
        UseCanonicalName Off
        Options -ExecCGI -Includes
        RemoveHandler cgi-script .cgi .pl .plx .ppl .perl
        CustomLog \${APACHE_LOG_DIR}/ssl-$domain combined
        CustomLog \${APACHE_LOG_DIR}/ssl-$domain-bytes_log "%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \"%r\" %b"

        # Enable HTTP2
        Protocols h2 http/1.1

        <FilesMatch "\.(cgi|shtml|phtml|php)$">
            SSLOptions +StdEnvVars
        </FilesMatch>

        <Directory $document_root/>
            Options -Indexes +FollowSymLinks
            AllowOverride All
            order allow,deny
            allow from all
            Require all granted
        </Directory>

        <IfModule mod_brotli.c>
            AddOutputFilterByType BROTLI_COMPRESS text/html text/plain text/xml text/css text/javascript application/x-javascript application/javascript application/json application/x-font-ttf application/vnd.ms-fontobject image/x-icon
        </IfModule>

        <FilesMatch \.php$>
            # Apache 2.4.10+ can proxy to unix socket
            SetHandler "proxy:unix:/var/run/php/php$phpver-fpm-$domain.sock|fcgi://localhost/"
        </FilesMatch>

        SSLEngine on
        SSLCipherSuite ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP
        SSLCertificateFile "/etc/apache2/certs2/$domain.crt"
        SSLCertificateKeyFile "/etc/apache2/certs2/$domain.key"
    </VirtualHost>
</IfModule>

HTML;

    if (HTTPS_SUPPORT) {
        return str_replace(
            '##AUTOREWRITE##',
            'RewriteEngine On
            RewriteCond %{HTTPS} off
            RewriteRule ^/(.*) https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]',
            $conf_http
        ) . chr(10) . chr(10) . $conf_https;
    } else {
        return str_replace('##AUTOREWRITE##', '', $conf_http);
    }
}

function getPhpFpmConf()
{
    $domain = DOMAIN;
    $document_root = DOCUMENT_ROOT;
    $phpver = PHPVER;

    $php_fpm_conf = <<<HTML
[$domain]
user = ##NOME_UTENTE##
group = ##NOME_UTENTE##
listen = /var/run/php/php$phpver-fpm-$domain.sock
listen.owner = ##NOME_UTENTE##
listen.group = ##NOME_UTENTE##
php_admin_value[disable_functions] = apache_child_terminate,apache_get_modules,apache_getenv,apache_note,apache_setenv,define_syslog_variables,disk_free_space,diskfreespace,dl,fpassthru,get_current_user,getmyuid,highlight_file,passthru,pclose,pcntl_exec,pfsockopen,php_uname,pcntl_alarm,pcntl_fork,pcntl_get_last_error,pcntl_signal,pcntl_getpriority,pcntl_setpriority,pcntl_strerror,pcntl_signal_dispatch,pcntl_sigprocmask,pcntl_waitpid,pcntl_wait,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_wexitstatus,pcntl_wifexited,pcntl_wifsignaled,pcntl_wifstopped,pcntl_wstopsig,pcntl_wtermsig,popen,show_source,socket_select,socket_strerror,stream_select,syslog,symlink
php_admin_flag[allow_url_fopen] = off
pm = dynamic
pm.max_children = 5
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3
chdir = /

catch_workers_output = yes
php_flag[display_errors] = off
php_admin_value[error_log] = $document_root/php$phpver-fpm-errors.log
php_admin_flag[log_errors] = on
php_admin_value[post_max_size] = 128M
php_admin_value[upload_max_filesize] = 128M
php_admin_value[memory_limit] = 1024M
php_value[memory_limit] = 1024M
php_value[short_open_tag] =  On

HTML;

    return $php_fpm_conf;
}

Contenuto dello script "create-ssl-cert.sh"

#!/usr/bin/env bash

# Ask for the base domain
BASE_DOMAIN="$1"
if [ -z "$BASE_DOMAIN" ]; then
  echo "Usage: $(basename $0) <domain>"
  exit 11
fi

fail_if_error() {
  [ $1 != 0 ] && {
    unset PASSPHRASE
    exit 10
  }
}

# Generate a passphrase
export PASSPHRASE=$(head -c 500 /dev/urandom | tr -dc a-z0-9A-Z | head -c 128; echo)

# Days for the cert to live
DAYS=3650

# Generated configuration file
CONFIG_FILE="config.txt"

cat > $CONFIG_FILE <<-EOF
[req]
default_bits = 2048
prompt = no
default_md = sha256
x509_extensions = v3_req
distinguished_name = dn

[dn]
C = IT
ST = Italy
L = Torino
O = Acme Corp
OU = The Dev Team
emailAddress = webmaster@$BASE_DOMAIN
CN = $BASE_DOMAIN

[v3_req]
subjectAltName = @alt_names

[alt_names]
DNS.1 = *.$BASE_DOMAIN
DNS.2 = $BASE_DOMAIN
EOF

# The file name can be anything
FILE_NAME="$BASE_DOMAIN"

# Remove previous keys
echo "Removing existing certs like $FILE_NAME.*"
if ls /etc/apache2/certs2/$FILE_NAME.* 1> /dev/null 2>&1; then
  rm -rf /etc/apache2/certs2/$FILE_NAME.*
fi

echo "Generating certs for $BASE_DOMAIN"

# Generate our Private Key, CSR and Certificate
# Use SHA-2 as SHA-1 is unsupported from Jan 1, 2017

openssl req -new -x509 -newkey rsa:2048 -sha256 -nodes -keyout "/etc/apache2/certs2/$FILE_NAME.key" -days $DAYS -out "/etc/apache2/certs2/$FILE_NAME.crt" -passin pass:$PASSPHRASE -config "$CONFIG_FILE"

# OPTIONAL - write an info to see the details of the generated crt
openssl x509 -noout -fingerprint -text < "/etc/apache2/certs2/$FILE_NAME.crt" > "/etc/apache2/certs2/$FILE_NAME.info"

# Protect the key
chmod 400 "/etc/apache2/certs2/$FILE_NAME.key"

# Remove the config file
rm -f $CONFIG_FILE

Contenuto del file di config Mysql "mysqld.conf"

Questo file è riportato per comodità. Non è necessario usarlo, ma è fortemente consigliato nel caso si abbia a disposizione una macchina con almenot 16GB di RAM.

#
# The MySQL database server configuration file.
#
# One can use all long options that the program supports.
# Run program with --help to get a list of available options and with
# --print-defaults to see which it would actually understand and use.
#
# For explanations see
# http://dev.mysql.com/doc/mysql/en/server-system-variables.html

# Here is entries for some specific programs
# The following values assume you have at least 32M ram

[mysqld]
#
# * Basic Settings
#
user            = mysql
# pid-file      = /var/run/mysqld/mysqld.pid
# socket        = /var/run/mysqld/mysqld.sock
# port          = 3306
# datadir       = /var/lib/mysql


# If MySQL is running as a replication slave, this should be
# changed. Ref https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_tmpdir
# tmpdir                = /tmp
#
# Instead of skip-networking the default is now to listen only on
# localhost which is more compatible and is not less secure.
bind-address            = 127.0.0.1
skip-networking
sql_mode=NO_ENGINE_SUBSTITUTION
default-authentication-plugin=mysql_native_password
collation-server = utf8_unicode_ci
character-set-server = utf8
#
# * Fine Tuning
#
# sort_buffer_size        = 256000000 (orig)
# key_buffer_size               = 16M (orig)
# max_allowed_packet    = 64M
# thread_stack          = 256K

# thread_cache_size       = -1

# This replaces the startup script and checks MyISAM tables if needed
# the first time they are touched
myisam-recover-options  = BACKUP

# my fine tuning
max_connections          = 20
table_open_cache         = 2048
thread_stack             = 32M
thread_cache_size        = 8
max_allowed_packet       = 16M
max_heap_table_size      = 128M
binlog_cache_size        = 2M
sort_buffer_size         = 16M
join_buffer_size         = 16M
tmp_table_size           = 128M
key_buffer_size          = 512M
read_buffer_size         = 4M
read_rnd_buffer_size     = 32M
bulk_insert_buffer_size  = 64M
myisam_sort_buffer_size  = 128M
innodb_buffer_pool_size  = 2G
innodb_lock_wait_timeout = 150



# table_open_cache       = 4000

#
# * Logging and Replication
#
# Both location gets rotated by the cronjob.
#
# Log all queries
# Be aware that this log type is a performance killer.
# general_log_file        = /var/log/mysql/query.log
# general_log             = 1
#
# Error log - should be very few entries.
#
log_error = /var/log/mysql/error.log
#
# Here you can see queries with especially long duration
# slow_query_log                = 1
# slow_query_log_file   = /var/log/mysql/mysql-slow.log
# long_query_time = 2
# log-queries-not-using-indexes
#
# The following can be used as easy to replay backup logs or for replication.
# note: if you are setting up a replication slave, see README.Debian about
#       other settings you may need to change.
# server-id             = 1
# log_bin                       = /var/log/mysql/mysql-bin.log
# binlog_expire_logs_seconds    = 2592000
max_binlog_size   = 100M
# binlog_do_db          = include_database_name
# binlog_ignore_db      = include_database_name