ചട്ടക്കൂടുകളും SDKയും ഇല്ലാതെ പൈത്തണിലെ Kubernetes ഓപ്പറേറ്റർ

ആളുകൾ കുബർനെറ്റസിനായി പ്രസ്താവനകൾ എഴുതാൻ തിരഞ്ഞെടുക്കുന്ന പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ Go- യ്ക്ക് നിലവിൽ കുത്തകയുണ്ട്. ഇതിന് വസ്തുനിഷ്ഠമായ കാരണങ്ങളുണ്ട്, ഉദാഹരണത്തിന്:

1. Go-യിൽ ഓപ്പറേറ്റർമാരെ വികസിപ്പിക്കുന്നതിന് ശക്തമായ ഒരു ചട്ടക്കൂട് ഉണ്ട് - ഓപ്പറേറ്റർ എസ്.ഡി.കെ.
2. Docker, Kubernetes പോലുള്ള ഗെയിം മാറ്റുന്ന ആപ്ലിക്കേഷനുകൾ Go-യിൽ എഴുതിയിരിക്കുന്നു. Go-യിൽ നിങ്ങളുടെ ഓപ്പറേറ്ററെ എഴുതുക എന്നതിനർത്ഥം ആവാസവ്യവസ്ഥയുമായി ഒരേ ഭാഷ സംസാരിക്കുക എന്നാണ്.
3. Go ആപ്ലിക്കേഷനുകളുടെ ഉയർന്ന പ്രകടനവും ബോക്‌സിന് പുറത്ത് സമവായത്തിൽ പ്രവർത്തിക്കുന്നതിനുള്ള ലളിതമായ ഉപകരണങ്ങളും.

NB: വഴിയിൽ, Go- ൽ നിങ്ങളുടെ സ്വന്തം പ്രസ്താവന എങ്ങനെ എഴുതാം, ഞങ്ങൾ ഇതിനകം വിവരിച്ചിരിക്കുന്നു വിദേശ എഴുത്തുകാരുടെ ഞങ്ങളുടെ വിവർത്തനങ്ങളിലൊന്നിൽ.

എന്നാൽ സമയക്കുറവോ ലളിതമായി പറഞ്ഞാൽ പ്രേരണയോ കാരണം Go പഠിക്കുന്നതിൽ നിന്ന് നിങ്ങളെ തടയുന്നെങ്കിലോ? മിക്കവാറും എല്ലാ DevOps എഞ്ചിനീയർക്കും അറിയാവുന്ന ഏറ്റവും ജനപ്രിയമായ ഭാഷകളിലൊന്ന് ഉപയോഗിച്ച് നിങ്ങൾക്ക് എങ്ങനെ ഒരു നല്ല പ്രസ്താവന എഴുതാം എന്നതിന്റെ ഒരു ഉദാഹരണം ലേഖനം നൽകുന്നു - പൈത്തൺ.

മീറ്റ്: കോപ്പിയർ - കോപ്പി ഓപ്പറേറ്റർ!

ഒരു ഉദാഹരണമായി, ഒരു പുതിയ നെയിംസ്‌പെയ്‌സ് ദൃശ്യമാകുമ്പോഴോ അല്ലെങ്കിൽ രണ്ട് എന്റിറ്റികളിൽ ഒന്ന് മാറുമ്പോഴോ കോൺഫിഗ്മാപ്പ് പകർത്താൻ രൂപകൽപ്പന ചെയ്‌ത ലളിതമായ ഒരു പ്രസ്താവന വികസിപ്പിക്കുന്നത് പരിഗണിക്കുക: കോൺഫിഗ്മാപ്പും രഹസ്യവും. ഒരു പ്രായോഗിക കാഴ്ചപ്പാടിൽ, ആപ്ലിക്കേഷൻ കോൺഫിഗറേഷനുകളുടെ ബൾക്ക് അപ്ഡേറ്റ് ചെയ്യുന്നതിനോ (കോൺഫിഗ്മാപ്പ് അപ്ഡേറ്റ് ചെയ്യുന്നതിലൂടെ) അല്ലെങ്കിൽ രഹസ്യ ഡാറ്റ അപ്ഡേറ്റ് ചെയ്യുന്നതിനോ ഓപ്പറേറ്റർക്ക് ഉപയോഗപ്രദമാകും - ഉദാഹരണത്തിന്, ഡോക്കർ രജിസ്ട്രിയിൽ പ്രവർത്തിക്കുന്നതിനുള്ള കീകൾ (നെയിംസ്പേസിൽ രഹസ്യം ചേർക്കുമ്പോൾ).

അങ്ങനെയാണെങ്കിൽ, ഒരു നല്ല ഓപ്പറേറ്റർക്ക് എന്ത് വേണം:

1. ഓപ്പറേറ്ററുമായുള്ള ഇടപെടൽ ഉപയോഗിച്ചാണ് നടത്തുന്നത് കസ്റ്റം റിസോഴ്സ് നിർവചനങ്ങൾ (ഇനി CRD എന്നറിയപ്പെടുന്നു).
2. ഓപ്പറേറ്ററെ ക്രമീകരിക്കാൻ കഴിയും. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ കമാൻഡ് ലൈൻ ഫ്ലാഗുകളും പരിസ്ഥിതി വേരിയബിളുകളും ഉപയോഗിക്കും.
3. ഡോക്കർ കണ്ടെയ്‌നറിന്റെയും ഹെൽം ചാർട്ടിന്റെയും ബിൽഡ് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നതിനാൽ ഉപയോക്താക്കൾക്ക് അവരുടെ കുബർനെറ്റസ് ക്ലസ്റ്ററിലേക്ക് ഓപ്പറേറ്ററെ എളുപ്പത്തിൽ (അക്ഷരാർത്ഥത്തിൽ ഒരു കമാൻഡ് ഉപയോഗിച്ച്) ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും.

സി.ആർ.ഡി

എന്ത് ഉറവിടങ്ങളാണ് തിരയേണ്ടതെന്നും എവിടെയാണ് നോക്കേണ്ടതെന്നും ഓപ്പറേറ്റർക്ക് അറിയാൻ, ഞങ്ങൾ അവനുവേണ്ടി ഒരു നിയമം സജ്ജീകരിക്കേണ്ടതുണ്ട്. ഓരോ നിയമവും ഒരൊറ്റ CRD ഒബ്ജക്റ്റായി പ്രതിനിധീകരിക്കും. ഈ സിആർഡിക്ക് എന്ത് ഫീൽഡുകൾ ഉണ്ടായിരിക്കണം?

1. റിസോഴ്സ് തരം, ഞങ്ങൾ തിരയുന്ന (ConfigMap അല്ലെങ്കിൽ രഹസ്യം).
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-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')}

ഈ കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന്റെ ഫലമായി, നമുക്ക് ഇനിപ്പറയുന്നവ ലഭിക്കും:

{'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: പൈത്തണിനുള്ള kubernetes ക്ലയന്റിന് അതിന്റേതായ പതിപ്പ് ഉണ്ട്. ക്ലയന്റ് പതിപ്പുകളും കുബെർനെറ്റസ് പതിപ്പുകളും തമ്മിലുള്ള അനുയോജ്യതയെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ കണ്ടെത്താനാകും അനുയോജ്യത മെട്രിക്സ്.

ഇപ്പോൾ ഞങ്ങളുടെ പ്രോജക്റ്റ് ഇതുപോലെ കാണപ്പെടുന്നു:

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

ഡോക്കറും ഹെൽമും

Dockerfile അവിശ്വസനീയമാംവിധം ലളിതമായിരിക്കും: അടിസ്ഥാന പൈത്തൺ-ആൽപൈൻ ഇമേജ് എടുത്ത് ഞങ്ങളുടെ പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുക. നല്ല സമയം വരെ അതിന്റെ ഒപ്റ്റിമൈസേഷൻ മാറ്റിവയ്ക്കാം:

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 നിങ്ങൾക്ക് കുബർനെറ്റസ് ഇവന്റുകൾ കൈകാര്യം ചെയ്യാൻ മടിയാണെങ്കിലോ ബാഷ് ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് കൂടുതൽ ശീലമാണെങ്കിൽ, ഞങ്ങളുടെ സഹപ്രവർത്തകർ ഫോമിൽ ഒരു റെഡിമെയ്ഡ് പരിഹാരം തയ്യാറാക്കിയിട്ടുണ്ട്. ഷെൽ ഓപ്പറേറ്റർ (ഞങ്ങൾ പ്രഖ്യാപിച്ചു അത് ഏപ്രിലിൽ).

പിപിഎസ്

ഞങ്ങളുടെ ബ്ലോഗിലും വായിക്കുക:

• «ഒരു കുബർനെറ്റസ് ക്ലസ്റ്റർ തയ്യാറാക്കുന്നത് എളുപ്പവും സൗകര്യപ്രദവുമാണോ? ആഡ്-ഓപ്പറേറ്റർ പ്രഖ്യാപിക്കുന്നു";
• «ഷെൽ-ഓപ്പറേറ്റർ അവതരിപ്പിക്കുന്നു: കുബർനെറ്റസിനായി ഓപ്പറേറ്റർമാരെ സൃഷ്ടിക്കുന്നത് ഇപ്പോൾ എളുപ്പമായി";
• «കുബർനെറ്റസ് വികസിപ്പിക്കുകയും പൂരകമാക്കുകയും ചെയ്യുക (അവലോകനവും വീഡിയോ റിപ്പോർട്ടും)";
• «ഗോലാങ്ങിലെ കുബെർനെറ്റസിനായി ഒരു ഓപ്പറേറ്റർ എഴുതുന്നു";
• «കുബെർനെറ്റസിനായുള്ള ഓപ്പറേറ്റർമാർ: സ്റ്റേറ്റ്ഫുൾ ആപ്ലിക്കേഷനുകൾ എങ്ങനെ പ്രവർത്തിപ്പിക്കാം".

അവലംബം: www.habr.com