ProHoster > Log > administrasjon > Loki - loggsamling ved hjelp av Prometheus-tilnærmingen

Loki - loggsamling ved hjelp av Prometheus-tilnærmingen

Hils, innbyggere i Khabrovsk! På tampen av starten av en ny påmelding til kurset "DevOps-praksis og verktøy" Vi har utarbeidet en oversettelse av interessant materiale for deg.

Denne artikkelen er en kort introduksjon til Loki. Prosjekt Loke støttet av Grafana og er rettet mot sentralisert innsamling av logger (fra servere eller containere).

Hovedinspirasjonen for Loke var Prometheus med ideen om å bruke hans tilnærminger til loggadministrasjon:

  • bruke etiketter for å lagre data
  • forbruk av få ressurser

Vi kommer tilbake til hvordan Prometheus fungerer og gir noen eksempler på bruken i Kubernetes-sammenheng.

Noen få ord om Prometheus

For å forstå hvordan Loki fungerer, er det viktig å ta et skritt tilbake og huske litt om Prometheus.

Et av særtrekkene til Prometheus er utvinning av beregninger fra innsamlingspunkter (via eksportører) og lagring av dem i TSDB (Time Series Data Base), med tillegg av metadata i form av etiketter.

Hvorfor trenger du det

Nylig har Prometheus blitt de facto-standarden i verden av containere og Kubernetes: installasjonen er veldig enkel, og Kubernetes-klyngen kommer med et innfødt endepunkt for Prometheus. Prometheus kan også trekke ut beregninger fra applikasjoner som er distribuert i en beholder mens du lagrer spesifikke etiketter. Derfor er applikasjonsovervåking veldig enkelt å implementere.

Dessverre finnes det fortsatt ingen nøkkelferdig løsning for logghåndtering, og du må finne en løsning selv:

  • administrert skytjeneste for sentralisering av logger (AWS, Azure eller Google)
  • overvåkingstjeneste "overvåking som en tjeneste" (for eksempel Datadog)
  • lage din egen logginnsamlingstjeneste.

For det tredje alternativet brukte jeg tradisjonelt Elasticsearch, til tross for at jeg ikke alltid var fornøyd med det (spesielt dens tyngde og kompleksitet i konfigurasjonen).

Loki ble designet for å forenkle implementeringen i henhold til følgende prinsipper:

  • være enkel å starte
  • bruker få ressurser
  • arbeide selvstendig uten noe spesielt vedlikehold
  • tjene som et tillegg til Prometheus for å hjelpe med feilundersøkelser

Denne enkelheten går imidlertid på bekostning av noen kompromisser. En av dem er å ikke indeksere innholdet. Derfor er tekstsøk ikke særlig effektivt eller rikt og tillater ikke statistikk over innholdet i teksten. Men siden Loki ønsker å være ekvivalent med grep og et supplement til Prometheus, er ikke dette en ulempe.

Hendelsesundersøkelse

For bedre å forstå hvorfor Loki ikke trenger indeksering, la oss gå tilbake til hendelsesundersøkelsesmetoden som Loki-utviklerne brukte:

Loki - loggsamling ved hjelp av Prometheus-tilnærmingen
1 Alert → 2 Dashboard → 3 Adhoc Query → 4 Loggaggregering → 5 Distribuert sporing → 6 Fix!
(1 Advarsel → 2 Dashboard → 3 Adhoc Query → 4 Loggaggregering → 5 Distribuert sporing → 6 Fiksing!)

Tanken er at vi mottar en slags varsling (Slack Notification, SMS, etc.) og etter det:

  • se på Grafana-dashbord
  • se på tjenesteberegninger (for eksempel i Prometheus)
  • se på loggoppføringer (for eksempel i Elasticsearch)
  • kanskje ta en titt på distribuerte spor (Jaeger, Zipkin, etc.)
  • og til slutt fikse det opprinnelige problemet.

Her, i tilfellet med Grafana + Prometheus + Elasticsearch + Zipkin-stabelen, må du bruke fire forskjellige verktøy. For å redusere tid, ville det være fint å kunne utføre alle disse trinnene ved hjelp av ett verktøy: Grafana. Det er verdt å merke seg at denne tilnærmingen til forskning har vært implementert i Grafana siden versjon 6. Dermed blir det mulig å få tilgang til Prometheus-data direkte fra Grafana.

Loki - loggsamling ved hjelp av Prometheus-tilnærmingen
Explorer-skjermen er delt mellom Prometheus og Loki

Fra denne skjermen kan du se Loki-logger relatert til Prometheus-målinger ved å bruke konseptet med delt skjerm. Siden versjon 6.5 lar Grafana deg analysere sporings-ID-en i Loki-loggoppføringer for å følge lenker til dine favorittdistribuerte sporingsverktøy (Jaeger).

Lokal Loki-test

Den enkleste måten å teste Loki lokalt på er å bruke docker-compose. Docker-compose-filen ligger i Loki-depotet. Du kan få depotet ved å bruke følgende kommando git:

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

Deretter må du gå til produksjonskatalogen:

$ cd production

Etter dette kan du få den nyeste versjonen av Docker-bilder:

$ docker-compose pull

Til slutt blir Loki-stakken lansert med følgende kommando:

$ docker-compose up

Loki arkitektur

Her er et lite diagram med Loki-arkitekturen:

Loki - loggsamling ved hjelp av Prometheus-tilnærmingen
Loki arkitekturprinsipper

Webklienten kjører applikasjoner på serveren, Promtail samler inn logger og sender dem til Loki, webklienten sender også metadata til Loki. Loke samler alt og overfører det til Grafana.
Loke blir lansert. For å se tilgjengelige komponenter, kjør følgende kommando:

$ docker ps

I tilfelle av en nyinstallert 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 sentralisering av logger
  • Grafana: et kjent instrumentbordverktøy
  • Loki: Datasentraliseringsdaemon

Som en del av en klassisk infrastruktur (for eksempel basert på virtuelle maskiner), må Promtail-agenten distribueres på hver maskin. Grafana og Loki kan installeres på samme maskin.

Distribusjon til Kubernetes

Installering av Loki-komponenter på Kubernetes vil være som følger:

  • daemonSet for å distribuere Promtail-agenten på hver av maskinene i serverklyngen
  • Utplassering Loki
  • og den siste er utplasseringen av Grafana.

Heldigvis er Loki tilgjengelig som en Helm-pakke, noe som gjør det enkelt å distribuere.

Montering via Heml

Du bør allerede ha Heml installert. Den kan lastes ned fra prosjektets GitHub-depot. Den installeres ved å pakke ut arkivet som tilsvarer din arkitektur og legge til ror $PATH.

Merk: versjon 3.0.0 av Helm ble nylig utgitt. Siden det har vært mange endringer i den, anbefales det at leseren venter litt før den tas i bruk..

Legger til en kilde for Helm

Det første trinnet er å legge til "loki"-depotet ved å bruke følgende kommando:

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

Etter dette kan du søke etter pakker kalt "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 pakkene har følgende funksjoner:

  • pakke loki/loki samsvarer kun med Loki-serveren
  • pakke loki/flytende-bit lar deg distribuere et DaemonSet ved å bruke fluent-bin for å samle logger i stedet for Promtail
  • pakke loki/promtail inneholder en loggfilinnsamlingsagent
  • pakke loki/loki-stack, lar deg distribuere Loki umiddelbart sammen med Promtail.

Installerer Loki

For å distribuere Loki til Kubernetes, kjør følgende kommando i "overvåking"-navneområdet:

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

For å lagre på disk, legg til parameteren --set loki.persistence.enabled = true:

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

Merk: hvis du vil distribuere Grafana samtidig, legg til parameteren --set grafana.enabled = true

Når du kjører denne kommandoen bør du få følgende utdata:

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å statusen til podene i "overvåking"-navneområdet, kan vi se at alt er distribuert:

$ 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 kjører. Nå er det på tide å ta noen tester!

Kobler til Grafana

For å koble til Grafana under Kubernetes, må du åpne en tunnel til poden. Nedenfor er kommandoen for å åpne port 3000 for Grafana pod:

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

Et annet viktig poeng er behovet for å gjenopprette Grafana-administratorpassordet. Passordet holdes hemmelig loki-grafana i feltet .data.admin-user i base64-format.

For å gjenopprette den, må du kjøre følgende kommando:

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

Bruk dette passordet sammen med standard administratorkonto (admin).

Definere en Loki-datakilde i Grafana

Først av alt, sørg for at Loki-datakilden er opprettet (Konfigurasjon/Datakilde).
Her er et eksempel:

Loki - loggsamling ved hjelp av Prometheus-tilnærmingen
Eksempel på å sette opp en datakilde for Loki

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

Kom med forespørsler til Loke

Gå nå til Grafana til "Utforsk"-delen. Når Loki mottar logger fra containere, legger Loki til metadata fra Kubernetes. Dermed blir det mulig å se loggene til en bestemt beholder.

For å velge promtail-beholderloggene kan du for eksempel bruke følgende spørring: {container_name = "promtail"}.
Husk også her å velge Loki-datakilden.

Denne spørringen vil returnere beholderaktivitet som følger:

Loki - loggsamling ved hjelp av Prometheus-tilnærmingen
Spørreresultat i Grafana

Legg til dashbordet

Fra og med Grafana 6.4 kan du plassere logginformasjon direkte på dashbordet. Etter dette vil brukeren raskt kunne bytte mellom antall forespørsler på nettstedet og applikasjonsspor.

Nedenfor er et eksempel på et dashbord som implementerer denne interaksjonen:

Loki - loggsamling ved hjelp av Prometheus-tilnærmingen
Eksempel på dashbord med Prometheus-målinger og Loki-logger

Lokis fremtid

Jeg begynte å bruke Loki tilbake i mai/juni med versjon 0.1. I dag er versjon 1, og til og med 1.1 og 1.2 allerede utgitt.

Det må innrømmes at versjon 0.1 ikke var stabil nok. Men 0.3 viste allerede reelle tegn på modenhet, og påfølgende versjoner (0.4, deretter 1.0) bare styrket dette inntrykket.

Etter 1.0.0 kan ingen ha noen unnskyldning for ikke å bruke dette fantastiske verktøyet.

Ytterligere forbedringer bør ikke handle om Loki, men snarere dens integrasjon med den utmerkede Grafana. Faktisk har Grafana 6.4 allerede god integrasjon med dashbord.

Grafana 6.5, som ble utgitt nylig, forbedrer denne integrasjonen ytterligere ved automatisk å gjenkjenne logginnhold i JSON-format.

Videoen nedenfor viser et lite eksempel på denne mekanismen:

Loki - loggsamling ved hjelp av Prometheus-tilnærmingen
Bruker Loki-strenger eksponert i Grafana

Det blir mulig å bruke et av JSON-feltene, for eksempel for:

  • lenker til eksternt verktøy
  • filtrering av logginnhold

Du kan for eksempel klikke på traceId for å gå til Zipkin eller Jaeger.

Som vanlig ser vi frem til dine kommentarer og inviterer deg til åpne webinar, hvor vi skal snakke om hvordan DevOps-industrien utviklet seg i løpet av 2019 og diskutere mulige utviklingsveier for 2020.

Kilde: www.habr.com