Dockerizing Your Gradio App for Consistent Endpoints; A Seamless Deployment

When developing machine learning applications, ease of deployment is often overlooked in favor of model accuracy and performance. However, an ML model is only as valuable as its accessibility. Enter Gradio, an intuitive library that allows developers to create user-friendly web interfaces for their ML models. But while Gradio makes UI development easy, deployment and scaling remain a challenge—unless you containerize your app with Docker.

One common frustration when using share=True in Gradio is that it generates a random URL each time the app is deployed. This makes it difficult to maintain a consistent endpoint for users or external integrations. By dockerizing the Gradio app, we solve this issue by providing a fixed and stable local or cloud-based URL for deployment.

In this post, we’ll walk through how to dockerize a Gradio app and make deployment seamless with the help of run_docker.py, a script that automates building, running, and managing your container with minimal effort.

📌 Access the full repository here.

Why Docker?

Docker is an essential tool for modern application development because:

• It provides consistency—no more “it works on my machine” issues.
• It enables scalability—easily move from local testing to cloud deployment.
• It simplifies dependency management—no need to worry about Python versions or missing libraries.
• It resolves the random URL issue in Gradio’s share=True mode by providing a stable and predictable deployment URL.

By dockerizing a Gradio app, we can ensure that our sentiment analysis model runs smoothly, no matter where it’s deployed.

Setting Up the Gradio App

We’ll use a sentiment analysis model powered by Hugging Face’s Transformers. Here’s the core Python script (app.py):

from transformers import pipeline
import gradio as gr

# Load sentiment analysis model
sentiment_model = pipeline("sentiment-analysis")

def analyze_sentiment(text):
    """Analyzes the sentiment of the given text."""
    result = sentiment_model(text)[0]
    return f"Sentiment: {result['label']} (Confidence: {result['score']:.2f})"

# Define Gradio UI
iface = gr.Interface(
    fn=analyze_sentiment,
    inputs="text",
    outputs="text",
    title="Sentiment Analysis",
    description="Enter a sentence and get its sentiment prediction."
)

# Launch app on 0.0.0.0 for Docker compatibility
iface.launch(server_name="0.0.0.0", server_port=7860)

This script loads a pre-trained sentiment analysis model and provides an interactive UI via Gradio. Unlike share=True, which generates a new temporary URL each time the app starts, this setup ensures that the application is always available at a consistent URL like http://localhost:7860.

Dockerizing the Gradio App

Step 1: Create a Dockerfile

A Dockerfile defines the environment for our application. Here’s what it looks like:

FROM python:3.9-slim

# Set working directory
WORKDIR /workspace

# Upgrade pip and install dependencies
RUN python -m pip install --upgrade pip && \
    pip --version

# Copy requirements and install dependencies
COPY requirements.txt .
RUN python -m pip install --no-cache-dir -r requirements.txt

# Copy application files
COPY app.py .

# Expose the port the app runs on
EXPOSE 7860

# Run the application
CMD ["python", "app.py"] 

This Dockerfile ensures:

• The app runs in a lightweight Python 3.9 environment.
• Dependencies are installed using requirements.txt.
• The app is accessible on port 7860.

Step 2: Create requirements.txt

List your dependencies in a requirements.txt file:

transformers==4.36.1
gradio==3.41.2
torch==2.1.0 

Step 3: Build and Run the Docker Container

Manually, you would run these commands:

docker build -t sentiment-analysis-app .
docker run -d -p 7860:7860 --name sentiment-container --restart unless-stopped sentiment-analysis-app 

But why do it manually when we can automate everything?

Making Deployment Extra Easy with run_docker.py

To simplify container management, we use run_docker.py, a script that automates building, running, stopping, and restarting our container.

Key Features of run_docker.py

• Automatically builds the Docker image if it doesn’t exist.
• Stops and removes any existing container before starting a new one.
• Ensures the container runs with a restart policy, keeping it alive even if it crashes.

Here’s how it works:

import subprocess
import time

def run_command(command):
    """Executes a command and streams output."""
    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
    for line in process.stdout:
        print(line.strip())
    process.wait()
    return process.returncode

def main():
    """Builds and runs the Docker container."""
    print("\n=== Building Docker Image ===")
    if run_command(["docker", "build", "-t", "sentiment-analysis-app", "."]) != 0:
        print("Error: Failed to build Docker image.")
        return 1
    
    print("\n=== Stopping Existing Container ===")
    run_command(["docker", "stop", "sentiment-container"])
    run_command(["docker", "rm", "sentiment-container"])

    print("\n=== Starting New Container ===")
    if run_command([
        "docker", "run", "-d",
        "--name", "sentiment-container",
        "-p", "7860:7860",
        "--restart", "unless-stopped",
        "sentiment-analysis-app"
    ]) != 0:
        print("Error: Failed to start the container.")
        return 1

    time.sleep(2)
    print("\n=== App is Running at http://localhost:7860 ===")
    return 0

if __name__ == "__main__":
    exit(main())

With this setup, deploying a Gradio sentiment analysis app is as easy as running one Python script:

python run_docker.py 

This will:

1. Build the Docker image (if not already built).
2. Stop and remove any previous container.
3. Start a new container with auto-restart enabled.
4. Provide a link to access the running app.

Next Steps

• Deploy this container on a cloud service (AWS, GCP, DigitalOcean).
• Use Kubernetes for scaling beyond a single instance.
• Add logging & monitoring (e.g., Prometheus, Grafana).

By combining Gradio, Docker, and run_docker.py, we create an efficient and user-friendly workflow for ML app deployment. Now, there’s no excuse for keeping your models locked inside Jupyter notebooks; dockerize them and share them with the world!

📌 Find the complete repository and source code here.