Application development and deployment on Kubernetes can be a very lengthy and complex process. A tool has been developed as TILT to make the workflow easy by providing a rapid feedback loop to the developers. In this blog post, we are going to walk you through using TILT with a Spring Boot application to make it easy to speed up your development.

What is TILT?

Tilt is an open-source tool for making application deployment to Kubernetes easier for developers. In this case, the build, deploy, and feedback loop are all automated so you see the effect of your code changes almost in an instant. With Tilt, you can:

Run your application on Kubernetes: Tilt manages the process of deployment, so you don't have to manually build and push Docker images or apply Kubernetes manifests.
You get real-time feedback: TILT lets you have a single view of your application's status and logs, making it easier to spot problems and fix them quickly.
Your workflow is optimized: TILT can be configured to automatically rebuild and redeploy your application every time you change your code.

Installing TILT

We will install TILT on your development machine before we proceed to configure TILT with a Spring Boot application.
Step 1: Install TILT
Installing with:
Homebrew (macOS/Linux):
brew install tilt-dev/tap/tilt

Scoop (Windows):
scoop install tilt

Direct Download: Visit the TILT installation page and download the appropriate binary for your OS. Then, follow the instructions to add TILT into PATH.

Step 2: Installation Confirmation

After having successfully installed TILT, you should confirm the installation by running:
tilt version
You must see the version information of TILT. It's an indication that you successfully installed TILT.

Setting up TILT with Spring Boot

Let's go through the process of setting up TILT using a simple Spring Boot application.

Step 1: Create a Spring Boot Application
Create a basic Spring Boot application. You may use Spring Initializr to generate a new project with all the required dependencies.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class, args);
}
}

Step 2: Dockerize Your Application
Next, create a Dockerfile to build a Docker image for your Spring Boot application.

# Use an official OpenJDK runtime as a parent image
FROM openjdk:11-jre-slim

# Set the working directory
WORKDIR /app

# Copy the application JAR file
COPY target/demo-0.0.1-SNAPSHOT.jar app.jar

# Run the application
ENTRYPOINT ["java", "-jar", "app.jar"]

Step 3: Create Kubernetes Manifests
Create a Kubernetes deployment and service manifest for your application.

# kubernetes.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: demo
  template:
    metadata:
      labels:
        app: demo
    spec:
      containers:
      - name: demo
        image: demo:latest
        ports:
        - containerPort: 8080

---
apiVersion: v1
kind: Service
metadata:
  name: demo
spec:
  selector:
    app: demo
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

Step 4: Configure TILT
Create a Tiltfile to configure TILT for your project.

Python

# Tiltfile
docker_build('demo', '.')
k8s_yaml('kubernetes.yaml')
k8s_resource('demo', port_forwards=8080)

Step 5: Run TILT
With everything set up, you can now run TILT to start your development workflow.

tilt up 

TILT will build your Docker image, deploy your application to Kubernetes, and provide a real-time view of your application’s status and logs. You can access your application at localhost:8080.

Conclusion

Using TILT with a Spring Boot application can significantly improve your development workflow by providing fast feedback and simplifying the deployment process. By following the steps outlined in this blog post, you can set up TILT to manage your Spring Boot application’s lifecycle on Kubernetes, allowing you to focus on writing code and delivering features.