How to run a command once in Docker compose
Solution 1
I suggest to add an entrypoint-script to your container; in this entrypoint-script, you can check if the database has been initialized, and if it isn't, perform the required steps.
As you noticed in your question, the order in which services / containers are started should not be taken for granted, so it's possible your application container is started before the database container, so the script should take that into account.
As an example, have a look at the official WordPress image, which performs a one-time initialization of the database in it's entrypoint-script. The script attempts to connect to the database (and retries if the database cannot be contacted (yet)), and checks if initialization is needed; https://github.com/docker-library/wordpress/blob/df190dc9c5752fd09317d836bd2bdcd09ee379a5/apache/docker-entrypoint.sh#L146-L171
NOTE
I notice you created a "data-only container" to attach your volume to. Since docker 1.9, docker has volume management, including naming volumes. Because of this, you no longer need to use "data-only" containers.
You can remove the data-only container from your compose file, and change your mongo service to look something like this;
mongo:
image: mongo:latest
volumes:
- mongodata:/data/db
ports:
- "28001:27017"
command: --smallfiles --rest --auth
This should create a new volume, named mongodata
if it doesn't exist, or re-use the existing volume with that name. You can list all volumes using docker volume ls
and remove a volume with docker volume rm <some-volume>
if you no longer need it
Solution 2
You could try to use ONBUILD
instruction:
The ONBUILD
instruction adds to the image a trigger instruction to be executed at a later time, when the image is used as the base for another build. The trigger will be executed in the context of the downstream build, as if it had been inserted immediately after the FROM
instruction in the downstream Dockerfile
.
Any build instruction can be registered as a trigger.
This is useful if you are building an image which will be used as a base to build other images, for example an application build environment or a daemon which may be customized with user-specific configuration.
For example, if your image is a reusable Python application builder, it will require application source code to be added in a particular directory, and it might require a build script to be called after that. You can’t just call ADD
and RUN
now, because you don’t yet have access to the application source code, and it will be different for each application build. You could simply provide application developers with a boilerplate Dockerfile
to copy-paste into their application, but that is inefficient, error-prone and difficult to update because it mixes with application-specific code.
The solution is to use ONBUILD
to register advance instructions to run later, during the next build stage.
Here’s how it works:
- When it encounters an
ONBUILD
instruction, the builder adds a trigger to the metadata of the image being built. The instruction does not otherwise affect the current build. - At the end of the build, a list of all triggers is stored in the image manifest, under the key
OnBuild
. They can be inspected with thedocker inspect
command. - Later the image may be used as a base for a new build, using the
FROM
instruction. As part of processing theFROM
instruction, the downstream builder looks forONBUILD
triggers, and executes them in the same order they were registered. If any of the triggers fail, theFROM
instruction is aborted which in turn causes the build to fail. If all triggers succeed, theFROM
instruction completes and the build continues as usual. - Triggers are cleared from the final image after being executed. In other words they are not inherited by “grand-children” builds.
Solution 3
Your application need some initial state for working. It means that you should:
- Check if required state already exists
- Depends on first step result init state or not
You can write program for checking current database state (here I will use bash script but it can be every other language program):
RUN if $(./check.sh); then my_project -setup; fi
In my case if script will return 0 (success exit status) then setup
command will be called.
Related videos on Youtube
Ivan
Updated on July 10, 2022Comments
-
Ivan almost 2 years
So I'm working on a docker compose file to deploy my Go web server. My server uses mongo, so I added a data volume container and the mongo service in docker compose. Then I wrote a Dockerfile in order to build my Go project, and finally run it.
However, there is another step that must be done. Once my project has been compiled, I have to run the following command:
./my-project -setup
This will add some necessary information to the database, and the information only needs to be added once. I can't however add this step on the Dockerfile (in the build process) because mongo must already be started.
So, how can I achieve this? Even if I restart the server and then run again
docker-compose up
I don't want this command to be executed again.I think I'm missing some Docker understanding, because I don't actually understand everything about data volume containers (are they just stopped containers that mount a volume?). Also, if I restart the server, and then run
docker-compose up
, which commands will be run? Will it just start the same container that was now stopped with the given CMD?In any case, here is my docker-compose.yml:
version: '2' services: mongodata: image: mongo:latest volumes: - /data/db command: --break-mongo mongo: image: mongo:latest volumes_from: - mongodata ports: - "28001:27017" command: --smallfiles --rest --auth my_project: build: . ports: - "6060:8080" depends_on: - mongo - mongodata links: - mongo
And here is my Dockerfile to build my project image:
FROM golang ADD . /go/src/my_project RUN cd /go/src/my_project && go get RUN go install my_project RUN my_project -setup ENTRYPOINT /go/bin/my_project EXPOSE 8080
-
Xiongbing Jin about 8 yearsYou can probably set up a flag (file or database) that indicates whether the script has been run and data have been initialized.
-
-
Cortwave about 8 yearsAnd how are you suggesting to use it?
-
Petr Razumov about 8 years@Cortwave it makes the structure a bit complex, since one needs to create a "base" image first with
ONBUILD
instructions and after that an image for an application. As for me, I'd better solve this problem on the application side or using something like a makefile. -
Petr Razumov about 8 years@Cortwave I'd better leave db as simple as possible, so edit on the app side.
-
Cortwave about 8 yearsBut as I understood
ONBUILD
command it just executes some trigger when you are using your image as base image for other build. In other words it will be executed every time when you are using your app image as base image. -
Petr Razumov about 8 years@Cortwave Yes, it will be executed every time you build the image, but not every time when you run a container.
-
Cortwave about 8 yearsLet us continue this discussion in chat.