Docker containerization in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when running this FastAPI app inside a Docker container?

Consider this FastAPI app code running inside a Docker container. What will the response be when accessing http://localhost:8000/hello?

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.get('/hello')
async def say_hello():
    return {'message': 'Hello from Docker!'}

A {"message": "Hello from Docker!"}

B 404 Not Found error

C 500 Internal Server Error

D Empty response with status 200

💡 Hint

Think about what the FastAPI route returns as JSON.

The FastAPI app defines a GET endpoint at '/hello' that returns a JSON with key 'message' and value 'Hello from Docker!'. When accessed correctly, the container serves this JSON response.

📝 Syntax

intermediate

Which Dockerfile snippet correctly exposes the FastAPI app port?

You want to expose port 8000 in your Dockerfile for a FastAPI app. Which snippet correctly does this?

A EXPOSE port 8000

B EXPOSE '8000'

C EXPOSE 8000

D EXPOSE:8000

💡 Hint

Check the Dockerfile syntax for exposing ports.

The correct Dockerfile syntax to expose a port is EXPOSE 8000 without quotes or extra words.

🔧 Debug

advanced

Why does the FastAPI app inside Docker fail to start with this command?

Given this Dockerfile CMD, the FastAPI app fails to start inside the container. What is the cause?

FastAPI

CMD ["uvicorn", "main:app"]

A uvicorn is not installed in the container

B Missing the --host 0.0.0.0 option to listen on all interfaces

C CMD should be a shell command string, not a JSON array

D The app should be run with python main.py instead

💡 Hint

Think about how Docker networking works and what IP the app listens on.

By default, uvicorn listens on 127.0.0.1 inside the container, which is not accessible externally. Adding --host 0.0.0.0 makes it listen on all interfaces, allowing external access.

❓ state_output

advanced

What is the value of the environment variable inside the FastAPI app running in Docker?

The Dockerfile sets ENV GREETING=Hi. Inside the FastAPI app, this code runs:

import os
from fastapi import FastAPI
app = FastAPI()

@app.get('/greet')
async def greet():
    return {"greeting": os.getenv('GREETING')}

What will the endpoint return?

A 500 Internal Server Error

B {"greeting": null}

C {"greeting": ""}

D {"greeting": "Hi"}

💡 Hint

Consider how environment variables set in Dockerfile are accessed in the app.

The environment variable GREETING is set in the Dockerfile and is accessible inside the container. The app reads it with os.getenv and returns its value.

🧠 Conceptual

expert

Which statement best explains why multi-stage builds are used in Docker for FastAPI apps?

Multi-stage builds help optimize Docker images. Which option correctly explains their main benefit for FastAPI apps?

A They separate build dependencies from runtime, reducing final image size

B They allow running multiple FastAPI apps in one container

C They enable automatic scaling of FastAPI apps inside Docker

D They provide a GUI to manage Docker containers

💡 Hint

Think about how build tools and runtime requirements differ.

Multi-stage builds let you install heavy build tools in one stage, then copy only the needed runtime files to the final image. This keeps the image small and efficient.