Aggiungere NoSQL su MySQL con memcached su Ubuntu 14.04

31 luglio 2015 NoSQL , MySQL , ottimizzazione del server Ubuntu

Introduzione

Il concetto generale dell’uso di memcached, e della sua implementazione da server standalone, con MySQL è stato descritto in articoli molti validi, per esempio in Come installare ed utilizzare Memcache su Ubuntu 14.04 . Tuttavia memcached, come server standalone, funziona da intermediario davanti al layer di accesso del client MySQL e gestisce le informazioni solo in memoria, senza la possibilità di conservarle permanentemente. Questo lo rende adatto per attività quali il caching dei risultati delle query duplicate di MySQL. Ciò consente di risparmiare risorse e ottimizza le prestazioni dei siti sotto forte carico.

Tuttavia, in questo articolo parleremo di qualcosa di diverso. Memcached sarà installato come plugin di MySQL e sarà strettamente integrato in esso. Fornirà un layer di accesso in stile NoSQL per la gestione delle informazioni, direttamente nelle abituali tabelle InnoDB di MySQL. Ciò presenta numerosi vantaggi, come vedremo più avanti in questo articolo.

Conoscenze di base

Per essere in grado di seguire questo articolo avrete bisogno di alcune conoscenze di base su ciò che sono NoSQL e memcached. In parole povere, NoSQL lavora con le informazioni sotto forma di elementi chiave-valore. Questo approccio, ovviamente più semplice dello standard SQL, comporta migliori prestazioni e scalabilità che sono particolarmente ricercati quando si lavora con grandi quantità di informazioni (Big Data).

Tuttavia, le buone prestazioni di NoSQL non sono sufficienti a sostituire il consueto SQL. La semplicità di NoSQL lo rende inadatto per dati strutturati legati tra loro da relazioni complesse. Così NoSQL non si sostituisce a SQL bensì ne diventa un’importante aggiunta.

Quanto a memcached, può essere considerato come una popolare implementazione di NoSQL. È molto veloce ed ha ottimi meccanismi di caching, come suggerisce il nome. Ciò lo rende la scelta ideale per portare lo stile NoSQL in quello tradizionale di MySQL.

È necessaria anche una certa comprensione del protocollo memcached. Memcached lavora con degli elementi che hanno i seguenti ruoli:

Una chiave – Valore alfanumerico che sarà la chiave per accedere al valore dell’elemento.
Un valore – Dati arbitrari in cui vengono memorizzate le informazioni essenziali.
Un flag – Di solito un valore utilizzato per la creazione di ulteriori parametri legati al valore principale. Ad esempio, potrebbe essere un flag l’utilizzo o meno della compressione.
Un tempo di scadenza – Il tempo di scadenza in secondi. Ricordiamoci che memcached è stato inizialmente progettato con in mente il caching.
Un valore di CAS – L’identificatore univoco di ogni elemento.

Prerequisiti

Questa guida è stata testata su Ubuntu 14.04. L’installazione e la configurazione qui descritte dovrebbero essere simili su altri sistemi operativi o su altre versioni del sistema operativo, ma i comandi e la posizione dei file di configurazione potrebbero variare.

Avrete bisogno di quanto segue:

Ubuntu 14.04 appena installato
Utente non root con privilegi sudo

Tutti i comandi di questo tutorial dovrebbero essere eseguiti come utente non root. Se è necessario usare un comando con i privilegi di root, questo verrà preceduto da sudo . Se non avete già tutto pronto, seguite questo tutorial: Configurazione iniziale del server con Ubuntu 14.04 .

Fase 1 – Installazione di MySQL 5.6

Il plugin memcached in MySQL è disponibile nelle versioni di MySQL superiori alla 5.6.6. Ciò significa che non è possibile utilizzare il pacchetto di MySQL (versione 5.5) dai repository di Ubuntu 14.04 standard. Dovrete invece:

Aggiungere il repository ufficiale di MySQL
Installare il server MySQL, client e librerie da tale repository

In primo luogo andate alla pagina dei repository apt MySQL e scaricate il pacchetto che aggiungerà il repository MySQL al vostro Ubuntu 14.04. È possibile scaricare il pacchetto direttamente sulla vostra Droplet [la VPS di DigitalOcean, NdT]:

$ wget https://dev.mysql.com/get/mysql-apt-config_0.3.5-1ubuntu14.04_all.deb

Dopodiché lo installiamo con dpkg :

$ sudo dpkg -i mysql-apt-config_0.3.5-1ubuntu14.04_all.deb

Quando si esegue il comando qui sopra, viene visualizzata una procedura guidata in modalità testo con due domande:

Which MySQL product do you wish to configure [Quale prodotto MySQL si desidera configurare]? Rispondete con Server .
Which server version do you wish to receive [Quale versione del server si desidera ricevere]? Rispondete con mysql-5.6 .

Una volta risposto a queste due domande si ritorna alla prima domanda su quale prodotto si desidera installare. Rispondete con Apply , la scelta in basso, per confermare le scelte e uscire dalla procedura guidata.

Ora che avete il nuovo repository MySQL, dovrete aggiornare la cache di apt, vale a dire le informazioni sui pacchetti disponibili per essere installati su Ubuntu. Così, quando si sceglierà di installare MySQL, questo verrà recuperato dal nuovo repository. Per aggiornare la cache di apt, eseguite il comando:

$ sudo apt-get update

Dopodiché si è pronti per l’installazione di MySQL 5.6 su Ubuntu 14.04 con il comando:

$ sudo apt-get install mysql-server

Una volta eseguito il comando qui sopra vi verrà chiesto di scegliere una password di root (amministratore) di MySQL. Per comodità, in questo punto è possibile scegliere di non impostare una password dunque, quando richiesto, basta premere INVIO. Tuttavia, una volta che si decide di portare questo server in produzione, si consiglia di eseguire il comando sudo mysql_secure_installation per rendere sicura l’installazione di MySQL e configurare una password di root.

Quando il processo di installazione sarà terminato, il server MySQL 5.6 sarà installato assieme al suo client da riga di comando e le librerie che servono. È possibile fare una verifica avviando il client con il comando:

$ mysql -u root

Se avete impostato una password, è necessario utilizzare il seguente comando e inserire la password di root di MySQL quando richiesto:

$ mysql -u root -p

Si dovrebbe leggere questo:

Welcome to the MySQL monitor. Commands end with ; or \g. 
Your MySQL connection id is 2 
Server version: 5.6.25 MySQL Community Server (GPL) ...

Mentre si è ancora nel monitor di MySQL (terminale del client), create un nuovo database denominato test :

mysql> CREATE DATABASE test;

Avremo bisogno di questo database più tardi per i nostri test.

Per uscire dal client di MySQL digitate:

mysql> quit

Infine, quale dipendenza per il plugin memcached, sarà necessario installare anche il pacchetto di sviluppo della libreria di notifica degli eventi asincroni: libevent-dev . Per farlo, eseguite il comando:

$ sudo apt-get install libevent-dev

Fase 2 – Installazione del plugin memcached su MySQL

Per preparare l’installazione del plugin memcached, prima si devono eseguire le query che si trovano nel file /usr/share/mysql/innodb_memcached_config.sql . Avviate il client di MySQL:

$ mysql -u root

oppure se usate una password:

 mysql -u root -p

e lanciate:

mysql> source /usr/share/mysql/innodb_memcached_config.sql;

Ciò creerà tutte le impostazioni necessarie al plugin nel database innodb_memcache ed inserirà anche alcuni dati di esempio nel database test appena creato.

Dopodiché è possibile eseguire l’installazione del plugin memcached dal terminale di MySQL con il seguente comando:

mysql> install plugin daemon_memcached soname "libmemcached.so";

Uscite dalla sessione di MySQL:

mysql> quit

Questo consente di installare il plugin memcached che si trova nella directory /usr/lib/mysql/plugin/ su Ubuntu 14.04. Questo file è disponibile solo per MySQL versione 5.6 e superiori.

Una volta completata l’installazione, è necessario configurare il listener del plugin memcached. Servirà per connettersi al plugin memcached. A questo scopo, aprite il file /etc/mysql/my.cnf con il vostro editor preferito, ad esempio:

$ sudo vim /etc/mysql/my.cnf

Da qualche parte, dopo la linea [mysqld] aggiungete una nuova linea contenente:

/etc/mysql/my.cnf

 daemon_memcached_option="-p11222 -l 127.0.0.1"

Quanto sopra configura il listener del plugin memcached sulla porta 11222, abilitato solo per l’ip di loopback 127.0.0.1. Ciò significa che solo i client della Droplet saranno in grado di connettersi. Se si omette la parte sull’ip ( -l 127.0.0.1 ), il nuovo listener sarà accessibile liberamente da ogni dove, il che è un grave rischio per la sicurezza. Se siete preoccupati per la sicurezza del plugin memcached consultate la sua documentazione riguardante la sicurezza .

Per avviare il nuovo processo listener del plugin memcached, riavviate il server MySQL con il comando:

$ sudo service mysql restart

Fase 3 – Test del plugin memcached

Per verificare che l’installazione abbia avuto successo, eseguite il seguente comando MySQL dal client MySQL (avviate il client con mysql -u root oppure mysql -u root -p ):

mysql> show plugins;

Se tutto va bene, in output dovreste avere:

| daemon_memcached    | ACTIVE  | DAEMON  | libmemcached.so | GPL     |

Se non è così, assicuratevi di utilizzare MySQL versione 5.6 o superiore e di aver seguito con precisione le istruzioni di installazione.

Potete anche provare a connettervi alla nuova interfaccia del plugin memcached con Telnet dalla vostra Droplet in questo modo:

$ telnet localhost 11222

In caso di successo dovreste avere un output del tipo:

 Connected to localhost.
 Escape character is '^]'.

Ora è possibile eseguire un comando generico come stats per le statistiche, per vedere come funziona la connessione. Per uscire dal prompt, sulla tastiera premete contemporaneamente CTRL e ]. Dopodiché digitate quit per chiudere il client Telnet.

Telnet è la maniera più semplice per connettersi al plugin memcached e ai dati di MySQL. Va bene per fare dei test, ma quando si decide di farne un uso professionale è necessario utilizzare le librerie per i linguaggi di programmazione come PHP e Python, di cui si può facilmente avere accesso.

Fase 4 – Effettuare query NoSQL su MySQL tramite il plugin memcached

Se tornate di nuovo alla parte dell’installazione del plugin memcached di questo articolo, si vedrà che abbiamo eseguito le dichiarazioni dal file /usr/share/mysql/innodb_memcached_config.sql . Queste dichiarazioni hanno creato una nuova tabella demo_test nel database test. La tabella demo_test ha le seguenti colonne in conformità del protocollo di memcached:

c1 implementa il campo chiave.
c2 implementa il campo valore.
c3 implementa il campo flag.
c4 implementa il campo CAS.
c5 implementa il campo scadenza.

La tabella demo_test sarà quella con la quale effettuermo il test. In primo luogo, apriamo il database/tabella con il client MySQL con il seguente comando:

$ mysql -u root test

Oppure, se si dispone di una password:

$ mysql -u root test -p

Ci dovrebbe essere già una riga nella tabella demo_test:

mysql> SELECT * FROM demo_test;

Il risultato dovrebbe essere simile a:

+-------------+--------------+------+------+------+
| c1          | c2           | c3   | c4   | c5   |
+-------------+--------------+------+------+------+
| AA          | HELLO, HELLO |    8 |    0 |    0 |
+-------------+--------------+------+------+------+
1 rows in set (0.00 sec)

Uscite dalla sessione di MySQL:

mysql> quit

Ora creiamo un secondo record utilizzando l’interfaccia NoSQL di memcached e telnet. Colleghiamoci di nuovo a localhost sulla porta TCP 11222:

$ telnet localhost 11222

Quindi utilizziamo la seguente sintassi:

set [chiave] [flag] [scadenza] [lunghezza in byte]
[valore]

Si noti che il valore deve essere su una nuova riga. Inoltre, quando si sta lavorando nel modo indicato sopra, per ogni record si deve specificare la lunghezza in byte del valore.

A titolo di esempio, creiamo un nuovo elemento (una riga del database) con chiave newkey , il valore 0 per il flag e il valore 0 per la scadenza (dunque senza scadenza). Il valore è di 12 byte.

set newkey 0 0 12 
NewTestValue

Ovviamente, tramite questa interfaccia NoSQL, è anche possibile recuperare i valori. Ciò viene fatto con il comando get seguito dal nome della chiave che si desidera recuperare. Mentre si è ancora nella sessione Telnet, digitate:

get newkey

Il risultato dovrebbe essere:

VALUE newkey 0 12 
NewTestValue

I comandi set e get qui sopra, sono validi per tutti i server memcached. Questi erano solo alcuni semplici esempi su come inserire e recuperare i record in uno stile NoSQL.

Ora cerchiamo di collegarci di nuovo al client MySQL con il comando mysql -u root test o mysql -u root test -p e vedere di nuovo il contenuto della tabella demo_test eseguendo la query:

mysql> SELECT * FROM demo_test WHERE c1="newkey";

La riga appena creata dovrebbe apparire così:

+--------+--------------+------+------+------+
| c1     | c2           | c3   | c4   | c5   |
+--------+--------------+------+------+------+
| newkey | NewTestValue |    0 |    1 |    0 |
+--------+--------------+------+------+------+

A questo punto ci si chiederà come il plugin memcached sappia quali sono il database e la tabella a cui connettersi e come faccia a mappare le informazioni per le colonne della tabella. La risposta è nel database innodb_memcache e la relativa tabella containers .

Eseguite questa select:

mysql> select * from containers \G

Si vedrà:

*************************** 1. row ***************************
                  name: aaa
             db_schema: test
              db_table: demo_test
           key_columns: c1
         value_columns: c2
                 flags: c3
            cas_column: c4
    expire_time_column: c5
unique_idx_name_on_key: PRIMARY
1 row in set (0.00 sec)

Per ulteriori informazioni su come creare differenti mappature e scoprire le caratteristiche avanzate del plugin memcached, consultate la pagina dei plugin memcached .

I vantaggi dell’integrazione di MySQL con il plugin memcached

Le informazioni e gli esempi qui sopra, delineano alcuni importanti vantaggi derivanti dall’integrazione di MySQL con NoSQL attraverso il plugin memcached:

Tutti i dati (MySQL e NoSQL) possono essere conservati in un unico luogo. Non è necessario installare e manutenere software aggiuntivo per i dati NoSQL.
La persistenza dei dati, il ripristino e la replica per i dati NoSQL sono possibili grazie al potente storage engine InnoDB.
Il veloce layer di accesso ai dati di memcached può essere utilizzato anche in modo che si possa lavorare con volumi di informazioni maggiori rispetto a quando si lavora con il più lento client MySQL.
I dati NoSQL possono essere gestiti con l’interfaccia e la sintassi di MySQL. Dunque è possibile includere i dati NoSQL in query SQL più complesse, come i left join.

Conclusioni

Finito l’articolo, dovreste aver acquisito familiarità con le nuove possibilità di eleborazione dei dati NoSQL forniti da MySQL. Ciò non può essere una soluzione universale per la sostituzione dei server dedicati NoSQL, come MongoDB, ma ha certamente i suoi meriti.

Autore: Anatoliy Dimitrov

Aggiungere NoSQL su MySQL con memcached su Ubuntu 14.04