Docker: Where to store version of multiple images for docker-compose?

Question

In my CI environment there are several build versions and I need to get a specific version for docker-compose :

registry.example.com/foo/core   0.1.3
registry.example.com/foo/core   0.2.2
... # multiple packages in several versions like this

The images are builded like this:

build:
  stage: build
  script:
    ...
    - docker build -t $CI_REGISTRY_IMAGE:$VERSION .
    - docker push $CI_REGISTRY_IMAGE:$VERSION

And they are pulled on deploy pipeline like this:

production:
  stage: deploy
  script:
    - docker pull $CI_REGISTRY_IMAGE:$VERSION

I'm also using docker-compose to start all microservices from that images:

$ docker-compose up -d

But now that is my problem. Where can I store which version of each image should be used? Hardcoded it looks like this - but this will always start 0.2.2, although the deploy pipeline could pull a different version, like 0.1.3:

core:
  container_name: core
  image: 'registry.example.com/foo/core:0.2.2'
  restart: always
  links:
    - 'mongo_live'
  environment:
    - ROOT_URL=https://example.com
    - MONGO_URL=mongodb://mongo_live/example

But the version should be better set as a variable. So I would think that on deploy I have to store the current $VERSION -value somewhere. On running docker-compose the version value should be read to get the correct version as the latest version is not always the selected one.

Answer 1

If you pass it as a variable, you'd store it where ever you define your environment variables in your CI environment. You can also store the values in a .env which is described here .

Using the variable defined in the environment (or .env file) would have a line in the docker-compose.yml like:

image: registry.example.com/foo/core:${VERSION}

Personally, I'd take a different approach and let the registry server maintain the version of the image with tags. If you have 3 versions for dev, stage, and prod, you can build your registry.example.com/foo/core:0.2.2 and then tag that same image as registry.example.com/foo/core:dev . The backend image checksum can be referenced by multiple tags and not take up additional disk space on the registry server or the docker hosts. Then in your dev environment, you'd just do a docker-compose pull && docker-compose up -d to grab the dev image and spin it up. The only downside of this approach is that the tag masks which version of the image is currently being used as dev , so you'll need to track that some other way.

Tagging an image in docker uses the docker tag command. You would run:

docker tag registry.example.com/foo/core:${VERSION} registry.example.com/foo/core:dev
docker push registry.example.com/foo/core:${VERSION}
docker push registry.example.com/foo/core:dev

If the registry already has a tag for registry.example.com/foo/core:dev it gets replaced with the new tag pointing to the new image id.