[{"data":1,"prerenderedAt":2087},["ShallowReactive",2],{"nav":3,"page-\u002Fcore-architecture-routing-patterns\u002Fapplication-factory-patterns\u002F":152,"surround-\u002Fcore-architecture-routing-patterns\u002Fapplication-factory-patterns\u002F":2085},[4,72],{"title":5,"path":6,"stem":7,"children":8},"Advanced Pydantic Validation Serialization","\u002Fadvanced-pydantic-validation-serialization","advanced-pydantic-validation-serialization",[9,12,24,36,48,54,66],{"title":10,"path":6,"stem":11},"Advanced Pydantic Validation & Serialization","advanced-pydantic-validation-serialization\u002Findex",{"title":13,"path":14,"stem":15,"children":16},"Custom Validators & Field Constraints in FastAPI & Pydantic V2","\u002Fadvanced-pydantic-validation-serialization\u002Fcustom-validators-field-constraints","advanced-pydantic-validation-serialization\u002Fcustom-validators-field-constraints\u002Findex",[17,18],{"title":13,"path":14,"stem":15},{"title":19,"path":20,"stem":21,"children":22},"Creating Reusable Custom Validators in Pydantic: Production Patterns","\u002Fadvanced-pydantic-validation-serialization\u002Fcustom-validators-field-constraints\u002Fcreating-reusable-custom-validators-in-pydantic","advanced-pydantic-validation-serialization\u002Fcustom-validators-field-constraints\u002Fcreating-reusable-custom-validators-in-pydantic\u002Findex",[23],{"title":19,"path":20,"stem":21},{"title":25,"path":26,"stem":27,"children":28},"JSON Schema Customization","\u002Fadvanced-pydantic-validation-serialization\u002Fjson-schema-customization","advanced-pydantic-validation-serialization\u002Fjson-schema-customization\u002Findex",[29,30],{"title":25,"path":26,"stem":27},{"title":31,"path":32,"stem":33,"children":34},"Customizing OpenAPI Schema Generation in FastAPI: Production Implementation Guide","\u002Fadvanced-pydantic-validation-serialization\u002Fjson-schema-customization\u002Fcustomizing-openapi-schema-generation-in-fastapi","advanced-pydantic-validation-serialization\u002Fjson-schema-customization\u002Fcustomizing-openapi-schema-generation-in-fastapi\u002Findex",[35],{"title":31,"path":32,"stem":33},{"title":37,"path":38,"stem":39,"children":40},"Mastering Nested Model Serialization in FastAPI","\u002Fadvanced-pydantic-validation-serialization\u002Fnested-model-serialization","advanced-pydantic-validation-serialization\u002Fnested-model-serialization\u002Findex",[41,42],{"title":37,"path":38,"stem":39},{"title":43,"path":44,"stem":45,"children":46},"Handling Deeply Nested JSON Models Efficiently in FastAPI","\u002Fadvanced-pydantic-validation-serialization\u002Fnested-model-serialization\u002Fhandling-deeply-nested-json-models-efficiently","advanced-pydantic-validation-serialization\u002Fnested-model-serialization\u002Fhandling-deeply-nested-json-models-efficiently\u002Findex",[47],{"title":43,"path":44,"stem":45},{"title":49,"path":50,"stem":51,"children":52},"Performance Optimization for Models in FastAPI","\u002Fadvanced-pydantic-validation-serialization\u002Fperformance-optimization-for-models","advanced-pydantic-validation-serialization\u002Fperformance-optimization-for-models\u002Findex",[53],{"title":49,"path":50,"stem":51},{"title":55,"path":56,"stem":57,"children":58},"Pydantic V2 Migration Guide: FastAPI Production Patterns","\u002Fadvanced-pydantic-validation-serialization\u002Fpydantic-v2-migration-guide","advanced-pydantic-validation-serialization\u002Fpydantic-v2-migration-guide\u002Findex",[59,60],{"title":55,"path":56,"stem":57},{"title":61,"path":62,"stem":63,"children":64},"Migrating from Pydantic v1 to v2 without breaking APIs","\u002Fadvanced-pydantic-validation-serialization\u002Fpydantic-v2-migration-guide\u002Fmigrating-from-pydantic-v1-to-v2-without-breaking-apis","advanced-pydantic-validation-serialization\u002Fpydantic-v2-migration-guide\u002Fmigrating-from-pydantic-v1-to-v2-without-breaking-apis\u002Findex",[65],{"title":61,"path":62,"stem":63},{"title":67,"path":68,"stem":69,"children":70},"Type Hinting & IDE Integration in FastAPI: Advanced Pydantic Patterns","\u002Fadvanced-pydantic-validation-serialization\u002Ftype-hinting-ide-integration","advanced-pydantic-validation-serialization\u002Ftype-hinting-ide-integration\u002Findex",[71],{"title":67,"path":68,"stem":69},{"title":73,"path":74,"stem":75,"children":76},"Core Architecture Routing Patterns","\u002Fcore-architecture-routing-patterns","core-architecture-routing-patterns",[77,80,92,104,116,128,140],{"title":78,"path":74,"stem":79},"Core Architecture & Routing Patterns in FastAPI: A Production-Ready Blueprint","core-architecture-routing-patterns\u002Findex",{"title":81,"path":82,"stem":83,"children":84},"Application Factory Patterns in FastAPI: Production Architecture Guide","\u002Fcore-architecture-routing-patterns\u002Fapplication-factory-patterns","core-architecture-routing-patterns\u002Fapplication-factory-patterns\u002Findex",[85,86],{"title":81,"path":82,"stem":83},{"title":87,"path":88,"stem":89,"children":90},"FastAPI App Factory Pattern for Testing and Deployment: Production Guide","\u002Fcore-architecture-routing-patterns\u002Fapplication-factory-patterns\u002Ffastapi-app-factory-pattern-for-testing-and-deployment","core-architecture-routing-patterns\u002Fapplication-factory-patterns\u002Ffastapi-app-factory-pattern-for-testing-and-deployment\u002Findex",[91],{"title":87,"path":88,"stem":89},{"title":93,"path":94,"stem":95,"children":96},"Configuration Management in FastAPI: Production-Ready Patterns & Security","\u002Fcore-architecture-routing-patterns\u002Fconfiguration-management","core-architecture-routing-patterns\u002Fconfiguration-management\u002Findex",[97,98],{"title":93,"path":94,"stem":95},{"title":99,"path":100,"stem":101,"children":102},"Managing Environment Variables with Pydantic Settings in FastAPI","\u002Fcore-architecture-routing-patterns\u002Fconfiguration-management\u002Fmanaging-environment-variables-with-pydantic-settings","core-architecture-routing-patterns\u002Fconfiguration-management\u002Fmanaging-environment-variables-with-pydantic-settings\u002Findex",[103],{"title":99,"path":100,"stem":101},{"title":105,"path":106,"stem":107,"children":108},"Dependency Injection Strategies","\u002Fcore-architecture-routing-patterns\u002Fdependency-injection-strategies","core-architecture-routing-patterns\u002Fdependency-injection-strategies\u002Findex",[109,110],{"title":105,"path":106,"stem":107},{"title":111,"path":112,"stem":113,"children":114},"Best Practices for FastAPI Dependency Injection","\u002Fcore-architecture-routing-patterns\u002Fdependency-injection-strategies\u002Fbest-practices-for-fastapi-dependency-injection","core-architecture-routing-patterns\u002Fdependency-injection-strategies\u002Fbest-practices-for-fastapi-dependency-injection\u002Findex",[115],{"title":111,"path":112,"stem":113},{"title":117,"path":118,"stem":119,"children":120},"Error Handling & Global Exceptions in FastAPI","\u002Fcore-architecture-routing-patterns\u002Ferror-handling-global-exceptions","core-architecture-routing-patterns\u002Ferror-handling-global-exceptions\u002Findex",[121,122],{"title":117,"path":118,"stem":119},{"title":123,"path":124,"stem":125,"children":126},"Global Exception Handlers for Consistent API Responses","\u002Fcore-architecture-routing-patterns\u002Ferror-handling-global-exceptions\u002Fglobal-exception-handlers-for-consistent-api-responses","core-architecture-routing-patterns\u002Ferror-handling-global-exceptions\u002Fglobal-exception-handlers-for-consistent-api-responses\u002Findex",[127],{"title":123,"path":124,"stem":125},{"title":129,"path":130,"stem":131,"children":132},"Middleware Implementation","\u002Fcore-architecture-routing-patterns\u002Fmiddleware-implementation","core-architecture-routing-patterns\u002Fmiddleware-implementation\u002Findex",[133,134],{"title":129,"path":130,"stem":131},{"title":135,"path":136,"stem":137,"children":138},"Implementing Custom Middleware for Request Tracing in FastAPI","\u002Fcore-architecture-routing-patterns\u002Fmiddleware-implementation\u002Fimplementing-custom-middleware-for-request-tracing","core-architecture-routing-patterns\u002Fmiddleware-implementation\u002Fimplementing-custom-middleware-for-request-tracing\u002Findex",[139],{"title":135,"path":136,"stem":137},{"title":141,"path":142,"stem":143,"children":144},"Modular Router Organization in FastAPI: Production-Grade Architecture","\u002Fcore-architecture-routing-patterns\u002Fmodular-router-organization","core-architecture-routing-patterns\u002Fmodular-router-organization\u002Findex",[145,146],{"title":141,"path":142,"stem":143},{"title":147,"path":148,"stem":149,"children":150},"How to Structure Large FastAPI Projects for Scale","\u002Fcore-architecture-routing-patterns\u002Fmodular-router-organization\u002Fhow-to-structure-large-fastapi-projects-for-scale","core-architecture-routing-patterns\u002Fmodular-router-organization\u002Fhow-to-structure-large-fastapi-projects-for-scale\u002Findex",[151],{"title":147,"path":148,"stem":149},{"id":153,"title":81,"body":154,"description":2080,"extension":2081,"meta":2082,"navigation":296,"path":82,"seo":2083,"stem":83,"__hash__":2084},"content\u002Fcore-architecture-routing-patterns\u002Fapplication-factory-patterns\u002Findex.md",{"type":155,"value":156,"toc":2068},"minimark",[157,161,180,186,202,205,210,218,223,234,914,920,922,926,933,1388,1402,1404,1408,1411,1753,1774,1776,1780,1783,1787,1790,1883,1889,1901,1906,1932,1934,1938,2030,2032,2036,2041,2044,2049,2052,2057,2064],[158,159,81],"h1",{"id":160},"application-factory-patterns-in-fastapi-production-architecture-guide",[162,163,164,165,170,171,174,175,179],"p",{},"Implementing Application Factory Patterns is critical for building maintainable, testable, and secure FastAPI services. This guide details how to decouple application initialization from global state, ensuring reliable dependency injection and environment isolation. By adopting a factory approach, engineering teams can seamlessly integrate ",[166,167,169],"a",{"href":168},"\u002Fcore-architecture-routing-patterns\u002Fmodular-router-organization\u002F","Modular Router Organization"," and enforce strict ",[166,172,105],{"href":173},"\u002Fcore-architecture-routing-patterns\u002Fdependency-injection-strategies\u002F"," across microservices and monolithic deployments. For foundational routing concepts, refer to ",[166,176,178],{"href":177},"\u002Fcore-architecture-routing-patterns\u002F","Core Architecture & Routing Patterns",".",[162,181,182],{},[183,184,185],"strong",{},"Key Operational Objectives:",[187,188,189,193,196,199],"ul",{},[190,191,192],"li",{},"Decouple app initialization from global scope to prevent cross-request state leakage",[190,194,195],{},"Enforce environment-specific configuration loading with strict schema validation",[190,197,198],{},"Secure middleware and router attachment during build time",[190,200,201],{},"Optimize lifecycle hooks for production throughput and serverless cold starts",[203,204],"hr",{},[206,207,209],"h2",{"id":208},"factory-function-architecture-lifecycle-hooks","Factory Function Architecture & Lifecycle Hooks",[162,211,212,213,217],{},"The ",[214,215,216],"code",{},"create_app"," factory serves as the single source of truth for service initialization. In production, the factory must manage ASGI-compliant startup\u002Fshutdown sequences without leaking mutable state into the global namespace. Global singletons are fundamentally incompatible with multi-worker deployments (Gunicorn\u002FUvicorn) and introduce race conditions during concurrent request handling.",[219,220,222],"h3",{"id":221},"asynchronous-initialization-lifespan-management","Asynchronous Initialization & Lifespan Management",[162,224,225,226,229,230,233],{},"FastAPI's ",[214,227,228],{},"lifespan"," context manager replaces the deprecated ",[214,231,232],{},"@app.on_event"," decorators. It provides deterministic resource provisioning and teardown, enabling precise observability hooks around initialization latency.",[235,236,241],"pre",{"className":237,"code":238,"language":239,"meta":240,"style":240},"language-python shiki shiki-themes github-light","import logging\nimport time\nfrom contextlib import asynccontextmanager\nfrom typing import AsyncGenerator\n\nfrom fastapi import FastAPI\nfrom .config import AppSettings\nfrom .db import DatabaseEngine\nfrom .routers import api_router\n\nlogger = logging.getLogger(__name__)\n\n@asynccontextmanager\nasync def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:\n start = time.perf_counter()\n try:\n # Eagerly provision heavy resources with explicit error boundaries\n app.state.db_engine = await DatabaseEngine.create_pool(\n dsn=app.settings.DATABASE_URL,\n pool_size=app.settings.DB_POOL_SIZE,\n max_overflow=app.settings.DB_MAX_OVERFLOW\n )\n logger.info(\"Database connection pool initialized\", extra={\"pool_size\": app.settings.DB_POOL_SIZE})\n \n # Record startup duration for observability dashboards\n init_duration = time.perf_counter() - start\n logger.info(\"Application startup completed\", extra={\"duration_ms\": round(init_duration * 1000, 2)})\n \n yield\n \n except Exception as exc:\n logger.critical(\"Lifespan startup failed\", exc_info=exc)\n raise RuntimeError(\"Service initialization aborted due to resource failure\") from exc\n finally:\n # Graceful teardown: prevent connection leaks during SIGTERM\n if hasattr(app.state, \"db_engine\"):\n await app.state.db_engine.dispose()\n logger.info(\"Database pool disposed successfully\")\n\ndef create_app(settings: AppSettings | None = None) -> FastAPI:\n cfg = settings or AppSettings.load()\n \n app = FastAPI(\n title=cfg.PROJECT_NAME,\n version=cfg.VERSION,\n lifespan=lifespan,\n docs_url=\"\u002Fdocs\" if cfg.ENVIRONMENT != \"production\" else None\n )\n app.settings = cfg # Attach validated config to app state\n \n app.include_router(api_router, prefix=\"\u002Fv1\")\n return app\n","python","",[214,242,243,256,264,278,291,298,311,324,337,350,355,374,379,386,412,423,432,439,453,471,486,499,505,536,542,548,565,607,612,618,623,638,657,680,688,694,712,720,730,735,761,778,783,794,810,825,835,866,871,884,889,905],{"__ignoreMap":240},[244,245,248,252],"span",{"class":246,"line":247},"line",1,[244,249,251],{"class":250},"sD7c4","import",[244,253,255],{"class":254},"sgsFI"," logging\n",[244,257,259,261],{"class":246,"line":258},2,[244,260,251],{"class":250},[244,262,263],{"class":254}," time\n",[244,265,267,270,273,275],{"class":246,"line":266},3,[244,268,269],{"class":250},"from",[244,271,272],{"class":254}," contextlib ",[244,274,251],{"class":250},[244,276,277],{"class":254}," asynccontextmanager\n",[244,279,281,283,286,288],{"class":246,"line":280},4,[244,282,269],{"class":250},[244,284,285],{"class":254}," typing ",[244,287,251],{"class":250},[244,289,290],{"class":254}," AsyncGenerator\n",[244,292,294],{"class":246,"line":293},5,[244,295,297],{"emptyLinePlaceholder":296},true,"\n",[244,299,301,303,306,308],{"class":246,"line":300},6,[244,302,269],{"class":250},[244,304,305],{"class":254}," fastapi ",[244,307,251],{"class":250},[244,309,310],{"class":254}," FastAPI\n",[244,312,314,316,319,321],{"class":246,"line":313},7,[244,315,269],{"class":250},[244,317,318],{"class":254}," .config ",[244,320,251],{"class":250},[244,322,323],{"class":254}," AppSettings\n",[244,325,327,329,332,334],{"class":246,"line":326},8,[244,328,269],{"class":250},[244,330,331],{"class":254}," .db ",[244,333,251],{"class":250},[244,335,336],{"class":254}," DatabaseEngine\n",[244,338,340,342,345,347],{"class":246,"line":339},9,[244,341,269],{"class":250},[244,343,344],{"class":254}," .routers ",[244,346,251],{"class":250},[244,348,349],{"class":254}," api_router\n",[244,351,353],{"class":246,"line":352},10,[244,354,297],{"emptyLinePlaceholder":296},[244,356,358,361,364,367,371],{"class":246,"line":357},11,[244,359,360],{"class":254},"logger ",[244,362,363],{"class":250},"=",[244,365,366],{"class":254}," logging.getLogger(",[244,368,370],{"class":369},"sYu0t","__name__",[244,372,373],{"class":254},")\n",[244,375,377],{"class":246,"line":376},12,[244,378,297],{"emptyLinePlaceholder":296},[244,380,382],{"class":246,"line":381},13,[244,383,385],{"class":384},"s7eDp","@asynccontextmanager\n",[244,387,389,392,395,398,401,404,407,409],{"class":246,"line":388},14,[244,390,391],{"class":250},"async",[244,393,394],{"class":250}," def",[244,396,397],{"class":384}," lifespan",[244,399,400],{"class":254},"(app: FastAPI) -> AsyncGenerator[",[244,402,403],{"class":369},"None",[244,405,406],{"class":254},", ",[244,408,403],{"class":369},[244,410,411],{"class":254},"]:\n",[244,413,415,418,420],{"class":246,"line":414},15,[244,416,417],{"class":254}," start ",[244,419,363],{"class":250},[244,421,422],{"class":254}," time.perf_counter()\n",[244,424,426,429],{"class":246,"line":425},16,[244,427,428],{"class":250}," try",[244,430,431],{"class":254},":\n",[244,433,435],{"class":246,"line":434},17,[244,436,438],{"class":437},"sAwPA"," # Eagerly provision heavy resources with explicit error boundaries\n",[244,440,442,445,447,450],{"class":246,"line":441},18,[244,443,444],{"class":254}," app.state.db_engine ",[244,446,363],{"class":250},[244,448,449],{"class":250}," await",[244,451,452],{"class":254}," DatabaseEngine.create_pool(\n",[244,454,456,460,462,465,468],{"class":246,"line":455},19,[244,457,459],{"class":458},"sqxcx"," dsn",[244,461,363],{"class":250},[244,463,464],{"class":254},"app.settings.",[244,466,467],{"class":369},"DATABASE_URL",[244,469,470],{"class":254},",\n",[244,472,474,477,479,481,484],{"class":246,"line":473},20,[244,475,476],{"class":458}," pool_size",[244,478,363],{"class":250},[244,480,464],{"class":254},[244,482,483],{"class":369},"DB_POOL_SIZE",[244,485,470],{"class":254},[244,487,489,492,494,496],{"class":246,"line":488},21,[244,490,491],{"class":458}," max_overflow",[244,493,363],{"class":250},[244,495,464],{"class":254},[244,497,498],{"class":369},"DB_MAX_OVERFLOW\n",[244,500,502],{"class":246,"line":501},22,[244,503,504],{"class":254}," )\n",[244,506,508,511,515,517,520,522,525,528,531,533],{"class":246,"line":507},23,[244,509,510],{"class":254}," logger.info(",[244,512,514],{"class":513},"sYBdl","\"Database connection pool initialized\"",[244,516,406],{"class":254},[244,518,519],{"class":458},"extra",[244,521,363],{"class":250},[244,523,524],{"class":254},"{",[244,526,527],{"class":513},"\"pool_size\"",[244,529,530],{"class":254},": app.settings.",[244,532,483],{"class":369},[244,534,535],{"class":254},"})\n",[244,537,539],{"class":246,"line":538},24,[244,540,541],{"class":254}," \n",[244,543,545],{"class":246,"line":544},25,[244,546,547],{"class":437}," # Record startup duration for observability dashboards\n",[244,549,551,554,556,559,562],{"class":246,"line":550},26,[244,552,553],{"class":254}," init_duration ",[244,555,363],{"class":250},[244,557,558],{"class":254}," time.perf_counter() ",[244,560,561],{"class":250},"-",[244,563,564],{"class":254}," start\n",[244,566,568,570,573,575,577,579,581,584,587,590,593,596,599,601,604],{"class":246,"line":567},27,[244,569,510],{"class":254},[244,571,572],{"class":513},"\"Application startup completed\"",[244,574,406],{"class":254},[244,576,519],{"class":458},[244,578,363],{"class":250},[244,580,524],{"class":254},[244,582,583],{"class":513},"\"duration_ms\"",[244,585,586],{"class":254},": ",[244,588,589],{"class":369},"round",[244,591,592],{"class":254},"(init_duration ",[244,594,595],{"class":250},"*",[244,597,598],{"class":369}," 1000",[244,600,406],{"class":254},[244,602,603],{"class":369},"2",[244,605,606],{"class":254},")})\n",[244,608,610],{"class":246,"line":609},28,[244,611,541],{"class":254},[244,613,615],{"class":246,"line":614},29,[244,616,617],{"class":250}," yield\n",[244,619,621],{"class":246,"line":620},30,[244,622,541],{"class":254},[244,624,626,629,632,635],{"class":246,"line":625},31,[244,627,628],{"class":250}," except",[244,630,631],{"class":369}," Exception",[244,633,634],{"class":250}," as",[244,636,637],{"class":254}," exc:\n",[244,639,641,644,647,649,652,654],{"class":246,"line":640},32,[244,642,643],{"class":254}," logger.critical(",[244,645,646],{"class":513},"\"Lifespan startup failed\"",[244,648,406],{"class":254},[244,650,651],{"class":458},"exc_info",[244,653,363],{"class":250},[244,655,656],{"class":254},"exc)\n",[244,658,660,663,666,669,672,675,677],{"class":246,"line":659},33,[244,661,662],{"class":250}," raise",[244,664,665],{"class":369}," RuntimeError",[244,667,668],{"class":254},"(",[244,670,671],{"class":513},"\"Service initialization aborted due to resource failure\"",[244,673,674],{"class":254},") ",[244,676,269],{"class":250},[244,678,679],{"class":254}," exc\n",[244,681,683,686],{"class":246,"line":682},34,[244,684,685],{"class":250}," finally",[244,687,431],{"class":254},[244,689,691],{"class":246,"line":690},35,[244,692,693],{"class":437}," # Graceful teardown: prevent connection leaks during SIGTERM\n",[244,695,697,700,703,706,709],{"class":246,"line":696},36,[244,698,699],{"class":250}," if",[244,701,702],{"class":369}," hasattr",[244,704,705],{"class":254},"(app.state, ",[244,707,708],{"class":513},"\"db_engine\"",[244,710,711],{"class":254},"):\n",[244,713,715,717],{"class":246,"line":714},37,[244,716,449],{"class":250},[244,718,719],{"class":254}," app.state.db_engine.dispose()\n",[244,721,723,725,728],{"class":246,"line":722},38,[244,724,510],{"class":254},[244,726,727],{"class":513},"\"Database pool disposed successfully\"",[244,729,373],{"class":254},[244,731,733],{"class":246,"line":732},39,[244,734,297],{"emptyLinePlaceholder":296},[244,736,738,741,744,747,750,753,756,758],{"class":246,"line":737},40,[244,739,740],{"class":250},"def",[244,742,743],{"class":384}," create_app",[244,745,746],{"class":254},"(settings: AppSettings ",[244,748,749],{"class":250},"|",[244,751,752],{"class":369}," None",[244,754,755],{"class":250}," =",[244,757,752],{"class":369},[244,759,760],{"class":254},") -> FastAPI:\n",[244,762,764,767,769,772,775],{"class":246,"line":763},41,[244,765,766],{"class":254}," cfg ",[244,768,363],{"class":250},[244,770,771],{"class":254}," settings ",[244,773,774],{"class":250},"or",[244,776,777],{"class":254}," AppSettings.load()\n",[244,779,781],{"class":246,"line":780},42,[244,782,541],{"class":254},[244,784,786,789,791],{"class":246,"line":785},43,[244,787,788],{"class":254}," app ",[244,790,363],{"class":250},[244,792,793],{"class":254}," FastAPI(\n",[244,795,797,800,802,805,808],{"class":246,"line":796},44,[244,798,799],{"class":458}," title",[244,801,363],{"class":250},[244,803,804],{"class":254},"cfg.",[244,806,807],{"class":369},"PROJECT_NAME",[244,809,470],{"class":254},[244,811,813,816,818,820,823],{"class":246,"line":812},45,[244,814,815],{"class":458}," version",[244,817,363],{"class":250},[244,819,804],{"class":254},[244,821,822],{"class":369},"VERSION",[244,824,470],{"class":254},[244,826,828,830,832],{"class":246,"line":827},46,[244,829,397],{"class":458},[244,831,363],{"class":250},[244,833,834],{"class":254},"lifespan,\n",[244,836,838,841,843,846,848,851,854,857,860,863],{"class":246,"line":837},47,[244,839,840],{"class":458}," docs_url",[244,842,363],{"class":250},[244,844,845],{"class":513},"\"\u002Fdocs\"",[244,847,699],{"class":250},[244,849,850],{"class":254}," cfg.",[244,852,853],{"class":369},"ENVIRONMENT",[244,855,856],{"class":250}," !=",[244,858,859],{"class":513}," \"production\"",[244,861,862],{"class":250}," else",[244,864,865],{"class":369}," None\n",[244,867,869],{"class":246,"line":868},48,[244,870,504],{"class":254},[244,872,874,877,879,881],{"class":246,"line":873},49,[244,875,876],{"class":254}," app.settings ",[244,878,363],{"class":250},[244,880,766],{"class":254},[244,882,883],{"class":437},"# Attach validated config to app state\n",[244,885,887],{"class":246,"line":886},50,[244,888,541],{"class":254},[244,890,892,895,898,900,903],{"class":246,"line":891},51,[244,893,894],{"class":254}," app.include_router(api_router, ",[244,896,897],{"class":458},"prefix",[244,899,363],{"class":250},[244,901,902],{"class":513},"\"\u002Fv1\"",[244,904,373],{"class":254},[244,906,908,911],{"class":246,"line":907},52,[244,909,910],{"class":250}," return",[244,912,913],{"class":254}," app\n",[162,915,916,919],{},[183,917,918],{},"Trade-off Analysis:"," Eager initialization guarantees that the service fails fast before accepting traffic, but increases memory footprint. For high-throughput APIs, defer non-critical resource provisioning (e.g., background task schedulers) until first invocation using lazy dependency resolution.",[203,921],{},[206,923,925],{"id":924},"secure-configuration-environment-isolation","Secure Configuration & Environment Isolation",[162,927,928,929,932],{},"Configuration must be validated at build time, not runtime. Injecting secrets directly into route handlers or relying on ",[214,930,931],{},"os.environ"," lookups introduces credential leakage vectors and breaks deterministic testing. Pydantic Settings provides type-safe parsing, strict validation, and explicit environment isolation.",[235,934,936],{"className":237,"code":935,"language":239,"meta":240,"style":240},"from pydantic import PostgresDsn, Field, ValidationError, SecretStr\nfrom pydantic_settings import BaseSettings, SettingsConfigDict\n\nclass AppSettings(BaseSettings):\n model_config = SettingsConfigDict(\n env_file=\".env\",\n env_file_encoding=\"utf-8\",\n extra=\"forbid\", # Reject unknown env vars to prevent misconfiguration\n case_sensitive=True\n )\n \n PROJECT_NAME: str = Field(min_length=3, max_length=50)\n VERSION: str = Field(default=\"1.0.0\")\n ENVIRONMENT: str = Field(pattern=\"^(development|staging|production|test)$\")\n DATABASE_URL: PostgresDsn\n SECRET_KEY: SecretStr = Field(min_length=32)\n DB_POOL_SIZE: int = Field(default=10, ge=2, le=50)\n DB_MAX_OVERFLOW: int = Field(default=5, ge=0, le=20)\n\n @classmethod\n def load(cls) -> \"AppSettings\":\n try:\n instance = cls()\n # Mask secrets in structured logs\n logger.debug(\"Configuration loaded successfully\", extra={\n \"env\": instance.ENVIRONMENT,\n \"pool_size\": instance.DB_POOL_SIZE\n })\n return instance\n except ValidationError as e:\n raise SystemExit(f\"Configuration validation failed:\\n{e}\") from e\n",[214,937,938,950,962,966,981,991,1003,1015,1030,1040,1044,1048,1083,1106,1129,1137,1158,1199,1239,1243,1251,1266,1272,1285,1290,1307,1319,1329,1334,1341,1354],{"__ignoreMap":240},[244,939,940,942,945,947],{"class":246,"line":247},[244,941,269],{"class":250},[244,943,944],{"class":254}," pydantic ",[244,946,251],{"class":250},[244,948,949],{"class":254}," PostgresDsn, Field, ValidationError, SecretStr\n",[244,951,952,954,957,959],{"class":246,"line":258},[244,953,269],{"class":250},[244,955,956],{"class":254}," pydantic_settings ",[244,958,251],{"class":250},[244,960,961],{"class":254}," BaseSettings, SettingsConfigDict\n",[244,963,964],{"class":246,"line":266},[244,965,297],{"emptyLinePlaceholder":296},[244,967,968,971,974,976,979],{"class":246,"line":280},[244,969,970],{"class":250},"class",[244,972,973],{"class":384}," AppSettings",[244,975,668],{"class":254},[244,977,978],{"class":384},"BaseSettings",[244,980,711],{"class":254},[244,982,983,986,988],{"class":246,"line":293},[244,984,985],{"class":254}," model_config ",[244,987,363],{"class":250},[244,989,990],{"class":254}," SettingsConfigDict(\n",[244,992,993,996,998,1001],{"class":246,"line":300},[244,994,995],{"class":458}," env_file",[244,997,363],{"class":250},[244,999,1000],{"class":513},"\".env\"",[244,1002,470],{"class":254},[244,1004,1005,1008,1010,1013],{"class":246,"line":313},[244,1006,1007],{"class":458}," env_file_encoding",[244,1009,363],{"class":250},[244,1011,1012],{"class":513},"\"utf-8\"",[244,1014,470],{"class":254},[244,1016,1017,1020,1022,1025,1027],{"class":246,"line":326},[244,1018,1019],{"class":458}," extra",[244,1021,363],{"class":250},[244,1023,1024],{"class":513},"\"forbid\"",[244,1026,406],{"class":254},[244,1028,1029],{"class":437},"# Reject unknown env vars to prevent misconfiguration\n",[244,1031,1032,1035,1037],{"class":246,"line":339},[244,1033,1034],{"class":458}," case_sensitive",[244,1036,363],{"class":250},[244,1038,1039],{"class":369},"True\n",[244,1041,1042],{"class":246,"line":352},[244,1043,504],{"class":254},[244,1045,1046],{"class":246,"line":357},[244,1047,541],{"class":254},[244,1049,1050,1053,1055,1058,1060,1063,1066,1068,1071,1073,1076,1078,1081],{"class":246,"line":376},[244,1051,1052],{"class":369}," PROJECT_NAME",[244,1054,586],{"class":254},[244,1056,1057],{"class":369},"str",[244,1059,755],{"class":250},[244,1061,1062],{"class":254}," Field(",[244,1064,1065],{"class":458},"min_length",[244,1067,363],{"class":250},[244,1069,1070],{"class":369},"3",[244,1072,406],{"class":254},[244,1074,1075],{"class":458},"max_length",[244,1077,363],{"class":250},[244,1079,1080],{"class":369},"50",[244,1082,373],{"class":254},[244,1084,1085,1088,1090,1092,1094,1096,1099,1101,1104],{"class":246,"line":381},[244,1086,1087],{"class":369}," VERSION",[244,1089,586],{"class":254},[244,1091,1057],{"class":369},[244,1093,755],{"class":250},[244,1095,1062],{"class":254},[244,1097,1098],{"class":458},"default",[244,1100,363],{"class":250},[244,1102,1103],{"class":513},"\"1.0.0\"",[244,1105,373],{"class":254},[244,1107,1108,1111,1113,1115,1117,1119,1122,1124,1127],{"class":246,"line":388},[244,1109,1110],{"class":369}," ENVIRONMENT",[244,1112,586],{"class":254},[244,1114,1057],{"class":369},[244,1116,755],{"class":250},[244,1118,1062],{"class":254},[244,1120,1121],{"class":458},"pattern",[244,1123,363],{"class":250},[244,1125,1126],{"class":513},"\"^(development|staging|production|test)$\"",[244,1128,373],{"class":254},[244,1130,1131,1134],{"class":246,"line":414},[244,1132,1133],{"class":369}," DATABASE_URL",[244,1135,1136],{"class":254},": PostgresDsn\n",[244,1138,1139,1142,1145,1147,1149,1151,1153,1156],{"class":246,"line":425},[244,1140,1141],{"class":369}," SECRET_KEY",[244,1143,1144],{"class":254},": SecretStr ",[244,1146,363],{"class":250},[244,1148,1062],{"class":254},[244,1150,1065],{"class":458},[244,1152,363],{"class":250},[244,1154,1155],{"class":369},"32",[244,1157,373],{"class":254},[244,1159,1160,1163,1165,1168,1170,1172,1174,1176,1179,1181,1184,1186,1188,1190,1193,1195,1197],{"class":246,"line":434},[244,1161,1162],{"class":369}," DB_POOL_SIZE",[244,1164,586],{"class":254},[244,1166,1167],{"class":369},"int",[244,1169,755],{"class":250},[244,1171,1062],{"class":254},[244,1173,1098],{"class":458},[244,1175,363],{"class":250},[244,1177,1178],{"class":369},"10",[244,1180,406],{"class":254},[244,1182,1183],{"class":458},"ge",[244,1185,363],{"class":250},[244,1187,603],{"class":369},[244,1189,406],{"class":254},[244,1191,1192],{"class":458},"le",[244,1194,363],{"class":250},[244,1196,1080],{"class":369},[244,1198,373],{"class":254},[244,1200,1201,1204,1206,1208,1210,1212,1214,1216,1219,1221,1223,1225,1228,1230,1232,1234,1237],{"class":246,"line":441},[244,1202,1203],{"class":369}," DB_MAX_OVERFLOW",[244,1205,586],{"class":254},[244,1207,1167],{"class":369},[244,1209,755],{"class":250},[244,1211,1062],{"class":254},[244,1213,1098],{"class":458},[244,1215,363],{"class":250},[244,1217,1218],{"class":369},"5",[244,1220,406],{"class":254},[244,1222,1183],{"class":458},[244,1224,363],{"class":250},[244,1226,1227],{"class":369},"0",[244,1229,406],{"class":254},[244,1231,1192],{"class":458},[244,1233,363],{"class":250},[244,1235,1236],{"class":369},"20",[244,1238,373],{"class":254},[244,1240,1241],{"class":246,"line":455},[244,1242,297],{"emptyLinePlaceholder":296},[244,1244,1245,1248],{"class":246,"line":473},[244,1246,1247],{"class":384}," @",[244,1249,1250],{"class":369},"classmethod\n",[244,1252,1253,1255,1258,1261,1264],{"class":246,"line":488},[244,1254,394],{"class":250},[244,1256,1257],{"class":384}," load",[244,1259,1260],{"class":254},"(cls) -> ",[244,1262,1263],{"class":513},"\"AppSettings\"",[244,1265,431],{"class":254},[244,1267,1268,1270],{"class":246,"line":501},[244,1269,428],{"class":250},[244,1271,431],{"class":254},[244,1273,1274,1277,1279,1282],{"class":246,"line":507},[244,1275,1276],{"class":254}," instance ",[244,1278,363],{"class":250},[244,1280,1281],{"class":369}," cls",[244,1283,1284],{"class":254},"()\n",[244,1286,1287],{"class":246,"line":538},[244,1288,1289],{"class":437}," # Mask secrets in structured logs\n",[244,1291,1292,1295,1298,1300,1302,1304],{"class":246,"line":544},[244,1293,1294],{"class":254}," logger.debug(",[244,1296,1297],{"class":513},"\"Configuration loaded successfully\"",[244,1299,406],{"class":254},[244,1301,519],{"class":458},[244,1303,363],{"class":250},[244,1305,1306],{"class":254},"{\n",[244,1308,1309,1312,1315,1317],{"class":246,"line":550},[244,1310,1311],{"class":513}," \"env\"",[244,1313,1314],{"class":254},": instance.",[244,1316,853],{"class":369},[244,1318,470],{"class":254},[244,1320,1321,1324,1326],{"class":246,"line":567},[244,1322,1323],{"class":513}," \"pool_size\"",[244,1325,1314],{"class":254},[244,1327,1328],{"class":369},"DB_POOL_SIZE\n",[244,1330,1331],{"class":246,"line":609},[244,1332,1333],{"class":254}," })\n",[244,1335,1336,1338],{"class":246,"line":614},[244,1337,910],{"class":250},[244,1339,1340],{"class":254}," instance\n",[244,1342,1343,1345,1348,1351],{"class":246,"line":620},[244,1344,628],{"class":250},[244,1346,1347],{"class":254}," ValidationError ",[244,1349,1350],{"class":250},"as",[244,1352,1353],{"class":254}," e:\n",[244,1355,1356,1358,1361,1363,1366,1369,1372,1375,1378,1381,1383,1385],{"class":246,"line":625},[244,1357,662],{"class":250},[244,1359,1360],{"class":369}," SystemExit",[244,1362,668],{"class":254},[244,1364,1365],{"class":250},"f",[244,1367,1368],{"class":513},"\"Configuration validation failed:",[244,1370,1371],{"class":369},"\\n{",[244,1373,1374],{"class":254},"e",[244,1376,1377],{"class":369},"}",[244,1379,1380],{"class":513},"\"",[244,1382,674],{"class":254},[244,1384,269],{"class":250},[244,1386,1387],{"class":254}," e\n",[162,1389,1390,1393,1394,1397,1398,1401],{},[183,1391,1392],{},"Runtime Secret Rotation Compatibility:"," The factory pattern enables hot-reloading of credentials by re-instantiating the app or updating ",[214,1395,1396],{},"app.state"," references. When paired with external secret managers (AWS Secrets Manager, HashiCorp Vault), implement a background task that periodically refreshes ",[214,1399,1400],{},"app.settings.SECRET_KEY"," and propagates changes to active connection pools without triggering a full restart.",[203,1403],{},[206,1405,1407],{"id":1406},"router-registration-dependency-wiring","Router Registration & Dependency Wiring",[162,1409,1410],{},"Factories enable conditional router mounting and deterministic dependency overrides. This is essential for isolating external services during integration testing and enforcing feature-flagged endpoints in staging environments.",[235,1412,1414],{"className":237,"code":1413,"language":239,"meta":240,"style":240},"from fastapi import FastAPI\nfrom .config import AppSettings\nfrom .dependencies import get_db_session, get_current_user\nfrom .routers import api_router, admin_router, health_router\n\ndef create_app(settings: AppSettings | None = None) -> FastAPI:\n cfg = settings or AppSettings.load()\n app = FastAPI(title=cfg.PROJECT_NAME, lifespan=lifespan)\n app.settings = cfg\n\n # Conditional routing based on environment or feature flags\n if cfg.ENVIRONMENT in (\"development\", \"staging\"):\n app.include_router(admin_router, prefix=\"\u002Fadmin\", tags=[\"internal\"])\n \n app.include_router(health_router, prefix=\"\u002Fhealth\", tags=[\"observability\"])\n app.include_router(api_router, prefix=\"\u002Fv1\", tags=[\"public\"])\n\n # Wire production dependencies\n app.dependency_overrides[get_db_session] = lambda: app.state.db_engine\n \n # Testing override injection point\n if cfg.ENVIRONMENT == \"test\":\n from .test.mocks import MockDBSession\n app.dependency_overrides[get_current_user] = lambda: {\"sub\": \"test-user\", \"role\": \"admin\"}\n app.dependency_overrides[get_db_session] = MockDBSession\n\n return app\n",[214,1415,1416,1426,1436,1448,1459,1463,1481,1493,1520,1529,1533,1538,1562,1590,1594,1619,1642,1646,1651,1664,1668,1673,1689,1702,1735,1743,1747],{"__ignoreMap":240},[244,1417,1418,1420,1422,1424],{"class":246,"line":247},[244,1419,269],{"class":250},[244,1421,305],{"class":254},[244,1423,251],{"class":250},[244,1425,310],{"class":254},[244,1427,1428,1430,1432,1434],{"class":246,"line":258},[244,1429,269],{"class":250},[244,1431,318],{"class":254},[244,1433,251],{"class":250},[244,1435,323],{"class":254},[244,1437,1438,1440,1443,1445],{"class":246,"line":266},[244,1439,269],{"class":250},[244,1441,1442],{"class":254}," .dependencies ",[244,1444,251],{"class":250},[244,1446,1447],{"class":254}," get_db_session, get_current_user\n",[244,1449,1450,1452,1454,1456],{"class":246,"line":280},[244,1451,269],{"class":250},[244,1453,344],{"class":254},[244,1455,251],{"class":250},[244,1457,1458],{"class":254}," api_router, admin_router, health_router\n",[244,1460,1461],{"class":246,"line":293},[244,1462,297],{"emptyLinePlaceholder":296},[244,1464,1465,1467,1469,1471,1473,1475,1477,1479],{"class":246,"line":300},[244,1466,740],{"class":250},[244,1468,743],{"class":384},[244,1470,746],{"class":254},[244,1472,749],{"class":250},[244,1474,752],{"class":369},[244,1476,755],{"class":250},[244,1478,752],{"class":369},[244,1480,760],{"class":254},[244,1482,1483,1485,1487,1489,1491],{"class":246,"line":313},[244,1484,766],{"class":254},[244,1486,363],{"class":250},[244,1488,771],{"class":254},[244,1490,774],{"class":250},[244,1492,777],{"class":254},[244,1494,1495,1497,1499,1502,1505,1507,1509,1511,1513,1515,1517],{"class":246,"line":326},[244,1496,788],{"class":254},[244,1498,363],{"class":250},[244,1500,1501],{"class":254}," FastAPI(",[244,1503,1504],{"class":458},"title",[244,1506,363],{"class":250},[244,1508,804],{"class":254},[244,1510,807],{"class":369},[244,1512,406],{"class":254},[244,1514,228],{"class":458},[244,1516,363],{"class":250},[244,1518,1519],{"class":254},"lifespan)\n",[244,1521,1522,1524,1526],{"class":246,"line":339},[244,1523,876],{"class":254},[244,1525,363],{"class":250},[244,1527,1528],{"class":254}," cfg\n",[244,1530,1531],{"class":246,"line":352},[244,1532,297],{"emptyLinePlaceholder":296},[244,1534,1535],{"class":246,"line":357},[244,1536,1537],{"class":437}," # Conditional routing based on environment or feature flags\n",[244,1539,1540,1542,1544,1546,1549,1552,1555,1557,1560],{"class":246,"line":376},[244,1541,699],{"class":250},[244,1543,850],{"class":254},[244,1545,853],{"class":369},[244,1547,1548],{"class":250}," in",[244,1550,1551],{"class":254}," (",[244,1553,1554],{"class":513},"\"development\"",[244,1556,406],{"class":254},[244,1558,1559],{"class":513},"\"staging\"",[244,1561,711],{"class":254},[244,1563,1564,1567,1569,1571,1574,1576,1579,1581,1584,1587],{"class":246,"line":381},[244,1565,1566],{"class":254}," app.include_router(admin_router, ",[244,1568,897],{"class":458},[244,1570,363],{"class":250},[244,1572,1573],{"class":513},"\"\u002Fadmin\"",[244,1575,406],{"class":254},[244,1577,1578],{"class":458},"tags",[244,1580,363],{"class":250},[244,1582,1583],{"class":254},"[",[244,1585,1586],{"class":513},"\"internal\"",[244,1588,1589],{"class":254},"])\n",[244,1591,1592],{"class":246,"line":388},[244,1593,541],{"class":254},[244,1595,1596,1599,1601,1603,1606,1608,1610,1612,1614,1617],{"class":246,"line":414},[244,1597,1598],{"class":254}," app.include_router(health_router, ",[244,1600,897],{"class":458},[244,1602,363],{"class":250},[244,1604,1605],{"class":513},"\"\u002Fhealth\"",[244,1607,406],{"class":254},[244,1609,1578],{"class":458},[244,1611,363],{"class":250},[244,1613,1583],{"class":254},[244,1615,1616],{"class":513},"\"observability\"",[244,1618,1589],{"class":254},[244,1620,1621,1623,1625,1627,1629,1631,1633,1635,1637,1640],{"class":246,"line":425},[244,1622,894],{"class":254},[244,1624,897],{"class":458},[244,1626,363],{"class":250},[244,1628,902],{"class":513},[244,1630,406],{"class":254},[244,1632,1578],{"class":458},[244,1634,363],{"class":250},[244,1636,1583],{"class":254},[244,1638,1639],{"class":513},"\"public\"",[244,1641,1589],{"class":254},[244,1643,1644],{"class":246,"line":434},[244,1645,297],{"emptyLinePlaceholder":296},[244,1647,1648],{"class":246,"line":441},[244,1649,1650],{"class":437}," # Wire production dependencies\n",[244,1652,1653,1656,1658,1661],{"class":246,"line":455},[244,1654,1655],{"class":254}," app.dependency_overrides[get_db_session] ",[244,1657,363],{"class":250},[244,1659,1660],{"class":250}," lambda",[244,1662,1663],{"class":254},": app.state.db_engine\n",[244,1665,1666],{"class":246,"line":473},[244,1667,541],{"class":254},[244,1669,1670],{"class":246,"line":488},[244,1671,1672],{"class":437}," # Testing override injection point\n",[244,1674,1675,1677,1679,1681,1684,1687],{"class":246,"line":501},[244,1676,699],{"class":250},[244,1678,850],{"class":254},[244,1680,853],{"class":369},[244,1682,1683],{"class":250}," ==",[244,1685,1686],{"class":513}," \"test\"",[244,1688,431],{"class":254},[244,1690,1691,1694,1697,1699],{"class":246,"line":507},[244,1692,1693],{"class":250}," from",[244,1695,1696],{"class":254}," .test.mocks ",[244,1698,251],{"class":250},[244,1700,1701],{"class":254}," MockDBSession\n",[244,1703,1704,1707,1709,1711,1714,1717,1719,1722,1724,1727,1729,1732],{"class":246,"line":538},[244,1705,1706],{"class":254}," app.dependency_overrides[get_current_user] ",[244,1708,363],{"class":250},[244,1710,1660],{"class":250},[244,1712,1713],{"class":254},": {",[244,1715,1716],{"class":513},"\"sub\"",[244,1718,586],{"class":254},[244,1720,1721],{"class":513},"\"test-user\"",[244,1723,406],{"class":254},[244,1725,1726],{"class":513},"\"role\"",[244,1728,586],{"class":254},[244,1730,1731],{"class":513},"\"admin\"",[244,1733,1734],{"class":254},"}\n",[244,1736,1737,1739,1741],{"class":246,"line":544},[244,1738,1655],{"class":254},[244,1740,363],{"class":250},[244,1742,1701],{"class":254},[244,1744,1745],{"class":246,"line":550},[244,1746,297],{"emptyLinePlaceholder":296},[244,1748,1749,1751],{"class":246,"line":567},[244,1750,910],{"class":250},[244,1752,913],{"class":254},[162,1754,1755,1758,1759,406,1762,1765,1766,1769,1770,179],{},[183,1756,1757],{},"Observability Note:"," Track router registration counts and dependency resolution latency during startup. Implement a custom middleware that logs ",[214,1760,1761],{},"request_id",[214,1763,1764],{},"route_path",", and ",[214,1767,1768],{},"dependency_resolution_time"," to correlate performance regressions with specific endpoint wiring. For comprehensive testing workflows and CI\u002FCD integration patterns, review the ",[166,1771,1773],{"href":1772},"\u002Fcore-architecture-routing-patterns\u002Fapplication-factory-patterns\u002Ffastapi-app-factory-pattern-for-testing-and-deployment\u002F","FastAPI app factory pattern for testing and deployment",[203,1775],{},[206,1777,1779],{"id":1778},"operational-constraints-serverless-readiness","Operational Constraints & Serverless Readiness",[162,1781,1782],{},"Deploying factory-based FastAPI applications to serverless platforms (AWS Lambda, GCP Cloud Run, Vercel) introduces strict latency and memory constraints. Cold starts occur when the execution environment initializes from scratch, making eager resource provisioning a liability.",[219,1784,1786],{"id":1785},"lazy-loading-connection-pooling","Lazy Loading & Connection Pooling",[162,1788,1789],{},"Serverless functions execute in ephemeral containers. Initializing large connection pools or loading ML models at startup increases cold start latency and risks hitting memory limits. Implement deferred initialization:",[235,1791,1793],{"className":237,"code":1792,"language":239,"meta":240,"style":240},"# Lazy dependency pattern for serverless\nasync def get_db_lazy() -> AsyncGenerator[DatabaseSession, None]:\n if not hasattr(app.state, \"db_engine\"):\n app.state.db_engine = await DatabaseEngine.create_pool(app.settings.DATABASE_URL)\n session = app.state.db_engine.session()\n try:\n yield session\n finally:\n await session.close()\n",[214,1794,1795,1800,1816,1831,1846,1856,1862,1870,1876],{"__ignoreMap":240},[244,1796,1797],{"class":246,"line":247},[244,1798,1799],{"class":437},"# Lazy dependency pattern for serverless\n",[244,1801,1802,1804,1806,1809,1812,1814],{"class":246,"line":258},[244,1803,391],{"class":250},[244,1805,394],{"class":250},[244,1807,1808],{"class":384}," get_db_lazy",[244,1810,1811],{"class":254},"() -> AsyncGenerator[DatabaseSession, ",[244,1813,403],{"class":369},[244,1815,411],{"class":254},[244,1817,1818,1820,1823,1825,1827,1829],{"class":246,"line":266},[244,1819,699],{"class":250},[244,1821,1822],{"class":250}," not",[244,1824,702],{"class":369},[244,1826,705],{"class":254},[244,1828,708],{"class":513},[244,1830,711],{"class":254},[244,1832,1833,1835,1837,1839,1842,1844],{"class":246,"line":280},[244,1834,444],{"class":254},[244,1836,363],{"class":250},[244,1838,449],{"class":250},[244,1840,1841],{"class":254}," DatabaseEngine.create_pool(app.settings.",[244,1843,467],{"class":369},[244,1845,373],{"class":254},[244,1847,1848,1851,1853],{"class":246,"line":293},[244,1849,1850],{"class":254}," session ",[244,1852,363],{"class":250},[244,1854,1855],{"class":254}," app.state.db_engine.session()\n",[244,1857,1858,1860],{"class":246,"line":300},[244,1859,428],{"class":250},[244,1861,431],{"class":254},[244,1863,1864,1867],{"class":246,"line":313},[244,1865,1866],{"class":250}," yield",[244,1868,1869],{"class":254}," session\n",[244,1871,1872,1874],{"class":246,"line":326},[244,1873,685],{"class":250},[244,1875,431],{"class":254},[244,1877,1878,1880],{"class":246,"line":339},[244,1879,449],{"class":250},[244,1881,1882],{"class":254}," session.close()\n",[162,1884,1885,1888],{},[183,1886,1887],{},"Trade-offs:"," Lazy loading reduces cold start footprint but shifts initialization latency to the first request. Mitigate this by:",[1890,1891,1892,1895,1898],"ol",{},[190,1893,1894],{},"Pre-warming execution environments with scheduled pings",[190,1896,1897],{},"Using connection proxies (PgBouncer, RDS Proxy) to pool across invocations",[190,1899,1900],{},"Implementing Optimizing FastAPI startup time for serverless alongside FastAPI cold start optimization strategies to balance memory allocation and initialization speed.",[162,1902,1903],{},[183,1904,1905],{},"Observability Metrics for Serverless:",[187,1907,1908,1917,1923,1929],{},[190,1909,1910,1913,1914],{},[214,1911,1912],{},"cold_start_duration_ms",": Time from container init to first ",[214,1915,1916],{},"200 OK",[190,1918,1919,1922],{},[214,1920,1921],{},"connection_pool_init_time_ms",": Database pool creation latency",[190,1924,1925,1928],{},[214,1926,1927],{},"memory_rss_mb",": Resident set size during peak concurrency",[190,1930,1931],{},"Track these via structured logging and push to CloudWatch\u002FDatadog for automated alerting.",[203,1933],{},[206,1935,1937],{"id":1936},"common-production-pitfalls","Common Production Pitfalls",[1939,1940,1941,1960],"table",{},[1942,1943,1944],"thead",{},[1945,1946,1947,1951,1954,1957],"tr",{},[1948,1949,1950],"th",{},"Issue",[1948,1952,1953],{},"Root Cause",[1948,1955,1956],{},"Operational Impact",[1948,1958,1959],{},"Mitigation",[1961,1962,1963,1986,2008],"tbody",{},[1945,1964,1965,1971,1974,1977],{},[1966,1967,1968],"td",{},[183,1969,1970],{},"Global State Leakage Between Requests",[1966,1972,1973],{},"Attaching mutable objects (DB sessions, caches) to module-level scope",[1966,1975,1976],{},"Cross-request contamination, thread-safety violations in async contexts, data corruption",[1966,1978,1979,1980,1982,1983,1985],{},"Instantiate resources inside ",[214,1981,228],{}," or use ",[214,1984,1396],{}," with explicit scoping",[1945,1987,1988,1993,1998,2001],{},[1966,1989,1990],{},[183,1991,1992],{},"Blocking I\u002FO in Startup Events",[1966,1994,1995,1996],{},"Synchronous migrations, heavy model loading, or network calls in ",[214,1997,228],{},[1966,1999,2000],{},"ASGI server blocked, increased TTFB, health check timeouts, orchestration restarts",[1966,2002,2003,2004,2007],{},"Use ",[214,2005,2006],{},"asyncio.to_thread()"," for sync calls, defer non-critical init, implement readiness probes",[1945,2009,2010,2015,2022,2025],{},[1966,2011,2012],{},[183,2013,2014],{},"Hardcoded Router Imports",[1966,2016,2017,2018,2021],{},"Direct ",[214,2019,2020],{},"import routers"," at module level bypasses factory logic",[1966,2023,2024],{},"Unnecessary dependency resolution, increased memory footprint, broken conditional routing",[1966,2026,2027,2028],{},"Import routers dynamically or conditionally within ",[214,2029,216],{},[203,2031],{},[206,2033,2035],{"id":2034},"frequently-asked-questions","Frequently Asked Questions",[162,2037,2038],{},[183,2039,2040],{},"Why use an app factory instead of a single global FastAPI instance?",[162,2042,2043],{},"Factories enable isolated testing environments, environment-specific configuration loading, and prevent global state pollution across concurrent requests or worker processes. A global instance couples initialization logic to runtime execution, making dependency mocking and parallel test execution unreliable.",[162,2045,2046],{},[183,2047,2048],{},"How does the factory pattern impact serverless cold starts?",[162,2050,2051],{},"Properly structured factories allow lazy initialization of heavy resources, significantly reducing cold start latency. By deferring connection pool creation and ML model loading until first invocation, you minimize memory overhead. Pair this with connection pooling proxies and deferred dependency resolution to maintain sub-100ms cold start targets.",[162,2053,2054],{},[183,2055,2056],{},"Can I override dependencies in a factory-built application?",[162,2058,2059,2060,2063],{},"Yes. The factory pattern explicitly supports ",[214,2061,2062],{},"app.dependency_overrides"," by returning a fresh, isolated app instance per test run. This enables deterministic mocking of external services, database sessions, and authentication providers without polluting production state or requiring complex test fixtures.",[2065,2066,2067],"style",{},"html pre.shiki code .sD7c4, html code.shiki .sD7c4{--shiki-default:#D73A49}html pre.shiki code .sgsFI, html code.shiki .sgsFI{--shiki-default:#24292E}html pre.shiki code .sYu0t, html code.shiki .sYu0t{--shiki-default:#005CC5}html pre.shiki code .s7eDp, html code.shiki .s7eDp{--shiki-default:#6F42C1}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html pre.shiki code .sqxcx, html code.shiki .sqxcx{--shiki-default:#E36209}html pre.shiki code .sYBdl, html code.shiki .sYBdl{--shiki-default:#032F62}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}",{"title":240,"searchDepth":258,"depth":258,"links":2069},[2070,2073,2074,2075,2078,2079],{"id":208,"depth":258,"text":209,"children":2071},[2072],{"id":221,"depth":266,"text":222},{"id":924,"depth":258,"text":925},{"id":1406,"depth":258,"text":1407},{"id":1778,"depth":258,"text":1779,"children":2076},[2077],{"id":1785,"depth":266,"text":1786},{"id":1936,"depth":258,"text":1937},{"id":2034,"depth":258,"text":2035},"Implementing Application Factory Patterns is critical for building maintainable, testable, and secure FastAPI services. This guide details how to decouple…","md",{},{"title":81,"description":2080},"9nGKDcno9WVq0eUNIlOdPFPjwFTg3UetcGdeIDv8KIc",[2086,2086],null,1778082655124]