1. Python运维的核心价值与应用场景
在当今的IT基础设施管理中，Python已经成为运维工程师的"瑞士军刀"。我从业十年间见证了Shell脚本逐渐被Python替代的过程——某次服务器批量部署任务中，用Python写的自动化工具比传统Shell脚本减少60%代码量，而处理速度反而提升3倍。这种效率跃升源于Python丰富的标准库和清晰的语法结构。
典型应用场景包括：
- 自动化部署：用Fabric或Ansible替代手工操作
- 日志分析：通过Pandas处理GB级日志文件
- 监控告警：结合Prometheus和Grafana实现智能监控
- 配置管理：使用SaltStack或自定义脚本管理服务器集群
关键提示：Python 3.8+版本对异步IO的重大改进，使得单机处理万级并发请求成为可能，这是运维脚本性能提升的关键
2. 环境搭建与工具链配置
2.1 跨平台环境部署方案
在Windows和Linux上配置Python环境的差异点：
bash复制# Linux环境（以Ubuntu为例）
sudo apt update
sudo apt install python3-pip python3-venv
python3 -m venv ~/venv/ops
# Windows环境
choco install python --version=3.10.4
python -m venv C:\venv\ops
开发工具选型建议：
- VSCode：安装Python扩展后支持智能补全和调试
- PyCharm Professional：对Docker和数据库的原生支持
- Jupyter Notebook：交互式数据分析场景
2.2 依赖管理的进阶技巧
requirements.txt的替代方案：
python复制# 使用pipenv管理依赖
pip install pipenv
pipenv install requests==2.28.1
pipenv graph # 查看依赖树
# 生产环境推荐poetry
poetry add psutil
poetry export -f requirements.txt --output requirements-prod.txt
3. 核心运维脚本开发实战
3.1 服务器监控系统实现
基于psutil的硬件监控示例：
python复制import psutil, time
def monitor(interval=5):
while True:
cpu_percent = psutil.cpu_percent(interval=1)
mem = psutil.virtual_memory()
print(f"CPU: {cpu_percent}% | "
f"Memory: {mem.used/1024/1024:.1f}MB/{mem.total/1024/1024:.1f}MB")
time.sleep(interval)
# 添加磁盘监控
disk = psutil.disk_usage('/')
print(f"Disk: {disk.used/1024/1024:.1f}GB/{disk.total/1024/1024:.1f}GB")
3.2 日志分析自动化
使用Pandas分析Nginx日志：
python复制import pandas as pd
logs = pd.read_csv(
'access.log',
sep=r'\s(?=(?:[^"]*"[^"]*")*[^"]*$)',
engine='python',
header=None,
names=['ip','-','-','time','request','status','size','referer','agent']
)
top_ips = logs['ip'].value_counts().head(10)
error_requests = logs[logs['status'].str.startswith('5')]
4. 企业级运维架构设计
4.1 自动化部署系统搭建
基于Fabric 2.x的部署脚本框架：
python复制from fabric import Connection, task
@task
def deploy(c):
with c.cd('/var/www/app'):
c.run('git pull origin main')
c.run('pip install -r requirements.txt')
c.run('systemctl restart app.service')
# 多服务器批量执行
hosts = ['web1.example.com', 'web2.example.com']
for host in hosts:
deploy(Connection(host, user='deploy'))
4.2 监控告警平台集成
Prometheus + Grafana的Python客户端实现：
python复制from prometheus_client import start_http_server, Gauge
import random
cpu_temp = Gauge('cpu_temperature', 'Current CPU temperature')
memory_usage = Gauge('memory_usage_bytes', 'Memory usage in bytes')
def collect_metrics():
while True:
cpu_temp.set(random.randint(40, 80))
memory_usage.set(psutil.virtual_memory().used)
time.sleep(15)
start_http_server(8000)
collect_metrics()
5. 性能优化与故障排查
5.1 脚本性能调优技巧
异步IO在运维脚本中的应用：
python复制import aiohttp, asyncio
async def check_url(url):
async with aiohttp.ClientSession() as session:
async with session.get(url) as resp:
return resp.status
urls = ['http://example.com']*100
loop = asyncio.get_event_loop()
results = loop.run_until_complete(asyncio.gather(*[check_url(u) for u in urls]))
5.2 常见问题诊断手册
典型错误排查表：
| 错误现象 | 可能原因 | 解决方案 |
|---|---|---|
| ImportError | 虚拟环境未激活/依赖缺失 | 检查PYTHONPATH，重新安装依赖 |
| MemoryError | 大数据集未分块处理 | 使用生成器替代列表 |
| SSLError | 证书验证失败 | 添加verify=False参数(仅测试环境) |
| TimeoutError | 网络延迟或阻塞操作 | 增加超时设置或改用异步 |
6. 容器化与持续集成
6.1 Docker化Python运维工具
标准Dockerfile模板：
dockerfile复制FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "monitor.py"]
构建优化技巧：
bash复制# 使用多阶段构建减小镜像体积
FROM python:3.9 as builder
RUN pip install --user -r requirements.txt
FROM python:3.9-slim
COPY --from=builder /root/.local /root/.local
ENV PATH=/root/.local/bin:$PATH
6.2 CI/CD流水线集成
GitLab CI示例配置：
yaml复制stages:
- test
- deploy
pytest:
stage: test
image: python:3.9
script:
- pip install pytest
- pytest tests/
deploy_prod:
stage: deploy
only:
- main
script:
- ansible-playbook deploy.yml
在Kubernetes中运行定时任务的最佳实践是使用CronJob资源，配合ConfigMap存储脚本：
yaml复制apiVersion: batch/v1
kind: CronJob
metadata:
name: python-cleanup
spec:
schedule: "0 3 * * *"
jobTemplate:
spec:
template:
spec:
containers:
- name: cleaner
image: python:3.9
command: ["python", "/scripts/cleanup.py"]
volumeMounts:
- name: scripts
mountPath: /scripts
volumes:
- name: scripts
configMap:
name: python-scripts
restartPolicy: OnFailure
对于需要持久化存储的运维数据（如监控历史记录），建议使用PVC挂载：
yaml复制apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: ops-data-pvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi
日志收集的sidecar模式实现：
yaml复制apiVersion: apps/v1
kind: Deployment
metadata:
name: log-generator
spec:
template:
spec:
containers:
- name: main
image: python:3.9
command: ["python", "app.py"]
- name: log-collector
image: fluent/fluentd
volumeMounts:
- name: logs
mountPath: /var/log/app
volumes:
- name: logs
emptyDir: {}
通过kubectl exec调试运行中容器的方法：
bash复制# 进入容器shell环境
kubectl exec -it <pod-name> -- /bin/bash
# 直接执行Python命令
kubectl exec <pod-name> -- python -c "import sys; print(sys.path)"
# 拷贝文件到本地
kubectl cp <pod-name>:/path/to/file ./local-file
对于需要特权模式的运维操作（如节点检测），需要配置securityContext：
yaml复制securityContext:
capabilities:
add: ["SYS_ADMIN"]
privileged: true
runAsUser: 0
使用ConfigMap管理Python配置文件的典型模式：
bash复制# 从本地文件创建ConfigMap
kubectl create configmap python-config \
--from-file=config.py=./config/prod.py
# 在Pod中挂载
volumeMounts:
- name: config
mountPath: /etc/app/config.py
subPath: config.py
volumes:
- name: config
configMap:
name: python-config
处理Python依赖的InitContainer模式：
yaml复制initContainers:
- name: install-deps
image: python:3.9
command: ["pip", "install", "-r", "/code/requirements.txt"]
volumeMounts:
- name: code
mountPath: /code
- name: site-packages
mountPath: /usr/local/lib/python3.9/site-packages
containers:
- name: app
image: python:3.9
volumeMounts:
- name: site-packages
mountPath: /usr/local/lib/python3.9/site-packages
volumes:
- name: site-packages
emptyDir: {}
对于需要GPU加速的运维AI任务（如日志异常检测），需要配置nvidia-docker：
yaml复制resources:
limits:
nvidia.com/gpu: 1
使用Headless Service暴露Python运维API：
yaml复制apiVersion: v1
kind: Service
metadata:
name: ops-api
spec:
clusterIP: None
selector:
app: ops-tools
ports:
- protocol: TCP
port: 8000
通过Ingress暴露Web界面的配置示例：
yaml复制apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /$1
spec:
rules:
- host: ops.example.com
http:
paths:
- path: /(.*)
pathType: Prefix
backend:
service:
name: ops-web
port:
number: 5000
使用HorizontalPodAutoscaler自动扩展运维工作负载：
yaml复制apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: log-processor
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: log-processor
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
通过PodDisruptionBudget保证关键运维服务可用性：
yaml复制apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
name: ops-pdb
spec:
minAvailable: 1
selector:
matchLabels:
app: critical-ops
使用NetworkPolicy限制运维服务访问：
yaml复制apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: ops-allow
spec:
podSelector:
matchLabels:
role: ops
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchLabels:
project: devops
ports:
- protocol: TCP
port: 8000
通过ResourceQuota限制运维命名空间资源：
yaml复制apiVersion: v1
kind: ResourceQuota
metadata:
name: ops-quota
spec:
hard:
pods: "10"
requests.cpu: "20"
requests.memory: 100Gi
limits.cpu: "40"
limits.memory: 200Gi
使用PriorityClass确保关键运维任务优先调度：
yaml复制apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
name: ops-critical
value: 1000000
globalDefault: false
description: "用于关键运维任务"
通过PodAntiAffinity实现运维服务高可用：
yaml复制affinity:
podAntiAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
- labelSelector:
matchExpressions:
- key: app
operator: In
values:
- ops-monitor
topologyKey: "kubernetes.io/hostname"
使用TopologySpreadConstraints均匀分布运维负载：
yaml复制topologySpreadConstraints:
- maxSkew: 1
topologyKey: zone
whenUnsatisfiable: DoNotSchedule
labelSelector:
matchLabels:
app: ops-worker
通过PodPreset注入通用运维配置：
yaml复制apiVersion: settings.k8s.io/v1alpha1
kind: PodPreset
metadata:
name: ops-env
spec:
selector:
matchLabels:
role: ops
env:
- name: LOG_LEVEL
value: INFO
volumeMounts:
- mountPath: /etc/ops
name: config
volumes:
- name: config
configMap:
name: ops-config
使用CustomResourceDefinition扩展运维功能：
yaml复制apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: opsjobs.example.com
spec:
group: example.com
names:
kind: OpsJob
plural: opsjobs
scope: Namespaced
versions:
- name: v1
served: true
storage: true
schema:
openAPIV3Schema:
type: object
properties:
spec:
type: object
properties:
command:
type: string
timeout:
type: integer
通过ValidatingWebhook验证运维配置：
yaml复制apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
name: ops-validator
webhooks:
- name: validator.example.com
rules:
- operations: ["CREATE", "UPDATE"]
apiGroups: ["apps"]
apiVersions: ["v1"]
resources: ["deployments"]
clientConfig:
service:
name: ops-validator
namespace: default
path: "/validate"
admissionReviewVersions: ["v1"]
failurePolicy: Fail
使用MutatingWebhook自动注入运维Sidecar：
yaml复制apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata:
name: ops-injector
webhooks:
- name: injector.example.com
rules:
- operations: ["CREATE"]
apiGroups: [""]
apiVersions: ["v1"]
resources: ["pods"]
clientConfig:
service:
name: ops-injector
namespace: default
path: "/inject"
admissionReviewVersions: ["v1"]
failurePolicy: Ignore
通过Controller实现自定义运维逻辑：
go复制// 示例Operator代码片段
func (r *OpsJobReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
var job examplev1.OpsJob
if err := r.Get(ctx, req.NamespacedName, &job); err != nil {
return ctrl.Result{}, client.IgnoreNotFound(err)
}
// 执行Python运维脚本
cmd := exec.Command("python3", "/scripts/"+job.Spec.Command)
if err := cmd.Run(); err != nil {
return ctrl.Result{RequeueAfter: 5*time.Minute}, err
}
return ctrl.Result{}, nil
}
使用Kubernetes Events记录运维操作：
python复制from kubernetes import client, config
config.load_kube_config()
core_v1 = client.CoreV1Api()
event = client.V1Event(
metadata=client.V1ObjectMeta(generate_name="ops-event-"),
involved_object=client.V1ObjectReference(
kind="Pod",
name="web-1",
namespace="default"
),
reason="Maintenance",
message="Executed cleanup script",
type="Normal"
)
core_v1.create_namespaced_event("default", event)
通过Kubernetes API直接操作集群的Python示例：
python复制from kubernetes import client, config
config.load_kube_config()
apps_v1 = client.AppsV1Api()
# 滚动重启Deployment
def restart_deployment(name, namespace):
body = {
"spec": {
"template": {
"metadata": {
"annotations": {
"kubectl.kubernetes.io/restartedAt": datetime.now().isoformat()
}
}
}
}
}
apps_v1.patch_namespaced_deployment(
name=name,
namespace=namespace,
body=body
)
使用Python处理Kubernetes资源的完整工作流：
python复制def scale_deployment(name, namespace, replicas):
try:
dep = apps_v1.read_namespaced_deployment(name, namespace)
dep.spec.replicas = replicas
apps_v1.patch_namespaced_deployment(
name=name,
namespace=namespace,
body=dep
)
print(f"Scaled {namespace}/{name} to {replicas} replicas")
except client.exceptions.ApiException as e:
print(f"Error scaling deployment: {e}")
def get_pod_logs(name, namespace, container=None):
return core_v1.read_namespaced_pod_log(
name=name,
namespace=namespace,
container=container
)
def list_nodes_with_label(label_selector):
return core_v1.list_node(label_selector=label_selector)
通过Python实现自定义资源监控：
python复制def monitor_custom_metrics(group, version, plural):
custom_api = client.CustomObjectsApi()
while True:
resources = custom_api.list_cluster_custom_object(
group=group,
version=version,
plural=plural
)
for item in resources['items']:
print(f"{item['metadata']['name']}: {item['status']}")
time.sleep(60)
使用Python开发Kubernetes Admission Webhook：
python复制from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/validate', methods=['POST'])
def validate():
admission_review = request.json
uid = admission_review['request']['uid']
# 验证逻辑
allowed = True
message = ""
return jsonify({
"apiVersion": "admission.k8s.io/v1",
"kind": "AdmissionReview",
"response": {
"uid": uid,
"allowed": allowed,
"status": {"message": message}
}
})
通过Python实现Kubernetes Operator模式：
python复制from kubernetes import client, config, watch
config.load_kube_config()
custom_api = client.CustomObjectsApi()
core_v1 = client.CoreV1Api()
def operator_loop(group, version, plural):
w = watch.Watch()
for event in w.stream(
custom_api.list_cluster_custom_object,
group=group,
version=version,
plural=plural
):
obj = event['object']
event_type = event['type']
# 处理自定义资源变更
handle_custom_resource(event_type, obj)
def handle_custom_resource(event_type, obj):
if event_type == 'ADDED':
print(f"New resource: {obj['metadata']['name']}")
# 执行相应运维操作
elif event_type == 'MODIFIED':
print(f"Modified resource: {obj['metadata']['name']}")
使用Python开发Kubernetes CLI工具：
python复制import click
from kubernetes import client, config
@click.group()
def cli():
pass
@cli.command()
@click.argument('namespace')
def list_pods(namespace):
"""List pods in a namespace"""
config.load_kube_config()
v1 = client.CoreV1Api()
pods = v1.list_namespaced_pod(namespace)
for pod in pods.items:
print(pod.metadata.name)
@cli.command()
@click.argument('deployment')
@click.argument('namespace')
def restart(deployment, namespace):
"""Restart a deployment"""
config.load_kube_config()
apps_v1 = client.AppsV1Api()
# 实现滚动重启逻辑...
if __name__ == '__main__':
cli()
通过Python实现Kubernetes批处理任务：
python复制def run_batch_job(image, command, namespace="default"):
batch_v1 = client.BatchV1Api()
job = client.V1Job(
metadata=client.V1ObjectMeta(generate_name="ops-job-"),
spec=client.V1JobSpec(
template=client.V1PodTemplateSpec(
spec=client.V1PodSpec(
containers=[client.V1Container(
name="job",
image=image,
command=command
)],
restart_policy="Never"
)
),
backoff_limit=3
)
)
return batch_v1.create_namespaced_job(namespace, job)
使用Python处理Kubernetes事件流：
python复制def watch_events(namespace=None):
v1 = client.CoreV1Api()
w = watch.Watch()
for event in w.stream(v1.list_event_for_all_namespaces):
print(f"Event: {event['object'].message}")
# 可添加自定义处理逻辑
if "OOMKilled" in event['object'].message:
alert_oom(event['object'])
通过Python实现自定义调度器：
python复制def scheduler_loop():
v1 = client.CoreV1Api()
w = watch.Watch()
for event in w.stream(v1.list_pod_for_all_namespaces):
pod = event['object']
if pod.spec.scheduler_name == "custom-scheduler" and pod.status.phase == "Pending":
schedule_pod(pod)
def schedule_pod(pod):
# 自定义调度逻辑
node_name = select_best_node(pod)
if node_name:
binding = client.V1Binding(
metadata=client.V1ObjectMeta(name=pod.metadata.name),
target=client.V1ObjectReference(
kind="Node",
name=node_name
)
)
try:
client.CoreV1Api().create_namespaced_pod_binding(
name=pod.metadata.name,
namespace=pod.metadata.namespace,
body=binding
)
except client.exceptions.ApiException as e:
print(f"Failed to bind pod: {e}")
使用Python开发Kubernetes扩展API：
python复制from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/apis/ops.example.com/v1/scripts', methods=['GET'])
def list_scripts():
return jsonify({
"apiVersion": "ops.example.com/v1",
"kind": "ScriptList",
"items": [
{"name": "cleanup", "description": "System cleanup script"},
{"name": "backup", "description": "Database backup script"}
]
})
@app.route('/apis/ops.example.com/v1/scripts/<name>', methods=['POST'])
def execute_script(name):
# 执行对应脚本
return jsonify({"status": "executed"})
通过Python实现Kubernetes资源回收：
python复制def cleanup_completed_jobs(namespace="default"):
batch_v1 = client.BatchV1Api()
jobs = batch_v1.list_namespaced_job(namespace)
for job in jobs.items:
if job.status.succeeded:
print(f"Deleting completed job: {job.metadata.name}")
batch_v1.delete_namespaced_job(
name=job.metadata.name,
namespace=namespace,
body=client.V1DeleteOptions()
)
def cleanup_failed_pods(namespace="default"):
v1 = client.CoreV1Api()
pods = v1.list_namespaced_pod(namespace)
for pod in pods.items:
if pod.status.phase == "Failed":
print(f"Deleting failed pod: {pod.metadata.name}")
v1.delete_namespaced_pod(
name=pod.metadata.name,
namespace=namespace,
body=client.V1DeleteOptions()
)
使用Python开发Kubernetes Dashboard插件：
python复制from flask import Flask, render_template
app = Flask(__name__)
@app.route('/dashboard')
def dashboard():
nodes = get_node_metrics()
pods = get_pod_distribution()
return render_template('dashboard.html', nodes=nodes, pods=pods)
def get_node_metrics():
v1 = client.CoreV1Api()
metrics = []
for node in v1.list_node().items:
metrics.append({
"name": node.metadata.name,
"cpu": node.status.capacity['cpu'],
"memory": node.status.capacity['memory']
})
return metrics
def get_pod_distribution():
v1 = client.CoreV1Api()
distribution = {}
for pod in v1.list_pod_for_all_namespaces().items:
namespace = pod.metadata.namespace
distribution[namespace] = distribution.get(namespace, 0) + 1
return distribution
通过Python实现Kubernetes配置验证：
python复制def validate_yaml(file_path):
with open(file_path) as f:
docs = yaml.safe_load_all(f)
for doc in docs:
if doc['kind'] == 'Deployment':
check_deployment(doc)
elif doc['kind'] == 'Service':
check_service(doc)
def check_deployment(deploy):
if not deploy['spec'].get('replicas', 0) > 0:
raise ValueError("Replicas must be > 0")
if not deploy['spec']['template']['spec'].get('containers'):
raise ValueError("No containers defined")
使用Python开发Kubernetes策略检查工具：
python复制def check_security_policies():
violations = []
# 检查特权容器
pods = client.CoreV1Api().list_pod_for_all_namespaces().items
for pod in pods:
for container in pod.spec.containers:
if container.security_context and container.security_context.privileged:
violations.append(f"Privileged container: {pod.metadata.namespace}/{pod.metadata.name}")
# 检查默认网络策略
netpols = client.NetworkingV1Api().list_network_policy_for_all_namespaces().items
if not netpols:
violations.append("No default network policies defined")
return violations
通过Python实现Kubernetes资源推荐：
python复制def recommend_resources(namespace="default"):
recommendations = []
metrics = client.CustomObjectsApi().list_namespaced_custom_object(
group="metrics.k8s.io",
version="v1beta1",
namespace=namespace,
plural="pods"
)
for pod in metrics['items']:
for container in pod['containers']:
cpu_usage = container['usage']['cpu']
mem_usage = container['usage']['memory']
# 分析使用模式并生成建议
recommendations.append({
"pod": pod['metadata']['name'],
"container": container['name'],
"cpu": f"Current: {cpu_usage}, Recommended: ...",
"memory": f"Current: {mem_usage}, Recommended: ..."
})
return recommendations
使用Python开发Kubernetes成本分析工具：
python复制def calculate_cost(namespace=None):
nodes = client.CoreV1Api().list_node().items
node_costs = {node.metadata.name: get_node_cost(node) for node in nodes}
total_cost = 0
pods = client.CoreV1Api().list_pod_for_all_namespaces().items
for pod in pods:
if namespace and pod.metadata.namespace != namespace:
continue
pod_cost = 0
for container in pod.spec.containers:
requests = container.resources.requests or {}
cpu = parse_quantity(requests.get('cpu', '0'))
memory = parse_quantity(requests.get('memory', '0'))
pod_cost += calculate_container_cost(cpu, memory)
total_cost += pod_cost
return {
"total_cost": total_cost,
"per_namespace": calculate_per_namespace(pods, node_costs)
}
def parse_quantity(quantity):
# 解析Kubernetes资源量表示
pass
def calculate_container_cost(cpu, memory):
# 根据定价模型计算成本
pass
通过Python实现Kubernetes自动化修复：
python复制def auto_fix_common_issues():
# 自动修复常见问题
fix_crashloop_backoff()
fix_image_pull_backoff()
fix_pending_pods()
def fix_crashloop_backoff():
v1 = client.CoreV1Api()
pods = v1.list_pod_for_all_namespaces().items
for pod in pods:
if any(c.state.waiting and c.state.waiting.reason == 'CrashLoopBackOff'
for c in pod.status.container_statuses or []):
print(f"Restarting pod in CrashLoopBackOff: {pod.metadata.name}")
v1.delete_namespaced_pod(
name=pod.metadata.name,
namespace=pod.metadata.namespace,
body=client.V1DeleteOptions()
)
def fix_image_pull_backoff():
# 类似实现
pass
def fix_pending_pods():
# 类似实现
pass
使用Python开发Kubernetes混沌工程工具：
python复制def chaos_test(namespace, duration=300):
# 随机删除Pod
v1 = client.CoreV1Api()
pods = v1.list_namespaced_pod(namespace).items
if pods:
target = random.choice(pods)
print(f"Deleting pod: {target.metadata.name}")
v1.delete_namespaced_pod(
name=target.metadata.name,
namespace=namespace,
body=client.V1DeleteOptions()
)
# 模拟网络延迟
netem_pod = create_netem_pod()
print(f"Network emulation pod: {netem_pod.metadata.name}")
# 定时恢复
time.sleep(duration)
cleanup_chaos(netem_pod)
def create_netem_pod():
# 创建网络模拟Pod
pass
def cleanup_chaos(netem_pod):
# 清理混沌工程资源
pass
通过Python实现Kubernetes金丝雀发布：
python复制def canary_deploy(deployment_name, namespace, new_image):
apps_v1 = client.AppsV1Api()
# 获取当前部署
dep = apps_v1.read_namespaced_deployment(deployment_name, namespace)
# 创建金丝雀部署
canary_dep = client.V1Deployment(
metadata=client.V1ObjectMeta(
name=f"{deployment_name}-canary",
labels={"app": deployment_name, "track": "canary"}
),
spec=dep.spec
)
canary_dep.spec.replicas = 1
canary_dep.spec.template.spec.containers[0].image = new_image
apps_v1.create_namespaced_deployment(namespace, canary_dep)
# 监控金丝雀状态
while True:
canary = apps_v1.read_namespaced_deployment_status(
name=f"{deployment_name}-canary",
namespace=namespace
)
if canary.status.ready_replicas == 1:
break
time.sleep(5)
# 逐步替换
for i in range(1, 10):
dep.spec.replicas = 10 - i
canary_dep.spec.replicas = i
apps_v1.patch_namespaced_deployment(
name=deployment_name,
namespace=namespace,
body=dep
)
apps_v1.patch_namespaced_deployment(
name=f"{deployment_name}-canary",
namespace=namespace,
body=canary_dep
)
time.sleep(60)
# 清理
apps_v1.delete_namespaced_deployment(
name=deployment_name,
namespace=namespace,
body=client.V1DeleteOptions()
)
apps_v1.patch_namespaced_deployment(
name=f"{deployment_name}-canary",
namespace=namespace,
body={"metadata": {"labels": {"track": "stable"}}}
)
使用Python开发Kubernetes HPA模拟器：
python复制def simulate_hpa(deployment_name, namespace, metric, target):
metrics = []
apps_v1 = client.AppsV1Api()
autoscaling_v2 = client.AutoscalingV2Api()
# 创建HPA
hpa = client.V2HorizontalPodAutoscaler(
metadata=client.V1ObjectMeta(name=deployment_name),
spec=client.V2HorizontalPodAutoscalerSpec(
scale_target_ref=client.V2CrossVersionObjectReference(
kind="Deployment",
name=deployment_name,
api_version="apps/v1"
),
metrics=[client.V2MetricSpec(
type="Resource",
resource=client.V2ResourceMetricSource(
name=metric,
target=client.V2MetricTarget(
type="Utilization",
average_utilization=target
)
)
)],
min_replicas=1,
max_replicas=10
)
)
autoscaling_v2.create_namespaced_horizontal_pod_autoscaler(namespace, hpa)
# 模拟负载变化
for i in range(24):
# 生成模拟指标
current_metric = generate_metric(i)
metrics.append(current_metric)
# 获取当前状态
status = autoscaling_v2.read_namespaced_horizontal_pod_autoscaler_status(
name=deployment_name,
namespace=namespace
)
print(f"Hour {i}: Current replicas={status.status.current_replicas}, "
f"Metric={current_metric}, Desired={status.status.desired_replicas}")
time.sleep(1)
return metrics
def generate_metric(hour):
# 生成模拟指标数据
return random.randint(30, 90)
通过Python实现Kubernetes配置漂移检测：
python复制def detect_config_drift(namespace="default"):
drifts = []
apps_v1 = client.AppsV1Api()
# 获取所有部署
deployments = apps_v1.list_namespaced_deployment(namespace).items
for dep in deployments:
# 获取当前运行的Pod配置
pods = client.CoreV1Api().list_namespaced_pod(
namespace=namespace,
label_selector=f"app={dep.metadata.labels['