Skip to main content

Dockerfiles

A Dockerfile allows you to define how Docker builds your container image by specifying the steps needed to set up your environment. In this guide, you will create a Dockerfile that customizes your own Docker image and sets up an entrypoint script to run when the container starts.

Create a Dockerfile​

To get started, create a new file called Dockerfile and add the following content:

FROM alpine:latest
COPY start.sh /
RUN chmod +x /start.sh
ENTRYPOINT ["/start.sh"]
  • The FROM command tells Docker to start building the image from the alpine:latest base image, which is a minimal Linux distribution.
  • The COPY command copies your start.sh script from your local machine into the container.
  • The RUN command ensures that your script is executable inside the container.
  • The ENTRYPOINT command specifies which command should be run when the container starts.

The entrypoint script​

Now, create a file called start.sh with the following content:

#!/bin/sh
echo "Container is running!"

This script simply outputs a message when the container starts. You can customize the script to run any other commands you want your container to execute.

Why use an entrypoint script?​

  • Customization: The entrypoint allows you to control what the container does when it starts. This can include starting services, setting up configurations, or running tasks.
  • Reusability: By using an entrypoint script, you make your containers more flexible and executable, allowing them to be reused across different environments and applications.
  • Automation: It prevents containers from exiting immediately after startup, especially useful for long-running services.

Build the Docker image​

Now that you've created your Dockerfile and script, it's time to build your Docker image. Run the following command in the directory where your Dockerfile is located:

docker image build -t my-custom-image .

This will create an image named my-custom-image based on the Dockerfile in the current directory.

Why build a custom image?​

  • Package Dependencies: Custom images allow you to bundle specific software, libraries, and configurations required for your application, ensuring everything is available in the environment.
  • Portability: Once built, the image can be reused across multiple environments without the need for additional setup.
  • Reliability: Building a custom image ensures your application runs consistently, reducing potential issues caused by different environments or missing dependencies.

Run the image​

To test your new Docker image, run the following command:

docker run my-custom-image

You should see the output from the start.sh script:

Container is running!

This demonstrates that Docker can use your custom image and automatically execute the entrypoint script.

Summary​

By using Dockerfiles and entrypoint scripts, you can build customized and reusable containers that include all the software, configurations, and commands necessary to run your applications. This makes your deployments simpler, more consistent, and easily sharable across teams and environments.