ആമുഖം

മറ്റൊരു സിസ്റ്റം വിന്യസിക്കുമ്പോൾ, നിരവധി വ്യത്യസ്ത ലോഗുകൾ പ്രോസസ്സ് ചെയ്യേണ്ടതിന്റെ ആവശ്യകത ഞങ്ങൾ അഭിമുഖീകരിച്ചു. ഉപകരണമായി ELK തിരഞ്ഞെടുത്തു. ഈ സ്റ്റാക്ക് സജ്ജീകരിക്കുന്നതിൽ ഞങ്ങളുടെ അനുഭവം ഈ ലേഖനം ചർച്ച ചെയ്യും.

അതിന്റെ എല്ലാ കഴിവുകളും വിവരിക്കാൻ ഞങ്ങൾ ഒരു ലക്ഷ്യം സജ്ജീകരിക്കുന്നില്ല, പക്ഷേ പ്രായോഗിക പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിൽ പ്രത്യേകം ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. സാമാന്യം വലിയ അളവിലുള്ള ഡോക്യുമെന്റേഷനും റെഡിമെയ്ഡ് ചിത്രങ്ങളും ഉണ്ടെങ്കിലും, ധാരാളം കുഴപ്പങ്ങൾ ഉണ്ട്, കുറഞ്ഞത് ഞങ്ങൾ അവ കണ്ടെത്തി എന്നതാണ് ഇതിന് കാരണം.

ഡോക്കർ-കംപോസ് വഴി ഞങ്ങൾ സ്റ്റാക്ക് വിന്യസിച്ചു. മാത്രമല്ല, ഞങ്ങൾക്ക് നന്നായി എഴുതപ്പെട്ട ഡോക്കർ-കമ്പോസ്.ഐഎംഎൽ ഉണ്ടായിരുന്നു, അത് പ്രശ്‌നങ്ങളില്ലാതെ സ്റ്റാക്ക് ഉയർത്താൻ ഞങ്ങളെ അനുവദിച്ചു. വിജയം ഇതിനകം അടുത്തതായി ഞങ്ങൾക്ക് തോന്നി, ഇപ്പോൾ ഞങ്ങൾ അത് ഞങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ രീതിയിൽ മാറ്റും, അത്രമാത്രം.

നിർഭാഗ്യവശാൽ, ഞങ്ങളുടെ ആപ്ലിക്കേഷനിൽ നിന്ന് ലോഗുകൾ സ്വീകരിക്കുന്നതിനും പ്രോസസ്സ് ചെയ്യുന്നതിനും സിസ്റ്റം കോൺഫിഗർ ചെയ്യാനുള്ള ശ്രമം ഉടനടി വിജയിച്ചില്ല. അതിനാൽ, ഓരോ ഘടകങ്ങളും വെവ്വേറെ പഠിക്കുന്നത് മൂല്യവത്താണെന്ന് ഞങ്ങൾ തീരുമാനിച്ചു, തുടർന്ന് അവയുടെ കണക്ഷനുകളിലേക്ക് മടങ്ങുക.

അതിനാൽ, ഞങ്ങൾ ലോഗ്സ്റ്റാഷിൽ ആരംഭിച്ചു.

പരിസ്ഥിതി, വിന്യാസം, ഒരു കണ്ടെയ്നറിൽ ലോഗ്സ്റ്റാഷ് പ്രവർത്തിപ്പിക്കുക

വിന്യാസത്തിനായി ഞങ്ങൾ ഡോക്കർ-കമ്പോസ് ഉപയോഗിക്കുന്നു; ഇവിടെ വിവരിച്ചിരിക്കുന്ന പരീക്ഷണങ്ങൾ MacOS-ലും ഉബുണ്ടു 18.0.4-ലും നടത്തി.

ഞങ്ങളുടെ യഥാർത്ഥ docker-compose.yml-ൽ രജിസ്റ്റർ ചെയ്ത ലോഗ്സ്റ്റാഷ് ചിത്രം docker.elastic.co/logstash/logstash:6.3.2 ആണ്

ഞങ്ങൾ അത് പരീക്ഷണങ്ങൾക്കായി ഉപയോഗിക്കും.

logstash പ്രവർത്തിപ്പിക്കുന്നതിന് ഞങ്ങൾ ഒരു പ്രത്യേക docker-compose.yml എഴുതി. തീർച്ചയായും, കമാൻഡ് ലൈനിൽ നിന്ന് ചിത്രം സമാരംഭിക്കുന്നത് സാധ്യമായിരുന്നു, പക്ഷേ ഞങ്ങൾ ഒരു പ്രത്യേക പ്രശ്നം പരിഹരിക്കുകയായിരുന്നു, അവിടെ ഞങ്ങൾ ഡോക്കർ-കംപോസ് മുതൽ എല്ലാം പ്രവർത്തിപ്പിക്കുന്നു.

കോൺഫിഗറേഷൻ ഫയലുകളെക്കുറിച്ച് ചുരുക്കത്തിൽ

വിവരണത്തിൽ നിന്ന് താഴെ പറയുന്നതുപോലെ, logstash ഒന്നുകിൽ ഒരു ചാനലിനായി പ്രവർത്തിപ്പിക്കാം, ഈ സാഹചര്യത്തിൽ അതിന് *.conf ഫയൽ കൈമാറേണ്ടതുണ്ട്, അല്ലെങ്കിൽ നിരവധി ചാനലുകൾക്കായി, പൈപ്പ്ലൈൻസ്.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

നമ്മൾ ഇവിടെ എന്താണ് കാണുന്നത്?

നെറ്റ്‌വർക്കുകളും വോള്യങ്ങളും യഥാർത്ഥ ഡോക്കർ-compose.yml-ൽ നിന്നാണ് എടുത്തത് (മുഴുവൻ സ്റ്റാക്കും സമാരംഭിച്ച ഒന്ന്) അവ ഇവിടെയുള്ള മൊത്തത്തിലുള്ള ചിത്രത്തെ കാര്യമായി ബാധിക്കുന്നില്ലെന്ന് ഞാൻ കരുതുന്നു.
docker.elastic.co/logstash/logstash:6.3.2 എന്ന ചിത്രത്തിൽ നിന്ന് ഞങ്ങൾ ഒരു logstash സേവനം(കൾ) സൃഷ്ടിക്കുകയും അതിന് logstash_one_channel എന്ന് പേരിടുകയും ചെയ്യുന്നു.
കണ്ടെയ്‌നറിനുള്ളിലെ പോർട്ട് 5046 ഞങ്ങൾ അതേ ഇന്റേണൽ പോർട്ടിലേക്ക് ഫോർവേഡ് ചെയ്യുന്നു.
ഞങ്ങളുടെ പൈപ്പ് കോൺഫിഗറേഷൻ ഫയൽ ./config/pipelines.yml കണ്ടെയ്‌നറിനുള്ളിലെ /usr/share/logstash/config/pipelines.yml എന്ന ഫയലിലേക്ക് ഞങ്ങൾ മാപ്പ് ചെയ്യുന്നു, അവിടെ ലോഗ്സ്റ്റാഷ് അത് എടുത്ത് വായിക്കാൻ മാത്രമുള്ളതാക്കും.
ചാനൽ ക്രമീകരണങ്ങളുള്ള ഫയലുകളുള്ള ./config/pipelines ഡയറക്‌ടറി ഞങ്ങൾ /usr/share/logstash/config/pipelines ഡയറക്‌ടറിയിലേക്ക് മാപ്പ് ചെയ്യുകയും അത് റീഡ്-ഒൺലി ആക്കുകയും ചെയ്യുന്നു.

Pipelines.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 Unreachable: [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-പാക്ക് ഇൻസ്റ്റാൾ ചെയ്യുക. മറ്റ് സവിശേഷതകൾ ലഭ്യമായേക്കാം.
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] ഒരു ഇലാസ്റ്റിക് സെർച്ച് കണക്ഷൻ പ്രവർത്തിക്കുന്നുണ്ടോ എന്നറിയാൻ ആരോഗ്യ പരിശോധന നടത്തുന്നു {: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 ലഭ്യമല്ല: [http://elasticsearch:9200/][SolutionF::ilure] ഇലാസ്റ്റിക് സെർച്ച്"}
logstash_one_channel | [2019-04-29T11:29:04,704][INFO ][logstash.licensechecker.licensereader] ഒരു ഇലാസ്റ്റിക് സെർച്ച് കണക്ഷൻ പ്രവർത്തിക്കുന്നുണ്ടോ എന്നറിയാൻ ആരോഗ്യ പരിശോധന നടത്തുന്നു {: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 ലഭ്യമല്ല: [http://elasticsearch:9200/][SolutionF::ilure] ഇലാസ്റ്റിക് സെർച്ച്"}

ഞങ്ങളുടെ ലോഗ് എല്ലാ സമയത്തും ഇഴയുകയാണ്.

പൈപ്പ്‌ലൈൻ വിജയകരമായി സമാരംഭിച്ചു എന്ന സന്ദേശം പച്ച നിറത്തിലും ചുവപ്പിൽ പിശക് സന്ദേശവും മഞ്ഞ നിറത്തിൽ ബന്ധപ്പെടാനുള്ള ശ്രമത്തെക്കുറിച്ചുള്ള സന്ദേശവും ഞാൻ ഇവിടെ ഹൈലൈറ്റ് ചെയ്തിട്ടുണ്ട്. ഇലാസ്റ്റിക് തിരയൽ: 9200.
ഇമേജിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന logstash.conf എന്നതിൽ ഇലാസ്റ്റിക് തിരയൽ ലഭ്യതയ്ക്കുള്ള ഒരു പരിശോധന അടങ്ങിയിരിക്കുന്നതിനാലാണ് ഇത് സംഭവിക്കുന്നത്. എല്ലാത്തിനുമുപരി, ഇത് എൽക്ക് സ്റ്റാക്കിന്റെ ഭാഗമായി പ്രവർത്തിക്കുന്നുവെന്ന് ലോഗ്സ്റ്റാഷ് അനുമാനിക്കുന്നു, പക്ഷേ ഞങ്ങൾ അത് വേർതിരിച്ചു.

ജോലി ചെയ്യാൻ കഴിയും, പക്ഷേ അത് സൗകര്യപ്രദമല്ല.

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

ഒരു ചാനലിൽ പ്രവർത്തിക്കുന്നു

അങ്ങനെ ഞങ്ങൾ ലോഞ്ച് ചെയ്തു. ഇപ്പോൾ നിങ്ങൾക്ക് യഥാർത്ഥത്തിൽ ലോഗ്സ്റ്റാഷ് കോൺഫിഗർ ചെയ്യാൻ സമയമെടുക്കാം. പൈപ്പ്ലൈൻസ്.yml എന്ന ഫയലിൽ തൽക്കാലം തൊടരുത്, ഒരു ചാനലിൽ പ്രവർത്തിക്കുന്നതിലൂടെ നമുക്ക് എന്ത് നേടാമെന്ന് നോക്കാം.

ചാനൽ കോൺഫിഗറേഷൻ ഫയലുമായി പ്രവർത്തിക്കുന്നതിനുള്ള പൊതുതത്ത്വം ഇവിടെ ഔദ്യോഗിക മാനുവലിൽ നന്നായി വിവരിച്ചിട്ടുണ്ടെന്ന് ഞാൻ പറയണം ഇവിടെ
നിങ്ങൾക്ക് റഷ്യൻ ഭാഷയിൽ വായിക്കണമെങ്കിൽ, ഞങ്ങൾ ഇത് ഉപയോഗിച്ചു ലേഖനം(എന്നാൽ അവിടെയുള്ള അന്വേഷണ വാക്യഘടന പഴയതാണ്, ഞങ്ങൾ ഇത് കണക്കിലെടുക്കേണ്ടതുണ്ട്).

ഇൻപുട്ട് വിഭാഗത്തിൽ നിന്ന് തുടർച്ചയായി പോകാം. ടിസിപിയിലെ ജോലി ഞങ്ങൾ ഇതിനകം കണ്ടു. ഇവിടെ മറ്റെന്താണ് രസകരമായത്?

ഹൃദയമിടിപ്പ് ഉപയോഗിച്ച് സന്ദേശങ്ങൾ പരിശോധിക്കുക

ഓട്ടോമാറ്റിക് ടെസ്റ്റ് സന്ദേശങ്ങൾ സൃഷ്ടിക്കാൻ അത്തരമൊരു രസകരമായ അവസരമുണ്ട്.
ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഇൻപുട്ട് വിഭാഗത്തിൽ ഹാർട്ട്ബീൻ പ്ലഗിൻ പ്രവർത്തനക്ഷമമാക്കേണ്ടതുണ്ട്.

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 ന് സമാനമായിരിക്കണം, അതായത്. പുതിയ വരികൾ വായിക്കുന്നു അല്ലെങ്കിൽ, ഒരു ഓപ്ഷനായി, മുഴുവൻ ഫയലും വായിക്കുന്നു.

അതിനാൽ ഞങ്ങൾ എന്താണ് നേടാൻ ആഗ്രഹിക്കുന്നത്:

ഒരു ലോഗ് ഫയലിൽ ചേർത്തിരിക്കുന്ന വരികൾ സ്വീകരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
എവിടെ നിന്ന് ലഭിക്കുന്നത് വേർതിരിക്കാൻ കഴിയുമ്പോൾ, നിരവധി ലോഗ് ഫയലുകളിലേക്ക് എഴുതിയ ഡാറ്റ സ്വീകരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
ലോഗ്സ്റ്റാഷ് പുനരാരംഭിക്കുമ്പോൾ, ഈ ഡാറ്റ അത് വീണ്ടും സ്വീകരിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
ലോഗ്സ്റ്റാഷ് ഓഫാക്കിയിരിക്കുകയും ഫയലുകളിലേക്ക് ഡാറ്റ എഴുതുന്നത് തുടരുകയും ചെയ്യുന്നുവെങ്കിൽ, ഞങ്ങൾ അത് പ്രവർത്തിപ്പിക്കുമ്പോൾ, ഞങ്ങൾക്ക് ഈ ഡാറ്റ ലഭിക്കുമോ എന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.

പരീക്ഷണം നടത്താൻ, 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"
   }
  }

മാത്രമല്ല, ഒരു ന്യൂനൻസ് ഉണ്ട്: ലോഗ്സ്റ്റാഷ് ഇതുവരെ കണ്ടിട്ടില്ലാത്ത പുതിയ ഫയലുകളെ മാത്രമേ ഇത് ബാധിക്കുകയുള്ളൂ. ലോഗ്സ്റ്റാഷിന്റെ വ്യൂ ഫീൽഡിൽ ഇതിനകം ഉണ്ടായിരുന്ന അതേ ഫയലുകൾക്കായി, അത് ഇതിനകം തന്നെ അവയുടെ വലുപ്പം ഓർത്തു, ഇപ്പോൾ അവയിൽ പുതിയ എൻട്രികൾ മാത്രമേ എടുക്കൂ.

നമുക്ക് ഇവിടെ നിർത്തി ഇൻപുട്ട് വിഭാഗം പഠിക്കാം. ഇനിയും നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്, എന്നാൽ ഇപ്പോൾ കൂടുതൽ പരീക്ഷണങ്ങൾക്ക് ഇത് മതിയാകും.

റൂട്ടിംഗും ഡാറ്റാ പരിവർത്തനവും

ഇനിപ്പറയുന്ന പ്രശ്നം പരിഹരിക്കാൻ ശ്രമിക്കാം, നമുക്ക് ഒരു ചാനലിൽ നിന്നുള്ള സന്ദേശങ്ങൾ ഉണ്ടെന്ന് പറയാം, അവയിൽ ചിലത് വിവരദായകമാണ്, ചിലത് പിശക് സന്ദേശങ്ങളാണ്. ടാഗ് അനുസരിച്ച് അവ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. ചിലത് വിവരമാണ്, മറ്റുള്ളവ പിശകാണ്.

പുറത്തുകടക്കുമ്പോൾ നമുക്ക് അവയെ വേർതിരിക്കേണ്ടതുണ്ട്. ആ. ഞങ്ങൾ ഒരു ചാനലിൽ വിവര സന്ദേശങ്ങളും മറ്റൊരു ചാനലിൽ പിശക് സന്ദേശങ്ങളും എഴുതുന്നു.

ഇത് ചെയ്യുന്നതിന്, ഇൻപുട്ട് വിഭാഗത്തിൽ നിന്ന് ഫിൽട്ടറിലേക്കും ഔട്ട്പുട്ടിലേക്കും നീങ്ങുക.

ഫിൽട്ടർ വിഭാഗം ഉപയോഗിച്ച്, ഞങ്ങൾ ഇൻകമിംഗ് സന്ദേശം പാഴ്‌സ് ചെയ്യും, അതിൽ നിന്ന് ഒരു ഹാഷ് (കീ-മൂല്യം ജോഡി) നേടുന്നു, അത് ഞങ്ങൾക്ക് ഇതിനകം പ്രവർത്തിക്കാൻ കഴിയും, അതായത്. വ്യവസ്ഥകൾ അനുസരിച്ച് ഡിസ്അസംബ്ലിംഗ് ചെയ്യുക. ഔട്ട്‌പുട്ട് വിഭാഗത്തിൽ, ഞങ്ങൾ സന്ദേശങ്ങൾ തിരഞ്ഞെടുത്ത് ഓരോന്നും അതിന്റേതായ ചാനലിലേക്ക് അയയ്ക്കും.

ഗ്രോക്ക് ഉപയോഗിച്ച് ഒരു സന്ദേശം പാഴ്‌സ് ചെയ്യുന്നു

ടെക്സ്റ്റ് സ്ട്രിംഗുകൾ പാഴ്‌സ് ചെയ്യുന്നതിനും അവയിൽ നിന്ന് ഒരു കൂട്ടം ഫീൽഡുകൾ നേടുന്നതിനും, ഫിൽട്ടർ വിഭാഗത്തിൽ ഒരു പ്രത്യേക പ്ലഗിൻ ഉണ്ട് - grok.

അതിന്റെ വിശദമായ വിവരണം ഇവിടെ നൽകാനുള്ള ലക്ഷ്യം സ്വയം സജ്ജമാക്കാതെ (ഇതിനായി ഞാൻ പരാമർശിക്കുന്നു ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ), ഞാൻ എന്റെ ലളിതമായ ഉദാഹരണം നൽകും.

ഇത് ചെയ്യുന്നതിന്, ഇൻപുട്ട് സ്ട്രിംഗുകളുടെ ഫോർമാറ്റ് നിങ്ങൾ തീരുമാനിക്കേണ്ടതുണ്ട്. എനിക്ക് അവ ഇതുപോലെയുണ്ട്:

1 വിവര സന്ദേശം1
2 പിശക് സന്ദേശം2

ആ. ഐഡന്റിഫയർ ആദ്യം വരുന്നു, തുടർന്ന് വിവരം/പിശക്, പിന്നീട് സ്‌പെയ്‌സുകളില്ലാത്ത കുറച്ച് വാക്കുകൾ.
ഇത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല, പക്ഷേ പ്രവർത്തന തത്വം മനസിലാക്കാൻ ഇത് മതിയാകും.

അതിനാൽ, ഗ്രോക്ക് പ്ലഗിന്റെ ഫിൽട്ടർ വിഭാഗത്തിൽ, ഞങ്ങളുടെ സ്ട്രിംഗുകൾ പാഴ്‌സ് ചെയ്യുന്നതിനുള്ള ഒരു പാറ്റേൺ ഞങ്ങൾ നിർവ്വചിക്കേണ്ടതുണ്ട്.

ഇത് ഇതുപോലെ കാണപ്പെടും:

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

എന്നാൽ ഒരു ഫയലിലേക്കുള്ള ഔട്ട്‌പുട്ട് - നമ്മൾ ഇതെല്ലാം ഒരു കണ്ടെയ്‌നറിൽ നിന്നാണ് പ്രവർത്തിപ്പിക്കുന്നതെന്ന് ഓർക്കുക, ഫലം എഴുതുന്ന ഫയൽ പുറത്ത് നിന്ന് ആക്‌സസ് ചെയ്യാൻ, ഡോക്കർ-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

ELK യുടെ പ്രായോഗിക പ്രയോഗം. ലോഗ്സ്റ്റാഷ് സജ്ജീകരിക്കുന്നു

ആമുഖം

പരിസ്ഥിതി, വിന്യാസം, ഒരു കണ്ടെയ്നറിൽ ലോഗ്സ്റ്റാഷ് പ്രവർത്തിപ്പിക്കുക

കോൺഫിഗറേഷൻ ഫയലുകളെക്കുറിച്ച് ചുരുക്കത്തിൽ

ഒരു ചാനലിൽ പ്രവർത്തിക്കുന്നു

ഹൃദയമിടിപ്പ് ഉപയോഗിച്ച് സന്ദേശങ്ങൾ പരിശോധിക്കുക

ഒരു ഫയലിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കുന്നു

നിലവിലുള്ള ഫയലുകൾ വായിക്കുന്നു

റൂട്ടിംഗും ഡാറ്റാ പരിവർത്തനവും

ഗ്രോക്ക് ഉപയോഗിച്ച് ഒരു സന്ദേശം പാഴ്‌സ് ചെയ്യുന്നു

if കമാൻഡ് ഉപയോഗിച്ച് ഔട്ട്‌പുട്ട് വിഭാഗത്തിലേക്ക് സന്ദേശങ്ങൾ റൂട്ട് ചെയ്യുന്നു

ഒരു അഭിപ്രായം ചേർക്കുക

ELK യുടെ പ്രായോഗിക പ്രയോഗം. ലോഗ്സ്റ്റാഷ് സജ്ജീകരിക്കുന്നു

ആമുഖം

പരിസ്ഥിതി, വിന്യാസം, ഒരു കണ്ടെയ്നറിൽ ലോഗ്സ്റ്റാഷ് പ്രവർത്തിപ്പിക്കുക

കോൺഫിഗറേഷൻ ഫയലുകളെക്കുറിച്ച് ചുരുക്കത്തിൽ

ഒരു ചാനലിൽ പ്രവർത്തിക്കുന്നു

ഹൃദയമിടിപ്പ് ഉപയോഗിച്ച് സന്ദേശങ്ങൾ പരിശോധിക്കുക

ഒരു ഫയലിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കുന്നു

നിലവിലുള്ള ഫയലുകൾ വായിക്കുന്നു

റൂട്ടിംഗും ഡാറ്റാ പരിവർത്തനവും

ഗ്രോക്ക് ഉപയോഗിച്ച് ഒരു സന്ദേശം പാഴ്‌സ് ചെയ്യുന്നു

if കമാൻഡ് ഉപയോഗിച്ച് ഔട്ട്‌പുട്ട് വിഭാഗത്തിലേക്ക് സന്ദേശങ്ങൾ റൂട്ട് ചെയ്യുന്നു

ഒരു അഭിപ്രായം ചേർക്കുക മറുപടി റദ്ദാക്കാൻ

ഒരു അഭിപ്രായം ചേർക്കുക