🥇We are writing an operator for Kubernetes on Golang

Cathetan. nerjemahake.: Operator minangka piranti lunak tambahan kanggo Kubernetes, dirancang kanggo ngotomatisasi eksekusi tumindak rutin ing obyek kluster nalika kedadeyan tartamtu. Kita wis nulis babagan operator ing artikel iki, ing ngendi dheweke ngomong babagan gagasan lan prinsip dhasar karyane. Nanging yen materi kasebut luwih katon saka sisih ngoperasikake komponen sing wis siap kanggo Kubernetes, mula terjemahan artikel anyar sing saiki diusulake wis dadi visi pangembang / insinyur DevOps sing bingung karo implementasine operator anyar.

Aku mutusake kanggo nulis kiriman iki kanthi conto nyata sawise nyoba golek dokumentasi babagan nggawe operator kanggo Kubernetes, sing sinau kode kasebut.

Conto sing bakal diterangake yaiku: ing kluster Kubernetes, saben Namespace makili lingkungan kothak wedhi tim, lan kita wanted kanggo matesi akses kanggo wong-wong mau supaya tim mung bisa muter ing kothak wedhi dhewe.

Sampeyan bisa entuk apa sing dikarepake kanthi menehi pangguna klompok sing duwe RoleBinding kanggo tartamtu Namespace и ClusterRole karo hak editing. Perwakilan YAML bakal katon kaya iki:

---
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.yamling mentah)

Nggawe siji RoleBinding Sampeyan bisa nindakake kanthi manual, nanging sawise nyabrang tandha atus spasi jeneng, dadi tugas sing mboseni. Iki ngendi operator Kubernetes migunani-sing ngidini sampeyan ngotomatisasi nggawe sumber daya Kubernetes adhedhasar owah-owahan sumber daya. Ing kasus kita pengin nggawe RoleBinding nalika nggawe Namespace.

Kaping pisanan, ayo nemtokake fungsi kasebut mainsing nindakake persiyapan sing dibutuhake kanggo mbukak statement banjur nelpon tumindak statement:

(Cathetan. nerjemahake.: kene lan ngisor komentar ing kode diterjemahake menyang Rusian. Kajaba iku, indentasi wis didandani menyang spasi tinimbang tab [disaranake ing Go] mung kanggo tujuan supaya luwih gampang diwaca ing tata letak Habr. Sawise saben dhaptar ana pranala menyang asli ing GitHub, ing ngendi komentar lan tab ing basa Inggris disimpen.)

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()   // Ожидаем, что все остановлено
}

(utama.going mentah)

Kita nindakake ing ngisor iki:

Kita ngatur handler kanggo sinyal sistem operasi tartamtu kanggo nimbulaké mandap anggun saka operator.
Kita nggunakake WaitGroupkanggo mungkasi kabeh goroutine kanthi apik sadurunge mungkasi aplikasi kasebut.
We nyedhiyani akses kanggo kluster dening nggawe clientset.
Bukak NamespaceController, ing ngendi kabeh logika kita bakal ana.

Saiki kita butuh basis kanggo logika, lan ing kasus kita iki sing kasebut 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
}

(pengontrol.going mentah)

Kene kita ngatur SharedIndexInformer, sing bakal kanthi efektif (nggunakake cache) ngenteni owah-owahan ing ruang jeneng (waca liyane babagan informan ing artikel "Kepiye cara kerja panjadwal Kubernetes?"- kira-kira. ngartekne). Sawise iki kita nyambung EventHandler marang informan, supaya nalika nambah spasi jeneng (Namespace) diarani fungsi createRoleBinding.

Langkah sabanjure kanggo nemtokake fungsi iki 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))
  }
}

(pengontrol.going mentah)

We njaluk namespace minangka obj lan ngowahi dadi obyek Namespace. Banjur kita nemtokake RoleBinding, adhedhasar file YAML sing kasebut ing wiwitan, nggunakake obyek sing kasedhiya Namespace lan nggawe RoleBinding. Pungkasan, kita log apa nggawe sukses.

Fungsi pungkasan sing ditetepake yaiku 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
}

(pengontrol.going mentah)

Kene kita ngomong WaitGroupsing kita miwiti goroutine banjur nelpon namespaceInformer, sing wis ditetepake sadurunge. Nalika sinyal mandeg teka, bakal mungkasi fungsi, ngandhani WaitGroup, sing ora dieksekusi maneh, lan fungsi iki bakal metu.

Informasi babagan mbangun lan nglakokake statement iki ing kluster Kubernetes bisa ditemokake ing repositori ing GitHub.

Iku kanggo operator sing nggawe RoleBinding nalika Namespace ing kluster Kubernetes, siap.

Source: www.habr.com

Nulis operator kanggo Kubernetes ing Golang

Add a comment Отменить ответ