Cómo analizar estadísticas de bases de datos Redis administradas utilizando Elastic Stack en Ubuntu 18.04

Tutoriales

El autor seleccionó el Fondo de Software Libre y de Código Abierto para recibir una donación como parte del programa Escribir para Donaciones.

Introducción

El monitoreo de bases de datos es el proceso continuo de rastrear sistemáticamente varias métricas que muestran cómo está funcionando la base de datos. Al observar los datos de rendimiento, puede obtener ideas valiosas e identificar posibles cuellos de botella, así como encontrar formas adicionales de mejorar el rendimiento de la base de datos. Dichos sistemas a menudo implementan alertas que notifican a los administradores cuando las cosas van mal. Las estadísticas recopiladas se pueden utilizar no solo para mejorar la configuración y el flujo de trabajo de la base de datos, sino también los de las aplicaciones cliente.

El beneficio de usar el Stack Elastic (ELK stack) para monitorear tu base de datos gestionada es su excelente soporte para búsqueda y la capacidad de ingerir datos nuevos muy rápidamente. No sobresale en la actualización de datos, pero este compromiso es aceptable para propósitos de monitoreo y registro, donde los datos pasados casi nunca se modifican. Elasticsearch ofrece un poderoso medio para consultar los datos, que puedes utilizar a través de Kibana para obtener una mejor comprensión de cómo se desempeña la base de datos en diferentes periodos de tiempo. Esto te permitirá correlacionar la carga de la base de datos con eventos reales para obtener información sobre cómo se está utilizando la base de datos.

En este tutorial, importarás métricas de la base de datos, generadas por el comando INFO de Redis, en Elasticsearch a través de Logstash. Esto implica configurar Logstash para ejecutar periódicamente el comando, analizar su salida y enviarla a Elasticsearch para indexarla inmediatamente después. Los datos importados pueden ser analizados y visualizados más tarde en Kibana. Al final del tutorial, tendrás un sistema automatizado que recopila estadísticas de Redis para su posterior análisis.

Requisitos previos

Un servidor Ubuntu 18.04 con al menos 8 GB de RAM, privilegios de root y una cuenta secundaria no root. Puede configurar esto siguiendo esta guía de configuración inicial del servidor. Para este tutorial, el usuario no root es sammy.
Java 8 instalado en su servidor. Para instrucciones de instalación, visite Cómo instalar Java con apt en Ubuntu 18.04 y siga los comandos descritos en el primer paso. No es necesario instalar el Java Development Kit (JDK).
Nginx instalado en su servidor. Para obtener una guía sobre cómo hacerlo, consulte el tutorial Cómo instalar Nginx en Ubuntu 18.04.
Elasticsearch y Kibana instalados en su servidor. Complete los dos primeros pasos del tutorial Cómo instalar Elasticsearch, Logstash y Kibana (Elastic Stack) en Ubuntu 18.04.
A Redis managed database provisioned from DigitalOcean with connection information available. Make sure that your server’s IP address is on the whitelist. For a guide on creating a Redis database using the DigitalOcean Control Panel, visit the Redis Quickstart guide.
Redli instalado en su servidor de acuerdo con el tutorial Cómo conectarse a una base de datos gestionada en Ubuntu 18.04.

Paso 1 — Instalación y Configuración de Logstash

En esta sección, instalarás Logstash y lo configurarás para extraer estadísticas de tu clúster de bases de datos Redis, luego las analizarás para enviarlas a Elasticsearch para su indexación.

Comienza instalando Logstash con el siguiente comando:

sudo apt install logstash -y

Una vez que Logstash esté instalado, habilita el servicio para que se inicie automáticamente al arrancar:

sudo systemctl enable logstash

Antes de configurar Logstash para extraer las estadísticas, veamos cómo es la propia información. Para conectarte a tu base de datos Redis, dirígete al Panel de Control de tu Base de Datos Administrada y, en el panel de Detalles de Conexión, selecciona Flags del menú desplegable:

Se te mostrará un comando preconfigurado para el cliente Redli, que usarás para conectarte a tu base de datos. Haz clic en Copiar y ejecuta el siguiente comando en tu servidor, reemplazando comando_bandera_redli con el comando que acabas de copiar:

redli_flags_command info

Dado que la salida de este comando es larga, explicaremos esto desglosado en sus diferentes secciones.

En la salida del comando info de Redis, las secciones están marcadas con #, lo que significa un comentario. Los valores se completan en forma de clave:valor, lo que los hace relativamente fáciles de analizar.

La sección Server contiene información técnica sobre la construcción de Redis, como su versión y el commit de Git en el que se basa, mientras que la sección Clients proporciona el número de conexiones actualmente abiertas.

Output# Server
redis_version:6.2.6
redis_git_sha1:4f4e829a
redis_git_dirty:1
redis_build_id:5861572cb79aebf3
redis_mode:standalone
os:Linux 5.11.12-300.fc34.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
atomicvar_api:atomic-builtin
gcc_version:11.2.1
process_id:79
process_supervised:systemd
run_id:b8a0aa25d8f49a879112a04a817ac2acd92e0c75
tcp_port:25060
server_time_usec:1640878632737564
uptime_in_seconds:1679
uptime_in_days:0
hz:10
configured_hz:10
lru_clock:13488680
executable:/usr/bin/redis-server
config_file:/etc/redis.conf
io_threads_active:0

# Clients
connected_clients:4
cluster_connections:0
maxclients:10032
client_recent_max_input_buffer:24
client_recent_max_output_buffer:0
...

Memory confirma cuánta RAM ha asignado Redis para sí mismo, así como la cantidad máxima de memoria que puede utilizar. Si comienza a quedarse sin memoria, liberará claves utilizando la estrategia que especificaste en el Panel de Control (mostrada en el campo maxmemory_policy en esta salida).

Output...
# Memory
used_memory:977696
used_memory_human:954.78K
used_memory_rss:9977856
used_memory_rss_human:9.52M
used_memory_peak:977696
used_memory_peak_human:954.78K
used_memory_peak_perc:100.00%
used_memory_overhead:871632
used_memory_startup:810128
used_memory_dataset:106064
used_memory_dataset_perc:63.30%
allocator_allocated:947216
allocator_active:1273856
allocator_resident:3510272
total_system_memory:1017667584
total_system_memory_human:970.52M
used_memory_lua:37888
used_memory_lua_human:37.00K
used_memory_scripts:0
used_memory_scripts_human:0B
number_of_cached_scripts:0
maxmemory:455081984
maxmemory_human:434.00M
maxmemory_policy:noeviction
allocator_frag_ratio:1.34
allocator_frag_bytes:326640
allocator_rss_ratio:2.76
allocator_rss_bytes:2236416
rss_overhead_ratio:2.84
rss_overhead_bytes:6467584
mem_fragmentation_ratio:11.43
mem_fragmentation_bytes:9104832
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_clients_slaves:0
mem_clients_normal:61504
mem_aof_buffer:0
mem_allocator:jemalloc-5.1.0
active_defrag_running:0
lazyfree_pending_objects:0
...

En la sección Persistence, puedes ver la última vez que Redis guardó las claves que almacena en disco, y si fue exitoso. La sección Stats proporciona números relacionados con las conexiones de clientes y en clúster, el número de veces que se encontró (o no) la clave solicitada, y así sucesivamente.

Output...
# Persistence
loading:0
current_cow_size:0
current_cow_size_age:0
current_fork_perc:0.00
current_save_keys_processed:0
current_save_keys_total:0
rdb_changes_since_last_save:0
rdb_bgsave_in_progress:0
rdb_last_save_time:1640876954
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:1
rdb_current_bgsave_time_sec:-1
rdb_last_cow_size:217088
aof_enabled:0
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_last_write_status:ok
aof_last_cow_size:0
module_fork_in_progress:0
module_fork_last_cow_size:0

# Stats
total_connections_received:202
total_commands_processed:2290
instantaneous_ops_per_sec:0
total_net_input_bytes:38034
total_net_output_bytes:1103968
instantaneous_input_kbps:0.01
instantaneous_output_kbps:0.00
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:0
expired_stale_perc:0.00
expired_time_cap_reached_count:0
expire_cycle_cpu_milliseconds:29
evicted_keys:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:452
total_forks:1
migrate_cached_sockets:0
slave_expires_tracked_keys:0
active_defrag_hits:0
active_defrag_misses:0
active_defrag_key_hits:0
active_defrag_key_misses:0
tracking_total_keys:0
tracking_total_items:0
tracking_total_prefixes:0
unexpected_error_replies:0
total_error_replies:0
dump_payload_sanitizations:0
total_reads_processed:2489
total_writes_processed:2290
io_threaded_reads_processed:0
io_threaded_writes_processed:0
...

Al observar el role bajo Replication, sabrás si estás conectado a un nodo primario o réplica. El resto de la sección proporciona el número de réplicas actualmente conectadas y la cantidad de datos que le falta a la réplica en relación con el primario. Puede haber campos adicionales si la instancia a la que estás conectado es una réplica.

Nota: El proyecto Redis utiliza los términos “master” y “slave” en su documentación y en varios comandos. DigitalOcean generalmente prefiere los términos alternativos “primary” y “replica”. Esta guía utilizará por defecto los términos “primary” y “replica” siempre que sea posible, pero ten en cuenta que hay algunas instancias en las que inevitablemente se mencionan los términos “master” y “slave”.

Output...
# Replication
role:master
connected_slaves:0
master_failover_state:no-failover
master_replid:f727fad3691f2a8d8e593b087c468bbb83703af3
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:45088768
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
...

Bajo CPU, verá la cantidad de potencia de CPU del sistema (used_cpu_sys) y del usuario (used_cpu_user) que Redis está consumiendo en este momento. La sección Cluster contiene solo un campo único, cluster_enabled, que sirve para indicar que el clúster de Redis está en funcionamiento.

Output...
# CPU
used_cpu_sys:1.617986
used_cpu_user:1.248422
used_cpu_sys_children:0.000000
used_cpu_user_children:0.001459
used_cpu_sys_main_thread:1.567638
used_cpu_user_main_thread:1.218768

# Modules

# Errorstats

# Cluster
cluster_enabled:0

# Keyspace

Se asignará a Logstash la tarea de ejecutar periódicamente el comando info en su base de datos Redis (similar a cómo lo acaba de hacer), analizar los resultados y enviarlos a Elasticsearch. Luego podrá acceder a ellos más tarde desde Kibana.

Almacenará la configuración para indexar estadísticas de Redis en Elasticsearch en un archivo llamado redis.conf en el directorio /etc/logstash/conf.d, donde Logstash guarda los archivos de configuración. Cuando se inicie como servicio, se ejecutarán automáticamente en segundo plano.

Cree redis.conf usando su editor favorito (por ejemplo, nano):

sudo nano /etc/logstash/conf.d/redis.conf

Agregue las siguientes líneas:

/etc/logstash/conf.d/redis.conf

input {
	exec {
		command => "redis_flags_command info"
		interval => 10
		type => "redis_info"
	}
}

filter {
	kv {
		value_split => ":"
		field_split => "\r\n"
		remove_field => [ "command", "message" ]
	}

	ruby {
		code =>
		"
		event.to_hash.keys.each { |k|
			if event.get(k).to_i.to_s == event.get(k) # is integer?
				event.set(k, event.get(k).to_i) # convert to integer
			end
			if event.get(k).to_f.to_s == event.get(k) # is float?
				event.set(k, event.get(k).to_f) # convert to float
			end
		}
		puts 'Ruby filter finished'
		"
	}
}

output {
    elasticsearch {
        hosts => "http://localhost:9200"
        index => "%{type}"
    }
}

Recuerde reemplazar redis_flags_command con el comando mostrado en el panel de control que utilizó anteriormente en el paso.

Define un input, que es un conjunto de filtros que se ejecutarán en los datos recopilados, y una salida que enviará los datos filtrados a Elasticsearch. La entrada consta del comando exec, que ejecutará un command en el servidor periódicamente, después de un tiempo establecido interval (expresado en segundos). También especifica un parámetro type que define el tipo de documento cuando se indexa en Elasticsearch. El bloque exec pasa un objeto que contiene dos campos, command y una cadena message. El campo command contendrá el comando que se ejecutó y el message contendrá su salida.

Hay dos filtros que se ejecutarán secuencialmente en los datos recopilados de la entrada. El filtro kv significa filtro de clave-valor y está integrado en Logstash. Se utiliza para analizar datos en la forma general de clavevalor_separadorvalor y proporciona parámetros para especificar qué se consideran separadores de valor y campo. El separador de campo se refiere a cadenas que separan los datos formateados en la forma general entre sí. En el caso de la salida del comando Redis INFO, el separador de campo (field_split) es una nueva línea y el separador de valor (value_split) es :. Las líneas que no siguen la forma definida se descartarán, incluidos los comentarios.

Para configurar el filtro kv, pasa : al parámetro value_split, y \r\n (indicando un salto de línea) al parámetro field_split. También ordenas que se eliminen los campos command y message del objeto de datos actual pasándolos a remove_field como elementos de un array, porque contienen datos que ahora son inútiles.

El filtro kv representa el valor que analizó como un tipo de cadena (texto) por diseño. Esto plantea un problema porque Kibana no puede procesar fácilmente los tipos de cadena, incluso si en realidad es un número. Para resolver esto, usarás código Ruby personalizado para convertir las cadenas que contienen solo números en números, cuando sea posible. El segundo filtro es un bloque ruby que proporciona un parámetro code que acepta una cadena que contiene el código que se ejecutará.

event es una variable que Logstash proporciona a tu código, y contiene los datos actuales en la canalización de filtros. Como se señaló anteriormente, los filtros se ejecutan uno después del otro, lo que significa que el filtro Ruby recibirá los datos analizados del filtro kv. El código Ruby en sí convierte el event a un Hash y recorre las claves, luego verifica si el valor asociado con la clave podría representarse como un entero o como un flotante (un número con decimales). Si puede, el valor de cadena se reemplaza con el número analizado. Cuando termina el bucle, imprime un mensaje (El filtro Ruby ha terminado) para informar sobre el progreso.

La salida envía los datos procesados a Elasticsearch para su indexación. El documento resultante se almacenará en el índice redis_info, definido en la entrada y pasado como parámetro al bloque de salida.

Guarda y cierra el archivo.

Has instalado Logstash usando apt y lo has configurado para solicitar periódicamente estadísticas de Redis, procesarlas y enviarlas a tu instancia de Elasticsearch.

Paso 2 — Prueba de la Configuración de Logstash

Ahora probarás la configuración ejecutando Logstash para verificar que extraerá los datos correctamente.

Logstash admite ejecutar una configuración específica pasando su ruta de archivo al parámetro -f. Ejecuta el siguiente comando para probar tu nueva configuración del último paso:

sudo /usr/share/logstash/bin/logstash -f /etc/logstash/conf.d/redis.conf

Puede tomar algún tiempo mostrar la salida, pero pronto verás algo similar a lo siguiente:

OutputUsing bundled JDK: /usr/share/logstash/jdk
OpenJDK 64-Bit Server VM warning: Option UseConcMarkSweepGC was deprecated in version 9.0 and will likely be removed in a future release.
WARNING: Could not find logstash.yml which is typically located in $LS_HOME/config or /etc/logstash. You can specify the path using --path.settings. Continuing using the defaults
Could not find log4j2 configuration at path /usr/share/logstash/config/log4j2.properties. Using default config which logs errors to the console
[INFO ] 2021-12-30 15:42:08.887 [main] runner - Starting Logstash {"logstash.version"=>"7.16.2", "jruby.version"=>"jruby 9.2.20.1 (2.5.8) 2021-11-30 2a2962fbd1 OpenJDK 64-Bit Server VM 11.0.13+8 on 11.0.13+8 +indy +jit [linux-x86_64]"}
[INFO ] 2021-12-30 15:42:08.932 [main] settings - Creating directory {:setting=>"path.queue", :path=>"/usr/share/logstash/data/queue"}
[INFO ] 2021-12-30 15:42:08.939 [main] settings - Creating directory {:setting=>"path.dead_letter_queue", :path=>"/usr/share/logstash/data/dead_letter_queue"}
[WARN ] 2021-12-30 15:42:09.406 [LogStash::Runner] multilocal - Ignoring the 'pipelines.yml' file because modules or command line options are specified
[INFO ] 2021-12-30 15:42:09.449 [LogStash::Runner] agent - No persistent UUID file found. Generating new UUID {:uuid=>"acc4c891-936b-4271-95de-7d41f4a41166", :path=>"/usr/share/logstash/data/uuid"}
[INFO ] 2021-12-30 15:42:10.985 [Api Webserver] agent - Successfully started Logstash API endpoint {:port=>9600, :ssl_enabled=>false}
[INFO ] 2021-12-30 15:42:11.601 [Converge PipelineAction::Create<main>] Reflections - Reflections took 77 ms to scan 1 urls, producing 119 keys and 417 values
[WARN ] 2021-12-30 15:42:12.215 [Converge PipelineAction::Create<main>] plain - Relying on default value of `pipeline.ecs_compatibility`, which may change in a future major release of Logstash. To avoid unexpected changes when upgrading Logstash, please explicitly declare your desired ECS Compatibility mode.
[WARN ] 2021-12-30 15:42:12.366 [Converge PipelineAction::Create<main>] plain - Relying on default value of `pipeline.ecs_compatibility`, which may change in a future major release of Logstash. To avoid unexpected changes when upgrading Logstash, please explicitly declare your desired ECS Compatibility mode.
[WARN ] 2021-12-30 15:42:12.431 [Converge PipelineAction::Create<main>] elasticsearch - Relying on default value of `pipeline.ecs_compatibility`, which may change in a future major release of Logstash. To avoid unexpected changes when upgrading Logstash, please explicitly declare your desired ECS Compatibility mode.
[INFO ] 2021-12-30 15:42:12.494 [[main]-pipeline-manager] elasticsearch - New Elasticsearch output {:class=>"LogStash::Outputs::ElasticSearch", :hosts=>["http://localhost:9200"]}
[INFO ] 2021-12-30 15:42:12.755 [[main]-pipeline-manager] elasticsearch - Elasticsearch pool URLs updated {:changes=>{:removed=>[], :added=>[http://localhost:9200/]}}
[WARN ] 2021-12-30 15:42:12.955 [[main]-pipeline-manager] elasticsearch - Restored connection to ES instance {:url=>"http://localhost:9200/"}
[INFO ] 2021-12-30 15:42:12.967 [[main]-pipeline-manager] elasticsearch - Elasticsearch version determined (7.16.2) {:es_version=>7}
[WARN ] 2021-12-30 15:42:12.968 [[main]-pipeline-manager] elasticsearch - Detected a 6.x and above cluster: the `type` event field won't be used to determine the document _type {:es_version=>7}
[WARN ] 2021-12-30 15:42:13.065 [[main]-pipeline-manager] kv - Relying on default value of `pipeline.ecs_compatibility`, which may change in a future major release of Logstash. To avoid unexpected changes when upgrading Logstash, please explicitly declare your desired ECS Compatibility mode.
[INFO ] 2021-12-30 15:42:13.090 [Ruby-0-Thread-10: :1] elasticsearch - Using a default mapping template {:es_version=>7, :ecs_compatibility=>:disabled}
[INFO ] 2021-12-30 15:42:13.147 [Ruby-0-Thread-10: :1] elasticsearch - Installing Elasticsearch template {:name=>"logstash"}
[INFO ] 2021-12-30 15:42:13.192 [[main]-pipeline-manager] javapipeline - Starting pipeline {:pipeline_id=>"main", "pipeline.workers"=>2, "pipeline.batch.size"=>125, "pipeline.batch.delay"=>50, "pipeline.max_inflight"=>250, "pipeline.sources"=>["/etc/logstash/conf.d/redis.conf"], :thread=>"#<Thread:0x5104e975 run>"}
[INFO ] 2021-12-30 15:42:13.973 [[main]-pipeline-manager] javapipeline - Pipeline Java execution initialization time {"seconds"=>0.78}
[INFO ] 2021-12-30 15:42:13.983 [[main]-pipeline-manager] exec - Registering Exec Input {:type=>"redis_info", :command=>"redli --tls -h db-redis-fra1-68603-do-user-1446234-0.b.db.ondigitalocean.com -a hnpJxAgoH3Om3UwM -p 25061 info", :interval=>10, :schedule=>nil}
[INFO ] 2021-12-30 15:42:13.994 [[main]-pipeline-manager] javapipeline - Pipeline started {"pipeline.id"=>"main"}
[INFO ] 2021-12-30 15:42:14.034 [Agent thread] agent - Pipelines running {:count=>1, :running_pipelines=>[:main], :non_running_pipelines=>[]}
Ruby filter finished
Ruby filter finished
Ruby filter finished
...

Verás el mensaje Ruby filter finished impreso a intervalos regulares (establecidos en 10 segundos en el paso anterior), lo que significa que las estadísticas se están enviando a Elasticsearch.

Puedes salir de Logstash haciendo clic en CTRL + C en tu teclado. Como se mencionó anteriormente, Logstash ejecutará automáticamente todos los archivos de configuración encontrados bajo /etc/logstash/conf.d en segundo plano cuando se inicie como un servicio. Ejecuta el siguiente comando para iniciarlo:

sudo systemctl start logstash

Has ejecutado Logstash para comprobar si puede conectarse a tu clúster de Redis y recopilar datos. A continuación, explorarás algunos de los datos estadísticos en Kibana.

Paso 3 — Explorando Datos Importados en Kibana

En esta sección, explorarás y visualizarás los datos estadísticos que describen el rendimiento de tu base de datos en Kibana.

En tu navegador web, dirígete a tu dominio donde expusiste Kibana como parte de los requisitos previos. Verás la página de bienvenida predeterminada:

Antes de explorar los datos que Logstash está enviando a Elasticsearch, primero necesitarás agregar el índice redis_info a Kibana. Para hacerlo, primero selecciona Explorar por mi cuenta desde la página de bienvenida y luego abre el menú hamburguesa en la esquina superior izquierda. Bajo Análisis, haz clic en Descubrir.

Kibana te pedirá entonces que crees un nuevo patrón de índice:

Pulsa en Crear patrón de índice. Verás un formulario para crear un nuevo Patrón de Índice. Los Patrones de Índice en Kibana proporcionan una manera de extraer datos de múltiples índices de Elasticsearch a la vez, y pueden ser usados para explorar solo un índice.

A la derecha, Kibana lista todos los índices disponibles, como redis_info que has configurado para que Logstash utilice. Escribe en el campo de texto Nombre y selecciona @timestamp del menú desplegable como el Campo de tiempo. Cuando hayas terminado, presiona el botón Crear patrón de índice debajo.

Para crear y ver visualizaciones existentes, abre el menú de hamburguesa. Bajo Análisis, selecciona Panel de control. Cuando cargue, presiona Crear visualización para empezar a crear una nueva:

El panel del lado izquierdo proporciona una lista de valores que Kibana puede usar para dibujar la visualización, que se mostrará en la parte central de la pantalla. En la parte superior derecha de la pantalla está el selector de rango de fechas. Si el campo @timestamp se está utilizando en la visualización, Kibana solo mostrará los datos pertenecientes al intervalo de tiempo especificado en el selector de rango.

Desde el menú desplegable en la parte principal de la página, selecciona Línea bajo la sección Línea y área. Luego, encuentra el campo used_memory en la lista del lado izquierdo y arrástralo a la parte central. Pronto verás una visualización de línea de la cantidad mediana de memoria utilizada a lo largo del tiempo:

En el lado derecho, puedes configurar cómo se procesan los ejes horizontal y vertical. Allí, puedes establecer el eje vertical para mostrar los valores promedio en lugar de la mediana presionando sobre el eje mostrado:

Puedes seleccionar una función diferente o proporcionar la tuya propia:

El gráfico se actualizará inmediatamente con los valores actualizados.

En este paso, has visualizado el uso de memoria de tu base de datos Redis administrada utilizando Kibana. Esto te permitirá obtener una mejor comprensión de cómo se está utilizando tu base de datos, lo que te ayudará a optimizar las aplicaciones de cliente, así como la base de datos misma.

Conclusión

Ahora tienes instalado el stack de Elastic en tu servidor y configurado para extraer datos estadísticos de tu base de datos Redis administrada de manera regular. Puedes analizar y visualizar los datos usando Kibana u otro software adecuado, lo que te ayudará a obtener valiosos conocimientos y correlaciones del mundo real sobre cómo está funcionando tu base de datos.

Para obtener más información sobre lo que puedes hacer con tu Base de Datos Administrada Redis, visita la documentación del producto. Si deseas presentar las estadísticas de la base de datos utilizando otro tipo de visualización, consulta la documentación de Kibana para obtener más instrucciones.

Source:
https://www.digitalocean.com/community/tutorials/how-to-analyze-managed-redis-database-statistics-using-the-elastic-stack-on-ubuntu-18-04