第 15 期 | Agent 驱动的 DevOps：CI/CD 与部署自动化

让 Hermes Agent 参与 DevOps 流程——自动化构建、测试运行、Docker 镜像管理、云服务部署。从"人工操作"到"Agent 编排"的范式转换。

🎯 学习目标

• 理解 Agent 驱动的 DevOps 范式，并认识其与传统自动化脚本的区别。
• 掌握如何利用 Hermes Agent 的 Skills、MCP 和 Cron 功能，自动化 CI（持续集成）流程中的构建、测试与 Docker 镜像管理。
• 学习如何通过 Hermes Agent 编排 CD（持续部署）任务，实现应用到远程服务器或云服务的自动化部署。
• 能够设计和实现一个端到端 Agent 驱动的 CI/CD 流程，从而提升开发效率和部署可靠性。

📖 核心概念讲解

15.1 Agent 驱动的 DevOps 范式：从脚本到智能编排

传统的 DevOps 流程严重依赖预设的脚本（Shell scripts, Python scripts）、配置管理工具（Ansible, Chef, Puppet）和 CI/CD 平台（Jenkins, GitLab CI, GitHub Actions）。这些工具极大地提升了自动化水平，但它们本质上是命令式的：你必须精确地告诉它们每一步该做什么。当环境发生变化、出现异常或需要处理复杂决策时，人工干预或修改脚本是常态。

Agent 驱动的 DevOps 引入了一种声明式和智能编排的范式。Agent（如 Hermes Agent）不仅仅是执行者，更是决策者和学习者。它能够：

1. 理解目标： 你告诉 Agent 最终的目标状态（例如：“部署最新的 Web 应用到生产环境”），而非具体的步骤。
2. 动态规划： Agent 根据其内置的知识、当前环境状态和可用的工具（通过 MCP 集成）动态地规划执行路径。
3. 自我修复与适应： 当遇到预期之外的问题时，Agent 可以尝试分析错误日志，利用其 Skills 库寻找解决方案，甚至学习新的 Skill 来解决问题，而无需人工修改脚本。
4. 跨会话记忆与学习： Hermes Agent 的 Memory (课程 04) 和 Skills (课程 03) 系统使其能够记住过去的操作经验、失败模式和成功策略，并在未来的任务中应用这些经验，持续优化其自动化能力。

Hermes Agent 通过其核心能力，为这种范式提供了坚实基础：

• Skills 系统： 允许 Agent 学习和执行复杂的、多步骤的任务，这些任务可以被抽象为可重用的“技能”。在 DevOps 场景中，这些技能可以是“构建 Docker 镜像”、“运行测试”、“SSH 远程执行命令”等。
• MCP (Multi-Tool Communication Protocol) (课程 06)： 提供与外部工具（如 Git、Docker CLI、云服务 API、SSH 客户端等）交互的能力。这是 Agent 连接真实世界的桥梁。
• Cron 调度 (课程 07)： 使得 Agent 能够按照预设的时间表触发 CI/CD 任务，例如每日构建、定期部署健康检查等。
• Context Files (课程 08)： 允许 Agent 访问和理解项目中的配置文件、Dockerfile、部署清单等，从而更好地感知工作区。

以下表格对比了传统脚本驱动与 Agent 驱动的 DevOps 范式：

Agent 驱动的 DevOps 并非要完全取代现有 CI/CD 工具，而是作为一层智能编排层，提升现有自动化的上限，让整个流程更加健壮、智能和自主。

15.2 Hermes Agent 在 CI 流程中的应用：构建、测试与镜像管理

持续集成（CI）是 DevOps 的核心环节，旨在频繁地将代码集成到主干，并通过自动化构建和测试来发现问题。Hermes Agent 可以在 CI 流程中扮演关键角色，自动化以下任务：

1. 代码拉取与依赖安装： 监控代码仓库（例如通过 MCP 接收 GitHub webhook 事件，或者通过 Cron 定时 git pull），当有新提交时，Agent 可以执行 git pull，然后运行项目所需的依赖安装命令（如 npm install, pip install, go mod download）。
2. 自动化测试： 在依赖安装完成后，Agent 可以触发各种测试套件（单元测试、集成测试、端到端测试）。如果测试失败，Agent 可以捕获错误日志，并通过消息网关 (课程 05) 通知开发者，甚至尝试分析失败原因。
3. Docker 镜像构建与管理： 对于容器化应用，Agent 可以根据项目中的 Dockerfile 构建 Docker 镜像。构建成功后，为镜像打上合适的标签（例如 latest 或基于 commit hash/版本号），并推送到容器注册表（如 Docker Hub, GitLab Container Registry, AWS ECR）。

为了实现这些功能，我们需要为 Hermes Agent 配置相应的 Skill，并可能集成一些外部工具。

示例 Skill 结构（伪代码）：

{
  "name": "build_and_test_docker_image",
  "description": "从 Git 仓库拉取代码，安装依赖，运行测试，并构建/推送 Docker 镜像。",
  "steps": [
    {
      "tool": "shell_command",
      "command": "git pull origin main"
    },
    {
      "tool": "shell_command",
      "command": "npm install"
    },
    {
      "tool": "shell_command",
      "command": "npm test"
    },
    {
      "tool": "shell_command",
      "command": "docker build -t my-app:latest ."
    },
    {
      "tool": "shell_command",
      "command": "docker tag my-app:latest myregistry/my-app:$(git rev-parse --short HEAD)"
    },
    {
      "tool": "shell_command",
      "command": "docker push myregistry/my-app:$(git rev-parse --short HEAD)"
    },
    {
      "tool": "shell_command",
      "command": "docker push myregistry/my-app:latest"
    }
  ],
  "requirements": ["git", "npm", "docker", "shell_command_tool"],
  "inputs": {
    "repo_url": "string",
    "registry_url": "string"
  }
}

在实际操作中，shell_command 这样的工具需要通过 MCP 进行集成。Hermes Agent 可以通过其内置的 shell 工具（如果已启用并配置安全权限）或自定义一个更安全的 execute_command MCP 工具来执行这些 Shell 命令。

Mermaid 流程图：Agent 驱动的 CI 流程

graph TD
    A[代码提交到 Git 仓库] --> B{Hermes Agent 接收通知/Cron 触发};
    B -- Cron 调度 --> C[Agent: pull_code Skill];
    B -- Webhook (MCP) --> C;
    C --> D[Agent: install_dependencies Skill];
    D --> E[Agent: run_tests Skill];
    E -- 测试失败 --> F[Agent: 通知开发者 (Telegram/Discord)];
    E -- 测试成功 --> G[Agent: build_docker_image Skill];
    G --> H[Agent: push_docker_image Skill到注册表];
    H --> I[CI 流程完成];
    F --> I;

通过这种方式，Hermes Agent 不仅能执行命令，还能根据执行结果（例如测试是否通过）做出决策，并触发后续的动作，极大地提升了 CI 流程的自动化和智能化水平。Agent 能够利用其对上下文的理解（通过 Context Files 获取 Dockerfile、测试报告等），以及其学习能力，优化构建和测试策略。例如，它可以记住哪些测试经常失败，并优先运行这些测试，或者在发现特定类型的错误时，自动尝试回滚到上一个稳定版本。

15.3 自动化部署与云服务集成：让 Agent 成为你的部署工程师

持续部署（CD）是 CI 的延伸，旨在将通过 CI 验证的代码自动部署到生产环境。这是一个高风险、高价值的环节，自动化程度越高，出错率越低，部署速度越快。Hermes Agent 可以在 CD 流程中发挥其智能编排的优势，实现从简单 SSH 部署到复杂云服务集成的自动化。

部署任务通常涉及以下几个步骤：

1. 环境准备： 确保目标服务器或云服务资源已准备就绪（例如，虚拟机启动、Kubernetes 集群可用）。
2. 凭证管理： 安全地访问部署所需的敏感信息，如 SSH 密钥、云服务 API 密钥等。Hermes Agent 可以通过其 Memory 系统（加密存储）或与外部秘密管理服务（如 HashiCorp Vault）集成来处理。
3. 应用分发： 将构建好的应用包（如 Docker 镜像、JAR 包、静态文件）传输到目标环境。
4. 服务更新与重启： 停止旧版本服务，启动新版本服务，并进行健康检查。
5. 回滚机制： 在部署失败或新版本出现问题时，能够自动或手动回滚到上一个稳定版本。

Hermes Agent 可以通过以下方式集成云服务和实现部署自动化：

• SSH 远程执行： 这是最常见的部署方式之一。Agent 可以通过 SSH 连接到远程服务器，并执行 Shell 命令来拉取镜像、更新配置、重启服务等。这需要 Agent 拥有一个能够执行 SSH 命令的 Skill，并安全地管理 SSH 密钥。
• 云服务 CLI/SDK 集成： 通过 MCP 集成云服务提供商的命令行工具（如 aws cli, gcloud cli, az cli）或 Python SDK。Agent 可以直接调用这些工具来管理云资源，例如启动/停止 EC2 实例、更新 ECS 服务、部署到 Kubernetes 集群等。
• API 调用： 对于一些没有 CLI 工具或需要更精细控制的场景，Agent 可以直接通过 HTTP 请求调用云服务的 RESTful API。这可以通过通用的 http_request MCP 工具或专门为特定 API 设计的 Skill 来实现。
• GitOps 模式： Agent 可以监控 Git 仓库中的部署配置文件（如 Kubernetes YAMLs），当这些文件发生变化时，Agent 自动应用这些变更到集群，实现声明式部署。

示例 Skill 结构（部署到远程 Docker 主机）：

{
  "name": "deploy_docker_app",
  "description": "通过 SSH 连接到远程服务器，拉取并部署最新的 Docker 镜像。",
  "steps": [
    {
      "tool": "ssh_command",
      "command": "docker login -u {{username}} -p {{password}} {{registry_url}}",
      "host": "{{remote_host}}",
      "port": 22,
      "user": "{{remote_user}}",
      "key_path": "/path/to/ssh/key"
    },
    {
      "tool": "ssh_command",
      "command": "docker pull {{registry_url}}/{{image_name}}:latest",
      "host": "{{remote_host}}",
      "port": 22,
      "user": "{{remote_user}}",
      "key_path": "/path/to/ssh/key"
    },
    {
      "tool": "ssh_command",
      "command": "docker stop {{container_name}} || true && docker rm {{container_name}} || true",
      "host": "{{remote_host}}",
      "port": 22,
      "user": "{{remote_user}}",
      "key_path": "/path/to/ssh/key"
    },
    {
      "tool": "ssh_command",
      "command": "docker run -d --name {{container_name}} -p 80:80 {{registry_url}}/{{image_name}}:latest",
      "host": "{{remote_host}}",
      "port": 22,
      "user": "{{remote_user}}",
      "key_path": "/path/to/ssh/key"
    },
    {
      "tool": "http_request",
      "method": "GET",
      "url": "http://{{remote_host}}/health",
      "expected_status": 200,
      "retries": 5,
      "delay": 10
    }
  ],
  "requirements": ["ssh_client", "docker_cli", "http_request_tool"],
  "inputs": {
    "remote_host": "string",
    "remote_user": "string",
    "registry_url": "string",
    "image_name": "string",
    "container_name": "string",
    "username": "string",
    "password": "string"
  }
}

这里的 ssh_command 和 http_request 需要作为 MCP 工具集成到 Hermes Agent 中。username 和 password 等敏感信息应从 Agent 的 Memory 或环境变量中安全获取，而不是直接硬编码在 Skill 定义中。

Agent 在执行部署 Skill 时，能够根据每一步的返回结果进行判断。例如，如果健康检查失败，Agent 可以尝试回滚到上一个版本，或者通知管理员进行干预。这种智能化的决策能力是传统脚本难以实现的。通过与 Agent 协作，我们可以构建出更健壮、更自适应的部署管道。

💻 实战演示

本次实战我们将演示如何让 Hermes Agent 自动化一个简单的 CI/CD 流程：从 Git 仓库拉取代码，构建 Docker 镜像，并将其部署到一个模拟的远程服务器。我们将使用一个简单的 Node.js 应用作为示例。

前提条件：

1. 已安装 Hermes Agent (课程 01)。
2. 已安装 Docker。
3. 一个简单的 Node.js 项目，包含 package.json 和 Dockerfile。
4. 一个模拟的远程服务器（可以是本地的另一个 Docker 容器或虚拟机，确保可以通过 SSH 访问）。为了简化，我们假设本地 Docker daemon 可以直接访问，但部署到远程需要 SSH 能力，这里模拟远程部署的命令。

Node.js 示例项目结构 (my-web-app/)：

my-web-app/app.js

const express = require('express');
const app = express();
const port = 80;

app.get('/', (req, res) => {
  res.send('Hello from Hermes Agent CI/CD! Version 1.0');
});

app.listen(port, () => {
  console.log(`App listening at http://localhost:${port}`);
});

my-web-app/package.json

{
  "name": "my-web-app",
  "version": "1.0.0",
  "description": "A simple web app for Hermes CI/CD demo",
  "main": "app.js",
  "scripts": {
    "start": "node app.js",
    "test": "echo 'No tests defined yet, but running anyway.'"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

my-web-app/Dockerfile

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 80
CMD ["npm", "start"]

请确保您在本地创建了 my-web-app 文件夹并放入上述文件。

场景 1: Agent 自动执行 CI 任务并构建 Docker 镜像

我们将创建一个 Hermes Skill，用于拉取代码（这里我们模拟为本地目录的初始化），安装依赖，运行测试，并构建 Docker 镜像。

步骤 1: 准备工作区和模拟的 Git 仓库

在你的终端中，确保你位于 my-web-app 目录的父目录。

# 假设你已经创建了my-web-app目录
cd my-web-app
git init
git add .
git commit -m "Initial commit"
cd .. # 返回到父目录

步骤 2: 创建一个 Hermes Skill 文件 (ci_skill.json)

我们将定义一个名为 ci_build_docker 的 Skill。为了简化，我们假设项目目录就在 Hermes Agent 运行的当前目录下。Hermes Agent 默认提供了 shell 工具，我们可以直接使用。

// ~/.hermes/skills/ci_build_docker.json
{
  "name": "ci_build_docker",
  "description": "自动化拉取代码、安装依赖、运行测试并构建 Docker 镜像。",
  "steps": [
    {
      "tool": "shell",
      "command": "echo '--- Starting CI Process ---'"
    },
    {
      "tool": "shell",
      "command": "cd my-web-app && git pull origin main || true && echo 'Code pulled or already up-to-date.'",
      "description": "拉取最新代码（如果项目是 Git 仓库）"
    },
    {
      "tool": "shell",
      "command": "cd my-web-app && npm install",
      "description": "安装 Node.js 依赖"
    },
    {
      "tool": "shell",
      "command": "cd my-web-app && npm test",
      "description": "运行测试"
    },
    {
      "tool": "shell",
      "command": "cd my-web-app && docker build -t my-web-app:latest .",
      "description": "构建 Docker 镜像"
    },
    {
      "tool": "shell",
      "command": "docker tag my-web-app:latest myregistry/my-web-app:$(git -C my-web-app rev-parse --short HEAD)",
      "description": "为镜像打上 commit hash 标签"
    },
    {
      "tool": "shell",
      "command": "docker push myregistry/my-web-app:$(git -C my-web-app rev-parse --short HEAD) || echo 'Push to registry failed or registry not configured. Skipping for demo.'",
      "description": "推送镜像到注册表（这里模拟，实际需配置 Docker Hub 等）"
    },
    {
      "tool": "shell",
      "command": "docker push myregistry/my-web-app:latest || echo 'Push to registry failed or registry not configured. Skipping for demo.'",
      "description": "推送 latest 标签镜像"
    },
    {
      "tool": "shell",
      "command": "echo '--- CI Process Finished ---'"
    }
  ],
  "requirements": ["git", "npm", "docker", "shell"],
  "inputs": {}
}

将上述内容保存为 ~/.hermes/skills/ci_build_docker.json。

步骤 3: 让 Hermes Agent 执行 CI Skill

hermes run "执行 ci_build_docker skill 来构建我的 web 应用的 Docker 镜像。"

预期输出 (部分，实际输出会更详细，包含 npm install 和 docker build 的日志):

Running with model: openrouter/nousresearch/hermes-2-theta-llama-3.1-8b
User: 执行 ci_build_docker skill 来构建我的 web 应用的 Docker 镜像。

Thought:
用户希望执行一个CI流程来构建Docker镜像。我应该使用名为 `ci_build_docker` 的技能来完成这个任务。该技能将处理代码拉取、依赖安装、测试运行和Docker镜像构建。

Action:
{
  "tool": "execute_skill",
  "skill_name": "ci_build_docker",
  "inputs": {}
}
Tool Output:
--- Starting CI Process ---
Code pulled or already up-to-date.
added 1 package, and audited 2 packages in 494ms
found 0 vulnerabilities
No tests defined yet, but running anyway.
[+] Building 0.1s (11/11) FINISHED
... (docker build output) ...
Successfully built 0a1b2c3d4e5f
Successfully tagged my-web-app:latest
The push refers to repository [docker.io/myregistry/my-web-app]
... (docker push output - may show error if registry not configured) ...
The push refers to repository [docker.io/myregistry/my-web-app]
... (docker push output - may show error if registry not configured) ...
--- CI Process Finished ---

Thought:
我已经成功执行了 `ci_build_docker` 技能，完成了CI流程，包括代码拉取、依赖安装、测试运行和Docker镜像的构建。虽然推送镜像到注册表可能因为本地没有配置而失败，但核心的构建和测试步骤已经完成。

Action:
{
  "tool": "send_message",
  "message": "CI 流程已成功执行，Docker 镜像 `my-web-app:latest` 和 `myregistry/my-web-app:<commit_hash>` 已构建完成。请检查 Docker 镜像列表以确认。"
}

此时，你可以通过 docker images 命令检查是否成功构建了 my-web-app:latest 镜像。

场景 2: Agent 自动化部署 Docker 容器到远程服务器

我们将创建一个新的 Skill，用于部署刚刚构建的 Docker 镜像到模拟的远程服务器。为了简化演示，我们假设“远程服务器”实际上是 Agent 运行的同一台机器，但我们使用 docker run 命令模拟部署行为。在真实场景中，ssh 工具是实现远程部署的关键。

步骤 1: 创建一个 Hermes Skill 文件 (cd_deploy_skill.json)

这里我们模拟部署到本地，但命令结构与远程 SSH 部署类似。

// ~/.hermes/skills/cd_deploy_app.json
{
  "name": "cd_deploy_app",
  "description": "自动化部署 Docker 镜像到目标环境。",
  "steps": [
    {
      "tool": "shell",
      "command": "echo '--- Starting CD Process ---'",
      "description": "开始部署流程"
    },
    {
      "tool": "shell",
      "command": "docker stop my-web-app-instance || true && docker rm my-web-app-instance || true",
      "description": "停止并移除旧的容器实例"
    },
    {
      "tool": "shell",
      "command": "docker run -d --name my-web-app-instance -p 8080:80 my-web-app:latest",
      "description": "运行最新的 Docker 镜像作为容器"
    },
    {
      "tool": "shell",
      "command": "sleep 5",
      "description": "等待容器启动"
    },
    {
      "tool": "shell",
      "command": "curl -s http://localhost:8080",
      "description": "执行健康检查"
    },
    {
      "tool": "shell",
      "command": "echo '--- CD Process Finished ---'",
      "description": "部署流程完成"
    }
  ],
  "requirements": ["docker", "curl", "shell"],
  "inputs": {}
}

将上述内容保存为 ~/.hermes/skills/cd_deploy_app.json。

步骤 2: 让 Hermes Agent 执行 CD Skill

hermes run "部署最新的 my-web-app 到我的本地测试环境。"

预期输出 (部分):

Running with model: openrouter/nousresearch/hermes-2-theta-llama-3.1-8b
User: 部署最新的 my-web-app 到我的本地测试环境。

Thought:
用户希望部署最新的 web 应用到本地测试环境。我应该使用 `cd_deploy_app` 技能来完成这个任务。这个技能将停止旧容器，运行新容器，并进行健康检查。

Action:
{
  "tool": "execute_skill",
  "skill_name": "cd_deploy_app",
  "inputs": {}
}
Tool Output:
--- Starting CD Process ---
my-web-app-instance
my-web-app-instance
f1e2d3c4b5a6... (Docker container ID)
Hello from Hermes Agent CI/CD! Version 1.0
--- CD Process Finished ---

Thought:
我已经成功执行了 `cd_deploy_app` 技能，部署了最新的 `my-web-app` 容器，并且健康检查也成功返回了预期的内容。

Action:
{
  "tool": "send_message",
  "message": "应用 `my-web-app` 已成功部署到本地测试环境，并通过健康检查。你可以在 `http://localhost:8080` 访问它。"
}

此时，你可以在浏览器中访问 http://localhost:8080，应该能看到 Hello from Hermes Agent CI/CD! Version 1.0。

通过这两个场景，我们展示了 Hermes Agent 如何通过 Skills 系统，利用内置的 shell 工具，编排复杂的 CI/CD 任务。在更高级的场景中，你可以集成自定义的 MCP 工具来处理 SSH 连接、云服务 API 调用等，从而实现更强大的 Agent 驱动的 DevOps 自动化。

🔧 涉及的命令与工具

📝 本期要点回顾

• Agent 驱动的 DevOps 范式： 强调从命令式脚本到声明式智能编排的转变，Hermes Agent 能够理解目标、动态规划、自我修复和持续学习，从而实现更高级别的自动化。
• CI 流程自动化： Hermes Agent 可以通过 Skills 编排 git pull、依赖安装 (npm install)、自动化测试 (npm test) 和 Docker 镜像构建 (docker build, docker push) 等 CI 任务。
• CD 流程自动化： Agent 能够管理部署凭证、分发应用、更新服务并执行健康检查。通过集成 SSH、云服务 CLI 或 API，Agent 可以实现自动化部署到远程服务器或云平台。
• 核心功能整合： 本期课程深入结合了 Hermes Agent 的 Skills (课程 03)、MCP (课程 06) 和 Cron 调度 (课程 07) 等核心功能，展示了它们在构建智能 DevOps 管道中的关键作用。
• 实战操作： 通过创建和运行 ci_build_docker 和 cd_deploy_app 两个 Hermes Skill，演示了 Agent 如何自动化项目的构建、测试和部署流程。

🔗 参考资料

1. Hermes Agent 官方文档： 深入了解 Hermes Agent 的架构、特性和配置细节。 https://hermes-agent.nousresearch.com/docs/
2. Hermes Agent GitHub 仓库： 查阅最新代码、提交 Issue 或贡献代码。 https://github.com/NousResearch/hermes-agent
3. Docker 官方文档： 学习 Docker 的基本概念、命令和最佳实践。 https://docs.docker.com/