ફ્રેમવર્ક અને SDK વિના પાયથોનમાં કુબરનેટ્સ ઓપરેટર

Go હાલમાં પ્રોગ્રામિંગ ભાષાઓ પર એકાધિકાર ધરાવે છે જે લોકો કુબરનેટ્સ માટે નિવેદનો લખવાનું પસંદ કરે છે. આના માટે ઉદ્દેશ્ય કારણો છે, જેમ કે:

1. Go માં ઓપરેટરો વિકસાવવા માટે એક શક્તિશાળી માળખું છે - ઓપરેટર SDK.
2. Docker અને Kubernetes જેવી રમત-બદલતી એપ્લિકેશનો Go માં લખેલી છે. Go માં તમારા ઓપરેટરને લખવાનો અર્થ એ છે કે ઇકોસિસ્ટમ સાથે સમાન ભાષા બોલવી.
3. ગો એપ્લીકેશનનું ઉચ્ચ પ્રદર્શન અને બોક્સની બહાર સંમતિ સાથે કામ કરવા માટેના સરળ સાધનો.

NB: બાય ધ વે, ગોમાં તમારું પોતાનું સ્ટેટમેન્ટ કેવી રીતે લખવું, અમે પહેલેથી જ વર્ણવેલ છે વિદેશી લેખકો દ્વારા અમારા અનુવાદોમાંના એકમાં.

પરંતુ જો તમને સમયના અભાવે અથવા, સરળ શબ્દોમાં કહીએ તો, પ્રેરણાથી ગો શીખવાથી અટકાવવામાં આવે તો શું? આ લેખ એક ઉદાહરણ પૂરું પાડે છે કે તમે કેવી રીતે એક સૌથી લોકપ્રિય ભાષાનો ઉપયોગ કરીને સારું નિવેદન લખી શકો છો જે લગભગ દરેક DevOps એન્જિનિયર જાણે છે - પાયથોન.

મળો: કૉપિયર - કૉપિ ઑપરેટર!

ઉદાહરણ તરીકે, જ્યારે નવું નેમસ્પેસ દેખાય અથવા જ્યારે બે એન્ટિટીમાં ફેરફાર થાય ત્યારે કોન્ફિગમેપની નકલ કરવા માટે રચાયેલ એક સરળ નિવેદન વિકસાવવાનું વિચારો: કોન્ફિગમેપ અને સિક્રેટ. વ્યવહારિક દૃષ્ટિકોણથી, ઑપરેટર એપ્લિકેશન રૂપરેખાંકનોના જથ્થાબંધ અપડેટ માટે (કોન્ફિગમેપ અપડેટ કરીને) અથવા ગુપ્ત ડેટાને અપડેટ કરવા માટે ઉપયોગી થઈ શકે છે - ઉદાહરણ તરીકે, ડોકર રજિસ્ટ્રી સાથે કામ કરવા માટેની ચાવીઓ (નેમસ્પેસમાં સિક્રેટ ઉમેરતી વખતે).

અને તેથી, એક સારા ઓપરેટર પાસે શું હોવું જોઈએ:

1. નો ઉપયોગ કરીને ઓપરેટર સાથેની ક્રિયાપ્રતિક્રિયા હાથ ધરવામાં આવે છે કસ્ટમ સંસાધન વ્યાખ્યાઓ (ત્યારબાદ CRD તરીકે ઓળખવામાં આવે છે).
2. ઓપરેટર રૂપરેખાંકિત કરી શકાય છે. આ કરવા માટે, અમે કમાન્ડ લાઇન ફ્લેગ્સ અને પર્યાવરણ વેરીએબલનો ઉપયોગ કરીશું.
3. ડોકર કન્ટેનર અને હેલ્મ ચાર્ટનું બિલ્ડ ડિઝાઇન કરવામાં આવ્યું છે જેથી વપરાશકર્તાઓ સરળતાથી (શાબ્દિક રીતે એક આદેશ સાથે) ઓપરેટરને તેમના કુબરનેટ્સ ક્લસ્ટરમાં ઇન્સ્ટોલ કરી શકે.

સીઆરડી

ઑપરેટરને જાણવા માટે કે કયા સંસાધનોની શોધ કરવી અને ક્યાં જોવું, આપણે તેના માટે એક નિયમ સેટ કરવાની જરૂર છે. દરેક નિયમને એક જ CRD ઑબ્જેક્ટ તરીકે રજૂ કરવામાં આવશે. આ સીઆરડીમાં કયા ક્ષેત્રો હોવા જોઈએ?

1. સંસાધન પ્રકાર, જે આપણે શોધીશું (કોન્ફિગમેપ અથવા સિક્રેટ).
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 જેવા લેબલ્સ સાથે તમામ કોન્ફિગમેપ 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']}

સરસ: અમે ઓપરેટર માટે એક નિયમ મેળવવામાં વ્યવસ્થાપિત છીએ. અને સૌથી અગત્યનું, અમે તે કર્યું જે કુબરનેટીસ માર્ગ કહેવાય છે.

પર્યાવરણ ચલો અથવા ધ્વજ? અમે બધું લઈએ છીએ!

ચાલો મુખ્ય ઓપરેટર રૂપરેખાંકન પર આગળ વધીએ. એપ્લિકેશનને ગોઠવવા માટે બે મૂળભૂત અભિગમો છે:

1. આદેશ વાક્ય વિકલ્પોનો ઉપયોગ કરો;
2. પર્યાવરણ ચલોનો ઉપયોગ કરો.

આદેશ વાક્ય વિકલ્પો તમને ડેટા પ્રકાર સપોર્ટ અને માન્યતા સાથે સેટિંગ્સને વધુ લવચીક રીતે વાંચવાની મંજૂરી આપે છે. પાયથોનની સ્ટાન્ડર્ડ લાઇબ્રેરીમાં મોડ્યુલ છે 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 

ઓપરેટર તર્ક

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)

મુખ્ય તર્ક તૈયાર છે! હવે આપણે આ બધાને એક પાયથોન પેકેજમાં પેક કરવાની જરૂર છે. અમે ફાઇલ તૈયાર કરીએ છીએ 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: Python માટે 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 }}

પરિણામ

આ રીતે, ડર, નિંદા અથવા ગો શીખ્યા વિના, અમે પાયથોનમાં કુબરનેટ્સ માટે અમારું પોતાનું ઓપરેટર બનાવવામાં સક્ષમ હતા. અલબત્ત, તેમાં હજુ પણ વૃદ્ધિ માટે જગ્યા છે: ભવિષ્યમાં તે બહુવિધ નિયમો પર પ્રક્રિયા કરી શકશે, બહુવિધ થ્રેડોમાં કામ કરી શકશે, સ્વતંત્ર રીતે તેના CRDsમાં ફેરફારોનું નિરીક્ષણ કરી શકશે...

તમને કોડને નજીકથી જોવા માટે, અમે તેને મૂક્યો છે જાહેર ભંડાર. જો તમે પાયથોનનો ઉપયોગ કરીને અમલમાં મૂકાયેલા વધુ ગંભીર ઓપરેટરોના ઉદાહરણો ઇચ્છતા હો, તો તમે મોંગોડબી (первый и બીજા).

PS અને જો તમે કુબરનેટીસ ઇવેન્ટ્સ સાથે વ્યવહાર કરવામાં ખૂબ આળસુ છો અથવા તમે બૅશનો ઉપયોગ કરવા માટે વધુ ટેવાયેલા છો, તો અમારા સાથીદારોએ ફોર્મમાં તૈયાર ઉકેલ તૈયાર કર્યો છે. શેલ-ઓપરેટર (અમે જાહેરાત કરી તે એપ્રિલમાં).

પી.પી.એસ.

અમારા બ્લોગ પર પણ વાંચો:

• «શું કુબરનેટ્સ ક્લસ્ટર તૈયાર કરવું સરળ અને અનુકૂળ છે? એડઓન-ઓપરેટરની જાહેરાત»;
• «શેલ-ઓપરેટરનો પરિચય: કુબરનેટ્સ માટે ઓપરેટર બનાવવાનું સરળ બન્યું છે»;
• «કુબરનેટ્સનું વિસ્તરણ અને પૂરક (વિહંગાવલોકન અને વિડિયો રિપોર્ટ)»;
• «ગોલાંગમાં કુબરનેટ્સ માટે ઓપરેટર લખવું»;
• «કુબરનેટ્સ માટે ઓપરેટર્સ: સ્ટેટફુલ એપ્લિકેશન કેવી રીતે ચલાવવી».

સોર્સ: www.habr.com