Monitoreo · 13 min read · Oct 27, 2025
Cómo instalar y configurar el sistema de monitoreo Graphite en Ubuntu 22.04
Graphite es una herramienta de código abierto utilizada para rastrear y graficar el rendimiento de los sistemas informáticos. Puedes usarla para rastrear el rendimiento de sitios web, aplicaciones, servicios empresariales y servidores en red. Es altamente flexible y se puede configurar para que puedas obtener los beneficios tanto de una representación detallada como de una visión general amplia del rendimiento y la salud de las métricas que estás rastreando.
Graphite está compuesto por varios componentes: la aplicación web, un backend de almacenamiento llamado Carbon, y la biblioteca de base de datos llamada whisper. En este tutorial, aprenderás a instalar y configurar Graphite en un servidor Ubuntu 22.04.
Requisitos previos
- Un servidor que ejecute Ubuntu 22.04.
- Un nombre de dominio completamente calificado (FQDN) apuntando al servidor. Para nuestro tutorial, usaremos el dominio
graphite.example.com. - Un usuario no root con privilegios sudo.
- El Firewall sin complicaciones (UFW) está habilitado y en funcionamiento.
- Asegúrate de que todo esté actualizado.
$ sudo apt update && sudo apt upgrade - Instala paquetes de utilidad básicos. Algunos de ellos pueden ya estar instalados.
$ sudo apt install wget curl nano unzip -y
Paso 1 - Configurar el Firewall
Antes de instalar cualquier paquete, el primer paso es configurar el firewall para permitir conexiones HTTP y HTTPS.
Verifica el estado del firewall.
$ sudo ufw status
Deberías ver algo como lo siguiente.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Permite los puertos HTTP y HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Verifica el estado nuevamente para confirmar.
$ sudo ufw status
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443 ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
80/tcp (v6) ALLOW Anywhere (v6)
443 (v6) ALLOW Anywhere (v6)
Paso 2 - Instalar Paquetes Requeridos
Instalaremos Graphite usando el gestor de paquetes PIP de Python. El primer paso es instalar los paquetes requeridos para la instalación.
$ sudo apt install vim python3-dev python3-pip libcairo2-dev libffi-dev build-essential
Paso 3 - Instalar Graphite y Graphite Web
Instalaremos Graphite en el directorio /opt/graphite.
$ export PYTHONPATH="/opt/graphite/lib/:/opt/graphite/webapp/"
$ sudo pip install --no-binary=:all: https://github.com/graphite-project/whisper/tarball/master
$ sudo pip install --no-binary=:all: https://github.com/graphite-project/carbon/tarball/master
$ sudo pip install --no-binary=:all: https://github.com/graphite-project/graphite-web/tarball/master
Paso 4 - Instalar y Configurar PostgreSQL
Usaremos el repositorio APT oficial de PostgreSQL para instalar. Ejecuta el siguiente comando para agregar la clave GPG de PostgreSQL.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Agrega el repositorio APT a tu lista de fuentes.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/postgresql-key.gpg arch=amd64] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
Actualiza el repositorio del sistema.
$ sudo apt update
Ahora, puedes instalar PostgreSQL y paquetes auxiliares usando el siguiente comando.
$ sudo apt install postgresql postgresql-contrib libpq-dev
Verifica el estado del servicio de PostgreSQL.
$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; vendor preset: enabled)
Active: active (exited) since Tue 2022-09-27 10:09:35 UTC; 4s ago
Process: 4456 ExecStart=/bin/true (code=exited, status=0/SUCCESS)
Main PID: 4456 (code=exited, status=0/SUCCESS)
CPU: 1ms
Sep 27 10:09:35 matrix systemd[1]: Starting PostgreSQL RDBMS...
Sep 27 10:09:35 matrix systemd[1]: Finished PostgreSQL RDBMS.
Puedes ver que el servicio está habilitado y en funcionamiento por defecto.
Inicia sesión en la consola de PostgreSQL.
$ sudo -su postgres psql
Crea un usuario de base de datos para Graphite.
postgres=# CREATE USER graphite WITH PASSWORD 'your_password';
Crea una base de datos para Graphite y otorga la propiedad al usuario graphite.
postgres=# CREATE DATABASE graphitedb WITH OWNER graphite;
Sal de la consola de PostgreSQL.
postgres=# \q
Paso 5 - Configurar Graphite Carbon y Web
El siguiente paso es configurar Graphite Carbon y Graphite web.
Configurar Carbon
Carbon se compone de tres servicios:
- carbon-cache: acepta métricas y las escribe en el disco.
- carbon-relay: replica los datos.
- carbon-aggregator: se ejecuta frente al servicio carbon-cache para almacenar métricas a lo largo del tiempo antes de reenviarlas a Whisper.
Configurar carbon-cache es necesario, pero carbon-relay y carbon-aggregator son opcionales.
Crea el archivo carbon.conf usando el archivo de ejemplo proporcionado.
$ sudo cp /opt/graphite/conf/carbon.conf.example /opt/graphite/conf/carbon.conf
A continuación, crea la configuración de esquemas de almacenamiento.
$ sudo cp /opt/graphite/conf/storage-schemas.conf.example /opt/graphite/conf/storage-schemas.conf
Abre el archivo de configuración del esquema de almacenamiento.
$ sudo nano /opt/graphite/conf/storage-schemas.conf
Dentro, encontrarás entradas como
[carbon]
pattern = ^carbon\.
retentions = 60:90d
Esto implica que un patrón que coincida con una expresión regular ^carbon\. debe retener los datos con una política de retención de 60:90d, lo que significa
- con qué frecuencia se registra una métrica: 60 segundos
- duración del tiempo para almacenar esos valores: 90 días
Puedes agregar tu propia entrada. Tomemos un ejemplo test, es decir, puntos de datos de monitoreo y nuestras entradas de puntos de datos comenzarán con la cadena test. Esta entrada debe agregarse antes de la entrada predeterminada mencionada al final del archivo.
[test]
pattern = ^test\.
retentions = 10s:10m,1m:1h
Esto coincidirá con cualquier métrica que comience con test. Almacenará los datos que recopila dos veces, con diferentes niveles de detalle. La primera definición (1s:10m) creará un punto de datos cada diez segundos. Solo almacenará los datos durante diez minutos. La segunda definición creará un punto de datos cada minuto. Recopilará todos los datos del último minuto (seis puntos, ya que la definición anterior crea un punto cada diez segundos) y los agregará para crear el punto. Almacena los datos a este nivel de detalle durante una hora.
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Inicia el servicio carbon-cache.
$ sudo /opt/graphite/bin/carbon-cache.py start
Configurar la Web de Graphite
El siguiente paso es configurar la aplicación web de Graphite.
Genera una clave secreta para la aplicación Graphite. Copia la clave mostrada para su uso posterior.
$ python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'
sp%71)6b$%^bc(7xpz1d!)x3(azog01&k^8l02*!y0#)72p07y
Crea el archivo de configuración de la aplicación web.
$ sudo cp /opt/graphite/webapp/graphite/local_settings.py.example /opt/graphite/webapp/graphite/local_settings.py
Necesitas configurar la aplicación web de Graphite con la configuración de la base de datos. Abre el local_settings.py para editar.
$ sudo nano /opt/graphite/webapp/graphite/local_settings.py
Descomenta la variable SECRET_KEY e ingresa un valor aleatorio para ella.
SECRET_KEY = 'your-secret-key'
Descomenta la variable ALLOWED_HOSTS.
ALLOWED_HOSTS = [ '*' ]
Descomenta la variable TIME_ZONE y configúralo al valor apropiado.
TIME_ZONE = 'Asia/Kolkata'
Descomenta la variable USE_REMOTE_USER_AUTHENTICATION y configúralo en TRUE para que el usuario remoto se autentique antes de realizar cualquier cambio en la base de datos.
USE_REMOTE_USER_AUTHENTICATION = True
Cambia la configuración de la base de datos.
DATABASES = {
'default': {
'NAME': 'graphitedb',
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'USER': 'graphite',
'PASSWORD': 'your_password',
'HOST': '127.0.0.1',
'PORT': ''
}
}
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Instala algunos requisitos previos para el envoltorio de PostgreSQL de Python.
$ sudo pip install psycopg2-binary
Ejecuta el siguiente comando para importar el esquema de la base de datos.
$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py migrate --settings=graphite.settings
Obtendrás la siguiente salida.
Operations to perform:
Apply all migrations: account, admin, auth, contenttypes, dashboard, events, sessions, tagging, tags, url_shortener
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying account.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying admin.0003_logentry_add_action_flag_choices... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_email_max_length... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying auth.0009_alter_user_last_name_max_length... OK
Applying auth.0010_alter_group_name_max_length... OK
Applying auth.0011_update_proxy_permissions... OK
Applying auth.0012_alter_user_first_name_max_length... OK
Applying dashboard.0001_initial... OK
Applying events.0001_initial... OK
Applying sessions.0001_initial... OK
Applying tagging.0001_initial... OK
Applying tagging.0002_on_delete... OK
Applying tags.0001_initial... OK
Applying url_shortener.0001_initial... OK
A continuación, recopila los archivos estáticos.
$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py collectstatic --settings=graphite.settings
Establece los permisos de propiedad correctos.
$ sudo chown -R www-data:www-data /opt/graphite/storage/
$ sudo chown -R www-data:www-data /opt/graphite/static/
$ sudo chown -R www-data:www-data /opt/graphite/webapp/
Crea un usuario root para iniciar sesión.
$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py createsuperuser --settings=graphite.settings
Username (leave blank to use 'root'): navjot
Email address: [email protected]
Password:
Password (again):
Superuser created successfully.
Se te pedirá que crees un superusuario. Este usuario se usará más tarde para conectarse a la aplicación Graphite.
Paso 6 - Configurar Apache
Graphite se envía con archivos de configuración de Apache por defecto. Instala el servidor Apache.
$ sudo apt install apache2 libapache2-mod-wsgi-py3
Crea el archivo mod_wsgi.
$ sudo cp /opt/graphite/conf/graphite.wsgi.example /opt/graphite/conf/graphite.wsgi
Copia el archivo de configuración de ejemplo de graphite a la ubicación de Apache.
$ sudo cp /opt/graphite/examples/example-graphite-vhost.conf /etc/apache2/sites-available/graphite.conf
Abre el archivo de configuración de Graphite para editar.
$ sudo nano /etc/apache2/sites-available/graphite.conf
Cambia el número de puerto en la primera línea de 80 a 127.0.0.1:8080. Poner 127.0.0.1 delante de esto restringe el acceso a través de la web.
Agrega tu nombre de dominio.
ServerName graphite.example.com #Reemplaza con tu dominio
Agrega las siguientes líneas debajo de la línea Alias /static/ /opt/graphite/static/.
#Agrega las líneas a continuación
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Desactiva el host virtual predeterminado y habilita el archivo de host virtual de Graphite.
$ sudo a2dissite 000-default
$ sudo a2ensite graphite
También necesitaremos decirle a Apache que escuche en el puerto 8080 y deje de escuchar en el puerto 80 porque usaremos Nginx como servidor proxy.
Abre el archivo /etc/apache2/ports.conf para editar.
$ sudo nano /etc/apache2/ports.conf
Encuentra la línea Listen 80 y reemplázala con lo siguiente.
Listen 127.0.0.1:8080
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Reinicia el servidor Apache.
$ sudo systemctl restart apache2
Para verificar que Graphite esté funcionando correctamente y sea accesible, ejecuta el siguiente comando.
$ curl 127.0.0.1:8080
Obtendrás la siguiente salida.
Graphite Browser
Esto confirma que está funcionando bien.
Paso 7 - Instalar Nginx
Usaremos Nginx como servidor proxy para Apache. De esta manera, obtenemos los beneficios de seguridad y oscuridad mientras usamos la configuración existente proporcionada por Graphite.
Ubuntu 22.04 se envía con una versión más antigua de Nginx. Para instalar la última versión, necesitas descargar el repositorio oficial de Nginx.
Importa la clave de firma de Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Agrega el repositorio para la versión estable de Nginx.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Actualiza los repositorios del sistema.
$ sudo apt update
Instala Nginx.
$ sudo apt install nginx
Verifica la instalación.
$ nginx -v
nginx version: nginx/1.22.0
Inicia el servidor Nginx.
$ sudo systemctl start nginx
Paso 8 - Instalar SSL
Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot usando el repositorio de Ubuntu o obtener la última versión usando la herramienta Snapd. Usaremos la versión Snapd.
Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd esté actualizada.
$ sudo snap install core
$ sudo snap refresh core
Instala Certbot.
$ sudo snap install --classic certbot
Usa el siguiente comando para asegurarte de que el comando Certbot pueda ejecutarse creando un enlace simbólico al directorio /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Ejecuta el siguiente comando para generar un certificado SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d graphite.example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/graphite.example.com en tu servidor.
Genera un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Verifica el servicio programador de renovación de Certbot.
$ sudo systemctl list-timers
Encontrarás snap.certbot.renew.service como uno de los servicios programados para ejecutarse.
NEXT LEFT LAST PASSED UNIT ACTIVATES
.................................................................................................................................
Wed 2022-09-28 00:00:00 UTC 7h left Tue 2022-09-27 00:00:01 UTC 16h ago logrotate.timer logrotate.service
Wed 2022-09-28 02:39:09 UTC 10h left Tue 2022-09-27 09:42:42 UTC 6h ago apt-daily.timer apt-daily.service
Wed 2022-09-28 06:02:00 UTC 13h left n/a n/a snap.certbot.renew.timer snap.certbot.renew.service
Para comprobar si la renovación de SSL está funcionando bien, haz una prueba en seco del proceso.
$ sudo certbot renew --dry-run
Si no ves errores, estás listo. Tu certificado se renovará automáticamente.
Paso 9 - Configurar Nginx
Abre el archivo /etc/nginx/nginx.conf para editar.
$ sudo nano /etc/nginx/nginx.conf
Agrega la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Crea y abre el archivo /etc/nginx/conf.d/uvdesk.conf para editar.
$ sudo nano /etc/nginx/conf.d/graphite.conf
Pega el siguiente código en él.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name graphite.example.com;
access_log /var/log/nginx/graphite.access.log;
error_log /var/log/nginx/graphite.error.log;
# SSL
ssl_certificate /etc/letsencrypt/live/graphite.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/graphite.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/graphite.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 8.8.8.8;
location / {
proxy_set_header Connection "upgrade";
proxy_set_header Upgrade $http_upgrade;
proxy_http_version 1.1;
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-NginX-Proxy true;
proxy_pass http://127.0.0.1:8080;
proxy_redirect off;
}
}
# forzar HTTPS
server {
listen 80;
listen [::]:80;
server_name graphite.example.com;
return 301 https://$host$request_uri;
}
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida una vez que hayas terminado.
Verifica la sintaxis del archivo de configuración de Nginx.
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
Reinicia el servicio Nginx.
$ sudo systemctl restart nginx
Paso 10 - Acceder y Usar Graphite
Visita la URL https://graphite.example.com en tu navegador y obtendrás la siguiente pantalla.
Haz clic en el enlace Iniciar sesión en la parte superior derecha para abrir la página de inicio de sesión. Ingresa tus credenciales de superusuario creadas en el paso 5 y presiona el botón iniciar sesión para continuar.
Hay varios métodos para alimentar datos a Graphite. Agregamos un coincididor de patrones en el esquema de almacenamiento, según el cual cualquier patrón que comience con test, se registrará como nuestro patrón. Agreguemos algunos datos aleatorios usando el siguiente comando.
$ echo "test.count 9 `date +%s`" | nc -q0 127.0.0.1 2003;
Esto agregará una métrica de datos de valor 9 al sistema. Agreguemos algunos datos más haciendo un bucle a través de los valores.
$ for i in 4 6 8 16 2; do echo "test.count $i `date +%s`" | nc -q0 127.0.0.1 2003; sleep 6; done
Regresa al panel de Graphite y abre Métricas >> test >> count desde la barra lateral izquierda. Deberías ver algo como lo siguiente.
Ahora puedes comenzar a usarlo para monitorear. También puedes combinarlo con Grafana para obtener un alto nivel de personalización.
Conclusión
Esto concluye nuestro tutorial sobre la instalación y configuración de Graphite en un servidor Ubuntu 22.04 junto con Nginx como servidor proxy. Si tienes alguna pregunta, publícalas en los comentarios a continuación.
Recibe nuevas publicaciones en tu bandeja de entrada.
No spam. Cancela la suscripción en cualquier momento.