A Kubernetes legjobb gyakorlatai

Beszélgettem egy korábbi Googler SRE-vel, aki (helyesen) rámutatott, hogy a Kubernetes nagyon gyorsan fejlődik (túl gyorsan fenntartja a valutát), (sok) új fogalmat használ, és hogy (túl) sok módszer létezik ugyanazon probléma megoldására.

Ennek nagy része igaz, és nem feltétlenül rossz, és nem feltétlenül különbözik minden más technológiától. Ahol nem értek egyet azzal, hogy ezek a tényezők visszatartották Kubernetes elfogadását. Arra bátorítanám, hogy merüljön be. A Kubernetes az a siker, amely * ezen (ésszerű) aggodalmak ellenére *, mert nagyon-nagyon jó.

Ebben a bejegyzésben néhány olyan kezdetleges legjobb gyakorlatot fogok bemutatni, amelyek remélem segítenek majd abban, hogy megragadja ezt a technológiát a konténereibe, és belemerüljön.

Nincs külön sorrend:

  1. Hagyja, hogy valaki másnak munkát végezzen!

Használjon olyan Kubernetes szolgáltatást, mint a Kubernetes Engine. Hacsak nem szellemi kíváncsi vagy, a Kubernetes-en dolgozó fejlesztő, vagy Ön olyan platformszolgáltató, amelynek ügyfelei Kubernetes szolgáltatásokat kérnek, mentse el a szóváltást és használja a Kubernetes szolgáltatást. Ön építette meg saját otthonát és autóját? Vagy szereti aludni egy olyan helyen, ahol a Farkas nem tud lerobbantani és vezetni egy olyan autót, amely megbízhatóan eljut téged a másikba.

Tehát, ha elolvasta a többi hozzászólásomat, azt is javaslom, hogy értékelje a regionális klasztereket, és így valamire nézze át a következőket:

A gcloud béta-tárolófürtök $ {CLUSTER} -t hoznak létre ...
gcloud béta-tárolófürtök get-credentials $ {CLUSTER} ...

És akkor készen állsz a következőkre:

kubectl apply - fájlnév = marvels.yaml

2. Próbáld ki gondolni a „Kubernetes” -re.

Ez * valószínűleg * nagyobb kihívást jelent a Kubernetes Engine számára, mint más platformon, de a Google Cloud Platformon kénytelen vagyok megérteni a Kubernetes erőforrásainak állapotát (pl. Csomópontok, Ingresses) és ugyanakkor , a mögöttes erőforrások a Compute Engine-ben (pl. virtuális gépek, HTTP / S terheléselosztók). Ez a részecskehullám kettős problémája sajnálatos. Köszönet Dale H.-nak, aki először megfogalmazta ezt nekem.

Ahol lehetséges, próbáljon ragaszkodni a Kubernetes erőforrásainak gondolkodásához, és ne vegye figyelembe a mögöttes GCE erőforrásokat. Most, hogy több mint egy évet arra törekszem, hogy a munkámat a Kubernetes felé torzítsam, könnyebbé válik a pusztán a Services (és az Ingresses) által kitett „néhány számú” hüvelykujj gondolkodása.

3. Névterek, névterek, névterek

Frissítés: Köszönet Michael Hausenblas-nak, aki a Kubernetes YAML fájljaiból a névterek * * hivatkozásának bevált gyakorlatáért oktatott. Bár mindig névtereket kell használnia, ezek megadása a fájl alkalmazásakor nagyobb rugalmasságot és lehetőséget kínál ugyanazon YAML fájlok használatára, pl. különböző tájak. Lásd Michael cikkét itt.

Mike Altarace és én hónapok óta blogot írtunk a Kubernetes névnevekről és arról, hogy hol kell ezeket használni. Azóta nagyon figyelmen kívül hagytam a saját tanácsomat, és azt gondoltam, hogy a használati esetek annyira kisebb jelentőségűek, hogy a Namespace használatát elveszítik. Tévedtem. Mindig használjon névneveket.

Mivel a konténerek folyamatba kerülnek, a névterek a Kubernetes projektekhez kerülnek. A Namespaces által megadott biztonsági határoktól eltekintve kiváló módszer a munka megosztásához, és kiváló módja annak visszaállítására vagy törlésére:

kubectl névtér törlése / $ WORKING_PROJECT

Az egyetlen hátránya, hogy a nem alapértelmezett névtér használatakor meg kell adnia a működő névteret --namespace = $ WORKING_PROJECT a kubectl parancsokon, amelyek véleményem szerint jó védintézkedések lehetnek. Azonban mindig - all-namespace vagy más névteret is beállíthat alapértelmezettként (link).

4. Túl sok a probléma megoldásának módja

Ez visszatartó gond. Azt hiszem, valószínűleg nem igaz, de jó útmutatások és a legjobb gyakorlatok hiányában talán úgy tűnik, hogy túl sok hasonló módszer létezik ugyanazon probléma megoldására. Használtam egy általános mintát, amelyet itt összefoglalok a vita ösztönzésére:

  • A YAML fájlok tudás a hűtőtárolóban (lásd: 5. szám)
  • A konténereknek jól kell csinálniuk egy dolgot (lásd: „distroless”)
  • Mindig telepítsen telepítéseket (lásd # 6)
  • Ha L7, más néven HTTP / S terheléselosztót szeretne, használja az Ingress alkalmazást (lásd # 7 - ha!)
  • A hitelesítő adatok biztonságos kezelése a titkok használatával (link)

5. A kubectl torzítása érvényes - fájlnév az alternatívák felett

Könnyű elérni a gyors találatot a kubectl névtér létrehozásával / $ {WORKING_DIR}, de több ilyen parancs után eldönti, hogy miként érte el az aktuális állapotot, és - ami még fontosabb - hogyan állíthatja vissza ezt az állapotot. Arra bátorítom, hogy hozzon létre YAML fájlokat az erőforrások leírására, és ne az egyenértékű kub ectl create parancs helyett.

Arra biztatom, hogy ismerkedjen meg a * kiváló * Kubernetes API dokumentációval (link, link és 1.10), amelyek kimerítőek, pontosak és könnyen navigálhatók (talán a tökéletes dokumentáció !?). De még ennek a nagy teljesítményű eszköznek a használatakor néha nehéz feladat egy kubectl parancs elkészítése, amely az Ön számára működik, és YAML-ként konvertálja. Ez nem:

kubectl bevezetés / $ {MY_DEPLOYMENT} --output = yaml
kubectl szerviz szolgáltatás / $ {MY_SERVICE} --output = yaml
kubectl bármit megszerezhet / $ {MY_ANYTHING} --output = yaml

Illessze az eredményeket egy fájlba, ha szeretné, de használja ezeket az egyenértékű (!) YAML fájl alapjául. Minden példányhivatkozást el kell dobnia.

Miután elkészítette a masterpiece.yaml fájlt, azt javaslom, hogy mindig jelentkezzen be az első létrehozáshoz, jelentkezzen be a későbbi frissítések elvégzésére, és ha törölnie kell. Ez az!

kubectl apply --filename = masterpiece.yaml
kubectl delete --filename = masterpiece.yaml

Kisebb betekintés: a telepítéshez nem kell helyi YAML fájlokat húznia. Megadhatja a kubectl apply --filename URL-címeket is, és mindaddig, amíg a függő fájlok helyi referenciák, a telepítés működni fog.

Kisebb betekintés: ezt a felhasznált helyet csak a Kubernetes-land-ban találom, de ez jogszerű gyakorlat, ha több YAML-fájlt egyesíthet egy YAML-fájlba a --- és ... fájl-elválasztókkal. Tehát a YAML névtér, a telepítési YAML és a szolgáltatás YAML helyett egy mega-YAML lehet, amely mindhárom fájlt egybe foglalja.

Ez érvényes YAML (másolja és illessze be például a YAML Lintbe). * Érvénytelen * Kubernetes spec | YAML, mert minden specifikáció hiányos, de ha mindegyik kitöltésre került, ez tökéletesen jó YAML, és jó módszer az erőforrások társítására.

Lásd a #B (Xsonnet) elemet egy kritikához.

6. Használjon telepítéseket

Van egy csomó hatalom a telepítésekben, elegendő az iránymutatásom, hogy mondjam: mindig és minden alkalommal használja a telepítéseket. Még akkor is, amikor az első egyedülálló podnginx-et telepíti. Az üzembe helyezés az „Első osztályú” utazás az edző áráért, gördülő telepítésekbe eshet, hibát követhet el, újra jelentkezhet, és a Kubernetes gondoskodik a szemtelen hüvelyek megöléséről és helyes viselkedésűek helyettesítéséről.

7. LoadBalancer és Ingress

Ezek zavart okoznak. Véleményem szerint (és tévedhetek), amikor a --type = LoadBalancer használatával hoztam létre Szolgáltatásokat, szeretnék | Hálózati LB-t szerezni. Ha HTTP / S (7. szintű) terheléselosztást akarok, létre kell hoznom egy beavatkozást. Az Ingress zavaró Kubernetes erőforrás. Elegendő mondani, L7 == behatolás (és ennek eredményeként rengeteg konfigurációs teljesítmény).

A Kubernetes Engine az Ingress erőforrásokat GCE HTTP / S terheléselosztókként jeleníti meg. Christopher Grant rendkívül jó munkát végez az Ingress elemzésében állásfoglalásaiban (itt és itt).

8. NodePorts

Én még (soha?) Nem hoztam létre közvetlenül a ClusterIP-t. Olyan dolgokat csináltam a Kubernetes-kel, amelyek eredményeként a szolgáltatásokat a ClusterIPs fedezte fel. Leginkább (!) NodePorts-ot készítettem, vagy olyan dolgokat csinálok (például létrehozok Ingress-erőforrásokat), amelyek NodePorts-ot használnak.

A NodePorts társítva van a Kubernetes Nodes-kel és ezek Portok. Az általuk nyújtott nagy teljesítményű szolgáltatás az, hogy a fürt * minden * csomópontja (vagy ez NodePool? [[TODO]]) ugyanazt a szolgáltatást jeleníti meg ugyanazon (csomópont) porton.

Ha létrehozok egy szolgáltatást, amely a NodePort X-en van feltüntetve, biztos lehet benne, hogy ha a fürt * bármelyik * csomópontján elérem ezt a portot, akkor hozzá fogok férni a szolgáltatáshoz. Ez képezi a Kubernetes terheléselosztási képességeinek alapját, mivel a fürt bármilyen csomóponton képes a kiszolgálóra érkező beérkező kéréseket erre a portra irányítani.

A Google Cloud SDK (más néven gcloud) tartalmaz egy ssh-ügyfelet, amely megkönnyíti a Compute Engine virtuális gépekhez való kapcsolódást (amelyek, amint emlékezni fogsz, a Kubernetes fürtcsomópontjai). Az ssh kliens tartalmaz egy port-továbbító képességet. Tehát, ha csatlakozni akarunk egy Kubernetes szolgáltatáshoz, és ki tudjuk keresni a szolgáltatás NodePort-ját, akkor triviaálisan (!) Továbbíthatjuk a szolgáltatás portját-továbbítással (gcloud vagy bármilyen ssh kliens használatával) a port bármelyik portjára történő továbbításával ( Csomópont.

A következő példa a kubectl segítségével megragadja a klaszter 0. csomópontját. A Kubernetes motorcsomópont neve megegyezik a Compute Engine virtuális gép nevével. Adott $ {MY_SERVICE} nevű szolgáltatást a $ {MY_NAMESPACE} nevű névtérben meghatározzuk a szolgáltatás NodePort értékét. Ezután átváltunk a gcloud-ra, és a beépített ssh-jét használjuk a továbbításhoz (--ssh-flag = "- L XXXX: localhost: XXXX).

NODE_HOST = $ (\
  kubectl csomópontok \
  --output = jsonpath = "{. tételek [0] .metadata.name}")
NODE_PORT = $ (\
  kubectl szolgáltatás igénybevétele / $ {MY_SERVICE} \
  --namespace = $ {MY_NAMESPACE} \
  --output = jsonpath = "{. spec.ports [0] .nodePort}")
echo $ {NODE_PORT}
gcloud compute ssh $ {NODE_HOST} \
--ssh-flag = "- L $ {NODE_PORT}: localhost: $ {NODE_PORT}" \
--project = $ {YOUR_PROJECT}

Mi ilyen erős ebben? Most már úgy érheti el a szolgáltatást, mintha helyi lenne, anélkül, hogy lyukakat kellene lyukasztania a tűzfalon.

A NodePort nagy számú port (~ 30 000–32 767).

9. A kubectl feltörése a JSON használatával

A Google Cloud SDK (más néven gcloud) valóban kiváló, de a kubectl (Kubernetes CLI) sokkal jobb (sic). Az egyik hatékony szolgáltatás a kimeneti formázás és szűrés. Ez lehetővé teszi a nem kódoló (nem API-kóros) módszereket a szkriptek és más eszközök kibővítésére a Kubernetes-fürtök információival.

Az összes Kubernetes erőforrásállapot elérhető például kubectl get (tapasztalatom szerint hasznosabb erre a célra, mint a kubectl leírása) parancsokat. Ezután csak az marad, hogy megtalálja a tűt a JSON szénakazalában.

A trükk az, hogy:

kubectl get [erőforrás] / [erőforrás-név] - output = JSON

Aztán szemmel láthatja az eredményeket, hogy elkezdje lekérdezési karakterlánc felépítését:

kubectl get [erőforrás] / [erőforrás-név] --output = jsonpath = ". tételek [*]"

és iteratívan finomítsa a megállapított eredményt, amíg meg nem kapja a keresett elemet. Íme egy példa, amelynek működnie kell minden fürtnél:

kubectl get node - output = json
kubectl csomópontok --output = jsonpath = "{. tételek [*]}
kubectl csomópontok --output = jsonpath = "{. tételek [0]}
kubectl csomópontok --output = jsonpath = "{. tételek [0] .metadata.name}

Végül létezik egy megfelelő argumentum (és egy tétel a * nix-ben) egy JSON-elemző eszköz megtanulásához, és az eszköz alkalmazásához az összes JSON-elemzési igényre. Ebben az esetben van-e ésszerű versenytárs a jq-nek? Gyanítom, hogy nem.

Plusz jq kiváló játszótérrel rendelkezik (jqplay.org).

A. Használjon címkéket

Régóta jött, de a szoftverszolgáltatások mindenféle formája támogatja az erőforrások önkényes címkézésének koncepcióját (általában kulcsérték-párokat). Ennek oka az, hogy ez a metaadat nyílt végű, teljes mértékben felhasználó által definiált módszert kínál az erőforrások lekérdezésére. Kubernetes ezt az alapelvet magában foglalja; ez egy belső képesség, és nem egy utógondolat |

A Kubernetes szolgálat tetszőleges számú Kubernetes hüvelyt tesz ki. A Szolgáltatások * nem * teszik ki a „Henry” elnevezésű hüvelyeket vagy a ReplicaSet-et tartalmazó hüvelyeket. Ehelyett a Szolgáltatás kiteszi azokat a hüvelyeket, amelyek címkéi megfelelnek a Szolgáltatás specifikációjában meghatározott kritériumoknak, és ezeket a címkéket természetesen a felhasználó határozza meg.

Megjegyzés: A fenti példában a projekt-x nevű névteret használjuk, és ez a névtér-specifikáció megjelenik a Névtérben (amikor létrehozták), a Telepítésben meghatározza, hogy a telepítés létezik, és a Szolgáltatásban. A központi telepítés (amelyet microservice-y-nek nevezünk) létrehoz egy ReplicaSet-et (amelyet implicit módon megadunk itt; ez az, amit az üzembe helyezés hoz létre), amely 100 Pods-ot fog fenntartani. Minden egyes Pod címkével rendelkezik: publicname-a, és egy grpc-proxy nevű tárolót tartalmaznak egy image-grpc-proxy nevû kép alapján. A szolgáltatás neve service-p. Lényeges, hogy a szolgáltatás olyan (!) Hüvelyeket választ ki (csak a projekt-x névtérben), amelyek címkével rendelkeznek: nyilvános név. A Szolgáltatás kiválaszt minden olyan Pod-ot (a projekt-x névtérben), amely rendelkezik ezzel a címkével (kulcs: érték) *, * nem * csak az ebben a telepítésben létrehozott hüvelyeket. A szolgáltatás nem hivatkozik a hüvelyekre a nevük alapján (amely a telepítés nevére épül), a tárolónév és a tárolókép neve alapján, csak a hüvelyhez társított címkék.

Megjegyzés: Ez * nem * jó gyakorlat, de bizonyítja a dolgot. Ha a fentiekhez hasonló konfigurációt kellene futtatnia, majd külön létrehoznia pl. egy Pod, amelyen fut az Nginx (a projekt-x névtérben), majd hozzáadta az app: publicname-a címkealkalmazást, amely gyorsan beépül a Pod-sorozatba, amelyet a service-p szolgáltatás összesít. Ha eltávolítaná a címkét a Szolgáltatás által összesített Pod-okból, akkor a Pod nem kerül bele.

Ezt a szolgáltatást példázzák a gördülő frissítésekkel, ahol a telepítés új replicaSet-et hoz létre, amely új pods-ot tartalmaz az X verzióhoz ', különbözik a ReplicaSet-től és az X-verzió Pods-tól. A szolgáltatás meghatározható úgy, hogy feltárja mindkét verzión futó podok metszéspontját, mert nem a ReplicaSets vagy az egyedi hüvelyek határozza meg, hanem a felhasználó által meghatározott címkék („választók”) alapján, amelyeket Ön alkalmaz a Pod-ok létrehozásakor.

Ez nagyon erős!

B. Használjon Jsonnet-et, esetleg Ksonnet-et

Két kihívás az összes (!?) Strukturált formátummal (YAML, JSON, XML, CSV ;-)) az önreferencia és a változó. A Kubernetes központi telepítésének marvellous.yaml specifikációinak kidolgozásakor könnyen felmerülhet ez a probléma. Megtalálja magát literálokkal (pl. Képnevek és kivonatolások), és még a tisztelt telepítéseknél is megismétli a neveket és a választókat.

Nincs megoldás ezekre a kérdésekre, ha a YAML-re és a JSON-ra korlátozódik. A Google részben létrehozta a Jsonnet-et e problémák megoldására. Az okos Heptio emberek kiterjesztették a Jsonnet-et Kubernetes-re a… Ksonnet-kel.

Mindkettő olyan sablonnyelv, amely a fent (és még többen) felvázolt problémákkal foglalkozik. Arra biztatom, hogy fontolja meg Jsonnet-et. Csakúgy, mint a jq használatának fontolgatására vonatkozó javaslatom, tanulja meg egyszer a Jsonnet alkalmazást, és alkalmazza azt mindenhol, ahol a JSON-t használja. A Ksonnet kifejezetten a Kubernetes-re vonatkozik, és - korlátozott (!) Tapasztalataim szerint - úgy találtam, hogy ennek a sajátosságnak az előnyei nem kerülnek súlyosbá a tanulási görbén.

C. YAML vagy JSON

A Kubernetes a YAML-et és a JSON-t egyformán kezeli. Személy szerint úgy gondolom, hogy a YAML inkább az olyan konfigurációs fájlok esetében ajánlott, amelyeket kubectl - alkalmazni, mert a YAML tömörebb, mint a JSON. Bár a YAML-et nehezebben írom.

Ugyanakkor a struktúra megértése és az elemzés szempontjából inkább a --output = JSON, és azért is, mert - output = JSONPATH. Hatalmas Golang rajongó vagyok, de a Go sablonok nem olyan intuitívak, és nem használom őket.

kisebb betekintés: A YAML a JSON (link) szuperhalmaza ... várjon! mit?

D. Downward Dog API és config

A „Downward API” annak helyes, bár nem kevésbé megzavaró nevének adása érdekében Kubernetesben egy olyan eszköz, amellyel a Pods megismerheti a körülöttük lévő klasztert. Feltételezem, hogy a normál áramlás a külvilág felől a Podba és annak tartályaiba *, de * vannak olyan esetek, amikor egy tartálynak (!) Hasznos információt szerezni a környezetéről, pl. csomópontneve | IP, a Pod neve (szóköz) | IP.

A lefelé mutató API értékeket környezeti változókon keresztül mutatják be a tárolóhoz. A környezeti változókat (mint másutt) használják a konténerek konfigurációjának vagy más állapotának biztosítására. A környezeti változók felhasználásának és a Downward API megvalósításának (kis figyelmeztetés mellett) egyik nagyon szép következménye az, hogy a konténer elválasztva marad a Kubernetes-től.

Íme egy példa a haveromatól - Sal Rashid-től, amely a Downward API-t használja a Node és Pod állapot összegyűjtésére és ezek bemutatására a felhasználó számára:

https://github.com/salrashid123/istio_helloworld/blob/master/all-istio.yaml

Megjegyzés: Lásd a 76., 80., 84., 88. sorral kezdődő szakaszokat, ahol a Pod név, névtér, IP és a csomópont nevét a Downward API futás közben biztosítja a myapp-container nevű tárolóhoz.

A Downward API az egyetlen, praktikus módszer az adatok tárolóhoz történő gyűjtésére. Tehát inkább az „egyetlen gyakorlat”, mint a „legjobb gyakorlat”.

Számos hozzászólásomban, amikor a Kubernetes számára megoldásokat építek, tesztelom a folyamatot egy tárolóhelyen és kívül, majd egy tárolóban (meghatározva a környezeti változókat), majd egy Kubernetes-fürtön. A konténeres mechanizmusok konzisztensek (lásd alább), még ha az egyik általában a Docker-en, a másik a Kubernetes-en fut.

Egy nemrégiben a Google Konténerre optimalizált operációs rendszerén írt bejegyzésemben bemutatom egy konténert, amely helyileg fut a Docker alatt, távolról a Konténerre optimalizált operációs rendszer alatt, majd a Kubernetesen.

Itt fut a Docker alatt helyileg. Figyelje meg, hogy a környezeti változók (--env) hogyan használják a gcr.io/${PROJECT}/datastore konfigurációjának biztosítását.

dokkoló futtatás \
--interaktív \
- elég \
--publikálás = 127.0.0.1: 8080: 8080 \
--env = GCLOUD_DATASET_ID = $ {PROJECT} \
--env = GOOGLE_APPLICATION_CREDENTIALS = / tmp / $ {ROBOT} .key.json \
--volume = $ PWD / $ {ROBOT} .key.json: / tmp / $ {ROBOT} .key.json \
gcr.io/${PROJECT}/datastore

Ugyanez az eredmény eredményezte a telepítést a konténerre optimalizált virtuális gép létrehozására. Ezúttal ellenőrizze a container-env zászló számára megadott értékeket:

gcloud béta számítási példányok létrehozása-tárolóval $ {INSTANCE} \
--zóna = $ {ZONE} \
--kép-család = cos-stabil \
--image-project = cos-cloud \
--container-image=gcr.io/${PROJECT}/${IMAGE}@${DIGEST}
--container-restart-policy = mindig \
--container-env = \
GCLOUD_DATASET_ID = $ {project}, \
GOOGLE_APPLICATION_CREDENTIALS = / tmp / $ {ROBOT} .key.json \
--container-mount-host-path = \
csatolási-path = / tmp, \
host-path = / tmp, \
mód = rw \
--project = $ {project}

És végül, itt van a Kubernetes telepítésének YAML-kivonata:

konténerek:
      - név: adattár
        kép: gcr.io/${PROJECT}/datastore
        imagePullPolicy: Mindig
        volumeMounts:
          - név: adattár
            mountPath: / var / secrets / google
        env:
        - név: GOOGLE_APPLICATION_CREDENTIALS
          érték: /var/secrets/google/datastore.key.json
        - név: GCLOUD_DATASET_ID
          érték: $ {PROJECT}
        portok:
        - név: http
          containerPort: 8080

Így a környezeti változók használata a konfigurációban meglehetősen ügyetlen. Nincs egyértelmű szándékosan, hogy bizonyos környezeti változók bizonyos folyamatokhoz kötődnek-e, és csak akkor veszi észre, hogy nem megfelelően vannak konfigurálva, amikor a dolgok összeomlanak. Könnyű elképzelni a környezeti változókat, amelyek ütköznek egy nem konténeres környezetben, bár ez egy kisebb probléma a konténerekkel, mivel a fentiekhez hasonlóan kifejezetten meghatározunk egy adott tároló értékét.

Mindezek ellenére a környezeti változók ilyen módon történő használata a legjobb gyakorlat.

E. Sidecars és miért a Pods nem mindig azonosak a konténerekkel

5 cl konyak
2 cl háromszoros
2 cl citromlé
Előkészítés Öntsen minden összetevőt jéggel megtöltött koktélrázóba. Rázzuk jól és szűrjük le a koktélpoharakba.

Az idő nagy részében Kubernetes hüvelyeket hoz létre, amelyek egyetlen tárolót tartalmaznak, és azon tűnődni fog, vajon miért van egy olyan Pod fejléc, ha csak egy tartályra van szüksége. A hüvelyek sokkal analógbak a gazdakörnyezettel, amely sok tárolót képes futtatni. Sokszor fontolóra veszi több tároló futtatását egy Pod-ban.

... és csak egy alkalommal kell :-)

Valószínűleg egynél több, de maradjunk csak egyszer.

Az anti-minta (ne csináld ezt) a jelenlegi konfiguráció elképzelése (tegyük fel a web-szervert és az adatbázis hátterét), és mindkettőt beillesztjük a Podba. Ez * nem * jó ötlet *, kivéve, ha * minden web-szerver példányt elválaszthatatlanul és örökre össze kell kapcsolni egy adott adatbázis példánnyal. Ez nem valószínű.

Valószínűbb, hogy a web-szerver példányainak az összesített előtét-terhelés szerint kell méreteznie, és az adatbázis-példányoknak (ettől függetlenül és) függetlenül attól, hogy az előtakarékosságot kezelni tudják-e. Ha az aggregált képet látja, gondolod a Szolgáltatást, és amikor gondolsz Szolgáltatásra, próbáljon meg tetszőleges számú Pod-ot elképzelni (mivel ez számlájának számít, de a legtöbb egyéb cél szempontjából nem számít, hány Pod-ra van szükség, amíg a a szám pontosan megfelelő a munkaterhelés kiszámításához).

Mikor mérlegelnie kell több tartályt Pod-nként? A * mindig * értelme csak akkor válik lehetővé, ha kiegészíteni, kibővíteni vagy gazdagítani szeretné az elsődleges pod viselkedését egy tartályban. Vizsgáljuk meg felülről a webszervert és az adatbázis példát. Ebben a forgatókönyvben remélhetőleg most már meggyőződött arról, hogy két Szolgáltatást (és két Telepítést) telepít, egyet az előlapra és egy a háttérrendszerre.

Jó és általános gyakorlat, hogy maga a web-szerver példányt fordított proxyval helyezze el. Általában ez Nginx vagy HAProxy lenne, és egyre gyakoribb az Envoy használata (ha meghatalmazást keresünk, azt javaslom, hogy fontolja meg Envoy-t; lásd #F Istio). A fordított proxy biztosítja a konzisztenciát (csak pl. Envoy-t használunk) akkor is, ha különféle webszervereket használunk (pl. Apache, Tomcat w / Java stb.), Akkor is, ha van HTTP, gRPC, Web Sockets stb. Forgalom keveréke. , akkor is, ha forgalmat kíván irányítani a web-szerverre, és némi forgalmat a gyorsítótárba (pl. Lakk).

Az összes korábbi forgatókönyv esetén ésszerű lenne a „mellkocsi” modellt alkalmazni. Ebben a modellben az elsődleges tárolónak (a webszervernek) kiegészítő és kiegészítő tárolói vannak (Envoy proxy, Lakk gyorsítótár stb.). Ezeket szorosan össze kell kapcsolni egy adott web-szerver példánnyal * és * funkcionálisan, a kombináció az „egység”.

Nagyon gyakori, hogy a naplózást, a megfigyelést, a nyomkövetést és az egyéb infrastrukturális alkatrészeket oldalkocsikként is szállítják. Ennek motivációja az aggodalmak elkülönítése. Annak biztosítása érdekében, hogy a fejlesztőknek következetes követelményeik legyenek a „kezelhető” kód előállításával, és rugalmasságot biztosítsanak az SRE számára az előnyben részesített eszközök kiválasztásában, tudva, hogy a flotta összes kódja naplózni fog, metrikákat bocsát ki, nyomon követhető, következetesen alkalmazza az auth stb. Ez egy minta amely a szolgáltatási háló alapját képezi (lásd #F Istio). Ez a végső legjobb, bár kialakuló gyakorlat.

F. Használja az Istiot

Óvatosan használja az Istiót.

Az Istio (és más szolgáltatási hálózatok) viszonylag kialakulóban lévő technológiák olyan cégekből származnak (beleértve a Google-t is), amelyek hatalmas méretű konténereket üzemeltetnek. A szolgáltatási hálózatok triviálisan helyeznek el egy univerzális (Istio esetében Envoy) proxy-t minden egyes Pod-ban, minden központi telepítésben, minden névtérben és fürtben.

Az eredmény egy következetes menedzsment szubsztrát, amely lehetővé teszi a menedzsment laza összekapcsolását (ma Stackdriver Trace-t fogunk használni, de a Jaegerbe való áttérés terve, a Prometheus megfigyelési rendszert futtatjuk) és a kontroll szolgáltatások (tudjuk, hogy minden szolgáltatásunk biztonságos, a forgalom 10% -át az A, B és C szolgáltatások kanári épületeire irányítja.

Azt tanácsolom „óvatosan”, mert ezek a technológiák újak, durva élekkel és gyors ütemben fejlődnek. De a módszer előnyei (rugalmasság, rugalmasság, jövőbiztosság) valószínűleg messze meghaladják a költségeket. A legfontosabb, hogy használja a szolgáltatás-hálót mint modellt a Kubernetesnél, még akkor is, ha még nem akarja alkalmazni az egyik szolgáltatás-háló technológiát.

Ez van, srácok!