To successfully deploy scalable Java applications to Kubernetes, the following 7 steps must be followed: 1. Use a streamlined basic image (such as eclipse-temurin:17-jre-alpine) and optimize JAR packages (such as Spring Boot layered JAR) to build efficient Docker images; 2. Write a Deployment YAML that supports horizontal scaling and rolling updates, set reasonable resource requests and restrictions, and configure liveness and readiness probes to deal with slow Java application startup problems; 3. Use ClusterIP Service to achieve internal communication, expose external access through Ingress (such as NGINX or Traefik), and implement TLS encryption with cert-manager; 4. Configure HorizontalPodAutoscaler (HPA) to automatically scale based on CPU and memory usage to ensure that the cluster has metrics-server installed, and use KEDA to support custom metrics scaling if necessary; 5. Use ConfigMap and Secret to externalize configuration and sensitive information, and integrate Vault, AWS Secrets Manager, or External Secrets Operator in the production environment to improve security; 6. Use container-aware features of Java 10 (such as -XX: UseContainerSupport and -XX:MaxRAMPercentage=75.0) to avoid manually setting -Xmx to allow the JVM to automatically adapt to container resource limitations; 7. Integrate monitoring logging tools such as Prometheus, Grafana, Loki or ELK, enable Micrometer metric exposure and distributed tracking (such as Jaeger), and enable service discovery through annotations. Following these practices can ensure that Java applications are flexible, observable and efficient resource utilization in Kubernetes, truly becoming a first-class citizen of cloud native.

Deploying a scalable Java application to Kubernetes isn't just about getting your app running in containers—it's about designing for resilience, performance, and automation from the start. Whether you're using Spring Boot, Quarkus, or another Java framework, the principles remain the same: package smartly, configure externally, scale dynamically, and monitor continuously.

Here's how to do it right.

1. Containerize Your Java Application Properly

Start by creating an efficient Docker image. Avoid using openjdk:latest or fat JARs without optimization.

 # Use a slim base image
FROM eclipse-temurin:17-jre-alpine

# Create app directory
WORKDIR /app

# Copy JAR (prefer layered JARs for faster builds)
COPY target/app.jar app.jar

# Run as non-root user
USER 1001

#Expose port
EXPOSE 8080

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

? Tip : Use Spring Boot's layered JAR feature ( repackage mode) so that only your code (not dependencies) rebuilds on change, speeding up CI/CD.

2. Define Kubernetes Deployments with Scalability in Mind

Your Deployment YAML should allow for horizontal scaling and rolling updates.

 apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-app
spec:
  replicas: 3
  Strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
      maxSurge: 1
  selector:
    matchLabels:
      app: java-app
  template:
    metadata:
      labels:
        app: java-app
    spec:
      containers:
        - name: java-app
          image: your-registry/java-app:1.0
          Ports:
            - containerPort: 8080
          env:
            - name: SPRING_PROFILES_ACTIVE
              value: "k8s"
          resources:
            Requests:
              memory: "512Mi"
              cpu: "250m"
            limits:
              memory: "1Gi"
              cpu: "500m"
          livenessProbe:
            httpGet:
              path: /actuator/health
              port: 8080
            initialDelaySeconds: 60
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /actuator/health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 5

? Key points:

• Set resource requests/limits to prevent OOM kills and ensure fair scheduling.
• Use liveness and readiness probes —especially important for Java apps with slow startup.
• Keep initialDelaySeconds high enough for JVM app startup.

3. Expose Your App with a Service and Ingress

Use a ClusterIP service for internal access and Ingress for external traffic.

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

 apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: java-app-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  Rules:
    - host: app.yourdomain.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: java-app-service
                port:
                  number: 80

? Use ingress controllers like NGINX or Traefik. Consider TLS via cert-manager for HTTPS.

4. Scale Automatically with HPA

Use Horizontal Pod Autoscaler (HPA) based on CPU, memory, or custom metrics.

 apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: java-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: java-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: AverageValue
          averageValue: 500Mi

? Ensure metrics-server is installed in your cluster for HPA to work.

For more advanced scaling (eg, based on Kafka queue depth or HTTP requests), consider KEDA.

5. Externalize Configuration and Secrets

Never hardcode configs. Use ConfigMaps and Secrets.

 # configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: java-app-config
data:
  application.yml: |
    server:
      port: 8080
    spring:
      datasource:
        url: ${DB_URL}

 # secret.yaml (apply with kubectl create secret or use external secret manager)
apiVersion: v1
kind: Secret
metadata:
  name: java-app-secret
type: Opaque
data:
  DB_PASSWORD: base64-encoded-password

Mount them in your Deployment:

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

? For production, integrate with Hashicorp Vault , AWS Secrets Manager , or use External Secrets Operator .

6. Optimize JVM for Containers

By default, older JVMs don't respect container memory limits—leading to OOM kills.

? Use Java 10 which supports container-aware memory and CPU limits:

 -XX: UseContainerSupport
-XX:MaxRAMPercentage=75.0
-Djava.security.egd=file:/dev/./urandom

Avoid setting -Xmx manually if you rely on container limits—let the JVM auto-calculate.

7. Monitor and Log Everything

Integrate with observability tools:

• Prometheus Grafana : Expose /metrics via Micrometer (built into Spring Boot Actuator).
• Loki or ELK : Collect logs. Use sidecar or DaemonSet (eg, Fluent Bit) to ship logs.
• Distributed tracing : Jaeger or Zipkin for microservices.

Add annotations for service discovery:

 prometheus.io/scrape: "true"
prometheus.io/port: "8080"

Final Thoughts

A scalable Java app on Kubernetes is more than just a containerized JAR. It's about:

• Efficient images
• Proper resource management
• Health checks
• Auto-scaling
• Externalized config
• Observability

Get these right, and your app won't just run—it'll thrive under load.

Basically, treat your Java app like a first-class citizen in the cloud-native world.

The above is the detailed content of Deploying a Scalable Java Application to Kubernetes. For more information, please follow other related articles on the PHP Chinese website!