მოდულის შემუშავება Grafana-სთვის: დიდი კადრების ისტორია

Სალამი ყველას! რამდენიმე თვის წინ, ჩვენ დავიწყეთ ჩვენი ახალი ღია კოდის პროექტი წარმოებაში - Grafana მოდული კუბერნეტების მონიტორინგისთვის, რომელსაც ჩვენ ვუწოდებდით DevOpsProdigy KubeGraf. მოდულის წყაროს კოდი ხელმისაწვდომია მისამართზე საჯარო საცავი GitHub-ზე. და ამ სტატიაში გვინდა გაგიზიაროთ ისტორია იმის შესახებ, თუ როგორ შევქმენით მოდული, რა ინსტრუმენტები გამოვიყენეთ და რა პრობლემები შეგვხვდა განვითარების პროცესში. Წავედით!

ნაწილი 0 - შესავალი: როგორ მივედით აქამდე?

Grafan-ისთვის ჩვენი საკუთარი მოდულის დაწერის იდეა სრულიად შემთხვევით გაგვიჩნდა. ჩვენი კომპანია 10 წელზე მეტია აკვირდება სხვადასხვა დონის სირთულის ვებ პროექტებს. ამ დროის განმავლობაში ჩვენ დავაგროვეთ დიდი ექსპერტიზა, საინტერესო შემთხვევები და გამოცდილება სხვადასხვა მონიტორინგის სისტემების გამოყენებაში. და რაღაც მომენტში ჩვენ საკუთარ თავს ვკითხეთ: "არსებობს თუ არა ჯადოსნური ინსტრუმენტი Kubernetes-ის მონიტორინგისთვის, რათა, როგორც ამბობენ, "დააყენე და დაივიწყო"?". K8-ების მონიტორინგის ინდუსტრიის სტანდარტი, რა თქმა უნდა, დიდი ხანია იყო. პრომეთე + გრაფანას კომბინაცია. და როგორც ამ სტეკისთვის მზა გადაწყვეტილებები, არის სხვადასხვა სახის ხელსაწყოების დიდი ნაკრები: პრომეთე-ოპერატორი, კუბერნეტის-მიქსინის დაფების ნაკრები, გრაანა-კუბერნეტეს-აპი.

როგორც ჩანს, grafana-kubernetes-app მოდული ჩვენთვის ყველაზე საინტერესო ვარიანტი იყო, მაგრამ ის წელიწადზე მეტია არ არის მხარდაჭერილი და, უფრო მეტიც, ვერ მუშაობს node-exporter და kube-state-metrics-ის ახალ ვერსიებთან. და რაღაც მომენტში ჩვენ გადავწყვიტეთ: "ჩვენ თვითონ არ უნდა მივიღოთ გადაწყვეტილება?"

რა იდეები გადავწყვიტეთ დანერგვა ჩვენს დანამატში:

• „აპლიკაციის რუკის“ ვიზუალიზაცია: აპლიკაციების მოსახერხებელი პრეზენტაცია კლასტერში, დაჯგუფებული სახელების სივრცის მიხედვით, განლაგების...;
• კავშირების ვიზუალიზაცია, როგორიცაა "განლაგება - სერვისი (+პორტები)".
• კლასტერული აპლიკაციების განაწილების ვიზუალიზაცია კლასტერულ კვანძებში.
• მეტრიკისა და ინფორმაციის კოლექცია რამდენიმე წყაროდან: პრომეთე და k8s api სერვერი.
• როგორც ინფრასტრუქტურის ნაწილის (პროცესორის დროის, მეხსიერების, დისკის ქვესისტემის, ქსელის გამოყენება) და აპლიკაციის ლოგიკის მონიტორინგი - ჯანმრთელობის სტატუსის პოდები, ხელმისაწვდომი ასლების რაოდენობა, ინფორმაცია სიცოცხლისუნარიანობის/მზადყოფნის ტესტების გავლის შესახებ.

ნაწილი 1: რა არის „გრაფანას დანამატი“?

ტექნიკური თვალსაზრისით, Grafana-ს მოდული არის კუთხოვანი კონტროლერი, რომელიც ინახება Grafana მონაცემთა დირექტორიაში (/var/grafana/plugins/ /dist/module.js) და შეიძლება ჩაიტვირთოს, როგორც SystemJS მოდული. ასევე ამ დირექტორიაში უნდა იყოს plugin.json ფაილი, რომელიც შეიცავს ყველა მეტა ინფორმაციას თქვენი მოდულის შესახებ: სახელი, ვერსია, დანამატის ტიპი, საცავების/საიტის/ლიცენზიის ბმულები, დამოკიდებულებები და ა.შ.

მოდული.ც

plugin.json

როგორც სკრინშოტში ხედავთ, ჩვენ დავაზუსტეთ plugin.type = app. რადგან Grafana-ს დანამატები შეიძლება იყოს სამი ტიპის:

პანელი: დანამატის ყველაზე გავრცელებული ტიპი - ეს არის პანელი ნებისმიერი მეტრიკის ვიზუალიზაციისთვის, რომელიც გამოიყენება სხვადასხვა დაფის ასაგებად.
მონაცემთა წყარო: დანამატის დამაკავშირებელი ზოგიერთი მონაცემთა წყაროსთვის (მაგალითად, Prometheus-datasource, ClickHouse-datasource, ElasticSearch-datasource).
app: მოდული, რომელიც საშუალებას გაძლევთ შექმნათ თქვენი საკუთარი წინაპირა აპლიკაცია Grafana-ს შიგნით, შექმნათ თქვენი საკუთარი html გვერდები და ხელით შეხვიდეთ მონაცემთა წყაროზე სხვადასხვა მონაცემების ვიზუალიზაციისთვის. ასევე, სხვა ტიპის დანამატები (მონაცემთა წყარო, პანელი) და სხვადასხვა დაფები შეიძლება გამოყენებულ იქნას როგორც დამოკიდებულებები.

მოდულების დამოკიდებულების მაგალითი type=app.

თქვენ შეგიძლიათ გამოიყენოთ როგორც JavaScript, ასევე TypeScript, როგორც პროგრამირების ენა (ჩვენ ავირჩიეთ). მზადება hello-world დანამატებისთვის ნებისმიერი ტიპის, რაც შეგიძლიათ იპოვნეთ ბმულით: ეს საცავი შეიცავს დამწყებ-პაკეტების დიდ რაოდენობას (დამატების ექსპერიმენტული მაგალითიც კი არის React-ში) წინასწარ დაინსტალირებული და კონფიგურირებული ბილდერებით.

ნაწილი 2: ადგილობრივი გარემოს მომზადება

დანამატზე სამუშაოდ, ბუნებრივია, გვჭირდება kubernetes კლასტერი ყველა წინასწარ დაინსტალირებული ხელსაწყოებით: პრომეთე, კვანძის ექსპორტიორი, kube-state-metrics, grafana. გარემო უნდა შეიქმნას სწრაფად, მარტივად და ბუნებრივად და ცხელი გადატვირთვის უზრუნველსაყოფად, Grafana მონაცემთა დირექტორია უნდა დამონტაჟდეს პირდაპირ დეველოპერის აპარატიდან.

ყველაზე მოსახერხებელი გზა, ჩვენი აზრით, კუბერნეტებთან ადგილობრივად მუშაობისთვის არის მინიკუბე. შემდეგი ნაბიჯი არის Prometheus + Grafana კომბინაციის დაყენება პრომეთე-ოპერატორის გამოყენებით. IN ეს არტიკლი დეტალურად არის აღწერილი პრომეთე-ოპერატორის მინიკუბეზე დაყენების პროცესი. მდგრადობის გასააქტიურებლად, თქვენ უნდა დააყენოთ პარამეტრი გამძლეობა: მართალია ჩარტებში/grafana/values.yaml ფაილში დაამატეთ თქვენი საკუთარი PV და PVC და მიუთითეთ ისინი persistence.existingClaim პარამეტრში

ჩვენი საბოლოო minikube გაშვების სკრიპტი ასე გამოიყურება:

minikube start --kubernetes-version=v1.13.4 --memory=4096 --bootstrapper=kubeadm --extra-config=scheduler.address=0.0.0.0 --extra-config=controller-manager.address=0.0.0.0
minikube mount 
/home/sergeisporyshev/Projects/Grafana:/var/grafana --gid=472 --uid=472 --9p-version=9p2000.L

ნაწილი 3: ფაქტობრივი განვითარება

ობიექტის მოდელი

მოდულის დანერგვის მომზადებისას, ჩვენ გადავწყვიტეთ აღვწეროთ Kubernetes-ის ყველა ძირითადი ერთეული, რომლებთანაც ვიმუშავებთ TypeScript კლასების სახით: pod, deployment, daemonset, statefulset, job, cronjob, სერვისი, კვანძი, სახელების სივრცე. თითოეული ეს კლასი მემკვიდრეობით იღებს საერთო BaseModel კლასის, რომელიც აღწერს კონსტრუქტორს, დესტრუქტორს, ხილვადობის განახლებისა და გადართვის მეთოდებს. თითოეული კლასი აღწერს ჩადგმულ ურთიერთობებს სხვა ერთეულებთან, მაგალითად, განყოფილებების სიას ტიპის განლაგების ერთეულისთვის.

import {Pod} from "./pod";
import {Service} from "./service";
import {BaseModel} from './traits/baseModel';

export class Deployment extends BaseModel{
   pods: Array<Pod>;
   services: Array<Service>;

   constructor(data: any){
       super(data);
       this.pods = [];
       this.services = [];
   }
}

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

get cpuAllocatableFormatted(){
   let cpu = this.data.status.allocatable.cpu;
   if(cpu.indexOf('m') > -1){
       cpu = parseInt(cpu)/1000;
   }
   return cpu;
}

გვერდები

ჩვენი ყველა დანამატის გვერდის სია თავდაპირველად აღწერილია ჩვენს pluing.json-ში დამოკიდებულებების განყოფილებაში:

თითოეული გვერდის ბლოკში უნდა მივუთითოთ PAGE NAME (შემდეგ ის გარდაიქმნება შლაგად, რომლითაც ეს გვერდი ხელმისაწვდომი იქნება); ამ გვერდის მუშაობაზე პასუხისმგებელი კომპონენტის დასახელება (კომპონენტების სია ექსპორტირებულია module.ts-ზე); მიუთითებს მომხმარებლის როლზე, რომლისთვისაც შესაძლებელია ამ გვერდზე მუშაობა და ნავიგაციის პარამეტრები გვერდითი ზოლისთვის.

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

• backendSrv - სერვისი, რომელიც უზრუნველყოფს ინტერაქციას Grafana API სერვერთან;
• datasourceSrv - სერვისი, რომელიც უზრუნველყოფს ლოკალურ ურთიერთქმედებას თქვენს Grafana-ში დაინსტალირებული ყველა მონაცემთა წყაროსთან (მაგალითად, .getAll() მეთოდი - აბრუნებს ყველა დაინსტალირებული მონაცემთა წყაროს სიას; .get( ) - აბრუნებს კონკრეტული მონაცემთა წყაროს ინსტანციის ობიექტს.

ნაწილი 4: მონაცემთა წყარო

Grafana-ს თვალსაზრისით, მონაცემთა წყარო ზუსტად იგივე დანამატია, როგორც ყველა სხვა: მას აქვს საკუთარი შესვლის წერტილი module.js, არის ფაილი მეტაინფორმაციით plugin.json. დანამატის შემუშავებისას type = აპლიკაციით, ჩვენ შეგვიძლია ურთიერთქმედება როგორც არსებულ მონაცემთა წყაროებთან (მაგალითად, prometheus-datasource), ასევე ჩვენს საკუთართან, რომელიც შეგვიძლია შევინახოთ პირდაპირ დანამატის დირექტორიაში (dist/datasource/*) ან დავაინსტალიროთ როგორც დამოკიდებულების სახით. ჩვენს შემთხვევაში, მონაცემთა წყაროს მოყვება მოდულის კოდი. ასევე აუცილებელია გქონდეთ config.html შაბლონი და ConfigCtrl კონტროლერი, რომელიც გამოყენებული იქნება მონაცემთა წყაროს ინსტანციის კონფიგურაციის გვერდისთვის და მონაცემთა წყაროს კონტროლერი, რომელიც ახორციელებს თქვენი მონაცემთა წყაროს ლოგიკას.

KubeGraf დანამატში, მომხმარებლის ინტერფეისის თვალსაზრისით, მონაცემთა წყარო არის kubernetes კლასტერის მაგალითი, რომელიც ახორციელებს შემდეგ შესაძლებლობებს (წყარო კოდი ხელმისაწვდომია по ссылке):

• მონაცემების შეგროვება k8s api-სერვერიდან (სახელთა სივრცის სიის მიღება, განლაგება...)
• Prometheus-datasource-ის მოთხოვნების პროქსირება (რომელიც არჩეულია თითოეული კონკრეტული კლასტერის დანამატის პარამეტრებში) და პასუხების ფორმატირება, რათა გამოიყენოს მონაცემები როგორც სტატიკურ გვერდებზე, ასევე საინფორმაციო დაფებში.
• მონაცემების განახლება სტატიკური დანამატის გვერდებზე (განახლების დაყენებული სიჩქარით).
• მოთხოვნების დამუშავება შაბლონის ფურცლის გენერირებისთვის grafana-dashboards-ში (metriFindQuery() მეთოდი)

• კავშირის ტესტი საბოლოო k8s კლასტერთან.

testDatasource(){
   let url = '/api/v1/namespaces';
   let _url = this.url;
   if(this.accessViaToken)
       _url += '/__proxy';
   _url += url;
   return this.backendSrv.datasourceRequest({
       url: _url,
       method: "GET",
       headers: {"Content-Type": 'application/json'}
   })
       .then(response => {
           if (response.status === 200) {
               return {status: "success", message: "Data source is OK", title: "Success"};
           }else{
               return {status: "error", message: "Data source is not OK", title: "Error"};
           }
       }, error => {
           return {status: "error", message: "Data source is not OK", title: "Error"};
       })
}

ცალკე საინტერესო პუნქტი, ჩვენი აზრით, არის მონაცემთა წყაროს ავთენტიფიკაციისა და ავტორიზაციის მექანიზმის დანერგვა. როგორც წესი, ჩვენ შეგვიძლია გამოვიყენოთ ჩაშენებული Grafana კომპონენტი datasourceHttpSettings მონაცემთა საბოლოო წყაროზე წვდომის კონფიგურაციისთვის. ამ კომპონენტის გამოყენებით, ჩვენ შეგვიძლია დავაკონფიგურიროთ http მონაცემთა წყაროზე წვდომა url-ის და ძირითადი ავთენტიფიკაციის/ავტორიზაციის პარამეტრების მითითებით: შესვლა-პაროლი, ან კლიენტ-სერტი/კლიენტ-გასაღები. იმისათვის, რომ განეხორციელებინათ წვდომის კონფიგურაციის შესაძლებლობა მატარებლის ნიშნის გამოყენებით (დე ფაქტო სტანდარტი k8s-ისთვის), ჩვენ მოგვიწია მცირე შესწორება.

ამ პრობლემის გადასაჭრელად შეგიძლიათ გამოიყენოთ ჩაშენებული Grafana „Plugin Routes“ მექანიზმი (დაწვრილებით ოფიციალური დოკუმენტაციის გვერდი). ჩვენი მონაცემთა წყაროს პარამეტრებში ჩვენ შეგვიძლია გამოვაცხადოთ მარშრუტიზაციის წესების ნაკრები, რომლებიც დამუშავდება grafana პროქსი სერვერის მიერ. მაგალითად, თითოეული ცალკეული ბოლო წერტილისთვის შესაძლებელია სათაურების ან url-ების დაყენება შაბლონის შესაძლებლობით, რომელთა მონაცემების აღება შესაძლებელია jsonData და safeJsonData ველებიდან (პაროლების ან ტოკენების დაშიფრული ფორმით შესანახად). ჩვენს მაგალითში, მოთხოვნები, როგორიცაა /__proxy/api/v1/namespaces პროქსი იქნება ფორმის url-ზე
/api/v8/namespaces ავტორიზაციით: Bearer header.

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

ნაწილი 5: გათავისუფლება

მას შემდეგ რაც დაწერთ საკუთარ Grafana დანამატს, ბუნებრივია, მოგინდებათ, რომ ის საჯაროდ გახადოთ. Grafana-ში ეს არის აქ ხელმისაწვდომი დანამატების ბიბლიოთეკა grafana.com/grafana/plugins

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

სადაც ვერსია არის თქვენი მოდულის ვერსია, url არის ბმული საცავთან და commit არის commit-ის ჰეში, რომლისთვისაც ხელმისაწვდომი იქნება მოდულის კონკრეტული ვერსია.

და გამოსავალზე ნახავთ მშვენიერ სურათს, როგორიცაა:

მისი მონაცემები ავტომატურად იქნება აღებული თქვენი Readme.md, Changelog.md და plugin.json ფაილიდან მოდულის აღწერილობით.

ნაწილი 6: დასკვნების ნაცვლად

ჩვენ არ შევწყვიტეთ ჩვენი მოდულის შემუშავება გამოშვების შემდეგ. ახლა ჩვენ ვმუშაობთ კლასტერული კვანძების რესურსების გამოყენების სწორ მონიტორინგზე, ახალი ფუნქციების დანერგვა UX-ის გასაუმჯობესებლად და ასევე მოდულის ინსტალაციის შემდეგ მიღებული უამრავ გამოხმაურებას, როგორც ჩვენი კლიენტების, ასევე GitHub-ის ხალხისგან (თუ დატოვებთ თქვენი პრობლემა ან მოთხოვნა, მე ძალიან ბედნიერი ვიქნები :)

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

Გმადლობთ!)

წყარო: www.habr.com