In this guide we create and deploy a Spring Boot web server.
To run this example, follow these steps:
Install the kraft
CLI tool and a container runtime engine, e.g. Docker.
Clone the examples
repository and cd
into the examples/java17-springboot3.2.x/
directory:
git clone https://github.com/kraftcloud/examples
cd examples/java17-springboot3.2.x/
Make sure to log into KraftCloud by setting your token and a metro close to you.
We use fra0
(Frankfurt, π©πͺ) in this guide:
# Set KraftCloud access token
export KRAFTCLOUD_TOKEN = token
# Set metro to Frankfurt, DE
export KRAFTCLOUD_METRO = fra0
When done, invoke the following command to deploy this application on KraftCloud:
kraft cloud deploy -M 1024 -p 443 :8080 .
The output shows the instance URL and other details:
[ β ] Deployed successfully!
β
β ββββββββββ name : java17-springboot32x-qseeo
β ββββββββββ uuid : b081166d-a2a0-43af-982d-1aa17f06b5c4
β βββββββββ state : running
β βββββββββββ url : https://long-dust-si7xsngk.fra0.kraft.host
β βββββββββ image : java17-springboot32x@sha256:cc2f2ad18ce8e36b8e8f4debee096fef7b0bb8b47762575a2ba5a9de8199c64a
β βββββ boot time : 153.97 ms
β ββββββββ memory : 1024 MiB
β β service group : long-dust-si7xsngk
β ββ private fqdn : java17-springboot32x-qseeo.internal
β ββββ private ip : 172.16.6.2
β ββββββββββ args : /usr/lib/jvm/java-17-openjdk-amd64/bin/java -jar /usr/src/demo-0.0.1-SNAPSHOT.jar
In this case, the instance name is java17-springboot32x-qseeo
and the URL is https://long-dust-si7xsngk.fra0.kraft.host
.
They are different for each run.
Use curl
to querythe Spring Boot serverβs hello
endpoint:
curl https://long-dust-si7xsngk.fra0.kraft.host/hello
When done, you can remove the instance:
kraft cloud instance remove
Customize your Application
To customize the application, update the files in the repository, listed below:
DemoApplication.java
: the server
Kraftfile
: the KraftCloud specification
Dockerfile
: the Docker-specified application filesystem
package com.example.demo ;
import org.springframework.boot.SpringApplication ;
import org.springframework.boot.autoconfigure.SpringBootApplication ;
import org.springframework.web.bind.annotation.GetMapping ;
import org.springframework.web.bind.annotation.RequestParam ;
import org.springframework.web.bind.annotation.RestController ;
@ SpringBootApplication
@ RestController
public class DemoApplication {
public static void main ( String [] args ) {
SpringApplication . run ( DemoApplication . class , args ) ;
}
@ GetMapping ( " /hello " )
public String hello ( @ RequestParam ( value = " name " , defaultValue = " World " ) String name ) {
return String . format ( " Hello %s! " , name ) ;
}
}
spec : v0.6
runtime : java:17
rootfs : ./Dockerfile
cmd : [ " /usr/lib/jvm/java-17-openjdk-amd64/bin/java " , " -jar " , " /usr/src/demo-0.0.1-SNAPSHOT.jar " ]
FROM --platform=linux/x86_64 debian:bookworm AS build
RUN set -xe ; \
apt -yqq update ; \
apt -yqq install default-jre default-jdk curl unzip ;
RUN ldconfig /usr/lib/jvm/java-17-openjdk-amd64/lib/
WORKDIR /src
RUN set -xe ; \
curl -G https://start.spring.io/starter.zip \
-d applicationName=DemoApplication \
-d artifactId=demo \
-d bootVersion=3.2.2 \
-d dependencies=web \
-d description=com.example \
-d javaVersion=17 \
-d language=java \
-d name=demo \
-d packageName=com.example.demo \
-d packaging=jar \
-d type=maven-project \
-d version=0.0.1-SNAPSHOT \
-o demo.zip ; \
unzip demo.zip \
;
COPY DemoApplication.java src/main/java/com/example/demo/
RUN set -xe ; \
./mvnw compile package install
RUN set -xe ; \
mkdir /tmpdir
FROM scratch
COPY --from=build /tmpdir /tmp
COPY --from=build /src/target/demo-0.0.1-SNAPSHOT.jar /usr/src/demo-0.0.1-SNAPSHOT.jar
Lines in the Kraftfile
have the following roles:
spec: v0.6
: The current Kraftfile
specification version is 0.6
.
runtime: java:17
: The Unikraft runtime kernel to use is Java.
rootfs: ./Dockerfile
: Build the application root filesystem using the Dockerfile
.
cmd: ["/usr/lib/jvm/java-17-openjdk-amd64/bin/java", "-jar", "/usr/src/demo-0.0.1-SNAPSHOT.jar"]
: Use as the starting command of the instance.
Lines in the Dockerfile
have the following roles:
FROM scratch
: Build the filesystem from the scratch
container image , to create a base image .
COPY DemoApplication.java src/main/java/com/example/demo/
: Copy the server implementation file in the Docker filesystem.
The following options are available for customizing the application:
If only updating the implementation in the DemoApplication.java
source file, no other change is required.
If new files are added, these have to be copied in the application filesystem, using the COPY
command in the Dockerfile
.
If a new Java source files is added, update the cmd
line in the Kraftfile
and replace DemoApplication.java
to run that file when creating the instance.
More extensive changes may require expanding the Dockerfile
with additional Dockerfile
commands .
Learn More
Use the --help
option for detailed information on using KraftCloud:
Or visit the CLI Reference .