ગ્રાફાના પ્લગઇનનો વિકાસ: ભૂલોનો ઇતિહાસ

નમસ્તે બધા! થોડા મહિના પહેલા, અમે અમારા નવા ઓપન-સોર્સ પ્રોજેક્ટ, કુબર્નેટ્સ મોનિટરિંગ માટે ગ્રાફાના પ્લગઇન, ને ઉત્પાદનમાં લોન્ચ કર્યું. ડેવઓપ્સપ્રોડિજી ક્યુબગ્રાફપ્લગઇન સોર્સ કોડ આમાં ઉપલબ્ધ છે GitHub પર જાહેર ભંડારઆ લેખમાં, અમે તમારી સાથે પ્લગઇન કેવી રીતે બનાવ્યું, અમે કયા સાધનોનો ઉપયોગ કર્યો અને વિકાસ દરમિયાન અમને કઈ મુશ્કેલીઓનો સામનો કરવો પડ્યો તેની વાર્તા શેર કરવા માંગીએ છીએ. ચાલો શરૂ કરીએ!

ભાગ ૦ - પરિચય: આપણે અહીં કેવી રીતે પહોંચ્યા?

ગ્રાફાના માટે આપણું પોતાનું પ્લગઇન લખવાનો વિચાર અમને આકસ્મિક રીતે આવ્યો. અમારી કંપની 10 વર્ષથી વધુ સમયથી વિવિધ જટિલતાના વેબ પ્રોજેક્ટ્સનું નિરીક્ષણ કરી રહી છે. આ સમય દરમિયાન, અમે વિવિધ મોનિટરિંગ સિસ્ટમ્સનો ઉપયોગ કરીને કુશળતા, રસપ્રદ કેસ સ્ટડીઝ અને અનુભવનો ભંડાર એકઠો કર્યો છે. કોઈક સમયે, અમે વિચાર્યું: "શું કુબર્નેટ્સનું નિરીક્ષણ કરવા માટે કોઈ જાદુઈ સાધન છે જે તમે, જેમ તેઓ કહે છે, 'તેને સેટ કરો અને ભૂલી જાઓ'" કરી શકો છો? સ્વાભાવિક રીતે, પ્રોમિથિયસ + ગ્રાફાના કોમ્બો લાંબા સમયથી K8S મોનિટરિંગ માટે ઉદ્યોગ માનક રહ્યો છે. આ સ્ટેક માટે તૈયાર સાધનોની વિશાળ શ્રેણી અસ્તિત્વમાં છે, જેમાં પ્રોમિથિયસ-ઓપરેટર, કુબર્નેટ્સ-મિક્સિન ડેશબોર્ડ સ્યુટ અને ગ્રાફાના-કુબર્નેટ્સ-એપનો સમાવેશ થાય છે.

grafana-kubernetes-app પ્લગઇન અમારા માટે સૌથી રસપ્રદ વિકલ્પ લાગતો હતો, પરંતુ તે એક વર્ષથી વધુ સમયથી સપોર્ટેડ નથી અને વધુમાં, node-exporter અને kube-state-metrics ના નવા સંસ્કરણો સાથે કામ કરતું નથી. કોઈક સમયે, અમે નક્કી કર્યું, "શા માટે આપણું પોતાનું સોલ્યુશન ન બનાવવું?"

અમે અમારા પ્લગઇનમાં કયા વિચારો અમલમાં મૂકવાનું નક્કી કર્યું?

• એપ્લિકેશન મેપ વિઝ્યુલાઇઝેશન: ક્લસ્ટરમાં એપ્લિકેશનોનું અનુકૂળ પ્રતિનિધિત્વ, નેમસ્પેસ, ડિપ્લોયમેન્ટ, વગેરે દ્વારા જૂથબદ્ધ;
• "ડિપ્લોયમેન્ટ - સર્વિસ (+પોર્ટ્સ)" પ્રકારના જોડાણોનું વિઝ્યુલાઇઝેશન.
• ક્લસ્ટર નોડ્સમાં ક્લસ્ટર એપ્લિકેશન્સના વિતરણનું વિઝ્યુલાઇઝેશન.
• બહુવિધ સ્ત્રોતોમાંથી મેટ્રિક્સ અને માહિતી એકત્રિત કરવી: પ્રોમિથિયસ અને k8s API સર્વર.
• ઇન્ફ્રાસ્ટ્રક્ચર (CPU સમય, મેમરી, ડિસ્ક સબસિસ્ટમ, નેટવર્કનો ઉપયોગ) અને એપ્લિકેશન લોજિક બંનેનું નિરીક્ષણ - પોડ્સની આરોગ્ય સ્થિતિ, ઉપલબ્ધ પ્રતિકૃતિઓની સંખ્યા અને જીવંતતા/તૈયારી પરીક્ષણોની પ્રગતિ વિશેની માહિતી.

ભાગ ૧: ગ્રાફાના પ્લગઇન શું છે?

ટેકનિકલ દૃષ્ટિકોણથી, ગ્રાફાના માટેનું પ્લગઇન એ એક કોણીય નિયંત્રક છે જે ગ્રાફાના ડેટા ડિરેક્ટરીમાં સંગ્રહિત થાય છે (/var/ગ્રાફાના/પ્લગઇન્સ/ /dist/module.js) અને SystemJS મોડ્યુલ તરીકે લોડ કરી શકાય છે. આ ડિરેક્ટરીમાં plugin.json ફાઇલ પણ હોવી જોઈએ, જેમાં તમારા પ્લગઇન વિશેનો તમામ મેટાડેટા શામેલ હોવો જોઈએ: નામ, સંસ્કરણ, પ્લગઇન પ્રકાર, રિપોઝીટરી/વેબસાઇટ/લાઇસન્સ લિંક્સ, ડિપેન્ડન્સીઝ, વગેરે.

મોડ્યુલ.ટીએસ

plugin.json

જેમ તમે સ્ક્રીનશોટમાં જોઈ શકો છો, અમે plugin.type = app સ્પષ્ટ કર્યું છે. આનું કારણ એ છે કે Grafana માટે ત્રણ પ્રકારના પ્લગઈન્સ છે:

પેનલ: પ્લગઇનનો સૌથી સામાન્ય પ્રકાર - તે ચોક્કસ મેટ્રિક્સને વિઝ્યુઅલાઈઝ કરવા માટેનું પેનલ છે અને તેનો ઉપયોગ વિવિધ ડેશબોર્ડ બનાવવા માટે થાય છે.
ડેટા સ્ત્રોત: કોઈપણ ડેટા સ્ત્રોત સાથે પ્લગઇન કનેક્ટર (ઉદાહરણ તરીકે, પ્રોમિથિયસ-ડેટાસોર્સ, ક્લિકહાઉસ-ડેટાસોર્સ, ઇલાસ્ટીકસર્ચ-ડેટાસોર્સ).
એપ્લિકેશન: એક પ્લગઇન જે તમને ગ્રાફાનામાં તમારી પોતાની ફ્રન્ટએન્ડ એપ્લિકેશન બનાવવા, તમારા પોતાના HTML પૃષ્ઠો બનાવવા અને વિવિધ ડેટાને વિઝ્યુઅલાઈઝ કરવા માટે ડેટાસોર્સને મેન્યુઅલી ઍક્સેસ કરવાની મંજૂરી આપે છે. અન્ય પ્લગઇન પ્રકારો (ડેટાસોર્સ, પેનલ) અને વિવિધ ડેશબોર્ડનો પણ નિર્ભરતા તરીકે ઉપયોગ કરી શકાય છે.

પ્રકાર = એપ્લિકેશન સાથે પ્લગઇન નિર્ભરતાનું ઉદાહરણ.

તમે પ્રોગ્રામિંગ ભાષા તરીકે JavaScript અથવા TypeScript નો ઉપયોગ કરી શકો છો (અમે TypeScript પસંદ કર્યું છે). તમે કોઈપણ પ્રકારના hello-world પ્લગઇન માટે ટેમ્પ્લેટ બનાવી શકો છો. લિંક દ્વારા શોધો: આ ભંડારમાં પહેલાથી ઇન્સ્ટોલ કરેલા અને ગોઠવેલા બિલ્ડરો સાથે મોટી સંખ્યામાં સ્ટાર્ટર પેક (રિએક્ટ પ્લગઇનનું પ્રાયોગિક ઉદાહરણ પણ છે) છે.

ભાગ ૨: સ્થાનિક વાતાવરણ તૈયાર કરવું

પ્લગઇન પર કામ કરવા માટે, આપણને સ્વાભાવિક રીતે જ બધા પૂર્વ-સ્થાપિત સાધનો સાથે કુબર્નેટ્સ ક્લસ્ટરની જરૂર પડશે: પ્રોમિથિયસ, નોડ-એક્સપોર્ટર, કુબે-સ્ટેટ-મેટ્રિક્સ અને ગ્રાફાના. પર્યાવરણ ઝડપી, સરળ અને સેટઅપ કરવા માટે મુશ્કેલી-મુક્ત હોવું જોઈએ, અને હોટ રીલોડિંગ સુનિશ્ચિત કરવા માટે, ગ્રાફાના ડેટા ડિરેક્ટરી સીધી ડેવલપરના મશીનથી માઉન્ટ થવી જોઈએ.

અમારા મતે, કુબર્નેટ્સ સાથે સ્થાનિક રીતે કામ કરવાનો સૌથી અનુકૂળ રસ્તો છે મિનીક્યુબઆગળનું પગલું પ્રોમિથિયસ-ઓપરેટરનો ઉપયોગ કરીને પ્રોમિથિયસ + ગ્રાફાના બંડલ ઇન્સ્ટોલ કરવાનું છે. આ લેખ મિનિક્યૂબ પર પ્રોમિથિયસ-ઓપરેટર ઇન્સ્ટોલ કરવાની પ્રક્રિયાનું વિગતવાર વર્ણન કરવામાં આવ્યું છે. પર્સિસ્ટન્સ સક્ષમ કરવા માટે, તમારે પેરામીટર સેટ કરવાની જરૂર છે દ્રઢતા: સાચું charts/grafana/values.yaml ફાઇલમાં, તમારા પોતાના PV અને PVC ઉમેરો અને તેમને persistence.existingClaim પેરામીટરમાં સ્પષ્ટ કરો.

અમારી અંતિમ મિનિક્યુબ લોન્ચ સ્ક્રિપ્ટ આના જેવી દેખાય છે:

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

ભાગ ૩: સીધો વિકાસ

ઑબ્જેક્ટ મોડેલ

પ્લગઇનના અમલીકરણની તૈયારીમાં, અમે બધા મૂળભૂત કુબર્નેટ્સ એન્ટિટીઝને વ્યાખ્યાયિત કરવાનું નક્કી કર્યું જેની સાથે અમે ટાઇપસ્ક્રિપ્ટ વર્ગો તરીકે કામ કરીશું: પોડ, ડિપ્લોયમેન્ટ, ડેમોનસેટ, સ્ટેટફુલસેટ, જોબ, ક્રોનજોબ, સર્વિસ, નોડ અને નેમસ્પેસ. આ દરેક ક્લાસ એક સામાન્ય બેઝમોડેલ ક્લાસમાંથી વારસામાં મળે છે, જે કન્સ્ટ્રક્ટર, ડિસ્ટ્રક્ટર અને દૃશ્યતાને અપડેટ અને ટૉગલ કરવા માટેની પદ્ધતિઓ વ્યાખ્યાયિત કરે છે. દરેક ક્લાસ અન્ય એન્ટિટીઝ સાથે નેસ્ટેડ સંબંધોને પણ વ્યાખ્યાયિત કરે છે, જેમ કે ડિપ્લોયમેન્ટ એન્ટિટી માટે પોડ્સની સૂચિ.

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 = [];
   }
}

ગેટર અને સેટરનો ઉપયોગ કરીને, આપણે ઇચ્છિત એન્ટિટી મેટ્રિક્સને અનુકૂળ અને વાંચી શકાય તેવા ફોર્મેટમાં પ્રદર્શિત અથવા સેટ કરી શકીએ છીએ. ઉદાહરણ તરીકે, ફાળવેલ CPU નોડ્સનું ફોર્મેટ કરેલ આઉટપુટ:

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

પાના

અમારા પ્લગઇનના બધા પૃષ્ઠોની સૂચિ શરૂઆતમાં અમારા pluing.json માં નિર્ભરતા વિભાગમાં વર્ણવેલ છે:

દરેક પૃષ્ઠ માટેના બ્લોકમાં, આપણે પૃષ્ઠ નામ (આ પછી સ્લગમાં રૂપાંતરિત થશે જેના દ્વારા આ પૃષ્ઠ ઍક્સેસિબલ હશે) સ્પષ્ટ કરવું આવશ્યક છે; આ પૃષ્ઠના સંચાલન માટે જવાબદાર ઘટકનું નામ (ઘટકોની સૂચિ module.ts પર નિકાસ કરવામાં આવે છે); આ પૃષ્ઠ સાથે કયા કાર્ય માટે વપરાશકર્તા ભૂમિકા ઉપલબ્ધ છે તેનો સંકેત અને સાઇડબાર માટે નેવિગેશન સેટિંગ્સ.

પેજના ઓપરેશન માટે જવાબદાર ઘટકમાં, આપણે templateUrl સેટ કરવું જોઈએ, તેને માર્કઅપ ધરાવતી HTML ફાઇલનો માર્ગ પસાર કરવો જોઈએ. કંટ્રોલરની અંદર, ડિપેન્ડન્સી ઇન્જેક્શન દ્વારા, આપણે બે મહત્વપૂર્ણ કોણીય સેવાઓને ઍક્સેસ કરી શકીએ છીએ:

• backendSrv એ એક સેવા છે જે Grafana API સર્વર સાથે ક્રિયાપ્રતિક્રિયા પૂરી પાડે છે;
• datasourceSrv એ એક સેવા છે જે તમારા Grafana માં ઇન્સ્ટોલ કરેલા બધા ડેટાસોર્સ સાથે સ્થાનિક ક્રિયાપ્રતિક્રિયા પૂરી પાડે છે (ઉદાહરણ તરીકે, .getAll() પદ્ધતિ બધા ઇન્સ્ટોલ કરેલા ડેટાસોર્સની સૂચિ પરત કરે છે; .get( ) — ચોક્કસ ડેટાસોર્સનો ઇન્સ્ટન્સ ઑબ્જેક્ટ પરત કરે છે.

ભાગ ૪: ડેટાસોર્સ

ગ્રાફાનાના દ્રષ્ટિકોણથી, ડેટાસોર્સ એ અન્ય કોઈપણ પ્લગઇનની જેમ જ એક પ્લગઇન છે: તેનો પોતાનો એન્ટ્રી પોઈન્ટ, module.js અને મેટાડેટા સાથે plugin.json ફાઇલ છે. type = app સાથે પ્લગઇન વિકસાવતી વખતે, આપણે હાલના ડેટાસોર્સ (ઉદાહરણ તરીકે, prometheus-datasource) અથવા આપણા પોતાના સાથે ક્રિયાપ્રતિક્રિયા કરી શકીએ છીએ, જેને આપણે સીધા પ્લગઇન ડિરેક્ટરીમાં (dist/datasource/*) સંગ્રહિત કરી શકીએ છીએ અથવા નિર્ભરતા તરીકે ઇન્સ્ટોલ કરી શકીએ છીએ. આપણા કિસ્સામાં, ડેટાસોર્સ પ્લગઇન કોડ સાથે બંડલ થયેલ છે. config.html ટેમ્પલેટ અને ConfigCtrl નિયંત્રક પણ જરૂરી છે, જેનો ઉપયોગ ડેટાસોર્સ ઇન્સ્ટન્સ કન્ફિગરેશન પેજ અને ડેટાસોર્સ નિયંત્રક માટે થશે, જે તમારા ડેટાસોર્સ માટે લોજિક લાગુ કરે છે.

કુબેગ્રાફ પ્લગઇનમાં, યુઝર ઇન્ટરફેસના દ્રષ્ટિકોણથી, ડેટાસોર્સ એ કુબર્નેટ્સ ક્લસ્ટરનું ઉદાહરણ છે જે નીચેની ક્ષમતાઓનો અમલ કરે છે (સોર્સ કોડ ઉપલબ્ધ છે). લિંક):

• k8s api સર્વરમાંથી ડેટા મેળવી રહ્યા છીએ (નેમસ્પેસ, ડિપ્લોયમેન્ટ, વગેરેની યાદી મેળવી રહ્યા છીએ)
• પ્રોમિથિયસ-ડેટાસોર્સ (જે દરેક ચોક્કસ ક્લસ્ટર માટે પ્લગઇન સેટિંગ્સમાં પસંદ થયેલ છે) ને પ્રોક્સી વિનંતીઓ કરવી અને સ્ટેટિક પૃષ્ઠો અને ડેશબોર્ડ બંનેમાં ડેટાનો ઉપયોગ કરવા માટે પ્રતિભાવો ફોર્મેટિંગ કરવા.
• પ્લગઇનના સ્ટેટિક પૃષ્ઠો પર ડેટા અપડેટ કરવો (સેટ રિફ્રેશ રેટ સાથે).
• ગ્રાફાના-ડેશબોર્ડ્સમાં ટેમ્પલેટ શીટ જનરેટ કરવા માટે ક્વેરીઝ પર પ્રક્રિયા કરી રહ્યા છીએ (પદ્ધતિ .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"};
       })
}

અમારા મતે, ડેટાસોર્સ માટે પ્રમાણીકરણ અને અધિકૃતતા પદ્ધતિનો અમલ એ ખાસ કરીને રસપ્રદ પાસું છે. સામાન્ય રીતે, બોક્સની બહાર, આપણે અંતિમ ડેટા સ્રોતની ઍક્સેસને ગોઠવવા માટે ગ્રાફાના બિલ્ટ-ઇન ડેટાસોર્સHttpSettings ઘટકનો ઉપયોગ કરી શકીએ છીએ. આ ઘટક સાથે, આપણે URL અને મૂળભૂત પ્રમાણીકરણ/અધિકૃતતા સેટિંગ્સનો ઉલ્લેખ કરીને HTTP ડેટા સ્રોતની ઍક્સેસને ગોઠવી શકીએ છીએ: લોગિન/પાસવર્ડ, અથવા ક્લાયંટ-સર્ટિફિકેટ/ક્લાયંટ-કી. બેરર ટોકન (k8s માટે ડી ફેક્ટો સ્ટાન્ડર્ડ) નો ઉપયોગ કરીને ઍક્સેસને ગોઠવવાની ક્ષમતાને અમલમાં મૂકવા માટે થોડી ટિંકરિંગની જરૂર હતી.

આ સમસ્યાને ઉકેલવા માટે, તમે ગ્રાફાના બિલ્ટ-ઇન "પ્લગઇન રૂટ્સ" મિકેનિઝમનો ઉપયોગ કરી શકો છો (વધુ વિગતો પર સત્તાવાર દસ્તાવેજીકરણ પાનું). અમારા ડેટાસોર્સ સેટિંગ્સમાં, અમે રૂટીંગ નિયમોનો સમૂહ જાહેર કરી શકીએ છીએ જે ગ્રાફાના પ્રોક્સી સર્વર દ્વારા પ્રક્રિયા કરવામાં આવશે. ઉદાહરણ તરીકે, દરેક વ્યક્તિગત એન્ડપોઇન્ટ માટે, ટેમ્પલેટ સપોર્ટ સાથે હેડર્સ અથવા URL સેટ કરવાનો વિકલ્પ છે, જેના માટે ડેટા jsonData અને secureJsonData ફીલ્ડ્સમાંથી લઈ શકાય છે (પાસવર્ડ્સ અથવા ટોકન્સને એન્ક્રિપ્ટેડ સ્વરૂપમાં સ્ટોર કરવા માટે). અમારા ઉદાહરણમાં, ફોર્મની વિનંતીઓ /__પ્રોક્સી/api/v1/નેમસ્પેસ નીચેના પ્રકારના URL ને પ્રોક્સી કરવામાં આવશે
/api/v1/namespaces ને Authorization: Bearer હેડર સેટ સાથે.

સ્વાભાવિક રીતે, k8s api સર્વર સાથે કામ કરવા માટે, આપણને ફક્ત વાંચવા માટે ઍક્સેસ ધરાવતા વપરાશકર્તાની જરૂર છે, બનાવવા માટેના મેનિફેસ્ટ જે તમે અહીં પણ શોધી શકો છો. પ્લગઇન સોર્સ કોડ.

ભાગ ૫: પ્રકાશન

એકવાર તમે તમારું પોતાનું ગ્રાફાના પ્લગઇન લખી લો, પછી તમે સ્વાભાવિક રીતે તેને ઓપન સોર્સ બનાવવા માંગો છો. ગ્રાફાનામાં, આ એક પ્લગઇન લાઇબ્રેરી છે, જે અહીં ઉપલબ્ધ છે grafana.com/grafana/plugins

તમારા પ્લગઇનને સત્તાવાર સ્ટોરમાં ઉપલબ્ધ કરાવવા માટે, તમારે PR બનાવવાની જરૂર છે આ ભંડાર, repo.json ફાઇલમાં આના જેવી સામગ્રી ઉમેરી રહ્યા છીએ:

જ્યાં version એ તમારા પ્લગઇનનું વર્ઝન છે, url એ રિપોઝીટરીનો લિંક છે, અને commit એ commit નો હેશ છે જે પ્લગઇનનું ચોક્કસ વર્ઝન ઉપલબ્ધ કરાવશે.

અને આઉટપુટ પર તમને આના જેવું એક અદ્ભુત ચિત્ર દેખાશે:

તેના માટેનો ડેટા આપમેળે તમારા Readme.md, Changelog.md અને પ્લગઇન વર્ણન સાથે plugin.json ફાઇલમાંથી લેવામાં આવશે.

ભાગ ૬: નિષ્કર્ષને બદલે

અમે અમારા પ્લગઇનને રિલીઝ થયા પછી વિકસાવવાનું બંધ કર્યું નથી. અમે હાલમાં ક્લસ્ટર નોડ રિસોર્સ વપરાશનું યોગ્ય રીતે નિરીક્ષણ કરવા, વપરાશકર્તા અનુભવને સુધારવા માટે નવી સુવિધાઓ લાગુ કરવા અને પ્લગઇન ઇન્સ્ટોલ કર્યા પછી અમારા ગ્રાહકો અને GitHub પર વપરાશકર્તાઓ બંને તરફથી મળેલા મોટા પ્રમાણમાં પ્રતિસાદને સૉર્ટ કરવા પર કામ કરી રહ્યા છીએ (જો તમે કોઈ સમસ્યા અથવા પુલ વિનંતી છોડી દો છો, તો મને ખૂબ આનંદ થશે :)).

અમને આશા છે કે આ લેખ તમને ગ્રાફાના જેવા અદ્ભુત સાધનને સમજવામાં અને કદાચ તમારું પોતાનું પ્લગઇન લખવામાં મદદ કરશે.

આભાર!)

સોર્સ: www.habr.com