Kubernetes Operater na Pythonu bez okvira i SDK-a

Kubernetes Operater na Pythonu bez okvira i SDK-a

Go trenutno dominira kao jedini jezik programiranja koji ljudi biraju za pisanje operatora za Kubernetes. To ima objektivne razloge, kao što su:

  1. Postoji moćni okvir za razvoj operatora na Go-u — Operator SDK.
  2. Na Go-u su napisane neke aplikacije koje su "promijenile igru", poput Dockera i Kubernetesa. Pisanje vlastitog operatora na Go-u znači govoriti s ekosistemom na istom jeziku.
  3. Visoke performanse aplikacija na Go-u i jednostavni alati za rad s konkurentnošću "iz kutije".

NB: Usput, kako napisati svoj operator na Go-u, mi već smo opisali u jednom od naših prevoda stranih autora.

Ali šta ako vam nedostatak vremena ili, jednostavno, motivacije, onemogućava da učite Go? U članku je prikazan primjer kako napisati kvalitetan operator koristeći jedan od najpopularnijih jezika, koji poznaje gotovo svaki DevOps inženjer — Python.

Upoznajte: Kopirator — operator za kopiranje!

Kao primjer, razmotrićemo razvoj jednostavnog operatora koji je namijenjen za kopiranje ConfigMap-a, ili kada se pojavi novi namespace, ili prilikom izmjene jednog od dva entiteta: ConfigMap-a i Secret-a. Sa praktičnog aspekta, operator može biti koristan za masovno ažuriranje konfiguracija aplikacije (ažuriranjem ConfigMap-a) ili za ažuriranje tajnih podataka — na primjer, ključeva za rad s Docker Registry (prilikom dodavanja Secret-a u namespace).

Dakle, šta treba da ima dobar operator:

  1. Interakcija s operatorom ostvaruje se putem Custom Resource Definitions (dalje — CRD).
  2. Operator se može konfigurisati. Za to ćemo koristiti opcije komandne linije i promenljive okruženja.
  3. Izrada Docker kontejnera i Helm šarta osmišljena je tako da korisnici lako (doslovno jednom komandom) instaliraju operator u svoj Kubernetes klaster.

CRD

Da bi operator znao koje resurse i gde da traži, potrebno je postaviti pravilo za njega. Svako pravilo će biti predstavljeno u obliku jednog CRD objekta. Koja polja treba da ima ovaj CRD?

  1. Tip resursa, koji ćemo tražiti (ConfigMap ili Secret).
  2. Spisak namespace-ova, u kojima treba da se nalaze resursi.
  3. Selector, po kojem ćemo tražiti resurse u namespace-u.

Opisaćemo 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

I odmah ćemo stvoriti jednostavno pravilo — za pretragu u namespace-u pod imenom default svi ConfigMap s oznakama tipa copyrator: "true":

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

Gotovo! Sada trebamo dobiti informacije o našem pravilu. Odmah napominjem da nećemo sami pisati zahteve ka API Server klastera. Umesto toga, iskoristićemo gotovu Python biblioteku 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')}

Kao rezultat ovog koda dobićemo sledeće:

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

Odlično: uspeli smo da dobijemo pravilo za operatora. I najvažnije — uradili smo to, tako da kažem, na Kubernetes način.

Promenljive okruženja ili oznake? Uzimamo sve!

Prelazimo na glavnu konfiguraciju operatora. Postoje dva osnovna pristupa za konfiguraciju aplikacija:

  1. koristiti parametre komandne linije;
  2. koristiti promenljive okruženja.

Parametri komandne linije omogućavaju čitanje postavki fleksibilnije, sa podrškom i validacijom tipova podataka. U standardnoj biblioteci Pythona postoji modul argparser, koji ćemo iskoristiti. Detalji i primeri njegovih mogućnosti dostupni su u službenoj dokumentaciji.

Ovako će za naš slučaj izgledati primer podešavanja čitanja oznaka komandne linije:

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

S druge strane, pomoću varijabli okruženja u Kubernetes-u možemo lako preneti informacije o pod-u unutar kontejnera. Na primer, informacije o namespace-u u kojem je pod pokrenut, možemo dobiti sledećom konstrukcijom:

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

Logika rada operatora

Da bismo razumeli kako da razdvojimo metode za rad sa ConfigMap i Secret, iskoristićemo posebne mape. Tada ćemo moći da shvatimo koje metode su nam potrebne za praćenje i kreiranje objekta:

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

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

Zatim, potrebno je dobiti događaje od API servera. Ovo ćemo implementirati na sledeći način:

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

    # Dobijamo metodu za praćenje objekata
    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)

Nakon prijema događaja prelazimo na glavnu logiku obrade:

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

Glavna logika je gotova! Sada treba sve to upakovati u jedan Python paket. Oformiti ćemo datoteku setup.py, pišemo tamo metainformacije o projektu:

from sys import version_info

from setuptools import find_packages, setup

if version_info[:2] < (3, 5):
    raise RuntimeError(
        'Nepodržana verzija pythona %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),
        ]
    }
)

NB: Kubernetes klijent za Python ima svoje verzionisanje. Više o kompatibilnosti verzija klijenta i verzija Kubernetes-a možete saznati iz matrice kompatibilnosti.

Sada naš projekat izgleda ovako:

copyrator
├── copyrator
│   ├── cli.py # Logika rada sa komandnom linijom
│   ├── constant.py # Konstantne vrednosti koje smo naveli ranije
│   ├── load_crd.py # Logika učitavanja CRD
│   └── operator.py # Glavna logika rada operatora
└── setup.py # Oformljivanje paketa

Docker i Helm

Dockerfile će biti do besmisla jednostavan: uzimamo osnovnu sliku python-alpine i instaliramo naš paket. Njegovu optimizaciju odlažemo za bolje vreme:

FROM python:3.7.3-alpine3.9

ADD . /app

RUN pip3 install /app

ENTRYPOINT ["copyrator"]

Implementacija za operatera je također vrlo jednostavna:

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

Na kraju, potrebno je stvoriti odgovarajuću ulogu za operatera s potrebnim pravima:

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

Zaključak

Tako, bez straha, prekoravanja i proučavanja Go jezika, uspjeli smo sastaviti vlastitog operatera za Kubernetes na Pythonu. Naravno, još ima prostora za napredak: u budućnosti će moći obraditi više pravila, raditi u više niti, samostalno pratiti promjene svojih CRD-a…

Kako bismo se bolje upoznali s kodom, smjestili smo ga u javni repozitorij. Ako želite primjere ozbiljnijih operatera, implementiranih pomoću Pythona, možete obratiti pažnju na dva operatera za postavljanje mongodb (prvi i drugi).

P.S. Ako vam se ne da mučiti s događajima Kubernetesa ili vam je jednostavno ugodnije koristiti Bash — naši kolege su pripremili gotovo rješenje u obliku shell-operator (mi su najavili smo ga u aprilu).

P.P.S.

Takođe pročitajte na našem blogu:

Izvor: habr.com

Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere 🔥 Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere | ProHoster