Distribuera appar på Kubernetes-kluster

I en tidigare artikel distribuerade vi ett Kubernetes-kluster med en huvud- och en arbetarnod. Kubernetes kluster handlar främst om två saker; Noder och skida. Pods är de containeriserade applikationerna som du vill distribuera på klustret och noder är de enskilda beräkningsservrarna som ansvarar för antingen hantering av klustret eller körning av appar. För att göra saken enklare börjar vi med en statslös applikation och introducerar olika koncept som etiketter och väljare som används för att binda pods med varandra.

Det finns andra viktiga begrepp som replikuppsättningar, tjänster och distributioner som vi alla kommer att lära oss i den här artikeln.

Traditionell appdistribution

Om du tittar på det traditionella sättet att distribuera en webbapp är skalbarhet något du måste tänka på innan du börjar. Om du behöver en databas som är skild från din webbgränssnitt är det bättre att du gör det just nu än att göra det senare. Planerar du att köra mer än en webbapp? Konfigurera en omvänd proxyserver bättre i förväg.

Med Kubernetes har tillvägagångssättet förändrats. Driftsättning kan göras med tanke på nuvarande behov och kan senare skalas när ditt företag växer. Containerization låter dig separera viktiga komponenter i dina webbtjänster, även när de körs på en enda nod. Senare när du skalar horisontellt (vilket innebär att du lägger till fler servrar i din miljö) behöver du helt enkelt snurra upp fler behållare, och Kubernetes kommer att schemalägga det på lämpliga noder för dig. Omvänd proxy? Kubernetes tjänster skulle komma in för att lösa det problemet.

Skida

Som ett första steg, låt oss snurra upp en pod. För att göra det skulle vi behöva en YAML-fil som definierar olika attribut för poden.

apiVersion: v1
snäll: Pod
metadata:
namn: nginx
spec:
behållare:
- namn: nginx
bild: nginx: 1.7.9
hamnar:
- containerPort: 80

Lägg till innehållet ovan i a pod.yaml filen och spara den. Om du tittar på texten ovan kan du se att snäll av den resurs vi skapar är en pod. Vi heter det nginx, och bilden är nginx: 1.7.9 vilket som standard innebär att Kubernetes kommer att hämta lämplig nginx-bild från Docker-navets offentligt tillgängliga bilder.

I storskaliga organisationer är K8 ofta konfigurerad för att peka på ett privat register där det kan hämta lämpliga containerbilder.

Nu för att starta podkörningen:

$ kubectl skapa -f pod.yaml

Du kan inte komma åt podden utanför klustret. Det är inte exponerat ännu, och det existerar bara som en ensam pod. För att säkerställa att den verkligen distribueras, kör:

$ kubectl få skida

För att bli av med namngiven pod nginx, kör kommandot:

$ kubectl ta bort pod nginx

Implementeringar

Att få bara en fungerande pod är inte poängen med Kubernetes, vad vi helst skulle vilja ha, är flera repliker av en pod, ofta schemalagda på olika noder, så om en eller flera noder misslyckas är resten av podsna fortfarande kvar för att ta öka den extra arbetsbelastningen.

Dessutom måste vi ur utvecklingssynpunkt ha något sätt att rulla ut pods med en nyare version av programvaran och göra de äldre podsna vilande. Om det finns ett problem med den nyare podden kan vi rulla tillbaka genom att ta tillbaka äldre pods och ta bort den misslyckade versionen. Driftsättningar gör att vi kan göra det.

Följande är ett mycket vanligt sätt att definiera en distribution:

apiVersion: appar / v1beta1
typ: Implementering
metadata:
namn: nginx-distribution
spec:
repliker: 2
mall:
metadata:
etiketter:
app: nginx
spec:
behållare:
- namn: nginx
bild: nginx: 1.7.9
hamnar:
- containerPort: 80

Du kommer att märka bland annat ett nyckel-värdepar som är:

etiketter:
app: nginx

Etiketter är viktiga för klusterhantering eftersom de hjälper till att hålla reda på ett stort antal pods som alla har samma plikt. Pods skapas på kommandot från masternoden och de kommunicerar med masternoden. Vi behöver dock fortfarande ett effektivt sätt för dem att prata med varandra och arbeta tillsammans som ett team.

Tjänster

Varje pod har sin egen interna IP-adress och ett kommunikationslager som Flannel hjälper pods att kommunicera med varandra. Denna IP-adress ändras dock ganska mycket, och trots allt är hela poängen med att ha många pods att låta dem vara disponibla. Pods dödas och återupplivas ofta.

Frågan som nu uppstår är denna - Hur kommer front-end-podsna att prata med back-end-podsna när saker är så dynamiska i klustret?

Tjänster kommer in i bilden för att lösa denna komplexitet. En tjänst är ännu en pod som fungerar som en lastbalanserare mellan en delmängd av pods och resten av Kubernetes-klustret. Det binder sig till alla pods som har en specifik etikett kopplad till sig, till exempel databas, och sedan exponerar de dem för resten av klustret.

Till exempel om vi har en databastjänst med 10 databaspodar kan några av databaspodarna komma upp eller bli dödade, men tjänsten skulle säkerställa att resten av klustret får den "tjänst" som är en databas. Tjänster kan också användas för att exponera frontend till resten av Internet.

Här är en typisk definition av en tjänst.

apiVersion: v1
typ: Service
metadata:
namn: wordpress-mysql
etiketter:
app: wordpress
spec:
hamnar:
- hamn: 3306
väljare:
app: wordpress
tier: mysql
clusterIP: Ingen

Pods märkta WordPress med det angivna mysql-nivån är de som kommer att plockas upp av den här tjänsten och exponeras för webserverpodarna för en typisk WordPress-inställning som görs på Kubernetes.

Ord av försiktighet

När du distribuerar en gigantisk app med flera nivåer riktad mot en stor konsumentbas blir det väldigt frestande att skriva många tjänster (eller en mikrotjänster, som de är allmänt kända). Även om detta är en elegant lösning för de flesta användningsfall kan saker snabbt gå ur hand.

Tjänster, som pods, är benägna att misslyckas. Den enda skillnaden är att när en tjänst misslyckas görs många pods, som är helt funktionella, värdelösa. Följaktligen, om du har en stor sammankoppling av tjänster (både interna och externa) och något misslyckas, skulle det vara omöjligt att räkna ut felpunkten.

Som en tumregel, om du har en grov visualisering av klustret, eller om du kan använda programvara som cockpit för att titta på klustret och förstå det, är din inställning bra. I slutet av dagen är Kubernetes utformade för att minska komplexiteten och inte förbättra den.