Iwwer déi wuessend Popularitéit vu Kubernetes

Hey Habr!

Um Enn vum Summer wëlle mir Iech drun erënneren, datt mir weider un deem Thema schaffen Kubernetes an huet decidéiert en Artikel aus Stackoverflow ze publizéieren, deen den Zoustand vun de Affären an dësem Projet Ufank Juni demonstréiert.

Genéisst Lies!

Zu der Zäit vun dësem Artikel ze schreiwen ass den Alter vu Kubernetes ongeféier. sechs Joer al, an iwwer déi lescht zwee Joer ass seng Popularitéit sou vill gewuess datt et konsequent ënner klasséiert ass beléifsten Plattformen. Kubernetes klasséiert dëst Joer drëtt. Fir zréckzekréien: Kubernetes ass eng Plattform entwéckelt fir containeriséierter Aarbechtslaascht ze lafen an ze orchestréieren.

Container hunn ugefaang als speziellen Design fir Prozesser an Linux ze isoléieren; Container sinn zënter 2007 abegraff Cgruppen, an zënter 2002 - Nummraim. Container goufen nach besser entworf bis 2008, wéi et verfügbar gouf LXC, a Google entwéckelt säin eegene internen Firmemechanismus genannt Borg, wou "all Aarbecht a Container gemaach gëtt." Vun hei aus gi mir séier op 2013, wéi déi éischt Verëffentlechung vum Docker stattfonnt huet, a Container endlech eng populär Masseléisung ginn. Deemools war den Haaptinstrument fir d'Containerorchestratioun Mesos, obwuel hien net ganz populär war. Kubernetes gouf fir d'éischt am Joer 2015 verëffentlecht, duerno gouf dëst Tool de de facto Standard am Beräich vun der Containerorchestratioun.

Fir ze probéieren ze verstoen firwat Kubernetes sou populär ass, loosst eis probéieren e puer Froen ze beäntweren. Wéini war d'leschte Kéier datt d'Entwéckler sech averstane kënnen iwwer wéi d'Applikatioune fir d'Produktioun ofsetzen? Wéi vill Entwéckler wësst Dir déi d'Tools benotzen wéi se aus der Këscht geliwwert ginn? Wéi vill Cloud Administrateuren ginn et haut déi net verstinn wéi d'Applikatiounen funktionnéieren? Mir wäerten d'Äntwerten op dës Froen an dësem Artikel kucken.

Infrastruktur als YAML

An der Welt, déi vu Puppet a Chef op Kubernetes gaangen ass, war eng vun de gréissten Ännerungen de Beweegung vun "Infrastruktur als Code" op "Infrastruktur als Daten" - speziell wéi YAML. All Ressourcen an Kubernetes, déi Pods, Konfiguratiounen, ofgebauten Instanzen, Bänn, etc., kënnen einfach an enger YAML Datei beschriwwe ginn. Zum Beispill:

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

Dës Vue mécht et méi einfach fir DevOps oder SRE Fachleit hir Aarbechtslaascht voll auszedrécken ouni Code a Sprooche wéi Python oder Javascript ze schreiwen.

Aner Virdeeler vun der Organisatioun vun Infrastruktur als Daten enthalen:

• GitOps oder Git Operations Version Control. Dës Approche erlaabt Iech all Kubernetes YAML Dateien an Git Repositories ze halen, sou datt Dir genau verfollegt wéini eng Ännerung gemaach gouf, wien et gemaach huet a wat genee geännert huet. Dëst erhéicht d'Transparenz vun den Operatiounen uechter d'Organisatioun a verbessert d'operationell Effizienz andeems d'Ambiguitéit eliminéiert gëtt, besonnesch wou d'Mataarbechter no de Ressourcen sichen déi se brauchen. Zur selwechter Zäit gëtt et méi einfach automatesch Ännerungen op Kubernetes Ressourcen ze maachen andeems Dir einfach eng Pull-Ufro fusionéiert.
• Skalierbarkeet. Wann Ressourcen als YAML definéiert sinn, gëtt et extrem einfach fir Clusterbetreiber eng oder zwou Zuelen an enger Kubernetes Ressource z'änneren, an doduerch z'änneren wéi et skaléiert. Kubernetes bitt e Mechanismus fir horizontal Autoscaling vu Pods, dee ka benotzt ginn fir bequem ze bestëmmen wat d'Mindest- a Maximal Unzuel vu Pods an enger bestëmmter Deploymentkonfiguratioun erfuerderlech sinn fir niddereg an héich Trafficniveauen ze handhaben. Zum Beispill, wann Dir eng Konfiguratioun agesat hutt déi zousätzlech Kapazitéit erfuerdert wéinst enger plötzlecher Spike am Traffic, da kënnen maxReplicas vun 10 op 20 geännert ginn:

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

• Sécherheet a Gestioun. YAML ass super fir ze evaluéieren wéi d'Saachen a Kubernetes ofgebaut ginn. Zum Beispill, eng grouss Sécherheet Suerg betrëfft ob Är Aarbechtslaaschten als Net-Administrateur Benotzer lafen. An dësem Fall kënne mir Tools wéi z contest, YAML/JSON Validator, plus Open Politik Agent, eng Politik Validator ze garantéieren, datt de Kontext Sécherheetskontext Är Aarbechtslaascht erlaabt de Container net mat Administrator Privilegien ze lafen. Wann dat néideg ass, kënnen d'Benotzer eng einfach Politik uwenden Ech bieden, esou:

package main

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

• Optiounen fir Integratioun mat engem Cloud Provider. Ee vun de bemierkenswäertsten Trends an der haiteger High-Technologie ass d'Aarbechtslaascht op ëffentlech Cloud Ubidder ze lafen. Benotzt de Komponent Cloud-Provider Kubernetes erlaabt all Cluster mat dem Cloud Provider z'integréieren op deem et leeft. Zum Beispill, wann e Benotzer eng Applikatioun a Kubernetes op AWS leeft an dës Applikatioun duerch e Service wëll aussoen, hëlleft de Cloud Provider automatesch de Service ze kreéieren LoadBalancerdéi automatesch de Lastbalancer ubitt Amazon Elastic Load Balancerfir de Verkéier op d'Applikatioun Pods ze redirectéieren.

Ausbaubarkeet

Kubernetes ass ganz erweiterbar an d'Entwéckler hunn et gär. Et gëtt eng Rei vu verfügbare Ressourcen wéi Pods, Deployment, StatefulSets, Geheimnisser, ConfigMaps, etc. True, Benotzer an Entwéckler kënnen aner Ressourcen an der Form derbäi Benotzerdefinéiert Ressource Definitiounen.

Zum Beispill, wa mir eng Ressource definéieren wëllen CronTab, da kéint Dir esou eppes maachen:

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

Méi spéit kënne mir eng CronTab Ressource esou eppes erstellen:

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

Eng aner Optioun fir Extensibilitéit an Kubernetes ass datt den Entwéckler seng eege Aussoe schreiwen kann. Betreiber ass e spezielle Prozess am Kubernetes Cluster deen no der "Kontroll Circuit" Mat der Hëllef vun engem Bedreiwer kann de Benotzer d'Gestioun vun CRDs (Custom Ressource Definitiounen) automatiséieren andeems Dir Informatioun mat der Kubernetes API austauscht.

Et gi verschidde Tools an der Gemeinschaft déi et einfach maachen fir Entwéckler hir eege Betreiber ze kreéieren. Ënnert hinnen - Bedreiwer Kader a seng Bedreiwer SDK. Dës SDK bitt e Fundament aus deem en Entwéckler séier en Bedreiwer ka ufänke. Loosst eis soen, Dir kënnt vun der Kommandozeil eppes wéi dëst ufänken:

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

Dëst erstellt all Kesselcode fir Ären Bedreiwer, dorënner YAML Dateien a Golang Code:

.
|____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

Da kënnt Dir déi erfuerderlech APIen a Controller addéieren, sou:

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

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

Dann, endlech, montéiert den Bedreiwer a schéckt en an de Registry vun Ärem Container:

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

Wann den Entwéckler nach méi Kontroll wëllt, kann de Boilerplate Code a Go Dateien geännert ginn. Zum Beispill, fir d'Spezifizitéiten vum Controller z'änneren, kënnt Dir Ännerungen an der Datei maachen controller.go.

En anere Projet iwerall, erlaabt Iech Aussoe mat nëmmen deklarativen YAML Dateien ze erstellen. Zum Beispill, e Bedreiwer fir Apache Kafka wier ongeféier definéiert sou. Mat et kënnt Dir e Kafka-Cluster uewen op Kubernetes mat just e puer Kommandoen installéieren:

$ kubectl kudo install zookeeper
$ kubectl kudo install kafka

An dann konfiguréieren et mat engem anere Kommando:

$ 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

Innovatioun

An de leschte Jore sinn grouss Kubernetes Verëffentlechungen all puer Méint erauskomm - dat ass, dräi bis véier grouss Verëffentlechungen pro Joer. D'Zuel vun den neie Fonctiounen, déi a jidderee vun hinnen agefouert goufen, geet net erof. Ausserdeem gëtt et och an dëse schwieregen Zäiten keng Unzeeche fir ze bremsen - kuckt wéi d'Situatioun elo ass Kubernetes Projet Aktivitéit op Github.

Nei Fäegkeeten erlaben Iech méi flexibel Operatiounen iwwer verschidden Aarbechtsbelaaschtungen ze clusteren. Zousätzlech genéissen d'Programméierer méi Kontroll wann se Uwendungen direkt an d'Produktioun ofsetzen.

Gemeinschaft

En anere groussen Aspekt vun der Popularitéit vum Kubernetes ass d'Stäerkt vu senger Gemeinschaft. Am Joer 2015, nodeems d'Versioun 1.0 erreecht gouf, gouf Kubernetes gesponsert vun Cloud Native Computing Foundation.

Et ginn och verschidde Communautéiten SIG (Special Interest Groups) konzentréiert sech op d'Aarbecht op verschiddene Beräicher vu Kubernetes wéi de Projet evoluéiert. Dës Gruppe fügen stänneg nei Features derbäi, fir mat Kubernetes méi praktesch a praktesch ze schaffen.

D'Cloud Native Foundation hält och CloudNativeCon/KubeCon, déi, am Schreiwenzäit, déi gréissten Open Source Konferenz op der Welt ass. Normalerweis dräimol am Joer ofgehalen, bréngt et Dausende vu Fachleit zesummen, déi Kubernetes a säin Ökosystem verbesseren wëllen, souwéi nei Features léieren, déi all dräi Méint erschéngen.

Ausserdeem huet d'Cloud Native Foundation Technesch Iwwerwaachung Comité, déi zesumme mat SIGs nei a bestehend iwwerpréift Projeten Fongen konzentréiert sech op de Cloud-Ökosystem. Déi meescht vun dëse Projeten hëllefen d'Stäerkte vu Kubernetes ze verbesseren.

Schlussendlech gleewen ech datt de Kubernetes net sou erfollegräich wier wéi et ass ouni déi bewosst Efforte vun der ganzer Gemeinschaft, wou d'Leit zesummenhänken, awer gläichzäiteg Newcomer an d'Fall begréissen.

D'Zukunft

Eng vun den Haapterausfuerderunge mat deenen d'Entwéckler an Zukunft musse këmmeren ass d'Fäegkeet sech op d'Detailer vum Code selwer ze fokusséieren, an net op d'Infrastruktur an där se leeft. Et entsprécht dësen Trends serverless architektonescht Paradigma, déi ee vun de féierende haut ass. Fortgeschratt Kadere ginn et schonn, z.B. Messer и OpenFaas, déi Kubernetes benotze fir d'Infrastruktur vum Entwéckler ze abstrakt.

An dësem Artikel hu mir nëmmen d'Uewerfläch vum aktuellen Zoustand vu Kubernetes gekräizt - tatsächlech ass et just den Tipp vum Äisbierg. Kubernetes Benotzer hu vill aner Ressourcen, Fäegkeeten a Konfiguratiounen zur Verfügung.

Source: will.com