Casglu boncyffion o Loki

Yn Badoo, rydym yn monitro technolegau newydd yn gyson ac yn gwerthuso a ydynt yn werth eu defnyddio yn ein system. Hoffem rannu un o'r astudiaethau hyn gyda'r gymuned. Mae'n ymroddedig i Loki, system agregu logiau.

Mae Loki yn ateb ar gyfer storio a gwylio logiau, ac mae'r pentwr hwn hefyd yn darparu system hyblyg ar gyfer eu dadansoddi ac anfon data i Prometheus. Ym mis Mai, rhyddhawyd diweddariad arall, sy'n cael ei hyrwyddo'n weithredol gan y crewyr. Roedd gennym ddiddordeb yn yr hyn y gall Loki ei wneud, pa alluoedd y mae'n eu darparu, ac i ba raddau y gall weithredu fel dewis arall yn lle ELK, y pentwr a ddefnyddiwn yn awr.

Beth yw Loki

Mae Grafana Loki yn set o gydrannau ar gyfer system gyflawn ar gyfer gweithio gyda logiau. Yn wahanol i systemau tebyg eraill, mae Loki yn seiliedig ar y syniad o fynegeio metadata log yn unig - labeli (yn union fel yn Prometheus), a chywasgu'r logiau eu hunain ochr yn ochr yn dalpiau ar wahân.

Tudalen gartref, GitHub

Cyn i mi fynd i mewn i'r hyn y gallwch chi ei wneud gyda Loki, rwyf am egluro'r hyn a olygir gan "y syniad o fynegeio metadata yn unig". Gadewch i ni gymharu dull Loki a'r dull mynegeio mewn datrysiadau traddodiadol, fel Elasticsearch, gan ddefnyddio'r enghraifft o linell o log nginx:

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

Mae systemau traddodiadol yn dosrannu'r rhes gyfan, gan gynnwys meysydd gyda nifer fawr o werthoedd user_id ac item_id unigryw, ac yn storio popeth mewn mynegeion mawr. Mantais y dull hwn yw y gallwch redeg ymholiadau cymhleth yn gyflym, gan fod bron yr holl ddata yn y mynegai. Ond daw hyn ar gost gan fod y mynegai yn dod yn fawr, sy'n trosi'n ofynion cof. O ganlyniad, mae'r mynegai log testun llawn yn debyg o ran maint i'r logiau eu hunain. Er mwyn chwilio trwyddo'n gyflym, rhaid llwytho'r mynegai i'r cof. A pho fwyaf o logiau, y cyflymaf y bydd y mynegai yn tyfu a'r mwyaf o gof y mae'n ei ddefnyddio.

Mae dull Loki yn mynnu mai dim ond y data angenrheidiol sy'n cael ei dynnu o linyn, y mae nifer ei werthoedd yn fach. Fel hyn rydym yn cael mynegai bach a gallwn chwilio'r data trwy ei hidlo yn ôl amser a fesul maes mynegeio, ac yna sganio'r gweddill gydag ymadroddion rheolaidd neu chwiliad is-linyn. Nid yw'r broses yn ymddangos fel y gyflymaf, ond mae Loki yn rhannu'r cais yn sawl rhan ac yn eu gweithredu ochr yn ochr, gan brosesu llawer iawn o ddata mewn amser byr. Mae nifer y darnau a'r ceisiadau cyfochrog sydd ynddynt yn ffurfweddadwy; felly, mae faint o ddata y gellir ei brosesu fesul uned o amser yn dibynnu'n llinol ar faint o adnoddau a ddarperir.

Mae'r cyfaddawd hwn rhwng mynegai mawr, cyflym a mynegai grym 'n Ysgrublaidd, cyfochrog bach, yn caniatáu i Loki reoli cost y system. Gellir ei ffurfweddu'n hyblyg a'i ehangu yn unol ag anghenion.

Mae pentwr Loki yn cynnwys tair cydran: Promtail, Loki, Grafana. Mae Promtail yn casglu logiau, yn eu prosesu ac yn eu hanfon at Loki. Mae Loki yn eu cadw. A gall Grafana ofyn am ddata gan Loki a'i arddangos. Yn gyffredinol, gellir defnyddio Loki nid yn unig ar gyfer storio logiau a chwilio trwyddynt. Mae'r pentwr cyfan yn darparu cyfleoedd gwych ar gyfer prosesu a dadansoddi data sy'n dod i mewn gan ddefnyddio'r ffordd Prometheus.
Gellir dod o hyd i ddisgrifiad o'r broses osod yma.

Chwilio yn ôl logiau

Gallwch chwilio'r logiau mewn rhyngwyneb Grafana arbennig - Explorer. Mae'r ymholiadau'n defnyddio'r iaith LogQL, sy'n debyg iawn i'r PromQL a ddefnyddir yn Prometheus. Mewn egwyddor, gellir meddwl amdano fel grep dosranedig.

Mae'r rhyngwyneb chwilio yn edrych fel hyn:

Mae'r ymholiad ei hun yn cynnwys dwy ran: dewisydd a hidlydd. Mae Selector yn chwiliad sy'n defnyddio metadata mynegeiedig (labeli) sy'n cael eu neilltuo i logiau, ac mae hidlydd yn llinyn chwilio neu regexp sy'n hidlo cofnodion a ddiffinnir gan y dewiswr. Yn yr enghraifft a roddir: Mewn cromfachau cyrliog - y dewisydd, popeth ar ôl - yr hidlydd.

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

Oherwydd y ffordd y mae Loki yn gweithio, ni allwch wneud ymholiadau heb ddewiswr, ond gellir gwneud labeli mor gyffredinol ag y dymunwch.

Gwerth gwerth-allweddol mewn braces cyrliog yw dewisydd. Gallwch gyfuno dewiswyr a phennu amodau chwilio gwahanol gan ddefnyddio'r gweithredyddion =, != neu ymadroddion rheolaidd:

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

Mae hidlydd yn destun neu regexp a fydd yn hidlo'r holl ddata a dderbynnir gan y dewiswr.

Mae'n bosibl cael graffiau ad-hoc yn seiliedig ar y data a dderbyniwyd yn y modd metrigau. Er enghraifft, gallwch ddarganfod pa mor aml mae cofnod sy'n cynnwys y mynegai llinynnol yn ymddangos yn y logiau nginx:

Ceir disgrifiad llawn o'r galluoedd yn y ddogfennaeth LogQL.

Dosrannu log

Mae sawl ffordd o gasglu logiau:

• Gan ddefnyddio Promtail, cydran safonol o'r pentwr ar gyfer casglu boncyffion.
• Yn uniongyrchol o'r cynhwysydd docwr gan ddefnyddio Gyrrwr Logio Loki Docker.
• Defnyddiwch Fluentd neu Fluent Bit, a all anfon data i Loki. Yn wahanol i Promtail, mae ganddynt parsers parod ar gyfer bron unrhyw fath o log a gallant hefyd drin logiau aml-linell.

Fel arfer defnyddir Promtail ar gyfer dosrannu. Mae'n gwneud tri pheth:

• Yn dod o hyd i ffynonellau data.
• Atodwch labeli iddyn nhw.
• Yn anfon data i Loki.

Ar hyn o bryd gall Promtail ddarllen logiau o ffeiliau lleol ac o gyfnodolyn systemd. Rhaid ei osod ar bob peiriant y cesglir boncyffion ohono.

Mae integreiddio â Kubernetes: Mae Promtail yn awtomatig, trwy API Kubernetes REST, yn cydnabod cyflwr y clwstwr ac yn casglu logiau o nod, gwasanaeth neu god, gan bostio labeli ar unwaith yn seiliedig ar fetadata o Kubernetes (enw pod, enw ffeil, ac ati) .

Gallwch hefyd hongian labeli yn seiliedig ar ddata o'r log gan ddefnyddio Pipeline. Gall Pipeline Promtail gynnwys pedwar math o gamau. Mwy o fanylion - yn dogfennaeth swyddogol, Nodaf ar unwaith rai o'r arlliwiau.

1. Camau dosrannu. Dyma'r cam RegEx a JSON. Ar y cam hwn, rydym yn tynnu data o'r logiau i'r map a echdynnwyd fel y'i gelwir. Gallwn echdynnu o JSON trwy gopïo'r meysydd sydd eu hangen arnom i'r map a echdynnwyd, neu drwy ymadroddion rheolaidd (RegEx), lle mae grwpiau a enwir yn cael eu “mapio” i'r map a echdynnwyd. Mae'r map a echdynnwyd yn storfa gwerth allwedd, lle mae allwedd yn enw'r cae, a gwerth yw ei werth o'r logiau.
2. Camau trawsnewid. Mae gan y cam hwn ddau opsiwn: trawsnewid, lle rydym yn gosod y rheolau trawsnewid, a ffynhonnell - y ffynhonnell ddata ar gyfer trawsnewid o'r map a dynnwyd. Os nad oes cae o'r fath yn y map a dynnwyd, yna caiff ei greu. Fel hyn mae'n bosibl creu labeli nad ydynt yn seiliedig ar y map a dynnwyd. Ar y cam hwn gallwn drin y data yn y map a dynnwyd gan ddefnyddio gweddol bwerus Templed Golang. Yn ogystal, mae'n rhaid i ni gofio bod y map a dynnwyd yn cael ei lwytho'n gyfan gwbl yn ystod dosrannu, sy'n ei gwneud hi'n bosibl, er enghraifft, i wirio'r gwerth ynddo: “{{if .tag}gwerth tag yn bodoli{end}}”. Mae'r templed yn cefnogi amodau, dolenni, a rhai swyddogaethau llinynnol fel Amnewid a Thrimio.
3. Camau gweithredu. Ar y pwynt hwn gallwch chi wneud rhywbeth gyda'r cynnwys a echdynnwyd:
   • Creu label o'r data a echdynnwyd, a fydd yn cael ei fynegeio gan Loki.
   • Newid neu osod amser y digwyddiad o'r log.
   • Newidiwch y data (testun log) a fydd yn mynd i Loki.
   • Creu metrigau.
4. Camau hidlo. Y cam paru, lle gallwn naill ai anfon cofnodion nad oes angen i ni eu /dev/null neu eu hanfon ymlaen i'w prosesu ymhellach.

Gan ddefnyddio'r enghraifft o brosesu logiau nginx cyffredin, byddaf yn dangos sut y gallwch chi ddosrannu logiau gan ddefnyddio Promtail.

Ar gyfer y prawf, gadewch i ni gymryd delwedd nginx wedi'i haddasu jwilder/nginx-proxy:alpine fel nginx-proxy a daemon bach a all ymholi ei hun trwy HTTP. Mae gan yr ellyll sawl pwynt terfyn, y gall roi ymatebion o wahanol feintiau iddynt, gyda gwahanol statws HTTP a chyda gwahanol oedi.

Byddwn yn casglu boncyffion o gynwysyddion docwyr, y gellir eu canfod ar hyd y llwybr /var/lib/docker/containers/ / -json.log

Yn docker-compose.yml rydym yn ffurfweddu Promtail ac yn nodi'r llwybr i'r ffurfwedd:

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'
 // ...

Ychwanegwch y llwybr at y logiau i promtail.yml (mae opsiwn "docker" yn y ffurfwedd sy'n gwneud yr un peth mewn un llinell, ond ni fyddai mor amlwg):

scrape_configs:
 - job_name: containers

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

Pan fydd y cyfluniad hwn wedi'i alluogi, bydd Loki yn derbyn logiau o bob cynhwysydd. Er mwyn osgoi hyn, rydym yn newid gosodiadau'r nginx prawf yn docker-compose.yml - ychwanegu maes tag logio:

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

Golygu promtail.yml a sefydlu Pipeline. Mae'r mewnbwn yn cynnwys logiau o'r math canlynol:

{"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"}

camau piblinell:

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

Rydym yn tynnu'r ffrwd caeau, attrs, attrs.tag (os ydynt yn bodoli) o'r JSON sy'n dod i mewn ac yn eu rhoi yn y map a dynnwyd.

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

Pe baem yn llwyddo i roi maes y tag yn y map a dynnwyd, yna gan ddefnyddio regexp rydym yn tynnu enwau'r ddelwedd a'r cynhwysydd.

 - labels:
     image_name:
     container_name:

Rydym yn neilltuo labeli. Os canfyddir yr allweddi image_name a container_name yn y data a echdynnwyd, yna bydd eu gwerthoedd yn cael eu neilltuo i'r labeli priodol.

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

Rydym yn cael gwared ar yr holl logiau sydd heb labeli gosod image_name a container_name.

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

Ar gyfer pob log y mae ei image_name yn nginx.promtail.test, tynnwch y maes log o'r log ffynhonnell a'i roi yn y map a echdynnwyd gyda'r allwedd rhes.

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

Rydym yn clirio'r llinell fewnbwn gydag ymadroddion rheolaidd ac yn tynnu allan y rhith-westeiwr nginx a llinell log nginx.

     - 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.]+)")?

Dosrannu log nginx gydag ymadroddion rheolaidd.

    - 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>[^/?.]+).*$

Dosrannu cais_url. Gan ddefnyddio regexp rydym yn pennu pwrpas y cais: i statig data, i luniau, i API ac yn gosod yr allwedd cyfatebol yn y map a dynnwyd.

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

Gan ddefnyddio gweithredwyr amodol yn Templed, rydym yn gwirio'r meysydd gosod yn y map a dynnwyd ac yn gosod y gwerthoedd gofynnol ar gyfer y maes request_type: llun, statig, API. Neilltuo eraill os yw'n methu. mae request_type bellach yn cynnwys y math o gais.

       - labels:
           api_request:
           virtual_host:
           request_type:
           status:

Rydym yn gosod y labeli api_request, virtual_host, request_type a statws (statws HTTP) yn seiliedig ar yr hyn y gwnaethom lwyddo i'w roi yn y map a dynnwyd.

       - output:
           source: nginx_log_row

Newid allbwn. Nawr mae'r log nginx wedi'i lanhau o'r map a dynnwyd yn mynd i Loki.

Ar ôl rhedeg y ffurfwedd uchod, gallwch weld bod pob cofnod yn cael ei neilltuo labeli yn seiliedig ar ddata o'r log.

Un peth i'w gadw mewn cof yw y gall adfer labeli â nifer fawr o werthoedd (cardinality) arafu Loki yn sylweddol. Hynny yw, ni ddylech roi yn y mynegai, er enghraifft, user_id. Darllenwch fwy am hyn yn yr erthyglSut y gall labeli yn Loki wneud ymholiadau log yn gyflymach ac yn haws" Ond nid yw hyn yn golygu na allwch chwilio yn ôl user_id heb fynegeion. Mae angen i chi ddefnyddio hidlwyr wrth chwilio ("cydio" y data), ac mae'r mynegai yma yn gweithredu fel dynodwr ffrwd.

Delweddu log

Gall Loki weithredu fel ffynhonnell ddata ar gyfer graffiau Grafana gan ddefnyddio LogQL. Cefnogir y nodweddion canlynol:

• cyfradd — nifer y cofnodion yr eiliad;
• cyfrif dros amser - nifer y cofnodion yn yr ystod a roddir.

Mae yna hefyd swyddogaethau agregu Swm, Cyf ac eraill. Gallwch chi adeiladu graffiau eithaf cymhleth, er enghraifft, graff o nifer y gwallau HTTP:

Mae'r ffynhonnell ddata safonol Loki ychydig yn llai ymarferol o'i gymharu â ffynhonnell ddata Prometheus (er enghraifft, ni allwch newid y chwedl), ond gellir cysylltu Loki fel ffynhonnell â'r math Prometheus. Dydw i ddim yn siŵr ai ymddygiad wedi’i ddogfennu yw hwn, ond a barnu yn ôl ymateb y datblygwyr “Sut i ffurfweddu Loki fel ffynhonnell ddata Prometheus? · Rhifyn #1222 · grafana/loki”, er enghraifft, mae'n gwbl gyfreithiol ac mae Loki yn gwbl gydnaws â PromQL.

Ychwanegu Loki fel ffynhonnell ddata gyda math Prometheus ac ychwanegu URL / loki:

A gallwch chi wneud graffiau, fel petaem yn gweithio gyda metrigau gan Prometheus:

Credaf mai dros dro yw'r anghysondeb o ran ymarferoldeb a bydd y datblygwyr yn cywiro hyn yn y dyfodol.

Metrigau

Mae Loki yn darparu'r gallu i dynnu metrigau rhifiadol o foncyffion a'u hanfon at Prometheus. Er enghraifft, mae log nginx yn cynnwys nifer y bytes fesul ymateb, yn ogystal â, gydag addasiad penodol o'r fformat log safonol, yr amser mewn eiliadau a gymerodd i ymateb. Gellir echdynnu'r data hwn a'i anfon at Prometheus.

Ychwanegu adran arall i 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

Mae'r opsiwn yn caniatáu ichi ddiffinio a diweddaru metrigau yn seiliedig ar ddata o'r map a dynnwyd. Nid yw'r metrigau hyn yn cael eu hanfon at Loki - maent yn ymddangos ym mhennod Promtail / metrigau. Rhaid ffurfweddu Prometheus i dderbyn y data a dderbyniwyd ar y cam hwn. Yn yr enghraifft uchod, ar gyfer request_type = “api” rydym yn casglu metrig histogram. Gyda'r math hwn o fetrigau mae'n gyfleus cael canraddau. Ar gyfer statig a llun, rydym yn casglu swm y beit a nifer y rhesi y cawsom beit ynddynt i gyfrifo'r cyfartaledd.

Darllenwch fwy am fetrigau yma.

Agorwch borthladd ar Promtail:

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

Sicrhewch fod metrigau gyda'r rhagddodiad promtail_custom yn ymddangos:

Sefydlu Prometheus. Ychwanegu hysbyseb swydd:

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

Ac rydyn ni'n tynnu graff:

Fel hyn gallwch ddarganfod, er enghraifft, y pedwar ymholiad arafaf. Gallwch hefyd ffurfweddu monitro ar gyfer y metrigau hyn.

Graddio

Gall Loki fod naill ai mewn modd deuaidd sengl neu mewn modd wedi'i dorri (modd graddadwy llorweddol). Yn yr ail achos, gall arbed data i'r cwmwl, ac mae'r talpiau a'r mynegai yn cael eu storio ar wahân. Mae fersiwn 1.5 yn cyflwyno'r gallu i storio mewn un lle, ond ni argymhellir ei ddefnyddio wrth gynhyrchu eto.

Gellir storio talpiau mewn storfa sy'n gydnaws â S3, a gellir defnyddio cronfeydd data graddadwy llorweddol i storio mynegeion: Cassandra, BigTable neu DynamoDB. Mae rhannau eraill o Loki - Dosbarthwyr (ar gyfer ysgrifennu) a Querier (ar gyfer ymholiadau) - yn ddi-wladwriaeth a hefyd ar raddfa llorweddol.

Yng nghynhadledd DevOpsDays Vancouver 2019, cyhoeddodd un o’r cyfranogwyr Callum Styan fod gan ei brosiect gyda Loki betabytes o foncyffion gyda mynegai o lai nag 1% o’r cyfanswm maint: “Sut mae Loki yn Cydberthyn Metrigau a Logiau - Ac Yn Arbed Arian i Chi".

Cymhariaeth o Loki ac ELK

Maint mynegai

I brofi maint y mynegai sy'n deillio o hynny, cymerais logiau o'r cynhwysydd nginx y ffurfweddwyd y Piblinell uchod ar ei gyfer. Roedd y ffeil log yn cynnwys 406 o linellau gyda chyfanswm cyfaint o 624 MB. Cynhyrchwyd logiau o fewn awr, tua 109 o gofnodion yr eiliad.

Enghraifft o ddwy linell o'r log:

Pan gafodd ei fynegeio gan ELK, roedd hyn yn rhoi maint mynegai o 30,3 MB:

Yn achos Loki, arweiniodd hyn at tua 128 KB o fynegai a thua 3,8 MB o ddata mewn talpiau. Mae'n werth nodi bod y log wedi'i gynhyrchu'n artiffisial ac nad oedd ganddo amrywiaeth fawr o ddata. Rhoddodd gzip syml ar y log Docker JSON gwreiddiol gyda data gywasgiad o 95,4%, a chan gymryd i ystyriaeth y ffaith mai dim ond y log nginx wedi'i lanhau a anfonwyd at Loki ei hun, mae cywasgu hyd at 4 MB yn ddealladwy. Cyfanswm y gwerthoedd unigryw ar gyfer labeli Loki oedd 35, sy'n esbonio maint bach y mynegai. Ar gyfer ELK, cliriwyd y log hefyd. Felly, cywasgodd Loki y data gwreiddiol 96%, ac ELK 70%.

Defnydd cof

Os byddwn yn cymharu'r pentwr Prometheus ac ELK cyfan, yna mae Loki yn “bwyta” sawl gwaith yn llai. Mae'n amlwg bod gwasanaeth Go yn defnyddio llai na gwasanaeth Java, ac mae cymharu maint y JVM Heap Elasticsearch a'r cof a neilltuwyd ar gyfer Loki yn anghywir, ond serch hynny mae'n werth nodi bod Loki yn defnyddio llawer llai o gof. Nid yw ei fantais CPU mor amlwg, ond mae hefyd yn bresennol.

Cyflymder

Mae Loki yn “diffodd” yn logio'n gyflymach. Mae'r cyflymder yn dibynnu ar lawer o ffactorau - pa fath o logiau yw, pa mor soffistigedig ydyn ni wrth eu dosrannu, rhwydwaith, disg, ac ati - ond mae'n bendant yn uwch na ELK (yn fy mhrawf - tua dwywaith cymaint). Eglurir hyn gan y ffaith bod Loki yn rhoi llawer llai o ddata yn y mynegai ac, yn unol â hynny, yn treulio llai o amser ar fynegeio. Gyda chyflymder chwilio, mae'r sefyllfa i'r gwrthwyneb: mae Loki yn amlwg yn arafu ar ddata sy'n fwy na sawl gigabeit, tra nad yw cyflymder chwilio ELK yn dibynnu ar faint y data.

Chwilio yn ôl logiau

Mae Loki yn sylweddol israddol i ELK o ran galluoedd chwilio logiau. Mae Grep gydag ymadroddion rheolaidd yn bwerus, ond mae'n israddol i gronfa ddata aeddfed. Y diffyg ymholiadau amrediad, agregu yn ôl labeli yn unig, yr anallu i chwilio heb labeli - mae hyn i gyd yn ein cyfyngu i chwilio am wybodaeth o ddiddordeb yn Loki. Nid yw hyn yn golygu na ellir dod o hyd i unrhyw beth gan ddefnyddio Loki, ond mae'n diffinio'r llif o weithio gyda boncyffion pan fyddwch chi'n dod o hyd i broblem gyntaf yn siartiau Prometheus, ac yna'n defnyddio'r labeli hyn i chwilio am yr hyn a ddigwyddodd yn y logiau.

rhyngwyneb

Yn gyntaf oll, mae'n brydferth (sori, ni allai wrthsefyll). Mae gan Grafana ryngwyneb braf, ond mae Kibana yn llawer mwy cyfoethog o ran nodweddion.

Manteision ac anfanteision Loki

O'r manteision, gellir nodi bod Loki yn integreiddio â Prometheus, yn y drefn honno, rydym yn cael metrigau a rhybuddion allan o'r blwch. Mae'n gyfleus casglu logiau a'u storio gyda Kubernetes Pods, gan fod ganddo ddarganfyddiad gwasanaeth a etifeddwyd gan Prometheus ac mae'n atodi labeli yn awtomatig.

Yr anfantais yw dogfennaeth wan. Rhai pethau, er enghraifft, nodweddion a galluoedd Promtail, darganfyddais yn y broses o astudio'r cod yn unig, yn ffodus mae'n ffynhonnell agored. Anfantais arall yw galluoedd dosrannu gwan. Er enghraifft, ni all Loki ddosrannu logiau aml-linell. Anfantais arall yw bod Loki yn dechnoleg gymharol ifanc (rhyddhawyd 1.0 ym mis Tachwedd 2019).

Casgliad

Mae Loki yn dechnoleg ddiddorol 100% sy'n addas ar gyfer prosiectau bach a chanolig, sy'n eich galluogi i ddatrys llawer o broblemau o agregu logiau, chwilio logiau, monitro a dadansoddi logiau.

Nid ydym yn defnyddio Loki yn Badoo oherwydd mae gennym stac ELK sy'n addas i ni ac sydd wedi tyfu'n wyllt gyda gwahanol atebion arfer dros y blynyddoedd. I ni, y maen tramgwydd yw chwilio trwy foncyffion. Gyda bron i 100 GB o logiau y dydd, mae'n bwysig i ni allu dod o hyd i bopeth ac ychydig mwy a'i wneud yn gyflym. Ar gyfer siartio a monitro, rydym yn defnyddio atebion eraill sydd wedi'u teilwra i'n hanghenion a'u hintegreiddio â'n gilydd. Mae gan stac Loki fanteision diriaethol, ond ni fydd yn rhoi mwy i ni nag sydd gennym eisoes, ac yn sicr ni fydd ei fanteision yn gorbwyso cost mudo.

Ac er y daeth yn amlwg ar ôl ymchwil na allwn ddefnyddio Loki, rydym yn gobeithio y bydd y swydd hon yn eich helpu yn eich dewis.

Mae'r ystorfa gyda'r cod a ddefnyddir yn yr erthygl wedi'i lleoli yma.

Ffynhonnell: hab.com