TEMPLATE FastAPI + Kafka + MySQL + Consumer Healthcheck

1. FastAPI

1.1. New Model

Model folder structures:

.
├── Customer.py
├── Item.py
└── __init__.py

Example Model:

from sqlalchemy import Column, ForeignKey, Integer, String
from sqlalchemy.orm import relationship
from repository.db import Base


class Item(Base):
    __tablename__ = "items"

    id = Column(Integer, autoincrement=True, primary_key=True, index=True)
    description = Column(String(50), index=False)
    title = Column(String(50), index=True)
    customer_id = Column(Integer, ForeignKey("customers.id"), index=True)

    customer = relationship("Customer", back_populates="items")

Guideline:

Add the actual SQLAlchemy table definition + table relationship
The type of each Model class is sqlalchemy.ext.declarative.declarative_base
Each file is each table
Table presents type of objects so plural is needed for table name table="customers", but for file name use singular Customer.py
Once done, import into the __init__.py file for ease of import later on import models will include both Customer and Item

from .Customer import Customer
from .Item import Item

1.2. New Schema

Schema vs. Model:

Schema is not the same as Model, and also does not have the same purpose
Model represent the format of the data at the persistence level, ie. the Database
Schema on the other hand is Data Class with schema enforcement and type checking capability
Imagine having Schema as the object types for the Input and Output of each API
Then when persisting or recalling data at the database level, you refer to the Models
In and out -> Schema, Persistence -> Model

Schema folder structure:

.
├── Customer.py
├── Item.py
└── __init__.py

Example Schema:

from typing import Optional
from pydantic import BaseModel

class ItemBase(BaseModel):
    title: str
    description: Optional[str] = None


class ItemCreate(ItemBase):
    pass


class Item(ItemBase):
    id: int
    customer_id: int

    class Config:
        orm_mode = True

Guideline:

Type of schema is Pydantic.BaseModel
Pydantic library has a lot of native data types for schema enforment, as well as standard decorator to check your entire object information validity
Previously, models/Item.py was already defined and as the result SQLAlchemy will manage table items for you
ItemCreate is the schema format for when you call an API to create an Item via PUT/POST API
Item is the schema format for when you return the information of an Item to the client calling the GET API
If there are DELETE API then there should be a ItemDelete schema, as well as a DELETE API
Likewise if an item is to be alter, there should be a ItemAlter schema, as well as a PUT API that allow for editing an existing item
Once done, import into the __init__.py file for ease of import later on import schemas will include both Customer and Item

from .Item import ItemBase, ItemCreate, Item
from .Customer import CustomerBase, CustomerCreate, Customer

mechatroNick/fastapi-docker-kafka-mysql-pytest-demo

TEMPLATE FastAPI + Kafka + MySQL + Consumer Healthcheck

1. FastAPI

1.1. New Model

1.2. New Schema