Apps implementeren op Kubernetes-clusters

In een vorig artikel hebben we een Kubernetes-cluster geïmplementeerd met één hoofd- en één werkknooppunt no. Kubernetes-clusters gaan voornamelijk over twee dingen; Knooppunten en pods. Pods zijn de gecontaineriseerde toepassingen die u op het cluster wilt implementeren en knooppunten zijn de afzonderlijke rekenservers die verantwoordelijk zijn voor het beheer van het cluster of het uitvoeren van de apps. Om de zaken eenvoudiger te maken, beginnen we met een stateless applicatie en introduceren we verschillende concepten zoals labels en selectors die worden gebruikt om pods aan elkaar te binden.

Er zijn andere belangrijke concepten zoals replicasets, services en implementaties die we allemaal in dit artikel zullen leren.

Traditionele app-implementatie

Als je kijkt naar de traditionele benadering om een web-app te implementeren, is schaalbaarheid iets waar je rekening mee moet houden voordat je begint. Als u een database nodig heeft die losstaat van uw webfront-end, kunt u dit beter nu doen dan later. Ben je van plan om meer dan één web-app te gebruiken?? Beter vooraf een Reverse Proxy-server configureren.

Met Kubernetes is de aanpak verschoven. Implementatie kan worden gedaan met de huidige behoeften in gedachten en kan later worden opgeschaald naarmate uw bedrijf groeit. Met containerisatie kunt u essentiële componenten van uw webservices scheiden, zelfs als ze op één knooppunt draaien. Later, wanneer u horizontaal schaalt (wat betekent dat u meer servers aan uw omgeving toevoegt), hoeft u alleen maar meer containers te laten draaien, en Kubernetes zal het op de juiste knooppunten voor u plannen. Omgekeerde proxy? Kubernetes-services zouden komen om dat probleem op te lossen.

Pods

Laten we als eerste stap een pod draaien. Om dat te doen, hebben we een YAML-bestand nodig dat verschillende attributen van de pod definieert.

apiVersie: v1
soort: Pod
metagegevens:
naam: nginx
specificaties:
containers:
- naam: nginx
afbeelding: nginx:1.7.9
poorten:
- containerhaven: 80

Voeg de inhoud hierboven toe in a peul.yaml bestand en sla het op. Als je naar de tekst hierboven kijkt, kun je zien dat de soort van de middelen die we creëren is een peul. We noemden het nginx, en de afbeelding is nginx:1.7.9 wat standaard betekent dat Kubernetes de juiste nginx-afbeelding ophaalt uit de openbaar beschikbare afbeeldingen van Docker Hub.

In grootschalige organisaties is K8 vaak geconfigureerd om te verwijzen naar een privéregister waaruit het de juiste container-images kan halen.

Om nu de pod-run te starten:

$kubectl create -f pod.yaml

Je hebt geen toegang tot de pod van buiten het cluster. Het is nog niet blootgesteld, en het bestaat alleen als een eenzame pod. Om ervoor te zorgen dat het inderdaad wordt geïmplementeerd, voert u het volgende uit:

$kubectl krijg pods

Om de pod met de naam kwijt te raken nginx, voer de opdracht uit:

$kubectl verwijder pod nginx

implementaties

Het is niet het doel van Kubernetes om slechts één werkende pod te krijgen, wat we idealiter zouden willen, zijn meerdere replica's van een pod, vaak gepland op verschillende knooppunten, dus als een of meer knooppunten falen, zullen de rest van de pods er nog zijn om te nemen de extra werklast verhogen.

Bovendien zouden we vanuit een ontwikkelingsstandpunt een manier moeten hebben om pods uit te rollen met een nieuwere versie van de software en de oudere pods inactief te maken. In het geval dat er een probleem is met de nieuwere pod, kunnen we terugdraaien door oudere pods terug te brengen en de mislukte versie te verwijderen. Implementaties stellen ons in staat om dat te doen.

Het volgende is een veelgebruikte manier om een implementatie te definiëren:

apiVersion: apps/v1beta1
soort: implementatie
metagegevens:
naam: nginx-implementatie
specificaties:
replica's: 2
sjabloon:
metagegevens:
etiketten:
app: nginx
specificaties:
containers:
- naam: nginx
afbeelding: nginx:1.7.9
poorten:
- containerhaven: 80

U zult onder andere een sleutel-waardepaar opmerken dat:

etiketten:
app: nginx

Labels zijn belangrijk voor clusterbeheer omdat ze helpen bij het bijhouden van een groot aantal pods met dezelfde taak. Pods worden gemaakt op bevel van het hoofdknooppunt en ze communiceren met het hoofdknooppunt. We hebben echter nog steeds een effectieve manier nodig om met elkaar te praten en als team samen te werken.

Diensten

Elke pod heeft zijn eigen interne IP-adres en een communicatielaag zoals Flanel helpt pods om met elkaar te communiceren. Dit IP-adres verandert echter nogal wat en het hele punt van het hebben van veel pods is om ze wegwerpbaar te maken. Pods worden vaak gedood en opgewekt.

De vraag die nu opkomt is deze: hoe zullen de front-end pods praten met de back-end pods als de dingen zo dynamisch zijn in het cluster?

Services komen in beeld om deze complexiteit op te lossen. Een service is nog een andere pod die fungeert als een load balancer tussen een subset van pods en de rest van het Kubernetes-cluster. Het bindt zich aan alle pods waaraan een specifiek label is gekoppeld, bijvoorbeeld database, en stelt ze vervolgens bloot voor de rest van het cluster.

Als we bijvoorbeeld een databaseservice hebben met 10 database-pods, kunnen sommige database-pods omhoog komen of worden gedood, maar de service zorgt ervoor dat de rest van het cluster de 'service' krijgt die een database is. Services kunnen ook worden gebruikt om de front-end bloot te stellen aan de rest van internet.

Hier is een typische definitie van een dienst.

apiVersie: v1
soort: Service
metagegevens:
naam: wordpress-mysql
etiketten:
app: wordpress
specificaties:
poorten:
- poort: 3306
keuze:
app: wordpress
laag: mysql
clusterIP: Geen

De pods met het label WordPress met de gespecificeerde mysql-laag zijn degenen die door deze service worden opgepikt en worden blootgesteld aan de webserver-pods voor een typische WordPress-installatie op Kubernetes.

Woord van waarschuwing

Bij het implementeren van een gigantische app met meerdere lagen die is gericht op een groot consumentenbestand, wordt het erg verleidelijk om veel services te schrijven (of microservices, zoals ze in de volksmond worden genoemd). Hoewel dit een elegante oplossing is voor de meeste gebruikssituaties, kunnen dingen snel uit de hand lopen.

Diensten, zoals pods, zijn vatbaar voor storingen. Het enige verschil is dat wanneer een service faalt, veel pods, die perfect functioneel zijn, onbruikbaar worden gemaakt. Als u dus een grote onderlinge verbinding van services hebt (zowel intern als extern) en er iets faalt, wordt het onmogelijk om het punt van falen te achterhalen.

Als vuistregel geldt dat als je een ruwe visualisatie van het cluster hebt, of als je software zoals cockpit kunt gebruiken om naar het cluster te kijken en het te begrijpen, je opstelling in orde is. Kubernetes is uiteindelijk ontworpen om de complexiteit te verminderen, niet te verbeteren.