Devops on 丸子有记, 记录生活、分享技术，专注于运维架构、运维开发(devops)。

基于OpenObserve和Fluent Bit搭建企业日志服务平台

wzdushu@gmail.com (wanzi) — Wed, 12 Nov 2025 09:30:00 +0800

平台架构

技术选型

OpenObserve（原名O2）是一款开源的可观测性平台，相比传统ELK方案具有显著优势：

资源占用低：内存占用仅为Elasticsearch的1/10，存储空间节省90%
高性能：基于Rust编写，单节点可处理5TB+日志/天
全功能：集成日志、指标、链路追踪，替代Grafana+Loki+Tempo
兼容性强：支持Elasticsearch API、Prometheus API、OpenTelemetry
部署简单：单一二进制文件，无外部依赖

Fluent Bit是云原生日志收集器：

轻量级：内存占用<1MB，适合嵌入式和容器环境
高性能：多线程异步处理，吞吐量可达100MB/s
丰富插件：支持200+输入/输出/过滤/解析器
Kubernetes原生：自动发现Pod、标签注入、元数据关联

架构设计

┌─────────────────────────────────────────────────────────────────┐
│                        业务应用层                                 │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
│  │  Java应用 │  │  Go服务  │  │ Nginx日志 │  │ 系统日志  │       │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘       │
│       │             │             │             │               │
│  stdout/stderr   stdout/stderr  /var/log/*   /var/log/*         │
└───────┼─────────────┼─────────────┼─────────────┼───────────────┘
        │             │             │             │
┌───────┴─────────────┴─────────────┴─────────────┴───────────────┐
│                      Kubernetes集群                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              DaemonSet: Fluent Bit                      │   │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │   │
│  │  │  Tail输入    │→ │  过滤/解析   │→ │  Buffer缓冲  │  │   │
│  │  └──────────────┘  └──────────────┘  └──────────────┘  │   │
│  └─────────────────────────────────────────────────────────┘   │
└──────────────────────────────┬──────────────────────────────────┘
                               │ HTTP/HTTPS
┌──────────────────────────────┴──────────────────────────────────┐
│                    OpenObserve集群                               │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │  Ingest节点  │→ │  数据存储    │→ │  查询引擎    │          │
│  │  (写入优化)  │  │  (Parquet)   │  │  (全文检索)  │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
└─────────────────────────────────────────────────────────────────┘

组件版本

组件	版本	说明
OpenObserve	0.15.0+	稳定版，支持分布式
Fluent Bit	4.0.0+	最新稳定版
Kubernetes	1.24+	生产环境
Helm	3.0+	部署工具

OpenObserve部署

前置准备

# 1. 创建Namespace
kubectl create namespace logging

# 2. 添加OpenObserve Helm仓库
helm repo add openobserve https://charts.openobserve.ai
helm repo update

# 3. 创建PV/PVC（生产环境使用分布式存储）
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: openobserve-data
  namespace: logging
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: zstack-rbd  # 根据实际SC调整
  resources:
    requests:
      storage: 500Gi
EOF

Helm部署OpenObserve

创建values文件 openobserve-values.yaml：

# openobserve-values.yaml

image:
  repository: public.ecr.aws/zinclabs/openobserve
  tag: "0.15.1"
  pullPolicy: IfNotPresent

replicaCount: 3  # 生产环境建议3节点高可用

# 资源配置（根据日志量调整）
resources:
  limits:
    cpu: "8"
    memory: 16Gi
  requests:
    cpu: "4"
    memory: 8Gi

# 数据持久化
persistence:
  enabled: true
  existingClaim: openobserve-data
  mountPath: /data

# 环境变量
env:
  - name: ZO_ROOT_USER_EMAIL
    value: "admin@example.com"
  - name: ZO_ROOT_USER_PASSWORD
    valueFrom:
      secretKeyRef:
        name: openobserve-secret
        key: password
  - name: ZO_DATA_DIR
    value: "/data"
  - name: ZO_HTTP_PORT
    value: "5080"
  - name: ZO_MEMORY_CACHE_ENABLED
    value: "true"
  - name: ZO_MEMORY_CACHE_MAX_SIZE
    value: "4096"  # MB
  - name: ZO_COMPRESSION_ENABLED
    value: "true"
  - name: ZO_COMPRESSION_FORMAT
    value: "zstd"
  - name: ZO_PARquet_COMPRESSION
    value: "zstd"
  - name: ZO_META_STORE
    value: "sqlite"  # 生产环境使用PostgreSQL
  - name: ZO_METRICS_ENABLED
    value: "true"

# 配置PostgreSQL元数据库（生产环境推荐）
envFrom:
  - secretRef:
      name: postgres-connection

# Service配置
service:
  type: ClusterIP
  port: 5080
  targetPort: 5080
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: "nlb"

# Ingress配置
ingress:
  enabled: true
  className: "nginx"
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
    nginx.ingress.kubernetes.io/proxy-body-size: "100m"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "600"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "600"
  hosts:
    - host: logs.example.com
      paths:
        - path: /
          pathType: Prefix
  tls:
    - secretName: logs-tls
      hosts:
        - logs.example.com

# Pod调度
nodeSelector: {}
tolerations: []
affinity:
  podAntiAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          labelSelector:
            matchExpressions:
              - key: app.kubernetes.io/name
                operator: In
                values:
                  - openobserve
          topologyKey: kubernetes.io/hostname

# 监控配置
monitoring:
  enabled: true
  serviceMonitor:
    enabled: true
    interval: 30s
    namespace: logging

部署OpenObserve

# 1. 创建密码Secret
kubectl create secret generic openobserve-secret \
  --from-literal=password='your-secure-password' \
  -n logging

# 2. 部署
helm upgrade --install openobserve openobserve/openobserve \
  -n logging \
  -f openobserve-values.yaml \
  --version 0.10.2 \
  --timeout 15m

# 3. 等待Pod就绪
kubectl wait --for=condition=ready pod \
  -l app.kubernetes.io/name=openobserve \
  -n logging \
  --timeout=300s

# 4. 查看状态
kubectl get pods -n logging
kubectl logs -f deployment/openobserve -n logging

# 5. 访问Web UI
echo "访问地址: https://logs.example.com"
echo "默认用户: admin@example.com"

Fluent Bit部署

安装 Helm Chart

helm repo add fluent https://fluent.github.io/helm-charts
helm repo update
helm pull fluent/fluent-bit --version 0.50.0
helm install fluent-bit ./fluent-bit-0.50.0.tgz --namespace uganda-prod

调整 DaemonSet 配置

spec:
  volumes:
    - name: config
      configMap:
        name: fluent-bit
        defaultMode: 420
  containers:
    resources:
      requests:
        cpu: "1"
        memory: 2Gi
      limits:
        cpu: "2"
        memory: 4Gi
    volumeMounts:
      - name: config
        mountPath: /fluent-bit/etc/conf/custom_parsers.conf
        subPath: custom_parsers.conf
      - name: config
        mountPath: /fluent-bit/etc/conf/multiline_parsers.conf
        subPath: multiline_parsers.conf

Fluent Bit采集规则调整

完整ConfigMap 配置

kind: ConfigMap
apiVersion: v1
metadata:
  name: fluent-bit-config
  namespace: uganda-prod
  labels:
    app: fluent-bit
    tier: logging
data:
  # ---------------------------------------------------------------------------
  # 1. 自定义解析器 (Custom Parsers)
  # 用于提取特定格式的日志字段，例如从 Java 日志中提取日志级别 (INFO, ERROR 等)
  # ---------------------------------------------------------------------------
  custom_parsers.conf: |
    [PARSER]
        Name        java_log_level
        Format      regex
        # 匹配格式: 2023-10-27 10:00:00.123 INFO ...
        # 捕获组 'level' 将包含日志级别
        Regex       ^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\s+(?<level>[A-Z]+)

  # ---------------------------------------------------------------------------
  # 2. 多行解析器 (Multiline Parsers)
  # 专门用于处理 Java 堆栈跟踪等多行日志，防止堆栈被拆分成多条记录
  # ---------------------------------------------------------------------------
  multiline_parsers.conf: |
    [MULTILINE_PARSER]
        Name          java_md_multiline
        Type          regex
        # 规则 1: 如果行以日期开头 (如 2023-...)，视为新日志的开始
        rule      "start_state"   "/^\d{4}-\d{2}-\d{2}/"           "cont"
        # 规则 2: 如果行不以日期开头，视为上一行的延续 (堆栈部分)
        rule      "cont"        "/^(?!\d{4}-\d{2}-\d{2}).+/"     "cont"
        # 刷新超时时间 (秒)，超时后强制输出当前缓冲的多行日志
        flush_timeout 5

  # ---------------------------------------------------------------------------
  # 3. 主配置文件 (Main Configuration)
  # ---------------------------------------------------------------------------
  fluent-bit.conf: |
    [SERVICE]
        Daemon              Off
        Flush               1
        Log_Level           info
        # 加载标准解析器和自定义解析器
        Parsers_File        /fluent-bit/etc/conf/parsers.conf
        Parsers_File        /fluent-bit/etc/conf/custom_parsers.conf
        Parsers_File        /fluent-bit/etc/conf/multiline_parsers.conf
        
        # 开启内置 HTTP 服务器，用于健康检查和指标暴露 (/api/v1/metrics)
        HTTP_Server         On
        HTTP_Listen         0.0.0.0
        HTTP_Port           2020
        Health_Check        On

        # 文件系统缓冲配置 (防止后端不可用时丢失数据)
        storage.path              /var/log/flb_storage
        storage.sync              normal
        storage.checksum          off
        storage.backlog.mem_limit 200M

    # -----------------------------------------------------------------------
    # [INPUT] 尾随文件采集
    # 采集 Docker/Containerd 生成的标准容器日志
    # -----------------------------------------------------------------------
    [INPUT]
        Name                tail
        Path                /var/log/containers/*.log
        # 启用内置的多行解析 (docker, cri 格式)
        multiline.parser    docker, cri
        Tag                 kube.*
        Mem_Buf_Limit       500MB
        Skip_Long_Lines     On
        Refresh_Interval    10
        # 持久化偏移量数据库，重启后从断点继续读取
        DB                  /var/log/flb_kube.db
        DB.Sync             Normal
        Rotate_Wait         30
        Read_from_Head      Off

    # -----------------------------------------------------------------------
    # [FILTER] 阶段 1: 多行合并
    # 在获取 K8s 元数据之前先合并多行日志，确保堆栈跟踪作为单条记录处理
    # -----------------------------------------------------------------------
    [FILTER]
        Name                multiline
        Match               kube.*
        multiline.key_content log
        multiline.parser    java_md_multiline

    # -----------------------------------------------------------------------
    # [FILTER] 阶段 2: K8s 元数据增强
    # 调用 K8s API 获取 Pod 详细信息 (Namespace, Pod Name, Labels 等)
    # -----------------------------------------------------------------------
    [FILTER]
        Name                kubernetes
        Match               kube.*
        Merge_Log           Off       # 不尝试解析 log 字段为 JSON (避免性能开销或错误)
        Keep_Log            On        # 保留原始 log 字段
        K8S-Logging.Parser  On        # 允许 Pod Annotation 指定 parser
        K8S-Logging.Exclude Off       # 不排除带有特定 annotation 的日志

    # -----------------------------------------------------------------------
    # [FILTER] 阶段 3: 日志内容解析
    # 使用自定义解析器提取 'level' 字段
    # -----------------------------------------------------------------------
    [FILTER]
        Name                parser
        Match               kube.*
        Key_Name            log
        Parser              java_log_level
        Reserve_Data        On        # 保留原始数据
        Preserve_Key        On        # 保留原始 log 键

    # -----------------------------------------------------------------------
    # [FILTER] 阶段 4: 字段初步清洗
    # 复制提取的 level 字段，移除不需要的临时字段
    # -----------------------------------------------------------------------
    [FILTER]
        Name                modify
        Match               kube.*
        Copy                level level
        Remove              _p
        Remove              stream
        Remove              time

    # -----------------------------------------------------------------------
    # [FILTER] 阶段 5: 结构重组 (Nest Lift)
    # 将 kubernetes 对象下的字段提升到顶层，并添加前缀 'k8s_'
    # 目的：扁平化数据结构，便于后续规则匹配
    # -----------------------------------------------------------------------
    [FILTER]
        Name                nest
        Match               kube.*
        Operation           lift
        Nested_under        kubernetes
        Add_prefix          k8s_

    # -----------------------------------------------------------------------
    # [FILTER] 阶段 6: 移除冗余元数据
    # 删除不需要发送到后端的庞大字段 (如 annotations, docker_id)
    # -----------------------------------------------------------------------
    [FILTER]
        Name                modify
        Match               kube.*
        Remove              k8s_annotations
        Remove              k8s_docker_id
        Remove              k8s_container_hash

    # -----------------------------------------------------------------------
    # [FILTER] 阶段 7: 结构重组 (Nest Nest)
    # 将所有 'k8s_' 前缀的字段重新打包回 'kubernetes' 对象下，去除前缀
    # 目的：恢复整洁的嵌套结构，同时已清理了无用字段
    # -----------------------------------------------------------------------
    [FILTER]
        Name                nest
        Match               kube.*
        Operation           nest
        Wildcard            k8s_*
        Nested_under        kubernetes
        Remove_prefix       k8s_

    # =======================================================================
    # [FILTER] 阶段 8: 动态路由 (Rewrite Tag) - 第一跳：按环境分流
    # 根据 Namespace 名称修改 Tag，将日志引导至不同的处理流
    # 语法: Rule $字段名 正则表达式 新Tag 保持原记录(布尔)
    # =======================================================================
    
    # 路由：uganda-uat 环境
    [FILTER]
        Name                rewrite_tag
        Match               kube.*
        Rule                $kubernetes['namespace_name'] ^uganda-uat$ uganda-uat.temp false
        Emitter_Name        re_emitted_uganda-uat-temp

    # 路由：uganda-test 环境
    [FILTER]
        Name                rewrite_tag
        Match               kube.*
        Rule                $kubernetes['namespace_name'] ^uganda-test$ uganda-test.temp false
        Emitter_Name        re_emitted_uganda-test-temp

    # 路由：uganda-prod 环境 (当前部署命名空间)
    [FILTER]
        Name                rewrite_tag
        Match               kube.*
        Rule                $kubernetes['namespace_name'] ^uganda-prod$ uganda-prod.temp false
        Emitter_Name        re_emitted_uganda-prod-temp

    # 路由：uganda-offline 环境
    [FILTER]
        Name                rewrite_tag
        Match               kube.*
        Rule                $kubernetes['namespace_name'] ^uganda-offline$ uganda-offline.temp false
        Emitter_Name        re_emitted_uganda-offline-temp

    # =======================================================================
    # [FILTER] 阶段 9: 动态路由 (Rewrite Tag) - 第二跳：按服务分流
    # 针对特定环境的特定容器进行二次分流，实现细粒度索引隔离
    # =======================================================================

    # 示例：UAT 环境 -> lms-backend 服务
    [FILTER]
        Name                rewrite_tag
        Match               uganda-uat.temp
        Rule                $kubernetes['container_name'] ^lms-backend$ uganda-uat-lms-backend false
        Emitter_Name        re_emitted_uganda-uat-lms-backend

    # 示例：UAT 环境 -> other-service 服务 (需补充完整配置)
    [FILTER]
        Name                rewrite_tag
        Match               uganda-uat.temp
        Rule                $kubernetes['container_name'] ^other-service$ uganda-uat-other-service false
        Emitter_Name        re_emitted_uganda-uat-other-service

    # 注意：Production 和其他环境需要类似地添加对应的容器名过滤规则
    # 例如：
    # [FILTER]
    #     Name rewrite_tag
    #     Match uganda-prod.temp
    #     Rule $kubernetes['container_name'] ^payment-service$ uganda-prod-payment-service false
    #     Emitter_Name re_emitted_uganda-prod-payment-service

    # =======================================================================
    # [OUTPUT] 输出插件配置
    # 将经过路由筛选的日志发送到 OpenObserve
    # =======================================================================

    # 输出：UAT LMS Backend
    [OUTPUT]
        Name                http
        Match               uganda-uat-lms-backend
        URI                 /api/39NVPcXSEBOwGM5UnceQ35hQFNB/lms_backend/_json
        Host                openobserve.uganda-uat.svc.cluster.local
        Port                5080
        tls                 Off
        Format              json
        Json_date_key       _timestamp
        Json_date_format    iso8601
        
        HTTP_User           ops@test.com
        HTTP_Passwd         ROPe50N4BJjovJiT 
        
        compress            gzip
        Retry_Limit         False       # 无限重试直到成功
        net.connect_timeout 10
        net.io_timeout      30

    # 输出：UAT Other Service (示例)
    [OUTPUT]
        Name                http
        Match               uganda-uat-other-service
        URI                 /api/39NVPcXSEBOwGM5UnceQ35hQFNB/other_service/_json
        Host                openobserve.uganda-uat.svc.cluster.local
        Port                5080
        tls                 Off
        Format              json
        Json_date_key       _timestamp
        Json_date_format    iso8601
        HTTP_User           devops@test.com
        HTTP_Passwd         ROPe50N4BJjovJiT
        compress            gzip
        Retry_Limit         False

    # 默认输出 (可选): 捕获未匹配任何特定规则的日志，防止数据丢失
    # [OUTPUT]
    #     Name http
    #     Match uganda-prod.temp
    #     URI /api/.../default/_json
    #     ...

配置说明

Filter 阶段: 使用 rewrite_tag 过滤器按 Namespace 和容器名称过滤日志
Output 阶段: 将过滤后的日志通过 HTTP 发送到不同环境下的OpenObserve
多行日志: 使用 multiline 过滤器处理 Java 异常堆栈
日志优化: gzip 压缩、失败重试、TCP 超时配置

多行合并规则说明

状态	匹配规则	说明
start_state	`/^\d{4}-\d{2}-\d{2}/`	以日期开头 → 新日志开始，进入 cont 状态
cont	`/^(?!\d{4}-\d{2}-\d{2}).+/`	不以日期开头 → 继续拼接到上一条日志

注意: 修改完 ConfigMap 后需要重启 fluent-bit 服务

数据管理

创建数据流

# 方法1：通过API创建
curl -X POST "https://logs.example.com/api/demo/streams" \
  -u "admin@example.com:password" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "app-logs",
    "storage_type": "memory",
    "stream_type": "logs"
  }'

# 方法2：自动创建（首次写入自动创建,我们这里采用这种方式）
# Fluent Bit写入新stream会自动创建

设置数据保留策略

openobserve的dashboard里可以基于索引设置保留策略,主要策略如下:

基于时间保留
基于大小保留
混合策略（3650天或30TB，先到为准，这里我们采用这种方式，由于业务为金融服务，故设置保留10年）

数据归档配置

# 启用S3归档
env:
  - name: ZO_S3_STORE_ENABLED
    value: "true"
  - name: ZO_S3_STORE_BUCKET
    value: "logs-archive"
  - name: ZO_S3_STORE_REGION
    value: "us-east-1"
  - name: ZO_S3_STORE_ACCESS_KEY
    valueFrom:
      secretKeyRef:
        name: s3-credentials
        key: access-key
  - name: ZO_S3_STORE_SECRET_KEY
    valueFrom:
      secretKeyRef:
        name: s3-credentials
        key: secret-key

数据压缩

# OpenObserve自动压缩
env:
  - name: ZO_COMPRESSION_ENABLED
    value: "true"
  - name: ZO_COMPRESSION_FORMAT
    value: "zstd"  # zstd/gzip/snappy
  - name: ZO_COMPRESSION_LEVEL
    value: "3"  # 1-19，越高压缩率越高但CPU消耗越大

查询与分析

OpenObserve 提供强大的查询引擎，支持 SQL 模式和原生查询语言 (VQL)。以下介绍基本查询和聚合查询在不同场景下使用，帮助您快速定位关键日志。

💡 核心提示

模式切换：聚合查询建议在 SQL 模式 下执行。

表名规范：Stream 名称（表名）必须用双引号包裹，例如 "lms"。

时间范围：所有查询均受 UI 右上角时间选择器的限制，请确保时间范围覆盖目标数据。

1. 基础检索 (Basic Search)

快速定位单条日志或特定事件。

1.1 全文索引搜索

自动扫描所有文本字段，适合模糊查找。

`1`	`match_all('timeout')`

场景：不确定错误出现在哪个字段，快速全局搜索关键词。

1.2 指定字段搜索

针对特定字段进行精确或包含匹配，性能更优。

`1`	`str_match(log, 'tenant-backend')`

场景：筛选特定服务（如 tenant-backend）或特定级别（str_match(level, 'ERROR')）的日志。

1.3 多条件组合查询

使用逻辑运算符 (AND, OR, NOT) 构建复杂过滤规则。

1
2

(level = 'INFO' OR level = 'ERROR') 
AND str_match(log, 'AuthInterceptor')

场景：只看认证模块的日志，且包含正常流程和报错流程。

2. 聚合查询 (Aggregation Queries) 🚀

通过 SQL 的 GROUP BY 和聚合函数 (COUNT, SUM, AVG, MAX, MIN)，将海量日志转化为统计图表数据。

2.1 按日志级别统计 (Count by Level)

统计不同日志级别的数量，快速判断系统健康度。

SELECT level, COUNT(*) as log_count 
FROM "lms" 
GROUP BY level 
ORDER BY log_count DESC

输出示例：

level log_count

INFO 15420

ERROR 32

WARN 105

level	log_count
INFO	15420
ERROR	32
WARN	105

2.2 按时间窗口趋势分析 (Time Series Histogram)

结合 date_trunc 函数，统计单位时间内的日志量，用于绘制趋势图。

SELECT date_trunc('minute', _timestamp) as time_window, COUNT(*) as hits
FROM "lms"
WHERE str_match(log, 'payment')
GROUP BY time_window
ORDER BY time_window ASC

场景：观察“支付”相关日志在每分钟内的波动情况，定位突发流量或故障时间点。
注意：'minute' 可替换为 'hour', 'day' 等。

2.3 按服务/容器分组统计 (Group by Service)

分析哪个微服务产生的日志最多或错误最多。

SELECT kubernetes.container_name, COUNT(*) as total_logs
FROM "lms"
WHERE level = 'ERROR'
GROUP BY kubernetes.container_name
ORDER BY total_logs DESC
LIMIT 5

场景：找出当前产生错误最多的前 5 个容器，优先排查。

2.4 多维度交叉分析 (Multi-Dimension Analysis)

同时按两个或多个维度分组，进行深度下钻分析。

SELECT 
  date_trunc('hour', _timestamp) as hour,
  level,
  COUNT(*) as count
FROM "lms"
WHERE str_match(log, 'database')
GROUP BY hour, level
ORDER BY hour ASC, level

场景：查看每小时中，数据库相关日志的 INFO 和 ERROR 分布变化。

2.5 数值字段统计 (Numeric Aggregation)

如果日志中包含提取出的数值字段（如响应时间 duration），可进行数学计算。

SELECT 
  AVG(duration) as avg_latency,
  MAX(duration) as max_latency,
  MIN(duration) as min_latency
FROM "lms"
WHERE str_match(log, 'API_REQUEST')

场景：计算特定 API 请求的平均耗时、最大耗时，评估性能瓶颈。

3. 高级技巧与最佳实践

技巧	说明	示例
限制结果集	避免返回过多数据导致浏览器卡顿	添加 `LIMIT 100`
去重统计	统计唯一的错误消息种类	`COUNT(DISTINCT log)`
别名优化	让输出列名更易读	`COUNT(*) as "错误总数"`
空值处理	排除字段为空的记录	`WHERE level IS NOT NULL`
正则匹配	比 `str_match` 更灵活的匹配	`REGEXP_MATCH(log, 'Error.*\d+')`

⚠️ 性能建议

先过滤后聚合：务必在 WHERE 子句中尽可能缩小数据范围（如指定时间、关键字），再进行 GROUP BY，能显著提升查询速度。
时间粒度：在大时间范围（如 7 天）查询时，使用 date_trunc('hour', ...) 或 date_trunc('day', ...)，避免使用 'second' 导致数据点过多。
字段索引：对常用于 GROUP BY 的字段（如 level, container_name），建议在 Stream Settings 中开启索引以获得最佳性能。

OpenObserve优化

# 内存缓存
env:
  - name: ZO_MEMORY_CACHE_ENABLED
    value: "true"
  - name: ZO_MEMORY_CACHE_MAX_SIZE
    value: "8192"  # 8GB

# 查询缓存
  - name: ZO_QUERY_CACHE_ENABLED
    value: "true"
  - name: ZO_QUERY_CACHE_MAX_SIZE
    value: "4096"  # 4GB

# 并行查询
  - name: ZO_QUERY_WORKER_THREADS
    value: "8"

存储优化

# Parquet列式存储
env:
  - name: ZO_PARQUET_COMPRESSION
    value: "zstd"
  - name: ZO_PARQUET_ROW_GROUP_SIZE
    value: "1048576"  # 1MB

# 数据分区
  - name: ZO_PARTITION_ENABLED
    value: "true"
  - name: ZO_PARTITION_FIELDS
    value: "_timestamp,kubernetes.namespace_name"

监控告警

这里有两个部分需要做监控，一部分是Openobserve本身服务监控，一部分是业务日志监控,对于Openobseve和fluentbit服务本身的监控直接采用Prometheus监控即可,对于核心业务订单日志监控直接采用Openobserve自带告警机制即可满足。

Prometheus指标采集

# Fluent Bit ServiceMonitor
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: fluent-bit
  namespace: logging
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: fluent-bit
  endpoints:
    - port: metrics
      interval: 30s

# OpenObserve ServiceMonitor
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: openobserve
  namespace: logging
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: openobserve
  endpoints:
    - port: http
      path: /metrics
      interval: 30s

告警规则

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: logging-alerts
  namespace: logging
spec:
  groups:
    - name: logging
      rules:
        # Fluent Bit日志丢失告警
        - alert: FluentBitLogsDropping
          expr: rate(fluentbit_output_proc_records_failed_total[5m]) > 100
          for: 5m
          labels:
            severity: warning
          annotations:
            summary: "Fluent Bit日志丢失"
            description: "过去5分钟丢失{{ $value }}条日志"

        # OpenObserve存储告警
        - alert: OpenObserveDiskSpaceLow
          expr: (node_filesystem_avail_bytes{mountpoint="/data"} / node_filesystem_size_bytes{mountpoint="/data"}) < 0.1
          for: 10m
          labels:
            severity: critical
          annotations:
            summary: "OpenObserve存储空间不足"
            description: "剩余空间不足10%"

        # 日志摄入延迟
        - alert: LoggingIngestLag
          expr: openobserve_ingest_delay_seconds > 300
          for: 5m
          labels:
            severity: warning
          annotations:
            summary: "日志摄入延迟"
            description: "日志延迟{{ $value }}秒"

业务日志告警

涉及如下几个关键部分:

告警消息模版

设置–> 模版 –>添加模版，定义Webhook告警消息格式, 注意这里的消息需要根据不同的聊天工具

新建\:cdi-prod-template

    {
      "msgtype": "text",
      "text": {
        "content": "🚨 【告警通知】\n告警名称: {alert_name}\n流名称: {stream_name}\n严重程度: Error\n日志信息: {rows:1}\n触发时间: {alert_trigger_time_str}"
      }
    }

注意: 这里的消息需要根据不同的聊天工具配置有差异，我这里的配置是企业微信配置，更多请参考https://openobserve.ai/docs/user-guide/management/templates/ 这里配置自己适合的告警模版

告警地址

通过企业微信群组添加消息助手，获取推送消息Webhook地址,然后Openobserve UI 设置–> 地址 –>添加地址即可.

告警规则配置

这个需要根据内部研发团队沟通，业务日志匹配规则，日常告警只匹配Erorr级别即可，对于核心订单和风控流程建议添加上电话告警:

OpenObserve开源版风险与注意事项

RBAC权限控制

开源版限制：

无细粒度的RBAC控制（企业版支持）
所有用户拥有相同权限
无法按组织/项目隔离数据

解决方案：

# 1. 使用多租户（Stream级别隔离）
# 为每个团队创建独立的Stream
curl -X POST "https://logs.example.com/api/demo/streams" \
  -d '{"name":"team-a-logs"}'
curl -X POST "https://logs.example.com/api/demo/streams" \
  -d '{"name":"team-b-logs"}'

# 2. 使用反向代理做权限控制
# Nginx根据用户路由到不同Stream
location /api/team-a/ {
  internal;
  proxy_pass http://openobserve.logging.svc/api/team-a-logs/;
}

# 3. 使用API Key做简单鉴权
# 为每个团队生成独立的API Key

这里由于项目比较多，通常在反向代理添加权限控制规则，比如限制Post请求的IP、和Host

数据安全

风险点：

开源版无字段级加密
敏感信息可能明文存储
缺少审计日志

最佳实践：

# 1. Fluent Bit脱敏
[FILTER]
    Name                modify
    Match               kube.*
    Remove              password,token,secret,key,ssn
    Rename              message  log_message

# 2. 使用Lua过滤器脱敏
[FILTER]
    Name                lua
    Match               kube.*
    Script              mask.lua
    Call                mask_sensitive

# mask.lua:
function mask_sensitive(tag, timestamp, record)
    if record["message"] ~= nil then
        record["message"] = string.gsub(record["message"], "password=%S+", "password=***")
    end
    return 1, timestamp, record
end

高可用风险

单点故障：

开源版无自动故障转移
节点宕机可能导致数据丢失

解决方案：

# 1. 部署多副本
replicaCount: 3

# 2. 使用共享存储
persistence:
  enabled: true
  storageClass: "nfs-client"  # 使用分布式存储,我这里底层采用的Ceph的RBD

# 3. 配置Pod反亲和性
affinity:
  podAntiAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchExpressions:
            - key: app.kubernetes.io/name
              operator: In
              values:
                - openobserve
        topologyKey: kubernetes.io/hostname

容量规划

日志量	Fluent Bit资源	OpenObserve资源	存储空间/月
10GB/天	100m CPU / 100Mi	2 CPU / 4Gi	100GB
100GB/天	200m CPU / 200Mi	4 CPU / 8Gi	1TB
1TB/天	500m CPU / 500Mi	8 CPU / 16Gi	10TB

总结

基于OpenObserve和Fluent Bit的日志平台方案具有以下优势：

成本优势：相比ELK方案，存储成本降低90%，计算资源降低70%
高性能：单节点支持5TB+/天日志摄入，查询响应<100ms
简单易用：部署时间<30分钟，学习成本低
云原生：Kubernetes原生集成，支持自动扩缩容

已在生产环境稳定运行半年，数据量5TB+，查询响应稳定在200ms以内，基本满足了大部分业务需求，如果对RBAC有强需求的建议直接购买商业版或者放弃本方案。

Kustomize私有化部署多场景多环境容器服务

wzdushu@gmail.com (wanzi) — Sat, 25 Oct 2025 10:30:00 +0800

早期一直在使用helm或者kubectl原生yaml结合CI和ArgoCD部署应用，最近在给一个金融大客户部署私有化服务的时候，发现客户的环境比较复杂，涉及多个国家多套环境，比如Test、UAT、Prod，差不多有三十个环境，每次修改的values和yaml文件快吐了，这次打算用Kustomize来改造现有的部署应用试试。

Kustomize介绍

什么是Kustomize

Kustomize是Kubernetes原生的配置管理工具，通过模板化的方式管理YAML资源：

核心特性：

无模板语法，纯YAML
声明式配置管理
支持多环境管理
GitOps友好
已集成kubectl 1.14+

与Helm对比：

特性	Kustomize	Helm
模板语法	无（纯YAML）	Go Template
学习曲线	低	中高
多环境管理	Base + Overlay	Values文件
包管理	无	Chart Repository
版本管理	Git	Chart版本
适合场景	应用开发者	应用分发者

基本概念

kustomization.yaml
├── bases/          # 基础配置（复用）
├── overlays/       # 环境覆盖
│   ├── dev/
│   ├── staging/
│   └── prod/
├── patches/        # 配置补丁
└── resources/      # 静态资源

Kustomize与Helm区别

设计理念

Kustomize设计理念：

# 声明式配置管理
# 不使用模板，而是通过叠加（Overlay）方式修改配置

# Base: 基础配置
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 1
  template:
    spec:
      containers:
        - name: app
          image: my-app:latest

# Overlay: 环境差异
# overlays/production/kustomization.yaml
bases:
  - ../../base
patchesStrategicMerge:
  - |-
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-app
    spec:
      replicas: 10

Helm设计理念：

# 模板化配置管理
# 使用Go Template模板

# templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}
spec:
  replicas: {{ .Values.replicaCount }}
  template:
    spec:
      containers:
        - name: app
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"

# values.yaml (不同环境不同values)
replicaCount: 1
image:
  repository: my-app
  tag: latest

# values-production.yaml
replicaCount: 10
image:
  repository: my-app
  tag: v1.2.3

功能对比

功能	Kustomize	Helm
模板	无模板，纯YAML	Go Template
学习曲线	低，只需会YAML	中高，需学模板语法
复用性	Base + Overlay	Chart + Values
调试	kubectl kustomize	helm template –dry-run
版本管理	Git版本控制	Chart版本号
环境管理	Overlay目录	多个Values文件
包分发	无（用Git）	Chart仓库
CI/CD集成	原生kubectl	需安装helm
Rollback	kubectl rollout	helm rollback
依赖管理	无直接支持	Chart dependencies

适用场景

选择Kustomize的场景：

应用开发者管理自己的K8s资源
需要GitOps工作流
多环境配置差异大
不想学习模板语言
团队熟悉YAML和kubectl

选择Helm的场景：

应用分发者（软件供应商）
需要包管理和版本控制
配置相对固定
复杂的应用依赖关系
快速部署第三方应用

Kustomize部署K8s应用

项目结构

my-app/
├── base/                           # 基础配置
│   ├── deployment.yaml
│   ├── service.yaml
│   ├── configmap.yaml
│   ├── serviceaccount.yaml
│   └── kustomization.yaml
├── overlays/                       # 环境配置
│   ├── dev/
│   │   ├── kustomization.yaml
│   │   ├── deployment-replica.yaml
│   │   ├── deployment-resources.yaml
│   │   └── configmap-env.yaml
│   ├── staging/
│   │   ├── kustomization.yaml
│   │   └── deployment-replica.yaml
│   └── production/
│       ├── kustomization.yaml
│       ├── deployment-replica.yaml
│       ├── deployment-resources.yaml
│       └── configmap-prod.yaml
└── scripts/
    └── deploy.sh

Base配置创建

base/deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
    version: v1.0.0
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: my-app
        version: v1.0.0
    spec:
      serviceAccountName: my-app
      securityContext:
        runAsNonRoot: true
        runAsUser: 1000
        fsGroup: 1000
      containers:
        - name: my-app
          image: my-app:latest
          imagePullPolicy: IfNotPresent
          ports:
            - name: http
              containerPort: 8080
              protocol: TCP
          env:
            - name: JAVA_OPTS
              value: "-Xms512m -Xmx512m"
            - name: SPRING_PROFILES_ACTIVE
              value: "prod"
          resources:
            requests:
              cpu: 100m
              memory: 512Mi
            limits:
              cpu: 500m
              memory: 1Gi
          livenessProbe:
            httpGet:
              path: /actuator/health/liveness
              port: 8080
            initialDelaySeconds: 60
            periodSeconds: 10
            timeoutSeconds: 5
            failureThreshold: 3
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 5
            timeoutSeconds: 3
            failureThreshold: 3
          volumeMounts:
            - name: config
              mountPath: /config
            - name: logs
              mountPath: /logs
      volumes:
        - name: config
          configMap:
            name: my-app-config
        - name: logs
          emptyDir: {}

base/service.yaml

apiVersion: v1
kind: Service
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  type: ClusterIP
  ports:
    - port: 80
      targetPort: http
      protocol: TCP
      name: http
  selector:
    app: my-app

base/configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-app-config
data:
  application.yml: |
    server:
      port: 8080
    spring:
      application:
        name: my-app
    logging:
      level:
        root: INFO

base/serviceaccount.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-app

base/kustomization.yaml

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

# 引用的资源文件
resources:
  - deployment.yaml
  - service.yaml
  - configmap.yaml
  - serviceaccount.yaml

# 通用标签（所有资源添加）
commonLabels:
  app.kubernetes.io/name: my-app
  app.kubernetes.io/instance: my-app
  app.kubernetes.io/managed-by: kustomize
  app.kubernetes.io/version: v1.0.0

# 通用注解
commonAnnotations:
  createdBy: kustomize
  env: base

# 名称前缀
# namePrefix: dev-

# 名称后缀
# nameSuffix: -v1

Overlay环境配置

overlays/production/kustomization.yaml

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

# 引用base
namespace: production
bases:
  - ../../base

# 副本数覆盖
replicas:
  - name: my-app
    count: 10

# 镜像覆盖
images:
  - name: my-app
    newName: harbor.example.com/prod/my-app
    newTag: v1.2.3

# ConfigMap生成器
configMapGenerator:
  - name: my-app-config
    behavior: replace
    files:
      - application.yml=application-production.yml

# Secret生成器
secretGenerator:
  - name: my-app-secret
    behavior: create
    envs:
      - .env.production

# 资源补丁
patchesStrategicMerge:
  - deployment-resources.yaml
  - deployment-probes.yaml
  - pvc.yaml

# 命名空间
namespace: production

# 通用标签覆盖
commonLabels:
  environment: production
  tier: backend

# 通用注解覆盖
commonAnnotations:
  env: production
  prometheus.io/scrape: "true"
  prometheus.io/port: "8080"

overlays/production/deployment-resources.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  template:
    spec:
      containers:
        - name: my-app
          resources:
            requests:
              cpu: 500m
              memory: 1Gi
            limits:
              cpu: 2000m
              memory: 4Gi

overlays/production/pvc.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-app-logs
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: fast-ssd
  resources:
    requests:
      storage: 50Gi

overlays/production/application-production.yml

server:
  port: 8080

spring:
  application:
    name: my-app
  datasource:
    url: jdbc:mysql://mysql-prod.svc:3306/mydb
    username: prod_user
    password: ${DB_PASSWORD}

logging:
  level:
    root: INFO
    com.example: DEBUG
  file:
    path: /logs

overlays/production/.env.production

1
2
3

DB_PASSWORD=prod_secure_password_123
API_KEY=prod_api_key_xyz
REDIS_PASSWORD=prod_redis_pass

部署命令

# 构建配置（不应用，查看最终YAML）
kubectl kustomize overlays/production

# 保存渲染结果
kubectl kustomize overlays/production > rendered-prod.yaml

# 查看差异
kubectl diff -k overlays/production

# 直接应用
kubectl apply -k overlays/production

# 删除资源
kubectl delete -k overlays/production

# 查看资源
kubectl get all -l app.kubernetes.io/name=my-app -n production

统一部署管理配置

1. Namespace管理

方式一：在Overlay中指定

1
2

# overlays/production/kustomization.yaml
namespace: production

方式二：作为资源管理

# overlays/production/kustomization.yaml
resources:
  - ../../base
  - namespace.yaml

# overlays/production/namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    environment: production
    name: production

2. Secret管理

方案一：环境变量文件

# overlays/production/kustomization.yaml
secretGenerator:
  - name: my-app-secret
    type: Opaque
    envs:
      - .env.production

方案二：字面值

secretGenerator:
  - name: my-app-secret
    type: Opaque
    literals:
      - DB_PASSWORD=prod123
      - API_KEY=xyz789

方案三：命令生成

secretGenerator:
  - name: tls-cert
    type: kubernetes.io/tls
    files:
      - tls.crt=tls.crt
      - tls.key=tls.key

方案四：从现有Secret引用

# overlays/production/kustomization.yaml
generatorOptions:
  disableNameSuffixHash: true

resources:
  - secret.yaml

# overlays/production/secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: my-app-secret
type: Opaque
stringData:
  DB_PASSWORD: prod123

方案五：Sealed Secrets（推荐生产使用）

# 本地生成sealed secret
kubeseal -f secret.yaml -w sealed-secret.yaml

# 在kustomization中引用
resources:
  - sealed-secret.yaml

3. PVC管理

# overlays/production/kustomization.yaml
resources:
  - ../../base
  - pvc-logs.yaml
  - pvc-data.yaml

# overlays/production/pvc-logs.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-app-logs
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: fast-ssd  # 使用SSD存储类
  resources:
    requests:
      storage: 50Gi

# overlays/production/pvc-data.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-app-data
spec:
  accessModes:
    - ReadWriteMany  # 多节点共享
  storageClassName: nfs-storage
  resources:
    requests:
      storage: 100Gi

4. 镜像版本管理

方式一：直接指定

images:
  - name: my-app
    newName: harbor.example.com/prod/my-app
    newTag: v1.2.3

方式二：使用SHA256

images:
  - name: my-app
    newName: harbor.example.com/prod/my-app
    digest: sha256:abc123def456...  # 最安全的方式

方式三：多个镜像

images:
  - name: nginx
    newName: harbor.example.com/library/nginx
    newTag: 1.21-alpine
  - name: redis
    newName: harbor.example.com/library/redis
    newTag: 6.2-alpine
  - name: my-app
    newName: harbor.example.com/prod/my-app
    newTag: v1.2.3

方式四：CI/CD动态更新

# 在CI Pipeline中
export IMAGE_TAG=$(git rev-parse --short HEAD)
cd overlays/production
kustomize edit set image my-app=harbor.example.com/prod/my-app:$IMAGE_TAG
kubectl apply -k .

5. 节点亲和性配置

# overlays/production/deployment-affinity.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  template:
    spec:
      affinity:
        # 节点亲和性
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: node.kubernetes.io/instance-type
                    operator: In
                    values:
                      - c5.2xlarge
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
              preference:
                matchExpressions:
                  - key: topology.kubernetes.io/zone
                    operator: In
                    values:
                      - us-west-1a
        # Pod亲和性
        podAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
              podAffinityTerm:
                labelSelector:
                  matchExpressions:
                    - key: app
                      operator: In
                      values:
                        - mysql
                topologyKey: kubernetes.io/hostname

在kustomization中引用：

1
2

patchesStrategicMerge:
  - deployment-affinity.yaml

6. 污点和容忍配置

# overlays/production/deployment-taints.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  template:
    spec:
      # 容忍专用节点污点
      tolerations:
        - key: workload
          operator: Equal
          value: dedicated
          effect: NoSchedule
        - key: node.kubernetes.io/not-ready
          operator: Exists
          effect: NoExecute
          tolerationSeconds: 300
        # 容许GPU节点
        - key: nvidia.com/gpu
          operator: Exists
          effect: NoSchedule

7. 副本数量管理

# 方式一：replicas字段（推荐）
replicas:
  - name: my-app
    count: 10
  - name: my-app-sidecar
    count: 2

# 方式二：Patch方式
# overlays/production/deployment-replica.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 10

8. ConfigMap管理

# 方式一：configMapGenerator（推荐）
configMapGenerator:
  # 从文件生成
  - name: my-app-config
    behavior: replace
    files:
      - application.yml=application-production.yml
      - logback.xml=logback-production.xml

  # 从字面值生成
  - name: my-app-env
    behavior: create
    literals:
      - SPRING_PROFILES_ACTIVE=production
      - LOG_LEVEL=INFO
      - JAVA_OPTS=-Xms2g -Xmx4g

  # 从env文件生成
  - name: my-app-file-env
    behavior: create
    envs:
      - .env.production

# 方式二：直接引用资源
resources:
  - configmap.yaml

完整生产环境示例

overlays/production/kustomization.yaml

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

# 命名空间
namespace: production

# 引用base
bases:
  - ../../base

# 额外资源
resources:
  - namespace.yaml
  - pvc-logs.yaml
  - pvc-data.yaml
  - hpa.yaml
  - service-monitor.yaml
  - network-policy.yaml

# 副本数
replicas:
  - name: my-app
    count: 10

# 镜像版本
images:
  - name: my-app
    newName: harbor.example.com/prod/my-app
    newTag: v1.2.3

# ConfigMap
configMapGenerator:
  - name: my-app-config
    behavior: replace
    files:
      - application.yml=config/application-production.yml
  - name: my-app-env
    behavior: merge
    literals:
      - ENV=production
      - LOG_LEVEL=INFO

# Secret
secretGenerator:
  - name: my-app-secret
    behavior: create
    envs:
      - .env.production

# Patch
patchesStrategicMerge:
  - deployment-resources.yaml
  - deployment-affinity.yaml
  - deployment-taints.yaml
  - deployment-probes.yaml

# 通用标签
commonLabels:
  environment: production
  tier: backend
  team: platform

# 通用注解
commonAnnotations:
  env: production
  prometheus.io/scrape: "true"
  prometheus.io/port: "8080"

CI/CD集成

GitLab CI示例

# .gitlab-ci.yml
stages:
  - build
  - deploy

variables:
  REGISTRY: harbor.example.com
  APP_NAME: my-app

build:
  stage: build
  image: docker:24
  services:
    - docker:24-dind
  script:
    - docker build -t $REGISTRY/$APP_NAME:$CI_COMMIT_SHA .
    - docker push $REGISTRY/$APP_NAME:$CI_COMMIT_SHA
  only:
    - main
    - develop

deploy:dev:
  stage: deploy
  image: bitnami/kubectl:latest
  environment:
    name: dev
  script:
    - cd overlays/dev
    - kustomize edit set image $REGISTRY/$APP_NAME=$REGISTRY/$APP_NAME:$CI_COMMIT_SHA
    - kubectl apply -k .
    - kubectl rollout status deployment/my-app -n dev
  only:
    - develop

deploy:prod:
  stage: deploy
  image: bitnami/kubectl:latest
  environment:
    name: production
  script:
    - cd overlays/production
    - kustomize edit set image $REGISTRY/$APP_NAME=$REGISTRY/$APP_NAME:$CI_COMMIT_SHA
    - kubectl apply -k .
    - kubectl rollout status deployment/my-app -n production
  when: manual
  only:
    - main

ArgoCD集成

# argocd/application.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-production
  namespace: argocd
spec:
  project: production
  source:
    repoURL: https://github.com/example/k8s-manifests.git
    targetRevision: main
    path: overlays/production
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true

总结

Kustomize最佳实践

目录结构规范
- base存放通用配置
- overlays管理环境差异
- 清晰的命名约定
版本管理
- 使用Git管理所有配置
- 镜像使用SHA256或明确的tag
- 不要使用latest
Secret管理
- 生产环境使用Sealed Secrets
- 不要将敏感信息提交到Git
- 使用External Secrets Operator集成Vault
组件复用
- 抽取通用配置为组件
- 建立Kustomize组件库
- 避免重复配置
CI/CD集成
- 自动化镜像tag更新
- 使用kubectl diff预览变更
- 配置验证通过后再应用

Kustomize vs Helm选择

场景	推荐方案	原因
微服务配置管理	Kustomize	灵活性高，Git友好
第三方应用部署	Helm	生态丰富，一键部署
复杂模板需求	Helm	Go Template功能强大
简单配置	Kustomize	无需学习模板
GitOps	Kustomize	天然支持

学习路径

基础语法：base + overlay结构
Patch策略：StrategicMerge vs JSON6902
组件复用：提取通用配置
CI/CD集成：自动化部署流程
GitOps实践：与ArgoCD/Flux结合

Kustomize是云原生时代配置管理的理想工具，掌握它能显著提升Kubernetes应用管理效率，在实际部署场景下，对于新项目不同环境差异化很小，可以结合VibeCoding工具生成一键部署脚本，快速交付新环境。

Azure云AKS集群调用Blob几种方式

wzdushu@gmail.com (wanzi) — Fri, 30 May 2025 21:22:42 +0800

在使用Azure云过程中，经常会用到Blob存储，这里记录一下，再业务使用过程中常用的几种场景：

一、通过Microsoft Entra ID应用程序账户访问Blob

优点：

可用于非 Azure 环境（如本地服务器、AWS EC2）
支持跨订阅、跨租户访问

缺点：

密钥必须安全存储（如 Key Vault）
密钥到期需手动轮换，否则应用中断
存在凭据泄露风险（尤其在 CI/CD 中硬编码）

具体配置如下：

1、配置应用程序专用账户

在Entra ID中注册应用，创建服务主体，生成客户端密钥或证书，将应用分配到Storage Blob Data Contributor角色(读写)，同时记录如下信息：

Tenant ID（租户 ID）
Client ID（客户端 ID）
客户端密钥（Client secrets），有过期时间，到期后需要手动更新。

2、赋予账户Azure Blob存储权限

(1)在Azure门户，转到存储账户（StorageAccount），选择你的存储账户（mdblob001）；

(2)在左侧菜单，选择访问控制（IAM）（Access Control），点击 + 添加（Add）→添加角色分配（Add role assignment）；选择角色：Storage Blob Data Contributor（允许读取 & 写入 Blob）；

(3)分配访问权限给：用户、组或服务主体（User, group, or service principal），选择成员：搜索你的应用名称（MyBlobApp），点击选择（Select），点击下一步 → 分配。

3、客户端调用Blob

应用代码中使用ClientSecretCredential或ClientCertificateCredential获取令牌访问Blob，这里拿Python SDK举例：

需要提前安装:

`1`	`pip install azure-identity azure-storage-blob`

from azure.identity import ClientSecretCredential
from azure.storage.blob import BlobServiceClient

# 配置 Entra ID 应用信息
TENANT_ID = "3c4e99f3-4831-4352-ae86-4d8f59512865"
CLIENT_ID = "3357a2b1-9895-484d-8754-42c162f2c9eb"      # 应用程序（客户端）ID
CLIENT_SECRET = "DoB8Q~4Gwl6sdzV_ocfUvXA3BtHYJLgrimwwMcj1"

# 存储账户和本地文件
ACCOUNT_NAME = "mdblob001"
LOCAL_FILE_PATH = "/mnt/d/file.txt"
BLOB_NAME = "uploaded-file.txt"          # 上传后在 Blob 中的名称

# 获取 Token 凭据
credential = ClientSecretCredential(
    tenant_id=TENANT_ID,
    client_id=CLIENT_ID,
    client_secret=CLIENT_SECRET
)

# 创建 Blob 客户端
blob_service_client = BlobServiceClient(
    account_url=f"https://{ACCOUNT_NAME}.blob.core.windows.net",
    credential=credential
)

# 列出容器（测试权限）
try:
    containers = blob_service_client.list_containers()
    for container in containers:
        print("Container:", container.name)
except Exception as e:
    print("Error:", e)

# === 上传文件 ===
try:
    blob_client = blob_service_client.get_blob_client(
        container=CONTAINER_NAME,
        blob=BLOB_NAME
    )

    with open(LOCAL_FILE_PATH, "rb") as data:
        blob_client.upload_blob(data, overwrite=True)  # overwrite=True 允许覆盖

    print(f"✅ 文件 '{LOCAL_FILE_PATH}' 已成功上传为 '{BLOB_NAME}'")

except FileNotFoundError:
    print("❌ 本地文件未找到")
except Exception as e:
    print("❌ 上传失败:", e)

二、通过AKS-系统托管标识访问Blob

系统托管标识（System-assigned Managed Identity）是Azure 提供的一种自动管理的服务主体（Service Principal），可为支持的 Azure 资源（如 VM、AKS、App Service 等）提供安全的身份认证能力，AKS默认已经启用。

优点：

自动管理生命周期，随着AKS集群创建、销毁等
无需管理凭证，完全无秘钥访问
更高安全，凭据不会暴露在代码、配置文件或环境变量中
可以和Azure的RBAC深度集成
开发SDK只需配置DefaultAzureCredential即可自动获取令牌

缺点:

不能跨资源复用，比如如多个workload使用不同权限，无法细化
标识自动管理，但是RBAC需要手动配置
无法跨云进行标记
无法自定义命名

1、AKS集群启用系统分配的托管标识：

az aks create --resource-group test --name md-test-southafrica --generate-ssh-keys #仅针对新集群启动系统托管标识
az aks update --resource-group test --name md-test-southafrica --enable-managed-identity # 针对已经存在集群
az aks show --resource-group test -n md-test-southafrica --query "identity" # 查看系统托管标识
{
"delegatedResources": null,
"principalId": "37e6bf32-b18d-4e3a-9f97-b86d0c9dc2cf",
"tenantId": "3c4e99f3-4831-4352-ae86-4d8f59512865",
"type": "SystemAssigned",
"userAssignedIdentities": null
}

2、为托管标识分配 Blob Storage 角色

可选角色：

Storage Blob Data Reader：只读
Storage Blob Data Contributor：读写
Storage Blob Data Owner：读写 + ACL 管理（用于 ADLS Gen2）

使用 Azure CLI 为该标识授予对 Blob Storage 的访问权限（例如 Storage Blob Data Contributor）：

# 获取存储账户 ID
STORAGE_ACCOUNT_ID=$(az storage account show -n mdblob001 -g test --query id -o tsv)
echo $STORAGE_ACCOUNT_ID
/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourceGroups/Test/providers/Microsoft.Storage/storageAccounts/mdblob001
# 分配角色
AKS_PRINCIPAL_ID=$(az aks show --resource-group test --name md-test-southafrica --query "identity.principalId" --output tsv)
echo "AKS Principal ID: $AKS_PRINCIPAL_ID"
AKS Principal ID: 37e6bf32-b18d-4e3a-9f97-b86d0c9dc2cf
az role assignment create --assignee "37e6bf32-b18d-4e3a-9f97-b86d0c9dc2cf" --role "Storage Blob Data Contributor" --scope "/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourceGroups/Test/providers/Microsoft.Storage/storageAccounts/mdblob001" # 授权给AKS系统托管认证

{
"condition": null,
"conditionVersion": null,
"createdBy": "dc8278a7-78d6-4f6e-971c-8974d0ac4e2f",
"createdOn": "2025-02-19T04:31:42.582306+00:00",
"delegatedManagedIdentityResourceId": null,
"description": null,
"id": "/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourceGroups/Test/providers/Microsoft.Storage/storageAccounts/mdblob001/providers/Microsoft.Authorization/roleAssignments/81f9e7d1-b83c-4c4b-aab0-047fc4fb525f",
"name": "81f9e7d1-b83c-4c4b-aab0-047fc4fb525f",
"principalId": "37e6bf32-b18d-4e3a-9f97-b86d0c9dc2cf",
"principalName": "ad674b19-a3b1-47ed-9463-128289ae5e34",
"principalType": "ServicePrincipal",
"resourceGroup": "Test",
"roleDefinitionId": "/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/providers/Microsoft.Authorization/roleDefinitions/ba92f5b4-2d11-453d-a403-e96b0029c9fe",
"roleDefinitionName": "Storage Blob Data Contributor",
"scope": "/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourceGroups/Test/providers/Microsoft.Storage/storageAccounts/mdblob001",
"type": "Microsoft.Authorization/roleAssignments",
"updatedBy": "dc8278a7-78d6-4f6e-971c-8974d0ac4e2f",
"updatedOn": "2025-02-19T04:31:42.582306+00:00"
}
az role assignment list --scope "/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourceGroups/Test/providers/Microsoft.Storage/storageAccounts/mdblob001" --output table #列出存储账户下授权信息
Principal                             Role                           Scope
--------------------------------------------------------------------------------
ad674b19-a3b1-47ed-9463-128289ae5e34  Storage Blob Data Contributor  /subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourceGroups/Test/providers/Microsoft.Storage/storageAccounts/mdblob001

3、验证

使用python SDK构建容器，验证访问：

from azure.storage.blob import BlobServiceClient
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()
blob_service_client = BlobServiceClient(
    account_url="https://mdblob001.blob.core.windows.net",
    credential=credential
)

# 列出容器
containers = blob_service_client.list_containers()
for c in containers:
    print(c.name)

DefaultAzureCredential 会自动尝试多种身份验证方式，在 AKS 中会通过 IMDS（Instance Metadata Service）获取令牌，前提是 Pod 运行在启用了托管标识的节点上。

三、通过AKS-用户托管标识访问Blob

1、创建用户分配的托管标识：

az group create -n rg-aks-wi -l test # 创建资源组,已经已经存在请忽略
az identity create --name MD-Blob-Identity --resource-group test # 创建用户分配托管标识
{
  "clientId": "7d9b65f6-959d-4a74-ab3f-67d16adc8c37",
  "id": "/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourcegroups/test/providers/Microsoft.ManagedIdentity/userAssignedIdentities/MD-Blob-Identity",
  "location": "southafricanorth",
  "name": "MD-Blob-Identity",
  "principalId": "bdd58864-063f-451d-b352-2dded3582b36",
  "resourceGroup": "test",
  "systemData": null,
  "tags": {},
  "tenantId": "3c4e99f3-4831-4352-ae86-4d8f59512865",
  "type": "Microsoft.ManagedIdentity/userAssignedIdentities"
}
# 获取关键信息
export USER_ASSIGNED_CLIENT_ID="$(az identity show -g test -n MD-Blob-Identity --query clientId -o tsv)" 
export USER_ASSIGNED_PRINCIPAL_ID="$(az identity show -g test -n MD-Blob-Identity --query principalId -o tsv)"

2、为标识分配Blob Storage权限

STORAGE_ACCOUNT_ID=$(az storage account show -n mdblob001 -g test --query id -o tsv)
echo $STORAGE_ACCOUNT_ID
/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourceGroups/Test/providers/Microsoft.Storage/storageAccounts/mdblob001
az role assignment create \
  --role "Storage Blob Data Contributor" \
  --assignee $USER_ASSIGNED_PRINCIPAL_ID \
  --scope $STORAGE_ACCOUNT_ID

3、在 AKS 上启用 Workload Identity（如未启用）

Workload Identity基于OIDC，标准、安全、微软主推一种方式

# 启用 OIDC issuer（AKS 1.24+ 支持）
az aks update -g test -n md-test-southafrica --enable-oidc-issuer
# 获取 OIDC issuer URL
export AKS_OIDC_ISSUER=$(az aks show -g test -n md-test-southafrica --query "oidcIssuerProfile.issuerUrl" -o tsv)
echo $AKS_OIDC_ISSUER

4、将用户标识与 Kubernetes Service Account 联邦（Federate）

# 获取用户标识的 clientId
export USER_ASSIGNED_CLIENT_ID=$(az identity show -g test -n MD-Blob-Identity --query clientId -o tsv)
# 创建联邦凭据（允许 AKS 中的特定 ServiceAccount 使用此标识）
az identity federated-credential list --resource-group test --name md-test-southafrica
az identity federated-credential create --name my-fed-cred  \
--identity-name MD-Blob-Identity \
--resource-group test \
--issuer $AKS_OIDC_ISSUER  \
--subject system:serviceaccount:demo:md-blob-sa
--audience api://AzureADTokenExchange
{
"audiences": [
"api://AzureADTokenExchange"
],
"id": "/subscriptions/cdab1cd0-0556-41bc-8905-33ce907e818a/resourcegroups/test/providers/Microsoft.ManagedIdentity/userAssignedIdentities/MD-Blob-Identity/federatedIdentityCredentials/my-fed-cred",
"issuer": "https://oidc.prod-aks.azure.com/3c4e99f3-4831-4352-ae86-4d8f59512865/",
"name": "my-fed-cred",
"resourceGroup": "test",
"subject": "system:serviceaccount:demo:md-blob-sa",
"systemData": null,
"type": "Microsoft.ManagedIdentity/userAssignedIdentities/federatedIdentityCredentials"
}

subject 格式：system:serviceaccount::

5、在 Kubernetes 中创建 ServiceAccount 并部署应用

创建 ServiceAccount

# blob-sa.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: blob-access-sa
  namespace: demo
  annotations:
    azure.workload.identity/client-id: "${USER_ASSIGNED_CLIENT_ID}"

kubectl aply -f blob-sa.yaml

6、部署应用

这里以python为例：

# python-blob.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: blob-client
  namespace: demo
  labels:
    azure.workload.identity/use: "true"  # 必须添加此标签！
spec:
  serviceAccountName: blob-access-sa
  containers:
    - name: app
      image: python:3.11-slim
      command: ["sh", "-c"]
      args:
        - |
          pip install azure-identity azure-storage-blob && \
          python -c "
from azure.storage.blob import BlobServiceClient
from azure.identity import DefaultAzureCredential
import os

account = 'mdblob001'
url = f'https://mdblob001.blob.core.windows.net'
client = BlobServiceClient(account_url=url, credential=DefaultAzureCredential())
print('Containers:', [c.name for c in client.list_containers()])
"
      env:
        - name: AZURE_CLIENT_ID
          value: "${USER_ASSIGNED_CLIENT_ID}"  # 可选，但推荐显式指定
  restartPolicy: Never

部署应用

kubectl apply -f python-blob.yaml 
kubectl logs blob-client # 可以正常列出blob里容器，应用使用令牌访问 Blob Storage已经全程无密钥！

至此,Azure云下，三种访问Blob存储的方式实践完成。

Python脚本生成一个sitemap网站地图

wzdushu@gmail.com (wanzi) — Sun, 10 Mar 2024 10:22:42 +0800

最近在帮朋友研究一个CMS站群，发现CMS没有sitemap功能，服务器上已经安装了python3，所以只能临时用脚本生成一个，这里记录一下。

脚本内容：

#!/usr/bin/env python

import datetime
import mysql.connector
import xml.etree.cElementTree as ET
from lxml import etree

# 数据库连接参数
config = {
    'host': '10.80.0.3', # 例如：'192.168.1.100'
    'user': 'wnote_r',
    'password': 'Wnote#Pss2024',
    'database': 'wnote',
    'raise_on_warnings': True
}

#sitemap路径
sdir = '/opt/wwwroot/'

def mselect(site, n1, n2):
    # 连接数据库
    cnx = mysql.connector.connect(**config)
    cursor = cnx.cursor()

    # 获取文章ID
    article_ids = []
    tag_ids = []

    # 查询文章表中的所有记录
    query1 = "select id from article order by newstime desc  limit {};".format(n1)
    cursor.execute(query1)
    for row in cursor:
        article_ids.append(row[0])

    # 查询所有标签
    query2 = "select id from phome_ecms_book order by newstime desc limit {};".format(n2)
    cursor.execute(query2)
    for row in cursor:
        tag_ids.append(row[0])

    # 生成URL列表
    article_urls = [f"https://{site}/article/{id}.html" for id in article_ids]
    tag_urls = [f"https://{site}/tags/{id}.html" for id in tag_ids]

    # 合并URL列表
    urls = article_urls + tag_urls

    # 创建Sitemap的XML树结构
    root = ET.Element('urlset',
                  {'xmlns': 'http://www.sitemaps.org/schemas/sitemap/0.9',
                   'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
                   'xmlns:mobile': 'http://www.baidu.com/schemas/sitemap-mobile/1/',
                   'xsi:schemaLocation': 'http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd'})

    # 生成sitemap文件,构建URL元素
    for url in urls:
        s_url = ET.SubElement(root, 'url')
        s_loc = ET.SubElement(s_url, 'loc')
        s_loc.text = url
        s_lastmod = ET.SubElement(s_url, 'lastmod')
        s_lastmod.text = datetime.now().strftime('%Y-%m-%dT%H:%M:%S+08:00')
        s_changefreq = ET.SubElement(s_url, 'changefreq')
        s_changefreq.text = 'always'
        s_priority = ET.SubElement(s_url, 'priority')
        s_priority.text = '0.95'


    # 生成XML字符串
    sitemap_str = ET.tostring(root, encoding='unicode')

    # 保存到文件
    with open(spfile, "w", encoding="utf-8") as f:
        f.write(sitemap_str)

    # 关闭数据库连接
    cursor.close()
    cnx.close()

with open('sites.list', 'r')  as files:
    for tmp in files:
        site = tmp.strip().split()[0]
        spfile = sdir + site + '/' + tmp.strip().split()[1]
        n1 = tmp.strip().split()[2]
        n2 = tmp.strip().split()[3]
        print(site, spfile)
        mselect(site, n1, n2)

其中sites.list内容为：

1
2

www.xxxxx.com 100 120
www.xxxxx.com 200 300

总结

其实，Python脚本写起来比较便捷，如果对性能有要求的话，还是用Golang比较好一些。

Go学习笔记 - 指针详解

wzdushu@gmail.com (wanzi) — Mon, 22 May 2023 18:22:42 +0800

指针是什么？

在Go语言中，指针是一个变量，它存储了另一个变量的内存地址。因此，指针变量指向的是另一个变量的内存地址，而不是变量本身。

声明指针变量时，需要在变量名前加上 *，表示这是一个指针变量，例如：

`1`	`var p *int`

这表示声明了一个名为 p 的指向整型变量的指针。使用 & 运算符可以取得一个变量的地址，例如：

1
2

x := 10
p := &x

这表示取得变量 x 的地址，并将地址赋给指针变量 p。

使用指针访问变量时，需要使用 * 运算符，它表示解引用操作符，例如：

1
2
3

x := 10
p := &x
fmt.Println(*p)

这表示打印出指针变量 p 指向的变量的值，即变量 x 的值。

除了声明指针变量和获取变量的地址之外，还可以使用 new 函数来创建指针变量。例如，创建一个指向整型变量的指针：

`1`	`p := new(int)`

这将创建一个新的整型变量，并返回它的地址，然后将地址赋给指针变量 p。

指针还可以用于函数参数和返回值，以便在函数调用之间共享数据。

在使用指针时需要小心，因为如果指针指向一个无效的内存地址，程序可能会崩溃或产生不可预测的行为。因此，使用指针时需要确保指针指向的内存地址是有效的。

指针使用场景

通过指针函数传参

指针可以用于函数参数的传递，当一个函数需要修改实参的值时，可以将实参的地址作为形参传递给函数，通过操作指针来达到修改实参的值的目的。例如：

func modify(s *string) {
    *s = "hello, world"
}

func main() {
    s := "hello"
    modify(&s)
    fmt.Println(s) // 输出：hello, world
}

通过指针访问结构体字段

通过指针可以更方便地访问结构体中的字段，特别是当结构体很大时，传递指针比较传递整个结构体更高效。例如：

type Person struct {
    Name string
    Age  int
}

func main() {
    p := &Person{
        Name: "Alice",
        Age:  18,
    }
    p.Name = "Bob"
    fmt.Println(p) // 输出：&{Bob 18}
}

通过指针动态分配内存

通过指针可以在运行时动态地分配内存，比如使用 new() 函数创建一个新的变量并返回它的地址。例如：

func main() {
    p := new(int)
    *p = 42
    fmt.Println(*p) // 输出：42
}

传递变长参数

在Golang中，可以使用指针传递变长参数。这是因为在使用变长参数时，传递的是一个切片（slice），而切片本身就是指向一个数组的指针。这样的操作，可以避免拷贝大量的数据。

例如，考虑以下函数，它接受一个变长参数并将其打印出来：

func printArgs(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

现在，如果要将切片作为参数传递给另一个函数，可以使用指针：

func printArgsPtr(args *[]int) {
    for _, arg := range *args {
        fmt.Println(arg)
    }
}

func main() {
    args := []int{1, 2, 3}
    printArgsPtr(&args)
}

在这个示例中，我们定义了一个新函数printArgsPtr，它使用指针作为参数来接收切片。函数体内，我们使用*args来解引用指针，从而得到实际的切片，并遍历它以打印每个元素。在主函数中，我们创建了一个切片，并将其地址传递给printArgsPtr函数。

需要注意的是，在使用指针传递变长参数时，如果切片为空，则不能传递nil指针，而应该传递一个空的切片。这是因为在Golang中，使用空的切片和nil指针的含义不同,后面我会介绍。

除了上述几个方面，指针在一些特定的场景下也非常有用，比如在处理数据结构时，通过指针可以更高效地操作链表、树等数据结构。但需要注意，过度使用指针可能会导致代码难以维护，需要谨慎使用。

常见空数据类型

在 Go 语言中，有一些空数据类型，包括：

空指针（nil pointer）：指向一个不存在地址的指针，一般用 nil 表示。
空切片（nil slice）：长度为 0 的切片，一般用 nil 表示。
空字典（nil map）：长度为 0 的字典，一般用 nil 表示。
空接口（nil interface）：类型和值均为 nil 的接口，一般用 nil 表示。
空通道（nil channel）：没有分配存储空间的通道，一般用 nil 表示。

nil表示一个空指针，即指针变量未指向任何地址，可以表示指针、接口、map、通道和函数类型的零值，而不能用来表示其他类型的零值，如int、float、bool等

这些空数据类型的定义均为对应类型的零值，其中指针、切片、字典、接口和通道的零值都是 nil，表示这些类型的默认值为 nil，即没有指向任何实际数据的指针、切片、字典、接口和通道。因此在实际使用这些数据类型时，可以将其初始化为零值，也可以显式地赋值为 nil。

例如:

var s []int = nil // 定义一个空切片
var p *int = nil  // 定义一个空指针
var m map[string]int = nil //定义一个空字典
var i interface{} = nil //定义一个空接口
var c chan int = nil //定一个空通道

需要注意，如下几点:

nil不是关键字，而是预定义的标识符。在 Go 中，可以将 nil 赋给任何类型的指针、切片、字典、函数和通道等变量。
空切片和空字典在使用前需要初始化，否则会出现 panic 异常。
空通道需要使用 make 函数初始化后才能使用。
空指针可以直接使用，因为它的值为 nil。
空接口不需要初始化即可直接使用。因为空接口本质上就是一个类型为 interface{} 的变量，它可以接受任何类型的值，包括 nil。所以在使用空接口时，如果没有显式地赋值，它就是一个空接口，可以直接使用。

避免空指针异常

在使用指针类型的变量时，需要进行 nil 检查以避免出现空指针异常。

例如：

整型指针类型

1
2

var p *int
fmt.Println(p == nil) // 输出 true

代码中，p 是一个整型指针类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 p 是否为 nil 来检查它是否为空指针。

整型切片类型

1
2

var s []int
fmt.Println(s == nil) // 输出 true

代码中，s 是一个整型切片类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 s 是否为 nil 来检查它是否为空切片。

字典类型

1
2

var m map[string]int
fmt.Println(m == nil) // 输出 true

代码中，m 是一个字典类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 m 是否为 nil 来检查它是否为空字典。

函数类型

1
2

var f func(int) int
fmt.Println(f == nil) // 输出 true

代码中，f 是一个函数类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 f 是否为 nil 来检查它是否为空函数。

整型通道类型

1
2

var ch chan int
fmt.Println(ch == nil) // 输出 true

代码中，ch 是一个整型通道类型的变量，因为没有被初始化，它的值为 nil。可以通过比较 ch 是否为 nil 来检查它是否为空通道。

最后，特别注意，空数组、空切片和空 map是可以使用 len() 函数求长度，结果都为 0。但是，空指针、空接口、空通道是不能使用 len() 函数求长度，否则会引发运行时错误。

这是因为，在 Go 中，len()函数返回一个值的长度，这个长度是预先定义好的，通常是由编译器计算得出的。空切片、空数组和空字典等类型变量的长度为0，因为它们在内存中已经有了一块空间，所以可以使用len()函数获取它们的长度。

而对于空接口和空通道，它们是不存储数据的，所以它们的长度是没有意义的，因此在使用len()函数时会引发运行时错误。如果要判断它们是否为空，应该使用nil值进行判断。

Go学习笔记 - Go基础知识复习

wzdushu@gmail.com (wanzi) — Fri, 17 Mar 2023 18:22:42 +0800

一、基础知识

1、基本数据类型

值类型：

bool（长度1Byte或1个字节）
byte(1个字节，uint8别名)
rune（4个字节，int32别名，-231~231）
int(32 or 64，长度4或8字节)
int8（长度1字节）、int16（长度2字节）、int32（长度4字节）、int64（长度8字节）
uint(32 or 64，长度4或8字节)
uint8(长度1字节)、uint16(长度4字节)、uint32(长度4字节)、uint64(长度8字节)
float32(长度4字节)、float64(长度8字节)
string     //一串固定长度字符连接起来的序列，底层为byte数组
complex64、complex128（默认）//复数类型
array   //数组（固定长度）
struct  //结构体

引用类型（指针类型）：

1
2
3

slice  //序列数组，默认值nil
map //映射，默认值nil
chan // 管道，默认值nil

2、编码&&字符串

golang默认编码是UTF-8

Unicode：一种全球字符编码标准，可变长编码，实现方式有多种，其目的是为了统一所有文字编码，比如UTF-8、UTF-16等，长度范围为1-4字节，默认英文占1Byte，中文占2Byte；每个字符对应一个十六进制的数字，Unicode字符串长度使用utf8.RuneCountInString()函数获取。
UTF-8：是可变长度字符编码，也是Unicode实现方式之一，英文占1Byte，中文占3Byte，emoji占4Byte。

GO中字符有两种，一种byte，一种rune

byte：是uint8别名，常用来处理ASCII字符，表示ASCII码的一个字符串，[]byte(s)，将s转换为byte数组。
rune：是int32别名，等价于int32类型，通常用于表示一个unicode字符的码点（code point），可以处理一切字符，使用方法为[]rune(s)，将s转换为unicode数组

string：一串固定长度字符连接起来的序列，底层为byte数组，字符串是不可改变的，当字符串只有数字字母，可以转换为[]byte或者[]rune，当有汉字等多字节编码的就必须转换为[]rune，最通用的方法是转换为[]rune(s)

单引号：用来表示byte类型或rune类型，默认是rune类型，单引号里面内容为Ascii码字符，ASCII字符串长度使用len()函数获取；
双引号：表示可以解析字符串字面量，支持转义，但是不能用来引用多行；
反引号：用于创建原生的字符串字面量，不支持任何转义序列，支持多行，多用于书写多行消息、html、正则；

3、内置函数

append  // 用于追加元素到数组、切片中，返回修改后的数组和切片
close   // 主要用于关闭channel
delete // 从map中删除key对应value
panic  // 停止常规goroutine(panic或recover：用于错误处理)
recover // 允许程序定义goroutine的panic动作
real  // 返回complex的实部(complex、real、imag用来创建和操作复数)
imag // 返回complex的虚部
make // 用来分配内存，返回Type本身（只能用于slice、map、channel）
new // 用来分配内存，主要用于分配值类型，比如int、struct，返回指向type的指针。
cap // 用来返回某个类型最大容量，只能用于切片和map
copy // 用来复制连接slice，返回复制的数目
len // 获取长度，比如string、array、slice、map、channel
print、println  // 底层打印函数

二、常用占位符：

占位符     说明                           举例                   输出
%v      相应值的默认格式。            Printf("%v", people)   {zhangsan}，
%+v     打印结构体时，会添加字段名     Printf("%+v", people)  {Name:zhangsan}
%#v     相应值的Go语法表示            Printf("#v", people)   main.Human{Name:"zhangsan"}
%T      相应值的类型的Go语法表示       Printf("%T", people)   main.Human
%%      字面上的百分号，并非值的占位符  Printf("%%")            %
%t      布尔占位符  true 或 false。   Printf("%t", true)       true
%c      字符占位符，相应Unicode码点所表示的字符 Printf("%c", 0x4E2D)        中
%d      整形占位符，十进制表示               Printf("%d", 0x12)          18
%s      字符串占位符（string类型或[]byte)   Printf("%s", []byte("Go语言"))  Go语言
%p      指针占位符，十六进制表示，前缀 0x     Printf("%p", &people)             0x4f57f0

三、数组&&切片&&map

1、数组

var 数组变量名 [元素数量]类型数组长度必须是常量，一旦定义，长度不能变，数组中的元素是可以变化的

`1`	`var a[5]int`

声明一个长度为5，类型为int的数组

a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}
b := a[3:6]
// 8 8
fmt.Println(len(a), cap(a))                        
//值：[3 4 5]，长度：3, 容量：5
fmt.Printf("值：%d，长度：%d, 容量：%d", b, len(b), cap(b))

2、切片

拥有相同类型元素的可变序列，它是基于数组做的一层封装，非常灵活，支持自动扩容，切片是一个引用类型，内部包含地址、长度(len)、容量(cap)

语法：var 切片变量名 []类型

var a []string //声明一个长度为0，类型为字符串切片。
var a[]string{} //声明一个长度为0，类型为字符串，并初始化

var myslice = []string{"北京", "上海", "深圳"}

for i := 0; i < len(myslice); i++ {
   fmt.Println("for循环:", myslice[i])
}

3、map

一种无序，基于key/value的数据结构，go中map是一种引用类型，必须使用make初始化才能使用。

语法: map[keytype]valuetype

map默认初始值为nil，需要使用make()函数进行分配内存，其中cap表示map的容量，该参数虽然不是必须的，获取map容量不能用cap，cap返回的是数组切片分配的空间大小；获取map的容量，可以使用len函数。

userInfo := map[string]string{
   "username": "xiaoli",
   "password": "1234556",
}
for k, v := range userInfo {
   fmt.Println(k, v, len(userInfo))
}

四、指针：

go语言中引用数据类型不仅要声明它，还要为它分配内存，否则我们的值就没发存储；而对于值类型的声明就不用分配内存，因为他们已经默认分配好内存。

指针地址：&a
指针取值：*&a
指针类型：&a --> *int
&取值，*跟进地址取值

new：为类型申请一片内存空间，并返回指针。比如对结构体实例化，返回的是结构体的指针地址

make：只用于chan、map以及、slice的内存创建，而且它的返回类型就是这三个类型本身，而不是他们的指针类型。

五、结构体

go语言里没有类的概念，也没有支持类的继承等面向对象的概念；go语言中主要通过结构体内嵌再配合接口比面向对象具有更高的扩展性和灵活性。

1、结构体实例化方法：

直接赋值(var)、new、键值对实例化

package main

import "fmt"

// 定义一个结构体
type member struct {
	name string
	city string
	age  int
}

func main() {
	var p1 member //直接赋值实例化结构体
	p1.name = "小明"
	p1.city = "beijing"
	p1.age = 32

	var p2 = new(member) // new关键字实例化
	p2.name = "小李"
	p2.city = "shanghai"
	p2.age = 20

	p3 := &member{
		name: "小张",
		city: "shenzhen",
		age:  18,
	} // 键值对实例化
	fmt.Printf("p1=%v \n", p1) // 输出值
	fmt.Printf("p1=%+v \n", p1) //输出结构体，并添加字段名称
	fmt.Printf("p2=%#v \n", p2) // 输出结构体字段并返回语法表示
	fmt.Printf("p3=%#v \n", p3)
}

输出结果：

p1={小明 beijing 32} 
p1={name:小明 city:beijing age:32} 
p2=&main.member{name:"小李", city:"shanghai", age:20} 
p3=&main.member{name:"小张", city:"shenzhen", age:18}

2、结构体方法和接收者

go语言的方法是一种特定类型变量的函数，这种特定类型叫做接收者，接收者的概念类似其他语言this,self等。

语法:

1
2

func (接受者变量，接受者类型)  方法名(参数列表) (返回值) {
}

package main

import "fmt"

// 定义一个结构体
type Person struct {
   name string
   age  int
   city string
}

// 值接收者
func (p Person) printInfo() {
   fmt.Printf("姓名：%s, 年龄：%d, 城市：%s \n", p.name, p.age, p.city)
}

// 指针接收者
func (p *Person) setInfo(name string, age int, city string) {
   p.name = name
   p.age = age
   p.city = city
}

func main() {
   // 实例化结构体
   p1 := Person{
      name: "xiaoming",
      age:  15,
      city: "tianjin",
   }
   p1.printInfo() //姓名：xiaoming, 年龄：15, 城市：tianjin
   p1.setInfo("tiantian", 18, "beijing")
   p1.printInfo() //姓名：tiantian, 年龄：18, 城市：beijing
}

terraform自动化创建ECS

wzdushu@gmail.com (wanzi) — Fri, 26 Feb 2021 17:22:42 +0800

快速创建一台阿里云ECS主机

指定terraform版本

这里我们指定了阿里云provider版本信息，并设置了terraform的版本要求

# mkdir aliyun-ecs-one && cd aliyun-ecs-one
# touch versions.tf
# vim versions.tf
 terraform {
  required_providers {
    alicloud = {
      source  = "aliyun/alicloud"
      version = "1.115.1"
    }
  }

  required_version = ">= 0.12"
}

配置变量

这里主要指定密钥对、云region、ECS账户和镜像信息

# vim variables.tf
# 阿里云子账户access_key
variable "alicloud_access_key" {
  default     = "LTAI4GBXXXXXXXXXXXXXXXXXXXXXX"
  description = "The Alicloud Access Key ID to launch resources. Support to environment 'ALICLOUD_ACCESS_KEY'."
}

# 阿里云子账户secret_key
variable "alicloud_secret_key" {
  default     = "4Z4gbl3dXXXXXXXXXXXXXXXXXXXXX"
  description = "The Alicloud Access Secret Key to launch resources.  Support to environment 'ALICLOUD_SECRET_KEY'."
}

# 阿里云区域，这里为杭州地区
variable "region" {
  default     = "cn-hangzhou"
  description = "The Alicloud region resources.  Support to environment 'REGION'."
}

# 设置阿里云杭州区域可用机房，这里设置为cn-hangzhou-i
variable "availability_zone" {
  description = "The available zone to launch ecs instance and other resources."
  default     = "cn-hangzhou-i"
}

# 设置镜像版本
variable "image_id" {
  default = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
}

# 设置ECS实例类型，对于
variable "ecs_type" {
  default = "ecs.s6-c1m2.small"
}

# 指定ECS实例密码
variable "ecs_password" {
  default = "Test12345"
}

# 指定ECS实例磁盘类型，这里为普通云盘
variable "disk_category" {
  default = "cloud_efficiency"
}

# 设置磁盘大小
variable "disk_size" {
  default = "40"
}

# 设置上网扣费泪行，默认为PayByTraffic（按流量计费）
variable "internet_charge_type" {
  default = "PayByTraffic"
}

# 公共网络最大传出带宽，从1.7版本，默认设置大于0会自动申请独享公网IP地址
variable "internet_max_bandwidth_out" {
  default = 5
}

配置实例相关资源

这里由于是测试，创建实例需要提前创建vpc，vswitch，安全组，安全组规则

# vim main.tf
provider "alicloud" {
  region     = var.region
  access_key = var.alicloud_access_key
  secret_key = var.alicloud_secret_key
}

resource "alicloud_vpc" "vpc" {
  name       = "tf_test_foo"
  cidr_block = "10.100.0.0/16"
}

resource "alicloud_vswitch" "vsw" {
  vpc_id            = alicloud_vpc.vpc.id
  cidr_block        = "10.100.0.0/24"
  availability_zone = var.availability_zone
}

resource "alicloud_security_group" "default" {
  name   = "default"
  vpc_id = alicloud_vpc.vpc.id
}

resource "alicloud_security_group_rule" "allow_all_tcp" {
  type              = "ingress"
  ip_protocol       = "tcp"
  nic_type          = "intranet"
  policy            = "accept"
  port_range        = "1/65535"
  priority          = 1
  security_group_id = alicloud_security_group.default.id
  cidr_ip           = "0.0.0.0/0"
}

resource "alicloud_instance" "wanzi_test" {
  # cn-hangzhou
  availability_zone = var.availability_zone
  security_groups   = alicloud_security_group.default.*.id

  instance_type        = var.ecs_type
  system_disk_category = var.disk_category
  image_id             = var.image_id
  instance_name        = "wanzi_tf001"
  vswitch_id           = alicloud_vswitch.vsw.id
  password             = var.ecs_password
}

执行plan，模拟执行效果

# terraform  plan

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # alicloud_instance.wanzi_test will be created
  + resource "alicloud_instance" "wanzi_test" {
      + availability_zone             = "cn-hangzhou-i"
      + credit_specification          = (known after apply)
      + deletion_protection           = false
      + dry_run                       = false
      + host_name                     = (known after apply)
      + id                            = (known after apply)
      + image_id                      = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
      + instance_charge_type          = "PostPaid"
      + instance_name                 = "wanzi_tf001"
      + instance_type                 = "ecs.s6-c1m2.small"
      + internet_max_bandwidth_in     = (known after apply)
      + internet_max_bandwidth_out    = 0
      + key_name                      = (known after apply)
      + password                      = (sensitive value)
      + private_ip                    = (known after apply)
      + public_ip                     = (known after apply)
      + role_name                     = (known after apply)
      + security_groups               = (known after apply)
      + spot_strategy                 = "NoSpot"
      + status                        = "Running"
      + subnet_id                     = (known after apply)
      + system_disk_category          = "cloud_efficiency"
      + system_disk_performance_level = (known after apply)
      + system_disk_size              = 40
      + volume_tags                   = (known after apply)
      + vswitch_id                    = (known after apply)
    }

创建云主机, 这个过程会请求阿里云API并在本地生成terraform state文件

# terraform apply
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # alicloud_instance.wanzi_test will be created
  + resource "alicloud_instance" "wanzi_test" {
      + availability_zone             = "cn-hangzhou-i"
      + credit_specification          = (known after apply)
      + deletion_protection           = false
      + dry_run                       = false
      + host_name                     = (known after apply)
      + id                            = (known after apply)
      + image_id                      = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
      + instance_charge_type          = "PostPaid"
      + instance_name                 = "wanzi_tf001"
      + instance_type                 = "ecs.s6-c1m2.small"
      + internet_max_bandwidth_in     = (known after apply)
      + internet_max_bandwidth_out    = 0
      + key_name                      = (known after apply)
      + password                      = (sensitive value)
      + private_ip                    = (known after apply)
      + public_ip                     = (known after apply)
      + role_name                     = (known after apply)
      + security_groups               = (known after apply)
      + spot_strategy                 = "NoSpot"
      + status                        = "Running"
      + subnet_id                     = (known after apply)
      + system_disk_category          = "cloud_efficiency"
      + system_disk_performance_level = (known after apply)
      + system_disk_size              = 40
      + volume_tags                   = (known after apply)
      + vswitch_id                    = (known after apply)
    }

  # alicloud_security_group.default will be created
  + resource "alicloud_security_group" "default" {
      + id                  = (known after apply)
      + inner_access        = (known after apply)
      + inner_access_policy = (known after apply)
      + name                = "default"
      + security_group_type = "normal"
      + vpc_id              = (known after apply)
    }
......
......
Plan: 5 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

alicloud_vpc.vpc: Creating...
alicloud_vpc.vpc: Creation complete after 9s [id=vpc-bp1kulcyygsi727aay4hd]
alicloud_security_group.default: Creating...
alicloud_vswitch.vsw: Creating...
alicloud_security_group.default: Creation complete after 1s [id=sg-bp11s5pka9pxtj6pn4xq]
alicloud_security_group_rule.allow_all_tcp: Creating...
alicloud_security_group_rule.allow_all_tcp: Creation complete after 1s [id=sg-bp11s5pka9pxtj6pn4xq:ingress:tcp:1/65535:intranet:0.0.0.0/0:accept:1]
alicloud_vswitch.vsw: Creation complete after 4s [id=vsw-bp1wgpgz9z8y2lfsl2beo]
alicloud_instance.wanzi_test: Creating...
alicloud_instance.wanzi_test: Still creating... [10s elapsed]
alicloud_instance.wanzi_test: Still creating... [20s elapsed]
alicloud_instance.wanzi_test: Creation complete after 22s [id=i-bp1gt9mb9asadff9r2zr]

Apply complete! Resources: 5 added, 0 changed, 0 destroyed.

通过以上操作，我们可以看出已经完成资源的创建，这个过程当前目录也会生成对应tfstate文件，这个数据非常重要，千万不要删除。另外，后续可以通过terraform show查看我们创建资源数据信息。

批量创建多台ECS云主机

配置Module

由于https://registry.terraform.io/上已经有很多优秀的模块，我们这里直接拿来alibaba/ecs-instance/alicloud这个module进行操作即可。

更多关于官方ECS module参考这里：https://github.com/terraform-alicloud-modules/terraform-alicloud-ecs-instance

这里variables.tf和versions.tf配置还是基于第一步配置；这里我们在main.tf增加module资源批量创建ECS配置，如下：

module "tf-instances" {
 source                      = "alibaba/ecs-instance/alicloud"
 region                      = "cn-hangzhou"
 number_of_instances         = "3"
 vswitch_id                  = alicloud_vswitch.vsw.id
 group_ids                   = [alicloud_security_group.default.id]
 private_ips                 = ["10.100.0.10", "10.100.0.11", "10.100.0.12"]
 image_ids                   = ["ubuntu_18_04_64_20G_alibase_20190624.vhd"]
 instance_type               = var.ecs_type
 internet_max_bandwidth_out  = 10
 associate_public_ip_address = true
 instance_name               = "my_module_instances_"
 host_name                   = "wanzi-cluster"
 internet_charge_type        = "PayByTraffic"
 password                    = var.ecs_password
 system_disk_category        = "cloud_ssd"
 data_disks = [
  {
    disk_category = "cloud_ssd"
    disk_name     = "my_module_disk"
    disk_size     = "50"
  }
 ]
}

这里需要注意默认情况下，internet_max_bandwidth_out配置以后，会自动申请一个独享公网IP地址，对于没有这个需求的，可以不用配置。

批量创建资源

➜ terraform apply
alicloud_vpc.vpc: Refreshing state... [id=vpc-bp1kulcyygsi727aay4hd]
alicloud_vswitch.vsw: Refreshing state... [id=vsw-bp1wgpgz9z8y2lfsl2beo]
alicloud_security_group.default: Refreshing state... [id=sg-bp11s5pka9pxtj6pn4xq]
alicloud_security_group_rule.allow_all_tcp: Refreshing state... [id=sg-bp11s5pka9pxtj6pn4xq:ingress:tcp:1/65535:intranet:0.0.0.0/0:accept:1]
alicloud_instance.wanzi_test: Refreshing state... [id=i-bp1gt9mb9asadff9r2zr]

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # module.tf-instances.alicloud_instance.this[0] will be created
  + resource "alicloud_instance" "this" {
      + availability_zone             = (known after apply)
      + credit_specification          = (known after apply)
      + deletion_protection           = false
      + description                   = "An ECS instance came from terraform-alicloud-modules/ecs-instance"
      + dry_run                       = false
      + host_name                     = "wanzi-cluster001"
      + id                            = (known after apply)
      + image_id                      = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
      + instance_charge_type          = "PostPaid"
      + instance_name                 = "my_module_instances_001"
      + instance_type                 = "ecs.s6-c1m2.small"
      + internet_charge_type          = "PayByTraffic"
      + internet_max_bandwidth_in     = (known after apply)
      + internet_max_bandwidth_out    = 10
      + key_name                      = (known after apply)
      + password                      = (sensitive value)
      + private_ip                    = "10.100.0.10"
      + public_ip                     = (known after apply)
      + role_name                     = (known after apply)
      + security_enhancement_strategy = "Active"
      + security_groups               = [
          + "sg-bp11s5pka9pxtj6pn4xq",
        ]
      + spot_strategy                 = "NoSpot"
      + status                        = "Running"
      + subnet_id                     = (known after apply)
      + system_disk_category          = "cloud_ssd"
      + system_disk_performance_level = (known after apply)
      + system_disk_size              = 40
      + tags                          = {
          + "Name" = "my_module_instances_001"
        }
      + volume_tags                   = {
          + "Name" = "my_module_instances_001"
        }
      + vswitch_id                    = "vsw-bp1wgpgz9z8y2lfsl2beo"

      + data_disks {
          + category             = "cloud_efficiency"
          + delete_with_instance = true
          + encrypted            = false
          + name                 = "TF_ECS_Disk"
          + performance_level    = (known after apply)
          + size                 = 40
        }
    }

  # module.tf-instances.alicloud_instance.this[1] will be created
  + resource "alicloud_instance" "this" {
      + availability_zone             = (known after apply)
      + credit_specification          = (known after apply)
      + deletion_protection           = false
      + description                   = "An ECS instance came from terraform-alicloud-modules/ecs-instance"
      + dry_run                       = false
      + host_name                     = "wanzi-cluster002"
      + id                            = (known after apply)
      + image_id                      = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
      + instance_charge_type          = "PostPaid"
      + instance_name                 = "my_module_instances_002"
      + instance_type                 = "ecs.s6-c1m2.small"
      + internet_charge_type          = "PayByTraffic"
      + internet_max_bandwidth_in     = (known after apply)
      + internet_max_bandwidth_out    = 10
      + key_name                      = (known after apply)
      + password                      = (sensitive value)
      + private_ip                    = "10.100.0.11"
      + public_ip                     = (known after apply)
      + role_name                     = (known after apply)
      + security_enhancement_strategy = "Active"
      + security_groups               = [
          + "sg-bp11s5pka9pxtj6pn4xq",
        ]
      + spot_strategy                 = "NoSpot"
      + status                        = "Running"
      + subnet_id                     = (known after apply)
      + system_disk_category          = "cloud_ssd"
      + system_disk_performance_level = (known after apply)
      + system_disk_size              = 40
      + tags                          = {
          + "Name" = "my_module_instances_002"
        }
      + volume_tags                   = {
          + "Name" = "my_module_instances_002"
        }
      + vswitch_id                    = "vsw-bp1wgpgz9z8y2lfsl2beo"

      + data_disks {
          + category             = "cloud_efficiency"
          + delete_with_instance = true
          + encrypted            = false
          + name                 = "TF_ECS_Disk"
          + performance_level    = (known after apply)
          + size                 = 40
        }
    }

  # module.tf-instances.alicloud_instance.this[2] will be created
  + resource "alicloud_instance" "this" {
      + availability_zone             = (known after apply)
      + credit_specification          = (known after apply)
      + deletion_protection           = false
      + description                   = "An ECS instance came from terraform-alicloud-modules/ecs-instance"
      + dry_run                       = false
      + host_name                     = "wanzi-cluster003"
      + id                            = (known after apply)
      + image_id                      = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
      + instance_charge_type          = "PostPaid"
      + instance_name                 = "my_module_instances_003"
      + instance_type                 = "ecs.s6-c1m2.small"
      + internet_charge_type          = "PayByTraffic"
      + internet_max_bandwidth_in     = (known after apply)
      + internet_max_bandwidth_out    = 10
      + key_name                      = (known after apply)
      + password                      = (sensitive value)
      + private_ip                    = "10.100.0.12"
      + public_ip                     = (known after apply)
      + role_name                     = (known after apply)
      + security_enhancement_strategy = "Active"
      + security_groups               = [
          + "sg-bp11s5pka9pxtj6pn4xq",
        ]
      + spot_strategy                 = "NoSpot"
      + status                        = "Running"
      + subnet_id                     = (known after apply)
      + system_disk_category          = "cloud_ssd"
      + system_disk_performance_level = (known after apply)
      + system_disk_size              = 40
      + tags                          = {
          + "Name" = "my_module_instances_003"
        }
      + volume_tags                   = {
          + "Name" = "my_module_instances_003"
        }
      + vswitch_id                    = "vsw-bp1wgpgz9z8y2lfsl2beo"

      + data_disks {
          + category             = "cloud_efficiency"
          + delete_with_instance = true
          + encrypted            = false
          + name                 = "TF_ECS_Disk"
          + performance_level    = (known after apply)
          + size                 = 40
        }
    }

Plan: 3 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

module.tf-instances.alicloud_instance.this[2]: Creating...
module.tf-instances.alicloud_instance.this[1]: Creating...
module.tf-instances.alicloud_instance.this[0]: Creating...
module.tf-instances.alicloud_instance.this[1]: Still creating... [10s elapsed]
module.tf-instances.alicloud_instance.this[2]: Still creating... [10s elapsed]
module.tf-instances.alicloud_instance.this[0]: Still creating... [10s elapsed]
module.tf-instances.alicloud_instance.this[1]: Still creating... [20s elapsed]
module.tf-instances.alicloud_instance.this[0]: Still creating... [20s elapsed]
module.tf-instances.alicloud_instance.this[2]: Still creating... [20s elapsed]
module.tf-instances.alicloud_instance.this[0]: Creation complete after 21s [id=i-bp1hwbo4htk8sbwxtk6o]
module.tf-instances.alicloud_instance.this[1]: Creation complete after 21s [id=i-bp17lh41gywyih0xg6we]
module.tf-instances.alicloud_instance.this[2]: Creation complete after 22s [id=i-bp11zlrl6vxeaerz4ad0]

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.

至此，整个创建多ECS实例的操作已经完成，后续如果对当前已经部署ecs资源有调整，进行基本write/plan/apply操作即可，这个过程会重启阿里云实例。

terraform安装与命令详解

wzdushu@gmail.com (wanzi) — Thu, 25 Feb 2021 17:22:42 +0800

安装Terraform

Mac系统安装

1
2

brew tap hashicorp/tap
brew install hashicorp/tap/terraform

Linux系统安装

ubuntu安装

1
2
3

curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install terraform

centos系统

1
2
3

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo
sudo yum -y install terraform

验证安装

# terraform -v
Terraform v0.14.3

Your version of Terraform is out of date! The latest version
is 0.14.7. You can update by downloading from https://www.terraform.io/downloads.html
# terraform
Usage: terraform [global options] <subcommand> [args]

The available commands for execution are listed below.
The primary workflow commands are given first, followed by
less common or more advanced commands.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure

All other commands:
  console       Try Terraform expressions at an interactive command prompt
  fmt           Reformat your configuration in the standard style
  force-unlock  Release a stuck lock on the current workspace
  get           Install or upgrade remote Terraform modules
  graph         Generate a Graphviz graph of the steps in an operation
  import        Associate existing infrastructure with a Terraform resource
  login         Obtain and save credentials for a remote host
  logout        Remove locally-stored credentials for a remote host
  output        Show output values from your root module
  providers     Show the providers required for this configuration
  refresh       Update the state to match remote systems
  show          Show the current state or a saved plan
  state         Advanced state management
  taint         Mark a resource instance as not fully functional
  untaint       Remove the 'tainted' state from a resource instance
  version       Show the current Terraform version
  workspace     Workspace management

Global options (use these before the subcommand, if any):
  -chdir=DIR    Switch to a different working directory before executing the
                given subcommand.
  -help         Show this help output, or the help for a specified subcommand.
  -version      An alias for the "version" subcommand.

terraform命令之资源管理

资源初始化

对于一个terraform资源项目，我这里创建了3个基本文件，分别为：main.tf（入口文件），variables.tf（变量信息），versions.tf（版本信息）

# ls 
main.tf     variables.tf      versions.tf
# terraform init

Initializing the backend...

Initializing provider plugins...
- Reusing previous version of aliyun/alicloud from the dependency lock file
- Using aliyun/alicloud v1.115.1 from the shared cache directory

Terraform has been successfully initialized!

格式化terraform文件

fmt默认会回格式化处理当前目录下.tf文件，并格式为标准的tf格式。

# terraform fmt 
main.tf
variables.tf
versions.tf
# terraform fmt -diff  #格式化处理
main.tf
--- old/main.tf
+++ new/main.tf
@@ -1,7 +1,7 @@
 provider "alicloud" {
   region     = var.region
   access_key = var.alicloud_access_key
-  secret_key =  var.alicloud_secret_key
+  secret_key = var.alicloud_secret_key
 }

 resource "alicloud_vpc" "vpc" {
@@ -12,7 +12,7 @@
 resource "alicloud_vswitch" "vsw" {
   vpc_id            = alicloud_vpc.vpc.id
   cidr_block        = "10.100.0.0/24"
-  availability_zone =  var.availability_zone
+  availability_zone = var.availability_zone
 }

 resource "alicloud_security_group" "default" {
variables.tf
--- old/variables.tf
+++ new/variables.tf
@@ -4,7 +4,7 @@
 }

 variable "alicloud_secret_key" {
-  default                     = "4Z4gbl3d9TGz9jWobv9MPwInvyH2Kf"
+  default     = "4Z4gbl3d9TGz9jWobv9MPwInvyH2Kf"
   description = "The Alicloud Access Secret Key to launch resources.  Support to environment 'ALICLOUD_SECRET_KEY'."
 }

创建资源计划

terraform plan 会检查一组更改的执行计划是否符合您的期望，而不会更改实际资源或状态。

# terraform  plan

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # alicloud_instance.wanzi_test will be created
  + resource "alicloud_instance" "wanzi_test" {
      + availability_zone             = "cn-hangzhou-i"
      + credit_specification          = (known after apply)
      + deletion_protection           = false
      + dry_run                       = false
      + host_name                     = (known after apply)
      + id                            = (known after apply)
      + image_id                      = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
      + instance_charge_type          = "PostPaid"
      + instance_name                 = "wanzi_tf001"
      + instance_type                 = "ecs.s6-c1m2.small"
      + internet_max_bandwidth_in     = (known after apply)
      + internet_max_bandwidth_out    = 0
      + key_name                      = (known after apply)
      + password                      = (sensitive value)
      + private_ip                    = (known after apply)
      + public_ip                     = (known after apply)
      + role_name                     = (known after apply)
      + security_groups               = (known after apply)
      + spot_strategy                 = "NoSpot"
      + status                        = "Running"
      + subnet_id                     = (known after apply)
      + system_disk_category          = "cloud_efficiency"
      + system_disk_performance_level = (known after apply)
      + system_disk_size              = 40
      + volume_tags                   = (known after apply)
      + vswitch_id                    = (known after apply)
    }

创建云资源

terraform apply 会自动生成一个资源创建计划，并批准执行该计划，同时在当前目录下会生成tfstate文件

# terraform apply
An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # alicloud_instance.wanzi_test will be created
  + resource "alicloud_instance" "wanzi_test" {
      + availability_zone             = "cn-hangzhou-i"
      + credit_specification          = (known after apply)
      + deletion_protection           = false
      + dry_run                       = false
      + host_name                     = (known after apply)
      + id                            = (known after apply)
      + image_id                      = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
      + instance_charge_type          = "PostPaid"
      + instance_name                 = "wanzi_tf001"
      + instance_type                 = "ecs.s6-c1m2.small"
      + internet_max_bandwidth_in     = (known after apply)
      + internet_max_bandwidth_out    = 0
      + key_name                      = (known after apply)
      + password                      = (sensitive value)
      + private_ip                    = (known after apply)
      + public_ip                     = (known after apply)
      + role_name                     = (known after apply)
      + security_groups               = (known after apply)
      + spot_strategy                 = "NoSpot"
      + status                        = "Running"
      + subnet_id                     = (known after apply)
      + system_disk_category          = "cloud_efficiency"
      + system_disk_performance_level = (known after apply)
      + system_disk_size              = 40
      + volume_tags                   = (known after apply)
      + vswitch_id                    = (known after apply)
    }

  # alicloud_security_group.default will be created
  + resource "alicloud_security_group" "default" {
      + id                  = (known after apply)
      + inner_access        = (known after apply)
      + inner_access_policy = (known after apply)
      + name                = "default"
      + security_group_type = "normal"
      + vpc_id              = (known after apply)
    }
......
......
Plan: 5 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

alicloud_vpc.vpc: Creating...
alicloud_vpc.vpc: Creation complete after 9s [id=vpc-bp1kulcyygsi727aay4hd]
alicloud_security_group.default: Creating...
alicloud_vswitch.vsw: Creating...
alicloud_security_group.default: Creation complete after 1s [id=sg-bp11s5pka9pxtj6pn4xq]
alicloud_security_group_rule.allow_all_tcp: Creating...
alicloud_security_group_rule.allow_all_tcp: Creation complete after 1s [id=sg-bp11s5pka9pxtj6pn4xq:ingress:tcp:1/65535:intranet:0.0.0.0/0:accept:1]
alicloud_vswitch.vsw: Creation complete after 4s [id=vsw-bp1wgpgz9z8y2lfsl2beo]
alicloud_instance.wanzi_test: Creating...
alicloud_instance.wanzi_test: Still creating... [10s elapsed]
alicloud_instance.wanzi_test: Still creating... [20s elapsed]
alicloud_instance.wanzi_test: Creation complete after 22s [id=i-bp1gt9mb9asadff9r2zr]

Apply complete! Resources: 5 added, 0 changed, 0 destroyed.

查看创建的资源信息

terraform show 会查看当前项目创建了哪些资源数据，

terraform show -json 以json形式查看数据

# terraform show
# alicloud_instance.wanzi_test:
resource "alicloud_instance" "wanzi_test" {
    availability_zone          = "cn-hangzhou-i"
    deletion_protection        = false
    dry_run                    = false
    host_name                  = "iZbp1gt9mb9asadff9r2zrZ"
    id                         = "i-bp1gt9mb9asadff9r2zr"
    image_id                   = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
    instance_charge_type       = "PostPaid"
    instance_name              = "wanzi_tf001"
    instance_type              = "ecs.s6-c1m2.small"
    internet_charge_type       = "PayByTraffic"
    internet_max_bandwidth_in  = -1
    internet_max_bandwidth_out = 0
    password                   = (sensitive value)
    private_ip                 = "10.100.0.234"
    security_groups            = [
        "sg-bp11s5pka9pxtj6pn4xq",
    ]
    spot_price_limit           = 0
    spot_strategy              = "NoSpot"
    status                     = "Running"
    subnet_id                  = "vsw-bp1wgpgz9z8y2lfsl2beo"
    system_disk_category       = "cloud_efficiency"
    system_disk_size           = 40
    volume_tags                = {}
    vswitch_id                 = "vsw-bp1wgpgz9z8y2lfsl2beo"
}

# alicloud_security_group.default:
resource "alicloud_security_group" "default" {
    id                  = "sg-bp11s5pka9pxtj6pn4xq"
    inner_access        = true
    inner_access_policy = "Accept"
    name                = "default"
    security_group_type = "normal"
    vpc_id              = "vpc-bp1kulcyygsi727aay4hd"
}

# alicloud_security_group_rule.allow_all_tcp:
resource "alicloud_security_group_rule" "allow_all_tcp" {
    cidr_ip           = "0.0.0.0/0"
    id                = "sg-bp11s5pka9pxtj6pn4xq:ingress:tcp:1/65535:intranet:0.0.0.0/0:accept:1"
    ip_protocol       = "tcp"
    nic_type          = "intranet"
    policy            = "accept"
    port_range        = "1/65535"
    priority          = 1
    security_group_id = "sg-bp11s5pka9pxtj6pn4xq"
    type              = "ingress"
}

# alicloud_vpc.vpc:
resource "alicloud_vpc" "vpc" {
    cidr_block        = "10.100.0.0/16"
    id                = "vpc-bp1kulcyygsi727aay4hd"
    name              = "tf_test_foo"
    resource_group_id = "rg-acfm2ogp24u3rcy"
    route_table_id    = "vtb-bp1wy8srerq12rta02r03"
    router_id         = "vrt-bp1apvobefvhshksnnwvm"
    router_table_id   = "vtb-bp1wy8srerq12rta02r03"
}

# alicloud_vswitch.vsw:
resource "alicloud_vswitch" "vsw" {
    availability_zone = "cn-hangzhou-i"
    cidr_block        = "10.100.0.0/24"
    id                = "vsw-bp1wgpgz9z8y2lfsl2beo"
    vpc_id            = "vpc-bp1kulcyygsi727aay4hd"
}

标记污点

terrraform taint 命令用于把某个资源标记为“被污染”状态，当再次执行 apply 命令时，这个被污染的资源将会被先释放，然后再创建一个新的，相当于对这个特定资源做了先删除后新建的操作。

1
2

# terraform taint alicloud_instance.wanzi_test
Resource instance alicloud_instance.wanzi_test has been marked as tainted.

而terrraform untaint正好相反，用于取消“被污染”标记，使其恢复到正常的状态。

1
2

# terraform untaint alicloud_instance.wanzi_test
Resource instance alicloud_instance.wanzi_test has been successfully untainted.

销毁云资源数据

terraform destory 将根据当前资源配置，销毁云端资源数据

#terraform destroy

Plan: 0 to add, 0 to change, 5 to destroy.

Do you really want to destroy all resources?
  Terraform will destroy all your managed infrastructure, as shown above.
  There is no undo. Only 'yes' will be accepted to confirm.

  Enter a value: yes

alicloud_security_group_rule.allow_all_tcp: Destroying... [id=sg-bp10tup89oothxz8tny1:ingress:tcp:1/65535:intranet:0.0.0.0/0:accept:1]
alicloud_instance.wanzi_test: Destroying... [id=i-bp10ukz4nlr894mhebgl]
alicloud_security_group_rule.allow_all_tcp: Destruction complete after 0s
alicloud_instance.wanzi_test: Still destroying... [id=i-bp10ukz4nlr894mhebgl, 10s elapsed]
alicloud_instance.wanzi_test: Still destroying... [id=i-bp10ukz4nlr894mhebgl, 20s elapsed]
alicloud_instance.wanzi_test: Destruction complete after 28s
alicloud_security_group.default: Destroying... [id=sg-bp10tup89oothxz8tny1]
alicloud_vswitch.vsw: Destroying... [id=vsw-bp1ap7ccst3fjxnw4pnza]
alicloud_security_group.default: Destruction complete after 9s
alicloud_vswitch.vsw: Still destroying... [id=vsw-bp1ap7ccst3fjxnw4pnza, 10s elapsed]
alicloud_vswitch.vsw: Destruction complete after 20s
alicloud_vpc.vpc: Destroying... [id=vpc-bp1obwt5ded2i0zlbu052]
alicloud_vpc.vpc: Destruction complete after 3s

Destroy complete! Resources: 5 destroyed.

将云端数据导入到本地项目

terraform import 通过云端实例ID来生成本地资源数据，本地目录会生成terraform.tfstate文件，对于本地项目已存在数据的导入前请先备份tfstate文件和.terraform目录；对于已经导入到本地的数据，可以通过terraform show展示出terrafrom文件格式，copy出来并进一步处理，即可得到tf资源文件内容。

# cat yunduan.tf
resource "alicloud_instance" "test999" {
  # (resource arguments)
}
#
# terraform import alicloud_instance.test999 i-bp1etiv4002h9q27lb97
alicloud_instance.test999: Importing from ID "i-bp1etiv4002h9q27lb97"...
alicloud_instance.test999: Import prepared!
  Prepared alicloud_instance for import
alicloud_instance.test999: Refreshing state... [id=i-bp1etiv4002h9q27lb97]

Import successful!

The resources that were imported are shown above. These resources are now in
your Terraform state and will henceforth be managed by Terraform.
# cat  terraform.tfstate
{
  "version": 4,
  "terraform_version": "0.14.3",
  "serial": 1,
  "lineage": "779fad5e-b076-8cfd-6041-f6eef8c88b8a",
  "outputs": {},
  "resources": [
    {
      "mode": "managed",
      "type": "alicloud_instance",
      "name": "test999",
      "provider": "provider[\"registry.terraform.io/aliyun/alicloud\"]",
      "instances": [
        {
          "schema_version": 0,
          "attributes": {
            "allocate_public_ip": null,
            "auto_release_time": "",
            "auto_renew_period": null,
            "availability_zone": "cn-hangzhou-i",
            "credit_specification": "",
            "data_disks": [],
            "deletion_protection": false,
            "description": "",
            "dry_run": null,
            "force_delete": null,
            "host_name": "iZbp1etiv4002h9q27lb97Z",
            "id": "i-bp1etiv4002h9q27lb97",
            "image_id": "ubuntu_18_04_64_20G_alibase_20190624.vhd",
            "include_data_disks": null,
            "instance_charge_type": "PostPaid",
            "instance_name": "wanzi_tf001",
            "instance_type": "ecs.s6-c1m2.small",
            "internet_charge_type": "PayByTraffic",
            "internet_max_bandwidth_in": -1,
            "internet_max_bandwidth_out": 0,
            "io_optimized": null,
            "is_outdated": null,
            "key_name": "",
            "kms_encrypted_password": null,
            "kms_encryption_context": null,
            "password": "",
            "period": null,
            "period_unit": null,
            "private_ip": "10.100.0.169",
            "public_ip": "",
            "renewal_status": null,
            "resource_group_id": "",
            "role_name": "",
            "security_enhancement_strategy": null,
            "security_groups": [
              "sg-bp14pij6g7sjmn9bz92a"
            ],
            "spot_price_limit": 0,
            "spot_strategy": "NoSpot",
            "status": "Running",
            "subnet_id": "vsw-bp1c966jdtiw1qwh2tng8",
            "system_disk_auto_snapshot_policy_id": "",
            "system_disk_category": "cloud_efficiency",
            "system_disk_description": null,
            "system_disk_name": null,
            "system_disk_performance_level": "",
            "system_disk_size": 40,
            "tags": {},
            "timeouts": {
              "create": null,
              "delete": null,
              "update": null
            },
            "user_data": "",
            "volume_tags": {},
            "vswitch_id": "vsw-bp1c966jdtiw1qwh2tng8"
          },
          "sensitive_attributes": [],
          "private": "eyJlMmJmYjczMC1lY2FhLTExZTYtOGY4OC0zNDM2M2JjN2M0YzAiOnsiY3JlYXRlIjo2MDAwMDAwMDAwMDAsImRlbGV0ZSI6MTIwMDAwMDAwMDAwMCwidXBkYXRlIjo2MDAwMDAwMDAwMDB9LCJzY2hlbWFfdmVyc2lvbiI6IjAifQ=="
        }
      ]
    }
  ]
}
# terraform show
# alicloud_instance.test999:
resource "alicloud_instance" "test999" {
    availability_zone          = "cn-hangzhou-i"
    deletion_protection        = false
    host_name                  = "iZbp1etiv4002h9q27lb97Z"
    id                         = "i-bp1etiv4002h9q27lb97"
    image_id                   = "ubuntu_18_04_64_20G_alibase_20190624.vhd"
    instance_charge_type       = "PostPaid"
    instance_name              = "wanzi_tf001"
    instance_type              = "ecs.s6-c1m2.small"
    internet_charge_type       = "PayByTraffic"
    internet_max_bandwidth_in  = -1
    internet_max_bandwidth_out = 0
    private_ip                 = "10.100.0.169"
    security_groups            = [
        "sg-bp14pij6g7sjmn9bz92a",
    ]
    spot_price_limit           = 0
    spot_strategy              = "NoSpot"
    status                     = "Running"
    subnet_id                  = "vsw-bp1c966jdtiw1qwh2tng8"
    system_disk_category       = "cloud_efficiency"
    system_disk_size           = 40
    tags                       = {}
    volume_tags                = {}
    vswitch_id                 = "vsw-bp1c966jdtiw1qwh2tng8"

    timeouts {}
}

terraform资源关系绘图

每个模板定义的资源之间都存在不同程度的关系，terraform graph可以绘制资源关系大图，如下：

# terraform graph
digraph {
        compound = "true"
        newrank = "true"
        subgraph "root" {
                "[root] alicloud_instance.wanzi_test (expand)" [label = "alicloud_instance.wanzi_test", shape = "box"]
                "[root] alicloud_security_group.default (expand)" [label = "alicloud_security_group.default", shape = "box"]
                "[root] alicloud_security_group_rule.allow_all_tcp (expand)" [label = "alicloud_security_group_rule.allow_all_tcp", shape = "box"]
                "[root] alicloud_vpc.vpc (expand)" [label = "alicloud_vpc.vpc", shape = "box"]
                "[root] alicloud_vswitch.vsw (expand)" [label = "alicloud_vswitch.vsw", shape = "box"]
                "[root] provider[\"registry.terraform.io/aliyun/alicloud\"]" [label = "provider[\"registry.terraform.io/aliyun/alicloud\"]", shape = "diamond"]
                "[root] var.alicloud_access_key" [label = "var.alicloud_access_key", shape = "note"]
                "[root] var.alicloud_secret_key" [label = "var.alicloud_secret_key", shape = "note"]
                "[root] var.availability_zone" [label = "var.availability_zone", shape = "note"]
                "[root] var.disk_category" [label = "var.disk_category", shape = "note"]
                "[root] var.disk_size" [label = "var.disk_size", shape = "note"]
                "[root] var.ecs_password" [label = "var.ecs_password", shape = "note"]
                "[root] var.ecs_type" [label = "var.ecs_type", shape = "note"]
                "[root] var.image_id" [label = "var.image_id", shape = "note"]
                "[root] var.internet_charge_type" [label = "var.internet_charge_type", shape = "note"]
                "[root] var.internet_max_bandwidth_out" [label = "var.internet_max_bandwidth_out", shape = "note"]
                "[root] var.region" [label = "var.region", shape = "note"]
                "[root] alicloud_instance.wanzi_test (expand)" -> "[root] alicloud_security_group.default (expand)"
                "[root] alicloud_instance.wanzi_test (expand)" -> "[root] alicloud_vswitch.vsw (expand)"
                "[root] alicloud_instance.wanzi_test (expand)" -> "[root] var.disk_category"
                "[root] alicloud_instance.wanzi_test (expand)" -> "[root] var.ecs_password"
                "[root] alicloud_instance.wanzi_test (expand)" -> "[root] var.ecs_type"
                "[root] alicloud_instance.wanzi_test (expand)" -> "[root] var.image_id"
                "[root] alicloud_security_group.default (expand)" -> "[root] alicloud_vpc.vpc (expand)"
                "[root] alicloud_security_group_rule.allow_all_tcp (expand)" -> "[root] alicloud_security_group.default (expand)"
                "[root] alicloud_vpc.vpc (expand)" -> "[root] provider[\"registry.terraform.io/aliyun/alicloud\"]"
                "[root] alicloud_vswitch.vsw (expand)" -> "[root] alicloud_vpc.vpc (expand)"
                "[root] alicloud_vswitch.vsw (expand)" -> "[root] var.availability_zone"
                "[root] meta.count-boundary (EachMode fixup)" -> "[root] alicloud_instance.wanzi_test (expand)"
                "[root] meta.count-boundary (EachMode fixup)" -> "[root] alicloud_security_group_rule.allow_all_tcp (expand)"
                "[root] meta.count-boundary (EachMode fixup)" -> "[root] var.disk_size"
                "[root] meta.count-boundary (EachMode fixup)" -> "[root] var.internet_charge_type"
                "[root] meta.count-boundary (EachMode fixup)" -> "[root] var.internet_max_bandwidth_out"
                "[root] provider[\"registry.terraform.io/aliyun/alicloud\"] (close)" -> "[root] alicloud_instance.wanzi_test (expand)"
                "[root] provider[\"registry.terraform.io/aliyun/alicloud\"] (close)" -> "[root] alicloud_security_group_rule.allow_all_tcp (expand)"
                "[root] provider[\"registry.terraform.io/aliyun/alicloud\"]" -> "[root] var.alicloud_access_key"
                "[root] provider[\"registry.terraform.io/aliyun/alicloud\"]" -> "[root] var.alicloud_secret_key"
                "[root] provider[\"registry.terraform.io/aliyun/alicloud\"]" -> "[root] var.region"
                "[root] root" -> "[root] meta.count-boundary (EachMode fixup)"
                "[root] root" -> "[root] provider[\"registry.terraform.io/aliyun/alicloud\"] (close)"
        }
}

该命令的结果还可以通过命令 terraform graph | dot -Tsvg > graph.svg 直接导出为一张图片（需要提前安装graphviz： brew install graphviz ）

`1`	`terraform graph \| dot -Tsvg > ~/Downloads/graph.svg`

查看graph.svg可以看到各个资源之间关系图谱：

terraform命令之State管理

查看当前state里存放所有资源

# terraform state list
alicloud_instance.wanzi_test
alicloud_security_group.default
alicloud_security_group_rule.allow_all_tcp
alicloud_vpc.vpc
alicloud_vswitch.vsw

查看某一个resource具体数据

# terraform state show alicloud_vswitch.vsw
# alicloud_vswitch.vsw:
resource "alicloud_vswitch" "vsw" {
    availability_zone = "cn-hangzhou-i"
    cidr_block        = "10.100.0.0/24"
    id                = "vsw-bp1wgpgz9z8y2lfsl2beo"
    vpc_id            = "vpc-bp1kulcyygsi727aay4hd"
}

移除特定资源

terraform state rm <资源类型>.<资源名称> state rm 命令用于将state中的某个资源移除，但是实际上并不会真正删除这个资源，另外也可以通过import操作从云端恢复到本地。

# terraform state rm  alicloud_security_group.default
Removed alicloud_security_group.default
Successfully removed 1 resource instance(s).
# terraform state list
alicloud_instance.wanzi_test
alicloud_vpc.vpc
alicloud_vswitch.vsw
# terraform import alicloud_security_group.default sg-bp11s5pka9pxtj6pn4xq
alicloud_security_group.default: Importing from ID "sg-bp11s5pka9pxtj6pn4xq"...
alicloud_security_group.default: Import prepared!
  Prepared alicloud_security_group for import
alicloud_security_group.default: Refreshing state... [id=sg-bp11s5pka9pxtj6pn4xq]

Import successful!

The resources that were imported are shown above. These resources are now in
your Terraform state and will henceforth be managed by Terraform.

刷新资源

terraform refresh刷新当前state内容，调用云API拉取最新数据写入state文件

# terraform refresh
alicloud_vpc.vpc: Refreshing state... [id=vpc-bp1kulcyygsi727aay4hd]
alicloud_vswitch.vsw: Refreshing state... [id=vsw-bp1wgpgz9z8y2lfsl2beo]
alicloud_security_group.default: Refreshing state... [id=sg-bp11s5pka9pxtj6pn4xq]
alicloud_instance.wanzi_test: Refreshing state... [id=i-bp1gt9mb9asadff9r2zr]

自动化编排工具Terraform介绍

wzdushu@gmail.com (wanzi) — Wed, 24 Feb 2021 17:22:42 +0800

Terraform是什么？：

Terraform是由HashiCorp公司在2014年左右推出的开源资源编排工具, 目前几乎所有的主流云服务商都支持Terraform，包括阿里云、腾讯云、华为云、AWS、Azure、百度云等等。目前很多公司都基于terraform构建自己的基础架构。

诞生背景：传统运维模式下，业务上线需经过设备采购，机器上架，网络环境搭建和系统安装等准备阶段。随着云计算的兴起，各大公有云厂商均提供了非常友好的交互界面，用户借助一个浏览器就可以按需采购各种云资源，快速实现业务架构的搭建。然而，随着业务架构的不断扩展，云资源采购的规模和种类也在持续增加。当用户需要快速采购大量不同类型的云资源时，云管理页面间大量的交互操作反而降低了云资源的采购效率。在阿里云控制台上初始化一个经典的VPC网络架构，从创建VPC、交换机VSwitch到创建Nat网关、弹性IP再到配置路由等工作，大概要花费20分钟甚至更久。同时，工作成果的不可复制性，带来的是跨Region和跨云平台场景下的重复劳动。

事实上，对业务运维人员而言，只关心对资源的配置，无需关心这些资源的创建步骤。如同喝咖啡，只需要告诉服务员喝什么，加不加冰等就够了。如果有一份完整的云资源采购清单，这张清单清楚的记录了所需要购买的云资源的种类，规格，数量以及各云资源之间的关系，然后一键完成购买，并且当业务需求发生变化时，只需要变更清单就可以实现对云资源的快速变更，那么效率就会提高很多。在云计算中这被称作资源编排，目前很多云平台也提供了资源编排的能力，如阿里云的ROS，AWS的CloudFormation等。

将云资源、服务或者操作步骤以代码的形式定义在模板中，借助编排引擎，实现资源的自动化管理，这就是基础设施即代码（Infrastructure as Code，简称IaC），也是资源编排最高效的实现模式。然而，多种云编排服务带来的是高昂的学习成本、低效的代码复用率和复杂的多云协同工作流程。每一种服务仅限于管理自家的单一云平台上，无法满足对多个云平台，多种层级（如IaaS，PaaS）资源的统一管理。如何解决如上问题，是否可以使用统一的编排工具，共用一套语法实现对包括阿里云在内的多云的统一管理呢？所以这个时候就诞生Terraform，来解决这些问题。

Terrafrom功能和作用：

功能点

IaC：infrastructure as code，用代码管理基础设施
执行计划：显示terraform apply时执行的操作
资源图：构建所有资源的图形
变更自动化：基于执行计划和资源图，可以清晰知道要变更的内容和顺序总结：terraform用于各类基础设施资源初始化，支持多种云平台，支持第三方服务对接

作用

使用不同provider的API，包装抽象成Terraform的标准代码结构
用户不需要了解每个云计算厂商的API细节，降低了部署难度

Terraform架构

Terraform本身是基于插件的架构，可扩展性很强，可以方便程序员对Terraform进行扩展。Terraform从逻辑上可以分为两层，核心层（Terraform Core）和插件层（Terraform Provider）。

核心层

核心层其实就是terraform的命令行工具，它是用go语言开发的，它负责：

读取.tf配置，进行变量替换
资源状态文件管理
分析资源关系，绘制图谱
依赖关系图谱，创建资源根据依赖关系，创建资源；对于没有依赖关系的资源，会并行进行创建(缺省10个并行进程），这也是Terraform能够高效快速管理云资源的原因。
用RPC调用插件层

插件层

插件层也是由go语言开发的，Terraform有超过250个不同的插件，它们负责：

接受核心层的RPC调用
具体提供某一项服务的执行

插件层又有两种：

Provider

Provider，负责与外界API的集成，比如阿里云Provider就提供了在阿里云创建、修改、删除云资源的功能。这个插件负责和阿里云云API的接口交互，并提供一层抽象，这样程序员可以在不了解API细节的情况下，通过terraform来编排资源。它负责：

始化以及外界API通信
外界API的认证
定义云资源与外界服务的关系

比如常见provider:

阿里云： https://github.com/aliyun/terraform-provider-alicloud
百度云：https://github.com/baidubce/terraform-provider-baiducloud
腾讯云：https://github.com/tencentcloudstack/terraform-provider-tencentcloud
华为云：https://github.com/huaweicloud/terraform-provider-huaweicloud
ucloud：https://github.com/ucloud/terraform-provider-ucloud
qingcloud：https://github.com/yunify/terraform-provider-qingcloud
AWS：https://github.com/hashicorp/terraform-provider-aws
Azure：https://github.com/terraform-providers/terraform-provider-azurerm
GoogleCloud：https://github.com/hashicorp/terraform-provider-google

Provisioner

Provisioner，负责在资源创建或者删除完成后，执行一些脚本。比如Puppet Provisioner就可以在云虚拟机资源创建完成后，在该资源上下载、安装、配置Puppet agent。

为了方便理解,网络上找了一个组件架构图，简单说明各个组件位置：

对于terraform日常操作，我画了一个基本workflow流程图如下：

terraform关键字解释：

声明式语言（HCL）：

Terraform是通过HashiCorp Configuration Language来编写代码的，HCL是声明式的，也就是说，程序员用HCL来描述整个基础架构应该是什么样的，然后把具体的实施工作交给Terraform就可以了，程序员不需要了解实施的具体步骤和细节，不需要了解terraform如何与云服务商的API进行对接。Terraform会根据代码，自动下载相应的Provider和Provisioner来负责具体步骤和细节。于声明式对应的是命令式。命令式语言是按照步骤执行的，先后顺序很重要，对固定输入执行命令式语言会得到固定的输出。声明式和命令式并无高下之分，只是在云资源编排这一领域，声明式会比较方便实现。我们日常见到的云资源编排工具都是声明式的，包括AWS CloudFormation、Azure Resource Template、Google Cloud Deoplyment Manager。大家如果通过调用腾讯云API来在腾讯云上实施资源编排，那通常就是命令式的。

资源状态文件(state)

Terraform初始化以后，会生成一个状态文件，该状态文件记录了最近一次操作的时间、各资源的相关属性、各变量的当前值、状态文件的版本、等等。

下一次再操作的时候，terraform首先会把当前状态文件与云服务商上的状态进行一次更新，找出是否后有被删除或者更改了的资源，然后再根据.tf文件，决定那些资源需要删除、更新、创建。操作完成后，会重新生成一个状态文件。

Terraform后台(backend)

资源状态文件的完整性比较重要，对于这些文件我们至少需要做到在操作开始时自动加锁，直到操作结束，这样别人无法更改；另外还需要对资源版本变更进行跟踪；对资源文件里敏感信息进行访问控制。

因此backend跟资源状态文件如何读取、存储、锁定，以及terraform apply如何执行严密相关。

terraform缺省使用本地后台，也就是说，状态文件会存放在当前目录下，terraform代码的执行也在本地虚拟机运行。这对一个人管理的云资源是没有问题的，但当团队人员数目加多以后，大家可能都有自己的工作台，但是需要一个共有的地方来存储资源状态文件。这是后就可以用到远程存储。目前terraform支持多种远程存储后台，包括AWS s3,Hashicorp Consul,etcd，Terraform云，以及terraform企业版等等，这些远程后台都提供在远程存储、锁定状态文件。其中terraform企业版提供远程运行terraform，以及其他一些企业级特性。

Terraform模块(module)

Terraform模块就是把一些高度可重用的代码写成模块，方便其他人使用。模块由输入参数、输出参数以及主逻辑组成。这就跟传统编程语言里的函数很像。Terraform提供了公开的模块注册器，模块编写完成以后，只要符合规范，就可以发布到模块注册器中让大家使用。https://registry.terraform.io/

saltstack之saltapi

wzdushu@gmail.com (wanzi) — Thu, 15 Feb 2018 16:22:42 +0800

安装

`1`	`yum -y install salt-api`

配置

cat /etc/salt/master.d/api.conf #配置证书和端口

rest_cherrypy:
  port: 8888
  debug: True
  ssl_crt: /etc/pki/tls/certs/localhost.crt
  ssl_key: /etc/pki/tls/private/localhost_nopass.key

cat /etc/salt/master.d/eauth.conf #设置权限

external_auth:
  pam:
    saltapi:
      - .*
      - '@wheel'
      - '@runner'

添加账号

1
2

useradd -M -s /sbin/nologin saltapi
echo "saltapi_xxxxxx" | passwd saltapi --stdin

启动服务

1
2

systemctl enable salt-api
systemctl start salt-api

测试

curl测试并获取token信息：

curl -k https://manage-op.test.cn:8888/login -H "Accept: application/x-yaml" \
-d username='saltapi' \
-d password='saltapi_xxxxxxxx' \
-d eauth='pam'

如果使用python或者golang可以自己封装client

saltstack之salt命令大全

wzdushu@gmail.com (wanzi) — Sat, 10 Feb 2018 16:22:42 +0800

常用命令

salt -N 'ceph' test.ping     #测试连通性
salt -E '^server10*' test.ping           #正则匹配连通性
salt -S 192.168.150.101 test.ping      #根据agent ip地址匹配执行
salt -S 192.168.150.0/24 test.ping     #根据agent ip地址匹配执行
salt -N 'ceph' cmd.run 'df -Th' #按组查看磁盘使用
salt -N 'ceph' cmd.exec_code python 'import os; print os.system("df -Th")' #python代码执行
salt -N 'ceph' cmd.exec_code perl 'print scalar localtime' #perl代码执行
salt -G 'osrelease:6.3' cmd.run 'python -V' #根据grans信息过滤后执行
salt '*'  smbios.get system-serial-number #获取服务器硬件序列号

远程执行脚本：

`1`	`salt -N 'ceph' salt://scripts/runme.sh #远程执行脚本`

远程拷贝文件：

salt -N 'ceph' cp.get_file salt://files/opencdn/a.txt /tmp/a.txt #agent端从master拉取文件到/tmp下
salt -N 'ceph' cp.get_file salt://files/opencdn/dir1/  /tmp   #agent端从master拉取目录到/tmp下
salt -N 'ceph' cp.get_url http://www.baidu.com  /tmp/index.html #下载url
salt -N 'ceph' cp.push /etc/fstab   #提取指定节点文件到master,默认在/var/cache/salt/master/minions/minion-id/files目录下
salt -N 'ceph' cp.push_dir /etc/modprobe.d/ glob='*.conf' #提取节点指定目录的指定配置文件
salt-cp '*' fstab /etc/fstab   #拷贝当前目录下fstab文件到节点/etc/fstab
salt-cp -E 'gpu0[1-2][1-5]' fstab /etc/fstab    #正则匹配拷贝文件
salt-cp -G 'os:CentOS*' fstab /etc/fstab   #grains匹配拷贝文件

获取磁盘信息

1
2
3

salt -N 'ceph' disk.percent /data01  #获取磁盘使用率
salt -N 'ceph' disk.nodeusage /data01  #获取磁盘inode使用
salt -N 'ceph' xfs.info /data01 #获取xfs分区信息

文件操作

1
2
3

salt -N 'ceph' file.chown /etc/passwd root root   #修改文件权限
salt -N 'ceph' file.copy  /etc/passwd  /tmp/passwd #拷贝文件
salt -N 'ceph' file.directory_exists /etc/passwd  #判断文件是否存在

用户信息操作

1
2
3

salt -N 'ceph' user.list_users  #列出系统所有系统账号
salt -N 'ceph' user.info  lianghaiqiang  #列出用户信息
salt -N 'ceph' user.delete lianghaiqiang remove=True force=True #强制删除用户

时区、重启、任务计划

salt -N 'ceph' timezone.get_zone  #获取时区
salt -N 'ceph' timezone.set_zone #设置时区
salt -N 'ceph' system.reboot #重启系统
salt -N 'ceph' cron.list_tab root  #列出root计划任务
salt -N 'ceph' cron.raw_cron root  #列出root计划任务，文本格式

文件解压缩：

1
2
3

salt -N 'ceph' archive.cmd_unzip template=jinja /tmp/zipfile.zip /tmp/{{grains.id}}/ excludes=file_1,file_2
salt -N 'ceph' archive.cmd_unzip /tmp/zipfile.zip /home/strongbad/ excludes=file_1,file_2
salt -N 'ceph' archive.cmd_zip template=jinja /tmp/zipfile.zip /tmp/sourcefile1,/tmp/{{grains.id}}.txt

网络

salt -N 'ceph' network.dig www.baidu.com  #dig解析
salt -N 'ceph' network.get_hostname  #获取主机名
salt -N 'ceph' network.hw_addr eth0  #获取MAC地址
salt -N 'ceph' network.ip_addrs  #获取IP地址
salt -N 'ceph' network.ping www.baidu.com  timeout=3 #ping信息
salt -N 'ceph' pkg.install  zlib   #安装软件包

获取对象帮助信息：

如：grains/disk/pillar/pip/pkg

salt -N 'ceph' sys.doc  sys  #获取sys系统帮助信息
salt 'gpu054' sys.list_functions grains  #查询grains属性用法
salt 'gpu054' sys.doc grains    #查询grains用法帮助
salt 'gpu054' sys.doc disk    #查询disk用法帮助

salt 'gpu054' sys.list_functions  pillar #查询pillar用法
salt 'gpu054' sys.doc  pillar #查询pillar用法帮助
salt 'gpu054' pillar.item  #查询pillar支持数据源

salt 'gpu054' sys.list_modules #查询minion支持模块
salt 'gpu054' sys.list_functions  pip #查询pip模块支持方法
salt 'gpu054' sys.doc  pip #查看pip模块帮助

salt 'gpu054' sys.list_state_modules #查询所有states列表
salt 'gpu054' sys.list_state_functions pkg #查询pkg方法
salt 'gpu054' sys.state_doc pkg #查询pkg帮助

Jobs管理：

salt-run jobs.active   #查看所有minion当前正在运行的jobs(在所有minions上运⾏saltutil.running)
salt-run jobs.lookup_jid <jid>        #从master jobs cache中查询指定jid的运行结果
salt-run jobs.list_jobs    #列出当前master jobs cache中的所有job
salt 'xxxx' saltutil.kill_job  <jid>  #master上kill掉某个job

python编码规范

wzdushu@gmail.com (wanzi) — Sat, 20 Jan 2018 10:22:42 +0800

编码声明

默认不设置为ASCII,可设置为

`1`	`# coding=<encoding name>`

或

1
2

#!/usr/bin/python
# -*- coding: <encoding name> -*-

或

1
2

#!/usr/bin/python
# coding: utf-8

代码编排

四个空格一个缩进，不建议使用tab，更不建议混合使用tab和空格
单行最长79字符，换行可使用反斜杠，最好使用括号
类和同级别函数之间空2行，类中方法之间空一行
模块书写顺序: 模块说明和docstring，import，globals，constants，其他；其中import又按标准、第三方、自己编写顺序摆放，同时不建议书写在一行
操作符左右各加一个空格，函数默认参数使用的赋值符左右省略空格，各种右括号前不要加空格;
注释必须使用英文，最好是完整的句子，首字母大写，句后要有结束符，结束符后跟两个空格，开始下一句。如果是短语，可以省略结束符。
所有的共有模块、函数、类、方法写docstrings；非共有的没有必要，但是可以写注释（在def的下一行）

命名规范

尽量单独使用小写字母‘l’，大写字母‘O’等容易混淆的字母。
模块命名尽量短小，使用全部小写的方式，可以使用下划线。
包命名尽量短小，使用全部小写的方式，不可以使用下划线。
类的命名使用CapWords的方式，模块内部使用的类采用_CapWords的方式。
异常命名使用CapWords+Error后缀的方式。
全局变量尽量只在模块内有效，类似C语言中的static。实现方法有两种，一是__all__机制;二是前缀一个下划线。
函数命名使用全部小写的方式，可以使用下划线。
常量命名使用全部大写的方式，可以使用下划线。
类的属性（方法和变量）命名使用全部小写的方式，可以使用下划线。
类的属性有3种作用域public、non-public和subclass API，可以理解成C++中的public、private、protected，non-public属性前，前缀一条下划线。
类的属性若与关键字名字冲突，后缀一下划线，尽量不要使用缩略等其他方式。
为避免与子类属性命名冲突，在类的一些属性前，前缀两条下划线。比如：类Foo中声明__a,访问时，只能通过Foo._Foo__a，避免歧义。如果子类也叫Foo，那就无能为力了。
类的方法第一个参数必须是self，而静态方法第一个参数必须是cls

代码检查工具

`1`	`pip install flake8`

安装flake8成功后，打开VScode，文件->首选项->用户设置，在settings.json文件中输入"python.linting.flake8Enabled": true

自动格式化工具

`1`	`pip install yapf`

安装yapf成功后，打开VScode，文件->首选项->用户设置，在settings.json文件中输入"python.formatting.provider": “yapf”

项目开发注意事项：

在开始一个空白项目的时候需要注意如下几条：

README.md这里写你项目的简介，quick start等信息，虽然distutils要求这个文件没有后缀名，但github上如果后缀是.md的话可以直接转换成html显示。
ChangeLog.txt该文件存放程序各版本的变更信息，也有一定的格式，参考web.py的ChangeLog.txt
LICENES.txt 这里存放你项目使用的协议，不要编写自己的协议。
requirements.txt 如果你的项目需要依赖其它的python第三方库，在这里一行一个写出来，可能pip install的时候能自动帮你安装
setup.py安装脚本，后面详细介绍
docs 里面存放你的项目文档，如概要设计，详细设计，维护文档，pydoc自动生成的文档等，强烈推荐大家使用MarkDown格式编写文档
src 这个目录里存放项目模块的主要代码，尽量不要把模块目录直接放到根目录，模块代码目录可以在setup.py里指定的
tests 这个目录存放所有单元测试，性能测试脚本，单元测试的文件确保以test_做前缀，这样distutils会自动打包这些文件，并且用python -m unittest discover -s ./ -p ’test_*.py’ -v 可以直接执行这些测试

参考：

https://www.python.org/dev/peps/pep-0008/ https://wiki.woodpecker.org.cn/moin/PythonCodingRule