Kubernetes operators Python bez ietvariem un SDK

Go šobrīd ir monopols programmēšanas valodu vidū, ko cilvēki izvēlas operatoru rakstīšanai Kubernetes. Tam ir objektīvi iemesli, piemēram:

1. Pastāv jaudīgs ietvars operatoru izstrādei, izmantojot Go — Operator SDK.
2. Operatori uz Go ir izstrādāti tādiem «spēli mainošiem» lietotnēm kā Docker un Kubernetes. Rakstot savu operatoru uz Go, jūs runājat ar ekosistēmu vienā valodā.
3. Augsta Go lietotņu veiktspēja un vienkārši instrumenti darbam ar konkurenci «no kastes».

Piezīme: Starp citu, kā uzrakstīt savu operatoru uz Go, mēs jau esam aprakstījuši vienā no mūsu tulkojumiem no ārzemju autoriem.

Bet ko darīt, ja Go apgūšana jums traucē laika trūkums vai, vienkārši, motivācijas trūkums? Šajā rakstā ir piemērs, kā var uzrakstīt labu operatoru, izmantojot vienu no populārākajām valodām, ko praktiski pazīst katrs DevOps inženieris — Python.

Iepazīstieties: Kopirotājs — kopēšanas operators!

Par piemēru aplūkosim vienkārša operatora izstrādi, kas paredzēts ConfigMap kopēšanai vai nu jauna namespace parādīšanās gadījumā, vai arī vienas no divām entitātēm: ConfigMap un Secret maiņas gadījumā. Praktiskās pielietošanas viedokļa, operators var būt noderīgs masveida lietojumprogrammu konfigurāciju atjaunināšanai (atjauninot ConfigMap) vai arī slepeno datu atjaunināšanai, piemēram, atslēgām darbam ar Docker Registry (pievienojot Secret ietvarā).

Tātad, kas jābūt labam operatoram:

1. Saziņa ar operatoru notiek, izmantojot ) pārvaldība paša (turpmāk — CRD).
2. Operators var būt konfigurējams. Tam mēs izmantosim komandlīnijas karogus un vides mainīgos.
3. Docker konteineru un Helm shēmu izstrāde tiek veikta tā, lai lietotāji varētu viegli (burtiski ar vienu komandu) instalēt operatoru savā Kubernetes klasterī.

CRD

Lai operators zinātu, kādus resursus un kur meklēt, mums ir jānosaka noteikums. Katrs noteikums tiks attēlots kā viens CRD objekts. Kādi lauki jābūt šim CRD?

1. Resursa tips, kuru mēs meklēsim (ConfigMap vai Secret).
2. Namespace saraksts, kuros jāatrodas resursiem.
3. Selector, pēc kura mēs meklēsim resursus namespace.

Aprakstīsim 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

Unā brīdī izveidosim vienkāršu noteikumu — meklēšanai namespace ar nosaukumu default visiem ConfigMap ar tādām etiķetēm kā copyrator: "true":

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

Gatavs! Tagad ir jānopelna informācija par mūsu noteikumu. Uzreiz jānorāda, ka mēs neizveidosim API Server pieprasījumus paši. Mēs izmantosim gatavu Python bibliotēku 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')}

Šī koda izpildes rezultātā saņemsim sekojošo:

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

Lieliski: mēs esam ieguvuši noteikumu operatoram. Un, kas ir vissvarīgākais — mēs to izdarījām, kā mēdz teikt, Kubernetes veidā.

Vides mainīgie vai karogi? Ņemam visu!

Pārejam pie operatora pamatkonfigurācijas. Ir divi pamatpieejas veidi lietojumprogrammu konfigurēšanai:

1. izmantot komandrindas parametrus;
2. izmantot vides mainīgos.

Komandrindas parametri ļauj elastīgāk nolasīt iestatījumus, atbalstot un validējot datu tipus. Standarta Python bibliotēkā ir modulis argparser, ko mēs izmantosim. Sīkāka informācija un piemēri ir pieejami oficiālajā dokumentācijā.

Tā kā mūsu gadījumā izskatīsies piemērs komandrindas karogu nolasīšanai:

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

No otras puses, izmantojot vides mainīgos Kubernetes, var viegli pārvietot pakalpojuma informāciju par podu iekšā konteinerā. Piemēram, informāciju par namespace, kurā ir palaists pods, varam iegūt ar sekojošo konstrukciju:

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

Operatora darbības loģika

Lai saprastu, kā sadalīt metodes darbībai ar ConfigMap un Secret, izmantosim īpašas kartes. Tādējādi mēs spēsim saprast, kādas metodes mums nepieciešamas, lai uzraudzītu un radītu objektu:

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

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

Tad ir nepieciešams saņemt notikumus no API servera. Realizēsim to šādi:

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

    # Iegūstam metodi, lai uzraudzītu objektus
    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)

Pēc notikuma saņemšanas pārejam pie galvenās tā apstrādes loģikas:

# Типы событий, на которые будем реагировать
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)

Galvenā loģika ir gatava! Tagad ir jāiekļauj viss tas vienā Python paketē. Noformējam failu setup.py, rakstām tur projektu metainformāciju:

from sys import version_info

from setuptools import find_packages, setup

if version_info[:2] < (3, 5):
    raise RuntimeError(
        'Atbalstītā python versija %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='maksim.nabokikh@flant.com',
    include_package_data=True,
    install_requires=[
        'kubernetes==9.0.0',
    ],
    entry_points={
        'console_scripts': [
            '{0} = {0}.cli:main'.format(_NAME),
        ]
    }
)

Piezīme: Kubernetes klients Pythonam piedāvā savu versiju pārvaldību. Plašāku informāciju par klienta versiju un Kubernetes versiju saderību var uzzināt no saderības matricas.

Tagad mūsu projekts izskatās šādi:

copyrator
├── copyrator
│   ├── cli.py # Darba loģika ar komandu rindu
│   ├── constant.py # Konstantas, kuras mēs iepriekš minējām
│   ├── load_crd.py # CRD ielādes loģika
│   └── operator.py # Operatora pamatdarbības loģika
└── setup.py # Paketes noformējums

Docker un Helm

Dockerfile būs vienkāršs: ņemsim pamatattēlu python-alpine un instalēsim mūsu paketi. Tās optimizāciju atliksim uz vēlāku laiku:

FROM python:3.7.3-alpine3.9

ADD . /app

RUN pip3 install /app

ENTRYPOINT ["copyrator"]

Izvietošana operatoram ir arī ļoti vienkārša:

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

Visbeidzot, ir jāizveido atbilstoša loma operatoram ar nepieciešamajām tiesībām:

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

Rezultāts

Tādējādi, bez bailēm, pārmetumiem un Go apguves, mēs spējam izveidot savu pašu operatoru Kubernetes platformai, izmantojot Python. Protams, tam vēl ir kur pilnveidoties: nākotnē tam būs iespēja apstrādāt vairākus noteikumus, strādāt paralēli, patstāvīgi uzraudzīt savas CRD izmaiņas…

Lai varētu tuvāk iepazīties ar kodu, mēs to ievietojām publiskajā repozitorijā. Ja vēlaties redzēt nopietnāku operatoru piemērus, kas izstrādāti ar Python palīdzību, varat pievērst uzmanību diviem operatoriem MongoDB izvietošanai (pirmais un otrais).

P.S. Un, ja jums ir slinkums izprast Kubernetes notikumus vai vienkārši ir ērtāk izmantot Bash — mūsu kolēģi ir sagatavojuši gatavu risinājumu, . Izmantojot to, var šo izveidot bez Go zināšanām, bet ar administratoriem pierastām metodēm: uz Bash, Python utt. (mēs paziņoja to izdarījām aprīlī).

P.P.S.

Lasiet arī mūsu emuāra rakstos:

• «Sagatavot Kubernetes klasteri ir vienkārši un ērti? Paziņojam par addon-operatoru»;
• «Iepazīstinām ar shell-operator: veidot operatorus Kubernetes tagad ir vēl vieglāk.»;
• «Paplašinām un papildinām Kubernetes (pārskats un video prezentācija)»;
• «Rakstām operatoru Kubernetes uz Golang»;
• «Operatori Kubernetes: kā palaist stateful lietojumprogrammas».

Avots: habr.com