Deployment von Kotlin auf Kubernetes: Grundlagenleitfaden

Deploy von Kotlin auf Kubernetes: Grundlegendes Handbuch

Moderne Entwicklung ist ohne Containerisierung und Orchestrierung nicht denkbar. Kubernetes (K8s) ist zum Standard für die Verwaltung von Microservices geworden, und Kotlin zu einer der beliebtesten Sprachen für die Erstellung zuverlässiger Backend-Anwendungen. In diesem Handbuch gehen wir den Weg von einer einfachen Kotlin-Anwendung bis zu ihrer vollständigen Bereitstellung in einem Kubernetes-Cluster. Sie erfahren, wie Sie Code in ein Docker-Image packen, Manifeste schreiben und den Zugriff auf den Dienst konfigurieren.

1. Vorbereitung der Kotlin-Anwendung

Als Beispiel nehmen wir eine einfache REST API mit Ktor – einem leichten Framework für Kotlin. Erstellen wir die Datei Main.kt:

import io.ktor.server.engine.*import io.ktor.server.netty.*import io.ktor.server.routing.*import io.ktor.http.*import io.ktor.server.response.*

fun main() {    embeddedServer(Netty, port = 8080) {        routing {            get("/") {                call.respondText("Hello from Kotlin on K8s!", ContentType.Text.Plain)            }            get("/health") {                call.respondText("OK", ContentType.Text.Plain)            }        }    }.start(wait = true)}

Dieser Code startet einen Server auf Port 8080 mit zwei Endpunkten: dem Root-Endpunkt und dem Health Check. Stellen Sie sicher, dass in der build.gradle.kts die Abhängigkeiten für Ktor und Netty eingebunden sind.

2. Erstellung des Docker-Images

Für das Deployment in Kubernetes muss die Anwendung in einen Container verpackt werden. Erstellen wir ein Dockerfile im Projektstammverzeichnis:

FROM gradle:8.5-jdk21 AS buildWORKDIR /appCOPY build.gradle.kts settings.gradle.kts ./COPY src ./srcRUN gradle build --no-daemon

FROM openjdk:21-jdk-slimWORKDIR /appCOPY --from=build /app/build/libs/*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

Der Build erfolgt in zwei Phasen: zuerst die Kompilierung mit Gradle, dann das Kopieren der JAR-Datei in ein sauberes Image. Bauen Sie das Image mit dem Befehl:

docker build -t my-kotlin-app:1.0 .

Für die Veröffentlichung in einer Registry (z. B. Docker Hub) führen Sie aus:

docker tag my-kotlin-app:1.0 yourusername/my-kotlin-app:1.0docker push yourusername/my-kotlin-app:1.0

3. Kubernetes-Manifeste

Jetzt erstellen wir YAML-Dateien für das Deployment im Cluster. Beginnen wir mit deployment.yaml:

apiVersion: apps/v1kind: Deploymentmetadata:  name: kotlin-appspec:  replicas: 2  selector:    matchLabels:      app: kotlin-app  template:    metadata:      labels:        app: kotlin-app    spec:      containers:      - name: kotlin-app        image: yourusername/my-kotlin-app:1.0        ports:        - containerPort: 8080        livenessProbe:          httpGet:            path: /health            port: 8080          initialDelaySeconds: 5          periodSeconds: 10        readinessProbe:          httpGet:            path: /health            port: 8080          initialDelaySeconds: 3          periodSeconds: 5

Dieses Manifest erstellt zwei Replikate der Anwendung und fügt Liveness- und Readiness-Probes hinzu. Als nächstes service.yaml:

apiVersion: v1kind: Servicemetadata:  name: kotlin-app-svcspec:  selector:    app: kotlin-app  ports:  - port: 80    targetPort: 8080  type: ClusterIP

Der Service leitet Traffic von Port 80 an Port 8080 des Containers weiter. Wenn externer Zugriff benötigt wird, ändern Sie den Typ auf NodePort oder LoadBalancer.

4. Ingress-Konfiguration und Deployment

Für das Routing von Anfragen von außen verwenden wir einen Ingress-Controller. Erstellen Sie ingress.yaml:

apiVersion: networking.k8s.io/v1kind: Ingressmetadata:  name: kotlin-app-ingress  annotations:    nginx.ingress.kubernetes.io/rewrite-target: /spec:  rules:  - host: kotlin.example.com    http: