ការសរសេរប្រតិបត្តិករសម្រាប់ Kubernetes នៅក្នុង Golang

ចំណាំ។ បកប្រែ៖ ប្រតិបត្តិករគឺជាកម្មវិធីជំនួយសម្រាប់ Kubernetes ដែលត្រូវបានរចនាឡើងដើម្បីធ្វើស្វ័យប្រវត្តិកម្មការប្រតិបត្តិនៃសកម្មភាពជាប្រចាំនៅលើវត្ថុចង្កោម នៅពេលដែលព្រឹត្តិការណ៍ជាក់លាក់កើតឡើង។ យើងបានសរសេររួចហើយអំពីប្រតិបត្តិករនៅក្នុង អត្ថបទនេះដែលជាកន្លែងដែលពួកគេបាននិយាយអំពីគំនិតជាមូលដ្ឋាន និងគោលការណ៍នៃការងាររបស់ពួកគេ។ ប៉ុន្តែប្រសិនបើសម្ភារៈនោះមានទស្សនៈច្រើនពីផ្នែកនៃប្រតិបត្តិការដែលត្រៀមរួចជាស្រេចសម្រាប់ Kubernetes នោះការបកប្រែអត្ថបទថ្មីដែលបានស្នើឡើងឥឡូវនេះគឺជាចក្ខុវិស័យរបស់អ្នកអភិវឌ្ឍន៍/វិស្វករ DevOps ដែលងឿងឆ្ងល់ដោយការអនុវត្តប្រតិបត្តិករថ្មី។

ខ្ញុំបានសម្រេចចិត្តសរសេរប្រកាសនេះជាមួយនឹងឧទាហរណ៍ជាក់ស្តែងមួយ បន្ទាប់ពីការព្យាយាមរបស់ខ្ញុំក្នុងការស្វែងរកឯកសារស្តីពីការបង្កើតប្រតិបត្តិករសម្រាប់ Kubernetes ដែលបានឆ្លងកាត់ការសិក្សាកូដ។

ឧទាហរណ៍ដែលនឹងត្រូវបានពិពណ៌នាគឺនេះ៖ នៅក្នុងចង្កោម Kubernetes របស់យើងនីមួយៗ Namespace តំណាងឱ្យបរិយាកាសប្រអប់ខ្សាច់របស់ក្រុម ហើយយើងចង់កំណត់ការចូលប្រើពួកវា ដូច្នេះក្រុមអាចលេងបានតែនៅក្នុងប្រអប់ខ្សាច់របស់ពួកគេប៉ុណ្ណោះ។

អ្នកអាចសម្រេចបាននូវអ្វីដែលអ្នកចង់បានដោយកំណត់ឱ្យអ្នកប្រើប្រាស់នូវក្រុមដែលមាន RoleBinding ជាក់លាក់ Namespace и ClusterRole ជាមួយនឹងសិទ្ធិកែសម្រួល។ តំណាង YAML នឹងមើលទៅដូចនេះ៖

---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: kubernetes-team-1
  namespace: team-1
subjects:
- kind: Group
  name: kubernetes-team-1
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: edit
apiGroup: rbac.authorization.k8s.io

(rolebinding.yamlនៅ ជួរដេក)

បង្កើតមួយ។ RoleBinding អ្នក​អាច​ធ្វើ​វា​ដោយ​ដៃ ប៉ុន្តែ​បន្ទាប់​ពី​ឆ្លងកាត់​សញ្ញា​ដក​ឈ្មោះ​មួយ​រយ វា​ក្លាយ​ជា​កិច្ចការ​ដ៏​ធុញទ្រាន់។ នេះគឺជាកន្លែងដែលប្រតិបត្តិករ Kubernetes ងាយស្រួល - ពួកគេអនុញ្ញាតឱ្យអ្នកបង្កើតធនធាន Kubernetes ដោយស្វ័យប្រវត្តិដោយផ្អែកលើការផ្លាស់ប្តូរធនធាន។ ក្នុងករណីរបស់យើងយើងចង់បង្កើត RoleBinding ខណៈពេលកំពុងបង្កើត Namespace.

ដំបូងយើងកំណត់មុខងារ mainដែលធ្វើការដំឡើងដែលត្រូវការដើម្បីដំណើរការសេចក្តីថ្លែងការណ៍ ហើយបន្ទាប់មកហៅសកម្មភាពសេចក្តីថ្លែងការណ៍៖

(ចំណាំ។ បកប្រែ៖ នៅទីនេះ និងខាងក្រោម មតិយោបល់នៅក្នុងកូដត្រូវបានបកប្រែជាភាសារុស្សី។ លើសពីនេះ ការចូលបន្ទាត់ត្រូវបានកែទៅដកឃ្លាជំនួសឱ្យផ្ទាំង [បានណែនាំក្នុង Go] សម្រាប់គោលបំណងនៃការអានកាន់តែល្អនៅក្នុងប្លង់ Habr ។ បន្ទាប់ពីការចុះបញ្ជីនីមួយៗ មានតំណភ្ជាប់ទៅកាន់ដើមនៅលើ GitHub ដែលមតិយោបល់ និងផ្ទាំងជាភាសាអង់គ្លេសត្រូវបានរក្សាទុក។)

func main() {
  // Устанавливаем вывод логов в консольный STDOUT
  log.SetOutput(os.Stdout)

  sigs := make(chan os.Signal, 1) // Создаем канал для получения сигналов ОС
  stop := make(chan struct{})     // Создаем канал для получения стоп-сигнала

  // Регистрируем получение SIGTERM в канале sigs
  signal.Notify(sigs, os.Interrupt, syscall.SIGTERM, syscall.SIGINT) 

  // Goroutines могут сами добавлять себя в WaitGroup,
 // чтобы завершения их выполнения дожидались
  wg := &sync.WaitGroup{} 

  runOutsideCluster := flag.Bool("run-outside-cluster", false, "Set this flag when running outside of the cluster.")
  flag.Parse()
  // Создаем clientset для взаимодействия с кластером Kubernetes
  clientset, err := newClientSet(*runOutsideCluster)

  if err != nil {
    panic(err.Error())
  }

  controller.NewNamespaceController(clientset).Run(stop, wg)

  <-sigs // Ждем сигналов (до получения сигнала более ничего не происходит)
  log.Printf("Shutting down...")

  close(stop) // Говорим goroutines остановиться
  wg.Wait()   // Ожидаем, что все остановлено
}

(main.goនៅ ជួរដេក)

យើងធ្វើដូចខាងក្រោមៈ

1. យើងកំណត់រចនាសម្ព័ន្ធឧបករណ៍ដោះស្រាយសម្រាប់សញ្ញាប្រព័ន្ធប្រតិបត្តិការជាក់លាក់ដើម្បីបង្កឱ្យមានការបញ្ចប់ប្រតិបត្តិករប្រកបដោយគុណធម៌។
2. យើង​ប្រើ WaitGroupដើម្បីបញ្ឈប់ goroutines ទាំងអស់យ៉ាងរលូន មុនពេលបញ្ចប់កម្មវិធី។
3. យើងផ្តល់សិទ្ធិចូលប្រើចង្កោមដោយបង្កើត clientset.
4. បើកដំណើរការ NamespaceControllerដែលក្នុងនោះតក្កវិជ្ជារបស់យើងទាំងអស់នឹងមានទីតាំងនៅ។

ឥឡូវនេះយើងត្រូវការមូលដ្ឋានសម្រាប់តក្កវិជ្ជាហើយក្នុងករណីរបស់យើងនេះគឺជាអ្វីដែលបានលើកឡើង NamespaceController:

// NamespaceController следит через Kubernetes API за изменениями
// в пространствах имен и создает RoleBinding для конкретного namespace.
type NamespaceController struct {
  namespaceInformer cache.SharedIndexInformer
  kclient           *kubernetes.Clientset
}

// NewNamespaceController создает новый NewNamespaceController
func NewNamespaceController(kclient *kubernetes.Clientset) *NamespaceController {
  namespaceWatcher := &NamespaceController{}

  // Создаем информер для слежения за Namespaces
  namespaceInformer := cache.NewSharedIndexInformer(
    &cache.ListWatch{
      ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
        return kclient.Core().Namespaces().List(options)
      },
      WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
        return kclient.Core().Namespaces().Watch(options)
      },
    },
    &v1.Namespace{},
    3*time.Minute,
    cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
  )

  namespaceInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
    AddFunc: namespaceWatcher.createRoleBinding,
  })

  namespaceWatcher.kclient = kclient
  namespaceWatcher.namespaceInformer = namespaceInformer

  return namespaceWatcher
}

(controller.goនៅ ជួរដេក)

នៅទីនេះយើងកំណត់រចនាសម្ព័ន្ធ SharedIndexInformerដែលនឹងមានប្រសិទ្ធិភាព (ដោយប្រើឃ្លាំងសម្ងាត់) រង់ចាំការផ្លាស់ប្តូរនៅក្នុង namespaces (អានបន្ថែមអំពីអ្នកផ្តល់ព័ត៌មាននៅក្នុងអត្ថបទ "តើកម្មវិធីកំណត់ពេល Kubernetes ពិតជាដំណើរការយ៉ាងដូចម្តេច?"- ប្រហែល ការបកប្រែ). បន្ទាប់ពីនេះយើងភ្ជាប់ EventHandler ទៅកាន់អ្នកផ្តល់ព័ត៌មាន ដូច្នេះនៅពេលបន្ថែម namespace (Namespace) មុខងារត្រូវបានគេហៅថា createRoleBinding.

ជំហានបន្ទាប់គឺកំណត់មុខងារនេះ។ createRoleBinding:

func (c *NamespaceController) createRoleBinding(obj interface{}) {
  namespaceObj := obj.(*v1.Namespace)
  namespaceName := namespaceObj.Name

  roleBinding := &v1beta1.RoleBinding{
    TypeMeta: metav1.TypeMeta{
      Kind:       "RoleBinding",
      APIVersion: "rbac.authorization.k8s.io/v1beta1",
    },
    ObjectMeta: metav1.ObjectMeta{
      Name:      fmt.Sprintf("ad-kubernetes-%s", namespaceName),
      Namespace: namespaceName,
    },
    Subjects: []v1beta1.Subject{
      v1beta1.Subject{
        Kind: "Group",
        Name: fmt.Sprintf("ad-kubernetes-%s", namespaceName),
      },
    },
    RoleRef: v1beta1.RoleRef{
      APIGroup: "rbac.authorization.k8s.io",
        Kind:     "ClusterRole",
        Name:     "edit",
    },
  }

  _, err := c.kclient.Rbac().RoleBindings(namespaceName).Create(roleBinding)

  if err != nil {
    log.Println(fmt.Sprintf("Failed to create Role Binding: %s", err.Error()))
  } else {
    log.Println(fmt.Sprintf("Created AD RoleBinding for Namespace: %s", roleBinding.Name))
  }
}

(controller.goនៅ ជួរដេក)

យើងទទួលបានចន្លោះឈ្មោះជា obj ហើយបំប្លែងវាទៅជាវត្ថុមួយ។ Namespace. បន្ទាប់មកយើងកំណត់ RoleBindingដោយផ្អែកលើឯកសារ YAML ដែលបានរៀបរាប់នៅដើម ដោយប្រើវត្ថុដែលបានផ្តល់ Namespace និងការបង្កើត RoleBinding. ជាចុងក្រោយ យើងកត់ត្រាថាតើការបង្កើតនេះបានជោគជ័យដែរឬទេ។

មុខងារចុងក្រោយដែលត្រូវកំណត់គឺ Run:

// Run запускает процесс ожидания изменений в пространствах имён
// и действия в соответствии с этими изменениями.
func (c *NamespaceController) Run(stopCh <-chan struct{}, wg *sync.WaitGroup) {
  // Когда эта функция завершена, пометим как выполненную
  defer wg.Done()

  // Инкрементируем wait group, т.к. собираемся вызвать goroutine
  wg.Add(1)

  // Вызываем goroutine
  go c.namespaceInformer.Run(stopCh)

  // Ожидаем получения стоп-сигнала
  <-stopCh
}

(controller.goនៅ ជួរដេក)

នៅទីនេះយើងកំពុងនិយាយ WaitGroupថាយើងបើកដំណើរការ goroutine ហើយបន្ទាប់មកហៅ namespaceInformerដែលត្រូវបានកំណត់ពីមុន។ នៅពេលដែលសញ្ញាឈប់មកដល់ វានឹងបញ្ចប់មុខងារ ជូនដំណឹង WaitGroupដែលមិនត្រូវបានអនុវត្តទៀតទេ ហើយមុខងារនេះនឹងចេញ។

ព័ត៌មានអំពីការកសាង និងដំណើរការសេចក្តីថ្លែងការណ៍នេះនៅលើចង្កោម Kubernetes អាចរកបាននៅក្នុង ឃ្លាំងនៅលើ GitHub.

នោះហើយជាវាសម្រាប់ប្រតិបត្តិករដែលបង្កើត RoleBinding ពេលណា​ Namespace នៅក្នុងចង្កោម Kubernetes រួចរាល់។

ប្រភព: www.habr.com