🥇 Logbicher vum Loki sammelen

Mir bei Badoo iwwerwaachen dauernd nei Technologien an evaluéieren ob se se an eisem System benotzen oder net. Mir wëllen eng vun dëse Studien mat der Gemeinschaft deelen. Et ass dem Loki gewidmet, e Log Aggregatiounssystem.

Loki ass eng Léisung fir Logbicher ze späicheren an ze gesinn, an dëse Stack bitt och e flexibele System fir se ze analyséieren an Daten op Prometheus ze schécken. Am Mee gouf en aneren Update verëffentlecht, deen aktiv vun den Creatoren gefördert gëtt. Mir waren interesséiert wat de Loki maache kann, wéi eng Features et ubitt, a wéi engem Ausmooss et als Alternativ zum ELK handele kann, de Stack dee mir elo benotzen.

Wat ass Loki

Grafana Loki ass e Set vu Komponenten fir e komplette Logsystem. Am Géigesaz zu aneren ähnlechen Systemer baséiert Loki op der Iddi fir nëmmen Log Metadaten ze indexéieren - Etiketten (just wéi am Prometheus), an d'Logbicher selwer niewentenee an getrennte Stécker kompriméieren.

Homepage, GitHub

Ier ech op wat Dir mat Loki maache kënnt, wëll ech klären wat "d'Iddi fir nëmmen Metadaten ze indexéieren" gemengt ass. Loosst eis d'Loki Approche an d'Index Approche an traditionelle Léisungen vergläichen, wéi Elasticsearch, mat dem Beispill vun enger Linn aus dem nginx Log:

172.19.0.4 - - [01/Jun/2020:12:05:03 +0000] "GET /purchase?user_id=75146478&amp;item_id=34234 HTTP/1.1" 500 8102 "-" "Stub_Bot/3.0" "0.001"

Traditionell Systemer parséieren déi ganz Rei, dorënner Felder mat villen eenzegaartege user_id an item_id Wäerter, a späicheren alles a groussen Indexen. De Virdeel vun dëser Approche ass datt Dir séier komplex Ufroe maache kënnt, well bal all d'Donnéeën am Index sinn. Awer Dir musst dofir bezuelen, datt den Index grouss gëtt, wat an Erënnerung Ufuerderunge iwwersetzt. Als Resultat ass de Volltext Index vu Logbicher a Gréisst vergläichbar mat de Logbicher selwer. Fir séier duerch ze sichen, muss den Index an d'Erënnerung gelueden ginn. A wat méi Logbicher, wat méi séier den Index eropgeet an wat méi Erënnerung et verbraucht.

D'Loki Approche erfuerdert datt nëmmen déi néideg Donnéeën aus dem String extrahéiert ginn, d'Zuel vun de Wäerter vun deenen kleng ass. Op dës Manéier kréien mir e klengen Index a kënnen d'Donnéeë sichen andeems se se no Zäit an indexéierte Felder filteren, an dann de Rescht mat regulären Ausdréck oder Substring Sichen scannen. De Prozess schéngt net de schnellsten, awer Loki trennt d'Ufro an e puer Deeler an fiert se parallel aus, veraarbecht eng grouss Quantitéit un Daten a kuerzer Zäit. D'Zuel vun shards a parallel Ufroen an hinnen ass configurable; also, der Quantitéit vun Donnéeën déi pro Unitéit vun Zäit veraarbecht ginn hänkt linear op der Quantitéit vun Ressourcen gëtt.

Dës Ofhandlung tëscht engem grousse schnelle Index an engem klenge parallele Brute-Force Index erlaabt Loki d'Käschte vum System ze kontrolléieren. Et kann flexibel konfiguréiert an erweidert ginn no Äre Besoinen.

De Loki Stack besteet aus dräi Komponenten: Promtail, Loki, Grafana. Promtail sammelt Logbicher, veraarbecht se a schéckt se un de Loki. Loki hält se. A Grafana kann Daten vum Loki ufroen a weisen. Am Allgemengen, Loki kann net nëmme benotzt ginn fir Logbicher ze späicheren an duerch se ze sichen. De ganze Stack bitt grouss Méiglechkeeten fir d'Veraarbechtung an d'Analyse vun erakommen Daten mam Prometheus Wee ze benotzen.
Eng Beschreiwung vum Installatiounsprozess ka fonnt ginn hei.

Log Sich

Dir kënnt d'Logbicher an engem speziellen Interface sichen Grafana - Explorer. D'Ufroe benotzen d'LogQL Sprooch, déi ganz ähnlech ass wéi de PromQL dee vum Prometheus benotzt gëtt. Am Prinzip kann et als verdeelt Grep geduecht ginn.

D'Sich-Interface gesäit esou aus:

D'Ufro selwer besteet aus zwee Deeler: Selektor a Filter. Selector ass eng Sich no indexéierten Metadaten (Etiketten) déi zu Logbicher zougewisen sinn, a Filter ass eng Sichstring oder Regexp déi records filtert, déi vum Selector definéiert sinn. Am uginn Beispill: An Curly Klammeren - de selector, alles no - de Filter.

{image_name="nginx.promtail.test"} |= "index"

Wéinst der Aart a Weis wéi Loki funktionnéiert, kënnt Dir keng Ufroe maachen ouni Selektor, awer Etiketten kënnen arbiträr generesch gemaach ginn.

De Selektor ass de Schlësselwäert vum Wäert a Curly Klammeren. Dir kënnt Selektor kombinéieren a verschidde Sichbedéngungen spezifizéieren mat den =, != Bedreiwer oder regulär Ausdréck:

{instance=~"kafka-[23]",name!="kafka-dev"} 
// Найдёт логи с лейблом instance, имеющие значение kafka-2, kafka-3, и исключит dev

E Filter ass en Text oder Regexp, deen all d'Donnéeën, déi vum Selektor kritt ginn, filtert.

Et ass méiglech ad-hoc Grafike ze kréien op Basis vun den erhalenen Donnéeën am Metrik Modus. Zum Beispill kënnt Dir d'Frequenz vum Optriede an den nginx Logbicher vun enger Entrée erausfannen, déi den Indexstring enthält:

Eng komplett Beschreiwung vun de Funktiounen kann an der Dokumentatioun fonnt ginn LogQL.

Log Parsing

Et gi verschidde Weeër fir Logbicher ze sammelen:

Mat der Hëllef vu Promtail, e Standardkomponent vum Stack fir Logbicher ze sammelen.
Direkt vum Docker Container benotzt Loki Docker Logging Driver.
Benotzt Fluentd oder Fluent Bit déi Daten op Loki schécken kann. Am Géigesaz zu Promtail hu se fäerdege Parser fir bal all Typ vu Logbicher a kënnen och Multiline Logbicher handhaben.

Normalerweis gëtt Promtail fir Parsing benotzt. Et mécht dräi Saachen:

Fannt Datenquellen.
Befestegt Etiketten hinnen.
Schéckt Daten un Loki.

De Moment kann Promtail Logbicher aus lokalen Dateien a vum Systemd Journal liesen. Et muss op all Maschinn installéiert ginn, aus deenen d'Logbicher gesammelt ginn.

Et gëtt Integratioun mat Kubernetes: Promtail fënnt automatesch den Zoustand vum Stärekoup duerch de Kubernetes REST API eraus a sammelt Logbicher aus engem Node, Service oder Pod, a postt direkt Etiketten baséiert op Metadaten vu Kubernetes (Podnumm, Dateinumm, etc.).

Dir kënnt och Etiketten hänken op Basis vun Daten aus dem Logbuch mat Pipeline. Pipeline Promtail kann aus véier Aarte vu Etappe besteet. Méi Detailer - an offiziell Dokumentatioun, Ech wäert direkt e puer vun den Nuancen notéieren.

Parsing Etappen. Dëst ass d'Bühn vu RegEx a JSON. Op dëser Etapp extrahéieren mir Daten aus de Logbicher an déi sougenannt extrahéiert Kaart. Dir kënnt aus JSON extrahéieren andeems Dir einfach d'Felder kopéiert, déi mir brauchen an déi extrahéiert Kaart, oder duerch regulär Ausdréck (RegEx), wou benannt Gruppen op déi extrahéiert Kaart "mapéiert" sinn. Extraitéiert Kaart ass eng Schlësselwäertlagerung, wou Schlëssel den Numm vum Feld ass, a Wäert ass säi Wäert aus de Logbicher.
Etappe transforméieren. Dës Etapp huet zwou Méiglechkeeten: Transformatioun, wou mir d'Transformatiounsregele festleeën, a Quell - d'Datequell fir d'Transformatioun vun der extrahéierter Kaart. Wann et keen esou Feld an der extrahéierter Kaart ass, da gëtt et erstallt. Sou ass et méiglech Etiketten ze kreéieren déi net op der extrahéierter Kaart baséieren. Op dëser Etapp kënne mir d'Donnéeën an der extrahéierter Kaart manipuléieren mat enger zimlech mächteger Golang Schabloun. Zousätzlech musse mir drun erënneren datt déi extrahéiert Kaart während dem Parsing voll gelueden ass, wat et zum Beispill erlaabt de Wäert dran ze kontrolléieren: "{{if .tag}Tag-Wäert existéiert{end}}". Schabloun ënnerstëtzt Konditiounen, Loops, an e puer Stringfunktiounen wéi Ersatz an Trim.
Aktioun Etappe. Op dëser Etapp kënnt Dir eppes mat der extrahéierter maachen:
- Erstellt e Label aus den extrahéierten Donnéeën, déi vum Loki indexéiert ginn.
- Änneren oder setzen d'Evenementzäit aus dem Logbuch.
- Ännert d'Donnéeën (Logtext) déi op Loki goen.
- Erstellt Metriken.
Filterstadien. De Match Etapp, wou kënne mir entweder records schécken, datt mir brauchen net ze /dev/null, oder se fir weider Veraarbechtung schécken.

Mat dem Beispill vun der Veraarbechtung vun gewéinleche nginx Logbicher, wäert ech weisen wéi Dir Logbicher mat Promtail parse kënnt.

Fir den Test, loosst eis e modifizéierten nginx jwilder / nginx-proxy: alpine Bild huelen an e klengen Daemon dee sech iwwer HTTP als nginx-Proxy ka froen. Den Daemon huet e puer Endpunkte, op déi et Äntwerte vu verschiddene Gréissten, mat verschiddene HTTP-Statusen a mat verschiddene Verspéidungen ka ginn.

Mir sammelen Logbicher aus Docker Container, déi laanscht de Wee fonnt kënne ginn /var/lib/docker/containers/ / -json.log

An docker-compose.yml setze mir Promtail op a spezifizéieren de Wee op d'Konfiguratioun:

promtail:
  image: grafana/promtail:1.4.1
 // ...
 volumes:
   - /var/lib/docker/containers:/var/lib/docker/containers:ro
   - promtail-data:/var/lib/promtail/positions
   - ${PWD}/promtail/docker.yml:/etc/promtail/promtail.yml
 command:
   - '-config.file=/etc/promtail/promtail.yml'
 // ...

Füügt de Wee an d'Logbicher op promtail.yml (et gëtt eng "Docker" Optioun an der Configuratioun déi d'selwecht an enger Zeil mécht, awer et wier net sou offensichtlech):

scrape_configs:
 - job_name: containers

   static_configs:
       labels:
         job: containerlogs
         __path__: /var/lib/docker/containers/*/*log  # for linux only

Wann dës Konfiguratioun aktivéiert ass, kritt Loki Logbicher vun all Container. Fir dëst ze vermeiden, änneren mir d'Astellunge vum Test nginx an docker-compose.yml - füügt de Logbuch an d'Tagfeld:

proxy:
 image: nginx.test.v3
//…
 logging:
   driver: "json-file"
   options:
     tag: "{{.ImageName}}|{{.Name}}"

Edit promtail.yml an ageriicht Pipeline. D'Logbicher sinn wéi follegt:

{"log":"u001b[0;33;1mnginx.1    | u001b[0mnginx.test 172.28.0.3 - - [13/Jun/2020:23:25:50 +0000] "GET /api/index HTTP/1.1" 200 0 "-" "Stub_Bot/0.1" "0.096"n","stream":"stdout","attrs":{"tag":"nginx.promtail.test|proxy.prober"},"time":"2020-06-13T23:25:50.66740443Z"}
{"log":"u001b[0;33;1mnginx.1    | u001b[0mnginx.test 172.28.0.3 - - [13/Jun/2020:23:25:50 +0000] "GET /200 HTTP/1.1" 200 0 "-" "Stub_Bot/0.1" "0.000"n","stream":"stdout","attrs":{"tag":"nginx.promtail.test|proxy.prober"},"time":"2020-06-13T23:25:50.702925272Z"}

Pipeline Etappen:

 - json:
     expressions:
       stream: stream
       attrs: attrs
       tag: attrs.tag

Mir extrahéieren de Stroum, attrs, attrs.tag Felder (wann iwwerhaapt) aus dem erakommen JSON a setzen se an déi extrahéiert Kaart.

 - regex:
     expression: ^(?P<image_name>([^|]+))|(?P<container_name>([^|]+))$
     source: "tag"

Wann et méiglech war d'Tagfeld an der extrahéierter Kaart ze setzen, dann mat der Regexp extrahéieren mir d'Nimm vum Bild an de Container.

 - labels:
     image_name:
     container_name:

Mir ginn Etiketten. Wann d'Schlësselen image_name a container_name an den extrahéierten Donnéeën fonnt ginn, da ginn hir Wäerter un déi entspriechend Etiketten zougewisen.

 - match:
     selector: '{job="docker",container_name="",image_name=""}'
     action: drop

Mir verwerfen all Logbicher déi keng Etiketten Image_Name a Container_Name Set hunn.

  - match:
     selector: '{image_name="nginx.promtail.test"}'
     stages:
       - json:
           expressions:
             row: log

Fir all Logbicher, deenen hiren Image_name gläich ass wéi nginx.promtail.test, extrahéiert de Logfeld aus dem Quellprotokoll a setzt se an d'extraktéiert Kaart mat der Zeil Schlëssel.

  - regex:
         # suppress forego colors
         expression: .+nginx.+|.+[0m(?P<virtual_host>[a-z_.-]+) +(?P<nginxlog>.+)
         source: logrow

Mir läschen den Input String mat reguläre Ausdréck an zitt den nginx virtuelle Host an d'nginx Log Linn eraus.

     - regex:
         source: nginxlog
         expression: ^(?P<ip>[w.]+) - (?P<user>[^ ]*) [(?P<timestamp>[^ ]+).*] "(?P<method>[^ ]*) (?P<request_url>[^ ]*) (?P<request_http_protocol>[^ ]*)" (?P<status>[d]+) (?P<bytes_out>[d]+) "(?P<http_referer>[^"]*)" "(?P<user_agent>[^"]*)"( "(?P<response_time>[d.]+)")?

Parse nginx Log mat reguläre Ausdréck.

    - regex:
           source: request_url
           expression: ^.+.(?P<static_type>jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|pdf|txt|tar|wav|bmp|rtf|js|flv|swf|html|htm)$
     - regex:
           source: request_url
           expression: ^/photo/(?P<photo>[^/?.]+).*$
       - regex:
           source: request_url
           expression: ^/api/(?P<api_request>[^/?.]+).*$

Parse request_url. Mat der Hëllef vun regexp, bestëmmen mir den Zweck vun der Ufro: Statik, Fotoen, API a setzen de entspriechende Schlëssel an der extrahéiert Kaart.

       - template:
           source: request_type
           template: "{{if .photo}}photo{{else if .static_type}}static{{else if .api_request}}api{{else}}other{{end}}"

Mat bedingungsbedéngte Betreiber an der Schabloun, iwwerpréift mir déi installéiert Felder an der extrahéierter Kaart a setzen déi erfuerderlech Wäerter fir den request_type Feld: Foto, statesch, API. Gitt aner wann et gescheitert ass. Elo enthält request_type den Ufrotyp.

       - labels:
           api_request:
           virtual_host:
           request_type:
           status:

Mir setzen d'Etiketten api_request, virtual_host, request_type a Status (HTTP Status) baséiert op wat mir et fäerdeg bruecht hunn an der extrahéierter Kaart ze setzen.

       - output:
           source: nginx_log_row

Ausgang änneren. Elo geet de gereinegt nginx Log vun der extrahéierter Kaart op Loki.

Nodeems Dir déi uewe genannte Konfiguratioun ausgefouert hutt, kënnt Dir gesinn datt all Entrée markéiert ass baséiert op Daten aus dem Logbuch.

Denkt drun datt d'Etikettë mat enger grousser Unzuel vu Wäerter (Kardinalitéit) extrahéiert kënne Loki wesentlech verlangsamen. Dat ass, Dir sollt net an den Index setzen, zum Beispill, user_id. Liest méi iwwer dëst am ArtikelWéi Etiketten am Loki kënne Logufroen méi séier a méi einfach maachen". Awer dëst bedeit net datt Dir net op user_id ouni Indexen sichen kënnt. Et ass noutwendeg fir Filteren ze benotzen wann Dir sicht ("gräifen" no den Donnéeën), an den Index handelt hei als Streamidentifizéierer.

Log Visualiséierung

Loki kann als Datenquell fir Grafana Charts mat LogQL handelen. Déi folgend Funktiounen ginn ënnerstëtzt:

Taux - Zuel vun records pro Sekonn;
zielen iwwer Zäit - d'Zuel vun den Opzeechnungen am bestëmmte Beräich.

Et ginn och aggregéiert Funktiounen Sum, Avg an anerer. Dir kënnt zimlech komplex Grafike bauen, zum Beispill eng Grafik vun der Unzuel vun HTTP-Feeler:

Dem Loki seng Standarddatenquell ass e bësse manner funktionell wéi d'Prometheus Datenquell (zum Beispill, Dir kënnt d'Legend net änneren), awer Loki kann als Prometheus Typ Quell verbonne sinn. Ech sinn net sécher ob dëst dokumentéiert Verhalen ass, awer no der Äntwert vun den Entwéckler beurteelen "Wéi konfiguréiert Loki als Prometheus Datenquell? · Ausgab #1222 · grafana/loki", zum Beispill, et ass perfekt legal a Loki ass voll kompatibel mat PromQL.

Füügt Loki als Datenquell mam Typ Prometheus an addéiert URL /loki:

An Dir kënnt Grafike maachen, wéi wa mir mat Metriken vum Prometheus schaffen:

Ech mengen datt d'Diskrepanz an der Funktionalitéit temporär ass an d'Entwéckler et an Zukunft fixéieren.

Metriken

Loki bitt d'Fäegkeet fir numeresch Metriken aus Logbicher ze extrahieren an se op Prometheus ze schécken. Zum Beispill enthält den nginx Log d'Zuel vun de Bytes pro Äntwert, an och, mat enger gewëssener Ännerung vum Standard Log Format, d'Zäit a Sekonnen déi et gedauert huet fir ze reagéieren. Dës Donnéeë kënnen extrahéiert an un Prometheus geschéckt ginn.

Füügt eng aner Sektioun op promtail.yml:

- match:
   selector: '{request_type="api"}'
   stages:
     - metrics:
         http_nginx_response_time:
           type: Histogram
           description: "response time ms"
           source: response_time
           config:
             buckets: [0.010,0.050,0.100,0.200,0.500,1.0]
- match:
   selector: '{request_type=~"static|photo"}'
   stages:
     - metrics:
         http_nginx_response_bytes_sum:
           type: Counter
           description: "response bytes sum"
           source: bytes_out
           config:
             action: add
         http_nginx_response_bytes_count:
           type: Counter
           description: "response bytes count"
           source: bytes_out
           config:
             action: inc

D'Optioun erlaabt Iech Metriken ze definéieren an ze aktualiséieren baséiert op Daten aus der extrahéierter Kaart. Dës Metriken ginn net un Loki geschéckt - si schéngen am Promtail / Metric Endpoint. Prometheus muss konfiguréiert sinn fir Daten aus dëser Etapp ze kréien. Am uewe genannte Beispill, fir request_type = "api" sammele mir eng Histogramm Metrik. Mat dëser Aart vu Metriken ass et bequem Prozenttilen ze kréien. Fir Statik a Fotoen sammele mir d'Zomm vun de Bytes an d'Zuel vun de Reihen an deenen mir Bytes kritt hunn fir den Duerchschnëtt ze berechnen.

Liest méi iwwer Metriken hei.

Öffnen e Port op Promtail:

promtail:
     image: grafana/promtail:1.4.1
     container_name: monitoring.promtail
     expose:
       - 9080
     ports:
       - "9080:9080"

Mir vergewësseren datt d'Metriken mam promtail_custom Präfix opgetaucht sinn:

Prometheus opbauen. Jobpromtail derbäisetzen:

- job_name: 'promtail'
 scrape_interval: 10s
 static_configs:
   - targets: ['promtail:9080']

A molen eng Grafik:

Op dës Manéier kënnt Dir zum Beispill déi véier luesst Ufroen erausfannen. Dir kënnt och Iwwerwaachung fir dës Metriken konfiguréieren.

Skaléieren

Loki kann souwuel am eenzege binäre Modus sinn a sharded (horizontal-skalierbare Modus). Am zweete Fall kann et Daten an d'Wollek späicheren, an d'Stécker an den Index ginn separat gespäichert. An der Versioun 1.5 ass d'Fäegkeet fir op enger Plaz ze späicheren implementéiert, awer et ass nach net recommandéiert et an der Produktioun ze benotzen.

Chunks kënnen an S3-kompatibel Späichere gespäichert ginn, fir Indexen ze späicheren, benotzt horizontal skalierbar Datenbanken: Cassandra, BigTable oder DynamoDB. Aner Deeler vu Loki - Distributeuren (fir ze schreiwen) a Querier (fir Ufroen) - sinn stateless an skaléieren och horizontal.

Op der DevOpsDays Vancouver 2019 Konferenz huet ee vun de Participanten Callum Styan ugekënnegt datt mam Loki säi Projet Petabytes vu Logbicher huet mat engem Index vu manner wéi 1% vun der Gesamtgréisst: "Wéi Loki Metriken a Logbicher korreléiert - A spuert Iech Suen".

Verglach vu Loki an ELK

Index Gréisst

Fir déi resultéierend Indexgréisst ze testen, hunn ech Logbicher aus dem nginx Container geholl fir deen d'Pipeline uewen konfiguréiert war. D'Protokolldatei enthält 406 Linnen mat engem Gesamtvolumen vun 624 MB. Logbicher goufen bannent enger Stonn generéiert, ongeféier 109 records pro Sekonn.

E Beispill vun zwou Linnen aus dem Logbuch:

Wann indexéiert vun ELK, huet dëst eng Indexgréisst vun 30,3 MB ginn:

Am Fall vu Loki huet dëst ongeféier 128 KB Index an ongeféier 3,8 MB Daten a Stécker ginn. Et ass derwäert ze notéieren datt de Log kënschtlech generéiert gouf an net eng grouss Varietéit vun Daten huet. En einfache gzip op den ursprénglechen Docker JSON Log mat Daten huet eng Kompressioun vun 95,4% ginn, a gitt datt nëmmen de gereinegt nginx Log op Loki selwer geschéckt gouf, ass d'Kompressioun op 4 MB verständlech. D'total Zuel vun eenzegaartege Wäerter fir Loki Etiketten war 35, wat d'kleng Gréisst vum Index erkläert. Fir ELK gouf och de Logbuch geläscht. Also huet de Loki déi ursprénglech Donnéeën ëm 96% kompriméiert, an ELK ëm 70%.

Erënnerung Konsum

Wa mir de ganze Stack vu Prometheus an ELK vergläichen, dann "iest" Loki e puer Mol manner. Et ass kloer datt de Go Service manner verbraucht wéi de Java Service, an d'Gréisst vum Heap Elasticsearch JVM ze vergläichen an d'allokéiert Erënnerung fir Loki ass falsch, awer trotzdem ass et derwäert ze notéieren datt Loki vill manner Erënnerung benotzt. Seng CPU Virdeel ass net sou offensichtlech, awer et ass och präsent.

Speed

Loki "devours" Logbicher méi séier. D'Geschwindegkeet hänkt vu ville Faktoren of - wéi eng Zort Logbicher, wéi sophistikéiert mir se parséieren, Netzwierk, Disk, asw. - awer et ass definitiv méi héich wéi déi vun ELK (a mengem Test - ongeféier zweemol). Dëst gëtt erkläert duerch d'Tatsaach datt de Loki vill manner Daten an den Index setzt an deementspriechend manner Zäit fir Indexéierung verbréngt. An dësem Fall ass d'Situatioun ëmgedréint mat der Sichgeschwindegkeet: Loki verlangsamt merkbar op Daten méi grouss wéi e puer Gigabytes, während fir ELK d'Sichgeschwindegkeet net vun der Dategréisst hänkt.

Log Sich

Loki ass wesentlech méi schlecht wéi ELK wat d'Log Sichméiglechkeeten ugeet. Grep mat reegelméissegen Ausdrock ass eng staark Saach, awer et ass schlëmm wéi eng erwuessene Datebank. De Mangel u Gamme Ufroen, Aggregatioun nëmmen duerch Etiketten, d'Onméiglechkeet ouni Etiketten ze sichen - all dëst limitéiert eis op der Sich no Informatioun vun Interesse am Loki. Dëst bedeit net datt näischt ka fonnt ginn mat Loki, awer et definéiert de Flow fir mat Logbicher ze schaffen, wann Dir fir d'éischt e Problem op de Prometheus Charts fannt, a kuckt dann no wat an de Logbicher geschitt ass mat dësen Etiketten.

Interface

Éischtens ass et schéin (sorry, konnt net widderstoen). Grafana huet eng flott sicht Interface, mee Kibana ass vill méi funktionell.

Loki Virdeeler an Nodeeler

Vun de Pluses kann et bemierkt ginn datt Loki mat Prometheus integréiert, respektiv, mir kréien Metriken an Alarm aus der Këscht. Et ass bequem fir Logbicher ze sammelen an se mat Kubernetes Pods ze späicheren, well et eng Service Entdeckung huet, déi vum Prometheus ierflecher ass an automatesch Etiketten befestegt.

Vun de Minusen - schlecht Dokumentatioun. E puer Saachen, wéi d'Features an d'Fäegkeete vu Promtail, hunn ech nëmmen am Prozess vun der Studie vum Code entdeckt, de Virdeel vun der Open Source. En aneren Nodeel ass déi schwaach Parsingfäegkeeten. Zum Beispill kann Loki net Multiline Logbicher parséieren. Och d'Nodeeler enthalen d'Tatsaach datt Loki eng relativ jonk Technologie ass (Verëffentlechung 1.0 war am November 2019).

Konklusioun

Loki ass eng 100% interessant Technologie déi fir kleng a mëttel Projeten gëeegent ass, wat Iech erlaabt Iech vill Probleemer vun der Aggregatioun vu Logbicher, Log Sich, Iwwerwaachung an Analyse vu Logbicher ze léisen.

Mir benotzen de Loki net bei Badoo, well mir en ELK Stack hunn deen eis passt an deen iwwer d'Joren mat verschiddene personaliséierte Léisungen iwwerwuess ass. Fir eis ass de Stoussblock d'Sich an de Logbicher. Mat bal 100 GB Logbicher pro Dag ass et wichteg fir eis alles an e bësse méi ze fannen an et séier ze maachen. Fir Charten an Iwwerwaachung benotze mir aner Léisungen, déi op eis Bedierfnesser ugepasst sinn an matenee integréiert sinn. De Loki Stack huet konkret Virdeeler, awer et wäert eis net méi ginn wéi dat wat mir hunn, a seng Virdeeler wäerten net genau d'Käschte vun der Migratioun iwwerwannen.

An och wann no der Fuerschung kloer gouf datt mir Loki net benotze kënnen, hoffen mir datt dëse Post Iech bei der Wiel hëlleft.

De Repository mam Code deen am Artikel benotzt gëtt ass lokaliséiert hei.

Source: will.com

Sammelt Logbicher vum Loki