<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/"><channel><title>SRE on Bless Blog</title><link>https://blog.hieros.me/zh/tags/sre/</link><description>Recent content in SRE on Bless Blog</description><generator>Hugo -- 0.166.0</generator><language>zh</language><lastBuildDate>Thu, 17 Sep 2026 23:00:00 +0800</lastBuildDate><atom:link href="https://blog.hieros.me/zh/tags/sre/index.xml" rel="self" type="application/rss+xml"/><item><title>Azure SRE 教程</title><link>https://blog.hieros.me/zh/posts/wsre/</link><pubDate>Thu, 17 Sep 2026 23:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/wsre/</guid><description>SRE学习</description><content type="text/html" mode="escaped"><![CDATA[<h1 id="sre简介">SRE简介<a href="#sre%e7%ae%80%e4%bb%8b" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>站点可靠性工程是一门工程专业，致力于持续帮助组织实现系统、服务和产品的可靠性级别。——本·特雷诺·斯洛斯</p>
<p>SRE 最核心的一词是“可靠性”，定义中说的不是“适当性能级别”、“适当效率级别”、“适当稳定性级别”或“达到适当收入级别”， 而是“适当可靠性级别”。如果应用程序没有正常运行（即如果它在客户需要访问它时无法运行或如果它不可靠），这对任何人都没有任何好处，尤其是对企业。缺少可靠性可能会（在信誉、经济、合同、士气等方面）对企业造成实际危害。</p>
<p>站点可靠性工程是一门工程专业，致力于持续帮助组织实现系统、服务和产品的可靠性级别。据 SRE 领域的重要观察，必须 100% 可靠的系统和服务寥寥无几。 值得注意的例外是，航空、医疗设备等生死攸关的行业。可靠性级别必须与业务需求保持一致，且切实可行。 例如，我们的客户可能通过不是 100% 可靠的网络连接到你（假设 90% 的时间都是）。 花费精力和金钱来确保服务 95% 的可靠性显然浪费时间和金钱。 建议实现系统、服务和产品的适当可靠性级别。</p>
<p>我们在继续之前需要重点强调的定义中的最后一个词是“持续”。 “持续”是指人员的角色。 创建可持续的操作实践至关重要。 人员生成可靠的系统、服务和产品。 <strong>如果我们不采取措施确保我们的工作是可持续的。 如果我们每天凌晨 3:00 把员工叫醒交付他们工作，不给他们和家人在一起的时间。 如果他们没有机会花时间照顾自己。 那么，他们就不可能构建可靠的系统。</strong> SRE 认为我们非常有必要实施一种长期可持续的操作实践，以便我们的员工能够在工作中发挥最大才能。</p>
<p>DevOps 可以理解为一种让开发和运维更紧密合作的软件交付方式。过去开发人员主要负责写代码，运维人员主要负责部署和维护系统，两边往往彼此独立。这样很容易出现“开发只管功能，运维只管稳定”的问题。DevOps 想解决的就是这种割裂，让开发、测试、部署和运维尽量形成一条连续的流程，并通过 CI/CD、自动化测试、自动部署等方式提高软件交付效率。</p>
<p>SRE，也就是站点可靠性工程，更关注系统上线之后如何长期稳定运行。它的核心思想是把传统运维中的问题当成工程问题来解决。例如，系统出现故障时，不只是依赖运维人员手动处理，而是考虑能不能通过监控、自动恢复、容量规划等方式提前发现和自动解决。SRE 还会用 SLI、SLO、Error Budget 等指标来明确“系统到底需要多可靠”。</p>
<p>两者最大的区别在于关注重点不同。DevOps 更关心“开发和运维怎么更好地协作，以及软件怎么更快、更顺利地上线”；SRE 更关心“系统上线之后怎么保持可靠，出了故障怎么快速恢复，以及怎么减少人工运维”。因此，DevOps 更像一种文化和工作方式，而 SRE 更像一套比较具体的工程方法。</p>
<p>不过两者并不是互相替代的关系。它们都强调自动化、监控、持续改进和减少人为失误，所以实际工作中经常会一起出现。一个已经实行 DevOps 的团队，通常也更容易进一步引入 SRE 的做法。<strong>DevOps 主要解决“怎么把软件交付好”，SRE 主要解决“怎么让软件运行好”。</strong></p>
<p>假设你正计划要将一项新服务投入生产，可能是已构造的服务，也可能是仍在计划过程当中的服务。 在此过程中，务必要对所需的可靠性做出一些决定。 如果不是所有代码都是你自己编写的，请与编写相应代码的开发人员共同做出这些决定（这一点至关重要）。</p>
<p>要做出的第一个决定是，应该用什么作为服务运行状况的指标（即“服务级别指标 (SLI)”）？ 这个问题的另一种问法是，“如何判断服务何时在运行且运行良好？”。 有很多方法可以跟踪 SLI，我们稍后会详细探讨一些方法。 但是，以下指标是很典型的：</p>
<ul>
<li>成功与失败度量标准： 服务是否在某个时间间隔内成功完成一定比例的操作？</li>
<li>计时度量值： 我们在某个时间阈值内是否返回答案？</li>
<li>吞吐量度量值： 我们处理了一定量的数据吗？</li>
</ul>
<p>SLO（Service Level Objective，服务级别目标）是团队根据服务运行指标设定的可靠性目标。例如，可以规定一天内的故障率不超过 20%。这里使用 20% 这样较大的数值，一方面便于理解和计算，另一方面也体现了 SRE 中对开发速度与运行稳定性之间平衡的考虑：在满足可靠性要求的同时，为持续交付、快速迭代和敏捷开发保留一定的调整空间。后续还可以进一步限定统计范围，例如哪些用户受到影响、错误率针对部分用户还是大多数用户等，从而使 SLO 的定义更加精确。</p>
<p>必须能够在监视系统中准确度量和表示 SLO。 这应该是一个客观且易于理解的服务可靠性目标。 多大的数字才够好呢？ 不得有下面这样的说辞：“好吧，我认为这项服务在过去一周左右的时间里一直没问题，但具体怎样很难说”。 服务要么实现 SLO，要么没有实现。 数据应该很明确。 如果服务没有实现 SLO（特别是在一段时间内反复这样），表示服务出现了问题，需要进行解决。</p>
<p>误差预算（Error Budget）是由 SLO 推导出来的“允许不可靠空间”。如果某项服务的 SLO 是 80% 可用性，那么理论上的误差预算就是 100% - 80% = 20%。这 20% 表示：只要整体可靠性仍然满足 SLO，服务可以在这部分范围内承担一定的故障、发布风险或升级带来的不稳定。</p>
<p>误差预算的意义在于，它为开发速度和系统稳定性之间提供了一个可以量化的平衡。例如，新版本上线后导致 10% 的额外故障时间，只要仍然没有超出 20% 的误差预算，就可以认为整体仍处于可接受范围内。因此，团队可以把一部分误差预算用于发布新功能、升级系统和快速迭代。</p>
<p>如果服务可靠性下降到 SLO 以下，例如目标是 80%，实际却只有 60%，就意味着误差预算已经耗尽甚至透支。此时团队通常会减少或暂停新的功能发布，把更多工程资源投入到稳定性、故障排查和可靠性改进中，直到服务重新恢复到目标水平。</p>
<p>因此，误差预算可以看作一种反馈机制：预算充足时，团队可以更积极地发布和迭代；预算接近耗尽时，就应更加保守；预算耗尽后，则优先修复可靠性问题。它把“到底该继续发版本，还是先解决稳定性问题”从主观争论转化成了基于 SLO 的工程判断。</p>
<p>事后调查（Postmortem）是对重大故障或异常事件进行回顾分析，目的是弄清楚故障为什么发生、哪些环节失效，以及今后如何避免类似问题再次出现。SRE 特别强调“无责备事后调查”，也就是分析重点放在系统、流程和信息设计上，而不是追究某个具体人员的责任。</p>
<p>无责备并不意味着忽视人的操作，而是进一步追问：为什么现有流程会允许一次操作演变成故障？当事人在当时缺少了什么信息？哪些提示或机制可能让他做出了错误判断？系统是否应该增加自动检查、权限限制、回滚机制或其他保护措施？核心目标是让系统本身变得更不容易出错。</p>
<p>这种做法背后的逻辑是，如果每次事故都优先寻找“谁犯了错”，员工以后就会更倾向于隐瞒问题、避免操作和拒绝尝试，从而让组织失去真正学习和改进的机会。相反，良好的事后调查会把故障转化为经验，通过持续改进流程和技术，让整个系统越来越可靠。</p>
<p>因此，SRE 把故障看作学习机会。每次事故都应该形成“发生故障—分析原因—改进系统—降低未来风险”的反馈循环，这也是 SRE 持续提升可靠性的核心机制之一。</p>
<p>Toil 是 SRE 中专门用来描述低价值重复性运维工作的概念。它通常具有手动、重复、可自动化、会随系统规模增长而增加等特点，而且完成这些工作并不会让系统得到长期改善。例如，反复重启进程、定期手动重置配置、人工创建账号或分配磁盘空间，都属于典型的 Toil。</p>
<p>Toil 的关键问题不在于工作本身是否困难，而在于它需要不断重复投入人力，却不会形成长期收益。即使这些工作通过工单系统被规范地记录和处理，只要最终仍然需要工程师一次次手动完成，它依然属于 Toil。</p>
<p>SRE 会尽可能减少或消除 Toil，其中最重要的手段之一就是自动化。通过把重复操作交给脚本、平台或自动化系统完成，可以让工程师把时间投入到架构改进、可靠性优化和工具建设等更有长期价值的工作中。不过，并不是所有 Toil 都必须立即消除，是否值得自动化仍要结合成本和优先级判断。</p>
<p>SRE 团队需要在“日常运维”和“长期工程改进”之间保持平衡。工程师不能把全部时间都用在处理告警、响应故障和清理工单上，还必须留出足够的时间编写代码、建设自动化工具、减少 Toil，并通过工程项目持续提高系统可靠性。</p>
<p>Google SRE 模型中常引用的原则是：<strong>操作性工作最好不要长期超过团队总时间的 50%</strong>。这里的 50% 并不是严格标准，而是一个经验性的上限，用来提醒团队必须为自动化和可靠性建设保留足够的工程时间。</p>
<p>在严重故障期间，SRE 团队短时间内把几乎全部精力投入救火是正常的；但如果这种状态长期持续，说明团队已经陷入被动运维：大量时间用于处理重复问题，却没有时间从根源上消除这些问题。这不仅容易造成工程师疲劳，也会使系统可靠性难以真正提高。</p>
<p>因此，SRE 强调形成一个正向循环：控制日常运维负担，把节省下来的时间投入自动化和可靠性改进，再进一步减少未来的运维负担。同时，也需要合理分配值班和告警压力，避免少数成员长期承担过重的响应任务。</p>
<h1 id="可靠性核心思路">可靠性核心思路<a href="#%e5%8f%af%e9%9d%a0%e6%80%a7%e6%a0%b8%e5%bf%83%e6%80%9d%e8%b7%af" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>可靠性（Reliability）是指系统在发生故障、异常或中断时，仍然能够持续提供预期功能的能力。一个可靠的系统通常需要同时具备韧性（Resiliency）、可恢复性（Recoverability）和可用性（Availability）。韧性强调系统在部分组件发生故障时仍能继续运行；可恢复性强调当故障超过系统的承受能力后，能够在约定时间内恢复服务；可用性则强调用户能否在承诺的时间范围内，以预期的质量访问服务。</p>
<p>在分布式系统中，故障几乎是不可避免的。某些组件可能发生故障，而其他组件仍然正常工作，因此系统设计不能建立在“不会出错”的假设上。真正需要考虑的是：系统能否提前发现问题、限制故障影响范围，并在必要时快速恢复，避免局部故障最终影响用户体验和业务目标。</p>
<p>可靠性不能只依赖某一个环节，而应同时体现在应用代码、基础设施和日常运维中。例如，应用本身需要具备异常处理和降级能力，基础设施需要考虑冗余和故障切换，运维则需要具备监控、告警和恢复机制。这些设计都应该服务于业务需求，而不能为了提高可靠性随意改变系统原本要实现的业务目标；如果必须做出取舍，就应该把它视为明确的架构权衡。</p>
<p>因此，可靠性设计应该贯穿整个开发生命周期，从设计阶段开始考虑系统可能出现的故障，并根据实际业务要求选择合适的方案。设计原则和可靠性检查清单的作用，就是帮助团队提前考虑这些问题，而不是等系统上线后出现事故再被动补救。对于普通系统，可靠性不足可能造成服务中断和经济损失；对于关键系统，严重的可靠性问题甚至可能影响安全。</p>
<h2 id="面向业务需求进行设计">面向业务需求进行设计<a href="#%e9%9d%a2%e5%90%91%e4%b8%9a%e5%8a%a1%e9%9c%80%e6%b1%82%e8%bf%9b%e8%a1%8c%e8%ae%be%e8%ae%a1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>可靠性设计应从业务需求出发，而不是凭经验猜测。需要先明确系统范围、用户增长、服务承诺、可接受的用户体验以及成本和技术约束，再根据这些要求选择合适的可靠性方案。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>明确解决方案的范围和深度，包括需要多高的韧性、恢复能力、可观测性和简洁性，并确定成本、合规、地域、延迟等约束</td>
					<td>先搞清楚“这个系统到底需要做到什么程度”，不要一开始就按最高标准设计</td>
					<td>明确“做到什么程度就足够”，避免目标模糊导致反复修改设计、浪费成本</td>
			</tr>
			<tr>
					<td>将业务目标转化为架构上的权衡，综合考虑成本、工程复杂度、安全和运维负担</td>
					<td>每提高一点可靠性，通常都要付出额外成本，所以必须权衡</td>
					<td>让业务方理解可靠性要求背后的代价，从而形成现实可行的目标</td>
			</tr>
			<tr>
					<td>优先针对关键用户流程定义可靠性目标，而不是只关注整体 uptime</td>
					<td>不要只看“网站有没有活着”，而要看用户最重要的操作能不能完成</td>
					<td>让可靠性直接对应真正有业务价值的功能</td>
			</tr>
			<tr>
					<td>按时间尺度考虑需求，例如上线时的用户量以及未来用户是线性、快速还是不确定增长</td>
					<td>不只考虑现在能不能跑，还要考虑未来规模扩大后是否还能稳定运行</td>
					<td>既满足当前需求，又避免未来因为增长而大规模重构</td>
			</tr>
			<tr>
					<td>考虑无法完全控制的外部依赖，例如统一基础设施、安全要求、网络策略和平台限制</td>
					<td>系统的可靠性不只取决于自己，还取决于外部平台和依赖服务</td>
					<td>确保 SLO、RTO、RPO 等目标现实可行，避免做出无法兑现的承诺</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>关键用户流程（Critical User Flow）</strong>：用户完成核心业务目标所经过的一整条流程，例如“登录 → 选择商品 → 下单 → 支付”。</li>
<li><strong>Uptime</strong>：系统处于可用状态的时间比例。</li>
<li><strong>SLO</strong>：服务级别目标，用来规定系统应达到的可靠性水平。</li>
<li><strong>RTO</strong>：Recovery Time Objective，恢复时间目标，即故障后允许多长时间恢复服务。</li>
<li><strong>RPO</strong>：Recovery Point Objective，恢复点目标，即最多允许丢失多长时间范围内的数据。</li>
<li><strong>架构权衡（Trade-off）</strong>：为了获得某种好处，需要接受其他方面的代价，例如更高可靠性通常意味着更高成本和复杂度。</li>
</ul>
<hr>
<h2 id="面向韧性进行设计">面向韧性进行设计<a href="#%e9%9d%a2%e5%90%91%e9%9f%a7%e6%80%a7%e8%bf%9b%e8%a1%8c%e8%ae%be%e8%ae%a1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>韧性（Resilience）强调：即使部分组件发生故障、平台中断、性能下降或资源不足，系统仍然能够以完整或降级形式继续提供服务。设计时应默认故障一定会发生。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>区分关键路径组件和允许降级的非关键组件</td>
					<td>先判断哪些组件一坏整个业务就不行，哪些坏了只是体验差一点</td>
					<td>将可靠性资源集中到真正重要的组件上，避免过度设计</td>
			</tr>
			<tr>
					<td>找出潜在故障点，特别是关键组件，并分析对用户流程的影响</td>
					<td>提前想清楚“哪里可能坏、坏了会影响多大范围”</td>
					<td>可以评估故障类型、严重程度和影响范围，据此设计错误处理机制</td>
			</tr>
			<tr>
					<td>通过合理的设计模式、模块化和故障隔离建立系统自我保护能力</td>
					<td>一个模块出问题时，不要让问题继续传到其他模块</td>
					<td>防止故障向下游传播，缩小故障范围</td>
			</tr>
			<tr>
					<td>让关键组件具备横向扩展能力，并考虑不同区域的容量限制</td>
					<td>流量变大时，可以增加更多实例一起分担压力</td>
					<td>应对突发流量和容量变化，也能缓解单一区域资源不足</td>
			</tr>
			<tr>
					<td>在基础设施、数据、服务、运维和人员等多个层次建立冗余</td>
					<td>重要东西不要只有一份，避免一个点坏了整个系统就停</td>
					<td>减少单点故障，提高整体可用性</td>
			</tr>
			<tr>
					<td>适当进行资源超配，为系统保留额外容量</td>
					<td>平时不要把资源用到极限，要留一点余量应对突发情况</td>
					<td>在实例故障或资源异常增长时提供缓冲，为扩容和修复争取时间</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Resilience（韧性）</strong>：系统在发生部分故障时，仍然能够继续提供服务的能力。</li>
<li><strong>关键路径（Critical Path）</strong>：完成核心业务流程时必须经过的一组组件，其中任意关键组件失败都可能导致整个流程失败。</li>
<li><strong>Graceful Degradation（优雅降级）</strong>：部分功能失效时，系统主动降低功能或服务质量，但仍保持核心功能可用。</li>
<li><strong>Blast Radius</strong>：某个故障能够影响的范围。设计目标通常是尽量缩小故障影响范围。</li>
<li><strong>故障隔离（Fault Isolation）</strong>：通过架构设计阻止一个组件的故障扩散到其他组件。</li>
<li><strong>横向扩展（Scale Out）</strong>：通过增加更多服务器或实例来提高处理能力，而不是单纯增强单台机器性能。</li>
<li><strong>冗余（Redundancy）</strong>：为关键组件准备多个副本或替代路径，避免单点故障。</li>
<li><strong>单点故障（Single Point of Failure）</strong>：某个组件一旦失效，就会导致整个系统或核心功能停止。</li>
<li><strong>资源超配（Overprovisioning）</strong>：提前准备超过正常需求的计算、存储或网络资源，为故障和流量突增提供缓冲。</li>
</ul>
<hr>
<h2 id="面向恢复进行设计">面向恢复进行设计<a href="#%e9%9d%a2%e5%90%91%e6%81%a2%e5%a4%8d%e8%bf%9b%e8%a1%8c%e8%ae%be%e8%ae%a1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>再强的韧性也无法处理所有故障。因此还必须考虑 Recovery：当故障已经超过系统自身的容错能力时，如何在规定的恢复目标内重新提供服务，并恢复正确的数据状态。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>制定结构化、经过测试、有文档记录，并与恢复目标一致的恢复计划</td>
					<td>真出大故障时不能临时想怎么办，要提前把恢复步骤写清楚并测试</td>
					<td>在事故发生时能够快速、按流程恢复，减少业务和声誉损失</td>
			</tr>
			<tr>
					<td>定期进行组件、数据、故障切换和故障回切演练</td>
					<td>恢复方案不能只写在文档里，还要真正演练过</td>
					<td>验证恢复流程是否真的可用</td>
			</tr>
			<tr>
					<td>确保所有有状态组件的数据都能在恢复目标内修复</td>
					<td>服务重新启动还不够，数据库里的数据也必须能恢复</td>
					<td>利用可信恢复点和备份把系统恢复到正常状态</td>
			</tr>
			<tr>
					<td>使用不可变并保持事务一致性的备份</td>
					<td>备份本身也要可靠，不能恢复以后发现数据还是坏的</td>
					<td>防止备份被篡改，并保证恢复数据的一致性</td>
			</tr>
			<tr>
					<td>建立自动自愈能力</td>
					<td>一些常见故障可以让系统自己检测、自己恢复</td>
					<td>减少人工干预和人为错误，缩短恢复时间</td>
			</tr>
			<tr>
					<td>将无状态组件设计成不可变、可随时创建和销毁的临时单元</td>
					<td>与其在坏掉的机器上反复修，不如直接重新创建一个干净实例</td>
					<td>提高部署一致性和可重复性，并减少恢复过程中的中断</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Recovery（恢复能力）</strong>：当系统已经无法继续正常工作时，将服务恢复到可接受状态的能力。</li>
<li><strong>Stateful Component（有状态组件）</strong>：内部保存持久数据或状态的组件，例如数据库。</li>
<li><strong>Stateless Component（无状态组件）</strong>：自身不依赖本地持久状态，可以比较容易地被替换或重新创建。</li>
<li><strong>Failover（故障切换）</strong>：主系统故障后，将业务切换到备用系统。</li>
<li><strong>Failback（故障回切）</strong>：原系统恢复后，再把业务从备用系统切回。</li>
<li><strong>Immutable Backup（不可变备份）</strong>：创建后不能被随意修改或删除的备份。</li>
<li><strong>事务一致性（Transactional Consistency）</strong>：备份或恢复的数据保持完整的业务状态，不会出现部分操作成功、部分操作丢失的情况。</li>
<li><strong>Self-healing（自愈）</strong>：系统检测到故障后自动执行重启、替换、切换等恢复操作。</li>
<li><strong>Ephemeral Unit（临时单元）</strong>：可以随时创建和销毁的实例，例如容器实例。</li>
</ul>
<hr>
<h2 id="面向运维进行设计">面向运维进行设计<a href="#%e9%9d%a2%e5%90%91%e8%bf%90%e7%bb%b4%e8%bf%9b%e8%a1%8c%e8%ae%be%e8%ae%a1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>可靠性工作应该尽量 Shift Left，即提前到开发和测试阶段，而不是等生产环境发生事故之后再处理。需要尽早测试故障，同时通过可观测性、诊断、告警和自动化支撑生产环境的可靠运行。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>建立能够关联遥测数据的可观测系统</td>
					<td>系统出了问题后，要能看见发生了什么，而不是只能靠猜</td>
					<td>能确定哪里故障、何时发生、为什么发生，并观察完整用户流程</td>
			</tr>
			<tr>
					<td>预测潜在故障和异常行为，并建立有优先级、可操作的告警</td>
					<td>告警不是越多越好，而是要及时指出真正需要工程师处理的问题</td>
					<td>让 SRE 快速处理正在发生的事故，也可以提前处理潜在故障</td>
			</tr>
			<tr>
					<td>在预生产和生产环境中主动模拟故障</td>
					<td>主动制造故障，看看系统是否真的能按设计继续运行或恢复</td>
					<td>验证真实恢复能力、降级机制和可靠性阈值</td>
			</tr>
			<tr>
					<td>在设计阶段考虑自动化，并尽可能自动化测试、部署和运维</td>
					<td>重复、标准化的事情尽量交给机器完成</td>
					<td>减少人为错误，提高不同环境和操作之间的一致性</td>
			</tr>
			<tr>
					<td>评估日常操作对系统稳定性的影响，例如版本升级、安全审计、组件升级和备份</td>
					<td>很多故障不是机器自己坏了，而是正常维护时改坏的</td>
					<td>避免正常运维操作反而成为生产事故来源</td>
			</tr>
			<tr>
					<td>持续从真实生产事故中学习</td>
					<td>每次出事故都应该留下改进措施，而不是修好就算了</td>
					<td>找出设计和运维缺陷，并利用事故经验持续改进系统</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Shift Left</strong>：把测试、可靠性、安全等工作尽量提前到开发生命周期的前面阶段。</li>
<li><strong>Observability（可观测性）</strong>：根据系统产生的数据理解其内部运行状态的能力。</li>
<li><strong>Telemetry（遥测数据）</strong>：系统运行过程中自动采集的数据，例如日志、指标和调用链。</li>
<li><strong>Metrics（指标）</strong>：CPU 使用率、请求错误率、响应时间等数值数据。</li>
<li><strong>Logs（日志）</strong>：系统在运行过程中记录的事件和错误信息。</li>
<li><strong>Traces（链路追踪）</strong>：追踪一次请求在多个服务之间完整的调用过程。</li>
<li><strong>Alert（告警）</strong>：当系统达到某种异常条件时自动通知相关人员。</li>
<li><strong>Pre-production（预生产环境）</strong>：正式生产环境之前用于验证系统的环境，例如测试环境、预发布环境。</li>
<li><strong>Incident（生产事故）</strong>：已经对线上系统、用户或业务造成实际影响的故障事件。</li>
</ul>
<hr>
<h2 id="保持简单">保持简单<a href="#%e4%bf%9d%e6%8c%81%e7%ae%80%e5%8d%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>可靠性不意味着不断增加组件。系统越复杂，配置错误、组件交互和意外行为出现的可能性通常越高，因此应尽量减少没有必要的复杂性。不过也不能为了简单而形成新的单点故障，需要在简单与冗余之间保持平衡。</p>
<table>
	<thead>
			<tr>
					<th>设计方法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>只有真正有助于实现业务目标时才添加新组件，并尽量保持关键路径精简</td>
					<td>不要为了让架构“看起来高级”就不断增加服务和组件</td>
					<td>减少关键故障点，同时让系统更容易实现、理解和管理</td>
			</tr>
			<tr>
					<td>为代码、部署和运维流程建立统一标准并形成文档，尽可能通过自动验证强制执行</td>
					<td>大家按同一套规则工作，减少因为个人习惯不同导致的问题</td>
					<td>提高一致性，减少人为错误，也方便故障排查</td>
			</tr>
			<tr>
					<td>判断理论上的设计方法是否真的适合实际业务场景</td>
					<td>理论上很先进的方案，不一定适合当前系统</td>
					<td>避免过度细粒度和过度复杂设计造成额外依赖和维护负担</td>
			</tr>
			<tr>
					<td>只编写足够满足需求的代码</td>
					<td>没必要为了可能永远不会发生的问题提前写大量复杂代码</td>
					<td>减少资源浪费、数据流问题和代码缺陷</td>
			</tr>
			<tr>
					<td>优先利用平台已经提供并经过验证的功能和现成能力</td>
					<td>能用成熟方案解决的事情，就不要重新造一套</td>
					<td>缩短开发时间，并复用已经验证过的可靠性实践</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Critical Path（关键路径）</strong>：完成核心业务所必须经过的组件和步骤。</li>
<li><strong>Overengineering（过度设计）</strong>：为了并不存在或不重要的问题，加入过多组件、机制和复杂性。</li>
<li><strong>Standardization（标准化）</strong>：为代码、部署、配置和运维制定统一规则。</li>
<li><strong>Automated Validation（自动验证）</strong>：使用工具自动检查代码、配置或流程是否符合标准。</li>
<li><strong>Platform-provided Feature（平台能力）</strong>：云平台、操作系统或基础设施已经提供的成熟功能，例如负载均衡、自动扩缩容、监控和备份。</li>
<li><strong>Technical Complexity（技术复杂度）</strong>：由于组件数量、依赖关系、配置和交互增加而带来的理解、维护和故障排查难度。</li>
</ul>
<h2 id="检查清单">检查清单<a href="#%e6%a3%80%e6%9f%a5%e6%b8%85%e5%8d%95" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>这份 Checklist 用来检查一个系统的架构是否真正考虑了<strong>可靠性、韧性和故障恢复能力</strong>。核心思路是：先根据业务需求确定可用性和恢复目标，再据此选择基础设施和应用设计方案。可靠性不能只在系统上线之后考虑，而应该贯穿<strong>设计、开发、测试和运维的整个生命周期</strong>。每个架构决策都可能影响系统的可靠性，因此需要明确其中的权衡，而不是单纯堆叠高可用技术。</p>
<hr>
<ol>
<li><strong>RE:01 保持简单和高效</strong></li>
</ol>
<p><strong>Focus your workload design on simplicity and efficiency.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>让系统设计尽量保持简单，同时满足业务需求</td>
					<td>不要为了“架构高级”加入大量实际上用不到的组件和技术</td>
					<td>降低系统复杂度，减少配置错误、依赖问题和潜在故障点</td>
			</tr>
			<tr>
					<td>使用实用而不是过度复杂的方案</td>
					<td>能简单解决的问题就不要使用复杂方案</td>
					<td>降低开发、维护和故障排查成本</td>
			</tr>
			<tr>
					<td>在满足业务目标的前提下提高效率</td>
					<td>简单并不意味着功能不足，而是在满足需求后不做多余设计</td>
					<td>避免 Overengineering，让架构更容易理解和维护</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Simplicity（简单性）</strong>：尽量减少不必要的组件、依赖和逻辑。</li>
<li><strong>Efficiency（效率）</strong>：在满足目标的同时减少不必要的资源和工程投入。</li>
<li><strong>Overengineering（过度设计）</strong>：使用远超实际需求的复杂架构或技术方案。</li>
</ul>
<hr>
<ol start="2">
<li><strong>RE:02 识别并评估用户流和系统流</strong></li>
</ol>
<p><strong>Identify and rate user and system flows.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>找出系统中的用户流程和系统内部流程</td>
					<td>不要只看“有哪些服务器”，还要看用户实际怎么使用系统</td>
					<td>从完整业务流程角度分析可靠性</td>
			</tr>
			<tr>
					<td>根据业务需求评估每条流程的重要程度</td>
					<td>不同流程的重要性不一样，例如付款比查看推荐更重要</td>
					<td>把可靠性资源优先投入真正重要的业务</td>
			</tr>
			<tr>
					<td>建立关键性等级</td>
					<td>给不同流程分级，例如关键、重要、普通</td>
					<td>为后续冗余、监控和恢复策略提供依据</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>User Flow（用户流）</strong>：用户完成一个业务目标时经过的一系列步骤。</li>
<li><strong>System Flow（系统流）</strong>：系统内部组件之间完成某项功能时的数据或调用流程。</li>
<li><strong>Criticality（关键性）</strong>：某个流程对业务的重要程度。</li>
<li><strong>Critical Flow（关键流程）</strong>：一旦失败就会严重影响核心业务的流程。</li>
</ul>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>用户登录 → 搜索商品 → 加入购物车 → 下单 → 支付
</span></span></code></pre></div><p>这就是一条用户流程，其中：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>支付 &gt; 推荐商品
</span></span></code></pre></div><p>因为支付失败会直接影响业务目标，而推荐失败通常只影响体验。</p>
<hr>
<ol start="3">
<li><strong>RE:03 使用故障模式分析</strong></li>
</ol>
<p><strong>Use Failure Mode Analysis (FMA) to identify potential failures.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>找出系统可能发生的故障</td>
					<td>提前思考“什么东西可能坏”</td>
					<td>在事故发生前发现潜在风险</td>
			</tr>
			<tr>
					<td>识别组件之间的依赖关系</td>
					<td>一个组件坏了，可能会影响依赖它的其他组件</td>
					<td>防止局部故障扩大</td>
			</tr>
			<tr>
					<td>找出关键故障点</td>
					<td>分析哪些组件一旦故障会产生严重影响</td>
					<td>优先对高风险部分进行保护</td>
			</tr>
			<tr>
					<td>针对不同故障制定缓解方案</td>
					<td>不能只知道“会坏”，还要提前决定坏了怎么办</td>
					<td>提高系统应对故障的能力</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>FMA（Failure Mode Analysis，故障模式分析）</strong>：系统性分析“可能出现哪些故障，以及这些故障会产生什么影响”。</li>
<li><strong>Failure Mode（故障模式）</strong>：某个组件可能以什么方式失效。</li>
<li><strong>Failure Point（故障点）</strong>：系统中可能发生故障的位置。</li>
<li><strong>Dependency（依赖）</strong>：一个组件正常运行所依赖的其他组件或服务。</li>
<li><strong>Mitigation（缓解措施）</strong>：降低故障发生概率或影响程度的措施。</li>
</ul>
<p>可以简单理解为：</p>
<blockquote>
<p><strong>先假设每个东西都有可能坏，然后问：它坏了会怎样？我们准备怎么办？</strong></p>
</blockquote>
<hr>
<ol start="4">
<li><strong>RE:04 定义可靠性和恢复目标</strong></li>
</ol>
<p><strong>Define reliability and recovery targets.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>明确系统应该达到什么可靠性水平</td>
					<td>不要只说“系统要稳定”，而要给出具体数字</td>
					<td>让可靠性可以衡量</td>
			</tr>
			<tr>
					<td>明确故障后需要多快恢复</td>
					<td>系统挂了以后多久恢复才算可以接受</td>
					<td>指导灾难恢复方案设计</td>
			</tr>
			<tr>
					<td>根据这些目标设计系统架构</td>
					<td>先定目标，再决定要不要做冗余、备份、多区域等设计</td>
					<td>避免盲目堆高可用技术</td>
			</tr>
			<tr>
					<td>将可靠性指标作为系统健康模型的基础</td>
					<td>系统是否健康，要根据提前定义的指标判断</td>
					<td>让监控、告警和运维具有明确标准</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Reliability Target（可靠性目标）</strong>：系统需要达到的可靠性水平。</li>
<li><strong>Availability Target（可用性目标）</strong>：系统需要保持可用的时间比例。</li>
<li><strong>SLO</strong>：服务级别目标。</li>
<li><strong>RTO</strong>：Recovery Time Objective，允许的最大恢复时间。</li>
<li><strong>RPO</strong>：Recovery Point Objective，允许的数据损失范围。</li>
<li><strong>Health Model（健康模型）</strong>：通过一组指标判断系统当前是否处于正常状态的方法。</li>
</ul>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLO：99.9% 可用性
</span></span><span style="display:flex;"><span>RTO：30 分钟
</span></span><span style="display:flex;"><span>RPO：5 分钟
</span></span></code></pre></div><p>表示：</p>
<blockquote>
<p>系统应该达到 99.9% 可用性；
真挂了以后最多 30 分钟恢复；
最多允许损失最近 5 分钟的数据。</p>
</blockquote>
<hr>
<ol start="5">
<li><strong>RE:05 建立不同层次的冗余</strong></li>
</ol>
<p><strong>Add redundancy at different levels, especially for critical flows.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>为关键流程增加冗余</td>
					<td>核心业务不要依赖唯一的一台机器或一个组件</td>
					<td>防止单点故障</td>
			</tr>
			<tr>
					<td>对计算资源进行冗余</td>
					<td>一台服务器坏了，还有其他实例接管</td>
					<td>保持服务继续运行</td>
			</tr>
			<tr>
					<td>对网络等基础设施进行冗余</td>
					<td>一条网络路径故障时，可以走其他路径</td>
					<td>减少基础设施故障造成的中断</td>
			</tr>
			<tr>
					<td>部署多个解决方案实例</td>
					<td>不让系统只有唯一实例</td>
					<td>提高整体可用性和容错能力</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Redundancy（冗余）</strong>：准备多个能够完成同一功能的资源。</li>
<li><strong>Single Point of Failure（单点故障）</strong>：某个组件一旦失效，就会导致整个系统无法工作的情况。</li>
<li><strong>Instance（实例）</strong>：某个应用或服务正在运行的一个副本。</li>
<li><strong>Critical Flow（关键流程）</strong>：直接影响核心业务的用户或系统流程。</li>
</ul>
<p>最简单的例子：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>只有一台服务器
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>服务器挂了
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>网站挂了
</span></span></code></pre></div><p>增加冗余后：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>服务器 A
</span></span><span style="display:flex;"><span>服务器 B
</span></span><span style="display:flex;"><span>服务器 C
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>A 挂了
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>B、C 继续服务
</span></span></code></pre></div><hr>
<ol start="6">
<li><strong>RE:06 建立可靠的扩缩容策略</strong></li>
</ol>
<p><strong>Implement a timely and reliable scaling strategy.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>在应用、数据和基础设施层面考虑扩缩容</td>
					<td>不只是服务器要能扩，数据库和应用本身也需要能扩</td>
					<td>避免某一层成为性能瓶颈</td>
			</tr>
			<tr>
					<td>根据真实或预测的使用量进行扩缩容</td>
					<td>用户变多时增加资源，用户变少时减少资源</td>
					<td>在可靠性和成本之间取得平衡</td>
			</tr>
			<tr>
					<td>尽量减少人工操作</td>
					<td>不要等工程师发现服务器不够了才手动加机器</td>
					<td>提高扩容速度并减少人为错误</td>
			</tr>
			<tr>
					<td>确保扩容能够及时发生</td>
					<td>扩容太慢的话，资源增加之前系统可能已经挂了</td>
					<td>应对突发流量</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Scaling（扩缩容）</strong>：根据负载增加或减少系统资源。</li>
<li><strong>Scale Out（横向扩展）</strong>：增加更多实例。</li>
<li><strong>Scale In（横向缩减）</strong>：减少实例。</li>
<li><strong>Autoscaling（自动扩缩容）</strong>：根据负载自动调整资源数量。</li>
<li><strong>Usage Pattern（使用模式）</strong>：用户访问量随时间变化的规律。</li>
</ul>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>平时：5 台服务器
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>流量突然增加
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>自动扩容
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>20 台服务器
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>流量恢复正常
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>自动缩容
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>5 台服务器
</span></span></code></pre></div><hr>
<ol start="7">
<li><strong>RE:07 建立自我保护和自愈能力</strong></li>
</ol>
<p><strong>Implement self-preservation and self-healing measures.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>建立系统自我保护机制</td>
					<td>系统发现异常时先保护自己，不要继续恶化</td>
					<td>防止故障扩散</td>
			</tr>
			<tr>
					<td>建立自动自愈能力</td>
					<td>可以自动解决的问题就不要等待人工处理</td>
					<td>缩短故障恢复时间</td>
			</tr>
			<tr>
					<td>优先使用平台已有能力</td>
					<td>云平台已经提供自动重启、故障切换等能力时优先使用</td>
					<td>减少自己开发复杂机制的成本</td>
			</tr>
			<tr>
					<td>使用经过验证的云设计模式</td>
					<td>不要自己随便发明故障处理方式</td>
					<td>使用成熟经验提高可靠性</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Self-preservation（自我保护）</strong>：系统主动采取措施防止故障进一步扩大。</li>
<li><strong>Self-healing（自愈）</strong>：系统发现故障后自动恢复。</li>
<li><strong>Cloud Pattern（云设计模式）</strong>：经过大量实践验证的云架构设计方法。</li>
</ul>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>某个服务实例异常
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>健康检查发现异常
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>停止向它发送请求
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>创建新的实例
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>新实例重新加入服务
</span></span></code></pre></div><p>整个过程可以不需要人工参与。</p>
<hr>
<ol start="8">
<li><strong>RE:08 使用混沌工程测试可靠性</strong></li>
</ol>
<p><strong>Test resiliency and availability by applying chaos engineering.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>主动制造故障进行测试</td>
					<td>不要等真实事故发生才第一次看到系统怎么反应</td>
					<td>验证系统是否真的具有韧性</td>
			</tr>
			<tr>
					<td>测试系统是否能够承受组件故障</td>
					<td>主动关掉服务器、网络或服务</td>
					<td>检查冗余和故障切换是否有效</td>
			</tr>
			<tr>
					<td>测试高负载情况下是否可以扩容</td>
					<td>人为制造流量高峰</td>
					<td>验证扩缩容策略</td>
			</tr>
			<tr>
					<td>测试系统是否可以在目标时间内恢复</td>
					<td>故意制造中断，再观察恢复时间</td>
					<td>验证 RTO、RPO 等目标是否真的能达到</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Chaos Engineering（混沌工程）</strong>：主动向系统注入故障，验证系统面对真实异常时的行为。</li>
<li><strong>Fault Injection（故障注入）</strong>：人为制造服务器、网络、磁盘、服务等故障。</li>
<li><strong>Reliability Testing（可靠性测试）</strong>：验证系统是否满足既定可靠性目标。</li>
<li><strong>Resilience Testing（韧性测试）</strong>：验证系统部分组件故障时是否仍能继续运行。</li>
</ul>
<p>例如：</p>
<blockquote>
<p>主动杀掉一台生产服务器，然后观察流量是否自动切换到其他服务器。</p>
</blockquote>
<p>重点不是“故意把系统搞坏”，而是：</p>
<blockquote>
<p><strong>提前证明系统真的扛得住故障。</strong></p>
</blockquote>
<hr>
<ol start="9">
<li><strong>RE:09 建立灾难恢复计划</strong></li>
</ol>
<p><strong>Implement structured, tested, and documented disaster recovery plans.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>建立结构化的灾难恢复方案</td>
					<td>大规模故障发生以后，要有完整恢复流程</td>
					<td>避免事故发生后临时决定怎么办</td>
			</tr>
			<tr>
					<td>恢复方案必须经过测试</td>
					<td>文档上写“可以恢复”不等于真的能恢复</td>
					<td>验证实际恢复能力</td>
			</tr>
			<tr>
					<td>将恢复方案形成正式文档</td>
					<td>谁负责、怎么恢复、恢复顺序都应该写清楚</td>
					<td>减少事故期间的混乱</td>
			</tr>
			<tr>
					<td>恢复方案应满足既定恢复目标</td>
					<td>恢复速度和数据损失必须符合 RTO、RPO</td>
					<td>保证灾难恢复能力满足业务要求</td>
			</tr>
			<tr>
					<td>既考虑单个组件，也考虑整个系统</td>
					<td>不能只知道如何恢复一台服务器</td>
					<td>应对区域级、平台级等大规模事故</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>DR（Disaster Recovery，灾难恢复）</strong>：面对严重系统中断或灾难时恢复业务的完整方案。</li>
<li><strong>Disaster Recovery Plan（灾难恢复计划）</strong>：描述事故发生后如何恢复系统、数据和业务的正式流程。</li>
<li><strong>Failover（故障切换）</strong>：从故障系统切换到备用系统。</li>
<li><strong>Failback（故障回切）</strong>：原系统恢复后重新切回。</li>
<li><strong>Recovery Drill（恢复演练）</strong>：定期模拟灾难并实际执行恢复流程。</li>
</ul>
<p>普通故障可能是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>一台服务器挂了
</span></span></code></pre></div><p>而 Disaster Recovery 更关注：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>整个机房故障
</span></span><span style="display:flex;"><span>整个区域故障
</span></span><span style="display:flex;"><span>严重数据损坏
</span></span><span style="display:flex;"><span>大规模网络中断
</span></span></code></pre></div><hr>
<ol start="10">
<li><strong>RE:10 持续监控系统健康状态</strong></li>
</ol>
<p><strong>Continuously measure and track system health.</strong></p>
<table>
	<thead>
			<tr>
					<th>设计建议</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>持续监控系统健康状态</td>
					<td>不能等用户告诉你“网站挂了”才发现问题</td>
					<td>尽早发现异常</td>
			</tr>
			<tr>
					<td>监控各组件和关键流程</td>
					<td>不只看单台服务器，还要看用户的完整业务流程</td>
					<td>判断故障是否真正影响用户</td>
			</tr>
			<tr>
					<td>使用 uptime 和可靠性指标</td>
					<td>用数据判断系统是否满足可靠性目标</td>
					<td>衡量 SLO 等目标是否实现</td>
			</tr>
			<tr>
					<td>保存历史监控数据</td>
					<td>监控数据不能看完就丢</td>
					<td>支持趋势分析和事故调查</td>
			</tr>
			<tr>
					<td>确保监控数据可以快速访问</td>
					<td>出事故后要马上能找到相关数据</td>
					<td>帮助故障响应和根因分析</td>
			</tr>
			<tr>
					<td>利用监控数据进行事故后分析</td>
					<td>事故结束后回看当时系统发生了什么</td>
					<td>支持 Postmortem 和持续改进</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>System Health（系统健康状态）</strong>：系统当前是否正常完成预期功能的整体状态。</li>
<li><strong>Reliability Indicator（可靠性指标）</strong>：衡量系统可靠性的指标，例如可用率、错误率和延迟。</li>
<li><strong>Uptime</strong>：系统正常可用的时间比例。</li>
<li><strong>Monitoring（监控）</strong>：持续收集和观察系统运行状态。</li>
<li><strong>Post-incident Analysis（事故后分析）</strong>：故障结束后根据监控、日志等数据分析事故原因。</li>
<li><strong>Retention（数据保留）</strong>：保存历史监控数据，供之后查询和分析。</li>
</ul>
<hr>
<h2 id="整体理解">整体理解<a href="#%e6%95%b4%e4%bd%93%e7%90%86%e8%a7%a3" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>这 10 条其实可以压缩成一个完整的可靠性设计流程：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>RE:01 先保持设计简单
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:02 找出哪些业务流程最重要
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:03 分析这些流程可能怎么坏
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:04 定义到底需要多可靠、多久恢复
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:05 给关键部分增加冗余
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:06 确保流量增加时能够及时扩容
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:07 让系统能够自我保护和自动恢复
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:08 主动制造故障，验证这些设计真的有效
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:09 如果发生严重灾难，要有完整恢复方案
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>RE:10 持续监控，确认系统实际是否达到目标
</span></span></code></pre></div><p>也就是说，这份 Checklist 并不是 10 个彼此独立的要求，而是从：</p>
<blockquote>
<p><strong>明确业务 → 找出关键流程 → 分析故障 → 定目标 → 做冗余和扩容 → 自动恢复 → 主动测试 → 灾难恢复 → 持续监控</strong></p>
</blockquote>
<p>构成了一套完整的可靠性设计思路。</p>
<h1 id="azure">Azure<a href="#azure" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<h2 id="云计算基础">云计算基础<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e5%9f%ba%e7%a1%80" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>云计算（Cloud Computing）是通过互联网按需提供计算服务的模式，它把原本需要自行购买和维护的 IT 资源变成随用随取的服务。这里的计算服务既包括虚拟机、存储、数据库和网络等传统基础设施，也包括物联网（IoT）、机器学习（ML）和人工智能（AI）等能力。</p>
<h3 id="云计算提供什么">云计算提供什么<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e6%8f%90%e4%be%9b%e4%bb%80%e4%b9%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<table>
	<thead>
			<tr>
					<th>服务类型</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Virtual Machines</td>
					<td>在云里运行一台虚拟电脑</td>
					<td>Windows / Linux 虚拟机</td>
			</tr>
			<tr>
					<td>Storage</td>
					<td>在云里保存数据</td>
					<td>文件、对象、备份</td>
			</tr>
			<tr>
					<td>Databases</td>
					<td>使用云端数据库</td>
					<td>SQL、NoSQL</td>
			</tr>
			<tr>
					<td>Networking</td>
					<td>提供网络连接和流量管理</td>
					<td>虚拟网络、负载均衡</td>
			</tr>
			<tr>
					<td>IoT</td>
					<td>连接和管理物联网设备</td>
					<td>传感器、工业设备</td>
			</tr>
			<tr>
					<td>ML</td>
					<td>提供机器学习能力</td>
					<td>模型训练、预测</td>
			</tr>
			<tr>
					<td>AI</td>
					<td>提供人工智能能力</td>
					<td>语音、视觉、生成式 AI</td>
			</tr>
	</tbody>
</table>
<h3 id="为什么云计算和传统数据中心不同">为什么云计算和传统数据中心不同<a href="#%e4%b8%ba%e4%bb%80%e4%b9%88%e4%ba%91%e8%ae%a1%e7%ae%97%e5%92%8c%e4%bc%a0%e7%bb%9f%e6%95%b0%e6%8d%ae%e4%b8%ad%e5%bf%83%e4%b8%8d%e5%90%8c" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统数据中心受物理基础设施限制较大。企业突然需要更多计算资源时，通常要经历以下过程：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>评估需求
</span></span><span style="display:flex;"><span>→ 购买服务器
</span></span><span style="display:flex;"><span>→ 等待运输
</span></span><span style="display:flex;"><span>→ 安装服务器
</span></span><span style="display:flex;"><span>→ 配置网络
</span></span><span style="display:flex;"><span>→ 部署系统
</span></span></code></pre></div><p>采购、运输、安装和配置可能耗时很久，而云计算允许企业通过平台直接申请资源：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>需要更多资源
</span></span><span style="display:flex;"><span>→ 在云平台申请
</span></span><span style="display:flex;"><span>→ 几分钟内获得资源
</span></span></code></pre></div><p>两种方式的差别在于，基础设施从“提前购买”变成了“按需获取”。</p>
<h3 id="实际例子">实际例子<a href="#%e5%ae%9e%e9%99%85%e4%be%8b%e5%ad%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>假设一家零售公司准备进行大型季节性促销，预计活动期间访问量会突然增加。传统方式可能需要提前几个月购买额外服务器：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>购买服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>安装和配置
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>促销期间使用
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>促销结束
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>大量服务器闲置
</span></span></code></pre></div><p>使用云计算时，企业可以根据活动进度调整资源：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>促销开始
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>临时增加云计算资源
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>处理高峰流量
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>促销结束
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>减少资源
</span></span></code></pre></div><p>这种做法既能更快应对流量变化，也能让成本更接近实际需求。</p>
<h3 id="云计算带来的几个变化">云计算带来的几个变化<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e5%b8%a6%e6%9d%a5%e7%9a%84%e5%87%a0%e4%b8%aa%e5%8f%98%e5%8c%96" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<table>
	<thead>
			<tr>
					<th>变化</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>On-demand Provisioning</td>
					<td>需要资源时再创建</td>
					<td>不必提前几个月购买服务器</td>
			</tr>
			<tr>
					<td>Rapid Scaling</td>
					<td>可以快速增加或减少资源</td>
					<td>更容易应对流量变化</td>
			</tr>
			<tr>
					<td>Faster Testing</td>
					<td>可以快速创建测试环境</td>
					<td>开发和测试速度更快</td>
			</tr>
			<tr>
					<td>Faster Recovery</td>
					<td>故障后可以快速重新创建或切换资源</td>
					<td>提高恢复能力</td>
			</tr>
			<tr>
					<td>Global Reach</td>
					<td>可以在世界不同地区部署服务</td>
					<td>让服务更靠近用户</td>
			</tr>
			<tr>
					<td>Regional Resilience</td>
					<td>可以跨区域设计系统</td>
					<td>一个区域出问题时，可以由其他区域继续提供服务</td>
			</tr>
	</tbody>
</table>
<h3 id="关键词">关键词<a href="#%e5%85%b3%e9%94%ae%e8%af%8d" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<ul>
<li><strong>Cloud Computing（云计算）</strong>：通过互联网按需提供计算资源和服务。</li>
<li><strong>IT Infrastructure（IT 基础设施）</strong>：运行信息系统所需要的计算、存储、网络等基础资源。</li>
<li><strong>Virtual Machine，VM（虚拟机）</strong>：通过软件模拟出来的一台完整计算机。</li>
<li><strong>Storage（存储）</strong>：用于保存文件和数据的资源。</li>
<li><strong>Database（数据库）</strong>：用于组织、保存和查询数据的系统。</li>
<li><strong>Networking（网络）</strong>：负责不同计算资源之间的通信。</li>
<li><strong>IoT（Internet of Things，物联网）</strong>：让各种物理设备连接到网络并交换数据。</li>
<li><strong>ML（Machine Learning，机器学习）</strong>：让计算机通过数据学习规律并进行预测或判断。</li>
<li><strong>AI（Artificial Intelligence，人工智能）</strong>：让计算机完成通常需要人类智能才能完成的任务。</li>
<li><strong>Provisioning（资源预配）</strong>：创建并准备计算资源，使其可以使用。</li>
<li><strong>On-demand（按需）</strong>：需要时再申请资源，而不是提前准备。</li>
<li><strong>Scaling（扩缩容）</strong>：根据负载增加或减少资源。</li>
<li><strong>Global Reach（全球覆盖）</strong>：利用云平台在多个国家和地区部署服务。</li>
<li><strong>Regional Resilience（区域韧性）</strong>：通过跨区域部署降低单一区域故障带来的影响。</li>
</ul>
<h3 id="本节总结">本节总结<a href="#%e6%9c%ac%e8%8a%82%e6%80%bb%e7%bb%93" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统 IT 的资源准备流程是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>传统 IT
</span></span><span style="display:flex;"><span>先买资源
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>安装和配置
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>再使用
</span></span></code></pre></div><p>云计算则把流程改为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云计算
</span></span><span style="display:flex;"><span>需要资源
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>立即创建
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>按需使用
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>不用时释放
</span></span></code></pre></div><p>因此，云计算把 IT 基础设施从长期采购、固定容量的资产，变成了可以按需获取、快速扩展和及时释放的服务。</p>
<h2 id="云计算共享责任模型shared-responsibility-model">云计算共享责任模型（Shared Responsibility Model）<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e5%85%b1%e4%ba%ab%e8%b4%a3%e4%bb%bb%e6%a8%a1%e5%9e%8bshared-responsibility-model" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>共享责任模型说明了云服务商与客户各自负责什么。传统本地数据中心的机房、服务器、网络、操作系统、应用和数据几乎都由企业管理；迁移到云之后，云服务商接管底层基础设施，客户仍要管理自己的数据和访问权限，操作系统、平台与应用等中间层则取决于使用的是 IaaS、PaaS 还是 SaaS。</p>
<hr>
<h3 id="1-本地数据中心中的责任">1. 本地数据中心中的责任<a href="#1-%e6%9c%ac%e5%9c%b0%e6%95%b0%e6%8d%ae%e4%b8%ad%e5%bf%83%e4%b8%ad%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>在传统本地数据中心（On-Premises）中，企业需要负责几乎整个 IT 环境：</p>
<table>
	<thead>
			<tr>
					<th>责任内容</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>维护物理空间</td>
					<td>机房、门禁、消防等都需要企业自己管理</td>
					<td>保证服务器所在环境安全</td>
			</tr>
			<tr>
					<td>负责电力和冷却</td>
					<td>服务器供电、UPS、空调散热都要自己维护</td>
					<td>保证硬件能够持续运行</td>
			</tr>
			<tr>
					<td>维护物理服务器</td>
					<td>服务器坏了需要自己维修或更换</td>
					<td>保证计算资源可用</td>
			</tr>
			<tr>
					<td>维护网络</td>
					<td>交换机、路由器、线路等都由自己管理</td>
					<td>保证设备之间能够通信</td>
			</tr>
			<tr>
					<td>管理操作系统和软件</td>
					<td>系统安装、版本升级和补丁都需要自己完成</td>
					<td>保证软件环境正常和安全</td>
			</tr>
			<tr>
					<td>管理应用、账号和数据</td>
					<td>应用部署、用户权限和数据保护都由企业负责</td>
					<td>保证业务系统和数据安全</td>
			</tr>
	</tbody>
</table>
<p>因此，On-Premises 基本意味着所有责任都由企业自己承担。</p>
<hr>
<h3 id="2-上云以后责任开始分开">2. 上云以后，责任开始分开<a href="#2-%e4%b8%8a%e4%ba%91%e4%bb%a5%e5%90%8e%e8%b4%a3%e4%bb%bb%e5%bc%80%e5%a7%8b%e5%88%86%e5%bc%80" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>使用云计算后，客户无法直接接触的数据中心、供电、冷却、物理网络和服务器等底层设施会转由云服务商负责：</p>
<table>
	<thead>
			<tr>
					<th>云服务商负责</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Physical Security</td>
					<td>数据中心的门禁、安保等物理安全</td>
			</tr>
			<tr>
					<td>Power</td>
					<td>数据中心和服务器供电</td>
			</tr>
			<tr>
					<td>Cooling</td>
					<td>服务器散热和机房温度控制</td>
			</tr>
			<tr>
					<td>Network Connectivity</td>
					<td>底层数据中心网络连接</td>
			</tr>
			<tr>
					<td>Physical Hardware</td>
					<td>真正的物理服务器及相关设备</td>
			</tr>
	</tbody>
</table>
<p>与此同时，客户仍然必须管理自己的数据、账号、身份和访问控制：</p>
<table>
	<thead>
			<tr>
					<th>客户负责</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Data</td>
					<td>自己上传、创建和保存的数据</td>
			</tr>
			<tr>
					<td>Information</td>
					<td>企业自己的业务信息</td>
			</tr>
			<tr>
					<td>Access Security</td>
					<td>谁能够访问系统和数据</td>
			</tr>
			<tr>
					<td>Accounts</td>
					<td>用户和服务账号</td>
			</tr>
			<tr>
					<td>Identities</td>
					<td>用户、服务和设备的身份</td>
			</tr>
	</tbody>
</table>
<p>Microsoft 可以替客户维护服务器，却不能替客户决定“张三是否应该看到公司的财务数据”。</p>
<hr>
<h3 id="3-有些责任取决于使用方式">3. 有些责任取决于使用方式<a href="#3-%e6%9c%89%e4%ba%9b%e8%b4%a3%e4%bb%bb%e5%8f%96%e5%86%b3%e4%ba%8e%e4%bd%bf%e7%94%a8%e6%96%b9%e5%bc%8f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>部分责任会随云服务模式变化。以 SQL 数据库为例：</p>
<p><strong>使用云端托管 SQL 数据库</strong></p>
<p>如果直接使用云服务商提供的数据库服务：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云服务商：
</span></span><span style="display:flex;"><span>维护数据库平台
</span></span><span style="display:flex;"><span>安装数据库补丁
</span></span><span style="display:flex;"><span>维护底层服务器
</span></span><span style="display:flex;"><span>维护操作系统
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>客户：
</span></span><span style="display:flex;"><span>管理数据库中的数据
</span></span><span style="display:flex;"><span>配置用户和权限
</span></span><span style="display:flex;"><span>决定数据如何使用
</span></span></code></pre></div><p>这种情况下，数据库平台本身主要由云服务商维护。</p>
<p><strong>在虚拟机中自己安装 SQL Server</strong></p>
<p>如果先创建一台虚拟机，再自己安装 SQL Server：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云服务商：
</span></span><span style="display:flex;"><span>维护物理服务器
</span></span><span style="display:flex;"><span>维护数据中心
</span></span><span style="display:flex;"><span>维护底层物理网络
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>客户：
</span></span><span style="display:flex;"><span>维护虚拟机操作系统
</span></span><span style="display:flex;"><span>安装和更新 SQL Server
</span></span><span style="display:flex;"><span>安装数据库补丁
</span></span><span style="display:flex;"><span>配置数据库
</span></span><span style="display:flex;"><span>维护数据库中的数据
</span></span></code></pre></div><p>同样是 SQL 数据库，采用不同的服务模式，责任划分也会完全不同。</p>
<hr>
<h3 id="4-共享责任与-iaaspaassaas">4. 共享责任与 IaaS、PaaS、SaaS<a href="#4-%e5%85%b1%e4%ba%ab%e8%b4%a3%e4%bb%bb%e4%b8%8e-iaaspaassaas" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>共享责任模型与云服务模式直接相关，总体规律是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>On-Premises → IaaS → PaaS → SaaS
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>客户负责的内容越来越少
</span></span><span style="display:flex;"><span>云服务商负责的内容越来越多
</span></span></code></pre></div><table>
	<thead>
			<tr>
					<th>服务模式</th>
					<th>客户责任</th>
					<th>云服务商责任</th>
					<th>通俗理解</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>On-Premises</td>
					<td>几乎全部</td>
					<td>几乎没有</td>
					<td>什么都自己管</td>
			</tr>
			<tr>
					<td>IaaS</td>
					<td>较多</td>
					<td>主要负责底层物理基础设施</td>
					<td>云厂商给你基础设施，上面的东西大多自己管</td>
			</tr>
			<tr>
					<td>PaaS</td>
					<td>中等</td>
					<td>基础设施和平台主要由厂商负责</td>
					<td>云厂商连运行平台都帮你维护</td>
			</tr>
			<tr>
					<td>SaaS</td>
					<td>较少</td>
					<td>大部分系统由厂商负责</td>
					<td>直接使用厂商已经运行好的软件</td>
			</tr>
	</tbody>
</table>
<p>越靠近 IaaS，客户越像在自行运维；越靠近 SaaS，客户越接近直接使用现成服务。</p>
<hr>
<h3 id="5-iaas-中的责任">5. IaaS 中的责任<a href="#5-iaas-%e4%b8%ad%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>IaaS（Infrastructure as a Service）主要把底层物理基础设施交给云服务商。</p>
<table>
	<thead>
			<tr>
					<th>云服务商负责</th>
					<th>客户通常负责</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>数据中心</td>
					<td>操作系统</td>
			</tr>
			<tr>
					<td>物理服务器</td>
					<td>操作系统补丁</td>
			</tr>
			<tr>
					<td>电力与冷却</td>
					<td>应用程序</td>
			</tr>
			<tr>
					<td>物理网络</td>
					<td>数据</td>
			</tr>
			<tr>
					<td>底层基础设施</td>
					<td>用户与权限</td>
			</tr>
	</tbody>
</table>
<p>IaaS 可以理解为云厂商提供一台“云里的电脑”，但系统里安装什么、如何配置和维护，主要仍由客户负责。</p>
<hr>
<h3 id="6-paas-中的责任">6. PaaS 中的责任<a href="#6-paas-%e4%b8%ad%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>PaaS（Platform as a Service）进一步把操作系统和运行平台交给云服务商维护，客户主要关注：</p>
<ul>
<li>应用代码</li>
<li>业务逻辑</li>
<li>数据</li>
<li>用户</li>
<li>权限</li>
</ul>
<p>云服务商主要负责：</p>
<ul>
<li>物理基础设施</li>
<li>操作系统</li>
<li>平台运行环境</li>
<li>平台维护和补丁</li>
</ul>
<p>PaaS 不只提供机器，还准备好应用运行的平台，因此开发人员可以少关注服务器和系统维护，把更多精力放在应用本身。</p>
<hr>
<h3 id="7-saas-中的责任">7. SaaS 中的责任<a href="#7-saas-%e4%b8%ad%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>SaaS（Software as a Service）中，云服务商负责的内容最多。客户直接使用已经运行好的软件，不需要自己维护：</p>
<ul>
<li>软件安装</li>
<li>操作系统</li>
<li>服务器</li>
<li>数据库基础设施</li>
<li>软件补丁</li>
<li>平台升级</li>
</ul>
<p>客户仍然需要管理自己的数据和使用方式，包括：</p>
<ul>
<li>自己的数据</li>
<li>用户账号</li>
<li>角色</li>
<li>权限</li>
<li>接入设备</li>
</ul>
<p>SaaS 的软件已经由服务商运行，客户主要负责如何使用它。</p>
<hr>
<h3 id="8-无论使用哪种云服务始终由客户负责的内容">8. 无论使用哪种云服务，始终由客户负责的内容<a href="#8-%e6%97%a0%e8%ae%ba%e4%bd%bf%e7%94%a8%e5%93%aa%e7%a7%8d%e4%ba%91%e6%9c%8d%e5%8a%a1%e5%a7%8b%e7%bb%88%e7%94%b1%e5%ae%a2%e6%88%b7%e8%b4%9f%e8%b4%a3%e7%9a%84%e5%86%85%e5%ae%b9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>无论采用哪种云服务，信息与数据、终端设备、账号与身份始终由客户负责：</p>
<table>
	<thead>
			<tr>
					<th>内容</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Information and Data</td>
					<td>自己存储在云中的信息和数据</td>
			</tr>
			<tr>
					<td>Devices / Endpoints</td>
					<td>允许连接到云环境的电脑、手机等设备</td>
			</tr>
			<tr>
					<td>Accounts and Identities</td>
					<td>用户、服务和设备的账号及身份</td>
			</tr>
	</tbody>
</table>
<p>上云不会把数据、账号、身份和终端设备的责任转交给云服务商。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Information and Data（信息和数据）</strong>：企业在云中创建、存储和处理的业务信息。</li>
<li><strong>Endpoint（终端）</strong>：连接云环境的电脑、手机等设备。</li>
<li><strong>Identity（身份）</strong>：用户、服务或设备在系统中的身份。</li>
<li><strong>Account（账号）</strong>：用来登录和访问系统的账户。</li>
</ul>
<hr>
<h3 id="9-无论使用哪种云服务始终由云服务商负责的内容">9. 无论使用哪种云服务，始终由云服务商负责的内容<a href="#9-%e6%97%a0%e8%ae%ba%e4%bd%bf%e7%94%a8%e5%93%aa%e7%a7%8d%e4%ba%91%e6%9c%8d%e5%8a%a1%e5%a7%8b%e7%bb%88%e7%94%b1%e4%ba%91%e6%9c%8d%e5%8a%a1%e5%95%86%e8%b4%9f%e8%b4%a3%e7%9a%84%e5%86%85%e5%ae%b9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云服务商始终负责客户无法直接接触的物理云基础设施：</p>
<table>
	<thead>
			<tr>
					<th>内容</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Physical Datacenter</td>
					<td>真正的数据中心和机房</td>
			</tr>
			<tr>
					<td>Physical Network</td>
					<td>数据中心中的实体网络设备和线路</td>
			</tr>
			<tr>
					<td>Physical Hosts</td>
					<td>真正运行云服务的物理服务器</td>
			</tr>
	</tbody>
</table>
<p>资源进入云环境后，真正的机房、物理服务器和物理网络便不再由客户维护。</p>
<hr>
<h3 id="10-根据服务类型决定的责任">10. 根据服务类型决定的责任<a href="#10-%e6%a0%b9%e6%8d%ae%e6%9c%8d%e5%8a%a1%e7%b1%bb%e5%9e%8b%e5%86%b3%e5%ae%9a%e7%9a%84%e8%b4%a3%e4%bb%bb" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>下面这些责任会随着 IaaS、PaaS、SaaS 的不同而变化：</p>
<table>
	<thead>
			<tr>
					<th>责任</th>
					<th>为什么会变化</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Operating Systems</td>
					<td>IaaS 通常由客户维护，PaaS / SaaS 更多由厂商维护</td>
			</tr>
			<tr>
					<td>Network Controls</td>
					<td>不同服务模式允许客户控制的网络层级不同</td>
			</tr>
			<tr>
					<td>Applications</td>
					<td>IaaS / PaaS 中更多由客户负责，SaaS 中更多由厂商负责</td>
			</tr>
			<tr>
					<td>Identity and Access</td>
					<td>客户和厂商通常共同承担</td>
			</tr>
			<tr>
					<td>Infrastructure</td>
					<td>上云之后逐渐转移给云服务商</td>
			</tr>
	</tbody>
</table>
<p><strong>Identity and Access 为什么是共享责任</strong></p>
<p>以 PaaS 或 SaaS 中的身份与访问为例，云服务商负责：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>运行认证平台
</span></span><span style="display:flex;"><span>维护认证服务
</span></span><span style="display:flex;"><span>维护底层身份基础设施
</span></span></code></pre></div><p>客户则负责：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>创建哪些用户
</span></span><span style="display:flex;"><span>给用户什么角色
</span></span><span style="display:flex;"><span>配置什么权限
</span></span><span style="display:flex;"><span>制定什么访问策略
</span></span></code></pre></div><p>在 Microsoft Entra ID 中，Microsoft 负责身份平台的运行，企业负责决定谁能登录以及登录后可以执行哪些操作。</p>
<hr>
<h3 id="关键词-1">关键词<a href="#%e5%85%b3%e9%94%ae%e8%af%8d-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<ul>
<li><strong>Shared Responsibility Model（共享责任模型）</strong>：云服务商与客户共同承担云环境中的管理、安全和运维责任。</li>
<li><strong>On-Premises（本地部署）</strong>：服务器和基础设施由企业自己拥有和维护。</li>
<li><strong>Cloud Provider（云服务商）</strong>：提供云基础设施和服务的厂商，例如 Microsoft Azure。</li>
<li><strong>Consumer / Customer（客户）</strong>：使用云服务的组织或个人。</li>
<li><strong>IaaS（Infrastructure as a Service）</strong>：基础设施即服务。</li>
<li><strong>PaaS（Platform as a Service）</strong>：平台即服务。</li>
<li><strong>SaaS（Software as a Service）</strong>：软件即服务。</li>
<li><strong>Identity and Access Management，IAM（身份与访问管理）</strong>：管理用户身份以及用户能够访问哪些资源。</li>
<li><strong>Authentication（认证）</strong>：确认“你是谁”。</li>
<li><strong>Authorization（授权）</strong>：确认“你能够做什么”。</li>
<li><strong>Role（角色）</strong>：一组预先定义好的权限。</li>
<li><strong>Policy（策略）</strong>：用于规定访问和使用规则的配置。</li>
<li><strong>Patch（补丁）</strong>：修复软件漏洞、Bug 或安全问题的软件更新。</li>
</ul>
<hr>
<h3 id="本节总结-1">本节总结<a href="#%e6%9c%ac%e8%8a%82%e6%80%bb%e7%bb%93-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>共享责任会随着服务模式变化：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>On-Premises
</span></span><span style="display:flex;"><span>客户几乎什么都负责
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>IaaS
</span></span><span style="display:flex;"><span>云服务商接管物理基础设施
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>PaaS
</span></span><span style="display:flex;"><span>云服务商进一步接管操作系统和平台
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>SaaS
</span></span><span style="display:flex;"><span>云服务商连应用本身也主要负责
</span></span></code></pre></div><p>客户承担的责任依次减少：</p>
<table>
	<thead>
			<tr>
					<th>模式</th>
					<th>客户责任</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>On-Premises</td>
					<td>最多</td>
			</tr>
			<tr>
					<td>IaaS</td>
					<td>较多</td>
			</tr>
			<tr>
					<td>PaaS</td>
					<td>较少</td>
			</tr>
			<tr>
					<td>SaaS</td>
					<td>最少</td>
			</tr>
	</tbody>
</table>
<p>无论采用哪种模式，客户始终负责数据、身份、账号和终端设备，云服务商始终负责物理数据中心、物理网络和物理服务器。共享责任模型并不表示责任消失，而是随着 On-Premises → IaaS → PaaS → SaaS，越来越多底层责任从客户转移到云服务商。</p>
<h2 id="云计算部署模型cloud-models">云计算部署模型（Cloud Models）<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e9%83%a8%e7%bd%b2%e6%a8%a1%e5%9e%8bcloud-models" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>云模型说明云资源以什么方式部署、由谁使用以及资源属于谁，主要分为三种：</p>
<ul>
<li>Private Cloud（私有云）</li>
<li>Public Cloud（公有云）</li>
<li>Hybrid Cloud（混合云）</li>
</ul>
<p>Multicloud（多云）也很常见，但它描述的是同时采用多个公有云平台，与三种基本部署模型不是同一个分类维度。公有云向多个客户开放，私有云只供一个组织使用，混合云则把公有云和私有云连接起来。</p>
<hr>
<h3 id="1-private-cloud私有云">1. Private Cloud（私有云）<a href="#1-private-cloud%e7%a7%81%e6%9c%89%e4%ba%91" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>私有云是只供一个组织使用的云环境，可以看作传统数据中心云化后的形态。它仍然服务于单一组织，但资源管理方式更接近云计算，可以部署在企业自己的数据中心、其他专用数据中心，也可以交给第三方托管：</p>
<ul>
<li>建在企业自己的本地数据中心</li>
<li>建在其他专用数据中心</li>
<li>甚至由第三方帮企业托管</li>
</ul>
<table>
	<thead>
			<tr>
					<th>特点</th>
					<th>通俗解释</th>
					<th>影响</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>资源只属于一个组织</td>
					<td>不和其他客户共享核心资源</td>
					<td>控制能力更强</td>
			</tr>
			<tr>
					<td>企业对资源和安全拥有完整控制权</td>
					<td>网络、安全策略、硬件配置等都可以自己决定</td>
					<td>更容易满足特殊安全要求</td>
			</tr>
			<tr>
					<td>数据不会和其他租户放在同一个共享环境中</td>
					<td>更容易进行严格的数据隔离</td>
					<td>适合部分高安全、高合规场景</td>
			</tr>
			<tr>
					<td>需要自己购买硬件</td>
					<td>服务器等基础设施不能直接按需从公共云获取</td>
					<td>初始投入通常更高</td>
			</tr>
			<tr>
					<td>企业负责硬件维护和升级</td>
					<td>服务器坏了、需要升级都要自己处理</td>
					<td>运维负担更重</td>
			</tr>
			<tr>
					<td>公有云的一些优势会减少</td>
					<td>扩容速度、按需使用等能力可能不如公有云</td>
					<td>灵活性通常较低</td>
			</tr>
	</tbody>
</table>
<p>私有云就是公司专用的一套云。例如，一家银行可能因为安全、监管或数据要求，不希望核心系统运行在共享公有云中，因此建立自己的私有云。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Private Cloud（私有云）</strong>：只供单一组织使用的云环境。</li>
<li><strong>Dedicated Resources（专用资源）</strong>：资源专门分配给某个组织，而不是和其他客户共同使用。</li>
<li><strong>Tenant（租户）</strong>：使用云平台资源的一个独立客户或组织。</li>
<li><strong>On-site / On-premises（本地）</strong>：资源部署在企业自己的场地或数据中心。</li>
<li><strong>Control（控制权）</strong>：企业能够直接决定硬件、网络、安全和配置方式的程度。</li>
</ul>
<hr>
<h3 id="2-public-cloud公有云">2. Public Cloud（公有云）<a href="#2-public-cloud%e5%85%ac%e6%9c%89%e4%ba%91" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>公有云由第三方云服务商建设、运营和维护，个人或组织通常都可以购买和使用，其中 Microsoft Azure 就是公有云平台。</p>
<table>
	<thead>
			<tr>
					<th>特点</th>
					<th>通俗解释</th>
					<th>影响</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>云平台由第三方服务商建设和管理</td>
					<td>客户不用自己建设数据中心</td>
					<td>大幅减少基础设施维护工作</td>
			</tr>
			<tr>
					<td>大量客户共同使用云平台</td>
					<td>云厂商把庞大的基础设施提供给很多客户使用</td>
					<td>可以形成规模效应</td>
			</tr>
			<tr>
					<td>不需要为了扩容提前购买硬件</td>
					<td>需要更多资源时直接申请</td>
					<td>扩容速度快</td>
			</tr>
			<tr>
					<td>应用可以快速创建和删除</td>
					<td>需要时开，不需要时关</td>
					<td>非常灵活</td>
			</tr>
			<tr>
					<td>按实际使用量付费</td>
					<td>用多少资源通常付多少费用</td>
					<td>避免大量闲置基础设施</td>
			</tr>
			<tr>
					<td>客户不能完全控制底层资源和物理安全</td>
					<td>机房、物理服务器等由云厂商管理</td>
					<td>控制权比私有云低</td>
			</tr>
	</tbody>
</table>
<p>云厂商建设和维护大型平台，再把资源按需提供给大量客户。企业需要 100 台服务器时，可以直接在 Azure 上创建虚拟机，不必自行采购 100 台实体服务器。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Public Cloud（公有云）</strong>：由第三方云服务商运营，并向多个客户提供服务的云环境。</li>
<li><strong>Cloud Provider（云服务商）</strong>：建设和运营公有云的企业。</li>
<li><strong>Provisioning（资源预配）</strong>：创建并准备云资源。</li>
<li><strong>Deprovisioning（资源释放）</strong>：删除或停止不再需要的云资源。</li>
<li><strong>Capital Expenditure，CapEx（资本支出）</strong>：提前购买服务器、机房等长期资产所需要的大额投入。</li>
<li><strong>Pay-as-you-go（按使用付费）</strong>：根据实际资源使用量支付费用。</li>
</ul>
<hr>
<h3 id="3-hybrid-cloud混合云">3. Hybrid Cloud（混合云）<a href="#3-hybrid-cloud%e6%b7%b7%e5%90%88%e4%ba%91" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>混合云把公有云和私有云连接起来共同使用。企业不必在两者之间二选一，可以根据业务、安全、成本和合规要求决定各个系统的运行位置。</p>
<table>
	<thead>
			<tr>
					<th>特点</th>
					<th>通俗解释</th>
					<th>影响</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>同时使用公有云和私有云</td>
					<td>一部分系统放自己这里，一部分放公共云</td>
					<td>灵活性最高</td>
			</tr>
			<tr>
					<td>企业可以决定每个应用运行在哪里</td>
					<td>不同业务根据需求选择最适合的环境</td>
					<td>可以兼顾成本、安全和性能</td>
			</tr>
			<tr>
					<td>私有云资源不足时，可以借用公有云资源</td>
					<td>临时高峰不需要提前购买大量硬件</td>
					<td>更容易应对短期流量增长</td>
			</tr>
			<tr>
					<td>敏感服务可以保留在私有云</td>
					<td>不适合上公有云的数据仍然留在企业内部</td>
					<td>更容易满足安全或法律要求</td>
			</tr>
			<tr>
					<td>普通服务可以使用公有云</td>
					<td>对安全要求较低的系统可以利用公有云优势</td>
					<td>降低成本并提高扩展能力</td>
			</tr>
	</tbody>
</table>
<p>例如，企业可以按以下方式分配工作负载：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>核心客户数据库
</span></span><span style="display:flex;"><span>→ 私有云
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>公开网站
</span></span><span style="display:flex;"><span>→ Azure 公有云
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>流量突然增加
</span></span><span style="display:flex;"><span>→ 临时增加 Azure 资源
</span></span></code></pre></div><p>这样企业既能保留核心系统的控制权，又能利用公有云的快速扩展能力。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Hybrid Cloud（混合云）</strong>：将公有云和私有云连接并共同使用的云环境。</li>
<li><strong>Cloud Bursting</strong>：私有云资源不足时，临时使用公有云资源处理额外负载。</li>
<li><strong>Compliance（合规）</strong>：满足法律、行业标准或组织内部规定。</li>
<li><strong>Flexibility（灵活性）</strong>：可以根据实际需求自由选择资源运行位置。</li>
</ul>
<hr>
<h3 id="4-三种云模型的比较">4. 三种云模型的比较<a href="#4-%e4%b8%89%e7%a7%8d%e4%ba%91%e6%a8%a1%e5%9e%8b%e7%9a%84%e6%af%94%e8%be%83" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<table>
	<thead>
			<tr>
					<th>对比项</th>
					<th>Public Cloud</th>
					<th>Private Cloud</th>
					<th>Hybrid Cloud</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>谁可以使用</td>
					<td>多个客户</td>
					<td>单一组织</td>
					<td>公有云 + 单一组织私有云</td>
			</tr>
			<tr>
					<td>基础设施投入</td>
					<td>通常不需要提前购买大量硬件</td>
					<td>通常需要购买和维护硬件</td>
					<td>根据私有云规模决定</td>
			</tr>
			<tr>
					<td>扩容速度</td>
					<td>很快</td>
					<td>通常较慢</td>
					<td>可以借助公有云快速扩容</td>
			</tr>
			<tr>
					<td>控制权</td>
					<td>较低</td>
					<td>最高</td>
					<td>可以按业务分别控制</td>
			</tr>
			<tr>
					<td>运维负担</td>
					<td>较低</td>
					<td>较高</td>
					<td>中等到较高</td>
			</tr>
			<tr>
					<td>按需使用能力</td>
					<td>强</td>
					<td>相对较弱</td>
					<td>较强</td>
			</tr>
			<tr>
					<td>安全和合规控制</td>
					<td>受云平台能力限制</td>
					<td>可以完全自行控制</td>
					<td>可以按需求选择部署位置</td>
			</tr>
			<tr>
					<td>灵活性</td>
					<td>高</td>
					<td>相对较低</td>
					<td>最高</td>
			</tr>
	</tbody>
</table>
<p>三种模型的差异可以概括为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Public Cloud
</span></span><span style="display:flex;"><span>便宜、灵活、扩展快
</span></span><span style="display:flex;"><span>但控制权相对少
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Private Cloud
</span></span><span style="display:flex;"><span>控制权强
</span></span><span style="display:flex;"><span>但成本和维护负担高
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Hybrid Cloud
</span></span><span style="display:flex;"><span>两者结合
</span></span><span style="display:flex;"><span>可以按需求选择
</span></span></code></pre></div><hr>
<h3 id="5-multicloud多云">5. Multicloud（多云）<a href="#5-multicloud%e5%a4%9a%e4%ba%91" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Multicloud 是同时使用两个或更多公有云服务商，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Microsoft Azure
</span></span><span style="display:flex;"><span>+
</span></span><span style="display:flex;"><span>Amazon Web Services
</span></span><span style="display:flex;"><span>+
</span></span><span style="display:flex;"><span>Google Cloud
</span></span></code></pre></div><p>企业采用多云的原因包括平台能力差异、迁移需要、降低供应商依赖，以及不同团队各自选择了不同平台：</p>
<table>
	<thead>
			<tr>
					<th>原因</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>不同云平台各有优势</td>
					<td>某个平台的 AI 更合适，另一个平台的数据库更适合</td>
			</tr>
			<tr>
					<td>正在进行云迁移</td>
					<td>原来使用一个云厂商，现在正在逐步迁移到另一个</td>
			</tr>
			<tr>
					<td>避免完全依赖单一供应商</td>
					<td>不把所有业务完全绑定在一个云平台</td>
			</tr>
			<tr>
					<td>不同团队使用不同平台</td>
					<td>不同业务部门可能选择不同云服务商</td>
			</tr>
	</tbody>
</table>
<p>多云环境也增加了管理负担，因为团队需要同时维护多个平台中的资源、安全策略和配置。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Multicloud（多云）</strong>：同时使用多个公有云服务商。</li>
<li><strong>Cloud Provider（云服务商）</strong>：例如 Microsoft、AWS、Google。</li>
<li><strong>Vendor Lock-in（供应商锁定）</strong>：系统高度依赖某个厂商，导致未来很难迁移到其他平台。</li>
</ul>
<hr>
<h3 id="6-azure-arc">6. Azure Arc<a href="#6-azure-arc" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure Arc 是微软提供的一组管理技术，帮助企业通过 Azure 管理不同位置和平台上的资源，范围包括：</p>
<ul>
<li>Azure 公有云</li>
<li>企业自己的私有云</li>
<li>混合云</li>
<li>多云环境</li>
</ul>
<p>管理关系可以表示为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Azure
</span></span><span style="display:flex;"><span>      \
</span></span><span style="display:flex;"><span>本地服务器
</span></span><span style="display:flex;"><span>       \
</span></span><span style="display:flex;"><span>AWS ------ Azure Arc
</span></span><span style="display:flex;"><span>       /
</span></span><span style="display:flex;"><span>其他云
</span></span></code></pre></div><p>Azure Arc 提供统一的管理入口，让分散在不同环境中的资源能够采用较为一致的管理方式。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Azure Arc</strong>：用于统一管理 Azure、本地、私有云和其他云资源的一组 Azure 技术。</li>
<li><strong>Hybrid Management（混合环境管理）</strong>：使用统一工具管理本地和云端资源。</li>
<li><strong>Multicloud Management（多云管理）</strong>：统一管理不同云服务商中的资源。</li>
</ul>
<hr>
<h3 id="7-azure-vmware-solution">7. Azure VMware Solution<a href="#7-azure-vmware-solution" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>已经使用 VMware 构建私有云的企业迁移到 Azure 时，需要处理原有工作负载。Azure VMware Solution 允许这些工作负载直接在 Azure 中运行，让企业保留现有 VMware 技术体系，同时逐步使用 Azure 的公有云和扩展能力。</p>
<p><strong>通俗理解</strong></p>
<p>原本：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>企业数据中心
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>VMware
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>大量虚拟机
</span></span></code></pre></div><p>想迁移到 Azure 时，不一定需要立即：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>全部重写
</span></span><span style="display:flex;"><span>全部重新部署
</span></span><span style="display:flex;"><span>全部改变架构
</span></span></code></pre></div><p>而可以：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>现有 VMware 工作负载
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Azure VMware Solution
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>在 Azure 中继续运行
</span></span></code></pre></div><p><strong>关键词</strong></p>
<ul>
<li><strong>VMware</strong>：常见的企业虚拟化平台。</li>
<li><strong>Workload（工作负载）</strong>：为了完成某项业务而运行的一组应用、服务和资源。</li>
<li><strong>Azure VMware Solution</strong>：允许 VMware 工作负载在 Azure 中运行的服务。</li>
<li><strong>Migration（迁移）</strong>：将应用、数据或工作负载从一个环境移动到另一个环境。</li>
</ul>
<hr>
<h3 id="本节总结-2">本节总结<a href="#%e6%9c%ac%e8%8a%82%e6%80%bb%e7%bb%93-2" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云部署模型主要回答资源部署在哪里以及由谁使用。三种基本模型如下：</p>
<table>
	<thead>
			<tr>
					<th>模型</th>
					<th>一句话理解</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Public Cloud</td>
					<td><strong>使用云厂商向大量客户开放的云平台</strong></td>
			</tr>
			<tr>
					<td>Private Cloud</td>
					<td><strong>整个云环境只服务一个组织</strong></td>
			</tr>
			<tr>
					<td>Hybrid Cloud</td>
					<td><strong>公有云和私有云连接起来一起使用</strong></td>
			</tr>
	</tbody>
</table>
<p>Multicloud 则表示同时使用多个公有云厂商。三种部署模型之间的关系可以整理为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Private Cloud
</span></span><span style="display:flex;"><span>自己的专用云
</span></span><span style="display:flex;"><span>      ↓
</span></span><span style="display:flex;"><span>Hybrid Cloud
</span></span><span style="display:flex;"><span>自己的云 + 公有云
</span></span><span style="display:flex;"><span>      ↓
</span></span><span style="display:flex;"><span>Public Cloud
</span></span><span style="display:flex;"><span>云厂商提供的公共云
</span></span></code></pre></div><p>Multicloud 属于另一个维度：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Azure + AWS + Google Cloud + ...
</span></span></code></pre></div><p>私有云侧重控制，公有云侧重灵活和按需使用，混合云结合两者，多云则表示同时使用多个公有云平台。</p>
<h2 id="云计算消费模型consumption-based-model">云计算消费模型（Consumption-based Model）<a href="#%e4%ba%91%e8%ae%a1%e7%ae%97%e6%b6%88%e8%b4%b9%e6%a8%a1%e5%9e%8bconsumption-based-model" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>云计算通常采用 Consumption-based Model（基于使用量的消费模型）：需要多少 IT 资源就使用多少，并按实际用量付费，不再需要时再释放。传统 IT 往往要提前购买服务器、网络设备和机房空间，而云计算更接近租用资源，区别可以概括为“传统 IT 先买再用，云计算按需租用”。</p>
<hr>
<h3 id="1-capex-与-opex">1. CapEx 与 OpEx<a href="#1-capex-%e4%b8%8e-opex" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统 IT 预算通常区分 CapEx 和 OpEx：</p>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>CapEx</td>
					<td>提前花一大笔钱购买长期使用的资产</td>
					<td>购买服务器、交换机、机房设备</td>
			</tr>
			<tr>
					<td>OpEx</td>
					<td>随着使用过程持续产生的运营费用</td>
					<td>每月支付云服务费用</td>
			</tr>
	</tbody>
</table>
<p>云计算通常归入 OpEx，因为资源不是一次性买下，而是根据使用情况持续付费。传统数据中心的支出过程如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>传统数据中心：
</span></span><span style="display:flex;"><span>先花钱买服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>服务器买下来以后长期使用
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>属于 CapEx
</span></span></code></pre></div><p>云计算的支出则随资源用量变化：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>这个月用了 10 台虚拟机
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>支付对应费用
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>下个月只需要 3 台
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>只支付 3 台的费用
</span></span></code></pre></div><p>因此，这类费用属于 OpEx。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>CapEx（Capital Expenditure，资本支出）</strong>：提前投入资金购买服务器、网络设备、机房等长期资产。</li>
<li><strong>OpEx（Operational Expenditure，运营支出）</strong>：随着业务运行持续产生的费用。</li>
<li><strong>Consumption-based Model（基于使用量的消费模型）</strong>：根据实际使用的资源量计费。</li>
<li><strong>Cloud Resource（云资源）</strong>：云平台提供的虚拟机、存储、数据库等资源。</li>
</ul>
<hr>
<h3 id="2-基于使用量模型的优势">2. 基于使用量模型的优势<a href="#2-%e5%9f%ba%e4%ba%8e%e4%bd%bf%e7%94%a8%e9%87%8f%e6%a8%a1%e5%9e%8b%e7%9a%84%e4%bc%98%e5%8a%bf" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<table>
	<thead>
			<tr>
					<th>优势</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>不需要提前购买硬件和数据中心基础设施</td>
					<td>不用先花大量资金采购服务器</td>
					<td>降低初始投入</td>
			</tr>
			<tr>
					<td>不需要提前购买可能用不上的容量</td>
					<td>不必为了预测未来需求而买一堆闲置服务器</td>
					<td>减少资源浪费</td>
			</tr>
			<tr>
					<td>需求增加时可以增加资源</td>
					<td>流量突然变大时，可以快速加机器</td>
					<td>应对业务增长和流量高峰</td>
			</tr>
			<tr>
					<td>需求下降时可以释放资源</td>
					<td>高峰结束后，把不用的资源删掉</td>
					<td>避免继续为空闲资源付费</td>
			</tr>
	</tbody>
</table>
<p>这种模式的核心是让资源投入尽可能贴近真实业务需求。</p>
<hr>
<h3 id="3-传统数据中心中的容量规划">3. 传统数据中心中的容量规划<a href="#3-%e4%bc%a0%e7%bb%9f%e6%95%b0%e6%8d%ae%e4%b8%ad%e5%bf%83%e4%b8%ad%e7%9a%84%e5%ae%b9%e9%87%8f%e8%a7%84%e5%88%92" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统数据中心需要提前预测未来的资源需求。例如，预计未来一年需要 20 台服务器时，可能要完成以下流程：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>预测需求
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>采购服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>运输
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>安装
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>配置电力和网络
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>部署应用
</span></span></code></pre></div><p>容量预测很难完全准确，过高或过低都会带来问题：</p>
<table>
	<thead>
			<tr>
					<th>情况</th>
					<th>结果</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>高估需求</td>
					<td>买了太多服务器，大量资源长期闲置</td>
			</tr>
			<tr>
					<td>低估需求</td>
					<td>服务器不够，应用性能下降甚至无法提供服务</td>
			</tr>
	</tbody>
</table>
<p>如果容量不足，企业也无法立即补充资源，还要重新采购、安装和配置硬件。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Capacity Planning（容量规划）</strong>：提前预测未来需要多少计算、存储和网络资源。</li>
<li><strong>Underutilized（利用不足）</strong>：买来的资源没有得到充分使用。</li>
<li><strong>Degraded Performance（性能下降）</strong>：因为资源不足，系统响应变慢或处理能力下降。</li>
<li><strong>Provisioning（预配）</strong>：准备并配置资源，使其能够投入使用。</li>
</ul>
<hr>
<h3 id="4-云计算中的容量规划">4. 云计算中的容量规划<a href="#4-%e4%ba%91%e8%ae%a1%e7%ae%97%e4%b8%ad%e7%9a%84%e5%ae%b9%e9%87%8f%e8%a7%84%e5%88%92" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云计算不必完全依赖长期预测，可以根据实际需求调整资源。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>平时：
</span></span><span style="display:flex;"><span>5 台虚拟机
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>促销活动开始：
</span></span><span style="display:flex;"><span>流量增加
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>增加到 20 台虚拟机
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>活动结束：
</span></span><span style="display:flex;"><span>流量下降
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>减少回 5 台
</span></span></code></pre></div><p>这样可以使资源容量更接近实际业务需求。</p>
<table>
	<thead>
			<tr>
					<th>云中的做法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>需求增加时添加资源</td>
					<td>忙的时候多开机器</td>
					<td>防止容量不足</td>
			</tr>
			<tr>
					<td>需求下降时删除资源</td>
					<td>闲的时候把多余机器关掉</td>
					<td>减少浪费</td>
			</tr>
			<tr>
					<td>按实际使用量计费</td>
					<td>不需要为空闲资源持续付费</td>
					<td>提高成本效率</td>
			</tr>
			<tr>
					<td>根据流量动态调整</td>
					<td>容量可以跟着业务变化</td>
					<td>提高灵活性</td>
			</tr>
	</tbody>
</table>
<hr>
<h3 id="5-scale-out-与-scale-in">5. Scale Out 与 Scale In<a href="#5-scale-out-%e4%b8%8e-scale-in" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p><strong>Scale Out</strong></p>
<p>Scale Out 是增加更多资源或实例，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>5 台服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>流量上涨
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>增加到 20 台服务器
</span></span></code></pre></div><p><strong>Scale In</strong></p>
<p>Scale In 是在需求降低后减少资源或实例，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>20 台服务器
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>流量下降
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>减少到 5 台服务器
</span></span></code></pre></div><p>两者与需求变化的关系如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>需求增加
</span></span><span style="display:flex;"><span>→ Scale Out
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>需求下降
</span></span><span style="display:flex;"><span>→ Scale In
</span></span></code></pre></div><p><strong>关键词</strong></p>
<ul>
<li><strong>Scale Out（横向扩展）</strong>：增加更多服务器或实例。</li>
<li><strong>Scale In（横向缩减）</strong>：减少服务器或实例。</li>
<li><strong>Scaling（扩缩容）</strong>：根据业务负载增加或减少系统资源。</li>
<li><strong>Capacity（容量）</strong>：系统能够处理的最大工作负载。</li>
</ul>
<hr>
<h3 id="6-pay-as-you-go-定价">6. Pay-as-you-go 定价<a href="#6-pay-as-you-go-%e5%ae%9a%e4%bb%b7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云服务商通常采用 Pay-as-you-go（按使用付费）的定价模式，也就是用了多少资源就支付多少费用。这与传统方式先购买一批服务器、之后无论是否充分使用都已经产生支出有明显区别。</p>
<table>
	<thead>
			<tr>
					<th>Pay-as-you-go 带来的好处</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>更容易管理运营成本</td>
					<td>费用更直接地跟实际资源使用情况关联</td>
			</tr>
			<tr>
					<td>提高基础设施利用率</td>
					<td>减少大量长期闲置资源</td>
			</tr>
			<tr>
					<td>可以根据负载调整成本</td>
					<td>业务增长时多花钱，业务下降时减少支出</td>
			</tr>
			<tr>
					<td>不必自己维护底层基础设施</td>
					<td>电力、冷却、硬件、物理网络由云服务商负责</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Pay-as-you-go（按使用付费）</strong>：根据实际使用的云资源计费。</li>
<li><strong>Idle Capacity（闲置容量）</strong>：已经购买或分配，但当前没有实际使用的资源。</li>
<li><strong>Operating Cost（运营成本）</strong>：系统持续运行过程中产生的费用。</li>
</ul>
<hr>
<h3 id="7-为什么云计算能做到这种模式">7. 为什么云计算能做到这种模式<a href="#7-%e4%b8%ba%e4%bb%80%e4%b9%88%e4%ba%91%e8%ae%a1%e7%ae%97%e8%83%bd%e5%81%9a%e5%88%b0%e8%bf%99%e7%a7%8d%e6%a8%a1%e5%bc%8f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>云服务商维护底层的大规模基础设施，包括：</p>
<ul>
<li>电力</li>
<li>冷却</li>
<li>物理服务器</li>
<li>物理网络</li>
</ul>
<p>客户不需要自行购买这些基础设施，而是使用云服务商已经建好的资源池：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云服务商
</span></span><span style="display:flex;"><span>提前建设大量基础设施
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>形成巨大的资源池
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>客户需要资源时申请
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>不用时释放
</span></span></code></pre></div><p>客户因此可以把更多精力放在业务问题和应用功能上，而不是购买、安装和维护硬件。</p>
<hr>
<h3 id="本节总结-3">本节总结<a href="#%e6%9c%ac%e8%8a%82%e6%80%bb%e7%bb%93-3" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>基于使用量的消费模型改变了资源规划方式。传统 IT 的流程是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>传统 IT：
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>预测未来需求
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>提前买硬件
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>固定容量
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>高估 = 浪费
</span></span><span style="display:flex;"><span>低估 = 性能不足
</span></span></code></pre></div><p>云计算的流程则是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>云计算：
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>实际需求增加
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>增加资源
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>实际需求下降
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>释放资源
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>按实际使用量付费
</span></span></code></pre></div><p>三个概念的关系如下：</p>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>一句话理解</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>CapEx</td>
					<td><strong>先买资产，再慢慢用</strong></td>
			</tr>
			<tr>
					<td>OpEx</td>
					<td><strong>随着使用持续付费</strong></td>
			</tr>
			<tr>
					<td>Consumption-based Model</td>
					<td><strong>用多少资源，付多少钱</strong></td>
			</tr>
	</tbody>
</table>
<p>云计算在容量规划上的主要优势，是不再要求企业准确预测未来所需的全部基础设施，而是允许资源随着实际需求扩缩。</p>
<h2 id="azure-物理基础架构">Azure 物理基础架构<a href="#azure-%e7%89%a9%e7%90%86%e5%9f%ba%e7%a1%80%e6%9e%b6%e6%9e%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>Azure 的核心架构组件分为两类：</p>
<ul>
<li><strong>Physical Infrastructure（物理基础架构）</strong></li>
<li><strong>Management Infrastructure（管理基础架构）</strong></li>
</ul>
<p>这一部分讨论物理基础架构。Azure 不让用户直接管理某台物理服务器，而是通过 Datacenter、Region、Availability Zone 和 Region Pair 组织全球资源，使工作负载能够在更高层次上部署，并获得故障隔离、可靠性和韧性。</p>
<hr>
<h3 id="1-datacenter数据中心">1. Datacenter（数据中心）<a href="#1-datacenter%e6%95%b0%e6%8d%ae%e4%b8%ad%e5%bf%83" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure 的物理基础从 Datacenter 开始。它与传统企业数据中心类似，包含：</p>
<ul>
<li>服务器</li>
<li>机架</li>
<li>电力系统</li>
<li>冷却系统</li>
<li>网络设备</li>
</ul>
<p>主要区别在于规模，Azure 在世界各地拥有大量数据中心。用户通常不会选择某个具体 Datacenter，而是通过更高层次的 Region 和 Availability Zone 部署资源。</p>
<table>
	<thead>
			<tr>
					<th>设计概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Datacenter 是 Azure 最底层的物理设施</td>
					<td>真正的服务器、网络、电力、冷却都在这里</td>
					<td>为 Azure 云服务提供实际硬件基础</td>
			</tr>
			<tr>
					<td>用户通常不直接操作具体 Datacenter</td>
					<td>你不会选择“把 VM 放到第几栋机房”</td>
					<td>Azure 可以自行管理底层资源</td>
			</tr>
			<tr>
					<td>Datacenter 会被进一步组织成 Region 和 Availability Zone</td>
					<td>把大量物理机房抽象成更容易使用的逻辑结构</td>
					<td>提供更好的可靠性和故障隔离</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Datacenter（数据中心）</strong>：容纳服务器、网络、电力和冷却设施的物理场所。</li>
<li><strong>Rack（机架）</strong>：用于安装服务器和网络设备的物理机柜。</li>
<li><strong>Physical Infrastructure（物理基础架构）</strong>：真正的机房、服务器、电力、网络等硬件设施。</li>
</ul>
<hr>
<h3 id="2-region区域">2. Region（区域）<a href="#2-region%e5%8c%ba%e5%9f%9f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure Region 是包含一个或多个邻近数据中心的地理区域，这些数据中心通过低延迟网络连接。创建 Azure 资源时，通常需要从以下这类 Region 中选择部署位置：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Japan East
</span></span><span style="display:flex;"><span>West Europe
</span></span><span style="display:flex;"><span>East US
</span></span><span style="display:flex;"><span>Southeast Asia
</span></span></code></pre></div><table>
	<thead>
			<tr>
					<th>设计概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>一个 Region 包含一个或多个邻近 Datacenter</td>
					<td>Region 不是一个机房，而是一组地理位置接近的数据中心</td>
					<td>把底层数据中心组织成可管理的部署区域</td>
			</tr>
			<tr>
					<td>Region 内部使用低延迟网络连接</td>
					<td>同一区域内的数据中心之间通信速度较快</td>
					<td>适合组成一个完整的区域级云环境</td>
			</tr>
			<tr>
					<td>创建 Azure 资源时通常需要选择 Region</td>
					<td>决定 VM、数据库等资源主要部署在哪里</td>
					<td>影响延迟、合规、服务可用性和成本</td>
			</tr>
			<tr>
					<td>Azure 会在 Region 内管理资源分配和负载</td>
					<td>用户不需要自己指定某台实体服务器</td>
					<td>Azure 自动管理底层资源</td>
			</tr>
	</tbody>
</table>
<p>Region 可以理解为 Azure 在某个地理范围内建立的一整套云基础设施。例如，在日本部署服务时可以选择 Japan East，使服务更接近日本用户。</p>
<hr>
<h3 id="3-region-并不是所有服务都一样">3. Region 并不是所有服务都一样<a href="#3-region-%e5%b9%b6%e4%b8%8d%e6%98%af%e6%89%80%e6%9c%89%e6%9c%8d%e5%8a%a1%e9%83%bd%e4%b8%80%e6%a0%b7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>并非所有 Azure 服务和功能都在每个 Region 中提供，常见差异包括：</p>
<ul>
<li>某些 VM Size 只在部分 Region 可用</li>
<li>某些 Storage 类型只在部分 Region 可用</li>
<li>某些特殊服务只部署在指定 Region</li>
</ul>
<p>因此，选择部署位置时既要考虑与用户的距离，也要确认目标 Region 是否提供所需服务。Microsoft Entra ID、Azure Traffic Manager 和 Azure DNS 等 Global Service 则不要求选择具体 Region：</p>
<ul>
<li>Microsoft Entra ID</li>
<li>Azure Traffic Manager</li>
<li>Azure DNS</li>
</ul>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Region（区域）</strong>：由一个或多个邻近数据中心组成的 Azure 地理部署范围。</li>
<li><strong>Low-latency Network（低延迟网络）</strong>：具有较低通信延迟的高速网络。</li>
<li><strong>Global Service（全球服务）</strong>：不要求用户选择特定 Azure Region 的服务。</li>
<li><strong>VM Size</strong>：Azure VM 不同的 CPU、内存和硬件规格组合。</li>
</ul>
<hr>
<h3 id="4-availability-zone可用区">4. Availability Zone（可用区）<a href="#4-availability-zone%e5%8f%af%e7%94%a8%e5%8c%ba" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Availability Zone 是同一个 Azure Region 内彼此物理分离的数据中心区域，每个 Zone 都有独立的：</p>
<ul>
<li>电力</li>
<li>冷却</li>
<li>网络</li>
</ul>
<p>一个 Zone 出现故障时，其他 Zone 仍可继续运行；各 Zone 之间则通过高速私有光纤网络连接，以支持跨 Zone 通信和复制。</p>
<table>
	<thead>
			<tr>
					<th>设计概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Availability Zone 在物理上彼此分离</td>
					<td>虽然都属于同一个 Region，但不是共用同一个机房环境</td>
					<td>减少单一机房故障造成的影响</td>
			</tr>
			<tr>
					<td>每个 Zone 有独立电力、冷却和网络</td>
					<td>一个 Zone 的供电或网络故障不会必然拖垮其他 Zone</td>
					<td>提供故障隔离</td>
			</tr>
			<tr>
					<td>Zone 之间通过高速私有网络连接</td>
					<td>不同 Zone 仍然可以快速通信</td>
					<td>支持跨 Zone 冗余和复制</td>
			</tr>
			<tr>
					<td>一个 Zone 可以包含一个或多个 Datacenter</td>
					<td>Availability Zone 是比单一机房更高一层的故障隔离单位</td>
					<td>提供更稳定的可用性边界</td>
			</tr>
	</tbody>
</table>
<p>假设一个 Region 有三个 Availability Zone：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Azure Region
</span></span><span style="display:flex;"><span>├── Zone 1
</span></span><span style="display:flex;"><span>├── Zone 2
</span></span><span style="display:flex;"><span>└── Zone 3
</span></span></code></pre></div><p>如果 Zone 1 因为电力问题完全故障：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Zone 1 ✕
</span></span><span style="display:flex;"><span>Zone 2 ✓
</span></span><span style="display:flex;"><span>Zone 3 ✓
</span></span></code></pre></div><p>只要服务跨多个 Zone 部署，Zone 1 的电力故障就不会必然中断整个服务。因此，Availability Zone 主要解决同一个 Region 内的机房级故障。</p>
<hr>
<h3 id="5-availability-zone-是故障隔离边界">5. Availability Zone 是故障隔离边界<a href="#5-availability-zone-%e6%98%af%e6%95%85%e9%9a%9c%e9%9a%94%e7%a6%bb%e8%be%b9%e7%95%8c" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure 把 Availability Zone 设计成 Isolation Boundary（隔离边界），目标是把故障限制在单个 Zone 内，避免影响其他 Zone。这与前文的 Fault Isolation 思路一致：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Zone 1
</span></span><span style="display:flex;"><span>电力故障
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>Zone 1 服务停止
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Zone 2 / Zone 3
</span></span><span style="display:flex;"><span>独立供电
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>继续运行
</span></span></code></pre></div><p>对于支持 Availability Zone 的 Region，Azure 至少提供三个独立 Zone。</p>
<p>不过，并非所有 Azure Region 都支持 Availability Zone。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Availability Zone（可用区）</strong>：Region 内物理隔离的基础设施区域。</li>
<li><strong>Isolation Boundary（隔离边界）</strong>：一个故障尽量被限制在该范围内，不继续向外扩散。</li>
<li><strong>Fault Isolation（故障隔离）</strong>：阻止局部故障影响其他资源的设计方式。</li>
</ul>
<hr>
<h3 id="6-如何利用-availability-zone-提高可靠性">6. 如何利用 Availability Zone 提高可靠性<a href="#6-%e5%a6%82%e4%bd%95%e5%88%a9%e7%94%a8-availability-zone-%e6%8f%90%e9%ab%98%e5%8f%af%e9%9d%a0%e6%80%a7" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>传统本地数据中心通常要购买两套或多套硬件才能实现冗余，而 Azure 可以把资源直接部署到不同 Availability Zone，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Zone 1
</span></span><span style="display:flex;"><span>VM A
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Zone 2
</span></span><span style="display:flex;"><span>VM B
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Zone 3
</span></span><span style="display:flex;"><span>VM C
</span></span></code></pre></div><p>某个 Zone 出现故障后，其他 Zone 中的资源仍然存在。可以跨 Zone 部署的资源包括：</p>
<ul>
<li>VM</li>
<li>Storage</li>
<li>Database</li>
<li>其他支持 Availability Zone 的 Azure 服务</li>
</ul>
<p>跨 Zone 冗余也会增加成本，例如：</p>
<ul>
<li>创建更多资源副本</li>
<li>跨 Zone 传输数据</li>
<li>保存更多数据副本</li>
</ul>
<p>因此，设计时仍需权衡可靠性与成本。</p>
<hr>
<h3 id="7-availability-zone-服务的三种类型">7. Availability Zone 服务的三种类型<a href="#7-availability-zone-%e6%9c%8d%e5%8a%a1%e7%9a%84%e4%b8%89%e7%a7%8d%e7%b1%bb%e5%9e%8b" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>支持 Availability Zone 的 Azure 服务大致分为三类：</p>
<table>
	<thead>
			<tr>
					<th>类型</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Zonal Service</td>
					<td>你自己指定资源放在哪个 Zone</td>
					<td>VM、Managed Disk、IP Address</td>
			</tr>
			<tr>
					<td>Zone-redundant Service</td>
					<td>Azure 自动在多个 Zone 之间复制</td>
					<td>Zone-redundant Storage、SQL Database</td>
			</tr>
			<tr>
					<td>Non-regional Service</td>
					<td>服务本身不依赖某一个单独 Region</td>
					<td>一些全球性 Azure 服务</td>
			</tr>
	</tbody>
</table>
<p><strong>Zonal Service</strong></p>
<p>使用 Zonal Service 时，用户明确指定资源所在的 Zone：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>VM A → Zone 1
</span></span><span style="display:flex;"><span>VM B → Zone 2
</span></span></code></pre></div><p>跨 Zone 冗余需要由用户设计。</p>
<p><strong>Zone-redundant Service</strong></p>
<p>使用 Zone-redundant Service 时，用户只需创建服务，Azure 平台会在多个 Zone 中部署副本：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Zone 1
</span></span><span style="display:flex;"><span>Zone 2
</span></span><span style="display:flex;"><span>Zone 3
</span></span></code></pre></div><p>多 Zone 复制由平台自动完成。</p>
<p><strong>Non-regional Service</strong></p>
<p>Non-regional Service 不绑定单个 Region，因此可以抵御：</p>
<ul>
<li>Zone 级故障</li>
<li>Region 级故障</li>
</ul>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Zonal Service</strong>：绑定到某一个特定 Availability Zone 的资源。</li>
<li><strong>Zone-redundant Service</strong>：Azure 自动将服务复制到多个 Zone。</li>
<li><strong>Non-regional Service</strong>：不依赖单一区域的服务。</li>
<li><strong>Managed Disk</strong>：Azure 管理的 VM 磁盘。</li>
<li><strong>Zone-redundant Storage，ZRS</strong>：自动在同一个 Region 的多个 Availability Zone 之间复制数据的存储方式。</li>
</ul>
<hr>
<h3 id="8-为什么有-availability-zone-还需要-region-pair">8. 为什么有 Availability Zone 还需要 Region Pair<a href="#8-%e4%b8%ba%e4%bb%80%e4%b9%88%e6%9c%89-availability-zone-%e8%bf%98%e9%9c%80%e8%a6%81-region-pair" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Availability Zone 可以应对单个 Zone 故障，但大规模自然灾害、区域级电力或网络中断、社会事件以及整个 Region 的基础设施问题，可能同时影响同一区域内的多个 Zone：</p>
<ul>
<li>大规模自然灾害</li>
<li>区域级电力中断</li>
<li>大规模网络故障</li>
<li>社会事件</li>
<li>整个 Region 的基础设施问题</li>
</ul>
<p>为了应对这类 Region 级故障，Azure 提供了 Region Pair（区域对）。</p>
<hr>
<h3 id="9-region-pair区域对">9. Region Pair（区域对）<a href="#9-region-pair%e5%8c%ba%e5%9f%9f%e5%af%b9" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>大多数 Azure Region 会与同一 Geography 中的另一个 Region 配对。两个 Region 通常至少相距约 300 英里，以降低同一场区域性灾难同时影响两边的可能性，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>West US ↔ East US
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Southeast Asia ↔ East Asia
</span></span></code></pre></div><table>
	<thead>
			<tr>
					<th>设计概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>两个 Region 组成 Region Pair</td>
					<td>一个区域还有另一个远距离区域作为恢复选择</td>
					<td>提高 Region 级灾难的恢复能力</td>
			</tr>
			<tr>
					<td>两个 Region 距离较远</td>
					<td>避免同一次区域灾难同时破坏两个 Region</td>
					<td>降低相关性故障风险</td>
			</tr>
			<tr>
					<td>可以跨 Region 复制资源或数据</td>
					<td>一个 Region 故障后可以使用另一个 Region</td>
					<td>提供更高级别的灾难恢复</td>
			</tr>
			<tr>
					<td>Region Pair 通常位于同一 Geography</td>
					<td>数据通常不会跨出所要求的地理范围</td>
					<td>有利于数据驻留和合规</td>
			</tr>
	</tbody>
</table>
<p>Availability Zone 类似一个城市里的多个独立机房，Region Pair 则相当于在远处的另一个城市准备一套恢复环境。</p>
<hr>
<h3 id="10-region-pair-并不等于自动灾备">10. Region Pair 并不等于自动灾备<a href="#10-region-pair-%e5%b9%b6%e4%b8%8d%e7%ad%89%e4%ba%8e%e8%87%aa%e5%8a%a8%e7%81%be%e5%a4%87" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Region Pair 只提供跨区域恢复的基础条件，并不表示 Azure 会自动复制所有数据和服务。事实上，并非所有服务都会：</p>
<ul>
<li>自动跨 Region 复制</li>
<li>自动 Failover</li>
<li>自动 Failback</li>
</ul>
<p>很多情况下，客户仍需自行配置：</p>
<ul>
<li>数据复制</li>
<li>备用 Region</li>
<li>Failover</li>
<li>Disaster Recovery</li>
</ul>
<p>是否进行跨 Region 复制和恢复，最终取决于服务本身的能力和客户配置。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Region Pair（区域对）</strong>：两个相距较远、用于增强区域级灾难恢复能力的 Azure Region。</li>
<li><strong>Cross-region Replication（跨区域复制）</strong>：把数据或资源复制到另一个 Region。</li>
<li><strong>Failover（故障切换）</strong>：主 Region 故障后切换到备用 Region。</li>
<li><strong>Failback（故障回切）</strong>：主 Region 恢复后再切回。</li>
<li><strong>Disaster Recovery，DR（灾难恢复）</strong>：发生大规模严重故障后恢复业务的整体能力。</li>
</ul>
<hr>
<h3 id="11-region-pair-的额外优势">11. Region Pair 的额外优势<a href="#11-region-pair-%e7%9a%84%e9%a2%9d%e5%a4%96%e4%bc%98%e5%8a%bf" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>除跨区域复制外，Region Pair 还有以下作用：</p>
<table>
	<thead>
			<tr>
					<th>优势</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>大规模 Azure 故障时，会优先恢复每对 Region 中至少一个</td>
					<td>微软会尽量保证一对 Region 不会长期一起不可用</td>
					<td>提高恢复概率</td>
			</tr>
			<tr>
					<td>Azure 计划更新通常不会同时更新两个配对 Region</td>
					<td>一个更新时，另一个暂时保持不变</td>
					<td>降低更新导致同时故障的风险</td>
			</tr>
			<tr>
					<td>数据通常保持在同一个 Geography 内</td>
					<td>数据不会随意跨出某个国家或地理范围</td>
					<td>满足数据驻留和合规需求</td>
			</tr>
	</tbody>
</table>
<hr>
<h3 id="12-region-pair-的特殊情况">12. Region Pair 的特殊情况<a href="#12-region-pair-%e7%9a%84%e7%89%b9%e6%ae%8a%e6%83%85%e5%86%b5" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>大多数 Region Pair 是双向的：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Region A ↔ Region B
</span></span></code></pre></div><p>这表示 A 和 B 互为备份选择，但并非所有 Region 都采用这种方式。Brazil South 就是一个特殊案例：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Brazil South
</span></span><span style="display:flex;"><span>→ South Central US
</span></span></code></pre></div><p>这种配对并不完全对称，还有一些 Region 没有传统 Region Pair，例如：</p>
<ul>
<li>Italy North</li>
<li>Poland Central</li>
<li>Israel Central</li>
</ul>
<p>这些 Region 更多依赖以下机制实现韧性：</p>
<ul>
<li>Availability Zone</li>
<li>Geo-redundant Storage</li>
</ul>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Bidirectional Pairing（双向配对）</strong>：两个 Region 互相作为配对区域。</li>
<li><strong>One-direction Pairing（单向配对）</strong>：Region A 使用 Region B 作为配对，但反过来并不成立。</li>
<li><strong>Geo-redundant Storage（地理冗余存储）</strong>：把数据复制到较远的另一个地理区域，以应对 Region 级故障。</li>
</ul>
<hr>
<h3 id="13-geography">13. Geography<a href="#13-geography" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Geography 是比 Region 更大的地理边界，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>United States
</span></span><span style="display:flex;"><span>Europe
</span></span><span style="display:flex;"><span>Asia
</span></span></code></pre></div><p>一个 Geography 可以包含多个 Region，整体层级如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Geography
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Region
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Availability Zone
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Datacenter
</span></span></code></pre></div><p>Geography 的范围最大，Datacenter 则是最具体的物理层级。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Geography（地理区域）</strong>：Azure 用来组织多个 Region 的更大地理范围，通常与数据驻留和合规要求相关。</li>
<li><strong>Data Residency（数据驻留）</strong>：规定数据应存储在哪个国家或地理范围内。</li>
</ul>
<hr>
<h3 id="14-sovereign-region主权区域">14. Sovereign Region（主权区域）<a href="#14-sovereign-region%e4%b8%bb%e6%9d%83%e5%8c%ba%e5%9f%9f" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>除普通 Azure Region 外，还有 Sovereign Region（主权区域）。它们与 Azure 的全球基础设施在物理和逻辑上隔离，主要用于满足：</p>
<ul>
<li>政府要求</li>
<li>法律要求</li>
<li>合规要求</li>
<li>数据主权要求</li>
</ul>
<table>
	<thead>
			<tr>
					<th>类型</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>US Government Regions</td>
					<td>专门为美国政府机构和合作伙伴提供的隔离 Azure 环境</td>
			</tr>
			<tr>
					<td>China Regions</td>
					<td>中国地区独立运营的 Azure 环境</td>
			</tr>
	</tbody>
</table>
<p><strong>美国政府区域</strong></p>
<p>美国政府区域包括：</p>
<ul>
<li>US DoD Central</li>
<li>US Gov Virginia</li>
<li>US Gov Arizona</li>
</ul>
<p>这些环境具有以下特点：</p>
<ul>
<li>与普通 Azure 网络隔离</li>
<li>面向美国政府机构及合作伙伴</li>
<li>由经过审查的美国人员运营</li>
<li>具备额外合规认证</li>
</ul>
<p><strong>中国区域</strong></p>
<p>中国区域包括：</p>
<ul>
<li>China East</li>
<li>China North</li>
</ul>
<p>中国 Azure 由 Microsoft 与 21Vianet 合作提供，Microsoft 不直接维护这些数据中心。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Sovereign Region（主权区域）</strong>：与普通全球 Azure 环境隔离、用于满足特殊法律和合规要求的云区域。</li>
<li><strong>Logical Isolation（逻辑隔离）</strong>：虽然都是 Azure 技术体系，但网络、账号或管理体系彼此独立。</li>
<li><strong>Compliance Certification（合规认证）</strong>：证明云环境符合特定政府、行业或法律标准的认证。</li>
<li><strong>21Vianet（世纪互联）</strong>：在中国运营相关 Azure 云服务的合作伙伴。</li>
</ul>
<hr>
<h3 id="总结">总结<a href="#%e6%80%bb%e7%bb%93" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure 的物理架构层级如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Geography
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Region
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Availability Zone
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Datacenter
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Physical Servers
</span></span></code></pre></div><p>每个层级解决的问题不同：</p>
<table>
	<thead>
			<tr>
					<th>层级</th>
					<th>主要解决什么问题</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Datacenter</td>
					<td>真正在哪里运行服务器</td>
			</tr>
			<tr>
					<td>Availability Zone</td>
					<td>一个机房级故障时怎么办</td>
			</tr>
			<tr>
					<td>Region</td>
					<td>资源主要部署在哪个地理区域</td>
			</tr>
			<tr>
					<td>Region Pair</td>
					<td>整个 Region 出现严重故障时怎么办</td>
			</tr>
			<tr>
					<td>Geography</td>
					<td>数据和资源属于哪个大的地理、合规范围</td>
			</tr>
			<tr>
					<td>Sovereign Region</td>
					<td>特殊政府、法律和数据主权要求</td>
			</tr>
	</tbody>
</table>
<p>其中最容易混淆的是 Availability Zone 与 Region Pair：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Availability Zone
</span></span><span style="display:flex;"><span>同一个 Region 内的故障隔离
</span></span></code></pre></div><p>相比之下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Region Pair
</span></span><span style="display:flex;"><span>不同 Region 之间的灾难恢复
</span></span></code></pre></div><p>简而言之，Zone 处理机房级故障，Region Pair 处理区域级灾难。Azure 的物理可靠性设计通过以下层级逐步扩大故障隔离范围：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>一台服务器坏了
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>Datacenter 内处理
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>一个机房 / Zone 坏了
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>其他 Availability Zone 继续运行
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>整个 Region 坏了
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>另一个 Region / Region Pair 提供恢复能力
</span></span></code></pre></div><p>Azure 通过 Datacenter → Availability Zone → Region → Region Pair 的多层结构，把故障隔离和冗余能力从单个数据中心扩展到整个地理区域。</p>
<h2 id="azure-管理基础架构">Azure 管理基础架构<a href="#azure-%e7%ae%a1%e7%90%86%e5%9f%ba%e7%a1%80%e6%9e%b6%e6%9e%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<p>Azure 的管理基础架构主要包括：</p>
<ul>
<li><strong>Resources（资源）</strong></li>
<li><strong>Resource Groups（资源组）</strong></li>
<li><strong>Subscriptions（订阅）</strong></li>
<li><strong>Management Groups（管理组）</strong></li>
<li><strong>Accounts / Microsoft Entra Tenant（账户 / 租户）</strong></li>
</ul>
<p>这些层级共同决定资源如何组织、权限如何控制以及费用如何管理，完整关系如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Tenant Root Group
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Management Groups
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Subscriptions
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resource Groups
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resources
</span></span></code></pre></div><hr>
<h3 id="1-azure-resource资源">1. Azure Resource（资源）<a href="#1-azure-resource%e8%b5%84%e6%ba%90" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Resource 是 Azure 中最基本的管理对象。在 Azure 中创建、预配或部署的服务实例通常都属于 Resource，例如：</p>
<ul>
<li>Virtual Machine</li>
<li>Virtual Network</li>
<li>Database</li>
<li>Storage Account</li>
<li>Azure AI Service</li>
</ul>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Resource 是 Azure 最基本的构建单元</td>
					<td>你实际创建出来并使用的 Azure 服务，就是资源</td>
					<td>所有部署、权限、监控和计费最终都会落到具体资源上</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Resource（资源）</strong>：Azure 中实际创建出来的服务实例。</li>
<li><strong>Provision（预配）</strong>：创建并准备资源，使其能够使用。</li>
<li><strong>Deploy（部署）</strong>：把资源、应用或配置真正放到环境中运行。</li>
</ul>
<hr>
<h3 id="2-resource-group资源组">2. Resource Group（资源组）<a href="#2-resource-group%e8%b5%84%e6%ba%90%e7%bb%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Resource Group 是一组 Azure Resources 的逻辑集合，每个 Resource 必须且只能同时属于一个 Resource Group。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Resource Group: Web-App-Prod
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>├── VM
</span></span><span style="display:flex;"><span>├── Virtual Network
</span></span><span style="display:flex;"><span>├── SQL Database
</span></span><span style="display:flex;"><span>└── Storage Account
</span></span></code></pre></div><p>资源组不是物理位置，而是组织相关资源的逻辑容器。</p>
<table>
	<thead>
			<tr>
					<th>设计规则</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>每个 Resource 必须属于一个 Resource Group</td>
					<td>Azure 不允许资源完全“散着放”</td>
					<td>让所有资源都有明确管理归属</td>
			</tr>
			<tr>
					<td>一个 Resource 同一时间只能属于一个 Resource Group</td>
					<td>一台 VM 不能同时放进两个资源组</td>
					<td>避免管理边界混乱</td>
			</tr>
			<tr>
					<td>某些 Resource 可以在 Resource Group 之间移动</td>
					<td>如果分组方式发生变化，可以把部分资源重新归类</td>
					<td>提高组织灵活性</td>
			</tr>
			<tr>
					<td>Resource Group 不能嵌套</td>
					<td>不能在一个资源组里面再建另一个资源组</td>
					<td>保持层级简单</td>
			</tr>
			<tr>
					<td>Resource Group 创建后不能重命名</td>
					<td>名字要在一开始就规划好</td>
					<td>避免后期命名混乱</td>
			</tr>
			<tr>
					<td>对 Resource Group 执行某些操作，会影响里面所有 Resource</td>
					<td>管理动作可以批量向下作用</td>
					<td>方便统一管理</td>
			</tr>
	</tbody>
</table>
<p><strong>为什么 Resource Group 很重要</strong></p>
<p>Resource Group 不只是用于分类的“文件夹”，在其范围内执行的删除或权限配置等操作可能作用于组内资源。</p>
<p><strong>删除 Resource Group</strong></p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Delete Resource Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>里面所有 Resources 一起删除
</span></span></code></pre></div><p>所以，如果你建立一个临时开发环境：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Dev-Test Resource Group
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>├── VM
</span></span><span style="display:flex;"><span>├── Database
</span></span><span style="display:flex;"><span>├── Storage
</span></span><span style="display:flex;"><span>└── Network
</span></span></code></pre></div><p>测试结束后可以直接删除整个 Resource Group，不必逐个清理资源。</p>
<p><strong>权限控制</strong></p>
<p>如果给某个用户授予 Resource Group 的访问权限：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>User
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>获得 Resource Group 权限
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>可以访问组内相应 Resources
</span></span></code></pre></div><p>因此，Resource Group 也是常用的权限管理范围。</p>
<p><strong>如何划分 Resource Group</strong></p>
<p>Azure 没有规定资源组的唯一划分方式，组织可以根据实际需求按项目划分：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Project A Resource Group
</span></span><span style="display:flex;"><span>Project B Resource Group
</span></span><span style="display:flex;"><span>Project C Resource Group
</span></span></code></pre></div><p>也可以按环境划分：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Dev Resource Group
</span></span><span style="display:flex;"><span>Test Resource Group
</span></span><span style="display:flex;"><span>Prod Resource Group
</span></span></code></pre></div><p>另一种方式是把生命周期相同的应用资源放在一起。划分时应优先考虑生命周期、权限和管理方式是否相近，例如临时测试环境中的 VM、数据库和网络通常一起创建和删除，适合放在同一个 Resource Group。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Resource Group（资源组）</strong>：用于组织和统一管理 Azure Resources 的逻辑容器。</li>
<li><strong>Lifecycle（生命周期）</strong>：资源从创建、运行到删除的整个过程。</li>
<li><strong>Naming Convention（命名规范）</strong>：统一规定资源和资源组如何命名。</li>
<li><strong>Access Control（访问控制）</strong>：规定谁能够访问和操作哪些资源。</li>
</ul>
<hr>
<h3 id="3-azure-subscription订阅">3. Azure Subscription（订阅）<a href="#3-azure-subscription%e8%ae%a2%e9%98%85" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Subscription 是 Azure 的资源组织、访问控制和费用管理边界，Resource Group 位于 Subscription 之下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Subscription
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resource Groups
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resources
</span></span></code></pre></div><p>一个 Azure Account 可以拥有多个 Subscription，但至少需要一个 Subscription 才能使用 Azure 服务。</p>
<table>
	<thead>
			<tr>
					<th>Subscription 的作用</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Management Unit</td>
					<td>用来组织一批 Resource Groups 和 Resources</td>
			</tr>
			<tr>
					<td>Billing Unit</td>
					<td>Azure 可以按照不同 Subscription 分别统计费用</td>
			</tr>
			<tr>
					<td>Access Boundary</td>
					<td>不同 Subscription 可以配置不同权限和访问策略</td>
			</tr>
			<tr>
					<td>Scale Boundary</td>
					<td>可以通过多个 Subscription 扩大和分隔资源管理范围</td>
			</tr>
	</tbody>
</table>
<p><strong>计费边界</strong></p>
<p>Subscription 可以作为独立的计费边界。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Azure Account
</span></span><span style="display:flex;"><span>├── Dev Subscription
</span></span><span style="display:flex;"><span>├── Test Subscription
</span></span><span style="display:flex;"><span>└── Production Subscription
</span></span></code></pre></div><p>Azure 可以分别产生：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Dev → 一份费用报告
</span></span><span style="display:flex;"><span>Test → 一份费用报告
</span></span><span style="display:flex;"><span>Production → 一份费用报告
</span></span></code></pre></div><p>分开统计后，组织可以清楚地看到各项目、团队或环境产生的费用。</p>
<table>
	<thead>
			<tr>
					<th>做法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>为不同业务创建不同 Subscription</td>
					<td>把费用拆开统计</td>
					<td>方便成本追踪</td>
			</tr>
			<tr>
					<td>为生产和开发环境使用不同 Subscription</td>
					<td>生产成本不会和测试成本混在一起</td>
					<td>提高财务可见性</td>
			</tr>
			<tr>
					<td>为不同团队创建 Subscription</td>
					<td>每个团队单独计算云资源成本</td>
					<td>方便预算管理</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Billing Boundary（计费边界）</strong>：费用统计和账单划分的范围。</li>
<li><strong>Billing Report（费用报告）</strong>：记录某个 Subscription 使用了多少 Azure 服务以及产生多少费用。</li>
<li><strong>Cost Tracking（成本追踪）</strong>：分析云费用来自哪些项目、团队或资源。</li>
</ul>
<p><strong>访问控制边界</strong></p>
<p>Subscription 同时也是权限控制边界，不同环境可以采用不同的权限配置：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Development Subscription
</span></span><span style="display:flex;"><span>开发人员拥有较高权限
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Production Subscription
</span></span><span style="display:flex;"><span>只有少数运维人员能够修改
</span></span></code></pre></div><p>这种隔离可以降低开发人员测试代码时误操作生产资源的风险。各 Subscription 还可以分别设置 Access Policy、Budget / Cost Alert 和 Resource Permission。只有 Free Trial、Visual Studio 等带额度的订阅才可能具有 Spending Limit，按使用付费的订阅通常通过预算和告警监控成本。</p>
<table>
	<thead>
			<tr>
					<th>做法</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Dev 和 Prod 使用不同 Subscription</td>
					<td>把开发环境和生产环境隔离</td>
					<td>减少误操作风险</td>
			</tr>
			<tr>
					<td>不同 Subscription 配置不同权限</td>
					<td>不同团队只能操作自己的资源</td>
					<td>加强安全性</td>
			</tr>
			<tr>
					<td>不同 Subscription 设置预算和成本告警</td>
					<td>分别监控各环境的支出</td>
					<td>控制成本风险</td>
			</tr>
	</tbody>
</table>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Access Control Boundary（访问控制边界）</strong>：权限规则可以独立配置的一层管理范围。</li>
<li><strong>Budget / Cost Alert（预算 / 成本告警）</strong>：跟踪费用并在达到阈值时通知相关人员，但不会自动停止资源。</li>
<li><strong>Access Policy（访问策略）</strong>：规定谁可以执行哪些操作。</li>
</ul>
<p><strong>为什么创建多个 Subscription</strong></p>
<p>随着 Azure 环境扩大，单个 Subscription 往往难以同时满足环境隔离、团队授权和成本核算需求，常见拆分方式有三类。</p>
<p><strong>按环境拆分</strong></p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Sandbox
</span></span><span style="display:flex;"><span>Development
</span></span><span style="display:flex;"><span>Test
</span></span><span style="display:flex;"><span>Production
</span></span></code></pre></div><p>这样可以隔离生命周期不同的环境。</p>
<p><strong>按团队或工作负载拆分</strong></p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Team A Subscription
</span></span><span style="display:flex;"><span>Team B Subscription
</span></span><span style="display:flex;"><span>Project C Subscription
</span></span></code></pre></div><p>这样更容易分别管理权限和费用。</p>
<p><strong>按计费需求拆分</strong></p>
<p>按计费需求拆分时，可以采用以下结构：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Production Subscription
</span></span><span style="display:flex;"><span>Development &amp; Test Subscription
</span></span></code></pre></div><p>这样财务部门可以清楚区分正式业务成本与开发测试成本。</p>
<hr>
<h3 id="4-azure-management-group管理组">4. Azure Management Group（管理组）<a href="#4-azure-management-group%e7%ae%a1%e7%90%86%e7%bb%84" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>少量 Subscription 可以逐个管理，但大型企业可能拥有：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>几十个
</span></span><span style="display:flex;"><span>几百个
</span></span><span style="display:flex;"><span>甚至几千个 Subscription
</span></span></code></pre></div><p>逐个配置这些 Subscription 的权限和策略会产生大量重复工作，因此 Azure 在 Subscription 之上提供了 Management Group：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscriptions
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource Groups
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resources
</span></span></code></pre></div><p>Management Group 用于统一管理多个 Subscription。</p>
<p><strong>策略继承</strong></p>
<p>Management Group 支持 Policy 和 Access 向下继承。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Production Management Group
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Policy:
</span></span><span style="display:flex;"><span>VM 只能部署到 West US
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscription A
</span></span><span style="display:flex;"><span>Subscription B
</span></span><span style="display:flex;"><span>Subscription C
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>所有 Resource Groups
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>所有 Resources
</span></span></code></pre></div><p>下层所有 Subscription 都会受到该规则约束，不需要逐个重复配置。</p>
<table>
	<thead>
			<tr>
					<th>Management Group 能做什么</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>对多个 Subscription 设置统一 Policy</td>
					<td>一条规则管很多订阅</td>
					<td>提高治理效率</td>
			</tr>
			<tr>
					<td>统一配置 Access</td>
					<td>给用户一次授权，就可以作用到下面多个 Subscription</td>
					<td>减少重复权限配置</td>
			</tr>
			<tr>
					<td>建立多层组织结构</td>
					<td>可以按照部门、区域、业务等组织 Subscription</td>
					<td>模拟真实企业组织结构</td>
			</tr>
			<tr>
					<td>向下继承配置</td>
					<td>子层级自动获得上层规则</td>
					<td>保持管理一致性</td>
			</tr>
	</tbody>
</table>
<p><strong>Policy 继承示例</strong></p>
<p>假设公司要求 Production 环境的 VM 只能运行在 West US，可以按以下方式配置：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Production Management Group
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Policy:
</span></span><span style="display:flex;"><span>Allowed Region = West US
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>├── Production Subscription A
</span></span><span style="display:flex;"><span>├── Production Subscription B
</span></span><span style="display:flex;"><span>└── Production Subscription C
</span></span></code></pre></div><p>在此结构中，下层 VM 都受到同一策略约束：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>所有下面的 VM
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>只能部署到 West US
</span></span></code></pre></div><p>继承的上层治理策略不能由 Subscription Owner 直接绕过，因此企业可以把统一规则应用到大量 Subscription。</p>
<p><strong>Azure RBAC 与 Management Group</strong></p>
<p>Management Group 也能统一分配权限。假设某个管理员需要读取多个 Subscription，没有 Management Group 时必须逐个配置：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Subscription A → 配一次权限
</span></span><span style="display:flex;"><span>Subscription B → 再配一次
</span></span><span style="display:flex;"><span>Subscription C → 再配一次
</span></span><span style="display:flex;"><span>Subscription D → 再配一次
</span></span></code></pre></div><p>使用 Management Group 后：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>配置一次 Azure RBAC
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>下面所有 Subscription 自动继承
</span></span></code></pre></div><p>权限还可以继续向下继承：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Sub-management Group
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Subscription
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resource Group
</span></span><span style="display:flex;"><span>    ↓
</span></span><span style="display:flex;"><span>Resource
</span></span></code></pre></div><p><strong>关键词</strong></p>
<ul>
<li><strong>Azure RBAC（Role-Based Access Control）</strong>：基于角色的访问控制，用角色决定用户能够对 Azure 资源执行什么操作。</li>
<li><strong>Role Assignment（角色分配）</strong>：把某个 Azure Role 分配给某个用户、组或身份。</li>
<li><strong>Inheritance（继承）</strong>：下层资源自动获得上层定义的权限或策略。</li>
<li><strong>Governance（治理）</strong>：通过规则、权限和策略统一管理云资源。</li>
<li><strong>Policy（策略）</strong>：用于限制或规范 Azure 资源配置的规则。</li>
</ul>
<p><strong>Management Group 嵌套</strong></p>
<p>Resource Group 不能嵌套，Management Group 则可以形成多层结构。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Tenant Root Group
</span></span><span style="display:flex;"><span>│
</span></span><span style="display:flex;"><span>├── Production
</span></span><span style="display:flex;"><span>│   ├── Europe
</span></span><span style="display:flex;"><span>│   │   ├── Subscription A
</span></span><span style="display:flex;"><span>│   │   └── Subscription B
</span></span><span style="display:flex;"><span>│   │
</span></span><span style="display:flex;"><span>│   └── Asia
</span></span><span style="display:flex;"><span>│       ├── Subscription C
</span></span><span style="display:flex;"><span>│       └── Subscription D
</span></span><span style="display:flex;"><span>│
</span></span><span style="display:flex;"><span>└── Development
</span></span><span style="display:flex;"><span>    ├── Subscription E
</span></span><span style="display:flex;"><span>    └── Subscription F
</span></span></code></pre></div><p>企业可以按照部门、国家或地区、开发环境、项目和业务类型建立管理层级。Management Group 最多可以嵌套 6 层，这一限制不计算：</p>
<ul>
<li>Tenant Root Group</li>
<li>Subscription 层</li>
</ul>
<p><strong>Management Group 的限制</strong></p>
<p>Management Group 还受以下数量和层级规则限制：</p>
<table>
	<thead>
			<tr>
					<th>规则</th>
					<th>含义</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>一个 Directory 最多支持 10,000 个 Management Groups</td>
					<td>Azure 对管理组数量有上限</td>
			</tr>
			<tr>
					<td>Management Group 可以嵌套最多 6 层</td>
					<td>可以建立较复杂的组织层级</td>
			</tr>
			<tr>
					<td>每个 Management Group 只能有一个 Parent</td>
					<td>一个管理组不能同时属于两个上级</td>
			</tr>
			<tr>
					<td>每个 Subscription 只能有一个 Parent</td>
					<td>一个 Subscription 同时只能处于一个 Management Group 分支中</td>
			</tr>
	</tbody>
</table>
<p>这与 Resource Group 的组织原则相似，每个对象在层级中都有明确的父级。</p>
<hr>
<h3 id="5-tenant-root-group">5. Tenant Root Group<a href="#5-tenant-root-group" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>每个 Microsoft Entra Tenant 都有一个 Tenant Root Group，它是 Management Group 层级的根节点，所有 Management Groups 和 Subscriptions 最终都位于其下。结构如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Tenant Root Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Management Groups
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscriptions
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource Groups
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resources
</span></span></code></pre></div><p>在 Tenant Root Group 上应用的 Policy 或角色分配会沿层级继承，因此可能影响整个 Tenant 下的 Azure 环境。</p>
<p><strong>关键词</strong></p>
<ul>
<li><strong>Microsoft Entra Tenant（Entra 租户）</strong>：一个组织在 Microsoft Entra ID 中的独立身份和目录边界。</li>
<li><strong>Tenant Root Group</strong>：Management Group 层级最顶层的根管理组。</li>
<li><strong>Directory（目录）</strong>：保存组织用户、组、身份等信息的身份管理环境。</li>
</ul>
<hr>
<h3 id="关键词总览">关键词总览<a href="#%e5%85%b3%e9%94%ae%e8%af%8d%e6%80%bb%e8%a7%88" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<ul>
<li><strong>Azure Resource</strong>：Azure 中实际创建和使用的服务实例。</li>
<li><strong>Resource Group</strong>：把相关 Resources 放在一起管理的逻辑容器。</li>
<li><strong>Subscription</strong>：Azure 中用于资源组织、权限控制和费用管理的边界。</li>
<li><strong>Management Group</strong>：用于统一管理多个 Subscription 的上层管理结构。</li>
<li><strong>Tenant Root Group</strong>：整个 Management Group 层级的根节点。</li>
<li><strong>Microsoft Entra Tenant</strong>：组织在 Microsoft Entra ID 中的独立身份目录。</li>
<li><strong>Billing Boundary</strong>：费用独立统计的管理边界。</li>
<li><strong>Access Control Boundary</strong>：权限可以独立配置的管理边界。</li>
<li><strong>Azure RBAC</strong>：基于角色控制用户能够访问和操作哪些 Azure 资源。</li>
<li><strong>Azure Policy</strong>：用于规定 Azure Resource 必须满足哪些配置和合规要求。</li>
<li><strong>Inheritance（继承）</strong>：上层的 Policy 或 Access 设置自动作用到下层。</li>
</ul>
<hr>
<h3 id="总结-1">总结<a href="#%e6%80%bb%e7%bb%93-1" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure 管理基础架构的核心是以下层级：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Tenant Root Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscription
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource
</span></span></code></pre></div><p>可以用公司的组织结构作类比：</p>
<table>
	<thead>
			<tr>
					<th>Azure 概念</th>
					<th>类比</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Tenant Root Group</td>
					<td>整个公司</td>
			</tr>
			<tr>
					<td>Management Group</td>
					<td>事业部 / 部门</td>
			</tr>
			<tr>
					<td>Subscription</td>
					<td>某个项目或独立预算单位</td>
			</tr>
			<tr>
					<td>Resource Group</td>
					<td>项目中的某一组相关资源</td>
			</tr>
			<tr>
					<td>Resource</td>
					<td>真正的 VM、数据库、网络等</td>
			</tr>
	</tbody>
</table>
<p>各层承担不同职责：</p>
<table>
	<thead>
			<tr>
					<th>层级</th>
					<th>核心作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Resource</td>
					<td>真正提供功能</td>
			</tr>
			<tr>
					<td>Resource Group</td>
					<td>管理一组相关资源</td>
			</tr>
			<tr>
					<td>Subscription</td>
					<td>隔离权限、费用和环境</td>
			</tr>
			<tr>
					<td>Management Group</td>
					<td>统一管理大量 Subscription</td>
			</tr>
			<tr>
					<td>Tenant Root Group</td>
					<td>对整个组织进行最高层治理</td>
			</tr>
	</tbody>
</table>
<p>Policy 和 Access 的继承关系如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>上层 Policy / Access
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Management Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Subscription
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource Group
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>Resource
</span></span></code></pre></div><p>Resource 是实际服务，Resource Group 管理一组资源，Subscription 负责资源组织、权限和费用边界，Management Group 统一管理多个 Subscription，Tenant Root Group 则位于整个 Azure 管理层级的顶层。</p>
<h2 id="azure-monitor">Azure Monitor<a href="#azure-monitor" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h2>
<h3 id="azure-monitor-中的-sli">Azure Monitor 中的 SLI<a href="#azure-monitor-%e4%b8%ad%e7%9a%84-sli" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>SLI（Service Level Indicator，服务级别指标）用于衡量服务的实际可靠性或性能。Azure Monitor 会把实际观测到的服务表现，与预先设定的目标进行比较，从而判断服务是否达到预期。一个完整的 SLI 不只是一个指标，而是由服务范围、SLI 类型、评估方式、信号设计、SLO 目标和统计周期等共同组成。</p>
<p><strong>1. SLI 的基本组成</strong></p>
<table>
	<thead>
			<tr>
					<th>组成部分</th>
					<th>通俗解释</th>
					<th>作用</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Service Group</td>
					<td>这个 SLI 到底是在衡量哪个应用或工作负载</td>
					<td>明确测量范围</td>
			</tr>
			<tr>
					<td>SLI Type</td>
					<td>你到底想测“能不能用”，还是“够不够快”</td>
					<td>决定可靠性问题的类型</td>
			</tr>
			<tr>
					<td>Evaluation Method</td>
					<td>按每一次请求统计，还是按一段段时间窗口统计</td>
					<td>决定 SLI 的计算方式</td>
			</tr>
			<tr>
					<td>Signal Design</td>
					<td>用哪些指标、过滤条件、聚合方式和公式来判断好坏</td>
					<td>定义什么算成功、什么算失败</td>
			</tr>
			<tr>
					<td>Baseline Target</td>
					<td>实际指标需要达到的目标值，也就是 SLO</td>
					<td>判断服务是否达标</td>
			</tr>
			<tr>
					<td>Compliance Period</td>
					<td>在多长时间范围内判断是否达标</td>
					<td>明确统计周期</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>SLI</strong>：实际测量出来的服务表现。</li>
<li><strong>SLO</strong>：SLI 应该达到的目标。</li>
<li><strong>Compliance Period</strong>：判断 SLO 是否达标的统计时间范围，例如 7 天、30 天。</li>
<li><strong>Signal</strong>：用于计算 SLI 的原始监控数据和条件。</li>
</ul>
<hr>
<p><strong>2. SLI 的两种主要类型</strong></p>
<p>Azure Monitor 主要支持 Availability 和 Latency 两类 SLI：</p>
<table>
	<thead>
			<tr>
					<th>类型</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Availability</td>
					<td>服务到底有没有正常工作</td>
					<td>99.99% 的读写请求成功</td>
			</tr>
			<tr>
					<td>Latency</td>
					<td>服务响应得够不够快</td>
					<td>95% 的请求在 300 ms 内完成</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Availability（可用性）</strong>：服务是否成功完成用户请求。</li>
<li><strong>Latency（延迟）</strong>：从请求发出到得到响应所需要的时间。</li>
</ul>
<p>Availability 衡量请求是否成功，Latency 衡量响应是否足够快。</p>
<hr>
<p><strong>3. 两种评估方式</strong></p>
<p>Azure Monitor 可以按 Request-based 或 Window-based 两种方式计算 SLI：</p>
<table>
	<thead>
			<tr>
					<th>评估方式</th>
					<th>通俗解释</th>
					<th>适合场景</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Request-based</td>
					<td>每个请求都算一次，然后看成功请求占总请求多少</td>
					<td>最适合衡量接口请求成功率，是最常见方式</td>
			</tr>
			<tr>
					<td>Window-based</td>
					<td>把时间切成一段一段，每一段判断“好还是坏”</td>
					<td>适合不希望短时间抖动对整体结果影响太大的场景</td>
			</tr>
	</tbody>
</table>
<p><strong>Request-based</strong></p>
<p>Request-based SLI 的核心公式是：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI = Good Requests / Total Requests
</span></span></code></pre></div><p>以下示例中，成功请求数为 9900，总请求数为 10000：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>成功请求：9900
</span></span><span style="display:flex;"><span>总请求：10000
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>SLI = 9900 / 10000 = 99%
</span></span></code></pre></div><p>其中，Good Signal 是分子，表示符合成功条件的请求；Total Signal 是分母，表示所有参与统计的请求。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Good Signal：
</span></span><span style="display:flex;"><span>HTTP 状态码 = 200 的请求
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Total Signal：
</span></span><span style="display:flex;"><span>所有 HTTP 请求
</span></span></code></pre></div><p>相应的 Availability SLI 为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Availability SLI
</span></span><span style="display:flex;"><span>= HTTP 200 请求数 / 总请求数
</span></span></code></pre></div><p><strong>Window-based</strong></p>
<p>Window-based 不直接统计成功请求占比，而是先把时间划分为多个窗口，例如每 5 分钟一个窗口：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>每 5 分钟作为一个窗口
</span></span></code></pre></div><p>然后逐个判断窗口是否合格：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>错误率 &lt; 1%
</span></span><span style="display:flex;"><span>→ Good Window
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>错误率 &gt;= 1%
</span></span><span style="display:flex;"><span>→ Bad Window
</span></span></code></pre></div><p>最终按合格窗口占比计算 SLI：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI = Good Windows / Total Windows
</span></span></code></pre></div><p>这种方法能降低短暂流量尖峰对整体 SLI 的影响。</p>
<p><em>关键词</em></p>
<ul>
<li><strong>Good Signal</strong>：满足成功条件的数据。</li>
<li><strong>Total Signal</strong>：参与统计的全部数据。</li>
<li><strong>Request-based</strong>：以请求为基本统计单位。</li>
<li><strong>Window-based</strong>：以时间窗口为基本统计单位。</li>
<li><strong>Threshold（阈值）</strong>：用于判断结果是否合格的界限值。</li>
</ul>
<hr>
<p><strong>4. Signal 如何定义</strong></p>
<p>真正创建 SLI 时，需要指定 Azure Monitor 应该使用哪些 Metrics，并通过过滤、聚合和公式定义成功条件。</p>
<table>
	<thead>
			<tr>
					<th>方法</th>
					<th>通俗解释</th>
					<th>例子</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Metric</td>
					<td>选择真正要统计的数据</td>
					<td>请求数、错误数、响应时间</td>
			</tr>
			<tr>
					<td>Filter</td>
					<td>只保留符合条件的数据</td>
					<td>只统计 HTTP 200</td>
			</tr>
			<tr>
					<td>Temporal Aggregation</td>
					<td>把一段时间内的数据进行汇总</td>
					<td>Average、Maximum、Count</td>
			</tr>
			<tr>
					<td>Spatial Aggregation</td>
					<td>把多个时间序列进一步合并</td>
					<td>把多个实例的数据汇总成服务整体</td>
			</tr>
			<tr>
					<td>Formula</td>
					<td>用多个指标计算出新信号</td>
					<td>成功请求数 ÷ 总请求数</td>
			</tr>
	</tbody>
</table>
<p><em>关键词</em></p>
<ul>
<li><strong>Metric（指标）</strong>：系统持续产生的数值，例如请求数、CPU、延迟。</li>
<li><strong>Filter（过滤）</strong>：从所有数据中筛选出需要的数据。</li>
<li><strong>Temporal Aggregation（时间聚合）</strong>：对一段时间内的数据进行平均、求最大值或计数。</li>
<li><strong>Spatial Aggregation（空间聚合）</strong>：把来自多个实例、区域或时间序列的数据合并。</li>
<li><strong>Formula（公式）</strong>：通过一个或多个指标计算出最终信号。</li>
</ul>
<hr>
<p><strong>5. SLI 与 SLO 的关系</strong></p>
<p>SLI 是实际测量值，Baseline Target 是 SLI 应达到的目标，也就是 SLO。例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI：
</span></span><span style="display:flex;"><span>过去 30 天请求成功率 = 99.92%
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>SLO：
</span></span><span style="display:flex;"><span>请求成功率 &gt;= 99.9%
</span></span></code></pre></div><p>此时实际值高于目标：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>99.92% &gt; 99.9%
</span></span><span style="display:flex;"><span>→ 达到 SLO
</span></span></code></pre></div><p>如果实际值低于目标：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI = 99.7%
</span></span><span style="display:flex;"><span>SLO = 99.9%
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>→ 未达到 SLO
</span></span></code></pre></div><p>可以把 SLI 理解为实际成绩，把 SLO 理解为目标分数。</p>
<hr>
<p><strong>6. Error Budget</strong></p>
<p>Azure Monitor 根据 SLO 计算 Error Budget，公式为：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Error Budget = 100% - SLO
</span></span></code></pre></div><p>SLO 为 99.9% 时：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLO = 99.9%
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Error Budget
</span></span><span style="display:flex;"><span>= 100% - 99.9%
</span></span><span style="display:flex;"><span>= 0.1%
</span></span></code></pre></div><p>这表示服务在当前统计周期内最多可以承受 0.1% 的不可靠性。</p>
<table>
	<thead>
			<tr>
					<th>概念</th>
					<th>通俗解释</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>SLO</td>
					<td>你要求系统达到的可靠性</td>
			</tr>
			<tr>
					<td>Error Budget</td>
					<td>在不违反 SLO 的前提下，还允许出多少问题</td>
			</tr>
	</tbody>
</table>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLO：99.9%
</span></span><span style="display:flex;"><span>允许失败：0.1%
</span></span></code></pre></div><p>当 SLO 为 99.9% 时，剩余的 0.1% 就是可以被故障、发布风险或其他异常消耗的预算。</p>
<hr>
<p><strong>7. Burn Rate</strong></p>
<p>Burn Rate 表示 Error Budget 的消耗速度。Azure Monitor 不只关心预算还剩多少，也会判断当前消耗速度是否会使预算很快耗尽。例如，初始 Error Budget 为 0.1%：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Error Budget = 0.1%
</span></span></code></pre></div><p>如果统计刚开始不久就出现以下情况：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>已经消耗 0.08%
</span></span></code></pre></div><p>即使服务暂时没有违反 SLO，预算也消耗得过快，Burn Rate 可以提前反映这种风险。</p>
<p><strong>Fast Burn</strong></p>
<p>Fast Burn 指 Error Budget 在短时间内快速消耗，通常意味着突然发生严重故障或版本回退，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>刚发布新版本
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>大量 500 错误
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>10 分钟消耗掉大量 Error Budget
</span></span></code></pre></div><p><strong>Slow Burn</strong></p>
<p>Slow Burn 的消耗速度较慢，但持续时间很长，例如：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>每天都有少量请求失败
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>问题持续几个星期
</span></span><span style="display:flex;"><span>↓
</span></span><span style="display:flex;"><span>最终仍然可能耗尽 Error Budget
</span></span></code></pre></div><p><em>关键词</em></p>
<ul>
<li><strong>Error Budget</strong>：允许的不可靠性额度。</li>
<li><strong>Burn Rate</strong>：Error Budget 的消耗速度。</li>
<li><strong>Fast Burn</strong>：短时间内快速消耗预算。</li>
<li><strong>Slow Burn</strong>：长期持续消耗预算。</li>
</ul>
<p>Error Budget 反映还剩多少容错空间，Burn Rate 反映这部分空间消耗得有多快。</p>
<hr>
<p><strong>8. Alert</strong></p>
<p>Azure Monitor 可以针对 SLI 配置不同类型的告警：</p>
<table>
	<thead>
			<tr>
					<th>告警类型</th>
					<th>通俗解释</th>
					<th>用途</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Baseline Alert</td>
					<td>SLI 已经低于 SLO</td>
					<td>告诉你服务已经不达标</td>
			</tr>
			<tr>
					<td>Fast Burn Rate Alert</td>
					<td>Error Budget 正在被快速消耗</td>
					<td>提前发现突然恶化的问题</td>
			</tr>
			<tr>
					<td>Slow Burn Rate Alert</td>
					<td>Error Budget 长时间持续被消耗</td>
					<td>发现长期的小问题</td>
			</tr>
	</tbody>
</table>
<p>三类告警关注的阶段不同：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Baseline Alert：
</span></span><span style="display:flex;"><span>“你已经不及格了。”
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Fast Burn：
</span></span><span style="display:flex;"><span>“照这个速度下去，很快就会不及格。”
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Slow Burn：
</span></span><span style="display:flex;"><span>“问题虽然不严重，但一直这样迟早会不及格。”
</span></span></code></pre></div><p>Burn Rate 告警能够在 SLO 真正被突破前发出预警，因此比只等待基线告警更早暴露风险。</p>
<hr>
<h3 id="整体流程">整体流程<a href="#%e6%95%b4%e4%bd%93%e6%b5%81%e7%a8%8b" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h3>
<p>Azure Monitor 中创建和使用 SLI 的流程如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>确定要监控哪个服务
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>选择 SLI 类型
</span></span><span style="display:flex;"><span>Availability / Latency
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>选择评估方式
</span></span><span style="display:flex;"><span>Request-based / Window-based
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>选择 Metrics
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>通过 Filter / Aggregation / Formula
</span></span><span style="display:flex;"><span>定义什么算 Good
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>计算 SLI
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>设置 SLO
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>计算 Error Budget
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>持续观察 Burn Rate
</span></span><span style="display:flex;"><span>        ↓
</span></span><span style="display:flex;"><span>配置告警
</span></span></code></pre></div><p>各概念之间的关系如下：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>SLI
</span></span><span style="display:flex;"><span>实际表现
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>与 SLO 比较
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>SLO
</span></span><span style="display:flex;"><span>目标表现
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>100% - SLO
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>Error Budget
</span></span><span style="display:flex;"><span>允许失败多少
</span></span><span style="display:flex;"><span>   ↓
</span></span><span style="display:flex;"><span>Burn Rate
</span></span><span style="display:flex;"><span>失败额度消耗多快
</span></span></code></pre></div><p>SLI 描述系统的实际表现，SLO 规定目标水平，Error Budget 表示还能容忍多少失败，Burn Rate 则反映这部分额度的消耗速度。</p>
]]></content></item><item><title>School of SRE</title><link>https://blog.hieros.me/zh/posts/sre/</link><pubDate>Thu, 17 Sep 2026 23:00:00 +0800</pubDate><author>BLESS</author><guid>https://blog.hieros.me/zh/posts/sre/</guid><description>SRE学习与翻译</description><content type="text/html" mode="escaped"><![CDATA[<p>最近在准备工作相关的，感觉 SRE 是个重要方向，所以开始看 Linkedin 的 SRE 教程，纯英，看的有点吃力，所以一边看一边写笔记缓解一下。这份笔记是我的个人评论和部分原文的 GPT5.6 sol翻译的结合，主要融入了一些我查阅的关于教程中我不理解的地方的信息，当否供参考。Linkedin 的 SRE 教程原链接 <a href="https://linkedin.github.io/school-of-sre/" target="_blank" >https://linkedin.github.io/school-of-sre/</a>，此份文档遵循CC BY-NC-SA 4.0 协议。</p>
<h1 id="school-of-sre">School of SRE<a href="#school-of-sre" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<p>站点可靠性工程师（Site Reliability Engineer，SRE）处于软件工程与系统工程的交叉领域。虽然基础设施和软件组件的组合方式几乎是无限的，不同组件可以通过各种排列组合来实现特定目标，但只要掌握扎实的基础技能，SRE 就能够应对复杂的系统和软件，不必过分依赖具体技术环境——无论这些系统是企业自研的、第三方提供的、开放式系统，还是运行在云端或本地基础设施上。关键是要深入理解系统与基础设施中各个领域之间是如何相互关联、相互作用的。兼具软件工程和系统工程能力的人才相对少见，这类能力通常需要经过较长时间的积累，并通过接触各种不同类型的基础设施、系统和软件逐渐形成。</p>
<p>SRE 会将工程化实践引入系统运维工作，以确保网站和服务能够持续稳定运行。每一个分布式系统本质上都是由大量组件组合而成的。SRE 需要验证业务需求，并将这些需求转化为针对分布式系统各个组成部分的服务等级协议（Service Level Agreement，SLA）；持续监控和衡量系统是否满足这些 SLA。当系统存在违反 SLA 的风险时，SRE 会通过重新设计系统架构、横向扩展等方式进行缓解或避免。与此同时，SRE 还会把这些实践中获得的经验反馈到新的系统或项目中，从而减少日常运维中重复、繁琐的人工工作（operational toil）。因此，在系统设计之初（day 0），SRE 就发挥着非常重要的作用。</p>
<p>我们相信，持续学习能够帮助大家获得更深入的知识和能力，从而不断扩展自己的技能体系。因此，每个模块中都加入了相关参考资料，可作为进一步学习的指南。我们希望，通过学习这些模块，大家能够逐步具备一名 SRE 所必需的核心技能。</p>
<h1 id="level-101">Level 101<a href="#level-101" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h1>
<blockquote>
<p>101 是美国大学课程编号里的习惯用法，通常代表某领域的基础课，201 301 401依次进阶。后文的 102 通常是 101 下一门课的编号。</p>
</blockquote>
<p><strong>什么是 Linux 操作系统</strong></p>
<p>我们大多数人都比较熟悉 Windows 操作系统。在个人电脑中，Windows 的使用比例超过 75%。Windows 操作系统基于 Windows NT 内核。</p>
<p>所谓<strong>内核（kernel）</strong>，是操作系统中最重要的组成部分。它负责执行很多核心功能，例如进程管理、内存管理、文件系统管理等。</p>
<p>Linux 操作系统则基于 Linux 内核。一个基于 Linux 的操作系统通常包括 Linux 内核、GUI/CLI、系统库以及系统工具。Linux 内核最初由 Linus Torvalds 独立开发并发布。Linux 内核是自由且开源的软件。</p>
<p>Linux 本身严格来说只是一个<strong>内核</strong>，并不是一个完整的操作系统。Linux 内核通常会与 GNU 系统结合，组成一个完整的操作系统。因此，基于 Linux 的操作系统也常被称为 <strong>GNU/Linux 系统</strong>。</p>
<p>GNU 是一个非常庞大的自由软件集合，其中包括编译器、调试器、C 语言库等工具和组件。</p>
<p>关于 Linux 与 GNU 系统之间的关系，可以参考：
<a href="https://www.gnu.org/gnu/linux-and-gnu.en.html" target="_blank" >Linux and the GNU System</a></p>
<p>关于 Linux 的发展历史，可以参考：
<a href="https://en.wikipedia.org/wiki/History_of_Linux" target="_blank" >History of Linux</a></p>
<p><strong>什么是常见的 Linux 发行版</strong></p>
<p>Linux 发行版（Linux distribution，简称 <strong>distro</strong>）是基于 Linux 内核，并配套了一套软件包管理系统的操作系统。</p>
<p>所谓<strong>软件包管理系统（package management system）</strong>，是由一组用于安装、升级、配置和卸载操作系统中软件的工具组成的。</p>
<p>软件通常需要针对不同的 Linux 发行版进行适配，并被打包成该发行版所采用的特定格式。这些软件包一般会存放在对应发行版的软件仓库（repository）中。</p>
<p>在操作系统中，用户通过**软件包管理器（package manager）**来安装和管理这些软件包。</p>
<p>常见的 Linux 发行版包括：</p>
<ul>
<li>Fedora</li>
<li>Ubuntu</li>
<li>Debian</li>
<li>CentOS</li>
<li>Red Hat Enterprise Linux（RHEL）</li>
<li>SUSE</li>
<li>Arch Linux</li>
</ul>
<p>不同发行版通常采用不同的软件包格式和软件包管理器：</p>
<table>
	<thead>
			<tr>
					<th>软件包体系</th>
					<th>常见发行版</th>
					<th>软件包管理器</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Debian 系（<code>.deb</code>）</td>
					<td>Debian、Ubuntu</td>
					<td>APT</td>
			</tr>
			<tr>
					<td>Red Hat 系（<code>.rpm</code>）</td>
					<td>Fedora、CentOS、Red Hat Enterprise Linux</td>
					<td>YUM</td>
			</tr>
	</tbody>
</table>
<blockquote>
<p>以上内容已经老了，2019 年 YUM 底层就彻底被 DNF 替代了，近几年 Nix 也火了：</p>
<table>
	<thead>
			<tr>
					<th>软件包体系</th>
					<th>常见发行版</th>
					<th>软件包管理器</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Debian 系（<code>.deb</code>）</td>
					<td>Debian、Ubuntu</td>
					<td>APT</td>
			</tr>
			<tr>
					<td>Red Hat 系（<code>.rpm</code>）</td>
					<td>Fedora、CentOS Stream、Red Hat Enterprise Linux</td>
					<td>DNF</td>
			</tr>
			<tr>
					<td>SUSE 系（<code>.rpm</code>）</td>
					<td>openSUSE、SUSE Linux Enterprise</td>
					<td>Zypper</td>
			</tr>
			<tr>
					<td>Arch 系（<code>.pkg.tar.zst</code>）</td>
					<td>Arch Linux、Manjaro</td>
					<td>Pacman</td>
			</tr>
			<tr>
					<td>Nix 系</td>
					<td>NixOS</td>
					<td>Nix</td>
			</tr>
	</tbody>
</table>
</blockquote>
<p><strong>Linux 架构</strong></p>
<img src="../../SRE/linux_arch.png" alt="Linux 架构" style="width:60%">
<blockquote>
<p>图中用户空间运行普通程序，例如 ls。大多数应用程序都运行在这一层，它们通常会依赖 glibc 或其他用户态库提供的接口。程序需要内核服务时，会通过系统调用接口发起请求，此时 CPU 从用户态切换到内核态，由内核中的不同子系统处理相应功能。进程管理负责进程的创建、调度和结束；内存管理负责虚拟内存、内存分配和页表等；虚拟文件系统 VFS 负责统一抽象不同文件系统；网络子系统负责 TCP/IP、socket 等网络功能；进程间通信 IPC 负责不同进程之间的数据交换。设备驱动则负责内核与具体硬件之间的通信，最终完成硬件操作。</p>
</blockquote>
<ul>
<li>Linux 内核本质上采用**宏内核（Monolithic Kernel）**架构。</li>
</ul>
<blockquote>
<p>宏内核是指大多数核心功能（文件系统、驱动等）都直接放到内核里运行的架构，区别于微内核——只保留核心功能。</p>
</blockquote>
<ul>
<li>内核代码只能在<strong>内核态（Kernel Mode）<strong>下执行；非内核代码通常运行在</strong>用户态（User Mode）</strong>。</li>
</ul>
<blockquote>
<p>用户态是供普通程序运行的低权限 CPU 执行模式，不能直接访问内核内存和随意操作硬件，内核态则是高权限 CPU 执行模式，可以访问系统全部内存和硬件资源。这里的权限指的是执行时 CPU 有多高的硬件权限，和操作系统的访问控制规则不同层级。</p>
</blockquote>
<ul>
<li>用户空间程序通过**系统调用（System Call）**与 Linux 内核空间进行交互。</li>
</ul>
<blockquote>
<p>系统调用运行在用户态的程序，为了请求操作系统内核提供某项受保护的服务，而通过规定接口主动切换到内核态执行的一种机制。用户态的程序像读写文件，建立网络连接都得请求内核服务，发生从用户态-&gt;内核态-&gt;用户态的切换。</p>
</blockquote>
<ul>
<li>**设备驱动（Device Driver）**用于与硬件设备进行通信。</li>
</ul>
<p><strong>Linux 操作系统的用途</strong></p>
<p>基于 Linux 内核的操作系统被广泛应用于：个人电脑，服务器，手机：Android 基于 Linux 内核；嵌入式设备：如手表、电视、交通信号灯等；卫星，网络设备：如路由器、交换机等。</p>
<p><strong>图形用户界面（GUI）与命令行界面（CLI）</strong></p>
<p>用户借助用户界面（User Interface）与计算机进行交互。用户界面可以是 GUI（Graph User Interface），也可以是 CLI（Command Line Interface）。</p>
<p>GUI 允许用户通过图标、图像等图形元素与计算机进行交互。当用户点击某个图标来打开计算机上的应用程序时，实际上就是在使用 GUI。使用 GUI 执行任务通常比较容易。</p>
<p>CLI 允许用户通过命令与计算机进行交互。用户在终端中输入命令，系统负责执行这些命令。对于习惯使用 GUI 的新用户来说，CLI 可能会比较难，因为用户需要知道执行某项具体操作所对应的命令。</p>
<p><strong>Shell 与终端</strong></p>
<p>Shell 是一种程序，它接收用户输入的命令，并将这些命令交给操作系统处理。Shell 是 CLI 的一种实现。Bash 是 Linux 服务器上最常见的 Shell 程序之一。其他常见的 Shell 程序还有 zsh、ksh、tcsh、fish、dash、nushell等等。</p>
<p>终端（Terminal）是一种程序，它会打开一个窗口，并允许你与 Shell 进行交互。常见的终端程序包括 GNOME Terminal、xterm、Konsole、Kitty等。</p>
<p>Linux 用户经常会将 shell、终端、命令提示符、控制台等术语混用。简单来说，这些术语都可以用来指代一种接收用户命令的方式。</p>
<h4 id="命令行基础">命令行基础<a href="#%e5%91%bd%e4%bb%a4%e8%a1%8c%e5%9f%ba%e7%a1%80" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p><strong>命令是什么</strong></p>
<p>命令（command）是一个告诉操作系统执行某项特定工作的程序。在 Linux 中，程序以文件的形式存储。因此，一个命令本质上也是一个存放在磁盘某处的文件。</p>
<blockquote>
<p>大多数常见 Linux 命令，本质上都是用户空间程序（还有一些 Shell 内置命令），并不是 Linux 内核的一部分，因此理论上可以不安装。下面这些命令只是大多数发行版通常会预装的工具。</p>
</blockquote>
<p>命令还可以接收用户提供的额外参数作为输入，这些参数称为命令行参数（command-line arguments）。</p>
<p>了解如何使用命令很重要，而 Linux 提供了很多获取帮助的方法，尤其是针对各种命令。几乎每个命令都会提供某种形式的文档。大多数命令都支持 -h 或 &ndash;help 这样的命令行参数，用来显示一定量的帮助信息。</p>
<p>不过，Linux 中最常用的文档系统是 man pages，也就是 manual pages（手册页） 的简称。</p>
<p><strong>文件系统组织方式</strong></p>
<p>Linux 文件系统采用树状结构，其最高层级的目录称为根目录（root directory），用 <code>/</code> 表示。根目录下包含多个目录，用于存放与系统相关的文件。这些目录中又可以继续存放系统文件、应用程序文件或与用户相关的文件。</p>
<img src="../../SRE/file_org.png" alt="file_org" style="width: 80%">
<div class="info-table-wrap directory-table-wrap">
  <table class="info-table directory-table">
    <thead>
      <tr>
        <th scope="col">目录</th>
        <th scope="col">英文来源</th>
        <th scope="col">说明</th>
      </tr>
    </thead>
    <tbody>
      <tr><td><code>/bin</code></td><td>binary</td><td>存放最常用命令的可执行程序</td></tr>
      <tr><td><code>/dev</code></td><td>device</td><td>存放与系统设备相关的文件</td></tr>
      <tr><td><code>/etc</code></td><td>et cetera</td><td>存放系统配置文件</td></tr>
      <tr><td><code>/home</code></td><td>home</td><td>存放普通用户的文件和目录</td></tr>
      <tr><td><code>/lib</code></td><td>library</td><td>存放系统所需的库文件</td></tr>
      <tr><td><code>/mnt</code></td><td>mount</td><td>通常用于挂载设备或文件系统</td></tr>
      <tr><td><code>/proc</code></td><td>process</td><td>存放与当前运行进程和内核状态相关的虚拟文件</td></tr>
      <tr><td><code>/root</code></td><td>root</td><td>root 用户的主目录</td></tr>
      <tr><td><code>/sbin</code></td><td>system binary</td><td>存放系统管理相关的程序</td></tr>
      <tr><td><code>/tmp</code></td><td>temporary</td><td>存放临时文件</td></tr>
      <tr><td><code>/usr</code></td><td>user（历史名称）</td><td>存放大量用户空间程序、库和相关文件</td></tr>
    </tbody>
  </table>
</div>
<p><strong>用于查看文件的命令</strong></p>
<p>有五个经常用于查看文件内容的基本命令：cat、head、tail、more、less</p>
<p>我们将创建一个名为 <code>numbers.txt</code> 的新文件，并在这个文件中写入从 1 到 100 的数字。每个数字单独占一行。</p>
<img src="../../SRE/seq1.png" alt="seq1">
<p>现在不必担心上面的命令。它是一个用于生成数字的高级命令。之后，我们又使用了一个重定向操作符，将这些数字写入文件中。我们将在后面的章节中讨论 I/O 重定向。</p>
<p><em>cat</em>(concatenate)</p>
<p><code>cat</code> 命令最简单的用途，是将文件内容打印到输出屏幕上。这个命令非常有用，还可以用于许多其他用途。我们会在后面学习它的其他用法。</p>
<img src="../../SRE/cat.png" alt="cat">
<p>你可以尝试运行上面的命令，你会看到从 1 到 100 的数字被打印到屏幕上。你需要向上滚动，才能查看所有数字。</p>
<p><em>head</em></p>
<p><code>head</code> 命令默认显示文件的前 10 行。我们可以加入额外参数，以显示从文件开头算起的任意行数。</p>
<p>在这个例子中，当我们使用 <code>head</code> 命令时，只能看到文件的前 10 行。</p>
<img src="../../SRE/head1.png" alt="head1">
<p>默认情况下，<code>head</code> 命令只会显示前 10 行。如果我们想指定从文件开头查看多少行，可以使用 <code>-n</code> 参数来提供这个数值。</p>
<img src="../../SRE/head2.png" alt="head2">
<p><em>tail</em></p>
<p><code>tail</code> 命令默认显示文件的最后 10 行。我们可以加入额外参数，以显示从文件末尾算起的任意行数。</p>
<img src="../../SRE/tail1.png" alt="tail1">
<p>默认情况下，<code>tail</code> 命令只会显示最后 10 行。如果我们想指定从文件末尾查看多少行，可以使用 <code>-n</code> 参数来提供这个数值。</p>
<img src="../../SRE/tail2.png" alt="tail2">
<p>在这个例子中，当我们显式使用 <code>-n</code> 选项配合 <code>tail</code> 命令时，只能看到文件的最后 5 行。</p>
<p><em>more</em></p>
<p><code>more</code> 命令用于显示文件内容或命令输出。当文件很大时，例如日志文件，它会一次显示一个屏幕的内容。它也支持向前导航，以及有限的向后导航。</p>
<blockquote>
<p><code>more</code> 就是前面提到的分页显示工具的一种</p>
</blockquote>
<img src="../../SRE/more.png" alt="more">
<p><code>more</code> 命令会显示当前屏幕能够容纳的尽可能多的内容，然后等待用户输入以继续。可以按 <code>Enter</code> 键向前移动一行，也可以按 <code>Space</code> 键向前移动一个屏幕。</p>
<p><em>less</em></p>
<p><code>less</code> 命令是 <code>more</code> 的改进版本。它用于显示文件内容或命令输出，并且一次显示一页。</p>
<p>它既支持向后导航，也支持向前导航，还提供搜索功能。我们可以使用方向键每次向前或向后移动一行。要向前移动一页，可以按 <code>Space</code>；要向后移动一页，可以按键盘上的 <code>b</code>。</p>
<p>你还可以立即跳转到文件的开头或结尾。</p>
<p><strong>文本处理命令</strong></p>
<p>在上一节中，我们学习了如何查看文件内容。在很多情况下，我们会希望执行以下操作：</p>
<ul>
<li>只打印包含某个特定单词的行</li>
<li>将文件中的某个特定单词替换为另一个单词</li>
<li>按照特定顺序对各行进行排序</li>
</ul>
<p>有三个经常用于处理文本的基本命令：<code>grep</code>，<code>sed</code>，<code>sort</code></p>
<p>我们将创建一个名为 <code>numbers.txt</code> 的新文件，并在该文件中写入从 1 到 10 的数字。每个数字单独占一行。</p>
<img src="../../SRE/seq2.png" alt="seq2">
<p><em>grep</em>(global regular expression print)</p>
<p><code>grep</code> 命令最简单的用途，是在文本文件中搜索特定单词。它会显示文件中所有包含特定输入内容的行。</p>
<p>我们想要搜索的单词会作为输入提供给 <code>grep</code> 命令。</p>
<p>使用 <code>grep</code> 命令的一般语法：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>grep &lt;word_to_search&gt; &lt;file_name&gt;
</span></span></code></pre></div><p>在这个例子中，我们尝试在这个文件中搜索字符串 <code>&quot;1&quot;</code>。<code>grep</code> 命令会输出找到这个字符串的那些行。</p>
<img src="../../SRE/grep.png" alt="grep">
<p><em>sed</em>(stream editor)</p>
<p><code>sed</code> 命令最简单的用途，是替换文件中的文本。</p>
<p>使用 <code>sed</code> 命令进行替换的一般语法：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>sed <span style="color:#e6db74">&#39;s/&lt;text_to_replace&gt;/&lt;replacement_text&gt;/&#39;</span> &lt;file_name&gt;
</span></span></code></pre></div><p>下面我们尝试使用 <code>sed</code> 命令，将文件中每次出现的 <code>&quot;1&quot;</code> 替换为 <code>&quot;3&quot;</code>。</p>
<img src="../../SRE/sed.png" alt="sed">
<p>在上面的例子中，文件本身的内容不会发生改变。</p>
<p>如果要让修改直接写回文件，我们必须额外使用 <code>-i</code> 参数，这样修改才会反映到原文件中。</p>
<p><em>sort</em></p>
<p><code>sort</code> 命令可以对作为参数提供给它的输入进行排序。默认情况下，它会按照升序进行排序。</p>
<p>在尝试排序之前，我们先查看一下文件内容。</p>
<img src="../../SRE/sort1.png" alt="sort1">
<p>现在，我们将尝试使用 <code>sort</code> 命令对文件进行排序。<code>sort</code> 命令按照字典序进行排序。</p>
<blockquote>
<p><code>sort</code> 默认进行的是“字符串排序”，不是“数学上的数字升序排序”。默认认为每行都是字符串然后依次比较每个字符的大小按ASCII码的顺序。</p>
</blockquote>
<img src="../../SRE/sort2.png" alt="sort2">
<p>在上面的例子中，文件本身的内容不会发生改变。</p>
<p><strong>I/O 重定向</strong></p>
<p>每个打开的文件都会被分配一个文件描述符（file descriptor）。文件描述符是系统中用于标识打开文件的唯一标识符。系统始终默认打开三个文件：</p>
<blockquote>
<p>程序每打开一个文件或输入输出通道，系统都会给它一个数字编号。这个数字编号叫文件描述符。程序启动时，默认已经有 0、1、2 三个文件描述符。</p>
</blockquote>
<ul>
<li><code>stdin</code> — standard input，标准输入，这里通常指键盘</li>
<li><code>stdout</code> — standard output，标准输出，这里通常指屏幕</li>
<li><code>stderr</code> — standard error，标准错误，即输出到屏幕上的错误信息</li>
</ul>
<p>这些文件都可以被重定向。</p>
<p>Linux 中“一切皆文件”（Everything is a file）：</p>
<p><a href="https://unix.stackexchange.com/questions/225537/everything-is-a-file" target="_blank" >https://unix.stackexchange.com/questions/225537/everything-is-a-file</a></p>
<blockquote>
<p>Linux 将普通文件、目录、设备、终端、管道等资源统一抽象为“文件”，程序可以通过类似的读写接口访问它们。很多操作都可以被抽象成对广义文件的<code>open</code>，<code>read</code>，<code>write</code>，<code>close</code>。前文的<code>stdin</code>，<code>stdout</code>，<code>stderr</code>就被抽象为文件。</p>
</blockquote>
<p>到目前为止，我们一直把所有输出显示在屏幕上，而屏幕就是标准输出。我们可以使用一些特殊操作符，将命令的输出重定向到文件中，甚至将其重定向成其他命令的输入。I/O 重定向是一项非常强大的功能。</p>
<p>在下面的例子中，我们使用 <code>&gt;</code> 操作符，将 <code>ls</code> 命令的输出重定向到 <code>output.txt</code> 文件中。</p>
<img src="../../SRE/io1.png" alt="io1">
<p>在下面的例子中，我们将 <code>echo</code> 命令的输出重定向到了一个文件中。</p>
<img src="../../SRE/io2.png" alt="io2">
<p>我们也可以将一个命令的输出重定向为另一个命令的输入。</p>
<p>这可以借助管道（pipe）来实现。</p>
<p>在下面的例子中，我们使用管道操作符 <code>|</code>，把 <code>cat</code> 命令的输出作为输入传递给 <code>grep</code> 命令。</p>
<img src="../../SRE/io3.png" alt="io3">
<p><em>uniq</em>(unique)</p>
<p>在下面的例子中，我们使用管道操作符 <code>|</code>，把 <code>sort</code> 命令的输出作为输入传递给 <code>uniq</code> 命令。</p>
<p><code>uniq</code> 命令只会打印输入中的唯一数字。</p>
<img src="../../SRE/io4.png" alt="io4">
<p>I/O 重定向： <a href="https://tldp.org/LDP/abs/html/io-redirection.html" target="_blank" >https://tldp.org/LDP/abs/html/io-redirection.html</a></p>
<h4 id="linux-服务器管理">Linux 服务器管理<a href="#linux-%e6%9c%8d%e5%8a%a1%e5%99%a8%e7%ae%a1%e7%90%86" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
      stroke-linecap="round" stroke-linejoin="round" class="feather">
      <path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path>
      <line x1="8" y1="12" x2="16" y2="12"></line>
   </svg></a></h4>
<p><strong>多用户操作系统</strong></p>
<p>如果一个操作系统允许多个用户使用同一台计算机，并且不会相互影响彼此的文件和个人设置，那么这个操作系统就可以被称为多用户操作系统。</p>
<p>基于 Linux 的操作系统本质上就是多用户操作系统，因为它允许多个用户同时访问系统。一台典型的计算机通常只有一个键盘和一台显示器，但如果计算机连接到了网络，多个用户就可以通过 SSH 登录到这台计算机。我们会在后面进一步介绍 SSH。</p>
<p>作为服务器管理员，我们大多数时候需要管理的 Linux 服务器，在物理位置上都距离我们非常远。我们可以借助 SSH 这类远程登录方式连接到这些服务器。</p>
<p>由于 Linux 支持多个用户，因此我们需要一种机制来让不同用户彼此隔离并受到保护。一个用户不应该能够访问或修改其他用户的文件。</p>
<p><strong>用户/用户组管理</strong></p>
<p>Linux 中的每个用户都有一个与之关联的用户 ID，称为 UID（User ID，用户标识符）。每个用户还会关联一个主目录（home directory）和一个登录 Shell（login shell）。**用户组（group）**是一个或多个用户的集合。通过用户组，可以更方便地为一组用户共享和管理权限。每个用户组都有一个与之关联的组 ID，称为 GID（Group ID，组标识符）。</p>
<p><em>id</em></p>
<p>id 命令可以用来查看与某个用户关联的 UID 和 GID。它还会列出该用户所属的用户组。</p>
<p>与 root 用户关联的 UID 和 GID 都是 0。</p>
<p>在 Linux 中，查看当前用户是谁，一个很方便的方法是使用 whoami 命令。</p>
<p>root 用户，也称为超级用户（superuser），是系统中权限最高的用户，可以不受限制地访问系统中的所有资源。它的 UID 为 0。</p>
<p><strong>与用户/用户组相关的重要文件</strong></p>
<div class="info-table-wrap account-files-table-wrap">
  <table class="info-table account-files-table">
    <thead>
      <tr>
        <th scope="col">文件</th>
        <th scope="col">作用</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><code>/etc/passwd</code></td>
        <td>记录用户名、<code>UID</code>、<code>GID</code>、主目录和登录 Shell 等账户信息</td>
      </tr>
      <tr>
        <td><code>/etc/shadow</code></td>
        <td>存储用户密码的哈希值及密码有效期等安全信息</td>
      </tr>
      <tr>
        <td><code>/etc/group</code></td>
        <td>记录用户组名称、<code>GID</code>及组成员信息</td>
      </tr>
    </tbody>
  </table>
</div>
<p>进一步理解 linux 的权限机制可以参考下面的链接：</p>
<p><a href="https://tldp.org/LDP/lame/LAME/linux-admin-made-easy/shadow-file-formats.html" target="_blank" >https://tldp.org/LDP/lame/LAME/linux-admin-made-easy/shadow-file-formats.html</a>
<a href="https://tldp.org/HOWTO/User-Authentication-HOWTO/x71.html" target="_blank" >https://tldp.org/HOWTO/User-Authentication-HOWTO/x71.html</a></p>
<p><strong>管理用户的重要命令</strong></p>
<p>Linux 中经常用于管理用户/用户组的一些命令如下：</p>
<ul>
<li><code>useradd</code> — <strong>user add</strong>，创建一个新用户</li>
<li><code>passwd</code> — <strong>password</strong>，为用户添加或修改密码</li>
<li><code>usermod</code> — <strong>user modify</strong>，修改用户属性</li>
<li><code>userdel</code> — <strong>user delete</strong>，删除用户</li>
</ul>
<p><em>useradd</em>(user add)</p>
<p><code>useradd</code> 命令用于在 Linux 中添加一个新用户。</p>
<p>我们将创建一个新用户 <code>shivam</code>。然后通过查看 <code>/etc/passwd</code> 文件的末尾内容，验证该用户是否已经成功创建。</p>
<p>新创建用户的 <code>UID</code> 和 <code>GID</code> 都是 <code>1000</code>。分配给该用户的主目录（home directory）是 <code>/home/shivam</code>，登录 Shell（login shell）是 <code>/bin/bash</code>。</p>
<p>需要注意的是，用户的主目录和登录 Shell 之后都可以修改。</p>
<img src="../../SRE/useradd1.png" alt="useradd1">
<p>如果我们没有为主目录或登录 Shell 等属性指定任何值，系统就会为用户分配默认值。</p>
<p>在创建新用户时，我们也可以覆盖这些默认值，手动指定相应属性。</p>
<img src="../../SRE/useradd2.png" alt="useradd2">
<p><em>passwd</em>(password)</p>
<p><code>passwd</code> 命令用于为用户创建或修改密码。</p>
<p>在上面的例子中，我们创建用户 <code>shivam</code> 和 <code>amit</code> 时，都没有为他们设置密码。</p>
<p>在 <code>/etc/shadow</code> 中，如果一个账户对应的字段中出现 <code>!!</code>，表示该用户账户已经创建，但尚未设置密码。</p>
<img src="../../SRE/passwd1.png" alt="passwd1">
<p>现在我们尝试为用户 <code>shivam</code> 创建一个密码。</p>
<img src="../../SRE/passwd2.png" alt="passwd2">
<p>请记住这个密码，因为在后面的示例中我们还会用到它。</p>
<p>另外，现在我们也来修改 <code>root</code> 用户的密码。</p>
<p>当我们从普通用户切换到 <code>root</code> 用户时，系统会要求输入密码。同样，当你直接使用 <code>root</code> 用户登录时，也会要求输入密码。</p>
<img src="../../SRE/passwd3.png" alt="passwd3">
<blockquote>
<p>图上密码强度检验工具的字典不存在所以报错，正常情况下不会报这种错。</p>
</blockquote>
<p><em>usermod</em>(user modify)</p>
<p><code>usermod</code> 命令用于修改用户的属性，例如主目录或 Shell。</p>
<p>下面我们尝试把用户 <code>amit</code> 的登录 Shell 修改为 <code>/bin/bash</code>。</p>
<img src="../../SRE/usermod.png" alt="usermod">
<p>类似地，你还可以修改用户的许多其他属性。</p>
<p>可以运行：</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-shell" data-lang="shell"><span style="display:flex;"><span>usermod -h
</span></span></code></pre></div><p>查看可以修改的属性列表。</p>
<p><em>userdel</em>(user delete)</p>
<p><code>userdel</code> 命令用于删除 Linux 中的用户。</p>
<p>删除一个用户后，与该用户相关的信息也会被删除。</p>
<p>下面我们尝试删除用户 <code>amit</code>。删除之后，你将无法再在 <code>/etc/passwd</code> 或 <code>/etc/shadow</code> 文件中找到该用户对应的条目。</p>
<img src="../../SRE/userdel.png" alt="userdel">
<p><strong>管理用户组的重要命令</strong></p>
<p>用于管理用户组的命令，与用于管理用户的命令非常相似。由于这些命令的用法比较接近，这里不再逐一详细解释。你可以尝试在自己的系统上运行这些命令。</p>
<table>
	<thead>
			<tr>
					<th>命令</th>
					<th>说明</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><code>groupadd &lt;group_name&gt;</code></td>
					<td><strong>group add</strong>，创建一个新用户组</td>
			</tr>
			<tr>
					<td><code>groupmod &lt;group_name&gt;</code></td>
					<td><strong>group modify</strong>，修改用户组的属性</td>
			</tr>
			<tr>
					<td><code>groupdel &lt;group_name&gt;</code></td>
					<td><strong>group delete</strong>，删除一个用户组</td>
			</tr>
			<tr>
					<td><code>gpasswd &lt;group_name&gt;</code></td>
					<td><strong>group password</strong>，修改用户组密码</td>
			</tr>
	</tbody>
</table>
<blockquote>
<p><code>groupmod</code> 一般用于改用户组名和 GID
用户组密码用的很少了，有<code>newgrp</code>命令可以临时将用户添加入该组，此时需要输入组密码。</p>
</blockquote>
<img src="../../SRE/groupadd.png" alt="groupadd">
<p>现在，我们将尝试把用户 <code>shivam</code> 添加到上面创建的用户组中。</p>
<img src="../../SRE/groups.png" alt="groups">
<p><strong>成为超级用户</strong></p>
<p><strong>在运行下面这些命令之前，请确保你已经按照上一节介绍的方法，使用 <code>passwd</code> 命令为用户 <code>shivam</code> 和用户 <code>root</code> 设置了密码。</strong></p>
<p><code>su</code>(switch user) 命令可以用于在 Linux 中切换用户。现在我们尝试切换到用户 <code>shivam</code>。</p>
<img src="../../SRE/su1.png" alt="su1">
<p>现在我们尝试打开 <code>/etc/shadow</code> 文件。</p>
<img src="../../SRE/su2.png" alt="su2">
<p>操作系统不允许用户 <code>shivam</code> 读取 <code>/etc/shadow</code> 文件的内容。这个文件在 Linux 中非常重要，用于存储用户密码相关的信息。只有 <code>root</code> 用户或具有超级用户权限的用户才能访问这个文件。</p>
<p><strong><code>sudo</code> 命令允许用户以 <code>root</code> 用户的安全权限来运行命令。</strong></p>
<p>请记住，<code>root</code> 用户拥有系统上的全部权限。</p>
<p>我们也可以使用 <code>su</code> 命令切换到 <code>root</code> 用户，然后再打开上面的文件，但这样做需要输入 <code>root</code> 用户的密码。</p>
<p>在大多数现代操作系统中，更常见也更推荐的另一种方式，是使用 <code>sudo</code>(superuser do/substitute user do) 命令来获得超级用户权限。采用这种方式时，用户通常需要输入自己的密码，并且需要属于拥有 <code>sudo</code> 权限的用户组。</p>
<p><strong>如何给其他用户提供超级用户权限？</strong></p>
<p>我们先使用 <code>su</code> 命令切换到 <code>root</code> 用户。需要注意的是，执行下面的命令时需要输入 <code>root</code> 用户的密码。</p>
<img src="../../SRE/su3.png" alt="su3">
<p>如果你忘了给 <code>root</code> 用户设置密码，可以输入<code>exit</code></p>
<p>这样你就会返回之前的 <code>root</code> 用户环境。然后使用 <code>passwd</code> 命令设置密码。</p>
<p><strong><code>/etc/sudoers</code> 文件用于保存哪些用户可以调用 <code>sudo</code>，以及相关的权限规则。</strong></p>
<p>在 Red Hat 系列操作系统中，这个文件所依赖的 <code>sudo</code> 工具在某些精简环境里可能默认没有安装，因此需要先安装 <code>sudo</code>。</p>
<p>尝试打开系统中的 <code>/etc/sudoers</code> 文件。这个文件包含很多信息，用来保存用户运行 <code>sudo</code> 命令时必须遵循的规则。</p>
<p>例如，<code>root</code> 用户被允许在任何地方运行任何命令。</p>
<img src="../../SRE/root.png" alt="root">
<p>一种比较简单的给用户提供 <code>root</code> 权限的方法，是把用户加入一个被允许执行所有命令的用户组。</p>
<p>在 Red Hat Linux 中，<code>wheel</code> 就是这样一个常见的特权用户组。</p>
<img src="../../SRE/wheel.png" alt="wheel">
<blockquote>
<p>这里的 <code>%wheel ALL=(ALL) ALL</code> 的意思是 <code>wheel</code> 这个组中的用户可以使用 <code>sudo</code> 命令临时用任何用户身份做任何事。所以 <code>sudo</code> 也可以被理解成 substitute user do —— 用另一个用户身份代替当前用户去执行命令。不加 <code>-u</code> 参数时，默认使用 <code>root</code> 用户。</p>
</blockquote>
<p>现在我们把用户 <code>shivam</code> 加入这个组，这样它也可以获得 <code>sudo</code> 权限。</p>
<img src="../../SRE/sudo.png" alt="sudo">
<p>现在我们切换回用户 <code>shivam</code>，再次尝试访问 <code>/etc/shadow</code> 文件。</p>
<img src="../../SRE/sudo2.png" alt="sudo2">
<p>由于这个文件只能由具有相应高权限的用户访问，因此我们需要在命令前加上 <code>sudo</code>。</p>
<p>我们之前已经把用户 <code>shivam</code> 加入了 <code>wheel</code> 组，因此它已经获得了使用 <code>sudo</code> 的权限。</p>
<blockquote>
<p><code>sudo</code> 的验证逻辑是先判断当前用户是不是本人，然后再按照权限组规则开发对应替代用户的权限，所以 <code>sudo</code> 时输入的是当前用户的密码。而 <code>su</code> 则是输入目标用户的密码。</p>
</blockquote>
]]></content></item></channel></rss>