1. day05 广告缓存

2. lua

lua 语言具有以下特性

  • 支持面向过程(procedure-oriented)编程和函数式编程(functional programming)；
  • 自动内存管理；只提供了一种通用类型的表（table），用它可以实现数组，哈希表，集合，对象；
  • 语言内置模式匹配；闭包(closure)；函数也可以看做一个值；提供多线程（协同进程，并非操作系统所支持的线程）支持；
  • 通过闭包和table可以很方便地支持面向对象编程所需要的一些关键机制，比如数据抽象，虚函数，继承和重载等。

2.1. lua的安装

  1. yum install -y gcc
  2. yum install libtermcap-devel ncurses-devel libevent-devel readline-devel
  3. curl -R -O http://www.lua.org/ftp/lua-5.3.5.tar.gz
  4. tar -zxf lua-5.3.5.tar.gz
  5. cd lua-5.3.5
  6. make linux test
  7. make install

2.2. 编写helloword

创建hello.lua文件，内容为

  1. print("hello");

执行

  1. lua helloworld.lua
  1. #或者直接lua 直接进入命令行模式
  2. lua
  3. print("hello");

2.3. 基本用法

  • lua有交互式编程和脚本式编程。

  • 交互式编程就是直接输入语法，就能执行。

  • 脚本式编程需要编写脚本文件，然后再执行。

一般采用脚本式编程。（例如：编写一个hello.lua的文件，输入文件内容，并执行lua hell.lua即可）

2.4. 注释

  1. -- 单行注释
  2. --[[
  3. 多行注释1
  4. 多行注释2
  5. --]]

2.5. 关键字
and break do else
elseif end false for
function if in local
nil not or repeat
return then true until
while

2.6. 定义变量

变量默认为全局变量 如果需要局部变量需要声明为local

  1. a = 1
  2. local b = 2 -- 局部变量

如果变量没有初始化：则 它的值为nil 这和java中的null不同。

2.7. 数据类型

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值 值可以存储在变量中，作为参数传递或结果返回。

Lua 中有 8 个基本类型:

数据类型 描述
nil 这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
boolean 包含两个值：false和true。
number 表示双精度类型的实浮点数
string 字符串由一对双引号或单引号来表示
function 由 C 或 Lua 编写的函数
userdata 表示任意存储在变量中的C数据结构
thread 表示执行的独立线路，用于执行协同程序
table Lua 中的表（table）其实是一个”关联数组”（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过”构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表。

2.8. 流程控制

  1. --[ 0 为 true ]
  2. if(0) then
  3.     print("0 为 true")
  4. else
  5.     print("0 不为true")
  6. end

2.9. 函数

  1. --[[ 函数返回两个值的最大值 --]]
  2. function max(num1, num2)
  4.    if (num1 > num2) then
  5.       result = num1;
  6.    else
  7.       result = num2;
  8.    end
  10.    return result; 
  11. end
  12. -- 调用函数
  13. print("两值比较最大值为 ",max(10,4))
  14. print("两值比较最大值为 ",max(5,6))

2.10. require 函数

require 用于 引入其他的模块，类似于import

  1. require "<模块名>"

3. nginx+lua+redis实现广告缓存

3.1. OpenResty

OpenResty(又称：ngx_openresty) 是一个基于 NGINX 的可伸缩的 Web 平台，由中国人章亦春发起，提供了很多高质量的第三方模块。

OpenResty 是一个强大的 Web 应用服务器，Web 开发人员可以使用 Lua 脚本语言调动 Nginx 支持的各种 C 以及 Lua 模块,更主要的是在性能方面，OpenResty可以 快速构造出足以胜任 10K 乃至1000K以上并发连接响应的超高性能 Web 应用系统。

OpenResty 简单理解，就相当于封装了nginx,并且集成了LUA脚本，开发人员只需要简单的其提供了模块就可以实现相关的逻辑，而不再像之前，还需要在nginx中自己编写lua的脚本，再进行调用了。

安装

  1. yum install yum-utils
  3. yum-config-manager --add-repo https://openresty.org/package/centos/openresty.repo
  4. yum install openresty  #yum安装路径为/usr/local/openresty

OpenResty 内置nginx 我们需要修改一下nginx配置 ,将配置文件使用的根设置为root,目的就是将来要使用lua脚本的时候 ，直接可以加载在root下的lua脚本。

  1. vim /usr/local/openresty/nginx/conf/nginx.conf
  3. #user nobody; 配置文件第一行原来为这样, 现改为下面的配置
  4. user root root;

3.2. 缓存预热与二级缓存查询

  1. 编写lua脚本实现缓存预热（将mysql里的数据查询出来存入redis

    05. day05 广告缓存 - 图1

  2. 编写lua脚本实现二级缓存读取
    05. day05 广告缓存 - 图2

3.3. 代码实现

3.3.1. 缓存预热

实现思路：

定义请求：用于查询数据库中的数据更新到redis中。

  1. 连接mysql ，按照广告分类ID读取广告列表，转换为json字符串。
  2. 连接redis，将广告列表json字符串存入redis 。

定义请求：

  1. 请求：
  2.     /ad_update
  3. 参数：
  4.     position  --指定广告位置
  5. 返回值：
  6.     json

在/root/lua目录下创建ad_load.lua ，实现连接mysql 查询数据 并存储到redis中。

  1. cd /root
  2. mkdir lua
  3. cd lua
  4. vim ad_load.lua
  1. ngx.header.content_type="application/json;charset=utf8"
  2. local cjson = require("cjson")
  3. local mysql = require("resty.mysql")
  4. local uri_args = ngx.req.get_uri_args()
  5. local position = uri_args["position"]
  7. local db = mysql:new()
  8. db:set_timeout(1000)  
  9. local props = {  
  10.     host = "192.168.130.128",  
  11.     port = 3306,  
  12.     database = "changgou_business",  
  13.     user = "root",  
  14.     password = "root"  
  15. }
  17. local res = db:connect(props)  
  18. local select_sql = "select url,image from tb_ad where status ='1' and position='"..position.."' and start_time<= NOW() AND end_time>= NOW()"  
  19. res = db:query(select_sql)  
  20. db:close()  
  22. local redis = require("resty.redis")
  23. local red = redis:new()
  24. red:set_timeout(2000)
  26. local ip ="192.168.130.128"
  27. local port = 6379
  28. red:connect(ip,port)
  30. red:set("ad_"..position,cjson.encode(res))
  31. red:close()
  33. ngx.say("{flag:true}")

修改/usr/local/openresty/nginx/conf/nginx.conf文件

  1. vim /usr/local/openresty/nginx/conf/nginx.conf

在server下添加以下内容

  1. # 添加广告 在mysql中查询广告信息 并缓存到redis中
  2. location /ad_update {
  3. content_by_lua_file /root/lua/ad_load.lua;
  4. }

完整配置文件

  1. #user  nobody;
  2. user root root;
  3. worker_processes  1;
  5. #error_log  logs/error.log;
  6. #error_log  logs/error.log  notice;
  7. #error_log  logs/error.log  info;
  9. #pid        logs/nginx.pid;
  11. events {
  12.     worker_connections  1024;
  13. }
  15. http {
  16.     include       mime.types;
  17.     default_type  application/octet-stream;
  18.     sendfile        on;
  19.     #tcp_nopush     on;
  21.     #keepalive_timeout  0;
  22.     keepalive_timeout  65;
  24.     #gzip  on;
  26.     server {
  27.         listen       80;
  28.         server_name  localhost;
  29.         charset utf-8;
  30.         #access_log  logs/host.access.log  main;
  31.         # 添加广告 在mysql中查询广告信息 并缓存到redis中
  32.         location /ad_update {
  33.             content_by_lua_file /root/lua/ad_load.lua;
  34.         }
  36.         # redirect server error pages to the static page /50x.html
  37.         #
  38.         error_page   500 502 503 504  /50x.html;
  39.         location = /50x.html {
  40.             root   html;
  41.         }        
  42.     }
  43. }

重启nginx

  1. cd /usr/local/openresty/nginx/sbin/
  2. ./nginx -s reload

访问http://192.168.130.128/ad_update?position=web_index_lb测试

如果返回{flag:true} 则成功

可以查看redis中ad_web_index_lb 是否有数据 如无数据 请到数据库中更改ad结束时间

3.3.2. 广告缓存读取

通过lua脚本直接从redis中获取数据即可。

定义请求：

  1. 请求:/ad_read
  2. 参数：position
  3. 返回值：json

在/root/lua目录下创建ad_read.lua

  1. vim /root/lua/ad_read.lua
  1. ngx.header.content_type="application/json;charset=utf8"
  3. local uri_args = ngx.req.get_uri_args();
  4. local position = uri_args["position"];
  6. local redis = require("resty.redis");
  8. local red = redis:new()
  10. red:set_timeout(2000)
  12. local ok, err = red:connect("192.168.130.128", 6379)
  14. local rescontent=red:get("ad_"..position)
  16. ngx.say(rescontent)
  18. red:close()

在/usr/local/openresty/nginx/conf/nginx.conf中server下添加配置

  1. vim /usr/local/openresty/nginx/conf/nginx.conf
  1. #从redis 读取广告
  2. location /ad_read {
  3.   content_by_lua_file /root/lua/ad_read.lua;
  4. }

重启nginx

  1. cd /usr/local/openresty/nginx/sbin/
  2. ./nginx -s reload

测试 http://192.168.130.128/ad_read?position=web_index_lb 输出

3.3.3. 二级缓存-加入openresty本地缓存

先查询openresty本地缓存 如果没有再查询redis中的数据

修改/root/lua目录下ad_read文件,

  1. ngx.header.content_type="application/json;charset=utf8"
  2. local uri_args = ngx.req.get_uri_args();
  3. local position = uri_args["position"];
  4. local cache_ngx = ngx.shared.dis_cache;
  5. local adCache = cache_ngx:get('ad_cache_'..position);
  6. if adCache == "" or adCache == nil then
  7.     local redis = require("resty.redis");
  8.     local red = redis:new()
  9.     red:set_timeout(2000)
  10.     local ok, err = red:connect("192.168.130.128", 6379)
  11.     local rescontent=red:get("ad_"..position)
  12.     ngx.say(rescontent)
  13.     red:close()
  14.     cache_ngx:set('ad_cache_'..position, rescontent, 10*60);
  15. else
  16.     ngx.say(adCache)
  17. end

修改nginx配置文件vi /usr/local/openresty/nginx/conf/nginx.conf ，http节点下添加配置:

  1. #包含redis初始化模块
  2. lua_shared_dict dis_cache 5m;  #共享内存开启

3.3.4. 前端页面实现

修改index.html，编写脚本

  1. <script>
  2.        new Vue({
  3.         el: '#app',
  4.         data: {
  5.             ad: {
  6.                 web_index_lb:[]
  7.             }
  8.         },
  9.         methods: {
  10.             adRead: function(position) {
  11.                 axios.get('ad_read?position='+position).then(response =>{
  12.                     this.ad[position]=response.data                 
  13.                 })
  14.             }
  15.         },
  16.         created(){
  17.             this.adRead('web_index_lb')
  18.         }
  19.       })
  20. </script>

修改index.html 渲染广告轮播图

  1. <div id="myCarousel" data-ride="carousel" data-interval="4000" class="sui-carousel slide">
  2.     <ol class="carousel-indicators">
  3.         <li data-target="#myCarousel" data-slide-to="0" class="active" v-for="item in ad.web_index_lb"></li>
  4.     </ol>
  5.     <div class="carousel-inner" id="lbt">
  6.         <div class="item" v-for="item in contentList">
  7.             <a :href="item.url">
  8.             <img :src="item.pic"  />
  9.           </a>
  10.         </div>      
  11.     </div>
  12.     <a href="#myCarousel" data-slide="prev" class="carousel-control left">‹</a>
  13.     <a href="#myCarousel" data-slide="next" class="carousel-control right">›</a>
  14. </div>

将整个前端项目 上传到nginx下的html中

3.4. nginx限流

一般情况下，首页的并发量是比较大的，即使有了多级缓存，如果有大量恶意的请求，也会对系统造成影响。而限流就是保护措施之一。

nginx提供两种限流的方式：

  • 一是控制速率
  • 二是控制并发连接数

3.4.1. 漏桶算法实现控制速率限流

控制速率的方式之一就是采用漏桶算法。

漏桶(Leaky Bucket)算法思路很简单,水(请求)先进入到漏桶里,漏桶以一定的速度出水(接口有响应速率),当水流入速度过大会直接溢出(访问频率超过接口响应速率),然后就拒绝请求,可以看出漏桶算法能强行限制数据的传输速率.示意图如下:

05. day05 广告缓存 - 图3

nginx的配置 将以下内容添加到http节点下

  1.     limit_req_zone $binary_remote_addr zone=myRateLimit:10m rate=2r/s;
  2.     server {  
  3.         listen       8081;
  4.         server_name  localhost;
  5.         charset utf-8;
  6.         location / {
  7.             limit_req zone=myRateLimit;
  8.             root   html;
  9.             index  index.html index.htm;
  10.         }
  11.     }
  • binaryremote_addr 是一种key，表示基于 remote_addr(客户端IP) 来做限流，binary 的目的是压缩内存占用量。
  • zone：定义共享内存区来存储访问信息， myRateLimit:10m 表示一个大小为10M，名字为myRateLimit的内存区域。1M能存储16000 IP地址的访问信息，10M可以存储16W IP地址访问信息。
  • rate 用于设置最大访问速率，rate=10r/s 表示每秒最多处理10个请求。Nginx 实际上以毫秒为粒度来跟踪请求信息，因此 10r/s 实际上是限制：每100毫秒处理一个请求。这意味着，自上一个请求处理完后，若后续100毫秒内又有请求到达，将拒绝处理该请求.我们这里设置成2 方便测试。

完整配置

  1. #user  nobody;
  2. user root root;
  3. worker_processes  1;
  5. #error_log  logs/error.log;
  6. #error_log  logs/error.log  notice;
  7. #error_log  logs/error.log  info;
  9. #pid        logs/nginx.pid;
  12. events {
  13.     worker_connections  1024;
  14. }
  17. http {
  18.     include       mime.types;
  19.     default_type  application/octet-stream;
  21.     #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
  22.     #                  '$status $body_bytes_sent "$http_referer" '
  23.     #                  '"$http_user_agent" "$http_x_forwarded_for"';
  25.     #access_log  logs/access.log  main;
  27.     sendfile        on;
  28.     #tcp_nopush     on;
  30.     #keepalive_timeout  0;
  31.     keepalive_timeout  65;
  33.     #gzip  on;
  36.     limit_req_zone $binary_remote_addr zone=myRateLimit:10m rate=2r/s;
  38.     server {  
  39.         listen       8081;
  40.         server_name  localhost;
  41.         charset utf-8;
  42.         location / {
  43.             limit_req zone=myRateLimit;
  44.             root   html;
  45.             index  index.html index.htm;
  46.         }
  47.     }
  48. }

访问http://192.168.130.128:8081/测试 限流则服务返回503错误

3.4.2. 处理突发流量

上面例子限制 2r/s，如果有时正常流量突然增大，超出的请求将被拒绝，无法处理突发流量，可以结合 burst 参数使用来解决该问题。

  1. server {
  2.     location / {
  3.         limit_req zone=myRateLimit burst=5;
  4.         root   html;
  5.         index  index.html index.htm;
  6.     }
  7. }

burst 译为突发、爆发，表示在超过设定的处理速率后能额外处理的请求数,当 rate=2r/s 时，将1s拆成2份，即每500ms可处理1个请求。

此处，burst=5 ，若同时有6个请求到达，Nginx 会处理第一个请求，剩余5个请求将放入队列，然后每隔500ms从队列中获取一个请求进行处理。若请求数大于6，将拒绝处理多余的请求，直接返回503.

不过，单独使用 burst 参数并不实用。假设 burst=50 ，rate为10r/s，排队中的50个请求虽然每100ms会处理一个，但第50个请求却需要等待 50 * 100ms即 5s，这么长的处理时间自然难以接受。

因此，burst 往往结合 nodelay 一起使用。

  1. server {
  2.     location / {
  3.         limit_req zone=myRateLimit burst=5 nodelay;
  4.         root   html;
  5.         index  index.html index.htm;
  6.     }
  7. }

处理突发5个请求的时候，没有延迟，等到完成之后，按照正常的速率处理。

如上两种配置结合就达到了速率稳定，但突然流量也能正常处理的效果

在1秒钟之内可以刷新5次，正常处理 但是超过之后，连续刷新5次，抛出异常。