ProHoster > Blog > administration > Loki - indsamling af logs ved hjælp af Prometheus-tilgangen

Loki - indsamling af logs ved hjælp af Prometheus-tilgangen

Hils, Khabroviter! I forventning om start af ny tilmelding til kurset "DevOps-praksis og værktøjer" udarbejdet en oversættelse af interessant materiale til dig.

Denne artikel er en kort introduktion til Loki. Projekt Loke støttet af Grafana og er rettet mod centraliseret indsamling af logfiler (fra servere eller containere).

Hovedinspirationen for Loke var Prometheus med ideen om at anvende hans tilgange til logstyring:

  • bruge etiketter til at gemme data
  • lavt ressourceforbrug

Vi vil vende tilbage til principperne for Prometheus og give nogle eksempler på dets brug i forbindelse med Kubernetes.

Et par ord om Prometheus

For fuldt ud at forstå, hvordan Loki fungerer, er det vigtigt at tage et skridt tilbage og gense Prometheus lidt.

Et af de karakteristiske kendetegn ved Prometheus er udtrækning af metrikker fra indsamlingssteder (via eksportører) og lagring af dem i en TSDB (Time Series Data Base, tidsseriedatabase) med tilføjelse af metadata i form af etiketter.

Hvorfor er det nødvendigt

For nylig er Prometheus blevet de facto-standarden i containernes og Kubernetes-verdenen: installationen er meget enkel, og en Kubernetes-klynge har oprindeligt et slutpunkt for Prometheus. Prometheus kan også udtrække metrics fra applikationer, der er implementeret i en container, samtidig med at specifikke etiketter bevares. Derfor er applikationsovervågning meget let at implementere.

Desværre er der stadig ingen nøglefærdig løsning til logstyring, og du skal selv finde en løsning:

  • administreret cloud-tjeneste til centralisering af logfiler (AWS, Azure eller Google)
  • overvågningstjeneste "overvågning som en tjeneste" (for eksempel Datadog)
  • oprette din egen logindsamlingstjeneste.

Til den tredje mulighed har jeg traditionelt brugt Elasticsearch, på trods af at jeg ikke altid var tilfreds med den (især dens tyngde og kompleksitet i opsætningen).

Loki er designet til at være let at implementere i henhold til følgende principper:

  • være let at starte
  • forbruge få ressourcer
  • arbejde selvstændigt uden særlig vedligeholdelse
  • tjene som en tilføjelse til Prometheus for at hjælpe med fejlundersøgelser

Denne enkelhed kommer dog på bekostning af nogle kompromiser. En af dem er ikke at indeksere indholdet. Derfor er tekstsøgning ikke særlig effektiv eller rig og giver dig ikke mulighed for at føre statistik over tekstens indhold. Men da Loki ønsker at være grep-ækvivalenten og komplementet til Prometheus, er dette ikke en ulempe.

Hændelsesundersøgelse

For bedre at forstå, hvorfor Loki ikke har brug for indeksering, lad os gå tilbage til hændelsesundersøgelsesmetoden, som Loki-udviklerne brugte:

Loki - indsamling af logs ved hjælp af Prometheus-tilgangen
1 Alert → 2 Dashboard → 3 Adhoc-forespørgsel → 4 Log-aggregation → 5 Distribueret sporing → 6 Fix!
(1 Advarsel → 2 Dashboard → 3 Adhoc-forespørgsel → 4 Log Aggregation → 5 Distributed Tracing → 6 Fix!)

Tanken er, at vi får en form for alarm (Slack Notification, SMS osv.) og derefter:

  • se på Grafana dashboards
  • se på servicemålinger (for eksempel i Prometheus)
  • se på logposter (for eksempel i Elasticsearch)
  • måske tage et kig på distribuerede spor (Jaeger, Zipkin osv.)
  • og endelig fikse det oprindelige problem.

Her, i tilfældet med Grafana + Prometheus + Elasticsearch + Zipkin-stakken, skal du bruge fire forskellige værktøjer. For at spare tid ville det være rart at kunne udføre alle disse trin med ét værktøj: Grafana. Det er værd at bemærke, at denne tilgang til forskning har været implementeret i Grafana siden version 6. Dermed bliver det muligt at tilgå Prometheus-data direkte fra Grafana.

Loki - indsamling af logs ved hjælp af Prometheus-tilgangen
Explorer-skærmen er delt mellem Prometheus og Loki

Fra denne skærm kan du se logfiler i Loki relateret til Prometheus-metrikker ved hjælp af split screen-konceptet. Siden version 6.5 giver Grafana dig mulighed for at analysere sporings-id'et i Loki-logposter for at følge links til dine foretrukne distribuerede sporingsværktøjer (Jaeger).

Loki lokal test

Den nemmeste måde at teste Loki lokalt er at bruge docker-compose. Docker-compose-filen er placeret i Loki-depotet. Du kan få depotet med følgende kommando git:

$ git clone https://github.com/grafana/loki.git

Så skal du skifte til produktionskataloget:

$ cd production

Derefter kan du få de seneste Docker-billeder:

$ docker-compose pull

Til sidst startes Loki-stakken med følgende kommando:

$ docker-compose up

Loki arkitektur

Her er et lille diagram med Loki-arkitektur:

Loki - indsamling af logs ved hjælp af Prometheus-tilgangen
Loki arkitekturprincipper

Webklienten kører applikationer på serveren, Promtail samler logs og sender dem til Loki, webklienten sender også metadata til Loki. Loke samler alt og giver det videre til Grafana.
Loke løber. For at se de tilgængelige komponenter skal du køre følgende kommando:

$ docker ps

I tilfælde af en nyinstalleret Docker, skal kommandoen returnere følgende resultat:

IMAGE               PORTS                  NAMES
grafana/promtail:                          production_promtail_1
grafana/grafana: m  0.0.0.0:3000->3000/tcp production_grafana_1
grafana/loki: late  80/tcp,0.0.0.0:3100... production_loki_1

Vi ser følgende komponenter:

  • Promtail: agent ansvarlig for centralisering af logfiler
  • Grafana: det berømte instrumentbrætværktøj
  • Loki: datacentraliseringsdæmon

Som en del af en klassisk infrastruktur (f.eks. baseret på virtuelle maskiner) skal Promtail-agenten installeres på hver maskine. Grafana og Loki kan installeres på samme maskine.

Implementering til Kubernetes

Installation af Loki-komponenter i Kubernetes vil være som følger:

  • daemonSet til at implementere Promtail-agenten på hver af maskinerne i serverklyngen
  • Loki-udrulning
  • og den sidste er indsættelsen af ​​Grafana.

Heldigvis er Loki tilgængelig som en Helm-pakke, hvilket gør det nemt at implementere.

Montering via Heml

Du burde allerede have Heml installeret. Det kan downloades fra projektets GitHub-lager. Det installeres ved at udtrække det arkiv, der passer til din arkitektur og tilføje ror til $PATH.

Note: version 3.0.0 af Helm blev udgivet for nylig. Da der er sket mange ændringer i den, rådes læseren til at vente lidt, før den begynder at bruge den..

Tilføjelse af kilde til Helm

Det første trin er at tilføje "loki"-depotet med følgende kommando:

$ helm add loki https://grafana.github.io/loki/charts

Derefter kan du søge efter pakker med navnet "loki":

$ helm search loki

Resultat:

loki/loki       0.17.2 v0.4.0 Loki: like Prometheus, but for logs.
loki/loki-stack 0.19.1 v0.4.0 Loki: like Prometheus, but for logs.
loki/fluent-bit 0.0.2  v0.0.1 Uses fluent-bit Loki go plugin for...
loki/promtail   0.13.1 v0.4.0 Responsible for gathering logs and...

Disse pakker har følgende funktioner:

  • пакет loki/loki matcher kun Loki-serveren
  • пакет loki/flydende-bit giver dig mulighed for at implementere DaemonSet ved hjælp af fluent-bin til at indsamle logfiler i stedet for Promtail
  • пакет loki/promtail indeholder en logindsamlingsagent
  • пакет loki/loki-stak, giver dig mulighed for straks at implementere Loki sammen med Promtail.

Installation af Loki

For at implementere Loki til Kubernetes skal du køre følgende kommando i "monitoring"-navnerummet:

$ helm upgrade --install loki loki/loki-stack --namespace monitoring

Tilføj indstillingen for at gemme på disk --set loki.persistence.enabled = true:

$ helm upgrade --install loki loki/loki-stack 
              --namespace monitoring 
              --set loki.persistence.enabled=true

Note: hvis du vil installere Grafana på samme tid, skal du tilføje parameteren --set grafana.enabled = true

Når du kører denne kommando, bør du få følgende output:

LAST DEPLOYED: Tue Nov 19 15:56:54 2019
NAMESPACE: monitoring
STATUS: DEPLOYED
RESOURCES:
==> v1/ClusterRole
NAME AGE
loki-promtail-clusterrole 189d
…
NOTES:
The Loki stack has been deployed to your cluster. Loki can now be added as a datasource in Grafana.
See <a href="http://docs.grafana.org/features/datasources/loki/">http://docs.grafana.org/features/datasources/loki/</a> for more details.

Når vi ser på tilstanden af ​​pods i "overvågnings"-navnerummet, kan vi se, at alt er implementeret:

$ kubectl -n monitoring get pods -l release=loki

Resultat:

NAME                 READY  STATUS   RESTARTS  AGE
loki-0               1/1    Running  0         147m
loki-promtail-9zjvc  1/1    Running  0         3h25m
loki-promtail-f6brf  1/1    Running  0         11h
loki-promtail-hdcj7  1/1    Running  0         3h23m
loki-promtail-jbqhc  1/1    Running  0         11h
loki-promtail-mj642  1/1    Running  0         62m
loki-promtail-nm64g  1/1    Running  0         24m

Alle pods kører. Nu er det tid til at lave nogle tests!

Tilslutning til Grafana

For at oprette forbindelse til Grafana under Kubernetes, skal du åbne en tunnel til dens pod. Følgende er kommandoen til at åbne port 3000 for en Grafana pod:

$ kubectl -n port-forward monitoring svc/loki-grafana 3000:80

Et andet vigtigt punkt er behovet for at gendanne Grafana-administratoradgangskoden. Adgangskoden holdes hemmelig loki-grafana i marken .data.admin-user i base64-format.

For at gendanne den skal du køre følgende kommando:

$ kubectl -n monitoring get secret loki-grafana 
 --template '{{index .data "admin-password" | base64decode}}'; echo

Brug denne adgangskode sammen med standardadministratorkontoen (admin).

Loki datakildedefinition i Grafana

Først og fremmest skal du sørge for, at Loki-datakilden (konfiguration / datakilde) er oprettet.
Her er et eksempel:

Loki - indsamling af logs ved hjælp af Prometheus-tilgangen
Et eksempel på opsætning af en datakilde for Loki

Ved at klikke på "Test" kan du teste forbindelsen med Loki.

Forespørgsler til Loke

Gå nu til Grafana og gå til sektionen "Udforsk". Når Loki modtager logfiler fra containere, tilføjer Loki metadata fra Kubernetes. Dermed bliver det muligt at se logfilerne for en specifik container.

For at vælge promtail-containerlogfiler kan du f.eks. bruge følgende forespørgsel: {container_name = "promtail"}.
Glem ikke at vælge Loki-datakilden her også.

Denne forespørgsel returnerer containeraktivitet som følger:

Loki - indsamling af logs ved hjælp af Prometheus-tilgangen
Forespørgselsresultat i Grafana

Tilføjes til dashboardet

Fra Grafana 6.4 er det muligt at lægge logoplysninger direkte på dashboardet. Derefter vil brugeren hurtigt kunne skifte mellem antallet af anmodninger på sit websted til applikationsspor.

Nedenfor er et eksempel på et dashboard, der implementerer denne interaktion:

Loki - indsamling af logs ved hjælp af Prometheus-tilgangen
Eksempel på dashboard med Prometheus-metrik og Loki-logfiler

Lokis fremtid

Jeg begyndte at bruge Loki tilbage i maj/juni med version 0.1. Version 1 er allerede blevet frigivet i dag, og endda 1.1 og 1.2.

Det må indrømmes, at version 0.1 ikke var stabil nok. Men 0.3 viste allerede reelle tegn på modenhed, og de næste versioner (0.4, derefter 1.0) forstærkede kun dette indtryk.

Efter 1.0.0 kan ingen have en undskyldning for ikke at bruge dette vidunderlige værktøj.

Yderligere forbedringer bør ikke handle om Loki, men snarere dens integration med den fremragende Grafana. Faktisk har Grafana 6.4 allerede god integration med dashboards.

Grafana 6.5, som blev udgivet for nylig, forbedrer denne integration yderligere ved automatisk at genkende indholdet af logfiler i JSON-format.

Videoen nedenfor viser et lille eksempel på denne mekanisme:

Loki - indsamling af logs ved hjælp af Prometheus-tilgangen
Brug af Loki-strenge gengivet i Grafana

Det bliver muligt at bruge et af JSON-felterne, for eksempel til at:

  • links til et eksternt værktøj
  • filtrering af logindhold

For eksempel kan du klikke på traceId for at gå til Zipkin eller Jaeger.

Som sædvanlig ser vi frem til dine kommentarer og inviterer dig til åbent webinar, hvor vi vil tale om, hvordan DevOps-industrien har udviklet sig i løbet af 2019 og diskutere mulige udviklingsveje for 2020.

Kilde: www.habr.com