DZ

壹加壹

环境配置
" K1 K" I' s* _3 B" t5 i. t, y

http://www.discuz.net/forum.php? ... amp;highlight=REDIS

壹加壹

http://www.discuz.net/forum.php? ... 648&highlight=REDIS
. M8 Z& a" r! j" w" l. l. ~7 ~9 l4 f无意间测试 单机状态 redis相当给力 测试1000请求/s  单纯的 get 和set 居然只用了 0.01秒 当时我惊呆了
5 b0 i( c1 b  D
. T% l2 f+ M: E* D4 J- |http://www.discuz.net/forum.php? ... 731&highlight=REDIS
; v8 A  k9 |' z* H+ f
https://wenku.baidu.com/view/265a5ce176a20029bc642d0b.html
, |  o/ g5 q- z4 d5 r
) i: m- A6 n' g0 v+ H! U+ j7 {＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

1. 连接上 ssh
   
2. 
   
3. 
   
4. 第一步:下载redis
   
5. # wget http://redis.googlecode.com/files/redis-2.6.10.tar.gz
   
6. # tar zxvf redis-2.6.10.tar.gz
   3 M! F# B4 J! g4 |4 a) i/ B: j/ A
7. # cd redis-2.6.10
   / f; x; \+ p; p6 J. b
8. # make
   1 f& [- `" p& O, d/ M8 B
9. # make install  
   , V5 D  x2 Z" Q4 R1 k$ O$ J' e
10. #cp redis.conf  /etc/ #复制配置文件到etc目录下面
    
11. 第二步：修改配置
    
12. #vi /etc/redis.conf
    
13. ######################下面是无措的配置文件 复制过去就成#########
    ; K7 Y+ `% D2 R" p% O# Y, p
14. # Redis configuration file example
    ; x4 J) i2 i0 J" S$ G! J3 f
15. 
    2 ?$ l5 ^1 Z+ ]" S
16. # Note on units: when memory size is needed, it is possible to specify
    2 j; ^* i9 D; T$ a; L9 E
17. # it in the usual form of 1k 5GB 4M and so forth:
    
18. #
    
19. # 1k => 1000 bytes
    7 m9 t6 z8 w  @  B' y) G
20. # 1kb => 1024 bytes
    . N) f+ b' c% u7 m( T
21. # 1m => 1000000 bytes
    
22. # 1mb => 1024*1024 bytes
    
23. # 1g => 1000000000 bytes
    
24. # 1gb => 1024*1024*1024 bytes
    
25. #
    
26. # units are case insensitive so 1GB 1Gb 1gB are all the same.
    
27. 
    
28. # By default Redis does not run as a daemon. Use 'yes' if you need it.
    ; t( N5 G3 U: U" \6 d2 P
29. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
    6 _3 o& e: g' O3 W! E! K& S5 A4 M
30. daemonize yes
    & i3 G0 k' P; M" i( l/ q# V/ T
31. 
    . h% a+ L7 B2 p* V  q2 P' O: p
32. # When running daemonized, Redis writes a pid file in /var/run/redis.pid by
    # d5 U- _& i! S: p, e. J
33. # default. You can specify a custom pid file location here.
    7 R8 }, L% U1 q
34. pidfile /var/run/redis.pid
    
35. 
    
36. # Accept connections on the specified port, default is 6379.
    % ^5 P' ^  M& m8 S! z
37. # If port 0 is specified Redis will not listen on a TCP socket.
      H: x$ n" p- Z# a5 J, {
38. port 6379
    6 i, f6 d/ _- W
39. 
    / m' A$ v7 h6 R! k7 Z, K! l
40. # If you want you can bind a single interface, if the bind option is not
    
41. # specified all the interfaces will listen for incoming connections.
    3 r! W) W! g+ }7 F- C
42. #
    
43. # bind 127.0.0.1
    
44. 
    3 h9 |; C2 B+ @" T) h' k
45. # Specify the path for the unix socket that will be used to listen for
    
46. # incoming connections. There is no default, so Redis will not listen
    ; I8 E# s8 [7 f" E
47. # on a unix socket when not specified.
    - \! j/ D2 c2 s( ^
48. #
    
49. # unixsocket /tmp/redis.sock
    . o1 H: l  C# I  [. r9 F) Z
50. # unixsocketperm 755
    
51. 
    : A+ \/ S" d: C1 M
52. # Close the connection after a client is idle for N seconds (0 to disable)
    % c- D% f) E" K; `( T0 `5 Q
53. timeout 300
    3 B4 A5 r: C1 ^4 A: L' X) q  T
54. 
    
55. # TCP keepalive.
    * i( q+ t# \, V- c4 E4 ~
56. #
    
57. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
    
58. # of communication. This is useful for two reasons:
    
59. #
    
60. # 1) Detect dead peers.
    1 P% r, X8 w/ e
61. # 2) Take the connection alive from the point of view of network
    6 e( P( L# u$ I
62. #    equipment in the middle.
    
63. #
    
64. # On Linux, the specified value (in seconds) is the period used to send ACKs.
    
65. # Note that to close the connection the double of the time is needed.
    
66. # On other kernels the period depends on the kernel configuration.
    : y5 J5 ?3 V% }/ w
67. #
    8 O) o* n5 q* a
68. # A reasonable value for this option is 60 seconds.
    * x& N& g! C& l' i* n/ ?
69. tcp-keepalive 0
    
70. 
    
71. # Specify the server verbosity level.
    0 C5 ]3 N; }* ^8 w' g" j
72. # This can be one of:
    
73. # debug (a lot of information, useful for development/testing)
    
74. # verbose (many rarely useful info, but not a mess like the debug level)
      E; {. ^7 E  H8 p; |4 F
75. # notice (moderately verbose, what you want in production probably)
    9 D- ^+ ~' r$ _5 c8 [
76. # warning (only very important / critical messages are logged)
    + P9 L& j5 S; ]; J. b
77. loglevel warning
    ( m: V; v1 l7 [1 H$ i; T
78. 
    
79. # Specify the log file name. Also 'stdout' can be used to force
    
80. # Redis to log on the standard output. Note that if you use standard
    - F3 L7 [* e' \2 @5 d# N2 V9 }) y
81. # output for logging but daemonize, logs will be sent to /dev/null
    ; Z/ X7 I) Q) P# ~4 F1 m9 e4 K' {
82. logfile /var/log/redis.log
    
83. 
    
84. # To enable logging to the system logger, just set 'syslog-enabled' to yes,
    ' C  L$ z/ Q, g7 V; f
85. # and optionally update the other syslog parameters to suit your needs.
    
86. syslog-enabled yes
    
87. 
    
88. # Specify the syslog identity.
    
89. # syslog-ident redis
    
90. 
    
91. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
    
92. syslog-facility local0
    
93. 
    ; e6 L, L# M  _) q) S# s8 s9 Q/ q
94. # Set the number of databases. The default database is DB 0, you can select
    - T* B1 y7 j$ g3 U# M8 k  _0 l4 {
95. # a different one on a per-connection basis using SELECT <dbid> where
    6 C- |, M4 F6 X' s- ^( H, A5 g
96. # dbid is a number between 0 and 'databases'-1
    - |: i6 Q/ N' y
97. databases 16
    ! R; H3 F1 A: A, N0 m
98. 
    
99. ################################ SNAPSHOTTING  #################################
    
100. #
     + m, r8 Z7 X( I* E. Z
101. # Save the DB on disk:
     
102. #
     9 q3 C1 C* M  ]# r. n
103. #   save <seconds> <changes>
     
104. #
     
105. #   Will save the DB if both the given number of seconds and the given
     / O2 j6 i" X" t3 g) H! U
106. #   number of write operations against the DB occurred.
     7 V5 b. y; ^3 B4 `% T
107. #
     
108. #   In the example below the behaviour will be to save:
     * q- e; N# x* n, V. y3 M& h& O
109. #   after 900 sec (15 min) if at least 1 key changed
     
110. #   after 300 sec (5 min) if at least 10 keys changed
     6 _2 Z/ K, X, S( |* A. c+ J9 v- J
111. #   after 60 sec if at least 10000 keys changed
     
112. #
     , e- v$ E, v3 J% `# W+ i: n
113. #   Note: you can disable saving at all commenting all the "save" lines.
     
114. #
     
115. #   It is also possible to remove all the previously configured save
     + R! s# P3 T8 g# n" S
116. #   points by adding a save directive with a single empty string argument
     + U3 D. P* I' W7 T
117. #   like in the following example:
     
118. #
     
119. #   save ""
     
120. 
     
121. save 900 1
     
122. save 300 10
       M+ f6 }6 `' g
123. save 60 10000
     + b5 s/ P( G  ]8 T/ v
124. 
     & z3 _# R# V# S6 |* K" e, B
125. # By default Redis will stop accepting writes if RDB snapshots are enabled
     
126. # (at least one save point) and the latest background save failed.
       c) k! {# l) @, P% C8 {
127. # This will make the user aware (in an hard way) that data is not persisting
     
128. # on disk properly, otherwise chances are that no one will notice and some
     7 r0 T+ B8 [$ w. M
129. # distater will happen.
     
130. #
     
131. # If the background saving process will start working again Redis will
     8 V2 r% \/ }( B( E
132. # automatically allow writes again.
     
133. #
     
134. # However if you have setup your proper monitoring of the Redis server
     
135. # and persistence, you may want to disable this feature so that Redis will
     . i" N+ x; M7 V* q  m
136. # continue to work as usually even if there are problems with disk,
     
137. # permissions, and so forth.
     8 v. R/ g& m3 d7 Z
138. stop-writes-on-bgsave-error yes
     ) V2 K% d& ^1 a5 l' n- s
139. 
     
140. # Compress string objects using LZF when dump .rdb databases?
     
141. # For default that's set to 'yes' as it's almost always a win.
     
142. # If you want to save some CPU in the saving child set it to 'no' but
     
143. # the dataset will likely be bigger if you have compressible values or keys.
     
144. rdbcompression yes
     
145. 
     7 C4 ~0 ~9 ]' f4 m2 f8 H$ V
146. # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
     0 o2 Z2 ]' k0 {; @3 D
147. # This makes the format more resistant to corruption but there is a performance
     
148. # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
     
149. # for maximum performances.
     
150. #
     
151. # RDB files created with checksum disabled have a checksum of zero that will
     # i1 \% D( w- s; [
152. # tell the loading code to skip the check.
     % G1 R' S2 c! E3 r0 R; ~( @
153. rdbchecksum yes
     
154. 
     
155. # The filename where to dump the DB
     5 G% L. P) b1 b. G- a, K( ?4 U
156. dbfilename dump.rdb
     
157. 
     
158. # The working directory.
     3 K8 B: ~% {& R* n) R. S. W0 T
159. #
     
160. # The DB will be written inside this directory, with the filename specified
     
161. # above using the 'dbfilename' configuration directive.
     0 @5 \8 a4 U& Z* Z
162. #
     
163. # The Append Only File will also be created inside this directory.
     1 A7 \, c7 b2 ^
164. #
     
165. # Note that you must specify a directory here, not a file name.
     , h( j- Q5 Y0 m3 o8 b
166. dir /var/db/redis
     
167. 
     , K9 |9 t! I3 j' E0 |3 y
168. ################################# REPLICATION #################################
     2 z- j7 C  |5 ]3 Z) s, l# c' z
169. 
     
170. # Master-Slave replication. Use slaveof to make a Redis instance a copy of
     : u& y7 c( X$ X4 L  @
171. # another Redis server. Note that the configuration is local to the slave
     
172. # so for example it is possible to configure the slave to save the DB with a
     % P7 _) C. I, e, R7 Z4 }
173. # different interval, or to listen to another port, and so on.
     # R3 i9 r/ `0 {% p: A0 x1 M
174. #
     
175. # slaveof <masterip> <masterport>
     + {" g- G* H1 k  c* z
176. 
     
177. # If the master is password protected (using the "requirepass" configuration
     
178. # directive below) it is possible to tell the slave to authenticate before
     * v( @, ]: \3 H( a/ R
179. # starting the replication synchronization process, otherwise the master will
     ! S* C" r" P& c8 e! x
180. # refuse the slave request.
     
181. #
     7 {: A/ f5 Z# N2 C! O/ E& B9 H
182. # masterauth <master-password>
     ) D! g4 s% ^5 n' @5 K; v5 o. G. g5 _# e
183. 
     . x: R: w3 T! I) u
184. # When a slave loses its connection with the master, or when the replication
     
185. # is still in progress, the slave can act in two different ways:
     
186. #
     : @2 z# K1 m7 w7 P
187. # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
     
188. #    still reply to client requests, possibly with out of date data, or the
     ( V8 F9 j- P0 Y' T: Q
189. #    data set may just be empty if this is the first synchronization.
     
190. #
     
191. # 2) if slave-serve-stale data is set to 'no' the slave will reply with
     ' K1 L) r$ Z9 X9 W6 K( n
192. #    an error "SYNC with master in progress" to all the kind of commands
     ( e4 T2 M1 L. [3 J
193. #    but to INFO and SLAVEOF.
     
194. #
     1 }- Y" V7 f" _/ e' N
195. slave-serve-stale-data yes
     
196. 
     
197. # You can configure a slave instance to accept writes or not. Writing against
     
198. # a slave instance may be useful to store some ephemeral data (because data
     0 k1 Y, r2 _9 `* [1 ~
199. # written on a slave will be easily deleted after resync with the master) but
     ! F( e9 F* [) H1 Q9 I8 p
200. # may also cause problems if clients are writing to it because of a
     # G# k% s8 q8 |0 R$ k7 A2 h. R& Q
201. # misconfiguration.
     
202. #
     ) b* J. C1 Q, `/ R9 s$ R+ ]7 B
203. # Since Redis 2.6 by default slaves are read-only.
     # x: e7 R/ E, N9 c
204. #
     
205. # Note: read only slaves are not designed to be exposed to untrusted clients
     
206. # on the internet. It's just a protection layer against misuse of the instance.
     , B0 w! U: W/ g( B  B5 n( O- ~
207. # Still a read only slave exports by default all the administrative commands
     - y  e5 ]" [9 A& h
208. # such as CONFIG, DEBUG, and so forth. To a limited extend you can improve
     
209. # security of read only slaves using 'rename-command' to shadow all the
     ! ^# x4 q& t0 ~
210. # administrative / dangerous commands.
     . \2 }  @2 B( x
211. slave-read-only yes
     
212. 
     , s8 _; x: G, ?7 k8 Y/ u- Z& P
213. # Slaves send PINGs to server in a predefined interval. It's possible to change
     
214. # this interval with the repl_ping_slave_period option. The default value is 10
     
215. # seconds.
     
216. #
     2 }! I' h% E# A
217. # repl-ping-slave-period 10
     ! O. }, ~# I# s% O6 O, [
218. 
     0 f  C" _3 j- y9 _+ g/ x
219. # The following option sets a timeout for both Bulk transfer I/O timeout and
     
220. # master data or ping response timeout. The default value is 60 seconds.
     
221. #
     ( A& T  S1 i; S& N. W4 N
222. # It is important to make sure that this value is greater than the value
     
223. # specified for repl-ping-slave-period otherwise a timeout will be detected
     
224. # every time there is low traffic between the master and the slave.
     6 R4 \& s- R+ R% Z
225. #
     ( Y3 O$ E8 h' a+ e* j
226. # repl-timeout 60
     
227. 
       Q7 e6 j* D1 F# H7 O- f8 g
228. # Disable TCP_NODELAY on the slave socket after SYNC?
     7 `' s8 @. |( Z" \
229. #
     
230. # If you select "yes" Redis will use a smaller number of TCP packets and
     / }3 j# k1 f! D# ^( d% B* u% G
231. # less bandwidth to send data to slaves. But this can add a delay for
     . c* T" x: }" `
232. # the data to appear on the slave side, up to 40 milliseconds with
     
233. # Linux kernels using a default configuration.
     
234. #
     
235. # If you select "no" the delay for data to appear on the slave side will
     1 C& m3 I, K. I6 c( K
236. # be reduced but more bandwidth will be used for replication.
     
237. #
     
238. # By default we optimize for low latency, but in very high traffic conditions
     
239. # or when the master and slaves are many hops away, turning this to "yes" may
     4 r# I/ K* S/ G( N
240. # be a good idea.
     5 w% j4 y4 w" [/ X3 p) j
241. repl-disable-tcp-nodelay no
     ; \" E& ^  h% B. g. y3 ^* r6 e! H+ f
242. 
     7 C7 l; }( M* {# g1 h4 O
243. # The slave priority is an integer number published by Redis in the INFO output.
     
244. # It is used by Redis Sentinel in order to select a slave to promote into a
     ( ~# j7 A# @% ~7 B
245. # master if the master is no longer working correctly.
     ; y) U9 O- z' u5 t7 Z
246. #
     
247. # A slave with a low priority number is considered better for promotion, so
     * J4 |9 X- X/ o2 v3 ~! O
248. # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
     ( \/ |; T8 p; m  \  h$ I- ^
249. # pick the one wtih priority 10, that is the lowest.
     
250. #
     2 l5 f2 o2 a9 r$ b
251. # However a special priority of 0 marks the slave as not able to perform the
     
252. # role of master, so a slave with priority of 0 will never be selected by
     
253. # Redis Sentinel for promotion.
     . v/ X3 f; w: T% F" f
254. #
     8 E" {; z! {: |0 q/ ^( f" ~1 `
255. # By default the priority is 100.
     
256. slave-priority 100
     ; ^# z$ k" t, C' @
257. 
     
258. ################################## SECURITY ###################################
     
259. 
     . T) J* p' c. N- Z( ^9 l
260. # Require clients to issue AUTH <ASSWORD> before processing any other
     5 o& ]& h0 X+ W+ k' ?; ~
261. # commands.  This might be useful in environments in which you do not trust
     4 q( V0 U: C/ A- ]9 I; ?
262. # others with access to the host running redis-server.
     
263. #
     
264. # This should stay commented out for backward compatibility and because most
     7 i0 x6 {. F. v9 }* y$ ^
265. # people do not need auth (e.g. they run their own servers).
       G( `. z0 G8 A3 g' d
266. #
     6 O# T3 x9 ~& Y* @( z. T7 E
267. # Warning: since Redis is pretty fast an outside user can try up to
     ( w' B6 _: v8 p, _) ]$ Y# ]" y
268. # 150k passwords per second against a good box. This means that you should
     1 q% F4 Y7 F, [
269. # use a very strong password otherwise it will be very easy to break.
     
270. #
       F4 K4 K7 C9 @" G( T  ~
271. # requirepass foobared
     
272. 
     2 }# H- I7 Z0 a5 p& m; ^" ?
273. # Command renaming.
     
274. #
     ( |8 a& B% V/ q/ ]  E& j9 D' d# j( ^
275. # It is possible to change the name of dangerous commands in a shared
     6 W+ ^& G, |$ e$ Y$ e
276. # environment. For instance the CONFIG command may be renamed into something
     7 e5 q4 Q4 V. o1 ^
277. # hard to guess so that it will still be available for internal-use tools
     6 b4 n' D' N5 n9 B
278. # but not available for general clients.
     6 i, e, f- r( I" {1 }
279. #
     
280. # Example:
     
281. #
     ! X5 H9 T3 m! |! w* X" F
282. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
     5 @! o2 X- D( M
283. #
     
284. # It is also possible to completely kill a command by renaming it into
     
285. # an empty string:
     $ \3 n( W& `* z7 ^
286. #
     
287. # rename-command CONFIG ""
     
288. 
     
289. ################################### LIMITS ####################################
     
290. 
     $ J8 ^5 w0 ?& ^7 U# I
291. # Set the max number of connected clients at the same time. By default
     3 F) Z6 w! z( q. d  [
292. # this limit is set to 10000 clients, however if the Redis server is not
     ; r( C; b+ A4 s1 ^& m! G9 }
293. # able to configure the process file limit to allow for the specified limit
     ( Z# m# t' ^# U2 h/ q* ^( w
294. # the max number of allowed clients is set to the current file limit
     / `+ g' [) x. Y  M9 |: g
295. # minus 32 (as Redis reserves a few file descriptors for internal uses).
     
296. #
     , H! Z' e8 n. T- Q
297. # Once the limit is reached Redis will close all the new connections sending
     ' k" |& g* a" q
298. # an error 'max number of clients reached'.
     
299. #
     ; b/ h, |$ F- [7 A9 t3 ?1 @8 x
300. maxclients 500
     ( y! `& V  a" N
301. 
       R; L- P6 i; C6 n" U3 w
302. # Don't use more memory than the specified amount of bytes.
     # H% ]* y+ U2 z) [* o& b% C5 y% h% B
303. # When the memory limit is reached Redis will try to remove keys
     2 ?' C2 W0 J5 K0 W. A, M/ O
304. # accordingly to the eviction policy selected (see maxmemmory-policy).
     ' ~3 g7 e. o# T; W( j
305. #
     : R" z; B0 `, ?4 Y
306. # If Redis can't remove keys according to the policy, or if the policy is
     & ^7 O! M; t8 M  E
307. # set to 'noeviction', Redis will start to reply with errors to commands
     
308. # that would use more memory, like SET, LPUSH, and so on, and will continue
     
309. # to reply to read-only commands like GET.
     
310. #
     
311. # This option is usually useful when using Redis as an LRU cache, or to set
     
312. # an hard memory limit for an instance (using the 'noeviction' policy).
     ! w4 {/ ]! r! @5 l& ^7 i
313. #
     
314. # WARNING: If you have slaves attached to an instance with maxmemory on,
     
315. # the size of the output buffers needed to feed the slaves are subtracted
     $ L2 I' T! F9 q9 t5 _$ C& p: ]
316. # from the used memory count, so that network problems / resyncs will
     
317. # not trigger a loop where keys are evicted, and in turn the output
       R- t: U& I+ Y9 x
318. # buffer of slaves is full with DELs of keys evicted triggering the deletion
     0 h3 y! P2 E7 r
319. # of more keys, and so forth until the database is completely emptied.
     - G2 X. i9 z. v8 x0 {
320. #
     , r8 x; z9 U% m
321. # In short... if you have slaves attached it is suggested that you set a lower
     . L9 l5 R0 a2 t4 ~5 U, S/ m
322. # limit for maxmemory so that there is some free RAM on the system for slave
     & F2 S5 b. B; b
323. # output buffers (but this is not needed if the policy is 'noeviction').
     
324. #
     ) }; y( g, n% x: w+ b; r- c
325. maxmemory 128000000
     
326. 
     
327. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
     1 L/ n: I0 T7 u1 C* w1 D
328. # is reached. You can select among five behaviors:
     9 b* F1 o# J8 `6 @0 ^& ^0 P
329. #
     
330. # volatile-lru -> remove the key with an expire set using an LRU algorithm
     
331. # allkeys-lru -> remove any key accordingly to the LRU algorithm
     
332. # volatile-random -> remove a random key with an expire set
     ( V. P0 k, m1 n) u
333. # allkeys-random -> remove a random key, any key
     " s8 d& k0 y2 l) B. H9 \3 n4 S
334. # volatile-ttl -> remove the key with the nearest expire time (minor TTL)
     7 \1 T$ a9 a, d7 }! T  v  b
335. # noeviction -> don't expire at all, just return an error on write operations
       w( G. h# _5 w, S7 M
336. #
     
337. # Note: with any of the above policies, Redis will return an error on write
     : U7 T# `! a. `/ Y
338. #       operations, when there are not suitable keys for eviction.
     ) `3 |$ S  x! ~# l  Q
339. #
     
340. #       At the date of writing this commands are: set setnx setex append
     
341. #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
     
342. #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
     $ {" [2 T, F+ H6 H+ C
343. #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
     
344. #       getset mset msetnx exec sort
     
345. #
     
346. # The default is:
     ; ]. I6 a: p1 _3 g9 {
347. #
     
348. # maxmemory-policy volatile-lru
     5 F& K+ B: v) A- V. O, N
349. 
     
350. # LRU and minimal TTL algorithms are not precise algorithms but approximated
     
351. # algorithms (in order to save memory), so you can select as well the sample
     
352. # size to check. For instance for default Redis will check three keys and
     : M4 C  C9 r' {( \$ |2 P
353. # pick the one that was used less recently, you can change the sample size
     
354. # using the following configuration directive.
     
355. #
     
356. # maxmemory-samples 3
     
357. 
     2 ]1 `- z. l$ N
358. ############################## APPEND ONLY MODE ###############################
     
359. 
     1 [' J" ?% L; Z. K
360. # By default Redis asynchronously dumps the dataset on disk. This mode is
     
361. # good enough in many applications, but an issue with the Redis process or
     
362. # a power outage may result into a few minutes of writes lost (depending on
     0 o5 V1 g, p6 P  r& B
363. # the configured save points).
     + J+ \6 O" V! ?+ e# r
364. #
     / P& L5 \3 j+ ~. ]8 w" g' a
365. # The Append Only File is an alternative persistence mode that provides
     
366. # much better durability. For instance using the default data fsync policy
     0 i8 ~/ V0 R1 X& W
367. # (see later in the config file) Redis can lose just one second of writes in a
     " Z6 G# e4 B  H6 q. E
368. # dramatic event like a server power outage, or a single write if something
     + r9 `4 R) ~' P8 B9 b
369. # wrong with the Redis process itself happens, but the operating system is
     # p* K  W# m3 _/ {4 c" I( Y
370. # still running correctly.
     1 O; ]% l2 G6 m/ G
371. #
     
372. # AOF and RDB persistence can be enabled at the same time without problems.
     
373. # If the AOF is enabled on startup Redis will load the AOF, that is the file
     - f3 F. ]! h3 r  ~9 E" E
374. # with the better durability guarantees.
     , [8 B: M$ t! A- @
375. #
     
376. # Please check http://redis.io/topics/persistence for more information.
     
377. 
     : Q. m' u* T8 Q5 q  Q7 g: a; K
378. appendonly no
     
379. 
     ; ~& W# S/ @% d* g. p( N* a
380. # The name of the append only file (default: "appendonly.aof")
     
381. # appendfilename appendonly.aof
     
382. 
     
383. # The fsync() call tells the Operating System to actually write data on disk
     # y5 U; N5 v' S# Y
384. # instead to wait for more data in the output buffer. Some OS will really flush
     
385. # data on disk, some other OS will just try to do it ASAP.
     , m4 `9 p5 D* y  i! E, y4 C% f
386. #
     4 K% O" g% R2 T
387. # Redis supports three different modes:
     / B9 L3 j# X, a0 }' y
388. #
     
389. # no: don't fsync, just let the OS flush the data when it wants. Faster.
     3 w) ?/ }0 y2 C2 n2 s7 l
390. # always: fsync after every write to the append only log . Slow, Safest.
     7 S. n9 ?" k4 I
391. # everysec: fsync only one time every second. Compromise.
     , W4 ~6 Q6 Y/ Q8 a( \" x
392. #
     
393. # The default is "everysec", as that's usually the right compromise between
     2 g4 K) B8 t8 {' w) ~4 s7 w/ N: b
394. # speed and data safety. It's up to you to understand if you can relax this to
     
395. # "no" that will let the operating system flush the output buffer when
     0 ^1 P, ~" o( x3 C; J5 V( ]
396. # it wants, for better performances (but if you can live with the idea of
     4 w: j3 s) e# q
397. # some data loss consider the default persistence mode that's snapshotting),
     6 K4 d  M6 l' O3 `
398. # or on the contrary, use "always" that's very slow but a bit safer than
     
399. # everysec.
     
400. #
     ' x/ P9 T( N0 q5 P5 G/ U- h
401. # More details please check the following article:
     
402. # http://antirez.com/post/redis-persistence-demystified.html
     
403. #
     
404. # If unsure, use "everysec".
     
405. 
     
406. # appendfsync always
     
407. appendfsync everysec
     & d0 M, x9 x! F9 v  q
408. # appendfsync no
     
409. 
     9 ?  o$ |! y* X. G3 y. ]% c8 P7 Q, D! f
410. # When the AOF fsync policy is set to always or everysec, and a background
     ( n6 k& q2 [% M+ x( v
411. # saving process (a background save or AOF log background rewriting) is
     
412. # performing a lot of I/O against the disk, in some Linux configurations
     
413. # Redis may block too long on the fsync() call. Note that there is no fix for
     
414. # this currently, as even performing fsync in a different thread will block
     
415. # our synchronous write(2) call.
     ; @# p7 G, y5 c! g: \3 e4 @
416. #
     
417. # In order to mitigate this problem it's possible to use the following option
     # ]9 d; N  ~9 q" D% q1 c6 c7 C: R! V
418. # that will prevent fsync() from being called in the main process while a
     
419. # BGSAVE or BGREWRITEAOF is in progress.
     
420. #
     4 D  R" M' E/ S
421. # This means that while another child is saving, the durability of Redis is
     ( B1 x4 h2 e, \$ W4 P$ t% [
422. # the same as "appendfsync none". In practical terms, this means that it is
     4 b. A- F- @0 h
423. # possible to lose up to 30 seconds of log in the worst scenario (with the
     . t% z8 t" N$ @. f' R( f
424. # default Linux settings).
       a2 z, ]" B, G% j9 G, `3 j
425. #
     ( r1 R5 f7 Y! W+ A" g- l
426. # If you have latency problems turn this to "yes". Otherwise leave it as
     
427. # "no" that is the safest pick from the point of view of durability.
     
428. no-appendfsync-on-rewrite no
     
429. 
     2 J; u; P3 }  s! F3 N
430. # Automatic rewrite of the append only file.
     2 |1 t2 J% a. f7 }
431. # Redis is able to automatically rewrite the log file implicitly calling
     
432. # BGREWRITEAOF when the AOF log size grows by the specified percentage.
     
433. #
     
434. # This is how it works: Redis remembers the size of the AOF file after the
     # x, \2 O9 a* C  t
435. # latest rewrite (if no rewrite has happened since the restart, the size of
     
436. # the AOF at startup is used).
     
437. #
     
438. # This base size is compared to the current size. If the current size is
     
439. # bigger than the specified percentage, the rewrite is triggered. Also
     
440. # you need to specify a minimal size for the AOF file to be rewritten, this
     
441. # is useful to avoid rewriting the AOF file even if the percentage increase
     
442. # is reached but it is still pretty small.
     " a0 R5 T+ O" P- j
443. #
     
444. # Specify a percentage of zero in order to disable the automatic AOF
     & P5 Q. a2 _7 O& H& a" |7 j; ~
445. # rewrite feature.
     
446. 
     
447. auto-aof-rewrite-percentage 100
     / E2 g" B) m) x* o9 s+ b* ]1 N- j
448. auto-aof-rewrite-min-size 64mb
     0 G# T9 p5 n* E2 P% l8 |( P$ F8 \
449. 
     
450. ################################ LUA SCRIPTING  ###############################
     : B3 I$ r2 l: |1 @
451. 
     
452. # Max execution time of a Lua script in milliseconds.
     0 f" n% R3 o$ P$ I
453. #
     
454. # If the maximum execution time is reached Redis will log that a script is
     
455. # still in execution after the maximum allowed time and will start to
     + ~. F& ^' ^1 }
456. # reply to queries with an error.
     ; e0 ]3 b+ \3 r) N" |9 v3 e
457. #
     
458. # When a long running script exceed the maximum execution time only the
     / [) i0 P) y" o9 @  E: Z# G
459. # SCRIPT KILL and SHUTDOWN NOSAVE commands are available. The first can be
     & e5 \  M" n  }9 Z* G
460. # used to stop a script that did not yet called write commands. The second
     
461. # is the only way to shut down the server in the case a write commands was
     ( T$ B8 k+ Q) h9 N" `8 _
462. # already issue by the script but the user don't want to wait for the natural
     
463. # termination of the script.
     % M6 _) }) K- D3 N. N& k; ]' W) _4 G
464. #
     
465. # Set it to 0 or a negative value for unlimited execution without warnings.
     
466. lua-time-limit 5000
     
467. 
     
468. ################################## SLOW LOG ###################################
     
469. 
     ) M( h& X9 [6 W" B9 v8 c
470. # The Redis Slow Log is a system to log queries that exceeded a specified
     % t& f# A- q/ I5 `8 d1 Q+ e
471. # execution time. The execution time does not include the I/O operations
     * q- r" Y0 a0 H9 n4 ]/ h
472. # like talking with the client, sending the reply and so forth,
     
473. # but just the time needed to actually execute the command (this is the only
     
474. # stage of command execution where the thread is blocked and can not serve
     
475. # other requests in the meantime).
     
476. #
     
477. # You can configure the slow log with two parameters: one tells Redis
     # c" [. j/ ~6 W: i: B/ h
478. # what is the execution time, in microseconds, to exceed in order for the
     4 z) l* {% {) f! V2 f) R
479. # command to get logged, and the other parameter is the length of the
     " p% y' ?( u+ ]( h2 ^& D
480. # slow log. When a new command is logged the oldest one is removed from the
     
481. # queue of logged commands.
     
482. 
     # t+ s# w' s4 _# R# s
483. # The following time is expressed in microseconds, so 1000000 is equivalent
     
484. # to one second. Note that a negative number disables the slow log, while
     
485. # a value of zero forces the logging of every command.
     
486. slowlog-log-slower-than 10000
     
487. 
     0 m$ m- `. C% w
488. # There is no limit to this length. Just be aware that it will consume memory.
     
489. # You can reclaim memory used by the slow log with SLOWLOG RESET.
     ! N* j, [: Y- u" g+ E0 L1 h6 u# c
490. slowlog-max-len 128
     / `2 e. Z4 \, s4 X* I
491. 
     " f. e0 [) V- L! e* g; G) \
492. ############################### ADVANCED CONFIG ###############################
     - d2 z' M6 g8 {/ K2 X7 q4 U+ Z
493. 
     5 Y- `( Q) `; w  t) X# L, M  @
494. # Hashes are encoded using a memory efficient data structure when they have a
     , W0 ]  h# w) |* u
495. # small number of entries, and the biggest entry does not exceed a given
     
496. # threshold. These thresholds can be configured using the following directives.
     
497. hash-max-ziplist-entries 512
     
498. hash-max-ziplist-value 64
     
499. 
     / W* Z' w/ }8 V- Z  q
500. # Similarly to hashes, small lists are also encoded in a special way in order
     
501. # to save a lot of space. The special representation is only used when
     
502. # you are under the following limits:
     
503. list-max-ziplist-entries 512
     
504. list-max-ziplist-value 64
       b5 R0 I% g5 h( T
505. 
       z5 `4 D. `, [3 L9 l4 B
506. # Sets have a special encoding in just one case: when a set is composed
     
507. # of just strings that happens to be integers in radix 10 in the range
     ! ?  U; a+ P% _  a8 ]' K
508. # of 64 bit signed integers.
     # o9 g0 @# l6 Z
509. # The following configuration setting sets the limit in the size of the
     
510. # set in order to use this special memory saving encoding.
     1 V$ }; V5 h, P. ^! ~( E
511. set-max-intset-entries 512
     , Z; P2 c+ k% s" o, K' a6 h4 [& ^" g
512. 
     
513. # Similarly to hashes and lists, sorted sets are also specially encoded in
     
514. # order to save a lot of space. This encoding is only used when the length and
     # f, P  ?' o8 D% T
515. # elements of a sorted set are below the following limits:
     % f" g6 J% m5 O% n: o  n
516. zset-max-ziplist-entries 128
     
517. zset-max-ziplist-value 64
     
518. 
     - [! h5 |3 c1 J! z( L8 h! N& t
519. # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
     
520. # order to help rehashing the main Redis hash table (the one mapping top-level
     - P3 C7 {7 q  P3 }
521. # keys to values). The hash table implementation Redis uses (see dict.c)
     
522. # performs a lazy rehashing: the more operation you run into an hash table
     
523. # that is rehashing, the more rehashing "steps" are performed, so if the
       C% C7 B- \% [+ v
524. # server is idle the rehashing is never complete and some more memory is used
     9 T3 g5 k9 D6 N1 t6 a
525. # by the hash table.
     * i8 }$ N+ F7 R  |5 n9 f) R% A! J
526. #
     + [9 g- \/ P- V- J
527. # The default is to use this millisecond 10 times every second in order to
     
528. # active rehashing the main dictionaries, freeing memory when possible.
     4 Z$ e( q( O: I3 `6 v
529. #
     
530. # If unsure:
     
531. # use "activerehashing no" if you have hard latency requirements and it is
     
532. # not a good thing in your environment that Redis can reply form time to time
     ) w: b! @1 ], s& a4 l1 l' a+ d* D
533. # to queries with 2 milliseconds delay.
     1 c5 Z. m+ [! f% j4 r0 W  N9 D& y' F
534. #
     
535. # use "activerehashing yes" if you don't have such hard requirements but
     
536. # want to free memory asap when possible.
     
537. activerehashing yes
     
538. 
     3 ^; e" @1 E/ S2 ]6 {, U
539. # The client output buffer limits can be used to force disconnection of clients
     ; w/ \0 j" r1 r* N4 l4 J) {4 m/ `
540. # that are not reading data from the server fast enough for some reason (a
     
541. # common reason is that a Pub/Sub client can't consume messages as fast as the
     & a' x* l9 K9 t+ Y1 O' q
542. # publisher can produce them).
     
543. #
     / g4 f0 J& S& M: O6 w* G
544. # The limit can be set differently for the three different classes of clients:
     5 z3 Z/ R5 [+ ^( b  r7 e
545. #
     
546. # normal -> normal clients
     4 H" @, ?3 q* h/ ?
547. # slave  -> slave clients and MONITOR clients
     
548. # pubsub -> clients subcribed to at least one pubsub channel or pattern
     ) A. [& N) Y! I2 `* |
549. #
     
550. # The syntax of every client-output-buffer-limit directive is the following:
     4 |% H2 m6 z; p0 z3 W% r+ l
551. #
     ( q0 q  N% ~# }0 z; ^- C# b
552. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
     ) @9 R( P. ?+ U# e+ a6 l, }+ p
553. #
     " @2 e" g2 L5 D  {# i0 |( g4 a
554. # A client is immediately disconnected once the hard limit is reached, or if
     8 k8 @: t/ s4 w  A. l9 N7 x
555. # the soft limit is reached and remains reached for the specified number of
     
556. # seconds (continuously).
     * b8 B; [" ?1 m8 S  V) O- N
557. # So for instance if the hard limit is 32 megabytes and the soft limit is
     ' S# R$ q5 ?" o8 v2 J5 K) M* z
558. # 16 megabytes / 10 seconds, the client will get disconnected immediately
     
559. # if the size of the output buffers reach 32 megabytes, but will also get
     $ R0 B& J3 _/ E2 V  e- q$ i  u: h
560. # disconnected if the client reaches 16 megabytes and continuously overcomes
     
561. # the limit for 10 seconds.
     + y# H8 D* ~/ y( a6 d
562. #
     
563. # By default normal clients are not limited because they don't receive data
     " A$ d- I. e+ x: K
564. # without asking (in a push way), but just after a request, so only
     1 X9 ^& r/ C3 X& o( ?, D0 n% y
565. # asynchronous clients may create a scenario where data is requested faster
     7 r- J4 [4 c9 T; O. b4 n
566. # than it can read.
     1 s3 U& u0 V1 ?' E$ ?
567. #
     
568. # Instead there is a default limit for pubsub and slave clients, since
     % v% A4 n2 B8 _% M
569. # subscribers and slaves receive data in a push fashion.
     % V& ]* {) z- h6 N
570. #
     
571. # Both the hard or the soft limit can be disabled by setting them to zero.
     
572. client-output-buffer-limit normal 0 0 0
     " E/ x; [4 A) T. d' X$ ?% ^
573. client-output-buffer-limit slave 256mb 64mb 60
     ' {3 V. W1 |+ V, y
574. client-output-buffer-limit pubsub 32mb 8mb 60
     5 [4 B" ?7 S: {1 H6 q1 V
575. 
     
576. ################################## INCLUDES ###################################
     
577. 
     7 y7 m( ^1 s( E* a7 a3 m
578. # Include one or more other config files here.  This is useful if you
     
579. # have a standard template that goes to all Redis server but also need
     : b/ i& p; Z: q4 t% Q2 K
580. # to customize a few per-server settings.  Include files can include
     " a! c2 E5 p) ~
581. # other files, so use this wisely.
     
582. #
     , ^, d. b: ^. P. l1 {
583. # include /path/to/local.conf
     
584. # include /path/to/other.conf        
     . W) U  \& F! V/ l6 a. R; D2 P9 a
585. ##########################配置文件结束################################
     ; w( u1 x! c( X* F
586. 第三步：启动进程
     
587. #redis-server /etc/redis.conf
     5 F2 V7 J, c& `" h$ x
588. 查看进程有没有成功启动
     
589. #ps -ef | grep redis
     
590. 测试输入一个键值
     
591. #redis-cli set test "testredis"
     
592. 获取键值
     
593. #redis-cli get test
     
594. 
     ) T( w) S' z- Z) `( g
595. 
     3 E7 T9 ^. ~2 \& E  F
596. 第四步:关闭redis  (这个是更改配置文件后 正常的重启方式  不重新加载redis配置跳过)
     
597. # redis-cli shutdown      //关闭所有   
     8 x& S7 X4 ~9 H/ K  f
598. 关闭某个端口上的redis   
     : M1 q9 Q  {2 b9 n2 k2 I4 V
599. # redis-cli -p 6397 shutdown  //关闭6397端口的redis  
     
600. 说明：关闭以后缓存数据会自动dump到硬盘上，硬盘地址见redis.conf中的dbfilename  dump.rdb  
     1 A! b% {  w) {6 o9 d" `! o+ b
601. 
     
602. 
     6 S2 a( U! y1 h& Q0 Q
603. 第5步:php扩展安装
     # |# ?) t3 U9 s4 \
604. phpredis PHP扩展下载地址
     
605. https://github.com/nicolasff/phpredis/tree/2.2.2
     
606. 选择最新版本下载zip
     % h- P3 [. o: o+ i/ v
607. 
     ; \7 _+ P0 Z- ^( X' H
608. 然后自己上传zip  用unzip解压到当前目录 unzip 文件名
     : H& d4 c9 \8 u7 @+ Q- ?( c
609. 
     
610. # cd owlient-phpredis-90ecd17/   #打开解压后的文件夹里面  这个解压后的目录 要是不知道 可以输入 "dir" 查看
     
611. # /www/nginx_php-5.2.17/bin
     
612. # ./configure --with-php-config=/www/nginx_php-5.2.17/bin/php-config
     
613. #make
     ) g- ~4 m8 v4 @# b5 E" C  p
614. #make install   #记录产生的redis.so路径
     0 t" C2 j0 C5 _; y
615. 
     , j4 N: T0 N0 \' d4 g, l( |
616. 修改php.ini文件
     
617. 在php.ini中添加如下一行：
     
618. extension=/?/redis.so  #是刚刚记录的产生redis.so的路 写在 ?那
     : i% M9 k1 R) I- k. r
619. 重启 使之生效：
     
620. /usr/local/php/sbin/php-fpm reload
     
621. /usr/local/nginx/sbin/nginx -s reload
     - P9 g+ n# t  ~, Q/ f
622. 
     
623. 将 Redis 作为 Linux 服务随机启动
     : r/ \' ]# p6 s0 L1 |
624. vi /etc/rc.local, 加入代码：
     
625. /root/redis-2.6.10/src/redis-serve  #路径看情况修改
     , z: z% l0 ^; A  |- T
626. 
     
627. redis-cli -h localhost -p 6379 info  #命令要在redis目录下面执行
     
628. 提供host为localhost，端口为6379，redis服务的统计信息
     . N+ K: ^( s+ {# U/ i
629. 
     ( V  M8 X- N( F
630. 
     9 E  _; J. W& B# |, W, X* u
631. 就这样你的web服务器就支持redis了 记得要在 给dz 的配置文件 加上12.0.0.1哦
     
632. dz配置文件在 config目录下面的 config_global.php
     
633. $_config['memory']['redis']['server'] = '127.0.0.1';
     
634. $_config['memory']['redis']['port'] = 6379;
     ( v, p/ A3 H  b1 z4 o
635. $_config['memory']['redis']['pconnect'] = 1;
     
636. $_config['memory']['redis']['timeout'] = '0';
     
637. $_config['memory']['redis']['serializer'] = 1;
     

复制代码