Linux运维 第三阶段 （十七） memcached

Linux运维 第三阶段 （十七） memcached
一、相关概念：
memcached.org（live journal站点贡献的），很多流行站点都在用，如wikipedia、twitter、youtube、mixi等，memcached是非常流行的缓存服务，众多的应用程序开发基本都支持memcached缓存（C有C库，C++有C++库，php有php库，开发时都可直接调用memcached功能，若某个应用程序开发时不用memcached，它就不能往memcached中缓存数据，缓存数据与否取决于app自身，由app决定缓不缓存用不用它）
memcached（键值对key:value server），它只适合存储key:value的数据，而且是缓存cache不是存储store（mysql是store，数据存储下来关机是没事的）

若将http中的web object缓存到memcached中，相应的key应如何存，每个web object都通过uri获取，如http://www.magedu.com/index.html，这个web object是唯一的，就将这个uri（index.html）当作key，而文件中的内容作为value
memcached是C/S架构的程序，tcp|udp（tcp支持长连接，每次从缓存中获取数据要三次握手很浪费时间；若server对性能要求高使用udp），无论tcp|udp都要基于IP报文发送，memcached会监听在某个socket上，否则无法接收client请求
tcp|udp，port：11211，由libevent提供event-driven功能的库文件

ftp service、httpd service之间区别（client同server端交互）：
协议的不同获取资源的方式不一样；使用独有的协议实现client和server的交互；
client发命令过去，server要接收并理解这个命令并做出处理，例如http报文，client（GET+URI），server理解GET并将资源响应给client，或client（PUT+FILE），server端先接收指令PUT并将文件存储下来；这些PUT、GET就是操作命令，例如ftp中的操作命令（put、get、mput、mget等）；
ftp和http这些协议所使用的命令都很简单，基于文件命令的简单协议simple protocol（http:text；ftp:text,binary），若想使用复杂命令（例如用get获取server上某个文件而且要查询文件对应的时间是否正确，否则就不要）是不能达到这样的要求的
memcached上client和server的交互就是上面这种方式（simplep rotocol），整个处理机制非常简单，在其协议的实施上默认也是基于simple protocol，封装任何指令不使用xml格式
注：两台计算机之间为了交互数据，为能让对方更能理解请求的命令是什么，使用xml格式封装指令，如集群，大多数配置文件是xml格式的，就为实现某些数据交互，避免对方误解，这种协议它所支持的功能及配置非常强大，但xml本身要能解析xml的文档，任何一个协议若支持xml格式传输数据的话，那client和server都要有一个xml引擎，至少要能分析xml文档，这将导致server复杂，而memcached本身就是为了高性能而存在的，所以越简单越好，因此memcached仅支持一些简单的命令，如get（获取一个key对应的value）、set（设定，保存缓存）

作为memcached，往它上面存key:value的数据，编码格式：
text，使用文本格式，整个处理机制将简单很多，还可用#telnet localhost 11211进行测试；
binary，二进制格式，在安全性、效率上要好得多，使用这种格式就要用到专用客户端工具，例如ftp client工具（既支持text又支持binary，如果默认是binary就只能使用专用客户端工具），只有客户端工具才能理解传输的内容，封装数据并传输，接收数据并还原
memcached早期使用text方式（基于text发送指令），现在支持两种格式（text|binary，发送指令，实现数据的上传（将数据放入缓存）下载（从缓存获取数据））

memcached是一个缓存服务器，但本身无法决定缓存任何数据，这意味着一半依赖于client-side，一半依赖于server-side，存储是由memacached server负责并提供检索能力，至于怎么存储、存多长时间（过期时间）、谁来存储是由client决定的（client要自己提供key名，标志位、缓存时长、value）
例如：set key 5 6 hello

memcached缓存管理工作在lazy模型下（只要系统上有足够空间可用，无论缓存数据有无过期都不会清理，只有没空间使用的情形下才清理），惰性的清理机制，同时又是LRU的清理机制（last recently use，最近最少使用）
若缓存空间过小，但缓存的数据量很大，这样导致缓存抖动很厉害（存了清，清了存，很少命中）
由于存了很多数据，因管理不善或空间过小，导致雪崩效果（表现为缓存数据很多，但就是命中不了）

memcached既然是缓存服务器，它并不保证数据持久存储（它假设自己坏了无所谓，它坏了，除影响业务本身访问速度变慢外，是不影响数据本身的），它尽可能实现用内存来缓存数据（内存缓存server），单个对象大小（下限48byte，上限1M）

memcached在内存中是如何管理缓存的数据，为了存储数据对象，要在内存开辟一段区域（内存中的数据都是按字节序列化的），一个byte一个byte的存，每一个byte都是编址的单元，使用时是按页来用，要能在内存中标记起始地址和结束地址，若失效这段空间要腾出来，这样存储大小不一的对象，存一个删一个，时间久了会有碎片，内存中到处是缝隙，缝隙多了内存要高效利用将很困难（如存一个数据，半天找不到空闲的地方），要反复的完成内存的申请、释放，尤其当存储百万个缓存对象时，这种建立、释放本身要消耗大量的时间，内存碎片将导致进程运行起来会非常慢，刚开始问题不大，运行越久越会拖慢速度，而我们用memcached是用来加速的

对于以上问题，如何用高效的机制解决内存的建立和释放，linux内核有两种机制来管理避免内存碎片（buddy system伙伴系统；slab allocator，slab分配器）
buddy system（避免内存外碎片，它实现在整个内存当中以页面的方式管理内存时，有足够的连续的空间可用；在x86或x86_64的server上，通常是4K大小一个页面，这就意味着，一个进程存第一个对象时，若这个对象8K要用2个页面，这个对象16K要用到4个页面，这样时间长了会有内存页碎片，若之后需要10M的连续空间，由于内存全是缝隙将找不到，为避免这种情况，buddy system就是解决将临近的空闲的内存页面合并为一个大的连续空间，将来申请时可以从一头开始，而不用从中间申请，这将避免页碎片）
注：有些数据存储时占用不了一个页面，例如内核在打开文件时，每一个inode结构（包括inode及元数据各种属性）仅占128byte左右的空间，若直接使用一个页面存那就太浪费空间了，使用slab allocator解决
slab allocator（避免内存内碎片，将要存储数据的大小小于页面单位的（非常小的内存数据结构），给它事先分配好这些结构，随时等待有需求的进程或要存储的对象使用，而且使用结束后不再销毁，随时重复利用，若不够用时再找一个空闲页面立即划分好，这样在使用时不用申请直接用已划分好的；OS上有众多的数据结构都需要这种方式实现，而且存储空间大小也各不相同，如每个进程都有进程描述符（进程号、进程名、属主、属组等信息）空间占约256byte、打开文件时的inode结构占约128byte，这样slab allocator为每一种数据结构都准备一些空间在那放着，任何时候申请直接使用已划分好的，用完后重新放在可用列表中（归类到空闲列表中），所以slab allocator将整个内存中的数据结构分成了已用的和空闲的，在内核中它使用一个数据结构追踪某个slab对象占据的有几个页面（大对象可分多个页面，小对象在一个页面中再次划分），哪个页面是空闲的，依次第一个页面用完了再用第二个，若之后第一个有空闲就在第一个上放数据，达到重复利用的目的

一旦给memcached指定有多大内存空间可用后，它会在可用的物理内存空间中申请过来，并且划分好存储空间，分好一个个的slab chunk，每一次缓存数据，找到最佳slab class，若指定的内存空间存满了就要清理了（根据LRU算法），没有存满就算过期了也不清理（lazy模型）

例如给memcached指定512M内存，服务在启动时会在内存中划分512M区域开始分片，分片时它会考虑到各种数据大小的存储，例如48byte分一堆，80byte的分一堆，200byte的再分一堆，这每一个类别叫slab类（slab class），每一slab class中都有很多块用来存数据，每一块叫slab chunk，之后要存数据，它会找一个最适合的大小的区域单元来存放，这每一类间隔越小则空间的浪费越少（但类别过多管理也会麻烦），例如要存20byte的数据，它会自动找到48byte这个slab class存（虽然它仅占20byte，另28byte空间就浪费了，为使内存高效管理此处浪费不可避免）；早期memcached类别之间是呈2倍增长趋势的，这种管理方式粗糙，浪费的空间大，现在支持使用增长因子来定义（growth factor，在每个类别上定义，每次在上次的基础上往上涨多少），增长因子一般是在1和2之间的数，例如有一类是48byte定义growth factor为2，则下一个是96，若growth factor定义为1.1，则下一个是48*1.1

memcached是不通信的分布式缓存服务器（它本身不支持高可用，但分布式功能是它的强项，分布式算法是在app-server上实现的），例如有两台memcached-server，前端app-server若轮流使用memcached，该怎么轮并不取决于这两台memcached-server（这两个memcached彼此间不通信，不需监控对方心跳等），而是用前端的app-server实现（memcached是否在线，上传数据等）
注：若是小规模应用完全可在app-server上实现调度；若大规模，则使用调度器（LVS、nginx、haproxy）加持久连接实现

memcached键值对key:value存储时，如对key做hash运算除以memcached-server总数再取余，就可定位到是用哪台memcached-server存储，这种算法有很大缺陷（弊端），例如若4台memcached中有其中一台挂了或者又新增了一台，之前是除以4，现在除以3，结果导致查询缓存不会定位到之前的那台memcached-server上，所以大量缓存失效要重新建立
consistency hash（一致性哈希算法）：client使用，例如一个环中有n个点位（散列的很多挨着的点），这些点0-2^32，有几台memcached-server就将其对应的放在环中的某个点上（例如有4台，2^32除以4），缓存数据时，仍取离散的值，对key做hash运算除以2^32取余，这个值会分散在环中某个点上，按顺时针找最近的一台server存储要缓存的数据，若某一server挂了或增加了一台，则只影响环中某一段中的缓存（增加或减少server只影响局部，之前的算法会影响到全部），使用这种算法将影响范围降到最低




以下是在LNMP架构中提到的memcached：
memcached（两个功能：实现缓存后端DB-server的查询结果，提供给多个app-server使用；缓存app-server的session信息）：
它本身只是个提供缓存功能的server，到底缓不缓存，谁来缓存，怎么缓存，缓存过期时间，缓存清除等它自身不管，它可以根据你的请求，替你做出决策，例如，app-server查询DB，觉的这个结果可以缓存，由app-server自己把数据放至memcaced 上，当app-server下次找数据时就自动去memcached上去找，memcached是个公共缓存，可被多个node共同使用，若命中率达到40%，对系统性能的提升非常明显

若是电商站点，后端某个app-server挂了，每一个app-server为了维持某个用户的购物车、http等会话信息会结合cookie在app-server本地内存中要维护一个session，每一个client只要连接，在app-server上都有session信息，若某个用户第一次连接在app-server5上，第二次被分配到了app-server1上，那之前的会话信息就没了，为使会话继续使用，可用持久连接（同一client的请求始终定位至同一个app-server上，虽会破坏LB效果，但能实现），但要是app-server5挂掉，用户一刷新同样会定位到其它app-server上，会话也照样没了，如果用户请求有5万个，某一个app-server挂掉将会丢失1万个session信息（很可怕）
注：session信息是保存在当前某一个app-server上的本地内存中一份，而且在FS上也会保存一份，方便以后读取，所以只能被这一个主机所使用

如果app-server建成集群，session信息在内存中可完成同步，如用户请求app-server1，app-server1在建立会话以后，直接通过高可用集群同步至任一node的内存中去，这将有额外的开销（每一个app-server都要通过组播发送出去），若app-server很多每一次这样同步数据量会很大，在小规模场景中勉强可用，但大规模场景就不理想了

这时要在各app-server间共享session，使用一个公共区域来保存session信息，让每一个app-server都到这个公共区域中去读会话信息，memcached正是这么一个公共缓存
当某一用户请求第一次被发到app-server1上时，app-server1发现需要为这个请求建立会话，这个会话数据不再保存在本地，直接保存到memcached中，之后哪怕这个用户的请求被转至app-server2上，app-server2会根据用户的cookie信息自动地去memcached中找session信息，把session读过来与用户建立会话，于是本地就有，不过这时风险更大，若memcached挂了，那所有会话都没了，想到为memcached做高可用，memcached本身并不支持高可用，但若做成高可用了也并不理想（它会这样假设，你保存在我这的都是缓存数据，是非关键性数据，是读取的原始数据，我这里的数据就算丢了，你无非是重建而已，我这里不会使用高可用的），但它可很好的实现分布式的功能（memcached的强项），这就意味着1个memcached不够用可用多个memcached，如有3个memcached，app-server在存数据时会选一个来存，查找时通过某种算法（例如将用户的cookie作hash运算再除以3取余，hash运算的结果相同除3取余的结果就相同）再定位至这个memcached-server上
注：若把memcached做成HA-server，意义并不大也不理想（因为缓存数据是在内存中，除非解决两个进程间通过内存将某一node的缓存通知给另一node）

这样memcached不仅可以缓存DB中查询的数据，还能缓存session信息，所以有人把memcached称万金油（银蛋），它能应付各种情况和场景，只要数据可缓存且缓存的是可序列化的数据（如string、各object等，网络上传输的是01代码，若发一张图片或其它对象最终都可被抽成一根线，再通过网络发送，接收端接收下来将其合并并还原即可）它都能缓存下来，不能序列化就无法在内存中存储，就更不用说发送了
缓存方法就是在内存中开辟一段很小的区域，每个缓存对象将占用一个小区域将数据缓存下来

若缓存了有1KW个数据，之后要怎么找，若要遍历这1000W个对象那也太慢了，memcached是键值存储（key:value），在存储时首先给这个数据创建个查找键key，然后再存储它的值value，key:value存储通常都是基于hash方式，每存一个数据时这个key也需要地方存储，key存储在叫做hash bucket桶中（hash bucket有多个），key存在哪一桶个中是根据hash函数计算得出的，每个桶中比如规定只存100个key，将来要找某一个key时做hash运算（hash函数），运算完后就知道在哪个hash bucket中，找到这个桶后，桶中数据相对就很少了，在hash bucket中迅速的做下字符串比较（二次计算）立即找出键，基于这种方式查找速度是无与伦比的快（hash索引非常快，所以查找都是O（1）的），这样1000个键无非是在某个桶中找一次，1000万个键无非是找出在哪一个桶中
但存储太多个对象也不好，每存储一个数据都要开辟一小段内存，不同的场景所需要的空间也不一样，对象多了导致内存碎片化，在内存中的这些对象要被管理（如对象过期要回收等），要有很好的内存管理策略（策略即算法，通过程序不定期的去执行，执行就要消耗CPU时间，会有额外开销），当对象少时没什么问题，但对象超多，内存随时都要释放和回收、分配，这是不小的工作量，所以并不建议在memcached中缓存过多的数据

memcached缓存时支持的单个对象最大1M空间，最小48byte
memcache是C/S架构，client就是app-server，应用程序通过协议把数据通过网络传送给memcached-server，memcached根据client的请求将数据缓存下来，所以client可向server-side发送不同指令，如建立缓存、清除缓存、在缓存中附加新数据等有很多命令

二、操作（1、memcached安装；2、常用命令；3、安装php的扩展memcache；4、nginx整合memcached；5、php的session保存在memcached中；6、使用web界面管理工具memadmin）：
环境：
[root@node1 ~]# uname -a
Linux node1.magedu.com 2.6.32-358.el6.x86_64#1 SMP Tue Jan 29 11:47:41 EST 2013 x86_64 x86_64 x86_64 GNU/Linux
准备安装包及yum源：
libevent-2.0.22-stable.tar.gz
memcached-1.4.25.tar.gz
memcache-2.2.7.tgz
memadmin-1.0.12.tar.gz
注：在LNMP环境上操作（LNMP环境搭建参照《Linux运维第三阶段（十五）理解LNMP》

1、安装
[root@node1 ~]# yum -y groupinstall “Desktop Platform” “Desktop Platform Development” "Server Platform Development" “Development tools” “Compatibility libraries”（确保这几个底层依赖包已安装）
[root@node1 ~]# rpm -q libevent（此版本在memcached源码编译时过不去，得安装2.0.22版本，2.0比自带的glibc库性能要高很多，对于高并发的程序它们运行时会自动使用libevent库）
libevent-1.4.13-4.el6.x86_64
[root@node1 ~]# rpm -q cyrus-sasl-devel（认证相关，确保已安装）
cyrus-sasl-devel-2.1.23-13.el6_3.1.x86_64

[root@node1 ~]# tar xf libevent-2.0.22-stable.tar.gz
[root@node1 ~]# cd libevent-2.0.22-stable
[root@node1 libevent-2.0.22-stable]#./configure --prefix=/usr/local/libevent
[root@node1 libevent-2.0.22-stable]# make && make install
[root@node1 libevent-2.0.22-stable]# cd
[root@node1 ~]# echo "/usr/local/libevent/lib" > /etc/ld.so.conf.d/libevent.conf
[root@node1 ~]# ldconfig -v
[root@node1 ~]# ln -sv /usr/local/libevent/include/ /usr/include/libevent
"/usr/include/libevent" ->"/usr/local/libevent/include/"

[root@node1 ~]# tar xf memcached-1.4.25.tar.gz
[root@node1 ~]# cd memcached-1.4.25
[root@node1 memcached-1.4.25]# ./configure --help
[root@node1 memcached-1.4.25]# ./configure --prefix=/usr/local/memcached --enable-sasl --with-libevent=/usr/local/libevent
[root@node1 memcached-1.4.25]# make && make install

[root@node1 memcached-1.4.25]# cd /usr/local/memcached/
[root@node1 memcached]# ls bin
memcached
[root@node1 memcached]# echo "export PATH=$PATH:/usr/local/memcached/bin/" > /etc/profile.d/memcached.sh
[root@node1 memcached]# . !$
. /etc/profile.d/memcached.sh
[root@node1 memcached]# cd
[root@node1 ~]# memcached -h（类似mysql-proxy，支持很多选项）
-m NUM（以M为单位指定最大可用内存空间，max memory to use for items in megabytes (default: 64 MB)）
-n BYTES（指定最小存储块是多大slab chunk，增长因子就是在此基础上增加的，minimum space allocated for key+value+flags (default: 48)）
-f FACTOR_NUM（指定增长因子grown factor，一般1-2之间的数，chunk size growth factor (default: 1.25)）
-vv（very verbose (also print client commands/reponses)）
-u USERNAME（assume identity of <username> (only when run as root)）
-d（run as a daemon）
-p NUM（TCP port number to listen on (default: 11211)）
-U NUM（UDP port number to listen on (default: 11211, 0 is off)）
-l ADDRESS（interface to listen on (default: INADDR_ANY, all addresses)）
-S（启用sasl认证，Turn on Sasl authentication）
-s FILE（指定socket，类似mysql中/tmp/mysql.sock本地套接字的通信机制，能利用近似共享内存的方式通信，UNIX socket path to listen on (disables network support)）
-r（maximize core file limit）
-c NUM（最大并发连接数，max simultaneous connections (default: 1024)）
-t NUM（用于处理入站请求的最大线程数，仅在memcached编译时开启支持线程才有效(linux对线程支持有限)，number of threads to use (default: 4)）
-P FILE（save PID in <file>, only used with -d option）
-L（试图使用最多的内存空间，Try touse large memory pages (if available)）
-C（Disable use of CAS）
-b NUM（Set the backlog queue limit (default: 1024)）
-o（指定额外选项，Comma separated list of extended or experimental options）

[root@node1 ~]# memcached -m 64 -n 20 -f 1.1 -vv -u nobody -d（可看出具体分配空间过程）
[root@node1 ~]# slab class 1: chunk size 72 perslab 14563
slab class 2: chunk size 80perslab 13107
slab class 3: chunk size 88perslab 11915
slab class 4: chunk size 96perslab 10922
slab class 5: chunk size 112perslab 9362
slab class 6: chunk size 128perslab 8192
slab class 7: chunk size 144perslab 7281
slab class 8: chunk size 160 perslab 6553
……
[root@node1 ~]# netstat -tnupl | grep :11211
tcp 0 0 0.0.0.0:11211 0.0.0.0:* LISTEN 3957/memcached
tcp 0 0 :::11211 :::* LISTEN 3957/memcached
udp 0 0 0.0.0.0:11211 0.0.0.0:* 3957/memcached
udp 0 0 :::11211 :::* 3957/memcached
[root@node1 ~]# killall memcached
[root@node1 ~]# ps aux |grep memcached |grep -v grep
[root@node1 ~]# vim /etc/init.d/memcached（为memcached提供sysv风格启动脚本，此脚本内容见文末附）
[root@node1 ~]# vim /etc/sysconfig/memcached（并为脚本提供配置文件，方便各配置选项的更改）
CACHESIZE="64"
BYTES="48"
FACTOR="1.25"
USER="nobody"
PORT="11211"
MAXCONN="1024"
OPTIONS=""
[root@node1 ~]# chmod +x !$
chmod +x /etc/init.d/memcached
[root@node1 ~]# chkconfig --add memcached
[root@node1 ~]# service memcached start
Starting Distributed memory caching(memcached): [确定]

2、常用命令：
memcached支持的命令（在telnet下使用，因为memcached没有客户端工具，只能在telnet下直接交互）：
syntax格式：
COMMAND_NAME KEY_NAME FLAGS EXPIRE_TIME BYTES
DATA_BLOCK
其中COMMAND_NAME常用的有（set|get|gets|add|replace|delete|cas|stats|statsitems|append|prepend|flush_all|incr|decr）；
KEY_NAME（要知道某个key所对应的value值，必须要知道key_name）
FLAGS（客户机使用此项存储关于key:value的额外信息）
EXPIRE_TIME（过期时间，0表示永远不过期）
BYTES（存储字节数）
DATA_BLOCK（存放value）

[root@node1 ~]# telnet localhost 11211
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
stats（输入此指令可看相关状态）
STAT pid 3957
STAT uptime 255
STAT time 1448113877
STAT version 1.4.25
STAT libevent 2.0.22-stable
STAT pointer_size 64
……
STAT get_hits 0
STAT get_misses 0
STAT delete_misses 0
STAT delete_hits 0
set mykey 0 10 12（set使用频率很高，用于如果key不存在，使用set可添加，如果key存在，使用set可更新key相关数据）
hello magedu
STORED
get mykey（get后跟key_name，查看key所对应的value，若要查看多个key用空格隔开）
VALUE mykey 0 12
hello magedu
END
add mykey1 0 0 7（add添加，仅在key不存在时才能添加）
jowin
STORED
get mykey1
VALUE mykey1 0 7
jowin
END
set mykey1 0 0 8（set更新key所对应的参数及value）
chai
STORED
get mykey1
VALUE mykey1 0 8
chai
END
replace mykey1 0 0 8（replace替换，仅在key存在时才能使用）
cjowin
STORED
get mykey1
VALUE mykey1 0 8
cjowin
END
delete mykey1（删除，已存在记录和不存在的记录会返回不同的结果）
DELETED
delete mykey2
NOT_FOUND
add mykey 0 0 7
hello
STORED
gets mykey（gets返回结果比get返回的结果多了一列，最后一列这个数字（此例中是7）可检查数据是否发生改变，当key对应的value改变时，最后的这个数字也会变化）
VALUE mykey 0 7 7
hello
END
replace mykey 0 0 7
haha
STORED
gets mykey（内容改变时，gets得到的结果中最后一个数字也变了）
VALUE mykey 0 7 8
haha
END
cas mykey 0 0 7 8（cas，checked and set，只有在此处输入的最后一个数字与gets得到的最后一位数字相同才存储，否则返回exists）
hello
STORED
gets mykey
VALUE mykey 0 7 9
hello
END
cas mykey 0 0 7 18
kao
EXISTS
stats items（列出STAT itmes行，若memcached中存储内容很多会列出很多行）
STAT items:2:number 1
STAT items:2:age 173
STAT items:2:evicted 0
STAT items:2:evicted_nonzero 0
STAT items:2:evicted_time 0
STAT items:2:outofmemory 0
STAT items:2:tailrepairs 0
STAT items:2:reclaimed 0
STAT items:2:expired_unfetched 0
STAT items:2:evicted_unfetched 0
STAT items:2:crawler_reclaimed 0
STAT items:2:crawler_items_checked 0
STAT items:2:lrutail_reflocked 0
END
stats cachedump 2 0（2是stats item返回的值，表示slab_id；0表示limit_num代表返回所有记录数；通过stats items,stats cachedump slab_id limit_num,get可遍历memcached的记录）
ITEM mykey [7 b; 1448113562 s]
END
stats cachedump 2 128
ITEM mykey [7 b; 1448113562 s]
END
另还有常用的：stats slabs,stats sizes,stats reset
append（在现有缓存数据后添加缓存数据）；prepend（在现有的缓存数据前添加缓存数据）；flush_all（默认使已经存在的key:value立即失效，或在指定的时间后，执行这个命令后再用get获取key时将不会有内容返回，之前的key:value在内存中并没有释放（因为是lazy模型及LRU清理机制））

3、安装php扩展（memcache）：
使用某一应用程序（php或mysql）来连接一个服务（memcached或mysqld）时，必须要利用这个服务的客户端库来编程（例如mysql用自己的client连上服务直接发命令，在使用php编程时调用一个库mysql-connect，在函数中传一大堆参数），没法直接调用客户端，只能用客户端库，这就是很多应用程序要提供命令行工具（供用户测试使用）和库（库可供二次开发用）
memcached没有客户端，只是通过#telnet localhost 11211与服务直接交互，作为php程序员（或C程序员）在开发时，要写一个程序能够利用memcached服务器来完成数据缓存以此提高系统性能，必须要针对客户端库来编程，由此必须要为某一种语言提供客户端库，以完成这个程序编程时尽可能简单的利用memcached

客户端库有（三种语言perl、php、C/C++各自提供的客户端库）：
perl module（perl要使用memcached就用这个perl module）：
cache;;memcached
php（php要使用memcached，得为php安装一个扩展，共提供了两个库（两个扩展））：
memcache
memcached
注：注意这里的memcache和memcached是php的两个库（两个扩展，使用时安装一个即可），memcached比memcache要先进，支持的功能要强大，一般用memcached
C/C++：
libmemcached

[root@node1 ~]# vim /etc/nginx/nginx.conf（确保以下段配置就绪）
……
location / {
root html;
index index.php index.html index.htm;
}
……
location ~ \.php$ {
root html;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /scripts$fastcgi_script_name;
include fastcgi_params;
}
……
[root@node1 ~]# cat /usr/html/index.php
<?php
phpinfo();
?>
[root@node1 ~]# service nginx start
正在启动 nginx： [确定]
[root@node1 ~]# service php-fpm start
Starting php-fpm done
[root@node1 ~]# netstat -tnlp | grep :9000
tcp 0 0 127.0.0.1:9000 0.0.0.0:* LISTEN 4998/php-fpm
[root@node1 ~]# ps aux | grep -v grep |grep -c php-fpm（php-fpm进程共9个，其中1个主进程，8个子进程，在/usr/local/php/etc/php-fpm.conf配置文件中设置了pm.start_servers= 8）
9




[root@node1 ~]# tar xf memcache-2.2.7.tgz
[root@node1 ~]# cd memcache
[root@node1 ~]# cd memcache-2.2.7
[root@node1 memcache-2.2.7]#/usr/local/php/bin/phpize
Configuring for:
PHP Api Version: 20100412
Zend Module Api No: 20100525
Zend Extension Api No: 220100525
[root@node1 memcache-2.2.7]# ./configure --with-php-config=/usr/local/php/bin/php-config --enable-memcache
[root@node1 memcache-2.2.7]# make && make install（记录安装完后最后一行给的目录）
……
Installing shared extensions: /usr/local/php/lib/php/extensions/no-debug-non-zts-20100525/

[root@node1 memcache-2.2.7]# ls /usr/local/php/lib/php/extensions/no-debug-non-zts-20100525/
memcache.so xcache.so
[root@node1 memcache-2.2.7]# vim /etc/php.d/memcache.ini
extension = “/usr/local/php/lib/php/extensions/no-debug-non-zts-20100525/memcache.so”
[root@node1 memcache-2.2.7]# cd
[root@node1 ~]# vim /usr/html/test.php
---------------test pagestart--------------------
<?php
$mem = new Memcache;
$mem->connect("127.0.0.1",11211) or die("Could notconnect");

$version = $mem->getVersion();
echo "Server's version:".$version."<br/>\n";

$mem->set('testkey', 'hello magedu', 0,600) or die("Failed to save data at the memcached server");
echo "Store data in the cache (datawill expire in 600 seconds)<br/>\n";

$get_result = $mem->get('testkey');
echo "$get_result is from memcachedserver.";
?>
---------------test pageend------------------
[root@node1 ~]# service php-fpm restart
Gracefully shutting down php-fpm . done
Starting php-fpm done

测试：







[root@node1 ~]# telnet localhost 11211
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
get testkey
VALUE testkey 0 12
hello magedu
END

4、nginx整合memcached
注：nginx的缓存是在磁盘上性能不好
[root@node1 ~]# vim /etc/nginx/nginx.conf
server {
listen 80;
server_name localhost;
root html;
location / {
set $memcached_key $uri;
memcached_pass 127.0.0.1:11211;
default_type text/html;
error_page 404 @fallback;
}
location @fallback {
proxy_pass http://192.168.41.135; }
}

5、将php的session保存在memcached中：
[root@node1 ~]# vim /etc/php.ini（注意Session段中以下几项，session.name按默认，此名字之后在很多地方要用到）
[Session]
session.save_handler = memcache
session.save_path = "tcp://127.0.0.1:11211?persistent=1&weight=1&timeout=1&retry_interval=15"
session.name = PHPSESSID
测试：准备两个测试脚本
[root@node1 ~]# vim /usr/html/setsession.php
--------------test script start-------------
<?php
session_start();
if (!isset($_SESSION['www.MageEdu.com'])) {
$_SESSION['www.MageEdu.com'] = time();
}
print $_SESSION['www.MageEdu.com'];
print "<br><br>";
print "Session ID: " .session_id();
?>
------------------test script end-------------
[root@node1 ~]# vim /usr/html/showsession.php
---------------test script start--------------
<?php
session_start();
$memcache_obj = new Memcache;
$memcache_obj->connect('127.0.0.1',11211);
$mysess=session_id();
var_dump($memcache_obj->get($mysess));
$memcache_obj->close();
?>
-------------test script end----------------------







6、使用web界面管理工具memadmin：
此工具官网描述：
MemAdmin是一款可视化的Memcached管理与监控工具,基于PHP5&JQuery开发,体积小,操作简单.
MemAdmin主要功能:
服务器参数监控:STATS、SETTINGS、ITEMS、SLABS、SIZES实时刷新
服务器性能监控:GET、DELETE、INCR、DECR、CAS等常用操作命中率实时监控
支持数据遍历,方便对存储内容进行监视支持条件查询,筛选出满足条件的KEY或VALUE 数组、JSON等序列化字符反序列显示
兼容memcache协议的其他服务,如Tokyo Tyrant (遍历功能除外) 支持服务器连接池,多服务器管理切换方便简洁.

[root@node1 ~]# tar xf memadmin-1.0.12.tar.gz
[root@node1 ~]# mv memadmin /usr/html/
[root@node1 ~]# ls /usr/html/memadmin/
apps config.php images include index.php langs LICENSE.txt README.txt views
[root@node1 ~]# vim /usr/html/memadmin/config.php（此文件中有账号密码，默认都是admin）







添加服务器连接-->名称：localhost，host：127.0.0.1，port：11211，持久化连接30秒-->添加-->开始管理

















附：memcached启动脚本：
--------------script start-----------------
#!/bin/bash
#
# Init file for memcached
#
# chkconfig: - 86 14
# description: Distributed memory cachingdaemon
#
# processname: memcached
# config: /etc/sysconfig/memcached

. /etc/rc.d/init.d/functions

## Default variables
CACHESIZE="64"
BYTES=”48”
FACTOR=”1.25”
USER="nobody"
PORT="11211"
MAXCONN="1024"
OPTIONS=""

[ -f /etc/sysconfig/memcached ] && source /etc/sysconfig/memcached

RETVAL=0
prog="/usr/local/memcached/bin/memcached"
desc="Distributed memory caching"
lockfile="/var/lock/subsys/memcached"

start() {
echo -n $"Starting $desc (memcached): "
daemon $prog -m $CACHESIZE -n $BYTES -f $FACTOR -u $USER -p $PORT -c$MAXCONN -d
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch $lockfile
return $RETVAL
}

stop() {
echo -n $"Shutting down $desc (memcached): "
killproc $prog
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f $lockfile
return $RETVAL
}

restart() {
stop
start
}

reload() {
echo -n $"Reloading $desc ($prog): "
killproc $prog -HUP
RETVAL=$?
echo
return $RETVAL
}

case "$1" in
start)
start
;;
stop)
stop
;;
restart)
restart
;;
condrestart)
[ -e $lockfile ] && restart
RETVAL=$?
;;
reload)
reload
;;
status)
status $prog
RETVAL=$?
;;
*)
echo $"Usage: $0 {start|stop|restart|condrestart|status}"
RETVAL=1
esac

exit $RETVAL
--------------scrip tstop--------------------

以上是学习《马哥运维课程》做的笔记。

本文出自 “Linux运维重难点学习笔记” 博客，请务必保留此出处http://jowin.blog.51cto.com/10090021/1733076