Tworzenie pierwszego projektu Kotlin z Gradle dla Cloud Run

· 360 słów · do przeczytania, w minut 2

Wprowadzenie

W poprzednim wpisie omówiłem architekturę Cloud Run i sposób działania tej platformy. Dziś czas przejść do praktyki: zbudujemy od podstaw prostą aplikację w Kotlinie, która wystawia endpoint HTTP i przygotujemy ją do uruchomienia na Cloud Run.

Minimalny projekt w Kotlinie

Aplikację stworzymy bez Springa oraz innych frameworków – tylko ktor, Gradle i czysty Kotlin.

Struktura projektu:

cloud-run-ktor-hello/
├── build.gradle.kts
├── settings.gradle.kts
├── src/
│   └── main/
│       └── kotlin/
│           └── com.zamolski.crkhello/
│               └── Main.kt
└── Dockerfile

Konfiguracja Gradle

settings.gradle.kts

rootProject.name = "cloud-run-ktor-hello"

build.gradle.kts

plugins {
    kotlin("jvm") version "2.1.10"
    application
}

application {
    mainClass.set("com.zamolski.crkhello.MainKt")
}

kotlin {
    jvmToolchain(21)
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("io.ktor:ktor-server-core:3.2.0")
    implementation("io.ktor:ktor-server-netty:3.2.0")
    implementation("org.slf4j:slf4j-simple:2.0.17")
}

Kod aplikacji

src/main/kotlin/com/zamolski/crkhello/Main.kt

package com.zamolski.crkhello

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

fun main() {
    val port = System.getenv("PORT")?.toIntOrNull() ?: 8080

    embeddedServer(Netty, port = port) {
        routing {
            get("/") {
                call.respondText("Hello from Cloud Run! [docker]")
            }
        }
    }.start(wait = true)
}

Budowanie i uruchamianie lokalnie

./gradlew ktor-jib:run

Otwórz w przeglądarce: http://localhost:8080

Dockerfile dla Cloud Run

FROM gradle:8.14.2-jdk21 AS build
COPY --chown=gradle:gradle . /app
WORKDIR /app
RUN gradle installDist

FROM eclipse-temurin:21-jre
COPY --from=build /app/build/install/ktor-docker /app
EXPOSE 8080
CMD ["/app/bin/ktor-docker"]

Aby zbudować i uruchomić obraz zbudowany wg powyższej instrukcji, należy wykonać następującą sekwencję poleceń:

./gradlew ktor-docker:build
cd ktor-docker
docker build -t cloud-run-ktor-hello .
docker run -p 8080:8080 cloud-run-ktor-hello

Gotowe do wdrożenia

Po zbudowaniu obrazu możesz wdrożyć go do Cloud Run:

cd ktor-docker
gcloud run deploy cloud-run-ktor-hello \
  --source . \
  --region europe-central2 \
  --allow-unauthenticated

Lub z użyciem Jib + Cloud Build – o tym opowiem w przyszłym wpisie.

Co dalej?

W kolejnym wpisie:

  • zbudujemy obraz aplikacji z użyciem Jib (bez Dockera)

  • i wdrożymy ją do Cloud Run za pomocą gcloud run deploy.

Repozytorium: https://github.com/mariuszz/cloud-run-ktor-hello

Linki

Inne artykuły z serii

  1. Wprowadzenie

  1. Dlaczego warto interesować się Cloud Run i językiem Kotlin?

  2. Co to jest Cloud Run i jak działa pod maską?

  1. Pierwsze wdrożenie

  1. Tworzenie pierwszego projektu Kotlin z Gradle dla Cloud Run

  2. Budowanie obrazów kontenerowych dla kotlin + ktor bez Dockera z użyciem Jib i Cloud Build

  3. Profesjonalny workflow CI/CD dla aplikacji Kotlin + Ktor z użyciem Cloud Build i GitHub

  4. Logowanie w Ktor i podgląd logów w GCP Cloud Logging

gcp cloud run kotlin serverless ktor gradle