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 , 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.

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(, u )
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
}(, u )
Radimo sledeće:
- Podesimo obradu specifičnih signala operativnog sistema za pravilan (graceful) prekid rada operatora.
- Koristimo
WaitGroup, kako bismo pravilno zaustavili sve goroutines pre gašenja aplikacije. - Obezbeđujemo pristup klasteru kreiranjem
clientset. - 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
}(, u )
Ovde postavljamo SharedIndexInformer, koji će efikasno (koristeći keš) čekati na promene u prostorima imena (detaljnije o informers pročitajte u članku "» — 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))
}
}(, u )
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
}(, u )
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 .
Na ovom operatoru, koji stvara RoleBinding pojavom Namespace u Kubernetes klasteru, spreman je.
Izvor: habr.com
