Overstarry Site

Goland 通过 ACP 连接 Claude Code

Sat, 06 Dec 2025 10:00:14 +0800

前言

2025年12月5日，JetBrains 官方正式推出了对 ACP 协议的正式支持，可以通过下载各个 JetBrains IDE 的2025.3 Release Candidate build版本来使用 ACP 协议。

配置

在本文中将以 Goland IDE 为例，介绍如何通过 ACP 协议连接 Claude Code。

安装 Goland 2025.3 Release Candidate build

在 Toolbox 安装 Goland 2025.3 Release Candidate 版本。

配置

打开 AI Chat 工具窗口,目前需要登录才能使用 AI Chat 功能,官方后续会进行调整。在选项卡选择配置 ACP 代理,会创建打开~/.jetbrains/acp.json 文件。

安装配置 Claude Code ACP 代理

使用 pnpm install @zed-industries/claude-code-acp 安装 claude-code-acp。

修改 ~/.jetbrains/acp.json 文件，添加以下内容：

{
    "agent_servers": {
        "Claude Code Agent": {
            "command": "pnpx",
            "args": [
                "@zed-industries/claude-code-acp"
            ],
        }
    }
}

配置完在 Chat界面选择 Claude Code Agent

在 Claude Code 中配置 Augment Context Engine MCP

Wed, 03 Dec 2025 21:55:59 +0800

前言

ACE(Augment Context Engine) 是 Augment 提供的上下文引擎，可以说是 Augment的核心竞争力，12月3号官方正式推出了 ACE MCP,方便在其它 code agent 中使用。

本文将介绍如何在 Claude Code 中配置 ACE MCP。

环境

OS: WSL Ubuntu 24.04
Host OS: Windows 10.0.26100
Claude Code: 2.0.57 (Claude Code)

安装

1 安装 Auggie CLI (Pre-release version) npm install -g @augmentcode/auggie@prerelease

2 登录 augment auggie login

3 打开Claude Code设置 mcp server

 claude mcp add-json auggie-mcp '{"type":"stdio","command":"auggie","args":["--mcp"],"env":{"AUGMENT_API_TOKEN":"xx","AUGMENT_API_URL":"https://xx.api.augmentcode.com"}}'

4 使用 What is this project ? Please use codebase retrieval tool to get the answer. 询问项目相关的内容，可以看到成功输出了项目相关的介绍。

Midscene

Sat, 29 Nov 2025 16:03:49 +0800

介绍

Midscene.js 是一个开源的 AI 操作助手，适用于 Web、移动端、自动化和测试。

特性

通过自然语言描述目标和步骤，自动生成 UI 自动化脚本

描述你的目标和步骤，Midscene 会为你规划和操作用户界面。
支持 JavaScript SDK 和 YAML 两种脚本格式

跨平台支持

网页自动化：集成 Puppeteer、Playwright 或桥接模式控制桌面浏览器
Android 自动化：通过 adb 控制本地设备
iOS 自动化：通过 WebDriverAgent 控制本地设备

辅助工具

提供可视化测试报告和 Playground 环境，便于调试和回放
支持脚本缓存，提升执行效率
开放 MCP 协议，允许其他 MCP Client 直接调用（支持 Web 和 Android）

三大 API 类型

交互 API：操作用户界面元素
数据提取 API：从 UI 和 DOM 中提取数据
实用 API：提供 aiAssert() 断言、aiLocate() 定位、aiWaitFor() 等待等辅助函数

模型选择

模型最好使用支持视觉的模型，如: gemini, claude, UI-TARS 等模型。本文的案例会使用 Doubao-1.5-UI-TARS 进行介绍。

Doubao-1.5-UI-TARS 是字节跳动开源的一款原生面向图形界面交互（GUI）的 Agent 模型。通过感知、推理和行动等类人的能力，与 GUI 进行无缝交互，非常适合 Midscene.js 使用。

fix Zed go lsp error

Mon, 20 Oct 2025 20:30:40 +0800

前言

前段时间在使用 Zed 编辑器时，出现了 go lsp 启动错误，未能正确找到 go 语言的二进制文件。

本文将一步步从源代码分析修复 Zed 的 go lsp 启动错误。

步骤

从错误信息可以得知，具体的逻辑在 /crates/languages/src/go.rs#L76，可以看到是 delegate.which("go".as_ref()).await.is_none() 方法的返回值为 true，导致 go 语言的二进制文件未找到。

接下来寻找 which 方法的定义位置，可以看到是在 /crates/project/src/lsp_store.rs#L12758，这段代码实现了 LspAdapterDelegate trait 中的 which 方法，用于在系统中查找可执行文件的路径。

修改 which 方法，添加一些日志，以便更好地理解其执行过程。

 async fn which(&self, command: &OsStr) -> Option<PathBuf> {
        let mut worktree_abs_path = self.worktree_root_path().to_path_buf();
        if self.fs.is_file(&worktree_abs_path).await {
            worktree_abs_path.pop();
        }
        let shell_path = self.shell_env().await.get("PATH").cloned();

        // Debug output
        log::info!(
            "which() called for command: {:?}, worktree_abs_path: {:?}, shell_path: {:?}",
            command,
            worktree_abs_path,
            shell_path
        );

        let result = which::which_in(command, shell_path.as_ref(), worktree_abs_path).ok();
        log::info!("which() result for {:?}: {:?}", command, result);
        result
    }

重新编译运行 Zed,查看日志:

Building Zed for Windows

Sun, 19 Oct 2025 14:14:38 +0800

前言

本文将介绍如何在 Windows11 上构建 Zed 编辑器。

依赖性

Zed 是由 rust 编写的，因此需要安装 rust 工具链。
安装 Visual Studio 2022 ,安装符合电脑架构的 C++ 工具集。

主要是如下组件:

{
  "version": "1.0",
  "components": [
    "Microsoft.VisualStudio.Component.CoreEditor",
    "Microsoft.VisualStudio.Workload.CoreEditor",
    "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
    "Microsoft.VisualStudio.Component.Windows11SDK.26100",
    "Microsoft.VisualStudio.ComponentGroup.WebToolsExtensions.CMake",
    "Microsoft.VisualStudio.Component.VC.CMake.Project",
    "Microsoft.VisualStudio.Component.VC.Runtimes.x86.x64.Spectre"
  ],
  "extensions": []
}

构建

安装完依赖项后，可以从源代码构建 Zed 编辑器。

Clone Zed Repository

gh repo clone overstarry/zed
cd zed

构建 debug 版本

cargo run

编译中出现了，需要将前面安装的 cmake 添加到环境变量中。

设置完，重新运行 cargo run 即可。

zed 配置 codex acp

Fri, 10 Oct 2025 20:16:30 +0800

前言

在前面的文章![https://jasminides.com/posts/zed-acp-claude-code/] 介绍了如何在 zed 中配置 Claude Code, 本文将介绍如何在 zed 编辑器中安装配置使用 codex。

安装

本文使用的环境是 Windows11 下的 wsl,进入 wsl，输入wget https://github.com/zed-industries/codex-acp/releases/download/0.2.4/codex-acp-0.2.4-x86_64-unknown-linux-gnu.tar.gz 下载 codex-acp, 使用 tar -xvf codex-acp-0.2.4-x86_64-unknown-linux-gnu.tar.gz 解压，将解压后的文件移动到 /usr/local/bin 目录下。

配置

codex-acp 的配置很简单，打开 zed 的设置，填入设置:

{
  "agent_servers": {
    "Custom Codex Agent": {
        "command": "/usr/local/bin/codex-acp",
        "args": [],
        "env": {}
      }
  }
}

设置完打开 Agent 面板就可以看到外部 Agents 的选项中已有 Custom Codex Agent 选项。

输入消息，顺利得到回复。

小结

本文介绍了如何在 Zed 编辑器中安装和配置 codex-acp，详细说明了下载、解压、移动可执行文件以及在 Zed 设置中添加自定义 Agent 的步骤。通过简单的配置，即可在 Zed 中顺利使用 Codex Agent，提升了编辑器的智能化体验。期待未来官方带来更多 agent 的集成。

将 MCP Server 提交到 MCP Registry

Wed, 10 Sep 2025 21:58:42 +0800

前言

MCP Registry 是 MCP 官方提供的一个提供 MCP Server 的平台，开发者可以将自己开发的 MCP Server 提交到 MCP Registry 以便其他用户可以方便的使用，MCP Registry 于 2025年 9月 8号推出了预览版，本文就讲述如何将自己开发的 MCP Server 提交到 MCP Registry。

提交 MCP Server

本文所使用的 MCP Server 是 qweather-mcp-go ,是一个使用 Node.js 开发的 MCP Server, 环境是 windows 11, 其他系统类似。

安装 Publisher CLI

要提交 MCP Server 需要使用安装使用 Publisher CLI

macOS/Linux/WSL 使用 Homebrew 安装:

brew install mcp-publisher

macOS/Linux/WSL 使用预编译的二进制文件安装:

# 下载最新版本的预编译二进制文件
curl -L "https://github.com/modelcontextprotocol/registry/releases/download/v1.0.0/mcp-publisher_1.0.0_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher && sudo mv mcp-publisher /usr/local/bin/

macOS/Linux/WSL 使用源码安装:

需要 Git、Make 和 Go 1.24 以上版本

Zed acp-claude-code

Mon, 01 Sep 2025 20:06:42 +0800

前言

zed 在 0.201.4 版本推出了应用 Agent Client Protocol (ACP) 协议的第一个正式版本，Agent Client Protocol (ACP) 是一个将外部 Agents 与编辑器集成的开放协议，zed 在这个版本中集成了 Google Gemini CLI , 开发者可以自己开发兼容 ACP 的自定义代理，本文就是讲述如何安装配置 acp-claude-code 以在 zed 更方便的使用 Claude Code.

配置

acp-claude-code 的配置很简单，打开 zed 的设置，填入设置:

{
  "agent_servers": {
    "Claude Code": {
      "command": "npx",
      "args": ["acp-claude-code"]
    }
  }
}

设置完打开 Agent 面板就可以看到外部 Agents的选项中已有 Claude Code 选项。

新建 Claude Code 线程，发现报错了，提示 program not found 。

根据以往的经验，这种错误主要发生在 windows 系统上，windows 系统的用户应该使用如下配置。

Enhancing qweather-mcp-go

Fri, 15 Aug 2025 23:23:09 +0800

前言

Claude Code 是 Anthropic 公司开发的 AI 编程工具，它在终端运行，能理解整个项目架构，通过自然语言指令进行代码生成、Bug 修复、Git 操作和自动化开发流程，显著提升开发效率。它支持 macOS、Ubuntu 和 Windows (WSL)，并提供按量付费或包月订阅模式。

本文将使用 Claude Code 来增强 qweather-mcp-go 项目，qweather-mcp-go 是一个 mcp 工具，可以方便的查询天气情况等数据。本文将一步步使用 Claude Code 来为 qweather-mcp-go 添加 Streamable HTTP 的支持。

开始

开始编写代码之前，介绍一下使用的工具及环境:

开发工具: zed
mcp: context7 、 server-sequential-thinking
AI 编程工具: claude code
模型: claude-sonnet-4

qweather-mcp-go 当前只支持 stdio 和 sse 协议，我们来为它添加 streamable http 的支持。

初始化项目

打开终端，输入 /init 初始化项目，会在项目中生成 CLAUDE.md 文件，使 Claude Code 能够快速理解项目。

实现

在 Claude Code 中输入以下内容:

请按照以下步骤实现 Streamable HTTP 支持：

1. 首先阅读 GitHub issue：https://github.com/overstarry/qweather-mcp-go/issues/4，理解具体的需求和期望的功能

2. 使用 context7 工具获取 github.com/mark3labs/mcp-go 库中与 Streamable HTTP 相关的 API 文档，重点关注：
   - 流式 HTTP 请求和响应的接口定义
   - 相关的结构体、方法和配置选项
   - 使用示例和最佳实践

3. 基于获取的文档信息，分析当前 qweather-mcp-go 项目的代码结构，确定需要修改的文件和组件

4. 提出一个详细的实现方案，包括：
   - 需要实现的具体功能点
   - 代码架构设计
   - 主要的实现步骤
   - 可能遇到的技术挑战和解决方案

5. 在开始编码前，先展示完整的实现计划供确认

输入后可以看到 Claude Code 会创建计划来一步步实现需求。

Docker Push Error

Wed, 25 Jun 2025 23:35:20 +0800

问题

最近升级 Docker-Desktop 后，发现 push 镜像到 nexus 注册表时，报错如下：

error from registry: unknown

升级到 v4.42.1 时，甚至出现镜像不能顺利上传的问题。

解决

通过查阅相关 issue , 发现是 nexus 版本太低，不支持目前主流的 OCI 镜像标准，如果想要解决，可以有两种方法解决:

1 升级 nexus 版本,从稳定版 Nexus 3.47.1 支持 OCI，升级到此版本以上即可解决。

2 通过 –provenance=false 参数解决，–provenance 标志是 docker buildx build 命令的一个选项，用于控制是否生成 provenance 凭证。它是 –attest=type=provenance 的简写形式。

启用 Provenance (默认行为): 在较新版本的 Buildx 中，provenance 凭证是默认启用的。您也可以显式地使用 true 来启用它，这会以 mode=min 的模式附加凭证为了兼容旧的镜像仓库，可以禁用。

小结

本文讲述了在使用 docker push 时遇到由于注册表版本太低导致的推送镜像失败问题，并提出了两个解决方案，对于两个方案，如果允许升级的话，最好还是更新 nexus 版本来解决，不能升级的话可以使用 –provenance=false 参数解决。

参考

Dify 学习 - 安装和初探

Mon, 28 Apr 2025 20:29:54 +0800

前言

Dify 是一个开源的 LLM 应用开发平台。其直观的界面结合了 AI 工作流、RAG 管道、Agent、模型管理、可观测性功能等，让您可以快速从原型到生产。本篇将介绍如何安装和初步使用 Dify，接下来还会有多篇介绍 Dify 的文章，敬请期待。

安装

接下来介绍如何使用 Docker 安装 Dify。

安装 Docker

在各个操作系统上安装 Docker，可以参考 Docker 官方文档，这里就不进行叙述了。

Clone Dify 仓库

使用命令 git clone https://github.com/langgenius/dify.git 克隆 Dify 仓库。

启动 Dify

进入 Docker 目录，拷贝一份环境变量配置文件,使用 docker compose up -d 命令启动 Dify。

cd dify/docker
cp .env.example .env

docker compose up -d

过一会儿，使用 docker compose ps 命令查看容器状态，确保所有容器都正常运行。

设置管理员账号

访问 http://localhost/install 设置管理员账号,设置完成之后，访问 http://localhost/signin 即可登录。

使用 gpt 改造你的小米音箱

Mon, 27 Jan 2025 14:19:32 +0800

前言

前段时间看到了一个项目 mi-gpt ,可以将你的小爱音箱接入 gpt，改造成专属于你的语音助手。

接下来就由作者来介绍小爱同学从零接入 deepseek 的过程。

设置环境变量和配置文件

mi-gpt 有两种部署方式，一是使用 docker 部署，二是使用 Node.js 进行部署，本文使用 docker 进行部署使用。

需要提供两个文件 .env 和 .migpt.js 文件，.migpt.js 是配置文件，包括一些配置，.env 是环境变量文件，存放 gpt 密钥相关文件。文件的例子可以从仓库里复制，然后进行相应的修改。

启动

使用以下命令启动 docker:

docker run -d --env-file $(pwd)/.env -v $(pwd)/.migpt.js:/app/.migpt.js idootop/mi-gpt:latest

windows 环境下需要将$(pwd) 替换为绝对路径。

启动后可以通过 callAIKeywords 设置的关键字调用 ai 来响应用户的消息。

小结

本文介绍了使用 mi-gpt 升级你的闲置的小爱音箱，通过简单的测试和使用，个人感觉还不够完善，稳定性不够好，感兴趣的读者可以根据本文的内容进行自行搭建尝试。

参考

https://github.com/idootop/mi-gpt

node.js 项目构建问题及解决

Sat, 28 Dec 2024 10:21:23 +0800

前言

今天在编译构建一个 node.js 项目时，在构建过程中遇到了一些问题，本文将记录问题及对应的解决方案。

问题 1

在执行 npm run build 遇到此提示：

error  Expected linebreaks to be 'LF' but found 'CRLF'  linebreak-style

根据信息可以看出是 eslint 的报错，查看 .eslintrc.js 文件，修改 linebreak-style 对应的行：

'linebreak-style': ['error', process.platform === 'win32' ? 'windows' : 'unix'],

重新运行命令，顺利构建成功。

这个问题的原因是项目的作者可能是使用 Linux 或 Mac 构建的，没有考虑 Windows 的情况，通过这行配置，可以根据运行的环境来决定 lint 规则。

问题 2

在执行 npm start 遇到了第二个问题：

Generating browser application bundles (phase: building)...node:internal/crypto/hash:79
  this[kHandle] = new _Hash(algorithm, xofLen, algorithmId, getHashCache());
                  ^

Error: error:0308010C:digital envelope routines::unsupported
    at new Hash (node:internal/crypto/hash:79:19)
    at Object.createHash (node:crypto:139:10)
    at BulkUpdateDecorator.hashFactory (D:\code\xx\node_modules\webpack\lib\util\createHash.js:145:18)
    at BulkUpdateDecorator.update (D:\code\xx\node_modules\webpack\lib\util\createHash.js:46:50)
    at RawSource.updateHash (D:\code\xx\node_modules\webpack\node_modules\webpack-sources\lib\RawSource.js:77:8)
    at NormalModule._initBuildHash (D:\code\xx\node_modules\webpack\lib\NormalModule.js:880:17)
    at handleParseResult (D:\code\xx\node_modules\webpack\lib\NormalModule.js:946:10)
    at D:\code\xx\node_modules\webpack\lib\NormalModule.js:1040:4
    at processResult (D:\code\xx\node_modules\webpack\lib\NormalModule.js:755:11)
    at D:\code\xx\node_modules\webpack\lib\NormalModule.js:819:5 {
  opensslErrorStack: [
    'error:03000086:digital envelope routines::initialization error',
    'error:0308010C:digital envelope routines::unsupported'
  ],
  library: 'digital envelope routines',
  reason: 'unsupported',
  code: 'ERR_OSSL_EVP_UNSUPPORTED'
}

根据这个报错，推测可能是啥 hash 算法不支持，通过查阅相关资料，得到以下解决方案：

go 解析 csv 文件报错

Thu, 05 Dec 2024 15:57:23 +0800

问题

最近在使用 go 解析 csv 文件时，读取并打印 csv 的每行内容时，读取到第 11 行时，程序报错，提示：

record on line 11: wrong number of fields

分析

遇到这个问题，我第一反应是 csv 文件的格式有问题，于是我使用 cat 命令查看 csv 文件，发现 csv 文件的格式是正确的，没有问题。并查看分隔符是正确的，于是可以得出 csv 文件是没有问题的。

接下来就查看所使用的标准库 encoding/csv，通过查阅文档及 issue, 发现 csv 包中的 FieldsPerRecord 字段，FieldsPerRecord 表示 csv 文件每行的预期字段数，如果为正数，则读取的每条记录都必须有对应的字段数，如果为 0，则会以第一条记录的数量为标准，接下来每行都必须有对应的字段数，如果为负数，则不会检查字段数。

修改后的代码如下：

package main

import (
	"encoding/csv"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {
	file, err := os.Open("./xx.csv")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()
	// 创建一个 CSV reader
	reader := csv.NewReader(file)
	reader.FieldsPerRecord = -1
	// 循环读取 CSV 文件中的每一行数据
	for {
		record, err := reader.Read()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatal(err)
		}

		// 处理每一行数据
		fmt.Println(record)
		fmt.Println(len(record))
	}
}

小结

本文记录了在使用 go 解析 csv 时遇到字段数不匹配的问题，并分析了问题的原因，并给出了相应的解决方法。

Go Recivie Email

Sat, 23 Nov 2024 10:21:05 +0800

前言

电子邮件是现代办公和通信中不可或缺的工具，它广泛应用于数据交换和工作沟通。为了更高效地处理邮件内容，我们可以借助程序来实现自动化处理。本文将详细介绍如何使用 Go 语言来接收和处理电子邮件。

通过查阅资料，了解到可以通过 IMAP 协议来接收电子邮件，IMAP 协议是电子邮件接收协议，它允许客户端通过网络连接到邮件服务器，并从服务器上下载邮件。除了 IMAP 协议，还有 POP3 协议，POP3 协议与 IMAP 协议类似，但它在在客户端上对邮件的操作不会反馈到邮件服务器上，也就是说，在客户端的操作不会影响服务器上的邮件。当你需要从多个邮件客户端访问邮件时，IMAP 协议是一个更好的选择。

go-imap

通过对比不同的库，最后选择了 go-imap 库，它是一个基于 IMAP 协议的 Go 语言库，可以通过它构建客户端或者服务端。

安装

可以通过以下命令安装：

go get github.com/emersion/go-imap

使用

我们将通过官方的例子进行切入：

先通过 DialTLS 连接对应的电子邮箱 IMAP 服务器，然后通过登录邮箱，获取所有的邮箱文件夹，最后选择收件箱，获取收件箱中最新的 4 封邮件，并打印没封邮件的主题。

运行代码：

2024/11/23 16:16:11 Connecting to server...
2024/11/23 16:16:11 Connected
2024/11/23 16:16:12 Logged in
2024/11/23 16:16:12 Mailboxes:
2024/11/23 16:16:13 * 其他文件夹
2024/11/23 16:16:13 * Drafts
2024/11/23 16:16:13 * Deleted Messages
2024/11/23 16:16:13 * Sent Messages
2024/11/23 16:16:13 * Junk
2024/11/23 16:16:13 * INBOX
2024/11/23 16:16:13 Flags for INBOX: [\Answered \Flagged \Deleted \Draft \Seen]
2024/11/23 16:16:13 Last 4 messages:
2024/11/23 16:16:13 * =?GBK?B?xx?=
2024/11/23 16:16:13 * =?GBK?B?xxx?=
2024/11/23 16:16:13 * =?GBK?B?xx==?=
2024/11/23 16:16:13 * =?GBK?B?xx+k=?=
2024/11/23 16:16:13 Done!

可以看到打印出来的邮件主题是乱码，通过查询资料，了解到邮件的字段是采用特殊编码的，需要进行解码。可以通过 https://github.com/emersion/go-message 这个库进行解码。

go-soap 简介

Fri, 04 Oct 2024 14:26:30 +0800

前言

最近需要调用一个第三方的接口进行数据的采集，这个接口是基于 SOAP 协议的，所以需要使用 soap 相关的客户端进行调用。于是我调研了一些开源的 golang 的 soap 客户端，发现 go-soap 这个库的文档比较完善，而且使用起来也比较简单，所以就选择了这个库。

安装

使用以下命令进行安装：

go get github.com/tiaguinho/gosoap

使用

由于目前没有特别好的例子，这里就以官方的例子进行说明。

官方的代码如下：

package main

import (
	"encoding/xml"
	"log"
	"net/http"
	"time"

	"github.com/tiaguinho/gosoap"
)

// GetIPLocationResponse will hold the Soap response
type GetIPLocationResponse struct {
	GetIPLocationResult string `xml:"GetIpLocationResult"`
}

// GetIPLocationResult will
type GetIPLocationResult struct {
	XMLName xml.Name `xml:"GeoIP"`
	Country string   `xml:"Country"`
	State   string   `xml:"State"`
}

var (
	r GetIPLocationResponse
)

func main() {
	httpClient := &http.Client{
		Timeout: 1500 * time.Millisecond,
	}
	soap, err := gosoap.SoapClient("http://wsgeoip.lavasoft.com/ipservice.asmx?WSDL", httpClient)
	if err != nil {
		log.Fatalf("SoapClient error: %s", err)
	}
	
	// Use gosoap.ArrayParams to support fixed position params
	params := gosoap.Params{
		"sIp": "8.8.8.8",
	}

	res, err := soap.Call("GetIpLocation", params)
	if err != nil {
		log.Fatalf("Call error: %s", err)
	}

	res.Unmarshal(&r)

	// GetIpLocationResult will be a string. We need to parse it to XML
	result := GetIPLocationResult{}
	err = xml.Unmarshal([]byte(r.GetIPLocationResult), &result)
	if err != nil {
		log.Fatalf("xml.Unmarshal error: %s", err)
	}

	if result.Country != "US" {
		log.Fatalf("error: %+v", r)
	}

	log.Println("Country: ", result.Country)
	log.Println("State: ", result.State)
}

可以看到 go-soap 的使用跟常规的 http client 的使用方法类似，都是创建一个连接，准备方法的参数，然后调用相应的方法。这段代码展示了如何使用 go-soap 库连接 SOAP 服务、发送请求、处理响应，以及如何解析 XML 格式的返回数据。

Docker Desktop 设置网络代理

Sat, 21 Sep 2024 15:12:23 +0800

前言

最近遇到 Docker Desktop 构建 node 项目时，由于网络问题导致的构建失败问题，本文将介绍两个给 Docker Desktop 设置网络代理的方法。

修改 WSL2 配置

为了测试代理的效果，这里创建一个 go 服务，代码很简单，就是访问 https://www.google.com/ 并返回结果。如果能正常访问，说明代理设置成功。

package main

import "net/http"

func main() {
	resp, err := http.Get("https://www.google.com/")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	println(resp.Status)
}

第一种方法是修改 WSL2 的配置，在 windows C:\Users<your_username> 目录下创建 .wslconfig 文件，输入以下内容：

[experimental]
autoMemoryReclaim=gradual  
networkingMode=mirrored
dnsTunneling=true
firewall=true
autoProxy=true

然后重启 WSL: wsl --shutdown

networkingMode 为 mirrored 表示网络模式使用镜像模式，会镜像宿主机的网络设置，能更好的集成宿主机和 WSL 的网络。

autoProxy 开启了自动代理的功能，意味 WSL 自动配置代理设置。

配置好，我们构建 Docker 镜像，运行：

可以看到代理成功生效，可以正常访问。

如何在 Github Pages 上部署 Hugo 网站

Sat, 31 Aug 2024 23:27:41 +0800

前言

本文将介绍当初我搭建这个博客网站的时候，是如何将 Hugo 网站部署到 GitHub 上的，本文会采用与 hugo 官方不同的方式进行部署。

创建仓库

首先我们在 GitHub 上创建一个仓库，仓库名称为 username.github.io，其中 username 为你的 GitHub 用户名。这个仓库是用来存储 hugo 最终生成的静态网站文件的。再创建一个名称为 blogs 的仓库，这个仓库是用来存储 hugo 网站源内容文件的。

启用 GitHub Pages

在 username.github.io 仓库中，点击 Settings 选项卡，在 GitHub Pages 中选择 Source 为从分支部署，然后点击 Save 按钮。

启用 GitHub Actions

接下来要实现提交 hugo 网站源文件到 blogs 仓库后，自动将 hugo 网站源文件编译成静态网站文件，并提交到 username.github.io 仓库中，这样就可以通过访问 username.github.io 仓库来访问 hugo 网站了。

生成 personal_token

在配置 Actions 前，需要先生成 personal_token，用于在 GitHub Actions 中使用。我们进入 Settings 选项卡，在 Developer settings 中选择 Personal access tokens，然后选择 Tokens (classic)，然后点击 Generate new token 下的Generate new token(classic)按钮，在 Note 中输入 blog，在 Expiration 中选择 No expiration，在 Select scopes 中选择 repo 和 admin:repo_hook，然后点击 Generate token 按钮，生成 personal_token。

V0.dev chat

Sat, 24 Aug 2024 14:53:53 +0800

v0.dev chat 介绍

v0.dev chat 是 vercel 推出的最新的生成式 AI 聊天机器人，可以通过用户对话的方式来生成相应的 react 代码。

v0.dev chat 相比 V0.dev 有以下优点：

最新的 react、next.js、web 技术知识
可以运行 npm 包
更快更可靠的流失传输

接下来将通过官方的几个例子及个人尝试的效果来讲解。

官方例子

解释 next 缓存机制

打开 https://v0.dev/chat/E8fIPvg，可以看到 bot 很好的通过图表及文字讲述了 next 的缓存机制。

贪吃蛇游戏

打开这个 https://v0.dev/chat/AjJVzgx，可以看到用户上传蛇的皮肤并一步步引导 bot 生成贪吃蛇游戏。

个人尝试

接下来将通过一个简单的视频网站例子来尝试 v0.dev chat 的效果。

先通过简单的提示生成视频网站的初始代码：

可以看到 bot 生成的代码是非常完整的，并且可以运行预览的。接下来继续完善视频网站。

接下来添加视频下载保存功能

接下来添加视频网站首页功能

通过不断的调整，可以慢慢的形成一个视频网站的雏形。

总结

v0.dev chat 可以很好的通过对话的方式来生成 react 代码，并且可以运行 npm 包，可以很好的帮助我们快速生成代码。本文通过构建一个视频网站的例子来尝试 v0.dev，由于免费版限制了 message 的数量，感兴趣的可以自行尝试。视频网站的生成步骤可以通过此链接查看：https://v0.dev/chat/PsqNuwjpzXx

Markdown Preview Enhanced plugin introduction and simple use

Fri, 23 Aug 2024 22:27:07 +0800

vscode Markdown Preview Enhanced plugin introduction and simple use

go humanize 介绍

Sat, 10 Aug 2024 14:19:30 +0800

前言

今天在 Github 查看一些开源项目时，发现了一个"人性化"的项目 go-humanize，此项目可以将一些常见的容量、时间、千分位转换为人们可以理解的形式，例如一个文件大小是 2000000 bytes，我们不能很好的理解，但如果告诉你是 2mb，我们就能很好的理解了。go-humanize 就是方便的将一些不太能快速理解的数字转换为人们可以理解的形式。

安装

使用以下命令安装：

go get github.com/dustin/go-humanize

使用

接下来分别介绍一些常见的功能。

容量转换

现在我们有一个文件大小是 52854982 bytes，我们使用 humanize 包的 Bytes 方法将其转换为人们可以理解的形式 53MB，也可以使用 IBytes 方法转换为 MIB 单位的值。也可以使用 ParseBytes 方法将可以理解的形式转换为 bytes 单位的值。

	fmt.Printf("That file is %s.\n", humanize.IBytes(52854982)) 
	fmt.Printf("That file is %s.", humanize.Bytes(52854982))

时间转换

时间转换与容量转换类型，使用方法十分类似，使用方法如下：

	t := time.Now().Add(time.Hour * -7)
	fmt.Printf("This was touched %s.", humanize.Time(t)) //This was touched 7 hours ago.

Time 根据相对时间转换为人们可以理解的形式，例如：xx 天之前、xx 小时之后等形式。

千分位转换

如果我们想在数字中添加逗号，就可以使用 Comma 方法，例如在处理金额时，我们通常会使用逗号将数字分隔开，例如 1,000,000,000

    	fmt.Printf("num is %s.", humanize.Comma(1000000000))

还可以使用 Commaf 方法将浮点数转换为千分位形式。

位序

在日常使用中，我们有时需要表示位序例如 1st、2nd、3rd、4th 等，humanize 包也提供了相应的功能。

解决检测到 localhost 代理配置，但未镜像到 WSL。NAT 模式下的 WSL 不支持 localhost 代理。

Thu, 18 Jul 2024 22:57:10 +0800

解决检测到 localhost 代理配置，但未镜像到 WSL。NAT 模式下的 WSL 不支持 localhost 代理。

AI 编程助手 - Cody

Wed, 03 Jul 2024 20:03:00 +0800

介绍

cody 是一个 AI 编程助手，可以帮助你更快更好的理解代码，编写代码，解决代码中的问题。通过本地代码仓库和远程代码库提取上下文，让你能够更好的理解和编写代码。Cody 目前可以在以下编程工具中使用:

VS Code

JetBrains IDE

Neovim (实验性)

Web (实验性)

Cody 主要有以下功能:

自动完成基于代码上下文的自动补全

聊天在聊天视图中询问代码相关的问题

命令为常见的操作提供了快捷命令，例如：生成文档，添加测试，检测代码问题

调试在编辑器中调试代码，帮你寻找代码中的问题

忽略可以过滤某些文件及过滤某些仓库

价格

介绍完 Cody 的特点后，接下来介绍大家关心的价格问题，Cody 有 3 个版本，分别是 Free、Pro、Enterprise.

Free 版本为免费版，目前每月提供 20 次聊天次数、500 次代码自动完成，今天查看 sourcegraph 的 blog，发现 Free 版本的额度提高了，代码自动完成次数为无限次，聊天和命令次数增加了 10 倍为 200 次。

Pro 版本为每个月 9 美元，提供了不限次数的代码补全及聊天功能及提供了 GPT-4o 等高级 LLM.

Enterprise 的价格需要联系 sourcegraph 的销售人员，Enterprise 相较于 Pro 版提供了更多的团队功能。

安装

接下来介绍如何安装 Cody，主要介绍 VS Code 中如何安装：

1 打开 VS Code

katana 新一代的爬虫工具

Sat, 29 Jun 2024 15:19:30 +0800

katana 介绍

katana 是一款强大的新一代的网络爬虫工具，通过使用 katana，用户能够快速的进行互联网资源的爬取和渗透测试阶段的收集任务。

特点

katana 有以下特点：

快速及高可配置的网络爬虫
标准及无头模式
主动和被动模式
JavaScript 脚本爬取解析
定制的表单内容自动填充
爬取范围控制
可自定义设置输出字段
输入数据支持标准输入 (STDIN)，URL 和列表 (LIST)
输出数据支持 STDOUT、文件和 JSON 格式

安装

接下来介绍如何安装 katana

katana 的安装需要 go1.18 版本以上，可以执行以下命令或下载 Github 仓库的发布版本。

go install github.com/projectdiscovery/katana/cmd/katana@latest

windows 在安装中可能会遇到以下报错：

github.com/smacker/go-tree-sitter/javascript: build constraints exclude all Go files in C:\Users\overstarry\go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\javascript
# github.com/smacker/go-tree-sitter
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:17:18: undefined: Node
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:21:21: undefined: Node
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:25:20: undefined: Node
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:30:26: undefined: Node
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:34:20: undefined: Node
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:38:32: undefined: Node
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:43:9: undefined: Node
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:46:18: undefined: Node
go\pkg\mod\github.com\smacker\go-tree-sitter@v0.0.0-20230720070738-0d0a9f78d8f8\iter.go:68:40: undefined: Node

可以使用以下命令解决：

Tianji 介绍

Sat, 22 Jun 2024 14:40:45 +0800

介绍

Tianji 是一个集网站分析、网站状态监控、服务状态监控集一体的工具平台。

在我们日常使用中，我们在观察监控一个网站使往往需要使用多个工具一起使用，例如使用 GA 来进行 PV/UV 数据的收集，使用 uptime monitor 来查看服务器的网络及连通性，使用 prometheus 来查看服务器的状态等那么有没有一个工具能满足这些需求呢？Tianji 就是这样一个工具，能够更方便更简洁的满足用户的需求。

安装

docker 安装 Tianji

wget https://raw.githubusercontent.com/msgbyte/tianji/master/docker-compose.yml
docker compose up -d

默认账号密码是 admin/admin

kubernetes 安装 Tianji

kubernetes 环境下可以使用 Helm 安装

helm repo add msgbyte https://msgbyte.github.io/charts
helm search repo tianji
helm install tianji msgbyte/tianji

本文使用了 Docker 进行安装，接下来的介绍也会以这个环境为主。

使用

安装完浏览器打开 http://localhost:12345/ 输入默认账号密码即进入主界面。

可以看到有六个栏目，接下来依次介绍这六个栏目的使用。

网站

网站顾名思义就是统计网站的 PV/UV 数据，创建好一个网站后，可以在你的网站中嵌入相应的脚本代码，就可追踪相应的用户数据。

监控器

监控器就是针对网站云服务进行一个相应的监控，保证服务的稳定性。

AI 检测文件类型 Magika

Sat, 15 Jun 2024 13:59:48 +0800

magika 介绍

Magika 是 Google 推出的一个新型工具，使用 AI 用来文件类型的检测，采用了高度优化的 Keras 模型，具有较高的准确性、模型较小等优点，支持100多种文件类型，准确性高达 99%,推测每个文件的时间大约 5 ms。

Magika 在 Google 内部已被大量使用，用于 Gmail，网络硬盘等应用，检测各种文件，提高了用户的安全性。

Magika 提供了 Pyhton 命令行、Pyhton API 和 js 包等多种方式使用，还支持批量处理提高推理速度。

安装

可以使用 pip 命令进行安装：pip install magika

如果没有 Python 环境，还可以 Docker 中进行使用：

git clone https://github.com/google/magika
cd magika/
docker build -t magika .
docker run -it --rm -v $(pwd):/magika magika -r /magika/tests_data

如果 Docker 环境也没有，那你可以使用 Google 部署的网站进行试用 https://google.github.io/magika/。

运行

运行仓库提供的测试数据 (magika -r /magika/tests_data):

可以看到文件的类型很精准的被识别出来了。

接下来做个试验，将一个 png 的图片的后缀修改为 jpg ,看看还能否正确识别，可以看到还是成功精准识别了。

使用 Coze 打造专属 AI Bot

Sat, 01 Jun 2024 14:58:48 +0800

前言

Coze 是新一代一站式 AI Bot 开发平台。无论你是否有编程基础，都可以在 Coze 平台上快速搭建基于 AI 模型的各类问答 Bot，从解决简单的问答到处理复杂逻辑的对话。并且，你可以将搭建的 Bot 发布到各类社交平台和通讯软件上，与这些平台/软件上的用户互动。

Coze 具有以下功能及优势：

Coze 提供了丰富的插件集合，可以扩展你的 Bot 的能力。用户也可进行插件的自定义，将现有的 API 能力通过配置的方式让 Bot 进行调用。
提供了知识库功能来管理和存储数据，可以让 Bot 使用知识库的内容进行回答。
长期记忆能力，Coze 提供了用于长期记忆的数据库功能，Bot 可以持久化的记住用户输入的参数和内容。
定时任务支持，Coze 支持为 Bot 创建定时任务，无需编写任何代码，只需输入任务描述，Bot 会暗示执行任务。
工作流，Coze 支持通过可视化的方式来创建工作流。
多 Agent 支持

Coze 有国内版 (www.coze.cn) 和国际版[www.coze.com]，本篇文章使用国际版进行介绍如何创建一个 Bot。

创建 Bot

注册完 Coze 账号，先创建 Bot，点击 Create Bot

输入 Bot 名称，这里由于想搭建一个 blog 助手，于是输入 Blog Assistant，然后上次 Bot 图像，如果没有合适的图像，也可以使用 DALL·E-3 生成头像。

设置

创建完 Bot 后，就进入 Bot 的设置页面。

golang 生成 slug 字符串

Sat, 25 May 2024 14:36:34 +0800

slug 介绍

slug 在不同的场景有不同的意义，在 URL 中表示一种用于描述资源的短简洁易于理解的资源描述符，在数据库系统中还可以用于描述资源的唯一标识符，总的来说 slug 可以用来标识和描述资源的文本标识符，有很好的可读性和唯一性。

本文将介绍 golang 中如何根据字符串生成相应的 slug 文本。

安装

执行 go get -u github.com/gosimple/slug 来安装 slug

使用

先介绍 slug 库的基础使用方法：

package main

import (
	"fmt"
	"github.com/gosimple/slug"
)

func main() {
	text := slug.Make("overstarry home")
	fmt.Println(text)
	text = slug.Make("text generate")
	fmt.Println(text)
}

运行后：

overstarry-home
text-generate

除了基础的转换功能，slug 还支持将不同的语言进行转换，查看下面的例子：

func main() {
	text := slug.Make("overstarry home")
	fmt.Println(text)
	text = slug.Make("text generate")
	fmt.Println(text)
	text = slug.Make("Hellö Wörld хелло ворлд")
	fmt.Println(text) 

	someText := slug.Make("影師")
	fmt.Println(someText) 
    enText := slug.MakeLang("This & that", "en")
	fmt.Println(enText) 
}

overstarry-home
text-generate
hello-world-khello-vorld
ping-guo
this-and-that

如果想要保留大写字母，可以设置 slug.Lowercase 参数来实现。如果想实现自定义的替换可以使用 slug.CustomSub 来实现。

metabase 介绍及简单使用

Fri, 17 May 2024 23:06:45 +0800

前言

前面的文章介绍过一个开源的大数据可视化工具 - Apache Superset，本文将介绍作者最近了解到的另一个可视化工具 Metabase。

Metabase 介绍

Metabase 是一个简单易用的开源项目，旨在为公司中的每个人提供商业智能和分析的最简单、最快捷的方法。Metabase 具有以下核心优势和主要功能：

短时间内完成设置。
团队成员不需要 SQL 知识基础。
提供 SQL 编辑器来进行更复杂的查询。
构建漂亮、交互式的仪表盘，包括过滤器、自动刷新、全屏显示和自定义点击行为等功能。
定义规范的细分和指标供团队使用
使用仪表板订阅按计划将数据发送到 Slack 或发送电子邮件。
设置警报，让数据更改时通知您。
在应用程序中嵌入图表及仪表盘。
配置了细粒度的数据权限功能，方便进行数据安全控制。

安装

接下来介绍如何安装 Metabase，我们将使用 docker 部署的方式进行安装。

docker-compose.yaml 内容如下：

version: '3.9'
services:
  metabase:
    image: metabase/metabase:latest
    container_name: metabase
    hostname: metabase
    volumes:
    - /dev/urandom:/dev/random:ro
    ports:
      - 3000:3000
    environment:
      MB_DB_TYPE: postgres
      MB_DB_DBNAME: metabaseappdb
      MB_DB_PORT: 5432
      MB_DB_USER: metabase
      MB_DB_PASS: mysecretpassword
      MB_DB_HOST: postgres
    networks:
      - metanet1
    healthcheck:
      test: curl --fail -I http://localhost:3000/api/health || exit 1
      interval: 15s
      timeout: 5s
      retries: 5
  postgres:
    image: postgres:latest
    container_name: postgres
    hostname: postgres
    environment:
      POSTGRES_USER: metabase
      POSTGRES_DB: metabaseappdb
      POSTGRES_PASSWORD: mysecretpassword
    networks:
      - metanet1
networks:
  metanet1:
    driver: bridge

执行 docker compose up -d 即可启动服务。接下来访问 http://127.0.0.1:3000/ 进行安装，设置完语言密码默认数据库，安装即算完成。

Go 生成 Google analytics 衡量 ID

Thu, 18 Apr 2024 21:51:54 +0800

Google Analytics 介绍

Google Analytics（分析）4 是一项分析服务，用于衡量您的网站和应用中的流量和互动情况。本文将介绍如何通过调用 Google Analytics admin API 来生成 Google Analytics 衡量 ID.

配置

启用 API

在 Google Cloud console 后台 API 和服务启用 Google Analytics Admin API。

配置服务账号

为了调用 API，我们需要创建一个服务账号，然后为创建的服务账号添加密钥。

需要注意的是还需要在 Google Analytics 为服务账号添加权限，不然请求接口会没数据。

安装 go 客户端

接下来安装 go 客户端：

go get google.golang.org/api/analyticsadmin/v1alpha

生成流程

接下来我们会按照常规的 id 生成流程编写相应的代码，流程: 1 获取账号信息

通过 List 接口获取当前服务账号所拥有的所有 Google Analytics 账户信息。

    accountsService := analyticsadmin.NewAccountsService(service)
	accountsReply, err := accountsService.List().Do(); 
	if err != nil {
		log.Fatal("list account err",err)
		return
	}
	for _,acc := range accountsReply.Accounts {
		fmt.Println(acc.Name)
	}

2 创建媒体资源

docker init 命令

Sat, 13 Apr 2024 23:26:38 +0800

前言

Docker 是一个广受欢迎的开发平台，它允许用户通过容器化技术来构建、打包和部署应用程序。尽管 Docker 提供了强大的功能和灵活性，但对于初学者而言，在项目中配置 Docker 可能会遇到一些挑战。

不过，Docker 官方为了降低使用门槛，推出了一个便捷的命令docker init。这个命令旨在快速初始化 Docker 配置，从而简化将 Docker 集成到项目中的流程。通过使用这个命令，用户可以轻松地为项目设置必要的 Docker 支持，进而享受到 Docker 带来的便利和效率提升。

docker init 简介

docker init 命令会根据用户指定的选项生成运行容器的一些文件，极大的加快了项目的容器化：

.dockerignore : docker 构建时忽略的文件列表
Dockerfile: 镜像的核心文件
Compose.yaml: docker compose 的配置文件
README.Docker.md

如果你的项目中已有以上文件，会让你选择是否覆盖旧文件避免文件冲突问题。

docker init 提供了一组项目的模板文件，包括了 Go、Python、ASP.NET Core 等常见的服务器应用程序及一个其它类型应用程序模板。开发者使用 init 命令时，可以根据选择的模板生成相应的文件，使开发者可以快速的构建并启动容器。

使用

接下来介绍如何使用 docker init 进行项目容器的初始化，这里以前文的 go 项目为例子进行介绍。

进入项目根目录执行 init 命令，选择 go 模板，会让你选择使用的 go 版本，主程序的位置及应用所使用的端口：

执行完可以看到会生成相应的文件及如何构建并运行的命令。

查看生成的 Dockerfile 和 Compose.yaml 文件：

# syntax=docker/dockerfile:1

# Comments are provided throughout this file to help you get started.
# If you need more help, visit the Dockerfile reference guide at
# https://docs.docker.com/go/dockerfile-reference/

# Want to help us make this template better? Share your feedback here: https://forms.gle/ybq9Krt8jtBL3iCk7

################################################################################
# Create a stage for building the application.
ARG GO_VERSION=1.21.0
FROM --platform=$BUILDPLATFORM golang:${GO_VERSION} AS build
WORKDIR /src

# Download dependencies as a separate step to take advantage of Docker's caching.
# Leverage a cache mount to /go/pkg/mod/ to speed up subsequent builds.
# Leverage bind mounts to go.sum and go.mod to avoid having to copy them into
# the container.
RUN --mount=type=cache,target=/go/pkg/mod/ \
    --mount=type=bind,source=go.sum,target=go.sum \
    --mount=type=bind,source=go.mod,target=go.mod \
    go mod download -x

# This is the architecture you’re building for, which is passed in by the builder.
# Placing it here allows the previous steps to be cached across architectures.
ARG TARGETARCH

# Build the application.
# Leverage a cache mount to /go/pkg/mod/ to speed up subsequent builds.
# Leverage a bind mount to the current directory to avoid having to copy the
# source code into the container.
RUN --mount=type=cache,target=/go/pkg/mod/ \
    --mount=type=bind,target=. \
    CGO_ENABLED=0 GOARCH=$TARGETARCH go build -o /bin/server ./retry/server

################################################################################
# Create a new stage for running the application that contains the minimal
# runtime dependencies for the application. This often uses a different base
# image from the build stage where the necessary files are copied from the build
# stage.
#
# The example below uses the alpine image as the foundation for running the app.
# By specifying the "latest" tag, it will also use whatever happens to be the
# most recent version of that image when you build your Dockerfile. If
# reproducability is important, consider using a versioned tag
# (e.g., alpine:3.17.2) or SHA (e.g., alpine@sha256:c41ab5c992deb4fe7e5da09f67a8804a46bd0592bfdf0b1847dde0e0889d2bff).
FROM alpine:latest AS final

# Install any runtime dependencies that are needed to run your application.
# Leverage a cache mount to /var/cache/apk/ to speed up subsequent builds.
RUN --mount=type=cache,target=/var/cache/apk \
    apk --update add \
        ca-certificates \
        tzdata \
        && \
        update-ca-certificates

# Create a non-privileged user that the app will run under.
# See https://docs.docker.com/go/dockerfile-user-best-practices/
ARG UID=10001
RUN adduser \
    --disabled-password \
    --gecos "" \
    --home "/nonexistent" \
    --shell "/sbin/nologin" \
    --no-create-home \
    --uid "${UID}" \
    appuser
USER appuser

# Copy the executable from the "build" stage.
COPY --from=build /bin/server /bin/

# Expose the port that the application listens on.
EXPOSE 9000

# What the container should run when it is started.
ENTRYPOINT [ "/bin/server" ]

可以看到 Dockerfile 是一个常见的多阶段构建镜像流程。

gRPC 客户端负载均衡

Sat, 30 Mar 2024 15:40:29 +0800

gRPC 中的负载均衡包括服务端负载均衡和客户端负载均衡，本文将介绍客户端负载均衡，gRPC 中的客户端负载均衡主要有 2 个部分:1) Name Resolver 2) Load Balancing Policy 接下来将依次介绍。

Name Resolver

gRPC 中的默认 name-system 是 DNS , 同时各种客户端还提供了插件以使用自定义 name-system。gRPC Name Resolver 会根据 name-system 进行对应的解析，将用户提供的名称转换为对应的地址。

Load Balancing Policy

gRPC 中内置了多种负载均衡策略，本文将介绍常见的几种负载均衡策略:1) pick_first 2) round_robin

pick_first

pick_first 是默认的负载均衡策略，该策略从 Name Resolver 获得到服务器的地址列表，按顺序依次对每个服务器地址进行连接，直到连接成功，如果某个地址连接成功则所有的 RPC 请求都会发送到这个服务器地址。

round_robin

round_robin 策略，该策略从 Name Resolver 获得到服务器的地址列表，依次将请求发送到每一个地址，例如第一个请求将发送到 backend1 ,第二个请求将发送到 backend2。

接下来分别使用这两种策略进行测试。

例子

我们先创建服务端，循环创建了 3 个服务端，分别使用 30051、30052、30053 端口。

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"sync"

	"google.golang.org/grpc"

	pb "github.com/overstarry/grpc-example/proto/echo"
)

var (
	addrs = []string{":30051", ":30052",":30053"}
)

type ecServer struct {
	pb.UnimplementedEchoServer
	addr string
}

func (s *ecServer) UnaryEcho(ctx context.Context, req *pb.EchoRequest) (*pb.EchoResponse, error) {
	return &pb.EchoResponse{Message: fmt.Sprintf("%s (from %s)", req.Message, s.addr)}, nil
}

func startServer(addr string) {
	lis, err := net.Listen("tcp", addr)
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer()
	pb.RegisterEchoServer(s, &ecServer{addr: addr})
	log.Printf("serving on %s\n", addr)
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

func main() {
	var wg sync.WaitGroup
	for _, addr := range addrs {
		wg.Add(1)
		go func(addr string) {
			defer wg.Done()
			startServer(addr)
		}(addr)
	}
	wg.Wait()
}

接下来创建对应的客户端连接：

gRPC 请求重试

Sat, 23 Mar 2024 21:56:51 +0800

前面的文章介绍了 gRPC 相关的功能，今天继续介绍 gRPC 的功能，本文将介绍 gRPC 的重试功能。

介绍

请求的重试是一个常见的功能，在我们日常的使用中，如果需要重试请求往往需要使用外部包进行实现，在 gRPC 中内置了重试了功能，不需要我们自己实现。

通过查阅 gRPC 的文档可以看到，gRPC 会根据开发者设定的策略进行失败 RPC 的重试，有两种策略 1) 重试策略：重试失败的 RPC 请求 2) hedging 策略：并行发生相同 RPC 请求。单个 RPC 请求可以选择两种重试策略中的一种，不能同时选择多种策略。

重试策略有以下参数可以使用：

maxAttempts: 必填 RPC 最大请求次数，包括原始请求
initialBackoff, maxBackoff, backoffMultiplier: 必填决定下次重试前的延迟时间 random(0, min(initialBackoff*backoffMultiplier**(n-1), maxBackoff))
retryableStatusCodes: 必填收到服务器非正常状态码时，根据 retryableStatusCodes 中的状态码列表决定是否重试请求

hedging 策略可以主动发送单个请求的多个副本，而无需等待响应。需要注意的是，此策略可能会导致后端多次执行，因此最好仅对可以多次执行不会有不利影响的请求开启此策略。有如下参数：

maxAttempts 必填
hedgingDelay 可选
nonFatalStatusCodes 可选

一个请求在没有收到成功响应时，经过 hedgingDelay 没收到响应将继续发送请求，直至达到 maxAttempts 最大次数或请求成功。当收到成功响应时，所有未完成的其它请求将停止。本质上 hedging 策略可以看作在收到失败响应前重试请求。

使用

接下来讲解如何在 gRPC go 语言版本中配置使用重试功能。

服务端

服务端创建一个服务，只有当请求次数达到第三次时，才返回成功响应。

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net"
	"sync"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	pb "github.com/overstarry/grpc-example/proto/echo"
)

var port = flag.Int("port", 9000, "port number")

type failingServer struct {
	pb.UnimplementedEchoServer
	mu sync.Mutex

	reqCounter uint
	reqModulo  uint
}


func (s *failingServer) maybeFailRequest() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.reqCounter++
	if (s.reqModulo > 0) && (s.reqCounter%s.reqModulo == 0) {
		return nil
	}

	return status.Errorf(codes.Unavailable, "maybeFailRequest: failing it")
}

func (s *failingServer) UnaryEcho(ctx context.Context, req *pb.EchoRequest) (*pb.EchoResponse, error) {
	if err := s.maybeFailRequest(); err != nil {
		log.Println("request failed count:", s.reqCounter)
		return nil, err
	}

	log.Println("request succeeded count:", s.reqCounter)
	return &pb.EchoResponse{Message: req.Message}, nil
}

func main() {
	flag.Parse()

	address := fmt.Sprintf(":%v", *port)
	lis, err := net.Listen("tcp", address)
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	fmt.Println("listen on address", address)

	s := grpc.NewServer()

	
	failingservice := &failingServer{
		reqCounter: 0,
		reqModulo:  3,
	}

	pb.RegisterEchoServer(s, failingservice)
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

客户端

客户端通过 WithDefaultServiceConfig 设置配置好重试功能

阿里云 dms 占用数据库连接问题及解决

Sat, 16 Mar 2024 19:37:23 +0800

问题

最近收到了阿里云云数据库的报警信息，提示数据库连接数过高，通过监控可以看到，数据库的连接数升高了 50%,其它指标保持正常。

分析及解决

通过阿里云后台的一键诊断中的会话管理可以看到占用大量连接的 ip 地址，可以看到 100.104.205.90、100.104.205.83 和 100.104.205.6 这三个 ip 占用了大量连接，可以看到并没有 sql 请求，只是单纯的保持数据库连接，通过查看阿里云文档和询问客服，可以得知这个 ip 地址是阿里云 dms 服务的地址，。

找到原因后就好解决了，可以使用SELECT pg_terminate_backend(pid)语句释放数据库连接，使用语句释放与这三个 ip 相关的数据库连接:select pg_terminate_backend(pid) from pg_stat_activity where client_addr in ('100.104.205.90','100.104.205.83') ,过了一会数据库连接恢复正常了。

小结

本文通过阿里云数据库连接过高的问题，分析遇到此类问题时如何排查并解决。

参考

https://help.aliyun.com/zh/dms/configure-an-ip-address-whitelist

Kubernetes 系统资源预留

Sat, 09 Mar 2024 21:23:52 +0800

前言

Kubernetes 的 pod 可以按照节点的资源进行调度，默认情况下 pod 能够使用节点的全部资源，这样往往会出现因为节点自身运行的一些驱动及 Kubernetes 系统守护进程，导致资源不足的问题。例如有一个应用在运行中使用了大量的系统资源，导致 kubelet 和 apiserver 的心跳出现故障，导致节点处于 Not Ready 的状态，节点出现 Not Ready 的状况后，过一会儿会将 pod 调度到其它 node 节点上运行，往往会导致节点雪崩，一个接一个的出现 Not Ready 状况。

那么如何解决这个问题呢？这时可以通过为 Kubernetes 集群配置资源预留，kubelet 暴露了一个名为 Node Allocatable 的特性，有助于为系统守护进程预留计算资源，Kubernetes 也是推荐集群管理员按照每个节点上的工作负载来配置 Node Allocatable。

Node Allocatable

Kubernetes 节点上的 Allocatable 被定义为 Pod 可用计算资源量。调度器不会超额申请 Allocatable。目前支持 CPU、内存和存储这几个参数。可以通过 kubectl describe node 命令查看节点可分配资源的数据：

可以看到有 Capacity 和 Allocatable 两个内容，Allocatable 这个就是节点可分配资源，由于没有设置，所以默认 Capacity 和 Allocatable 是一致的。

Capacity 是节点所有的系统资源，kube-reserved 是给 kube 组件预留的资源，system-reserved 是给系统进程预留的资源，eviction-hard 是 Kubelet 的驱逐阈值。

atop 工具介绍及使用

Sat, 02 Mar 2024 17:32:25 +0800

前言

最近出现了服务器 cpu、内存升高导致服务器宕机的问题，发生宕机后，往往由于对系统资源数据收集的不齐全，导致无法快速查明发生宕机的原因。在通过云厂商客服和网络相关资料帮助下，了解了 atop 这个工具，本机对 atop 的安装及使用进行介绍。

atop 介绍

atop 是一款用于监控 Linux 系统资源与进程的工具，能够报告所有进程的活动。其以一定的频率记录系统和进程活动，采集的数据包含 CPU、内存、磁盘、网络的资源使用情况和进程运行情况，并能以日志文件的方式保存在磁盘中。对于每个进程，会显示 CPU 使用率、内存增长、磁盘使用率、优先级、用户名、状态和退出码等。当服务器出现问题后，可以根据相应的 atop 日志文件进行分析。

安装

atop 不是系统的内部自带命令，需要进行安装，接下来以 Ubuntu 系统为例子，介绍如何安装 atop 命令。

1 更新软件源

执行 sudo apt update 进行软件源的更新。

2 安装 atop

执行 sudo apt install atop 命令安装 atop。

配置

安装完 atop 后，可以使用 atop 的默认配置使用，也可根据使用情况修改默认配置，atop 默认配置在 /etc/sysconfig/atop,查看默认配置文件内容：

# /etc/default/atop
# see man atoprc for more possibilities to configure atop execution

LOGOPTS="-R"
LOGINTERVAL=600
LOGGENERATIONS=28
LOGPATH=/var/log/atop

LOGINTERVAL 是监控周期，默认 600s，LOGGENERATIONS 是日志文件保留周期，默认是 28 天，可以根据具体的需求进行修改。

Kubernetes ExternalName

Sat, 24 Feb 2024 13:52:30 +0800

前言

我们知道 kubernetes 内部服务之间是通过 service 进行相互访问的，那么如果现在有一个非 kubernetes 部署的服务，我们可以也通过 service 进行内部交互使用吗？答案是可以，我们可以使用 service 的 ExternalName 类型将 service 映射到外部服务上。

最近需要将一个外部服务映射到 kubernetes service 上，通过查找资料学习，本文记录如何将 kubernetes service 映射到外部服务的流程步骤。

外部域名映射内部 service

先讲解如何将外部服务通过域名的方式映射到内部 service 上，通过配置 externalName 字段来配置映射关系。例如，以下 Service 定义将 test 命名空间中的 my-service 服务映射到 my.overstarry.vip:

apiVersion: v1
kind: Service
metadata:
  name: my-service
  namespace: test
spec:
  type: ExternalName
  externalName: my.overstarry.vip

虽然 externalName 也支持填写 ip 地址，但不会被 kubernetes 解析，如果需要使用 ip 地址，可以使用无头服务 Headless，下文会进行介绍。

外部服务 ip 映射 service

接下来介绍没有域名的外部服务和 service 如何进行映射。上文讲过虽然 externalName 也支持填写 ip 地址，但不会被 kubernetes 解析，如果需要，则应该使用 Headless Service 进行映射。

Go 刷新 cdn

Fri, 19 Jan 2024 22:51:52 +0800

前言

cdn 刷新是 cdn 使用过程中的一项重要的功能，通过刷新功能，您可以删除 CDN 节点上已经缓存的资源，并强制 CDN 节点回源站获取最新资源，适用于源站资源更新和发布、违规资源清理、域名配置变更等。

接下来将分别讲述阿里云 CDN、AWS cloudfront、Cloudflare cdn 使用 go 语言进行 cdn 的刷新操作的。

阿里云刷新 cdn

如何刷新阿里云 cdn 的缓存呢？只需使用阿里云 openapi 的 go sdk 即可，通过查阅文档，我们只需使用 RefreshObjectCaches API 即可刷新阿里云 cdn 的缓存，RefreshObjectCaches 有以下参数：

ObjectPath: 刷新的url ,多个 url 使用换行符进行分隔
ObjectType: 刷新任务的类型，有以下类型 
    File（默认值）：文件刷新。
    Directory：目录刷新。
    Regex：正则刷新。
    IgnoreParams：去参数刷新。去参数指的是去除请求 URL 中?及?之后的参数，去参数刷新指的是用户先通过接口提交去参数后的 URL，然后用户提交的待刷新 URL 将会与已缓存资源的 URL 进行去参数匹配，如果已缓存资源的 URL 去参数以后与待刷新 URL 匹配，那么 CDN 节点将对缓存资源执行刷新处理。
Force: 当回源内容和源站资源对比后不一致时，是否刷新对应目录下的资源。默认为 false。

下面是一个例子：

package main

import (
	cdn20180510 "github.com/alibabacloud-go/cdn-20180510/v4/client"
	openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
	util "github.com/alibabacloud-go/tea-utils/v2/service"
	"github.com/alibabacloud-go/tea/tea"
	"os"
)

func CreateClient(accessKeyId *string, accessKeySecret *string) (result *cdn20180510.Client, err error) {
	config := &openapi.Config{
		AccessKeyId:     accessKeyId,
		AccessKeySecret: accessKeySecret,
	}
	config.Endpoint = tea.String("cdn.ap-southeast-1.aliyuncs.com")
	result = &cdn20180510.Client{}
	result, err = cdn20180510.NewClient(config)
	return result, err
}

func main() {
	client, err := CreateClient(tea.String(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")), tea.String(os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")))
	if err != nil {
		return
	}

	refreshObjectCachesRequest := &cdn20180510.RefreshObjectCachesRequest{
		ObjectPath: tea.String("http://example.com/image/1.png\\\n\t\thttp://aliyundoc.com/image/2.png"),
	}
	runtime := &util.RuntimeOptions{}
	_, err = client.RefreshObjectCachesWithOptions(refreshObjectCachesRequest, runtime)
	if err != nil {
		return
	}

	return
}

aws cloudfront

接下来讲解 aws cloudfront 如何刷新 cdn，cloudfront 刷新缓存的操作叫使文件失效，通过查阅 cloudfront 的 API 文档，发现可以使用 CreateInvalidation 来创建失效。可以使用 aws go sdk 来进行操作。

Apisix 开启 gzip

Sat, 13 Jan 2024 16:10:31 +0800

最近使用 Apisix 网关时，需要开启 gzip 功能，通过查阅资料学习，了解了几种开启 gzip 的方式，本文记录 2 种 Apisix 开启 gzip 的方式。

gzip 插件

我们可以使用 gzip 插件针对某些路由开启 gzip，只需对路由使用 gzip 插件并配置一些插件属性即可。

接下来使用一个例子来演示 gzip 插件，使用 apisix admin api 创建一条路由，要注意的是本文的例子是使用 apisix 3.7 版本：

curl -i http://127.0.0.1:9180/apisix/admin/routes  \
-H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X POST -d '
{
	"uri": "/get",
	"plugins": {
		"gzip": {
			"buffers": {
				"number": 8
			},
		"comp_level": 6,
		"disable": false,
		"types": "*"
		}
	},
	"upstream": {
    "nodes": [
      {
        "host": "httpbin.org",
        "port": 443,
        "weight": 1
      }
    ],
    "timeout": {
      "connect": 6,
      "send": 6,
      "read": 6
    },
    "type": "roundrobin",
    "scheme": "https",
    "pass_host": "pass",
    "keepalive_pool": {
      "idle_timeout": 60,
      "requests": 1000,
      "size": 320
    }
  },
	"status": 1
}'

如何收集系统宕机后的内存转储信息

Sat, 06 Jan 2024 14:46:21 +0800

前言

最近出现了多次因为各种原因导致的操作系统宕机的问题，为了查找系统宕机的原因，需要收集系统宕机后的内存转储信息。本文就介绍几种常见的方式。

阿里云内置命令收集

由于主要使用的是阿里云的服务器，就先介绍阿里云收集系统宕机内存转储信息的方式。

阿里云系统默认没有开启 dump 配置，我们需要使用以下命令开启：acs-plugin-manager --exec --plugin=ecs_dump_collector --params="--enable"

那我们如何收集内存转储信息呢，执行以下命令：acs-plugin-manager --exec --plugin=ecs_dump_collector --params="-c" 出现以下信息表示收集成功。

有了转储信息文件我们就可以将文件交给专业的运维人员或阿里云工程师进行宕机原因分析。

使用 Crash + Kdump

如果我们没有使用阿里云的服务该如何收集系统崩溃的转储信息呢，我们可以使用 Crash + Kdump 进行收集，通过前面的使用可以看出阿里云的插件就是使用了这两个工具，接下来开始进行简单的介绍。

安装

需要先安装 Crash + Kdump，使用此命令进行安装：

$ sudo apt install linux-crashdump
$ sudo apt install crash

安装完为了使服务生效需要重启服务器。

使用以下命令：sudo cat /etc/default/grub.d/kdump-tools.cfg

可以看出系统保留了 192M RAM 内存区供转储捕获内核使用

收集

为了测试方便我们可以使用此命令快速触发崩溃：sudo echo c > /proc/sysrq-trigger 。命令执行后在 /var/crash 目录会生成以当前时间为名称的目录，目录里面就是收集到的转储信息。

demsg.x 为崩溃时候的系统内核日志，dump.x 文件则为转储的内核快照文件。为了更好的查找问题，我们还需要安装 vmlinux，使用以下命令安装：

go 汉字转拼音 go-pinyin

Sat, 23 Dec 2023 23:40:04 +0800

前言

本文介绍一个 go 汉字转拼音的库 go-pinyin，可以从名字看出这个库的功能就是将汉字转换为相应的拼音。接下来就由我来简单的介绍 go-pinyin。

安装

使用此命令安装：go get github.com/mozillazg/go-pinyin

cli 安装

如果你的 go 版本在 1.17 以下使用此命令安装：go get -u github.com/mozillazg/go-pinyin/cli/pinyin。1.17 及以上版本使用此命令安装：go install github.com/mozillazg/go-pinyin/cli/pinyin@latest。

使用

接下来将分别介绍 cli 的使用和 API 的使用。

cli 使用

安装完在终端输入 pinyin，可以看到使用的方法，尝试一个汉字，可以看到相应的拼音，但也可以看出对多音字的支持有问题。

$ pinyin 中国
zhōng guó 
$ pinyin 重庆
zhòng qìng

接下来介绍 API 的使用。

api 使用

通过查看文档，可以看出主要是 2 个方法 pinyin.NewArgs 和 pinyin.Pinyin 。

pinyin.NewArgs 创建包含默认配置的 Args, 可以通过修改 Args 的成员来使用不同的模式。

type Args struct {
	Style     int    // 拼音风格（默认：Normal)
	Heteronym bool   // 是否启用多音字模式（默认：禁用）
	Separator string // Slug 中使用的分隔符（默认：-)

	// 处理没有拼音的字符（默认忽略没有拼音的字符）
	// 函数返回的 slice 的长度为 0 则表示忽略这个字符
	Fallback func(r rune, a Args) []string
}

pinyin.Pinyin 就是将汉字转为拼音。

mergo 介绍

Sat, 16 Dec 2023 22:15:27 +0800

前言

今天介绍一个 go 库 - mergo, mergo 用来方便的合并 struct 和 map ,可以将结构体的字段赋值到 map 中，可以将 map 的值赋值给结构体的字段。

Mergo 通过在零值字段中设置默认值来合并同类型的 struct 和 map。Mergo 不会合并未导出（私有）字段。它会递归合并任何已导出的字段。它也不会合并 map 中的结构体（因为它们无法使用 Go 反射寻址）。

Mergo 在很多知名项目中被使用，如 containerd、k8s、loki 等。

安装

使用以下命令安装 mergo : go get -u dario.cat/mergo

使用

接下来介绍 mergo 的基础使用和高级用法。

基础使用

mergo 提供了 2 个主要函数：Merge 和 Map, Mergo 用来合并 2 个相同结构的 struct 和 map, Map 用来在结构和 map 之间赋值。

例子：

package main

import (
	"fmt"
	"log"

	"github.com/imdario/mergo"
)

type redisConfig struct {
	Address  string
	Port     int
	DB       int
	UserName string
	PassWord string
}

var defaultConfig = redisConfig{
	Address:  "127.0.0.1",
	Port:     6379,
	DB:       1,
	UserName: "123",
	PassWord: "123",
}

func main() {
	var config redisConfig

	if err := mergo.Merge(&config, defaultConfig); err != nil {
		log.Fatal(err)
	}

	fmt.Println("redis address: ", config.Address)
	fmt.Println("redis port: ", config.Port)
	fmt.Println("redis db: ", config.DB)
	fmt.Println("redis username: ", config.UserName)
	fmt.Println("redis password: ", config.PassWord)

	var m = make(map[string]interface{})
	if err := mergo.Map(&m, defaultConfig); err != nil {
		log.Fatal(err)
	}

	fmt.Println(m)
}

接下来介绍一些高级用法：

conc 一个更好的 go 并发库

Sat, 09 Dec 2023 23:58:07 +0800

前言

本文介绍 conc - 一个更好的 go 并发库，sourcegraph 在日常开发中使用 go 原生并发出现了问题，由此开发了 conc，相比标准并发代码更优雅，代码更少，下面展示一个例子，可以看出代码减少了许多。

type propagatedPanic struct {
    val   any
    stack []byte
}
 
func main() {
    done := make(chan *propagatedPanic)
    go func() {
        defer func() {
            if v := recover(); v != nil {
                done <- &propagatedPanic{
                    val:   v,
                    stack: debug.Stack(),
                }
            } else {
                done <- nil
            }
        }()
        doSomethingThatMightPanic()
    }()
    if val := <-done; val != nil {
        panic(val)
    }
}

// conc

func main() {
    var wg conc.WaitGroup
    wg.Go(doSomethingThatMightPanic)
    // panics with a nice stacktrace
    wg.Wait()
}

安装

使用以下命令进行安装：go get github.com/sourcegraph/conc

Kubernetes externaltrafficpolicy 简介

Sun, 03 Dec 2023 09:48:07 +0800

前言

最近在使用 Kubernetes 查看 pod 日志时，发现 pod 日志显示的 ip 不是真实的请求者 ip, 而是 Node 节点的 ip。通过查阅资料发现可以通过设置 externalTrafficPolicy 来显示真实的 IP。

本文对 externaltrafficpolicy 进行一个简单的介绍。

简介

ExternalTrafficPolicy 是 Kubernetes Service 对象的一个属性，它决定了流量如何从集群外部访问 Service。有两个可选值：Cluster 和 Local。

Cluster 模式：在 Cluster 模式下，流量将通过负载均衡器分发到 Service 的所有 Pod 上。这是传统的负载均衡方式，适用于需要水平扩展和容错的场景。负载均衡器会将流量平均分配给所有可用的 Pod，从而实现负载均衡。

Local 模式：在 Local 模式下，流量将直接访问与请求最近的节点上运行的 Pod。这种方式避免了负载均衡器的介入，直接将流量定向到本地的 Pod 上。这样可以减少延迟，并且在负载均衡器发生故障时仍然保持可用性。

区别

两种模式有什么区别呢？

Cluster 模式

Cluster 模式是默认的模式，Kube-proxy 不管容器在哪个节点上，会公平的转发到某一个节点上，在转发时会替换掉源 ip，变成转发的上一个节点的 ip.原因是 Kube-proxy 在做转发的时候，会做一次 SNAT (source network address translation)，所以源 ip 变成了上一个节点的 ip 地址。

这个模式的优点是负载均衡比较好，缺点是由于转发，可能会有性能损耗。

Local 模式

Local 模式下，请求只转发给本机的容器，不会转发给其它节点的容器，保留了源 ip。

clarity 学习

Fri, 24 Nov 2023 22:42:32 +0800

前言

最近发现了一个新的工具-clarity, clarity 是一种免费工具，用于捕获用户使用网站。安装非常简单，可以在数分钟内开始获取数据。

clarity 有以下功能特点：

热点地图：为你的所有页面自动生成。查看用户点击的位置、他们忽略的内容以及滚动的距离。
insights: 快速发现用户在何处感到灰心，并将这些问题转化为机会。
Google Analytics: 可以方便的与 Google Analytics 关联。
会话录制：观看用户如何使用你的网站。了解运行顺畅的地方、需要改进的内容，并测试新想法。
copilot: 使用由 GPT 构建的直观对话体验来理解你的分析数据。

接下来就开始介绍 clarity 的简单使用。

clarity 使用

创建项目

登录成功后，可以选择网站或者移动项目，这里选择网站，输入相应的信息。

配置代码

填完信息，需要配置相应的代码信息，可以看到有 2 种方法，一种是知名第三方平台提供的快捷配置方法另一种是手动添加代码。这里选择手动添加代码。

配置信息

根据导览，可以配置一些信息，例如与 ga 关联，屏蔽一些隐私信息。

查看数据

根据导览的指引配置完信息后，第二天再次登录系统就可以看到数据了。可以看到有 4 个主要的模块栏目：仪表盘、录制、热度地图、ga，接下来分别介绍这 4 个部分。

仪表盘

仪表盘主要就是用户在你网站上访问的整体数据的展现。

录制

录制通过名字就可以得知这个是对用户在你页面上浏览情况的录制，可以看到用户的访问的整体情况，点击了哪些元素等。

热度地图

热度地图可以看到网站的哪些页面经常被访问，被访问的页面哪些部分经常被点击。

Google Analytics

Google Analytics 主要就是 ga 的数据了。

Postgresql CTE 表达式

Sun, 19 Nov 2023 12:27:37 +0800

前言

本文介绍如何使用 CTE 表达式来简化 PostgreSQL 中的一些复杂查询。那 CTE 表达式是什么呢？

CTE 介绍

在 PostgreSql 中 WITH 提供了一种方式来书写在一个大型查询中使用的辅助语句。这些语句通常被称为公共表表达式或 CTE（Common Table Expressions），它们可以被看成是定义只在一个查询中存在的临时表。在 WITH 子句中的每一个辅助语句可以是一个 SELECT、INSERT、UPDATE 或 DELETE，并且 WITH 子句本身也可以被附加到一个主语句，主语句也可以是 SELECT、INSERT、UPDATE 或 DELETE。在 PostgreSQL 中，WITH 子句提供了一种编写辅助语句的方法，以便在复杂的查询中使用。

使用

该如何创建 CTE 呢，创建 CTE 的语句如下：

WITH cte_name AS (
    SELECT column1, column2, ...
    FROM table_name
WHERE condition
    ...
    )
SELECT *
FROM cte_name;

在日常查询中 CTE 用于哪些场景呢：

递归查询：CTE 表达式常用于执行递归查询。通过在 CTE 表达式中引用自身，可以简洁地实现递归操作。
复杂查询：CTE 表达式可以用于构建复杂的查询，将查询逻辑分解为更易于理解和维护的部分。每个 CTE 子查询块可以负责不同的逻辑操作，最终组合成一个完整的查询。
数据转换和重组：CTE 表达式可以用于对数据进行转换和重组。通过在不同的 CTE 子查询块中选择、过滤和连接数据，可以生成新的结果集。

递归查询

WITH 表达式如何实现递归查询呢，可以通过添加 RECURSIVE 修饰符来实现。下面是一个示例：

Go 设计模式 - 策略模式

Sat, 11 Nov 2023 17:29:39 +0800

今天介绍一个常见的设计模式 - 策略模式，并基于一个简单的例子来讲解。

策略模式介绍

策略模式（Strategy Pattern）是一种行为型设计模式，它将一组算法封装成独立的对象，并使它们可以互相替换。这样做的好处是，可以在运行时动态地改变对象的行为，而不需要修改使用该对象的代码。

何时可以使用策略模式呢

我们在用 GO 编程的时候经常碰到多层控制语句，一层又一层，既不优雅，也不利于后续维护。比如下述这种：

if xxx {
// do something
} else if xxx {
// do something
} else if xxx {
// do something
 else {
}

虽然按这种模式写起来简单快捷，但它也违背了面向对象的两个原则：

单一职责原则：多个控制语句，意味着拥有多种功能；
开闭原则：当要进行修改时，原有代码不可避免要被修改；

此时就可以采用策略模式来替换这类多层控制语句。

go 实现策略模式

go 语言该怎么实现策略模式呢？

在 Go 语言中，策略模式可以通过接口和函数来实现。首先，我们定义一个接口，该接口声明了算法执行的方法。然后，我们可以为每个具体的算法实现一个结构体，并实现接口中的方法。最后，我们可以在需要使用算法的地方，通过接口来调用具体的算法。

下面通过一个简单的例子来讲解策略模式，现在有这样一个场景我们现在有 2 个数据表，这 2 个数据表拥有相同的字段，都可以根据 name 来查询某个数据，我们需要根据参数的不同来决定使用哪种表进行查询，在没有使用策略模式时，我们往往使用大量的 if 来实现这个操作。接下来由我来介绍策略模式来实现相同的操作。

先定义查询操作的接口：

type DataStrategy interface {
	Query(name string)
}

定义 2 张表的查询 struct，并实现 DataStrategy 接口：


// table1 通过 table1 来查询
type table1 struct{}

func (s *table1) Query(name string) {
	fmt.Println("table1 query")
}

// table2
type table2 struct{}

func (s *table2) Query(name string) {
	fmt.Println("table2 query")
}

再定义 Data 对象用来执行不同的策略：

Go1.22 新循环语义

Sat, 04 Nov 2023 22:54:05 +0800

前言

前段时间看到了一个提案，是关于 go for 循环的一个提案，根据提案看到了去年 rsc 在社区发出的讨论，讨论的内容主要是为了解决 for 循环变量的问题，是什么样的问题呢，常见的例子如下：

var all []*Item
for _, item := range items {
	all = append(all, &item)
}

这段代码有一个问题，循环结束后，all 的内容是包含了 len(all) 个相同的指针，指针指向迭代的最后一个 item。为什么会发生这种情况呢，因为 item 变量是每个循环的而不是每次迭代的，&item 每次迭代都是相同的，并且每次迭代都会被覆盖。怎么解决呢，最简单的方法就是添加 item := item 这段代码：

var all []*Item
for _, item := range items {
	item := item
	all = append(all, &item)
}

我在使用 Goroutine 协程时也经常遇到这种问题。这种错误已导致许多公司出现生产问题，包括 Lets Encrypt 公开记录的问题。

go 社区为了解决这个问题，打算将循环变量改为每次迭代，即隐式的添加上面的代码。由于其它一些原因，直到今年的 6 月才正式决定在 go 1.21 中添加 GOEXPERIMENT=loopvar 进行相应的尝试，并且将在 go1.22 版本中正式推出。为了确保与现有代码的向后兼容性，新语义将仅适用于声明 go 1.22 或稍后在其 go.mod 文件中声明的模块中包含的包。

特性测试

我们通过不同版本运行的结果来对比

package main

import "fmt"

func main() {
	var prints []func()
	for _, v := range []int{1, 2, 3} {
		prints = append(prints, func() { fmt.Println(v) })
	}
	for _, print := range prints {
		print()
	}
}

没使用旧版本运行的结果是：

apisix 代理 gRPC 服务

Fri, 20 Oct 2023 23:04:34 +0800

最近需要使用 apisix 来代理 gRPC 服务，本文记录一下 apisix 代理 gRPC 服务以及实践过程中遇到的一些问题。

准备

在接下来的步骤前，我们需要准备一个 gRPC 服务，我们使用 kratos 简单启动一个 gRPC 服务：

$ kratos new hellowrold
$ cd helloworld
$ kratos run

一个简单的 gRPC 服务就启动了，我们先直接请求 gRPC 服务看看，通过 postman 请求接口后，接口顺利返回相应的值。

接下来我们开始本篇的主要内容：apisix 代理服务。

apisix 代理 gRPC 服务

我们使用 apisix admin 接口创建 Route: upstream 的 scheme 指定为 grpc 或 grpcs,nodes 指定需要代理的服务地址。

curl http://127.0.0.1:9180/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "methods": ["POST", "GET"],
    "uri": "/helloworld.v1.Greeter/SayHello",
    "upstream": {
        "scheme": "grpc",
        "type": "roundrobin",
        "nodes": {
            "127.0.0.1:9001": 1
        }
    }
}'

Go 漏洞管理工具 govulncheck

Sat, 14 Oct 2023 14:45:10 +0800

前言

在 7 月份 go 团队正式推出了官方的漏洞检测工具 - govulncheck, govulncheck 默认向 https://vuln.go.dev/ 漏洞数据库请求，对数据库的请求不包含代码只有使用的包，你也可以使用 -db 来指导所使用的漏洞数据库，所使用的数据库必须实现相应的规范。

govulncheck 具有以下限制：

Govulncheck 在分析函数指针和接口调用时采用保守的方法，这可能导致一些情况下的误报或不准确的调用堆栈。
使用 reflect 进行的函数调用对于静态分析是不可见的。仅通过这些调用才能访问的易受攻击的代码将不会被报告。使用 unsafe 包可能导致漏报。
由于 Go 二进制文件不包含详细的调用信息，govulncheck 无法显示检测到的漏洞的调用图。对于二进制文件中但无法访问的代码，它可能还会报告误报。
目前还不支持 silencing 漏洞发现。请参阅 https://go.dev/issue/61211。
Govulncheck 只能读取使用 Go 1.18 及更高版本编译的二进制文件。
对于无法提取符号信息的二进制文件，govulncheck 会报告二进制文件所依赖的所有模块的漏洞。

govulncheck 架构图

govulncheck 还提供了一个可用的 API govulncheck，使开发者能够方便的将 govulncheck 集成到各种工具之中。

安装

通过以下命令安装 govulncheck:

go install golang.org/x/vuln/cmd/govulncheck@latest

使用

安装完 govulncheck 后，我们就可以使用了，进入项目路径中，执行 govulncheck ./... 。

以下是我的一个项目的输出：

Scanning your code and 508 packages across 71 dependent modules for known vulnerabilities...

Vulnerability #1: GO-2023-2102
    HTTP/2 rapid reset can cause excessive work in net/http
  More info: https://pkg.go.dev/vuln/GO-2023-2102
  Standard library
    Found in: net/http@go1.21
    Fixed in: net/http@go1.21.3
    Example traces found:
      #1: cmd\xxx\main.go:94:19: xxx.main calls kratos.App.Run, which eventually calls http.Server.Serve
      #2: cmd\xxx\main.go:94:19: xxx.main calls kratos.App.Run, which eventually calls http.Server.ServeTLS

Vulnerability #2: GO-2023-2043
    Improper handling of special tags within script contexts in html/template
  More info: https://pkg.go.dev/vuln/GO-2023-2043
  Standard library
    Found in: html/template@go1.21
    Fixed in: html/template@go1.21.1
    Example traces found:
      #1: cmd\xxx\main.go:94:19: xxx.main calls kratos.App.Run, which eventually calls template.Template.Execute
      #2: cmd\xxx\main.go:94:19: xxx.main calls kratos.App.Run, which eventually calls template.Template.ExecuteTemplate

Vulnerability #3: GO-2023-2041
    Improper handling of HTML-like comments in script contexts in html/template
  More info: https://pkg.go.dev/vuln/GO-2023-2041
  Standard library
    Found in: html/template@go1.21
    Fixed in: html/template@go1.21.1
    Example traces found:
      #1: cmd\xxx\main.go:94:19: xxx.main calls kratos.App.Run, which eventually calls template.Template.Execute
      #2: cmd\xxx\main.go:94:19: xxx.main calls kratos.App.Run, which eventually calls template.Template.ExecuteTemplate

=== Informational ===

Found 3 vulnerabilities in packages that you import, but there are no call
stacks leading to the use of these vulnerabilities. You may not need to
take any action. See https://pkg.go.dev/golang.org/x/vuln/cmd/govulncheck
for details.

Vulnerability #1: GO-2023-2045
    Memory exhaustion in QUIC connection handling in crypto/tls
  More info: https://pkg.go.dev/vuln/GO-2023-2045
  Standard library
    Found in: crypto/tls@go1.21
    Fixed in: crypto/tls@go1.21.1

Vulnerability #2: GO-2023-2044
    Panic when processing post-handshake message on QUIC connections in
    crypto/tls
  More info: https://pkg.go.dev/vuln/GO-2023-2044
  Standard library
    Found in: crypto/tls@go1.21
    Fixed in: crypto/tls@go1.21.1

Vulnerability #3: GO-2023-1988
    Improper rendering of text nodes in golang.org/x/net/html
  More info: https://pkg.go.dev/vuln/GO-2023-1988
  Module: golang.org/x/net
    Found in: golang.org/x/net@v0.9.0
    Fixed in: golang.org/x/net@v0.13.0

Your code is affected by 3 vulnerabilities from the Go standard library.

Share feedback at https://go.dev/s/govulncheck-feedback.

输出内容分为 2 块，第一块是 Vulnerability 信息，是项目中存在的漏洞，可以看到发现了 3 个漏洞及具体的原因、触发函数、发现的版本和修复的版本。第二块是 Informational 是一些没有直接引用的包中存在的安全漏洞。

Go WSDL

Sat, 23 Sep 2023 14:17:03 +0800

最近在实现一个功能时需要使用第三方的接口，由于第三方只提供了一个 WSDL 文件的链接，于是研究了 golang 如何解析 WSDL 并调用相应接口，本文就是介绍 WSDL 和 go 如何解析并调用。

WSDL 介绍

WSDL 是 Web Services Description Language（Web 服务描述语言）的缩写。它是一种用于描述基于 Web 服务的通信协议和消息格式的 XML 格式语言。

WSDL 被广泛用于描述 Web 服务的接口和操作。它定义了 Web 服务所提供的功能、方法、参数、数据类型以及与服务进行交互的方式。通过 WSDL 文件，客户端应用程序可以了解如何与特定的 Web 服务进行通信。

WSDL 文件通常包含以下几个主要部分：

服务定义：描述了 Web 服务的名称、命名空间和位置。
类型定义：定义了 Web 服务中使用的数据类型，例如字符串、整数等。
消息定义：定义了 Web 服务中使用的消息格式，包括输入和输出消息。
操作定义：定义了 Web 服务的操作或方法，包括输入和输出消息以及相关的参数。
绑定定义：定义了 Web 服务使用的通信协议和消息格式，例如 SOAP（Simple Object Access Protocol）和 HTTP（Hypertext Transfer Protocol）。
服务定义：将服务、绑定和端口等部分组合在一起，定义了 Web 服务的完整描述。

使用 WSDL，开发人员可以生成客户端代码，使其能够与 Web 服务进行交互。客户端可以根据 WSDL 文件了解 Web 服务的结构和可用方法，以便正确地构造请求和解析响应。

总之，WSDL 是一种用于描述 Web 服务接口和操作的语言，它提供了一种标准化的方式来描述和访问 Web 服务。

Nginx Ingress http 请求 413 状态码问题及解决方法

Sat, 16 Sep 2023 16:30:30 +0800

问题

最近在调用一个上传文件的接口时，发现接口调用响应状态码为 413，并且控制台显示跨域错误信息。查找了相关信息，得知 413 状态码表示请求的包体过大导致的。

出现这种情况，我想到了 2 种解决方案：1) 调整上传文件的方式 2) 调整网关的参数。

综合目前的现况，采取了第二种方式调整网关客户端请求体最大值的参数。

解决

通过查阅 nginx ingress 的文档，得知可以添加 nginx.ingress.kubernetes.io/proxy-body-size 注解来设置请求体的最大值，设置 nginx.ingress.kubernetes.io/proxy-body-size 值为合适的值后，再请求接口发现接口顺利响应。

小结

本文介绍了客户端请求接口时，由于 nginx 默认 proxy-body-size 参数太小，导致请求 413 的问题及相应的解决方案。

参考

playwright-go 浏览器截图

Sat, 02 Sep 2023 17:33:33 +0800

以前的文章介绍了 chromedp 进行浏览器网页截图，这次介绍一种新的网页截图的方法——即使用 playwright 进行浏览器网页截图。

playwright 介绍

Playwright 是一个用于自动化浏览器操作的开源工具集。它由微软开发并于 2020 年发布，旨在提供一种跨浏览器、跨平台的解决方案，可用于测试 Web 应用程序、编写爬虫、执行自动化任务等。

Playwright 支持多种主流浏览器，包括 Chrome、Firefox、Safari 和 Edge，它提供了一组简单易用的 API，可以模拟用户与 Web 页面的交互行为，例如点击、填写表单、导航等。与其他类似工具相比，Playwright 的一个重要特点是它的跨浏览器支持，这意味着你可以使用相同的代码在不同浏览器上运行你的自动化任务，而不需要为每个浏览器单独编写代码。

Playwright 还提供了强大的调试功能，可以帮助开发人员在自动化过程中定位和解决问题。它支持截图和录制操作，使得调试变得更加直观和高效。

另外，Playwright 还具有一些高级功能，例如可以模拟不同的设备、网络环境和地理位置，以及支持并发执行多个浏览器实例等，这些功能使得它在编写复杂的自动化任务时非常有用。

由于我日常主要使用 go 语言进行开发，所以本文的内容主要以 playwright 的 go 模块 playwright-go 为主要介绍。

安装

go get -u github.com/playwright-community/playwright-go

安装相关浏览器和操作系统依赖项：

go run github.com/playwright-community/playwright-go/cmd/playwright@latest install --with-deps
# Or
go install github.com/playwright-community/playwright-go/cmd/playwright@latest
playwright install --with-deps

也可以在代码中使用以下代码安装：err := playwright.Install()

通过安装截图可以看出安装了 3 大主流浏览器和 ffmpeg。

例子

接下来我们看一个官方的例子，从 Hacker News 中抓取当前投票最高的项目。


package main

import (
	"fmt"
	"log"

	"github.com/playwright-community/playwright-go"
)

func main() {
	pw, err := playwright.Run()
	if err != nil {
		log.Fatalf("could not start playwright: %v", err)
	}
	browser, err := pw.Chromium.Launch()
	if err != nil {
		log.Fatalf("could not launch browser: %v", err)
	}
	page, err := browser.NewPage()
	if err != nil {
		log.Fatalf("could not create page: %v", err)
	}
	if _, err = page.Goto("https://news.ycombinator.com"); err != nil {
		log.Fatalf("could not goto: %v", err)
	}
	entries, err := page.Locator(".athing").All()
	if err != nil {
		log.Fatalf("could not get entries: %v", err)
	}
	for i, entry := range entries {
		title, err := entry.Locator("td.title > span > a").TextContent()
		if err != nil {
			log.Fatalf("could not get text content: %v", err)
		}
		fmt.Printf("%d: %s\n", i+1, title)
	}
	if err = browser.Close(); err != nil {
		log.Fatalf("could not close browser: %v", err)
	}
	if err = pw.Stop(); err != nil {
		log.Fatalf("could not stop Playwright: %v", err)
	}
}

使用 Google Api Go Client 调用 Google Adsense 报告接口失败的问题及解决方案

Sat, 26 Aug 2023 14:13:53 +0800

问题

最近需要使用 Google Api Go Client 获取 Google Adsense 的数据，由于常规 generate 接口返回的数据是有 10w 行的限制，不满足目前的使用需要，于是使用了 csv 的生成方法 generateCsv，和 generate 相比 generateCsv 能返回更多的数据并且不需要改动太多参数。

在调用 generateCsv 接口时，发现接口不能返回正确数据，提示错误，错误信息如下：

panic: invalid character 'D' looking for beginning of value

根据错误信息可以得知错误应该是解析错误，通过方法接口和源代码看出，接口返回的是 csv 类型的数据，但 api 只针对 json 进行解析，没有判断数据类型，导致解析失败。

解决

找到问题后，我立即就想到一个方法，就是在 decode 代码里添加 csv 格式的判断，尝试了一下，由于对 csv 解析方法不熟悉，并且修改 Client 代码会导致模块更新不方便 (客户端代码都是生成的，于是决定另寻它法。通过寻找各种资料 issue 后，找到了一个可能可行的方法，就是创建手动创建 http 连接发送请求。

根据相应的文档，很快就写好了相应的代码：

package main

import (
	"context"
	"fmt"
	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"google.golang.org/api/adsense/v2"
	"google.golang.org/api/option"
	"google.golang.org/api/transport/http"
	"io"
	"net/url"
)

func main() {
	ctx := context.Background()
	var config = &oauth2.Config{
		ClientID:     "xxx.apps.googleusercontent.com", // from https://console.developers.google.com/project/<your-project-id>/apiui/credential
		ClientSecret: "GOCSPX-xxxxxx",                                      // from https://console.developers.google.com/project/<your-project-id>/apiui/credential
		Endpoint:     google.Endpoint,
		Scopes:       []string{adsense.AdsenseReadonlyScope},
		RedirectURL:  "https://developers.google.com",
	}
	//token := newOAuthClient(ctx, config)
	client, _, err := http.NewClient(ctx, option.WithTokenSource(config.TokenSource(ctx, &oauth2.Token{RefreshToken: "code"})))
	if err != nil {
		return
	}
	URL, err := url.Parse(fmt.Sprintf("https://adsense.googleapis.com/v2/accounts/pub-123123/reports:generateCsv"))
	if err != nil {
		return
	}
	query := URL.Query()
	query.Set("dateRange", "YESTERDAY")
	query.Set("dimensions", "URL_CHANNEL_NAME")
	query.Set("metrics", "PAGE_VIEWS")

	URL.RawQuery = query.Encode()
	resp, err := client.Get(URL.String())
	if err != nil {
		return
	}
	defer resp.Body.Close()
	all, err := io.ReadAll(resp.Body)
	if err != nil {
		return
	}
	fmt.Println(string(all))
}

主要逻辑就是创建到 google cloud service 的连接，调用 generateCsv 接口即可。

gonew 介绍

Sat, 19 Aug 2023 14:00:23 +0800

前几周。在关注的 go 提案每周会议中，发现了一条比较感兴趣的内容：gonew: templates for new modules ,通过标题可以猜到 gonew 应该是一个通过配置项目模板生成新项目的模块。

通过对 discussions 中 rsc 所描述的内容进行分析，可以得知为什么要启动这么一个新项目: go 团队经常收到用户的请求，想要通过模板启动一个新项目，即以某种基本的项目模板来创建一个新 Go module。Russ 私下编写了一个实现这个功能的小工具:rsc.io/tmp/gonew. Russ 在 google 内部宣传该工具后，Google 内部的一些团队便定制了一些模板 (template) ，尤其是 ServiceWeaver 团队的响应尤为积极。这一切最终让 Russ 决定引入 golang.org/x/tools/cmd/gonew。 gonew 工具的引入大幅简化了 Go 项目的创建，同时由于对自定义项目模板的支持，也可以提高 Go 项目的标准化水平。目前 gonew 工具是实验性的，后续可能会增加新的特性，但目前的核心功能是会保留的。

通过对 discussions 中社区用户开发着的回应可以看出，大家纷纷讲述了没有 gonew 前所使用的工具，并对 gonew 建言献策，可以看出大部分的开发者都十分欢迎这个新功能的。

接下来就由我来介绍 gonew。

安装

通过以下命令安装 gonew:

go install golang.org/x/tools/cmd/gonew@latest

$ go install golang.org/x/tools/cmd/gonew@latest
go: downloading golang.org/x/tools v0.12.0
go: downloading golang.org/x/mod v0.12.0

执行 gonew:

ent 相同列名排序问题解决

Sat, 12 Aug 2023 16:15:15 +0800

前言

最近在开发的时候，需要进行数据库计算，主要是根据表中的某些字段进行汇总计算，但由于数据库表中已有同名字段名，ent 不会使用计算后的指标，默认使用 schema 中定义的字段，导致无法返回正确的结果。

针对这种情况，我能想到的方法有 2 种：1) 不使用同名的字段名 2) 查找 ent 是否有相关的解决方案。

这里我采用了第二种方法，查找相关的 issues, 通过查找相关 issue，找到了相关的解决方案：ent 的 sql/modifier 特性。

场景重现

定义一个新的数据库表结构，结构如下：

func (Ad) Fields() []ent.Field {
    return []ent.Field{
        field.Float("estimated_earnings"),
        field.Int("page_views"),
        field.Time("date"),
        field.Float("page_views_rpm").Optional(),
    }
}

page_views_rpm 字段是由 estimated_earnings 和 page_views 计算而来。

编写相应的查询代码：

package main

import (
	"context"
	"entgo.io/ent/dialect/sql"
	"fmt"
	_ "github.com/lib/pq"
	"log"
	"modifier-demo/ent"
	"modifier-demo/ent/ad"
	"time"
)

type Ads struct {
	EstimatedEarnings float64   `json:"estimated_earnings"`
	PageViews         int64     `json:"page_views"`
	Date              time.Time `json:"date"`
	PageViewsRpm      float64   `json:"page_views_rpm"`
}

func main() {
	client, err := ent.Open("postgres", "host=127.0.0.1 port=5432 sslmode=disable user=postgres dbname=data_test password=mysecretpassword")
	if err != nil {
		log.Fatalf("failed opening connection to postgres: %v", err)
	}
	defer client.Close()
	// Run the auto migration tool.
	if err := client.Schema.Create(context.Background()); err != nil {
		log.Fatalf("failed creating schema resources: %v", err)
	}
	var a []Ads
	err = client.Debug().Ad.Query().Order(ent.Desc(ad.FieldPageViewsRpm)).GroupBy(ad.FieldDate).Aggregate(func(selector *sql.Selector) string {
		return sql.As(" CAST(COALESCE(SUM(estimated_earnings) / NULLIF(SUM(page_views)*1.0, 0.0)*1000, 0)AS numeric(10,2))", "page_views_rpm")
	}).Scan(context.TODO(), &a)
	if err != nil {
		return
	}
	fmt.Println(a)
}

主要是根据 date 来汇总并重新计算 page_views_rpm 字段，运行代码后发现没有成功输出，打印后发现 ent 使用了旧的 PageViewsRpm 字段进行排序，导致 sql 无法顺利运行。

Golang_embed 简单介绍

Sat, 05 Aug 2023 17:37:56 +0800

最近需要使用 golang1.16 中的功能 embed ,本文简单记录下 embed 的使用。

embed 介绍

Go 1.16 引入了 embed 包，允许我们在编译时将静态文件（例如 .go、.html、.css、.js 等）嵌入到 Go 源文件中。这在构建静态网站、单页应用程序（SPA）和其他项目时非常有用。

主要有几个优点：

方便部署：不需要再部署静态资源文件，所有的资源都直接嵌入到可执行文件中。
安全：用户无法直接访问或修改嵌入的文件。
版本管理：和 Go 代码一起版本控制。

使用

嵌入为字符串

可以将文件内容保存到字符串变量中。

package main

import (
	_ "embed"
	"fmt"
)

//go:embed hello.txt
var s string

func main() {
	fmt.Println(s)
}

文件路径下有个 hello.txt，内容如下：hello, overstarry,代码运行输出：hello, overstarry

保存为 []bytes

还可以将文件内容保存为 []bytes 变量

package main

import (
	_ "embed"
	"fmt"
)

//go:embed hello.txt
var s []byte

func main() {
	fmt.Println(string(s))
}

运行代码输出内容与上面一致。

Nginx 反向代理中出现的问题及解决方法

Fri, 28 Jul 2023 09:34:09 +0800

最近在使用 nginx 反向代理时遇到了一些问题，在本文记录一下问题及相应的解决方法。

问题 1

问题现象

错误日志如下：

: host not found in upstream "xx.xx.vip"in /etc/nginx/conf.d/default.conf:17
nginx: [emerg] host not found in upstream "xx.xx.vip”in /etc/nginx/conf.d/default. conf:17

从错误日志可以看出这个问题主要是 nginx 无法解析相应的域名。

解决方法

怎么解决这个问题呢，我们只需添加相应的 dns 服务器即可 resolver 8.8.8.8; 。

问题 2

问题现象

错误日志如下：

2023/07/28 01:35:43 [error] 34#34: *44 SSL_do_handshake() failed (SSL: error:14094438:SSL routines:ssl3_read_bytes:tlsv1 alert internal error:SSL alert number 80) while SSL handshaking to upstream, client: 172.16.64.75, server: , request: "POST /v1/data/xx/filter HTTP/1.1", upstream: "https://xxxx:443/v1/data/xx/filter", host: "xx.xx.com", referrer: "https://xx.xx.com/user/login"

解决方法

这个问题主要是 https 相关配置的问题，我们只需添加这几行配置即可：

使用 cert Manager 申请免费证书

Sat, 22 Jul 2023 14:50:03 +0800

cert manager 介绍

cert-manager 是一个可信证书管理器，可以自动为您的集群中的服务提供 SSL 证书和可靠的基础设施。它执行以下任务：

自动通过类似 Let’s Encrypt 和 eigene 之类的 Certificate Authority (CA) 重新生成即将过期的证书。为您的集群中的服务自动生成证书。提供一个组件库，可用于自签名证书或其他 CA API。主要特性：

自动生成/重新生成证书
支持多种 CA 颁发的证书:Let’s Encrypt、自签名证书、HashiCorp Vault 等
支持多种记录类型:DNS01、HTTP01、Kubernetes Ingress 等
适用于支持 TLS 密码学的任何 Kubernetes API 对象
具有密钥轮换功能，可无缝替换即将到期的证书
流畅的 API，易于扩展

总的来说，cert-manager 可以让您将集群负载均衡的 TLS 实现自动化，减少运维负担。它主要用于解决基础设施中最常见的挑战：如何高可用地为应用提供 TLS 证书。

申请证书

接下来我来讲解本文的重点：如何使用 cert-manager 申请证书并配置于 ingress 上。

安装 cert-manager

执行 kubectl apply -f https://github.com/cert-manager/cert-manager/releases/latest/download/cert-manager.yaml 部署最新版本 cert-manager.

查看 pod 状态

部署后，过一会执行 kubectl get pods -n cert-manager 查看 pod 状态。

Golang i18n

Sun, 16 Jul 2023 12:18:09 +0800

最近在开发一个需求时，需要将英文转为中文，这就需要进行本地化的处理，通过查找相关的库，决定使用 gettext-go 来进行本地化的处理，本篇文章主要简单介绍 gettext-go 和它在 k8s kubectl 中的运用。

gettext-go 简单介绍和使用

gettext-go 简单来说就是读取预先编写的 po 或 mo 文件来进行本地化的处理。

po 和 mo 文件是什么呢？接下来介绍一下 po 和 mo 文件

po 和 mo 文件介绍

.po 文件，.mo 文件是由 gettext 程序生成或者使用的源代码和编译结果。

1、.pot 文件

是一种模板文件，其实质与.po 文件一样，其中包含了从源代码中提取所有的翻译字符串的列表，主要提供给翻译人员使用。

2、.po 文件

（1）用程序 msginit 来分析 pot 文件，生成各语言对应的 po 文件，比如中文就是 zh_CN.po，法语就是 fr.po 文件。

（2）PO 是 Portable Object（可移植对象）的缩写形式，它是面向翻译人员的、提取于源代码的一种资源文件。

（3）.po 文件可以用任何编辑器如 poEdit，vi，Emacs，editplus 打开，交给翻译人员来将其中的文字翻译成本国语言。

3、.mo 文件

（1）用 msgfmt 将.po 文件编译成 mo 文件，这是一个二进制文件，不能直接编辑。

（2）MO 是 Machine Object（机器对象）的缩写形式，它是面向计算机的、由.po 文件通过 GNU gettext 工具包编译而成的二进制文件，应用程序通过读取.mo 文件使自身的界面转换成用户使用的语言，如简体中文。

rueidis 简介

Sat, 08 Jul 2023 15:43:01 +0800

简介

rueidis 是一个快速的 Golang Redis 客户端，支持客户端缓存、Auto Pipelining、泛型 OM、RedisJSON、RedisBloom、RediSearch 等功能。

Features

Auto pipelining for non-blocking redis commands
RESP3 中的客户端缓存
Pub/Sub, Sharded Pub/Sub, Streams
Redis Cluster, Sentinel, RedisJSON, RedisBloom, RediSearch, RedisTimeseries, 等。
具有客户端缓存和乐观锁定的通用对象映射
具有客户端缓存的分布式锁
rueidis mock
OpenTelemetry 集成
Hooks and other 集成
提供类似 Go-redis API 的适配器

需要注意的是由于使用了一些 go1.20 版本才有的特性，如果想要使用低版本 go，必须安装相应的版本。

简单使用

package main

import (
	"context"
	"fmt"
	"github.com/redis/rueidis"
)

func main() {
	// 创建 redis 客户端连接
	client, err := rueidis.NewClient(rueidis.ClientOption{InitAddress: []string{"127.0.0.1:6379"}})
	if err != nil {
		panic(err)
	}
	defer client.Close()

	ctx := context.Background()
	// 执行 redis set 命令
	err = client.Do(ctx, client.B().Set().Key("key1").Value("val").Nx().Build()).Error()
	if err != nil {
		panic(err)
	}
	hm, err := client.Do(ctx, client.B().Get().Key("key1").Build()).ToString()
	if err != nil {
		panic(err)
	}
	fmt.Println(hm)
}

go-redis 适配器

如何快速从 go-redis 切换到 rueidis 客户端呢，rueidis 提供了 rueidiscompat.NewAdapter 方法，通过 Adapter 可以使用熟悉的 go-redis 中的方法。

PostgreSQL 怎么解决 division by zero 问题

Sat, 01 Jul 2023 22:28:18 +0800

问题

最近在使用 sql 进行数值计算时，发现 sql 语句运行报错，报错信息如下：division by zero，综合分析 sql 语句得出是在进行除法运算时，除数为 0 导致的。

解决

接下来我来介绍几种解决这种问题的方法：

NULLIF 和 COALESCE 函数

我们可以使用 NULLIF 函数检查变量是否是 0 值，如果是 0 则为 null。使用 COALESCE 函数检查分子和分母是否有 NULL 值，然后返回默认值。

例子：

SELECT 
   COALESCE(dividend / NULLIF(divisor, 0), default_value)
FROM xx

CASE 表达式

我们可以使用 case when 来检查除数是否为 0，如果是 0 则使用默认值。例子：

SELECT 
   COALESCE(dividend / NULLIF(divisor, 0), default_value)
FROM xx

最终我采用了第一种方法，顺利的解决了问题，还需要多说的是在 postgresql sql 语句使用过程中，要注意所使用函数需要的参数的类型，遇到需要转换参数类型的情况，可以使用 case 函数进行类型转换。

小结

本文讲述了我遇到的 PostgreSQL 进行数值计算时遇到的 division by zero 问题的情况及解决方法。

参考

Kubernetes Health check

Fri, 23 Jun 2023 22:42:41 +0800

本文我来讲解 Kubernetes 中的一个重要概念：容器的健康检查。

介绍

在 Kubernetes 中，你可以为 Pod 里的容器定义一个健康检查“探针”（Probe）。这样，kubelet 就会根据这个 Probe 的返回值决定这个容器的状态，而不是直接以容器镜像是否运行（来自 Docker 返回的信息）作为依据。这种机制，是生产环境中保证应用健康存活的重要手段。

k8s 主要有三种健康检查的探针：1) LivenessProbe 存活探针 2) ReadinessProbe 就绪探针 3) StartupProbe 启动探针

kubelet 使用存活探针来确定什么时候要重启容器。例如，存活探针可以探测到应用死锁（应用程序在运行，但是无法继续执行后面的步骤）情况。重启这种状态下的容器有助于提高应用的可用性，即使其中存在缺陷。

存活探针的常见模式是为就绪探针使用相同的低成本 HTTP 端点，但具有更高的 failureThreshold。这样可以确保在硬性终止 Pod 之前，将观察到 Pod 在一段时间内处于非就绪状态。

kubelet 使用就绪探针可以知道容器何时准备好接受请求流量，当一个 Pod 内的所有容器都就绪时，才能认为该 Pod 就绪。这种信号的一个用途就是控制哪个 Pod 作为 Service 的后端。若 Pod 尚未就绪，会被从 Service 的负载均衡器中剔除。

kubelet 使用启动探针来了解应用容器何时启动。如果配置了这类探针，你就可以控制容器在启动成功后再进行存活性和就绪态检查，确保这些存活、就绪探针不会影响应用的启动。启动探针可以用于对慢启动容器进行存活性检测，避免它们在启动运行之前就被杀掉。

probe 介绍

接下来我来讲解用的较多的 2 个探针：1) LivenessProbe 存活探针 2) ReadinessProbe 就绪探针

LivenessProbe

许多应用由于长时间运行导致程序异常，需要重启服务才能继续正常使用，Kubernetes 提供了存活探针 (LivenessProbe) 来发现并处理这种情况。

我们先创建一个 pod, pod 的文件如下：

Rancher Cattle Cluster Agent Could not Resolve Host

Fri, 16 Jun 2023 15:06:49 +0800

起因

最近在使用 rancher 导入外部 k8s 集群时，遇到了一个问题：在要导入的集群上执行命令后，创建的 pod 运行错误，错误日志大概如下：

INFO: Environment: CATTLE_ADDRESS=100.66.209.198 CATTLE_CA_CHECKSUM= CATTLE_CLUSTER=true CATTLE_CLUSTER_AGENT_PORT=tcp://11.11.10.11:80 CATTLE_CLUSTER_AGENT_PORT_443_TCP=tcp://11.11.10.11:443 CATTLE_CLUSTER_AGENT_PORT_443_TCP_ADDR=10.96.0.125 CATTLE_CLUSTER_AGENT_PORT_443_TCP_PORT=443 CATTLE_CLUSTER_AGENT_PORT_443_TCP_PROTO=tcp CATTLE_CLUSTER_AGENT_PORT_80_TCP=tcp://10.96.0.125:80 CATTLE_CLUSTER_AGENT_PORT_80_TCP_ADDR=10.96.0.125 CATTLE_CLUSTER_AGENT_PORT_80_TCP_PORT=80 CATTLE_CLUSTER_AGENT_PORT_80_TCP_PROTO=tcp CATTLE_CLUSTER_AGENT_SERVICE_HOST=10.96.0.125 CATTLE_CLUSTER_AGENT_SERVICE_PORT=80 CATTLE_CLUSTER_AGENT_SERVICE_PORT_HTTP=80 CATTLE_CLUSTER_AGENT_SERVICE_PORT_HTTPS_INTERNAL=443 CATTLE_CLUSTER_REGISTRY= CATTLE_INGRESS_IP_DOMAIN=sslip.io CATTLE_INSTALL_UUID=333850e4-f500-43a2-a359-e1dfd94e4f35 CATTLE_INTERNAL_ADDRESS= CATTLE_IS_RKE=false CATTLE_K8S_MANAGED=true CATTLE_NODE_NAME=cattle-cluster-agent-55b9954958-5679q CATTLE_SERVER=https://xx.xx.vip CATTLE_SERVER_VERSION=v2.6.6
INFO: Using resolv.conf: search cattle-system.svc.cluster.local svc.cluster.local cluster.local nameserver 10.96.0.10 options ndots:5
ERROR: https://xx.xx.vip/ping is not accessible (Could not resolve host: xx.xx.vip)

可以很好的看出错误的原因是域名 dns 解析错误。

解决

在发现问题后，可以根据错误日志进行相应的解决，我们先查看 coredns 的日志 kubectl logs deployment/coredns -n kube-system

[ERROR] plugin/errors: 2 XX.XX.vip. A: read udp 100.108.11.198:32988->100.100.2.136:53: i/o timeout
[ERROR] plugin/errors: 2 XX.XX.vip. A: read udp 100.108.11.198:53477->100.100.2.136:53: i/o timeout
[ERROR] plugin/errors: 2 XX.XX.vip. AAAA: read udp 100.108.11.198:40436->100.100.2.136:53: i/o timeout

可以看到相应域名解析错误，根据以前的经验，先重启 coredns 容器尝试是否能解决问题，重启后发现问题未能解决 (可能需要重启相应节点的机器。

sealos version compare error

Sat, 10 Jun 2023 16:26:48 +0800

前言

最近在使用 sealos 安装更新 k8s 的过程中发现了一个问题：nfo new cluster version v1.25.10 behind the current version v1.25.8。

现在我来简单描述下过程：我想要将 k8s 版本从 v1.25.8 升级到 v1.25.10，运行更新命令：sealos run labring/kubernetes:v1.25.10-4.2.0 -f 后，出现了以下错误信息： 2023-06-09T11:30:06 info new cluster version v1.25.10 behind the current version v1.25.8 ,通过对错误信息的理解，发现提示 v1.25.10 版本比 v1.25.8 小，通过我对版本号的理解，这应该是个错误。

发现及解决问题

发现了问题，接下来要寻找出现问题的代码和解决问题。通过 Github 的代码搜索功能搜索关键字 behind the current version 顺利找到问题代码所在。

对找到的代码进行分析，发现是 versionutil.Compare(curversion, version) 方法出现了错误，我们来看看这个函数的代码：

func Compare(v1, v2 string) bool {
	v1 = strings.Replace(v1, "v", "", -1)
	v2 = strings.Replace(v2, "v", "", -1)
	v1 = strings.Split(v1, "-")[0]
	v2 = strings.Split(v2, "-")[0]
	v1List := strings.Split(v1, ".")
	v2List := strings.Split(v2, ".")

	if len(v1List) != 3 || len(v2List) != 3 {
		logger.Error("error version format %s %s", v1, v2)
		return false
	}
	if v1List[0] > v2List[0] {
		return true
	} else if v1List[0] < v2List[0] {
		return false
	}
	if v1List[1] > v2List[1] {
		return true
	} else if v1List[1] < v2List[1] {
		return false
	}
	if v1List[2] >= v2List[2] {
		return true
	}
	return false
}

通过对代码的分析，发现是对主次修订版本号对比时出现了问题，代码中是简单的使用了字符串比较，字符串数字比较会以字典序进行比较，所以会出现 “8” 大于 “10"的情况。正常的数字比较应该是将字符串转为数字进行相应比较。

Kubernetes pod 修改 hosts 文件

Sat, 03 Jun 2023 21:37:05 +0800

前言

最近看了 k8s 的书，学习了一些新的知识，将会分几篇来介绍学习到的知识，本文来先介绍 k8s 中如何修改 pod 的 hosts 文件。

我们知道当 DNS 出现问题时，可以向 Pod 的/etc/hosts 文件添加条目来提供主机名解析 Pod 级别覆盖。该如何向 hosts 文件中添加条目呢？可以使用 PodSpec 中的 HostAliases 字段添加自定义条目。

虽然我们也可以直接进入 pod 修改 host 文件来实现，但这样 pod 重建时会被覆盖，所以我们应该使用 HostAliases 来进行修改，因为该文件会由 Kubelet 管理，并且可以在 Pod 创建/重启过程中被重写。

使用

我们该如何操作呢，接下来由我来介绍使用步骤：

1 先创建 Deployment YAML 文件来创建后台运行的 busybox pod

apiVersion: apps/v1
kind: Deployment
metadata:
  name: busybox-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: busybox
  template:
    metadata:
      labels:
        app: busybox
    spec:
      containers:
        - name: busybox
          image: busybox
          args: [ "sleep", "3600" ]
          resources:
            limits:
              memory: "128Mi"
              cpu: "500m"
            requests:
              memory: "64Mi"
              cpu: "250m"
          volumeMounts:
            - name: busybox-volume
              mountPath: /data
      volumes:
        - name: busybox-volume
          emptyDir: {}

查看 pod ip

Apisix 忽略 uri 大小写

Fri, 26 May 2023 22:53:41 +0800

前言

最近需要忽略请求 uri 大小写，即不管 uri 的大小写都返回小写 uri 所请求的响应内容，例如请求 xx.vip/A 实际请求 xx.vip/a, 本文主要以 apisix 来讲解如何实现这个功能。

解决

遇到这个需求，首先肯定采用 apisix 的插件来实现，根据前面多次的经验，这个功能应该可以使用 serverless 插件中的 serverless-pre-function 插件来实现，具体的流程如下：

1 获取请求的 uri 2 将 uri 转为小写 3 修改请求的 uri

具体的插件内容如下：

"serverless-pre-function": {
      "_meta": {
        "disable": false
      },
      "functions": [
"return function(conf, ctx)  local uri = ctx.var.uri;ctx.var.uri= string.lower(uri);ngx.log(ngx.ERR, \"match uri \",  ctx.var.uri ); end"      ],
      "phase": "rewrite"
    }

添加插件后，再次请求路径，发现请求结果还是没有变，查看日志发现 uri 修改成功了，不知为何还是没有修改成功。

后面又仔细研究了 proxy-rewrite 插件中修改 uri 的代码，发现它是使用了 nginx 标准的函数 ngx.req.set_uri 来赋值新的 uri。

sqlc 初体验

Sat, 20 May 2023 15:54:29 +0800

简介

sqlc 可以生成从 SQL 生成类型安全代码。它的工作原理是：

使用 SQL 书写查询语句。
运行 sqlc 生成 Go 代码，该代码为这些查询提供类型安全的接口。
在应用程序代码中调用生成的代码与数据库进行交互。

安装

sqlc 有多种安装方式：

macOS:

brew install sqlc

Ubuntu:

sudo snap install sqlc

go 安装：

# Go >= 1.17:
go install github.com/kyleconroy/sqlc/cmd/sqlc@latest
# Go < 1.17:
go get github.com/kyleconroy/sqlc/cmd/sqlc

docker 安装：

docker pull kjconroy/sqlc

其它：

https://github.com/kyleconroy/sqlc/releases

入门使用

插件 sqlc.yaml

首先创建 sqlc.yaml 文件，sqlc 会在当前目录下查找 sqlc.yaml 或 sqlc.json 文件。

# sqlc.yaml
version: 1
packages:
  - path: "tutorial"
    name: "tutorial"
    engine: "mysql"
    schema: "schema.sql"
    queries: "query.sql"

创建 sql 文件

sqlc 需要得知数据库表结构和相应的 sql 语句，我们创建 schema.sql 定义表结构：

Apisix Docker 部署网站重定向端口错误问题

Sat, 13 May 2023 22:02:10 +0800

前言

前段时间在使用 apisix 添加路由时，需要将 http 转为 https, 在配置 http_to_https 后，访问相应网址时发现 https 的端口不是我们所配置的默认端口 443，而是 9443 端口。

可以看到访问 http://localhost 会跳转至错误的地址：https://localhost:9443/ ,正确的地址应该是 https://localhost，这是怎么回事呢？

分析

接下来我来简单对问题进行简单分析。

我是采用 docker 的方式部署的 apisix，这是我们的配置文件：

version: "3"

services:
  apisix-dashboard:
    image: apache/apisix-dashboard:3.0.0-alpine
    restart: always
    volumes:
      - ./dashboard_conf/conf.yaml:/usr/local/apisix-dashboard/conf/conf.yaml
    ports:
      - "9000:9000"
    networks:
      apisix:

  apisix:
    image: apache/apisix:${APISIX_IMAGE_TAG:-3.2.0-debian}
    restart: always
    volumes:
      - ./apisix_conf/config.yaml:/usr/local/apisix/conf/config.yaml:ro
    depends_on:
      - etcd
    ##network_mode: host
    ports:
      - "9180:9180/tcp"
      - "80:9080/tcp"
      - "9091:9091/tcp"
      - "443:9443/tcp"
      - "9092:9092/tcp"
    networks:
      apisix:

  etcd:
    image: bitnami/etcd:3.4.15
    restart: always
    volumes:
      - etcd_data:/bitnami/etcd
    environment:
      ETCD_ENABLE_V2: "true"
      ALLOW_NONE_AUTHENTICATION: "yes"
      ETCD_ADVERTISE_CLIENT_URLS: "http://etcd:2379"
      ETCD_LISTEN_CLIENT_URLS: "http://0.0.0.0:2379"
    ports:
      - "2379:2379/tcp"
    networks:
      apisix:

  web1:
    image: nginx:1.19.0-alpine
    restart: always
    volumes:
      - ./upstream/web1.conf:/etc/nginx/nginx.conf
    ports:
      - "9081:80/tcp"
    environment:
      - NGINX_PORT=80
    networks:
      apisix:

networks:
  apisix:
    driver: bridge

volumes:
  etcd_data:
    driver: local

可以看到我们将 apisix 容器的 http 端口和 https 端口映射为 80 和 443，按照常理来说，http_to_https 后的端口应该也是 443 端口才对。我猜测重定向时，apisix 还是采用配置文件中设定的 https 端口才导致跳转的 url 端口错误。

Go wasi

Tue, 02 May 2023 15:41:33 +0800

WebAssembly 是一种新的编码方式，可以在现代的网络浏览器中运行－它是一种低级的类汇编语言，具有紧凑的二进制格式，可以接近原生的性能运行，并为诸如 C / C ++等语言提供一个编译目标，以便它们可以在 Web 上运行。它也被设计为可以与 JavaScript 共存，允许两者一起工作。

Go 从 1.11 版本就开始支持将 Go 源码编译为 wasm 二进制文件，并在支持 wasm 的浏览器环境中运行。

不过 WebAssembly 绝不仅仅被设计为仅限于在 Web 浏览器中运行，核心的 WebAssembly 语言是独立于其周围环境的，WebAssembly 完全可以通过 API 与外部世界互动。在 Web 上，它自然使用浏览器提供的现有 Web API。然而，在浏览器之外，之前还没有一套标准的 API 可以让 WebAssembly 程序使用。这使得创建真正可移植的非 Web WebAssembly 程序变得困难。WebAssembly System Interface(WASI) 是一个填补这一空白的倡议，它有一套干净的 API，可以由多个引擎在多个平台上实现，并且不依赖于浏览器的功能（尽管它们仍然可以在浏览器中运行）。

Go 1.21 将增加对 WASI 的支持，初期先支持 WASI Preview1 版本，之后会支持 WASI Preview2 版本，直至最终 WASI API 版本发布！

go 编译支持 wasi 的程序

怎么样才能编译支持 wasi 的程序呢？我们可以使用 GOOS=wasip1 GOARCH=wasm 将 Go 源码编译为支持 WASI 的 wasm 程序。下面是一个例子：

Go 实现简单反向代理

Sat, 08 Apr 2023 17:12:41 +0800

前言

说起反向代理，大家应该都不陌生，是指以代理服务器来接受 internet 上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给 internet 上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。常见的反向代理有 Nginx,HAProxy,Apisix 等。

接下来介绍如何使用 go 实现一个反向代理服务器。

golang 实现

使用 golang 实现反向代理非常简单，标准库 net/http/httputil 提供了反向代理的方法可以让我们方便的实现反向代理，使我们可以很快的实现一个简单的反向代理服务器。

package main

import (
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
)

func NewProxy(targetHost string) (*httputil.ReverseProxy, error) {
	url, err := url.Parse(targetHost)
	if err != nil {
		return nil, err
	}

	return httputil.NewSingleHostReverseProxy(url), nil
}

func ProxyRequestHandler(proxy *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		proxy.ServeHTTP(w, r)
	}
}

func main() {
	proxy, err := NewProxy("https://overstarry.vip")
	if err != nil {
		panic(err)
	}

	http.HandleFunc("/", ProxyRequestHandler(proxy))
	log.Fatal(http.ListenAndServe(":8080", nil))
}

这段代码将到达我们代理服务器的任何请求都会被代理到 https://overstarry.vip。我们运行代码，访问网站，发现 403 Forbidden 好像请求被拦截了，应该是源网站进行了请求校验，这该怎么处理呢？通过查阅资料得知，我们需要将 host 传递过去，修改后的代码如下：

package main

import (
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
)

func NewProxy(targetHost string) (*httputil.ReverseProxy, error) {
	url, err := url.Parse(targetHost)
	if err != nil {
		return nil, err
	}

	return httputil.NewSingleHostReverseProxy(url), nil
}

func ProxyRequestHandler(proxy *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		r.Host = "overstarry.vip"
		proxy.ServeHTTP(w, r)
	}
}

func main() {
	proxy, err := NewProxy("https://overstarry.vip")
	if err != nil {
		panic(err)
	}

	http.HandleFunc("/", ProxyRequestHandler(proxy))
	log.Fatal(http.ListenAndServe(":8080", nil))
}

现在运行代码即可正常访问了。

CertificateManager 使用 dns 授权申请证书 -- gcloud 方式

Wed, 29 Mar 2023 10:42:59 +0800

本文讲解如何使用 dns 授权方式申请 google cloud 证书，通过查阅官方文档可以得知可以使用 gcloud 和 Certificate Manager API 来申请证书，本文使用 gcloud 命令行工具来执行步骤。

创建 DNS 授权

第一步是创建 DNS 授权，使用以下命令来创建：

gcloud certificate-manager dns-authorizations create AUTHORIZATION_NAME \
  --domain="DOMAIN_NAME"
gcloud certificate-manager dns-authorizations describe AUTHORIZATION_NAME

需要将 AUTHORIZATION_NAME 和 DOMAIN_NAME 分别替换为 dns 授权的名称和相应的域名。

先创建 dns 授权然后查看授权的详细信息

gcloud certificate-manager dns-authorizations create overstarry --domain="overstarry.vip"
gcloud certificate-manager dns-authorizations describe overstarry

根据返回的 cname 信息，需要到相应的域名解析中添加 cname 记录。

创建引用 DNS 授权的 Google 管理的证书

接下来创建引用 DNS 授权的 Google 管理的证书，使用以下命令创建：

Google Cloud 清除 CDN 缓存

Sat, 25 Mar 2023 14:33:23 +0800

最近在研究使用 google cloud 的 cdn 服务，本文就来讲解如何清除 cdn 的缓存。

本文介绍了几种清除 cdn 缓存的方法。

google cloud console 清除

第一种也是最简单的，就是直接从 google cloud console 后台进行操作，我们打开 console 后台，选择网络服务，点击负载均衡界面，选择我们要清除的 cdn 缓存所使用的负载均衡器，点击缓存页面，输入想要 cdn 节点清除的路径即可。过了一会，就可以看到操作成功，相应的文件已经失效。

Google Cloud CLI 命令

第二种方法是使用 Google Cloud CLI 使 cdn 缓存文件失效。

Google Cloud CLI 安装

该怎么安装 Google Cloud CLI 呢，有 2 个办法：1) 直接下载安装二进制文件 2) 使用 Cloud Shell. 本文是使用 Cloud Shell 进行的操作。

使缓存内容失效

1 使用 gcloud compute url-maps list 列出目前所使用的负载均衡器

apisix 数据备份

Sat, 18 Mar 2023 23:17:24 +0800

今天我来讲讲如何备份 apisix 的数据，主要是路由、服务、上游等数据。本文中的 apisix 版本为 apisix 3.1.0 版本。

接下来由我来介绍几种备份方法。

dashboard 导出备份

介绍的第一种方法是使用 apisix dashboard 进行数据导出，但这种方法有许多缺陷，只能导出 route 数据，其他服务、ssl 数据都不能导出，而且新版本 (3.0+)dashboard 导出的路由不包含上游服务的数据，不方便进行快速的路由迁移复制 (我猜测可能是害怕上游服务信息不一致导致路由错误)。

接下来就来介绍如何进行导入导出。

1 我们打开 dashboard

2 选择要导出的路由，点击 export openapi

3 在新的 apisix dashboard 导入刚刚导出的 openapi 文件并填写相应的信息，导入成功后就可以看到导入的路由信息，相应路由的服务需要补充填写。

根据 admin api 编写相应的脚本

apisix 提供了各种 route、service 的 admin api 数据接口，我们可以根据官方提供的接口编写相应的脚本。

使用 etcd 备份方案

由于 apisix 默认采用 etcd 进行数据存储，我们可以备份 etcd 数据，到新的 apisix 集群导入备份的数据。

由于我对 etcd 的运维不太熟悉，想要了解 etcd 备份快照，可以查看这条链接。

apisix 如何添加自定义插件

Sun, 12 Mar 2023 11:40:27 +0800

最近在研究 apisix 插件，想要研究插件的执行流程，为了了解插件的具体运行流程，查看了几种方法来调试:1. inspect plugin 2. 自定义插件调试等等。

本文介绍了添加启用自定义插件。

简单修改插件

最近在研究 apisix 的 proxy-cache 插件，本文就以 proxy-cache 插件为例子来讲解 docker 环境下如何自定义插件。

我们先从 apisix 官方 git 库拷贝 proxy-cache 插件代码到本地文件夹。我们对插件的内容进行修改删除，并将插件名称修改为 proxy-cache2, 修改后的插件文件列表如下：

删除了内存缓存的相关内容，只保留了磁盘缓存的内容，并添加了一些日志记录好了解整个插件的整体流程。

apisix 添加自定义插件

接下来需要给 apisix 添加我们修改的 proxy-cache2 插件，通过查看容器的目录，我们需要将插件挂载到 /usr/local/apisix/apisix/plugins 目录下，我们修改 docker-compose 文件：

version: "3"

services:
  apisix:
    image: apache/apisix:${APISIX_IMAGE_TAG:-3.2.0-debian}
    restart: always
    volumes:
      - ./apisix_conf/config.yaml:/usr/local/apisix/conf/config.yaml:ro
      - ./apisix/plugins/proxy-cache2:/usr/local/apisix/apisix/plugins/proxy-cache2
      - ./apisix_log://usr/local/apisix/logs
    depends_on:
      - etcd
    ##network_mode: host
    ports:
      - "9180:9180/tcp"
      - "9080:9080/tcp"
      - "9091:9091/tcp"
      - "9443:9443/tcp"
      - "9092:9092/tcp"
    networks:
      apisix:

我们添加 ./apisix/plugins/proxy-cache2:/usr/local/apisix/apisix/plugins/proxy-cache2 将本地的插件目录挂载进行容器中，重启 apisix。

apisix 根据请求 host 访问不同路径

Sat, 04 Mar 2023 23:29:36 +0800

前言

最近有一个需求，需要配置一个路由，这个路由是子域名形式的，域名类似 xx.apps.overstarry.vip，我们需要根据子域名中的 xx 内容来请求同一个对象存储中不同的文件。

这个需求之前处理过，那时采用了 nginx 来处理主要路径的逻辑，apisix 直接请求 nginx 服务，也就是大概这样的一种结构：apisix -> nginx -> oss。这次同样的需求，我决定采用 2 层结构，去除中间的 nginx 层，由 apisix 直接访问 oss 服务。

接下来我就来讲述处理的过程。

过程

使用 proxy-rewrite

处理这个需求，我第一反应是使用 proxy-rewrite 插件来处理，我使用 regex_uri 字段来进行正则替换匹配，添加的插件内容如下：

 "proxy-rewrite": {
      "regex_uri": [
        "^(.*).apps0.overstarry.vip(.*)$",
        "/$1/production$2"
      ]
    }

配置完后，请求了几次，发现没有请求成功，通过查看日志发现请求到了奇怪的地址。又仔细的研究了一会，发现是我理解错误了，proxy_rewrite 是根据 uri 进行正则匹配的，没有根据 host 匹配的选项，前面填写的那些是根本不会匹配成功的。

`serverless`

proxy-rewrite 插件不能实现我们的需求，我又查看了 issue 列表，发现了一个 issue(#7739),里面提到了可以使用插件 serverless 来实现我们的需求。

serverless 介绍

APISIX 有两个 serverless 插件：serverless-pre-function 和 serverless-post-function。

serverless-pre-function 插件会在指定阶段开始时运行，serverless-post-function 插件会在指定阶段结束时运行。这两个插件使用相同的属性。

实现

我们的需求应该是采用 serverless-pre-function 来实现，具体过程描述如下：获得请求的 host, 对 host 进行相应的文本正则替换，将替换的文本和 uri 进行组合拼接，得到真正的 uri.

使用 acme 自动更新 APISIX ssl 证书

Sat, 25 Feb 2023 14:20:59 +0800

前言

最近在给 APISIX 配置自动更新 SSL 证书的时候，发现了一些问题，本文记录以下发现问题的过程和解决方案。

步骤

我们先来看下原始的配置方法吧：

1 安装相应脚本

$ curl --output /root/.acme.sh/renew-hook-update-APISIX.sh --silent https://gist.githubusercontent.com/anjia0532/9ebf8011322f43e3f5037bc2af3aeaa6/raw/65b359a4eed0ae990f9188c2afa22bacd8471652/renew-hook-update-APISIX.sh

$ chmod +x /root/.acme.sh/renew-hook-update-APISIX.sh

$ /root/.acme.sh/renew-hook-update-APISIX.sh 

Usage : /root/.acme.sh/renew-hook-update-APISIX.sh -h <APISIX admin host> -p <certificate pem file> -k <certificate private key file> -a <admin api key> -t <print debug info switch off/on,default off>

2 安装 acme.sh

curl https://get.acme.sh | sh -s email=my@example.com

3 申请证书，并添加 renew-hook

这里我采用的是 dns api 的方式申请证书的

 ~/.acme.sh/acme.sh --issue  --dns dns_ali     -d *.xx.com   --renew-hook '~/.acme.sh/renew-hook-update-APISIX.sh  -h http://127.0.0.1:9280 -p ~/.acme.sh/"*.xx.com_ecc"/"fullchain.cer"  -k ~/.acme.sh/"*.xx.com_ecc"/"*.xx.com.key" -a {admin-key}' --log --debug

这里的 http://127.0.0.1:9280 是你的 APISIX 的 admin 接口地址，admin-key 是你的 key。

Containerd 本地调试环境搭建

Sun, 19 Feb 2023 00:43:59 +0800

最近在学习常用的容器运行时 containerd, 本篇我就来介绍如何本地构建 containerd 进行调试开发，主要介绍 2 种常规方式和使用容器构建，由于本地环境限制，我主要是使用 docker 搭建本地调试环境。

非容器 build

这里先开始介绍常规直接从源码本地构建的方式。

构建环境要求

1 go1.19.x 及以上版本

2 Protoc 3.x+

3 适用于您的发行版的 Btrfs 标头和库。请注意，可以通过构建标签禁用构建 btrfs 驱动程序 no_btrfs，从而删除此依赖项。

前面 2 点相信大家都很清楚，第三点的 Btrfs 是什么呢？Btrfs 是一种现代的 Linux 写时复制（COW）文件系统，旨在实现先进的功能，同时也注重容错、修复和简易管理。

build

1 拉取 containerd 源代码至本地

2 构建

进入源代码根目录，执行一下命令：

cd containerd
make

执行后，会在 ./bin/ 目录下生成所有项目的二进制文件。

如果你需要修改 gRPC API ,修改后需要使用 protoc 编译生成新的代码：make generate

docker 容器构建

接下来讲解怎么通过 docker 构建本地 containerd 调试环境。

构建要求

1 go1.19.x 及以上版本

2 Protoc 3.x+

containerd 安装和客户端简单使用

Sat, 11 Feb 2023 21:57:19 +0800

介绍

containerd 是一个用于管理容器生命周期的开源容器守护程序，是 Docker 引擎中的核心组件之一。它负责容器的创建、启动、停止、销毁等操作，并提供了对容器的基本管理功能，如镜像管理、网络管理、存储管理等。与 Docker 引擎相比，containerd 更加轻量级，同时也支持多种容器运行时，如 runc、gVisor、Kata Containers 等。由于其简单、可扩展和可移植等优点，containerd 也成为了许多容器平台和工具的基础组件之一。

安装

本文只介绍 Linux 系统下的安装方式。Linux 下的 deb 和 rpm 包 containerd.io 由 docker 官方进行分发，通过查阅官方文档，具体的安装步骤如下：

1 更新 apt 软件包索引并安装必要的软件包，以便 apt 能够使用 HTTPS 仓库。

sudo apt-get update
sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

2 添加 Docker’s 官方 GPG key:

sudo mkdir -m 0755 -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

3 设置存储库

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

4 安装

Helm 介绍及使用

Sat, 04 Feb 2023 14:31:08 +0800

今天我来简单介绍 kubernetes 生态中一个重要一环 - 包管理工具 Helm。

介绍

Helm 是 Kubernetes 的开源包管理器。它提供了提供、共享和使用为 Kubernetes 构建的软件的能力。

Helm 于 2015 年在 Deis 创建，后来被微软收购。现在称为 Helm Classic 的是在当年 11 月的首届 KubeCon 上推出的。2016 年 1 月，Helm Classic 与谷歌的 Kubernetes 部署管理器合并到现在是 Helm 主要项目的存储库中。

该项目目前拥有超过 30,000 个 GitHub stars，每月从全球获得超过 200 万次下载。2020 年 4 月，Helm 在 CNCF 中获得毕业。

安装 Helm

二进制安装

1 打开 https://github.com/helm/helm/releases , 下载你需要的版本 2 解压安装包 3 将文件夹中的 helm 二进制文件移动到相应的位置

脚本安装

helm 官方提供了一个安装的脚本：

$ curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
$ chmod 700 get_helm.sh
$ ./get_helm.sh

除了以上 2 种安装方式，你还可以通过各个操作系统的包管理工具安装和编译源码安装，这里就不过多赘述了。

Ubuntu20.04 设置 DNS

Sat, 07 Jan 2023 16:03:00 +0800

最近一台 Ubuntu 出现了网络问题，ping baidu.com 出现了 temporary failure in name resolution 报错，根据我的经验这是服务器的 DNS 出现了问题，特此在本文记录一下如何设置 DNS 的过程。

修改 netplan 配置文件

我先尝试修改 netplan 的配置文件，编辑相应的配置文件，我这里的路径是 /etc/netplan/00-installer-config.yaml, 修改后的内容如下：

network:
  ethernets:
    ens160:
      addresses:
      - 192.168.1.51/24
      gateway4: 192.168.1.1
      nameservers:
        addresses:
        - 114.114.114.114
        search: []
  version: 2

修改后执行 netplan apply, 重新 ping 后发现没有效果，未能解决问题。

修改 /etc/resolv.conf

我们还可以通过修改 /etc/resolv.conf 文件来设置 dns, 虽然通过修改此文件可以解决我们的问题，但编辑 /etc/resolv.conf 文件时，发现了一行注释 This file is managed by man:systemd-resolved(8). Do not edit. 可以得知这个文件是由 man:systemd-resolved(8) 管理，/etc/resolv.conf 是一个动态生成的文件，下次重启服务器时此文件还会恢复到默认的内容，所以此方案只适合临时解决，不能一次性解决问题。

接下来我来介绍如何永久的修改 /etc/resolv.conf

修改 /etc/systemd/resolved.conf 文件

#  This file is part of systemd.
#
#  systemd is free software; you can redistribute it and/or modify it
#  under the terms of the GNU Lesser General Public License as published by
#  the Free Software Foundation; either version 2.1 of the License, or
#  (at your option) any later version.
#
# Entries in this file show the compile time defaults.
# You can change settings by editing this file.
# Defaults can be restored by simply deleting this file.
#
# See resolved.conf(5) for details

[Resolve]
DNS=114.114.114.114 8.8.8.8
#FallbackDNS=
#Domains=
#LLMNR=no
#MulticastDNS=no
#DNSSEC=no
#DNSOverTLS=no
#Cache=no-negative
#DNSStubListener=yes
#ReadEtcHosts=yes
~                                                                                                                                       ~                                                                                                                                       ~                                                                                                                                       ~                                                                                                                                       ~                                                                                                                                       ~                                                                                                                                       ~

添加要修改的 dns 信息。

Postgresql 的 json 类型

Sat, 24 Dec 2022 21:44:24 +0800

最近工作需要使用 sql 语句进行 Postgresql json 类型字段的查询，本文特此记录下一些常用的函数。

Postgresql json 类型简介

postgresql 支持两种 json 数据类型：json 和 jsonb，而两者唯一的区别在于效率，json 是对输入的完整拷贝，使用时再去解析，所以它会保留输入的空格，重复键以及顺序等。而 jsonb 是解析输入后保存的二进制，它在解析时会删除不必要的空格和重复的键，顺序和输入可能也不相同。使用时不用再次解析。两者对重复键的处理都是保留最后一个键值对。效率的差别：json 类型存储快，使用慢，jsonb 类型存储稍慢，使用较快。

json 类型操作符

我们先介绍 json 和 jsonb 的一些常用通用操作符：

操作符	右操作数类型	描述	示例	结果
->	int	获取 JSON 数组元素（索引从 0 开始）	select ‘[{“a”:“foo”},{“b”:“bar”},{“c”:“baz”}]’::json->2;	{“c”:“baz”}
->	text	通过键获取值	select ‘{“a”: {“b”:“foo”}}’::json->‘a’;	{“b”:“foo”}
-»	int	获取 JSON 数组元素为 text	select ‘[1,2,3]’::json-»2;	3
-»	text	通过键获取值为 text	select ‘{“a”:1,“b”:2}’::json-»‘b’;	2

jsonb 独有的操作符

操作符	右操作数类型	描述	示例	结果
@>	jsonb	左侧 json 最上层的值是否包含右边 json 对象	select ‘{“a”:{“b”:2}}’::jsonb @> ‘{“b”:2}’::jsonb; select ‘{“a”:1, “b”:2}’::jsonb @> ‘{“b”:2}’::jsonb;	f t
<@	jsonb	左侧 json 对象是否包含于右侧 json 最上层的值内	select ‘{“b”:2}’::jsonb <@ ‘{“a”:1, “b”:2}’::jsonb;	t
?	text	text 是否作为左侧 Json 对象最上层的键	select ‘{“a”:1, “b”:2}’::jsonb ? ‘b’;	t
?\|	text[]	text[]中的任一元素是否作为左侧 Json 对象最上层的键	select ‘{“a”:1, “b”:2, “c”:3}’::jsonb ?\| array[‘b’, ‘c’];	t
?&	text[]	text[]中的所有元素是否作为左侧 Json 对象最上层的键	select ‘[“a”, “b”]’::jsonb ?& array[‘a’, ‘b’];	t
\|\|	jsonb	连接两个 json 对象，组成一个新的 json 对象	select ‘[“a”, “b”]’::jsonb \|\| ‘[“c”, “d”]’::jsonb;	[“a”, “b”, “c”, “d”]
-	text	删除左侧 json 对象中键为 text 的键值对	select ‘{“a”: “b”}’::jsonb - ‘a’;	{}
-	integer	删除数组指定索引处的元素，如果索引值为负数，则从右边计算索引值。如果最上层容器内不是数组，则抛出错误。	select ‘[“a”, “b”]’::jsonb - 1;	[“a”]

创建 json 类型

那我们该如何创建 json 类型呢，下面介绍一些常见的函数

使用 APISIX 代理 PostgreSQL 数据库

Sat, 17 Dec 2022 16:19:16 +0800

本文我来讲解如何使用 APISIX 来代理 PostgreSQL 数据库服务。

初试

最开始我以为很简单，我采用了直接在 APISIX DashBoard 上配置了一条路由，配置好后，连接发现无法成功连接，提示连接失败。

经过仔细的思考，发现 PostgreSQL 是使用 TCP 协议的数据库，不能通过简单的 route 进行配置，必须使用 stream-proxy 进行代理，接下来我们来看看怎么样来进行配置。

stream-proxy

TCP 是许多流行应用程序和服务的协议，例如 LDAP、MySQL 和 RTMP。UDP（用户数据报协议）是许多流行的非事务性应用程序的协议，例如 DNS、系统日志和 RADIUS。

APISIX 可以动态负载平衡 TCP/UDP 代理。在 Nginx 的世界里，我们把 TCP/UDP proxy 称为 stream proxy，APISIX 就遵循了这个说法。

启用 stream-proxy

要开启 APISIX 流代理需要在 APISIX 配置中开启，APISIX 默认是关闭的。

apisix:
  stream_proxy: # TCP/UDP proxy
    tcp: # TCP proxy address list
      - 9100
      - "127.0.0.1:9101"
    udp: # UDP proxy address list
      - 9200
      - "127.0.0.1:9211"

如果 apisix.enable_admin 为 true，则 HTTP 和流代理都启用了上述配置。

DataX 数据同步中遇到的问题

Wed, 07 Dec 2022 14:06:46 +0800

最近在使用 DataX 进行 PostgreSQL 和 PostgreSQL 之间的数据同步，在数据同步过程中，遇到了一个问题，在本文简单记录下问题和相应的解决方案。

问题

在一次数据同步中，DataX 执行失败，错误信息如下：

具体错误信息为：com.alibaba.datax.common.exception.DataXException: Code:[DBUtilErrorCode-12], Description:[不支持的数据库类型. 请注意查看 DataX 已经支持的数据库类型以及数据库版本.].  - 您的配
置文件中的列配置信息有误. 因为DataX 不支持数据库读取这种字段类型. 字段名:[country], 字段名称:[1111], 字段Java类型:[java.lang.String]. 请尝试使用数据库函数将其转换datax支持的类型

我的配置如下：

{
  "job": {
    "setting": {
      "speed": {
        "channel": 3
      },
      "errorLimit": {
        "record": 0,
        "percentage": 0.02
      }
    },
    "content": [
      {
        "reader": {
          "name": "postgresqlreader",
          "parameter": {
            "username": "xasdas",
            "password": "xxx",
            "column": [
              "id",
              "country"
            ],
            "connection": [
              {
                "table": [
                  "xx"
                ],
                "jdbcUrl": [
                  "jdbc:postgresql://xxx:5432/xxxx"
                ]
              }
            ]
          }
        },
        "writer": {
          "name": "postgresqlwriter",
          "parameter": {
            "username": "xxxx",
            "password": "x",
            "column": [
              "id",
              "country"
            ],
            "preSql": [
            ],
            "postSql": [
             ],
            "connection": [
              {
                "jdbcUrl": "jdbc:postgresql://xxx:5432/xxxx",
                "table": [
                  "xx"
                ]
              }
            ]
          }
        }
      }
    ]
  }
}

通过检查数据库字段，发现 country 字段是 jsonb 类型，DataX 不支持此类型，DataX 的支持列表：

Go 时间处理库 carbon

Sat, 03 Dec 2022 22:33:35 +0800

我们在日常开发中，常常会对时间进行各种处理，今天我来介绍一个 go 处理时间的库 golang-module/carbon。

Carbon 是一个轻量级、语义化、对开发者友好的 golang 时间处理库，支持链式调用。

安装

go 版本大于 1.16

go get -u github.com/golang-module/carbon/v2

版本小于 1.16

go get -u github.com/golang-module/carbon

使用

创建 carbon 实例

carbon.Now() // 获取当前时间
carbon.Now("Asia/Qatar").ToDateTimeString() // 不同时区当前的时间，卡塔尔当前的时间
carbon.Yesterday() // 昨天
carbon.CreateFromTime(22, 9, 13).ToString()
carbon.Tomorrow().ToDateString() // 明天

标准库转换

carbon 还可以和标准库 time 进行相互转换。

// 将 标准库 time 转换为 carbon 实例
carbon.Time2Carbon(time.Now())
// carbon 转换为 time.Time

解析字符串

carbon 可以解析字符串，生成 carbon 实例

// 将时间字符串转换为 carbon 实例
fmt.Println(carbon.Parse("1998-04-01").ToDateTimeString())
carbon.Parse("tomorrow").ToString()
carbon.ParseByFormat("2020|08|05 13|14|15", "Y|m|d H|i|s").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByFormat("It is 2020-08-05 13:14:15", "\\I\\t \\i\\s Y-m-d H:i:s").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByFormat("今天是 2020 年 08 月 05 日 13 时 14 分 15 秒", "今天是 Y 年 m 月 d 日 H 时 i 分 s 秒").ToDateTimeString() // 2020-08-05 13:14:15
carbon.ParseByFormat("2020-08-05 13:14:15", "Y-m-d H:i:s", carbon.Tokyo).ToDateTimeString() // 2020-08-05 14:14:15

获取开始时间和结束时间

carbon 可以很方便的获取一个时刻的开始和结束

Superset 简单使用

Sat, 26 Nov 2022 13:59:44 +0800

本文我来讲讲 Superset 的简单使用，并使用 superset 制作一个简单的图表。

Apache Superset 介绍

Apache Superset 是一款现代化的开源大数据工具，也是企业级商业智能 Web 应用，用于数据探索分析和数据可视化。它提供了简单易用的无代码可视化构建器和声称是最先进的 SQL 编辑器，用户可以使用这些工具快速地构建数据仪表盘。

Superset 提供了源码、pypi、Docker 等多种安装方式，其文档称，Superset 目前在许多公司被大规模使用。例如，Superset 在 Airbnb 基于 Kubernetes 的生产环境中运行，为每天查看超过 10 万张图表的 600 多名活跃用户提供服务。

Apache Superset 将 SQL IDE、数据浏览工具、拖拽式仪表板编辑器和插件组合使用，以构建自定义的可视化效果，支持从许多关系数据库和非关系数据库中创建仪表板，这些数据库包括 SQLite、MySQL，以及 Amazon Redshift、Google BigQuery、Snowflake、Oracle 数据库、IBM DB2 和其他各种兼容的数据源，并且可以连接到 Apache Drill 和 Apache Druid。此外，Superset 还适用于云原生场景和 Docker。

安装

我采用官方提供的 helm chart 安装在 Kubernetes 上，安装过程中遇到了一些问题。这里就不过多讲述了，接下来进入本文的正题，如何使用 superset 制作一个简单的图表呢。

简单使用

连接数据源

我们打开 Superset 主界面，点击右上角 settings ,选择连接数据库选项，进入数据库配置界面。点击右上角的添加数据库，选择相应的数据源，并填写相应的数据库连接配置，superset 内置几种常见的数据源，如果你想添加的数据源类型不再此列，可能需要安装相应的 python package 来解决。

使用 Fly.io 部署 MinIO 对象存储服务

Sat, 19 Nov 2022 21:54:39 +0800

前面的文章讲了 Fly.io 的入门使用和如何使用 Fly.io 部署 go 开发的应用程序。今天我们来继续讲解使用 Fly.io 部署对象存储服务 MinIO.

MinIO 是什么我就不过多介绍了，接下来我们就进入正题，进行 MinIO 服务的部署。

准备 Dockerfile 文件

我们先准备 MinIO docker 部署相关的文件，我们使用官方的镜像进行部署，Dockerfile 文件内容如下：

FROM minio/minio

CMD [ "server", "/data", "--console-address", ":9001"]

MinIO 的数据文件将存储在 data 目录下，指定 9001 为 web 控制台的端口，如果不指定将会使用随机端口。

初始化 Fly.io 应用

接下来像以前一样使用 flyctl launch 命令进行应用的初始化。

我们照常不使用数据库，不立即部署，生成的配置如下：

# fly.toml file generated for twilight-lake-5450 on 2022-11-19T22:34:39+08:00

app = "twilight-lake-5450"
kill_signal = "SIGINT"
kill_timeout = 5
processes = []

[env]

[experimental]
allowed_public_ports = []
auto_rollback = true

[[services]]
http_checks = []
internal_port = 8080
processes = ["app"]
protocol = "tcp"
script_checks = []
[services.concurrency]
hard_limit = 25
soft_limit = 20
type = "connections"

[[services.ports]]
force_https = true
handlers = ["http"]
port = 80

[[services.ports]]
handlers = ["tls", "http"]
port = 443

[[services.tcp_checks]]
grace_period = "1s"
interval = "15s"
restart_limit = 0
timeout = "2s"

如果我们要限制从公网连接 MinIO ,只允许和 MinIO 使用相同网络的应用访问，只要删除 [[services]] 下的内容即可。

Fly.io 部署 go 应用

Sat, 12 Nov 2022 21:58:19 +0800

前面讲解了 Fly.io 的初步入门使用，本文讲解在没有 docker 环境情况下部署 go 开发的应用。

项目

这里为了演示方便，简单使用 go 编写一个：

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w,"hello world")

	})

	log.Println("listening on", 8080)
	log.Fatal(http.ListenAndServe(":"+"8080", nil))
}

安装 Flyctl 并登录

这个步骤上篇文章已经介绍过来，还不了解如何安装登录的可以参考前面的文章。

配置 Fly 应用程序

进入项目的根目录，执行 flyctl launch,它会根据你输入的配置 (主要是应用名，部署区域，是否需要数据库和 redis) 来生成相应的配置文件，并帮你在远程构建器上打包镜像并部署，如果有 DOCKERFILE 文件就会使用你的进行构建，如果没有就会使用相应的官方文件进行构建镜像。

需要注意的是你的应用需要监听 8080 端口，否则部署时会报错

从日志可以看到打包好的镜像名是 registry.fly.io/cool-grass-2591:deployment-01GHPEDCXBC3K5NAGHNZWKT49H

fly.toml 配置

我们来看看 flyctl 帮我们生成的 fly.toml 具体内容：

# fly.toml file generated for cool-grass-2591 on 2022-11-13T01:32:35+08:00

app = "cool-grass-2591"
kill_signal = "SIGINT"
kill_timeout = 5
processes = []

[env]

[experimental]
  allowed_public_ports = []
  auto_rollback = true

[[services]]
  http_checks = []
  internal_port = 8080
  processes = ["app"]
  protocol = "tcp"
  script_checks = []
  [services.concurrency]
    hard_limit = 25
    soft_limit = 20
    type = "connections"

  [[services.ports]]
    force_https = true
    handlers = ["http"]
    port = 80

  [[services.ports]]
    handlers = ["tls", "http"]
    port = 443

  [[services.tcp_checks]]
    grace_period = "1s"
    interval = "15s"
    restart_limit = 0
    timeout = "2s"

主要就是一些常规的服务端口配置等。

Png 压缩工具

Sat, 05 Nov 2022 15:24:37 +0800

最近有一个需求，需要对 png 和 jpg 格式的图片进行压缩，jpg 格式的图片压缩比较简单，难点主要是针对 png 图片，本想继续采用前篇文章的方式将 png 转为 jpg 图片进行压缩的，但我发现部分转换后的图片出现比较大的问题，图片的背景由其它颜色变成了黑色，那看来不能采用原来的方法，得寻找新的方法，通过查阅资料发现了 2 个压缩 png 图片的工具 pngquant 和 pngcrush，接下来我就来分别介绍这 2 个工具。

pngquant

pngquant 是一个命令行实用程序，也是一个用于 PNG 图像有损压缩的库。这种转换大大减少了文件大小 (通常多达 70%)，并保留了完全的 alpha 透明度。

下载

可以通过官网提供的 gui 程序或者命令行程序链接下载 pngquant，也可以通过源代码进行编译，我采用了编译好的命令行程序。

参数


options:
  --force           覆盖原来输出的图片
  --skip-if-larger  仅当原来图片小于原图片时才保留
  --output file     输出的文件路径
  --ext new.png     为输出文件名设置自定义扩展名。默认情况下使用-or8.png 或-fs8.png。
  --quality min-max 指示使用达到或超过最高质量 pngquant 所需的最少颜色。如果转换导致质量低于最低质量，则图像将不会被保存（如果输出到标准输出，将输出 24 位原始图像）并将以状态码 99 退出。pngquant
min 和 max 是 0（最差）到 100（完美）范围内的数字
  --speed N         从 1（暴力）到 10（最快）的速度/质量权衡。默认值为 3。速度 10 的质量降低 5%，但比默认值快 8 倍。
  --nofs            禁用 Floyd-Steinberg dithering
  --posterize N     output lower-precision color (e.g. for ARGB4444 output)
  --strip           remove optional metadata (default on Mac)
  --verbose         打印状态信息

简单使用

压缩单个 png

pngquant –force –verbose –quality=45-85 pngpath

apisix 实现 nginx proxy_hide_header 参数

Sat, 05 Nov 2022 13:54:01 +0800

前言

最近需要使用 apisix 反向代理 oss, 实现通过域名访问相应的资源 (由于条件的限制，不能在 oss 绑定自定义域名)，我直接在 apisix dashboard 配置了路由，创建成功后，我通过浏览器访问时，发现资源不能预览会直接下载。

这样的现象让我很奇怪，通过查阅相关资料，发现使用 OSS 默认域名通过文件 URL 从浏览器访问图片或者网页文件时，Response Header 中会自动加上 Content-Disposition:attachment。即从浏览器访问这些文件时，会以附件形式进行下载。

解决

通过询问同事，得知他是通过 nginx 的 proxy_hide_header 忽略 Content-Disposition 解决的。那 apisix 该怎么实现呢，我通过自己的不断尝试和提 issue 询问官方人员，得知可以使用 response-rewrite 插件实现这个功能。

接下来我就来介绍下我尝试的过程吧，我最开始是使用 proxy-rewrite 将 Content-Disposition 设置为 inline，具体配置如下：

{
  "uri": "/*",
  "name": "xx",
  "host": "xixi.xx.work",
  "plugins": {
    "proxy-rewrite": {
      "headers": {
        "Content-Disposition": "inline"
      },
      "host": "xx",
      "regex_uri": [
        "/(.*)$",
        "/xx/${1}"
      ]
    }
  },
  "upstream": {
    "nodes": [
      {
        "host": "xxx.com",
        "port": 80,
        "weight": 1
      }
    ],
    "timeout": {
      "connect": 6,
      "send": 6,
      "read": 6
    },
    "type": "roundrobin",
    "scheme": "http",
    "pass_host": "pass",
    "keepalive_pool": {
      "idle_timeout": 60,
      "requests": 1000,
      "size": 320
    }
  },
  "status": 1
}

curl 结果：

前后端使用 AES 加密传输数据

Sat, 29 Oct 2022 16:28:17 +0800

最近遇到前后端传输数据需要进行加密的需求，本篇文章就分别介绍使用 Node.js 和 go 进行 AES 加密解密的方法，AES 有很多不同的算法，如 aes192，aes-128-ecb，aes-256-cbc 等，根据不同的密钥长度会使用不同的算法。加密后的结果有两种表示方法：hex 和 base64，我们这里使用 hex.

golang

使用 golang 实现 aes 加密，我使用标准库的方法实现，我使用的 CBC 模式。

加密

func AesEncrypt(encryptStr string, key []byte, iv string) (string, error) {
	encryptBytes := []byte(encryptStr)
	block, err := aes.NewCipher(key)
	if err != nil {
		return "", err
	}

	blockSize := block.BlockSize()
	encryptBytes = pkcs5Padding(encryptBytes, blockSize)

	blockMode := cipher.NewCBCEncrypter(block, []byte(iv))
	encrypted := make([]byte, len(encryptBytes))
	blockMode.CryptBlocks(encrypted, encryptBytes)
	return hex.EncodeToString(encrypted), nil
}

解密

func AesDecrypt(decryptStr string, key []byte, iv string) (string, error) {
	decryptBytes, err := hex.DecodeString(decryptStr)
	if err != nil {
		return "", err
	}

	block, err := aes.NewCipher(key)
	if err != nil {
		return "", err
	}

	blockMode := cipher.NewCBCDecrypter(block, []byte(iv))
	decrypted := make([]byte, len(decryptBytes))

	blockMode.CryptBlocks(decrypted, decryptBytes)
	decrypted = pkcs5UnPadding(decrypted)
	return string(decrypted), nil
}

运行加密解密例子

package main

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"encoding/hex"
	"fmt"
)

func AesEncrypt(encryptStr string, key []byte, iv string) (string, error) {
	encryptBytes := []byte(encryptStr)
	block, err := aes.NewCipher(key)
	if err != nil {
		return "", err
	}

	blockSize := block.BlockSize()
	encryptBytes = pkcs5Padding(encryptBytes, blockSize)

	blockMode := cipher.NewCBCEncrypter(block, []byte(iv))
	encrypted := make([]byte, len(encryptBytes))
	blockMode.CryptBlocks(encrypted, encryptBytes)
	return hex.EncodeToString(encrypted), nil
}

func AesDecrypt(decryptStr string, key []byte, iv string) (string, error) {
	decryptBytes, err := hex.DecodeString(decryptStr)
	if err != nil {
		return "", err
	}

	block, err := aes.NewCipher(key)
	if err != nil {
		return "", err
	}

	blockMode := cipher.NewCBCDecrypter(block, []byte(iv))
	decrypted := make([]byte, len(decryptBytes))

	blockMode.CryptBlocks(decrypted, decryptBytes)
	decrypted = pkcs5UnPadding(decrypted)
	return string(decrypted), nil
}

func pkcs5Padding(cipherText []byte, blockSize int) []byte {
	padding := blockSize - len(cipherText)%blockSize
	padText := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(cipherText, padText...)
}

func pkcs5UnPadding(decrypted []byte) []byte {
	length := len(decrypted)
	unPadding := int(decrypted[length-1])
	return decrypted[:(length - unPadding)]
}
func main() {
	data := "i am test data"
	key := []byte("1111111111111111")
	iv := "1111122211111111"
	encrypt, err := AesEncrypt(data, key, iv)
	if err != nil {
		panic(err)
		return
	}
	fmt.Println(encrypt)
	decrypt, err := AesDecrypt(encrypt, key, iv)
	if err != nil {
		panic(err)
	}
	fmt.Println(decrypt)
}

Fly.io 初体验

Sat, 22 Oct 2022 22:30:36 +0800

前言

最近在群里看到群友提到了 Fly.io 这个应用部署平台，相比其它平台，Fly.io 提供了数据库。本篇文章我就来简单介绍如何使用 Fly.io。

安装 flyctl

Flyctl 是一个应用命令行工具，可以让你很方便的从创建用户、创建应用并部署应用。

Windows 安装

iwr https://fly.io/install.ps1 -useb | iex

Linux 安装

curl -L https://fly.io/install.sh | sh

MAC 安装

brew install flyctl

或者

curl -L https://fly.io/install.sh | sh

注册 Fly.io 账号

使用 flyctl auth signup 命令进行用户注册，你可以使用电子邮件注册，也可以使用 Github 账号进行登录。

登录账号

使用 flyctl auth login 命令登录你的 Fly.io 账号，由于我没有 Fly.io 账号，前面注册时就会登录，可以直接跳过这步。

启动应用程序

接下来我们就可以进行应用的部署了，Fly.io 使用的是 docker 镜像的方式进行应用部署的，由于我本地环境的限制，本文我使用一个基础的 flyio/hellofly:latest 镜像进行部署使用。

每个应用使用 fly.toml 配置文件来告诉 Fly.io 如何进行部署。我们使用 flyctl launch 命令生成相应的配置文件。

AI 绘画初体验

Sat, 15 Oct 2022 22:19:32 +0800

前言

最近我发现各个群里出现了一股利用 AI 进行绘画的潮流，今天我也尝试使用 Stable Diffusion 模型进行 AI 绘画。

Stable Diffusion 简介

Stable Diffusion 是一个文本到图像的模型，将使人们可以在几秒钟内创造出令人惊叹的艺术作品。它在速度和质量方面都有突破，这意味着它可以在消费级 GPU 上运行

开始

我们采用别人封装的 stable-diffusion-webui 平台进行绘画，由于各种条件限制，我们使用 github 上提供的 Google colab notbook 进行部署 (https://colab.research.google.com/drive/1IplUv47g9CgtlJmFnyT2sDyNYDEeMJDi?usp=sharing).

打开链接，我简单的看了下代码，前面是基础的安装运行环境、需要的 Python package .我们依次运行即可。

我们直接来到 1.4 Connect to Google Drive，勾选 download_if_missing，然后到 https://huggingface.co/settings/tokens 复制你的 toekn 并填入。(huggingface 注册耗费了许多时间，reCAPTCHA 没有通过).

点击运行后就开始拉取模型。

如果运行发现报错了：

remote: Access to model CompVis/stable-diffusion-v-1-4-original is restricted and you are not in the authorized list. Visit https://huggingface.co/CompVis/stable-diffusion-v-1-4-original to ask for access.
fatal: unable to access 'https://huggingface.co/CompVis/stable-diffusion-v-1-4-original/': The requested URL returned error: 403

你需要到 https://huggingface.co/CompVis/stable-diffusion-v-1-4-original 授权模型的访问权限。授权后重新运行即可。

Kubernetes Configmaps mounted with subPath not update when changed

Sun, 02 Oct 2022 13:05:57 +0800

起因

最近在使用 k8s 部署应用时，我使用 ConfigMaps 的方式来挂载应用的配置文件。在我的知识储备中，k8s 修改 cm 的内容，pod 里的配置文件应该也会同步更新才是，但是我进入 pod , 发现配置还是旧版本没有更新，需要重启 pod 才会生效。

问题

那为什么配置没有及时更新呢？通过查阅资料，我发现使用 subPath 挂载的容器不会接收到配置更新。这是为什么呢，相比于没有使用 subPath 有什么区别呢？

subPath 使用了符号链接的方式挂载文件，容器内的文件是一个链接到存储在一个隐藏的带有时间戳目录中的同名文件。当 configMaps 更新时，符号链接会更新，但挂载在容器中的文件绑定保持不变。

解决

使用 path 字段为特定 ConfigMap 项指定所需的文件路径

具体如下：

apiVersion: v1
kind: Pod
metadata:
  name: dapi-test-pod
spec:
  containers:
    - name: test-container
      image: registry.k8s.io/busybox
      command: [ "/bin/sh","-c","cat /etc/config/keys" ]
      volumeMounts:
      - name: config-volume
        mountPath: /etc/config
  volumes:
    - name: config-volume
      configMap:
        name: special-config
        items:
        - key: SPECIAL_LEVEL
          path: keys
  restartPolicy: Never

亲测这样是可以正常更新的，但同目录下的其它文件会删除掉，看了几个相关的 issues , 发现你还可以手动创建符号链接到相应的文件夹，

小结

使用 subPath 挂载配置至容器时，配置更新时，容器内的配置不能同步更新，这是 k8s 官方处于各种原因做出的限制，目前还没有很好的办法来解决这个问题。

参考

Easeprobe 简单介绍使用

Sat, 24 Sep 2022 16:28:44 +0800

本篇文章将由我来介绍一款健康/状态检查工具 - Easeprobe 的简单使用。

介绍

EaseProbe 是一个由用 Go 编写的简单、独立、轻量级的工具，可以进行健康/状态检查，

EaseProbe 主要完成 3 个目标工具：探测、通知、报告

探测

EaseProbe 支持多种方法来执行其探测，例如：

*  HTTP。检查 HTTP 状态码，支持 mTLS，HTTP Basic Auth，可以设置 Request Header/Body。（HTTP 探针配置）
*  TCP。检查是否可以建立 TCP 连接。(TCP 探针配置)
*  shell。运行 Shell 命令并检查结果。（Shell 命令探针配置）
*  SSH。通过 SSH 运行远程命令并检查结果。支持堡垒/跳转服务器（SSH 命令探针配置）
*  TLS。使用 TLS 连接到给定端口并（可选）验证已撤销或过期的证书（TLS 探针配置）
*  Host。在远程主机上运行 SSH 命令并检查 CPU、内存和磁盘使用情况。（主机负载探针）
*  client。支持以下本机客户端。它们都支持 mTLS 和数据检查，请参阅 Native Client Probe 配置
    *  MySQL。连接到 MySQL 服务器并运行 SHOW STATUSSQL。
    *  Redis。连接到 Redis 服务器并运行 PING 命令。
    *  Memcache。连接到 Memcache 服务器并运行 version 命令或验证给定的键/值对。
    *  MongoDB。连接到 MongoDB 服务器并执行 ping。
    *  Kafka。连接到 Kafka 服务器并执行所有主题的列表。
    *  PostgreSQL。连接到 PostgreSQL 服务器并运行 SELECT 1SQL。
    *  Zookeeper。连接到 Zookeeper 服务器并运行 get /命令。

通知

EaseProbe 支持多种通知方式向你发送通知，例如：slack、钉钉、企业微信、邮件、Telegram 等。

gRPC 中间件

Sun, 18 Sep 2022 00:06:58 +0800

本文我来介绍 gRPC 中的中间件相关知识。

介绍

gRPC 中间件基于前面讲解的拦截器相关概念，它是一组拦截器、辅助、工具的集合，在我们使用 gRPC 开发应用时，往往会使用到各种中间件。它允许在服务端或客户端以拦截器链条形式应用多个中间件。因为拦截器经常用来实现一些通用的功能 ,如鉴权认证、日志、监控等，所以使用 gRPC 中间件来实现这些可重用功能是十分合适的。下面的代码就分别暂时服务端和客户端使用中间件的例子：

import "github.com/grpc-ecosystem/go-grpc-middleware"

myServer := grpc.NewServer(
    grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(
        grpc_ctxtags.StreamServerInterceptor(),
        grpc_opentracing.StreamServerInterceptor(),
        grpc_prometheus.StreamServerInterceptor,
        grpc_zap.StreamServerInterceptor(zapLogger),
        grpc_auth.StreamServerInterceptor(myAuthFunction),
        grpc_recovery.StreamServerInterceptor(),
    )),
    grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
        grpc_ctxtags.UnaryServerInterceptor(),
        grpc_opentracing.UnaryServerInterceptor(),
        grpc_prometheus.UnaryServerInterceptor,
        grpc_zap.UnaryServerInterceptor(zapLogger),
        grpc_auth.UnaryServerInterceptor(myAuthFunction),
        grpc_recovery.UnaryServerInterceptor(),
    )),
)

import "github.com/grpc-ecosystem/go-grpc-middleware"

clientConn, err = grpc.Dial(
    address,
    grpc.WithUnaryInterceptor(grpc_middleware.ChainUnaryClient(monitoringClientUnary, retryUnary)),
    grpc.WithStreamInterceptor(grpc_middleware.ChainStreamClient(monitoringClientStream, retryStream)),
)

常用的中间件

go-grpc-middleware 项目提供了一些常用的中间件：

认证

grpc_auth - 一个可定制的（通过 AuthFunc）身份验证中间件

日志记录

grpc_ctxtags - 将 Tag 地图添加到上下文的库，数据从请求正文填充
grpc_zap - 将 zap 日志库集成到 gRPC 处理程序中。
grpc_logrus - 将 logrus 日志库集成到 gRPC 处理程序中。
grpc_kit - 将 go-kit/log 日志库集成到 gRPC 处理程序中。
grpc_grpc_logsettablegrpclog.LoggerV2 - 一个允许在运行时替换记录器的包装器（线程安全）。

监控

grpc_prometheus - Prometheus 客户端和服务器端监控中间件
otgrpc - OpenTracing 客户端和服务器端拦截器
grpc_opentracing - OpenTracing 客户端和服务器端拦截器，支持流式处理和处理程序返回的标签
otelgrpc - OpenTelemetry 客户端和服务器端拦截器

客户端中间件

grpc_retry - 一个通用的 gRPC 响应代码重试机制，客户端中间件

Gitlab CVE-2021-22205

Sat, 10 Sep 2022 22:06:22 +0800

起因

最近一台服务器出现服务器资源 cpu、内存过高的情况，通过对进程的分析，发现是 gitlab 容器进程，怀疑是 gitlab 被入侵运行了挖矿病毒，通过对 gitlab 日志的分析，可以得出入侵者是利用了 gitlab 的 CVE-2021-22205 的漏洞，对 gitlab 进行了攻击。

CVE-2021-22205 介绍

CVE-2021-22205 是一个严重的严重性漏洞 (CVSS 10.0)，它是由第三方文件解析器 Exif-Tool 对图像文件进行不当验证的结果，导致远程命令执行漏洞，可能导致您的 GitLab 实例被攻击。

以下版本受到漏洞影响:

11.9.x - 13.8.7

13.9.0 - 13.9.5

13.10.0 - 13.10.2

解决

gitlab 发布了 GitLab 13.10.3、13.9.6 和 13.8.8 版本来解决这个漏洞。请尽快升级。

如果无法即使更新和使用热更新补丁解决，可以通过将 exiftool 脚本替换为 cat -。这个解决方案将防止从上传的图像中剥离所有的 exif 数据。

将 /opt/gitlab/embedded/bin/exiftool 脚本内容替换为

#!/bin/bash

cat -

这种方法不是长久之计，每次重启容器时都要手动修改文件，还是尽快更新版本。

原因

根据 gitlab 的官方漏洞 issues 来看，当访问接口/uploads/user 上传图像文件时，GitLab Workhorse 会将扩展名为 jpg、jpeg、tiff 文件传递给 ExifTool。用于删除其中不合法的标签。具体的标签在 workhorse/internal/upload/exif/exif.go 中的 startProcessing 方法中有定义，为白名单处理。

gRPC 请求抓包

Sat, 03 Sep 2022 22:46:19 +0800

前言

本文来简单介绍如何使用 wireshark 来获取 gRPC 请求。

wireshark 配置

在进行对 gRPC 请求抓包前，得来几个准备。

设置 proto 文件路径

依次打开编辑 > 首选项 > Protocols > ProtoBuf, 点击如图选项，添加 proto 文件所在的路径。记得勾选右边的 “Load all files” 选项。

设置 TCP 消息解码

默认情况下，界面上显示的都是 TCP 数据包。依次点击菜单栏的分析 -> 解码为… （或者右击随便一行）。

把 9000 (你的 gRPC 服务端端口) 端口的 TCP 消息解码成 HTTP2 协议信息。

开始抓包

现在开始捕获 gRPC 请求消息，为了避免其他无关的流量，在捕获选项设置筛选 tcp port 9000 只获得跟服务端相关的流量。

我们使用 postman 向服务端发送请求。回到 wireshark 界面，我们就可以看到许多流量，通过前面设置的解码，我们可以很方便的获得 gRPC 消息的具体内容。

小结

本文简单介绍了如何使用 wireshark 捕获 gRPC 请求流量。在使用 Wireshark 抓包时把未识别的 HTTP/2 协议手动设置为 HTTP/2，这样会方便很多。

gRPC 服务反射协议

Sat, 27 Aug 2022 23:50:09 +0800

本文主要介绍 gRPC 的服务反射协议和相关的应用。

介绍

gRPC 服务反射协议 (server reflection) 是在 gRPC 服务端定义的一个服务，它能提供该服务器端上可公开使用的 gRPC 服务的信息，简单的来说，就是服务反射向客户端提供了服务端注册的服务的信息。因此客户端不需要预编译服务定义就能与服务端交互了。

客户端想要与服务端程序进行通信，必须要有所定义的服务信息，需要编译生产客户端存根，借助 gRPC 服务反射协议，我们就可以无需编译服务定义就能通信。

使用

该如何开启服务反射协议呢？很简单，只需要通过一行代码即可开启：reflection.Register()

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net"

	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"

	ecpb "google.golang.org/grpc/examples/features/proto/echo"
	hwpb "google.golang.org/grpc/examples/helloworld/helloworld"
)

var port = flag.Int("port", 50051, "the port to serve on")

// hwServer is used to implement helloworld.GreeterServer.
type hwServer struct {
	hwpb.UnimplementedGreeterServer
}

// SayHello implements helloworld.GreeterServer
func (s *hwServer) SayHello(ctx context.Context, in *hwpb.HelloRequest) (*hwpb.HelloReply, error) {
	return &hwpb.HelloReply{Message: "Hello " + in.Name}, nil
}

type ecServer struct {
	ecpb.UnimplementedEchoServer
}

func (s *ecServer) UnaryEcho(ctx context.Context, req *ecpb.EchoRequest) (*ecpb.EchoResponse, error) {
	return &ecpb.EchoResponse{Message: req.Message}, nil
}

func main() {
	flag.Parse()
	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	fmt.Printf("server listening at %v\n", lis.Addr())

	s := grpc.NewServer()

	// Register Greeter on the server.
	hwpb.RegisterGreeterServer(s, &hwServer{})

	// Register RouteGuide on the same server.
	ecpb.RegisterEchoServer(s, &ecServer{})

	// Register reflection service on gRPC server.
	reflection.Register(s)

	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

服务端开启服务反射协议后，就可以通过 gRPC CLI 工具来检查服务端了。这里就不多介绍了，接下来我们来看看服务反射协议在 kratos 中的使用。

Prometheus_operato

Tue, 23 Aug 2022 22:18:08 +0800

本文介绍 Prometheus operato 的安装

Go 进行浏览器网页截图

Sat, 20 Aug 2022 22:55:14 +0800

前言

在本文中将介绍使用 golang 进行加载某个网站并进行截图。

chromedp

我们将使用 chromedp 通过浏览器驱动来加载网页并截图。具体的步骤如下：

1 启动 chrome 浏览器 2 加载网页 (还可进行其他浏览器操作) 3 截图并保存

需要注意的是项目使用了 Chrome 的驱动，如果没有 Chrome 将不能顺利运行，需要运行 https://hub.docker.com/r/chromedp/headless-shell/ 来进行或运行其他版本的 Chrome。

安装

go get -u github.com/chromedp/chromedp

示例

package main

import (
    "context"
    "io/ioutil"
    "log"

    "github.com/chromedp/chromedp"
)

func main() {


    ctx, cancel := chromedp.NewContext(context.Background(), chromedp.WithDebugf(log.Printf))
    defer cancel()

    url := "https://www.minigame.vip/"
    filename := "minigame.png"


    var imageBuf []byte
	// 捕获某个元素的截图
	if err := chromedp.Run(ctx, elementScreenshot(`https://pkg.go.dev/`, `img.Homepage-logo`, &imageBuf)); err != nil {
		log.Fatal(err)
	}
	if err := ioutil.WriteFile("elementScreenshot.png", imageBuf, 0644); err != nil {
		log.Fatal(err)
	}
    if err := chromedp.Run(ctx, ScreenshotTasks(url, &imageBuf)); err != nil {
        log.Fatal(err)
    }

    if err := ioutil.WriteFile(filename, imageBuf, 0644); err != nil {
        log.Fatal(err)
    }
}

func elementScreenshot(urlstr, sel string, res *[]byte) chromedp.Tasks {
	return chromedp.Tasks{
		chromedp.Navigate(urlstr),
		chromedp.Screenshot(sel, res, chromedp.NodeVisible),
	}
}
func ScreenshotTasks(url string, imageBuf *[]byte) chromedp.Tasks {
    return chromedp.Tasks{
        chromedp.Navigate(url),
		chromedp.FullScreenshot(imageBuf, 90),
    }
}

上面的例子分别是对网页中的单个元素进行截图和对网页全局截图。

gopsutil 介绍

Sat, 13 Aug 2022 23:02:32 +0800

简介

psutil 是一个使用 Python 编写的跨平台平台进程和系统利用率监控库，gopsutil 就是 psutil 的 go 语言实现。

使用

安装

go get github.com/shirou/gopsutil/v3

CPU

获取 cpu 基本信息

func getCpuInfo() {
	cpuInfos, err := cpu.Info()
	if err != nil {
		fmt.Printf("get cpu info failed, err:%v", err)
	}
	for _, ci := range cpuInfos {
		fmt.Println(ci)
	}
	for {
		percent, _ := cpu.Percent(time.Second, false)
		fmt.Printf("cpu percent:%v\n", percent)
	}
}

{"cpu":0,"vendorId":"GenuineIntel","family":"205","model":"","stepping":0,"physicalId":"BFEBFBFF000406E3","coreId":"","cores":4,"modelName":"Intel(R)
 Core(TM) i5-6200U CPU @ 2.30GHz","mhz":2400,"cacheSize":0,"flags":[],"microcode":""}
cpu percent:[40.625]
cpu percent:[15]
cpu percent:[9.615384615384617]
cpu percent:[28.125]

获取 cpu 负载

func getCpuLoad() {
    info, err := load.Avg()
    if err != nil {
    panic(err)
    }
    fmt.Printf("%v\n", info)
}

内存

获取内存

func getMemInfo() {
	memInfo, _ := mem.VirtualMemory()
	fmt.Printf("mem info:%v\n", memInfo)
}

mem info:{"total":8472920064,"available":1921372160,"used":6551547904,"usedPerce
nt":77,"free":1921372160,"active":0,"inactive":0,"wired":0,"laundry":0,"buffers"
:0,"cached":0,"writeBack":0,"dirty":0,"writeBackTmp":0,"shared":0,"slab":0,"srec
laimable":0,"sunreclaim":0,"pageTables":0,"swapCached":0,"commitLimit":0,"commit
tedAS":0,"highTotal":0,"highFree":0,"lowTotal":0,"lowFree":0,"swapTotal":0,"swap
Free":0,"mapped":0,"vmallocTotal":0,"vmallocUsed":0,"vmallocChunk":0,"hugePagesT
otal":0,"hugePagesFree":0,"hugePagesRsvd":0,"hugePagesSurp":0,"hugePageSize":0}

库的其他用法可以查看相应的官方文档。

记一次阿里云 OSS 报错的解决

Tue, 02 Aug 2022 15:28:18 +0800

最近在使用 MinIO go-sdk 操作阿里云 OSS 时遇到了一个问题，特此记录下。

问题

在使用 sdk 调用 PutObject 方法时，发生了报错，具体报错如下：

The request signature we calculated does not match the signature you provided. Check your key and signing method.

解决

可以看出报错的意思是签名不一致问题，我们首先检查 AccessKey ID 和 AccessKey Secret 是否正确，我发现同样创建的 client 在其它地方调用方法时，没有报错，成功上传了文件对象。

后来查了多个相关的问题，发现可能是我填写的 objectName 的问题，我的 objectName 前带了 / 符号，导致在计算签名时变成 // ,使签名不一致。

我去掉前面的 ‘/’ 符号后，果然成功上传了。

总结

在编写相关操作 OSS 代码时，要注意 objectName 的格式，不要加上多余的符号。但奇怪的是原来上传至 MinIO 时没有报错，正常上传，可能是不同的存储有不同的签名规则吧。

参考

gRPC 健康探针

Sun, 31 Jul 2022 14:44:07 +0800

简介

gRPC 健康探针 grpc-health-probe 是社区提供的一个工具，用来检查 gRPC 服务的健康状态，此工具是通过 gRPC 健康检查协议公开服务的状态。

使用

我在本地使用 kratos 创建一个使用 9000 端口的 gRPC 的服务。通过 grpc-health-probe 可以检查服务的健康状态。

 grpc-health-probe -addr=localhost:9000
status: SERVING

可以看到此服务目前是健康的，不健康的服务将以非零退出代码退出。

grpc_health_probe -addr=localhost:9000 -connect-timeout 250ms -rpc-timeout 100ms
failed to connect service at "localhost:9000": context deadline exceeded
exit status 2

grpc_health_probe 发送了一个对 /grpc.health.v1.Health/Check 的 RPC 请求。如果已 SERVING 状态作为响应，就会正常成功退出，否则会给出一个非零的退出。

Kubernetes 使用

grpc_health_probe 可用于 Kubernetes 对 Pod 中运行的 gRPC 服务器进行健康检查。建议您使用 Kubernetes exec 探针并为您的 gRPC 服务器 pod 定义活跃度和/或就绪性检查。

您可以将静态编译 grpc_health_probe 的内容捆绑到您的容器映像中。

GRPC 健康检查

Sat, 23 Jul 2022 21:49:58 +0800

本篇文章我来介绍 gRPC 中的健康检查相关的知识。

简介

服务的健康检测一般是指的是检测服务是否正常运行：

是否存在，因为程序逻辑错误或者 OOM 等进程不存在；
存在是否可以正常的响应请求，尽管进程存在但可能因为请求量过大或者程序逻辑错误，导致服务 hang 住，无法正常对外请求。

gRPC 定义了一个健康检查协议，它允许使用了 gRPC 服务暴露服务器的状态，这样服务的消费者就能获得服务的健康状态。服务器的健康状态是由服务器是否响应非健康状态来确定的。当服务器还没准备好处理 rpc 请求或者根本没有响应健康探针的请求时，就会发生这种情况。

健康服务定义

gRPC 健康检查协议基于 gRPC 定义了 API。下面就是服务定义：

syntax = "proto3";

package grpc.health.v1;

message HealthCheckRequest {
  string service = 1;
}

message HealthCheckResponse {
  enum ServingStatus {
    UNKNOWN = 0;
    SERVING = 1;
    NOT_SERVING = 2;
  }
  ServingStatus status = 1;
}

service Health {
  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);

  rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse);
}

客户端应该调用 Check 服务来判断服务是否正常运行，并且设置 deadline。客户端可以设置需要查询的服务名称，来返回对应的服务是否正常。

服务器应手动注册所有的服务并单个设置状态，包括空服务名称及其状态。对于收到的每一个请求，从注册表中查询服务的状态并返回。如果未找到，返回 NOT_FOUND 状态。服务器也可以根据实际的业务逻辑提供更为复杂的状态返回。

Go 发送邮件

Sat, 16 Jul 2022 20:47:01 +0800

介绍

电子邮件是一种用电子手段提供信息交换的通信方式，是互联网应用最广的服务。通过网络的电子邮件系统，用户可以以非常低廉的价格（不管发送到哪里，都只需负担网费）、非常快速的方式（几秒钟之内可以发送到世界上任何指定的目的地），与世界上任何一个角落的网络用户联系。

电子邮件在网络中的传输需要遵从一定的协议的，常用的电子邮件协议包括 SMTP，POP3，IMAP。电子邮件的创建和发送只涉及到 SMTP 协议，本文主要就是介绍 go 使用 SMTP 协议发生邮件。

使用

我们这里使用 https://github.com/jordan-wright/email 这个 pkg 来创建和发送邮件。pkg 的安装这里就不过多介绍了。

我们知道邮箱使用 SMTP/POP3/IMAP 等协议从邮件服务器上拉取邮件。邮件并不是直接发送到邮箱的，而是邮箱请求拉取的。所以，我们需要配置 SMTP/POP3/IMAP 服务器。从头搭建固然可行，而且也有现成的开源库，但是比较麻烦。这里我使用 gmail，配置流程就不过多介绍了 (ps: Google 的安全性还是比较强的，设置了好久。

代码：

package main

import (
	"log"
	"net/smtp"

	"github.com/jordan-wright/email"
)

func main() {
	e := email.NewEmail()
	e.From = "jm@gmail.com"
	e.To = []string{"1@qq.com"}
	e.Subject = "这是主题"
	e.Text = []byte("测试邮件发送")
	err := e.Send("smtp.gmail.com:587", smtp.PlainAuth("", "jm@gmail.com", "xx", "smtp.gmail.com"))
	if err != nil {
		log.Fatal(err)
	}
}

过一会就顺利收到邮件了，有时候邮件会被当作垃圾邮件收入垃圾箱里，收不到时可以去垃圾箱看看。

参考

https://baike.baidu.com/item/%E7%94%B5%E5%AD%90%E9%82%AE%E4%BB%B6/111106

Go 协程闭包的问题

Sun, 10 Jul 2022 10:27:23 +0800

问题

最近在代码中遇到了这么一个问题，现在有一个循环，每一个循环中创建一个协程用来执行函数，我发现函数运行的结果却是大部分时候都是使用最后一个循环变量，不符合实际要求。

大概的代码如下：

package main

import (
	"fmt"
	"net/http"
)

func main() {

	for i := 0; i < 10; i++ {
		go func() { fmt.Println(i) }()
	}
	http.ListenAndServe(":8080", nil)
}

运行：

多次运行，可以发现大部分情况都是将 i = 10 代入函数执行。

原因

那这是为什么呢？这个就是函数闭包。协程运行的是一个闭包函数，其中使用了主线程的变量 i。看上去这和第一组几乎一样。但是在每个协程中，从进入匿名函数到调用 Println 将 i 的值复制入栈之间仍需要一小段时间运行，而这段时间内足以主线程完成全部 10 次循环。所以终于到将 i 的值复制入栈调用 Println 时，i 已经成为 10 且不再变化了。

解决

那该怎么解决使代码如我们的需求运行呢？

我们只需将变量 i 复制进栈中即可，改动后的代码：

package main

import (
	"fmt"
	"net/http"
)

func main() {

	for i := 0; i < 10; i++ {
		go func(j int) { fmt.Println(j) }(i)
	}
	http.ListenAndServe(":8080", nil)
}

结果：

Go 压缩 png 图像大小

Sat, 02 Jul 2022 21:32:02 +0800

起因

最近在处理一个需求，需要将 png 图像按比例调整图像尺寸，要求在保证图像质量的情况下尽量缩小文件大小。在本篇文章主要介绍我将 png 文件大小缩小使用的方法。

方法

这个需求缩小图像的尺寸很好解决，但缩小后的图像大小不尽人意，缩小的图像文件大小没有变化过多，甚至更大。我通过查询，发现了一种方法，就是先将图片转换为 jpeg 格式，再进行压缩后转换为 png 即可。

Jpeg 的图片压缩是很好做的，因为 jpeg 这个协议本身就支持调整图片质量的。在 golang 中，我们只需要使用标准库的 image/jpeg，将图片从二进制数据解码后，降低质量再编码为二进制数据即可实现压缩。而且质量和压缩比例相对而言还不错。

func compressImageResource(data []byte) []byte {
    imgSrc, _, err := image.Decode(bytes.NewReader(data))
    if err != nil {
    return data
    }
    newImg := image.NewRGBA(imgSrc.Bounds())
    draw.Draw(newImg, newImg.Bounds(), &image.Uniform{C: color.White}, image.Point{}, draw.Src)
    draw.Draw(newImg, newImg.Bounds(), imgSrc, imgSrc.Bounds().Min, draw.Over)
    buf := bytes.Buffer{}
    err = jpeg.Encode(&buf, newImg, &jpeg.Options{Quality: 40})
    if err != nil {
    return data
    }
    if buf.Len() > len(data) {
    return data
    }
    return buf.Bytes()
}

小结

本文主要介绍了将 png 图像大小缩小的一种简单方法，还有其他方法等待你们的发掘。

Go 处理 zip 解压乱码问题

Sat, 25 Jun 2022 22:09:31 +0800

问题

最近在某个场景中，需要使用 go 官方的 archive/zip 处理 zip 压缩包，在处理过程中，遇到了一个问题：go 解压后的文件存在文件名乱码的情况。

解决

我们知道在 go 中，字符串是以 UTF-8 编码的，所以有可能出现乱码的情况。

我们只要在处理压缩包中的文件时，通过判断 Flags 字段，如果 Flags 为 0 , 则使用本地编码，默认为 GBK。如果为 1 , 则使用 UTF-8 编码。

我们只要在为 0 时对文件名进行处理就好。代码：

func Unzip(zipFile string, destDir string) error {
    zipReader, err := zip.OpenReader(zipFile)
    if err != nil {
        return err
    }
    defer zipReader.Close()
    var decodeName string
    for _, f := range zipReader.File {
        if f.Flags == 0{
            i:= bytes.NewReader([]byte(f.Name))
            decoder := transform.NewReader(i, simplifiedchinese.GB18030.NewDecoder())
            content,_:= ioutil.ReadAll(decoder)
            decodeName = string(content)
        }else{
            decodeName = f.Name
        }

        fpath := filepath.Join(destDir, decodeName)
        if f.FileInfo().IsDir() {
            os.MkdirAll(fpath, os.ModePerm)
        } else {
            if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
                return err
            }

            inFile, err := f.Open()
            if err != nil {
                return err
            }
            defer inFile.Close()

            outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
            if err != nil {
                return err
            }
            defer outFile.Close()

            _, err = io.Copy(outFile, inFile)
            if err != nil {
                return err
            }
        }
    }
    return nil
}

参考

Singleflight 介绍

Sat, 18 Jun 2022 16:25:02 +0800

缓存击穿

对于一些设置了过期时间的 key，如果这些 key 可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：缓存被“击穿”的问题，这个和缓存雪崩的区别在于这里针对某一 key 缓存，前者则是很多 key。

缓存在某个时间点过期的时候，恰好在这个时间点对这个 Key 有大量的并发请求过来，这些请求发现缓存过期一般都会从后端 DB 加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端 DB 压垮。

我在 go-redis/cache 中发现了库使用了 singleflight , 经过查阅资料，了解了这个库的主要作用就是将一组相同的请求合并成一个请求，实际上只会去请求一次，然后对所有的请求返回相同的结果。这样会大大降低数据库的压力。

singleflight 使用

函数签名

type Group struct {
    mu sync.Mutex       // protects m
    m  map[string]*call // lazily initialized
}
// Do 执行函数，对同一个 key 多次调用的时候，在第一次调用没有执行完的时候
// 只会执行一次 fn 其他的调用会阻塞住等待这次调用返回
// v, err 是传入的 fn 的返回值
// shared 表示是否真正执行了 fn 返回的结果，还是返回的共享的结果
func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool)
// DoChan 和 Do 类似，只是 DoChan 返回一个 channel，也就是同步与异步的区别
func (g *Group) DoChan(key string, fn func() (interface{}, error)) <-chan Result
// Forget 用于通知 Group 删除某个 key 这样后面继续这个 key 的调用的时候就不会在阻塞等待了
func (g *Group) Forget(key string)

示例

接下来我们来讲解一个简单的例子，我们来看看 singleflight 的使用方式，先来看一个简单的例子：

Go 定时监控 Https 证书

Sat, 11 Jun 2022 14:29:57 +0800

起因

最近有由于一个域名的 https 证书过期，导致某个网站出现大面积无法正常使用的故障。于是我打算使用 go 语言来监控域名的 HTTPS 证书过期情况，来及时续期证书。

HTTPS 证书

了解证书加密体系的应该知道，TLS 证书是链式信任的，所以中间任何一个证书过期、失效都会导致整个信任链断裂，不过单纯的 Let’s Encrypt ACME 证书检测可能只关注末端证书即可，除非哪天 Let’s Encrypt 倒下…

解决

在 go 语言中，Go 在发送 HTTP 请求后，在响应体中会包含一个 TLS *tls.ConnectionState 结构体，该结构体中目前存放了服务端返回的整个证书链：

// ConnectionState records basic TLS details about the connection.
type ConnectionState struct {
	// Version is the TLS version used by the connection (e.g. VersionTLS12).
	Version uint16

	// HandshakeComplete is true if the handshake has concluded.
	HandshakeComplete bool

	// DidResume is true if this connection was successfully resumed from a
	// previous session with a session ticket or similar mechanism.
	DidResume bool

	// CipherSuite is the cipher suite negotiated for the connection (e.g.
	// TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS_AES_128_GCM_SHA256).
	CipherSuite uint16

	// NegotiatedProtocol is the application protocol negotiated with ALPN.
	NegotiatedProtocol string

	// NegotiatedProtocolIsMutual used to indicate a mutual NPN negotiation.
	//
	// Deprecated: this value is always true.
	NegotiatedProtocolIsMutual bool

	// ServerName is the value of the Server Name Indication extension sent by
	// the client. It's available both on the server and on the client side.
	ServerName string

	// PeerCertificates are the parsed certificates sent by the peer, in the
	// order in which they were sent. The first element is the leaf certificate
	// that the connection is verified against.
	//
	// On the client side, it can't be empty. On the server side, it can be
	// empty if Config.ClientAuth is not RequireAnyClientCert or
	// RequireAndVerifyClientCert.
	PeerCertificates []*x509.Certificate

	// VerifiedChains is a list of one or more chains where the first element is
	// PeerCertificates[0] and the last element is from Config.RootCAs (on the
	// client side) or Config.ClientCAs (on the server side).
	//
	// On the client side, it's set if Config.InsecureSkipVerify is false. On
	// the server side, it's set if Config.ClientAuth is VerifyClientCertIfGiven
	// (and the peer provided a certificate) or RequireAndVerifyClientCert.
	VerifiedChains [][]*x509.Certificate

	// SignedCertificateTimestamps is a list of SCTs provided by the peer
	// through the TLS handshake for the leaf certificate, if any.
	SignedCertificateTimestamps [][]byte

	// OCSPResponse is a stapled Online Certificate Status Protocol (OCSP)
	// response provided by the peer for the leaf certificate, if any.
	OCSPResponse []byte

	// TLSUnique contains the "tls-unique" channel binding value (see RFC 5929,
	// Section 3). This value will be nil for TLS 1.3 connections and for all
	// resumed connections.
	//
	// Deprecated: there are conditions in which this value might not be unique
	// to a connection. See the Security Considerations sections of RFC 5705 and
	// RFC 7627, and https://mitls.org/pages/attacks/3SHAKE#channelbindings.
	TLSUnique []byte

	// ekm is a closure exposed via ExportKeyingMaterial.
	ekm func(label string, context []byte, length int) ([]byte, error)
}

可以看到 PeerCertificates 包含了所有的证书，我们只只要遍历 PeerCertificates，根据 NotBefore, NotAfter 字段就能进行是否过期的判断

Go 并发 Sync.Once 解析

Fri, 03 Jun 2022 22:57:38 +0800

在 go 语言中我们可以使用 sync.Once 对象来实现函数方法只执行一次的功能。

简单代码示例

package main

import (
	"fmt"
	"sync"
)

func main() {
	var (
		o  sync.Once
		wg sync.WaitGroup
	)

	for i := 0; i < 10; i++ {
		wg.Add(1)

		go func(i int) {
			defer wg.Done()
			o.Do(func() {
				fmt.Printf("hello %d\n", i)
			})
		}(i)
	}

	wg.Wait()
}

输出：

hello 9

不使用 Sync.Once 的结果如下：

hello 9
hello 4
hello 0
hello 1
hello 2
hello 3
hello 6
hello 5
hello 7
hello 8

可以看到，在使用 sync.Once 的情况下，只执行一次函数。

Go 截取视频某一帧图片

Sat, 28 May 2022 22:28:19 +0800

前言

最近遇到一个需求，需要截取视频的某一帧图片作为视频封面。我搜寻了相关资料，在 go 语言端常见的有两种做法，1）使用 opencv 的 go 绑定库，2）使用 ffmpeg 的 go 绑定库。

这里我打算使用第二种方法，使用 ffmpeg 的 go 绑定库。

ffmpeg 介绍

FFmpeg 是一个开源免费跨平台的视频和音频流方案，属于自由软件，采用 LGPL 或 GPL 许可证（依据你选择的组件）。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库 libavcodec，为了保证高可移植性和编解码质量，libavcodec 里很多 codec 都是从头开发的。

FFmpeg 在 Linux 平台下开发，但它同样也可以在其它操作系统环境中编译运行，包括 Windows、Mac OS X 等。

FFmpeg 项目由以下几部分组成:

FFMpeg 视频文件转换命令行工具，也支持经过实时电视卡抓取和编码成视频文件。

FFServer 基于 HTTP(RTSP 正在开发中) 用于实时广播的多媒体服务器，也支持时间平移.

FFplay 用 SDL 和 FFmpeg 库开发的一个简单的媒体播放器.

libavcodec 一个包含了所有 FFmpeg 音视频编解码器的库。为了保证最优性能和高可复用性，大多数编解码器从头开发的.

libavformat 一个包含了所有的普通音视格式的解析器和产生器的库

解决

1 安装 ffmpeg

浏览器访问 https://ffbinaries.com/downloads 根据你的系统安装 ffmpeg

2 安装 ffmpeg 的 go 绑定库

Go errgroup

Sat, 21 May 2022 22:13:36 +0800

我们知道在 go 语言中很容易开启携程进行并发任务，但是如何处理并发过程中的错误是非常棘手的，接下来我就来介绍 errgroup 的用法。

errgroup

errgroup 包里主要是一个结构体和相应的方法，它可以让你在并发任务中处理错误。

type Group struct {
    // context 的 cancel 方法
	cancel func()
	// 复用 WaitGroup
	wg sync.WaitGroup

	sem chan token
	
	// 用来保证只会接受一次错误
	errOnce sync.Once
	
	// 保存第一个返回的错误
	err     error
}
func WithContext(ctx context.Context) (*Group, context.Context)
func (g *Group) done()
func (g *Group) Wait() error
func (g *Group) Go(f func() error)
func (g *Group) TryGo(f func() error) bool
func (g *Group) SetLimit(n int)

通过 WithContext 可以创建一个可以取消的 Group，当然除此之外也可以零值的 Group 也可以直接使用，但是出错之后就不会取消其他的 goroutine 了。Go 方法传入一个函数参数，会启动一个 goroutine 处理。

Wait 类似 WaitGroup 的 Wait 方法，等待所有的 goroutine 结束后退出，返回的错误是一个出错的 err。

TryGo 是和 SetLimit 配套的，只有当 group 中的 goroutines 数量小于配置的数量时，才会在 goroutine 中调用函数。TryGo 用来判断 goroutine 是否启动。

应用内存升高原因排查

Sat, 14 May 2022 15:50:16 +0800

起因

最近一个部署了 go 应用的服务器出现了 OOM 的现象，内存占用过高。

原因

通过 Pyroscope 分析得出是因为 Minio 的 go sdk 中的 PutObject 函数占用了大量的内存。Pyroscope 是什么，前面的文章已经介绍过了，这里就不过多介绍了。

接下来我们通过查看相关的源码来查看是什么原因。

// PutObject creates an object in a bucket.
//
// You must have WRITE permissions on a bucket to create an object.
//
//  - For size smaller than 16MiB PutObject automatically does a
//    single atomic PUT operation.
//
//  - For size larger than 16MiB PutObject automatically does a
//    multipart upload operation.
//
//  - For size input as -1 PutObject does a multipart Put operation
//    until input stream reaches EOF. Maximum object size that can
//    be uploaded through this operation will be 5TiB.
//
//    WARNING: Passing down '-1' will use memory and these cannot
//    be reused for best outcomes for PutObject(), pass the size always.
//
// NOTE: Upon errors during upload multipart operation is entirely aborted.
func (c *Client) PutObject(ctx context.Context, bucketName, objectName string, reader io.Reader, objectSize int64,
	opts PutObjectOptions,
) (info UploadInfo, err error) {
	if objectSize < 0 && opts.DisableMultipart {
		return UploadInfo{}, errors.New("object size must be provided with disable multipart upload")
	}

	err = opts.validate()
	if err != nil {
		return UploadInfo{}, err
	}

	return c.putObjectCommon(ctx, bucketName, objectName, reader, objectSize, opts)
}

从方法的注释可以看出，当传递的大小为 -1 时，会进行多次 put 操作，直到输入流结束。多次 put 操作的最大大小为 5TiB，并且不能重用内存，导致占用大量内存。

多平台博客发布工具 openwrite 使用

Sat, 07 May 2022 21:47:52 +0800

介绍

OpenWrite 是一款便捷的多平台博客发布工具，可以在 OpenWrite 编写 markdown 文档，然后发布到其他博客平台，目前已经支持 CSDN、SegmentFault、掘金、博客园、简书等知名平台。

使用

注册

进入 http://admin.openwrite.cn/, 注册并登陆账号。

安装浏览器插件

第一步需要安装浏览器插件，根据这个链接教程安装，只有安装了插件，才能配置分发的平台。根据对插件的源码的分析，插件是通过 cookie、storage 等浏览器数据进行认证登陆的。此插件还包括模拟写作和 mackdown 编辑器。

认证配置渠道

安装完插件后，点击渠道管理，可以看到可配置的平台，支持多个平台。相应的平台如果没有登陆则显示未登陆，这时需要你登陆相应的平台。登陆平台后，点击认证，即可配置渠道。

这里以掘金为例，认证成功后，可以进行相应的配置，配置文章分类和标题。

发布文章

点击文章管理界面，添加文章，添加文章后，可以选择配置的平台，并发布到相应的平台。

普通用户一个月只有 10 次机会，一个平台占用一次机会。

Buf 初入门 2

Wed, 04 May 2022 19:19:58 +0800

上文讲了 Buf lint 命令的基础方法，本文将介绍 Buf lint 命令的一些常用配置。

如果你的项目中没有 buf.yaml 配置文件，Buf lint 会提供一个默认的配置文件，默认内容如下：

version: v1
lint:
  use:
    - DEFAULT
  except:
    - FILE_LOWER_SNAKE_CASE
  ignore:
    - bat
    - ban/ban.proto
  ignore_only:
    ENUM_PASCAL_CASE:
      - foo/foo.proto
      - bar
    BASIC:
      - foo
  enum_zero_value_suffix: _UNSPECIFIED
  rpc_allow_same_request_response: false
  rpc_allow_google_protobuf_empty_requests: false
  rpc_allow_google_protobuf_empty_responses: false
  service_suffix: Service
  allow_comment_ignores: true

配置选项

接下来开始介绍 Buf lint 命令的配置选项。

use

use 选项配置 lint 的类别，不同类别有相应的规则，有多种类别：DEFAULT、FILE_LOWER_SNAKE_CASE、BASIC 等。默认是 DEFAULT 类别。

except

except 选项配置 lint 不使用的类别。

下面的配置，显示使用 DEFAULT 类别，但是不使用 ENUM_NO_ALLOW_ALIAS ,BASIC 类别中的规则。

version: v1
lint:
  use:
    - DEFAULT
  except:
    - ENUM_NO_ALLOW_ALIAS
    - BASIC

ignore

ignore 选项指定忽略的文件，可以是文件名，也可以是目录，注意路径是要相对于 buf.yaml 文件的。

Buf 初入门 1

Sat, 23 Apr 2022 19:25:43 +0800

Buf 的目标是将 API 开发转向模式驱动的范式，从而为未来铺平道路，使 API 以服务所有者和客户可以依赖的方式定义。

与简单地暴露 REST/JSON 服务相比，使用 IDL 来定义 API 有很多好处，今天，Protobuf 是业界最稳定、最广泛采用的 IDL。但就目前的情况来看，使用 Protobuf 比使用 JSON 作为数据传输格式要困难得多。

Buf 正在建立工具，使 Protobuf 对服务所有者和客户来说是可靠和友好的，同时保持它在技术上的明显优势。您的组织不需要重新发明轮子来高效地创建、维护和使用 Protobuf API。我们将为您处理您的 Protobuf 管理策略，因此您可以专注于重要的事情。

本篇文章是讲述 buf 使用的第一篇文章，主要讲解使用 buf 定义 proto 文件的 lint 规则。统一的 lint 规则，可以让个人或团队定义的 API 保持一致。

lint

1 创建 buf.yaml 文件使用 buf mod init 命令创建 buf.yaml 文件。

version: v1
breaking:
  use:
    - FILE
lint:
  use:
    - DEFAULT

使用默认 lint 规则。

2 运行 lint 命令

使用 buf lint 命令运行 lint。

Go 统计代码测试覆盖率

Sat, 16 Apr 2022 22:08:49 +0800

今天来讲一讲如何统计 go 代码的测试覆盖率，主要是 cover 命令。

cover 基本用法

1 先简单写个函数和相应的测试，代码如下：

func Max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

这个函数就是简单的比较大小，如果 a > b，返回 a，否则返回 b。

测试代码如下

package main

import "testing"

func TestMax(t *testing.T) {
	type args struct {
		a int
		b int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{
			name: "a is larger than b",
			args: args{
				a: 2,
				b: 1,
			},
			want: 2,
		},
		{
			name: "b is larger than a",
			args: args{
				a: 1,
				b: 2,
			},
			want: 2,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := Max(tt.args.a, tt.args.b); got != tt.want {
				t.Errorf("Max() = %v, want %v", got, tt.want)
			}
		})
	}
}

2 go test -cover 能够统计出代码测试的覆盖率，这是一种比统计函数是否被调用更强悍的手法。我们执行这个命令。输出如下：

Kswapd0 is consuming a lot of CPU.

Sat, 09 Apr 2022 16:17:19 +0800

Issue

Recently, a Linux server has been experiencing high CPU usage, causing the server to become unresponsive and other processes to fail to execute smoothly. By using the top command to check resource usage, it can be seen that the kswapd0 process is consuming a large amount of CPU resources.

Cause and solution

Based on my research, the kswapd0 process is responsible for managing virtual memory.

Typically, a Linux system comprises RAM, swap, and EXT4 components. The EXT4 partition is used to store regular files and can be created on either an HDD or an SSD, though it is relatively slower compared to RAM. RAM, commonly referred to as memory, is used for high-speed program execution. The swap partition, on the other hand, is used as additional virtual memory and is normally allocated on physical disks, especially on machines with limited physical RAM.

Kswapd0 消耗大量 cpu

Sat, 09 Apr 2022 16:17:19 +0800

最近一台 Linux 服务器经常出现 cpu 过高，导致服务器卡顿，其他进程不能顺利进行。通过 top 命令查看资源的占用情况，可以看到 Kswapd0 进程消耗了大量的 cpu 资源。

Postgresql 修改序列产生器

Wed, 06 Apr 2022 17:49:03 +0800

问题

在我日常使用 PostgreSQL 数据库过程中，会遇到一个问题：我在重新创建一个数据库表时，往往会导入已有的数据，这样会导致新增表数据时，由于 id 采用了自增，会从 1 开始生成，然后由于已有数据的缘故，所以会导致 id 重复报错。

解决

查看了 stackoverflow 的一些回答，发现了一个解决方案：采用 ALTER SEQUENCE 语句进行修改。

ALTER SEQUENCE

ALTER SEQUENCE — 更改序列生成器的定义

语法：

ALTER SEQUENCE [ IF EXISTS ] name
    [ AS data_type ]
    [ INCREMENT [ BY ] increment ]
    [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
    [ START [ WITH ] start ]
    [ RESTART [ [ WITH ] restart ] ]
    [ CACHE cache ] [ [ NO ] CYCLE ]
    [ OWNED BY { table_name.column_name | NONE } ]
ALTER SEQUENCE [ IF EXISTS ] name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
ALTER SEQUENCE [ IF EXISTS ] name RENAME TO new_name
ALTER SEQUENCE [ IF EXISTS ] name SET SCHEMA new_schema

参数：

Kratos 业务状态码和 HTTP 状态码分离

Sun, 27 Mar 2022 12:30:30 +0800

起因

在我们使用 kratos 开发 web 应用时，由于 kratos 默认设计导致我们在自定义错误时，访问 api 时，相应的状态码是以自定义的 error code 作为 http status code 表现的。

如果我们想将业务状态码和 HTTP 状态码分离，即所有的 http status code 都为 200，实际的业务状态码以在 response 中响应的 code 为主。

我们该如何实现呢？有 2 种方法，一种是自定义中间件将错误进行特别处理，另一种是自定义 Encoder。本篇文章主要就是介绍 Encoder 方法。

自定义 Encoder

根据我们的需要，我们需要自定义 2 个 Encoder, ErrorEncoder 和 ResponseEncoder 函数。需要的参数类型分别如下：

// ResponseEncoder with response encoder.
func ResponseEncoder(en EncodeResponseFunc) ServerOption {
    return func(o *Server) {
        o.enc = en
	}
}

// ErrorEncoder with error encoder.
func ErrorEncoder(en EncodeErrorFunc) ServerOption {
    return func(o *Server) {
        o.ene = en
    }
}
// EncodeResponseFunc is encode response func.
type EncodeResponseFunc func(http.ResponseWriter, *http.Request, interface{}) error

// EncodeErrorFunc is encode error func.
type EncodeErrorFunc func(http.ResponseWriter, *http.Request, error)

1 自定义 Response 结构定义一个 Response 的结构体

Apisix 使用 authing 进行认证登陆

Sat, 19 Mar 2022 19:13:54 +0800

本文介绍 apisix 和 authing 对接进行 api 登陆验证的方式。

apisix 介绍

Apache APISIX 是一个动态、实时、高性能的 API 网关，提供负载均衡、动态上游、灰度发布、服务熔断、身份认证、可观测性等丰富的流量管理功能。Apache APISIX 不仅支持插件动态变更和热插拔，而且拥有众多实用的插件。Apache APISIX 的 OpenID Connect 插件支持 OpenID Connect 协议，用户可以使用该插件让 Apache APISIX 对接 Authing 服务，作为集中式认证网关部署于企业中。

authing 介绍

Authing 是国内首款以开发者为中心的全场景身份云产品，集成了所有主流身份认证协议，为企业和开发者提供完善安全的用户认证和访问管理服务。其主要功能包括：单点登录、用户分析、扫码登录、多因素认证、行为审计、风险控制、跨平台设备管理、IoT 身份认证等；兼容国际各类标准协议：OAuth2.0、OIDC、SAML、AD/LDAP、WS-Fed、JWT 等；此外还有基于函数计算可以无限制拓展 Authing 能力的 Pipeline。支持云交付和私有化部署方式，帮助企业和开发者提升生产效率。

apisix 和 authing 对接

1 登录 Authing 账号，选择自建用户应用，输入应用名称和认证地址

2 设置登陆回调 URL 和登出回调 URL 为你的 apisix 访问地址 http://127.0.0.1:9080/

3 在用户管理界面创建一个新用户，账号密码都是 user1/user1

4 在应用的配置里记录下应用的 App ID、App Secret、服务发现地址这些信息会在 apisix 配置插件时使用。

5 安装 apisix, 具体的安装步骤就不用我们讲了，可以参考官方文档。

Google_OAuth2 实践

Sun, 13 Mar 2022 12:56:02 +0800

本篇文章主要介绍了 OAuth2.0 和使用 Google 的 OAuth2.0 登录方式。

OAuth2.0 介绍

OAuth 2.0 是 OAuth 协议的下一版本，但不向下兼容 OAuth 1.0。OAuth 2.0 关注客户端开发者的简易性，同时为 Web 应用、桌面应用、手机和智能设备提供专门的认证流程。

Facebook 的新的 Graph API 只支持 OAuth 2.0，Google 在 2011 年 3 月也宣布 Google API 对 OAuth 2.0 的支持，Windows Live 也支持 OAuth 2.0。

在认证和授权的过程中涉及的三方包括： 1、服务提供方，用户使用服务提供方来存储受保护的资源，如照片，视频，联系人列表。 2、用户，存放在服务提供方的受保护的资源的拥有者。 3、客户端，要访问服务提供方资源的第三方应用，通常是网站，如提供照片打印服务的网站。在认证过程之前，客户端要向服务提供者申请客户端标识。

使用 OAuth 进行认证和授权的过程如下所示：

（A）用户打开客户端以后，客户端要求用户给予授权。（B）用户同意给予客户端授权。（C）客户端使用上一步获得的授权，向认证服务器申请令牌。（D）认证服务器对客户端进行认证以后，确认无误，同意发放令牌。（E）客户端使用令牌，向资源服务器申请获取资源。（F）资源服务器确认令牌无误，同意向客户端开放资源

Google 的 OAuth2.0 登录方式

1 进入 Google Cloud Platform 创建一个项目

2 进入 API 与服务界面，选择凭据管理，点击创建凭据，选择 OAuth 2.0 客户端 ID

Go 模糊测试

Sun, 06 Mar 2022 10:47:15 +0800

本篇文章主要讲解在 go 语言中进行模糊测试的基础知识。通过模糊测试，随机数据会针对您的测试运行，以尝试找出漏洞或导致崩溃的输入。可以通过模糊测试发现的一些漏洞示例包括 SQL 注入、buffer overflow、拒绝服务和 cross-site scripting 攻击。

想要在 go 中使用模糊测试，需要安装 go1.18beta1 以上版本，具体的安装就不过多叙述了。

1 创建项目文件夹

我们创建一个名叫 fuzz-demo 的文件夹，并在其中创建一个名叫 main.go 的文件。

2 输入代码

在 main.go 中输入如下代码：

package main

import "fmt"

func Reverse(s string) string {
	b := []byte(s)
	for i, j := 0, len(b)-1; i < len(b)/2; i, j = i+1, j-1 {
		b[i], b[j] = b[j], b[i]
	}
	return string(b)
}
func main() {
	input := "quick quick brown fox jumped over the lazy dog"
	rev := Reverse(input)
	doubleRev := Reverse(rev)
	fmt.Printf("原来: %q\n", input)
	fmt.Printf("反转: %q\n", rev)
	fmt.Printf("再反转: %q\n", doubleRev)
}

Reverse 函数的作用就是对字符串进行反转。

Pyroscope 持续分析平台

Sat, 26 Feb 2022 19:37:46 +0800

什么是 Pyroscope?

Pyroscope 是一个开源的持续分析系统，使用 Go 语言实现。服务端使用 web 页面查看，提供丰富的分析的功能，客户端提供 Go、Java、Python、Ruby、PHP、.NET 等多种语言的支持，并且支持 PUSH、PULL 两种采集方式。

Pyroscope 是一个开源的持续性能剖析平台。它能够帮你：

找出源代码中的性能问题和瓶颈
解决 CPU 利用率高的问题
理解应用程序的调用树（call tree）
追踪随一段时间内变化的情况

特性：

可以存储来自多个应用程序的多年剖析数据
你可以一次查看多年的数据或单独查看特定的事件
较低的 CPU 开销
数据压缩效率高，磁盘空间要求低
快捷的 UI 界面

部署架构图：

Pyroscope server 安装

Pyroscope server 端可以通过 docker 安装：

docker run -it -p 4040:4040 pyroscope/pyroscope:latest server

也可以在各中操作系统中直接安装。

比如 Mac:

brew install pyroscope-io/brew/pyroscope
brew services start pyroscope-server

各 Liunx 发行版也方便安装

比如 ubuntu:

wget https://dl.pyroscope.io/release/pyroscope_0.10.2_amd64.deb
sudo apt-get install ./pyroscope_0.10.2_amd64.deb

安装完成后，就可以通过 web 界面访问了：http://localhost:4040, 你可以通过配置文件更改监听端口以及其它一些配置项。

Fsck

Sat, 19 Feb 2022 21:57:10 +0800

起因

在一次使用虚拟机的时候，发现 Linux 系统进入了 Initramfs，无法正常进入系统，推测可能是系统异常关机导致磁盘文件损坏导致的。

解决

网上搜寻了一些解决方法，普遍的推荐方法是使用 Linux 命令 fsck 命令来修复磁盘文件。

费了好大劲进入另一个系统使用 fsck.ext4 -f /dev/sda1 来检查修复磁盘文件 (我所使用的 linux 系统磁盘是 ext4 格式的)。

接下来我来介绍下 fsck 的使用。

fsck

fsck（file system consistency check）是 Unix 和类 Unix 系统上用于检查文件系统完整性的工具。

语法：fsck [选项] [文件系统]

常见参数：

 -f          强制检查文件系统，不管是否有损坏

 -p          自动修复文件系统错误

 -q          做一个快速检查，以确定文件系统是否被干净地卸载。

 -y          关闭互动模式，询问全部选择 y

参考

GRPC 单向安全连接

Sat, 12 Feb 2022 22:01:09 +0800

从本篇开始，我将介绍加强 gRPC 的安全性的一系列措施。本篇介绍使用 TLS 加密 gRPC 通信的第一篇文章：gRPC 单向安全连接。

TLS 协议介绍

传输层安全性协议（英语：Transport Layer Security，缩写作 TLS），及其前身安全套接层（Secure Sockets Layer，缩写作 SSL）是一种安全协议，目的是为互联网通信提供安全及数据完整性保障。网景公司（Netscape）在 1994 年推出首版网页浏览器，网景导航者时，推出 HTTPS 协议，以 SSL 进行加密，这是 SSL 的起源。IETF 将 SSL 进行标准化，1999 年公布第一版 TLS 标准文件。随后又公布 RFC 5246（2008 年 8 月）与 RFC 6176（2011 年 3 月）。在浏览器、邮箱、即时通信、VoIP、网络传真等应用程序中，广泛支持这个协议。主要的网站，如 Google、Facebook 等也以这个协议来创建安全连线，发送数据。目前已成为互联网上保密通信的工业标准。

SSL 包含记录层（Record Layer）和传输层，记录层协议确定传输层数据的封装格式。传输层安全协议使用 X.509 认证，之后利用非对称加密演算来对通信方做身份认证，之后交换对称密钥作为会谈密钥（Session key）。这个会谈密钥是用来将通信两方交换的数据做加密，保证两个应用间通信的保密性和可靠性，使客户与服务器应用之间的通信不被攻击者窃听。

单向安全连接

通过安全的连接进行传输数据非常重要，那么如何在 gRPC 中使用 TLS 保护 gRPC 通信呢？TLS 认证机制集成在了 gRPC 库中，这使得 gRPC 可以很方便使用 TLS 进行安全连接。客户端和服务端之间的安全传输可以采用单向或双向的方式来实现。本文主要介绍 单向安全连接。

在单向安全连接中，只有客户端会校验服务端，以确保它所接收的数据来自预期的服务器，在建立连接时，服务端会与客户端共享其公开证书，客户端会校验收到的证书。这是通过证书授权中心完成的。证书校验完成后，客户端会使用密钥加密数据。

要启用 TLS，需要证书和密钥 (xx.key,xx.pem/xx.crt),前者是用于签名和扔着公钥，后者用于分发自签名 X.509 公钥。证书和密钥的生成这里就不过多介绍了，需要的可以自行了解。

Log_and_trace

Thu, 27 Jan 2022 17:59:52 +0800

本篇文章讲述了如何将 loki 和 tempo 结合进行分布式追踪。日志和 trace 结合使用的方案有很多，由于 loki 官方自带了 trace 结合的配置，不用进行过多的二次开发，所以这里采用 loki 和 tempo 结合的方案。

loki 和 tempo 是什么就不过多介绍，安装流程也省略。这里主要讲如何配置。

配置

这里我们采用普遍的方案，使用 grafana 来展示日志和 trace。

配置 loki

在 grafana , 打开数据源配置界面，新建 loki 数据源，并且配置好地址，如下图所示点击 Save & Test, 如果配置正确，则会出现 Data source connected and labels found. 标志。

配置 tempo

同配置 loki 一致，新建 grafana 数据源，选择 tempo，配置好相应的 url 数据，点击测试，出现 Data source connected and labels found. 标志，就表示配置成功。

在 tempo 配置页面的底部可以看到一个配置栏目 Trace to logs，可以选择相应的日志数据源，这里我们选择 loki.

K8s_Finalizers

Sun, 23 Jan 2022 11:21:44 +0800

起因

在我们日常使用 k8s 中，可能会遇到这样的情况：在删除 namespace 时，往往会遇到资源没有被删除的情况，资源处于 terminating 的状态，这时我们该如何解决了，寻找到的解决方法往往是如下：

1 运行以下命令查看处于 terminating 状态的资源 (这里以 namespace 为例):

kubectl get namespaces

2 选择一个 Terminating namespace，并查看 namespace 中的 finalizer。运行以下命令：

kubectl get namespace <terminating-namespace> -o yaml

得到类似这样的信息：

apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: "2021-01-20T15:18:06Z"
  deletionTimestamp: "2021-01-21T02:50:02Z"
  name: <terminating-namespace>
  resourceVersion: "3249493"
  selfLink: /api/v1/namespaces/knative-eventing
  uid: f300ea38-c8c2-4653-b432-b66103e412db
spec:
  finalizers:
  - kubernetes
status:
  phase: Terminating

3 导出 json 格式到 tmp.json:

Casbin 学习 1

Wed, 12 Jan 2022 17:00:39 +0800

从本篇文章开始，将由我来开始介绍访问控制框架的基础知识，本篇文章是 casbin 系列文章的第一篇，主要介绍一些 casbin 的概念和基础知识。

概述

casbin 是一个开源的访问控制框架，它的目标是让开发人员可以更加简单的控制访问控制，支持多种访问控制模型，支持多种编程语言 (各种编程语言支持的程度可以查看官网的文档)。

casbin 可以

支持自定义请求的格式，默认的请求格式为{subject, object, action}。
具有访问控制模型 model 和策略 policy 两个核心概念。
支持 RBAC 中的多层角色继承，不止主体可以有角色，资源也可以具有角色。
支持内置的超级用户例如：root 或 administrator。超级用户可以执行任何操作而无需显式的权限声明。
支持多种内置的操作符，如 keyMatch，方便对路径式的资源进行管理，如 /foo/bar 可以映射到 /foo*

Casbin 不支持的是：

身份认证 authentication（即验证用户的用户名和密码），Casbin 只负责访问控制。应该有其他专门的组件负责身份认证，然后由 Casbin 进行访问控制，二者是相互配合的关系。
管理用户列表或角色列表。Casbin 认为由项目自身来管理用户、角色列表更为合适，用户通常有他们的密码，但是 Casbin 的设计思想并不是把它作为一个存储密码的容器。而是存储 RBAC 方案中用户和角色之间的映射关系。

工作原理

在 Casbin 中，访问控制模型被抽象为基于 PERM (Policy, Effect, Request, Matcher) 的一个文件。因此，切换或升级项目的授权机制与修改配置一样简单。您可以通过组合可用的模型来定制您自己的访问控制模型。例如，您可以在一个 model 中结合 RBAC 角色和 ABAC 属性，并共享一组 policy 规则。

adapters

在 Casbin 中，策略存储作为 adapter(Casbin 的中间件) 实现。Casbin 用户可以使用 adapter 从存储中加载策略规则 (aka LoadPolicy()) 或者将策略规则保存到其中 (aka SavePolicy())。为了保持代码轻量级，我们没有把 adapter 代码放在主库中。

Go 如何使用私有仓库模块

Wed, 12 Jan 2022 15:08:07 +0800

今天我来讲一讲在 golang 中如何在项目中引用私有仓库吧，在我们的实际生产开发中，往往需要在项目中引用内部代码管理平台上的仓库代码，接下来我来介绍如何在 golang 中使用私有仓库模块。

设置

1 我们的私有代码往往存储在内部的代码管理平台 (如 gitlab, gittee 等) 上，假设我们的地址是 git.xx.vip. 接下来开始设置一些配置项。

2 设置 GOPRIVATE 变量。

我们先设置 GOPRIVATE 环境变量，GOPRIVATE 会将 GOPRIVATE 变量值所匹配的路径前缀视为私有模块，就不会使用代理和进行校验。设置了 GOPRIVATE 变量后，GONOPROXY 和 GONOSUMDB 环境变量也会接收同样的值。

3 设置 GOINSECURE 变量

我们的 gitlab 等代码管理平台往往没有使用 https 协议，所以我们需要设置 GOINSECURE 变量，GOINSECURE 变量中的值以逗号分隔，其中的每一个值在 go get 时不会进行 https 协议的校验，只会采用 http 协议。

4 go get

设置完以上步骤后，可以执行 go get 看看效果，具体命令： go get -v git.xx.vip/swords/xkratos

可以看到相应的库已经顺利拉取成功，并且输出了相应的版本信息

参考

GRPC 多路复用

Sun, 09 Jan 2022 15:10:42 +0800

今天来讲一讲 gRPC 的多路复用，gRPC 的多路复用是指一个 gRPC 服务器端可以运行多个 gRPC 服务，也允许多个客户端存根使用同一个 gRPC 客户端连接。

我们继续沿用前面的代码来讲解如何使用多路复用。

多个 gRPC 服务共享同一个服务器端

假如在订单服务中，为了管理的需求，需要在同一个服务端运行另一个 RPC 服务，这样客户端就能重用同一个连接，这样就可以按需调用相应的服务。通过相应的服务器端注册函数，可以使多个服务注册在同一个服务器端。

具体代码如下：

func main() {
    initSampleData()
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to isten: %v", err)
    }
    
    s := grpc.NewServer(grpc.UnaryInterceptor(orderUnaryServerInterceptor))
    ordermgt_pb.RegisterOrderManagementServer(s, &orderMgtServer{})
    user_pb.RegisterUserManagementServer(s, &userMgtServer{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

这样就是多个 gRPC 服务共享同一个服务端连接，这样就可以按需调用相应的服务。同理，通过客户端，可以在两个 gRPC 客户端存根间共享相同的 gRPC 客户端连接。

两个 gRPC 客户端存根共享同一个客户端连接

如代码所示，两个 gRPC 服务在同一个 gRPC 服务器端运行，所以可以创建一个 gRPC 连接，并在两个服务创建 gRPC 客户端实例时使用这个连接。

func main() {
    conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
    if err != nil {
     log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    client := pb.NewOrderManagementClient(conn)
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
    defer cancel()
    heclien := hwpb.NewGreetingClient(conn)

}

小结

在我们的日常使用中，通常不会出现两个服务间共享同一个服务器端连接的情况。

Trace_in_sql

Fri, 31 Dec 2021 20:33:55 +0800

使用分布式链路追踪查看 sql 的执行情况

今天我们来讲一讲如何在 go 语言中使用 OpenTelemetry 链路追踪追踪 sql 的执行情况 (执行时间、语句等)。

初始化

我们这里需要有一个采用了数据库的项目，为了使用方便，我们这里采用了 ent 来进行数据库的操作。

初始化数据库实体

为了演示方便，我们这里简单定义一个 user 实体，user 有 2 个成员字段 id 和 name。

$ ent init User

package schema

import (
	"entgo.io/ent"
	"entgo.io/ent/schema/field"
)

// User holds the schema definition for the User entity.
type User struct {
	ent.Schema
}

// Fields of the User.
func (User) Fields() []ent.Field {
	return []ent.Field{
		field.Int("id"),
		field.String("name"),
	}
}

// Edges of the User.
func (User) Edges() []ent.Edge {
	return nil
}

执行 go run -mod=mod entgo.io/ent/cmd/ent generate ./schema,就会生成一系列的文件。

GRPC 元数据

Sat, 25 Dec 2021 20:22:40 +0800

今天我来讲一讲 gRPC 元数据的使用，以及如何获取元数据。gRPC 应用程序通常会通过 gRPC 服务和消费者之间的 RPC 来共享信息。在大多数场景中，某些与服务端业务逻辑相关的信息会作为远程调用方法的参数，但在某些场景可能存在与服务端业务上下文无关的数据，这些数据不应该通过参数来传递，而应该通过 gRPC 元数据来处理传递。元数据的结构构造是 K-V 形式，其中 k 为字符串，v 为任意类型。

接下来就介绍如何在客户端和服务端之间使用元数据来传递数据。

创建和查询元数据

在 gRPC 应用程序中，创建元数据非常简单，在 go 语言中有两种方式创建元数据：1) 通过 metadata.New(map[string]string{“key1”:“val1”}) 函数创建；2) 通过 metadata.Pairs 来创建元数据对，相同的 key 会被合并为切片数组。

    md := metadata.New(map[string]string{"foo": "bar"})
md := metadata.Pairs(
"key1", "value1",
"key2", "value2",
)

二进制数据也可以设置为元数据值，以元数据值形式所设置的二进制数据在发送前都会进行 base4 编码，在传输过程中会被解码。

在客户端或服务端读取元数据，可以通过传入的 RPC 上下文和 metadata.FromIncomingContext 函数来获取元数据。

    md, metadataAvailble := metadata.FromIncomingContext(ctx)

接下来讲解客户端和服务端如何发送和接受元数据。

客户端发送接收元数据

在客户端，要发送元数据，可以创建元数据并将其设置到 RPC 上下文中。在 go 语言中有两种方式实现，可以使用 NewOutgoingContext 函数创建，也可以使用 AppendToOutgoingContext 函数来将元数据附加到 RPC 上下文中，使用 NewOutgoingContext 会替换掉上下文中已有的元数据。在创建完带有元数据的上下文后，就可以用于 RPC 中了。在上下文中设置的元数据会转换成 header 信息。

// 客户端发送元数据
// ****** Metadata : Creation *****

    md := metadata.Pairs(
    "timestamp", time.Now().Format(time.StampNano),
    "kn", "vn",
    )
    mdCtx := metadata.NewOutgoingContext(context.Background(), md)

    ctxA := metadata.AppendToOutgoingContext(mdCtx, "k1", "v1", "k1", "v2", "k2", "v3")

    // Search Order
    searchStream, _ := client.SearchOrders(ctxA, &wrapper.StringValue{Value: "Google"})
    for {
        searchOrder, err := searchStream.Recv()
        if err == io.EOF {
            log.Print("EOF")
            break
        }

        if err == nil {
            log.Print("Search Result : ", searchOrder)
        }
    }

// 在 gRPC 中接受元数据
    var header,trailer metadata.MD
   r,err := client.SomeRPC(
	   ctx,
	   someReq,
	   grpc.Header(&header),
	   grpc.Trailer(trailer),
    )
   stream, err := client.SomeStreamingRPC(ctx)
   
   header, err := stream.Header()
   
   trailer := stream.Trailer()

从对应的 RPC 获取到值时，就可以像处理 map 一样进行，对元数据进行相应处理。

Golang 多版本共存

Sat, 18 Dec 2021 22:25:23 +0800

为什么要使用多个 go 版本

在我们的日常项目开发中，我们可能会使用多个不同的版本的 go 语言，来进行应用的测试，因为不同的版本有着不同的性能优化，可以通过对不同版本情况的测试，选择线上使用的版本。

如何安装多个 go 版本

可能会有人说，可以通过多个不同的 go 安装包来安装，这种方法是可行的，但 go 官方提供了另一种方法来方便安装。

1 使用 go install 命令安装相应版本的 go , 例如：

 go install golang.org/dl/go1.18.0beta1@latest

2 使用相应命令下载，例如我前面安装的是 go1.18.0beta1，那就使用 go1.18.0beta1 download 下载。

3 下载完毕可以使用对应的版本测试，例如：go1.18.0beta1 version

参考

https://go.dev/doc/manage-install

GRPC 错误处理

Sat, 18 Dec 2021 21:45:16 +0800

今天来讲一讲 gRPC 错误处理的方式，以及如何自定义错误处理。当发起 gRPC 调用时，客户端会接受成功状态的响应或带有错误信息状态的错误响应。考虑程序的健壮性，我们需要在编写客户端处理信息时，要处理所有可能的错误。编写服务端代码也要处理错误，并构建合适的错误状态码。

当 gRPC 发生错误时，会返回一个错误码。并附带一条可选的信息，错误状态信息由一个整形状态码和一条字符串消息组成，适用于不同的语言实现。

下图展示了 gRPC 内置的错误码：

缺陷

gRPC 提供的错误模型非常有限，并且与底层的数据格式无关，最常用的数据格式就是 protocol buffers。如果使用了 protocol buffers，google.rpc 提供了更丰富的错误模型，但语言兼容性待测试。

错误处理例子

接下来继续沿用前面的代码，来讲解如何运用错误处理。假如我们需要在订单添加处理中处理非法 ID 请求。如果我们传了一个不合法的 ID 如 -1，需要返回错误给客户端消费者。

func (s *server) AddOrder(ctx context.Context, orderReq *pb.Order) (*wrappers.StringValue, error) {
	if orderReq.Id == "-1" {
		log.Printf("Order ID is vaild : %s", orderReq.Id)

		errorStatus := status.New(codes.InvalidArgument, "Order ID is not valid")
		ds, err := errorStatus.WithDetails(
			&epb.BadRequest_FieldViolation{
				Field:       "ID",
				Description: fmt.Sprintf("Order ID received is not valid %s : %s", orderReq.Id, orderReq.Description),
			},
		)
		if err != nil {
			return nil, errorStatus.Err()
		}

		return nil, ds.Err()
	}
	orderMap[orderReq.Id] = *orderReq
	log.Println("Order : ", orderReq.Id, " -> Added")
	return &wrapper.StringValue{Value: "Order Added: " + orderReq.Id}, nil
}

通过 status 包可以很方便的创建所需的错误码和相应错误详情。使用 Google API 的相应包可以设置更丰富的错误详情。

GRPC 拦截器

Sat, 11 Dec 2021 22:21:23 +0800

本篇文章我来介绍一下 gRPC 拦截器的使用，拦截器主要用于在服务器端和客户端拦截 RPC.

拦截器可以在 gRPC 中拦截 RPC 的执行，来满足一些特殊的需求，如日志，认证，访问控制等。gRPC 提供了简单的接口，用来在客户端和服务端的 gRPC 协议中添加拦截器。

根据所使用的 gRPC 通信模式的不同，主要分为 2 种拦截器：1）一元拦截器，2）流拦截器。既可以在客户端使用拦截器，也可以在服务端使用拦截器。

接下来，我会依次介绍在服务端和客户端的使用。

服务端拦截器

当客户端调用 gRPC 的远程调用方法时，可以通过服务端拦截器，在执行一些方法前，执行一些通用的操作。如果希望在 Rpc 服务中添加服务端拦截器，只需实现该拦截器，并在创建服务端时注册进来。

下面依次介绍两种服务端拦截器：1）一元拦截器，2）流拦截器。

一元拦截器

如果想在服务端拦截一元 RPC 调用时，需要在服务端实现相应的函数，此函数的签名为：

type UnaryServerInterceptor func(ctx context.Context, req interface{}, info *UnaryServerInfo, handler UnaryHandler) (resp interface{}, err error)

我们在上一篇文章的代码中添加如下代码：

func orderUnaryServerInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
	
	log.Println("======= [Server Interceptor] ", info.FullMethod)
	log.Printf(" Pre Proc Message : %s", req)

	m, err := handler(ctx, req)
	if err != nil {
		log.Printf("Error : %v", err)
	}
	log.Printf(" Post Proc Message : %s", m)
	return m, err
}
func main() {
    initSampleData()
    lis, err := net.Listen("tcp", port)
    if err != nil {
    log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer(grpc.UnaryInterceptor(orderUnaryServerInterceptor))
    pb.RegisterOrderManagementServer(s, &server{})
    // Register reflection service on gRPC server.
    // reflection.Register(s)
    if err := s.Serve(lis); err != nil {
    log.Fatalf("failed to serve: %v", err)
    }
}

一元拦截器的实现主要分为三个部分：前置处理、调用 RPC 服务、后置处理。在前置处理阶段可以通过检查参数获得 RPC 的信息，比如 RPC 上下文、请求和服务端信息。

GRPC 通信模式

Sat, 04 Dec 2021 19:53:43 +0800

在我们日常的客户端和服务端的通信中，往往是简单的请求 - 响应风格的通信，这里一个请求会得到一个响应。借助 gRPC，我们可以实现不同的进程间通信模式。

接下来就由我来介绍 gRPC 的 4 种通信模式：一元 RPC, 服务端流式 RPC, 客户端流式 RPC, 客户端流式 RPC（双向流式），并会带有一些简单的例子展示各种模式，在这里客户端和服务端都由 go 编写。

一元 RPC

我们先来介绍一元 RPC，这是一种单向通信，客户端调用服务端的远程方法时，客户端发送请求至服务端并获得一个响应。

假设我们现在需要构建一个商城系统，商城系统有一个订单服务，提供了根据订单号查询订单的功能。

下面来实现这个功能，先使用 protocol buffer 来定义服务，然后再使用 gRPC 实现一元 RPC。

syntax = "proto3";

import "google/protobuf/wrappers.proto";
service OrderManagement {
  rpc getOrder(google.protobuf.StringValue) returns (Order) {}
}

message Order{
  string id = 1;
  string desc = 2;
  float price = 3;
  string destination = 4;
  repeated string items = 5;
}

接下来编写相应的服务端实现代码：

func (s *server) GetOrder(ctx context.Context, orderId *wrapper.StringValue) (*pb.Order, error) {
ord, exists := orderMap[orderId.Value]
if exists {
return &ord, status.New(codes.OK, "").Err()
}

return nil, status.Errorf(codes.NotFound, "Order does not exist. : ", orderId)

}

由于只是简单的例子，所以使用了一个简单的 map 来存储订单信息，这里我们可以使用数据库来替代。

Go 常见 linter

Sun, 28 Nov 2021 13:37:30 +0800

静态分析是一种编译时的编译器检查，它可以检查代码的语法，语义，结构，等等，但是不能检查代码的运行时的错误。

静态分析一般会集成在项目上线的 Ci 流程中，如果过程中出现了错误，那么项目就不能上线，避免了有问题的代码被部署上线。

常见的 go linter

在 go 语言社区中，已经有了很多的 linter，这些 linter 可以帮助我们检查代码的语法，语义，结构等等，接下来我来介绍一些常见的 linter。

go lint

go lint 是 go 官方推出的最早的 linter, 它可以检查导出函数是否有注释，变量、函数等名称是否符合官方规范。随着近年来的发展，各种 linter 已经层出不穷了，go lint 已经被 deprecated and frozen 了，官方推荐使用 Staticcheck 和 go vet 等 linter。

go vet

go vet 也是官方提供的静态分析工具，其内置了锁拷贝检查、循环变量捕获问题、printf 参数不匹配等工具。比如下面的例子：

package main

import "sync"

func main() {
	var wg sync.WaitGroup
	for _, v := range []int{0,1,2,3} { 
		wg.Add(1)
		go func() {
			print(v)
			wg.Done()
		}()
	}
	wg.Wait()
}

执行 go vet 命令会提示相应错误，如下图所示：正确应该使用如下代码：

WebAssembly In Go

Sat, 27 Nov 2021 20:37:57 +0800

WebAssembly 介绍

Go 1.11 向 WebAssembly 添加了一个实验性端口。Go 1.12 对其某些部分进行了改进，预计 Go 1.13 会进一步改进。

简单入门

1 编写 main.go

package main

import "fmt"

func main() {
	fmt.Println("Hello, WebAssembly!")
}

2 使用命令编译

GOOS=js GOARCH=wasm go build -o main.wasm

这将生成一个可以在浏览器中运行的 WebAssembly 文件。

要在浏览器中执行 main.wasm，我们还需要一个 JavaScript 支持文件和一个 HTML 页面来将所有内容连接在一起。

3 复制 js 支持文件

cp "$(go env GOROOT)/misc/wasm/wasm_exec.js" .

4 创建 HTML 页面


<html>
<head>
    <meta charset="utf-8"/>
    <script src="wasm_exec.js"></script>
    <script>
        const go = new Go();
        WebAssembly.instantiateStreaming(fetch("main.wasm"), go.importObject).then((result) => {
            go.run(result.instance);
        });
    </script>
</head>
<body></body>
</html>

5 启动 web 服务器

Containerd 配置私有仓库

Fri, 19 Nov 2021 17:27:01 +0800

问题

今天在使用 K8S 部署应用时，遇到容器镜像拉取失败的错误 imagepullbackoff ，通过对应用整体资源清单的分析，发现是使用了使用私有仓库镜像，但是没有配置私有仓库，这样就会导致容器无法拉取镜像，这个问题可以通过配置私有仓库来解决。

由于我使用了 Containerd 容器管理器，所以我需要配置私有仓库，并且配置私有仓库的地址为：https://docker.xx.vip. Containerd 没有 docker 配置私有仓库方便，需要修改 Containerd 配置文件进行配置，配置文件在 /etc/containerd/config.toml 中。

配置私有仓库

Containerd 默认没有此配置文件，需要通过命令导出配置文件 containerd config default> /etc/containerd/config.toml (需要提前创建目录)。

接下来我来讲解如何配置私有镜像仓库。

打开配置文件
找到 [plugins.“io.containerd.grpc.v1.cri”.registry]
修改相应配置，具体配置如下：

 [plugins."io.containerd.grpc.v1.cri".registry]
[plugins."io.containerd.grpc.v1.cri".registry.mirrors]
[plugins."io.containerd.grpc.v1.cri".registry.mirrors."docker.xx.vip"]
endpoint = ["https://docker.xx.vip"]
[plugins."io.containerd.grpc.v1.cri".registry.auths]
[plugins."io.containerd.grpc.v1.cri".registry.configs]
[plugins."io.containerd.grpc.v1.cri".registry.configs."docker.xx.vip".auth]
username = "xx"
password = "xx"
[plugins."io.containerd.grpc.v1.cri".registry.headers]

重启 containerd systemctl restart containerd.service
查看 containerd systemctl status containerd.service
回到 K8S 重新拉取镜像，可以看到镜像已经顺利拉取

参考

容器出现时间异常问题及解决方法

Fri, 12 Nov 2021 09:33:31 +0800

问题

最近在使用 MinIO SDK 上传资源对象时，出现了一个问题：The difference between the request time and the server's time is too large. 从错误信息可以看出客户端上传资源的时间与 Minio server 的时间相差太大，导致资源上传失败。

解决

根据错误信息得出 server 端的时间出现异常，由于我采用容器部署的方式，因此可以先查看容器的时间是否正确。

进入 Minio 容器 , 执行命令：date, 可以看到如图结果 ( UTC 时间):

而目前的时间是 ( CST 时间) :

可以看出容器的时间与实际的时间相差太大，所以导致资源上传失败。

方法 1

出现了时间异常的问题，可能很多人第一反应就是调整容器的时间，通过 ntpdate 等工具调整时间，这种解决方法方法适用于非容器的 MinIO SERVER 环境调整时间，容器因为一些限制无法使用此方法。

方法 2

在网上查看了许多相关的问题，有了一个针对容器的解决方法，执行：

docker run --rm --privileged alpine hwclock -s

可以看到容器时间已经正常了：

我对这条命令不太明白，不明白为什么会影响到其它运行中的容器，可能是与 docker for win 的一些容器实现机制相关。

参考资料

Consul 学习

Sat, 06 Nov 2021 19:39:55 +0800

Consul 是一个全功能的服务网格解决方案，解决了操作微服务和云基础设施的网络和安全挑战。Consul 提供了一种软件驱动的路由和分段方法。它还带来了额外的好处，如故障处理、重试和网络可观察性。这些功能中的每一个都可以根据需要单独使用，也可以一起使用，建立一个完整的服务网格。

Consul 是一个分布式系统，旨在运行在一个节点集群上。一个节点可以是一个物理服务器、云实例、虚拟机或容器。连接在一起的 Consul 运行的节点集被称为数据中心。在数据中心内，Consul 可以以服务器或客户端两种模式运行。服务器代理维护 Consul 的一致状态。客户端是一个轻量级的进程，运行在每个运行服务的节点上。一个数据中心将有 3-5 个服务器和许多客户端。

安装 Consul

Consul 的安装就不多介绍了，具体可以看看官网的教程。

运行 Consul

由于我采用了本地安装的方式，我将以开发模式运行 Consul , 在实际生产中不要使用这种方法运行部署。

通过 consul agent -dev 在开发模式下启动 Consul 代理。

可以看到 consul 代理已经顺利启动。

通过 consul members 命令可以查看你的 consul 列表。

输出显示代理、它的 IP 地址、它的健康状态、它在数据中心中的角色以及一些版本信息。您可以通过提供 - 详细标志来发现其他元数据。

通过 members 命令查询的结果可能跟实际不太一样，通过 HTTP API 可以查询准确的结果 curl localhost:8500/v1/catalog/nodes。

使用命令 consul leave 可以停止 consul 代理。

注册服务

接下来介绍在 consul 注册一个服务。

Consul 的主要功能之一是服务发现。Consul 提供了一个 DNS 接口，下游服务可以用它来寻找其上游依赖的 IP 地址。

Kubernetes 安装 APISIX

Wed, 27 Oct 2021 10:23:33 +0800

今天介绍如何在 k8s 上安装 APISIX 相关组件 (Apache APISIX、Apache APISIX Dashboard、Apache APISIX Ingress Controller)。

Apache APISIX

由于 APISIX helm 组件将相关组件集合在一起了，所以只要装一个就好了。

安装步骤

前提要创建好相应的 PV .
命令

helm repo add apisix https://charts.apiseven.com
helm repo update
helm install apisix apisix/apisix --set gateway.type=NodePort --set ingress-controller.enabled=true --set dashboard.enabled=true --set etcd.volumePermissions.enabled=true   --namespace ingress-apisix

如果看到如下信息并且执行 kubectl get pods -n ingress-apisix 就表示 apisix 安装成功。

NNAME: apisix
LAST DEPLOYED: Wed Oct 27 03:00:23 2021
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
1. Get the application URL by running these commands:
  export NODE_PORT=$(kubectl get --namespace default -o jsonpath="{.spec.ports[0].nodePort}" services apisix-gateway)
  export NODE_IP=$(kubectl get nodes --namespace default -o jsonpath="{.items[0].status.addresses[0].address}")
  echo http://$NODE_IP:$NODE_PORT
  
  
NAME                                         READY   STATUS    RESTARTS   AGE
apisix-69459554d4-tc7sd                      1/1     Running   0          8m49s
apisix-etcd-0                                1/1     Running   0          8m49s
apisix-etcd-1                                1/1     Running   0          8m49s
apisix-etcd-2                                1/1     Running   0          5m16s
apisix-ingress-controller-678d8b5f6d-h6kq8   1/1     Running   0          8m49s

修改 apisix-dashboard service 的 spec.type 为 NodePort

安装过程的问题及解决

etcd pod 启动失败

2021-10-27 06:29:47.259764 C | etcdmain: cannot access data directory: mkdir /bitnami/etcd/data: permission denied

设置 Rancher 服务器的本地 Kubernetes 集群

Tue, 26 Oct 2021 15:32:15 +0800

本篇文章介绍如何在 k8s 集群上安装 rancher。

前提

需要安装 kubectl 和 helm。

安装 Rancher Helm Chart

添加 helm chart 仓库

使用 helm repo add rancher-<CHART_REPO> https://releases.rancher.com/server-charts/<CHART_REPO> 添加 helm 仓库。

请将命令中的<CHART_REPO>，替换为 latest，stable 或 alpha。更多信息，请查看选择 Rancher 版本来选择最适合您的仓库。

latest: 建议在尝试新功能时使用。

stable: 建议在生产环境中使用。（推荐）

alpha: 未来版本的实验性预览。

创建 Namespace

创建一个名为 cattle-system 的 Namespace。

kubectl create namespace cattle-system

安装 cert-manager

# 如果你手动安装了CRD，而不是在Helm安装命令中添加了`--set installCRDs=true`选项，你应该在升级Helm chart之前升级CRD资源。
kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v1.5.1/cert-manager.crds.yaml

# 添加 Jetstack Helm 仓库

helm repo add jetstack https://charts.jetstack.io

# 更新本地 Helm chart 仓库缓存

helm repo update

# 安装 cert-manager Helm chart

helm install cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --version v1.5.1

安装完 cert-manager 后，您可以通过检查 cert-manager 命名空间中正在运行的 Pod 来验证它是否已正确部署：

使用 sealos 部署 Kubernetes 集群

Tue, 26 Oct 2021 11:28:39 +0800

今天介绍使用 sealos 一键部署 Kubernetes 集群，sealos 是只能用丝滑一词形容的 kubernetes 高可用安装（kubernetes install）工具，一条命令，离线安装，包含所有依赖，内核负载不依赖 haproxy keepalived，纯 golang 开发，99 年证书，支持 v1.20.0 v1.19.5 v1.18.13 v1.17.15!

sealos 支持的环境

Linux 发行版，CPU 架构

Debian 9+, x86_64/ arm64
Ubuntu 16.04, 18.04, 20.04, x86_64/ arm64
Centos/RHEL 7.6+, x86_64/ arm64
其他支持 systemd 的系统环境。x86_64/ arm64
Kylin arm64

kubernetes 版本

1.16+
1.17+
1.18+
1.19+
1.20+
1.21+
1.22+

要求和建议

最低资源要求
- 2 vCpu
- 4G Ram
- 40G+ 存储
操作系统要求
- ssh 可以访问各安装节点
- 各节点主机名不相同，并满足 kubernetes 的主机名要求。
- 各节点时间同步
- 网卡名称如果是不常见的，建议修改成规范的网卡名称，如 (eth.|en.|em.*)
- kubernetes1.20+ 使用 containerd 作为 cri. 不需要用户安装 docker/containerd. sealos 会安装 1.3.9 版本 containerd。
- kubernetes1.19 及以下使用 docker 作为 cri。也不需要用户安装 docker。sealos 会安装 1.19.03 版本 docker
网络和 DNS 要求：

kratos 自定义 handler func 没有请求日志的问题及解决

Fri, 22 Oct 2021 20:47:31 +0800

出现的问题

最近在使用 kratos 开发 api 的时候，由于通过 proto 生成的 server handler 不符合业务的需求，需要通过自定义 handlerFunc 来定义接口。在开发中为了程序的可观测性，我使用了 kratos 提供的 logging 中间件。

在使用的过程中，我发现自定义的 HandlerFunc 的请求日志没有显示，而 proto 生成的请求正确显示了。

问题的原因

为了找到出现这种情况的原因，我在官方的 Github 仓库提了个 issue(#1566), 得到了维护人员的解答。

出现这种情况的原因是自己定义的 handlerFunc 不走 middleware 中间件，需要自定义 http filter 才能解决。

解决

经过对 http filter 例子的简单研究，参考了官方的 logging 中间件，我自己实现了 logging filter.

代码：

package middleware

import (
	"fmt"
	"net/http"
	"time"

	"github.com/go-kratos/kratos/v2/errors"
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/transport"
)

func Server(logger log.Logger) func(next http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			var (
				code      int32
				reason    string
				kind      string
				operation string
			)
			ctx := r.Context()
			startTime := time.Now()
			if info, ok := transport.FromServerContext(ctx); ok {
				kind = info.Kind().String()
				operation = info.Operation()
			}
			next.ServeHTTP(w, r)

			if se := errors.FromError(nil); se != nil {
				code = se.Code
				reason = se.Reason
			}
			level, stack := extractError(nil)
			_ = log.WithContext(ctx, logger).Log(level,
				"kind", "server",
				"component", kind,
				"operation", operation,
				"args", extractArgs(r),
				"code", code,
				"reason", reason,
				"stack", stack,
				"latency", time.Since(startTime).Seconds(),
			)
		})
	}
}

// extractArgs returns the string of the req
func extractArgs(req interface{}) string {
	if stringer, ok := req.(fmt.Stringer); ok {
		return stringer.String()
	}
	return fmt.Sprintf("%+v", req)
}

// extractError returns the string of the error
func extractError(err error) (log.Level, string) {
	if err != nil {
		return log.LevelError, fmt.Sprintf("%+v", err)
	}
	return log.LevelInfo, ""
}

顺利的显示了请求的日志：

golang 随机 time.Sleep 出现的问题

Fri, 15 Oct 2021 10:08:08 +0800

问题

最近需要使用 rand 包随机 time.Sleep() 的时间，我的代码是这样的：

package main

import (
	"math/rand"
	"time"
)

func main() {
	rand.Seed(time.Now().UTC().UnixNano())
	n := rand.Intn(10)
	time.Sleep(n * time.Second)
}

会遇到下面的问题：

Cannot use 'n * time.Second' (type int) as the type Duration
Invalid operation: n * time.Second (mismatched types int and Duration)

解决的方法

使用 time.Duration 转换类型，代码如下：

package main

import (
	"math/rand"
	"time"
)

func main() {
	rand.Seed(time.Now().UTC().UnixNano())
	n := rand.Intn(10)
	time.Sleep(time.Duration(n) * time.Second)
}

问题的原因

time.Sleep 方法接收的类型是 Duration 类型。

func Sleep(d Duration)

当我们要 sleep 5s 时，参数是 5 * time.Second, Second 又是 1000 * Millisecond, Millisecond 是 1000 * Microsecond，Microsecond 是 1000 * Nanosecond,Nanosecond 是 1 纳秒，它的类型就是 Duration。最后 5s 就变成 5000000000 数值。

如何在 gin 中查看 Prometheus 指标

Thu, 30 Sep 2021 15:21:09 +0800

在我们的 go 应用程序中，我们如果想要查看应用程序的相关指标，该如何操作呢？

解决

Prometheus 的官方 pkg 提供了 promhttp.Handler() 方法，但是该方法返回了一个 http.Handler 接口，不满足 gin 所使用的类型，我们采用其他的方法进行。

具体的代码：

promhttp.InstrumentMetricHandler(prometheus.DefaultRegisterer, promhttp.HandlerFor(prometheus.DefaultGatherer, promhttp.HandlerOpts{
DisableCompression: true,
})).ServeHTTP(c.Writer, c.Request)

通过在路由处理函数中添加此代码，就能顺利的展示与应用程序相关的指标。

如果想要自定义指标，你只需将自定义的指标进行相应的注册。

参考链接

https://github.com/prometheus/client_golang

使用 Prometheus 收集 MinIO 指标

Tue, 28 Sep 2021 09:54:07 +0800

今天我来讲一讲如何使用 Prometheus 获取 MinIO 指标。

前提

需要部署好 Prometheus、Minio 服务和配置好 Minio Client , MinIO 和 Prometheus 的网络需要可互相访问。

步骤

1. 生成 JWT 令牌

使用以下命令生成 JWT bearer token


mc admin Prometheus generate ALIAS

请将 ALIAS 替换成你的 MinIO 主机服务名。

该命令会产生如下的信息输出：

scrape_configs:
- job_name: minio-job
  bearer_token: token
  metrics_path: /minio/v2/metrics/cluster
  scheme: http
  static_configs:
  - targets: [minIOip]

配置 Prometheus Targets

将上一个步骤输出的信息添加至 Targets 配置文件 (Prometheus.yml) 中，重新启动 Prometheus 服务。

查询 Prometheus 指标

添加重启完 Prometheus 服务后，我们就可以在 Prometheus 界面查询 Minio 相关的指标。例如：我们可以通过 minio_bucket_usage_object_total 指标查询 bucket 的对象总数。

分布式链路追踪初探 2

Fri, 24 Sep 2021 20:22:44 +0800

上一篇文章介绍了分布式链路的标准 OpenTracing, 在 OpenTracing 的官网我们可以看到这样一条信息 OpenTracing and OpenCensus have merged to form OpenTelemetry!。 可以看到 OpenTracing 和 OpenCensus 已经被合并为 OpenTelemetry 了。

OpenCensus 是什么呢？OpenTracing 是最早为分布式追踪制定了一套平台无关、厂商无关的协议标准的项目，并以此成为了 CNCF 的孵化项目。在之后，谷歌牵头，微软加入，创建了 OpenCensus 项目统一 Metrics 基础指标监控的使用方式，还做了 OpenTracing 的老本行：分布式追踪。

OpenTelemetry

OpenTelemetry 的自身定位十分明确：数据采集和标准规范的统一，对于数据如何去使用、存储、展示、告警，官方是不涉及的。

OpenTelemetry 的终极目标十分伟大：实现 Metrics、Tracing、Logging 的融合及大一统，作为 APM 的数据采集终极解决方案。

目前 OpenTelemetry 正式成为 CNCF 的孵化项目，OpenTracing 和 OpenCensus 不再维护，OpenTracing 目前是 CNCF 的存档项目。

OpenTelemetry 的一些基础知识是兼容 OpenTracing 的，只有一些 API 是不同的。

OpenTelemetry for go

我们继续使用上文的代码，对上文的代码进行修改。

install 依赖

go get go.opentelemetry.io/otel@v1.0.0-RC1 go.opentelemetry.io/otel/sdk@v1.0.0-RC1 go.opentelemetry.io/otel/exporters/stdout/stdouttrace@v1.0.0-RC1 go.opentelemetry.io/otel/trace@v1.0.0-RC1
go get -u go.opentelemetry.io/otel/exporters/jaeger

OpenTelemetry 官方为多种开源框架提供了开箱即用的 Instrumentation Packages，如 gin , beego , mux , go-kit 等，当然也支持 net/http 标准库，更多可浏览 opentelemetry-go-contrib 仓库。

分布式链路追踪初探

Sat, 18 Sep 2021 22:38:37 +0800

微服务架构作为云原生核心技术之一，提倡将单体应用程序 (巨石架构) 划分成一组小的服务（微服务），服务之间互相协调、互相配合，为用户提供最终价值。

微服务架构设计中，通常由多个微服务组件组成，有 1) API 网关 ( apisix, kong, traefik ) 负责认证鉴权、负载均衡、限流和静态响应处理; 2) 服务注册发现中心 ( ZooKeeper、Consul、ETCD ) ,负责服务的注册和发现。3) 可观测性负责日志收集查看的 ELK、Loki，负责服务性能指标告警的指标 Metrics 监控 Prometheus, 负责追踪请求的 Tracing 链路追踪。在多个组件的组成下，才能顺利组成一个好的微服务架构。

今天我就来简单的讲一讲微服务组成中可观测性的分布式链路追踪。

OpenTracing 介绍

OpenTracing 是一个新的、开放的分布式追踪标准，用于应用程序和 OSS 包。有过大规模构建微服务经验的开发者都知道分布式追踪的作用和重要性：每个进程的日志和指标监控都有它们的用武之地，但它们都无法重建事务在分布式系统中传播时的复杂旅程。分布式跟踪就是这些旅程。

OpenTracing 项目定义了一套分布式追踪的标准，以统一各种分布式追踪系统的实现。OpenTracing 中包含了一套分布式追踪的标准规范，各种语言的 API，以及实现了该标准的编程框架和函数库。

OpenTracing 提供了平台无关、厂商无关的 API，因此开发者只需要对接 OpenTracing API，无需关心后端采用的到底是什么分布式追踪系统，Jager、Skywalking、LightStep 等都可以无缝切换。

数据模型

OpenTracing 定义了以下数据模型：

Trace（调用链）：一个 Trace 代表一个事务或者流程在（分布式）系统中的执行过程。例如来自客户端的一个请求从接收到处理完成的过程就是一个 Trace。

Span（跨度）：Span 是分布式追踪的最小跟踪单位，一个 Trace 由多段 Span 组成。可以被理解为一次方法调用，一个程序块的调用，或者一次 RPC/数据库访问。只要是一个具有完整时间周期的程序访问，都可以被认为是一个 Span。

SpanContext（跨度上下文）：分布式追踪的上下文信息，包括 Trace id，Span id 以及其它需要传递到下游服务的内容。一个 OpenTracing 的实现需要将 SpanContext 通过某种序列化协议 (Wire Protocol) 在进程边界上进行传递，以将不同进程中的 Span 关联到同一个 Trace 上。对于 HTTP 请求来说，SpanContext 一般是采用 HTTP header 进行传递的。

遍历 map 列表的 Golang 模板

Fri, 10 Sep 2021 09:47:55 +0800

遍历 map 列表的 Golang 模板遇到的问题及解决方式

出现了什么问题？

今天在使用 go template 渲染文本的时候，在运行的时候，遇到了一个问题导致渲染不成功，具体的问题是：

2021/09/10 09:47:05 template: test:2:3: executing "test" at <.Attributes>: can't evaluate field Attributes in type interface {}

具体的代码如下：

package main

import (
 "log"
 "os"
 "strings"
 "text/template"
)

type TestData struct {
 Name       string `json:"name"`
 Attributes map[string]interface{}
}

const testTemplate = `{{ range $key, $value := .Attributes }}
 {{.Name}} {{ $key }}: {{ $value }}{{- end }}`

func main() {
 tmpl, err := template.New("test").Parse(strings.TrimSpace(testTemplate))
 if err != nil {
  log.Println(err)
  return
 }
 data := TestData{
  "hello",
  map[string]interface{}{
   "key":   "hello",
   "value": "json",
  },
 }
 err = tmpl.Execute(os.Stdout, data)
 if err != nil {
  log.Println(err)
  return
 }
}

问题出现的原因？

模板在 range 循环中会把。设置为当前 Attributes 变量，在 Attributes 变量中没有 name 这个成员结构，这就导致模板没有渲染成功。

Golang Templates

Fri, 03 Sep 2021 21:41:10 +0800

Golang Template

今天来讲讲 golang 中的标准库 template, Go 标准库提供了几个 package 可以产生输出结果，主要有 2 个：text/template 和 html/template, text/template 提供根据模板输出内容，html/template 产生安全的 HTML 的输出，这两个库的使用方式很相似，文中的例子大部分是基于 html/template 展示的。

解析和创建模板

模板命名

template 所使用的库没有限定扩展名，但最经常使用的后缀是 .tmpl, 编辑器对.tmpl 的支持最好，官方的例子也是使用 .tmpl, .tpl 也经常使用。

创建模板

通过 Parse 方法可以创建文件名为名字的模板。

package main

import (
	"fmt"
	"html/template"
	"log"
)

func main() {
	tpl, err := template.New("index").Parse("index.tmpl")
	if err != nil {
		log.Fatalln(err)
	}

}

解析多个模板

通过 template.ParseFiles(filenames …string) 方法可以解析一组模板，使用各个文件名作为模板名称。

template.ParseGlob(pattern) 方法会根据 pattern 解析所有匹配的模板并保存。

package main

import "html/template"

func main() {
	template.ParseFiles("index.tmpl", "index2.tmpl")

}

解析字符串模板

除了可以解析文件，还可以解析字符串模板。

Wire 入门

Fri, 27 Aug 2021 21:36:08 +0800

今天我们来讲一讲 Wire 的入门使用。

Wire 是什么

go 的依赖注入工具常见有 2 种，一类是通过反射在运行时进行依赖注入，典型代表是 uber 开源的 dig，另外一类是通过 generate 进行代码生成，典型代表就是我今天要将的 Google 开源的 wire。使用 dig 功能会强大一些，但是缺点就是错误只能在运行时才能发现，这样如果不小心的话可能会导致一些隐藏的 bug 出现。使用 wire 的缺点就是功能限制多一些，但是好处就是编译的时候就可以发现问题，并且生成的代码其实和我们自己手写相关代码差不太多，更符合直觉，心智负担更小。

Wire 使用

安装

Wire 的安装十分简单，只要执行 go get github.com/google/wire/cmd/wire , wire 命令行工具就会被安装到 $GOPATH/bin 目录下。

核心概念

在正式使用前，我来介绍一下 Wire 中的 2 个重要概念：Provider 和 Injector。

Provider

Provider 是一个普通的函数，这个函数会返回构建依赖关系所需的组件。如下所示，就是一个 provider 函数，在实际使用的时候，往往是一些简单工厂函数。

func NewDb(opt *DbOpt)(*Db, error){...}

在使用中，不能存在 2 个 Provider 返回相同的类型。

Injector

Injector 是由 wire 自动生成的函数。函数内部会按根据依赖顺序调用相关 Provider。

我们往往在 wire.go 文件中定义 Injector 函数签名。然后通过 wire 命令行工具生成完整函数。由于 wire.go 中的函数并没有真正返回值，为避免编译器报错，简单地用 panic 函数包装起来即可。不用担心执行时报错，因为它不会实际运行，只是用来生成真正的代码的依据。

Go 泛型初探

Fri, 20 Aug 2021 21:47:14 +0800

go 泛型初探

go1.17 于几天前正式发布，虽然 go 的泛型还没正式发布，但 go 的泛型代码已经并入 master 分支，所以我们可以在 go1.17 版本中提前试用泛型。

下载 go1.17

如果你目前没有 go 的任何版本，你只能去官网链接下载 1.17 版本，如果已有了 go 的其它版本，你可以通过以下方式下载使用 go1.17:

 go  get golang.org/dl/go1.17
 go1.17 download
 go1.17 version

这样就 1.17 就下好了。

例子

接下来我们来看看 2 个使用泛型的例子。

例子 1:

package main
import ("fmt")
func print[T any](s []T) {
	for _, v := range s {
		fmt.Println(v)
	}
}

func main() {
	print([]string{"Hello, ", "overstarry\n"})
	print([]int64{1, 2, 3})
	print([]float64{1, 2, 3})
}

go 使用[] 定义类型参数，与 java、c++ 等的<>有很大不同，any 关键字来表示任意类型约束。然后怎么运行呢？简单的 go run\build 是肯定不行的，要运行泛型代码，你需要在 run\build 后加-G 参数，运行的命令是：

Functional_Options

Sat, 14 Aug 2021 12:17:18 +0800

Functional Options

今天我来讲一下在 go 语言编程中一种很常用的编程模式 - Functional Options 模式。Functional Options 模式是目前在 Go 语言中最流行的一种编程模式，在 Kubernetes 等开源项目中就有 Functional Options 的影子。接下来我们就来聊一聊 Functional Options 和它解决的问题。

常见的使用场景

在我们编程中，我们会经常性的需要对一个对象进行相关的配置。比如下面这个结构实体：

type Server struct {
    Addr     string
    Port     int
    Protocol string
    TLS      *tls.Config
}

在这个 Server 对象中，我们可以看到：有侦听的 IP 地址 Addr 和端口号 Port，这两个配置选项是必填的。然后，还有协议 Protoco 字段，这几个字段是不能为空的，但是有默认值的，例如协议的默认值是 tcp。还有一个 TLS 这个是 HTTPS 安全链接，需要配置相关的证书和私钥。这个是可以为空的，为空就是不使用 HTTPS。

所以根据上述结构体的描述，我们需要有多种不同的创建不同配置 Server 的函数签名，如下所示：

func NewDefaultServer(addr string, port int) (*Server, error) {
	return &Server{addr, port, "tcp", nil}, nil
}
func NewTLSServerWithMaxConnAndTimeout(addr string, port int, tls *tls.Config) (*Server, error) {
	return &Server{addr, port, "tcp", tls}, nil
}

因为 go 语言与 Python 等语言是不同的，没用重载函数，所你得用不同的函数名来应对不同的配置选项。

新增配置对象

要解决这个问题，最常见的方式是使用一个配置对象，如下所示：


type Config struct {
    Protocol string
    TLS      *tls.Config
}
type Server struct {
    Addr string
    Port int
    Conf *Config
}

我们将那些不是必填的字段存入新的结构体中，于是 Server 结构体就变成如上图所示的样子。于是，我们只需要一个 NewServer() 的函数了，在使用前需要构造 Config 对象。

Docker_grafana 启动失败

Thu, 12 Aug 2021 10:56:32 +0800

Docker grafana 启动失败

今天在使用 Docker 启动 grafana 的时候，遇到了一个问题，问题如图：

为什么会出现这个问题

根据错误日志的提示，打开 http://docs.grafana.org/installation/docker/#migrate-to-v51-or-later 网址，根据官方的描述，grafana Docker 镜像在版本 5.1 及以后有了重大改变：

* 在容器启动过程中不会改变文件的权限
* 默认用户 ID 由 104 变为 472
* 删除了以下的隐式卷：
    * /var/lib/grafana
    * /etc/grafana
    * /var/log/grafana

解决

根据官方文档的提示，我仔细查看了我的 compose 文件，发现我加了 user: ‘104’ , 应该是此行的原因导致 grafana 没有启动成功，删除此行，顺利启动。

Nginx 搭建静态图片资源服务器

Fri, 06 Aug 2021 16:20:16 +0800

Nginx 搭建静态图片资源服务器

本文介绍使用 Docker Nginx 搭建静态图片资源服务器的过程和搭建中间遇到的问题。

我使用 Docker compose 搭建静态图片资源服务器，我使用的 compose 文件内容如下：

version: '3.1'

services:
  nginx:
    restart: always
    image: nginx
    container_name: asset
    ports:
      - 80:80
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./uploads:/usr/share/nginx/uploads
      - ./conf.d:/etc/nginx/conf.d

/srv/msg/storage/uploads:/usr/share/nginx/uploads 将本地的图片文件夹挂载到容器内的 /usr/share/nginx/uploads 文件夹 nginx.conf 是 Nginx 的主配置文件，conf.d 是各个网站配置的文件夹。我的 nginx.conf 内容如下：


user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
    access_log  /var/log/nginx/access.log  main;
    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;
    include /etc/nginx/conf.d/*.conf;
    server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  192.168.1.117;
        root /usr/share/nginx/uploads/;
        location /{
              autoindex on;
        }
        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }

    }
     
}

静态资源图片服务器的配置文件如下：

Traefik 入门使用

Fri, 06 Aug 2021 14:42:43 +0800

Traefik 入门使用

简介

Traefik（发音为 traffic）是一个现代 HTTP 反向代理和负载均衡设施，使部署微服务变得容易。Traefik 与你现有的基础设施组件（Docker、Swarm 模式、Kubernetes、Consul、Etcd、…）集成，并自动和动态地配置自己。将 Traefik 指向你的基础设施组件应该是你唯一需要的配置步骤。

快速入门

在这里我使用 Docker 来快速使用 Traefik。

先创建一个 docker-compose.yml 文件，写入如下内容：

version: '3'
services:
  reverse-proxy:
    # 使用的 traefik2.4 Docker 镜像版本
    image: traefik:v2.4
    # 通过命令行参数启动 traefik，启用不安全模式以使用 dashboard，配置发现使用了 docker
    command: --api.insecure=true --providers.docker
    ports:
      # The HTTP port
      - "80:80"
      # dashboard 端口
      - "8080:8080"
    volumes:
      # 监听 docker 事件
      - /var/run/docker.sock:/var/run/docker.sock

执行 docker-compose up -d reverse-proxy 启动

docker-compose up -d reverse-proxy

打开浏览器输入 http://localhost:8080/api/rawdata 访问看见 Traefik’s API rawdata，就表示安装成功了。

Go_Modules 指南和常见问题

Fri, 30 Jul 2021 22:11:41 +0800

Go Modules 简明使用

Go Modules 是从 go1.11 开始初步支持，到现在的 1.16、1.17 默认开启，是目前 go 项目的推荐包管理方式。接下来让我们看一下 go modules 的简单使用方法。

使用 Go Modules

初始化

# go mod init [包路径]
go mod init github.com/overstarry/go-mod-example

执行上述命令会生成 go.mod 文件

module github.com/overstarry/kratos-demo
go 1.16

添加依赖

在当前项目的目录中执行 go get 命令，会添加相应的库到 mod 文件中

go get github.com/go-kratos/kratos/v2

这个命令会在 mod 文件里添加以下信息

require (
	github.com/go-kratos/kratos/v2 v2.0.1
)

在 go get 的时候如果不手动指定版本信息，会自动拉取最新的版本的包
如果想要拉取指定版本可以通过 go get github.com/go-kratos/kratos/v2 v2.0.1 的方式，支持
- @版本号例如 @v2.0.1
- @分支名例如 @master
- @commit tag 例如 @6cff360233dc4457f1536e4f3df4e4e740fd3410
- // indirect 表示，我们在代码中没有直接应用这个包
执行完 go get 命令之后还会在目录下生成一个 go.sum 文件

github.com/go-kratos/kratos/v2 v2.0.0-rc7 h1:Qvpz07BefgMFQycSDb57NlWhtYGz4me3wh8E1naI9/k=
github.com/go-kratos/kratos/v2 v2.0.0-rc7/go.mod h1:/2bGobqE+/F9kKOe4Re0OO5X2NWNGt+7n2e8Y5DHFRc=
github.com/go-kratos/kratos/v2 v2.0.1 h1:iFteVlcLWnAQu5n4I5bTN63svW+0YylGwhNTYO2MkOQ=
github.com/go-kratos/kratos/v2 v2.0.1/go.mod h1:Jz6fuJFF2SLczQ7Y8ocKieVGgstQKa+R9NX09bCHekU=

这个文件主要包含当前依赖的所有的包。

Gitlab CI 构建 docker 镜像

Thu, 22 Jul 2021 12:44:00 +0800

Gitlab CI 构建 docker 镜像

利用 Gitlab CI 结合 Docker 构建 docker 镜像主要有三种方法。

将 Docker 执行器与 Docker 镜像一起使用。
使用 shell 执行器
Docker socket 绑定

现在来讲讲我的具体使用过程和遇到的一些问题，由于我的 gitlab-runners 使用了 docker 执行器，所以我主要使用了 1 和 3 两种方法。

由于网上的相关文章主要是采用 Docker in Docker 的方式，所以最开始我也是采用这种方式。我的 ci 脚本是：

services:
  - docker:dind
variables:
  OUTPUT_NAME: bot
  DOCKER_HOST: tcp://localhost:2375
  DOCKER_DRIVER: overlay2
  DOCKER_TLS_CERTDIR: ""

build_docker_image_and_push_to_nexus:
  stage: build
  image: docker:stable
  extends: .go-cache
  script:
    - docker info
    - docker build -t docker.overtsarry.vip/bot:1.0.1 .
    - docker login --username=$username docker.overtsarry.vip --password $pwd
    - docker push docker.overtsarry.vip/bot:1.0.1

运行 CI，发现 CI 运行失败，具体报错是

Hugo Github_page 自定义域名

Thu, 15 Jul 2021 20:47:51 +0800

部署好 GithubPage 后，觉得提供的域名不好，想要换成自己的域名，该如何操作呢。下面来介绍下给 Github Page 设置自定义域的方式。

在 Github 上，打开 GithubPage 所在仓库。
在仓库名称下，单击 Settings（设置）。
在左侧边栏中，单击 Pages（页面）。
在 “Custom domain（自定义域）“下，输入自定义域，然后单击 Save（保存）。这将创建一个在发布源根目录中添加 CNAME 文件的提交。
导航到您的 DNS 提供程序并创建 CNAME 记录，使子域指向您站点的默认域。就是在你域名的提供商进行相应域名的解析，添加对应的 CNAME 记录集。 6.（可选）要为您的站点实施 HTTPS 加密，请选择 Enforce HTTPS（实施 HTTPS）。可能要过 24 小时才能使用此选项。

上面这是常规的标准做法，由于我是采用 Github actions 构建生成站点，每次 CI 运行时，都会重新生成仓库文件，CNAME 文件都需要重新创建，十分不方便。于是在 Hugo site static 文件夹创建 CNAME 文件，这样每次运行 CI 时，都不需要重复上面步骤。

参考链接

https://docs.github.com/en/pages/configuring-a-custom-domain-for-your-github-pages-site/managing-a-custom-domain-for-your-github-pages-site

Go 错误实践

Fri, 09 Jul 2021 15:23:53 +0800

panic

在程序启动的时候，如果有强依赖的服务出现故障时 panic 退出
在程序启动的时候，如果发现有配置明显不符合要求，可以 panic 退出（防御编程）
其他情况下只要不是不可恢复的程序错误，都不应该直接 panic 应该返回 error
在程序入口处，例如 gin 中间件需要使用 recover 预防 panic 程序退出
在程序中我们应该避免使用野生的 goroutine
1. 如果是在请求中需要执行异步任务，应该使用异步 worker，消息通知的方式进行处理，避免请求量大时大量 goroutine 创建
2. 如果需要使用 goroutine 时，应该使用同一的 Go 函数进行创建，这个函数中会进行 recover，避免因为野生 goroutine panic 导致主进程退出

func fn(f func()){
    go func(){
        defer func(){
            if err := recover(); err != nil {
                log.Printf("panic: %+v", err)
            }
        }()

        f()
    }()
}

error

我们在应用程序中使用 github.com/pkg/errors 处理应用错误，注意在公共库当中，我们一般不使用这个
error 应该是函数的最后一个返回值，当 error 不为 nil 时，函数的其他返回值是不可用的状态，不应该对其他返回值做任何期待
1. func f() (io.Reader, *S1, error) 在这里，我们不知道 io.Reader 中是否有数据，可能有，也有可能有一部分
错误处理的时候应该先判断错误，if err != nil 出现错误及时返回，使代码是一条流畅的直线，避免过多的嵌套。
在应用程序中出现错误时，使用 errors.New 或者 errors.Errorf 返回错误
如果是调用应用程序的其他函数出现错误，请直接返回，如果需要携带信息，请使用 errors.WithMessage
如果是调用其他库（标准库、企业公共库、开源第三方库等）获取到错误时，请使用 errors.Wrap 添加堆栈信息
1. 切记，不要每个地方都是用 errors.Wrap 只需要在错误第一次出现时进行 errors.Wrap 即可
2. 根据场景进行判断是否需要将其他库的原始错误吞掉，例如可以把 repository 层的数据库相关错误吞掉，返回业务错误码，避免后续我们分割微服务或者更换 ORM 库时需要去修改上层代码
3. 注意我们在基础库，被大量引入的第三方库编写时一般不使用 errors.Wrap 避免堆栈信息重复

func f() error {
    err := json.Unmashal(&a, data)
    if err != nil {
        return errors.Wrap(err, "其他附加信息")
    }

    // 其他逻辑
    return nil
}

禁止每个出错的地方都打日志，只需要在进程的最开始的地方使用 %+v 进行统一打印，例如 http/rpc 服务的中间件
错误判断使用 errors.Is 进行比较

func f() error {
    err := A()
    if errors.Is(err, io.EOF){
    	return nil
    }

    // 其他逻辑
    return nil
}

错误类型判断，使用 errors.As 进行赋值

func f() error {
    err := A()

    var errA errorA
    if errors.As(err, &errA){
    	// ...
    }

    // 其他逻辑
    return nil
}

如何判定错误的信息是否足够，想一想当你的代码出现问题需要排查的时候你的错误信息是否可以帮助你快速的定位问题，例如我们在请求中一般会输出参数信息，用于辅助判断错误
对于业务错误，推荐在一个统一的地方创建一个错误字典，错误字典里面应该包含错误的 code，并且在日志中作为独立字段打印，方便做业务告警的判断，错误必须有清晰的错误文档
不需要返回，被忽略的错误必须输出日志信息
同一个地方不停的报错，最好不要不停输出错误日志，这样可能会导致被大量的错误日志信息淹没，无法排查问题，比较好的做法是打印一次错误详情，然后打印出错误出现的次数
对同一个类型的错误，采用相同的模式，例如参数错误，不要有的返回 404 有的返回 200
处理错误的时候，需要处理已分配的资源，使用 defer 进行清理，例如文件句柄

使用 Redis 实现消息队列

Wed, 07 Jul 2021 22:51:18 +0800

使用 Redis 实现消息队列主要有三种方法：

List 队列
发布/订阅模型 Pub/Sub
Stream (Redis5+)

下面分别对这三种方法进行介绍，并编写简单例子。

List 队列

看到队列，你会想到 Redis 有个数据类型 List，List 能很好符合队列的要求。List 的底层是一个链表，在头部和尾部进行操作的时间复杂度都是 O(1)。使用 List 进行队列操作，你可以这样使用。生产者使用 LPUSH 进行消息发布消费者使用 RPOP 对消息进行消费这里存在着一个问题，如果 LIST 没有消息时，消费者执行 RPOP 时，会返回 null(nil)。我们在编写消费者逻辑时，一般是循环不断从队列中消费数据进行处理，如果此时队列为空，那消费者依旧会频繁拉取消息，这会造成「CPU 空转」，不仅浪费 CPU 资源，还会对 Redis 造成压力。Redis 提供了阻塞式拉起命令 BRPOP / BLPOP，使用 BRPOP 这种阻塞式方式拉取消息时，还支持传入一个「超时时间」，如果设置为 0，则表示不设置超时，直到有新消息才返回，否则会在指定的超时时间后返回 null，既兼顾了效率还避免了 CPU 空转问题。这是 List 队列的代码例子：

// 生产者
package main

import (
	"context"
    
	"github.com/go-redis/redis/v8"
)

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       1,
	})
	data :=[]string{`{"name": "jinzhu11221212321", "age": 18, "tags": ["tag211", "tag2"], "orgs": {"orga": "orga"}`,`{"name": "asd", "age": 18, "tags": ["tag211", "tag2"], "orgs": {"orga": "orga"}`}
	rdb.LPush(context.Background(), "queue", data)
}

// 消费者
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/go-redis/redis/v8"
)

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       1,
	})
	for true {
		//result, err := rdb.RPop(context.Background(), "queue").Result()
		result, err := rdb.BRPop(context.Background(), 0, "queue").Result()
		if err == redis.Nil {
			continue
		} else if err != nil {
			log.Println(err)
		}
		fmt.Printf("consumer msg %v\n", result)

	}
}

List 队列的缺点：

My First Post

Mon, 05 Jul 2021 10:46:32 +0800