Bereitstellung einer Kotlin-Anwendung auf Kubernetes: Ein grundlegender Leitfaden

Kotlin auf Kubernetes bereitstellen: Ein grundlegender praktischer Leitfaden

Kubernetes (K8s) ist zum Standard für die Orchestrierung containerisierter Anwendungen geworden. Wenn Sie serverseitige Anwendungen in Kotlin entwickeln (mit Ktor, Spring Boot oder http4k), stellt sich früher oder später die Frage nach deren Bereitstellung in einem Cluster. In diesem Leitfaden gehen wir den Weg vom Verpacken einer Kotlin-Anwendung in ein Docker-Image bis hin zum Ausführen in Kubernetes mit ConfigMap und Ingress. Alle Beispiele sind funktionsfähig und bereit zur Anpassung.

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

Als Beispiel nehmen wir eine einfache Anwendung mit Ktor (kann durch jedes andere Framework ersetzt werden). Unsere Anwendung lauscht auf Port 8080 und gibt JSON mit einer Version zurück.

// src/main/kotlin/com/example/Application.ktimport io.ktor.server.engine.*import io.ktor.server.netty.*import io.ktor.server.routing.*import io.ktor.server.response.*

fun main() {    embeddedServer(Netty, port = 8080) {        routing {            get("/") {                call.respond(mapOf("app" to "kotlin-on-k8s", "version" to "1.0.0"))            }        }    }.start(wait = true)}

Wir bauen die Anwendung mit Gradle (Plugin shadow) in ein fat JAR. Nach dem Bau erstellen wir ein Dockerfile:

# DockerfileFROM openjdk:17-jdk-slimWORKDIR /appCOPY build/libs/app-all.jar app.jarEXPOSE 8080CMD ["java", "-jar", "app.jar"]

Wir bauen das Image und pushen es in eine Registry (z.B. Docker Hub):

docker build -t youruser/kotlin-app:1.0.0 .docker push youruser/kotlin-app:1.0.0

2. Erstellung von Kubernetes-Manifesten

Jetzt beschreiben wir die Ressourcen für die Bereitstellung. Wir erstellen drei Dateien: deployment.yaml, service.yaml und configmap.yaml.

2.1. ConfigMap für die Konfiguration

Wir lagern die Anwendungseinstellungen (z.B. Log-Level oder Verbindungszeichenfolge) in eine ConfigMap aus:

# configmap.yamlapiVersion: v1kind: ConfigMapmetadata:  name: app-configdata:  LOG_LEVEL: "DEBUG"  APP_MODE: "production"

2.2. Deployment

Im Deployment-Manifest geben wir das Image, den Port, die Replikate an und leiten die Variablen aus der ConfigMap weiter:

# deployment.yamlapiVersion: apps/v1kind: Deploymentmetadata:  name: kotlin-appspec:  replicas: 2  selector:    matchLabels:      app: kotlin-app  template:    metadata:      labels:        app: kotlin-app    spec:      containers:        - name: app          image: youruser/kotlin-app:1.0.0          ports:            - containerPort: 8080          envFrom:            - configMapRef:                name: app-config          livenessProbe:            httpGet:              path: /              port: 8080            initialDelaySeconds: 10            periodSeconds: 5

2.3. Service

Der Service verteilt den Datenverkehr auf die Pods:

# service.yamlapiVersion: v1kind: Servicemetadata:  name: kotlin-app-servicespec:  selector:    app: kotlin-app  ports:    - protocol: TCP      port: 80      targetPort: 8080  type: ClusterIP

3. Bereitstellung im Cluster und Konfiguration von Ingress

Wir wenden die Manifeste an:

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

Wir überprüfen, ob die Pods laufen:

kubectl get podskubectl logs <pod-name>

Jetzt machen wir die Anwendung von außen zugänglich. Wir erstellen einen Ingress (vorausgesetzt, im Cluster ist ein Ingress Controller installiert, z.B. NGINX):

# ingress.yamlapiVersion: networking.k8s.io/v1kind: Ingressmetadata:  name: kotlin-app-ingressspec:  rules:    - host: kotlin.example.com      http:        paths: