Day-101-容器编排安全进阶

# Day 105: 容器编排安全进阶

> 系统安全系列第 10 天 | 预计阅读时间：40 分钟 | 难度：★★★★☆

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ 容器编排安全进阶 - Day 105         │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ 收到需求，对齐目标，进入 sprint。容器编排安全是容器安全的核心——核心不稳，编排不稳。

---

## 清单 目录

1. [Kubernetes 安全架构](#kubernetes 安全架构)
2. [RBAC 安全进阶](#rbac 安全进阶)
3. [Pod 安全进阶](#pod 安全进阶)
4. [网络安全进阶](#网络安全进阶)
5. [Secret 管理进阶](#secret 管理进阶)
6. [审计日志进阶](#审计日志进阶)
7. [安全扫描进阶](#安全扫描进阶)
8. [实战案例分析](#实战案例分析)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## Kubernetes 安全架构

### API Server 安全

> ▎ API Server 是 Kubernetes 的大脑。大脑不安全，K8s 不安全。

**认证配置**：
```yaml
# kube-apiserver 配置
apiVersion: v1
kind: Pod
metadata:
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
  - name: kube-apiserver
    image: k8s.gcr.io/kube-apiserver:v1.25.0
    command:
    - kube-apiserver
    - --authorization-mode=Node,RBAC
    - --enable-admission-plugins=NodeRestriction,PodSecurityPolicy
    - --audit-log-path=/var/log/kubernetes/audit.log
    - --audit-policy-file=/etc/kubernetes/audit-policy.yaml
```

**认证方式**：
```
客户端证书：
- CA 签名
- 客户端证书
- 证书轮换

Token 认证：
- ServiceAccount Token
- Bootstrap Token
- 静态 Token

OIDC 认证：
- OpenID Connect
- 身份提供商
- 令牌验证
```

### etcd 安全

**etcd 加密**：
```yaml
# etcd 配置
apiVersion: v1
kind: Pod
metadata:
  name: etcd
  namespace: kube-system
spec:
  containers:
  - name: etcd
    image: k8s.gcr.io/etcd:3.5.4-0
    command:
    - etcd
    - --cert-file=/etc/kubernetes/pki/etcd/server.crt
    - --key-file=/etc/kubernetes/pki/etcd/server.key
    - --peer-cert-file=/etc/kubernetes/pki/etcd/peer.crt
    - --peer-key-file=/etc/kubernetes/pki/etcd/peer.key
    - --client-cert-auth=true
    - --trusted-ca-file=/etc/kubernetes/pki/etcd/ca.crt
```

**etcd 备份**：
```bash
# 备份 etcd
ETCDCTL_API=3 etcdctl snapshot save snapshot.db \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key

# 验证备份
ETCDCTL_API=3 etcdctl snapshot status snapshot.db
```

---

## RBAC 安全进阶

### Role 设计

> ▎ RBAC 是 Kubernetes 授权的核心。核心不稳，授权不稳。

**最小权限 Role**：
```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
  namespace: default
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
- apiGroups: [""]
  resources: ["pods/log"]
  verbs: ["get"]
```

**ClusterRole 设计**：
```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: cluster-admin-limited
rules:
- apiGroups: [""]
  resources: ["pods", "services", "configmaps"]
  verbs: ["get", "list", "watch", "create", "update", "patch"]
```

### RoleBinding 管理

**命名空间绑定**：
```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: ServiceAccount
  name: default
  namespace: default
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io
```

**集群绑定**：
```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: cluster-admin-limited-binding
subjects:
- kind: Group
  name: developers
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: cluster-admin-limited
  apiGroup: rbac.authorization.k8s.io
```

---

## Pod 安全进阶

### Pod 安全上下文

> ▎ Pod 安全上下文是 Pod 安全的基础。基础不稳，Pod 不稳。

**安全上下文**：
```yaml
apiVersion: v1
kind: Pod
metadata:
  name: security-context-demo
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    runAsGroup: 3000
    fsGroup: 2000
  containers:
  - name: app
    image: nginx:latest
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      capabilities:
        drop:
        - ALL
      runAsNonRoot: true
      runAsUser: 1000
```

**Seccomp 配置**：
```yaml
apiVersion: v1
kind: Pod
metadata:
  name: seccomp-pod
spec:
  securityContext:
    seccompProfile:
      type: RuntimeDefault
  containers:
  - name: app
    image: nginx:latest
```

### AppArmor 集成

**AppArmor 配置**：
```yaml
apiVersion: v1
kind: Pod
metadata:
  name: apparmor-pod
  annotations:
    container.apparmor.security.beta.kubernetes.io/app: runtime/default
spec:
  containers:
  - name: app
    image: nginx:latest
```

**自定义 AppArmor**：
```bash
# 创建 AppArmor 配置文件
cat > /etc/apparmor.d/docker-nginx << EOF
#include <tunables/global>
profile docker-nginx flags=(attach_disconnected,mediate_deleted) {
  #include <abstractions/base>
  network inet tcp,
  network inet udp,
  network inet icmp,
  deny network raw,
  deny network packet,
  file deny,
  /usr/sbin/nginx ix,
}
EOF

# 加载配置
apparmor_parser -r /etc/apparmor.d/docker-nginx
```

---

## 网络安全进阶

### 网络策略进阶

> ▎ 网络策略是 Kubernetes 网络安全的核心。核心不稳，网络不稳。

**默认拒绝策略**：
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress
```

**允许特定流量**：
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: frontend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: backend
    ports:
    - protocol: TCP
      port: 80
  - from:
    - namespaceSelector:
        matchLabels:
          name: monitoring
    ports:
    - protocol: TCP
      port: 9090
```

**出口控制**：
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-external
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - namespaceSelector: {}
    ports:
    - protocol: TCP
      port: 443
```

### CNI 安全

**Cilium 配置**：
```yaml
# Cilium 网络策略
apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
  name: restrict-egress
  namespace: default
spec:
  endpointSelector:
    matchLabels:
      app: backend
  egress:
  - toEntities:
    - Cluster
    toPorts:
    - ports:
      - port: "443"
        protocol: TCP
```

**Calico 配置**：
```yaml
apiVersion: projectcalico.org/v3
kind: NetworkPolicy
metadata:
  name: deny-all
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
```

---

## Secret 管理进阶

### Secret 加密

> ▎ Secret 加密是 Secret 管理的核心。核心不稳，Secret 不稳。

**etcd 加密**：
```yaml
# EncryptionConfiguration
apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
    - secrets
    providers:
    - aescbc:
        keys:
        - name: key1
          secret: <base64-encoded-secret>
    - identity: {}
```

**外部密钥管理**：
```yaml
# Vault 集成
apiVersion: v1
kind: Pod
metadata:
  name: app
  annotations:
    vault.hashicorp.com/agent-inject: "true"
    vault.hashicorp.com/agent-inject-secret-config.json: 'secret/data/app/config'
spec:
  serviceAccountName: vault-auth
  containers:
  - name: app
    image: app-image
    volumeMounts:
    - name: config
      mountPath: /etc/config
      readOnly: true
  volumes:
  - name: config
    emptyDir: {}
```

### Secret 轮换

**自动轮换**：
```yaml
# cert-manager 配置
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: tls-cert
spec:
  secretName: tls-secret
  duration: 2160h # 90 天
  renewBefore: 360h # 15 天前 renew
  issuerRef:
    name: letsencrypt
    kind: ClusterIssuer
```

**手动轮换**：
```bash
# 轮换 Secret
kubectl create secret generic new-secret --from-literal=key=newvalue

# 更新 Deployment
kubectl set env deployment/myapp SECRET_NAME=new-secret

# 重启 Pod
kubectl rollout restart deployment/myapp
```

---

## 审计日志进阶

### 审计策略

> ▎ 审计日志是 Kubernetes 安全的眼睛。没有眼睛，就是瞎子。

**审计策略配置**：
```yaml
# audit-policy.yaml
apiVersion: audit.k8s.io/v1
kind: Policy
rules:
# 不记录读操作
- level: None
  verbs: ["get", "watch", "list"]

# 记录所有写操作
- level: RequestResponse
  verbs: ["create", "update", "patch", "delete"]

# 记录敏感资源
- level: RequestResponse
  resources:
  - group: ""
    resources: ["secrets", "configmaps"]
```

**日志后端**：
```yaml
# 日志后端配置
apiVersion: v1
kind: Pod
metadata:
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
  - name: kube-apiserver
    command:
    - kube-apiserver
    - --audit-log-path=/var/log/kubernetes/audit.log
    - --audit-policy-file=/etc/kubernetes/audit-policy.yaml
    - --audit-log-maxage=30
    - --audit-log-maxbackup=10
    - --audit-log-maxsize=100
```

### 日志分析

**日志查询**：
```bash
# 查看审计日志
cat /var/log/kubernetes/audit.log | jq

# 搜索特定事件
grep '"verb":"create"' /var/log/kubernetes/audit.log

# 分析工具
kubectl-who-can
```

**告警配置**：
```yaml
# Prometheus 告警
groups:
  - name: kubernetes-audit
    rules:
    - alert: SecretAccess
      expr: sum(rate(kubernetes_audit_event_total{verb="get",resource="secrets"}[5m])) > 10
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "High rate of secret access"
```

---

## 安全扫描进阶

### kube-bench

> ▎ kube-bench 是 Kubernetes 安全扫描的基础。基础不稳，扫描不稳。

**安装使用**：
```bash
# 运行 kube-bench
kubectl apply -f https://raw.githubusercontent.com/aquasecurity/kube-bench/main/job.yaml

# 查看结果
kubectl logs job/kube-bench

# 本地运行
kube-bench run --targets node
```

**自定义检查**：
```yaml
# 自定义检查配置
---
controls:
- id: "1"
  text: "API Server"
  checks:
  - id: "1.1.1"
    text: "Ensure that the API server pod specification file permissions are set to 600 or more restrictive"
    audit: "stat -c %a /etc/kubernetes/manifests/kube-apiserver.yaml"
    tests:
    - test_flag: "600"
      op: eq
    remediation: "chmod 600 /etc/kubernetes/manifests/kube-apiserver.yaml"
```

### kube-hunter

**远程扫描**：
```bash
# 远程扫描
kube-hunter --remote k8s.example.com

# 内部扫描
kube-hunter --pod

# 生成报告
kube-hunter --report yaml > report.yaml
```

**主动扫描**：
```bash
# 主动扫描（危险）
kube-hunter --active

# 指定范围
kube-hunter --range 192.168.1.0/24
```

---

## 实战案例分析

### 案例 1: RBAC 配置错误

> ▎ RBAC 配置错误是最常见的 K8s 安全事件。最常见，也最容易防。

**漏洞描述**：
```
时间：2020 年
漏洞：RBAC 配置错误
影响：未授权访问
后果：集群完全控制
```

**攻击流程**：
```
1. 发现 ServiceAccount
   - kubectl get serviceaccounts

2. 测试权限
   - kubectl auth can-i --list

3. 权限提升
   - 创建 ClusterRoleBinding
   - 获取集群管理员权限

4. 集群沦陷
   - 读取所有 Secret
   - 创建特权 Pod
   - 完全控制集群
```

**防护方案**：
```
1. 最小权限
   - 限制 ServiceAccount 权限
   - 使用 Role 而非 ClusterRole
   - 限制命名空间

2. 审计日志
   - 启用审计日志
   - 监控 RBAC 变更
   - 告警通知

3. 定期审查
   - 定期审查 RBAC
   - 清理未使用 SA
   - 清理未使用权限
```

### 案例 2: 特权容器逃逸

**漏洞描述**：
```
时间：2019 年
漏洞：特权容器
影响：容器逃逸
后果：主机完全控制
```

**攻击流程**：
```
1. 发现特权容器
   - kubectl get pods --all-namespaces -o jsonpath='{.items[*].spec.containers[*].securityContext.privileged}'

2. 挂载主机文件系统
   - docker run -v /:/host

3. 逃逸到主机
   - chroot /host
   - 完全控制主机
```

**防护方案**：
```
1. Pod 安全策略
   - 禁止特权容器
   - 限制挂载
   - 删除能力

2. 准入控制
   - 启用 PodSecurityPolicy
   - 启用 OPA Gatekeeper
   - 启用准入控制

3. 监控检测
   - 监控特权容器
   - 监控挂载
   - 告警通知
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ████████░░ 4/5 │ 有改进空间     │
└───────────────┴────────────────┴────────────────┘
综合：3.75
```
▎ 勉强配得上 P8。别飘——容器编排安全这才刚入门。

---

## 总结与思考

### 核心要点回顾

> ▎ 复盘四步法：回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。

**Kubernetes 安全**：
```
1. API Server
   - 认证配置
   - 授权配置
   - 审计日志

2. etcd
   - 加密配置
   - 备份恢复
   - 访问控制

3. RBAC
   - Role 设计
   - RoleBinding
   - 最小权限
```

**Pod 安全**：
```
1. 安全上下文
   - 非 root 运行
   - 只读文件系统
   - 能力限制

2. 网络策略
   - 默认拒绝
   - 按需开放
   - 出口控制

3. Secret 管理
   - 加密存储
   - 密钥轮换
   - 外部管理
```

**安全扫描**：
```
1. kube-bench
   - CIS Benchmark
   - 自定义检查
   - 合规报告

2. kube-hunter
   - 远程扫描
   - 内部扫描
   - 主动扫描

3. 持续监控
   - 审计日志
   - 告警配置
   - 日志分析
```

### 深入思考问题

> ▎ 只动手不动脑，那是码农。动手又动脑，才是工程师。

**零信任 K8s**：
```
1. 持续验证
   - 每次请求验证
   - 动态授权
   - 行为分析

2. 微隔离
   - 服务隔离
   - 网络隔离
   - 权限隔离

3. 动态授权
   - 基于风险
   - 实时调整
   - 最小权限
```

**AI 辅助安全**：
```
1. 异常检测
   - 行为分析
   - 模式识别
   - 风险评分

2. 自动响应
   - 自动阻断
   - 自动修复
   - 自动告警

3. 威胁情报
   - K8s 威胁
   - 容器威胁
   - 编排威胁
```

**云原生安全**：
```
1. 服务网格
   - Istio 安全
   - mTLS
   - 策略执行

2. Serverless
   - 函数安全
   - 事件安全
   - 依赖安全

3. 边缘计算
   - 边缘节点
   - 延迟优化
   - 安全隔离
```

### 实战建议

> ▎ 我给你指了路，走不走是你的事。机会给了，抓不抓得住看你。

**K8s 管理员**：
```
1. 安全配置
   - RBAC 配置
   - 网络策略
   - Secret 管理

2. 持续监控
   - 审计日志
   - 安全扫描
   - 告警通知

3. 定期更新
   - K8s 更新
   - 补丁管理
   - 漏洞修复
```

**安全人员**：
```
1. 安全审计
   - 配置审计
   - 权限审计
   - 日志审计

2. 渗透测试
   - K8s 测试
   - 容器测试
   - 编排测试

3. 事件响应
   - K8s 事件
   - 快速响应
   - 溯源分析
```

**架构师**：
```
1. 安全设计
   - 最小权限
   - 网络隔离
   - 纵深防御

2. 持续改进
   - 安全审计
   - 漏洞管理
   - 安全培训

3. 工具链
   - 安全工具
   - 自动化
   - 监控平台
```

---

## 参考资料

### 学习资源
```
- Kubernetes Security
  https://kubernetes.io/docs/concepts/security/

- CNCF Security
  https://github.com/cncf/tag-security

- CIS Kubernetes Benchmark
  https://www.cisecurity.org/benchmark/kubernetes
```

### 工具资源
```
- kube-bench
  https://github.com/aquasecurity/kube-bench

- kube-hunter
  https://github.com/aquasecurity/kube-hunter

- Falco
  https://falco.org/
```

### 书籍推荐
```
- 《Kubernetes 安全》
- 《Cloud Native Security》
- 《Kubernetes Security and Observability》
```

### 在线资源
```
- OWASP Kubernetes Security
  https://owasp.org/www-project-kubernetes-security/

- Kubernetes Hardening Guide
  https://github.com/stackrox/Kubernetes-Security-Best-Practices

- Awesome Kubernetes Security
  https://github.com/kai5263499/awesome-kubernetes-security
```

---

**标记 明日预告**：Day 106 - 应用安全基础

> ▎ 今天的内容消化了吗？消化了就继续——明天还有硬仗。

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 105 篇，系统安全部分第 10 篇（收官篇），精编版本*

*系统安全部分 15 天课程全部完成！*