ગ્રાફના માટે પ્લગઇનનો વિકાસ: મોટા શોટ્સનો ઇતિહાસ

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

ભાગ 0 - પ્રારંભિક: આપણે આ બિંદુ સુધી કેવી રીતે પહોંચ્યા?

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

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

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

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

ભાગ 1: "Grafana પ્લગઇન" શું છે?

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

મોડ્યુલ.ts

plugin.json

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

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

type=app સાથે પ્લગઇન અવલંબનનું ઉદાહરણ.

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

ભાગ 2: સ્થાનિક વાતાવરણની તૈયારી

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

અમારા મતે, કુબરનેટ્સ સાથે સ્થાનિક રીતે કામ કરવાની સૌથી અનુકૂળ રીત છે મિનીક્યુબ. આગળનું પગલું પ્રોમિથિયસ-ઓપરેટરનો ઉપયોગ કરીને પ્રોમિથિયસ + ગ્રાફાના સંયોજનને ઇન્સ્ટોલ કરવાનું છે. IN આ લેખ મિનીક્યુબ પર પ્રોમિથિયસ-ઓપરેટર ઇન્સ્ટોલ કરવાની પ્રક્રિયા વિગતવાર વર્ણવેલ છે. દ્રઢતાને સક્ષમ કરવા માટે, તમારે પરિમાણ સેટ કરવું આવશ્યક છે દ્રઢતા: સાચું 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

ભાગ 3: વાસ્તવિક વિકાસ

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

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

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 ફાઇલનો માર્ગ પસાર કરવો. નિયંત્રકની અંદર, નિર્ભરતા ઇન્જેક્શન દ્વારા, અમે 2 મહત્વપૂર્ણ કોણીય સેવાઓ સુધી ઍક્સેસ કરી શકીએ છીએ:

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

ભાગ 4: ડેટા સ્ત્રોત

ગ્રાફનાના દૃષ્ટિકોણથી, ડેટાસોર્સ એ બીજા બધા જેવા જ પ્લગઇન છે: તેનું પોતાનું એન્ટ્રી પોઇન્ટ મોડ્યુલ.જેએસ છે, મેટા ઇન્ફોર્મેશન plugin.json સાથેની ફાઇલ છે. પ્રકાર = એપ્લિકેશન સાથે પ્લગઇન વિકસાવતી વખતે, અમે અસ્તિત્વમાંના ડેટાસોર્સ (ઉદાહરણ તરીકે, પ્રોમિથિયસ-ડેટાસોર્સ) અને આપણા પોતાના બંને સાથે ક્રિયાપ્રતિક્રિયા કરી શકીએ છીએ, જેને આપણે સીધા પ્લગઇન ડિરેક્ટરીમાં સ્ટોર કરી શકીએ છીએ (dist/ડેટાસોર્સ/*) અથવા નિર્ભરતા તરીકે ઇન્સ્ટોલ કરી શકીએ છીએ. અમારા કિસ્સામાં, ડેટાસોર્સ પ્લગઇન કોડ સાથે આવે છે. 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"};
       })
}

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

આ સમસ્યાને ઉકેલવા માટે, તમે બિલ્ટ-ઇન ગ્રાફના “પ્લગઇન રૂટ્સ” મિકેનિઝમનો ઉપયોગ કરી શકો છો (વધુ વિગતો અહીં સત્તાવાર દસ્તાવેજીકરણ પૃષ્ઠ). અમારા ડેટાસોર્સની સેટિંગ્સમાં, અમે રૂટીંગ નિયમોનો સમૂહ જાહેર કરી શકીએ છીએ જેની પ્રક્રિયા ગ્રાફના પ્રોક્સી સર્વર દ્વારા કરવામાં આવશે. ઉદાહરણ તરીકે, દરેક વ્યક્તિગત એન્ડપોઇન્ટ માટે ટેમ્પ્લેટિંગની શક્યતા સાથે હેડર અથવા યુઆરએલ સેટ કરવાનું શક્ય છે, જે માટેનો ડેટા jsonData અને સુરક્ષિતJsonData ફીલ્ડ્સમાંથી લઈ શકાય છે (એન્ક્રિપ્ટેડ સ્વરૂપમાં પાસવર્ડ્સ અથવા ટોકન્સ સ્ટોર કરવા માટે). અમારા ઉદાહરણમાં, જેમ કે પ્રશ્નો /__proxy/api/v1/namespaces ફોર્મના url સાથે પ્રોક્સી કરવામાં આવશે
અધિકૃતતા સાથે /api/v8/namespaces: બેરર હેડર.

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

ભાગ 5: રિલીઝ

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

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

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

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

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

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

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

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

આભાર!)

સોર્સ: www.habr.com