技术文章 Archives - 原立方 https://www.atomic-cube.cn/category/技术文章/ 技术栈的流动-从零到∞ Mon, 29 Jun 2026 00:54:45 +0000 zh-CN hourly 1 https://wordpress.org/?v=7.0.2 MYSQL线上数据库表归档工具推荐Percona-Toolkit 之 pt-archiver https://www.atomic-cube.cn/mysql%e7%ba%bf%e4%b8%8a%e6%95%b0%e6%8d%ae%e5%ba%93%e8%a1%a8%e5%bd%92%e6%a1%a3%e5%b7%a5%e5%85%b7%e6%8e%a8%e8%8d%90percona-toolkit-%e4%b9%8b-pt-archiver/ https://www.atomic-cube.cn/mysql%e7%ba%bf%e4%b8%8a%e6%95%b0%e6%8d%ae%e5%ba%93%e8%a1%a8%e5%bd%92%e6%a1%a3%e5%b7%a5%e5%85%b7%e6%8e%a8%e8%8d%90percona-toolkit-%e4%b9%8b-pt-archiver/#respond Sun, 21 Jun 2026 23:00:57 +0000 https://www.atomic-cube.cn/?p=1645 Percona Toolkit中的pt-archiver是一个用于归档数据的工具，它可以有效地将旧数据移动到另一个表中，而不会对生产数据库性能产生太大影响。 https://github.com/percona/percona-toolkit  pt-archiver的核心思路是以空间换时间，它通过创建一个临时表来存放需要保留的“热”数据，并使用触发器（Triggers） 来保证数据一致性，最后通过一次快速的表名交换来完成归档。 ⚙️ 第一步：前置检查 在开始操作前，工具会先进行一轮严格的环境检查，如不满足以下任一条件将直接退出，不予执行。 🛠️ 第二步：创建临时表 通过环境检查后，工具会创建一个与原始表结构完全相同的空临时表（默认命名为 原表名_tmp），作为新数据的“容器”。 🔗 第三步：创建触发器（核心机制） 这是重构版保证数据一致性的关键。在向临时表复制数据的过程中，原表可能会继续接收业务的读写请求。为了保证这部分增量数据不丢失，工具会在原表上创建三个 AFTER 类型的触发器，将期间所有的数据变更实时同步到临时表。 这三种触发器协同工作的逻辑如下： 通过这套触发器机制，临时表的数据始终与原表保持同步，无论复制过程耗时多久，都不会丢失增量数据。 📦 第四步：复制数据 部署好触发器后，工具开始分批将原表中的数据复制到临时表。工具会使用 WHERE 条件来筛选出需要保留的数据（例如近7天的记录）。 注意：为了将对线上数据库的影响降到最低，工具在复制时会采取低优先级策略（INSERT LOW_PRIORITY IGNORE），并默认在每复制完一批数据（如1000行）后主动休眠1秒。 🔄 第五步：原子切换 当所有符合条件的“热数据”都复制完成后，归档工作进入最后一步。工具会执行一个原子的 RENAME TABLE 操作，将原始表与临时表的名字互换。对于上层应用而言，这个切换是瞬间完成的，几乎是无感知的。 pt-archiver核心用法实践 pt-archiver的命令格式可概括为：pt-archiver --source [源库参数] --dest [目标库参数] [可选参数]，以下针对不同业务场景给出具体示例，并解释关键参数含义。 场景1：全表归档（不删除原表数据） 适用于“需保留主库数据副本，同时归档备份”的场景（如历史订单归档但主库需临时查询）： 场景2：全表归档（删除原表数据） 适用于“主库无需保留历史数据，仅需归档”的场景（如超过1年的日志数据）： 场景3：直接删除原表数据（不归档） 适用于“历史数据无保留价值，仅需清理”的场景（如测试数据、临时日志）： 场景4：按条件归档部分数据实际业务中最常用的场景（如归档年龄小于30的用户数据、超过30天的日志）： 场景5：归档数据到文件（而非数据库） 注意事项与最佳实践

The post MYSQL线上数据库表归档工具推荐Percona-Toolkit 之 pt-archiver appeared first on 原立方.

]]> Percona Toolkit中的pt-archiver是一个用于归档数据的工具，它可以有效地将旧数据移动到另一个表中，而不会对生产数据库性能产生太大影响。

https://github.com/percona/percona-toolkit

 pt-archiver的核心思路是以空间换时间，它通过创建一个临时表来存放需要保留的“热”数据，并使用触发器（Triggers） 来保证数据一致性，最后通过一次快速的表名交换来完成归档。

⚙️ 第一步：前置检查

在开始操作前，工具会先进行一轮严格的环境检查，如不满足以下任一条件将直接退出，不予执行。

  • 无触发器：确保原表上当前没有定义任何触发器，以防冲突。
  • 无外键：检查是否存在外键约束，避免因外键关联导致操作失败。
  • 有主键：强制要求原表必须有主键，这是保证数据唯一性的前提。
  • Binlog格式为ROW：要求MySQL的 binlog_format 参数必须设置为 ROW，以确保在主从复制环境下，基于触发器的数据变更能被正确同步。

🛠️ 第二步：创建临时表

通过环境检查后，工具会创建一个与原始表结构完全相同的空临时表（默认命名为 原表名_tmp），作为新数据的“容器”。

🔗 第三步：创建触发器（核心机制）

这是重构版保证数据一致性的关键。在向临时表复制数据的过程中，原表可能会继续接收业务的读写请求。为了保证这部分增量数据不丢失，工具会在原表上创建三个 AFTER 类型的触发器，将期间所有的数据变更实时同步到临时表。

这三种触发器协同工作的逻辑如下：

  • AFTER INSERT触发器：使用 REPLACE INTO 语句。当原表插入新数据时，该数据会被同步插入或覆盖到临时表。即使该数据尚未被复制，也能确保临时表包含所有新增记录。
  • AFTER UPDATE触发器：同样使用 REPLACE INTO 语句。原表的数据更新会被转换为对临时表的插入或覆盖操作，从而保证数据一致。
  • AFTER DELETE触发器：执行 DELETE IGNORE 操作。当原表删除数据时，如果该数据尚未被复制到临时表，则忽略删除；如果已复制，则同步删除。这确保了数据的一致性。

通过这套触发器机制，临时表的数据始终与原表保持同步，无论复制过程耗时多久，都不会丢失增量数据。

📦 第四步：复制数据

部署好触发器后，工具开始分批将原表中的数据复制到临时表。工具会使用 WHERE 条件来筛选出需要保留的数据（例如近7天的记录）。

注意：为了将对线上数据库的影响降到最低，工具在复制时会采取低优先级策略（INSERT LOW_PRIORITY IGNORE），并默认在每复制完一批数据（如1000行）后主动休眠1秒。

🔄 第五步：原子切换

当所有符合条件的“热数据”都复制完成后，归档工作进入最后一步。工具会执行一个原子的 RENAME TABLE 操作，将原始表与临时表的名字互换。对于上层应用而言，这个切换是瞬间完成的，几乎是无感知的。

pt-archiver核心用法实践

pt-archiver的命令格式可概括为：pt-archiver --source [源库参数] --dest [目标库参数] [可选参数]，以下针对不同业务场景给出具体示例，并解释关键参数含义。

场景1：全表归档（不删除原表数据）

适用于“需保留主库数据副本，同时归档备份”的场景（如历史订单归档但主库需临时查询）：

pt-archiver \
--source h=192.168.12.161,u=dba,p='Id81Gdac_a',D=martin,t=archiver_test \  # 源库信息（h=IP,u=用户,p=密码,D=库,t=表）
--dest h=192.168.12.163,u=dba,p='Id81Gdac_a',D=archiver_db,t=archiver_test \  # 归档库信息
--where '1=1' \  # 条件：全表（1=1表示所有数据）
--progress 10000 \  # 每处理10000行输出进度
--limit=10000 \  # 每次批量处理10000行（避免单次查询压力过大）
--txn-size=10000 \  # 每10000行提交一次事务（减少事务日志占用）
--no-safe-auto-increment \  # 禁用自增主键安全检查（避免归档表自增冲突）
--statistics \  # 输出操作统计信息（如处理行数、耗时）
--no-delete  # 核心参数：不删除源表数据

场景2：全表归档（删除原表数据）

适用于“主库无需保留历史数据，仅需归档”的场景（如超过1年的日志数据）：

pt-archiver \
--source h=192.168.12.161,u=dba,p='Id81Gdac_a',D=martin,t=archiver_test \
--dest h=192.168.12.163,u=dba,p='Id81Gdac_a',D=archiver_db,t=archiver_test \
--where '1=1' \
--progress 10000 \
--limit=10000 \
--txn-size=10000 \
--no-safe-auto-increment \
--statistics \
--purge  # 核心参数：归档后删除源表数据（替代--no-delete）

场景3：直接删除原表数据（不归档）

适用于“历史数据无保留价值，仅需清理”的场景（如测试数据、临时日志）：

pt-archiver \
--source h=192.168.12.161,u=dba,p='Id81Gdac_a',D=martin,t=archiver_test \
--where '1=1' \  # 可修改条件（如age>50）筛选特定数据删除
--progress 10000 \
--limit=10000 \
--txn-size=10000 \
--no-safe-auto-increment \
--statistics \
--purge  # 仅删除源表数据，无需--dest参数

场景4：按条件归档部分数据
实际业务中最常用的场景（如归档年龄小于30的用户数据、超过30天的日志）：

# 1. 先清空归档表（避免重复数据，可选）
mysql -h192.168.12.163 -udba -p'Id81Gdac_a' -e "TRUNCATE TABLE archiver_db.archiver_test;"
# 2. 按条件归档（仅归档age<30的数据，并删除源表对应数据）
pt-archiver \
--source h=192.168.12.161,u=dba,p='Id81Gdac_a',D=martin,t=archiver_test \
--dest h=192.168.12.163,u=dba,p='Id81Gdac_a',D=archiver_db,t=archiver_test \
--where 'age<30' \  # 核心条件：筛选需归档的数据
--progress 10000 \
--limit=10000 \
--txn-size=10000 \
--no-safe-auto-increment \
--statistics \
--purge

场景5：归档数据到文件（而非数据库）

# 1. 归档为SQL文件（默认格式）
pt-archiver \
--source h=192.168.152.70,u=dba,p='Id81Gdac_a',D=martin,t=archiver_test \
--where 'age<35' \
--progress 10000 \
--limit=10000 \
--txn-size=10000 \
--no-safe-auto-increment \
--statistics \
--purge \
--file=./archiver.sql  # 输出文件路径（当前目录）
# 2. 归档为CSV格式（便于Excel分析或导入其他系统）
pt-archiver \
--source h=192.168.152.70,u=dba,p='Id81Gdac_a',D=martin,t=archiver_test \
--where '1=1' \
--progress 10000 \
--limit=10000 \
--txn-size=10000 \
--no-safe-auto-increment \
--statistics \
--purge \
--file=./archiver.csv \
--output-format=csv  # 指定输出格式为CSV

注意事项与最佳实践

  1. 操作前备份：归档/删除前务必备份关键数据，避免条件错误导致数据丢失；
  2. 测试环境验证：新脚本或命令需先在测试环境验证，确认参数正确后再推广到生产；
  3. 避免锁表：批量处理时--limit和--txn-size不宜过大（建议1000-10000行），防止长事务阻塞业务；
  4. 权限最小化：生产环境中，dba用户权限可缩小至“仅操作源库和归档库”，避免全库权限泄露；
  5. 监控与告警：结合crontab告警（如执行失败发送邮件），定期检查归档日志，确保脚本正常运行。

The post MYSQL线上数据库表归档工具推荐Percona-Toolkit 之 pt-archiver appeared first on 原立方.

]]> https://www.atomic-cube.cn/mysql%e7%ba%bf%e4%b8%8a%e6%95%b0%e6%8d%ae%e5%ba%93%e8%a1%a8%e5%bd%92%e6%a1%a3%e5%b7%a5%e5%85%b7%e6%8e%a8%e8%8d%90percona-toolkit-%e4%b9%8b-pt-archiver/feed/ 0 Agent Skills：像搭积木一样赋予 AI 专业能力 https://www.atomic-cube.cn/agent-skills%ef%bc%9a%e5%83%8f%e6%90%ad%e7%a7%af%e6%9c%a8%e4%b8%80%e6%a0%b7%e8%b5%8b%e4%ba%88-ai-%e4%b8%93%e4%b8%9a%e8%83%bd%e5%8a%9b/ https://www.atomic-cube.cn/agent-skills%ef%bc%9a%e5%83%8f%e6%90%ad%e7%a7%af%e6%9c%a8%e4%b8%80%e6%a0%b7%e8%b5%8b%e4%ba%88-ai-%e4%b8%93%e4%b8%9a%e8%83%bd%e5%8a%9b/#respond Sun, 21 Jun 2026 00:00:00 +0000 https://www.atomic-cube.cn/?p=1595 试想一个场景：你新招了一位实习生，他聪明、反应快，但对你公司的业务流程、内部规范、工具操作一无所知。怎么办？你给他写了一份详细的 SOP 手册，告诉他遇到什么情况该怎么做、用到什么工具、注意什么细节。从此，这位实习生就像一位经验丰富的老员工一样稳定输出。 Agent Skills，就是 AI 智能体的那份 SOP 手册。 🤔 一句话理解 Agent Skills Agent Skills 是一种轻量级的开放标准，由 Anthropic 于 2025 年底发布，迅速被 OpenAI、Microsoft、GitHub、Cursor 等主流平台采纳。它的核心思想非常简单： 把一个任务的全部“know-how”——操作步骤、判断依据、可执行脚本、参考资料——打包成一个文件夹，AI 智能体在需要时自动读取并严格执行。 Skill 就像 AI 的“即插即用”扩展包。一个 PDF 处理 Skill，让 AI 瞬间掌握提取文本、合并文档的能力；一个发票处理 Skill，让 AI 自动识别发票信息、重命名文件、生成汇总报告。你不必每次都从头教 AI 怎么做，它自己就知道该调用哪个“技能包”。 一个 Skill 长什么样？ Agent Skills 本质是一个按约定组织的文件夹。以 PDF 处理 Skill 为例： 核心是 SKILL.md 文件，顶部用 YAML 声明元数据，正文是 Markdown 格式的详细操作说明： 就是这么简单。AI 读到这个文件，就知道何时该激活这个技能、按什么流程操作、需要时去读取哪些附加文件。 🔄 […]

The post Agent Skills：像搭积木一样赋予 AI 专业能力 appeared first on 原立方.

]]> 试想一个场景：你新招了一位实习生，他聪明、反应快，但对你公司的业务流程、内部规范、工具操作一无所知。怎么办？你给他写了一份详细的 SOP 手册，告诉他遇到什么情况该怎么做、用到什么工具、注意什么细节。从此，这位实习生就像一位经验丰富的老员工一样稳定输出。

Agent Skills，就是 AI 智能体的那份 SOP 手册。

🤔 一句话理解 Agent Skills

Agent Skills 是一种轻量级的开放标准，由 Anthropic 于 2025 年底发布，迅速被 OpenAI、Microsoft、GitHub、Cursor 等主流平台采纳。它的核心思想非常简单：

把一个任务的全部“know-how”——操作步骤、判断依据、可执行脚本、参考资料——打包成一个文件夹，AI 智能体在需要时自动读取并严格执行。

Skill 就像 AI 的“即插即用”扩展包。一个 PDF 处理 Skill，让 AI 瞬间掌握提取文本、合并文档的能力；一个发票处理 Skill，让 AI 自动识别发票信息、重命名文件、生成汇总报告。你不必每次都从头教 AI 怎么做，它自己就知道该调用哪个“技能包”。

一个 Skill 长什么样？

Agent Skills 本质是一个按约定组织的文件夹。以 PDF 处理 Skill 为例：

pdf-processing/           # 技能文件夹
├── SKILL.md              # 必需：技能定义与工作流
├── references/           # 可选：详细参考资料
│   ├── field-mappings.md
│   └── validation-rules.md
└── scripts/              # 可选：可执行脚本
    └── extract_data.py

核心是 SKILL.md 文件，顶部用 YAML 声明元数据，正文是 Markdown 格式的详细操作说明：

---
name: pdf-processing
description: 从 PDF 提取文本和表格，填写表单，合并文档。
---
# PDF 处理工作流

1. 用 `scripts/extract_data.py` 读取 PDF 文件
2. 提取字段：供应商名称、发票号、日期、明细、合计
3. 按 `references/validation-rules.md` 验证数据
4. 按 `references/field-mappings.md` 的 schema 输出 JSON

就是这么简单。AI 读到这个文件，就知道何时该激活这个技能、按什么流程操作、需要时去读取哪些附加文件。

🔄 为什么需要 Skills？——告别“每次重头教一遍”

在 Skills 出现之前，开发者想赋予 AI 专业能力，通常有两种做法：

  1. 写超长 Prompt：把所有操作规范、步骤全部塞进提示词，每次对话都重复一遍，导致上下文臃肿、成本高昂。
  2. 硬编码工具调用：用代码写死调用逻辑，但缺乏灵活性，且不同任务需要写不同的定制 Agent。

Skills 通过 “渐进式披露” 机制，巧妙地解决了这个问题：

三步走，按需加载：

  • 第一层（元数据） ：启动时只加载所有技能的名称和简介，占用极少上下文。
  • 第二层（主体指令） ：AI 判断某个技能与当前任务相关时，才加载完整的 SKILL.md。
  • 第三层（附加资源） ：只有在执行具体步骤时，才读取引用的参考资料或执行脚本。

这种设计让 AI 可以拥有大量专业技能，而不会撑爆上下文窗口。

⚡ Skills vs. MCP Tools：菜谱 vs. 食材

很多人初次接触 Skills 时会问：这和 MCP（Model Context Protocol）工具调用有什么区别？一个生动的比喻可以帮你瞬间厘清：

概念比喻解决的问题
MCP Tools🥚 食材（鸡蛋、面粉、盐）“AI 能做什么操作？”（查数据库、调 API、读文件）
Agent Skills📖 菜谱（步骤说明、火候控制）“AI 该怎么做好这件事？”（流程、规范、判断依据）
AI Agent👨‍🍳 厨师根据菜谱选择食材，完成一道菜

MCP 工具是原子化的外部能力——数据库查询、API 调用、文件读写——每个工具只做一件小事。而 Skills 是更高层级的“行为模式”，它告诉 AI：什么时候该用工具、用什么工具、按什么顺序组合、如何验证结果。一个强大的 AI 智能体 = 大模型 + MCP 工具 + Skills 操作流程——三者缺一不可。

🚀 如何创建一个自己的 Skill？

创建一个 Skill 只需要三个步骤：

  1. 创建文件夹：命名为技能名称（如 my-first-skill），放在 AI 智能体的 skills 目录下。
  2. 编写 SKILL.md：顶部 YAML 声明 name 和 description，正文用 Markdown 写清楚工作流程和注意事项。
  3. 添加附加文件（可选） ：在 scripts/ 放 Python/Shell 脚本，在 references/ 放补充文档。

写好之后，支持 Skills 的 AI 工具（如 Claude Code、Cursor、OpenClaw）会自动识别并加载。当你的任务描述与技能的 description 匹配时，AI 就会激活它，按你写的流程执行。

💡 实践建议：初学者可以从一个简单的“文档格式化”Skill 开始练手——写清楚输入格式、输出要求、处理步骤，然后逐步扩展。

🌍 生态现状：正在爆发的“技能经济”

Agent Skills 的生态发展速度惊人。自 Anthropic 于 2025 年底发布开放标准以来：

  • 主流平台全面跟进：OpenAI Codex、GitHub Copilot、VS Code、Cursor、Claude Code 均已支持。
  • 企业级应用落地：Microsoft、Atlassian、Figma、Canva 等已为自家平台开发了 Skills，用于自动化办公、设计辅助等场景。
  • 开源社区活跃：OpenClaw（35 万+ GitHub Star）、ModelScope 的 MS-Agent、LangChain 的 deepagents-CLI 等开源项目都已实现 Skills 支持。
  • 技能市场兴起：Skills Marketplace 已有超 7 万个社区贡献的技能，涵盖 PDF 处理、数据分析、代码审查、客户支持等各领域。浙大与合作伙伴推出的 SkillNet 更是拥有超 20 万个可复用技能，实测可提升奖励 40%、减少执行步骤 30%。

这场变革的核心意义在于：行业知识首次从“依附于人”变成了“可蒸馏、可复用的技能包” 。专家经验不再锁在个人脑中，而是被标准化、版本化，可以一键分发给整个团队的所有 AI 助手。

Agent Skills 让 AI 从“能回答问题”进化到“能稳定做事”。它用极简的文件夹约定，实现了专业知识的模块化封装与渐进式加载，既避免了上下文爆炸，又让能力的复用和分发变得前所未有的简单。

如果你正在探索如何让 AI 真正融入工作流，Agent Skills 是一个值得立刻上手的方向。毕竟，让 AI 学会按 SOP 办事，才是通往可靠生产力的最短路径。

The post Agent Skills：像搭积木一样赋予 AI 专业能力 appeared first on 原立方.

]]> https://www.atomic-cube.cn/agent-skills%ef%bc%9a%e5%83%8f%e6%90%ad%e7%a7%af%e6%9c%a8%e4%b8%80%e6%a0%b7%e8%b5%8b%e4%ba%88-ai-%e4%b8%93%e4%b8%9a%e8%83%bd%e5%8a%9b/feed/ 0 MYSQL线上数据库表归档工具推荐之gh-ost https://www.atomic-cube.cn/mysql%e7%ba%bf%e4%b8%8a%e6%95%b0%e6%8d%ae%e5%ba%93%e8%a1%a8%e5%bd%92%e6%a1%a3%e5%b7%a5%e5%85%b7%e6%8e%a8%e8%8d%90%e4%b9%8bgh-ost/ https://www.atomic-cube.cn/mysql%e7%ba%bf%e4%b8%8a%e6%95%b0%e6%8d%ae%e5%ba%93%e8%a1%a8%e5%bd%92%e6%a1%a3%e5%b7%a5%e5%85%b7%e6%8e%a8%e8%8d%90%e4%b9%8bgh-ost/#respond Fri, 19 Jun 2026 23:00:57 +0000 https://www.atomic-cube.cn/?p=1648 一：gh-ost 介绍 gh-ost 是一款由GitHub开发的在线DDL（Online Data Definition Language）变更工具，专门用于MySQL数据库 。它允许在不锁定表的情况下执行数据库模式变更，从而避免了传统ALTER TABLE命令可能带来的长时间锁表问题，这对于高可用性要求严格的生产环境尤为重要。它通过无触发器 （trigger-less）的方式实现表结构变更，减少了对数据库性能的影响，同时支持暂停、限速、动态配置等功能。相较于传统的 pt-online-schema-change，gh-ost 更安全、灵活，且对主库负载更低。 📖主要特点 其操作流程大致如下： 二：gh-ost 的三种模式架构 2.1 连接从库，在主库转换 这是 gh-ost 默认的工作模式，它会查看从库情况，找到集群的主库并且连接上去，对主库侵入最少。大体步骤是： 2.2 连接主库，在主库转换 需要使用 –allow-on-master 选项： 2.3 在从库上测试和转换 这种模式会在从库上做修改。gh-ost 仍然会连上主库，但所有操作都是在从库上做的，不会对主库产生任何影响。在操作过程中，gh-ost 也会不时地暂停，以便从库的数据可以保持最新。 –migrate-on-replica 选项让 gh-ost 直接在从库上修改表。最终的切换过程也是在从库正常复制的状态下完成的。 –test-on-replica 表明操作只是为了测试目的。在进行最终的切换操作之前，复制会被停止。原始表和临时表会相互切换，再切换回来，最终相当于原始表没被动过。主从复制暂停的状态下，你可以检查和对比这两张表中的数据。 三：下载安装： https://github.com/github/gh-ost/releases/latest 1.18已经支持MySQL 8.4了👍🏻 基本使用 🔥使用示例 1.添加新列 2.修改字段类型 3.添加索引 4.切换主库在主库故障转移时，支持动态切换： 💥注意事项权限要求 需要 SUPER、REPLICATION SLAVE、REPLICATION CLIENT 权限。对原表和临时表有 CREATE、DELETE、ALTER 权限。主键必须存在目标表必须包含主键或唯一索引。 外键和触发器gh-ost 不支持有外键约束或触发器的表。 大表操作超大表迁移时需关注磁盘空间（临时表会占用额外空间）和网络负载。

The post MYSQL线上数据库表归档工具推荐之gh-ost appeared first on 原立方.

]]>

一：gh-ost 介绍

gh-ost 是一款由GitHub开发的在线DDL（Online Data Definition Language）变更工具，专门用于MySQL数据库 。它允许在不锁定表的情况下执行数据库模式变更，从而避免了传统ALTER TABLE命令可能带来的长时间锁表问题，这对于高可用性要求严格的生产环境尤为重要。
它通过无触发器 （trigger-less）的方式实现表结构变更，减少了对数据库性能的影响，同时支持暂停、限速、动态配置等功能。相较于传统的 pt-online-schema-change，gh-ost 更安全、灵活，且对主库负载更低。

📖主要特点

  • 无锁表操作：与传统的ALTER TABLE不同，gh-ost不会长时间锁表，使得在生产环境中进行DDL变更更加安全。
  • 基于复制的迁移：gh-ost通过从库读取二进制日志来应用变更，这减少了对主库的压力。
  • 灵活的控制方式：支持动态调整速率限制、暂停/恢复操作等。
  • 模拟和预检查功能：提供dry-run选项用于测试变更效果，以及pre-flight checks确保操作的安全性。
  • 易于使用：虽然功能强大，但相对简单易用，适合DBA和技术人员快速上手。
  • 无触发器设计:不依赖数据库触发器，而是通过解析 MySQL 的 binlog 来同步数据变更，减少主库负载和潜在锁冲突。
  • 多种运行模式:可连接到主库（master）或副本库（replica），根据需求选择不同迁移策略。

其操作流程大致如下：

  1. 创建两张内部管理表：包括 _表名_gho 的“影子表”（Ghost Table，即变更后的新表）和 _表名_ghc 的“日志表”，用于记录心跳、进度等元信息。
  2. 复制存量与同步增量（双线程并行）：
    • 一个线程负责将原表的存量数据分批复制到影子表。
    • 同时，另一个线程模拟从库拉取Binlog，解析出原表上的所有INSERT, UPDATE, DELETE增量变更，并同步到影子表。
  3. 冲突处理策略：为保证双线程并行时数据一致，gh-ost 采用了特殊的语句改写策略：将复制线程的 INSERT 改写为 INSERT IGNORE，将 Binlog 中的 INSERT 改写为 REPLACE INTO。
  4. 原子切换 (Cut-over)：当数据同步完成，gh-ost会锁定原表并执行RENAME操作，瞬间将影子表替换为正式表。

二：gh-ost 的三种模式架构

2.1 连接从库，在主库转换

这是 gh-ost 默认的工作模式，它会查看从库情况，找到集群的主库并且连接上去，对主库侵入最少。大体步骤是：

  • 在主库上创建 _xxx_gho（和原表表结构一致）、_xxx_ghc（记录变更日志），并修改 _xxx_gho 表结构；
  • 从 slave 上读取二进制日志事件，将变更应用到主库上的 _xxx_gho 表；
  • 在主库上读源表的数据写入 _xxx_gho 表中；
  • 在主库上完成表切换。

2.2 连接主库，在主库转换

需要使用 –allow-on-master 选项：

  • 在主库上创建 _xxx_gho、_xxx_ghc，并修改 _xxx_gho 表结构；
  • 从主库上读取二进制日志事件，将变更应用到主库上的 _xxx_gho 表；
  • 在主库上读源表的数据写入 _xxx_gho 表中；
  • 在主库上完成表切换。

2.3 在从库上测试和转换

这种模式会在从库上做修改。gh-ost 仍然会连上主库，但所有操作都是在从库上做的，不会对主库产生任何影响。在操作过程中，gh-ost 也会不时地暂停，以便从库的数据可以保持最新。

–migrate-on-replica 选项让 gh-ost 直接在从库上修改表。最终的切换过程也是在从库正常复制的状态下完成的。

–test-on-replica 表明操作只是为了测试目的。在进行最终的切换操作之前，复制会被停止。原始表和临时表会相互切换，再切换回来，最终相当于原始表没被动过。主从复制暂停的状态下，你可以检查和对比这两张表中的数据。

三：下载安装：

https://github.com/github/gh-ost/releases/latest

1.18已经支持MySQL 8.4了👍🏻

chmod +x gh-ost

基本使用

gh-ost \
  --host=<主库地址> \
  --port=<主库端口> \
  --user=<用户名> \
  --password=<密码> \
  --database=<数据库名> \
  --table=<表名> \
  --alter="<DDL语句>" \
  --execute

🔥关键参数说明
参数	说明
--alter	需要执行的 DDL 语句（如 ADD COLUMN，DROP INDEX 等）
--execute	实际执行迁移（默认是 dry-run 模式）
--allow-on-master	允许直接连接主库（默认连接到副本库）
--max-load=<metrics>	设置负载阈值（如 Threads_running=50）
--chunk-size=<rows>	每次迁移的数据块大小（默认 1000）
--critical-load=<metrics>	负载超限时终止操作
--switch-to-rbr	自动将副本库的 binlog 格式改为 ROW
--postpone-cut-over-flag-file=<path>	通过文件控制是否延迟切换表
--throttle-control-replicas	指定需要监控的副本库列表
--tmpdir	指定临时文件目录

🔥使用示例

1.添加新列

gh-ost \
  --host=127.0.0.1 \
  --port=3306 \
  --user=admin \
  --password=secret \
  --database=mydb \
  --table=orders \
  --alter="ADD COLUMN comment VARCHAR(255)" \
  --execute

2.修改字段类型

gh-ost \
  --alter="MODIFY COLUMN amount DECIMAL(10,2)" \
  --host=127.0.0.1 \
  --execute

3.添加索引

gh-ost \
  --alter="ADD INDEX idx_created_at (created_at)" \
  --host=127.0.0.1 \
  --execute

4.切换主库
在主库故障转移时，支持动态切换：

gh-ost \
  --assume-master-host=<new_master_host:port> \
  --execute

💥注意事项
权限要求

需要 SUPER、REPLICATION SLAVE、REPLICATION CLIENT 权限。
对原表和临时表有 CREATE、DELETE、ALTER 权限。
主键必须存在
目标表必须包含主键或唯一索引。

外键和触发器
gh-ost 不支持有外键约束或触发器的表。

大表操作
超大表迁移时需关注磁盘空间（临时表会占用额外空间）和网络负载。

The post MYSQL线上数据库表归档工具推荐之gh-ost appeared first on 原立方.

]]> https://www.atomic-cube.cn/mysql%e7%ba%bf%e4%b8%8a%e6%95%b0%e6%8d%ae%e5%ba%93%e8%a1%a8%e5%bd%92%e6%a1%a3%e5%b7%a5%e5%85%b7%e6%8e%a8%e8%8d%90%e4%b9%8bgh-ost/feed/ 0 微服务全套docker-compose.yaml https://www.atomic-cube.cn/%e5%be%ae%e6%9c%8d%e5%8a%a1%e5%85%a8%e5%a5%97docker-compose-yaml/ https://www.atomic-cube.cn/%e5%be%ae%e6%9c%8d%e5%8a%a1%e5%85%a8%e5%a5%97docker-compose-yaml/#respond Wed, 17 Jun 2026 12:11:58 +0000 https://www.atomic-cube.cn/?p=1417 go-zero微服务开发，本地微服务开发环境

The post 微服务全套docker-compose.yaml appeared first on 原立方.

]]> 这份 docker-compose.yml 定义了一套完整的 go-zero 微服务开发环境，覆盖了服务发现、消息队列、数据存储、监控追踪、日志中心等核心基础设施。它让开发者无需在本地繁琐安装配置，即可快速启动一套微服务所需的所有中间件，专注于业务代码开发

该项目存在的意义，旨在于本地docker快速搭建微服务环境

github地址：https://github.com/EvansYe2/microservice-docker-compose-deploy

一、服务发现（etcd）

容器：etcd

  • 作用：etcd 是分布式键值存储，在 go-zero 中充当 服务注册与发现中心。每个微服务启动时将自己注册到 etcd，其他服务通过 etcd 获取对方地址，实现自动路由。
  • 配置：单节点模式，对外暴露 2379 端口供客户端（go-zero 服务）访问。
  • 协作：go-zero 服务通过 etcd 客户端连接 etcd:2379 完成注册与发现。

二、消息队列

1. Kafka 生态（Kafka + Zookeeper + Kafka-UI）

  • Zookeeper：Kafka 依赖 ZooKeeper 管理集群元数据、Broker 选举等。
  • Kafka：高吞吐量分布式消息队列，用于 异步解耦、削峰填谷、事件驱动。go-zero 中的异步任务（如发邮件、订单状态变更）可通过 Kafka 生产消费。
  • Kafka-UI：Web 管理界面，可查看 Topic、消息、消费者组状态，便于开发调试。
  • 协作：go-zero 服务作为生产者将消息投递到 Kafka，消费者从 Kafka 拉取处理；Kafka-UI 连接 Kafka 和 Zookeeper 提供可视化。

2. Beanstalkd 生态（Beanstalkd + Beanstalkd-Console）

  • Beanstalkd：轻量级 延迟队列，专门处理延时任务（如订单超时未支付自动取消）。
  • Beanstalkd-Console：Web 管理界面，查看队列、任务统计。
  • 协作：go-zero 服务可将延时任务投递到 Beanstalkd，消费者在指定时间后取出执行。

三、数据库与缓存

  • MySQL：关系型数据库，存储业务数据（用户、订单等）。
  • Redis：高性能内存数据库，用作 缓存、分布式锁、会话存储、计数器 等。
  • 协作：go-zero 服务通过 GORM 或原生 SQL 操作 MySQL，通过 go-redis 操作 Redis。

四、监控与可观测性

1. Prometheus + Grafana

  • Prometheus：时序数据库，从 go-zero 服务抓取指标（请求量、延迟、错误率），存储为时间序列数据。
    • 配置文件 prometheus.yml 和 targets.json 定义了抓取规则和目标（需列出具体服务端点）。
  • Grafana：可视化面板，连接 Prometheus 展示图表、仪表盘，便于分析系统状态。
  • 协作：go-zero 服务暴露 /metrics 端点，Prometheus 定期拉取；Grafana 读取 Prometheus 数据并展示。

2. Jaeger（链路追踪）

  • Jaeger：分布式链路追踪系统，跟踪一个请求在多个微服务间的完整调用链，帮助定位性能瓶颈和故障点。
  • 存储：将链路数据写入 Elasticsearch（通过 SPAN_STORAGE_TYPE=elasticsearch 配置）。
  • 协作：go-zero 服务通过 OpenTelemetry 或 Jaeger 客户端将 trace 数据发送到 Jaeger 收集器（端口 14250/14268），Jaeger UI（端口 16686）提供查询界面。

五、日志中心（ELK + Filebeat + go-stash）

日志流完整路径：

Docker 容器日志 → Filebeat → Kafka → go-stash → Elasticsearch → Kibana

1. Filebeat（日志采集）

  • 读取宿主机 Docker 容器日志（/var/lib/docker/containers/*/*.log），将日志发送到 Kafka 的 go-zero-logs Topic。
  • 配置文件 filebeat.yml 定义了输出目标（Kafka 地址、Topic 等）。

2. Kafka（日志缓冲）

  • 作为日志中转站，削峰填谷，确保日志不会因突发流量丢失。

3. go-stash（日志处理与写入）

  • 从 Kafka 消费日志，按照配置规则处理后写入 Elasticsearch。
  • 配置 config.yaml 中指定了 Kafka 和 Elasticsearch 地址、索引格式（如 go-zero-logs-2006.01.02）。

4. Elasticsearch（日志存储）

  • 分布式搜索引擎，存储日志数据，支持快速检索。

5. Kibana（日志可视化）

  • Elasticsearch 的 Web 界面，用于查询、分析、可视化日志。

协作总结

  • 所有微服务的日志（通过 stdout/stderr）被 Docker 捕获，Filebeat 采集后发往 Kafka；go-stash 消费并写入 ES；开发者通过 Kibana 统一查看、搜索日志。

六、整体协作关系图（数据流）

阶段组件说明
服务启动go-zero 服务 → etcd注册自己
业务调用go-zero 服务 → MySQL / Redis数据读写
异步任务go-zero 服务 → Kafka / Beanstalkd发送消息或延时任务
监控Prometheus → go-zero 服务拉取 /metrics
链路追踪go-zero 服务 → Jaeger发送 trace
日志Filebeat → Kafka → go-stash → Elasticsearch → Kibana采集、传输、存储、展示
version: '3.8'

networks:
  go-zero-network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

volumes:
  etcd-data:
  mysql-data:
  redis-data:
  kafka-data:
  prometheus-data:
  grafana-data:
  jaeger-data:
  elasticsearch-data:
  go-stash:

services:
  # ==================== Service Discovery ====================
  etcd:
    image: quay.io/coreos/etcd:v3.5.10
    container_name: etcd
    restart: unless-stopped
    environment:
      - ETCD_NAME=etcd0
      - ETCD_DATA_DIR=/etcd-data
      - ETCD_LISTEN_CLIENT_URLS=http://0.0.0.0:2379
      - ETCD_ADVERTISE_CLIENT_URLS=http://etcd:2379
      - ETCD_LISTEN_PEER_URLS=http://0.0.0.0:2380
      - ETCD_INITIAL_ADVERTISE_PEER_URLS=http://etcd:2380
      - ETCD_INITIAL_CLUSTER=etcd0=http://etcd:2380
      - ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster
      - ETCD_INITIAL_CLUSTER_STATE=new
    ports:
      - "2379:2379"
      - "2380:2380"
    volumes:
      - ./etcd-data:/etcd-data
    networks:
      - go-zero-network

  # ==================== Message Queue ====================
  #Kafka 依赖 ZooKeeper 来管理集群元数据、选举控制器等。它本身不参与业务消息，但却是 Kafka 正常工作的基础。
  zookeeper:
    image: zookeeper:3.9.5
    container_name: zookeeper
    restart: unless-stopped
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
      ZOO_MY_ID: 1
    ports:
      - "2181:2181"
    volumes:
      - ./zk-data:/var/lib/zookeeper/data
      - ./zk-datalog:/var/lib/zookeeper/log
    networks:
      - go-zero-network

  #Kafka 是一个高吞吐量分布式消息队列，用于 异步解耦、削峰填谷、事件驱动。go-zero 中的异步任务（如发送通知、订单处理）可以通过 Kafka 生产消费。
  kafka:
    image: apache/kafka:4.0.2
    container_name: kafka
    restart: unless-stopped
    depends_on:
      - zookeeper
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: broker,controller
      # 外部访问监听端口为 9092，容器内部使用不同的端口 9094
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9094,CONTROLLER://localhost:9093,PLAINTEXT_CONTAINER://kafka:9092
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9094,PLAINTEXT_CONTAINER://kafka:9092
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,PLAINTEXT_CONTAINER:PLAINTEXT
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@localhost:9093
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_NUM_PARTITIONS: 3
    ports:
      - "9092:9092"  # 容器内部之间使用的监听端口
      - "9094:9094"  # 容器外部访问监听端口
    volumes:
      - ./kafka-data:/var/lib/kafka/data
    networks:
      - go-zero-network

  #Kafka 的可视化 Web 管理界面，用于查看主题、消息、消费者组状态，方便开发和调试。
  kafka-ui:
    image: provectuslabs/kafka-ui:latest
    container_name: kafka-ui
    restart: unless-stopped
    depends_on:
      - kafka
    environment:
      KAFKA_CLUSTERS_0_NAME: local
      KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: kafka:9092
      KAFKA_CLUSTERS_0_ZOOKEEPER: zookeeper:2181
    ports:
      - "8080:8080"
    networks:
      - go-zero-network

  #Beanstalkd 是一个轻量级的 延迟队列，专门用于处理延时任务（如订单超时未支付自动取消）。
  beanstalkd:
    image: schickling/beanstalkd:latest
    container_name: beanstalkd
    restart: unless-stopped
    command: -l 0.0.0.0
    ports:
      - "11300:11300"
    networks:
      - go-zero-network

  #Beanstalkd 的 Web 管理界面，查看队列状态、任务统计等。
  beanstalkd-console:
    image: agaveapi/beanstalkd-console:latest
    container_name: beanstalkd-console
    restart: unless-stopped
    depends_on:
      - beanstalkd
    environment:
      BEANSTALKD_HOST: beanstalkd
      BEANSTALKD_PORT: 11300
    ports:
      - "8081:8080"
    networks:
      - go-zero-network

  # ==================== Database & Cache ====================
  mysql:
    image: mysql:8.0
    container_name: mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: go_zero
      MYSQL_USER: go_zero
      MYSQL_PASSWORD: go_zero123
    ports:
      - "3306:3306"
    volumes:
      - ./mysql-data:/var/lib/mysql
    networks:
      - go-zero-network

  redis:
    image: redis:7.2-alpine
    container_name: redis
    restart: unless-stopped
    command: redis-server --requirepass 123456
    ports:
      - "6379:6379"
    volumes:
      - ./redis-data:/data
    networks:
      - go-zero-network

  

  # ==================== Monitoring & Observability 监控业务====================
  #时序数据库，从 go-zero 服务抓取指标（请求量、延迟、错误率等），并存储为时间序列数据。
  #挂载了 prometheus.yml（抓取规则）和 targets.json（服务发现目标）。
  #targets.json 中应列出需要监控的服务端点（如 user-api:9081）。
  prometheus:
    image: prom/prometheus:v2.48.0
    container_name: prometheus
    restart: unless-stopped
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./prometheus/targets.json:/etc/prometheus/targets.json:ro
      - ./prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.enable-lifecycle'
    ports:
      - "9090:9090"
    networks:
      - go-zero-network

  #prometheus 的 ui 很难看，用来显示 prometheus 收集来的数据，查看prometheus监控数据
  #可视化面板，从 Prometheus 读取数据并展示为图表、仪表盘。
  grafana:
    image: grafana/grafana:10.2.0
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
      - GF_INSTALL_PLUGINS=grafana-piechart-panel
    volumes:
      - ./grafana-data:/var/lib/grafana
      - ./grafana/datasources:/etc/grafana/provisioning/datasources:ro
      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards:ro
    ports:
      - "3000:3000"
    networks:
      - go-zero-network

  #jaeger链路追踪 — Jaeger for tracing
  #分布式链路追踪系统，用于跟踪一个请求在多个微服务之间的完整调用链，定位性能瓶颈。
  #将链路数据存储在 Elasticsearch 中（SPAN_STORAGE_TYPE=elasticsearch）。
  jaeger:
    image: jaegertracing/all-in-one:1.53
    container_name: jaeger
    restart: unless-stopped
    environment:
      - COLLECTOR_OTLP_ENABLED=true
      - SPAN_STORAGE_TYPE=elasticsearch
      - ES_SERVER_URLS=http://elasticsearch:9200
    ports:
      - "5775:5775/udp"
      - "6831:6831/udp"
      - "6832:6832/udp"
      - "5778:5778"
      - "16686:16686"
      - "14268:14268"
      - "14250:14250"
      - "9411:9411"
    networks:
      - go-zero-network

  # ==================== Logging Stack ====================
  #存储收集的日志，分布式搜索引擎，用于存储和索引日志数据，支持快速检索。
  #Docker 容器日志 → Filebeat → Kafka → (go-stash/Logstash) → Elasticsearch → Kibana
  elasticsearch:
    image: elasticsearch:7.17.15
    container_name: elasticsearch
    restart: unless-stopped
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms512m -Xmx512m
      - xpack.security.enabled=false
    ports:
      - "9200:9200"
      - "9300:9300"
    volumes:
      - ./elasticsearch-data:/usr/share/elasticsearch/data
    networks:
      - go-zero-network

  #显示 elasticsearch日志，Elasticsearch 的可视化界面，用于查询、分析日志。
  kibana:
    image: kibana:7.17.15
    container_name: kibana
    restart: unless-stopped
    environment:
      ELASTICSEARCH_HOSTS: http://elasticsearch:9200
    ports:
      - "5601:5601"
    networks:
      - go-zero-network

  #消费kafka中filebeat收集的数据输出到es - The data output collected by FileBeat in Kafka is output to ES
  go-stash:
    image: kevinwan/go-stash:1.1.1
    container_name: go-stash
    environment:
      # 时区上海 - Time zone Shanghai (Change if needed)
      TZ: Asia/Shanghai
    restart: always
    volumes:
      - ./go-stash/etc:/app/etc
    networks:
      - go-zero-network
    depends_on:
      - elasticsearch
      - kafka


  #收集业务数据，收集日志到 kafka
  #轻量级日志采集器，读取 Docker 容器的日志（/var/lib/docker/containers/*/*.log），并将日志发送到 Kafka。
  #挂载了 filebeat.yml 定义输出目标（Kafka topic go-zero-logs）。
  #Docker 容器日志 → Filebeat → Kafka → (go-stash/Logstash) → Elasticsearch → Kibana
  filebeat:
    image: docker.elastic.co/beats/filebeat:7.17.15
    container_name: filebeat
    restart: unless-stopped
    user: root
    volumes:
      - ./filebeat/filebeat.yml:/usr/share/filebeat/filebeat.yml:ro
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - go-zero-network

Prometheus 配置文件 (prometheus/prometheus.yml)

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'file_ds'
    file_sd_configs:
      - files:
          - /etc/prometheus/targets.json
        refresh_interval: 30s

Prometheus 服务发现目标 (prometheus/targets.json)

[
  {
    "targets": ["user-api:9081"],
    "labels": {
      "job": "user-api",
      "app": "user-api",
      "env": "test"
    }
  },
  {
    "targets": ["user-rpc:9091"],
    "labels": {
      "job": "user-rpc",
      "app": "user-rpc",
      "env": "test"
    }
  },
  {
    "targets": ["order-api:9082"],
    "labels": {
      "job": "order-api",
      "app": "order-api",
      "env": "test"
    }
  },
  {
    "targets": ["order-rpc:9092"],
    "labels": {
      "job": "order-rpc",
      "app": "order-rpc",
      "env": "test"
    }
  }
]

Grafana 数据源配置 (grafana/datasources/prometheus.yaml)

apiVersion: 1
datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true

Filebeat 配置文件 (filebeat/filebeat.yml)

filebeat.inputs:
  - type: container
    paths:
      - /var/lib/docker/containers/*/*.log

output.kafka:
  hosts: ["kafka:9092"]
  topic: "go-zero-logs"
  partition.round_robin:
    reachable_only: true

logging.level: info

go-stash/etc/config.yaml

Clusters:
  - Input:
      Kafka:
        Name: gostash
        Brokers:
          - kafka:9092
        Topics:
          - go-zero-logs
        Group: go-stash-group
        Consumer:
          Offset: first
    Output:
      ElasticSearch:
        Hosts:
          - http://elasticsearch:9200
        Index: go-zero-logs-{{yyyy-MM-dd}}
        # 可选：索引滚动策略等

Go-zero 服务配置示例 (config.yaml)

# 服务发现
Etcd:
  Hosts:
    - etcd:2379
  Key: user.rpc

# 链路追踪
Telemetry:
  Name: user-api
  Endpoint: http://jaeger:14268/api/traces
  Sampler: 1.0
  Batcher: jaeger

# Prometheus 监控
Prometheus:
  Host: 0.0.0.0
  Port: 9081
  Path: /metrics

# MySQL
DB:
  DataSource: root:123456@tcp(mysql:3306)/go_zero?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghai

# Redis
Redis:
  Host: redis:6379
  Pass: 123456
  Type: node

# Kafka 配置
Kafka:
  Brokers:
    - kafka:9092
  GroupID: go-zero-group
  Topic: order-topic

# Beanstalkd 配置
Beanstalkd:
  Endpoint: beanstalkd:11300
  Tube: delay-tube
# 创建配置文件目录
mkdir -p prometheus grafana/datasources filebeat

# 将上述配置文件写入对应目录
# 启动所有容器
docker-compose up -d

验证服务状态
docker-compose ps

访问各服务 UI

服务地址说明
etcdhttp://localhost:2379服务注册发现（etcd API）
Kafka UIhttp://localhost:8080Kafka 管理界面
Beanstalkd Consolehttp://localhost:8081延迟队列管理界面
Redis Commanderhttp://localhost:8082Redis 管理界面
Prometheushttp://localhost:9090监控指标收集
Grafanahttp://localhost:3000监控可视化（admin/admin）从 Prometheus 读取数据并展示为图表、仪表盘。
Jaeger UIhttp://localhost:16686链路追踪查询
Kibanahttp://localhost:5601日志分析,查看es日志
MySQLlocalhost:3306数据库
Redislocalhost:6379缓存
etcd-keeperhttp://localhost:8080

访问 kibana http://127.0.0.1:5601/ ， 创建日志索引

点击左上角菜单(三个横线那个东东)，找到 Analytics – > 点击 discover

然后在当前页面，Create index pattern->输入 go-zero-logs-* -> Next Step ->选择 @timestamp->Create index pattern

然后点击左上角菜单，找到 Analytics->点击 discover ，日志都显示了 （如果不显示，就去排查 filebeat、go-stash，使用 docker logs -f filebeat 查看）

The post 微服务全套docker-compose.yaml appeared first on 原立方.

]]> https://www.atomic-cube.cn/%e5%be%ae%e6%9c%8d%e5%8a%a1%e5%85%a8%e5%a5%97docker-compose-yaml/feed/ 0 Kubectl 命令参考手册 https://www.atomic-cube.cn/kubectl-%e5%91%bd%e4%bb%a4%e5%8f%82%e8%80%83%e6%89%8b%e5%86%8c/ https://www.atomic-cube.cn/kubectl-%e5%91%bd%e4%bb%a4%e5%8f%82%e8%80%83%e6%89%8b%e5%86%8c/#respond Tue, 16 Jun 2026 00:00:22 +0000 https://www.atomic-cube.cn/?p=2016 Kubectl 命令参考手册

The post Kubectl 命令参考手册 appeared first on 原立方.

]]> K8S 命令老是忘记，索性整理了常用的 kubectl 命令，方便日常 Kubernetes 集群管理使用。

一：基础命令

1.1 查看集群信息

# 查看集群信息
kubectl cluster-info

# 查看 Kubernetes 版本
kubectl version

# 查看 API 资源列表
kubectl api-resources

# 查看 API 版本
kubectl api-versions

1.2 查看节点信息

# 查看所有节点
kubectl get nodes

# 查看节点详细信息
kubectl get nodes -o wide

# 查看节点详细信息（JSON/YAML）
kubectl get nodes -o json
kubectl get nodes -o yaml

# 查看特定节点
kubectl get node <node-name>

# 描述节点
kubectl describe node <node-name>

二：资源查看

2.1 Pod 相关：

# 查看所有命名空间的 Podkubectl get pods --all-namespaces
kubectl get pods -A

# 查看指定命名空间的 Podkubectl get pods -n <namespace>

# 查看 Pod 详细信息
kubectl get pods -o wide

# 查看 Pod 详细信息（JSON/YAML）
kubectl get pods -o json
kubectl get pods -o yaml

# 查看特定 Podkubectl get pod <pod-name> -n <namespace>

# 查看 Pod 标签
kubectl get pods --show-labels

2.2 Deployment 相关：

# 查看所有 Deploymentkubectl get deployments
kubectl get deploy

# 查看 Deployment 详细信息
kubectl get deployments -o wide

# 查看特定 Deploymentkubectl get deployment <deployment-name> -n <namespace>

2.3 Service 相关：

# 查看所有 Servicekubectl get services
kubectl get svc

# 查看 Service 详细信息
kubectl get services -o wide

# 查看特定 Servicekubectl get service <service-name> -n <namespace>

2.4 其他资源：

# 查看所有资源类型
kubectl get all

# 查看 ConfigMapkubectl get configmaps
kubectl get cm

# 查看 Secretkubectl get secrets

# 查看 PersistentVolumekubectl get pv

# 查看 PersistentVolumeClaimkubectl get pvc

# 查看 Ingresskubectl get ingress
kubectl get ing

# 查看 Jobkubectl get jobs

# 查看 CronJobkubectl get cronjobs

# 查看 DaemonSetkubectl get daemonsets
kubectl get ds

# 查看 StatefulSetkubectl get statefulsets
kubectl get sts

三：资源操作

3.1 创建资源

# 从文件创建资源
kubectl create -f <file.yaml>

# 从 URL 创建资源
kubectl create -f <url>

# 从目录创建所有资源
kubectl create -f <directory>/

# 创建命名空间
kubectl create namespace <namespace-name>

3.2 应用资源

# 应用配置文件（推荐）
kubectl apply -f <file.yaml>

# 应用目录下所有文件
kubectl apply -f <directory>/

# 应用并记录配置
kubectl apply -f <file.yaml> --record

# 强制替换资源
kubectl apply -f <file.yaml> --force

3.3 删除资源

# 删除资源
kubectl delete -f <file.yaml>

# 删除特定资源
kubectl delete pod <pod-name> -n <namespace>
kubectl delete deployment <deployment-name> -n <namespace>
kubectl delete service <service-name> -n <namespace>

# 删除所有资源
kubectl delete all --all -n <namespace>

# 删除命名空间（会删除命名空间下所有资源）
kubectl delete namespace <namespace-name>

# 强制删除 Podkubectl delete pod <pod-name> --force --grace-period=0

3.4 编辑资源

# 编辑资源（使用默认编辑器）
kubectl edit pod <pod-name> -n <namespace>
kubectl edit deployment <deployment-name> -n <namespace>

# 编辑并应用
kubectl edit -f <file.yaml>

3.5 替换资源

# 替换资源
kubectl replace -f <file.yaml>

# 强制替换
kubectl replace -f <file.yaml> --force

四：调试和日志

4.1查看日志

# 查看 Pod 日志
kubectl logs <pod-name> -n <namespace>

# 查看前 N 行日志
kubectl logs <pod-name> -n <namespace> --tail=100

# 实时跟踪日志
kubectl logs <pod-name> -n <namespace> -f

# 查看之前容器的日志
kubectl logs <pod-name> -n <namespace> --previous

# 查看多容器 Pod 中特定容器的日志
kubectl logs <pod-name> -c <container-name> -n <namespace>

# 查看指定时间范围的日志
kubectl logs <pod-name> -n <namespace> --since=1h
kubectl logs <pod-name> -n <namespace> --since-time="2024-01-01T00:00:00Z"

4.2 进入容器

# 进入 Pod 容器（交互式）
kubectl exec -it <pod-name> -n <namespace> -- /bin/bash
kubectl exec -it <pod-name> -n <namespace> -- /bin/sh

# 在容器中执行命令
kubectl exec <pod-name> -n <namespace> -- <command>

# 在特定容器中执行命令
kubectl exec <pod-name> -c <container-name> -n <namespace> -- <command>

4.3 调试工具

# 查看 Pod 详细信息
kubectl describe pod <pod-name> -n <namespace>

# 查看事件
kubectl get events -n <namespace> --sort-by='.lastTimestamp'

# 查看资源使用情况
kubectl top nodes
kubectl top pods -n <namespace>

# 查看资源使用情况（所有命名空间）
kubectl top pods --all-namespaces

五: 配置管理

5.1 ConfigMap 操作

# 查看 ConfigMapkubectl get configmap <configmap-name> -n <namespace>

# 查看 ConfigMap 内容
kubectl get configmap <configmap-name> -n <namespace> -o yaml

# 从文件创建 ConfigMapkubectl create configmap <configmap-name> --from-file=<file-path>

# 从目录创建 ConfigMapkubectl create configmap <configmap-name> --from-file=<directory>/

# 从字面量创建 ConfigMapkubectl create configmap <configmap-name> --from-literal=key1=value1 --from-literal=key2=value2

# 编辑 ConfigMapkubectl edit configmap <configmap-name> -n <namespace>

# 删除 ConfigMapkubectl delete configmap <configmap-name> -n <namespace>

5.2 Secret 操作

# 查看 Secretkubectl get secret <secret-name> -n <namespace>

# 查看 Secret 内容（Base64 编码）
kubectl get secret <secret-name> -n <namespace> -o yaml

# 解码 Secretkubectl get secret <secret-name> -n <namespace> -o jsonpath='{.data.<key>}' | base64 -d

# 从文件创建 Secretkubectl create secret generic <secret-name> --from-file=<file-path>

# 从字面量创建 Secretkubectl create secret generic <secret-name> --from-literal=username=admin --from-literal=password=secret

# 从 Docker 注册表创建 Secretkubectl create secret docker-registry <secret-name> --docker-server=<server> --docker-username=<username> --docker-password=<password>

# 编辑 Secretkubectl edit secret <secret-name> -n <namespace>

# 删除 Secretkubectl delete secret <secret-name> -n <namespace>

5.3 端口转发

# 转发 Pod 端口到本地
kubectl port-forward <pod-name> <local-port>:<pod-port> -n <namespace>

# 转发 Service 端口到本地
kubectl port-forward service/<service-name> <local-port>:<service-port> -n <namespace>

# 转发 Deployment 端口到本地
kubectl port-forward deployment/<deployment-name> <local-port>:<container-port> -n <namespace>

# 示例：转发 MySQL 服务
kubectl port-forward service/mysql 3306:3306 -n default

5.4 执行命令

# 在 Pod 中执行命令
kubectl exec <pod-name> -n <namespace> -- <command>

# 在 Pod 中执行交互式命令
kubectl exec -it <pod-name> -n <namespace> -- <command>

# 在特定容器中执行命令
kubectl exec <pod-name> -c <container-name> -n <namespace> -- <command>

# 示例
kubectl exec my-pod -- ls /tmp
kubectl exec -it my-pod -- /bin/bash

5.5 标签和选择器

# 查看资源标签
kubectl get pods --show-labels

# 给资源添加标签
kubectl label pod <pod-name> app=myapp -n <namespace>

# 更新标签
kubectl label pod <pod-name> app=newapp --overwrite -n <namespace>

# 删除标签
kubectl label pod <pod-name> app- -n <namespace>

# 使用标签选择器查询
kubectl get pods -l app=myapp -n <namespace>
kubectl get pods -l 'app in (myapp,yourapp)' -n <namespace>
kubectl get pods -l 'app=myapp,version=v1' -n <namespace>

5.6 滚动更新

# 查看滚动更新状态
kubectl rollout status deployment/<deployment-name> -n <namespace>

# 查看滚动更新历史
kubectl rollout history deployment/<deployment-name> -n <namespace>

# 回滚到上一个版本
kubectl rollout undo deployment/<deployment-name> -n <namespace>

# 回滚到指定版本
kubectl rollout undo deployment/<deployment-name> --to-revision=<revision-number> -n <namespace>

# 暂停滚动更新
kubectl rollout pause deployment/<deployment-name> -n <namespace>

# 恢复滚动更新
kubectl rollout resume deployment/<deployment-name> -n <namespace>

# 扩展 Deploymentkubectl scale deployment/<deployment-name> --replicas=<number> -n <namespace>

5.7 资源描述

# 描述 Podkubectl describe pod <pod-name> -n <namespace>

# 描述 Deploymentkubectl describe deployment <deployment-name> -n <namespace>

# 描述 Servicekubectl describe service <service-name> -n <namespace>

# 描述 Nodekubectl describe node <node-name>

# 描述命名空间
kubectl describe namespace <namespace-name>

5.8 事件查看

# 查看所有事件
kubectl get events -n <namespace>

# 查看所有命名空间的事件
kubectl get events --all-namespaces

# 按时间排序查看事件
kubectl get events -n <namespace> --sort-by='.lastTimestamp'

# 查看特定资源的事件
kubectl get events --field-selector involvedObject.name=<pod-name> -n <namespace>

# 实时监控事件
kubectl get events -n <namespace> --watch

5.9 命名空间管理

# 查看所有命名空间
kubectl get namespaces
kubectl get ns

# 查看命名空间详细信息
kubectl get namespace <namespace-name> -o yaml

# 创建命名空间
kubectl create namespace <namespace-name>

# 删除命名空间
kubectl delete namespace <namespace-name>

# 切换到命名空间（使用 kubectx/kubens 工具）
# 或者使用上下文
kubectl config set-context --current --namespace=<namespace-name>

5.10 上下文和配置

# 查看当前上下文
kubectl config current-context

# 查看所有上下文
kubectl config get-contexts

# 切换上下文
kubectl config use-context <context-name>

# 查看配置
kubectl config view

# 查看特定上下文的配置
kubectl config view --context=<context-name>

# 设置默认命名空间
kubectl config set-context --current --namespace=<namespace-name>

# 查看集群信息
kubectl config view --minify

# 重命名上下文
kubectl config rename-context <old-name> <new-name>

六: 实用技巧

6.1 输出格式

# JSON 格式
kubectl get pods -o json

# YAML 格式
kubectl get pods -o yaml

# 自定义列
kubectl get pods -o custom-columns=NAME:.metadata.name,STATUS:.status.phase

# JSONPath
kubectl get pods -o jsonpath='{.items[*].metadata.name}'

# 表格格式（默认）
kubectl get pods

6.2 过滤和搜索

# 按标签过滤
kubectl get pods -l app=myapp

# 按字段选择器过滤
kubectl get pods --field-selector status.phase=Running

# 搜索资源
kubectl get all | grep <keyword>

6.3 批量操作

# 删除所有命名空间下的所有 Podkubectl delete pods --all --all-namespaces

# 删除所有命名空间下的所有 Deploymentkubectl delete deployments --all --all-namespaces

# 删除命名空间下的所有资源
kubectl delete all --all -n <namespace>

6.4 导出资源

<em># 导出资源为 YAMLkubectl get pod <pod-name> -n <namespace> -o yaml > pod.yaml</em>

<em># 导出资源为 JSONkubectl get pod <pod-name> -n <namespace> -o json > pod.json</em>

<em># 导出并移除集群特定信息</em>
kubectl get pod <pod-name> -n <namespace> -o yaml --export > pod.yaml

6.5 补丁操作

<em># 使用 JSON 补丁</em>
kubectl patch pod <pod-name> -p '{"spec":{"containers":[{"name":"mycontainer","image":"newimage"}]}}'

<em># 使用策略性合并补丁</em>
kubectl patch deployment <deployment-name> -p '{"spec":{"replicas":3}}'

<em># 使用 JSON 补丁文件</em>
kubectl patch pod <pod-name> --patch-file=patch.json

七: 常用组合命令

<em># 查看 Pod 并显示标签</em>
kubectl get pods --show-labels -n <namespace>

<em># 查看所有命名空间的资源</em>
kubectl get all --all-namespaces

<em># 查看资源并持续监控</em>
kubectl get pods -w -n <namespace>

<em># 查看资源并排序</em>
kubectl get pods --sort-by=.metadata.creationTimestamp -n <namespace>

<em># 查看资源使用情况</em>
kubectl top pods --sort-by=memory -n <namespace>

<em># 查看资源并过滤</em>
kubectl get pods -n <namespace> | grep <keyword>

<em># 查看资源并导出</em>
kubectl get deployment <deployment-name> -n <namespace> -o yaml > deployment.yaml

八: 故障排查命令

<em># 查看 Pod 状态和事件</em>
kubectl describe pod <pod-name> -n <namespace>

<em># 查看 Pod 日志</em>
kubectl logs <pod-name> -n <namespace> --previous

<em># 查看所有命名空间的错误 Podkubectl get pods --all-namespaces --field-selector status.phase!=Running</em>

<em># 查看节点资源使用</em>
kubectl top nodes

<em># 查看集群事件</em>
kubectl get events --all-namespaces --sort-by='.lastTimestamp'

<em># 检查 API 服务器连接</em>
kubectl cluster-info dump

<em># 查看资源配额</em>
kubectl describe quota -n <namespace>

注意事项

1. 命名空间：大多数命令需要指定 -n <namespace> 或 --namespace=<namespace>，如果不指定则使用默认命名空间（通常是 default）

2. 资源名称：可以使用完整名称或简写形式，例如：

  • pods 或 po
  • services 或 svc
  • deployments 或 deploy
  • namespaces 或 ns

3. 输出格式：使用 -o 参数指定输出格式，常用格式包括：

  • yaml
  • json
  • wide
  • custom-columns

4. 强制删除：删除资源时，如果 Pod 处于 Terminating 状态，可以使用：

kubectl delete pod <pod-name> --force --grace-period=0 -n <namespace>

5. 权限：某些命令可能需要相应的 RBAC 权限，确保当前用户有足够的权限执行操作

参考资源

The post Kubectl 命令参考手册 appeared first on 原立方.

]]> https://www.atomic-cube.cn/kubectl-%e5%91%bd%e4%bb%a4%e5%8f%82%e8%80%83%e6%89%8b%e5%86%8c/feed/ 0 本地安装Minikube部署Kubernetes环境 https://www.atomic-cube.cn/apple-chip%e5%ae%89%e8%a3%85minikube/ https://www.atomic-cube.cn/apple-chip%e5%ae%89%e8%a3%85minikube/#respond Thu, 11 Jun 2026 23:20:00 +0000 https://www.atomic-cube.cn/?p=1685 Minikube 是一个工具，它为本地环境提供了一种轻量化的 Kubernetes 集群实现。通过 Minikube，用户可以在本地机器上快速启动并运行一个 Kubernetes 环境，用来学习、测试和开发。Minikube支持Kubernetes的所有主要功能，包括Dashboard、DNS、容器运行时（如Docker、containerd、CRI-O）等。这种本地化的 Kubernetes 环境主要为开发者提供了便捷，不再需要花费额外的精力去搭建和维护一个庞大的远程集群。 1.安装 Docker Desktop 作为官方推荐的容器化平台，安装Docker Desktop能让你顺利使用Docker驱动。 2. 安装 Minikube 和 kubectl 使用 Homebrew 可以一键安装这两个核心工具。 使用 Homebrew 安装：在终端中执行以下命令： 验证安装：运行以下命令，确认版本信息能正常输出： 3. 启动你的 Kubernetes 集群 启动命令是最关键的一步。对于国内的网络环境，强烈建议配置阿里云的镜像加速，这能显著提升启动速度和成功率。 推荐方案：使用 Docker 驱动 + 阿里云镜像/dl.k8s.io加速：使用以下命令启动 Minikube： 4.验证并开始使用 如果看到节点状态为 Ready，就说明你的单节点 Kubernetes 集群已经成功运行了。 5. (可选) 启用 Minikube 插件 Minikube 提供了许多插件来扩展功能，最常用的是仪表盘（Dashboard）。 启用仪表盘 (Dashboard)：执行以下命令，浏览器将自动打开 Kubernetes 的 Web UI 界面，方便你直观地管理集群。 更多插件：执行 minikube addons list 可以查看所有可用插件，例如 ingress 用于管理入站网络流量。 […]

The post 本地安装Minikube部署Kubernetes环境 appeared first on 原立方.

]]> Minikube 是一个工具，它为本地环境提供了一种轻量化的 Kubernetes 集群实现。通过 Minikube，用户可以在本地机器上快速启动并运行一个 Kubernetes 环境，用来学习、测试和开发。Minikube支持Kubernetes的所有主要功能，包括Dashboard、DNS、容器运行时（如Docker、containerd、CRI-O）等。这种本地化的 Kubernetes 环境主要为开发者提供了便捷，不再需要花费额外的精力去搭建和维护一个庞大的远程集群。

1.安装 Docker Desktop

作为官方推荐的容器化平台，安装Docker Desktop能让你顺利使用Docker驱动。

  • 下载与安装：访问 Docker 官网，我使用的是Mac M2，需要下载适用于 Apple Chip 的安装包并进行安装。
  • 启动与验证：安装完成后，启动 Docker Desktop，并确保它在后台正常运行，状态显示为 Running。

2. 安装 Minikube 和 kubectl

使用 Homebrew 可以一键安装这两个核心工具。

使用 Homebrew 安装：在终端中执行以下命令：

brew install kubectl
brew install minikube


验证安装：运行以下命令，确认版本信息能正常输出：

kubectl version --client
minikube version

3. 启动你的 Kubernetes 集群

启动命令是最关键的一步。对于国内的网络环境，强烈建议配置阿里云的镜像加速，这能显著提升启动速度和成功率。

推荐方案：使用 Docker 驱动 + 阿里云镜像/dl.k8s.io加速：使用以下命令启动 Minikube：

docker配置使用国内镜像源后，可直接运行：
minikube start --driver=docker

可以手动指定其他源，可尝试多次下载：
minikube start --driver=docker --kubernetes-version='v1.35.1' --binary-mirror='https://dl.k8s.io'

如出现下载失败或者下载超时，可采用以下方式彻底清除现有集群和缓存，然后重新执行上面的命令进行下载：
minikube delete --all --purge
rm -rf ~/.minikube   # 可选，彻底清理残留配置

4.验证并开始使用

minikube status
kubectl get nodes

如果看到节点状态为 Ready，就说明你的单节点 Kubernetes 集群已经成功运行了。

5. (可选) 启用 Minikube 插件

Minikube 提供了许多插件来扩展功能，最常用的是仪表盘（Dashboard）。

启用仪表盘 (Dashboard)：执行以下命令，浏览器将自动打开 Kubernetes 的 Web UI 界面，方便你直观地管理集群。

minikube addons enable dashboard
启用可能会失败：
# 拉取 dashboard 镜像
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/dashboard:v2.7.0

# 拉取 metrics-scraper 镜像
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-scraper:v1.0.8

将拉取下来的国内镜像，标记为 Kubernetes 期望的官方镜像名：
docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/dashboard:v2.7.0 kubernetes/dashboard:v2.7.0

docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-scraper:v1.0.8 kubernetes/metrics-scraper:v1.0.8

删除失败的 Pod，让它们重新创建
kubectl delete pod -n kubernetes-dashboard --all

kubectl get pods -n kubernetes-dashboard

minikube dashboard


更多插件：执行 minikube addons list 可以查看所有可用插件，例如 ingress 用于管理入站网络流量。

🧪 测试集群：部署一个 Nginx 应用

为了验证集群功能，可以尝试部署一个简单的 Nginx 应用。

  1. 创建 Nginx Deployment：
kubectl create deployment nginx --image=nginx:alpine

2.创建一个 Service 来暴露应用：

kubectl expose deployment nginx --type=NodePort --port=80

3.获取访问地址：运行以下命令获取服务的访问 URL，然后在浏览器中打开它，就能看到 Nginx 的欢迎页面了。

minikube service nginx --url

4.清理测试资源：测试完成后，可以删除 Deployment 和 Service 来释放资源。

kubectl delete service nginx
kubectl delete deployment nginx

常用 Minikube 命令
停止集群: minikube stop (保留数据，释放 CPU/内存)
暂停集群: minikube pause (快速暂停)
删除集群: minikube delete (彻底删除数据)
查看 Dashboard: minikube dashboard (打开 Web 界面)
查看插件列表: minikube addons list

The post 本地安装Minikube部署Kubernetes环境 appeared first on 原立方.

]]> https://www.atomic-cube.cn/apple-chip%e5%ae%89%e8%a3%85minikube/feed/ 0 VSCode ,codex,claude code使用 ‌oMLX‌ 本地模型 https://www.atomic-cube.cn/vs-code-%e4%b8%ad%e4%bd%bf%e7%94%a8-omlx-%e6%9c%ac%e5%9c%b0%e6%a8%a1%e5%9e%8b/ https://www.atomic-cube.cn/vs-code-%e4%b8%ad%e4%bd%bf%e7%94%a8-omlx-%e6%9c%ac%e5%9c%b0%e6%a8%a1%e5%9e%8b/#respond Sun, 07 Jun 2026 22:00:00 +0000 https://www.atomic-cube.cn/?p=1858 在 VS Code 中使用 ‌oMLX‌ 本地模型，主要依赖于 oMLX 提供的 ‌OpenAI / Anthropic 兼容 API 接口‌，通过配置 VS Code 的 AI 插件（如 Continue、Copilot Chat 等）连接到 oMLX 本地服务。 ✅ 核心步骤 🛠️ 在 VS Code 中配置 oMLX 的方法 一：使用 ‌Continue 插件‌（推荐） ✅ 优势：完全离线、代码不上传云端、支持工具调用与结构化输出 ‌。 本地使用截图，能用，够用(M2 16G+512G的macbook pro，请忽略token生成的速度)： 集成 Claude Code / Codex/OpenCode/OpenClaw oMLX 提供一键配置生成器，简化了与主流开发工具的集成：

The post VSCode ,codex,claude code使用 ‌oMLX‌ 本地模型 appeared first on 原立方.

]]> 在 VS Code 中使用 ‌oMLX‌ 本地模型，主要依赖于 oMLX 提供的 ‌OpenAI / Anthropic 兼容 API 接口‌，通过配置 VS Code 的 AI 插件（如 Continue、Copilot Chat 等）连接到 oMLX 本地服务。

✅ 核心步骤

  • ‌oMLX 仅支持 macOS + Apple Silicon（M1/M2/M3/M4/M5）‌，不支持 Windows 或 NVIDIA 显卡 ‌。
  • oMLX 启动后默认提供以下 API 接口：
    • OpenAI 兼容：http://localhost:8000/v1
    • Anthropic 兼容：http://localhost:8000

🛠️ 在 VS Code 中配置 oMLX 的方法

一：使用 ‌Continue 插件‌（推荐）

  1. ‌安装 Continue 插件‌
    • 打开 VS Code → 扩展市场 → 搜索 Continue → 安装 ‌。
  2. ‌配置本地模型‌
    • 打开 VS Code 设置（Cmd+,）→ 搜索 Continue。
    • 在 Continue: Models 中添加如下配置：
    • 重启 VS Code 或重新加载 Continue。
models:
  - name: MLX-Qwen3.5-9B-Claude-4.6-Opus-Reasoning-Distilled-v2-4bit
    provider: openai #一定要设置成openai
    model: MLX-Qwen3.5-9B-Claude-4.6-Opus-Reasoning-Distilled-v2-4bit #这里改成本地使用的模型
    apiKey: omlx #这里改成本地omlx设置的apikey
    apiBase: http://localhost:8000/v1 #这里改成OMLX中API 端点OpenAI API的地址即可
    roles:
      - chat
      - edit
      - apply

  1. 启动 oMLX 服务‌
    • 确保 oMLX 已在终端或菜单栏中运行，并已加载目标模型 ‌。
  2. ‌使用‌
    • 在 VS Code 编辑器中右键 → 选择 Continue: Chat、Agent 或按快捷键（默认 Cmd+I）即可调用本地模型。

✅ 优势：完全离线、代码不上传云端、支持工具调用与结构化输出 ‌。

本地使用截图，能用，够用(M2 16G+512G的macbook pro，请忽略token生成的速度)：

集成 Claude Code / Codex/OpenCode/OpenClaw

oMLX 提供一键配置生成器，简化了与主流开发工具的集成：

  1. 打开 Web 管理面板 (http://localhost:8000/admin)
  2. 选择要使用的模型
  3. 点击 “Integrations” 选项卡
  4. 一键复制配置命令
  5. 打开命令行，cd进入需要处理的项目文件夹，对应的命令 回车就可以啦，如codex和claude code的启动命令
'/Applications/oMLX.app/Contents/MacOS/omlx-cli' launch codex --model 'MLX-Qwen3.5-4B-Claude-4.6-Opus-Reasoning-Distilled-v2-8bit' --api-key 'omlx'
ANTHROPIC_BASE_URL='http://127.0.0.1:8000' ANTHROPIC_AUTH_TOKEN='omlx' ANTHROPIC_DEFAULT_OPUS_MODEL='MLX-Qwen3.5-4B-Claude-4.6-Opus-Reasoning-Distilled-v2-8bit' ANTHROPIC_DEFAULT_SONNET_MODEL='MLX-Qwen3.5-4B-Claude-4.6-Opus-Reasoning-Distilled-v2-8bit' ANTHROPIC_DEFAULT_HAIKU_MODEL='MLX-Qwen3.5-4B-Claude-4.6-Opus-Reasoning-Distilled-v2-8bit' API_TIMEOUT_MS=3000000 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 claude

The post VSCode ,codex,claude code使用 ‌oMLX‌ 本地模型 appeared first on 原立方.

]]> https://www.atomic-cube.cn/vs-code-%e4%b8%ad%e4%bd%bf%e7%94%a8-omlx-%e6%9c%ac%e5%9c%b0%e6%a8%a1%e5%9e%8b/feed/ 0 多合一macOS系统安装U盘制作教程-终端篇 https://www.atomic-cube.cn/%e5%a4%9a%e5%90%88%e4%b8%80macos%e7%b3%bb%e7%bb%9f%e5%ae%89%e8%a3%85u%e7%9b%98%e5%88%b6%e4%bd%9c%e6%95%99%e7%a8%8b-%e7%bb%88%e7%ab%af%e7%af%87/ https://www.atomic-cube.cn/%e5%a4%9a%e5%90%88%e4%b8%80macos%e7%b3%bb%e7%bb%9f%e5%ae%89%e8%a3%85u%e7%9b%98%e5%88%b6%e4%bd%9c%e6%95%99%e7%a8%8b-%e7%bb%88%e7%ab%af%e7%af%87/#respond Wed, 03 Jun 2026 04:42:09 +0000 https://www.atomic-cube.cn/?p=2104 前排提示： 终端篇是在 Mac OS 系统环境制作 下列教程前提是你已经知道了怎么在 Mac 系统下通过终端命令制作U启动盘，知道原理后才能进阶学习多合一制作。 为啥需要多合一？： 对于技术员来说，macOS的系统版本众多，一个U盘制作一个系统的话需要多个U盘，且不利于维护，往往都不知道哪个U盘是哪个版本，如果有一个大容量的U盘的，是否可以一次性把多个 macOS 写入进去呢，答案是可以的，下面教程就说说如何利用终端工具，一个U盘多个分区，逐个写入每个分区 注意：目前官方最新提供的 macOS 10.12 不知道存在什么原因，无法终端写入，只能工具写，我也会跟进这个问题，不断获取最新的 macOS 10.12，希望早日也能终端写入，旧版的10.12就不再发布了，虽然可以终端写入，但是存在证书问题和有效负载报错问题，推荐用10.13代替，10.12和10.13支持的机型一模一样，Mac尽量保持能装新就装新原则 根据上面原则，推荐制作顺序：10.7、10.11、10.13、10.15，重复配置安装最新 macOS 制作过程 分区： 首先需要一个大容量U盘，最好64G以上，我们将U盘分区，格式 GUID ，分几个区则要看你想要制作几个 macOS 。 然后分区： 除了第一个叫upan外，其他暂时先用默认的用 未命名 名称，后面再改 制作第一个 macOS ： 没有看到0-100进度条的，请耐心等待。。。 等待上面完成后，继续制作第二个： 把第二个的未命名名字改成 upan 然后继续终端写入，我这里写入10.14 最后成品图： 剩下的以此类推。

The post 多合一macOS系统安装U盘制作教程-终端篇 appeared first on 原立方.

]]> 前排提示：

终端篇是在 Mac OS 系统环境制作

下列教程前提是你已经知道了怎么在 Mac 系统下通过终端命令制作U启动盘，知道原理后才能进阶学习多合一制作。

为啥需要多合一？：

对于技术员来说，macOS的系统版本众多，一个U盘制作一个系统的话需要多个U盘，且不利于维护，往往都不知道哪个U盘是哪个版本，如果有一个大容量的U盘的，是否可以一次性把多个 macOS 写入进去呢，答案是可以的，下面教程就说说如何利用终端工具，一个U盘多个分区，逐个写入每个分区

注意：目前官方最新提供的 macOS 10.12 不知道存在什么原因，无法终端写入，只能工具写，我也会跟进这个问题，不断获取最新的 macOS 10.12，希望早日也能终端写入，旧版的10.12就不再发布了，虽然可以终端写入，但是存在证书问题和有效负载报错问题，推荐用10.13代替，10.12和10.13支持的机型一模一样，Mac尽量保持能装新就装新原则

根据上面原则，推荐制作顺序：10.7、10.11、10.13、10.15，重复配置安装最新 macOS

制作过程

分区：

首先需要一个大容量U盘，最好64G以上，我们将U盘分区，格式 GUID ，分几个区则要看你想要制作几个 macOS 。

然后分区：

除了第一个叫upan外，其他暂时先用默认的用 未命名 名称，后面再改

制作第一个 macOS ：

没有看到0-100进度条的，请耐心等待。。。

等待上面完成后，继续制作第二个：

把第二个的未命名名字改成 upan

然后继续终端写入，我这里写入10.14

最后成品图：

剩下的以此类推。

The post 多合一macOS系统安装U盘制作教程-终端篇 appeared first on 原立方.

]]> https://www.atomic-cube.cn/%e5%a4%9a%e5%90%88%e4%b8%80macos%e7%b3%bb%e7%bb%9f%e5%ae%89%e8%a3%85u%e7%9b%98%e5%88%b6%e4%bd%9c%e6%95%99%e7%a8%8b-%e7%bb%88%e7%ab%af%e7%af%87/feed/ 0 Mac 本地跑 AI 大模型神器OMLX：专为 Apple Silicon深度优化的开源本地大语言模型（LLM）推理引擎 https://www.atomic-cube.cn/mac-%e6%9c%ac%e5%9c%b0%e8%b7%91-ai-%e5%a4%a7%e6%a8%a1%e5%9e%8b%e7%a5%9e%e5%99%a8%ef%bc%9aomlx%ef%bc%9a%e4%b8%93%e4%b8%ba-apple-silicon-mac-%e6%b7%b1%e5%ba%a6%e4%bc%98%e5%8c%96%e7%9a%84%e5%bc%80/ https://www.atomic-cube.cn/mac-%e6%9c%ac%e5%9c%b0%e8%b7%91-ai-%e5%a4%a7%e6%a8%a1%e5%9e%8b%e7%a5%9e%e5%99%a8%ef%bc%9aomlx%ef%bc%9a%e4%b8%93%e4%b8%ba-apple-silicon-mac-%e6%b7%b1%e5%ba%a6%e4%bc%98%e5%8c%96%e7%9a%84%e5%bc%80/#respond Mon, 25 May 2026 21:20:19 +0000 https://www.atomic-cube.cn/?p=1723 oMLX.AI 是专为 macOS 设计的原生 MLX 服务器，旨在充分利用 Apple Silicon 的计算能力，提供极速的本地大型语言模型（LLM）推理体验

The post Mac 本地跑 AI 大模型神器OMLX：专为 Apple Silicon深度优化的开源本地大语言模型（LLM）推理引擎 appeared first on 原立方.

]]> oMLX.AI 是专为 macOS 设计的原生 MLX 服务器，旨在充分利用 Apple Silicon 的计算能力，提供极速的本地大型语言模型（LLM）推理体验。该平台通过融合智能 SSD 缓存与连续批处理技术，解决了传统内存缓存的局限性，实现了低延迟多模型推理。开发者无需依赖云端，即可在本地环境中高效测试、部署和优化 AI 模型，适用于编码辅助、内容生成及多模态任务等场景。

对于 macOS 用户而言，一款能够充分发挥 Apple Silicon 芯片潜力的本地大模型推理引擎显得尤为重要。

oMLX 正是为解决这一痛点而生的开源项目。它是一个专为 macOS 原生设计的 MLX 服务器，提供 LLM 大语言模型推理服务，具有智能缓存功能，针对编码代理的实际工作方式进行了深度优化。

🎯 oMLX 的核心价值：让 Claude Code、OpenClaw 和 Cursor 等工具能在 5 秒内响应，而非传统的 90 秒。这意味着开发效率的质的飞跃！

核心功能特性

技术架构详解

oMLX 的技术架构采用分层设计，核心组件包括：

  • FastAPI Server：提供 OpenAI 和 Anthropic API 兼容接口
  • EnginePool：多模型管理，支持 LRU 驱逐、TTL、手动加载/卸载
  • ProcessMemoryEnforcer：总内存限制，防止 OOM
  • Scheduler：FCFS 调度，可配置批处理大小
  • Cache Stack：分层 KV 缓存（内存热缓存 + SSD 冷缓存）

实测性能数据

oMLX 官方基准测试收集了大量社区用户的测试数据。以下是不同 Apple Silicon 芯片的实测表现：

M4 Pro (48GB) 测试结果

安装与配置

系统要求

  • 芯片：Apple Silicon (M1/M2/M3/M4/M5)
  • 系统：macOS 15.0+ (Sequoia)
  • 内存：最低 16GB（推荐 64GB+）
  • Python：3.10+

安装方式一：macOS 应用（推荐）

方式 A：macOS 应用（推荐）

  1. 从 GitHub Releases 下载 DMG 文件
  2. 拖动到 Applications 文件夹
  3. 首次启动时显示欢迎屏幕，引导完成以下步骤
  • 设置模型目录
  • 启动服务器
  • 下载第一个模型

安装方式二：Homebrew

# 添加 Tap 并安装
brew tap jundot/omlx https://github.com/jundot/omlx
brew install omlx

# 升级到最新版本
brew update && brew upgrade omlx

# 作为后台服务运行（崩溃自动重启）
brew services start omlx

# 可选：安装 MCP 支持
/opt/homebrew/opt/omlx/libexec/bin/pip install mcp

安装方式三：从源码安装

# 克隆并安装
git clone https://github.com/jundot/omlx.git
cd omlx
pip install -e .              # 仅核心功能
pip install -e ".[mcp]"       # 带 MCP 支持

# 启动服务
omlx serve --model-dir ~/models

使用教程

启动服务器

通过命令行启动 oMLX 服务器：

# 基本启动
omlx serve --model-dir ~/models

# 启用 SSD 缓存
omlx serve --model-dir ~/models --paged-ssd-cache-dir ~/.omlx/cache

# 设置内存限制
omlx serve --model-dir ~/models --max-process-memory 80%

💡 提示：可以复用现有的 LM Studio 模型目录，无需重新下载所有模型。

API 调用示例

Chat Completions

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "model-name",
    "messages": [{"role": "user", "content": "你好！"}]
  }'

流式输出

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "model-name",
    "messages": [{"role": "user", "content": "写一首诗"}],
    "stream": true
  }'

Anthropic API

curl http://localhost:8000/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: your-key" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "解释量子计算"}]
  }'

集成 Claude Code / Codex/OpenCode/OpenClaw

oMLX 提供一键配置生成器，简化了与主流开发工具的集成：

  1. 打开 Web 管理面板 (http://localhost:8000/admin)
  2. 选择要使用的模型
  3. 点击 “Integrations” 选项卡
  4. 一键复制配置命令
  5. 粘贴到对应工具的配置文件

重要说明：推荐配置为 M 系列 Pro/Max + 64GB+ 内存，以获得最佳的使用体验。16GB 内存虽然可以运行，但可能会遇到内存不足的情况。

与传统方案对比

oMLX vs Ollama / LM Studio

oMLX 的核心竞争力在于：

  • 极速响应：TTFT 从 30-90 秒缩短到 5 秒以内
  • 智能缓存：SSD KV 缓存技术实现上下文复用
  • 高并发：连续批处理支持 8× 并发，吞吐量提升 4.14×
  • 原生体验：非 Electron 构建的系统原生应用
  • 完全开源：Apache 2.0 许可证，透明可控

最大的区别就是缓存机制：

Ollama和LM Studio的KV缓存都是放在内存里的，而且一旦对话的上下文变化，比如你用Claude Code的时候，它会不断地修改上下文，加工具调用的结果，这时候整个缓存就直接失效了，下次还要重新计算一遍，这就是为什么你会等半天。

而oMLX的缓存是块级的，持久化到SSD，不管上下文怎么变，只要有相同的前缀，就能直接复用缓存，不用重新算，这就是它能把首响从90秒降到5秒的核心原因。

而且oMLX专门针对Claude Code这类AI编码工具做了优化，比如SSE keep-alive防止长请求超时，上下文缩放让小模型也能配合Claude Code用，这些都是其他工具没有的。

oMLX 不仅是一个性能强大的 LLM 推理引擎，更通过其创新的缓存机制和友好的交互设计，解决了本地部署大模型的实际痛点。如果你拥有一台 Apple Silicon Mac，并希望在本地高效、便捷地运行大模型，oMLX 无疑是一个非常值得尝试的选择。

如果你有一台Apple Silicon Mac，并且正在寻找一个高效、易用的本地LLM推理方案，oMLX值得你立即上手体验。它很可能就是那块让Mac变身私人AI数据中心的最后拼图。

快速入口：

快去试试吧，然后把你的Mac菜单栏交给oMLX——相信你也会成为它的忠实用户。

The post Mac 本地跑 AI 大模型神器OMLX：专为 Apple Silicon深度优化的开源本地大语言模型（LLM）推理引擎 appeared first on 原立方.

]]> https://www.atomic-cube.cn/mac-%e6%9c%ac%e5%9c%b0%e8%b7%91-ai-%e5%a4%a7%e6%a8%a1%e5%9e%8b%e7%a5%9e%e5%99%a8%ef%bc%9aomlx%ef%bc%9a%e4%b8%93%e4%b8%ba-apple-silicon-mac-%e6%b7%b1%e5%ba%a6%e4%bc%98%e5%8c%96%e7%9a%84%e5%bc%80/feed/ 0 Go深度指南：从基础到高级的全面解析 https://www.atomic-cube.cn/go%e6%b7%b1%e5%ba%a6%e6%8c%87%e5%8d%97%ef%bc%9a%e4%bb%8e%e5%9f%ba%e7%a1%80%e5%88%b0%e9%ab%98%e7%ba%a7%e7%9a%84%e5%85%a8%e9%9d%a2%e8%a7%a3%e6%9e%90/ https://www.atomic-cube.cn/go%e6%b7%b1%e5%ba%a6%e6%8c%87%e5%8d%97%ef%bc%9a%e4%bb%8e%e5%9f%ba%e7%a1%80%e5%88%b0%e9%ab%98%e7%ba%a7%e7%9a%84%e5%85%a8%e9%9d%a2%e8%a7%a3%e6%9e%90/#respond Sat, 23 May 2026 07:25:58 +0000 https://www.atomic-cube.cn/?p=2098 Go 语言自推出以来，因其简洁性、并发支持和高效性能，在云计算、微服务和分布式系统中广泛应用。作为开发者，面试时往往需要面对一系列技术问题，这些常被称为“八股文”的题目，虽然有时显得高级特性，力求每个解释都严谨实用，避免空话套话。让我们从最基础的部分开始。 第一章：基础概念与语法 变量与类型系统 Go 是静态类型语言，类型安全且编译时检查。变量声明使用 var 关键字，或短变量声明 :=。基础类型包括整型、浮点型、布尔型和字符串等。理解零值概念至关重要：未初始化的变量会赋予其类型的零值，例如整型为 0，字符串为空字符串””。 类型转换必须是显式的，Go 不支持隐式类型转换。例如，将 int 转换为 float64 需要使用 float64(x)。这有助于避免意外错误。 控制结构 Go 的控制结构包括 if、for、switch 等，设计简洁。for 循环是唯一的循环结构，但可以模拟 while 循环。if 语句可以包含初始化语句，增强可读性。 switch 语句在 Go 中更为灵活，case 表达式可以是常量、变量或函数调用，且默认不需要 break。 函数 函数是 Go 的一等公民，支持多返回值，这在错误处理中尤为常见。函数可以定义为方法，与类型关联。理解值传递和引用传递的区别很重要：Go 中所有参数都是值传递，但对于切片、映射和通道等引用类型，传递的是底层数据的引用。 第二章：并发编程核心 Go 的并发模型基于 goroutine 和 channel，是其最强大的特性之一。面试中常深入探讨这方面。 goroutine goroutine 是轻量级线程，由 Go 运行时管理。使用 go 关键字启动，开销小，可轻松创建成千上万个。但需要注意，goroutine 的执行顺序不确定，依赖于调度器。 channel channel 是 goroutine 间的通信管道，可以传递数据并同步执行。分为有缓冲和无缓冲两种。无缓冲 channel 要求发送和接收同时就绪，否则会阻塞；有缓冲 channel 在缓冲区满或空时阻塞。 同步原语 除了 channel，Go 的 sync 包提供了 Mutex、WaitGroup 等同步工具。在共享资源访问时，使用 Mutex 避免数据竞争。WaitGroup 用于等待一组 goroutine 完成。 第三章：高级特性与设计模式 接口与多态 […]

The post Go深度指南：从基础到高级的全面解析 appeared first on 原立方.

]]> Go 语言自推出以来，因其简洁性、并发支持和高效性能，在云计算、微服务和分布式系统中广泛应用。作为开发者，面试时往往需要面对一系列技术问题，这些常被称为“八股文”的题目，虽然有时显得高级特性，力求每个解释都严谨实用，避免空话套话。让我们从最基础的部分开始。

第一章：基础概念与语法

变量与类型系统

Go 是静态类型语言，类型安全且编译时检查。变量声明使用 var 关键字，或短变量声明 :=。基础类型包括整型、浮点型、布尔型和字符串等。理解零值概念至关重要：未初始化的变量会赋予其类型的零值，例如整型为 0，字符串为空字符串””。

package main

import "fmt"

func main() {
    var a int      // 声明整型变量，零值为0
    b := 10        // 短变量声明，类型推断为int
    var s string   // 字符串零值为""
    fmt.Printf("a: %d, b: %d, s: %s\n", a, b, s) // 输出: a: 0, b: 10, s: 
}

类型转换必须是显式的，Go 不支持隐式类型转换。例如，将 int 转换为 float64 需要使用 float64(x)。这有助于避免意外错误。

控制结构

Go 的控制结构包括 if、for、switch 等，设计简洁。for 循环是唯一的循环结构，但可以模拟 while 循环。if 语句可以包含初始化语句，增强可读性。

package main

import "fmt"

func main() {
    // for循环示例
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
    // 类似while循环
    j := 0
    for j < 3 {
        fmt.Println(j)
        j++
    }
    // if带初始化
    if x := 10; x > 5 {
        fmt.Println("x大于5")
    }
}

switch 语句在 Go 中更为灵活，case 表达式可以是常量、变量或函数调用，且默认不需要 break。

函数

函数是 Go 的一等公民，支持多返回值，这在错误处理中尤为常见。函数可以定义为方法，与类型关联。理解值传递和引用传递的区别很重要：Go 中所有参数都是值传递，但对于切片、映射和通道等引用类型，传递的是底层数据的引用。

package main

import "fmt"

// 多返回值函数
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result) // 输出: 结果: 5
    }
}

第二章：并发编程核心

Go 的并发模型基于 goroutine 和 channel，是其最强大的特性之一。面试中常深入探讨这方面。

goroutine

goroutine 是轻量级线程，由 Go 运行时管理。使用 go 关键字启动，开销小，可轻松创建成千上万个。但需要注意，goroutine 的执行顺序不确定，依赖于调度器。

package main

import (
    "fmt"
    "time"
)

func sayHello(name string) {
    for i := 0; i < 3; i++ {
        fmt.Println("Hello,", name)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    go sayHello("Alice")  // 启动goroutine
    go sayHello("Bob")
    time.Sleep(1 * time.Second) // 等待goroutine完成，实际应用中应使用同步机制
}

channel

channel 是 goroutine 间的通信管道，可以传递数据并同步执行。分为有缓冲和无缓冲两种。无缓冲 channel 要求发送和接收同时就绪，否则会阻塞；有缓冲 channel 在缓冲区满或空时阻塞。

package main

import "fmt"

func main() {
    // 无缓冲channel
    ch := make(chan int)
    go func() {
        ch <- 42 // 发送数据
    }()
    value := <-ch // 接收数据
    fmt.Println("接收值:", value) // 输出: 接收值: 42

    // 有缓冲channel
    bufferedCh := make(chan string, 2)
    bufferedCh <- "hello"
    bufferedCh <- "world"
    fmt.Println(<-bufferedCh, <-bufferedCh) // 输出: hello world
}

同步原语

除了 channel，Go 的 sync 包提供了 Mutex、WaitGroup 等同步工具。在共享资源访问时，使用 Mutex 避免数据竞争。WaitGroup 用于等待一组 goroutine 完成。

package main

import (
    "fmt"
    "sync"
    "time"
)

var counter int
var mu sync.Mutex

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mu.Lock()
    counter++
    mu.Unlock()
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    fmt.Println("最终计数器值:", counter) // 应该输出1000
}

第三章：高级特性与设计模式

接口与多态

Go 的接口是隐式实现的：类型只需实现接口所有方法，就自动满足该接口。这促进了松耦合设计。接口常用于定义行为，如 io.Reader 和 io.Writer。

package main

import "fmt"

// 定义接口
type Speaker interface {
    Speak() string
}

// 结构体实现接口
type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

type Cat struct{}

func (c Cat) Speak() string {
    return "Meow!"
}

func makeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{}
    cat := Cat{}
    makeSound(dog) // 输出: Woof!
    makeSound(cat) // 输出: Meow!
}

空接口 interface{} 可以表示任何类型，但使用时应谨慎，通常与类型断言结合。

错误处理

Go 的错误处理通过返回值实现，而非异常。标准库提供了 error 接口。建议使用 errors.New 或 fmt.Errorf 创建错误，并通过 if err != nil 检查。defer、panic 和 recover 用于处理异常情况，但 panic 应仅用于不可恢复错误。

package main

import (
    "errors"
    "fmt"
)

func process(value int) (int, error) {
    if value < 0 {
        return 0, errors.New("值不能为负")
    }
    return value * 2, nil
}

func safeProcess() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("恢复panic:", r)
        }
    }()
    panic("测试panic")
}

func main() {
    result, err := process(5)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result) // 输出: 结果: 10
    }
    safeProcess() // 输出: 恢复panic: 测试panic
}

反射与元编程

反射通过 reflect 包实现，允许程序在运行时检查类型和值。尽管强大，但反射性能开销大，应仅在必要时使用，如序列化或通用函数中。

package main

import (
    "fmt"
    "reflect"
)

func inspectType(v interface{}) {
    t := reflect.TypeOf(v)
    fmt.Printf("类型: %v, 种类: %v\n", t, t.Kind())
}

func main() {
    var x int = 42
    inspectType(x) // 输出: 类型: int, 种类: int
    inspectType("hello") // 输出: 类型: string, 种类: string
}

第四章：内存管理与性能优化

指针与值语义

Go 有指针，但不像 C 那样复杂。指针允许直接操作内存地址，常用于避免大结构体复制的开销。值语义和引用语义的选择依赖于场景：值语义更安全，引用语义更高效。

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

// 值接收者
func (p Person) String() string {
    return fmt.Sprintf("%s (%d岁)", p.Name, p.Age)
}

// 指针接收者，可修改结构体
func (p *Person) Birthday() {
    p.Age++
}

func main() {
    p1 := Person{"Alice", 30}
    p1.Birthday() // 即使p1是值，Go会自动取地址
    fmt.Println(p1.String()) // 输出: Alice (31岁)
}

垃圾回收

Go 使用并发标记清除垃圾回收器，自动管理内存。开发者无需手动释放内存，但应注意避免内存泄漏，如未关闭的资源或全局变量引用。通过 runtime 包可以监控 GC 行为。

性能调优

性能优化包括减少分配、使用 sync.Pool 重用对象、避免不必要的反射等。工具如 pprof 用于分析 CPU 和内存使用。

package main

import (
    "fmt"
    "sync"
)

var pool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func main() {
    buf := pool.Get().([]byte)
    // 使用buf...
    fmt.Println("缓冲区长度:", len(buf))
    pool.Put(buf) // 放回池中以重用
}

第五章：标准库与实战问题

常用标准库

Go 标准库丰富，面试常问 net/http、encoding/json、testing 等。例如，HTTP 服务器实现简单：

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

JSON 序列化和反序列化：

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    user := User{"Bob", 25}
    data, err := json.Marshal(user)
    if err != nil {
        fmt.Println("错误:", err)
        return
    }
    fmt.Println(string(data)) // 输出: {"name":"Bob","age":25}
    var newUser User
    json.Unmarshal(data, &newUser)
    fmt.Println(newUser) // 输出: {Bob 25}
}

常见面试题解析

面试中常出现的问题包括：goroutine 泄漏如何避免、channel 死锁场景、接口设计原则等。例如，goroutine 泄漏通常因未正确关闭 channel 或忽略错误导致，解决方案是使用 context 包进行取消。

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context, ch chan int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker停止")
            return
        case val := <-ch:
            fmt.Println("处理值:", val)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    ch := make(chan int)
    go worker(ctx, ch)
    ch <- 1
    time.Sleep(1 * time.Second)
    cancel() // 取消worker，避免泄漏
    time.Sleep(100 * time.Millisecond)
}

第六章：最佳实践与总结

在 Go 开发中，遵循最佳实践能提升代码质量：使用 go fmt 统一格式、编写单元测试、依赖管理使用 go mod、避免全局状态等。测试是 Go 文化的一部分，内置 testing 包支持表格驱动测试。

package main

import (
    "testing"
)

func Add(a, b int) int {
    return a + b
}

func TestAdd(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tt := range tests {
        result := Add(tt.a, tt.b)
        if result != tt.expected {
            t.Errorf("Add(%d, %d) = %d; 期望 %d", tt.a, tt.b, result, tt.expected)
        }
    }
}

总结来说，Go 需要对语言特性的深刻理解。通过本文的梳理，我们希望读者能掌握从基础语法到并发模型、从接口设计到性能优化的核心点。实际编码中，多实践、多阅读优秀源码是提升的关键。持续学习才能应对不断变化的技术挑战。

The post Go深度指南：从基础到高级的全面解析 appeared first on 原立方.

]]> https://www.atomic-cube.cn/go%e6%b7%b1%e5%ba%a6%e6%8c%87%e5%8d%97%ef%bc%9a%e4%bb%8e%e5%9f%ba%e7%a1%80%e5%88%b0%e9%ab%98%e7%ba%a7%e7%9a%84%e5%85%a8%e9%9d%a2%e8%a7%a3%e6%9e%90/feed/ 0