当前位置:首页 > CMS教程 > 其它CMS > 列表

Laravel中GraphQL接口请求频率实战记录

发布:smiling 来源: PHP粉丝网  添加日期:2022-03-24 15:05:34 浏览: 评论:0 

这篇文章主要给大家介绍了关于Laravel中GraphQL接口请求频率的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。

前言

起源:通常在产品的运行过程,我们可能会做数据埋点,以此来知道用户触发的行为,访问了多少页面,做了哪些操作,来方便产品根据用户喜好的做不同的调整和推荐,同样在服务端开发层面,也要做好“数据埋点”,去记录接口的响应时长、接口调用频率,参数频率等,方便我们从后端角度去分析和优化问题,如果遇到异常行为或者大量攻击来源,我们可以具体针对到某个接口去进行优化。

项目环境:

framework:laravel 5.8+

cache : redis >= 2.6.0

目前项目中几乎都使用的是 graphql 接口,采用的 package 是 php lighthouse graphql,那么主要的场景就是去统计好,graphql 接口的请求次数即可。

实现GraphQL Record Middleware

首先建立一个middleware 用于稍后记录接口的请求频率,在这里可以使用artisan 脚手架快速创建:

php artisan make:middleware GraphQLRecord

  1. <?php 
  2.  
  3. namespace App\Http\Middleware; 
  4.  
  5. use Closure; 
  6.  
  7. class GraphQLRecord 
  8.   /** 
  9.    * Handle an incoming request. 
  10.    * 
  11.    * @param \Illuminate\Http\Request $request 
  12.    * @param \Closure $next 
  13.    * @return mixed 
  14.    */ 
  15.   public function handle($request, Closure $next
  16.   { 
  17.     return $next($request); 
  18.   } 

然后添加到 app/config/lighthouse.php middleware 配置中,或后添加到项目中 app/Http/Kernel.php 中,设置为全局中间件

  1. 'middleware' => [ 
  2.   \App\Http\Middleware\GraphQLRecord::class
  3.   \Nuwave\Lighthouse\Support\Http\Middleware\AcceptJson::class
  4. ], 

获取 GraphQL Operation Name

  1. public function handle($request, Closure $next
  2.     $opName = $request->get('operationName'); 
  3.     return $next($request); 

获取到 Operation Name 之后,开始就通过在Redis 来实现一个接口计数器。

添加接口计数器

首先要设置我们需要记录的时间,如5秒,60秒,半小时、一个小时、5个小时、24小时等,用一个数组来实现,具体可以根据自我需求来调整。

const PRECISION = [5, 60, 1800, 3600, 86400];

然后就开始添加对接口计数的逻辑,计数完成后,我们将其添加到zsset中,方便后续进行数据查询等操作。

  1. /** 
  2.  * 更新请求计数器 
  3.  * 
  4.  * @param string $opName 
  5.  * @param integer $count 
  6.  * @return void 
  7.  */ 
  8. public function updateRequestCounter(string $opName$count = 1) 
  9.   $now  = microtime(true); 
  10.   $redis = self::getRedisConn(); 
  11.   if ($redis) { 
  12.     $pipe = $redis->pipeline(); 
  13.     foreach (self::PRECISION as $prec) { 
  14.       //计算时间片 
  15.       $pnow = intval($now / $prec) * $prec
  16.       //生成一个hash key标识 
  17.       $hash = "request:counter:{$prec}:$opName"
  18.       //增长接口请求数 
  19.       $pipe->hincrby($hash$pnow, 1); 
  20.       // 添加到集合中,方便后续数据查询 
  21.       $pipe->zadd('request:counter', [$hash => 0]); 
  22.     } 
  23.     $pipe->execute(); 
  24.   } 
  25.  
  26. /** 
  27.  * 获取Redis连接 
  28.  * 
  29.  * @return object 
  30.  */ 
  31. public static function getRedisConn() 
  32.   $redis = Redis::connection('cache'); 
  33.   try { 
  34.     $redis->ping(); 
  35.   } catch (Exception $ex) { 
  36.     $redis = null; 
  37.     //丢给sentry报告 
  38.     app('sentry')->captureException($ex); 
  39.   } 
  40.  
  41.   return $redis

然后请求一下接口,用medis查看一下数据。

Laravel中GraphQL接口请求频率实战记录

Laravel中GraphQL接口请求频率实战记录

查询、分析数据

数据记录完善后,可以通过opName 及 prec两个属性来查询,如查询24小时的tag接口访问数据。

  1. /** 
  2.  * 获取接口访问计数 
  3.  * 
  4.  * @param string $opName 
  5.  * @param integer $prec 
  6.  * @return array 
  7.  */ 
  8. public static function getRequestCounter(string $opName, int $prec
  9.   $data = []; 
  10.   $redis = self::getRedisConn(); 
  11.   if ($redis) { 
  12.     $hash   = "request:counter:{$prec}:$opName"
  13.     $hashData = $redis->hgetall($hash); 
  14.     foreach ($hashData as $k => $v) { 
  15.       $date  = date("Y/m/d"$k); 
  16.       $data[] = ['timestamp' => $k'value' => $v'date' => $date]; 
  17.     } 
  18.   } 
  19.  
  20.   return $data

获取 tag 接口 24小时的访问统计

$data = $this->getRequestCounter('tagQuery', '86400');

清除数据

完善一系列步骤后,我们可能需要将过期和一些不必要的数据进行清理,可以通过定时任务来进行定期清理,相关实现如下:

  1. /** 
  2.    * 清理请求计数 
  3.    * 
  4.    * @param integer $clearDay 
  5.    * @return void 
  6.    */ 
  7.   public function clearRequestCounter($clearDay = 7) 
  8.   { 
  9.     $index   = 0; 
  10.     $startTime = microtime(true); 
  11.     $redis   = self::getRedisConn(); 
  12.     if ($redis) { 
  13.       //可以清理的情况下 
  14.       while ($index < $redis->zcard('request:counter')) { 
  15.         $hash = $redis->zrange('request:counter'$index$index); 
  16.         $index++; 
  17.  
  18.         //当前hash存在 
  19.         if ($hash) { 
  20.           $hash = $hash[0]; 
  21.           //计算删除截止时间 
  22.           $cutoff = intval(microtime(true) - ($clearDay * 24 * 60 * 60)); 
  23.  
  24.           //优先删除时间较远的数据 
  25.           $samples = array_map('intval'$redis->hkeys($hash)); 
  26.           sort($samples); 
  27.  
  28.           //需要删除的数据 
  29.           $removes = array_filter($samplesfunction ($itemuse (&$cutoff) { 
  30.             return $item <= $cutoff
  31.           }); 
  32.           if (count($removes)) { 
  33.             $redis->hdel($hash, ...$removes); 
  34.             //如果整个数据都过期了的话,就清除掉统计的数据 
  35.             if (count($removes) == count($samples)) { 
  36.               $trans = $redis->transaction(['cas' => true]); 
  37.               try { 
  38.                 $trans->watch($hash); 
  39.                 if (!$trans->hlen($hash)) { 
  40.                   $trans->multi(); 
  41.                   $trans->zrem('request:counter'$hash); 
  42.                   $trans->execute(); 
  43.                   $index--; 
  44.                 } else { 
  45.                   $trans->unwatch(); 
  46.                 } 
  47.               } catch (\Exception $ex) { 
  48.                 dump($ex); 
  49.               } 
  50.             } 
  51.           } 
  52.  
  53.         } 
  54.       } 
  55.       dump('清理完成'); 
  56.     } 
  57.  
  58.   } 

清理一个30天前的数据:

$this->clearRequestCounter(30);

整合代码

我们将所有操作接口统计的代码,单独封装到一个类中,然后对外提供静态函数调用,既实现了职责单一,又方便集成到其他不同的模块使用。

  1. <?php 
  2. namespace App\Helpers; 
  3.  
  4. use Illuminate\Support\Facades\Redis; 
  5.  
  6. class RequestCounter 
  7.   const PRECISION = [5, 60, 1800, 3600, 86400]; 
  8.  
  9.   const REQUEST_COUNTER_CACHE_KEY = 'request:counter'
  10.  
  11.   /** 
  12.    * 更新请求计数器 
  13.    * 
  14.    * @param string $opName 
  15.    * @param integer $count 
  16.    * @return void 
  17.    */ 
  18.   public static function updateRequestCounter(string $opName$count = 1) 
  19.   { 
  20.     $now  = microtime(true); 
  21.     $redis = self::getRedisConn(); 
  22.     if ($redis) { 
  23.       $pipe = $redis->pipeline(); 
  24.       foreach (self::PRECISION as $prec) { 
  25.         //计算时间片 
  26.         $pnow = intval($now / $prec) * $prec
  27.         //生成一个hash key标识 
  28.         $hash = self::counterCacheKey($opName$prec); 
  29.         //增长接口请求数 
  30.         $pipe->hincrby($hash$pnow, 1); 
  31.         // 添加到集合中,方便后续数据查询 
  32.         $pipe->zadd(self::REQUEST_COUNTER_CACHE_KEY, [$hash => 0]); 
  33.       } 
  34.       $pipe->execute(); 
  35.     } 
  36.   } 
  37.  
  38.   /** 
  39.    * 获取Redis连接 
  40.    * 
  41.    * @return object 
  42.    */ 
  43.   public static function getRedisConn() 
  44.   { 
  45.     $redis = Redis::connection('cache'); 
  46.     try { 
  47.       $redis->ping(); 
  48.     } catch (Exception $ex) { 
  49.       $redis = null; 
  50.       //丢给sentry报告 
  51.       app('sentry')->captureException($ex); 
  52.     } 
  53.  
  54.     return $redis
  55.   } 
  56.  
  57.   /** 
  58.    * 获取接口访问计数 
  59.    * 
  60.    * @param string $opName 
  61.    * @param integer $prec 
  62.    * @return array 
  63.    */ 
  64.   public static function getRequestCounter(string $opName, int $prec
  65.   { 
  66.     $data = []; 
  67.     $redis = self::getRedisConn(); 
  68.     if ($redis) { 
  69.       $hash   = self::counterCacheKey($opName$prec); 
  70.       $hashData = $redis->hgetall($hash); 
  71.       foreach ($hashData as $k => $v) { 
  72.         $date  = date("Y/m/d"$k); 
  73.         $data[] = ['timestamp' => $k'value' => $v'date' => $date]; 
  74.       } 
  75.     } 
  76.  
  77.     return $data
  78.   } 
  79.  
  80.   /** 
  81.    * 清理请求计数 
  82.    * 
  83.    * @param integer $clearDay 
  84.    * @return void 
  85.    */ 
  86.   public static function clearRequestCounter($clearDay = 7) 
  87.   { 
  88.     $index   = 0; 
  89.     $startTime = microtime(true); 
  90.     $redis   = self::getRedisConn(); 
  91.     if ($redis) { 
  92.       //可以清理的情况下 
  93.       while ($index < $redis->zcard(self::REQUEST_COUNTER_CACHE_KEY)) { 
  94.         $hash = $redis->zrange(self::REQUEST_COUNTER_CACHE_KEY, $index$index); 
  95.         $index++; 
  96.  
  97.         //当前hash存在 
  98.         if ($hash) { 
  99.           $hash = $hash[0]; 
  100.           //计算删除截止时间 
  101.           $cutoff = intval(microtime(true) - ($clearDay * 24 * 60 * 60)); 
  102.  
  103.           //优先删除时间较远的数据 
  104.           $samples = array_map('intval'$redis->hkeys($hash)); 
  105.           sort($samples); 
  106.  
  107.           //需要删除的数据 
  108.           $removes = array_filter($samplesfunction ($itemuse (&$cutoff) { 
  109.             return $item <= $cutoff
  110.           }); 
  111.           if (count($removes)) { 
  112.             $redis->hdel($hash, ...$removes); 
  113.             //如果整个数据都过期了的话,就清除掉统计的数据 
  114.             if (count($removes) == count($samples)) { 
  115.               $trans = $redis->transaction(['cas' => true]); 
  116.               try { 
  117.                 $trans->watch($hash); 
  118.                 if (!$trans->hlen($hash)) { 
  119.                   $trans->multi(); 
  120.                   $trans->zrem(self::REQUEST_COUNTER_CACHE_KEY, $hash); 
  121.                   $trans->execute(); 
  122.                   $index--; 
  123.                 } else { 
  124.                   $trans->unwatch(); 
  125.                 } 
  126.               } catch (\Exception $ex) { 
  127.                 dump($ex); 
  128.               } 
  129.             } 
  130.           } 
  131.  
  132.         } 
  133.       } 
  134.       dump('清理完成'); 
  135.     } 
  136.  
  137.   } 
  138.  
  139.   public static function counterCacheKey($opName$prec
  140.   { 
  141.     $key = "request:counter:{$prec}:$opName"
  142.  
  143.     return $key
  144.   } 

在Middleware中使用.

  1. <?php 
  2.  
  3. namespace App\Http\Middleware; 
  4.  
  5. use App\Helpers\RequestCounter; 
  6. use Closure; 
  7.  
  8. class GraphQLRecord 
  9.  
  10.   /** 
  11.    * Handle an incoming request. 
  12.    * 
  13.    * @param \Illuminate\Http\Request $request 
  14.    * @param \Closure $next 
  15.    * @return mixed 
  16.    */ 
  17.   public function handle($request, Closure $next
  18.   { 
  19.     $opName = $request->get('operationName'); 
  20.     if (!emptyempty($opName)) { 
  21.       RequestCounter::updateRequestCounter($opName); 
  22.     } 
  23.  
  24.     return $next($request); 
  25.   } 

结尾

上诉代码就实现了基于GraphQL的请求频率记录,但是使用不止适用于GraphQL接口,也可以基于Rest接口、模块计数等统计行为,只要有唯一的operation name即可。

Tags: GraphQL Laravel接口请求频率

分享到: