Configuration management in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is configuration management in FastAPI?

Configuration management in FastAPI is the practice of organizing and handling settings and parameters that control how the application behaves, such as database URLs, secret keys, and debug modes.

beginner

How does Pydantic help with configuration management in FastAPI?

Pydantic helps by defining settings as Python classes with type validation, making sure configuration values are correct and easy to access throughout the app.

beginner

What is the purpose of environment variables in FastAPI configuration?

Environment variables store configuration outside the code, allowing different settings for development, testing, and production without changing the app code.

intermediate

Show a simple example of a Pydantic settings class for FastAPI.

from pydantic import BaseSettings

class Settings(BaseSettings):
    app_name: str = "My FastAPI App"
    debug: bool = False
    database_url: str

    class Config:
        env_file = ".env"

settings = Settings()

beginner

Why is it important to keep sensitive data like secret keys out of source code in FastAPI?

Keeping sensitive data out of source code prevents accidental exposure when sharing or publishing code, improving security by using environment variables or secret managers instead.

Which Python library is commonly used in FastAPI for managing configuration settings?

A SQLAlchemy

B Requests

C Pydantic

D Flask

Pydantic is used to define and validate configuration settings in FastAPI.

Where should you store environment-specific settings like database URLs in FastAPI?

A Hardcoded in the source code

B In environment variables or .env files

C In HTML files

D In JavaScript files

Environment variables or .env files keep settings flexible and secure across environments.

What does the Config class inside a Pydantic settings class do?

A Defines the database schema

B Handles HTTP requests

C Runs the FastAPI server

D Specifies where to load environment variables from

The Config class can specify the .env file location for loading environment variables.

Why use Pydantic BaseSettings instead of a normal class for configuration?

A It automatically validates and parses environment variables

B It makes the app run faster

C It creates HTML templates

D It manages database connections

BaseSettings helps validate and load config values from environment variables automatically.

What is a good practice for managing secret keys in FastAPI?

A Use environment variables or secret managers

B Send them in HTTP responses

C Write them in comments

D Store them in the source code

Using environment variables or secret managers keeps secrets safe and out of code.

Explain how you would set up configuration management in a FastAPI app using Pydantic and environment variables.

Think about how to keep settings organized and secure.

Why is separating configuration from code important in FastAPI projects?

Consider how apps change from development to production.

Practice

1. What is the primary purpose of using pydantic.BaseSettings in a FastAPI application?

easy

A. To generate API documentation

B. To manage application configuration using environment variables or .env files

C. To handle HTTP request routing

D. To create database models automatically

Solution

1. Step 1: Understand the role of pydantic.BaseSettings

   BaseSettings is designed to load configuration values from environment variables or .env files.

2. Step 2: Differentiate from other FastAPI features

   Database models, routing, and documentation are handled by other parts of FastAPI, not BaseSettings.

3. Final Answer:

   To manage application configuration using environment variables or .env files -> Option B

4. Quick Check:

   Configuration management = To manage application configuration using environment variables or .env files [OK]

Hint: Remember: BaseSettings is for config, not routing or DB [OK]

Common Mistakes:

• Confusing BaseSettings with database model classes
• Thinking BaseSettings handles API routing
• Assuming BaseSettings generates docs

2. Which of the following is the correct way to define a FastAPI settings class using pydantic.BaseSettings?

easy

A. def Settings(): return BaseSettings(app_name="MyApp")

B. class Settings: app_name = BaseSettings("MyApp")

C. class Settings(BaseModel): app_name: str = "MyApp"

D. class Settings(BaseSettings): app_name: str = "MyApp"

Solution

1. Step 1: Check class inheritance

   The settings class must inherit from BaseSettings to load environment variables.

2. Step 2: Verify attribute definition

   Attributes are defined as class variables with type annotations and default values.

3. Final Answer:

   class Settings(BaseSettings): app_name: str = "MyApp" -> Option D

4. Quick Check:

   Correct inheritance and attribute syntax = class Settings(BaseSettings): app_name: str = "MyApp" [OK]

Hint: Settings class must inherit BaseSettings with typed attributes [OK]

Common Mistakes:

• Using BaseModel instead of BaseSettings
• Defining settings as a function
• Incorrect inheritance or attribute assignment

3. Given this settings class and environment variable API_KEY=secret123 set, what will print(settings.api_key) output?

from pydantic import BaseSettings

class Settings(BaseSettings):
    api_key: str

settings = Settings()

medium

A. '' (empty string)

B. None

C. secret123

D. Raises a validation error

Solution

1. Step 1: Understand environment variable loading

   BaseSettings automatically reads environment variables matching attribute names in uppercase.

2. Step 2: Check if API_KEY is set

   The environment variable API_KEY=secret123 is set, so settings.api_key will be 'secret123'.

3. Final Answer:

   secret123 -> Option C

4. Quick Check:

   Env var API_KEY loads as 'secret123' [OK]

Hint: BaseSettings reads uppercase env vars matching attribute names [OK]

Common Mistakes:

• Assuming missing default means None instead of error
• Thinking attribute names are case-sensitive differently
• Expecting empty string if env var is set

4. Identify the error in this FastAPI settings code snippet:

from pydantic import BaseSettings

class Settings(BaseSettings):
    debug: bool = False

settings = Settings(debug="foo")

medium

A. Passing a string "foo" instead of a boolean causes a validation error

B. Missing environment variable causes failure

C. BaseSettings cannot have default values

D. Class must inherit from BaseModel, not BaseSettings

Solution

1. Step 1: Check type of passed value

   The debug attribute expects a boolean, but the code passes a string "foo".

2. Step 2: Understand Pydantic validation

   Pydantic tries to coerce the string to bool but "foo" is not recognized, causing a ValidationError.

3. Final Answer:

   Passing a string "foo" instead of a boolean causes a validation error -> Option A

4. Quick Check:

   Pydantic rejects invalid bool strings like "foo" [OK]

Hint: Pydantic bool fields reject invalid strings like "foo" [OK]

Common Mistakes:

• Thinking Pydantic converts any string to bool
• Missing environment variable causes failure
• BaseSettings cannot have default values

5. You want to load configuration from a .env file and override some values with environment variables in FastAPI. Which approach correctly achieves this using pydantic.BaseSettings?

hard

A. Create a Settings class inheriting BaseSettings with class Config: env_file = '.env' and place a .env file in the project root; environment variables override .env values automatically

B. Manually read .env file with open() and parse it, then pass values to Settings constructor

C. Use BaseModel instead of BaseSettings and load .env with dotenv package separately

D. Set environment variables only; .env files are not supported by BaseSettings

Solution

1. Step 1: Understand BaseSettings .env support

   BaseSettings loads .env files when env_file='.env' is set in the inner Config class.

2. Step 2: Know environment variable precedence

   Environment variables override .env file values automatically when both exist.

3. Final Answer:

   Create a Settings class inheriting BaseSettings with class Config: env_file = '.env' and place a .env file in the project root; environment variables override .env values automatically -> Option A

4. Quick Check:

   BaseSettings loads .env via Config env_file and env vars override [OK]

Hint: BaseSettings loads .env via Config(env_file='.env'); env vars override .env values [OK]

Common Mistakes:

• Manually parsing .env instead of using BaseSettings Config
• Using BaseModel which lacks .env support
• Thinking .env files are unsupported by BaseSettings