Understanding CMD and ENTRYPOINT in Dockerfiles

When working with Docker, two essential instructions in a Dockerfile are CMD and ENTRYPOINT. Both are used to specify the command that should be run within a container, but they serve different purposes and have distinct behaviors. This article will delve into the differences between CMD and ENTRYPOINT, their defaults, pros and cons, and provide multiple examples to help you understand their usage.

What is CMD in a Dockerfile?

The CMD instruction in a Dockerfile specifies the default command to run when a container starts. It is important to note that CMD can be overridden by providing a command at the end of the docker run command.

Syntax of CMD

There are three forms of the CMD instruction:

1. Shell form:

   CMD command param1 param2

2. Exec form:

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

3. Parameter form:

   CMD ["param1", "param2"]

Example of CMD

Consider the following Dockerfile:

FROM ubuntu:latest
CMD ["echo", "Hello, World!"]

When you build and run this Docker image, it will execute the echo "Hello, World!" command by default.

docker build -t my-echo-image .
docker run my-echo-image

Output:

Hello, World!

However, you can override the CMD instruction by providing a different command:

docker run my-echo-image echo "Hello, Docker!"

Output:

Hello, Docker!

What is ENTRYPOINT in a Dockerfile?

The ENTRYPOINT instruction in a Dockerfile specifies the command that will always be executed when the container starts. Unlike CMD, ENTRYPOINT cannot be overridden by providing a command at the end of the docker run command. Instead, any arguments provided will be passed to the ENTRYPOINT command.

Syntax of ENTRYPOINT

There are two forms of the ENTRYPOINT instruction:

1. Shell form:

   ENTRYPOINT command param1 param2

2. Exec form:

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

Example of ENTRYPOINT

Consider the following Dockerfile:

FROM ubuntu:latest
ENTRYPOINT ["echo"]

When you build and run this Docker image, it will execute the echo command with any arguments provided:

docker build -t my-entrypoint-image .
docker run my-entrypoint-image "Hello, World!"

Output:

Hello, World!

In this case, the ENTRYPOINT command (echo) cannot be overridden, but the arguments can be changed.

Combining CMD and ENTRYPOINT

You can use both CMD and ENTRYPOINT together in a Dockerfile. When used together, CMD provides default arguments to the ENTRYPOINT instruction.

Example of Combining CMD and ENTRYPOINT

Consider the following Dockerfile:

FROM ubuntu:latest
ENTRYPOINT ["echo"]
CMD ["Hello, World!"]

When you build and run this Docker image, it will execute the echo command with the default argument provided by CMD:

docker build -t my-combined-image .
docker run my-combined-image

Output:

Hello, World!

You can also override the CMD arguments by providing different arguments:

docker run my-combined-image "Hello, Docker!"

Output:

Hello, Docker!

Advanced Examples of CMD and ENTRYPOINT in Dockerfiles

To further illustrate the differences and use cases of CMD and ENTRYPOINT, let’s explore some advanced examples. These examples will demonstrate how to use these instructions in more complex scenarios, including multi-stage builds, scripts, and environment variables.

Example 1: Using CMD with Environment Variables

In this example, we’ll create a Dockerfile that uses CMD to run a script that reads environment variables.

# Stage 1: Build the application
FROM ubuntu:latest AS builder

# Install necessary packages
RUN apt-get update && apt-get install -y curl

# Create a script that uses environment variables
RUN echo '#!/bin/bash\n' > /app/start.sh && \
    echo 'echo "Hello, $NAME!"' >> /app/start.sh && \
    chmod +x /app/start.sh

# Stage 2: Create the final image
FROM ubuntu:latest

# Copy the script from the builder stage
COPY --from=builder /app/start.sh /app/start.sh

# Set the default environment variable
ENV NAME World

# Use CMD to run the script
CMD ["/app/start.sh"]

Build and run the Docker image:

docker build -t my-env-image .
docker run my-env-image

Output:

Hello, World!

Override the environment variable:

docker run -e NAME=Docker my-env-image

Output:

Hello, Docker!

Example 2: Using ENTRYPOINT with Arguments

In this example, we’ll create a Dockerfile that uses ENTRYPOINT to ensure a specific command is always executed, and CMD to provide default arguments.

# Use a base image
FROM ubuntu:latest

# Install necessary packages
RUN apt-get update && apt-get install -y curl

# Create a script that accepts arguments
RUN echo '#!/bin/bash\n' > /app/start.sh && \
    echo 'echo "Arguments: $@"' >> /app/start.sh && \
    chmod +x /app/start.sh

# Set the entry point to the script
ENTRYPOINT ["/app/start.sh"]

# Provide default arguments
CMD ["arg1", "arg2"]

Build and run the Docker image:

docker build -t my-entrypoint-args-image .
docker run my-entrypoint-args-image

Output:

Arguments: arg1 arg2

Override the default arguments:

docker run my-entrypoint-args-image custom1 custom2

Output:

Arguments: custom1 custom2

Example 3: Multi-Stage Build with CMD and ENTRYPOINT

In this example, we’ll create a multi-stage Dockerfile that builds a simple Go application and uses ENTRYPOINT and CMD to run it.

# Stage 1: Build the Go application
FROM golang:1.16 AS builder

# Set the working directory
WORKDIR /app

# Copy the Go source code
COPY main.go .

# Build the Go application
RUN go build -o myapp main.go

# Stage 2: Create the final image
FROM ubuntu:latest

# Copy the built application from the builder stage
COPY --from=builder /app/myapp /usr/local/bin/myapp

# Set the entry point to the application
ENTRYPOINT ["/usr/local/bin/myapp"]

# Provide default arguments
CMD ["--help"]

Create a simple Go application (main.go):

package main

import (
    "flag"
    "fmt"
)

func main() {
    help := flag.Bool("help", false, "Display help")
    name := flag.String("name", "World", "Name to greet")
    flag.Parse()

    if *help {
        fmt.Println("Usage: myapp [--name <name>]")
        return
    }

    fmt.Printf("Hello, %s!\n", *name)
}

Build and run the Docker image:

docker build -t my-go-app-image .
docker run my-go-app-image

Output:

Usage: myapp [--name <name>]

Provide custom arguments:

docker run my-go-app-image --name Docker

Output:

Hello, Docker!

Example 4: Using CMD and ENTRYPOINT with a Web Server

In this example, we’ll create a Dockerfile that sets up a simple Python web server using ENTRYPOINT and CMD.

# Use a base image
FROM python:3.9-slim

# Create a simple web server script
RUN echo 'from http.server import SimpleHTTPRequestHandler, HTTPServer\n' > /app/server.py && \
    echo 'import sys\n' >> /app/server.py && \
    echo 'port = int(sys.argv[1]) if len(sys.argv) > 1 else 8000\n' >> /app/server.py && \
    echo 'server = HTTPServer(("0.0.0.0", port), SimpleHTTPRequestHandler)\n' >> /app/server.py && \
    echo 'print(f"Serving on port {port}")\n' >> /app/server.py && \
    echo 'server.serve_forever()\n' >> /app/server.py

# Set the entry point to the Python interpreter
ENTRYPOINT ["python", "/app/server.py"]

# Provide the default port
CMD ["8000"]

Build and run the Docker image:

docker build -t my-web-server-image .
docker run -p 8000:8000 my-web-server-image

Output:

Serving on port 8000

Override the default port:

docker run -p 8080:8080 my-web-server-image 8080

Output:

Serving on port 8080

Defaults, Pros, and Cons

CMD

• Default: If no CMD instruction is specified, the default command is inherited from the base image.
• Pros:
• Easy to override with docker run command.
• Suitable for providing default arguments to ENTRYPOINT.
• Cons:
• Can be completely overridden, which might not be desirable in some cases.

ENTRYPOINT

• Default: If no ENTRYPOINT instruction is specified, the default entry point is inherited from the base image.
• Pros:
• Ensures that a specific command is always executed.
• Can be combined with CMD to provide default arguments.
• Cons:
• Less flexible as the command cannot be overridden, only the arguments can be changed.

Conclusion

In summary, CMD and ENTRYPOINT are both used to specify commands to run within a Docker container, but they have different behaviors and use cases. CMD is more flexible and can be easily overridden, making it suitable for providing default commands or arguments. ENTRYPOINT, on the other hand, ensures that a specific command is always executed, providing more control over the container’s behavior.

Some of these advanced examples demonstrate how to use CMD and ENTRYPOINT in various scenarios, including working with environment variables, passing arguments, multi-stage builds, and setting up web servers. By understanding these advanced use cases, you can create more flexible and powerful Docker images tailored to your specific needs.