AI Agents · Leçon

Profils de configuration pour le développement et la production

Configurations propres à l’environnement, indicateurs de fonctionnalité et déploiements progressifs.

Profils de configuration pour le développement et la production est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Pourquoi les profils de configuration sont importants

Un agent de production et un agent de développement doivent se comporter différemment : niveaux de journalisation différents, niveaux de modèles différents (coût ou qualité), bases de données différentes et limites de débit différentes. Les profils de configuration automatisent cette distinction : une seule variable d’environnement suffit à modifier tous les paramètres.

Détecter l’environnement avec la variable ENV

Le modèle standard consiste à lire une variable ENV (ou ENVIRONMENT) qui identifie le contexte de déploiement actuel. Votre code sélectionne ensuite le profil de configuration approprié en fonction de cette valeur.

import os

# Read the environment identifier
ENV = os.getenv('ENV', 'development').lower()

if ENV not in ('development', 'staging', 'production'):
    raise ValueError(
        f'Invalid ENV value: "{ENV}". '
        f'Must be: development, staging, or production'
    )

print(f'Running in {ENV} mode')

# Usage:
# ENV=development python agent.py   -> dev settings
# ENV=staging python agent.py       -> staging settings
# ENV=production python agent.py    -> prod settings
# python agent.py                   -> defaults to development

Classes de configuration par environnement

Définissez une classe de configuration de base et des sous-classes pour chaque environnement. Chaque sous-classe remplace les valeurs qui diffèrent. Cette approche est plus lisible et offre un meilleur contrôle des types qu’un grand dictionnaire rempli de conditions.

import os

class BaseConfig:
    OPENAI_API_KEY: str = os.environ.get('OPENAI_API_KEY', '')
    MAX_STEPS: int = 20
    LOG_LEVEL: str = 'INFO'
    CACHE_ENABLED: bool = True
    CACHE_TTL_SECONDS: int = 3600

class DevelopmentConfig(BaseConfig):
    MODEL: str = 'gpt-4o-mini'  # cheaper in dev
    LOG_LEVEL: str = 'DEBUG'    # verbose logging in dev
    CACHE_ENABLED: bool = False  # fresh results in dev
    MAX_STEPS: int = 10          # shorter loops in dev

class StagingConfig(BaseConfig):
    MODEL: str = 'gpt-4o-mini'
    LOG_LEVEL: str = 'INFO'
    MAX_STEPS: int = 20

class ProductionConfig(BaseConfig):
    MODEL: str = 'gpt-4o'       # best quality in prod
    LOG_LEVEL: str = 'WARNING'  # less noise in prod
    MAX_STEPS: int = 30         # more steps allowed in prod

if __name__ == '__main__':
    for cls in (DevelopmentConfig, StagingConfig, ProductionConfig):
        c = cls()
        print(f'{cls.__name__}: model={c.MODEL} log_level={c.LOG_LEVEL} max_steps={c.MAX_STEPS} cache={c.CACHE_ENABLED}')

Fabrique de Config : sélectionner le bon profil

Une fonction fabrique de configuration lit la variable ENV et renvoie la classe de configuration appropriée. Cette fonction est le seul endroit qui connaît la logique de sélection de l’environnement.

import os

def get_config():
    env = os.getenv('ENV', 'development').lower()
    configs = {
        'development': DevelopmentConfig,
        'staging': StagingConfig,
        'production': ProductionConfig
    }
    config_class = configs.get(env)
    if not config_class:
        raise ValueError(f'Unknown environment: {env}')
    return config_class()

# Usage throughout your agent:
config = get_config()
print(f'Model: {config.MODEL}')
print(f'Max steps: {config.MAX_STEPS}')
print(f'Log level: {config.LOG_LEVEL}')

# All code uses config.MODEL, config.LOG_LEVEL etc.
# Switching environments requires only changing ENV variable

Paramètres Pydantic pour une configuration typée

pydantic-settings fournit une méthode puissante et sûre du point de vue des types pour définir la configuration. Il lit automatiquement les variables d’environnement, vérifie les types et peut charger des fichiers .env. Installez-le avec pip install pydantic-settings.

# pip install pydantic-settings
from pydantic_settings import BaseSettings
from pydantic import Field
from typing import Literal

class AgentSettings(BaseSettings):
    # Required fields — raise error if not set
    openai_api_key: str
    search_api_key: str

    # Optional with defaults
    env: Literal['development', 'staging', 'production'] = 'development'
    model: str = 'gpt-4o-mini'
    max_steps: int = Field(default=20, ge=1, le=100)  # validated range
    log_level: str = 'INFO'
    cache_enabled: bool = True
    cache_ttl_seconds: int = Field(default=3600, ge=60)

    class Config:
        env_file = '.env'
        case_sensitive = False  # OPENAI_API_KEY -> openai_api_key

# settings = AgentSettings()  # raises ValidationError if required vars missing

Paramètres Pydantic avec des valeurs spécifiques à l’environnement

Combinez Pydantic Settings avec des propriétés calculées pour appliquer des valeurs par défaut propres à l’environnement, tout en permettant aux variables d’environnement de les remplacer.

from pydantic_settings import BaseSettings
from pydantic import model_validator
import os

class AgentSettings(BaseSettings):
    openai_api_key: str
    env: str = 'development'
    model: str = ''
    log_level: str = ''
    max_steps: int = 0

    @model_validator(mode='after')
    def apply_env_defaults(self) -> 'AgentSettings':
        env_defaults = {
            'development': {'model': 'gpt-4o-mini', 'log_level': 'DEBUG', 'max_steps': 10},
            'staging':     {'model': 'gpt-4o-mini', 'log_level': 'INFO',  'max_steps': 20},
            'production':  {'model': 'gpt-4o',      'log_level': 'WARNING', 'max_steps': 30}
        }
        defaults = env_defaults.get(self.env, env_defaults['development'])
        if not self.model:     self.model     = defaults['model']
        if not self.log_level: self.log_level = defaults['log_level']
        if not self.max_steps: self.max_steps = defaults['max_steps']
        return self

    class Config:
        env_file = '.env'

Indicateurs de fonctionnalité par environnement

Utilisez les profils de configuration pour activer ou désactiver des fonctionnalités selon l’environnement. Par exemple, activez l’interface de débogage uniquement en développement, utilisez les paiements réels uniquement en production et dirigez-vous vers des services isolés en préproduction.

import os

class AgentFeatureFlags:
    env = os.getenv('ENV', 'development')

    # Enable memory persistence (requires DB)
    MEMORY_ENABLED: bool = env in ('staging', 'production')

    # Use real payment processing
    REAL_PAYMENTS: bool = env == 'production'

    # Enable verbose step-by-step output
    VERBOSE_STEPS: bool = env == 'development'

    # Use cheap model for unit test runs
    FORCE_MINI_MODEL: bool = os.getenv('CI') == 'true'

flags = AgentFeatureFlags()
print(f'Memory: {flags.MEMORY_ENABLED}')
print(f'Verbose: {flags.VERBOSE_STEPS}')
print(f'Payments: {flags.REAL_PAYMENTS}')

Valider la configuration au démarrage

Validez toute la configuration au démarrage et affichez un récapitulatif afin que les opérateurs puissent vérifier que l’agent est correctement configuré avant qu’il ne commence son traitement. Vous éviterez ainsi les erreurs de configuration silencieuses en production.

import os
import sys

def validate_and_print_config(config) -> None:
    print(f'=== Agent Configuration ===')
    print(f'Environment : {config.env}')
    print(f'Model       : {config.model}')
    print(f'Max steps   : {config.max_steps}')
    print(f'Log level   : {config.log_level}')
    print(f'Cache       : {"enabled" if config.cache_enabled else "disabled"}')
    print(f'OpenAI key  : ...{config.openai_api_key[-4:]}')
    print('===========================')

    # Critical validations
    if config.env == 'production' and config.log_level == 'DEBUG':
        print('WARNING: DEBUG logging in production exposes sensitive data!')

    if not config.openai_api_key:
        print('FATAL: OPENAI_API_KEY not set')
        sys.exit(1)

    print('Configuration validated.')

if __name__ == '__main__':
    from types import SimpleNamespace
    demo_config = SimpleNamespace(
        env='development', model='gpt-4o-mini', max_steps=10,
        log_level='DEBUG', cache_enabled=False, openai_api_key='sk-demo-1234'
    )
    validate_and_print_config(demo_config)

Remplacer des valeurs de configuration selon l’environnement

Dans les chaînes CI/CD, remplacez certaines valeurs de configuration sans modifier l’intégralité du profil. Transmettez des variables individuelles en plus de la variable ENV afin de personnaliser les paramètres d’un déploiement donné.

# Staging deployment with custom model override:
# ENV=staging AGENT_MODEL=gpt-4o python agent.py

# Production with reduced max_steps for cost control:
# ENV=production AGENT_MAX_STEPS=15 python agent.py

# CI test run — use production profile but with cheap model:
# ENV=production AGENT_MODEL=gpt-4o-mini CI=true python agent.py

# The config class reads ENV first for the profile,
# then individual overrides take precedence:
import os

env = os.getenv('ENV', 'development')
config = get_config()  # loads base profile for env

# Individual overrides applied on top:
if os.getenv('AGENT_MODEL'):
    config.MODEL = os.getenv('AGENT_MODEL')
if os.getenv('AGENT_MAX_STEPS'):
    config.MAX_STEPS = int(os.getenv('AGENT_MAX_STEPS'))

print(f'Final model: {config.MODEL}')

Documenter les profils de configuration pour l’équipe

Documentez clairement vos profils de configuration, dans des commentaires du code, dans README, ou dans les deux. Les nouveaux développeurs doivent comprendre ce qui change entre les environnements pour pouvoir déployer en toute confiance.

# config_profiles.py — Configuration per environment
#
# | Setting        | development    | staging        | production  |
# |----------------|----------------|----------------|-------------|
# | MODEL          | gpt-4o-mini    | gpt-4o-mini    | gpt-4o      |
# | MAX_STEPS      | 10             | 20             | 30          |
# | LOG_LEVEL      | DEBUG          | INFO           | WARNING     |
# | CACHE_ENABLED  | False          | True           | True        |
# | MEMORY_DB      | SQLite (local) | PostgreSQL     | PostgreSQL  |
#
# To switch environments:
#   ENV=staging python agent.py
#
# To override a single setting:
#   ENV=production AGENT_MAX_STEPS=15 python agent.py

print('Config profile table documents all per-environment differences')

Configuration des tests : profil de test imposé

Les tests doivent toujours utiliser une configuration de test précise, jamais les paramètres de production. Créez une fixture de configuration de test qui applique les paramètres appropriés et empêche tout appel accidentel aux API de production.

import os
import pytest

@pytest.fixture(autouse=True)
def test_environment(monkeypatch):
    'Force test configuration for all tests'
    monkeypatch.setenv('ENV', 'test')
    monkeypatch.setenv('AGENT_MODEL', 'gpt-4o-mini')
    monkeypatch.setenv('AGENT_MAX_STEPS', '5')  # short loops in tests
    monkeypatch.setenv('LOG_LEVEL', 'DEBUG')
    monkeypatch.setenv('CACHE_ENABLED', 'false')
    # Use a fake API key — tests should mock all LLM calls
    monkeypatch.setenv('OPENAI_API_KEY', 'test-key-not-real')

# This fixture runs before every test automatically
# Tests cannot accidentally use production settings

Vérification des connaissances : profils de configuration

Vérifiez votre compréhension des profils de configuration propres à chaque environnement.

Récapitulatif : profils de configuration pour le développement et la production

Vous disposez désormais d’une stratégie complète de gestion de la configuration des agents dans différents environnements :

Utilisez une variable ENV pour identifier le contexte de déploiement
Définissez des classes de configuration pour chaque environnement avec des valeurs par défaut appropriées
Utilisez une fabrique de configuration pour sélectionner automatiquement le bon profil
Utilisez pydantic-settings pour une configuration vérifiée et sûre du point de vue des types
Utilisez des indicateurs de fonctionnalité pour activer ou désactiver des fonctionnalités selon l’environnement
Validez et affichez la configuration au démarrage afin que les opérateurs puissent vérifier les paramètres
Imposez une configuration de test dans les fixtures de pytest pour empêcher les appels vers la production

Une bonne gestion de la configuration permet de déployer en toute sécurité la même base de code en développement, en préproduction et en production.

Questions Fréquemment Posées

La leçon « Profils de configuration pour le développement et la production » est-elle gratuite ?

Oui — le texte complet de « Profils de configuration pour le développement et la production » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Profils de configuration pour le développement et la production » ?

Configurations propres à l’environnement, indicateurs de fonctionnalité et déploiements progressifs. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Profils de configuration pour le développement et la production » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Variables d’environnement pour les agents
Fichiers .env et python-dotenv
Rotation et sécurité des secrets
Profils de configuration pour le développement et la production

← Retour à AI Agents