0Pricing
AI Agents · Lección

Perfiles de configuración para desarrollo y producción

Configuraciones específicas del entorno, indicadores de funcionalidades y despliegues por etapas.

Perfiles de configuración para desarrollo y producción es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.

Por qué son importantes los perfiles de configuración

Un agente de producción y uno de desarrollo deberían comportarse de forma diferente: distintos niveles de registro, distintos niveles de modelo (coste frente a calidad), distintas bases de datos y distintos límites de tasa. Los perfiles de configuración automatizan estas diferencias: una sola variable de entorno cambia todos los ajustes a la vez.

Detección del entorno con la variable ENV

El patrón estándar consiste en leer una variable ENV (o ENVIRONMENT) que identifique el contexto de implementación actual. A continuación, el código selecciona el perfil de configuración adecuado según este valor.

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

Clases de configuración por entorno

Defina una clase de configuración base y subclases para cada entorno. Cada subclase sobrescribe los valores que difieren. Esto resulta más legible y seguro en cuanto a tipos que un diccionario grande de condicionales.

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}')

Fábrica de configuración: selección del perfil adecuado

Una función de fábrica de configuración lee la variable ENV y devuelve la clase de configuración adecuada. Esta única función es el único lugar que conoce la lógica de cambio de entorno.

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

Pydantic Settings para una configuración con tipos

pydantic-settings ofrece una forma potente y segura en cuanto a tipos de definir la configuración. Lee automáticamente las variables de entorno, valida los tipos y puede cargar datos desde archivos .env. Instálelo con 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

Pydantic Settings con sobrescrituras específicas del entorno

Combine Pydantic Settings con propiedades calculadas para aplicar valores predeterminados específicos del entorno que aún puedan sobrescribirse mediante variables de entorno.

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'

Indicadores de funcionalidades por entorno

Use perfiles de configuración para habilitar o deshabilitar funcionalidades según el entorno. Por ejemplo, habilite la interfaz de depuración únicamente en desarrollo, use pagos reales solo en producción y dirija el tráfico a servicios aislados en staging.

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}')

Validación de la configuración al iniciar

Valide toda la configuración al iniciar y muestre un resumen para que los operadores puedan comprobar que el agente está configurado correctamente antes de comenzar a procesar solicitudes. Así evitará configuraciones incorrectas silenciosas en producción.

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)

Sobrescritura de valores de configuración por entorno

En las canalizaciones de CI/CD, sobrescriba valores de configuración específicos sin cambiar todo el perfil. Pase variables individuales junto con la variable ENV para personalizar los ajustes de una implementación concreta.

# 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}')

Documentación de perfiles de configuración para el equipo

Documente claramente sus perfiles de configuración, ya sea en comentarios del código, en el README o en ambos. Los nuevos desarrolladores deben entender qué cambia entre entornos para poder realizar implementaciones con confianza.

# 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')

Configuración en las pruebas: perfil de pruebas forzado

Las pruebas siempre deberían ejecutarse con una configuración de pruebas específica, nunca con los ajustes de producción. Cree un fixture de configuración de pruebas que aplique los ajustes adecuados y evite cualquier llamada accidental a las API de producción.

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

Comprobación de conocimientos: perfiles de configuración

Compruebe sus conocimientos sobre los perfiles de configuración específicos de cada entorno.

Resumen: perfiles de configuración para desarrollo y producción

Ahora dispone de una estrategia completa de gestión de la configuración para agentes en distintos entornos:

  • Use una variable ENV para identificar el contexto de implementación
  • Defina clases de configuración por entorno con los valores predeterminados adecuados
  • Use una fábrica de configuración para seleccionar automáticamente el perfil adecuado
  • Use pydantic-settings para disponer de una configuración validada y segura en cuanto a tipos
  • Use indicadores de funcionalidades para habilitarlas o deshabilitarlas según el entorno
  • Valide y muestre la configuración al iniciar para que los operadores puedan comprobar los ajustes
  • Fuerce una configuración de pruebas en los fixtures de pytest para evitar llamadas a producción

Una buena gestión de la configuración permite implementar de forma segura la misma base de código en desarrollo, staging y producción.

Preguntas frecuentes

¿La lección «Perfiles de configuración para desarrollo y producción» es gratis?

Sí — el texto completo de «Perfiles de configuración para desarrollo y producción» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.

¿Qué aprenderé en «Perfiles de configuración para desarrollo y producción»?

Configuraciones específicas del entorno, indicadores de funcionalidades y despliegues por etapas. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Agents?

No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Perfiles de configuración para desarrollo y producción»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Agents?

Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Variables de entorno para agentes
  2. Archivos .env y python-dotenv
  3. Rotación y seguridad de secretos
  4. Perfiles de configuración para desarrollo y producción
← Volver a AI Agents