ఫ్రేమ్‌వర్క్‌లు మరియు SDK లేకుండా పైథాన్‌లో 🥇Kubernetes ఆపరేటర్

ప్రజలు కుబెర్నెట్స్ కోసం స్టేట్‌మెంట్‌లను వ్రాయడానికి ఎంచుకున్న ప్రోగ్రామింగ్ భాషలపై Go ప్రస్తుతం గుత్తాధిపత్యాన్ని కలిగి ఉంది. దీనికి ఆబ్జెక్టివ్ కారణాలు ఉన్నాయి, అవి:

గోలో ఆపరేటర్‌లను అభివృద్ధి చేయడానికి శక్తివంతమైన ఫ్రేమ్‌వర్క్ ఉంది - ఆపరేటర్ SDK.
Docker మరియు Kubernetes వంటి గేమ్-మారుతున్న అప్లికేషన్లు Goలో వ్రాయబడ్డాయి. గోలో మీ ఆపరేటర్‌ని వ్రాయడం అంటే పర్యావరణ వ్యవస్థతో ఒకే భాష మాట్లాడటం.
Go అప్లికేషన్‌ల యొక్క అధిక పనితీరు మరియు బాక్స్ వెలుపల ఏకాగ్రతతో పని చేయడానికి సులభమైన సాధనాలు.

NB: మార్గం ద్వారా, గోలో మీ స్వంత ప్రకటనను ఎలా వ్రాయాలి, మేము ఇప్పటికే వివరించబడింది విదేశీ రచయితల ద్వారా మా అనువాదాలలో ఒకటి.

కానీ మీరు సమయం లేకపోవటం వల్ల లేదా కేవలం ప్రేరణతో గో నేర్చుకోవడం నుండి నిరోధించబడితే ఏమి చేయాలి? దాదాపు ప్రతి DevOps ఇంజనీర్‌కు తెలిసిన అత్యంత జనాదరణ పొందిన భాషలలో ఒకదానిని ఉపయోగించి మీరు మంచి స్టేట్‌మెంట్‌ను ఎలా వ్రాయవచ్చో ఈ కథనం ఒక ఉదాహరణను అందిస్తుంది - పైథాన్.

మీట్: కాపీయర్ - కాపీ ఆపరేటర్!

ఒక ఉదాహరణగా, ఒక కొత్త నేమ్‌స్పేస్ కనిపించినప్పుడు లేదా రెండు ఎంటిటీలలో ఒకటి మారినప్పుడు కాన్ఫిగ్మ్యాప్‌ను కాపీ చేయడానికి రూపొందించిన సాధారణ స్టేట్‌మెంట్‌ను అభివృద్ధి చేయడాన్ని పరిగణించండి: కాన్ఫిగ్మ్యాప్ మరియు సీక్రెట్. ఆచరణాత్మక దృక్కోణం నుండి, ఆపరేటర్ అప్లికేషన్ కాన్ఫిగరేషన్‌లను బల్క్ అప్‌డేట్ చేయడానికి (కాన్ఫిగమ్యాప్‌ను అప్‌డేట్ చేయడం ద్వారా) లేదా రహస్య డేటాను అప్‌డేట్ చేయడానికి ఉపయోగపడుతుంది - ఉదాహరణకు, డాకర్ రిజిస్ట్రీతో పని చేయడానికి కీలు (నేమ్‌స్పేస్‌కు రహస్యాన్ని జోడించేటప్పుడు).

కాబట్టి, మంచి ఆపరేటర్‌కి ఏమి ఉండాలి:

ఆపరేటర్‌తో పరస్పర చర్య ఉపయోగించి నిర్వహించబడుతుంది కస్టమ్ రిసోర్స్ నిర్వచనాలు (ఇకపై CRD గా సూచిస్తారు).
ఆపరేటర్‌ను కాన్ఫిగర్ చేయవచ్చు. దీన్ని చేయడానికి, మేము కమాండ్ లైన్ ఫ్లాగ్స్ మరియు ఎన్విరాన్మెంట్ వేరియబుల్స్ ఉపయోగిస్తాము.
డాకర్ కంటైనర్ మరియు హెల్మ్ చార్ట్ యొక్క బిల్డ్ రూపొందించబడింది, తద్వారా వినియోగదారులు తమ కుబెర్నెట్స్ క్లస్టర్‌లో ఆపరేటర్‌ను సులభంగా (వాచ్యంగా ఒక ఆదేశంతో) ఇన్‌స్టాల్ చేసుకోవచ్చు.

CRD

ఆపరేటర్ ఏ వనరులను వెతకాలి మరియు ఎక్కడ చూడాలో తెలుసుకోవాలంటే, మేము అతని కోసం ఒక నియమాన్ని సెట్ చేయాలి. ప్రతి నియమం ఒకే CRD వస్తువుగా సూచించబడుతుంది. ఈ CRD ఏ ఫీల్డ్‌లను కలిగి ఉండాలి?

వనరుల రకం, దీని కోసం మనం చూస్తాము (కాన్ఫిగ్ మ్యాప్ లేదా సీక్రెట్).
నేమ్‌స్పేస్‌ల జాబితా, దీనిలో వనరులు ఉండాలి.
సెలెక్టర్, దీని ద్వారా మనం నేమ్‌స్పేస్‌లో వనరుల కోసం శోధిస్తాము.

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 వంటి లేబుల్‌లతో అన్ని కాన్ఫిగ్‌మ్యాప్ copyrator: "true":

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

సిద్ధంగా ఉంది! ఇప్పుడు మనం ఏదో ఒకవిధంగా మన పాలన గురించి సమాచారాన్ని పొందాలి. క్లస్టర్ API సర్వర్‌కు మనమే అభ్యర్థనలను వ్రాయబోమని వెంటనే రిజర్వేషన్ చేయనివ్వండి. దీన్ని చేయడానికి, మేము రెడీమేడ్ పైథాన్ లైబ్రరీని ఉపయోగిస్తాము 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']}

గొప్పది: మేము ఆపరేటర్ కోసం ఒక నియమాన్ని పొందగలిగాము. మరియు ముఖ్యంగా, మేము కుబెర్నెట్స్ మార్గం అని పిలవబడేదాన్ని చేసాము.

ఎన్విరాన్‌మెంట్ వేరియబుల్స్ లేదా ఫ్లాగ్‌లు? మేము ప్రతిదీ తీసుకుంటాము!

ప్రధాన ఆపరేటర్ కాన్ఫిగరేషన్‌కు వెళ్దాం. అప్లికేషన్లను కాన్ఫిగర్ చేయడానికి రెండు ప్రాథమిక విధానాలు ఉన్నాయి:

కమాండ్ లైన్ ఎంపికలను ఉపయోగించండి;
పర్యావరణ వేరియబుల్స్ ఉపయోగించండి.

కమాండ్ లైన్ ఎంపికలు డేటా రకం మద్దతు మరియు ధ్రువీకరణతో సెట్టింగ్‌లను మరింత సరళంగా చదవడానికి మిమ్మల్ని అనుమతిస్తాయి. పైథాన్ యొక్క ప్రామాణిక లైబ్రరీలో మాడ్యూల్ ఉంది 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()

మరోవైపు, కుబెర్నెట్స్‌లోని ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ని ఉపయోగించి, మీరు కంటైనర్‌లోని పాడ్ గురించి సేవా సమాచారాన్ని సులభంగా బదిలీ చేయవచ్చు. ఉదాహరణకు, కింది నిర్మాణంతో పాడ్ నడుస్తున్న నేమ్‌స్పేస్ గురించి సమాచారాన్ని మనం పొందవచ్చు:

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

ఆపరేటర్ లాజిక్

కాన్ఫిగ్‌మ్యాప్ మరియు సీక్రెట్‌తో పని చేయడానికి పద్ధతులను ఎలా వేరు చేయాలో అర్థం చేసుకోవడానికి, మేము ప్రత్యేక మ్యాప్‌లను ఉపయోగిస్తాము. ఆబ్జెక్ట్‌ను ట్రాక్ చేయడానికి మరియు సృష్టించడానికి మనకు ఏ పద్ధతులు అవసరమో మనం అర్థం చేసుకోవచ్చు:

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)

ప్రధాన తర్కం సిద్ధంగా ఉంది! ఇప్పుడు మనం వీటన్నింటినీ ఒక పైథాన్ ప్యాకేజీగా ప్యాక్ చేయాలి. మేము ఫైల్ను సిద్ధం చేస్తాము 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 క్లయింట్ దాని స్వంత సంస్కరణను కలిగి ఉంది. క్లయింట్ వెర్షన్‌లు మరియు కుబెర్నెటెస్ వెర్షన్‌ల మధ్య అనుకూలత గురించి మరింత సమాచారం చూడవచ్చు అనుకూలత మాత్రికలు.

ఇప్పుడు మా ప్రాజెక్ట్ ఇలా కనిపిస్తుంది:

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

డాకర్ మరియు హెల్మ్

డాకర్‌ఫైల్ చాలా సరళంగా ఉంటుంది: బేస్ పైథాన్-ఆల్పైన్ ఇమేజ్‌ని తీసుకుని, మా ప్యాకేజీని ఇన్‌స్టాల్ చేయండి. మంచి సమయాల వరకు దాని ఆప్టిమైజేషన్‌ను వాయిదా వేద్దాం:

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

ఫలితం

ఆ విధంగా, భయం, నిందలు లేదా గో నేర్చుకోవడం లేకుండా, మేము పైథాన్‌లో కుబెర్నెట్స్ కోసం మా స్వంత ఆపరేటర్‌ని నిర్మించగలిగాము. వాస్తవానికి, ఇది ఇంకా పెరగడానికి స్థలం ఉంది: భవిష్యత్తులో ఇది బహుళ నియమాలను ప్రాసెస్ చేయగలదు, బహుళ థ్రెడ్‌లలో పని చేస్తుంది, దాని CRDలలో మార్పులను స్వతంత్రంగా పర్యవేక్షించగలదు...

మీకు కోడ్‌ని నిశితంగా పరిశీలించడానికి, మేము దానిని ఉంచాము పబ్లిక్ రిపోజిటరీ. పైథాన్‌ని ఉపయోగించి అమలు చేయబడిన మరింత తీవ్రమైన ఆపరేటర్‌ల ఉదాహరణలు మీకు కావాలంటే, మీరు mongodbని అమలు చేయడానికి మీ దృష్టిని ఇద్దరు ఆపరేటర్‌ల వైపు మళ్లించవచ్చు (మొదటిది и రెండవది).

PS మరియు మీరు కుబెర్నెటెస్ ఈవెంట్‌లను ఎదుర్కోవడంలో చాలా సోమరిగా ఉన్నట్లయితే లేదా మీరు బాష్‌ని ఉపయోగించడం మరింత అలవాటు చేసుకున్నట్లయితే, మా సహోద్యోగులు రూపంలో రెడీమేడ్ పరిష్కారాన్ని సిద్ధం చేశారు. షెల్-ఆపరేటర్ (మేము ప్రకటించారు అది ఏప్రిల్‌లో).

PPS

మా బ్లాగులో కూడా చదవండి:

మూలం: www.habr.com

ఫ్రేమ్‌వర్క్‌లు మరియు SDK లేకుండా పైథాన్‌లో Kubernetes ఆపరేటర్

మీట్: కాపీయర్ - కాపీ ఆపరేటర్!

CRD

ఎన్విరాన్‌మెంట్ వేరియబుల్స్ లేదా ఫ్లాగ్‌లు? మేము ప్రతిదీ తీసుకుంటాము!

ఆపరేటర్ లాజిక్

డాకర్ మరియు హెల్మ్

ఫలితం

PPS

ఒక వ్యాఖ్యను జోడించండి

ఫ్రేమ్‌వర్క్‌లు మరియు SDK లేకుండా పైథాన్‌లో Kubernetes ఆపరేటర్

మీట్: కాపీయర్ - కాపీ ఆపరేటర్!

CRD

ఎన్విరాన్‌మెంట్ వేరియబుల్స్ లేదా ఫ్లాగ్‌లు? మేము ప్రతిదీ తీసుకుంటాము!

ఆపరేటర్ లాజిక్

డాకర్ మరియు హెల్మ్

ఫలితం

PPS

ఒక వ్యాఖ్యను జోడించండి ప్రత్యుత్తరం రద్దు

ఒక వ్యాఖ్యను జోడించండి