Production-ready boilerplate for building async microservices in Python (FastAPI + Pydantic), Go, and Rust (Axum + sqlx). All templates include async PostgreSQL, health checks, Docker support, and common microservice patterns.

Use this to rapidly scaffold new microservices—copy a template, rename it, and start building.

docker compose up --build

• Python service: http://localhost:8000
• Go service: http://localhost:8080
• Rust service: http://localhost:8081
• PostgreSQL: localhost:5432 (postgres/postgres)

microservices-boilerplate/
├── python/                 # FastAPI + Pydantic + async Postgres
│   ├── app/
│   │   ├── main.py         # Application entrypoint
│   │   ├── config.py      # Pydantic Settings
│   │   ├── database.py    # Async SQLAlchemy + asyncpg
│   │   ├── models/        # SQLAlchemy ORM models
│   │   ├── schemas/       # Pydantic request/response models
│   │   ├── routers/       # API route handlers
│   │   ├── services/      # Business logic layer
│   │   └── http_client.py # Service-to-service HTTP client
│   ├── requirements.txt
│   └── Dockerfile
├── go/                     # Echo + pgx + async/concurrent Postgres
│   ├── cmd/server/
│   │   └── main.go        # Application entrypoint
│   ├── internal/
│   │   ├── config/        # Configuration
│   │   ├── database/      # Connection pool + migrations
│   │   ├── models/        # Domain structs
│   │   ├── handlers/      # HTTP handlers
│   │   └── services/      # Business logic
│   ├── go.mod
│   └── Dockerfile
├── rust/                   # Axum + sqlx + async Postgres
│   ├── src/
│   │   ├── main.rs        # Application entrypoint
│   │   ├── config.rs      # Configuration
│   │   ├── database.rs    # Connection pool + schema
│   │   ├── models.rs      # Domain structs with serde
│   │   └── handlers.rs    # HTTP handlers
│   ├── Cargo.toml
│   └── Dockerfile
├── docker-compose.yml
└── README.md

• FastAPI – Async web framework
• Pydantic – Validation and serialization
• SQLAlchemy 2.0 – Async ORM with asyncpg
• httpx – Async HTTP client for inter-service calls

cd python
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -r requirements.txt
cp .env.example .env        # Edit DATABASE_URL if needed
uvicorn app.main:app --reload

1. Add SQLAlchemy model in app/models/
2. Add Pydantic schemas in app/schemas/
3. Add service methods in app/services/
4. Add router in app/routers/
5. Include router in app/main.py

• Echo – Lightweight HTTP framework
• pgx v5 – Concurrent Postgres driver with connection pool
• Standard library – Config, JSON, errors

cd go
cp .env.example .env        # Edit if needed
go run ./cmd/server

1. Add model structs in internal/models/
2. Add service in internal/services/
3. Add handler in internal/handlers/
4. Register routes in cmd/server/main.go

• Axum – Async web framework
• sqlx – Async Postgres with connection pooling
• serde – Serialization for JSON
• tokio – Async runtime

cd rust
cp .env.example .env        # Edit if needed
cargo run

1. Add model structs in src/models.rs
2. Add handler logic in src/handlers.rs
3. Register routes in src/main.rs

All services expose the same API surface (shared items table):

curl -X POST http://localhost:8081/items \
  -H "Content-Type: application/json" \
  -d '{"name": "My Item", "description": "A test item"}'

# All services
docker compose up -d

# Specific service
docker compose up -d python-service
# or: go-service, rust-service

# Rebuild after changes
docker compose up --build -d

Each service can be built standalone:

# Python
docker build -t my-python-service ./python

# Go
docker build -t my-go-service ./go

# Rust
docker build -t my-rust-service ./rust

1. Clone or copy the repo or the specific python/, go/, or rust/ directory.
2. Rename the service (app name, package names, Docker image).
3. Replace the example Item model with your domain entities.
4. Add your business logic in services/.
5. Extend routers/handlers for new endpoints.

• Java template (planned)

MIT