Kubernet'lerin En İyi Uygulamaları

(Doğru) Kubernetes'in çok hızlı bir şekilde geliştiğini (para birimini korumak için çok hızlı), (birçok) yeni kavram kullandığını ve aynı sorunu çözmenin birçok yolu olduğunu belirten eski bir Googler SRE ile sohbet ediyordum.

Bunların çoğu doğrudur ve mutlaka kötü bir şey değil, diğer teknolojilerden farklı olabilir. Kabul etmediğim nokta, bu faktörlerin Kubernet'leri benimsemesini engelledi. Sizi dalmaya teşvik ediyorum. Kubernet'ler, bu (makul) kaygılara rağmen * olduğu başarı * çünkü çok çok iyi.

Bu yazıda, size bu teknolojiyi kaplarından alıp dalmanıza yardımcı olacak umudum ilk temel uygulamaları sunacağım.

Belirli bir sırada değil:

  1. Başka birinin çalmasını sağla!

Kubernetes Engine gibi bir Kubernetes servisi kullanın. Entelektüel olarak meraklı olmadığınız sürece, Kubernet'lerde çalışan bir geliştirici ya da Kubernet'lerin hizmetlerini isteyen müşterileri olan bir platform sağlayıcısıysanız, zorlukları kurtarın ve bir Kubernetes hizmeti kullanın. Kendi evini ve arabanı yaptın mı? Yoksa Kurt'un sizi havaya uçuramayacağı ve sizi A'dan B'ye güvenilir bir şekilde götürecek bir araba kullanamayacağı bir yerde uyumak mı istiyorsunuz?

Bu nedenle, diğer yayınlarımdan herhangi birini okuduysanız, Bölgesel Kümeleri değerlendirmenizi de öneririm ve bu nedenle aşağıdaki satırlar boyunca bir şeye bakıyorsunuz:

gcloud beta konteyner kümeleri $ {CLUSTER} oluşturur ...
gcloud beta konteyner kümeleri get-credentials $ {CLUSTER} ...

Ve sonra, gitmeye hazırsınız:

kubectl uygula --filename = marvels.yaml

2. “Kubernetleri” düşünmeye çalışın

Bu *, Kubernetes Engine ile diğer platformlardan daha fazla zor olabilir, ancak Google Cloud Platform'da, kaynaklarınızın Kubernet'lerdeki (örneğin Düğümler, Girişimler) ve aynı zamanda durumunun anlaşılmasını sağlamak zorunda kalırsınız. Hesaplama Motorundaki temel kaynaklar (örneğin, VM'ler, HTTP / S Yük Dengeleyicileri). Bu parçacık dalgası dualite problemi talihsizdir. Bunu benim için ilk dile getirdiği için Dale H.'e teşekkür ederim.

Mümkün olduğunda, Kubernet'lerin kaynakları açısından düşünmeye bağlı kalın ve temel GCE kaynaklarını göz ardı edin. İşimi Kubernet'lere önyargılı etmek için bir yıldan fazla zaman harcadıktan sonra, Hizmetler (ve Girişler) tarafından maruz bırakılan “bazı” Bölmeler açısından sadece düşünmek daha kolay hale geldi.

3. İsim Alanları, İsim Alanları, İsim Alanları

Güncelleme: Beni en iyi uygulama konusunda eğitmek için Michael Hausenblas'a teşekkürler * Kubernetes YAML dosyalarından isim alanlarına * not * başvurma. Her zaman ad alanlarını kullanmanız gerekirken, dosyayı uyguladığınızda bunları belirtmek daha fazla esneklik sağlar ve aynı YAML dosyalarını örneğin; farklı manzaralar Burada Michael’ın makalesine bakın.

Mike Altarace ve ben aylar önce Kubernetes'teki Namespaces ve onları nerede kullanmanız gerektiği hakkında blog yazdık. O zamandan beri, kullanım davalarımın Namespaces kullanımının çok fazla zorlanacağı kadar küçük olduğunu düşünerek kendi tavsiyemi neredeyse hiç görmedim. Ben hatalıydım. Her zaman ad alanlarını kullanın.

Konteynırlar proseslenecekse, Ad alanları Kubernetes projelerine yapılacaktır. Namespaces'in taşıdığı güvenlik sınırından ayrı olarak, işinizi bölümlemenin mükemmel bir yoludur ve işi sıfırlamak veya silmek için mükemmel bir yol sunar:

kubectl ad alanını sil / $ WORKING_PROJECT

Tek dezavantajı, varsayılan olmayan ad alanını kullanırken, bence iyi bir koruma uygulaması olabilecek kubectl komutlarında çalışma ad alanınızı --namespace = $ WORKING_PROJECT belirtmeniz gerekmesidir. Ancak, her zaman - tüm ad alanlarını veya varsayılan adınız (bağlantı) olarak farklı bir ad alanı belirleyebilirsiniz.

4. Bir sorunu çözmek için çok fazla yol var

Bu cesaret kırıcı bir endişedir. Muhtemelen yanlış olduğunu düşünüyorum, ancak iyi rehberlik ve en iyi uygulamalar olmadığında, belki de aynı sorunu çözmek için çok benzer yollar olduğu anlaşılıyor. Tartışmayı teşvik etmek için burada özetleyeceğim, kullandığım ortak bir kalıpım:

  • YAML dosyaları soğuk hava deposunda bilgi sahibidir (# 5'e bakınız)
  • Konteynırlarınız bir şeyi iyi yapmalı (bakınız “ilgisizlik”)
  • Daima Dağıtımları dağıtın (bkz. # 6)
  • L7 aka HTTP / S Yük Dengeleme istiyorsanız, Giriş kullanın (bakınız # 7 - ha!)
  • Sırları kullanarak kimlik bilgilerini güvenle yönet (link)

5. Kubectl uygulamasında yanlılık - alternatiflerin yerine dosya ismi

Kubectl ile isabet almak çok kolaydır. / $ {WORKING_DIR} ad alanı yaratır, ancak bu tür komutlardan sonra mevcut duruma nasıl ulaştığınızı ve daha da önemlisi bu durumu nasıl yeniden yaratacağınızı merak edebilirsiniz. Kaynaklarınızı tanımlamak için eşdeğer kub ectl create komutundan ziyade YAML dosyaları oluşturmanızı tavsiye ederim.

Kapsamlı, doğru ve gezinmesi kolay (belki de mükemmel belgeler !?) olan * mükemmel * Kubernetes API belgelerine (link, link ve 1.10) aşina olmanızı tavsiye ederim. Ancak, bu güçlü araçla bile, bazen sizin için çalışan bir kubectl komutu almak ve onu YAML'ye dönüştürmek biraz zor olabilir. O değil:

kubectl konuşlandırma al / $ {MY_DEPLOYMENT} --output = yaml
kubectl hizmet almak / $ {MY_SERVICE} --output = yaml
kubectl bir şey olsun / $ {MY_ANYTHING} --output = yaml

İsterseniz sonuçları bir dosyaya aktarın, ancak bunları eşdeğer (!) YAML dosyası için temel olarak kullanın. Herhangi bir örnek referansını bırakmanız gerekecek.

Masterpiece.yaml dosyasını oluşturduktan sonra, ilk oluşturmayı yapmak için her zaman başvurmanızı, sonraki güncellemeleri yapmak için başvurmanızı ve silmeniz gerekirse başvurmanızı öneririm. Bu kadar!

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

Küçük içgörü: dağıtmak için YAML dosyalarını yerel olarak çekmenize gerek yoktur. Kubectl application --filename 'i URL'lerle de sağlayabilirsiniz ve bağımlı dosyalar yerel referanslar olduğu sürece dağıtım çalışacaktır.

Küçük içgörü: kullandığım tek yer Kubernetes ülkesinde ama meşru bir uygulama, birden fazla YAML dosyasını bir YAML dosyasında --- ve ... dosya ayırıcılarla birleştirebilirsiniz. Bu nedenle, bir YAML ad alanı, bir YAML dağıtımı ve bir YAML hizmeti yerine üç dosyayı da bir araya getiren bir mega-YAML olabilir.

Bu geçerli bir YAML'dir (kopyalayıp yapıştırın, örneğin YAML Lint'e). * Geçersiz * Kubernetes spec | YAML çünkü her bir özellik eksik ancak her biri tamamlandığında, bu tamamen iyi bir YAML ve kaynakları ilişkilendirmenin iyi bir yolu.

Bir eleştiri için #B (Xsonnet) bölümüne bakınız.

6. Dağıtımları Kullan

Dağıtımlarda bir sürü güç var, söylemek için rehberliğim yeterli: Dağıtımları her zaman, her zaman kullanın. İlk single podnginx'i konuşlandırırken bile. Konuşlandırmalar, Koç fiyatına “Birinci Sınıf” seyahat, haddeleme uygulamalarına girebilir, bir hata yaparsınız, yeniden başvurursunuz ve Kubernetler, yaramaz baklaları öldürmeyi ve onları iyi niyetli olanlarla değiştirmeyi önemser.

7. LoadBalancer ve Giriş

Bunlar karışıklığa neden olur. Aklımda (ve yanlış olabilir), --type = LoadBalancer kullanarak Hizmetler oluştururken, bir Ağ LB istiyorum. Eğer HTTP / S (Seviye 7) Yük Dengeleme istiyorsam, bir Giriş yapmam gerekiyor. Ingress kafa karıştırıcı bir Kubernetes kaynağıdır. Söylemeye yeterli, L7 == Giriş (ve sonuç olarak çok fazla yapılandırma gücü).

Kubernetes Engine, Ingress kaynaklarını GCE HTTP / S Yük Dengeleyicileri olarak gösterir. Christopher Grant, girişlerinde (burada ve burada) Ingress'i parçalayan çok iyi bir iş yapıyor.

8. NodePorts

(Hiç?) Doğrudan bir ClusterIP oluşturmadım. KümeIP'lerin hizmetlerinin açığa çıkmasına neden olan Kubernet'lere bazı şeyler yaptım. Çoğunlukla (!) NodePorts yarattım veya NodePorts kullanan şeyler yaptım (ör. Ingress kaynakları oluştur).

NodePorts, Kubernetes Nodes ile ilişkilendirilir ve Limanlar'dır. Sağladıkları güçlü özellik kümedeki her * düğümün (veya bu NodePool? [[TODO]]) aynı hizmeti aynı (düğüm) bağlantı noktasında göstermesidir.

NodePort X'te açık olan bir hizmet oluşturursam, kümedeki herhangi bir * düğümdeki o bağlantı noktasına * erişirsem, hizmete erişeceğimi garanti edebilirim. Bu, Kubernet’lerin yük dengeleme özelliklerinin temelini oluşturur çünkü küme, hizmet için gelen talepleri herhangi bir düğümdeki bu bağlantı noktasına yönlendirebilmektedir.

Google Cloud SDK (aka gcloud), Compute Engine VM'lerine bağlanmayı önemsiz kılan bir ssh istemcisi içerir (bu da sizin de Kubernetes Küme Düğümleri dediğiniz gibi). ssh istemcisi bağlantı noktası iletme özelliği içerir. Yani, eğer bir Kubernetes Servisine bağlanmak istiyorsak ve servisin NodePort'una bakabilirsek, o zaman herhangi bir porttaki portlara yönlendirebilir (gcloud veya ssh istemcisini kullanarak) bu servise önemsiz bir şekilde (!) Yönlendirebiliriz. Düğüm.

Aşağıdaki örnek, kümedeki 0 düğümünü almak için kubectl'i kullanır. Kubernetes Motor Düğümü adı, Compute Engine VM adıyla aynıdır. $ {MY_NAMESPACE} adlı bir ad alanında $ {MY_SERVICE} adlı bir hizmet göz önüne alındığında, hizmetin NodePort'unu belirleriz. Daha sonra gcloud'a geçiyoruz ve ssh'yi port-forward için kullanıyoruz (--ssh-flag = "- L XXXX: localhost: XXXX kullanarak).

NODE_HOST = $ (\
  kubectl düğümleri al \
  --output = jsonpath = "{. öğeleri [0] .metadata.name}")
NODE_PORT = $ (\
  kubectl hizmet alır / $ {MY_SERVICE} \
  --namespace = $ {MY_NAMESPACE} \
  --output = jsonpath = "{. spec.ports [0] .nodePort}")
echo $ {NODE_PORT}
gcloud ssh $ hesapla {NODE_HOST} \
--ssh-flag = "- L $ {NODE_PORT}: yerel ana bilgisayar: $ {NODE_PORT}" \
--project = $ {YOUR_PROJECT}

Bu konuda bu kadar güçlü olan ne? Artık hizmete yerelmiş gibi ve bir güvenlik duvarında delik açmaya gerek kalmadan erişebilirsiniz.

NodePorts yüksek numaralı portlardır (~ 30,000–32,767).

9. Hacking kubectl JSON kullanıyor

Google’ın Cloud SDK’sı (aka gcloud) gerçekten mükemmel ancak kubectl (Kubernetes CLI) daha iyi (sic). Güçlü özelliklerden biri çıktı biçimlendirmek ve filtrelemek. Bu, kodlama yapmayan (API-wrangling olmayan) kodları ve diğer araçları Kubernetes kümelerinden gelen bilgilerle genişletme yollarına izin verir.

Tüm Kubernet'lerin kaynak durumuna örneğin; kubectl olsun (benim deneyimlerime göre bu amaç için kubectl'in tanımladığından daha kullanışlı) komutları. O zaman kalan tek şey, iğneyi JSON samanlığında ne olabileceğini bulmak.

İşin püf noktası:

kubectl olsun [resource] / [resource adı] --output = JSON

Ve sonra bir sorgu dizesi oluşturmaya başlamak için sonuçları göz küresi:

kubectl get [resource] / [resource adı] --output = jsonpath = ". items [*]"

ve aradığınız öğeyi elde edinceye kadar belirlenen sonucu yinelemeli olarak daraltın. İşte herhangi bir küme ile çalışması gereken bir örnek:

kubectl düğümleri al --output = json
kubectl alma düğümleri --output = jsonpath = "{. items [*]}
kubectl alma düğümleri --output = jsonpath = "{. items [0]}
kubectl alma düğümleri --output = jsonpath = "{. items [0] .metadata.name}

Son olarak, bir JSON ayrıştırma aracını öğrenmek ve bu aracı tüm JSON ayrıştırma gereksinimlerine uygulamak için iyi bir argüman (ve * nix in tenet) vardır. Bu durumda, jq için herhangi bir makul rakip var mı? Ben şüpheli değilim.

Ayrıca jq mükemmel bir oyun alanına sahiptir (jqplay.org).

A. Etiketleri Kullan

Uzun zamandır gelmekte olan ancak her yönden yazılım hizmetleri artık kaynakların keyfi etiketlenmesi kavramını (genellikle anahtar / değer çiftleri) desteklemektedir. Bunun güçlü olmasının nedeni, bu meta verilerin kaynakları sorgulamak için açık uçlu, tamamen kullanıcı tanımlı bir yol sağlamasıdır. Kubernet'ler bu prensibi kendiliğinden kullanır; gerçek bir kabiliyettir ve düşünce sonrası bir cıvata değil.

Bir Kubernetes Hizmeti, isteğe bağlı sayıda Kubernetes Pod'ları sunar. Bir Hizmetler * “Henry” adlı Pod'ları veya bir ReplicaSet içeren Pod'ları * göstermez *. Bir Servis yerine, etiketleri Servisin spesifikasyonu sırasında tanımlanan kriterleri karşılayan ve bu etiketler elbette kullanıcı tanımlı olan Pod'ları gösterir.

Not: Yukarıdaki örnekte, project-x adında bir ad alanı kullanıyoruz ve bu ad alanı özelliği Ad Alanında (oluşturulduğunda), Dağıtımın nerede bulunduğunu tanımlamak için Dağıtım'da ve Hizmet'te görünür. Dağıtım (microservice-y olarak adlandırılır), 100 Bölmeyi koruyacak bir ReplicaSet (burada tam olarak belirtilmiş; Dağıtımların oluşturduğu şey) oluşturacaktır. Her bölmenin bir etiket uygulaması olacaktır: publicname-a ve image-grpc-proxy adlı bir resmi temel alan grpc-proxy adlı bir kapsayıcı. Hizmet, servis-p olarak adlandırılır. Önemli bir şekilde, Servis bir etiket uygulamasına sahip (!) Bölmeleri (yalnızca project-x ad alanında) seçer: publicname-a. Servis, yalnızca bu dağıtımda yaratılan Pod'ları değil, bu etiketi (anahtar: değer) çifti * olan herhangi bir Pod'u (project-x ad alanında) seçecektir. Hizmet, Pod'lara adlarına (Dağıtım adına bağlı olarak), konteyner adlarına veya konteyner görüntü adlarına, yalnızca kapsülle ilişkili etiketlere göre başvuruda bulunmaz.

Not: Bu * * değildir * iyi bir uygulamadır, ancak bunun kanıtıdır. Yukarıdakine benzer bir konfigürasyon çalıştırıyorsanız ve ayrı ayrı mesela; Nginx çalıştıran bir Pod (proje-x ad alanında) ve sonra etiket uygulamasını eklediniz: publicname-a, buna hızlı bir şekilde servis-p Servisi tarafından toplanan Podlar kümesine dahil edilecektir. Etiketi, Servis tarafından bir araya getirilen herhangi bir Pod'dan çıkarsaydınız, Pod dahil edilmeyi bırakırdı.

Bu özellik, Dağıtım'ın X sürümü için yeni Bölmeler içeren yeni bir ReplicaSet oluşturduğu ve X sürümü için bölmelerden farklı olarak yeni bir ReplicaSet oluşturduğu güncellemelerle örneklenmiştir. Hizmet, bu sürümlerin her ikisinde de çalışan bölmelerin kesişimini ortaya koymak için tanımlanabilir. ReplicaSets veya belirli Bölmeler açısından tanımlanmamıştır, ancak bölmeler oluşturulduğunda sizin tarafınızdan uygulanan kullanıcı tanımlı etiketler (“seçiciler”) ile tanımlanmıştır.

Bu çok güçlü!

B. Jsonnet kullanın, muhtemelen Ksonnet

Tüm (!?) Yapılandırılmış biçimlerde iki zorluk (YAML, JSON, XML, CSV ;-) öz referanslar ve değişkenlerdir. Kubernetes dağıtımınız için marvellous.yaml teknik özelliklerini hazırlarken, bu sorunla kolayca karşılaşırsınız. Kendinizi değişmezleri kullanarak (örneğin, resim adları ve özetler için) ve saygın Dağıtımlarda bile yinelenen isimleri ve seçicileri bulabilirsiniz.

Kendinizi YAML ve JSON ile sınırlandırırsanız, bu sorunların çözümü yoktur. Google, bu sorunları çözmek için kısmen Jsonnet’i yarattı. Akıllı Heptio millet, Jsonnet'i Kubernetes'e… Ksonnet ile genişletti.

Her ikisi de yukarıda (ve daha fazlası) ana hatları verilen problemleri ele alan cazip dillerdir. Jsonnet'i düşünmeni tavsiye ederim. Jq kullanarak düşünmek benim önerim olduğu gibi, bir kez Jsonnet öğrenin ve JSON kullandığınız her yere uygulayın. Ksonnet, Kubernet'lere özgüdür ve - sınırlı (!) Deneyimime göre - bu özellikten elde edilen faydaların, öğrenme eğrisi tarafından ağır basılmadığını tespit ettim.

C. YAML veya JSON

Kubernet'ler YAML ve JSON'u çoğunlukla eşit olarak ele alır. Şahsen ben YAML JSON'dan daha özlü olduğu için kubectl --apply kubectl konfigürasyon dosyaları için tercih edilebilir buluyorum. YAML'ı yazmak daha zor olsa da.

Ancak, yapıyı ve ayrıştırmayı anlama konusunda, --output = JSON ve ayrıca - output = JSONPATH'i tercih ediyorum. Büyük bir Golang hayranıyım ancak Go şablonları sezgisel değil ve onları kullanmıyorum.

minör içgörü: YAML, JSON'un (süper) bir süpermarketidir… bekleyin! ne?

D. Aşağı Köpek API ve config

En az karıştırıcı isim olsa bile, doğru olanı sağlayan “Aşağı API”, Kubernet'lerde Pod'ların çevrelerindeki kümelenme hakkında bir fikir edinebilecekleri bir tesistir. Tahmin ediyorum ki, normal akış dış dünyadan Pod ve konteynerlerine kadardır * ama * bir konteynerin (!) Ortamı hakkında bilgi edinmesinin yararlı olacağı zamanlar vardır; Düğüm adı | IP, Pod’un adı (boşluk) | IP.

Aşağıya doğru API değerleri kabına çevre değişkenleri aracılığıyla sunulur. Ortam değişkenleri (başka yerlerde olduğu gibi) config veya diğer durumları konteynerlere sağlamak için kullanılır. Ortam değişkenlerini kullanmanın ve Downward API'sinin (küçük bir uyarı ile) kullanılmasının çok hoş bir sonucu, kabın Kubernet'lerden ayrılmaya devam etmesidir.

İşte Düğüm ve Pod durumunu toplamak ve bunları kullanıcıya sunmak için Downward API'sını kullanan dostum Sal Rashid - 'in bir örneği.

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

NB 76, 80, 84, 88 satırlarından başlayan bölümlere bakın; burada Pod adı, ad alanı, IP ve Düğüm adı çalışma zamanında Downya API tarafından myapp-container adındaki kaba verilir.

Aşağı doğru API, bu verileri bir kapsayıcı için toplamanın tek ve pratik yoludur. Bu yüzden “en iyi uygulama” yerine, “tek bir uygulama” dan çok daha fazlası.

Postalarımın çoğunda, Kubernet'lere çözümler ürettiğimde, işlemi yerel olarak ve bir kabın dışında, sonra bir kabın içinde (ortam değişkenlerini belirterek), sonra da bir Kubernet kümesinde test ederim. Konteynırlanmış mekanizmalar, biri genellikle Docker'da ve biri Kubernet'lerde çalışsa da tutarlı (aşağıya bakın).

Google’ın Konteyner Optimize Edilmiş İşletim Sistemi’nde yakın zamanda yazdığım bir yayında, yerel olarak Docker’ın altında, uzaktan Konteyner Optimize Edilmiş İşletim Sistemi ve ardından Kubernet'lerde çalışan bir konteyner gösteriyorum.

Yerel olarak Docker altında çalışıyoruz. Ortam değişkenlerinin (--env) gcr.io/${PROJECT£/datastore 'a config sağlamak için nasıl kullanıldığına dikkat edin.

liman işçisi
- etkileşimli \
--tty \
- yayınla = 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

İşte aynı sonucu, konuşlandırmayı bir Konteyner Optimize Edilmiş Sanal Makinenin oluşturulmasına sarar. Bu sefer container-env bayrağına verilen değerleri kontrol edin:

gcloud beta hesaplama örnekleri, container ile birlikte oluştur $ {INSTANCE} \
--zone = $ {ZONE} \
--image-family = cos-stabil \
--image-project = cos-cloud \
--container-image=gcr.io/${PROJECT /${IM/}@///imim==========
--container-restart-policy = daima \
--container-env \
GCLOUD_DATASET_ID = $ {PROJE}, \
GOOGLE_APPLICATION_CREDENTIALS = / tmp / $ {ROBOT} .key.json \
--container montaj-host-path = \
bağlama yolu = / tmp \
ana-yolu = / tmp \
mode = rw \
--project = $ {PROJE}

Ve son olarak, Kubernet'ler için Dağıtım'ın YAML snippet'i burada:

konteynerler:
      - adı: veri deposu
        image: gcr.io/${PROJECT|/datastore
        imagePullPolicy: Her zaman
        volumeMounts:
          - adı: veri deposu
            mountPath: / var / secrets / google
        env:
        - ad: GOOGLE_APPLICATION_CREDENTIALS
          değer: /var/secrets/google/datastore.key.json
        - ad: GCLOUD_DATASET_ID
          değer: $ {PROJECT}
        portlar:
        - isim: http
          containerPort: 8080

Bu nedenle, ortam değişkenlerinin config için oldukça sakar olduğunu gördüm. Belirli ortam değişkenlerinin belirli işlemlere kasıtlı olarak bağlanması net değildir ve yalnızca işler bozulduğunda doğru yapılandırılmadıklarını fark edersiniz. Kapsayıcı olmayan bir ortamda çakışan ortam değişkenlerini hayal etmek kolaydır, ancak bu, kapsayıcılarla daha az sorun teşkil eder, çünkü yukarıda olduğu gibi, belirli bir kapsayıcı için açıkça değerler koyarız.

Bütün bunlar, ortam değişkenlerini bu şekilde kullanmak en iyi yöntemdir.

E. Sidecars ve neden Pod'ların her zaman konteynerlerle eşanlamlı olmadıkları

5 cl konyak
2 cl üçlü sn
2 cl limon suyu
Hazırlık Tüm malzemeleri buzla doldurulmuş kokteyl çalkalayıcısına dökün. İyice çalkalayın ve kokteyl bardağını süzün.

Çoğu zaman, tek kapsayıcı içeren Kubernetes Pod'ları yaratacaksınız ve yalnızca bir konteynere ihtiyaç duyduğunuzda neden bir Pod'un tüm ek yükünün bulunduğunu merak edeceksiniz. Bölmeler, çok sayıda konteyner çalıştırabilen bir ana bilgisayar ortamına daha benzer. Bir Pod'da birden fazla konteyner çalıştırmayı düşüneceğiniz birçok zaman vardır…

… Ve tek bir kez yapmanız gereken :-)

Muhtemelen birden fazla, ama sadece bir seferlik yapalım.

Anti-patern (bunu yapma), mevcut yapılandırmanızı öngörmek (bir web sunucusu ve bir veritabanı arka ucu olduğunu varsayalım) ve her ikisini de bir Pod içinde sıkıştırabilir. Bu * değil * iyi bir fikirdir * sürece * her web sunucusu örneğinin ayrılmaz bir şekilde ve sonsuza dek belirli bir veritabanı örneğine katılması gerekir. Bu pek mümkün değil.

Daha muhtemel olan şey, web sunucusu örneklerinin toplam ön uç yüküne göre ölçeklendirilmesi ve veritabanı örneklerinin, ön uç yüküyle başa çıkma yeteneklerine göre ölçeklendirilmesi (bundan bağımsız ve) olması. Toplamı gördüğünüzde, Servis'i düşünün ve Servis'i düşündüğünüzde, lütfen istediğiniz sayıda Bölme öngörmeye çalışın (çünkü faturanız için önemlidir, ancak diğer birçok amaç için, kaç tane Pod'a ihtiyaç olduğu önemli değildir). sayı, iş yüküne hizmet etmek için haklıdır).

Pod başına ne zaman birden fazla konteyner düşünmelisiniz? Bunun * her zaman * ne zaman anlamlı olduğu bir zaman, bir kaptaki birincil Pod'un davranışını tamamlamak, genişletmek veya zenginleştirmek istediğiniz zamandır. Web sunucusu ve veritabanı örneğini yukarıdan tekrar görelim. Bu senaryoda, umarım şimdi, biri ön uç diğeri arka uç için iki Hizmet (ve iki Dağıtım) dağıtacağınıza ikna olmuş olursunuz.

Web sunucusu eşgörünümünüzü bir ters proxy ile tanıtmak iyi ve yaygın bir uygulamadır. Genellikle bu, Nginx veya HAProxy olur ve Envoy'u kullanmak giderek daha yaygın hale geliyor (Proxy'lere bakıyorsanız, Envoy'u göz önünde bulundurmanız önerilir; bakınız #F Istio). Ters-proxy, HTTP, gRPC, Web Prizleri vb. Trafik karışımınız olsa bile, farklı web sunucuları (örn. Apache, Tomcat w / Java vb.) Kullanıyor olsanız bile tutarlılık sağlar (yalnızca Envoy kullanırız). bir miktar trafiği web sunucunuza yönlendirmek ve bir trafiği önbelleğe almak istese bile (örn. Vernik).

Önceki tüm senaryolarda, “sepet” modelini kullanmak mantıklı olacaktır. Bu modelde, birincil kapta (web sunucunuz) yardımcı, tamamlayıcı kaplar (Envoy proxy, Varnish cache vb.) Bulunur. Bunlar, belirli bir web sunucusu örneğine * ve * sıkıca bağlanmalıdır, kombinasyon “birim” dir.

Günlük olarak, izleme, izleme ve diğer yan yapı bileşenlerini de yan sepet olarak teslim etmek çok yaygındır. Burada bir motivasyon endişeleri ayırmaktır. Geliştiricilere 'yönetilebilir' kod üreten tutarlı bir gereksinim sağlamak ve SRE'ye filodaki tüm kodların günlüğe kaydedileceğini, metrikleri yayımladığını, izlenebilir olduğunu, tutarlı bir şekilde uygulanacağını bilerek tercih edilen araçları seçme esnekliği sağlayın. Bu bir kalıptır. servis ağlarının temelini oluşturan (bkz. #F Istio). Bu, son pratik olsa da, son pratik.

F. Istio kullanın

Istio'yu dikkatli kullanın.

Istio (ve diğer hizmet ağları), büyük ölçekli konteynerler işleten şirketlerden (Google dahil) doğan nispeten yeni ortaya çıkan teknolojilerdir. Hizmet ağları, her kümedeki her Ad Alanındaki her Dağıtımdaki her Bölmeye evrensel bir (Istio’nun durumunda, Envoy) vekil sunucu yerleştirir.

Sonuç, yönetimin gevşek bir şekilde bir araya gelmesine izin veren tutarlı bir yönetim substratıdır (bugün Stackdriver Trace'ı kullanacağız, ancak Jaeger'e geçmeyi planlıyoruz, Prometheus izlememizi gerçekleştiriyoruz) ve kontrol hizmetlerini (tüm hizmetlerimizin güvenli olduğunu biliyoruz, biz trafiğin% 10'unu A, B ve C hizmetlerinin kanarya binalarına yönlendiriyor).

“Dikkatlice” öneririm çünkü bu teknolojiler yeni, pürüzlü kenarlara sahip ve hızlı bir şekilde gelişiyor. Ancak, metodolojinin avantajları (esneklik, çeviklik, geleceğe yönelik koruma) size maliyetlerden çok daha ağır basar. En önemlisi, henüz servis ağı teknolojilerinden birini benimsemek istemeseniz bile, Kubernet'lerde modeliniz olarak servis ağını kullanın.

Hepsi bu kadar millet!