How to set up Spring Boot application with Docker and dynamic ports?

Introduction

Problem Description:

Setting up a Spring Boot application is a common task for java developers, and containerizing it with Docker adds another layer of convenience, enabling consistent environments across different stages of development, testing, and deployment. However, setting up dynamic ports in a Docker container adds complexity. This guide walks you through the steps required to set up a Spring Boot application with Docker, while also enabling the use of dynamic ports. This is particularly useful for situations where port numbers may conflict or need to be set at runtime.

Solution

Step-by-Step Guide

1. Setting Up a Spring Boot Application

Sample Code:

package com.example.demo

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

@SpringBootApplication
class DemoApplication

fun main(args: Array<String>) {
    SpringApplication.run(DemoApplication::class.java, *args)
}

Advantages:

• Simple setup.
• Uses Spring Boot’s auto-configuration.

Disadvantages:

• Port is fixed by default unless configured otherwise.

2. Configuring Dynamic Ports

Sample Code:

Configure application.properties to use a random port.

server.port=0

Or, programmatically:

import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration
class ServerConfig {

    @Bean
    fun webServerFactory(): TomcatServletWebServerFactory {
        val factory = TomcatServletWebServerFactory()
        factory.port = 0 // 0 assigns a random port
        return factory
    }
}

Advantages:

• Avoids port conflicts.
• Suitable for integration testing.

Disadvantages:

• No control over which port is chosen.

3. Dockerizing the Application

Dockerfile

Create a Dockerfile:

# Use the official image as a parent image
FROM openjdk:11-jre-slim 

# Set the working directory
WORKDIR /app

# Add the application's jar to the container
COPY target/demo-0.0.1-SNAPSHOT.jar /app/demo.jar

# Make port configurable
ENV PORT 8080

# Expose the port to the Docker host
EXPOSE ${PORT}

# Run the jar file
CMD ["sh", "-c", "java -jar demo.jar --server.port=${PORT}"]

Advantages:

• Portable and isolated environment.
• Allows environment variable configuration.

Disadvantages:

• Larger image size due to the Java runtime.

4. Using Docker-Compose for Dynamic Ports

docker-compose.yml

Use docker-compose to manage the container lifecycle with dynamic ports:

version: '3.8'

services:
  web:
    build: .
    ports:
      - "${PORT:-8080}:8080"
    environment:
      - PORT=8080

Run with dynamic ports:

PORT=9090 docker-compose up

Advantages:

• Simplifies multi-container setups.
• Easy port config management.

Disadvantages:

• Additional configuration file needed.

5. Dynamic Port Integration Testing

Maven Configuration

Modify Maven to reserve ports dynamically:

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>build-helper-maven-plugin</artifactId>
    <executions>
        <execution>
            <id>reserve-network-port</id>
            <goals>
                <goal>reserve-network-port</goal>
            </goals>
            <configuration>
                <portNames>
                    <portName>server.port</portName>
                </portNames>
            </configuration>
        </execution>
    </executions>
</plugin>

Advantages:

• Automates port configuration.
• Useful for CI/CD pipelines.

Disadvantages:

• Adds build complexity.

6. Monitoring Docker Container Ports

Use commands to check dynamic port assignments:

docker ps

Example output:

CONTAINER ID        IMAGE               COMMAND             PORTS                     NAMES
1e2f3a4b5c6d        demo                "java -jar demo..." 0.0.0.0:32768->8080/tcp   web

Advantages:

• Real-time port tracking.

Disadvantages:

• Requires command-line knowledge.

Similar Topics

1. How to configure SSL in a Spring Boot application with Docker
2. Setting up database connection in a Spring Boot application with Docker
3. How to use Docker Compose with Spring Boot and a MySQL database
4. Deploying a Spring Boot application on AWS with Docker
5. Integrating Kubernetes with Dockerized Spring Boot applications
6. Automating Docker Spring Boot deployments using Jenkins
7. Using environment variables in Spring Boot applications with Docker
8. Creating a multi-stage Dockerfile for Spring Boot applications
9. Logging and monitoring Dockerized Spring Boot applications
10. Scaling Dockerized Spring Boot applications with Docker Swarm