🥇 Skryf 'n operateur vir Kubernetes in Golang

Let wel. vertaal.: Operateurs is hulpprogrammatuur vir Kubernetes wat ontwerp is om die uitvoering van roetine-aksies op groepvoorwerpe tydens sekere gebeurtenisse te outomatiseer. Ons het reeds geskryf oor operateurs in Hierdie artikelwaar hulle oor die fundamentele idees en beginsels van hul werk gepraat het. Maar as daardie materiaal eerder 'n siening was van die kant van die werking van klaargemaakte komponente vir Kubernetes, dan is die vertaling van die nuwe artikel wat nou voorgestel word, reeds die visie van 'n ontwikkelaar / DevOps-ingenieur, verbaas oor die implementering van 'n nuwe operateur .

Ek het besluit om hierdie pos met 'n werklike voorbeeld te skryf nadat my pogings om dokumentasie te vind oor die skep van 'n operateur vir Kubernetes, deur die studie van die kode gegaan het.

Die voorbeeld wat beskryf sal word, is die volgende: in ons Kubernetes-kluster, elk Namespace verteenwoordig 'n span se sandbox-omgewing, en ons wou toegang daartoe beperk sodat spanne net in hul eie sandboxes kan speel.

Jy kan bereik wat jy wil deur 'n gebruiker toe te wys aan 'n groep wat het RoleBinding spesifiek Namespace и ClusterRole met redigeerregte. Die YAML-voorstelling sal soos volg lyk:

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

(rolbinding.yamlIn rou)

Skep so RoleBinding jy kan dit met die hand doen, maar sodra jy meer as honderd naamruimtes kry, word dit 'n vervelige taak. Dit is waar Kubernetes-operateurs handig te pas kom - hulle laat jou toe om die skepping van Kubernetes-hulpbronne te outomatiseer op grond van veranderinge in hulpbronne. In ons geval wil ons skep RoleBinding terwyl jy skep Namespace.

Eerstens, laat ons die funksie definieer main, wat die vereiste opstelling doen om die stelling uit te voer en dan die stellingsaksie aanroep:

(Let wel. vertaal.: hierna word die opmerkings in die kode in Russies vertaal. Daarbenewens word die inkeping gekorrigeer vir spasies in plaas van [aanbeveel in Gaan] oortjies uitsluitlik vir die doel van beter leesbaarheid binne die raamwerk van Habr se uitleg. Na elke aanbieding is daar skakels na die oorspronklike op GitHub, waar Engelstalige opmerkings en oortjies gestoor word.)

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

(hoof.gaanIn rou)

Ons doen die volgende:

Ons het 'n hanteerder vir spesifieke bedryfstelselseine opgestel om die operateur grasieus te laat verlaat.
Ons gebruik WaitGroupom alle goroutines grasieus te stop voordat die toepassing beëindig word.
Ons bied toegang tot die groepering deur te skep clientset.
Begin NamespaceController, waarin al ons logika geleë sal wees.

Nou het ons 'n basis vir logika nodig, en in ons geval is dit die genoemde 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
}

(kontroleerder.gaanIn rou)

Hier sit ons SharedIndexInformer, wat doeltreffend (met behulp van die kas) sal wag vir naamruimteveranderings (lees meer oor informante in die artikel "Hoe werk die Kubernetes-skeduleerder eintlik?"- ongeveer. vertaal.). Daarna verbind ons EventHandler aan die informant, waardeur, wanneer 'n naamruimte bygevoeg word (Namespace) word die funksie genoem createRoleBinding.

Die volgende stap is om hierdie funksie te definieer 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))
  }
}

(kontroleerder.gaanIn rou)

Ons kry die naamruimte as obj en omskep dit na 'n voorwerp Namespace. Dan definieer ons RoleBinding, gebaseer op die YAML-lêer wat aan die begin genoem is, deur die verskafde voorwerp te gebruik Namespace en skep RoleBinding. Ten slotte teken ons aan of die skepping suksesvol was.

Die laaste funksie wat gedefinieer moet word is − 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
}

(kontroleerder.gaanIn rou)

Hier praat ons WaitGroupdat ons die goroutine begin en dan bel namespaceInformerwat voorheen gedefinieer is. Wanneer 'n stopsein inkom, sal dit die funksie beëindig, laat weet WaitGroup, wat nie meer uitgevoer word nie, en hierdie funksie sal verlaat.

Inligting oor die bou en uitvoer van hierdie stelling op 'n Kubernetes-kluster kan gevind word by bewaarplekke op GitHub.

Op hierdie stelling, wat skep RoleBinding wanneer Namespace in 'n Kubernetes-kluster, gereed.

Bron: will.com

Ons skryf 'n operateur vir Kubernetes in Golang

Voeg 'n opmerking Kanselleer antwoord