పరిచయం
మరొక సిస్టమ్‌ని అమలు చేస్తున్నప్పుడు, మేము పెద్ద సంఖ్యలో విభిన్న లాగ్‌లను ప్రాసెస్ చేయవలసిన అవసరాన్ని ఎదుర్కొన్నాము. ELK సాధనంగా ఎంపిక చేయబడింది. ఈ స్టాక్‌ను సెటప్ చేయడంలో మా అనుభవాన్ని ఈ కథనం చర్చిస్తుంది.
మేము దాని అన్ని సామర్థ్యాలను వివరించడానికి లక్ష్యాన్ని నిర్దేశించము, కానీ మేము ఆచరణాత్మక సమస్యలను పరిష్కరించడంపై ప్రత్యేకంగా దృష్టి పెట్టాలనుకుంటున్నాము. డాక్యుమెంటేషన్ మరియు రెడీమేడ్ చిత్రాలు చాలా పెద్ద మొత్తంలో ఉన్నప్పటికీ, చాలా ఆపదలు ఉన్నాయి, కనీసం మేము వాటిని కనుగొన్నాము.
మేము డాకర్-కంపోజ్ ద్వారా స్టాక్‌ని అమలు చేసాము. అంతేకాకుండా, మేము బాగా వ్రాసిన docker-compose.ymlని కలిగి ఉన్నాము, ఇది దాదాపు సమస్యలు లేకుండా స్టాక్‌ను పెంచడానికి మాకు వీలు కల్పించింది. మరియు విజయం ఇప్పటికే దగ్గరగా ఉందని మాకు అనిపించింది, ఇప్పుడు మేము దానిని మా అవసరాలకు అనుగుణంగా కొద్దిగా సర్దుబాటు చేస్తాము మరియు అంతే.
దురదృష్టవశాత్తూ, మా అప్లికేషన్ నుండి లాగ్‌లను స్వీకరించడానికి మరియు ప్రాసెస్ చేయడానికి సిస్టమ్‌ను కాన్ఫిగర్ చేసే ప్రయత్నం వెంటనే విజయవంతం కాలేదు. అందువల్ల, ప్రతి భాగాన్ని విడిగా అధ్యయనం చేయడం విలువైనదని మేము నిర్ణయించుకున్నాము, ఆపై వారి కనెక్షన్‌లకు తిరిగి వస్తాము.
కాబట్టి, మేము లాగ్‌స్టాష్‌తో ప్రారంభించాము.
పర్యావరణం, విస్తరణ, కంటైనర్‌లో లాగ్‌స్టాష్‌ను అమలు చేయడం
విస్తరణ కోసం మేము డాకర్-కంపోజ్‌ని ఉపయోగిస్తాము; ఇక్కడ వివరించిన ప్రయోగాలు MacOS మరియు ఉబుంటు 18.0.4లో జరిగాయి.
మా అసలు docker-compose.ymlలో నమోదు చేయబడిన లాగ్‌స్టాష్ చిత్రం docker.elastic.co/logstash/logstash:6.3.2
మేము దానిని ప్రయోగాలకు ఉపయోగిస్తాము.
లాగ్‌స్టాష్‌ని అమలు చేయడానికి మేము ప్రత్యేక డాకర్-కంపోజ్.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
మనం ఇక్కడ ఏమి చూస్తాము?
- నెట్‌వర్క్‌లు మరియు వాల్యూమ్‌లు ఒరిజినల్ డాకర్-compose.yml (మొత్తం స్టాక్ ప్రారంభించబడినది) నుండి తీసుకోబడ్డాయి మరియు అవి ఇక్కడ మొత్తం చిత్రాన్ని పెద్దగా ప్రభావితం చేయవని నేను భావిస్తున్నాను.
- మేము docker.elastic.co/logstash/logstash:6.3.2 చిత్రం నుండి ఒక లాగ్‌స్టాష్ సేవ(ల)ను సృష్టిస్తాము మరియు దానికి logstash_one_channel అని పేరు పెట్టాము.
- మేము కంటైనర్ లోపల పోర్ట్ 5046ని అదే అంతర్గత పోర్ట్‌కి ఫార్వార్డ్ చేస్తాము.
- మేము మా పైప్ కాన్ఫిగరేషన్ ఫైల్ ./config/pipelines.ymlని కంటైనర్‌లోని /usr/share/logstash/config/pipelines.yml ఫైల్‌కి మ్యాప్ చేస్తాము, ఇక్కడ లాగ్‌స్టాష్ దానిని ఎంచుకొని చదవడానికి మాత్రమే చేస్తుంది.
- మేము /usr/share/logstash/config/pipelines డైరెక్టరీలో ఛానెల్ సెట్టింగ్‌లతో ఫైల్‌లను కలిగి ఉన్న ./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=>“ఎలాస్టిక్ సెర్చ్ చేరుకోలేదు: [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 లాగ్‌స్టాష్‌లో ఇన్‌స్టాల్ చేయబడింది కానీ సాగే శోధనలో కాదు. పర్యవేక్షణ లక్షణాన్ని ఉపయోగించడానికి దయచేసి సాగే శోధనలో 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][హెచ్చరించండి [logstash.outputs.elasticsearch] చనిపోయిన ES ఉదాహరణకి కనెక్షన్‌ని పునరుద్ధరించడానికి ప్రయత్నించారు, కానీ లోపం వచ్చింది. {:url=>":9200/", :error_type=>LogStash::Outputs::ElasticSearch::HttpClient::Pool::HostUnreachableError, :error=>"సాగే శోధన చేరుకోలేనిది: [http://elasticsearch:9200/][SolutionFar::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][హెచ్చరించండి ][logstash.licensechecker.licensereader] చనిపోయిన ES ఉదాహరణకి కనెక్షన్‌ని పునరుద్ధరించడానికి ప్రయత్నించారు, కానీ లోపం వచ్చింది. {:url=>":9200/", :error_type=>LogStash::Outputs::ElasticSearch::HttpClient::Pool::HostUnreachableError, :error=>"సాగే శోధన చేరుకోలేనిది: [http://elasticsearch:9200/][SolutionFar::il] సాగే శోధన"}
మరియు మా చిట్టా అన్ని వేళలా పాకుతోంది.
ఇక్కడ నేను పైప్‌లైన్ విజయవంతంగా ప్రారంభించబడిన సందేశాన్ని ఆకుపచ్చ రంగులో హైలైట్ చేసాను, ఎరుపు రంగులో ఎర్రర్ మెసేజ్ మరియు పసుపు రంగులో సంప్రదించే ప్రయత్నం గురించి సందేశం : 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 ఫైల్‌ను ప్రస్తుతానికి తాకవద్దు, ఒక ఛానెల్‌తో పని చేయడం ద్వారా మనం ఏమి పొందవచ్చో చూద్దాం.
ఛానెల్ కాన్ఫిగరేషన్ ఫైల్‌తో పని చేసే సాధారణ సూత్రం ఇక్కడ అధికారిక మాన్యువల్‌లో బాగా వివరించబడిందని నేను తప్పక చెప్పాలి
మీరు రష్యన్‌లో చదవాలనుకుంటే, మేము దీన్ని ఉపయోగించాము (కానీ అక్కడ ప్రశ్న వాక్యనిర్మాణం పాతది, మనం దీనిని పరిగణనలోకి తీసుకోవాలి).
ఇన్‌పుట్ విభాగం నుండి వరుసగా వెళ్దాం. మేము ఇప్పటికే 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 వలె ఉండాలి, అనగా. కొత్త పంక్తులను చదువుతుంది లేదా, ఒక ఎంపికగా, మొత్తం ఫైల్‌ను చదువుతుంది.
కాబట్టి మనం ఏమి పొందాలనుకుంటున్నాము:
- మేము ఒక లాగ్ ఫైల్‌కు జోడించబడిన పంక్తులను స్వీకరించాలనుకుంటున్నాము.
- మేము అనేక లాగ్ ఫైల్‌లకు వ్రాసిన డేటాను స్వీకరించాలనుకుంటున్నాము, అయితే ఎక్కడి నుండి స్వీకరించబడిందో వేరు చేయగలదు.
- లాగ్‌స్టాష్ పునఃప్రారంభించబడినప్పుడు, అది ఈ డేటాను మళ్లీ స్వీకరించదని మేము నిర్ధారించుకోవాలనుకుంటున్నాము.
- లాగ్‌స్టాష్ ఆపివేయబడి ఉంటే మరియు ఫైల్‌లకు డేటా వ్రాయడం కొనసాగితే, మేము దీన్ని అమలు చేసినప్పుడు, మేము ఈ డేటాను స్వీకరిస్తాము.
ప్రయోగాన్ని నిర్వహించడానికి, మేము ఫైల్‌లను ఉంచే డైరెక్టరీని తెరవడం ద్వారా 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 ERROR సందేశం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, కన్సోల్‌కి అవుట్‌పుట్ అవుతుంది మరియు ఎర్రర్‌లతో, మేము ఫైల్‌కి అవుట్‌పుట్ చేస్తాము.
మేము ఈ సందేశాలను ఎలా వేరు చేస్తాము? సమస్య యొక్క పరిస్థితి ఇప్పటికే పరిష్కారాన్ని సూచిస్తుంది - అన్నింటికంటే, మేము ఇప్పటికే అంకితమైన message_type ఫీల్డ్‌ని కలిగి ఉన్నాము, ఇది రెండు విలువలను మాత్రమే తీసుకోగలదు: 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