ការអភិវឌ្ឍន៍កម្មវិធីជំនួយសម្រាប់ Grafana៖ ប្រវត្តិនៃការបាញ់ប្រហារដ៏ធំ

សួស្តី​អ្នក​ទាំងអស់គ្នា! កាលពីប៉ុន្មានខែមុន យើងបានចាប់ផ្តើមគម្រោងប្រភពបើកចំហថ្មីរបស់យើងចូលទៅក្នុងផលិតកម្ម - កម្មវិធីជំនួយ Grafana សម្រាប់ការត្រួតពិនិត្យ kubernetes ដែលយើងហៅថា DevOpsProdigy KubeGraf. កូដប្រភពកម្មវិធីជំនួយមាននៅ ឃ្លាំងសាធារណៈនៅលើ GitHub. ហើយនៅក្នុងអត្ថបទនេះ យើងចង់ចែករំលែកជាមួយអ្នកនូវរឿងរ៉ាវអំពីរបៀបដែលយើងបង្កើតកម្មវិធីជំនួយ តើឧបករណ៍អ្វីខ្លះដែលយើងបានប្រើ និងអ្វីដែលយើងជួបប្រទះក្នុងដំណើរការអភិវឌ្ឍន៍។ តោះ​ទៅ!

ផ្នែកទី 0 - ការណែនាំ៖ តើយើងឈានដល់ចំណុចនេះដោយរបៀបណា?

គំនិតក្នុងការសរសេរកម្មវិធីជំនួយផ្ទាល់ខ្លួនរបស់យើងសម្រាប់ Grafan បានមករកយើងដោយចៃដន្យ។ ក្រុមហ៊ុនរបស់យើងបាននឹងកំពុងតាមដានគម្រោងបណ្តាញនៃកម្រិតផ្សេងៗនៃភាពស្មុគស្មាញអស់រយៈពេលជាង 10 ឆ្នាំមកហើយ។ ក្នុងអំឡុងពេលនេះ យើងបានប្រមូលផ្តុំនូវជំនាញជាច្រើន ករណីគួរឱ្យចាប់អារម្មណ៍ និងបទពិសោធន៍ក្នុងការប្រើប្រាស់ប្រព័ន្ធត្រួតពិនិត្យផ្សេងៗ។ ហើយនៅចំណុចខ្លះ យើងបានសួរខ្លួនយើងថា "តើមានឧបករណ៍វេទមន្តសម្រាប់ត្រួតពិនិត្យ Kubernetes ដូច្នេះដូចដែលពួកគេនិយាយថា "កំណត់វាហើយបំភ្លេចវា"? ការរួមបញ្ចូលគ្នានៃ Prometheus + Grafana ។ ហើយជាដំណោះស្រាយដែលត្រៀមរួចជាស្រេចសម្រាប់ជង់នេះ មានឧបករណ៍ជាច្រើនប្រភេទដូចជា៖ prometheus-operator, សំណុំនៃផ្ទាំងគ្រប់គ្រង kubernetes-mixin, grafana-kubernetes-app ។

កម្មវិធីជំនួយកម្មវិធី grafana-kubernetes ហាក់ដូចជាជម្រើសគួរឱ្យចាប់អារម្មណ៍បំផុតសម្រាប់យើង ប៉ុន្តែវាមិនត្រូវបានគាំទ្រអស់រយៈពេលជាងមួយឆ្នាំ ហើយលើសពីនេះទៅទៀត មិនអាចដំណើរការជាមួយកំណែថ្មីនៃ node-exporter និង kube-state-metrics បានទេ។ ហើយនៅចំណុចខ្លះយើងបានសម្រេចចិត្តថា: "តើយើងគួរធ្វើការសម្រេចចិត្តដោយខ្លួនឯងទេ?"

តើគំនិតអ្វីខ្លះដែលយើងសម្រេចចិត្តអនុវត្តនៅក្នុងកម្មវិធីជំនួយរបស់យើង៖

• ការមើលឃើញនៃ "ផែនទីកម្មវិធី"៖ ការបង្ហាញដ៏ងាយស្រួលនៃកម្មវិធីនៅក្នុងចង្កោម បានដាក់ជាក្រុមដោយ namespaces ការដាក់ពង្រាយ ... ;
• ការមើលឃើញនៃការតភ្ជាប់ដូចជា "ការដាក់ពង្រាយ - សេវាកម្ម (+ ច្រក)" ។
• ការមើលឃើញនៃការចែកចាយកម្មវិធីចង្កោមនៅទូទាំងថ្នាំងចង្កោម។
• ការប្រមូលម៉ែត្រ និងព័ត៌មានពីប្រភពជាច្រើន៖ Prometheus និង k8s api server។
• ការត្រួតពិនិត្យទាំងផ្នែកហេដ្ឋារចនាសម្ព័ន្ធ (ការប្រើប្រាស់ពេលវេលាស៊ីភីយូ អង្គចងចាំ ប្រព័ន្ធរងថាស បណ្តាញ) និងតក្កវិជ្ជាកម្មវិធី - ផតនៃស្ថានភាពសុខភាព ចំនួននៃការចម្លងដែលអាចរកបាន ព័ត៌មានអំពីការឆ្លងកាត់ការធ្វើតេស្តភាពរស់រវើក/ការត្រៀមខ្លួន។

ផ្នែកទី 1: តើអ្វីទៅជា "កម្មវិធីជំនួយ Grafana"?

តាមទស្សនៈបច្ចេកទេស កម្មវិធីជំនួយសម្រាប់ Grafana គឺជាឧបករណ៍បញ្ជាមុំ ដែលត្រូវបានរក្សាទុកនៅក្នុងថតទិន្នន័យ Grafana (/var/grafana/plugins/ /dist/module.js) ហើយអាចផ្ទុកជាម៉ូឌុល SystemJS ។ ដូចគ្នានេះផងដែរនៅក្នុងថតនេះគួរតែមានឯកសារ plugin.json ដែលមានព័ត៌មានមេតាទាំងអស់អំពីកម្មវិធីជំនួយរបស់អ្នក៖ ឈ្មោះ កំណែ ប្រភេទកម្មវិធីជំនួយ តំណភ្ជាប់ទៅកាន់ឃ្លាំង/គេហទំព័រ/អាជ្ញាប័ណ្ណ ភាពអាស្រ័យ និងអ្វីៗផ្សេងទៀត។

module.ts

plugin.json

ដូចដែលអ្នកអាចឃើញនៅក្នុងរូបថតអេក្រង់ យើងបានបញ្ជាក់ plugin.type = app ។ ដោយសារតែកម្មវិធីជំនួយសម្រាប់ Grafana អាចមានបីប្រភេទ៖

បន្ទះ៖ ប្រភេទកម្មវិធីជំនួយទូទៅបំផុត - វាជាបន្ទះសម្រាប់មើលឃើញម៉ែត្រណាមួយ ដែលប្រើសម្រាប់បង្កើតផ្ទាំងគ្រប់គ្រងផ្សេងៗ។
ប្រភពទិន្នន័យ៖ កម្មវិធីភ្ជាប់កម្មវិធីជំនួយទៅកាន់ប្រភពទិន្នន័យមួយចំនួន (ឧទាហរណ៍ Prometheus-datasource, ClickHouse-datasource, ElasticSearch-datasource)។
កម្មវិធី៖ កម្មវិធីជំនួយដែលអនុញ្ញាតឱ្យអ្នកបង្កើតកម្មវិធីផ្នែកខាងមុខផ្ទាល់ខ្លួនរបស់អ្នកនៅខាងក្នុង Grafana បង្កើតទំព័រ html ផ្ទាល់ខ្លួនរបស់អ្នក និងចូលប្រើប្រភពទិន្នន័យដោយដៃដើម្បីមើលទិន្នន័យផ្សេងៗ។ ដូចគ្នានេះផងដែរ កម្មវិធីជំនួយនៃប្រភេទផ្សេងទៀត (ប្រភពទិន្នន័យ បន្ទះ) និងផ្ទាំងគ្រប់គ្រងផ្សេងៗអាចត្រូវបានប្រើជាភាពអាស្រ័យ។

ឧទាហរណ៍ភាពអាស្រ័យនៃកម្មវិធីជំនួយជាមួយ type=app.

អ្នកអាចប្រើទាំង JavaScript និង TypeScript ជាភាសាសរសេរកម្មវិធី (យើងបានជ្រើសរើសវា)។ ការរៀបចំសម្រាប់កម្មវិធីជំនួយ hello-world គ្រប់ប្រភេទដែលអ្នកអាចធ្វើបាន ស្វែងរកតំណ៖ ឃ្លាំងនេះផ្ទុកនូវ starter-packs មួយចំនួនធំ (មានសូម្បីតែឧទាហរណ៍សាកល្បងនៃកម្មវិធីជំនួយនៅក្នុង React) ជាមួយអ្នកសាងសង់ដែលបានដំឡើង និងកំណត់រចនាសម្ព័ន្ធជាមុន។

ផ្នែកទី 2: ការរៀបចំបរិស្ថានក្នុងតំបន់

ដើម្បីធ្វើការលើកម្មវិធីជំនួយ យើងត្រូវការចង្កោម kubernetes ដោយធម្មជាតិជាមួយនឹងឧបករណ៍ដែលបានដំឡើងជាមុនទាំងអស់៖ prometheus, node-exporter, kube-state-metrics, grafana។ បរិស្ថានគួរតែត្រូវបានរៀបចំយ៉ាងរហ័ស ងាយស្រួល និងមានលក្ខណៈធម្មជាតិ ហើយដើម្បីធានាបាននូវការផ្ទុកឡើងវិញ ថតទិន្នន័យ Grafana គួរតែត្រូវបានតំឡើងដោយផ្ទាល់ពីម៉ាស៊ីនរបស់អ្នកអភិវឌ្ឍន៍។

មធ្យោបាយងាយស្រួលបំផុត តាមគំនិតរបស់យើង ដើម្បីធ្វើការក្នុងស្រុកជាមួយ kubernetes គឺ មីនីគុប. ជំហានបន្ទាប់គឺត្រូវដំឡើងបន្សំ Prometheus + Grafana ដោយប្រើ prometheus-operator ។ IN អត្ថបទ​នេះ ដំណើរការនៃការដំឡើង prometheus-operator នៅលើ minikube ត្រូវបានពិពណ៌នាលម្អិត។ ដើម្បីបើកដំណើរការជាប់លាប់ អ្នកត្រូវតែកំណត់ប៉ារ៉ាម៉ែត្រ ការតស៊ូ៖ ពិត នៅក្នុងឯកសារ charts/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, service, node, namespace។ ថ្នាក់នីមួយៗទាំងនេះទទួលមរតកពីថ្នាក់ BaseModel ទូទៅ ដែលពណ៌នាអំពី constructor, destructor, method សម្រាប់អាប់ដេត និងប្តូរភាពមើលឃើញ។ ថ្នាក់នីមួយៗពិពណ៌នាអំពីទំនាក់ទំនងដែលបានដាក់ជាមួយអង្គភាពផ្សេងទៀត ឧទាហរណ៍ បញ្ជីនៃផតឃែរសម្រាប់អង្គភាពនៃការដាក់ពង្រាយប្រភេទ។

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 របស់យើងនៅក្នុងផ្នែកភាពអាស្រ័យ៖

នៅក្នុងប្លុកសម្រាប់ទំព័រនីមួយៗ យើងត្រូវចង្អុលបង្ហាញ PAGE NAME (បន្ទាប់មកវានឹងត្រូវបានបំប្លែងទៅជា slug ដែលទំព័រនេះអាចចូលប្រើបាន); ឈ្មោះនៃសមាសភាគដែលទទួលខុសត្រូវសម្រាប់ប្រតិបត្តិការនៃទំព័រនេះ (បញ្ជីនៃសមាសភាគត្រូវបាននាំចេញទៅ module.ts); ការបង្ហាញពីតួនាទីរបស់អ្នកប្រើដែលធ្វើការជាមួយទំព័រនេះអាចរកបាន និងការកំណត់រុករកសម្រាប់របារចំហៀង។

នៅក្នុងសមាសភាគដែលទទួលខុសត្រូវចំពោះប្រតិបត្តិការនៃទំព័រ យើងត្រូវកំណត់ templateUrl ដោយឆ្លងកាត់ទីនោះផ្លូវទៅកាន់ឯកសារ html ជាមួយការសម្គាល់។ នៅខាងក្នុងឧបករណ៍បញ្ជា តាមរយៈការចាក់ដោយភាពអាស្រ័យ យើងអាចចូលប្រើសេវាកម្មមុំសំខាន់ៗចំនួន 2៖

• backendSrv - សេវាកម្មដែលផ្តល់អន្តរកម្មជាមួយម៉ាស៊ីនមេ Grafana API;
• datasourceSrv - សេវាកម្មដែលផ្តល់អន្តរកម្មក្នុងតំបន់ជាមួយប្រភពទិន្នន័យទាំងអស់ដែលបានដំឡើងនៅក្នុង Grafana របស់អ្នក (ឧទាហរណ៍ វិធីសាស្ត្រ .getAll() - ត្រឡប់បញ្ជីនៃប្រភពទិន្នន័យដែលបានដំឡើងទាំងអស់; .get( ) - ត្រឡប់វត្ថុវត្ថុនៃប្រភពទិន្នន័យជាក់លាក់មួយ។

ផ្នែកទី 4៖ ប្រភពទិន្នន័យ

តាមទស្សនៈរបស់ Grafana ប្រភពទិន្នន័យគឺដូចគ្នាបេះបិទនឹងកម្មវិធីជំនួយផ្សេងទៀត៖ វាមានចំណុចចូលរបស់វាផ្ទាល់ module.js មានឯកសារដែលមានព័ត៌មានមេតា ​​plugin.json ។ នៅពេលបង្កើតកម្មវិធីជំនួយជាមួយ type=app យើងអាចធ្វើអន្តរកម្មជាមួយប្រភពទិន្នន័យដែលមានស្រាប់ (ឧទាហរណ៍ prometheus-datasource) និងរបស់យើងផ្ទាល់ ដែលយើងអាចរក្សាទុកដោយផ្ទាល់នៅក្នុងបញ្ជីកម្មវិធីជំនួយ (dist/datasource/*) ឬដំឡើងជាការពឹងផ្អែក។ ក្នុងករណីរបស់យើង ប្រភពទិន្នន័យភ្ជាប់មកជាមួយកូដកម្មវិធីជំនួយ។ វាក៏ចាំបាច់ផងដែរដើម្បីឱ្យមានគំរូ config.html និងឧបករណ៍បញ្ជា ConfigCtrl ដែលនឹងត្រូវបានប្រើសម្រាប់ទំព័រកំណត់រចនាសម្ព័ន្ធឧទាហរណ៍ប្រភពទិន្នន័យ និងឧបករណ៍បញ្ជាប្រភពទិន្នន័យ ដែលអនុវត្តតក្កវិជ្ជានៃប្រភពទិន្នន័យរបស់អ្នក។

នៅក្នុងកម្មវិធីជំនួយ KubeGraf ពីចំណុចប្រទាក់អ្នកប្រើនៃទិដ្ឋភាព ប្រភពទិន្នន័យគឺជាឧទាហរណ៍នៃក្រុម kubernetes ដែលអនុវត្តសមត្ថភាពដូចខាងក្រោម (កូដប្រភពមាន តំណភ្ជាប់):

• ការប្រមូលទិន្នន័យពី k8s api-server (ទទួលបានបញ្ជីឈ្មោះ ការដាក់ពង្រាយ...)
• សំណើប្រូកស៊ីទៅ prometheus-datasource (ដែលត្រូវបានជ្រើសរើសនៅក្នុងការកំណត់កម្មវិធីជំនួយសម្រាប់ចង្កោមជាក់លាក់នីមួយៗ) និងការធ្វើទ្រង់ទ្រាយការឆ្លើយតបដើម្បីប្រើទិន្នន័យទាំងនៅក្នុងទំព័រឋិតិវន្ត និងនៅក្នុងផ្ទាំងគ្រប់គ្រង។
• ការធ្វើបច្ចុប្បន្នភាពទិន្នន័យនៅលើទំព័រកម្មវិធីជំនួយឋិតិវន្ត (ជាមួយនឹងការកំណត់អត្រាធ្វើឱ្យស្រស់)។
• ដំណើរការសំណួរដើម្បីបង្កើតសន្លឹកគំរូនៅក្នុង grafana-dashboards (metriFindQuery() method)

• ការធ្វើតេស្តការតភ្ជាប់ជាមួយចង្កោម 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"};
       })
}

ចំណុចគួរឱ្យចាប់អារម្មណ៍ដាច់ដោយឡែកមួយ តាមគំនិតរបស់យើងគឺការអនុវត្តយន្តការផ្ទៀងផ្ទាត់ និងការអនុញ្ញាតសម្រាប់ប្រភពទិន្នន័យ។ ជាធម្មតា ចេញពីប្រអប់ យើងអាចប្រើ datasourceHttpSettings ដែលមានភ្ជាប់មកជាមួយ Grafana ដើម្បីកំណត់រចនាសម្ព័ន្ធការចូលប្រើប្រភពទិន្នន័យចុងក្រោយ។ ដោយប្រើសមាសភាគនេះ យើងអាចកំណត់រចនាសម្ព័ន្ធការចូលប្រើប្រភពទិន្នន័យ http ដោយបញ្ជាក់ url និងការកំណត់ការផ្ទៀងផ្ទាត់/ការអនុញ្ញាតជាមូលដ្ឋាន៖ login-password ឬ client-cert/client-key។ ដើម្បីអនុវត្តសមត្ថភាពក្នុងការកំណត់រចនាសម្ព័ន្ធការចូលប្រើដោយប្រើសញ្ញាសម្គាល់អ្នកកាន់ (ស្តង់ដារជាក់ស្តែងសម្រាប់ k8s) យើងត្រូវធ្វើការកែប្រែបន្តិច។

ដើម្បីដោះស្រាយបញ្ហានេះ អ្នកអាចប្រើយន្តការ Grafana “Plugin Routes” ដែលមានស្រាប់ (ព័ត៌មានលម្អិតបន្ថែមនៅ ទំព័រឯកសារផ្លូវការ) នៅក្នុងការកំណត់នៃប្រភពទិន្នន័យរបស់យើង យើងអាចប្រកាសអំពីសំណុំនៃច្បាប់នាំផ្លូវដែលនឹងត្រូវបានដំណើរការដោយម៉ាស៊ីនមេប្រូកស៊ី grafana ។ ឧទាហរណ៍ សម្រាប់ចំណុចបញ្ចប់នីមួយៗ គេអាចកំណត់បឋមកថា ឬ urls ជាមួយនឹងលទ្ធភាពនៃទម្រង់គំរូ ទិន្នន័យដែលអាចយកចេញពីវាល jsonData និង secureJsonData (សម្រាប់រក្សាទុកពាក្យសម្ងាត់ ឬសញ្ញាសម្ងាត់ក្នុងទម្រង់ដែលបានអ៊ិនគ្រីប)។ ក្នុងឧទាហរណ៍របស់យើងសំណួរដូចជា /__proxy/api/v1/namespaces នឹងត្រូវបានប្រូកស៊ីទៅ url នៃទម្រង់
/api/v8/namespaces ជាមួយនឹងការអនុញ្ញាត៖ បឋមកថា Bearer ។

ជាធម្មជាតិ ដើម្បីធ្វើការជាមួយម៉ាស៊ីនមេ k8s api យើងត្រូវការអ្នកប្រើប្រាស់ដែលមានសិទ្ធិចូលប្រើបានតែអាន បង្ហាញសម្រាប់ការបង្កើតដែលអ្នកក៏អាចស្វែងរកបាននៅក្នុង កូដប្រភពកម្មវិធីជំនួយ.

ផ្នែកទី 5: ការចេញផ្សាយ

នៅពេលដែលអ្នកបានសរសេរកម្មវិធីជំនួយ Grafana ផ្ទាល់ខ្លួនរបស់អ្នក អ្នកនឹងចង់ធ្វើឱ្យវាអាចប្រើបានជាសាធារណៈ។ នៅក្នុង Grafana នេះគឺជាបណ្ណាល័យនៃកម្មវិធីជំនួយដែលមាននៅទីនេះ grafana.com/grafana/plugins

ដើម្បីឱ្យកម្មវិធីជំនួយរបស់អ្នកមាននៅលើហាងផ្លូវការ អ្នកត្រូវបង្កើត PR ចូល ឃ្លាំងនេះ។ដោយបន្ថែមមាតិកាដូចនេះទៅឯកសារ repo.json៖

ដែលកំណែគឺជាកំណែនៃកម្មវិធីជំនួយរបស់អ្នក url គឺជាតំណភ្ជាប់ទៅកាន់ឃ្លាំង ហើយ commit គឺជា hash នៃ commit ដែលកំណែជាក់លាក់នៃកម្មវិធីជំនួយនឹងមាន។

ហើយនៅលទ្ធផលអ្នកនឹងឃើញរូបភាពដ៏អស្ចារ្យដូចជា៖

ទិន្នន័យសម្រាប់វានឹងត្រូវបានចាប់យកដោយស្វ័យប្រវត្តិពី Readme.md, Changelog.md និងឯកសារ plugin.json របស់អ្នកជាមួយនឹងការពិពណ៌នាកម្មវិធីជំនួយ។

ផ្នែកទី 6: ជំនួសឱ្យការសន្និដ្ឋាន

យើង​មិន​បាន​បញ្ឈប់​ការ​អភិវឌ្ឍ​កម្មវិធី​ជំនួយ​របស់​យើង​បន្ទាប់​ពី​ការ​ចេញ​ផ្សាយ។ ហើយឥឡូវនេះ យើងកំពុងធ្វើការលើការត្រួតពិនិត្យយ៉ាងត្រឹមត្រូវនូវការប្រើប្រាស់ធនធានរបស់ថ្នាំងចង្កោម ដោយណែនាំមុខងារថ្មីៗដើម្បីកែលម្អ UX ហើយថែមទាំងទទួលបានមតិកែលម្អជាច្រើនដែលទទួលបានបន្ទាប់ពីដំឡើងកម្មវិធីជំនួយទាំងដោយអតិថិជនរបស់យើង និងពីមនុស្សនៅលើ GitHub (ប្រសិនបើអ្នកចាកចេញ បញ្ហាឬសំណើររបស់អ្នក ខ្ញុំនឹងសប្បាយចិត្តខ្លាំងណាស់ :)

យើងសង្ឃឹមថាអត្ថបទនេះនឹងជួយអ្នកឱ្យយល់ពីឧបករណ៍ដ៏អស្ចារ្យដូចជា Grafana ហើយប្រហែលជាសរសេរកម្មវិធីជំនួយផ្ទាល់ខ្លួនរបស់អ្នក។

សូមអរគុណ!)

ប្រភព: www.habr.com