Jak monitorovat Kubernetes pomocí Prometheus

Úvod

Prometheus je open-source instrumentační framework. Prometheus dokáže absorbovat obrovské množství dat každou sekundu, takže se dobře hodí pro komplexní pracovní zátěž.

Použijte Prometheus k monitorování serverů, virtuálních počítačů, databází a na základě těchto dat analyzujte výkon vašich aplikací a infrastruktury.

Tento článek vysvětluje, jak nastavit monitorování Prometheus v clusteru Kubernetes.

Předpoklady

• Cluster Kubernetes
• Plně nakonfigurovaný kubectl rozhraní příkazového řádku na vašem místním počítači

Monitorování Kubernetes Cluster pomocí Prometheus

Prometheus je systém založený na tahu. Odešle HTTP požadavek, tzv. scrape , na základě konfigurace definované v souboru nasazení . Odpověď na toto scrape požadavek je uložen a analyzován v úložišti spolu s metrikami pro samotný scrape.

Úložiště je vlastní databáze na serveru Prometheus a dokáže zvládnout masivní příliv dat. Je možné sledovat tisíce strojů současně pomocí jediného serveru.

Data musí být náležitě vystavena a naformátována, aby je společnost Prometheus mohla shromažďovat. Prometheus může přistupovat k datům přímo z klientských knihoven aplikace nebo pomocí exportérů.

Vývozci se používají pro data, která nemáte plně pod kontrolou (například metriky jádra). Exportér je část softwaru umístěná vedle vaší aplikace. Jeho účelem je přijímat požadavky HTTP od společnosti Prometheus, ujistit se, že data jsou v podporovaném formátu, a poté poskytnout požadovaná data serveru Prometheus.

Všechny vaše aplikace jsou nyní vybaveny tak, aby poskytovaly data společnosti Prometheus. Stále musíme informovat Promethea, kde tato data hledat. Prometheus zjišťuje cíle, ze kterých lze seškrábat, pomocí Zjišťování služeb .

Váš cluster Kubernetes již má štítky a anotace a vynikající mechanismus pro sledování změn a stavu jeho prvků. Proto Prometheus používá Kubernetes API k objevování cílů.

Objevy služby Kubernetes, které můžete vystavit Prometheus, jsou:

• uzel
• koncový bod
• služba
• pod
• vstup

Prometheus získává metriky na úrovni stroje odděleně od informací o aplikaci. Jediný způsob, jak odhalit metriky paměti, místa na disku, využití procesoru a šířky pásma, je použití exportéru uzlů . Kromě toho je třeba odhalit také metriky o cgroups.

Naštěstí je exportér cAdvisor již zabudován na úrovni uzlu Kubernetes a lze jej snadno zpřístupnit.

Jakmile systém shromáždí data, můžete k nim přistupovat pomocí dotazovacího jazyka PromQL, exportovat je do grafických rozhraní, jako je Grafana, nebo je používat k odesílání upozornění pomocí Správce upozornění.

Nainstalujte Prometheus Monitoring na Kubernetes

Monitorování Prometheus lze nainstalovat do clusteru Kubernetes pomocí sady souborů YAML (Yet Another Markup Language). Tyto soubory obsahují konfigurace, oprávnění a služby, které společnosti Prometheus umožňují přistupovat ke zdrojům a získávat informace seškrabováním prvků vašeho clusteru.

Soubory YAML lze snadno sledovat, upravovat a lze je neomezeně dlouho znovu používat. Soubory uvedené v tomto tutoriálu jsou snadno a volně dostupné v online repozitářích, jako je GitHub.

Vytvoření jmenného prostoru monitorování

Všechny prostředky v Kubernetes jsou spuštěny v oboru názvů. Pokud není specifikován, systém používá výchozí jmenný prostor. Abychom měli lepší kontrolu nad procesem monitorování clusteru, určíme jmenný prostor monitorování.

Název jmenného prostoru musí být štítek kompatibilní s DNS. Pro snadnou orientaci pojmenujeme jmenný prostor:monitoring .

Existují dva způsoby, jak vytvořit monitorovací jmenný prostor pro načítání metrik z Kubernetes API.

Možnost 1:

Zadejte tento jednoduchý příkaz do rozhraní příkazového řádku a vytvořte monitorování jmenný prostor na vašem hostiteli:

kubectl create namespace monitoring

Možnost 2:

Vytvořte a použijte soubor .yml:

apiVersion: v1
kind: Namespace
metadata:
  name: monitoring

Tato metoda je pohodlná, protože stejný soubor můžete nasadit v budoucích instancích. Použijte soubor na svůj cluster zadáním následujícího příkazu do příkazového terminálu:

kubectl -f apply namespace monitoring.yml

Bez ohledu na použitou metodu vypište existující jmenné prostory pomocí tohoto příkazu:

kubectl get namespaces

Konfigurace souboru nasazení Prometheus

Následující část obsahuje prvky nezbytné k úspěšnému nastavení stírání Prometheus ve vašem clusteru Kubernetes a jeho prvcích.

Sekce lze implementovat jako jednotlivé .yml soubory spouštěné v pořadí. Po vytvoření každého souboru jej lze použít zadáním následujícího příkazu:

kubectl -f apply [name_of_file].yml

V tomto příkladu jsou všechny prvky umístěny do jednoho .yml soubor a aplikované současně.

Soubor prometheus.yml soubor v našem příkladu instruuje kubectl odeslat požadavek na server Kubernetes API. Soubor obsahuje:

1. Oprávnění, která společnosti Prometheus umožňují přístup ke všem podům a uzlům.
2. Prometheus configMap který definuje, které prvky by měly být vyřazeny.
3. Pokyny k nasazení Prometheus.
4. Služba, která vám umožňuje přístup k uživatelskému rozhraní Prometheus.

Role clusteru, servisní účet a vazba role clusteru

Jmenné prostory jsou navrženy tak, aby omezovaly oprávnění výchozích rolí, pokud chceme získat data z celého clusteru, která potřebujeme, abychom společnosti Prometheus poskytli přístup ke všem zdrojům tohoto clusteru. Základní soubor .yml Prometheus, který poskytuje přístup pro celý cluster, má následující prvky:

1. Definujte roli clusteru

Slovesa v každém pravidle definují akce, které může role provádět na apiGroups.

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. Vytvořte servisní účet

Kromě toho musíme vytvořit účet služby, abychom mohli použít tuto roli:

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

3. Použijte ClusterRoleBinding

Nakonec musíme použít ClusterRoleBinding . Tato akce naváže účet služby na dříve vytvořenou roli clusteru.

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

Přidáním těchto zdrojů do našeho souboru jsme společnosti Prometheus udělili přístup k celému clusteru z monitorování jmenný prostor.

Prometheus ConfigMap

Tato část souboru poskytuje pokyny pro proces škrábání. Konkrétní pokyny pro každý prvek clusteru Kubernetes by měly být přizpůsobeny tak, aby odpovídaly vašim požadavkům na monitorování a nastavení clusteru.

1. Globální pravidla stírání

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

2. Scrape Node

Toto zjišťování služby odhaluje uzly, které tvoří váš cluster Kubernetes. Kubelet běží na každém jednotlivém uzlu a je zdrojem cenných informací.

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 (informace o úrovni kontejneru)

kubelet poskytuje pouze informace o sobě, nikoli o kontejnerech. Abychom mohli přijímat informace z úrovně kontejneru, musíme použít exportér. CAdvisor je již vložen a potřebuje pouze metrics_path : /metrics/cadvisor pro společnost Prometheus shromažďovat data kontejneru:

    - 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

Použijte roli koncových bodů k zacílení každé instance aplikace. Tato část souboru vám umožňuje smazat servery API ve vašem clusteru 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 pro služby Kubernetes (kromě serverů API)

Odstraňte pody podporující všechny služby Kubernetes a ignorujte metriky serveru 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. Role pod

Objevte všechny porty podů s metrikami názvu pomocí názvu kontejneru jako štítku úlohy.

- 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. Konfigurace ReplicaSet

Definujte počet replik, které potřebujete, a šablonu, která se má použít na definovanou sadu modulů.

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. Definujte nodePort

Prometheus aktuálně běží v clusteru. Přidání následující sekce do našeho prometheus.yml soubor nám poskytne přístup k údajům, které Prometheus shromáždil.

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

Použít soubor prometheus.yml

Konfigurační mapa definovaná v souboru poskytuje konfigurační data každému modulu v nasazení:

kubectl apply -f prometheus.yml

Použijte URL jednotlivého uzlu a nodePort definované v prometheus.yml pro přístup k Prometheus z vašeho prohlížeče. Například:

http://192.153.99.106:30909

Zadáním URL nebo IP vašeho uzlu a určením portu ze souboru yml jste úspěšně získali přístup k Prometheus Monitoring.

Jak sledovat metriky kube-state-metrics? (Volitelné)

Nyní můžete plně monitorovat infrastrukturu Kubernetes a také instance aplikací. To však nezahrnuje metriky informací, které má Kubernetes o prostředcích ve vašem clusteru.

Metrika kube-state-metrics je exportér, který společnosti Prometheus umožňuje seškrábat i tyto informace. Vytvořte soubor YAML pro exportér 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

Použijte soubor zadáním následujícího příkazu:

kubectl apply -f kube-state-metrics.yml

Jakmile použijete soubor, otevřete Prometheus zadáním IP/URL uzlu a definovaného nodePort, jak bylo definováno dříve.