- Published on
Creating Google Cloud Functions With Kotlin
- Authors
- Name
- Michael Whyte
- @mwhyte_dev
In May 2020, Google announced that Java 11 was coming to Google Cloud Functions. Naturally, my first thought was “Excellent, but can I write functions in other JVM-based languages like Kotlin?”
Thankfully, there is no such limitation. In fact, you can write your functions in any JVM language of your choosing.
The source code for this example can be found on GitHub:
github.com/mwhyte-dev/kotlin-google-cloud-function
Prerequisites
You’ll need some things to follow along with this example:
Java 11
Gradle
Access to GCP with a sample project created
gcloud installed and authenticated
The source code cloned and imported into your IDE of choice
Main Function
The main function is a straightforward one to get us started — a basic HTTP endpoint that will return the string “FUNCTION COMPLETE” when triggered:
package dev.mwhyte.function
import com.google.cloud.functions.HttpFunction
import com.google.cloud.functions.HttpRequest
import com.google.cloud.functions.HttpResponse
import mu.KotlinLogging
import java.io.IOException
class App : HttpFunction {
private val logger = KotlinLogging.logger {}
@Throws(IOException::class)
override fun service(request: HttpRequest, response: HttpResponse) {
logger.info { "hello world" }
response.writer.write("FUNCTION COMPLETE")
}
}
This class extends HttpFunction
from the functions-framework library, and the service function takes an HttpRequest
and a HttpResponse
object as parameters.
For non-HTTP ways to trigger a cloud function, you can use a RawBackgroundFunction
or a typed variant.
For example: BackgroundFunction<PubSubMessage>
Some other options for triggering functions include Cloud Pub/Sub, Cloud Storage, Cloud Firestore, and various Firebase-based triggers.
You can find examples of other triggering mechanisms in the functions-framework-java readme.
Gradle Build File
For this example, we are using Gradle’s Kotlin DSL to configure our project.
import java.lang.invoke.MethodHandles.invoker
val invoker by configurations.creating
plugins {
id("org.jetbrains.kotlin.jvm") version "1.3.72"
id("com.github.johnrengelman.shadow") version "6.0.0"
application
}
repositories {
jcenter()
}
dependencies {
implementation(platform("org.jetbrains.kotlin:kotlin-bom"))
implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
implementation("io.github.microutils:kotlin-logging:1.11.5")
implementation("com.google.cloud.functions:functions-framework-api:1.0.1")
invoker("com.google.cloud.functions.invoker:java-function-invoker:1.0.0-alpha-2-rc5")
testImplementation("org.jetbrains.kotlin:kotlin-test")
testImplementation("org.jetbrains.kotlin:kotlin-test-junit")
testImplementation("org.mockito:mockito-core:3.5.10")
testImplementation("com.google.truth:truth:1.0.1")
testImplementation("com.google.guava:guava-testlib:29.0-jre")
}
application {
mainClassName = "dev.mwhyte.function.AppKt"
}
task<JavaExec>("runFunction") {
main = "com.google.cloud.functions.invoker.runner.Invoker"
classpath(invoker)
inputs.files(configurations.runtimeClasspath, sourceSets["main"].output)
args(
"--target", project.findProperty("runFunction.target") ?: "dev.mwhyte.function.App",
"--port", project.findProperty("runFunction.port") ?: 8080
)
doFirst {
args("--classpath", files(configurations.runtimeClasspath, sourceSets["main"].output).asPath)
}
}
tasks.named("build") {
dependsOn(":shadowJar")
}
task("buildFunction") {
dependsOn("build")
copy {
from("build/libs/" + rootProject.name + "-all.jar")
into("build/deploy")
}
}
Dependencies
There are a few critical dependencies.
Functions-framework-api allows us to write lightweight functions that run in many different environments, including Google Cloud Functions and cloud-run.
Java-function-invoker enables us to run the function locally for testing.
runFunction Task
The runFunction
task in the Gradle build file triggers the java-function-invoker, which wraps the function and serves it using a jetty web server.
To run the function locally, call runFunction using the Gradle wrapper:
❯ ./gradlew runFunction
> Task :runFunction
2021-07-13 20:21:00.608:INFO:oejs.Server:main: jetty-9.4.26.v20200117; built: 2020-01-17T12:35:33.676Z; git: 7b38981d25d14afb4a12ff1f2596756144edf695; jvm 15.0.1+9
2021-07-13 20:21:00.646:INFO:oejsh.ContextHandler:main: Started o.e.j.s.ServletContextHandler@467aecef{/,null,AVAILABLE}
2021-07-13 20:21:00.671:INFO:oejs.AbstractConnector:main: Started ServerConnector@3d24753a{HTTP/1.1,[http/1.1]}{0.0.0.0:8080}
2021-07-13 20:21:00.672:INFO:oejs.Server:main: Started @485ms
Jul 13, 2021 8:21:00 PM com.google.cloud.functions.invoker.runner.Invoker logServerInfo
INFO: Serving function...
Jul 13, 2021 8:21:00 PM com.google.cloud.functions.invoker.runner.Invoker logServerInfo
INFO: Function: dev.mwhyte.function.App
Jul 13, 2021 8:21:00 PM com.google.cloud.functions.invoker.runner.Invoker logServerInfo
INFO: URL: http://localhost:8080/
<==========---> 80% EXECUTING [15s]
> :runFunction
Optionally, you can override some args:
❯ ./gradlew runFunction -PrunFunction.target=dev.mwhyte.function.App -PrunFunction.port=8080
> Task :runFunction
INFO: Function: dev.mwhyte.function.App
Jul 13, 2021 8:24:24 PM com.google.cloud.functions.invoker.runner.Invoker logServerInfo
INFO: URL: http://localhost:8080/
<==========---> 80% EXECUTING [8s]
> :runFunction
buildFunction Task
The buildFunction task in the Gradle build file works with the Gradle Shadow plugin to create a fat jar and copy it to the build/deploy directory ready to be uploaded to GCP Cloud Storage.
To execute this, use the Gradle wrapper:
❯ ./gradlew buildFunction
BUILD SUCCESSFUL in 1s
10 actionable tasks: 10 up-to-date
Deploying With gcloud
So you’ve tested your function locally, you’ve built it, and now it's time to deploy. Deploying can be achieved easily with the gcloud command-line utility.
First, ensure you are deploying to the GCP Project of your choice:
gcloud config get-value project my-functions-project
Then select the region you wish to deploy to :
gcloud config set functions/region europe-west1
Lastly, deploy the function:
❯ gcloud functions deploy my-test-function \
--entry-point=dev.mwhyte.function.App \
--source=build/deploy --runtime=java11 --trigger-http \
--allow-unauthenticated
Deploying function (may take a while - up to 2 minutes)...⠹
Note: The entry-point argument is the fully qualified class name of the function, and the source is the location of our fat jar.
If you open the GCP console and navigate to Cloud Functions, you’ll see the function:
From here, you can open it and view various information, including the trigger. Alternatively, you can run a describe from gcloud:
gcloud functions describe my-test-function
By hitting the trigger URL, you will see the function return the expected response:
❯ curl https://europe-west1-slice-poc.cloudfunctions.net/my-test-function
FUNCTION COMPLETE%
References
We’ve seen just how easy it is to deploy a Kotlin function to GCP. To explore the topic further, I’d recommend the following documentation:
mwhyte-dev/kotlin-google-cloud-function
Cloud Functions documentation | Cloud Functions Documentation
GoogleCloudPlatform/functions-framework-java
Running a function with Gradle & Kotlin (build.gradle.kts) · Issue #35