Dockerfile cheat sheet

FROM <image>:<tag>

FROM ubuntu:20.04

RUN <command>

RUN apt-get update && apt-get install -y python3

CMD ["executable","param1","param2"]

CMD ["echo", "Hello World"]

LABEL <key>=<value> <key>=<value> ...

LABEL version="1.0" description="This is an example."

EXPOSE <port>

EXPOSE 80

ENV <key>=<value>

ENV MY_NAME="John Doe"

COPY [--chown=<user>:<group>] <src>... <dest>

COPY . /app

ADD [--chown=<user>:<group>] <src>... <dest>

ADD https://example.com/example.tar.gz /var/www/html/

WORKDIR /path/to/workdir

WORKDIR /app

• For Debian/Ubuntu-based containers:

  RUN apt-get update && apt-get install -y package-name

• For Red Hat/CentOS-based containers:

  RUN yum install -y package-name

• For Alpine-based containers:

  RUN apk add --update package-name

RUN apt-get update && apt-get install -y curl

RUN apt-get install -y package-name \
  && rm -rf /var/lib/apt/lists/*

RUN apt-get update && apt-get install -y \
  git \
  && apt-get clean \
  && rm -rf /var/lib/apt/lists/*

• Chain commands using &&.
• Avoid unnecessary layers by combining related tasks into a single RUN statement.

RUN apt-get update && apt-get install -y \
  curl \
  git \
  && apt-get clean \
  && rm -rf /var/lib/apt/lists/*

ARG VERSION=latest
RUN apt-get install -y package-name=${VERSION}

ARG PHP_VERSION=7.4
RUN apt-get update && apt-get install -y \
  php${PHP_VERSION}

CMD ["executable","param1","param2"]  # exec form, preferred
CMD command param1 param2            # shell form

CMD ["echo", "Hello world"]  # Using exec form
CMD echo Hello world         # Using shell form

ENTRYPOINT ["executable", "param1", "param2"]  # exec form, preferred
ENTRYPOINT command param1 param2              # shell form

ENTRYPOINT ["/usr/sbin/apache2ctl", "-D", "FOREGROUND"]
ENTRYPOINT exec top -b

• Use ENTRYPOINT for setting the container's main application.
• Reserve CMD for default arguments and running additional setups before the main process begins.

ENTRYPOINT ["executable", "param1"]
CMD ["param2", "param3"]

VOLUME ["/data"]

VOLUME /var/log /var/db

• VOLUME can be used to enable access to Docker data from outside the Docker container and to share data between containers.
• When a volume is declared, any changes made to that volume will be made directly on the host machine and will persist even after the container is deleted.

VOLUME ["/data:ro"]

• Backup: docker run --rm --volumes-from dbstore -v $(pwd):/backup ubuntu tar cvf /backup/backup.tar /dbdata
• Restore: docker run --rm --volumes-from dbstore2 -v $(pwd):/backup ubuntu tar xvf /backup/backup.tar

• Ensure that operations on data volumes do not interrupt running services unless necessary.

EXPOSE <port> [<port>/<protocol>...]

EXPOSE 80/tcp
EXPOSE 443

• EXPOSE does not make the ports of the container accessible to the host. To do this, you need to run the container with the -p flag.
• This instruction is useful for building images that are meant to intercommunicate or are intended to be run in linked containers.

• When running containers, use Docker run commands to specify networking configurations:

  docker run --network=host --name container_name image_name

docker run -d --network=my-network --name my-app my-image

• Common network modes include bridge, host, none, and user-defined networks.
• --network=host uses the host’s networking stack, and not isolated networking for the container.

• Link two containers:

  docker run --link <name or id>:alias

docker run --name database --detach some-database
docker run --detach --name app --link database:db my-app-image

• Linking is a legacy feature and might be removed in future Docker versions. It’s recommended to use user-defined networks to facilitate communication between containers.

RUN apt-get update && apt-get install -y \
  git \
  curl \
  && rm -rf /var/lib/apt/lists/*

.git
node_modules
tmp/

COPY package.json /app/
RUN npm install
COPY . /app

FROM node:14-alpine

RUN adduser -D myuser
USER myuser

ENV API_KEY_ENV_VAR_NAME

Usage:

# Build stage
FROM golang:1.16 as builder
WORKDIR /go/src/app
COPY . .
RUN go build -o /my-app

# Final stage
FROM alpine:latest
COPY --from=builder /my-app /my-app
CMD ["/my-app"]

Example:

FROM node:12 as builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src

FROM python:3.7
ONBUILD COPY requirements.txt /app/
ONBUILD RUN pip install --no-cache-dir -r /app/requirements.txt

HEALTHCHECK --interval=5m --timeout=3s \
CMD curl -f http://localhost/ || exit 1

HEALTHCHECK CMD curl --fail http://localhost:8080/health || exit 1

Docker build failures:

• Symptoms: Build stops with an error message.
• Common Causes: Syntax errors in Dockerfile, missing files in context, permissions issues.
• Solution:
• Check Dockerfile syntax and ensure all referenced files are available in the build context.
• Ensure that file permissions allow Docker to access necessary files.

Container won't start:

• Symptoms: Container exits immediately after start or fails to start.
• Common Causes: Misconfiguration in CMD or ENTRYPOINT, necessary services not started.
• Solution:
• Use docker logs container_name to check the logs for error messages.
• Verify that CMD and ENTRYPOINT scripts are executable and correctly formatted.

docker logs [container_id or name]

docker logs my-running-app

• Checking logs is often the first step in troubleshooting container issues, as they can reveal errors and other runtime information.

• Docker Stats: Provides a live stream of container resource usage statistics.

  docker stats

• Portainer: A GUI for managing Docker environments.
• cAdvisor: Google's container advisor that provides container users an understanding of the resource usage and performance characteristics of their running containers.

• Docker Official Documentation

• Overview: This book is great for both beginners and seasoned users. It covers fundamental concepts to advanced topics in Docker.

• Overview: Explores practical use cases and best practices for deploying Docker containers at scale.

• Overview: A comprehensive course that not only covers Docker but also includes Kubernetes and Swarm, making it ideal for those looking to expand beyond basic Docker usage.

• Overview: Focuses on the basics and is offered by Duke University, making it a solid foundation course.

• Link:
• Docker YouTube Channel
• Content: Offers a range of tutorials, talks, and demos to help you understand Docker from the ground up.

• Link:
• Join Docker Slack
• Purpose: Connect with Docker experts and enthusiasts around the world to share knowledge and solve problems.

• Tag:
• Docker Questions on Stack Overflow
• Purpose: A great place to find solutions to specific problems and engage with an active community of developers.