@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references//345/276/256/346/234/215/345/212/241/345/274/200/345/217/221//346/234/215/345/212/241/351/205/215/347/275/256/347/256/241/347/220/206.md

@@ -0,0 +1,166 @@
+## 基本介绍
+
+`GoFrame` 框架提供了功能强大的配置管理组件，采用了解耦化和接口化设计，可以灵活对接各种第三方配置管理中心。配置管理组件默认提供基于本地系统文件的实现，更多的第三方配置中心实现请参考社区组件： [https://github.com/gogf/gf/tree/master/contrib/config](https://github.com/gogf/gf/tree/master/contrib/config)
+
+社区组件提供了常用的多种配置中心实现，例如 `Polaris`、 `Apollo`、 `Nacos`、 `Consul` 以及容器编排的 `Kubernetes ConfigMap`。
+
+## 组件启用
+
+配置管理组件的启用采用了包初始化的方式。由于配置管理功能比较底层，需要保证社区组件包在 `main` 包的最顶部引入，确保配置组件在其他组件之前初始化。我们这里以 `Polaris` 为例，社区组件的使用说明： [https://github.com/gogf/gf/tree/master/contrib/config/polaris](https://github.com/gogf/gf/tree/master/contrib/config/polaris)
+
+需要提供一个独立的引入包，例如 `boot`：
+
+```go
+package boot
+
+import (
+    "github.com/gogf/gf/contrib/config/polaris/v2"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+func init() {
+    var (
+        ctx       = gctx.GetInitCtx()
+        namespace = "default"
+        fileGroup = "TestGroup"
+        fileName  = "config.yaml"
+        path      = "manifest/config/polaris.yaml"
+        logDir    = "/tmp/polaris/log"
+    )
+    // Create polaris Client that implements gcfg.Adapter.
+    adapter, err := polaris.New(ctx, polaris.Config{
+        Namespace: namespace,
+        FileGroup: fileGroup,
+        FileName:  fileName,
+        Path:      path,
+        LogDir:    logDir,
+        Watch:     true,
+    })
+    if err != nil {
+        g.Log().Fatalf(ctx, `%+v`, err)
+    }
+    // Change the adapter of default configuration instance.
+    g.Cfg().SetAdapter(adapter)
+}
+```
+
+其中配置参数说明：
+
+- `Namespace` 指定的是 `Polaris` 配置中的命名空间。
+- `FileGroup` 指定的是 `Polaris` 中的文件分组。
+- `FileName` 指定的是需要读取的 `Polaris` 中的配置文件名称。
+- `Path` 指定的是 `Polaris` 服务端配置文件路径，包括 Polaris 的链接地址、监听地址、组件输出日志路径等。
+
+`Polaris` 的服务端配置文件内容如下：
+
+```yaml
+global:
+  serverConnector:
+    addresses:
+      - 127.0.0.1:8091
+config:
+  configConnector:
+    addresses:
+      - 127.0.0.1:8093
+consumer:
+  localCache:
+    persistDir: "/tmp/polaris/backup"
+```
+
+随后在 `main.go` 顶部引入 `boot` 包，保证该包的引入在所有组件的最前面：
+
+```go
+package main
+
+import (
+    _ "github.com/gogf/gf/example/config/polaris/boot"
+
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+func main() {
+    var ctx = gctx.GetInitCtx()
+
+    // Available checks.
+    g.Dump(g.Cfg().Available(ctx))
+
+    // All key-value configurations.
+    g.Dump(g.Cfg().Data(ctx))
+
+    // Retrieve certain value by key.
+    g.Dump(g.Cfg().MustGet(ctx, "server.address"))
+}
+```
+
+注意其中顶部 `import` 的引入语句：
+
+```
+_ "github.com/gogf/gf/example/config/polaris/boot"
+```
+
+## 常用组件
+
+| 组件名称 | 文档说明 | 备注 |
+| --- | --- | --- |
+| `file` | 框架内置 | 默认实现 |
+| `apollo` | [https://github.com/gogf/gf/tree/master/contrib/config/apollo](https://github.com/gogf/gf/tree/master/contrib/config/apollo) |  |
+| `kubecm` | [https://github.com/gogf/gf/tree/master/contrib/config/kubecm](https://github.com/gogf/gf/tree/master/contrib/config/kubecm) | 常用于容器部署环境 |
+| `nacos` | [https://github.com/gogf/gf/tree/master/contrib/config/nacos](https://github.com/gogf/gf/tree/master/contrib/config/nacos) |  |
+| `polaris` | [https://github.com/gogf/gf/tree/master/contrib/config/polaris](https://github.com/gogf/gf/tree/master/contrib/config/polaris) |  |
+| `consul` | [https://github.com/gogf/gf/tree/master/contrib/config/consul](https://github.com/gogf/gf/tree/master/contrib/config/consul) |  |
+
+更多组件，请参考： [https://github.com/gogf/gf/tree/master/contrib/config](https://github.com/gogf/gf/tree/master/contrib/config)
+
+## 使用示例
+
+[https://github.com/gogf/gf/tree/master/example/config/polaris](https://github.com/gogf/gf/tree/master/example/config/polaris)
+
+### 运行 `polaris`
+
+```bash
+docker run -d --name polaris -p 8080:8080 -p 8090:8090 -p 8091:8091 -p 8093:8093 loads/polaris-server-standalone:1.11.2
+```
+
+### 运行示例
+
+```bash
+$ go run main.go
+true
+{}
+"failed to update local value: config file is empty"
+panic: failed to update local value: config file is empty
+
+goroutine 1 [running]:
+github.com/gogf/gf/v2/os/gcfg.(*Config).MustGet(0x0?, {0x1c1c4f8?, 0xc0000c2000?}, {0x1ac11ad?, 0x0?}, {0x0?, 0xc000002340?, 0xc000064738?})
+        /Users/john/Workspace/gogf/gf/os/gcfg/gcfg.go:167 +0x5e
+main.main()
+        /Users/john/Workspace/gogf/gf/example/config/polaris/main.go:20 +0x1b8
+```
+
+可以看到最后的 `MustGet` 方法执行报错，这是因为 `Polaris` 配置中心里并没有指定的命名空间、配置分组以及配置文件。即使查询不到任何数据，但由于涉及到配置问题因此返回了错误。由于这里使用的是 `Must*` 方法，在执行返回错误时将会直接 `panic` 而不是返回错误。
+
+那么我们进入 `polaris` 的后台添加一些测试数据再试试。
+
+### 添加测试数据
+
+进入 [http://127.0.0.1:8080/#/login](http://127.0.0.1:8080/#/login) 默认账号 `polaris` 密码 `polaris`
+
+### 再次运行示例
+
+```bash
+$ go run main.go
+true
+{
+    "server": {
+        "openapiPath": "/api.json",
+        "swaggerPath": "/swagger",
+        "address":     ":8199",
+    },
+}
+<nil>
+":8199"
+```
+
+可以看到已经正确查询到了 `Polaris` 配置中心中的配置数据。

package/skills/goframe-v2/references//345/276/256/346/234/215/345/212/241/345/274/200/345/217/221//347/216/257/345/242/203/345/207/206/345/244/207.md

@@ -0,0 +1,22 @@
+后续微服务章节主要以 `gRPC` 协议为主，介绍微服务的开发、组件及工具使用。
+
+## 依赖安装
+
+在进一步学习之前，请先了解 `gRPC` 相关概念，并在本地开发环境中安装对应的工具：
+
+- [https://grpc.io/](https://grpc.io/)
+- [https://grpc.io/docs/languages/go/quickstart/](https://grpc.io/docs/languages/go/quickstart/)
+
+如果是 `MacOS` 环境，可以考虑使用 `brew` 工具安装依赖：
+
+```
+brew install grpc protoc-gen-go protoc-gen-go-grpc
+```
+
+依赖工具安装完成后，请参考 [https://grpc.io/docs/languages/go/quickstart/](https://grpc.io/docs/languages/go/quickstart/) 章节完成基础的 `protoc` 工具使用学习。
+
+## 框架工具
+
+`GoFrame` 框架的 `CLI` 开发工具请保证版本 `>= v2.4`。工具安装、升级请参考章节：[开发工具](../开发工具/开发工具.md)
+
+框架工具针对 `GRPC` 协议，提供了额外的命令支持，极大地简化了基于 `GRPC` 协议的微服务开发。

package/skills/goframe-v2/references//345/276/256/346/234/215/345/212/241/345/274/200/345/217/221//350/204/232/346/211/213/346/236/266/346/250/241/345/235/227.md

@@ -0,0 +1,367 @@
+`GoFrame` 框架包含多个微服务组件，并提供了易用的 `gRPC` 脚手架模块和工具。脚手架由 `grpcx` 社区包实现： [https://github.com/gogf/gf/tree/master/contrib/rpc/grpcx](https://github.com/gogf/gf/tree/master/contrib/rpc/grpcx) 包含多个模块。
+
+## 服务端- `Server`
+
+服务端由 `grpcx.Server` 模块维护，用于实现服务端对象的创建与维护。使用示例： [https://github.com/gogf/gf/blob/master/example/rpc/grpcx/basic/server/main.go](https://github.com/gogf/gf/blob/master/example/rpc/grpcx/basic/server/main.go)
+
+服务端的创建往往结合配置文件一起使用，关于服务端配置文件的介绍请参考章节： [服务端配置](服务端配置.md)
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/basic/controller"
+)
+
+func main() {
+    s := grpcx.Server.New()
+    controller.Register(s)
+    s.Run()
+}
+```
+
+## 客户端- `Client`
+
+客户端由 `grpcx.Client` 模块维护，用于实现客户端对象的创建与维护。使用示例： [https://github.com/gogf/gf/blob/master/example/rpc/grpcx/basic/client/main.go](https://github.com/gogf/gf/blob/master/example/rpc/grpcx/basic/client/main.go)
+
+在微服务架构中，大部分场景下服务间的访问使用服务名称而非直接的地址。
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/basic/protobuf"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+func main() {
+    var (
+        ctx    = gctx.New()
+        conn   = grpcx.Client.MustNewGrpcClientConn("demo")
+        client = protobuf.NewGreeterClient(conn)
+    )
+    res, err := client.SayHello(ctx, &protobuf.HelloRequest{Name: "World"})
+    if err != nil {
+        g.Log().Error(ctx, err)
+        return
+    }
+    g.Log().Debug(ctx, "Response:", res.Message)
+}
+```
+:::warning
+常见问题
+
+**是否需要保存复用创建的 `Client` 对象？**
+
+每个 `gRPC Client` 对象实际上对应一个目标服务的访问连接。在应用中，应该将该对象保存下来复用，而不是每次请求都新建 `Client` 对象。这样可以提高效率、降低资源使用、减轻 `GC` 压力。
+:::
+## 上下文- `Ctx`
+
+上下文由 `grpcx.Ctx` 模块维护，用于实现客户端与服务端之间、服务与服务之间的自定义数据传递。包含以下常用方法：
+
+```go
+func (c Ctx) NewIncoming(ctx context.Context, data ...g.Map) context.Context
+func (c Ctx) NewOutgoing(ctx context.Context, data ...g.Map) context.Context
+func (c Ctx) IncomingToOutgoing(ctx context.Context, keys ...string) context.Context
+func (c Ctx) IncomingMap(ctx context.Context) *gmap.Map
+func (c Ctx) OutgoingMap(ctx context.Context) *gmap.Map
+func (c Ctx) SetIncoming(ctx context.Context, data g.Map) context.Context
+func (c Ctx) SetOutgoing(ctx context.Context, data g.Map) context.Context
+```
+
+其中 `Outgoing` 用于客户端，表示将要传递给服务端的自定义数据，一般为 `Key-Value` 键值对组成的 `Map` 数据格式。`Incoming` 用于服务端，表示服务端接收到的客户端提交数据。框架相关的一些内嵌信息也会写入到 `Incoming` 键值对中，例如链路跟踪信息、客户端版本信息等。使用示例：
+
+`server.go`
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/ctx/controller"
+)
+
+func main() {
+    s := grpcx.Server.New()
+    controller.Register(s)
+    s.Run()
+}
+```
+
+`controller.go`
+
+```go
+package controller
+
+import (
+    "context"
+
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/ctx/protobuf"
+    "github.com/gogf/gf/v2/frame/g"
+)
+
+type Controller struct {
+    protobuf.UnimplementedGreeterServer
+}
+
+func Register(s *grpcx.GrpcServer) {
+    protobuf.RegisterGreeterServer(s.Server, &Controller{})
+}
+
+// SayHello implements helloworld.GreeterServer
+func (s *Controller) SayHello(ctx context.Context, in *protobuf.HelloRequest) (*protobuf.HelloReply, error) {
+    m := grpcx.Ctx.IncomingMap(ctx)
+    g.Log().Infof(ctx, `incoming data: %v`, m.Map())
+    return &protobuf.HelloReply{Message: "Hello " + in.GetName()}, nil
+}
+```
+
+`client.go`
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/ctx/protobuf"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+func main() {
+    var (
+        conn   = grpcx.Client.MustNewGrpcClientConn("demo")
+        client = protobuf.NewGreeterClient(conn)
+        ctx    = grpcx.Ctx.NewOutgoing(gctx.New(), g.Map{
+            "UserId":   "1000",
+            "UserName": "john",
+        })
+    )
+    g.Log().Infof(ctx, `outgoing data: %v`, grpcx.Ctx.OutgoingMap(ctx).Map())
+    res, err := client.SayHello(ctx, &protobuf.HelloRequest{Name: "World"})
+    if err != nil {
+        g.Log().Error(ctx, err)
+        return
+    }
+    g.Log().Debug(ctx, "Response:", res.Message)
+}
+```
+
+执行后，服务端输出：
+
+```bash
+$ go run server.go
+2023-03-15 19:28:45.331 [DEBU] set default registry using file registry as no custom registry set
+2023-03-15 19:28:45.331 [DEBU] service register: &{Head: Deployment: Namespace: Name:demo Version: Endpoints:10.35.12.81:51707 Metadata:map[protocol:grpc]}
+2023-03-15 19:28:45.332 [INFO] pid[83753]: grpc server started listening on [:51707]
+2023-03-15 19:28:54.093 [INFO] {d049db1a39944c1711bd9f37d58a88f9} incoming data: map[:authority:service/default/default/demo/latest/ content-type:application/grpc traceparent:00-d049db1a39944c1711bd9f37d58a88f9-adbd2ba657ffea45-01 user-agent:grpc-go/1.49.0 userid:1000 username:john]
+2023-03-15 19:28:54.093 {d049db1a39944c1711bd9f37d58a88f9} /protobuf.Greeter/SayHello, 0.049ms, name:"World", message:"Hello World"
+```
+
+客户端输出：
+
+```bash
+$ go run client.go
+2023-03-15 19:28:54.087 [INFO] {d049db1a39944c1711bd9f37d58a88f9} outgoing data: map[userid:1000 username:john]
+2023-03-15 19:28:54.089 [DEBU] client conn updated with addresses [{"Addr":"10.35.12.81:51707","ServerName":"demo","Attributes":{},"BalancerAttributes":null,"Type":0,"Metadata":null}]
+2023-03-15 19:28:54.093 [DEBU] {d049db1a39944c1711bd9f37d58a88f9} Response: Hello World
+```
+
+## 负载均衡- `Balancer`
+
+负载均衡由 `grpcx.Balancer` 模块维护，用于实现当服务端存在多个访问地址时，客户端根据何种策略进行请求。当客户端未设置负载均衡策略时，默认使用轮询策略。关于负载均衡的详细介绍请参考章节： [服务负载均衡](服务负载均衡.md)
+
+以下使用**随机策略**作为示例。使用随机策略时，各个服务端实例接收到的请求数分布不一定均衡，但从概率角度上能够实现负载分散。
+
+`server.go`
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/balancer/controller"
+)
+
+func main() {
+    s := grpcx.Server.New()
+    controller.Register(s)
+    s.Run()
+}
+```
+
+`client.go`
+
+```go
+package main
+
+import (
+    "context"
+
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/balancer/protobuf"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+func main() {
+    var (
+        ctx    context.Context
+        conn   = grpcx.Client.MustNewGrpcClientConn("demo", grpcx.Balancer.WithRandom())
+        client = protobuf.NewGreeterClient(conn)
+    )
+    for i := 0; i < 10; i++ {
+        ctx = gctx.New()
+        res, err := client.SayHello(ctx, &protobuf.HelloRequest{Name: "World"})
+        if err != nil {
+            g.Log().Error(ctx, err)
+            return
+        }
+        g.Log().Debug(ctx, "Response:", res.Message)
+    }
+}
+```
+
+其中的 `grpcx.Balancer.WithRandom()` 表示使用随机的请求策略。
+
+启动两个 `server.go` 服务端，随后运行 `client.go` 客户端，查看服务端的请求日志：
+
+`server1` 终端输出：
+
+```bash
+$ go run server.go
+2023-03-15 19:50:44.801 [DEBU] set default registry using file registry as no custom registry set
+2023-03-15 19:50:44.802 [DEBU] service register: &{Head: Deployment: Namespace: Name:demo Version: Endpoints:10.35.12.81:53962 Metadata:map[protocol:grpc]}
+2023-03-15 19:50:44.802 [INFO] pid[89290]: grpc server started listening on [:53962]
+2023-03-15 19:50:57.282 {7025612f6d954c17c5f335051bf10899} /protobuf.Greeter/SayHello, 0.003ms, name:"World", message:"Hello World"
+2023-03-15 19:50:57.283 {60567c2f6d954c17c7f335052ce05185} /protobuf.Greeter/SayHello, 0.002ms, name:"World", message:"Hello World"
+2023-03-15 19:50:57.285 {f8d09b2f6d954c17ccf33505dff1a4ea} /protobuf.Greeter/SayHello, 0.002ms, name:"World", message:"Hello World"
+2023-03-15 19:50:57.287 {f0fab02f6d954c17cdf33505438b2c80} /protobuf.Greeter/SayHello, 0.001ms, name:"World", message:"Hello World"
+```
+
+`server2` 终端输出：
+
+```bash
+$ go run server.go
+2023-03-15 19:50:51.720 [DEBU] set default registry using file registry as no custom registry set
+2023-03-15 19:50:51.721 [DEBU] service register: &{Head: Deployment: Namespace: Name:demo Version: Endpoints:10.35.12.81:53973 Metadata:map[protocol:grpc]}
+2023-03-15 19:50:51.722 [INFO] pid[89351]: grpc server started listening on [:53973]
+2023-03-15 19:50:57.280 {b89a0d2f6d954c17c4f33505a046817c} /protobuf.Greeter/SayHello, 0.002ms, name:"World", message:"Hello World"
+2023-03-15 19:50:57.282 {28bf732f6d954c17c6f33505adedff5f} /protobuf.Greeter/SayHello, 0.002ms, name:"World", message:"Hello World"
+2023-03-15 19:50:57.283 {9876832f6d954c17c8f3350580ed535b} /protobuf.Greeter/SayHello, 0.002ms, name:"World", message:"Hello World"
+2023-03-15 19:50:57.284 {684e8b2f6d954c17c9f33505d56e4b05} /protobuf.Greeter/SayHello, 0.001ms, name:"World", message:"Hello World"
+2023-03-15 19:50:57.284 {c045912f6d954c17caf3350599006197} /protobuf.Greeter/SayHello, 0.001ms, name:"World", message:"Hello World"
+2023-03-15 19:50:57.284 {500a972f6d954c17cbf33505252b0e01} /protobuf.Greeter/SayHello, 0.001ms, name:"World", message:"Hello World"
+```
+
+客户端终端输出：
+
+```bash
+$ go run client.go
+2023-03-15 19:50:57.278 [DEBU] client conn updated with addresses [{"Addr":"10.35.12.81:53962","ServerName":"demo","Attributes":{},"BalancerAttributes":null,"Type":0,"Metadata":null},{"Addr":"10.35.12.81:53973","ServerName":"demo","Attributes":{},"BalancerAttributes":null,"Type":0,"Metadata":null}]
+2023-03-15 19:50:57.281 [DEBU] {b89a0d2f6d954c17c4f33505a046817c} Response: Hello World
+2023-03-15 19:50:57.282 [DEBU] {7025612f6d954c17c5f335051bf10899} Response: Hello World
+2023-03-15 19:50:57.282 [DEBU] {28bf732f6d954c17c6f33505adedff5f} Response: Hello World
+2023-03-15 19:50:57.283 [DEBU] {60567c2f6d954c17c7f335052ce05185} Response: Hello World
+2023-03-15 19:50:57.283 [DEBU] {9876832f6d954c17c8f3350580ed535b} Response: Hello World
+2023-03-15 19:50:57.284 [DEBU] {684e8b2f6d954c17c9f33505d56e4b05} Response: Hello World
+2023-03-15 19:50:57.284 [DEBU] {c045912f6d954c17caf3350599006197} Response: Hello World
+2023-03-15 19:50:57.285 [DEBU] {500a972f6d954c17cbf33505252b0e01} Response: Hello World
+2023-03-15 19:50:57.286 [DEBU] {f8d09b2f6d954c17ccf33505dff1a4ea} Response: Hello World
+2023-03-15 19:50:57.287 [DEBU] {f0fab02f6d954c17cdf33505438b2c80} Response: Hello World
+```
+
+可以看到，客户端发送了 `10` 次请求，两个服务端分别接收到了 `4` 次和 `6` 次请求，请求的负载比较随机。
+
+## 注册发现- `Resolver`
+
+注册发现由 `grpcx.Resolver` 模块维护，该模块用于 `gRPC` 服务名称解析。`grpcx` 组件默认情况下使用本地文件系统实现注册发现，仅用于测试使用。如果是生产环境，则需要使用其他的注册发现组件。一个简单示例：
+
+`server.go`
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/contrib/registry/etcd/v2"
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/resolver/controller"
+)
+
+func main() {
+    grpcx.Resolver.Register(etcd.New("127.0.0.1:2379"))
+
+    s := grpcx.Server.New()
+    controller.Register(s)
+    s.Run()
+}
+```
+
+其中的 `grpcx.Resolver.Register(etcd.New("127.0.0.1:2379"))` 用于设置服务注册发现组件为 `etcd`，仅支持 `gRPC` 协议。
+
+`client.go`
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/contrib/registry/etcd/v2"
+    "github.com/gogf/gf/contrib/rpc/grpcx/v2"
+    "github.com/gogf/gf/example/rpc/grpcx/resolver/protobuf"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+func main() {
+    grpcx.Resolver.Register(etcd.New("127.0.0.1:2379"))
+
+    var (
+        ctx    = gctx.New()
+        conn   = grpcx.Client.MustNewGrpcClientConn("demo")
+        client = protobuf.NewGreeterClient(conn)
+    )
+    res, err := client.SayHello(ctx, &protobuf.HelloRequest{Name: "World"})
+    if err != nil {
+        g.Log().Error(ctx, err)
+        return
+    }
+    g.Log().Debug(ctx, "Response:", res.Message)
+}
+```
+
+启动 `etcd`：
+
+```bash
+$ etcd
+{"level":"info","ts":"2023-03-15T20:02:50.966+0800","caller":"etcdmain/etcd.go:73","msg":"Running: ","args":["etcd"]}
+{"level":"info","ts":"2023-03-15T20:02:50.967+0800","caller":"etcdmain/etcd.go:100","msg":"failed to detect default host","error":"default host not supported on darwin_amd64"}
+{"level":"warn","ts":"2023-03-15T20:02:50.967+0800","caller":"etcdmain/etcd.go:105","msg":"'data-dir' was empty; using default","data-dir":"default.etcd"}
+{"level":"info","ts":"2023-03-15T20:02:50.967+0800","caller":"etcdmain/etcd.go:116","msg":"server has been already initialized","data-dir":"default.etcd","dir-type":"member"}
+{"level":"info","ts":"2023-03-15T20:02:50.967+0800","caller":"embed/etcd.go:124","msg":"configuring peer listeners","listen-peer-urls":["http://localhost:2380"]}
+{"level":"info","ts":"2023-03-15T20:02:50.968+0800","caller":"embed/etcd.go:132","msg":"configuring client listeners","listen-client-urls":["http://localhost:2379"]}
+...
+```
+
+运行 `server.go`：
+
+```bash
+$ go run server.go
+2023-03-15 20:02:19.472 [DEBU] service register: &{Head: Deployment: Namespace: Name:demo Version: Endpoints:10.35.12.81:55066 Metadata:map[protocol:grpc]}
+2023-03-15 20:02:19.516 [DEBU] etcd put success with key "/service/default/default/demo/latest/10.35.12.81:55066", value "{"protocol":"grpc"}", lease "7587869265929863945"
+2023-03-15 20:02:19.516 [INFO] pid[92040]: grpc server started listening on [:55066]
+2023-03-15 20:02:29.310 {88c4c04e0e964c17dddec53b1adb54f7} /protobuf.Greeter/SayHello, 0.001ms, name:"World", message:"Hello World"
+```
+
+运行 `client.go`：
+
+```bash
+$ go run client.go
+2023-03-15 20:02:29.297 [DEBU] Watch key "/service/default/default/demo/latest/"
+2023-03-15 20:02:29.307 [DEBU] client conn updated with addresses [{"Addr":"10.35.12.81:55066","ServerName":"demo","Attributes":{},"BalancerAttributes":null,"Type":0,"Metadata":null}]
+2023-03-15 20:02:29.308 [DEBU] client conn updated with addresses [{"Addr":"10.35.12.81:55066","ServerName":"demo","Attributes":{},"BalancerAttributes":null,"Type":0,"Metadata":null}]
+2023-03-15 20:02:29.310 [DEBU] {88c4c04e0e964c17dddec53b1adb54f7} Response: Hello World
+```

package/skills/goframe-v2/references//345/277/253/351/200/237/345/274/200/345/247/213/Hello World.md"

@@ -0,0 +1,74 @@
+`GoFrame` 是一款基础设施建设比较完善的模块化框架， 
+`Web Server` 模块是其中比较核心的模块，我们这里将 `Web` 服务开发作为框架入门的选择，便于大家更容易学习和理解。
+
+## Hello World
+
+我们先来开发一个简单的`Web Server`程序。
+
+- 新建`main.go`文件
+  ```go title="main.go"
+  package main
+
+  import (
+      "github.com/gogf/gf/v2/frame/g"
+      "github.com/gogf/gf/v2/net/ghttp"
+  )
+
+  func main() {
+      s := g.Server()
+      s.BindHandler("/", func(r *ghttp.Request) {
+          r.Response.Write("Hello World!")
+      })
+      s.SetPort(8000)
+      s.Run()
+  }
+  ```
+- 配置`go mod`并安装依赖
+  ```shell
+  go mod init main
+  go mod tidy
+  ```
+
+我们来看看这段代码：
+- 任何时候，您都可以通过 `g.Server()` 方法获得一个默认的 `Server` 对象，该方法采用**单例模式**设计，
+  也就是说，多次调用该方法，返回的是同一个 `Server` 对象。其中的`g`组件是框架提供的一个耦合组件，封装和初始化一些常用的组件对象，为业务项目提供便捷化的使用方式。
+- 通过`Server`对象的`BindHandler`方法绑定路由以及路由函数。在本示例中，我们绑定了`/`路由，并指定路由函数返回`Hello World`。
+- 在路由函数中，输入参数为当前请求对象`r *ghttp.Request`，该对象包含当前请求的上下文信息。在本示例中，我们通过`r.Response`返回对象直接`Write`返回结果信息。
+- 通过`SetPort`方法设置当前`Server`监听端口。在本示例中，我们监听`8000`端口，如果在没有设置端口的情况下，它默认会监听一个随机的端口。
+- 通过 `Run()` 方法阻塞执行 `Server` 的监听运行。
+
+## 执行结果
+
+运行该程序，您将在终端看到类似以下日志信息：
+```html
+$ go run main.go
+2024-10-27 21:30:39.412 [INFO] pid[58889]: http server started listening on [:8000]
+2024-10-27 21:30:39.412 [INFO] {08a0b0086e5202184111100658330800} openapi specification is disabled
+
+  ADDRESS | METHOD | ROUTE |     HANDLER     | MIDDLEWARE  
+----------|--------|-------|-----------------|-------------
+  :8000   | ALL    | /     | main.main.func1 |             
+----------|--------|-------|-----------------|-------------
+```
+
+在默认的日志打印中包含以下信息：
+- 当前进程号`58889`，以及监听的地址`:8000`（表示监听本机所有IP地址的`8000`端口）。
+- 由于框架带有自动接口文档生成功能，本示例中未启用，因此提示`openapi specification is disabled`。
+  关于接口文档的自动生成，在开发手册中对应章节会详细讲解，本示例不作介绍。
+- 最后会打印当前`Server`的路由列表。由于我们只监听了`/`路由，那么这里只打印了一个路由信息。在路由信息表中：
+
+  | 路由字段 | 字段描述 |
+  |----------|----------|
+  | `ADDRESS` | 表示该路由的监听地址，同一个进程可以同时运行多个`Server`，不同的`Server`可以监听不同的地址。 |
+  | `METHOD` | 表示路由监听的`HTTP Method`信息，比如`GET/POST/PUT/DELETE`等。这里的`ALL`标识监听所有的`HTTP Method`。 |
+  | `ROUTE` | 表示监听的具体路由地址信息。 |
+  | `HANDLER` | 表示路由函数的名称。由于本示例使用的是闭包函数，因此看到的是一个临时函数名称`main.main.func1`。 |
+  | `MIDDLEWARE` | 表示绑定到当前路由的中间件函数名称，中间件是`Server`中一种经典的拦截器，后续章节中会有详细讲解，这里暂不做介绍。 |
+
+运行后，我们尝试访问 http://127.0.0.1:8000/ 您将在页面中看到输出
+
+## 学习小结
+
+太棒了！您使用`GoFrame`框架开发第一个`Web Server`程序！
+
+下一步，我们将会学习如何在`Web Server`中获取客户端提交的参数数据。

package/skills/goframe-v2/references//345/277/253/351/200/237/345/274/200/345/247/213/What's Next.md"

@@ -0,0 +1,12 @@
+## 学习小结
+通过快速章节，您应当了解到了关于`Web Server`接口的完整开发流程，以及一些实用特性的掌握。在这些章节中，我们只是点到即止，更详细的讲解以及功能特性介绍请查看对应开发手册章节。当您对某一模块的使用感到疑惑不解时，建议仔细阅读对应的开发手册章节，里面对各个组件重要的功能特性、使用方式、常见问题做了详细的讲解。
+
+:::info
+如果您开始尝试翻阅开发手册，需要注意的是，由于`GoFrame`是低耦合、模块化设计的，每一个模块都相对独立，因此开发手册中的文档也是基于模块化编写的，每个章节只会介绍对应的组件本身的使用。
+:::
+
+接下来我们应该做什么呢？
+
+## 项目脚手架
+
+在接下来的章节中，我们将尝试使用`GoFrame`框架提供的项目脚手架，开发一个简单的、较完整的业务项目。