如何在单个Docker容器运行多进程？如何整合多应用镜像简化部署？

Great question! Let’s break this down step by step—since you’re looking to streamline deploying multiple co-located apps with minimal effort, we’ll cover all your options, including best practices for your use case.

1. Running Multiple Processes in a Single Docker Container #

Docker containers are optimized for single foreground processes by default, but there are reliable ways to run multiple processes when your workflow requires it:

• Use a lightweight init system (Tini)
  Tini handles zombie process cleanup and signal propagation, which helps keep your container stable. Here’s how to include it in your Dockerfile:

  FROM ubuntu:latest
  # Install Tini
  RUN apt-get update && apt-get install -y tini
  # Set Tini as the entrypoint to run as PID 1
  ENTRYPOINT ["/usr/bin/tini", "--"]
  # Launch multiple processes via a shell command
  CMD ["sh", "-c", "nginx -g 'daemon off;' && python3 /app/main.py"]
  

• Use a custom shell script as the entrypoint
  Create a simple script to start all your processes, ensuring they run in the foreground so the container doesn’t exit prematurely.
  Example start-services.sh:

  #!/bin/bash
  # Start first service in the background
  redis-server &
  # Start second service in the foreground (keeps container running)
  node /app/server.js
  

  Update your Dockerfile to use this script:

  FROM node:18-alpine
  RUN apk add --no-cache redis
  COPY start-services.sh /usr/local/bin/
  RUN chmod +x /usr/local/bin/start-services.sh
  COPY server.js /app/
  ENTRYPOINT ["start-services.sh"]
  

• Use a process manager (Supervisor)
  Supervisor is a Python-based tool that monitors and restarts processes automatically. It’s great for more complex multi-process setups.
  Example supervisord.conf:

  [supervisord]
  nodaemon=true  # Run in foreground
  
  [program:nginx]
  command=/usr/sbin/nginx -g "daemon off;"
  
  [program:flask-app]
  command=python3 /app/app.py
  directory=/app
  

  Dockerfile setup:

  FROM ubuntu:latest
  RUN apt-get update && apt-get install -y nginx python3 supervisor
  COPY supervisord.conf /etc/supervisor/conf.d/
  COPY app.py /app/
  CMD ["supervisord"]
  

2. Building a Multi-App Docker Image (or Integrating Existing Images) #

You absolutely can build a single image containing multiple applications—though it’s worth noting Docker’s best practice favors one process per container for isolation and easier maintenance. That said, if your use case requires co-locating apps, here’s how to proceed:

• Build a single multi-app image from scratch
  Start with a base image (like Alpine or Ubuntu), install all dependencies for your apps, copy in code/configs, and use one of the multi-process methods above to start everything. This is simple but means changes to one app require rebuilding the entire image.

• Avoid "merging" existing pre-built images
  Merging separate images into one isn’t a standard practice and often leads to messy, unmaintainable images (conflicting dependencies, overlapping files, etc.). Instead, use Docker Compose to orchestrate existing images together—it keeps each app isolated but lets you deploy them all with one command.

3. Simplify Deployment with a Single Command #

For your goal of deploying all apps with one command, Docker Compose is the perfect tool. It lets you define your entire stack (apps, databases, volumes, networks) in a single docker-compose.yml file, then manage everything with simple commands.

Example docker-compose.yml:

version: '3.8'
services:
  frontend:
    image: your-frontend-image:latest
    ports:
      - "80:80"
    volumes:
      - ./frontend-config:/etc/nginx/conf.d

  backend:
    image: your-backend-image:latest
    ports:
      - "3000:3000"
    environment:
      - DB_CONNECTION=postgresql://db:5432/mydb

  db:
    image: postgres:15
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=your-secure-password

volumes:
  db-data:

To deploy the entire stack in one go:

docker-compose up -d

To stop and clean up:

docker-compose down

This approach follows Docker best practices (isolated containers) while giving you the simplicity of one-command deployment. If you really need everything in a single container, you can build that multi-app image and deploy it with docker run, but Compose offers far more flexibility for updates, scaling, and troubleshooting later.

内容的提问来源于stack exchange，提问作者Sredny M Casanova