基础设施实战指南：从日志系统到负载均衡

import logging

DEBUG = logging.DEBUG     # 10 - 调试信息
INFO = logging.INFO       # 20 - 正常运行
WARNING = logging.WARNING # 30 - 警告
ERROR = logging.ERROR     # 40 - 错误
CRITICAL = logging.CRITICAL  # 50 - 严重错误

import json
import logging
from datetime import datetime

class JSONFormatter(logging.Formatter):
    def format(self, record):
        log = {
            'timestamp': datetime.utcnow().isoformat(),
            'level': record.levelname,
            'message': record.getMessage(),
            'module': record.module,
            'function': record.funcName,
            'line': record.lineno,
        }
        # 链路追踪 ID
        if hasattr(record, 'request_id'):
            log['request_id'] = record.request_id
        if hasattr(record, 'user_id'):
            log['user_id'] = record.user_id
        return json.dumps(log)

# 配置
handler = logging.StreamHandler()
handler.setFormatter(JSONFormatter())
logging.basicConfig(level=logging.INFO, handlers=[handler])

# 使用
logger = logging.getLogger(__name__)
logger.info('User logged in',
           extra={'request_id': 'abc123', 'user_id': 42})

# 1. 不要记录敏感信息
logger.info(f"User login: {username}")  # ✓
logger.info(f"User login: {username}, password: {password}")  # ✗

# 2. 记录足够上下文
logger.error(f"Database error",
             extra={'query': sql, 'params': params, 'host': db_host})

# 3. 异步日志（不阻塞主线程）
from logging.handlers import QueueHandler, QueueListener
import queue

log_queue = queue.Queue()
queue_handler = QueueHandler(log_queue)
file_handler = logging.FileHandler('app.log')
listener = QueueListener(log_queue, file_handler)
listener.start()

logger.addHandler(queue_handler)

# 4. 日志轮转
from logging.handlers import RotatingFileHandler

handler = RotatingFileHandler(
    'app.log',
    maxBytes=100 * 1024 * 1024,  # 100MB
    backupCount=10
)

# Nacos 配置
spring:
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        namespace: production
        group: ORDER_GROUP
        data-id: order-service.yaml

# Python 客户端
from nacos import NacosClient

client = NacosClient('localhost:8848', namespace='production')
config = client.get_config('order-service.yaml', 'ORDER_GROUP')

# 监听配置变更
def on_config_change(args):
    print(f"Config changed: {args['content']}")

client.add_config_watcher('order-service.yaml', 'ORDER_GROUP', on_config_change)

# 配置分层
application.yaml        # 通用配置
application-dev.yaml    # 开发环境
application-prod.yaml   # 生产环境

# 敏感配置用 Secret
apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
data:
  password: <base64-encoded>

import random
import itertools

# 1. 轮询
class RoundRobin:
    def __init__(self, servers):
        self.servers = servers
        self.cycle = itertools.cycle(servers)

    def next(self):
        return next(self.cycle)

# 2. 加权轮询
class WeightedRoundRobin:
    def __init__(self, servers, weights):
        self.servers = servers
        self.weights = weights

    def next(self):
        expanded = []
        for server, weight in zip(self.servers, self.weights):
            expanded.extend([server] * weight)
        return random.choice(expanded)

# 3. 最少连接
class LeastConnections:
    def __init__(self, servers):
        self.connections = {s: 0 for s in servers}

    def next(self):
        return min(self.connections, key=self.connections.get)

    def acquire(self, server):
        self.connections[server] += 1

    def release(self, server):
        self.connections[server] -= 1

# 4. 一致性哈希（会话保持）
import hashlib

class ConsistentHashing:
    def __init__(self, servers, replicas=100):
        self.ring = {}
        for server in servers:
            for i in range(replicas):
                key = f"{server}:{i}"
                hash_val = int(hashlib.md5(key.encode()).hexdigest(), 16)
                self.ring[hash_val] = server
        self.sorted_hashes = sorted(self.ring.keys())

    def get_server(self, key):
        hash_val = int(hashlib.md5(key.encode()).hexdigest(), 16)
        for h in self.sorted_hashes:
            if h >= hash_val:
                return self.ring[h]
        return self.ring[self.sorted_hashes[0]]

# 加权轮询
upstream backend {
    server 10.0.0.1 weight=3;
    server 10.0.0.2 weight=1;
    server 10.0.0.3 backup;  # 备用
}

# IP 哈希（会话保持）
upstream backend {
    ip_hash;
    server 10.0.0.1;
    server 10.0.0.2;
}

# 最少连接
upstream backend {
    least_conn;
    server 10.0.0.1 max_fails=3 fail_timeout=30s;
    server 10.0.0.2 max_fails=3 fail_timeout=30s;
}

# 健康检查
upstream backend {
    server 10.0.0.1;
    server 10.0.0.2;
    keepalive 32;  # 保持长连接
}

# /etc/sysctl.conf
# 增加文件描述符
fs.file-max = 1000000

# TCP 缓冲区
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# 连接复用
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30

# KeepAlive
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 3

# 生效
sysctl -p

# CPU
top / htop          # 实时进程
mpstat              # CPU 统计
perf                # 性能分析

# 内存
free -h             # 内存使用
vmstat              # 虚拟内存
sar -r              # 内存历史

# 磁盘 IO
iostat              # IO 统计
iotop               # IO top
df -h               # 磁盘使用

# 网络
iftop               # 网络流量
ss / netstat        # 连接状态
tcpdump             # 抓包

# 综合
dstat               # 综合监控
sar                 # 历史数据

# 找到最耗 CPU 的进程
top -c
# 找到最耗 CPU 的线程
top -H -p <pid>
# 查看线程在做什么
printf "%x\n" <tid>  # 转 16 进制
jstack <pid> | grep <hex_tid>

# 查看进程内存
ps aux --sort=-%mem | head
# Java 堆 dump
jmap -dump:format=b,file=heap.hprof <pid>

# 查看 IO
iostat -x 1
# IOPS 高的进程
iotop