Python 配置（conf）管理完全指南

余光705
0 阅读6分钟

Python 配置管理完全指南

从基础到高级，一文读懂 Python 项目配置管理的最佳实践
适用场景：Web 应用、AI 项目、数据工程、微服务架构

📋 目录

一、为什么需要配置管理？

1.1 没有配置管理的灾难

想象一下，如果配置硬编码在代码里：

# ❌ 错误示范：配置硬编码
class DatabaseService:
   def __init__(self):
        self.host = "localhost"           # 换环境要改代码！
        self.port = 3307
        self.user= "atguigu"
        self.password = "Atguigu.123"     # 密码泄露风险！
        self.database = "meta"
        
# 问题：
# 1. 开发环境 → 生产环境，需要修改源代码
# 2. 敏感信息（密码）暴露在代码仓库
# 3. 无法灵活调整参数（如连接池大小）
# 4. 团队协作时，每个人的本地配置不同，容易冲突

1.2 配置管理的目标

目标说明示例
代码与配置分离不改代码，只改配置换数据库只需改 YAML
类型安全启动时就发现类型错误port: "abc" 立即报错
环境隔离开发/测试/生产环境独立config.dev.yaml, config.prod.yaml
敏感信息保护密码、密钥不入库使用环境变量或密钥管理服务
灵活扩展轻松添加新配置项新增 LLM 配置不影响旧代码

二、传统/基础方案详解

2.1 键值对配置 - configparser (INI)

适用场景： 简单的分组键值对配置

示例
; config.ini
[database]
host = localhost
port = 3307
user= atguigu
password = Atguigu.123
database = meta

[logging]
level = INFO
path = logs

# 读取配置
import configparser

config = configparser.ConfigParser()
config.read('config.ini')

# 访问配置
db_host = config['database']['host']
db_port = config.getint('database', 'port')  # 自动转 int
log_level = config['logging']['level']
优缺点分析
✅ 优点❌ 缺点
Python 内置，无需安装不支持嵌套结构
语法简单直观数据类型单一（都是字符串）
适合小型脚本无法表达复杂关系

推荐指数： ⭐⭐（仅适合超简单场景）

2.2 结构化配置 - JSON / YAML

JSON 方案
{
  "database": {
    "host": "localhost",
    "port": 3307,
    "credentials": {
      "user": "atguigu",
      "password": "secret"
    }
  },
  "logging": {
    "level": "INFO",
    "handlers": ["console", "file"]
  }
}

import json

with open('config.json', 'r') as f:
   config = json.load(f)

db_host = config['database']['host']

JSON 特点：

  • ✅ 通用格式，所有语言都支持
  • ✅ 解析速度快
  • ❌ 不支持注释（大忌！）
  • ❌ 语法严格（逗号、引号不能错）
YAML 方案（推荐）
# config.yaml
database:
  host: localhost
  port: 3307
  credentials:
    user: atguigu
   password: ${DB_PASSWORD}  # 支持环境变量引用
  
logging:
  level: INFO
  handlers:
    - console
    - file
  
# 支持注释！可读性极佳
llm:
  model_name: deepseek-chat  # 可切换为 qwen-plus
  temperature: 0             # SQL 生成需要确定性

# 需要安装 PyYAML: pip install pyyaml
import yaml

with open('config.yaml', 'r', encoding='utf-8') as f:
   config = yaml.safe_load(f)

db_host = config['database']['host']
llm_model = config['llm']['model_name']

YAML 特点：

  • ✅ 支持注释（关键优势！）
  • ✅ 可读性最佳（缩进清晰）
  • ✅ 支持列表、嵌套字典
  • ❌ 缩进敏感（空格数必须一致）
  • ❌ 类型需自行验证（port: "abc" 不会报错）

推荐指数： ⭐⭐⭐⭐（大多数场景够用）

2.3 环境变量 - os.environ + python-dotenv

适用场景： 敏感信息、容器化部署、12 要素应用

基础用法
import os

# 方式 1：系统环境变量
db_password = os.environ.get('DB_PASSWORD')

# 方式 2：从 .env 文件加载（开发环境方便）
from dotenv import load_dotenv

load_dotenv('.env')  # 加载当前目录的.env 文件

db_host = os.getenv('DB_HOST', 'localhost')  # 有默认值
db_password = os.getenv('DB_PASSWORD')       # 必填

# .env 文件（不要提交到 Git！）
DB_HOST=localhost
DB_PORT=3307
DB_USER=atguigu
DB_PASSWORD=Atguigu.123
DB_NAME=meta

# 敏感信息
LLM_API_KEY=sk-xxxxxxxxxxxxx
SECRET_KEY=your-secret-key-here
生产环境最佳实践
# config.py
import os
from typing import Optional

class Config:
    """从环境变量读取配置"""
    
    DATABASE_URL = os.getenv(
        'DATABASE_URL',
        f"mysql+asyncmy://{os.getenv('DB_USER')}:{os.getenv('DB_PASSWORD')}@{os.getenv('DB_HOST')}:{os.getenv('DB_PORT')}/{os.getenv('DB_NAME')}"
    )
    
    LLM_API_KEY = os.getenv('LLM_API_KEY')  # 必填，没有会抛异常
    if not LLM_API_KEY:
       raise ValueError("LLM_API_KEY 环境变量未设置！")
    
    DEBUG = os.getenv('DEBUG', 'false').lower() == 'true'

# Docker Compose 中
services:
  app:
   image: myapp:latest
   environment:
      - DB_HOST=mysql
      - DB_PASSWORD=${DB_PASSWORD}  # 从宿主机的环境变量传入
      - LLM_API_KEY=${LLM_API_KEY}

环境变量特点：

  • ✅ 安全性最高（密码不进代码库）
  • ✅ 符合 12 要素原则
  • ✅ 容器化/云原生标准做法
  • ❌ 只适合扁平键值（无法表达嵌套结构）
  • ❌ 大量配置时会很繁琐

推荐指数： ⭐⭐⭐⭐（配合 YAML 使用）

2.4 代码即配置 - Python 模块

适用场景： 配置逻辑复杂、需要动态计算

# settings.py
import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent

DEBUG = True

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'mydb',
        'HOST': os.getenv('DB_HOST', 'localhost'),
        'PORT': os.getenv('DB_PORT', '3306'),
    }
}

# 动态计算配置
if DEBUG:
    LOGGING_LEVEL = 'DEBUG'
    EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
else:
    LOGGING_LEVEL = 'WARNING'
    EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

# 使用第三方库
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',
    }
}

# 其他模块导入
from settings import DEBUG, DATABASES

if DEBUG:
    print("调试模式开启")

特点：

  • ✅ 极其灵活，可执行任意 Python 代码
  • ✅ 可利用 Python 生态（Path、os 等）
  • ❌ 安全隐患大（如果配置文件来自不可信来源）
  • ❌ 配置与代码耦合（改配置需要重启服务）

推荐指数： ⭐⭐⭐（适合 Django 等框架）

2.5 命令行参数 - argparse

适用场景： 临时覆盖配置、脚本运行时选项

# train.py
import argparse

parser= argparse.ArgumentParser(description='训练脚本')
parser.add_argument('--epochs', type=int, default=10, help='训练轮数')
parser.add_argument('--batch-size', type=int, default=32, help='批次大小')
parser.add_argument('--lr', type=float, default=0.001, help='学习率')
parser.add_argument('--data-path', type=str, required=True, help='数据路径')

args = parser.parse_args()

# 使用参数
print(f"训练 {args.epochs} 轮，批次大小 {args.batch_size}")

# 运行
python train.py --epochs 50 --batch-size 64 --data-path ./data

特点：

  • ✅ 灵活，交互性强
  • ✅ 适合实验性场景
  • ❌ 不适合管理大量固定配置

推荐指数： ⭐⭐⭐（作为补充手段）

2.6 基础方案通用流程

无论用哪种，都需要自己处理：

# ❌ 传统方式：需要手写大量样板代码
import json
import os
from dotenv import load_dotenv

# 1. 加载 YAML
with open('config.yaml', 'r') as f:
   config = yaml.safe_load(f)

# 2. 用环境变量覆盖
db_password = os.getenv('DB_PASSWORD')
if db_password:
   config['database']['password'] = db_password

# 3. 手动验证类型
port = config['database']['port']
if not isinstance(port, int):
   raise TypeError(f"port 必须是整数，得到 {type(port)}")

# 4. 访问配置（没有智能提示）
db_host = config['database']['host']

痛点：

  1. 需要自己写加载、合并、验证逻辑
  2. 类型不安全（运行时才发现问题）
  3. IDE 没有智能提示
  4. 多个配置文件难以优雅合并

三、现代高级方案详解 OmegaConf

3.1 OmegaConf 核心特性

OmegaConf 是 Hydra 项目的配置核心，解决了传统方案的所有痛点。

特性对比表
特性传统方案OmegaConf 方案解决的问题
统一接口不同格式不同 APIcfg.key.subkey 通吃无需记多种解析方法
类型验证手动检查集成 dataclass/Pydantic启动时就发现错误
智能合并自己写逻辑OmegaConf.merge()基础 + 环境 + 实验配置
动态覆盖需要 argparseCLI 直接覆盖python app.py db.port=3308
变量插值字符串拼接${other.key}避免重复值

3.2 OmegaConf 快速上手

安装
pip install omegaconf
基础示例
from omegaconf import OmegaConf

# 1. 从字典创建
cfg = OmegaConf.create({
    'database': {
        'host': 'localhost',
        'port': 3307
    },
    'debug': True
})

# 2. 访问配置（点号语法）
print(cfg.database.host)  # → "localhost"
print(cfg.debug)          # → True

# 3. 从 YAML 文件加载
cfg = OmegaConf.load('config.yaml')

# 4. 转为普通字典（兼容旧代码）
dict_config = OmegaConf.to_container(cfg)

3.3 类型安全：集成 dataclass

from dataclasses import dataclass
from omegaconf import OmegaConf

# 1. 定义配置结构（类似 Java 类）
@dataclass
class DatabaseConfig:
    host: str = "localhost"
    port: int = 3307
    user: str = "root"
   password: str = ""

@dataclass
class AppConfig:
    database: DatabaseConfig
   debug: bool = False

# 2. 从 YAML 加载并验证
schema = OmegaConf.structured(AppConfig)  # 创建 Schema
yaml_config = OmegaConf.load('config.yaml')  # 加载实际配置

# 3. 合并（YAML 覆盖默认值）
merged = OmegaConf.merge(schema, yaml_config)

# 4. 转为强类型对象
config: AppConfig = OmegaConf.to_object(merged)

# ✅ IDE 有完整智能提示！
print(config.database.host)
print(config.database.port)  # 如果 YAML 中 port="abc"，这里会抛异常

类型验证效果：

# config.yaml
database:
  port: "abc"  # ❌ 错误！应该是 int

# 运行时报错：
# ValidationError: Value 'abc' could not be converted to integer

3.4 智能合并：多环境配置

from omegaconf import OmegaConf

# 1. 基础配置（base.yaml）
base = OmegaConf.load('base.yaml')
# database:
#   host: localhost
#   port: 3307

# 2. 开发环境覆盖（dev.yaml）
dev = OmegaConf.load('dev.yaml')
# database:
#   host: dev-db.example.com
#  debug: true

# 3. 实验特定调（experiment.yaml）
experiment= OmegaConf.load('experiment.yaml')
# database:
#   pool_size: 20

# 4. 深度合并（后面的覆盖前面的）
final = OmegaConf.merge(base, dev, experiment)

# 结果：
# database:
#   host: dev-db.example.com  ← 被 dev 覆盖
#   port: 3307                ← 保持 base
#  debug: true               ← 来自 dev
#   pool_size: 20             ← 来自 experiment

3.5 动态覆盖：CLI 参数

from omegaconf import OmegaConf

# 从命令行读取覆盖
cli_overrides = OmegaConf.from_cli()
# 运行：python app.py database.host=new-host database.port=3308

base = OmegaConf.load('config.yaml')
final = OmegaConf.merge(base, cli_overrides)

无需写 argparse！

3.6 变量插值：避免重复

# config.yaml
root_dir: /opt/myapp

database:
  data_path: ${root_dir}/data  # ← 引用其他配置
  backup_path: ${root_dir}/backup

logging:
  file_path: ${root_dir}/logs/app.log

cfg = OmegaConf.load('config.yaml')

print(cfg.database.data_path)   
# → "/opt/myapp/data"（自动展开）

print(cfg.logging.file_path)
# → "/opt/myapp/logs/app.log"

3.7 完整工作流示例

# config_manager.py
from dataclasses import dataclass
from omegaconf import OmegaConf, MISSING
from pathlib import Path

# 1. 定义配置结构
@dataclass
class DatabaseConfig:
    host: str = "localhost"
    port: int = 3307
    user: str = "root"
   password: str = MISSING  # 必填字段
    database: str = "mydb"

@dataclass
class LLMConfig:
   model_name: str = "deepseek-chat"
    api_key: str = MISSING
    base_url: str = "https://api.deepseek.com"
    temperature: float = 0.0

@dataclass
class AppConfig:
    database: DatabaseConfig
    llm: LLMConfig
   debug: bool = False

# 2. 加载配置
def load_config(env: str = "dev") -> AppConfig:
    # 基础配置
    base = OmegaConf.structured(AppConfig)
    
    # 环境配置
   env_file = Path(f"config.{env}.yaml")
    if env_file.exists():
       env_config = OmegaConf.load(env_file)
        base = OmegaConf.merge(base, env_config)
    
    # CLI 覆盖
   cli_overrides = OmegaConf.from_cli()
    base = OmegaConf.merge(base, cli_overrides)
    
    # 环境变量覆盖（敏感信息）
   import os
    if os.getenv('DB_PASSWORD'):
        base.database.password = os.getenv('DB_PASSWORD')
    if os.getenv('LLM_API_KEY'):
        base.llm.api_key = os.getenv('LLM_API_KEY')
    
    # 类型验证并返回
   return OmegaConf.to_object(base)

# 3. 使用
if __name__ == "__main__":
   config = load_config("prod")
    print(f"连接数据库：{config.database.host}:{config.database.port}")
    print(f"使用 LLM: {config.llm.model_name}")

四、项目实例

4.1 项目配置结构

data-agent/
├── conf/
│   ├── app_config.yaml      # 主配置文件
│   └── meta_config.yaml     # 元数据配置
└── app/
    └── conf/
        ├── __init__.py      # 模块导出
        ├── app_config.py    # 配置 Schema 定义
        └── config_loader.py # （可选）配置加载器

4.2 完整实现解析

步骤 1：定义配置 Schema（app_config.py）
from dataclasses import dataclass
from omegaconf import OmegaConf

# 1. 子配置类（单一职责）
@dataclass
class DBConfig:
    """数据库配置（复用两次）"""
    host: str
    port: int
    user: str
   password: str
    database: str

@dataclass
class LLMConfig:
    """大语言模型配置"""
   model_name: str
    api_key: str
    base_url: str

# 2. 总配置类（组合模式）
@dataclass
class AppConfig:
    """应用配置总入口"""
    logging: LoggingConfig
    db_meta: DBConfig      # 元数据库
    db_dw: DBConfig        # 数据仓库
    qdrant: QdrantConfig   # 向量数据库
   embedding: EmbeddingConfig
   es: ESConfig
    llm: LLMConfig         # 大语言模型

# 3. 加载并验证
config_file = Path(__file__).parents[2] / 'conf' / 'app_config.yaml'
context = OmegaConf.load(config_file)  # 加载 YAML
schema = OmegaConf.structured(AppConfig)  # 定义结构
app_config = OmegaConf.to_object(
    OmegaConf.merge(schema, context)  # 合并 + 验证
)
步骤 2：YAML 配置文件（app_config.yaml）
logging:
  file:
   enable: true
    level: INFO
   path: logs
   rotation: "10 MB"
   retention: "7 days"
  console:
   enable: true
    level: INFO

db_meta:
  host: localhost
  port: 3307  # Docker 映射后的端口
  user: atguigu
  password: Atguigu.123
  database: meta

llm:
  model_name: deepseek-chat
  api_key: sk-977f02b85dbb408fbf18e636a88afc60
  base_url: https://api.deepseek.com
步骤 3：模块导出（init.py）
"""配置模块导出 - 统一从 app.conf 导入配置。

Examples:
    其他模块使用方式：
    >>> from app.conf import app_config
    >>> print(app_config.llm.model_name)
"""
from app.conf.app_config import app_config

__all__ = ["app_config"]
步骤 4：全项目使用
# 任何需要配置的地方
from app.conf import app_config

# 数据库连接
engine = create_async_engine(
   f"mysql+asyncmy://{app_config.db_meta.user}:{app_config.db_meta.password}"
    f"@{app_config.db_meta.host}:{app_config.db_meta.port}/{app_config.db_meta.database}"
)

# LLM 初始化
llm = init_chat_model(
   model=app_config.llm.model_name,
    api_key=app_config.llm.api_key,
    base_url=app_config.llm.base_url
)

# Qdrant 客户端
qdrant = QdrantClient(
    host=app_config.qdrant.host,
    port=app_config.qdrant.port
)

4.3 设计亮点

设计点实现方式好处
单一职责每个 dataclass 只负责一个领域职责清晰，易于维护
组合模式AppConfig 由多个小组件组合易于扩展，不耦合
类型安全dataclass + OmegaConf 验证启动时发现错误
IDE 友好强类型对象完整的智能提示
环境隔离可创建 config.dev.yaml / config.prod.yaml安全部署

五、快速选用决策树

0.png

决策路径文字版

问题 1：配置是否简单、固定，且无需复杂验证？

是 → 选择传统方案

  • 有敏感信息或需要区分环境？

    • → 环境变量 + python-dotenv
    • 示例：.env 文件存密码，Docker Compose 注入环境变量

  • 只是普通键值对？

    • → configparser (INI)
    • 示例：小型脚本工具

  • 需要嵌套结构？

    • → YAML/JSON + 手动验证
    • 示例：Flask/Django 项目配置

否（配置复杂、需要合并、验证、动态覆盖） → 进入下一步

问题 2：是否来自机器学习、AI 实验或大型项目？

是 → 直接使用 Hydra

  • Hydra 基于 OmegaConf，功能更全
  • 自动支持多实验配置、超参数搜索
  • 示例：训练 100 次实验，每次调整不同参数

否 → 使用 OmegaConf

问题 3：是否需要严格的类型检查和 IDE 自动补全？

是 → 务必使用 OmegaConf + dataclass/Pydantic

  • 启动时就验证类型
  • IDE 提供完整智能提示
  • 示例：Web 服务、生产环境应用

否 → 纯 OmegaConf

  • 更灵活，但类型安全靠自己

一句话总结

对于简单应用，用基础方案组合（如 YAML + .env）即可；
对于需要灵活组合、严格验证、特别是科研实验和复杂系统的配置，OmegaConf/Hydra 是现代 Python 项目的强力工具。

六、最佳实践与避坑指南

6.1 配置分层策略

# 第 1 层：基础配置（base.yaml）- 团队共享
database:
  host: localhost
  port: 3307
  pool_size: 10

# 第 2 层：环境配置（dev.yaml / prod.yaml）- 按环境分开
# dev.yaml
database:
  host: dev-db.example.com
  debug: true

# prod.yaml
database:
  host: prod-db.example.com
  debug: false
  pool_size: 50  # 生产环境加大连接池

# 第 3 层：个人配置（local.yaml）- 不提交到 Git
database:
  host: my-local-db
  port: 3308

# 第 4 层：环境变量（.env）- 敏感信息
DB_PASSWORD=super-secret
LLM_API_KEY=sk-xxx

加载顺序：

final = OmegaConf.merge(base, env, local, cli_overrides)
# 后面的覆盖前面的

6.2 敏感信息处理

❌ 错误做法
# config.yaml
database:
  password: Atguigu.123  # 明文密码提交到 Git
llm:
  api_key: sk-xxxxxxxx   # API 密钥泄露
✅ 正确做法

方式 1：环境变量

# config.yaml
database:
  password: ${DB_PASSWORD}  # 从环境变量读取

import os
os.environ['DB_PASSWORD'] = 'secret'  # 或在 Shell 中 export

方式 2：.env 文件（不提交到 Git）

# .env
DB_PASSWORD=Atguigu.123
LLM_API_KEY=sk-xxx

from dotenv import load_dotenv
load_dotenv()  # 加载.env 到环境变量

方式 3：密钥管理服务（生产环境）

# AWS Secrets Manager / Azure Key Vault
import boto3

client = boto3.client('secretsmanager')
response = client.get_secret_value(SecretId='myapp/db/password')
db_password = response['SecretString']

6.3 配置文件版本控制

# .gitignore

# ✅ 提交：配置模板
conf/base.yaml
conf/meta_config.yaml

# ❌ 不提交：包含敏感信息的配置
conf/local.yaml
conf/*.secret.yaml
.env
*.env

# ✅ 提交：示例文件
.env.example          # 占位符，不含真实密钥
conf/base.example.yaml

.env.example 示例：

# 复制此文件为 .env 并填入真实值
DB_HOST=localhost
DB_PORT=3307
DB_USER=root
DB_PASSWORD=your-password-here
LLM_API_KEY=your-api-key-here

6.4 配置验证最佳实践

from dataclasses import dataclass, field
from omegaconf import OmegaConf, MISSING
from typing import List, Optional

@dataclass
class DatabaseConfig:
    host: str = "localhost"
    port: int = field(default=3307, metadata={"min": 1024, "max": 65535})
    user: str = MISSING  # 必填
   password: str = MISSING  # 必填
    database: str = "mydb"
    
   def __post_init__(self):
        """自定义验证逻辑"""
        if self.port < 1024 or self.port > 65535:
           raise ValueError(f"port 必须在 1024-65535 之间，得到 {self.port}")
        if not self.user:
           raise ValueError("user 不能为空")

@dataclass
class AppConfig:
    database: DatabaseConfig
    features: List[str] = field(default_factory=list)
    optional_setting: Optional[str] = None

# 加载时会自动验证
try:
   config = OmegaConf.to_object(
        OmegaConf.merge(
            OmegaConf.structured(AppConfig),
            OmegaConf.load('config.yaml')
        )
    )
except Exception as e:
    print(f"配置验证失败：{e}")
    exit(1)

6.5 常见陷阱与解决方案

陷阱 1：YAML 缩进错误
# ❌ 错误：缩进不一致
database:
  host: localhost
   port: 3307  # 多了 1 个空格

# ✅ 正确：统一 2 空格
database:
  host: localhost
  port: 3307

解决： 使用编辑器插件（VS Code YAML 插件）自动检查

陷阱 2：布尔值陷阱
# ❌ 错误：字符串 "False" 会被当作 True
debug: "False"  # 这是字符串！

# ✅ 正确
debug: false  # YAML 布尔值
陷阱 3：空值处理
# ❌ 不明确
optional_field: null
optional_field: ~
optional_field: NULL

# ✅ 明确
optional_field: null  # 统一使用 null
陷阱 4：列表 vs 标量
# ❌ 单个值时是字符串
hosts: localhost

# ✅ 即使只有一个也用列表
hosts:
  - localhost

# 这样代码永远处理列表，不需要特殊判断

6.6 性能优化

懒加载配置
from functools import lru_cache

@lru_cache(maxsize=1)
def get_config() -> AppConfig:
    """缓存配置对象，避免重复加载"""
   return load_config("prod")

# 第一次调用会加载，后续直接返回缓存
config1 = get_config()
config2 = get_config()  # 秒返回，不重新加载

6.7 测试配置

# test_config.py
import pytest
from omegaconf import OmegaConf

def test_database_config():
    """测试数据库配置是否正确加载"""
   config = load_config("test")
    
    assert config.database.host == "test-db"
    assert config.database.port == 3307
    assert config.database.user == "test_user"

def test_llm_config():
    """测试 LLM 配置"""
   config = load_config("test")
    
    assert config.llm.model_name== "deepseek-chat"
    assert config.llm.temperature == 0.0

@pytest.fixture
def test_config():
    """测试夹具：提供测试配置"""
   return OmegaConf.create({
        'database': {
            'host': 'test-db',
            'port': 3307
        }
    })

📚 延伸资源

官方文档

相关项目

  • FastAPI 配置管理：使用 Pydantic Settings
  • Django 配置：使用 django-configurations
  • Flask 配置：使用 Flask Config

进阶话题

  • 配置热重载（不重启服务更新配置）
  • 分布式配置中心（Consul、etcd）
  • 配置加密（ansible-vault、sops）

🎯 总结

方案适用场景推荐指数
环境变量敏感信息、容器化⭐⭐⭐⭐
YAML通用配置、可读性要求高⭐⭐⭐⭐
OmegaConf + dataclass复杂项目、类型安全⭐⭐⭐⭐⭐
HydraML/AI 实验、超参数管理⭐⭐⭐⭐⭐

核心原则：

  1. 代码与配置分离
  2. 敏感信息不进代码库
  3. 类型越早验证越好
  4. 配置应该可测试、可回滚

文档版本： v1.0
最后更新： 2026-03-07

avatar
文章
阅读
粉丝