How to Run an Application In A Docker Container: A Step-by-Step Guide

Docker has revolutionized how we deploy applications by encapsulating them in lightweight, portable containers. In this guide, we'll walk through deploying a Python application using Docker, covering everything from creating a Dockerfile to running and cleaning up containers.

1. Understanding the Project Structure

Before diving into Docker, let’s understand the project structure:

• Dockerfile: The recipe for building your Docker image.
• requirements.txt: Lists the Python dependencies.
• my_docker_build_and_run.sh: A script to build and run the Docker container.
• my_docker_clean.sh: A script to stop and remove Docker containers and images.
• my_docker_terminal.sh: A script to access the running container's terminal.

2. Writing the Dockerfile

The Dockerfile is the heart of your Docker setup. Here's a breakdown of the provided Dockerfile:

FROM ubuntu:24.04

ARG APP_VERSION="1.0"
ARG APP_NAME="my-application-1"

# Install dependencies and python3-venv for virtual environment
RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    python3-venv

# Create a working directory
WORKDIR /app

# Copy dependency file
COPY src/requirements.txt requirements.txt

# Create a virtual environment and install dependencies
RUN python3 -m venv venv && \
    venv/bin/pip install --upgrade pip && \
    venv/bin/pip install -r requirements.txt

# Copy remaining files
COPY src/my-application-1.py ./

# Create the output and logs directories
RUN mkdir -p /app/output /app/logs

# Set the entry point with output redirection
ENTRYPOINT ["sh", "-c", "venv/bin/python my-application-1.py > /app/logs/logfile.trc 2>&1"]

Key Points:

• Base Image: FROM ubuntu:24.04 sets the base image to Ubuntu 24.04.
• Dependencies: Installs Python and necessary packages.
• Virtual Environment: Creates and uses a Python virtual environment to install dependencies.
• Working Directory: Sets /app as the working directory.
• Copy Files: Copies application files into the Docker image.
• Entrypoint: Specifies the command to run the application and redirect logs.

3. Building the Docker Image

Create a script named my_docker_build_and_run.sh to build and run the Docker container:

#!/bin/bash

APP_VERSION="1.0"
APP_NAME="my-application-1"

docker build -t ${APP_NAME}:${APP_VERSION} .

docker run -d \
  --name ${APP_NAME}-${APP_VERSION} \
  -v /home/dmitry/my_docker/my-application-1/output:/app/output \
  -v /home/dmitry/my_docker/my-application-1/logs:/app/logs \
  ${APP_NAME}:${APP_VERSION}

docker image ls ${APP_NAME}

docker ps --filter "name=${APP_NAME}_${APP_VERSION}"

Explanation:

• Build Image: docker build -t ${APP_NAME}:${APP_VERSION} . builds the Docker image.
• Run Container: docker run -d starts a container in detached mode.
• Volume Mounts: -v mounts local directories to the container, allowing persistent storage.
• Check Image and Container: Lists images and running containers.

4. Cleaning Up Docker Resources

Use my_docker_clean.sh to stop and remove Docker containers and images:

#!/bin/bash

APP_VERSION="1.0"
APP_NAME="my-application-1"

CONTAINER_ID=$(docker ps -a --filter "ancestor=${APP_NAME}:${APP_VERSION}" --format "{{.ID}}")

if [ -n "$CONTAINER_ID" ]; then
    echo "Stopping container $CONTAINER_ID..."
    docker stop "$CONTAINER_ID"
    echo "Removing container $CONTAINER_ID..."
    docker rm "$CONTAINER_ID"
fi

# Remove the image
IMAGE_ID=$(docker images --format '{{.Repository}}:{{.Tag}}' | grep ${APP_NAME}:${APP_VERSION})

if [ -n "$IMAGE_ID" ]; then
    echo "Removing image $IMAGE_ID..."
    docker rmi "$IMAGE_ID"
fi

Key Points:

• Stop Container: Stops the running container.
• Remove Container: Deletes the stopped container.
• Remove Image: Deletes the Docker image to free up space.

5. Accessing the Running Container

To access the container’s terminal, use my_docker_terminal.sh:

APP_VERSION="1.0"
APP_NAME="my-application-1"

docker exec -it ${APP_NAME}-${APP_VERSION} /bin/bash

Explanation:

docker exec -it: Opens an interactive terminal session inside the running container.

Conclusion

Deploying an application using Docker simplifies many aspects of software deployment, such as dependency management and environment consistency. By following these steps, you can effectively build, run, and manage your Dockerized applications.

Whether you’re deploying a simple Python script or a complex application, Docker provides a robust and scalable solution.