🥇Kubernetes ប្រតិបត្តិករនៅក្នុង Python ដោយគ្មានក្របខ័ណ្ឌនិង SDK

បច្ចុប្បន្ន Go មានសិទ្ធិផ្តាច់មុខលើភាសាសរសេរកម្មវិធី ដែលមនុស្សជ្រើសរើសដើម្បីសរសេរសេចក្តីថ្លែងការណ៍សម្រាប់ Kubernetes ។ មានហេតុផលគោលបំណងសម្រាប់រឿងនេះ ដូចជា៖

មានក្របខ័ណ្ឌដ៏មានអានុភាពសម្រាប់អភិវឌ្ឍប្រតិបត្តិករនៅក្នុង Go - ប្រតិបត្តិករ SDK.
កម្មវិធីផ្លាស់ប្តូរហ្គេមដូចជា Docker និង Kubernetes ត្រូវបានសរសេរនៅក្នុង Go ។ ការសរសេរប្រតិបត្តិកររបស់អ្នកនៅក្នុង Go មានន័យថានិយាយភាសាដូចគ្នាជាមួយនឹងប្រព័ន្ធអេកូ។
ដំណើរការខ្ពស់នៃកម្មវិធី Go និងឧបករណ៍សាមញ្ញសម្រាប់ធ្វើការជាមួយការស្របគ្នាក្រៅប្រអប់។

NB៖ ដោយវិធីនេះ របៀបសរសេរសេចក្តីថ្លែងការណ៍ផ្ទាល់ខ្លួនរបស់អ្នកនៅក្នុង Go យើង បានពិពណ៌នារួចហើយ នៅក្នុងការបកប្រែរបស់យើងដោយអ្នកនិពន្ធបរទេស។

ប៉ុន្តែចុះយ៉ាងណាបើអ្នកត្រូវបានរារាំងពីការរៀន Go ដោយខ្វះពេលវេលា ឬនិយាយដោយសាមញ្ញថា ការលើកទឹកចិត្ត? អត្ថបទផ្តល់នូវឧទាហរណ៍មួយអំពីរបៀបដែលអ្នកអាចសរសេរសេចក្តីថ្លែងការណ៍ដ៏ល្អដោយប្រើភាសាដ៏ពេញនិយមបំផុតមួយដែលស្ទើរតែគ្រប់វិស្វករ DevOps ដឹង - ពស់ថ្លាន់.

ជួប៖ ម៉ាស៊ីនថតចម្លង - ប្រតិបត្តិករចម្លង!

ជាឧទាហរណ៍ សូមពិចារណាបង្កើតសេចក្តីថ្លែងការណ៍សាមញ្ញមួយ ដែលត្រូវបានរចនាឡើងដើម្បីចម្លង ConfigMap ទាំងនៅពេលដែល namespace ថ្មីលេចឡើង ឬនៅពេលដែលធាតុមួយក្នុងចំណោមពីរផ្លាស់ប្តូរ៖ ConfigMap និង Secret ។ តាមទស្សនៈជាក់ស្តែង ប្រតិបត្តិករអាចមានប្រយោជន៍សម្រាប់ការធ្វើបច្ចុប្បន្នភាពភាគច្រើននៃការកំណត់រចនាសម្ព័ន្ធកម្មវិធី (ដោយការអាប់ដេត ConfigMap) ឬសម្រាប់ការអាប់ដេតទិន្នន័យសម្ងាត់ - ឧទាហរណ៍ គ្រាប់ចុចសម្រាប់ធ្វើការជាមួយ Docker Registry (នៅពេលបន្ថែមការសម្ងាត់ទៅក្នុង namespace)។

ហើយដូច្នេះ, អ្វីដែលប្រតិបត្តិករល្អគួរតែមាន:

អន្តរកម្មជាមួយប្រតិបត្តិករត្រូវបានអនុវត្តដោយប្រើ និយមន័យធនធានផ្ទាល់ខ្លួន (តទៅនេះហៅថា CRD)។
ប្រតិបត្តិករអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធ។ ដើម្បីធ្វើដូច្នេះ យើងនឹងប្រើទង់បន្ទាត់ពាក្យបញ្ជា និងអថេរបរិស្ថាន។
ការបង្កើតធុង Docker និងគំនូសតាង Helm ត្រូវបានរចនាឡើងដើម្បីឱ្យអ្នកប្រើប្រាស់អាចងាយស្រួល (តាមន័យត្រង់ដោយប្រើពាក្យបញ្ជាមួយ) ដំឡើងប្រតិបត្តិករទៅក្នុងចង្កោម Kubernetes របស់ពួកគេ។

ស៊ីឌីឌី

ដើម្បីឱ្យប្រតិបត្តិករដឹងពីធនធានអ្វីដែលត្រូវរកមើល និងកន្លែងដែលត្រូវរកមើល យើងត្រូវកំណត់ច្បាប់សម្រាប់គាត់។ ច្បាប់នីមួយៗនឹងត្រូវបានតំណាងជាវត្ថុ CRD តែមួយ។ តើ CRD នេះគួរមានវិស័យអ្វីខ្លះ?

ប្រភេទធនធានដែលយើងនឹងស្វែងរក (ConfigMap ឬ Secret)។
បញ្ជីឈ្មោះចន្លោះដែលធនធានគួរស្ថិតនៅ។
កម្មវិធីជ្រើសដែលយើងនឹងស្វែងរកធនធាននៅក្នុង namespace ។

ចូរពណ៌នាអំពី 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

រួចរាល់ហើយ! ឥឡូវនេះ យើងត្រូវទទួលបានព័ត៌មានអំពីច្បាប់របស់យើង។ អនុញ្ញាតឱ្យខ្ញុំធ្វើការកក់ទុកភ្លាមៗថាយើងនឹងមិនសរសេរសំណើទៅកាន់ Cluster API Server ខ្លួនយើងទេ។ ដើម្បីធ្វើដូច្នេះ យើងនឹងប្រើបណ្ណាល័យ Python ដែលត្រៀមរួចជាស្រេច kubernetes-អតិថិជន:

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។

អថេរបរិស្ថាន ឬទង់ជាតិ? យើងយកទាំងអស់!

ចូរបន្តទៅការកំណត់រចនាសម្ព័ន្ធប្រតិបត្តិករសំខាន់។ មានវិធីសាស្រ្តជាមូលដ្ឋានចំនួនពីរក្នុងការកំណត់រចនាសម្ព័ន្ធកម្មវិធី៖

ប្រើជម្រើសបន្ទាត់ពាក្យបញ្ជា;
ប្រើអថេរបរិស្ថាន។

ជម្រើសបន្ទាត់ពាក្យបញ្ជាអនុញ្ញាតឱ្យអ្នកអានការកំណត់កាន់តែបត់បែន ដោយមានការគាំទ្រប្រភេទទិន្នន័យ និងសុពលភាព។ បណ្ណាល័យស្តង់ដាររបស់ 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 # Оформление пакета

Docker និង Helm

Dockerfile នឹងមានលក្ខណៈសាមញ្ញមិនគួរឱ្យជឿ៖ យករូបភាព python-alpine មូលដ្ឋាន ហើយដំឡើងកញ្ចប់របស់យើង។ សូមពន្យារពេលការបង្កើនប្រសិទ្ធភាពរបស់វារហូតដល់ពេលវេលាកាន់តែប្រសើរ៖

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 ។ ជាការពិតណាស់ វានៅតែមានកន្លែងដើម្បីរីកចម្រើន៖ នៅពេលអនាគត វានឹងអាចដំណើរការច្បាប់ជាច្រើន ធ្វើការក្នុងខ្សែស្រឡាយច្រើន ដោយឯករាជ្យ ត្រួតពិនិត្យការផ្លាស់ប្តូរនៅក្នុង CRDs របស់វា...

ដើម្បីឱ្យអ្នកមើលកាន់តែច្បាស់អំពីកូដនោះ យើងបានដាក់វាចូល ឃ្លាំងសាធារណៈ. ប្រសិនបើអ្នកចង់បានឧទាហរណ៍នៃប្រតិបត្តិករដ៏ធ្ងន់ធ្ងរបន្ថែមទៀតដែលត្រូវបានអនុវត្តដោយប្រើ Python អ្នកអាចបង្វែរការយកចិត្តទុកដាក់របស់អ្នកទៅប្រតិបត្តិករពីរសម្រាប់ដាក់ពង្រាយ mongodb (первый и ទីពីរ).

PS ហើយប្រសិនបើអ្នកខ្ជិលពេកក្នុងការដោះស្រាយជាមួយព្រឹត្តិការណ៍ Kubernetes ឬអ្នកកាន់តែស៊ាំនឹងការប្រើប្រាស់ Bash សហការីរបស់យើងបានរៀបចំដំណោះស្រាយដែលត្រៀមរួចជាស្រេចក្នុងទម្រង់ ប្រតិបត្តិករសែល (យើង បានប្រកាស វានៅក្នុងខែមេសា) ។

PPS

សូមអានផងដែរនៅលើប្លក់របស់យើង៖

ប្រភព: www.habr.com

ប្រតិបត្តិករ Kubernetes នៅក្នុង Python ដោយគ្មានក្របខ័ណ្ឌ និង SDK