ಚೌಕಟ್ಟುಗಳು ಮತ್ತು SDK ಇಲ್ಲದೆ ಪೈಥಾನ್‌ನಲ್ಲಿ ಕುಬರ್ನೆಟ್ಸ್ ಆಪರೇಟರ್

ಜನರು ಕುಬರ್ನೆಟ್ಸ್‌ಗಾಗಿ ಹೇಳಿಕೆಗಳನ್ನು ಬರೆಯಲು ಆಯ್ಕೆಮಾಡುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳ ಮೇಲೆ Go ಪ್ರಸ್ತುತ ಏಕಸ್ವಾಮ್ಯವನ್ನು ಹೊಂದಿದೆ. ಇದಕ್ಕೆ ವಸ್ತುನಿಷ್ಠ ಕಾರಣಗಳಿವೆ, ಉದಾಹರಣೆಗೆ:

1. Go ನಲ್ಲಿ ನಿರ್ವಾಹಕರನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಪ್ರಬಲ ಚೌಕಟ್ಟನ್ನು ಹೊಂದಿದೆ - ಆಪರೇಟರ್ SDK.
2. Docker ಮತ್ತು Kubernetes ನಂತಹ ಆಟವನ್ನು ಬದಲಾಯಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು Go ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ನಿಮ್ಮ ಆಪರೇಟರ್ ಅನ್ನು ಗೋದಲ್ಲಿ ಬರೆಯುವುದು ಎಂದರೆ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಅದೇ ಭಾಷೆಯನ್ನು ಮಾತನಾಡುವುದು ಎಂದರ್ಥ.
3. Go ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಪೆಟ್ಟಿಗೆಯ ಹೊರಗೆ ಏಕಕಾಲಿಕವಾಗಿ ಕೆಲಸ ಮಾಡಲು ಸರಳ ಸಾಧನಗಳು.

NB: ಮೂಲಕ, ಗೋದಲ್ಲಿ ನಿಮ್ಮ ಸ್ವಂತ ಹೇಳಿಕೆಯನ್ನು ಹೇಗೆ ಬರೆಯುವುದು, ನಾವು ಈಗಾಗಲೇ ವಿವರಿಸಲಾಗಿದೆ ವಿದೇಶಿ ಲೇಖಕರ ನಮ್ಮ ಅನುವಾದಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿ.

ಆದರೆ ಸಮಯದ ಕೊರತೆಯಿಂದ ಅಥವಾ ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಪ್ರೇರಣೆಯಿಂದ ನೀವು ಗೋ ಕಲಿಯುವುದನ್ನು ತಡೆಯುತ್ತಿದ್ದರೆ ಏನು? ಪ್ರತಿಯೊಂದು DevOps ಇಂಜಿನಿಯರ್‌ಗೆ ತಿಳಿದಿರುವ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಭಾಷೆಗಳಲ್ಲಿ ಒಂದನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಹೇಗೆ ಉತ್ತಮ ಹೇಳಿಕೆಯನ್ನು ಬರೆಯಬಹುದು ಎಂಬುದಕ್ಕೆ ಲೇಖನವು ಒಂದು ಉದಾಹರಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ - ಪೈಥಾನ್.

ಭೇಟಿ: ಕಾಪಿಯರ್ - ಕಾಪಿ ಆಪರೇಟರ್!

ಉದಾಹರಣೆಯಾಗಿ, ಹೊಸ ನೇಮ್‌ಸ್ಪೇಸ್ ಕಾಣಿಸಿಕೊಂಡಾಗ ಅಥವಾ ಎರಡು ಘಟಕಗಳಲ್ಲಿ ಒಂದನ್ನು ಬದಲಾಯಿಸಿದಾಗ ಕಾನ್ಫಿಗ್‌ಮ್ಯಾಪ್ ಅನ್ನು ನಕಲಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಸರಳ ಹೇಳಿಕೆಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ: ಕಾನ್ಫಿಗ್‌ಮ್ಯಾಪ್ ಮತ್ತು ಸೀಕ್ರೆಟ್. ಪ್ರಾಯೋಗಿಕ ದೃಷ್ಟಿಕೋನದಿಂದ, ಅಪ್ಲಿಕೇಶನ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ಬೃಹತ್ ನವೀಕರಣಕ್ಕಾಗಿ (ಕಾನ್ಫಿಗ್‌ಮ್ಯಾಪ್ ಅನ್ನು ನವೀಕರಿಸುವ ಮೂಲಕ) ಅಥವಾ ರಹಸ್ಯ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಲು ಆಪರೇಟರ್ ಉಪಯುಕ್ತವಾಗಬಹುದು - ಉದಾಹರಣೆಗೆ, ಡಾಕರ್ ರಿಜಿಸ್ಟ್ರಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಕೀಗಳು (ನೇಮ್‌ಸ್ಪೇಸ್‌ಗೆ ರಹಸ್ಯವನ್ನು ಸೇರಿಸುವಾಗ).

ಆದ್ದರಿಂದ, ಉತ್ತಮ ಆಪರೇಟರ್ ಏನು ಹೊಂದಿರಬೇಕು:

1. ಆಪರೇಟರ್ನೊಂದಿಗಿನ ಸಂವಹನವನ್ನು ಬಳಸಿಕೊಂಡು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ ಕಸ್ಟಮ್ ಸಂಪನ್ಮೂಲ ವ್ಯಾಖ್ಯಾನಗಳು (ಇನ್ನು ಮುಂದೆ CRD ಎಂದು ಉಲ್ಲೇಖಿಸಲಾಗುತ್ತದೆ).
2. ಆಪರೇಟರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಆಜ್ಞಾ ಸಾಲಿನ ಫ್ಲ್ಯಾಗ್‌ಗಳು ಮತ್ತು ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.
3. ಡಾಕರ್ ಕಂಟೇನರ್ ಮತ್ತು ಹೆಲ್ಮ್ ಚಾರ್ಟ್‌ನ ನಿರ್ಮಾಣವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಇದರಿಂದ ಬಳಕೆದಾರರು ಸುಲಭವಾಗಿ (ಅಕ್ಷರಶಃ ಒಂದು ಆಜ್ಞೆಯೊಂದಿಗೆ) ಆಪರೇಟರ್ ಅನ್ನು ತಮ್ಮ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ಸ್ಥಾಪಿಸಬಹುದು.

ಸಿಆರ್ಡಿ

ಆಪರೇಟರ್‌ಗೆ ಯಾವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹುಡುಕಬೇಕು ಮತ್ತು ಎಲ್ಲಿ ನೋಡಬೇಕು ಎಂದು ತಿಳಿಯಲು, ನಾವು ಅವನಿಗೆ ನಿಯಮವನ್ನು ಹೊಂದಿಸಬೇಕಾಗಿದೆ. ಪ್ರತಿಯೊಂದು ನಿಯಮವನ್ನು ಒಂದೇ CRD ವಸ್ತುವಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ. ಈ 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 ಸರ್ವರ್‌ಗೆ ನಾವು ವಿನಂತಿಗಳನ್ನು ಬರೆಯುವುದಿಲ್ಲ ಎಂದು ಈಗಿನಿಂದಲೇ ಕಾಯ್ದಿರಿಸೋಣ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಸಿದ್ಧ ಪೈಥಾನ್ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತೇವೆ ಕುಬರ್ನೆಟ್ಸ್-ಕ್ಲೈಂಟ್:

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 

ಆಪರೇಟರ್ ತರ್ಕ

ಕಾನ್ಫಿಗ್ಮ್ಯಾಪ್ ಮತ್ತು ಸೀಕ್ರೆಟ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ವಿಧಾನಗಳನ್ನು ಹೇಗೆ ಪ್ರತ್ಯೇಕಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ನಾವು ವಿಶೇಷ ನಕ್ಷೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮತ್ತು ರಚಿಸಲು ನಮಗೆ ಯಾವ ವಿಧಾನಗಳು ಬೇಕಾಗುತ್ತವೆ ಎಂಬುದನ್ನು ನಾವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು:

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: ಪೈಥಾನ್‌ಗಾಗಿ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲೈಂಟ್ ತನ್ನದೇ ಆದ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿದೆ. ಕ್ಲೈಂಟ್ ಆವೃತ್ತಿಗಳು ಮತ್ತು ಕುಬರ್ನೆಟ್ಸ್ ಆವೃತ್ತಿಗಳ ನಡುವಿನ ಹೊಂದಾಣಿಕೆಯ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ಕಾಣಬಹುದು ಹೊಂದಾಣಿಕೆಯ ಮ್ಯಾಟ್ರಿಕ್ಸ್.

ಈಗ ನಮ್ಮ ಯೋಜನೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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 ಅನ್ನು ನಿಯೋಜಿಸಲು ನಿಮ್ಮ ಗಮನವನ್ನು ಎರಡು ಆಪರೇಟರ್‌ಗಳತ್ತ ತಿರುಗಿಸಬಹುದು (первый и ಎರಡನೆಯದು).

ಪಿಎಸ್ ಮತ್ತು ನೀವು ಕುಬರ್ನೆಟ್ ಈವೆಂಟ್‌ಗಳನ್ನು ಎದುರಿಸಲು ತುಂಬಾ ಸೋಮಾರಿಯಾಗಿದ್ದರೆ ಅಥವಾ ನೀವು ಬ್ಯಾಷ್ ಅನ್ನು ಬಳಸಲು ಹೆಚ್ಚು ಒಗ್ಗಿಕೊಂಡಿದ್ದರೆ, ನಮ್ಮ ಸಹೋದ್ಯೋಗಿಗಳು ರೂಪದಲ್ಲಿ ಸಿದ್ಧ ಪರಿಹಾರವನ್ನು ಸಿದ್ಧಪಡಿಸಿದ್ದಾರೆ ಶೆಲ್-ಆಪರೇಟರ್ (ನಾವು ಘೋಷಿಸಲಾಗಿದೆ ಇದು ಏಪ್ರಿಲ್ನಲ್ಲಿ).

ಪಿಪಿಎಸ್

ನಮ್ಮ ಬ್ಲಾಗ್‌ನಲ್ಲಿಯೂ ಓದಿ:

• «ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು ಸುಲಭ ಮತ್ತು ಅನುಕೂಲಕರವಾಗಿದೆಯೇ? addon-operator ಅನ್ನು ಪ್ರಕಟಿಸಲಾಗುತ್ತಿದೆ";
• «ಶೆಲ್-ಆಪರೇಟರ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ: ಕುಬರ್ನೆಟ್ಸ್‌ಗಾಗಿ ಆಪರೇಟರ್‌ಗಳನ್ನು ರಚಿಸುವುದು ಈಗ ಸುಲಭವಾಗಿದೆ";
• «ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ವಿಸ್ತರಿಸುವುದು ಮತ್ತು ಪೂರಕಗೊಳಿಸುವುದು (ವಿಮರ್ಶೆ ಮತ್ತು ವೀಡಿಯೊ ವರದಿ)";
• «ಗೊಲಾಂಗ್‌ನಲ್ಲಿ ಕುಬರ್ನೆಟ್ಸ್‌ಗೆ ಆಪರೇಟರ್ ಬರೆಯುವುದು";
• «ಕುಬರ್ನೆಟ್ಸ್‌ಗಾಗಿ ಆಪರೇಟರ್‌ಗಳು: ಸ್ಟೇಟ್‌ಫುಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೇಗೆ ಚಲಾಯಿಸುವುದು».

ಮೂಲ: www.habr.com