【曹大golang实战营年度压轴课】：从零手写企业级RPC框架，含完整源码+压测报告+线上回滚SOP

第一章：课程导览与企业级RPC框架全景认知

现代分布式系统已从单体架构演进为以服务为核心、跨语言跨网络协同的复杂生态，而远程过程调用（RPC）正是支撑这一演进的底层通信基石。本章将带您跳出“仅会调用接口”的表层认知，系统性地构建对企业级RPC框架的全景理解——它不仅是序列化与网络传输的组合，更是融合服务发现、负载均衡、熔断降级、链路追踪、安全认证与可观测性的综合基础设施。

RPC的本质与演进脉络

RPC的核心目标是让远程调用像本地方法调用一样自然，其演进路径清晰呈现技术收敛趋势：从早期基于Socket手动编解码（如原始RMI），到IDL驱动的标准化框架（Thrift/Protocol Buffers），再到云原生时代强调治理能力的平台化方案（gRPC + Service Mesh、Apache Dubbo 3.x）。关键差异在于：传统RPC聚焦“通”，而企业级RPC必须保障“稳、准、全”。

主流框架能力对比

框架	序列化协议	传输层	内置服务发现	流控/熔断	跨语言支持
gRPC	Protobuf	HTTP/2	否（需集成）	支持	✅（10+）
Apache Dubbo	多协议可选	Netty	✅（ZK/Nacos）	✅	✅（Java为主，Go/Node SDK渐进）
Spring Cloud OpenFeign	JSON/RPC	HTTP/1.1	✅（Eureka/Nacos）	依赖Resilience4j	✅（JVM系）

快速体验gRPC服务端骨架

以下命令可在5分钟内启动一个最小可用gRPC服务（需预装protoc与grpc-java插件）：

# 1. 定义接口（hello.proto）
syntax = "proto3";
package example;
service Greeter { rpc SayHello (HelloRequest) returns (HelloReply); }
message HelloRequest { string name = 1; }
message HelloReply { string message = 1; }

# 2. 生成Java代码（自动包含ServerBuilder、Stub等）
protoc --java_out=. --grpc-java_out=. hello.proto

# 3. 编译并运行（无需Spring Boot容器，纯Netty嵌入式启动）
mvn compile exec:java -Dexec.mainClass="example.HelloServer"

该流程揭示企业级RPC的起点：契约先行（IDL）、代码生成、轻量运行时——所有高级治理能力均在此坚实底座上叠加演进。

第二章：RPC核心协议与通信层手写实现

2.1 RPC调用模型解析：同步/异步/流式语义与序列化选型对比

RPC 调用模型本质是远程过程抽象的语义契约，其核心差异体现在控制流与数据流的耦合程度。

同步 vs 异步语义

• 同步调用：线程阻塞等待响应，编程模型简单但吞吐受限
• 异步调用：返回 CompletableFuture 或 Promise，解耦执行与结果消费
• 流式调用：双向持续数据帧（如 gRPC Streaming），适用于实时日志、IoT 传感数据

序列化选型关键维度

特性	Protobuf	JSON	Apache Avro
二进制体积	极小 ✅	大 ❌	小 ✅
向后兼容性	强（字段编号）	弱（字段名依赖）	强（Schema Registry）
跨语言支持	广泛 ✅	通用 ✅	良好 ✅

// gRPC 异步流式客户端示例
StreamObserver<SearchRequest> requestObserver = 
    stub.search(SearchResponse.newBuilder(), response -> {
        System.out.println("Received: " + response.getResultCount());
    });
requestObserver.onNext(SearchRequest.newBuilder()
    .setQuery("microservices").build()); // 发送请求帧
requestObserver.onCompleted(); // 结束请求流

该代码构建了单向流式请求，onNext() 触发帧发送，onCompleted() 标记请求终结；回调函数在任意时刻接收服务端推送的多个 SearchResponse 帧，体现“请求-多响应”流式语义。

graph TD
    A[Client] -->|同步: 等待单响应| B[Server]
    A -->|异步: 提交后立即返回| C[Executor]
    C --> D[Server]
    A -->|流式: 建立长连接| E[Server Stream]
    E -->|连续推送帧| A

2.2 基于Go net.Conn的高性能TCP连接池与粘包拆包实战

连接池核心设计原则

• 复用 net.Conn 避免频繁建连开销
• 设置空闲连接最大数、超时驱逐策略
• 支持按业务标签（如服务名）隔离连接池

粘包问题本质与解法

TCP 是字节流协议，需在应用层定义边界：

• 固定长度帧（简单但不灵活）
• 长度前缀（推荐：4 字节大端整型）
• 分隔符（如 \n，仅适用于文本场景）

关键代码：带长度前缀的 Decoder

type LengthPrefixedDecoder struct {
    buf    *bytes.Buffer
    header [4]byte
}

func (d *LengthPrefixedDecoder) Decode(conn net.Conn) ([]byte, error) {
    // 先读取4字节长度头
    if _, err := io.ReadFull(conn, d.header[:]); err != nil {
        return nil, err
    }
    msgLen := binary.BigEndian.Uint32(d.header[:])
    if msgLen > 1024*1024 { // 防止恶意超长包
        return nil, errors.New("message too large")
    }
    // 再读取指定长度消息体
    data := make([]byte, msgLen)
    if _, err := io.ReadFull(conn, data); err != nil {
        return nil, err
    }
    return data, nil
}

逻辑分析：io.ReadFull 保证读满指定字节数；binary.BigEndian.Uint32 解析网络字节序长度；1MB 上限防止内存耗尽。参数 conn 必须是阻塞模式或已配置合理 ReadDeadline。

性能对比（单位：QPS）

方案	并发100连接	并发1000连接
无连接池+无解包	12,400	8,900
连接池+长度前缀解包	41,600	39,200

graph TD
    A[Client Write] --> B[OS TCP Stack]
    B --> C[Server Read Buffer]
    C --> D{是否收到完整 header?}
    D -->|否| C
    D -->|是| E[解析 length]
    E --> F{是否收到 length 字节?}
    F -->|否| C
    F -->|是| G[交付完整 message]

2.3 自研二进制协议编解码器：支持Schema演进的MessagePack+TLV混合设计

传统二进制协议在字段增删时易引发兼容性断裂。我们融合 MessagePack 的紧凑序列化能力与 TLV（Tag-Length-Value）的动态字段寻址特性，构建可演进的混合编码模型。

核心设计优势

• 字段独立编码：每个字段携带 type tag + length prefix，解码器跳过未知 tag
• 兼容性保障：新增字段默认设为 optional，旧客户端忽略；删除字段仅需服务端逻辑降级
• 性能平衡：MessagePack 处理基础类型（int/str/bool），TLV 封装嵌套结构与扩展字段

编码结构示意

# 示例：User 消息编码片段（Python 伪代码）
def encode_user(user: User) -> bytes:
    buf = bytearray()
    buf.extend(pack_tagged_field(0x01, "name", msgpack.packb(user.name)))   # tag=0x01, str
    buf.extend(pack_tagged_field(0x02, "age", msgpack.packb(user.age)))     # tag=0x02, int
    buf.extend(pack_tagged_field(0x0A, "metadata", msgpack.packb(user.meta))) # tag=0x0A, extensible
    return bytes(buf)

pack_tagged_field(tag, _, payload) 将 tag（1字节）、len(payload)（变长整数，≤4字节）、payload 三段拼接。tag 全局唯一且语义稳定，是 Schema 演进锚点。

字段	类型	说明
tag	uint8	字段标识符，由 IDL 预分配，永不复用
length	varint	Payload 字节数，支持 0–2³⁰ 范围
payload	binary	MessagePack 编码的原始值

graph TD
    A[原始对象] --> B[字段遍历]
    B --> C{tag 是否注册？}
    C -->|是| D[MsgPack 序列化]
    C -->|否| E[跳过，记录 warn]
    D --> F[TLV 封装]
    F --> G[字节流输出]

2.4 跨语言兼容性设计：IDL定义、代码生成器与gRPC/Thrift协议对齐策略

跨语言服务通信的核心在于契约先行。IDL（Interface Definition Language）作为唯一真相源，需兼顾表达力与可映射性：

// service.proto —— gRPC兼容的IDL定义
syntax = "proto3";
package example.v1;

message UserProfile {
  string user_id = 1;        // 必填标识，对应Java String / Go string / Python str
  int32 age = 2;             // 显式类型，规避int/int32语义歧义
  repeated string tags = 3;  // 通用列表结构，各语言自动生成对应容器类型
}

service UserService {
  rpc GetProfile (UserProfileRequest) returns (UserProfile);
}

该定义经protoc+插件生成多语言桩代码，确保字段序号、默认值、空值处理逻辑一致。Thrift则需通过thrift --gen配合proto2thrift转换工具对齐字段语义。

协议对齐关键维度

维度	gRPC（Proto3）	Thrift（IDL v1）	对齐策略
空值语义	无显式null，用wrapper	支持optional/required	统一用optional+显式包装类型
枚举序列化	整数映射	符号名+整数双模式	强制启用enum_as_int=true
流式传输	Server/Client streaming	Oneway + callback模拟	优先采用gRPC原生streaming

代码生成器协同流程

graph TD
  A[统一IDL源文件] --> B{生成器调度中心}
  B --> C[protoc --go_out=.]
  B --> D[thrift --gen py]
  B --> E[custom --gen rust]
  C & D & E --> F[校验字段哈希一致性]

生成后自动执行跨语言字段签名比对（如sha256(user_id + age)），阻断IDL变更未同步导致的序列化错位。

2.5 连接管理与心跳保活：优雅断连检测、重连退避算法与连接状态机实现

心跳机制设计

客户端每 30s 发送 PING 帧，服务端超时 45s 未收则标记连接异常。心跳间隔需小于 TCP Keepalive 默认值（7200s），避免被中间设备静默断连。

优雅断连检测

• 主动关闭前发送 CLOSE 帧并等待 ACK
• 网络闪断时依赖 SO_KEEPALIVE + 应用层心跳 双校验
• 断连后立即触发状态机迁移至 DISCONNECTED

指数退避重连

def next_backoff(attempt: int) -> float:
    base = 1.0
    cap = 60.0
    return min(base * (2 ** attempt), cap)  # 单位：秒

逻辑分析：attempt 从 0 开始计数；第 0 次重试延迟 1s，第 6 次达上限 60s，防止雪崩重连。参数 cap 可热更新。

连接状态机（简化）

graph TD
    IDLE --> CONNECTING
    CONNECTING --> CONNECTED
    CONNECTED --> DISCONNECTED
    DISCONNECTED --> CONNECTING

状态	允许触发事件	自动迁移条件
CONNECTING	connect(), timeout	成功 → CONNECTED
CONNECTED	heartbeat(), close	心跳失败 → DISCONNECTED

第三章：服务治理能力内核构建

3.1 注册中心集成与本地缓存一致性：基于etcd的Watch机制与LRU+TTL双维度缓存

数据同步机制

etcd Watch 机制实现服务变更的实时推送，避免轮询开销。客户端建立长连接监听 /services/ 前缀路径，事件流自动触发本地缓存更新。

watchChan := client.Watch(ctx, "/services/", clientv3.WithPrefix())
for watchResp := range watchChan {
    for _, ev := range watchResp.Events {
        handleServiceEvent(ev) // 解析 PUT/DELETE 事件，更新内存映射
    }
}

WithPrefix() 确保监听所有服务实例；ev.Type 区分新增（PUT）与下线（DELETE）；ev.Kv.Value 含序列化服务元数据，需反序列化后校验有效性。

缓存策略设计

采用 LRU + TTL 双控：LRU 控制内存占用上限，TTL 防止 stale data。当 etcd 连接中断时，缓存仍可降级服务发现。

维度	作用	典型值
LRU 容量	限制最大条目数	10,000
TTL	单条记录最大存活时间	30s
刷新阈值	TTL 剩余	5s

一致性保障流程

graph TD
    A[etcd Watch 事件] --> B{事件类型}
    B -->|PUT| C[解析并写入LRU]
    B -->|DELETE| D[从LRU驱逐]
    C --> E[重置TTL计时器]
    D --> E

• 缓存写入时同时注册 TTL 定时器；
• LRU 驱逐仅发生在容量超限时，不干扰 TTL 过期逻辑；
• 每次服务查询均触发 TTL 检查与懒刷新。

3.2 负载均衡策略落地：加权轮询、最少连接数与响应时间感知动态权重算法实现

三种策略的适用场景对比

策略类型	适用场景	实时性要求	配置复杂度
加权轮询（WRR）	后端节点性能差异稳定	低	★☆☆
最少连接数（LC）	请求处理时长波动大（如文件上传）	中	★★☆
响应时间感知动态权重	高SLA敏感服务（如支付网关）	高	★★★

动态权重核心逻辑（Python伪代码）

def update_dynamic_weight(node, rtt_ms):
    # 基准RTT设为100ms，衰减因子α=0.8，最小权重为1
    base_rtt = 100.0
    alpha = 0.8
    node.weight = max(1, int(alpha * node.base_weight * base_rtt / max(rtt_ms, 1)))

逻辑分析：权重与实测RTT成反比，通过指数平滑抑制瞬时抖动；base_weight为运维预设静态基线值，max(rtt_ms, 1)避免除零；max(1, ...)保障节点永不被剔除。

策略协同调度流程

graph TD
    A[接收新请求] --> B{是否启用RTT监控？}
    B -- 是 --> C[采集最近3次RTT均值]
    B -- 否 --> D[降级为LC策略]
    C --> E[重算动态权重]
    E --> F[按WRR+权重排序选节点]

3.3 熔断降级与限流控制：基于滑动窗口的令牌桶限流器与Hystrix风格熔断器手写

核心设计思想

限流与熔断需协同工作：限流拦截过载请求，熔断器在下游故障时快速失败，避免雪崩。

滑动窗口令牌桶实现（Java片段）

public class SlidingWindowTokenBucket {
    private final long capacity;      // 桶容量
    private final long refillRateMs;  // 每毫秒补充令牌数
    private long lastRefillTime;
    private long tokens;

    public boolean tryAcquire() {
        long now = System.currentTimeMillis();
        long elapsed = now - lastRefillTime;
        tokens = Math.min(capacity, tokens + elapsed * refillRateMs);
        if (tokens >= 1) {
            tokens--;
            lastRefillTime = now;
            return true;
        }
        return false;
    }
}

逻辑分析：tokens 动态补给依赖时间差与速率，Math.min 防溢出；lastRefillTime 确保单调递增，避免时钟回拨导致误放行。

Hystrix风格熔断状态机

graph TD
    CLOSED -->|失败率 > 50% 且请求数 ≥ 20| OPEN
    OPEN -->|超时后进入半开| HALF_OPEN
    HALF_OPEN -->|成功则CLOSED| CLOSED
    HALF_OPEN -->|失败则OPEN| OPEN

关键参数对照表

参数	限流器	熔断器
触发条件	QPS超阈值	错误率+最小请求数
响应策略	拒绝新请求	快速失败/降级兜底
状态持久化	内存滑动窗口	环形缓冲区统计失败率

第四章：生产级高可用保障体系搭建

4.1 全链路可观测性接入：OpenTelemetry标准Trace注入、Metrics暴露与Logging结构化输出

统一信号采集层设计

OpenTelemetry SDK 作为语言无关的观测信号采集中枢，通过 TracerProvider、MeterProvider 和 LoggerProvider 三者协同，实现 Trace、Metrics、Logs 的标准化注入与导出。

Trace 自动注入示例（Go）

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/sdk/trace"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
)

func initTracer() {
    exporter, _ := otlptracehttp.New(
        otlptracehttp.WithEndpoint("localhost:4318"),
        otlptracehttp.WithHeaders(map[string]string{"Authorization": "Bearer token"}),
    )
    tp := trace.NewTracerProvider(trace.WithBatcher(exporter))
    otel.SetTracerProvider(tp)
}

逻辑分析：otlptracehttp 将 Span 数据以 OTLP/HTTP 协议推送至后端（如 Jaeger 或 Tempo）；WithHeaders 支持鉴权透传；WithBatcher 启用批量发送以降低网络开销。

Metrics 与 Logs 对齐策略

信号类型	标准化字段	用途
Trace	trace_id, span_id	链路追踪上下文锚点
Metrics	service.name, http.status_code	维度标签驱动聚合分析
Logs	trace_id, span_id, severity_text	实现日志与调用链精准关联

数据同步机制

graph TD
    A[应用代码] --> B[OTel SDK]
    B --> C{信号分流}
    C --> D[Trace Exporter]
    C --> E[Metrics Exporter]
    C --> F[Logs Exporter]
    D & E & F --> G[OTLP Collector]
    G --> H[(后端存储：Tempo/Grafana/Mimir)]

4.2 压测方案设计与性能调优：wrk+Prometheus+Grafana压测闭环与GC/锁/协程瓶颈定位

压测闭环架构设计

graph TD
    A[wrk 发起 HTTP 压测] --> B[应用暴露 /metrics]
    B --> C[Prometheus 定期抓取指标]
    C --> D[Grafana 可视化 QPS/延迟/GC/协程数]
    D --> E[火焰图+pprof 定位热点]

wrk 脚本示例（带动态连接复用）

wrk -t4 -c100 -d30s \
  -s ./scripts/latency.lua \         # 自定义延迟统计逻辑
  --latency \
  http://localhost:8080/api/items

-t4 启动4个线程模拟并发；-c100 维持100个长连接复用；--latency 启用毫秒级延迟直方图，避免平均值失真。

关键观测指标对比表

指标	健康阈值	异常信号
go_goroutines		> 2000 → 协程泄漏风险
go_gc_duration_seconds	P99	频繁 > 50ms → GC压力大
http_server_req_duration_seconds_sum	P95	突增 → 锁竞争或DB慢查询

pprof 协程阻塞分析命令

# 实时抓取阻塞协程栈
curl "http://localhost:6060/debug/pprof/goroutine?debug=2" > goroutines.txt

该命令输出所有 goroutine 的当前状态（running/blocked/waiting），重点关注 semacquire（锁等待）和 netpoll（IO阻塞）调用链。

4.3 线上回滚SOP标准化：灰度发布检查清单、配置快照比对、事务性回滚脚本与K8s Rollback原子操作

灰度发布健康检查清单（Checklist）

• ✅ 核心API成功率 ≥99.5%（Prometheus rate(http_requests_total{job="api",status=~"5.."}[5m]) / rate(http_requests_total{job="api"}[5m])）
• ✅ 新旧Pod CPU/内存差异 kubectl top pods -l app=svc –containers）
• ✅ 日志无新增ERROR级别异常关键词（grep -E "(panic|timeout|deadlock)" /var/log/app/*.log）

配置快照比对机制

使用GitOps方式管理配置，每次发布前自动保存快照：

# 生成当前ConfigMap快照（含时间戳与commit hash）
kubectl get cm app-config -o yaml \
  | yq e '.metadata.annotations["snapshot/timestamp"] = env(STRFTIME) | .metadata.annotations["snapshot/commit"] = env(GIT_COMMIT)' - \
  > snapshots/cm-app-config-$(date +%Y%m%d-%H%M%S).yaml

逻辑说明：yq注入双注解字段，STRFTIME和GIT_COMMIT由CI环境注入，确保快照可溯源；输出文件名含毫秒级时间戳，避免并发覆盖。

K8s Rollback原子操作流程

graph TD
  A[触发回滚] --> B{验证新旧Revision一致性}
  B -->|通过| C[执行kubectl rollout undo deployment/app --to-revision=X]
  B -->|失败| D[中止并告警]
  C --> E[等待Ready Pods ≥95%]
  E --> F[运行事务性回滚脚本]

事务性回滚脚本核心逻辑

步骤	操作	原子性保障
1	数据库schema回退（Flyway repair+rollback）	依赖事务日志校验
2	消息队列DLQ重投过滤	基于x-original-timestamp丢弃过期消息
3	缓存预热（Redis Pipeline写入热点Key）	使用EVALSHA防重复执行

4.4 故障注入与混沌工程实践：基于go-fuzz和chaos-mesh模拟网络分区、节点宕机与时钟偏移场景

混沌工程需在受控前提下验证系统韧性。chaos-mesh 提供声明式故障编排能力，而 go-fuzz 用于协议层模糊测试，二者协同覆盖协议鲁棒性与基础设施级容错。

网络分区模拟

# network-partition.yaml
apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: partition-a-b
spec:
  action: partition
  mode: one
  selector:
    namespaces: ["default"]
    pods: {app: "service-a"} # 目标Pod标签
  direction: to
  target:
    selector: {app: "service-b"}

该配置使 service-a 无法访问 service-b 的入向流量，模拟跨AZ网络断裂。direction: to 表示阻断目标接收方向，符合典型分区语义。

时钟偏移注入

故障类型	工具	偏移范围	持续时间	触发方式
软件时钟漂移	chronosync	±500ms	30s	Kubernetes Job
硬件时钟偏移	chaos-mesh TimeChaos	±2s	10s	CRD 声明

节点宕机编排逻辑

graph TD
  A[启动 ChaosExperiment] --> B{选择故障类型}
  B -->|NetworkPartition| C[注入iptables规则]
  B -->|PodKill| D[执行kubectl delete pod]
  B -->|TimeChaos| E[调用clock_settime syscall]
  C & D & E --> F[观测etcd leader切换/raft日志同步延迟]

go-fuzz 则针对 gRPC 接口定义生成非法 timestamp 字段，触发服务端时序校验逻辑分支，暴露未处理的 NTP 同步异常路径。

第五章：结课项目交付与架构演进路线图

项目交付清单与质量门禁

结课项目采用 GitOps 流水线实现自动化交付，最终交付物包括：

• 可运行的 Helm Chart（含 values-prod.yaml 与 namespace-scoped RBAC 配置）
• OpenAPI 3.0 文档（托管于 Swagger UI，自动同步至 docs/ 目录）
• Terraform 模块封装的云资源定义（AWS EKS + RDS + S3，支持多区域部署）
• 基于 Prometheus + Grafana 的可观测性套件（预置 12 个核心 SLO 看板，如 API 错误率 所有交付物均通过 CI 阶段的 4 层质量门禁：静态代码扫描（SonarQube）、契约测试（Pact）、混沌工程注入（Chaos Mesh 模拟节点宕机）、生产环境蓝绿验证（Flagger 自动回滚阈值设为错误率 >1% 持续 60s）

架构演进三阶段实施路径

阶段	时间窗口	关键动作	技术验证指标
稳定期（0–3月）	2024 Q3	完成单体服务容器化改造，接入 Istio 1.21 服务网格，剥离数据库连接池至 Sidecar	请求成功率 ≥99.95%，Mesh 延迟增量 ≤8ms
能力解耦期（4–9月）	2024 Q4–2025 Q1	按业务域拆分订单、库存、支付子系统，引入 Kafka 3.6 实现事件驱动通信，落地 Saga 分布式事务	订单履约链路端到端耗时下降 42%，跨服务调用失败率降至 0.03%
智能治理期（10–18月）	2025 Q2–Q4	部署 OpenTelemetry Collector 统一采集遥测数据，训练轻量级异常检测模型（XGBoost+LSTM），实现故障自愈策略编排	MTTR 从 18min 缩短至 92s，预测性告警准确率达 87.3%

生产环境灰度发布策略

采用基于流量特征的渐进式发布：首阶段仅对 user_region=cn-east 且 app_version>=2.3.0 的请求放行新版本；第二阶段叠加 ab_test_group=blue 标签过滤；第三阶段按 5%/15%/30%/100% 四级比例滚动。每次升级均触发自动比对：

# canary-analysis.yaml 示例
analysis:
  metrics:
    - name: error-rate
      threshold: "0.005"
      interval: "30s"
      count: 3
    - name: latency-p95
      threshold: "350ms"
      interval: "30s"

技术债偿还机制

建立架构健康度仪表盘，每日扫描以下维度并生成修复建议：

• 数据库反范式设计项（如冗余字段更新不一致）
• 服务间循环依赖（通过 Jaeger 依赖图谱识别）
• 过期 TLS 证书（自动匹配 ACM 证书生命周期）
• Kubernetes Pod 中未配置 resource requests/limits 的容器（覆盖率目标：100%）

演进风险控制矩阵

使用 Mermaid 绘制关键路径风险图谱：

graph TD
    A[单体服务容器化] --> B[服务网格接入]
    B --> C[领域事件总线建设]
    C --> D[无状态计算单元弹性伸缩]
    D --> E[边缘 AI 推理节点纳管]
    style A fill:#4CAF50,stroke:#388E3C
    style B fill:#2196F3,stroke:#0D47A1
    style C fill:#FF9800,stroke:#E65100
    style D fill:#9C27B0,stroke:#4A148C
    style E fill:#00BCD4,stroke:#006064