褚成志的分享站

Spring AI 框架中如何集成 MCP？

2026-04-09T16:00:00.000Z

SpringAI MCP介绍

Spring AI MCP 为模型上下文协议提供 Java 和Spring 框架集成、它使 SpringAI 应用程序能够通过标准化的接口与不同的数据源和工是进行交互，支持同步和异步通信模式。整体架构如下:

Spring Al 通过以下 Spring Boot 启动器提供 MCP 集成：

客户端启动器

spring-ai-starter-mcp-client 核心启动器提供 STDIO 和基于 HTTP 的 SSE 支持。
spring-ai-starter-mcp-client-webflux 基于WebFlux的SSE流式传输实现

服务端启动器

spring-ai-starter-mcp-server 核心服务器具有 STDIO 传输支持
spring-ai-starter-mcp-server-webmvc 基于Spring MVC的SSE流式传输实现
spring-ai-starter-mcp-server-webflux 基于WebFlux的SSE流式传输实现

基于stdio标准流

MCP 服务端

基于 stdio 的实现是最常见的 MCP客户端方案，它通过标准输入输出流与 MCP 服务器进行通信，这种方式简单直观，能够直接通过进程间通信实现数据交互，避免了额外的网络通信开销，特别适用于本地部署的MCP服务器，可以在司一台机器上启动 MCP 服务器进程，与客户端无缝对接。

引入依赖


org.springframework.ai
spring-ai-mcp-server-spring-boot-starter
1.0.0-M6

配置MCP服务端

spring:
  application:
    name: mcp-server
  main:
    web-application-type: none # 必须禁用web应用类型
    banner-mode: off # 禁用banner
  ai:
    mcp:
      server:
        stdio: true # 启用stdio模式
        name: mcp-server # 服务器名称
        version: 0.0.1 # 服务器版本

实现MCP工具

@Tool 是 SpingAI MCP框架中用于快速暴露业务能力为AI 工具的核心注解，该注解实现Java方法与MCP协议工具的自动银蛇，并且可以通过注解的属性description，有助于人工智能模型根据用户输入的信息决定是否调用这些工具，并返回相应的结果.

@Service
public class OpenMeteoService {

    @Tool(description = "根据经纬度获取天气预报")
    public String getAirQuality(
        @ToolParameter(description = "纬度，例如：39.9042") String latitude,
        @ToolParameter(description = "经度，例如：116.4074") String longitude) {

        // 模拟数据，实际应用中应调用真实API
        return "当前位置（纬度：" + latitude + "，经度：" + longitude + "）的天气信息：\n 多云转阴";
    }
}

这个工具方法主要是用来根据经纬度获取天气预报的，这里为了方便演示，写了模拟数据

注册MCP工具

最后向 MCP 服务注册刚刚写的工具：

@Bean
    public ToolCallbackProvider serverTools(OpenMeteoService openMeteoService) {
        return MethodToolCallbackProvider.builder().toolObjects(openMeteoService).build();
    }

这段代码定义了一个 Spring 的 Bean，用于将查询天气服务 OpenMeteoService 中所有用 @Tool 注解标记的方法注册为工具，供 AI 模型调用。

ToolCallbackProvider 是Spring Al 中的一个接口，用于定义工具发现机制，主要负责将那些使用

@Tool 注解标记的方法转换为工具回调对象，并提供给 ChatClient 或ChatModel 使用，以便 AI 模型能够在对话过程中调用这些工具。

MCP 客户端

引入依赖


org.springframework.ai
spring-ai-mcp-client-spring-boot-starter
1.0.0-M6

配置MCP服务器

因为服务端是通过 stdio 实现的，需要在 application.yml 中配置MCP服务器的一些参数：

spring:
  ai:
    mcp:
      client:
        stdio:
          # 指定MCP服务器配置文件
          servers-configuration: classpath:/mcp-servers-config.json
  mandatory-file-encoding: UTF-8

其中 mcp-servers-config.json 的配置如下：

{
  "mcpServers": {
    "weatherServer": {
      "command": "java",
      "args": [
        "-Dspring.ai.mcp.server.stdio=true",
        "-Dspring.main.web-application-type=none",
        "-Dlogging.pattern.console=",
        "-jar",
        "/Users/gulihua/Documents/mcp-server/target/mcp-server-0.0.1-SNAPSHOT.jar"
      ],
      "env": {}
    }
  }
}

这个配置文件设置了MCP客户端的基本配置，包括 Java 命令参数，服务端 jar 包的绝对路径等，上述的 JSON 配置文件也可以直接写在 apllication.yaml 里，效果是一样的。

mcp:
      client:
        stdio:
         connections:
           server1:
             command: java
             args:
               - -Dspring.ai.mcp.server.stdio=true
               - -Dspring.main.web-application-type=none
               - -Dlogging.pattern.console=
               - -jar
               - /Users/gulihua/Documents/mcp-server/target/mcp-server-0.0.1-SNAPSHOT.jar

客户端我们使用问里巴巴的通义千问模型，所以引入 spring-ai-alibaba-starter 依赖，如果使用的是其他的模型，也可以使用对应的依赖项，比加 openAI 引入 sprine-ai-openai-spring-boot-starter 这个依赖就行了

配置大模型的密钥等信息：

spring:
  ai:
    dashscope:
      api-key: ${通义千问的key}
      chat:
        options:
          model: qwen-max

初始化聊天客户端

@Bean
public ChatClient initChatClient(ChatClient.Builder chatClientBuilder,
                                 ToolCallbackProvider mcpTools) {
    return chatClientBuilder
    .defaultTools(mcpTools)
    .build();
}

该代码定义了一个 spring pean，用于初始化一个AI聊天客户端，里面有两个参数，chatcient.Buinider 是 SpnngAI 提供的AI聊天客户端构建器，用于构建 ChatCient实例，是由 Spring AI 自动注入的，另一个是 ToolCallbackProvider，用于从MCP客服端发现并获取AI工具。

然后就可以通过这个 chatclient 去调用了：

chatClient.prompt()
.user(request.getContent())
.call()
.content();

基于SSE

MCP服务端

除了基于 stdio 的实现外，Spring Al还提供了基于 Server-Sent vents(SSE)的 MCP客户端方案。相较于 stdio方式，SSE 更适用于远程部署的 MCP 服务器，客户端可以通过标准 HTTP 协议与服务器建立连接，实现单向的实时数据推送。基于 SSE的 MCP 服务器支持被多个客户端的远程调用。

引入依赖


org.springframework.ai
spring-ai-mcp-server-webflux-spring-boot-starter
1.0.0-M6

配置MCP服务端

server:
  port: 8090

spring:
  application:
    name: mcp-server
  ai:
    mcp:
      server:
        name: mcp-server # MCP服务器名称
        version: 0.0.1   # 服务器版本号

除了引入的依赖包不一样，以及配置文件不同，其他的不需要修改。

MCP 客户端

引入依赖


org.springframework.ai
spring-ai-mcp-client-webflux-spring-boot-starter
1.0.0-M6

配置MCP服务器

因为服务端是通过SSE实现的，需要在 application.yml 中配置MCP服务器的URL端口：

spring:
  ai:
    mcp:
      client:
        enabled: true
        name: mcp-client
        version: 1.0.0
        request-timeout: 30s
        type: ASYNC # 类型同步或者异步
        sse:
          connections:
            server1:
              url: http://localhost:8090

和MCP服务端的修改一样，除了依赖和配置的修改，其他的也不需要调整

注意

除了上面基础的用法和配置，还应该考虑以下几个方面:

工具设计

每个工具方法应具备明确的功能定义及参数说明。

使用 @Tool 注解提供清晰、完整的工具描述，便于自动生成文档或展示给前端。
使用 @ToolParameter 注解详细说明每个参数的用途，提升使用者的理解与正确性。

错误处理

应全面捕获并妥善处理可能出现的异常，防止服务崩溃。
返回结构化、具备可读性的错误信息，便于客户端识别错误原因并进行相应处理。

性能优化

对于可能耗时的任务，建议使用异步处理机制，避免阻塞主线程，
设置合理的超时时间，防止客户端长时间等待，提高系统响应性和稳定性。

安全性考虑

对涉及敏感资源或关键操作的工具方法，应添加严格的权限校验逻辑
禁止在工具方法中执行高风险操作(如执行任意系统命令)，以防止安全洞。

部署策略

Stdio 模式：适用于嵌入式场景，可作为客户端的子进程运行，便于集成与资源控制。
SSE模式：更适合部署为独立服务，支持多个客户端同时访问，适用于需要持续通信的远程调用场景。

【从0到1构建一个ClaudeAgent】工具与执行-工具

2026-04-09T16:00:00.000Z

这是 Agent 进化的关键一步：从“只会说话”变成了“真正干活”。

Java 实现代码

public class AgentWithTools {
    // 配置
    private static final Path WORKDIR = Paths.get(System.getProperty("user.dir"));
    
    // --- 核心：工具定义与分发 ---
    // 1. 定义工具枚举
    public enum ToolType {
        BASH("bash", "Run a shell command."),
        READ_FILE("read_file", "Read file contents."),
        WRITE_FILE("write_file", "Write content to file."),
        EDIT_FILE("edit_file", "Replace exact text in file.");
        // ... 省略构造器
    }

    // 2. 工具执行接口
    @FunctionalInterface
    interface ToolExecutor {
        String execute(Map args) throws Exception;
    }

    // 3. 注册工具处理逻辑
    private static final Map TOOL_HANDLERS = new HashMap<>();

    static {
        TOOL_HANDLERS.put(ToolType.BASH.name, args -> {
            String command = (String) args.get("command");
            return runBash(command);
        });
        TOOL_HANDLERS.put(ToolType.READ_FILE.name, args -> {
            String path = (String) args.get("path");
            Integer limit = (Integer) args.get("limit");
            return runRead(path, limit);
        });
        TOOL_HANDLERS.put(ToolType.WRITE_FILE.name, args -> {
            String path = (String) args.get("path");
            String content = (String) args.get("content");
            return runWrite(path, content);
        });
        TOOL_HANDLERS.put(ToolType.EDIT_FILE.name, args -> {
            String path = (String) args.get("path");
            String oldText = (String) args.get("old_text");
            String newText = (String) args.get("new_text");
            return runEdit(path, oldText, newText);
        });
    }

    // --- 核心循环 ---
    public static void agentLoop(List> messages) {
        while (true) {
            // ... 省略相同的 LLM 调用、消息追加逻辑
            
            // 4. 执行工具
            List> toolResults = new ArrayList<>();
            List> content = (List>) response.get("content");

            for (Map block : content) {
                if ("tool_use".equals(block.get("type"))) {
                    String toolName = (String) block.get("name");  // 关键新增
                    String toolId = (String) block.get("id");
                    Map inputArgs = (Map) block.get("input");

                    // 路由分发
                    ToolExecutor handler = TOOL_HANDLERS.get(toolName);
                    String output;
                    try {
                        if (handler != null) {
                            output = handler.execute(inputArgs);
                        } else {
                            output = "Error: Unknown tool " + toolName;
                        }
                    } catch (Exception e) {
                        output = "Error: " + e.getMessage();
                    }

                    System.out.println("> " + toolName + ": " + output.substring(0, Math.min(output.length(), 100)));

                    // ... 省略相同的工具结果构造逻辑
                }
            }
            // ... 省略相同的回传逻辑
        }
    }

    // --- 工具具体实现 ---
    private static Path safePath(String p) throws IOException {
        Path path = WORKDIR.resolve(p).normalize();
        if (!path.startsWith(WORKDIR)) {
            throw new IOException("Path escapes workspace: " + p);
        }
        return path;
    }

    // ... 省略与之前相同的 runBash 实现

    private static String runRead(String pathStr, Integer limit) throws IOException {
        Path path = safePath(pathStr);
        String content = Files.readString(path);
        if (limit != null && limit  args) throws Exception;
    // 统一接口：所有工具都实现此方法
    // 参数和返回值标准化
}

// 工具注册表 - 动态路由
private static final Map TOOL_HANDLERS = new HashMap<>();

static {
    TOOL_HANDLERS.put("bash", args -> {
        // 工具实现1
    });
    TOOL_HANDLERS.put("read_file", args -> {
        // 工具实现2
    });
    // 注册中心：工具名 -> 实现函数
    // 新增工具只需在这里注册
}

开闭原则：不修改主循环就能添加新工具
统一管理：所有工具注册、调用逻辑一致
类型安全：通过枚举定义工具，避免硬编码字符串

文件操作工具集

核心思想：为Agent提供文件系统读写能力，使其能像人类开发者一样操作文件。

private static Path safePath(String p) throws IOException {
    Path path = WORKDIR.resolve(p).normalize();
    if (!path.startsWith(WORKDIR)) {
        throw new IOException("Path escapes workspace: " + p);
    }
    return path;
    // 安全沙箱：确保工具只能操作工作目录内的文件
    // 防止路径逃逸攻击
}

private static String runRead(String pathStr, Integer limit) throws IOException {
    Path path = safePath(pathStr);
    String content = Files.readString(path);
    if (limit != null && limit  inputArgs = (Map) block.get("input");

// 根据工具名查找处理器
ToolExecutor handler = TOOL_HANDLERS.get(toolName);
String output;
try {
    if (handler != null) {
        output = handler.execute(inputArgs);  // 动态调用
    } else {
        output = "Error: Unknown tool " + toolName;
    }
} catch (Exception e) {
    output = "Error: " + e.getMessage();  // 统一错误处理
}

动态分派：根据LLM选择的工具名调用对应实现
统一错误处理：未知工具、执行异常都有统一格式的返回
解耦：主循环不需要知道具体工具的实现细节

架构对比与价值

从AgentLoop到AgentWithTools的演进：

维度	AgentLoop	AgentWithTools
工具数量	1个(Bash)	4+个(可扩展)
架构设计	硬编码	策略模式
添加新工具	修改主代码	注册表添加
文件操作	无	读写编辑
安全性	命令检查	沙箱路径
代码复用	低	高

核心价值：

可扩展性：添加新工具只需在注册表中添加一行
维护性：工具实现与主循环分离
安全性：统一的路径和权限控制
专业性：为开发任务优化的专用工具集

Ansible常用模块分类

2026-04-09T06:42:38.000Z

一、系统管理类

1. 计划任务与定时

crond（Linux 定时任务管理）
- 时间规则：minute（分钟）、hour（小时）、day（日期）、month（月份）、week（星期）
- 任务定义：job（要执行的命令/脚本，如 "/usr/bin/backup.sh"）
- 状态控制：state（present 新增任务、absent 删除任务）
- 场景：周期性日志切割、数据库备份
at（一次性定时任务）
- 时间参数：at_time（指定执行时间，如 "now + 1 hour"、"17:00 tomorrow" ）
- 任务内容：command（要执行的命令，如 "shutdown -r now" ）
- 状态控制：state（present 新增任务、absent 删除任务）
- 场景：系统维护前延迟重启

2. 用户与组管理

user（用户生命周期管理）
- 基础属性：name（用户名）、uid（用户 ID）、shell（默认 Shell，如 /bin/bash ）、create_home（是否创建家目录，yes/no ）
- 权限与密码：password（加密后的密码，需用 ansible-vault 或 mkpasswd 生成）、groups（附加用户组，如 ["wheel", "docker"] ）
- 状态控制：state（present 创建用户、absent 删除用户）
- 高级：expires（账户过期时间，Unix 时间戳）、remove（删除用户时是否连带删除家目录，yes/no ）
group（用户组管理）
- 基础属性：name（组名）、gid（组 ID）
- 状态控制：state（present 创建组、absent 删除组）
- 扩展：system（是否为系统组，yes/no ，影响组 ID 范围）

3. 系统配置与初始化

sysctl（内核参数调整）
- 参数设置：name（参数名，如 net.ipv4.ip_forward ）、value（参数值，如 1 开启 IP 转发）
- 持久化：state（present 确保参数生效并写入 /etc/sysctl.conf ）
- 场景：调整网络转发、文件描述符限制
lineinfile（精准修改配置文件行）
- 目标文件：path（要修改的文件路径，如 /etc/nginx/nginx.conf ）
- 内容控制：line（要写入的行，如 "worker_processes auto;" ）、regexp（匹配行的正则，用于替换或确保唯一）
- 状态：state（present 确保行存在、absent 删除行）
- 高级：backrefs（正则匹配时保留原内容）、insertafter/insertbefore（指定插入位置，如 EOF 前）

4. 软件包管理

yum（RHEL/CentOS 系列）
- 包操作：name（包名，支持列表/通配符，如 ["nginx", "python*"] ）
- 状态：state（present 安装、latest 升级到最新、absent 卸载）
- 缓存：update_cache（yes/no ，是否更新 yum 缓存）
- 扩展：disable_gpg_check（跳过 GPG 校验，yes/no ，非安全场景临时用）
apt（Debian/Ubuntu 系列）
- 包操作：name（包名，如 apache2、mysql-server ）
- 状态：state（present 安装、latest 升级、absent 卸载）
- 缓存：update_cache（yes/no ，更新 apt 缓存）
- 扩展：force（强制安装/覆盖依赖，yes/no ）
homebrew（macOS）
- 包操作：name（brew 包名，如 git、vim ）
- 状态：state（present 安装、latest 升级、absent 卸载）
- 扩展：install_options（安装选项，如 --with-python 编译时启用 Python 支持）

二、文件操作类

1. 基础文件管理

file（文件/目录属性、存在性控制）
- 路径：path（目标路径，如 /opt/app/config ）
- 类型与状态：state（directory 确保目录存在、file 确保文件存在、link 建软链接、absent 删除）
- 权限：mode（权限，如 0644、0755 ）、owner（属主）、group（属组）
- 高级：attributes（文件系统属性，如 +i 设为只读）
copy（本地→远程拷贝文件）
- 源与目标：src（控制节点的源文件/目录）、dest（目标主机路径，如 /tmp/upload/ ）
- 内容替代：content（直接写入文本内容，替代 src ，适合小配置）
- 权限：mode、owner、group（同 file 模块）
- 特殊：remote_src（yes 时，src 为目标主机本地路径，实现远程拷贝）
fetch（远程→本地拉取文件）
- 源与目标：src（目标主机文件路径，如 /var/log/syslog ）、dest（控制节点存储目录，自动按主机名分级）
- 扁平化：flat（yes 时，直接存为 dest 文件名，不分级）
- 过滤：fail_on_missing（文件不存在时是否失败，yes/no ）

2. 模板与变量渲染

template（带 Jinja2 渲染的文件拷贝）
- 源与目标：src（模板文件，含 {{ 变量 }} ，如 config.j2 ）、dest（目标路径，如 /etc/nginx/nginx.conf ）
- 变量传递：结合 Ansible 变量（Playbook vars、Inventory 变量等）
- 权限：mode、owner、group（同 file 模块）
- 高级：trim_blocks（去除 Jinja2 块的空行，yes/no ）、lstrip_blocks（左 trim 空格，yes/no ）

3. 归档与解压

archive（打包文件/目录）
- 源：path（要打包的文件/目录，支持通配符，如 /var/log/*.log ）
- 目标：dest（打包后的归档路径，如 /tmp/logs.tar.gz ）
- 格式：format（tar、gz、zip 等）
- 过滤：exclude_path（排除的路径，如 "/var/log/old" ）
unarchive（解压归档）
- 源与目标：src（归档文件路径，支持控制节点或远程主机路径）、dest（解压目标目录，如 /opt/app ）
- 来源：remote_src（yes 时，src 是目标主机路径；no 时，src 是控制节点路径）
- 权限：mode、owner、group（解压后文件权限）
- 特殊：extra_opts（解压额外参数，如 tar --strip-components=1 去掉一级目录）

三、网络管理类

1. 网络配置（Linux 网络）

nmcli（NetworkManager 管理）
- 连接管理：conn_name（连接名，如 "eth0-static" ）
- 类型：type（ethernet、bridge 等）
- IP 配置：ip4（IP 地址，如 192.168.1.10/24 ）、gw4（默认网关，如 192.168.1.1 ）
- DNS：dns4（DNS 服务器，如 8.8.8.8 ）
- 状态：state（present 确保存在、absent 删除、up/down 启停）
- 高级：master（桥接/ bonding 主设备，如 "br0" ）
network（传统网络脚本方式，兼容老系统）
- 网卡：name（网卡名，如 eth0 ）
- IP 配置：ip（IP 地址）、netmask（子网掩码）、gateway（网关）
- 状态：state（up/down 启停网卡）
- 持久化：bootproto（dhcp/static ，控制 /etc/sysconfig/network-scripts 配置）

2. 网络设备配置（网络设备自动化）

ios_config（Cisco IOS 设备）
- 配置来源：src（本地配置文件，如 ios_config.txt ）、lines（逐行命令，如 "interface GigabitEthernet0/1" ）
- 设备连接：provider（指定连接参数，如 host、username、password ）
- 操作：before（执行配置前的命令，如 "configure terminal" ）、after（执行配置后的命令，如 "write memory" ）
- 替换模式：replace（line 按行替换、block 按块替换）
- 回滚：backup（yes 时备份原有配置，用于回滚）
nxos_config（Cisco Nexus 设备）
- 类似 ios_config，适配 Nexus OS 特性（如 ACI 配置、Nexus 特有命令）
- 连接：provider 或使用 Ansible 网络连接插件

3. 网络服务与检测

uri（HTTP/HTTPS 服务检测与交互）
- 目标：url（请求地址，如 https://example.com/api ）
- 方法：method（GET、POST、PUT、DELETE 等）
- 参数：body（POST/PUT 数据，JSON 或表单，如 '{"key": "value"}' ）、headers（请求头，如 Content-Type: application/json ）
- 验证：status_code（期望返回状态码，如 200 ）、validate_certs（是否校验 SSL 证书，yes/no ）
- 结果：return_content（yes 时返回响应内容）
ping（基础网络连通性检测）
- 极简：无特殊参数，返回 pong 表示目标主机可连通
- 扩展：结合 ignore_errors 处理非强制检测场景（如监控任务不中断 Playbook ）

四、应用部署与容器类

1. 容器管理（Docker）

docker_image（镜像管理）
- 镜像：name（镜像名，如 nginx:latest ）
- 状态：state（present 确保存在、absent 删除、build 从 Dockerfile 构建）
- 构建：path（Dockerfile 路径，state=build 时用）、dockerfile（指定 Dockerfile 名，如 Dockerfile.prod ）
- 推送：push（yes 时推送到镜像仓库）、repository（推送的仓库地址，如 docker.io/username/repo ）
docker_container（容器管理）
- 容器：name（容器名，如 webserver ）、image（镜像名，如 nginx:alpine ）
- 网络与端口：ports（端口映射，如 80:8080 ）、networks（网络模式，如 bridge ）
- 存储：volumes（数据卷挂载，如 /host/path:/container/path ）
- 环境：env（环境变量，字典形式，如 {"DB_HOST": "db"} ）
- 状态：state（started 启动、stopped 停止、absent 删除、restarted 重启）

2. 代码与应用部署

git（代码仓库拉取）
- 仓库：repo（仓库地址，如 https://github.com/user/repo.git ）
- 目标：dest（本地路径，如 /opt/app ）
- 版本：version（分支、标签或提交 ID，如 main、v1.0 ）
- 强制：force（yes 时强制拉取覆盖本地修改）
- 深度：depth（克隆深度，如 1 只拉取最新提交，加速大仓库）
pip（Python 包管理）
- 包：name（包名，如 requests、django ）
- 状态：state（present 安装、latest 升级、absent 卸载）
- 版本：version（指定版本，如 django==4.0 ）
- 环境：virtualenv（虚拟环境路径，如 /opt/venv ）
- 索引：extra_args（指定 PyPI 源，如 -i https://pypi.tuna.tsinghua.edu.cn/simple ）

3. 中间件与服务管理

service（系统服务启停，兼容 Systemd/Upstart 等）
- 服务：name（服务名，如 httpd、nginx ）
- 状态：state（started 启动、stopped 停止、restarted 重启、reloaded 重载）
- 开机启动：enabled（yes/no ，是否开机自启）
- 扩展：args（启动参数，如 --debug ）
systemd（Systemd 专属管理，功能更细）
- 服务：name（服务单元名，如 nginx.service ）
- 状态：state（started、stopped 等，同 service ）
- 开机启动：enabled（yes/no ）、masked（yes 时屏蔽服务，无法启动）
- 重载：daemon_reload（yes 时重载 Systemd 单元文件）

五、监控与日志类

1. 日志与事件

syslog（写入系统日志）
- 日志内容：msg（日志信息，如 "Ansible 配置完成：nginx 启动" ）
- 日志级别：priority（日志优先级，如 info、warning、error ）
- 日志设备：facility（日志设备，如 user、daemon、local0 ）
- 目标主机：host（远程 syslog 服务器地址，默认写入本地）
logrotate（日志轮转配置）
- 目标文件：path（要轮转的日志路径，如 /var/log/nginx/access.log ）
- 轮转规则：rotate（保留份数，如 7 ）、daily/weekly/monthly（轮转频率）
- 压缩：compress（yes/no ，是否压缩旧日志）、delaycompress（延迟压缩，保留最新 1 份未压缩）
- 触发条件：size（达到指定大小轮转，如 100M ）
- 后置操作：postrotate（轮转后执行的命令，如 `”systemctl reload nginx

2. 系统指标与信息采集

setup（采集目标主机 Facts 信息）
- 采集范围：默认无参数时，采集全量系统信息（CPU型号/核心数、内存总量/使用率、磁盘分区、网卡IP、操作系统版本等）
- 过滤采集：filter（按规则筛选 Facts，支持通配符，如 ansible_mem* 仅采集内存相关、ansible_eth0 仅采集 eth0 网卡信息、ansible_distribution* 采集系统发行版相关）
- 自定义 Facts：fact_path（指定自定义 Facts 文件路径，如 /etc/ansible/facts.d，支持 .ini/.json/可执行脚本格式，脚本输出需符合 JSON 结构）
- 应用场景：基于 Facts 动态适配配置（如根据 ansible_memtotal_mb 设置 JVM 堆内存、根据 ansible_os_family 选择 yum/apt 模块）
stat（获取文件/目录详细属性）
- 目标路径：path（文件/目录路径，如 /etc/passwd、/var/log/nginx）
- 采集信息：返回 size（大小，单位字节）、mode（权限，如 0o644）、uid/gid（属主/属组ID）、mtime（最后修改时间）、ctime（最后状态变更时间）、checksum（文件校验和，默认 sha1）、exists（是否存在，布尔值）
- 结果处理：register（将采集结果存入变量，用于后续条件判断，如 if stat_result.stat.exists == true 则执行某任务）
- 扩展参数：follow（yes/no，是否跟随软链接，默认 no）、get_checksum（yes/no，是否计算文件校验和，默认 yes）、get_mime（yes/no，是否获取 MIME 类型，默认 yes）
service_facts（采集系统服务状态 Facts）
- 核心功能：专门采集所有系统服务的运行状态（running/stopped/failed）和开机启动状态（enabled/disabled/masked）
- 结果存储：信息存入 ansible_facts.services 字典变量，可通过 ansible_facts.services['nginx.service'].state 获取指定服务运行状态、ansible_facts.services['sshd.service'].status 获取开机启动状态
- 兼容性：自动适配 Systemd、Upstart、SysVinit 等主流服务管理系统，无需手动指定服务类型

3. 监控告警与检测

wait_for（等待资源就绪，常用于服务启动监控）
- 等待对象：
  - 端口监听：port（目标端口，如 80、3306）+ host（目标主机，默认 localhost）
  - 文件状态：path（目标文件路径，如 /var/run/nginx.pid）
  - 进程PID：pid（进程ID，需结合 register 从其他任务获取）
- 超时与重试：timeout（超时时间，默认 300 秒，超时则任务失败）、delay（开始等待前的延迟时间，如 5 秒，避免资源未开始初始化导致误判）、retries（重试次数，默认无限重试直到超时）
- 状态判断：state（started 等待端口监听/进程启动、present 等待文件存在、absent 等待文件删除）
- 应用场景：部署 Nginx 后等待 80 端口就绪再执行健康检查、数据库启动后等待 /var/run/mysqld/mysqld.sock 存在再执行初始化 SQL
sensu_check（Sensu 监控检查配置，社区模块）
- 检查基础配置：name（Sensu 检查名称，如 check_nginx_process）、command（监控执行命令，如 check-process.rb -p nginx -w 2 -c 1，表示进程数低于1报警、低于2警告）
- 执行频率：interval（检查间隔时间，单位秒，如 60 表示每分钟检查一次）
- 告警分发：subscribers（订阅该检查的客户端列表，如 ["web-server", "app-server"]）、handlers（触发告警时的处理程序，如 email、slack、pagerduty）
- 状态控制：state（present 新增检查配置、absent 删除检查配置）
- 依赖：需在目标主机提前部署 Sensu Client 并配置与 Sensu Server 通信

六、云服务与存储类

1. AWS 云服务模块

ec2（EC2 实例管理）
- 实例基础配置：image（AMI 镜像 ID，如 ami-0c55b159cbfafe1f0 对应 Amazon Linux 2）、instance_type（实例规格，如 t2.micro、c5.large）、key_name（SSH 密钥对名称，用于登录实例）
- 网络配置：vpc_subnet_id（子网 ID，如 subnet-12345678）、security_group_ids（安全组 ID 列表，如 ["sg-87654321"]）、associate_public_ip_address（yes/no，是否分配公网 IP）
- 存储配置：volumes（EBS 卷配置，格式为 [{"device_name": "/dev/sda1", "volume_size": 20, "volume_type": "gp2"}]，支持 gp2/gp3/io1 等卷类型）
- 状态控制：state（present 创建实例、absent 删除实例、running 启动实例、stopped 停止实例）
- 初始化：user_data（实例启动脚本，支持 cloud-init 格式，如 #!/bin/bash\nyum install -y nginx，用于实例初始化）
aws_s3（S3 存储桶与对象管理）
- 存储桶操作：bucket（桶名，需全局唯一）、state（present 创建桶、absent 删除桶）、region（AWS 地域，如 us-east-1、ap-beijing-1）、tags（桶标签，如 {"Environment": "production", "Project": "app"}）
- 对象操作：
  - 上传：mode: put + src（本地文件路径，如 /tmp/data.csv） + object（S3 中对象路径，如 data/202405.csv）
  - 下载：mode: get + object（S3 对象路径） + dest（本地存储路径，如 /tmp/download.csv）
  - 删除：mode: delete + object（S3 对象路径）
  - 列出：mode: list + prefix（对象路径前缀，如 data/2024，仅列出该前缀下的对象）
- 权限控制：aws_access_key/aws_secret_key（AWS 访问密钥，或通过环境变量、IAM 角色自动获取，推荐使用 IAM 角色避免硬编码密钥）
rds（RDS 数据库实例管理）
- 实例配置：db_instance_identifier（实例名，如 prod-mysql）、engine（数据库引擎，如 mysql、postgres、sqlserver-ex）、engine_version（引擎版本，如 8.0 对应 MySQL 8.0）
- 规格与存储：db_instance_class（实例规格，如 db.t3.small）、allocated_storage（存储大小，单位 GB，如 50）、storage_type（存储类型，如 gp2、io1）
- 账号配置：master_username（管理员用户名，如 admin）、master_user_password（管理员密码，建议用 ansible-vault 加密存储）
- 网络与安全：vpc_security_group_ids（安全组 ID 列表）、db_subnet_group_name（DB 子网组名，需提前创建）
- 状态控制：state（present 创建实例、absent 删除实例、running 启动实例、stopped 停止实例）

2. 存储管理

mount（文件系统挂载与持久化）
- 挂载基础信息：path（挂载点路径，如 /mnt/data，需提前创建目录）、src（设备/共享路径，如 /dev/sdb1（本地磁盘）、//192.168.1.100/share（Windows 共享）、192.168.1.101:/data（NFS 共享））
- 文件系统类型：fstype（如 ext4、xfs（本地磁盘）、cifs（Windows 共享）、nfs（NFS 共享））
- 状态控制：
  - mounted：立即挂载，并写入 /etc/fstab 实现开机自动挂载
  - unmounted：立即卸载，且从 /etc/fstab 中移除配置
  - present：仅写入 /etc/fstab，不立即挂载
  - absent：从 /etc/fstab 中移除配置，不影响当前挂载状态
- 挂载参数：opts（挂载选项，如 defaults,noatime（本地磁盘，禁用访问时间更新）、username=user,password=pass（CIFS 共享，指定登录账号密码）、rw,sync（NFS 共享，读写/同步模式））
lvg（逻辑卷组管理）
- 卷组基础：vg（卷组名，如 vg_data）、pvs（物理卷列表，如 ["/dev/sdb", "/dev/sdc"]，需提前初始化物理卷 pvcreate）
- 状态控制：state（present 创建卷组、absent 删除卷组（需先删除逻辑卷）、extended 扩展卷组（添加新物理卷，如 pvs: "/dev/sdd"））
- 扩展参数：force（yes/no，扩展卷组时强制添加物理卷，忽略“物理卷属于其他卷组”等警告，默认 no）
lvol（逻辑卷管理）
- 逻辑卷基础：lv（逻辑卷名，如 lv_app）、vg（所属卷组名，如 vg_data）
- 大小配置：size（逻辑卷大小，支持绝对值（如 50G、100M）和相对值（如 100%FREE 表示使用卷组所有剩余空间、+20G 表示在现有基础上增加 20G））
- 状态控制：state（present 创建逻辑卷、absent 删除逻辑卷（需先卸载文件系统）、resized 调整逻辑卷大小（需确保文件系统支持在线扩容，如 ext4/xfs））
- 扩展参数：force（yes/no，调整大小时强制操作，默认 no；扩容前建议备份数据，缩容需先缩小文件系统）

3. 其他云平台模块

azure_rm_virtualmachine（Azure 虚拟机管理）
- 实例配置：name（虚拟机名，如 prod-web-01）、resource_group（资源组名，如 prod-resource-group）、vm_size（实例规格，如 Standard_D2s_v3）
- 镜像配置：image（镜像参数，格式为 {"publisher": "Canonical", "offer": "UbuntuServer", "sku": "20.04-LTS", "version": "latest"}，或使用自定义镜像 ID）
- 网络配置：virtual_network_name（虚拟网络名）、subnet_name（子网名）、public_ip_allocation_method（公网 IP 分配方式，Dynamic 动态分配、Static 静态分配）
- 认证配置：admin_username（管理员用户名）、admin_password（密码，或 ssh_public_keys 指定 SSH 公钥）
- 状态控制：state（present 创建实例、absent 删除实例、started 启动实例、stopped 停止实例）
google.cloud.gcp_compute_instance（GCP 计算实例管理）
- 实例配置：name（实例名）、zone（可用区，如 us-central1-a）、machine_type（实例类型，如 n1-standard-1）
- 镜像配置：boot_disk（启动磁盘，格式为 {"source_image": "debian-cloud/debian-11", "size_gb": 20}，指定镜像和磁盘大小）
- 网络配置：network_interfaces（网卡配置，如 [{"network": "default", "access_configs": [{"name": "External NAT"}]}]，配置网络和公网访问）
- 认证配置：service_account_email（服务账号邮箱，用于权限控制）、credentials_file（GCP 凭证文件路径，或通过环境变量 GOOGLE_APPLICATION_CREDENTIALS 指定）
- 状态控制：state（present 创建实例、absent 删除实例、running 启动实例、stopped 停止实例）

七、通用工具与命令类

1. 命令执行模块（核心差异：Shell 特性支持）

command（非交互式执行命令，无 Shell 特性）
- 命令内容：cmd（执行的命令，如 ls /opt、cat /etc/hosts、systemctl status nginx）
- 条件跳过：creates（若指定文件存在则跳过命令，如 creates: /tmp/init.flag，用于避免重复执行初始化命令）、removes（若指定文件不存在则跳过命令，如 removes: /etc/nginx/nginx.conf，用于仅在配置文件存在时执行操作）
- 执行环境：chdir（执行命令前切换到目标目录，如 chdir: /opt/app，避免命令路径依赖问题）
- 限制：不支持管道（|）、重定向（>/>>/<）、环境变量（$HOME/$PATH）、通配符（*/?）等 Shell 特性，需复杂语法时用 shell 模块
shell（交互式执行命令，支持 Shell 特性）
- 命令内容：cmd（支持 Shell 语法的命令，如 ps aux | grep nginx（管道）、echo "test" > /tmp/file.txt（重定向）、echo $HOME（环境变量）、ls /opt/*.log（通配符））
- 通用参数：chdir、creates、removes（同 command 模块）
- 扩展参数：executable（指定 Shell 解释器，如 /bin/bash、/bin/sh，默认使用目标主机 $SHELL 或 /bin/sh）
- 风险提示：因支持 Shell 语法，需避免命令注入风险（如不直接拼接用户输入的变量，需用 quote 过滤器转义，如 cmd: "echo {{ user_input | quote }}"）
raw（无 Python 依赖，直接执行原始命令）
- 适用场景：目标主机未安装 Python 时（Ansible 绝大多数模块依赖 Python，raw 模块通过 SSH 直接执行命令，无需 Python 环境），常用于初始化 Python（如 raw: "yum install -y python3" 或 apt install -y python3）
- 命令内容：args（命令字符串，如 raw: "ssh-keygen -t rsa -N '' -f ~/.ssh/id_rsa"）
- 限制：不支持 Ansible 变量插值（需手动用 Shell 变量，如 raw: "echo $ENV_VAR"）、无结构化结果返回（仅返回命令输出文本，无法直接提取关键信息）、不支持 creates/removes 等条件参数

2. 脚本与程序执行

script（在目标主机执行控制节点本地脚本）
- 脚本路径：script（控制节点上的脚本路径，如 ./scripts/install_nginx.sh、/opt/ansible/scripts/init_db.sh，Ansible 会自动将脚本传输到目标主机临时目录并执行）
- 脚本参数：args（传递给脚本的参数，如 args: "arg1 arg2 --env production"，脚本内通过 $1/$2/$3 接收）
- 执行环境：chdir（执行脚本前切换到目标主机的指定目录，如 chdir: /opt/app，脚本内相对路径基于此目录）
- 优势：无需手动拷贝脚本到目标主机，减少文件传输步骤；支持任意脚本类型（Shell、Python、Perl 等，需脚本头部指定解释器，如 #!/bin/bash）
command_shell（社区模块，灵活切换执行模式）
- 核心参数：command（命令内容）、use_shell（yes/no，是否启用 Shell 特性，默认 no，即 command 模式；设为 yes 则切换为 shell 模式）
- 通用参数：chdir、creates、removes（同 command/shell 模块）
- 应用场景：需根据变量动态切换命令执行模式时（如 use_shell: "{{ use_complex_syntax | default('no') }}"，当 use_complex_syntax 为 yes 时启用 Shell 特性）

3. 变量与结果处理

set_fact（定义/修改 Facts 变量）
- 变量定义：支持多种数据类型，格式为 key=value：
  - 字符串：set_fact: app_version="1.0.0"
  - 数字：set_fact: max_connections=1000
  - 布尔值：set_fact: is_production={{ env == 'prod' }}（通过 Jinja2 表达式计算布尔值）
  - 列表：set_fact: web_servers=["192.168.1.10", "192.168.1.11", "192.168.1.12"]
  - 字典：set_fact: db_config={"host": "db.example.com", "port": 3306, "user": "admin"}
- 动态计算：支持 Jinja2 过滤器和表达式，如 set_fact: total_memory_gb="{{ ansible_memtotal_mb | int / 1024 | round(1) }}G"（将内存从 MB 转为 GB 并保留1位小数）
- 作用域：定义的变量属于 Facts 范畴，在当前 Play 内所有任务可见，可通过 {{ 变量名 }} 直接引用，优先级高于普通 Play 变量
debug（输出调试信息，用于 Playbook 排错）
- 输出方式：
  - 自定义消息：msg（自定义文本，支持变量插值，如 debug: msg="当前环境：{{ env }}, 应用版本：{{ app_version }}"）
  - 变量详情：var（输出指定变量的完整结构，包括嵌套层级，如 debug: var=db_config，会显示字典 db_config 的所有键值对）
  - 格式化输出：verbosity（调试级别，0-4，级别越高输出越详细，默认 0；设为 1 时，需执行 Playbook 加 -v 参数才显示，如 ansible-playbook -v site.yml）
- 应用场景：验证变量值是否符合预期（如检查 Inventory 变量是否正确加载）、查看任务执行结果（如 register 注册的命令输出、stat 模块采集的文件信息）、定位条件判断逻辑问题（如 debug: msg="条件成立" when: is_production）

七、通用工具与命令类（补充）

4. 条件与循环控制辅助模块

with_items/with_list（循环迭代，Ansible 2.5+ 推荐用 loop 替代）

核心功能：遍历列表数据，为每个元素执行一次任务，适用于批量操作（如批量安装软件、批量创建文件）

基础用法：loop: "{{ 列表变量 }}"（替代旧版 with_items），任务内通过 {{ item }} 引用当前元素

示例1（批量安装软件）：

- name: 批量安装依赖包
  apt:
    name: "{{ item }}"
    state: present
  loop: "{{ dependencies }}"  # dependencies 为列表变量：["curl", "git", "vim"]
  loop_control:
    label: "安装 {{ item }}"  # 自定义循环日志标签，增强可读性

示例2（批量创建文件）：

- name: 批量创建配置文件
  file:
    path: "/etc/{{ item }}"
    state: touch
    mode: 0644
  loop: ["app.conf", "db.conf", "log.conf"]

扩展用法：loop: "{{ query('inventory_hostnames', 'web_servers') }}"（结合 Inventory 插件，遍历指定组的主机名）

with_dict/loop + dict2items（字典迭代）

核心功能：遍历字典类型数据，获取键（key）和值（value），适用于批量配置键值对相关场景（如批量设置环境变量、批量创建用户并指定 UID）

基础用法：通过 loop: "{{ 字典变量 | dict2items }}" 转换字典为列表，任务内通过 {{ item.key }}/{{ item.value }} 引用键和值

示例（批量创建用户并指定 UID）：

- name: 批量创建用户（指定 UID）
  user:
    name: "{{ item.key }}"
    uid: "{{ item.value }}"
    state: present
  loop: "{{ user_uid_map | dict2items }}"  # user_uid_map 为字典：{"alice": 1001, "bob": 1002, "charlie": 1003}
  loop_control:
    label: "创建用户 {{ item.key }}（UID: {{ item.value }}）"

when（条件判断）

核心功能：根据条件决定任务是否执行，支持布尔值、比较运算、逻辑运算、Facts 变量判断等，实现任务的动态适配
常用条件场景：
- 基于操作系统：when: ansible_os_family == "Debian"（仅 Debian/Ubuntu 执行 apt 安装）、when: ansible_distribution == "CentOS"（仅 CentOS 执行 yum 操作）
- 基于变量值：when: env == "production"（生产环境执行某任务）、when: app_version is version("2.0.0", ">=")（版本号大于等于 2.0.0 时执行）
- 基于任务结果：when: stat_result.stat.exists（文件存在时执行）、when: command_result.rc == 0（命令执行成功时执行，rc 为返回码，0 表示成功）
- 逻辑组合：when: ansible_os_family == "RedHat" and ansible_memtotal_mb > 2048（RedHat 系统且内存大于 2G 时执行）

示例（按系统选择包管理器）：

- name: Debian 系列安装 nginx
  apt:
    name: nginx
    state: present
  when: ansible_os_family == "Debian"

- name: RedHat 系列安装 nginx
  yum:
    name: nginx
    state: present
  when: ansible_os_family == "RedHat"

5. 加密与安全模块

ansible-vault（文件加密，非 Playbook 模块，属 Ansible 命令行工具，常用于加密敏感文件）
- 核心功能：加密/解密 Ansible 敏感文件（如含密码的变量文件、Inventory 文件），避免敏感信息明文存储
- 常用命令：
  - 创建加密文件：ansible-vault create secrets.yml（交互式设置密码，创建后通过文本编辑器写入敏感内容）
  - 编辑加密文件：ansible-vault edit secrets.yml（输入密码后编辑，保存后自动重新加密）
  - 加密已有明文文件：ansible-vault encrypt plain.yml（将明文文件 plain.yml 加密为加密文件）
  - 解密文件（临时）：ansible-vault decrypt secrets.yml --output=plain_secrets.yml（解密为明文文件 plain_secrets.yml，谨慎使用）
  - 执行含加密文件的 Playbook：ansible-playbook -i inventory.yml site.yml --ask-vault-pass（执行时交互式输入 vault 密码）或 --vault-password-file=vault_pass.txt（从文件读取密码，需确保文件权限为 0600）
- 应用场景：存储数据库密码、云服务密钥、SSH 私钥等敏感信息，如 secrets.yml 中定义 db_password: "EncryptedPassword123"，Playbook 中通过 include_vars: secrets.yml 加载并引用
openssl_privatekey（生成 OpenSSL 私钥）
- 核心功能：在目标主机生成 RSA/ECC 私钥，用于 SSL/TLS 证书配置（如 Nginx HTTPS、API 服务加密）
- 核心参数：
  - path：私钥存储路径，如 /etc/nginx/ssl/server.key
  - size：RSA 密钥长度，如 2048 或 4096（推荐 4096 位增强安全性）
  - type：密钥类型，RSA（默认）或 ECC（椭圆曲线加密，效率更高）
  - mode：私钥文件权限，如 0600（仅属主可读，必须严格限制权限）
  - state：present（确保私钥存在，不存在则生成）、absent（删除私钥）
- 示例（生成 Nginx HTTPS 私钥）：
  1
  2
  3
  4
  5
  6
  - name: 生成 Nginx HTTPS 私钥（4096 位 RSA）
  openssl_privatekey:
  path: /etc/nginx/ssl/server.key
  size: 4096
  mode: 0600
  state: present

openssl_certificate（生成/签署 SSL 证书）

核心功能：生成自签名证书、CSR（证书签名请求）或通过 CA 签署证书，配合 openssl_privatekey 实现 HTTPS 配置
核心参数：
- path：证书存储路径，如 /etc/nginx/ssl/server.crt
- privatekey_path：对应私钥路径，如 /etc/nginx/ssl/server.key（与私钥关联）
- provider：证书生成方式，selfsigned（自签名，适用于测试/内部服务）、csr（生成 CSR 文件，用于向公共 CA 申请证书）、certificate_authority（通过自建 CA 签署证书）
- subject：证书主题信息，字典格式，如 {"CN": "example.com", "O": "MyCompany", "C": "CN", "ST": "Beijing", "L": "Beijing"}（CN 为域名，必须与服务访问域名一致）

示例（生成自签名 HTTPS 证书）：

- name: 生成 Nginx HTTPS 自签名证书
  openssl_certificate:
    path: /etc/nginx/ssl/server.crt
    privatekey_path: /etc/nginx/ssl/server.key
    provider: selfsigned
    subject:
      CN: example.com
      O: MyWebService
      C: CN
    state: present

八、特殊场景模块

1. Windows 系统管理模块

win_package（Windows 软件安装）
- 核心功能：在 Windows 主机安装 MSI 安装包或 exe 安装程序，支持静默安装
- 核心参数：
  - name：软件名称（用于标识已安装状态，如 "7-Zip 23.01 (x64)"）
  - path：安装程序路径（本地路径或网络共享路径，如 C:\installers\7z2301-x64.msi、\\fileserver\installers\Notepad++.exe）
  - product_id：MSI 包的 Product ID（可选，用于精准判断是否已安装，可通过 msiexec /i 安装包.msi /qb! /log install.log 安装后从注册表或日志获取）
  - arguments：安装参数（静默安装参数，如 MSI 用 /qn /norestart，exe 用 /S 或 /verysilent，需参考软件安装文档）
  - state：present（安装）、absent（卸载，仅支持 MSI 包）
- 示例（安装 7-Zip MSI 包）：
  1
  2
  3
  4
  5
  6
  - name: Windows 安装 7-Zip
  win_package:
  name: 7-Zip 23.01 (x64)
  path: C:\temp\7z2301-x64.msi
  arguments: /qn /norestart # 静默安装，不重启
  state: present
win_service（Windows 服务管理）
- 核心功能：管理 Windows 系统服务（启动/停止/重启/设置开机启动），类似 Linux 的 service 模块
- 核心参数：
  - name：服务名称（需用服务的“服务名称”而非“显示名称”，可通过 services.msc 查看，如 "wuauserv" 对应“Windows Update”服务）
  - state：started（启动）、stopped（停止）、restarted（重启）、reloaded（重载，部分服务支持）
  - start_mode：开机启动模式，auto（自动）、manual（手动）、disabled（禁用）
- 示例（启动并设置 Windows Update 服务为自动）：
  1
  2
  3
  4
  5
  - name: 启动 Windows Update 服务并设为自动启动
  win_service:
  name: wuauserv
  state: started
  start_mode: auto
win_copy（Windows 本地/远程文件拷贝）
- 核心功能：在 Windows 主机间或控制节点与 Windows 主机间拷贝文件，类似 Linux 的 copy 模块
- 核心参数：
  - src：源路径（控制节点路径或 Windows 主机本地路径，如 ./files/win_config.ini、C:\temp\old_config.ini）
  - dest：目标路径（Windows 主机路径，如 C:\ProgramData\app\config.ini）
  - remote_src：yes/no（yes 表示源路径在目标 Windows 主机本地，no 表示源路径在控制节点）
  - force：yes/no（yes 表示目标文件存在时强制覆盖，no 表示仅在目标文件不存在时拷贝）
- 示例（从控制节点拷贝配置文件到 Windows 主机）：
  1
  2
  3
  4
  5
  - name: 拷贝配置文件到 Windows 主机
  win_copy:
  src: ./files/app_config.ini
  dest: C:\Program Files\MyApp\config.ini
  force: yes

2. 数据库操作模块

mysql_db（MySQL 数据库管理）

核心功能：创建/删除 MySQL 数据库、导入 SQL 文件，需提前在目标主机安装 PyMySQL 或 mysqlclient Python 库（通过 pip 模块安装）
核心参数：
- name：数据库名（如 "app_db"）
- state：present（创建数据库）、absent（删除数据库，谨慎使用）、import（导入 SQL 文件）
- login_user：MySQL 登录用户名（如 "root"）
- login_password：MySQL 登录密码（建议通过 ansible-vault 加密存储）
- login_host：MySQL 服务器地址（默认 localhost，远程数据库需指定）
- login_port：MySQL 端口（默认 3306）
- target：state=import 时，指定 SQL 文件路径（如 /opt/sql/init_db.sql）

示例（创建 MySQL 数据库并导入初始化 SQL）：

- name: 安装 PyMySQL（MySQL 模块依赖）
  pip:
    name: PyMySQL
    state: present

- name: 创建 app_db 数据库
  mysql_db:
    name: app_db
    state: present
    login_user: root
    login_password: "{{ mysql_root_password }}"  # 加密变量
    login_host: localhost

- name: 导入 app_db 初始化 SQL
  mysql_db:
    name: app_db
    state: import
    target: /opt/sql/init_app_db.sql
    login_user: root
    login_password: "{{ mysql_root_password }}"

postgresql_db（PostgreSQL 数据库管理）

核心功能：类似 mysql_db，用于 PostgreSQL 数据库的创建/删除/导入，依赖 psycopg2 Python 库
核心参数：
- name：数据库名（如 "pg_app_db"）
- state：present（创建）、absent（删除）、import（导入 SQL）
- login_user：PostgreSQL 登录用户（如 "postgres"）
- login_password：PostgreSQL 登录密码
- login_host：PostgreSQL 服务器地址（默认 localhost）
- login_port：PostgreSQL 端口（默认 5432）
- target：state=import 时的 SQL 文件路径

示例（创建 PostgreSQL 数据库）：

- name: 安装 psycopg2（PostgreSQL 模块依赖）
  apt:
    name: python3-psycopg2
    state: present
  when: ansible_os_family == "Debian"

- name: 创建 pg_app_db 数据库
  postgresql_db:
    name: pg_app_db
    state: present
    login_user: postgres
    login_password: "{{ pg_postgres_password }}"

九、模块使用注意事项与最佳实践

1. 模块依赖检查

Python 依赖：绝大多数 Ansible 模块依赖 Python（如 yum/apt/file/copy 等），目标主机需提前安装 Python（Linux 通常预装，最小化系统需手动安装：CentOS 用 yum install -y python3，Ubuntu 用 apt install -y python3）
模块专属依赖：部分模块需额外安装依赖库，如：
- 数据库模块：mysql_db 依赖 PyMySQL/mysqlclient，postgresql_db 依赖 psycopg2
- 云服务模块：aws_s3/ec2 依赖 boto3/botocore，azure_rm_virtualmachine 依赖 azure-mgmt-compute
- 建议在 Playbook 开头通过 pip 模块统一安装依赖，如：
  1
  2
  3
  4
  - name: 安装 AWS 模块依赖
  pip:
  name: boto3
  state: present

2. 幂等性保障（核心原则）

定义：Ansible 模块需支持“幂等性”——即多次执行同一任务，结果一致且无副作用（如安装软件时，已安装则跳过；创建文件时，已存在则不重复创建）
关键参数：
- state: present（确保存在，已存在则跳过）而非 state: latest（强制升级，可能有风险）
- creates/removes（command/shell 模块实现幂等性的关键，避免重复执行命令）
- force: no（copy/template 模块默认值，仅在源文件变化时覆盖目标文件）

反例（非幂等）：

1 2	- name: 非幂等命令（每次执行都会追加内容） shell: echo "test" >> /tmp/log.txt # 多次执行会重复追加，无幂等性

正例（幂等）：

1
2
3

- name: 幂等命令（仅在文件不存在时执行）
  shell: echo "test" > /tmp/log.txt
  creates: /tmp/log.txt  # 文件存在则跳过，实现幂等性

3. 安全性最佳实践

敏感信息加密：使用 ansible-vault 加密含密码、密钥的文件，避免明文存储；执行 Playbook 时通过 --ask-vault-pass 或安全的密码文件（权限 0600）传递密码
最小权限原则：避免用 root 执行所有任务，可通过 become: yes 按需提权，或在 Inventory 中指定普通用户+sudo 权限
避免命令注入：shell 模块使用变量时，通过 quote 过滤器转义，如 cmd: "echo {{ user_input | quote }}"
模块优先于 raw/shell：能用官方模块（如 file/copy/service）实现的功能，优先不用 raw/shell，减少脚本依赖和安全风险

CDN部署

2026-04-09T06:42:38.000Z

视图预览

阿里云 CDN 每秒访问次数，下行流量，边缘带宽，响应时间，回源带宽，状态码等

版本支持

操作系统支持：Linux

前置条件

服务器 <安装 Datakit>
服务器 <安装 Func 携带版>
阿里云 RAM 访问控制账号授权

RAM 访问控制

登录 RAM 控制台 https://ram.console.aliyun.com/users
新建用户：人员管理 - 用户 - 创建用户

保存或下载 AccessKey ID 和 AccessKey Secret 的 CSV 文件 (配置文件会用到)
用户授权 (只读访问所有阿里云资源的权限)

安装配置

说明：

示例 Linux 版本为：CentOS Linux release 7.8.2003 (Core)
通过一台服务器采集所有阿里云 CDN 数据

部署实施

脚本市场

开启脚本市场，管理 - 实验性功能 - 开启脚本市场模块

**依次添加 **三个脚本集
1. 观测云集成 (核心包)
2. 观测云集成 (阿里云-云监控)
3. 观测云集成 (阿里云-CDN)

注：在安装「核心包」后，系统会提示安装第三方依赖包，按照正常步骤点击安装即可

脚本安装完成后，可以在脚本库中看到所有脚本集

添加脚本

开发 - 脚本库 - 添加脚本集

点击该脚本集 - 添加脚本

创建 ID 为 main 的脚本

添加代码 (需要修改账号配置 AccessKey ID/AccessKey Secret/Account Name)

from guance_integration__runner import Runner        # 引入启动器
import guance_aliyun_cdn__main as aliyun_cdn         # 引入阿里云NAT采集器
import guance_aliyun_monitor__main as aliyun_monitor # 引入阿里云云监控采集器

# 账号配置
account = {
    'ak_id'     : 'AccessKey ID',
    'ak_secret' : 'AccessKey Secret',
    'extra_tags': {
        'account_name': 'Account Name',
    }
}

# 由于采集数据较多，此处需要为函数指定更大的超时时间（单位秒）
@DFF.API('执行云资产同步', timeout=300)
def run():
    # 采集器配置
    common_aliyun_configs = {
        'regions': [ 'cn-hangzhou' ], #阿里云CDN对应的地域
    }
    monitor_collector_configs = {
        'targets': [
            { 'namespace': 'acs_cdn', 'metrics': 'ALL' }, # 采集云监控中CDN所有指标
        ],
    }

    # 创建采集器
    collectors = [
        aliyun_cdn.DataCollector(account, common_aliyun_configs),
        aliyun_monitor.DataCollector(account, monitor_collector_configs),
    ]

    # 启动执行
    Runner(collectors).run()

**保存 **配置并发布

定时任务

添加自动触发任务，管理 - 自动触发配置 - 新建任务

自动触发配置，执行函数中添加此脚本，执行频率为 **5分钟 */5 * * * * **(1分钟会被阿里限流)

指标预览

场景视图

<场景 - 新建仪表板 - 内置模板库 - 阿里云 CDN>

指标详解

<阿里云 CDN 指标列表>

常见问题排查

查看日志：Func 日志路径 /usr/local/dataflux-func/data/logs/dataflux-func.log
代码调试：选择主函数，直接运行 (可以看到脚本输出)

连接配置：Func 无法连接 Datakit，请检查数据源配置

Dubbo SPI机制

2026-04-09T06:42:38.000Z

Dubbo SPI 机制

EIP指标监控

2026-04-09T06:42:38.000Z

视图预览

阿里云 EIP 指标展示，包括网络带宽，网络数据包，限速丢包率，带宽利用率等

版本支持

操作系统支持：Linux

前置条件

服务器 <安装 Datakit>
服务器 <安装 Func 携带版>
阿里云 RAM 访问控制账号授权

RAM 访问控制

登录 RAM 控制台 https://ram.console.aliyun.com/users
新建用户：人员管理 - 用户 - 创建用户

保存或下载 AccessKey ID 和 AccessKey Secret 的 CSV 文件 (配置文件会用到)
用户授权 (云监控只读/时序指标数据权限)

安装配置

说明：

示例 Linux 版本为：CentOS Linux release 7.8.2003 (Core)
通过一台服务器采集所有阿里云 EIP 数据

部署实施

脚本市场

开启脚本市场，管理 - 实验性功能 - 开启脚本市场模块

载入阿里云数据同步脚本，管理 - 脚本市场 - 阿里云数据同步 (云监控)

添加脚本

阿里云数据同步 (云监控) - 添加脚本

输入标题/描述信息

编辑脚本并复制代码，从 (同步阿里云监控数据) 到当前脚本
修改阿里云账号配置 (Ram 访问控制)

1 2	'aliyun_ak_id' : 'AccessKey ID', 'aliyun_ak_secret': 'AccessKey Secret',

修改阿里云 EIP 指标

'metric_targets': [
    {
        'namespace': 'acs_vpc_eip',
        'metrics': 'ALL',
     }           
                  ]

**保存 **配置并发布

定时任务

添加自动触发任务，管理 - 自动触发配置 - 新建任务

自动触发配置，执行函数中添加此脚本，其他默认即可

指标预览

场景视图

<场景 - 新建仪表板 - 内置模板库 - 阿里云 EIP>

监控规则

<监控 - 模板新建 - 阿里云 EIP 检测库>

指标详解

<阿里云 EIP 指标列表>

故障排查

查看日志：Func 日志路径 /usr/local/dataflux-func/data/logs/dataflux-func.log
代码调试：选择主函数，直接运行 (可以看到脚本输出)

连接配置：Func 无法连接 Datakit，请检查数据源配置

Hadoop--HDFS-HA高可用

2026-04-09T06:42:38.000Z

high avilability

HA概述

1）所谓HA（High Availablity），即高可用（7*24小时不中断服务）。

2）实现高可用最关键的策略是消除单点故障。HA严格来说应该分成各个组件的HA机制：HDFS的HA和YARN的HA。

3）Hadoop2.0之前，在HDFS集群中NameNode存在单点故障（SPOF）。

4）NameNode主要在以下两个方面影响HDFS集群

NameNode机器发生意外，如宕机，集群将无法使用，直到管理员重启NameNode机器需要升级，包括软件、硬件升级，此时集群也将无法使用

HDFS HA功能通过配置Active/Standby两个NameNodes实现在集群中对NameNode的热备来解决上述问题。如果出现故障，如机器崩溃或机器需要升级维护，这时可通过此种方式将NameNode很快的切换到另外一台机器。

HDFS-HA工作机制

通过双NameNode消除单点故障

**HDFS-HA工作要点

元数据管理方式需要改变

内存中各自保存一份元数据；

Edits日志只有Active状态的NameNode节点可以做写操作；

两个NameNode都可以读取Edits；

共享的Edits放在一个共享存储中管理（qjournal和NFS两个主流实现）；

需要一个状态管理功能模块

实现了一个zkfailover，常驻在每一个namenode所在的节点，每一个zkfailover负责监控自己所在NameNode节点，利用zk进行状态标识，当需要进行状态切换时，由zkfailover来负责切换，切换时需要防止brain split现象的发生。

必须保证两个NameNode之间能够ssh无密码登录
隔离（Fence），即同一时刻仅仅有一个NameNode对外提供服务

HDFS-HA*自动故障转移工作**机制*

前面学习了使用命令hdfs haadmin -failover手动进行故障转移，在该模式下，即使现役NameNode已经失效，系统也不会自动从现役NameNode转移到待机NameNode，下面学习如何配置部署HA自动进行故障转移。自动故障转移为HDFS部署增加了两个新组件：ZooKeeper和ZKFailoverController（ZKFC）进程，如图3-20所示。ZooKeeper是维护少量协调数据，通知客户端这些数据的改变和监视客户端故障的高可用服务。HA的自动故障转移依赖于ZooKeeper的以下功能：

1**）****故障检测：**集群中的每个NameNode在ZooKeeper中维护了一个持久会话，如果机器崩溃，ZooKeeper中的会话将终止，ZooKeeper通知另一个NameNode需要触发故障转移。

2**）****现役NameNode选择：**ZooKeeper提供了一个简单的机制用于唯一的选择一个节点为active状态。如果目前现役NameNode崩溃，另一个节点可能从ZooKeeper获得特殊的排外锁以表明它应该成为现役NameNode。

ZKFC是自动故障转移中的另一个新组件，是ZooKeeper的客户端，也监视和管理NameNode的状态。每个运行NameNode的主机也运行了一个ZKFC进程，ZKFC负责：

**1）****健康监测：**ZKFC使用一个健康检查命令定期地ping与之在相同主机的NameNode，只要该NameNode及时地回复健康状态，ZKFC认为该节点是健康的。如果该节点崩溃，冻结或进入不健康状态，健康监测器标识该节点为非健康的。

2**）****ZooKeeper会话管理：**当本地NameNode是健康的，ZKFC保持一个在ZooKeeper中打开的会话。如果本地NameNode处于active状态，ZKFC也保持一个特殊的znode锁，该锁使用了ZooKeeper对短暂节点的支持，如果会话终止，锁节点将自动删除。

**3）****基于ZooKeeper的选择：**如果本地NameNode是健康的，且ZKFC发现没有其它的节点当前持有znode锁，它将为自己获取该锁。如果成功，则它已经赢得了选择，并负责运行故障转移进程以使它的本地NameNode为Active。故障转移进程与前面描述的手动故障转移相似，首先如果必要保护之前的现役NameNode，然后本地NameNode转换为Active状态。

HDFS-HA集群配置

环境准备

修改IP
修改主机名及主机名和IP地址的映射
关闭防火墙
ssh免密登录
安装JDK，配置环境变量等

规划集群

hadoop102	hadoop103	hadoop104
NameNode	NameNode
ZKFC	ZKFC
JournalNode	JournalNode	JournalNode
DataNode	DataNode	DataNode
ZK	ZK	ZK
	ResourceManager
NodeManager	NodeManager	NodeManager

配置Zookeeper集群

集群规划

在hadoop102、hadoop103和hadoop104三个节点上部署Zookeeper。

解压安装

（1）解压Zookeeper安装包到/opt/module/目录下

[atguigu@hadoop102 software]$ tar -zxvf zookeeper-3.4.14.tar.gz -C /opt/module/

（2）在/opt/module/zookeeper-3.4.14/这个目录下创建zkData

mkdir -p zkData

（3）重命名/opt/module/zookeeper-3.4.14/conf这个目录下的zoo_sample.cfg为zoo.cfg

mv zoo_sample.cfg zoo.cfg

配置zoo.cfg文件
（1）具体配置

dataDir=/opt/module/zookeeper-3.4.14/zkData

增加如下配置

#######################cluster##########################

server.2=hadoop102:2888:3888

server.3=hadoop103:2888:3888

server.4=hadoop104:2888:3888

（2）配置参数解读

Server.A=B:C:D。

A是一个数字，表示这个是第几号服务器；

B是这个服务器的IP地址；

C是这个服务器与集群中的Leader服务器交换信息的端口；

D是万一集群中的Leader服务器挂了，需要一个端口来重新进行选举，选出一个新的Leader，而这个端口就是用来执行选举时服务器相互通信的端口。

集群模式下配置一个文件myid，这个文件在dataDir目录下，这个文件里面有一个数据就是A的值，Zookeeper启动时读取此文件，拿到里面的数据与zoo.cfg里面的配置信息比较从而判断到底是哪个server。

集群操作

（1）在/opt/module/zookeeper-3.4.14/zkData目录下创建一个myid的文件

touch myid

添加myid文件，注意一定要在linux里面创建，在notepad++里面很可能乱码

（2）编辑myid文件

vi myid

在文件中添加与server对应的编号：如2

（3）拷贝配置好的zookeeper到其他机器上

scp -r zookeeper-3.4.14/ root@hadoop103.atguigu.com:/opt/app/

scp -r zookeeper-3.4.14/ root@hadoop104.atguigu.com:/opt/app/

并分别修改myid文件中内容为3、4

（4）分别启动zookeeper

[root@hadoop102 zookeeper-3.4.14]# bin/zkServer.sh start

[root@hadoop103 zookeeper-3.4.14]# bin/zkServer.sh start

[root@hadoop104 zookeeper-3.4.14]# bin/zkServer.sh start

（5）查看状态

[root@hadoop102 zookeeper-3.4.14]# bin/zkServer.sh status

JMX enabled by default

Using config: /opt/module/zookeeper-3.4.14/bin/../conf/zoo.cfg

Mode: follower

[root@hadoop103 zookeeper-3.4.14]# bin/zkServer.sh status

JMX enabled by default

Using config: /opt/module/zookeeper-3.4.14/bin/../conf/zoo.cfg

Mode: leader

[root@hadoop104 zookeeper-3.4.5]# bin/zkServer.sh status

JMX enabled by default

Using config: /opt/module/zookeeper-3.4.14/bin/../conf/zoo.cfg

Mode: follower

配置HDFS-HA集群

官方地址：http://hadoop.apache.org/
在opt目录下创建一个ha文件夹

mkdir ha

将/opt/app/下的 hadoop-3.1.3拷贝到/opt/ha目录下

cp -r hadoop-3.1.3/ /opt/ha/

配置hadoop-env.sh

export JAVA_HOME=/opt/module/jdk1.8.0_144

配置core-site.xml

fs.defaultFS hdfs://mycluster hadoop.data.dir /opt/module/hadoop-3.1.3/data

配置hdfs-site.xml

    dfs.namenode.name.dir
    file://${hadoop.data.dir}/name


    dfs.datanode.data.dir
    file://${hadoop.data.dir}/data


    dfs.nameservices
    mycluster


    dfs.ha.namenodes.mycluster
    nn1,nn2, nn3


    dfs.namenode.rpc-address.mycluster.nn1
    hadoop102:8020


    dfs.namenode.rpc-address.mycluster.nn2
    hadoop103:8020


    dfs.namenode.rpc-address.mycluster.nn3
    hadoop104:8020


    dfs.namenode.http-address.mycluster.nn1
    hadoop102:9870


    dfs.namenode.http-address.mycluster.nn2
    hadoop103:9870


    dfs.namenode.http-address.mycluster.nn3
    hadoop104:9870


    dfs.namenode.shared.edits.dir
    qjournal://hadoop102:8485;hadoop103:8485;hadoop104:8485/mycluster


    dfs.client.failover.proxy.provider.mycluster
    org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider


    dfs.ha.fencing.methods
    sshfence


    dfs.ha.fencing.ssh.private-key-files
    /home/atguigu/.ssh/id_ecdsa


    dfs.journalnode.edits.dir
    ${hadoop.data.dir}/jn

拷贝配置好的hadoop环境到其他节点

启动HDFS-HA集群

在各个JournalNode节点上，输入以下命令启动journalnode服务
hdfs –daemon start journalnode
在[nn1]上，对其进行格式化，并启动
bin/hdfs namenode -format
hdfs –daemon start namenode
在[nn2]和[nn3]上，同步nn1的元数据信息
hdfs namenode -bootstrapStandby
启动[nn2]和[nn3]
hdfs –daemon start namenode
查看web页面显示，

hadoop102(standby)

hadoop103(standby)

hadoop104(standby)

在所有节点上上，启动datanode
hdfs –daemon start datanode
将[nn1]切换为Active
bin/hdfs haadmin -transitionToActive nn1

5. 查看是否Active

hdfs haadmin -getServiceState nn1

配置HDFS-HA自动故障转移

具体配置
（1）在hdfs-site.xml中增加

dfs.ha.automatic-failover.enabledtrue

（2）在core-site.xml文件中增加

ha.zookeeper.quorumhadoop102:2181,hadoop103:2181,hadoop104:2181

启动
（1）关闭所有HDFS服务：

stop-dfs.sh

（2）启动Zookeeper集群：

zkServer.sh start

（3）初始化HA在Zookeeper中状态：

hdfs zkfc -formatZK

（4）启动HDFS服务：

start-dfs.sh

验证
（1）将Active NameNode进程kill

kill -9 namenode的进程id

（2）将Active NameNode机器断开网络

service network stop

YARN-HA配置

YARN-HA工作机制

官方文档：

http://hadoop.apache.org/docs/r3.1.3/hadoop-yarn/hadoop-yarn-site/ResourceManagerHA.html

YARN-HA工作机制，如图3-23所示

图3-22 YARN-HA工作机制

配置YARN-HA集群

环境准备

（1）修改IP

（2）修改主机名及主机名和IP地址的映射

（3）关闭防火墙

（4）ssh免密登录

（5）安装JDK，配置环境变量等

（6）配置Zookeeper集群

规划集群

hadoop102	hadoop103	hadoop104
NameNode	NameNode
JournalNode	JournalNode	JournalNode
DataNode	DataNode	DataNode
ZK	ZK	ZK
ResourceManager	ResourceManager
NodeManager	NodeManager	NodeManager

具体配置

（1）yarn-site.xml

        yarn.nodemanager.aux-services
        mapreduce_shuffle




        yarn.resourcemanager.ha.enabled
        true




        yarn.resourcemanager.cluster-id
        cluster-yarn1



        yarn.resourcemanager.ha.rm-ids
        rm1,rm2



        yarn.resourcemanager.hostname.rm1
        hadoop102



        yarn.resourcemanager.hostname.rm2
        hadoop103




        yarn.resourcemanager.zk-address
        hadoop102:2181,hadoop103:2181,hadoop104:2181




        yarn.resourcemanager.recovery.enabled
        true




        yarn.resourcemanager.store.class     org.apache.hadoop.yarn.server.resourcemanager.recovery.ZKRMStateStore

（2）同步更新其他节点的配置信息

启动hdfs

（1）在各个JournalNode节点上，输入以下命令启动journalnode服务：

hdfs –daemon start journalnode

（2）在[nn1]上，对其进行格式化，并启动：

hdfs namenode -format

hdfs –daemon start namenode

（3）在[nn2]上，同步nn1的元数据信息：

hdfs namenode -bootstrapStandby

（4）启动[nn2]：

hdfs –daemon start namenode

（5）启动所有DataNode

hdfs –-daemon start datanode

（6）将[nn1]切换为Active

hdfs haadmin -transitionToActive nn1

启动YARN

（1）在hadoop102中执行：

start-yarn.sh

（2）在hadoop103中执行：

yarn –daemon start resourcemanager

（3）查看服务状态，如图3-24所示

yarn rmadmin -getServiceState rm1

HDFS Federation架构设计

NameNode架构的局限性

（1）Namespace（命名空间）的限制

由于NameNode在内存中存储所有的元数据（metadata），因此单个NameNode所能存储的对象（文件+块）数目受到NameNode所在JVM的heap size的限制。50G的heap能够存储20亿（200million）个对象，这20亿个对象支持4000个DataNode，12PB的存储（假设文件平均大小为40MB）。随着数据的飞速增长，存储的需求也随之增长。单个DataNode从4T增长到36T，集群的尺寸增长到8000个DataNode。存储的需求从12PB增长到大于100PB。

（2）隔离问题

由于HDFS仅有一个NameNode，无法隔离各个程序，因此HDFS上的一个实验程序就很有可能影响整个HDFS上运行的程序。

（3）性能的瓶颈由于是单个NameNode的HDFS架构，因此整个HDFS文件系统的吞吐量受限于单个NameNode的吞吐量。

HDFS Federation架构设计，如图3-25所示

能不能有多个NameNode

表3-3

NameNode	NameNode	NameNode
元数据	元数据	元数据
Log	machine	电商数据/话单数据

HDFS Federation应用思考

不同应用可以使用不同NameNode进行数据管理

图片业务、爬虫业务、日志审计业务

Hadoop生态系统中，不同的框架使用不同的NameNode进行管理NameSpace。（隔离性）

CPU多进程切换导致过载-CPU上下文切换

2026-04-09T06:42:38.000Z

Linux 支持远大于 CPU 数量的任务同时运行。系统在很短的时间内，将 CPU 轮流分配给它们，造成多任务同时运行的错觉。过多的上下文切换，会把 CPU 时间消耗在寄存器、内核栈以及虚拟内存等数据的保存和恢复上，从而缩短进程真正运行的时间，导致系统的整体性能大幅下降。

每个进程运行前，系统事先帮它设置好 CPU 寄存器和程序计数器（Program Counter，PC）。

CPU 上下文：
- CPU 寄存器，是 CPU 内置的容量小、但速度极快的内存。
- 程序计数器，则是用来存储 CPU 正在执行的指令位置、或者即将执行的下一条指令位置。
CPU 上下文切换
- 把前一个任务的 CPU 上下文（也就是 CPU 寄存器和程序计数器）保存起来，然后加载新任务的上下文到这些寄存器和程序计数器，最后再跳转到程序计数器所指的新位置，运行新任务。
- 保存下来的上下文，会存储在系统内核中，并在任务重新调度执行时再次加载进来
根据任务的不同， CPU 上下文切换场景
- 进程上下文切换
- 线程上下文切换
- 中断上下文切换

系统调用–特权模式切换–同进程CPU上下文切换

系统调用过程通常称为特权模式切换，而不是上下文切换。但实际上，系统调用过程中，CPU 的上下文切换还是无法避免的。

进程的运行空间：进程在用户空间运行时，被称为进程的用户态，而陷入内核空间的时候，被称为进程的内核态。
- 内核空间（Ring 0）具有最高权限，可以直接访问所有资源；
- 用户空间（Ring 3）只能访问受限资源，不能直接访问内存等硬件设备，必须通过系统调用陷入到内核中，才能访问这些特权资源。
系统调用 eg：当我们查看文件内容时，就需要多次系统调用来完成：首先调用 open() 打开文件，然后调用 read() 读取文件内容，并调用 write() 将内容写到标准输出，最后再调用 close() 关闭文件。
一次系统调用的过程，其实是发生了两次 CPU 上下文切换。
- CPU 寄存器里原来用户态的指令位置，需要先保存起来。接着，为了执行内核态代码，CPU 寄存器需要更新为内核态指令的新位置。最后才是跳转到内核态运行内核任务。
- 而系统调用结束后，CPU 寄存器需要恢复原来保存的用户态，然后再切换到用户空间，继续运行进程。

进程上下文切换

与系统调用的区别

进程上下文切换，是指从一个进程切换到另一个进程运行。进程的切换只能发生在内核态。所以，进程的上下文不仅包括了虚拟内存、栈、全局变量等用户空间的资源，还包括了内核堆栈、寄存器等内核空间的状态。
- 比系统调用时多了一步：在保存当前进程的内核状态和 CPU 寄存器之前，需要先把该进程的虚拟内存、栈等保存下来；而加载了下一进程的内核态后，还需要刷新进程的虚拟内存和用户栈。
而系统调用过程中一直是同一个进程在运行。不会涉及到虚拟内存等进程用户态的资源，也不会切换进程

上下文切换时机–进程调度

进程调度的时候，才需要切换上下文。Linux 为每个 CPU 都维护了一个就绪队列，将活跃进程（即正在运行和正在等待 CPU 的进程）按照优先级和等待 CPU 的时间排序，优先级最高和等待 CPU 时间最长的进程来运行。

时间片耗尽
**系统资源不足，**挂起，要等到满足才可以运行
自主挂起，sleep
优先级更高的到来时
硬件中断，会被中断挂起，之后执行内核中的中断服务程序

线程上下文切换

线程是调度的基本单位，而进程则是资源拥有的基本单位。

内核中的任务调度，实际上的调度对象是线程；而进程只是给线程提供了虚拟内存、全局变量等资源。

前后两个线程属于不同进程。此时，因为资源不共享，所以切换过程就跟进程上下文切换是一样
前后两个线程属于同一个进程。此时，因为虚拟内存是共享的，所以在切换时，虚拟内存这些资源就保持不动，只需要切换线程的私有数据、寄存器等不共享的数据。

中断上下文切换–短小快

中断处理比进程拥有更高的优先级。为了快速响应硬件的事件，中断处理会打断进程的正常调度和执行，转而调用中断处理程序，响应设备事件。

中断上下文切换并不涉及到进程的用户态。所以，即便中断过程打断了一个正处在用户态的进程，也不需要保存和恢复这个进程的虚拟内存、全局变量等用户态资源。

中断上下文，其实只包括内核态中断服务程序执行所必需的状态，包括 CPU 寄存器、内核堆栈、硬件中断参数等。

查看系统的上下文切换情况-vmstat

过多的上下文切换，会把 CPU 时间消耗在寄存器、内核栈以及虚拟内存等数据的保存和恢复上

vmstat 是一个常用的系统性能分析工具，主要用来分析系统的内存使用情况，也常用来分析 CPU 上下文切换和中断的次数。系统总体的上下文切换情况:

pidstat -w 参数表示输出进程切换指标，而 -u 参数则表示输出 CPU 使用指标

pidstat 默认显示进程的指标数据，加上 -t 参数后，才会输出线程的指标。也就是-wt

cswch ，表示每秒自愿上下文切换（voluntary context switches）的次数：进程无法获取所需资源，导致的上下文切换。比如说， I/O、内存等系统资源不足时，就会发生自愿上下文切换。
nvcswch ，表示每秒非自愿上下文切换（non voluntary context switches）的次数：进程由于时间片已到等原因，被系统强制调度，进而发生的上下文切换。比如说，大量进程都在争抢 CPU 时，就容易发生非自愿上下文切换。

实验：

sysbench 来模拟系统多线程调度切换的瓶颈情况，是一个多线程的基准测试工具，一般用来评估不同系统参数下的数据库负载情况。当然，在这次案例中，我们只把它当成一个异常进程来看，作用是模拟上下文切换过多的问题。

1 2	# 以 10 个线程运行 5 分钟的基准测试，模拟多线程切换的问题 $ sysbench --threads=10 --max-time=300 threads run

vmstat 1
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 6  0      0 6487428 118240 1292772    0    0     0     0 9019 1398830 16 84  0  0  0
 8  0      0 6487428 118240 1292772    0    0     0     0 10191 1392312 16 84  0  0  0

r 列：就绪队列的长度已经到了 8，远远超过了系统 CPU 的个数 2，所以肯定会有大量的 CPU 竞争。
us（user）和 sy（system）列：这两列的 CPU 使用率加起来上升到了 100%，其中系统 CPU 使用率，也就是 sy 列高达 84%，说明** CPU 主要是被内核占用了。**
in 列：中断次数也上升到了 1 万左右，说**明中断处理也是个潜在的问题。**

# 每隔 1 秒输出 1 组数据（需要 Ctrl+C 才结束）
# -w 参数表示输出进程切换指标，而 -u 参数则表示输出 CPU 使用指标
$ pidstat -w -u 1
08:06:33      UID       PID    %usr %system  %guest   %wait    %CPU   CPU  Command
08:06:34        0     10488   30.00  100.00    0.00    0.00  100.00     0  sysbench
08:06:34        0     26326    0.00    1.00    0.00    0.00    1.00     0  kworker/u4:2
 
08:06:33      UID       PID   cswch/s nvcswch/s  Command
08:06:34        0         8     11.00      0.00  rcu_sched
08:06:34        0        16      1.00      0.00  ksoftirqd/1
08:06:34        0       471      1.00      0.00  hv_balloon
08:06:34        0      1230      1.00      0.00  iscsid
08:06:34        0      4089      1.00      0.00  kworker/1:5
08:06:34        0      4333      1.00      0.00  kworker/0:3
08:06:34        0     10499      1.00    224.00  pidstat
08:06:34        0     26326    236.00      0.00  kworker/u4:2
08:06:34     1000     26784    223.00      0.00  sshd

# 每隔 1 秒输出一组数据（需要 Ctrl+C 才结束）
# -wt 参数表示输出线程的上下文切换指标
$ pidstat -wt 1
08:14:05      UID      TGID       TID   cswch/s nvcswch/s  Command
...
08:14:05        0     10551         -      6.00      0.00  sysbench
08:14:05        0         -     10551      6.00      0.00  |__sysbench
08:14:05        0         -     10552  18911.00 103740.00  |__sysbench
08:14:05        0         -     10553  18915.00 100955.00  |__sysbench
08:14:05        0         -     10554  18827.00 103954.00  |__sysbench
...

除了上下文切换频率骤然升高，还有一个指标也有很大的变化，中断次数。

pidstat 只是一个进程的性能分析工具，并不提供任何关于中断的详细信息

/proc 实际上是 Linux 的一个虚拟文件系统，用于内核空间与用户空间之间的通信。/proc/interrupts 就是这种通信机制的一部分，提供了一个只读的中断使用情况。

# -d 参数表示高亮显示变化的区域
$ watch -d cat /proc/interrupts
           CPU0       CPU1
...
RES:    2450431    5279697   Rescheduling interrupts

变化速度最快的是重调度中断（RES），这个中断类型表示，唤醒空闲状态的 CPU 来调度新的任务运行。这是多处理器系统（SMP）中，调度器用来分散任务到不同 CPU 的机制，通常也被称为处理器间中断（Inter-Processor Interrupts，IPI）。

中断升高还是因为过多任务的调度问题，跟前面上下文切换次数的分析结果是一致的。

总结

自愿上下文切换变多了，说明进程都在等待资源，有可能发生了 I/O 等其他问题；
非自愿上下文切换变多了，说明进程都在被强制调度，也就是都在争抢 CPU，说明 CPU 的确成了瓶颈；
中断次数变多了，说明 CPU 被中断处理程序占用，还需要通过查看 /proc/interrupts 文件来分析具体的中断类型。

ECS监控

2026-04-09T06:42:38.000Z

视图预览

阿里云 ECS 指标展示，包括CPU 负载，内存使用，磁盘读写，网络流量等

版本支持

操作系统支持：Linux / Windows

前置条件

服务器 <安装 Datakit>
服务器 <安装 Func 携带版>
阿里云 ECS 安装云监控
阿里云 RAM 访问控制账号授权

云监控安装

登录阿里云监控控制台 https://cloudmonitor.console.aliyun.com/
主机监控 - 点击安装 (建议勾选新建 ECS 自动安装云监控)

RAM 访问控制

登录 RAM 控制台 https://ram.console.aliyun.com/users
新建用户：人员管理 - 用户 - 创建用户

保存或下载 AccessKey ID 和 AccessKey Secret 的 CSV 文件 (配置文件会用到)
用户授权 (只读访问所有阿里云资源的权限)

安装配置

说明：

示例 Linux 版本为：CentOS Linux release 7.8.2003 (Core)
通过一台服务器采集所有阿里云 ECS 数据

部署实施

脚本市场

开启脚本市场，管理 - 实验性功能 - 开启脚本市场模块

**依次添加 **三个脚本集
1. 观测云集成 (核心包)
2. 观测云集成 (阿里云-云监控)
3. 观测云集成 (阿里云-ECS)

注：在安装「核心包」后，系统会提示安装第三方依赖包，按照正常步骤点击安装即可

脚本安装完成后，可以在脚本库中看到所有脚本集

添加脚本

开发 - 脚本库 - 添加脚本集

点击该脚本集 - 添加脚本

创建 ID 为 main 的脚本

添加代码 (需要修改账号配置 AccessKey ID/AccessKey Secret/Account Name)

from guance_integration__runner import Runner        # 引入启动器
import guance_aliyun_ecs__main as aliyun_ecs         # 引入阿里云ECS采集器
import guance_aliyun_monitor__main as aliyun_monitor # 引入阿里云云监控采集器

# 账号配置
account = {
    'ak_id'     : 'AccessKey ID',
    'ak_secret' : 'AccessKey Secret',
    'extra_tags': {
        'account_name': 'Account Name',
    }
}

# 由于采集数据较多，此处需要为函数指定更大的超时时间（单位秒）
@DFF.API('执行云资产同步', timeout=300)
def run():
    # 采集器配置
    common_aliyun_configs = {
        'regions': [ 'cn-hangzhou' ], #阿里云ECS对应的地域
    }
    monitor_collector_configs = {
        'targets': [
            { 'namespace': 'acs_ecs_dashboard', 'metrics': ['cpu_cores','cpu_idle','cpu_system','cpu_user','cpu_wait','disk_readbytes','disk_readiops','disk_writebytes','disk_writeiops','diskusage_avail','diskusage_free','diskusage_total','diskusage_used','diskusage_utilization','fs_inodeutilization','load_15m','load_1m','load_5m','memory_freespace','memory_freeutilization','memory_totalspace','memory_usedspace','memory_usedutilization','net_tcpconnection','networkin_packages','networkin_rate','networkout_packages','networkout_rate'] }, 
        ],
    }

    # 创建采集器
    collectors = [
        aliyun_ecs.DataCollector(account, common_aliyun_configs),
        aliyun_monitor.DataCollector(account, monitor_collector_configs),
    ]

    # 启动执行
    Runner(collectors).run()

**保存 **配置并发布

定时任务

添加自动触发任务，管理 - 自动触发配置 - 新建任务

自动触发配置，执行函数中添加此脚本，执行频率为 **每分钟 * * * * ***

指标预览

场景视图

<场景 - 新建仪表板 - 内置模板库 - 阿里云 ECS>

监控规则

<监控 - 模板新建 - 阿里云 ECS 检测库>

指标详解

<阿里云 ECS 指标列表>

常见问题排查

查看日志：Func 日志路径 /usr/local/dataflux-func/data/logs/dataflux-func.log
代码调试：编辑模式选择主函数，直接运行 (可以看到脚本输出)

连接配置：Func 无法连接 Datakit，请检查数据源配置 (Datakit 需要监听 0.0.0.0)

Hadoop--HDFS

2026-04-09T06:42:38.000Z

注意机器启动过之后，同步的时候不要同步data文件夹

一次写入，多次读出，不支持文件修改。适合数据分析，不适合网盘应用

分布式存储，文件系统。

优点：

高容错性。多复制，丢失自动恢复
适合大数据，数据以及文件规模
可以在廉价机器上，多副本来实现高可靠

缺点：

不适合低延时数据访问
无法对小文件高效存储
不支持并发多线程同时写入、文件随机修改，只支持append

组成

nn:master，

管理HDFS命名空间；
配置副本策略（放在那个nn节点）；
管理数据块Block（DN里面存放的是一个个数据块，不是简单的文件）的映射信息；
处理客户端读写请求

dn:slave，nn下达指令，DN执行操作。

存储实际的数据块，数据块的形式存在
执行读写操作。

client:

文件切块，block大小由此处决定，平衡数据存储
与NN交互，获取文件位置信息
DN交互，获取文件信息
访问和管理HDFS

2NN：

NN助手

HDFS文件块：

物理上是分块存储的，大小可以通过配置参数来决定，默认是128M

web页面无法新建文件夹权限问题

http://hadoop101:9870/explorer.html#/

在浏览器创建目录和删除目录及文件，是dr.who用户，dr.who其实是hadoop中http访问的静态用户名，并没有啥特殊含义，可以通过修改core-site.xml，配置为当前用户

<name>hadoop.http.staticuser.user</name>

<value>deltaqin</value>

</property>

另外，通过查看hdfs的默认配置hdfs-default.xml发现hdfs默认是开启权限检查的。

dfs.permissions.enabled=true #是否在HDFS中开启权限检查,默认为true

解决

第一种方案

直接修改/user目录的权限设置，操作如下:

hdfs dfs -chmod -R 755 /user

第二种方案

在Hadoop的配置文件core-site.xml中增加如下配置：

<name>hadoop.http.staticuser.user</name>

<value>deltaqin</value>

</property>

<name>dfs.permissions.enabled</name>

<value>false</value>

</property>

命令行操作

bin/hadoop fs 
bin/hdfs dfs

hadoop fs 
hdfs dfs

# 启动Hadoop集群（方便后续的测试）
# 101
sbin/start-dfs.sh
# 102
sbin/start-yarn.sh

# -help：输出这个命令参数
hadoop fs -help rm


#上传
# -moveFromLocal：从本地剪切粘贴到HDFS
touch kongming.txt
hadoop fs  -moveFromLocal  ./kongming.txt  /sanguo/shuguo
# -copyFromLocal：从本地文件系统中拷贝文件到HDFS路径去
hadoop fs -copyFromLocal README.txt /
# -appendToFile：追加一个文件到已经存在的文件末尾
touch liubei.txt
vi liubei.txt
# 输入
san gu mao lu
hadoop fs -appendToFile liubei.txt /sanguo/shuguo/kongming.txt
# -put：等同于copyFromLocal
hadoop fs -put ./zaiyiqi.txt /user/atguigu/test/


# 下载
# -copyToLocal：从HDFS拷贝到本地
hadoop fs -copyToLocal /sanguo/shuguo/kongming.txt ./
# -get：等同于copyToLocal，就是从HDFS下载文件到本地
hadoop fs -get /sanguo/shuguo/kongming.txt ./
# -getmerge：合并下载多个文件，比如HDFS的目录 /user/atguigu/test下有多个文件:log.1, log.2,log.3,...
hadoop fs -getmerge /user/atguigu/test/* ./zaiyiqi.txt


# HDFS直接操作
# -ls: 显示目录信息
hadoop fs -ls /
# -mkdir：在HDFS上创建目录
hadoop fs -mkdir -p /sanguo/shuguo
# -cat：显示文件内容
hadoop fs -cat /sanguo/shuguo/kongming.txt
# -chgrp 、-chmod、-chown：Linux文件系统中的用法一样，修改文件所属权限
hadoop fs  -chmod  666  /sanguo/shuguo/kongming.txt
hadoop fs  -chown  deltaqin:deltaqin   /sanguo/shuguo/kongming.txt
# -cp ：从HDFS的一个路径拷贝到HDFS的另一个路径
hadoop fs -cp /sanguo/shuguo/kongming.txt /zhuge.txt
# -mv：在HDFS目录中移动文件
hadoop fs -mv /zhuge.txt /sanguo/shuguo/
# -tail：显示一个文件的末尾
hadoop fs -tail /sanguo/shuguo/kongming.txt
# -rm：删除文件或文件夹
hadoop fs -rm /user/atguigu/test/jinlian2.txt
# -rmdir：删除空目录
hadoop fs -mkdir /test
hadoop fs -rmdir /test
# -du统计文件夹的大小信息
hadoop fs -du -s -h /user/atguigu/test
2.7 K  /user/atguigu/test

hadoop fs -du  -h /user/atguigu/test
1.3 K  /user/atguigu/test/README.txt
15     /user/atguigu/test/jinlian.txt
1.4 K  /user/atguigu/test/zaiyiqi.txt

# -setrep：设置HDFS中文件的副本数量
hadoop fs -setrep 10 /sanguo/shuguo/kongming.txt

客户端操作

连接和关闭

@Before
public void before() throws IOException, InterruptedException {
//        相当于site文件，配置HDFS
//        Configuration configuration = new Configuration();
//        2个副本
//        configuration.set("dfs.replication", "2");
//        128/2 = 64M
//        configuration.set("dfs.blocksize", "67108864");
    
    //1. 新建HDFS对象
    fileSystem = FileSystem.get(URI.create("hdfs://hadoop101:8020"),
                                new Configuration(), "deltaqin");
}

@After
public void after() throws IOException {
    fileSystem.close();
}

基本操作API

/**
     * 上传
     * @throws IOException
     * @throws InterruptedException
     */
@Test
public void put() throws IOException, InterruptedException {
    //        相当于site文件，配置HDFS
    //        Configuration configuration = new Configuration();
    //        2个副本
    //        configuration.set("dfs.replication", "2");
    //        128/2 = 64M
    //        configuration.set("dfs.blocksize", "67108864");

    //2. 操作集群
    fileSystem.copyFromLocalFile(
        new Path("/Users/qinzetao/Pictures/QQ20200621-0.jpg"),
        new Path("/1.jpg"));
}


/**
     * 下载
     *
     */
@Test
public void get() throws IOException {
    fileSystem.copyToLocalFile(
        new Path("/1.jpg"),
        new Path("/Users/qinzetao/Documents/大数据/1_hadoop/代码/Hadoop/hdfs200105")
    );
}


/**
     * 查看文件和文件夹
     * @throws IOException
     */
@Test
public void ls() throws IOException {
    FileStatus[] fileStatuses = fileSystem.listStatus(new Path("/"));
    for (FileStatus fileStatus : fileStatuses) {
        System.out.println(fileStatus.getPath());
        System.out.println(fileStatus.getOwner());
        System.out.println("=================");
    }
}

/**
     * 查看文件
     * @throws IOException
     */
@Test
public void lf() throws IOException {
    RemoteIterator statusRemoteIterator =
        fileSystem.listFiles(new Path("/"), true);
    while (statusRemoteIterator.hasNext()) {
        LocatedFileStatus fileStatus = statusRemoteIterator.next();

        System.out.println(fileStatus.getPath());
        BlockLocation[] blockLocations = fileStatus.getBlockLocations();
        for (int i = 0; i < blockLocations.length; i++) {
            System.out.println("第" + i + "块");
            String[] hosts = blockLocations[i].getHosts();
            for (String host : hosts) {
                System.out.print(host + " ");
            }
            System.out.println();
        }

        System.out.println("===================================");

    }
}

/**
     * 追加
     */
@Test
public void append() throws IOException {

    FSDataOutputStream append = fileSystem.append(
        new Path("/README.txt")
    );

    append.write("TestAPI".getBytes());

    IOUtils.closeStream(append);
}

/**
     * 移动
     */
@Test
public void mv() throws IOException {
    fileSystem.rename(new Path("/1.jpg"),
                      new Path("/logs/2.jpg"));
}

数据流

写数据

完整流程

注意每一块选择存放在哪些节点是完全独立的过程。

节点选择

NameNode会选择距离待上传数据最近距离的DataNode接收数据

节点距离（网络拓扑距离）：两个节点到达最近的共同祖先的距离总和。
rack：机架，看做路由器，下面有很多DN

机架感知（副本存储节点选择）

副本放置策略：For the common case, when the replication factor is three, HDFS’s placement policy is to put one replica on the local machine if the writer is on a datanode, otherwise on a random datanode, another replica on a node in a different (remote) rack, and the last on a different node in the same remote rack.

第一个副本在Client所处的节点上。如果客户端在集群外，随机选一个。
第二个副本和第一个副本位于相同机架，随机节点。
第三个副本位于不同机架，随机节点。

读数据

NameNode和SecondaryNameNode

元数据要求读写快，放在内存里面

涉及到持久化问题，如何提高效率？

利用多级缓存的思想！！！

FSImage文件是HDFS中名字节点NameNode上文件/目录元数据在特定某一时刻的持久化存储文件。（相当于是内存的镜像）
edits.log记录的是该干什么，不是元数据，元数据是读取这个记录之后读取对应的元数据放到内存里面得到的。
日志和image都在磁盘上，一个是日志，一个是数据

NN

NN只持久化操作日志，

edits.log：记录操作，编辑日志

fsimage：edits持久化，镜像文件

NameNode被格式化之后，将在 $HADOOP_HOME/data/tmp/dfs/name/current 目录中产生如下文件：

Fsimage文件：（记录某一时刻内存状态）HDFS文件系统元数据的一个永久性的检查点，其中包含HDFS文件系统的所有目录和文件inode的序列化信息。
Edits文件：（记录过程，没有元数据）存放HDFS文件系统的所有更新操作的路径，文件系统客户端执行的所有写操作首先会被记录到Edits文件中。
seen_txid文件保存的是一个数字，就是最后一个edits_的数字
每次NameNode启动的时候都会将Fsimage文件读入内存，加载Edits里面的更新操作，保证内存中的元数据信息是最新的、同步的，可以看成NameNode启动的时候就将Fsimage和Edits文件进行了合并。

启动流程

重启结束之后会触发一次合并，保存为checkpoint

2NN

Fsimage和Edits

格式化会生成一个空的fsimage,就可以启动了。

oiv查看Fsimage文件

oev apply the offline edits viewer to an edits file

oiv apply the offline fsimage viewer to an fsimage

hdfs oiv -p 文件类型 -i 镜像文件 -o 转换后文件输出路径

pwd
/opt/module/hadoop-3.1.3/data/tmp/dfs/name/current
hdfs oiv -p XML -i fsimage_0000000000000000025 -o /opt/module/hadoop-3.1.3/fsimage.xml 
cat /opt/module/hadoop-3.1.3/fsimage.xml

记录块信息，几块，多大

Fsimage中只记录由哪些块组成，没有记录块所对应DataNode，为什么？

在集群刚刚启动后，加载fsimage之后，要求DataNode上报数据块信息，并间隔一段时间后再次上报。（在安全模式里面，由DN主动向NN汇报，不让NN维护可以避免自己拿到的是陈旧的位置，）

oev查看Edits文件

hdfs oev -p 文件类型 -i编辑日志 -o 转换后文件输出路径

hdfs oev -p XML -i edits_0000000000000000012-0000000000000000013 -o /opt/module/hadoop-3.1.3/edits.xml
cat /opt/module/hadoop-3.1.3/edits.xml

内部是一个个的record，记录的是一个个操作

NameNode如何确定下次开机启动的时候合并哪些Edits？

CheckPoint时间设置

通常情况下，SecondaryNameNode每隔**一小时执行一次。下图所示：**

hdfs-default.xml：


  dfs.namenode.checkpoint.period
  3600

*一分钟*检查一次操作次数，当操作次数达到1百万*时，SecondaryNameNode执行一次。*


  dfs.namenode.checkpoint.txns
  1000000
操作动作次数

 

  dfs.namenode.checkpoint.check.period
  60
 1分钟检查一次操作次数

（现在都用HA，不用这个）NameNode故障处理

NameNode故障后，可以采用如下两种方法恢复数据。

将SecondaryNameNode中数据拷贝到NameNode存储数据的目录

2NN的数据其实只是NN的部分数据，所以这个一般不再使用

kill -9 NameNode进程
# 删除NameNode存储的数据（/opt/module/hadoop-3.1.3/data/tmp/dfs/name）
rm -rf /opt/module/hadoop-3.1.3/data/tmp/dfs/name/*
# 拷贝SecondaryNameNode中数据到原NameNode存储数据目录
scp -r atguigu@hadoop104:/opt/module/hadoop-3.1.3/data/tmp/dfs/namesecondary/* ./name/
# 重新启动NameNode
hdfs --daemon start namenode

使用-importCheckpoint选项启动NameNode守护进程，从而将SecondaryNameNode 中数据拷贝到NameNode目录中。

修改hdfs-site.xml中的


    dfs.namenode.checkpoint.period
    120

 

    dfs.namenode.name.dir
    /opt/module/hadoop-3.1.3/data/tmp/dfs/name

kill -9 NameNode进程
# 删除NameNode存储的数据（/opt/module/hadoop-3.1.3/data/tmp/dfs/name）
rm -rf /opt/module/hadoop-3.1.3/data/tmp/dfs/name/*
# 如果SecondaryNameNode不和NameNode在一个主机节点上，需要将
# SecondaryNameNode存储数据的目录拷贝到NameNode存储数据的平级目录，并删除in_use.lock文件
scp -r atguigu@hadoop104:/opt/module/hadoop-3.1.3/data/tmp/dfs/namesecondary ./
 
rm -rf in_use.lock
 
pwd
/opt/module/hadoop-3.1.3/data/tmp/dfs
 
ls
data  name  namesecondary

# 导入检查点数据（等待一会ctrl+c结束掉）
bin/hdfs namenode -importCheckpoint

# 启动NameNode
hdfs --daemon start namenode

集群安全模式

集群状态不正确的时候，就加入，启动的时候也会进入。

NameNode启动

NameNode启动时，首先将镜像文件（Fsimage）载入内存，并执行编辑日志（Edits）中的各项操作。一旦在内存中成功建立文件系统元数据的映像，则创建一个新的Fsimage文件和一个空的编辑日志。此时，NameNode开始监听DataNode请求。这个过程期间，NameNode一直运行在安全模式，即NameNode的文件系统对于客户端来说是只读的。

DataNode启动

系统中的数据块的位置并不是由NameNode维护的，而是以块列表的形式存储在DataNode中。在系统的正常操作期间，NameNode会在内存中保留所有块位置的映射信息。在安全模式下，各个DataNode会向NameNode发送最新的块列表信息，NameNode了解到足够多的块位置信息之后，即可高效运行文件系统。

安全模式退出判断

如果满足“最小副本条件”，NameNode会在30秒钟之后就退出安全模式。所谓的最小副本条件指的是在整个文件系统中99.9%的块满足最小副本级别（默认值：dfs.replication.min=1，一块只要有一个副本就可以）。在启动一个刚刚格式化的HDFS集群时，因为系统中还没有任何块，所以NameNode不会进入安全模式。

以下内容可以不看：

集群处于安全模式，不能执行重要操作（写操作）。集群启动完成后，自动退出安全模式。

（1）bin/hdfs dfsadmin -safemode get（功能描述：查看安全模式状态）

（2）bin/hdfs dfsadmin -safemode enter （功能描述：进入安全模式状态）

（3）bin/hdfs dfsadmin -safemode leave（功能描述：离开安全模式状态）

（4）bin/hdfs dfsadmin -safemode wait（功能描述：等待安全模式状态）

# 查看当前模式
hdfs dfsadmin -safemode get
Safe mode is OFF
# 先进入安全模式
hdfs dfsadmin -safemode enter
# 创建并执行下面的脚本
# 在/opt/module/hadoop-3.1.3路径上，编辑一个脚本safemode.sh
touch safemode.sh
vim safemode.sh

1
2
3

#!/bin/bash
hdfs dfsadmin -safemode wait
hdfs dfs -put /opt/module/hadoop-3.1.3/README.txt /

chmod 777 safemode.sh
 
./safemode.sh 

# 再打开一个窗口，执行
hdfs dfsadmin -safemode leave

# 观察
# 观察上一个窗口
Safe mode is OFF

# HDFS集群上已经有上传的数据了。

DataNode

原理：把文件数据整整齐齐切开之后按照block存放，想要直接自己恢复的话，可以复制出来，使用cat将文件追加，拼接起来之后直接解压就可以获取原始数据
块也有自己的元数据

保证数据完整性的方法

（1）当DataNode读取Block的时候，它会计算CheckSum。

（2）如果计算后的CheckSum，与Block创建时值不一样，说明Block已经损坏。

（3）Client读取其他DataNode上的Block。

（4）DataNode在其文件创建后周期验证CheckSum。

掉线处理（时限设置）

需要注意的是hdfs-site.xml 配置文件中的heartbeat.recheck.interval的单位为毫秒，dfs.heartbeat.interval的单位为秒。


    dfs.namenode.heartbeat.recheck-interval
    300000


    dfs.heartbeat.interval
    3

添加新数据节点

在原有集群基础上动态添加新的数据节点。

再克隆一台hadoop104主机，修改IP地址和主机名称，

-a 包含所有属性以及角色权限复制

1 2	sudo rsync -av /opt/module hadoop104:/opt sudo rsync -av /etc/profile.d hadoop104:/etc

删除原来HDFS文件系统留存的文件（/opt/module/hadoop-3.1.3/data和log），source一下配置文件 source /etc/profile

注意这里使用的不是群起，所以不需要配置workers

# 停止DataNode
hdfs --daemon stop datanode

# 直接启动DataNode，即可关联到集群
hdfs --daemon start datanode
sbin/yarn-daemon.sh start nodemanager

# 在hadoop104上上传文件
hadoop fs -put /opt/module/hadoop-3.1.3/LICENSE.txt /

# 如果数据不均衡，可以用命令实现集群的再平衡
./start-balancer.sh
starting balancer, logging to /opt/module/hadoop-3.1.3/logs/hadoop-atguigu-balancer-hadoop102.out
Time Stamp               Iteration#  Bytes Already Moved  Bytes Left To Move  Bytes Being Moved

退役旧数据节点

添加白名单

添加到白名单的主机节点，都允许访问NameNode，不在白名单的主机节点，都会被退出。

# 在NameNode的/opt/module/hadoop-3.1.3/etc/hadoop目录下创建dfs.hosts文件
pwd
/opt/module/hadoop-3.1.3/etc/hadoop

touch dfs.hosts
vi dfs.hosts
# 添加如下主机名称（不添加hadoop105）
hadoop102
hadoop103
hadoop104

# 在NameNode的hdfs-site.xml配置文件中增加dfs.hosts属性

  dfs.hosts
  /opt/module/hadoop-3.1.3/etc/hadoop/dfs.hosts

# 配置文件分发
xsync hdfs-site.xml
# 刷新NameNode
hdfs dfsadmin -refreshNodes
Refresh nodes successful
# 更新ResourceManager节点
yarn rmadmin -refreshNodes
17/06/24 14:17:11 INFO client.RMProxy: Connecting to ResourceManager at hadoop103/192.168.1.103:8033

# 在web浏览器上查看
# 如果数据不均衡，可以用命令实现集群的再平衡
./start-balancer.sh
starting balancer, logging to /opt/module/hadoop-3.1.3/logs/hadoop-atguigu-balancer-hadoop102.out
Time Stamp               Iteration#  Bytes Already Moved  Bytes Left To Move  Bytes Being Moved

黑名单退役

在黑名单上面的主机都会被强制退出。

# 在NameNode的/opt/module/hadoop-3.1.3/etc/hadoop目录下创建dfs.hosts.exclude文件
pwd
/opt/module/hadoop-3.1.3/etc/hadoop

touch dfs.hosts.exclude
vi dfs.hosts.exclude
# 添加如下主机名称（要退役的节点）
hadoop105

# 在NameNode的hdfs-site.xml配置文件中增加dfs.hosts.exclude属性

dfs.hosts.exclude
/opt/module/hadoop-3.1.3/etc/hadoop/dfs.hosts.exclude


# 刷新NameNode、刷新ResourceManager
hdfs dfsadmin -refreshNodes
Refresh nodes successful

yarn rmadmin -refreshNodes
17/06/24 14:55:56 INFO client.RMProxy: Connecting to ResourceManager at hadoop103/192.168.1.103:8033

# 检查Web浏览器，退役节点的状态为decommission in progress（退役中），说明数据节点正在复制块到其他节点
# 等待退役节点状态为decommissioned（所有块已经复制完成），停止该节点及节点资源管理器。
# 注意：如果副本数是3，服役的节点小于等于3，是不能退役成功的，需要修改副本数后才能退役

# 退役之后就可以关闭，退役完成意味着数据备份完成，
# 注意这里不是群起，群关闭，所以只需要单独在需要操作的机器上关闭
hdfs --daemon stop datanode
stopping datanode

sbin/yarn-daemon.sh stop nodemanager
stopping nodemanager

# 如果数据不均衡，可以用命令实现集群的再平衡
sbin/start-balancer.sh 
starting balancer, logging to /opt/module/hadoop-3.1.3/logs/hadoop-atguigu-balancer-hadoop102.out
Time Stamp               Iteration#  Bytes Already Moved  Bytes Left To Move  Bytes Being Moved
# 注意：不允许白名单和黑名单中同时出现同一个主机名称。

Datanode多目录配置

*DataNode也可以配置成多个目录，每个目录存储的数据不一样。即：数据不是副本*

配置namenode所在的机器的hdfs-site.xml，数据就会均匀的放在data/data和data/data2

<property>
  <name>dfs.datanode.data.dirname>
  <value>file:///${hadoop.tmp.dir}/dfs/data1,file:///${hadoop.tmp.dir}/dfs/data2value>
property>

Hadoop3新特性

最低java版本由7升级为8
引入纠删码，默认3副本，开销较大，只是为了提高容错能力。纠删码在不到百分之50的数据冗余的情况下提供和3副本相同的容错机制，所以使用纠删码作为副本机制的改进
重写shell脚本。

ElasticSearch

2026-04-09T06:42:38.000Z

ElasticSearch的应用场景说明

全文检索能力

日志存储分析能力

数据存储（用的比较少）

全文检索

什么是全文检索

存在索引关键字，就是命中文档

使用关键字就可以搜索对应的文档数据

检索算法

倒排索引

先将非结构化数据转换为结构化数据，之后使用关键字建立索引

全文检索的结构

索引库结构

检索流程

ElasticSearch 实践与集群架构

ES 集群架构

ES是如何进行分片存储的？

主分片和副本分片的关系：

数据在主分片上做写入，主从节点都可以进行数据写入和数据的读取。

主分片是读写，从分片只可以读不可以写。

分片和节点是不一样的。

节点类型

ES集群故障转移

ES横向扩容能力

ES 集群脑裂

文档读写路由

IDE热加载与热部署

2026-04-09T06:42:38.000Z

热加载则是在运行时通过重新加载class改变类信息，直接改变程序行为。
- **主要依赖java的类加载机制，在实现方式可以概括为在容器启动的时候起一条后台线程，定时的检测类文件的时间戳变化，如果类的时间戳变掉了，则将类重新载入。**对比反射机制，反射是在运行时获取类信息，通过动态的调用来改变程序行为；
热部署就是在服务器运行时重新部署项目，
- 直接重新加载整个应用，这种方式会释放内存，比热加载更加干净彻底，但同时也更费时间。

JRebel 加载的速度优于 devtools
JRebel 不仅仅局限于 Spring Boot 项目，可以用在任何的 Java 项目中。
devtools 方式的热部署在功能上有限制，方法内的修改可以实现热部署，但新增的方法或者修改方法参数之后热部署是不生效的。

JRebel

JRebel 可实现热加载，节省了大量重启时间，提高了个人开发效率。

虚拟机插件，即时分别看到类和资源的变化，直接反应在部署好的应用程序上，从而跳过了构建和部署的过程

激活

安装之后会提示输入license激活。使用下面的网址生成服务器地址GUID

https://www.guidgen.com/

如果失效刷新GUID替换就可以！

选择Team URL的方式激活

服务器地址：https://jrebel.qekang.com/{GUID}

邮箱：自己的邮箱即可

之后按照提示操作即可。

通过JRebel启动项目。通过快捷键 Ctrl+shift+F9 或者 command + S 使得修改生效。

支持下面的这些类型的文件改变：

改变Java classes文件.
改变框架配置文件 (e.g. Spring XML files and annotations, Struts mappings, etc).
任何静态资源文件 (e.g. JSPs, HTMLs, CSSs, XMLs, .properties, etc)

devtool

https://blog.csdn.net/u013042707/article/details/78648259

原理是在发现代码有更改之后，重新启动应用，但是比速度比手动停止后再启动还要更快，更快指的不是节省出来的手工操作的时间。

其深层原理是使用了两个ClassLoader，一个Classloader加载那些不会改变的类（第三方Jar包），另一个ClassLoader加载会更改的类，称为 restart ClassLoader,这样在有代码更改的时候，原来的restart ClassLoader 被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间（5秒以内）。

<dependency>
      <groupId>org.springframework.bootgroupId>
       <artifactId>spring-boot-devtoolsartifactId>
       <optional>trueoptional>
       <scope>truescope>
dependency>

<build>
  <finalName>www.fitness.manager.comfinalName>
  <plugins>
    
    <plugin>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-maven-pluginartifactId>
      <configuration>
        
        <fork>truefork>
      configuration>
    plugin>
  plugins>
build>

参考链接：

https://www.cnblogs.com/sfnz/p/14157833.html?ivk_sa=1024320u

https://blog.csdn.net/lianghecai52171314/article/details/105637251

https://blog.csdn.net/weixin_44233253/article/details/118788185

Elasticsearch指标监控

2026-04-09T06:42:38.000Z

视图预览

阿里云 Elasticsearch 指标展示，包括集群状态，索引QPS，节点 CPU/内存/磁盘使用率等

版本支持

操作系统支持：Linux

前置条件

服务器 <安装 Datakit>
服务器 <安装 Func 携带版>
阿里云 RAM 访问控制账号授权

RAM 访问控制

登录 RAM 控制台 https://ram.console.aliyun.com/users
新建用户：人员管理 - 用户 - 创建用户

保存或下载 AccessKey ID 和 AccessKey Secret 的 CSV 文件 (配置文件会用到)
用户授权 (云监控只读/时序指标数据权限)

安装配置

说明：

示例 Linux 版本为：CentOS Linux release 7.8.2003 (Core)
通过一台服务器采集所有阿里云 Elasticsearch 数据

部署实施

脚本市场

开启脚本市场，管理 - 实验性功能 - 开启脚本市场模块

载入阿里云数据同步脚本，管理 - 脚本市场 - 阿里云数据同步 (云监控)

添加脚本

阿里云数据同步 (云监控) - 添加脚本

输入标题/描述信息

复制代码，从 (同步阿里云监控数据) 到当前脚本
修改阿里云账号配置 (Ram 访问控制)

1 2	'aliyun_ak_id' : 'AccessKey ID', 'aliyun_ak_secret': 'AccessKey Secret',

修改阿里云 Elasticsearch 指标

'metric_targets': [
    {
        'namespace': 'acs_elasticsearch',
        'metrics': 'ALL'
     }           
                  ]

**保存 **配置并发布

定时任务

添加自动触发任务，管理 - 自动触发配置 - 新建任务

自动触发配置，执行函数中添加此脚本，其他默认即可

指标预览

场景视图

<场景 - 新建仪表板 - 内置模板库 - 阿里云 Elasticsearch>

监控规则

<监控 - 模板新建 - 阿里云 Elasticsearch>

指标详解

<阿里云 Elasticsearch 指标列表>

常见问题排查

查看日志：Func 日志路径 /usr/local/dataflux-func/data/logs/dataflux-func.log
代码调试：选择主函数，直接运行 (可以看到脚本输出)

连接配置：Func 无法连接 Datakit，请检查数据源配置

K 个一组翻转链表

2026-04-09T06:42:38.000Z

在一次翻转完成之后

nxt.next = cur 这一次翻转的尾节点应指向下一次的头节点

p0.next = pre 上次翻转的尾节点应指向这次翻转的头节点

p0 变为这次翻转后的尾节点

Hadoop-MapReduce

2026-04-09T06:42:38.000Z

dr.who是通过http连接的默认用户，可以直接在配置文件里面修改为当前用户，重启之后就可以使用当前用户在页面里面对文件进行相关操作。

MapReduce概述

分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。

MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。

优点

**MapReduce ****易于编程**它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。

好的扩展性当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。

高容错性MapReduce设计的初衷就是使程序能够部署在廉价的PC机器上，这就要求它具有很高的容错性。比如其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上运行，不至于这个任务运行失败，而且这个过程不需要人工参与，而完全是由Hadoop内部完成的。

适合PB级以上海量数据的离线处理可以实现上千台服务器集群并发工作，提供数据处理能力。

缺点

不擅长实时计算MapReduce无法像MySQL一样，在毫秒或者秒级内返回结果。

不擅长流式计算流式计算的输入数据是动态的，而MapReduce的输入数据集是静态的，不能动态变化。这是因为MapReduce自身的设计特点决定了数据源必须是静态的。

不擅长**DAG（有向图）计算**多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce并不是不能做，而是使用后，每个MapReduce作业的输出结果都会写入到磁盘，会造成大量的磁盘IO，导致性能非常的低下。

MapReduce核心思想

map阶段：MapTask并发实例，完全并行运行，互不相干。

reduce阶段：ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。

MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个MapReduce程序，串行运行。

一个完整的MapReduce程序在分布式运行时有三类实例进程：

（1）MrAppMaster：负责整个程序的过程调度及状态协调。

（2）MapTask：负责Map阶段的整个数据处理流程。

（3）ReduceTask：负责Reduce阶段的整个数据处理流程。

直接使用官方的 Wordcount

1
2
3

[deltaqin@hadoop101 mapreduce]$ pwd                                                                                                                        
/opt/module/hadoop-3.1.3/share/hadoop/mapreduce
[deltaqin@hadoop101 mapreduce]$ yarn jar hadoop-mapreduce-examples-3.1.3.jar wordcount /test.txt /output

常用数据序列化类型

hadoop包装好的类型，想用必须使用包装好的类型

Java类型	Hadoop Writable类型
Boolean	BooleanWritable
Byte	ByteWritable
Int	IntWritable
Float	FloatWritable
Long	LongWritable
Double	DoubleWritable
String	Text
Map	MapWritable
Array	ArrayWritable

自己实现 WordCount

有Map类、Reduce类和驱动类。且数据的类型是Hadoop自身封装的序列化类型。

在给定的文本文件中统计输出每一个单词出现的总次数

按照MapReduce编程规范，分别编写Mapper，Reducer，Driver。

编写Mapper类

package com.deltqin;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

// 框架拿到内容变成kv给当前程序，输入类型由框架决定
// 将数据一行行，给该程序来处理,如何拿到数据不用管，只需要管业务（框架下编程）

//LongWritable, Text 输入类型：行号，内容
//Text, IntWritable 输出类型：内容

// LongWritable：开头在文件中位置，位置索引
// Text： 输入类型
// Text：输出类型
// IntWritable：对应个数
public class WordCountMapper extends Mapper {

//    map里面尽量不要生成对象，垃圾回收压力太大，降低性能
    private Text word = new Text();
    private IntWritable one = new IntWritable(1);

//    框架给一些数据，处理之后交还给框架
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

        String string = value.toString();
        String[] words = string.split(" ");

//        (单词, 1),只是数据类型转变，不负责数
        for (String word : words){
            this.word.set(word);
            context.write(this.word, this.one);
        }
    }
}

编写Reducer类

package com.deltqin;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class WordCountReducer extends Reducer {

    private IntWritable intWritable = new IntWritable();

    /**
     * 框架将mapper输出的内容处理，变成（单词，单词所有的1（可迭代变量）），同一单词个数相加
     * @param key 单词
     * @param values 单词所有的1（可迭代变量）
     * @param context 任务自己
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable intWritable1: values){
            sum += intWritable1.get();
        }
        intWritable.set(sum);
        context.write(key, intWritable);

    }
}

编写Driver驱动类

package com.deltqin;

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCountDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        // 1 获取配置信息以及封装任务job实例
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        // 2 设置jar加载路径
        job.setJarByClass(WordCountDriver.class);

        // 3 设置map和reduce类
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);

        // 4 设置map输出
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);

        // 5 设置最终输出kv类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        // 6 设置输入和输出路径
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        // 7 提交
        boolean result = job.waitForCompletion(true);

        System.exit(result ? 0 : 1);
    }
}

mvn pacakage 打成jar包，然后拷贝到Hadoop集群中

在 Hadoop101 执行WordCount程序，jar包提交到集群运行。

1	yarn jar wc.jar com.deltaqin.WordcountDriver /test.txt /output1

com.deltaqin.WordcountDriver 注意使用类名的全类型引用

/output1 后面是输入文件以及输出文件，输出路径必须是一个不存在的路径

Hadoop序列化

序列化不代表持久化

序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。序列化可以存储“活的”对象，可以将“活的”对象发送到远程计算机
反序列化就是将收到字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。

Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，Header，继承体系等），大数据数据量本来就大，不便于在网络中高效传输。所以，Hadoop自己开发了一套序列化机制（Writable）。

紧凑快速：只序列化必要的数据，开销小。
可扩展：随着通信协议升级而升级
互操作：支持多语言的交互

注意上面的WordCount，类型都是明确指定，一一设定的，不像java自己的序列化可以自动识别

// 3 设置map和reduce类
job.setMapperClass(WordcountMapper.class);
job.setReducerClass(WordcountReducer.class);

// 4 设置map输出
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);

// 5 设置最终输出kv类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);

自定义bean对象实现序列化接口（Writable）

统计号码流量

输入数据格式：

7 13560436666120.196.100.991116 954200 id手机号码网络ip上行流量下行流量网络状态码

期望输出数据格式

13560436666 1116 954 2070 手机号码上行流量下行流量总流量

必须实现Writable接口
反序列化时，需要反射调用空参构造函数 super(); ，所以必须有空参构造（通过反射构造对象一般会使用无参构造器）
重写序列化方法 write(DataOutput out)
重写反序列化方法 readFields(DataInput in)，注意反序列化的顺序和序列化的顺序完全一致
要想把结果显示在文件中，需要重写toString()，可用”\t”分开，方便后续用。
如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为MapReduce中的Shuffle过程要求对key必须能排序。

@Override
public int compareTo(FlowBean o) {
// 倒序排列，从大到小
return this.sumFlow > o.getSumFlow() ? -1 : 1;
}

package com.deltaqin;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import org.apache.hadoop.io.Writable;

// 1 实现writable接口
public class FlowBean implements Writable{

    private long upFlow;
    private long downFlow;
    private long sumFlow;

    //2  反序列化时，需要反射调用空参构造函数，所以必须有
    public FlowBean() {
        super();
    }

    public FlowBean(long upFlow, long downFlow) {
        super();
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.sumFlow = upFlow + downFlow;
    }

    public void set(long upFlow, long downFlow) {
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.sumFlow = upFlow + downFlow;
    }

    //3  写序列化方法,将数据写到指定的地方
    // DataOutput 数据的容器
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    //4 反序列化方法
    //5 反序列化方法读顺序必须和写序列化方法的写顺序必须一致
    @Override
    public void readFields(DataInput in) throws IOException {
        this.upFlow  = in.readLong();
        this.downFlow = in.readLong();
        this.sumFlow = in.readLong();
    }

    @Override
    public String toString() {
        return upFlow + "\t" + downFlow + "\t" + sumFlow;
    }

    public long getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(long upFlow) {
        this.upFlow = upFlow;
    }

    public long getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(long downFlow) {
        this.downFlow = downFlow;
    }

    public long getSumFlow() {
        return sumFlow;
    }

    public void setSumFlow(long sumFlow) {
        this.sumFlow = sumFlow;
    }
}

编写Mapper类

输出类型是 FlowBean

package com.deltaqin;
import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class FlowCountMapper extends Mapper{

    FlowBean v = new FlowBean();
    Text k = new Text();

    @Override
    protected void map(LongWritable key, Text value, Context context)throws IOException, InterruptedException {

        // 1 获取一行
        String line = value.toString();

        // 2 切割字段
        String[] fields = line.split("\t");

        // 3 封装对象
        // 取出手机号码
        String phoneNum = fields[1];

        // 取出上行流量和下行流量
        long upFlow = Long.parseLong(fields[fields.length - 3]);
        long downFlow = Long.parseLong(fields[fields.length - 2]);

        k.set(phoneNum);
        v.set(downFlow, upFlow);

        // 4 写出
        context.write(k, v);
    }
}

编写Reducer类

package com.deltaqin;
import java.io.IOException;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
 
public class FlowCountReducer extends Reducer {

private FlowBean flowBean01 = new FlowBean();

@Override
protected void reduce(Text key, Iterable values, Context context)throws IOException, InterruptedException {
 
long sum_upFlow = 0;
long sum_downFlow = 0;
 
// 1 遍历所用bean，将其中的上行流量，下行流量分别累加
for (FlowBean flowBean : values) {
sum_upFlow += flowBean.getUpFlow();
sum_downFlow += flowBean.getDownFlow();
}
 
// 2 封装对象
flowBean01.set(sum_upFlow,sum_downFlow);

// 3 写出
context.write(key, flowBean01);
}
}

编写Driver驱动类

package com.atguigu.mapreduce.flowsum;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class FlowsumDriver {

    public static void main(String[] args) throws IllegalArgumentException, IOException, ClassNotFoundException, InterruptedException {

        // 输入输出路径需要根据自己电脑上实际的输入输出路径设置
        args = new String[] { "e:/input/inputflow", "e:/output1" };

        // 1 获取配置信息，或者job对象实例
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        // 6 指定本程序的jar包所在的本地路径
        job.setJarByClass(FlowsumDriver.class);

        // 2 指定本业务job要使用的mapper/Reducer业务类
        job.setMapperClass(FlowCountMapper.class);
        job.setReducerClass(FlowCountReducer.class);

        // 3 指定mapper输出数据的kv类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);

        // 4 指定最终输出的数据的kv类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        // 5 指定job的输入原始文件所在目录
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        // 7 将job中配置的相关参数，以及job所用的java类所在的jar包， 提交给yarn去运行
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);
    }
}

MapReduce框架原理

Map阶段：

MapTask.run 执行map阶段，
- 调用Mapper的map方法

InputFormat数据输入

一般分几份之后就会启动多少个MapTask来执行****

遍历文件，按最小切片大小生成切片****。
**数据变成KV：**切片是在客户端完成。对每一个切片获取recordReader，在并行的mapper task完成，recordreader就可以变成KV。实际切KV是recordReader，不是切片实现的。
输出给mapper

切片与MapTask并行度决定机制****

MapTask的并行度决定Map阶段的任务处理并发度，进而影响到整个Job的处理速度。

**数据（切）**块：Block是HDFS物理上把数据分成一块一块。

数据****切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。

按照块大小来切分数据（物理切块和逻辑切分对应起来），就避免了原本在这个DN的数据还需要传递到其他DN上，减少了网络传输，更多的带宽留给shuffle

Job提交流程源码

jar包
切片信息
job配置的xml

调试源码：主要代码片段：

waitForCompletion()

submit();

// 1建立连接
connect();
// 1）创建提交Job的代理
new Cluster(getConfiguration());
// （1）判断是本地yarn还是远程
initialize(jobTrackAddr, conf); 

// 2 提交job
submitter.submitJobInternal(Job.this, cluster)
    // 1）创建给集群提交数据的Stag路径
    Path jobStagingArea = JobSubmissionFiles.getStagingDir(cluster, conf);

// 2）获取jobid ，并创建Job路径
JobID jobId = submitClient.getNewJobID();

// 3）拷贝jar包到集群
copyAndConfigureFiles(job, submitJobDir);
rUploader.uploadFiles(job, jobSubmitDir);

// 4）计算切片，生成切片规划文件
writeSplits(job, submitJobDir);
maps = writeNewSplits(job, jobSubmitDir);
input.getSplits(job);

// 5）向Stag路径写XML配置文件
writeConf(conf, submitJobFile);
conf.writeXml(out);

// 6）提交Job,返回提交状态
status = submitClient.submitJob(jobId, submitJobDir.toString(), job.getCredentials());

切片源码

对应上面源码解读的第4步。

注意下面的1.1倍长才会切片1倍，怕浪费

FileInputFormat（抽象父类）切片机制

源码里面该抽象父类只实现了getSplits也就是上面的切片过程。

还有一个createRecordReader没有实现，需要他的特定子类实现，默认使用的是TextInputFormat

TextInputFormat的KV

TextInputFormat是默认的FileInputFormat实现类。按行读取每条记录。键是存储该行在整个文件中的起始字节偏移量， LongWritable类型。值是这行的内容，不包括任何行终止符（换行符和回车符），Text类型。

KeyValueTextInputFormat的KV

每一行一条记录，分隔符分为KV，默认分隔符是tab

NLineInputFormat的KV

map处理的不是按照block划分，而是按照指定的行数去划分

CombineTextInputFormat切片机制

框架默认的TextInputFormat切片机制是对任务按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个MapTask，这样如果有大量小文件，就会产生大量的MapTask，处理效率极其低下。

CombineTextInputFormat用于小文件过多的场景，它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个MapTask处理。

CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);// 4m

注意：虚拟存储切片最大值设置最好根据实际的小文件大小情况来设置具体的值。

生成切片过程包括：虚拟存储过程和切片过程二部分。

（1）虚拟存储过程：

将输入目录下所有文件大小，依次和设置的setMaxInputSplitSize值比较，如果不大于设置的最大值，逻辑上划分一个块。如果输入文件大于设置的最大值且大于两倍，那么以最大值切割一块；当剩余数据大小超过设置的最大值且不大于最大值2倍，此时将文件均分成2个虚拟存储块（防止出现太小切片）。

例如setMaxInputSplitSize值为4M，输入文件大小为8.02M，则先逻辑上分成一个4M。剩余的大小为4.02M，如果按照4M逻辑划分，就会出现0.02M的小的虚拟存储文件，所以将剩余的4.02M文件切分成（2.01M和2.01M）两个文件。

（2）切片过程：

（a）判断虚拟存储的文件大小是否大于setMaxInputSplitSize值，大于等于则单独形成一个切片。

（b）如果不大于则跟下一个虚拟存储文件进行合并，共同形成一个切片。

（c）测试举例：有4个小文件大小分别为1.7M、5.1M、3.4M以及6.8M这四个小文件，则虚拟存储之后形成6个文件块，大小分别为：

1.7M，（2.55M、2.55M），3.4M以及（3.4M、3.4M）

最终会形成3个切片，大小分别为：

（1.7+2.55）M，（2.55+3.4）M，（3.4+3.4）M

CombineTextInputFormat案例实操

将输入的大量小文件合并成一个切片统一处理。

//不做任何处理，运行1.6节的WordCount案例程序，观察切片个数为4。
 
//在WordcountDriver中增加如下代码，运行程序，并观察运行的切片个数为3。
//驱动类中添加代码如下：
// 如果不设置InputFormat，它默认用的是TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);
 
//虚拟存储切片最大值设置4m
CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);
//运行为3个切片。


//在WordcountDriver中增加如下代码，运行程序，并观察运行的切片个数为1。
//驱动中添加代码如下：
// 如果不设置InputFormat，它默认用的是TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);
 
//虚拟存储切片最大值设置20m
CombineTextInputFormat.setMaxInputSplitSize(job, 20971520);
//运行如果为1个切片。

自定义inputFormat

继承一些东西（RecordReader），实现一些，重写一些方法

初始化
是否读到
读取K
读取V
获取进度
关闭****

Shuffle机制

Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle。

MapReduce工作流程****

MapTask工作机制

7往缓存区里面写东西，写满之后才会输出，溢出为文件

其中第9步使用的快排，全部在内存完成，

局部排序可以使用快排

归并不需要全部在内存里面，两个指针逐渐遍历即可，没必要全进来内存，但是快排必须全部到内存里面，所以这里最后使用归并而不是快排。

最后每个task都输出一个有序文件。

多个有序文件再归并变成一个有序文件，给reduce

Read阶段：MapTask通过用户编写的RecordReader，从输入InputSplit中解析出一个个key/value。
Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。
Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitioner），并写入一个环形内存缓冲区中。
Spill阶段：即“溢写”，当环形缓冲区满后，MapReduce会将数据写到本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地排序，并在必要时对数据进行合并、压缩等操作。
- 步骤1：利用快速排序算法对缓存区内的数据进行排序，排序方式是，先按照分区编号Partition进行排序，然后按照key进行排序。这样，经过排序后，数据以分区为单位聚集在一起，且同一分区内所有数据按照key有序。
- 步骤2：按照分区编号由小到大依次将每个分区中的数据写入任务工作目录下的临时文件output/spillN.out（N表示当前溢写次数）中。如果用户设置了Combiner，则写入文件之前，对每个分区中的数据进行一次聚集操作。
- 步骤3：将分区数据的元信息写到内存索引数据结构SpillRecord中，其中每个分区的元信息包括在临时文件中的偏移量、压缩前数据大小和压缩后数据大小。如果当前内存索引大小超过1MB，则将内存索引写到文件output/spillN.out.index中。
Combine阶段：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。

当所有数据处理完后，MapTask会将所有临时文件合并成一个大文件，并保存到文件output/file.out中，同时生成相应的索引文件output/file.out.index。在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并io.sort.factor（默认10）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。

让每个MapTask最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。

ReduceTask工作机制

Copy阶段：ReduceTask从各个MapTask上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。
Merge阶段：在远程拷贝数据的同时，ReduceTask启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。
Sort阶段：按照MapReduce语义，用户编写reduce()函数输入数据是按key进行聚集的一组数据。为了将key相同的数据聚在一起，Hadoop采用了基于排序的策略。由于各个MapTask已经实现对自己的处理结果进行了局部排序，因此，ReduceTask只需对所有数据进行一次归并排序即可。
Reduce阶段：reduce()函数将计算结果写到HDFS上。

设置ReduceTask****并行度（个数）

ReduceTask的并行度同样影响整个Job的执行并发度和执行效率，但与MapTask的并发数由切片数决定不同，ReduceTask数量的决定是可以直接手动设置：

// 默认值是1，手动设置为4

job.setNumReduceTasks(4);

shuffle流程

shuffle洗牌过程，一共涉及三次排序（用时间换空间，其实快排比归并更快）：

第一次内存里面的快排
第二次是一个task里面的归并
第三次是所有task的有序文件的归并

上面的流程是整个MapReduce最全工作流程，但是Shuffle过程只是从第7步开始到第16步结束，具体Shuffle过程详解，如下：

（1）MapTask收集我们的map()方法输出的kv对，放到内存缓冲区中

（2）从内存缓冲区不断溢出本地磁盘文件，可能会溢出多个文件

（3）多个溢出文件会被合并成大的溢出文件

（4）在溢出过程及合并的过程中，都要调用Partitioner进行分区和针对key进行排序

（5）ReduceTask根据自己的分区号，去各个MapTask机器上取相应的结果分区数据

（6）ReduceTask会取到同一个分区的来自不同MapTask的结果文件，ReduceTask会将这些文件再进行合并（归并排序）

（7）合并成大文件后，Shuffle的过程也就结束了，后面进入ReduceTask的逻辑运算过程（从文件中取出一个一个的键值对Group，调用用户自定义的reduce()方法）

注意：

（1）Shuffle中的缓冲区大小会影响到MapReduce程序的执行效率，原则上说，缓冲区越大，磁盘io的次数越少，执行速度就越快。

（2）缓冲区的大小可以通过参数调整，参数：io.sort.mb默认100M。

看转过来的第二行开始位置，reduce处理的时候是拿每一个map的相同分区上的数据来归并。得到的结果再分组给不同的reduce。

Partition–分区

一个map被分为很多区，分区是为了给reduce划分数据。reduce处理的时候也是采用并行的机制，

在分区之后才会快排。分区的依据就是有多少reduce在工作

默认分区方式

key的 hashcode对reduce的个数取余，相同的取余运算结果去往同一个分区。

默认分区是根据key的hashCode对ReduceTasks个数取模得到的。用户没法控制哪个key存储到哪个分区。

public class HashPartitioner extends Partitioner {

    public int getPartition(K key, V value, int numReduceTasks) {
        // 与是为了去负号，除了第一个其余不变，相当于把符号位变成0
        return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
    }
}

自定义分区方式

自定义类继承Partitioner，重写getPartition()方法

public class CustomPartitioner extends Partitioner {
    @Override
    public int getPartition(Text key, FlowBean value, int numPartitions) {
        // 控制分区代码逻辑
        … …
            return partition;
    }
}

Partition分区案例实操

将统计结果按照手机归属地不同省份输出到不同文件中（分区）

手机号136、137、138、139开头都分别放到一个独立的4个文件中，其他开头的放到一个文件中。

package com.atguigu.mapreduce.flowsum;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

public class ProvincePartitioner extends Partitioner {

    @Override
    public int getPartition(Text key, FlowBean value, int numPartitions) {

        // 1 获取电话号码的前三位
        String preNum = key.toString().substring(0, 3);

        int partition = 4;

        // 2 判断是哪个省
        if ("136".equals(preNum)) {
            partition = 0;
        }else if ("137".equals(preNum)) {
            partition = 1;
        }else if ("138".equals(preNum)) {
            partition = 2;
        }else if ("139".equals(preNum)) {
            partition = 3;
        }

        return partition;
    }
}

在驱动函数中增加自定义数据分区设置和ReduceTask设置

不设置的话还是使用默认的hash分区

// 8 指定自定义数据分区

// 不设置的话还是使用默认的hash分区

job.setPartitionerClass(ProvincePartitioner.class);

// 9 同时指定相应数量的reduce task

job.setNumReduceTasks(5);

package com.atguigu.mapreduce.flowsum;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class FlowsumDriver {

    public static void main(String[] args) throws IllegalArgumentException, IOException, ClassNotFoundException, InterruptedException {

        // 输入输出路径需要根据自己电脑上实际的输入输出路径设置
        args = new String[]{"e:/output1","e:/output2"};

        // 1 获取配置信息，或者job对象实例
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        // 2 指定本程序的jar包所在的本地路径
        job.setJarByClass(FlowsumDriver.class);

        // 3 指定本业务job要使用的mapper/Reducer业务类
        job.setMapperClass(FlowCountMapper.class);
        job.setReducerClass(FlowCountReducer.class);

        // 4 指定mapper输出数据的kv类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);

        // 5 指定最终输出的数据的kv类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        // 8 指定自定义数据分区
        // 不设置的话还是使用默认的hash分区
        job.setPartitionerClass(ProvincePartitioner.class);

        // 9 同时指定相应数量的reduce task
        job.setNumReduceTasks(5);

        // 6 指定job的输入原始文件所在目录
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        // 7 将job中配置的相关参数，以及job所用的java类所在的jar包， 提交给yarn去运行
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);
    }
}

WritableComparable接口–排序

自定义排序 WritableComparable 原理分析

bean对象做为key传输，需要实现WritableComparable接口重写compareTo方法，就可以实现排序。

只要实现了此接口，就可以动态调用你。

@Override
public int compareTo(FlowBean o) {

    int result;

    // 按照总流量大小，倒序排列
    if (sumFlow > bean.getSumFlow()) {
        result = -1;
    }else if (sumFlow < bean.getSumFlow()) {
        result = 1;
    }else {
        result = 0;
    }

    return result;
}

WritableComparable排序案例实操（全排序）****

根据案例2.3产生的结果再次对总流量进行排序。

135094687237335110349117684

1373623051324812468127162

1395643563613215121644

138465441212640264

。。。。。。

FlowBean对象在在需求1基础上增加了比较功能

package com.atguigu.mapreduce.sort;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import org.apache.hadoop.io.WritableComparable;

public class FlowBean implements WritableComparable {

    private long upFlow;
    private long downFlow;
    private long sumFlow;

    // 反序列化时，需要反射调用空参构造函数，所以必须有
    public FlowBean() {
        super();
    }

    public FlowBean(long upFlow, long downFlow) {
        super();
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.sumFlow = upFlow + downFlow;
    }

    public void set(long upFlow, long downFlow) {
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.sumFlow = upFlow + downFlow;
    }

    public long getSumFlow() {
        return sumFlow;
    }

    public void setSumFlow(long sumFlow) {
        this.sumFlow = sumFlow;
    }

    public long getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(long upFlow) {
        this.upFlow = upFlow;
    }

    public long getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(long downFlow) {
        this.downFlow = downFlow;
    }

    /**
 * 序列化方法
 * @param out
 * @throws IOException
 */
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeLong(upFlow);
        out.writeLong(downFlow);
        out.writeLong(sumFlow);
    }

    /**
 * 反序列化方法 注意反序列化的顺序和序列化的顺序完全一致
 * @param in
 * @throws IOException
 */
    @Override
    public void readFields(DataInput in) throws IOException {
        upFlow = in.readLong();
        downFlow = in.readLong();
        sumFlow = in.readLong();
    }

    @Override
    public String toString() {
        return upFlow + "\t" + downFlow + "\t" + sumFlow;
    }

    @Override
    public int compareTo(FlowBean bean) {

        int result;

        // 按照总流量大小，倒序排列
        if (sumFlow > bean.getSumFlow()) {
            result = -1;
        }else if (sumFlow < bean.getSumFlow()) {
            result = 1;
        }else {
            result = 0;
        }

        return result;
    }
}

编写Mapper类

package com.atguigu.mapreduce.sort;
import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
 
public class FlowCountSortMapper extends Mapper{
 
FlowBean bean = new FlowBean();
Text v = new Text();
 
@Override
protected void map(LongWritable key, Text value, Context context)throws IOException, InterruptedException {
 
// 1 获取一行
String line = value.toString();

// 2 截取
String[] fields = line.split("\t");

// 3 封装对象
String phoneNbr = fields[0];
long upFlow = Long.parseLong(fields[1]);
long downFlow = Long.parseLong(fields[2]);

bean.set(upFlow, downFlow);
v.set(phoneNbr);

// 4 输出
context.write(bean, v);
}
}

编写Reducer类

package com.atguigu.mapreduce.sort;
import java.io.IOException;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class FlowCountSortReducer extends Reducer{

    @Override
    protected void reduce(FlowBean key, Iterable values, Context context)throws IOException, InterruptedException {

        // 循环输出，避免总流量相同情况
        for (Text text : values) {
            context.write(text, key);
        }
    }
}

编写Driver类

package com.atguigu.mapreduce.sort;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class FlowCountSortDriver {

    public static void main(String[] args) throws ClassNotFoundException, IOException, InterruptedException {

        // 输入输出路径需要根据自己电脑上实际的输入输出路径设置
        args = new String[]{"e:/output1","e:/output2"};

        // 1 获取配置信息，或者job对象实例
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        // 2 指定本程序的jar包所在的本地路径
        job.setJarByClass(FlowCountSortDriver.class);

        // 3 指定本业务job要使用的mapper/Reducer业务类
        job.setMapperClass(FlowCountSortMapper.class);
        job.setReducerClass(FlowCountSortReducer.class);

        // 4 指定mapper输出数据的kv类型
        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);

        // 5 指定最终输出的数据的kv类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        // 6 指定job的输入原始文件所在目录
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        // 7 将job中配置的相关参数，以及job所用的java类所在的jar包， 提交给yarn去运行
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);
    }
}

WritableComparable排序案例实操（区内排序）

1）需求

要求每个省份手机号输出的文件中按照总流量内部排序。

2）需求****分析

基于前一个需求，增加自定义分区类，分区按照省份手机号设置。

**3）**案例实操

（1）增加自定义分区类
package com.atguigu.mapreduce.sort;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;
 
public class ProvincePartitioner extends Partitioner {
 
@Override
public int getPartition(FlowBean key, Text value, int numPartitions) {

// 1 获取手机号码前三位
String preNum = value.toString().substring(0, 3);

int partition = 4;

// 2 根据手机号归属地设置分区
if ("136".equals(preNum)) {
partition = 0;
}else if ("137".equals(preNum)) {
partition = 1;
}else if ("138".equals(preNum)) {
partition = 2;
}else if ("139".equals(preNum)) {
partition = 3;
}
 
return partition;
}
}
（2）在驱动类中添加分区类
// 加载自定义分区类
job.setPartitionerClass(ProvincePartitioner.class);
 
// 设置Reducetask个数
job.setNumReduceTasks(5);

Combiner–合并

（6）自定义Combiner实现步骤

自定义一个Combiner继承Reducer，重写Reduce方法

public class WordcountCombiner extends Reducer{

    @Override
    protected void reduce(Text key, Iterable values,Context context) throws IOException, InterruptedException {

        // 1 汇总操作
        int count = 0;
        for(IntWritable v :values){
            count += v.get();
        }

        // 2 写出
        context.write(key, new IntWritable(count));
    }
}

在Job驱动类中设置：

1	job.setCombinerClass(WordcountCombiner.class);

Combiner合并案例实操****

统计过程中对每一个MapTask的输出进行局部汇总，以减小网络传输量即采用Combiner功能。

期望：Combine输入数据多，输出时经过合并，输出数据降低。

（1）增加一个WordcountCombiner类继承Reducer

package com.atguigu.mr.combiner;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
 
public class WordcountCombiner extends Reducer{
 
IntWritable v = new IntWritable();
 
@Override
protected void reduce(Text key, Iterable values, Context context) throws IOException, InterruptedException {
 
        // 1 汇总
int sum = 0;
 
for(IntWritable value :values){
sum += value.get();
}
 
v.set(sum);
 
// 2 写出
context.write(key, v);
}
}

（2）在WordcountDriver驱动类中指定Combiner

1 2	// 指定需要使用combiner，以及用哪个类作为combiner的逻辑 job.setCombinerClass(WordcountCombiner.class);

OutputFormat数据输出

OutputFormat接口实现类

自定义OutputFormat

编写FilterMapper类

package com.atguigu.mapreduce.outputformat;
import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
 
public class FilterMapper extends Mapper{

@Override
protected void map(LongWritable key, Text value, Context context)throws IOException, InterruptedException {
 
// 写出
context.write(value, NullWritable.get());
}
}

编写FilterReducer类

package com.atguigu.mapreduce.outputformat;
import java.io.IOException;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
 
public class FilterReducer extends Reducer {
 
Text k = new Text();
 
@Override
protected void reduce(Text key, Iterable values, Context context)throws IOException, InterruptedException {
 
       // 1 获取一行
String line = key.toString();
 
       // 2 拼接
line = line + "\r\n";
 
       // 3 设置key
       k.set(line);
 
       // 4 输出
context.write(k, NullWritable.get());
}
}

（3）自定义一个OutputFormat类

package com.atguigu.mapreduce.outputformat;
import java.io.IOException;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 
public class FilterOutputFormat extends FileOutputFormat{
 
@Override
public RecordWriter getRecordWriter(TaskAttemptContext job)throws IOException, InterruptedException {
 
// 创建一个RecordWriter
return new FilterRecordWriter(job);
}
}

（4）编写RecordWriter类

package com.atguigu.mapreduce.outputformat;
import java.io.IOException;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;

public class FilterRecordWriter extends RecordWriter {

    FSDataOutputStream atguiguOut = null;
    FSDataOutputStream otherOut = null;

    public FilterRecordWriter(TaskAttemptContext job) {

        // 1 获取文件系统
        FileSystem fs;

        try {
            fs = FileSystem.get(job.getConfiguration());

            // 2 创建输出文件路径
            Path atguiguPath = new Path("e:/atguigu.log");
            Path otherPath = new Path("e:/other.log");

            // 3 创建输出流
            atguiguOut = fs.create(atguiguPath);
            otherOut = fs.create(otherPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void write(Text key, NullWritable value) throws IOException, InterruptedException {

        // 判断是否包含“atguigu”输出到不同文件
        if (key.toString().contains("atguigu")) {
            atguiguOut.write(key.toString().getBytes());
        } else {
            otherOut.write(key.toString().getBytes());
        }
    }

    @Override
    public void close(TaskAttemptContext context) throws IOException, InterruptedException {

        // 关闭资源
        IOUtils.closeStream(atguiguOut);
        IOUtils.closeStream(otherOut);}
}

（5）编写FilterDriver类

package com.atguigu.mapreduce.outputformat;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 
public class FilterDriver {
 
public static void main(String[] args) throws Exception {
 
// 输入输出路径需要根据自己电脑上实际的输入输出路径设置
args = new String[] { "e:/input/inputoutputformat", "e:/output2" };
 
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
 
job.setJarByClass(FilterDriver.class);
job.setMapperClass(FilterMapper.class);
job.setReducerClass(FilterReducer.class);
 
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);

job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
 
// 要将自定义的输出格式组件设置到job中
job.setOutputFormatClass(FilterOutputFormat.class);
 
FileInputFormat.setInputPaths(job, new Path(args[0]));
 
// 虽然我们自定义了outputformat，但是因为我们的outputformat继承自fileoutputformat
// 而fileoutputformat要输出一个_SUCCESS文件，所以，在这还得指定一个输出目录
FileOutputFormat.setOutputPath(job, new Path(args[1]));
 
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}

Join多种应用

Reduce Join

Map端的主要工作：为来自不同表或文件的key/value对，打标签以区别不同来源的记录。然后用连接字段作为key，其余部分和新加的标志作为value，最后进行输出。

Reduce端的主要工作：在Reduce端以连接字段作为key的分组已经完成，我们只需要在每一个分组当中将那些来源于不同文件的记录(在Map阶段已经打标志)分开，最后进行合并就ok了。

通过将关联条件作为Map输出的key，将两表满足Join条件的数据并携带数据所来源的文件信息，发往同一个ReduceTask，在Reduce中进行数据的串联。

（1）创建商品和订合并后的Bean类

package com.atguigu.reducejoin;
 
import org.apache.hadoop.io.WritableComparable;
 
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
 
public class OrderBean implements WritableComparable {
    private String id;
    private String pid;
    private int amount;
    private String pname;
 
    @Override
    public String toString() {
        return id + "\t" + pname + "\t" + amount;
    }
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public String getPid() {
        return pid;
    }
 
    public void setPid(String pid) {
        this.pid = pid;
    }
 
    public int getAmount() {
        return amount;
    }
 
    public void setAmount(int amount) {
        this.amount = amount;
    }
 
    public String getPname() {
        return pname;
    }
 
    public void setPname(String pname) {
        this.pname = pname;
    }
 
    //按照Pid分组，组内按照pname排序，有pname的在前
    @Override
    public int compareTo(OrderBean o) {
        int compare = this.pid.compareTo(o.pid);
        if (compare == 0) {
            return o.getPname().compareTo(this.getPname());
        } else {
            return compare;
        }
    }
 
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeUTF(id);
        out.writeUTF(pid);
        out.writeInt(amount);
        out.writeUTF(pname);
    }
 
    @Override
    public void readFields(DataInput in) throws IOException {
        id = in.readUTF();
        pid = in.readUTF();
        amount = in.readInt();
        pname = in.readUTF();
    }
}

（2）编写TableMapper类

package com.atguigu.reducejoin;
 
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
 
import java.io.IOException;
 
public class OrderMapper extends Mapper {
 
    private String filename;
 
    private OrderBean order = new OrderBean();
 
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        
        //获取切片文件名
        FileSplit fs = (FileSplit) context.getInputSplit();
        filename = fs.getPath().getName();
    }
 
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\t");
        
        //对不同数据来源分开处理
        if ("order.txt".equals(filename)) {
            order.setId(fields[0]);
            order.setPid(fields[1]);
            order.setAmount(Integer.parseInt(fields[2]));
            order.setPname("");
        } else {
            order.setPid(fields[0]);
            order.setPname(fields[1]);
            order.setAmount(0);
            order.setId("");
        }
 
        context.write(order, NullWritable.get());
    }
}

（3）编写TableReducer类

package com.atguigu.reducejoin;
 
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Reducer;
 
import java.io.IOException;
import java.util.Iterator;
 
public class OrderReducer extends Reducer {
 
    @Override
    protected void reduce(OrderBean key, Iterable values, Context context) throws IOException, InterruptedException {
        
        //第一条数据来自pd，之后全部来自order
        Iterator iterator = values.iterator();
        
        //通过第一条数据获取pname
        iterator.next();
        String pname = key.getPname();
        
        //遍历剩下的数据，替换并写出
        while (iterator.hasNext()) {
            iterator.next();
            key.setPname(pname);
            context.write(key,NullWritable.get());
        }
    }
}

（4）编写TableDriver类

package com.atguigu.reducejoin;
 
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 
import java.io.IOException;
 
public class OrderDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Job job = Job.getInstance(new Configuration());
        job.setJarByClass(OrderDriver.class);
 
        job.setMapperClass(OrderMapper.class);
        job.setReducerClass(OrderReducer.class);
        job.setGroupingComparatorClass(OrderComparator.class);
 
        job.setMapOutputKeyClass(OrderBean.class);
        job.setMapOutputValueClass(NullWritable.class);
 
        job.setOutputKeyClass(OrderBean.class);
        job.setOutputValueClass(NullWritable.class);
 
        FileInputFormat.setInputPaths(job, new Path("d:\\input"));
        FileOutputFormat.setOutputPath(job, new Path("d:\\output"));
 
        boolean b = job.waitForCompletion(true);
 
        System.exit(b ? 0 : 1);
 
    }
}

缺点：这种方式中，合并的操作是在Reduce阶段完成，Reduce端的处理压力太大，Map节点的运算负载则很低，资源利用率不高，且在Reduce阶段极易产生数据倾斜。

Map Join****

Map Join适用于一张表十分小、一张表很大的场景。

在Reduce端处理过多的表，非常容易产生数据倾斜。怎么办？

在Map端缓存多张表，提前处理业务逻辑，这样增加Map端业务，减少Reduce端数据的压力，尽可能的减少数据倾斜。

在Mapper的setup阶段，将文件读取到缓存集合中。

在驱动函数中加载缓存。

（1）先在驱动模块中添加缓存文件

package test;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 
public class DistributedCacheDriver {
 
public static void main(String[] args) throws Exception {

// 0 根据自己电脑路径重新配置
args = new String[]{"e:/input/inputtable2", "e:/output1"};
 
// 1 获取job信息
Configuration configuration = new Configuration();
Job job = Job.getInstance(configuration);
 
// 2 设置加载jar包路径
job.setJarByClass(DistributedCacheDriver.class);
 
// 3 关联map
job.setMapperClass(DistributedCacheMapper.class);

// 4 设置最终输出数据类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
 
// 5 设置输入输出路径
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
 
// 6 加载缓存数据
job.addCacheFile(new URI("file:///e:/input/inputcache/pd.txt"));

// 7 Map端Join的逻辑不需要Reduce阶段，设置reduceTask数量为0
job.setNumReduceTasks(0);
 
// 8 提交
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}

（2）读取缓存的文件数据

package com.atguigu.mapjoin;
 
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
 
public class MjMapper extends Mapper {
 
    //pd表在内存中的缓存
    private Map pMap = new HashMap<>();
 
    private Text line = new Text();
 
    //任务开始前将pd数据缓存进PMap
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        
        //从缓存文件中找到pd.txt
        URI[] cacheFiles = context.getCacheFiles();
        Path path = new Path(cacheFiles[0]);
 
        //获取文件系统并开流
        FileSystem fileSystem = FileSystem.get(context.getConfiguration());
        FSDataInputStream fsDataInputStream = fileSystem.open(path);
 
        //通过包装流转换为reader
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(fsDataInputStream, "utf-8"));
 
        //逐行读取，按行处理
        String line;
        while (StringUtils.isNotEmpty(line = bufferedReader.readLine())) {
            String[] fields = line.split("\t");
            pMap.put(fields[0], fields[1]);
        }
 
        //关流
        IOUtils.closeStream(bufferedReader);
 
    }
 
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\t");
 
        String pname = pMap.get(fields[1]);
 
        line.set(fields[0] + "\t" + pname + "\t" + fields[2]);
 
        context.write(line, NullWritable.get());
    }
}

计数器应用

Hadoop为每个作业维护若干内置计数器，以描述多项指标。例如，某些计数器记录已处理的字节数和记录数，使用户可监控已处理的输入数据量和已产生的输出数据量。

数据清洗（ETL）

在运行核心业务MapReduce程序之前，往往要先对数据进行清洗，清理掉不符合用户要求的数据。清理的过程往往只需要运行Mapper程序，不需要运行Reduce程序。

（1）编写LogMapper类

package com.atguigu.mapreduce.weblog;
import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
 
public class LogMapper extends Mapper{

Text k = new Text();

@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

// 1 获取1行数据
String line = value.toString();

// 2 解析日志
boolean result = parseLog(line,context);

// 3 日志不合法退出
if (!result) {
return;
}

// 4 设置key
k.set(line);

// 5 写出数据
context.write(k, NullWritable.get());
}
 
// 2 解析日志
private boolean parseLog(String line, Context context) {
 
// 1 截取
String[] fields = line.split(" ");

// 2 日志长度大于11的为合法
if (fields.length > 11) {
 
// 系统计数器
context.getCounter("map", "true").increment(1);
return true;
}else {
context.getCounter("map", "false").increment(1);
return false;
}
}
}

（2）编写LogDriver类

package com.atguigu.mapreduce.weblog;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 
public class LogDriver {
 
public static void main(String[] args) throws Exception {
 
// 输入输出路径需要根据自己电脑上实际的输入输出路径设置
        args = new String[] { "e:/input/inputlog", "e:/output1" };
 
// 1 获取job信息
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
 
// 2 加载jar包
job.setJarByClass(LogDriver.class);
 
// 3 关联map
job.setMapperClass(LogMapper.class);
 
// 4 设置最终输出类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
 
// 设置reducetask个数为0
job.setNumReduceTasks(0);
 
// 5 设置输入和输出路径
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
 
// 6 提交
job.waitForCompletion(true);
}
}

总结

Linux性能分析、调优套路以及工具总结

2026-04-09T06:42:38.000Z

分析性能问题

从系统资源瓶颈的角度来说，USE 法是最为有效的方法，即从使用率、饱和度以及错误数这三个方面，来分析 CPU、内存、磁盘和文件系统 I/O、网络以及内核资源限制等各类软硬件资源。

从应用程序瓶颈的角度来说，资源瓶颈跟系统资源瓶颈，本质是一样的。依赖服务瓶颈，你可以使用全链路跟踪系统进行定位。而应用自身的问题，你可以通过系统调用、热点函数，或者应用自身的指标监控以及日志监控等，进行分析定位。

值得注意的是，虽然我把瓶颈分为了系统和应用两个角度，但在实际运行时，这两者往往是相辅相成、相互影响的。系统是应用的运行环境，系统的瓶颈会导致应用的性能下降；而应用的不合理设计，也会引发系统资源的瓶颈。我们做性能分析，就是要结合应用程序和操作系统的原理，揪出引发问题的真凶。

系统资源瓶颈

USE 法，即使用率、饱和度以及错误数这三类指标来衡量。

资源列表：

CPU、内存、磁盘和文件系统以及网络等，都是最常见的硬件资源。
文件描述符数、连接跟踪数、套接字缓冲区大小等，则是典型的软件资源。

收到监控系统告警时，就可以对照这些资源列表，再根据指标的不同来进行定位。

系统资源：CPU 性能分析

利用 top、vmstat、pidstat、strace 以及 perf 等几个最常见的工具，获取 CPU 性能指标后，再结合进程与 CPU 的工作原理，就可以迅速定位出 CPU 性能瓶颈的来源。

top、pidstat、vmstat 这类工具所汇报的 CPU 性能指标，都源自 /proc 文件系统（比如 /proc/loadavg、/proc/stat、/proc/softirqs 等）。这些指标，都应该通过监控系统监控起来。

收到系统的用户 CPU 使用率过高告警时，从监控系统中直接查询到，导致 CPU 使用率过高的进程；然后再登录到进程所在的 Linux 服务器中，分析该进程的行为。使用 strace，查看进程的系统调用汇总；也可以使用 perf 等工具，找出进程的热点函数；甚至还可以使用动态追踪的方法，来观察进程的当前执行过程，直到确定瓶颈的根源。

系统资源：内存性能分析

free 和 vmstat 输出的性能指标，确认内存瓶颈；然后，再根据内存问题的类型，进一步分析内存的使用、分配、泄漏以及缓存等，最后找出问题的来源。

很多内存的性能指标，也来源于 /proc 文件系统（比如 /proc/meminfo、/proc/slabinfo 等），它们也都应该通过监控系统监控起来。

收到内存不足的告警时，首先可以从监控系统中。找出占用内存最多的几个进程。然后，再根据这些进程的内存占用历史，观察是否存在内存泄漏问题。确定出最可疑的进程后，再登录到进程所在的 Linux 服务器中，分析该进程的内存空间或者内存分配，最后弄清楚进程为什么会占用大量内存。

系统资源：磁盘和文件系统 I/O 性能分析

iostat ，发现磁盘 I/O 存在性能瓶颈（比如 I/O 使用率过高、响应时间过长或者等待队列长度突然增大等）后，可以再通过 pidstat、 vmstat 等，确认 I/O 的来源。接着，再根据来源的不同，进一步分析文件系统和磁盘的使用率、缓存以及进程的 I/O 等，从而揪出 I/O 问题的真凶。

很多磁盘和文件系统的性能指标，也来源于 /proc 和 /sys 文件系统（比如 /proc/diskstats、/sys/block/sda/stat 等）。自然，它们也应该通过监控系统监控起来。

发现某块磁盘的 I/O 使用率为 100% 时，首先可以从监控系统中，找出 I/O 最多的进程。然后，再登录到进程所在的 Linux 服务器中，借助 strace、lsof、perf 等工具，分析该进程的 I/O 行为。最后，再结合应用程序的原理，找出大量 I/O 的原因。

系统资源：网络性能分析

网络接口和内核资源

从 Linux 网络协议栈的原理来切入。包括应用层、套机字接口、传输层、网络层以及链路层等。通过使用率、饱和度以及错误数这几类性能指标，观察是否存在性能问题。

在链路层，可以从网络接口的吞吐量、丢包、错误以及软中断和网络功能卸载等角度分析；
在网络层，可以从路由、分片、叠加网络等角度进行分析；
在传输层，可以从 TCP、UDP 的协议原理出发，从连接数、吞吐量、延迟、重传等角度进行分析；在应用层，可以从应用层协议（如 HTTP 和 DNS）、请求数（QPS）、套接字缓存等角度进行分析。

网络的性能指标也都来源于内核，包括 /proc 文件系统（如 /proc/net）、网络接口以及 conntrack 等内核模块。这些指标同样需要被监控系统监控。

收到网络不通的告警时，就可以从监控系统中，查找各个协议层的丢包指标，确认丢包所在的协议层。然后，从监控系统的数据中，确认网络带宽、缓冲区、连接跟踪数等软硬件，是否存在性能瓶颈。最后，再登录到发生问题的 Linux 服务器中，借助 netstat、 tcpdump、bcc 等工具，分析网络的收发数据，并且结合内核中的网络选项以及 TCP 等网络协议的原理，找出问题的来源。

应用程序瓶颈

最典型的应用程序性能问题，就是**吞吐量（并发请求数）下降、错误率升高以及响应时间增大**。

第一种资源瓶颈，其实还是指刚才提到的 CPU、内存、磁盘和文件系统 I/O、网络以及内核资源等各类软硬件资源出现了瓶颈，从而导致应用程序的运行受限。对于这种情况，我们就可以用前面系统资源瓶颈模块提到的各种方法来分析。
第二种依赖服务的瓶颈，也就是诸如数据库、分布式缓存、中间件等应用程序，直接或者间接调用的服务出现了性能问题，从而导致应用程序的响应变慢，或者错误率升高。这说白了就是跨应用的性能问题，使用全链路跟踪系统，就可以帮你快速定位这类问题的根源。
最后一种，应用程序自身的性能问题，包括了多线程处理不当、死锁、业务算法的复杂度过高等等。对于这类问题，观察关键环节的耗时和内部执行过程中的错误，就可以帮你缩小问题的范围。

需要应用程序在设计和开发时，就提供出这些指标，以便监控系统可以了解应用程序的内部运行状态。如果这些手段过后还是无法找出瓶颈，你还可以用系统资源模块提到的各类进程分析工具，来进行分析定位。

优化性能问题

从系统的角度来说，CPU、内存、磁盘和文件系统 I/O、网络以及内核数据结构等各类软硬件资源，需要优化。

从应用程序的角度来说，降低 CPU 使用，减少数据访问和网络 I/O，使用缓存、异步处理以及多进程多线程等，都是常用的性能优化方法。除了这些单机优化方法，调整应用程序的架构，或是利用水平扩展，将任务调度到多台服务器中并行处理，也是常用的优化思路。

一定要避免过早优化。性能优化往往会提高复杂性，这一方面降低了可维护性，另一方面也为适应复杂多变的新需求带来障碍。

性能优化最好是逐步完善，动态进行；不追求一步到位，而要首先保证，能满足当前的性能要求。

发现性能不满足要求或者出现性能瓶颈后，再根据性能分析的结果，选择最重要的性能问题进行优化。

系统优化

CPU 优化

第一种，把进程绑定到一个或者多个 CPU 上，充分利用 CPU 缓存的本地性，并减少进程间的相互影响。
第二种，为中断处理程序开启多 CPU 负载均衡，以便在发生大量中断时，可以充分利用多 CPU 的优势分摊负载。
第三种，使用 Cgroups 等方法，为进程设置资源限制，避免个别进程消耗过多的 CPU。同时，为核心应用程序设置更高的优先级，减少低优先级任务的影响。

内存优化

可用内存不足、内存泄漏、 Swap 过多、缺页异常过多以及缓存过多等等

第一种，除非有必要，Swap 应该禁止掉。这样就可以避免 Swap 的额外 I/O ，带来内存访问变慢的问题。
第二种，使用 Cgroups 等方法，为进程设置内存限制。这样就可以避免个别进程消耗过多内存，而影响了其他进程。对于核心应用，还应该降低 oom_score，避免被 OOM 杀死。
第三种，使用大页、内存池等方法，减少内存的动态分配，从而减少缺页异常。

磁盘和文件系统 I/O 优化

第一种，也是最简单的方法，通过 SSD 替代 HDD、或者使用 RAID 等方法，提升 I/O 性能。
第二种，针对磁盘和应用程序 I/O 模式的特征，选择最适合的 I/O 调度算法。比如， SSD 和虚拟机中的磁盘，通常用的是 noop 调度算法；而数据库应用，更推荐使用 deadline 算法。
第三，优化文件系统和磁盘的缓存、缓冲区，比如优化脏页的刷新频率、脏页限额，以及内核回收目录项缓存和索引节点缓存的倾向等等。
除此之外，使用不同磁盘隔离不同应用的数据、优化文件系统的配置选项、优化磁盘预读、增大磁盘队列长度等，也都是常用的优化思路。

网络优化

从内核资源和网络协议的角度来说，我们可以对内核选项进行优化，比如：
- 可以增大套接字缓冲区、连接跟踪表、最大半连接数、最大文件描述符数、本地端口范围等内核资源配额；
- 可以减少 TIMEOUT 超时时间、SYN+ACK 重传数、Keepalive 探测时间等异常处理参数；
- 可以开启端口复用、反向地址校验，并调整 MTU 大小等降低内核的负担。
其次，从网络接口的角度来说，我们可以考虑对网络接口的功能进行优化，
- 将原来 CPU 上执行的工作，卸载到网卡中执行，即开启网卡的 GRO、GSO、 RSS、VXLAN 等卸载功能；
- 可以开启网络接口的多队列功能，这样，每个队列就可以用不同的中断号，调度到不同 CPU 上执行；
- 可以增大网络接口的缓冲区大小以及队列长度等，提升网络传输的吞吐量。
- 在极限性能情况（比如 C10M）下，内核的网络协议栈可能是最主要的性能瓶颈，所以，一般会考虑绕过内核协议栈。
  - 可以使用 DPDK 技术，跳过内核协议栈，直接由用户态进程用轮询的方式，来处理网络请求。同时，再结合大页、CPU 绑定、内存对齐、流水线并发等多种机制，优化网络包的处理效率。
  - 还可以使用内核自带的 XDP 技术，在网络包进入内核协议栈前，就对其进行处理。这样，也可以达到目的，获得很好的性能。

应用程序优化

系统的软硬件资源，是保证应用程序正常运行的基础，性能优化的最佳位置，还是应用程序内部。

系统 CPU 使用率（sys%）过高的问题。有时候出现问题，虽然表面现象是系统 CPU 使用率过高，应用程序的不合理系统调用才是罪魁祸首。这种情况下，优化应用程序内部系统调用的逻辑，显然要比优化内核要简单也有用得多。
数据库的 CPU 使用率高、I/O 响应慢，也是最常见的一种性能问题。并不是因为数据库本身性能不好，而是应用程序不合理的表结构或者 SQL 查询语句导致的。这时候，优化应用程序中数据库表结构的逻辑或者 SQL 语句，显然要比优化数据库本身，能带来更大的收益。

所以，在观察性能指标时，先查看应用程序的响应时间、吞吐量以及错误率等指标，因为它们才是性能优化要解决的终极问题。

第一，从 CPU 使用的角度来说，简化代码、优化算法、异步处理以及编译器优化等，都是常用的降低 CPU 使用率的方法，这样可以利用有限的 CPU 处理更多的请求。
第二，从数据访问的角度来说，使用缓存、写时复制、增加 I/O 尺寸等，都是常用的减少磁盘 I/O 的方法，这样可以获得更快的数据处理速度。
第三，从内存管理的角度来说，使用大页、内存池等方法，可以预先分配内存，减少内存的动态分配，从而更好地内存访问性能。
第四，从网络的角度来说，使用 I/O 多路复用、长连接代替短连接、DNS 缓存等方法，可以优化网络 I/O 并减少网络请求数，从而减少网络延时带来的性能问题。
第五，从进程的工作模型来说，异步处理、多线程或多进程等，可以充分利用每一个 CPU 的处理能力，从而提高应用程序的吞吐能力。
除此之外，你还可以使用消息队列、CDN、负载均衡等各种方法，来优化应用程序的架构，将原来单机要承担的任务，调度到多台服务器中并行处理。这样也往往能获得更好的整体性能。

工具

从性能指标出发，根据性能指标的不同，找工具。

info 可以理解为 man 的详细版本，只有在 man 的输出不太好理解时，才会再去参考 info 文档。

有些工具不需要额外安装，就可以直接使用，比如内核的 /proc 文件系统；

而有些工具，则需要安装额外的软件包，比如 sar、pidstat、iostat 等。

CPU 性能工具

内存性能工具

磁盘 I/O 性能工具

网络性能工具

基准测试工具

除了性能分析外，我们还需要对系统性能进行基准测试。比如，使用 fio 工具，测试磁盘 I/O 的性能。使用 iperf、pktgen 等，测试网络的性能。使用 ab、wrk 等，测试 Nginx 应用的性能。

总结

从性能瓶颈出发，根据系统和应用程序的运行原理，确认待分析的性能指标。
选出最合适的性能工具，然后了解并使用工具，从而更快观测到需要的性能数据。

当然，正如咱们专栏一直强调的，不要把性能工具当成性能分析和优化的全部。

一方面，性能分析和优化的核心，是对系统和应用程序运行原理的掌握，而性能工具只是辅助你更快完成这个过程的帮手。
另一方面，完善的监控系统，可以提供绝大部分性能分析所需的基准数据。从这些数据中，你很可能就能大致定位出性能瓶颈，也就不用再去手动执行各类工具了。

Kubernetes

2026-04-09T06:42:38.000Z

docker-email=2427785116@qq.com

##命令格式
kubectl create secret docker-registry regcred
–docker-server=<你的镜像仓库服务器>
–docker-username=<你的用户名>
–docker-password=<你的密码>
–docker-email=<你的邮箱地址>




```yaml
apiVersion: v1
kind: Pod
metadata:
  name: private-nginx
spec:
  containers:
  - name: private-nginx
    image: dockerhub123456wk/redis:v1.0
  imagePullSecrets:
  - name: dockerhub123456wk-docker

3、Kubernetes卸载

按照顺序执行以下命令：

sudo kubeadm reset -f
sudo rm -rvf $HOME/.kube
sudo rm -rvf ~/.kube/
sudo rm -rvf /etc/kubernetes/
sudo rm -rvf /etc/systemd/system/kubelet.service.d
sudo rm -rvf /etc/systemd/system/kubelet.service
sudo rm -rvf /usr/bin/kube*
sudo rm -rvf /etc/cni
sudo rm -rvf /opt/cni
sudo rm -rvf /var/lib/etcd
sudo rm -rvf /var/etcd

查看是否卸载

docker ps

查看是否有关kubernetes的相关容器启动。

没有则卸载成功。

Linux操作系统扫盲汇总

2026-04-09T06:42:38.000Z

Linux操作系统扫盲汇总

linux 基本概念概括

VFS 树链接：虚拟文件系统就是一个树，树的根部就是 / , 树上不同的节点，都会指向不同的物理地址（文件系统的目录树的不同节点其实是来自不同的分区），可以是具体的文件系统，或者网络节点，或者自己虚拟的节点。不同的dev就相当于是挂载到了树上的不同的节点，也就是一个文件夹
FD：文件描述符，指向INODE，进程打开文件的时候使用FD找到文件，同时FD是有数量限制的，默认是一个进程1024，可以使用ulimit -SHn 65535 临时修改，也可以修改文件 /etc/security/limits.conf 永久生效，在最后一行加入- nofile 65535参考
- FD是进程而言的，INODE是文件而言的，多个进程指向同一个文件，就是多个FD指向同一个INODE，
指针seek：每个应用（进程）读取文件的时候有自己的fd, 有自己的seek 指针
**inode** ：虚拟文件系统里面的每一个文件都有一个ID，每一个文件打开的时候在内存里面有一个
**/proc** : 内核映射目录，内核的一些属性。
- 系统的变量属性，进程的在这里都会在这里被映射成文件
- 只有开机之后才存在。
- /proc/$$ 获取和你当前交互的进程的ID号，$BASHPID 也可以获得
- /proc/$$/fd 目录下是当前进程的所有文件描述符
  - lsof -op $$ 更加细节，查看当前进程打开文件的文件描述符的细节
**page cache：（内核缓冲区就是这个）优化IO性能，优先走内存。**会开一个一个页缓存，默认大小是4K。内存里面对数据的缓存，物理内存是一份，两个程序是共享这个pc的，也就是第二个访问的时候是缓存命中了。
- 脏****page cache：会有一个flush的过程，
**缓存行****：CPU里面，**CPU Cache是由最小的存储区块-缓存行(cacheline)组成，缓存行大小通常为64byte。也就是一次读取的数据的大小。
- 一个缓存行对应多个内存块，所以缓存行有一个标志就是组标记tag区分不同的内存块，除了组标记Tag，还有实际数据data以及有效为valid bit，有效位是0的话无论CPU line中是否有数据都会直接访问内存。（具体看在MESI里面起到的作用）
- 有**伪共享**的问题，限制一行只放一个数据，就不会因为MESI导致的频繁将数据换入内存的问题发生
进程的NICE：涉及优先级的设置，越小优先级越高（其实是对应的虚拟运行时间越小，完全公平调度算法CFS就会优先调度这个进程。查看关于线程调度）
Linux内核对进程的完全公平调度CFS算法：是针对CPU普通进程的调度而言的，不涉及DeadLine和RealTIME任务，只是Fair任务，大多数的进程（线程（task_struct））都是普通的任务，都使用的是CFS算法，两碗水端平的思想。查看关于线程调度）
中断：硬中断，软中断
**异常：**故障，操作系统会将控制转移给相应的异常处理程序。如果处理程序能够修正这个错误情况，就将返回到引起异常的指令重新执行。否则，终止该应用程序。
陷阱：软中断的一种，就是系统调用
**中断向量表 IVT、中断描述符表 IDT：**中断向量表是一个通用的概念，在不同的架构下有不同的实现，比如在 x86 处理器下的实现是中断描述符表（Interrupt Descriptor Table，IDT）。
- **中断向量表（interrupt vector table，IVT）是由一系列中断向量（interrupt vector）组成的列表。每个中断向量都是一个中断处理程序的入口地址。**中断向量的类型包括：硬件中断、软件中断和处理器异常，这些事件在中断向量表中统一称作中断
- 当中断或异常产生时，由硬件负责产生一个中断标记，CPU 根据中断标记获得相应的**中断向量号****，然后将其作为偏移，在中断向量表中获得相应的处理程序地址，并执行。**链接

系统启动过程

BIOS uefi 工作
BIOS 自检：硬件是否有问题
BIOS 加载bootLoader到内存，
- BootLoader在硬盘上的位置也是写死的。硬盘的第一个扇区上，也就是主引导记录。BootLoader决定启动哪一个操作系统
读取可配置信息：
- CMOS ：存可以配置的信息，必须加电，不加电下次开机就没了；过几年密码也没了，因为自己的电池没电了。
OS的代码放到内存，从OS的指令位置开始执行，之后操作权利放给OS，

CPU和线程和内核

ALU：运算单元

控制单元

MMU ：内存管理单元，管理虚拟内存

超线程：

一个运算单元对应多组寄存器和PC，不切换线程了，而是直接切换寄存器，没有上下文切换了，

存储器的层次结构

速度不一样，寄存器，一级缓存（每个核一个），二级缓存（每个核一个），三级缓存（每一个CPU一个），主存（多个CPU共享）

CPU的乱序执行

指令1在读等待（等待内存磁盘返回），指令2不依赖指令1的话，CPU会提高效率让指令2 先执行

禁止指令重排：

CPU实现：使用内存屏障

单例为什么要加volatile

指令重排，提前指向了半初始化状态，

JVM 规范要求的4个内存屏障

具体实现的时候可以使用lock指令。

happens-before–java语言规范

就是一个保证规则，最后的效果就是看上去是没有重排序的

as if serial

像是顺序执行

不管如何重排序，单线程执行结果不变，看上去是Serial

用户态和内核态

CPU分为不同的指令级别，内核态可使用ring0级别的指针，用户态可以使用ring3级别的指令

Linux内核跑在ring 0级，用户程序是ring3级别，对于系统的关键访问，需要经过kernel的同意，保证系统的健壮性

内核执行的操作–> 200多个系统调用 sendFile read write pthread fork

JVM 在操作系统的角度就是一个普通的程序

线程和进程和纤程

进程是资源分配的基本单位，线程是调度的基本单位

线程就是一个进程的不同执行路径

在Linux里面线程其实就是一个普通的进程，因为他是通过fork来创建的，只不过和其他进程共享资源（内存空间，全局数据等等）。其他的操作系统都有自己所谓的LWP实现（Light Weight Process）

纤程：（用户空间级别的线程）线程中的线程，用户态的线程，切换和调度不需要经过OS

优势：占用资源少，OS的线程是1M，纤程是4K；切换简单不需要经过OS；可以启动好多个10w+，不像CPU多了就全是CPU切换了。

实现：java中没有内置纤程的支持，需要使用依赖包

不是对应操作系统里面的重量级线程，而是JVM内部自己调度的线程，原来的线程需要和硬件打交道，切换起来速度比较慢，不然CPU全耗在切换上了。多个纤程对应一个线程，每一个纤程都有自己的栈。

进程

Linux中也叫做Task，系统分配资源的基本单位

资源：独立的地址空间，内核数据结构（进程描述符…）全局变量、数据段…

进程描述符：PCB（ProcessControlBlock）

创建和启动

系统函数fork() exec()

从A中forkB的话，A就是B的父进程，

对于主进程 fork()返回新建的子进程ID，子进程fork()返回0

在语句pid=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了，这两个进程的代码部分完全相同，将要执行的下一条语句都是if(pid==0)……。
两个进程中，原先就存在的那个被称作“父进程”，新出现的那个被称作“子进程”。父子进程的区别除了进程标志符（process ID）不同外，变量pid的值也不相同，pid存放的是fork的返回值。fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：
在父进程中，fork返回新创建子进程的进程ID；
在子进程中，fork返回0；
如果出现错误，fork返回一个负值；
fork出错可能有两种原因：（1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。（2）系统内存不足，这时errno的值被设置为ENOMEM

僵尸进程和孤儿进程

僵尸进程：每一个父进程都会维护自己子进程的PCB结构，子进程退出之后，父进程释放PCB，但是父进程不释放那么子进程就是一个僵尸进程，此时子进程占用的空间就是PCB的大小
- ps -ef | grep defuct defuct 就是僵尸
孤儿进程：子进程在结束之前，父进程已经退出，孤儿进程就会被1号进程管理，也就是init进程。

内核线程（不重要）

内核独有，内核启动之后经常需要做一些后台操作，这些由Kernel Thread 来完成只在内核空间运行

进程调度

Linux内核什么时候开始运行，运行多长时间，每一个进程有自己对应的调度方案，可以指定，也可以自己实现内核调度方案给内核打补丁。

单任务独占到多任务分时，原则就是压榨CPU资源

抢占式：进程调度器强制开始或者暂停，抢占某一进程的执行

非抢占式：除非进程主动让出（yielding），否则一直运行

Linux的内核进程调度：Linux2.5 使用经典的Unix O(1) 调度策略，偏向服务器。时间片轮询，对交互不友好。Linux2.6.23 采用CFS完全公平调度策略算法 Completely Fair Scheduler，按照优先级分配时间片的比例，记录每一个进程的执行时间，如果有一个进程执行的时间不到他应该分配的比例，优先执行。

进程类型

IO 密集型：大部分时间都在用于等待IO
CPU密集型：大部分时间计算

进程优先级

实时进程 > 普通进程（0-99）
普通进程的nice值（-20 - 19）

时间分配

Linux采用按照优先级的CPU时间比
其他系统使用按优先级的时间片

Linux默认的调度策略（看导图）

**对于实时的进程：**使用SCHD_FIFO（优先级分高低）和 SCHED_RR（轮询）两种
- FIFO 是等级最高的，除非自己让出CPU否则一直会执行它，也就是除非更高级别的FIFO或者RR抢占它
- RR只是这种线程中是同级别FIFO的平均分配
**对于普通的进程：**使用CFS：按照优先级分配时间片的比例，记录每一个进程的执行时间，如果有一个进程执行时间不到他应该分配的比例，优先执行

只有实时的进程主动让出，或者执行完毕之后，普通的进程才有机会运行

中断

硬件的电信号控制了软件的输出

按键–> 中断控制器 –> CPU芯片 –> kernerl –> 中断处理程序 –> 上半场下半场

CPU芯片只是知道中断了，不知道中断谁，
会去操作系统找kernel，让kernel说出是中断谁，interrupt 80 中断，软中断就是80中断

中断是一个信号，内核暂停处理，不一定会处理。

硬中断：1号键盘，2号鼠标
软中断：read 。read、fork ,内核会停下自己，拿到参数去执行返回
- 系统调用：interrupt 0x80（C语言层面）或者 sysenter （原语层面）原语，通过ax寄存器填入调用号（调用号就代表使用的是几号函数，read fork等等）。参数通过bx cx dx si di 传入内核，返回值通过ax 返回
- java读网络：jvm read() –> c read() –> 内核空间也就是inter 80 这个中断 –> system_call() 系统调用处理程序，查看ax参数里面使用的内核函数 –> sys_read()，之后再去剩下的五个bx cx dx si di 读取参数 ，最后将结果写在ax,返回ax，程序去ax读取结果即可

int 0x80

系统调用会调用这个，这个会导致中断，中断映射表找到 callback的地址开始执行对应的系统调用

虚拟内存管理–MMU

发展历程

DOS：同一时间只有一个进程在运行

win 9x ：多个进程都放入1. 内存撑爆，2. 互相打扰，会访问到别人的空间

解决内存爆的问题：程序**分页**，内存划分为一个个个page frame页框，固定大小，装入分页之后的程序，页框大小就是4K，内存标准页大小就是4K，
- 局部性原理，时间局部性空间局部性
- 内存满了，进入swap交换分区，LRU算法
  - 其实就是LinkedHashMap的实现，也就是hashMap保证查找是O1，链表保证删除插入是O1
  - 还必须是双向链表就是为了避免找左右的时候还需要从头开始遍历
- 一个进程新建分配资源的时候只是分配了一张表，内存都没分配，记录了程序的页表在硬盘的位置就行了
- 缺页中断：内存中没有要使用的页面，产生缺页异常，由内核处理并且
解决相互打扰的问题：虚拟内存。直接访问程序的物理内存地址是比较危险的，为了保证不会互相影响，所以程序使用的空间地址不是物理空间，而是虚拟的地址，A永远访问不了B的地址
- 虚拟空间的大小：寻址空间，64位的操作系统就是 2^ 64的大小，只要自己可以表示就可以，单位是bit
- 在程序的角度，进程是独享整个系统+CPU的，每一个进程虚拟的独占整个CPU
- - **段页式：**进程的虚拟内存是分段的（按照程序功能），分段里面才是分页，需要该页的时候加载到页框
- 逻辑地址转换为虚拟空间的线性地址再映射到物理地址：内存映射的线性地址 = 基地址+偏移量（逻辑地址），操作系统+MMU来完成线性地址最终找到物理地址的转换
缺页异常：产生一个软中断去读取数据

MMU 虚拟内存管理单元

内存管理单元：使得每一个进程都有自己独立的虚拟地址空间。

作用：

地址转换：将线性地址映射为物理地址
提供硬件机制的内存访问授权

大多数使用MMU的机器都采用分页机制。虚拟地址空间以页为单位进行划分，而相应的物理地址空间也被划分，其使用的单位称为页帧，页帧和页必须保持相同，因为内存与外部存储器之间的传输是以页为单位进行传输的。

如果处理器启用了MMU，CPU执行单元发出的内存地址将被MMU截获，从CPU到MMU的地址称为虚拟地址（Virtual Address，以下简称VA），而MMU将这个地址翻译成另一个地址发到CPU芯片的外部地址引脚上，也就是将VA映射成PA

快表

快表其实是对MMU的加速，和MMU交互太慢所以直接和CPU里面的快表交互

物理内存

page cache

物理内存上是一个。但是可以有多个进程，每一个进程有自己的fd，维护自己的seek，所以页缓存是一份，但是不同的进程之间读取整个文件不会相互影响。（明析fd和INODE的关系，多个fd可以指向一个INODE，fd是针对进程而言的）

DMA-直接存储器访问

在实现DMA传输时，是由DMA控制器直接掌管总线，因此，存在着一个总线控制权转移问题。

即DMA传输前，CPU要把总线控制权交给DMA控制器，而在结束DMA传输后，DMA控制器应立即把总线控制权再交回给CPU。一个完整的DMA传输过程必须经过DMA请求、DMA响应、DMA传输、DMA结束4个步骤。

虚拟文件系统–VFS树

df -h 查看虚拟目录树挂载的真正物理地址

磁盘分区（也就是文件系统。都按照一定的文件系统规则进行了格式化****）挂载到VFS 树的不同目录节点，

其中系统启动会将内核的镜像文件系统（图中的/dev/sda1）加载之后，挂载到虚拟节点 /boot 下，会将操作系统（图中的/dev/mapper/centos-root）的文件系统挂载到虚拟节点 / 下，所以其实是 /dev/sda1 的文件系统覆盖了 /dev/mapper/centos-root 对于虚拟节点 /boot 的挂载，可以自己手动去除虚拟节点 /boot 上文件系统/dev/sda1 的挂载，得到 /boot 就是空的目录了

在将文件系统挂载到VFS树上的 /boot 虚拟节点上，文件夹里面又有了内容：

所以虚拟目录树是Linux的一个规范，结构是稳定化的。至于是哪一个文件系统挂载到这个树上的哪个节点是可以灵活改变的！！！

Linux 文件类型

冯诺依曼计算机：控制器（CPU）存储器（主存内存）输入输出设备（IO设设备）。

虚拟文件系统的抽象，就是一切皆文件。

- : 普通文件（可执行文件）TYPE=REG
d : 目录 TYPE=DIR
b : 块设备 TYPE=CHR，可以随意漂移，硬盘等等（/dev目录下）
c : 字符设备，不能随意漂移，键盘网卡都是（/dev目录下）
s : socket
p : pipline
l : 连接
eventPoll ：内存提供的epoll区域
等等

ls -l 之后第一列的内容就是文件的类型，之后的就是文件的权限，以及所属用户以及所属的用户组，文件大小

/dev 目录下会有c 开头的字符设备和 b 开头的块设备

Linux文件系统与磁盘工作原理

2026-04-09T06:42:38.000Z

磁盘为系统提供了最基本的持久化存储。

文件系统则在磁盘的基础上，提供了一个用来管理文件的树状结构。

“Linux 一切皆文件”的深刻含义。无论是普通文件和块设备、还是网络套接字和管道等，它们都通过统一的 VFS 接口来访问。

索引节点和目录项

文件系统，本身是**对存储设备上的文件进行组织管理的机制。组织方式不同，就会形成不同的文件系统。**

为方便管理，Linux 文件系统为每个文件都分配两个数据结构，索引节点（index node）和目录项（directory entry）。它们主要用来记录文件的元信息和目录结构。

索引节点，简称为 inode，用来记录文件的元数据，比如 inode 编号、文件大小、访问权限、修改日期、数据的位置等。索引节点和文件一一对应，它跟文件内容一样，都会被持久化存储到磁盘中。所以记住，索引节点同样占用磁盘空间。
目录项，简称为 dentry，用来记录文件的名字、索引节点指针以及与其他目录项的关联关系。多个关联的目录项，就构成了文件系统的目录结构。不过，不同于索引节点，目录项是由内核维护的一个内存数据结构，所以通常也被叫做目录项缓存。

目录项、索引节点、索引块、数据块以及超级块关系

索引节点是磁盘上每个文件实体的唯一标志
目录项维护的正是文件系统的树状结构。目录项和索引节点的关系是多对一，你可以简单理解为，一个文件可以有多个别名
举个例子，通过硬链接为文件创建的别名，就会对应不同的目录项，不过这些目录项本质上还是链接同一个文件，所以，它们的索引节点相同。

索引节点、目录项纪录了文件的元数据，以及文件间的目录关系，磁盘读写的最小单位是扇区，然而扇区只有 512B 大小，如果每次都读写这么小的单位，效率一定很低。所以，文件系统又把连续的扇区组成了逻辑块，然后每次都以逻辑块为最小单元，来管理数据。常见的逻辑块大小为 4KB，也就是由连续的 8 个扇区组成。

processon

目录项本身就是一个内存缓存，而索引节点则是存储在磁盘中的数据。
磁盘在执行文件系统格式化时，会被分成三个存储区域，超级块、索引节点区和数据块区。
- 超级块，存储整个文件系统的状态。
- 索引节点区，用来存储索引节点。
- 数据块区，则用来存储文件数据。

虚拟文件系统

为了支持各种不同的文件系统，Linux 内核**在用户进程和文件系统的中间，又引入了一个抽象层，也就是虚拟文件系统 VFS（Virtual File System）。**

VFS 定义了一组所有文件系统都支持的数据结构和标准接口。用户进程和内核中的其他子系统，只需要跟 VFS 提供的统一接口进行交互就可以了，而不需要再关心底层各种文件系统的实现细节。

VFS 内部又通过目录项、索引节点、逻辑块以及超级块等数据结构，来管理文件。

目录项，记录了文件的名字，以及文件与其他目录项之间的目录关系。
索引节点，记录了文件的元数据。
逻辑块，是由连续磁盘扇区构成的最小读写单元，用来存储文件数据。
超级块，用来记录文件系统整体的状态，如索引节点和逻辑块的使用情况等。

目录项是一个内存缓存；而超级块、索引节点和逻辑块，都是存储在磁盘中的持久化数据。

系统调用、VFS、缓存、文件系统以及块存储

processon

文件系统可以分为三类。

第一类是**基于磁盘的文件系统，也就是把数据直接存储在计算机本地挂载的磁盘中**。常见的 Ext4、XFS、OverlayFS 等，都是这类文件系统。
第二类是**基于内存的文件系统，也就是我们常说的虚拟文件系统。不需要任何磁盘分配存储空间，但会占用内存。我们经常用到的 /proc 文件系统，其实就是一种最常见的虚拟文件系统。此外，/sys 文件系统也属于这一类，主要向用户空间导出层次化的内核对象。**
第三类是**网络文件系统，也就是用来访问其他计算机数据的文件系统**，比如 NFS、 SMB、iSCSI 等。

这些文件系统，要先**挂载到 VFS 目录树中的某个子目录（称为挂载点），然后才能访问其中的文件。**

基于磁盘的文件系统在安装系统时，要先挂载一个根目录（/），
在根目录下再把其他文件系统（比如其他的磁盘分区、/proc 文件系统、/sys 文件系统、NFS 等）挂载进来。

文件系统 I/O

把文件系统挂载到挂载点后，就能**通过挂载点，再去访问它管理的文件了。VFS 提供了一组标准的文件访问接口。这些接口以系统调用的方式，提供给应用程序使用**。

就拿 cat 命令来说，它首先调用 open() ，打开一个文件；然后调用 read() ，读取文件的内容；最后再调用 write() ，把文件内容输出到控制台的标准输出中。

文件 IO分类：缓冲与非缓冲 I/O、直接与非直接 I/O、阻塞与非阻塞 I/O、同步与异步 I/O

是否利用标准库缓存：缓冲 I/O 与非缓冲 I/O

缓冲 I/O，是指**利用标准库缓存来加速文件的访问，而标准库内部再通过系统调度访问文件**。
- 很多程序遇到换行时才真正输出，而换行前的内容，其实就是被标准库暂时缓存了起来。
非缓冲 I/O，是指**直接通过系统调用来访问文件**，不再经过标准库缓存。

无论缓冲 I/O 还是非缓冲 I/O，它们**最终还是要经过系统调用来访问文件**。系统调用后，还会通过页缓存，来减少磁盘的 I/O 操作。

是否利用操作系统的页缓存：直接 I/O 与非直接 I/O

直接 I/O，是指**跳过操作系统的页缓存，直接跟文件系统交互来访问文件。**
- 需要你在系统调用中，指定 O_DIRECT 标志。如果没有设置过，默认的是非直接 I/O。
非直接 I/O 正好相反，文件读写时，先要经过系统的页缓存，然后再由内核或额外的系统调用，真正写入磁盘。

直接 I/O、非直接 I/O，本质上还是和文件系统交互。如果是在数据库等场景中，你还会看到，跳过文件系统读写磁盘的情况，也就是我们通常所说的裸 I/O****。

应用程序是否阻塞自身运行：阻塞 I/O 和非阻塞 I/O

阻塞 I/O，是指应用程序执行** I/O 操作后，如果没有获得响应，就会阻塞当前线程**，自然就不能执行其他任务。
非阻塞 I/O，是指应用程序执行** I/O 操作后，不会阻塞当前的线程，可以继续执行其他的任务，随后再通过轮询或者事件通知****的形式，获取调用的结果。**
- 访问管道或者网络套接字时，设置 O_NONBLOCK 标志，就表示用非阻塞方式访问；而如果不做任何设置，默认的就是阻塞访问。
- 非阻塞 I/O，通常会跟 select/poll 配合，用在网络套接字的 I/O 中。

是否等待响应结果：可以把文件 I/O 分为同步和异步 I/O

同步 I/O，是指应用程序执行 I/O 操作后，要一直等到整个 I/O 完成后，才能获得 I/O 响应。
- 在操作文件时，如果你设置了 O_SYNC 或者 O_DSYNC 标志，就代表同步 I/O。如果设置了 O_DSYNC，就要等文件数据写入磁盘后，才能返回；而 O_SYNC，则是在 O_DSYNC 基础上，要求文件元数据也要写入磁盘后，才能返回。
异步 I/O，是指应用程序执行 I/O 操作后，不用等待完成和完成后的响应，而是继续执行就可以。等到这次 I/O 完成后，响应会**用事件通知的方式，告诉应用程序。**
- 访问管道或者网络套接字时，设置了 O_ASYNC 选项后，相应的 I/O 就是异步 I/O。这样，内核会再通过 SIGIO 或者 SIGPOLL，来通知进程文件是否可读写。

同步异步和阻塞非阻塞的区别

不同角度的 I/O 划分方式：根据应用程序**是否阻塞自身运行或者I/O 响应的通知方式的不同**
描述的对象不同，阻塞 / 非阻塞针对的是 I/O 调用者（即应用程序），而同步 / 异步针对的是 I/O 执行者（即系统）。

性能观测

容量

文件数据的使用情况

df 命令，就能查看文件系统的磁盘空间使用情况

总空间用 1K-blocks 的数量来表示，你可以给 df 加上 -h 选项，以获得更好的可读性：

索引节点的使用情况

除了文件数据，索引节点也占用磁盘空间。你可以给 df 命令加上 -i 参数，查看索引节点的使用情况：

索引节点的容量，（也就是 Inode 个数）是在格式化磁盘时设定好的，一般由格式化工具自动生成。当你发现索引节点空间不足，但磁盘空间充足时，很可能就是过多小文件导致的。

一般来说，删除这些小文件，或者把它们移动到索引节点充足的其他磁盘中，就可以解决这个问题。

缓存

可以用 free 或 vmstat，来观察页缓存的大小。

Cache : 页缓存和可回收 Slab 缓存的和

free 输出的 Cache，是页缓存和可回收 Slab 缓存的和，可以从 /proc/meminfo ，直接得到它们的大小：

1	cat /proc/meminfo \| grep -E "SReclaimable\|Cached"

Buffer 以及文件系统中的目录项和索引节点缓存

文件名以及文件之间的目录关系，都放在目录项缓存中。而这是一个基于内存的数据结构，会根据需要动态构建。所以，查找文件时，Linux 就会动态构建不在缓存中的目录项结构，导致 dentry 缓存升高。

除了目录项缓存增加，Buffer 的使用也会增加。如果你用** vmstat 1 **观察一下，会发现 Buffer 和 Cache 都在增长，Buffer 的增长是因为，构建目录项缓存所需的元数据（比如文件名称、索引节点等），需要从文件系统中读取。

内核使用 Slab 机制，管理目录项和索引节点的缓存。/proc/meminfo 只给出了 Slab 的整体大小，具体到每一种 Slab 缓存，还要查看 /proc/slabinfo 这个文件。

所有目录项和各种文件系统索引节点的缓存情况：

1	cat /proc/slabinfo \| grep -E '^#\|dentry\|inode'

dentry 行表示目录项缓存，
inode_cache 行，表示 VFS 索引节点缓存，其余的则是各种文件系统的索引节点缓存。

/proc/slabinfo 的列比较多，在实际性能分析中，我们更常使用 slabtop ，来找到占用内存最多的缓存类型。

按下 c 按照缓存大小排序，按下 a 按照活跃对象数排序

slabtop

文件系统总结

文件系统：是对存储设备上的文件，进行组织管理的一种机制。

VFS：为了支持各类不同的文件系统，Linux 在各种文件系统实现上，抽象了一层虚拟文件系统（VFS）。VFS 定义了一组所有文件系统都支持的数据结构和标准接口。这样，用户进程和内核中的其他子系统，就只需要跟 VFS 提供的统一接口交互，而不需要关注文件系统的具体实现；对具体的文件系统来说，只需要按照 VFS 的标准，就可以无缝支持各种应用程序。

为了降低慢速磁盘对性能的影响，文件系统又通过页缓存、目录项缓存以及索引节点缓存，缓和磁盘延迟对应用程序的影响。

Linux 磁盘分类

磁盘按照存储介质来分类

机械和SSD的区别是什么？

机械磁盘，也称为硬盘驱动器（Hard Disk Driver），通常缩写为 HDD。盘片和读写磁头组成，数据就存储在盘片的环状磁道中。在读写数据前，需要移动读写磁头，定位到数据所在的磁道，然后才能访问数据。
- 如果 I/O 请求刚好连续，那就不需要磁道寻址，也就是（顺序）**连续 I/O **的工作原理。
- 随机 I/O，它需要不停地移动磁头，来定位数据位置，所以读写速度就会比较慢。
固态磁盘（Solid State Disk），通常缩写为 SSD，由固态电子元器件组成。固态磁盘不需要磁道寻址，所以，不管是连续 I/O，还是随机 I/O 的性能，都比机械磁盘要好得多。

（顺序）连续 I/O 可以通过预读的方式，来减少 I/O 请求的次数，这也是其性能优异的一个原因。很多性能优化的方案，也都会从这个角度出发，来优化 I/O 性能。

机械磁盘和固态磁盘还分别有一个最小的读写单位。机械磁盘的最小读写单位是扇区，一般大小为 512 字节。而固态磁盘的最小读写单位是页，通常大小是 4KB、8KB 等。

如果每次都读写 512 字节这么小的单位的话，效率很低。所以，文件系统会把连续的扇区或页，组成逻辑块，然后以逻辑块作为最小单元来管理数据。常见的逻辑块的大小是 4KB，也就是说，连续 8 个扇区，或者单独的一个页，都可以组成一个逻辑块。

SSD的随机访问性能好吗？

无论机械磁盘，还是固态磁盘，相同磁盘的随机 I/O 都要比连续 I/O 慢很多，

对机械磁盘来说，随机 I/O 需要更多的磁头寻道和盘片旋转，它的性能自然要比连续 I/O 慢。

对固态磁盘来说，虽然它的随机性能比机械硬盘好很多，但**同样存在“先擦除再写入”的限制。随机读写会导致大量的垃圾回收**，所以相对应的，随机 I/O 的性能比起连续 I/O 来，也还是差了很多。

磁盘按照接口来分类

硬盘分为 IDE（Integrated Drive Electronics）、SCSI（Small Computer System Interface）、SAS（Serial Attached SCSI）、SATA（Serial ATA）、FC（Fibre Channel）等。

不同的接口，往往分配不同的设备名称。比如， IDE 设备会分配一个 hd 前缀的设备名， SCSI 和 SATA 设备会分配一个 sd 前缀的设备名。如果是多块同类型的磁盘，就会按照 a、b、c 等的字母顺序来编号。

磁盘按照架构来分类

当把磁盘接入服务器后，按照不同的使用方式，又可以把它们划分为多种不同的架构。

作为独立磁盘设备来使用。往往还会根据需要，划分为不同的逻辑分区，每个分区再用数字编号。/dev/sda 还可以分成两个分区 /dev/sda1 和 /dev/sda2。
多块磁盘组合成一个逻辑磁盘，构成冗余独立磁盘阵列，也就是 RAID（Redundant Array of Independent Disks），从而可以提高数据访问的性能，并且**增强数据存储的可靠性。**
- RAID0 有最优的读写性能，但不提供数据冗余的功能。
- 而其他级别的 RAID，在提供数据冗余的基础上，对读写性能也有一定程度的优化。
最后一种架构，是把这些磁盘组合成一个网络存储集群，再通过 NFS、SMB、iSCSI 等网络存储协议，暴露给服务器使用。

其实在 Linux 中，磁盘实际上是作为一个块设备来管理的，也就是以块为单位读写数据，并且支持随机读写。每个块设备都会被赋予两个设备号，分别是主、次设备号。主设备号用在驱动程序中，用来区分设备类型；而次设备号则是用来给多个同类设备编号。

通用块层

虚拟文件系统 VFS 类似，为了减小不同块设备的差异带来的影响， Linux 通过一个统一的通用块层，来管理各种不同的块设备。

processon

通用块层，其实是处在文件系统和磁盘驱动中间的一个块设备抽象层。它主要有两个功能。

第一个功能跟虚拟文件系统的功能类似。向上，为文件系统和应用程序，提供访问块设备的标准接口；向下，把各种异构的磁盘设备抽象为统一的块设备，并提供统一框架来管理这些设备的驱动程序。
第二个功能，通用块层还会给文件系统和应用程序发来的 I/O 请求排队，并通过重新排序、请求合并等方式，提高磁盘读写的效率。也就是 I/O 调度。

通用块层的IO调度算法

事实上，Linux 内核支持四种 I/O 调度算法，分别是 NONE、NOOP、CFQ 以及 DeadLine。

**第一种 NONE **，更确切来说，并不能算 I/O 调度算法。因为它完全不使用任何 I/O 调度器，对文件系统和应用程序的 I/O 其实不做任何处理，常用在虚拟机中（此时磁盘 I/O 调度完全由物理机负责）。
**第二种 NOOP **，是最简单的一种 I/O 调度算法。它实际上是一个先入先出的队列，只做一些最基本的请求合并，常用于 SSD 磁盘。
第三种 CFQ（Completely Fair Scheduler），也被称为完全公平调度器，是现在很多发行版的默认 I/O 调度器，它为每个进程维护了一个 I/O 调度队列，并按照时间片来均匀分布每个进程的 I/O 请求。类似于进程 CPU 调度，CFQ 还支持进程 I/O 的优先级调度，所以它适用于运行大量进程的系统，像是桌面环境、多媒体应用等。
DeadLine 调度算法，分别为读、写请求创建了不同的 I/O 队列，可以提高机械磁盘的吞吐量，并确保**达到最终期限（deadline）的请求被优先处理。**DeadLine 调度算法，多用在 I/O 压力比较重的场景，比如数据库等。

总结：I/O 栈==文件系统层、通用块层和设备层

文件系统层，包括虚拟文件系统和其他各种文件系统的具体实现。它为上层的应用程序，提供标准的文件访问接口；对下会通过通用块层，来存储和管理磁盘数据。
通用块层，包括块设备 I/O 队列和 I/O 调度器。它会对文件系统的 I/O 请求进行排队，再通过重新排序和请求合并，然后才要发送给下一级的设备层。
- 通用块层是 Linux 磁盘 I/O 的核心。向上，它为文件系统和应用程序，提供访问了块设备的标准接口；向下，把各种异构的磁盘设备，抽象为统一的块设备，并会对文件系统和应用程序发来的 I/O 请求进行重新排序、请求合并等，提高了磁盘访问的效率。
设备层，包括存储设备和相应的驱动程序，负责最终物理设备的 I/O 操作。
**存储系统的 I/O **，通常是整个系统中最慢的一环。所以， Linux 通过多种缓存机制来优化 I/O 效率。
- 为了优化文件访问的性能，会使用页缓存、索引节点缓存、目录项缓存等多种缓存机制，以减少对下层块设备的直接调用。
- 同样，为了优化块设备的访问效率，会使用缓冲区，来缓存块设备的数据。

磁盘 I/O 性能指标

使用率、饱和度、IOPS、吞吐量以及响应时间等。这五个指标，是衡量磁盘性能的基本指标。

使用率，是指磁盘处理 I/O 的时间百分比。过高的使用率（比如超过 80%），通常意味着磁盘 I/O 存在性能瓶颈。
- 使用率只考虑有没有 I/O，而不考虑 I/O 的大小，换句话说，当使用率是 100% 的时候，磁盘依然有可能接受新的 I/O 请求。
饱和度，是指磁盘处理 I/O 的繁忙程度。过高的饱和度，意味着磁盘存在严重的性能瓶颈。当饱和度为 100% 时，磁盘无法接受新的 I/O 请求
IOPS（Input/Output Per Second），是指每秒的 I/O 请求**数**。
吞吐量，是指每秒的 I/O 请求**大小**。
响应时间，是指 I/O 请求从发出到收到响应的间隔时间。

不要孤立地去比较某一指标，而要结合读写比例、I/O 类型（随机还是连续）以及 I/O 的大小，综合来分析。在数据库、大量小文件等这类随机读写比较多的场景中，IOPS 更能反映系统的整体性能；而在多媒体等顺序读写较多的场景中，吞吐量才更能反映系统的整体性能。

磁盘 I/O 性能工具

磁盘 I/O 观测

在为应用程序的服务器选型时，要先对磁盘的 I/O 性能进行基准测试，以便可以准确评估，磁盘性能是否可以满足应用程序的需求。推荐用性能测试工具 fio ，来测试磁盘的 IOPS、吞吐量以及响应时间等。

测试出，不同 I/O 大小（一般是 512B 至 1MB 中间的若干值）分别在随机读、顺序读、随机写、顺序写等各种场景下的性能情况。用性能工具得到的这些指标，可以作为后续分析应用程序性能的依据。一旦发生性能问题，你就可以把它们作为磁盘性能的极限值，进而评估磁盘 I/O 的使用情况。

每块磁盘的使用情况：iostat

iostat 是最常用的磁盘 I/O 性能观测工具，它提供了**每个磁盘的使用率、IOPS、吞吐量**等各种常见的性能指标，当然，这些指标实际上来自 /proc/diskstats。

-d -x 表示显示所有磁盘 I/O 的指标

第一列的 Device 表示磁盘设备的名字

%util ，磁盘 I/O 使用率；

r/s+ w/s ，就是 IOPS；

rkB/s+wkB/s ，就是吞吐量；

r_await+w_await ，就是响应时间。

结合请求的大小（ rareq-sz 和 wareq-sz）一起分析。从 iostat 并不能直接得到磁盘饱和度。可以把观测到的，平均请求队列长度或者读写请求完成的等待时间，跟基准测试的结果（比如通过 fio）进行对比，综合评估磁盘的饱和情况。

进程 I/O 观测

iostat 只提供磁盘整体的 I/O 性能数据，缺点在于，并不能知道具体是哪些进程在进行磁盘读写。

pidstat 实时查看

pidstat 加上 -d 参数，你就可以看到进程的 I/O 情况，

实时查看每一秒每个进程的 I/O 情况，包括下面这些内容。

用户 ID（UID）和进程 ID（PID）。

每秒读取的数据大小（kB_rd/s），单位是 KB。

每秒发出的写请求数据大小（kB_wr/s），单位是 KB。

每秒取消的写请求数据大小（kB_ccwr/s），单位是 KB。

iotop：I/O 大小对进程排序

iotop。它是一个类似于 top 的工具，前两行分别表示，进程的磁盘读写大小总数和磁盘真实的读写大小总数。因为缓存、缓冲区、I/O 合并等因素的影响，它们可能并不相等。

剩下的部分，则是从各个角度来分别表示进程的 I/O 情况，包括线程 ID、I/O 优先级、每秒读磁盘的大小、每秒写磁盘的大小、换入和等待 I/O 的时钟百分比等。

Linux文本编辑三剑客之awk

2026-04-09T06:42:38.000Z

Linux 文本编辑三剑客之 awk

Linux 文本处理三剑客是面试和后端工作中较为常见的。需要掌握：
grep：文本过滤、筛选
sed：文本编辑加工
awk：文本格式化输出
文章只列举常用的，不会完全把手册复述一遍

本节内容基于正则表达式：

正则表达式

借助正则表达式可以快速匹配、过滤需要的字符串，在 Linux 上处理大量文本比较高效。

一次处理一行
Linux 上只有文本处理工具三剑客（grep、sed、awk）常用，编程语言都有对应支持
扩展正则是基本正则的补充，一般结合三剑客使用建议直接使用扩展正则的写法，简洁

基本正则

符号	作用
`^`	模式匹配最左侧，`^abc`就是以abc开头
`$`	模式匹配最右侧，`abc$`就是以abc结尾
`^$`	组合符。空行
`.`	任意一个且只有一个字符，不匹配空行
`*`	匹配前一个字符0或多次，不单独使用
`.*`	组合符。匹配任意多个字符
`^.*`	组合符。匹配任意多个字符开头
`.*$`	组合符。匹配任意多个字符结尾
`\`	特殊字符还原本意，`\.`是小数点
`[abc]`	匹配集合内任意字符
`[^abc]`	匹配集合之外的字符
`<>`	定位单词的左侧和右侧。可以找出 `deltaqin nb`找不出`deltaqinnb`

扩展正则

符号	作用
`+`	匹配前面字符一次或多次
`[:@]+`	组合符。匹配[]内的字符一次或多次
`?`	匹配前面字符0次或1次
`	`
`()`	分组过滤，括号内是一个整体
`a{m,n}`	前面的字符最少m最多n次
`a{m,}`	前面的字符最少m次
`a{m}`	前面的字符m次
`a{,m}`	前面的字符最多m次

具体使用还是要结合三剑客一起

Why awk

按行对文本复杂格式化处理，简单使用 grep 或者 sed 就可以，自定义要求高就使用 awk。更像是一门编程语言，支持判断、数组、循环等等。

What awk

1 2	awk [option] '[pattern]{action}' file # awk 'BEGIN{action} pattern{action} END{action}' file

option：可选参数
- -F 指定分隔符，默认空格分割
- -v 定义或修改一个awk内部变量
pattern：可以是普通文本字符，也可以是正则表达式
- BEGAIN处理文本前要执行的操作
- END 处理文本之后执行的操作
- 使用内置变量 + 关系运算符，限制输出内容，例如NR>3、NR!=3、/正则/、!/正则/不匹配正则、/正则/、/正则/范围，条件&&条件
action：对文本执行的操作
- print 自带换行符，
- printf 是没有换行符的。printf需要指定每一个item的输出格式，格式都是%开头，和C语言基本一致，默认右对齐，-变为左对齐
内置变量：
- 行列：$0整行；NF分割完最后一列；(NF-1)分割完倒数第二列；NR当前行号；FNR各文件分别计数的行号
- 分隔符：FS字段输入分隔符，默认空格；OFS字段输出分隔符，默认空格；
- 换行符：RS输入换行符，替代回车；ORS输出换行符，替代回车
- 其余变量：FILENAME文件名；ARGC命令行参数个数；ARGV命令行参数构成的数组；

注意：

必须外层单引号，内层双引号。

How awk

使用简单内置变量打印内容

输出内容之间加上,否则没有空格

自定义输出的内容：

多个文件的行号分开打印：FNR

打印匹配模式的内容

awk '[pattern]{action}' file

打印第5行：

打印第5行第一列：

打印第5-7行第一列：

行号 NR

number of row

列数NF

number of field

指定输入/输出分隔符

FS 输入分隔符

OFS 输出分隔符

参数打印

自定义变量

全局变量

局部变量

shell变量

printf 格式化输出

模式使用

指定了条件模式，只有匹配模式的才会执行action

正则条件模式使用

范围匹配：

常见使用案例

查询系统禁止登录的用户

统计日志访客IP数量

sort -nsort 默认从小到大排序，-n逆序

wc -l 统计行数

访问频繁IP top3

打印所有非系统建立用户的用户名和家目录

删除文件空白行写到新文件

显示第三列是211的行

$3~指定针对第三列正则匹配