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

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(, u )
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
}(, u )
Radimo sledeće:
- Podešavamo upravljača za specifične signale operativnog sistema kako bismo pokrenuli ispravno (graceful) zatvaranje rada operatora.
- Koristimo
WaitGroup, kako bismo ispravno zaustavili sve goroutines pre zatvaranja aplikacije. - Omogućavamo pristup klasteru kreiranjem
clientset. - 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
}(, u )
Ovde podešavamo SharedIndexInformer, koji će efikasno (koristeći cache) čekati promene u prostorima imena (više o informers-ima pročitajte u članku "» — 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))
}
}(, u )
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
}(, u )
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 .
Ovdje, operater koji stvara RoleBinding pojavom Imenski prostor u Kubernetes klasteru, je spreman.
Izvor: habr.com
