Service Discovery & Registry

# pip install python-consul
import consul
import socket
from fastapi import FastAPI
import uvicorn
import atexit

app = FastAPI()
c = consul.Consul(host='localhost', port=8500)

SERVICE_NAME = "payment-service"
SERVICE_PORT = 8001
SERVICE_ID = f"payment-service-{socket.gethostname()}"

def register_service():
    """Consul এ service register করুন"""
    c.agent.service.register(
        name=SERVICE_NAME,
        service_id=SERVICE_ID,
        address=socket.gethostbyname(socket.gethostname()),
        port=SERVICE_PORT,
        check={
            "http": f"http://localhost:{SERVICE_PORT}/health",
            "interval": "10s",   # Every 10s health check
            "timeout": "5s"
        },
        tags=["payment", "api", "v1"]
    )
    print(f"✅ Registered: {SERVICE_ID}")

def deregister_service():
    """Shutdown এ deregister করুন"""
    c.agent.service.deregister(SERVICE_ID)
    print(f"❌ Deregistered: {SERVICE_ID}")

def discover_service(service_name: str) -> str:
    """Service এর URL বের করুন"""
    _, services = c.health.service(service_name, passing=True)
    if not services:
        raise Exception(f"No healthy instances of {service_name}")
    # Simple round-robin (real এ load balancer করবেন)
    service = services[0]['Service']
    return f"http://{service['Address']}:{service['Port']}"

@app.on_event("startup")
async def startup():
    register_service()
    atexit.register(deregister_service)

@app.get("/health")
async def health():
    return {"status": "healthy"}

@app.post("/orders")
async def create_order():
    # Discover payment service dynamically
    payment_url = discover_service("payment-service")
    return {"payment_url": payment_url, "status": "processing"}

# Kubernetes Service — stable DNS endpoint
apiVersion: v1
kind: Service
metadata:
  name: payment-service   # DNS name হবে: payment-service.default.svc.cluster.local
  namespace: default
spec:
  selector:
    app: payment          # এই label এর pods কে route করবেন
  ports:
    - port: 80            # Service port
      targetPort: 8001     # Pod এর actual port
  type: ClusterIP        # Internal only
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payment-deployment
spec:
  replicas: 3            # 3 pods — K8s Service load balances
  selector:
    matchLabels:
      app: payment
  template:
    metadata:
      labels:
        app: payment
    spec:
      containers:
      - name: payment
        image: payment-service:latest
        ports:
        - containerPort: 8001
        # Order service এখন শুধু "payment-service" use করে
        # কোনো IP hardcode না!

from fastapi import FastAPI, Response
import httpx
import asyncpg

app = FastAPI()

@app.get("/health")
async def health_check(response: Response):
    """
    Proper health check — সব dependencies check করুন
    """
    checks = {
        "status": "healthy",
        "database": "unknown",
        "external_api": "unknown"
    }

    # Database connection check
    try:
        conn = await asyncpg.connect("postgresql://localhost/mydb")
        await conn.execute("SELECT 1")
        await conn.close()
        checks["database"] = "healthy"
    except Exception as e:
        checks["database"] = f"unhealthy: {str(e)}"
        checks["status"] = "unhealthy"

    # External service check
    try:
        async with httpx.AsyncClient(timeout=2.0) as client:
            resp = await client.get("https://external-api/ping")
            if resp.status_code == 200:
                checks["external_api"] = "healthy"
            else:
                checks["external_api"] = "degraded"
    except Exception:
        checks["external_api"] = "unhealthy"
        # External service unhealthy কিন্তু আমরা still serve করতে পারবো
        # তাই status "degraded" — critical না হলে

    if checks["status"] == "unhealthy":
        response.status_code = 503  # Service Unavailable

    return checks

# Consul এ register করার সময় এই endpoint দিন:
# "http": "http://localhost:8001/health"
# Consul 503 response দেখলে automatically deregister করবেন