પરિચય

બીજી સિસ્ટમ ગોઠવતી વખતે, અમને મોટી સંખ્યામાં વિવિધ લોગ પર પ્રક્રિયા કરવાની જરૂરિયાતનો સામનો કરવો પડ્યો. ELK ને સાધન તરીકે પસંદ કરવામાં આવ્યું હતું. આ લેખ આ સ્ટેક સેટ કરવાના અમારા અનુભવ વિશે વાત કરશે.

અમે તેની તમામ ક્ષમતાઓનું વર્ણન કરવા માટે કોઈ ધ્યેય નક્કી કરતા નથી, પરંતુ અમે વ્યવહારિક સમસ્યાઓના ઉકેલ પર ધ્યાન કેન્દ્રિત કરવા માંગીએ છીએ. આ તે હકીકતને કારણે છે કે પૂરતા પ્રમાણમાં મોટી માત્રામાં દસ્તાવેજીકરણ અને તૈયાર છબીઓ સાથે, ત્યાં ઘણી બધી મુશ્કેલીઓ છે, ઓછામાં ઓછી અમને તે મળી.

અમે ડોકર-કંપોઝ દ્વારા સ્ટેક જમાવ્યું. વધુમાં, અમારી પાસે સારી રીતે લખાયેલ docker-compose.yml હતું જેણે અમને લગભગ કોઈ સમસ્યા વિના સ્ટેક વધારવાની મંજૂરી આપી હતી. અને અમને એવું લાગતું હતું કે વિજય પહેલેથી જ નજીક છે, હવે અમે અમારી જરૂરિયાતોને અનુરૂપ થવા માટે તેને થોડું ટ્વિસ્ટ કરીશું અને બસ.

કમનસીબે, અમારી એપ્લિકેશનમાંથી લોગ મેળવવા અને પ્રક્રિયા કરવા માટે સિસ્ટમને ટ્યુન કરવાનો પ્રયાસ તરત જ સફળ થયો ન હતો. તેથી, અમે નક્કી કર્યું કે તે દરેક ઘટકનો અલગથી અભ્યાસ કરવા યોગ્ય છે, અને પછી તેમના જોડાણો પર પાછા ફરો.

તો ચાલો લોગસ્ટેશ સાથે શરૂઆત કરીએ.

પર્યાવરણ, જમાવટ, કન્ટેનરમાં લોગસ્ટેશ ચલાવવું

જમાવટ માટે, અમે ડોકર-કંપોઝનો ઉપયોગ કરીએ છીએ, અહીં વર્ણવેલ પ્રયોગો MacOS અને Ubuntu 18.0.4 પર હાથ ધરવામાં આવ્યા હતા.

અમારી મૂળ docker-compose.yml માં જે લોગસ્ટેશ છબી હતી તે છે docker.elastic.co/logstash/logstash:6.3.2

અમે પ્રયોગો માટે તેનો ઉપયોગ કરીશું.

logstash ચલાવવા માટે, અમે એક અલગ docker-compose.yml લખ્યું છે. અલબત્ત, કમાન્ડ લાઇનથી ઇમેજ લોંચ કરવાનું શક્ય હતું, પરંતુ છેવટે, અમે એક ચોક્કસ કાર્ય હલ કર્યું, જ્યાં ડોકર-કંપોઝથી બધું અમારા માટે લોન્ચ કરવામાં આવ્યું છે.

રૂપરેખાંકન ફાઇલો વિશે સંક્ષિપ્તમાં

વર્ણનમાંથી નીચે મુજબ, logstash એક ચેનલ માટે ચલાવી શકાય છે, આ કિસ્સામાં, તેને *.conf ફાઇલ અથવા ઘણી ચેનલો માટે સ્થાનાંતરિત કરવાની જરૂર છે, આ કિસ્સામાં તેને pipelines.yml ફાઇલ સ્થાનાંતરિત કરવાની જરૂર છે, જે બદલામાં , દરેક ચેનલ માટે .conf ફાઈલોનો સંદર્ભ લેશે.
અમે બીજો રસ્તો લીધો. તે અમને વધુ સર્વતોમુખી અને માપી શકાય તેવું લાગતું હતું. તેથી, અમે pipelines.yml બનાવી, અને પાઇપલાઇન્સ ડિરેક્ટરી બનાવી જેમાં આપણે દરેક ચેનલ માટે .conf ફાઇલો મૂકીશું.

કન્ટેનરની અંદર બીજી રૂપરેખાંકન ફાઇલ છે - logstash.yml. અમે તેને સ્પર્શતા નથી, અમે તેનો ઉપયોગ કરીએ છીએ.

તેથી અમારી ડિરેક્ટરી માળખું છે:

હાલમાં, અમે ધારીએ છીએ કે ઇનપુટ ડેટા મેળવવા માટે આ પોર્ટ 5046 પર tcp છે, અને અમે આઉટપુટ માટે stdout નો ઉપયોગ કરીશું.

અહીં પ્રથમ રન માટે આટલું સરળ રૂપરેખાંકન છે. કારણ કે પ્રારંભિક કાર્ય લોન્ચ કરવાનું છે.

તેથી અમારી પાસે આ docker-compose.yml છે

version: '3'

networks:
  elk:

volumes:
  elasticsearch:
    driver: local

services:

  logstash:
    container_name: logstash_one_channel
    image: docker.elastic.co/logstash/logstash:6.3.2
    networks:
      	- elk
    ports:
      	- 5046:5046
    volumes:
      	- ./config/pipelines.yml:/usr/share/logstash/config/pipelines.yml:ro
	- ./config/pipelines:/usr/share/logstash/config/pipelines:ro

આપણે અહીં શું જોઈએ છીએ?

1. નેટવર્ક્સ અને વોલ્યુમો મૂળ docker-compose.yml (એ જ્યાં સમગ્ર સ્ટેક લોન્ચ કરવામાં આવે છે) માંથી લેવામાં આવ્યા હતા અને મને લાગે છે કે તેઓ અહીં એકંદર ચિત્રને મોટા પ્રમાણમાં અસર કરતા નથી.
2. અમે docker.elastic.co/logstash/logstash:6.3.2 ઈમેજમાંથી એક સેવા (સેવાઓ) લોગસ્ટેશ બનાવીએ છીએ અને તેને logstash_one_channel નામ આપીએ છીએ.
3. અમે કન્ટેનરની અંદર પોર્ટ 5046 ને સમાન આંતરિક પોર્ટ પર ફોરવર્ડ કરી રહ્યા છીએ.
4. અમે અમારી ./config/pipelines.yml પાઇપ રૂપરેખાંકન ફાઇલને કન્ટેનરની અંદર /usr/share/logstash/config/pipelines.yml ફાઇલ સાથે મેપ કરીએ છીએ, જ્યાં logstash તેને ઉપાડશે અને તેને ફક્ત વાંચવા માટે બનાવશે.
5. અમે ./config/pipelines ડિરેક્ટરી, જ્યાં અમારી પાસે પાઇપ રૂપરેખાંકન ફાઇલો છે, તેને /usr/share/logstash/config/pipelines ડિરેક્ટરીમાં મેપ કરીએ છીએ અને તેને ફક્ત વાંચવા માટે બનાવીએ છીએ.

piping.yml ફાઇલ

- pipeline.id: HABR
  pipeline.workers: 1
  pipeline.batch.size: 1
  path.config: "./config/pipelines/habr_pipeline.conf"

તે HABR ઓળખકર્તા સાથેની એક ચેનલ અને તેની રૂપરેખાંકન ફાઇલના પાથનું વર્ણન કરે છે.

અને છેલ્લે ફાઈલ "./config/pipelines/habr_pipeline.conf"

input {
  tcp {
    port => "5046"
   }
  }
filter {
  mutate {
    add_field => [ "habra_field", "Hello Habr" ]
    }
  }
output {
  stdout {
      
    }
  }

અમે હમણાં માટે તેના વર્ણનમાં જઈશું નહીં, અમે ચલાવવાનો પ્રયાસ કરીએ છીએ:

docker-compose up

આપણે શું જોઈએ છીએ?

કન્ટેનર ચાલુ થઈ ગયું છે. અમે તેનું કાર્ય ચકાસી શકીએ છીએ:

echo '13123123123123123123123213123213' | nc localhost 5046

અને અમે કન્ટેનર કન્સોલમાં પ્રતિસાદ જોઈએ છીએ:

પરંતુ તે જ સમયે, આપણે એ પણ જોઈએ છીએ:

logstash_one_channel | [2019-04-29T11:28:59,790][ERROR][logstash.licensechecker.licensereader] લાયસન્સ સર્વરમાંથી લાઇસન્સ માહિતી પુનઃપ્રાપ્ત કરવામાં અસમર્થ {:message=>"Elasticsearch અપ્રિય: [http://elasticsearch:9200/][Manticore ::રિઝોલ્યુશન નિષ્ફળતા]સ્થિતિસ્થાપક શોધ", ...

logstash_one_channel | [2019-04-29T11:28:59,894][INFO ][logstash.pipeline ] પાઇપલાઇન સફળતાપૂર્વક શરૂ થઈ {:pipeline_id=>".monitoring-logstash", :thread=>"# »}

logstash_one_channel | [2019-04-29T11:28:59,988][INFO ][logstash.agent ] પાઈપલાઈન ચાલી રહી છે {:count=>2, :running_pipelines=>[:HABR, :."monitoring-logstash"], :non_running_pipelines=>[ ]}
logstash_one_channel | [2019-04-29T11:29:00,015][ERROR][logstash.inputs.metrics ] X-Pack Logstash પર ઇન્સ્ટોલ કરેલું છે પણ Elasticsearch પર નહીં. મોનિટરિંગ સુવિધાનો ઉપયોગ કરવા માટે કૃપા કરીને Elasticsearch પર X-Pack ઇન્સ્ટોલ કરો. અન્ય સુવિધાઓ ઉપલબ્ધ હોઈ શકે છે.
logstash_one_channel | [2019-04-29T11:29:00,526][INFO [logstash.agent ] Logstash API એન્ડપોઇન્ટ {:port=>9600} સફળતાપૂર્વક શરૂ થયું
logstash_one_channel | [2019-04-29T11:29:04,478][INFO ][logstash.outputs.elasticsearch] Elasticsearch કનેક્શન કામ કરી રહ્યું છે કે કેમ તે જોવા માટે આરોગ્ય તપાસ ચલાવવી {:healthcheck_url=>http://elasticsearch:9200/, :path=> "/"}
logstash_one_channel | [2019-04-29T11:29:04,487][WARN ][logstash.outputs.elasticsearch] ડેડ ES ઉદાહરણ સાથે કનેક્શનને પુનઃજીવિત કરવાનો પ્રયાસ કર્યો, પરંતુ એક ભૂલ આવી. {:url=>"સ્થિતિસ્થાપક:9200/", :error_type=>LogStash::Outputs::ElasticSearch::HttpClient::Pool::HostUnreachableError, :error=>"Elasticsearch Unreachable: [http://elasticsearch:9200/][Manticore:]ResolutionFail સ્થિતિસ્થાપક શોધ"}
logstash_one_channel | [2019-04-29T11:29:04,704][INFO ][logstash.licensechecker.licensereader] Elasticsearch કનેક્શન કામ કરી રહ્યું છે કે કેમ તે જોવા માટે આરોગ્ય તપાસ ચલાવવી {:healthcheck_url=>http://elasticsearch:9200/, :path=> "/"}
logstash_one_channel | [2019-04-29T11:29:04,710][WARN ][logstash.licensechecker.licensereader] મૃત ES ઉદાહરણ સાથે કનેક્શનને પુનઃજીવિત કરવાનો પ્રયાસ કર્યો, પરંતુ એક ભૂલ આવી. {:url=>"સ્થિતિસ્થાપક:9200/", :error_type=>LogStash::Outputs::ElasticSearch::HttpClient::Pool::HostUnreachableError, :error=>"Elasticsearch Unreachable: [http://elasticsearch:9200/][Manticore:]ResolutionFail સ્થિતિસ્થાપક શોધ"}

અને અમારો લોગ દરેક સમયે ક્રોલ થાય છે.

અહીં મેં લીલા રંગમાં સંદેશ પ્રકાશિત કર્યો છે કે પાઇપલાઇન સફળતાપૂર્વક શરૂ થઈ છે, લાલ રંગમાં ભૂલ સંદેશ અને પીળા રંગમાં સંપર્ક કરવાનો પ્રયાસ કરવાનો સંદેશ સ્થિતિસ્થાપક: 9200
આ એ હકીકતને કારણે થાય છે કે ઈમેજમાં સમાવિષ્ટ logstash.conf માં, elasticsearchની ઉપલબ્ધતા માટે તપાસ છે. છેવટે, logstash ધારે છે કે તે એલ્ક સ્ટેકના ભાગ રૂપે કામ કરે છે, અને અમે તેને અલગ કરી દીધું.

તમે કામ કરી શકો છો, પરંતુ તે અનુકૂળ નથી.

XPACK_MONITORING_ENABLED પર્યાવરણ વેરીએબલ દ્વારા આ ચેકને અક્ષમ કરવાનો ઉકેલ છે.

ચાલો docker-compose.yml માં ફેરફાર કરીએ અને તેને ફરીથી ચલાવીએ:

version: '3'

networks:
  elk:

volumes:
  elasticsearch:
    driver: local

services:

  logstash:
    container_name: logstash_one_channel
    image: docker.elastic.co/logstash/logstash:6.3.2
    networks:
      - elk
    environment:
      XPACK_MONITORING_ENABLED: "false"
    ports:
      - 5046:5046
   volumes:
      - ./config/pipelines.yml:/usr/share/logstash/config/pipelines.yml:ro
      - ./config/pipelines:/usr/share/logstash/config/pipelines:ro

હવે, બધું સારું છે. કન્ટેનર પ્રયોગો માટે તૈયાર છે.

અમે બાજુના કન્સોલમાં ફરીથી ટાઇપ કરી શકીએ છીએ:

echo '13123123123123123123123213123213' | nc localhost 5046

અને જુઓ:

logstash_one_channel | {
logstash_one_channel |         "message" => "13123123123123123123123213123213",
logstash_one_channel |      "@timestamp" => 2019-04-29T11:43:44.582Z,
logstash_one_channel |        "@version" => "1",
logstash_one_channel |     "habra_field" => "Hello Habr",
logstash_one_channel |            "host" => "gateway",
logstash_one_channel |            "port" => 49418
logstash_one_channel | }

એક ચેનલમાં કામ કરો

તેથી અમે શરૂ કર્યું. હવે તમે ખરેખર લોગસ્ટેશને સીધું ગોઠવવા માટે સમય કાઢી શકો છો. ચાલો હમણાં માટે pipelines.yml ફાઇલને સ્પર્શ ન કરીએ, ચાલો જોઈએ કે આપણે એક ચેનલ સાથે કામ કરીને શું મેળવી શકીએ છીએ.

મારે કહેવું જ જોઇએ કે ચેનલ રૂપરેખાંકન ફાઇલ સાથે કામ કરવાના સામાન્ય સિદ્ધાંતનું અહીં અધિકૃત માર્ગદર્શિકામાં સારી રીતે વર્ણન કરવામાં આવ્યું છે અહીં
જો તમે રશિયનમાં વાંચવા માંગતા હો, તો અમે આનો ઉપયોગ કર્યો લેખ(પરંતુ ક્વેરી સિન્ટેક્સ ત્યાં જૂનો છે, તમારે આને ધ્યાનમાં લેવાની જરૂર છે).

ચાલો ઇનપુટ વિભાગમાંથી ક્રમિક રીતે જઈએ. અમે પહેલાથી જ tcp પર કામ જોયું છે. અહીં બીજું શું રસપ્રદ હોઈ શકે?

હૃદયના ધબકારાનો ઉપયોગ કરીને સંદેશાઓનું પરીક્ષણ કરો

સ્વચાલિત પરીક્ષણ સંદેશાઓ જનરેટ કરવાની આવી રસપ્રદ શક્યતા છે.
આ કરવા માટે, તમારે ઇનપુટ વિભાગમાં હાર્ટબીન પ્લગઇન શામેલ કરવાની જરૂર છે.

input {
  heartbeat {
    message => "HeartBeat!"
   }
  } 

અમે તેને ચાલુ કરીએ છીએ, અમે એક મિનિટમાં એકવાર પ્રાપ્ત કરવાનું શરૂ કરીએ છીએ

logstash_one_channel | {
logstash_one_channel |      "@timestamp" => 2019-04-29T13:52:04.567Z,
logstash_one_channel |     "habra_field" => "Hello Habr",
logstash_one_channel |         "message" => "HeartBeat!",
logstash_one_channel |        "@version" => "1",
logstash_one_channel |            "host" => "a0667e5c57ec"
logstash_one_channel | }

અમે વધુ વખત પ્રાપ્ત કરવા માંગીએ છીએ, અમારે અંતરાલ પરિમાણ ઉમેરવાની જરૂર છે.
આ રીતે અમને દર 10 સેકન્ડે એક સંદેશ પ્રાપ્ત થશે.

input {
  heartbeat {
    message => "HeartBeat!"
    interval => 10
   }
  }

ફાઇલમાંથી ડેટા મેળવવો

અમે ફાઇલ મોડ જોવાનું પણ નક્કી કર્યું. જો તે ફાઇલ સાથે બરાબર કામ કરે છે, તો શક્ય છે કે કોઈ એજન્ટની જરૂર નથી, સારું, ઓછામાં ઓછા સ્થાનિક ઉપયોગ માટે.

વર્ણન મુજબ, ઓપરેશનનો મોડ tail -f જેવો જ હોવો જોઈએ, એટલે કે. નવી લાઇન વાંચે છે અથવા વૈકલ્પિક રીતે, આખી ફાઇલ વાંચે છે.

તો આપણે શું મેળવવા માંગીએ છીએ:

1. અમે એક લોગ ફાઈલ સાથે જોડાયેલી લીટીઓ મેળવવા માંગીએ છીએ.
2. અમે ડેટા પ્રાપ્ત કરવા માંગીએ છીએ જે ઘણી લોગ ફાઈલો પર લખાયેલ છે, જ્યારે તે ક્યાંથી પ્રાપ્ત થયું હતું તે અલગ કરવામાં સક્ષમ છીએ.
3. અમે ખાતરી કરવા માંગીએ છીએ કે જ્યારે લોગસ્ટેશ પુનઃપ્રારંભ થાય, ત્યારે તે આ ડેટા ફરીથી પ્રાપ્ત કરશે નહીં.
4. અમે તપાસવા માંગીએ છીએ કે જો લોગસ્ટેશ અક્ષમ છે, અને ડેટા ફાઇલોમાં લખવાનું ચાલુ રાખે છે, તો જ્યારે અમે તેને ચલાવીશું, ત્યારે અમને આ ડેટા પ્રાપ્ત થશે.

પ્રયોગ કરવા માટે, ચાલો docker-compose.yml માં વધુ એક લીટી ઉમેરીએ, જ્યાં આપણે ફાઇલો મૂકીએ છીએ તે ડિરેક્ટરી ખોલીએ.

version: '3'

networks:
  elk:

volumes:
  elasticsearch:
    driver: local

services:

  logstash:
    container_name: logstash_one_channel
    image: docker.elastic.co/logstash/logstash:6.3.2
    networks:
      - elk
    environment:
      XPACK_MONITORING_ENABLED: "false"
    ports:
      - 5046:5046
   volumes:
      - ./config/pipelines.yml:/usr/share/logstash/config/pipelines.yml:ro
      - ./config/pipelines:/usr/share/logstash/config/pipelines:ro
      - ./logs:/usr/share/logstash/input

અને habr_pipeline.conf માં ઇનપુટ વિભાગ બદલો

input {
  file {
    path => "/usr/share/logstash/input/*.log"
   }
  }

અમે શરૂ:

docker-compose up

લોગ ફાઇલો બનાવવા અને લખવા માટે, અમે આદેશનો ઉપયોગ કરીશું:


echo '1' >> logs/number1.log

{
logstash_one_channel |            "host" => "ac2d4e3ef70f",
logstash_one_channel |     "habra_field" => "Hello Habr",
logstash_one_channel |      "@timestamp" => 2019-04-29T14:28:53.876Z,
logstash_one_channel |        "@version" => "1",
logstash_one_channel |         "message" => "1",
logstash_one_channel |            "path" => "/usr/share/logstash/input/number1.log"
logstash_one_channel | }

હા, તે કામ કરે છે!

તે જ સમયે, આપણે જોઈએ છીએ કે આપણે આપમેળે પાથ ફીલ્ડ ઉમેર્યું છે. તેથી ભવિષ્યમાં, અમે તેના દ્વારા રેકોર્ડ્સ ફિલ્ટર કરી શકીશું.

ચાલો ફરીથી પ્રયત્ન કરીએ:

echo '2' >> logs/number1.log

{
logstash_one_channel |            "host" => "ac2d4e3ef70f",
logstash_one_channel |     "habra_field" => "Hello Habr",
logstash_one_channel |      "@timestamp" => 2019-04-29T14:28:59.906Z,
logstash_one_channel |        "@version" => "1",
logstash_one_channel |         "message" => "2",
logstash_one_channel |            "path" => "/usr/share/logstash/input/number1.log"
logstash_one_channel | }

અને હવે બીજી ફાઇલ પર:

 echo '1' >> logs/number2.log

{
logstash_one_channel |            "host" => "ac2d4e3ef70f",
logstash_one_channel |     "habra_field" => "Hello Habr",
logstash_one_channel |      "@timestamp" => 2019-04-29T14:29:26.061Z,
logstash_one_channel |        "@version" => "1",
logstash_one_channel |         "message" => "1",
logstash_one_channel |            "path" => "/usr/share/logstash/input/number2.log"
logstash_one_channel | }

સરસ! ફાઇલ લેવામાં આવી હતી, પાથ યોગ્ય રીતે નિર્દિષ્ટ કરવામાં આવ્યો હતો, બધું બરાબર છે.

લોગસ્ટેશ બંધ કરો અને પુનઃપ્રારંભ કરો. ચાલો રાહ જોઈએ. મૌન. તે. અમને આ રેકોર્ડ્સ ફરીથી પ્રાપ્ત થતા નથી.

અને હવે સૌથી હિંમતવાન પ્રયોગ.

અમે લોગસ્ટેશ મૂકીએ છીએ અને એક્ઝિક્યુટ કરીએ છીએ:

echo '3' >> logs/number2.log
echo '4' >> logs/number1.log

ફરીથી લોગસ્ટેશ ચલાવો અને જુઓ:

logstash_one_channel | {
logstash_one_channel |            "host" => "ac2d4e3ef70f",
logstash_one_channel |     "habra_field" => "Hello Habr",
logstash_one_channel |         "message" => "3",
logstash_one_channel |        "@version" => "1",
logstash_one_channel |            "path" => "/usr/share/logstash/input/number2.log",
logstash_one_channel |      "@timestamp" => 2019-04-29T14:48:50.589Z
logstash_one_channel | }
logstash_one_channel | {
logstash_one_channel |            "host" => "ac2d4e3ef70f",
logstash_one_channel |     "habra_field" => "Hello Habr",
logstash_one_channel |         "message" => "4",
logstash_one_channel |        "@version" => "1",
logstash_one_channel |            "path" => "/usr/share/logstash/input/number1.log",
logstash_one_channel |      "@timestamp" => 2019-04-29T14:48:50.856Z
logstash_one_channel | }

હુરે! બધું ઉપાડ્યું.

પરંતુ, નીચેના વિશે ચેતવણી આપવી જરૂરી છે. જો લોગસ્ટેશ કન્ટેનર દૂર કરવામાં આવે તો (ડોકર સ્ટોપ logstash_one_channel && docker rm logstash_one_channel), કંઈપણ લેવામાં આવશે નહીં. ફાઇલની સ્થિતિ કે જ્યાં સુધી તે વાંચવામાં આવી હતી તે કન્ટેનરની અંદર સંગ્રહિત હતી. જો તમે શરૂઆતથી શરૂ કરો છો, તો તે ફક્ત નવી લાઇન સ્વીકારશે.

હાલની ફાઇલો વાંચી રહ્યા છીએ

ચાલો કહીએ કે અમે પ્રથમ વખત લોગસ્ટેશ ચલાવી રહ્યા છીએ, પરંતુ અમારી પાસે પહેલેથી જ લોગ છે અને અમે તેને પ્રક્રિયા કરવા માંગીએ છીએ.
જો આપણે ઉપર ઉપયોગ કરેલ ઇનપુટ વિભાગ સાથે લોગસ્ટેશ ચલાવીએ, તો આપણને કંઈપણ મળશે નહીં. લોગસ્ટેશ દ્વારા ફક્ત નવી લાઇન પર પ્રક્રિયા કરવામાં આવશે.

હાલની ફાઇલોમાંથી રેખાઓ ખેંચવા માટે, ઇનપુટ વિભાગમાં વધારાની લાઇન ઉમેરો:

input {
  file {
    start_position => "beginning"
    path => "/usr/share/logstash/input/*.log"
   }
  }

તદુપરાંત, ત્યાં એક સૂક્ષ્મતા છે, આ ફક્ત નવી ફાઇલોને અસર કરે છે જે લોગસ્ટેશે હજી સુધી જોઈ નથી. તે જ ફાઇલો માટે કે જે પહેલાથી જ લોગસ્ટેશના દૃશ્યના ક્ષેત્રમાં હતી, તે પહેલાથી જ તેમનું કદ યાદ રાખે છે અને હવે તેમાં ફક્ત નવા રેકોર્ડ્સ લેશે.

ચાલો ઇનપુટ વિભાગનો અભ્યાસ કરીને આના પર અટકીએ. ત્યાં ઘણા બધા વિકલ્પો છે, પરંતુ હમણાં માટે, અમારી પાસે વધુ પ્રયોગો માટે પૂરતા છે.

રૂટીંગ અને ડેટા ટ્રાન્સફોર્મેશન

ચાલો નીચેની સમસ્યાને હલ કરવાનો પ્રયાસ કરીએ, ચાલો કહીએ કે અમારી પાસે એક ચેનલના સંદેશા છે, તેમાંથી કેટલાક માહિતીપ્રદ છે, અને કેટલાક ભૂલ સંદેશાઓ છે. તેઓ ટેગમાં અલગ પડે છે. કેટલીક માહિતી છે, અન્ય ERROR છે.

આપણે તેમને બહાર નીકળતી વખતે અલગ કરવાની જરૂર છે. તે. અમે એક ચેનલમાં માહિતીપ્રદ સંદેશાઓ અને બીજી ચેનલમાં ભૂલ સંદેશાઓ લખીએ છીએ.

આ કરવા માટે, ઇનપુટ વિભાગમાંથી ફિલ્ટર અને આઉટપુટ પર જાઓ.

ફિલ્ટર વિભાગનો ઉપયોગ કરીને, અમે આવનારા સંદેશને પાર્સ કરીશું, તેમાંથી હેશ (કી-વેલ્યુ જોડીઓ) મેળવીશું, જેની સાથે આપણે પહેલેથી જ કામ કરી શકીએ છીએ, એટલે કે. શરતો અનુસાર વિશ્લેષણ કરો. અને આઉટપુટ વિભાગમાં, અમે સંદેશાઓ પસંદ કરીશું અને દરેકને તેની પોતાની ચેનલ પર મોકલીશું.

ગ્રોક સાથે સંદેશનું વિશ્લેષણ

ટેક્સ્ટ લાઇન્સને પાર્સ કરવા અને તેમાંથી ફીલ્ડ્સનો સમૂહ મેળવવા માટે, ફિલ્ટર વિભાગમાં એક વિશેષ પ્લગઇન છે - grok.

અહીં તેનું વિગતવાર વર્ણન આપવાનું લક્ષ્ય નક્કી કર્યા વિના (આ માટે હું સંદર્ભ લઉં છું સત્તાવાર દસ્તાવેજીકરણ), હું મારું સરળ ઉદાહરણ આપીશ.

આ કરવા માટે, તમારે ઇનપુટ લાઇનના ફોર્મેટ પર નિર્ણય લેવાની જરૂર છે. મારી પાસે તેઓ આના જેવા છે:

1 માહિતી સંદેશ1
2 ભૂલ સંદેશ2

તે. પહેલા ઓળખકર્તા, પછી INFO/ERROR, પછી ખાલી જગ્યા વગરનો અમુક શબ્દ.
મુશ્કેલ નથી, પરંતુ ઓપરેશનના સિદ્ધાંતને સમજવા માટે પૂરતું છે.

તેથી, ફિલ્ટર વિભાગમાં, ગ્રોક પ્લગઇનમાં, અમારે અમારા શબ્દમાળાઓનું પદચ્છેદન કરવા માટે એક પેટર્ન વ્યાખ્યાયિત કરવાની જરૂર છે.

તે આના જેવો દેખાશે:

filter {
  grok {
    match => { "message" => ["%{INT:message_id} %{LOGLEVEL:message_type} %{WORD:message_text}"] }
   }
  } 

મૂળભૂત રીતે, તે નિયમિત અભિવ્યક્તિ છે. તૈયાર પેટર્નનો ઉપયોગ થાય છે, જેમ કે INT, LOGLEVEL, WORD. તેમનું વર્ણન, તેમજ અન્ય દાખલાઓ, અહીં જોઈ શકાય છે. અહીં

હવે, આ ફિલ્ટરમાંથી પસાર થતાં, આપણી સ્ટ્રીંગ ત્રણ ફીલ્ડની હેશમાં ફેરવાઈ જશે: message_id, message_type, message_text.

તેઓ આઉટપુટ વિભાગમાં પ્રદર્શિત થશે.

if આદેશ સાથે આઉટપુટ વિભાગમાં સંદેશાઓને રૂટીંગ કરો

આઉટપુટ વિભાગમાં, જેમ અમને યાદ છે, અમે સંદેશાઓને બે સ્ટ્રીમમાં વિભાજિત કરવાના હતા. કેટલાક - જે iNFO છે, અમે કન્સોલમાં આઉટપુટ કરીશું, અને ભૂલો સાથે, અમે ફાઇલમાં આઉટપુટ કરીશું.

અમે આ સંદેશાઓ કેવી રીતે શેર કરી શકીએ? સમસ્યાની સ્થિતિ પહેલેથી જ ઉકેલ સૂચવે છે - છેવટે, અમારી પાસે પહેલેથી જ એક સમર્પિત મેસેજ_ટાઇપ ફીલ્ડ છે, જે ફક્ત બે મૂલ્યો INFO અને ERROR લઈ શકે છે. તેના પર આપણે if સ્ટેટમેન્ટનો ઉપયોગ કરીને પસંદગી કરીશું.

if [message_type] == "ERROR" {
        # Здесь выводим в файл
       } else
     {
      # Здесь выводим в stdout
    }

ક્ષેત્રો અને ઓપરેટરો સાથેના કાર્યનું વર્ણન આ વિભાગમાં મળી શકે છે સત્તાવાર માર્ગદર્શિકા.

હવે, નિષ્કર્ષ પોતે વિશે.

કન્સોલ આઉટપુટ, અહીં બધું સ્પષ્ટ છે - stdout {}

પરંતુ ફાઇલનું આઉટપુટ - યાદ રાખો કે આપણે આ બધું કન્ટેનરમાંથી ચલાવીએ છીએ અને જે ફાઇલમાં આપણે પરિણામ લખીએ છીએ તે બહારથી ઉપલબ્ધ થાય તે માટે, આપણે આ ડિરેક્ટરીને docker-compose.yml માં ખોલવાની જરૂર છે.

કુલ:

અમારી ફાઇલનો આઉટપુટ વિભાગ આના જેવો દેખાય છે:


output {
  if [message_type] == "ERROR" {
    file {
          path => "/usr/share/logstash/output/test.log"
          codec => line { format => "custom format: %{message}"}
         }
    } else
     {stdout {
             }
     }
  }

આઉટપુટ માટે docker-compose.yml માં વધુ એક વોલ્યુમ ઉમેરો:

version: '3'

networks:
  elk:

volumes:
  elasticsearch:
    driver: local

services:

  logstash:
    container_name: logstash_one_channel
    image: docker.elastic.co/logstash/logstash:6.3.2
    networks:
      - elk
    environment:
      XPACK_MONITORING_ENABLED: "false"
    ports:
      - 5046:5046
   volumes:
      - ./config/pipelines.yml:/usr/share/logstash/config/pipelines.yml:ro
      - ./config/pipelines:/usr/share/logstash/config/pipelines:ro
      - ./logs:/usr/share/logstash/input
      - ./output:/usr/share/logstash/output

અમે શરૂ કરીએ છીએ, અમે પ્રયાસ કરીએ છીએ, અમે બે પ્રવાહોમાં વિભાજન જોઈએ છીએ.

સોર્સ: www.habr.com