ഷെൽ-ഓപ്പറേറ്റർ അവതരിപ്പിക്കുന്നു: കുബർനെറ്റസിനായി ഓപ്പറേറ്റർമാരെ സൃഷ്ടിക്കുന്നത് ഇപ്പോൾ എളുപ്പമായി

ഞങ്ങളുടെ ബ്ലോഗിൽ ഇതിനകം ലേഖനങ്ങൾ സംസാരിച്ചു കുബർനെറ്റസിലെ ഓപ്പറേറ്റർ കഴിവുകൾ എങ്ങനെ ഒരു ലളിതമായ ഓപ്പറേറ്റർ സ്വയം എഴുതുക. ഈ സമയം ഞങ്ങളുടെ ഓപ്പൺ സോഴ്സ് സൊല്യൂഷൻ നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, അത് ഓപ്പറേറ്റർമാരുടെ സൃഷ്ടിയെ വളരെ എളുപ്പമുള്ള തലത്തിലേക്ക് കൊണ്ടുപോകുന്നു - പരിശോധിക്കുക ഷെൽ ഓപ്പറേറ്റർ!

എന്തുകൊണ്ട്?

ഒരു ഷെൽ-ഓപ്പറേറ്റർ എന്ന ആശയം വളരെ ലളിതമാണ്: കുബർനെറ്റസ് ഒബ്‌ജക്റ്റുകളിൽ നിന്നുള്ള ഇവന്റുകൾ സബ്‌സ്‌ക്രൈബുചെയ്യുക, ഈ ഇവന്റുകൾ ലഭിക്കുമ്പോൾ, ഒരു ബാഹ്യ പ്രോഗ്രാം സമാരംഭിക്കുക, ഇവന്റിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ നൽകുന്നു:

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

15 മിനിറ്റിനുള്ളിൽ ഓപ്പറേറ്റർ

ഒരു കുബർനെറ്റസ് ക്ലസ്റ്ററിൽ എന്തൊക്കെ ഓട്ടോമേറ്റ് ചെയ്യാം, ഷെൽ-ഓപ്പറേറ്റർ എങ്ങനെ സഹായിക്കാം എന്നതിന്റെ ഒരു ഉദാഹരണം നോക്കാം. ഒരു ഉദാഹരണം ഇനിപ്പറയുന്നതായിരിക്കും: ഡോക്കർ രജിസ്ട്രി ആക്സസ് ചെയ്യുന്നതിനുള്ള ഒരു രഹസ്യം പകർത്തുക.

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

ലളിതമായ ഓട്ടോമേഷൻ

ഓരോ N സെക്കന്റിലും ഒരിക്കൽ പ്രവർത്തിക്കുന്ന ഒരു ഷെൽ സ്ക്രിപ്റ്റ് എഴുതാം, ഒരു രഹസ്യത്തിന്റെ സാന്നിധ്യത്തിനായി നെയിംസ്പേസുകൾ പരിശോധിക്കുന്നു, രഹസ്യം ഇല്ലെങ്കിൽ, അത് സൃഷ്ടിക്കപ്പെടും. ഈ പരിഹാരത്തിന്റെ പ്രയോജനം, ഇത് ക്രോണിൽ ഒരു ഷെൽ സ്ക്രിപ്റ്റ് പോലെ കാണപ്പെടുന്നു എന്നതാണ് - എല്ലാവർക്കുമായി ഒരു ക്ലാസിക്, മനസ്സിലാക്കാവുന്ന സമീപനം. അതിന്റെ ലോഞ്ചുകൾക്കിടയിലുള്ള ഇടവേളയിൽ ഒരു പുതിയ നെയിംസ്‌പെയ്‌സ് സൃഷ്‌ടിക്കാൻ കഴിയും, കുറച്ച് സമയത്തേക്ക് അത് ഒരു രഹസ്യവുമില്ലാതെ നിലനിൽക്കും, ഇത് പോഡുകൾ സമാരംഭിക്കുന്നതിൽ പിശകുകളിലേക്ക് നയിക്കും.

ഷെൽ-ഓപ്പറേറ്റർ ഉള്ള ഓട്ടോമേഷൻ

ഞങ്ങളുടെ സ്ക്രിപ്റ്റ് ശരിയായി പ്രവർത്തിക്കുന്നതിന്, ഒരു നെയിംസ്പേസ് ചേർക്കുമ്പോൾ, ക്ലാസിക് ക്രോൺ ലോഞ്ച് ഒരു ലോഞ്ച് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കേണ്ടതുണ്ട്: ഈ സാഹചര്യത്തിൽ, അത് ഉപയോഗിക്കുന്നതിന് മുമ്പ് നിങ്ങൾക്ക് ഒരു രഹസ്യം സൃഷ്ടിക്കാൻ കഴിയും. ഷെൽ-ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഇത് എങ്ങനെ നടപ്പിലാക്കാമെന്ന് നോക്കാം.

ആദ്യം, നമുക്ക് തിരക്കഥ നോക്കാം. ഷെൽ-ഓപ്പറേറ്റർ പദങ്ങളിലുള്ള സ്ക്രിപ്റ്റുകളെ ഹുക്കുകൾ എന്ന് വിളിക്കുന്നു. ഒരു കൊടിയുമായി ഓടുമ്പോൾ ഓരോ കൊളുത്തും --config അതിന്റെ ബൈൻഡിംഗുകളെക്കുറിച്ച് ഷെൽ-ഓപ്പറേറ്ററെ അറിയിക്കുന്നു, അതായത്. ഏതൊക്കെ ഇവന്റുകളിലാണ് ഇത് ലോഞ്ച് ചെയ്യേണ്ടത്. ഞങ്ങളുടെ കാര്യത്തിൽ ഞങ്ങൾ ഉപയോഗിക്കും onKubernetesEvent:

#!/bin/bash
if [[ $1 == "--config" ]] ; then
cat <<EOF
{
"onKubernetesEvent": [
  { "kind": "namespace",
    "event":["add"]
  }
]}
EOF
fi

ഇവന്റുകൾ ചേർക്കുന്നതിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെന്ന് ഇവിടെ വിവരിക്കുന്നു (add) തരത്തിലുള്ള വസ്തുക്കൾ namespace.

ഇവന്റ് സംഭവിക്കുമ്പോൾ എക്സിക്യൂട്ട് ചെയ്യുന്ന കോഡ് നിങ്ങൾ ഇപ്പോൾ ചേർക്കേണ്ടതുണ്ട്:

#!/bin/bash
if [[ $1 == "--config" ]] ; then
  # конфигурация
cat <<EOF
{
"onKubernetesEvent": [
{ "kind": "namespace",
  "event":["add"]
}
]}
EOF
else
  # реакция:
  # узнать, какой namespace появился
  createdNamespace=$(jq -r '.[0].resourceName' $BINDING_CONTEXT_PATH)
  # создать в нём нужный секрет
  kubectl create -n ${createdNamespace} -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  ...
data:
  ...
EOF
fi

കൊള്ളാം! ഫലം ചെറുതും മനോഹരവുമായ ഒരു തിരക്കഥയായിരുന്നു. ഇത് "പുനരുജ്ജീവിപ്പിക്കാൻ", രണ്ട് ഘട്ടങ്ങൾ അവശേഷിക്കുന്നു: ചിത്രം തയ്യാറാക്കി ക്ലസ്റ്ററിൽ സമാരംഭിക്കുക.

ഒരു ഹുക്ക് ഉപയോഗിച്ച് ഒരു ചിത്രം തയ്യാറാക്കുന്നു

നിങ്ങൾ സ്ക്രിപ്റ്റ് നോക്കിയാൽ, കമാൻഡുകൾ ഉപയോഗിക്കുന്നതായി നിങ്ങൾക്ക് കാണാൻ കഴിയും kubectl и jq. ഇതിനർത്ഥം ചിത്രത്തിൽ ഇനിപ്പറയുന്ന കാര്യങ്ങൾ ഉണ്ടായിരിക്കണം: ഞങ്ങളുടെ ഹുക്ക്, ഇവന്റുകൾ നിരീക്ഷിക്കുകയും ഹുക്ക് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്ന ഒരു ഷെൽ-ഓപ്പറേറ്റർ, ഹുക്ക് ഉപയോഗിക്കുന്ന കമാൻഡുകൾ (kubectl, jq). Hub.docker.com-ൽ ഇതിനകം തന്നെ ഷെൽ-ഓപ്പറേറ്റർ, kubectl, jq എന്നിവ പാക്കേജുചെയ്‌ത ഒരു റെഡിമെയ്ഡ് ഇമേജ് ഉണ്ട്. ഒരു ലളിതമായ ഹുക്ക് ചേർക്കാൻ മാത്രമാണ് അവശേഷിക്കുന്നത് Dockerfile:

$ cat Dockerfile
FROM flant/shell-operator:v1.0.0-beta.1-alpine3.9
ADD namespace-hook.sh /hooks

$ docker build -t registry.example.com/my-operator:v1 . 
$ docker push registry.example.com/my-operator:v1

ഒരു ക്ലസ്റ്ററിൽ പ്രവർത്തിക്കുന്നു

നമുക്ക് വീണ്ടും ഹുക്ക് നോക്കാം, ഈ സമയം ക്ലസ്റ്ററിൽ എന്ത് പ്രവർത്തനങ്ങൾ ചെയ്യുന്നു, ഏതൊക്കെ വസ്തുക്കളാണ് അത് ചെയ്യുന്നത് എന്ന് എഴുതുക:

1. നെയിംസ്പേസ് സൃഷ്ടിക്കൽ ഇവന്റുകൾ സബ്സ്ക്രൈബ് ചെയ്യുന്നു;
2. ലോഞ്ച് ചെയ്യുന്നിടത്ത് ഒഴികെയുള്ള നെയിംസ്പേസുകളിൽ ഒരു രഹസ്യം സൃഷ്ടിക്കുന്നു.

ഞങ്ങളുടെ ഇമേജ് ലോഞ്ച് ചെയ്യുന്ന പോഡിന് ഈ പ്രവർത്തനങ്ങൾ ചെയ്യാനുള്ള അനുമതികൾ ഉണ്ടായിരിക്കണമെന്ന് ഇത് മാറുന്നു. നിങ്ങളുടെ സ്വന്തം സർവീസ് അക്കൗണ്ട് സൃഷ്ടിച്ചുകൊണ്ട് ഇത് ചെയ്യാൻ കഴിയും. അനുമതി ക്ലസ്റ്റർ റോൾ, ക്ലസ്റ്റർ റോൾ ബൈൻഡിംഗ് എന്നിവയുടെ രൂപത്തിലായിരിക്കണം, കാരണം മുഴുവൻ ക്ലസ്റ്ററിൽ നിന്നുമുള്ള വസ്തുക്കളിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്.

YAML-ലെ അവസാന വിവരണം ഇതുപോലെയായിരിക്കും:

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: monitor-namespaces-acc

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: monitor-namespaces
rules:
- apiGroups: [""]
  resources: ["namespaces"]
  verbs: ["get", "watch", "list"]
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "list", "create", "patch"]

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: monitor-namespaces
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: monitor-namespaces
subjects:
  - kind: ServiceAccount
    name: monitor-namespaces-acc
    namespace: example-monitor-namespaces

ഒരു ലളിതമായ വിന്യാസമായി നിങ്ങൾക്ക് അസംബിൾ ചെയ്ത ചിത്രം സമാരംഭിക്കാം:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-operator
spec:
  template:
    spec:
      containers:
      - name: my-operator
        image: registry.example.com/my-operator:v1
      serviceAccountName: monitor-namespaces-acc

സൗകര്യാർത്ഥം, ഷെൽ-ഓപ്പറേറ്റർ സമാരംഭിക്കുകയും സൃഷ്ടിച്ച മാനിഫെസ്റ്റുകൾ പ്രയോഗിക്കുകയും ചെയ്യുന്ന ഒരു പ്രത്യേക നെയിംസ്പേസ് സൃഷ്ടിക്കപ്പെടുന്നു:

$ kubectl create ns example-monitor-namespaces
$ kubectl -n example-monitor-namespaces apply -f rbac.yaml
$ kubectl -n example-monitor-namespaces apply -f deployment.yaml

അത്രയേയുള്ളൂ: ഷെൽ-ഓപ്പറേറ്റർ ആരംഭിക്കും, നെയിംസ്‌പേസ് സൃഷ്‌ടിക്കൽ ഇവന്റുകൾ സബ്‌സ്‌ക്രൈബ് ചെയ്യുകയും ആവശ്യമുള്ളപ്പോൾ ഹുക്ക് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യും.

അങ്ങനെ, ഒരു ലളിതമായ ഷെൽ സ്ക്രിപ്റ്റ് കുബർനെറ്റസിന്റെ യഥാർത്ഥ ഓപ്പറേറ്ററായി മാറി ഒരു ക്ലസ്റ്ററിന്റെ ഭാഗമായി പ്രവർത്തിക്കുന്നു. ഗോലാങ്ങിൽ ഓപ്പറേറ്റർമാരെ വികസിപ്പിക്കുന്നതിനുള്ള സങ്കീർണ്ണമായ പ്രക്രിയയില്ലാതെ ഇതെല്ലാം:

ഈ വിഷയത്തിൽ മറ്റൊരു ദൃഷ്ടാന്തമുണ്ട്...

ഇനിപ്പറയുന്ന പ്രസിദ്ധീകരണങ്ങളിലൊന്നിൽ ഞങ്ങൾ അതിന്റെ അർത്ഥം കൂടുതൽ വിശദമായി വെളിപ്പെടുത്തും.

ഫിൽട്ടറിംഗ്

ഒബ്‌ജക്‌റ്റുകൾ ട്രാക്കുചെയ്യുന്നത് നല്ലതാണ്, പക്ഷേ പലപ്പോഴും പ്രതികരിക്കേണ്ട ആവശ്യമുണ്ട് ചില ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ മാറ്റുന്നു, ഉദാഹരണത്തിന്, വിന്യാസത്തിലെ പകർപ്പുകളുടെ എണ്ണം മാറ്റുന്നതിനോ ഒബ്ജക്റ്റ് ലേബലുകൾ മാറ്റുന്നതിനോ.

ഒരു ഇവന്റ് എത്തുമ്പോൾ, ഷെൽ-ഓപ്പറേറ്റർ ഒബ്ജക്റ്റിന്റെ JSON മാനിഫെസ്റ്റ് സ്വീകരിക്കുന്നു. ഈ JSON-ൽ നമുക്ക് താൽപ്പര്യമുള്ള പ്രോപ്പർട്ടികൾ തിരഞ്ഞെടുത്ത് ഹുക്ക് പ്രവർത്തിപ്പിക്കാം മാത്രം അവർ മാറുമ്പോൾ. ഇതിനായി ഒരു മൈതാനമുണ്ട് jqFilter, JSON മാനിഫെസ്റ്റിലേക്ക് പ്രയോഗിക്കുന്ന jq എക്സ്പ്രഷൻ നിങ്ങൾ വ്യക്തമാക്കേണ്ടതുണ്ട്.

ഉദാഹരണത്തിന്, വിന്യാസ വസ്തുക്കൾക്കുള്ള ലേബലുകളിലെ മാറ്റങ്ങളോട് പ്രതികരിക്കുന്നതിന്, നിങ്ങൾ ഫീൽഡ് ഫിൽട്ടർ ചെയ്യേണ്ടതുണ്ട് labels വയലിന് പുറത്ത് metadata. കോൺഫിഗറേഷൻ ഇതുപോലെയായിരിക്കും:

cat <<EOF
{
"onKubernetesEvent": [
{ "kind": "deployment",
  "event":["update"],
  "jqFilter": ".metadata.labels"
}
]}
EOF

ഈ jqFilter എക്സ്പ്രഷൻ വിന്യാസത്തിന്റെ നീണ്ട JSON മാനിഫെസ്റ്റിനെ ലേബലുകളുള്ള ഹ്രസ്വ JSON ആക്കി മാറ്റുന്നു:

ഈ ഹ്രസ്വ JSON മാറുമ്പോൾ മാത്രമേ ഷെൽ-ഓപ്പറേറ്റർ ഹുക്ക് പ്രവർത്തിപ്പിക്കുകയുള്ളൂ, മറ്റ് പ്രോപ്പർട്ടികളിലേക്കുള്ള മാറ്റങ്ങൾ അവഗണിക്കപ്പെടും.

ഹുക്ക് ലോഞ്ച് സന്ദർഭം

ഇവന്റുകൾക്കായി നിരവധി ഓപ്ഷനുകൾ വ്യക്തമാക്കാൻ ഹുക്ക് കോൺഫിഗറേഷൻ നിങ്ങളെ അനുവദിക്കുന്നു - ഉദാഹരണത്തിന്, കുബർനെറ്റസിൽ നിന്നുള്ള ഇവന്റുകൾക്കുള്ള 2 ഓപ്‌ഷനുകളും 2 ഷെഡ്യൂളുകളും:

{"onKubernetesEvent":[
  {"name":"OnCreatePod",
  "kind": "pod",
  "event":["add"]
  },
  {"name":"OnModifiedNamespace",
  "kind": "namespace",
  "event":["update"],
  "jqFilter": ".metadata.labels"
  }
],
"schedule": [
{ "name":"every 10 min",
  "crontab":"* */10 * * * *"
}, {"name":"on Mondays at 12:10",
"crontab": "* 10 12 * * 1"
]}

ഒരു ചെറിയ വ്യതിചലനം: അതെ, ഷെൽ-ഓപ്പറേറ്റർ പിന്തുണയ്ക്കുന്നു ക്രോണ്ടാബ് ശൈലിയിലുള്ള സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നു. കൂടുതൽ വിശദാംശങ്ങൾ കണ്ടെത്താനാകും പ്രമാണീകരണം.

എന്തുകൊണ്ടാണ് ഹുക്ക് സമാരംഭിച്ചതെന്ന് വേർതിരിച്ചറിയാൻ, ഷെൽ-ഓപ്പറേറ്റർ ഒരു താൽക്കാലിക ഫയൽ സൃഷ്ടിക്കുകയും അതിലേക്കുള്ള പാത ഒരു വേരിയബിളിൽ ഹുക്കിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു. BINDING_CONTEXT_TYPE. ഫയലിൽ ഹുക്ക് പ്രവർത്തിപ്പിക്കാനുള്ള കാരണത്തിന്റെ JSON വിവരണം അടങ്ങിയിരിക്കുന്നു. ഉദാഹരണത്തിന്, ഓരോ 10 മിനിറ്റിലും ഹുക്ക് ഇനിപ്പറയുന്ന ഉള്ളടക്കത്തിൽ പ്രവർത്തിക്കും:

[{ "binding": "every 10 min"}]

... തിങ്കളാഴ്‌ച ഇത് ഇങ്ങനെ തുടങ്ങും:

[{ "binding": "every 10 min"}, { "binding": "on Mondays at 12:10"}]

വേണ്ടി onKubernetesEvent കൂടുതൽ JSON ട്രിഗറുകൾ ഉണ്ടാകും, കാരണം അതിൽ വസ്തുവിന്റെ ഒരു വിവരണം അടങ്ങിയിരിക്കുന്നു:

[
 {
 "binding": "onCreatePod",
 "resourceEvent": "add",
 "resourceKind": "pod",
 "resourceName": "foo",
 "resourceNamespace": "bar"
 }
]

ഫീൽഡുകളുടെ ഉള്ളടക്കം അവയുടെ പേരുകളിൽ നിന്ന് മനസ്സിലാക്കാനും കൂടുതൽ വിശദാംശങ്ങൾ വായിക്കാനും കഴിയും പ്രമാണീകരണം. ഒരു ഫീൽഡിൽ നിന്ന് ഒരു റിസോഴ്സ് നാമം ലഭിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം resourceName jq ഉപയോഗിക്കുന്നത് ഇതിനകം തന്നെ രഹസ്യങ്ങൾ ആവർത്തിക്കുന്ന ഒരു ഹുക്കിൽ കാണിച്ചിരിക്കുന്നു:

jq -r '.[0].resourceName' $BINDING_CONTEXT_PATH

സമാനമായ രീതിയിൽ നിങ്ങൾക്ക് മറ്റ് ഫീൽഡുകൾ ലഭിക്കും.

അടുത്തത് എന്ത്?

പ്രോജക്റ്റ് റിപ്പോസിറ്ററിയിൽ, ഇൻ / ഉദാഹരണ ഡയറക്ടറികൾ, ഒരു ക്ലസ്റ്ററിൽ പ്രവർത്തിക്കാൻ തയ്യാറായ കൊളുത്തുകളുടെ ഉദാഹരണങ്ങളുണ്ട്. നിങ്ങളുടെ സ്വന്തം കൊളുത്തുകൾ എഴുതുമ്പോൾ, നിങ്ങൾക്ക് അവ അടിസ്ഥാനമായി ഉപയോഗിക്കാം.

പ്രോമിത്യൂസ് ഉപയോഗിച്ച് മെട്രിക്‌സ് ശേഖരിക്കുന്നതിന് പിന്തുണയുണ്ട് - ലഭ്യമായ മെട്രിക്‌സ് വിഭാഗത്തിൽ വിവരിച്ചിരിക്കുന്നു മെട്രിക്സ്.

നിങ്ങൾ ഊഹിക്കുന്നതുപോലെ, ഷെൽ-ഓപ്പറേറ്റർ Go- ൽ എഴുതുകയും ഒരു ഓപ്പൺ സോഴ്സ് ലൈസൻസിന് കീഴിൽ വിതരണം ചെയ്യുകയും ചെയ്യുന്നു (അപ്പാച്ചെ 2.0). ഏത് വികസന സഹായത്തിനും ഞങ്ങൾ നന്ദിയുള്ളവരായിരിക്കും GitHub-ലെ പദ്ധതി: ഒപ്പം നക്ഷത്രങ്ങളും, പ്രശ്നങ്ങളും, അഭ്യർത്ഥനകളും വലിച്ചിടുക.

രഹസ്യത്തിന്റെ മൂടുപടം ഉയർത്തി, ഷെൽ ഓപ്പറേറ്ററാണെന്നും ഞങ്ങൾ നിങ്ങളെ അറിയിക്കും ചെറിയ Kubernetes ക്ലസ്റ്ററിൽ ഇൻസ്റ്റാൾ ചെയ്ത ആഡ്-ഓണുകൾ കാലികമായി നിലനിർത്താനും വിവിധ സ്വയമേവയുള്ള പ്രവർത്തനങ്ങൾ നടത്താനും കഴിയുന്ന ഞങ്ങളുടെ സിസ്റ്റത്തിന്റെ ഭാഗം. ഈ സംവിധാനത്തെക്കുറിച്ച് കൂടുതൽ വായിക്കുക പറഞ്ഞു അക്ഷരാർത്ഥത്തിൽ തിങ്കളാഴ്ച സെന്റ് പീറ്റേഴ്‌സ്ബർഗിലെ HighLoad++ 2019-ൽ - ഈ റിപ്പോർട്ടിന്റെ വീഡിയോയും ട്രാൻസ്ക്രിപ്റ്റും ഞങ്ങൾ ഉടൻ പ്രസിദ്ധീകരിക്കും.

ഈ സിസ്റ്റത്തിന്റെ ബാക്കി ഭാഗം തുറക്കാൻ ഞങ്ങൾക്ക് ഒരു പ്ലാനുണ്ട്: ആഡ്ഓൺ-ഓപ്പറേറ്ററും ഞങ്ങളുടെ ഹുക്കുകളുടെയും മൊഡ്യൂളുകളുടെയും ശേഖരം. വഴിയിൽ, addon-operator ഇതിനകം ഉണ്ട് github-ൽ ലഭ്യമാണ്, എന്നാൽ അതിനുള്ള ഡോക്യുമെന്റേഷൻ ഇപ്പോഴും വഴിയിലാണ്. മൊഡ്യൂളുകളുടെ ശേഖരത്തിന്റെ റിലീസ് വേനൽക്കാലത്ത് ആസൂത്രണം ചെയ്തിട്ടുണ്ട്.

ഇവിടെത്തന്നെ നിൽക്കുക!

പി.എസ്

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

• «കുബെർനെറ്റസിനായുള്ള ഓപ്പറേറ്റർമാർ: സ്റ്റേറ്റ്ഫുൾ ആപ്ലിക്കേഷനുകൾ എങ്ങനെ പ്രവർത്തിപ്പിക്കാം";
• «ഗോലാങ്ങിലെ കുബെർനെറ്റസിനായി ഒരു ഓപ്പറേറ്റർ എഴുതുന്നു";
• «ഗ്രാഫാനയ്‌ക്കായി ഒരു പുതിയ പ്ലഗിൻ അവതരിപ്പിക്കുന്നു - സ്റ്റാറ്റസ്‌മാപ്പ് പാനൽ";
• «ലോഗ്ഹൗസ് അവതരിപ്പിക്കുന്നു - കുബർനെറ്റസിലെ ലോഗുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു ഓപ്പൺ സോഴ്സ് സിസ്റ്റം";
• «ഞങ്ങൾ ഔദ്യോഗികമായി dapp അവതരിപ്പിക്കുന്നു - CI/CD അറ്റകുറ്റപ്പണികൾക്കുള്ള DevOps യൂട്ടിലിറ്റി".

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