Cómo optimizar las consultas de MySql con almacenamiento en caché de ProxySQL en Ubuntu 16.04

El autor seleccionó la Free Software Foundation para recibir una donación como parte del programa Write for DOnations.

Introducción

ProxySQL es un servidor proxy con reconocimiento de SQL que puede posicionarse entre su aplicación y su base de datos. Ofrece muchas funciones, como el equilibrio de carga entre varios servidores MySQL y además sirve como capa de almacenamiento en caché para las consultas. Este tutorial se centrará en la función de almacenamiento en caché de ProxySQL, y en la forma en que puede optimizar las consultas de su base de datos MySQL.

El almacenamiento en caché de MySQL se produce cuando el resultado de una consulta se almacena de modo que, cuando se repite la consulta, el resultado pueda mostrarse sin necesidad de realizar búsquedas en la base de datos. Esto puede aumentar considerablemente la velocidad de las consultas comunes. Sin embargo, en muchos métodos de almacenamiento en caché, los desarrolladores deben modificar el código de su aplicación, lo que podría introducir un error en la base de código. Para evitar esta práctica propensa a errores, ProxySQL le permite configurar un método de almacenamiento en caché transparente.

En el almacenamiento en caché transparente, los administradores de la base de datos solo necesitan cambiar la configuración de ProxySQL para permitir el almacenamiento en caché de las consultas más comunes, y estos cambios pueden realizarse a través de la interfaz de administración de ProxySQL. Lo único que el desarrollador debe hacer es establecer conexión con el proxy que reconoce el protocolo. El proxy decidirá si la consulta puede presentarse desde la memoria caché sin alcanzar al servidor de backend.

En este tutorial, usará ProxySQL para configurar un almacenamiento en caché transparente para un servidor MySQL en Ubuntu 16.04. A continuación, probará su rendimiento usando mysqlslap con y sin almacenamiento en caché para demostrar el efecto del almacenamiento en caché y la cantidad de tiempo que puede ahorrarse con él al ejecutar muchas consultas similares.

Requisitos previos

Para completar esta guía, necesitará lo siguiente:

• Un servidor de Ubuntu 16.04 con al menos 2 GB de RAM, configurado con un usuario no root con privilegios sudo y un firewall, como se indica en nuestra Guía de configuración inicial para servidores de Ubuntu 16.04.

Paso 1: Instalar y configurar el servidor de MySQL

Primero, instalará el servidor de MySQL y lo configurará para que lo use ProxySQL como servidor de backend para presentar consultas de clientes.

En Ubuntu 16.04, puede instalar mysql-server usando este comando:

sudo apt-get install mysql-server

Pulse Y para confirmar la instalación.

Se solicitará su contraseña de usuario** root** de MySQL. Introduzca una contraseña segura y guárdela para su uso posterior.

Ahora que tiene su servidor MySQL listo, lo configurará para que ProxySQL funcione correctamente. Debe añadir un usuario monitor para que ProxySQL monitorice el servidor de MySQL, ya que ProxySQL escucha al servidor de backend a través del protocolo SQL en vez de usar una conexión TCP o solicitudes HTTP GET para garantizar que el backend está en ejecución. El **usuario monitor **usará una conexión SQL ficticia para determinar si el servidor está activo o no.

Primero, inicie sesión en el shell de MySQL:

mysql -uroot -p

-uroot inicia sesión por usted usando el usuario root de MySQL y -p solicita la contraseña del usuario root. Este usuario root es diferente del usuario root de su servidor y la contraseña es la que introdujo cuando instaló el paquete mysql-server.

Introduzca la contraseña root y pulse ENTER.

Ahora, creará dos usuarios, uno llamado** monitor** para ProxySQL y otro que usará para ejecutar las consultas de los clientes y otorgarles los privilegios adecuados. En este tutorial, se asignará el nombre sammy a este usuario.

Cree el usuario monitor:

CREATE USER 'monitor'@'%' IDENTIFIED BY 'monitor_password';

La consulta CREATE USER se utiliza para crear un nuevo usuario que pueda conectarse desde IP específicas. Usar % denota que el usuario puede conectarse desde cualquier dirección IP. IDENTIFIED BY establece la contraseña para el nuevo usuario; introduzca la contraseña que desee, pero asegúrese de recordarla para usarla más adelante.

Una vez creado el usuario monitor, cree el usuario sammy:

CREATE USER 'sammy'@'%' IDENTIFIED BY 'sammy_password';

A continuación, conceda privilegios a sus nuevos usuarios. Ejecute el siguiente comando para configurar el usuario monitor:

GRANT SELECT ON sys.* TO 'monitor'@'%';

La consulta GRANT se utiliza para dar privilegios a los usuarios. Aquí solo concedió SELECT en todas las tablas de la base de datos sys al usuario monitor; solo necesita este privilegio para escuchar al servidor de backend.

Ahora, conceda todos los privilegios para todas las bases de datos al usuario sammy:

GRANT ALL PRIVILEGES on *.* TO 'sammy'@'%';

Esto permitirá que sammy realice las consultas necesarias para probar su base de datos más tarde.

Aplique los cambios de privilegios ejecutando lo siguiente:

FLUSH PRIVILEGES;

Finalmente, salga del shell mysql:

exit;

Con esto, habrá instalado mysql-server y creado un usuario que ProxySQL utilizará para monitorizar su servidor de MySQL, y otro para ejecutar las consultas de clientes. A continuación, instalará y configurará ProxySQL.

Paso 2: Instalar y configurar el servidor de ProxySQL

Ahora podrá instalar el servidor de ProxySQL, que se utilizará como una capa de almacenamiento en caché para sus consultas. Una capa de almacenamiento en caché existe como punto de detención entre los servidores de su aplicación y los servidores de backend de la base de datos; se utiliza para conectar con la base de datos y para guardar los resultados de algunas consultas en su memoria para acceder a ellas más rápidamente.

En la página de Github para versiones de ProxySQL se ofrecen archivos de instalación para distribuciones comunes de Linux. A los efectos de este tutorial, usará wget para descargar el archivo de instalación de Debian para la versión de ProxySQl 2.0.4:

wget https://github.com/sysown/proxysql/releases/download/v2.0.4/proxysql_2.0.4-ubuntu16_amd64.deb

A continuación, instale el paquete usando dpkg:

sudo dpkg -i proxysql_2.0.4-ubuntu16_amd64.deb

Una vez que lo haga, inicie ProxySQL con este comando:

sudo systemctl start proxysql

Puede comprobar si ProxySQL se inició correctamente con este comando:

sudo systemctl status proxysql

Verá un resultado similar a este:

Output
root@ubuntu-s-1vcpu-2gb-sgp1-01:~# systemctl status proxysql
● proxysql.service - LSB: High Performance Advanced Proxy for MySQL
   Loaded: loaded (/etc/init.d/proxysql; bad; vendor preset: enabled)
   Active: active (exited) since Wed 2019-06-12 21:32:50 UTC; 6 months 7 days ago
     Docs: man:systemd-sysv-generator(8)
    Tasks: 0
   Memory: 0B
      CPU: 0

Ahora es el momento de conectar su servidor de ProxySQL con el servidor de MySQL. Para esto, utilice la interfaz de administración SQL de ProxySQl, que por defecto escucha el puerto 6032 en localhost y tiene admin como nombre de usuario y contraseña.

Establezca conexión con la interfaz ejecutando lo siguiente:

mysql -uadmin -p -h 127.0.0.1 -P6032

Introduzca admin cuando se le solicite la contraseña.

-uadmin establece admin como nombre de usuario, y el indicador -h especifica que localhost es el host. El puerto es el 6032, especificado usando el indicador -P.

Aquí, tuvo que especificar el host y el puerto de forma explícita porque, por defecto, el cliente MySQL se conecta usando un archivo de sockets local y el puerto 3306.

Ahora que inició sesión en el shell de mysql como admin, configure el usuario monitor de modo que ProxySQL pueda usarlo. Primero, utilice consultas SQL estándares para establecer los valores de dos variables globales:

UPDATE global_variables SET variable_value='monitor' WHERE variable_name='mysql-monitor_username';
UPDATE global_variables SET variable_value='monitor_password' WHERE variable_name='mysql-monitor_password';

La variable mysql-monitor_username especifica el nombre de usuario de MySQL que se utilizará para comprobar si el servidor de backend está activo o no. La variable mysql-monitor_password apunta a la contraseña que se usará cuando establece conexión con el servidor de backend. Utilice la contraseña que creó para el nombre de usuario monitor.

Cada vez que realice un cambio en la interfaz de administración de ProxySQL, deberá usar el comando LOAD adecuado para aplicar los cambios a la instancia de ProxySQL en ejecución. Cambió las variables globales de MySQL. Por ello, cárguelas en RUNTIME para aplicar los cambios:

LOAD MYSQL VARIABLES TO RUNTIME;

A continuación, aplique SAVE los cambios a la base de datos en el disco para que los cambios persistan entre reinicios. ProxySQL utiliza su propia base de datos local SQLite para guardar sus tablas y variables:

SAVE MYSQL VARIABLES TO DISK;

Ahora, transmitirá información a ProxySQL sobre el servidor de backend. La tabla mysql_servers contiene información sobre cada servidor de backend en los cuales ProxySQL puede establecer conexión y ejecutar consultas. Por lo tanto, debe añadir un nuevo registro usando una instrucción INSERT de SQL con los siguientes valores para hostgroup_id, hostname y port:

INSERT INTO mysql_servers(hostgroup_id, hostname, port) VALUES (1, '127.0.0.1', 3306);

Para aplicar los cambios, ejecute LOAD y SAVE de nuevo:

LOAD MYSQL SERVERS TO RUNTIME;
SAVE MYSQL SERVERS TO DISK;

Finalmente, indicará a ProxySQL el usuario que se conectará con el servidor de backend; establezca sammy como el usuario y sustituya sammy_password por la contraseña que creó antes:

INSERT INTO mysql_users(username, password, default_hostgroup) VALUES ('sammy', 'sammy_password', 1);

La tabla mysql_users contiene información sobre los usuarios empleados para establecer conexión con los servidores de backend; especificó username, password y default_hostgroup.

Aplique LOAD y SAVE a los cambios:

LOAD MYSQL USERS TO RUNTIME;
SAVE MYSQL USERS TO DISK;

Finalmente, cierre el shell mysql:

exit;

Para probar que pueda establecer conexión con su servidor de backend usando ProxySQL, ejecute la siguiente consulta de prueba:

mysql -usammy -h127.0.0.1 -p -P6033 -e "SELECT @@HOSTNAME as hostname"

En este comando, usó el indicador -e para ejecutar una consulta y cerrar la conexión. La consulta imprime el nombre de host del servidor de backend.

El resultado tendrá este aspecto y your_hostname se sustituirá por su nombre de host:

Output
+----------------------------+
| hostname                   |
+----------------------------+
| your_hostname        |
+----------------------------+

Para obtener más información sobre la configuración de ProxySQL, consulte el paso 3 de Cómo usar ProxySQL como equilibrador de carga para MySQL en Ubuntu 16.04.

Hasta ahora, configuró ProxySQL para que utilice su servidor de MySQL como backend y estableció conexión con el este último usando ProxySQL. Ahora, estará listo para usar mysqlslap para hacer referencia al rendimiento de la consulta sin almacenamiento en caché.

Paso 3: Probar mysqlslap sin almacenamiento en caché

En este paso, descargará una base de datos de prueba para poder ejecutar consultas en ella con mysqlslap para probar la latencia sin almacenamiento en caché, estableciendo una referencia para la velocidad de sus consultas. También verá la forma en que ProxySQL lleva registros de las consultas en la tabla stats_mysql_query_digest.

mysqlslap es un cliente de emulación de carga que se usa como herramienta de prueba de carga para MySQL. Puede probar un servidor MySQL con consultas autogeneradas o con algunas consultas personalizadas ejecutadas en una base de datos. Viene instalado con el paquete cliente de MySQL, de modo que no necesita instalarlo. En vez de eso, descargará una base de datos solo para pruebas en la cual puede usar mysqlslap.

En este tutorial, usará una base de datos de empleados de muestra. Usará esta base de datos de empleados porque cuenta con un gran conjunto de datos que puede ilustrar las diferencias en la optimización de consultas. La base de datos tiene seis tablas, pero los datos que contiene tienen más de 300.000 registros de empleados. Esto le permitirá emular una carga de trabajo de producción a gran escala.

Para descargar la base de datos, primero clone el repositorio de Github usando este comando:

git clone https://github.com/datacharmer/test_db.git

A continuación, introduzca el directorio test_db y cargue la base de datos en el servidor MySQL usando estos comandos:

cd test_db
mysql -uroot -p < employees.sql

Este comando utiliza redireccionamiento de shell para leer las consultas SQL en el archivo employees.sql y las ejecuta en el servidor MySQL para crear la estructura de la base de datos.

Verá un resultado similar a este:

Output
INFO
CREATING DATABASE STRUCTURE
INFO
storage engine: InnoDB
INFO
LOADING departments
INFO
LOADING employees
INFO
LOADING dept_emp
INFO
LOADING dept_manager
INFO
LOADING titles
INFO
LOADING salaries
data_load_time_diff
00:00:32

Una vez que la base de datos se cargue en su servidor MySQL, pruebe que mysqlslap funcione con la siguiente consulta:

mysqlslap -usammy -p -P6033 -h127.0.0.1  --auto-generate-sql --verbose

mysqlslap tiene indicadores similares a los del cliente mysql; aquí están los que se utilizan en este comando:

• -u especifica el usuario usado para establecer conexión con el servidor.
• -p pide la contraseña del usuario.
• -P establece conexión usando el puerto especificado.
• -h establece conexión con el host especificado.
• --auto-generate-sql permite que MySQL realice una prueba de carga usando sus propias consultas generadas.
• --verbose hace que en el resultado se muestre más información.

Obtendrá un resultado similar al siguiente:

Output
Benchmark
    Average number of seconds to run all queries: 0.015 seconds
    Minimum number of seconds to run all queries: 0.015 seconds
    Maximum number of seconds to run all queries: 0.015 seconds
    Number of clients running queries: 1
    Average number of queries per client: 0

En este resultado, puede ver los números de segundos promedio, mínimo y máximo utilizados para ejecutar todas las consultas. Esto le proporciona una indicación sobre la cantidad de tiempo necesario para ejecutar las consultas por un número de clientes. En este resultado, solo se utilizó un cliente para ejecutar las consultas.

A continuación, descubra las consultas que mysqlslap ejecutó en el último comando mirando stats_mysql_query_digest de ProxySQL. Esto nos dará información, como el* resumen* de las consultas, que es una forma normalizada de la instrucción de SQL a la que se puede hacer referenciad más tarde para habilitar el almacenamiento en caché.

Ingrese en la interfaz de administración de ProxySQL con este comando:

mysql -uadmin -p -h 127.0.0.1 -P6032

A continuación, ejecute esta consulta para buscar la información en la tabla stats_mysql_query_digest:

SELECT count_star,sum_time,hostgroup,digest,digest_text FROM stats_mysql_query_digest ORDER BY sum_time DESC;

Verá resultados similares al siguiente:

+------------+----------+-----------+--------------------+----------------------------------+
| count_star | sum_time | hostgroup | digest             | digest_text                      |
+------------+----------+-----------+--------------------+----------------------------------+
| 1          | 598      | 1         | 0xF8F780C47A8D1D82 | SELECT @@HOSTNAME as hostname    |
| 1          | 0        | 1         | 0x226CD90D52A2BA0B | select @@version_comment limit ? |
+------------+----------+-----------+--------------------+----------------------------------+
2 rows in set (0.01 sec)

Con la consulta previa se seleccionan datos de la tabla stats_mysql_query_digest, que contiene información sobre todas las consultas ejecutadas en ProxySQL. A continuación, se muestran cinco columnas seleccionadas:

• count_star: número de veces que se ejecutó esta consulta.
• sum_time: tiempo total en milisegundos que tardó esta consulta en ejecutarse.
• hotsgroup: hostgroup usado para ejecutar la consulta.
• digest: resumen de la consulta ejecutada.
• digest_text: la consulta real. En este ejemplo del tutorial, la segunda consulta se parametriza usando signos ? en lugar de parámetros variables. select @@version_comment limit 1 y select @@version_comment limit 2, por lo tanto, se agrupan como la misma consulta con el mismo resumen.

Ahora que sabe comprobar los datos de la consulta en la tabla stats_mysql_query_digest, cierre el shell de mysql:

exit;

La base de datos que descargó contiene algunas tablas con datos de demostración. Ahora, probará las consultas en la tabla dept_emp seleccionando cualquier registro cuya from_date sea mayor que 2000-04-20 y registrando el tiempo medio de ejecución.

Utilice este comando para ejecutar la prueba:

mysqlslap -usammy -P6033 -p -h127.0.0.1  --concurrency=100 --iterations=20 --create-schema=employees --query="SELECT * from dept_emp WHERE from_date>'2000-04-20'" --verbose

Aquí usa algunos indicadores nuevos:

• --concurrency=100: esto establece el número de usuarios que se simulará; en este caso, 100.
• --iterations=20: esto hace que la prueba se ejecute 20 veces y calcule los resultados de todas ellas.
• --create-schema=employees: aquí seleccionó la base de datos employees.
• --query="SELECT * from dept_emp WHERE from_date>'2000-04-20'": aquí especificó la consulta ejecutada en la prueba.

La prueba tardará unos minutos. Una vez que esta se realice, obtendrá resultados similares a los siguientes:

Output
Benchmark
        Average number of seconds to run all queries: 18.117 seconds
        Minimum number of seconds to run all queries: 8.726 seconds
        Maximum number of seconds to run all queries: 22.697 seconds
        Number of clients running queries: 100
        Average number of queries per client: 1

Sus números podrían ser un poco diferentes. Mantenga estos números en algún lugar para compararlos con los resultados obtenidos tras habilitar el almacenamiento en caché.

Una vez que pruebe ProxySQL sin almacenamiento en caché, será el momento de ejecutar la misma prueba de nuevo, pero esta vez con el almacenamiento en caché habilitado.

Paso 4: Probar mysqlslap con almacenamiento en caché

En este paso, el almacenamiento en caché nos ayudará a disminuir la latencia al ejecutar consultas similares. Aquí identificará las consultas ejecutadas, obtendrá sus resúmenes desde la tabla stats:mysql_query_digest de ProxySQL y los usará para habilitar el almacenamiento en caché. A continuación, hará otra prueba para comprobar la diferencia.

Para habilitar el almacenamiento en caché, deberá conocer los resúmenes de las consultas que se almacenarán en caché. Inicie sesión en la interfaz de administración de ProxySQL usando este comando:

mysql -uadmin -p -h127.0.0.1 -P6032

A continuación, ejecute esta consulta de nuevo para obtener una lista de las consultas ejecutadas y sus resúmenes:

SELECT count_star,sum_time,hostgroup,digest,digest_text FROM stats_mysql_query_digest ORDER BY sum_time DESC;

Verá un resultado similar a este:

Output
+------------+-------------+-----------+--------------------+------------------------------------------+
| count_star | sum_time    | hostgroup | digest             | digest_text                              |
+------------+-------------+-----------+--------------------+------------------------------------------+
| 2000       | 33727110501 | 1         | 0xC5DDECD7E966A6C4 | SELECT * from dept_emp WHERE from_date>? |
| 1          | 601         | 1         | 0xF8F780C47A8D1D82 | SELECT @@HOSTNAME as hostname            |
| 1          | 0           | 1         | 0x226CD90D52A2BA0B | select @@version_comment limit ?         |
+------------+-------------+-----------+--------------------+------------------------------------------+
3 rows in set (0.00 sec)

Observe la primera fila. Se relaciona con una consulta que se ejecutó 2000 veces. Esta es la consulta que se ejecutó previamente y a la que se hizo referencia. Tome su resumen y guárdelo para usarlo a la hora de añadir una regla de consulta para el almacenamiento en caché.

Con las siguientes consultas se añadirá una nueva regla de consulta a ProxySQL que coincidirá con el resumen de la consulta anterior y pondrá un valor cache_ttl para ella. cache_ttl es el número de milisegundos durante los cuales el resultado está almacenado en la memoria caché:

INSERT INTO mysql_query_rules(active, digest, cache_ttl, apply) VALUES(1,'0xC5DDECD7E966A6C4',2000,1);

En este comando, añade un nuevo registro a la tabla mysql_query_rules; esta tabla contiene todas las reglas aplicadas antes de ejecutar una consulta. En este ejemplo, agrega un valor para la columna cache_ttl que hará que la consulta conciliada debido al resumen dado se almacene en caché durante un número de milisegundos especificado en esta columna. Usted dispone 1 en la columna apply para garantizar que la regla se aplique a las consultas.

Aplique LOAD y SAVE a estos cambios, y luego cierre el shell de mysql:

LOAD MYSQL QUERY RULES TO RUNTIME;
SAVE MYSQL QUERY RULES TO DISK;
exit;

Ahora que el almacenamiento en caché está habilitado, vuelva a ejecutar la prueba de nuevo para comprobar el resultado:

mysqlslap -usammy -P6033 -p -h127.0.0.1  --concurrency=100 --iterations=20 --create-schema=employees --query="SELECT * from dept_emp WHERE from_date>'2000-04-20'" --verbose

Con esto, se mostrará un resultado similar al siguiente:

Output
Benchmark
        Average number of seconds to run all queries: 7.020 seconds
        Minimum number of seconds to run all queries: 0.274 seconds
        Maximum number of seconds to run all queries: 23.014 seconds
        Number of clients running queries: 100
        Average number of queries per client: 1

Aquí puede ver la gran diferencia en el tiempo de ejecución promedio: se redujo de 18.117 a 7.020 segundos.

Conclusión

A través de este artículo, configuró un almacenamiento en caché transparente con ProxySQL para almacenar en caché resultados de consultas a la base de datos. También probó la velocidad de las consultas con y sin almacenamiento en caché para ver la diferencia que este puede suponer.

Durante este tutorial, usó un nivel de almacenamiento en caché. También podría probar el almacenamiento en caché web, que se dispone delante de un servidor web, almacena las respuestas a solicitudes similares y envía la respuesta de vuelta al cliente sin llegar a los servidores de backend. Esto es muy similar al almacenamiento en caché de ProxySQL, pero a un nivel diferente. Para obtener más información sobre el almacenamiento en caché, consulte nuestro artículo introductorio Principios básicos del almacenamiento en caché web: terminología, encabezados HTTP y estrategias de almacenamiento en caché.

El servidor MySQL también tiene su propia memoria caché de consultas; puede obtener más información sobre ella en el tutorial Cómo optimizar MySQL con memoria caché de consultas en Ubuntu 18.04.