ჩვენ ვაგვარებთ პრაქტიკულ პრობლემებს Zabbix-ში JavaScript-ის გამოყენებით

ტიხონ უსკოვი, Zabbix ინტეგრაციის გუნდის ინჟინერი

Zabbix არის კონფიგურირებადი პლატფორმა, რომელიც გამოიყენება ნებისმიერი სახის მონაცემების მონიტორინგისთვის. Zabbix-ის ადრეული ვერსიებიდან მოყოლებული, მონიტორინგის ადმინისტრატორებს ჰქონდათ სხვადასხვა სკრიპტების გაშვების შესაძლებლობა. აქციები სამიზნე ქსელის კვანძების შემოწმებისთვის. ამავდროულად, სკრიპტების გაშვებამ გამოიწვია მთელი რიგი სირთულეები, მათ შორის, როგორიცაა სკრიპტების მხარდაჭერის აუცილებლობა, მათი მიწოდება საკომუნიკაციო კვანძებსა და პროქსიებში, ასევე სხვადასხვა ვერსიების მხარდაჭერა.

JavaScript Zabbix-ისთვის

2019 წლის აპრილში, Zabbix 4.2 დაინერგა JavaScript წინასწარი დამუშავებით. ბევრი ადამიანი აღფრთოვანებული იყო იმ იდეით, რომ უარი თქვას წერის სკრიპტებზე, რომლებიც მონაცემებს სადღაც იღებენ, ამუშავებენ და მიაწოდებენ Zabbix-ის გასაგებ ფორმატში და შეასრულებენ მარტივ შემოწმებას, რომლებიც მიიღებენ მონაცემებს, რომლებიც მზად არ არის Zabbix-ის მიერ შესანახად და დასამუშავებლად, და შემდეგ დაამუშავეთ ეს მონაცემთა ნაკადი Zabbix და JavaScript ინსტრუმენტების გამოყენებით. დაბალი დონის აღმოჩენასთან და დამოკიდებულ ელემენტებთან ერთად, რომლებიც გამოჩნდა Zabbix 3.4-ში, მივიღეთ საკმაოდ მოქნილი კონცეფცია მიღებული მონაცემების დახარისხებისა და მართვისთვის.

Zabbix 4.4-ში, როგორც JavaScript-ში წინასწარი დამუშავების ლოგიკური გაგრძელება, გამოჩნდა შეტყობინების ახალი მეთოდი - Webhook, რომლის გამოყენებაც შესაძლებელია Zabbix-ის შეტყობინებების ადვილად ინტეგრირებისთვის მესამე მხარის აპლიკაციებთან.

JavaScript და Duktapes

რატომ აირჩიეს JavaScript და Duktape? განიხილებოდა ენებისა და ძრავების სხვადასხვა ვარიანტი:

• ლუა - ლუა 5.1
• ლუა - LuaJIT
• Javascript - Duktape
• Javascript - JerryScript
• ჩაშენებული პითონი
• ჩაშენებული პერლი

შერჩევის მთავარი კრიტერიუმი იყო პრევალენტობა, ძრავის პროდუქტში ინტეგრაციის სიმარტივე, რესურსების დაბალი მოხმარება და ძრავის საერთო ფუნქციონირება და ამ ენაზე კოდის მონიტორინგში დანერგვის უსაფრთხოება. ინდიკატორების კომბინაციის საფუძველზე, JavaScript-მა გაიმარჯვა Duktape ძრავზე.

შერჩევის კრიტერიუმები და შესრულების ტესტირება

Duktape მახასიათებლები:

- სტანდარტული ECMAScript E5/E5.1
- Zabbix მოდულები Duktape-სთვის:

• Zabbix.log() - საშუალებას გაძლევთ დაწეროთ შეტყობინებები სხვადასხვა დონის დეტალებით პირდაპირ Zabbix სერვერის ჟურნალში, რაც შესაძლებელს ხდის შეცდომების კორელაციას, მაგალითად, Webhook-ში, სერვერის მდგომარეობასთან.
• CurlHttpRequest() - საშუალებას გაძლევთ განახორციელოთ HTTP მოთხოვნები ქსელში, რომელზედაც დაფუძნებულია Webhook-ის გამოყენება.
• atob() და btoa() - საშუალებას გაძლევთ დაშიფვროთ და გაშიფროთ სტრიქონები Base64 ფორმატში.

შენიშვნა. Duktape შეესაბამება ACME სტანდარტებს. Zabbix იყენებს სცენარის 2015 ვერსიას. შემდგომი ცვლილებები უმნიშვნელოა, ამიტომ მათი იგნორირება შესაძლებელია..

JavaScript მაგია

JavaScript-ის მთელი ჯადოქრობა მდგომარეობს დინამიურ აკრეფაში და კასტინგში: სიმებიანი, რიცხვითი და ლოგიკური.

ეს ნიშნავს, რომ არ არის აუცილებელი წინასწარ განვაცხადოთ, თუ რა ტიპის ცვლადს უნდა დააბრუნოს მნიშვნელობა.

მათემატიკური ოპერაციების დროს, ფუნქციის ოპერატორების მიერ დაბრუნებული მნიშვნელობები გარდაიქმნება რიცხვებად. ასეთი ოპერაციების გამონაკლისი არის დამატება, რადგან თუ ტერმინებიდან ერთი მაინც არის სტრიქონი, სტრიქონების კონვერტაცია გამოიყენება ყველა ტერმინზე.

შენიშვნა. ასეთ ტრანსფორმაციებზე პასუხისმგებელი მეთოდები, როგორც წესი, დანერგილია ობიექტის მშობელ პროტოტიპებში, ფასეულობა и გადასვლა. ფასეულობა იწოდება რიცხვითი კონვერტაციის დროს და ყოველთვის მეთოდის წინ გადასვლა. მეთოდი ფასეულობა უნდა დააბრუნოს პრიმიტიული მნიშვნელობები, წინააღმდეგ შემთხვევაში მისი შედეგი იგნორირებული იქნება.

მეთოდი იწოდება ობიექტზე ფასეულობა. თუ ის ვერ მოიძებნა ან არ დააბრუნებს პრიმიტიულ მნიშვნელობას, მეთოდი გამოიძახება გადასვლა. თუ მეთოდი გადასვლა ვერ მოიძებნა, ეძებს ფასეულობა ობიექტის პროტოტიპში და ყველაფერი მეორდება მანამ, სანამ მნიშვნელობის დამუშავება არ დასრულდება და გამონათქვამში ყველა მნიშვნელობა გადაიცემა იმავე ტიპზე. თუ ობიექტი ახორციელებს მეთოდს გადასვლა, რომელიც აბრუნებს პრიმიტიულ მნიშვნელობას, მაშინ სწორედ ის გამოიყენება სტრიქონების კონვერტაციისთვის. თუმცა, ამ მეთოდის გამოყენების შედეგი სულაც არ არის სტრიქონი.

მაგალითად, თუ ობიექტისთვისObjმეთოდი განსაზღვრულია გადასვლა,

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

მეთოდი გადასვლა აბრუნებს ზუსტად სტრიქონს და რიცხვით სტრიქონის დამატებისას ვიღებთ წებოვან სტრიქონს:

`obj + 1 // '2001'` 

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

მაგრამ თუ გადაწერ გადასვლა, რათა მეთოდი აბრუნებს რიცხვს, ობიექტის დამატებისას შესრულდება მათემატიკური ოპერაცია რიცხვითი გარდაქმნით და მიიღება მათემატიკური შეკრების შედეგი.

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

`obj + 1 // '2001'`

ამ შემთხვევაში, თუ სტრიქონით შევასრულებთ მიმატებას, ხდება სტრიქონის გარდაქმნა და ვიღებთ წებოვან სტრიქონს.

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

ეს არის JavaScript-ის დამწყები მომხმარებლების დიდი რაოდენობის შეცდომის მიზეზი.

Მეთოდი გადასვლა შეგიძლიათ დაწეროთ ფუნქცია, რომელიც გაზრდის ობიექტის მიმდინარე მნიშვნელობას 1-ით.

სკრიპტის შესრულება იმ პირობით, რომ ცვლადი უდრის 3-ს და ის ასევე უდრის 4-ს.

როდესაც შევადარებთ მსახიობს (==), მეთოდი ყოველ ჯერზე სრულდება გადასვლა ღირებულების გაზრდის ფუნქციით. შესაბამისად, ყოველი მომდევნო შედარებისას, ღირებულება იზრდება. ამის თავიდან აცილება შესაძლებელია არაგადაღებული შედარების გამოყენებით (===).

შედარება ტიპის ჩამოსხმის გარეშე

შენიშვნა. ზედმეტად არ გამოიყენოთ მსახიობების შედარება.

რთული სკრიპტებისთვის, როგორიცაა Webhooks რთული ლოგიკით, რომლებიც საჭიროებენ შედარებას ტიპის კასტინგთან, რეკომენდებულია წინასწარ ჩაწეროთ შემოწმებები იმ მნიშვნელობებისთვის, რომლებიც აბრუნებენ ცვლადებს და ამუშავებენ შეუსაბამობებს და შეცდომებს.

Webhook Media

2019 წლის ბოლოს და 2020 წლის დასაწყისში, Zabbix-ის ინტეგრაციის გუნდი აქტიურად ავითარებდა Webhooks-ს და გარე ინტეგრაციებს, რომლებიც მოყვება Zabbix დისტრიბუციას.

• უთანხმოება
• Jira
• Jira Service Desk
• მატერია
• Microsoft გუნდები
• ოპსგენიე
• სხვები
• პეიჯერდუტი
• Pushover
• წითელი
• სერვისი
• SINGL4
• Slack
• დეპეშა
• ზამმადი
• Zendesk

ბმული დოკუმენტაცია

წინასწარი დამუშავება

• JavaScript-ში წინასწარი დამუშავების გამოჩენამ შესაძლებელი გახადა გარე სკრიპტების უმეტესობის მიტოვება და ამჟამად Zabbix-ში შეგიძლიათ მიიღოთ ნებისმიერი მნიშვნელობა და გადაიყვანოთ იგი სრულიად განსხვავებულ მნიშვნელობად.
• Zabbix-ში წინასწარი დამუშავება ხორციელდება JavaScript კოდით, რომელიც ბაიტეკოდში შედგენისას გარდაიქმნება ფუნქციად, რომელიც პარამეტრად იღებს ერთ მნიშვნელობას. ღირებულება როგორც სტრიქონი (სტრიქონი შეიძლება შეიცავდეს ციფრსაც და რიცხვსაც).
• ვინაიდან გამომავალი არის ფუნქცია, სკრიპტის ბოლოს საჭიროა დაბრუნების.
• შესაძლებელია კოდში მორგებული მაკროების გამოყენება.
• რესურსები შეიძლება შეიზღუდოს არა მხოლოდ ოპერაციული სისტემის დონეზე, არამედ პროგრამულადაც. წინასწარი დამუშავების საფეხურს ეთმობა მაქსიმუმ 10 მეგაბაიტი ოპერატიული მეხსიერება და მუშაობის ვადა 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 წამის განმავლობაში „ჰაკერებს“ და ბოლო წამს იწყებს შემოწმებას და გამოთვლას. ეს ქმნის რიგს და გავლენას ახდენს შესრულებაზე. ამიტომ, რეკომენდებულია ფიქსირებული ინტერვალების გამოყენება მხოლოდ იმ შემთხვევაში, თუ ეს ნამდვილად აუცილებელია.

ამ პრობლემაში, ოპტიმალური გადაწყვეტა არის ერთსტრიქონიანი JavaScript წინასწარი დამუშავება, რომელიც გარდაქმნის ფარენჰეიტის გრადუსს ცელსიუს ხარისხებად:

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

ეს არის სწრაფი და მარტივი, თქვენ არ გჭირდებათ არასაჭირო მონაცემთა ელემენტების შექმნა და მათზე ისტორიის შენარჩუნება, ასევე შეგიძლიათ გამოიყენოთ მოქნილი ინტერვალები შემოწმებისთვის.

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

მაგრამ, თუ ჰიპოთეტურ სიტუაციაში აუცილებელია მიღებული მონაცემთა ელემენტის დამატება, მაგალითად, მაკროში განსაზღვრული ნებისმიერი მუდმივით, მხედველობაში უნდა იქნას მიღებული, რომ პარამეტრი ღირებულება სტრინგად ფართოვდება. სტრიქონების დამატების ოპერაციის დროს ორი სტრიქონი უბრალოდ გაერთიანებულია ერთში.

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

მათემატიკური ოპერაციის შედეგის მისაღებად აუცილებელია მიღებული მნიშვნელობების ტიპების გადაყვანა ციფრულ ფორმატში. ამისათვის შეგიძლიათ გამოიყენოთ ფუნქცია parseInt(), რომელიც აწარმოებს მთელ რიცხვს, ფუნქციას parseFloat(), რომელიც აწარმოებს ათწილადს ან ფუნქციას რაოდენობა, რომელიც აბრუნებს მთელ რიცხვს ან ათწილადს.

დავალება 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 საშუალებას გაძლევთ იმუშაოთ მხოლოდ მაკროებით {თარიღი и {დრო}, რომელიც აბრუნებს თარიღსა და დროს მომხმარებლისთვის მოსახერხებელი ფორმატით.

• ჩვენ შეგვიძლია მივიღოთ მიმდინარე თარიღი JavaScript-ში Unix Timestamp ფორმატში და გამოვაკლოთ იგი მიღებული სერტიფიკატის ვადის გასვლის თარიღს, რათა მივიღოთ მილიწამების რაოდენობა ამიერიდან სერტიფიკატის ვადის ამოწურვამდე.

`now = Date.now();`

• მიღებულ მნიშვნელობას ვყოფთ ათასზე, რათა მივიღოთ წამი Zabbix-ში.

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

ტრიგერში შეგიძლიათ მიუთითოთ გამოთქმა 'ბოლომოჰყვება ციფრების ნაკრები, რომელიც შეესაბამება წამების რაოდენობას იმ პერიოდში, რომელზეც გსურთ პასუხის გაცემა, მაგალითად, კვირებში. ამრიგად, ტრიგერი შეატყობინებს, რომ სერთიფიკატი იწურება ერთ კვირაში.

შენიშვნა. ყურადღება მიაქციეთ გამოყენებას parseInt() ფუნქციაში დაბრუნებისმილიწამების გაყოფის შედეგად მიღებული წილადი რიცხვის მთელ რიცხვად გადაქცევა. თქვენ ასევე შეგიძლიათ გამოიყენოთ parseFloat() და შეინახეთ წილადი მონაცემები.

ნახეთ რეპორტაჟი

წყარო: www.habr.com