1- Introducción al Monitoreo

El monitoreo de sistemas es un componente esencial en el ciclo de vida de las plataformas de software durante su operación en producción. Junto con los requisitos, diseño, desarrollo, pruebas, despliegue y operaciones, constituye el ciclo completo de vida del software.

El monitoreo de sistemas abarca múltiples niveles, como el monitoreo de hosts, seguridad, middleware, negocios y contenedores.

Monitoreo de Hosts

El monitoreo de hosts consiste en supervisar los servidores que ejecutan entornos de prueba y producción. Pertenece al nivel de hardware y sistema operativo. El monitoreo de hosts se centra en el rendimiento, disponibilidad y uso de CPU, memoria, disco y red. El monitoreo a nivel de sistema operativo se enfoca en el número de procesos, hilos, archivos abiertos y uso de inodes. Los indicadores de CPU incluyen tiempo de inactividad (idle), carga (load) y saltos (jump). Los indicadores de memoria incluyen tasa de uso y situación del swap. Los indicadores de disco incluyen el uso de cada punto de montaje, como el directorio raíz (/), /app, /data, etc. Los indicadores principales de red incluyen los valores máximos, mínimos y promedio del tráfico saliente.

Monitoreo de Seguridad

El monitoreo de seguridad se centra principalmente en aspectos de seguridad del sistema, como métodos comunes de intrusión como ataques de fuerza bruta con contraseñas débiles, inyección SQL, inyección de archivos de script, vulnerabilidad de deserialización de Shiro, ataques DDoS, troyanos WebShell, etc. El monitoreo de seguridad debe vigilar tanto las intrusiones externas como las vulnerabilidades internas. Las intrusiones por vulnerabilidades comunes (como vulnerabilidades de seguridad de Weblogic, vulnerabilidades de deserialización de Shiro, etc.) aprovechan las vulnerabilidades conocidas en actualizaciones de middleware no oportunas. El monitoreo de intrusiones por vulnerabilidades puede registrar información detallada como hora de alerta, dirección IP del atacante, dirección IP de la víctima, tipo de ataque, nivel de ataque, etc.

Monitoreo de Middleware

El monitoreo de middleware consiste en supervisar los indicadores de estado, tráfico y recursos de los middleware centrales utilizados en el sistema de software. Los middleware comunes incluyen Tomcat, Weblogic, Redis, Kafka, MySQL, etc. Middleware Tomcat: se pueden monitorear los estados de sus hilos, los indicadores principales incluyen hilos activos, pico de hilos y número de hilos daemon, estado de la memoria heap. Middleware de base de datos relacional MySQL: sus indicadores de monitoreo principal incluyen operaciones InnoDB, consultas lentas y escaneos completos de tablas. InnoDB es un motor de almacenamiento de MySQL, sus operaciones de fila incluyen eliminación, inserción, lectura y actualización de filas. Los elementos de monitoreo de consultas lentas de MySQL incluyen los valores más recientes, mínimo, promedio y máximo. Los escaneos completos de tablas en MySQL afectan gravemente el acceso al sistema y las modificaciones de la base de datos, lo que indica que no se utilizan índices y que cada consulta tiene un gran costo para el sistema.

Monitoreo de Negocios

Se centra principalmente en el procesamiento de operaciones del sistema, como el volumen de acceso, cantidad de errores, categorías de errores, picos de negocio, etc. Debido a las grandes diferencias entre los sistemas de negocio, no existe un sistema de monitoreo de negocios unificado, generalmente es necesario personalizar según las características del negocio.

Monitoreo de Contenedores

Se enfoca principalmente en el monitoreo de contenedores basados en el entorno Docker y en el monitoreo del entorno de orquestación de contenedores basado en Kubernetes. Para los contenedores, se monitorea principalmente el uso de CPU y memoria dentro del contenedor, así como el estado de salud del contenedor y el tráfico de red del contenedor. Para Kubernetes, se monitorea principalmente el estado de los nodos del clúster y la situación de los contenedores que se ejecutan en ellos.

2 - Alertas de Monitoreo y Respuesta a Incidentes

• Definición clara de incidentes
• Sistema de gestión de incidentes y monitoreo: mecanismo de interconexión
• Clasificación de sistemas de información y alertas: condiciones de escalada
• Necesidad de convergencia de alertas: cuando ocurre un problema, múltiples dimensiones de monitoreo pueden generar información de alerta, resultando en alertas inútiles

3 - Monitoreo de Enlace Completo

Monitoreo de Enlace Completo
- APM: Gestión de Rendimiento de Aplicaciones, Application Performance Management
- Implementación de análisis multidimensional en tiempo real y diagnóstico de anomalías, detección del estado de funcionamiento de los componentes del servicio en entornos de enlace complejos
- Visualización dinámica de las relaciones y estados de llamada entre múltiples servicios
- Análisis y localización de cuellos de botella en enlaces complejos y optimización
- Los componentes de monitoreo de enlace completo pueden realizar el seguimiento de la cadena de llamadas de microservicios

Cadena de Llamadas de Negocio
- Para sistemas de microservicios, cada solicitud iniciada desde el frontend puede formar una cadena de llamada de servicio distribuida compleja,
- Una sola llamada puede involucrar múltiples servicios, por lo que el proceso de procesamiento de una solicitud forma una cadena de llamada.
- La cadena de llamada registra todo el proceso de todos los módulos atravesados por una solicitud desde su inicio hasta su finalización en un sistema distribuido.

4 - Plataforma de Monitoreo Unificada

Un sistema de monitoreo multidimensional puede detectar y predecir problemas en el primer momento. Al establecer un sistema de monitoreo de abajo hacia arriba que cubra indicadores de infraestructura, aplicación y niveles de negocio, se pueden lograr objetivos como monitoreo en tiempo real y predicción de estado.

• Monitoreo básico de la infraestructura de TI de capa IaaS, virtualización y plataforma de contenedores en la nube
• Monitoreo de la capa PaaS: monitoreo de registros clave de sistemas de aplicación, monitoreo de middleware, monitoreo de enlace completo APM y monitoreo de rendimiento
• Monitoreo de la capa de negocio: indicadores clave de negocio, tendencias de big data

Componentes importantes

• Monitoreo básico
• Plataforma de registros
• Monitoreo de enlace completo
• Monitoreo de indicadores clave

5 - Prácticas de Monitoreo

## Todos los sistemas de monitoreo son sistemas internos
## Prestar atención al proceso general de monitoreo y la experiencia del usuario, establecer y optimizar el mecanismo de manejo de eventos de alerta de monitoreo

## Monitoreo de sala de servidores y hardware
- Monitoreo básico
- Inspecciones periódicas de sala de servidores: inspección automática del sistema, inspección en sitio
- Hardware: IPMI (Interfaz de Gestión de Plataforma Inteligente), Zabbix
- Soluciones de proveedores

## Monitoreo de sistemas
- Monitoreo básico
- Uso de CPU, memoria (tasa de uso, tasa de uso de SWAP), uso de disco, E/S, situación de red (cantidad y estado de conexiones TCP), archivos abiertos, número de procesos, puertos, etc.
- Establecimiento de umbrales de alerta

## Monitoreo de aplicaciones
- Monitoreo de diversos servicios de aplicación ejecutados en el servidor
- Middleware: Nginx, Tomcat, Redis, MySQL, Nacos, RocketMQ, etc.
- Estado de la JVM de la aplicación
- Número de hilos de Java, puertos
- Indicadores de rendimiento de la aplicación en ejecución

## Monitoreo de registros
- A través de estadísticas de registros UV/PV, analizar fuentes de tráfico, comprender el comportamiento del usuario, realizar consultas rápidas de registros, análisis, resolver problemas y ayudar a localizar y resolver problemas
- Comandos manuales: head, less, tail, grep, wc, awk, sed, count, cut, etc.
- Scripts: Shell o Python
- Plataformas de herramientas: análisis automático, estadísticas y visualización, por ejemplo ELK
- Recopilación y filtrado de registros de errores de aplicación, implementación de alertas a través de configuración de palabras clave

## Monitoreo de experiencia de usuario
- Prestar atención a la experiencia operativa del usuario final
- Rendimiento de procesamiento de páginas de acceso, tiempo de respuesta DNS, tiempo de establecimiento de conexión HTTP, tamaño de elementos, etc.
- Considerando globalmente, monitorear cubriendo puntos clave como el lado del cliente, la salida de red de la sala de servidores, monitoreo de páginas e interfaces, punto de acceso de tráfico, lado del clúster de negocio, etc.

## Monitoreo de negocio
- Establecer indicadores y umbrales de monitoreo para negocios clave
- Volumen de transacciones por minuto, número de registros por minuto, número de excepciones de conciliación, usuarios activos diarios, uso de SMS, etc.
- Prestar atención al estado de los indicadores de transacción, prestar atención a las situaciones anómalas y mantener el seguimiento, análisis y confirmación posteriores
- Determinación de indicadores de negocio (cooperación con el equipo de desarrollo)
- Si se elige un método basado en registros, debe especificar el formato y la especificación del contenido del archivo de registro para evitar confusiones

## Monitoreo de seguridad
- Monitoreo de seguridad de red --》 Enfoque
- Dispositivos de seguridad esenciales: IDS/IPS/WAF/FW convencionales
- Productos de seguridad de código abierto: control de red, ataques de capa de aplicación, auditoría de código, detección de vulnerabilidades, detección de código, etc.

## Pantalla grande
- Extraer indicadores clave de varios sistemas en la misma plataforma para visualización unificada
- Basado en la plataforma de código abierto Grafana (soporta consulta, análisis y visualización de múltiples fuentes de datos, fácil de integrar, plantillas y complementos ricos, soporte de comunidad, etc.)

6 - Madurez de Observabilidad

Puntos de atención:

• Completitud del proceso: recolección, observación, acción, análisis
• Cobertura, precisión, velocidad de respuesta
• Clasificación, clasificación por nivel, por etapas

7 - Recolección de Información

• Diagrama de arquitectura: incluye hosts (CPU, memoria, disco, etc.), red (IP, puertos, etc.), aplicaciones (nombre, uso, etc.), soporte de negocio, etc.
• Diagrama de flujo de datos: diagrama de operación de negocio, diagrama de llamada de enlace, etc.
• Información de configuración: diagrama de distribución, mecanismo de respaldo, mecanismo de recuperación, lista de parámetros clave, etc.
• Información de registros: directorio de generación, directorio de almacenamiento, estrategia de partición,方案 de almacenamiento, método de visualización, etc.
• Aplicación: diseño de rendimiento (número de concurrencia, tiempo de respuesta, etc.), mecanismo de tolerancia a fallos, distribución de estado de negocio (pico y valle), información de proceso, pasos de inicio y parada, códigos de error, reglas de nomenclatura, gestión de versiones, estrategia de lanzamiento, etc.
• Monitoreo: sistema de indicadores, respuesta de alertas, mecanismo de retroalimentación, cobertura, predicción de tendencias, visualización, etc.

8 -

Ejemplos de Implementación de Monitoreo

Monitoreo de Recursos del Sistema

# Ejemplo de monitoreo de recursos del sistema
import psutil
import time

class SistemaMonitor:
    def __init__(self):
        self.intervalo = 5  # segundos
        self.umbral_cpu = 80  # porcentaje
        self.umbral_memoria = 85  # porcentaje
        
    def obtener_estado_cpu(self):
        # Obtener el porcentaje de uso de CPU
        return psutil.cpu_percent(interval=1)
    
    def obtener_estado_memoria(self):
        # Obtener información de memoria
        mem = psutil.virtual_memory()
        return {
            'total': mem.total,
            'disponible': mem.available,
            'porcentaje_uso': mem.percent,
            'swap_uso': psutil.swap_memory().percent
        }
    
    def obtener_estado_disco(self):
        # Obtener uso del disco
        disco = psutil.disk_usage('/')
        return {
            'total': disco.total,
            'usado': disco.used,
            'libre': disco.free,
            'porcentaje_uso': disco.percent
        }
    
    def verificar_alertas(self):
        cpu = self.obtener_estado_cpu()
        memoria = self.obtener_estado_memoria()
        disco = self.obtener_estado_disco()
        
        alertas = []
        
        if cpu > self.umbral_cpu:
            alertas.append(f"Alerta: Uso de CPU alto: {cpu}%")
            
        if memoria['porcentaje_uso'] > self.umbral_memoria:
            alertas.append(f"Alerta: Uso de memoria alto: {memoria['porcentaje_uso']}%")
            
        if disco['porcentaje_uso'] > self.umbral_memoria:
            alertas.append(f"Alerta: Uso de disco alto: {disco['porcentaje_uso']}%")
            
        return alertas

# Ejemplo de uso
monitor = SistemaMonitor()
while True:
    alertas = monitor.verificar_alertas()
    if alertas:
        for alerta in alertas:
            print(alerta)
    time.sleep(monitor.intervalo)

Monitoreo de Aplicación Java

// Ejemplo de monitoreo de aplicación Java
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.ThreadMXBean;
import java.util.HashMap;
import java.util.Map;

public class MonitorAplicacion {
    
    private MemoryMXBean memoriaBean;
    private ThreadMXBean threadBean;
    private double umbralMemoria = 85.0; // porcentaje
    
    public MonitorAplicacion() {
        this.memoriaBean = ManagementFactory.getMemoryMXBean();
        this.threadBean = ManagementFactory.getThreadMXBean();
    }
    
    public Map<string object=""> obtenerEstadoMemoria() {
        Map<string object=""> estado = new HashMap<>();
        
        // Uso de heap
        long heapUsado = memoriaBean.getHeapMemoryUsage().getUsed();
        long heapMaximo = memoriaBean.getHeapMemoryUsage().getMax();
        double porcentajeHeap = (heapUsado * 100.0) / heapMaximo;
        
        // Uso de no-heap
        long noHeapUsado = memoriaBean.getNonHeapMemoryUsage().getUsed();
        long noHeapMaximo = memoriaBean.getNonHeapMemoryUsage().getMax();
        double porcentajeNoHeap = (noHeapUsado * 100.0) / noHeapMaximo;
        
        estado.put("heap_usado_mb", heapUsado / (1024 * 1024));
        estado.put("heap_maximo_mb", heapMaximo / (1024 * 1024));
        estado.put("porcentaje_heap", porcentajeHeap);
        estado.put("no_heap_usado_mb", noHeapUsado / (1024 * 1024));
        estado.put("porcentaje_no_heap", porcentajeNoHeap);
        
        return estado;
    }
    
    public Map<string object=""> obtenerEstadoHilos() {
        Map<string object=""> estado = new HashMap<>();
        
        estado.put("hilos_activos", threadBean.getThreadCount());
        estado.put("hilos_pico", threadBean.getPeakThreadCount());
        estado.put("hilos_daemon", threadBean.getDaemonThreadCount());
        
        return estado;
    }
    
    public String verificarAlertas() {
        StringBuilder alertas = new StringBuilder();
        
        Map<string object=""> estadoMemoria = obtenerEstadoMemoria();
        double porcentajeHeap = (double) estadoMemoria.get("porcentaje_heap");
        
        if (porcentajeHeap > umbralMemoria) {
            alertas.append(String.format("ALERTA: Uso de memoria heap alto: %.2f%%\n", porcentajeHeap));
        }
        
        return alertas.toString();
    }
    
    public static void main(String[] args) {
        MonitorAplicacion monitor = new MonitorAplicacion();
        
        while (true) {
            System.out.println("=== Estado de la Aplicación ===");
            
            Map<string object=""> estadoMemoria = monitor.obtenerEstadoMemoria();
            System.out.println("Estado Memoria:");
            estadoMemoria.forEach((k, v) -> System.out.printf("  %s: %s\n", k, v));
            
            Map<string object=""> estadoHilos = monitor.obtenerEstadoHilos();
            System.out.println("Estado Hilos:");
            estadoHilos.forEach((k, v) -> System.out.printf("  %s: %s\n", k, v));
            
            String alertas = monitor.verificarAlertas();
            if (!alertas.isEmpty()) {
                System.out.println("Alertas:");
                System.out.print(alertas);
            }
            
            try {
                Thread.sleep(5000); // Esperar 5 segundos
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
</string></string></string></string></string></string></string>

Monitoreo de Seguridad

#!/bin/bash
# Script de monitoreo de seguridad básico

# Configuración
LOG_AUTH="/var/log/auth.log"
LOG_SECURE="/var/log/secure"
UMBRAL_INTENTOS_FALLIDOS=5
CORREO_ADMIN="admin@empresa.com"

# Función para enviar alerta
enviar_alerta() {
    mensaje=$1
    asunto="Alerta de Seguridad: $mensaje"
    echo "$mensaje" | mail -s "$asunto" "$CORREO_ADMIN"
}

# Monitoreo de intentos de inicio de sesión fallidos
echo "Revisando intentos de inicio de sesión fallidos..."
intentos=$(grep "Failed password" $LOG_AUTH | tail -n $UMBRAL_INTENTOS_FALLIDOS | wc -l)

if [ $intentos -ge $UMBRAL_INTENTOS_FALLIDOS ]; then
    ip_atacante=$(grep "Failed password" $LOG_AUTH | tail -n $UMBRAL_INTENTOS_FALLIDOS | awk '{print $(NF-3)}' | sort | uniq)
    mensaje="Se detectaron $intentos intentos de inicio de sesión fallidos desde la IP: $ip_atacante"
    echo "$mensaje"
    enviar_alerta "$mensaje"
fi

# Monitoreo de usuarios nuevos
echo "Revisando creación de nuevos usuarios..."
nuevos_usuarios=$(last | grep "still logged in" | awk '{print $1}' | sort | uniq)

if [ -n "$nuevos_usuarios" ]; then
    mensaje="Se detectaron nuevos usuarios en el sistema: $nuevos_usuarios"
    echo "$mensaje"
    enviar_alerta "$mensaje"
fi

# Monitoreo de servicios críticos
echo "Revisando servicios críticos..."
servicios_criticos=("sshd" "nginx" "mysql")

for servicio in "${servicios_criticos[@]}"; do
    estado=$(systemctl is-active $servicio)
    if [ "$estado" != "active" ]; then
        mensaje="El servicio crítico $servicio está inactivo (Estado: $estado)"
        echo "$mensaje"
        enviar_alerta "$mensaje"
    fi
done

echo "Monitoreo de seguridad completado."