docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

engine: restructure mult-service container page 

Signed-off-by: David Karlsson <david.karlsson@docker.com>
This commit is contained in:
David Karlsson 2023-05-11 16:54:23 +02:00
parent 7079dc4572
commit a2d22f16e6
1 changed files with 85 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
config/containers/multi-service_container.md
View File

@ -10,8 +10,8 @@ title: Run multiple services in a container
--- ---
A container's main running process is the `ENTRYPOINT` and/or `CMD` at the A container's main running process is the `ENTRYPOINT` and/or `CMD` at the
end of the `Dockerfile`. It is generally recommended that you separate areas of end of the `Dockerfile`. It's best practice to separate areas of concern by
concern by using one service per container. That service may fork into multiple using one service per container. That service may fork into multiple
processes (for example, Apache web server starts multiple worker processes). processes (for example, Apache web server starts multiple worker processes).
It's ok to have multiple processes, but to get the most benefit out of Docker, It's ok to have multiple processes, but to get the most benefit out of Docker,
avoid one container being responsible for multiple aspects of your overall avoid one container being responsible for multiple aspects of your overall
@ -28,91 +28,97 @@ container exits. Handling such processes this way is superior to using a
full-fledged init process such as `sysvinit`, `upstart`, or `systemd` to handle full-fledged init process such as `sysvinit`, `upstart`, or `systemd` to handle
process lifecycle within your container. process lifecycle within your container.
If you need to run more than one service within a container, you can accomplish If you need to run more than one service within a container, you can achieve
this in a few different ways. this in a few different ways.
- Put all of your commands in a wrapper script, complete with testing and ## Use a wrapper script
debugging information. Run the wrapper script as your `CMD`. This is a very
naive example. First, the wrapper script:
```bash Put all of your commands in a wrapper script, complete with testing and
#!/bin/bash debugging information. Run the wrapper script as your `CMD`. This is a very
naive example. First, the wrapper script:
# Start the first process ```bash
./my_first_process & #!/bin/bash
# Start the second process # Start the first process
./my_second_process & ./my_first_process &
# Wait for any process to exit # Start the second process
wait -n ./my_second_process &
# Exit with status of process that exited first # Wait for any process to exit
exit $? wait -n
```
Next, the Dockerfile: # Exit with status of process that exited first
exit $?
```
```dockerfile Next, the Dockerfile:
# syntax=docker/dockerfile:1
FROM ubuntu:latest
COPY my_first_process my_first_process
COPY my_second_process my_second_process
COPY my_wrapper_script.sh my_wrapper_script.sh
CMD ./my_wrapper_script.sh
```
- If you have one main process that needs to start first and stay running but ```dockerfile
you temporarily need to run some other processes (perhaps to interact with # syntax=docker/dockerfile:1
the main process) then you can use bash's job control to facilitate that. FROM ubuntu:latest
First, the wrapper script: COPY my_first_process my_first_process
COPY my_second_process my_second_process
COPY my_wrapper_script.sh my_wrapper_script.sh
CMD ./my_wrapper_script.sh
```
```bash ## Use Bash job controls
#!/bin/bash
# turn on bash's job control If you have one main process that needs to start first and stay running but
set -m you temporarily need to run some other processes (perhaps to interact with
the main process) then you can use bash's job control to facilitate that.
First, the wrapper script:
# Start the primary process and put it in the background ```bash
./my_main_process & #!/bin/bash
# Start the helper process # turn on bash's job control
./my_helper_process set -m
# the my_helper_process might need to know how to wait on the # Start the primary process and put it in the background
# primary process to start before it does its work and returns ./my_main_process &
# Start the helper process
./my_helper_process
# the my_helper_process might need to know how to wait on the
# primary process to start before it does its work and returns
# now we bring the primary process back into the foreground # now we bring the primary process back into the foreground
# and leave it there # and leave it there
fg %1 fg %1
``` ```
```dockerfile ```dockerfile
# syntax=docker/dockerfile:1 # syntax=docker/dockerfile:1
FROM ubuntu:latest FROM ubuntu:latest
COPY my_main_process my_main_process COPY my_main_process my_main_process
COPY my_helper_process my_helper_process COPY my_helper_process my_helper_process
COPY my_wrapper_script.sh my_wrapper_script.sh COPY my_wrapper_script.sh my_wrapper_script.sh
CMD ./my_wrapper_script.sh CMD ./my_wrapper_script.sh
``` ```
- Use a process manager like `supervisord`. This is a moderately heavy-weight ## Use a process manager
approach that requires you to package `supervisord` and its configuration in
your image (or base your image on one that includes `supervisord`), along with
the different applications it manages. Then you start `supervisord`, which
manages your processes for you. Here is an example Dockerfile using this
approach, that assumes the pre-written `supervisord.conf`, `my_first_process`,
and `my_second_process` files all exist in the same directory as your
Dockerfile.
```dockerfile Use a process manager like `supervisord`. This is a moderately heavy-weight
# syntax=docker/dockerfile:1 approach that requires you to package `supervisord` and its configuration in
FROM ubuntu:latest your image (or base your image on one that includes `supervisord`), along with
RUN apt-get update && apt-get install -y supervisor the different applications it manages. Then you start `supervisord`, which
RUN mkdir -p /var/log/supervisor manages your processes for you. Here is an example Dockerfile using this
COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf approach, that assumes the pre-written `supervisord.conf`, `my_first_process`,
COPY my_first_process my_first_process and `my_second_process` files all exist in the same directory as your
COPY my_second_process my_second_process Dockerfile.
CMD ["/usr/bin/supervisord"]
``` ```dockerfile
# syntax=docker/dockerfile:1
FROM ubuntu:latest
RUN apt-get update && apt-get install -y supervisor
RUN mkdir -p /var/log/supervisor
COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf
COPY my_first_process my_first_process
COPY my_second_process my_second_process
CMD ["/usr/bin/supervisord"]
```