כתיבת מפעיל עבור Kubernetes בגולנג

הערה. תרגום: מפעילים הם תוכנת עזר עבור Kubernetes, שנועדה להפוך את הביצוע של פעולות שגרתיות על אובייקטי אשכול כאשר מתרחשים אירועים מסוימים. כבר כתבנו על מפעילים ב מאמר זה, שם הם דיברו על הרעיונות והעקרונות הבסיסיים של עבודתם. אבל אם החומר הזה היה יותר מבט מהצד של תפעול רכיבים מוכנים עבור Kubernetes, אז התרגום של המאמר החדש המוצע כעת הוא כבר חזון של מפתח/מהנדס DevOps המבולבל מהיישום של מפעיל חדש.

החלטתי לכתוב את הפוסט הזה עם דוגמה מהחיים האמיתיים לאחר הניסיונות שלי למצוא תיעוד על יצירת מפעיל עבור Kubernetes, שעבר לימוד הקוד.

הדוגמה שתתואר היא זו: באשכול Kubernetes שלנו, כל אחד Namespace מייצג את סביבת ארגז החול של קבוצה, ורצינו להגביל את הגישה אליהם כך שצוותים יוכלו לשחק רק בארגזי החול שלהם.

אתה יכול להשיג את מה שאתה רוצה על ידי הקצאת משתמש לקבוצה שיש לו RoleBinding לספציפית Namespace и ClusterRole עם זכויות עריכה. ייצוג YAML ייראה כך:

---
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בתוך חי)

תיצור אחד RoleBinding אתה יכול לעשות את זה ידנית, אבל לאחר חציית מאה מרחבי השמות, זה הופך למשימה מייגעת. זה המקום שבו מפעילי Kubernetes שימושיים - הם מאפשרים לך להפוך את היצירה של משאבי Kubernetes לאוטומטי על סמך שינויים במשאבים. במקרה שלנו אנחנו רוצים ליצור RoleBinding תוך כדי יצירה Namespace.

קודם כל, בואו נגדיר את הפונקציה mainאשר מבצע את ההגדרה הנדרשת להפעלת ההצהרה ולאחר מכן קורא לפעולת ההצהרה:

(הערה. תרגום: כאן ומטה ההערות בקוד מתורגמות לרוסית. בנוסף, ההזחה תוקנה לרווחים במקום ללשוניות [מומלץ ב- Go] אך ורק למטרת קריאה טובה יותר בפריסת Habr. לאחר כל רישום יש קישורים למקור ב-GitHub, שבו מאוחסנות הערות וכרטיסיות בשפה האנגלית.)

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

(main.goבתוך חי)

אנו עושים את הפעולות הבאות:

1. אנו מגדירים מטפל לאותות ספציפיים של מערכת הפעלה כדי לגרום לסיום חינני של המפעיל.
2. השתמש WaitGroupלהפסיק בחן את כל הגורוטין לפני סיום היישום.
3. אנו מספקים גישה לאשכול על ידי יצירה clientset.
4. רוץ NamespaceController, שבו כל ההיגיון שלנו יהיה ממוקם.

עכשיו צריך בסיס להיגיון, ובמקרה שלנו זה זה שהוזכר 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בתוך חי)

כאן אנו מגדירים SharedIndexInformer, אשר למעשה (באמצעות מטמון) ימתין לשינויים במרחבי השמות (קרא עוד על מלשינים במאמר "כיצד פועל מתזמן Kubernetes למעשה?- משוער. תרגום). אחרי זה אנחנו מתחברים EventHandler למודיע, כך שכאשר מוסיפים מרחב שמות (Namespace) הפונקציה נקראת createRoleBinding.

השלב הבא הוא הגדרת פונקציה זו 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))
  }
}

(controller.goבתוך חי)

אנחנו מקבלים את מרחב השמות כ obj ולהמיר אותו לאובייקט Namespace. ואז נגדיר RoleBinding, בהתבסס על קובץ YAML שהוזכר בהתחלה, תוך שימוש באובייקט שסופק Namespace ויצירה RoleBinding. לבסוף, אנו רושמים אם היצירה הצליחה.

הפונקציה האחרונה שיש להגדיר היא 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בתוך חי)

כאן אנחנו מדברים WaitGroupשנפעיל את הגורוטין ואז נתקשר namespaceInformer, שהוגדר בעבר. כאשר אות העצירה יגיע, הוא יסיים את הפונקציה, הודע WaitGroup, אשר אינו מבוצע יותר, והפונקציה הזו תצא.

מידע על בנייה והפעלה של הצהרה זו באשכול Kubernetes ניתן למצוא ב מאגרים ב- GitHub.

זה הכל עבור המפעיל שיוצר RoleBinding מתי Namespace באשכול Kubernetes, מוכן.

מקור: www.habr.com