🥇 Kubernetes ausbauen an ergänzen (Iwwerpréiwung a Videobericht)

8. Abrëll op der Konferenz Saint HighLoad++ 2019, als Deel vun der Rubrik "DevOps and Operations" gouf e Bericht "Kubernetes erweidert an ergänzt", an der Schafung vun deenen dräi Mataarbechter vun der Flant Firma deelgeholl hunn. An et schwätze mir iwwer vill Situatiounen, an deenen mir d'Fäegkeete vu Kubernetes wollten ausbauen an ergänzen, awer fir déi mir keng fäerdeg an einfach Léisung fonnt hunn. Mir hunn déi néideg Léisungen a Form vun Open Source Projeten, an dës Ried ass och hinnen gewidmet.

Vun Traditioun si mir frou Iech ze presentéieren Video vum Bericht (50 Minutten, vill méi informativ wéi den Artikel) an den Haaptresumé an Textform. Gitt!

Kär an Ergänzunge an K8s

Kubernetes ännert d'Industrie an d'Approche fir d'Verwaltung déi laang etabléiert sinn:

Merci him Abstraktiounen, mir funktionnéieren net méi mat Konzepter wéi eng Configuratioun opzestellen oder e Kommando auszeféieren (Chef, Ansible ...), mee benotze Gruppéierung vu Container, Servicer, asw.
Mir kënnen Uwendungen virbereeden ouni iwwer d'Nuancen vun der ze denken spezifesche Site, op deem et lancéiert gëtt: Bare Metal, Wollek vun engem vun de Provider, etc.
Mat K8s sidd Dir ni méi zougänglech beschte Praktiken iwwer d'Organisatioun vun Infrastrukturen: Skaléierungstechniken, Selbstheilung, Feelertoleranz, asw.

Wéi och ëmmer, alles ass net sou glat: Kubernetes huet och seng nei Erausfuerderunge bruecht.

Kubernetes Net ass eng Kombinatioun déi all d'Problemer vun all Benotzer léist. De Kär Kubernetes ass verantwortlech nëmme fir eng Rei vun de Minimum néideg Funktiounen, déi präsent sinn an all Cluster:

De Kubernetes Kär definéiert eng Basisset vu Primitiv fir Container ze gruppéieren, Traffic ze managen, asw. Mir hunn iwwer si méi am Detail geschwat Rapport virun 2 Joer.

Op der anerer Säit bitt K8s super Méiglechkeeten fir déi verfügbar Funktiounen auszebauen, déi hëllefen anerer zouzemaachen - spezifesch - Benotzer brauch. Ergänzunge fir Kubernetes sinn d'Verantwortung vun de Clusteradministratoren, déi alles installéieren an konfiguréieren fir hire Cluster "an déi richteg Form" ze kréien [fir hir spezifesch Problemer ze léisen]. Wéi eng Ergänzunge sinn dat? Loosst eis e puer Beispiller kucken.

Beispiller vun Add-ons

Nodeems Dir Kubernetes installéiert hutt, kënne mir iwwerrascht sinn datt d'Netzwierk, déi sou noutwendeg ass fir d'Interaktioun vu Pods souwuel an engem Node wéi och tëscht Node, net eleng funktionnéiert. De Kubernetes Kernel garantéiert net déi néideg Verbindungen; amplaz bestëmmt et d'Netzwierk Interface (CNI) fir Drëtt Partei Add-ons. Mir mussen eng vun dësen Add-ons installéieren, déi fir d'Netzkonfiguratioun verantwortlech sinn.

En enk Beispill ass Datenspeicherléisungen (lokal Disk, Netzwierkblockapparat, Ceph ...). Am Ufank waren se am Kär, awer mam Advent CSI d'Situatioun ännert sech op eppes ähnlech wéi dat scho beschriwwen: d'Interface ass a Kubernetes, a seng Ëmsetzung ass an Drëtt-Partei Moduler.

Aner Beispiller enthalen:

Ingress-Kontroller (kuckt hir Iwwerpréiwung an eise rezenten Artikel).
cert-Manager:
Betreiber ass eng ganz Klass vun Add-ons (wat den ernimmten Certificat-Manager enthält), si definéieren primitiv (en) a Controller (en). D'Logik vun hirer Aarbecht ass nëmme vun eiser Fantasi limitéiert an erlaabt eis fäerdeg Infrastrukturkomponenten (zum Beispill e DBMS) a Primitiv ze maachen, mat deenen vill méi einfach ze schaffen (wéi mat enger Rei vu Container an hiren Astellungen). Eng riesech Unzuel vun Opérateuren ass geschriwwe ginn - och wa vill vun hinnen nach net fäerdeg sinn fir d'Produktioun, et ass nëmmen eng Fro vun der Zäit:
Metriken - eng aner Illustratioun vu wéi Kubernetes d'Interface (Metrics API) vun der Implementatioun getrennt huet (Drëtt Partei Add-ons wéi Prometheus Adapter, Datadog Cluster Agent ...).
fir Iwwerwachung a Statistiken, wou an der Praxis net nëmme gebraucht ginn Prometheus und Grafana, awer och Kube-State-Metrics, Node-Exporter, etc.

An dat ass net eng komplett Lëscht vun Ergänzunge ... Zum Beispill installéiere mir bei der Flant Firma 29 Add-ons (all déi am Ganzen 249 Kubernetes Objeten erstellen). Einfach gesot, mir kënnen d'Liewen vun engem Cluster net ouni Ergänzunge gesinn.

Automatioun

Bedreiwer sinn entwéckelt fir Routineoperatiounen ze automatiséieren déi mir all Dag begéinen. Hei sinn real-Liewen Beispiller fir déi e Bedreiwer schreiwen wier eng exzellent Léisung:

Et gëtt e privaten (dh e Login erfuerdert) Registry mat Biller fir d'Applikatioun. Et gëtt ugeholl datt all Pod e spezielle Geheimnis zougewisen gëtt, deen d'Authentifikatioun am Registry erlaabt. Eis Aufgab ass et ze garantéieren datt dëst Geheimnis am Nummraum fonnt gëtt, sou datt Pods Biller kënnen eroflueden. Et kënne vill Applikatiounen sinn (jidderee vun deenen e Geheimnis brauch), an et ass nëtzlech d'Geheimnisser selwer regelméisseg ze aktualiséieren, sou datt d'Optioun fir Geheimnisser mat der Hand auszeleeën ass eliminéiert. Dëst ass wou de Bedreiwer op d'Rettung kënnt: Mir kreéieren e Controller dee waart bis den Nummraum erschéngt a baséiert op dësem Event e Geheimnis an den Nummraum bäidréit.
Loosst Par défaut Zougang vu Pods op den Internet ass verbueden. Awer heiansdo kann et erfuerderlech sinn: et ass logesch datt den Zougangserlaabnesmechanismus einfach funktionnéiert, ouni spezifesch Fäegkeeten ze erfuerderen, zum Beispill duerch d'Präsenz vun engem bestëmmte Label am Nummraum. Wéi kann de Bedreiwer eis hei hëllefen? E Controller gëtt erstallt, dee waart bis de Label am Nummraum erschéngt an déi entspriechend Politik fir den Internetzougang bäidréit.
Eng ähnlech Situatioun: ugeholl, mir missten eng gewëssen derbäisetzen uerdentlech, wann et en ähnleche Label huet (mat enger Aart vu Präfix). D'Aktiounen mam Bedreiwer sinn offensichtlech ...

An all Cluster muss Routine Aufgaben geléist ginn, an richteg dëst kann mat Betreiber gemaach ginn.

All déi beschriwwe Geschichten zesummefaassen, si mir zur Conclusioun komm fir bequem Aarbecht an Kubernetes Dir braucht:A) add-ons installéieren, b) entwéckelen Opérateuren (fir alldeeglech Administratiounsaufgaben ze léisen).

Wéi eng Ausso fir Kubernetes ze schreiwen?

Am Allgemengen ass de Schema einfach:

... mee dann stellt sech eraus datt:

De Kubernetes API ass eng zimlech net-trivial Saach déi vill Zäit brauch fir ze beherrschen;
Programméiere ass och net fir jiddereen (d'Go Sprooch gouf als déi léifste Sprooch gewielt well et e spezielle Kader dofir ass - Bedreiwer SDK);
D'Situatioun ass ähnlech mam Kader selwer.

Stréch: e Controller ze schreiwen (Bedreiwer) muss bedeitend Ressourcen ausginn Material ze studéieren. Dëst wier gerechtfäerdegt fir "grouss" Betreiber - soen, fir de MySQL DBMS. Awer wa mir eis uewe beschriwwen Beispiller erënneren (Geheimnisser entfalen, Pods op den Internet kréien ...), déi mir och richteg maache wëllen, da wäerte mir verstoen datt d'Ustrengung, déi ausginn ass, méi wéi d'Resultat ass, déi mir elo brauchen:

Am Allgemengen entsteet en Dilemma: verbréngt vill Ressourcen a fënnt dat richtegt Tool fir Aussoen ze schreiwen, oder maacht et op almodesch Manéier (awer séier). Fir et ze léisen - fir e Kompromiss tëscht dësen Extremer ze fannen - hu mir eisen eegene Projet erstallt: Shell-Operateur (kuckt och seng rezent Ukënnegung op den Hub).

Shell-Operateur

Wéi funktionéiert hien? De Stärekoup huet e Pod mat engem Go Binär mat engem Shell-Bedreiwer. Nieft et ass e Set vu Haken (méi Detailer iwwer si - kuckt hei ënnen). De Shell-Bedreiwer selwer abonnéiert op bestëmmte Evenementer an der Kubernetes API, op der Optriede vun deem et déi entspriechend Haken lancéiert.

Wéi weess de Shell-Bedreiwer wéi eng Haken op wéi eng Eventer ze ruffen? Dës Informatioun gëtt un de Shell-Bedreiwer vun den Haken selwer iwwerdroen, a si maachen et ganz einfach.

En Hook ass e Bash Skript oder all aner ausführbar Datei déi en eenzegt Argument akzeptéiert --config a reagéiert mat JSON. Déi lescht bestëmmt wéi eng Objete fir si interesséiert sinn a wéi eng Eventer (fir dës Objeten) solle reagéiert ginn:

Ech illustréieren d'Ëmsetzung op de Shell-Bedreiwer vun engem vun eise Beispiller - Zersetzungsgeheimnisser fir Zougang zu engem privaten Registry mat Applikatiounsbilder. Et besteet aus zwou Etappen.

Praxis: 1. Schreift en Haken

Éischt vun all, am Haken wäerte mir veraarbecht --config, wat beweist datt mir un Nummraim interesséiert sinn, a speziell de Moment vun hirer Schafung:

[[ $1 == "--config" ]] ; then
  cat << EOF
{
  "onKubernetesEvent": [
    {
      "kind": "namespace",
      "event": ["add"]
    }
  ]
}
EOF
…

Wéi géif d'Logik ausgesinn? Och ganz einfach:

…
else
  createdNamespace=$(jq -r '.[0].resourceName' $BINDING_CONTEXT_PATH)
  kubectl create -n ${createdNamespace} -f - << EOF
Kind: Secret
...
EOF
fi

Den éischte Schrëtt ass fir erauszefannen wéi ee Nummraum erstallt gouf, an deen zweeten ass et ze kreéieren mat kubectl Geheimnis fir dësen Nummraum.

Praxis: 2. Assemblée d'Bild

Alles wat bleift ass den erstallten Haken un de Shell-Bedreiwer ze passéieren - wéi maacht Dir dat? De Shell-Operateur selwer kënnt als Docker-Bild, also ass eis Aufgab den Hook an e spezielle Verzeechnes an dësem Bild ze addéieren:

FROM flant/shell-operator:v1.0.0-beta.1
ADD my-handler.sh /hooks

Alles wat bleift ass et ze montéieren an ze drécken:

$ docker build -t registry.example.com/my-operator:v1 .
$ docker push registry.example.com/my-operator:v1

Déi lescht Touch ass d'Bild an de Cluster z'installéieren. Fir dëst ze maachen, loosst eis schreiwen Détachement:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-operator
spec:
  template:
    spec:
      containers:
      - name: my-operator
        image: registry.example.com/my-operator:v1 # 1
      serviceAccountName: my-operator              # 2

Et ginn zwee Punkte fir opzepassen:

Indikatioun vum nei erstallt Bild;
Dëst ass e Systemkomponent deen (op e Minimum) Rechter brauch fir op Eventer a Kubernetes ze abonnéieren an Geheimnisser un Nummraim ze verdeelen, also kreéiere mir e ServiceAccount (an eng Rei vu Regelen) fir den Hook.

Resultat - mir hunn eise Problem geléist Famill fir Kubernetes op eng Manéier déi e Bedreiwer erstellt fir Geheimnisser ze decomposéieren.

Aner Shell-Bedreiwer Funktiounen

Fir d'Objete vun Ärem gewielten Typ ze limitéieren, mat deem den Haken funktionnéiert, si kënne gefiltert ginn, wielt no bestëmmte Etiketten (oder benotzt matchExpressions):

"onKubernetesEvent": [
  {
    "selector": {
      "matchLabels": {
        "foo": "bar",
       },
       "matchExpressions": [
         {
           "key": "allow",
           "operation": "In",
           "values": ["wan", "warehouse"],
         },
       ],
     }
     …
  }
]

Versuergt deduplication Mechanismus, wat Iech - mat engem jq-Filter - erlaabt Iech grouss JSON-Objeten a kleng ze konvertéieren, wou nëmmen déi Parameteren bleiwen, déi mir no Ännerungen iwwerwaache wëllen.

Wann en Hook genannt gëtt, passéiert de Shell-Bedreiwer et Objet Daten, déi fir all Besoin benotzt ka ginn.

D'Evenementer déi Haken ausléisen sinn net limitéiert op Kubernetes Eventer: de Shell-Bedreiwer bitt Ënnerstëtzung fir ruffen Haken duerch Zäit (ähnlech wéi Crontab an engem traditionelle Scheduler), souwéi e speziellen Event op Startup. All dës Eventer kënne kombinéiert ginn an dem selwechten Hook zougewisen ginn.

An zwee méi Features vum Shell-Bedreiwer:

Et funktionnéiert asynchron. Zënter datt e Kubernetes Event (wéi en Objet deen erstallt gëtt) opgeholl gouf, kënnen aner Eventer (wéi dee selwechten Objet deen geläscht gëtt) am Stärekoup geschéien, an Haken musse sech dofir berücksichtegen. Wann den Hook mat engem Feeler ausgefouert gouf, da gëtt et par défaut erëm ruffen bis erfollegräich Réalisatioun (dëst Verhalen kann geännert ginn).
Et exportéiert Metriken fir Prometheus, mat deem Dir kënnt verstoen ob de Shell-Bedreiwer funktionnéiert, fannt Dir d'Zuel vu Feeler fir all Haken an déi aktuell Schlaanggréisst.

Fir dësen Deel vum Bericht ze resuméieren:

Add-ons Installatioun

Fir bequem Aarbecht mat Kubernetes, gouf och de Besoin fir Add-ons z'installéieren. Ech wäert Iech doriwwer soen andeems Dir d'Beispill vum Wee vun eiser Firma benotzt wéi mir et elo maachen.

Mir hunn ugefaang mat Kubernetes mat verschiddene Stärekéip ze schaffen, déi eenzeg Ergänzung zu deem war Ingress. Et muss anescht an all Stärekoup installéiert ginn, a mir hunn e puer YAML Konfiguratiounen fir verschidden Ëmfeld gemaach: Bare Metal, AWS ...

Wéi et méi Cluster waren, goufen et méi Konfiguratiounen. Zousätzlech hu mir dës Konfiguratiounen selwer verbessert, als Resultat vun deem se zimlech heterogen ginn:

Fir alles an Uerdnung ze setzen, hu mir ugefaang mat engem Skript (install-ingress.sh), déi als Argument d'Zort vu Stärekoup geholl huet, op deen mir ofsetzen, déi néideg YAML Konfiguratioun generéiert an op Kubernetes ausgerullt.

Kuerz gesot, eise weidere Wee an d'Begrënnung, déi domat verbonnen ass, waren wéi follegt:

fir mat YAML Konfiguratiounen ze schaffen, ass e Schablounmotor erfuerderlech (an den éischte Stufen ass dëst einfach sed);
mat der Erhéijung vun der Unzuel vun de Stärekéip ass de Besoin fir automatesch Aktualiséierung komm (déi fréierst Léisung war de Skript an Git ze setzen, se mat Cron ze aktualiséieren an ze lafen);
en ähnlecht Skript war erfuerderlech fir Prometheus (install-prometheus.sh), awer et ass bemierkenswäert fir d'Tatsaach datt et vill méi Inputdaten erfuerdert, souwéi hir Späichere (op eng gutt Manéier - zentraliséiert an an engem Cluster), an e puer Daten (Passwierder) kënnen automatesch generéiert ginn:
de Risiko fir eppes falsch op eng wuessend Zuel vu Cluster auszerollen ass stänneg wuessend, sou datt mir gemierkt hunn datt Installateuren (dh zwee Skripte: fir Ingress a Prometheus) Inszenéierung war néideg (verschidde Filialen am Git, verschidde Crons fir se am entspriechende aktualiséieren: stabil oder Testcluster);
с kubectl apply et ass schwéier ginn mat ze schaffen well et net deklarativ ass a kann nëmmen Objete schafen, awer net Entscheedungen iwwer hire Status huelen / se läschen;
Mir fehlen e puer Funktiounen déi mir deemools guer net ëmgesat haten:
- voll Kontroll iwwer d'Resultat vu Clusterupdates,
- automatesch Determinatioun vun e puer Parameteren (Input fir Installatioun Scripten) baséiert op Donnéeën, déi aus dem Cluster kritt ginn (Entdeckung),
- seng logesch Entwécklung a Form vun kontinuéierlech Entdeckung.

Mir hunn all dës gesammelt Erfahrung am Kader vun eisem anere Projet ëmgesat - addon-Operateur.

Addon-Operateur

Et baséiert op de scho genannte Shell-Bedreiwer. De ganze System gesäit esou aus:

Déi folgend gëtt un d'Schuelbetreiberhaken bäigefüügt:

Wäerter Stockage,
Helm Chart,
Komponente datt iwwerwaacht de Wäertergeschäft an - am Fall vun Ännerungen - freet Helm d'Diagramm nei ze rullen.

Also kënne mir op en Event zu Kubernetes reagéieren, en Hook starten, a vun dësem Hook kënne mir Ännerunge fir d'Späichere maachen, duerno gëtt d'Diagramm nei erofgelueden. Am entsteet Diagramm trennen mir de Satz vun Haken an d'Diagramm an eng Komponent, déi mir nennen modul:

Et kënne vill Moduler sinn, an hinnen addéiere mir global Haken, e globale Wäertgeschäft, an e Komponent deen dëse globale Buttek iwwerwaacht.

Elo, wann eppes a Kubernetes geschitt, kënne mir dorop reagéieren mat engem globalen Hook an eppes am globalen Store änneren. Dës Ännerung gëtt bemierkt a wäert all Moduler am Cluster ausrollen:

Dëse Schema entsprécht all Ufuerderunge fir Add-ons z'installéieren, déi uewen uginn:

Helm ass verantwortlech fir Template an Deklarativitéit.
D'Fro vum Auto-Aktualiséierung gouf mat engem globalen Hook geléist, deen op engem Zäitplang an de Registry geet a wann et en neit Systembild do gesäit, rullt et aus (dh "selwer").
Astellunge späicheren am Cluster gëtt implementéiert mat ConfigMap, déi d'Primärdaten fir d'Späicheren enthält (beim Start gi se an d'Späichere gelueden).
Problemer mat der Passwuert Generatioun, Entdeckung a kontinuéierlech Entdeckung goufen mat Haken geléist.
Staging gëtt erreecht duerch Tags, déi Docker aus der Këscht ënnerstëtzt.
D'Resultat gëtt iwwerwaacht mat Metriken, duerch déi mir de Status kënne verstoen.

Dëse ganze System gëtt a Form vun engem eenzege Binär am Go implementéiert, deen Addon-Operator genannt gëtt. Dëst mécht den Diagramm méi einfach:

Den Haaptkomponent an dësem Diagramm ass eng Rei vu Moduler (ënnert grau markéiert). Elo kënne mir e Modul fir den erfuerderlechen Add-on mat e bëssen Effort schreiwen a sécher sinn datt et an all Cluster installéiert gëtt, aktualiséiert gëtt an op d'Evenementer reagéiert déi se am Cluster brauch.

"Flant" benotzt addon-Operateur op 70+ Kubernetes Stärekéip. Aktuelle Status - alpha Versioun. Elo preparéiere mir Dokumentatioun fir d'Beta ze verëffentlechen, awer fir de Moment am Repository Beispiller verfügbar, op Basis vun deem Dir Ären eegene Addon erstellen kënnt.

Wou kann ech d'Module fir Addon-Bedreiwer kréien? D'Verëffentlechung vun eiser Bibliothéik ass déi nächst Etapp fir eis; mir plangen dëst am Summer ze maachen.

Videoen a Rutschen

Video vun der Leeschtung (~ 50 Minutten):

Presentatioun vum Rapport:

PS

Aner Berichter op eisem Blog:

«Datenbanken a Kubernetes"; (Dmitry Stolyarov; 8. November 2018 op HighLoad++);
«Iwwerwachung an Kubernetes"; (Dmitry Stolyarov; Mee 28, 2018 bei RootConf);
«CI / CD Best Practices mat Kubernetes a GitLab"; (Dmitry Stolyarov; 7. November 2017 op HighLoad++);
«Eis Erfahrung mat Kubernetes a klenge Projeten"; (Dmitry Stolyarov; Juni 6, 2017 bei RootConf).

Dir kënnt och un de folgende Publikatiounen interesséiert sinn:

«Shell-Bedreiwer aféieren: Bedreiwer fir Kubernetes erstellen ass just méi einfach ginn".

Source: will.com

Kubernetes ausbauen an ergänzen (Iwwerpréiwung a Videobericht)