Java-Bereitstellung auf Kubernetes: Ein grundlegender Leitfaden für Anfänger

Java-Bereitstellung auf Kubernetes: Ein grundlegender Leitfaden für Anfänger

Moderne Java-Entwicklung ist ohne Containerisierung und Orchestrierung undenkbar. Kubernetes (K8s) ist zum De-facto-Standard für die Verwaltung containerisierter Anwendungen geworden. In diesem Leitfaden werden wir Schritt für Schritt den Prozess der Bereitstellung einer einfachen Java-Anwendung auf einem Kubernetes-Cluster durchgehen. Sie erfahren, wie Sie den Code in ein Docker-Image packen, die erforderlichen Manifeste erstellen und die Anwendung in einer produktionsähnlichen Umgebung starten.

1. Vorbereitung der Java-Anwendung und des Docker-Images

Beginnen wir mit einer einfachen Spring Boot-Anwendung. Erstellen Sie eine Datei Dockerfile im Stammverzeichnis des Projekts:

FROM openjdk:17-jdk-alpine\nWORKDIR /app\nCOPY target/my-app.jar app.jar\nEXPOSE 8080\nENTRYPOINT ["java", "-jar", "app.jar"]

Erstellen Sie das Image und senden Sie es an eine Registry (z. B. Docker Hub):

mvn clean package -DskipTests\ndocker build -t myregistry/my-java-app:v1 .\ndocker push myregistry/my-java-app:v1

Stellen Sie sicher, dass das Image lokal funktioniert:

docker run -p 8080:8080 myregistry/my-java-app:v1

2. Wichtige Kubernetes-Objekte

Für die Bereitstellung einer Java-Anwendung benötigen wir drei wichtige Ressourcen:

\n
• Deployment — verwaltet Replikate und Updates
\n
• Service — stellt den Netzwerkzugriff auf die Pods sicher
\n
• Ingress — (optional) Routing des externen Datenverkehrs
\n

Erstellen des Deployments (deployment.yaml)

apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: java-app-deployment\nspec:\n  replicas: 3\n  selector:\n    matchLabels:\n      app: java-app\n  template:\n    metadata:\n      labels:\n        app: java-app\n    spec:\n      containers:\n      - name: java-app\n        image: myregistry/my-java-app:v1\n        ports:\n        - containerPort: 8080\n        resources:\n          requests:\n            memory: "256Mi"\n            cpu: "250m"\n          limits:\n            memory: "512Mi"\n            cpu: "500m"\n        livenessProbe:\n          httpGet:\n            path: /actuator/health\n            port: 8080\n          initialDelaySeconds: 30\n          periodSeconds: 10\n        readinessProbe:\n          httpGet:\n            path: /actuator/health\n            port: 8080\n          initialDelaySeconds: 20\n          periodSeconds: 5

Erstellen des Services (service.yaml)

apiVersion: v1\nkind: Service\nmetadata:\n  name: java-app-service\nspec:\n  selector:\n    app: java-app\n  ports:\n  - protocol: TCP\n    port: 80\n    targetPort: 8080\n  type: ClusterIP

3. Bereitstellung auf dem Kubernetes-Cluster

Wenden Sie die Manifeste auf Ihren Cluster an (stellen Sie sicher, dass kubectl konfiguriert ist):

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

Überprüfen Sie den Status der Pods und des Services:

kubectl get pods\nkubectl get svc java-app-service

Für den externen Zugriff (z. B. zum Testen) verwenden Sie port-forward:

kubectl port-forward service/java-app-service 8080:80

Die Anwendung ist nun unter http://localhost:8080 erreichbar.

4. Skalierung und Aktualisierung

Kubernetes ermöglicht eine einfache Skalierung der Anwendung:

kubectl scale deployment java-app-deployment --replicas=5

Um das Image zu aktualisieren (Rolling Update), ändern Sie den Tag im Deployment und wenden Sie es an:

kubectl set image deployment/java-app-deployment java-app=myregistry/my-java-app:v2\nkubectl rollout status deployment/java-app-deployment

Falls nötig, machen Sie die Änderungen rückgängig:

kubectl rollout undo deployment/java-app-deployment

Fazit

Wir haben den grundlegenden Prozess der Bereitstellung einer Java-Anwendung auf Kubernetes betrachtet.