单体 or 微服务？Service Weaver：我全都要！

2023-10-12 10:36
文章标签 服务 service 单体 全都 weaver

本文主要是介绍单体 or 微服务？Service Weaver：我全都要！，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

TL;DR

怎么理解 Service Weaver，就是一个应用中有很多的接口，这些接口间会互相调用。如果将操作系统进程（应用）比做一块电路板，接口比做元器件。可以选择将哪些元器件放入该电路板中，哪些元器件放入其他的电路板中。

同一块电路板中的元器件间通过板上的导线连接（进程内的本地方法调用）；不同电路板中的元器件间通过排线来连接（远程方法调用）。

总结几个关键词：

  • 一个编程框架
  • 用于编写、部署、管理分布式应用
  • 支持的语言 Go
  • 在本地以单进程、多进程运行
  • 在云端由框架拆分成微服务，并于云供应商集成
  • 单体方式开发，微服务方式部署

体验了一圈下来，给我的感觉有点类似 Notion、Obsidian 这类笔记软件。传统的笔记软件只能引用其他的笔记，而这类笔记可以细粒度到 heading 内容。

放到微服务下就是管理的维度不在是服务本身，而且更小的接口，并且对某些接口进行扩展，即使所有接口都位于同一个二进制文件中。

背景

架构的演进，总是在解决问题的过程中引入新的问题，然后再解决问题，循环往复。

从单体到微服务

软件架构从单体演进到微服务架构已经十多年了，尤其是近几年云原生风生水起，微服务架构已有深入人心的架势。

单体架构由于在规模扩大时，单体面临性能瓶颈和硬件限制、无法支撑业务的快读迭代、开发效率下降协同难度增加等原因，颓势日渐明显。然后就有了微服务架构的提出，来解决单体架构的各种问题。

上云

由于云平台提供显著的成本效益，减少初始投资并实现按需付费、提供极大的灵活性和可扩展性、提供的稳定性和可靠性确保业务连续性、专业的安全保障和合规性支持减轻企业的运营负担，企业将其业务和数据迁移至云计算平台。

问题

拆分成微服务，由此带来了不少好处：更高效的应用扩展、更小的错误传播半径、独立的安全域以及完善的模块边界。

反过来，如何正确地找到边界进行拆分并非易事。拆分的依据是什么？two pizza team？依据资源使用、组织架构、数据结构？亦或是考虑未来的增长？

微服务的拆分执行下来毫无章法，最终的结果是微服务越来越多、更多的故障点、更长的链路、更大的延迟。这实际上增加了应用的开发、部署和管理成本。

  • 原本单个二进制文件，拆分后有多个；原本一次部署完成，拆分后需要多个 CI/CD 流水线来部署；原本一个配置文件，拆分后需要维护多个。
  • 微服务彼此独立部署，无法忽略多版本的情况。需要调整部署策略来降低风险，同样还有本地开发和测试的难度增加。
  • 学习成本高，需要学习如何将应用二进制文件包装成容器，并了解云的各种工具和部署方式，即使对经验丰富的程序员来说也难以理解。
  • 同时还要解决分布式带来的各种问题，如服务发现、安全、负载均衡，以及服务间的调用。
  • 延迟增加，时间消耗在数据的序列化以及网络传输上。

为什么用 Service Weaver？

今年 3 月 Google 开源了 Service Weaver，希望能解决微服务架构的各种问题。

有了 Servier Weaver，你可以专注在业务逻辑的开发上，其他的工作交给 Service Weaver 来完成。

无需要纠结微服务的拆分规则，可以拆分为任意数量的组件。可以在部署的时候轻松指定哪些组件作为一个微服务来运行，哪些在不同的微服务上运行。

使用 Service 可以部署和管理单一二进制文件。

Service Weaver 使用自定义的序列化和传输协议，成本效益比行业最佳的解决方案（gRPC+protobuf）高出三倍。

如何使用 Service Weaver 开发应用？

Service Weaver 的核心是组件（component），一个类似 actor 的计算单元。

组件是个常见的 Go 接口，组件间的交互通过调用接口定义的方法来完成。

下面的示例中定义了一个 Reverser 组件，用于反转字符串。

// The interface of the Reverser component.
type Reverser interface {Reverse(context.Context, string) (string, error)
}// The implementation of the Reverser component.
type reverser struct{weaver.Implements[Reverser]
}func (r reverser) Reverse(_ context.Context, s string) (string, error) {runes := []rune(s)n := len(runes)for i := 0; i < n/2; i++ {runes[i], runes[n-i-1] = runes[n-i-1], runes[i]}return string(runes), nil
}

其他组件可以调用 Reverser 组件的方法：

reversed, err := reverser.Reverse(ctx, "Hello, World!")

组件的最大优点是不依赖于系统进程。上面的例子中，尽管没有编写任何网络和序列化相关的代码，这些组件可以运行在不同的进程中甚至是不同的机器上。

如上图所示，如果组件位于同一个进程中，方法的调用就是传统的 Go 方法调用；如果位于不同的进程中，方法的调用就是 RPC。

将应用拆分为不同组件的过程，有点类似微服务的拆分。组件也同样有着清晰的边界，以及很好的扩展性。但又没有微服务的缺陷：

  • 所有组件都运行同一个版本，无需考虑版本的兼容性。
  • 可以很容易地通过 go run 和 go test 运行和测试应用。
  • 微服务的拆分和合并是非常痛苦的。

如何管理 Service Weaver 应用？

部署

在云上运行就跟本地运行一样简单：

$ go run .                           # Run locally, in the same OS process.
$ weaver multi deploy weaver.toml    # Run locally, in multiple OS processes.
$ weaver gke deploy weaver.toml      # Run in the cloud.

配置

Service Weaver 需要的配置非常少。一个 在线商城 的演示中可能需要超过 1500 行配置，而 Service Weaver 编写的同样应用所需的配置不超过 10 行：

[weaver]
binary = "./online_boutique"
rollout = "6h"[gke]
regions = ["us-west1", "us-east2"]
listeners.boutique = {public_hostname = "online-boutique.net"}

只需指定二进制文件、部署的持续时间、部署的区域以及公开访问的地址。就这么简单。

发布新版本

传统的微服务，在发布新版本时，旧版本的示例可以会与其他新版本的示例进行通信。

Service Weaver 使用不同的方式升级，确保客户端的请求完全在相同的版本下处理：不同版本的组件不会发生通信。

这就避免了大多数的系统故障：研究表明的：多大三分之二的故障是由系统多个版本之间的交互引起的。

有了 Service Weaver，仅需更新代码、构建、运行即可，其他的交给 Service Weaver。

可观测性

Service Weaver 提供了用于日志、指标和链路跟踪的库，并自动与应用的部署环境集成。

下面的示例演示了如何为 Reverser 组件添加计数指标：

var reverseCount = metrics.NewCounter("reverse_count","The number of times Reverser.Reverse has been called",
)func (reverser) Reverse(_ context.Context, s string) (string, error) {reverseCount.Add(1.0)// ...
}

测试

传统的微服务，应用开发周期非常慢。在迭代中，需要安装笨重的云依赖、复杂的测试框架，或者部署到云上。这些都极大影响了开发进度。

有了 Service Weaver 可以想运行 Go 程序一样完成构建、运行、测试。提供的 weavertest 包可用来编写端到端测试，就像写单元测试一样简单。

演示

安装 Service Weaver

参考 安装文档，注意要求 Go 的版本不低于 1.21。在 macOS 上直接用 Homebrew 安装：

brew install  service-weaver
weaver version
weaver v0.21.2 darwin/arm64
go version
go version go1.21.3 darwin/arm64

初始化工程

mkdir hello-sample
cd hello-sample
go mod init hello-sample

使用上面 Reverser 组件的例子。

编写 Reverser 组件

创建 reverser.go 文件，内容如下：

package main
import ("context""github.com/ServiceWeaver/weaver"
)
// Reverser component.
type Reverser interface {Reverse(context.Context, string) (string, error)
}
// Implementation of the Reverser component.
type reverser struct{weaver.Implements[Reverser]
}
func (r *reverser) Reverse(_ context.Context, s string) (string, error) {runes := []rune(s)n := len(runes)for i := 0; i < n/2; i++ {runes[i], runes[n-i-1] = runes[n-i-1], runes[i]}return string(runes), nil
}

Reverser 组件通过定义创建接口 Reverser 定义，该接口定义了用于反转字符串的方法 Reverse；结构体类型 reverser 通过 weaver.Implements[Reverser] 定义为组件 Reverser 的实现。

接下来是调用组件的代码。

编写 Main 组件

创建 main.go 文件，内容如下，也就是 main 组件：

package main
import ("context""fmt""log""github.com/ServiceWeaver/weaver"
)
func main() {if err := weaver.Run(context.Background(), serve); err != nil {log.Fatal(err)}
}
type app struct{weaver.Implements[weaver.Main]reverser weaver.Ref[Reverser]
}
func serve(ctx context.Context, app *app) error {// Call the Reverse method.var r Reverser = app.reverser.Get()reversed, err := r.Reverse(ctx, "!dlroW ,olleH")if err != nil {return err}fmt.Println(reversed)return nil
}

weaver.Run(...) 初始化并运行 Service Weaver 应用，每个应用都有一组组件组成。运行时会自动创建 weaver.Main 并将其交给应用。

查看其源码可以看到使用了泛型：

func Run[T any, P PointerToMain[T]](ctx context.Context, app func(context.Context, *T) error) error {...
}

Run 执行时会先找到 Main 组件的定义，在上面的代码中结构体类型 app 被定义为 weaver.Main 组件，然后创建该组件并将其交给代码中的 serve 来使用，然后调用 serve 函数。

在 Main 组件 app 中我们还可以看到 reverser weaver.Ref[Reverser]。在 Service Weaver 中，如果一个组件 X 要调用组件 Y，就会再 X 的定义中加入 y weaver.Ref[Y]，因此这里 Main 组件将会调用 Reverser 组件。

在创建 Main 组件时，会从“注册表”中找到组件 Reverser 的“真正”实现，并将其交给 Main 组件。

这里的真正实现，可能是本地的调用，也可能是远程的调用。怎么实现的？还有很重要的一步：生成代码。

生成代码

然后执行下面的命令生成代码 weaver_gen.go：

weaver generate

简单看下文件的内容（里面用了大量的反射），首先有个 init() 方法进行组件的注册，注册信息包括

  • 组件名
  • 接口
  • 接口的实现
  • 本地调用 stub
  • 远程调用的客户端 stub
  • 供远程调用的服务端 stub
  • 通过反射进行方法调用的 stub

其中几个 stub 也都在 weaver_gen.go 文件中，由上面的命令自动生成。

因此，假如不执行 weaver generate 命令就没有 weaver_gen.go 文件，在运行时也就找不到任何组件的注册信息的。

运行

现在可以运行应用：

go run .          
╭───────────────────────────────────────────────────╮
│ app        : hello-sample                         │
│ deployment : 09caf84b-822c-44d3-a149-a5b2e733a136 │
╰───────────────────────────────────────────────────╯
Hello, World!

对服务来说用这种方式来触发调用肯定不合理，而是应该让其接收 HTTP 的流量。

进阶 - 单进程部署部署

接下来，使用下面的代码替换 main.go：

package mainimport ("context""fmt""log""net/http""github.com/ServiceWeaver/weaver"
)func main() {if err := weaver.Run(context.Background(), serve); err != nil {log.Fatal(err)}
}type app struct {weaver.Implements[weaver.Main]reverser weaver.Ref[Reverser]hello    weaver.Listener
}func serve(ctx context.Context, app *app) error {// The hello listener will listen on a random port chosen by the operating// system. This behavior can be changed in the config file.fmt.Printf("hello listener available on %v\n", app.hello)// Serve the /hello endpoint.http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {name := r.URL.Query().Get("name")if name == "" {name = "World"}reversed, err := app.reverser.Get().Reverse(ctx, name)if err != nil {http.Error(w, err.Error(), http.StatusInternalServerError)return}fmt.Fprintf(w, "Hello, %s!\n", reversed)})return http.Serve(app.hello, nil)
}

在定义 Main 组件时加入了 hello weaver.Listener，Service Weaver 会自动初始化一个 HTTP 监听器，并接收网络流量。

在 serve 中定义了 HTTP 路径 /hello：在接收到流量后从请求中读取参数 name 的值，然后调用 Reverser 组件；同时 serve 返回的 http.Server 运行在 Main 组件的 HTTP 监听器上。

生成代码

由于修改了 Main 组件的定义，需要执行 weaver generate 重新生成代码。在更新后的 weaver_gen.go 中可以看到 Main 组件的注册信息多了一个 Listeners，值是个字符串数组 []string{"hello"}，对应着代码中监听器的名字 hello。

配置文件

此时如果运行应用，会随机给应用分配一个端口。如果要自定义端口的话，就需要增加配置文件了。

创建一个名为 weaver.toml 的文件，内容如下：

[single]
listeners.hello = {address = "localhost:12345"}

在配置文件中设置监听器 hello 的监听地址。

运行

在运行时需要将配置文件的路径提供给应用。

SERVICEWEAVER_CONFIG=weaver.toml go run . 
╭───────────────────────────────────────────────────╮
│ app        : hello-sample                         │
│ deployment : 68e82ba2-a5ba-49c0-8b56-4edb775dba4b │
╰───────────────────────────────────────────────────╯
hello listener available on 127.0.0.1:12345

发送请求，可以收到反转后的字符串。

curl "localhost:12345/hello?name=world"
Hello, dlrow!

[!INFO] 可以通过 /debug/weaver/healthz 端点查看应用的健康状态。 curl -i "localhost:12345/debug/weaver/healthz" HTTP/1.1 200 OK Date: Wed, 11 Oct 2023 00:20:01 GMT Content-Length: 2 Content-Type: text/plain; charset=utf-8 OK

进阶 - 多进程

配置文件

接下来修改配置文件，用下面的内容替换：

[serviceweaver]
binary = "./hello-sample"
[multi]
listeners.hello = {address = "localhost:12345"}

在配置文件中，这次我们加入了二进制文件地址，以及多进程部署的地址。

运行

因为是多进程运行无法使用 go run 命令了，此时要用到 weaver multi 命令了（通过 weaver multi -h 查看使用方式）：

weaver multi deploy weaver.toml 
╭───────────────────────────────────────────────────╮
│ app        : hello-sample                         │
│ deployment : 9956d5c9-e88b-4d0f-a808-d4f7f475ed36 │
╰───────────────────────────────────────────────────╯
S1011 08:36:28.419836 stdout               5df75365                      │ hello listener available on 127.0.0.1:12345
S1011 08:36:28.419922 stdout               74d79043                      │ hello listener available on 127.0.0.1:12345

weaver multi 为每个组件各创建了两个副本，因此可以看到打印了两行日志。如果再次发送请求，也会得到同样的应答。

这次我们通过 Weaver Dashboard 来查看应用情况，通过下面的命令启用 dashboard（为其随机分配监听接口）：

weaver multi dashboard
Dashboard available at: http://127.0.0.1:56108

在浏览器中可以打开其 dashboard。

点击链接后可以获取其详细信息，其中就可以看到每个组件都有两个进程：

Dashboard 展示的信息相比命令行的内容会更加详细：

weaver multi status
╭────────────────────────────────────────────────────────────────╮
│ DEPLOYMENTS                                                    │
├──────────────┬──────────────────────────────────────┬──────────┤
│ APP          │ DEPLOYMENT                           │ AGE      │
├──────────────┼──────────────────────────────────────┼──────────┤
│ hello-sample │ 9956d5c9-e88b-4d0f-a808-d4f7f475ed36 │ 1h46m17s │
╰──────────────┴──────────────────────────────────────┴──────────╯
╭──────────────────────────────────────────────────────────────────╮
│ COMPONENTS                                                       │
├──────────────┬────────────┬───────────────────────┬──────────────┤
│ APP          │ DEPLOYMENT │ COMPONENT             │ REPLICA PIDS │
├──────────────┼────────────┼───────────────────────┼──────────────┤
│ hello-sample │ 9956d5c9   │ weaver.Main           │ 28079, 28082 │
│ hello-sample │ 9956d5c9   │ hello-sample.Reverser │ 28083, 28084 │
╰──────────────┴────────────┴───────────────────────┴──────────────╯
╭────────────────────────────────────────────────────────╮
│ LISTENERS                                              │
├──────────────┬────────────┬──────────┬─────────────────┤
│ APP          │ DEPLOYMENT │ LISTENER │ ADDRESS         │
├──────────────┼────────────┼──────────┼─────────────────┤
│ hello-sample │ 9956d5c9   │ hello    │ 127.0.0.1:12345 │
╰──────────────┴────────────┴──────────┴─────────────────╯

进阶 - 云端部署

[!IMPORTANT] 注意！ 接下来的操作是在 X86 的平台上完成的。

安装 weaver-kube

使用 weaver-kube 可以将应用部署到普通的 Kubernetes 上。

go install github.com/ServiceWeaver/weaver-kube/cmd/weaver-kube@latest
weaver-kube version 
weaver kube v0.21.2 darwin/arm64

配置文件

使用下面的内容替换 weaver.toml 文件：

[serviceweaver]
binary = "./hello-sample"
[kube]
repo = "docker.io/addozhang"
listeners.hello = {public = true}

这次使用 kube 配置，对应 weaver kube deploy 操作。其中 repo 是执行操作时构建镜像所推送的仓库地址，设置监听器为 {public = true} 将会为其创建 Kubernetes LoadBalancer Service。

weaver kube deploy weaver.toml...
Generating kube deployment info ...
Generated roles and bindings
Replica sets generated successfully [hello-sample/Reverser github.com/ServiceWeaver/weaver/Main]
Generated kube deployment for replica set github.com/ServiceWeaver/weaver/Main
Generated kube autoscaler for replica set github.com/ServiceWeaver/weaver/Main
Generated kube listener service for listener hello
Generated kube deployment for replica set hello-sample/Reverser
Generated kube autoscaler for replica set hello-sample/Reverser
Generated Jaeger deployment
Generated Jaeger service
Generated kube deployment for config map hello-sample-prometheus-config-4beb9a0b
Generated kube deployment for Prometheus hello-sample-prometheus-21ee5ea1
Generated kube service for Prometheus hello-sample-prometheus-21ee5ea1
Generated kube deployment for config map hello-sample-loki-config-e2c46e76
Generated kube deployment for config map hello-sample-promtail-b648e7f2
Generated kube deployment for Loki hello-sample-loki-e8d90de6
Generated kube service for Loki hello-sample-loki-e8d90de6
Generated kube daemonset for Promtail hello-sample-promtail-b648e7f2
Generated kube deployment for config map hello-sample-grafana-config-a873d265
Generated Grafana deployment
Generated Grafana service
kube deployment information successfully generated
/tmp/kube_1cfbd355-10a4-47b6-aaec-efd9bbd17a06.yaml

镜像推送到仓库后，还会生成部署所需的 manifest 文件，执行命令进行部署：

kubectl apply -f /tmp/kube_1cfbd355-10a4-47b6-aaec-efd9bbd17a06.yaml

集群我用的是 k3s 创建的：

export INSTALL_K3S_VERSION=v1.27.1+k3s1 curl -sfL https://get.k3s.io | sh -s - --disable traefik --disable local-storage --disable metrics-server --write-kubeconfig-mode 644 --write-kubeconfig ~/.kube/config

测试

查看 Pod 和 LoadBalancer 的端口，可以看到为两个组件各创建了一个 Pod。

kubectl get po,svc -l appName=hello-sample
NAME                                                                  READY   STATUS    RESTARTS   AGE
pod/hello-sample-github-com-serviceweaver-weaver-main-a0713fddsfgb2   1/1     Running   0          6h16m
pod/hello-sample-hello-sample-reverser-ad954898-01bf315f-86df6pvchc   1/1     Running   0          6h16mkubectl get svc -l lisName=hello                                                                                                                                                                                default ⎈
NAME                              TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
hello-sample-lis-hello-4701ccf4   LoadBalancer   10.43.195.210   10.0.2.4      80:31340/TCP   6h17m

在宿主机上执行命令，执行成功。

curl "localhost/hello?name=world"
Hello, dlrow!

总结

Service Weaver 的思路很好，针对目前微服务架构的问题做了优化和提升，再加上有 Google 的背书，希望继续演进下去。尤其当前只支持 Go 语言，虽说 Go 在云原生中风生水起，当时业务开发大部分仍是 Java 技术栈。在业务开发中，Go 的受众还是相当小。

当前的版本是 v0.21.2，仍处于很早期的阶段，请谨慎对待（源码里搜了下 TODO 关键词有 100 多处）。

没有完美的架构，没有银弹！

关注"云原生指北"微信公众号 （转载本站文章请注明作者和出处乱世浮生，请勿用于任何商业用途）

这篇关于单体 or 微服务？Service Weaver：我全都要！的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/195253。

相关文章

【区块链 + 人才服务】可信教育区块链治理系统 | FISCO BCOS应用案例

【区块链 + 人才服务】可信教育区块链治理系统 | FISCO BCOS应用案例

伴随着区块链技术的不断完善，其在教育信息化中的应用也在持续发展。利用区块链数据共识、不可篡改的特性， 将与教育相关的数据要素在区块链上进行存证确权，在确保数据可信的前提下，促进教育的公平、透明、开放，为教育教学质量提升赋能，实现教育数据的安全共享、高等教育体系的智慧治理。 可信教育区块链治理系统的顶层治理架构由教育部、高校、企业、学生等多方角色共同参与建设、维护，支撑教育资源共享、教学质量评估、
阅读更多...
【区块链 + 人才服务】区块链集成开发平台 | FISCO BCOS应用案例

【区块链 + 人才服务】区块链集成开发平台 | FISCO BCOS应用案例

随着区块链技术的快速发展，越来越多的企业开始将其应用于实际业务中。然而，区块链技术的专业性使得其集成开发成为一项挑战。针对此，广东中创智慧科技有限公司基于国产开源联盟链 FISCO BCOS 推出了区块链集成开发平台。该平台基于区块链技术，提供一套全面的区块链开发工具和开发环境，支持开发者快速开发和部署区块链应用。此外，该平台还可以提供一套全面的区块链开发教程和文档，帮助开发者快速上手区块链开发。
阅读更多...
基于SpringBoot的宠物服务系统+uniapp小程序+LW参考示例

基于SpringBoot的宠物服务系统+uniapp小程序+LW参考示例

系列文章目录 1.基于SSM的洗衣房管理系统+原生微信小程序+LW参考示例 2.基于SpringBoot的宠物摄影网站管理系统+LW参考示例 3.基于SpringBoot+Vue的企业人事管理系统+LW参考示例 4.基于SSM的高校实验室管理系统+LW参考示例 5.基于SpringBoot的二手数码回收系统+原生微信小程序+LW参考示例 6.基于SSM的民宿预订管理系统+LW参考示例 7.基于
阅读更多...
Golang支持平滑升级的HTTP服务

Golang支持平滑升级的HTTP服务

前段时间用Golang在做一个HTTP的接口，因编译型语言的特性，修改了代码需要重新编译可执行文件，关闭正在运行的老程序，并启动新程序。对于访问量较大的面向用户的产品，关闭、重启的过程中势必会出现无法访问的情况，从而影响用户体验。 使用Golang的系统包开发HTTP服务，是无法支持平滑升级（优雅重启）的，本文将探讨如何解决该问题。 一、平滑升级（优雅重启）的一般思路 一般情况下，要实现平滑
阅读更多...
Golang服务平滑重启

Golang服务平滑重启

与重载配置相同的是我们也需要通过信号来通知server重启，但关键在于平滑重启，如果只是简单的重启，只需要kill掉，然后再拉起即可。平滑重启意味着server升级的时候可以不用停止业务。 我们先来看下Github上有没有相应的库解决这个问题，然后找到了如下三个库： facebookgo/grace - Graceful restart & zero downtime deploy for G
阅读更多...
Java后端微服务架构下的API限流策略：Guava RateLimiter

Java后端微服务架构下的API限流策略：Guava RateLimiter

Java后端微服务架构下的API限流策略：Guava RateLimiter 大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在微服务架构中，API限流是保护服务不受过度使用和拒绝服务攻击的重要手段。Guava RateLimiter是Google开源的Java库中的一个组件，提供了简单易用的限流功能。 API限流概述 API限流通过控制请求的速率来防止
阅读更多...
【微服务】Ribbon（负载均衡，服务调用）+ OpenFeign（服务发现，远程调用）【详解】

【微服务】Ribbon（负载均衡，服务调用）+ OpenFeign（服务发现，远程调用）【详解】

文章目录 1.Ribbon（负载均衡，服务调用）1.1问题引出1.2 Ribbon负载均衡1.3 RestTemplate整合Ribbon1.4 指定Ribbon负载均衡策略1.4.1 配置文件1.4.2 配置类1.4.3 定义Ribbon客户端配置1.4.4 自定义负载均衡策略 2.OpenFeign面向接口的服务调用（服务发现，远程调用）2.1 OpenFeign的使用2.1 .1创建
阅读更多...
UserWarning: mkl-service package failed to import

UserWarning: mkl-service package failed to import

安装完成anaconda，并设置了两个环境变量  之后再控制台运行python环境，输入import numpy as np，提示错误 D:\InstallFolder\Anaconda3\lib\site-packages\numpy\__init__.py:143: UserWarning: mkl-service package failed to import, therefore
阅读更多...
java后端服务监控与告警：Prometheus与Grafana集成

java后端服务监控与告警：Prometheus与Grafana集成

Java后端服务监控与告警：Prometheus与Grafana集成 大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在现代的微服务架构中，监控和告警是确保服务稳定性的关键组成部分。Prometheus和Grafana是两个强大的工具，它们可以集成在一起，为Java后端服务提供实时监控和可视化告警。 服务监控的重要性 服务监控可以帮助我们实时了解服务的健
阅读更多...
OpenStack离线Train版安装系列—3控制节点-Keystone认证服务组件

OpenStack离线Train版安装系列—3控制节点-Keystone认证服务组件

本系列文章包含从OpenStack离线源制作到完成OpenStack安装的全部过程。 在本系列教程中使用的OpenStack的安装版本为第20个版本Train（简称T版本），2020年5月13日，OpenStack社区发布了第21个版本Ussuri（简称U版本）。 OpenStack部署系列文章 OpenStack Victoria版 安装部署系列教程 OpenStack Ussuri版
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2