ການຂຽນຕົວປະຕິບັດການສໍາລັບ Kubernetes ໃນ Golang

ຫມາຍ​ເຫດ​. ແປ.: ຕົວປະຕິບັດການແມ່ນຊອບແວຊ່ວຍເຫຼືອສໍາລັບ Kubernetes, ອອກແບບມາເພື່ອອັດຕະໂນມັດການປະຕິບັດການດໍາເນີນການປົກກະຕິກ່ຽວກັບວັດຖຸ cluster ເມື່ອມີເຫດການສະເພາະໃດຫນຶ່ງເກີດຂຶ້ນ. ພວກເຮົາໄດ້ຂຽນແລ້ວກ່ຽວກັບຜູ້ປະກອບການໃນ ບົດຂຽນນີ້, ບ່ອນທີ່ເຂົາເຈົ້າສົນທະນາກ່ຽວກັບແນວຄວາມຄິດພື້ນຖານແລະຫຼັກການຂອງການເຮັດວຽກຂອງເຂົາເຈົ້າ. ແຕ່ຖ້າອຸປະກອນດັ່ງກ່າວເປັນມຸມເບິ່ງຫຼາຍກວ່າດ້ານຂອງອົງປະກອບທີ່ກຽມພ້ອມສໍາລັບ Kubernetes, ການແປບົດຄວາມໃຫມ່ທີ່ສະເຫນີໃນປັດຈຸບັນແມ່ນເປັນວິໄສທັດຂອງຜູ້ພັດທະນາ / ວິສະວະກອນ DevOps ທີ່ສັບສົນກັບການຈັດຕັ້ງປະຕິບັດຕົວປະຕິບັດການໃຫມ່.

ຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈຂຽນຂໍ້ຄວາມນີ້ດ້ວຍຕົວຢ່າງຊີວິດຈິງຫຼັງຈາກຄວາມພະຍາຍາມຂອງຂ້ອຍເພື່ອຊອກຫາເອກະສານກ່ຽວກັບການສ້າງຕົວປະຕິບັດການສໍາລັບ Kubernetes, ເຊິ່ງໄດ້ຜ່ານການສຶກສາລະຫັດ.

ຕົວຢ່າງທີ່ຈະຖືກອະທິບາຍນີ້ແມ່ນ: ໃນກຸ່ມ Kubernetes ຂອງພວກເຮົາ, ແຕ່ລະຄົນ Namespace ເປັນຕົວແທນຂອງສະພາບແວດລ້ອມ sandbox ຂອງທີມງານ, ແລະພວກເຮົາຕ້ອງການຈໍາກັດການເຂົ້າເຖິງໃຫ້ເຂົາເຈົ້າເພື່ອໃຫ້ທີມງານສາມາດຫຼິ້ນໃນ sandbox ຂອງເຂົາເຈົ້າເອງເທົ່ານັ້ນ.

ທ່ານສາມາດບັນລຸສິ່ງທີ່ທ່ານຕ້ອງການໂດຍການມອບຫມາຍໃຫ້ຜູ້ໃຊ້ກຸ່ມທີ່ມີ 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 ທ່ານສາມາດເຮັດໄດ້ດ້ວຍຕົນເອງ, ແຕ່ຫຼັງຈາກຂ້າມຮ້ອຍ namespaces, ມັນກາຍເປັນວຽກງານທີ່ຫນ້າເບື່ອ. ນີ້ແມ່ນບ່ອນທີ່ຜູ້ປະຕິບັດການ 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, ໃນ ວັດຖຸດິບ)

ທີ່ນີ້ພວກເຮົາ configure SharedIndexInformer, ເຊິ່ງຈະມີປະສິດທິພາບ (ໃຊ້ cache) ລໍຖ້າການປ່ຽນແປງໃນ 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, ໃນ ວັດຖຸດິບ)

ພວກເຮົາໄດ້ຮັບ namespace ເປັນ 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 ສາມາດພົບໄດ້ໃນ repositories ໃນ GitHub.

ນັ້ນແມ່ນມັນສໍາລັບຜູ້ປະກອບການທີ່ສ້າງ RoleBinding ເມື່ອ​ໃດ​ Namespace ໃນກຸ່ມ Kubernetes, ພ້ອມແລ້ວ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com