[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [volume] [parte]
MySQL (1) è un DBMS (Data base management system) relazionale. Il nome contiene la sigla «SQL», a indicare che si tratta di un DBMS in grado di comprendere le istruzioni SQL.
L'installazione del servente MySQL può essere molto laboriosa, se non si dispone di un pacchetto già pronto per la propria distribuzione GNU. La descrizione di come installare MySQL viene omessa, perché questa appare nella documentazione di MySQL in modo molto dettagliato. Qui si fa riferimento a una situazione relativamente «comune», a seguito dell'installazione automatica di un pacchetto pronto.
In generale, il servente MySQL è costituito dal demone mysqld, avviato attraverso uno script della procedura di inizializzazione del sistema, che potrebbe corrispondere a /etc/init.d/mysql. Assieme a questo demone ci sono altri programmi di servizio che servono principalmente per l'amministrazione e la manutenzione delle basi di dati, il più importante dei quali è mysqladmin.
L'installazione del servente MySQL richiede, nell'ambito del sistema operativo, la preparazione di un utente e un gruppo speciali, entrambi con il nome mysql. Questa utenza dovrebbe essere già disponibile oppure potrebbe essere creata automaticamente dal sistema di installazione dei pacchetti della propria distribuzione. La directory personale associata a questo utente speciale dovrebbe rappresentare il contenitore dei file che compongono le basi di dati gestite da MySQL: ~mysql/.
Il servente MySQL è sottoposto al controllo di un file di configurazione, che in condizioni normali potrebbe corrispondere a /etc/mysql/my.cnf, oppure solo /etc/my.cnf. Tuttavia, questo file è suddiviso in sezioni e contiene anche la configurazione relativa ai programmi clienti, mentre una configurazione specifica del solo servente può essere collocata nel file ~mysql/my.cnf.
L'amministratore del DBMS con MySQL si chiama convenzionalmente root e si prevede che in un sistema Unix coincida con l'utente root, ma ciò non è strettamente necessario. L'accesso da parte di questo utente, come degli altri, è sottoposto alla presentazione di una parola d'ordine che viene stabilita con l'ausilio di mysqladmin, o attraverso istruzioni SQL appropriate; pertanto, anche se ci può essere una corrispondenza tra utenze di MySQL e utenze del sistema operativo, le parole d'ordine usate non sono collegate tra loro.
MySQL ha una gestione particolare delle proprie utenze, distinguendole in base alla provenienza degli accessi. A seconda del contesto può capitare di utilizzare notazioni del tipo tizio@dinkel.brot.dg, dove si intende fare riferimento all'utente denominato tizio che accede dal nodo dinkel.brot.dg. Deve essere subito chiaro che non si tratta di un indirizzo di posta elettronica e nemmeno di un'utenza Unix. Pertanto, anche l'utente root (l'amministratore del DBMS), deve essere qualificato meglio e solitamente si fa riferimento a root@localhost (l'utente root che accede al servente attraverso lo stesso elaboratore che offre il servizio.
Come accennato, la configurazione generale di MySQL è contenuta nel file /etc/mysql/my.cnf, oppure /etc/my.cnf, a seconda dell'organizzazione della propria distribuzione GNU, con la possibilità di usare il file ~mysql/my.cnf per ciò che riguarda strettamente il funzionamento del servente. Molto probabilmente, il file di configurazione generale è già predisposto per consentire un accesso locale al servente MySQL; di solito può essere utile verificare o ritoccare solo alcune direttive, specialmente per ciò che riguarda l'abilitazione dell'accesso attraverso la rete.
Il file di configurazione contiene direttive che assomigliano in pratica all'assegnamento di variabili, nella forma seguente:
nome = valore |
Queste direttive sono suddivise in sezioni, dichiarate tra parentesi quadre:
[sezione] direttiva ... |
È attraverso la presenza di queste sezioni che è possibile distinguere le direttive relative al servente da quelle di altre componenti.
Come spesso accade nei file di configurazione comuni, il simbolo # introduce un commento, fino alla fine della riga; inoltre, le righe bianche o vuote sono ignorate.
Le direttive che riguardano il funzionamento del servente sono contenute nelle sezioni [mysqld_safe] e [mysqld]. Per il momento conviene soffermarsi solo su alcune della seconda di queste sezioni:
|
Si comprende intuitivamente il significato di queste direttive: il demone mysqld viene avviato con i privilegi dell'utente mysql; viene usato il file /var/run/mysqld/mysqld.pid per annotare il numero PID del demone in funzione; viene utilizzato il file /var/run/mysqld/mysqld.sock come socket di dominio Unix per le comunicazioni locali, oppure la porta 3 306 per le comunicazioni attraverso la rete; nel file /var/log/mysql.log vengono annotate le informazioni relative al suo funzionamento; la directory /usr/ è il punto di partenza dell'installazione dei programmi e di altre componenti; la directory /var/lib/mysql/ è il punto di inizio dei file che compongono le basi di dati (equivale a ~mysql/); la directory usata per i file temporanei è /tmp/; infine, i messaggi mostrati dal demone sono quelli contenuti nella directory /usr/share/mysql/english/, ovvero quelli espressi in lingua inglese.
Alcune direttive particolari non hanno la forma dell'assegnamento e contengono una sola stringa, nella forma seguente:
skip-nome |
La presenza di queste direttive indica la disabilitazione di ciò che viene descritto sinteticamente dalla parte finale del loro nome; per esempio, la direttiva skip-networking serve a disabilitare l'accesso attraverso la rete. Di solito, la configurazione predefinita di MySQL prevede proprio l'uso di questa direttiva per impedire l'accesso attraverso la rete, rendendo necessaria la modifica di questo file per consentirlo in modo esplicito.
Un altro tipo di direttiva, che comunque rientra nel genere normale di assegnamento, serve a dichiarare delle variabili, intese come opzioni di funzionamento, a cui si assegna anche un valore. Si tratta di direttive che hanno l'aspetto seguente:
set-variable = nome=valore |
L'utilizzo di queste variabili può dipendere dal modo in cui si compilano i sorgenti di MySQL; pertanto può essere necessario stabilire su cosa si può intervenire, avviando il demone mysqld con l'opzione --help, anche senza privilegi particolari:
$ /usr/bin/mysqld --help[Invio]
Oltre alla sintassi relativa alla riga di comando, si dovrebbe osservare la presenza dell'elenco seguente, che qui viene abbreviato:
Variables (--variable-name=value)
and boolean options {FALSE|TRUE} Value (after reading options)
--------------------------------- -----------------------------
auto-rehash TRUE
character-sets-dir (No default value)
default-character-set (No default value)
compress FALSE
database (No default value)
...
net_buffer_length 16384
select_limit 1000
max_join_size 1000000
|
Un problema comune che si può avvertire quando si cerca di mettere in funzione un servente MySQL, sta nel concedere gli accessi attraverso la rete.
Generalmente, la configurazione contenuta nel file /etc/mysql/my.cnf (o solo /etc/my.cnf) prevede una direttiva che limita gli accessi al solo elaboratore locale. Ci sono due possibilità:
|
Se si usa la direttiva skip-networking, si intende concedere esclusivamente un accesso locale, tramite un socket di dominio Unix; se si usa la direttiva bind-address = 127.0.0.1 (senza però usare anche skip-networking), si concede l'accesso attraverso la rete, ma in pratica si concede esclusivamente un accesso locale, tramite l'indirizzo 127.0.0.1.
In pratica, per consentire un accesso remoto al DBMS, occorre eliminare (o commentare) entrambe queste direttive.
L'avvio e l'arresto del servente dovrebbe essere gestito da uno script della procedura di inizializzazione del sistema, che in generale potrebbe corrispondere a /etc/init.d/mysql. Se le cose stanno così, è sufficiente avviare il servizio con il comando seguente:
# /etc/init.d/mysql start[Invio]
Nello stesso modo, per arrestare il servizio basta il comando seguente:
# /etc/init.d/mysql stop[Invio]
Può essere interessante approfondire cosa succede realmente all'interno di questo script per comprendere come è organizzato MySQL nell'ambito del proprio sistema operativo.
In generale ci sono da considerare due aspetti: il demone mysqld non viene avviato direttamente, ma attraverso un altro programma, mysqld_safe; in secondo luogo, l'arresto del funzionamento del servente avviene attraverso mysqladmin, che richiede l'indicazione di una parola d'ordine.
L'avvio del servente attraverso mysqld_safe non richiede la comprensione di altre questioni, a parte la necessità di accertarsi che non ci sia già un servente MySQL in funzione. Comunque, la presenza di questo programma (mysqld_safe) fa sì che esista anche una sezione apposita nella configurazione, denominata nello stesso modo:
|
Il problema dell'arresto del servizio è invece più complesso, in quanto si deve usare un altro programma, mysqladmin, che può portare a termine l'operazione soltanto se si utilizzano i privilegi dell'amministratore del servizio, per ottenere i quali occorre fornire la parola d'ordine relativa:
# mysqladmin --password="ciaociao" shutdown[Invio]
L'amministratore di MySQL ha il nome root (in questo caso sarebbe precisamente root@localhost), che, come accennato nella premessa, coincide volutamente con il nome dell'amministrazione di un sistema Unix, pur non essendo la stessa cosa. Dal momento che ogni utente di MySQL può predisporre nella propria directory personale un file di configurazione personalizzato, corrispondente a ~/.my.cnf, in questo file si può anche inserire la propria parola d'ordine, con una direttiva della sezione [client], che in questo caso è riferita all'utente root:
|
Così facendo, come viene chiarito in seguito, quando un utente del sistema operativo accede a un servente MySQL locale, se l'utenza di MySQL coincide con il nominativo usato nell'ambito del sistema operativo, può fare a meno di fornire la propria parola d'ordine perché già definita nella configurazione personale. Secondo questo principio, l'utente root del sistema operativo potrebbe fare altrettanto per consentire a script che vengono avviati automaticamente di svolgere il loro compito.
Esistono comunque dei raggiri differenti, per evitare di costringere l'utente root del sistema operativo a inserire la parola d'ordine nel file di configurazione ~/.my.cnf. In particolare, la distribuzione GNU/Linux Debian definisce un utente speciale, denominato debian-sys-maint (debian-sys-maint@localhost), con i privilegi necessari, a cui associa il file di configurazione /etc/mysql/debian.cnf, avviando poi mysqladmin con l'opzione --defaults-extra-file:
# mysqladmin --defaults-extra-file=/etc/mysql/debian.cnf ...[Invio]
Naturalmente, il file /etc/mysql/debian.cnf non deve essere leggibile agli utenti comuni del sistema operativo, dal momento che contiene la parola d'ordine per le funzioni amministrative gestite in modo automatico dal sistema stesso:
|
Perché il servente MySQL possa essere avviato e funzionare, è necessario che sia stata predisposta una struttura iniziale di dati, che serve successivamente ad accogliere le basi di dati. Si tratta di file di una base di dati speciale, che si colloca assieme alle altre nella directory ~mysql/.
Questa struttura iniziale si crea con il comando mysql_install_db, che corrisponde a uno script. Si usa semplicemente così:
# mysql_install_db[Invio]
Può succedere che la propria distribuzione GNU, pur predisponendo un pacchetto per il servente MySQL, non provveda alla creazione di questa struttura iniziale dei dati; in tal caso non si riesce ad avviare il servente e occorre provvedere da soli a usare il comando mysql_install_db.
MySQL distingue le proprie utenze in base a un nominativo e al nome dell'elaboratore da cui questi accedono. Il nominativo può anche essere assente e in tal caso si parla di utenze anonime. L'accesso può essere sottoposto al controllo di una parola d'ordine; inoltre, può anche essere consentito l'accesso a una base di dati senza essere utenti conosciuti.
Un primo controllo di accesso si ottiene con la configurazione del servente MySQL, dove è possibile escludere l'accesso attraverso la rete con la direttiva skip-networking, cosa che è utile fare quando il sistema di utenze e dei privilegi relativi non è ancora stato definito.
Per poter iniziare a organizzare le basi di dati e le utenze di MySQL, occorre agire con i privilegi dell'utente root. Quando si installa MySQL per la prima volta, è molto probabile che questo utente risulti essere sprovvisto di parola d'ordine, consentendo in pratica a qualunque utente di dichiararsi root, senza bisogno di altre forme di riconoscimento (ecco perché inizialmente è bene che la configurazione impedisca almeno l'accesso dall'esterno, attraverso la rete). Per associare una parola d'ordine all'utente root presso l'elaboratore che ospita il servente MySQL (quindi root@localhost) quando questo ne è ancora sprovvisto, basta usare il comando seguente:
# mysqladmin -u root password 'ciaociao'[Invio]
Come si intende, la parola d'ordine che appare nell'esempio è proprio «ciaociao».
A partire dal momento in cui la parola d'ordine è stata definita, ogni accesso al servente compiuto da questo utente richiede la sua indicazione, a meno che questa parola d'ordine risulti inserita nel file di configurazione personale ~/.my.cnf:
|
In questo caso, facendo riferimento alla sezione [client], la configurazione riguarda qualunque situazione in cui si accede al servente; in pratica riguarda qualunque programma. Eventualmente, si possono definire contesti più precisi; per esempio come nel caso seguente, in cui si consente di non specificare la parola d'ordine solo quando si utilizza il programma mysqladmin:
|
Il sistema di gestione delle utenze di MySQL è abbastanza complesso, dove per esempio, è possibile anche concedere dei privilegi di accesso a utenti qualunque provenienti da un certo nodo, o da un certo gruppo di nodi.
Per quanto riguarda l'indicazione dei nominativi-utente, esistono solo due possibilità: indicare un nome preciso, oppure non indicarlo affatto. Nel secondo caso si intende fare riferimento a qualunque utente nell'ambito del nodo o del gruppo di nodi a cui la definizione dei privilegi è associata.
Il nodo di accesso può essere indicato per nome, per numero, oppure si può fare riferimento a un gruppo di nodi con l'uso di caratteri jolly oppure associando a un indirizzo una maschera di rete. I caratteri jolly in questione sono il simbolo di percentuale (%) e il trattino basso (_). Segue una tabellina che descrive alcuni esempi di associazione tra utenti e nodi di accesso.
A seconda del contesto, le coordinate di un utente si indicano come nella tabella, inserendo il carattere @ per separare le due parti, oppure in campi distinti. In molti casi, nell'ambito delle istruzioni di MySQL è necessario proteggere il nome dell'utente e l'indicazione del nodo o dei nodi di accesso attraverso apici singoli. Per esempio, per poter indicare qualunque utente, come nel secondo esempio della tabella, è necessario delimitare la stringa nulla: ''@dinkel.brot.dg. Così, quando si usa il carattere jolly % è indispensabile delimitare l'indicazione riferita al nodo: tizio@'%.brot.dg'. In generale non si sbaglia se si delimitano sempre queste due componenti, anche se non dovesse servire: 'tizio'@'dinkel.brot.dg'.
Prima di poter definire delle politiche di accesso, è necessario prendere un po' di confidenza con il programma mysql, che consente di interagire con il servente MySQL. Si è già accennato al fatto che inizialmente dovrebbe risultare permesso l'accesso da parte di qualunque utente, inoltre dovrebbe essere disponibile la base di dati test, a cui qualunque utente può accedere.
mysql [opzioni] [base_di_dati] |
cat file_sql | mysql [opzioni] [base_di_dati] |
I modelli sintattici mostrano la possibilità di indicare delle opzioni ed eventualmente il nome di una base di dati da aprire inizialmente. Nel secondo modello, si vede in particolare come si può alimentare il programma mysql con uno script SQL. La tabella successiva descrive alcune delle opzioni che possono essere utilizzate.
|
Il programma mysql è uno di quelli che prende in considerazione la configurazione di MySQL, soprattutto per quanto riguarda il file ~/.my.cnf, dove gli utenti possono inserire il proprio nominativo-utente da utilizzare con MySQL e la parola d'ordine, per non dover ogni volta utilizzare le opzioni -u e -p:
|
Per esempio, se un certo utente del sistema operativo ha la necessità di identificarsi con il nominativo tizio e la sua parola d'ordine:
$ mysql -u tizio -p ...[Invio]
Enter password: digitazione_all'oscuro[Invio]
Oppure, disponendo del file ~/.my.cnf mostrato sopra, può fare a meno di queste opzioni e dell'indicazione della parola d'ordine.
Viene mostrato un esempio riferito all'utente tizio che accede a un servente MySQL locale:
$ mysql -u tizio[Invio]
Molto probabilmente non è necessario inserire alcuna parola d'ordine, dal momento che inizialmente dovrebbe essere stata inserita automaticamente l'utenza anonima @localhost senza parola d'ordine:
Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 14 to server version: 4.0.13-log Type 'help;' or '\h' for help. Type '\c' to clear the buffer. |
Da questo momento appare un invito speciale, rappresentato dalla stringa mysql>. La prima cosa che può essere conveniente fare è verificare la disponibilità di basi di dati a cui si può accedere:
mysql> SHOW DATABASES;[Invio]
Molto probabilmente si ottiene precisamente quanto segue, ovvero il riferimento all'unica base di dati, test, a cui è consentito accedere con questo utente:
+----------+ | Database | +----------+ | test | +----------+ 1 row in set (0.03 sec) |
Si può selezionare la base di dati con il comando seguente:
mysql> USE test;[Invio]
Database changed |
Quindi si può tentare di consultare l'elenco delle relazioni disponibili, con il comando seguente, ma inizialmente la basi di dati test non ne contiene alcuna:
mysql> SHOW TABLES;[Invio]
Empty set (0.00 sec) |
A titolo di esempio si vuole creare la relazione Indirizzi con il codice SQL seguente:
|
Con il programma mysql si può fare così:
mysql> CREATE TABLE Indirizzi ([Invio]
-> Codice INTEGER,[Invio]
-> Cognome CHAR(40),[Invio]
-> Nome CHAR(40),[Invio]
-> Indirizzo VARCHAR(60),[Invio]
-> Telefono VARCHAR(40)[Invio]
-> );[Invio]
Query OK, 0 rows affected (0.06 sec) |
Come si può osservare, finché l'istruzione SQL non risulta completa, appare un invito differente: ->.
Per completare l'esempio si può inserire qualche dato e poi si può visualizzare il contenuto della relazione:
mysql> INSERT INTO Indirizzi VALUES (01, 'Pallino', 'Pinco',[Invio]
-> 'Via Biglie 1', '0222,222222');[Invio]
Query OK, 1 row affected (0.06 sec) |
mysql> SELECT * FROM Indirizzi;[Invio]
+--------+---------+-------+--------------+-------------+ | Codice | Cognome | Nome | Indirizzo | Telefono | +--------+---------+-------+--------------+-------------+ | 1 | Pallino | Pinco | Via Biglie 1 | 0222,222222 | +--------+---------+-------+--------------+-------------+ 1 row in set (0.00 sec) |
Per concludere il funzionamento di mysql basta il comando interno quit, che si può esprimere anche come \q:
mysql> \q[Invio]
Bye |
MySQL gestisce le proprie informazioni amministrative all'interno della base di dati mysql, a cui si dovrebbe poter accedere soltanto in qualità di utente root (possibilmente root@localhost), o comunque solo attraverso utenze speciali.
# mysql -u root -p[Invio]
Enter password: digitazione all'oscuro[Invio]
In questo modo si vuole accedere al servente MySQL locale, in qualità di utente root (root@localhost), fornendo anche la parola d'ordine.
Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 15 to server version: 4.0.13-log Type 'help;' or '\h' for help. Type '\c' to clear the buffer. |
Si controlla la disponibilità di basi di dati esistenti:
mysql> SHOW DATABASES;[Invio]
+----------+ | Database | +----------+ | mysql | | test | +----------+ 2 rows in set (0.01 sec) |
Si accede alla base di dati mysql:
mysql> USE mysql;[Invio]
Database changed |
Si elencano le relazioni disponibili:
mysql> SHOW TABLES;[Invio]
+-----------------+ | Tables_in_mysql | +-----------------+ | columns_priv | | db | | func | | host | | tables_priv | | user | +-----------------+ 6 rows in set (0.00 sec) |
Il significato dettagliato di queste relazioni può essere studiato nella documentazione originale che accompagna MySQL. Ciò che è importante comprendere è che non si può consentire l'accesso a queste relazioni a utenti che non hanno un ruolo amministrativo. Tuttavia, durante la fase di studio di MySQL da parte di chi deve poi amministrarne il servizio, è utile imparare a consultare queste relazioni. Per esempio, è utile essere al corrente delle utenze che sono effettivamente previste:
mysql> SELECT User, Host, Password FROM user;[Invio]
+------------------+-----------+------------------+ | user | host | password | +------------------+-----------+------------------+ | root | localhost | 576gtd435e967361 | | root | dinkel | | | | localhost | | | | dinkel | | | debian-sys-maint | localhost | 69b3c178kbvcd325 | +------------------+-----------+------------------+ 5 rows in set (0.00 sec) |
Quello che si vede qui è quanto si potrebbe ottenere dopo aver installato MySQL in una distribuzione GNU/Linux Debian, attraverso pacchetti appositi, in un elaboratore dove il comando hostname restituisce il nome dinkel. Si può notare la presenza dell'utente speciale debian-sys-maint, a cui si è già accennato, ma si deve portare attenzione alle utenze «normali». Si può osservare che ci sono due utenti root; precisamente si tratta di root@localhost e di root@dinkel. La seconda di queste due utenze rappresenta l'utente root che accede localmente, ma attraverso la rete, da un'interfaccia che è associata al nome dell'elaboratore (in questo caso dinkel.brot.dg). Può anche darsi che un'utenza annotata in questo modo non risulti funzionante, ma rimane il problema, dato il fatto che si tratta di un'utenza importante e senza parola d'ordine per accedere (per quanto riguarda l'utenza root@localhost è già stato mostrato come definire la parola d'ordine ed è per questo che appare qualcosa nella colonna password). Eventualmente, si possono fare considerazioni simili per l'utenza anonima @dinkel.
Probabilmente è superfluo precisare che nella colonna password, se esiste una parola d'ordine associata all'utenza, appare una stringa che rappresenta la parola d'ordine cifrata.
mysql> \q[Invio]
Bye |
Durante la fase della prima installazione di MySQL uno script si occupa di creare le directory che devono ospitare i file che compongono le basi di dati, inserendo la base di dati amministrativa (mysql). In pratica, è questo script che definisce anche le utenze iniziali, senza parola d'ordine. Questo script è mysql_install_db.
MySQL AB, MySQL reference manual
Appunti di informatica libera 2007.02 --- Copyright © 2000-2007 Daniele Giacomini -- <daniele (ad) swlibero·org>
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome mysql_struttura_e_preparazione.htm
[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico]
