PDO vs mysqli in PHP: Differenze, Performance e Scelta per Sviluppatori Web

Intermedio
PHP

Un'analisi approfondita delle differenze tra PDO e mysqli, due API fondamentali per la connessione ai database MySQL in PHP, con un focus su performance, sicurezza e scenari d'uso.

Pubblicato
Tag
PHP Web Development MySQL database sql Performance PDO Sicurezza mysqli

La programmazione web moderna si basa in larga parte sull'interazione dinamica con i database. In PHP, due delle interfacce più diffuse per connettersi e interagire con i database MySQL sono mysqli e PDO (PHP Data Objects). Entrambe offrono funzionalità robuste per la gestione delle query, la protezione dalle iniezioni SQL tramite prepared statements e la gestione delle transazioni. Tuttavia, presentano differenze significative in termini di architettura, flessibilità e approccio.

Questo articolo si propone di esplorare in dettaglio mysqli e PDO, analizzandone le caratteristiche, i punti di forza e di debolezza, e fornendo esempi pratici per aiutarti a scegliere l'API più adatta alle tue esigenze di sviluppo web. Non si tratta solo di capire 'cosa' fanno, ma 'perché' una scelta potrebbe essere migliore dell'altra in specifici contesti, con un occhio di riguardo alla performance e alla sicurezza.

Comprendere la Connessione ai Database in PHP

Prima di addentrarci nel confronto, è fondamentale capire il ruolo di queste API. PHP, essendo un linguaggio server-side, necessita di un modo per comunicare con i sistemi di gestione di database (DBMS) come MySQL, PostgreSQL, SQLite e altri. Storicamente, PHP ha offerto diverse estensioni per questo scopo, come la vecchia estensione mysql_ (ora deprecata e rimossa). Le estensioni mysqli e PDO sono le soluzioni moderne e raccomandate per interagire con i database.

Entrambe le API forniscono un'interfaccia per eseguire operazioni CRUD (Create, Read, Update, Delete) sui dati, gestire le connessioni, eseguire query parametrizzate (prepared statements) per prevenire le iniezioni SQL e controllare l'integrità dei dati tramite transazioni. La scelta tra mysqli e PDO non è banale e può influenzare la portabilità, la manutenibilità e la sicurezza della tua applicazione.

L'Importanza della Sicurezza

Un aspetto cruciale nell'interazione con i database è la sicurezza. Le iniezioni SQL sono tra le vulnerabilità più comuni e pericolose. Sia mysqli che PDO offrono meccanismi robusti, in particolare i prepared statements, per mitigare questo rischio. Ignorare questi meccanismi significa esporre la propria applicazione a gravi pericoli, compromettendo l'integrità e la riservatezza dei dati.

mysqli: La Scelta Storica e Orientata agli Oggetti

mysqli (MySQL Improved Extension) è un'estensione specifica per MySQL, progettata per sfruttare le funzionalità avanzate di MySQL 4.1.3 e versioni successive. È un'evoluzione dell'ormai deprecata estensione mysql_ e offre un'interfaccia sia procedurale che orientata agli oggetti (OO).

Caratteristiche Principali di mysqli

  • Specifico per MySQL: Funziona esclusivamente con database MySQL.
  • Doppia Interfaccia: Supporta sia uno stile di programmazione procedurale (mysqli_connect(), mysqli_query()) sia uno stile orientato agli oggetti (new mysqli(), $mysqli->query()). Lo stile OO è generalmente preferito per la sua chiarezza e per la coerenza con le moderne pratiche di programmazione.
  • Prepared Statements: Implementazione robusta per query parametrizzate, essenziale per prevenire le iniezioni SQL. Permette di separare la logica della query dai dati, inviando i dati come parametri separati.
  • Transazioni: Supporto completo per le transazioni, permettendo di raggruppare più operazioni di database in un'unica unità logica, garantendo atomicita, consistenza, isolamento e durabilità (ACID).
  • Supporto per Funzionalità Avanzate: Include supporto per stored procedures, multi-query e altre funzionalità specifiche di MySQL.

Quando Usare mysqli

mysqli è un'ottima scelta se:

  • La tua applicazione si connetterà esclusivamente a database MySQL.
  • Preferisci un'API strettamente legata alle funzionalità di MySQL.
  • Stai lavorando su un progetto esistente che già utilizza mysqli e non hai necessità di migrare.

Esempio Pratico con mysqli (Orientato agli Oggetti)

Ecco come si presenta una connessione e una query sicura con mysqli usando lo stile orientato agli oggetti.

<?php
$servername = "localhost";
$username = "tuo_utente";
$password = "tua_password";
$dbname = "tuo_database";

// Creazione della connessione
$conn = new mysqli($servername, $username, $password, $dbname);

// Controllo della connessione
if ($conn->connect_error) {
    die("Connessione fallita: " . $conn->connect_error);
}

// Preparazione della query con prepared statement
$stmt = $conn->prepare("INSERT INTO utenti (nome, email) VALUES (?, ?)");
if ($stmt === false) {
    die("Errore nella preparazione dello statement: " . $conn->error);
}

// Binding dei parametri
$nome = "Mario Rossi";
$email = "mario.rossi@example.com";
$stmt->bind_param("ss", $nome, $email); // "ss" indica due stringhe

// Esecuzione dello statement
if ($stmt->execute()) {
    echo "Nuovo record creato con successo";
} else {
    echo "Errore: " . $stmt->error;
}

// Chiusura dello statement e della connessione
$stmt->close();
$conn->close();

?>

Questo esempio mostra come stabilire una connessione, preparare una query INSERT con placeholder ?, associare i tipi di dati e i valori (bind_param), ed eseguire la query. La gestione degli errori è basilare ma fondamentale.

PDO (PHP Data Objects): L'Interfaccia Astratta e Flessibile

PDO è un'estensione che definisce un'interfaccia leggera e coerente per accedere ai database in PHP. A differenza di mysqli, PDO non è specifico per MySQL, ma è un'astrazione che può connettersi a diversi tipi di database (MySQL, PostgreSQL, SQLite, Oracle, ecc.) purché sia disponibile il driver PDO corrispondente.

Caratteristiche Principali di PDO

  • Astrazione del Database: La sua caratteristica più distintiva è l'astrazione. Ciò significa che il codice scritto per interagire con un database MySQL può essere facilmente adattato per PostgreSQL o SQLite, cambiando solo la stringa di connessione (DSN) e il driver, senza dover riscrivere gran parte della logica delle query.
  • Interfaccia Orientata agli Oggetti: PDO è interamente orientato agli oggetti, offrendo un'API pulita e moderna.
  • Prepared Statements Avanzati: Supporta sia placeholder posizionali (?) che placeholder nominativi (:nome), offrendo maggiore leggibilità e manutenibilità per query complesse.
  • Gestione degli Errori Flessibile: Permette di configurare diverse modalità di gestione degli errori (silenziosa, warning, eccezioni), con le eccezioni (PDO::ERRMODE_EXCEPTION) che sono la best practice per una gestione robusta.
  • Transazioni: Supporto completo per le transazioni, con metodi chiari come beginTransaction(), commit() e rollBack().
  • Diverse Modalità di Fetching: Offre una vasta gamma di opzioni per recuperare i risultati delle query (oggetti, array associativi, array numerici, ecc.).

Quando Usare PDO

PDO è generalmente la scelta preferita e raccomandata se:

  • La tua applicazione potrebbe aver bisogno di connettersi a diversi tipi di database in futuro (portabilità).
  • Stai sviluppando un framework o una libreria che deve essere agnostica rispetto al database.
  • Vuoi un'API più moderna e coerente.
  • Apprezzi la flessibilità dei placeholder nominativi nei prepared statements.

Esempio Pratico con PDO

Ecco un esempio di connessione e query con PDO, utilizzando i placeholder nominativi.

<?php
$servername = "localhost";
$username = "tuo_utente";
$password = "tua_password";
$dbname = "tuo_database";

try {
    // Creazione della connessione (DSN per MySQL)
    $conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
    // Imposta la modalità errore su eccezioni per una gestione robusta
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    // Preparazione della query con prepared statement e placeholder nominativi
    $stmt = $conn->prepare("INSERT INTO utenti (nome, email) VALUES (:nome, :email)");

    // Binding dei parametri
    $nome = "Giulia Verdi";
    $email = "giulia.verdi@example.com";
    $stmt->bindParam(':nome', $nome); // bindParam accetta una variabile per riferimento
    $stmt->bindParam(':email', $email);

    // Esecuzione dello statement
    $stmt->execute();

    echo "Nuovo record creato con successo";

} catch(PDOException $e) {
    echo "Errore: " . $e->getMessage();
}

// La connessione si chiude automaticamente alla fine dello script
// o quando l'oggetto $conn non ha più riferimenti.
$conn = null;

?>

In questo esempio, notiamo l'uso del blocco try-catch per la gestione delle eccezioni, la stringa DSN per la connessione e l'uso di bindParam con placeholder nominativi. bindParam è particolarmente utile quando si vuole legare una variabile che potrebbe cambiare valore tra le esecuzioni dello statement.

Confronto Dettagliato: PDO vs mysqli

Ora che abbiamo familiarità con entrambe le API, analizziamole punto per punto per evidenziare le differenze chiave.

1. Supporto Database

  • mysqli: Esclusivamente per MySQL. Se la tua applicazione deve interagire solo con MySQL, questa specificità può essere un vantaggio in termini di ottimizzazione delle funzionalità native di MySQL.
  • PDO: Supporta una vasta gamma di database (MySQL, PostgreSQL, SQLite, Oracle, SQL Server, ecc.) tramite driver specifici. Questo offre un'enorme flessibilità e portabilità. Se un giorno dovessi cambiare DBMS, il tuo codice che usa PDO richiederà modifiche minime.

2. Interfaccia e Stile di Programmazione

  • mysqli: Offre sia un'interfaccia procedurale che una orientata agli oggetti. L'interfaccia OO è più moderna e raccomandata, ma la presenza dell'interfaccia procedurale può confondere i meno esperti o portare a codice meno leggibile se non si è consistenti.
  • PDO: È esclusivamente orientato agli oggetti. Questo garantisce un'API più pulita, coerente e in linea con le moderne pratiche di programmazione, facilitando l'apprendimento e l'uso.

3. Sicurezza (Prepared Statements)

Entrambe le API supportano i prepared statements, che sono il meccanismo fondamentale per prevenire le iniezioni SQL. La differenza sta nel modo in cui i parametri vengono gestiti:

  • mysqli: Utilizza placeholder posizionali (?) e richiede l'uso di bind_param() per legare i parametri, specificando il tipo di dato di ciascun parametro (es. 's' per stringa, 'i' per intero). Questo può essere un po' macchinoso per query con molti parametri.
  • PDO: Supporta sia placeholder posizionali (?) che nominativi (:nome_parametro). I placeholder nominativi migliorano significativamente la leggibilità del codice per query complesse, poiché non è necessario contare l'ordine dei parametri. PDO inferisce il tipo di dato, o si può specificare esplicitamente con PDO::PARAM_STR, PDO::PARAM_INT, ecc.

4. Gestione degli Errori

  • mysqli: Gli errori vengono tipicamente gestiti controllando i valori di ritorno delle funzioni/metodi (es. false per fallimento) e accedendo alle proprietà d'errore ($conn->error, $stmt->error). Questo richiede controlli espliciti dopo ogni operazione che potrebbe fallire.
  • PDO: Offre tre modalità di gestione degli errori tramite PDO::setAttribute(PDO::ATTR_ERRMODE, ...):
    • PDO::ERRMODE_SILENT: Non emette errori, richiede controlli manuali (default).
    • PDO::ERRMODE_WARNING: Emette un warning PHP, ma lo script continua.
    • PDO::ERRMODE_EXCEPTION: Lancia un'eccezione PDOException in caso di errore. Questa è la modalità raccomandata perché permette di catturare gli errori in blocchi try-catch, centralizzando e semplificando la gestione degli errori in modo robusto.

5. Performance

Questa è una delle aree più dibattute e spesso fraintese. In generale, le differenze di performance tra mysqli e PDO per le operazioni di database standard sono trascurabili nella maggior parte delle applicazioni web. Entrambe le estensioni sono scritte in C e compilate, il che le rende estremamente efficienti.

Le vere strozzature di performance si trovano solitamente altrove:

  • Design del Database: Struttura delle tabelle, indicizzazione, normalizzazione.
  • Efficienza delle Query SQL: Query mal scritte, JOIN inefficienti.
  • Configurazione del Server MySQL: Cache, buffer, configurazione hardware.
  • Logica Applicativa PHP: Codice PHP inefficiente, troppe query inutili.
  • Latenza di Rete: Distanza tra il server web e il server database.

Sebbene ci possano essere micro-benchmark che mostrano leggere differenze in scenari specifici, nella pratica, la scelta tra mysqli e PDO raramente sarà il fattore determinante per le performance complessive di un'applicazione.

6. Flessibilità e Portabilità

  • mysqli: Bassa flessibilità e portabilità. Il tuo codice è strettamente legato a MySQL.
  • PDO: Alta flessibilità e portabilità. La sua astrazione consente di scrivere codice che funziona con diversi database, riducendo lo sforzo di migrazione o supportando architetture multi-database.

Esempi Pratici e Scenari d'Uso

Vediamo alcuni scenari comuni e come PDO e mysqli si comportano.

Scenario 1: Gestione delle Transazioni

Le transazioni sono fondamentali per garantire l'integrità dei dati, specialmente in operazioni che coinvolgono più scritture, come trasferimenti di denaro o creazione di ordini complessi.

Transazione con mysqli

<?php
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
    die("Connessione fallita: " . $conn->connect_error);
}

$conn->autocommit(FALSE); // Disabilita l'autocommit

try {
    // Inizio della transazione implicita con autocommit=FALSE

    $stmt1 = $conn->prepare("UPDATE conti SET saldo = saldo - ? WHERE id = ?");
    $stmt1->bind_param("di", $amount, $fromAccountId);
    $amount = 100.00;
    $fromAccountId = 1;
    $stmt1->execute();
    $stmt1->close();

    $stmt2 = $conn->prepare("UPDATE conti SET saldo = saldo + ? WHERE id = ?");
    $stmt2->bind_param("di", $amount, $toAccountId);
    $toAccountId = 2;
    $stmt2->execute();
    $stmt2->close();

    $conn->commit(); // Conferma le modifiche
    echo "Transazione completata con successo.";

} catch (Exception $e) {
    $conn->rollback(); // Annulla le modifiche in caso di errore
    echo "Transazione fallita: " . $e->getMessage();
}

$conn->autocommit(TRUE); // Riabilita l'autocommit
$conn->close();
?>

Transazione con PDO

<?php
try {
    $conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $conn->beginTransaction(); // Inizio esplicito della transazione

    $stmt1 = $conn->prepare("UPDATE conti SET saldo = saldo - :amount WHERE id = :fromId");
    $amount = 100.00;
    $fromAccountId = 1;
    $stmt1->bindParam(':amount', $amount);
    $stmt1->bindParam(':fromId', $fromAccountId);
    $stmt1->execute();

    $stmt2 = $conn->prepare("UPDATE conti SET saldo = saldo + :amount WHERE id = :toId");
    $toAccountId = 2;
    $stmt2->bindParam(':amount', $amount);
    $stmt2->bindParam(':toId', $toAccountId);
    $stmt2->execute();

    $conn->commit(); // Conferma le modifiche
    echo "Transazione completata con successo.";

} catch (PDOException $e) {
    $conn->rollBack(); // Annulla le modifiche in caso di errore
    echo "Transazione fallita: " . $e->getMessage();
}

$conn = null;
?>

Entrambi gli esempi raggiungono lo stesso obiettivo, ma l'approccio di PDO con beginTransaction(), commit() e rollBack() è spesso percepito come più chiaro e standardizzato.

Scenario 2: Recupero Dati e Modalità di Fetching

Il modo in cui i risultati di una query vengono recuperati può variare.

Fetching con mysqli

<?php
$conn = new mysqli($servername, $username, $password, $dbname);
// ... controllo errori ...

$stmt = $conn->prepare("SELECT id, nome, email FROM utenti WHERE id > ?");
$id = 0;
$stmt->bind_param("i", $id);
$stmt->execute();

$result = $stmt->get_result(); // Ottiene l'oggetto mysqli_result

if ($result->num_rows > 0) {
    // Recupera i dati come array associativo
    while($row = $result->fetch_assoc()) {
        echo "id: " . $row["id"]. " - Nome: " . $row["nome"]. " - Email: " . $row["email"]. "<br>";
    }
} else {
    echo "0 risultati";
}

$stmt->close();
$conn->close();
?>

Fetching con PDO

<?php
try {
    $conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $stmt = $conn->prepare("SELECT id, nome, email FROM utenti WHERE id > :id");
    $id = 0;
    $stmt->bindParam(':id', $id, PDO::PARAM_INT);
    $stmt->execute();

    // Recupera tutti i dati come array di array associativi
    $users = $stmt->fetchAll(PDO::FETCH_ASSOC);

    if (count($users) > 0) {
        foreach($users as $user) {
            echo "id: " . $user["id"]. " - Nome: " . $user["nome"]. " - Email: " . $user["email"]. "<br>";
        }
    } else {
        echo "0 risultati";
    }

} catch(PDOException $e) {
    echo "Errore: " . $e->getMessage();
}

$conn = null;
?>

PDO offre una maggiore varietà di modalità di fetching (PDO::FETCH_OBJ, PDO::FETCH_CLASS, PDO::FETCH_NUM, ecc.), rendendolo molto versatile per adattarsi a diverse esigenze di rappresentazione dei dati.

Sicurezza e Best Practices Indipendenti dalla Scelta

Indipendentemente dalla scelta tra PDO e mysqli, alcune pratiche di sicurezza e sviluppo sono universali e imprescindibili:

  • Utilizzare sempre Prepared Statements: Questa è la regola d'oro. Mai concatenare direttamente input utente nelle query SQL. I prepared statements sono la difesa più efficace contro le iniezioni SQL.
  • Validazione e Sanitizzazione degli Input: Anche con i prepared statements, è buona pratica validare e, se necessario, sanificare gli input utente prima di elaborarli. Questo previene altri tipi di attacchi (es. XSS) e garantisce che i dati siano nel formato atteso.
  • Gestione Robusta degli Errori: Non ignorare gli errori del database. Utilizza la modalità eccezioni di PDO o controlla attentamente i valori di ritorno di mysqli per rilevare e gestire i problemi in modo sicuro, evitando di esporre dettagli sensibili agli utenti finali.
  • Credenziali del Database Sicure: Non hardcodare le credenziali direttamente nel codice. Utilizza variabili d'ambiente, file di configurazione esterni o servizi di gestione segreti. Assicurati che questi file non siano accessibili pubblicamente.
  • Principio del Minimo Privilegio: Concedi all'utente del database solo i permessi strettamente necessari per le operazioni che deve eseguire. Evita di usare l'utente root per le applicazioni.
  • Aggiornamenti Regolari: Mantieni PHP e il tuo DBMS aggiornati alle ultime versioni stabili per beneficiare delle correzioni di sicurezza e delle ottimizzazioni.

Errori Comuni e Come Evitarli

Anche gli sviluppatori esperti possono cadere in alcune trappole comuni. Ecco come evitarle:

1. Non Usare Prepared Statements

Errore: "SELECT * FROM users WHERE username = '" . $_POST['username'] . "' AND password = '" . $_POST['password'] . "'"

Perché è un errore: Questo codice è estremamente vulnerabile alle iniezioni SQL. Un utente malintenzionato può manipolare l'input per alterare la query e accedere a dati non autorizzati.

Soluzione: Usa sempre prepare() e execute() con binding dei parametri, sia con PDO che mysqli.

2. Gestione degli Errori Inadeguata

Errore: Ignorare i messaggi di errore o stamparli direttamente all'utente (echo $e->getMessage(); in produzione).

Perché è un errore: Ignorare gli errori significa perdere l'opportunità di debug e non sapere quando qualcosa va storto. Esporre messaggi di errore dettagliati all'utente può rivelare informazioni sensibili sull'infrastruttura del tuo server o sul database.

Soluzione: In ambiente di sviluppo, stampa o logga gli errori completi. In produzione, logga gli errori in un file sicuro e mostra un messaggio generico all'utente. Con PDO, configura PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION e gestisci le eccezioni in un blocco try-catch.

3. Connessioni non Chiuse (con mysqli)

Errore: Dimenticare di chiamare $conn->close() e $stmt->close() con mysqli.

Perché è un errore: Anche se PHP chiude automaticamente le connessioni e gli statement alla fine dello script, chiuderli esplicitamente appena non sono più necessari libera risorse e può prevenire problemi in script di lunga durata o in ambienti con molte connessioni concorrenti.

Soluzione: Chiudi esplicitamente $stmt e $conn quando hai finito di usarli. Con PDO, assegnare null all'oggetto connessione ($conn = null;) chiude la connessione.

4. Credenziali Hardcoded

Errore: Inserire username e password del database direttamente nel file PHP principale.

Perché è un errore: Se il file PHP viene accidentalmente esposto o commesso in un repository pubblico, le credenziali sono compromesse.

Soluzione: Utilizza variabili d'ambiente (es. .env file con Dotenv), un file di configurazione esterno non web-accessibile o un servizio di gestione segreti. Questi metodi aumentano la sicurezza e la flessibilità del deployment.

Quale Scegliere? Raccomandazioni Finali

La scelta tra PDO e mysqli dipende dal contesto del tuo progetto, ma le tendenze attuali e le best practice favoriscono PDO per la maggior parte delle nuove applicazioni.

  • Per Nuovi Progetti e Framework (Raccomandato): PDO è quasi sempre la scelta migliore. La sua astrazione del database, la gestione flessibile degli errori tramite eccezioni e il supporto per placeholder nominativi lo rendono più potente, portabile e moderno. È la scelta predefinita per la maggior parte dei framework PHP (Laravel, Symfony, Zend Framework, ecc.).

  • Per Progetti Esistenti con mysqli: Se stai lavorando su un progetto maturo e stabile che utilizza mysqli e non hai piani per cambiare database, non c'è un'urgenza immediata di migrare. mysqli è un'API perfettamente valida e sicura per MySQL. L'importante è che il codice utilizzi correttamente i prepared statements e gestisca gli errori in modo robusto.

  • Per Sviluppo Specifico MySQL con Necessità Particolari: In rari casi, se hai bisogno di accedere a funzionalità molto specifiche e a basso livello di MySQL che potrebbero essere leggermente più dirette o performanti (marginalmente) con mysqli, potresti considerarlo. Tuttavia, questi scenari sono eccezionali e spesso risolvibili anche con PDO.

In sintesi, per la maggior parte degli sviluppatori web PHP di livello intermedio, PDO rappresenta la scelta più lungimirante e versatile. Offre una base solida per applicazioni scalabili, sicure e manutenibili, preparandoti meglio per il futuro del tuo stack tecnologico.

Prossimi Passi

Per approfondire ulteriormente le tue competenze nella programmazione web e nella gestione dei database, considera questi argomenti:

  1. ORM (Object-Relational Mapping): Esplora ORM come Doctrine (usato da Symfony) o Eloquent (usato da Laravel). Questi strumenti astraggono ulteriormente l'interazione con il database, permettendoti di lavorare con oggetti PHP invece che con query SQL dirette.
  2. Design del Database Avanzato: Approfondisci la normalizzazione del database, l'indicizzazione, le viste, le stored procedures e i trigger per ottimizzare le performance e l'integrità dei dati.
  3. Ottimizzazione delle Query SQL: Impara a scrivere query SQL efficienti e a utilizzare strumenti di analisi delle query (es. EXPLAIN in MySQL) per identificare e risolvere i colli di bottiglia.
  4. Sicurezza del Database: Studia tecniche avanzate di hardening del database, gestione dei permessi e monitoraggio delle attività.
  5. Database NoSQL: Sebbene PDO e mysqli siano per database relazionali, esplora le alternative NoSQL come MongoDB o Redis per capire quando e perché potrebbero essere una scelta migliore per specifici tipi di dati o carichi di lavoro.

Continuare a imparare e ad applicare le best practice ti renderà uno sviluppatore più competente e richiesto nel panorama della programmazione web.

Continua a leggere