ಶೆಲ್-ಆಪರೇಟರ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ: ಕುಬರ್ನೆಟ್ಸ್‌ಗಾಗಿ ಆಪರೇಟರ್‌ಗಳನ್ನು ರಚಿಸುವುದು ಈಗ ಸುಲಭವಾಗಿದೆ

ನಮ್ಮ ಬ್ಲಾಗ್‌ನಲ್ಲಿ ಈಗಾಗಲೇ ಲೇಖನಗಳು ಮಾತನಾಡುತ್ತಿವೆ ಕುಬರ್ನೆಟ್ಸ್ನಲ್ಲಿ ಆಪರೇಟರ್ ಸಾಮರ್ಥ್ಯಗಳು ಮತ್ತೆ ಹೇಗೆ ಸರಳ ಆಪರೇಟರ್ ಅನ್ನು ನೀವೇ ಬರೆಯಿರಿ. ಈ ಸಮಯದಲ್ಲಿ ನಾವು ನಿಮ್ಮ ಗಮನಕ್ಕೆ ನಮ್ಮ ಓಪನ್ ಸೋರ್ಸ್ ಪರಿಹಾರವನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಲು ಬಯಸುತ್ತೇವೆ, ಇದು ಆಪರೇಟರ್‌ಗಳ ರಚನೆಯನ್ನು ಸೂಪರ್-ಸುಲಭ ಮಟ್ಟಕ್ಕೆ ಕೊಂಡೊಯ್ಯುತ್ತದೆ - ಪರಿಶೀಲಿಸಿ ಶೆಲ್-ಆಪರೇಟರ್!

ಯಾಕೆ?

ಶೆಲ್ ಆಪರೇಟರ್ನ ಕಲ್ಪನೆಯು ತುಂಬಾ ಸರಳವಾಗಿದೆ: ಕುಬರ್ನೆಟ್ಸ್ ವಸ್ತುಗಳಿಂದ ಈವೆಂಟ್ಗಳಿಗೆ ಚಂದಾದಾರರಾಗಿ, ಮತ್ತು ಈ ಘಟನೆಗಳನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ, ಬಾಹ್ಯ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ, ಈವೆಂಟ್ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ:

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

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

ನಮ್ಮ ಚಿತ್ರವನ್ನು ಪ್ರಾರಂಭಿಸುವ ಪಾಡ್ ಈ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಲು ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿರಬೇಕು ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ. ನಿಮ್ಮ ಸ್ವಂತ ಸೇವಾ ಖಾತೆಯನ್ನು ರಚಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು. ಅನುಮತಿಯನ್ನು ClusterRole ಮತ್ತು ClusterRoleBinding ರೂಪದಲ್ಲಿ ಮಾಡಬೇಕು, ಏಕೆಂದರೆ ನಾವು ಸಂಪೂರ್ಣ ಕ್ಲಸ್ಟರ್‌ನ ವಸ್ತುಗಳ ಬಗ್ಗೆ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ.

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 ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಓಪನ್ ಸೋರ್ಸ್ ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ ವಿತರಿಸಲಾಗಿದೆ (Apache 2.0). ಯಾವುದೇ ಅಭಿವೃದ್ಧಿ ಸಹಾಯಕ್ಕಾಗಿ ನಾವು ಕೃತಜ್ಞರಾಗಿರುತ್ತೇವೆ GitHub ನಲ್ಲಿ ಯೋಜನೆ: ಮತ್ತು ನಕ್ಷತ್ರಗಳು, ಮತ್ತು ಸಮಸ್ಯೆಗಳು ಮತ್ತು ವಿನಂತಿಗಳನ್ನು ಎಳೆಯಿರಿ.

ಗೌಪ್ಯತೆಯ ಮುಸುಕನ್ನು ಎತ್ತುವ ಮೂಲಕ, ಶೆಲ್ ಆಪರೇಟರ್ ಎಂದು ನಾವು ನಿಮಗೆ ತಿಳಿಸುತ್ತೇವೆ ಸಣ್ಣ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾದ ಆಡ್-ಆನ್‌ಗಳನ್ನು ನವೀಕೃತವಾಗಿ ಇರಿಸಿಕೊಳ್ಳುವ ಮತ್ತು ವಿವಿಧ ಸ್ವಯಂಚಾಲಿತ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ನಮ್ಮ ಸಿಸ್ಟಮ್‌ನ ಭಾಗವಾಗಿದೆ. ಈ ವ್ಯವಸ್ಥೆಯ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ಓದಿ ಹೇಳಿದರು ಅಕ್ಷರಶಃ ಸೋಮವಾರದಂದು ಸೇಂಟ್ ಪೀಟರ್ಸ್‌ಬರ್ಗ್‌ನ HighLoad++ 2019 ರಲ್ಲಿ - ನಾವು ಶೀಘ್ರದಲ್ಲೇ ಈ ವರದಿಯ ವೀಡಿಯೊ ಮತ್ತು ಪ್ರತಿಲೇಖನವನ್ನು ಪ್ರಕಟಿಸುತ್ತೇವೆ.

ಈ ಸಿಸ್ಟಮ್‌ನ ಉಳಿದ ಭಾಗವನ್ನು ತೆರೆಯಲು ನಾವು ಯೋಜನೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ: addon-ಆಪರೇಟರ್ ಮತ್ತು ನಮ್ಮ ಕೊಕ್ಕೆಗಳು ಮತ್ತು ಮಾಡ್ಯೂಲ್‌ಗಳ ಸಂಗ್ರಹ. ಮೂಲಕ, addon-operator ಈಗಾಗಲೇ ಆಗಿದೆ ಗಿಥಬ್‌ನಲ್ಲಿ ಲಭ್ಯವಿದೆ, ಆದರೆ ಅದರ ದಾಖಲಾತಿಯು ಇನ್ನೂ ದಾರಿಯಲ್ಲಿದೆ. ಮಾಡ್ಯೂಲ್‌ಗಳ ಸಂಗ್ರಹದ ಬಿಡುಗಡೆಯನ್ನು ಬೇಸಿಗೆಯಲ್ಲಿ ಯೋಜಿಸಲಾಗಿದೆ.

ಟ್ಯೂನ್ ಮಾಡಿ!

ಪಿಎಸ್

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

• «ಕುಬರ್ನೆಟ್ಸ್‌ಗಾಗಿ ಆಪರೇಟರ್‌ಗಳು: ಸ್ಟೇಟ್‌ಫುಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೇಗೆ ಚಲಾಯಿಸುವುದು";
• «ಗೊಲಾಂಗ್‌ನಲ್ಲಿ ಕುಬರ್ನೆಟ್ಸ್‌ಗೆ ಆಪರೇಟರ್ ಬರೆಯುವುದು";
• «ಗ್ರಾಫಾನಾ - ಸ್ಟೇಟಸ್‌ಮ್ಯಾಪ್ ಪ್ಯಾನೆಲ್‌ಗಾಗಿ ಹೊಸ ಪ್ಲಗಿನ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ";
• «ಲಾಗ್‌ಹೌಸ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ - ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಲಾಗ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಓಪನ್ ಸೋರ್ಸ್ ಸಿಸ್ಟಮ್";
• «ನಾವು ಅಧಿಕೃತವಾಗಿ dapp ಅನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇವೆ - CI/CD ನಿರ್ವಹಣೆಗಾಗಿ DevOps ಉಪಯುಕ್ತತೆ».

ಮೂಲ: www.habr.com