ਗੋਲੰਗ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਲਈ ਇੱਕ ਆਪਰੇਟਰ ਲਿਖਣਾ

ਨੋਟ ਕਰੋ। ਅਨੁਵਾਦ: ਆਪਰੇਟਰ ਕੁਬਰਨੇਟਸ ਲਈ ਸਹਾਇਕ ਸਾਫਟਵੇਅਰ ਹਨ, ਜੋ ਕਿ ਕੁਝ ਘਟਨਾਵਾਂ ਵਾਪਰਨ 'ਤੇ ਕਲੱਸਟਰ ਵਸਤੂਆਂ 'ਤੇ ਰੁਟੀਨ ਕਾਰਵਾਈਆਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਵਿਚ ਆਪਰੇਟਰਾਂ ਬਾਰੇ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਲਿਖਿਆ ਹੈ ਇਸ ਲੇਖ, ਜਿੱਥੇ ਉਨ੍ਹਾਂ ਨੇ ਆਪਣੇ ਕੰਮ ਦੇ ਬੁਨਿਆਦੀ ਵਿਚਾਰਾਂ ਅਤੇ ਸਿਧਾਂਤਾਂ ਬਾਰੇ ਗੱਲ ਕੀਤੀ। ਪਰ ਜੇਕਰ ਉਹ ਸਮੱਗਰੀ ਕੁਬਰਨੇਟਸ ਲਈ ਤਿਆਰ-ਕੀਤੇ ਭਾਗਾਂ ਦੇ ਸੰਚਾਲਨ ਦੇ ਪੱਖ ਤੋਂ ਵਧੇਰੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਸੀ, ਤਾਂ ਹੁਣ ਪ੍ਰਸਤਾਵਿਤ ਨਵੇਂ ਲੇਖ ਦਾ ਅਨੁਵਾਦ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਨਵੇਂ ਆਪਰੇਟਰ ਦੇ ਲਾਗੂ ਕਰਨ ਦੁਆਰਾ ਉਲਝੇ ਹੋਏ ਇੱਕ ਡਿਵੈਲਪਰ/DevOps ਇੰਜੀਨੀਅਰ ਦਾ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਹੈ।

ਮੈਂ ਕੁਬਰਨੇਟਸ ਲਈ ਇੱਕ ਓਪਰੇਟਰ ਬਣਾਉਣ ਬਾਰੇ ਦਸਤਾਵੇਜ਼ ਲੱਭਣ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਤੋਂ ਬਾਅਦ ਇੱਕ ਅਸਲ-ਜੀਵਨ ਦੀ ਉਦਾਹਰਣ ਦੇ ਨਾਲ ਇਸ ਪੋਸਟ ਨੂੰ ਲਿਖਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਜੋ ਕੋਡ ਦਾ ਅਧਿਐਨ ਕਰਨ ਵਿੱਚ ਗਿਆ ਸੀ।

ਜਿਸ ਉਦਾਹਰਨ ਦਾ ਵਰਣਨ ਕੀਤਾ ਜਾਵੇਗਾ ਉਹ ਇਹ ਹੈ: ਸਾਡੇ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਵਿੱਚ, ਹਰੇਕ 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 ਤੁਸੀਂ ਇਸਨੂੰ ਹੱਥੀਂ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਸੌ ਨਾਮ-ਸਥਾਨਾਂ ਦੇ ਨਿਸ਼ਾਨ ਨੂੰ ਪਾਰ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇਹ ਇੱਕ ਔਖਾ ਕੰਮ ਬਣ ਜਾਂਦਾ ਹੈ. ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਕੁਬਰਨੇਟਸ ਓਪਰੇਟਰ ਕੰਮ ਆਉਂਦੇ ਹਨ—ਉਹ ਤੁਹਾਨੂੰ ਸਰੋਤਾਂ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦੇ ਅਧਾਰ 'ਤੇ ਕੁਬਰਨੇਟਸ ਸਰੋਤਾਂ ਦੀ ਰਚਨਾ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਅਸੀਂ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ RoleBinding ਬਣਾਉਣ ਵੇਲੇ Namespace.

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ mainਜੋ ਸਟੇਟਮੈਂਟ ਨੂੰ ਚਲਾਉਣ ਲਈ ਲੋੜੀਂਦਾ ਸੈੱਟਅੱਪ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਸਟੇਟਮੈਂਟ ਐਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ:

(ਨੋਟ ਕਰੋ। ਅਨੁਵਾਦ: ਇੱਥੇ ਅਤੇ ਹੇਠਾਂ ਕੋਡ ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਦਾ ਰੂਸੀ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਿਰਫ਼ ਹੈਬਰ ਲੇਆਉਟ ਦੇ ਅੰਦਰ ਬਿਹਤਰ ਪੜ੍ਹਨਯੋਗਤਾ ਦੇ ਉਦੇਸ਼ ਲਈ [ਗੋ ਵਿੱਚ ਸਿਫ਼ਾਰਿਸ਼ ਕੀਤੀ] ਟੈਬਾਂ ਦੀ ਬਜਾਏ ਇੰਡੈਂਟੇਸ਼ਨ ਨੂੰ ਸਪੇਸ ਵਿੱਚ ਠੀਕ ਕੀਤਾ ਗਿਆ ਹੈ। ਹਰੇਕ ਸੂਚੀ ਦੇ ਬਾਅਦ 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ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਬੰਦ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਾਰੀਆਂ ਗੋਰਟਾਈਨਾਂ ਨੂੰ ਸ਼ਾਨਦਾਰ ਤਰੀਕੇ ਨਾਲ ਬੰਦ ਕਰਨ ਲਈ।
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, ਜੋ ਅਸਰਦਾਰ ਢੰਗ ਨਾਲ (ਇੱਕ ਕੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਕੇ) ਨੇਮਸਪੇਸ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦੀ ਉਡੀਕ ਕਰੇਗਾ (ਲੇਖ ਵਿੱਚ ਮੁਖਬਰਾਂ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹੋ "ਕੁਬਰਨੇਟਸ ਸ਼ਡਿਊਲਰ ਅਸਲ ਵਿੱਚ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?"- ਲਗਭਗ ਅਨੁਵਾਦ). ਇਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਜੁੜਦੇ ਹਾਂ EventHandler ਸੂਚਨਾ ਦੇਣ ਵਾਲੇ ਨੂੰ, ਤਾਂ ਜੋ ਇੱਕ ਨੇਮਸਪੇਸ ਜੋੜਨ ਵੇਲੇ (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ਕਿ ਅਸੀਂ ਗੋਰੂਟੀਨ ਲਾਂਚ ਕਰਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਕਾਲ ਕਰਦੇ ਹਾਂ namespaceInformer, ਜਿਸ ਨੂੰ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਸਟਾਪ ਸਿਗਨਲ ਆਉਂਦਾ ਹੈ, ਇਹ ਫੰਕਸ਼ਨ ਨੂੰ ਖਤਮ ਕਰ ਦੇਵੇਗਾ, ਸੂਚਿਤ ਕਰੋ WaitGroup, ਜੋ ਹੁਣ ਐਗਜ਼ੀਕਿਊਟ ਨਹੀਂ ਹੈ, ਅਤੇ ਇਹ ਫੰਕਸ਼ਨ ਬੰਦ ਹੋ ਜਾਵੇਗਾ।

ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ 'ਤੇ ਇਸ ਸਟੇਟਮੈਂਟ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਚਲਾਉਣ ਬਾਰੇ ਜਾਣਕਾਰੀ ਇਸ ਵਿੱਚ ਪਾਈ ਜਾ ਸਕਦੀ ਹੈ GitHub 'ਤੇ ਰਿਪੋਜ਼ਟਰੀਆਂ.

ਇਹ ਉਸ ਆਪਰੇਟਰ ਲਈ ਹੈ ਜੋ ਬਣਾਉਂਦਾ ਹੈ RoleBinding ਜਦੋਂ Namespace ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਵਿੱਚ, ਤਿਆਰ।

ਸਰੋਤ: www.habr.com