KillrVideo v2 – Python FastAPI Backend

Date: June 2025

A reference backend for the KillrVideo sample application rebuilt for 2025 using FastAPI, Poetry and DataStax Astra DB.

---

Overview

This repo demonstrates modern API best-practices with:

• FastAPI & Pydantic v2 for typed request/response models
• Role-based JWT auth
• Async Cassandra (Astra DB) driver via astrapy
• Ruff + MyPy for quality gates
• Pytest suite (~150 tests)
• Micro-service friendly layout – or run everything as a monolith

---

Prerequisites

1. Python 3.10+ (use pyenv or asdf)
2. Poetry for dependency management:
   pip install "poetry==1.7.1"
3. A DataStax Astra DB serverless database – grab a free account.
4. Docker (optional) if you want to run the individual services in containers.

---

Setup & Configuration

# clone
git clone https://github.com/your-org/killrvideo-python-fastapi-backend.git
cd killrvideo-python-fastapi-backend
# install runtime dependencies (prod / Docker)
poetry install
# for local development with tests & tooling uncomment:# poetry install --with dev# copy env template & fill in Astra creds and SECRET_KEY
cp .env.example .env

Environment variables (all live in .env):

Variable	Description
ASTRA_DB_API_ENDPOINT	REST endpoint for your Astra DB instance
ASTRA_DB_APPLICATION_TOKEN	Token created in Astra UI
ASTRA_DB_KEYSPACE	Keyspace name
SECRET_KEY	JWT signing secret
VECTOR_SEARCH_ENABLED	Toggle semantic vector search (true/false)

---

Running the Application

1. Monolith (combined services)

poetry run uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

Docs: http://localhost:8000/docs

2. Individual Micro-services

Service	Entry-point	Port (example)	Docs URL
user-svc	app.main_user:service_app	8001	/docs
video-svc	app.main_video:service_app	8002	/docs
comment-svc	app.main_comment:service_app	8003	/docs
reco-svc	app.main_reco:service_app	8004	/docs

Run one:

poetry run uvicorn app.main_video:service_app --reload --port 8002

---

Local HTTPS Development

Front-end development expects HTTPS at https://localhost:8443. Follow these steps to generate a trusted certificate and run FastAPI over TLS locally.

# 1. Install mkcert (one-time)
brew install mkcert # macOS# Linux:# sudo apt install libnss3-tools && \# curl -L https://github.com/FiloSottile/mkcert/releases/download/v1.4.4/mkcert-v1.4.4-linux-amd64 -o /usr/local/bin/mkcert && \# chmod +x /usr/local/bin/mkcert# 2. Generate & trust a local CA (one-time)
mkcert -install
# 3. Create cert/key for localhost and loopback addresses
mkdir -p certs
mkcert -key-file certs/localhost-key.pem \
-cert-file certs/localhost.pem \
localhost 127.0.0.1 ::1

Start the backend on https://localhost:8443:

poetry run uvicorn app.main:app \
--reload --host 0.0.0.0 --port 8443 \
--ssl-certfile certs/localhost.pem \
--ssl-keyfile certs/localhost-key.pem

Your React/Next.js dev server can now proxy or fetch against https://localhost:8443 without the ECONNREFUSED error.

Tip: For convenience create scripts/run_dev_https.py and a Poetry entry-point so you can simply run poetry run serve-https. See the script in the repo for details.

---

Linting & Type Checking

poetry run ruff check .# lint
poetry run ruff format .# auto-format
poetry run mypy .# static types

---

Running Tests

poetry run pytest # run all tests
poetry run pytest -v # verbose
poetry run pytest --cov=app # with coverage (needs pytest-cov)

End-to-End Smoke Test (staging)

Provide the base URL of a running deployment via the STAGING_BASE_URL env var and run the e2e marked tests:

STAGING_BASE_URL=https://staging.killrvideo.com \
poetry run pytest tests/e2e -m e2e -q

The test performs a single semantic search request and validates the JSON schema.

On-Demand Load Testing

A lightweight Locust scenario ships with the repo. Use the run-load-test helper (registered as a Poetry script) to drive a burst of semantic searches against any environment:

# 200 users, ramping at 20/s for 5 minutes
poetry run run-load-test https://staging.killrvideo.com \
--users 200 --spawn-rate 20 --duration 5m

Flags:

• URL (positional) – base URL to test
• --users – concurrent users (default 200)
• --spawn-rate – users spawned per second (default 20)
• --duration – test length (Locust time string, default 5m)

Behind the scenes this wraps:

locust -f load/semantic_search.py --headless -u <users> -r <spawn> -t <duration> --host <URL>

---

Project Structure

app/
api/v1/endpoints/ # FastAPI routers per feature
models/ # Pydantic domain models
services/ # Business-logic layer
db/ # Astra client helpers
core/ # config, security, utils
main.py # monolith entrypoint
main_*.py # per-service entrypoints
services_dockerfiles/ # Dockerfiles per service

---

Building & Running with Docker

# user service
docker build -t killrvideo/user-svc -f services_dockerfiles/user.Dockerfile .
docker run -p 8001:8000 --env-file .env killrvideo/user-svc
# video service
docker build -t killrvideo/video-svc -f services_dockerfiles/video.Dockerfile .
docker run -p 8002:8000 --env-file .env killrvideo/video-svc

(Repeat for comment-svc & reco-svc.)

---

API Specification

The OpenAPI schema is autogenerated by FastAPI and served at /openapi.json for each service (or /api/v1/<svc>/openapi.json when running monolith).

Refreshing the YAML snapshot

For convenience the repo keeps a pre-generated copy under docs/killrvideo_openapi.yaml so documentation sites and static tooling don't need a live server. Whenever you change endpoints, regenerate the file via:

# install/update dev deps (PyYAML is required)
poetry install # one-time# generate/update the spec
poetry run gen-openapi
# commit the change if you want it in version control
git add docs/killrvideo_openapi.yaml
git commit -m "Refresh OpenAPI spec"

gen-openapi is a Poetry script defined in pyproject.toml and implemented in scripts/generate_openapi.py. It imports the FastAPI app, calls app.openapi(), and writes the YAML with keys preserved in the original order.

You can also run it ad-hoc without Poetry's script shim:

poetry run python scripts/generate_openapi.py

Observability

See docs/observability.md for full guide. Import-ready Grafana dashboards:

Dashboard	File	UID
API latency by route	docs/grafana/api_latency_by_route.json	kv-api-latency
Backend hot-path latency	docs/grafana/backend_hot_path.json	kv-hotpath
Astra DB operations	docs/grafana/astra_db_calls.json	kv-astra-db

Upload the JSON → select Prometheus datasource → done.