第一章：Go语言创造的项目
Go语言自2009年开源以来，凭借其简洁语法、内置并发模型和高效编译能力，催生了一批具有广泛影响力的开源项目与生产级系统。这些项目不仅验证了Go在云原生时代的工程价值，也重塑了现代基础设施的构建范式。
主流基础设施项目
以下为由Go语言主导开发并被全球大规模采用的核心项目：
- Docker：容器运行时与镜像管理工具，其核心
containerd组件完全用Go实现，依赖net/http与os/exec构建轻量API服务； - Kubernetes：集群编排系统，控制平面组件（如
kube-apiserver、etcd客户端）大量使用Go的goroutine与channel处理高并发请求； - Prometheus：监控告警系统，其服务端通过
http.Handler暴露指标端点，并利用sync.Map安全存储时间序列数据。
快速体验一个Go项目：搭建简易HTTP服务
执行以下命令初始化并运行一个最小化Web服务：
# 创建项目目录并初始化模块
mkdir hello-web && cd hello-web
go mod init hello-web
# 编写main.go
cat > main.go << 'EOF'
package main
import (
"fmt"
"log"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello from Go! Path: %s", r.URL.Path)
}
func main() {
http.HandleFunc("/", handler)
log.Println("Server starting on :8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}
EOF
# 运行服务
go run main.go启动后访问 http://localhost:8080/test 将返回带路径的响应字符串。该示例展示了Go标准库net/http的零依赖服务能力——无需第三方框架即可构建生产就绪的HTTP服务。
项目共性特征
| 特性 | 表现 |
|---|---|
| 构建效率 | 单二进制分发，go build生成静态链接可执行文件 |
| 并发模型 | 基于goroutine+channel的CSP范式替代传统线程池 |
| 生态协同 | 普遍采用go.mod统一依赖管理，golang.org/x/提供官方扩展库 |
这些项目共同印证：Go并非仅适用于“小工具”，而是支撑现代分布式系统底层骨架的关键语言。
第二章：高性能网络中间件：从理论模型到亿级QPS实战调优
2.1 Go net/http 与 fasthttp 的并发模型对比与选型依据
核心并发模型差异
net/http 基于 goroutine-per-connection 模型：每个连接启动独立 goroutine 处理请求，依赖 Go 运行时调度器管理；fasthttp 采用 goroutine-pool + state machine 模式，复用 goroutine 并避免堆分配，显著降低 GC 压力。
性能关键对比
| 维度 | net/http | fasthttp |
|---|---|---|
| 内存分配/req | ~3–5 KB（含 http.Request/Response） |
|
| 并发吞吐（万 QPS） | ~15–25（高负载下调度开销上升） | ~40–70（实测 4c8g 环境） |
// fasthttp 零拷贝请求处理示例
func handler(ctx *fasthttp.RequestCtx) {
// ctx.URI().Path() 直接指向原始字节切片，无内存拷贝
path := ctx.Path()
ctx.SetStatusCode(200)
ctx.SetBodyString("OK")
}此 handler 避免
net/http中r.URL.Path的字符串转换与内存分配；ctx全生命周期复用，path是原始[]byte子切片，不触发 GC。
选型决策树
- ✅ 优先选
fasthttp：API 网关、高吞吐内部服务、资源受限场景 - ✅ 优先选
net/http：需标准中间件生态（如 OpenTelemetry、Gin）、HTTP/2/HTTPS 兼容性、调试友好性
graph TD
A[新项目接入] --> B{是否强依赖标准库生态？}
B -->|是| C[net/http]
B -->|否| D{QPS > 30k 且延迟敏感？}
D -->|是| E[fasthttp]
D -->|否| C2.2 零拷贝序列化与内存池在高吞吐场景下的工程落地
核心挑战：CPU 与内存带宽瓶颈
在百万级 TPS 的实时风控系统中，传统 JSON 序列化+堆内存分配导致 42% CPU 耗于 memcpy，GC Pause 高达 8–12ms。
零拷贝序列化实践
使用 FlatBuffers 替代 Protobuf，直接操作内存映射区：
// 构建无拷贝二进制消息（无需 runtime 分配）
flatbuffers::FlatBufferBuilder fbb(1024);
auto msg = CreateRiskEvent(fbb, /*...*/);
fbb.Finish(msg);
const uint8_t* buf = fbb.GetBufferPointer(); // 直接指向连续内存块
FlatBufferBuilder预分配固定缓冲区，Finish()仅重排字节序并返回只读指针，规避对象深拷贝与中间 buffer。
内存池协同优化
采用对象池 + slab 分配器统一管理 FlatBuffer 缓冲区生命周期：
| 池类型 | 分配粒度 | 复用率 | GC 影响 |
|---|---|---|---|
| 4KB slab 池 | 4096B | 99.3% | 无 |
| 64KB arena 池 | 动态切片 | 91.7% | 无 |
数据同步机制
graph TD
A[Producer 线程] -->|mmap 写入| B[共享内存 ring buffer]
B --> C{Consumer 批处理}
C -->|零拷贝取 ptr| D[FlatBuffer::GetRoot<RiskEvent>]
D --> E[业务逻辑直读字段]关键收益：端到端延迟从 14.2ms 降至 2.3ms，吞吐提升 3.8×。
2.3 连接复用、连接池与TLS会话复用的深度优化实践
HTTP/1.1 默认启用 Connection: keep-alive，但单连接串行阻塞；HTTP/2 天然支持多路复用，大幅提升并发效率。
连接池关键参数调优
maxIdleTime: 空闲连接最大存活时间（推荐 5–30s）maxLifeTime: 连接总生命周期（避免长时连接状态漂移）evictionInterval: 驱逐检查周期（需 ≤maxIdleTime）
TLS会话复用双机制
// Java SSLEngine 启用会话缓存
SSLContext context = SSLContext.getInstance("TLSv1.3");
context.init(keyManager, trustManagers, new SecureRandom());
SSLParameters params = new SSLParameters();
params.setUseSessionTickets(true); // 启用Session Ticket（优于Session ID）
params.setSessionCacheSize(1024);
sslEngine.setSSLParameters(params);逻辑分析：setUseSessionTickets(true) 启用无状态服务端会话恢复，避免全局会话存储瓶颈；sessionCacheSize 控制本地缓存容量，过大会增加GC压力。
| 机制 | 恢复延迟 | 服务端状态 | 适用场景 |
|---|---|---|---|
| Session ID | ~1 RTT | 有状态 | 小规模集群 |
| Session Ticket | ~0 RTT | 无状态 | 多实例横向扩展 |
graph TD A[Client Hello] –> B{Server supports Session Ticket?} B –>|Yes| C[Send encrypted ticket in Server Hello] B –>|No| D[Fallback to Session ID] C –> E[Subsequent Client Hello with ticket] E –> F[Resume handshake in 0-RTT]
2.4 基于 eBPF + Go 的流量观测与动态限流系统构建
核心架构设计
系统采用双层协同模型：eBPF 程序在内核态实时采集连接级流量指标（如 tcp_send_bytes、conn_time_us），Go 控制平面通过 libbpf-go 加载并轮询 map 数据，触发自适应限流决策。
数据同步机制
// 初始化 perf event ring buffer，接收 eBPF 发送的观测事件
rb, err := ebpf.NewRingBuffer("events", obj.ProgramMaps.events, func(e *Event) {
if e.RttUs > 50000 { // 毫秒级 RTT 异常阈值
throttleIP(e.SrcIP, 100*1024) // 限流至 100KB/s
}
})该代码监听 eBPF perf_event_output 事件流；Event 结构由 BPF CO-RE 自动适配内核版本；throttleIP 调用 tc qdisc 动态注入 HTB 规则。
限流策略映射表
| 策略类型 | 触发条件 | 执行动作 | 生效延迟 |
|---|---|---|---|
| 突增抑制 | QPS ≥ 500/s | 令牌桶速率降至 30% | |
| 长尾阻断 | P99 RTT > 200ms | 丢弃目标 IP 新建连接 |
流量调控流程
graph TD
A[eBPF socket filter] --> B[统计 per-IP 连接数/字节]
B --> C[perf buffer 推送事件]
C --> D[Go 读取 RingBuffer]
D --> E{RTT/P99 > 阈值?}
E -->|是| F[调用 netlink 更新 tc class]
E -->|否| G[更新 Prometheus metrics]2.5 百万级长连接管理：goroutine 调度器与 GC 协同压测调参
百万级长连接场景下，goroutine 泄漏与 GC 压力常呈正相关。需协同调优 GOMAXPROCS、GOGC 及 runtime/debug.SetGCPercent。
关键参数协同策略
GOMAXPROCS=32：匹配物理核数，避免调度器争抢GOGC=20：降低 GC 频率，减少 STW 对连接心跳的影响- 启用
GODEBUG=mcsweep=1观察标记辅助线程行为
典型连接管理代码片段
func handleConn(c net.Conn) {
defer c.Close()
// 使用 sync.Pool 复用读写缓冲区
buf := bufferPool.Get().([]byte)
defer bufferPool.Put(buf[:0])
for {
n, err := c.Read(buf)
if err != nil { break }
// ……业务处理
}
}该模式将单连接 goroutine 生命周期与连接生命周期严格对齐，避免闭包捕获导致的 goroutine 持有；bufferPool 减少堆分配，降低 GC 扫描压力。
GC 与调度器协同压测指标对比
| 场景 | 平均延迟(ms) | GC Pause(us) | Goroutine 数量 |
|---|---|---|---|
| 默认参数 | 128 | 4200 | 1.3M |
| 调优后 | 41 | 680 | 980K |
graph TD
A[新连接接入] --> B{是否启用连接池？}
B -->|是| C[复用 goroutine + buffer]
B -->|否| D[新建 goroutine]
C --> E[GC 压力↓]
D --> F[堆分配↑ → GC 频率↑]第三章：分布式协调与服务发现：Go 实现的轻量级一致性基石
3.1 Raft 协议在 Go 中的精简实现与日志压缩策略
核心结构设计
采用 struct Node 封装节点状态，含 currentTerm、votedFor、log []LogEntry 等字段；日志条目定义为：
type LogEntry struct {
Term uint64 `json:"term"`
Index uint64 `json:"index"`
Command string `json:"command"`
}Term 保证时序一致性，Index 提供全局唯一偏移，Command 为序列化业务指令；该结构支持快速二分查找与截断。
日志压缩机制
- 触发条件：
len(log) > 1000 && committedIndex > snapshotIndex + 500 - 压缩方式：生成快照（Snapshot）并截断
log[0:committedIndex+1] - 快照元数据包含
lastIncludedIndex和lastIncludedTerm
| 组件 | 作用 |
|---|---|
| Snapshot | 持久化已提交状态 |
| log compaction | 减少重放开销与内存占用 |
数据同步流程
graph TD
A[Leader AppendEntries] --> B{Follower 日志冲突？}
B -->|是| C[回退 nextIndex 并重试]
B -->|否| D[追加新条目并更新 commitIndex]同步过程依赖 nextIndex 动态探测匹配点，避免全量日志传输。
3.2 基于 Watcher 机制的服务注册/发现低延迟同步实践
数据同步机制
Watcher 机制通过长连接监听服务节点变更事件（如 REGISTER/DEREGISTER），避免轮询开销，将平均同步延迟从秒级降至百毫秒内。
核心实现要点
- 客户端注册时携带唯一
instanceId与 TTL 心跳策略 - 服务端基于 etcd 的
Watch接口监听/services/{service-name}/前缀路径 - 变更事件触发增量推送，仅同步 diff 数据而非全量快照
# etcd watch 示例（客户端侧）
watcher = client.watch_prefix("/services/api-gateway/",
start_revision=last_rev + 1) # 避免漏事件
for event in watcher:
if event.type == "PUT":
update_service_cache(event.kv.key, json.loads(event.kv.value))
elif event.type == "DELETE":
remove_from_cache(event.kv.key)
start_revision确保事件不丢失；event.kv.value为 JSON 序列化的实例元数据（含 IP、port、tags）；update_service_cache执行本地路由表原子更新。
性能对比（ms，P95）
| 场景 | 轮询模式 | Watcher 模式 |
|---|---|---|
| 实例上线同步 | 1200 | 85 |
| 故障下线感知 | 2100 | 92 |
graph TD
A[服务实例心跳上报] --> B[etcd 存储 /services/x/xxx]
B --> C{Watcher 监听路径变更}
C -->|PUT/DELETE 事件| D[本地缓存增量更新]
D --> E[负载均衡器实时路由刷新]3.3 多租户隔离与元数据分片在超大规模集群中的演进路径
早期单体元数据服务（如集中式 etcd）在百万级租户场景下遭遇线性扩展瓶颈，催生了逻辑租户分组 + 物理分片路由的双层隔离模型。
元数据分片策略演进
- 阶段1：Hash 分片 —— 简单但易倾斜，租户 ID
hash % shard_count - 阶段2：Range + Tag 混合分片 —— 按租户业务标签（如 region、SLA 等级）预分配连续区间
- 阶段3：动态权重分片（v3+） —— 基于实时 QPS 与存储水位自动 rebalance
分片路由核心代码片段
// TenantRouter 负责将租户请求映射到对应元数据分片
func (r *TenantRouter) Route(tenantID string) string {
tag := metadata.GetTag(tenantID, "tier") // 如 "premium", "basic"
shardID := r.weightedPicker.Pick(tag) // 基于当前负载权重选择分片
return fmt.Sprintf("meta-shard-%s-%d", tag, shardID)
}逻辑分析：
GetTag提取租户业务维度标签；weightedPicker维护各分片的 CPU/IO 权重快照（每5s更新），避免冷热不均。参数tag决定路由域，shardID由一致性哈希环+权重因子联合计算得出。
各阶段能力对比
| 阶段 | 租户规模支持 | 隔离粒度 | 动态扩缩容 | 数据迁移开销 |
|---|---|---|---|---|
| Hash | ≤50K | 租户级 | ❌ | 高（全量 rehash） |
| Range+Tag | ≤500K | 标签组级 | ⚠️（需人工干预） | 中（仅移动区间） |
| 动态权重 | ≥2M | 租户+标签+负载三维 | ✅（自动） | 低（增量迁移） |
graph TD
A[租户请求] --> B{提取业务标签<br/>+实时负载快照}
B --> C[权重感知分片选择器]
C --> D[定位目标元数据分片]
D --> E[强一致性读写<br/>跨分片事务协调]第四章：云原生可观测性栈：Go 构建的全链路指标采集与分析体系
4.1 OpenTelemetry Go SDK 的零侵入埋点与上下文传播优化
零侵入埋点：基于 otelhttp 中间件的自动注入
无需修改业务逻辑，仅通过 HTTP 中间件即可完成 Span 创建与生命周期管理：
import "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
mux := http.NewServeMux()
mux.HandleFunc("/api/user", userHandler)
http.ListenAndServe(":8080", otelhttp.NewHandler(mux, "server"))
otelhttp.NewHandler自动注入trace.SpanContext到http.Request.Context()，并为每个请求创建server类型 Span；"server"作为 Span 名称前缀，便于服务端识别。中间件透明封装了StartSpan与End()调用，避免手动defer span.End()。
上下文传播：W3C TraceContext 协议兼容
OpenTelemetry Go 默认启用 traceparent 头解析与注入，支持跨进程链路透传：
| 传播机制 | 标准协议 | 自动启用 | 依赖注入方式 |
|---|---|---|---|
| HTTP Header | W3C TraceContext | ✅ | otelhttp.WithPropagators |
| gRPC Metadata | B3 / W3C | ✅（需配置 propagator） | otelgrpc.WithPropagators |
跨协程上下文继承优化
Go 的 context.WithValue() 在 goroutine 分叉时需显式传递，SDK 提供 trace.ContextWithSpan() 安全封装：
ctx := trace.ContextWithSpan(context.Background(), span)
go func() {
// 子协程自动继承父 Span 上下文
child := trace.SpanFromContext(ctx).Tracer().Start(ctx, "db-query")
defer child.End()
}()
trace.ContextWithSpan将 Span 绑定至context.Context，确保trace.SpanFromContext()在任意 goroutine 中可安全提取，规避context.TODO()或裸context.Background()导致的链路断裂。
4.2 高频指标聚合：基于 WAL + Ring Buffer 的时序数据写入引擎
为应对每秒百万级指标写入压力，该引擎融合预写日志（WAL）的持久性保障与环形缓冲区（Ring Buffer）的无锁高吞吐特性。
核心架构设计
- WAL 确保崩溃恢复：所有写入先追加到磁盘日志，再进入内存处理
- Ring Buffer 实现生产者-消费者解耦：固定大小、原子指针推进，避免 GC 与锁竞争
数据流示意
graph TD
A[Metrics Producer] --> B[Ring Buffer: Enqueue]
B --> C{Batch Aggregator}
C --> D[WAL Append]
D --> E[Immutable Time-Window Segment]Ring Buffer 写入示例（伪代码）
// 初始化容量为 8192 的无锁环形缓冲区
ring := NewRingBuffer(8192)
// 原子写入：CAS 更新 tail 指针
if ring.Enqueue(metric) {
// metric 包含 timestamp, name, value, labels
// size=64B/entry，支持 500K+ ops/sec 单核吞吐
}Enqueue 使用 atomic.CompareAndSwapUint64 实现无锁入队；缓冲区满时触发批处理落盘，避免阻塞采集线程。
| 组件 | 吞吐量（单核） | 持久性保障 | 延迟（P99） |
|---|---|---|---|
| 直接写磁盘 | ~20K ops/s | 强一致 | >10ms |
| Ring Buffer | >400K ops/s | WAL兜底 |
4.3 分布式追踪采样策略的动态配置与资源感知降采样实践
在高吞吐微服务场景中，全量追踪会引发可观测性“自损”——采集开销反向拖慢业务。动态采样需兼顾精度与轻量。
资源感知降采样决策流
graph TD
A[CPU > 85% 或 内存使用率 > 90%] --> B[触发降采样]
B --> C{请求关键性}
C -->|SLA敏感路径| D[保底10%采样]
C -->|非核心调用| E[降至0.1%]动态配置热加载示例
# sampling-config.yaml（通过Consul Watch实时拉取）
adaptive:
base_rate: 0.05 # 基础采样率
cpu_threshold: 0.85 # CPU阈值触发条件
memory_threshold: 0.90 # 内存阈值触发条件
critical_paths: ["/api/pay", "/auth/token"] # SLA敏感路径白名单该配置由Agent监听变更并毫秒级生效，base_rate作为兜底基准，critical_paths确保支付等链路不被过度降级。
采样率调节效果对比
| 场景 | QPS | 日均Span量 | 平均延迟增幅 |
|---|---|---|---|
| 全量采样 | 12k | 10.4亿 | +12.7% |
| 静态5%采样 | 12k | 5200万 | +1.3% |
| 资源感知动态采样 | 12k | 2800万 | +0.6% |
4.4 Prometheus Remote Write 协议的批量压缩与失败重试韧性设计
数据同步机制
Remote Write 采用 snappy 压缩 + 批量打包（默认 max_samples=1000）策略，降低网络开销并提升吞吐。每批次封装为 WriteRequest protobuf 消息：
message WriteRequest {
repeated TimeSeries timeseries = 1; // 已按 metric 标签哈希分片
optional uint64 timestamp = 2; // 批次级时间戳（非单点）
}
timeseries内部已预排序去重；timestamp仅用于调试，不参与服务端时序对齐逻辑。
失败重试策略
- 指数退避：初始 100ms，上限 30s，底数 2
- 重试限界：单批次最多 5 次，超限后丢弃并上报
remote_write_failed_samples_total - 队列保护：内存缓冲区达 80% 容量时自动降频（
queue_capacity × 0.8触发min_backoff）
压缩与重试协同设计
| 阶段 | 压缩时机 | 重试影响 |
|---|---|---|
| 缓冲期 | 不压缩 | 可安全丢弃旧批次 |
| 发送前 | Snappy 压缩 | 压缩后校验和绑定批次ID |
| 重试时 | 复用原压缩体 | 避免重复压缩开销 |
graph TD
A[采样数据入队] --> B{队列满/定时触发?}
B -->|是| C[分片→Snappy压缩→签名]
C --> D[HTTP POST /api/v1/write]
D --> E{HTTP 2xx?}
E -->|否| F[指数退避→重试]
E -->|是| G[ACK清除缓冲]
F --> C第五章：Go语言创造的项目
高性能微服务网关：Kratos Gateway
Kratos 是由百度开源的 Go 微服务框架，其配套网关组件已落地于国内多家金融机构的核心支付链路。该网关采用零拷贝内存池（sync.Pool + 自定义 bufio.Reader）优化 HTTP/1.1 请求解析，在 4 核 8G 容器环境下实测吞吐达 42,800 QPS（压测工具：wrk -t12 -c400 -d30s），延迟 P99 稳定在 18ms 以内。关键代码片段如下：
// request pool with pre-allocated buffers
var reqPool = sync.Pool{
New: func() interface{} {
return &http.Request{Header: make(http.Header)}
},
}分布式日志采集系统：Loki 的 Go 核心模块
Grafana Loki 的 promtail 组件完全基于 Go 编写，通过 fsnotify 实时监听文件变更，并利用 chunk 分片机制将日志按标签哈希写入对象存储。某电商大促期间，单集群日均处理 37TB 原生日志，内存占用稳定在 1.2GB（对比 Python 版本下降 68%）。其标签路由逻辑依赖 prometheus/common/model.LabelSet 结构体，确保多租户隔离。
云原生数据库代理：TiDB Dashboard 后端
TiDB 5.0+ 内置的 Web 控制台后端全部使用 Go 开发，集成 Gin 框架与 Prometheus 客户端库。它直接调用 TiKV 的 gRPC 接口获取 Region 状态，并通过 WebSocket 实时推送慢查询分析结果。以下为真实部署中的资源监控指标表：
| 指标项 | 数值（单实例） | 采集周期 |
|---|---|---|
| 内存峰值 | 312 MB | 15s |
| 并发连接数 | 2,147 | 实时 |
| gRPC 调用成功率 | 99.997% | 1m |
| WebSocket 消息延迟 | P95 |
容器镜像安全扫描器：Trivy 的 Go 实现优势
Aqua Security 开发的 Trivy 使用 Go 原生 archive/tar 和 image/draw 包解析容器镜像层，无需依赖外部二进制工具。其 CVE 数据库同步模块采用 goroutines 并发拉取 NVD、GitHub Advisory 多源数据，全量更新耗时从 Python 版本的 142 秒压缩至 23 秒。核心调度逻辑使用 errgroup.Group 控制并发上限：
g, _ := errgroup.WithContext(ctx)
for _, layer := range layers {
layer := layer
g.Go(func() error {
return scanLayer(layer)
})
}
_ = g.Wait()无服务器函数平台：OpenFaaS 的 Go 模板生态
OpenFaaS 官方维护的 golang-http 模板已被超过 12,000 个项目采用。某物流公司在 Kubernetes 集群中部署 327 个 Go 函数，处理实时运单轨迹计算，冷启动时间平均 117ms（对比 Node.js 模板快 3.2 倍）。其构建流程通过 Dockerfile 中多阶段编译实现：
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -a -ldflags '-extldflags "-static"' -o handler .
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/handler .
CMD ["./handler"]服务网格数据平面：Istio Envoy 的 Go 扩展插件
虽然 Envoy 本身用 C++ 编写，但 Istio 社区广泛采用 Go 编写 WASM 扩展插件（通过 tinygo 编译）。某银行基于 proxy-wasm-go-sdk 实现了符合 PCI-DSS 的请求头脱敏逻辑，在每秒 8,500 请求负载下 CPU 占用仅 0.3 个 vCPU。其敏感字段匹配采用 Aho-Corasick 算法预编译的 Go 实现，比正则引擎提速 17 倍。
低延迟交易系统中间件：NATS JetStream 的 Go 客户端深度定制
高频量化交易公司对 NATS JetStream 进行 Go 客户端二次开发，禁用默认重连策略，改用指数退避 + 本地环形缓冲区暂存未确认消息。在模拟网络分区场景下，消息端到端 P99 延迟控制在 23μs（启用 SO_REUSEPORT 和 net.Conn.SetReadBuffer(1024*1024)）。该方案已支撑日均 4.2 亿笔订单状态同步。
flowchart LR
A[Go 应用] --> B[NATS Conn]
B --> C{JetStream Publish}
C --> D[环形缓冲区<br>容量 65536]
D --> E[内核 Socket Buffer]
E --> F[网卡 DMA]
style D fill:#4CAF50,stroke:#388E3C,color:white