Docker 배포 : 쉽게 시작하기Docker Deployment: Getting Started the Easy Way

Deploying with Docker

Let’s look at how to deploy Docker to a server.

• Manual deployment
• Watchtower
• Building CI/CD with AWS CodePipeline

Creating a Docker Image

API Code

First, let’s write the API server code to deploy. It’s simple FastAPI code that returns a string. We’ll put it in run.py.

project/
└── run.py (new file)

from fastapi import FastAPI
from fastapi.responses import PlainTextResponse

app = FastAPI()

@app.get("/")
def health(response_class=PlainTextResponse):
    return "Hello Docker Container"

Writing the Dockerfile

Next, let’s write the Dockerfile used to build the Docker image.

project/
├── Dockerfile (new file)
└── run.py

FROM python:3.12-alpine

RUN pip install "fastapi[standard]"

WORKDIR /app

COPY . .

EXPOSE 8000

CMD ["uvicorn", "run:app", "--host", "0.0.0.0", "--port", "8000"]

Building the Docker Image

Build the image from the Dockerfile we wrote. The -t option gives the image a tag, which we’ll use later when pushing the image to Docker Hub.

$ docker build -t tiaz0128/fast-api .

Signing Up at docker.com

Sign up at docker.com and log in. The Username you create when signing up is used on Docker Hub (Docker Hub), where Docker images are stored.

> Docker Hub, which works a lot like GitHub

Docker Hub: Pushing the Image

Docker Hub is a repository for the Docker images you build. In the repositories tab, create a repository under your Username as the namespace.

Here we’ll create a Public repository named fast-api. For reference, each free account gets one Private repository.

> Docker Hub: a remote registry for images

Docker login

Let’s push the image we built to Docker Hub. You can log in with the email or Username you registered on docker.io.

$ docker login docerk.io

Username: tiaz0128.dev@gmail.com
Password: ****

Login Succeeded

Pushing the Built Image

To push an image to Docker Hub, you push it based on the Username registered on docker.io and the repository name.

On Docker Hub you generally have to follow the Username/repository format. That’s because Docker Hub manages namespaces per user.

$ docker push <Username>/<repository>[:tag]

$ docker push tiaz0128/fast-api

Docker tag

The tag command adds or changes a tag on a Docker image. The basic usage is:

$ docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]

$ docker tag fast-api:1.0 tiaz0128/fast-api

• SOURCE_IMAGE : the name and tag of the source image you want to retag
• TARGET_IMAGE : the new image name and tag
• [:TAG] : optional; specifies a tag. If omitted, the default latest is used

Manual Docker Deployment

Any server environment will do. Here I used Amazon EC2 (Amazon Linux 2023 AMI).

Installing Docker

First, install Docker on the server.

$ sudo yum update -y

$ sudo yum -y install docker

Daemon & Permissions

After installing, start the daemon. If needed, adjust the user’s group permissions: add the user (ec2-user) to the docker group. This lets you run docker commands without sudo.

$ sudo systemctl restart docker

$ sudo usermod -a -G docker ec2-user

Docker pull

Log in to Docker Hub and pull the image you built.

$ docker login docerk.io

Username: tiaz0128.dev@gmail.com
Password: ****

Login Succeeded

$ docker pull tiaz0128/fast-api

Docker run & stop

Run a container from the pulled image. If a container is already running, you can deploy manually by stopping it and starting a new one.

$ docker run -it -d --name fast-api --rm tiaz0128/fast-api

The Problem with Manual Deployment

So far we’ve deployed a Docker container by hand. At this point, a question comes to mind.

What happens when the code changes and a new image is built?

Just like before, we’d have to pull the image and restart the container by hand every single time.

There are several ways to solve this, but here we’ll try the simple Watchtower.

Watchtower

Watchtower periodically checks for image updates and, when a new version is available, updates the container automatically. Just keep a Watchtower container running: it pulls the image, gracefully shuts down the existing container, and restarts it with the same options it was originally deployed with.

Basic Watchtower Usage

The command below monitors the container named fast-api running on the EC2 instance. You can also monitor several containers at once.

$ docker ps

CONTAINER ID   IMAGE                        NAMES
dad54e31fb2b   tiaz0128/fast-api:latest     fast-api

$ docker run -d \
  --name watchtower \
  -v /var/run/docker.sock:/var/run/docker.sock \
  containrrr/watchtower \
  fast-api

Key Watchtower Options

• --interval : how often to check for updates, in seconds. default: 86400 (24H)
• --schedule : a 6-field cron expression. Can’t be combined with --interval
• --run-once : tries to update the listed containers just once, then Watchtower exits

Wrapping Up

We pushed the built image to Docker Hub, deployed it to an EC2 instance with Docker, first by hand and then automatically with Watchtower.

Even with Watchtower, it’s still a hassle to deploy the git code and the Docker image separately. The methodology that emerged to solve this is GitOps.

Its core idea is to treat the git repository as the single source of truth (single source of truth), the reference point for everything.

> Ttabae: [Ttabae GitOps] 0. Course Introduction

What’s Next

Next, let’s look at a better way to deploy with Docker that handles both the git deployment and the Docker deployment in one go! Let’s learn how to go about Building CI/CD with AWS CodePipeline. 😊

References

• [Ttabae GitOps] Learn GitOps Easily in One Go! (Korean)