Cómo configurar Redis como caché para MySQL con PHP en Ubuntu 20.04

La autora seleccionó a Girls Who Code para recibir una donación como parte del programa Write for DOnations .

Introducción

Redis ( Remote Dictionary Server ) es una base de datos rápida, de código abierto y en memoria que se puede utilizar como almacén de clave-valor para un sistema altamente escalable y orientado al rendimiento. Algunos de los casos de uso de Redis incluyen: almacenamiento en caché, transacciones de alta velocidad, análisis en tiempo real, notificaciones en vivo, aprendizaje automático, búsqueda y procesamiento de colas/trabajos. Dado que Redis es un almacén de clave-valor en memoria, su rendimiento lo hace adecuado para almacenar en caché datos en su aplicación.

El almacenamiento en caché consiste en almacenar datos temporalmente en una capa de almacenamiento de alta velocidad (por ejemplo, en la memoria RAM de una computadora) para ofrecer los datos más rápido cuando los clientes realicen las mismas solicitudes en el futuro. Esto mejora la reutilización de los datos calculados previamente en lugar de recuperarlos cada vez del disco.

Cuando trabaja con PHP y MySQL , el uso de Redis como caché mejora el rendimiento de su aplicación porque Redis almacena datos en RAM, que es varias veces más rápida que un disco duro (HDD) o una unidad de estado sólido (SSD). El almacenamiento en caché también reduce los costos de la base de datos (es decir, la cantidad de viajes de ida y vuelta que se realizan a la base de datos del back-end) y evita la sobrecarga del back-end.

El almacenamiento en caché de datos es una característica de diseño integral cuando se diseñan aplicaciones web con más lecturas que escrituras. Entre estas aplicaciones se incluyen blogs, tiendas en línea y sitios de redes sociales.

En este tutorial, utilizará Redis para almacenar en caché datos MySQL con PHP en Ubuntu 20.04.

Prerrequisitos

Para completar este tutorial, necesitarás lo siguiente:

• Un servidor Ubuntu 20.04 con un usuario no root con privilegios sudo. Configúrelo siguiendo la guía Configuración inicial del servidor con Ubuntu 20.04 .

• Una pila LAMP. Sigue el tutorial Cómo instalar la pila Linux, Apache, MySQL, PHP (LAMP) en Ubuntu 20.04 . Para esta guía, puedes omitir el Paso 4: Crear un host virtual para tu sitio web .

• Un servidor Redis configurado siguiendo el tutorial de inicio rápido Cómo instalar y proteger Redis en Ubuntu 20.04 .

Paso 1: Instalación de la biblioteca Redis para PHP

Para comenzar, deberá instalar la php-redisextensión, que le permitirá usar PHP para comunicarse con Redis. Ejecute los siguientes comandos para actualizar su servidor e instalar la extensión:

sudo apt update
sudo apt install php-redis

Confirme la instalación y reinicie el servidor web Apache para cargar la extensión:

sudo systemctl restart apache2

Ahora que ha instalado sus dependencias, configurará su base de datos.

Paso 2: Configuración de una base de datos de prueba, una tabla y datos de muestra

En este paso, creará una base de datos MySQL para almacenar datos de forma permanente en el disco. También creará algunas tablas y una cuenta de usuario con privilegios completos para la base de datos.

Primero, inicie sesión en su servidor MySQL como usuario root :

sudo mysql -u root -p

Ingrese la contraseña raíz de su servidor MySQL que configuró en el requisito previo de LAMP. Luego, presione ENTERpara continuar.

A continuación, cree una test_storebase de datos con el siguiente comando:

CREATE database test_store;

Asegúrese de que la acción sea exitosa confirmando el resultado:

OutputQuery OK, 1 row affected (0.00 sec)

A continuación, crea un usuario para tu base de datos. En este tutorial, lo llamaremos test_userPASSWORD . Reemplázalo también por una contraseña segura:

CREATE USER 'test_user'@'localhost' IDENTIFIED WITH mysql_native_password BY 'PASSWORD';

Luego, otorgue a test_user privilegios completos sobre la test_storebase de datos con:

GRANT ALL PRIVILEGES ON test_store.* TO 'test_user'@'localhost';

Finalmente, ejecute el siguiente comando para recargar las tablas de concesiones en MySQL:

FLUSH PRIVILEGES;

Asegúrese de obtener el siguiente resultado después de cada comando exitoso:

OutputQuery OK, 0 rows affected (0.01 sec)

Finalizar la sesión raíz de MySQL:

quit;

Recibirás la palabra Byey el sistema te llevará de regreso a la interfaz de línea de comandos del servidor.

Vuelva a iniciar sesión en el servidor MySQL con las credenciales del test_user que acaba de crear:

mysql -u test_user -p

Ingrese la contraseña para test_user para continuar. Luego, cambie a la test_storebase de datos cuando aparezca el mysqlmensaje:

USE test_store;

Asegúrese de recibir el siguiente resultado:

OutputDatabase Changed.

A continuación, creará una productstabla con tres columnas. Utilizará la product_idcolumna para identificar de forma única cada producto. Para evitar asignar los identificadores manualmente, utilizará la AUTO_INCREMENTpalabra clave. Luego, utilizará el BIGINTtipo de datos para la product_idcolumna para admitir un conjunto de datos grande. El BIGINTtipo de datos puede contener un valor mínimo de -2^63 y un valor máximo de 2^63 – 1.

El product_namecampo contendrá los nombres reales de los artículos. En este caso, un VARCHARtipo de datos con una longitud de 50caracteres será suficiente. La última columna de la productstabla es la que priceutilizará para incluir precios con decimales (por ejemplo, 16,33).DOUBLE

Para crear la productstabla, ejecute el siguiente comando:

CREATE table products
(
product_id BIGINT PRIMARY KEY AUTO_INCREMENT,
product_name VARCHAR(50),
price DOUBLE
) Engine = InnoDB;

Recibirá el siguiente resultado:

OutputQuery OK, 0 rows affected (0.01 sec)

Ahora rellenarás la productstabla con algunos registros para fines de prueba.

No es necesario que introduzcas los datos en la product_idcolumna de forma manual, ya que la AUTO_INCREMENTcolumna se encargará de ello. Ejecuta los siguientes comandos uno por uno:

INSERT INTO products(product_name, price) VALUES ('Virtual Private Servers', '5.00');
INSERT INTO products(product_name, price) VALUES ('Managed Databases', '15.00');
INSERT INTO products(product_name, price) VALUES ('Block Storage', '10.00');
INSERT INTO products(product_name, price) VALUES ('Managed Kubernetes', '60.00');
INSERT INTO products(product_name, price) VALUES ('Load Balancer', '10.00');

Después de ejecutar cada comando, asegúrese de obtener este resultado:

OutputQuery OK, 1 row affected (0.00 sec)

Verifique los datos usando el SELECTcomando:

SELECT * FROM products;

Recibirá un resultado similar al siguiente:

Output+------------+-------------------------+-------+| product_id | product_name            | price |+------------+-------------------------+-------+|          1 | Virtual Private Servers |     5 ||          2 | Managed Databases       |    15 ||          3 | Block Storage           |    10 ||          4 | Managed Kubernetes      |    60 ||          5 | Load Balancer           |    10 |+------------+-------------------------+-------+5 rows in set (0.00 sec)

Finalizar la sesión MySQL para test_user :

quit;

Una vez que haya configurado la test_storebase de datos, productsla tabla y test_user , codificará un script PHP para recuperar datos de la base de datos MySQL y almacenarlos en caché en Redis.

Paso 3: Diseño de un script PHP para obtener y almacenar en caché datos MySQL

En este paso, creará un script PHP para recuperar los datos de muestra que ha creado en el paso anterior.

Cuando ejecute el script por primera vez, leerá los datos de MySQL (es decir, del disco) y luego los almacenará en caché en Redis. Como resultado, las lecturas posteriores de los datos de los productos se realizarán desde Redis (es decir, desde la RAM del sistema). La memoria del sistema es varias veces más rápida que incluso la unidad de estado sólido más rápida, por lo que los datos se recuperarán más rápido de la memoria caché de Redis que al leerlos desde el disco del sistema.

Nota: si bien es posible que no obtenga ningún aumento en el rendimiento, dado que está recuperando solo unos pocos registros de la base de datos MySQL, varios puntos de referencia demuestran que recuperar datos en caché de Redis es varias veces más rápido que leerlos de MySQL cuando se trata de varios cientos de miles de registros.

Crea un products.phparchivo en el directorio raíz de tu sitio web:

sudo nano /var/www/html/products.php

Para comenzar, ingrese la siguiente información para conectarse y crear una instancia de Redis y almacenarla como un objeto en una $redisvariable.

La dirección 127.0.0.1se conecta a localhost. Puede cambiar este valor si está ejecutando Redis desde un servidor remoto. Recuerde reemplazarlo REDIS_PASSWORDcon la contraseña específica para Redis establecida en el /etc/redis/redis.confarchivo de configuración.

Además, ingrese el número de puerto correspondiente. De manera predeterminada, Redis se ejecuta en el puerto 6379:

/var/www/html/productos.php

?php$redis = new Redis();$redis-connect('127.0.0.1', 6379);$redis-auth('REDIS_PASSWORD');

Nota: En esta guía, el comando envía su contraseña a Redis en texto sin formato. En un entorno de producción, puede considerar proteger la comunicación de extremo a extremo entre Redis y el servidor cliente que ejecuta el código PHP con una capa de control de acceso más potente, como TLS (Transport Layer Security) . Además, al configurar su contraseña de Redis en el archivo, asegúrese de establecer un valor largo y seguro para evitar ataques de fuerza bruta.$redis-auth('REDIS_PASSWORD')/etc/redis/redis.conf

El siguiente paso es inicializar una variable PHP que usarás como clave en Redis.

Como se mencionó anteriormente en esta guía, Redis actúa como una base de datos clave-valor y, por lo tanto, debe tener una clave única para los datos que desea almacenar y recuperar de ella.

Por lo tanto, defina una PRODUCTSclave agregando la siguiente información al /var/www/html/products.phparchivo. Puede utilizar cualquier nombre en lugar de PRODUCTSla clave.

Su script PHP utilizará esta clave para almacenar en caché la información en Redis una vez que se recuperen los datos de la base de datos MySQL:

/var/www/html/productos.php

...$key = 'PRODUCTS';

A continuación, incluya una declaración PHP condicional if...elsepara comprobar si la PRODUCTSclave existe en Redis:

/var/www/html/productos.php

...if (!$redis-get($key)) {    $source = 'MySQL Server';    $database_name     = 'test_store';    $database_user     = 'test_user';    $database_password = 'PASSWORD';    $mysql_host        = 'localhost';    $pdo = new PDO('mysql:host=' . $mysql_host . '; dbname=' . $database_name, $database_user, $database_password);    $pdo-setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);    $sql  = "SELECT * FROM products";    $stmt = $pdo-prepare($sql);    $stmt-execute();    while ($row = $stmt-fetch(PDO::FETCH_ASSOC)) {       $products[] = $row;    }    $redis-set($key, serialize($products));    $redis-expire($key, 10);} else {     $source = 'Redis Server';     $products = unserialize($redis-get($key));}echo $source . ': br';print_r($products);

Si la clave no existe en Redis, el script se conecta a la base de datos que creó anteriormente, consulta la productstabla y almacena los datos en Redis usando el $redis-set($key, serialize($products))comando.

El $redis-expire($key, 10);comando establece la caducidad en 10segundos. Puede modificar este valor según su política de caché.

La $sourcevariable le ayuda a identificar la fuente de los datos una vez que se reflejan como una matriz al final del script utilizando los comandos echo $sourcey print_r($products).

Una vez que hayas puesto todo junto, tu /var/www/html/products.phparchivo quedará así:

/var/www/html/productos.php

?php$redis = new Redis();$redis-connect('127.0.0.1', 6379);$redis-auth('REDIS_PASSWORD');$key = 'PRODUCTS';if (!$redis-get($key)) {    $source = 'MySQL Server';    $database_name     = 'test_store';    $database_user     = 'test_user';    $database_password = 'PASSWORD';    $mysql_host        = 'localhost';    $pdo = new PDO('mysql:host=' . $mysql_host . '; dbname=' . $database_name, $database_user, $database_password);    $pdo-setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);    $sql  = "SELECT * FROM products";    $stmt = $pdo-prepare($sql);    $stmt-execute();    while ($row = $stmt-fetch(PDO::FETCH_ASSOC)) {       $products[] = $row;    }    $redis-set($key, serialize($products));    $redis-expire($key, 10);} else {     $source = 'Redis Server';     $products = unserialize($redis-get($key));}echo $source . ': br';print_r($products);

Guarde y cierre el archivo.

Ya ha configurado un script PHP que se conectará a MySQL y almacenará en caché los datos en Redis. Probará el script en el siguiente paso.

Paso 4: Probar el script PHP

Para comprobar si Redis almacena en caché los datos de la base de datos MySQL, deberá ingresar la ruta del script PHP en una ventana del navegador. Recuerde reemplazarla your_server_IPcon la dirección IP pública de su servidor, de la siguiente manera: .http://your_server_IP/products.php

Cuando ejecute el script por primera vez, recibirá el siguiente resultado que muestra datos de la base de datos MySQL porque, en este punto, el script PHP aún no ha almacenado en caché ningún dato en Redis:

MySQL ServerArray ( [0] = Array ( [product_id] = 1 [product_name] = Virtual Private Servers [price] = 5 ) [1] = Array ( [product_id] = 2 [product_name] = Managed Databases [price] = 15 ) [2] = Array ( [product_id] = 3 [product_name] = Block Storage [price] = 10 ) [3] = Array ( [product_id] = 4 [product_name] = Managed Kubernetes [price] = 60 ) [4] = Array ( [product_id] = 5 [product_name] = Load Balancer [price] = 10 ) )

Una vez que ejecute el script nuevamente, obtendrá una salida que confirma que está leyendo datos de Redis, que actúa como caché para MySQL.

Redis ServerArray ( [0] = Array ( [product_id] = 1 [product_name] = Virtual Private Servers [price] = 5 ) [1] = Array ( [product_id] = 2 [product_name] = Managed Databases [price] = 15 ) [2] = Array ( [product_id] = 3 [product_name] = Block Storage [price] = 10 ) [3] = Array ( [product_id] = 4 [product_name] = Managed Kubernetes [price] = 60 ) [4] = Array ( [product_id] = 5 [product_name] = Load Balancer [price] = 10 ) )

Recuerde que la clave caducará después de 10 segundos y los datos se recuperarán nuevamente de MySQL.

Conclusión

En esta guía, ha utilizado Redis para almacenar en caché datos MySQL con PHP en Ubuntu 20.04. Puede utilizar el código de esta guía para configurar un mecanismo de almacenamiento en caché para sus datos MySQL, lo que resulta especialmente útil para aplicaciones web con mucho tráfico.

Puede consultar nuestra página de temas de Redis para obtener más recursos educativos. O bien, puede aprender más sobre codificación en PHP con más tutoriales y contenido en la página de temas de PHP .