Implementering af apps på Kubernetes-klynger

I en tidligere artikel indsatte vi en Kubernetes-klynge med en master- og en arbejdsknude. Kubernetes-klynger handler primært om to ting; Noder og bælg. Pods er de containeriserede applikationer, som du vil distribuere på klyngen, og noder er de individuelle computerservere, der er ansvarlige for enten at administrere klyngen eller køre apps. For at gøre tingene enklere starter vi med en statsløs applikation og introducerer forskellige koncepter som etiketter og vælgere, der bruges til at binde bælg med hinanden.

Der er andre vigtige begreber som replika-sæt, tjenester og implementeringer, som vi alle lærer i denne artikel.

Traditionel app-implementering

Hvis du ser på den traditionelle tilgang til implementering af en webapp, er skalerbarhed noget, du bliver nødt til at overveje, før du starter. Hvis du har brug for en database, der er adskilt fra din webfront, er det bedre at gøre det lige nu end at gøre det senere. Har du planer om at køre mere end en webapp? Konfigurer bedre en Reverse Proxy-server på forhånd.

Med Kubernetes har tilgangen skiftet. Implementering kan ske med tanke på de nuværende behov og kan senere skaleres, når din virksomhed vokser. Containerization giver dig mulighed for at adskille væsentlige komponenter i dine webtjenester, selv når de kører på en enkelt node. Senere når du skalerer vandret (hvilket betyder at du tilføjer flere servere til dit miljø) skal du simpelthen spinde flere containere op, og Kubernetes planlægger det på passende noder til dig. Omvendt proxy? Kubernetes-tjenester ville komme ind for at løse dette problem.

Bælg

Lad os som et første skridt skrue en pod op. For at gøre det har vi brug for en YAML-fil, der definerer forskellige attributter for pod'en.

apiVersion: v1
venlig: Pod
metadata:
navn: nginx
spec:
containere:
- navn: nginx
billede: nginx: 1.7.9
porte:
- containerPort: 80

Tilføj indholdet ovenfor i a pod.yaml fil og gem den. Når du ser på teksten ovenfor, kan du se, at venlig af den ressource, vi skaber, er en pod. Vi navngav det nginx, og billedet er nginx: 1.7.9 hvilket som standard betyder, at Kubernetes vil hente det passende nginx-billede fra Docker-hubens offentligt tilgængelige billeder.

I store organisationer er K8 ofte konfigureret til at pege på et privat register, hvorfra det kan trække de relevante containerbilleder.

Nu for at starte podkørslen:

$ kubectl opret -f pod.yaml

Du kan ikke få adgang til pod'en uden for klyngen. Det er ikke udsat endnu, og det eksisterer kun som en ensom pod. For at sikre, at den faktisk implementeres, skal du køre:

$ kubectl få bælg

For at slippe af med den navngivne pod nginx, kør kommandoen:

$ kubectl slet pod nginx

Implementeringer

At få bare en fungerende pod er ikke pointen for Kubernetes, hvad vi gerne vil have, er ideelt set flere replikaer af en pod, ofte planlagt på forskellige noder, så hvis en eller flere noder fejler, er resten af bælgene stadig der for at tage øge den ekstra arbejdsbyrde.

Desuden skal vi ud fra et udviklingsmæssigt synspunkt have en eller anden måde at rulle pods ud med en nyere version af softwaren og gøre de ældre pods sovende. Hvis der er et problem med den nyere pod, kan vi rulle tilbage ved at bringe ældre pods tilbage og slette den mislykkede version. Implementeringer giver os mulighed for at gøre det.

Følgende er en meget almindelig måde at definere en implementering på:

apiVersion: apps / v1beta1
art: Implementering
metadata:
navn: nginx-implementering
spec:
replikaer: 2
skabelon:
metadata:
etiketter:
app: nginx
spec:
containere:
- navn: nginx
billede: nginx: 1.7.9
porte:
- containerPort: 80

Du vil blandt andet bemærke et nøgleværdipar, som er:

etiketter:
app: nginx

Etiketter er vigtige for klyngestyring, da de hjælper med at holde styr på et stort antal bælg, der alle har samme pligt. Pods oprettes på kommando af masternoden, og de kommunikerer med masternoden. Vi har dog stadig brug for en effektiv måde for dem at tale med hinanden og arbejde sammen som et team.

Tjenester

Hver pod har sin egen interne IP-adresse, og et kommunikationslag som Flannel hjælper pods med at kommunikere med hinanden. Denne IP-adresse ændrer sig dog ganske lidt, og trods alt er pointen med at have mange bælg at lade dem være engangsbrug. Bælter dræbes og genopstå ofte.

Spørgsmålet, der nu opstår, er dette - Hvordan vil frontend-bælgene tale med back-end-bælgene, når tingene er så dynamiske i klyngen?

Tjenester kommer ind i billedet for at løse denne kompleksitet. En tjeneste er endnu en pod, der fungerer som en belastningsafbalancering mellem en delmængde af bælg og resten af Kubernetes-klyngen. Det binder sig til alle bælgene, der har en bestemt etiket knyttet til sig, for eksempel database, og derefter udsætter den dem for resten af klyngen.

For eksempel hvis vi har en databasetjeneste med 10 databasepods, kan nogle af databasepoderne komme op eller blive dræbt, men tjenesten vil sikre, at resten af klyngen får den 'service', der er en database. Tjenester kan også bruges til at eksponere frontend til resten af internettet.

Her er en typisk definition af en tjeneste.

apiVersion: v1
venlig: Service
metadata:
navn: wordpress-mysql
etiketter:
app: wordpress
spec:
porte:
- havn: 3306
vælger:
app: wordpress
tier: mysql
clusterIP: Ingen

De bælg, der er mærket WordPress med det angivne mysql-niveau, er dem, der vil blive afhentet af denne service og udsættes for webserver-bælgene til en typisk WordPress-opsætning udført på Kubernetes.

Ord med forsigtighed

Når du implementerer en kæmpe multi-tier-app målrettet mod en stor forbrugerbase, bliver det meget fristende at skrive mange tjenester (eller en mikrotjeneste, som de er populært kendt). Selvom dette er en elegant løsning til de fleste brugssager, kan ting hurtigt komme ud af hånden.

Tjenester, ligesom bælg, er tilbøjelige til at mislykkes. Den eneste forskel er, at når en tjeneste fejler, bliver mange bælg, der er perfekt funktionelle, ubrugelige. Derfor, hvis du har en stor sammenkobling af tjenester (både interne og eksterne) og noget mislykkes, ville det være umuligt at finde ud af fejlpunktet.

Som en tommelfingerregel, hvis du har en grov visualisering af klyngen, eller hvis du kan bruge software som cockpit til at se på klyngen og give mening, er din opsætning fint. I slutningen af dagen er Kubernetes designet til at reducere kompleksiteten og ikke forbedre den.