在 Go 语言微服务中如何进行服务之间的调用

于 2024-09-23 22:33:14 发布
阅读量864 收藏 5
点赞数 13
分类专栏： golang 文章标签： iphone ios golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57836225/article/details/142470391
版权

目录

在 Go 语言微服务中如何进行服务之间的调用

一、微服务架构概述

二、服务之间调用的方式

（一）HTTP 调用

（二）RPC 调用

（三）消息队列调用

三、服务发现与负载均衡

（一）服务发现

（二）负载均衡

四、总结

在微服务架构中，服务之间的调用是实现系统功能的关键环节。Go 语言以其高效、简洁的特点，在微服务开发中得到了广泛应用。本文将介绍在 Go 语言的微服务中如何进行服务之间的调用。

一、微服务架构概述

微服务架构是一种将单一应用程序拆分为多个小型服务的架构风格。每个服务都运行在自己的进程中，通过轻量级的通信机制进行交互。这种架构风格具有高可扩展性、高可用性和高灵活性等优点。

在 Go 语言中，常用的微服务框架有 [框架名称 1]、[框架名称 2] 等。这些框架提供了丰富的功能，如服务注册与发现、负载均衡、熔断机制等，方便开发者构建和管理微服务。

二、服务之间调用的方式

在 Go 语言的微服务中，服务之间的调用可以通过以下几种方式实现：

（一）HTTP 调用

  1. 使用标准库net/http包：
    • Go 语言的标准库提供了强大的 HTTP 客户端和服务器功能。可以使用http.Get、http.Post等函数发起 HTTP 请求，调用其他服务的接口。
    • 例如：

     resp, err := http.Get("http://other-service-url/api/endpoint")
     if err!= nil {
        log.Fatal(err)
     }
     defer resp.Body.Close()
     body, err := ioutil.ReadAll(resp.Body)
     if err!= nil {
        log.Fatal(err)
     }
     fmt.Println(string(body))

  1. 使用第三方 HTTP 客户端库：
    • 除了标准库，还有很多优秀的第三方 HTTP 客户端库，如Golang 的流行 HTTP 客户端库名称等。这些库提供了更多的功能和灵活性，如连接池、超时控制、重试机制等。
    • 例如：
     client := NewHttpClient()
     resp, err := client.Get("http://other-service-url/api/endpoint")
     if err!= nil {
        log.Fatal(err)
     }
     defer resp.Body.Close()
     body, err := ioutil.ReadAll(resp.Body)
     if err!= nil {
        log.Fatal(err)
     }
     fmt.Println(string(body))

（二）RPC 调用

  1. 使用gRPC：
    • gRPC是一种高性能、开源的远程过程调用（RPC）框架。它使用 Protocol Buffers 作为接口定义语言（IDL），可以在不同的编程语言之间进行高效的通信。
    • 在 Go 语言中，可以使用google.golang.org/grpc包来实现gRPC服务。首先，定义服务接口和消息类型，然后使用 Protocol Buffers 编译器生成代码。接着，实现服务端和客户端代码，进行 RPC 调用。
    • 例如：
      • 定义服务接口：

       syntax = "proto3";

       package service;

       service MyService {
          rpc MyMethod(MyRequest) returns (MyResponse) {}
       }

       message MyRequest {
          string name = 1;
       }

       message MyResponse {
          string message = 1;
       }

  • 生成代码：

       protoc --go_out=. --go-grpc_out=. myservice.proto

  • 实现服务端：

       package main

       import (
          "log"
          "net"

          "google.golang.org/grpc"
          pb "path/to/generated/proto/package"
       )

       type server struct {
          pb.UnimplementedMyServiceServer
       }

       func (s *server) MyMethod(ctx context.Context, in *pb.MyRequest) (*pb.MyResponse, error) {
          return &pb.MyResponse{Message: "Hello, " + in.Name}, nil
       }

       func main() {
          lis, err := net.Listen("tcp", ":50051")
          if err!= nil {
             log.Fatalf("failed to listen: %v", err)
          }
          s := grpc.NewServer()
          pb.RegisterMyServiceServer(s, &server{})
          if err := s.Serve(lis); err!= nil {
             log.Fatalf("failed to serve: %v", err)
          }
       }

  • 实现客户端：
       package main

       import (
          "log"

          "google.golang.org/grpc"
          pb "path/to/generated/proto/package"
       )

       func main() {
          conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
          if err!= nil {
             log.Fatalf("did not connect: %v", err)
          }
          defer conn.Close()
          c := pb.NewMyServiceClient(conn)
          r, err := c.MyMethod(context.Background(), &pb.MyRequest{Name: "World"})
          if err!= nil {
             log.Fatalf("could not call MyMethod: %v", err)
          }
          log.Printf("Response: %s", r.Message)
       }

  1. 使用其他 RPC 框架：
    • 除了gRPC，还有一些其他的 RPC 框架可供选择，如Thrift、Dubbo-go等。这些框架各有特点，可以根据项目需求进行选择。

（三）消息队列调用

  1. 使用消息队列的好处：
    • 解耦服务：通过消息队列，服务之间可以实现松耦合，一个服务的故障不会影响其他服务的正常运行。
    • 异步通信：消息队列可以实现异步通信，提高系统的性能和响应速度。
    • 流量削峰：在高并发场景下，消息队列可以缓冲请求，避免服务过载。
  2. 使用 Go 语言的消息队列库：
    • Go 语言有很多优秀的消息队列库，如RabbitMQ的 Go 客户端库amqp、Kafka的 Go 客户端库Sarama等。
    • 例如，使用RabbitMQ进行服务之间的调用：
      • 发送消息：
       package main

       import (
          "log"

          "github.com/streadway/amqp"
       )

       func main() {
          conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
          if err!= nil {
             log.Fatalf("failed to connect to RabbitMQ: %v", err)
          }
          defer conn.Close()
          ch, err := conn.Channel()
          if err!= nil {
             log.Fatalf("failed to open a channel: %v", err)
          }
          defer ch.Close()
          q, err := ch.QueueDeclare(
             "myqueue",
             false,
             false,
             false,
             false,
             nil,
          )
          if err!= nil {
             log.Fatalf("failed to declare a queue: %v", err)
          }
          body := "Hello, World!"
          err = ch.Publish(
             "",
             q.Name,
             false,
             false,
             amqp.Publishing{
                ContentType: "text/plain",
                Body:        []byte(body),
             },
          )
          if err!= nil {
             log.Fatalf("failed to publish a message: %v", err)
          }
          log.Printf("Sent: %s", body)
       }

  • 接收消息：

       package main

       import (
          "log"

          "github.com/streadway/amqp"
       )

       func main() {
          conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
          if err!= nil {
             log.Fatalf("failed to connect to RabbitMQ: %v", err)
          }
          defer conn.Close()
          ch, err := conn.Channel()
          if err!= nil {
             log.Fatalf("failed to open a channel: %v", err)
          }
          defer ch.Close()
          q, err := ch.QueueDeclare(
             "myqueue",
             false,
             false,
             false,
             false,
             nil,
          )
          if err!= nil {
             log.Fatalf("failed to declare a queue: %v", err)
          }
          msgs, err := ch.Consume(
             q.Name,
             "",
             true,
             false,
             false,
             false,
             nil,
          )
          if err!= nil {
             log.Fatalf("failed to register a consumer: %v", err)
          }
          forever := make(chan bool)
          go func() {
             for d := range msgs {
                log.Printf("Received: %s", d.Body)
             }
          }()
          log.Printf("Waiting for messages. To exit press CTRL+C")
          <-forever
       }

三、服务发现与负载均衡

在微服务架构中，服务的实例数量可能会动态变化，因此需要进行服务发现和负载均衡，以确保服务之间的调用能够正确地路由到可用的服务实例上。

（一）服务发现

  1. 使用服务注册中心：
    • 服务注册中心是一个存储服务实例信息的中心节点。服务在启动时向注册中心注册自己的信息，其他服务可以从注册中心获取可用的服务实例列表。
    • Go 语言的微服务框架通常会提供对服务注册中心的支持，如Consul、Etcd、Zookeeper等。
    • 例如，使用Consul进行服务发现：
      • 服务注册：

       package main

       import (
          "log"
          "net/http"

          "github.com/hashicorp/consul/api"
       )

       func main() {
          // 创建 Consul 客户端
          client, err := api.NewClient(api.DefaultConfig())
          if err!= nil {
             log.Fatalf("failed to create Consul client: %v", err)
          }
          // 注册服务
          registration := &api.AgentServiceRegistration{
             ID:      "my-service",
             Name:    "my-service",
             Address: "localhost",
             Port:    8080,
             Check: &api.AgentServiceCheck{
                HTTP:     "http://localhost:8080/health",
                Interval: "10s",
             },
          }
          err = client.Agent().ServiceRegister(registration)
          if err!= nil {
             log.Fatalf("failed to register service with Consul: %v", err)
          }
          // 启动 HTTP 服务
          http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
             w.Write([]byte("Hello, World!"))
          })
          log.Fatal(http.ListenAndServe(":8080", nil))
       }

  • 服务发现：

       package main

       import (
          "log"
          "net/http"

          "github.com/hashicorp/consul/api"
       )

       func main() {
          // 创建 Consul 客户端
          client, err := api.NewClient(api.DefaultConfig())
          if err!= nil {
             log.Fatalf("failed to create Consul client: %v", err)
          }
          // 获取服务实例列表
          services, _, err := client.Health().Service("my-service", "", true, nil)
          if err!= nil {
             log.Fatalf("failed to get service instances from Consul: %v", err)
          }
          if len(services) == 0 {
             log.Fatalf("no service instances found")
          }
          // 选择一个服务实例
          service := services[0]
          // 调用服务
          resp, err := http.Get("http://" + service.Service.Address + ":" + strconv.Itoa(service.Service.Port))
          if err!= nil {
             log.Fatalf("failed to call service: %v", err)
          }
          defer resp.Body.Close()
          body, err := ioutil.ReadAll(resp.Body)
          if err!= nil {
             log.Fatalf("failed to read response body: %v", err)
          }
          log.Println(string(body))
       }

（二）负载均衡

  1. 客户端负载均衡：
    • 客户端负载均衡是指在客户端实现负载均衡算法，选择一个可用的服务实例进行调用。
    • Go 语言的微服务框架通常会提供客户端负载均衡的功能，如gRPC的RoundRobin负载均衡策略。
    • 例如，使用gRPC的客户端负载均衡：

     package main

     import (
        "log"

        "google.golang.org/grpc"
        pb "path/to/generated/proto/package"
     )

     func main() {
        conn, err := grpc.Dial("my-service", grpc.WithInsecure(), grpc.WithBalancerName("round_robin"))
        if err!= nil {
           log.Fatalf("did not connect: %v", err)
        }
        defer conn.Close()
        c := pb.NewMyServiceClient(conn)
        r, err := c.MyMethod(context.Background(), &pb.MyRequest{Name: "World"})
        if err!= nil {
           log.Fatalf("could not call MyMethod: %v", err)
        }
        log.Printf("Response: %s", r.Message)
     }

  1. 服务端负载均衡：
    • 服务端负载均衡是指在服务端实现负载均衡算法，将请求分发到不同的服务实例上。
    • 可以使用反向代理服务器（如Nginx、HAProxy等）来实现服务端负载均衡。

四、总结

在 Go 语言的微服务中，服务之间的调用可以通过 HTTP 调用、RPC 调用和消息队列调用等方式实现。同时，需要进行服务发现和负载均衡，以确保服务之间的调用能够正确地路由到可用的服务实例上。选择合适的调用方式和服务发现负载均衡策略，需要根据项目的需求和特点进行综合考虑。

希望本文对大家在 Go 语言微服务中进行服务之间的调用有所帮助。

以上是一篇关于在 Go 语言微服务中如何进行服务之间调用的博客文章，你可以根据实际情况进行调整和完善。

阿贾克斯的黎明
关注
专栏目录
Go语言在微服务架构中的应用探索
AI天才研究院
04-03 846
Go语言在微服务架构中的应用探索 作者：禅与计算机程序设计艺术 1. 背景介绍 在当今快速发展的互联网时代,微服务架构已经成为构建可扩展、高度可靠和敏捷的应用程序的主流方法。与单体应用程序相比,微服务架构提供了更好的可维护性、可伸缩性和可部署性。其中,Go语言凭借其出色的性能
Go语言的微服务架构
AI天才研究院
02-18 158
1. 背景介绍 1.1 微服务架构的兴起 随着互联网技术的快速发展，企业和开发者们面临着越来越复杂的应用场景和需求。传统的单体应用架构已经无法满足这些需求，因此微服务架构应运而生。微服务架构通过将一个大型应用拆分成多个独立的、可独立部署和扩展的小型服务，从而提高了系统的可维护性、可扩展性和灵活性。
golang使用grpc实现服务调用(入门级一)
小飞哥的博客
08-07 895
golang使用grpc实现服务调用(一) 学习目标 grpc 了解 protobuf 了解 老样子 首先日常三问： 3. 什么是grpc？ 在官方文档也有什么一句提问:(Why gRPC?) 以下是官方做的解释： gRPC is a modern open source high performance Remote Procedure Call (RPC) framework that can run in any environment. It can efficiently co
Go微服务: 基于net/rpc/jsonrpc模块实现微服务跨语言调用
Wang的专栏
03-08 1303
Golang 提供库来实现rpc方法采用 json 方式进行数据编解码，支持跨语言调用这里演示了，基于go语言为服务端，nodejs 和 golang 为客户端的3种示范注意，上面 nodejs版本中的 params 的格式与 golang 中的区别标准库的RPC默认采用Go语言特有的gob编码，没法实现跨语言调用golang官方还提供了 net/rpc/jsonrpc 库实现RPC方法JSON RPC采用JSON进行数据编解码，因而支持跨语言调用。
Go微服务: 基于Go Micro框架实现微服务调用
Wang的专栏
03-10 1484
在具体的项目开发过程中，开发者聚焦的是业务逻辑的开发和功能的实现 大量的环境配置，调试搭建等基础性工作会耗费相当一部分的精力 因此有必要将微服务架构中所涉及到的，相关的解决方案做集中管理和维护 Go Micro 帮助我们解决了大部分上述问题，它是一个简化分布式开发的微服务生态系统 该系统为开发分布式应用程序提供了高效，便捷的模块构建, 主要目的是简化分布式系统的开发 它默认实现了consul 作为服务发现，通过http进行通信，通过protobuf和json进行编解码
调用http_Go教程34:Go微服务间Http+Json调用
weixin_39689687的博客
12-04 196
这篇文章你可以学习到Go使用Http 客户端调用Go语言序列化或反序列化Json1. Go使用Http 客户端调用package utilimport ("apigate/logger""encoding/json""io/ioutil""net/http""strings""time")const (JsonType = "application/json"timeOut = 5 * time....
golang之微服务系列2
weixin_50134791的博客
06-17 515
什么是服务雪崩？ 在调用微服务的过程中，如果下层的微服务挂掉了，如果没有超时机制，会导致上层微服务调用失败，阻塞，得不到返回。引起从下到上，一连串的服务崩掉 如图，如果H挂掉，上层所有服务都会挂掉，最终演变成下图这样 如何避免服务雪崩？ 超时机制 在调用微服务一段时间得不到返回时，必须设置超时时间，比如300ms，无论是否调用成功，必须返回 重试机制 如果调用超时，为了用户体验，必须进行重试，重试如果正常返回，那么这个请求就被挽救了，能够正常给前端数据，只是慢一些 重试机制会引发什么问题？ 重试机制会
Go语言与微服务架构教程
07-14
在Go语言中，函数是程序的基本执行单元，可以接受参数并返回结果。而方法则是与特定类型关联的函数，通过类型接收者来调用。 例如： ```go package main import "fmt" // 函数 func add(x, y int) int { return x...
罗辑思维Go语言微服务改造实践.pdf
09-20
罗辑思维公司在技术转型升级的过程中，选择了Go语言进行微服务改造，这一过程的详细实践和经验被记录在《罗辑思维Go语言微服务改造实践》的文件中。接下来，我们将详细探讨文件中提到的各个知识点。 首先，罗辑思维...
服务mesh技术在Go语言微服务中的应用
在微服务架构中，服务mesh是一种用于管理不同微服务之间通信的专用基础设施层。它处理了诸如服务发现、负载均衡、安全性、监控等与服务通信相关的复杂任务，使开发人员可以专注于业务逻辑而不是底层通信。 ## 1.2 ...
GO语言实现rpc服务调用
July_whj
09-08 1121
RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求 服务，而不需要了解底层网络技术的协议。 简单来说，就是跟远程访问或者web请求差不多，都是一个client向远端服务器请求服务返回结果，但是web请求 使用的网络协议是http高层协议，而rpc所使用的协议多为TCP，是网络层协议，减少了信息的包装，加快了处理速 度...
GO语言：微服务--定义和标准
最新发布
2401_87019212的博客
09-07 1001
另外，一般微服务在系统内部，通常是无状态的，而我们的用户在进行业务操作时，往往是跨业务模块进行操作，且需要是有状态的，在此时的这个系统架构中，也无法解决这个问题。服务调用者通过服务管理框架进行寻址，根据特定的算法，找到对应的服务，或者将服务的注册信息缓存到本地，这样提高性能。异步消息的方式在分布式系统中有特别广泛的应用，他既能减低调用服务之间的耦合，又能成为调用之间的缓冲，确保消息积压不会冲垮被调用方，同时能保证调用方的服务体验，继续干自己该干的活，不至于被后台性能拖慢。这就是服务的发现、识别与管理问题。
[转载]IOS开发系列之阿堂教程:玩转IPhone客户端和Web服务端交互(客户端_技术成长笔记_新浪博客...
u010783713的专栏
12-15 214
原文地址：IOS开发系列之阿堂教程:玩转IPhone客户端和Web服务端交互(客户端)实践作者：时空网络 说到ios的应用开发，我们不能不提到web server服务端，如果没有服务端的支持,ios应用开发就没有多大意义了，因为从事过手机开发的朋友都知道(Android也一样)，大量复杂业务的处理和数据库的处理，其实大部分都是在服务端来完成的，因为iphone客户端的资源是非常有限的...
微服务服务间调用方式
热门推荐
淺雨吖的博客
10-21 1万+
服务间调用的方式，RestTemplate|OpenFeign介绍，一文包含OpenFeign和RestTemplate的基础内容
Go 云原生应用实战系列（二）
微服务技术与实践专栏
09-14 356
本章节我将专注于开发第一个微服务系统，我们将学会如何用go chassis开发微服务并完成微服务之间的调用 开发你的第一个微服务 启动注册中心 docker run -d -p 30100:30100 servicecomb/service-center 强烈推荐直接使用all in one的docker compose模板启动，因为可以使用可视化的UI界面。  https://github.com/go-chassis/go-chassis/blob/master/examp..
Go语言：REST Web服务调用
yushulx的专栏
02-21 4127
Dynamsoft部署了基于REST的条形码服务。这里分享下如何使用Go语言发送包含BASE64图像数据的HTTP POST请求。 环境配置 IDE: JetBrain Gogland.Go 1.7.4.Windows 10.工作目录结构: - src - bin - pkg   Go设置： GOROOT=E:\Go GOPATH=g:\gowork
php与go服务之间调用,PHP调用Go服务的正确方式 - Unix Domain Sockets
weixin_36371504的博客
04-10 392
原标题：PHP调用Go服务的正确方式 - Unix Domain Sockets作者：枕边书链接：http://www.cnblogs.com/zhenbianshu/p/7265415.html來源：博客园共 5043字，阅读需 13分钟问题可能是由于经验太少，工作中经常会遇到问题，探究和解决问题的过程总想记录一下，所以我写博客经常是问题驱动，首先介绍一下今天要解决的问题：服务耦合我们在开发过程...
微服务互相调用
ss123mlk的博客
03-23 1415
微服务互相调用 服务A 调用远程服务B feign 为了彼此发现 大家要一同注册到NAOCS 在各服务的配置文件中配置相同的注册中心地址 引入open-feign maven坐标 并都在启动类上开启服务注册和发现功能 注解@EnableDiscoverClient使其他服务可以发现自己 在服务A 中创建feign包 在包下创建接口 声明式的远程调用 声明注解@FeignClient（） 调用那个远程服务的 想调用服务B的什么方法 就照搬服务B该方法的完整请求路径 （服务B的类的mapping+方法m
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值