Pišemo operatora za Kubernetes na Golangu

Napomena prev.: Operateri – to su pomoćni programi za Kubernetes, koji služe za automatizaciju izvršavanja rutinskih zadataka nad objektima klastera prilikom određenih događaja. Već smo pisali o operatorima u ovoj članku, gde smo govorili o osnovnim idejama i principima njihovog rada. Dok je taj materijal bio više pogled sa strane eksploatacije gotovih komponenti za Kubernetes, sadašnji prevod novog članka predstavlja viđenje programera/DevOps inženjera, koji se suočava s realizacijom novog operatora.

Pišemo operatora za Kubernetes na Golangu

Ovaj post s primerom iz stvarnog života odlučio sam napisati nakon svojih pokušaja da pronađu dokumentaciju za kreiranje operatora za Kubernetes, koja je prošla kroz proučavanje koda.

Primer koji će biti opisano je sledeći: u našem Kubernetes klasteru svaka Namespace predstavlja sandbox okruženje neke ekipe, i želeli smo da ograničimo pristup njima tako da timovi mogu da igraju samo u svojim sandbox-ima.

Da bismo postigli željeno, možemo dodeliti korisniku grupu koja ima RoleBinding pravo na uređivanje za Namespace i ClusterRole . YAML predstavljanje će izgledati ovako:

---
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, u raw)

Ovakve RoleBinding može se kreirati i ručno, ali nakon prelaska oznake od stotinu prostora imena to postaje iscrpljujući zadatak. Upravo ovde pomažu Kubernetes operatori – oni omogućavaju automatizaciju kreiranja Kubernetes resursa, oslanjajući se na promene u resursima. U našem slučaju želimo da kreiramo RoleBinding prilikom kreiranja Namespace.

Prvo ćemo definisati funkciju main, koja vrši potrebna podešavanja za pokretanje operatora i zatim poziva radnju operatora:

(Napomena prev.: ovde i dalje su komentari u kodu prevedeni na srpski jezik. Pored toga, uvlačenja su ispravljena na razmake umesto [preporučenih u Go] tabova isključivo radi bolje čitljivosti u okviru dizajna Habra. Nakon svake liste nalaze se linkovi na izvor na GitHub-u, gde su očuvani komentari na engleskom jeziku i tabovi.)

func main() {
  // Postavljamo izlaz logova u konzolni STDOUT
  log.SetOutput(os.Stdout)

  sigs := make(chan os.Signal, 1) // Kreiramo kanal za primanje OS signala
  stop := make(chan struct{})     // Kreiramo kanal za primanje stop signala

  // Registrujemo primanje SIGTERM u kanalu sigs
  signal.Notify(sigs, os.Interrupt, syscall.SIGTERM, syscall.SIGINT) 

  // Goroutines mogu sami dodavati sebe u WaitGroup,
  // kako bi se čekalo da završe
  wg := &sync.WaitGroup{} 

  runOutsideCluster := flag.Bool("run-outside-cluster", false, "Postavite ovu oznaku kada se radi van klastera.")
  flag.Parse()
  // Kreiramo clientset za interakciju sa Kubernetes klasterom
  clientset, err := newClientSet(*runOutsideCluster)

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

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

  <-sigs // Čekamo signale (do primanja signala više ništa ne dešava)
  log.Printf("Isključujemo...")

  close(stop) // Kažemo goroutines da se zaustave
  wg.Wait()   // Čekamo da se sve zaustavi
}

(main.go, u raw)

Radimo sledeće:

  1. Podesimo obradu specifičnih signala operativnog sistema za pravilan (graceful) prekid rada operatora.
  2. Koristimo WaitGroup, kako bismo pravilno zaustavili sve goroutines pre gašenja aplikacije.
  3. Obezbeđujemo pristup klasteru kreiranjem clientset.
  4. Pokrećemo NamespaceController, u kojem će se nalaziti sva naša logika.

Sada nam treba osnova za logiku, a u našem slučaju to je pomenuti 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, u raw)

Ovde postavljamo SharedIndexInformer, koji će efikasno (koristeći keš) čekati na promene u prostorima imena (detaljnije o informers pročitajte u članku "Kako zapravo radi planirač Kubernetes-a?» — napomena prev.). Nakon toga povežemo EventHandler sa informatorom, čime se funkcija poziva prilikom dodavanja prostora imena (Namespace) poziva funkciju createRoleBinding.

Sledeći korak je definisati ovu funkciju 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("Neuspešno kreiranje Role Binding: %s", err.Error()))
  } else {
    log.Println(fmt.Sprintf("Kreiran AD RoleBinding za Namespace: %s", roleBinding.Name))
  }
}

(controller.go, u raw)

Dobijamo prostor imena kao obj i pretvaramo ga u objekat Namespace. Zatim definišemo RoleBinding, oslanjajući se na ono što je navedeno u YAML datoteci, koristeći pruženi objekt Namespace i stvarajući RoleBinding. Na kraju, evidentiramo je li kreiranje prošlo uspješno.

Posljednja funkcija koju treba definirati je 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, u raw)

Ovde govorimo WaitGroup, da ćemo pokrenuti goroutine i zatim pozvati namespaceInformer, koji je prethodno definisan. Kada dođe signal za zaustavljanje, završiće funkciju i obavestiti WaitGroup, da više nije aktivna, i ova funkcija će se završiti.

Informacije o izgradnji i pokretanju ovog operatora u Kubernetes klasteru mogu se naći u repozitorijumu na GitHub-u.

Na ovom operatoru, koji stvara RoleBinding pojavom Namespace u Kubernetes klasteru, spreman je.

Izvor: habr.com

Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere 🔥 Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere | ProHoster