YAML解析复杂结构化配置

本文目录导读：

1. 基础数据结构
2. 高级特性
3. 实战：Kubernetes Deployment 配置
4. 解析复杂配置的Python示例
5. 最佳实践建议
6. 常见问题与解决方案

YAML（YAML Ain’t Markup Language）非常适合表示复杂的结构化配置，因为它支持嵌套、列表、映射、多行字符串以及锚点/别名等高级特性，下面我为你详细解析如何用YAML处理复杂结构化配置。

基础数据结构

映射（字典/Maps）

server:
  host: "localhost"
  port: 8080
  ssl:
    enabled: true
    cert_path: "/etc/ssl/cert.pem"

序列（列表/Arrays）

services:
  - name: "web"
    port: 80
  - name: "api"
    port: 8080
  - name: "db"
    port: 5432

混合嵌套

application:
  name: "my-app"
  version: "2.0.0"
  databases:
    primary:
      host: "db-primary.example.com"
      port: 5432
      credentials:
        user: "admin"
        password: "${DB_PASSWORD}"  # 环境变量引用
    replica:
      - host: "db-replica-1.example.com"
        port: 5432
      - host: "db-replica-2.example.com"
        port: 5432

高级特性

锚点与别名（重复利用配置）

# 定义公共配置块
defaults: &defaults
  adapter: postgresql
  encoding: unicode
  pool: 5
development:
  database: myapp_dev
  <<: *defaults  # 合并默认配置
production:
  database: myapp_prod
  <<: *defaults
  pool: 25  # 覆盖默认值
staging:
  database: myapp_staging
  host: staging-db.example.com
  <<: *defaults  # 也可以与其他字段组合

多行字符串

description: |
  这是第一行
  这是第二行
  保留换行和缩进
short_desc: >
  这是一个折叠的
  多行字符串
  最终会被合并成一行
code_block: |
  def hello():
      print("Hello, World!")
  # 适合嵌入代码片段

环境变量引用（实际需解析器支持）

app:
  database_url: "${DATABASE_URL:-postgres://localhost:5432/default}"
  secret_key: "${SECRET_KEY}"
  debug: ${DEBUG:false}

实战：Kubernetes Deployment 配置

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
    tier: backend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app-container
          image: my-app:2.0.0
          ports:
            - containerPort: 8080
              protocol: TCP
          env:
            - name: DB_HOST
              value: "db-service"
            - name: DB_PORT
              value: "5432"
            - name: LOG_LEVEL
              valueFrom:
                configMapKeyRef:
                  name: app-config
                  key: log_level
          resources:
            requests:
              memory: "256Mi"
              cpu: "250m"
            limits:
              memory: "512Mi"
              cpu: "500m"
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
      volumes:
        - name: config-volume
          configMap:
            name: app-config

解析复杂配置的Python示例

import yaml
import os
from pathlib import Path
class ConfigParser:
    def __init__(self, config_path: str):
        self.config_path = Path(config_path)
        self.raw_config = None
        self.parsed_config = None
    def load(self):
        """加载并解析YAML配置"""
        with open(self.config_path, 'r', encoding='utf-8') as f:
            self.raw_config = yaml.safe_load(f)
        return self
    def resolve_environment_variables(self, data=None):
        """递归解析环境变量"""
        if data is None:
            data = self.raw_config
        if isinstance(data, dict):
            return {k: self.resolve_environment_variables(v) 
                   for k, v in data.items()}
        elif isinstance(data, list):
            return [self.resolve_environment_variables(item) 
                   for item in data]
        elif isinstance(data, str):
            # 处理 ${VAR:-default} 格式
            if data.startswith('${') and data.endswith('}'):
                var_name = data[2:-1]
                if ':-' in var_name:
                    var_name, default = var_name.split(':-', 1)
                    return os.environ.get(var_name, default)
                return os.environ.get(var_name, '')
        return data
    def validate_required_fields(self, required_fields: list):
        """验证必要的配置字段是否存在"""
        missing = []
        for field in required_fields:
            keys = field.split('.')
            current = self.parsed_config
            for key in keys:
                if isinstance(current, dict):
                    current = current.get(key)
                else:
                    missing.append(field)
                    break
            if current is None:
                missing.append(field)
        return missing
# 使用示例
parser = ConfigParser('config.yaml')
parser.load()
parser.parsed_config = parser.resolve_environment_variables()
# 访问复杂配置
db_config = parser.parsed_config['application']['databases']['primary']
print(f"DB Host: {db_config['host']}")
print(f"DB Port: {db_config['port']}")

最佳实践建议

分层设计

# 将配置分为不同层次
layers:
  base:
    - config/base.yaml
  environment:
    - config/${ENV}.yaml
  local:
    - config/local.yaml

使用YAML合并

# default.yaml
database: &default_db
  host: localhost
  port: 5432
  username: admin
# production.yaml
database:
  <<: *default_db
  host: prod-db.example.com
  password: ${DB_PASSWORD}

配置验证

from pydantic import BaseModel, Field
from typing import Optional, List
class DatabaseConfig(BaseModel):
    host: str
    port: int = 5432
    username: str = "admin"
    password: Optional[str] = None
    pool_size: int = Field(default=5, ge=1, le=100)
class AppConfig(BaseModel):
    name: str
    version: str
    databases: DatabaseConfig
    services: List[dict] = []

常见问题与解决方案

YAML的强大之处在于它的可读性和表达复杂结构的能力,合理使用这些特性可以创建既清晰又灵活的配置系统。