Kubernetes Operator ב- Python ללא מסגרות ו-SDK

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

1. יש מסגרת חזקה לפיתוח אופרטורים ב-Go - SDK של מפעיל.
2. יישומים משנים משחקים כמו Docker ו-Kubernetes כתובים ב-Go. כתיבת המפעיל שלך ב-Go פירושה דיבור באותה שפה עם המערכת האקולוגית.
3. ביצועים גבוהים של יישומי Go וכלים פשוטים לעבודה עם בו זמנית מחוץ לקופסה.

NB: אגב, איך לכתוב הצהרה משלך בגו, אנחנו כבר תואר באחד מהתרגומים שלנו על ידי סופרים זרים.

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

הכירו: מכונת צילום - מפעיל עותקים!

כדוגמה, שקול לפתח הצהרה פשוטה שנועדה להעתיק ConfigMap כאשר מופיע מרחב שמות חדש או כאשר אחת משתי ישויות משתנה: ConfigMap ו-Secret. מנקודת מבט מעשית, המפעיל יכול להיות שימושי לעדכון בכמות גדולה של תצורות אפליקציות (על ידי עדכון ה-ConfigMap) או לעדכון נתונים סודיים - למשל מפתחות לעבודה עם Docker Registry (בעת הוספת Secret למרחב השמות).

לפיכך, מה צריך להיות למפעיל טוב:

1. האינטראקציה עם המפעיל מתבצעת באמצעות הגדרות משאבים מותאמות אישית (להלן: CRD).
2. ניתן להגדיר את המפעיל. לשם כך, נשתמש בדגלי שורת הפקודה ובמשתני סביבה.
3. המבנה של תרשים ה-Docker ו-Helm תוכנן כך שמשתמשים יכולים בקלות (ממש בפקודה אחת) להתקין את המפעיל באשכול Kubernetes שלהם.

CRD

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

1. סוג משאב, שנחפש (ConfigMap או Secret).
2. רשימה של מרחבי שמות, שבו יש למקם את המשאבים.
3. בורר, שבאמצעותו נחפש משאבים במרחב השמות.

בואו נתאר את ה-CRD:

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: copyrator.flant.com
spec:
  group: flant.com
  versions:
  - name: v1
    served: true
    storage: true
  scope: Namespaced
  names:
    plural: copyrators
    singular: copyrator
    kind: CopyratorRule
    shortNames:
    - copyr
  validation:
    openAPIV3Schema:
      type: object
      properties:
        ruleType:
          type: string
        namespaces:
          type: array
          items:
            type: string
        selector:
          type: string

ואנחנו ניצור את זה מיד כלל פשוט — כדי לחפש במרחב השמות עם השם default הכל ConfigMap עם תוויות כמו copyrator: "true":

apiVersion: flant.com/v1
kind: CopyratorRule
metadata:
  name: main-rule
  labels:
    module: copyrator
ruleType: configmap
selector:
  copyrator: "true"
namespace: default

מוּכָן! עכשיו אנחנו צריכים איכשהו לקבל מידע על הכלל שלנו. הרשו לי לבצע הזמנה מיד שלא נכתוב בקשות לשרת ה-API של אשכול בעצמנו. לשם כך, נשתמש בספריית Python מוכנה kubernetes-client:

import kubernetes
from contextlib import suppress


CRD_GROUP = 'flant.com'
CRD_VERSION = 'v1'
CRD_PLURAL = 'copyrators'


def load_crd(namespace, name):
    client = kubernetes.client.ApiClient()
    custom_api = kubernetes.client.CustomObjectsApi(client)

    with suppress(kubernetes.client.api_client.ApiException):
        crd = custom_api.get_namespaced_custom_object(
            CRD_GROUP,
            CRD_VERSION,
            namespace,
            CRD_PLURAL,
            name,
        )
    return {x: crd[x] for x in ('ruleType', 'selector', 'namespace')}

כתוצאה מהפעלת קוד זה, אנו מקבלים את הדברים הבאים:

{'ruleType': 'configmap', 'selector': {'copyrator': 'true'}, 'namespace': ['default']}

נהדר: הצלחנו להשיג כלל למפעיל. והכי חשוב, עשינו את מה שנקרא דרך Kubernetes.

משתני סביבה או דגלים? אנחנו לוקחים הכל!

בואו נעבור לתצורת המפעיל הראשי. קיימות שתי גישות בסיסיות להגדרת אפליקציות:

1. השתמש באפשרויות שורת הפקודה;
2. להשתמש במשתני סביבה.

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

במקרה שלנו, כך תיראה דוגמה להגדרת דגלים של שורת הפקודה לקריאה:

   parser = ArgumentParser(
        description='Copyrator - copy operator.',
        prog='copyrator'
    )
    parser.add_argument(
        '--namespace',
        type=str,
        default=getenv('NAMESPACE', 'default'),
        help='Operator Namespace'
    )
    parser.add_argument(
        '--rule-name',
        type=str,
        default=getenv('RULE_NAME', 'main-rule'),
        help='CRD Name'
    )
    args = parser.parse_args()

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

env:
- name: NAMESPACE
  valueFrom:
     fieldRef:
         fieldPath: metadata.namespace 

היגיון מפעיל

כדי להבין כיצד להפריד בין שיטות לעבודה עם ConfigMap ו- Secret, נשתמש במפות מיוחדות. אז נוכל להבין אילו שיטות אנחנו צריכים כדי לעקוב וליצור את האובייקט:

LIST_TYPES_MAP = {
    'configmap': 'list_namespaced_config_map',
    'secret': 'list_namespaced_secret',
}

CREATE_TYPES_MAP = {
    'configmap': 'create_namespaced_config_map',
    'secret': 'create_namespaced_secret',
}

לאחר מכן, עליך לקבל אירועים משרת ה-API. בואו ליישם את זה באופן הבא:

def handle(specs):
    kubernetes.config.load_incluster_config()
    v1 = kubernetes.client.CoreV1Api()

    # Получаем метод для слежения за объектами
    method = getattr(v1, LIST_TYPES_MAP[specs['ruleType']])
    func = partial(method, specs['namespace'])

    w = kubernetes.watch.Watch()
    for event in w.stream(func, _request_timeout=60):
        handle_event(v1, specs, event)

לאחר קבלת האירוע, אנו עוברים להיגיון העיקרי של עיבודו:

# Типы событий, на которые будем реагировать
ALLOWED_EVENT_TYPES = {'ADDED', 'UPDATED'}


def handle_event(v1, specs, event):
    if event['type'] not in ALLOWED_EVENT_TYPES:
        return

    object_ = event['object']
    labels = object_['metadata'].get('labels', {})

    # Ищем совпадения по selector'у
    for key, value in specs['selector'].items():
        if labels.get(key) != value:
            return
    # Получаем активные namespace'ы
    namespaces = map(
        lambda x: x.metadata.name,
        filter(
            lambda x: x.status.phase == 'Active',
            v1.list_namespace().items
        )
    )
    for namespace in namespaces:
        # Очищаем метаданные, устанавливаем namespace
        object_['metadata'] = {
            'labels': object_['metadata']['labels'],
            'namespace': namespace,
            'name': object_['metadata']['name'],
        }
        # Вызываем метод создания/обновления объекта
        methodcaller(
            CREATE_TYPES_MAP[specs['ruleType']],
            namespace,
            object_
        )(v1)

ההיגיון העיקרי מוכן! כעת עלינו לארוז את כל זה בחבילת Python אחת. אנחנו מכינים את הקובץ setup.py, כתוב שם מטא מידע על הפרויקט:

from sys import version_info

from setuptools import find_packages, setup

if version_info[:2] < (3, 5):
    raise RuntimeError(
        'Unsupported python version %s.' % '.'.join(version_info)
    )


_NAME = 'copyrator'
setup(
    name=_NAME,
    version='0.0.1',
    packages=find_packages(),
    classifiers=[
        'Development Status :: 3 - Alpha',
        'Programming Language :: Python',
        'Programming Language :: Python :: 3',
        'Programming Language :: Python :: 3.5',
        'Programming Language :: Python :: 3.6',
        'Programming Language :: Python :: 3.7',
    ],
    author='Flant',
    author_email='[email protected]',
    include_package_data=True,
    install_requires=[
        'kubernetes==9.0.0',
    ],
    entry_points={
        'console_scripts': [
            '{0} = {0}.cli:main'.format(_NAME),
        ]
    }
)

NB: ללקוח kubernetes עבור Python יש גירסה משלו. מידע נוסף על תאימות בין גרסאות לקוח וגרסאות Kubernetes ניתן למצוא ב מטריצות תאימות.

כעת הפרויקט שלנו נראה כך:

copyrator
├── copyrator
│   ├── cli.py # Логика работы с командной строкой
│   ├── constant.py # Константы, которые мы приводили выше
│   ├── load_crd.py # Логика загрузки CRD
│   └── operator.py # Основная логика работы оператора
└── setup.py # Оформление пакета

דוקר והלם

ה-Dockerfile יהיה פשוט להפליא: קח את תמונת הפיתון-אלפינית הבסיסית והתקן את החבילה שלנו. בואו נדחה את האופטימיזציה שלו לזמנים טובים יותר:

FROM python:3.7.3-alpine3.9

ADD . /app

RUN pip3 install /app

ENTRYPOINT ["copyrator"]

גם הפריסה עבור המפעיל פשוטה מאוד:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Chart.Name }}
spec:
  selector:
    matchLabels:
      name: {{ .Chart.Name }}
  template:
    metadata:
      labels:
        name: {{ .Chart.Name }}
    spec:
      containers:
      - name: {{ .Chart.Name }}
        image: privaterepo.yourcompany.com/copyrator:latest
        imagePullPolicy: Always
        args: ["--rule-type", "main-rule"]
        env:
        - name: NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
      serviceAccountName: {{ .Chart.Name }}-acc

לבסוף, עליך ליצור תפקיד מתאים למפעיל עם הזכויות הדרושות:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: {{ .Chart.Name }}-acc

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: {{ .Chart.Name }}
rules:
  - apiGroups: [""]
    resources: ["namespaces"]
    verbs: ["get", "watch", "list"]
  - apiGroups: [""]
    resources: ["secrets", "configmaps"]
    verbs: ["*"]
---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: {{ .Chart.Name }}
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: {{ .Chart.Name }}
subjects:
- kind: ServiceAccount
  name: {{ .Chart.Name }}

סך הכל

כך, ללא חשש, תוכחה או לימוד Go, הצלחנו לבנות מפעיל משלנו עבור Kubernetes ב-Python. כמובן, עדיין יש לו מקום לצמוח: בעתיד הוא יוכל לעבד מספר כללים, לעבוד במספר שרשורים, לנטר באופן עצמאי שינויים ב-CRD שלו...

כדי לתת לך מבט מקרוב על הקוד, הכנסנו אותו מאגר ציבורי. אם אתה רוצה דוגמאות לאופרטורים רציניים יותר המיושמים באמצעות Python, אתה יכול להפנות את תשומת לבך לשני אופרטורים לפריסת mongodb (первый и שני).

נ.ב. ואם אתה עצלן מכדי להתמודד עם אירועי Kubernetes או שאתה פשוט רגיל יותר להשתמש ב-Bash, הקולגות שלנו הכינו פתרון מוכן בטופס מפעיל מעטפת (אָנוּ הוכרז זה באפריל).

PPS

קרא גם בבלוג שלנו:

• «האם קל ונוח להכין אשכול Kubernetes? מכריז על מפעיל תוסף";
• «היכרות עם מפעיל מעטפת: יצירת אופרטורים עבור Kubernetes פשוט נעשתה קלה יותר";
• «הרחבת והשלמה של Kubernetes (סקירה כללית ודוח וידאו)";
• «כתיבת מפעיל עבור Kubernetes בגולנג";
• «אופרטורים עבור Kubernetes: כיצד להפעיל יישומים סטטיסטיים".

מקור: www.habr.com