(77条消息) hyperf搭建与使用RPC微服务_iphone元的博客-CSDN博客_hyperf rpc

[he426100]

---

首先，微服务是一种思想，是一种将单个应用程序开发成为一组小服务得方法，每个小服务都在自己的进程中运行并与轻量化机制（通常是 HTTP 资源 API）进行通讯。这些服务围绕着业务功能构建，并且可以由全自动部署机制独立部署。

---

1、一开始

最初的需求：一开始的需求是相当的简单，只需做一个简单的网上商城并挂在公网上就可以赚钱了。这个时候如下图的架构即可满足要求。

2、随着业务发展…

这个时候需要加入数据分析以及移动端相关开发模块。

可以看出，这个阶段存在许多不合理的地方：
移动端和网站有许多同样冗余的代码。
单个应用为了为其他应用提供接口，包含了很多不属于它的逻辑。
所有的应用都在一个数据库上操作，数据库出现性能瓶颈。特别是数据分析跑起来的时候，数据库性能急剧下降。

3、改造…

随着问题的逐渐增多，需要进行微服务改造，需要对项目冗余的代码进行抽象整理出来。微服务改造实际上也是一个抽象的功能，

但是这样子会有一个问题，数据库是共用的，随着时间的推移，总会有一个服务直接从数据库取另一个服务数据的现象。
如果一直保持共用数据库的模式，则整个架构会越来越僵化，失去了架构的意义。所以在这里我们一并把数据库进行拆分。如下图

这种单体应用程序是最自然的构建系统的方式，所有请求的处理都到单体应用程序的进程内，采用应用程序开发语言的基本特性把它拆分成不同的包、类和函数中从而实现模块化，可以在开发者的便携机上开发和测试单体应用。可以采用部署流水线把测试后的应用程序部署到生产环境中，可以增加更多负载均衡器后面的实例数量来水平的扩展服务能力。

单体应用程序可以做的很好，但人们也越来越发现问题，尤其是把应用程序部署到云上以后。变更被捆绑在一起，单体应用程序中一个小的改变都需要整个程序重新部署，时间长了保持模块化的架构也会比较困难，本应影响一个模块的变更也很难做到仅影响单个模块。单个模块的伸缩需要整个程序来伸缩，这也导致需要更多的资源。这些问题就导致了人们自然而然地想到了微服务架构，把程序构建成一系列服务，每个服务可以独立部署和伸缩，每个服务也定义了清晰的边界，不同的服务可以采用不同的语言编写，不同的团队来维护。

正是单体架构的这些问题，才使得微服务风格的架构得以发展，微服务除了服务是可独立部署、可独立扩展的之外，每个服务都提供一个固定的模块边界。甚至允许不同的服务用不同的的语言开发，由不同的团队管理。下面文章探讨一下微服务所具有的共同特征。

1、稳定性下降。服务数量变多导致其中一个服务的概率变大，并且一个服务故障可能导致整个系统崩溃。事实上，在大访问前提下，故障总会出现的。
2、微服务架构整个应用分散服务，定位故障点非常困难。
3、测试方面：服务拆分后，几乎所有功能都会涉及多个服务。原本单个程序的测试变为服务间调用的测试。测试变得更加复杂。

解决方案：
①尽量减少故障发生的概率
②降低故障造成的影响。

1. 概念

顾名思义，PPC 是 Remote Procedure Call Protocol 的缩写，既远程过程调用。

RPC 框架，要向调用方屏蔽各种复杂性，要向服务提供方也屏蔽各类复杂性：

1、服务调用方 client 感觉就像调用本地函数一样，来调用服务。
2、服务提供方 server 感觉就像实现一个本地函数一样，来实现服务。

2、RPC 或者 RESTful API

RPC 就用于调用者与服务之间的通讯，RPC 协议可基于 TCP、UDP 或者 HTTP 实现，但是更推荐选择 TCP。

1、TCP 的支持保持连接，当调用服务的时候不需要每次都进行三次握手才实现。从性能和网络消耗来说 RPC 都具备了很好的优势。
2、RESTful API 基于 HTTP 的，也就是说每次调用服务都需要进行三次握手建立起通信才可以实现调用，当我们的并发量高的时候这就会浪费很多带宽资源

服务对外的话采用 RESTful API 会比 RPC 更具备优势，因此看自己团队的服务是对内还是对外

3、使用 hyperf 框架搭建 RPC 服务

1、hyperf 给我们提供了 RPC 的底层服务，我们并不需要去关心底层通讯细节和调用的过程。
2、hyperf 通过定义接口，实现接口，启动 RPC Server 提供接口服务。我们只需要简单的写好几个类就可以实现一个简单 RPC 模块。

搭建环境：

一、分别在两台虚拟机上搭建两套 hyperf 环境。
搭建过程：

centor7 下安装 docker

 yum -y install docker-ce --nobest

启动 docker

systemctl start docker
systemctl enable docker

下载 hyperf 环境镜像

docker pull hyperf/hyperf

检查镜像是否下载成功

docker images

回到根目录，运行容器

docker run -itd --network host -v $PWD/first_hyperf:/first_hyperf  --name first_hyperf  hyperf/hyperf

这个时候我们已经进入到容器里面了。

我们进入到我们新建的 first_hyperf 文件里面去。

将 composer 源置为国内源，加快下载速度。

composer config -g repo.packagist composer https://mirrors.aliyun.com/composer

新建 hyperf 项目

composer create-project hyperf/hyperf-skeleton client

安装配置如下：

What time zone do you want to setup ?
  [n] Default time zone for php.ini
  Make your selection or type a time zone name, like Asia/Shanghai (n): n

Which RPC protocol do you want to use ?
  [1] JSON-RPC with Service Governance
  [2] JSON-RPC
  [3] gRPC
  [n] None of the above
  Make your selection or type a composer package name and version (n): 2

Which config center do you want to use ?
  [1] Apollo
  [2] Aliyun ACM
  [n] None of the above
  Make your selection or type a composer package name and version (n): 1

Do you want to use hyperf/constants component ?
  [1] yes
  [n] None of the above
  Make your selection (n): 1

Do you want to use hyperf/async-queue component ? (A simple redis queue component)
  [1] yes
  [n] None of the above
  Make your selection or type a composer package name and version (n): 1

Do you want to use hyperf/amqp component ?
  [1] yes
  [n] None of the above
  Make your selection or type a composer package name and version (n): 1

Do you want to use hyperf/model-cache component ?
  [1] yes
  [n] None of the above
  Make your selection or type a composer package name and version (n): 1

Do you want to use hyperf/elasticsearch component ?
  [1] yes
  [n] None of the above
  Make your selection or type a composer package name and version (n): n

Do you want to use hyperf/tracer component ? (A open tracing protocol component, adapte with Zipkin etc.)
  [1] yes
  [n] None of the above
  Make your selection or type a composer package name and version (n): 1

安装 JSON RPC 服务端：

composer require hyperf/rpc-server

安装 JSON RPC 客户端：

composer require hyperf/rpc-client

运行 hyperf 框架

cd hyperf-skeleton

php bin/hyperf.php start

运行成功。
关闭容器

docker stop  容器id

重新进入容器

docker exec -it 容器id  bash

安装完毕，另外一台服务器也同理安装。

开始搭建 RPC

服务端代码编写

编辑 IndexController.php 文件：

<?php

declare(strict_types=1);

namespace App\Controller;
use Hyperf\Utils\Context;
use Hyperf\Utils\Coroutine;
use Hyperf\Utils\Parallel;
use Hyperf\Utils\ApplicationContext;
use App\JsonRpc\CalculatorService;
use App\JsonRpc\MathValue;

class IndexController extends AbstractController
{
    public function index()
    {
        $user = $this->request->input('user', 'Hyperf');
        $method = $this->request->getMethod();

        return [
            'method' => $method,
            'message' => "Hello {$user}.",
        ];
    }
    public function add()
    {
        $client = ApplicationContext::getContainer()->get(CalculatorService::class);
        $value = $client->add(10, 20);
        return $value;
    }

}

在 app 下新增 JsonRpc 目录并新增 CalculatorService.php 和 CalculatorServiceInterface.php 文件。

CalculatorService.php

<?php


namespace App\JsonRpc;
use Hyperf\RpcServer\Annotation\RpcService;



class CalculatorService implements CalculatorServiceInterface
{

    public function add(int $v1, int $v2): int
    {
        return $v1 + $v2;
        
    }

}

CalculatorServiceInterface.php

<?php
declare(strict_types=1);

namespace App\JsonRpc;


interface CalculatorServiceInterface
{
    public function add(int $v1, int $v2): int;

}

route.php

<?php

declare(strict_types=1);

use Hyperf\HttpServer\Router\Router;

Router::addRoute(['GET', 'POST', 'HEAD'], '/', 'App\Controller\IndexController@index');
Router::addRoute(['GET', 'POST', 'HEAD'],'/add', 'App\Controller\IndexController@add');
Router::get('/favicon.ico', function () {
    return '';
});

server.php

<?php

declare(strict_types=1);

use Hyperf\Server\Server;
use Hyperf\Server\SwooleEvent;

return [
    'mode' => SWOOLE_PROCESS,
    'servers' => [
        [
            'name' => 'http',
            'type' => Server::SERVER_HTTP,
            'host' => '0.0.0.0',
            'port' => 9601,
            'sock_type' => SWOOLE_SOCK_TCP,
            'callbacks' => [
                SwooleEvent::ON_REQUEST => [Hyperf\HttpServer\Server::class, 'onRequest'],
            ],
        ],
        [
            'name' => 'jsonrpc-http',
            'type' => Server::SERVER_HTTP,
            'host' => '0.0.0.0',
            'port' => 9604,
            'sock_type' => SWOOLE_SOCK_TCP,
            'callbacks' => [
                SwooleEvent::ON_REQUEST => [\Hyperf\JsonRpc\HttpServer::class, 'onRequest'],
            ],
        ],
        [
            'name' => 'jsonrpc',
            'type' => Server::SERVER_BASE,
            'host' => '0.0.0.0',
            'port' => 9603,
            'sock_type' => SWOOLE_SOCK_TCP,
            'callbacks' => [
                SwooleEvent::ON_RECEIVE => [\Hyperf\JsonRpc\TcpServer::class, 'onReceive'],
            ],
            'settings' => [
                'open_eof_split' => true,
                'package_eof' => "\r\n",
                'package_max_length' => 1024 * 1024 * 2,
            ],
        ],
    ],
    'settings' => [
        'enable_coroutine' => true,
        'worker_num' => swoole_cpu_num(),
        'pid_file' => BASE_PATH . '/runtime/hyperf.pid',
        'open_tcp_nodelay' => true,
        'max_coroutine' => 100000,
        'open_http2_protocol' => true,
        'max_request' => 100000,
        'socket_buffer_size' => 2 * 1024 * 1024,
        'buffer_output_size' => 2 * 1024 * 1024,
    ],
    'callbacks' => [
        SwooleEvent::ON_WORKER_START => [Hyperf\Framework\Bootstrap\WorkerStartCallback::class, 'onWorkerStart'],
        SwooleEvent::ON_PIPE_MESSAGE => [Hyperf\Framework\Bootstrap\PipeMessageCallback::class, 'onPipeMessage'],
        SwooleEvent::ON_WORKER_EXIT => [Hyperf\Framework\Bootstrap\WorkerExitCallback::class, 'onWorkerExit'],
    ],
];

消费端代码编写

IndexController.php

<?php

declare(strict_types=1);
/**
 * This file is part of Hyperf.
 *
 * @link     https://www.hyperf.io
 * @document https://hyperf.wiki
 * @contact  group@hyperf.io
 * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
 */
namespace App\Controller;
use Hyperf\Utils\Context;
use Hyperf\Utils\Coroutine;
use Hyperf\Utils\Parallel;
use Hyperf\Utils\ApplicationContext;
use App\JsonRpc\CalculatorServiceInterface;
use function PHPStan\dumpType;

class IndexController extends AbstractController
{
    public function index()
    {
        $user = $this->request->input('user', 'Hyperf');
        $method = $this->request->getMethod();

        return [
            'method' => $method,
            'message' => "Hello {$user}.",
        ];
    }
    public function add()
    {
        $client = ApplicationContext::getContainer()->get(CalculatorServiceInterface::class);
        $value = $client->add(10, 20);
        return $value;
    }

}

CalculatorServiceInterface.php

<?php

declare(strict_types=1);
namespace App\JsonRpc;


interface CalculatorServiceInterface
{
    public function add(int $v1, int $v2): int;
}

server.php

<?php

declare(strict_types=1);
/**
 * This file is part of Hyperf.
 *
 * @link     https://www.hyperf.io
 * @document https://hyperf.wiki
 * @contact  group@hyperf.io
 * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
 */
use Hyperf\Server\Server;
use Hyperf\Server\SwooleEvent;

return [
    'mode' => SWOOLE_PROCESS,
    'servers' => [
        [
            'name' => 'http',
            'type' => Server::SERVER_HTTP,
            'host' => '0.0.0.0',
            'port' => 9501,
            'sock_type' => SWOOLE_SOCK_TCP,
            'callbacks' => [
                SwooleEvent::ON_REQUEST => [Hyperf\HttpServer\Server::class, 'onRequest'],
            ],
        ],
        [
            'name' => 'jsonrpc-http',
            'type' => Server::SERVER_HTTP,
            'host' => '0.0.0.0',
            'port' => 9504,
            'sock_type' => SWOOLE_SOCK_TCP,
            'callbacks' => [
                SwooleEvent::ON_REQUEST => [\Hyperf\JsonRpc\HttpServer::class, 'onRequest'],
            ],
        ],
        [
            'name' => 'jsonrpc',
            'type' => Server::SERVER_BASE,
            'host' => '0.0.0.0',
            'port' => 9503,
            'sock_type' => SWOOLE_SOCK_TCP,
            'callbacks' => [
                SwooleEvent::ON_RECEIVE => [\Hyperf\JsonRpc\TcpServer::class, 'onReceive'],
            ],
            'settings' => [
                'open_eof_split' => true,
                'package_eof' => "\r\n",
            ],
        ],


    ],
    'settings' => [
        'enable_coroutine' => true,
        'worker_num' => swoole_cpu_num(),
        'pid_file' => BASE_PATH . '/runtime/hyperf.pid',
        'open_tcp_nodelay' => true,
        'max_coroutine' => 100000,
        'open_http2_protocol' => true,
        'max_request' => 100000,
        'socket_buffer_size' => 2 * 1024 * 1024,
        'buffer_output_size' => 2 * 1024 * 1024,
    ],
    'callbacks' => [
        SwooleEvent::ON_WORKER_START => [Hyperf\Framework\Bootstrap\WorkerStartCallback::class, 'onWorkerStart'],
        SwooleEvent::ON_PIPE_MESSAGE => [Hyperf\Framework\Bootstrap\PipeMessageCallback::class, 'onPipeMessage'],
        SwooleEvent::ON_WORKER_EXIT => [Hyperf\Framework\Bootstrap\WorkerExitCallback::class, 'onWorkerExit'],
    ],
];

service.php

<?php

declare(strict_types=1);
/**
 * This file is part of Hyperf.
 *
 * @link     https://www.hyperf.io
 * @document https://hyperf.wiki
 * @contact  group@hyperf.io
 * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
 */
return [
    'consumers' => [
        [
            // The service name, this name should as same as with the name of service provider.
            'name' => 'CalculatorService',
            // The service registry, if `nodes` is missing below, then you should provide this configs.
            // 服务接口名，可选，默认值等于 name 配置的值，如果 name 直接定义为接口类则可忽略此行配置，如 name 为字符串则需要配置 service 对应到接口类
            'service' => \App\JsonRpc\CalculatorServiceInterface::class,
            // 服务提供者的服务协议，可选，默认值为 jsonrpc-http
            'protocol' => 'jsonrpc',
            // 负载均衡算法，可选，默认值为 random
            'load_balancer' => 'random',
            // 对应容器对象 ID，可选，默认值等于 service 配置的值，用来定义依赖注入的 key
            'id' => \App\JsonRpc\CalculatorServiceInterface::class,
            // If `registry` is missing, then you should provide the nodes configs.
            'nodes' => [
                // Provide the host and port of the service provider.
                 ['host' => '192.168.227.129', 'port' => 9603]
            ],
            // 配置项，会影响到 Packer 和 Transporter
            'options' => [
                'connect_timeout' => 5.0,
                'recv_timeout' => 5.0,
                'settings' => [
                    // 根据协议不同，区分配置
                    'open_eof_split' => true,
                    'package_eof' => "\r\n",
                    // 'open_length_check' => true,
                    // 'package_length_type' => 'N',
                    // 'package_length_offset' => 0,
                    // 'package_body_offset' => 4,
                ],
                // 当使用 JsonRpcPoolTransporter 时会用到以下配置
                'pool' => [
                    'min_connections' => 1,
                    'max_connections' => 32,
                    'connect_timeout' => 10.0,
                    'wait_timeout' => 3.0,
                    'heartbeat' => -1,
                    'max_idle_time' => 60.0,
                ],
            ]

        ],
    ],
];

分别进入这两台主机，分别把服务端和消费者端启动起来。

服务端运行截图

消费者端运行截图

另外一台主机同理运行。

验证：
我们访问消费者端：

我们达到了我们的目的，我们访问消费者端，然后消费者端通过 jsonrpc 发送 tcp 请求到服务器端的计算服务。

4、构建注册中心

在进行服务拆分之后，服务的数量变得非常多，而每个服务又可能有非常多的集群点来提供服务，那么为保障系统的正常运行，必然需要有一个中心化的组件完成对各个服务的整合，即将分散于各处的服务进行汇总，汇总的信息屎可以提供服务的组件名称、地址、数量等，每个组件都拥有一个监听设备，当本组件的某个服务的状态变化时报告至中心化的组件进行状态的更新。服务的调用方在请求某项服务时首先到中心化组件获取可提供该项服务的组件信息（IP、端口等），通过默认或自定义的策略选择该服务的某一提供者进行访问，实现服务的调用。那么这个中心化的组件我们一般称之为 服务中心，在 Hyperf 里，我们实现了以 Consul 为服务中心的组件支持，后续将适配更多的服务中心。

安装

composer require hyperf/service-governance

配置服务中心

发布服务到 consul 在 Hyperf 也是非常容易的一件事情，通过 composer require hyperf/consul 加载 Consul 组件（如果已安装则可忽略该步骤），然后再在 config/autoload/consul.php 配置文件内配置您的 Consul 配置即可，示例如下：

<?php

return [
    'uri' => 'http://127.0.0.1:8500',
];

注册服务

5、服务熔断和降级

安装

composer require hyperf/circuit-breaker

为什么要熔断？
比如我们进行一些 Db 查询的时候，需要查询多个表，在这种情况下，平常并发量不高的时候，相应速度还可以说得过去。一旦并发量激增得时候，就可能出现服务不可用的情况，最后导致整个系统都不可用，这种现象被称为服务雪崩效应。为了应对服务雪崩，一种常见的做法是服务降级。

降级是指自己的待遇下降了，从 RPC 调用环节来讲，就是去访问一个本地的伪装者而不是真实的服务。
例如当双 11 活动时，把无关交易的服务统统降级，如查看蚂蚁深林，查看历史订单，商品历史评论，只显示最后 100 条等等。

在 hyperf 框架钟使用熔断器非常简单。
新建 UserController.php，如下：

<?php
declare(strict_types=1);

namespace App\Controller;
use Hyperf\CircuitBreaker\Annotation\CircuitBreaker;
use Hyperf\Di\Annotation\Inject;

class UserController extends AbstractController
{
    private $client;

    
    public function search()
    {
        for($i=1;$i<100000;$i++){
            $a=$i;
            print($a);
        }

        return [
            'message' => "正常",
        ];
    }

    public static function searchFallback()
    {
        return [
            'message' => "流量过大，熔断",
        ];
    }
}

效果如下：

模拟并发量大的情况，我们访问一下 search 的方法。

我们看看正常请求的情况。

6、服务限流

限流的目的是通过对并发访问 / 请求进行限速或者一个时间窗口内的请求进行限速保护系统，一旦达到限制速率就可以拒绝服务（定向到错误页或告知资源没有了），排队等候（比如秒杀、评论和下单）、降级（返回兜底数据和默认数据，如商品详情页默认有货）。

那我们该如何用 hyperf 搭建框架呢？
下面我们将使用到令牌桶限流器。

安装

composer require hyperf/rate-limit

修改配置

<?php

declare(strict_types=1);
/**
 * This file is part of Hyperf.
 *
 * @link     https://www.hyperf.io
 * @document https://hyperf.wiki
 * @contact  group@hyperf.io
 * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
 */
return [
    'create' => 1,
    'consume' => 1,
    'capacity' => 2,
    'limitCallback' => 'limitCallback',
    'waitTimeout' => 0.05,
];

使用限流器

编辑 RateLimitController.php

<?php

namespace App\Controller;

use Hyperf\Di\Aop\ProceedingJoinPoint;
use Hyperf\HttpServer\Annotation\Controller;
use Hyperf\HttpServer\Annotation\RequestMapping;
use Hyperf\RateLimit\Annotation\RateLimit;

/**
 * @Controller(prefix="rate-limit")
 * @RateLimit(limitCallback={RateLimitController::class, "limitCallback"})
 */
class RateLimitController
{
    /**
     * @RequestMapping(path="test")
     * @RateLimit(create=1, capacity=1)
     */
    public function test()
    {
        return ["QPS 1, 峰值3"];
}

    public static function limitCallback(float $seconds, ProceedingJoinPoint $proceedingJoinPoint)
    {
        // $seconds 下次生成Token 的间隔, 单位为秒
        // $proceedingJoinPoint 此次请求执行的切入点
        // 可以通过调用 `$proceedingJoinPoint->process()` 继续执行或者自行处理
        print("完蛋了，限流了。");
        return $proceedingJoinPoint->process();
    }
}

当我们通过多个 postman 压力测试窗口进行测试时，效果如下。

我们可以看到，当我们进行压力测试的时候，该接口已经触发了限流控制了。

---

以上就是关于 rpc 技术的 演化以及一些 使用场景，并 简单介绍什么是 rpc 以及如何使用 hyperf 框架搭建 rpc 服务的过程。希望对大家的学习有些许的帮助。
https://blog.csdn.net/weixin_40670060/article/details/109582821