Feat: Add health check endpoint for MySQL and Redis connectivity, update Dockerfile for faster package installation, and enhance Redis client support for clusters and standalone instances.

Author: luisleo526

Dockerfile

@@ -18,18 +18,20 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libpq-dev \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements and install Python dependencies
+# Install uv for faster package installation
+RUN pip install --no-cache-dir uv
+
+# Copy requirements and install Python dependencies using uv
 COPY requirements.txt .
-RUN pip install --user --no-warn-script-location -r requirements.txt
+RUN uv pip install --system --no-cache -r requirements.txt
 
 # Stage 2: Runtime stage
 FROM python:3.11-slim
 
 # Set environment variables
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
-    PYTHONPATH="/app" \
-    PATH="/home/appuser/.local/bin:${PATH}"
+    PYTHONPATH="/app"
 
 # Install runtime dependencies only
 RUN apt-get update && apt-get install -y --no-install-recommends \
@@ -44,8 +46,9 @@ RUN useradd -m -u 1000 appuser && \
 
 WORKDIR /app
 
-# Copy Python packages from builder
-COPY --from=builder --chown=appuser:appuser /root/.local /home/appuser/.local
+# Copy Python packages from builder (system site-packages)
+COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY --from=builder /usr/local/bin /usr/local/bin
 
 # Copy application code
 COPY --chown=appuser:appuser . /app
@@ -55,7 +58,7 @@ USER appuser
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:8000/health || exit 1
+    CMD curl -f http://localhost:8000/healthz || exit 1
 
 # Expose the application port
 EXPOSE 8000

example.env

@@ -4,6 +4,12 @@ DB_PASS=admin1234
 DB_PORT=3306
 DB_NAME=template_db
 
+# Redis Configuration
+REDIS_HOST=redis
+REDIS_PORT=6379
+# Set to 'true' for Redis Cluster (AWS ElastiCache), 'false' for standalone Redis
+REDIS_CLUSTER=false
+
 AWS_ACCESS_KEY_ID=
 AWS_SECRET_ACCESS_KEY=
 AWS_REGION=

requirements.txt

@@ -9,7 +9,7 @@ passlib
 bcrypt
 email-validator
 python-ulid[pydantic]
-redis[hiredis]
+redis[hiredis]>=4.2.0
 boto3
 alembic
 pwdlib[argon2]

src/dependencies/basic.py

@@ -1,23 +1,74 @@
 import os
+import ssl
+from typing import Generator, Union
 
-from redis import StrictRedis as Redis
+from redis import RedisCluster, StrictRedis
+from sqlalchemy.orm import Session
 
 from src.database.database import SessionLocal
 
 
-def get_redis_client() -> Redis:
-    r = Redis(
-        host=os.getenv('REDIS_HOST', 'redis'),
-        port=int(os.getenv('REDIS_PORT', '6379')),
-        decode_responses=True
-    )
+def get_redis_client(db: int = 0) -> Generator[Union[RedisCluster, StrictRedis], None, None]:
+    """
+    FastAPI dependency for Redis client that supports both Redis Cluster (AWS ElastiCache) and standalone Redis.
+    
+    Usage:
+        @app.get("/endpoint")
+        def my_endpoint(redis: Redis = Depends(get_redis_client)):
+            redis.set("key", "value")
+    
+    Args:
+        db: Database number (only used for standalone Redis, clusters don't support db selection)
+    
+    Yields:
+        RedisCluster or StrictRedis instance
+    """
+    ssl_context = ssl.create_default_context()
+    ssl_context.check_hostname = False
+    ssl_context.verify_mode = ssl.CERT_NONE
+
+    if os.getenv('REDIS_CLUSTER', 'false').lower() == 'true':
+        # Redis Cluster doesn't support database selection - all data goes to db=0
+        # This fallback ensures consistent behavior across cluster and standalone modes
+        r = RedisCluster(
+            host=os.getenv('REDIS_HOST', 'redis'),
+            port=int(os.getenv('REDIS_PORT', '6379')),
+            decode_responses=True,
+            ssl=True,
+            ssl_context=ssl_context,
+            socket_connect_timeout=5,
+            socket_timeout=5,
+            skip_full_coverage_check=True
+        )
+    else:
+        # Standalone Redis with database selection support
+        r = StrictRedis(
+            host=os.getenv('REDIS_HOST', 'redis'),
+            port=int(os.getenv('REDIS_PORT', '6379')),
+            db=db,
+            decode_responses=True,
+            socket_connect_timeout=5,
+            socket_timeout=5
+        )
+    
     try:
         yield r
     finally:
         r.close()
 
 
-def get_db():
+def get_db() -> Generator[Session, None, None]:
+    """
+    FastAPI dependency for database session.
+    
+    Usage:
+        @app.get("/endpoint")
+        def my_endpoint(db: Session = Depends(get_db)):
+            db.query(User).all()
+    
+    Yields:
+        SQLAlchemy Session instance
+    """
     db = SessionLocal()
     try:
         yield db

src/schemas/basic.py

@@ -15,3 +15,14 @@ class UploadedFile(BaseModel):
     original_file_name: str = Field(..., title="Original File Name")
     extension: str = Field(..., title="File Extension")
     content_type: str = Field(..., title="Content Type")
+
+
+class ServiceStatus(BaseModel):
+    status: str = Field(..., title="Status", description="Service status: healthy or unhealthy")
+    message: str = Field(default="", title="Message", description="Additional information")
+
+
+class HealthCheck(BaseModel):
+    status: str = Field(..., title="Overall Status", description="Overall health status")
+    mysql: ServiceStatus = Field(..., title="MySQL Status")
+    redis: ServiceStatus = Field(..., title="Redis Status")

src/server.py

@@ -1,19 +1,23 @@
+import logging
 import os
-from fastapi import FastAPI
+
+from fastapi import FastAPI, status
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse
-from starlette.requests import Request
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy import text
 import sentry_sdk
 from sentry_sdk.integrations.fastapi import FastApiIntegration
-from sentry_sdk.integrations.starlette import StarletteIntegration
 from sentry_sdk.integrations.logging import LoggingIntegration
 from sentry_sdk.integrations.redis import RedisIntegration
 from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
+from sentry_sdk.integrations.starlette import StarletteIntegration
 from sentry_sdk.integrations.threading import ThreadingIntegration
-import logging
+from starlette.requests import Request
 
+from src.database.database import engine
+from src.dependencies.basic import get_redis_client
 from src.routers.server import router
-from src.schemas.basic import TextOnly
+from src.schemas.basic import TextOnly, HealthCheck, ServiceStatus
 from src.utils.swagger import custom_swagger_ui_html
 
 # Initialize Sentry
@@ -98,6 +102,52 @@ async def root():
     return TextOnly(text="Hello World")
 
 
+@app.get("/healthz", response_model=HealthCheck, tags=["Health"])
+async def health_check():
+    """
+    Health check endpoint that verifies MySQL and Redis connectivity.
+    Returns 200 if all services are healthy, 503 if any service is unhealthy.
+    """
+    mysql_status = ServiceStatus(status="healthy", message="Connected")
+    redis_status = ServiceStatus(status="healthy", message="Connected")
+    overall_healthy = True
+
+    # Check MySQL connection
+    try:
+        with engine.connect() as connection:
+            connection.execute(text("SELECT 1"))
+    except Exception as e:
+        mysql_status = ServiceStatus(status="unhealthy", message=f"Connection failed: {str(e)}")
+        overall_healthy = False
+
+    # Check Redis connection
+    try:
+        redis_gen = get_redis_client()
+        redis_client = next(redis_gen)
+        redis_client.ping()
+        try:
+            next(redis_gen)  # Trigger the finally block to close the connection
+        except StopIteration:
+            pass
+    except Exception as e:
+        redis_status = ServiceStatus(status="unhealthy", message=f"Connection failed: {str(e)}")
+        overall_healthy = False
+
+    health_response = HealthCheck(
+        status="healthy" if overall_healthy else "unhealthy",
+        mysql=mysql_status,
+        redis=redis_status
+    )
+
+    if overall_healthy:
+        return health_response
+    else:
+        return JSONResponse(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            content=health_response.model_dump()
+        )
+
+
 @app.get("/elements", include_in_schema=False)
 async def api_documentation(request: Request):
     return HTMLResponse("""