Microservices, APIs
& CI/CD

API stands for Application Programming Interface. In plain English: it's a menu that one program offers to another. Your app doesn't need to know how the kitchen cooks — it just orders from the menu and gets a result back.

When you use a weather app, it doesn't measure temperature itself. It calls a weather service's API: "Give me the forecast for London." The API returns structured data (usually JSON), and the app displays it.

REST (Representational State Transfer) is a popular style for building web APIs. Resources (users, orders, products) are identified by URLs, and you use standard HTTP methods to act on them — like verbs in a sentence.

Status codes tell you what happened: 200 OK means success, 404 Not Found means the resource doesn't exist, and 500 Server Error means something broke on the server.

Imagine a restaurant that used to be one giant kitchen where one chef did everything. A monolith app works the same way — one big codebase handles users, payments, inventory, and shipping.

Microservices split that kitchen into specialized stations: a pastry station, a grill, a salad bar. Each service is a small, independent app with its own database, deployed and scaled separately. They talk to each other through APIs.

CI/CD stands for Continuous Integration and Continuous Delivery/Deployment. Instead of manually copying code to a server every Friday, automation pipelines test and deploy your API whenever you push to Git.

• CI — automatically run tests & lint on every commit
• CD — automatically deploy passing builds to staging or production

Popular tools: GitHub Actions, GitLab CI, Jenkins, CircleCI. For APIs, pipelines often run unit tests with pytest, build Docker images, and deploy to cloud platforms.

FastAPI is a modern Python framework for building APIs. It's fast, automatically generates interactive docs, and uses Python type hints for validation. uvicorn is the ASGI server that actually runs your FastAPI app.

Installation

pip install fastapi uvicorn[standard]

Minimal app (main.py)

from fastapi import FastAPI

app = FastAPI(title="My API")

@app.get("/")
def read_root():
    return {"message": "Hello, API!"}

Run with uvicorn

uvicorn main:app --reload --host 0.0.0.0 --port 8000

Visit http://127.0.0.1:8000/docs for auto-generated Swagger UI.

GET requests retrieve data without changing anything. Use path parameters for specific resources and query parameters for filtering.

from fastapi import FastAPI
from typing import List

app = FastAPI()

# In-memory "database" for learning
items_db = [
    {"id": 1, "name": "Laptop", "price": 999.99},
    {"id": 2, "name": "Mouse", "price": 29.99},
]

@app.get("/items", response_model=List[dict])
def list_items(skip: int = 0, limit: int = 10):
    """GET all items with pagination."""
    return items_db[skip : skip + limit]

@app.get("/items/{item_id}")
def get_item(item_id: int):
    """GET a single item by ID."""
    for item in items_db:
        if item["id"] == item_id:
            return item
    from fastapi import HTTPException
    raise HTTPException(status_code=404, detail="Item not found")

What the client receives

The client (browser, mobile app, or curl) gets an HTTP status code plus a JSON body. Use curl -i to see headers and body together.

[
  { "id": 1, "name": "Laptop", "price": 999.99 },
  { "id": 2, "name": "Mouse", "price": 29.99 }
]

{
  "id": 1,
  "name": "Laptop",
  "price": 999.99
}

{
  "detail": "Item not found"
}

{
  "detail": [
    {
      "type": "int_parsing",
      "loc": ["path", "item_id"],
      "msg": "Input should be a valid integer...",
      "input": "abc"
    }
  ]
}

POST sends a JSON body to create a new resource. FastAPI uses Pydantic models to validate incoming data automatically.

from fastapi import FastAPI, status
from pydantic import BaseModel

app = FastAPI()
items_db = []
next_id = 1

class ItemCreate(BaseModel):
    name: str
    price: float

@app.post("/items", status_code=status.HTTP_201_CREATED)
def create_item(item: ItemCreate):
    global next_id
    new_item = {"id": next_id, **item.model_dump()}
    items_db.append(new_item)
    next_id += 1
    return new_item

What the client receives

On success, the client gets 201 Created and the new record (including the server-assigned id). On bad input, FastAPI returns 422 with a structured list of validation errors.

{
  "id": 1,
  "name": "Keyboard",
  "price": 79.99
}

{
  "detail": [
    {
      "type": "missing",
      "loc": ["body", "price"],
      "msg": "Field required",
      "input": { "name": "Keyboard" }
    }
  ]
}

{
  "detail": [
    {
      "type": "float_parsing",
      "loc": ["body", "price"],
      "msg": "Input should be a valid number...",
      "input": "free"
    }
  ]
}

PUT replaces an entire resource; PATCH updates only the fields you send. DELETE removes a resource.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

app = FastAPI()
items_db = [{"id": 1, "name": "Laptop", "price": 999.99}]

class ItemUpdate(BaseModel):
    name: Optional[str] = None
    price: Optional[float] = None

def find_item(item_id: int):
    for i, item in enumerate(items_db):
        if item["id"] == item_id:
            return i, item
    raise HTTPException(status_code=404, detail="Item not found")

@app.put("/items/{item_id}")
def replace_item(item_id: int, data: ItemUpdate):
    """Full replace — all fields required in practice."""
    idx, _ = find_item(item_id)
    updated = {"id": item_id, **data.model_dump(exclude_unset=True)}
    items_db[idx] = updated
    return updated

@app.patch("/items/{item_id}")
def patch_item(item_id: int, data: ItemUpdate):
    """Partial update — only sent fields change."""
    idx, item = find_item(item_id)
    patch_data = data.model_dump(exclude_unset=True)
    items_db[idx] = {**item, **patch_data}
    return items_db[idx]

@app.delete("/items/{item_id}", status_code=204)
def delete_item(item_id: int):
    idx, _ = find_item(item_id)
    items_db.pop(idx)
    return None

What the client receives

Updates return the full updated object (200 OK). Deletes often return 204 No Content with an empty body. Missing resources and invalid input produce clear error JSON — same patterns as GET and POST.

{
  "id": 1,
  "name": "Laptop",
  "price": 899.99
}

(empty response body)

{
  "detail": "Item not found"
}

{
  "detail": [
    {
      "type": "float_parsing",
      "loc": ["body", "price"],
      "msg": "Input should be a valid number...",
      "input": "cheap"
    }
  ]
}