మేము జావాస్క్రిప్ట్ ఉపయోగించి Zabbixలో ఆచరణాత్మక సమస్యలను పరిష్కరిస్తాము

టిఖోన్ ఉస్కోవ్, Zabbix ఇంటిగ్రేషన్ టీమ్ ఇంజనీర్

Zabbix అనేది ఏ విధమైన డేటాను పర్యవేక్షించడానికి ఉపయోగించే అనుకూలీకరించదగిన ప్లాట్‌ఫారమ్. Zabbix యొక్క ప్రారంభ సంస్కరణల నుండి, పర్యవేక్షణ నిర్వాహకులు వివిధ స్క్రిప్ట్‌లను దీని ద్వారా అమలు చేయగల సామర్థ్యాన్ని కలిగి ఉన్నారు చర్యలు లక్ష్య నెట్‌వర్క్ నోడ్‌లపై తనిఖీల కోసం. అదే సమయంలో, స్క్రిప్ట్‌ల ప్రారంభం, స్క్రిప్ట్‌లకు మద్దతు ఇవ్వాల్సిన అవసరం, కమ్యూనికేషన్ నోడ్‌లు మరియు ప్రాక్సీలకు వాటి డెలివరీ, అలాగే విభిన్న వెర్షన్‌లకు మద్దతు వంటి అనేక ఇబ్బందులకు దారితీసింది.

Zabbix కోసం జావాస్క్రిప్ట్

ఏప్రిల్ 2019లో, జావాస్క్రిప్ట్ ప్రీప్రాసెసింగ్‌తో Zabbix 4.2 పరిచయం చేయబడింది. డేటాను ఎక్కడికో తీసుకెళ్లి, దాన్ని జీర్ణం చేసి, Zabbix అర్థం చేసుకునే ఫార్మాట్‌లో అందించడం మరియు Zabbix ద్వారా నిల్వ చేయడానికి మరియు ప్రాసెస్ చేయడానికి సిద్ధంగా లేని డేటాను స్వీకరించే సాధారణ తనిఖీలను నిర్వహించే స్క్రిప్ట్‌లను వదిలివేయాలనే ఆలోచనతో చాలా మంది ఉత్సాహంగా ఉన్నారు. Zabbix మరియు JavaScript సాధనాలను ఉపయోగించి ఈ డేటా స్ట్రీమ్‌ని ప్రాసెస్ చేయండి. Zabbix 3.4లో కనిపించిన తక్కువ-స్థాయి ఆవిష్కరణ మరియు డిపెండెంట్ ఐటెమ్‌లతో కలిపి, అందుకున్న డేటాను క్రమబద్ధీకరించడానికి మరియు నిర్వహించడానికి మేము చాలా సరళమైన భావనను పొందాము.

Zabbix 4.4లో, JavaScriptలో ప్రీ-ప్రాసెసింగ్ యొక్క తార్కిక కొనసాగింపుగా, ఒక కొత్త నోటిఫికేషన్ పద్ధతి కనిపించింది - Webhook, ఇది థర్డ్-పార్టీ అప్లికేషన్‌లతో Zabbix నోటిఫికేషన్‌లను సులభంగా ఇంటిగ్రేట్ చేయడానికి ఉపయోగించబడుతుంది.

జావాస్క్రిప్ట్ మరియు డక్టేప్స్

జావాస్క్రిప్ట్ మరియు డక్టేప్ ఎందుకు ఎంపిక చేయబడ్డాయి? భాషలు మరియు ఇంజిన్ల కోసం వివిధ ఎంపికలు పరిగణించబడ్డాయి:

• లువా - లువా 5.1
• లువా - LuaJIT
• జావాస్క్రిప్ట్ - డక్టేప్
• జావాస్క్రిప్ట్ - జెర్రీస్క్రిప్ట్
• ఎంబెడెడ్ పైథాన్
• ఎంబెడెడ్ పెర్ల్

ప్రధాన ఎంపిక ప్రమాణాలు ప్రాబల్యం, ఉత్పత్తిలో ఇంజిన్‌ను సులభంగా ఏకీకృతం చేయడం, తక్కువ వనరుల వినియోగం మరియు ఇంజిన్ యొక్క మొత్తం పనితీరు మరియు పర్యవేక్షణలో ఈ భాషలో కోడ్‌ను ప్రవేశపెట్టడం యొక్క భద్రత. సూచికల కలయిక ఆధారంగా, Duktape ఇంజిన్‌పై JavaScript గెలిచింది.

ఎంపిక ప్రమాణాలు మరియు పనితీరు పరీక్ష

Duktape యొక్క లక్షణాలు:

- ప్రామాణిక ECMAScript E5/E5.1
- Duktape కోసం Zabbix మాడ్యూల్స్:

• Zabbix.log() - వివిధ స్థాయిల వివరాలతో సందేశాలను నేరుగా Zabbix సర్వర్ లాగ్‌లోకి వ్రాయడానికి మిమ్మల్ని అనుమతిస్తుంది, ఇది లోపాలను సహసంబంధం చేయడం సాధ్యపడుతుంది, ఉదాహరణకు, Webhookలో, సర్వర్ స్థితితో.
• CurlHttpRequest() - వెబ్‌హూక్ ఉపయోగం ఆధారంగా ఉన్న నెట్‌వర్క్‌కు HTTP అభ్యర్థనలను చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
• atob() మరియు btoa() - తీగలను Base64 ఫార్మాట్‌లో ఎన్‌కోడ్ చేయడానికి మరియు డీకోడ్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

గమనిక. Duktape ACME ప్రమాణాలకు అనుగుణంగా ఉంది. Zabbix స్క్రిప్ట్ యొక్క 2015 సంస్కరణను ఉపయోగిస్తుంది. తదుపరి మార్పులు చిన్నవి కాబట్టి వాటిని విస్మరించవచ్చు..

జావాస్క్రిప్ట్ మేజిక్

జావాస్క్రిప్ట్ యొక్క అన్ని అద్భుతాలు డైనమిక్ టైపింగ్ మరియు టైప్ కాస్టింగ్‌లో ఉన్నాయి: స్ట్రింగ్, న్యూమరిక్ మరియు బూలియన్.

దీని అర్థం వేరియబుల్ ఏ రకం విలువను తిరిగి ఇవ్వాలో ముందుగానే ప్రకటించాల్సిన అవసరం లేదు.

గణిత శాస్త్ర కార్యకలాపాలలో, ఫంక్షన్ ఆపరేటర్లు తిరిగి ఇచ్చే విలువలు సంఖ్యలుగా మార్చబడతాయి. అటువంటి కార్యకలాపాలకు మినహాయింపు అదనంగా ఉంటుంది, ఎందుకంటే నిబంధనలలో కనీసం ఒకటి స్ట్రింగ్ అయితే, స్ట్రింగ్ మార్పిడి అన్ని నిబంధనలకు వర్తించబడుతుంది.

గమనిక. అటువంటి పరివర్తనలకు బాధ్యత వహించే పద్ధతులు సాధారణంగా ఆబ్జెక్ట్ యొక్క పేరెంట్ ప్రోటోటైప్‌లలో అమలు చేయబడతాయి, యొక్క విలువ и ట్రింగ్. యొక్క విలువ సంఖ్యా మార్పిడి సమయంలో మరియు ఎల్లప్పుడూ పద్ధతికి ముందు అంటారు ట్రింగ్. పద్ధతి యొక్క విలువ తప్పనిసరిగా ఆదిమ విలువలను అందించాలి, లేకుంటే దాని ఫలితం విస్మరించబడుతుంది.

ఒక వస్తువుపై ఒక పద్ధతి అంటారు యొక్క విలువ. అది కనుగొనబడకపోతే లేదా ఆదిమ విలువను తిరిగి ఇవ్వకపోతే, పద్ధతి అంటారు ట్రింగ్. పద్ధతి అయితే ట్రింగ్ కనుగొనబడలేదు, వెతుకుతున్నాను యొక్క విలువ వస్తువు యొక్క నమూనాలో, మరియు విలువ యొక్క ప్రాసెసింగ్ పూర్తయ్యే వరకు ప్రతిదీ పునరావృతమవుతుంది మరియు వ్యక్తీకరణలోని అన్ని విలువలు ఒకే రకానికి ప్రసారం చేయబడతాయి. వస్తువు ఒక పద్ధతిని అమలు చేస్తే ట్రింగ్, ఇది ఆదిమ విలువను అందిస్తుంది, ఆపై అది స్ట్రింగ్ మార్పిడికి ఉపయోగించబడుతుంది. అయితే, ఈ పద్ధతిని వర్తింపజేయడం వల్ల వచ్చే ఫలితం తప్పనిసరిగా స్ట్రింగ్ కాదు.

ఉదాహరణకు, వస్తువు కోసం అయితే 'ఆబ్జెక్ట్' పద్ధతి నిర్వచించబడింది ట్రింగ్,

`var obj = { toString() { return "200" }}` 

పద్ధతి ట్రింగ్ ఖచ్చితంగా స్ట్రింగ్‌ను అందిస్తుంది మరియు సంఖ్యతో స్ట్రింగ్‌ను జోడించినప్పుడు, మనకు గ్లూడ్ స్ట్రింగ్ వస్తుంది:

`obj + 1 // '2001'` 

`obj + 'a' // ‘200a'`

కానీ మీరు తిరిగి వ్రాస్తే ట్రింగ్, తద్వారా పద్ధతి సంఖ్యను అందిస్తుంది, ఆబ్జెక్ట్ జోడించబడినప్పుడు, సంఖ్యా మార్పిడితో గణిత ఆపరేషన్ నిర్వహించబడుతుంది మరియు గణిత జోడింపు ఫలితం పొందబడుతుంది.

`var obj = { toString() { return 200 }}` 

`obj + 1 // '2001'`

ఈ సందర్భంలో, మేము స్ట్రింగ్తో అదనంగా నిర్వహిస్తే, ఒక స్ట్రింగ్ మార్పిడి నిర్వహించబడుతుంది మరియు మేము గ్లూడ్ స్ట్రింగ్ను పొందుతాము.

`obj + 'a' // ‘200a'`

అనుభవం లేని జావాస్క్రిప్ట్ వినియోగదారులు పెద్ద సంఖ్యలో తప్పులు చేయడానికి ఇది కారణం.

పద్దతి ట్రింగ్ మీరు ఆబ్జెక్ట్ యొక్క ప్రస్తుత విలువను 1 ద్వారా పెంచే ఫంక్షన్‌ను వ్రాయవచ్చు.

స్క్రిప్ట్ యొక్క అమలు, వేరియబుల్ 3కి సమానం, మరియు అది కూడా 4కి సమానం.

తారాగణం (==)తో పోల్చినప్పుడు, పద్ధతి ప్రతిసారీ అమలు చేయబడుతుంది ట్రింగ్ విలువ పెరుగుదల ఫంక్షన్‌తో. దీని ప్రకారం, ప్రతి తదుపరి పోలికతో, విలువ పెరుగుతుంది. తారాగణం కాని పోలిక (===) ఉపయోగించడం ద్వారా దీనిని నివారించవచ్చు.

రకం కాస్టింగ్ లేకుండా పోలిక

గమనిక. తారాగణం పోలికను అనవసరంగా ఉపయోగించవద్దు.

కాంప్లెక్స్ లాజిక్‌తో కూడిన వెబ్‌హూక్స్ వంటి సంక్లిష్ట స్క్రిప్ట్‌ల కోసం, టైప్ కాస్టింగ్‌తో పోలిక అవసరం, వేరియబుల్‌లను తిరిగి ఇచ్చే మరియు అసమానతలు మరియు లోపాలను నిర్వహించే విలువల కోసం చెక్‌లను ముందే వ్రాయమని సిఫార్సు చేయబడింది.

వెబ్‌హుక్ మీడియా

2019 చివరిలో మరియు 2020 ప్రారంభంలో, Zabbix ఇంటిగ్రేషన్ బృందం Zabbix పంపిణీతో వచ్చే Webhooks మరియు అవుట్-ఆఫ్-ది-బాక్స్ ఇంటిగ్రేషన్‌లను చురుకుగా అభివృద్ధి చేస్తోంది.

• అసమ్మతి
• Jira
• జిరా సర్వీస్ డెస్క్
• Mattermost
• మైక్రోసాఫ్ట్ జట్లు
• Opsgenie
• OTR
• పేజర్డ్యూటీ
• పుషోవర్
• సభ్యుడు
• ServiceNow
• SINGL4
• మందగింపు
• Telegram
• జమ్మద్
• Zendesk

దీనికి లింక్ చేయండి డాక్యుమెంటేషన్

ప్రిప్రాసెసింగ్

• జావాస్క్రిప్ట్‌లో ప్రీప్రాసెసింగ్ యొక్క ఆగమనం చాలా బాహ్య స్క్రిప్ట్‌లను వదిలివేయడం సాధ్యం చేసింది మరియు ప్రస్తుతం Zabbixలో మీరు ఏదైనా విలువను పొందవచ్చు మరియు దానిని పూర్తిగా భిన్నమైన విలువకు మార్చవచ్చు.
• Zabbixలో ప్రీప్రాసెసింగ్ JavaScript కోడ్ ద్వారా అమలు చేయబడుతుంది, ఇది బైట్‌కోడ్‌గా కంపైల్ చేయబడినప్పుడు, ఒకే విలువను పారామీటర్‌గా తీసుకునే ఫంక్షన్‌గా మార్చబడుతుంది. విలువ స్ట్రింగ్‌గా (ఒక స్ట్రింగ్ ఒక అంకె మరియు సంఖ్య రెండింటినీ కలిగి ఉంటుంది).
• అవుట్‌పుట్ ఒక ఫంక్షన్ కాబట్టి, స్క్రిప్ట్ చివరిలో అవసరం తిరిగి.
• కోడ్‌లో అనుకూల మాక్రోలను ఉపయోగించడం సాధ్యమవుతుంది.
• వనరులు ఆపరేటింగ్ సిస్టమ్ స్థాయిలో మాత్రమే కాకుండా, ప్రోగ్రామ్‌లపరంగా కూడా పరిమితం చేయబడతాయి. ప్రీప్రాసెసింగ్ దశ గరిష్టంగా 10 మెగాబైట్‌ల RAM మరియు రన్ టైమ్ పరిమితి 10 సెకన్లు కేటాయించబడుతుంది.

గమనిక. 10 సెకన్ల గడువు ముగింపు విలువ చాలా ఎక్కువ, ఎందుకంటే "భారీ" ప్రీప్రాసెసింగ్ దృష్టాంతంలో 1 సెకనులో షరతులతో కూడిన వేలకొద్దీ డేటా ఐటెమ్‌లను సేకరించడం Zabbix వేగాన్ని తగ్గిస్తుంది. అందువల్ల, షాడో డేటా ఎలిమెంట్స్ (డమ్మీ ఐటెమ్‌లు) అని పిలవబడే వాటి ద్వారా పూర్తి స్థాయి జావాస్క్రిప్ట్ స్క్రిప్ట్‌లను అమలు చేయడానికి ప్రీప్రాసెసింగ్‌ని ఉపయోగించడం సిఫార్సు చేయబడదు, ఇవి ప్రీప్రాసెసింగ్ చేయడానికి మాత్రమే అమలు చేయబడతాయి..

మీరు మీ కోడ్‌ను ప్రీప్రాసెసింగ్ పరీక్ష ద్వారా లేదా యుటిలిటీని ఉపయోగించి తనిఖీ చేయవచ్చు zabbix_js:

`zabbix_js -s *script-file -p *input-param* [-l log-level] [-t timeout]`

`zabbix_js -s script-file -i input-file [-l log-level] [-t timeout]`

`zabbix_js -h`

`zabbix_js -V`

ప్రాక్టికల్ పనులు

పని 1

లెక్కించిన అంశాన్ని ప్రీప్రాసెసింగ్‌తో భర్తీ చేయండి.

కండిషన్: సెల్సియస్‌లో నిల్వ చేయడానికి సెన్సార్ నుండి ఉష్ణోగ్రతను ఫారెన్‌హీట్‌లో పొందండి.

మునుపు, మేము డిగ్రీల ఫారెన్‌హీట్‌లో ఉష్ణోగ్రతను సేకరించే అంశాన్ని సృష్టిస్తాము. ఆ తర్వాత, ఫారెన్‌హీట్‌ను ఫార్ములా ఉపయోగించి సెల్సియస్‌కు మార్చే మరొక డేటా అంశం (లెక్కించబడింది).

సమస్యలు:

• డేటా మూలకాలను నకిలీ చేయడం మరియు డేటాబేస్లో అన్ని విలువలను నిల్వ చేయడం అవసరం.
• ఫార్ములాలో లెక్కించబడిన మరియు ఉపయోగించిన "పేరెంట్" డేటా అంశం మరియు లెక్కించిన డేటా అంశం కోసం మీరు తప్పనిసరిగా విరామాలను అంగీకరించాలి. లేకపోతే, కంప్యూటెడ్ అంశం మద్దతు లేని స్థితికి వెళ్లవచ్చు లేదా మునుపటి విలువను లెక్కించవచ్చు, ఇది పర్యవేక్షణ ఫలితాల విశ్వసనీయతను ప్రభావితం చేస్తుంది.

ఒక పరిష్కారం ఏమిటంటే, డేటాను స్వీకరించే అంశం (మా సందర్భంలో, డిగ్రీల ఫారెన్‌హీట్‌లో ఉష్ణోగ్రత) తర్వాత కంప్యూటెడ్ ఐటెమ్ మూల్యాంకనం చేయబడుతుందని నిర్ధారించడానికి స్థిరమైన విరామాలకు అనుకూలంగా ఉండే ఫ్లెక్సిబుల్ చెక్ ఇంటర్వెల్‌ల నుండి దూరంగా వెళ్లడం.

అయితే, ఉదాహరణకు, మేము పెద్ద సంఖ్యలో పరికరాలను తనిఖీ చేయడానికి టెంప్లేట్‌ను ఉపయోగిస్తాము మరియు ప్రతి 30 సెకన్లకు ఒకసారి చెక్ నిర్వహిస్తే, Zabbix 29 సెకన్ల పాటు "హ్యాక్" అవుతుంది మరియు చివరి సెకనులో అది తనిఖీ చేయడం మరియు గణించడం ప్రారంభిస్తుంది. ఇది క్యూను సృష్టిస్తుంది మరియు పనితీరును ప్రభావితం చేస్తుంది. అందువల్ల, ఇది నిజంగా అవసరమైతే మాత్రమే స్థిర విరామాలను ఉపయోగించమని సిఫార్సు చేయబడింది.

ఈ సమస్యలో, సరైన పరిష్కారం ఒక-లైన్ జావాస్క్రిప్ట్ ప్రీప్రాసెసింగ్, ఇది డిగ్రీల ఫారెన్‌హీట్‌ను డిగ్రీల సెల్సియస్‌గా మారుస్తుంది:

`return (value - 32) * 5 / 9;`

ఇది వేగవంతమైనది మరియు సులభం, మీరు అనవసరమైన డేటా ఐటెమ్‌లను సృష్టించాల్సిన అవసరం లేదు మరియు వాటిపై చరిత్రను ఉంచాల్సిన అవసరం లేదు మరియు మీరు తనిఖీల కోసం సౌకర్యవంతమైన విరామాలను కూడా ఉపయోగించవచ్చు.

`return (parseInt(value) + parseInt("{$EXAMPLE.MACRO}"));`

కానీ, ఊహాత్మక పరిస్థితిలో అందుకున్న డేటా మూలకాన్ని జోడించాల్సిన అవసరం ఉంటే, ఉదాహరణకు, స్థూలంలో నిర్వచించిన ఏదైనా స్థిరాంకంతో, అది తప్పనిసరిగా పరామితిని పరిగణనలోకి తీసుకోవాలి. విలువ స్ట్రింగ్‌గా విస్తరిస్తుంది. స్ట్రింగ్ అడిషన్ ఆపరేషన్‌లో, రెండు స్ట్రింగ్‌లు కేవలం ఒకటిగా కలపబడతాయి.

`return (value + "{$EXAMPLE.MACRO}");`

గణిత ఆపరేషన్ ఫలితాన్ని పొందడానికి, పొందిన విలువల రకాలను సంఖ్యా ఆకృతికి మార్చడం అవసరం. దీని కోసం మీరు ఫంక్షన్ ఉపయోగించవచ్చు parseInt(), ఇది పూర్ణాంకం, ఒక ఫంక్షన్‌ను ఉత్పత్తి చేస్తుంది పార్స్‌ఫ్లోట్(), ఇది దశాంశం లేదా ఫంక్షన్‌ని ఉత్పత్తి చేస్తుంది సంఖ్య, ఇది పూర్ణాంకం లేదా దశాంశాన్ని అందిస్తుంది.

టాస్క్ 2

సర్టిఫికేట్ ముగిసే వరకు సెకన్లలో సమయాన్ని పొందండి.

కండిషన్: ఒక సేవ "ఫిబ్రవరి 12 12:33:56 2022 GMT" ఆకృతిలో సర్టిఫికేట్ గడువు తేదీని జారీ చేస్తుంది.

ECMAScript5లో date.parse() ISO 8601 ఆకృతిలో తేదీని అంగీకరిస్తుంది (YYYY-MM-DDTHH:mm:ss.sssZ). MMM DD YYYY HH:mm:ss ZZ ఫార్మాట్‌లో దీనికి స్ట్రింగ్‌ను ప్రసారం చేయడం అవసరం

సమస్య: నెల విలువ సంఖ్యగా కాకుండా వచనంగా వ్యక్తీకరించబడింది. ఈ ఫార్మాట్‌లోని డేటాను Duktape ఆమోదించదు.

పరిష్కారం ఉదాహరణ:

• అన్నింటిలో మొదటిది, విలువను తీసుకునే వేరియబుల్ ప్రకటించబడుతుంది (మొత్తం స్క్రిప్ట్ కామాలతో వేరు చేయబడిన వేరియబుల్స్ యొక్క డిక్లరేషన్).

• మొదటి పంక్తిలో మనం పరామితిలో తేదీని పొందుతాము విలువ మరియు పద్ధతిని ఉపయోగించి ఖాళీలతో దానిని వేరు చేయండి స్ప్లిట్. ఈ విధంగా, మేము ఒక శ్రేణిని పొందుతాము, ఇక్కడ శ్రేణిలోని ప్రతి మూలకం, సూచిక 0 నుండి ప్రారంభమై, ఖాళీకి ముందు మరియు తర్వాత ఒక తేదీ మూలకానికి అనుగుణంగా ఉంటుంది. విభజన(0) - నెల, విభజన(1) - సంఖ్య, విభజన(2) - సమయంతో కూడిన స్ట్రింగ్ మొదలైనవి. ఆ తర్వాత, తేదీలోని ప్రతి మూలకాన్ని శ్రేణిలోని సూచిక ద్వారా యాక్సెస్ చేయవచ్చు.

`var split = value.split(' '),`

• ప్రతి నెల (కాలక్రమానుసారం) శ్రేణిలో దాని స్థానం యొక్క సూచికకు అనుగుణంగా ఉంటుంది (0 నుండి 11 వరకు). వచన విలువను సంఖ్యా విలువగా మార్చడానికి, నెల సూచికకు ఒకటి జోడించబడుతుంది (ఎందుకంటే నెలలు 1 నుండి ప్రారంభించబడతాయి). ఈ సందర్భంలో, ఒకదానితో కూడిన వ్యక్తీకరణ బ్రాకెట్లలో తీసుకోబడుతుంది, లేకపోతే ఒక స్ట్రింగ్ పొందబడుతుంది, సంఖ్య కాదు. చివరికి మేము చేస్తాము ముక్క () - రెండు అక్షరాలను మాత్రమే వదిలివేయడానికి శ్రేణిని చివరి నుండి కత్తిరించండి (ఇది రెండు అంకెల సంఖ్యతో నెలలపాటు ముఖ్యమైనది).

`MONTHS_LIST = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],`

`month_index = ('0' + (MONTHS_LIST.indexOf(split[0]) + 1)).slice(-2),`

• తగిన క్రమంలో స్ట్రింగ్‌లను సాధారణ జోడింపు ద్వారా పొందిన విలువల నుండి మేము ISO ఆకృతిలో స్ట్రింగ్‌ను ఏర్పరుస్తాము.

`ISOdate = split[3] + '-' + month_index + '-' + split[1] + 'T' + split[2],`

ఫలిత ఆకృతిలోని డేటా 1970 నుండి భవిష్యత్తులో కొంత సమయం వరకు ఉన్న సెకన్ల సంఖ్య. ట్రిగ్గర్‌లలో స్వీకరించిన ఆకృతిలో డేటాను ఉపయోగించడం దాదాపు అసాధ్యం, ఎందుకంటే Zabbix మిమ్మల్ని మాక్రోలతో మాత్రమే ఆపరేట్ చేయడానికి అనుమతిస్తుంది {తేదీ} и {సమయం}, ఇది తేదీ మరియు సమయాన్ని వినియోగదారు-స్నేహపూర్వక ఆకృతిలో అందిస్తుంది.

• మేము ఇప్పుడు జావాస్క్రిప్ట్‌లో యునిక్స్ టైమ్‌స్టాంప్ ఆకృతిలో ప్రస్తుత తేదీని పొందవచ్చు మరియు సర్టిఫికేట్ గడువు ముగిసే వరకు మిల్లీసెకన్ల సంఖ్యను పొందడం కోసం ఫలిత ప్రమాణపత్రం గడువు తేదీ నుండి తీసివేయవచ్చు.

`now = Date.now();`

• Zabbixలో సెకన్లను పొందడానికి మేము అందుకున్న విలువను వెయ్యితో భాగిస్తాము.

`return parseInt((Date.parse(ISOdate) - now) / 1000);`

ట్రిగ్గర్‌లో, మీరు ' అనే వ్యక్తీకరణను పేర్కొనవచ్చుచివరిది' మీరు ప్రతిస్పందించాలనుకుంటున్న వ్యవధిలో సెకన్ల సంఖ్యకు అనుగుణంగా ఉండే అంకెల సమితిని అనుసరించండి, ఉదాహరణకు, వారాలలో. ఆ విధంగా, సర్టిఫికేట్ గడువు ఒక వారంలో ముగుస్తుందని ట్రిగ్గర్ తెలియజేస్తుంది.

గమనిక. ఉపయోగంపై శ్రద్ధ వహించండి parseInt() ఫంక్షన్ లో తిరిగిమిల్లీసెకన్ల విభజన ఫలితంగా వచ్చే పాక్షిక సంఖ్యను పూర్ణాంకానికి మార్చడానికి. మీరు కూడా ఉపయోగించవచ్చు పార్స్‌ఫ్లోట్() మరియు పాక్షిక డేటాను నిల్వ చేయండి.

నివేదికను చూడండి

మూలం: www.habr.com