当前位置：首页 > PHP教程 > php高级应用 > 列表

go-micro+php+consul实现简单的微服务

发布:smiling　来源: PHP粉丝网 　添加日期：2022-05-28 09:21:13　浏览: 评论：0　

首先我们用go-micro构建一个服务，关于go-micro的使用可以参照官方实例或者文档。

//新建一个微服务

micro new --type "srv" user-srv

定义我们的服务，这里定义两个rpc服务，Register和User

  1. // 修改proto 
  2.  
  3. syntax = "proto3"; 
  4.  
  5. package go.micro.srv.user; 
  6.  
  7. service User { 
  8.  
  9.     rpc Register(RegisterRequest) returns (UserInfo) {} 
  10.  
  11.     rpc User(UserInfoRequest) returns (UserInfo) {} 
  12.  
  13.     rpc Stream(StreamingRequest) returns (stream StreamingResponse) {} 
  14.  
  15.     rpc PingPong(stream Ping) returns (stream Pong) {} 
  16.  
  17. } 
  18.  
  19.  
  20. message UserInfoRequest { 
  21.  
  22.     int64 userId  = 1; 
  23.  
  24. } 
  25.  
  26.  
  27. message RegisterRequest { 
  28.  
  29.     string username  = 1; 
  30.  
  31.     string email     = 2; 
  32.  
  33.     string password  = 3; 
  34.  
  35. } 
  36.  
  37.  
  38.  
  39. message UserInfo { 
  40.  
  41.     int64  id       =  1; 
  42.  
  43.     string username =  2; 
  44.  
  45.     string email    =  3; 
  46.  
  47. } 
  48.  
  49.  
  50. message StreamingRequest { 
  51.  
  52.     int64 count = 1; 
  53.  
  54. } 
  55.  
  56.  
  57. message StreamingResponse { 
  58.  
  59.     int64 count = 1; 
  60.  
  61. } 
  62.  
  63.  
  64. message Ping { 
  65.  
  66.     int64 stroke = 1; 
  67.  
  68. } 
  69.  
  70.  
  71. message Pong { 
  72.  
  73.     int64 stroke = 1; 
  74.  
  75. } 

然后生成执行下面命令我们就可以发现在proto文件中多出两个文件，这个proto为我们生成的，后面会用到。

protoc --proto_path=${GOPATH}/src:. --micro_out=. --go_out=. proto/user/user.proto

写我们的业务逻辑，修改handle/user.go文件

  1. type User struct{} 
  2.  
  3. // Call is a single request handler called via client.Call or the generated client code 
  4.  
  5. func (e *User) Register(ctx context.Context, req *user.RegisterRequest, rsp *user.UserInfo) error { 
  6.  
  7.     log.Log("Received User.Register request") 
  8.  
  9.     rsp.Id    = 1 
  10.  
  11.     rsp.Email = req.Email 
  12.  
  13.     rsp.Username = req.Username 
  14.  
  15.     return nil 
  16.  
  17. } 
  18.  
  19.  
  20.  
  21.  
  22.  
  23. func (e *User) User(ctx context.Context, req *user.UserInfoRequest, rsp *user.UserInfo) error { 
  24.  
  25.     log.Log("Received User.Register request") 
  26.  
  27.     rsp.Id    = 1 
  28.  
  29.     rsp.Email = "741001560@qq.com" 
  30.  
  31.     rsp.Username = "chensi" 
  32.  
  33.     return nil 
  34.  
  35. } 
  36.  
  37.  
  38.  
  39. // Stream is a server side stream handler called via client.Stream or the generated client code 
  40.  
  41. func (e *User) Stream(ctx context.Context, req *user.StreamingRequest, stream user.User_StreamStream) error { 
  42.  
  43.     log.Logf("Received User.Stream request with count: %d", req.Count) 
  44.  
  45.  
  46.  
  47.     for i := 0; i < int(req.Count); i++ { 
  48.  
  49.         log.Logf("Responding: %d", i) 
  50.  
  51.         if err := stream.Send(&user.StreamingResponse{ 
  52.  
  53.             Count: int64(i), 
  54.  
  55.         }); err != nil { 
  56.  
  57.             return err 
  58.  
  59.         } 
  60.  
  61.     } 
  62.  
  63.  
  64.  
  65.     return nil 
  66.  
  67. } 
  68.  
  69.  
  70.  
  71. // PingPong is a bidirectional stream handler called via client.Stream or the generated client code 
  72.  
  73. func (e *User) PingPong(ctx context.Context, stream user.User_PingPongStream) error { 
  74.  
  75.     for { 
  76.  
  77.         req, err := stream.Recv() 
  78.  
  79.         if err != nil { 
  80.  
  81.             return err 
  82.  
  83.         } 
  84.  
  85.         log.Logf("Got ping %v", req.Stroke) 
  86.  
  87.         if err := stream.Send(&user.Pong{Stroke: req.Stroke}); err != nil { 
  88.  
  89.             return err 
  90.  
  91.         } 
  92.  
  93.     } 
  94.  
  95. } 

最后修改我们的main.go文件，服务发现使用时consul。

  1. func main() { 
  2.  
  3.     //initCfg() 
  4.  
  5.     // New Service 
  6.  
  7.     micReg := consul.NewRegistry() 
  8.  
  9.     service := micro.NewService( 
  10.  
  11.         micro.Server(s.NewServer()), 
  12.  
  13.         micro.Name("go.micro.srv.user"), 
  14.  
  15.         micro.Version("latest"), 
  16.  
  17.         micro.Registry(micReg), 
  18.  
  19.     ) 
  20.  
  21.     // Initialise service 
  22.  
  23.     service.Init() 
  24.  
  25.     // Run service 
  26.  
  27.     if err := service.Run(); err != nil { 
  28.  
  29.         log.Fatal(err) 
  30.  
  31.     } 
  32.  
  33. } 

我们使用consul做微服务发现，当然首先你需要安装consul

wget https://releases.hashicorp.com/consul/1.2.0/consul_1.6.1_linux_amd64.zip

unzip consul_1.6.1_linux_amd64.zip

mv consul /usr/local/bin/

启动consul的时候由于在是本地虚拟机上面，所以我们可以简单处理

consul agent -dev  -client 0.0.0.0 -ui

这时候可以启动consul的ui了，我本地vagrant的虚拟机192.168.10.100，那么我们打开的是http://192.168.10.100:8500/ui/dc1/services

启动user-srv的服务发现consul里面出现 go.micro.srv.user 的服务注册信息了。

下面来写hyperf的代码了。按照官方文档安装框架，安装的时候rpc需要选择grpc，需要注意的是你的系统上面需要安装php7.2以上的版本，swoole版本也需要4.3的版本以上，我用的是最新homestead，所以相对而言安装这些依赖比较简单，所以在此强烈推荐。

第一次启动时候官方会要求修改一些php.ini的参数，大家安装要求走就是了。

这部分的流程自己参照官方文档，至于一些扩展的安装可以谷歌或者百度。

安装好框架之后再根目录下面新建一个grpc和proto的目录，把go-micro里面user.proto文件复制到hyperf项目的proto的目录之下。然后在目录下执行命令

protoc --php_out=plugins=grpc:../grpc user.proto

执行成功之后会发现在grpc目录下多出两个文件夹。

接下来我们开始编写client的代码，在hyperf项目的app目录下新建一个Grpc的目录并且新建一个UserClient.php的文件

  1. namespace App\Grpc; 
  2. use Go\Micro\Srv\User\RegisterRequest; 
  3.  
  4. use Go\Micro\Srv\User\UserInfo; 
  5.  
  6. use Hyperf\GrpcClient\BaseClient; 
  7.  
  8.  
  9.  
  10. class UserClient extends BaseClient 
  11.  
  12. { 
  13.  
  14.     public function Register(RegisterRequest $argument) 
  15.  
  16.     { 
  17.  
  18.         return $this->simpleRequest( 
  19.  
  20.             '/user.User/Register', 
  21.  
  22.             $argument, 
  23.  
  24.             [UserInfo::class, 'decode'] 
  25.  
  26.         ); 
  27.  
  28.     } 

关于这一块的代码，其实官方文档写得特别详细，具体可以参照官方文档。

新建一个路由

Router::addRoute(['GET', 'POST', 'HEAD'], '/grpc', 'App\Controller\IndexController@grpc');

编写控制器

  1. public function grpc () 
  2.  
  3. { 
  4.  
  5.  
  6.  
  7.         $client = new \App\Grpc\UserClient('127.0.0.1:9527', [ 
  8.  
  9.             'credentials' => null, 
  10.  
  11.         ]); 
  12.  
  13.  
  14.  
  15.         $request = new RegisterRequest(); 
  16.  
  17.         $request->setEmail("741001560@qq.com"); 
  18.  
  19.         $request->setUsername("chensi"); 
  20.  
  21.         $request->setPassword("123456"); 
  22.  
  23.  
  24.  
  25.         /** 
  26.  
  27.          * @var \Grpc\HiReply $reply 
  28.  
  29.          */ 
  30.  
  31.         list($reply, $status) = $client->Register($request); 
  32.  
  33.  
  34.  
  35.         $message = $reply->getId(); 
  36.  
  37.         return [ 
  38.  
  39.             'id' => $message 
  40.  
  41.         ]; 
  42.  
  43.     } 

这时候还需要吧根目录下的grpc目录加载进来。修改composer.json文件

  1. // psr-4 下面新增两个行 
  2.  
  3. "autoload": { 
  4.  
  5.         "psr-4": { 
  6.  
  7.             "App\\": "app/", 
  8.  
  9.             "GPBMetadata\\": "grpc/GPBMetadata", 
  10.  
  11.             "Go\\": "grpc/Go" 
  12.  
  13.         }, 
  14.  
  15.         "files": [] 
  16.  
  17.     } 

然后执行composer dump-autoload命令。然后启动hyperf项目，打开浏览器输入http://192.168.10.100:9501/grpc回车，这时候我们就能看到结果了。

这时候我们会发现一个问题，那就是consul在client端压根没用到，在代码中我们还是需要指明我们的端口号。然后再看看官方文档其实是支持consul的，那么将代码改造下。

在app下新建一个Register的目录创建一个文件ConsulServices.php，然后开始编写服务发现的代码，安装consul包以后，由于官方提供的consul包没有文档所以需要自己去看源代码。官方在consul提供的api上面做了简单的封装，如KV、Health等，在实例化话的时候需要穿一个客户端过去。下面提供一个简单的实例。

  1. <?php 
  2.  
  3. declare(strict_types=1); 
  4.  
  5.  
  6.  
  7. namespace App\Register; 
  8.  
  9.  
  10.  
  11. use Hyperf\Consul\Health; 
  12.  
  13. use Psr\Container\ContainerInterface; 
  14.  
  15. use Hyperf\Guzzle\ClientFactory; 
  16.  
  17.  
  18.  
  19. class ConsulServices 
  20.  
  21. { 
  22.  
  23.  
  24.  
  25.     public $servers; 
  26.  
  27.     private $container; 
  28.  
  29.  
  30.  
  31.  
  32.  
  33.     public function __construct(ContainerInterface $container) 
  34.  
  35.     { 
  36.  
  37.         $this->container = $container; 
  38.  
  39.     } 
  40.  
  41.  
  42.  
  43.     public function getServers() 
  44.  
  45.     { 
  46.  
  47.         $health = new Health(function ()  { 
  48.  
  49.             return $this->container->get(ClientFactory::class)->create([ 
  50.  
  51.                 'base_uri' => 'http://127.0.0.1:8500', 
  52.  
  53.             ]); 
  54.  
  55.         }); 
  56.  
  57.         $resp = $health->service("go.micro.srv.user"); 
  58.  
  59.         $servers = $resp->json(); 
  60.  
  61.         if (emptyempty($servers)){ 
  62.  
  63.             $this->servers = []; 
  64.  
  65.         } 
  66.  
  67.         foreach ($servers as $server) { 
  68.  
  69.             $this->servers[] = sprintf("%s:%d",$server['Service']['Address'],$server['Service']['Port']); 
  70.  
  71.         } 
  72.  
  73.     } 
  74.  
  75. } 

这时候发现一个问题如果每次请求过来都去请求一次必然给consul造成很大的负荷。既然用到了swoole框架可以在每次swoole启动的时候去请求一次，然后把服务发现的信息存起来。修改配置文件server。

  1. 'callbacks' => [ 
  2.  
  3. //        SwooleEvent::ON_BEFORE_START => [Hyperf\Framework\Bootstrap\ServerStartCallback::class, 'beforeStart'], 
  4.  
  5.         SwooleEvent::ON_BEFORE_START => [\App\Bootstrap\ServerStartCallback::class, 'beforeStart'], 
  6.  
  7.         SwooleEvent::ON_WORKER_START => [Hyperf\Framework\Bootstrap\WorkerStartCallback::class, 'onWorkerStart'], 
  8.  
  9.         SwooleEvent::ON_PIPE_MESSAGE => [Hyperf\Framework\Bootstrap\PipeMessageCallback::class, 'onPipeMessage'], 
  10.  
  11.     ], 

可以在ServerStartCallback类里面请求consul进行服务发现 后面拿到参数就好了。

  1. namespace App\Bootstrap; 
  2.  
  3. use App\Register\ConsulServices; 
  4.  
  5. class ServerStartCallback 
  6.  
  7. { 
  8.  
  9.     public function beforeStart() 
  10.  
  11.     { 
  12.  
  13.         $container = \Hyperf\Utils\ApplicationContext::getContainer(); 
  14.  
  15.         $container->get(ConsulServices::class)->getServers(); 
  16.  
  17.     } 
  18.  
  19. } 

改造一下原来的控制器

  1. public function grpc () 
  2.  
  3. { 
  4.  
  5.  
  6.  
  7.         $container = \Hyperf\Utils\ApplicationContext::getContainer(); 
  8.  
  9.         $servers = $container->get(ConsulServices::class)->servers; 
  10.  
  11.         if (emptyempty($servers)) { 
  12.  
  13.             return [ 
  14.  
  15.                 'errCode' => 1000, 
  16.  
  17.                 'msg'     => '服务不存在', 
  18.  
  19.             ]; 
  20.  
  21.         } 
  22.  
  23.         $key = array_rand($servers,1); // 哈哈哈一个简单的负载均衡 
  24.  
  25.         $hostname = $servers[$key]; 
  26.  
  27.         $client = new \App\Grpc\UserClient($hostname, [ 
  28.  
  29.             'credentials' => null, 
  30.  
  31.         ]); 
  32.  
  33.         $request = new RegisterRequest(); 
  34.  
  35.         $request->setEmail("741001560@qq.com"); 
  36.  
  37.         $request->setUsername("chensi"); 
  38.  
  39.         $request->setPassword("123456"); 
  40.  
  41.  
  42.  
  43.         /** 
  44.  
  45.          * @var \Grpc\HiReply $reply 
  46.  
  47.          */ 
  48.  
  49.         list($reply, $status) = $client->Register($request); 
  50.  
  51.  
  52.  
  53.         $message = $reply->getId(); 
  54.  
  55.         return [ 
  56.  
  57.             'id' => $message 
  58.  
  59.         ]; 
  60.  
  61.     } 

重启服务，这时候然后刷新浏览器试试，这时候一个简单基于go rpc server和php client的微服务就搭建完成了，当然了这时候还没有心跳机制，hyperf官网提供了一个定时器的功能，我们定时去刷服务发现就好了。

Tags: go-micro+php+consul

分享到：

推荐文章

热门文章

最新评论文章