Environment variable management in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of environment variables in a FastAPI application?

Environment variables store configuration settings outside the code. This helps keep sensitive data like API keys or database URLs safe and allows easy changes without editing the code.

beginner

How do you load environment variables from a .env file in FastAPI?

You can use the python-dotenv package to load variables from a .env file. Call load_dotenv() at the start of your app to make variables available via os.getenv().

intermediate

What is the role of Pydantic's BaseSettings in managing environment variables?

Pydantic's BaseSettings helps define settings as Python classes. It automatically reads environment variables and validates them, making configuration safer and easier to manage.

beginner

Why should sensitive information like passwords not be hardcoded in FastAPI code?

Hardcoding secrets risks exposing them if code is shared or uploaded publicly. Using environment variables keeps secrets outside the code, reducing security risks.

intermediate

How can you access an environment variable named 'DATABASE_URL' in FastAPI using Pydantic BaseSettings?

Define a class inheriting from <code>BaseSettings</code> with a field <code>database_url: str</code>. Then create an instance and access <code>settings.database_url</code>. Pydantic reads the value from the environment automatically.

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

A python-dotenv

B fastapi-env

C env-loader

D dotenv-fastapi

The python-dotenv package is widely used to load environment variables from .env files in Python projects including FastAPI.

What does Pydantic's BaseSettings class do in FastAPI?

A Creates database connections automatically

B Manages and validates environment variables as settings

C Handles HTTP requests and responses

D Generates API documentation

BaseSettings helps define configuration settings that are read from environment variables and validated.

Why is it better to use environment variables for secrets instead of hardcoding them?

A To avoid using external packages

B To make the code run faster

C To keep secrets safe and separate from code

D To reduce the size of the code file

Storing secrets in environment variables keeps them out of the codebase, improving security.

How do you access an environment variable in Python after loading it?

A Using os.getenv('VARIABLE_NAME')

B Using sys.env('VARIABLE_NAME')

C Using env.get('VARIABLE_NAME')

D Using os.env('VARIABLE_NAME')

The os module's getenv function is used to access environment variables in Python.

Which of these is NOT a benefit of using environment variables in FastAPI?

A Easier configuration changes without code edits

B Better separation of code and settings

C Improved security for sensitive data

D Automatic code optimization

Environment variables help with configuration and security but do not optimize code automatically.

Explain how to manage environment variables in a FastAPI project using python-dotenv and Pydantic BaseSettings.

Think about loading, defining, and accessing environment variables safely.

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

Consider risks of sharing code and benefits of separation.

Practice

1. What is the main reason to use environment variables in a FastAPI project?

easy

A. To keep sensitive information like API keys out of the code

B. To make the code run faster

C. To store user data permanently

D. To create new API endpoints automatically

Solution

1. Step 1: Understand environment variables purpose

   Environment variables are used to keep sensitive data like passwords or API keys separate from the code to improve security.

2. Step 2: Identify the correct reason in FastAPI context

   FastAPI uses environment variables to avoid hardcoding secrets, which helps keep them safe and flexible.

3. Final Answer:

   To keep sensitive information like API keys out of the code -> Option A

4. Quick Check:

   Environment variables = keep secrets safe [OK]

Hint: Environment variables store secrets, not speed or data [OK]

Common Mistakes:

• Thinking environment variables speed up code
• Confusing environment variables with database storage
• Assuming environment variables create API routes

2. Which of the following is the correct way to get an environment variable named API_KEY using Python's os module in FastAPI?

easy

A. api_key = os.get('API_KEY')

B. api_key = os.getenv('API_KEY')

C. api_key = os.environ.get('API_KEY')()

D. api_key = os.getenv(API_KEY)

Solution

1. Step 1: Recall correct os module function

   The correct function to get environment variables is os.getenv('VAR_NAME').

2. Step 2: Check syntax correctness

   api_key = os.getenv('API_KEY') uses os.getenv('API_KEY') correctly with quotes around the variable name and no extra parentheses.

3. Final Answer:

   api_key = os.getenv('API_KEY') -> Option B

4. Quick Check:

   Use os.getenv('VAR') to get environment variables [OK]

Hint: Use os.getenv('VAR_NAME') with quotes [OK]

Common Mistakes:

• Using os.get instead of os.getenv
• Calling os.environ.get with extra parentheses
• Not quoting the environment variable name

3. Given this FastAPI code snippet using Pydantic's BaseSettings:

from pydantic import BaseSettings

class Settings(BaseSettings):
    app_name: str
    debug_mode: bool = False

settings = Settings()

If the environment variable APP_NAME is set to "MyApp" and DEBUG_MODE is not set, what will settings.app_name and settings.debug_mode be?

medium

A. None and None

B. "MyApp" and True

C. None and False

D. "MyApp" and False

Solution

1. Step 1: Understand BaseSettings behavior

   Pydantic BaseSettings reads environment variables matching attribute names in uppercase by default.

2. Step 2: Check provided environment variables and defaults

   APP_NAME is set to "MyApp", so settings.app_name is "MyApp". DEBUG_MODE is not set, so it uses the default False.

3. Final Answer:

   "MyApp" and False -> Option D

4. Quick Check:

   Env var set = value, missing uses default [OK]

Hint: Unset vars use default values in BaseSettings [OK]

Common Mistakes:

• Assuming missing env vars become True
• Thinking unset vars become None instead of default
• Confusing attribute names with env var names

4. What is wrong with this FastAPI environment variable usage code?

import os

API_KEY = os.getenv('API_KEY')
print(f"API key is {API_KEY.upper()}")

Assuming API_KEY is not set in the environment.

medium

A. It will raise an AttributeError because API_KEY is None

B. It will print 'API key is ' with empty string

C. It will raise a SyntaxError

D. It will print the string 'None'

Solution

1. Step 1: Check os.getenv behavior when var missing

   os.getenv returns None if the environment variable is not set and no default is given.

2. Step 2: Understand what happens calling upper() on None

   Calling None.upper() raises an AttributeError because NoneType has no method upper().

3. Final Answer:

   It will raise an AttributeError because API_KEY is None -> Option A

4. Quick Check:

   None.upper() causes AttributeError [OK]

Hint: Check for None before calling string methods [OK]

Common Mistakes:

• Assuming os.getenv returns empty string if missing
• Expecting no error when calling upper() on None
• Confusing AttributeError with SyntaxError

5. You want to manage environment variables in FastAPI using Pydantic's BaseSettings and ensure a default port of 8000 if PORT is not set. Which code snippet correctly achieves this?

hard

A. class Settings(BaseSettings):
port: int

settings = Settings(port=8000)

B. class Settings(BaseSettings):
port: int

settings = Settings() # default 8000 if missing

C. class Settings(BaseSettings):
port: int = 8000

settings = Settings()

D. class Settings(BaseSettings):
port: str = '8000'

settings = Settings()

Solution

1. Step 1: Define default value in BaseSettings attribute

   Setting port: int = 8000 provides a default if the environment variable PORT is missing.

2. Step 2: Instantiate Settings without arguments

   Calling Settings() reads environment variables or uses defaults if missing, so port will be 8000 if PORT is unset.

3. Final Answer:

   class Settings(BaseSettings): port: int = 8000 settings = Settings() -> Option C

4. Quick Check:

   Default values in BaseSettings = default used if env var missing [OK]

Hint: Set default in class attribute for fallback [OK]

Common Mistakes:

• Not providing default and expecting fallback
• Passing default in constructor instead of attribute
• Using string type for port instead of int