Hey there! Let's get those two Java processes firing up automatically when you launch your Docker container—no more manual shell sessions inside the container. Here are a few practical approaches you can use right away:

Option 1: Use a Custom Startup Script (Clean & Maintainable) #

If you can modify your Docker image, adding a simple shell script is the most straightforward way. Here's how:

• Create a startup script inside your image (let's call it /app/start-services.sh):

  #!/bin/bash
  # Launch first Java process in the background
  java -jar /path/to/your-first-app.jar &
  # Capture its PID to wait on later
  PID1=$!
  
  # Launch second Java process in the background
  java -jar /path/to/your-second-app.jar &
  PID2=$!
  
  # Wait for both processes to finish so the container stays running
  wait $PID1 $PID2
  

• Make the script executable (you can add this step to your Dockerfile if building the image yourself):

  chmod +x /app/start-services.sh
  

• Run the container with the script as the entrypoint:

  docker run -d your-custom-image:latest /app/start-services.sh
  

This keeps the container alive because the script waits for both Java processes to exit—if either process crashes, the script (and container) will exit too, which is great for monitoring.

Option 2: Embed Commands Directly in docker run (No Image Modifications) #

If you don't want to update your image, you can chain the commands directly using sh -c in the docker run command. Just remember to escape special characters so your host shell doesn't interpret them:

docker run -d your-custom-image:latest sh -c "java -jar /path/to/your-first-app.jar & PID1=\$!; java -jar /path/to/your-second-app.jar & PID2=\$!; wait \$PID1 \$PID2"

The & sends each Java process to the background, wait ensures the container stays running until both processes finish, and the escaped \$ makes sure the container's shell handles the PID variables instead of your local shell.

Option 3: Use a Process Manager (For Robust Monitoring) #

If you need more control—like automatically restarting a process if it crashes—use a tool like supervisord:

• Add supervisord to your image (via your Dockerfile, e.g., for Debian/Ubuntu-based images):

  RUN apt-get update && apt-get install -y supervisor
  

• Create a supervisord config file (e.g., /etc/supervisor/conf.d/services.conf):

  [supervisord]
  nodaemon=true  # Run in foreground so Docker doesn't exit
  
  [program:first-java]
  command=java -jar /path/to/your-first-app.jar
  autostart=true
  autorestart=true  # Restart if the process crashes
  stdout_logfile=/var/log/first-app.log
  stderr_logfile=/var/log/first-app.err
  
  [program:second-java]
  command=java -jar /path/to/your-second-app.jar
  autostart=true
  autorestart=true
  stdout_logfile=/var/log/second-app.log
  stderr_logfile=/var/log/second-app.err
  

• Run the container with supervisord:

  docker run -d your-custom-image:latest supervisord -c /etc/supervisor/conf.d/services.conf
  

This is ideal for production environments where you need process resilience and centralized logging.

内容的提问来源于stack exchange，提问作者Adi Ohana