ਫ੍ਰੇਮਵਰਕ ਅਤੇ SDK ਤੋਂ ਬਿਨਾਂ ਪਾਈਥਨ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਓਪਰੇਟਰ

ਗੋ ਦਾ ਵਰਤਮਾਨ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ 'ਤੇ ਏਕਾਧਿਕਾਰ ਹੈ ਜੋ ਲੋਕ ਕੁਬਰਨੇਟਸ ਲਈ ਬਿਆਨ ਲਿਖਣ ਲਈ ਚੁਣਦੇ ਹਨ। ਇਸਦੇ ਬਾਹਰਮੁਖੀ ਕਾਰਨ ਹਨ, ਜਿਵੇਂ ਕਿ:

1. ਗੋ ਵਿੱਚ ਓਪਰੇਟਰਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਢਾਂਚਾ ਹੈ - ਓਪਰੇਟਰ SDK.
2. Docker ਅਤੇ Kubernetes ਵਰਗੀਆਂ ਗੇਮ ਬਦਲਣ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ Go ਵਿੱਚ ਲਿਖੀਆਂ ਗਈਆਂ ਹਨ। Go ਵਿੱਚ ਆਪਣੇ ਆਪਰੇਟਰ ਨੂੰ ਲਿਖਣ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਈਕੋਸਿਸਟਮ ਨਾਲ ਉਹੀ ਭਾਸ਼ਾ ਬੋਲਣੀ।
3. ਗੋ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦਾ ਉੱਚ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਬਾਕਸ ਦੇ ਬਾਹਰ ਇਕਸਾਰਤਾ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸਧਾਰਨ ਸਾਧਨ।

NB: ਤਰੀਕੇ ਨਾਲ, ਗੋ ਵਿੱਚ ਆਪਣਾ ਬਿਆਨ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ, ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਦੱਸਿਆ ਗਿਆ ਹੈ ਵਿਦੇਸ਼ੀ ਲੇਖਕਾਂ ਦੁਆਰਾ ਸਾਡੇ ਅਨੁਵਾਦਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ।

ਪਰ ਉਦੋਂ ਕੀ ਜੇ ਤੁਹਾਨੂੰ ਸਮੇਂ ਦੀ ਘਾਟ ਜਾਂ, ਸਿੱਧੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਪ੍ਰੇਰਣਾ ਦੁਆਰਾ ਸਿੱਖਣ ਤੋਂ ਰੋਕਿਆ ਜਾਂਦਾ ਹੈ? ਲੇਖ ਇੱਕ ਉਦਾਹਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵਧੀਆ ਬਿਆਨ ਕਿਵੇਂ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਲਗਭਗ ਹਰ DevOps ਇੰਜੀਨੀਅਰ ਜਾਣਦਾ ਹੈ - ਪਾਈਥਨ.

ਮਿਲੋ: ਕਾਪੀਰ - ਕਾਪੀ ਆਪਰੇਟਰ!

ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ 'ਤੇ, ਇੱਕ ਸਧਾਰਨ ਸਟੇਟਮੈਂਟ ਵਿਕਸਿਤ ਕਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ ਜੋ ਇੱਕ ConfigMap ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਤਾਂ ਜਦੋਂ ਇੱਕ ਨਵਾਂ ਨੇਮਸਪੇਸ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ ਜਾਂ ਜਦੋਂ ਦੋ ਸੰਸਥਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਦਲਦਾ ਹੈ: ConfigMap ਅਤੇ ਸੀਕਰੇਟ। ਵਿਹਾਰਕ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਓਪਰੇਟਰ ਐਪਲੀਕੇਸ਼ਨ ਕੌਂਫਿਗਰੇਸ਼ਨਾਂ (ਕਨਫਿਗਮੈਪ ਨੂੰ ਅੱਪਡੇਟ ਕਰਕੇ) ਦੇ ਬਲਕ ਅੱਪਡੇਟ ਕਰਨ ਜਾਂ ਗੁਪਤ ਡੇਟਾ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ - ਉਦਾਹਰਨ ਲਈ, ਡੌਕਰ ਰਜਿਸਟਰੀ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਕੁੰਜੀਆਂ (ਜਦੋਂ ਨੇਮਸਪੇਸ ਵਿੱਚ ਸੀਕਰੇਟ ਜੋੜਦੇ ਹੋਏ)।

ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ, ਇੱਕ ਚੰਗੇ ਆਪਰੇਟਰ ਕੋਲ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

1. ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਰੇਟਰ ਨਾਲ ਗੱਲਬਾਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਸਟਮ ਸਰੋਤ ਪਰਿਭਾਸ਼ਾਵਾਂ (ਇਸ ਤੋਂ ਬਾਅਦ CRD ਕਿਹਾ ਜਾਂਦਾ ਹੈ)।
2. ਆਪਰੇਟਰ ਨੂੰ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਕਮਾਂਡ ਲਾਈਨ ਫਲੈਗ ਅਤੇ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।
3. ਡੌਕਰ ਕੰਟੇਨਰ ਅਤੇ ਹੈਲਮ ਚਾਰਟ ਦਾ ਬਿਲਡ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਗਿਆ ਹੈ ਤਾਂ ਜੋ ਉਪਭੋਗਤਾ ਆਸਾਨੀ ਨਾਲ (ਸ਼ਾਬਦਿਕ ਤੌਰ 'ਤੇ ਇੱਕ ਕਮਾਂਡ ਨਾਲ) ਆਪਰੇਟਰ ਨੂੰ ਆਪਣੇ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਵਿੱਚ ਸਥਾਪਿਤ ਕਰ ਸਕਣ।

ਸੀ.ਆਰ.ਡੀ.

ਓਪਰੇਟਰ ਨੂੰ ਇਹ ਜਾਣਨ ਲਈ ਕਿ ਕਿਹੜੇ ਸਰੋਤਾਂ ਦੀ ਭਾਲ ਕਰਨੀ ਹੈ ਅਤੇ ਕਿੱਥੇ ਦੇਖਣਾ ਹੈ, ਸਾਨੂੰ ਉਸਦੇ ਲਈ ਇੱਕ ਨਿਯਮ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਹਰੇਕ ਨਿਯਮ ਨੂੰ ਇੱਕ ਸਿੰਗਲ CRD ਵਸਤੂ ਵਜੋਂ ਦਰਸਾਇਆ ਜਾਵੇਗਾ। ਇਸ 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 ਵਰਗੇ ਲੇਬਲ ਦੇ ਨਾਲ ਸਾਰੇ ConfigMap 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 ਅਤੇ ਸੀਕਰੇਟ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਢੰਗਾਂ ਨੂੰ ਕਿਵੇਂ ਵੱਖ ਕਰਨਾ ਹੈ, ਅਸੀਂ ਵਿਸ਼ੇਸ਼ ਨਕਸ਼ਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਫਿਰ ਅਸੀਂ ਸਮਝ ਸਕਦੇ ਹਾਂ ਕਿ ਸਾਨੂੰ ਆਬਜੈਕਟ ਨੂੰ ਟਰੈਕ ਕਰਨ ਅਤੇ ਬਣਾਉਣ ਲਈ ਕਿਹੜੇ ਤਰੀਕਿਆਂ ਦੀ ਲੋੜ ਹੈ:

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)

ਮੁੱਖ ਤਰਕ ਤਿਆਰ ਹੈ! ਹੁਣ ਸਾਨੂੰ ਇਹ ਸਭ ਇੱਕ Python ਪੈਕੇਜ ਵਿੱਚ ਪੈਕ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅਸੀਂ ਫਾਈਲ ਤਿਆਰ ਕਰਦੇ ਹਾਂ 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 }}

ਨਤੀਜਾ

ਇਸ ਤਰ੍ਹਾਂ, ਬਿਨਾਂ ਕਿਸੇ ਡਰ, ਬਦਨਾਮੀ, ਜਾਂ ਗੋ ਸਿੱਖਣ ਦੇ, ਅਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਲਈ ਆਪਣਾ ਆਪਰੇਟਰ ਬਣਾਉਣ ਦੇ ਯੋਗ ਹੋ ਗਏ। ਬੇਸ਼ੱਕ, ਇਸ ਵਿੱਚ ਅਜੇ ਵੀ ਵਧਣ ਲਈ ਥਾਂ ਹੈ: ਭਵਿੱਖ ਵਿੱਚ ਇਹ ਕਈ ਨਿਯਮਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵੇਗਾ, ਮਲਟੀਪਲ ਥਰਿੱਡਾਂ ਵਿੱਚ ਕੰਮ ਕਰੇਗਾ, ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਇਸਦੇ CRDs ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰੇਗਾ...

ਤੁਹਾਨੂੰ ਕੋਡ 'ਤੇ ਨੇੜਿਓਂ ਨਜ਼ਰ ਦੇਣ ਲਈ, ਅਸੀਂ ਇਸਨੂੰ ਪਾ ਦਿੱਤਾ ਹੈ ਜਨਤਕ ਭੰਡਾਰ. ਜੇ ਤੁਸੀਂ ਪਾਇਥਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਗੂ ਕੀਤੇ ਹੋਰ ਗੰਭੀਰ ਓਪਰੇਟਰਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਮੋਂਗੌਡਬੀ (первый и ਦੂਜਾ).

PS ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਕੁਬਰਨੇਟਸ ਇਵੈਂਟਸ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਬਹੁਤ ਆਲਸੀ ਹੋ ਜਾਂ ਤੁਸੀਂ ਬੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਜ਼ਿਆਦਾ ਆਦੀ ਹੋ, ਤਾਂ ਸਾਡੇ ਸਹਿਯੋਗੀਆਂ ਨੇ ਫਾਰਮ ਵਿੱਚ ਇੱਕ ਤਿਆਰ ਹੱਲ ਤਿਆਰ ਕੀਤਾ ਹੈ ਸ਼ੈੱਲ-ਆਪਰੇਟਰ (ਅਸੀਂ ਐਲਾਨ ਕੀਤਾ ਇਹ ਅਪ੍ਰੈਲ ਵਿੱਚ).

Pps

ਸਾਡੇ ਬਲੌਗ 'ਤੇ ਵੀ ਪੜ੍ਹੋ:

• «ਕੀ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਤਿਆਰ ਕਰਨਾ ਆਸਾਨ ਅਤੇ ਸੁਵਿਧਾਜਨਕ ਹੈ? ਐਡ-ਆਨ-ਆਪਰੇਟਰ ਦੀ ਘੋਸ਼ਣਾ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ";
• «ਸ਼ੈੱਲ-ਓਪਰੇਟਰ ਪੇਸ਼ ਕਰਨਾ: ਕੁਬਰਨੇਟਸ ਲਈ ਆਪਰੇਟਰ ਬਣਾਉਣਾ ਹੁਣੇ ਆਸਾਨ ਹੋ ਗਿਆ ਹੈ";
• «ਕੁਬਰਨੇਟਸ ਦਾ ਵਿਸਥਾਰ ਅਤੇ ਪੂਰਕ (ਸਮੀਖਿਆ ਅਤੇ ਵੀਡੀਓ ਰਿਪੋਰਟ)";
• «ਗੋਲੰਗ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਲਈ ਇੱਕ ਆਪਰੇਟਰ ਲਿਖਣਾ";
• «ਕੁਬਰਨੇਟਸ ਲਈ ਆਪਰੇਟਰ: ਸਟੇਟਫੁੱਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ".

ਸਰੋਤ: www.habr.com