Background file processing in FastAPI - Mini Project: Build & Apply

Background File Processing with FastAPI

📖 Scenario: You are building a simple web service that accepts file uploads. To keep the service fast and responsive, you want to process the uploaded files in the background without making the user wait.

🎯 Goal: Create a FastAPI app that accepts a file upload and processes the file content in the background using FastAPI's BackgroundTasks. The app should immediately respond to the user while the file processing happens asynchronously.

📋 What You'll Learn

Create a FastAPI app instance named app

Create a POST endpoint /upload/ that accepts a file upload with parameter file of type UploadFile

Use BackgroundTasks to run a function called process_file in the background

The process_file function should read the file content and simulate processing by writing the content length to a file named processed.txt

Return a JSON response immediately confirming the file upload

💡 Why This Matters

🌍 Real World

Web applications often need to handle file uploads without making users wait for long processing times. Background file processing allows the app to stay responsive while handling heavy tasks.

💼 Career

Understanding background tasks in FastAPI is valuable for backend developers building scalable and user-friendly APIs that handle file uploads or other time-consuming operations.

1

Set up FastAPI app and import modules

Import FastAPI, UploadFile, and BackgroundTasks from fastapi. Create a FastAPI app instance called app.

FastAPI

from fastapi import FastAPI, UploadFile, BackgroundTasks

# Create FastAPI app instance
# Your code here

Hint

Use app = FastAPI() to create the app instance.

2

Create the background processing function

Define a function called process_file that takes one parameter file of type UploadFile. Inside the function, read the file content asynchronously using await file.read() and write the length of the content to a file named processed.txt.

FastAPI

from fastapi import FastAPI, UploadFile, BackgroundTasks

app = FastAPI()

# Define background file processing function
# Your code here

Hint

Use async def and await file.read() to read the file content asynchronously.

3

Create the file upload endpoint with background task

Create a POST endpoint /upload/ using @app.post. The endpoint function called upload_file should accept parameters: file of type UploadFile and background_tasks of type BackgroundTasks. Inside the function, add the background task to call process_file with the uploaded file. Return a JSON response with key message and value "File upload received".

FastAPI

from fastapi import FastAPI, UploadFile, BackgroundTasks

app = FastAPI()

async def process_file(file: UploadFile):
    content = await file.read()
    with open('processed.txt', 'w') as f:
        f.write(f'File content length: {len(content)}')

# Create POST endpoint /upload/ with background task
# Your code here

Hint

Use background_tasks.add_task(process_file, file) to run the file processing in the background.

4

Add file upload parameter type and run the app

Ensure the file parameter in the upload_file endpoint is annotated as UploadFile. Add the necessary import for UploadFile if missing. This completes the FastAPI app for background file processing.

FastAPI

from fastapi import FastAPI, UploadFile, BackgroundTasks

app = FastAPI()

async def process_file(file: UploadFile):
    content = await file.read()
    with open('processed.txt', 'w') as f:
        f.write(f'File content length: {len(content)}')

@app.post('/upload/')
async def upload_file(file: UploadFile, background_tasks: BackgroundTasks):
    background_tasks.add_task(process_file, file)
    return {"message": "File upload received"}

# Confirm UploadFile type annotation and imports
# Your code here

Hint

Make sure the file parameter is typed as UploadFile for FastAPI to handle file uploads correctly.

Practice

1. What is the main benefit of using BackgroundTasks in FastAPI for file processing?

easy

A. It allows slow tasks to run after sending the response, keeping the app fast.

B. It automatically compresses files before saving.

C. It blocks the request until the file is fully processed.

D. It encrypts files during upload.

Solution

1. Step 1: Understand the role of BackgroundTasks

   BackgroundTasks in FastAPI lets you run tasks after the response is sent, so the user doesn't wait.

2. Step 2: Identify the benefit for file processing

   Running slow file processing in the background keeps the app responsive and fast for users.

3. Final Answer:

   It allows slow tasks to run after sending the response, keeping the app fast. -> Option A

4. Quick Check:

   BackgroundTasks = run slow tasks after response [OK]

Hint: BackgroundTasks run after response to keep app fast [OK]

Common Mistakes:

• Thinking BackgroundTasks block the response
• Assuming BackgroundTasks handle file encryption
• Believing BackgroundTasks compress files automatically

2. Which of the following is the correct way to add a background task for file processing in a FastAPI endpoint?

easy

A. def upload(file: UploadFile, background_tasks: BackgroundTasks): process_file(file)

B. def upload(file: UploadFile): process_file(file) background_tasks.add_task()

C. def upload(file: UploadFile): background_tasks = BackgroundTasks() process_file(file)

D. def upload(file: UploadFile, background_tasks: BackgroundTasks): background_tasks.add_task(process_file, file)

Solution

1. Step 1: Check function parameters

   To use BackgroundTasks, it must be a parameter in the endpoint function.

2. Step 2: Add the task correctly

   Use background_tasks.add_task(function, args) to schedule the task after response.

3. Final Answer:

   def upload(file: UploadFile, background_tasks: BackgroundTasks): background_tasks.add_task(process_file, file) -> Option D

4. Quick Check:

   Use add_task with BackgroundTasks parameter [OK]

Hint: Add tasks using background_tasks.add_task inside endpoint [OK]

Common Mistakes:

• Calling process_file directly inside endpoint
• Not including BackgroundTasks as a parameter
• Creating BackgroundTasks inside the function without adding tasks

3. Given this FastAPI code snippet, what will be the response behavior when a file is uploaded?

from fastapi import FastAPI, UploadFile, BackgroundTasks
app = FastAPI()

def save_file(file: UploadFile):
    with open(f"saved_{file.filename}", "wb") as f:
        f.write(file.file.read())

@app.post("/upload")
async def upload(file: UploadFile, background_tasks: BackgroundTasks):
    background_tasks.add_task(save_file, file)
    return {"message": "File upload started"}

medium

A. The response returns immediately with message, while file saving happens in background.

B. The response waits until the file is saved, then returns the message.

C. The file is saved before the response, but no message is returned.

D. The code will raise an error because file.file.read() is not allowed.

Solution

1. Step 1: Analyze background task usage

   The save_file function is added as a background task, so it runs after response.

2. Step 2: Understand response timing

   The endpoint returns the message immediately, without waiting for save_file to finish.

3. Final Answer:

   The response returns immediately with message, while file saving happens in background. -> Option A

4. Quick Check:

   BackgroundTasks run after response = immediate reply [OK]

Hint: BackgroundTasks run after response, so response is immediate [OK]

Common Mistakes:

• Assuming file saving blocks response
• Thinking file.file.read() causes error here
• Believing no message is returned

4. Identify the error in this FastAPI endpoint for background file processing:

from fastapi import FastAPI, UploadFile, BackgroundTasks
app = FastAPI()

def process_file(file: UploadFile):
    content = file.file.read()
    with open(f"processed_{file.filename}", "wb") as f:
        f.write(content)

@app.post("/upload")
async def upload(file: UploadFile, background_tasks: BackgroundTasks):
    background_tasks.add_task(process_file, file.file.read())
    return {"message": "Processing started"}

medium

A. Missing await keyword before background_tasks.add_task call.

B. Passing file.file.read() instead of file causes the file to be read too early.

C. process_file should be async but is defined as sync.

D. File is not saved before background task starts.

Solution

1. Step 1: Check argument passed to add_task

   The code passes file.file.read() which reads the file immediately, not the file object.

2. Step 2: Understand why this is a problem

   Reading the file before background task means the task gets raw bytes, not the file to read later, causing errors or empty data.

3. Final Answer:

   Passing file.file.read() instead of file causes the file to be read too early. -> Option B

4. Quick Check:

   Pass file object, not file.file.read() to background task [OK]

Hint: Pass file object, not file.file.read(), to background task [OK]

Common Mistakes:

• Thinking add_task needs await
• Believing process_file must be async
• Ignoring file saving order

5. You want to save an uploaded file immediately and then process it in the background. Which FastAPI code snippet correctly implements this pattern?

hard

A. async def upload(file: UploadFile, background_tasks: BackgroundTasks):
background_tasks.add_task(process_file, file)
return {"message": "Processing started"}

B. async def upload(file: UploadFile):
contents = await file.read()
with open(f"saved_{file.filename}", "wb") as f:
f.write(contents)
process_file(f"saved_{file.filename}")
return {"message": "File saved and processed"}

C. async def upload(file: UploadFile, background_tasks: BackgroundTasks):
contents = await file.read()
with open(f"saved_{file.filename}", "wb") as f:
f.write(contents)
background_tasks.add_task(process_file, f"saved_{file.filename}")
return {"message": "File saved and processing started"}

D. async def upload(file: UploadFile, background_tasks: BackgroundTasks):
background_tasks.add_task(process_file, file.file.read())
return {"message": "Processing started"}

Solution

1. Step 1: Save file before background processing

   The file is read and saved immediately using await file.read() and writing to disk.

2. Step 2: Add background task with saved filename

   The background task processes the saved file path, ensuring file exists before processing.

3. Final Answer:

   Save file first, then add background task with saved filename. -> Option C

4. Quick Check:

   Save file first, then background task with filename [OK]

Hint: Save file first, then add background task with filename [OK]

Common Mistakes:

• Adding background task before saving file
• Passing file.file.read() instead of file or filename
• Calling process_file synchronously inside endpoint