Rakstām operatoru Kubernetes uz Golang

Piezīme:: Operatori (operators) ir atbalsta programmatūra Kubernetes, kas paredzēta rutīnu uzdevumu automatizēšanai attiecībā uz klastera objektiem noteiktos notikumos. Mēs jau esam rakstījuši par operatoriem šajā rakstā, kur aplūkojām to pamatidejas un darbības principus. Taču, ja iepriekšējais materiāls bija drīzāk skatījums no puses uz gatavu komponentu izmantošanu Kubernetes, tad šis jaunais raksts ir izstrādātāja/DevOps inženiera skatījums, kas mocās ar jauna operatora izstrādi.

Šo ierakstu ar reāla piemēra aprakstu es nolēmu uzrakstīt pēc tam, kad mēģināju atrast dokumentāciju par operatora izveidi Kubernetes, kas iekļāva koda izpēti.

Piemērs, kuru mēs aprakstīsim, ir šāds: mūsu Kubernetes klasterī katrs Namespace pārstāv kādas komandas smilšu kasti, un mēs vēlējāmies ierobežot piekļuvi tām tā, lai komandas varētu spēlēt tikai savās smilšu kastēs.

Vēlamo var panākt, piešķirot lietotājam grupu, kurai ir RoleBinding attiecībā uz Namespace un ClusterRole ar rediģēšanas tiesībām. YAML attēlojums izskatīsies šādi:

---
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, vienā no saviem ziņojumiem raw)

Šādus RoleBinding var izveidot arī manuāli, taču, kad ir jāizveido vairāk par simtu nosaukumu telpām, tas kļūst nogurdinošs darbs. Tieši šeit noder Kubernetes operatori — tie ļauj automatizēt Kubernetes resursu izveidi, pamatojoties uz resursu izmaiņām. Mūsu gadījumā mēs vēlamies izveidot RoleBinding nosaukumu telpā izveidošanas laikā. Namespace.

Vispirms noskaidrosim funkciju main, kas veic nepieciešamos iestatījumus operatora palaišanai un pēc tam izsauc operatora darbību:

(Piezīme:: šeit un turpmāk kodā komentāri ir tulkoti uz krievu valodu. Turklāt, ieloces ir labotas tā, lai izmantotu atstarpes vietā [Go ieteiktos] tabulācijas simbolus, lai uzlabotu lasāmību šajā Hubra noformējumā. Pēc katra saraksta ir saites uz oriģinālu GitHub, kurū ir saglabāti angļu valodas komentāri un tabulācijas simboli.

func main() {
  // Iestatām žurnālu izvadi konsolē STDOUT
  log.SetOutput(os.Stdout)

  sigs := make(chan os.Signal, 1) // Izveidojam kanālu, lai saņemtu OS signālus
  stop := make(chan struct{})     // Izveidojam kanālu, lai saņemtu apstopēšanas signālu

  // Reģistrējam SIGTERM saņemšanu kanālā sigs
  signal.Notify(sigs, os.Interrupt, syscall.SIGTERM, syscall.SIGINT) 

  // Goroutines var pašas pievienot sevi WaitGroup,
  // lai gaidītu to izpildes pabeigšanu
  wg := &sync.WaitGroup{} 

  runOutsideCluster := flag.Bool("run-outside-cluster", false, "Lūdzu, iestatiet šo karoga vērtību, kad darbojas ārpus klusteru.")
  flag.Parse()
  // Izveidojam clientset, lai mijiedarbotos ar Kubernetes klasteri
  clientset, err := newClientSet(*runOutsideCluster)

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

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

  <-sigs // Gaidām signālus (pirms signāla saņemšanas nekas netiek darīts)
  log.Printf("Aizveram...")

  close(stop) // Sakām goroutines apstāties
  wg.Wait()   // Gaidām, līdz viss ir apstādināts
}

(main.go, vienā no saviem ziņojumiem raw)

Mēs veicam sekojošo:

1. Iestādām specifisku operētājsistēmas signālu apstrādātāju, lai izsauktu pareizu (graceful) operatora aizvēršanu.
2. Izmantojam WaitGroup, lai pareizi apstādinātu visas goroutines pirms programmas izbeigšanas.
3. Nodrošinām piekļuvi klasterim, izveidojot clientset.
4. Sāksim NamespaceController, kurā būs izvietota visa mūsu loģika.

Tagad nepieciešama pamata loģika, un mūsu gadījumā tā ir minētais 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, vienā no saviem ziņojumiem raw)

Šeit mēs iestatām SharedIndexInformer, kas efektīvi (izmantojot kešatmiņu) gaidīs izmaiņas vārdnīcās (vairāk par informatoriem lasiet rakstā "Kā patiesībā darbojas Kubernetes plānotājs?» — piez. tulk.). Pēc tam mēs pievienojam EventHandler informatoram, tādējādi, pievienojot vārdnīcu (Namespace), tiek izsaukta funkcija createRoleBinding.

Nākamais solis — definēt šo 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("Neizdevās izveidot Role Binding: %s", err.Error()))
  } else {
    log.Println(fmt.Sprintf("Izveidots AD RoleBinding vārdnīcai: %s", roleBinding.Name))
  }
}

(controller.go, vienā no saviem ziņojumiem raw)

Mēs iegūstam vārdnīcu kā obj un pārvēršam to par objektu Namespace. Pēc tam definējam RoleBinding, pamatojoties uz iepriekš minēto YAML failā, izmantojot norādīto objektu Namespace un izveidojot RoleBinding. Visbeidzot, reģistrējam, vai izveide noritēja veiksmīgi.

Pēdējā funkcija, kas jānosaka, ir 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, vienā no saviem ziņojumiem raw)

Šeit mēs sakām WaitGroup, ka palaidīsim goroutine un pēc tam izsauksim namespaceInformer, kas tika iepriekš definēts. Kad saņemsim apstāšanās signālu, tas pabeigs funkciju un paziņos WaitGroup, ka vairs netiek izpildīts, un šī funkcija pabeigs savu darbu.

Informāciju par šī operators būvēšanu un palaišanu Kubernetes klasterī var atrast repozitorijā GitHub.

Šeit operators, kas izveido RoleBinding parādīšanās brīdī Namespace Kubernetes klasterī ir gatavs.

Avots: habr.com