<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>设计 on 文叨叨 | IaaS 排障手记</title><link>/tags/%E8%AE%BE%E8%AE%A1/</link><description>Recent content in 设计 on 文叨叨 | IaaS 排障手记</description><generator>Hugo</generator><language>zh-cn</language><lastBuildDate>Sun, 24 May 2026 10:00:00 +0800</lastBuildDate><atom:link href="/tags/%E8%AE%BE%E8%AE%A1/index.xml" rel="self" type="application/rss+xml"/><item><title>长运行与临时调整要分离</title><link>/posts/long-running-vs-temp-adjust/</link><pubDate>Sun, 24 May 2026 10:00:00 +0800</pubDate><guid>/posts/long-running-vs-temp-adjust/</guid><description>存量 VM 不切换，我们可以提供一个接口来调整虚拟机的 cpu_mode 来实现。这样长运行的逻辑简单，而调整和长运行逻辑分离，降低复杂性。</description></item><item><title>架构决定稳定性：核心对象 + 流水线</title><link>/posts/architecture-determines-stability/</link><pubDate>Sat, 23 May 2026 10:00:00 +0800</pubDate><guid>/posts/architecture-determines-stability/</guid><description>架构决定下限，代码决定上限。虽然代码影响很大，但是整体的稳定性，依然是架构占大部分决定因素。linux 网络栈足够复杂，但又有足够的扩展性，且非常的高性能，为什么？因为它流水线 + sk_buff。</description></item><item><title>简单是唯一标准吗？</title><link>/posts/is-simple-the-only-criterion/</link><pubDate>Sun, 17 May 2026 10:00:00 +0800</pubDate><guid>/posts/is-simple-the-only-criterion/</guid><description>很多时候讨论方案，&amp;#39;这个改起来简单&amp;#39;，然后就没有人说话了。简单没有错，问题是简单就是指这一次改动的简单呢？那运维的简单性、扩展的简单性、稳定的简单性、排查的简单性呢？</description></item><item><title>边界：计算、存储、网络要分离</title><link>/posts/boundary-compute-storage-network/</link><pubDate>Sat, 16 May 2026 10:00:00 +0800</pubDate><guid>/posts/boundary-compute-storage-network/</guid><description>拿快照来说，为啥我们支持快照的多链这么复杂？按道理虚拟机只需要一个卷，至于这个卷背后的链是完全不需要关心的。如果计算存储分离，快照局限于存储模块，计算只需要一个卷。</description></item><item><title>可变与不可变：找到变化，封装变化</title><link>/posts/variable-vs-invariable/</link><pubDate>Sun, 10 May 2026 10:00:00 +0800</pubDate><guid>/posts/variable-vs-invariable/</guid><description>设计模式一个基本点两个原则：一个基本点是找到变化、封装变化；两个原则是基于接口而不是基于实现、组合优于继承。核心是可变与不可变的隔离、解耦。</description></item><item><title>简单 + 组合，才是最强的</title><link>/posts/simple-plus-combination/</link><pubDate>Sat, 09 May 2026 10:00:00 +0800</pubDate><guid>/posts/simple-plus-combination/</guid><description>《UNIX编程艺术》里讲的：cmd + 管道 + 文本的设计理念，让单个命令足够简单清晰，而命令的编排又可以创造无限扩展的能力。单元简单，才容易组合。</description></item><item><title>高可用要么不做，要么做完善：fence 是必备</title><link>/posts/ha-fence-essential/</link><pubDate>Sun, 03 May 2026 10:00:00 +0800</pubDate><guid>/posts/ha-fence-essential/</guid><description>稳定性相关的，要么不做，要么就要完善，要不然做了高可用，反而造成雪崩。高可用必备 fence，fence 就是 ipmi 强制关机，这是最稳妥的方式。</description></item><item><title>状态机：围绕状态，而不是围绕具体流程</title><link>/posts/state-machine-around-state/</link><pubDate>Sat, 02 May 2026 10:00:00 +0800</pubDate><guid>/posts/state-machine-around-state/</guid><description>状态机的核心是围绕状态，而不是围绕具体流程。当前状态、输入、转移状态，就是围绕着三要素设计的。它可以把一个超长流程、超多条件判断的流程，解耦为一个个独立的状态。</description></item><item><title>正向流程容易，逆向回滚才是灾难</title><link>/posts/forward-easy-rollback-hard/</link><pubDate>Sun, 26 Apr 2026 10:00:00 +0800</pubDate><guid>/posts/forward-easy-rollback-hard/</guid><description>当流程跨越了多个服务，一旦中途某一步失败，如何把已经扭转的状态干净地恢复原状，是软件架构里最重的活。优秀的架构师会尽量避免物理回滚，把流程设计为只能向前。</description></item><item><title>面向过程还是面向对象？对象是骨架，流程是血肉</title><link>/posts/oop-vs-procedural/</link><pubDate>Sat, 25 Apr 2026 10:00:00 +0800</pubDate><guid>/posts/oop-vs-procedural/</guid><description>流程是易变的、脆弱的，对象是稳定的、高内聚的。面向对象的流程是分治，将易变的流程拆分成多个稳定的对象，对象之间面向接口协作，复杂性拆分成局部复杂性。</description></item><item><title>决策树还是决策层？决策流程适合树</title><link>/posts/decision-tree-vs-layer/</link><pubDate>Sun, 19 Apr 2026 10:00:00 +0800</pubDate><guid>/posts/decision-tree-vs-layer/</guid><description>决策流程这个场景，适合树而不是层。树是前后依赖的，层是前后不依赖的、每一层是通用的。规则引擎天生就是规则流，前后有依赖，所以写规则配置就是树的方式。</description></item><item><title>mq 相比直接传递消息的优势</title><link>/posts/mq-advantage-over-direct-message/</link><pubDate>Sat, 18 Apr 2026 10:00:00 +0800</pubDate><guid>/posts/mq-advantage-over-direct-message/</guid><description>mq 不仅是削峰填谷，也不仅是解耦服务，还有降低代码复杂性、增加稳定性的作用。中间件是一个稳定的、没有逻辑的、仅仅存储数据的。</description></item><item><title>check 和修复，要从大流程上就分开</title><link>/posts/check-and-fix-separate/</link><pubDate>Sun, 12 Apr 2026 10:00:00 +0800</pubDate><guid>/posts/check-and-fix-separate/</guid><description>check 有很多项，每个项都有修复。check 是一条线，修复是一条线。不要在 check 中发现某个项有问题就进行修复，而是要等 check 完再调用修复。</description></item><item><title>底层单一，上层组合</title><link>/posts/bottom-single-top-combine/</link><pubDate>Sat, 11 Apr 2026 10:00:00 +0800</pubDate><guid>/posts/bottom-single-top-combine/</guid><description>底层逻辑尤其要保证单一，一个能力只提供一种方法。想要更多，通过上层组合、上层封装来实现。千万不要把所有需求都放到底层原子能力上。</description></item><item><title>Hook、插件、Middleware：三种扩展机制的区别</title><link>/posts/hook-plugin-middleware/</link><pubDate>Sun, 05 Apr 2026 10:00:00 +0800</pubDate><guid>/posts/hook-plugin-middleware/</guid><description>Hook 侧重现有流程上运行时的局部修改，插件侧重模块化功能扩展，Middleware 是流程中可以扩展的横切面。三者核心目标都是不侵入主程序的前提下实现扩展。</description></item><item><title>耦合的松紧，关键在于变化</title><link>/posts/coupling-key-is-change/</link><pubDate>Sun, 29 Mar 2026 10:00:00 +0800</pubDate><guid>/posts/coupling-key-is-change/</guid><description>什么是耦合，怎么判断有没有耦合？可以从结果反推：A 变化了，B 要不要跟着变化。如果跟着变，那就是耦合了；如果没有跟着变，或者变动很小，那就是松耦合。</description></item><item><title>即便是补丁，也要面向对象，而不是针对流程打补丁</title><link>/posts/patch-object-oriented/</link><pubDate>Sat, 21 Mar 2026 10:00:00 +0800</pubDate><guid>/posts/patch-object-oriented/</guid><description>哪里遇到问题了，就找个地方加个开关、加个检查、加个条件判断来处理掉。这导致不够系统化，引入了局部的分支点，会造成多流程的耦合交叉，扩展容易遗漏。</description></item><item><title>代码也有一致性：面向接口而非面向实现</title><link>/posts/code-consistency-interface/</link><pubDate>Sat, 14 Mar 2026 10:00:00 +0800</pubDate><guid>/posts/code-consistency-interface/</guid><description>不仅数据有一致性问题，代码的一致性问题更加遍地都是。判断主机是否运行应该面向 libvirt 接口，而不是面向实现中的文件、过程。</description></item><item><title>面向接口，面向接口，面向接口</title><link>/posts/interface-oriented/</link><pubDate>Sun, 08 Mar 2026 10:00:00 +0800</pubDate><guid>/posts/interface-oriented/</guid><description>接口很多时候听起来很有道理，写的时候会质疑是不是为了接口而接口。一写二抄三重构，前面没有必要的时候不用接口，后面重复的时候可以引入接口。</description></item><item><title>封装和独立的区别：复用 vs 管理能力</title><link>/posts/encapsulation-vs-independent/</link><pubDate>Sat, 07 Mar 2026 10:00:00 +0800</pubDate><guid>/posts/encapsulation-vs-independent/</guid><description>封装仅仅是为了复用，但是独立有管理能力。封装调用了就得执行，独立有自己的一套管理规则，比如排队、限流、调整优先级、丢弃、转换等。</description></item><item><title>底层最好有默认值，上层可以少硬编码</title><link>/posts/bottom-default-value/</link><pubDate>Sun, 01 Mar 2026 10:00:00 +0800</pubDate><guid>/posts/bottom-default-value/</guid><description>底层（被依赖者）最好有默认值，上层（依赖者）可以少硬编码。判断不是问题，问题是重复判断；硬编码本身是必须的，问题是重复的硬编码。</description></item></channel></rss>