Come monitorare Kubernetes con Prometeo

Introduzione

Prometheus è un framework di strumentazione open source. Prometheus può assorbire enormi quantità di dati ogni secondo, il che lo rende adatto a carichi di lavoro complessi.

Usa Prometheus per monitorare i tuoi server, VM, database e attingere a quei dati per analizzare le prestazioni delle tue applicazioni e della tua infrastruttura.

Questo articolo spiega come configurare il monitoraggio Prometheus in un cluster Kubernetes.

Prerequisiti

• Un cluster Kubernetes
• Un kubectl completamente configurato interfaccia a riga di comando sul tuo computer locale

Monitoraggio del cluster Kubernetes con Prometheus

Prometheus è un sistema basato su pull. Invia una richiesta HTTP, un cosiddetto scrape , in base alla configurazione definita nel file di distribuzione . La risposta a questo scrape la richiesta viene archiviata e analizzata nello spazio di archiviazione insieme alle metriche per lo scrape stesso.

Lo storage è un database personalizzato sul server Prometheus e può gestire un enorme afflusso di dati. È possibile monitorare migliaia di macchine contemporaneamente con un unico server.

I dati devono essere opportunamente esposti e formattati in modo che Prometheus possa raccoglierli. Prometheus può accedere ai dati direttamente dalle librerie client dell'app o utilizzando gli esportatori.

Esportatori vengono utilizzati per i dati sui quali non si ha il pieno controllo (ad esempio, le metriche del kernel). Un esportatore è un pezzo di software posizionato accanto alla tua applicazione. Il suo scopo è accettare richieste HTTP da Prometheus, assicurarsi che i dati siano in un formato supportato e quindi fornire i dati richiesti al server Prometheus.

Tutte le tue applicazioni sono ora attrezzate per fornire dati a Prometheus. Dobbiamo ancora informare Prometheus dove cercare quei dati. Prometheus rileva gli obiettivi da cui raschiare utilizzando Service Discovery .

Il tuo cluster Kubernetes ha già etichette e annotazioni e un eccellente meccanismo per tenere traccia delle modifiche e dello stato dei suoi elementi. Quindi, Prometheus utilizza l'API Kubernetes per scoprire i target.

Le scoperte del servizio Kubernetes che puoi esporre a Prometheus sono:

• nodo
• endpoint
• servizio
• pod
• ingresso

Prometheus recupera le metriche a livello di macchina separatamente dalle informazioni sull'applicazione. L'unico modo per esporre le metriche di memoria, spazio su disco, utilizzo della CPU e larghezza di banda è utilizzare un esportatore di nodi . Inoltre, è necessario esporre anche le metriche relative ai cgroup.

Fortunatamente, l'esportatore cAdvisor è già incorporato a livello di nodo Kubernetes e può essere facilmente esposto.

Una volta che il sistema ha raccolto i dati, puoi accedervi utilizzando il linguaggio di query PromQL , esportarli in interfacce grafiche come Grafana o utilizzarli per inviare avvisi con Alertmanager.

Installa Prometheus Monitoring su Kubernetes

Il monitoraggio di Prometheus può essere installato su un cluster Kubernetes utilizzando un set di file YAML (Yet Another Markup Language). Questi file contengono configurazioni, autorizzazioni e servizi che consentono a Prometheus di accedere alle risorse ed estrarre informazioni estraendo gli elementi del tuo cluster.

I file YAML sono facilmente tracciabili, modificati e possono essere riutilizzati all'infinito. I file presentati in questo tutorial sono prontamente e gratuitamente disponibili in repository online come GitHub.

Crea spazio dei nomi di monitoraggio

Tutte le risorse in Kubernetes vengono avviate in uno spazio dei nomi. A meno che non ne venga specificato uno, il sistema utilizza lo spazio dei nomi predefinito. Per avere un migliore controllo sul processo di monitoraggio del cluster, specificheremo uno spazio dei nomi di monitoraggio.

Il nome dello spazio dei nomi deve essere un'etichetta compatibile con DNS. Per una facile consultazione, chiameremo lo spazio dei nomi:monitoraggio .

Esistono due modi per creare uno spazio dei nomi di monitoraggio per il recupero delle metriche dall'API Kubernetes.

Opzione 1:

Inserisci questo semplice comando nell'interfaccia della riga di comando e crea il monitoraggio namespace sul tuo host:

kubectl create namespace monitoring

Opzione 2:

Crea e applica un file .yml:

apiVersion: v1
kind: Namespace
metadata:
  name: monitoring

Questo metodo è conveniente in quanto puoi distribuire lo stesso file in istanze future. Applica il file al tuo cluster immettendo il seguente comando nel tuo terminale di comando:

kubectl -f apply namespace monitoring.yml

Indipendentemente dal metodo utilizzato, elenca gli spazi dei nomi esistenti utilizzando questo comando:

kubectl get namespaces

Configura il file di distribuzione di Prometheus

La sezione seguente contiene gli elementi necessari per impostare correttamente lo scraping Prometheus sul cluster Kubernetes e sui suoi elementi.

Le sezioni possono essere implementate come singoli .yml file eseguiti in sequenza. Dopo aver creato ciascun file, è possibile applicarlo immettendo il seguente comando:

kubectl -f apply [name_of_file].yml

In questo esempio, tutti gli elementi vengono inseriti in un unico .yml file e applicati contemporaneamente.

Il prometheus.yml nel nostro esempio indica il kubectl per inviare una richiesta al server API Kubernetes. Il file contiene:

1. Autorizzazioni che consentono a Prometheus di accedere a tutti i pod e nodi.
2. Il Prometeo configMap che definisce quali elementi devono essere scartati.
3. Istruzioni per l'implementazione di Prometheus.
4. Un servizio che ti dà accesso all'interfaccia utente di Prometheus.

Ruolo cluster, account di servizio e associazione ruolo cluster

Gli spazi dei nomi sono progettati per limitare le autorizzazioni dei ruoli predefiniti se vogliamo recuperare dati a livello di cluster di cui abbiamo bisogno per consentire a Prometheus l'accesso a tutte le risorse di quel cluster. Un file Prometheus .yml di base che fornisce l'accesso a livello di cluster ha i seguenti elementi:

1. Definisci il ruolo del cluster

I verbi su ogni regola definiscono le azioni che il ruolo può intraprendere sugli apiGroup.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: prometheus
rules:
- apiGroups: [""]
  resources:
  - nodes
  - services
  - endpoints
  - pods
  verbs: ["get", "list", "watch"]
- apiGroups:
  - extensions
  resources:
  - ingresses
  verbs: ["get", "list", "watch"]

2. Crea un account di servizio

Inoltre, dobbiamo creare un account di servizio per applicare questo ruolo a:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: prometheus
  namespace: monitoring

3. Applicare ClusterRoleBinding

Infine, dobbiamo applicare un ClusterRoleBinding . Questa azione collegherà l'account di servizio al ruolo cluster creato in precedenza.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: prometheus
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus
subjects:
- kind: ServiceAccount
  name: prometheus
  namespace: monitoring

Aggiungendo queste risorse al nostro file, abbiamo concesso a Prometheus l'accesso a livello di cluster dal monitoraggio spazio dei nomi.

Mappa di configurazione Prometeo

Questa sezione del file fornisce le istruzioni per il processo di scraping. Le istruzioni specifiche per ciascun elemento del cluster Kubernetes devono essere personalizzate per soddisfare i requisiti di monitoraggio e la configurazione del cluster.

1. Regole globali di scraping

apiVersion: v1
data:
  prometheus.yml: |
    global:
      scrape_interval: 10s

2. Nodo di raschiatura

Questo rilevamento del servizio espone i nodi che compongono il tuo cluster Kubernetes. Il kubelet gira su ogni singolo nodo ed è una fonte di informazioni preziose.

2.1 Scrape kubelet

    scrape_configs:
    - job_name: 'kubelet'
      kubernetes_sd_configs:
      - role: node
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required with Minikube.

2.2 Scrape cAdvisor (informazioni a livello di contenitore)

Il kubelet fornisce solo informazioni su se stesso e non sui contenitori. Per ricevere informazioni dal livello del contenitore, dobbiamo utilizzare un esportatore. Il cAdvisor è già incorporato e richiede solo un metrics_path : /metrics/cadvisor affinché Prometheus raccolga i dati dei container:

    - job_name: 'cadvisor'
      kubernetes_sd_configs:
      - role: node
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required with Minikube.
      metrics_path: /metrics/cadvisor

3. Scrape APIServer

Utilizza il ruolo degli endpoint per scegliere come destinazione ogni istanza dell'applicazione. Questa sezione del file ti consente di eseguire lo scraping dei server API nel tuo cluster Kubernetes.

    - job_name: 'k8apiserver'
      kubernetes_sd_configs:
      - role: endpoints
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required if using Minikube.
      bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
      relabel_configs:
   - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
        action: keep
        regex: default;kubernetes;https

4. Scrape Pods per i servizi Kubernetes (esclusi i server API)

Raschia i pod che supportano tutti i servizi Kubernetes e ignora le metriche del server API.

- job_name: 'k8services'
      kubernetes_sd_configs:
      - role: endpoints
      relabel_configs:
      - source_labels:
          - __meta_kubernetes_namespace
          - __meta_kubernetes_service_name
        action: drop
        regex: default;kubernetes
      - source_labels:
          - __meta_kubernetes_namespace
        regex: default
        action: keep
      - source_labels: [__meta_kubernetes_service_name]
        target_label: job

5. Ruolo Pod

Scopri tutte le porte pod con le metriche del nome utilizzando il nome del contenitore come etichetta del lavoro.

- job_name: 'k8pods'
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__meta_kubernetes_pod_container_port_name]
        regex: metrics
        action: keep
      - source_labels: [__meta_kubernetes_pod_container_name]
        target_label: job
kind: ConfigMap
metadata:
  name: prometheus-config

6. Configura ReplicaSet

Definisci il numero di repliche di cui hai bisogno e un modello da applicare all'insieme definito di pod.

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: prometheus
spec:
  selector:
    matchLabels:
      app: prometheus
  replicas: 1
  template:
    metadata:
      labels:
        app: prometheus
    spec:
      serviceAccountName: prometheus
      containers:
      - name: prometheus
        image: prom/prometheus:v2.1.0
        ports:
        - containerPort: 9090
          name: default
        volumeMounts:
        - name: config-volume
          mountPath: /etc/prometheus
      volumes:
      - name: config-volume
        configMap:
         name: prometheus-config

7. Definisci nodePort

Prometheus è attualmente in esecuzione nel cluster. Aggiunta della seguente sezione al nostro prometheus.yml ci darà accesso ai dati raccolti da Prometheus.

kind: Service
apiVersion: v1
metadata:
  name: prometheus
spec:
  selector:
    app: prometheus
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 9090
    targetPort: 9090
    nodePort: 30909

Applica il file prometheus.yml

La mappa di configurazione definita nel file fornisce i dati di configurazione a ogni pod della distribuzione:

kubectl apply -f prometheus.yml

Utilizza l'URL del singolo nodo e la nodePort definita in prometheus.yml file per accedere a Prometheus dal tuo browser. Ad esempio:

http://192.153.99.106:30909

Inserendo l'URL o l'IP del tuo nodo e specificando la porta dal file yml, hai ottenuto con successo l'accesso a Prometheus Monitoring.

Come monitorare kube-state-metrics? (Facoltativo)

Ora puoi monitorare completamente la tua infrastruttura Kubernetes, così come le tue istanze dell'applicazione. Tuttavia, questo non include le metriche sulle informazioni che Kubernetes ha sulle risorse nel tuo cluster.

Il kube-state-metrics è un esportatore che consente a Prometheus di raccogliere anche queste informazioni. Crea un file YAML per l'esportatore kube-state-metrics:

---
apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: kube-state-metrics
spec:
  selector:
    matchLabels:
      app: kube-state-metrics
  replicas: 1
  template:
    metadata:
      labels:
        app: kube-state-metrics
    spec:
      serviceAccountName: prometheus
      containers:
      - name: kube-state-metrics
        image: quay.io/coreos/kube-state-metrics:v1.2.0
        ports:
        - containerPort: 8080
          name: monitoring
---
kind: Service
apiVersion: v1
metadata:
  name: kube-state-metrics
spec:
  selector:
    app: kube-state-metrics
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080

Applicare il file immettendo il seguente comando:

kubectl apply -f kube-state-metrics.yml

Una volta applicato il file, accedi a Prometheus inserendo l'IP/URL del nodo e definendo nodePort come precedentemente definito.