Environment-based settings in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of environment-based settings in FastAPI?

Environment-based settings help you configure your FastAPI app differently for development, testing, and production without changing the code. This keeps your app flexible and secure.

beginner

How can you load environment variables in a FastAPI project?

You can use the python-dotenv package to load variables from a .env file or use the OS environment variables directly with Python's os.environ.

intermediate

What is Pydantic's role in managing environment-based settings in FastAPI?

Pydantic's <code>BaseSettings</code> class lets you define settings as Python classes. It automatically reads environment variables and validates them, making configuration safe and easy.

beginner

Why should sensitive data like API keys be stored in environment variables instead of code?

Storing sensitive data in environment variables keeps secrets out of your codebase. This protects them from accidental sharing and makes it easier to change them without touching the code.

intermediate

How do you switch between different environment settings (e.g., development vs production) in FastAPI?

You can create different .env files or set environment variables differently on each machine. Your FastAPI app reads these variables at startup to adjust behavior accordingly.

Which Python package is commonly used to load environment variables from a file in FastAPI?

A python-dotenv

B requests

C fastapi-utils

D uvicorn

The python-dotenv package loads environment variables from a .env file into the environment.

What class from Pydantic helps manage environment-based settings in FastAPI?

A BaseModel

B BaseSettings

C Config

D SettingsManager

Pydantic's BaseSettings class is designed to read and validate environment variables as settings.

Why is it important to keep API keys in environment variables rather than hardcoding them?

A To keep secrets secure and avoid accidental exposure

B To make the code run faster

C To reduce file size

D To make the app compatible with all browsers

Environment variables keep sensitive data out of the code, protecting secrets from exposure.

How does FastAPI typically access environment variables in code?

A Using HTML forms

B Using SQL queries

C Using os.environ or Pydantic BaseSettings

D Using JavaScript

FastAPI uses Python's os.environ or Pydantic BaseSettings to read environment variables.

What is a common file name used to store environment variables locally?

A variables.txt

B settings.yaml

C config.json

D .env

The .env file is a standard way to store environment variables locally.

Explain how you would set up environment-based settings in a FastAPI project using Pydantic.

Think about how Pydantic reads environment variables and validates them.

Describe why environment-based settings improve security and flexibility in FastAPI applications.

Consider how separating config from code helps in real projects.

Practice

1. What is the main purpose of using environment-based settings in a FastAPI application?

easy

A. To change app behavior without modifying the code

B. To speed up the app's response time

C. To add more routes automatically

D. To create user interfaces dynamically

Solution

1. Step 1: Understand environment-based settings concept

   Environment-based settings allow configuration changes without changing the code itself.

2. Step 2: Identify the main benefit in FastAPI

   This lets the app behave differently in development, testing, or production by just changing environment variables.

3. Final Answer:

   To change app behavior without modifying the code -> Option A

4. Quick Check:

   Environment-based settings = change behavior without code change [OK]

Hint: Think: change settings without touching code [OK]

Common Mistakes:

• Confusing settings with performance improvements
• Thinking it automatically adds routes
• Assuming it creates UI elements

2. Which of the following is the correct way to define a settings class using Pydantic's BaseSettings in FastAPI?

easy

A. class Settings(BaseModel):\n debug: bool = False

B. class Settings(BaseSettings):\n debug: bool = False

C. class Settings(dict):\n debug: bool = False

D. class Settings(object):\n debug: bool = False

Solution

1. Step 1: Recall correct base class for environment settings

   Pydantic's BaseSettings is designed for environment-based config loading.

2. Step 2: Check class definition syntax

   Using BaseSettings with typed attributes and default values is correct.

3. Final Answer:

   class Settings(BaseSettings):\n debug: bool = False -> Option B

4. Quick Check:

   Use BaseSettings for env config classes [OK]

Hint: Use BaseSettings, not BaseModel, for env configs [OK]

Common Mistakes:

• Using BaseModel instead of BaseSettings
• Inheriting from dict or object directly
• Missing type annotations

3. Given this FastAPI settings class and .env file, what will be the value of settings.debug?

class Settings(BaseSettings):
    debug: bool = False

settings = Settings()

.env file content:

DEBUG=true

medium

A. False

B. Error: missing attribute

C. True

D. None

Solution

1. Step 1: Understand BaseSettings behavior with .env

   BaseSettings reads environment variables and overrides defaults if present.

2. Step 2: Check .env value for DEBUG

   The .env file sets DEBUG=true, which overrides the default False.

3. Final Answer:

   True -> Option C

4. Quick Check:

   .env overrides default values in BaseSettings [OK]

Hint: .env values override defaults in BaseSettings [OK]

Common Mistakes:

• Assuming default stays despite .env
• Confusing string 'true' with boolean
• Expecting error if .env exists

4. What is wrong with this FastAPI settings code that tries to load environment variables?

from pydantic import BaseSettings

class Settings(BaseSettings):
    api_key: str

settings = Settings()

Assuming no environment variable API_KEY is set.

medium

A. It will silently ignore missing api_key

B. It will set api_key to an empty string

C. It will set api_key to None

D. It will raise a validation error because api_key is required but missing

Solution

1. Step 1: Check required fields in BaseSettings

   Fields without defaults are required and must be provided via env or arguments.

2. Step 2: Consider missing environment variable

   Since API_KEY is not set, BaseSettings raises a validation error on instantiation.

3. Final Answer:

   It will raise a validation error because api_key is required but missing -> Option D

4. Quick Check:

   Missing required env vars cause validation errors [OK]

Hint: Required fields without defaults must be set in env [OK]

Common Mistakes:

• Expecting default empty string or None
• Thinking missing vars are ignored
• Assuming no error on missing required field

5. You want to create a FastAPI settings class that loads a database URL from environment variables but uses a default if none is set. Which code correctly implements this with Pydantic's BaseSettings?

hard

A. class Settings(BaseSettings):\n database_url: str = 'sqlite:///default.db'

B. class Settings(BaseSettings):\n database_url: str

C. class Settings(BaseSettings):\n database_url: str = Field(default_factory=lambda: 'sqlite:///default.db')

D. class Settings(BaseSettings):\n database_url: Optional[str] = None

Solution

1. Step 1: Understand default values with environment override

   Using a default value directly allows configuration from environment variables if present, falling back to the default otherwise.

2. Step 2: Compare options for correct default and override behavior

   class Settings(BaseSettings):\n database_url: str = 'sqlite:///default.db' uses a direct default value, overridden by DATABASE_URL env var if set.

3. Final Answer:

   class Settings(BaseSettings):\n database_url: str = 'sqlite:///default.db' -> Option A

4. Quick Check:

   Direct default = env override if present [OK]

Hint: Direct field default: str = 'default' for env override [OK]

Common Mistakes:

• Leaving field required without default
• Using Field(default_factory=...) unnecessarily (requires Field import)
• Using Optional[str] = None (defaults to None)