How to keep a Docker container running after starting several services? (Edited)

I’d like to add three more variations:

1. Using Docker Compose (dc) with the options stdin_open and restart:

When running with dc, you can set options to keep the container running even if the main process finishes. For instance, in docker-compose.yml you can add:

		

			
				
			
		
		services:
  app:
    image: myapp:latest
    stdin_open: true
    restart: always
	

Pros:

– Easy configuration through the compose file.

– Automatically restarts the container in case of failure.

Cons:

– It does not solve the core problem (the main process ending), it only softens it.

– It requires using dc.

2. Running the container with the flags -t and -d:

Running with the -t flag (pseudo-terminal) together with -d (detached mode) helps keep the container active:

		

			
				
			
		
		docker run -td myapp:latest
	

Pros:

– Simple command.

– Keeping the pseudo-terminal may prevent immediate exit.

Cons:

– This method depends on the specific application; if PID 1 finishes, the container will still stop.

– It is not a solution for process management inside the container.

3. Using "wait" to track the main process’s lifecycle:

If your script starts a service, you can record its PID and run wait. Such as:

		

			
				
			
		
		#!/bin/bash

service nginx start

NGINX_PID=$(pgrep nginx)

wait $NGINX_PID
	

Pros:

– The container will keep running as long as nginx is running.

– It allows the container to finish correctly when the service stops.

Cons:

– It requires precise configuration and tracking of the PID.

– If the process spawns child processes, it might not work perfectly.

In general, there are a lot of options in Docker...

I can recall a few more ways or variations of what has already been mentioned:

1. Running the container with a light init process, such as tini.

This init process is launched as ENTRYPOINT and handles signal forwarding and managing child processes. Its benefits include proper signal handling (SIGTERM, SIGINT, etc.), ease, low overhead, and being a universal solution for Docker containers. However, by itself it does not solve the problem of multiple processes – you still need to organize the service startup (for instance, using Supervisor or another method).

2. An infinite loop in the script.

At the end of the service startup script, you can add a simple infinite loop. In bash it looks like this:

		

			
				
			
		
		while true; do
  sleep 1000
done
	

The advantage of an infinite loop is its simplicity and clarity without needing extra software. This method guarantees that the main process (PID 1) does not exit. The clear disadvantage is the lack of a mechanism to manage or monitor child processes, and termination signals may not be handled properly. This method, like exec tail -f /dev/null, is usually used as a temporary solution for development, not for production.

3. Running systemd inside the container.

Running a full systemd in the container to manage services. This allows you to use the standard service manager features. Its advantage is the ability to manage dependencies and logging through systemd, allowing you to start several services with detailed settings. The downside is a more complex container configuration, a larger image size, and increased startup time.

Hello again! Thank you, everyone, for your answers!

According to modern recommendations, each container should do one task.

If possible, consider splitting your services into separate containers and combining them with Docker Compose. This makes scaling and managing dependencies easier.

docker-compose.yml:

		

			
				
			
		
		version: "3.9"
services:
  web:
    image: mywebserver:latest
    ports:
      - "80:80"
  daemon:

    image: mydaemon:latest
	

If you prefer not to modify the container’s architecture and want to continue launching services via a script, you can simply append an instruction at the end of your start-services.sh that never terminates:

		

			
				
			
		
		#!/bin/bash
# Start necessary services
service apache2 start
service mydaemon start

# Keep the container active
exec tail -f /dev/null
	

Or you can change the Dockerfile so that the main process waits indefinitely:

		

			
				
			
		
		CMD ["sleep", "infinity"]
	

Modern Docker practice is to run a single process per container.

If you need multiple services, the best method is to use a process manager that keeps the Docker container running and manages the services. 

As an illustration, you can use Supervisor in foreground mode.

dockerfile:

		

			
				
			
		
		FROM ubuntu:latest

# Install necessary packages
RUN apt-get update && apt-get install -y apache2 supervisor

# Copy Supervisor configuration file
COPY supervisord.conf /etc/supervisord.conf

# Copy scripts or other files if needed
COPY start-services.sh /opt/start-services.sh

# Run Supervisor in foreground mode
CMD ["/usr/bin/supervisord", "-n"]
	

supervisord.conf:

		

			
				
			
		
		[supervisord]
nodaemon=true

[program:webserver]
command=apache2 -DFOREGROUND
autorestart=true

[program:daemon]
command=/usr/local/bin/mydaemon --run
autorestart=true