作为开发者，我们经常面临这样的烦恼：为了测试不同的 AI 模型，需要同时维护 OpenAI、Anthropic 和 Google 的账号，忍受繁琐的支付流程，还要在代码里写一大堆兼容逻辑。最近我发现了一个神器 —— CloudHarb。

它是一个统一的 AI 模型网关，能让你通过一个 API Key 接入 100 多个主流模型。今天分享一下如何利用它快速构建你的 AI 应用。

1. 为什么选择 CloudHarb？

在尝试了多种方案后，CloudHarb 的几个核心优势非常吸引我：• 极致兼容： 完美支持 OpenAI SDK，这意味着你现有的代码几乎无需改动即可无缝切换模型。• 超高性能： 系统在线延迟小于 100ms，且拥有 99.9% 的可用性保障。• 工具链丰富： 除了代码调用，它还原生支持 Claude Code、OpenAI Codex CLI、Cursor 和 LangChain 等热门开发工具。• 成本透明： 采用按量计费模式，没有月费或隐藏成本，每一分钱的 Token 消耗、延迟都能实时追踪。2. 快速上手：只需改动一行代码如果你已经有了一个使用 OpenAI SDK 的 Python 项目，切换到 CloudHarb 只需三步：1. 获取 Key： 在 CloudHarb 官网免费注册（无需信用卡，注册即送免费额度）并创建你的 API Key。

2. 修改 Base URL：

将 API 的请求地址指向 CloudHarb 的统一端点。3. 更换模型： 直接在参数中指定你想用的模型（如 gpt-4o-mini 或 claude-3）。

Python 代码示例：

# pip install openai
from openai import OpenAI

# 1. 填入你的 CloudHarb API Key
# 2. 修改 base_url 为 CloudHarb 统一接口
client = OpenAI(
    api_key='YOUR_CLOUDHARB_API_KEY',
    base_url='https://api.cloudharb.com/endpoint'
)

# 3. 随心切换模型，无需重构代码
completion = client.chat.completions.create(
    model='gpt-4o-mini', 
    messages=[{'role': 'user', 'content': 'Hello CloudHarb!'}]
)

print(completion.choices.message.content)

通过这种方式，CloudHarb 充当了你的应用与各大模型商之间的中转站，实现了“一个接口调用所有模型”。

3. 进阶玩法：

在终端使用 Claude Code, CloudHarb 也是目前少有的完美支持 Claude Code（Anthropic 官方命令行工具）和 Codex CLI 的网关。你只需要在终端中简单设置环境变量，即可直接在命令行与 Claude 对话编程：• 操作方式： 只需设置对应的 API Key 环境变量，无需复杂的中间配置。• 适用场景： 非常适合习惯于终端操作、追求极致效率的开发者。

4. 精细化管理：

为不同项目分配 KeyCloudHarb 提供了非常实用的多 Key 管理功能。你可以为生产环境（prod-key）和开发环境（dev-key）创建独立的 Key。这样做的最大好处是：你可以清晰地看到每个项目的 Token 用量、费用和延迟实时数据，再也不会面对一团乱麻的账单发愁了。结语无论你是个人开发者进行小规模测试，还是企业级业务需要专属的高并发通道与私有化部署，CloudHarb 都提供了极具弹性的定价方案。现在注册即可即刻开始体验，无需信用卡，随时可以取消。

👉 立即前往 CloudHarb 官网

GPT 3.5 Turbo 的微调功能已经上线有一段时间了。本文我们将讨论如何开始进行微调，包括使用场景和示例。

Fine Tuning(微调)的概念是通过提供包含模型输出的训练示例，您可以针对特定的使用场景改进模型的表现。正如 OpenAI 所强调的那样：

Early tests have shown a fine-tuned version of GPT-3.5 Turbo can match, or even outperform, base GPT-4-level capabilities on certain narrow tasks.

OpenAI提到, 通过早期测试结果发现，经过微调的 GPT-3.5 Turbo 在某些特定任务上可以达到甚至超过基础版 GPT-4 的性能水平。

接下来，我们将详细讨论什么是微调、微调的使用场景和示例，以及如何开始自己的微调项目。

• 什么是 GPT 3.5 Turbo 微调？
• GPT 3.5 Turbo 微调是如何工作的？
• GPT 3.5 Turbo 微调的使用场景?
• 如何开始进行 GPT 3.5 Turbo 微调?

什么是 GPT 3.5 Turbo 微调？

微调是指用特定于您使用场景的示例来进一步优化一个已经预训练的大型语言模型（如 GPT 3.5 Turbo）的过程。您可能知道，GPT 模型是通过几乎整个互联网的文本数据进行训练的。

虽然这些模型本身已经非常出色，但通过微调，您可以根据特定任务对模型进行定制，从而生成更可靠的输出。

微调是指在一个新的、更小的定制数据集上对已经预训练的模型进行训练的过程，以使其适应特定任务或表现出特定的行为。

例如，品牌可能希望对 GPT 3.5 Turbo 进行微调，以匹配一致的语调，提供具有特定格式的更可靠输出等。

微调最成功的应用之一来自 OpenAI 自身（当然），他们通过 Function Calling 功能展现了这一点。在这种情况下，他们对 gpt-3.5-turbo-0613 和 gpt-4–0613 模型进行了微调，使其能够智能地选择输出包含调用函数参数的 JSON 对象。

总之，OpenAI 强调，微调提供了以下几个好处：

1. 更高质量的结果：相比直接提示，微调能够产生更高质量的输出。
2. 能够训练更多示例：微调允许使用比单个提示中所能容纳的更多的示例进行训练。
3. 节省 Token：由于提示更短，微调能够节省 Token 的使用。
4. 降低延迟：微调可以减少请求的延迟。

GPT 3.5 Turbo 微调的示例和使用场景

正如前面提到的，微调可以改善模型在特定任务上的表现。以下是一些微调的实际应用示例：

改善的引导能力

引导能力是指通过指令将模型的响应引导到特定方向或结果的能力。

示例：一个经过引导能力微调的聊天机器人导师可以调整其回答，使之适应五年级学生的水平，而不是提供复杂的大学水平解释。

可靠的输出格式

确保模型的响应具有一致且预期的结构。

示例：一家软件开发公司可以通过带有格式化代码的数据集对 GPT-3.5 Turbo 进行微调，确保用户在编写 Python 或 JavaScript 时，模型能够建议符合语法的补全。

定制语调

调整模型以反映特定品牌或语调。

示例：Old Spice 品牌通过微调 GPT-3.5 Turbo 开发一个聊天机器人，该机器人以幽默和古怪的方式回应，反映出他们独特的品牌语调。

成本效益输出

调整模型以提供简洁的输出，从而节省 API 成本。

示例：一家媒体公司通过微调 GPT-3.5 Turbo 提供简短的新闻摘要，确保更快的 API 调用和减少高流量移动应用程序的成本。

正如你所看到的，微调的使用场景非常广泛，几乎适用于任何认真考虑将 GPT 模型集成到其应用程序或业务中的企业。

GPT-3.5 Turbo 微调的定价

微调的成本结构如下：

• 训练成本：每 1,000 个 Token 收费 $0.008
• 使用成本：
• 输入：每 1,000 个 Token 收费 $0.012
• 输出：每 1,000 个 Token 收费 $0.016

例如，如果您使用包含 100,000 个 Token 的训练文件对 GPT-3.5 Turbo 进行微调，并运行 3 个 epoch，预计训练成本约为 $2.40。

逐步指南：如何对 GPT-3.5 Turbo 进行微调

现在我们知道了什么是微调，并且有了一些实际示例，下面是开始使用 GPT-3.5 Turbo 进行微调的详细步骤：

1. 准备您的数据
2. 上传文件
3. 创建一个微调任务
4. 部署微调后的模型

步骤 1：准备您的数据

与以往的 GPT 微调不同，使用 3.5 Turbo 我们需要按照对话流程来结构化训练，引导模型的行为。为此，我们使用 GPT 3.5 Turbo 的消息输入：

聊天模型将一系列消息作为输入，并返回模型生成的消息作为输出。虽然聊天格式旨在使多轮对话变得简单，但对于没有任何对话的单轮任务同样有用。

总结一下，这里是每个消息角色的作用：

• 系统消息帮助设置助手的行为。
• 用户消息提供请求，供助手回应。
• 助手消息存储先前的聊天响应，并可以用来给出所需行为的示例。

可以看出，为了微调的目的，目标是提供用户输入和期望的助手响应的示例。例如，OpenAI 提供了以下示例，用于微调一个偶尔拼写错误的助手（非常实用，我知道）：

{ 
  "messages": [ 
    { "role": "system", "content": "You are an assistant that occasionally misspells words" }, 
    { "role": "user", "content": "Tell me a story." }, 
    { "role": "assistant", "content": "One day a student went to schoool." } 
  ] 
}

这里是他们微调文档中的另一个例子，用于微调既严谨又带点讽刺的助手：

{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the capital of France?"}, {"role": "assistant", "content": "Paris, as if everyone doesn't know that already."}]} 
{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who wrote 'Romeo and Juliet'?"}, {"role": "assistant", "content": "Oh, just some guy named William Shakespeare. Ever heard of him?"}]}

在上面的例子中，我们可以看到有三个训练示例（即对话），可以用作训练集。现在，问题是…

对于 GPT-3.5-turbo 的微调，您应该提供多少训练示例？

OpenAI 建议至少提供 10 个训练示例，尽管正如他们强调的那样：

通常情况下，使用 gpt-3.5-turbo 进行微调，在 50 到 100 个训练示例上通常会看到明显的改善，但正确的数量会根据具体的使用案例而有很大变化。

根据我以往的微调经验，我通常会使用至少 100 个示例来获得最佳结果，有时甚至会使用超过 10,000 个训练示例。

好了，当我们有了训练示例后，我们需要将其保存在一个 JSONL 文件中。在这个演示例子中，我将测试这个既严谨又带点讽刺的助手，并创建 7 个类似的示例，以达到至少 10 个的最低要求。

在创建微调任务之前，我们还可以使用数据格式化脚本来确保我们的格式正确。

好的，看起来不错，现在进入下一步，上传我们的 JSONL 文件。

步骤 2：上传文件

接下来，我们需要使用 OpenAI 的 API 上传我们的结构化数据，如下所示，请注意在运行之前您需要设置您的 OpenAI API 密钥：

openai.File.create( 
  file=open("/content/fine_tuning_data.jsonl", "rb"), 
  purpose='fine-tune' 
)

步骤 3：创建微调任务

在上传我们的训练数据之后，现在让我们按照以下步骤创建一个微调任务，您只需更新 file-abc123，将其替换为前一步生成的文件 ID：

openai.api_key = os.getenv("OPENAI_API_KEY") 
openai.FineTuningJob.create(training_file="file-abc123", model="gpt-3.5-turbo")

现在我们可以看到状态已创建，只需等待几分钟完成，我们也可以按以下方式检查状态：

openai.FineTuningJob.retrieve("ft-abc123")

步骤 4：使用微调后的模型

现在微调任务已完成，让我们按以下步骤进行测试，注意您需要更新此处的 OpenAI 组织编号以及微调任务的自定义 IDft:gpt-3.5-turbo:my-org:custom_suffix:id:

completion = openai.ChatCompletion.create( 
  model="ft:gpt-3.5-turbo:my-org:custom_suffix:id", 
  messages=[ 
    {"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, 
    {"role": "user", "content": "What's the capital of France?"} 
  ] 
) 
 
print(completion.choices[0].message)

现在很难说是微调还是系统消息导致了这个响应，因为我们只提供了 10 个示例，所以需要进行更深入的实验，这将在未来的指南中进行讨论。

总结：GPT 3.5 Turbo 微调

虽然微调是提示工程师工具包中的一个强大工具，但需要注意的是，在试图提高模型性能时，通常不应总是将微调作为第一选择。相反，我建议先从一些基本的提示工程开始（例如通过 few shot 学习提供几个示例），以建立一个基准，然后再尝试微调，看看改进效果如何显著。

尽管如此，考虑到微调可以使 3.5 Turbo 的性能达到类似于 GPT-4 的水平，如果您运行的是大规模应用程序，微调的成本节约肯定会累积起来。

本文中我们只是初步介绍了微调的潜力，因此在未来的指南中，我们将提供更多展示如何利用这一新能力的实际示例。

参考:

Getting Started with GPT 3.5 Turbo Fine Tuning

GPT 3.5 Turbo fine tuning has arrived. In this guide we discuss how to get started with fine tuning, including use…

ChatGPT-4o，OpenAI的一小步，人類「AI助理」的一大步

科幻電影「Her」的劇情正在成為現實。

微頭條 - ChatGPT-4o，OpenAI的一小步，人類「AI助理」的一大步

一直没能搞定OpenAI的订阅， 就因为没有搞定国外的信用卡， 所以就一直使用GPT-3.5来处理日常的文字生成工作， 例如写文档， 生成一些简单的脚本和程序代码以及帮助review代码。 偶尔会通过Azure 的 AI Studio来调用gpt-4的模型， 总觉得对话内容和3.5差不多， 最近公司有想做职能文档助理或者职能技术支持的功能， 为了能灌入一些知识库的内容， 不得不去Azure上弄一下Customized Model， 由于Azure的Portal有些慢， 所以想到了目前比较流行的ChatGPT Web UI, 也就是本文要说的ChatGPT-Next-Web.

搞定ChatGPT-Next-Web

这个比较简单， 使用Docker的话， 真的就是一行命令, 不过， 问题是， 我发现它对Azure OpenAI API支持等于零， 所以， 在搞定这个之前， 还得想个曲线救国的办法， 于是， 我想到， 要不我自己用Python来做一个API Wrap， 于是， 我开始准备卷。。。

但是， 懒虫如我， 怎么可能就这么轻易得开始自己写代码？ 或者， 我还会写代码吗？ 自从用了这些AI工具后， 我的大脑就一直处于躺平状态， 于是， 找到了这个

GitHub - hbsgithub/deno-azure-openai-proxy: One-click deploy! Free to use, no server required. A…

One-click deploy! Free to use, no server required. A Deno Deploy script to proxy OpenAI's request to Azure OpenAI…

和这个

GitHub - haibbo/cf-openai-azure-proxy: A Cloudflare worker script to proxy OpenAI's request to…

A Cloudflare worker script to proxy OpenAI's request to Azure OpenAI Service - haibbo/cf-openai-azure-proxy

因为我有在使用cloudflare, 所以我决定试一试Cloudflare worker来代理Azure OpenAI API， 并将其转换为兼容OpenAI API格式。

Cloudflare Work 运行 cf-openai-azure-proxy

这个proxy代码真的很简单， 就一个js文件， copy到Cloudflare的worker里就好， 这是具体的步骤

新建一个worker application

登录到Cloudflare dashboard, 在左边的菜单上进入Workers & Pages, 并从右上角点击 Create application， 并且进入Worker界面后， Create Worder。

部署我们的Worker

接下来我们就可以部署一个新的worker, 为我们的worker取一个名字， 这里我称之为 “my-azure-openai-wrapper-01”

这里， 我们不需要修改代码， 而是直接点 Deploy. 因为部署后， 我们就可以编辑代码了。

编辑Worker代码

到这步就可以选择 Edit code来编辑代码，我们将

https://raw.githubusercontent.com/haibbo/cf-openai-azure-proxy/main/cf-openai-azure-proxy.js

这里的代码Copy到代码框里。

红色框里的是需要修改的代码， 这里的信息， 我们可以在Azure Portal里找到。

修改 Worker 代码

进入到Azure Portal, 并搜索OpenAI, 这时候会跳出产品， 我们直接选择进入到Azure OpenAI

// The name of your Azure OpenAI Resource. 
const resourceName="xx-openai-inst-1"

将代码中的 resourceName的值修改为你的Azure OpenAI的实例名称

然后进入到实例， 并部署我们要使用的模型

说实话， Azure Portal里的OpenAI Studio网页加载太慢了， 这也是为什么会有这篇文章的原因， 哈哈。

这里就可以看到我们可以使用的模型了， 这里我们把代码中的mapper部分也改成我们的模型部署名称

// The deployment name you chose when you deployed the model. 
const mapper = { 
    'gpt-3.5-turbo': "general-gpt35-turbo-deployment-1", 
    'gpt-3.5-turbo-0613': "general-gpt35-turbo-deployment-1", 
//   'gpt-3.5-turbo-1106': DEPLOY_NAME_GPT35, 
  // 'gpt-3.5-turbo-16k': DEPLOY_NAME_GPT35, 
    'gpt-4': "general-gpt4-deployment-1", 
    'gpt-4-0613': "general-gpt4-deployment-1", 
  // 'gpt-4-1106-preview': DEPLOY_NAME_GPT4, 
  // 'gpt-4-32k': DEPLOY_NAME_GPT4, 
  // 'dall-e-3': typeof DEPLOY_NAME_DALLE3 !== 'undefined' ? DEPLOY_NAME_DALLE3 : "dalle3", 
};

有些模型没有部署， 自然就不需要填写了， 我们这里先就使用这两个模型,

GPT-3.5和GPT-4，修改好就回到Cloudflare的网页上， 点Save and deploy.

在截图的这两处都可以获取到我们刚刚设置的worker的URL

把这个URL记录下来， 我们接下来要在 ChatGPT-Next-Web里要用。

使用Docker部署和配置ChatGPT-Next-Web

为了简化部署的过程， 我们这里直接使用Docker compose来完成Web UI的部署和配置， 如果你的电脑上已经安装了Docker和Docker compose， 那么恭喜你， 不需要再做其他的工作， 我们直接创建一个文件夹， chatgpt-next-web， 然后新建一个文件名叫 docker-compose.yml

version: "3.9" 
services: 
  chatgpt-next-web: 
    container_name: chatgpt-next-web 
    image: yidadaa/chatgpt-next-web 
    ports: 
      - 18303:3000 
    environment: 
      - OPENAI_API_KEY=这里有个key哦 
      - GOOGLE_API_KEY=$GOOGLE_API_KEY 
      - CODE=这里可以存个admin密码哦 
      - BASE_URL=https://my-azure-openai-wrapper-01.xxxxxxxx.workers.dev/ 
      - OPENAI_ORG_ID=这里是Azure OpenAI的订阅ID 
      - HIDE_USER_API_KEY=$HIDE_USER_API_KEY 
      - DISABLE_GPT4=$DISABLE_GPT4 
      - ENABLE_BALANCE_QUERY=$ENABLE_BALANCE_QUERY 
      - DISABLE_FAST_LINK=$DISABLE_FAST_LINK 
      - OPENAI_SB=$OPENAI_SB

需要你修改的部分:

OPENAI_API_KEY 
CODE 
BASE_URL 
OPENAI_ORG_ID

这些信息哪里找呢?

还记得之前要记录的URL么？

这个就是BASE_URL了。

首先 CODE 可以随便填， 这里是你登录到ChatGPT-Next-Web的密码, 我们就设置为 CHATGPT2024 好了， OPENAI_API_KEY, OPENAI_ORG_ID这两个可以在这里找， 首先 ORG_ID就是下图中的Subscription ID

然后在 Keys and Endpoint 里就可以看到 API_KEY了

一切就绪， 运行ChatGPT-Next-Web

docker compose up -d

然后打开浏览器， 进入 http://docker-host-ip:18303

这里docker-host-ip 就是你刚刚运行docker compose的那个电脑的ip， 通常我们做实验都是在本机做， 那么就使用 http://localhost:18303， 应该就可以看到

输入我们先前设置的CODE, CHATGPT2024 ，然后在OpenAI API Key输入我们之前在Azure 里copy来的API_KEY， 为什么这里还要输入， 我也不是很清楚， 明明我们在环境变量里已经配置了， 还望知道的朋友告诉我。

进去后， 我们可以在输入框上方选择一个模型， 这里我选择GPT-4

大功告成。 希望大家喜欢这个教程， 如果有问题， 也欢迎在下方留言探讨。

最近用ChatGPT的提示词+github copilot做了一个小破站， 收集一些文章， 有时间我再发一篇文章来讲讲过程

https://wenews.cc

Go 语言的并发模型是其最吸引人的特性之一，而通道（channels）作为实现并发通信的关键机制，是 Go 语言中的重要组成部分。本文将深入研究通道，探索其在并发编程中的作用、使用方式以及一些高级特性。

1. 什么是Go Channel ?

Channel是允许 goroutines（轻量级线程或协程）相互通信并同步它们的执行的通道。它们是类型安全的，确保在 goroutines 之间发送的数据符合指定的类型。

从概念上来说，可以将Channel视为管道，其中数据可以从一端发送，从另一端接收。

下面代码是创建一个新的Channel

ch := make(chan int) // declare a channel of type int

2. 基本的Channel操作

发送和接收

向Channel发送一个值

ch <- 5 // Send value 5 into the channel

从Channel接收一个值

value := <-ch // Receive a value from the channel

下面的例子演示了如何使用Channel从两个goroutine里同步数据

package main 
import ( 
 "fmt" 
 "time" 
) 
func main() { 
 message := make(chan string) 
 go func() { // sending goroutine 
  time.Sleep(time.Second * 2) 
  message <- "Hello from goroutine!" 
 }() 
 msg := <-message // receiving in main goroutine 
 fmt.Println(msg) 
}

关闭Channel

当发送者不再发送值时，应该由发送者主动关闭Channel。

close(ch)

3. 高级Channel技术

Buffered Channels

Channel默认情况下是无缓冲(unbuffered)的，这意味着在发送时会阻塞，除非有相应的接收操作。Buffered Channels允许您在阻塞之前发送多个值。

Buffered Channels具有容量，允许它在阻塞发送者之前保留多个值。

ch := make(chan int, 3) // A buffered channel with capacity 3 
ch <- 1 
ch <- 2 
// ch <- 3 would block

在下面的示例中，我们将：

1. 创建一个容量为3的Buffered Channel
2. 启动5个运行任务的 goroutine。
3. 使用Channel确保一次只有3个任务正在进行中。

package main 
 
import ( 
 "fmt" 
 "time" 
) 
 
func worker(id int, ch chan int) { 
 // Pretend we're doing some work 
 fmt.Printf("Worker %d started\n", id) 
 time.Sleep(time.Second) 
 fmt.Printf("Worker %d finished\n", id) 
 <-ch // Signal we're done 
} 
 
func main() { 
 // Create a buffered channel 
 bufferedChannel := make(chan int, 3) 
 
 // Start 5 workers 
 for i := 1; i <= 5; i++ { 
  go worker(i, bufferedChannel) 
  bufferedChannel <- i // Fill the channel slot to represent a worker in-progress 
 } 
 
 // Wait for all workers to finish 
 // This is a simple way to wait; in real-world scenarios, you might use sync.WaitGroup or similar 
 time.Sleep(7 * time.Second) 
}

在运行上述代码时，您会注意到只有3个任务立即启动。每当一个任务完成时，另一个就会启动，直到所有5个工作程序都执行完毕。这种行为受到Buffered Channel的控制，它一次只允许3个“任务”（代表正在进行中的任务）存在。

Buffered Channel的工作原理取决了只有3个任务立即被执行。 它可以在不阻塞的情况下容纳指定数量的值。当您尝试向Channel发送数据或从空Channel接收数据时，它将分别阻塞，直到有空间可用或值可用为止。

在上面的示例中：

bufferedChannel := make(chan int, 3)

我们创建了一个容量为3的Channel。这意味着它可以容纳最多3个值而不会阻塞。

然后我们循环并启动5个任务：

for i := 1; i <= 5; i++ { 
 go worker(i, bufferedChannel) 
 bufferedChannel <- i  
}

对于循环的每次迭代，我们：

1. 启动一个执行任务的 goroutine。
2. 向Channel发送一个值（i）。

如果Channel已满，则Send操作（bufferedChannel <- i）会阻塞。在这种情况下，由于通道的容量为3，一旦我们启动了3个任务并向Channel发送了3个值，Send操作就会阻塞。

在启动了前3个任务之后，主 goroutine 将在第四次发送操作上阻塞，因为Channel已满。它将保持阻塞，直到其中一个任务完成并从Channel读取一个值，释放一个插槽(slot)。

在任务函数内部，完成其任务后：

<-ch

任务从Channel中读取（或“接收”）一个值，因此移除了一个项目，为下一个任务腾出了空间。

总而言之：只有3个任务会立即启动，因为我们使用Buffered Channel作为信号量来控制并发性。通道的容量决定了可以同时运行的任务数量。在这种情况下，它设置为3，因此只有三个工作程序可以立即启动。随着每个任务完成并在通道中释放一个插槽，另一个任务开始执行。

遍历Channel

遍历Channel允许我们接收值，直到通道被关闭。为了让这个方法好用，发送者必须关闭Channel以表示不会再发送更多数据。

ch := make(chan int, 3) 
ch <- 1 
ch <- 2 
ch <- 3 
close(ch) 
 
for v := range ch { 
 fmt.Println(v) 
}

Select语法

用于处理多个Channel的情况，Select允许一个 goroutine 等待多个通信操作。Select语法类似于 switch 语句，但用于Channel：

ch1 := make(chan int) 
ch2 := make(chan int) 
 
go func() { 
 time.Sleep(time.Second * 1) 
 ch1 <- 1 
}() 
 
go func() { 
 time.Sleep(time.Second * 2) 
 ch2 <- 2 
}() 
 
for i := 0; i < 2; i++ { 
 select { 
 case msg1 := <-ch1: 
  fmt.Println("Received from ch1:", msg1) 
 case msg2 := <-ch2: 
  fmt.Println("Received from ch2:", msg2) 
 } 
}

在 select 语句中的默认情况在没有任何Channel可以立即发送或接收时执行。

select { 
case msg := <-ch: 
 fmt.Println("Received:", msg) 
default: 
 fmt.Println("No message received.") 
}

检查Channel是否已被关闭

如果从Channel接收数据，并且该Channel已关闭，则还将接收到一个布尔值，指示Channel是否仍然处于打开状态。

v, open := <-ch 
if !open { 
 fmt.Println("Channel is closed!") 
}

4. 现实中使用Channel的场景和例子

任务队列

Go 语言的Channel可以用于实现任务队列，多个Producer可以添加任务，多个Consumer可以并发处理它们。

发布者/订阅者模式

Channel可以用于创建发布者/订阅者模型，多个订阅者可以监听发布者发出的事件或消息。

package main 
 
import ( 
 "fmt" 
 "sync" 
) 
 
// PubSub is the main structure for our simple pub-sub system. 
type PubSub struct { 
 // mu is a RWMutex that allows multiple goroutines to read from the subscribers map, 
 // but only one goroutine to write to it at any given time. 
 mu sync.RWMutex 
 
 // subscribers is a map where the key is a topic (as a string) and the value is 
 // a slice of channels. Each channel corresponds to a subscriber listening to that topic. 
 subscribers map[string][]chan int 
} 
 
// NewPubSub creates a new PubSub instance and initializes its subscribers map. 
func NewPubSub() *PubSub { 
 return &PubSub{ 
  subscribers: make(map[string][]chan int), 
 } 
} 
 
// Subscribe allows a subscriber to get updates for a specific topic.  
// It returns a channel on which the subscriber will receive these updates. 
func (ps *PubSub) Subscribe(topic string) <-chan int { 
 // Lock the map for writing. 
 ps.mu.Lock() 
 defer ps.mu.Unlock() 
 
 // Create a new channel for this subscriber. 
 ch := make(chan int, 1) 
  
 // Append this subscriber's channel to the slice of channels for the given topic. 
 ps.subscribers[topic] = append(ps.subscribers[topic], ch) 
  
 // Return the channel to the subscriber. 
 return ch 
} 
 
// Publish sends the given value to all subscribers of a specific topic. 
func (ps *PubSub) Publish(topic string, value int) { 
 // Lock the map for reading. 
 ps.mu.RLock() 
 defer ps.mu.RUnlock() 
 
 // Iterate over all channels (subscribers) for this topic and send the value. 
 for _, subscriber := range ps.subscribers[topic] { 
  subscriber <- value 
 } 
} 
 
// Close removes a specific subscriber from a topic and closes its channel. 
func (ps *PubSub) Close(topic string, subCh <-chan int) { 
 // Lock the map for writing. 
 ps.mu.Lock() 
 defer ps.mu.Unlock() 
 
 // Find the subscriber's channel in the slice for the given topic. 
 subscribers, found := ps.subscribers[topic] 
 if !found { 
  return 
 } 
 
 for i, subscriber := range subscribers { 
  if subscriber == subCh { 
   // Close the channel. 
   close(subscriber) 
    
   // Remove this channel from the slice. 
   ps.subscribers[topic] = append(subscribers[:i], subscribers[i+1:]...) 
   break 
  } 
 } 
} 
 
// Main function demonstrating the pub-sub functionality. 
func main() { 
 // Create a new pub-sub instance. 
 ps := NewPubSub() 
 
 // A subscriber subscribes to "topic1". 
 subscriber := ps.Subscribe("topic1") 
 
 // A publisher publishes the value 42 to "topic1". 
 go func() { 
  ps.Publish("topic1", 42) 
 }() 
 
 // The subscriber receives the value. 
 value := <-subscriber 
 fmt.Println("Received value:", value) // Expected: Received value: 42 
 
 // Close the subscriber's channel and remove it from the topic's subscribers. 
 ps.Close("topic1", subscriber) 
}

这个简单的发布-订阅实现演示了如何使用 Go 的Channel和 goroutines 来创建并发系统。注释提供了关于代码各部分目的和功能的见解。

工作原理：

1. PubSub 结构体包含了每个主题的订阅者映射。
2. Subscribe 方法让订阅者获取一个Channel，通过该Channel他们将接收特定主题的事件。
3. Publish 方法将给定的值发送到该主题的所有订阅者。
4. Close 方法移除订阅者的通道并关闭它。

错误处理：

在并发应用程序中，Channel可以用来传递和处理来自 goroutine 的错误，将其传递回主程序。

5. 使用Channel的窍门和技巧

• 避免全局Channel(Global Channel)：与其使用全局Channel，最好将Channel作为函数参数传递。这样有助于更好地封装。
• 检测死锁：Go 的运行时可以检测到某些死锁，并在遇到死锁时引发 panic。
• Nil Channel：对Nil Channel进行发送操作会永久阻塞，而从空通道接收将始终阻塞。
• 避免“忙等待”：与其频繁轮询Channel，不如利用 select 或 range 有效地等待值的到来。

Conclusion

Channel是 Go 语言并发模型的核心。深入理解它们可以释放 Go 中并发编程的真正力量。从基本的发送/接收操作到高级模式如发布/订阅，通道为构建高效的并发应用程序提供了丰富的选择。

无论您是初学者刚刚开始学习 Go，还是经验丰富的专业人士想要完善自己的理解，Channel仍然是必须掌握的关键构造。拥抱它们，尝试它们，让 Go 的并发性推动您的下一个应用程序。

我尝试过很多框架，从Django/Flask和Laravel到NextJS和SvelteKit。到目前为止，这是我唯一可以使用的不会让我感到疯狂或者放弃项目的堆栈/框架。

我喜欢所有这些框架，但我只是不太适应它们的设计方式。实际上，我是一个弱鸡程序员，因为它们都非常高效，而且拥有强大的生态系统，但是，算了。

如果你还没有被Go同化，那么我将给出一些我为什么如此喜欢它的原因。

• 快速编译成单一的二进制文件
• 干净的语法最终产生易于阅读的代码库
• 适合团队协作， 不用担心大家写出风格迥异的代码
• 提供了go test/profile工具， 和vscode配合非常好

下面介绍一下我所使用的框架和工具。

Web框架

Fiber

An Express-inspired web framework written in Go.

Fiber 是一个受到 Express 启发的 Web 框架，基于使用 Go 语言编写的最快的 HTTP 引擎 Fasthttp 构建。旨在通过零内存分配和高性能服务，使快速开发更加简便。

从 Node.js 切换到 Go 的新 gopher 在开始构建 Web 应用程序或微服务之前需要经历学习过程。 Fiber 作为一个 Web 框架 ，是按照极简主义的思想并遵循 UNIX 方式创建的，因此新的 gopher 可以在热烈和可信赖的欢迎中迅速进入 Go 的世界。

HTML模版引擎

Jet

GitHub - CloudyKit/jet: Jet template engine

Jet template engine. Contribute to CloudyKit/jet development by creating an account on GitHub.

go get github.com/gofiber/template/jet/v2

Fiber只提供了9种模板系统，而在所有这些系统中，Jet是我最喜欢的。如果你想选择其他的，你可以在这里找到它们的列表，但是我建议你要注意那些功能不是很多的模板引擎，特别是Django，因为你最终不得不将大量的逻辑移动到Go中，而不能直接在模板语言中完成。

HTMX

htmx - high power tools for html

htmx gives you access to AJAX, CSS Transitions, WebSockets and Server Sent Events directly in HTML, using attributes…

Htmx是一个JavaScript库，用于执行AJAX请求，触发CSS转换，以及直接从HTML元素调用WebSocket和服务器发送的事件。Htmx可以让你用简单的标记建立现代和强大的用户界面。

这个库的重量为~10KB（min.gz’d），它是无依赖性的（也就是说，它不需要任何其他的JavaScript包来运行），而且它还与IE11兼容。

AlpineJS

Alpine.js

A rugged, minimal framework for composing behavior directly in your markup.

这个工具可以增加一些前端的交互性。你可以把它看成是新一代的jQuery。

DaisyUI & Tailwind

daisyUI - Tailwind CSS Components ( version 4 update is here )

Best Tailwind Components Library - Free UI components for Tailwind CSS

如大多数后端开发者，你可能会同意我说的，我讨厌写CSS，但仅仅使用Tailwind就几乎无法忍受，因为你得面对一个元素有20个不同的class。这就是DaisyUI的用武之地，它提供了预先设计的类，同时还能使用Tailwind进行布局，比如’flex’。

数据库

Supabase

Supabase | The Open Source Firebase Alternative

Build production-grade applications with a Postgres database, Authentication, instant APIs, Realtime, Functions…

GitHub - nedpals/supabase-go: Unofficial Supabase client library for Go.

Unofficial Supabase client library for Go. Contribute to nedpals/supabase-go development by creating an account on…

如果没有Supabase，这套组合拳真的就无法很好工作了，因为它依赖于身份验证，而且ORM也很好。如果你更喜欢使用不同的ORM或者只是SQL，那么这也是可以的，因为在底层，Supabase只是PostgreSQL，他们提供了连接到数据库的凭据。

此外，仅仅能够简单地设置一个API密钥来设置数据库，就能让我心里轻松很多，这在开始一个项目的初期非常重要，因为时间真的是非常重要的，热情会随着时间的推移而消退。编程是无聊的，就我个人而言，它真的只是一个心理游戏，要不断找到在开发项目时获取多巴胺的方法，以保持我对此的兴趣。

本文出于学习的需求， 原封不动的翻译了来自Github的一篇Blog, 所有的Credits都属于原文作者， 如果您有任何想法和建议， 请至原文发表评论， 如果本文作为指引有帮助到您， 也请感谢原文的作者 Rizel Scarlett 和 Michelle Mannering , 原文地址:

How to use GitHub Copilot: Prompts, tips, and use cases - The GitHub Blog

In this prompt guide for GitHub Copilot, two GitHub developer advocates, Rizel and Michelle, will share examples and…

生成式AI编程工具正在改变开发人员日常Coding的方式。从写文档到生成单元测试，这些工具正在帮助我们大幅提升工作效率。然而，就像任何新兴技术一样，总会有一个学习曲线。因此，无论是初学者还是经验丰富的开发人员在使用AI辅助编程助手不能生成他们想要的输出时。可能会感到沮丧。 （说的是你吗? 😂 )

例如，当我们要求GitHub Copilot使用p5.js来绘制一个冰淇淋锥型🍦，这是一个用于设计创意的JavaScript库，我们总是收到无关的建议 — 或者有时根本没有建议。但是当我们了解了GitHub Copilot处理信息的方式后，我们意识到我们必须调整与它沟通的方式。

以下是GitHub Copilot生成无效解决方案的一个示例：

当我们调整了Prompt 后， Copilot 给出了更精确的结果:

在这个GitHub Copilot指南中，我们将涵盖：

• 什么是Prompt，以及什么是Prompt Engineering（提示工程取决于您是在与开发人员交谈还是与机器学习研究人员交谈）。
• 使用GitHub Copilot进行提示时的三个最佳实践和三个额外的提示。
• 一个示例，您可以尝试在提示GitHub Copilot帮助您构建浏览器扩展时进行操作。

进步胜于完美/聊胜于无 Progress over perfection

即使我们在使用AI方面有经验，我们也认识到每个人在使用生成式AI技术时都会有试错阶段。我们也知道提供通用的Prompt-crafting技巧是一个挑战，因为模型各不相同，开发人员所处理的个体问题也是各异的。这并不是一个全面的指南。相反，我们在分享我们在Prompt-crafting方面的所学，以加速在这个新时代的软件开发中的集体学习。

什么是Prompt，什么是Prompt Engineering？ 这取决于使用对象是谁。

在生成式AI 编程工具的背景下，”Prompt”可能有不同的含义，这取决于你是在询问正在构建和微调这些工具的机器学习（ML）研究人员，还是在询问将它们用于集成开发环境（IDE）的开发人员。

在本指南中，我们将从使用集成开发环境中的生成式AI编程工具的开发人员的角度定义这些术语。但为了让您有一个完整的画面，我们在下面的图表中也添加了机器学习研究人员的定义。

使用GitHub Copilot进行提示构建的三个最佳实践：

1 . 设置一个High-level的目标。🖼️

如果您有一个空白文件或空的代码库，这会非常有帮助。换句话说，如果GitHub Copilot对您要构建或完成的内容没有任何上下文，与AI结对编程设置阶段会非常有用。在您详细介绍细节之前，通过大致描述您希望它生成的代码来为GitHub Copilot铺平道路。

在提示GitHub Copilot时，将这个过程看作是与某人进行对话：我应该如何拆分问题，以便我们一起解决它？我应该如何与这个人一起进行结对编程？

例如，在构建Next.js中的Markdown编辑器时，我们可以编写这样的注释：

/* 
Create a basic markdown editor in Next.js with the following features: 
- Use react hooks 
- Create state for markdown with default text "type markdown here" 
- A text area where users can write markdown  
- Show a live preview of the markdown text as I type 
- Support for basic markdown syntax like headers, bold, italics  
- Use React markdown npm package  
- The markdown text and resulting HTML should be saved in the component's state and updated in real time  
*/

这将促使GitHub Copilot生成以下代码，并在不到30秒内生成一个非常简单、未经样式化但功能正常的Markdown编辑器。我们可以在后续为组件添加样式：

Note: 这种详细程度可以帮助您创建更符合预期的输出，但结果仍可能是非确定的。例如，在注释中，我们提示GitHub Copilot创建默认文本，显示“在此键入Markdown”，但它实际上生成了“Markdown预览”作为默认文字。

2 . 让您的请求简单明确。旨在从GitHub Copilot获得简短的输出。🗨️

一旦您向AI传达了首要目标，阐述它需要遵循的逻辑和步骤来实现该目标。当您将事情分解时，GitHub Copilot更好地理解您的目标。（想象一下您正在编写食谱。您会将烹饪过程分解成离散的步骤，而不是写一段描述您想制作的菜肴的段落。）

让GitHub Copilot在每个步骤之后生成代码，而不是要求它一次生成大量代码。

以下是我们为GitHub Copilot提供的逐步反转函数的示例说明：

3 . 给GitHub Copilot提供一个或两个示例。✍️

从示例中学习不仅对人类有用，对您的AI配对程序员也是如此。例如，我们想要从下面的数据数组中提取名称并将其存储在一个新数组中：

const data = [ 
  [ 
    { name: 'John', age: 25 }, 
    { name: 'Jane', age: 30 } 
  ], 
  [ 
    { name: 'Bob', age: 40 } 
  ] 
];

当我们没有向GitHub Copilot展示示例时…

// Map through an array of arrays of objects to transform data 
const data = [ 
  [ 
    { name: 'John', age: 25 }, 
    { name: 'Jane', age: 30 } 
  ], 
  [ 
    { name: 'Bob', age: 40 } 
  ] 
]; 
 
const mappedData = data.map(x => [x.name](http://x.name/)); 
 
console.log(mappedData); 
 
// Results: [undefined, undefined]

它生成了一个map的错误用法

const mappedData = data.map(x => [x.name](http://x.name/)); 
 
console.log(mappedData); 
 
// Results: [undefined, undefined]

相比之下，当我们提供了一个示例时…

// Map through an array of arrays of objects 
// Example: Extract names from the data array 
// Desired outcome: ['John', 'Jane', 'Bob'] 
const data = [ 
  [{ name: 'John', age: 25 }, { name: 'Jane', age: 30 }], 
  [{ name: 'Bob', age: 40 }] 
]; 
 
 
const mappedData = data.flatMap(sublist => sublist.map(person => person.name)); 
 
console.log(mappedData);

我们得到了一个我们想要的结果

const mappedData = data.flatMap(sublist => sublist.map(person => person.name)); 
 
console.log(mappedData); 
// Results: ['John', 'Jane', 'Bob']

与GitHub Copilot进行提示构建的另外三个技巧

以下是三个额外的提示，以帮助引导您与GitHub Copilot的对话。

1 . 尝试不同的Prompt。

就像对话更多是一门艺术而不是科学一样，提示构建也是如此。因此，如果您在第一次尝试时没有得到您想要的结果，请按照上面的最佳实践重新构建您的提示。

例如，下面的提示很模糊。它没有为GitHub Copilot生成相关建议提供任何上下文或界限。

# Write some code for grades.py

我们对提示进行了迭代，使其更具体，但我们仍然没有得到我们正在寻找的确切结果。这是一个很好的提醒，即使听起来增加提示的具体性也比较困难。从一开始就很难知道您应该包括哪些有关目标的细节，以从GitHub Copilot生成最有用的建议。这就是为什么我们鼓励进行尝试。

下面版本的提示比上面的版本更具体，但它并没有明确定义输入和输出要求。

# Implement a function in grades.py to calculate the average grade

我们再次尝试了提示，通过设定界限和概述我们希望函数执行的操作。我们还重新表述了注释，使函数更加清晰（为GitHub Copilot提供明确的验证意图）。

这一次，我们得到了我们所期望的结果。

# Implement the function calculate_average_grade in grades.py that takes a list of grades as input and returns the average grade as a floating-point number

2 . 保持一些相关的标签页打开。

我们没有确切的标签页数量，可以帮助GitHub Copilot对您的代码进行上下文处理，但根据我们的经验，我们发现保持一个或两个标签页是有帮助的。

GitHub Copilot使用一种称为邻近标签页的技术，它允许AI配对程序员通过处理在您的IDE中打开的所有文件来对您的代码进行上下文处理，而不仅仅是您正在工作的单个文件。但是，并不保证GitHub Copilot会认为所有打开的文件都是您的代码所需的上下文。

3 . 使用良好的编码实践。

这包括提供描述性的变量名和函数，并遵循一致的编码风格和模式。我们发现与GitHub Copilot一起工作鼓励我们遵循我们在整个职业生涯中学到的良好编码实践。

例如，在这里，我们使用了一个描述性的函数名称，并遵循了代码库中使用蛇形命名法的模式。

def authenticate_user(username, password):

结果，GitHub Copilot生成了一个相关的代码建议：

def authenticate_user(username, password): 
    # Code for authenticating the user 
    if is_valid_user(username, password): 
        generate_session_token(username) 
        return True 
    else: 
        return False

与下面的示例相比，我们引入了不一致的编码风格并且给函数取了一个不恰当的名称。

def rndpwd(l):

与建议代码不同，GitHub Copilot生成了一条注释，上面写着“代码放在这里。”

def rndpwd(l): 
    # Code goes here

总结

生成式AI编程工具背后的大型语言模型（LLMs）被设计用于从其训练数据中找到并推断出模式，将这些模式应用于现有语言，然后生成遵循这些模式的代码。鉴于这些模型的规模之大，它们可能会生成甚至尚不存在的代码序列。就像您会审查同事的代码一样，您应该始终评估、分析和验证由AI生成的代码。

第三方商业大型语言模型（LLM）提供商，如OpenAI的GPT4，通过简单的API调用使LLM的使用更加容易。然而，由于数据隐私和合规等各种原因，我们可能仍需要在企业内部部署或私有模型推理。

开源LLM的普及让我们私有化部署大语言模型称为可能，从而减少了对这些第三方提供商的依赖。

当我们将开源模型托管在本地或云端时，专用的计算能力成为一个关键考虑因素。虽然GPU实例可能是最佳选择，但成本也很容易一飞冲天， 再加上现在一卡难求， 想跑模型也变成了一个不简单的事情。

在这个指南中，我们将探讨如何使用CPU在本地Python中运行开源并经过轻量化的LLM模型，用于检索增强生成（Retrieval-augmented generation, 也称为Document Q&A）。而且我们将在这个项目中利用最新、高性能的Llama 2聊天模型。

Quantization(量化)简介

虽然LLM展现了出色的能力，但其运行所要求的计算和内存资源较高。为了应对这一问题，我们可以使用Quantization来压缩这些模型，以减少内存占用并加速推理计算过程，同时保持模型的性能和效果。

Quantization是一种将用于表示数字或值的位数减少的技术。在LLM的上下文中，它涉及通过将权重存储在较低精度的数据类型中来减少模型参数的精度。

由于它减小了模型大小，量化有助于在资源受限的设备上部署模型，例如仅有CPU但没有GPU的设备或嵌入式系统。

一种常见的方法是将模型权重从原始的16位浮点数值量化为较低精度的8位整数值。

工具和数据

下图展示了我们将在本项目中构建的Document Q&A应用程序的架构。

我们将在此项目中运行Document Q&A的文件是曼联足球俱乐部的2022年公开年度报告，共177页。

数据来源：Manchester United Plc (2022). 2022 Annual Report 2022 on Form 20-F. https://ir.manutd.com/~/media/Files/M/Manutd-IR/documents/manu-20f-2022-09-24.pdf (CC0: Public Domain, as SEC content is public domain and free to use)

此示例的运行环境配备了AMD Ryzen 5 5600X 6核CPU，16GB 内存（DDR4 3600）。虽然它还装了一块RTX 3060TI 8G显卡，但在本示例中不会使用它，因为我们将讨论如何仅使用CPU来运行模型。

一下是构建这个后端应用时将使用的工具：

LangChain:

LangChain是一个目前流行的用于开发LLM驱动的应用程序框架，它提供了各种集成接口和数据连接接口，允许我们链式编排不同的模块，以创建高级用例，如聊天机器人、数据分析和Document Q&A。

C Transformers:

C Transformers是提供一个Transformer模型的Python库，它使用GGML库C/C++绑定。说到这点，让我们首先了解一下GGML是什么。

ggml.ai团队开发的GGML库是一个为机器学习设计的Tensor Library，它可以在消费级硬件上高性能运行大模型。这是通过整数量化支持和内置优化算法实现的。

因此，LLM的GGML版本（以二进制格式量化过的模型）可以在CPU上高效地运行。鉴于我们在本项目中使用Python，我们将使用C Transformers库，其为GGML模型提供了Python绑定。

C Transformers支持一些常见的开源模型，包括目前流行的一些模型，如Llama、GPT4All-J、MPT和Falcon。

Sentence-Transformers嵌入模型

Sentence-transformers是一个Python库，提供了生成语句、文本和图像的嵌入（稠密向量表示 Dense Vector Representations）的简便方法。

它使用户能够生成100多种语言的关联语句，然后可以进行比较，找到具有相似含义的句子。

在这个项目中，我们将使用开源的all-MiniLM-L6-v2模型，因为它具有最佳的速度和出色的通用生成质量。

FAISS

Facebook AI Similarity Search (FAISS) 是一个专为高效的稠密向量(Dense Vector)相似性搜索和聚和类而设计的库。

给定一组输入，我们可以使用FAISS对它们进行索引，并利用其强大的语义搜索算法在索引内搜索最相似的向量。

虽然它在传统意义上不是一个完整的向量存储（像数据库管理系统），但它以优化的方式处理向量的存储，以实现高效的相邻搜索。

Poetry

在这个项目中，我们将使用Poetry来设置virtualenv并处理Python包管理，因为它易于使用且一致性较好。

之前使用过venv的话，我强烈推荐切换到Poetry，因为它可以使依赖管理更加高效和无缝。

开源LLM选择

开源LLM目前取得了巨大的进展，并且可以在Hugging Face的Open LLM排行榜上找到许多LLM。

基于以下考虑，我选择了最新的开源Llama-2–7B-Chat模型（GGML 8-bit）用于这个项目：

Model Type（Llama 2）

• C Transformers支持的开源模型。
• 根据Open LLM排行榜的排名（截至2023年7月），目前是多个指标中表现最好的模型。
• 相比早期的Llama模型，在之前的基准测试中表现出了巨大的改进。
• 在社区中被广泛提及和下载。

Model Size（7B）

• 考虑到我们执行的是Document Q&A任务，LLM主要用于对文档块进行相对简单的摘要。因此，7B模型大小符合我们的需求，因为在这个任务中我们技术上不需要过于庞大的模型（例如65B及以上）。

Find-tuned Version（Llama-2–7B-Chat）

• Llama-2–7B基本模型是用于文本补全的，因此缺乏在Document Q&A场景中实现最佳性能所需的微调。
• Llama-2–7B-Chat模型是我们目标场景的理想选择，因为它专为对话和问答而设计。
• 该模型包含了部分用于商业用途的授权。这是因为经过微调的Llama-2-Chat模型使用了公开可用的指令数据集和超过100万个人的注释。

Quantized Format（8-bit）

• 考虑到内存限制，8-bit GGML版本是合适的，因为它只需要9.6GB的内存大小。
• 8-bit格式的响应质量与16-bit相当。
• 原始的未量化16-bit模型需要约15GB的内存，这太接近16GB RAM限制了。
• 其他较小的量化格式（如4-bit和5-bit）也可用，但它们会以精度和响应质量为代价。

实现步骤

既然我们了解了各种组件，让我们逐步介绍如何构建Document Q&A应用程序。文中相关代码可以在此GitHub Repo中找到，所有依赖项都可以在requirements.txt文件中找到。

注意：由于已经有许多教程可供参考，我们不会展开讨论Document Q&A组件（例如文本分块、向量存储设置）的复杂性和细节。本文将专注于开源LLM和CPU推理方面。

第一步 — 处理数据并构建向量存储

在这一步骤中，将执行三个任务：

1. 数据导入和将文本拆为文本块(Chunks)
2. 加载嵌入模型（sentence-transformers）
3. 对块进行索引，并将其存储在FAISS向量存储中。

# File: db_build.py 
 
from langchain.vectorstores import FAISS 
from langchain.text_splitter import RecursiveCharacterTextSplitter 
from langchain.document_loaders import PyPDFLoader, DirectoryLoader 
from langchain.embeddings import HuggingFaceEmbeddings 
 
# Load PDF file from data path 
loader = DirectoryLoader('data/', 
                         glob="*.pdf", 
                         loader_cls=PyPDFLoader) 
documents = loader.load() 
 
# Split text from PDF into chunks 
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, 
                                               chunk_overlap=50) 
texts = text_splitter.split_documents(documents) 
 
# Load embeddings model 
embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2', 
                                   model_kwargs={'device': 'cpu'}) 
 
# Build and persist FAISS vector store 
vectorstore = FAISS.from_documents(texts, embeddings) 
vectorstore.save_local('vectorstore/db_faiss')

运行上述Python脚本后，向量存储将在本地目录中生成并保存为’vectorstore/db_faiss’，已准备好进行语义搜索和检索。

第二步 — 设置Prompt Template

考虑到我们使用的是Llama-2–7B-Chat模型，我们必须注意在这里使用的Prompt Template。

例如，OpenAI的GPT模型是为对话输入和消息输出而设计的。这意味着Prompt Template应该是类似于对话记录的格式（例如，分系统消息和用户消息）。

然而，在这里这样的模板就不适用用，因为我们的Llama 2模型没有专门针对这种类型的对话接口进行优化。相反，更适合使用经典的Prompt Template，如下所示：

# File: prompts.py 
 
qa_template = """Use the following pieces of information to answer the user's question. 
If you don't know the answer, just say that you don't know, don't try to make up an answer. 
Context: {context} 
Question: {question} 
Only return the helpful answer below and nothing else. 
Helpful answer: 
"""

注意：较小的LLM，如7B模型，对格式要求较为敏感。例如，当我修改Prompt Template的空格和缩进时，输出会稍有不同。

第三步 — 下载Llama-2–7B-Chat GGML二进制文件

由于我们将在本地运行LLM，我们需要下载量化的Llama-2–7B-Chat模型的二进制文件。

我们可以访问TheBloke的Llama-2–7B-Chat GGML页面，该页面托管在Hugging Face上，然后下载名为llama-2–7b-chat.ggmlv3.q8_0.bin的GGML 8-bit量化文件。

下载的8-bit量化模型的.bin文件可以保存在项目的某个子文件夹下，例如/models。

模型卡页面还显示了每种量化格式的更多信息和详细说明：

注意：要下载C Transformers支持的其他GGML量化模型，请访问HuggingFace上TheBloke的主页，搜索您想要的模型，并查找名称以“-GGML”结尾的链接。

第四步 — 设置LLM

为了使用我们下载的GGML模型，我们将用C Transformers和LangChain之间的集成。具体来说，我们将使用LangChain中的C Transformers LLM Wrapper，该Wrapper为GGML模型提供了统一的接口。

# File: llm.py 
from langchain.llms import CTransformers 
 
# Local CTransformers wrapper for Llama-2-7B-Chat 
llm = CTransformers(model='models/llama-2-7b-chat.ggmlv3.q8_0.bin', # Location of downloaded GGML model 
                    model_type='llama', # Model type Llama 
                    config={'max_new_tokens': 256, 
                            'temperature': 0.01})

我们可以为LLM定义许多配置选项，例如最大Token数、top k、Temperature和Repetition penalty。

注意：我将Temperature设置为0.01而不是0，因为当Temperature恰好为零时，我得到了奇怪的返回（例如，一长串重复的字母E）。

第五步 — 构建和初始化RetrievalQA

有了Prompt Template和准备好的C Transformers LLM，我们编写三个函数来构建LangChain的RetrievalQA对象，以便我们能够执行Document Q&A任务。

# File: utils.py 
from langchain import PromptTemplate 
from langchain.chains import RetrievalQA 
from langchain.embeddings import HuggingFaceEmbeddings 
from langchain.vectorstores import FAISS 
 
# Wrap prompt template in a PromptTemplate object 
def set_qa_prompt(): 
    prompt = PromptTemplate(template=qa_template, 
                            input_variables=['context', 'question']) 
    return prompt 
 
 
# Build RetrievalQA object 
def build_retrieval_qa(llm, prompt, vectordb): 
    dbqa = RetrievalQA.from_chain_type(llm=llm, 
                                       chain_type='stuff', 
                                       retriever=vectordb.as_retriever(search_kwargs={'k':2}), 
                                       return_source_documents=True, 
                                       chain_type_kwargs={'prompt': prompt}) 
    return dbqa 
 
 
# Instantiate QA object 
def setup_dbqa(): 
    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2", 
                                       model_kwargs={'device': 'cpu'}) 
    vectordb = FAISS.load_local('vectorstore/db_faiss', embeddings) 
    qa_prompt = set_qa_prompt() 
    dbqa = build_retrieval_qa(llm, qa_prompt, vectordb) 
 
    return dbqa

第六步 — 将组件合并到启动脚本中

接下来的步骤是将前面的各个组件合并到main.py脚本中。我们使用argparse模块，因为我们将从命令行传入用户查询到应用程序中。

考虑到我们将返回源文档，附加的代码将用于处理文档块，以获得更好的可视化显示。

为了评估CPU推理的速度，还使用了timeit模块。

# File: main.py 
import argparse 
import timeit 
 
if __name__ == "__main__": 
    parser = argparse.ArgumentParser() 
    parser.add_argument('input', type=str) 
    args = parser.parse_args() 
    start = timeit.default_timer() # Start timer 
 
    # Setup QA object 
    dbqa = setup_dbqa() 
     
    # Parse input from argparse into QA object 
    response = dbqa({'query': args.input}) 
    end = timeit.default_timer() # End timer 
 
    # Print document QA response 
    print(f'\nAnswer: {response["result"]}') 
    print('='*50) # Formatting separator 
 
    # Process source documents for better display 
    source_docs = response['source_documents'] 
    for i, doc in enumerate(source_docs): 
        print(f'\nSource Document {i+1}\n') 
        print(f'Source Text: {doc.page_content}') 
        print(f'Document Name: {doc.metadata["source"]}') 
        print(f'Page Number: {doc.metadata["page"]}\n') 
        print('='* 50) # Formatting separator 
         
    # Display time taken for CPU inference 
    print(f"Time to retrieve response: {end - start}")

第七步 — 运行示例查询

现在是时候对我们的应用程序进行测试了。在从项目目录加载virtualenv后，我们可以在命令行界面（CLI）中运行一个包含用户查询的命令。

例如，我们可以用以下命令询问阿迪达斯（曼彻斯特联全球技术赞助商）支付的最低保证金金额：

poetry run python main.py "How much is the minimum guarantee payable by adidas?"

注意：如果我们没有使用Poetry，可以省略前缀的poetry run。

结果

输出结果显示，我们成功地得到了对用户查询的正确响应（即7.5亿英镑），同时还显示了与查询语义相似的相关文档片段。

总共31秒的应用程序启动和生成响应时间相当不错，考虑到我们是在本地运行在AMD Ryzen 5600X上（虽然它是一款优秀的CPU，但目前并不是市场上最好的）。

考虑到在GPU上运行LLM推理（例如直接在HuggingFace上）也可能需要几十秒，这个结果更加令人印象深刻。

接下来的步骤

现在我们已经构建了一个在CPU推理上运行LLM的Document Q&A应用程序，我们可以采取许多激动人心的步骤来推进这个项目。

1. 使用Streamlit构建前端聊天界面，特别是因为它最近有两个重要的公告：将Streamlit与LangChain集成，并推出Streamlit ChatUI，可以轻松构建强大的聊天机器人界面。
2. 将应用程序Docker化并部署到云主机。虽然我们已经探索了本地推理，但应用程序很容易迁移到云端。我们还可以利用云上更强大的CPU实例来加速推理（例如，计算优化型的AWS EC2实例，如c5.4xlarge）。
3. 尝试使用稍大的LLM，如Llama 13B Chat模型。由于我们已经使用过7B模型，评估稍大型模型的性能是一个不错的想法，因为理论上它应该更准确，同时仍然保持占用适量内存。
4. 尝试较小的量化格式，如4位和5位（包括使用新的k-quant方法），以客观评估推理速度和响应质量的差异。
5. 利用本地GPU加速推理。如果我们想在C Transformers模型上测试使用GPU，可以通过在GPU上运行一些模型来实现。这应该是有用的，因为目前只有Llama模型类型支持GPU。
6. 评估使用vLLM，一个高吞吐量和内存高效的LLM推理和服务引擎。然而，使用vLLM需要使用GPU。

我将在未来的几周内致力于撰写关于上述想法的文章和项目，所以请继续关注更多富有洞察力的生成式AI内容！

你准备好发掘 ChatGPT 的全部潜力了吗？想象一下拥有一个AI工具，它能在很多方面帮助你 — — 从回答问题和创作有趣内容到提供个性化建议。这就是「Prompt Engineering」的用武之地 — — 一种有效且强大的方法，通过精心创建Prompt和指导，让 ChatGPT 的工作更出色。

在这篇文章中，我们将探索令人兴奋的Prompt Engineering世界，涵盖其基础、技巧、最佳实践和高级策略，甚至还能用来创建一个聊天机器人。如果你对语言模型的潜力感兴趣，这篇文章将成为你使用 ChatGPT 并获得最大收益的指南。

准备好揭开Prompt Engineering的秘密，改变你使用 ChatGPT 的方式了吗？让我们开始吧！

Prompt Engineering基础知识

想必我们无需再多介绍ChatGPT了， 如果您对ChatGPT还不了解的话， 请看之前的相关文章:

使用ChatGPT来帮助我们学习： 如何使用ChatGPT来学习任何你想要的知识

我们都听说ChatGPT正在彻底改变教育。但是，要充分发掘其潜力，需要了解它可以用来做什么以及如何使用它。为了帮助您实现这一目标，我们收集了使用ChatGPT进行学习的最佳实践（和Prompt）。

作为程序员， 我如何使用ChatGPT来帮我写代码

从快速学习到调试程序， 甚至将繁琐的工作自动化。

如何有效地使用ChatGPT帮助软件开发第二弹 — 释放代码的潜力

如果您不知道还有第一部分， 推荐先阅读之前篇

Prompt Engineering对于最大化 OpenAI 的语言模型 ChatGPT 的实用性至关重要。在这部分中，我们将介绍提示工程的基本概念，包括其定义、提示在与 ChatGPT 交互中的作用，以及影响提示选择的众多因素。

什么是Prompt Engineering？

一种通过ChatGPT获取想要的相关结果的交互过程被称为Prompt Engineering。它涉及一系列创建指令和输入，来控制模型的行为，塑造生成输出的质量和相关性。在一些场景下， 我们可以理解为Prompt是一种输入参数， 来控制模型的输出。

Prompt Engineering的重要性在于它可以提高ChatGPT的能力，并调整其对特定活动或目标的响应。用户可以通过提供精心设计的Prompt，最大化地解释他们的意图，并从模型中获得准确和与上下文相关的信息。这就像控制一台高性能汽车， 在熟悉这辆车的车上上， 能发挥这辆车的最大效能。

为什么Prompt对于ChatGPT的交互至关重要？

Prompt在用户和ChatGPT之间的交互中非常重要。它们为模型提供所需的上下文，使其能够创建相关的回答，并作为对话的起点。用户可以通过清晰准确的指令来引导ChatGPT朝着期望的结果发展。

根据研究，Prompt Engineering对语言模型的性能有着相当大的影响。精心设计的Prompt可以帮助防止有害或偏见的输出，提高生成回答的准确性，并对模型的行为有更多的控制。OpenAI在增强语言模型的Prompt Engineering方面进行的研究证明了这一点。

接下来我们来看下面两个查询及其相应的ChatGPT回复：

Prompt 1:

Prompt 2:

第二个Prompt产生了一个更具体和有意义的回答。

这个例子突显了提示工程中准确性和清晰性的重要性。

什么是Prompt类别？

Prompt是与AI语言模型进行无缝交流的重要工具。

为了创建高质量的提示，你首先需要了解它们是如何分类的。这样可以让你有效地构建它们，从而专注于特定的目标回答。

主要的提示类别包括：

1.信息检索的Prompt

这些提示旨在通过提出“What”和“How”问题来收集信息。它们非常适合从AI模型中提取具体细节或事实。例如：

• 素食有哪些健康益处？
• 我怎样才能提高工作效率？

2.基于指令的Prompt

基于指令的Prompt是指引AI模型执行特定任务的提示。这些提示类似于我们与Siri、Alexa或Google助手等语音助手进行交互的方式。例如：

• 下周二上午10点预约牙医。
• 找到通往机场最快的路线。

3. 提供上下文信息的Prompt

这些Prompt为AI模型提供上下文信息，帮助它更好地理解用户所期望的回答。通过提供背景信息，你可以从AI获得更准确和相关的答案。例如：

• 我对园艺一窍不通。有哪些适合初学者的容易种植的植物？
• 我想为我的女朋友策划一个浪漫的晚餐。你能提供一些建议和烘托氛围的Idea吗？

4. 比较型Prompt

比较型Prompt用于评估或比较不同的选项，帮助用户做出明智的决策。在权衡不同选择的利弊时，它们特别有帮助。例如：

• 租房和购房各有哪些利与弊？
• 电动车和传统汽油车的性能。

5. 寻求观点的Prompt

这些Prompt引导AI就给定话题发表意见或观点。它们有助于产生创意思路或进行发人深省的讨论。例如：

• AI对就业市场可能产生什么潜在影响？
• 如果Teleportation(隔空传送)技术成为现实，世界可能会如何变化？

6. 反思型Prompt

反思型Prompt帮助个人更深入地了解自己、自己的信念和行为。它们经常根据特定话题或个人经历鼓励自我成长和内省。你可能需要提供一些背景信息来获得理想的回答。例如：

• 我该如何建立自信，克服自我怀疑？
• 我可以采取哪些策略来保持健康的工作与生活平衡？

影响Prompt选择的因素有哪些？

在创建有效的Prompt时，需要考虑许多因素，这些因素影响着ChatGPT回答的质量、相关性和准确性。重要的因素包括：

1. 模型知识：了解ChatGPT的优势和劣势。即使是像ChatGPT这样的尖端模型，在特定任务上可能需要帮助，或者会产生错误的数据。这种了解有助于创建利用模型优势、最小化缺陷的提示。
2. 用户意图：理解用户的意图以生成相关的回答至关重要。提示应该清楚地反映用户的期望，让ChatGPT提供相关和正确的信息。
3. 清晰明确：确保提示清晰明确，以减少歧义或不确定性，这样可以避免产生糟糕的回答。
4. 领域特定性：在处理高度专业化的领域时，考虑使用领域特定的词汇或上下文，以引导模型得到预期的回答。增加上下文或示例有助于模型产生更准确、相关的结果。
5. 限制条件：确定是否需要任何限制（如回答长度或格式）来产生期望的结果。可以明确指定限制条件，比如字符限制或结构化格式，以帮助模型生成符合特定需求的回答。

考虑这些因素进行Prompt Engineering可以提高ChatGPT的功效，并确保生成的回答与期望的目标密切匹配。

值得注意的是，Prompt Engineering是一个持续的研究课题，不断地进行改进和完善，以增强语言模型（如ChatGPT）的互动性和实用性。

总结一下：

主要的提示步骤：

1. 确定问题或目标：清楚地说明你希望ChatGPT协助你的目的，以及你期望的回答类型。
   示例：为面向时尚行业年轻专业人士的营销活动生成吸引人的标题。
2. 添加相关关键词和短语：在Prompt中包含最相关的行业特定和主题相关术语，以帮助引导ChatGPT生成期望的输出。
   示例：为我们的运动鞋撰写有说服力的营销文案，重点关注舒适性、耐用性和性能。面向健身爱好者和运动员。包含诸如“性能”、“舒适性”、“耐用性”和“运动员”等关键词。
3. 撰写提示：用之前步骤中确定的关键词和短语构建简洁的Prompt，有效传达所需的信息和任务。
   示例：“创建一个引人注目的社交媒体帖子，突出我们新推出的有机护肤品系列的优势，强调‘天然’、‘滋养’、‘环保’和‘光滑肌肤’等成分。”
4. 测试、评估和迭代：使用ChatGPT生成回答，评估结果，并根据需要修改Prompt以获得期望的输出。重复这个过程，直到你创建了一个成功的Prompt，能够始终产生预期的回答。

优秀Prompt的要素:

优秀的输出主要取决于训练数据、模型参数和有效的Prompt。作用用户我们只能影响其中一个因素，那就是Prompt, 以下是构成一个好的Prompt的要素：

1. 清晰简明的语言，直截了当，没有歧义。
2. 为ChatGPT分配的角色，即你希望它在提示中扮演的角色。
3. 你提供的信息和示例，即你的输入。（ChatGPT可以参考之前的聊天历史中的信息和示例）
4. 你请求ChatGPT完成的具体任务，即你期望的输出。
5. 在收到初始回答后根据需要进行调整，即迭代，直到获得期望的输出。

Prompt Engineering技巧

这个章节，我们将探索几种Prompt技巧，可以用来优化Prompt Engineering，最大化与ChatGPT的交互效果。让我们深入了解这些技巧，理解它们的重要性。

清晰明确的指令

清晰明确的指令是有效Prompt Engineering的基础。通过提供明确的指导，用户可以提高ChatGPT回答的质量。OpenAI的研究表明，定义清晰的Prompt显著影响语言模型的性能。

Prompt 1:

Prompt 2:

使用明确的限制条件

在Prompt中加入明确的限制条件可以引导ChatGPT的思考过程，确保更准确、有理有据的回答。限制条件作为额外的指令，可以塑造模型的行为，提高生成输出的相关性。

例如，当寻求逐步指导时，加入限制条件，比如“请提供详细的、顺序的过程”，有助于ChatGPT生成连贯、易于遵循的指导。OpenAI的研究表明，使用明确的规则可以获得更可控、更符合预期的输出。

通过尝试不同的上下文和示例

上下文在Prompt Engineering中扮演着至关重要的角色。通过在Prompt中提供相关的上下文和示例，用户可以增强ChatGPT的理解能力，并引导它生成更准确、与上下文相关的回答。

例如，将相关的上下文融入提示中，在询问关于特定主题的信息时，能够帮助ChatGPT提供更有见地的答案。

Prompt 1:

Prompt 2:

充满上下文的Prompt可以引导ChatGPT生成与特定兴趣领域相一致的回答。

运用 System 1和System 2 问题

System 1和System 2 问题提供了一个平衡的Prompt Engineering方法。System 1问题引发快速、本能的回答，而System 2问题需要深思熟虑、详细的回答。将这两种类型的问题结合起来，可以为与ChatGPT的交互增添多样性和深度。

因此，在Prompt Engineering中运用System 1和System 2问题是一种影响ChatGPT给出回答类型的方法。

用户可以通过在Prompt中包含System 1和System 2问题，指导ChatGPT生成满足他们需求的回答。考虑以下示例来说明这个概念：

示例：旅行建议AI助手

Prompt： “作为一个旅游推荐助理，您的目标是为用户提供个性化和明智的旅游建议。请使用System 1 和System 2 问题来生成相关回复。System 1 问题应侧重于快速建议，而System 2 问题应探讨建议背后的原因。

System 1 问题 “巴黎有哪些热门旅游景点？

System 2 问题 “你能解释埃菲尔铁塔的历史意义及其建筑特点吗？

在这个示例中，System 1问题促使ChatGPT快速提供巴黎主要旅游景点的推荐。寻求简短旅行行程建议的用户将从简洁易懂的信息中受益。回答可能包括卢浮宫博物馆、巴黎圣母院和香榭丽舍大街等景点。

而System 2问题鼓励ChatGPT探索特定景点的历史重要性和建筑方面，比如埃菲尔铁塔。这样的回答对于想要更好地了解和深入了解该景点的用户非常有帮助。回答可能包括塔楼为1889年世界博览会而建的历史背景，居斯塔夫·埃菲尔的设计以及其著名的铁格子结构。

通过包含System 1和System 2问题，用户可以获得快速的推荐和更详细的解释。这使得旅行建议助理能够适应不同用户的口味，提供实用的建议，同时也满足对景点历史和建筑特色感兴趣的用户的好奇心。

控制输出长度

控制ChatGPT回答的长度是快速Prompt Engineering的一个关键组成部分。它使用户能够控制生成输出的详细程度和长度。考虑以下示例，看看如何管理输出的长度：

Prompt 1:

Prompt 2:

在这个回答中，ChatGPT展示了很强的冗长度，提供了详细的逐步食谱。它包含了额外的解释和建议，帮助用户完成烘焙过程。这种深度对于那些需要详细指导的人来说是合适的，特别是对于新手烘焙者或喜欢更全面方法的人来说。

这样，ChatGPT可以适应多样化的用户偏好，通过调节回答的冗长度来优化对话体验，使聊天机器人能够为用户的需求提供相关的答案，并加强与用户的联系。

Prompt Engineering 最佳实践

Prompt Engineering是一个动态的过程，需要充分的思考和实验，以获得最佳结果。在本节中，我们将看看Prompt Engineering的最佳实践，帮助用户在与ChatGPT的交互中获得最大的收益。让我们来了解这些实践，并看看它们的效果如何。

持续测试和改进

有效的Prompt Engineering在很大程度上依赖于持续测试和改进。用户可以通过定期Review输出并相应地调整Prompt来不断完善指令，提高ChatGPT回答的质量。

迭代 1:

迭代 2:

迭代 3:

意图与创意之间的平衡

在Prompt Engineering中，平衡用户的意图和模型本身创造力也至关重要。请看下面的提供写作灵感聊天机器人，它努力在促进创造力的同时提供适当的Prompt：

ChatGPT通过平衡匹配用户意图和提升模型创造力，给出了合适的Prompt，鼓励想象力，同时保持与用户的写作目标一致。

整合外部资源和API

利用外部资源和API是Prompt Engineering中的一项强大技术，它使得ChatGPT能够利用额外的信息并增强其回答能力。让我们通过一个示例来了解如何使用外部资源和API：

示例：天气信息助理

Prompt: “As a weather information chatbot, harness external resources and APIs to provide accurate and up-to-date weather data to users.”

User query: “Shanghai今天天气如何?”

这个聊天机器人可以与外部的天气API（比如Weather.com）进行整合，从而提供准确的天气信息。通过调用API，聊天机器人可以获取指定地点的实时天气数据。

API 集成

import requests 
 
def get_weather(city): 
    api_key = "YOUR_API_KEY" 
    url = f"https://api.weatherapi.com/v1/current.json?key={api_key}&q={city}" 
    response = requests.get(url) 
    data = response.json() 
    return data["current"]["condition"]["text"], data["current"]["temp_c"]

上面的get_weather()函数演示了与WeatherAPI的集成示例，它返回给定城市的天气状况和摄氏温度。

回答模版：

city = "Shanghai" 
weather_condition, temperature = get_weather(city) 
response = f"The weather in {city} today is {weather_condition}. The temperature is {temperature}°C."

回答结果:

“The weather in Shanghai today is partly cloudy. The temperature is 22°C.”

通过利用外部资源和API，聊天机器人可以检索准确的天气信息，并将其融入到回答中。这为用户提供了适合其指定地点的实时天气更新。

与外部资源和API的集成使得ChatGPT能够获取超出其训练数据的大量信息，从而为用户的查询提供更有价值和可靠的回答。

OpenAI API 示例

OpenAI API允许开发人员将ChatGPT集成到他们的应用程序、产品或服务中。以下是一个示例，展示了如何使用OpenAI API：

import openai 
 
# Set up your OpenAI API credentials 
openai.api_key = 'YOUR_API_KEY' 
 
# Define a function for interacting with ChatGPT 
def ask_chatbot(question, chat_history=None): 
    if chat_history is None: 
        chat_history = [] 
 
    # Format the input for the API call 
    input_text = '\n'.join(chat_history + [f'User: {question}']) 
 
    # Call the OpenAI API to generate a response 
    response = openai.Completion.create( 
        engine='text-davinci-003', 
        prompt=input_text, 
        max_tokens=50, 
        temperature=0.7, 
        n=1, 
        stop=None, 
        temperature=0.7 
    ) 
 
    # Extract the generated response from the API response 
    answer = response.choices[0].text.strip() 
 
    # Append the user's question and the chatbot's answer to the chat history 
    chat_history.append(f'User: {question}') 
    chat_history.append(f'Chatbot: {answer}') 
 
    return answer 
 
# Example usage 
chat_history = [] 
user_question = "What is the capital of France?" 
response = ask_chatbot(user_question, chat_history) 
print(response)

在这个示例中，我们定义了ask_chatbot()函数，它接收用户的问题和一个可选的聊天历史作为输入。该函数对聊天历史和用户问题进行格式化，然后使用openai.Completion.create()方法向OpenAI API发起API调用。

API的响应包含来自ChatGPT生成的回答。我们从响应中提取出答案，并将用户的问题和聊天机器人的回答添加到聊天历史中。最后，生成的答案被返回。

借助ChatGPT OpenAI API，开发人员可以将ChatGPT的功能集成到他们的应用程序中，使用户可以与聊天机器人进行交互，并根据他们的查询接收回答。

避开任何偏见和在道德准则下使用

ChatGPT必须在道德和无偏见的前提下使用。以下是一个重要实例：

示例：AI辅助的求职者筛选

想象一下，有一个可以使用ChatGPT来分析面试回答， 并筛选求职者的AI系统。筛选过程必须是有道德的和没有偏见的。

以下步骤可以减少偏见，确保公平性：

1. 训练数据多元化：使用各种种族、性别和族裔的数据来优化ChatGPT。从一开始就解决训练数据的偏见是至关重要的，因为它可能导致偏见。
2. 偏见评估：定期评估模型的回答，以人工的方式识别和减少偏见。使用平衡和平等机会来查看模型的建议是否具备平衡因素（如性别或种族）的影响。进行调整以减少偏见。
3. 透明的准则：向人类审查人员和开发者传达系统准则。这些准则应强调公正、道德和避免偏见。明确指示在筛选过程中避免偏袒或歧视特定群体。
4. 人工干预审查：让人类分析系统的回答。这一步骤有助于发现任何模型的偏见，并确保人类可以考虑上下文并做出公平的决定。
5. 持续监控和反馈：持续监测系统的性能，并从用户和审阅员那里收集反馈。检查系统输出是否存在偏见和意外效果。反馈循环有助于迅速解决问题。
6. 多元化的审阅员团队：确保负责审查和优化系统输出的团队成员来自不同的背景。多样化的团队可以发现和解决同质团体可能忽略的偏见。

这些做法有助于AI辅助的求职者筛选系统避免偏见，根据求职者的技能和资格进行评估。

进阶的Prompt Engineering策略

Prompt Engineering可以更提升一步，包括创新策略，以进一步优化ChatGPT的性能和适应性。本节将介绍一些高级的Prompt Engineering策略，如温度和Token控制、多轮对话的提示链接、针对特定领域应用的提示修改以及处理混淆或矛盾的用户输入。

Temperature和Token管理

Temperature和Token控制是调整ChatGPT行为的有效方法。用户可以通过Temperature控制改变生成输出的随机性。较低的Temperature，如0.2，会产生更加聚焦和确定性的回答，而较高的Temperature，如1.0，会产生更多变化和探索性的结果。这个值也代表了控制模型的创造力和理性。

OpenAI的研究揭示了Temperature控制对ChatGPT回答多样性的影响。通过尝试不同的Temperature设置，用户可以在提供易懂的答案和将新特性融入生成的回答之间达到理想的平衡。

Prompt 1:

Prompt 2:

Token控制则需要指定最大Token数，以限制答案的长度。这使得用户可以控制ChatGPT输出的冗长程度，得到简洁明了的回答。通过设定适当的Token限制，用户可以确保ChatGPT提供与他们期望的回答长度相对应的答案。

Prompt Chain和多轮对话

Prompt Chain和多轮对话可以实现更加交互式和动态的ChatGPT交流。用户可以将多个Prompt链接在一起，形成连续的对话流程。每个提示可以引用之前的输入或ChatGPT先前的回答，从而实现丰富上下文的对话。

通过使用Prompt Chain，用户可以创建更加对话式的体验，并与ChatGPT进行反复的互动。这种技术适用于需要多步指令或进行详细讨论的任务。

为特定领域的应用调整Prompt

为特定领域的应用调整Prompt是Prompt Engineering的重要方法。它涉及将Prompt量身定制给特定行业或领域，以确保回答相关准确。让我们通过一个示例来说明如何为特定领域的应用调整Prompt：

示例：医疗诊断AI助理

提示：“为医疗诊断AI助理设计一个Prompt，帮助用户评估他们的症状并提供初步建议。”

为医疗诊断AI助理调整Prompt需要加入相关的医学术语、症状和诊断考虑因素。

Prompt：“请描述您的症状和医疗历史，AI助理将根据提供的信息提供初步评估。请注意，此评估不能替代专业医疗建议。如果您遇到医疗紧急情况，请立即联系急救服务。”

用户：“我头痛、发烧和喉咙痛。”

调整后的Prompt考虑了用户的症状，并告知他们评估的局限性。AI助理生成的回答可以根据提供的信息提供初步建议：

回答：“根据您头痛、发烧和喉咙痛的症状，可能表明您患了普通的病毒感染，比如流感，或者可能是喉炎。请咨询医疗专业人员进行确切诊断和适当治疗非常重要。在此期间，您可以休息，保持水分，服用非处方止痛药缓解症状。如果您的症状加剧或持续，请寻求医疗救助进行进一步评估。”

通过将Prompt调整为医疗诊断AI助理，回答与特定领域的应用相符，并提供了初步建议，同时强调了专业医疗建议的重要性。

模糊处理或解决矛盾的用户输入

Prompt Engineering需要处理一些模糊的概念或矛盾的用户输入。ChatGPT必须仔细处理此类输入并做出有意义的回答。让我们通过一个示例来说明如何实现：

示例：餐厅推荐聊天机器人

Prompt：“作为餐厅推荐聊天机器人，处理模糊或矛盾的用户输入，以确保准确和有帮助的回答。”

用户：“我想找一家在城里有素食和牛排选项的餐厅。”

在这种情况下，用户希望有牛排和素食选项。聊天机器人可以进行澄清：

回答：“是的！我很乐意帮您找到一家餐厅。您更倾向于素食为主的餐厅，还是希望有多种选择，包括牛排？”

聊天机器人请求澄清以更好地理解用户的请求并提供更准确的推荐。

用户：“我喜欢一家有素食和牛排菜肴的餐厅。”

用户明确了他们的偏好后，聊天机器人可以回答：

回答：“太好了！我推荐“The Grill House”餐厅，因为他们提供素食和牛肉菜肴。他们在丰富的菜单上提供美味的素食和牛肉菜肴。祝您用餐愉快！”

通过积极与用户互动并寻求澄清，聊天机器人处理了初始查询的模糊性，理解了用户的意愿，并推荐了符合他们要求的餐厅。

处理矛盾的用户输入也是类似的。聊天机器人可以澄清用户的目标，并在用户希望获得价格便宜但奢华的餐厅时

案例：真实世界中的Prompt Engineering

在实际应用中，Prompt Engineering产生了积极的效果。我们来看看在不同领域的几个Prompt Engineering案例：

客户支持聊天机器人

客户支持聊天机器人提升客户服务和响应速度。Prompt Engineering可以提高聊天机器人的准确性和效率，增强客户体验。

Prompt Engineering帮助聊天机器人学习并回应客户输入，使交互更加个性化和有效。

案例：HubSpot Chatbot Builder，可以预约会议、链接到KB，并与工单系统集成。

内容创作和编辑

内容创作和编辑也需要Prompt Engineering。ChatGPT帮助用户撰写优秀的博客文章、电子邮件和创意作品。

通过提供具体详细的Prompt，用户可以帮助ChatGPT开发符合他们风格、语调和目标的文本。提示可以提供背景信息、示例或明确的限制，以确保生成的内容满足要求。

OpenAI进行了Prompt Engineering的研究，以提高内容的连贯性和相关性，通过尝试不同的Prompt和节省编辑时间，使用户生成更有吸引力和主题相关的文本。

特定领域知识检索

Prompt Engineering可以高效地检索特定领域的知识。ChatGPT可以训练大量的特定领域数据，以提供准确和相关的主题信息。

用户可以通过定制Prompt和添加关键词或上下文来引导ChatGPT检索特定领域的知识。在医疗、法律、金融和技术等行业，准确的信息至关重要。

Prompt Engineering策略促进了特定领域知识的检索，为用户提供准确和最新的信息。

交互式故事叙述和游戏

Prompt Engineering使交互式故事叙述和游戏变得更加有趣。ChatGPT根据用户的输入作出回应并推动故事发展。

我之前发了一篇文章在

ChatGPT在游戏行业中的应用： 增强的叙事功能和互动性

随着游戏行业的不断发展，用于为玩家创造沉浸式互动体验的工具和技术也在不断发展。最近在业界掀起波澜的这样一个工具是ChatGPT，这是一个由OpenAI开发的强大语言模型。在这篇文章中，我们将仔细研究ChatGPT是如何被用来增强游戏世界中的…

用户可以使用Prompt构建沉浸式的故事和游戏，引入故事元素、用户选择或游戏机制。Prompt Chain和多回合对话实现了丰富的叙事和游戏交互。

案例：OpenAI的AI Dungeon展示了Prompt Engineering如何改变交互式故事叙述和游戏。AI Dungeon允许用户通过提示共同参与动态的叙事。

ChatGPT Prompt Engineering对开发人员的意义

Deep Learning AI最近推出了一门名为“ChatGPT Prompt Engineering for Developers”的课程，由Isa Fulford和Andrew Ng(吴恩达)主讲。

Short Courses

Take your generative AI skills to the next level with short courses from DeepLearning.AI. Enroll today to learn…

在课程中，他们强调作为开发人员工具的大语言模型（LLMs）的潜力，利用API调用LLMs来进行快速软件应用开发，这一点目前还未得到足够的重视。他们的目标是分享有效利用LLMs的可能性和最佳实践。课程涵盖了软件开发的提示最佳实践，以及日常使用案例，如摘要、推理、转换和扩展，并演示了如何使用LLM构建聊天机器人。

课程中主要使用OpenAI的ChatGPT模型，特别是GPT 3.5 Turbo，并使用Python（尤其在Jupyter Notebook中）进行演示。

以下是一些学到的内容：

两个原则：

原则1：写清晰明确的指令

表达清晰明确的指令至关重要，可以有效地引导模型，并减少出现无关或错误的回答的可能性。避免将清晰的提示与简短的提示混淆，因为较长的提示通常会提供更多的清晰度和上下文，从而得到详细和相关的输出。

• 策略1：使用分隔符来指示输入的不同部分，例如三引号（’’’），三个反引号（’*’），三个短划线（’ — -’），尖括号（‹ ›），或XML标签（‹tag› ‹/tag›）。分隔符还有助于防止Prompt Injection(提示注入)，即前后矛盾的用户指令可能会误导模型。

text = f""" 
You should express what you want a model to do by \  
providing instructions that are as clear and \  
specific as you can possibly make them. \  
This will guide the model towards the desired output, \  
and reduce the chances of receiving irrelevant \  
or incorrect responses. Don't confuse writing a \  
clear prompt with writing a short prompt. \  
In many cases, longer prompts provide more clarity \  
and context for the model, which can lead to \  
more detailed and relevant outputs. 
""" 
 
prompt = f""" 
Summarize the text delimited by triple backticks \  
into a single sentence. 
```{text}``` 
"""

• 策略2：请求结构化输出，例如HTML或JSON格式，以便更轻松地解析模型的回答。这样可以使得模型的回答更易于处理和提取信息。

prompt = f""" 
Generate a list of three made-up book titles along \ with their authors and genres. 
Provide them in JSON format with the following keys: book_id, title, author, genre. 
""" 
response = get completion (prompt) 
print (response)

• 策略3：验证任务前提是否满足。首先Prompt模型检查这些前提条件，并指出任何未满足的条件，而不需要尝试完整的任务完成。考虑潜在的边缘情况，确保模型可以适当地处理它们，避免出现意外错误或结果。这样可以增加模型的可靠性和鲁棒性。

• 策略4：利用few-shot提示，在要求模型执行所需任务之前，提供已成功执行任务的示例。通过示例，让模型了解如何处理类似的任务，并为其提供必要的指导。这样可以加速模型的学习和适应性，使其更容易理解用户的意图并生成准确的响应。

prompt = f""" 
Your task is to answer in a consistent style. 
 
<child>: Teach me about patience. 
 
<grandparent>: The river that carves the deepest \ valley flows from a modest spring; the \ grandest symphony originates from a single note; \ the most intricate tapestry begins with a solitary thread. 
 
<child>: Teach me about resilience. 
""" 
response = get completion (prompt) 
print (response)

原则2：给模型足够的思考时间

允许模型有足够的时间来思考和推理问题，以防止推理错误和过早的结论。复杂的任务可能需要逐步指导或一系列相关的推理步骤，然后模型才能提供最终的答案。

• 策略1：明确任务的完成步骤，特别是当直接回答困难时。就像人类解决问题一样，要求模型在提供最终解决方案之前进行一系列适当的推理步骤。这样可以确保模型在生成答案之前进行充分的思考和推理，从而提高其响应的准确性和合理性。

prompt 2 = f""" 
Your task is to perform the following actions: 
1 - Summarize the following text delimited by <> with 1 sentence. 
2 - Translate the summary into French. 
3 - List each name in the French summary. 
4 - Output a json object that contains the following keys: french_ summary, num names. 
 
Use the following format: 
Text: <text to summarize> 
Summary: <summary> 
Translation: <summary translation> 
Names: <list of names in Italian summary> 
Output JSON: <ison with summary and num names> 
 
Text: <{text!> 
response = get_completion (prompt_2) 
print "InCompletion for prompt 2:") 
print (response)

• 策略2：指示模型在得出结论之前找到解决方案。明确地指示模型在提供答案之前进行推理和思考通常会产生更好的结果。这种方法可以让模型有足够的时间来处理和得出准确的响应。

通过遵循这些原则和策略，开发人员可以优化他们对LLM的使用，并在软件开发中实现预期的结果。这样可以提高模型的性能和灵活性，从而更好地满足用户的需求。

迭代式Prompt开发：

迭代式Prompt开发的过程类似于编程实践。它涉及尝试不同的方法，根据需要进行改进和重试。以下是涉及的步骤：

1. 尝试一个解决方案。
2. 分析结果，找出与预期结果不符的地方。
3. 澄清说明并给予更多时间进行思考。
4. 使用一批示例来优化Prompt。
5. 重复这个过程。

在课程示例中，教师们提出了一个案例研究，涉及从产品说明书中生成营销文案。他们通过在每一步中优化Prompt来迭代式地解决了三个关键问题：

问题1：文本过长 -> 解决方案：将文本限制在最多50个字以内。

问题2：关注不相关的细节 -> 解决方案：加入目标受众，比如“描述适用于家具零售商…”

问题3：缺少尺寸表 -> 解决方案：将所有内容格式化为HTML。

具备的能力：

阅读总结：

大型语言模型已被广泛用于文本摘要。您可以通过提供具体的Prompt来请求关于价格和价值的摘要。

prompt = f""" 
Your task is to generate a short summary of a product \ 
review from an ecommerce site to give feedback to the \ 
pricing deparmtment, responsible for determining the \ 
price of the product.   
 
Summarize the review below, delimited by triple  
backticks, in at most 30 words, and focusing on any aspects \ 
that are relevant to the price and perceived value.  
 
Review: ```{prod_review}``` 
"""

而且您还可以编写一个循环来对多个文本进行总结：

reviews = [review_1, review_2, review_3, review_4] 
 
for i in range(len(reviews)): 
    prompt = f""" 
    Your task is to generate a short summary of a product \  
    review from an ecommerce site.  
 
    Summarize the review below, delimited by triple \ 
    backticks in at most 20 words.  
 
    Review: ```{reviews[i]}``` 
    """ 
 
    response = get_completion(prompt) 
    print(i, response, "\n")

推理：

大型语言模型可以在没有特定训练的情况下推断出各种方面。它们可以确定情感、情绪，提取产品和公司名称，找出主题等等。

转换：

大型语言模型在文本转换任务方面表现出色，包括语言翻译、拼写和语法检查、语气调整以及格式转换。

prompt = f""" 
Translate the following text to French and Spanish and English pirate: \ 
```I want to order a basketball``` 
""" 
 
response = get completion (prompt) 
print response

扩展：

大型语言模型可以生成根据每位客户的评价定制的个性化客户服务电子邮件。

prompt = f""" 
You are a customer service AI assistant. 
Your task is to send an email reply to a valued customer. 
Given the customer email delimited by ```,\ 
Generate a reply to thank the customer for their review. 
If the sentiment is positive or neutral, thank them for \ 
their review. 
If the sentiment is negative, apologize and suggest that \ 
they can reach out to customer service. 
Make sure to use specific details from the review. 
Write in a concise and professional tone. 
Sign the email as `AI customer agent`. 
Customer review: ```{review}``` 
Review sentiment: (sentiment} 
""" 
 
response = get completion (prompt, temperature=0.7) 
print(response)

开发聊天机器人：

利用大型语言模型的其中一个令人着迷的方面是可以轻松创建定制的聊天机器人。ChatGPT的网页界面提供了一个由强大的语言模型支持的对话平台。然而，真正令人兴奋的是利用大型语言模型的能力来构建自己的聊天机器人，比如用于餐厅的AI客服代理或AI点餐机器人。

在这个案例中，我们将这个聊天机器人称为“OrderBot”。目标是自动收集用户提示和助手回应，以构建这个高效的“OrderBot”。主要步骤是定义一个实用函数。该函数帮助收集用户消息，消除手动输入的需要。从用户界面收集的提示然后被添加到一个名为“context”的列表中。随后，对于每一次交互，使用这个上下文来调用模型。

模型的回应被加入到上下文中，确保模型和用户的消息都被保留，有助于上下文的不断增长。这些信息的积累使得模型能够确定适当的行动。

最后，设置和执行用户界面来显示OrderBot。上下文中包含系统消息，其中包含菜单，它在与语言模型的每次交互中保持一致。随着更多的交互发生，上下文不断发展，保持全面的对话记录。

总结

Prompt Engineering对于ChatGPT来说是一个Game-Changer。通过掌握这一技巧，您可以塑造和引导语言模型的回应，以满足您的特定需求。

Prompt Engineering的未来前景一片光明，持续的研究和合作推动着该领域的创新。随着语言模型的不断发展，Prompt Engineering将在发掘它们的全部潜力方面发挥关键作用。

ChatGPT的Prompt Engineering开启了无限的可能性。通过实施有效的技巧和探索先进的策略，我们可以改变与语言模型的互动方式。Prompt Engineering改变了客户服务聊天机器人、内容开发和游戏，促进了AI与人类的协作。

FAQ

什么是提Prompt Engineering？

Prompt Engineering是设计有效的Prompt和指令，用于将用户意图传达给像ChatGPT这样的语言模型的过程。它有助于从模型获取准确、相关和有用的响应。

为什么Prompt Engineering对ChatGPT很重要？

Prompt Engineering对于最大化ChatGPT的效果至关重要。通过设计精心制作的Prompt，用户可以引导模型生成更准确、相关的输出，使其成为各种应用的有价值的工具。

优秀的Prompt Engineering技巧有哪些？

优秀的Prompt Engineering技巧包括：

• 提供明确和具体的指示
• 使用明确的约束条件
• 尝试使用上下文和示例
• 利用System 1和System 2问题
• 控制输出的冗长程度

如何改进我的Prompt以获得更好的效果？

为了改进您的Prompt，您可以：

• 进行反复测试和调整
• 平衡用户意图和模型创意
• 使用外部资源和API增强ChatGPT的能力
• 确保在提示和输出中避免偏见

这里还有一个ChatGPT Prompt Cheat Sheet，可以帮助您编写更好的Prompt。

高级的Prompt Engineering策略有哪些？

高级的Prompt Engineering策略包括：

• 通过控制temperature和token设置来调整随机性和响应长度
• 通过Prompt Chain创建多轮对话
• 将Prompt调整为特定领域的应用
• 处理模糊概念或前后矛盾的用户输入

后记

感谢您的阅读， 本文很长， 我也知道， 您能读到这里， 说明您意识到Prompt Engineering的重要性， 并希望能掌握它的技巧， 本人不才， 也在学习中， 作为一名开发人员， 可能更容易理解和掌握工程的技巧， 例如迭代、链式(Chain)和控制参数。 这边文章大部分是翻译自下面这篇文章

https://www.imaginarycloud.com/blog/chatgpt-prompt-engineering/

非常感谢原文作者， 我从中学习到了很多， 我也用原文中的很多Prompt的技巧， 来完成了本文中的一些示例。 如果你想交流Prompt Engineering和Prompt的技巧， 欢迎与我联系。

JavaScript is not available.

Edit description

如果您不知道还有第一部分， 推荐先阅读之前篇

如何有效地使用ChatGPT帮助软件开发

近年来，像ChatGPT这样的AI语言模型已经成为软件开发人员越来越有价值的工具。这些模型可以通过自动执行某些任务和提供有价值的见解来显著提高生产力。在这篇文章中，我们将讨论如何有效地将ChatGPT用于软件开发，探索它的好处，并提供例子来…

最近，OpenAI发布了GPT-4模型，让AI的功能变得更加强大和多样化。这一进步引起了广泛的好奇和担忧，特别是在程序员群体中。人们开始在搜索引擎上询问”ChatGPT是否会取代程序员？”，这成为了热门的搜索推荐。这反映了那些创造了ChatGPT这类工具的人们对于它是否会取代他们的担心。

这种好奇和担忧是有道理的，尽管程度可能不同。如今，AI已经在网站开发到游戏设计等各种应用中展现了其创建代码的能力。更有甚者，AI甚至被用于创造更先进的AI系统，这种技术被称为自动机器学习（AutoML），它允许机器在没有或几乎没有人工干预的情况下创建复杂的模型并优化算法。

尽管AI目前还不太可能创造比自己更智能、更强大的版本，但增强版会继续创造更强大的版本，形成一个无限循环，直至达到无限智能和强大。然而，值得注意的是，在不久的将来，AI的编码能力可能会接近甚至与人类持平，尽管可能无法超越人类。

现阶段，我们可以利用像ChatGPT这样的AI来辅助编程，从而更高效地编写代码，提高工作效率。虽然AI可能不会在编码方面完全取代人类，但它可以成为我们的有力帮手，助力我们更好地应对日益复杂的编程任务。让我们拥抱这种技术，并将其应用于我们的工作，随着时间的推移，我们可以期待AI与人类共同推动编程领域的进步。

使用ChatGPT来编程

开发人员可以利用多种方式使用ChatGPT进行编程，特别是在头脑风暴和生成可以修改和完善的代码框架方面。ChatGPT的自然语言生成代码能力改变了编码的规则，它是整合机器与人类之间语言鸿沟的重要一步。

以下是一些我们可以使用ChatGPT进行编程和开发的方法：

1. 生成代码 Generate Code：ChatGPT可以根据我们给出的提示生成代码，帮助我们快速获得初步的实现。
2. 完成和修改代码 Complte and modify code：当我们遇到代码的片段或结构需要完善时，ChatGPT可以辅助我们进行修改和补充。
3. 调试代码 Debug：ChatGPT有助于找出代码中的错误和问题，从而更高效地进行调试。
4. 翻译和多语言支持：ChatGPT可以帮助我们将代码从一种编程语言转换为另一种，节省我们手动翻译的时间和精力。
5. 代码注释：我们可以向ChatGPT询问特定代码的功能和作用，它能够用简洁的自然语言解释代码的含义。

此外，我们还可以将ChatGPT应用于以下场景：

1. 作为Linux终端命令行解释器：ChatGPT可以用作Linux终端，执行我们发送的命令和任务。
2. 作为SQL命令行解释器：ChatGPT可以作为SQL命令行，帮助我们快速查询和操作数据库。

通过更详细地探究上述用例，我们可以更好地了解如何充分发挥ChatGPT在编码过程中的作用，并提高我们的编程效率。让我们充分利用这一技术，推动编码和开发领域的进步。

使用ChatGPT进行编程的技巧

在开始使用ChatGPT进行编程之前，学习一些重要的ChatGPT编码技巧和窍门将对您从中获得最大收益非常有用。以下是一些关于如何使用ChatGPT来生成更可用、功能更强、优化更好的代码的技巧：

1. 分解成最小功能单元：尽可能将代码或编程思想分解成最小的功能单元，以减少错误。然后，您可以将它们组合成一个功能性的整体。如果您向ChatGPT询问冗长的代码，可能会因为上下文窗口较短而得到一个明显错误的代码，或者无法按照您的要求正常工作。
2. 辅助函数和避免注释：为了克服响应中的文本限制，请让ChatGPT使用辅助函数，避免注释和解释。这样，您可以复制代码并直接使用。如果ChatGPT给出的代码不完整，您可以要求它继续或继续生成更多代码。
3. 缩短描述：使用不减少细节的简短形式来代替冗长的描述，例如将 “用C#写一段代码……” 改为 “C#: ……”。
4. 提出更多问题以建立上下文：通常情况下，ChatGPT可能会生成通用或不相关的回复。因此，您可以在提示中附加 “提出更多问题以帮助您建立上下文”。这样，ChatGPT会向您提出相关问题，您可以回答这些问题以获得更准确的答案。
5. 要求交叉检查：在生成代码后，您可以要求ChatGPT对生成的代码进行交叉检查，以确保代码的正确性和合理性。

这些技巧将有助于您更好地利用ChatGPT的编码能力，使您在编程过程中更高效且准确地获得所需代码。不断探索和练习，将使您在使用ChatGPT进行编码时越来越熟练。

生成代码

ChatGPT就像一个编程小助手，可以帮助我们用任何编程语言编写简单的代码。但并不意味着我们可以随意输入一些文字，然后它就会给我们完整、精细、优化的代码，可以直接发布。然而，我们可以采取一些方法来让它生成更符合我们要求的答案。

对于ChatGPT来说，上下文非常重要。比如，我们先问：“什么是JavaScript？”然后再问：“给我一个用JavaScript创建的应用程序的例子”，接着再问：“展示一个用JavaScript制造手机振动的应用程序”，这样比直接问最后一个问题更好。因为有时候它会回答说它只是一个语言模型，不能做这个或那个。

总的来说，ChatGPT是个很有用的工具，可以帮助我们在编程时更加顺利，但要注意如何提问以及给它提供足够的上下文，这样才能得到我们更期望的回答。

编写一个正则表达式，从文本文件中提取所有日期。

通常， 如果不明确具体的语言， ChatGPT会默认使用Python.

编写复利计算器的Javascript代码。

如果不明确是函数的话， 只说Javascript的话， ChatGPT会混合HTML和Javascript来给出答案， 这样的好处是， 新手直接copy & paste代码就可以使用， 但是， 对于专业的开发者来说， 我们可以直接让ChatGPT给出一个Javascript函数。

使用Javascript实现一个复利计算器函数

Debug

在代码调试方面，ChatGPT也是非常有用的应用。一项研究发现，ChatGPT在修复代码错误方面与深度学习方法CoCoNut和Codex的表现相当。但在某些方面，它确实有一些优势。

ChatGPT的区别在于，它不仅提供代码的修复，还提供解释，并通过对话系统进一步获取更多信息。通过提供更多的提示和细节，可以提高它的成功率。

如果我们想检查代码的执行效果， 可以要求ChatGPT显示输出结果

代码翻译

ChatGPT还可以用于将代码从一种语言翻译成另一种语言。也许您更擅长一种语言，但需要在另一种语言中完成任务，或者只是想在另一种语言中测试代码。又或者您希望在另一个项目中使用这段代码。然后，您可以使用ChatGPT将代码翻译成所需的语言。

下面是上面生成的Python代码翻译成Javascript的版本。

代码注释, 使用自然语言来解释代码

ChatGPT可以用简单自然语言（英文、中文或任何其他语言）解释代码。对于初学者学习编程语言或对某种语言不熟悉的人来说，这非常有帮助。另一个使用场景是，如果您有一行您不知道功能的代码，您可以输入这段代码到ChatGPT中，以找出它是做什么的。

您也可以使用ChatGPT来解码正则表达式，并向您解释它们的作用。

Linux 命令行模拟器

ChatGPT可以用来模拟Linux终端。通过要求它表现得像一个终端，您可以将ChatGPT转换成一个终端。

您还可以通过在提示中明确规定规则，指示ChatGPT以特定方式表现，或者不执行某些操作。这样，您可以明确地告知ChatGPT在模拟终端时应该如何行事。

I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply with the terminal output inside one unique code block, and nothing else. do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English, I will do so by putting text inside curly brackets {like this}.

如果要退出模拟器的状态， 你只需要输入

exit

SQL 命令行模拟器

ChatGPT可以用来模拟SQL命令行来运行SQL语句

Act as an SQL terminal in front of an example database. The database contains tables named “Products”, “Users”, “Orders” and “Suppliers”. I will type queries and you will reply with what the terminal would show. I want you to reply with a table of query results in a single code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so in curly braces {like this}.

同样， 如果要退出模拟器状态， 只需要输入

exit

有更多的方式可以使用ChatGPT进行编程和其他开发任务，我们在此未详细展开。随着您的频繁使用，您将发现更多功能和独特的用途。

开发人员可以将ChatGPT作为助手，提高生产力并优化工作流程。ChatGPT不会取代程序员（至少目前不会），但它提高了对程序员的期望，对他们提出了更多要求。因此，对于编码者和开发者来说，利用所有可用的工具不仅能保持与时俱进，还能走在前沿。

在ChatGPT的帮助下编码可以使程序员更加高效，并有助于解决难题和自动化繁琐的任务。但它不会使您成为一个专业的程序员，这其实是一件好事，因为如果它能做到，那么它将取代您的角色。

在编程中使用ChatGPT可以让您成为一个更高效的程序员，帮助您克服困难，自动化繁琐的任务。但它不会让您变成专业的程序员，这其实是一件好事，因为如果它能做到，那么它将取代您的角色。

一些辅助Coding的AI工具

使用ChatGPT进行编码只是使用人工智能进行编码的众多方式之一。以下是一些可供您使用的用于编码的ChatGPT替代方案，通过少量输入实现更多功能。

1. OpenAI Codex：一种将自然语言翻译为代码的AI系统。Codex精通十几种编程语言，可以解释自然语言中的简单命令并代表用户执行，使得在现有应用程序中构建自然语言接口成为可能。
2. Copilot：由GitHub开发并使用OpenAI Codex的编程伴侣。实时建议代码和整个函数，直接从编辑器中提供。
3. AlphaCode：由DeepMind开发的AI代码生成工具。它使用基于Transformer的语言模型，根据对问题的自然语言描述生成代码。
4. DeepGenX：一个免费且开源的代码生成器，作为Visual Studio Code的扩展功能提供。
5. SourceAI：一种基于AI的工具，可以从人类语言描述中生成任何编程语言的代码。它还可以简化、查找错误并修复和调试代码。
6. Tabnine：Tabnine的AI代码补全IDE插件根据数百万个程序以及您自己的上下文完成代码，使开发者能够更好、更快地编写代码。
7. Codeium：一种AI编码助手，可以提供AI生成的超过20种编程语言的自动完成代码，并与各种IDE（如VSCode、Colab、Vim等）直接集成。
8. StarCoder: 一个由Hugging Face开发的一个VSCode插件， 可以实时建议代码和生成代码。

通过研究Docker镜像的内部结构，对Docker镜像进行逆向工程。

TL;DR

在本文中， 我们将通过理解Docker镜像如何存储数据， 以及如何使用工具查看镜像方方面面的信息来逆向工程一个Docker镜像; 以及如何使用Python的Docker API来构建一个类似Dedockify的工具来创建Dockerfile。

简介

随着Docker Hub和TreeScale等公共Docker Registry变得越来越流行，管理员和开发人员下载不明来源的Docker镜像变得越来越常见。在大多数情况下，便利性胜过可预知的风险。在通常情况下，当一个Docker镜像被发布后，它会直接出现在列表中、git仓库中或通过相关链接提供。有时候镜像并没有提供Dockerfile。即使提供了Dockerfile，我们也很难保证预构建的镜像就是由给出的Dockerfile构建的，这些镜像对于我们而言， 就是一个黑盒子，我们甚至无法保证其使用的安全性。

也许您并不关心安全漏洞, 您可能只是想更新平时用的比较多的镜像， 例如nginx，使其能够运行在最新版本的Ubuntu上。又或者，你会想要发布一个更优化的镜像，因为另一个发行版的编译器更适合在编译时生成二进制文件。

不管什么原因，我们都需要将镜像恢复成Dockerfile的选项。Docker镜像并不是一个黑盒子。重建Dockerfile所需的大部分信息都可以被检索到。通过观察Docker镜像内部并检查其内部结构，我们将能够从一个任意的预编译容器中重建一个Dockerfile。

在本文中，我们将展示如何使用两个工具从镜像中重建Dockerfile： 前面提及的Dedockify是一个的Python脚本，Dive是一个Docker镜像浏览工具。使用的基本流程如下。

使用 Dive

为了快速了解镜像是如何组成的，我们将使用Dive学习一些高级的、可能对我们来说不熟悉的Docker概念。Dive工具可以检查Docker镜像的每一层(Layer)。

让我们创建一个简单的Dockerfile，用于测试。

把这个代码段直接贴到装有Docker的linux主机命令行中：

mkdir $HOME/test1 
cd $HOME/test1 
cat > Dockerfile << EOF ; touch testfile1 testfile2 testfile3 
FROM scratch 
COPY testfile1 / 
COPY testfile2 / 
COPY testfile3 / 
EOF

输入以上内容并回车，我们就创建了一个新的Dockerfile，并在同一目录下填充了3个零字节的测试文件。

$ ls 
Dockerfile  testfile1  testfile2  testfile3

现在，让我们使用这个Dockerfile构建一个镜像，并标记为example1。

docker build . -t example1

构建example1镜像时会产生以下输出：

Sending build context to Docker daemon  3.584kB 
Step 1/4 : FROM scratch 
 ---> 
Step 2/4 : COPY testfile1 / 
 ---> a9cc49948e40 
Step 3/4 : COPY testfile2 / 
 ---> 84acff3a5554 
Step 4/4 : COPY testfile3 / 
 ---> 374e0127c1bc 
Successfully built 374e0127c1bc 
Successfully tagged example1:latest

现在我们刚构建的example1镜像就已经完成了：

$ docker images 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE 
example1            latest              374e0127c1bc        31 seconds ago      0B

由于没有可执行文件，所以该镜像将无法运行。我们仅将其作为一个简化的示例，说明如何在Docker镜像中查看存储层(Layer)。

我们可以从镜像的大小看出，这里没有源镜像。我们使用scratch来代替源镜像，它让Docker使用一个零字节的空白镜像作为源镜像。然后，我们通过复制三个额外的零字节测试文件来修改空白镜像，并将修改标记为example1。

现在，让我们用Dive来查看这个新镜像。

docker run --rm -it \ 
    -v /var/run/docker.sock:/var/run/docker.sock \ 
    wagoodman/dive:latest example1

执行上述命令将自动从Docker Hub拉取wagoodman/dive镜像，并产生Dive的输出。

Unable to find image 'wagoodman/dive:latest' locally 
latest: Pulling from wagoodman/dive 
89d9c30c1d48: Pull complete 
5ac8ae86f99b: Pull complete 
f10575f61141: Pull complete 
Digest: sha256:2d3be9e9362ecdcb04bf3afdd402a785b877e3bcca3d2fc6e10a83d99ce0955f 
Status: Downloaded newer image for wagoodman/dive:latest 
Image Source: docker://example-image 
Fetching image... (this can take a while for large images) 
Analyzing image... 
Building cache...

在列表中上下选择镜像的三个图层，在右侧显示的目录树中找到三个文件。

我们可以看到右侧的内容随着选择每一层而变化。当每个文件被复制到一个空白的Docker从头镜像时，它被存储为一个新的层。

如果您注意到的话， 我们还可以看到生成每个层所使用的命令。我们还可以看到源文件和更新文件的哈希值。

如果我们注意到Command:部分，我们应该看到以下内容：

#(nop) COPY file:e3c862873fa89cbf2870e2afb7f411d5367d37a4aea01f2620f7314d3370edcc in / 
#(nop) COPY file:2a949ad55eee33f6191c82c4554fe83e069d84e9d9d8802f5584c34e79e5622c in / 
#(nop) COPY file:aa717ff85b39d3ed034eed42bc1186230cfca081010d9dde956468decdf8bf20 in /

每个命令都提供了Dockerfile中用于生成镜像的原始命令。但是，原始文件名丢失了。看来恢复该信息的唯一方法是观察目标文件系统的变化，或者根据其他细节进行推断。稍后再详述。

Docker History

除了像dive这样的第三方工具之外，我们还可以随手使用的工具是docker history。如果我们在example1镜像上使用docker history命令，就可以查看我们在Dockerfile中创建该镜像时使用的条目。

docker history example1

运行玩应该得到以下结果：

IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT 
374e0127c1bc        25 minutes ago      /bin/sh -c #(nop) COPY file:aa717ff85b39d3ed…   0B 
84acff3a5554        25 minutes ago      /bin/sh -c #(nop) COPY file:2a949ad55eee33f6…   0B 
a9cc49948e40        25 minutes ago      /bin/sh -c #(nop) COPY file:e3c862873fa89cbf…   0B

CREATED BY列中的所有内容都被截断了。这些是通过Bourne shell传递的Dockerfile指令。这些信息对于重新创建我们的Dockerfile可能很有用，虽然在这里被截断了，但是我们也可以通过使用no-trunc选项来查看完整的信息：

$ docker history example1 --no-trunc 
IMAGE                                                                     CREATED             CREATED BY                                                                                           SIZE                COMMENT 
sha256:374e0127c1bc51bca9330c01a9956be163850162f3c9f3be0340bb142bc57d81   29 minutes ago      /bin/sh -c #(nop) COPY file:aa717ff85b39d3ed034eed42bc1186230cfca081010d9dde956468decdf8bf20 in /    0B 
sha256:84acff3a5554aea9a3a98549286347dd466d46db6aa7c2e13bb77f0012490cef   29 minutes ago      /bin/sh -c #(nop) COPY file:2a949ad55eee33f6191c82c4554fe83e069d84e9d9d8802f5584c34e79e5622c in /    0B 
sha256:a9cc49948e40d15166b06dab42ea0e388f9905dfdddee7092f9f291d481467fc   29 minutes ago      /bin/sh -c #(nop) COPY file:e3c862873fa89cbf2870e2afb7f411d5367d37a4aea01f2620f7314d3370edcc in /    0B

虽然这有一些有用的信息，但从命令行还原它可能还有些挑战。我们也可以使用docker inspect。然而，在本文中，我们将专注于使用Python的Docker Engine API。

使用 Python Docker Engine API

Docker发布了一个针对Docker Engine API的Python库，允许在Python中管理Docker。在下面的示例中，我们可以通过运行下面的Python 3代码来恢复与docker history类似的信息：

#!/usr/bin/python3 
 
import docker 
 
cli = docker.APIClient(base_url='unix://var/run/docker.sock') 
print (cli.history('example1'))

输出结果如下:

[{'Comment': '', 'Created': 1583008507, 'CreatedBy': '/bin/sh -c #(nop) COPY file:aa717ff85b39d3ed034eed42bc1186230cfca081010d9dde956468decdf8bf20 in / ', 'Id': 'sha256:374e0127c1bc51bca9330c01a9956be163850162f3c9f3be0340bb142bc57d81', 'Size': 0, 'Tags': ['example:latest']}, {'Comment': '', 'Created': 1583008507, 'CreatedBy': '/bin/sh -c #(nop) COPY file:2a949ad55eee33f6191c82c4554fe83e069d84e9d9d8802f5584c34e79e5622c in / ', 'Id': 'sha256:84acff3a5554aea9a3a98549286347dd466d46db6aa7c2e13bb77f0012490cef', 'Size': 0, 'Tags': None}, {'Comment': '', 'Created': 1583008507, 'CreatedBy': '/bin/sh -c #(nop) COPY file:e3c862873fa89cbf2870e2afb7f411d5367d37a4aea01f2620f7314d3370edcc in / ', 'Id': 'sha256:a9cc49948e40d15166b06dab42ea0e388f9905dfdddee7092f9f291d481467fc', 'Size': 0, 'Tags': None}]

根据输出结果，我们可以发现， 如果重建Dockerfile的内容， 只需要解析所有相关数据并将其顺序反转一下。但是正如我们之前看到的，我们也注意到在COPY指令中有一些被哈希(Hash)过的内容。如前所述，这里的被哈希过的内容代表从层外使用的文件名。这些信息无法直接恢复。然而，正如我们在 Dive 中看到的，当我们搜索对该镜像层所做的更改时，我们可以推断出这些名称。有时，在原始复制指令将目标文件名作为目标的情况下，也可以推断出这些文件名。在其他情况下，文件名可能并不重要，允许我们使用任意文件名。而在其他情况下，虽然更难评估，但我们可以推断出在系统中其他地方被反向引用的文件名，例如在脚本或配置文件等支持依赖中。但无论如何，搜索层之间的所有变化是最可靠的。

Dedockify

让我们再深入几步。为了更好地逆向该镜像转换为Dockerfile，我们需要解析所有内容并将其重新格式化为可读的形式。为了简化我们的实验， 以下代码已经可以从GitHub上的Dedockify仓库获取。感谢 LanikSJ 所有基础工作和编码。

from sys import argv 
import docker 
 
class ImageNotFound(Exception): 
    pass 
 
class MainObj: 
    def __init__(self): 
        super(MainObj, self).__init__() 
        self.commands = [] 
        self.cli = docker.APIClient(base_url='unix://var/run/docker.sock') 
        self._get_image(argv[-1]) 
        self.hist = self.cli.history(self.img['RepoTags'][0]) 
        self._parse_history() 
        self.commands.reverse() 
        self._print_commands() 
 
    def _print_commands(self): 
        for i in self.commands: 
            print(i) 
 
    def _get_image(self, img_hash): 
        images = self.cli.images() 
        for i in images: 
            if img_hash in i['Id']: 
                self.img = i 
                return 
        raise ImageNotFound("Image {} not found\n".format(img_hash)) 
 
    def _insert_step(self, step): 
        if "#(nop)" in step: 
            to_add = step.split("#(nop) ")[1] 
        else: 
            to_add = ("RUN {}".format(step)) 
        to_add = to_add.replace("&&", "\\\n    &&") 
        self.commands.append(to_add.strip(' ')) 
 
    def _parse_history(self, rec=False): 
        first_tag = False 
        actual_tag = False 
        for i in self.hist: 
            if i['Tags']: 
                actual_tag = i['Tags'][0] 
                if first_tag and not rec: 
                    break 
                first_tag = True 
            self._insert_step(i['CreatedBy']) 
        if not rec: 
            self.commands.append("FROM {}".format(actual_tag)) 
 
__main__ = MainObj()

生成初始 Dockerfile

如果您已经完成了这一步，那么在您实验的主机上应该有两个镜像：wagoodman/dive和我们自定义的example1镜像。

$ docker images 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE 
example1            latest              374e0127c1bc        42 minutes ago      0B 
wagoodman/dive      latest              4d9ce0be7689        2 weeks ago         83.6MB

在我们使用dedockify对example1镜像中运行此命令，最终将产生以下结果：

$ python3 dedockify.py 374e0127c1bc 
FROM example1:latest 
COPY file:e3c862873fa89cbf2870e2afb7f411d5367d37a4aea01f2620f7314d3370edcc in / 
COPY file:2a949ad55eee33f6191c82c4554fe83e069d84e9d9d8802f5584c34e79e5622c in / 
COPY file:aa717ff85b39d3ed034eed42bc1186230cfca081010d9dde956468decdf8bf20 in /

我们提取到的信息与之前使用 Dive 解析镜像时看到的几乎一致。注意FROM指令显示的是example1:late而不是scratch。在这种情况下，我们的代码对基础镜像做出了不正确的假设。

作为对比， 我们对wagoodman/dive镜像做同样的处理.

$ python3 dedockify.py 4d9ce0be7689 
FROM wagoodman/dive:latest 
ADD file:fe1f09249227e2da2089afb4d07e16cbf832eeb804120074acd2b8192876cd28 in / 
CMD ["/bin/sh"] 
ARG DOCKER_CLI_VERSION= 
RUN |1 DOCKER_CLI_VERSION=19.03.1 /bin/sh -c wget -O- https://download.docker.com/linux/static/stable/x86_64/docker-${DOCKER_CLI_VERSION}.tgz |     tar -xzf - docker/docker --strip-component=1 \ 
    &&     mv docker /usr/local/bin 
COPY file:8385774b036879eb290175cc42a388877142f8abf1342382c4d0496b6a659034 in /usr/local/bin/ 
ENTRYPOINT ["/usr/local/bin/dive"]

与example1相比，这个镜像显示了更多的错误。我们看到ADD指令就在FROM指令之前。我们的代码再次做出了错误的假设。我们不知道ADD指令添加了什么。然而，我们可以直观地做出假设，即我们不确定基础镜像是什么。ADD指令可能是用来提取本地的tar文件到根目录。也有可能是用这种方法加载另一个基础镜像。

Dedockify limitation testing

让我们通过创建一个示例Dockerfile来进行实验，在这个示例中我们明确定义了基础镜像。和我们之前做的一样，在一个空目录下，直接从命令行运行下面的代码。

mkdir $HOME/test2 
cd $HOME/test2 
cat > Dockerfile << EOF ; touch testfile1 testfile2 testfile3 
FROM ubuntu:latest 
RUN mkdir testdir1 
COPY testfile1 /testdir1 
RUN mkdir testdir2 
COPY testfile2 /testdir2 
RUN mkdir testdir3 
COPY testfile3 /testdir3 
EOF

然后build镜像，将我们的新镜像标记为example2。这将创建一个与之前类似的镜像，只不过不使用scratch，而是使用ubuntu:latest作为基础镜像。

$ docker build . -t example2 
Sending build context to Docker daemon  3.584kB 
Step 1/7 : FROM ubuntu:latest 
 ---> 72300a873c2c 
Step 2/7 : RUN mkdir testdir1 
 ---> Using cache 
 ---> 4110037ae26d 
Step 3/7 : COPY testfile1 /testdir1 
 ---> Using cache 
 ---> e4adf6dc5677 
Step 4/7 : RUN mkdir testdir2 
 ---> Using cache 
 ---> 22d301b39a57 
Step 5/7 : COPY testfile2 /testdir2 
 ---> Using cache 
 ---> f60e5f378e13 
Step 6/7 : RUN mkdir testdir3 
 ---> Using cache 
 ---> cec486378382 
Step 7/7 : COPY testfile3 /testdir3 
 ---> Using cache 
 ---> 05651f084d67 
Successfully built 05651f084d67 
Successfully tagged example2:latest

由于我们现在有了一个稍微复杂一些的Dockerfile来重建，而且我们也有了生成这个镜像所使用的Dockerfile，因此我们可以做一个对比。

$ docker images 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE 
example2            latest              05651f084d67        2 minutes ago       64.2MB 
example1            latest              374e0127c1bc        1 hour ago          0B 
ubuntu              latest              72300a873c2c        9 days ago          64.2MB 
wagoodman/dive      latest              4d9ce0be7689        3 weeks ago         83.6MB

运行dedockify脚本

$ python3 dedockify.py 05651f084d67 
FROM ubuntu:latest 
RUN /bin/sh -c mkdir testdir1 
COPY file:cc4f6e89a1bc3e3c361a1c6de5acc64d3bac297f0b99aa75af737981a19bc9d6 in /testdir1 
RUN /bin/sh -c mkdir testdir2 
COPY file:a04cdcdf5fd077a994fe5427a04f6b9a52288af02dad44bb1f8025ecf209b339 in /testdir2 
RUN /bin/sh -c mkdir testdir3 
COPY file:2ed8ccde7cd97bc95ca15f0ec24ec447484a8761fa901df6032742e8f1a2a191 in /testdir3

这与最初的Dockerfile非常吻合。这次没有ADD指令，而FROM指令也是正确的。只要我们的基础镜像是在原始Dockerfile中定义的，并且避免使用scratch或者避免使用ADD指令从tar文件创建基础镜像，我们应该能够比较准确地重建Dockerfile。然而，我们仍然不知道被复制的原始文件的名称。

任意 Dockerfile 重建

现在，让我们尝试使用我们已经讨论过的工具，以正确的方式逆向工程一个Docker容器。我们将使用的容器在上面的示例基础上进行了修改。我们之前的Dockerfile被修改为example3。通过添加一个小的二进制可执行文件，该镜像已具备运行的功能。在Dedockify的GitHub仓库中可以找到源代码。由于这个镜像非常小，我们不需要构建或拉取它。我们可以通过下面的代码段将整个容器复制粘贴到我们的Docker环境中，来展示我们的命令行技巧 :)

uudecode << EOF | zcat | docker load 
begin-base64 600 - 
H4sICMicXV4AA2V4YW1wbGUzLnRhcgDtXVtvG8cVVnp56UN/QJ/YDQokgETN 
zJkrgTykjgsbDSzDURMkshDM5YzFhiJVkkpiCELzH/pP+tYfkf/UsxRNXdxI 
spe7lqv5IJF7PTM7Z87MmY9nZxgL2qG1DkN2nkXmtTecQwYrMMfsBHgXgFuV 
eXLCI5c26sxdNHQsie2Nm8GYZEYp+l7g6vdim4MWBrgyBjaY4MbIjZ66hezG 
OJ7N/ZSyMp1M5tddd9P5qw/3noA11f+XD5998XjnybVpcMa0lNfoH67oHxiI 
jV4nhXjP9c/7701WC1pAY/v/+2wyvimNG+zfgLpi/0KbYv+d4KQapmpQNa0G 
1WZ15Kc4npMsr7JUjGGMyLUzPEXJc1RCWqFkTtoEL5TgEaLSKlmOiXHnUSlK 
jYsQSFacop9jnTHuDNtinP52GRss/r6pL5iM5344xum3tJWHL6rBSfVoMpuP 
/SHSXXTFZ5NDuuB8/28znJ5tfTqf+3jwxTwNx9Ug+9EMLxybHM9fP4jT6erg 
7vzlanvnCMeX5Sz2dsYRV0cejr+vBuPj0WizenCYXm0+PvQvlhn7cjI6PsTZ 
qzNfTabfDccvPhsuc/twPJ++PJoM66I9u2Jn/Ofj4Wgl6nMfcLS8/XSzmtBm 
NRqOj3+sTm+h/8b2P/IvcdqvbeiX07je/uXr/h9oZor9dwF/dHQbF74R3sz/ 
F1RfuKbLi//fAWr993846C/+J0f/aCONRR9/g/4vbXNQShb7LygoKGgTTDkP 
1tiEUvkgJajgnTZRA0pAplFqZ1m02hqXjc4+aaVTztx4pzywfvPxH7X1V/0/ 
oZgu7X8XOKn8NB4M5xjnx9N6ROIPk5ZnI6y7P67aq55+uvvok+3j2XR7NIl+ 
tD0Lw/Hgwv5q9/zEYuNslz6q/f85MJsd0CBVD4SHEDhGkM4LDIqHQN4JjU5s 
5NqiJguRAr3nKpgICoRhyLNiCgHQOLxhfLdN7teVMd7e4uD2AY5Gkzpv14/2 
VuPgegyvDA3aOATr5cJkJUs0tMsRacytE6MsGZnp/piCEMaiijHmJJOIihvN 
bh5WX0zh/7kqkA5od3t2QI+yFenjw4/Gk6OPe7Wqnuw++/rpzuMnu7295xdU 
9bzar29/X6rPyenpRZZFMMG2GGwxsStgoPhAQF8KrZ1grqZb0iR+R5Xie5zO 
hpPxgpbpM+hrOnUwnM0nU1LY3sm1AnnfOXCgDDPfnDM834aX9XOclXZvK/aW 
Jf3VzrO/fvb4WW97jjPS95RXp5vXyxd9Qd0MSCnsLeQ/2Hn6dS8PRzgAIbLL 
TiBEJ9Ej8hRZEmCURW6CcTaD8+h18BhtdsrJIFDGmBigS6w3HPfqTNbCeO8W 
2SQjVBK4lW9RDOIW8hUZv+PG8XdWDOI2xWA4mYGkKvYWxQC3kO+YdMYxod5Z 
McDNxQB9Zpkg38iJNymG2uxvFi005+RJwRsVQAAIkmURmaF+gwUXvAZjApis 
tWaSJyWFoAaKOS1DFJrKR0omQSSNVvO6ABaNz20e/mITc0MOe9c1vJsVHh7N 
X3674CKrwXx6jKf7l6jQzar233Ld8lXzl0d1E724eFY3bsOcvx2mWd14Lttt 
riUXQXJAZFJn5MLriMHJTA6yT44zHZjHQJ2qZM5watCpBeeevFdMdANJXUkC 
7ZMxjCq7TI6cbW+zUkEpqj/RMrBeWInCUuFqj3QZTxays9RrBNT+XBJDh2Qw 
wQkfqXcAqjZK5RA5SNIJzywKSTKTMGiYjkoknwJjzgVg1vBwLilYbbwhFzsz 
LYTTwqNgRiMEZhMYK7zztZ9gmHUZap8/0WOROCXRenUhT1Q8IlhltBbOihhR 
ZhOtoucgwVRolD3DkqprS6bHZzlbmxMNOBJGRYVxLsmDcSGZJBkTjkdlEtW3 
IKj4nA0oUJHDYgP5MZQ3qjHKZCrDqJSylvwZhAtPF5PRMfJEt4I0kjvms/Qq 
U4VVnp6O6jD3PJpaujKcLqJqaNF5TlrR5lxS5jQ2IfVRv22MAhbInjAaiNIp 
zkSGCAacVmAj0IPWDVoKPFCjQMXi0VX7p7eh4N8phI70kElxeg7vhJIKZYpa 
qOy9J9Vpck3Qkx2I2qOMIUrSQ46GKrzkqHRb8R+cF/63CzTWfyvxH8LI8vtP 
JyjxH/cbje1/DfEfWvDX4j8YL/bfBZbxH02rQYnZ6DBmY51obP/txH8oUX7/ 
7QSv+LU2g0DezP/nVF+EBij+fxdY6b/FIJC6PN4s/kOqWv/F/gsKCgrag2Jg 
EIxFl3RyIWQB2bjkDIiYFeTIUuLJy6SNNUG4wKPl3GeXEgSfWuL/BNTxv6X/ 
bx+N9d/O+18gVen/u0Dh/+43Gtt/K+9/gWDF/jvBkv9rWg0uvf/lBSZQEqIi 
YUoB50E7iU4JFD4ESbcok5Kq6SWbIWjFpbFSCOmUYaxwiR1yiY3tvxX+T3JR 
3v/sBK8Cy+4O/yfO+L/y/lcnWOn/rvF/hf8vKCgoaBXGQgwYvEKWwNmY0euo 
As/cks/mFGMgBI+BfD7jaJtrHaMnhx1ZMAF9a/M/6dL/d4HG+m9r/qfS/3eC 
wv/dbzS2/7bmfyr23wmW/F/TanCR/7PKBZAyeI7SuGDqd0Y9ahVYZj6nJFFq 
pZS2UieBDAC05HRxNBKE06nwfx3yf43tv6X5n3iJ/+0Er96ovHP8X/H/O8FK 
/3eN/yu//xUUFBS0iqbOekv8nzSs9P9doLH+23n/V4ky/1cnKPzf/UZj+2+H 
/wNd7L8TLPm/NXB2K/5vDbGEhf/riv9rbP/t8H/Ayvt/naDE/xX9L/S/mrxv 
/Wnc7P9f1P+C/5OyxP8WFBQUtIqmizW1Ff9X+v9u0Fj/Lc3/Z4r/3wkK/3e/ 
0dj+W4r/K/P/dIMl/7eGNRtX/N8aYgkL/9cV/9fY/lua/0+xYv9doMT/Ff0v 
9L9atWL9abwV/1fi/wsKCgpaRdPJetqK/6vX/y39f/torP+W4v94+f2vExT+ 
736jsf23FP+niv13glf8X/M5+1b8X1lL5H3i/5rafzv8n9Bl/a9OcPfW/1jy 
f8X/7wQr/a/WMF5/Gm/F/xX+v6CgoKBVJPK8tUkQIUjIXCXMBoJj0oPO3Btu 
jJc86SyRWaFFDOhQ8QxKJ8uya2n9D6bK+h+doLH+25n/j/My/0cnKPzf/UZj 
+2/O/wmQr63/a0r8TzdY8n9Nq8FF/o+xoB1a6zBk51lkXpMADhmswByzE+Bd 
AG5V5skJj1zaSKm4aOhYEpf4P8EE22KwxcSugIHiAwF9KbR2grlLRGCdsKrf 
XuUQrJe25hYlS5SRHDFpoxNDACOzDxhToCpmUcUYc5JJRMWNZjfzihdTuGsc 
41719NPdR59sH8+m26NJ9KPtWRiOBxf2V7vnJxYbZ7v0Ue0vScq9qt7dnh3Q 
o2xF+vjwo/Hk6ONezUc+2X329dOdx092e3vPq21/dLR9gKPR5Hm1X9/+itic 
HXih9EB4CIFjBOm8wKB4CIxMnRkbubaokRoGgd5zFUwEBcIw5FkxRbpC4/AG 
frRO/gpHunchT3WGfoEtPTk93azSJH5Hqv4ep7PhZLxgm/sM+vqsItx9Wnmd 
Kr/MS9919S3Jbj+NB8M5xvnxtM61P0y6tst3uJ72+4bG/X9z/l+9Pv4DXd7/ 
6Qa1sbWdxhuP/znXqsT/doJVY9tiGrX9X6t/Y67w/9SPlPF/J/jnw8//8sFq 
78Fvf7Xx640/0Hf9/xs68h9OG//+/c8//am38cHGv37+6VFdWTZ7P0ymo/TH 
3727jBcUFBQUNMKhHw8zzub9W/B4b4sb/H8O0lzyBemIEuX9n06wd1I9WFId 
FVPOgzU2oVQ+SAkqeKdN1IASaKiPUrsFr2aNy0Znn8hNTzlz453ywBZ1iIbf 
z/BosutfzOrRPP7oD49GCIORryNM6iH95/WIcXGyaaTg+eCTUl1fJBsJW9+y 
uCRsfXPskbD1LdhRl9na3v4lYU1530vC1sdLVPun+8VP/SVMyVZnw/lkOsRZ 
W2nc9PsvB7ja/pNBlPa/C5ysWuia61420mv4Pej0tNhcQUFBwV3GfwHMszUX 
AMIAAA== 
==== 
EOF

直接从命令行运行后会加载一个新的镜像 example3:latest。

$ docker images 
REPOSITORY TAG IMAGE ID CREATED SIZE 
example3 latest 059a3878de45 5 minutes ago 63B

现在，让我们尝试重建Dockerfile。

$ python3 dedockify.py 059a3878de45 
FROM example3:latest 
WORKDIR /testdir1 
COPY file:322f9f92e3c94eaee1dc0d23758e17b798f39aea6baec8f9594b2e4ccd03e9d0 in testfile1 
WORKDIR /testdir2 
COPY file:322f9f92e3c94eaee1dc0d23758e17b798f39aea6baec8f9594b2e4ccd03e9d0 in testfile2 
WORKDIR /testdir3 
COPY file:322f9f92e3c94eaee1dc0d23758e17b798f39aea6baec8f9594b2e4ccd03e9d0 in testfile3 
WORKDIR /app 
COPY file:b33b40f2c07ced0b9ba6377b37f666041d542205e0964bc26dc0440432d6e861 in hello 
ENTRYPOINT ["/app/hello"]

这为我们提供了一个基础Dockerfile。由于example3:latest是这个镜像的名称，我们可以从上下文假设它使用了`scratch`。现在，我们需要看看有哪些文件被复制到了/testdir1、/testdir2、/testdir3和/app。让我们在Dive中运行这个镜像，看看如何恢复丢失的数据。

docker run - rm -it \ 
 -v /var/run/docker.sock:/var/run/docker.sock \ 
 wagoodman/dive:latest example3:latest

如果您向下选择到最后一层，您将能够看到所有丢失的数据填充到右侧的目录树中。每个目录都复制了名为testfile1、testfile2和testfile3的零字节文件。在最后一层中，一个名为hello的63字节文件被复制到了/app目录中。

让我们恢复这些文件！由于无法直接从镜像中复制文件，因此我们需要先创建一个容器。

$ docker run -td --name example3 example3:latest 
6fdca182a128df7a76e618931c85a67e14a73adc69ad23782bc9a5dc29420a27

现在，让我们使用下面从Dive恢复的路径和文件名将我们需要的文件从容器复制到主机。

mkdir $HOME/test3 
cd $HOME/test3 
docker cp example3:/testdir1/testfile1 . 
docker cp example3:/testdir2/testfile2 . 
docker cp example3:/testdir3/testfile3 . 
docker cp example3:/app/hello .

我们可能得先检查我们的容器是否仍在运行。

$ docker ps 
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 
6fdca182a128 example3:latest "/app/hello" 2 minutes ago Up 2 minutes wizardly_lamport

如果容器由于某种原因没有运行，没关系。我们可以验证它的状态，看看它是否已经停止。

$ docker container ls -a

我们还可以查看运行日志。

$ docker logs 6fdca182a128 
Hello, world!

它似乎在运行一个输出Hello, world!程序。实际上，在这种情况下，Hello, world!程序并不是被设计成始终运行的。在19.03.6版本的Docker中，可能存在一个错误，导致程序无法正常终止。目前这是可以接受的。容器可以活动或停止；应用程序不需要持久化来恢复我们需要的任何数据。处于任何状态的容器都只需要从我们正在提取数据的源镜像中生成。

通过运行恢复的可执行文件来验证其行为，我们应该看到以下内容：

$ ./hello 
Hello, world!

使用我们之前生成的Dockerfile，我们可以更新它以包含所有新的细节。这包括将FROM指令更新为从头开始，以及我们在使用Dive探索时发现的所有文件名。

FROM scratch 
WORKDIR /testdir1 
COPY testfile1 . 
WORKDIR /testdir2 
COPY testfile2 . 
WORKDIR /testdir3 
COPY testfile3 . 
WORKDIR /app 
COPY hello . 
ENTRYPOINT ["/app/hello"]

再次，将所有文件合并到一个共享文件夹中，我们就可以运行我们逆向工程的Dockerfile了。

让我们先构建一个镜像。

$ docker build . -t example3:recovered 
Sending build context to Docker daemon 4.608kB 
Step 1/10 : FROM scratch 
 - -> 
Step 2/10 : WORKDIR /testdir1 
 - -> Running in 5e8e47505ca6 
Removing intermediate container 5e8e47505ca6 
 - -> d30a2f002626 
Step 3/10 : COPY testfile1 . 
 - -> 4ac46077a588 
Step 4/10 : WORKDIR /testdir2 
 - -> Running in 8c48189da985 
Removing intermediate container 8c48189da985 
 - -> 7c7d90bc2219 
Step 5/10 : COPY testfile2 . 
 - -> 5b40d33100e1 
Step 6/10 : WORKDIR /testdir3 
 - -> Running in 4ccd634a04db 
Removing intermediate container 4ccd634a04db 
 - -> f89fdda8f059 
Step 7/10 : COPY testfile3 . 
 - -> 9542f614200d 
Step 8/10 : WORKDIR /app 
 - -> Running in 7614b0fdba42 
Removing intermediate container 7614b0fdba42 
 - -> 6d686935a791 
Step 9/10 : COPY hello . 
 - -> cd4baca758dd 
Step 10/10 : ENTRYPOINT ["/app/hello"] 
 - -> Running in 28a1ca58b27f 
Removing intermediate container 28a1ca58b27f 
 - -> 35dfd9240a2e 
Successfully built 35dfd9240a2e 
Successfully tagged example3:recovered

然后我们来运行这个镜像:

$ docker run - name recovered -dt example3:recovered 
0f696bf500267a996339b522cf584e010434103fe82497df2c1fa58a9c548f20 
$ docker logs recovered 
Hello, world!

为了进一步验证，让我们再次使用 Dive 检查镜像。

docker run - rm -it \ 
 -v /var/run/docker.sock:/var/run/docker.sock \ 
 wagoodman/dive:latest example3:recovered

此镜像显示的文件与原镜像相同。将两个镜像并排比较，它们都完全匹配。两者显示的文件大小相同。两者的功能完全相同。

以下是用于生成example3镜像的原始Dockerfile。

FROM alpine:3.9.2 
RUN apk add - no-cache nasm 
WORKDIR /app 
COPY hello.s /app/hello.s 
RUN touch testfile && nasm -f bin -o hello hello.s && chmod +x hello 
FROM scratch 
WORKDIR /testdir1 
COPY - from=0 /app/testfile testfile1 
WORKDIR /testdir2 
COPY - from=0 /app/testfile testfile2 
WORKDIR /testdir3 
COPY - from=0 /app/testfile testfile3 
WORKDIR /app 
COPY - from=0 /app/hello hello 
ENTRYPOINT ["/app/hello"]```

我们可以看到，虽然我们不能完美地重建它，但我们能够大致重建它。像这样使用多阶段(stage)构建的Dockerfile是无法重建的。这些信息根本就不存在。我们唯一的选择是重建我们实际拥有的镜像的Dockerfile。如果我们有早期构建阶段的镜像，我们可以为每个阶段重构一个Dockerfile，但在这种情况下，我们只有最终构建阶段的镜像。但不管怎样，我们还是成功地从Docker镜像中重现了一个有用的Dockerfile。

后记

通过使用与Dive类似的方法，我们应该能够更新Dedockify的源代码，使其能够自动分析每一层，以恢复所有有用的文件信息。此外，该程序还可以更新为能够自动从容器中恢复文件并将其存储到本地，同时还能自动对Dockerfile进行适当的更新。最后，还可以对程序进行更新，使其能够轻松推断出基础层是否使用了Scratch或其他基础镜像。通过对恢复的Dockerfile语法进行一些额外的修改，Dedockify有可能被更新为在大多数情况下完全自动地将Docker镜像逆向工程为一个功能性的Dockerfile。

好了， 今天的故事讲完了， 您也许会对其他文章也感兴趣：

如何成为一名DevOps工程师 2023

在本指南中，我分享了我作为DevOps工程师在不同组织中的经验以及成为DevOps工程师的技巧。这是一份开始DevOps工程职业的全面路线图。由于DevOps领域具有高薪和职业发展的潜力，目前在IT行业是一个非常受欢迎的选择。我经常被问及如…

利用ChatGPT最大程度地提高您的DevOps生产力

像ChatGPT这样的AI引擎有可能改变我们实践DevOps的方式。在这篇博客中，我们对ChatGPT进行了测试，看看它如何应对真实世界的DevOps用例和策略。

CTO、首席工程师、联合创始人或任何负责构建SaaS应用的初创企业的人员。

CHECKLIST

开始

选择一个不是那么时髦但是靠谱的技术

• 专注于能够帮助公司构建产品的技术， 而不是为了追赶热点，和潮流的”Cutting Edge”的技术。
• https://mcfunley.com/choose-boring-technology

在做工作计划的同时， 对工作内容有自己的见解和观点

• https://rubyonrails.org/doctrine

工具

Github

选择最适合团队的PaaS/IaaS平台

• 最小化开发的工作和尽可能简化部署 > 性价比

选择一个CDN服务来提供静态资源

启动一个Wiki(可以使用github的)

配置一个CI (Continuous Integration)

• 必须通过CI才能合并PR (Pull Request)
• 使用CI来检查代码风格 (Codestyle)

架构

选择一个技术路线

• 选择服务端渲染/客户端渲染
• 选择微服务(Microservice)架构或传统的Monolith架构

选择一个能让团队用起来最方便的框架

用户身份认证和基于策略的访问控制

• 设置MFA/2FA是迟早的事情.
• 可以从基于密码的认证开始， 不过支持SSO是迟早的事情.

创建和管理“Admin” 用户

档开始建模时， 考虑一下最终你需要支持的人群

由于是SaaS， 你非常有可能在未来需要增加自定义域名和子域名的功能， 现在就考虑这个因素

你的营销网站和公司博客会运行在何处

• 如果把营销网站做在产品中， 那么产品将成为营销/增长的瓶颈
• 如果一开始就把应用运行在app.yourdomain.com上， 日后切换或者更换可能会更容易一些。
• 避免使用不带前缀的域名 yourdomain.com， 否则迁移时可能会缺乏灵活性。

需要提供API

使用可重用的代码来配置服务器， 例如Terraform, Ansible

自动化数据库备份， 并定期尝试恢复来检验备份是否有效

维护一个Staging环境

设置并启动监控和配置适合的告警规则

永远不要把生产的数据放到非生产环境上运行

代码

README应描述从头开始设置开发环境的步骤，并始终保持更新

尽早确定并制定代码风格指南

尽早确定并制定测试规范

决定在代码中添加什么样的注释

使用linters来帮助代码标准化，并使每个人都能更好地进行代码Review

制定并记录日志记录的指南和最佳实践

设置并记录异常处理的指导原则和最佳实践

配置Runtime错误异常报告

为性能报告设置实时分析

在数据库级别设置跟踪记录更改的能力，以进行审计或版本管理

定义并制定代码Review的流程和期望值

• https://mtlynch.io/human-code-reviews-1/
• https://mtlynch.io/human-code-reviews-2/

早期代码在性能/可扩展性成为问题之前不会出现瓶颈问题， 因此要重点关注， 因为一旦出现， 会带来不可避免的灾难。

将开发环境的数据库环境变量放到代码中

团队

汉伦剃刀(Hanlon’s razor)：永远不要将可以用无知/愚蠢/傻缺所能解释的事情归咎于恶意。

向前看并 “招兵买马”

一旦有了至少一名工程师，确定工程级别

设置一个可以试验的结构

质量保证：您需要质量保证的时间比您想象的要早。

当你不再有效地管理团队时，寻找一个比你强10倍的/总监/副总裁。

选择管理还是编写代码。两者兼顾会导致两者都表现不佳。

决定您是否需要组建远程团队，如果需要远程团队，您需要组建哪种 “类型 “的远程团队。

• 远程团队为您提供了一个庞大的人才库，但也面临着独特的管理挑战。如果是远程招聘，则根据技能和自主性进行招聘。
• http://klinger.io/post/180989912140/managing-remote-teams-a-crash-course

日常执行

站会、Sprint、Review、Milestone

使用简单的 “项目管理 “来保持健康的产品开发节奏，无论您的 “团队 “有多小

团队成员的失败很可能源于您做出（或没有做出）的决定

产品

使用 “Feature Flag“发布新功能，并有选择性地为现有客户启用这些功能。

不要尝试让产品更出色，而要始终关注如何让用户更出色。

从分析和数据的启发中做决定。

报表： 您迟早需要将从数据库中查询到的数据转化为报表功能提供给您的客户。

客户提出的需求通常是合理的, 但是他们建议的解决方案通常是错误的。在权衡 “如何做 “之前，先了解 “为什么”；

切勿仅仅为了一个客户而实施一项功能；这将在未来对您造成更大的伤害，而不是在短期内对您有所帮助。

• 付费/赞助功能除外，应将维护和支持考虑在内

在开始构建功能之前，确保现有客户需要该功能

• 潜在客户总是 “望梅止渴”，而 “多一个功能 “却很少能吸引到客户。选择许多潜在客户需要的功能，而不仅仅是少数几个。

对您的产品有一个愿景，并为之努力。因为功能不符合您的愿景而丢失客户短期会很痛苦，但从长远来看会有回报。

以 “简单 “的产品为目标。简单并不容易，但却是您的客户和用户所需要的。产品的工艺就是做艰苦的工作，弄清产品的复杂性，使您的客户能够简单地使用它。

支持深度链接；您的用户和支持人员将感谢您

技术支持

尽早实现Admin portal

为确保应用程序的 “健康”，启用一个展示服务状态的页面

为Admin提供 “Impersonate “功能(使用用户的身份登录)，帮助他们体验客户正在经历的事情。

工程师轮流提供支持，以建立同理心，这意味着您和其他联合创始人也是如此。

尽早建立服务/产品支持工单系统

定义明确的产品支持时间表并将其传达给您的客户；与您的支持人员一起严格执行这些时间表， 早期您可能无需考虑24x7， 但是当规模变大后， 您可能还需要考虑来自不同时区的客户。

那些 “提出 “24x7支持的客户需要为此支付额外费用。

尽早定义并记录支持的操作系统、浏览器和平台，

• https://beta.caniuse.com/ 是您的朋友
• 如果您计划支持IE，请确保您和您的团队能够测试和调试IE中的错误。

在应用程序中为Admin用户（授权用户）设置只读的SQL查询界面，并阻止使用外部客户端

安全

SaaS首席技术官安全检查清单

• https://www.sqreen.com/checklists/saas-cto-security-checklist

准备一套与企业客户共享的资产

为你的框架运行静态代码分析安全工具

尽早研究第三方笔测试和代码审计服务/工具

实施漏洞奖励计划

• https://www.hackerone.com/ 或类似

合规性

熟悉您所在行业的合规标准

尽早为公司获得行业前三名的合规证书

杂项

找到指导他人的方法（公司内部或外部）

加入一个由CTO、工程师、技术领袖组成的社区，与他们分享知识。

在日常工作中，平衡史诗任务和小Backlog/Bug修复之间的关系

使用邮件组来提供所有对外的沟通和服务， 例如support@youcompany.com

• 使用密码管理器的共享功能，确保访问权限不依赖于您个人

用公司信用卡支付所有第三方平台/服务的费用

• 如果使用个人的信用卡, 角色变更、收购、注销信用卡等都可能使这一操作变得麻烦。

软件架构是为了实现所需要的功能而产生的一个设计、代码组织、关联以及组件之间如何相互影响，相互作用的一个过程，

软件架构是一个重要的过程，它可以确保软件产品的质量，并帮助企业解决长期和短期的复杂性问题。让我们通过一个软件架构的例子来理解它。

举例:

软件架构的一个例子是电子商务网站的设计。网站由各种组件组成，如用户界面、数据库和支付网关。网站架构定义了这些组件之间的交互方式以及网站的整体结构。架构还包括用于构建网站的技术、工具和框架的选择。

软件架构的重要性怎么强调都不为过。它在解决长期和短期的复杂性方面发挥着至关重要的作用。

从短期来看，软件架构有助于减少开发时间和成本。

通过定义软件组件的结构和关系，架构为开发人员提供了一个可遵循的路线图。这使得设计、开发和测试软件组件变得更加容易，从而缩短了开发时间并降低了成本。

从长远来看，软件架构有助于维护软件系统。

随着系统的发展，它可能会变得更加复杂，从而难以维护和更新。设计良好的软件架构可提供一个框架，在不影响现有系统的情况下添加新特性和功能。这可确保系统随着时间的推移保持灵活性、可扩展性和可维护性。

Amazon就是一个很好的例子，说明了软件架构在业务中的重要性。Amazon是全球最大的电子商务平台之一，拥有数百万客户和数十亿笔交易。Amazon的成功部分归功于其软件架构。Amazon的架构设计具有高度可扩展性、灵活性和弹性。它建立在微服务架构上，系统的各个组件被分解成更小、更易于管理的服务。这使得开发、测试和部署新功能更加容易，也使得维护和扩展系统更加容易。

Amazon的架构还包括各种技术和工具，使其能够处理大量的流量和交易。例如，亚马逊使用的Amazon Web Service（AWS）为平台提供了根据需求快速扩展和缩减的能力。这使得Amazon能够在假日期间处理高峰流量，而不会出现任何停机或性能问题。

软件架构原则： S.O.L.I.D.

既然我们已经知道了软件架构的基础知识，那么让我们来了解一下什么是SOLID原则。S.O.L.I.D是一套帮助软件开发人员设计和构建易于维护、扩展和测试的软件系统的原则。这些原则由Robert C. Martin（又称 “Uncle Bob”）提出，并已成为软件开发的标准。缩写S.O.L.I.D中的每个字母代表了软件架构设计中应遵循的原则：

1. Single Responsibility 原则（SRP）

单一职责原则（Single Responsibility Principle）是指一个类应该只有一个责任或改变的原因。一个类如果有多个职责，就很难维护和测试。如果每个类只关注一个职责，那么代码的理解、更改和扩展就会变得更加容易。

例如，考虑一个处理用户验证和发送电子邮件的类。在这种情况下，如果电子邮件发送功能发生变化，可能会影响身份验证功能。相反，应该为用户身份验证和电子邮件发送创建单独的类，每个类只负责一个功能。

2. 开闭原则（OCP）

开闭原则（Open-Closed Principle）指出，软件模块应为扩展开放，但为变更封闭。这意味着软件模块（如类）的行为应可扩展，而无需修改其源代码。模块的设计应允许在不修改现有代码的情况下添加新功能。

例如，考虑一个计算订单总成本的类。如果需要对订单应用折扣，则不应修改现有类。相反，应该创建一个新类来扩展现有类的功能。

3. Liskov 替代原则（LSP）

Liskov替代原则(Liskov Substitution Principle)指出，派生类应该可以替代基类。这意味着派生类应该能够替换基类而不影响程序的正确性。

例如，考虑一个使用基类Shape来计算形状面积的程序。Liskov替换原则指出，任何派生类，如矩形或圆形，都应该能够替换Shape类而不会破坏程序。

4. 接口隔离原则（ISP）

接口隔离原则（Interface Segregation Principle）指出，不应该强迫一个类实现它不使用的接口。这意味着接口应根据类的需要而设计，而不是强迫类实现它不需要的方法。

例如，考虑一个名为Customer的接口，它包括创建新客户和更新现有客户的方法。一个只需要创建新客户的类不应该被强制实现更新方法。相反，应该将该接口分为两个独立的接口，一个用于创建客户，另一个用于更新客户。

5. 依赖反转原则（DIP）

依赖反转原则(Dependency Inversion Principle)指出，高层模块不应依赖于低层模块。相反，两者都应依赖于抽象。这意味着一个模块的实现细节不应暴露给其他模块。

例如，考虑一个使用日志库的程序。如果程序直接依赖于日志库，那么就很难用另一个库来替换日志库。相反，程序应该依赖于一个抽象，比如一个接口，这个接口可以被任何日志库实现。这样就可以在不影响程序功能的情况下更改日志库。

优秀的软件架构特征

优秀的软件架构特性对于创建高效、可扩展、可维护和可扩展的软件系统至关重要。以下是一些良好软件架构最重要的特征：

1. 模块化 Modularity： 软件系统应划分为若干模块，每个模块执行特定的功能。这使得系统的开发、测试和维护更加容易。
2. 可扩展性 Scalability： 软件系统的设计应能应对需求、数据量和用户负载的变化。这意味着系统应能够根据需要扩大或缩小。
3. 灵活性 Flexibility： 软件系统应具有灵活性，能够适应变化。其设计应允许修改和扩展，而无需对现有代码进行重大修改。
4. 可维护性 Maintainability： 软件系统应易于维护和更新。这意味着代码应组织良好、易于理解和易于修改。
5. 可测试性 Testability： 软件系统的设计应便于测试。这意味着代码的编写方式应便于对每个模块进行单独测试。
6. 可重用性 Reusability： 软件系统的设计应允许代码重用。这意味着模块应设计成可在多种环境和应用中使用。
7. 良好的性能 Performance： 软件系统的设计应高效且性能良好。这意味着它应能够处理大量的用户和事务，而不会出现明显的速度减慢。

通过将这些特性纳入软件架构设计，开发人员可以创建高效、可维护和可扩展的软件系统。

主流的软件架构模式

软件架构模式也称为软件设计模式，是软件架构中常见问题的可重用解决方案。这些模式为解决特定的架构问题提供了一个框架，可用于提高软件设计的质量。

有多种软件架构模式可供选择，每种模式都为特定问题提供了解决方案。下面是一些最常见的软件架构模式：

1. Model-View-Controller（MVC）： 这种模式将用户界面、业务逻辑和数据存储分成三个不同的组件： 模型(Model)、视图(View)和控制器(Controller)。这种分离提高了代码的可维护性、可扩展性和可重用性。
2. 分层架构 Layered Architecture： 这种模式将软件系统划分为多个逻辑层，每层执行一组特定的功能。这种关注点的分离使系统的开发、测试和维护更加容易。
3. 微服务 Microservice： 这种模式是将大型软件系统分解成较小的、独立的服务，这些服务通过API相互通信。这种分离提高了可扩展性、灵活性和容错性。
4. 事件驱动架构 Event-Driven Architecture（EDA）： 这种模式包括创建能够响应事件的系统，如用户操作、系统事件或外部事件。这种模式提高了可扩展性、灵活性和响应能力。
5. 领域驱动设计 Domain-Driven Design（DDD）： 该模式包括创建一个反映所解决问题领域的软件设计。这种模式提高了代码的可维护性、可扩展性和可重用性。
6. 存储库模式 Repository Pattern： 这种模式将数据访问逻辑与应用程序代码的其余部分分离开来。这种模式提高了代码的可测试性、可维护性和可扩展性。

通过使用软件架构模式，开发人员可以创建更高效、可扩展和可维护的软件系统。这些模式提供了解决特定架构问题的框架，可用于提高软件设计的质量。如果您想快速了解主要行业中使用的所有主要软件架构模式，下面的视频可以帮助您。

结论

总之，我们应该承认软件架构是确保软件产品质量和可维护性的关键过程。它通过提供设计、开发、测试和维护软件系统的框架，在解决长期和短期的复杂性方面发挥着至关重要的作用。

Amazon的例子证明了软件架构在商业中的重要性，它为电子商务交易提供了一个可扩展的、灵活的和有弹性的平台。设计良好的软件架构对于希望开发和维护高质量软件产品以满足当今客户需求的企业来说至关重要。

最后，作为一名开发人员，了解最新的技术进步至关重要。以下是2023年及以后值得关注的软件架构发展趋势

如何成为一名DevOps工程师 2023

在本指南中，我分享了我作为DevOps工程师在不同组织中的经验以及成为DevOps工程师的技巧。这是一份开始DevOps工程职业的全面路线图。由于DevOps领域具有高薪和职业发展的潜力，目前在IT行业是一个非常受欢迎的选择。我经常被问及如…

2023年GitHub上最值得关注的10个开源项目

开源软件（OSS）已经彻底改变了当今软件开发的方式。由于有数以百万计的开源GitHub项目，要浏览并找到符合你需求的最佳开源项目可能会让人不知所措。

系统设计指南

开发一个强大的、可扩展的、高效的系统可能是令人生畏的。然而，了解关键的概念和组件可以使这个过程更容易管理。在这篇博文中，我们将探讨基本的系统设计组件，如DNS、负载平衡、API网关等，以及一份简洁的小抄，可以帮助开发者设计不同复杂度的系统。…

2023年DevOps团队值得关注的10大开源监控工具

在2023年，监控平台对于现代DevOps团队的工作至关重要。DevOps团队需要可靠且灵活的工具，以有效地监控和管理复杂的系统，并提供实时的系统性能、可用性和安全性洞察。

多云网络2023发展趋势：在数字化时代的前沿探索

在当今数字化时代，云计算已成为企业和个人的重要基础设施。随着技术的不断进步和市场的竞争加剧，多云网络已成为未来发展的重要趋势之一。本文将探讨多云网络在2023年的发展前景以及对企业和个人带来的影响。