Connection lifecycle management in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a FastAPI app with a startup event handler.

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.on_event("[1]")
async def startup_event():
    print("App is starting up")

Drag options to blanks, or click blank then click option'

Astartup

Bon_startup

Con_start

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect event names like 'start' or 'on_start'.

Forgetting to use the @app.on_event decorator.

The correct decorator for startup events in FastAPI is @app.on_event("startup"). Here, the blank is filled with startup.

2fill in blank

medium

Complete the code to define a shutdown event handler in FastAPI.

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.on_event("[1]")
async def shutdown_event():
    print("App is shutting down")

Drag options to blanks, or click blank then click option'

Astop

Bstart

Cshutdown

Dclose

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'stop' or 'close' instead of 'shutdown'.

Not using the @app.on_event decorator.

The correct event name for shutdown in FastAPI is "shutdown". This decorator runs the function when the app is closing.

3fill in blank

hard

Fix the error in the code to properly close a database connection on shutdown.

FastAPI

from fastapi import FastAPI

app = FastAPI()
db = None

@app.on_event("startup")
async def connect_db():
    global db
    db = await connect_to_db()

@app.on_event("[1]")
async def close_db():
    await db.close()

Drag options to blanks, or click blank then click option'

Astart

Bclose

Cstop

Dshutdown

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'close' or 'stop' instead of 'shutdown'.

Not awaiting the close method.

The shutdown event must be named "shutdown" to properly register the close_db function to run when the app stops.

4fill in blank

hard

Fill both blanks to create a dependency that opens and closes a database connection per request.

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

async def get_db():
    db = await connect_to_db()
    try:
        yield db
    finally:
        await db.[1]()

@app.get("/items")
async def read_items(db = Depends([2])):
    return await db.fetch_items()

Drag options to blanks, or click blank then click option'

Aclose

Bconnect

Cget_db

Ddisconnect

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'disconnect' instead of 'close'.

Passing 'connect' instead of the dependency function to Depends.

The database connection should be closed with close() in the finally block. The dependency function is get_db, which is passed to Depends.

5fill in blank

hard

Fill all three blanks to create a FastAPI app that manages a resource with startup and shutdown events and a route using that resource.

FastAPI

from fastapi import FastAPI

app = FastAPI()
resource = None

@app.on_event("[1]")
async def startup():
    global resource
    resource = await open_resource()

@app.on_event("[2]")
async def shutdown():
    await resource.[3]()

Drag options to blanks, or click blank then click option'

Astartup

Bshutdown

Cclose

Dopen

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up event names.

Using 'open' instead of 'close' to release the resource.

The startup event is named "startup", the shutdown event is "shutdown", and the resource is closed with close().

Practice

1. What is the main purpose of using yield in FastAPI dependencies for connection lifecycle management?

easy

A. To setup a resource before the request and clean it up after the request

B. To define a synchronous function only

C. To permanently keep a connection open for all requests

D. To return multiple values from a function

Solution

1. Step 1: Understand yield in dependencies

   In FastAPI, yield is used in dependencies to create a setup before the request and a cleanup after the request finishes.

2. Step 2: Identify the lifecycle role

   This pattern ensures resources like database connections open before and close after each request, preventing leaks.

3. Final Answer:

   To setup a resource before the request and clean it up after the request -> Option A

4. Quick Check:

   Yield in dependencies = setup and cleanup per request [OK]

Hint: Yield in dependencies means setup before and cleanup after request [OK]

Common Mistakes:

• Thinking yield returns multiple values at once
• Assuming yield keeps connection open forever
• Confusing yield with async context managers

2. Which of the following is the correct way to define a FastAPI dependency that opens a connection before a request and closes it after using yield?

easy

A. def get_conn():
conn = open_conn()
yield conn
return
conn.close()

B. def get_conn():
conn = open_conn()
return conn
conn.close()

C. async def get_conn():
conn = open_conn()
yield conn
conn.close()

D. def get_conn():
conn = open_conn()
yield conn
conn.close()

Solution

1. Step 1: Check the use of yield for setup and cleanup

   def get_conn(): conn = open_conn() yield conn conn.close() correctly uses yield to provide the connection and then closes it after the request.

2. Step 2: Identify syntax and flow correctness

   def get_conn(): conn = open_conn() return conn conn.close() returns before closing, so cleanup never runs. async def get_conn(): conn = open_conn() yield conn conn.close() mixes async with a sync open_conn (may cause issues). def get_conn(): conn = open_conn() yield conn return conn.close() returns early after yield, skipping cleanup.

3. Final Answer:

   def get_conn(): conn = open_conn() yield conn conn.close() -> Option D

4. Quick Check:

   Yield then cleanup = correct dependency pattern [OK]

Hint: Yield must be followed by cleanup code, not return [OK]

Common Mistakes:

• Placing return before cleanup code
• Using async without async resource
• Returning after yield instead of cleanup

3. Given this FastAPI dependency:

async def get_db():
    db = await connect_db()
    try:
        yield db
    finally:
        await db.disconnect()

What happens when a request finishes using this dependency?

medium

A. An error occurs because yield cannot be used with async

B. The database connection remains open for reuse

C. The database connection is closed asynchronously after the request

D. The connection is closed before the request starts

Solution

1. Step 1: Analyze async dependency with yield and finally

   The yield pauses the function to provide db during the request, then finally runs cleanup after the request.

2. Step 2: Understand async cleanup

   The await db.disconnect() runs after the request finishes, closing the connection asynchronously.

3. Final Answer:

   The database connection is closed asynchronously after the request -> Option C

4. Quick Check:

   Async yield with finally = async cleanup after request [OK]

Hint: Async yield with finally cleans up after request ends [OK]

Common Mistakes:

• Thinking yield can't be async
• Assuming connection stays open
• Confusing order of cleanup

4. Identify the error in this FastAPI startup event handler:

@app.on_event("startup")
@asynccontextmanager
async def startup():
    await connect_to_service()
    yield
    await disconnect_from_service()

medium

A. Missing async keyword before function definition

B. Cannot combine @app.on_event with @asynccontextmanager on the same function

C. Yield cannot be used in async functions

D. No error, this is correct usage

Solution

1. Step 1: Understand decorator usage for startup events

   The @app.on_event("startup") expects a normal async function, not an async context manager.

2. Step 2: Recognize conflict of decorators

   Using @asynccontextmanager with @app.on_event on the same function is invalid because FastAPI expects a coroutine, not a context manager.

3. Final Answer:

   Cannot combine @app.on_event with @asynccontextmanager on the same function -> Option B

4. Quick Check:

   @app.on_event and @asynccontextmanager cannot be combined [OK]

Hint: Don't mix @app.on_event with @asynccontextmanager on one function [OK]

Common Mistakes:

• Assuming yield is invalid in async functions
• Forgetting async keyword
• Thinking this pattern is valid

5. You want to manage a database connection pool that opens once when the FastAPI app starts and closes when it shuts down. Which is the best way to implement this lifecycle management?

hard

A. Use @app.on_event("startup") to open and @app.on_event("shutdown") to close the pool directly without context managers

B. Use a dependency with yield to open and close the pool per request

C. Open the pool globally outside FastAPI and never close it

D. Use @asynccontextmanager to create a context manager function and call it in @app.on_event("startup") and @app.on_event("shutdown")

Solution

1. Step 1: Understand app-wide resource lifecycle

   A connection pool should open once at app startup and close at shutdown, not per request.

2. Step 2: Choose correct FastAPI pattern

   Using @app.on_event("startup") and @app.on_event("shutdown") to open and close the pool directly is the simplest and recommended way.

3. Step 3: Why not others?

   Use @asynccontextmanager to create a context manager function and call it in @app.on_event("startup") and @app.on_event("shutdown") misuses @asynccontextmanager with events. Use a dependency with yield to open and close the pool per request opens/closes per request, which is inefficient. Open the pool globally outside FastAPI and never close it never closes, risking resource leaks.

4. Final Answer:

   Use @app.on_event("startup") to open and @app.on_event("shutdown") to close the pool directly without context managers -> Option A

5. Quick Check:

   App startup/shutdown events manage global resources best [OK]

Hint: Use startup and shutdown events for global resource management [OK]

Common Mistakes:

• Opening/closing pool per request wastes resources
• Not closing pool causes leaks
• Misusing asynccontextmanager for app events