DZ

壹加壹

环境配置

+ S' D* t  p/ R6 B
http://www.discuz.net/forum.php? ... amp;highlight=REDIS

壹加壹

http://www.discuz.net/forum.php? ... 648&highlight=REDIS
4 W) d. A# A, a' T5 n" w无意间测试 单机状态 redis相当给力 测试1000请求/s  单纯的 get 和set 居然只用了 0.01秒 当时我惊呆了

' t+ l8 R2 K0 [3 V: N9 v7 phttp://www.discuz.net/forum.php? ... 731&highlight=REDIS
! b* \  ^# i+ h+ ~3 K6 _
https://wenku.baidu.com/view/265a5ce176a20029bc642d0b.html

. b& c0 f$ {* W＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
& A3 u0 V% |* \' g/ e

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

复制代码