# Configuración de Grafana con Prometheus para proyectos Python usando Docker
En este artículo, cubriremos cómo configurar el monitoreo de servicios para proyectos Python con Prometheus y Grafana utilizando contenedores Docker.
El monitoreo de servicios nos permite analizar eventos específicos en nuestros proyectos, tales como llamadas a bases de datos, interacción con API, seguimiento del rendimiento de recursos, etc. Puedes detectar fácilmente comportamientos inusuales o descubrir pistas útiles detrás de los problemas.
## Escenario de Caso Real
Teníamos un servicio temporal que redirigía las solicitudes entrantes de sitios web específicos hasta que Google dejara de indexar estas páginas web. Utilizando el monitoreo de servicios, podemos ver fácilmente el conteo de redirecciones de forma regular. En un momento determinado en el futuro, el número de redirecciones disminuirá, lo que significa que el tráfico se ha migrado al sitio web objetivo, y ya no necesitaremos que este servicio esté en funcionamiento.
## Configuración de contenedores Docker
Vamos a ejecutar todos nuestros servicios localmente en contenedores Docker. En las grandes empresas, existe un servicio global para Prometheus y Grafana que incluye todos los proyectos de monitoreo de microservicios. Probablemente ni siquiera necesites escribir ningún pipeline de despliegue para las herramientas de monitoreo de servicios.
### Archivo docker-compose.yml
Comencemos creando un archivo `docker-compose.yml` con los servicios necesarios:
El punto más importante de la configuración anterior es montar el archivo `prometheus.yml` desde nuestra máquina local al contenedor Docker. Este archivo incluye la configuración para obtener datos (métricas) de nuestro servicio de aplicación o proyecto Python. Sin el archivo, no podrás ver las métricas personalizadas que incluye tu proyecto.
Por lo tanto, crea un nuevo archivo llamado `prometheus.yml` en el nivel raíz de tu proyecto.
### Archivo prometheus.yml
```yaml
global:
scrape_interval: 15s
scrape_configs:
- job_name: 'app'
static_configs:
- targets: ['app:8080']
```
Ahora, Prometheus obtendrá datos de nuestro proyecto.
Todas las demás configuraciones en el archivo de composición son autoexplicativas y no son muy críticas, como mencionamos para Prometheus.
## Crear un nuevo proyecto Python
Ahora, vamos a crear una aplicación Python muy sencilla que creará una métrica para rastrear el tiempo empleado y las solicitudes realizadas. Crea una nueva carpeta llamada `app` en el nivel raíz del proyecto. También incluye `__init__.py` para marcarla como un paquete Python.
A continuación, crea otro archivo llamado `main.py` que contendrá la lógica principal del programa, como se muestra a continuación:
### Archivo app/main.py
```python
from prometheus_client import start_http_server, Summary, Counter, Gauge, Histogram
import random
import time
# Create metrics to track time spent, requests made, and other events.
time.sleep(random.uniform(0.5, 2.0)) # Random delay between requests
if __name__ == '__main__':
main()
```
Aquí, estamos utilizando un paquete de Python llamado `prometheus_client` para interactuar con Prometheus. Permite fácilmente la creación de diferentes tipos de métricas que nuestro proyecto requiere.
El código anterior se copió de la documentación oficial de `prometheus_client`, que simplemente crea una nueva métrica llamada `request_processing_seconds` que mide el tiempo empleado en esa solicitud en particular. Cubriremos otros tipos de métricas más adelante en este artículo.
Ahora, vamos a crear un `Dockerfile` y un `requirements.txt` para construir nuestro proyecto.
### Archivo Dockerfile
```dockerfile
# Usa la imagen base oficial de Python
FROM python:3.9-slim
# Establece el directorio de trabajo
WORKDIR /app
# Copia los archivos de requerimientos
COPY requirements.txt .
# Instala las dependencias
RUN pip install --no-cache-dir -r requirements.txt
# Copia el código de la aplicación
COPY app/ /app
# Expone el puerto de la aplicación
EXPOSE 8000
# Comando por defecto para ejecutar la aplicación
CMD ["python", "main.py"]
```
### Archivo requirements.txt
```txt
prometheus_client
```
Ahora estamos listos para construir y ejecutar los servicios.
## Ejecución de los servicios
Para ver todo en acción, ejecuta los siguientes comandos:
```bash
docker-compose up -d --build
```
Esto levantará todos los servicios definidos en `docker-compose.yml`, compilando la imagen de la aplicación en el proceso.
## Configuración de Grafana
En esta sección, usaremos Prometheus como fuente de datos para mostrar métricas en gráficos de Grafana.
1. Navega a `http://localhost:3001` para ver la página de inicio de sesión de Grafana y utiliza `admin` tanto para el nombre de usuario como para la contraseña. Luego, requerirá agregar una nueva contraseña, y puedes mantenerla igual ya que estamos probando localmente.
2. Después de iniciar sesión correctamente, deberías ver el panel predeterminado de Grafana. Luego selecciona **Data Sources** en la página.
4. Luego requerirá la URL en la que se está ejecutando el servicio de Prometheus, que será el nombre del servicio de Docker que creamos `http://prometheus:9090`.
¡Genial! Ahora nuestro Grafana está listo para ilustrar las métricas que provienen de Prometheus.
## Creación de un nuevo dashboard en Grafana
1. Navega a `http://localhost:3001/dashboards` para crear un nuevo dashboard y agregar un nuevo panel. Haz clic en **New Dashboard** y luego en **Add New Panel** para la inicialización.
2. A continuación, seleccionamos código dentro del panel de consultas y escribimos `request_processing_seconds`. Podrás ver 3 tipos diferentes de sufijos con los datos de tus métricas personalizadas. Prometheus simplemente aplica diferentes tipos de cálculos a tus datos de manera predeterminada.
3. Selecciona una de las opciones y haz clic en **Run Query** para verla en el gráfico.
Finalmente, podemos ver las métricas de nuestro proyecto ilustradas muy bien por Grafana.
## Otras métricas
Hay muchos tipos de métricas disponibles según lo que requiera el proyecto. Si queremos contar un evento específico, como actualizaciones de registros en la base de datos, podemos usar `Counter()`.
Si tenemos una cola de mensajes como Kafka o RabbitMQ, podemos usar `Gauge()` para ilustrar el número de elementos que esperan en la cola.
Intenta agregar otra métrica en `main.py` como se muestra a continuación y aplica los mismos pasos para conectar Prometheus con Grafana:
### Ejemplo de una nueva métrica con Counter
```python
UPDATE_COUNT = Counter('update_count', 'Number of updates')
# Dentro de tu función de procesamiento
update_increment = random.randint(1, 100)
UPDATE_COUNT.inc(update_increment)
```
No olvides construir nuevamente la imagen de Docker para todos los servicios:
