Creating a Simple Task CRUD App with Flask, PostgreSQL, SQLAlchemy, and Docker

In the world of web development, one common task is to build CRUD (Create, Read, Update, Delete) applications. Let’s walk through the process of creating a simple Task CRUD app using Flask, PostgreSQL, SQLAlchemy, and Docker. This tutorial assumes you have a basic understanding of Docker and Python.

Step 1: Set Up Your Development Environment

Before diving in, make sure you have Docker and Docker Compose installed on your system. Create a new directory for your project:

mkdir flask-task-app
cd flask-task-app

Set up a virtual environment:

python -m venv venv
source venv/bin/activate

Install the required Python packages:

pip install Flask Flask-SQLAlchemy Flask-Migrate

Step 2: Initialize a Git Repository

Initialize a Git repository in your project directory:

git init

Step 3: Set Up Flask App and Database

Create the following directory structure for your project:

flask-task-app/
    app/
        __init__.py
        models.py
        views.py
    migrations/
    config.py
    run.py

Inside config.py, configure your Flask application and database:

# config.py

import os

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'your_secret_key'
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or 'postgresql://postgres:password@db:5432/tasks'
    SQLALCHEMY_TRACK_MODIFICATIONS = False

Step 4: Create Database Models

Define your database models inside models.py. For this example, let's create a Task model:

# app/models.py

from app import db

class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    description = db.Column(db.String(255))

Step 5: Create Flask Views

Create views for your Flask application inside views.py. Implement CRUD operations for tasks:

# app/views.py

from flask import Blueprint, jsonify, request
from app import db
from app.models import Task

tasks_bp = Blueprint('tasks', __name__)

@tasks_bp.route('/tasks', methods=['GET'])
def get_tasks():
    tasks = Task.query.all()
    task_list = [{'id': task.id, 'title': task.title, 'description': task.description} for task in tasks]
    return jsonify(task_list)

@tasks_bp.route('/tasks/<int:id>', methods=['GET'])
def get_task(id):
    task = Task.query.get(id)
    if not task:
        return jsonify({'message': 'Task not found'}), 404
    return jsonify({'id': task.id, 'title': task.title, 'description': task.description})

@tasks_bp.route('/tasks', methods=['POST'])
def create_task():
    data = request.json
    task = Task(title=data['title'], description=data['description'])
    db.session.add(task)
    db.session.commit()
    return jsonify({'message': 'Task created successfully'}), 201

@tasks_bp.route('/tasks/<int:id>', methods=['PUT'])
def update_task(id):
    task = Task.query.get(id)
    if not task:
        return jsonify({'message': 'Task not found'}), 404
    data = request.json
    task.title = data['title']
    task.description = data['description']
    db.session.commit()
    return jsonify({'message': 'Task updated successfully'})

@tasks_bp.route('/tasks/<int:id>', methods=['DELETE'])
def delete_task(id):
    task = Task.query.get(id)
    if not task:
        return jsonify({'message': 'Task not found'}), 404
    db.session.delete(task)
    db.session.commit()
    return jsonify({'message': 'Task deleted successfully'})

Step 6: Initialize Database Migrations

Initialize Alembic for database migrations:

flask db init

Edit the generated migrations/env.py file to load your Flask application and database configuration:

from your_app import create_app, db

app = create_app()
app.app_context().push()

Step 7: Create Database Migrations

Generate an initial migration:

flask db migrate -m "Initial migration"

Apply the migration to create the database tables:

flask db upgrade

Step 8: Create a Docker Compose File

Create a docker-compose.yml file to define your application and database services:

# docker-compose.yml

version: '3'

services:
  web:
    build: .
    command: python run.py
    volumes:
      - ./app:/app
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      FLASK_APP: run.py
      FLASK_ENV: development
      SECRET_KEY: your_secret_key
      SQLALCHEMY_DATABASE_URI: postgresql://postgres:password@db:5432/tasks

  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
      POSTGRES_DB: tasks
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Step 9: Create a Dockerfile

Create a Dockerfile to build your Flask application container:

# Dockerfile

FROM python:3.8-slim

WORKDIR /app

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

COPY . .

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

Step 10: Create a Requirements File

Create a requirements.txt file to list your project's dependencies:

Flask==2.0.1
Flask-SQLAlchemy==2.5.1
Flask-Migrate==3.1.1

Step 11: Build and Run the Docker Containers

Build and run the Docker containers for your application:

docker-compose up --build

Your Flask Task CRUD app is now running in a Docker container, and you can access it at http://localhost:5000. Use tools like Postman or cURL to interact with the CRUD API.

This is a basic setup, and you can extend it further by adding authentication, more features, and error handling based on your project requirements.