Building and Automating the Deployment of a Flask Application with Docker, GitHub, and CI/CD

This content originally appeared on DEV Community and was authored by Joseph Ibeh

📚 Introduction

This project demonstrates how to build, containerize, and deploy a simple Flask application with Docker, using GitHub for version control and GitHub Actions for Continuous Integration/Continuous Deployment (CI/CD). You will learn how to:

Create a simple Flask web application.
Containerize the application using Docker.
Set up version control with Git and GitHub.
Implement CI/CD pipelines using GitHub Actions to build and deploy the Docker image.

⚙️ Prerequisites

Before you begin, ensure that you have the following tools installed:

Python: A programming language for building web applications.
Flask: A lightweight Python web framework.
Docker: A platform for developing, shipping, and running applications in containers.
Git: A version control system for tracking changes in code.
GitHub: A platform for hosting and sharing code repositories.
Docker Hub: A cloud-based registry to share Docker images.

If you don't have these installed, refer to their respective official websites for installation instructions.

✅ Step 1: Create a Simple Flask Application

Create a new folder for the project:

mkdir flask-devops-app
cd flask-devops-app

Set up a Python virtual environment:
```
python -m venv venv
```

Activate the virtual environment:

source venv/Scripts/activate  # On Windows use: venv\Scripts\activate

Install Flask:
```
pip install flask
```

Create the app.py file:

# app.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello DevOps!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Run the app locally:
```
python app.py
```
Visit http://localhost:5000 in your browser. You should see "Hello DevOps!".

✅ Step 2: Containerize the Application

Create a Dockerfile in the same folder:

# Dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt

COPY . .

CMD ["python", "app.py"]

Generate requirements.txt:
```
pip freeze > requirements.txt
```
Create a .dockerignore file:
```
__pycache__/
*.pyc
venv/
```
Build the Docker image:
```
docker build -t flask-devops-app .
```

Run the Docker container:

docker run -p 5000:5000 flask-devops-app

Open http://localhost:5000 again and see your app running inside a Docker container.

✅ Step 3: Set Up Version Control

🧰 Tools: Git + GitHub

Initialize a Git repository:
```
git init
```
Create a .gitignore file:
```
venv/
__pycache__/
*.pyc
```

Commit your files:

git add .
git commit -m "Initial commit"

Create a GitHub repository and link it to your local repo:

git remote add origin https://github.com/YOUR_USERNAME/flask-devops-app.git
git branch -M main
git push -u origin main

✅ Step 4: Implement CI/CD with GitHub Actions

🧰 Tools: GitHub Actions, Docker Hub

Create a .github/workflows/docker-publish.yml file:

mkdir -p .github/workflows
touch .github/workflows/docker-publish.yml

Edit the docker-publish.yml file and add the following content:

# .github/workflows/docker-publish.yml
name: Build and Push Docker Image

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2

      - name: Log in to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Build and push image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: YOUR_DOCKERHUB_USERNAME/flask-devops-app:latest

Add Docker Hub credentials as GitHub Secrets:
- Go to your GitHub repository → Settings → Secrets and variables → Actions
- Add the following secrets:
  - DOCKER_USERNAME → your Docker Hub username
  - DOCKER_PASSWORD → your Docker Hub password or access token

Push your code again:

git add .
git commit -m "Add CI/CD workflow"
git push

GitHub Actions will now automatically build your Docker image and push it to Docker Hub whenever you push to the main branch.

🚀 Final Output

✅ A live Flask app running inside a Docker container.
✅ The source code is hosted on GitHub.
✅ The Docker image is automatically built and pushed to Docker Hub on every commit.

🎯 Conclusion

Congratulations! You've successfully created a simple Flask app, containerized it with Docker, set up version control with Git and GitHub, and implemented CI/CD with GitHub Actions. This project is a foundational step in building scalable and automated systems in DevOps.

🛠️ Troubleshooting

If Docker is not running: Ensure Docker Desktop is open and running.
If you encounter permission issues with GitHub Actions: Double-check your Docker Hub credentials in GitHub Secrets.
If the Flask app does not load: Ensure you are using the correct port and that the Docker container is running. needs!

This content originally appeared on DEV Community and was authored by Joseph Ibeh

Print Share Comment Cite Upload Translate Updates

APA

Joseph Ibeh | Sciencx (2025-04-11T13:40:24+00:00) Building and Automating the Deployment of a Flask Application with Docker, GitHub, and CI/CD. Retrieved from https://www.scien.cx/2025/04/11/building-and-automating-the-deployment-of-a-flask-application-with-docker-github-and-ci-cd/

MLA

" » Building and Automating the Deployment of a Flask Application with Docker, GitHub, and CI/CD." Joseph Ibeh | Sciencx - Friday April 11, 2025, https://www.scien.cx/2025/04/11/building-and-automating-the-deployment-of-a-flask-application-with-docker-github-and-ci-cd/

HARVARD

Joseph Ibeh | Sciencx Friday April 11, 2025 » Building and Automating the Deployment of a Flask Application with Docker, GitHub, and CI/CD., viewed ,<https://www.scien.cx/2025/04/11/building-and-automating-the-deployment-of-a-flask-application-with-docker-github-and-ci-cd/>

VANCOUVER

Joseph Ibeh | Sciencx - » Building and Automating the Deployment of a Flask Application with Docker, GitHub, and CI/CD. [Internet]. [Accessed ]. Available from: https://www.scien.cx/2025/04/11/building-and-automating-the-deployment-of-a-flask-application-with-docker-github-and-ci-cd/

CHICAGO

" » Building and Automating the Deployment of a Flask Application with Docker, GitHub, and CI/CD." Joseph Ibeh | Sciencx - Accessed . https://www.scien.cx/2025/04/11/building-and-automating-the-deployment-of-a-flask-application-with-docker-github-and-ci-cd/

IEEE

" » Building and Automating the Deployment of a Flask Application with Docker, GitHub, and CI/CD." Joseph Ibeh | Sciencx [Online]. Available: https://www.scien.cx/2025/04/11/building-and-automating-the-deployment-of-a-flask-application-with-docker-github-and-ci-cd/. [Accessed: ]

rf:citation

» Building and Automating the Deployment of a Flask Application with Docker, GitHub, and CI/CD | Joseph Ibeh | Sciencx | https://www.scien.cx/2025/04/11/building-and-automating-the-deployment-of-a-flask-application-with-docker-github-and-ci-cd/ |

Please log in to upload a file.

There are no updates yet.
Click the Upload button above to add an update.

You must be logged in to translate posts. Please log in or register.