Lección 180: Registro y monitorización de microservicios en las primeras etapas del desarrollo

Imagina un zoológico de microservicios con decenas o incluso cientos de servicios independientes. ¿Qué haces si uno de ellos deja de funcionar correctamente de repente? ¿Cómo entender qué se rompió, dónde y por qué? Ahí es donde entra el registro. Los logs son tus huellas en la arena del desierto de microservicios.

El registro en microservicios es especialmente importante porque:

• Cada microservicio tiene su propia base de datos, lógica y configuración.
• Los microservicios se comunican entre sí a través de la red, por eso hace falta rastrear las llamadas y las respuestas.
• Los errores pueden ocurrir en cualquiera de los servicios: necesitas datos para encontrar rápidamente la fuente del problema.

Spring Boot facilita la configuración del registro gracias a la integración con bibliotecas populares como SLF4J y Logback.

Fundamentos del registro con SLF4J y Logback

SLF4J (Simple Logging Facade for Java) es una fachada para diferentes herramientas de logging. Te ayuda a abstraer el código de una implementación concreta (por ejemplo, Logback, Log4j) y permite cambiar fácilmente una librería por otra sin tocar el código de la aplicación.

En Spring Boot Logback se usa "out of the box". No necesitas añadir dependencias adicionales: sólo escribe las configuraciones y usa los loggers correctamente.

Creación de un logger

Imagina que tenemos CustomerService y queremos registrar las acciones en esa clase:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

@Service
public class CustomerService {
    private static final Logger logger = LoggerFactory.getLogger(CustomerService.class);

    public void handleCustomerRequest(String customerId) {
        logger.info("Handling request for customer: {}", customerId);

        try {
            // Lógica de procesamiento
            logger.debug("Processing customer data for ID: {}", customerId);
        } catch (Exception e) {
            logger.error("Error while processing customer data", e);
        }
    }
}

Niveles de registro

Los niveles de logs permiten indicar la importancia de los mensajes:

• TRACE — el registro más detallado. Se usa rara vez.
• DEBUG — para desarrollo, para ver detalles de la ejecución del programa.
• INFO — para información general sobre la ejecución.
• WARN — advertencias sobre posibles problemas.
• ERROR — errores que provocan fallos o un funcionamiento incorrecto.

Configuración del registro mediante application.yml

Puedes configurar el registro directamente en application.yml usando Spring Boot:

logging:
  level:
    root: INFO # Registro general
    com.example: DEBUG # Registro para un paquete específico
  file:
    name: logs/app.log # Salida de logs a archivo
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} - %msg%n" # Plantilla para logs de console

Ahora todos nuestros DEBUG-logs para el paquete com.example se mostrarán en la consola y se guardarán en el archivo logs/app.log.

Orden de sobreescritura de la configuración de logging

1. Configuraciones a nivel de application.yml o application.properties.
2. Configuración mediante un archivo XML logback.xml (si necesitas un formato de logs más complejo).
3. Variables de entorno, si necesitas cambiar temporalmente el nivel de logging en producción.

Monitorización de microservicios

El registro a veces no es suficiente. También deberías vigilar el estado del microservicio, el consumo de recursos y otros parámetros importantes. Para eso Spring Boot ofrece una herramienta potente — Spring Boot Actuator.

¿Qué es Spring Boot Actuator?

Actuator es un conjunto de endpoints incorporados que proporcionan información sobre el estado de la aplicación. Con él puedes:

• Saber el estado de dependencias del servidor (por ejemplo, la base de datos).
• Obtener métricas de rendimiento (tiempos de respuesta, uso de memoria, etc.).
• Comprobar qué endpoints están listos para ser usados.

Incluir Spring Boot Actuator

Añade la dependencia en pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Actuator activa automáticamente varios endpoints. Vamos a configurarlos.

Configuración de Actuator en application.yml

Activemos las métricas básicas:

management:
  endpoints:
    web:
      exposure:
        include: "*" # Permitimos todos los endpoints
  endpoint:
    health:
      show-details: always # Mostrar detalles del estado del servicio
  metrics:
    enabled: true # Activar métricas

Ahora, al arrancar la aplicación, podemos consultar varios endpoints de Actuator (por ejemplo, /actuator/health).

Endpoints de Actuator

Ejemplo: comprobemos el estado del servidor

curl http://localhost:8080/actuator/health

Resultado:

{
  "status": "UP"
}

Aplicación práctica: Configurar registro y monitorización

1. Configurar logs para un microservicio

Imagina que desarrollamos el servicio de gestión de pedidos OrderService. Necesitamos:

1. Añadir logging en los métodos principales (creación de pedido, actualización, eliminación).
2. Guardar los logs en un archivo para poder enviarlos a un sistema centralizado de logging.

Ejemplo de OrderService con logging:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);

    public void createOrder(String orderId) {
        logger.info("Creating order with ID: {}", orderId);
    }

    public void updateOrder(String orderId) {
        logger.debug("Updating order with ID: {}", orderId);
    }

    public void deleteOrder(String orderId) {
        logger.warn("Deleting order with ID: {}", orderId);
    }
}

Configuremos la salida de logs a archivo mediante application.yml:

logging:
  level:
    root: INFO
    com.example.orderservice: DEBUG
  file:
    name: logs/orderservice.log

2. Activar métricas con Actuator

Añadamos información sobre el tiempo de actividad del servicio (uptime) vía Actuator. Compruébalo a través de /actuator/metrics.

Ejemplo de llamada:

curl http://localhost:8080/actuator/metrics/jvm.uptime

Problemas reales y cómo evitarlos

• ¿Demasiado ruido en los logs? Usa niveles de logging (DEBUG solo para desarrollo).
• ¿Los archivos de logs son demasiado grandes? Configura rotación de logs con logback.xml.
• ¿No hay suficientes métricas? Integra Actuator con herramientas como Prometheus y Grafana para monitorización completa.

Para el logging centralizado en proyectos reales a menudo se usa el stack ELK (Elasticsearch, Logstash, Kibana). Spring Boot se integra fácilmente con ese stack.

Práctica para estudiantes

1. Añade logging en todos los servicios principales de tu aplicación:
   • Usa los niveles INFO, DEBUG y ERROR.
   • Guarda los logs en archivo y revisa su contenido.
2. Configura Actuator:
   • Activa /actuator/health.
   • Comprueba la disponibilidad de métricas a través de /actuator/metrics.
3. (Opcional) Integra Actuator con Prometheus y visualiza las métricas en Grafana.