This content originally appeared on DEV Community and was authored by Ishwor Subedi
Introduction
In this blog, we’ll learn how to deploy a FastAPI app using Docker and automate it with CI/CD. We’ll go over why Docker is better than traditional SSH-based deployment, and how it simplifies the process of running apps in the cloud.
Why Docker?
With normal file setup, you manually upload files to a server via SSH. This often leads to issues like mismatched environments (e.g., different Python versions or missing libraries). Docker eliminates this problem by packaging everything (code, libraries, configurations) into a container.
- Consistency: Docker ensures the app works the same on every machine.
- Simplicity: Once the container is created, you don’t have to worry about setting up environments.
- Scalability: Docker makes scaling your application easier, especially in cloud environments.
Why Not Traditional SSH Deployment?
In traditional deployment, you often use scp or rsync to upload code, and manually configure environments via SSH, which can cause:
- Environment issues: Different setups on local vs. server.
- Manual errors: Forgetting to install dependencies.
- Time-consuming: Manual steps every time you update the app.
Docker fixes this by packaging everything together. You create an image once, and then run it anywhere with Docker.
What is Docker?
Docker is a platform for running applications in containers. A Docker container is a self-contained unit that packages your code and all its dependencies. With Docker, your app works the same in development and production.
- Dockerfile: Instructions to build the Docker image.
- Image: Blueprint for the container.
- Container: Running instance of an image.
What is CI/CD?
CI/CD (Continuous Integration/Continuous Delivery) automates testing, building, and deploying applications.
- CI (Continuous Integration): Automatically test and integrate new code changes.
- CD (Continuous Delivery): Automatically deploy tested code into production.
Creating a FastAPI App
We will create a simple FastAPI app and Dockerize it. Then, we'll automate the deployment using GitHub Actions.
1. FastAPI App (main.py)
# main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, Dockerized FastAPI World!"}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)
2. Dockerfile
The Dockerfile is used to create a Docker image for our FastAPI app.
# Use an official Python runtime as a parent image
FROM python:3.9-slim
# Set the working directory in the container
WORKDIR /app
# Copy the current directory contents into the container
COPY . /app
# Install FastAPI and Uvicorn
RUN pip install fastapi uvicorn
# Expose the port FastAPI will run on
EXPOSE 8000
# Command to run the app
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
3. Build and Run Docker Container
To build and run the Docker container:
docker build -t fastapi-app .
docker run -d -p 8000:8000 fastapi-app
This will make the app accessible at http://localhost:8000.
Push to Docker Hub
To share your Docker image, push it to Docker Hub.
-
Log in to Docker Hub:
docker login -
Tag your image:
docker tag fastapi-app yourdockerhubusername/fastapi-app:latest -
Push the image to Docker Hub:
docker push yourdockerhubusername/fastapi-app:latest
CI/CD Workflow with GitHub Actions
Here’s how to automate Docker image building and deployment using GitHub Actions.
GitHub Actions Workflow (.github/workflows/docker.yml)
name: CI/CD for FastAPI Docker App
on:
push:
branches:
- main
jobs:
build-and-push:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v2
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v1
- name: Login to DockerHub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Build and Push Docker image
run: |
docker build -t yourdockerhubusername/fastapi-app:latest .
docker push yourdockerhubusername/fastapi-app:latest
- name: Log out from DockerHub
run: docker logout
This workflow builds and pushes your Docker image to Docker Hub automatically when changes are pushed to the main branch. To set up:
- Add your Docker Hub credentials (
DOCKER_USERNAMEandDOCKER_PASSWORD) as GitHub secrets. - Create the
.github/workflows/docker.ymlfile.
Deploying Docker on RunPod
To deploy your Docker container on RunPod:
- Create an account at RunPod.
- Create a new pod (choose the appropriate machine type).
- ** Create a new template**
- Deploy the template based on your hardware requirements, such as CPU or GPU. It will automatically pull the Docker image from Docker Hub and initiate the container accordingly.
Now your FastAPI app will be running on the cloud via RunPod.
Docker Commands
Docker Installation instruction and commands
Conclusion
In this guide, we learned how to create a FastAPI app, Dockerize it, and automate its deployment using CI/CD. Docker simplifies the deployment process by ensuring the app runs consistently across environments. With tools like GitHub Actions and platforms like RunPod, you can automate the entire deployment process.
This content originally appeared on DEV Community and was authored by Ishwor Subedi
Ishwor Subedi | Sciencx (2024-09-12T12:29:23+00:00) Dockerized deployments, CI/CD, automated workflows for production in cloud environments. Retrieved from https://www.scien.cx/2024/09/12/dockerized-deployments-ci-cd-automated-workflows-for-production-in-cloud-environments/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.