4. Making Configuration Data Available to Containerised Applications

Question 1

What is application configuration?

Answer 1

An app’s configuration is everything that is likely to vary between deploys (staging, production, dev environments, etc).

Question 2

What are some examples of application configuration?

Answer 2

1. Database server URL for an app’s backend.
2. Port the app listens on for client requests.
3. An application’s logging level for debugging purposes.
4. The version of the app or API served by the environment.

Question 3

What are the Twelve Factor App recommendations around configuration?

Answer 3

1. Separate code and config — don’t define configuration as constants in the application’s source code.
2. Store config in env vars — do use environment variables to define the application’s configuration.

Question 4

What are the benefits of using environment variables rather than the app’s source code to define configuration?

Answer 4

1. No leakage of sensitive information hard-coded in software applications.
2. Straightforward onboarding of new environments to host software applications.
3. No need to re-test software applications due to changes to the configuration.
4. Configuration defined in environment variables is agnostic concerning languages and operating systems.

Question 5

What Dockerfile instruction do we use to define environment variables?

Answer 5

The ENV instruction.

Question 6

What can be said about the availability and persistence of environment variables defined in the Dockerfile for building images vs running containers?

Answer 6

Environment variables we define in the Dockerfile are available for builds. They can be used by other Dockerfile instructions.

These variables persist in the container. They are present in containers derived from the image build using the Dockerfile.

Question 7

What is the recommended method of defining environment variables in the Dockerfile?

Answer 7

Using the ENV instruction followed by the variable name, an equal sign, and variable value. Then, if you need more than one variable, you can use the backslash to define each one in a new line.

ENV REDIS_HOST="redis_server" \
         REDIS_PORT="6379"

Question 8

What kind of flexibility does Docker provide in regards to the point and time that environment variables are define?.

Answer 8

Environment variables can either be defined inside the Dockerfile or at the point of build. The latter meaning that the environment variables can be assigned when image builds are initiated.

Question 9

How can we define an environment variable at the point of build?

Answer 9

1. Arguments are provided on the command line when an image build is initiated with a Dockerfile.
2. A corresponding variable is defined in the image’s Dockerfile using the ARG instruction.
3. The value provided for the variable on the command line is substituted into the Dockerfile.

Question 10

How do we define in the Dockerfile a command line argument to be passed when initiating a build?

Answer 10

By using the ARG instruction followed by the argument name, an equals sign and the default value.

ARG VERSION="1.18.0"

Question 11

How do we specify the value of an argument defined in the Dockerfile when running an image build?

Answer 11

By using the --build-arg option followed by the argument name, an equals sign and the argument value.

docker build --build-arg VERSION="1.19.5"

Question 12

What benefit does the fact that Docker ARG instruction allows us to re-assign values to variables in command-line allow us to do?

Answer 12

It allows us to build different image variants without altering the Dockerfile by choosing the value of the variable at the point in time of the build.

Question 13

What facts about the ARG instruction should you take into consideration when deciding whether to use it to define a variable?

Answer 13

1. It’s for values only known at build-time.
2. Useful for variables required only for builds.
3. Scoped from the line in which it is defined.
4. Not visible when inspecting an image.

Question 14

In what process/location can we access a variable defined using the ARG instruction?

Answer 14

Only during the build process. Variables defined using the ARG instruction don’t trickle down to containers that are derived from the image.

Question 15

What facts about the ENV instruction should you take into consideration when deciding whether to use it to define a variable?

Answer 15

1. General-purpose mechanism for defining variables.
2. Useful for persisting variables in images.
3. ENV variables trump same-named ARG variables.
4. Visible in image’s configuration.

Question 16

What options do we have when defining application configuration in Docker?

Answer 16

1. Authoring (Dockerfile) — ENV instruction.
2. Building (Dockerfile and CLI Options) — ARG instruction, --build-arg.
3. Running (CLI Options) — --env, --env-file.

Question 17

How can we set environment variables at runtime for Docker images/containers?

Answer 17

By using the -e or --env CLI option. If already defined in Dockerfile, the CLI definition overrides the set values.

Question 18

What happens if we at runtime define an environment variable that is already defined in Dockerfile?

Answer 18

The CLI definition overrides the pre-defined value.

Question 19

How can you provide Docker environment variables that are already defined in the environment?

Answer 19

By using the --env option and passing it the environment variable name only.

export REDIS_HOST=redis_server
docker run --rm --env REDIS_HOST redis

Question 20

How can you provide Docker with a whole file of environment variables at runtime?

Answer 20

By using the --env-file option and passing it the full path to the file.

redis.env file content:

REDIS_HOST=redis_server
REDIS_PORT=6379
~~~
```

the command:
~~~
docker run –rm –env-file $(pwd)/redis.env
~~~

Question 21

In Dockerfile, how do you set an environment variable based on an argument which doesn’t have a defined value but may or may not have a value defined at runtime?

Answer 21

By using the :- operator in a curly braces and quotes.

ARG NODE_ENV
ENV NODE_ENV "{NODE_ENV:-production}"

Question 22

How do you specify a script to be run rather than a command-line tool when a container is run?

Answer 22

By using the ENTRYPOINT instruction and passing it the path to the script inside the container — the script must have execution rights (chmod).

ENTRYPOINT ["/app/docker-entrypoint.sh"]