Day-124-云原生安全架构

# Day 138: 云原生安全架构

> 应用安全系列第 31 天 | 预计阅读时间：50 分钟 | 难度：★★★★★

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ 云原生安全架构 - Day 138           │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ 云原生不是把应用搬上云，是重构应用架构。架构重构，安全就要重构。今天系统学习云原生安全。

---

## 清单 目录

1. [云原生概述](#云原生概述)
2. [云原生安全威胁](#云原生安全威胁)
3. [容器安全](#容器安全)
4. [Kubernetes 安全](#kubernetes 安全)
5. [服务网格安全](#服务网格安全)
6. [DevSecOps 实践](#devsecops 实践)
7. [零信任架构](#零信任架构)
8. [云原生合规](#云原生合规)
9. [实战安全建设](#实战安全建设)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 云原生概述

### 什么是云原生

> ▎ 云原生不是云上的应用，是为云设计的应用。为云设计，才能用好云。

**CNCF 定义**：
```
云原生 (Cloud Native) 是一种构建和运行可扩展应用的方法，充分利用云计算交付模型的优势。

核心特征：
1. 容器化 (Containerized)
   - 应用打包为容器
   - 环境一致性
   - 快速部署

2. 动态编排 (Dynamically Orchestrated)
   - 自动调度
   - 弹性伸缩
   - 自愈能力

3. 微服务架构 (Microservices)
   - 松耦合服务
   - 独立部署
   - 技术多样性

4. DevOps 文化 (DevOps Culture)
   - 持续交付
   - 自动化
   - 快速迭代
```

**云原生技术栈**：
```
┌─────────────────────────────────────────────────────────┐
│                    应用层                                │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │微服务    │  │Serverless │  │API 网关  │              │
│  └──────────┘  └──────────┘  └──────────┘              │
├─────────────────────────────────────────────────────────┤
│                    编排层                                │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │Kubernetes│  │服务网格  │  │服务发现  │              │
│  └──────────┘  └──────────┘  └──────────┘              │
├─────────────────────────────────────────────────────────┤
│                    运行时层                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │容器运行时 │  │容器镜像  │  │安全沙箱  │              │
│  └──────────┘  └──────────┘  └──────────┘              │
├─────────────────────────────────────────────────────────┤
│                    基础设施层                            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │公有云    │  │私有云    │  │混合云    │              │
│  └──────────┘  └──────────┘  └──────────┘              │
└─────────────────────────────────────────────────────────┘
```

### 云原生安全挑战

**新挑战**：
```
1. 边界模糊
   - 传统网络边界消失
   - 东西向流量增加
   - 微服务间信任问题

2. 动态变化
   - 容器频繁启停
   - IP 地址动态分配
   - 传统安全工具失效

3. 供应链复杂
   - 基础镜像来源
   - 第三方依赖
   - CI/CD 管道安全

4. 配置复杂
   - Kubernetes 配置
   - 网络策略
   - RBAC 权限

5. 可观测性困难
   - 分布式追踪
   - 日志聚合
   - 安全监控
```

---

## 云原生安全威胁

### 威胁矩阵

> ▎ 威胁不看清，防御就是盲目的。盲目防御，等于不防。

**云原生威胁矩阵**：
```
┌─────────────────────────────────────────────────────────┐
│              云原生安全威胁矩阵 (CNCF)                   │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  阶段 1: 构建时                                          │
│  ├── 代码漏洞                                           │
│  ├── 依赖漏洞                                           │
│  ├── 镜像漏洞                                           │
│  └── 密钥泄露                                           │
│                                                         │
│  阶段 2: 部署时                                          │
│  ├── 配置错误                                           │
│  ├── 权限过大                                           │
│  ├── 网络暴露                                           │
│  └── 凭证泄露                                           │
│                                                         │
│  阶段 3: 运行时                                          │
│  ├── 容器逃逸                                           │
│  ├── 横向移动                                           │
│  ├── 数据窃取                                           │
│  └── 资源滥用                                           │
│                                                         │
└─────────────────────────────────────────────────────────┘
```

**常见攻击场景**：
```
1. 镜像投毒
   - 污染基础镜像
   - 植入后门
   - 供应链攻击

2. 配置利用
   - 暴露的 API Server
   - 宽松的 RBAC
   - 未设置网络策略

3. 容器逃逸
   - 内核漏洞
   - 特权容器
   - 挂载敏感目录

4. 横向移动
   - 服务账号窃取
   - 内部网络扫描
   - 凭证传递

5. 数据泄露
   - 未加密存储
   - 日志敏感信息
   - 配置泄露
```

---

## 容器安全

### 镜像安全

> ▎ 镜像是容器的模板。模板有毒，容器就是毒的。

**镜像安全最佳实践**：
```dockerfile
# 不安全的 Dockerfile
FROM ubuntu:latest
RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    curl \
    wget
COPY . /app
WORKDIR /app
RUN pip3 install -r requirements.txt
USER root
EXPOSE 8080
CMD ["python3", "app.py"]

# 安全的 Dockerfile
# 1. 使用精简基础镜像
FROM python:3.11-slim

# 2. 指定具体版本
FROM python:3.11.4-slim-bullseye

# 3. 多阶段构建
FROM golang:1.21 AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

FROM alpine:3.18
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
COPY --from=builder /app/config.yaml .

# 4. 非 root 用户
RUN adduser -D -g '' appuser
USER appuser

# 5. 只读文件系统
USER appuser
WORKDIR /app
COPY --chown=appuser:appuser . .
RUN chmod -R 555 .
RUN chmod -R 444 config.yaml

# 6. 最小化暴露
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget -q --spider http://localhost:8080/health || exit 1

# 7. 使用 distroless
FROM gcr.io/distroless/static-debian11
COPY --from=builder /app/main .
CMD ["./main"]
```

**镜像扫描**：
```python
# 镜像安全扫描
class ContainerImageSecurity:
    def __init__(self):
        self.scanners = {
            'trivy': TrivyScanner(),
            'grype': GrypeScanner(),
            'clair': ClairScanner()
        }
    
    def scan_image(self, image_name):
        """扫描镜像"""
        results = {}
        
        # 漏洞扫描
        for scanner_name, scanner in self.scanners.items():
            scan_result = scanner.scan(image_name)
            results[scanner_name] = scan_result
        
        # 汇总结果
        aggregated = self.aggregate_results(results)
        
        # 风险评估
        risk_level = self.assess_risk(aggregated)
        
        return {
            'vulnerabilities': aggregated,
            'risk_level': risk_level,
            'recommendation': self.get_recommendation(risk_level)
        }
    
    def check_best_practices(self, image_name):
        """检查最佳实践"""
        checks = [
            # 1. 是否使用 root 用户
            {'name': 'non_root_user', 'passed': self.check_non_root(image_name)},
            
            # 2. 是否有多阶段构建
            {'name': 'multi_stage', 'passed': self.check_multi_stage(image_name)},
            
            # 3. 是否有敏感信息
            {'name': 'no_secrets', 'passed': self.check_no_secrets(image_name)},
            
            # 4. 是否使用最新基础镜像
            {'name': 'updated_base', 'passed': self.check_base_image_updated(image_name)},
            
            # 5. 是否最小化安装
            {'name': 'minimal_install', 'passed': self.check_minimal_install(image_name)}
        ]
        
        passed = sum(1 for c in checks if c['passed'])
        score = passed / len(checks)
        
        return {
            'score': score,
            'checks': checks,
            'passed': passed,
            'total': len(checks)
        }
    
    def get_recommendation(self, risk_level):
        """获取建议"""
        if risk_level == 'CRITICAL':
            return "DO NOT DEPLOY - Fix critical vulnerabilities first"
        elif risk_level == 'HIGH':
            return "Deploy with caution - Fix high severity issues"
        elif risk_level == 'MEDIUM':
            return "Acceptable for non-production - Plan fixes"
        else:
            return "Ready for deployment"
```

### 运行时安全

**容器运行时保护**：
```python
# 容器运行时安全
class ContainerRuntimeSecurity:
    def __init__(self):
        self.security_context = {
            'runAsNonRoot': True,
            'readOnlyRootFilesystem': True,
            'allowPrivilegeEscalation': False,
            'capabilities': {
                'drop': ['ALL']
            }
        }
    
    def configure_security_context(self, pod_spec):
        """配置安全上下文"""
        # Pod 级别
        pod_spec['securityContext'] = {
            'runAsNonRoot': True,
            'runAsUser': 1000,
            'runAsGroup': 1000,
            'fsGroup': 1000
        }
        
        # 容器级别
        for container in pod_spec['containers']:
            container['securityContext'] = {
                'runAsNonRoot': True,
                'readOnlyRootFilesystem': True,
                'allowPrivilegeEscalation': False,
                'capabilities': {
                    'drop': ['ALL']
                }
            }
        
        return pod_spec
    
    def detect_anomaly(self, container_events):
        """检测异常行为"""
        anomalies = []
        
        # 检测容器逃逸
        if self.detect_escape_attempt(container_events):
            anomalies.append({
                'type': 'CONTAINER_ESCAPE',
                'severity': 'CRITICAL',
                'action': 'ISOLATE_AND_INVESTIGATE'
            })
        
        # 检测异常进程
        if self.detect_suspicious_process(container_events):
            anomalies.append({
                'type': 'SUSPICIOUS_PROCESS',
                'severity': 'HIGH',
                'action': 'INVESTIGATE'
            })
        
        # 检测异常网络连接
        if self.detect_suspicious_network(container_events):
            anomalies.append({
                'type': 'SUSPICIOUS_NETWORK',
                'severity': 'HIGH',
                'action': 'BLOCK_AND_INVESTIGATE'
            })
        
        # 检测资源滥用
        if self.detect_resource_abuse(container_events):
            anomalies.append({
                'type': 'RESOURCE_ABUSE',
                'severity': 'MEDIUM',
                'action': 'THROTTLE'
            })
        
        return anomalies
    
    def detect_escape_attempt(self, events):
        """检测容器逃逸"""
        escape_indicators = [
            'mounting host filesystem',
            'accessing /proc or /sys',
            'using ptrace',
            'loading kernel modules',
            'accessing docker socket'
        ]
        
        for event in events:
            for indicator in escape_indicators:
                if indicator in event.get('message', ''):
                    return True
        
        return False
```

---

## Kubernetes 安全

### 集群安全配置

> ▎ Kubernetes 不是装好就安全，是配好才安全。配置不对，集群就是裸奔的。

**API Server 安全**：
```yaml
# Kubernetes API Server 安全配置
apiVersion: v1
kind: Pod
metadata:
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
  - name: kube-apiserver
    image: k8s.gcr.io/kube-apiserver:v1.28.0
    command:
    - kube-apiserver
    # 认证配置
    - --anonymous-auth=false              # 禁用匿名访问
    - --basic-auth-file=""                # 禁用基本认证
    - --token-auth-file=""                # 禁用静态令牌
    - --client-ca-file=/etc/pki/ca.pem    # 客户端 CA
    
    # 授权配置
    - --authorization-mode=Node,RBAC      # 启用 RBAC
    - --enable-admission-plugins=NodeRestriction,PodSecurityPolicy
    
    # 审计配置
    - --audit-log-path=/var/log/kubernetes/audit.log
    - --audit-log-maxage=30
    - --audit-log-maxbackup=10
    - --audit-log-maxsize=100
    - --audit-policy-file=/etc/kubernetes/audit-policy.yaml
    
    # TLS 配置
    - --tls-cert-file=/etc/pki/apiserver.crt
    - --tls-private-key-file=/etc/pki/apiserver.key
    - --kubelet-client-certificate=/etc/pki/apiserver-kubelet.crt
    - --kubelet-client-key=/etc/pki/apiserver-kubelet.key
    
    # 安全端口
    - --secure-port=6443
    - --insecure-port=0                   # 禁用非安全端口
    
    # 服务账号
    - --service-account-key-file=/etc/pki/sa.pub
    - --service-account-signing-key-file=/etc/pki/sa.key
    - --service-account-issuer=https://kubernetes.default.svc
```

**RBAC 最佳实践**：
```yaml
# 最小权限 RBAC 配置
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: app-reader
  namespace: production
rules:
# 只读权限
- apiGroups: [""]
  resources: ["pods", "services", "configmaps"]
  verbs: ["get", "list", "watch"]
# 不允许 create, update, delete

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: app-reader-binding
  namespace: production
subjects:
- kind: ServiceAccount
  name: app-service-account
  namespace: production
roleRef:
  kind: Role
  name: app-reader
  apiGroup: rbac.authorization.k8s.io

---
# 禁止绑定 cluster-admin
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: no-cluster-admin
subjects: []  # 永远为空
roleRef:
  kind: ClusterRole
  name: cluster-admin
  apiGroup: rbac.authorization.k8s.io
```

### 网络策略

**网络隔离**：
```yaml
# 默认拒绝所有流量
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: production
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

---
# 允许特定服务间通信
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080

---
# 允许访问外部数据库
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-external-db
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 10.0.0.0/8
        except:
        - 10.0.0.0/24  # 排除内部网络
    ports:
    - protocol: TCP
      port: 5432

---
# 允许 DNS 查询
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns
  namespace: production
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          name: kube-system
    ports:
    - protocol: UDP
      port: 53
    - protocol: TCP
      port: 53
```

### Pod 安全

**Pod 安全标准**：
```yaml
# Pod 安全准入 (Pod Security Admission)
apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    pod-security.kubernetes.io/enforce: restricted    # 强制执行
    pod-security.kubernetes.io/enforce-version: latest
    pod-security.kubernetes.io/audit: restricted      # 审计
    pod-security.kubernetes.io/audit-version: latest
    pod-security.kubernetes.io/warn: restricted       # 警告
    pod-security.kubernetes.io/warn-version: latest

---
# 安全的 Pod 配置
apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
  namespace: production
spec:
  # Pod 安全上下文
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    runAsGroup: 1000
    fsGroup: 1000
    seccompProfile:
      type: RuntimeDefault
  
  containers:
  - name: app
    image: myapp:1.0.0
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      capabilities:
        drop:
        - ALL
      
    # 资源限制
    resources:
      limits:
        cpu: "1"
        memory: "512Mi"
      requests:
        cpu: "100m"
        memory: "128Mi"
    
    # 挂载只读
    volumeMounts:
    - name: tmp
      mountPath: /tmp
    - name: config
      mountPath: /etc/config
      readOnly: true
  
  volumes:
  - name: tmp
    emptyDir: {}
  - name: config
    configMap:
      name: app-config
```

---

## 服务网格安全

### Istio 安全

> ▎ 服务网格不是可选的，是云原生安全的必需品。没有服务网格，微服务就是散的。

**mTLS 配置**：
```yaml
# Istio 全局 mTLS
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: istio-system
spec:
  mtls:
    mode: STRICT  # 强制 mTLS

---
# 命名空间级别 mTLS
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: production-mtls
  namespace: production
spec:
  mtls:
    mode: STRICT

---
# 服务级别 mTLS
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: api-mtls
  namespace: production
spec:
  selector:
    matchLabels:
      app: api
  mtls:
    mode: STRICT
```

**授权策略**：
```yaml
# 允许特定服务访问
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: production
spec:
  selector:
    matchLabels:
      app: backend
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/production/sa/frontend"]
    to:
    - operation:
        methods: ["GET", "POST"]
        paths: ["/api/*"]

---
# 拒绝特定请求
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: deny-sensitive-endpoints
  namespace: production
spec:
  selector:
    matchLabels:
      app: api
  action: DENY
  rules:
  - to:
    - operation:
        paths: ["/admin/*", "/debug/*"]
    from:
    - source:
        notNamespaces: ["admin-namespace"]

---
# 基于 JWT 的授权
apiVersion: security.istio.io/v1beta1
kind: RequestAuthentication
metadata:
  name: jwt-auth
  namespace: production
spec:
  selector:
    matchLabels:
      app: api
  jwtRules:
  - issuer: "https://auth.example.com"
    jwksUri: "https://auth.example.com/.well-known/jwks.json"
    audiences:
    - "my-api"

---
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: require-jwt
  namespace: production
spec:
  selector:
    matchLabels:
      app: api
  action: ALLOW
  rules:
  - from:
    - source:
        requestPrincipals: ["*"]  # 需要 JWT
```

---

## DevSecOps 实践

### 安全流水线

> ▎ 安全不是上线前检查，是贯穿全流程。流程不嵌入，安全就是事后补救。

**CI/CD 安全集成**：
```yaml
# GitLab CI 安全流水线
stages:
  - build
  - test
  - security
  - deploy

variables:
  SECURE_LOG_LEVEL: info

# 构建阶段
build:
  stage: build
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

# 测试阶段
test:
  stage: test
  script:
    - npm test
    - npm run test:coverage

# 安全扫描阶段
sast:
  stage: security
  script:
    # 静态应用安全测试
    - semgrep --config auto --json --output sast-report.json .
    
    # 依赖扫描
    - npm audit --json > npm-audit-report.json
    - safety check --json > safety-report.json
    
    # 镜像扫描
    - trivy image --format json --output trivy-report.json $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
    
  artifacts:
    reports:
      sast: sast-report.json
      dependency_scanning: npm-audit-report.json

container_scan:
  stage: security
  script:
    - grype $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA --fail-on high
  allow_failure: false

iac_scan:
  stage: security
  script:
    # Kubernetes 配置扫描
    - kube-score score -ci deployment.yaml
    # Terraform 扫描
    - checkov -d . --framework terraform
  allow_failure: false

# 部署阶段
deploy:
  stage: deploy
  script:
    - kubectl apply -f k8s/
  only:
    - main
  when: on_success
  dependencies:
    - sast
    - container_scan
    - iac_scan
```

**安全门禁**：
```python
# 安全门禁实现
class SecurityGate:
    def __init__(self):
        self.gates = {
            'sast': SASTGate(),
            'dependency': DependencyGate(),
            'container': ContainerGate(),
            'iac': IACGate()
        }
        self.thresholds = {
            'critical': 0,  # 不允许高危
            'high': 0,      # 不允许高危
            'medium': 10,   # 最多 10 个中危
            'low': 100      # 最多 100 个低危
        }
    
    def check_all_gates(self, scan_results):
        """检查所有安全门禁"""
        results = {}
        all_passed = True
        
        for gate_name, gate in self.gates.items():
            if gate_name in scan_results:
                passed = gate.check(scan_results[gate_name], self.thresholds)
                results[gate_name] = {
                    'passed': passed,
                    'findings': gate.count_findings(scan_results[gate_name])
                }
                if not passed:
                    all_passed = False
        
        return {
            'all_passed': all_passed,
            'gates': results,
            'recommendation': 'DEPLOY' if all_passed else 'BLOCK'
        }

class SASTGate:
    def check(self, results, thresholds):
        """SAST 门禁"""
        critical = sum(1 for r in results if r['severity'] == 'critical')
        high = sum(1 for r in results if r['severity'] == 'high')
        
        return critical <= thresholds['critical'] and high <= thresholds['high']

class DependencyGate:
    def check(self, results, thresholds):
        """依赖扫描门禁"""
        critical = sum(1 for r in results if r['severity'] == 'critical')
        high = sum(1 for r in results if r['severity'] == 'high')
        
        return critical <= thresholds['critical'] and high <= thresholds['high']
```

---

## 零信任架构

### 零信任原则

> ▎ 零信任不是不信任，是持续验证。不验证，信任就是盲目的。

**零信任核心原则**：
```
1. 显式验证 (Verify Explicitly)
   - 验证所有请求
   - 基于所有可用数据
   - 动态授权

2. 最小权限 (Least Privilege)
   - 按需授权
   - 及时回收
   -  JIT 访问

3. 假设泄露 (Assume Breach)
   - 分段隔离
   - 加密所有
   - 持续监控
```

**零信任架构**：
```
┌─────────────────────────────────────────────────────────┐
│                    策略引擎                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │身份策略  │  │设备策略  │  │应用策略  │              │
│  └──────────┘  └──────────┘  └──────────┘              │
├─────────────────────────────────────────────────────────┤
│                    策略执行点                            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │API 网关  │  │服务网格  │  │防火墙    │              │
│  └──────────┘  └──────────┘  └──────────┘              │
├─────────────────────────────────────────────────────────┤
│                    数据源                                │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │身份系统  │  │设备管理  │  │威胁情报  │              │
│  └──────────┘  └──────────┘  └──────────┘              │
└─────────────────────────────────────────────────────────┘
```

### 实施零信任

**身份验证**：
```yaml
# Kubernetes 服务账号认证
apiVersion: v1
kind: ServiceAccount
metadata:
  name: api-service
  namespace: production
  annotations:
    # 绑定到特定工作负载
    eks.amazonaws.com/role-arn: arn:aws:iam::123456789:role/api-role

---
# 短期凭证
apiVersion: v1
kind: Secret
metadata:
  name: api-service-token
  namespace: production
  annotations:
    # 自动过期
    kubernetes.io/service-account.name: api-service
type: kubernetes.io/service-account-token
```

**微隔离**：
```yaml
# 服务间零信任通信
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: zero-trust-default
  namespace: production
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
  # 默认拒绝所有
  ingress: []
  egress: []

---
# 明确允许的通信
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-specific
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    - podSelector:
        matchLabels:
          app: monitoring
    ports:
    - protocol: TCP
      port: 8080
```

---

## 实战安全建设

### 安全建设路线图

**阶段一：基础安全 (1-3 个月)**：
```
1. 镜像安全
   - 建立镜像扫描流程
   - 使用可信基础镜像
   - 实施非 root 用户

2. 集群加固
   - API Server 安全配置
   - 启用 RBAC
   - 审计日志

3. 网络安全
   - 默认拒绝策略
   - 网络策略实施
   - 服务间 mTLS
```

**阶段二：进阶安全 (3-6 个月)**：
```
1. DevSecOps
   - 安全集成 CI/CD
   - 自动化安全测试
   - 安全门禁

2. 运行时保护
   - 异常检测
   - 入侵检测
   - 自动响应

3. 密钥管理
   - 集中密钥管理
   - 自动轮换
   - 访问审计
```

**阶段三：成熟安全 (6-12 个月)**：
```
1. 零信任架构
   - 身份感知
   - 动态授权
   - 持续验证

2. 安全运营
   - 安全监控
   - 威胁狩猎
   - 应急响应

3. 合规管理
   - 自动化合规
   - 持续审计
   - 报告生成
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ██████████ 5/5 │ 生产就绪       │
└───────────────┴────────────────┴────────────────┘
综合：4.5
```
▎ 这才配得上 P8。云原生安全不是一蹴而就，是持续建设。建设不停，安全才有保障。

---

## 总结与思考

### 核心要点回顾

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

**云原生安全框架**：
```
1. 容器安全
   - 镜像安全
   - 运行时安全
   - Registry 安全

2. Kubernetes 安全
   - 集群配置
   - RBAC
   - 网络策略
   - Pod 安全

3. 服务网格安全
   - mTLS
   - 授权策略
   - 访问控制

4. DevSecOps
   - 安全流水线
   - 安全门禁
   - 自动化测试

5. 零信任架构
   - 身份验证
   - 微隔离
   - 持续监控
```

**关键实践**：
```
1. 安全左移
   - 设计阶段考虑安全
   - 开发阶段集成安全
   - 测试阶段验证安全

2. 纵深防御
   - 多层防护
   - 冗余设计
   - 故障安全

3. 持续监控
   - 实时检测
   - 自动响应
   - 持续改进
```

### 深入思考问题

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

**云原生安全演进**：
```
1. 从边界到零信任
   - 网络边界消失
   - 身份成为新边界
   - 持续验证

2. 从手动到自动
   - 自动化安全
   - 策略即代码
   - 自动响应

3. 从合规到安全
   - 合规是基线
   - 安全是目标
   - 持续改进
```

**安全与效率平衡**：
```
1. 安全不阻碍创新
   - 自助服务
   - 安全默认
   - 例外流程

2. 效率不牺牲安全
   - 自动化检查
   - 智能决策
   - 风险感知

3. 找到平衡点
   - 风险接受
   - 成本效益
   - 业务对齐
```

### 实战建议

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

**安全建设**：
```
1. 从基础开始
   - 先做最重要的
   - 快速见效
   - 建立信心

2. 持续改进
   - 定期评估
   - 学习分享
   - 工具升级

3. 文化建设
   - 安全培训
   - 责任共担
   - 正向激励
```

**团队能力**：
```
1. 技能培养
   - 云原生知识
   - 安全技能
   - 工具使用

2. 流程建设
   - 安全流程
   - 应急响应
   - 知识沉淀

3. 工具链建设
   - 自动化工具
   - 监控平台
   - 报告系统
```

---

## 参考资料

### 学习资源
```
- CNCF Security Technical Advisory Group
  https://github.com/cncf/tag-security

- Kubernetes Security Best Practices
  https://kubernetes.io/docs/concepts/security/

- Cloud Native Security (O'Reilly)
  https://www.oreilly.com/library/view/cloud-native-security/
```

### 工具资源
```
- Trivy (镜像扫描)
  https://github.com/aquasecurity/trivy

- Falco (运行时安全)
  https://falco.org/

- OPA (策略引擎)
  https://www.openpolicyagent.org/

- kube-bench (CIS 基准检查)
  https://github.com/aquasecurity/kube-bench
```

### 标准规范
```
- CIS Kubernetes Benchmark
  https://www.cisecurity.org/benchmark/kubernetes

- NIST Container Security
  https://csrc.nist.gov/publications/detail/sp/800-190/final

- NSA/CISA Kubernetes Hardening Guide
  https://media.defense.gov/2022/Aug/29/2003066362/-1/-1/0/CTR_KUBERNETES_HARDENING_GUIDANCE_1.2_20220829.PDF
```

### 书籍推荐
```
- 《Cloud Native Security》
- 《Kubernetes Security and Observability》
- 《DevSecOps on Kubernetes》
- 《Zero Trust Networks》
```

---

**标记 明日预告**：Day 139 - API 安全最佳实践

> ▎ 云原生安全是基础设施，API 安全是应用前沿——明天看 API 安全最佳实践。

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

---

*本文是 365 天信息安全技术系列的第 138 篇，应用安全部分第 31 篇，精编版本*

*新兴技术安全深化系列继续！*