Mistral-入门指南-四-

Mistral 入门指南（四）

原文：Learn Mistral

译者：飞龙

协议：CC BY-NC-SA 4.0

• 安装 Mistral Code 扩展。打开 VS Code 中的扩展面板板。搜索Mistral Code Enterprise或直接访问marketplace.visualstudio.com/items?itemName=mistralai.mistral-code。点击安装，并允许浏览器在 VS Code 中打开它：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_07_21.png

图 7.21：Mistral Code Enterprise

• 登录你的 Mistral 账户。点击 VS Code 左侧栏中的M图标。会出现一个欢迎界面，提示你登录。按照身份验证流程激活你的助手：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_07_22.png

图 7.22：Mistral Code Enterprise 首页

• JetBrains 替代方案：如果你在使用IntelliJ、PyCharm或其他 JetBrains IDE，可以从 JetBrains Marketplace 安装相同的插件：plugins.jetbrains.com/plugin/27493-mistral-code-enterprise。

• 关于功能和用例的更多详情，请参阅官方发布公告：mistral.ai/news/mistral-code。

• 一旦安装并登录，你就可以使用自然语言提示通过 Mistral Code 补全代码、解释片段或直接在编辑器中构建。祝编程和实验愉快！

加入我们的 Discord 和 Reddit 空间

你并不是唯一一个在碎片化的工具、持续的更新和不明确的最佳实践中摸索的人。加入不断增长的专业社区，交流未记录在文档中的见解。

| 通过我们作者的更新、讨论和幕后见解保持信息畅。加入我们的 Discord：packt.link/z8ivB 或扫描下方的二维码：https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/Discord_Code.jpg | 与同行联系，分享想法并讨论真实的生成式 AI 挑战。在 Reddit 上关注我们：packt.link/0rExL 或扫描下方的二维码：https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/Reddit.jpg |

|---|---|

resource "aws_security_group" "example" {

  name        = "example-security-group"
  description = "Security group for example application"
  vpc_id      = aws_vpc.main.id

  # Allow SSH access
  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  # Allow HTTP access
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  # Allow HTTPS access
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  # Egress rule
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
     Name = "example-security-group"
  }
}

好的，正如我们看到的，HTTP和HTTPS协议均对整个互联网开放，并且还有一个不受限制的出站规则。

手动审查此类配置以发现潜在风险是枯燥且容易出错的，特别是在复杂的环境中。相反，你可以利用Mistral LLM来自动化这一过程。针对此任务定制的优化提示词（prompt）如下：

分析以下 Terraform 脚本并识别任何违反最小权限原则或过度宽松的配置。为改进提供具体的建议。

当由Mistral处理时，模型会识别出潜在的配置错误并提供可操作的建议：

潜在的配置错误：

- SSH 入站规则（端口 22）允许无限制访问。建议限制为受信任的 IP。
- HTTP 入站规则（端口 80）对整个互联网开放。建议根据应用需求限制访问。
- 开放的出站规则允许所有传出流量。建议将范围缩小到特定的目标和协议。

建议操作：更新入站规则以使用限制的 CIDR 范围，并优化出站规则以符合应用需求。

通过自动化这种分析，Mistral简化了合规审计，降低了疏忽的风险。它为安全配置提供了清晰的指导，让你的团队专注于实施必要的更改。这种方法确保你的防火墙规则既有效又符合安全最佳实践。

在本章的后半部分工作坊中，我们将深入分析 Terraform 脚本，以确保它们遵循最小权限原则。使用Codestral，我们将识别出过度宽松的配置（例如不受限制的入站或出站规则），并学习如何有效地保护它们，以符合云安全最佳实践。

防火墙日志分析

防火墙日志就像数据宝——只要你知道寻找什么。它们记录了你的网络与外部世界之间的每一次交互，但理解所有这些噪音可能会让人感到无从从。这就是Mistral LLM介入的地方，它可以帮助你快速识别模式并关注真正重要的事情。

在本节中，我们将深入探讨让防火墙日志为你提供服务的实用方法，学习如何识别可能信号 DDoS 攻击或未经授权访问尝试的异常流量，使用地理位置分析标记来自可疑区域或已知坏分子的流量，检查你的防火墙规则是否按规程办事，并保持你的设置安全。

我们还将向你展示如何将告警分类，以便你先处理大问题，并使用 AI 发现你可能根本不知道去寻找的新威胁。到结束时，你将知道如何将原始日志数据转换为有用的洞察并采取行动。

异常流量检测

每个网络都通过其流量讲述故事，但在稳定的数据流中，隐藏着可能预示着迫临威胁的异常模式。检测这些异常（例如 DDoS 攻击期间流量的突然激增或来自可疑 IP 的重复访问尝试）可能是保持安全与沦为攻击受区别。在 Mistral LLM 和 Codestral 的帮助下，这一过程可以变得更加高效，在片时间内将日志转化为可操作的洞察。

识别 DDoS 流量

DDoS 攻击通常会导致来自多个 IP 针对同一终点的请求洪水。这些攻击可能会阻塞你的网络，因此快速识别来源至关重要。例如，考虑以下示例日志条目：

2023-12-28T10:15:12Z SRC_IP=192.168.1.5 DEST_IP=10.0.0.8 DEST_PORT=443 PROTOCOL=TCP BYTES_SENT=0 BYTES_RECEIVED=124
2023-12-28T10:15:12Z SRC_IP=192.168.1.6 DEST_IP=10.0.0.8 DEST_PORT=443 PROTOCOL=TCP BYTES_SENT=0 BYTES_RECEIVED=124
2023-12-28T10:15:13Z SRC_IP=192.168.1.7 DEST_IP=10.0.0.8 DEST_PORT=443 PROTOCOL=TCP BYTES_SENT=0 BYTES_RECEIVED=124

手动分析这些日志以检测模式可能是枯燥且容易出错的。这是 Mistral LLM 擅长的地方。让我们带有如下提示词将日志输入 Mistral：

分析日志并识别潜在的 DDoS。

Mistral 处理数据并提供：

检测到潜在 DDoS：
- SRC_IP=192.168.1.5, 请求数：100
- SRC_IP=192.168.1.6, 请求数：98
- SRC_IP=192.168.1.7, 请求数：95

建议操作：临时屏蔽这些 IP。

识别端口扫描尝试

端口扫描是另一种常见的威胁，攻击者探测多个端口以寻找漏洞。检测这些扫描需要跟踪连接。例如，这里有一个示例日志：

2023-12-28T11:00:15Z SRC_IP=203.0.113.5 DEST_IP=10.0.0.8 DEST_PORT=22 PROTOCOL=TCP
2023-12-28T11:00:16Z SRC_IP=203.0.113.5 DEST_IP=10.0.0.8 DEST_PORT=80 PROTOCOL=TCP
2023-12-28T11:00:17Z SRC_IP=203.0.113.5 DEST_IP=10.0.0.8 DEST_PORT=443 PROTOCOL=TCP

手动分析用于指示端口扫描模式的日志可能是耗时且容易出错的，特别是在处理大型数据集时。通过利用语言模型（如 Mistral 8B），你可以自动化这一过程。模型可以通过处理日志条目并提供如下良好的提示词来快速识别可疑活动：

分析以下数据包并检测潜在的端口扫描活动。如果检测到，提供源 IP，列出目标端口并建议适当的操作。

模型处理数据并提供简洁且可操作的响应：

检测到端口扫描：
源 `IP: 203.0.113.5`
目标端口：22, 80, 443
建议操作：加入动态屏蔽列表。

处理未经授权的访问尝试

破解攻击是一个持续存在的问题，通常涉及针对特定系统或账户的重复失败登录尝试。从日志中手动识别这些尝试可能是耗力且容易出错的，特别是在高流量环境中。使用 Mistral LLM 进行自动化分析提供了一种更快、更可靠的方法，帮助检测模式并建议对措施。

例如，考虑以下日志条目：

2023-12-28T12:30:10Z SRC_IP=198.51.100.7 DEST_PORT=22 STATUS=FAILED
2023-12-28T12:30:11Z SRC_IP=198.51.100.7 DEST_PORT=22 STATUS=FAILED
2023-12-28T12:30:12Z SRC_IP=198.51.100.7 DEST_PORT=22 STATUS=FAILED

与其手动分析这些日志以查找重复尝试，不如利用如 Mistral 这样的语言模型。通过提供日志和精心设计的提示（prompt），模型可以高效处理数据并提供可操作的见解。一个合适的提示如下：

Analyze the logs for repeated failed login attempts. Identify the source IP, the number of attempts, and recommend appropriate mitigations.

模型处理日志并提供了清晰简洁的输出：

Repeated failed login attempts detected from SRC_IP: 198.51.100.7

Attempts: 50 within 5 minutes

Suggested action: Enforce IP blocking and review SSH access policies.

此输出不仅识别了违规源 IP，还建议了具体的缓解措施，例如强制 IP 阻塞和审查访问策略。通过自动化检测和响应过程，Mistral 简化了威胁管理，让安全团队能够迅速行动并降低未经访问的风险。

我们已经在日志中标记了可疑行为——DDoS 突发、端口扫描和暴力破解尝试。下一步是添加地理上下文，以便我们能够常规流量与风险更高的流量隔离开。基于地理位置的分析利用区域和威胁情报信号来丰富每个事件，使分拣处理更快。让我们来看下一个部分。

基于地理位置的分析

了解流量的源地是识别网络潜在威胁的关键组成。地理位置分析允许您检测到源自高风险区域或已知恶意 IP 的流量，这些流量通常是恶意活动的早期指标。

然而，手动分析日志以寻找此类模式不仅耗时耗力，而且容易人为错误。利用 Mistral LLM 可以自动化这一过程，实现对地理位置元数据快速、准确的分析。

例如，考虑以下包含地理位置信息的日志条目：

2023-12-28T14:05:22Z SRC_IP=45.67.89.101 DEST_IP=10.0.0.8 GEOLOCATION=Unknown REGION="Eastern Europe"
2023-12-28T14:05:23Z SRC_IP=203.0.113.88 DEST_IP=10.0.0.8 GEOLOCATION=Known Malicious REGION="Asia"

为了增强地理位置分析，您可以将 MaxMind 的 GeoLite2 等 IP 地理数据库集成到 Wireshark 等工具中。这允许将 IP 地址实时映射到其地理位置，为流量模式提供宝贵的上下文，并有助于识别高风险区域或恶意 IP。

手动识别和分类来自可疑区域的流量是一项艰巨的任务，特别是当日志量巨大时。为了简化这一过程，可以使用提示将这些日志提供给 Mistral LLM，引导模型突出显示任何高风险流量源。一个重构且重点突出的提示可能如下：

Review the logs and identify traffic from suspicious regions or known malicious IPs. Provide the source IP, the region or geolocation, and recommend appropriate actions.

处理后，Mistral 会生成如下见解：

Suspicious traffic detected:

- SRC_IP: 45.67.89.101 (Region: Eastern Europe, Geo: Unknown)
- SRC_IP: 203.0.113.88 (Region: Asia, Geo: Known Malicious)

Suggested action: Monitor or block these IPs.

此输出不仅指明了源 IP 及其关联区域，还建议了可操作的步骤，例如阻塞或监控识别出的流量。通过自动化地理位置分析，Mistral 不仅节省了宝的时间，还提高了准确性，使安全团队能够专注于主动措施。这种方法确保了针对演变威胁提供更稳健、更高效的防御。

现在我们已经可以检测异常并了解它们的来源，挑战变成了告警量。

告警优先级

管理网络安全面临的最大挑战之一是从现代系统产生的海量告警中筛选。并非所有告警的重要性都相同；某些可能指示需要立即采取的关键威胁，而另一些仅仅是常规通知。如果没有适当的优先级，安全团队面临在低优先级问题上浪费时间的风险，可能导致严重威胁得不到处理。自动化这些告警的分类有助于简化响应工作，让团队专注于最重要的事情。

考虑以下代表不同类型网络事件的日志条目：

2023-12-28T15:10:12Z SRC_IP=198.51.100.1 EVENT="Unauthorized access attempt"
2023-12-28T15:10:15Z SRC_IP=192.0.2.5 EVENT="Login failure"
2023-12-28T15:10:17Z SRC_IP=192.0.2.5 EVENT="Login failure"
2023-12-28T15:10:18Z SRC_IP=192.0.2.5 EVENT="Login failure"
2023-12-28T15:10:20Z SRC_IP=192.0.2.5 EVENT="Login failure"
2023-12-28T15:10:25Z SRC_IP=203.0.113.50="Routine connection"

手动分析这些日志以确定其紧急性是低效且易错的，特别是在高流量环境中。为了实现自动化，Mistral LLM 可以分析日志并分配严重级别。Mistral 处理这些日志并交付可操作的见解：

Critical: 198.51.100.1
Warning: 192.0.2.5
Informational: 203.0.113.50

通过自动化这种分析，Mistral 使安全团队能够识别并响应关键事件（如未经访问），同时监控低优先级警告。这种优先级排序不仅缩短了响应时间，还确保了安全资源的有效分配。

即使有更严格的规则和更敏锐的上下文，某些威胁仍会溜进来。那么，接下来是什么？我们转向发现异常。在下一节中，我们将探讨异常检测如何帮助捕捉零日威胁。

零日威胁检测

零日威胁是最挑战性的安全风险之一，它们利用未知漏洞暴露系统。Mistral LLM 擅长识别这些模式，提供能够快速响应和缓解的见解。让我们探讨两个可能指示零日威胁的异常流量示例。

示例 1：快速波动的流量量

流量异常波动是零日威胁的一个潜在指标。此类模式可能意味着数据外泄、流量整形或其他未经授权的操作。考虑以下日志条目：

2023-12-28T14:00:01Z SRC_IP=192.168.1.20 DEST_IP=10.0.0.8 BYTES_SENT=500KB PROTOCOL=TCP
2023-12-28T14:00:05Z SRC_IP=192.168.1.20 DEST_IP=10.0.0.8 BYTES_SENT=5MB PROTOCOL=TCP
2023-12-28T14:00:06Z SRC_IP=192.168.1.20 DEST_IP=10.0.0.8 BYTES_SENT=20KB PROTOCOL=TCP
2023-12-28T14:00:07Z SRC_IP=192.168.1.20 DEST_IP=10.0.0.8 BYTES_SENT=100MB PROTOCOL=TCP
2023-12-28T14:00:08Z SRC_IP=192.168.1.20 DEST_IP=10.0.0.8 BYTES_SENT=1KB PROTOCOL=TCP

手动识别这些不规则之处非常耗时且容易出错，特别是在监控大型数据集时。通过利用 Mistral LLM，你可以使用如下目标提示词（prompt）来自动化此过程：

分析以下日志，寻找可能指示新兴威胁的异常流量模式。突出异常情况并建议适当的措施以降低潜在风险。

处理后，Mistral 会提供以下可操作的洞察：

检测到新兴威胁：

- 流量大小从 SRC_IP: 192.168.1.20 出现异常波动。
- 数据外泄或流量整形尝试的潜在指标。

建议操作：密切监控系统，并检查日志以寻找未经授权数据传输的迹象。

这些洞察突出了不规则行为，允许安全团队采取采取行动，例如隔离源或加强数据监控。

示例 2：不规则的会话建立与终止

另一个可疑模式涉及异常的会话行为，即源 IP 在短时间内频繁建立和终止会话。这可能表明连接探测或试图利用会话漏洞。查看以下日志条目：

2023-12-28T14:05:10Z SRC_IP=203.0.113.25 DEST_IP=10.0.0.8 EVENT="Session start" PROTOCOL=TCP
2023-12-28T14:05:11Z SRC_IP=203.0.113.25 DEST_IP=10.0.0.8 EVENT="Session end" PROTOCOL=TCP
2023-12-28T14:05:12Z SRC_IP=203.0.113.25 DEST_IP=10.0.0.8 EVENT="Session start" PROTOCOL=TCP
2023-12-28T14:05:13Z SRC_IP=203.0.113.25 DEST_IP=10.0.0.8 EVENT="Session end" PROTOCOL=TCP
2023-12-28T14:05:14Z SRC_IP=203.0.113.25 DEST_IP=10.0.0.8 EVENT="Session start" PROTOCOL=TCP

这种频繁的会话变化在人工审核期间很容易被忽略，但 Mistral 的异常检测能力使其识别和确定优先级变得非常简单。让我们考虑与上一个示例相同的情况：

分析以下日志，寻找可能指示新兴威胁的异常流量模式。突出异常情况并建议适当的措施以降低潜在风险。

Mistral 的响应引起了异常异常，并提供了处理潜在威胁的清晰后续步骤，例如跟踪会话或进一步隔离源以进行深层分析：

检测到新兴威胁：

- 来自 SRC_IP: 203.0.113.25 的不规则会话建立与终止。
- 行为与潜在的连接探测或会话劫持尝试相符。

建议操作：调查源 IP 并实施会话跟踪机制以进一步监控。

通过自动检测异常流量模式，Mistral LLM 允许安全团队快速识别并响应零日威胁。无论是波动的流量大小还是反复无常的会话行为，这些洞察都能实现主动的威胁缓解，降低被利用的风险。通过 Mistral 和 Codestral 等工具，你在保护关键系统免受未知漏洞方面获得了显著优势。

从基于地理位置的过滤到零日异常检测，Mistral LLM 彻底了我们处理防火墙日志和安全工作流的方式。它自动化地理位置分析、审核防火墙规则、优先处理告警以及检测新兴威胁的能力简化了复杂任务并增强了决策。AI 无缝集成到安全操作中，确保组织领先于攻击者，对潜在风险做出更快、更智能的响应。通过将实用工具与 AI 驱动的洞察相结合，这些方法将原始数据转化为可操作的情报，实现了更稳健、更高效的防御策略。

分析以下日志，检查非标准端口上是否存在异常的协议使用。请提供源 IP、使用的协议、端口号并提供解决该问题的建议操作。

在处理时，Mistral 会提供清晰且可操作的响应：

检测到协议误用：

- SRC_IP: 192.0.2.5
- Protocol: 端口 8080 上的 SMTP
- Suggested action: 调查源 IP 并强制执行协议-端口映射规则，以防止未经授权的使用

此响应强调了误用行为，并提供了建议的行动方案。调查源 IP 可以揭示该行为是由于配置错误还是更严重的威胁。执行严格的协议-端口映射有助于防止未经授权的活动，并确保网络在预期边界内运行。

通过自动化检测协议误用，Mistral 使安全团队能够快速识别并处理异常。这不仅增强了网络管理的效率，还降低了潜在漏洞的风险，使您的基础设施保持安全可靠。

状态检测防火墙日志是网络行为洞察的金矿，允许您发现从不完全握手到协议误用的各种威胁。通过 Mistral LLM，分析这些日志变得简单且具有可操作性。通过识别问题、建议响应以及自动更新动态块列表等任务，Mistral 将复杂数据转化为简单的解决方案，确保您的网络保持安全和韧性。

关于实时日志处理

由于网络日志量巨大且复杂，实时日志处理并非总是可行的，这通常需要大量的计算资源。然而，随着如 Mistral 8B 和 Mistral Nemo 等本地部署选项可用，即使在有限的基础设施上也可以实现近实时的分析。在本地运行 Mistral 可以实现高效、低延迟的处理，使组织能够在不依赖昂贵的云解决方案或外部依赖的情况下监控并响应威胁。这种方法平衡了性能与资源可用性，对于希望在不超出运营预算的情况下增强安全态势的企业来说，是一个实用的选择。

其他安全应用

让我们现在探索 Mistral LLM 如何增强多个领域的网络安全。从检测终端威胁和异常用户行为，到监控文件完整性和云配置错误，Mistral 都能支持实时分析和自动化。让我们来看看它在加强身份验证、授权以及识别潜在数据泄露风险方面的作用：

• 终端安全、恶意软件行为预测：预测恶意软件行为就像在野外中识别隐藏的捕食者：在攻击之前看起来无害。通过通过 Mistral 分析代码片段，您可以及早发现恶意模式，甚至识别零日威胁。一个真实案例是 Stuxnet，这是一种高度复杂的恶意软件，它通过隐藏在伪装代码中攻击工业系统（参考材料：www.codeproject.com/articles/246545/stuxnet-malware-analysis-paper）。

• 文件完整性监控：关键系统文件一旦被篡改就会损害整个系统。在 2017 年的 NotPetya 攻击中，未经授权的文件更改导致了广泛破坏。Mistral 可以实时监控文件完整性，提醒您任何未经授权的修改（参考材料：css.csail.mit.edu/6.566/2018/readings/stuxnet.pdf）。

• 数据泄露检测（异常数据传输）：大规模或重复的数据导出通常标志着泄露尝试。2014 年，索尼图片泄露事件涉及数周内盗取的数 GB 敏感数据。使用 Mistral，您可以通过分析网络日志并标记向未知目的地的传输来识别此类异常（参考材料：www.itgovernance.co.uk/blog/global-data-breaches-and-cyber-attacks-in-december-2023-22419675-breached）。

• 身份验证与授权（凭据滥用）：凭据填充和暴力破解攻击持续构成重大威胁。2024 年，35%的组织报告了由于暴力破解导致的身份泄露，包括凭据填充和密码喷洒（参考材料：https://www.beyondtrust.com/blog/the-state-of-identity-security-threats-breaches-security-practices）。此外，2023 年，凭据填充占泄露事件的约 10%（参考材料：jumpcloud.com/blog/password-statistics）。Mistral 可以实时分析登录尝试，检测并拦截滥用模式。

• 应用代码漏洞：OWASP 前 10 名列出了如 XSS 和 CSRF 等关键 Web 漏洞。Mistral 通过扫描不安全模式识别您的应用程序代码中的这些缺陷，提供修复建议以加强您的代码（参考材料：github.com/x86byte/Stuxnet-Rootkit）。

• 用户行为分析 (UBA)（命令与控制）：C2 服务器经常用于高级攻击，例如 2020 年的 SolarWinds 泄露事件。Mistral 可以从日志中识别已知的 C2 通信模式，从而早期检测并破坏这些通道（参考材料：css.csail.mit.edu/6.566/2018/readings/stuxnet.pdf）。

• 云配置错误：云配置错误导致了 73%的云安全问题，如 2018 年的 Tesla 泄露事件所示。Mistral 可以分析 Terraform 和 CloudFormation 等配置文件来检测开放端口、过度权限和不安全的设置（参考文章：www.cloudcomputing-news.net/news/misconfiguration-was-the-cause-of-security-incidents-in-2021/）。

• 存储安全：公开暴露的存储桶导致了多次泄露，例如 2017 年的 Verizon 数据泄露。Mistral 可以分析桶策略，确保敏感数据得到适当保护（参考材料：www.osibeyond.com/blog/cloud-services-problem/）。

我们已经浏览了现代网络安全的一些关键领域，从发现恶意软件到标记异常数据传输并锁定配置错误。这并不是深科学，但比起“只需点击此处”要复杂得多。坦率地说，Mistral 通过捕捉异常并提供可操作的见解，让繁重的工作变得更容易。

准备好大起袖子了吗？在接下来的实验中，我们将实操 SQL 注入分析并处理配置脚本。你将看到 Mistral 如何比你老板说“什么是 SQL 注入”更快发现漏洞。重点是将原始日志和脚本转化为支持更安全的清晰见解。

在本节结束时，你将看到 AI 辅助分析如何简化安全任务，并准备好将相同技术应用于其他高风险场景。

实战实验：使用 Mistral 进行代码和云安全防护

在本次实验中，我们将发现显而易见的漏洞，例如过度权限的云配置、SQL 注入以及 XSS 风险。通过 Visual Studio Code、Continue 扩展以及 Mistral 的强大分析，我们不仅能检测这些威胁，还能学习像专业人士一样修复它们。到结束时，你将掌握战胜潜在攻击者的技能！

第 1 步：环境设置

在准备的第一步中，我们将涵盖必要的设置任务，以确保实验顺利开始。我们将从安装 Visual Studio Code 开始，这是一个适合项目的强大编辑器。接下来，我们将访问 GitHub 仓库中的参考材料，其中包含所有必要的文件和脚本。我们将安装 Continue 开发扩展，通过 AI 驱动的辅助增强编码体验。随后，我们将通过免费试用或兼容的部署设置 Codestral，启用高级安全分析功能，如代码审查和漏洞检测。最后，我们将准备一个新的项目空间来有效组织和管理我们的工作。这些基础步骤将为动手探索安全应用奠定基础：

1. 为实验设置环境，你需要一个如 Visual Studio Code 的编辑器。它是一个轻量且强大的工具。虽然安装步骤可能因操作系统略有不同，但过程非常简单：下载、安装并启动编辑器。详细步骤请参阅第 7 章工作坊 2（Chapter 7, Workshop 2）。按照这些指令操作，你就准备绪了！

   如果已安装 VS Code，请跳过

   如果你已经安装了 Visual Studio Code，可以跳过安装步骤，直接配置扩展。

2. 为了进行实验设置，你需要访问 GitHub 仓库。访问主项目 github.com/PacktPublishing/Learn-Mistral 并导航到第 8 章（Chapter-8）。这些文件包含了所需的脚本和数据。

3. 为了增强编码体验，你需要设置 Continue 扩展以获得 AI 辅助。它通过自动补全和上下文建议等功能简化编码。详细步骤请参阅第 7 章工作坊 2 第 1.3 节（Chapter 7, Workshop 2, Step 1.3）。按照这些操作，扩展就准备好了！

4. 为 Visual Studio Code 中的 Continue 扩展设置 Codestral 模型，你有多种选择。可以使用免费试用（这对本实验足够），或者选择配置了 API 密钥的付费版本。或者，如果你倾向于本地处理，可以在电脑上与 Ollama 集成。详细步骤请参阅第 7 章工作坊 2（Chapter 7, Workshop 2）。按照步骤操作确保无缝集成。

5. 最后，为了启动实验，我们将初始化一个名为 security_usecases 的新项目。你可以从仓库的第 8 文件夹中复制包含所有文件的整个文件夹，也可以在练习过程中创建自己的文件。只需将提供的代码片段复制到你的文件中，并结合它们来逐一探索实验步骤。

第 2 步：云安全分析

在这一步中，我们将分析一个权限过大的 Terraform 脚本，以揭示源于过度权限和开放端口的安全风险。此类配置违反了最小权限原则，可能会使您的基础设施暴露在不必要的漏洞之中。使用 Codestral，我们将识别并解决这些问题以加强您的云安全态势。

请遵循以下步骤：

1. 打开提供的 Terraform 脚本 (too-permissive.terraform)。关注定义入站和出站规则的安全组配置。

2. 然后通过查看以下行来识别漏洞代码：

resource "aws_security_group" "example" {
  name        = "example-security-group"
  description = "Security group"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"] # Open SSH access
  }

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"] # Open HTTP access
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"] # Open all traffic
  }
}

这些配置允许对 SSH 和 HTTP 的无限制访问并开放了所有出站流量，使应用程序暴露在不必要的风险之中。此外，请识别以下几行：

# 具有广泛权限的内联策略
inline_policy {
  name   = "example-inline-policy"
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect   = "Allow"
        Action   = "*"
        Resource = "*" # 权限过大的角色
      }
    ]
  })
}

如前面的 Terraform 配置所示，该内联 IAM 策略在没有任何限制的情况下授予了过于宽泛的权限。使用 Codestral，我们分析了这段代码将其标记为安全风险。这种无限制的访问可能导致权限提升或横向移动，这强调了在策略定义中应用最小权限原则的必要性。

3. 接下来，我们按下 CMD + A 选中所有行，然后按 CMD + L 将整个文件片段添加到新的 Codestral 对话上下。我们这样做的原因是因为文件的第一部分包含一个内联 IAM 策略，该策略授予了通用的 "Action": "*" 和 "Resource": "*" 访问，这种危险的宽松配置违反了最小权限原则，并构成了严重的安全风险。

4. 然后，使用以下提示词：

你是一个专注于安全的 AI 专家。你的任务是审查以下 Terraform 脚本，以识别潜在的安全配置错误。逐步分析脚本，并识别任何与权限过宽的规则、不必要的开放端口以及违反最小权限原则相关的问题。

分析任务：
1. 识别并描述配置错误，重点关注权限过大的入站和出站规则。
2. 提出具体的改进建议，以执行最小权限原则。
3. 提供保障云基础设施安全的通用最佳实践。

请按以下结构组织你的分析：
1. 识别出的配置错误：
   - [问题的简要描述]
   - [代码行号或位置]
   - [影响或潜在的利用方式]
2. 缓解建议：
   - [建议的配置更改]
   - [最佳实践]
3. 安全配置建议：
   - [关于安全云配置的建议]

重点关注可操作的建议以及如何改进安全态势的具体示例。

提交提示词后，模型将生成一个结构化响应，突出显示配置错误、建议缓解措施并概述安全配置实践。为了理解这些结果，我们将逐部分分析每一个内容。首先，我们将回顾响应中识别出的发现漏洞配置错误部分：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_08_01.png

图 8.1: Terraform 脚本 – 识别出的配置错误

让我们仔细观察并对这些识别出的配置错误进行分析：

• 权限过大的入站规则：如响应所示，允许从任何 IP 地址（0.0.0.0/0）访问 SSH、HTTP 和 HTTPS 会使应用程序无限制地暴露在互联网上。这为未经授权的访问或拒绝服务攻击创建了巨大的攻击面。将访问限制在受信任的 IP 范围内对于降低风险至关重要。

• 权限过大的出站规则：如强调的，开放的出站规则允许所有出站流量访问任何 IP 地址，这带来了意外数据泄露或与恶意资源通信的风险。通过将出站流量限制为仅必要的 IP 和端口，你可以更好地控制和监控出站连接。

• 权限过大的 IAM 角色：响应指出，对所有资源授予完全权限违反了最小权限原则。这为在 AWS 资源上进行未经授权的操作打开了大门，可能导致意外删除或权限提升等严重后果。将权限限制在仅必要的范围内有助于缓解这些风险。

现在，让我们调查缓解建议：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_08_02.png

图 8.2: Terraform 脚本缓解建议

让我们仔细观察并对这些缓解建议进行分析：

• 限制入站规则 涉及将访问缩小到仅限绝对必要且来自受信任源的流量。将 0.0.0.0/0 CIDR 块替换为特定的 IP 地址或范围，可以确保您的系统在保持基本连接的同时，不会暴露在潜在入侵者的攻口之下。

• 限制出站规则 的精髓在于精确控制出站流量。通过消除开放的出站规则并引入目标规则，你可以防止意外的通信和数据泄露，确保仅允许授权且必要的连接。

• 限制 IAM 角色权限 的原理是为该角色执行其工作提供足够的访问权限。放弃过度宽泛的权限并指定具体的操作和资源，可以创建更严密的安全态势，减少未经授权操作和权限提升的风险。

接下来，让我们查看安全配置建议。以下建议概述了通过解决权限过大的配置来增强云安全的关键策略。这些步骤利用 AWS 最佳实践来控制访问、减少暴露面并有效监控网络活动。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_08_03.png

图 8.3: 安全配置建议

让我们仔细观察并对安全配置建议进行分析：

• 使用安全组进行实例级访问控制的精髓在于过滤流量并仅允许授权的连接，减少对威胁的暴露。

• 实施子网级访问控制的网络 ACL（访问控制列表）意味着是在到达实例之前添加另一层安全层来过滤流量。

• 使用 IAM 角色和策略进行访问控制的原理是仅授予必要的权限，最大限度地减少未经授权访问的风险。

• 启用 VPC 流日志的目标是跟踪流量并识别可疑活动，以进行更好的威胁监控。

此练习步骤强调了权限过大的云配置的风险，例如不受限制的 SSH 访问和开放的出站规则。通过使用 Codestral 定位这些漏洞，你可以实施更严密的安全措施，强化最小权限原则并最小化你的攻击面。在有了安全配置的情况下，你的云环境将受到针对潜在威胁的良好保护。

在对如何通过适当访问控制和流量监控来保护云环境有了充分理解后，是时候将注意力转移到应用程序级漏洞了。在下一步中，我们将深入 SQL 注入检测，探索处理不当的用户输入如何破坏您的数据库。让我们发现这些风险并学习如何保护您的数据！

步骤 3：SQL 注入检测

安全漏洞就像地基中的隐藏裂缝，可能会破坏整个系统。主动检测并解决它们可以确保稳固的防御。在此步中，我们将分析 Java Servlet 代码以发现 SQL 注入等常见问题，并学习如何利用 Codestral 提供的可行见解来加强应用程序。总的来说，这次练习将展示如何在真实代码中检测和缓解安全风险。

1. 我们首先打开 JdbcServlet.java 文件。关注第 14–66 行，这些行包含处理用户输入和数据库查询的逻辑。

2. 将第 14–66 行复制到剪贴板。特别注意第 39 行，用户输入被直接拼接到 SQL 查询语句中。

String sql = "SELECT * FROM users WHERE username = '" + param + "'";

这使得应用程序面临 SQL 注入风险，这是一个常见且危险的漏洞。例如，恶意用户可以注入 SQL 命令来删除表或提取敏感数据，从而绕过预定的功能。

3. 按下 CMD + L 将选定的代码段添加到 Continue 扩展中的新聊天上下文中。这将允许 Codestral 分析代码。

提示词结构化技巧

• 首先告诉 LLM 它是谁（例如，"你是一个安全专家"）。

• 列出你想要的任务（例如寻找漏洞、建议修复方案）。

• 最后，定义你期望的响应格式。

• 清晰的角色、清晰的目标和清晰的结构会带来更好的结果。

将以下提示词粘贴到 Codestral 聊天中：

你是一个专注于安全的 AI 专家。你的任务是审查以下 Java Servlet 代码的潜在漏洞。分步分析代码并识别与安全、代码质量或最佳实践相关的问题。

分析任务：

1. 识别并描述安全漏洞，关注 SQL 注入、硬编码凭据和处理不当等风险。

2. 针对每个识别出的漏洞提出缓解建议。

3. 针对处理用户输入、数据库查询和敏感信息推荐安全编码实践。

4. 如果适用，突出任何代码异味或对最佳实践的违反。

按以下结构提供你的分析：

1. 识别出的漏洞： - [问题的简要描述] - [代码中的行号] - [影响或潜在利用方式]

2. 缓解建议： - [建议的代码改进] - [最佳实践]

3. 安全编码建议： - [关于安全编码的通用建议]

关注可操作的建议和改进代码的具体示例。

Codestral 将分析代码并突出显示漏洞。以下是你可能会看到的示例：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_08_04.png

图 8.4: Java 代码中识别出的漏洞

图 8.4 展示了 Codestral 的响应，它标记了漏洞 JDBC 代码段中的关键安全问题，例如 SQL 注入、硬编码凭据和错误泄露。SQL 注入反映了对信任边界的广泛忽视。通过直接将用户输入嵌入查询中，代码为攻击者提供了重定义逻辑（redefine logic）、访问数据或提升权限的机会。这是缺乏验证以及数据与命令之间分离不良的典型标志。

同时，硬编码凭据和错误泄露表明缺乏秘密管理规范。以明文存储数据库凭据是一种捷径方法，如果仓库泄露，可能会产生毁灭性的影响。同样，将原始错误消息返回给客户端会让内部逻辑对外部可见，为攻击者提供利用漏洞的线索。这两者表明缺乏分层安全思维。

接下来，让我们调查缓解建议：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_08_05.png

图 8.5: 漏洞 Java 代码的缓解建议

图 8.5 展示了使用预编译语句（prepared statements）构建 SQL 查询的安全方法。这种方法通过将 SQL 逻辑与用户输入分离，有助于消除 SQL 注入风险，确保恶意值不会更改预期的查询行为。

此外，图中强调应避免硬编码凭据。相反，鼓励开发者将敏感凭据存储在环境变量或安全箱（vaults）中，以减少在源代码泄露时的暴露风险。

最后，对于不当的错误处理，最佳实践是通过自定义错误页面提供通用错误消息。这可以防止技术细节泄露，这些细节可能会帮助攻击者探测系统弱性。

现在，让我们调查编码建议：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_08_06.png

图 8.6: 漏洞 Java 代码的安全编码建议

图 8.6 提供了一组更广泛的安全配置实践，这些实践超越了单一漏洞，并涵盖了整体的应用程序卫生问题。指南包括使用参数化查询来防御注入、避免硬编码密钥以及清理输入以停止恶意负载。它还强调了适当的错误处理、使用 HTTPS 进行加密传输以及保持软件更新，共同构成了分层的、主动的安全态势。

Codestral 提供了全面的分析，详细说明了漏洞、潜在利用方式和可操作的解决方案。这些反馈不仅有助于修复当前问题，还为安全编码实践奠定了基础，确保应用程序对未来攻击的韧性。

通过这个过程，我们学习了如何识别和修复安全风险，这是构建安全软件的一项技能。我们对 SQL 注入漏洞及其处理方法有了清晰的理解。在 Codestral 的帮助下，我们解决了风险并采用了安全编码实践，使我们的应用程序更加安全。

接下来，我们将深入研究跨站脚本（Cross-Site Scripting, XSS），这是另一种常见且危险的漏洞。你将学习攻击者如何利用未清洗的用户输入来注入恶意脚本，以及如何通过有效的验证和清理技术来防御你的应用程序。让我们继续加强防御吧！

第 4 步：跨站脚本检测

在这一步中，我们将探索 PHP 脚本中的跨站脚本（XSS）漏洞，该脚本接收 URL 参数并在响应中未转义地包含。XSS 允许攻击者向 Web 应用程序注入恶意脚本，可能损害用户数据或获取控制权。

让我们开始：

1. 打开或创建 PHP 文件并将以下代码保存为 vulnerable.php：

<?php

if (isset($_GET['input'])) {

    $input = $_GET['error'];

    echo "<div>Error: $input</div>";

} else {

    echo "<div>No input provided.</div>";

}

?>

2. 然后，识别漏洞代码。关注第 3–4 行：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_08_07.png

图 8.7: 漏洞 PHP 代码段

• 第 3 行从错误 URL 参数获取用户输入，且没有进行任何验证或清理。

• 第 4 行将输入直接输出到 HTML 中，这可能允许攻击者注入恶意脚本，例如 <script>alert('XSS');</script>。

3. 使用 Continue 扩展分析代码。按 CMD + L 将代码段添加到新的聊天上下文中供 Codestral 处理。将此提示词粘贴到 Codestral：

You are a security-focused AI expert. Your task is to review the following PHP script for potential vulnerabilities. 逐步分析代码并识别任何与安全、代码质量或最佳实践相关的问题。

    Analysis Tasks:

    1. 识别并描述安全漏洞，关注如 XSS、不当的输入处理和输出清理等风险。

    2. 建议改进措施以缓解每个已识别的漏洞。

    3. 为处理用户输入和防止 XSS 攻击推荐安全编码实践。

    请按照以下结构提供你的分析：

    1. Identified Vulnerabilities: - [问题的简要描述] - [代码中的行号或位置] - [影响或潜在的利用方式]

    2. Mitigation Recommendations: - [建议的改进代码] - [最佳实践]

    3. Secure Coding Recommendations: - [关于安全编码的通用建议]

    关注可操作的建议以及改进代码的特定示例。

Codestral 的响应应该类似于此：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_08_08.png

图 8.8：Codestral 对脆弱 PHP 代码段的响应

如我们所示，图 8.8 中的 LLM 响应彻底识别了 XSS 漏洞、其影响以及可操作的缓解措施，例如使用htmlspecialchars()对输出进行清理。它强调了安全编码实践，包括输入验证、输出编码和深层防御策略。这种清晰且可操作的反馈使开发者能够有效地解决漏洞并构建更安全的应用程序。

整个练习演示了 XSS 漏洞如何容易地从未经清理的用户输入产生。通过使用 Codestral，我们可以快速识别这些风险并实施适当的缓解措施，例如转义用户输入和验证 URL 参数。这些实践对于保护用户和确保 Web 应用程序的安全至关重要。

总结

在本章中，我们探索了现代网络安全的多方面世界，深入研究了关键安全应用和实际漏洞分析。我们首先通过检查防火墙日志来检测异常并确定威胁优先级，随后重点关注状态化防火墙日志，以发现不完整的会话和协议滥用。SQL 注入检测强调了不安全的数据库交互的风险以及参数化查询的重要性。端点安全强调了预测恶意软件、确保配置合规性以及监控关键文件，而数据外泄检测则揭示了异常传输、加密滥用和内部威胁的危险。

我们涵盖了身份验证与授权，识别了过度许可的访问控制并检测了凭据滥用。应用程序代码安全关注了 OWASP 漏洞、依赖风险和自定义威胁模式。用户行为分析帮助我们识别会话异常、命令与控制模式以及钓鱼尝试。云安全强调了误配置监控和存储安全的重要性，而通过 Mistral 实现自动化则展示了 LLM 在生成执行剧本（playbooks）和分析日志方面的强大能力。上手工作坊通过实际练习巩固了这些概念：保护 Terraform 脚本、识别 JDBC 代码中的 SQL 注入以及缓解 PHP 脚本中的 XSS 漏洞。这些技能合在一起为应对现实世界中的安全挑战提供了坚实的基础。

在下一章中，我们将进入更具开放性的领域，面对高级的课后式 RAG 挑战。你将为自己的检索增强生成（RAG）解决方案进行脑风暴、构建和评估，将所学应用于现实场景。别担心，第 10 章和第 11 章将回到更具引导性的格式，但会有有趣的可选的课外活动来进一步提升你的技能。

课外活动

1. 使用 Wireshark 分析可疑数据包：深入真实数据包捕并使用 Wireshark 调查异常。然后，将选定的数据包摘要或日志粘贴到你的 Mistral LLM 设置中，让它标记异常模式、检测可疑 IP 或解释某些协议的意义，就像一个虚拟 SOC 分析师帮助你磨炼直觉一样。链接：

   • www.malware-traffic-analysis.net/

   • digitalcorpora.org/?s=pcap

2. 在 CVE/CWE 数据库中探索真实世界的漏洞：使用 CVE 和 CWE 数据库研究过去的安全误配置案例。将 CVE 摘要或 CWE 描述输入 Mistral 并请求解释、风险总结，甚至是针对 Terraform 的类比。这是将阅读与实操 AI 指南相结合的极佳方式，可以根据你的风格量身定制学习。链接：

   • www.cve.org/

   • cwe.mitre.org/

   • nvd.nist.gov/

| | |

| :--- | :--- |

| 现在解锁此书的专属福利。扫描此二维码 或访问 packtpub.com/unlock，然后按名称搜索此书。 | https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/Unlock-01.pnghttps://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/Unlock2.png |

| 注意：在开始之前请准备好你的购买发票。 | |

9 课后 RAG 挑战

预测未来的最好方法是发明它。

—阿兰·凯 (Alan Kay)

RAG 通过无缝结合检索与生成为 AI 开启了新的可能性。然而，最令人兴奋的潜力在于尚未被探索的领域。将 RAG 应用于法律、医学和金融等专业领域需要精确、创意和技术深度。诸如优化嵌入、针对特定应用进行微调以及集成实时数据流等挑战推向了现有实现的极限。在多模态场景下，当文本与图像、代码甚至实时环境相遇时，复杂性进一步增加。

本章提供了一个高层次的挑战：将这些高级思想转化为可操作的项目。尝试新的检索机制，重新定义性能基准，并跨模态进行创新。想象新颖的应用，并构建能够动态适应不断变化的信息格局的系统。

你的任务非常明确：将这些挑战拆解为具体的步骤，大胆实验，并为塑造 RAG 的下一个前沿做出贡献。智能系统的未来不仅在于理解信息，更在于发现检索、生成和创建的新方法。

本章将涵盖以下主要主题：

• 有帮助的代码示例

• 问题陈述

• 挑战 1：用 RAG 彻底改变软件 QA

• 挑战 2：用 RAG 构建实时摘要器

有帮助的代码示例

为了强化本章中的概念，我们包含了几个装满实操、即插可用代码的 Jupyter 笔记本。你可以在https://github.com/PacktPublishing/Learn-Mistral仓库中找到所有示例：

• Ch09_01_various_integrations.ipynb：探索与外部服务的实时集成。此笔记本提供了用于 Jira 跟踪、Slack 机器人、RSS 馈以及 GDELT 新闻的工作代码。你将学习如何身份验证、调用 API、获取并解析数据，并在下游应用中使用。

• Ch09_02_indexing.ipynb：深入使用集成Weaviate和Milvus等向量数据库的向量索引。遵循端到端工作流来嵌入向量并使用余弦相似度执行高效搜索。

• Ch09_03_custom_embedding.ipynb：查看如何设计你自己的领域嵌入，例如时尚，并构建完整的管道来生成。对于预训练模型不符合需求的情况非常有用。

• Ch09_04_data_parsing_and_organization.ipynb：这是一个演示端到端文本处理的综合笔记本：解析 PDF 和 HTML，使用Beautiful Soup和pandas进行清理，使用Transformers进行总结，提取实体并进行标签标记。对于涉及非结构化文档摄取和语义增强的工作流非常理想。

这些笔记本作为构建和扩展 AI 管道的实用模板。

问题陈述

世界越来越重视能够独立思考、创造性工程化并清晰解决问题的人。在现实世界的 AI 应用中，没有分步的指南；只有高层次的目标和混乱的数据。本章邀请你学习最重要的技能：将复杂的挑战转化为结构化的解决方案。通过开放式的实操 RAG 项目，你将练习拆解、做出智能架构选择并构建适应和扩展的系统。如果可以在需要时快速找到正确的信息（测试步骤、日志或过去的修复方案）将会如何？这个挑战是你设计更智能、更快且响应迅速的 QA 工作流的机会。

挑战 1：用 RAG 彻底改变软件 QA

软件 QA 可能是枯燥的，充满了分散的文档和重复的调试。RAG 助手可以通过自动查找测试用例、总结错误历史并提供感知建议来简化这一点，从而将 QA 从被动任务转向主动过程。

例如，一个新入职 QA 实习生加入移动应用开发团队。为了理解测试方法，他们筛选了过时的 Excel 表格并阅读了 GitHub 和 Google Docs 上数百行的测试脚本。他们感到不知所措。通过使用 RAG 手，实习生可以询问 QA 助手：“登录模块常见的错误有哪些？”它总结了失败的测试场景，显示了最近的身份验证问题，甚至建议重新运行测试。学习曲线从几周缩到了几天。

让我们看另一个例子。金融科技公司的 QA 工程师正在测试流程。他们在模拟信用卡失败时遇到漏洞。为了调查，他们翻阅 Jira ，在 Confluence 中搜索测试脚本并扫描 Slack 获取提示，在清晰的情况下浪费了 45 分钟。现在，在 RAG 的帮助下，QA 工程师将错误信息输入 QA 助手。它立即返回上次类似错误的测试用例，链接到三个月前的匹配修复，并在几秒内建议可能的 API 头错误。

这些示例揭示了一个模式：重复的搜索、分散的文档和缺失的洞察减慢了 QA 工作。为了解决这个问题，该挑战提出了由 RAG 驱动的聚焦管道（摄取、检索和生成）。下面的插图概述了它的关键组件以及它们如何相互配合。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_09_01.png

图 9.1：QA RAG 系统的高层架构

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/1.png快速提示：需要查看此图像的高分辨率版本吗？在下一代 Packt Reader 中打开此书或在 PDF/ePub 副本中查看。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/2.png购买此书免费赠送下一代 Packt Reader。扫描此二维码或访问 packtpub.com/unlock，然后使用搜索栏按名称找到此书。双检查显示的版本以确保获取的是正确的。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/Unlock2.png

在后续步骤中，你将定义 QA 助手的范围，摄取并结构化真实的测试数据，设计检索管道，并微调系统使其在现实场景中运行。将其看作一次黑客松式的练习，创意和精确性同样重要。

步骤 1：定义你的 RAG 系统范围

从明确你的 RAG 系统将实现什么开始。将其目的视为 QA 工程师的虚拟助手，能够获取测试用例或常见错误的总结。为了有效实现此目标，探索如 Atlassian REST API 等 API，以程序化的方式获取错误报告和测试用例。对于额外数据，考虑与 GitHub Issues 或 Jenkins 等工具集成。

在上手构建你的 RAG 助手之前，花时间收集洞察：

• 标记异常模式，

• 检测可疑 IP，

• 解释某些协议的意义，

就像一个虚拟 SOC 分析师帮助你磨炼直觉一样。

在没有模板的情况下，能够跨层进行推理并快速构建原型想法是一种竞争优势。让我们练习这种心态并享受其中吧。让我们从一个现实世界的挑战开始：使用 RAG 改进软件测试。QA 团队通常处理长测试用例、错误报告和重复任务。如果可以构建一个系统在需要时快速找到正确的信息（测试步骤、日志或过去的修复方案）将会如何？这个挑战是你设计更智能、更快且响应迅速的 QA 工作流的机会。

{
  "prompt": "登录错误的测试用例是什么？",
  "system": "你是一个得力的 QA 助手。",
  "options": {}
}

RAG 封装与流式输出

你可以编写一个轻量级的封装器（例如使用 FastAPI），来接收此请求并将提示词（prompt）路由到你自己的 RAG 流线。在后台执行检索、组合上下文并运行生成，然后以流式块的形式返回，就像 Ollama 一样。

这个技巧允许你完全复用 UI，包括语音转文本、流式输出和消息格式化，同时更换后端“大脑”。它简单、高效，并让你专注于改进助手的智能性，而不是重新构建已经运行良好的部分。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_09_03.png

图 9.3：检索过程流程图

上图说明了检索过程，展示了用户查询如何转换为嵌入（embeddings），以便使用 Elasticsearch 或 FAISS 进行高效的语义搜索。

• 参考资料：

• 使用 Weaviate 和 Milvus 通过 Mistral 嵌入进行向量索引和语义搜索的示例包含在 Chapter-9/Ch09_02_indexing.ipynb 中。

• 对于自定义嵌入工作流（例如为时尚品类设计并索引自己的向量），请参考 Chapter-9/Ch09_03_custom_embedding.ipynb。

这些笔记本共同提供了使用预训练嵌入和领域特定嵌入进行向量创建、存储和检索的端端解决方案。

你最终将获得一个运行的检索流线，它能为给查询返回最相关的文档。该流线应该使用嵌入来实现语义准确的结果，使其比基础的关键词搜索要有效得多。

进阶目标

通过集成混合搜索方法来扩展你的检索系统，该方法结合了语义搜索（使用嵌入）和传统的基于关键词的搜索。测试这种混合方法如何提高检索的相关性，特别是在语义模型可能会误解测试用例中特定技术术语或唯一标识的边缘情况下。

此外，实现一个查询扩展模块。使用同义词扩展或相关术语生成等技术（例如将“登录失败”扩展为“验证错误”或“凭据不匹配”）。测试查询扩展如何影响检索结果的多样性和准确性。你可以尝试 NLTK 或 WordNet 等库来构建你的扩展逻辑。

对于更高级的挑战，创建一个反馈循环，让 QA 工程师可以将检索结果标记为“相关”或“不相关”。使用此反馈来微调检索引擎，动态提高未来相似查询的相关性。

第 4 步：微调 RAG 系统

微调你的 RAG 系统可以确保它在软件测试场景下表现良好。从准备一个高质量数据集开始，其中应包含查询及其相应理想响应的标记示例。使用该数据集通过 Hugging Face Transformers 等框架微调你的系统。

例如，考虑诸如“调试内存泄漏问题的步骤”之类的查询。你微调后的 RAG 系统应该从调试指南中检索出一系列详细步骤，并用生成的提示来丰富它们。为了进一步提升你的系统，探索它如何处理模糊的查询，例如“后端服务的性能问题”。尝试使用提示工程来澄清模糊的用户输入，并生成更具上下文感知能力的输出。

高效且简便的微调

微调大模型听起来可能很重，但只要方法正确，它可以变得出乎意料地易于且高效。一个很好的起点是 DigitalOcean 的指南 Fine-Tune Mistral-7B with LoRA: A Quickstart Guide，它介绍了如何在 A6000 等适中硬件上使用 QLoRA（4 位量化 + LoRA）：https://www.digitalocean.com/community/tutorials/mistral-7b-fine-tuning。

你会在 Mistral-FineTune GitHub 仓库 (https://github.com/mistralai/finetune) 中找到生产级代码库，并在 https://colab.research.google.com/github/mistralai/finetune/blob/main/tutorials/finetune_7b.ipynb 中找到完全可执行的 Colab 教程。这些资源将引导你完成环境搭建、数据集格式化以及使用 peft 和 trl 的训练流。

将其适配你的 RAG 系统，使用真实的调试问题和结构化答案作为训练示例。模型将学习检索并生成上下文相关的精确输出，同时保持轻量化。从小数据集开始，跟踪性能并迭代。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_09_04.png

图 9.4：微调流程图

上图概述了微调流程，展示了如何使用标记数据集进行训练和验证。

• 参考资料：

• Chapter-9/Ch09_04_data_parsing_and_organization.ipynb 笔记本演示了如何解析 PDF 和 HTML，使用 pandas 和 Beautiful Soup 清理文本，应用 sentence-transformers 进行摘要，使用 NER 提取实体并通过标记丰富文档。

预期结果是一个微调后的 RAG 模型，它能够将检索的数据与 QA 任务的可执行输出相结合。

进阶目标

通过引入为软件工程定制的领域特定嵌入来进一步推进微调。在 Stack Overflow 或开源的 GitHub Issues 上进行训练，以创建检索和生成过程。将你的 RAG 系统性能与通用嵌入进行比较。

另一个有趣的挑战是实现零样本或少样本学习。不需要标记大型数据集，只需在微调期间提供几个高质量的示例，以观察系统对未见查询的泛化能力如何。对于高级挑战，通过调优系统以处理后续查询来实验多轮查询理解。例如，在查询“调试内存泄漏的步骤”后，下一个查询可能是“我可以使用哪些工具？”。

第 5 步：验证输出

测试并验证你的 RAG 系统以确保其有效性。从使用常见 bug 查询系统进行手动验证开始，将其与已知解决方案进行比较。衡量精确率、召回率和相关性等指标。

除了手动测试，通过编写符合预定义标准的用例来自动化验证过程。例如，创建一个 CI/CD 流线，每当录入新数据或更新组件时自动运行这些测试。通过集成 Jenkins 或 GitLab 等工具可以保持系统可靠性。

自动化反馈循环以实现扩展

测试你的 RAG 系统不仅是为了证明它在工作，更是为了构建在规模扩大时保持可靠的信心。从小开始：使用电子表格或 JSON 文件来跟踪查询和理想答案。一旦对基准有了信心，就转向自动化。使用 pytest 或 unittest 进行测试。使用 sklearn 或 sentence-transformers 等库计算参考与生成答案之间的语义相似度。

将这些测试接入 CI/CD 流线——Jenkins、GitLab 或 GitHub Actions。每当你更新数据、检索器或模型权重时，流线都应自动重新运行验证。这创建了一个反馈循环，让你比用户注意到质量下降更早发现问题。

到此步骤结束，你的 RAG 系统应该始终返回准确且相关的输出，并由健壮的验证过程支持。

扩展目标

通过引入压力测试场景来增强验证过程。使用 Apache JMeter 或 Locust 等工具模拟高查询负载，衡量系统在压力下保持准确性和响应时间的能力。评估并发对检索和生成组件的影响，识别瓶颈以进一步优化。

另一个微挑战是实现真实测试套件，直接从生产日志或团队对话（例如 Slack 或 Jira）中提取查询。这将为你提供一个评估 RAG 系统在真实场景中表现的实践基准。

第 6 步：优化与扩展

为了让你的系统做好真实部署准备，关注优化和可扩展性。从调优检索引擎以处理数据集开始。探索高级索引方法或缓存机制以降低延迟。例如，缓存高频查询可以显著提高响应速度。

扩展系统涉及使用 S3 等云存储解决方案管理数据量。考虑使用 Milvus 或 Weaviate 等工具进行分布式索引。对于优化，尝试预生成嵌入并将其存储为 .npy 或 .parquet 文件，而不是实时计算。

对于扩展性尝试，使用 Docker Compose 等工具运行多个节点以模拟分布式行为。如果你还没有配置云资源，第 10 章 将引导你设置账户、创建用于摄取和检索的第一个 S3 桶。

预期结果是一个针对性能优化的高效可扩展系统。

通过实现优先考虑高频查询的缓存层实验动态缓存策略。使用 Redis 或 Memcached 等工具缓存结果并比较对延迟的影响。

第 7 步：集成 QA 工作流

优化后，将你的 RAG 系统集成到现有的 QA 工作流中以实现无缝可用。一种方法是创建一个机器人界面，QA 工程师可以直接从 Slack 或 Microsoft Teams 等协作工具进行查询。另一个想法是将系统与 Jira 连接，以便它可以为新创建的问题自动解决方案。使用 n8n 作为你的 QA 助手的原型场。你可以模拟真实工作流并测试 RAG 在上下文中的响应。这种方法有助于及早发现用户体验差距。

接下来，通过设计直观的界面来关注用户体验。添加功能，如常见查询的自动补全建议或可视化复杂调试步骤的流程图。对于一个有趣的挑战，使用 Slack API 构建 Slack 机器人并测试 QA 团队如何与它交互。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_09_05.png

图 9.5：集成 QA 工作流

该图说明了 QA RAG 系统如何与现有工作流集成，连接 Jira、Slack 和 CI/CD 流线等工具。

• 参考资料：在 Chapter-9/Ch09_01_various_integrations.ipynb 中，你会找到集成外部数据源的操作示例，包括 Jira、Slack、RSS 馈、GDELT 项目和 News API。该笔记本帮助你从这些平台连接、身份验证并检索实时数据，用于下游处理或集成到更大的 AI 工作流中。

预期结果是拥有完全集成的系统，QA 工程师可以通过 Slack 或 Jira 等工具轻松访问，提供实时协助并提高整体测试生产力。

扩展目标

通过实现主动通知来进一步推进集成。配置你的 RAG 系统以监控 Jira 或 Slack 中的持续活动，当特定关键词或模式出现时自动建议解决方案。例如，如果 Jira 中创建一个关于“登录失败”的新问题，系统可以推荐相关的调试指南和用例。

下一级练习是开发多平台集成。扩展你的聊天机器人不仅工作于 Slack，也工作于 Microsoft Teams 或 Discord。

对于更高级的挑战，集成视觉化助手。允许 RAG 系统生成复杂问题的流程图或逐步调试指南。使用 diagram-js 或 draw.io 等库动态生成这些可视化内容。一旦你的 RAG 系统完成，就是时候将其分享给世界了。

结语

构建系统以重新思考软件测试可以通过高级 AI 工具的支持。从数据摄取到微调和集成，概述的每个步骤提供了创新机会，解决现实挑战并直接影响 QA 流程。

挑战 2：使用 RAG 构建实时新闻摘要器

新闻变化极快，信息的持续流也是如此。从头条新闻到详细分析，这个挑战探索了 RAG 如何通过获取最新故事并将其转换为简洁相关的摘要来过滤噪音。

第 1 步：集成新闻流和公共 API

第一步是从新闻来源和 API 收集数据。使用 Google News RSS 馈、NewsAPI 等公共 API 或 GDELT 等开源数据集。配置你的系统实时获取并预处理文章。构建一个简单的摄取流线来清理和结构化导入的数据。可以使用 Python 的 pandas 和 Beautiful Soup 进行预处理。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/0.png

图 9.7：实时新闻摄取

上图演示了使用 TG、RSS 馈和 API 的实时新闻摄取。

参考资料：本章的所有代码示例组织在四个笔记本中以便探索和复用：

• 集成：Ch09_01_various_integrations.ipynb 包含了 Jira、Slack、RSS、GDELT 和 News API Demo。

• 向量索引：Ch09_02_indexing.ipynb 展示了使用 Weaviate 和 Milvus 通过 Mistral 嵌入进行向量索引。

• 自定义嵌入：Ch09_03_custom_embedding.ipynb 介绍了如何创建和查询你自己的自定义嵌入。

• 数据解析和 NLP：Ch09_04_data_parsing_and_organization.ipynb 引导你完成解析、清理、摘要、NER 和标记。

为了实验近实时摄取，使用 n8n 或 Make.com 构建无代码/低代码自动化工作流。使用 RSS 馈触发数据收集，然后通过预构建的 Python 函数或 HTTP 节点调用你的 FastAPI 服务进行清理步骤。通过完成此阶段，你应该拥有一个运行的摄取流线，能够持续收集和预处理实时新闻文章。输出应该是干净的、结构化的数据，准备在 RAG 系统中进行语义索引和检索。

扩展目标

通过集成实时数据流将你的摄取流线提升到新水平。使用 Kafka 持续处理文章，并在它们进入向量存储之前按区域、语言或主题进行过滤。这允许你保持数据集的新鲜、聚焦和高度相关，非常适合构建动态基于新闻的助手。流式处理也为时间敏感的触发器和警报打开了大门。

第 2 步：构建相关文章的检索系统

设计一个检索系统来获取匹配用户查询的文章。从使用可扩展搜索引擎 Elasticsearch 或 FAISS 索引你的预处理文章开始。使用通过 OpenAI API 或 sentence-transformers 生成嵌入来实现语义搜索。这种方法确保你的系统可以匹配查询的含义，而不是仅仅依赖关键词重叠。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_09_06.png

图 9.6：新闻摘要器：设计稿

上图显示了该系统的概要设计。多个实时源（RSS 馈、公共 API 甚至 TG 频道）接入摄取流线，在实时索引之前进行清理和结构化。你的任务是设计并构建这个系统作为一个个人新闻聚合器，将检索速度与摘要准确性相结合，同时跟上更新。

为了支持你的实验，我们为每个主要集成包含了完全功能的 Jupyter 笔记本：

• Chapter-9/Ch09_01_various_integrations.ipynb 探索了 Jira、Slack、RSS、GDELT 和 News API 连接。

• Ch09_02_indexing.ipynb 展示了使用 Weaviate 和 Milvus 通过 Mistral 嵌入进行向量索引。

• Ch09_03_custom_embedding.ipynb 引导你创建和查询你自己的自定义嵌入。

• 最后，Ch09_04_data_parsing_and_organization.ipynb 专注于解析真实的 PDF 和 HTML，结构化数据。

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
embedding = model.encode("What's the latest on semiconductor stocks?")

你将看到本地向量搜索变得多快且高效。

预期目标是，你的检索引擎应该根据用户查询准确地呈现最相关的新闻文章，并保持极低的延迟。它必须有效地处理实时输入，确保响应反映了最新且与上下文最对齐的内容。在实际使用中，系统应该感觉灵敏、准确且可靠。

扩展目标

升级你的检索流水线以支持混合搜索或流式搜索。将语义向量搜索与关键词过滤（例如使用 BM25 或在 Elasticsearch 中进行关键词预过滤）相结合以平衡精确性和性能。对于近实时应用，添加 Kafka 或 Kinesis Streams 在文章发布时进行摄取，实现持续索引并确保搜索的立即可用。这种架构为你的系统处理动态、大规模用例（如金融监控或危机警报）做好了准备。

第 3 步：微调生成式模型进行摘要

一旦检索到相关文章，你就需要对它们进行简洁的摘要。微调一个生成式模型（例如来自 Hugging Face library 的模型）来创建保留关键信息的摘要。通过将新闻文章与高质量摘要配对来准备训练数据，专注于保持事实的准确性。使用抽取式摘要等技术作为基准，并逐渐引入抽象式方法以获得更丰富的输出。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_09_09.png

图 9.9: 摘要模块

图 9.9 展示了摘要模块，演示了检索到的文章如何通过微调后的生成式模型处理以产生简洁输出。

参考材料：所有与 PDF 和 HTML 解析、使用 pandas 和 Beautiful Soup 进行数据清洗、NER 以及标签标记相关的示例均可在 Chapter-9/Ch09_04_data_parsing_and_organization.ipynb 中找到。该笔记本提供了一个完整的、可运行的工作流，用于结构化和丰富非结构化文档。

要快速开始，可以使用开源摘要模型，如来自 Hugging Face 的 facebook/bart-large-cnn 或 google/pegasus-xsum。这些模型开箱即用的性能强大。对于实际应用，你可以在本地进行原型设计或通过 Hugging Face Inference API 进行部署。在迭代过程中，尝试提示词调优（prompt tuning）或 LoRA 微调以匹配你的领域语气。将摘要步骤集成到模块化工作流中，并在检索后触发。如果你使用 n8n，可以通过 FastAPI 服务或 Hugging Face 端点调用你的摘要器，让你无需深入深究编排代码即可构建并测试工作流：

from transformers import pipeline

summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
summary = summarizer("Long article text here", max_length=150,

摘要与查询引擎

配置摘要模型参数，设置最小生成长度为 min_length=40，并关闭采样以提高确定性：

min_length=40, do_sample=False

print(summary[0]['summary_text'])

保持快速运行，使用几个新闻示例进行测试，并逐渐完善输出风格。如果延迟很重要，在全规模上线之前探索量化或模型蒸馏以加速处理。

完成此步后，你的系统应该包含一个健壮的摘要模块，能够对检索到的新闻内容提供清晰、简洁且与查询相关的摘要。模型应该有效地将长文章压缩为信息量丰富的亮点，保留上下文和事实完整性。这使用户能够快速吸收关键见解，增强在快速变化的实时信息环境中的可用性和相关性。

扩展目标

使用模糊查询对系统进行测试，例如“气候更新”或“经济展望”。探索系统在检索和压缩复杂的多文章主题为有意义的摘要方面表现如何。

将你的摘要模块封装为可复用的 CLI 工具或轻量级 Web 服务。将流水线（检索、摘要和响应格式化）封装进单个接口。添加配置模型选择、摘要长度和查询过滤器的选项。这使得你的工具更容易集成到其他工作流或插入到聊天界面。加分项：对其进行容器化，以便跨环境快速部署。

第 4 步：通过动态索引流水线实现实时更新

动态新闻聚合需要一个能够在新信息可用时持续更新的系统。创建一个定期摄取新文章、即时索引并失效过时内容的流水线。为此，请使用云存储（如 Amazon S3）结合 Apache Kafka（用于流式传输）和 Elasticsearch（用于实时索引）。

使用n8n或 Python 脚本开始 RSS 摄取。以下是如何从 RSS 馈送中提取和清洗数据：

import feedparser
from bs4 import BeautifulSoup
import pandas as pd

rss_url = "https://news.google.com/rss/search?q=semiconductors"
feed = feedparser.parse(rss_url)

cleaned_articles = []
for entry in feed.entries:
    soup = BeautifulSoup(entry.summary, "html.parser")
    content = soup.get_text()
    cleaned_articles.append({
        "title": entry.title,
        "link": entry.link,
        "summary": content,
        "published": entry.published
    })

df = pd.DataFrame(cleaned_articles)
df.to_csv("/tmp/cleaned_news.csv", index=False)

接下来，将清洗后的数据上传到 Amazon S3：

import boto3
s3 = boto3.client('s3')
s3.upload_file('/tmp/cleaned_news.csv', 'your-bucket-name',
     'news/cleaned_news.csv')

之后，将元数据发送到 Apache Kafka：

from kafka import KafkaProducer
import json

producer = KafkaProducer(bootstrap_servers='localhost:9092',
                         value_serializer=lambda v: json.dumps(v).encode('utf-8'))

for article in cleaned_articles:
    producer.send("news-stream", article)

使用 Elasticsearch 索引：

from elasticsearch import Elasticsearch

es = Elasticsearch("http://localhost:9200")

for article in cleaned_articles:
    es.index(index="news", document=article)

预期结果是一个能够动态整合新文章、保持索引新鲜度并对突破新闻做出响应，同时保持高效检索和摘要的系统。

性能测试与优化

前面的命令使用 Uvicorn 启动一个 FastAPI 应用，它是一个极快的 Python 服务器。这默认将在端口 8000 上启动 Web 服务。

在 JMeter 中创建测试计划

打开 JMeter GUI 界面，并添加一个具有 10–50 个并发用户的 thread group（线程组）。添加一个包含以下内容的 HTTP request sampler 采样器：

• 方法：POST

• URL：localhost:8000/summarize

• 请求数据：{ "text": "Latest news about quantum computing from Google." }

然后添加 view results tree 监听器并运行测试，测量平均延迟、错误和吞吐量。这可以让你量化性能瓶颈，并为缓存、负载均衡或异步处理策略制定计划。

想让你的系统性能更优吗？

Quantify -> Diagnose -> Cache -> Scale -> Optimize

预期的结果是一个响应迅速且优化的 RAG 系统，它能够持续检索最相关的新闻文章，并生成简洁、高质量的摘要，即使在处理频繁更新或处于用户需求高峰时也是如此。系统应表现出低延迟、极少错误，并在不同负载下保持吞吐量，确保流畅的用户体验和扩展可靠性。

进阶目标

为热门查询创建一个缓存层，并衡量它在多大程度上减少了高频用户请求的响应时间。尝试相同的 perf 测试，但使用 Locust 代替 Apache JMeter。

一旦你通过 Apache JMeter 和 Locust 完成了性能测试，请探索水平扩展策略。使用负载均衡器（例如 NGINX 或 AWS ALB）部署多个 API 实例，并测试并发用户负载下的系统行为。跟踪响应时间和吞吐量如何随系统规模而扩展。考虑启用异步处理（例如使用 FastAPI + asyncio 或任务队列如 Celery），以处理长时间耗时的摘要任务而不阻塞其他请求。

第 6 步：集成用户友好界面

设计一种完全通过聊天界面运行的简化用户体验。使用 Flask 或 FastAPI 处理后端逻辑，并使用官方 API 将你的系统集成到 Slack 或 Microsoft Teams 等平台。允许用户提交自然语言查询并直接在聊天中接收结构化结果。通过支持基于分类的过滤器（例如政治、体育和科技）以及启用线程对话进行更深层次的后续查询来增强体验。这种设置避免了对自定义前端的需求，同时支持实时对话式交互。

以下是一些实用的建议：

为你的自定义聊天前端暴露标准的 /rag-query 端点：

from fastapi import FastAPI, Request
from pydantic import BaseModel

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

@app.post("/rag-query")
async def rag_query(payload: QueryRequest):
    result = your_rag_pipeline(payload.query)
    return {"answer": result}

使用 TG 连接器将消息从聊天中继到 RAG 端点：

import requests

BOT_TOKEN = ""
RAG_API = "http://localhost:8000/rag-query"
URL = f"https://api.TG.org/bot{BOT_TOKEN}/"

def handle_updates():
    offset = None
    while True:
        res = requests.get(URL + "getUpdates", 
            params={"offset": offset}).json()
        for update in res.get("result", []):
            chat_id = update["message"]["chat"]["id"]
            text = update["message"]["text"]
            reply = requests.post(RAG_API,
                json={"query": text}).json()["answer"]
            requests.post(URL + "sendMessage",
                data={"chat_id": chat_id, "text": reply})
            offset = update["update_id"] + 1

handle_updates()

开发期间使用 ngrok 将你的本地服务暴露给 Slack 或 TG 等平台：

ngrok http 8000

到此步骤结束，你的系统应该提供一个无缝的对话式界面，用户可以使用自然语言与实时新闻进行交互。无论是集成到 Slack、Teams 还是自定义端点，这种体验都应该是响应迅速且毫不费力的，从而消除对传统前端的需求。

核心要点

使用 RAG 构建实时新闻聚合器不仅仅是一个酷炫的项目——它是你通往应用 AI 的跳板。在此过程中，你练习了集成实时数据、优化流水线，以及将嘈杂的数据流转化为有用的见解。核心收获是什么？你不需要一次性完成所有工作。从小处开始：也许是解析订阅、对标题进行嵌入，或者循序渐进地扩展。每一个部分都能提升你的技能并增加价值。你现在具备了将信息过载转化为清晰思路的能力。快速迭代，持续学习，让它属于你。

总结

本章的编写目的是激发你的好奇心，并启发你以创意且实用的方式尝试 RAG 系统。通过两个不同的挑战——构建一个问答助手和一个创建一个实时新闻摘要器，你已经接触了让 RAG 成为解决复杂问题游戏规则改变者的步骤、工具和方法。但这里的目标不仅仅是教学；而是让你对数据检索与生成式 AI 结合时产生的可能性感到兴奋。在Challenge 1中，我们探索了 QA 系统如何通过检索测试用例和调试步骤来协助工程师。在Challenge 2中，我们深入了实时新闻聚合的世界，处理实时数据摄取和摘要。本章的设计是为了激发你的想象力，而不是限制它。分步指南旨在帮助你开始，但真正的乐趣从你加入自己的点花、探索新工具并推向 RAG 能力的边界时开始。每一次实验，即使是混乱的实验，都是迈向创新的一步。所以，卷起袖子，启动你喜爱的 API，开始构建吧。谁知道呢？你的下一个想法可能会改变游戏。去吧——打破（安全地打破），学习并创造！接下来是探索 Amazon 上的 Mistral！是时候体验这种基础设施由他人代处理的愉快感觉了。在下一章中，我们将查看 Amazon Bedrock 上提供哪些 Mistral 模型。让我们接入云端，看看真正的“企业级”到底是什么样的。

AWS Bedrock 上的 10 Mistral

人多力量大。

—Johnwood

到此为止，你已经熟悉了 LLM 的转型力量。本章的核心在于帮助你充分利用 AWS Bedrock 的价值，因为它通过提供对高级模型的托管访问，简化了其中的一些挑战。我们将介绍 Bedrock 工作原理原理，探索为什么 Mistral 是一个脱颖出的模型，并查看如何将它们结合使用。然后，我们将进入一个实战工作坊，涵盖从设置环境到将 Mistral 集成到真实世界应用的所有内容。到结束时，你将拥有所需的工具和信心，让 AWS Bedrock 和 Mistral 成为你 AI 旅程中无缝的一部分。简而言之，将涵盖以下主题：

• 基于云的 AI 模型以及 Bedrock 如何简化扩展

• 使用 IAM 角色和权限确保安全

• 使用boto3发送请求并运行推理

• 通过 CloudWatch 日志监控活动和趋势

• 将 Mistral 部署在 Bedrock 上的实战工作坊

技术要求

为了完成此工作坊，中途需要一些基础要素。你需要一个AWS 账户、AWS CLI以及 Python SDKboto3。如果你已经准备了其中任何内容，那太好了——你可以复用现有的设置。如果没有，不要担心——这些组件都将作为环境设置的一部分逐步配置。

• AWS 账户：访问 Bedrock 服务所需的。如果你已经有一个个人账户，可以使用。创建一个账户是设置过程的一部分。

• AWS CLI：此命令行工具允许你从本地机器与 AWS 服务进行交互。如果尚未安装，稍后将设置指南。

• Pythonboto3SDK：适用于 Python 的官方 AWS SDK，采用 Apache 2.0 许可发布。它提供了对 Bedrock API 的程序化访问。我们将在干净的 Python 环境中安装它，但如果你已经有了，可以跳过安装步骤。

本章的所有代码和参考可以在 GitHub 仓库中找到：github.com/PacktPublishing/Learn-Mistral-7B，位于Chapter-10文件夹下。该仓库包含与工作坊一致的脚本，将作为你的实践参考。

问题描述

在与 LLM 工作时，很容易发现自己正穿梭于基础设施、扩展决策和模型优化的迷宫中。AWS Bedrock 旨在通过提供对 Mistral AI 等强大模型的托管访问来简化这一过程，但有效使用它仍然需要理解该平台及其细微差别。例如，你如何使用IAM 角色设置安全访问？如何微调工作流以在保持扩展性和成本控制的同时充分利用 Mistral 的性能？

让我们深入探讨这些问题及更多内容，为掌握 AWS Bedrock 和 Mistral AI 提供一条清晰的路线图。你将学习如何设置环境、将 Mistral 集成到你的项目中，并有信地扩展你的应用程序。目标是简化你与 LLM 的工作，让你专注于构建创新的、高性能的解决方案，而不会被技术障碍所困。

按顺序来看，接下来的章节形成了一个进展过程：我们从云端 AI 服务的为什么开始，然后移动到安全访问的机制、发布请求，最后是监控。这些内容为本后的实战工作坊奠定了基础。

基于云的 AI 模型：为什么 Bedrock 很重要

人工智能从复杂的基础设施密集型任务转变为易获取的云驱动解决方案。传统的部署 AI 需要管理计算资源、维护更新和扩展基础设施。这些挑战使得 AI 集成变得昂贵且耗时。AWS Bedrock 通过提供托管服务的预训练基础模型消除了这些障碍。开发者可以通过 API 访问可用即用的 AI，这允许更快的实现、自动更新和无缝安全。扩展性是另一个主要优势。AI 应用经常遇到波动的需求。通过 Bedrock，AI 会自动扩展以满足需求，无论你是处理几个查询还是数百万查询——都不需要手动干预。成本效率也是关键。运行自托管 AI 模型需要持续的硬件投资和维护。相比之下，Bedrock 以按需付费模式运行，你为你使用的部分付费。通过将 AI 视为服务而非基础设施，Bedrock 让开发者专注于创新而非维护。现在，在建立了为什么之后，下一步是理解如何安全连接——在与 Bedrock 交互之前，我们需要一种结构化的访问方式。包括 Bedrock 在内的每个 AWS 服务都依赖身份和访问管理 (IAM) 来定义谁或什么可以执行操作。为了启用访问，我们将配置IAM 角色、策略和访问密钥。这确保我们的 Bedrock 集成运行正常，同时考虑到安全实践。遵循最小权限原则确保只分配必要的权限。在这个阶段，IAM已正确配置，我们建立了系统的门禁层。而不是默认提供完全访问，我们将限制操作到所需的范围。现在，我们准备好进入下一个阶段：程序化交互。

API 驱动的模型交互

基于云的 AI 服务依赖于客户端-服务器模型，应用程序（客户端）向 Bedrock（服务器）发送请求，后者处理并返回响应。这种方法实现了安全的 AI 交互，允许开发者无需管理复杂的基础设施即可集成模型。而不是手动处理 HTTP 请求和响应，AWS 提供了官方工具包 (SDK)。

Boto3是适用于 Python 的官方 AWS SDK，旨在实现与 AWS 服务的无缝交互。它在 Apache 2.0 下开源，意味着可以免费。使用boto3请求 Bedrock 的典型请求涉及指定模型 ID、提供结构化输入并定义temperature（影响随机性）和max tokens（限制输出长度）。Bedrock 处理这些请求并以JSON格式返回响应，应用程序很容易解析。由于 AWS 服务设计为可扩展，boto3让动态修改提示和微调响应成为可能。

使用 CloudWatch 进行观测性

为了可靠地运行 AI 应用，观测性是必不可少的。AWS Bedrock 默认与CloudTrail集成，自动记录如InvokeModel和ListFoundationModels等关键事件。CloudTrail在后台记录活动，而CloudWatch通过实时跟踪延迟、错误和使用趋势使这些信息有用。这些元素共同为随需求变化保持工作负载的可靠性提供了基础。

实战工作坊：使用 boto3 和 CLI 进行手动推理

人工智能正在改变我们构建和与技术交互的方式，AWS Bedrock 将尖端 AI 模型带到你的指尖。这个工作坊是你掌握 AI 驱动开发的大门，从设置环境到使用boto3进行实时请求。最后，你将拥有将强大模型集成到真实应用中的技能。无论你是 AI 爱好者还是想要扩展知识的开发者，这种实践经验都将赋予你创造未来的能力。

第一步：环境设置

在我们与 AWS Bedrock 交互并开始使用 Mistral Small 之前，我们需要确保环境已正确设置。这包括访问参考资料、创建一个AWS 账户以及设置具有相应权限的IAM用户。我们将生成访问密钥、配置AWS CLI并请求访问 Mistral 模型的权限。最后，我们将在VSCode中准备开发环境，确保一切就绪，以便与 AWS 服务无缝通信。

对于工作坊设置，你需要访问托管在 GitHub 上的项目文件。访问主项目仓库 https://github.com/PacktPublishing/Learn-Mistral 。包含代码的相关文件夹是/Chapter-10。这些文件包含了我们在工作坊中编写的完整解决方案；在出现任何问题时可以作为参考材料。开始之前务必下载或克隆仓库！

创建 AWS 账户

要配合 Mistral AI 使用 AWS Bedrock，你需要一个具有正确权限的 AWS 账户。如果你已经有一个个人 AWS 账户并熟悉操作 AWS 控制台，可以跳过这一步。但是，除非明确批准，否则避免使用公司 AWS 账户以防止账单或合规冲突。

1. 访问 aws.amazon.com/ 并点击 Create an AWS Account（创建 AWS 账户）。

2. 输入你的电子邮件地址，选择账户名称并设置强密码。

3. 选择 Basic Support（基础支持计划）。

4. 提供账单详细信息（免费）。

5. 完成身份验证。

在 AWS 控制台中，可用区域可以在此处找到：https://docs.aws.amazon.com/general/latest/guide.html](https://docs.aws.amazon.com/general/latest/guide.html)。

6. 在 AWS 控制台中，选中的区域位于右上角——如有必要请调整。

一旦你的账户准备就绪，就可以进入设置IAM角色和 CLI 访问步骤。

创建新的 IAM 用户并设置权限

为了从命令行与 AWS Bedrock 交互，我们需要一个具有权限的IAM用户。该用户bedrock-cli-user将用于通过AWS CLI进行安全访问。虽然本工作坊提供了完全管理员权限，但在实践中应遵循最小权限原则。

首先，让我们创建该用户：

1. 进入 AWS 控制台中的 IAM 服务。

2. 选择 Users（用户）并点击 Create user（创建用户）。

3. 输入用户名bedrock-cli-user并点击 Next。

4. 对于权限，选择 Attach policies directly（直接附加策略）。

5. 搜索并选择AmazonBedrockFullAccess。

6. 点击 Next 然后点击 Create user。

用户创建后，我们需要生成访问密钥：

1. 点击新创建的bedrock-cli-user用户。

2. 转到 Security credentials（安全凭证）选项卡。

3. 点击 Create access key（创建访问密钥）。

4. 选择 Command CLI 作为用例并按照提示操作。

5. 创建后，将显示你的 Access Key ID 和 Secret Access Key。妥善保存这些信息！

which aws

以下是预期输出：

/usr/local/bin/aws

1. 使用你的凭据配置 AWS CLI。在终端中运行以下命令：

aws configure

2. 在提示时输入凭据，如图 10.9 所示——使用你的凭据。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_10_09.png

图 10.9：设置访问密钥的终端屏幕截图

此处是重复文本（密钥和密钥已用星号掩码）：

AWS Access Key ID [None]: AK**********44E
AWS Secret Access Key [None]: xdG*****************************3k
Default region name [None]: us-east-1
Default output format [None]: json

1. 现在运行以下命令检查 AWS CLI 是否配置正确：

aws s3 ls

如果你有任何 S3 桶，你将看到类似下方的输出：

2024-09-07 17:04:24 some_s3_bucket

1. 要测试 AWS Bedrock 访问，运行以下命令：

aws bedrock list-foundation-models

以下是预期的 JSON 输出：

{
  "modelSummaries": [
    {
      "modelArn": "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-tg1-large",
      "modelId": "amazon.titan-tg1-large",
      "modelName": "Titan Text Large",
      "providerName": "Amazon",
      "inputModalities": ["TEXT"],
      "outputModalities": ["TEXT"]
    },
    ...
  ]
}

配置 AWS CLI V2 后，你能够向 AWS 服务（包括 Bedrock）发送身份验证后的请求。接下来，我们将请求 Bedrock 上 Mistral 模型的访问权限，确保我们有权限使用 Mistral Small。一旦获得授权，我们就可以开始对该模型进行 API 调用。

请求 Bedrock 上的 Mistral 模型访问权限

在我们开始使用 Mistral Small 之前，我们需要通过 AWS Bedrock 请求访问权限。这一步骤确保了我们的 IAM 用户拥有与 Bedrock 上的 Mistral 模型交互的必要权限。一旦获得授权，我们将能够发送 API 请求并将 Mistral AI 集成到我们的应用程序中。请按照以下步骤获取访问权限：

1. 返回 AWS 控制台。

2. 在 AWS 搜索栏中输入Bedrock并在结果中选择Amazon Bedrock。

查看图 10.10以了解如何导航到 Amazon Bedrock 服务的描述。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_10_10.png

图 10.10：导航到 Bedrock 服务

1. 在左侧面板中，点击Providers。图 10.11 展示了左侧菜单的布局。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_10_11.png

图 10.11：导航到 Providers

1. 找到 Bedrock 上的 Mistral 模型，并从列表中选择Mistral AI提供商。图 10.12 展示了Providers列表的相关部分。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_10_12.png

图 10.12：选择 Mistral AI 提供者

1. 找到Mistral Small，点击 Mistral 模型旁的三个点 (⋮) 菜单，并选择Modify access。图 10.13 可视化了模型的上下文菜单。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_10_13.png

图 10.13：请求相关模型的修改访问权限

1. 勾选Mistral Small复选框以请求访问。查看图 10.14以获取要选择的候选模型列表的描述。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_10_14.png

图 10.14：在列表中标记 Mistral Small

1. 等待片刻让 AWS 处理请求。然后确认访问已授予。该模型现在应该可以可以使用了。图 10.15提供了所需访问授予行的插图。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_10_15.png

图 10.15：访问授予

现在我们已经成功请求并确认了对 Mistral Small 的访问权限，我们准备好开始使用它了。下一步是设置我们的 VSCode 项目。

准备 VSCode 项目

现在我们已经获得了 Mistral Small 的访问权限，是时候设置开发环境了。在这一步骤中，我们将准备一个 VSCode 项目，创建一个 Python 虚拟环境并安装必要的依赖项。此设置将为处理 AWS Bedrock 提供一个整洁的工作空间。请按照以下步骤准备环境：

1. 打开 VSCode 并创建一个新文件夹。

2. 打开终端。

3. 运行以下命令创建虚拟环境：

python3 -m venv .venv

4. 激活虚拟环境：

source .venv/bin/activate

准备 AWS Bedrock 环境

在创建 Python 项目之前，我们需要设置好项目依赖和开发环境。

创建项目依赖文件

1. 在项目中创建requirements.txt文件。

2. 在requirements.txt中添加以下依赖：

boto3>=1.36

3. 运行以下命令安装依赖：

pip install -r requirements.txt

一旦 VSCode 项目设置完成，环境就完全准备好与 AWS Bedrock 交互。现在，我们可以开始使用boto3了！

Step 2：使用 boto3 连接 AWS Bedrock

在这一步骤中，我们将首次从 Python 连接到 AWS Bedrock。这是一个里程碑——确认了我们的设置是正确的并且我们可以成功获取列表。

1. 打开你的 VSCode 项目并创建一个新的 Python 文件：ws10_step01_list_models.py。

2. 添加以下代码：

import boto3

### 在指定区域创建 Bedrock 客户端
bedrock = boto3.client(service_name='bedrock', region_name='us-east-1')

### 请求基础模型列表
response = bedrock.list_foundation_models()
models = response['modelSummaries']

# 打印提供者、模型名称和模型 ID
for model in models:
    print(model['providerName'] + " - " + model['modelName'] + " - " + model['modelId'])

3. 运行脚本：

python ws10_step01_list_models.py

以下是预期输出：

...
Mistral AI - Mistral Large (24.02) - mistral.mistral-large-2402-v1:0
Mistral AI - Mistral Small (24.02) - mistral.mistral-small-2402-v1:0
Mistral AI - Pixtral Large (25.02) - mistral.pixtral-large-2502-v1:0

如果你遇到如botocore.exceptions.NoCredentialsError: Unable to locate credentials的错误，请返回 AWS CLI 配置并确保命令行验证步骤通过。

脚本列出了 AWS Bedrock 上可用的基础模型，包括它们的提供者、名称和模型 ID。此输出确认了我们的 Python 环境配置正确并能够与 AWS Bedrock 通信。

在可用模型中，我们将使用以下模型：

Mistral AI - Mistral Small (24.02) - mistral.mistral-small-2402-v1:0

此模型 ID（mistral.mistral-small-2402-v1:0）将在下一节用于与 Mistral Small 交互，发送提示（prompts）并处理响应。

现在我们已经成功连接到 AWS Bedrock 并获取了模型列表，准备好向 Mistral 发送第一个请求了。下一步将介绍如何与模型通信并获取 AI 生成的响应。

步骤 3：向 Bedrock 发送提示并获取流式响应

现在一切都准备就绪，是时候通过 AWS Bedrock 向 Mistral Small 发送第一个 API 请求了。在此步骤中，我们将初始化 Bedrock 运行时客户端，构建请求负载（payload），处理潜在错误并提取模型的响应。这将允许我们与 AI 交互、处理文本并验证环境配置是否正确。

请仔细遵循以下步骤，以确保 Python 与 AWS Bedrock 之间的顺畅通信：

1. 在运行时与 Bedrock 交互，我们使用bedrock-runtime而不是bedrock。bedrock-runtime客户端专门用于调用模型，而bedrock则用于管理模型。

client = boto3.client(service_name='bedrock-runtime',
     region_name='us-east-1')

Bedrock 与 bedrock-runtime

AWS 提供了两个用于处理 Bedrock 的不同客户端，理解它们的区别非常重要。

bedrock客户端用于管理任务。它允许你列出可用的基础模型、管理访问权限并配置 Bedrock 相关的设置。简而言之，它可以帮助你了解有哪些可用模型并控制谁可以使用它们。

bedrock-runtime客户端专门用于推理。在这里你发送输入负载、执行模型调用并接收 AI 生成的响应。每当你想要实际对模型运行提示时，都将使用此运行时客户端。

由于我们正在向 Mistral Small 请求响应，因此我们必须在此操作中使用bedrock-runtime。

2. 随后，我们需要指定正确的模型 ID，以确保我们的请求被正确处理：

model_id = ' mistral.mistral-small-2402-v1:0'

如果使用了错误的模型 ID，AWS 将返回错误消息：

Exception Type: ValidationException
Error Message: An error occurred (ValidationException) when calling the InvokeModel operation: The provided model identifier is invalid.

3. 下一步是构建负载。负载定义了我们希望模型生成的内容。它包含了提示、响应长度和随机性控制。

payload = {
    "prompt": "Explain the concept of reinforcement learning in simple terms.",
    "temperature": 0.7,
    "max_tokens": 300
}

正如我们在第 3 章介绍过的，"temperature"控制响应的创造性，而"max_tokens"限制响应长度。确保这些值没有封装在parameters对象内部，并且"max_tokens"拼写正确。

4. 为了捕捉潜在问题，我们将 API 调用封装在try-except块中。该块有助于排查诸如无效输入、API 失败或权限问题等问题。接下来发送负载到模型。

try:
    # client invocation happens here
except Exception as e:
    # Print detailed debug information
    print("Error occurred while invoking the model:")
    print(f"Exception Type: {type(e).__name__}")
    print(f"Error Message: {e}")
    if hasattr(e, 'response'):
        print("AWS Error Response:")
        print(json.dumps(e.response, indent=2))

5. 现在我们通过将负载传递给 Bedrock 运行时客户端来调用模型。这会将请求发送到 AWS Bedrock 并等待模型的响应。接下来，我们将从负载中检索响应体。

response = client.invoke_model(
    modelId=model_id,
    body=json.dumps(payload),
    contentType="application/json",
    accept="application/json"
)

6. 然后我们将流式响应转换为字符串。AWS Bedrock 以流格式返回响应，这意味着数据是分块提供的而不是一次性提供的。在此步骤中，response["body"].read()一次性从流中读取所有可用字节。由于我们的负载很小，这将瞬时完成。

对于较大的响应，数据可能会分多次接收，因此我们需要通过按到达顺序读取响应块来增量地处理流。

.decode("utf-8")将字节数据转换为可读的字符串，而json.loads(response_body)将其解析为 Python 字典。

response_body = response["body"].read().decode("utf-8")
result = json.loads(response_body)

接下来检索模型的响应文本。

7. 为了检索 AI 生成的文本，我们从 JSON 响应中提取"text"字段：

output_text = result.get("outputs", [{}])[0].get(
        "text",
        "No response received.")

如果没有收到有效响应，脚本将默认返回"No response received."而不是抛出错误。这段代码结束了详细的代码说明，在下一节中，我们将获得完整的代码。

8. 以下是发送提示并检索模型响应的完整脚本。该脚本完全自动化了向 Mistral 发送请求并处理错误的过程。我们准备好运行部分工作并查看结果了。

import boto3
import json

client = boto3.client(service_name='bedrock-runtime',
    region_name='us-east-1')

model_id = ' mistral.mistral-small-2402-v1:0'

### Payload for Bedrock
payload = {
    "prompt": "Explain the concept of reinforcement learning in simple terms.",
    "temperature": 0.7,
    "max_tokens": 300
}

try:
    # Call the Bedrock model
    response = client.invoke_model(
        modelId=model_id,
        body=json.dumps(payload),
        contentType="application/json",
        accept="application/json"
    )

    # Read the response body (convert StreamingBody to string)
    response_body = response["body"].read().decode("utf-8")
    result = json.loads(response_body)

    # Extract the model's output
    output_text = result.get("outputs", [{}])[0].get(
        "text",
        "No response received.")

    print(">>>", payload["prompt"])
    print("<<<", output_text)

except Exception as e:
    # Print detailed debug information
    print("Error occurred while invoking the model:")
    print(f"Exception Type: {type(e).__name__}")
    print(f"Error Message: {e}")
    if hasattr(e, 'response'):
        print("AWS Error Response:")
        print(json.dumps(e.response, indent=2))

9. 要测试脚本，请在终端中运行命令：

python3 ./src/ws10_step02_call_model.py

如果一切设置正确，响应将包含来自 Mistral Small AI 生成文本。

我们已成功向 AWS Bedrock 发送了第一个 API 请求，并从 Mistral Small 获取了响应。这证明我们的 AWS 环境运行正常，我们现在可以与模型进行通信了。

第 4 步：检查 Bedrock 的 CloudWatch 日志

要查看的 AWS Bedrock 活动，你可以直接在 CloudTrail 事件历史中访问日志。这有助于你验证请求是否成功，并在无需额外设置的情况下排除故障。请按照以下步骤查看 Bedrock 日志：

1. 进入 AWS 控制台中的CloudTrail。

2. 打开Event history标签。

3. 在Lookup attributes中，通过Event source过滤并输入：bedrock.amazonaws.com

请参考图 10.16查看 CloudTrail 控制台中显示的 Bedrock 日志的视觉示例。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_10_16.png

图 10.16：Bedrock 事件

对于长期保留或高级查询，你可以配置 CloudTrail 将这些日志发布到 S3 存储桶，并在那里可以使用Athena或AWS Glue等服务进行存档或分析。

最后一步完成了本次工作坊，并演示了使用 Mistral Small 运行 AWS Bedrock 的实际操作。现在，让我们在继续之前回顾一下本章的核心要点。

总结

我们成功利用 AWS Bedrock 构建了一个功能完的 AI 开发环境，实现了与 Mistral Small 的无缝交互。从设置到执行第一个 API 请求，我们将一个抽象概念转变为一个具有安全 IAM 身份验证和使用boto3构建的功能 Python 工作流的 AI 驱动系统。

真正的成就不仅仅是连接到 Bedrock——更是你对 AI 集成所获得的信心和控制力。你构建了 API 调用结构，处理了错误，探索了CloudWatch，并获得了云基础设施的实战经验。这一基础使你能够开始将 AI 集成到真实世界的应用程序中。继续实验，继续完善，最重要的是，继续创造。

在下一章中，我们将探索如何使用Vertex AI和Model Garden在 Google Cloud 上运行大语言模型。你将学习如何在完全全托管的无服务器环境中与这些模型协作，我们将为对 GCP 上更深层部署策略感兴趣的人引入可选挑战。

课外拓展

• 扩展boto3推理之外：通过将boto3连接到其他 AWS 服务超越简单的推理调用。将提示词和响应存储在S3中，触发Lambda函数实现自动化，或在DynamoDB中记录输出以构建轻量级检索分析工作流。

• 实验 Bedrock 参数：调整temperature、max tokens和提示词设计，观察输出的变化。这种探索强调了微小的参数调整如何影响创造力、精确或详细程度，让你对模型行为和响应控制有深入的见解。

• 构建一个微项目：将你的技能应用于小型项目，例如创建机器人、自动化S3文档的内容摘要或运行批量推理。这些练习将工作坊的知识转化为实用的现实问题解决经验。

• 使用 n8n 和 Bedrock 自动化工作流：使用n8n的工作流自动化连接 Bedrock 与日常工具。创建流水线，从电子邮件或聊天应用将提示词发送到 Bedrock，然后自动将响应传回，让 AI 成为日常工作流的无缝部分。

• 立即解锁本书专属福利：扫描此二维码或访问packtpub.com/unlock，然后通过书名搜索此书https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/Unlock-01.pnghttps://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/Unlock2.png

  • 注意：在开始之前请准备好你的购买发票。

11

通过 Google Cloud Vertex AI 挥洒 Mistral 的力量

如果你想一辈子幸福，就去种花园吧。

—中国谚语

在这一章中，我们将整合所有内容——云基础设施、模型 API 和真实世界的脚本——向你展示如何使用 Google Cloud 的Vertex AI平台运行和集成大语言模型（LLMs）。我们将从理论开始，涵盖构成Vertex AI生态系统的关键服务和组件。你将学习Model Garden是如何工作的、同步和流式推理在实践中意味着什么，以及身份验证、访问控制和配置如何融入工作流。Vertex AI中的Model Garden提供了精选的预训练机器学习模型和工具，帮助你简化 AI 解决方案的开发、测试和部署——无需从头训练模型。

一旦概念清晰，我们将开始一个实战工作坊，你将从零开始构建自己的设置。你将从Google Colab Enterprise开始快速实验，然后过渡到带有模块化Python环境的VS Code。你将配置项目，使用gcloud进行身份验证，并对托管的 Mistral 模型进行同步和流式调用。你还将应用脚本结构和环境管理的最佳实践。

到本章结束时，你不仅将理解Vertex AI上推理是如何工作的——你还将拥有一个功能且可复用的代码库，镜像了生产系统中使用的架构。这就是你的LLM集成变得真实的地方。

简之，本章将涵盖以下主题：

• 理解Vertex AI

• 实战工作坊

技术要求

这是一个高级别的工作坊，适用于熟悉Python脚本编写和在云环境中工作的开发者和工程师。虽然我们会提供指导，但请确保你拥有：

• Google Cloud 账户：你必须有一个有效的账户。

• Google Cloud CLI：必需（gcloud）。

• Python 3.8+：环境必需。

• VS Code：任何支持 Python 的编辑器。

• Git：工作流必需。

resp = client.chat.complete(
    model=MODEL,
    messages=[{"role": "user", "content": "Summarize today's news."}]
)
print(resp.choices[0].message.content)

另一方面，流式推理会在生成 token 的同时返回它们。这对于聊天机器人或实时应用非常有用，因为你可以在完整答案准备好之前就开始显示结果。接下来的代码段演示了流式推理，模型会增量返回 token，以便你可以实时显示部分结果：

stream = client.chat.stream(
    model=MODEL,
    messages=[{
        "role": "user",
        "content": "Tell me a story, one line at a time."}])
for chunk in stream:
    print(chunk.data.choices[0].delta.content, end="")

这两种选项在同一个 API 中都受支持，因此在它们之间切换只需更改方法调用。在工作坊期间，你将使用这两种方法，以感受它们在真实场景中的行为。

模型请求的结构

每个模型调用都围绕一个简单但灵活的结构构建，包含了模型名称、消息列表以及可选的生成参数。在 Vertex AI 的聊天界面中，消息是基于角色的——通常来自用户或助手——模型将它们处理为一段对话。

以下是你在本章工作坊中将使用的请求格式：

resp = client.chat.complete(
    model=f"{MODEL}",
    messages=[
        {
            "role": "user",
            "content": "Who is the best French painter? in one short sentence",
        }
    ],
)

在这个示例中，我们拥有以下内容：

• model指定要使用哪个模型（例如mistral-small-2503）

• messages包含实际提示提示，包括发送者角色（user）和消息内容

• 可选参数（如max_tokens或temperature）可以用来控制响应的长度和创造性

response object（resp）包含了生成的内容和元数据（如 token 使用情况），这有助于跟踪输出大小和潜在成本。在本章整个工作坊中，你将在每次调用中看到这种结构。

GCP 中的身份验证与访问

身份验证是使用 Vertex AI 的核心部分，确保只有经过授权的用户和服务才能与你的模型和资源进行交互。Google Cloud 底层使用 OAuth 2.0，对于开发者来说，这通常意味着生成并使用访问令牌。这些令牌受限于你的 Google Cloud 项目，权限通过Identity and Access Management（IAM）roles强制执行。

对于交互式使用，最简单的方法是使用gcloud CLI。一旦你使用gcloud auth login登录，就可以如下所示获取访问令牌：

gcloud auth print-access-token

gcloud是 Google Cloud 的命令行工具。我们将在工作坊期间介绍安装和设置步骤。

该令牌随后会被包含在 HTTP 请求的Authorization头中，或者在 Python 脚本中使用。在工作坊中，我们通过以下代码程序化地检索了令牌：

import subprocess
def get_gcloud_access_token():
    process = subprocess.Popen(
        "gcloud auth print-access-token",
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        shell=True
    )
    access_token_bytes, _ = process.communicate()
    return access_token_bytes.decode("utf-8").strip()

IAM角色决定了该令牌可以做什么；它是否被允许调用模型、从存储中读取或部署新的端点。在生产环境中，安全地处理令牌并知道何时刷新它们至关重要，特别是对于自动化和长时间运行的服务。

选择正确的开发流

Google Colab Enterprise 为在 Vertex AI 中工作提供了一个快速、无需配置的环境。由于它已经连接到你的 Google Cloud 项目，身份验证和 API 访问在后台处理，使其非常适合早期探索或原型设计。

尽管如此，对于更多的控制和长期开发，VS Code 等本地工具是必不可少的。它们让你对代码库拥有完全可见性、版本控制访问以及将工作流模块化的能力。你可以在虚拟环境中管理依赖，进行精确调试，并构建适用于自动化或生产环境的代码。

本工作坊支持这两种流。你将从方便的 Colab 开始，然后到本地 Python 脚本以构建可维护、可重用的真实代码。了解何时使用每种环境有助于你在项目增长时平衡速度与扩展性。

AI 集成的开发最佳实践

构建语言模型应用不仅是为了获取响应，更是为了创建随项目扩展的可维护、可重用的代码。一个好的起点是将你的脚本模块化。将配置、身份验证和推理逻辑放在不同的 Python 文件中。这可以保持代码整洁、易于测试且便于修改。

例如，模型和项目设置应该位于配置模块中：

# config.py
MODEL = "mistral-small-2503"
PROJECT_ID = "learnmistral"
LOCATION = "us-central1"

身份验证逻辑应该隔离在辅助函数中：

# auth.py
def get_access_token():
    # subprocess 调用 gcloud 获取令牌

在你的主推理脚本中，你可以这样导入必要的常量和身份验证方法：

from config import MODEL, PROJECT_ID, LOCATION
from auth import get_access_token

我们强烈建议在工作坊中使用 Pythonvirtual environment（venv）。这可以使你的依赖局限于项目，并避免污染全局 Python 环境：

python3 -m venv ./gcpenv
source ./gcpenv/bin/activate

我们将在研讨期间详细介绍venv。

通过遵循这些实践（模块化代码、项目范围环境和最少硬编码），你将构建出更易于调试、共享和随时间扩展的 AI 集成。

现在你已经掌握了理论知识，是时候让它们付诸实践了。在本次实战研讨会上，你将启动一个真实的Vertex AI工作流——从云端设置到Colab尝试，再到Python驱动的推理。每一步都为构建模块化、可维护的基础，让你能够在类生产环境中充满信心地处理托管的Mistral模型。

实战研讨会：使用 Vertex AI 快速启动 Mistral 应用

欢迎参加使用Vertex AI部署和交互Mistral AI模型的研讨会。将本次研讨会视为一次引导之旅，专为想要将强大的语言模型集成到应用程序中的开发者量身定制。我们将首先在Google Cloud中设置环境，确保所有配置均无误。接下来，我们将启用关键 API，允许应用程序与Vertex AI服务之间进行无缝通信。

一旦基础工作完成，你将直接从Vertex AI Model Garden部署Mistral模型，这是一个精选的前沿 AI 模型存储库。在你的模型上线后，研讨会将引导你通过在Google Colab Enterprise中进行实际练习，提供身份验证、区域选择和项目链接的实操经验。你将使用简单而稳健的方法运行推理请求并处理响应，直接与Mistral模型进行交互。

在后续阶段，研讨会将探索高级功能，例如流式请求和利用Python的Vertex SDK。我们将创建并激活venv，安装必要的依赖项，并使用 Google 的云命令行界面（CLI）对我们的请求进行身份验证。

此外，我们将学习如何通过程序化构建推理请求，以增强我们对将 AI 模型集成到现实软件应用程序中的理解。

在这段旅程结束时，你将清晰掌握部署Mistral AI模型、通过交互式笔记本和后端Python脚本与模型进行交互，以及在Google Cloud中管理模型生命周期的方法。关键成果包括一个运行的Vertex AI环境、API 集成的实用知识、推理请求的实战编码经验，以及对 AI 模型如何在你的开发工作流中运行的深入理解。

需要什么

在开始第 1 步之前，请确保你已准备好以下前提条件。你需要一个Google Cloud账户；如果你还没有，请在console.cloud.google.com创建。

请注意，设置结算账户需要一张有效的信用卡，这对于我们在练习期间启用某些云服务是必要的。

说到代码，你需要访问托管在GitHub上的项目文件。访问本章节的主项目仓库：github.com/PacktPublishing/Learn-Mistral-7B/tree/main/Chapter-11。

这些文件包含了我们将在研讨会上编写的完整解决方案。在出现任何问题时，它们可以作为参考材料。请确保在开始之前下载或克隆仓库。将Chapter-11文件夹添加到你现有的VS Code项目中。

第 1 步：设置与准备

在第 1 步中，我们将从准备Google Cloud环境开始，建立有效使用Vertex AI的基础设置。首先，让我们在Google Cloud账户创建一个专用项目，为我们的练习提供集中的工作空间。接下来，我们将激活关键 API，包括Vertex AI API、Cloud Resource Manager API和IAM API，这些都是与云服务无缝集成的关键组件。我们还将项目连接到结算账户，以便完全访问所有所需的Google Cloud资源。

完成这些初始设置任务对于确保你的环境完全准备好以部署和交互Mistral模型至关重要。

创建 Google Cloud 项目

在部署Mistral模型之前，你需要一个专用的Google Cloud项目。按照以下指令通过Google Cloud控制台创建一个名为LearnMistral的项目：

1. 转到Google Cloud控制台。

2. 点击项目选择器字段（顶部栏，搜索栏左侧）。参见图 11.1。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_01.png

图 11.1: 项目选择器

1. 点击 NEW PROJECT（新建项目）。

2. 将你的项目命名为LearnMistral。参见图 11.2。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_02.png

图 11.2: 新项目名称

1. 如果已配置了结算账户，请选择；如果没有，我们稍后会关联。

2. 点击 Create（创建）。

3. 创建完成后，点击 Select Project（选择项目）打开它。

在创建Google Cloud项目后，接下来我们可以启用所需的 API。

启用所需的 API

接下来，我们将配置Google Cloud项目与Vertex AI有效交互并管理资源所需的 API。激活这些 API 确保了我们的Google Cloud服务之间的无缝通信和集成，为部署和使用Mistral形成关键基础。

采取以下步骤：

1. 在左侧菜单中，转到 APIs & Services | Library。

2. 搜索并启用这些 API：

   • Vertex AI API

   • Cloud Resource Manager API

   • IAM API

你可以通过点击console.cloud.google.com/apis/dashboard?project=mistral仪表板上的 APIs 卡片定位定位。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_03.png

图 11.3: APIs 卡片

或者，可以通过访问console.cloud.google.com/welcome?project=mistral欢迎页并选择 APIs & Services 来实现。请查看图 11.4。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_04.png

图 11.4: 欢迎页——快速访问

启用 API 后，你的项目设置几乎完成。接下来我们将链接结算账户，以确保所有必要的Google Cloud服务均可访问。

链接结算账户

此步骤的目的是将你的Google Cloud项目连接到结算账户。这确保你的云环境充分访问所有必要的服务，允许在整个研讨会期间顺畅部署和管理。直接访问console.cloud.google.com/billing结算页，如图 11.5所示。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_05.png

图 11.5: 我的结算账户

如果你还没有结算账户，点击 Create account 进行设置。输入新的结算账户名称并选择你的国家，如图 11.6所示。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_06.png

图 11.6: 创建结算账户

接下来，按 Continue（继续）提供你的支付方式详情，如图 11.7所示。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_07.png

图 11.7: 结算摘要

一旦创建了结算账户并确认了支付方式，你就可以将此结算账户连接到你的特定项目。在下一步，我们将介绍如何将新创建的结算账户链接到LearnMistral项目，完成使用Vertex AI的结算配置。

将项目链接到结算账户

现在结算账户已激活，下一步是将其链接到你的项目。此连接允许你的Google Cloud项目访问所有付费服务，包括Vertex AI和Mistral模型部署所需的服务。通过以下 URL 导航到项目的欢迎页：console.cloud.google.com/welcome?inv=1&project=mistral。请参考图 11.8定位 Billing（结算）部分。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_08.png

图 11.8: 欢迎页——快速访问

点击 Billing 或直接访问链接结算页console.cloud.google.com/billing/linkedaccount?project=mistral。查看图 11.9的链接账户视图：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_09.png

图 11.9: 项目未链接到结算账户

到达后，点击 Link a billing account（链接结算账户），你将进入下一个屏幕，如图 11.10所示：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_10.png

图 11.10: 为项目选择结算账户

从列表中选择你的结算账户并点击 Set account（设置账户）确认链接。这完成了你项目的结算配置。现在结算已正确链接，是时候继续并启用通过Vertex AI运行Mistral模型所需的 API 和服务了。

启用 API 和服务

链接结算账户后，你的项目已准备好激活驱动与Vertex AI交互的关键 API。这些 API 将允许你的应用程序运行模型、管理权限并访问云资源——这些都是Mistral工作流的核心组件。

让我们逐个启用它们：

1. 你可以直接通过console.cloud.google.com/apis/dashboard?project=mistral打开 APIs & Services 控制台。这会将你带到主面板，在其中可以管理 API 活动。或者，如果你在项目的欢迎页（console.cloud.google.com/welcome?inv=1&project=mistral），只需从 Quick access 区域点击 APIs & Services。接下来，点击 Enable APIs and services（启用 API 和服务）按钮。这将打开 API 库，你可以在其中搜索并激活服务。请参考图 11.11。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_11.png

图 11.11: APIs & Services——启用服务

在搜索栏中输入Vertex AI API，然后打开其详情页。点击 ENABLE 为你的项目激活。此 API 允许你的环境访问并运行Mistral模型。请参考图 11.12。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_12.png

图 11.12: Vertex AI API

如果你还没有完成结算设置，可能会遇到提示启用结算的消息。查看图 11.13。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_13.png

图 11.13: 需要结算

2. 现在在 API 库中搜索Cloud Resource Manager API。Cloud Resource Manager API是Google Cloud中的一项基础服务，允许你程序化地管理云资源的结构和访问控制。它允许你将项目组织到文件夹和组织中，应用IAM策略并维护治理。在 GCP 内部安全高效地工作至关重要。一旦页面打开，点击 ENABLE。参考图 11.14。Cloud Resource Manager API有助于组织你的资源。与Identity and Access Management (IAM)配合，它控制谁可以做什么。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_14.png

图 11.14: Cloud Resource Manager API

3. 最后，搜索IAM API。此服务对于管理角色、凭据以及对Vertex AI资源的访问至关重要。一旦找到，在其页面上也点击 ENABLE。

启用这些 API 后，你的项目已准备好安全高效地与Vertex AI交互。下一步进入Model Garden。

从 Model Garden 部署 Mistral

我们现在准备好将Mistral模型部署到Google Cloud环境中。下一步将可以使用Vertex AI进行测试和推理。我们将引导你在Model Garden中定位模型并为你的项目启用它。让我们开始：

1. 首先通过Google Cloud控制台中的console.cloud.google.com/vertex-ai?project=mistral打开Vertex AI界面。从左侧菜单导航到 Vertex AI | Model Garden，或使用顶部的搜索栏搜索Garden或Model Garden。请参考图 11.15的导航布局。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_1115.png

图 11.15: 搜索栏中的“Garden”

2. 在Model Garden搜索栏内输入Mistral以定位可用模型。特别寻找Mistral Small 3.1。该模型针对轻量推理用例进行了优化，是实验的良好起点。查看图 11.16的搜索结果视图。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_16.png

图 11.16: 搜索模型

点击模型卡片查看详情。模型卡片界面的布局如图 11.17中所示。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_17.png

图 11.17: 模型卡片

3. 在模型详情页中，点击 Enable 按钮为你的项目激活模型。你将被提示查看并同意购买订单。查看图 11.18的购买确认屏幕。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_18.png

图 11.18: 购买摘要

接受条款后，你将看到模型服务已成功激活的确认。参考图 11.19的成功消息布局。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_19.png

图 11.19: 成功屏幕

请注意使用此模型的成本是按使用计算的，并根据处理的标记数量计算。本次研讨会的总成本预计低于 5 美元。要获得最准确和更新的价格，请访问官方定价页面。

环境现在已就绪。

第 2 步：玩转 Mistral

（提供的文本在此处结束，以下为代码示例部分）

if "google.colab" in sys.modules:
    from google.colab import auth

如果满足此条件，将导入 Colab 的身份验证程序：

auth.authenticate_user()

在 Google Colab Enterprise 中，身份验证通常作为工作区上下文的一部分自动处理。运行此代码可能会触发警告，但不会中断任何操作。警告信息如下所示：

WARNING: google.colab.auth.authenticate_user() is not supported in Colab Enterprise.

你可以安全地忽略此消息。它仅意味着笔记本已经通过你的组织会话完成了身份验证，不需要手动登录。

运行身份验证代码块后，你的会话现在已获得完全授权访问后台的 Vertex AI 服务。即使出现警告，你的笔记本也已准备就绪并连接。此时不再需要额外的人工验证。

选择 Mistral 模型

在发送第一个提示词（prompt）之前，下一步是选择你想要使用的特定 Mistral 模型和版本。选择正确的模型可以确保你的请求被正确路由，并且你的实验与工作坊的流程保持一致。

按照以下步骤操作：

1. 滚动到笔记本的该部分，其中可用的 Mistral 模型以下拉菜单或变量赋值块的形式列出。你在此决定在会话中使用哪个模型。请参考图 11.24查看选择界面的概述。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_24.png

图 11.24：模型选择代码块和 UI

这段代码不包含任何用于推理的功能逻辑——它的主要作用是帮助初始化几个关键变量。你可以用如下简单的手动赋值来替换整个代码块：

MODEL = "mistral-small-2503"
available_regions = ["europe-west4", "us-central1"]
available_versions = ["latest"]

然而，使用下拉菜单可以确保与你环境中当前支持的内容保持一致。

1. 在可用选项中，选择 mistral-small-2503 或笔记本中列出的最新等效模型。这是一个轻量、高性能的模型，适用于快速推理和实验。根据版本的更新，数字后缀可能会有所不同，但通常建议在工作坊中使用小型变体（small variant）。

2. 一旦选中，该模型将传递到笔记本后续逻辑中用于区域匹配和推理。你不需要手动修改任何代码——只需从提供的界面中选择即可设置激活模型。

你的环境现在已链接到特定的 Mistral 模型。此选择决定了在会话期间哪个版本的模型将响应你的提示词。这是一个关键步骤，因为根据你的用例，不同的模型在输出风格、速度或成本上存在差异。

运行区域选择组件

为了完成配置，你现在需要选择部署区域。下一步将引入一个组件，帮助你将模型匹配到可用的区域和版本，确保推理请求的正确路由。

按照以下步骤操作：

1. 继续滚动 Colab 笔记本，直到进入帮助选择部署区域和模型版本的部分。该部分使用交互式组件来引导你的选择。请参考图 11.25查看包含下拉 UI 的代码单元：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_25.png

图 11.25：区域选择块

虽然这段代码提供了一个用户友好界面，但它并没有执行工作坊功能必需的任何逻辑。如果需要，你可以跳过组件并使用以下内容直接赋值：

LOCATION = "us-central1"
MODEL_VERSION = "latest"

运行单元格将显示两个下拉菜单：一个用于选择模型托管的区域，另一个用于指定模型版本（如果适用）。这些选择确保了模型变体与可用基础设施之间的兼容性。组件输出显示在图 11.26中。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_26.png

图 11.26：选择位置和版本的 UI 组件

下拉菜单中列出的任何区域或模型版本都应该可用。建议的区域通常是地理上离你最近的区域，以减少延迟。建议的版本是 Model Garden 中最新的版本，为了兼容性和性能，推荐使用。

1. 从下拉菜单中选择一个支持的区域——通常为 us-central1 或 europe-west4。对于大多数用户来说，选择 latest 作为版本足够了，除非为了兼容性或测试需要特定的发布版本。

此时，你已经选择了模型运行的位置以及要使用的版本。这些变量现在已准备好传递到你的 API 调用中，并将引导未来所有推理请求的路由。

运行项目选择组件

在下一步中，你将通过提供 ID 将笔记本链接到特定项目。这会将你的会话绑定到正确的计单和模型上下文，从而解锁对你的云托管 Mistral 部署的完全访问。

按照以下步骤操作：

1. 继续向下滚动 Colab 笔记本，直到进入指定 Google Cloud 项目 ID 的部分。这对于将所有 API 调用和计单路由到正确的云环境中是必须的。界面允许你通过表单输入进入项目 ID。请参考图 11.27查看包含下拉 UI 的代码单元：

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_27.png

图 11.27：区域选择块

这段代码提供了一个用户友好界面，但它并没有执行工作坊功能必需的任何逻辑。如果需要，你可以跳过组件并使用以下内容直接赋值：

PROJECT_ID = "learnmistral"
ENDPOINT = f"https://{LOCATION}-aiplatform.googleapis.com"
SELECTED_MODEL_VERSION=""

1. 默认值为 learnmistral。如果你使用的是不同的项目，请确保在输入表单中相应更新。此步骤确保你的 API 请求经过授权并限制在正确的环境中。

2. 单元格还包含基础检查：如果项目 ID 为空或仍设置为占位符值 [your-project-id]，将抛出 ValueError。这防止了在继续之前出现意外的配置错误。

你的笔记本现在已连接到正确的 Google Cloud 项目。这确保了对 Vertex AI 的所有后续调用都被正确路由、授权和计费。你的环境现在已完全定义并准备与 Mistral 模型进行交互。

由于配置已经完成，我们可以转向执行代码。在下一步中，你将导入所需的库，以便能够发送 HTTP 请求、处理身份验证令牌并管理模型响应。

导入所需的库

现在你的配置已完成，是时候导入支持与模型交互的关键 Python 库了。这些库处理 HTTP 通信、令牌检索和 JSON 处理——你通过代码与 Vertex AI 交互所需的所有工具：

import json
import subprocess
import requests

这些导入虽然精简但强大。json 用于结构化发送到模型的负载。subprocess 帮助获取你的访问令牌。requests 是用于将这些负载发送到 Vertex AI 端点的客户端。

这段简短的代码块为你将执行的请求奠定了基础。没有这些导入，后续的推理代码将无法运行。所有必要的库现在已就绪。

运行推理

运行推理将从准备一个简单的 JSON 负载开始——一个模型可以理解的结构化问题。然后，你将使用 cURL 命令发送该负载，以查看 Vertex AI 如何实时响应。一旦运行，你将使用 Python 重新运行请求，以美化打印响应并使输出变得更容易。最后，我们将探索更高级的功能，例如流式传输（streaming），让你体验 Mistral 如何动态处理对话流并在生成时返回结果。

准备负载

在向模型发送请求之前，你需要定义想让它做什么。这是通过创建一个结构化字典实现的，该字典包含了模型名称、用户消息、输出长度以及流式传输偏好。一旦定义，字典将被序列化为 JSON 格式，这是 Vertex AI API 请求预期的结构：

PAYLOAD = {
    "model": MODEL,
    "messages": [{
        "role": "user", "content": "who is the best French painter?"
    }],
    "max_tokens": 100,
    "stream": False,
}

request = json.dumps(PAYLOAD)

"model"键指向你部署的 Mistral 实例。"messages"字段是一个数组，其中每个条目模拟聊天消息；在这里我们模拟一个提问的用户。"max_tokens"定义了响应的最大长度，而"stream"设置为 False 意味着响应将一次性返回，而不是分块返回。

这段简短代码是至关重要的——它是查询封装的内容以及你期望模型响应的方式。

你现在创建了告诉 Mistral 模型要做什么的负载。它包含了你的问题和一些配置参数，并且格式正确，可以通过网络发送。

在下一步中，你将获取此负载，并使用 cURL 命令将其直接发送到 Vertex AI 端点。这将是你的第一次完整往返请求，Mistral 模型将返回实时响应。

运行到模型的 cURL 请求

滚动到 Colab 笔记本中的下一个代码单元格。此部分将你之前准备的 JSON 负载直接发送到托管在 Vertex AI 中的 Mistral 模型。该命令使用了 cURL——这是一个简单而强大的工具，用于从终端或笔记本环境发起 HTTP 请求：

!curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
{ENDPOINT}/v1/projects/{PROJECT_ID}/locations/{LOCATION}/publishers/mistralai/models/{MODEL}{MODEL_VERSION}:rawPredict \
-d '{request}'

此命令构建了一个指向模型端点的 POST 请求。它包含了正确的授权头（通过 gcloud 获取你的访问令牌），将内容类型设置为 JSON，并传递了你的序列化请求负载。执行后，模型将处理你的输入并以 JSON 格式返回响应。

你应该收到一个没有错误的有效 JSON 响应。输出包含 "content"键下的生成消息，以及诸如令牌使用和响应结构等元数据。一个成功的响应可能如下示例所示：

{"content":"Determining the \"best\" French painter can be subjective and depends on personal preferences, as well as the criteria one uses to define \"best\" (e.g., historical significance, technical skill, innovation, etc.). However, several French painters are frequently cited as among the greatest:\n\n1\. **Claude Monet** - Often considered the father of Impressionism, Monet's work is renowned for its use of light and color to capture the fleeting effects of the natural world.\n\n2\. **"},...}

响应已缩小为最小属性，显示了推理的成功。

你现在完成了通过 Vertex AI 与 Mistral 模型的首次实时交互。这种底层方法对于理解 HTTP 请求在后台的工作原理非常有帮助，并让你对数据的传递和返回拥有完全的控制权。

为了让结果更易读和处理，你现在将使用 Python 重新运行请求，以美化打印响应。比起依赖 cURL 进行推理，这种使用 requests 库的方法提供了更好的错误处理、更整洁的输出以及更容易集成。如果你计划扩展或嵌入模型调用，这种方法更具扩展性：

# 获取访问令牌
process = subprocess.Popen(
    "gcloud auth print-access-token", stdout=subprocess.PIPE, shell=True)
(access_token_bytes, err) = process.communicate()
access_token = access_token_bytes.decode("utf-8")  # 去除换行

# 定义头
headers = {
    "Authorization": f"Bearer {access_token}",
    "Accept": "application/json",
}

# 替换为实际值
url = f"{ENDPOINT}/v1/projects/{PROJECT_ID}/locations/{LOCATION}/publishers/mistralai/models/{MODEL}{MODEL_VERSION}:rawPredict"

data = {
    "model": MODEL,
    "messages": [{"role": "user", 
        "content": "who is the best French painter?"}],
    "stream": False,
}

# 发起 POST 请求
response = requests.post(url, headers=headers, json=data)

# 检查状态码并尝试将响应解析为 JSON
if response.status_code == 200:
  try:
    response_dict = response.json()
    print(response_dict["choices"][0]["message"]["content"])
  except json.JSONDecodeError as e:
    print("JSON 解析错误:", e)
    print("原始响应:", response.text)

# 如果解析失败则打印原始响应
else:
    print(f"请求失败，状态码为：{response.status_code}")

该请求的输出将类似于早期的 cURL 响应，但在笔记本输出区域中格式更整洁。你应该能看到一段文字，根据你原始的提示词，可能会列出莫奈或塞尚等著名的法国画家。

4. 亨利·马蒂斯：马蒂斯以其色彩的使用而闻名……

5. 帕罗·毕加索：他的作品因共同创立立体主义而闻名遐迩。

6. 爱德华·马奈：通常被认为是写实主义与印象主义之间的桥梁……

该响应在多处进行了收缩，主要用于展示消息的结构。

这一步将为你提供一种更健壮、更易读的方式来与模型进行交互。使用 Python 代码允许你超越基础提示词，开始从构建功能、测试变体或将响应集成到更复杂的工作流的角度思考。

接下来，我们将让你尝试更高级的交互方式——特别是流式请求（streaming requests）。你不需要等待整个响应生成并一次性返回，而是将看到模型实时流式输出，模拟更具对话性或动态的用户体验。

探索更多功能

笔记本并没有在此结束——你还有许多内容供你自行探索。花几分钟向下滚动，尝试演示中包含的其他功能。你将找到流式调用的工作示例（实时返回响应），以及涉及 Codestral 模型和 Fill-in-the-Middle（FiM）提示的用例。这是一个实验、调整参数并观察模型在不同上下文中表现的绝佳机会。不要犹豫尝试——你已经设置好了一切，现在这里是你的沙箱了。

既然你已经探索了笔记本界面并运行了标准和流式推理请求，现在是时候提升到下一个水平了。

步骤 3：使用 Mistral AI 的 Vertex SDK for Python

你已经体验过 Colab Enterprise 环境有多强大和方便——但现在是时候将这种力量带到自己的机器上了。在工作坊的这部分，我们将离开笔记本，转向使用 VS Code 和终端（terminal）的开发者原生设置。

你将从安装 Google Cloud CLI 并初始化环境开始——就像你之前可能对 AWS CLI 执行的那样。从那里，你创建一个干净的 Python venv，安装所需的包，并使用 gcloud 对会话进行身份验证。

设置完成后，我们将定义整个工作坊将使用的变量——例如 MODEL、LOCATION 和 PROJECT_ID——并直接从 Python 运行真实的推理请求。我们将首先发送一个同步请求并获得立即响应，然后跟一个streaming request（流式请求），它会实时逐令牌地交付结果。

这段旅程反映了真实生产系统如何通过 Vertex AI 与 Mistral 交互，为你提供了可以带回项目的实用工具和工作流。让我们从实验转向集成。

设置 gcloud CLI

在移动到本地 Python 脚本之前，你需要设置 gcloud CLI 以允许你的机器与 Google Cloud 服务进行安全交互。在这一步中，你根据需要安装 CLI 工具，验证你的 Google 账户，并运行 gcloud init 过程来配置环境。你还将选择之前创建的活动项目，确保未来所有的 API 调用和部署都能正确关联。此设置对于管理身份令牌、与 Vertex AI 交互以及在 Colab 之外的完全控制环境中运行推理请求至关重要。

gcloud CLI 的初始安装

选项 1：根据操作系统选择安装方法

在从终端与 Google Cloud 交互之前，你需要安装 gcloud CLI。该工具提供了一个命令行界面，用于初始化环境、管理项目和发送 API 请求。如果你使用的是 Windows 或 Mac，请访问官方安装指南并下载适用于你系统的版本：

• Windows：cloud.google.com/sdk/docs/install#windows

本节将介绍在 macOS 上安装 Google Cloud SDK 的两种方法。第一种是直接下载安装包，第二种是使用 Homebrew 快速安装（仅限 Mac）。

选项 1：直接下载安装包（macOS）

在 macOS 上安装 gcloud 的标准方法是直接下载安装包。请访问以下地址获取适用于 macOS 的安装包： cloud.google.com/sdk/docs/install#mac

选项 2：使用 Homebrew 快速安装（仅限 Mac）

如果你使用的是 macOS 并安装了 Homebrew，安装 gcloud 的快方法是在终端中运行以下命令：

brew install --cask google-cloud-sdk

此方法会为你处理下载和设置。关于此方法的更多文档请访问：formulae.brew.sh/cask/gcloud-cli。

安装完成后，重启你的终端 shell 以确保 gcloud CLI 正确加载到系统路径中。这允许你从以后在任何终端窗口运行 gcloud 命令。

gcloud CLI 已安装并在你的机器上准备就绪。该工具将成为你通过与 Google Cloud 进行身份验证、选择项目以及通过命令行管理 Mistral 模型交互的网关。

现在我们准备好验证会话并选择整个工作坊将使用的活动项目。这一步反映了我们之前在 Colab 笔记本中做的操作，但这次我们将通过终端在本地完成。让我们初始化 CLI 环境。

初始化、身份验证和选择活动项目

现在你已经进入了本地开发环境，是时候初始化 Google Cloud CLI 了。按照以下步骤操作：

1. 打开你的终端并运行以下命令：

gcloud init

这将启动一个交互式流程，引导你完成配置、身份验证和项目选择。参考 图 11.28 查看设置界面。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_28.png

图 11.28：登录 Google Cloud SDK

2. 诊断检查完成后，系统会提示登录。Google 将打开一个浏览器窗口让你验证身份并允许访问账户。重定向后，点击“继续”，如 图 11.28 所示。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_29.png

图 11.29：授权屏幕

3. 确认后，将要求允许 Google Cloud SDK 访问你的项目数据和凭据。此步完成了身份验证过程。参考 图 11.29 查看授权屏幕。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_30.png

图 11.30：gcloud CLI 身份验证成功

4. 身份验证后，终端将显示与你的账户关联的项目列表。你可以选择现有项目——例如 learnmistral——或选择创建一个新项目。你的当前项目将根据你的选择进行设置。终端提示符所示：

选择要使用的云项目：

 [1] yourauth-1571888950021

 [2] coffe-cups-agent

 [3] learnmistral

 [4] plasma-creek-454

 [5] 输入项目 ID

 [6] 创建新项目

2. 输入相应的数字（例如，3）来选择你想要的项目。

根据你的账户历史，你的列表可能会有所不同，并且可能只包含一个项目。

你现在已经通过 Google Cloud 对本地 CLI 完成了身份验证，并选择了你的活动项目。此连接允许你的终端发布安全命令、管理资源，并直接从你的机器运行推理——完全在 Colab 界面之外。

准备虚拟环境和依赖项

在验证环境并配置项目后，下一步是创建一个干净的 Python venv。这会隔离你的依赖项，并确保基于 SDK 的代码以可预测的方式运行，不受全局安装的其他 Python 工具的影响。让我们准备好本地工作空间：

1. 首先在 VS Code 内部启动终端。确保你正处于之前检出的 Git 项目目录中——具体说是本章的文件夹。这确保了你所有的代码和依赖项都整齐地集中。正确的终端视图请参见图 11.31。

https://github.com/OpenDocCN/freelearn-dl-zh/tree/master/docs/learn-mistral/img/B24489_11_31.png

图 11.31: VS Code – 在 Chapter-11 文件夹上选择在集成终端中打开选项

2. 在终端中，运行以下命令在你的项目目录下创建一个新的 Python venv。该环境将此工作坊的包与系统上的其他 Python 项目隔离开：

python3 -m venv ./gcpenv

接下来，激活环境：

source ./gcpenv/bin/activate

1. 激活后，升级 pip 以确保你正在使用最新的包管理器：

python3 -m pip install --upgrade pip

2. 然后，安装 mistralai[gcp] 包，它包含了在 Vertex AI 上使用 Mistral 所需的所有内容：

python3 -m pip install -U -q 'mistralai[gcp]>=1.2.4'

3. 最后，安装 httpx，这是一个现代的 Python 异步 HTTP 客户端：

python3 -m pip install -U -q httpx

你的环境现在已完全为安全且洁的开发准备就绪。所有必要的包已在隔离的工作空间内安装，确保了可复现性并最小化了系统冲突。你现在已经能够从本地机器直接与 Mistral 交互。

从 Python 进行会话验证

下一步是在 Python 内部进行身份验证。你将学习如何通过程序检索你的 Google Cloud 访问令牌，并使用它对 Mistral 模型发送安全的 API 请求，就像我们在 Colab 笔记本中做的那样——只不过这次完全通过代码实现。

执行以下步骤：

1. 身份验证现在从终端移动到你的 Python 代码。你将使用位于 Chapter-11 文件夹中的脚本，从 gcloud CLI 程序化地获取访问令牌。此令牌将授权你对 Vertex AI 的请求，并实现与 Mistral 模型的安全交互。

请参考 ./Chapter-11/ch11_ws_step3_3.py 中的函数：

import subprocess

def get_gcloud_access_token():
    process = subprocess.Popen(
        "gcloud auth print-access-token",
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        shell=True
    )
    access_token_bytes, err = process.communicate()
    if process.returncode != 0:
        raise RuntimeError(f"Failed to get access token: {err.decode('utf-8').strip()}")
    return access_token_bytes.decode("utf-8").strip()

# 取消注释以测试并查看令牌
# print(get_gcloud_access_token())

1. 在脚本底部，你会看到一行被注释掉的代码：

# print(get_gcloud_access_token())

2. 取消注释以打印令牌并确认身份验证正常工作。此令牌将用于未来所有的推理调用，以验证你的会话：

print(get_gcloud_access_token())

3. 在准备好 venv 的 VS Code 内置终端中运行此命令：

python3 ./ch11_ws_step3_3.py

如果一切设置都正确，你应该应该在终端中看到打印出的令牌——这证明你的 Python 环境已安全连接到 Google Cloud 账户。