కుబెర్నెట్స్ యొక్క పెరుగుతున్న ప్రజాదరణ గురించి

హే హబ్ర్!

వేసవి చివరిలో, మేము అంశంపై పని చేస్తూనే ఉన్నామని మేము మీకు గుర్తు చేయాలనుకుంటున్నాము Kubernetes మరియు జూన్ ప్రారంభంలో ఈ ప్రాజెక్ట్‌లోని వ్యవహారాల స్థితిని ప్రదర్శిస్తూ Stackoverflow నుండి ఒక కథనాన్ని ప్రచురించాలని నిర్ణయించుకుంది.

మంచి పఠనం!

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

Linuxలో ప్రక్రియలను వేరుచేయడానికి కంటైనర్‌లు ప్రత్యేక రూపకల్పనగా ప్రారంభమయ్యాయి; కంటైనర్లు 2007 నుండి చేర్చబడ్డాయి cgroups, మరియు 2002 నుండి – నేమ్‌స్పేస్‌లు. కంటైనర్లు అందుబాటులోకి వచ్చిన 2008 నాటికి మరింత మెరుగ్గా రూపొందించబడ్డాయి ఎల్‌ఎక్స్‌సి, మరియు Google అనే దాని స్వంత అంతర్గత కార్పొరేట్ మెకానిజంను అభివృద్ధి చేసింది బోర్గ్, ఇక్కడ "అన్ని పని కంటైనర్లలో జరుగుతుంది." ఇక్కడ నుండి మేము డాకర్ యొక్క మొదటి విడుదల జరిగిన 2013కి ఫాస్ట్ ఫార్వార్డ్ చేసాము మరియు చివరకు కంటైనర్‌లు ఒక ప్రసిద్ధ సామూహిక పరిష్కారంగా మారాయి. ఆ సమయంలో, కంటైనర్ ఆర్కెస్ట్రేషన్ యొక్క ప్రధాన సాధనం మెసోస్, అతను విపరీతంగా ప్రజాదరణ పొందనప్పటికీ. కుబెర్నెటెస్ మొదటిసారిగా 2015లో విడుదలైంది, ఆ తర్వాత ఈ సాధనం కంటైనర్ ఆర్కెస్ట్రేషన్ రంగంలో వాస్తవ ప్రమాణంగా మారింది.

కుబెర్నెటీస్ ఎందుకు బాగా ప్రాచుర్యం పొందిందో అర్థం చేసుకోవడానికి, కొన్ని ప్రశ్నలకు సమాధానం ఇవ్వడానికి ప్రయత్నిద్దాం. అప్లికేషన్‌లను ఉత్పత్తికి ఎలా అమర్చాలనే దానిపై డెవలపర్‌లు చివరిసారి ఎప్పుడు అంగీకరించగలిగారు? సాధనాలు పెట్టె వెలుపల అందించబడినందున వాటిని ఉపయోగించే డెవలపర్‌లు ఎంతమంది మీకు తెలుసు? అప్లికేషన్‌లు ఎలా పనిచేస్తాయో అర్థం కాని క్లౌడ్ అడ్మినిస్ట్రేటర్‌లు ఎంత మంది ఉన్నారు? ఈ ప్రశ్నలకు సమాధానాలను ఈ వ్యాసంలో చూద్దాం.

YAML వలె మౌలిక సదుపాయాలు

పప్పెట్ మరియు చెఫ్ నుండి కుబెర్నెటెస్‌కి వెళ్ళిన ప్రపంచంలో, "ఇన్‌ఫ్రాస్ట్రక్చర్‌ను కోడ్‌గా" నుండి "ఇన్‌ఫ్రాస్ట్రక్చర్ డేటా"కి-ప్రత్యేకంగా, YAML లాగా మార్చడం అతిపెద్ద మార్పులలో ఒకటి. పాడ్‌లు, కాన్ఫిగరేషన్‌లు, డిప్లాయ్డ్ ఇన్‌స్టాన్స్‌లు, వాల్యూమ్‌లు మొదలైన వాటితో కూడిన కుబెర్నెట్స్‌లోని అన్ని వనరులను సులభంగా YAML ఫైల్‌లో వివరించవచ్చు. ఉదాహరణకి:

apiVersion: v1
kind: Pod
metadata:
  name: site
  labels:
    app: web
spec:
  containers:
    - name: front-end
      image: nginx
      ports:
        - containerPort: 80

పైథాన్ లేదా జావాస్క్రిప్ట్ వంటి భాషల్లో కోడ్ రాయాల్సిన అవసరం లేకుండానే DevOps లేదా SRE నిపుణులు తమ పనిభారాన్ని పూర్తిగా వ్యక్తీకరించడాన్ని ఈ వీక్షణ సులభతరం చేస్తుంది.

మౌలిక సదుపాయాలను డేటాగా నిర్వహించడం వల్ల కలిగే ఇతర ప్రయోజనాలు:

• GitOps లేదా Git ఆపరేషన్స్ వెర్షన్ కంట్రోల్. ఈ విధానం మీరు అన్ని Kubernetes YAML ఫైల్‌లను git రిపోజిటరీలలో ఉంచడానికి అనుమతిస్తుంది, కాబట్టి మీరు ఎప్పుడు మార్పు చేసారు, ఎవరు చేసారు మరియు సరిగ్గా ఏమి మార్చారు. ఇది సంస్థ అంతటా కార్యకలాపాల యొక్క పారదర్శకతను పెంచుతుంది మరియు అస్పష్టతను తొలగించడం ద్వారా కార్యాచరణ సామర్థ్యాన్ని మెరుగుపరుస్తుంది, ప్రత్యేకించి ఉద్యోగులు వారికి అవసరమైన వనరుల కోసం వెతకాలి. అదే సమయంలో, పుల్ అభ్యర్థనను విలీనం చేయడం ద్వారా కుబెర్నెట్స్ వనరులకు స్వయంచాలకంగా మార్పులు చేయడం సులభం అవుతుంది.
• స్కేలబిలిటీ. వనరులు YAMLగా నిర్వచించబడినప్పుడు, క్లస్టర్ ఆపరేటర్‌లు కుబెర్నెట్స్ రిసోర్స్‌లో ఒకటి లేదా రెండు సంఖ్యలను మార్చడం చాలా సులభం అవుతుంది, తద్వారా అది ఎలా స్కేల్ అవుతుంది. కుబెర్నెటెస్ పాడ్‌ల యొక్క క్షితిజసమాంతర ఆటోస్కేలింగ్ కోసం ఒక యంత్రాంగాన్ని అందిస్తుంది, తక్కువ మరియు అధిక స్థాయి ట్రాఫిక్‌ని నిర్వహించడానికి నిర్దిష్ట విస్తరణ కాన్ఫిగరేషన్‌లో కనీస మరియు గరిష్ట సంఖ్యలో పాడ్‌లు ఏమి అవసరమో సౌకర్యవంతంగా నిర్ణయించడానికి దీనిని ఉపయోగించవచ్చు. ఉదాహరణకు, మీరు ట్రాఫిక్‌లో అకస్మాత్తుగా పెరిగిన కారణంగా అదనపు సామర్థ్యం అవసరమయ్యే కాన్ఫిగరేషన్‌ని అమలు చేసి ఉంటే, అప్పుడు maxReplicasని 10 నుండి 20కి మార్చవచ్చు:

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp-deployment
  minReplicas: 1
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

• భద్రత మరియు నిర్వహణ. కుబెర్నెట్స్‌లో విషయాలు ఎలా అమలు చేయబడతాయో విశ్లేషించడానికి YAML గొప్పది. ఉదాహరణకు, మీ వర్క్‌లోడ్‌లు నాన్-అడ్మిన్ యూజర్‌గా రన్ అవుతున్నాయా లేదా అనేది ప్రధాన భద్రతా సమస్య. ఈ సందర్భంలో, మనకు వంటి సాధనాలు అవసరం కావచ్చు ఘర్షణ, YAML/JSON వాలిడేటర్, ప్లస్ పాలసీ ఏజెంట్‌ని తెరవండి, సందర్భాన్ని నిర్ధారించడానికి పాలసీ వ్యాలిడేటర్ భద్రతా సందర్భం మీ పనిభారం కంటైనర్‌ను నిర్వాహక అధికారాలతో అమలు చేయడానికి అనుమతించదు. ఇది అవసరమైతే, వినియోగదారులు సాధారణ విధానాన్ని వర్తింపజేయవచ్చు నేను ప్రార్థిస్తున్నాను, ఇలా:

package main

deny[msg] {
  input.kind = "Deployment"
  not input.spec.template.spec.securityContext.runAsNonRoot = true
  msg = "Containers must not run as root"
}

• క్లౌడ్ ప్రొవైడర్‌తో ఏకీకరణ కోసం ఎంపికలు. పబ్లిక్ క్లౌడ్ ప్రొవైడర్‌లపై పనిభారాన్ని అమలు చేయడం నేటి హై టెక్నాలజీలో అత్యంత గుర్తించదగిన ట్రెండ్‌లలో ఒకటి. భాగం ఉపయోగించి క్లౌడ్ ప్రొవైడర్ కుబెర్నెటెస్ ఏదైనా క్లస్టర్‌ని అది నడుస్తున్న క్లౌడ్ ప్రొవైడర్‌తో ఏకీకృతం చేయడానికి అనుమతిస్తుంది. ఉదాహరణకు, ఒక వినియోగదారు AWSలో కుబెర్నెట్స్‌లో ఒక అప్లికేషన్‌ను రన్ చేసి, ఆ అప్లికేషన్‌ను సేవ ద్వారా బహిర్గతం చేయాలనుకుంటే, క్లౌడ్ ప్రొవైడర్ స్వయంచాలకంగా సేవను రూపొందించడంలో సహాయపడుతుంది LoadBalancerఇది స్వయంచాలకంగా లోడ్ బ్యాలెన్సర్‌ను అందిస్తుంది అమెజాన్ సాగే లోడ్ బ్యాలెన్సర్అప్లికేషన్ పాడ్‌లకు ట్రాఫిక్‌ను దారి మళ్లించడానికి.

విస్తరణ

కుబెర్నెటెస్ చాలా విస్తరించదగినది మరియు డెవలపర్‌లు దీన్ని ఇష్టపడతారు. పాడ్‌లు, విస్తరణలు వంటి అందుబాటులో ఉన్న వనరుల సమితి ఉంది. StatefulSets, రహస్యాలు, ConfigMaps, మొదలైనవి నిజమే, వినియోగదారులు మరియు డెవలపర్‌లు ఫారమ్‌లో ఇతర వనరులను జోడించగలరు అనుకూల వనరుల నిర్వచనాలు.

ఉదాహరణకు, మేము ఒక వనరును నిర్వచించాలనుకుంటే CronTab, అప్పుడు మీరు ఇలా చేయవచ్చు:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: crontabs.my.org
spec:
  group: my.org
  versions:
    - name: v1
      served: true
      storage: true
      Schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                cronSpec:
                  type: string
                  pattern: '^(d+|*)(/d+)?(s+(d+|*)(/d+)?){4}$'
                replicas:
                  type: integer
                  minimum: 1
                  maximum: 10
  scope: Namespaced
  names:
    plural: crontabs
    singular: crontab
    kind: CronTab
    shortNames:
    - ct

తరువాత మనం CronTab వనరుని ఇలా సృష్టించవచ్చు:

apiVersion: "my.org/v1"
kind: CronTab
metadata:
  name: my-cron-object
spec:
  cronSpec: "* * * * */5"
  image: my-cron-image
  replicas: 5

కుబెర్నెటెస్‌లో పొడిగింపు కోసం మరొక ఎంపిక ఏమిటంటే డెవలపర్ తన స్వంత స్టేట్‌మెంట్‌లను వ్రాయవచ్చు. ఆపరేటర్లు కుబెర్నెటెస్ క్లస్టర్‌లో ఒక ప్రత్యేక ప్రక్రియ ప్రకారం పని చేస్తుందినియంత్రణ సర్క్యూట్" ఆపరేటర్ సహాయంతో, వినియోగదారు కుబెర్నెటెస్ APIతో సమాచారాన్ని మార్పిడి చేయడం ద్వారా CRDల (కస్టమ్ రిసోర్స్ నిర్వచనాలు) నిర్వహణను ఆటోమేట్ చేయవచ్చు.

డెవలపర్‌లు తమ స్వంత ఆపరేటర్‌లను సృష్టించడాన్ని సులభతరం చేసే అనేక సాధనాలు సంఘంలో ఉన్నాయి. వారందరిలో - ఆపరేటర్ ఫ్రేమ్‌వర్క్ మరియు అతని ఆపరేటర్ SDK. ఈ SDK ఒక పునాదిని అందిస్తుంది, దీని నుండి డెవలపర్ త్వరగా ఆపరేటర్‌ని సృష్టించడం ప్రారంభించవచ్చు. మీరు కమాండ్ లైన్ నుండి ఇలా ప్రారంభించవచ్చని అనుకుందాం:

$ operator-sdk new my-operator --repo github.com/myuser/my-operator

ఇది YAML ఫైల్‌లు మరియు గోలాంగ్ కోడ్‌తో సహా మీ ఆపరేటర్ కోసం అన్ని బాయిలర్‌ప్లేట్ కోడ్‌ను సృష్టిస్తుంది:

.
|____cmd
| |____manager
| | |____main.go
|____go.mod
|____deploy
| |____role.yaml
| |____role_binding.yaml
| |____service_account.yaml
| |____operator.yaml
|____tools.go
|____go.sum
|____.gitignore
|____version
| |____version.go
|____build
| |____bin
| | |____user_setup
| | |____entrypoint
| |____Dockerfile
|____pkg
| |____apis
| | |____apis.go
| |____controller
| | |____controller.go

అప్పుడు మీరు అవసరమైన APIలు మరియు కంట్రోలర్‌ను ఇలా జోడించవచ్చు:

$ operator-sdk add api --api-version=myapp.com/v1alpha1 --kind=MyAppService

$ operator-sdk add controller --api-version=myapp.com/v1alpha1 --kind=MyAppService

ఆపై, చివరకు, ఆపరేటర్‌ను సమీకరించండి మరియు దానిని మీ కంటైనర్ రిజిస్ట్రీకి పంపండి:

$ operator-sdk build your.container.registry/youruser/myapp-operator

డెవలపర్ మరింత నియంత్రణను కోరుకుంటే, Go ఫైల్‌లలోని బాయిలర్‌ప్లేట్ కోడ్‌ని మార్చవచ్చు. ఉదాహరణకు, కంట్రోలర్ యొక్క ప్రత్యేకతలను సవరించడానికి, మీరు ఫైల్‌కు మార్పులు చేయవచ్చు controller.go.

మరో ప్రాజెక్ట్ కుడో, డిక్లరేటివ్ YAML ఫైల్‌లను మాత్రమే ఉపయోగించి స్టేట్‌మెంట్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఉదాహరణకు, Apache Kafka కోసం ఒక ఆపరేటర్ సుమారుగా నిర్వచించబడుతుంది కాబట్టి. దానితో, మీరు కేవలం రెండు ఆదేశాలతో కుబెర్నెట్స్ పైన కాఫ్కా క్లస్టర్‌ను ఇన్‌స్టాల్ చేయవచ్చు:

$ kubectl kudo install zookeeper
$ kubectl kudo install kafka

ఆపై దానిని మరొక ఆదేశంతో కాన్ఫిగర్ చేయండి:

$ kubectl kudo install kafka --instance=my-kafka-name 
            -p ZOOKEEPER_URI=zk-zookeeper-0.zk-hs:2181 
            -p ZOOKEEPER_PATH=/my-path -p BROKER_CPUS=3000m 
            -p BROKER_COUNT=5 -p BROKER_MEM=4096m 
            -p DISK_SIZE=40Gi -p MIN_INSYNC_REPLICAS=3 
            -p NUM_NETWORK_THREADS=10 -p NUM_IO_THREADS=20

ఆవిష్కరణలు

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

కొత్త సామర్థ్యాలు విభిన్న పనిభారంలో మరింత సరళంగా క్లస్టర్ కార్యకలాపాలకు మిమ్మల్ని అనుమతిస్తాయి. అదనంగా, ప్రోగ్రామర్లు నేరుగా ఉత్పత్తికి అప్లికేషన్‌లను అమలు చేస్తున్నప్పుడు ఎక్కువ నియంత్రణను పొందుతారు.

కమ్యూనిటీ

కుబెర్నెటెస్ యొక్క ప్రజాదరణ యొక్క మరొక ప్రధాన అంశం దాని సంఘం యొక్క బలం. 2015లో, వెర్షన్ 1.0కి చేరుకున్న తర్వాత, కుబెర్నెటెస్ స్పాన్సర్ చేయబడింది క్లౌడ్ స్థానిక కంప్యూటింగ్ ఫౌండేషన్.

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

క్లౌడ్ నేటివ్ ఫౌండేషన్ CloudNativeCon/KubeConని కూడా నిర్వహిస్తుంది, ఇది వ్రాసే సమయంలో, ప్రపంచంలోనే అతిపెద్ద ఓపెన్ సోర్స్ కాన్ఫరెన్స్. సాధారణంగా సంవత్సరానికి మూడు సార్లు నిర్వహించబడుతుంది, ఇది కుబెర్నెట్స్ మరియు దాని పర్యావరణ వ్యవస్థను మెరుగుపరచాలనుకునే వేలాది మంది నిపుణులను ఒకచోట చేర్చుతుంది, అలాగే ప్రతి మూడు నెలలకోసారి కనిపించే కొత్త ఫీచర్లను నేర్చుకుంటుంది.

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

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

భవిష్యత్తు

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

ఈ కథనంలో, మేము ప్రస్తుత కుబెర్నెటెస్ స్థితి యొక్క ఉపరితలంపై మాత్రమే గీతలు చేసాము-వాస్తవానికి, ఇది మంచుకొండ యొక్క కొన మాత్రమే. Kubernetes వినియోగదారులు అనేక ఇతర వనరులు, సామర్థ్యాలు మరియు కాన్ఫిగరేషన్‌లను కలిగి ఉన్నారు.

మూలం: www.habr.com