To containerize a Java application, create a Docker image using a minimal base image like openjdk:17-jre-alpine, copy the pre-built JAR file into the image, expose the required port (e.g., 8080), and define the entry point with java -jar, ensuring the JAR is built outside the Docker build process for efficiency. 2. Deploy the containerized app to Kubernetes by defining a Deployment manifest with desired replicas, container image, resource limits, and environment variables, and pair it with a Service manifest of type LoadBalancer to expose the app externally. 3. Apply best practices such as enabling JVM container support with -XX: UseContainerSupport and setting -Xmx to align with container memory limits, using lightweight or distroless base images, implementing liveness and readiness probes for reliability, and externalizing configuration via ConfigMaps and Secrets. 4. Leverage Kubernetes for scaling and management by manually scaling replicas or using Horizontal Pod Autoscaler based on metrics, and monitor application performance using tools like Prometheus and Grafana to track garbage collection and thread usage, ensuring optimal and resilient operation.

Containerizing Java applications has become a standard practice in modern software development, especially when leveraging Docker for packaging and Kubernetes for orchestration. This approach brings consistency across environments, improves scalability, and simplifies deployment workflows. Here’s how to effectively containerize a Java application using Docker and run it on Kubernetes.

1. Creating a Docker Image for a Java Application

The first step is to package your Java app into a Docker container. Most Java apps are built as JAR files (especially Spring Boot apps), which can be run with java -jar.

Key Steps:

• Use a minimal base image (e.g., OpenJDK with Alpine or Amazon Corretto)
• Copy the built JAR into the image
• Expose the necessary port
• Define the startup command

Example Dockerfile:

# Use a lightweight OpenJDK image
FROM openjdk:17-jre-alpine

# Set working directory
WORKDIR /app

# Copy JAR from host (build process should produce this first)
COPY target/myapp.jar app.jar

# Expose port (e.g., 8080 for Spring Boot)
EXPOSE 8080

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

? Tip: Build your JAR outside the Dockerfile (using Maven/Gradle locally or in CI), then copy it in. This keeps the Docker build fast and avoids installing build tools in the container.

Build the image:

docker build -t my-java-app:1.0 .

Run it:

docker run -p 8080:8080 my-java-app:1.0

2. Deploying to Kubernetes

Once containerized, you can deploy your Java app on a Kubernetes cluster using standard manifests: Deployment and Service.

Example deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-app-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: java-app
  template:
    metadata:
      labels:
        app: java-app
    spec:
      containers:
      - name: java-app
        image: my-java-app:1.0
        ports:
        - containerPort: 8080
        resources:
          limits:
            memory: "512Mi"
            cpu: "500m"
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"

Example service.yaml (to expose the app):

apiVersion: v1
kind: Service
metadata:
  name: java-app-service
spec:
  selector:
    app: java-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

Apply to cluster:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

? Your Java app is now running in Kubernetes with load balancing and basic resource constraints.

3. Best Practices for Java in Containers

Java wasn’t originally designed with containers in mind, so a few tweaks help avoid common pitfalls.

Important Considerations:

• Set memory limits and JVM flags
  The JVM may not respect container memory limits by default. Use flags like:

  ENTRYPOINT ["java", "-XX: UseContainerSupport", "-Xmx400m", "-jar", "app.jar"]

  This enables container-aware memory and CPU detection (available since Java 10 ).

• Use small base images
  Prefer eclipse-temurin:17-jre-alpine or distroless images to reduce attack surface and image size.

• Health checks in Kubernetes
  Add liveness and readiness probes for better reliability:

  livenessProbe:
    httpGet:
      path: /actuator/health
      port: 8080
    initialDelaySeconds: 60
    periodSeconds: 10
  readinessProbe:
    httpGet:
      path: /actuator/health
      port: 8080
    initialDelaySeconds: 30
    periodSeconds: 5

• Externalize configuration
  Use ConfigMaps and Secrets instead of hardcoding values:

  envFrom:
    - configMapRef:
        name: java-app-config
    - secretRef:
        name: java-app-secrets

  ---

  4. Scaling and Managing with Kubernetes

  Kubernetes shines when scaling Java apps based on load.

  • Use kubectl scale deployment java-app-deployment --replicas=5 to scale manually.
  • Set up Horizontal Pod Autoscaler (HPA) based on CPU or custom metrics.
  • Monitor with tools like Prometheus Grafana, especially GC performance and thread usage.

  ---

  Containerizing Java apps with Docker and Kubernetes isn’t complicated, but getting it right means paying attention to JVM behavior in containers, proper resource management, and leveraging Kubernetes features like probes and auto-scaling.

  Basically, build a lean image, run it safely in the JVM, and let Kubernetes handle the rest.

  The above is the detailed content of Containerizing Java Applications with Docker and Kubernetes. For more information, please follow other related articles on the PHP Chinese website!