✅ Dockerfile + Deployment Guide for Your AI Chatbot API (DeepSeek Edition)

2024-12-26

🔍 Introduction

With the rise of powerful local large language models (LLMs) like DeepSeek, developers are increasingly deploying their own chatbot APIs for privacy, control, and cost-efficiency. But to ensure scalability, portability, and easy updates, Docker is the go-to tool for containerizing and deploying such applications.

This guide provides a step-by-step walkthrough for containerizing your Python-based chatbot API (e.g., chatbot_api.py) and deploying it via Docker, Docker Compose, and optionally to cloud environments like AWS EC2, DigitalOcean, or VPS.

You’ll also learn how to:

Write a production-ready Dockerfile
Connect your Docker container to a local DeepSeek model via Ollama
Set environment variables
Configure HTTPS and reverse proxy via NGINX
Deploy to cloud with persistence and logs
Auto-restart on crash or reboot

✅ Table of Contents

Why Use Docker for Chatbot Deployment?
Project Prerequisites and Tools
Directory Layout Overview
Creating a Production-Ready Dockerfile
Creating a docker-compose.yml
Environment Variables via .env
Running Locally with Ollama (DeepSeek)
Setting Up NGINX Reverse Proxy (Optional)
Hosting on Cloud/VPS
Debugging and Logs
Auto-Startup with Systemd or Watchtower
Security Best Practices
Conclusion + Full Download Pack

1. 🧱 Why Use Docker for Deployment?

Benefits	Explanation
Portability	Run on any OS with Docker (Linux, Windows, macOS)
Reproducibility	Same environment everywhere—no “works on my machine” issues
Easy updates	Just rebuild and redeploy in seconds
Isolation	Keeps dependencies separate
Infrastructure-ready	Easily works with CI/CD, cloud, Kubernetes

2. ⚙️ Prerequisites and Tools

You’ll need:

A backend like chatbot_api.py built with FastAPI or Flask
Docker installed: Install Docker
(Optional) Docker Compose
Ollama with DeepSeek running locally or network-accessible
A Linux VPS (Ubuntu preferred) if deploying remotely

3. 📁 Project Directory Structure

arduino
chatbot-docker/
├── app/
│   ├── chatbot_api.py
│   ├── requirements.txt
├── Dockerfile
├── docker-compose.yml
├── .env
└── nginx/
    └── default.conf

4. 🐳 Creating a Dockerfile

Here’s a production-grade Dockerfile:

dockerfile
# Use official lightweight Python base image
FROM python:3.10-slim

# Set working directory
WORKDIR /app

# Copy app files
COPY app/ /app/

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

# Expose API port
EXPOSE 8000

# Set environment variables (can also use .env)
ENV HOST=0.0.0.0
ENV PORT=8000

# Run FastAPI app
CMD ["uvicorn", "chatbot_api:app", "--host", "0.0.0.0", "--port", "8000"]

5. 🧩 Creating `docker-compose.yml`

This helps manage multiple services (e.g., chatbot + Ollama + NGINX).

yaml
version: '3.9'services:
  chatbot:
    build: .
    ports:
      - "8000:8000"
    environment:
      - MODEL_NAME=deepseek-chat
      - API_KEY=secure123
    depends_on:
      - ollama
    restart: always

  ollama:
    image: ollama/ollama
    volumes:
      - ollama_data:/root/.ollama
    ports:
      - "11434:11434"volumes:
  ollama_data:

You must run ollama pull deepseek-chat on the host at least once before starting the containerized version.

6. 🧾 `.env` File (Optional)

Use this to store secrets or config cleanly:

ini
MODEL_NAME=deepseek-chatAPI_KEY=secure123

In your docker-compose.yml:

yaml
env_file:
  - .env

In Python (chatbot_api.py):

python
import os
model = os.getenv("MODEL_NAME")

7. 🚀 Running the App Locally

Run everything with one command:

bash
docker compose up --build -d

Check logs:

bash
docker compose logs -f chatbot

Test it:

bash
curl http://localhost:8000/chat -X POST \
  -H "Content-Type: application/json" \
  -d '{"user_id":"dev","message":"Hello"}'

You should get a JSON reply from DeepSeek.

8. 🌐 Setting Up NGINX Reverse Proxy (Optional)

`nginx/default.conf`

nginx
server {  listen 80;  server_name yourdomain.com;  location / {    proxy_pass http://chatbot:8000;    proxy_set_header Host $host;    proxy_set_header X-Real-IP $remote_addr;
  }
}

Add to Compose

yaml
  nginx:
    image: nginx
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf
    ports:
      - "80:80"
    depends_on:
      - chatbot

You now have http://yourdomain.com serving your API!

9. 🖥️ Hosting on Cloud/VPS

Steps:

Spin up a server (Ubuntu 22.04 recommended)
Install Docker and Docker Compose
Upload your project via SCP or Git
Run docker compose up -d
(Optional) Set up domain and HTTPS with Caddy or Certbot

10. 🪵 Debugging and Logs

bash
docker logs chatbot
docker exec -it chatbot bash
docker top chatbot

Add log files:

yaml
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

11. 🔁 Auto-Restart and Systemd

Already handled in docker-compose.yml with:

yaml
restart: always

For system-level resilience:

bash
sudo systemctl enable docker

Or use Watchtower to auto-update containers:

yaml
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

12. 🔐 Security Best Practices

Concern	Recommendation
Public API abuse	Add token or API key headers
DoS prevention	Rate limit via NGINX or API gateway
HTTPS	Use Caddy or Certbot with NGINX
Isolation	Run Docker with non-root user (optional)
Logging	Sanitize logs and rotate them