Installazione e configurazione di MySQL su Ubuntu 20.04

Gli utenti di Ubuntu possono scegliere tra due sistemi di gestione di database relazionali affidabili (RDBMS),MySQL e MariaDB . MySQL ha un vantaggio di lunga data in termini di popolarità, ma c'è stato un maggiore interesse per MariaDB a causa dei suoi vantaggi in termini di prestazioni e funzionalità aggiunte. Questa guida confronta i due sistemi di database e fornisce istruzioni su come installare e utilizzare MySQL su Ubuntu 20.04.

Cos'è MySQL?

MySQL RDBMS è una delle applicazioni open source più popolari. Fa parte dello Stack LAMP , che è la pietra angolare di molti sistemi Ubuntu. Questo stack è costituito da Linux, il server Web Apache, MySQL RDBMS e il linguaggio di programmazione PHP. Queste applicazioni interagiscono per supportare applicazioni Web, sviluppo software e attività specializzate come la scienza dei dati. L'uso principale di MySQL è in configurazioni a server singolo di piccole e medie dimensioni.

Le query MySQL sono scritte nel Structured Query Language (SQL). In quanto database relazionale, archivia e organizza i dati in tabelle. Le tabelle strutturano i dati effettivi all'interno delle tabelle come una serie di righe, con ogni riga composta da una o più colonne. Ogni riga rappresenta una voce diversa nella tabella, mentre ogni colonna contiene un campo dati all'interno della voce. I campi di dati in queste tabelle possono essere correlati tra loro e queste relazioni aiutano a strutturare e organizzare il database. Le istruzioni SQL specializzate consentono ai client di aggiungere, eliminare, modificare e recuperare dati.

MySQL è noto per la sua stabilità e affidabilità ed è considerato semplice e facile da usare. È disponibile come software open source gratuito sotto la GNU General Public License. MySQL è prontamente disponibile per tutte le distribuzioni Linux e altri sistemi operativi. Ora è di proprietà della Oracle Corporation. Oracle offre anche la commercialeMySQL Enterprise Edition come prodotto di fascia alta.

MySQL e MariaDB

Le due principali alternative di database open source, MySQL e MariaDB, sono molto simili. Sono entrambi prodotti RDBMS ed entrambi utilizzano SQL. Entrambi i sistemi di database hanno versioni gratuite e sembrano e agiscono più o meno allo stesso modo. Poiché MariaDB originariamente si è diramata da MySQL, questo non è sorprendente. Da allora MariaDB ha subito un ulteriore sviluppo e presenta molti nuovi miglioramenti in termini di sicurezza e prestazioni. Con MySQL, tuttavia, molte funzionalità avanzate si trovano solo nell'edizione Enterprise. Ecco un riepilogo delle somiglianze e delle differenze tra i due prodotti:

MariaDB supporta più connessioni di MySQL.
Entrambi i database possono funzionare con più sistemi di archiviazione, sebbene MariaDB offra più opzioni.
MariaDB può replicare i dati più rapidamente di MySQL e ha prestazioni complessive migliori. MySQL gestisce transazioni di grandi dimensioni in modo più efficace, ma MariaDB offre prestazioni migliori in situazioni scalate.
MySQL supporta alcune funzionalità che MariaDB non ha, come le colonne dinamiche. Ogni database ha alcune funzionalità avanzate e miglioramenti che l'altro non ha.
MySQL è più vecchio, più affermato, più popolare e ha più supporto dalla comunità. MySQL offre piani di supporto a pagamento più completi.
MariaDB e MySQL sono completamente compatibili.
Entrambi i prodotti sono open source, ma il modello di licenza MySQL è più restrittivo.

Per riassumere, entrambi i sistemi sono più che adeguati per la maggior parte degli utenti. MariaDB offre prestazioni migliori, mentre MySQL è consolidato e supportato meglio.

Prima di iniziare

Se non l'hai già fatto, crea un account Linode e un'istanza di calcolo. Consulta le nostre guide Introduzione a Linode e Creazione di un'istanza di calcolo.
Segui la nostra guida alla configurazione e alla protezione di un'istanza di calcolo per aggiornare il tuo sistema. Potresti anche voler impostare il fuso orario, configurare il tuo nome host, creare un account utente limitato e rafforzare l'accesso SSH.

Nota I passaggi in questa guida sono scritti per utenti non root. I comandi che richiedono privilegi elevati sono preceduti da sudo . Se non hai familiarità con sudo comando, vedere la guida per utenti e gruppi Linux.

Come installare il server MySQL

MySQL è disponibile come parte dei pacchetti Ubuntu predefiniti, quindi non è necessario modificare l'elenco dei sorgenti. Può essere facilmente installato usando apt , ma è importante proteggere l'applicazione e modificare il firewall in seguito. Queste istruzioni sono rivolte agli utenti di Ubuntu, ma sono generalmente applicabili a coloro che desiderano installare MySQL su un'altra distribuzione Linux.

Scarica MySQL

Per installare il server MySQL su Ubuntu, segui i passaggi seguenti:

Installa l'applicazione del server MySQL.
```
sudo apt install mysql-server
```

Conferma che il server MySQL è in esecuzione utilizzando systemctl comando. Dovrebbe visualizzare uno stato di active .

sudo systemctl status mysql

mysql.service - MySQL Community Server
    Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset:>
    Active: active (running) since Thu 2021-09-09 12:24:29 UTC; 1h 44min ago

Configura il server MySQL su Linux

La mysql_secure_installation utility è il modo più semplice per configurare l'applicazione. Per utilizzare lo script di installazione, segui questi passaggi:

Avvia mysql_secure_installation utility per impostare la password di root e configurare altre opzioni predefinite.
```
sudo mysql_secure_installation
```

L'applicazione chiede se attivare il VALIDATE PASSWORD COMPONENT componente. Se rispondi y , quindi chiede se impostare la sicurezza della password su LOW , MEDIUM o HIGH .

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Al prompt successivo, l'utilità richiede una password per l'account root. Impostare la password e poi reinserirla.
```
Please set the password for root here.

New password:

Re-enter new password:
```

Le seguenti domande chiedono se rimuovere gli utenti anonimi, per consentire il root account per connettersi in remoto e rimuovere il test Banca dati. Inserisci y o n ad ogni richiesta secondo le vostre preferenze. Il test database è utile durante la convalida iniziale, ma per motivi di sicurezza è meglio non consentire il root account dall'accesso remoto.

By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.

Remove anonymous users? (Press y|Y for Yes, any other key for No) :

Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.

Disallow root login remotely? (Press y|Y for Yes, any other key for No) :

By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.

Remove test database and access to it? (Press y|Y for Yes, any other key for No

Quando richiesto, ricarica il privilege tabelle per aggiornare il database.

Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.

Reload privilege tables now? (Press y|Y for Yes, any other key for No)

Success.

All done!

(Facoltativo ) Per accedere a MySQL in remoto, assicurati che il traffico MySQL sia consentito tramite ufw firewall. Aggiungi la seguente regola per aprire la porta 3306 sul firewall. Questa regola non deve essere aggiunta se non è richiesto l'accesso remoto.

ufw allow mysql

Status: active

To                         Action      From
--                         ------      ----
Apache Full                ALLOW       Anywhere
OpenSSH                    ALLOW       Anywhere
3306/tcp                   ALLOW       Anywhere
Apache Full (v6)           ALLOW       Anywhere (v6)
OpenSSH (v6)               ALLOW       Anywhere (v6)
3306/tcp (v6)              ALLOW       Anywhere (v6)

Accedi a MySQL come utente root

Sebbene il root l'utente ha pieno accesso al database MySQL, il suo utilizzo dovrebbe essere riservato per scopi amministrativi. Ciò riduce la possibilità di sovrascrivere accidentalmente sezioni critiche del database. Anche in una configurazione a utente singolo, dovrebbe essere creato un account utente separato per la maggior parte delle attività MySQL.

Per accedere al server MySQL come root utente e creare un nuovo account utente, attenersi alla seguente procedura:

Usa sudo mysql comando per accedere al database. MySQL autentica l'utente root in base alle sue credenziali di root quando accede localmente, quindi non è richiesta alcuna password. In alternativa, accedi all'account root usando sudo mysql -u root -p , insieme alla root password.
```
sudo mysql
```

MySQL visualizza il numero di versione e alcune informazioni sull'installazione, quindi presenta il prompt di MySQL.

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 15
Server version: 8.0.26-0ubuntu0.20.04.2 (Ubuntu)
...
mysql>

Per confermare il corretto funzionamento di MySQL, utilizzare SHOW DATABASES comando per visualizzare tutti i database.

SHOW DATABASES;

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.01 sec)

Crea un nuovo utente usando il CREATE USER comando. Inserisci il nome utente nel formato 'username'@'IP_Address' , dove IP_Address è l'indirizzo IP dell'utente. Se l'utente sta accedendo a MySQL dal Linode locale, sostituisci localhost al posto dell'indirizzo IP. Nel comando seguente, sostituisci mysqluser e password con il nome utente e la password effettivi.

Nota MySQL offre diversi meccanismi di autenticazione. Il caching_sha2_password Il metodo è consigliato per gli utenti che desiderano accedere utilizzando una password e viene utilizzato qui. Tuttavia, alcune applicazioni meno recenti potrebbero non essere in grado di autenticarsi correttamente in questo modo. In tal caso, mysql_native_password dovrebbe essere usato invece. La replica della replica sorgente di MySQL potrebbe richiedere il sha256_password metodo.
```
CREATE USER 'mysqluser'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'password';
```
Concedi l'accesso al nuovo utente utilizzando il GRANT PRIVILEGE comando, utilizzando il formato GRANT list of privileges ON table TO 'username'@'IP_Address'; . Alcuni dei privilegi più comuni includono CREATE , ALTER , DROP , INSERT , UPDATE , DELETE e SELECT . Per applicare questi privilegi a tutti i database, utilizzare la variabile jolly *.* . Il comando seguente concede privilegi non amministrativi comuni su tutti i database a mysqluser .
```
GRANT CREATE, ALTER, DROP, INSERT, UPDATE, DELETE, SELECT, REFERENCES, RELOAD ON *.* TO 'mysqluser'@'localhost' WITH GRANT OPTION;
```
Per uscire dal prompt di MySQL, digita exit .
```
exit
```

Come utilizzare MySQL

MySQL utilizza la sintassi SQL standard per tutti i suoi comandi. I passaggi in questa sezione mostrano come eseguire attività di base in MySQL, come la creazione di database, tabelle e l'aggiunta di dati. Per informazioni complete su come utilizzare MySQL, vedere il Manuale di riferimento di MySQL. Per un'introduzione breve ma completa, prova il tutorial di MySQL.

Crea un database

Per creare un database, accedi a MySQL utilizzando un account con CREATE privilegi. Sostituisci mysqlusername con il nome utente che hai creato.
```
mysql -u mysqlusername -p
```
Crea un nuovo database usando CREATE DATABASE comando. Sostituisci newdatabasename con il nome desiderato per il tuo database.
```
CREATE DATABASE newdatabasename;
```
```
Query OK, 1 row affected (0.00 sec)
```

Per confermare la corretta creazione del nuovo database, utilizzare SHOW DATABASES .

SHOW DATABASES;

+--------------------+
| Database           |
+--------------------+
...
| newdatabasename   |
...
+--------------------+
5 rows in set (0.00 sec)

Indica il database con cui vuoi lavorare usando il USE comando. Sostituisci newdatabasename con il nome del database che hai appena creato.
```
USE newdatabasename;
```
```
Database changed
```
Nota Puoi anche usare USE comando quando hai più di un database e vuoi passare da uno all'altro.

Per conoscere il nome del database corrente, utilizzare il SELECT DATABASE comando. L'output mostra il nome del database.

SELECT DATABASE();

+------------------+
| DATABASE()       |
+------------------+
| newdatabasename |
+------------------+

Crea una tabella

A questo punto, il database, newdatabasename non ha tabelle, quindi non è ancora possibile memorizzare alcun dato al suo interno. Per definire una tabella, usa CREATE TABLE comando. Insieme al nome della tabella, questo comando richiede il nome e il tipo di dati di ciascun campo. Il tipo di dati caratterizza i dati memorizzati nel campo. Ad esempio, il tipo di dati potrebbe essere una stringa di lunghezza variabile, nota come VARCHAR . Per un elenco completo dei tipi di dati, consultare la documentazione di MySQL. Alcuni dei tipi di dati più comuni sono i seguenti.

INT: Questo può contenere un valore compreso tra -2147483648 e 2147483647 . Se specificato come UNSIGNED , può memorizzare valori compresi tra 0 e 4294967295 .
PICCOLO: Contiene un valore intero ancora più piccolo compreso tra -32768 e 32767 .
GALLEGGIANTE: Questo tipo può memorizzare un numero a virgola mobile.
DATA: Memorizza una data in YYYY-MM-DD formato.
DATA ORA: Memorizza una combinazione di data e ora in YYYY-MM-DD HH:MM:SS formato. Lo stesso tempo può essere memorizzato senza trattini e due punti nel TIMESTAMP formato.
VARCHAR(N): Questa è una stringa di lunghezza variabile compresa tra 1 e N caratteri di lunghezza, con una lunghezza massima di 255 caratteri.
TESTO: Questo tipo di dati può contenere fino a 65535 caratteri. Può contenere testo, immagini o dati binari.
CHAR(N): Questo tipo rappresenta un campo di testo a lunghezza fissa di lunghezza N . Ad esempio, per contenere codici di stato a due caratteri, utilizza un tipo di dati CHAR(2) .

Prima di creare tabelle, è importante stabilire uno schema per la banca dati. Lo schema descrive cosa rappresenta ogni tabella, quali dati sono archiviati in ogni tabella e come le tabelle sono correlate. Per creare una tabella, segui questi passaggi:

Dopo aver effettuato l'accesso a MySQL, passa al database in cui desideri aggiungere la tabella.
```
use newdatabasename;
```

Usa CREATE TABLE comando per generare una nuova tabella. Usa il formato CREATE TABLE table_name (field_1 datatype, field_n datatype); .

CREATE TABLE newtablename (column1 VARCHAR(20), column2 CHAR(1), column3 DATE, column4 SMALLINT UNSIGNED);

Query OK, 0 rows affected (0.02 sec)

Per confermare che la tabella ora esiste, usa SHOW TABLES comando.

SHOW TABLES;

+----------------------------+
| Tables_in_newdatabasename |
+----------------------------+
| newtablename              |
+----------------------------+
1 row in set (0.00 sec)

Per rivedere la struttura della tabella e verificare l'elenco dei campi, utilizzare il DESCRIBE comando.

DESCRIBE newtablename;

+---------+-------------------+------+-----+---------+-------+
| Field   | Type              | Null | Key | Default | Extra |
+---------+-------------------+------+-----+---------+-------+
| column1 | varchar(20)       | YES  |     | NULL    |       |
| column2 | char(1)           | YES  |     | NULL    |       |
| column3 | date              | YES  |     | NULL    |       |
| column4 | smallint unsigned | YES  |     | NULL    |       |
+---------+-------------------+------+-----+---------+-------+
4 rows in set (0.00 sec)

Se una tabella non è più necessaria, eliminala utilizzando il DROP TABLE comando.

Attenzione Quando una tabella viene eliminata, tutti i dati all'interno della tabella vengono persi e non possono essere recuperati.
```
DROP TABLE newtablename;
```

Aggiungi e recupera dati

Il modo principale per inserire una nuova riga di dati in una tabella è con INSERT comando.

Per aggiungere una riga, usa INSERT comando. Specifica il nome della tabella, la parola chiave VALUES e un elenco di valori tra parentesi separati da virgole nel formato INSERT INTO tablename VALUES ('value_1', ... 'value_n'); . I valori delle colonne devono avere la stessa sequenza della definizione della tabella, con i valori della stringa e della data tra virgolette. Ad esempio, per aggiungere dati a newtablename , specifica i valori per column1 , column2 , column3 e column4 , in quest'ordine.
```
INSERT INTO newtablename VALUES ('value1','a','2021-09-10',123);
```
```
Query OK, 1 row affected (0.01 sec)
```

Per recuperare i dati, usa il SELECT comando, insieme ad alcuni vincoli che dicono a MySQL quali righe restituire. È possibile restituire l'intero contenuto della tabella o solo un sottoinsieme. Per selezionare tutte le righe di una tabella, usa SELECT * comando, ma non aggiungere alcun qualificatore.

SELECT * FROM newtablename;

+---------+---------+------------+---------+
| column1 | column2 | column3    | column4 |
+---------+---------+------------+---------+
| value1  | a       | 2021-09-10 |     123 |
| value2  | b       | 2021-09-08 |     123 |
+---------+---------+------------+---------+
2 rows in set (0.00 sec)

È anche possibile selezionare solo righe che soddisfano criteri particolari, ad esempio, quando una colonna è impostata su un determinato valore. Usa il WHERE parola chiave come qualificatore, seguito dai criteri di corrispondenza come vincolo. In questo esempio, solo le righe in cui column2 è impostato su b vengono visualizzati.
```
SELECT * FROM newtablename WHERE column2 = 'b';
```
```
+---------+---------+------------+---------+
| column1 | column2 | column3    | column4 |
+---------+---------+------------+---------+
| value2  | b       | 2021-09-08 |     123 |
+---------+---------+------------+---------+
1 row in set (0.00 sec)
```
Per le tabelle con molte colonne, è spesso più semplice limitare le informazioni visualizzate. Per selezionare solo determinate colonne per ogni riga, specifica i nomi delle colonne invece di * simbolo.
```
SELECT column1, column4 FROM newtablename;
```
```
+---------+---------+
| column1 | column4 |
+---------+---------+
| value1  |     123 |
| value2  |     123 |
+---------+---------+
2 rows in set (0.00 sec)
```
Per modificare una riga in una tabella, usa UPDATE comando. Il SET parola chiave indica la colonna da aggiornare e il nuovo valore. Se necessario, il WHERE La parola chiave fornisce un metodo per vincolare l'operazione da applicare solo a determinate righe. Nell'esempio seguente, il valore di column4 viene modificato solo in 155 se column2 è uguale a b .
```
UPDATE newtablename SET column4 = 155 WHERE column2 = 'b';
```
```
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
```

Il SELECT * dichiarazione può essere utilizzata per confermare l'aggiornamento.

SELECT * FROM newtablename;

+---------+---------+------------+---------+
| column1 | column2 | column3    | column4 |
+---------+---------+------------+---------+
| value1  | a       | 2021-09-10 |     123 |
| value2  | b       | 2021-09-08 |     155 |
+---------+---------+------------+---------+
2 rows in set (0.00 sec)

Conclusione:MySQL su Ubuntu 20.04

MySQL è una buona scelta per applicazioni web di piccole e medie dimensioni. Utilizza il linguaggio di programmazione SQL standard del settore, che è abbastanza semplice da usare. MySQL è molto stabile e robusto e ha molte risorse insieme a un buon supporto. L'alternativa principale a MySQL è MariaDB. Offre prestazioni migliori e funzionalità più recenti, ma non è così consolidato.

Puoi facilmente scaricare e installare il server MySQL su Ubuntu usando apt pacchetti e mysql_secure_installation utilità. Anche se sei l'unica persona che utilizza MySQL, è meglio creare un nuovo utente MySQL con privilegi più limitati.

Per utilizzare MySQL, prima determina lo schema del database e definisci il contenuto della tabella. Quindi, crea un database e le tabelle di dati. I dati possono essere aggiunti usando il INSERT comando, modificato usando il UPDATE comando e recuperato utilizzando il SELECT comando. Naturalmente, MySQL può eseguire anche operazioni molto complesse. Segui il tutorial di MySQL per iniziare e consulta la documentazione di MySQL per una panoramica completa.

Maggiori informazioni

Si consiglia di consultare le seguenti risorse per ulteriori informazioni su questo argomento. Sebbene questi siano forniti nella speranza che possano essere utili, tieni presente che non possiamo garantire l'accuratezza o la tempestività dei materiali ospitati esternamente.

Sito web MariaDB
Sito Web MySQL