Seamlessly Scaling Elixir Applications using Docker: A Comprehensive Guide

One of the key challenges for modern-day developers, including those who hire Elixir developers, is ensuring their applications run seamlessly across all platforms without any dependency-related issues. Docker comes into play here, providing an open-source platform used for automating the deployment, scaling, and management of applications via containerization. Docker packages an application and its dependencies into a virtual container that can run on any Linux server, thereby eliminating the notorious “it works on my machine” problem.

On the other hand, Elixir, a go-to choice for companies looking to hire Elixir developers, is a functional, concurrent, general-purpose programming language running on the Erlang virtual machine (BEAM). Elixir provides efficient tooling and an extensible design, making it perfect for building scalable and maintainable applications.

So, how can we integrate Docker with Elixir for scalable deployments? Especially when you hire Elixir developers, what is the process they need to understand and follow? This blog post will guide you through this procedure with practical examples.

1. Prerequisites

Before we begin, ensure you have the following:

1. Basic understanding of Docker and Elixir.
2. Docker installed on your local system.
3. Elixir and Phoenix installed on your local system.

2. Creating an Elixir Application

Let’s begin by creating a new Elixir application using the Phoenix Framework. Phoenix is a productive web framework that does not compromise speed and maintainability.

```bash
mix phx.new my_app
cd my_app
```

Follow the prompts and generate your new Elixir application.

3. Dockerizing the Elixir Application

Now, let’s start dockerizing our application. To do so, we need to create a Dockerfile. This file contains all the commands a user could call on the command line to assemble an image.

Create a Dockerfile in the root directory and open it in your preferred text editor:

```bash
touch Dockerfile
```

Copy and paste the following into your Dockerfile:

```dockerfile
FROM elixir:1.12.2

# create and set the app directory as the working directory
RUN mkdir /app
WORKDIR /app

# install hex package manager
RUN mix local.hex --force

# install the latest phoenix 
RUN mix archive.install hex phx_new 1.6.2 --force

# install npm
RUN apt-get update && \
  apt-get upgrade -y && \
  apt-get install -y nodejs npm

# copy everything from the current directory to the /app in the container
COPY . .

# compile the project
RUN mix do compile

CMD ["/app/entrypoint.sh"]
```

This Dockerfile instructs Docker to do the following:

1. Start from the official Elixir image.
2. Make and set the ‘/app’ directory as the working directory.
3. Install the Hex package manager, which is necessary to get the Phoenix framework and other dependencies.
4. Install the Phoenix framework.
5. Install Node.js and npm, which are necessary for Phoenix to compile static assets.
6. Copy the entire current directory into our ‘/app’ directory on the Docker image.
7. Compile the project.
8. Set the entry point for our application.

Now let’s create the `entrypoint.sh` file as mentioned in the Dockerfile:

```bash
touch entrypoint.sh
```

Make it executable:

```bash
chmod +x entrypoint.sh
```

Open `entrypoint.sh` in your preferred text editor and copy the following script into it:

```bash
#!/bin/sh

# wait for Postgres to start
sleep 10

# Run migrations
mix ecto.create
mix ecto.migrate

# Start the phoenix server
mix phx.server
```

4. Building the Docker Image

With the Dockerfile ready, you can now build the Docker image. Navigate to the root directory where your Dockerfile resides and run the following command:

```bash
docker build -t my_app:1.0 .
```

The `-t` option allows you to tag your image so it’s easier to find later using the `docker images` command.

5. Running the Docker Container

With the Docker image successfully built, you can now run your Elixir application inside a Docker container. Use the following command to create and start a Docker container:

```bash
docker run -p 4000:4000 my_app:1.0
```

You should now have your Elixir application running inside a Docker container, accessible at `localhost:4000`.

6. Making it Scalable

The beauty of Docker, which becomes even more apparent when you hire Elixir developers, is that it allows for effortless scaling of applications. With Docker Compose, you can manage a multi-container application, enabling scaling across multiple containers. This proves to be especially ideal for various environments such as development, testing, and staging. When you hire Elixir developers, they can leverage this inherent scalability of Docker, thereby efficiently enhancing your application’s performance and adaptability.

First, let’s create a `docker-compose.yml` file in our root directory:

```bash
touch docker-compose.yml
```

Edit the `docker-compose.yml` file as follows:

```yml
version: "3.8"

services:
  web:
    build: .
    ports:
      - 4000:4000
    depends_on:
      - db
    volumes:
      - .:/app

  db:
    image: postgres:13
    environment:
      POSTGRES_PASSWORD: postgres
```

In this `docker-compose.yml` file, we define two services: `web` and `db`. The `web` service builds from the Dockerfile in the current directory and maps port 4000 on the host to port 4000 in the container. The `db` service uses the official Postgres image and sets a Postgres password.

You can scale your services using the `docker-compose up –scale` command. For example:

```bash
docker-compose up --scale web=3
```

This will start three instances of the `web` service, allowing you to handle more traffic.

Conclusion

In this post, we’ve illustrated how you can Dockerize an Elixir application and scale it using Docker Compose. Docker is a powerful tool that guarantees your application runs identically in different environments, making it easier for your team, particularly if you hire Elixir developers. Elixir, on the other hand, brings functionality and scalability, ensuring your application can handle high traffic volumes. By combining the strengths of Docker and Elixir, you can build robust, scalable web applications, further simplifying the job for your Elixir developers.