Installa PHP 8.1 e configura un ambiente di sviluppo locale su Ubuntu

Una versione precedente di questo tutorial è stata scritta da alenaholligan.

Introduzione

PHP è un linguaggio di scripting lato server popolare e open-source progettato per lo sviluppo web e alimenta una parte significativa di internet, dai blog e siti di e-commerce alle applicazioni su larga scala. Con ogni nuova versione, PHP offre prestazioni migliorate, sicurezza e funzionalità di sviluppo moderne per aiutare gli sviluppatori a creare software robusto e scalabile.

PHP 8.1 è una versione stabile e supportata a lungo termine che porta importanti miglioramenti e nuove funzionalità del linguaggio, mantenendo al contempo l'affidabilità. Installare PHP 8.1 su Ubuntu garantisce che il tuo ambiente di sviluppo locale sia aggiornato, sicuro e compatibile con framework e piattaforme ampiamente utilizzati come WordPress, Laravel e applicazioni PHP personalizzate.

Questo tutorial ti guida nell'installazione di PHP 8.1 su Ubuntu, configurandolo con Apache o Nginx, impostando le estensioni PHP essenziali e installando Composer per la gestione delle dipendenze. Imparerai anche come verificare la tua installazione e risolvere i problemi comuni.

Punti Chiave

• Installazione di PHP 8.1 su Ubuntu 22.04: Ubuntu 22.04 LTS include PHP 8.1 nei suoi repository predefiniti, consentendoti di installare una versione stabile di PHP a lungo supporto usando apt senza PPA di terze parti. Questo garantisce aggiornamenti prevedibili, patch di sicurezza e compatibilità con i moderni framework PHP.

• Estensioni PHP essenziali per progetti reali: La maggior parte delle applicazioni PHP di livello produttivo si basa su estensioni come mysql, curl, xml, mbstring, zip, gd e bcmath. Installarle in anticipo previene errori durante l'esecuzione e garantisce la compatibilità con framework come Laravel, Symfony e WordPress.

• Scegliere Apache o Nginx per lo sviluppo in PHP: Apache può eseguire PHP direttamente usando mod_php, mentre Nginx richiede PHP‑FPM per la gestione delle richieste. Entrambi gli approcci funzionano bene per lo sviluppo locale, ma PHP‑FPM rispecchia più da vicino gli ambienti di produzione moderni e si adatta meglio ai carichi elevati.

• Composer come fondamento dei flussi di lavoro PHP moderni: Composer gestisce le dipendenze del progetto tramite composer.json e composer.lock, garantendo build coerenti su diverse macchine. È essenziale per l'installazione dei framework, la generazione di autoloader e il mantenimento di versioni affidabili delle dipendenze nei progetti PHP collaborativi.

• Configurare PHP specificamente per lo sviluppo: Gli ambienti di sviluppo beneficiano di un'ampia segnalazione degli errori, limiti di memoria più elevati e tempi di esecuzione più lunghi. Modificare queste impostazioni in php.ini aiuta a individuare rapidamente i bug durante lo sviluppo, ma devono sempre essere ripristinate per l'ambiente di produzione.

• Risoluzione dei problemi e convalida fanno parte della configurazione: Verificare PHP con php -v, controllare le estensioni caricate e rivedere i log di Apache, Nginx o PHP‑FPM sono passaggi fondamentali. La maggior parte dei problemi di configurazione deriva da estensioni mancanti, permessi o direttive del server web configurate in modo errato.

Prerequisiti

Per completare questo tutorial, hai bisogno di:

• Una macchina locale o un server virtuale che esegue Ubuntu (compatibile con Ubuntu 22.04 LTS e versioni successive)
• Accesso amministrativo (sudo) alla macchina
• Una connessione internet attiva
• Conoscenza di base della riga di comando

Se stai configurando un nuovo server Ubuntu, consulta la nostra guida sulla Configurazione Iniziale del Server con Ubuntu.

Fase 1 — Configurazione di PHP 8.1

Completerai l'installazione e la configurazione tramite la riga di comando, che è un modo non grafico di interagire con il tuo computer. Cioè, invece di fare clic sui pulsanti, digiterai testo e riceverai risposte dal computer attraverso il testo stesso.

La riga di comando, conosciuta anche come shell o terminale, può aiutarti a modificare e automatizzare molte delle attività che svolgi ogni giorno su un computer ed è uno strumento essenziale per gli sviluppatori di software. Ci sono molti comandi del terminale da imparare che possono permetterti di fare cose più potenti. L'articolo Introduzione al Terminale Linux può aiutarti a orientarti meglio con il terminale.

Su Ubuntu, puoi trovare l'applicazione Terminal cliccando sull'icona di Ubuntu nell'angolo in alto a sinistra dello schermo e digitando terminal nella barra di ricerca. Clicca sull'icona dell'applicazione Terminal per aprirla. In alternativa, puoi premere contemporaneamente i tasti CTRL, ALT e T sulla tastiera per aprire automaticamente l'applicazione Terminal.

Esegui i seguenti comandi per aggiornare la tua lista di pacchetti disponibili, quindi installa PHP 8.1:

sudo apt update

sudo apt install --no-install-recommends php8.1

Il flag --no-install-recommends assicurerà che altri pacchetti come il server web Apache non vengano installati.

Controlla le informazioni sulla versione di PHP con il seguente comando:

php -v

Riceverai un output come questo:

PHP 8.1.2-1ubuntu2.22 (cli) (built: Jul 15 2025 12:11:22) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
    with Zend OPcache v8.1.2-1ubuntu2.22, Copyright (c), by Zend Technologies

Questa configurazione è stata testata su Ubuntu 22.04 LTS utilizzando i pacchetti PHP 8.1 dai repository ufficiali di Ubuntu.

Installa le estensioni PHP essenziali per lo sviluppo web:

sudo apt install -y php8.1-cli php8.1-common php8.1-mysql php8.1-zip php8.1-gd php8.1-mbstring php8.1-curl php8.1-xml php8.1-bcmath

Questo comando installerà i seguenti moduli:

• php8.1-cli - interprete dei comandi, utile per testare script PHP da una shell o per eseguire compiti generali di scripting da shell
• php8.1-common - documentazione, esempi e moduli comuni per PHP
• php8.1-mysql - per lavorare con database MySQL
• php8.1-zip - per lavorare con file compressi
• php8.1-gd - per lavorare con le immagini
• php8.1-mbstring - utilizzato per gestire stringhe non ASCII
• php8.1-curl - ti permette di effettuare richieste HTTP in PHP
• php8.1-xml - per lavorare con dati XML
• php8.1-bcmath - usato quando si lavora con numeri a virgola mobile ad alta precisione

I file di configurazione di PHP sono archiviati in /etc/php/8.1/. Il file di configurazione principale è php.ini, che può trovarsi in diverse directory a seconda della configurazione:

• Configurazione CLI: /etc/php/8.1/cli/php.ini
• Configurazione di Apache: /etc/php/8.1/apache2/php.ini (se Apache è installato)
• Configurazione di PHP-FPM: /etc/php/8.1/fpm/php.ini (se PHP-FPM è installato)

Verifica le estensioni installate:

php -m

Questo elenca tutti i moduli PHP caricati. Se php -v mostra una versione diversa da quella prevista, potresti avere più versioni di PHP installate. Usa php8.1 -v per verificare specificamente PHP 8.1.

Hai installato PHP e verificato la versione in esecuzione. Hai inoltre installato eventuali moduli PHP richiesti e sei stato in grado di elencare i moduli caricati.

Passo 2 — Configurare PHP con Apache

Installa il modulo PHP di Apache:

sudo apt install libapache2-mod-php8.1

Abilita il modulo e riavvia Apache:

sudo a2enmod php8.1
sudo systemctl restart apache2

Comprendere mod_php: Il modulo mod_php integra PHP direttamente nel processo di Apache. Quando Apache riceve una richiesta per un file PHP, lo elabora internamente utilizzando l'interprete PHP incorporato. Questo è diverso da Nginx, che richiede un servizio PHP-FPM separato. Il comando a2enmod crea un collegamento simbolico in /etc/apache2/mods-enabled/ per attivare il modulo.

Verifica che Apache stia elaborando correttamente PHP creando un file di test nella radice dei documenti di Apache (tipicamente /var/www/html):

echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

Visita http://localhost/info.php nel tuo browser. Dovresti vedere la pagina delle informazioni sulla configurazione di PHP. Rimuovi questo file dopo il test per motivi di sicurezza:

sudo rm /var/www/html/info.php

Risoluzione dei problemi di Apache e PHP

Se Apache non si avvia dopo l'installazione di mod_php:

Controlla il registro degli errori di Apache:

sudo tail -20 /var/log/apache2/error.log

I problemi comuni includono:

• Moduli PHP in conflitto: Se hai più versioni di PHP, disabilita prima gli altri moduli PHP con sudo a2dismod php7.4 (se presenti)
• Errori di sintassi nella configurazione di Apache: esegui sudo apache2ctl configtest per verificare

Se visiti localhost e vedi “It works!” ma i file PHP vengono mostrati come testo normale:

Questo significa che Apache non sta elaborando PHP. Controlla:

1. Verifica che il modulo sia abilitato:

apache2ctl -M | grep php

1. Se non appare nulla, il modulo non è caricato. Riattivalo:

sudo a2enmod php8.1
sudo systemctl restart apache2

1. Verifica che il tuo file PHP abbia l'estensione corretta (.php) e contenga codice PHP

Se ricevi un errore 403 Forbidden:

Controlla le autorizzazioni del file:

sudo chown -R www-data:www-data /var/www/html
sudo chmod -R 755 /var/www/html

Configurazione del Virtual Host di Apache

Per lo sviluppo locale con domini personalizzati, crea un host virtuale:

sudo nano /etc/apache2/sites-available/example.local.conf

Aggiungi questa configurazione:

<VirtualHost *:80>
    ServerName example.local
    DocumentRoot /var/www/example.local
    <Directory /var/www/example.local>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

• ServerName: Il nome di dominio per questo host virtuale
• DocumentRoot: Dove si trovano i tuoi file PHP
• AllowOverride All: Consente ai file .htaccess di sovrascrivere le impostazioni di Apache (necessario per framework come Laravel)
• Require all granted: Consente l'accesso alla directory

Crea la directory, abilita il sito e riavvia Apache:

sudo mkdir -p /var/www/example.local
sudo chown -R www-data:www-data /var/www/example.local
sudo a2ensite example.local.conf
sudo systemctl restart apache2

Aggiungi il dominio al tuo file /etc/hosts per l'accesso locale:

echo "127.0.0.1 example.local" | sudo tee -a /etc/hosts

Scegliere tra Apache e Nginx

Prima di configurare il tuo server web, considera quale si adatta meglio alle tue esigenze:

Quando scegliere Apache:

• Sei familiare con Apache o hai bisogno di supporto per .htaccess
• Configurare un semplice ambiente di sviluppo
• Lavorare con framework che fanno ampio uso di .htaccess (alcune configurazioni di WordPress)
• Preferisci una configurazione iniziale più semplice

Quando scegliere Nginx:

• Hai bisogno di migliori prestazioni sotto carico elevato
• Vuoi replicare gli ambienti di produzione moderni
• Stai costruendo applicazioni che cresceranno con te
• Preferisci un'architettura più moderna

Entrambi funzionano altrettanto bene per lo sviluppo locale. La scelta spesso dipende dalle preferenze personali o dall'infrastruttura esistente.

Fase 3 — Configurazione di PHP con Nginx

Installa PHP-FPM (FastCGI Process Manager):

sudo apt install php8.1-fpm

Avvia e abilita PHP-FPM:

sudo systemctl start php8.1-fpm
sudo systemctl enable php8.1-fpm

Comprendere PHP-FPM e FastCGI: A differenza del mod_php di Apache, Nginx non elabora direttamente PHP. PHP-FPM (FastCGI Process Manager) funziona come un servizio separato con cui Nginx comunica usando il protocollo FastCGI. FastCGI è un protocollo binario per l'interfacciamento di programmi con i server web: è più veloce del CGI tradizionale perché mantiene i processi attivi tra le richieste.

Quando Nginx riceve una richiesta per un file PHP, inoltra la richiesta a PHP-FPM tramite un socket Unix (o una connessione TCP). PHP-FPM elabora il codice PHP e restituisce il risultato a Nginx, che a sua volta lo invia al client. Questa separazione consente a PHP-FPM di gestire il proprio pool di processi, migliorando le prestazioni e la gestione delle risorse.

Configurazione del Blocco Server Nginx

Crea una configurazione del blocco server:

sudo nano /etc/nginx/sites-available/example.local

Aggiungi questa configurazione:

server {
    listen 80;
    server_name example.local;
    root /var/www/example.local;
    index index.php index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
    }

    location ~ /\.ht {
        deny all;
    }
}

Configurazione spiegata:

• root: Directory in cui si trovano i tuoi file PHP
• location ~ \.php$: Corrisponde a tutte le richieste che terminano con .php usando le espressioni regolari
• include snippets/fastcgi-php.conf: Include la configurazione FastCGI predefinita di Nginx (imposta SCRIPT_FILENAME e altre variabili necessarie)
• fastcgi_pass unix:/var/run/php/php8.1-fpm.sock: Il socket Unix su cui PHP-FPM ascolta. Questo è il modo in cui Nginx comunica con PHP-FPM. Il percorso del socket è definito in /etc/php/8.1/fpm/pool.d/www.conf

Abilita il sito e testa la configurazione:

sudo mkdir -p /var/www/example.local
sudo chown -R www-data:www-data /var/www/example.local
sudo ln -s /etc/nginx/sites-available/example.local /etc/nginx/sites-enabled/
sudo nginx -t

Se il test ha esito positivo, riavvia Nginx:

sudo systemctl restart nginx

Aggiungi il dominio a /etc/hosts:

echo "127.0.0.1 example.local" | sudo tee -a /etc/hosts

Crea un file PHP di prova:

echo "<?php phpinfo(); ?>" | sudo tee /var/www/example.local/info.php

Visita http://example.local/info.php. Dovresti vedere la pagina di configurazione di PHP. Rimuovi il file di test dopo aver verificato:

sudo rm /var/www/example.local/info.php

Risoluzione dei problemi di Nginx e PHP

Se ricevi l'errore “502 Bad Gateway”:

Ciò significa che Nginx non può comunicare con PHP-FPM. Controlla:

1. Verifica che PHP-FPM sia in esecuzione:

sudo systemctl status php8.1-fpm

1. Controlla che il percorso del socket sia corretto. La posizione del socket è definita in /etc/php/8.1/fpm/pool.d/www.conf:

grep listen /etc/php/8.1/fpm/pool.d/www.conf

Dovresti vedere qualcosa come listen=/run/php/php8.1-fpm.sock. Il percorso nella tua configurazione di Nginx deve corrispondere esattamente. Nota che /var/run è spesso un collegamento simbolico a /run, quindi entrambi i percorsi funzionano.

1. Controlla i permessi del file socket:

ls -la /var/run/php/php8.1-fpm.sock

Il socket dovrebbe essere di proprietà di www-data o dell'utente con cui gira Nginx. Se i permessi sono errati:

sudo chown www-data:www-data /var/run/php/php8.1-fpm.sock

1. Controlla il registro degli errori di Nginx:

sudo tail -20 /var/log/nginx/error.log

Potresti vedere errori come:

connect() to unix:/var/run/php/php8.1-fpm.sock failed (2: No such file or directory)

Ciò indica che il percorso del socket è errato o che PHP-FPM non è in esecuzione.

Se i file PHP vengono scaricati invece di essere eseguiti:

Ciò significa che Nginx non sta passando i file PHP a PHP-FPM. Controlla:

• Il blocco location ~ \.php$ esiste nella configurazione del tuo server
• La direttiva fastcgi_pass punta al socket corretto
• Hai riavviato Nginx dopo aver effettuato le modifiche

Se ricevi errori “File non trovato”:

Verifica che snippets/fastcgi-php.conf esista:

ls -la /etc/nginx/snippets/fastcgi-php.conf

Questo file imposta SCRIPT_FILENAME che indica a PHP-FPM quale file eseguire. Senza di esso, PHP-FPM non sa quale file elaborare.

Fase 4 — Configurare PHP per lo sviluppo

Configura PHP per lo sviluppo regolando la segnalazione degli errori, le impostazioni di visualizzazione e i limiti di memoria in php.ini. Queste impostazioni differiscono dalle configurazioni di produzione.

PHP utilizza file di configurazione separati per l'utilizzo da CLI (riga di comando) e per il server web. Modifica il file appropriato:

Per CLI (quando si esegue PHP dal terminale):

sudo nano /etc/php/8.1/cli/php.ini

Per server web (Apache o Nginx con PHP-FPM):

# For Apache
sudo nano /etc/php/8.1/apache2/php.ini

# For PHP-FPM (Nginx)
sudo nano /etc/php/8.1/fpm/php.ini

Impostazioni di sviluppo essenziali

Trova e aggiorna queste impostazioni nel tuo file php.ini:

display_errors = On
display_startup_errors = On
error_reporting = E_ALL
log_errors = On
error_log = /var/log/php_errors.log
memory_limit = 256M
upload_max_filesize = 64M
post_max_size = 64M
max_execution_time = 300
date.timezone = America/New_York

Cosa fa ciascuna impostazione:

• display_errors=On: Mostra gli errori PHP direttamente nel browser (utile per il debug, pericoloso in produzione)
• display_startup_errors=On: Mostra gli errori che si verificano durante l'avvio di PHP
• error_reporting=E_ALL: Riporta tutti i tipi di errori (avvisi, notifiche, ecc.)
• log_errors=On: Scrive gli errori in un file di log
• error_log: Dove PHP scrive i log degli errori
• memory_limit=256M: Memoria massima che uno script può usare (aumenta se ricevi errori di "memoria esaurita")
• upload_max_filesize=64M: Dimensione massima per i file caricati
• post_max_size=64M: Dimensione massima per i dati POST (deve essere maggiore di upload_max_filesize)
• max_execution_time=300: Tempo massimo in cui uno script può essere eseguito (in secondi)
• date.timezone: Imposta il fuso orario predefinito (usa il tuo fuso orario locale: Asia/Kolkata, Europe/London, UTC, ecc.)

Dopo aver effettuato le modifiche, riavvia il server web:

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

Verifica della tua configurazione

Verifica se le tue modifiche hanno avuto effetto:

# For CLI
php -i | grep display_errors

# For web server (create a test file)
echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/test.php

Visita il file di test nel tuo browser e cerca display_errors. Dovrebbe mostrare On. Rimuovi il file di test dopo la verifica.

Se le tue modifiche non appaiono:

1. Assicurati di aver modificato il file php.ini corretto (CLI vs server web)
2. Controlla eventuali errori di battitura nei nomi delle impostazioni (sono sensibili alle maiuscole)
3. Riavvia il tuo server web dopo aver apportato modifiche
4. Alcune impostazioni possono essere sovrascritte da .htaccess (Apache) o php.ini nella directory del tuo progetto

Potresti iniziare a usare PHP subito, ma probabilmente vorrai usare varie librerie per creare applicazioni PHP rapidamente. Prima di testare il tuo ambiente PHP, configura prima un gestore di dipendenze per i tuoi progetti.

Passo 5 — Configurare Composer per la gestione delle dipendenze (Opzionale)

Le librerie sono una raccolta di codice che può aiutarti a risolvere problemi comuni senza dover scrivere tutto da solo. Poiché esistono molte librerie disponibili, usare un gestore di dipendenze ti aiuterà a gestire più librerie man mano che acquisisci più esperienza nella scrittura di PHP.

Composer è uno strumento per la gestione delle dipendenze in PHP. Ti permette di dichiarare le librerie da cui dipende il tuo progetto e si occuperà di installare e aggiornare questi pacchetti.

Sebbene simile, Composer non è un gestore di pacchetti nello stesso senso di yum o apt. Gestisce i “pacchetti” o le librerie, ma li amministra su base per progetto, installandoli in una directory (ad esempio vendor) all'interno del tuo progetto. Per impostazione predefinita, non installa nulla a livello globale. Pertanto, è un gestore di dipendenze. Supporta comunque un progetto globale per comodità tramite il comando global.

Questa idea non è nuova, e Composer è fortemente ispirato a npm di Node e a bundler di Ruby.

Supponiamo:

• Hai un progetto che dipende da diverse librerie.
• Alcune di quelle librerie dipendono da altre librerie.

Compositore:

• Ti consente di dichiarare le librerie da cui dipendi.
• Scopre quali versioni di quali pacchetti possono e devono essere installate e le installa scaricandole nel tuo progetto.
• Ti consente di aggiornare tutte le tue dipendenze con un solo comando.
• Ti consente di consultare il capitolo sull'Uso di Base per maggiori dettagli sulla dichiarazione delle dipendenze.

Scarica l'installer di Composer:

curl -sS https://getcomposer.org/installer -o /tmp/composer-setup.php

Verifica l'integrità dell'installer controllando il suo hash SHA-384. Ottieni l'hash più recente:

HASH=$(curl -sS https://composer.github.io/installer.sig)

Verifica che l'hash corrisponda:

php -r "if (hash_file('SHA384', '/tmp/composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('/tmp/composer-setup.php'); } echo PHP_EOL;"

Dovresti vedere:

Installer verified

Se vedi Installer corrotto, il download è stato incompleto o manomesso. Scarica di nuovo l'installer e verifica l'hash. Se continua a dare errore, controlla la tua connessione a internet o prova a scaricare da una rete diversa.

Installa Composer globalmente:

sudo php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer

Riceverai un output simile a questo:

All settings correct for using Composer
Downloading...

Composer (version 2.3.5) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer

Verifica la tua installazione:

composer

Riceverai un output simile al seguente:

   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 2.3.5 2022-04-13 16:43:00

Usage:
  command [options] [arguments]

Options:
  -h, --help                     Display help for the given command. When no command is given display help for the list command
  -q, --quiet                    Do not output any message
  -V, --version                  Display this application version
      --ansi|--no-ansi           Force (or disable --no-ansi) ANSI output
  -n, --no-interaction           Do not ask any interactive question
      --profile                  Display timing and memory usage information
      --no-plugins               Whether to disable plugins.
      --no-scripts               Skips the execution of all scripts defined in composer.json file.
  -d, --working-dir=WORKING-DIR  If specified, use the given directory as working directory.
      --no-cache                 Prevent use of the cache
  -v|vv|vvv, --verbose           Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
. . .

Questo verifica che Composer sia stato installato correttamente sul tuo sistema ed è disponibile in tutto il sistema.

Passo 6 — Usare Composer in un progetto PHP

Come passaggio finale, puoi opzionalmente inizializzare il tuo progetto con composer init. Questo creerà il file composer.json che gestirà le dipendenze del tuo progetto. Inizializzare il progetto ti permetterà anche di definire dettagli del progetto come Autore e Licenza, e di utilizzare la funzionalità di autoload di Composer. Puoi definire le dipendenze ora oppure aggiungerle in seguito.

Crea una directory per il progetto e inizializza Composer:

cd ~
mkdir example-project
cd example-project
composer init

Eseguire questo comando avvierà la procedura guidata di installazione. I dettagli che inserisci nella procedura guidata possono essere aggiornati in seguito, quindi sentiti libero di lasciare i valori predefiniti e semplicemente premere INVIO. Se non sei pronto a installare dipendenze, puoi scegliere no. Inserisci i tuoi dettagli a ogni richiesta:

                                            
  Welcome to the Composer config generator  
                                            


This command will guide you through creating your composer.json config.

Package name (<vendor>/<name>) [sammy/example-project]:  sammy/project1
Description []:
Author [n to skip]: Sammy <sammy@linux-console.net>
Minimum Stability []: 
Package Type (e.g. library, project, metapackage, composer-plugin) []: project
License []: 

Define your dependencies.

Would you like to define your dependencies (require) interactively [yes]? no
Would you like to define your dev dependencies (require-dev) interactively [yes]? no

Add PSR-4 autoload mapping? Maps namespace "Sammy\Project1" to the entered relative path. [src/, n to skip]: n

{
    "name": "sammy/project1",
    "type": "project",
    "authors": [
        {
            "name": "Sammy",
            "email": "sammy@linux-console.net"
        }
    ],
    "require": {}
}

Do you confirm generation [yes]? yes

Prima di confermare la generazione, vedrai un esempio del file composer.json che il wizard creerà. Se tutto è a posto, puoi confermare l'impostazione predefinita sì. Se hai bisogno di ricominciare, scegli no.

La prima volta che definisci una dipendenza, Composer creerà una cartella vendor. Tutte le dipendenze vengono installate in questa cartella vendor. Composer crea anche un file composer.lock. Questo file specifica la versione esatta di ogni dipendenza e sotto-dipendenza utilizzata nel tuo progetto. Questo garantisce che qualsiasi macchina su cui viene eseguito il tuo programma utilizzerà esattamente la stessa versione di ogni pacchetto.

Ora che hai PHP installato e un modo per gestire le dipendenze del tuo progetto usando Composer, sei pronto per testare il tuo ambiente.

Fase 7 — Testare l'ambiente PHP

Crea ed esegui uno script PHP di base per testare la tua installazione:

nano hello.php

Aggiungi il seguente codice PHP:

<?php
echo 'Hello World!';
?>

Salva e chiudi il file (premi CTRL+X, poi Y, poi INVIO). Esegui lo script:

php hello.php

Se il PHP viene elaborato correttamente, vedrai solo i caratteri all'interno delle virgolette:

Hello World!

PHP ha elaborato correttamente lo script, il che significa che il tuo ambiente PHP è installato correttamente e sei pronto per continuare il tuo percorso di programmazione.

Fase 8 — Configurazione di progetti PHP reali

I framework PHP moderni come Laravel, Symfony e WordPress richiedono estensioni PHP specifiche e Composer. Installa il framework usando Composer o l’installer del framework, quindi configura il tuo server web per puntare alla directory pubblica del progetto.

Configurazione di Laravel

Installa Laravel usando Composer:

composer create-project laravel/laravel my-laravel-app
cd my-laravel-app

Questo comando scarica Laravel e tutte le sue dipendenze. Il processo potrebbe richiedere alcuni minuti.

Laravel richiede queste estensioni PHP (installate nel Passo 1):

• php8.1-mbstring - Gestione delle stringhe multibyte
• php8.1-xml - Analisi XML
• php8.1-curl - richieste HTTP
• php8.1-zip - Gestione degli archivi
• php8.1-bcmath - Matematica a precisione arbitraria

Se Laravel dice “mbstring mancante” anche se lo hai installato:

Questo di solito significa che l'estensione è installata ma non caricata. Verifica:

1. Verifica che l'estensione sia installata:

php -m | grep mbstring

1. Se manca, installalo:

sudo apt install php8.1-mbstring

1. Se è installato ma non viene visualizzato, riavvia il tuo server web:

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

1. Verifica quale file php.ini viene utilizzato. L'installer di Laravel usa il PHP da CLI, quindi controlla:

php --ini

Assicurati che l'estensione sia abilitata nel file php.ini della CLI.

Verifica dell'installazione di Laravel:

Dopo il completamento dell'installazione, avvia il server di sviluppo di Laravel:

php artisan serve

Dovresti vedere:

INFO  Server running on [http://127.0.0.1:8000]

Visita http://localhost:8000 nel tuo browser. Dovresti vedere la pagina di benvenuto di Laravel.

Per configurazioni simili alla produzione con Apache o Nginx:

Configura il tuo server web in modo che punti alla directory public (non alla radice del progetto). Il public/index.php di Laravel è il punto di ingresso per tutte le richieste.

Configurazione di WordPress

Scarica ed estrai WordPress:

cd /var/www
sudo wget https://wordpress.org/latest.tar.gz
sudo tar -xzf latest.tar.gz
sudo chown -R www-data:www-data /var/www/wordpress

WordPress richiede un database MySQL o MariaDB. Installa MySQL se necessario:

sudo apt install mysql-server
sudo mysql_secure_installation

Lo script mysql_secure_installation ti chiederà di:

• Imposta una password di root
• Rimuovere utenti anonimi
• Disabilita l'accesso remoto come root
• Rimuovere il database di test
• Ricarica le tabelle dei privilegi

Crea un database e un utente per WordPress:

sudo mysql -u root -p

Al prompt di MySQL:

CREATE DATABASE wordpress_db;
CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'secure_password';
GRANT ALL PRIVILEGES ON wordpress_db.* TO 'wpuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Sostituisci secure_password con una password sicura. WordPress utilizzerà queste credenziali per connettersi al database.

Se WordPress non riesce a connettersi al database:

1. Verifica che MySQL sia in esecuzione:

sudo systemctl status mysql

1. Testare la connessione al database:

mysql -u wpuser -p wordpress_db

Se questo fallisce, controlla:

• Il nome utente e la password sono corretti
• Il database esiste: SHOW DATABASES;
• L'utente ha i permessi: SHOW GRANTS FOR 'wpuser'@'localhost';

1. Verifica che l'estensione MySQL di PHP sia installata:

php -m | grep mysql

Se manca, installalo:

sudo apt install php8.1-mysql
sudo systemctl restart apache2  # or php8.1-fpm for Nginx

Completamento dell'installazione di WordPress:

Configura il tuo server web in modo che punti a /var/www/wordpress (vedi il Passo 2 per Apache o il Passo 3 per Nginx). Visita il sito nel tuo browser. WordPress ti chiederà di:

1. Seleziona la tua lingua
2. Inserisci le credenziali del database (usa il database, il nome utente e la password che hai creato)
3. Completa l'installazione

Configurazione di Symfony

Installa Symfony usando Composer:

composer create-project symfony/website-skeleton my-symfony-app
cd my-symfony-app

Symfony richiede le stesse estensioni di Laravel. Avvia il server di sviluppo:

symfony server:start

Oppure usa il server integrato di PHP:

php -S localhost:8000 -t public

Se l'installazione di Symfony fallisce a causa di errori di estensione:

Verifica che tutte le estensioni richieste siano installate e caricate:

php -m | grep -E 'mbstring|xml|curl|zip|bcmath'

Se ne mancano, installali e riavvia il server web.

Passo 9 — Migliori pratiche per lo sviluppo locale

Proteggi il tuo ambiente locale, utilizza il controllo delle versioni, configura correttamente i permessi dei file e imposta configurazioni specifiche per l'ambiente. Queste pratiche prevengono problemi di sicurezza e rendono lo sviluppo più fluido.

Considerazioni sulla sicurezza

Anche nello sviluppo locale, segui le migliori pratiche di sicurezza:

1. Disabilitare le funzioni PHP pericolose in produzione: Funzioni come exec(), system() e shell_exec() dovrebbero essere limitate nei file php.ini di produzione.

2. Usa le variabili d'ambiente: memorizza le configurazioni sensibili nei file .env (non committarli mai nel controllo versione). Laravel e Symfony supportano questa funzionalità nativamente.

3. Imposta le autorizzazioni dei file corrette: I file del server web devono essere leggibili dall'utente del server web, ma non scrivibili:

sudo chown -R www-data:www-data /var/www/your-project
sudo find /var/www/your-project -type d -exec chmod 755 {} \;
sudo find /var/www/your-project -type f -exec chmod 644 {} \;

Perché queste autorizzazioni sono importanti: Le directory devono avere 755 (lettura, scrittura ed esecuzione per il proprietario; lettura ed esecuzione per gli altri) in modo che il server web possa attraversarle. I file devono avere 644 (lettura e scrittura per il proprietario; sola lettura per gli altri) in modo che il server web possa leggerli senza modificarli. Questo previene che script dannosi sovrascrivano i tuoi file.

Integrazione del Controllo Versioni

Usa sempre il controllo di versione per i tuoi progetti PHP. Inizializza Git nella directory del tuo progetto:

cd /var/www/your-project
git init

Crea un file .gitignore per escludere i file non necessari:

/vendor/
/node_modules/
.env
.DS_Store
*.log

Ottimizzazione delle prestazioni

Per migliorare le prestazioni nello sviluppo locale:

• Abilita OPcache: OPcache è incluso in PHP 8.1 e migliora le prestazioni memorizzando nella cache il codice PHP compilato.

• Utilizza l'ottimizzazione dell'autoloader di Composer:

composer install --optimize-autoloader --no-dev

• Configura i pool PHP-FPM per una migliore gestione delle risorse se utilizzi Nginx.

Fase 10 — Risoluzione dei Problemi Comuni

I problemi comuni nell'installazione di PHP includono estensioni mancanti, permessi dei file errati, errori di configurazione del server web e conflitti di versione. La maggior parte dei problemi può essere risolta controllando l'installazione delle estensioni, verificando i permessi dei file e esaminando i log del server web.

Estensioni PHP non caricate

Se php -m non mostra un'estensione che hai appena installato:

• Verifica che sia effettivamente installato:

dpkg -l | grep php8.1-extension_name

• Verifica se il file dell'estensione esiste:

ls /usr/lib/php/*/extension_name.so

• Verifica che sia abilitato in php.ini. Alcune estensioni devono essere abilitate esplicitamente:

grep -i extension_name /etc/php/8.1/*/php.ini

• Riavvia il tuo server web:

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

• Verifica quale php.ini viene utilizzato:

php --ini

Assicurati di controllare il file php.ini corretto (CLI vs server web).

Se l’estensione non appare ancora:

• Alcune estensioni richiedono librerie di sistema aggiuntive. Controlla la documentazione dell'estensione
• Verifica di aver installato la versione corretta (php8.1-extension, non php8.0-extension)
• Controlla se ci sono versioni di PHP in conflitto che potrebbero interferire

500 Errore Interno del Server

Un errore 500 significa che il server ha riscontrato un errore ma non può mostrarne i dettagli. Controlla i registri degli errori:

# Apache
sudo tail -20 /var/log/apache2/error.log

# Nginx
sudo tail -20 /var/log/nginx/error.log

# PHP-FPM
sudo tail -20 /var/log/php8.1-fpm.log

Cause comuni e soluzioni:

1. Permessi dei file non corretti: i file PHP devono essere leggibili dall'utente del server web

sudo chown -R www-data:www-data /var/www/your-project
sudo find /var/www/your-project -type f -exec chmod 644 {} \;
sudo find /var/www/your-project -type d -exec chmod 755 {} \;

1. Estensioni PHP mancanti: Controlla il registro degli errori per messaggi come “Chiamata a funzione indefinita”. Installa l'estensione mancante e riavvia il server web.

2. Errori di sintassi nei file PHP: Il registro degli errori mostrerà il file e il numero di riga. Problemi comuni:

   • Puntini e virgola mancanti
   • Parentesi o virgolette non chiuse
   • Utilizzo di funzioni o classi non definite

3. Configurazione errata del server web:

   • Apache: Controllare la configurazione degli host virtuali, il caricamento dei moduli
   • Nginx: Verifica il percorso del socket PHP-FPM, configurazione FastCGI

4. Limite di memoria PHP superato: aumenta memory_limit in php.ini se vedi errori “Dimensione memoria consentita esaurita”

Conflitti di versione PHP

Se php -v mostra una versione diversa da quella prevista, hai installato più versioni di PHP.

Controlla quali versioni sono installate:

dpkg -l | grep php | grep -E 'php[0-9]'

Usa esplicitamente la versione corretta:

php8.1 -v
php8.1 -m

Aggiorna il tuo server web per utilizzare PHP 8.1:

Per Apache, disabilita altri moduli PHP e abilita PHP 8.1:

sudo a2dismod php7.4 php8.0  # if they exist
sudo a2enmod php8.1
sudo systemctl restart apache2

Per PHP-FPM, interrompi le altre versioni e avvia PHP 8.1:

sudo systemctl stop php7.4-fpm php8.0-fpm  # if they exist
sudo systemctl start php8.1-fpm
sudo systemctl enable php8.1-fpm

Imposta PHP 8.1 come versione CLI predefinita:

sudo update-alternatives --set php /usr/bin/php8.1

Problemi di memoria di Composer

Se Composer esaurisce la memoria, vedrai un errore simile a:

Fatal error: Allowed memory size of 134217728 bytes exhausted

Risolvi eseguendo Composer con più memoria:

php -d memory_limit=512M /usr/local/bin/composer install

O aumenta il limite di memoria di PHP in php.ini:

memory_limit = 512M

Se l'installazione di Composer fallisce a causa di una discrepanza dell'hash:

La verifica dell'hash potrebbe fallire se:

• L'installatore è stato aggiornato da quando lo hai scaricato (scaricalo di nuovo per ottenere l'hash più recente)
• Il tuo download è corrotto (prova a scaricarlo di nuovo)
• Sei dietro un proxy che modifica i file (controlla le impostazioni di rete)

Problemi di connessione al database

Se la tua applicazione PHP non riesce a connettersi a MySQL/MariaDB, potresti vedere errori come:

SQLSTATE[HY000] [2002] No such file or directory

o

Access denied for user 'username'@'localhost'

Passaggi per la risoluzione dei problemi:

1. Verifica che il servizio del database sia in esecuzione:

sudo systemctl status mysql

Se non è in esecuzione, avvialo:

sudo systemctl start mysql
sudo systemctl enable mysql

1. Verifica che l'estensione MySQL di PHP sia installata:

php -m | grep mysql

Se manca, installalo:

sudo apt install php8.1-mysql
sudo systemctl restart apache2  # or php8.1-fpm for Nginx

1. Verifica le credenziali e i permessi del database. Testa la connessione:

mysql -u username -p database_name

Se questo fallisce, controlla:

• Il nome utente e la password sono corretti
• Il database esiste: SHOW DATABASES;
• L'utente ha i permessi: SHOW GRANTS FOR 'username'@'localhost';

Il file PHP viene visualizzato come testo normale invece di eseguirsi

Se il tuo file PHP viene visualizzato come testo normale nel browser:

1. Controlla l'estensione del file: Deve essere .php, non .txt né .html

2. Verifica che PHP stia elaborando i file:

   • Apache: Verifica che mod_php sia abilitato: apache2ctl -M | grep php
   • Nginx: Verifica che PHP-FPM sia in esecuzione e che il percorso del socket sia corretto

3. Controlla i permessi del file: Il server web deve essere in grado di leggere il file

4. Verifica che il file contenga codice PHP: Assicurati che inizi con <?php o <?

5. Controlla la configurazione del server web:

   • Apache: L'host virtuale potrebbe non essere configurato correttamente
   • Nginx: Il blocco location ~ \.php$ potrebbe essere assente o errato

Problemi di caricamento file

Se il caricamento dei file fallisce, potresti vedere errori come:

The uploaded file exceeds the upload_max_filesize directive

Controlla queste impostazioni di php.ini:

upload_max_filesize = 64M
post_max_size = 64M
max_execution_time = 300

Importante: post_max_size deve essere maggiore di upload_max_filesize. Se imposti upload_max_filesize=100M, imposta post_max_size=110M o superiore.

Se i caricamenti continuano a non funzionare:

1. Controlla il registro errori per messaggi di errore specifici
2. Verifica che la directory di caricamento esista e sia scrivibile:

sudo chmod 755 /path/to/upload/directory
sudo chown www-data:www-data /path/to/upload/directory

1. Controlla lo spazio su disco: df -h
2. Verifica che il modulo utilizzi enctype="multipart/form-data"

Riavvia il server web dopo aver apportato modifiche a php.ini.

Domande frequenti

Come faccio a installare PHP 8.1 su Ubuntu?

Installa PHP 8.1 utilizzando il gestore di pacchetti di Ubuntu: sudo apt update && sudo apt install php8.1. PHP 8.1 è disponibile nei repository predefiniti di Ubuntu, quindi non sono necessarie fonti di pacchetti aggiuntive.

Quali estensioni PHP sono essenziali per lo sviluppo?

Le estensioni essenziali includono php8.1-cli, php8.1-mysql, php8.1-curl, php8.1-xml, php8.1-mbstring, php8.1-zip, php8.1-gd e php8.1-bcmath. Queste coprono la connettività al database, le richieste HTTP, la gestione delle stringhe e l'elaborazione delle immagini.

Come configuro PHP con Apache o Nginx?

Per Apache, installa libapache2-mod-php8.1 e abilitalo con sudo a2enmod php8.1. Per Nginx, installa php8.1-fpm e configura Nginx per inoltrare le richieste PHP al socket PHP-FPM usando FastCGI.

Come posso verificare se PHP è installato correttamente?

Esegui php -v per controllare la versione di PHP. Crea un file di test con <?php phpinfo(); ?> e accedilo tramite il tuo server web per vedere informazioni dettagliate sulla configurazione di PHP.

Posso eseguire Laravel o WordPress in locale con questa configurazione?

Sì. Laravel richiede Composer e le estensioni PHP standard menzionate sopra. WordPress ha bisogno di un database MySQL oltre a PHP. Entrambi i framework funzionano con configurazioni Apache o Nginx.

Come installo Composer per progetti PHP?

Scarica il programma di installazione di Composer, verifica il suo hash e installalo globalmente: sudo php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer. Verifica con composer --version.

Come risolvo i problemi delle estensioni PHP mancanti?

Controlla le estensioni installate con php -m. Installa le estensioni mancanti usando sudo apt install php8.1-nome_estensione, poi riavvia il tuo server web.

Come configuro la segnalazione degli errori di PHP per lo sviluppo?

Modifica php.ini e imposta display_errors=On, error_reporting=E_ALL e log_errors=On. Ricorda di disabilitare la visualizzazione degli errori negli ambienti di produzione.

Qual è la differenza tra Apache e Nginx per PHP?

Apache utilizza mod_php per elaborare direttamente PHP (PHP è integrato nel processo di Apache), mentre Nginx richiede PHP-FPM (FastCGI Process Manager) per gestire le richieste PHP (PHP funziona come servizio separato). Consultare la sezione “Scegliere tra Apache e Nginx” sopra per una tabella di confronto dettagliata. Entrambi gli approcci funzionano bene; scegli in base alle tue esigenze di prestazioni, familiarità e infrastruttura esistente.

Posso installare più versioni di PHP sullo stesso sistema?

Sì, utilizzando strumenti come phpenv o phpbrew. Tuttavia, per la maggior parte degli scenari di sviluppo, una singola versione di PHP è sufficiente. Usa i gestori di versioni quando hai bisogno di testare applicazioni con diverse versioni di PHP.

Conclusione

Ora hai un ambiente di sviluppo PHP 8.1 completamente configurato su Ubuntu con supporto per entrambi i server web Apache e Nginx. La tua configurazione include le estensioni PHP essenziali, Composer per la gestione delle dipendenze e una corretta configurazione per lo sviluppo locale.

Prima di iniziare il tuo prossimo progetto, considera di configurare un Ambiente di Sviluppo Integrato (IDE) come VS Code con estensioni PHP per l'evidenziazione della sintassi, il debug e il supporto di IntelliSense.

Con l'ambiente pronto, puoi esplorare ulteriormente lo sviluppo in PHP:

• Impara le basi del PHP con Come lavorare con le stringhe in PHP
• Crea API utilizzando Come usare le API Web in PHP
• Comprendere le funzioni in Come usare le funzioni in PHP
• Configura i database con Come installare e usare PostgreSQL su Ubuntu

Per le distribuzioni in produzione, considera di utilizzare la piattaforma App Linux-Console.net per distribuire le tue applicazioni PHP direttamente da GitHub con scalabilità automatica e certificati SSL.

Grazie per aver imparato con la community di Linux-Console.net.