Loki - loggsamling med Prometheus-ansatsen

Hej, Habr-läsare! Inför starten av den nya kullen av kursen «DevOps metoder och verktyg» har vi förberett en översättning av intressant material.

Den här artikeln är en kort introduktion till Loki. Projektet Loki stöds av Grafana och syftar till centraliserad insamling av loggar (från servrar eller containrar).

Den huvudsakliga inspirationskällan för Loki var Prometheus idén att tillämpa dess logik för logghantering:

• använda etiketter (labels) för att lagra data
• konsumera lite resurser

Vi kommer att återkomma till hur Prometheus fungerar och ge några exempel på dess användning i kontexten av Kubernetes.

Några ord om Prometheus

För att fullt ut förstå hur Loki fungerar är det viktigt att ta ett steg tillbaka och tänka på Prometheus.

En av de utmärkande egenskaperna hos Prometheus är att den hämtar metrik från insamlingspunkter (via exporters) och lagrar dem i TSDB (Time Series Data Base, tidsserie-databas) med metadata i form av etiketter.

Varför behövs det?

På senare tid har Prometheus blivit de facto-standard i världen av containrar och Kubernetes: installationen är mycket enkel, och det finns från början en endpoint för Prometheus i Kubernetes-klustret. Prometheus kan också hämta metrik från applikationer som körs i containrar, samtidigt som vissa etiketter sparas. Därför är övervakning av applikationer mycket enkelt att genomföra.

Tyvärr finns det fortfarande ingen "plug and play"-lösning för logghantering, och du måste hitta en lösning för dig själv:

• en hanterad molntjänst för centralisering av loggar (AWS, Azure eller Google)
• en övervakningstjänst som "övervakning som en tjänst" (monitoring as a service) (till exempel Datadog)
• skapa din egen loggsamlartjänst.

För det tredje alternativet har jag traditionellt använt Elasticsearch, även om jag inte alltid har varit nöjd med det (särskilt dess tyngd och komplexitet vid installation).

Loki har designats för att förenkla implementeringen enligt följande principer:

• vara lätt att starta
• konsumera lite resurser
• fungera självständigt utan specialunderhåll
• vara ett komplement till Prometheus för att hjälpa till att undersöka buggar.

Men denna enkelhet uppnås på bekostnad av vissa kompromisser. En av dem är att inte indexera innehållet. Därför är textbaserad sökning inte särskilt effektiv eller innehållsrik och tillåter inte att vi gör statistik på textinnehållet. Men eftersom Loki vill vara ekvivalent med grep och ett komplement till Prometheus är detta ingen nackdel.

Incidentutredning

För att bättre förstå varför Loki inte behöver indexing, låt oss gå tillbaka till metoden för incidentutredning som utvecklarna av Loki använde:

1 Varning → 2 Instrumentpanel → 3 Adhoc Fråga → 4 Loggaggregation → 5 Distribuerad Spårning → 6 Åtgärda!
(1 Varning → 2 Instrumentpanel → 3 Adhoc Fråga → 4 Loggaggregation → 5 Distribuerad Spårning → 6 Åtgärdar!)

Tanken är att vi får en alert (Slack-notis, SMS osv.) och efter det:

• tittar på Grafana-instrumentpaneler
• tittar på tjänsternas mätvärden (till exempel i Prometheus)
• tittar på loggar (till exempel i Elasticsearch)
• möjligen kollar på distribuerade spårningar (Jaeger, Zipkin m.fl.)
• och slutligen åtgärdar det ursprungliga problemet.

Här, i fallet med Grafana + Prometheus + Elasticsearch + Zipkin, måste vi använda fyra olika verktyg. För att spara tid skulle det vara bra att kunna utföra alla dessa steg med hjälp av ett enda verktyg: Grafana. Det är värt att notera att detta tillvägagångssätt för utredning har implementerats i Grafana sedan version 6. Således blir det möjligt att komma åt Prometheus-data direkt från Grafana.

Explorer-skärmen delas mellan Prometheus och Loki

På den här skärmen kan man se loggar i Loki, kopplade till Prometheus-mätvärden, med hjälp av konceptet för delad skärm. Från och med version 6.5 låter Grafana hantera spårnings-ID:t (trace id) i loggeinlägg från Loki för att länka till dina favoritverktyg för distribuerad spårning (Jaeger).

Lokal test av Loki

Det enklaste sättet att testa Loki lokalt är att använda docker-compose. Docker-compose-filen finns i Loki-repositoriet. Du kan få repositoriet med följande kommando git:

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

Därefter måste du gå till produktionskatalogen:

$ cd production

Efter det kan du få den senaste versionen av Docker-bilder:

$ docker-compose pull

Slutligen startas Loki-stacken med följande kommando:

$ docker-compose up

Arkitektur för Loki

Här är ett litet diagram över arkitekturen för Loki:

Arkitekturprinciper för Loki

Webbklienten kör applikationer på servern, Promtail samlar in loggar och skickar dem till Loki, webbklienten skickar också metadata till Loki. Loki aggregerar allt och vidarebefordrar till Grafana.
Loki är igång. För att se de komponenter som finns, kör följande kommando:

$ docker ps

Vid en nyinstallerad Docker bör kommandot returnera följande resultat:

BILD               PORTAR                  NAMN
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öljande komponenter:

• Promtail: agent som ansvarar för centralisering av loggar
• Grafana: ett välkänt verktyg för dashboards
• Loki: daemon för centralisering av data

Inom en klassisk infrastruktur (till exempel baserad på virtuella maskiner) måste varje maskin ha agenten Promtail installerad. Grafana och Loki kan installeras på samma maskin.

Distribution i Kubernetes

Installationen av Loki-komponenter i Kubernetes kommer att bestå av följande:

• daemonSet för att distribuera agenten Promtail på varje maskin i serverklustret
• distribution (Deployment) av Loki
• och sist — distribution av Grafana.

Lyckligtvis är Loki tillgänglig som ett Helm-paket, vilket förenklar dess distribution.

Installation via Heml

Heml bör redan vara installerad hos dig. Den kan laddas ner från GitHub-repositoryt för projektet. Den installeras genom att packa upp arkivet motsvarande din arkitektur, och lägga till helm i $PATH.

Anmärkning: version 3.0.0 av Helm släpptes nyligen. Eftersom det gjordes många förändringar, rekommenderas läsaren att vänta lite innan de börjar använda den..

Tillägg av källa för Helm

Första steget är att lägga till 'loki'-repo med följande kommando:

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

Därefter kan man söka efter paket med namnet 'loki':

$ helm search loki

Resultatet:

loki/loki       0.17.2 v0.4.0 Loki: som Prometheus, men för loggar.
loki/loki-stack 0.19.1 v0.4.0 Loki: som Prometheus, men för loggar.
loki/fluent-bit 0.0.2  v0.0.1 Använder fluent-bit Loki go-plugin för...
loki/promtail   0.13.1 v0.4.0 Ansvarig för att samla loggar och...

Dessa paket har följande funktioner:

• paketet loki/loki motsvarar endast Loki-servern
• paketet loki/fluent-bit låt dig distribuera DaemonSet med fluent-bit för loggsamling istället för Promtail
• paketet loki/promtail innehåller agenten för loggfilssamling
• paketet loki/loki-stack, tillåter att omedelbart distribuera Loki tillsammans med Promtail.

Installation av Loki

För att distribuera Loki i Kubernetes, kör följande kommando i namnutrymmet 'monitoring':

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

För att spara på disk, lägg till parametern --set loki.persistence.enabled = true:

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

Anmärkning: om du vill distribuera Grafana samtidigt, lägg till parametern --set grafana.enabled = true

När du kör det här kommandot bör du få följande utdata:

SENASTE UTPLACERING: Tis 19 nov 15:56:54 2019
NAMNRYMD: övervakning
STATUS: UTPLACERAD
RESURSER:
==> v1/ClusterRole
NAMN ÅLDER
loki-promtail-clusterrole 189d
…
ANTECKNINGAR:
Loki-stacken har blivit utplacerad i din kluster. Loki kan nu läggas till som en datakälla i Grafana.
Se <a href="http://docs.grafana.org/features/datasources/loki/">http://docs.grafana.org/features/datasources/loki/</a> för mer information.

Genom att titta på statusen för poddar i namnområdet "monitoring" ser vi att allt är distribuerat:

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

Resultatet:

NAMN                 KLAR  STATUS   OMSTARTAR  ÅLDER
loki-0               1/1    Kör      0         147m
loki-promtail-9zjvc  1/1    Kör      0         3h25m
loki-promtail-f6brf  1/1    Kör      0         11h
loki-promtail-hdcj7  1/1    Kör      0         3h23m
loki-promtail-jbqhc  1/1    Kör      0         11h
loki-promtail-mj642  1/1    Kör      0         62m
loki-promtail-nm64g  1/1    Kör      0         24m

Alla poddar körs. Nu är det dags att göra några tester!

Anslutning till Grafana

För att ansluta till Grafana via Kubernetes, måste du öppna en tunnel till dess pod. Här är kommandot för att öppna port 3000 för Grafana-poden:

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

En annan viktig punkt är behovet av att återställa administratörslösenordet för Grafana. Lösenordet lagras i hemligheten loki-grafana i fältet .data.admin-user i base64-format.

För att återställa det, kör följande kommando:

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

Använd detta lösenord tillsammans med det standardadministratörskontot (admin).

Definiera datakälla för Loki i Grafana

Först, se till att en datakälla för Loki har skapats (Konfiguration / Datasource).
Här är ett exempel:

Exempel på inställning av datakälla för Loki

Genom att klicka på "Test" kan du kontrollera anslutningen till Loki.

Gör förfrågningar till Loki

Nu går du till Grafana i avsnittet "Explore". När Loki tar emot loggar från containrar lägger den till metadata från Kubernetes. Därför blir det möjligt att granska loggar från en specifik container.

Till exempel, för att välja loggar från promtail-containern kan du använda följande förfrågan: {container_name = "promtail"}.
Kom ihåg att också välja datakälla för Loki.

Denna förfrågan kommer att returnera containeraktivitet i följande form:

Resultatet av förfrågan i Grafana

Lägg till på dashboard

Från och med Grafana 6.4 kan du placera logginformation direkt på dashboarden. Efter detta kommer användaren snabbt kunna växla mellan antalet förfrågningar på sin webbplats och applikationens spårningar.

Nedan är ett exempel på en dashboard som implementerar denna interaktion:

Exempel på en instrumentpanel med Prometheus-metriker och Loki-loggar

Framtiden för Loki

Jag började använda Loki i maj/juni med version 0.1. Idag har version 1 släppts, och till och med 1.1 och 1.2.

Vi måste erkänna att version 0.1 inte var tillräckligt stabil. Men 0.3 visade redan verkliga tecken på mognad, och de följande versionerna (0.4, sedan 1.0) förstärkte bara det intrycket.

Efter 1.0.0 finns det ingen ursäkt för att inte använda detta fantastiska verktyg.

Framtida förbättringar bör handla om integrationen av Loki med den utmärkta Grafana. Faktum är att Grafana 6.4 redan hade en bra integration med instrumentpanelerna.

Grafana 6.5, som nyligen släpptes, förbättrar denna integration ytterligare genom att automatiskt känna igen innehållet i loggar i JSON-format.

Nedan finns en kort video som visar detta mekanism:

Användning av Loki-strängar som visas i Grafana

Det blir möjligt att använda ett av JSON-fälten, till exempel för:

• länkar till externa verktyg
• filtrering av logginnehåll

Till exempel kan du klicka på traceId för att gå till Zipkin eller Jaeger.

Vi ser fram emot era kommentarer och bjuder in till öppen webbinarie, där vi pratar om hur DevOps-industrin utvecklades under 2019 och diskuterar möjliga utvecklingsvägar för 2020.

Källa: habr.com