Análisis en profundidad de la instalación e implementación nativas de la nube y análisis de principios de Prometheus

1. Introducción a Prometeo

① Funciones de Prometeo

• Prometheus fue originalmente un sistema de alarma y monitoreo de código abierto desarrollado por SoundCloud, y es una versión de código abierto del sistema de monitoreo BorgMon de Google. En 2016, Prometheus se unió a CNCF y se convirtió en el segundo proyecto organizado por CNCF después de Kubernetes. Con el establecimiento de la posición de liderazgo de Kubernetes en la disposición de contenedores, Prometheus también se ha convertido en la configuración estándar para el monitoreo de contenedores de Kubernetes.
• Las principales características de Prometheus son las siguientes:
• • Modelos de datos de series temporales multidimensionales que se distinguen por nombres y etiquetas de métricas (pares clave/valor);
• • Sintaxis de consulta flexible PromQL;
• • Un nodo de servicio puede funcionar sin depender de almacenamiento adicional;
• • Utilice el protocolo http para recopilar datos de series temporales a través del modo de extracción;
• • Las aplicaciones que requieren el modo push se pueden implementar a través de la puerta de enlace de middleware;
• • Los objetivos de monitoreo admiten el descubrimiento de servicios y la configuración estática;
• • Admite una amplia variedad de componentes de gráficos y tableros.

② Componentes principales de Prometheus

• Todo el ecosistema de Prometheus contiene varios componentes, todos opcionales excepto el componente del servidor de Prometheus;
• • Prometheus Server: el principal componente central utilizado para recopilar y almacenar datos de series temporales;
• • Biblioteca de cliente: la biblioteca de cliente genera las métricas correspondientes para los servicios que deben monitorearse y las expone al servidor de Prometheus.Cuando el servidor de Prometheus llega a extraer, devuelve directamente las métricas en tiempo real;
• • puerta de enlace push: se utiliza principalmente para trabajos a corto plazo. Dado que dichos trabajos existen por poco tiempo, pueden desaparecer antes de que Prometheus los extraiga. Por esta razón, los trabajos pueden enviar directamente sus métricas al servidor Prometheus. Este método se usa principalmente Métricas a nivel de servicio, para métricas a nivel de máquina, debe usar el exportador de nodos;
• • Exportadores: se utiliza para exponer las métricas de los servicios de terceros existentes a Prometheus;
• • Alertmanager: después de recibir alertas del servidor Prometheus, eliminará los datos duplicados, los agrupará y los enrutará al método de recepción y enviará una alarma.Los métodos de recepción comunes incluyen: correo electrónico, pagerduty, OpsGenie, webhook, etc.;
• • Varias herramientas de apoyo.

③ Marco Prometeo

• La recuperación es responsable de capturar datos de indicadores de muestreo en la página de destino expuesta a intervalos regulares;
• El almacenamiento es responsable de escribir los datos de muestreo en el almacenamiento de la base de datos de series temporales especificado;
• PromQL es un módulo de lenguaje de consulta proporcionado por Prometheus, que se puede integrar con algunas webui como grfana;
• Trabajos/Exportadores: Prometheus puede extraer datos de monitoreo de Trabajos o Exportadores, y el Exportador expone la interfaz de recopilación de datos en forma de API web;
• Servidor Prometheus: Prometheus también puede extraer datos de otros servidores Prometheus;
• Pushgateway: para algunos componentes que se ejecutan como trabajos temporales, es posible que Prometheus no haya tenido tiempo de extraer los datos de monitoreo de ellos. Estos trabajos han finalizado y el tiempo de ejecución del trabajo puede enviar los datos de monitoreo a Pushgateway en el tiempo de ejecución, y Prometheus extraerá los datos de monitoreo. de Pushgateway Extraiga datos para evitar la pérdida de datos de monitoreo.
• Descubrimiento de servicios: Prometheus puede descubrir dinámicamente algunos servicios y extraer datos para monitorear, como DNS, Kubernetes, Consul, file_sd es un archivo configurado estáticamente;
• AlertManager: es un componente externo independiente de Prometheus, que se utiliza para monitorear las alertas del sistema.Algunas reglas de alerta se pueden configurar a través de archivos de configuración, y Prometheus enviará alertas a AlertManager.

④ Flujo de trabajo

• El servidor Prometheus extrae periódicamente métricas de trabajos o exportadores configurados, o recibe métricas de Pushgateway, o extrae métricas de otros servidores Prometheus;
• El servidor Prometheus almacena las métricas recopiladas localmente y ejecuta las reglas de alerta definidas para registrar nuevas series temporales o enviar alertas a Alertmanager;
• Alertmanager procesa las alertas recibidas y envía alertas según el archivo de configuración;
• En la interfaz gráfica, visualice los datos recopilados.

2. Despliegue de Prometheus

① instalar git

$ yum install -y git

• Descargar kube-prometheus:

# 下载
$ git clone https://github.com/prometheus-operator/kube-prometheus.git
$ cd kube-prometheus/manifests
# yaml文件比较多，进行归档
$ mkdir -p serviceMonitor prometheus adapter node-exporter blackbox kube-state-metrics grafana alertmanager operator other/{
    
    nfs-storage,ingress}
$ mv alertmanager-* alertmanager/ && mv blackbox-exporter-* blackbox/ &&  mv grafana-* grafana/ && mv kube-state-metrics-* kube-state-metrics/ && mv node-exporter-*  node-exporter/ && mv prometheus-adapter-* adapter/ && mv prometheus-* prometheus/ && mv kubernetes-serviceMonitor* serviceMonitor/
$ 

② Modificar la fuente del espejo

• Algunas imágenes de fuentes espejo extranjeras no se pueden extraer. Aquí, modifique las fuentes espejo de prometheus-operator, prometheus, alertmanager, kube-state-metrics, node-exporter y prometheus-adapter a fuentes espejo domésticas:

# 查找
$ grep -rn 'quay.io' *
# 批量替换
$ sed -i 's/quay.io/quay.mirrors.ustc.edu.cn/g' `grep "quay.io" -rl *`
# 再查找
$ grep -rn 'quay.io' *
$ grep -rn 'image: ' *

③ Cambiar el tipo a NodePort

• Para acceder a prometheus, alertmanager y grafana desde el exterior, modifique el tipo de servicio de promethes, alertmanager y grafana al tipo NodePort;
• Modificar el servicio de prometeo:

# 设置对外访问端口：30080
$ cat prometheus-service.yaml

• Modificar el servicio de grafana:

# 设置对外访问端口：30081
$ cat grafana-service.yaml

• Modificar el servicio de alertmanager:

# 设置对外访问端口：30082
$ cat alertmanager-service.yaml

• Instale CRD y el operador Prometheus:

$ kubectl apply -f setup/

• Se tarda unos minutos en descargar la imagen de Prometheus-Operator, solo espere hasta que se ejecute Prometheus-Operator:

$ kubectl get pod -n monitoring

• Instale prometheus, alertmanager, grafana, kube-state-metrics, node-exporter y otros recursos:

$ kubectl apply -f .

• Espere un momento y verifique nuevamente, verifique el estado del pod bajo el espacio de nombres de monitoreo hasta que todos los pods bajo el espacio de nombres de monitoreo cambien al estado de ejecución, y listo:

$ kubectl get pod -n monitoring

• Flujo de trabajo: Prometheus Server extrae periódicamente métricas de los Exportadores/Trabajos configurados, o las métricas enviadas por la puerta de enlace, u otras métricas, ejecuta las reglas de alerta definidas después de la recopilación, registra series temporales o envía alertas a Alertmanager.
• Descripción de Componente:
• • node_exporter: se utiliza para monitorear la información de recursos del host en el nodo informático y debe implementarse en todos los nodos informáticos;
• • kube-state-metric: el exportador que Prometheus recopila datos de recursos de k8 puede recopilar los datos relevantes de la mayoría de los recursos integrados de k8, como pod, deployment, service, etc., y también proporciona sus propios datos, principalmente el número y colección de recursos Estadísticas sobre el número de excepciones que ocurrieron;
• • blackbox_exporter: monitorear la capacidad de supervivencia de los contenedores comerciales;
• • Prometheus-adapter: dado que Prometheus en sí mismo es una solución de terceros, el sistema k8s nativo no puede analizar los indicadores personalizados de Prometheus, por lo que es necesario usar k8s-prometheus-adapter para convertir estas interfaces de consulta de datos de indicadores en las interfaces estándar de definición automática de Kubernetes. indicadores;
• verificar:

$ kubectl get svc -n monitoring

• Acceso al navegador:
• • prometeo：http://192.168.0.113:30080/：

• • grafana: http://192.168.0.113:30081/login, cuenta/contraseña por defecto: admin/admin:

• • administrador de alertas：http://192.168.0.113:30082/：

• Grafana agrega una fuente de datos y modifica la dirección de Prometheus:

• Importar tableros:
• • Descargue e importe la plantilla desde el sitio web oficial de los paneles :

• • Importación de plantilla de kubernetes (plantilla k8s):

3. Conceptos relacionados con Prometeo

① Mecanismo de almacenamiento interno

• Prometheus tiene un método de almacenamiento de datos de series temporales muy eficiente. Cada dato muestreado solo ocupa alrededor de 3,5 bytes de espacio. Millones de series temporales, intervalos de 30 segundos y retención de 60 días cuestan más de 200 G.
• Prometheus se divide principalmente en tres grandes bloques:
• • La recuperación es responsable de capturar datos de indicadores de muestreo en la página de destino expuesta a intervalos regulares;
• • El almacenamiento es responsable de escribir datos de muestra en el disco;
• • PromQL es un módulo de lenguaje de consulta proporcionado por Prometheus.

② Modelo de datos

• Todos los datos almacenados por Prometheus son datos de series temporales (Datos de series temporales, denominados datos de series temporales), los datos de series temporales son un flujo de datos con una marca de tiempo, el flujo de datos pertenece a una métrica (Métrica) y varias etiquetas debajo de la métrica (Etiqueta):

• Cada nombre de Métrica representa un tipo de indicador, y pueden llevar diferentes Etiquetas.Cada Nombre de Métrica + Etiqueta se combinan para representar una serie temporal de datos. En Prometheus, todos los valores son de 64 bits, y lo que se registra en cada serie de tiempo es en realidad una marca de tiempo de 64 bits (timestamp) + valor de 64 bits (valor de muestreo):
• • Nombre de la métrica (nombre del índice): El nombre debe tener semántica y generalmente se usa para representar la función de la métrica, por ejemplo: http_requests_total, que representa el número total de solicitudes http, donde el nombre de la métrica está compuesto por caracteres ASCII, números, guiones bajos y dos puntos, y debe cumplir con la expresión regular [a-zA-Z_:][a-zA-Z0-9_:]*;
• • Etiquetas (labels): Haz que una misma serie temporal tenga diferentes dimensiones para identificar, por ejemplo, http_requests_total{method="Get"} significa Obtener solicitudes en todas las solicitudes http. Cuando method="post", es una nueva métrica. La clave en la etiqueta se compone de caracteres ASCII, números y guiones bajos, y debe satisfacer la expresión regular [a-zA-Z_:][a-zA-Z0- 9_:]*;
• • marca de tiempo (marca de tiempo): la hora del punto de datos, que indica la hora de grabación de datos;
• • Valor de muestra: la serie de tiempo real, cada serie incluye un valor float64 y una marca de tiempo de nivel de milisegundos.

http_requests_total{
    
    status="200",method="GET"}
http_requests_total{
    
    status="404",method="GET"}

• De acuerdo con el análisis anterior, el almacenamiento de series temporales parece estar diseñado como almacenamiento de valores clave (basado en BigTable):

• Dividiendo aún más, puede verse así:

• El segundo estilo en la figura anterior es la representación interna actual de Prometheus, y el nombre es una etiqueta de etiqueta específica que representa el nombre de la métrica.
• Repasemos el proceso general de Prometheus:

• Se menciona el almacenamiento KV, por supuesto, utiliza el motor LevelDB, que se caracteriza por un rendimiento de lectura y escritura secuencial muy alto, que es muy consistente con el almacenamiento de series temporales.

③Tipo métrico

• Prometheus define 4 tipos de métricas diferentes: Counter (contador), Gauge (tablero), Histogram (histograma), Summary (resumen).
• Encimera:
• • Una métrica acumulativa, aplicaciones típicas como: el número de solicitudes, el número de tareas completadas, el número de errores, etc.;
• • Por ejemplo: consulta http_requests_total{method="get", job="Prometheus", handler="query"} devuelve 8, después de 10 segundos, vuelve a consultar y devuelve 14.
• Indicador (tablero):
• • Los datos son un valor instantáneo, si el uso actual de la memoria cambia con el tiempo;
• • Por ejemplo: go_goroutines{instance="172.17.0.2", job="Prometheus"} devuelve 147 y devuelve 124 después de 10 segundos.
• Histograma (histograma):
• • El histograma muestra los resultados de las observaciones (por lo general, la duración de la solicitud o el tamaño de la respuesta) y calcula estos resultados en un intervalo de distribución configurable (depósito), que también proporciona la suma de todas las observaciones;
• • El histograma tiene un nombre de métrica básico que muestra varias series temporales en una captura: el contador acumulado representa el intervalo de observación: _bucket{le=""}, el número total de todas las observaciones: _sum y el número de eventos observados: _count.
• • Por ejemplo: prometheus_local_storage_series_chunks_persisted en el servidor Prometheus indica la cantidad de fragmentos que deben almacenarse para cada serie temporal en Prometheus, que se puede usar para calcular el cuantil de los datos que se conservarán;
• Resumen:
• • Similar al histograma, el resumen muestra los resultados de las observaciones (por lo general, la duración de la solicitud o el tamaño de la respuesta), pero también proporciona el número de observaciones y la suma de todos los valores, lo que calcula cuantiles configurables en una ventana de tiempo variable;
• • El resumen tiene un nombre de métrica básico que representa múltiples series de tiempo en una sola búsqueda: Transmisión de φ cuantiles de eventos observados (0 ≤ φ ≤ 1): {quantile="φ"}, suma de todas las observaciones: _sum, el número de eventos observados : _contar;
• • 如：Servidor Prometheus 中 prometheus_target_interval_length_seconds。

④ Comparación entre Histograma y Resumen

número de serie	histograma	Resumen
configuración	configuración de intervalo	Cuantiles y ventanas deslizantes
rendimiento del cliente	Solo es necesario aumentar el costo de los contadores es pequeño	Requiere un alto costo de flujo de computación
rendimiento del servidor	Calcular cuantiles es costoso y puede llevar mucho tiempo	No se requiere cálculo, bajo costo
Cantidad de tiempo	_sum,_count, cubo	_sum,_count, cuantil
error cuantil	El tamaño de la cubeta está relacionado con	La configuración de φ está relacionada con
φ y la ventana corredera	Ajustes de expresión de Prometheus	configuración del cliente
polimerización	Agregado por expresión	generalmente no agregable

• El siguiente es un ejemplo de salida de muestra para tipos de histograma y resumen:

# A histogram, which has a pretty complex representation in the text format:
# HELP http_request_duration_seconds A histogram of the request duration.
# TYPE http_request_duration_seconds histogram
http_request_duration_seconds_bucket{
    
    le="0.05"} 24054
http_request_duration_seconds_bucket{
    
    le="0.1"} 33444
http_request_duration_seconds_bucket{
    
    le="0.2"} 100392
http_request_duration_seconds_bucket{
    
    le="+Inf"} 144320
http_request_duration_seconds_sum 53423
http_request_duration_seconds_count 144320
# Finally a summary, which has a complex representation, too:
# HELP rpc_duration_seconds A summary of the RPC duration in seconds.
# TYPE rpc_duration_seconds summary
rpc_duration_seconds{
    
    quantile="0.01"} 3102
rpc_duration_seconds{
    
    quantile="0.05"} 3272
rpc_duration_seconds{
    
    quantile="0.5"} 4773
rpc_duration_seconds_sum 1.7560473e+07
rpc_duration_seconds_count 2693

⑤ Tarea (TRABAJOS) e instancia (INSTANCIAS)

• En la terminología de Prometheus, el punto final que se puede capturar se denomina instancia, que generalmente corresponde a un solo proceso;
• Una colección de instancias con el mismo propósito (por ejemplo, un proceso de replicación para escalabilidad o confiabilidad) se denomina trabajo.
• Un trabajo de servidor API con cuatro instancias replicadas:
• • trabajo: api-servidor：
• • • instancia 1: 1.2.3.4:5670
• • • instancia 2: 1.2.3.4:5671
• • • instancia 3: 5.6.7.8:5670
• • • instancia 4: 5.6.7.8:5671
• • ejemplo: un solo objetivo de raspado, generalmente correspondiente a un proceso;
• • trabajos: un grupo de instancias del mismo tipo (utilizado principalmente para garantizar la escalabilidad y la confiabilidad).

⑥ Exportador de nodos

• El exportador de nodos se usa principalmente para exponer métricas a Prometheus, donde las métricas incluyen: carga de CPU, uso de memoria, red, etc.

⑦ Pasarela de empuje

• Pushgateway es una herramienta importante en el ecosistema de Prometheus, las principales razones para usarla son:
• • Prometheus adopta el modo de extracción, lo que puede hacer que Prometheus no pueda extraer directamente cada dato de destino porque no se encuentra en una subred o en un firewall;
• • Al monitorear datos comerciales, es necesario resumir diferentes datos y recopilarlos uniformemente por parte de Prometheus;
• Por las razones anteriores, se debe usar pushgateway, pero antes de usarlo, es necesario comprender algunas de sus desventajas:
• • Resumir los datos de varios nodos en la puerta de enlace. Si la puerta de enlace está inactiva, el impacto será mayor que el de varios objetivos;
• • Prometheus pull status up es solo para pushgateway y no puede ser efectivo para todos los nodos;
• • Pushgateway puede conservar todos los datos de monitoreo que se le envían, por lo que incluso si el monitoreo está fuera de línea, Prometheus seguirá extrayendo los datos de monitoreo antiguos y deberá limpiar manualmente los datos que Pushgateway no desea.

4. Introducción a TSDB

① Características de la base de datos de series temporales

• La base de datos de series temporales TSDB (Time Series Database) puede entenderse simplemente como un software optimizado para procesar datos de series temporales, y las matrices de los datos están indexadas por tiempo.
• Las características de TSDB son:
• • escribir operaciones la mayor parte del tiempo;
• • Las operaciones de escritura se agregan casi secuencialmente, y la mayoría de las veces los datos llegan ordenados por tiempo;
• • Las operaciones de escritura rara vez escriben datos hace mucho tiempo y rara vez actualizan datos. En la mayoría de los casos, los datos se escribirán en la base de datos después de unos segundos o minutos después de que se recopilen;
• • La operación de eliminación es generalmente la eliminación de bloques, seleccione el tiempo histórico de inicio y especifique el bloque posterior, y rara vez elimine datos en un momento determinado o en un momento aleatorio separado;
• • Los datos básicos son grandes, generalmente exceden el tamaño de la memoria, y generalmente solo una pequeña parte es seleccionada e irregular, y el caché casi no tiene efecto;
• • La operación de lectura es una lectura secuencial ascendente o descendente típica;
• • Las operaciones de lectura altamente simultáneas son muy comunes.

② Base de datos de series temporales comunes

proyecto TSDB	página web oficial
influjoDB	https://influxdata.com/
herramienta RRD	http://oss.oetiker.ch/rrdtool/
Grafito	http://graphiteapp.org/
OpenTSDB	http://opentsdb.net/
kdb+	http://kx.com/
druida	http://druida.io/
KairosDB	http://kairosdb.github.io/
Prometeo	https://prometeo.io/

Cinco, expresión de consulta PromQL

• Los cuatro tipos de datos de PromQL:
• • Vector instantáneo: un conjunto de series de tiempo que contiene una sola muestra de cada serie de tiempo, compartiendo la misma marca de tiempo;
• • Vector de rango: un conjunto de series temporales que contienen puntos de datos dentro de un rango;
• • Escalar: un valor de punto flotante numérico simple;
• • String (String): un valor de cadena simple, actualmente sin usar.

① Selector de vector instantáneo

• El selector de vector instantáneo permite seleccionar un conjunto de series de tiempo o datos de muestra en una marca de tiempo determinada, como se muestra a continuación, selecciona la serie de tiempo con http_requests_total:

http_requests_total

• Estas series temporales se pueden filtrar aún más agregando un conjunto de etiquetas encerradas entre {}, de la siguiente manera para seleccionar solo series temporales con el nombre http_requests_total, con la etiqueta de trabajo de Prometheus y con la etiqueta de grupo Canary:

http_requests_total

• Además, también es posible hacer coincidir inversamente el valor de la etiqueta, o hacer coincidir el valor de la etiqueta con una expresión regular. Los operadores coincidentes se enumeran a continuación:
• • =: Seleccione etiquetas de cadena exactamente iguales;
• • !=: Seleccionar etiquetas de cadena que no sean iguales;
• • =~: seleccione una etiqueta (o subetiqueta) que coincida con una expresión regular;
• • !~: seleccione etiquetas (o subetiquetas) que no coincidan con la expresión regular;
• Seleccione la serie temporal de http_requests_total de métodos HTTP que no sean GET en entornos de ensayo, prueba y desarrollo:

http_requests_total

② Selector de vector de rango

• Las expresiones vectoriales de rango funcionan igual que las expresiones vectoriales instantáneas, pero las primeras devuelven un conjunto de series de tiempo para un cierto rango de tiempo a partir del momento actual. La sintaxis es agregar [] después de una expresión vectorial para indicar el intervalo de tiempo, la duración se representa mediante un número, seguido de una de las siguientes unidades:
• • s：segundos
• • m：minutos
• • h：horas
• • d：días
• • w：semanas
• • y：años
• En el ejemplo que se muestra a continuación, seleccione los registros de los últimos 5 minutos, todos los valores de la serie temporal cuyo nombre de métrica es http_requests_total y la etiqueta del trabajo es prometheus:

http_requests_total{
    
    job="prometheus"}[5m]

③ Modificador de compensación

• El desplazamiento puede cambiar los desplazamientos de vector de tiempo y rango para momentos individuales en la consulta. Por ejemplo, la siguiente expresión devuelve el valor de http_requests_total durante los últimos 5 minutos en relación con el tiempo de evaluación de la consulta actual:

http_requests_total offset 5m

• Lo mismo ocurre con el vector de rango, esto devolverá http_requests_total la tasa de 5 minutos de hace una semana:

rate(http_requests_total[5m] offset 1w)

④ Usar operaciones de agregación

• La operación de agregación proporcionada por PromQL se puede utilizar para procesar estas series temporales para formar una nueva serie temporal:

# 查询系统所有http请求的总量
sum(http_request_total)

# 按照mode计算主机CPU的平均使用时间
avg(node_cpu) by (mode)

# 按照主机查询各个主机的CPU使用率
sum(sum(irate(node_cpu{
    
    mode!='idle'}[5m]))  / sum(irate(node_cpu[5m]))) by (instance)

• Funciones agregadas comunes:
• • suma
• • min (valor mínimo)
• • max (valor máximo)
• • promedio (valor promedio)
• • stddev (desviación estándar)
• • stdvar (varianza estándar)
• • contar (contar)
• • count_values ​​(valor de conteo)
• • bottomk (última n serie temporal)
• • topk (serie temporal superior n)
• • cuantil

6. Exportador

• El exportador es una parte importante del seguimiento de Prometheus y es responsable de la recopilación de indicadores de datos. En términos generales, todos los programas que pueden proporcionar datos de muestra de monitoreo a Prometheus pueden denominarse Exportador, y una instancia de Exportador se denomina destino.

• Los complementos oficiales incluyen blackbox_exporter, node_exporter, mysqld_exporter, snmp_exporter, etc. Los complementos de terceros incluyen redis_exporter, cadvisor, etc. y la dirección oficial del exportador .

① Exportador común

• exportador de blockbox:
• bloackbox exporter es una solución de monitoreo de caja negra proporcionada por la comunidad de Prometheus que permite a los usuarios detectar la red a través de HTTP, HTTPS, DNS, TCP e ICMP, y recopilar información del sitio a través de Blackbox.
• • Dirección de GitHub .
• nodo_exportador：
• • node_exporter se utiliza principalmente para recopilar datos de índice de rendimiento de la máquina, incluida información básica como CPU, memoria, disco e io.
• • Dirección de GitHub .
• exportador_mysqld:
• • mysql_exporter se usa para recopilar indicadores relacionados con la base de datos MysQL o Mariadb, mysql_exporter necesita conectarse a la base de datos y tener los permisos pertinentes.
• • Dirección de GitHub .
• exportador_snmp:
• • SNMP Exporter recopila información del servicio SNMP y la proporciona al sistema de monitoreo de Promethers.
• • Dirección de GitHub .

② Cómo funciona el Exportador

• Operación independiente: dado que el sistema operativo en sí no es compatible directamente con Prometheus, y los usuarios no pueden proporcionar soporte para Prometheus directamente desde el nivel del sistema operativo, los usuarios solo pueden ejecutar un programa de forma independiente a través de las interfaces relevantes proporcionadas por el sistema operativo, para convertir el sistema en ejecución datos de estado en datos de seguimiento que puede leer Prometheus. Además de Node Exporter, MySQL Exporter, Redis Exporter, etc. se implementan de esta manera. Estos programas Exporter desempeñan el papel de un agente intermedio (conversión de datos).
• Integrar en la aplicación (recomendado): para monitorear mejor el estado operativo interno del sistema, algunos proyectos de código abierto como Kubernetes, ETCD, etc. usan directamente la biblioteca de cliente de Prometheus en el código, brindando soporte directo para Prometheus. los límites de la supervisión permiten que la aplicación exponga directamente el estado de funcionamiento interno a Prometheus, lo que es adecuado para algunos proyectos que requieren indicadores de supervisión más personalizados.

③ Especificación del exportador

• Todos los programas de exportación deben devolver los datos de muestra monitoreados de acuerdo con la especificación de Prometheus. Tomando como ejemplo a Node Exporter, al acceder a la dirección /metrics, se devolverá el siguiente contenido (direct curl no puede obtener los datos, debe estar autorizado):

# 取前面10行
$ curl -s -k --header "Authorization: Bearer $TOKEN" https://192.168.0.113:6443/metrics|head -10

# HELP aggregator_openapi_v2_regeneration_count [ALPHA] Counter of OpenAPI v2 spec regeneration count broken down by causing APIService name and reason.
# TYPE aggregator_openapi_v2_regeneration_count counter
aggregator_openapi_v2_regeneration_count{
    
    apiservice="*",reason="startup"} 0
aggregator_openapi_v2_regeneration_count{
    
    apiservice="k8s_internal_local_delegation_chain_0000000002",reason="update"} 0
aggregator_openapi_v2_regeneration_count{
    
    apiservice="v1beta1.metrics.k8s.io",reason="add"} 0
aggregator_openapi_v2_regeneration_count{
    
    apiservice="v1beta1.metrics.k8s.io",reason="update"} 0
# HELP aggregator_openapi_v2_regeneration_duration [ALPHA] Gauge of OpenAPI v2 spec regeneration duration in seconds.
# TYPE aggregator_openapi_v2_regeneration_duration gauge
aggregator_openapi_v2_regeneration_duration{
    
    reason="add"} 0.929158077
aggregator_openapi_v2_regeneration_duration{
    
    reason="startup"} 0.509336209

• Los datos de muestra devueltos por Exporter se componen principalmente de tres partes: la información de anotación general de la muestra (AYUDA), la información de anotación de tipo de la muestra (TIPO) y la muestra.
• Prometheus analizará el contenido de la respuesta del Exportador línea por línea:
• • Si la línea actual comienza con # HELP, Prometheus analizará el contenido de acuerdo con las siguientes reglas para obtener el nombre del indicador actual y la información de descripción correspondiente:

# HELP <metrics_name> <doc_string>

• • Si la línea actual comienza con # TYPE , Prometheus analizará el contenido de acuerdo con las siguientes reglas para obtener el nombre y el tipo de indicador actuales:

# TYPE <metrics_name> <metrics_type>

• • La línea de comentario TIPO debe aparecer antes de la primera muestra del indicador. Si no hay un tipo de indicador claro que deba devolverse como sin tipo, todas las líneas, excepto # al principio, se considerarán como datos de muestra de seguimiento. Cada línea de muestras debe cumplir con las siguientes especificaciones de formato:

metric_name [
"{" label_name "=" " label_value " {
    
     "," label_name "=" " label_value " } [ "," ] "}"
] value [ timestamp ]

④ exportador de nodos

• El exportador es el componente de recopilación de datos de indicador de Prometheus. Es responsable de recopilar datos de los trabajos de destino y convertir los datos recopilados al formato de datos de serie temporal compatible con Prometheus. A diferencia del componente tradicional de recopilación de datos de indicadores, solo es responsable de la recopilación y no envía datos al servidor, sino que espera a que Prometheus Server los tome activamente.
• node-exporter se utiliza para recopilar los indicadores de ejecución del nodo, incluidos los indicadores básicos de monitoreo, como la CPU del nodo, la carga, el sistema de archivos, meminfo, la red, etc., similar a zabbix-agent del sistema de monitoreo de zabbix, el diagrama esquemático es el siguiente:

• Compruebe el servicio exportador de nodos:

$ kubectl get pods -n monitoring -o wide|grep node-exporter
# 查看pod内的node_exporter进程
$ kubectl exec -it node-exporter-dc65j -n monitoring -- ps -ef|grep node_exporter
# 获取容器ID
$ docker ps |grep node_exporter
# 查看docker 容器的pid
$ docker inspect -f {
    
    {
    
    .State.Pid}} 8b3f0c3ea055
# 再通过pid进入命名空间
$ nsenter -n -t8303
# 再查看进程
$ ps -ef|grep node_exporter
# 退出当前命名空间
$ exit

• Diseño a archivo yaml:

node-exporter-clusterRoleBinding.yaml # 角色绑定
node-exporter-clusterRole.yaml # 角色
node-exporter-daemonset.yaml # daemonset，容器配置，node-exporter配置
node-exporter-prometheusRule.yaml # 采集规则
node-exporter-serviceAccount.yaml # 服务账号
# K8s集群内的Prometheus抓取监测数据是通过servicemonitor这个crd来完成的。
# 每个servicemonitor对应Prometheus中的一个target。
# 每个servicemonitor对应一个或多个service，负责获取这些service上指定端口暴露的监测数据，并向Prometheus上报。
node-exporter-serviceMonitor.yaml 
node-exporter-service.yaml # 服务

• Servicio de descubrimiento automático:
• • Cualquier objetivo monitoreado debe incluirse en el sistema de monitoreo con anticipación para la recopilación, el almacenamiento, la alarma y la visualización de datos de series temporales. El objetivo de monitoreo se puede especificar de forma estática a través de la información de configuración, o Prometheus puede administrarlo dinámicamente a través del mecanismo de descubrimiento de servicios.
• • Primero echemos un vistazo al método de configuración tradicional:
• • • Primero, debe instalar el exportador de nodos, obtener métricas de nodos y exponer un puerto;
• • • Luego vaya al archivo prometheus.yaml de Prometheus Server para agregar el trabajo del exportador de nodos en scarpe_config y configure la dirección del exportador de nodos y la información del puerto;
• • • Luego, debe reiniciar el servicio Prometheus;
• • • Finalmente, espere a que el servicio Prometheus extraiga la información de monitoreo y luego complete la tarea de agregar un monitoreo de exportador de nodos.
• • La configuración de muestra es la siguiente (prometheus.yml):

- job_name: 'node-exporter'
    static_configs:
    - targets: ['192.168.0.113:9090']   #这里我修改了端口为9090

• • reiniciar servicio

$ systemctl restart prometheus

• • descubrimiento automático del servicio kube-prometheus:
• • • Primero, el primer paso es el mismo que el método tradicional, implementando un exportador de nodos para obtener elementos de monitoreo;
• • • A continuación, escriba un ServiceMonitor para seleccionar el exportador de nodos recién implementado mediante labelSelector. Dado que el operador especifica Prometheus al implementar Prometheus de forma predeterminada, la etiqueta es: prometheus: kube-prometheus ServiceMonitor, por lo que solo necesita etiquetar prometheus: kube-prometheus en ServiceMonitor Puede ser seleccionado por Prometheus;
• • • Después de completar los dos pasos anteriores, se completa la supervisión de los recursos del host. No es necesario cambiar el archivo de configuración de Prometheus o reiniciar el servicio de Prometheus. ¿Es muy conveniente? El operador generará dinámicamente el archivo de configuración de Prometheus cuando observe cambios en el ServiceMonitor, y asegúrese de que el archivo de configuración sea efectivo inmediatamente.

7. Agregue monitoreo externo k8s

① Proceso de configuración

• Puede ser difícil para un proyecto lograr la contenedorización completa al principio, como las bases de datos y los clústeres de CDH, pero todavía necesitan ser monitoreados.Si se dividen en dos conjuntos de Prometheus, no es propicio para la gestión, por lo que estos monitoreos se agregan a kube-prometheus uniformemente.
• Para una introducción específica a la propiedad adicionalScrapeConfigs, puede usar el comando kubectl Explain para obtener más información al respecto:

$ kubectl explain prometheus.spec.additionalScrapeConfigs

• A continuación, cree un nuevo archivo prometheus-additional.yaml y agregue componentes de monitoreo adicionales para configurar scrape_configs:

$ cat << EOF > prometheus-additional.yaml
- job_name: 'node-exporter-others'
  static_configs:
    - targets:
      - *.*.*.113:31190
      - *.*.*.114:31190
      - *.*.*.115:31190

- job_name: 'mysql-exporter'
  static_configs:
    - targets:
      - *.*.*.104:9592
      - *.*.*.125:9592
      - *.*.*.128:9592

- job_name: 'nacos-exporter'
  metrics_path: '/nacos/actuator/prometheus'
  static_configs:
    - targets:
      - *.*.*.113:8848
      - *.*.*.114:8848
      - *.*.*.115:8848

- job_name: 'elasticsearch-exporter'
  static_configs:
  - targets:
    - *.*.*.113:9597
    - *.*.*.114:9597
    - *.*.*.115:9597

- job_name: 'zookeeper-exporter'
  static_configs:
  - targets:
    - *.*.*.113:9595
    - *.*.*.114:9595
    - *.*.*.115:9595

- job_name: 'nginx-exporter'
  static_configs:
  - targets:
    - *.*.*.113:9593
    - *.*.*.114:9593
    - *.*.*.115:9593

- job_name: 'redis-exporter'
  static_configs:
  - targets:
    - *.*.*.113:9594

- job_name: 'redis-exporter-targets'
  static_configs:
    - targets:
      - redis://*.*.*.113:7090
      - redis://*.*.*.114:7090
      - redis://*.*.*.115:7091
  metrics_path: /scrape
  relabel_configs:
    - source_labels: [__address__]
      target_label: __param_target
    - source_labels: [__param_target]
      target_label: instance
    - target_label: __address__
      replacement: *.*.*.113:9594
EOF

• Luego, estas configuraciones de monitoreo deben almacenarse en el clúster k8s como un tipo de recurso secreto:

$ kubectl create secret generic additional-scrape-configs --from-file=prometheus-additional.yaml -n monitoring

② Modificar el archivo de Prometheus

• AdditionalScrapeConfigs: Agregar configuración de elemento de monitoreo adicional:

$ vi prometheus-prometheus.yaml

• Agregue lo siguiente:

additionalScrapeConfigs:
    name: additional-scrape-configs
    key: prometheus-additional.yaml

• examinar:

$ grep -n -C5 'additionalScrapeConfigs' prometheus-prometheus.yaml

• La configuración surte efecto:

$ kubectl apply -f prometheus-prometheus.yaml