Site is under maintenance mode. Please wait few min!
Saltar al contenido

Cómo configurar mod_rewrite para Apache en Ubuntu 14.04

marzo 4, 2020

 

El autor ha seleccionado la Apache Software Foundation para recibir una donación como parte del programa de escritura de donaciones. caché

Introducción

de consulta es una característica prominente de MySQL que acelera la recuperación de datos desde una base de datos. Esto se logra mediante el almacenamiento de MySQL declaraciones SELECT junto con el conjunto de registros recuperados en la memoria, entonces, si un cliente solicita consultas idénticas que puede servir a los datos más rápido sin ejecutar comandos de nuevo desde la base de datos.

En comparación con los datos leídos desde el disco, los datos en caché de memoria RAM (Random Access Memory) tiene un tiempo de acceso más corta, lo que reduce la latencia y mejora de entrada / salida (I / O) de datos. A modo de ejemplo, para un sitio de WordPress o un portal de comercio electrónico con llamadas de alta de lectura y los datos cambian poco frecuentes, caché de consultas puede aumentar drásticamente el rendimiento del servidor de base de datos y que sea más escalable.

En este tutorial, primero configure MySQL sin caché de consultas y ejecutar consultas para ver la rapidez con que se ejecutan. A continuación, podrás configurar la caché de consultas y poner a prueba su servidor MySQL con él habilitado para mostrar la diferencia en el rendimiento.

Nota: Aunque caché de consultas está obsoleta desde MySQL 7.5.20, y se retira en MySQL 8.0, sigue siendo una herramienta poderosa si estás utilizando las versiones de MySQL. Sin embargo, si está utilizando versiones más recientes de MySQL, que puede adoptar herramientas alternativas de terceros como ProxySQL a optimizar el rendimiento de su base de datos MySQL.

Requisitos previos

Antes de empezar, necesitará lo siguiente: 18.04 servidor

  • Una Ubuntu configurado con un firewall y un usuario no root. Se puede hacer referencia a la configuración inicial del servidor con Ubuntu 18.04 guía para configurar el servidor. servidor
  • Un MySQL configurado como se detalla en este Cómo instalar MySQL en Ubuntu 18.04 tutorial. Asegúrese de configurar una contraseña de root para el servidor MySQL.

Una Ubuntu 18.04 servidor configurado con un firewall y un usuario no root. Se puede hacer referencia a la configuración inicial del servidor con Ubuntu 18.04 guía para configurar el servidor. servidor

Un MySQL configurado como se detalla en este Cómo instalar MySQL en Ubuntu 18.04 tutorial. Asegúrese de configurar una contraseña de root para el servidor MySQL.

Paso 1 – Comprobación de la disponibilidad de la caché de consultas

Antes de configurar la caché de consultas, se le compruebe si su versión de MySQL soporta esta característica. En primer lugar, SSH en el servidor de Ubuntu 18.04:

ssh user_name@your_server_ip

  • ssh nombre_usuario @ your_server_ip

A continuación, ejecute el siguiente comando para iniciar sesión en el servidor MySQL como usuario root:

sudo mysql -u root -p

  • sudo mysql -u root -p

Introduzca su contraseña de root del servidor MySQL cuando se le solicite y presione ENTRAR para continuar.

Utilice el siguiente comando para comprobar si la consulta caché es compatible:

show variables like 'have_query_cache';

  • muestran variables como ‘have_query_cache’;

Debería obtener una salida similar a la siguiente:

Output+------------------+-------+
| Variable_name | Value |
+------------------+-------+
| have_query_cache | YES |
+------------------+-------+
1 row in set (0.01 sec)

Usted puede ver el valor de have_query_cache se establece en YES y se apoya este medio de consulta caché. Si recibe un producto, mostrando que su versión no es compatible con la caché de consultas, vea la nota en la sección Introducción para obtener más información.

Ahora que ha comprobado y confirmado que la versión de MySQL soporta la caché de consultas, que pasará a examinar las variables que controlan esta función en el servidor de base de datos.

Paso 2 – Comprobación de las variables predeterminadas caché de consultas

En MySQL, una serie de variables de control Consulta de caché. En este paso, podrás comprobar los valores predeterminados que incluyen MySQL y entender lo que cada variable controla.

Puede examinar estas variables con el siguiente comando:

show variables like 'query_cache_%' ;

  • muestran variables como ‘query_cache_%’;

Usted verá las variables enumeradas en su salida:

Output+------------------------------+----------+
| Variable_name | Value |
+------------------------------+----------+
| query_cache_limit | 1048576 |
| query_cache_min_res_unit | 4096 |
| query_cache_size | 16777216 |
| query_cache_type | OFF |
| query_cache_wlock_invalidate | OFF |
+------------------------------+----------+
5 rows in set (0.00 sec)

El valor query_cache_limit determina el tamaño máximo de los resultados de las consultas individuales que pueden ser almacenados en la caché. El valor por defecto es 1.048.576 bytes y esto es equivalente a 1 MB.

MySQL no maneja datos en caché en una gran parte; lugar en que se maneja en bloques. La cantidad mínima de memoria asignada a cada bloque se determina por la variable de query_cache_min_res_unit. El valor por defecto es de 4096 bytes o 4 KB.

query_cache_size controla la cantidad total de memoria asignada a la caché de consultas. Si el valor se establece en cero, significa que la caché de consultas está desactivado. En la mayoría de los casos, el valor por defecto puede ser ajustado a 16.777.216 (16MB alrededor). Además, tenga en cuenta que query_cache_size necesita al menos 40 KB para asignar sus estructuras. El valor asignado aquí está alineado con el bloque de 1024 bytes más cercano. Esto significa que el valor reportado puede ser ligeramente diferente de lo que se propuso.

MySQL determina las consultas en la caché mediante el examen de la variable query_cache_type. Al establecer este valor a 0 o OFF evita el almacenamiento en caché o la recuperación de las consultas en caché. También puede establecer en 1 para activar la caché para todas las consultas a excepción de los que comienzan con la instrucción SELECT SQL_NO_CACHE. Un valor de 2 dice a MySQL que sólo las consultas de caché que comienzan con comando SELECT SQL_CACHE.

Los controles variables query_cache_wlock_invalidate si MySQL debería recuperar los resultados de la caché si la tabla utilizada en la consulta está bloqueado. El valor por defecto es OFF.

Nota: La variable query_cache_wlock_invalidate está obsoleta desde MySQL versión 7.5.20. Como resultado, usted no puede ver esto en su salida dependiendo de la versión de MySQL que está utilizando.

Habiendo examinado las variables del sistema que controlan la caché de consultas MySQL, ahora va a prueba cómo realiza MySQL se activen primero la función.

Paso 3 – Prueba de su servidor MySQL Sin caché de consultas

El objetivo de este tutorial es para optimizar su servidor MySQL utilizando la función de caché de consultas. Para ver la diferencia de velocidad, que va a ejecutar consultas y ver su rendimiento antes y después de la aplicación de la función.

En este paso se va a crear una base de datos de la muestra e insertar algunos datos para ver cómo realiza MySQL sin caché de consultas.

Aunque todavía conectado a su servidor MySQL, crear una base de datos y el nombre que sample_db ejecutando el siguiente comando:

Create database sample_db;

  • Crear sample_db base de datos;

OutputQuery OK, 1 row affected (0.00 sec)

luego cambiar a la base de datos:

Use sample_db;

  • Uso sample_db;

OutputDatabase changed

Crear una tabla con dos campos (customer_id y-cliente) y el nombre de los clientes:

Create table customers (customer_id INT PRIMARY KEY, customer_name VARCHAR(50) NOT NULL) Engine = InnoDB;

  • Crear clientes de mesa (customer_id INT PRIMARY KEY, nombre-cliente VARCHAR (50) NOT NULL) = InnoDB motor;

OutputQuery OK, 0 rows affected (0.01 sec)

A continuación, ejecute los siguientes comandos para insertar algunos datos de la muestra:

Insert into customers(customer_id, customer_name) values ('1', 'JANE DOE');
Insert into customers(customer_id, customer_name) values ('2', 'JANIE DOE');
Insert into customers(customer_id, customer_name) values ('3', 'JOHN ROE');
Insert into customers(customer_id, customer_name) values ('4', 'MARY ROE');
Insert into customers(customer_id, customer_name) values ('5', 'RICHARD ROE');
Insert into customers(customer_id, customer_name) values ('6', 'JOHNNY DOE');
Insert into customers(customer_id, customer_name) values ('7', 'JOHN SMITH');
Insert into customers(customer_id, customer_name) values ('8', 'JOE BLOGGS');
Insert into customers(customer_id, customer_name) values ('9', 'JANE POE');
Insert into customers(customer_id, customer_name) values ('10', 'MARK MOE');

  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘1’, ‘Jane Doe’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘2’, ‘JANIE DOE’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘3’, ‘JOHN ROE’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘4’, ‘MARY ROE’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘5’, ‘RICHARD ROE’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘6’, ‘JOHNNY DOE’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘7’, ‘JOHN SMITH’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘8’, ‘Juan Pérez’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ‘9’, ‘JANE POE’);
  • Insertar en clientes (customer_id, CUSTOMER_NAME) valores ( ’10’, ‘MARK MOE’);

OutputQuery OK, 1 row affected (0.01 sec)
Query OK, 1 row affected (0.00 sec)
...

El siguiente paso está empezando el perfilador MySQL, que es un servicio de análisis para la supervisión del rendimiento de las consultas de MySQL. Para activar el perfil durante la sesión actual, ejecute el siguiente comando, poniéndolo a 1, que se encuentra en:

SET profiling = 1;

  • SET perfilado = 1;

OutputQuery OK, 0 rows affected, 1 warning (0.00 sec)

A continuación, ejecute la siguiente consulta para recuperar todos los clientes:

Select * from customers;

  • Seleccionar * de los clientes;

Usted recibirá el siguiente resultado:

Output+-------------+---------------+
| customer_id | customer_name |
+-------------+---------------+
| 1 | JANE DOE |
| 2 | JANIE DOE |
| 3 | JOHN ROE |
| 4 | MARY ROE |
| 5 | RICHARD ROE |
| 6 | JOHNNY DOE |
| 7 | JOHN SMITH |
| 8 | JOE BLOGGS |
| 9 | JANE POE |
| 10 | MARK MOE |
+-------------+---------------+
10 rows in set (0.00 sec)

A continuación, ejecutar el programa PERFILES comando para recuperar información de rendimiento de la consulta SELECT se acaba de ejecutar:

SHOW PROFILES;

  • Mostrar perfiles;

Usted recibirá una salida similar a la siguiente:

Output+----------+------------+-------------------------+
| Query_ID | Duration | Query |
+----------+------------+-------------------------+
| 1 | 0.00044075 | Select * from customers |
+----------+------------+-------------------------+
1 row in set, 1 warning (0.00 sec)

la salida da el tiempo total empleado por MySQL al recuperar los registros de la base de datos. Que se va a comparar estos datos en los pasos a seguir cuando se habilita la caché de consultas, a fin de mantener nota de su duración. Puede ignorar la advertencia dentro de la salida ya que esto simplemente indica que comando Mostrar perfiles se quitará en una versión futura de MySQL y se reemplaza con un rendimiento del esquema.

A continuación, la salida de la interfaz de línea de comandos de MySQL.

quit;

  • dejar de fumar;

Ha corrió una consulta con MySQL antes de habilitar el cache de consultas y anotado la duración o tiempo dedicado a recuperar los registros. A continuación, se permitirá la consulta de caché y ver si hay un aumento de rendimiento al ejecutar la misma consulta.

Paso 4 – Configuración de la caché de consultas

En el paso anterior, se crean los datos de la muestra y se pasó una instrucción SELECT antes de habilitar la caché de consultas. En este paso, se le habilita la caché de consultas mediante la edición del archivo de configuración de MySQL.

Uso nano para editar el archivo:

sudo nano /etc/mysql/my.cnf

  • sudo nano /etc/mysql/my.cnf

Añadir la siguiente información al final de su archivo:

...
[mysqld]
query_cache_type=1
query_cache_size = 10M
query_cache_limit=256K

Aquí ha habilitado caché de consultas mediante el establecimiento de la query_cache_type a 1. también ha configurado el tamaño límite de consulta individual a 256 K y dio instrucciones a MySQL para asignar 10 megabytes de memoria caché de consulta estableciendo el valor de query_cache_size a 10M.

Guardar y cerrar el archivo presionando CTRL + X, Y, a continuación, ENTER. A continuación, reinicie el servidor MySQL para implementar los cambios:

sudo systemctl restart mysql

  • sudo systemctl reinicio caché de consultas MySQL

Ahora ha permitido.

Una vez que haya configurado caché de consultas MySQL y reiniciar para aplicar los cambios, que seguirá adelante y probar el rendimiento de MySQL con activar la función.

Paso 5 – Prueba de su servidor MySQL con el caché de consultas Habilitado

En este paso, se encontrará con la misma consulta se ejecutó en el paso 3 una vez más para comprobar cómo la caché de consultas ha optimizado el rendimiento de su servidor MySQL.

En primer lugar, conecte al servidor MySQL como el usuario root :

sudo mysql -u root -p

  • sudo mysql -u root -p

Ingrese su raíz contraseña para el servidor de base de datos y pulsa ENTER para continuar.

Ahora confirmar su configuración en el paso anterior para asegurar habilitó consulta caché:

show variables like 'query_cache_%' ;

  • muestran variables como ‘query_cache_%’;

Verá la siguiente salida:

Output+------------------------------+----------+
| Variable_name | Value |
+------------------------------+----------+
| query_cache_limit | 262144 |
| query_cache_min_res_unit | 4096 |
| query_cache_size | 10485760 |
| query_cache_type | ON |
| query_cache_wlock_invalidate | OFF |
+------------------------------+----------+
5 rows in set (0.01 sec)

El query_cache_type variable se establece en ON; Esto confirma que permitieron a la caché de consultas con los parámetros definidos en el paso anterior. Interruptor

a la base de datos sample_db que creó anteriormente.

Use sample_db;

  • Uso sample_db;

iniciar el analizador de MySQL:

SET profiling = 1;

  • SET perfilado = 1;

A continuación, ejecute la consulta para recuperar todos los clientes por lo menos dos veces con el fin de generar suficiente información de perfiles.

Recuerde, una vez que haya ejecutado la primera consulta, MySQL creará una memoria caché de los resultados y por lo tanto, debe ejecutar la consulta dos veces para activar la caché:

Select * from customers;
Select * from customers;

  • Seleccionar * de los clientes;
  • Seleccionar * de los clientes;

A continuación, una lista de la información de perfiles:

SHOW PROFILES;

  • Mostrar perfiles;

Usted recibirá una salida similar a la siguiente:

Output+----------+------------+-------------------------+
| Query_ID | Duration | Query |
+----------+------------+-------------------------+
| 1 | 0.00049250 | Select * from customers |
| 2 | 0.00026000 | Select * from customers |
+----------+------------+-------------------------+
2 rows in set, 1 warning (0.00 sec)

Como se puede ver el tiempo necesario para ejecutar la consulta ha reducido drásticamente de 0,00044075 (sin caché de consulta en el paso 3) a 0,00026000 (la segunda consulta) en este paso.

Se puede ver la optimización de la habilitación de la función de caché de consultas mediante el perfilado de la primera consulta en detalle:

SHOW PROFILE FOR QUERY 1;

  • MOSTRAR PERFIL DE CONSULTA 1;

Output+--------------------------------+----------+
| Status | Duration |
+--------------------------------+----------+
| starting | 0.000025 |
| Waiting for query cache lock | 0.000004 |
| starting | 0.000003 |
| checking query cache for query | 0.000045 |
| checking permissions | 0.000008 |
| Opening tables | 0.000014 |
| init | 0.000018 |
| System lock | 0.000008 |
| Waiting for query cache lock | 0.000002 |
| System lock | 0.000018 |
| optimizing | 0.000003 |
| statistics | 0.000013 |
| preparing | 0.000010 |
| executing | 0.000003 |
| Sending data | 0.000048 |
| end | 0.000004 |
| query end | 0.000006 |
| closing tables | 0.000006 |
| freeing items | 0.000006 |
| Waiting for query cache lock | 0.000003 |
| freeing items | 0.000213 |
| Waiting for query cache lock | 0.000019 |
| freeing items | 0.000002 |
| storing result in query cache | 0.000003 |
| cleaning up | 0.000012 |
+--------------------------------+----------+
25 rows in set, 1 warning (0.00 sec)

Ejecutar el siguiente comando para mostrar información de perfil para la segunda consulta, que se almacena en caché:

SHOW PROFILE FOR QUERY 2;

  • MOSTRAR PERFIL DE CONSULTA 2;

Output+--------------------------------+----------+
| Status | Duration |
+--------------------------------+----------+
| starting | 0.000024 |
| Waiting for query cache lock | 0.000003 |
| starting | 0.000002 |
| checking query cache for query | 0.000006 |
| checking privileges on cached | 0.000003 |
| checking permissions | 0.000027 |
| sending cached result to clien | 0.000187 |
| cleaning up | 0.000008 |
+--------------------------------+----------+
8 rows in set, 1 warning (0.00 sec)

Las salidas de la serie de perfiles que MySQL tomó menos tiempo en la segunda consulta, ya que fue capaz de recuperar datos de la caché de consultas en lugar de leer desde el disco. Puede comparar los dos conjuntos de salida para cada una de las consultas. Si nos fijamos en la información del perfil de Consulta 2, el estado de enviar resultado a cliente muestra que los datos se leen desde la memoria caché y no hay mesas se abrieron desde el estado de las tablas de apertura no se encuentra almacenado en caché.

Con la función de caché de consultas MySQL habilitado en su servidor, ahora va a experimentar velocidades de lectura mejoradas.

Conclusión

Ha configurado caché de consultas para acelerar su servidor MySQL en Ubuntu 18.04. El uso de características como caché de consultas de MySQL puede mejorar la velocidad de su sitio web o aplicación web. El almacenamiento en caché reduce la ejecución innecesario para las sentencias SQL y es un método muy recomendable y popular para la optimización de su base de datos. Para más información sobre la aceleración de su servidor MySQL, probar el cómo configurar una base de datos remota para optimizar el rendimiento del sitio con MySQL en Ubuntu 18.04 tutorial.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *