Kubernetes for Java Developers: The Ultimate Quarkus + Minikube Quick Reference

A fast, practical cheat sheet that accelerates your Kubernetes learning curve with real Quarkus and Minikube examples.

Kubernetes is one of those technologies every modern Java developer eventually touches, even if they never asked for it. It powers the platforms we deploy to. It shapes how we package services. It defines how our applications scale, recover, and communicate. And yet, for day-to-day development, Kubernetes often slows you down. The feedback loop becomes longer. The amount of YAML grows. Debugging feels distant compared to running a Quarkus app locally.

Still, the concepts matter. Understanding pods, services, deployments, health checks, and resource management changes how you design applications. The moment you grasp these fundamentals, Quarkus starts to shine because it gives you the right abstractions and build-time automation to work with Kubernetes instead of fighting it.

This is why I keep coming back to Minikube. It is small, predictable, and self-contained. It behaves like a real Kubernetes cluster without the operational overhead. It gives Java developers a safe place to experiment with Kubernetes concepts, test Quarkus deployments, and build confidence before touching production environments. And Minikube’s built-in dashboard creates a visual understanding that pure CLI workflows often miss.

This quick reference card exists for one purpose. To remove friction. To give you the exact commands, configuration snippets, and workflows you need to build, deploy, inspect, and debug Quarkus applications on Kubernetes. It is not a full guide. It is the cheat sheet you reach for when you just want things to work.

Start Minikube the Right Way

Configure Podman with enough resources:

podman machine stop
podman machine rm
podman machine init --cpus 4 --memory 8192 --rootful
podman machine start

Start Minikube:

minikube start --driver=podman --container-runtime=containerd --cpus=4 --memory=7909

Open the Minikube dashboard:

minikube dashboard

Create a Minimal Quarkus Project Ready for Kubernetes

quarkus create app org.acme:k8s-quickref \
  --extension="rest,kubernetes,container-image-podman,health,metrics" \
  --no-code
cd k8s-quickref

Add a tiny REST endpoint:

package com.example;

import jakarta.ws.rs.Produces;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.core.MediaType;

@Path(”/”)
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return “Hello from Quarkus on Minikube”;
    }

}

Add the image configuration and some more to your application.properties

# 1. The “Group” 
quarkus.container-image.group=demo

# 2. The “Name” 
quarkus.container-image.name=quickref

# 3. Naming the Deployment 
quarkus.kubernetes.name=quickref

# 4. The “Tag” 
quarkus.container-image.tag=v1

# 5. Ensure we don’t try to push to a real registry
quarkus.container-image.push=false

# 6. Let’s make sure we load the image from the local registry and don’t have minikube pull it
quarkus.kubernetes.image-pull-policy=IfNotPresent

# 7. Health endpoint
quarkus.smallrye-health.root-path=/health

quarkus.kubernetes.resources.requests.memory=256Mi
quarkus.kubernetes.resources.limits.memory=512Mi

Build a Container Image and load it into Minikube

./mvnw clean package -Dquarkus.container-image.build=true -Dquarkus.kubernetes.image-pull-policy=Never

Load the image into Minikube

minikube image load docker.io/demo/quickref:v1

Deploy to Kubernetes (auto-generated manifests)

# The manifest was generated during the packaging phase.
kubectl apply -f target/kubernetes/kubernetes.yml

(You can also just use 'quarkus deploy' which is the equivalent)

Watch it roll out:

kubectl rollout status deployment.apps/quickref

Expose Your App

kubectl port-forward service/quickref 8080:80

Test (in a new terminal):

curl http://localhost:8080/hello

See the Quarkus Logs

kubectl logs deployment.apps/quickref

Health (Quarkus Native Support)

Check:

curl http://localhost:8080/q/health

Resource Limits

Add to application.properties:

quarkus.kubernetes.resources.requests.memory=256Mi
quarkus.kubernetes.resources.limits.memory=512Mi

Reapply:

./mvnw quarkus:kubernetes
kubectl apply -f target/kubernetes/kubernetes.yml

Quick Commands Every Java Dev Needs

Pods

kubectl get pods
kubectl logs -f <pod>
kubectl exec -it <pod> -- sh
kubectl describe pod <pod>

Deployments

kubectl get deployments
kubectl rollout restart deployment.apps/quickref
kubectl delete deployment quickref

Services

kubectl get svc
kubectl describe svc quickref

Namespaces

kubectl get ns
kubectl create ns dev
kubectl config set-context --current --namespace=dev

ConfigMaps & Secrets: Minimal Examples

ConfigMap

kubectl create configmap app-config \
  --from-literal=message="Hello ConfigMap"

Inject into Quarkus (via the application properties):

# 1. Map a specific key to a specific env var
quarkus.kubernetes.env-vars.message.value-from.configmap-key=app-config:message

# OR, inject EVERYTHING in the ConfigMap as env vars (Easier)
quarkus.kubernetes.env.configmaps=app-config

And access via:

import org.eclipse.microprofile.config.inject.ConfigProperty;

// ... inside your class
@ConfigProperty(name = "message", defaultValue = "Hello Localhost")
String message;

Secret

kubectl create secret generic app-secret \
  --from-literal=password=supersecret

Use in application.properties:

# Inject all values from ‘app-secret’ as Environment Variables
quarkus.kubernetes.env.secrets=app-secret

# Use for a specific key
quarkus.kubernetes.env-vars.db-password.secret=app-secret

Base64 is NOT Encryption!

If you run kubectl get secret app-secret -o yaml, you will see something like: password: c3VwZXJzZWNyZXQ=

Anyone who can type that command can decode your password (echo c3VwZXJzZWNyZXQ= | base64 -D).

Fastest Dev Loop: Quarkus Dev + Minikube

# Local development, no Kubernetes yet
./mvnw quarkus:dev

When ready to test on-cluster:

./mvnw quarkus:kubernetes
kubectl apply -f target/kubernetes/kubernetes.yml

Ingress (Minimal Example)

minikube addons enable ingress

Mapp an ingress for your Quarkus app in application.properties:

# 1. Generate an Ingress resource
quarkus.kubernetes.ingress.expose=true

# 2. Define the hostname you want to use
quarkus.kubernetes.ingress.host=quickref.local

# 3. (Optional) Explicitly set the target path
quarkus.kubernetes.ingress.path=/

Apply:

quarkus deploy

On macOS, the Ingress controller gets isolated inside the Podman VM. You must run a tunnel to expose it to your Mac’s localhost.

Open a new terminal (keep this running) and run:

minikube tunnel

Test:

curl -H “Host: quarkus.local” http://$(minikube ip)

Fast Cleanup

kubectl delete all --all
minikube delete

✔️ Quarkus. K8. Short. Fast. Practical.