Loki — logger innsamling med Prometheus-tilnærming

Hei, Habr-medlemmer! Før oppstarten av det nye kurset, “DevOps Practices and Tools” har vi forberedt en oversettelse av et interessant materiale.

Denne artikkelen er en kort introduksjon til Loki. Prosjektet Loki støttes av Grafana og har som mål å sentralisere logger (fra servere eller containere).

Den viktigste inspirasjonskilden for Loki var Prometheus ideen om å anvende dens loggforvaltningsmetoder:

• bruken av etiketter for datalagring
• lav ressursforbruk

Vi kommer tilbake til prinsippene til Prometheus og vil gi noen eksempler på bruken i konteksten Kubernetes.

Noen ord om Prometheus

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

En av de karakteristiske trekkene til Prometheus er innhentingen av målinger fra innsamling punkter (gjennom eksportører) og lagring i TSDB (Time Series Data Base, tidsseriedatabase) med tilleggsmetadata i form av etiketter.

Hvorfor er dette nødvendig

I det siste har Prometheus blitt et de facto-standard i containerverdenen og Kubernetes: installasjonen er veldig enkel, og i Kubernetes-klyngen er det alltid et endepunkt for Prometheus. Prometheus kan også hente målinger fra applikasjoner som er distribuert i containere, mens det samtidig opprettholder bestemte etiketter. Dermed er overvåking av applikasjoner lett å implementere.

Dessverre finnes det fortsatt ingen «plug-and-play»-løsning for loggføring, og du må finne en løsning for deg selv:

• en administrert sky-tjeneste for sentralisering av logger (AWS, Azure eller Google)
• monitorering som en tjeneste (monitoring as a service) (for eksempel Datadog)
• opprettelsen av din egen loggsamlertjeneste.

For det tredje alternativet har jeg tradisjonelt brukt Elasticsearch, selv om jeg ikke alltid har vært fornøyd med det (særlig med hensyn til dets tyngde og kompleksitet i oppsettet).

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

• være enkel å starte
• bruke lite ressurser
• fungere selvstendig uten spesialtilsyn
• tjene som et supplement til Prometheus for å hjelpe i feilsøking

Den enkle tilgangen oppnås imidlertid på bekostning av noen kompromisser. Et av dem er at innholdet ikke indekseres. Derfor er tekstsøk ikke veldig effektivt eller rikt, og det tillater ikke statistikk over tekstinnholdet. Men fordi Loki ønsker å være ekvivalenten til grep og et supplement til Prometheus, er dette ikke en ulempe.

Hendelseshåndtering

For bedre å forstå hvorfor Loki ikke trenger indeksering, la oss gå tilbake til metoden for hendelseshåndtering som utviklerne av Loki har brukt:

1 Varsel → 2 Dashboard → 3 Adhoc-spørring → 4 Loggaggregasjon → 5 Distribuert sporing → 6 Fiks!
(1 Varsel → 2 Dashboard → 3 Adhoc-spørring → 4 Loggaggregasjon → 5 Distribuert sporing → 6 Fiks!)

Ideen er at vi får et varsel (Slack-notifikasjon, SMS osv.) og deretter:

• sjekker Grafana-dashboards
• sjekker service-metrikker (for eksempel i Prometheus)
• sjekker loggoppføringer (for eksempel i Elasticsearch)
• kanskje ser på distribuerte spor (Jaeger, Zipkin osv.)
• og til slutt retter opp den opprinnelige problemet.

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

Explorer-skjermen er delt mellom Prometheus og Loki

På denne skjermen kan man se logger i Loki relatert til metrikker fra Prometheus, ved hjelp av skjermdelt konsept. Siden versjon 6.5 tillater Grafana behandling av sporings-ID (trace id) i loggoppføringer fra Loki for å navigere lett til favorittverktøyene for distribuerte sporinger (Jaeger).

Lokal testing av Loki

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

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

Deretter må du gå til produksjonskatalogen:

$ cd production

Deretter kan du hente den nyeste versjonen av Docker-bilder:

$ docker-compose pull

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

$ docker-compose up

Arkitekturen av Loki

Her er et lite diagram med arkitekturen av Loki:

Prinsippene for arkitekturen av Loki

Web-klienten kjører applikasjoner på serveren, Promtail samler logger og sender dem til Loki, web-klienten sender også metadata til Loki. Loki aggregerer alt og videreformidler det til Grafana.
Loki er startet. For å se tilgjengelige komponenter, kjør følgende kommando:

$ docker ps

Ved nyinstallert Docker skal kommandoen returnere følgende resultat:

BILDE               PORTER                  NAVN
 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: agenten som er ansvarlig for sentralisering av logger
• Grafana: velkjent verktøy for dashboards
• Loki: daemon for datakonsolidering

I en klassisk infrastruktur (for eksempel basert på virtuelle maskiner) må en Promtail-agent være installert på hver maskin. Grafana og Loki kan installeres på samme maskin.

Distribusjon i Kubernetes

Installeringen av Loki-komponentene i Kubernetes vil bestå av det følgende:

• daemonSet for å distribuere Promtail-agenten på hver av maskinene i serverklusteret
• distribusjon (Deployment) av Loki
• og sist - distribusjon av Grafana.

Heldigvis er Loki tilgjengelig som et Helm-pakke, noe som forenkler distribusjonen.

Installering via Helm

Helm bør allerede være installert hos deg. Det kan lastes ned fra prosjektets GitHub-repositorium. Det installeres ved å pakke ut arkivet som passer til din arkitektur og legge til helm i $PATH.

Merk: versjon 3.0.0 av Helm ble nettopp utgitt. Siden det er mange endringer, anbefales det at leseren venter litt før han begynner å bruke det..

Legge til kilde for Helm

Første steg vil være å legge til 'loki'-repoet med følgende kommando:

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

Etter dette kan du søke etter pakker med navnet 'loki':

$ helm search loki

Resultat:

loki/loki       0.17.2 v0.4.0 Loki: som Prometheus, men for logger.
loki/loki-stack 0.19.1 v0.4.0 Loki: som Prometheus, men for logger.
loki/fluent-bit 0.0.2  v0.0.1 Bruker fluent-bit Loki go-plugin for...
loki/promtail   0.13.1 v0.4.0 Ansvarlig for å samle logger og...

Disse pakkene har følgende funksjoner:

• med displayserveren Mir. loki/loki er kun for Loki-serveren
• med displayserveren Mir. loki/fluent-bit lar deg distribuere DaemonSet ved å bruke fluent-bit for logging i stedet for Promtail
• med displayserveren Mir. loki/promtail inneholder agenten for innsamling av loggfiler
• med displayserveren Mir. loki/loki-stack, lar deg umiddelbart distribuere Loki sammen med Promtail.

Installering av Loki

For å distribuere Loki i Kubernetes, kjør følgende kommando i navnerommet 'monitoring':

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

For disk saving, add the parameter --set loki.persistence.enabled = true:

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

Merk: If you want to deploy Grafana simultaneously, add the parameter --set grafana.enabled = true

When you run this command, you should see the following output:

SISTE UTRULLET: Tue Nov 19 15:56:54 2019
NAVNROM: monitoring
STATUS: UTRULLER
REKURRANSE:
==> v1/ClusterRole
NAVN ALDER
loki-promtail-clusterrole 189d
…
MERKNADER:
Loki-stakken har blitt utplassert til klyngen din. Loki kan nå legges til som en datakilde i Grafana.
Se <a href="http://docs.grafana.org/features/datasources/loki/">http://docs.grafana.org/features/datasources/loki/</a> for mer informasjon.

By looking at the status of the pods in the namespace 'monitoring', we will see that everything is deployed:

$ 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

All pods are running. Now it’s time to perform some tests!

Connecting to Grafana

To connect to Grafana under Kubernetes, you need to open a tunnel to its pod. Below is the command to open port 3000 for the Grafana pod:

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

Another important point is the need to retrieve the Grafana administrator password. The password is stored in the secret loki-grafana in the field .data.admin-user in base64 format.

To retrieve it, you need to run the following command:

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

Use this password along with the default administrator account (admin).

Configuring the Loki data source in Grafana

First, make sure that you have created the Loki data source (Configuration / Datasource).
Here’s an example:

Example configuration of the data source for Loki

By clicking 'Test', you can check the connection to Loki.

Making requests to Loki

Now go to Grafana and select 'Explore'. When receiving logs from containers, Loki adds metadata from Kubernetes. Thus, it becomes possible to view logs of a specific container.

For example, to select logs from the promtail container, you can use the following query: {container_name = "promtail"}.
Don’t forget to also select the Loki data source.

This query will return the container activity in the following format:

Query result in Grafana

Adding to the dashboard

Starting from Grafana 6.4, you can place log information directly on the dashboard. After this, the user can quickly switch between the number of requests on their site to application traces.

Below is an example of a dashboard implementing this interaction:

Eksempel på dashbord med Prometheus-metrikker og Loki-loggene

Fremtiden for Loki

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

Det må innrømmes at versjon 0.1 ikke var helt stabil. Men 0.3 viste allerede reelle tegn på modenhet, og de neste versjonene (0.4, deretter 1.0) forsterket bare dette inntrykket.

Etter 1.0.0 kan ingen lenger ha unnskyldninger for å ikke bruke dette fantastiske verktøyet.

Videre forbedringer bør ikke handle om Loki, men heller om integrasjonen med det fremragende Grafana. Faktisk har Grafana 6.4 allerede en god integrasjon med dashbordene.

Grafana 6.5, som nylig ble utgitt, forbedrer denne integrasjonen ytterligere, ved automatisk gjenkjenning av innholdet i logger i JSON-format.

Nedenfor er en liten demonstrasjon av denne mekanismen i videoen:

Bruk av Loki-strenger vist i Grafana

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

• lenke til et eksternt verktøy
• filtrering av logginnhold

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

Tradisjonelt venter vi på kommentarene deres og inviterer dere til åpent webinar, hvor vi vil diskutere hvordan DevOps-industrien har utviklet seg i løpet av 2019 og diskutere mulige utviklingsveier for 2020.

Kilde: habr.com