Kubernetes Introduktion: Hur man effektivt hanterar containeriserade applikationer

Kubernetes har blivit den mest populära plattformen för containerorkestrering, som erbjuder en lösning för automatiserad distribution, skalning och hantering av containeriserade applikationer. Denna artikel kommer att ge en praktisk introduktion för nybörjare och medelnivåutvecklare, för att hjälpa dig snabbt förstå Kubernetes kärnkoncept och praktiska operationer.

Vad är Kubernetes?

Kubernetes (vanligtvis förkortat till K8s) är en öppen plattform för automatisering av distribution, skalning och hantering av containeriserade applikationer. Den utvecklades av Google och donerades till Cloud Native Computing Foundation (CNCF). Kubernetes huvudmål är att förenkla livscykelhanteringen av applikationer och säkerställa systemets hög tillgänglighet och automatiserad hantering.

Kubernetes kärnkomponenter

1. Pod

Pod är den minsta distributionsenheten i Kubernetes, som kan innehålla en eller flera containrar. Varje Pod delar nätverk och lagring, vilket gör den lämplig för att köra tätt kopplade tjänster.

apiVersion: v1
kind: Pod
metadata:
  name: my-app-pod
spec:
  containers:
  - name: my-app-container
    image: nginx

2. Deployment

Deployment används för att hantera Pod:ens livscykel, säkerställa att ett angivet antal Pods är i drift och möjliggöra versionskontroll och uppdateringar.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app-container
        image: nginx

3. Service

Service tillhandahåller en stabil åtkomstpunkt, vilket tillåter andra Pods eller externa användare att få tillgång till körande Pods.

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 80

Kubernetes fördelar

• Automatiserad hantering: Kubernetes kan automatiskt distribuera, skala och hantera containerapplikationer, vilket minskar manuella operationer och minskar risken för fel.
• Hög tillgänglighet: Genom ReplicaSets säkerställer Kubernetes att det finns tillräckligt med Pod-instans i drift, och om en instans misslyckas, kommer systemet automatiskt att starta om eller ersätta den.
• Lastbalansering: Kubernetes har inbyggd lastbalanseringsfunktionalitet som kan fördela trafik till tjänster, vilket säkerställer effektiv resursanvändning.

Hur man snabbt kommer igång med Kubernetes

1. Miljöförberedelse

Först behöver du sätta upp en Kubernetes-miljö. Detta kan göras på flera sätt, till exempel genom att använda Minikube för lokal testning, eller genom att sätta upp en kluster på en molnleverantör (som Google Kubernetes Engine, AWS EKS, Azure AKS).

Installera Kubernetes med Minikube

• Installera Minikube och kubectl

# Installera Minikube (se Minikube officiella dokumentation för specifika installationsmetoder)
brew install minikube

# Installera kubectl
brew install kubectl

• Starta Minikube

minikube start

2. Distribuera den första applikationen

Som exempel kan vi använda Nginx och definiera en Deployment och Service för att distribuera Nginx.

# Skapa deployment.yaml fil
cat  deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
EOF

# Tillämpa distribution
kubectl apply -f deployment.yaml

# Skapa service.yaml fil
cat  service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort
EOF

# Tillämpa tjänst
kubectl apply -f service.yaml

3. Åtkomst till applikationen

När du skapar en NodePort-typ av Service kommer Kubernetes att tilldela en port till den. Du kan få åtkomstadressen med följande kommando:

minikube service nginx-service --url

Använd webbläsaren för att besöka den utskrivna URL:en för att se Nginx välkomstsidan.

Vanliga fel och felsökning

Under användningen av Kubernetes kan du stöta på några vanliga problem, som att Pod-status är CrashLoopBackOff. Detta är inte ett fel, utan en säkerhetsmekanism där Kubernetes inte kommer att starta om Pod oändligt efter en krasch, utan istället ökar fördröjningen mellan varje omstart för att undvika systemkaos.

Du kan använda följande kommando för att se loggarna för Pod, vilket hjälper till med felsökning:

kubectl logs 

Slutsats

Kubernetes är ett kraftfullt verktyg för hantering av containrar. Genom att förstå dess kärnkoncept och vanliga kommandon kan du effektivare hantera och distribuera moln-native applikationer. Med den ökande populariteten av molnberäkning och containerteknik kommer lärande av Kubernetes att öppna nya möjligheter för din karriärutveckling. Vi hoppas att denna guide kan ge hjälp och referens i din lärande resa med Kubernetes.