Pišemo operatera za Kubernetes u Golangu

Napomena za prijevod.: Operateri (operators) su pomoćni softver za Kubernetes koji ima za cilj automatizaciju izvođenja rutinskih radnji nad objektima klastera pri određenim događajima. Već smo pisali o operatorima u ovom članku, gdje smo govorili o osnovnim idejama i principima njihovog rada. No, dok je taj materijal bio više pogled sa strane korištenja gotovih komponenata za Kubernetes, sada ponuđeni prijevod novog članka predstavlja viziju programera/DevOps inženjera, zapletenog u izradu novog operatora.

Pišemo operatera za Kubernetes u Golangu

Ovu objavu s primjerom iz stvarnog života odlučio sam napisati nakon svojih pokušaja da pronađem dokumentaciju za izradu operatora za Kubernetes, koja je uključivala proučavanje koda.

Primjer koji će biti opisan je sljedeći: u našem Kubernetes klasteru svaki Imenski prostor predstavlja sandbox okruženje za neku ekipu, i htjeli smo ograničiti pristup tim okruženjima na način da ekipe mogu igrati samo u svojim sandboxovima.

Ono što želimo postići može se ostvariti dodjeljivanjem korisniku grupe koja ima RoleBinding k određenim Imenski prostor i ClusterRole s pravom na uređivanje. YAML prikaz ć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)

Također je moguće stvarati takvo RoleBinding ručno, ali nakon što pređemo oznaku od stotinu prostora imena, to postaje naporna aktivnost. Tada pomažu Kubernetes operatori — oni omogućuju automatizaciju stvaranja Kubernetes resursa, na temelju promjena u resursima. U našem slučaju želimo stvarati RoleBinding prilikom stvaranja Imenski prostor.

Prvo ćemo definirati funkciju main, koja izvodi potrebnu konfiguraciju za aktiviranje operatora i zatim poziva radnju operatora:

(Napomena za prijevod.: ovdje i dalje su komentari u kodu prevedeni na hrvatski jezik. Osim toga, odmori su ispravljeni u prostore umjesto [preporučenih u Go] tabulacija isključivo radi bolje čitljivosti unutar Habra. Nakon svakog popisa navedene su poveznice na original na GitHubu, gdje su sačuvani engleski komentari 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,
  // da bi čekali na završetak njihovog izvršenja
  wg := &sync.WaitGroup{} 

  runOutsideCluster := flag.Bool("run-outside-cluster", false, "Postavite ovu zastavicu kada pokrećete van klastera.")
  flag.Parse()
  // Kreiramo clientset za interakciju s Kubernetes klasterom
  clientset, err := newClientSet(*runOutsideCluster)

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

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

  <-sigs // Čekamo signale (do primanja signala ne događa se ništa)
  log.Printf("Gašenje...")

  close(stop) // Govorimo goroutines da se zaustave
  wg.Wait()   // Čekamo da sve bude zaustavljeno
}

(main.go, u raw)

Radimo sledeće:

  1. Podešavamo upravljača za specifične signale operativnog sistema kako bismo pokrenuli ispravno (graceful) zatvaranje rada operatora.
  2. Koristimo WaitGroup, kako bismo ispravno zaustavili sve goroutines pre zatvaranja aplikacije.
  3. Omogućavamo pristup klasteru kreiranjem clientset.
  4. Pokrenite NamespaceController, u kojem će biti smeštena sva naša logika.

Sada nam je potrebna 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 podešavamo SharedIndexInformer, koji će efikasno (koristeći cache) čekati promene u prostorima imena (više o informers-ima pročitajte u članku "Kako zapravo funkcionira Kubernetes scheduler?» — napomena prev.). Nakon toga povezujemo EventHandler s informera, zahvaljujući čemu se funkcija poziva prilikom dodavanja prostora imena (Imenski prostor) poziva funkciju createRoleBinding.

Sledeći korak je definisanje ove funkcije 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-a: %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 Imenski prostor. Zatim definišemo RoleBinding, oslanjajući se na spomenut u YAML datoteci, koristeći dostavljeni objekt Imenski prostor i stvarajući RoleBinding. Na kraju, bilježimo je li kreiranje uspjelo.

Zadnja 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)

Ovdje govorimo WaitGroup, da ćemo pokrenuti goroutine, a zatim pozvati namespaceInformer, koji je prethodno definiran. Kada signal za zaustavljanje dođe, završit će funkciju, obavijestiti WaitGroup, da se više ne izvršava, a ova funkcija će završiti.

Informacije o izgradnji i pokretanju ovog operatera u Kubernetes klasteru mogu se naći u repozitoriju na GitHubu.

Ovdje, operater koji stvara RoleBinding pojavom Imenski prostor u Kubernetes klasteru, je spreman.

Izvor: habr.com

Kupite pouzdan hosting za web stranice s DDoS zaštitom, VPS VDS servere 🔥 Kupite pouzdan hosting za web stranice s DDoS zaštitom, VPS VDS servere | ProHoster