Running Docker Containers in Kubernetes

Docker hat die Art und Weise, wie Anwendungen entwickelt, verpackt und bereitgestellt werden, revolutioniert. Wenn Anwendungen jedoch an Größe und Komplexität zunehmen, kann die Verwaltung mehrerer Docker-Container eine entmutigende Aufgabe werden. Hier kommt Kubernetes ins Spiel. Kubernetes, eine Open-Source-Orchestrierungsplattform, bietet leistungsstarke Tools zur Verwaltung containerisierter Anwendungen im großen Maßstab. In diesem Artikel werden wir untersuchen, wie Docker-Container innerhalb eines Kubernetes-Clusters ausgeführt werden, und dabei wichtige Konzepte, Konfigurationen und bewährte Verfahren behandeln.

Grundlagen verstehen

Before diving into running Docker containers in Kubernetes, it’s essential to grasp some fundamental concepts.

Was ist Docker?

Docker is a platform that allows developers to automate the deployment of applications inside lightweight, portable containers. Containers package the application and all its dependencies, ensuring that it runs consistently across various environments.

Was ist Kubernetes?

Kubernetes (oft mit K8s abgekürzt) ist eine Container-Orchestrierungsplattform, die entwickelt wurde, um die Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen zu automatisieren. Sie abstrahiert die zugrunde liegende Infrastruktur und erleichtert so die Verwaltung großer Container-Cluster.

Why Use Kubernetes with Docker?

Während Docker die Möglichkeit bietet, Container auf einem einzelnen Host auszuführen, ermöglicht Kubernetes die Verwaltung von Clustern mit Docker-Containern über mehrere Hosts hinweg. Es bietet Funktionen wie:

• SkalierungPassen Sie die Skalierung Ihrer Anwendung automatisch an die Nachfrage an.
• Lastenausgleich: Distribute traffic to ensure a high availability of applications.
• Self-HealingAutomatisch fehlerhafte Container ersetzen und sie auf gesunde Knoten neu planen.
• Service DiscoveryContainer automatisch erkennen und ihre Kommunikation verwalten.

Setting Up Your Environment

Before running Docker containers in Kubernetes, ensure that you have the following prerequisites:

1. Kubernetes-ClusterSie können einen lokalen Kubernetes-Cluster mit Tools wie Minikube oder Kind einrichten oder cloud-verwaltete Lösungen wie Google Kubernetes Engine (GKE), Amazon EKS oder Azure AKS verwenden.
2. Docker InstalliertStellen Sie sicher, dass Docker auf Ihrem Computer installiert ist, um Docker-Images zu erstellen.
3. kubectl: Install kubectl, das Kommandozeilenwerkzeug zur Interaktion mit Ihrem Kubernetes-Cluster.

Installing Minikube

Für die lokale Entwicklung könnten Sie Minikube verwenden wollen. Hier ist eine kurze Einrichtungsanleitung:

1. Installieren Sie MinikubeBefolgen Sie die Installationsanweisungen für Ihr Betriebssystem von der Minikube documentation.
2. Start Minikube:

   minikube start

3. Installation überprüfen:

   kubectl get Knoten

Erstellen eines Docker-Images

Sobald Ihre Umgebung eingerichtet ist, können Sie ein Docker-Image für Ihre Anwendung erstellen. Hier ist ein Beispiel für eine einfache Node.js-Anwendung.

Schritt 1: Erstellen Sie eine einfache Node.js-Anwendung

Erstelle ein Verzeichnis mit dem Namen... myapp Und fügen Sie die folgenden Dateien hinzu:

app.js:

const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
    res.send('Hallo, Kubernetes mit Docker!');
});

app.listen(PORT, () => {
    console.log(`Server läuft auf http://localhost:${PORT}`);
});

package.json:

{
  "name": "myapp",
  "version": "1.0.0",
  "main": "app.js",
  "dependencies": {
    "express": "^4.17.1"
  }
}

Schritt 2: Erstellen einer Dockerfile

Erstelle eine Datei namens Dockerfile in dem myapp Verzeichnis

# Use the official Node.js image.
FROM node:14

# Set the working directory.
WORKDIR /usr/src/app

# Copy package.json and install dependencies.
COPY package.json ./
RUN npm install

# Copy the rest of the application code.
COPY . .

# Expose the application port.
EXPOSE 3000

# Start the application.
CMD ["node", "app.js"]

Step 3: Build the Docker Image

Navigieren Sie zu myapp Verzeichnis und bauen Sie Ihr Docker-Image:

docker build -t myapp:1.0 .

Step 4: Run the Docker Image Locally (Optional)

You can test your Docker image locally before deploying it to Kubernetes:

docker run -p 3000:3000 myapp:1.0

Visit http://localhost:3000 in Ihrem Browser, um die Anwendung laufen zu sehen.

Bereitstellen in Kubernetes

Jetzt, da Sie Ihr Docker-Image erstellt haben, ist es an der Zeit, es in Kubernetes bereitzustellen.

Step 1: Create a Kubernetes Deployment

Ein Kubernetes Deployment verwaltet mehrere Replikate Ihrer Anwendung. Um ein Deployment zu erstellen, können Sie Folgendes verwenden: deployment.yaml file.

deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:1.0
        ports:
        - containerPort: 3000

Step 2: Apply the Deployment

Verwenden kubectl um die Bereitstellungskonfiguration anzuwenden:

kubectl apply -f deployment.yaml

Step 3: Verify the Deployment

Prüfen Sie den Status Ihres Deployments und Ihrer Pods.

kubectl get deployments
kubectl get pods

Schritt 4: Die Bereitstellung verfügbar machen

Um Ihre Anwendung von außerhalb des Clusters zugänglich zu machen, können Sie sie über einen Service verfügbar machen. Erstellen Sie einen service.yaml file:

service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: NodePort
  selector:
    app: myapp
  ports:
    - port: 3000
      targetPort: 3000
      nodePort: 30001

Wenden Sie die Dienstkonfiguration an:

kubectl apply -f service.yaml

Schritt 5: Zugriff auf Ihre Anwendung

Für den Zugriff auf Ihre Anwendung besuchen Sie:

http://:30001

Zum Abrufen der Minikube-IP-Adresse:

minikube ip

Scaling and Updating Deployments

Skalierung der Anwendung

Kubernetes macht es einfach, Ihre Anwendung hoch- oder herunterzuskalieren. Sie können die gewünschte Anzahl an Replikaten direkt im Deployment ändern:

kubectl scale deployment myapp-deployment --replicas=5

You can also update the deployment with a new image version:

kubectl set image deployment/myapp-deployment myapp=myapp:2.0

Rolling Updates

Kubernetes unterstützt Rolling Updates, die es Ihnen ermöglichen, Ihre Anwendungen mit minimaler Ausfallzeit zu aktualisieren. deployment.yaml Datei mit neuer Bildversion speichern und erneut anwenden.

Rollbacks

Wenn bei Ihrer Bereitstellung etwas schief geht, ermöglicht Kubernetes Ihnen, auf eine frühere Version zurückzusetzen:

kubectl rollout undo deployment/myapp-deployment

Monitoring and Logging

Monitoring and logging are crucial in production environments. Kubernetes provides several ways to monitor and log your applications:

Metrics-Server

Sie können den Kubernetes Metrics Server bereitstellen, um Ressourcenmetriken von den Kubelets zu sammeln. Dies hilft bei der horizontalen Pod-Autoskalierung.

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Logging

Kubernetes bietet keine integrierte Protokollierung, sondern integriert sich in verschiedene Protokollierungslösungen wie Fluentd, Logstash und Elasticsearch. Sie können diese Tools verwenden, um Protokolle aus Ihren Containern zu aggregieren.

Verwenden kubectl logs

To view logs from a specific pod, you can use:

kubectl logs 

Best Practices

Verwende Ressourcenanforderungen und Begrenzungen

Definieren Sie CPU- und Speicheranforderungen und -limits für Ihre Container, um sicherzustellen, dass Ihre Anwendung reibungslos läuft und die Ressourcenzuweisung optimiert wird:

resources:
  requests:
    memory: "64Mi"
    cpu: "250m"
  limits:
    memory: "128Mi"
    cpu: "500m"

Health Checks implementieren

Implementieren Sie Readiness- und Liveness-Probes, um sicherzustellen, dass Ihre Anwendungen fehlerfrei laufen.

readinessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 5
  periodSeconds: 10

livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 15
  periodSeconds: 20

Namensräume

Organisieren Sie Ihre Kubernetes-Ressourcen mithilfe von Namespaces, insbesondere bei größeren Anwendungen, um Ressourcenkonflikte zu vermeiden und die Ressourcenverwaltung zu erleichtern.

Version Control für Ihre Kubernetes-ManifestsKubernetes-Manifests sind YAML-Dateien, die die gewünschten Zustände von Kubernetes-Ressourcen wie Pods, Services und Deployments definieren. Die Verwaltung dieser Manifests in einem Versionskontrollsystem wie Git ist entscheidend für die Zusammenarbeit, Nachverfolgung und Wiederherstellung von Änderungen. Hier sind einige bewährte Verfahren für die Versionskontrolle Ihrer Kubernetes-Manifests:1. Verwenden Sie Git für die Versionskontrolle: - Erstellen Sie ein Git-Repository für Ihre Kubernetes-Manifests. - Committen Sie Ihre Manifests regelmäßig mit aussagekräftigen Commit-Nachrichten.2. Organisieren Sie Ihre Manifests: - Strukturieren Sie Ihre Manifests in Verzeichnissen basierend auf ihrer Funktion oder Umgebung (z. B. dev, staging, prod). - Verwenden Sie beschreibende Dateinamen für Ihre Manifests.3. Nutzen Sie Git-Features: - Verwenden Sie Branches für die Entwicklung und das Testen neuer Funktionen. - Nutzen Sie Pull Requests für Code-Reviews und Zusammenarbeit. - Verwenden Sie Tags, um wichtige Versionen oder Releases zu markieren.4. Automatisieren Sie die Bereitstellung: - Integrieren Sie Ihre Git-Repository mit einem CI/CD-Pipeline, um die Bereitstellung von Manifests in Kubernetes-Clustern zu automatisieren. - Verwenden Sie GitOps-Praktiken, um den gewünschten Zustand Ihres Clusters mit dem Zustand in Ihrem Git-Repository zu synchronisieren.5. Sichern Sie sensible Informationen: - Verwenden Sie keine sensiblen Informationen wie Passwörter oder API-Schlüssel direkt in Ihren Manifests. - Nutzen Sie Kubernetes Secrets oder externe Geheimnisverwaltungstools, um sensible Informationen sicher zu speichern und abzurufen.6. Dokumentieren Sie Ihre Manifests: - Fügen Sie Kommentare und Dokumentation zu Ihren Manifests hinzu, um deren Zweck und Konfiguration zu erklären. - Verwenden Sie ein README-Datei in Ihrem Git-Repository, um Anweisungen zur Bereitstellung und Verwaltung Ihrer Manifests bereitzustellen.Indem Sie diese bewährten Verfahren befolgen, können Sie Ihre Kubernetes-Manifests effektiv versionieren und verwalten, was zu einer besseren Zusammenarbeit, Nachverfolgung und Wiederherstellung von Änderungen führt.

Speichern Sie Ihre Kubernetes-Manifeste in einem Versionskontrollsystem (wie Git), um die Zusammenarbeit und Nachverfolgung von Änderungen zu erleichtern.

Fazit

Das Ausführen von Docker-Containern in Kubernetes bietet eine robuste Lösung für die Verwaltung von containerisierten Anwendungen im großen Stil. Mit Funktionen wie Selbstheilung, Skalierung und Service-Discovery bietet Kubernetes eine leistungsstarke Plattform für die Bereitstellung und Verwaltung Ihrer Anwendungen. Indem Sie die in diesem Artikel beschriebenen Best Practices befolgen, können Sie effiziente, skalierbare und wartbare Bereitstellungen in Kubernetes erstellen. Während Sie Ihre Reise mit Kubernetes fortsetzen, sollten Sie zusätzliche Tools und Integrationen in Betracht ziehen, die Ihre Container-Orchestrierungsfähigkeiten weiter verbessern können.