కుబెర్నెట్స్ కోసం ఆపరేటర్లు: స్టేట్‌ఫుల్ అప్లికేషన్‌లను ఎలా అమలు చేయాలి

కుబెర్నెట్స్‌లో స్టేట్‌ఫుల్ అప్లికేషన్‌లతో సమస్య

స్టేట్‌లెస్‌గా వర్గీకరించబడిన కేసుల విషయానికి వస్తే అప్లికేషన్‌లు మరియు సేవల కాన్ఫిగరేషన్, లాంచ్ మరియు తదుపరి స్కేలింగ్ సులభం, అనగా. డేటాను సేవ్ చేయకుండా. కుబెర్నెట్స్‌లో అటువంటి సేవలను దాని ప్రామాణిక APIలను ఉపయోగించి అమలు చేయడం సౌకర్యంగా ఉంటుంది, ఎందుకంటే ప్రతిదీ “బాక్స్ వెలుపల” జరుగుతుంది: ప్రామాణిక కాన్ఫిగరేషన్‌ల ప్రకారం, ఎటువంటి ప్రత్యేకతలు లేదా మాయాజాలం లేకుండా.

సరళంగా చెప్పాలంటే, PHP/Ruby/Pythonలో బ్యాకెండ్ యొక్క మరో ఐదు కాపీలను కంటైనర్‌ల క్లస్టర్‌లో లాంచ్ చేయడానికి, మీరు కొత్త సర్వర్‌ను 5 సార్లు సెటప్ చేసి, మూలాధారాలను కాపీ చేయాలి. సోర్స్ కోడ్ మరియు init స్క్రిప్ట్ రెండూ ఇమేజ్‌లో ఉన్నందున, స్థితిలేని అప్లికేషన్‌ను స్కేలింగ్ చేయడం పూర్తిగా ప్రాథమికంగా మారుతుంది. కంటైనర్లు మరియు మైక్రోసర్వీస్ ఆర్కిటెక్చర్ అభిమానులకు బాగా తెలుసు కాబట్టి, కష్టాలు మొదలవుతాయి రాష్ట్రీయ యాప్‌లు, అనగా డేటాబేస్‌లు మరియు కాష్‌ల వంటి డేటా నిలకడతో (MySQL, PostgreSQL, Redis, ElasticSearch, Cassandra...). ఇది కోరమ్ క్లస్టర్‌ను స్వతంత్రంగా అమలు చేసే సాఫ్ట్‌వేర్ (ఉదాహరణకు, పెర్కోనా ఎక్స్‌ట్రాడిబి మరియు కాసాండ్రా) మరియు ప్రత్యేక మేనేజ్‌మెంట్ యుటిలిటీలు అవసరమయ్యే సాఫ్ట్‌వేర్ (రెడిస్, MySQL, PostgreSQL... వంటివి) రెండింటికీ వర్తిస్తుంది.

సోర్స్ కోడ్ మరియు సేవను ప్రారంభించడం సరిపోదు కాబట్టి ఇబ్బందులు తలెత్తుతాయి - మీరు మరికొన్ని దశలను చేయవలసి ఉంటుంది. కనీసం, డేటాను కాపీ చేయండి మరియు/లేదా క్లస్టర్‌లో చేరండి. మరింత ఖచ్చితంగా చెప్పాలంటే, ఈ సేవలకు డేటా నష్టం లేదా తాత్కాలిక లభ్యత లేకుండా వాటిని సరిగ్గా స్కేల్ చేయడం, నవీకరించడం మరియు రీకాన్ఫిగర్ చేయడం ఎలా అనే దానిపై అవగాహన అవసరం. ఈ అవసరాలను పరిగణనలోకి తీసుకోవడాన్ని "కార్యాచరణ జ్ఞానం" అంటారు.

CoreOS ఆపరేటర్లు

కార్యాచరణ జ్ఞానాన్ని "ప్రోగ్రామ్" చేయడానికి, గత సంవత్సరం చివరలో CoreOS ప్రాజెక్ట్ సమర్పించిన కుబెర్నెటెస్ ప్లాట్‌ఫారమ్ కోసం “కొత్త తరగతి సాఫ్ట్‌వేర్” - ఆపరేటర్లు (ఇంగ్లీష్ “ఆపరేషన్”, అంటే “ఆపరేషన్” నుండి).

కుబెర్నెటెస్ యొక్క ప్రధాన సామర్థ్యాలను ఉపయోగిస్తున్న మరియు విస్తరించే ఆపరేటర్లు (ఇంకా. స్టేట్‌ఫుల్ సెట్‌లు, దిగువన ఉన్న వ్యత్యాసాన్ని చూడండి) అప్లికేషన్ కోడ్‌కు కార్యాచరణ పరిజ్ఞానాన్ని జోడించడానికి DevOps నిపుణులను అనుమతించండి.

ఆపరేటర్ యొక్క ప్రయోజనం — హుడ్ కింద ఏమి ఉందో (ఏ డేటా మరియు దానితో ఏమి చేయాలి, క్లస్టర్‌ను నిర్వహించడానికి ఇంకా ఏ ఆదేశాలను అమలు చేయాలి అనే దాని గురించి ఆలోచించకుండా, Kubernetes క్లస్టర్‌లో బహుళ స్టేట్‌ఫుల్ అప్లికేషన్ ఎంటిటీలను నిర్వహించడానికి మిమ్మల్ని అనుమతించే APIని వినియోగదారుకు అందించండి. ) వాస్తవానికి, ఆపరేటర్ క్లస్టర్‌లోని అప్లికేషన్‌తో పనిని వీలైనంత సులభతరం చేయడానికి రూపొందించబడింది, గతంలో మాన్యువల్‌గా పరిష్కరించాల్సిన కార్యాచరణ పనుల అమలును ఆటోమేట్ చేస్తుంది.

ఆపరేటర్లు ఎలా పని చేస్తారు

రెప్లికాసెట్స్ Kubernetes మీకు కావలసిన సంఖ్యలో నడుస్తున్న పాడ్‌లను పేర్కొనడానికి అనుమతిస్తుంది మరియు కంట్రోలర్‌లు వాటి సంఖ్యను నిర్వహించేలా చూస్తాయి (పాడ్‌లను సృష్టించడం మరియు తొలగించడం ద్వారా). ఒక ఆపరేటర్ ఇదే విధంగా పని చేస్తాడు, ప్రామాణిక కుబెర్నెట్స్ వనరు మరియు కంట్రోలర్‌కు కార్యాచరణ జ్ఞానాన్ని జోడిస్తుంది, ఇది అవసరమైన సంఖ్యలో అప్లికేషన్ ఎంటిటీలకు మద్దతు ఇవ్వడానికి అదనపు చర్యలను చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఇది ఎలా భిన్నంగా ఉంటుంది స్టేట్‌ఫుల్ సెట్‌లు, క్లస్టర్‌కు డేటా నిల్వ లేదా స్టాటిక్ IPలు వంటి స్టేట్‌ఫుల్ వనరులను అందించడానికి అవసరమైన అప్లికేషన్‌ల కోసం రూపొందించబడిందా? అటువంటి అనువర్తనాల కోసం, ఆపరేటర్లు ఉపయోగించవచ్చు స్టేట్‌ఫుల్ సెట్‌లు (బదులుగా రెప్లికాసెట్స్) ఒక ఆధారంగా, సమర్పణ అదనపు ఆటోమేషన్: క్రాష్‌ల విషయంలో అవసరమైన చర్యలను చేయండి, బ్యాకప్‌లు చేయండి, కాన్ఫిగరేషన్‌ను నవీకరించండి మొదలైనవి.

కాబట్టి, ఇదంతా ఎలా పని చేస్తుంది? ఆపరేటర్ ఒక మేనేజర్ డెమోన్:

1. కుబెర్నెట్స్‌లో ఈవెంట్ APIకి సభ్యత్వం పొందింది;
2. దాని నుండి సిస్టమ్ గురించి డేటాను అందుకుంటుంది (దాని గురించి రెప్లికాసెట్స్, ప్యాడ్లు, సేవలు మరియు మొదలైనవి);
3. గురించి డేటా అందుకుంటుంది మూడవ పక్ష వనరులు (క్రింద ఉదాహరణలు చూడండి);
4. ప్రదర్శన/మార్పుకు ప్రతిస్పందిస్తుంది మూడవ పక్ష వనరులు (ఉదాహరణకు, పరిమాణాన్ని మార్చడానికి, సంస్కరణను మార్చడానికి మరియు మొదలైనవి);
5. సిస్టమ్ స్థితిలో మార్పులకు ప్రతిస్పందిస్తుంది (దాని గురించి రెప్లికాసెట్స్, ప్యాడ్లు, సేవలు మరియు మొదలైనవి);
6. అతి ముఖ్యమిన:
   1. Kubernetes APIకి అవసరమైన ప్రతిదాన్ని సృష్టించడానికి కాల్ చేస్తుంది (మళ్ళీ, దాని స్వంతం రెప్లికాసెట్స్, ప్యాడ్లు, సేవలు...),
   2. కొంత మేజిక్ చేస్తుంది (సులభతరం చేయడానికి, ఆపరేటర్ స్వయంగా పాడ్‌లలోకి వెళ్లి ఆదేశాలను పిలుస్తారని మీరు అనుకోవచ్చు, ఉదాహరణకు, క్లస్టర్‌లో చేరడానికి లేదా సంస్కరణను నవీకరించేటప్పుడు డేటా ఆకృతిని అప్‌గ్రేడ్ చేయడానికి).

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

అందువలన, మేము సృష్టించిన తర్వాత నేంస్పేస్ ఆపరేటర్, మేము దానికి జోడించవచ్చు మూడవ పక్ష వనరులు.

మొదలైన వాటికి ఉదాహరణ (వివరాల కోసం క్రింద చూడండి):

apiVersion: etcd.coreos.com/v1beta1
kind: Cluster
metadata:
  name: example-etcd-cluster
spec:
  size: 3
  version: 3.1.0

సాగే శోధనకు ఉదాహరణ:

apiVersion: enterprises.upmc.com/v1
kind: ElasticsearchCluster
metadata:
  name: example-es-cluster
spec:
  client-node-replicas: 3
  master-node-replicas: 2
  data-node-replicas: 3
  zones:
  - us-east-1c
  - us-east-1d
  - us-east-1e
  data-volume-size: 10Gi
  java-options: "-Xms1024m -Xmx1024m"
  snapshot:
    scheduler-enabled: true
    bucket-name: elasticsnapshots99
    cron-schedule: "@every 2m"
  storage:
    type: gp2
    storage-class-provisioner: kubernetes.io/aws-ebs

ఆపరేటర్ల కోసం అవసరాలు

CoreOS ఆపరేటర్లపై పని చేస్తున్నప్పుడు ఇంజనీర్లు పొందిన ప్రధాన నమూనాలను రూపొందించింది. అన్ని ఆపరేటర్లు వ్యక్తిగతంగా ఉన్నప్పటికీ (దాని స్వంత లక్షణాలు మరియు అవసరాలతో నిర్దిష్ట అప్లికేషన్ కోసం సృష్టించబడింది), వారి సృష్టి తప్పనిసరిగా క్రింది అవసరాలను విధించే ఒక రకమైన ఫ్రేమ్‌వర్క్‌పై ఆధారపడి ఉండాలి:

1. సంస్థాపన సింగిల్ ద్వారా చేయాలి విస్తరణ: kubectl create -f SOME_OPERATOR_URL/deployment.yaml - మరియు అదనపు చర్యలు అవసరం లేదు.
2. Kubernetesలో ఆపరేటర్‌ని ఇన్‌స్టాల్ చేస్తున్నప్పుడు, కొత్త థర్డ్-పార్టీ రకాన్ని తప్పనిసరిగా సృష్టించాలి (థర్డ్‌పార్టీ రిసోర్స్). అప్లికేషన్ ఇన్‌స్టాన్స్‌లను (క్లస్టర్ ఇన్‌స్టాన్స్‌లు) ప్రారంభించడానికి మరియు వాటిని మరింత నిర్వహించడానికి (సంస్కరణలను నవీకరించడం, పునఃపరిమాణం చేయడం మొదలైనవి), వినియోగదారు ఈ రకాన్ని ఉపయోగిస్తారు.
3. సాధ్యమైనప్పుడల్లా, మీరు కుబెర్నెట్స్‌లో నిర్మించిన ఆదిమాలను ఉపయోగించాలి సేవలు и రెప్లికాసెట్స్బాగా పరీక్షించిన మరియు అర్థమయ్యే కోడ్‌ని ఉపయోగించడానికి.
4. ఆపరేటర్‌ల వెనుకబడిన అనుకూలత మరియు వినియోగదారు సృష్టించిన వనరుల యొక్క పాత సంస్కరణలకు మద్దతు అవసరం.
5. ఆపరేటర్ తీసివేయబడితే, అప్లికేషన్ మార్పులు లేకుండా పని చేయడం కొనసాగించాలి.
6. వినియోగదారులు కోరుకున్న అప్లికేషన్ వెర్షన్‌ను నిర్వచించగలరు మరియు అప్లికేషన్ వెర్షన్ అప్‌డేట్‌లను ఆర్కెస్ట్రేట్ చేయగలరు. సాఫ్ట్‌వేర్ అప్‌డేట్‌లు లేకపోవడం అనేది కార్యాచరణ మరియు భద్రతా సమస్యలకు సాధారణ మూలం, కాబట్టి ఆపరేటర్లు ఈ విషయంలో వినియోగదారులకు తప్పనిసరిగా సహాయం చేయాలి.
7. పాడ్‌లు, కాన్ఫిగరేషన్‌లు మరియు నెట్‌వర్క్‌లో సంభావ్య వైఫల్యాలను గుర్తించే ఖోస్ మంకీ వంటి సాధనంతో ఆపరేటర్‌లను పరీక్షించాలి.

etcd ఆపరేటర్

ఆపరేటర్ అమలు ఉదాహరణ - etcd ఆపరేటర్, సిద్ధం ఈ భావన యొక్క ప్రకటన రోజున. etcd క్లస్టర్ కాన్ఫిగరేషన్ కోరమ్‌ను నిర్వహించాల్సిన అవసరం, క్లస్టర్ మెంబర్‌షిప్‌ను రీకాన్ఫిగర్ చేయడం, బ్యాకప్‌లను సృష్టించడం మొదలైన వాటి కారణంగా సంక్లిష్టంగా ఉంటుంది. ఉదాహరణకు, etcd క్లస్టర్‌ను మాన్యువల్‌గా స్కేల్ చేయడం అంటే మీరు కొత్త క్లస్టర్ మెంబర్ కోసం DNS పేరుని సృష్టించాలి, కొత్త etcd ఎంటిటీని ప్రారంభించాలి మరియు కొత్త సభ్యుని గురించి క్లస్టర్‌ని హెచ్చరించాలి (etcdctl సభ్యుడు జోడించండి) ఆపరేటర్ విషయంలో, వినియోగదారు క్లస్టర్ పరిమాణాన్ని మాత్రమే మార్చాలి - మిగతావన్నీ స్వయంచాలకంగా జరుగుతాయి.

మరియు etcd కూడా CoreOSలో సృష్టించబడినందున, దాని ఆపరేటర్ మొదట కనిపించడం చాలా తార్కికంగా ఉంది. అతను ఎలా పని చేస్తాడు? ఆపరేటర్ లాజిక్ మొదలైనవి మూడు భాగాల ద్వారా నిర్ణయించబడుతుంది:

1. గమనించండి. ఆపరేటర్ Kubernetes APIని ఉపయోగించి క్లస్టర్ స్థితిని పర్యవేక్షిస్తారు.
2. విశ్లేషణ. ప్రస్తుత స్థితి మరియు కావలసిన దాని మధ్య తేడాలను కనుగొంటుంది (యూజర్ కాన్ఫిగరేషన్ ద్వారా నిర్వచించబడింది).
3. చర్య. etcd మరియు/లేదా Kubernetes సర్వీస్ APIలను ఉపయోగించి గుర్తించిన తేడాలను పరిష్కరిస్తుంది.

ఈ లాజిక్‌ను అమలు చేయడానికి, ఆపరేటర్‌లో విధులు సిద్ధం చేయబడ్డాయి సృష్టించండి/నాశనం చేయండి (etcd క్లస్టర్ సభ్యులను సృష్టించడం మరియు తొలగించడం) మరియు పునఃపరిమాణం (క్లస్టర్ సభ్యుల సంఖ్యలో మార్పు). నెట్‌ఫ్లిక్స్ నుండి ఖోస్ మంకీ వలె సృష్టించబడిన యుటిలిటీని ఉపయోగించి దాని ఆపరేషన్ యొక్క ఖచ్చితత్వం తనిఖీ చేయబడింది, అనగా. etcd పాడ్‌లను యాదృచ్ఛికంగా చంపడం.

etcd పూర్తి ఆపరేషన్ కోసం, ఆపరేటర్ అదనపు ఫీచర్లను అందిస్తుంది: బ్యాకప్ (బ్యాకప్ కాపీల సృష్టి స్వయంచాలకంగా మరియు వినియోగదారులకు కనిపించదు - కాన్ఫిగరేషన్‌లో వాటిని ఎంత తరచుగా తయారు చేయాలో మరియు ఎన్ని నిల్వ చేయాలో నిర్ణయించడానికి సరిపోతుంది - మరియు వాటి నుండి డేటా యొక్క తదుపరి పునరుద్ధరణ) మరియు నవీకరణ (డౌన్‌టైమ్ లేకుండా etcd ఇన్‌స్టాలేషన్‌లను నవీకరిస్తోంది).

ఆపరేటర్‌తో పని చేయడం ఎలా ఉంటుంది?

$ kubectl create -f https://coreos.com/operators/etcd/latest/deployment.yaml
$ kubectl create -f https://coreos.com/operators/etcd/latest/example-etcd-cluster.yaml
$ kubectl get pods
NAME                             READY     STATUS    RESTARTS   AGE
etcd-cluster-0000                1/1       Running   0          23s
etcd-cluster-0001                1/1       Running   0          16s
etcd-cluster-0002                1/1       Running   0          8s
etcd-cluster-backup-tool-rhygq   1/1       Running   0          18s

etcd ఆపరేటర్ యొక్క ప్రస్తుత స్థితి బీటా వెర్షన్, అమలు చేయడానికి Kubernetes 1.5.3+ మరియు etcd 3.0+ అవసరం. సోర్స్ కోడ్ మరియు డాక్యుమెంటేషన్ (ఉపయోగానికి సంబంధించిన సూచనలతో సహా) ఇక్కడ అందుబాటులో ఉన్నాయి గ్యాలరీలు.

CoreOS నుండి మరొక ఉదాహరణ అమలు సృష్టించబడింది - ప్రోమేతియస్ ఆపరేటర్, కానీ ఇది ఇప్పటికీ ఆల్ఫా వెర్షన్‌లో ఉంది (అన్ని ప్రణాళికాబద్ధమైన లక్షణాలు అమలు చేయబడలేదు).

స్థితి మరియు అవకాశాలు

కుబెర్నెట్స్ ఆపరేటర్ల ప్రకటన నుండి 5 నెలలు గడిచాయి. అధికారిక CoreOS రిపోజిటరీలో (etcd మరియు Prometheus కోసం) ఇంకా రెండు అమలులు మాత్రమే అందుబాటులో ఉన్నాయి. రెండూ ఇంకా వారి స్థిరమైన సంస్కరణలను చేరుకోలేదు, కానీ కమిట్‌లు ప్రతిరోజూ గమనించబడతాయి.

డెవలపర్లు "వినియోగదారులు తమ కుబెర్నెట్స్ క్లస్టర్‌లలో పోస్ట్‌గ్రెస్ ఆపరేటర్‌లు, కాసాండ్రా ఆపరేటర్‌లు లేదా రెడిస్ ఆపరేటర్‌లను ఇన్‌స్టాల్ చేసే భవిష్యత్తును ఊహించారు మరియు ఈ అప్లికేషన్‌ల స్కేలబుల్ ఎంటిటీలతో సులువుగా స్టేట్‌లెస్ వెబ్ అప్లికేషన్‌ల ప్రతిరూపాలను అమలు చేస్తున్నంత సులభంగా పని చేస్తారు." ప్రధమ మూడవ పార్టీ డెవలపర్‌ల నుండి ఆపరేటర్లు నిజంగా కనిపించడం ప్రారంభించింది:

• సాగే శోధన ఆపరేటర్ UPMC ఎంటర్‌ప్రైజెస్ నుండి;
• PostgreSQL ఆపరేటర్ క్రంచీ డేటా నుండి (మార్చి 2017 చివరిలో ప్రకటించబడింది);
• రూక్ ఆపరేటర్ Ceph ఆధారంగా పంపిణీ చేయబడిన డేటా నిల్వ వ్యవస్థ రచయితల నుండి (రూక్ ఆల్ఫా స్థితిలో ఉంది);
• ఓపెన్‌స్టాక్ ఆపరేటర్లు SAP CCloud నుండి.

ఫిబ్రవరి 2017లో బ్రస్సెల్స్‌లో జరిగిన అతిపెద్ద యూరోపియన్ ఫ్రీ సాఫ్ట్‌వేర్ కాన్ఫరెన్స్ FOSDEMలో, CoreOS నుండి జోష్ వుడ్ ఆపరేటర్లను ప్రకటించారు. నివేదిక (లింక్‌లో ఒక వీడియో అందుబాటులో ఉంది!), ఇది విస్తృత ఓపెన్ సోర్స్ కమ్యూనిటీలో ఈ కాన్సెప్ట్ యొక్క జనాదరణ పెరగడానికి దోహదం చేస్తుంది.

PS వ్యాసంపై మీ ఆసక్తికి ధన్యవాదాలు! మా హబ్‌కు సభ్యత్వాన్ని పొందండి, DevOps మరియు GNU/Linux సిస్టమ్ అడ్మినిస్ట్రేషన్‌లో కొత్త మెటీరియల్‌లు మరియు వంటకాలను మిస్ కాకుండా ఉండేందుకు - మేము వాటిని క్రమం తప్పకుండా ప్రచురిస్తాము!

మూలం: www.habr.com