Nu när din applikation körs smidigt i containrar är nästa utmaning att orkestrera och hantera dessa containrar i stor skala. Det är här Kubernetes kommer in i bilden.

För att komma igång definierar du applikationens önskade tillstånd med hjälp av YAML-filer. En fil beskriver en Deployment, som hanterar uppdateringar och skalning, medan en annan definierar en Service, som exponerar din applikation mot nätverket och gör den tillgänglig för användare.

En Deployment säkerställer att önskat antal applikationsinstanser (Pods) alltid körs och gör det enkelt att rulla ut uppdateringar eller återgå till tidigare versioner. En Service exponerar dessa containrar mot nätverket och fördelar inkommande trafik mellan dem.

Köra Minikube

Efter att du har installerat Minikube och lagt till det i din system-PATH, öppna PowerShell (eller din valda terminal) och kör:

Detta kommando kontrollerar om Minikube är tillgängligt och visar den installerade versionen.

När du har bekräftat att Minikube är installerat, starta din lokala Kubernetes-kluster med:

Detta kommando skapar och startar ett lokalt Kubernetes-kluster på din maskin. Det laddar ner nödvändiga komponenter och startar kontrollplanet samt arbetsnoderna.

Distribution: Utrullning av applikation

Börja med att skapa filen deployment.yaml. En Deployment i Kubernetes säkerställer att ett specifikt antal Pods (applikationsinstanser) alltid körs och kan uppdateras eller återställas utan driftstopp.

I denna manifest anger parametern replicas hur många Pod-instanser som ska köras samtidigt — i detta fall två. För att veta vilka Pods som ska hanteras använder Deployment en kombination av selector och labels: selector fungerar som ett filter för att hitta Pods med en specifik label, och Pod-mallen definierar den labeln. När labels matchar betraktar Deployment dessa Pods som sina egna och ansvarar för att upprätthålla deras antal, uppdatera dem och starta om dem vid behov.

Alla Pods körs på port 3000. De kan alla använda samma port eftersom varje Pod arbetar i sitt eget isolerade nätverksutrymme, så det uppstår ingen konflikt mellan dem.

Service: Nätverksåtkomst till applikationen

När Deployment är på plats behövs en Service för att tillhandahålla nätverksåtkomst och lastbalansering mellan Pods. Skapa filen service.yaml:

Detta manifest definierar en Service med namnet my-app-service som dirigerar trafik till Pods med etiketten app: my-app. Den lyssnar på port 80 externt och vidarebefordrar förfrågningar till port 3000 inuti Pods.

Typen LoadBalancer är viktig eftersom den exponerar applikationen externt och distribuerar trafik över Pods.

Distribuera applikationen i Kubernetes

När YAML-filerna är klara kan de appliceras på klustret:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Kommandot kubectl apply -f skapar eller uppdaterar resurser i klustret baserat på innehållet i YAML-filen.

Kontrollera status

Efter att ha tillämpat konfigurationsfilerna är det viktigt att bekräfta att allt har distribuerats som förväntat. Eftersom Pods och Tjänster tar en stund att starta, börja med att lista de körande Pods:

Om filen deployment.yaml anger replicas: 2, ska två Pods visas i utdata.

För att bekräfta att Tjänsten körs och är tillgänglig:

Detta visar Tjänstens IP-adress och de portar genom vilka applikationen kan nås.

Hämta tjänstens URL

För att komma åt din applikation, kör följande kommando i PowerShell eller din terminal:

Detta kommando instruerar Minikube att returnera den URL där din applikation är exponerad. Minikube kontrollerar den tjänst du skapade (my-app-service) och tillhandahåller en länk som du kan öppna i din webbläsare.

Skala applikationen

Kubernetes gör det enkelt att justera antalet körande Pods utan att stoppa applikationen.

Till exempel, för att skala från 2 till 4 repliker:

Att köra kubectl get pods igen kommer nu att lista fyra aktiva Pods.

Kubernetes tillhandahåller kraftfulla verktyg för att hantera containeriserade applikationer i alla skala. En Deployment säkerställer att rätt antal Pods körs och kan enkelt uppdateras eller återställas. En Service exponerar applikationen mot nätverket och balanserar inkommande trafik. YAML-konfigurationsfiler gör uppsättningen tydlig och läsbar, medan kubectl-kommandon möjliggör att dessa konfigurationer kan tillämpas och hanteras i realtid.