Lab 5: Containerization with Docker

Lab Overview

What You'll Do: Install Docker, understand containerization basics, and containerize your Flask MLOps service to prepare for cloud deployment

Lab Collaborators:

• Edward Lampoh - Software Developer & Collaborator
• Oluwafemi Adebayo, PhD - Academic Professor & Collaborator

Prerequisites Check

Before starting Lab 5, ensure you have:

• ✅ Working Flask MLOps service from Lab 2
• ✅ Passing tests from Lab 3
• ✅ GitHub Actions pipeline from Lab 4
• ✅ Flask service runs locally on port 5001

Part A: Understanding Docker

Learn what Docker is and why it's essential for modern application deployment

1. What is Docker?

Docker is a platform that packages your application and all its dependencies into a standardized unit called a container.

2. Why Use Docker?

The "Works on My Machine" Problem:

• ❌ Your Flask app works on your laptop but breaks on the server
• ❌ Different Python versions cause issues
• ❌ Missing dependencies or libraries
• ❌ Environment variable conflicts

Docker Solution:

• ✅ Package your app with exact Python version
• ✅ Include all dependencies
• ✅ Run the same container anywhere
• ✅ Consistent behavior across development, testing, and production

3. Key Docker Concepts

Part B: Install Docker

Get Docker Desktop installed on your computer

1. Install Docker Desktop

All Platforms:

1. Go to docker.com/products/docker-desktop
2. Download Docker Desktop for your operating system
3. Install with default settings
4. Start Docker Desktop (it will run in the background)

2. Verify Installation

Open a terminal and run:

# Check Docker version
docker --version

# Check Docker is running
docker ps

# Test with hello-world container
docker run hello-world

Part C: Containerize Flask MLOps Service

Create a Docker container for your Flask service

1. Create Dockerfile

Your repository already includes a Dockerfile in the mlops-service/ directory. Let's understand what it does:

View the Dockerfile:

Mac/Linux:

cd mlops-service
cat Dockerfile

Windows (Command Prompt):

cd mlops-service
type Dockerfile

Windows (PowerShell):

cd mlops-service
Get-Content Dockerfile

Understanding each line:

# Start from official Python 3.11 image
FROM python:3.11-slim

# Set working directory inside container
WORKDIR /app

# Copy requirements file
COPY requirements.txt .

# Install Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose port 5001 (Flask runs on this port)
EXPOSE 5001

# Command to run when container starts
CMD ["python", "app.py"]

2. Create .dockerignore File

Just like .gitignore, we need a .dockerignore file to exclude unnecessary files from the Docker image.

Check if .dockerignore exists:

Mac/Linux:

# In mlops-service directory
ls -la .dockerignore

Windows (Command Prompt):

REM In mlops-service directory
dir .dockerignore

Windows (PowerShell):

# In mlops-service directory
ls .dockerignore

The .dockerignore file should contain:

# Virtual environment
venv/
__pycache__/
*.pyc
*.pyo
*.pyd

# Environment files
.env
.env.local

# Test files
test_*.py
tests/
*.pytest_cache

# Git
.git/
.gitignore

# IDE
.vscode/
.idea/
*.swp

# Documentation
README.md
*.md

3. Build Docker Image

Build your first Docker image (works on all platforms):

# Make sure you're in the mlops-service directory
cd mlops-service

# Build the Docker image
# -t names the image "mlops-service"
# . means use current directory as build context
docker build -t mlops-service .

What happens during the build:

• 1. Docker downloads the Python 3.11 base image
• 2. Creates a working directory
• 3. Installs all Python dependencies from requirements.txt
• 4. Copies your Flask application code
• 5. Creates a complete image ready to run

Verify the image was created:

# List Docker images
docker images

# You should see mlops-service in the list

4. Run Docker Container

Start your containerized Flask service:

Mac/Linux:

# Run the container
docker run -d \
  --name mlops-container \
  -p 5001:5001 \
  -e DATABASE_URL="your_database_url_here" \
  -e FLASK_ENV=development \
  mlops-service

Windows (Command Prompt):

REM Run the container
docker run -d ^
  --name mlops-container ^
  -p 5001:5001 ^
  -e DATABASE_URL="your_database_url_here" ^
  -e FLASK_ENV=development ^
  mlops-service

Windows (PowerShell):

# Run the container
docker run -d `
  --name mlops-container `
  -p 5001:5001 `
  -e DATABASE_URL="your_database_url_here" `
  -e FLASK_ENV=development `
  mlops-service

Explanation:

• -d: Run in detached mode (background)
• --name: Give container a friendly name
• -p 5001:5001: Map port 5001 from container to your computer
• -e: Set environment variables
• mlops-service: The image to run

Check if container is running:

# List running containers
docker ps

# You should see mlops-container in the list

5. Test Containerized Service

Test the health endpoint:

curl http://localhost:5001/health

You should see:

{
  "status": "healthy",
  "service": "mlops-service",
  "timestamp": "2024-01-15T10:30:00.000000",
  "monitoring": "prometheus"
}

Test Prometheus metrics:

curl http://localhost:5001/metrics

6. Test with Next.js Application

Now test that your Next.js app can communicate with the containerized Flask service:

1. Make sure the Docker container is running (docker ps)
2. In a new terminal, start your Next.js app: npm run dev
3. Go to http://localhost:3000
4. Chat with the AI
5. Check http://localhost:5001/metrics to see if new metrics appear

Part D: Docker Container Management

Learn essential Docker commands for managing your containers

1. Essential Docker Commands

View container logs:

# View logs from your container
docker logs mlops-container

# Follow logs in real-time (like tail -f)
docker logs -f mlops-container

Stop the container:

docker stop mlops-container

Start the container again:

docker start mlops-container

Restart the container:

docker restart mlops-container

Remove the container:

# Stop first, then remove
docker stop mlops-container
docker rm mlops-container

Remove the image:

docker rmi mlops-service

2. Debugging Containers

Execute commands inside a running container:

Mac/Linux:

# Open a shell inside the container
docker exec -it mlops-container /bin/bash

# Once inside, you can:
# - Check files: ls -la
# - View environment: env
# - Test Python: python --version
# - Exit: exit

Windows:

REM Open a shell inside the container
docker exec -it mlops-container /bin/bash

REM Once inside, you can:
REM - Check files: ls -la
REM - View environment: env
REM - Test Python: python --version
REM - Exit: exit

View container resource usage:

docker stats mlops-container

Inspect container details:

docker inspect mlops-container

Part E: Docker Compose (Optional)

Use docker-compose for easier container management

1. What is Docker Compose?

Docker Compose is a tool for defining and running Docker applications using a YAML configuration file. Instead of typing long docker commands, you define everything in a file.

2. Create docker-compose.yml

Your repository already includes a docker-compose.yml file in the mlops-service/ directory.

View the file:

Mac/Linux:

cat mlops-service/docker-compose.yml

Windows (Command Prompt):

type mlops-service\docker-compose.yml

Windows (PowerShell):

Get-Content mlops-service/docker-compose.yml

Understanding the configuration:

version: '3.8'

services:
  mlops-service:
    build: .
    container_name: mlops-container
    ports:
      - "5001:5001"
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - FLASK_ENV=development
      - FLASK_DEBUG=True
    restart: unless-stopped
    volumes:
      - ./logs:/app/logs

3. Create .env File for Docker Compose

Docker Compose can read environment variables from a .env file.

Your mlops-service/.env should have:

# Database Configuration
DATABASE_URL=your_neon_database_url_here

# Flask Configuration
FLASK_ENV=development
FLASK_DEBUG=True

# Service Configuration
SERVICE_PORT=5001

4. Use Docker Compose

Start the service with Docker Compose (same on all platforms):

# Navigate to mlops-service directory
cd mlops-service

# Build and start the container
docker-compose up -d

# -d runs in detached mode (background)

View logs:

docker-compose logs -f

Stop the service:

docker-compose down

Rebuild and restart after code changes:

docker-compose up -d --build

Troubleshooting

Lab 5 Summary - What You Built

Congratulations! You've successfully containerized your Flask MLOps service. Here's what you accomplished:

✅ Docker Skills Gained

• Docker Fundamentals: Understanding containers, images, and Dockerfiles
• Containerization: Packaged Flask service with all dependencies
• Container Management: Start, stop, debug, and monitor containers
• Docker Compose: Simplified container orchestration (optional)

🚀 What You Can Now Do

• Consistent Environment: Flask service runs the same everywhere
• Easy Deployment: Ready to deploy to any cloud platform
• Isolated Service: No conflicts with other applications
• Professional Workflow: Industry-standard containerization

🎯 Why This Matters

You've now containerized your Flask MLOps service, which is the first step toward cloud deployment. In upcoming labs, you'll deploy this container to AWS, Google Cloud, or Azure. Your Next.js app will stay on Vercel (no containerization needed), while your Flask service runs in the cloud.

📝 Key Takeaways

• Containers solve the "works on my machine" problem
• Dockerfile defines how to build your container image
• Docker images are blueprints, containers are running instances
• Docker Compose simplifies multi-container applications
• Only the Flask service needs containerization (Next.js stays on Vercel)