Using Docker Images
- Register docker runner
- What is an image
- What is a service
- Overwrite image and services
- How to use other images as services
Define image and services from
Define image and services in
- Define an image from a private Docker registry
- Accessing the services
- Configuring services
- How Docker integration works
- How to debug a job locally
Docker is an open-source project that allows you to use predefined images to run applications in independent "containers" that are run within a single Linux instance. Docker Hub has a rich database of pre-built images that can be used to test and build your applications.
Docker, when used with GitLab CI, runs each job in a separate and isolated
container using the predefined image that is set up in
This makes it easier to have a simple and reproducible build environment that can also run on your workstation. The added benefit is that you can test all the commands that we will explore later from your shell, rather than having to test them on a dedicated CI server.
To use GitLab Runner with docker you need to register a new runner to use the
gitlab-ci-multi-runner register \ --url "https://gitlab.com/" \ --registration-token "PROJECT_REGISTRATION_TOKEN" \ --description "docker-ruby-2.1" \ --executor "docker" \ --docker-image ruby:2.1 \ --docker-postgres latest \ --docker-mysql latest
The registered runner will use the
ruby:2.1 docker image and will run two
mysql:latest, both of which will be
accessible during the build process.
image keyword is the name of the docker image the docker executor
will run to perform the CI tasks.
For more information about images and Docker Hub please read the Docker Fundamentals documentation.
services keyword defines just another docker image that is run during
your job and is linked to the docker image that the
image keyword defines.
This allows you to access the service image during build time.
The service image can run any application, but the most common use case is to
run a database container, eg.
mysql. It's easier and faster to use an
existing image and run it as an additional container than install
time the project is built.
You can see some widely used services examples in the relevant documentation of CI services examples.
To better understand how the container linking works, read Linking containers together.
To summarize, if you add
mysql as service to your application, the image will
then be used to create a container that is linked to the job container.
The service container for MySQL will be accessible under the hostname
So, in order to access your database service you have to connect to the host
mysql instead of a socket or
You are not limited to have only database services. You can add as many
services you need to
.gitlab-ci.yml or manually modify
Any image found at Docker Hub can be used as a service.
You can simply define an image that will be used for all jobs and a list of services that you want to use during build time.
image: ruby:2.2 services: - postgres:9.3 before_script: - bundle install test: script: - bundle exec rake spec
It is also possible to define different images and services per job:
before_script: - bundle install test:2.1: image: ruby:2.1 services: - postgres:9.3 script: - bundle exec rake spec test:2.2: image: ruby:2.2 services: - postgres:9.4 script: - bundle exec rake spec
Look for the
[runners.docker] image = "ruby:2.1" services = ["mysql:latest", "postgres:latest"]
The image and services defined this way will be added to all job run by that runner.
Starting with GitLab Runner 0.6.0, you are able to define images located to private registries that could also require authentication.
All you have to do is be explicit on the image definition in
In the example above, GitLab Runner will look at
my.registry.tld:5000 for the
If the repository is private you need to authenticate your GitLab Runner in the registry. Learn how to do that on GitLab Runner's documentation.
Let's say that you need a Wordpress instance to test some API integration with your application.
You can then use for example the tutum/wordpress image in your
services: - tutum/wordpress:latest
When the job is run,
tutum/wordpress will be started and you will have
access to it from your build container under the hostnames
(requires GitLab Runner v1.1.0 or newer) and
Note: hostname with underscores is not RFC valid and may cause problems in 3rd party applications.
The alias hostnames for the service are made from the image name following these rules:
- Everything after
- Slash (
/) is replaced with double underscores (
__) - primary alias
- Slash (
/) is replaced with dash (
-) - secondary alias, requires GitLab Runner v1.1.0 or newer
Many services accept environment variables which allow you to easily change database names or set account names depending on the environment.
GitLab Runner 0.5.0 and up passes all YAML-defined variables to the created service containers.
For all possible configuration variables check the documentation of each image provided in their corresponding Docker hub page.
Note: All variables will be passed to all services containers. It's not designed to distinguish which variable should go where.
See the specific documentation for using PostgreSQL as a service.
See the specific documentation for using MySQL as a service.
Below is a high level overview of the steps performed by docker during job time.
- Create any service container:
- Create cache container to store all volumes as defined in
Dockerfileof build image (
ruby:2.1as in above example).
- Create build container and link any service container to build container.
- Start build container and send job script to the container.
- Run job script.
- Checkout code in:
- Run any step defined in
- Check exit status of build script.
- Remove build container and all created service containers.
Note: The following commands are run without root privileges. You should be able to run docker with your regular user account.
First start with creating a file named
cat <<EOF > build_script git clone https://gitlab.com/gitlab-org/gitlab-ci-multi-runner.git /builds/gitlab-org/gitlab-ci-multi-runner cd /builds/gitlab-org/gitlab-ci-multi-runner make EOF
Here we use as an example the GitLab Runner repository which contains a
Makefile, so running
make will execute the commands defined in the Makefile.
Your mileage may vary, so instead of
make you could run the command which
is specific to your project.
Then create some service containers:
docker run -d --name service-mysql mysql:latest docker run -d --name service-postgres postgres:latest
This will create two service containers, named
service-postgres which use the latest MySQL and PostgreSQL images
respectively. They will both run in the background (
Finally, create a build container by executing the
build_script file we
docker run --name build -i --link=service-mysql:mysql --link=service-postgres:postgres ruby:2.1 /bin/bash < build_script
The above command will create a container named
build that is spawned from
ruby:2.1 image and has two services linked to it. The
piped using STDIN to the bash interpreter which in turn executes the
build_script in the
When you finish testing and no longer need the containers, you can remove them with:
docker rm -f -v build service-mysql service-postgres
This will forcefully (
-f) remove the
build container, the two service
containers as well as all volumes (
-v) that were created with the container