Containerization with Docker

In this lesson, we'll learn how to package your Elixir and Phoenix applications using Docker containers. This makes your deployments consistent and portable across different environments.

Think of Docker as a way to bundle your application and all its dependencies into a single, isolated package.

Let's define some core Docker terms:

• Image: A lightweight, standalone, executable package that includes everything needed to run a piece of software, including the code, a runtime, system tools, libraries, and settings.
• Container: A running instance of an image. It's an isolated process that shares the host OS kernel but runs in its own environment.
• Dockerfile: A text file that contains all the commands a user could call on the command line to assemble an image. It's your recipe for building an image.

Elixir and Phoenix applications benefit greatly from containerization:

• Consistent Environments: Ensure your app runs the same way from development to production, avoiding "it works on my machine" issues.
• Dependency Management: Easily manage Erlang/OTP, Elixir versions, and system-level dependencies.
• Portability: Deploy your containerized app on any system that runs Docker, from local machines to cloud servers.
• Isolation: Containers isolate your application, preventing conflicts with other software on the host system.

Before Dockerizing, let's have a simple Elixir script. We'll put this into a file named hello.exs. This script simply prints a greeting.

You can run this locally with elixir hello.exs.

A Dockerfile is like a set of instructions for building your Docker image. Here's a basic one for our simple Elixir script:

• FROM: Specifies the base image (e.g., an official Elixir image).
• WORKDIR: Sets the working directory inside the container.
• COPY: Copies files from your host machine into the container.
• CMD: Defines the default command to execute when a container starts.

Let's create a Dockerfile in the same directory as hello.exs:

FROM elixir:1.15.7-slim-bullseye selects a lean base image with Elixir 1.15.7. COPY . . copies everything from the current directory into the container's working directory. CMD ["elixir", "hello.exs"] runs our script.

With your Dockerfile and hello.exs ready, you can build your Docker image. Open your terminal in the same directory and run:

The -t my-elixir-app tags your image with a name for easy reference. The . tells Docker to look for the Dockerfile in the current directory.

Once the image is built, you can run a container from it:

This command starts a new container based on the my-elixir-app image. You should see the output "Hello from Elixir in a container!" printed to your terminal. Your Elixir application is now running in an isolated Docker container!

For real Phoenix applications, image size matters. Multi-stage builds allow you to use multiple FROM statements in your Dockerfile to create smaller, more secure images.

Typically, you'll have a "build" stage (where dependencies are fetched and compiled) and a "release" stage (which only copies the final compiled application and a minimal runtime). This significantly reduces the final image size.

Which Dockerfile instruction specifies the base image for building your container?

We've explored how Docker containerizes Elixir/Phoenix applications, providing consistency and portability. You learned about Docker images, containers, and how to define them using a Dockerfile. We covered building and running a basic Elixir app in a container and introduced multi-stage builds for optimized production images.

Next, you might explore Docker Compose for multi-service applications or deploying these containers to the cloud!