ಪರಿಚಯ
ಮತ್ತೊಂದು ವ್ಯವಸ್ಥೆಯನ್ನು ನಿಯೋಜಿಸುವಾಗ, ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ವಿವಿಧ ಲಾಗ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಅಗತ್ಯವನ್ನು ನಾವು ಎದುರಿಸಿದ್ದೇವೆ. ELK ಅನ್ನು ಸಾಧನವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ. ಈ ಲೇಖನವು ಈ ಸ್ಟಾಕ್ ಅನ್ನು ಹೊಂದಿಸುವಲ್ಲಿ ನಮ್ಮ ಅನುಭವವನ್ನು ಚರ್ಚಿಸುತ್ತದೆ.
ಅದರ ಎಲ್ಲಾ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ವಿವರಿಸಲು ನಾವು ಗುರಿಯನ್ನು ಹೊಂದಿಸುವುದಿಲ್ಲ, ಆದರೆ ಪ್ರಾಯೋಗಿಕ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವಲ್ಲಿ ನಾವು ನಿರ್ದಿಷ್ಟವಾಗಿ ಕೇಂದ್ರೀಕರಿಸಲು ಬಯಸುತ್ತೇವೆ. ಸಾಕಷ್ಟು ದೊಡ್ಡ ಪ್ರಮಾಣದ ದಾಖಲಾತಿ ಮತ್ತು ಸಿದ್ಧ ಚಿತ್ರಗಳಿದ್ದರೂ ಸಹ, ಸಾಕಷ್ಟು ಮೋಸಗಳಿವೆ, ಕನಿಷ್ಠ ನಾವು ಅವುಗಳನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ ಎಂಬುದು ಇದಕ್ಕೆ ಕಾರಣ.
ನಾವು ಡಾಕರ್-ಕಂಪೋಸ್ ಮೂಲಕ ಸ್ಟಾಕ್ ಅನ್ನು ನಿಯೋಜಿಸಿದ್ದೇವೆ. ಇದಲ್ಲದೆ, ನಾವು ಚೆನ್ನಾಗಿ ಬರೆದ ಡಾಕರ್-compose.yml ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಇದು ಬಹುತೇಕ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ ಸ್ಟಾಕ್ ಅನ್ನು ಹೆಚ್ಚಿಸಲು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಟ್ಟಿತು. ಮತ್ತು ವಿಜಯವು ಈಗಾಗಲೇ ಹತ್ತಿರದಲ್ಲಿದೆ ಎಂದು ನಮಗೆ ತೋರುತ್ತದೆ, ಈಗ ನಾವು ಅದನ್ನು ನಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ಸ್ವಲ್ಪ ತಿರುಚುತ್ತೇವೆ ಮತ್ತು ಅದು ಅಷ್ಟೆ.
ದುರದೃಷ್ಟವಶಾತ್, ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ಲಾಗ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಿಸ್ಟಮ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಪ್ರಯತ್ನವು ತಕ್ಷಣವೇ ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ. ಆದ್ದರಿಂದ, ಪ್ರತಿ ಘಟಕವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಅಧ್ಯಯನ ಮಾಡುವುದು ಯೋಗ್ಯವಾಗಿದೆ ಎಂದು ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ ಮತ್ತು ನಂತರ ಅವರ ಸಂಪರ್ಕಗಳಿಗೆ ಹಿಂತಿರುಗುತ್ತೇವೆ.
ಆದ್ದರಿಂದ, ನಾವು ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ.
ಪರಿಸರ, ನಿಯೋಜನೆ, ಕಂಟೇನರ್‌ನಲ್ಲಿ ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವುದು
ನಿಯೋಜನೆಗಾಗಿ ನಾವು ಡಾಕರ್-ಕಂಪೋಸ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ; ಇಲ್ಲಿ ವಿವರಿಸಿದ ಪ್ರಯೋಗಗಳನ್ನು MacOS ಮತ್ತು ಉಬುಂಟು 18.0.4 ನಲ್ಲಿ ನಡೆಸಲಾಗಿದೆ.
ನಮ್ಮ ಮೂಲ docker-compose.yml ನಲ್ಲಿ ನೋಂದಾಯಿಸಲಾದ logstash ಚಿತ್ರವು docker.elastic.co/logstash/logstash:6.3.2
ನಾವು ಅದನ್ನು ಪ್ರಯೋಗಗಳಿಗೆ ಬಳಸುತ್ತೇವೆ.
logstash ಅನ್ನು ರನ್ ಮಾಡಲು ನಾವು ಪ್ರತ್ಯೇಕ ಡಾಕರ್-compose.yml ಅನ್ನು ಬರೆದಿದ್ದೇವೆ. ಸಹಜವಾಗಿ, ಆಜ್ಞಾ ಸಾಲಿನಿಂದ ಚಿತ್ರವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಿದೆ, ಆದರೆ ನಾವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತಿದ್ದೇವೆ, ಅಲ್ಲಿ ನಾವು ಡಾಕರ್-ಕಂಪೋಸ್ನಿಂದ ಎಲ್ಲವನ್ನೂ ರನ್ ಮಾಡುತ್ತೇವೆ.
ಸಂರಚನಾ ಕಡತಗಳ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ
ವಿವರಣೆಯಿಂದ ಈ ಕೆಳಗಿನಂತೆ, ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಅನ್ನು ಒಂದು ಚಾನಲ್‌ಗಾಗಿ ಚಲಾಯಿಸಬಹುದು, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅದು *.conf ಫೈಲ್ ಅನ್ನು ರವಾನಿಸಬೇಕಾಗುತ್ತದೆ, ಅಥವಾ ಹಲವಾರು ಚಾನಲ್‌ಗಳಿಗೆ, ಪೈಪ್‌ಲೈನ್ಸ್.yml ಫೈಲ್ ಅನ್ನು ರವಾನಿಸಬೇಕಾಗುತ್ತದೆ, ಅದು ಪ್ರತಿಯಾಗಿ , ಪ್ರತಿ ಚಾನಲ್ಗೆ .conf ಫೈಲ್‌ಗಳಿಗೆ ಲಿಂಕ್ ಮಾಡುತ್ತದೆ.
ನಾವು ಎರಡನೇ ದಾರಿ ಹಿಡಿದೆವು. ಇದು ನಮಗೆ ಹೆಚ್ಚು ಸಾರ್ವತ್ರಿಕ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಎಂದು ತೋರುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಾವು pipelines.yml ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಪೈಪ್‌ಲೈನ್‌ಗಳ ಡೈರೆಕ್ಟರಿಯನ್ನು ಮಾಡಿದ್ದೇವೆ, ಅದರಲ್ಲಿ ನಾವು ಪ್ರತಿ ಚಾನಲ್ಗೆ .conf ಫೈಲ್ಗಳನ್ನು ಹಾಕುತ್ತೇವೆ.
ಕಂಟೇನರ್ ಒಳಗೆ ಮತ್ತೊಂದು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಇದೆ - logstash.yml. ನಾವು ಅದನ್ನು ಮುಟ್ಟುವುದಿಲ್ಲ, ನಾವು ಅದನ್ನು ಹಾಗೆಯೇ ಬಳಸುತ್ತೇವೆ.
ಆದ್ದರಿಂದ, ನಮ್ಮ ಡೈರೆಕ್ಟರಿ ರಚನೆ:
ಇನ್ಪುಟ್ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲು, ಇದು ಪೋರ್ಟ್ 5046 ನಲ್ಲಿ tcp ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ ಮತ್ತು ಔಟ್‌ಪುಟ್‌ಗಾಗಿ ನಾವು stdout ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
ಮೊದಲ ಉಡಾವಣೆಗೆ ಸರಳವಾದ ಸಂರಚನೆ ಇಲ್ಲಿದೆ. ಏಕೆಂದರೆ ಆರಂಭಿಕ ಕಾರ್ಯವು ಉಡಾವಣೆಯಾಗಿದೆ.
ಆದ್ದರಿಂದ, ನಾವು ಈ ಡಾಕರ್-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_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-Pack ಅನ್ನು Logstash ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಆದರೆ Elasticsearch ನಲ್ಲಿ ಅಲ್ಲ. ಮೇಲ್ವಿಚಾರಣಾ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಬಳಸಲು Elasticsearch ನಲ್ಲಿ X-Pack ಅನ್ನು ಸ್ಥಾಪಿಸಿ. ಇತರ ವೈಶಿಷ್ಟ್ಯಗಳು ಲಭ್ಯವಿರಬಹುದು.
logstash_one_channel | [2019-04-29T11:29:00,526][INFO ][logstash.agent ] ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ 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::ಔಟ್‌ಪುಟ್‌ಗಳು::ElasticSearch::HttpClient::Pool::HostUnreachableError, :error=>"Elasticsearch ತಲುಪಲು ಸಾಧ್ಯವಿಲ್ಲ: [http://elasticsearch:9200/][solutionFor::il] ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟ"}
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::ಔಟ್‌ಪುಟ್‌ಗಳು::ElasticSearch::HttpClient::Pool::HostUnreachableError, :error=>"Elasticsearch ತಲುಪಲು ಸಾಧ್ಯವಿಲ್ಲ: [http://elasticsearch:9200/][solutionFor::il] ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟ"}
ಮತ್ತು ನಮ್ಮ ಲಾಗ್ ಎಲ್ಲಾ ಸಮಯದಲ್ಲೂ ಹರಿದಾಡುತ್ತಿದೆ.
ಪೈಪ್‌ಲೈನ್ ಯಶಸ್ವಿಯಾಗಿ ಉಡಾವಣೆಯಾಗಿದೆ ಎಂಬ ಸಂದೇಶವನ್ನು ನಾನು ಹಸಿರು ಬಣ್ಣದಲ್ಲಿ ಹೈಲೈಟ್ ಮಾಡಿದ್ದೇನೆ, ಕೆಂಪು ಬಣ್ಣದಲ್ಲಿ ದೋಷ ಸಂದೇಶ ಮತ್ತು ಹಳದಿ ಬಣ್ಣದಲ್ಲಿ ಸಂಪರ್ಕಿಸುವ ಪ್ರಯತ್ನದ ಸಂದೇಶವನ್ನು ಹೈಲೈಟ್ ಮಾಡಿದ್ದೇನೆ. : 9200.
ಚಿತ್ರದಲ್ಲಿ ಸೇರಿಸಲಾದ logstash.conf, ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟದ ಲಭ್ಯತೆಯ ಪರಿಶೀಲನೆಯನ್ನು ಹೊಂದಿರುವ ಕಾರಣ ಇದು ಸಂಭವಿಸುತ್ತದೆ. ಎಲ್ಲಾ ನಂತರ, 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 | }
ಒಂದು ಚಾನೆಲ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಲಾಗುತ್ತಿದೆ
ಆದ್ದರಿಂದ ನಾವು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ. ಈಗ ನೀವು ನಿಜವಾಗಿಯೂ ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಸದ್ಯಕ್ಕೆ ಪೈಪ್‌ಲೈನ್ಸ್.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
}
}
ಫೈಲ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲಾಗುತ್ತಿದೆ
ನಾವು ಫೈಲ್ ಮೋಡ್ ಅನ್ನು ನೋಡಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ಇದು ಫೈಲ್‌ನೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದರೆ, ಕನಿಷ್ಠ ಸ್ಥಳೀಯ ಬಳಕೆಗಾಗಿ ಯಾವುದೇ ಏಜೆಂಟ್ ಅಗತ್ಯವಿಲ್ಲ.
ವಿವರಣೆಯ ಪ್ರಕಾರ, ಆಪರೇಟಿಂಗ್ ಮೋಡ್ ಟೈಲ್ -f ಗೆ ಹೋಲುವಂತಿರಬೇಕು, ಅಂದರೆ. ಹೊಸ ಸಾಲುಗಳನ್ನು ಓದುತ್ತದೆ ಅಥವಾ, ಒಂದು ಆಯ್ಕೆಯಾಗಿ, ಸಂಪೂರ್ಣ ಫೈಲ್ ಅನ್ನು ಓದುತ್ತದೆ.
ಆದ್ದರಿಂದ ನಾವು ಏನನ್ನು ಪಡೆಯಲು ಬಯಸುತ್ತೇವೆ:
- ಒಂದು ಲಾಗ್ ಫೈಲ್‌ಗೆ ಲಗತ್ತಿಸಲಾದ ಸಾಲುಗಳನ್ನು ನಾವು ಸ್ವೀಕರಿಸಲು ಬಯಸುತ್ತೇವೆ.
- ಎಲ್ಲಿಂದ ಸ್ವೀಕರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಸಾಧ್ಯವಾಗುವಾಗ, ಹಲವಾರು ಲಾಗ್ ಫೈಲ್‌ಗಳಿಗೆ ಬರೆಯಲಾದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲು ನಾವು ಬಯಸುತ್ತೇವೆ.
- ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿದಾಗ, ಅದು ಈ ಡೇಟಾವನ್ನು ಮತ್ತೆ ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು ಬಯಸುತ್ತೇವೆ.
- ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಆಫ್ ಆಗಿದ್ದರೆ ಮತ್ತು ಫೈಲ್‌ಗಳಿಗೆ ಡೇಟಾವನ್ನು ಬರೆಯುವುದನ್ನು ಮುಂದುವರಿಸಿದರೆ, ನಾವು ಅದನ್ನು ರನ್ ಮಾಡಿದಾಗ, ನಾವು ಈ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಲು ಬಯಸುತ್ತೇವೆ.
ಪ್ರಯೋಗವನ್ನು ನಡೆಸಲು, ಡಾಕರ್-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 && ಡಾಕರ್ rm logstash_one_channel), ನಂತರ ಏನನ್ನೂ ತೆಗೆದುಕೊಳ್ಳಲಾಗುವುದಿಲ್ಲ. ಅದನ್ನು ಓದಿದ ಫೈಲ್‌ನ ಸ್ಥಾನವನ್ನು ಕಂಟೇನರ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. ನೀವು ಅದನ್ನು ಮೊದಲಿನಿಂದ ಚಲಾಯಿಸಿದರೆ, ಅದು ಹೊಸ ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ಸ್ವೀಕರಿಸುತ್ತದೆ.
ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಫೈಲ್ಗಳನ್ನು ಓದುವುದು
ನಾವು ಮೊದಲ ಬಾರಿಗೆ ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ, ಆದರೆ ನಾವು ಈಗಾಗಲೇ ಲಾಗ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಬಯಸುತ್ತೇವೆ.
ನಾವು ಮೇಲೆ ಬಳಸಿದ ಇನ್ಪುಟ್ ವಿಭಾಗದೊಂದಿಗೆ ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಅನ್ನು ರನ್ ಮಾಡಿದರೆ, ನಾವು ಏನನ್ನೂ ಪಡೆಯುವುದಿಲ್ಲ. ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್‌ನಿಂದ ಹೊಸ ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ.
ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಫೈಲ್‌ಗಳಿಂದ ಸಾಲುಗಳನ್ನು ಎಳೆಯಲು, ನೀವು ಇನ್ಪುಟ್ ವಿಭಾಗಕ್ಕೆ ಹೆಚ್ಚುವರಿ ಸಾಲನ್ನು ಸೇರಿಸಬೇಕು:
input {
file {
start_position => "beginning"
path => "/usr/share/logstash/input/*.log"
}
}
ಇದಲ್ಲದೆ, ಒಂದು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸವಿದೆ: ಇದು ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್ ಇನ್ನೂ ನೋಡದ ಹೊಸ ಫೈಲ್‌ಗಳ ಮೇಲೆ ಮಾತ್ರ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ. ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್‌ನ ವೀಕ್ಷಣೆಯ ಕ್ಷೇತ್ರದಲ್ಲಿ ಈಗಾಗಲೇ ಇದ್ದ ಅದೇ ಫೈಲ್‌ಗಳಿಗಾಗಿ, ಅದು ಈಗಾಗಲೇ ಅವುಗಳ ಗಾತ್ರವನ್ನು ನೆನಪಿಸಿಕೊಂಡಿದೆ ಮತ್ತು ಈಗ ಅವುಗಳಲ್ಲಿ ಹೊಸ ನಮೂದುಗಳನ್ನು ಮಾತ್ರ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಇಲ್ಲಿಗೆ ನಿಲ್ಲಿಸಿ ಮತ್ತು ಇನ್ಪುಟ್ ವಿಭಾಗವನ್ನು ಅಧ್ಯಯನ ಮಾಡೋಣ. ಇನ್ನೂ ಹಲವು ಆಯ್ಕೆಗಳಿವೆ, ಆದರೆ ಸದ್ಯಕ್ಕೆ ಹೆಚ್ಚಿನ ಪ್ರಯೋಗಗಳಿಗೆ ಇದು ನಮಗೆ ಸಾಕು.
ರೂಟಿಂಗ್ ಮತ್ತು ಡೇಟಾ ರೂಪಾಂತರ
ಕೆಳಗಿನ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ, ನಾವು ಒಂದು ಚಾನಲ್‌ನಿಂದ ಸಂದೇಶಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ, ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಮಾಹಿತಿಯುಕ್ತವಾಗಿವೆ ಮತ್ತು ಕೆಲವು ದೋಷ ಸಂದೇಶಗಳಾಗಿವೆ. ಅವು ಟ್ಯಾಗ್ ಮೂಲಕ ಭಿನ್ನವಾಗಿರುತ್ತವೆ. ಕೆಲವು ಮಾಹಿತಿ, ಇತರವು ದೋಷ.
ನಿರ್ಗಮನದಲ್ಲಿ ನಾವು ಅವುಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಬೇಕಾಗಿದೆ. ಆ. ನಾವು ಒಂದು ಚಾನಲ್‌ನಲ್ಲಿ ಮಾಹಿತಿ ಸಂದೇಶಗಳನ್ನು ಮತ್ತು ಇನ್ನೊಂದು ಚಾನಲ್‌ನಲ್ಲಿ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಬರೆಯುತ್ತೇವೆ.
ಇದನ್ನು ಮಾಡಲು, ಇನ್ಪುಟ್ ವಿಭಾಗದಿಂದ ಫಿಲ್ಟರ್ ಮತ್ತು ಔಟ್‌ಪುಟ್‌ಗೆ ಸರಿಸಿ.
ಫಿಲ್ಟರ್ ವಿಭಾಗವನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಒಳಬರುವ ಸಂದೇಶವನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತೇವೆ, ಅದರಿಂದ ಹ್ಯಾಶ್ (ಕೀ-ಮೌಲ್ಯ ಜೋಡಿಗಳು) ಪಡೆದುಕೊಳ್ಳುತ್ತೇವೆ, ನಾವು ಈಗಾಗಲೇ ಕೆಲಸ ಮಾಡಬಹುದು, ಅಂದರೆ. ಷರತ್ತುಗಳ ಪ್ರಕಾರ ಡಿಸ್ಅಸೆಂಬಲ್ ಮಾಡಿ. ಮತ್ತು ಔಟ್ಪುಟ್ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಸಂದೇಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಪ್ರತಿಯೊಂದನ್ನು ಅದರ ಸ್ವಂತ ಚಾನಲ್ಗೆ ಕಳುಹಿಸುತ್ತೇವೆ.
ಗ್ರೋಕ್‌ನೊಂದಿಗೆ ಸಂದೇಶವನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಪಠ್ಯ ತಂತಿಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಮತ್ತು ಅವುಗಳಿಂದ ಕ್ಷೇತ್ರಗಳ ಸೆಟ್ ಅನ್ನು ಪಡೆಯಲು, ಫಿಲ್ಟರ್ ವಿಭಾಗದಲ್ಲಿ ವಿಶೇಷ ಪ್ಲಗಿನ್ ಇದೆ - ಗ್ರೋಕ್.
ಇಲ್ಲಿ ಅದರ ವಿವರವಾದ ವಿವರಣೆಯನ್ನು ನೀಡುವ ಗುರಿಯನ್ನು ನಾನೇ ಹೊಂದಿಸದೆ (ಇದಕ್ಕಾಗಿ ನಾನು ಉಲ್ಲೇಖಿಸುತ್ತೇನೆ ), ನಾನು ನನ್ನ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನೀಡುತ್ತೇನೆ.
ಇದನ್ನು ಮಾಡಲು, ನೀವು ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ಗಳ ಸ್ವರೂಪವನ್ನು ನಿರ್ಧರಿಸಬೇಕು. ನಾನು ಅವುಗಳನ್ನು ಈ ರೀತಿ ಹೊಂದಿದ್ದೇನೆ:
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