Darle un poco de color a la consola de MySQL

En el post anterior explicamos como paginar la salida de datos, usando ese mismo truco con un comando de linux llamado grcat, podemos darle color al texto; números, direcciones IP, fechas, etc… así deja de ser aburrida la consola de MySQL.

Ejecutamos el siguiente comando para instalar la nueva tool:

apt-get install grc

Ahora nos bajamos el fichero de configuración del grcat, aquí es donde están definidas las reglas de colores:

wget https://raw.githubusercontent.com/nicola51980/myterm/master/bash/dotfiles/grcat -O ~/.grcat

Nos queda un último paso, y es editar este fichero para decirle al pager que use el grcat:

vim .my.cnf

Así debería quedar el fichero:

[mysql]
auto-rehash
user = root
pager = grcat ~/.grcat | less -RSFXin
prompt = "\[email protected]\h:\d> "
default-character-set = utf8

Una ves que hayas configurado el fichero de .my.cnf accede a MySQL y ejecuta varios comandos para que notes la diferencia, tienes que ver algo como en la siguiente imagen:

MySQL Colors

MySQL y HAProxy es una Arquitectura de Balanceo de Carga & Failover

La Base de Datos es un servicio muy importante que debe estar operativo el 99.99%, hay muchas arquitecturas para lograr esto, todo depende de las necesidades, hoy les explico la más básica usando un Master y dos Slaves con AWS y HAProxy.

Los Slaves se usan para las lecturas, todo el tráfico que es de disposición NO inmediata (<1s) debe ser accedido desde los Slaves, la idea es hacer un balanceo de carga, le quitamos peso al Master y se lo delegamos a los Slaves.

Como podemos imaginar, usar Slaves no son muy seguros, de vez en cuando se rompe por una serie de motivos, o necesitamos hacer mantenimiento y no debemos detener el servicio, entonces creamos una arquitectura tolerante a fallos como se muestra en la siguiente imagen:

MySQL Arquitectura Failover

Podemos observar que todo lo que está susceptible a fallos está duplicado. Hago una breve descripción de cada elemento que interviene en el diagrama:

  • APPS: Las aplicaciones con una configuración especial saben dirigir el tráfico de lectura o de escritura.
  • Master: Usamos un RDS Multi A-Z, esto permite una redundancia de servidores en multiples zonas, y entra en acción una zona u otra si una de ellas falla. Si no usamos RDS recomiendo tener una configuración Multi Master, hay una solución muy buena llamada Percona.
  • DNS: Cada servidor se le crea un CNAME, pero uno de ellos, está definido con dos IP’s, que es para los HAProxy, así tenemos redundancia, Route 53 de AWS permite hacer esto (Como los de Amazon nos quitan trabajo).
  • Slave: Las instancias de MySQL, no requiere ninguna configuración especial.
  • HAProxy: Éste servicio debe usar la versión 1.5 que tiene soporte para MySQL. Depende como lo configuremos, pero balancea las conexiones en Round Robin por ejemplo, también podemos definir el número máximo de conexiones, como una conexión de backup que valla contra el Master en caso de que todos los Slaves fallen.

Cronología de un desastre:

Vamos a ver en orden que pasa si algo falla y como se resuelve:

  • Si el DNS detecta que uno de los HAProxy falla, el DNS le pasa la conexión a otro HAProxy.
  • Si el HAProxy detecta que un slave no responde, le pasa la conexión a otro Slave.
  • Si todos los Slaves no responden, el HAProxy redirige la conexión al Master.

Para que todos los pasos anteriores sean transparentes para la aplicación, está debe tener una tolerancia a fallos de conexiones. Lo que quiero decir, es: que si una conexión es interrumpida, la vuelve a reanudar sin mostrar mensajes de error.

Es muy importante tener algún sistema de monitoring de cada cosa que está involucrado en el diagrama, sino no podemos entrar en acción rápido para prevenir algún desastre. También debe tener bien calculado y configurado el número de conexiones soportadas por cada instancia de MySQL.

Trabajando con largas listas de procesos en MySQL

Los fans de la terminal nos encontramos frecuentemente con algunas limitaciones por el tamaño del monitor y todo el contenido, en este caso hablo de listar y filtrar entre muchos rows en MySQL sin la opción WHERE como; “SHOW PROCESSLIST;” y “SHOW TABLES;”. Generalmente necesitamos buscar algo en largas listas para; matar procesos, verificar conexiones, consultas, etc… y como podemos hacer para mostrar los que nos interesa? En el post anterior hable de como usar el parámetro pager, y resulta que éste nos puede ayudar en más cosas.

Lo podemos cambiar estando dentro de la consola de MySQL, por ejemplo; Necesito listar todas las conexiones que sean distintas al estado Sleep:

mysql> \P grep -v Sleep
PAGER set to 'grep -v Sleep'
mysql> SHOW PROCESSLIST;
+--------+---------+-----------+------+---------+-------+-------+------------------+ 
| Id     | User    | Host      | db   | Command | Time  | State | Info             | 
+--------+---------+-----------+------+---------+-------+-------+------------------+ 
| 109530 | root    | localhost | NULL | Query   |     0 | NULL  | show processlist | 

Listo, así de simple o lo hacemos más complejo? ahora necesito saber cuales son las conexiones dormidas, y lo ordenamos de forma descendente, nos quedaría así:

mysql> \P grep Sleep | sort -t \| -k 7 -n -r
PAGER set to 'grep Sleep | sort -t \| -k 7 -n -r'
mysql> SHOW PROCESSLIST;
| 7550471 | app | 10.65.54.110:53481   | demo  | Sleep | 9559 |      | NULL |
| 7550429 | app | 10.65.54.110:53479   | demo  | Sleep | 8877 |      | NULL |
| 7560240 | app | 10.33.181.84:57960   | demo  | Sleep | 2029 |      | NULL |
| 7560214 | app | 10.33.181.84:57955   | demo  | Sleep | 1058 |      | NULL |
| 7560993 | app | 10.33.181.84:58083   | demo  | Sleep |  616 |      | NULL |
| 7548835 | app | 10.36.142.140:39371  | demo  | Sleep |  225 |      | NULL |
| 7548697 | app | 10.36.142.140:39350  | demo  | Sleep |  211 |      | NULL |
| 7555321 | app | 10.65.19.225:45810   | demo  | Sleep |  208 |      | NULL |
| 7562608 | app | 10.65.19.225:47517   | demo  | Sleep |  109 |      | NULL |
| 5517613 | app | localhost:25380      | mysql | Sleep |    7 |      | NULL |
| 7562775 | app | 10.250.249.182:42425 | demo  | Sleep |    5 |      | NULL |
| 7562774 | app | 10.250.249.182:42424 | demo  | Sleep |    5 |      | NULL |
| 7562679 | app | 10.250.249.182:42370 | demo  | Sleep |    1 |      | NULL |

El ejemplo habla por si solo, y como podemos observar, simplemente estamos usando los comandos básicos de Linux, no hay mayor cosa. Un ejemplo más, si queremos listar cuales tablas quedan de respaldo cuando se hace un alter table con las Percona Toolkit:

mysql> \P egrep "_*_(new|old)";
PAGER set to 'egrep "_*_(new|old)";'
mysql> SHOW TABLES;
| _users_old                         |
| _acl_new                           |

Si queremos quitar el filtro y ponerlo como antes, tenemos dos formas;

  • La primera:
mysql> \P
Default pager wasn't set, using stdout.
  • La segunda:
mysql> NOPAGER;
PAGER set to stdout

Listo, ya somos un poco más hábiles con el comando mysql.

Paginar en la consola de MySQL

Yo uso mucho la consola de MySQL, la verdad que es muy útil, pero muchas veces ejecutamos una Query que nos arroja un gran número de rows y columns que no caben en nuestra pantalla, y terminamos recurriendo a usar el scroll de la terminal para explorar los datos, ahora podemos implementar la paginación en la consola de una forma muy fácil.

Solo debemos editar o modificar un fichero de configuración, el que usa MySQL Command Line, manos a la obra:

vim ~/.my.cnf

Agregamos estas líneas al final:

pager = less -RSFXin

Debe quedar así:

[mysql]
user = root
pager = less -RSFXin

Podemos observar que hay un parámetro de configuración llamado pager que se encarga de pasar por STDOUT los datos a otro programa de la terminal de Linux para que haga su magia, en este caso usamos el comando less para paginar el resultado que es retornado por STDIN.