షెల్-ఆపరేటర్‌ను పరిచయం చేస్తున్నాము: కుబెర్నెట్స్ కోసం ఆపరేటర్‌లను సృష్టించడం ఇప్పుడే సులభమైంది

గురించి మా బ్లాగ్‌లో ఇప్పటికే కథనాలు వచ్చాయి Kubernetes లో ఆపరేటర్ సామర్థ్యాలు మరి ఎలా ఒక సాధారణ ఆపరేటర్ మీరే వ్రాయండి. ఈసారి మేము మా ఓపెన్ సోర్స్ సొల్యూషన్‌ని మీ దృష్టికి అందించాలనుకుంటున్నాము, ఇది ఆపరేటర్‌ల సృష్టిని చాలా సులభమైన స్థాయికి తీసుకువెళుతుంది - తనిఖీ చేయండి షెల్-ఆపరేటర్!

ఎందుకు?

షెల్-ఆపరేటర్ యొక్క ఆలోచన చాలా సులభం: కుబెర్నెట్స్ వస్తువుల నుండి ఈవెంట్‌లకు సభ్యత్వాన్ని పొందండి మరియు ఈ సంఘటనలు స్వీకరించబడినప్పుడు, ఈవెంట్ గురించి సమాచారాన్ని అందించడం ద్వారా బాహ్య ప్రోగ్రామ్‌ను ప్రారంభించండి:

క్లస్టర్ల ఆపరేషన్ సమయంలో, మేము నిజంగా సరైన మార్గంలో ఆటోమేట్ చేయాలనుకుంటున్న చిన్న పనులు కనిపించడం ప్రారంభించినప్పుడు దాని అవసరం ఏర్పడింది. ఈ చిన్న పనులన్నీ సాధారణ బాష్ స్క్రిప్ట్‌లను ఉపయోగించి పరిష్కరించబడ్డాయి, అయినప్పటికీ, మీకు తెలిసినట్లుగా, గోలాంగ్‌లో ఆపరేటర్‌లను వ్రాయడం మంచిది. సహజంగానే, అటువంటి ప్రతి చిన్న పని కోసం ఆపరేటర్ యొక్క పూర్తి స్థాయి అభివృద్ధిలో పెట్టుబడి పెట్టడం అసమర్థంగా ఉంటుంది.

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"
]}

ఒక చిన్న డైగ్రెషన్: అవును, షెల్-ఆపరేటర్ మద్దతు ఇస్తుంది crontab శైలి స్క్రిప్ట్‌లను అమలు చేస్తోంది. మరిన్ని వివరాలను లో చూడవచ్చు డాక్యుమెంటేషన్.

హుక్ ఎందుకు ప్రారంభించబడిందో గుర్తించడానికి, షెల్-ఆపరేటర్ ఒక తాత్కాలిక ఫైల్‌ను సృష్టిస్తుంది మరియు హుక్‌కు వేరియబుల్‌లో దాని మార్గాన్ని పంపుతుంది. 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

మీరు ఇదే విధంగా ఇతర ఫీల్డ్‌లను పొందవచ్చు.

తరువాత ఏమిటి?

ప్రాజెక్ట్ రిపోజిటరీలో, ఇన్ / ఉదాహరణలు డైరెక్టరీలు, క్లస్టర్‌పై అమలు చేయడానికి సిద్ధంగా ఉన్న హుక్స్ ఉదాహరణలు ఉన్నాయి. మీ స్వంత హుక్స్ వ్రాసేటప్పుడు, మీరు వాటిని ఆధారంగా ఉపయోగించవచ్చు.

ప్రోమేతియస్ ఉపయోగించి కొలమానాలను సేకరించడానికి మద్దతు ఉంది - అందుబాటులో ఉన్న కొలమానాలు విభాగంలో వివరించబడ్డాయి మెట్రిక్స్.

మీరు ఊహించినట్లుగా, షెల్-ఆపరేటర్ గోలో వ్రాయబడింది మరియు ఓపెన్ సోర్స్ లైసెన్స్ (అపాచీ 2.0) క్రింద పంపిణీ చేయబడుతుంది. ఏదైనా అభివృద్ధి సహాయానికి మేము కృతజ్ఞతలు తెలుపుతాము GitHub పై ప్రాజెక్ట్: మరియు నక్షత్రాలు, మరియు సమస్యలు మరియు అభ్యర్థనలను లాగండి.

గోప్యత యొక్క ముసుగును ఎత్తివేస్తూ, షెల్-ఆపరేటర్ అని కూడా మేము మీకు తెలియజేస్తాము చిన్నది Kubernetes క్లస్టర్‌లో ఇన్‌స్టాల్ చేయబడిన యాడ్-ఆన్‌లను తాజాగా ఉంచగల మరియు వివిధ స్వయంచాలక చర్యలను చేయగల మా సిస్టమ్‌లో భాగం. ఈ వ్యవస్థ గురించి మరింత చదవండి చెప్పారు అక్షరాలా సోమవారం సెయింట్ పీటర్స్‌బర్గ్‌లోని HighLoad++ 2019లో - మేము ఈ నివేదిక యొక్క వీడియో మరియు ట్రాన్‌స్క్రిప్ట్‌ను త్వరలో ప్రచురిస్తాము.

ఈ సిస్టమ్‌లోని మిగిలిన వాటిని తెరవడానికి మాకు ఒక ప్రణాళిక ఉంది: యాడ్ఆన్-ఆపరేటర్ మరియు మా హుక్స్ మరియు మాడ్యూల్స్ సేకరణ. మార్గం ద్వారా, యాడ్ఆన్-ఆపరేటర్ ఇప్పటికే ఉంది గితుబ్‌లో అందుబాటులో ఉంది, కానీ దానికి సంబంధించిన డాక్యుమెంటేషన్ ఇంకా మార్గంలో ఉంది. మాడ్యూల్స్ సేకరణ విడుదల వేసవిలో ప్లాన్ చేయబడింది.

వేచి ఉండండి!

PS

మా బ్లాగులో కూడా చదవండి:

• «కుబెర్నెట్స్ కోసం ఆపరేటర్లు: స్టేట్‌ఫుల్ అప్లికేషన్‌లను ఎలా అమలు చేయాలి";
• «గోలాంగ్‌లోని కుబెర్నెటీస్ కోసం ఆపరేటర్‌ని వ్రాస్తున్నాను";
• «గ్రాఫానా కోసం కొత్త ప్లగ్‌ఇన్‌ని పరిచయం చేస్తున్నాము - స్టేటస్‌మ్యాప్ ప్యానెల్";
• «లాగ్‌హౌస్‌ని పరిచయం చేస్తున్నాము - కుబెర్నెట్స్‌లో లాగ్‌లతో పని చేయడానికి ఓపెన్ సోర్స్ సిస్టమ్";
• «మేము అధికారికంగా dappని అందిస్తున్నాము - CI/CD నిర్వహణ కోసం DevOps యుటిలిటీ".

మూలం: www.habr.com