Kubernetes labākā prakse

Es tērzēju ar bijušo Googler SRE, kurš (pareizi) norādīja, ka Kubernetes attīstās ļoti ātri (pārāk ātri, lai uzturētu valūtu), izmanto (daudzus) jaunus jēdzienus un ka ir (pārāk) daudz iespēju vienas un tās pašas problēmas risināšanai.

Liela daļa no tā ir patiesība, un tā nebūt nav slikta lieta un nebūt atšķirīga no jebkuras citas tehnoloģijas. Es nepiekrītu, ka šie faktori ir atturējuši viņu pieņemt Kubernetes kungu. Es mudinātu jūs ienirt. Kubernetes ir panākums, neraugoties uz * šīm (pamatotajām) bažām, jo ​​tas ir ļoti ļoti labs.

Šajā rakstā es jums sniegšu dažus rudimentārus paraugpraksi, kas, es ceru, palīdzēs jums satvert šo tehnoloģiju pie tās traukiem un ienirt.

Nevienā īpašā secībā:

  1. Ļaujiet kādam citam rīkoties!

Izmantojiet Kubernetes pakalpojumu, piemēram, Kubernetes Engine. Ja vien jūs neesat intelektuāli ziņkārīgs, izstrādātājs, kas strādā pie Kubernetes, vai arī jūs esat platformas nodrošinātājs, kura klienti pieprasa Kubernetes pakalpojumus, saglabājiet problēmu un izmantojiet Kubernetes pakalpojumu. Vai jūs pats uzbūvējāt savas mājas un savu automašīnu? Vai arī jums patīk gulēt vietā, kur vilks nevar notriekt un vadīt automašīnu, kas jūs droši ved no viena uz otru?

Tātad, ja esat lasījis kādu no maniem citiem ierakstiem, es arī iesaku novērtēt reģionālos klasterus, tāpēc jūs skatāties kaut ko līdzīgu:

gcloud beta konteineru kopas rada $ {CLUSTER} ...
gcloud beta konteineru kopu iegūšanas akreditācijas dati $ {CLUSTER} ...

Un tad jūs esat gatavs doties kopā ar:

kubectl apply --filename = marvels.yaml

2. Mēģiniet domāt “Kubernetes”

Tas * var * būt lielāks izaicinājums Kubernetes Engine nekā citās platformās, taču Google Cloud Platform jums ir spiests saglabāt izpratni par savu resursu stāvokli Kubernetes (piemēram, Mezgli, Ingresses) un tajā pašā laikā , Compute Engine pamatā esošie resursi (piemēram, VM, HTTP / S slodzes līdzsvarotāji). Šī daļiņu viļņu divdabības problēma ir žēl. Paldies Dale H. par to, ka viņš to pirmo reizi noformulēja man.

Ja iespējams, mēģiniet pieturēties pie domām par Kubernetes resursiem un neņemiet vērā pamatā esošos GCE resursus. Tagad, kad esmu pavadījis vairāk nekā gadu, novirzot savu darbu uz Kubernetes, ir vieglāk domāt tikai par “dažu” kāju skaitu, kuras atklāj Pakalpojumi (un Ingresses).

3. Vārdu atstarpes, nosaukumvietas, nosaukumvietas

Atjauninājums: Paldies Maiklam Hausenblamam par manis izglītošanu par paraugpraksi * ne * atsaukties uz vārdu zonām no Kubernetes YAML failiem. Lai gan vienmēr vajadzētu izmantot nosaukumvietas, šo precizēšana, lietojot failu, nodrošina lielāku elastību un iespēju izmantot tos pašus YAML failus pret, piemēram, dažādas ainavas. Maikla rakstu skatiet šeit.

Maiks Altarace un es pirms daudziem mēnešiem blogojām emuārus par vietņu nosaukumiem Kubernetes un to, kur jums tie būtu jāizmanto. Kopš tā laika es diezgan daudz ignorēju savus padomus, uzskatot, ka manas lietošanas gadījumi ir bijuši tik niecīgi, ka Namespaces lietošana būtu pārspīlēta. ES kļūdījos. Vienmēr izmantojiet vārdu zonu.

Tā kā konteineri ir paredzēti procesiem, nosaukumvietas ir Kubernetes projektiem. Neatkarīgi no drošības robežas, ko Namespaces norāda, tie ir lielisks veids, kā sadalīt jūsu darbu, un tie nodrošina lielisku iespēju to atiestatīt vai izdzēst:

kubectl izdzēst namespace / $ WORKING_PROJECT

Vienīgais mīnuss ir tas, ka, lietojot vārda zonu, kas nav noklusējuma vērtība, kubectl komandās jums būs jānorāda darba vārda telpa - nosaukumvieta = $ WORKING_PROJECT, kas, manuprāt, var būt laba drošības prakse. Tomēr jūs vienmēr varat - visas vārdu vietas vai kā noklusējuma iestatīt citu nosaukumvietu (saite).

4. Pārāk daudz problēmu risināšanas paņēmienu

Tas rada bažas. Es domāju, ka tas, iespējams, nav patiess, bet, ja nav labu norādījumu un paraugprakses, iespējams, šķiet, ka ir pārāk daudz līdzīgu veidu, kā atrisināt to pašu problēmu. Es izmantoju kopīgu modeli, ko šeit apkopoju, lai rosinātu diskusiju:

  • YAML faili ir zināšanas saldētavā (sk. # 5)
  • Jūsu konteineriem vajadzētu labi darīt vienu lietu (skat. “Bezrūpīgs”)
  • Vienmēr izvietot izvietojumus (skat. 6. punktu)
  • Ja vēlaties L7 aka HTTP / S slodzes līdzsvarošanu, izmantojiet Ingress (sk. # 7 - ha!)
  • Droši pārvaldiet akreditācijas datus, izmantojot Secrets (saite)

5. Neobjektivitāte attiecībā uz kubectl - faila nosaukums pār alternatīvām

Izmantojot kubectl create namespace / $ {WORKING_DIR}, ir viegli nokļūt ātri un ātri, taču pēc vairākām šādām komandām jums var rasties jautājums, kā jūs esat sasniedzis pašreizējo stāvokli un - vēl svarīgāk - kā atjaunot šo stāvokli. Es iesaku jums izveidot YAML failus, lai aprakstītu savus resursus, nevis līdzvērtīgu komandu kub ectl create.

Es aicinu jūs iepazīties ar * izcilo * Kubernetes API dokumentāciju (saite, saite un 1.10), kas ir izsmeļoša, precīza un viegli orientējama (iespējams, perfekta dokumentācija !?). Bet, pat izmantojot šo jaudīgo rīku, dažreiz ir grūti izaicināt paņemt jums noderīgu kubectl komandu un pārveidot to YAML. Tas nav:

kubectl saņemt izvietošanu / $ {MY_DEPLOYMENT} --output = yaml
kubectl saņemt pakalpojumu / $ {MY_SERVICE} - output = yaml
kubectl saņemt jebko / $ {MY_ANYTHING} --output = yaml

Pievienojiet rezultātus failā, ja vēlaties, bet izmantojiet tos par pamatu līdzvērtīgam (!) YAML failam. Jums būs jāatstāj visas atsauces uz instancēm.

Kad esat izveidojis meistardarbu.yaml, es aicinu jūs vienmēr pieteikties veikt sākotnējo izveidi, pieteikties veikt visus turpmākos atjauninājumus un, ja jums tas ir jāizdzēš. Tieši tā!

kubectl apply --filename = masterpiece.yaml
kubectl izdzēst - faila nosaukums = masterpiece.yaml

Neliels ieskats: lai izvērstu, jums nav jāvelk vietējie YAML faili. Jūs varat sniegt kubectl apply --filename arī ar URL un kamēr visi atkarīgie faili ir vietējas atsauces, izvietošana darbosies.

Neliels ieskats: vienīgā vieta, kur es to izmantoju, ir Kubernetes zemē, taču tā ir likumīga prakse, jūs varat apvienot vairākus YAML failus vienā YAML failā ar --- un ... failu atdalītājiem. Tātad, nevis nosaukumvietas YAML, izvietošanas YAML un pakalpojuma YAML vietā, iespējams, jums ir mega-YAML, kas visus trīs failus apvieno vienā.

Tas ir derīgs YAML (kopējiet un ielīmējiet to, piemēram, YAML Lint). Tas ir * nederīgs * Kubernetes spec | YAML, jo katra specifikācija ir nepilnīga, bet, ja katra no tām tiktu pabeigta, tas ir lieliski YAML un labs veids, kā saglabāt resursus.

Par vienu kritiku skatiet #B (Xsonnet).

6. Izmantojiet izvietošanu

Izvietošanā ir daudz enerģijas, pietiek ar maniem norādījumiem, lai teiktu: izmantojiet izvietošanu visu laiku, katru reizi. Pat tad, kad jūs izvietojat savu pirmo singlu podnginx. Izvietošana ir “Pirmās klases” ceļojums par Coach cenu, jūs varat nonākt slīdošajā izvietošanā, jūs pieļāvāt kļūdu, atkārtoti piesakāties, un Kubernetes rūpējas par nerātno pākstu nogalināšanu un aizstāšanu ar labi izturēšanos.

7. LoadBalancer un Ingress

Tie rada neskaidrības. Manuprāt (un es varētu kļūdīties), veidojot pakalpojumus, izmantojot --type = LoadBalancer, es gribu | iegūt tīkla LB. Ja es vēlos HTTP / S (7. līmenis) slodzes līdzsvarošanu, man jāizveido ievainojums. Ingress ir mulsinošs Kubernetes resurss. Pietiek pateikt, L7 == notiek (un rezultātā ir daudz konfigurācijas jaudas).

Kubernetes Engine manifestē resursus kā GCE HTTP / S slodzes līdzsvarotājus. Kristofers Grants savos amatos (šeit un šeit) veic ļoti labu darbu, lai mazinātu Ingress.

8. NodePorts

Es nekad (nekad?) Neesmu tieši izveidojis ClusterIP. Es esmu darījis Kubernetes lietas, kuru rezultātā ClusterIPs atklāja pakalpojumus. Pārsvarā (!) Es izveidoju NodePorts vai arī daru lietas (piemēram, izveidoju Ingress resursus), kurās tiek izmantots NodePorts.

NodePorts ir saistīts ar Kubernetes mezgliem, un tie ir porti. To nodrošinātais jaudīgais līdzeklis ir tāds, ka * katrs * klastera * mezgls (vai tas ir šis NodePool? [[TODO]]) pakļauj vienu un to pašu pakalpojumu tajā pašā (mezgla) ostā.

Ja izveidoju pakalpojumu, kas ir atvērts NodePort X, es varu būt drošs, ka, piekļūstot šim portam * klastera * jebkurā mezglā, es tam piekļūšu. Tas veido Kubernetes slodzes līdzsvarošanas iespēju pamatu, jo klasteris spēj novirzīt ienākošos pakalpojuma pieprasījumus uz šo portu uz jebkuru mezglu.

Google Cloud SDK (pazīstams arī kā gcloud) ietver SSH klientu, kas padara triviālu savienojumu ar Compute Engine VM (kas, kā jūs atceraties, ir Kubernetes klastera mezgli). SSH klientam ir arī portu pāradresācijas spēja. Tātad, ja mēs vēlamies izveidot savienojumu ar Kubernetes pakalpojumu un mēs varam meklēt pakalpojuma NodePort, tad mēs varam triviāli (!) Portu pāradresēt uz šo pakalpojumu, izmantojot portu pāradresāciju (izmantojot gcloud vai jebkuru SSH klientu) uz jebkuru portu. Mezgls.

Šis piemērs izmanto kubectl, lai klasterī satvertu 0. mezglu. Kubernetes dzinēja mezgla nosaukums ir tāds pats kā Compute Engine VM nosaukums. Ņemot vērā pakalpojumu, ko sauc par $ {MY_SERVICE} nosaukumvietā ar nosaukumu $ {MY_NAMESPACE}, mēs nosakām pakalpojuma NodePort. Pēc tam mēs pārslēdzamies uz gcloud un izmantojam tā iebūvēto ssh, lai pārietu uz priekšu (izmantojot -ssh-flag = "- L XXXX: localhost: XXXX).

NODE_HOST = $ (\
  kubectl iegūt mezglus \
  - output = jsonpath = "{. vienumi [0] .metadata.name}")
NODE_PORT = $ (\
  kubectl saņemt pakalpojumus / $ {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}" \
- projekts = $ {YOUR_PROJECT}

Kas šajā sakarā ir tik spēcīgs? Tagad jūs varat piekļūt pakalpojumam tā, it kā tas būtu lokāls, un jums nav jāpiesprauž caurumi ugunsmūrī.

NodePorts ir porti ar lielu numuru (~ 30 000–32 767).

9. Datorurķēšana kubectl izmantojiet JSON

Google Cloud Cloud SDK (pazīstams arī kā gcloud) ir patiešām lielisks, taču kubectl (Kubernetes CLI) ir labāks (sic). Viena efektīva funkcija ir izvades formatēšana un filtrēšana. Tas ļauj nekodēt (ne-API-wrangling) veidus, kā paplašināt skriptus un citus rīkus ar informāciju no Kubernetes klasteriem.

Viss Kubernetes resursa stāvoklis ir pieejams, izmantojot, piem. kubectl saņemt (manā pieredzē šim nolūkam noderīgākas nekā kubectl aprakstīt) komandas. Pēc tam atliek tikai atrast adatu tajā, kas var būt JSON siena kaudze.

Viltība ir šāda:

kubectl get [resurss] / [resursa nosaukums] - output = JSON

Pēc tam rezultātu acīs, lai sāktu veidot vaicājuma virkni:

kubectl get [resurss] / [resursa nosaukums] - output = jsonpath = ". items [*]"

un iteratīvi uzlabojiet noteikto rezultātu, līdz jums ir prece (-s), kuru meklējat. Šis ir piemērs, kam vajadzētu darboties ar jebkuru kopu:

kubectl iegūt mezglus - output = json
kubectl iegūt mezglus --output = jsonpath = "{. preces [*]}
kubectl iegūt mezglus --output = jsonpath = "{. vienumi [0]}
kubectl get mezgli - output = jsonpath = "{. vienumi [0] .metadata.name}

Visbeidzot, ir pienācīgs arguments (un princips * nix), lai iemācītos vienu JSON parsēšanas rīku un piemērotu šo rīku visām JSON parsēšanas vajadzībām. Vai šajā gadījumā ir kāds saprātīgs JQ konkurents? Man ir aizdomas, ka nē.

Plus jq ir lielisks rotaļu laukums (jqplay.org).

A. Izmantojiet etiķetes

Tas bija pagājis ilgs laiks, bet visa veida programmatūras pakalpojumi tagad atbalsta patvaļīgu resursu marķēšanas koncepciju (parasti galveno vērtību pāri). Ietekmes iemesls ir tas, ka šie metadati nodrošina beztermiņa, pilnībā lietotāja definētu veidu, kā pieprasīt resursus. Kubernetes šo principu izmanto raksturīgi; tā ir raksturīga spēja, nevis pēcpārdomāšana |

Kubernetes dienests pakļauj patvaļīgu skaitu Kubernetes Pods. Pakalpojums * neizsaka * statīvus, kurus sauc par “Henriju”, vai Pods, kas satur ReplicaSet. Tā vietā pakalpojums pakļauj statīvus, kuru etiķetes atbilst kritērijiem, kas noteikti pakalpojuma specifikācijā, un šīs etiķetes, protams, ir noteiktas lietotāja.

NB! Iepriekšminētajā piemērā mēs izmantojam nosaukumvietu, ko sauc par projektu-x, un šī nosaukumvietas specifikācija parādās nosaukumvietā (kad tā tiek izveidota), izvietošana, lai noteiktu, kur pastāv izvietošana, un pakalpojums. Izvietošana (ko sauc par mikroservisu-y) izveidos ReplicaSet (tas netieši norādīts šeit; tas ir tas, ko izveido izvietošana), kas uztur 100 Pods. Katrā Pod būs iezīmju lietotne: publicname-a, un tajās ir viens konteiners ar nosaukumu grpc-proxy, pamatojoties uz attēlu, ko sauc par image-grpc-proxy. Pakalpojumu sauc par pakalpojumu-p. Būtiski, ka dienests izvēlas (!) Pods (tikai projekta x nosaukumvietā), kuriem ir apzīmējums app: publicname-a. Pakalpojums atlasīs jebkuru Pod (projekta x nosaukumvietā), kam ir šī etiķetes (atslēga: vērtība) pāra * nevis * tikai tie Pods, kas izveidoti šajā izvietojumā. Pakalpojums neatsaucas uz pākstiem pēc to nosaukuma (kura pamatā ir izvietošanas nosaukums), konteinera nosaukuma vai konteinera attēla nosaukuma, tikai uz etiķetēm, kas saistītas ar pod.

NB! Tā nav * laba prakse, bet tā pierāda to. Ja jūs vadītu konfigurāciju, kas līdzīga iepriekšminētajam, un pēc tam atsevišķi izveidotu, piem. Pod, palaižot Nginx (projekta x nosaukumvietā), un pēc tam jūs tam pievienojāt apzīmējuma lietotni: publicname-a, tas ātri tiks iekļauts Pods komplektā, kuru apkopo service-p Service. Ja jūs noņemtu etiķeti no jebkura pakalpojuma apkopotajiem paliktņiem, Pods vairs netiktu iekļauts.

Šī funkcija tiek parādīta, veicot atjauninošos atjauninājumus, kur izvietošana izveido jaunu ReplicaSet, kas satur jaunus Pods versijai X ', kas atšķiras no ReplicaSet un Pods X versijai. Pakalpojums var tikt definēts, lai pakļautu Pods krustojumu, kas darbojas abās šajās versijās, jo tas nav definēts ReplicaSets vai īpašos Pods izteiksmē, bet gan ar lietotāja definētām etiķetēm (“selektoriem”), kuras jūs lietojat, veidojot Pods.

Tas ir ļoti spēcīgi!

B. Izmantojiet Jsonnet, iespējams, Ksonnet

Divas problēmas ar visiem (!?) Strukturētajiem formātiem (YAML, JSON, XML, CSV ;-) ir paš atsauces un mainīgie. Kad jūs izstrādājat marvellous.yaml specifikācijas savai Kubernetes izvietošanai, jūs viegli saskarsities ar šo problēmu. Jūs atradīsit sevi lietojot burtus (piemēram, attēlu nosaukumiem un kopsavilkumiem) un pat ar ievērojamo izvietošanu atkārtojot nosaukumus un atlasītājus.

Šīm problēmām nav risinājuma, ja aprobežojaties ar YAML un JSON. Google daļēji izveidoja Jsonnet, lai risinātu šīs problēmas. Gudrie Heptio ļaudis ir paplašinājuši Jsonnet līdz Kubernetes ar… Ksonnet.

Abas ir veidņu valodas, kurās risinātas iepriekš (un vēl vairāk) izklāstītās problēmas. Es aicinu jūs apsvērt Jsonnet. Tāpat kā ar manu ieteikumu apsvērt jq izmantošanu, vienreiz apgūstiet Jsonnet un izmantojiet to visur, kur lietojat JSON. Ksonnet ir raksturīgs Kubernetes, un - savā ierobežotajā (!) Pieredzē es atklāju, ka ieguvumi, kas iegūti no šīs specifikas, nav svarīgāki par mācību līkni.

C. YAML vai JSON

Kubernetes YAML un JSON izturas galvenokārt vienādi. Personīgi es uzskatu, ka YAML ir vēlams konfigurācijas failiem, kurus es kubectl lietoju, jo YAML ir kodolīgāks par JSON. Lai gan man YAML ir grūtāk rakstīt.

Tomēr, runājot par struktūras izpratni un parsēšanu, es dodu priekšroku - output = JSON un arī tāpēc, ka - output = JSONPATH. Es esmu milzīgs Golang fans, bet Go veidnes nav tik intuitīvas, un es tās neizmantoju.

neliels ieskats: YAML ir JSON superset (saite)… pagaidiet! kas?

D. Downward Dog API un konfigur

“Lejupvērstā API”, lai tai piešķirtu pareizo, lai arī ne mazāk neskaidro nosaukumu, ir Kubernetes iekārta, ar kuras palīdzību Pods var iegūt izpratni par apkārt esošo kopu. Es pieņemu, ka normāla plūsma notiek no ārpasaules līdz podiņam un tā konteineriem *, bet * ir reizes, kad konteineram (!) Ir noderīgi iegūt informāciju par tā vidi, piem. tā mezgla nosaukums | IP, poda nosaukums (atstarpe) | IP.

Lejupvērstās API vērtības konteinerā tiek parādītas, izmantojot vides mainīgos. Vides mainīgie tiek izmantoti (tāpat kā citur), lai konteineriem nodrošinātu konfigurāciju vai citu stāvokli. Vides mainīgo izmantošanas un lejupejošās API ieviešanas (ar nelielu brīdinājumu) ļoti jaukas sekas ir tas, ka konteiners paliek atdalīts no Kubernetes.

Šis ir mana drauga - Sal Rashid - piemērs, kurš izmanto lejupejošo API, lai apkopotu mezglu un Pod stāvokli un parādītu tos lietotājam:

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

NB! Skatiet sadaļas, kas sākas ar 76., 80., 84., 88. rindu, kur pakārtoto vārdu, nosaukumvietu, IP un mezgla nosaukumu izpildlaiks nodrošina lejupvērstā API konteineram ar nosaukumu myapp-container.

Lejupvērstā API ir vienīgais praktiskais veids, kā apkopot šos datus par konteineru. Tātad tā drīzāk ir “vienīgā prakse”, nevis “labākā prakse”.

Daudzos no maniem postījumiem, veidojot Kubernetes risinājumus, es testēju procesu lokāli un ārpus konteinera, pēc tam konteinerā (norādot vides mainīgos lielumus), pēc tam Kubernetes klasterī. Konteinerizētie mehānismi ir konsekventi (skatīt zemāk), kaut arī viens parasti darbojas uz Docker un viens uz Kubernetes.

Nesen rakstā, kas rakstīts Google operētājsistēmā Container Optimized, es demonstrēju konteineru, kas darbojas lokāli ar Docker, attālināti ar konteineru optimizētu OS un pēc tam Kubernetes.

Šeit darbojas vietne Docker. Ievērojiet, kā vides mainīgie (- env) tiek izmantoti, lai nodrošinātu gcr.io/${PROJECT}/datastore konfigurāciju.

dokotāja palaist \
--interaktīvs \
- diezgan \
--publicēt = 127.0.0.1: 8080: 8080 \
--env = GCLOUD_DATASET_ID = $ {PROJECT} \
--env = GOOGLE_APPLICATION_CREDENTIALS = / tmp / $ {ROBOT} .key.json \
--svars = $ PWD / $ {ROBOT} .key.json: / tmp / $ {ROBOT} .key.json \
gcr.io/${PROJECT}/datastore

Šis ir tas pats rezultāts, iesaiņojot izvietošanu, izveidojot konteinera optimizētu virtuālo datoru. Šoreiz pārbaudiet vērtības, kas norādītas konteinera env karogam:

gcloud beta aprēķināšanas gadījumi izveidot ar konteineru $ {INSTANCE} \
- zona = $ {ZONE} \
--attēlu ģimene = kos stabils \
- attēls-projekts = cos-mākonis \
--container-image=gcr.io/${PROJECT}/${IMAGE}@${DIGEST}
--container-restart-policy = vienmēr \
--container-env = \
GCLOUD_DATASET_ID = $ {PROJECT}, \
GOOGLE_APPLICATION_CREDENTIALS = / tmp / $ {ROBOT} .key.json \
--container-mount-host-path = \
montāžas ceļš = / tmp, \
resursdatora ceļš = / tmp, \
mode = rw \
--projekts = $ {PROJECT}

Visbeidzot, šeit ir YAML fragments par Kubernetes izvietošanu:

konteineri:
      - nosaukums: datu krātuve
        attēls: gcr.io/${PROJECT}/datastore
        imagePullPolicy: Vienmēr
        apjoma stiprinājumi:
          - nosaukums: datu krātuve
            mountPath: / var / secrets / google
        env:
        - nosaukums: GOOGLE_APPLICATION_CREDENTIALS
          vērtība: /var/secrets/google/datastore.key.json
        - nosaukums: GCLOUD_DATASET_ID
          vērtība: $ {PROJECT}
        ostas:
        - vārds: http
          konteinersPorts: 8080

Tādējādi es uzskatu, ka vides mainīgo izmantošana konfigurācijai ir diezgan neveikla. Nav skaidru apzinātu konkrētu vides mainīgo saistību ar noteiktiem procesiem, un jūs tikai saprotat, ka, pārtrūkstot, tie nav pareizi konfigurēti. Ir viegli iedomāties vides mainīgos, kas konfliktē vidē, kurā nav konteinera, lai gan šī ir mazāka konteineru problēma, jo, kā minēts iepriekš, mēs precīzi nosakām konkrēta konteinera vērtības.

Viss, kas teica, vides mainīgo izmantošana šādā veidā ir labākā prakse.

E. blakusvāģi un kāpēc portfelis ne vienmēr ir sinonīms konteineriem

5 cl konjaka
2 cl trīskārša sek
2 cl citronu sulas
Pagatavošana Ielejiet visas sastāvdaļas kokteiļu kratītājā, kas piepildīts ar ledu. Labi sakratiet un izkāš kokteiļa glāzē.

Lielu daļu laika jūs izveidosit Kubernetes Pods ar atsevišķiem konteineriem, un jūs domājat, kāpēc tur ir viss Pods virs galvas, kad jums ir nepieciešams tikai viens konteiners. Pods ir vairāk līdzīgs resursdatora videi, kas var darbināt daudzus konteinerus. Ir daudz reižu, ja jūs apsvērsit vairāku konteineru vadīšanu podā…

… Un tikai vienu reizi jums vajadzētu :-)

Droši vien vairāk nekā viens, bet pieturēsimies tikai pie viena laika.

Pretstats (to nedariet) ir paredzēt jūsu pašreizējo konfigurāciju (pieņemsim, ka Web serveris un datu bāzes aizmugure) un iestrēgt abos Pod. Šī * nav * laba ideja *, ja vien * katram tīmekļa servera gadījumam jābūt neatdalāmi un mūžīgi savienotam ar noteiktu datu bāzes gadījumu. Tas ir maz ticams.

Visticamāk, ka jūsu tīmekļa servera gadījumiem vajadzētu būt mērogam pēc kopējās priekšējās platformas slodzes un datu bāzes gadījumiem vajadzētu būt mērogam (neatkarīgi no šī un), balstoties uz to kopējo spēju tikt galā ar priekšējās puses slodzi. Kad redzat apkopotu, domājat par pakalpojumu un, domājot par pakalpojumu, lūdzu, mēģiniet paredzēt patvaļīgu numuru skaitu (jo tas ir svarīgs jūsu rēķinam, bet lielākajai daļai citu mērķu nav nozīmes, cik daudz Pods ir vajadzīgs, kamēr vien numurs ir tieši piemērots darba slodzes apkalpošanai).

Kad jums vajadzētu apsvērt vairākus konteinerus vienā Pod? Vienmēr, kad šim * vienmēr * ir jēga, ir tas, kad vēlaties papildināt, paplašināt vai bagātināt primārā poda izturēšanos traukā. Pārskatīsim tīmekļa servera un datu bāzes piemēru no augšas. Šajā scenārijā, cerams, tagad esat pārliecināts, ka izvērsīsit divus pakalpojumus (un divus izvietojumus) - vienu priekšpuses un otru aizmugures versijai.

Tā ir laba un ierasta prakse, lai jūsu tīmekļa servera instance tiktu aizstāta ar reverso starpniekserveri. Parasti tas ir vai nu Nginx, vai HAProxy, un aizvien biežāk tiek izmantots Envoy (ja ieskatāties uz pilnvarām, es iesaku apsvērt sūtni; skat. #F Istio). Apgrieztais starpniekserveris nodrošina konsekvenci (mēs izmantojam tikai, piemēram, Envoy), pat ja jūs izmantojat dažādus tīmekļa serverus (piemēram, Apache, Tomcat w / Java utt.), Pat ja jums ir HTTP, gRPC, Web Sockets utt. Trafika sajaukums. , pat ja vēlaties novirzīt daļu trafika uz savu tīmekļa serveri un daļu trafika uz kešatmiņu (piemēram, laka).

Visos iepriekšējos scenārijos būtu jēga izmantot “blakusvāģa” modeli. Šajā modelī primārajam konteineram (jūsu tīmekļa serverim) ir papildu, papildu komplekti (Envoy proxy, Varnish cache utt.). Tiem jābūt cieši savienotiem ar noteiktu tīmekļa servera gadījumu * un * funkcionāli, kombinācija ir “vienība”.

Ļoti bieži mežizstrādi, uzraudzību, izsekošanu un citas infrastruktūras sastāvdaļas redz arī kā blakusvāģus. Motivācija šeit ir nodalīt bažas. Nodrošināt izstrādātājiem konsekventu prasību, kas rada “pārvaldāmu” kodu, un SRE nodrošina iespēju elastīgi izvēlēties vēlamos rīkus, zinot, ka viss autoparka kods reģistrēsies, izstaros metriku, būs izsekojams, konsekventi izmantos autorizāciju utt. Šis ir modelis kas veido pakalpojumu acu pamatu (sk. #F Istio). Šī ir pēdējā labākā, kaut arī topošā prakse.

F. Izmantojiet Istio

Lietojiet Istio uzmanīgi.

Istio (un citi pakalpojumu tīkli) ir salīdzinoši topošās tehnoloģijas, kas radītas no uzņēmumiem (ieskaitot Google), kuri ir izmantojuši konteinerus masveidā. Pakalpojuma tīkli triviāli ievieto universālu (Istio gadījumā Envoy) starpniekserveri katrā Pod katrā displejā katrā Namespace telpā un katrā klasterī.

Rezultāts ir konsekvents pārvaldības substrāts, kas ļauj brīvi savienot vadību (mēs šodien izmantosim Stackdriver Trace, taču ir plānots pāriet uz Jaeger, mēs esam ieviesuši mūsu Prometheus uzraudzības sistēmu) un kontroles pakalpojumus (mēs zinām, ka visi mūsu pakalpojumi ir droši, mēs novirzīt 10% no satiksmes uz A, B un C pakalpojumu kanārijputniņiem.

Es iesaku “uzmanīgi”, jo šīs tehnoloģijas ir jaunas, ar aptuvenām malām un strauji attīstās. Bet metodoloģijas sniegtās priekšrocības (elastība, veiklība, izturība pret nākotni), iespējams, ievērojami pārsniedz izmaksas. Vissvarīgākais - izmantojiet servisa sietu kā modeli kopā ar Kubernetes, pat ja jūs vēl nevēlaties izmantot kādu no pakalpojumu sietu tehnoloģijām.

Tas ir viss, ļaudis!