BUILD an AI App Using FastAPI and Dockerize It the Quickest Way Using docker init

Using Docker Init for FastAPI and Docker Integration

What is Docker init?

Why Use Docker init?

• Simplified Setup: Docker init automates the creation of Dockerfiles and Docker Compose configurations, reducing manual configuration errors.

• Best Practices: It incorporates best practices for your chosen application platform and environment settings, ensuring optimized Docker images.

• Time-Saving: Ideal for developers who want a fast and reliable way to containerize their applications without delving into complex Docker configurations.

Step-by-Step Guide

Step 1: Create a Project Directory

mkdir fastapi-ml-docker
cd fastapi-ml-docker

Step 2: Set Up a Virtual Environment

python -m venv venv
source venv/bin/activate  # On Windows, use `venv\\Scripts\\activate`

Step 3: Install Necessary Packages

pip install fastapi uvicorn transformers torch pillow

Step 4: Create Application Files

Directory Structure

fastapi-ml-docker/
├── app/
│   ├── __init__.py
│   ├── main.py
│   └── model.py
├── requirements.txt

app/__init__.py

app/main.py

# app/main.py

from fastapi import FastAPI, UploadFile, File
from fastapi.responses import JSONResponse
from PIL import Image
import io
from app.model import get_prediction

app = FastAPI()



@app.post("/predict")
async def predict(image: UploadFile = File(...), question: str = "How many cats are there?"):
    try:
        image_data = await image.read()
        image = Image.open(io.BytesIO(image_data))
        predicted_answer = get_prediction(image, question)
        return JSONResponse(content={"predicted_answer": predicted_answer})
    except Exception as e:
        return JSONResponse(content={"error": str(e)}, status_code=500)
    
@app.get("/")
async def root():
    return {"message": "Welcome to the FastAPI ML Docker app!"}

app/model.py

# app/model.py

from transformers import ViltProcessor, ViltForQuestionAnswering
import torch

processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-vqa")
model = ViltForQuestionAnswering.from_pretrained("dandelin/vilt-b32-finetuned-vqa")

def get_prediction(image, question):
    # Prepare inputs
    encoding = processor(image, question, return_tensors="pt")

    # Forward pass
    outputs = model(**encoding)
    logits = outputs.logits
    idx = logits.argmax(-1).item()
    predicted_answer = model.config.id2label[idx]
    return predicted_answer

Step 5: Create Requirements File

fastapi
uvicorn
transformers
torch
pillow

Step 6: Using Docker Init

1. Initialize Docker in Your Project Directory

docker init

2. Answer the Prompts

• Application Platform: Python

• Python Version: 3.10

• Port: 8000

• Command to Run Your App: uvicorn app.main:app --host 0.0.0.0 --port 8000

3. Review the Generated Files

Dockerfile

# syntax=docker/dockerfile:1

# Comments are provided throughout this file to help you get started.
# If you need more help, visit the Dockerfile reference guide at
# https://docs.docker.com/go/dockerfile-reference/

# Want to help us make this template better? Share your feedback here: https://forms.gle/ybq9Krt8jtBL3iCk7

ARG PYTHON_VERSION=3.10.9
FROM python:${PYTHON_VERSION}-slim as base

# Prevents Python from writing pyc files.
ENV PYTHONDONTWRITEBYTECODE=1

# Keeps Python from buffering stdout and stderr to avoid situations where
# the application crashes without emitting any logs due to buffering.
ENV PYTHONUNBUFFERED=1

WORKDIR /app

# Create a non-privileged user that the app will run under.
# See https://docs.docker.com/go/dockerfile-user-best-practices/
# ARG UID=10001
# RUN adduser \
#     --disabled-password \
#     --gecos "" \
#     --home "/nonexistent" \
#     --shell "/sbin/nologin" \
#     --no-create-home \
#     --uid "${UID}" \
#     appuser

# Download dependencies as a separate step to take advantage of Docker's caching.
# Leverage a cache mount to /root/.cache/pip to speed up subsequent builds.
# Leverage a bind mount to requirements.txt to avoid having to copy them into
# into this layer.
RUN --mount=type=cache,target=/root/.cache/pip \
    --mount=type=bind,source=requirements.txt,target=requirements.txt \
    python -m pip install -r requirements.txt

# Switch to the non-privileged user to run the application.
# USER appuser

# Copy the source code into the container.
COPY . .

# Expose the port that the application listens on.
EXPOSE 8000

# Run the application.
CMD uvicorn app.main:app --host 0.0.0.0 --port 8000

compose.yaml

# syntax=docker/dockerfile:1

# Comments are provided throughout this file to help you get started.
# If you need more help, visit the Dockerfile reference guide at
# https://docs.docker.com/go/dockerfile-reference/

# Want to help us make this template better? Share your feedback here: https://forms.gle/ybq9Krt8jtBL3iCk7

ARG PYTHON_VERSION=3.10.9
FROM python:${PYTHON_VERSION}-slim as base

# Prevents Python from writing pyc files.
ENV PYTHONDONTWRITEBYTECODE=1

# Keeps Python from buffering stdout and stderr to avoid situations where
# the application crashes without emitting any logs due to buffering.
ENV PYTHONUNBUFFERED=1

WORKDIR /app

# Create a non-privileged user that the app will run under.
# See https://docs.docker.com/go/dockerfile-user-best-practices/
# ARG UID=10001
# RUN adduser \
#     --disabled-password \
#     --gecos "" \
#     --home "/nonexistent" \
#     --shell "/sbin/nologin" \
#     --no-create-home \
#     --uid "${UID}" \
#     appuser

# Download dependencies as a separate step to take advantage of Docker's caching.
# Leverage a cache mount to /root/.cache/pip to speed up subsequent builds.
# Leverage a bind mount to requirements.txt to avoid having to copy them into
# into this layer.
RUN --mount=type=cache,target=/root/.cache/pip \
    --mount=type=bind,source=requirements.txt,target=requirements.txt \
    python -m pip install -r requirements.txt

# Switch to the non-privileged user to run the application.
# USER appuser

# Copy the source code into the container.
COPY . .

# Expose the port that the application listens on.
EXPOSE 8000

# Run the application.
CMD uvicorn app.main:app --host 0.0.0.0 --port 8000

.dockerignore

# Include any files or directories that you don't want to be copied to your
# container here (e.g., local build artifacts, temporary files, etc.).
#
# For more help, visit the .dockerignore file reference guide at
# https://docs.docker.com/go/build-context-dockerignore/

**/.DS_Store
**/__pycache__
**/.venv
**/.classpath
**/.dockerignore
**/.env
**/.git
**/.gitignore
**/.project
**/.settings
**/.toolstarget
**/.vs
**/.vscode
**/*.*proj.user
**/*.dbmdl
**/*.jfm
**/bin
**/charts
**/docker-compose*
**/compose*
**/Dockerfile*
**/node_modules
**/npm-debug.log
**/obj
**/secrets.dev.yaml
**/values.dev.yaml
LICENSE
README.md

Step 7: Build and Run Your Docker Container

docker compose up --build

Conclusion

Resources

• Vision-and-Language Transformer (ViLT) Model on Hugging Face

• Video Tutorial

• GitHub Repository