Environment-based configuration in Flask - Step-by-Step Execution

Concept Flow - Environment-based configuration

Start Flask App

↓

Read ENV Variable

↓

Select Config Class

↓

Apply Config to App

↓

Run App with Config

↓

App Behavior Depends on Config

The app starts, reads environment variables to pick the right config, applies it, then runs with those settings.

Execution Sample

Flask

import os
from flask import Flask

class Config:
    DEBUG = False

class DevConfig(Config):
    DEBUG = True

app = Flask(__name__)
config_name = os.getenv('FLASK_ENV', 'default')
if config_name == 'development':
    app.config.from_object(DevConfig)
else:
    app.config.from_object(Config)

@app.route('/')
def home():
    return f"Debug is {app.config['DEBUG']}"

This Flask app reads the FLASK_ENV environment variable to decide if debug mode is on or off.

Execution Table

Step	Action	ENV FLASK_ENV	Config Selected	app.config['DEBUG']	Output
1	Start app	Not read yet	None	None	None
2	Read FLASK_ENV	development	None	None	None
3	Check config_name	development	DevConfig	None	None
4	Apply DevConfig	development	DevConfig	True	None
5	Call home route	development	DevConfig	True	Debug is True
6	End	development	DevConfig	True	App runs with debug True

💡 App runs with configuration based on FLASK_ENV environment variable.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
config_name	None	development	development	development	development
app.config['DEBUG']	None	None	None	True	True

Key Moments - 2 Insights

Why does the app use DevConfig when FLASK_ENV is 'development'?

Because at step 3 in the execution table, the code checks if config_name equals 'development' and then selects DevConfig, which sets DEBUG to True.

What happens if FLASK_ENV is not set?

The code uses the default Config class which has DEBUG set to False, so the app runs without debug mode.

Visual Quiz - 3 Questions

Look at the execution table, what is app.config['DEBUG'] after applying configuration?

A False

B True

C None

D Error

💡 Hint

Check step 4 in the execution table where DevConfig is applied.

At which step does the app decide which configuration to use?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the step where config_name is checked to select the config class.

If FLASK_ENV was set to 'production', what config would be selected?

A DevConfig

B None

C Config

D Error

💡 Hint

The else branch applies Config when FLASK_ENV is not 'development'.

Concept Snapshot

Environment-based configuration in Flask:
- Use environment variables like FLASK_ENV to select config.
- Define config classes with settings (e.g., DEBUG).
- Load config with app.config.from_object().
- App behavior changes based on selected config.
- Helps run app differently in dev, test, production.

Full Transcript

This example shows how a Flask app reads the FLASK_ENV environment variable to choose which configuration class to use. The app defines a base Config class with DEBUG set to False and a DevConfig subclass with DEBUG True. When the app starts, it reads FLASK_ENV. If it is 'development', it applies DevConfig, enabling debug mode. Otherwise, it uses the default Config. The home route returns the current debug setting. This approach lets the app behave differently depending on the environment, like turning on debug mode during development but off in production.

Practice

1. What is the main reason to use environment-based configuration in a Flask app?

easy

A. To avoid using environment variables completely

B. To write all configuration directly in the main app file

C. To separate settings for development, testing, and production environments

D. To hardcode sensitive data like passwords in the code

Solution

1. Step 1: Understand environment-based configuration purpose

   It helps keep different settings for development, testing, and production separate and secure.

2. Step 2: Identify best practice for config management

   Separating configs avoids hardcoding sensitive data and makes the app flexible across environments.

3. Final Answer:

   To separate settings for development, testing, and production environments -> Option C

4. Quick Check:

   Environment-based config = Separate settings [OK]

Hint: Think about keeping dev and prod settings separate [OK]

Common Mistakes:

• Hardcoding all config in one file
• Ignoring environment differences
• Storing secrets in code
• Not using environment variables

2. Which of the following is the correct way to load configuration from a Python class in Flask?

easy

A. app.config.from_object('config.DevelopmentConfig')

B. app.config.from_file('config.py')

C. app.load_config('config.py')

D. app.config.load('DevelopmentConfig')

Solution

1. Step 1: Recall Flask config loading methods

   Flask uses from_object to load config from a Python class.

2. Step 2: Match correct syntax

   app.config.from_object('config.DevelopmentConfig') correctly loads the class named DevelopmentConfig from config module.

3. Final Answer:

   app.config.from_object('config.DevelopmentConfig') -> Option A

4. Quick Check:

   Use from_object to load class config [OK]

Hint: Use from_object with full class path string [OK]

Common Mistakes:

• Using non-existent methods like from_file or load_config
• Passing filename instead of class path
• Missing quotes around class path
• Confusing from_object with from_envvar

3. Given this Flask config setup:

class Config:
    DEBUG = False

class DevelopmentConfig(Config):
    DEBUG = True

app = Flask(__name__)
app.config.from_object(DevelopmentConfig)
print(app.config['DEBUG'])

What will be printed?

medium

A. False

B. KeyError

C. None

D. True

Solution

1. Step 1: Understand class inheritance

   DevelopmentConfig inherits from Config and overrides DEBUG to True.

2. Step 2: Check which config is loaded

   app.config.from_object loads DevelopmentConfig, so DEBUG is True.

3. Final Answer:

   True -> Option D

4. Quick Check:

   Subclass overrides DEBUG = True [OK]

Hint: Subclass config overrides parent values [OK]

Common Mistakes:

• Assuming base class value is used
• Confusing attribute names
• Expecting KeyError for existing keys
• Ignoring inheritance

4. What is wrong with this Flask config loading code?

app = Flask(__name__)
app.config.from_envvar('MY_CONFIG')

Assuming the environment variable MY_CONFIG is not set.

medium

A. It will silently ignore missing MY_CONFIG and use default config

B. It will raise a RuntimeError because MY_CONFIG is missing

C. It will load config from a file named 'MY_CONFIG'

D. It will load config from environment variables automatically

Solution

1. Step 1: Understand from_envvar behavior

   from_envvar expects an environment variable with a filepath; if missing, it raises RuntimeError.

2. Step 2: Check what happens if MY_CONFIG is not set

   Since MY_CONFIG is missing, Flask raises RuntimeError to alert missing config file.

3. Final Answer:

   It will raise a RuntimeError because MY_CONFIG is missing -> Option B

4. Quick Check:

   Missing env var causes RuntimeError [OK]

Hint: from_envvar requires env var set or it errors [OK]

Common Mistakes:

• Assuming it ignores missing env var
• Thinking it loads from env vars automatically
• Confusing from_envvar with from_object
• Expecting silent fallback to defaults

5. You want your Flask app to load different configs based on the environment variable FLASK_ENV. Which code snippet correctly implements this?

hard

A. if os.getenv('FLASK_ENV') == 'production':
app.config.from_object('config.ProductionConfig')
else:
app.config.from_object('config.DevelopmentConfig')

B. app.config.from_object('config.' + FLASK_ENV + 'Config')

C. app.config.from_envvar('FLASK_ENV')

D. app.config.from_object('config.DefaultConfig')

Solution

1. Step 1: Check how to read environment variable

   Use os.getenv('FLASK_ENV') to get the current environment string.

2. Step 2: Use conditional logic to load correct config

   If environment is 'production', load ProductionConfig; otherwise load DevelopmentConfig.

3. Final Answer:

   if os.getenv('FLASK_ENV') == 'production': app.config.from_object('config.ProductionConfig') else: app.config.from_object('config.DevelopmentConfig') -> Option A

4. Quick Check:

   Use os.getenv + if-else to select config [OK]

Hint: Use os.getenv and if-else to pick config class [OK]

Common Mistakes:

• Trying to concatenate string without quotes
• Using from_envvar with FLASK_ENV directly
• Not handling default environment
• Loading only one config regardless of env