ਜਾਣ ਪਛਾਣ

ਇੱਕ ਹੋਰ ਸਿਸਟਮ ਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਸਮੇਂ, ਸਾਨੂੰ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਲੌਗਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਲੋੜ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ। ELK ਨੂੰ ਟੂਲ ਵਜੋਂ ਚੁਣਿਆ ਗਿਆ ਸੀ। ਇਹ ਲੇਖ ਇਸ ਸਟੈਕ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਵਿੱਚ ਸਾਡੇ ਅਨੁਭਵ ਬਾਰੇ ਚਰਚਾ ਕਰੇਗਾ।

ਅਸੀਂ ਇਸ ਦੀਆਂ ਸਾਰੀਆਂ ਸਮਰੱਥਾਵਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਕੋਈ ਟੀਚਾ ਨਹੀਂ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ, ਪਰ ਅਸੀਂ ਵਿਹਾਰਕ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ 'ਤੇ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਇਹ ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਹੈ ਕਿ ਭਾਵੇਂ ਦਸਤਾਵੇਜ਼ਾਂ ਅਤੇ ਤਿਆਰ ਚਿੱਤਰਾਂ ਦੀ ਕਾਫ਼ੀ ਵੱਡੀ ਮਾਤਰਾ ਹੈ, ਇੱਥੇ ਬਹੁਤ ਸਾਰੀਆਂ ਕਮੀਆਂ ਹਨ, ਘੱਟੋ ਘੱਟ ਅਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਲੱਭ ਲਿਆ ਹੈ.

ਅਸੀਂ ਡੌਕਰ-ਕੰਪੋਜ਼ ਦੁਆਰਾ ਸਟੈਕ ਨੂੰ ਤੈਨਾਤ ਕੀਤਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਚੰਗੀ-ਲਿਖਤ docker-compose.yml ਸੀ, ਜਿਸ ਨੇ ਸਾਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਸਮੱਸਿਆ ਦੇ ਸਟੈਕ ਨੂੰ ਵਧਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਸੀ। ਅਤੇ ਇਹ ਸਾਨੂੰ ਜਾਪਦਾ ਸੀ ਕਿ ਜਿੱਤ ਪਹਿਲਾਂ ਹੀ ਨੇੜੇ ਸੀ, ਹੁਣ ਅਸੀਂ ਇਸ ਨੂੰ ਆਪਣੀਆਂ ਜ਼ਰੂਰਤਾਂ ਦੇ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਥੋੜਾ ਜਿਹਾ ਸੁਧਾਰਾਂਗੇ ਅਤੇ ਬੱਸ ਹੋ ਗਿਆ।

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਸਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਲੌਗ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਸਿਸਟਮ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਤੁਰੰਤ ਸਫਲ ਨਹੀਂ ਹੋਈ। ਇਸ ਲਈ, ਅਸੀਂ ਫੈਸਲਾ ਕੀਤਾ ਹੈ ਕਿ ਹਰੇਕ ਹਿੱਸੇ ਦਾ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਅਧਿਐਨ ਕਰਨਾ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਦੇ ਕਨੈਕਸ਼ਨਾਂ 'ਤੇ ਵਾਪਸ ਜਾਣਾ ਮਹੱਤਵਪੂਰਣ ਹੈ।

ਇਸ ਲਈ, ਅਸੀਂ ਲੌਗਸਟੈਸ਼ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕੀਤੀ.

ਵਾਤਾਵਰਣ, ਤੈਨਾਤੀ, ਇੱਕ ਕੰਟੇਨਰ ਵਿੱਚ ਲੌਗਸਟੈਸ਼ ਚੱਲ ਰਿਹਾ ਹੈ

ਤੈਨਾਤੀ ਲਈ ਅਸੀਂ ਡੌਕਰ-ਕੰਪੋਜ਼ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ; ਇੱਥੇ ਵਰਣਿਤ ਪ੍ਰਯੋਗ MacOS ਅਤੇ Ubuntu 18.0.4 'ਤੇ ਕੀਤੇ ਗਏ ਸਨ।

ਲੌਗਸਟੈਸ਼ ਚਿੱਤਰ ਜੋ ਸਾਡੇ ਮੂਲ docker-compose.yml ਵਿੱਚ ਰਜਿਸਟਰ ਕੀਤਾ ਗਿਆ ਸੀ docker.elastic.co/logstash/logstash:6.3.2 ਹੈ

ਅਸੀਂ ਇਸਨੂੰ ਪ੍ਰਯੋਗਾਂ ਲਈ ਵਰਤਾਂਗੇ।

ਅਸੀਂ logstash ਨੂੰ ਚਲਾਉਣ ਲਈ ਇੱਕ ਵੱਖਰਾ docker-compose.yml ਲਿਖਿਆ ਹੈ। ਬੇਸ਼ੱਕ, ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਚਿੱਤਰ ਨੂੰ ਲਾਂਚ ਕਰਨਾ ਸੰਭਵ ਸੀ, ਪਰ ਅਸੀਂ ਇੱਕ ਖਾਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰ ਰਹੇ ਸੀ, ਜਿੱਥੇ ਅਸੀਂ ਡੌਕਰ-ਕੰਪੋਜ਼ ਤੋਂ ਸਭ ਕੁਝ ਚਲਾਉਂਦੇ ਹਾਂ।

ਸੰਰਚਨਾ ਫਾਈਲਾਂ ਬਾਰੇ ਸੰਖੇਪ ਵਿੱਚ

ਵਰਣਨ ਤੋਂ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ, ਲੌਗਸਟੈਸ਼ ਨੂੰ ਜਾਂ ਤਾਂ ਇੱਕ ਚੈਨਲ ਲਈ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਸਥਿਤੀ ਵਿੱਚ ਇਸਨੂੰ *.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 ਨਾਲ ਮੈਪ ਕਰਦੇ ਹਾਂ, ਜਿੱਥੇ ਲੌਗਸਟੈਸ਼ ਇਸਨੂੰ ਚੁੱਕ ਲਵੇਗਾ ਅਤੇ ਇਸਨੂੰ ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ ਬਣਾ ਦੇਵੇਗਾ।
5. ਅਸੀਂ ./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 ਪਹੁੰਚਯੋਗ ਨਹੀਂ: [http://elasticsearch:9200/][Manticore ::ResolutionFailure] elasticsearch", ...

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 | [INFO ] "/"}
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/][Manticore::ResolutionFail. elasticsearch"}
logstash_one_channel | [INFO ] "/"}
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/][Manticore::ResolutionFail. elasticsearch"}

ਅਤੇ ਸਾਡਾ ਲੌਗ ਹਰ ਸਮੇਂ ਵਧ ਰਿਹਾ ਹੈ.

ਇੱਥੇ ਮੈਂ ਹਰੇ ਰੰਗ ਵਿੱਚ ਸੁਨੇਹੇ ਨੂੰ ਉਜਾਗਰ ਕੀਤਾ ਹੈ ਕਿ ਪਾਈਪਲਾਈਨ ਸਫਲਤਾਪੂਰਵਕ ਸ਼ੁਰੂ ਹੋ ਗਈ ਹੈ, ਲਾਲ ਵਿੱਚ ਗਲਤੀ ਸੰਦੇਸ਼ ਅਤੇ ਪੀਲੇ ਵਿੱਚ ਸੰਪਰਕ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਬਾਰੇ ਸੰਦੇਸ਼ ਲਚਕੀਲਾ: 9200
ਅਜਿਹਾ ਇਸ ਲਈ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ logstash.conf, ਚਿੱਤਰ ਵਿੱਚ ਸ਼ਾਮਲ, ਵਿੱਚ elasticsearch ਉਪਲਬਧਤਾ ਦੀ ਜਾਂਚ ਹੁੰਦੀ ਹੈ। ਆਖ਼ਰਕਾਰ, ਲੌਗਸਟੈਸ਼ ਮੰਨਦਾ ਹੈ ਕਿ ਇਹ ਐਲਕ ਸਟੈਕ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਅਸੀਂ ਇਸਨੂੰ ਵੱਖ ਕਰ ਦਿੱਤਾ ਹੈ।

ਕੰਮ ਕਰਨਾ ਸੰਭਵ ਹੈ, ਪਰ ਇਹ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ।

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 ਦੇ ਸਮਾਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, i.e. ਨਵੀਆਂ ਲਾਈਨਾਂ ਪੜ੍ਹਦਾ ਹੈ ਜਾਂ, ਇੱਕ ਵਿਕਲਪ ਵਜੋਂ, ਪੂਰੀ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।

ਇਸ ਲਈ ਅਸੀਂ ਕੀ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ:

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

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਸੂਖਮਤਾ ਹੈ: ਇਹ ਸਿਰਫ ਉਹਨਾਂ ਨਵੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਦਾ ਹੈ ਜੋ ਲੌਗਸਟੈਸ਼ ਨੇ ਅਜੇ ਤੱਕ ਨਹੀਂ ਵੇਖੀਆਂ ਹਨ. ਉਹੀ ਫਾਈਲਾਂ ਲਈ ਜੋ ਪਹਿਲਾਂ ਹੀ ਲੌਗਸਟੈਸ਼ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਵਿੱਚ ਸਨ, ਇਸ ਨੇ ਉਹਨਾਂ ਦੇ ਆਕਾਰ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਯਾਦ ਰੱਖਿਆ ਹੈ ਅਤੇ ਹੁਣ ਉਹਨਾਂ ਵਿੱਚ ਸਿਰਫ ਨਵੀਆਂ ਐਂਟਰੀਆਂ ਲਵੇਗੀ.

ਆਓ ਇੱਥੇ ਰੁਕੀਏ ਅਤੇ ਇਨਪੁਟ ਸੈਕਸ਼ਨ ਦਾ ਅਧਿਐਨ ਕਰੀਏ। ਅਜੇ ਵੀ ਬਹੁਤ ਸਾਰੇ ਵਿਕਲਪ ਹਨ, ਪਰ ਇਹ ਸਾਡੇ ਲਈ ਹੁਣ ਲਈ ਹੋਰ ਪ੍ਰਯੋਗਾਂ ਲਈ ਕਾਫੀ ਹੈ।

ਰੂਟਿੰਗ ਅਤੇ ਡਾਟਾ ਪਰਿਵਰਤਨ

ਆਓ ਹੇਠਾਂ ਦਿੱਤੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ, ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਚੈਨਲ ਤੋਂ ਸੰਦੇਸ਼ ਹਨ, ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕੁਝ ਜਾਣਕਾਰੀ ਵਾਲੇ ਹਨ, ਅਤੇ ਕੁਝ ਗਲਤੀ ਸੁਨੇਹੇ ਹਨ। ਉਹ ਟੈਗ ਦੁਆਰਾ ਵੱਖਰੇ ਹਨ. ਕੁਝ INFO ਹਨ, ਕੁਝ ERROR ਹਨ।

ਸਾਨੂੰ ਬਾਹਰ ਨਿਕਲਣ 'ਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਵੱਖ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਉਹ. ਅਸੀਂ ਇੱਕ ਚੈਨਲ ਵਿੱਚ ਜਾਣਕਾਰੀ ਸੰਦੇਸ਼ ਲਿਖਦੇ ਹਾਂ, ਅਤੇ ਦੂਜੇ ਵਿੱਚ ਗਲਤੀ ਸੁਨੇਹੇ।

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਇਨਪੁਟ ਸੈਕਸ਼ਨ ਤੋਂ ਫਿਲਟਰ ਅਤੇ ਆਉਟਪੁੱਟ 'ਤੇ ਜਾਓ।

ਫਿਲਟਰ ਸੈਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਆਉਣ ਵਾਲੇ ਸੰਦੇਸ਼ ਨੂੰ ਪਾਰਸ ਕਰਾਂਗੇ, ਇਸ ਤੋਂ ਇੱਕ ਹੈਸ਼ (ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜੇ) ਪ੍ਰਾਪਤ ਕਰਾਂਗੇ, ਜਿਸ ਨਾਲ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕੰਮ ਕਰ ਸਕਦੇ ਹਾਂ, ਜਿਵੇਂ ਕਿ. ਸ਼ਰਤਾਂ ਅਨੁਸਾਰ ਵੱਖ ਕਰੋ. ਅਤੇ ਆਉਟਪੁੱਟ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਸੁਨੇਹੇ ਚੁਣਾਂਗੇ ਅਤੇ ਹਰ ਇੱਕ ਨੂੰ ਇਸਦੇ ਆਪਣੇ ਚੈਨਲ ਤੇ ਭੇਜਾਂਗੇ।

grok ਨਾਲ ਇੱਕ ਸੁਨੇਹਾ ਪਾਰਸ ਕਰਨਾ

ਟੈਕਸਟ ਸਤਰ ਨੂੰ ਪਾਰਸ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਤੋਂ ਖੇਤਰਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਫਿਲਟਰ ਭਾਗ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਪਲੱਗਇਨ ਹੈ - grok.

ਆਪਣੇ ਆਪ ਨੂੰ ਇੱਥੇ ਇਸਦਾ ਵਿਸਤ੍ਰਿਤ ਵੇਰਵਾ ਦੇਣ ਦਾ ਟੀਚਾ ਨਿਰਧਾਰਤ ਕੀਤੇ ਬਿਨਾਂ (ਇਸਦੇ ਲਈ ਮੈਂ ਹਵਾਲਾ ਦਿੰਦਾ ਹਾਂ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼), ਮੈਂ ਆਪਣੀ ਸਧਾਰਨ ਉਦਾਹਰਣ ਦੇਵਾਂਗਾ।

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇਨਪੁਟ ਸਤਰ ਦੇ ਫਾਰਮੈਟ 'ਤੇ ਫੈਸਲਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਮੇਰੇ ਕੋਲ ਉਹ ਇਸ ਤਰ੍ਹਾਂ ਹਨ:

1 ਜਾਣਕਾਰੀ ਸੁਨੇਹਾ 1
2 ਗਲਤੀ ਸੁਨੇਹਾ2

ਉਹ. ਪਛਾਣਕਰਤਾ ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ, ਫਿਰ INFO/ERROR, ਫਿਰ ਖਾਲੀ ਥਾਂ ਤੋਂ ਬਿਨਾਂ ਕੁਝ ਸ਼ਬਦ।
ਇਹ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ, ਪਰ ਓਪਰੇਸ਼ਨ ਦੇ ਸਿਧਾਂਤ ਨੂੰ ਸਮਝਣ ਲਈ ਇਹ ਕਾਫ਼ੀ ਹੈ.

ਇਸ ਲਈ, grok ਪਲੱਗਇਨ ਦੇ ਫਿਲਟਰ ਭਾਗ ਵਿੱਚ, ਸਾਨੂੰ ਆਪਣੀਆਂ ਸਤਰਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨ ਲਈ ਇੱਕ ਪੈਟਰਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

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