DZ

壹加壹

环境配置


# u9 z6 A3 l0 S2 K  Z8 F: L( Ahttp://www.discuz.net/forum.php? ... amp;highlight=REDIS

壹加壹

http://www.discuz.net/forum.php? ... 648&highlight=REDIS
无意间测试 单机状态 redis相当给力 测试1000请求/s  单纯的 get 和set 居然只用了 0.01秒 当时我惊呆了
- F3 R  Y  W% ], j! O% C1 S  @7 B" j
http://www.discuz.net/forum.php? ... 731&highlight=REDIS

https://wenku.baidu.com/view/265a5ce176a20029bc642d0b.html
' `6 @( V' j, w
2 w- U" F, ^7 O9 v5 E& Z- B' J4 W, i＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
' c, C) D2 Y% I& v3 a% z

1. 连接上 ssh
   ' T. \7 J# W0 X/ S$ `  Z
2. 
   
3. 
   ( o9 t5 L, e* L6 w% c7 i
4. 第一步:下载redis
   + U. m' l( V: v% a3 R1 U& U2 K
5. # wget http://redis.googlecode.com/files/redis-2.6.10.tar.gz
   0 L% m' p' z4 y* ?' g
6. # tar zxvf redis-2.6.10.tar.gz
   
7. # cd redis-2.6.10
   
8. # make
   
9. # make install  
   4 o& Z4 E! D8 m; E9 {& t; |, h
10. #cp redis.conf  /etc/ #复制配置文件到etc目录下面
    # e) Z: `! @+ K( Y+ F
11. 第二步：修改配置
    
12. #vi /etc/redis.conf
    
13. ######################下面是无措的配置文件 复制过去就成#########
    ' ~4 y5 b! ~  |4 R8 V4 o3 k
14. # Redis configuration file example
    5 B, j# k. Y* A1 H! z6 `
15. 
    8 {- {4 d1 c2 Z4 G; y) r$ p3 i
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
    
21. # 1m => 1000000 bytes
    
22. # 1mb => 1024*1024 bytes
    
23. # 1g => 1000000000 bytes
    
24. # 1gb => 1024*1024*1024 bytes
    4 O" L4 g1 G; ]
25. #
    5 |/ {  N& t0 W" [. o
26. # units are case insensitive so 1GB 1Gb 1gB are all the same.
    $ L* E/ `5 E% O3 {
27. 
    
28. # By default Redis does not run as a daemon. Use 'yes' if you need it.
    5 @( u9 p9 y3 c
29. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
    3 x# `2 ?, _3 l( Q/ b) E$ U
30. daemonize yes
    
31. 
    
32. # When running daemonized, Redis writes a pid file in /var/run/redis.pid by
    " I: G, x6 U1 E# u& ^+ L
33. # default. You can specify a custom pid file location here.
    ) K5 E9 U/ C' q& D
34. pidfile /var/run/redis.pid
    
35. 
    
36. # Accept connections on the specified port, default is 6379.
    9 L6 @' O; b) ^6 M8 b
37. # If port 0 is specified Redis will not listen on a TCP socket.
    % k6 [) U+ Q3 H3 y( T9 w$ k
38. port 6379
    
39. 
    
40. # If you want you can bind a single interface, if the bind option is not
    / i6 |( K8 \! N! {4 v, Q
41. # specified all the interfaces will listen for incoming connections.
    
42. #
    
43. # bind 127.0.0.1
    % r+ Q- E( n) W0 n/ j3 ^
44. 
    $ ]- K3 X+ Z& u6 x0 e7 Z
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
    
47. # on a unix socket when not specified.
    3 O0 m# h: ~  N( H
48. #
    , t0 A: e' k. T6 @
49. # unixsocket /tmp/redis.sock
    4 H8 S( q% _7 W1 O' ]
50. # unixsocketperm 755
    ' F' A5 K' Q7 _; b: \) _4 g9 P# A) E
51. 
    . J# b. B4 r" }# a5 o
52. # Close the connection after a client is idle for N seconds (0 to disable)
    
53. timeout 300
    
54. 
    
55. # TCP keepalive.
    
56. #
    3 O9 u/ L" N. b; r6 O
57. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
    
58. # of communication. This is useful for two reasons:
    6 L# ?; @; k, _( }$ @
59. #
    
60. # 1) Detect dead peers.
      j3 q, Q: t: F! M7 u* F% w
61. # 2) Take the connection alive from the point of view of network
    
62. #    equipment in the middle.
    
63. #
    ) R: `' V: x5 Q  q8 E
64. # On Linux, the specified value (in seconds) is the period used to send ACKs.
    " H- v. {/ n- n$ c+ U% }0 ~' n
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.
    6 t; F; S# W. M( o7 F/ j* Y; x5 Y
67. #
    : C0 I( H* n) ~5 _
68. # A reasonable value for this option is 60 seconds.
    & _/ ~0 ?( c& T' W6 F# J$ i, D# \
69. tcp-keepalive 0
    
70. 
    
71. # Specify the server verbosity level.
    / z( E% U: D  g% i  h9 m" _7 b* V
72. # This can be one of:
    
73. # debug (a lot of information, useful for development/testing)
    - m+ o9 \% r9 F
74. # verbose (many rarely useful info, but not a mess like the debug level)
    ( q7 Z: k4 T% S7 i" |. M
75. # notice (moderately verbose, what you want in production probably)
    & u/ O; X. e' ~: ~! }5 b
76. # warning (only very important / critical messages are logged)
    
77. loglevel warning
    ; d" m9 F3 K& a* \% l
78. 
    
79. # Specify the log file name. Also 'stdout' can be used to force
    ) b. x" q" v  e( e( q+ g
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
    ( F2 y# D: V( s& i4 ^
83. 
    2 f' m# w% {% C/ }) `/ N
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.
    1 G) p* i4 U3 ~6 ~7 C8 r3 D$ A
86. syslog-enabled yes
    
87. 
    . F& h$ k1 V7 j4 H& x6 [) f( A
88. # Specify the syslog identity.
    
89. # syslog-ident redis
    
90. 
    . A1 Q+ a" t, u5 v# }5 X
91. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
    ; _# N3 u' s, u7 `: a
92. syslog-facility local0
    5 X1 R" E) J! e% o! m/ B, w6 N
93. 
    $ ~2 k6 H$ p- _% p& n9 c  k
94. # Set the number of databases. The default database is DB 0, you can select
    
95. # a different one on a per-connection basis using SELECT <dbid> where
    
96. # dbid is a number between 0 and 'databases'-1
    ' {6 T2 T! a& j
97. databases 16
    # l2 c3 c0 g! K. Z9 r
98. 
    * ]" U; z2 {) c8 y
99. ################################ SNAPSHOTTING  #################################
    
100. #
     $ D8 `8 L8 [2 m5 h( a/ ]$ ~
101. # Save the DB on disk:
     1 ~1 r* i  H4 x5 |% j; @
102. #
     
103. #   save <seconds> <changes>
     
104. #
     ) i( o& {& |; l' e" O( W" Y, P
105. #   Will save the DB if both the given number of seconds and the given
     
106. #   number of write operations against the DB occurred.
     
107. #
     
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
     4 A* [3 G$ F! ?! @8 m" W1 \5 Y5 f
111. #   after 60 sec if at least 10000 keys changed
     1 |; k. x! K" _9 y+ O" |2 s
112. #
     
113. #   Note: you can disable saving at all commenting all the "save" lines.
       i, a8 N) k/ P0 g
114. #
     : m; p3 N/ d5 H  m9 u
115. #   It is also possible to remove all the previously configured save
     9 f$ z4 r$ D% {8 e, Z8 r, B5 }" ^
116. #   points by adding a save directive with a single empty string argument
     
117. #   like in the following example:
     + `* d$ J5 l1 a" }1 ?
118. #
     4 @: q. z; ~5 Q3 j
119. #   save ""
     6 |. ?* L& M& p5 m6 b- u# K
120. 
     
121. save 900 1
     
122. save 300 10
     
123. save 60 10000
     
124. 
     
125. # By default Redis will stop accepting writes if RDB snapshots are enabled
     5 I4 n. C; K$ K. H0 G% w
126. # (at least one save point) and the latest background save failed.
     ; p, O5 w4 J7 M
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. #
     5 x3 J8 }8 g3 ~2 w4 K' N
131. # If the background saving process will start working again Redis will
     ) T8 T. i! M6 g4 ?
132. # automatically allow writes again.
     
133. #
     3 x; t" f% e# M) r
134. # However if you have setup your proper monitoring of the Redis server
     : A0 E8 D( }) Y3 k6 P, F- q5 @
135. # and persistence, you may want to disable this feature so that Redis will
     5 r& Q1 ]1 M7 p* C) `: M
136. # continue to work as usually even if there are problems with disk,
     6 d$ m- A, G8 b. ^) n
137. # permissions, and so forth.
     $ h$ n+ N% m& L5 L4 y
138. stop-writes-on-bgsave-error yes
     
139. 
     * k. b: D, m1 {
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.
     4 h* b! p; Y% V6 I) G" M! p
144. rdbcompression yes
     / ~5 A& ^# u2 P# V8 a/ j
145. 
     0 t4 X* i. P4 \2 Q2 a
146. # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
     
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.
     ' Q) I( j* A+ J! Z8 j
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. 
     7 D' M% c+ g! p5 l
155. # The filename where to dump the DB
     ; `. Q8 }* b# |, O' B+ `3 C
156. dbfilename dump.rdb
     + A* U$ _! w$ ^2 _
157. 
     
158. # The working directory.
     
159. #
     . R* Z! Q2 u; B% m+ L) K
160. # The DB will be written inside this directory, with the filename specified
     * k# f$ T8 c7 R* b) v
161. # above using the 'dbfilename' configuration directive.
     5 h  j* i6 ?! Y  q
162. #
     
163. # The Append Only File will also be created inside this directory.
     ' s1 h0 M; i/ }$ }! O* p
164. #
     
165. # Note that you must specify a directory here, not a file name.
     3 l1 }4 i1 c$ ^4 ]7 R- L! B
166. dir /var/db/redis
     5 h! R* l; }0 w9 `3 r
167. 
     
168. ################################# REPLICATION #################################
     ( V, {" q. G4 u& Z; A. a+ q
169. 
     
170. # Master-Slave replication. Use slaveof to make a Redis instance a copy of
     ! j; O" Z3 M7 q4 ^5 n7 j8 ?
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
     
173. # different interval, or to listen to another port, and so on.
     
174. #
     
175. # slaveof <masterip> <masterport>
     
176. 
       M- q/ v  A! [! z* }
177. # If the master is password protected (using the "requirepass" configuration
     
178. # directive below) it is possible to tell the slave to authenticate before
     / F* S4 {4 d& q" D
179. # starting the replication synchronization process, otherwise the master will
     
180. # refuse the slave request.
     
181. #
     
182. # masterauth <master-password>
     
183. 
     5 K  \1 `& ?8 b$ C3 }& e3 \% w
184. # When a slave loses its connection with the master, or when the replication
     - z4 Q( f" n7 Z3 d4 p
185. # is still in progress, the slave can act in two different ways:
     
186. #
     , f0 t  f$ z$ Z; _! A( E* w
187. # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
     1 Y5 r* f% h. K* B& v
188. #    still reply to client requests, possibly with out of date data, or the
     / ?3 Z% j0 E  J- F
189. #    data set may just be empty if this is the first synchronization.
     
190. #
     : k/ k1 V4 w3 \3 D- T+ y
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
     
193. #    but to INFO and SLAVEOF.
     " x/ `& X+ e4 q5 G
194. #
     9 j5 V+ |0 Y9 `3 A7 l% d
195. slave-serve-stale-data yes
     1 ~4 \- d: C5 {1 i
196. 
     : V. v7 q- U7 A2 L
197. # You can configure a slave instance to accept writes or not. Writing against
     3 ^" N% f' a, t- Q: n
198. # a slave instance may be useful to store some ephemeral data (because data
     / {/ Z* u# M) d. G$ c& |
199. # written on a slave will be easily deleted after resync with the master) but
     
200. # may also cause problems if clients are writing to it because of a
     ' ~, J4 o1 y# w& Z3 r
201. # misconfiguration.
     
202. #
     : C( E* d. Y: a- K& V
203. # Since Redis 2.6 by default slaves are read-only.
     2 ?3 s0 y4 ^7 w- Z# i( t4 F
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.
     4 A7 T( W, j8 }
207. # Still a read only slave exports by default all the administrative commands
     & N" @! v. I5 `3 N' W% c4 I
208. # such as CONFIG, DEBUG, and so forth. To a limited extend you can improve
     ; o' R2 ]6 c' W# o' p( b
209. # security of read only slaves using 'rename-command' to shadow all the
     ' x+ }* |5 h, K. [7 G
210. # administrative / dangerous commands.
     4 I1 ^  S; }2 L' N
211. slave-read-only yes
     
212. 
     
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
     : D; S1 r( V3 ]. C* v4 g4 b4 T
215. # seconds.
     + ?0 h9 l, d3 m$ c, ?: l9 l
216. #
     
217. # repl-ping-slave-period 10
     
218. 
     
219. # The following option sets a timeout for both Bulk transfer I/O timeout and
     " }  H2 u, O! u" i+ e
220. # master data or ping response timeout. The default value is 60 seconds.
     1 z7 J4 ~# Y8 P+ X/ t2 [
221. #
     4 J+ F- B; x0 ^8 a) {, W
222. # It is important to make sure that this value is greater than the value
     + E, ^% h( h1 y+ T- X4 C2 V
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.
     4 f: {8 K$ |7 g" r
225. #
     
226. # repl-timeout 60
     
227. 
     6 R0 F3 X* i" Q# g: f& J6 ]
228. # Disable TCP_NODELAY on the slave socket after SYNC?
     4 Y/ p" y# y% `9 c. z, O! S
229. #
     
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
     - i* r: J% ^3 f8 k0 M+ d
232. # the data to appear on the slave side, up to 40 milliseconds with
     
233. # Linux kernels using a default configuration.
     0 @, g- L2 T  M' d1 M
234. #
     , p: v! b. z8 C0 r/ E" o
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.
     
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
     , G" H0 ]% @$ M0 a: L% C$ o* t
240. # be a good idea.
     
241. repl-disable-tcp-nodelay no
     5 J3 m9 y2 j$ W. C, u1 e
242. 
     $ Q) e9 `$ C5 \3 s4 E
243. # The slave priority is an integer number published by Redis in the INFO output.
     % O. U( F- T1 W9 G: n. H4 ^: k
244. # It is used by Redis Sentinel in order to select a slave to promote into a
     3 I( y4 c- s+ ]$ D; a' L
245. # master if the master is no longer working correctly.
     
246. #
     ' Y! n3 C9 N# }
247. # A slave with a low priority number is considered better for promotion, so
     
248. # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
     , t+ g3 s* S' m" a0 o3 A
249. # pick the one wtih priority 10, that is the lowest.
     : A  y" D# g3 s7 \' r
250. #
     
251. # However a special priority of 0 marks the slave as not able to perform the
     ! O: A- u; i0 Y% v1 L: g% f; |
252. # role of master, so a slave with priority of 0 will never be selected by
     
253. # Redis Sentinel for promotion.
     
254. #
     + ^; M9 [# f9 S( e9 R4 ]# ~, L# i
255. # By default the priority is 100.
     
256. slave-priority 100
     , n) b+ v/ G7 p  d
257. 
     $ S7 V/ O# J+ @: g
258. ################################## SECURITY ###################################
     
259. 
     8 L; H8 r$ @9 Y& a  u, m
260. # Require clients to issue AUTH <ASSWORD> before processing any other
     : p! X* ~5 _& p8 D* V: r
261. # commands.  This might be useful in environments in which you do not trust
       B4 p+ S1 l* t/ U/ t# C+ E8 N) d1 r; B; u
262. # others with access to the host running redis-server.
     
263. #
     - H4 ~9 r) i1 z; [1 k
264. # This should stay commented out for backward compatibility and because most
     
265. # people do not need auth (e.g. they run their own servers).
     " p" v4 C9 J2 c( [5 A. R
266. #
     
267. # Warning: since Redis is pretty fast an outside user can try up to
     
268. # 150k passwords per second against a good box. This means that you should
     
269. # use a very strong password otherwise it will be very easy to break.
     4 z: i  M- B. w* X  E. F
270. #
     # G8 `: i1 R0 m7 ]+ p2 V
271. # requirepass foobared
     # |/ `' A9 x4 q6 ^/ q
272. 
     0 b# B5 S; o0 P$ t
273. # Command renaming.
     
274. #
     
275. # It is possible to change the name of dangerous commands in a shared
     
276. # environment. For instance the CONFIG command may be renamed into something
     + |# V. f# \1 e" h8 E% ]# |4 v
277. # hard to guess so that it will still be available for internal-use tools
     
278. # but not available for general clients.
     
279. #
     
280. # Example:
     
281. #
     
282. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
     ( _. U. d) J% Z+ S% h
283. #
     
284. # It is also possible to completely kill a command by renaming it into
     - M3 t9 k* a( Q: q- ~) ~4 c
285. # an empty string:
     3 q3 w, c) X5 H/ [
286. #
     / `% k4 z' _+ a3 t
287. # rename-command CONFIG ""
     * R! v- t% ]1 S9 {
288. 
     ! I& m$ W& ~$ `2 `
289. ################################### LIMITS ####################################
     
290. 
     
291. # Set the max number of connected clients at the same time. By default
     
292. # this limit is set to 10000 clients, however if the Redis server is not
     ( c- L! G7 X6 t& u
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
     
295. # minus 32 (as Redis reserves a few file descriptors for internal uses).
     
296. #
     
297. # Once the limit is reached Redis will close all the new connections sending
     
298. # an error 'max number of clients reached'.
     / @$ r4 D4 J% e* m  \9 w
299. #
     ! |2 t) A# T4 u$ V! M" e
300. maxclients 500
     ' s8 h9 k0 X+ ]2 g- |; p
301. 
     8 m& a" X) j! d+ j0 i, n* r
302. # Don't use more memory than the specified amount of bytes.
     % e  q2 [' K6 C, c
303. # When the memory limit is reached Redis will try to remove keys
     
304. # accordingly to the eviction policy selected (see maxmemmory-policy).
     1 ?7 L; ?4 W$ m8 M0 P
305. #
     
306. # If Redis can't remove keys according to the policy, or if the policy is
     ' S" b; f8 W7 ~0 B, B" ]
307. # set to 'noeviction', Redis will start to reply with errors to commands
     : Z9 f4 i) J5 Q7 P& W1 Z
308. # that would use more memory, like SET, LPUSH, and so on, and will continue
     
309. # to reply to read-only commands like GET.
     , ]* C: Q$ K. V0 P7 c. v
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).
     & w  T( D6 w6 U, V
313. #
     
314. # WARNING: If you have slaves attached to an instance with maxmemory on,
     5 G$ h4 B! a/ d5 g
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 b2 E8 a% B8 {* v  x9 [, \: G; S
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
     
319. # of more keys, and so forth until the database is completely emptied.
     * |% h" d3 l3 f( _& i( u; f4 N
320. #
     , p9 p' X; v* M5 j: j
321. # In short... if you have slaves attached it is suggested that you set a lower
     
322. # limit for maxmemory so that there is some free RAM on the system for slave
     % b7 g6 I; N4 m7 l) v
323. # output buffers (but this is not needed if the policy is 'noeviction').
     
324. #
     8 s% I7 a4 x0 D1 V8 F
325. maxmemory 128000000
     
326. 
     4 C4 Z* A5 E; I+ B0 l" \9 a+ x7 E
327. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
     ' p/ n. t# [! Q' O, I
328. # is reached. You can select among five behaviors:
     # ~7 ^, L- A, W8 x& Q
329. #
     
330. # volatile-lru -> remove the key with an expire set using an LRU algorithm
     ! Y2 N0 W: v" p' j
331. # allkeys-lru -> remove any key accordingly to the LRU algorithm
     
332. # volatile-random -> remove a random key with an expire set
     
333. # allkeys-random -> remove a random key, any key
     1 q' P3 g1 q( x8 Y
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
     ! M7 q- x' c' k/ S( b4 t2 u. L2 m
336. #
     
337. # Note: with any of the above policies, Redis will return an error on write
       s7 n6 s, v3 i2 c
338. #       operations, when there are not suitable keys for eviction.
     
339. #
     
340. #       At the date of writing this commands are: set setnx setex append
     , Q+ ?) V' H8 s7 Z; g; |/ A1 d
341. #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
     
342. #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
     
343. #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
     
344. #       getset mset msetnx exec sort
     
345. #
     : {/ ?" ?) u" T
346. # The default is:
     # W: c1 D8 m3 J( }* c0 M
347. #
     ( P/ Q( `1 l8 z8 l" G
348. # maxmemory-policy volatile-lru
     & t2 F& O$ `. |  e, w* a& 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
     . r" z7 }! i9 k! w
352. # size to check. For instance for default Redis will check three keys and
     
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
     8 d1 A( b" v6 D& q1 R2 G( R
357. 
     6 g+ B* c- }, [; \
358. ############################## APPEND ONLY MODE ###############################
     
359. 
     " Y; R! {6 m& c+ D$ `1 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
     - ?8 C( v: }$ S# F$ t
362. # a power outage may result into a few minutes of writes lost (depending on
     2 V9 F3 {" t' b8 m! \3 a
363. # the configured save points).
     
364. #
     * m$ m! Z" Q5 C* U- m* Y8 W2 C
365. # The Append Only File is an alternative persistence mode that provides
     $ L" `( L% s! O5 k/ s6 m6 O
366. # much better durability. For instance using the default data fsync policy
     0 z" Y# [9 {9 a3 M
367. # (see later in the config file) Redis can lose just one second of writes in a
     ! U" f6 |+ x6 f7 ]# [
368. # dramatic event like a server power outage, or a single write if something
     
369. # wrong with the Redis process itself happens, but the operating system is
     
370. # still running correctly.
     " @" z$ L1 [9 b; A
371. #
     : e7 _$ Q4 m# `0 Q' L% i
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
     ) E" X3 Z/ X: {" A, V) x
374. # with the better durability guarantees.
     : D: @' @8 \# m& ^% l
375. #
     # w8 D- p  Y5 @2 W7 X% F( i
376. # Please check http://redis.io/topics/persistence for more information.
     # Z( `! H: R+ n! X5 C) ^9 O1 L/ |
377. 
     0 H5 S3 k3 r8 W
378. appendonly no
     
379. 
     
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
     # m! p) z" P1 U" n1 w/ i
384. # instead to wait for more data in the output buffer. Some OS will really flush
     # p/ ]4 @+ K' T: U8 L! L: y: j+ f
385. # data on disk, some other OS will just try to do it ASAP.
     
386. #
     - X" ?( \) n+ W
387. # Redis supports three different modes:
     
388. #
     ) F. }& Z2 `# |8 `$ z: M, [
389. # no: don't fsync, just let the OS flush the data when it wants. Faster.
     8 r5 w) U& o6 N- G7 L' h3 K
390. # always: fsync after every write to the append only log . Slow, Safest.
     
391. # everysec: fsync only one time every second. Compromise.
     7 N* \: }! C. g% ~& i" i$ t) O
392. #
     / I$ p7 y9 X& Y
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
     ! b$ a+ I" y5 l3 o) Q" _
395. # "no" that will let the operating system flush the output buffer when
     
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. #
     
401. # More details please check the following article:
     ' w, m4 u! }2 h: H% F
402. # http://antirez.com/post/redis-persistence-demystified.html
     ! n: M( ?& v+ E' {: Y
403. #
     
404. # If unsure, use "everysec".
     ; a4 u4 B. U0 n$ K5 `2 m7 S2 b
405. 
     
406. # appendfsync always
     
407. appendfsync everysec
     
408. # appendfsync no
     4 h2 m0 g$ m' i4 M* }  z
409. 
     
410. # When the AOF fsync policy is set to always or everysec, and a background
     
411. # saving process (a background save or AOF log background rewriting) is
     $ d) U5 ]0 c. e5 k; \( {' W
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.
     6 o: j* w6 P4 u0 i; c5 x
416. #
     
417. # In order to mitigate this problem it's possible to use the following option
     1 _/ r. v! O* I% s
418. # that will prevent fsync() from being called in the main process while a
     
419. # BGSAVE or BGREWRITEAOF is in progress.
     
420. #
     8 A; F& A0 E' D4 M- j& y- z
421. # This means that while another child is saving, the durability of Redis is
     
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
     , l, p5 p# ?) T% P( d2 v
424. # default Linux settings).
     
425. #
     7 O  _) \- D1 H
426. # If you have latency problems turn this to "yes". Otherwise leave it as
     1 u/ a/ |: Q6 D, r) l) [  N
427. # "no" that is the safest pick from the point of view of durability.
     ( W- r4 x& b* c7 J
428. no-appendfsync-on-rewrite no
       }# L3 `: U- P3 o" R7 n
429. 
     
430. # Automatic rewrite of the append only file.
     
431. # Redis is able to automatically rewrite the log file implicitly calling
     
432. # BGREWRITEAOF when the AOF log size grows by the specified percentage.
     $ E- v( \3 G9 O9 ]
433. #
     + B8 ^9 @! Z, W! a8 @
434. # This is how it works: Redis remembers the size of the AOF file after the
     # l2 g7 x9 O9 O2 ?
435. # latest rewrite (if no rewrite has happened since the restart, the size of
     - i. d: f5 o. @. ~, @1 O
436. # the AOF at startup is used).
     
437. #
     ! L" k2 \# A$ V! w, r
438. # This base size is compared to the current size. If the current size is
     & {: G& ~$ i& X# s  j- D3 S* u
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.
     
443. #
     
444. # Specify a percentage of zero in order to disable the automatic AOF
     
445. # rewrite feature.
     
446. 
     ( H! R8 Z. S' w: s9 Z* H
447. auto-aof-rewrite-percentage 100
     
448. auto-aof-rewrite-min-size 64mb
     
449. 
     , i4 q7 C# B$ L- K9 b* T$ W
450. ################################ LUA SCRIPTING  ###############################
     % K2 W( X. g! C  h& V. D. C
451. 
     
452. # Max execution time of a Lua script in milliseconds.
     5 Z6 i' \3 t+ M) H& i6 A
453. #
     + u3 Z! t. f6 V! S7 L! a- p
454. # If the maximum execution time is reached Redis will log that a script is
     8 v+ ?; ~' z. d3 |7 b
455. # still in execution after the maximum allowed time and will start to
     % P8 w) H" I+ e  U, p6 g
456. # reply to queries with an error.
     7 f% t5 ^5 p$ L& ^3 {& R# r
457. #
     9 f5 b( b" x2 Y. O
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
       X: _  n# d4 h- q! C) I0 m% c
460. # used to stop a script that did not yet called write commands. The second
     2 H( F6 V, H4 h' q; S! D. C/ z5 b8 ]
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
     9 d( c+ L" S. c8 C
463. # termination of the script.
     
464. #
     
465. # Set it to 0 or a negative value for unlimited execution without warnings.
     
466. lua-time-limit 5000
     
467. 
     5 P9 _3 Z  A, v) V; x
468. ################################## SLOW LOG ###################################
     
469. 
     # ?, ?+ W1 U+ k) l
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
     / L2 C$ \' n  _$ f) P
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
     2 k- J4 D( [* D+ y
478. # what is the execution time, in microseconds, to exceed in order for the
     & @( J$ c$ R6 F$ z" ]
479. # command to get logged, and the other parameter is the length of the
     ; W. [3 x; u7 @$ \1 r
480. # slow log. When a new command is logged the oldest one is removed from the
     3 O9 [) f& o' G5 L! z: ^6 \
481. # queue of logged commands.
     
482. 
     
483. # The following time is expressed in microseconds, so 1000000 is equivalent
     ) `: ~# |8 u/ R( J: }0 p+ |. Y% c3 E5 c
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.
     ' K; Q3 g* X, Y; o. k: n2 H
486. slowlog-log-slower-than 10000
     % `! c3 S5 @" q" H7 Z9 H5 w' `
487. 
     
488. # There is no limit to this length. Just be aware that it will consume memory.
     & y# A% W+ f' R  `  j
489. # You can reclaim memory used by the slow log with SLOWLOG RESET.
     
490. slowlog-max-len 128
     
491. 
     : a9 O$ ], @3 E, m6 p
492. ############################### ADVANCED CONFIG ###############################
     
493. 
     
494. # Hashes are encoded using a memory efficient data structure when they have a
     
495. # small number of entries, and the biggest entry does not exceed a given
     1 i& ^8 u$ D& p
496. # threshold. These thresholds can be configured using the following directives.
     
497. hash-max-ziplist-entries 512
     
498. hash-max-ziplist-value 64
     
499. 
     
500. # Similarly to hashes, small lists are also encoded in a special way in order
     + \5 I% w$ B, r# T- Z% |/ Q0 F
501. # to save a lot of space. The special representation is only used when
     
502. # you are under the following limits:
     ! u8 E. L3 V/ k/ m' C$ Y7 Z" _
503. list-max-ziplist-entries 512
     
504. list-max-ziplist-value 64
     
505. 
     # E) Y: A1 n2 L' _, v3 S
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
     9 a4 j; z) H0 d4 m$ T
508. # of 64 bit signed integers.
     
509. # The following configuration setting sets the limit in the size of the
     ! ?- n: K, S, N& j; U8 _
510. # set in order to use this special memory saving encoding.
     
511. set-max-intset-entries 512
     
512. 
     
513. # Similarly to hashes and lists, sorted sets are also specially encoded in
     + r1 f) i/ }% g+ ^
514. # order to save a lot of space. This encoding is only used when the length and
     , N2 C9 k$ O6 o( M
515. # elements of a sorted set are below the following limits:
     
516. zset-max-ziplist-entries 128
     6 j) x9 u* x8 |9 U, _
517. zset-max-ziplist-value 64
     
518. 
     ' E" X  b& b) k: j6 u- {2 I
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
     : K' g1 V/ Y: ]
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
     
524. # server is idle the rehashing is never complete and some more memory is used
     * p' O1 a& `# _2 s! }
525. # by the hash table.
     
526. #
     9 g& v+ a2 J5 N  z8 }9 f8 {# r
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.
     
529. #
     2 X- ^: ~# g" b7 P- g
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
     
533. # to queries with 2 milliseconds delay.
     " ]& k2 x  ^# G$ P7 S
534. #
     
535. # use "activerehashing yes" if you don't have such hard requirements but
     ' {/ o- S) B9 ]% B
536. # want to free memory asap when possible.
     $ k  ]& i7 h2 u* Z
537. activerehashing yes
     
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
     4 v2 ]3 n9 B. U# }! j
541. # common reason is that a Pub/Sub client can't consume messages as fast as the
     
542. # publisher can produce them).
     
543. #
     . r4 U7 q$ d* }! O. \) o
544. # The limit can be set differently for the three different classes of clients:
     
545. #
     
546. # normal -> normal clients
     
547. # slave  -> slave clients and MONITOR clients
     6 r/ D/ d# N3 j: [* o% @. ~  t
548. # pubsub -> clients subcribed to at least one pubsub channel or pattern
     ! @9 }4 Z0 _0 \: R) [1 |  s/ G
549. #
     
550. # The syntax of every client-output-buffer-limit directive is the following:
     # }$ `1 z7 h) V
551. #
     8 p# j: h; ]3 b4 C8 u" y, d9 i
552. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
     ) v$ @, ^; t  U# v8 U, {6 ^1 }+ W
553. #
     
554. # A client is immediately disconnected once the hard limit is reached, or if
     ! c% ?6 h. x; ~+ o3 o. D* N- Y* j
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
     7 l9 B4 J7 d) M8 Z! r0 Z. G) F
558. # 16 megabytes / 10 seconds, the client will get disconnected immediately
     - N) j/ Q8 X; i: ~6 `
559. # if the size of the output buffers reach 32 megabytes, but will also get
     0 e9 A- l" A3 \- N! a; D$ a
560. # disconnected if the client reaches 16 megabytes and continuously overcomes
     
561. # the limit for 10 seconds.
     / W5 Y, [4 J" {3 Q7 B. S% W  }) X+ c
562. #
     
563. # By default normal clients are not limited because they don't receive data
     8 _# o* g9 J; D1 e9 c, }
564. # without asking (in a push way), but just after a request, so only
     $ \3 J& n- L0 O* v7 A- n1 b% N* g; P
565. # asynchronous clients may create a scenario where data is requested faster
     6 O1 i: V, K. [
566. # than it can read.
     
567. #
     
568. # Instead there is a default limit for pubsub and slave clients, since
     
569. # subscribers and slaves receive data in a push fashion.
     
570. #
     + d1 F, u/ \" m" y& c
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
     
573. client-output-buffer-limit slave 256mb 64mb 60
     
574. client-output-buffer-limit pubsub 32mb 8mb 60
     . \5 s. q& `4 p% V& P
575. 
     
576. ################################## INCLUDES ###################################
     2 V# H  b( ^5 _1 S, c5 L. n
577. 
     
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
     + M( }" ]. _3 Q; J1 U# F
580. # to customize a few per-server settings.  Include files can include
     
581. # other files, so use this wisely.
     
582. #
     6 W+ H# A2 f5 A) w0 _0 p2 \2 i0 v
583. # include /path/to/local.conf
     
584. # include /path/to/other.conf        
     
585. ##########################配置文件结束################################
     & }! @: Q$ s. Y  g
586. 第三步：启动进程
     2 i# c- A2 t& p
587. #redis-server /etc/redis.conf
     - Y) P& t: \' M
588. 查看进程有没有成功启动
     ' C& K' |- a, J* R+ [5 @0 l8 i$ A
589. #ps -ef | grep redis
     4 C* l& z4 Z  I+ m4 c, a
590. 测试输入一个键值
     * ~9 ?5 I+ I8 A, F& h" Y# }4 [
591. #redis-cli set test "testredis"
     
592. 获取键值
     4 p$ w2 y% a( w% R/ I( K
593. #redis-cli get test
     " {: M5 E4 n# N$ _3 u. k* p' [
594. 
     
595. 
     / @; {$ ~5 S/ K" W" z& |5 b
596. 第四步:关闭redis  (这个是更改配置文件后 正常的重启方式  不重新加载redis配置跳过)
     
597. # redis-cli shutdown      //关闭所有   
     " K! ^4 O$ p2 X/ d5 q- G/ o3 V
598. 关闭某个端口上的redis   
     , A! r) j3 p" x& j
599. # redis-cli -p 6397 shutdown  //关闭6397端口的redis  
     
600. 说明：关闭以后缓存数据会自动dump到硬盘上，硬盘地址见redis.conf中的dbfilename  dump.rdb  
     0 W) L: S' A$ J* w
601. 
     # i* A+ Q- T6 `; _; [- f
602. 
     & \: x# `& h3 V$ N: {6 P
603. 第5步:php扩展安装
     ' B5 X* S6 e7 g$ o/ m8 o% D
604. phpredis PHP扩展下载地址
     7 \: b# O7 e0 D0 S, F7 G2 @
605. https://github.com/nicolasff/phpredis/tree/2.2.2
     , H6 ^! U- ~! B5 ]6 W
606. 选择最新版本下载zip
     & D& C! \: Q: s( W
607. 
     
608. 然后自己上传zip  用unzip解压到当前目录 unzip 文件名
     
609. 
     
610. # cd owlient-phpredis-90ecd17/   #打开解压后的文件夹里面  这个解压后的目录 要是不知道 可以输入 "dir" 查看
     2 |6 A& J1 H2 I
611. # /www/nginx_php-5.2.17/bin
     
612. # ./configure --with-php-config=/www/nginx_php-5.2.17/bin/php-config
     
613. #make
     8 C/ x4 p. C! ]* m6 p
614. #make install   #记录产生的redis.so路径
     ; q' R, Z, b' d; X
615. 
     ' v, i' d9 M9 C6 M) j9 F
616. 修改php.ini文件
     7 J+ b/ }6 B- p  r6 Y) v: Y
617. 在php.ini中添加如下一行：
     
618. extension=/?/redis.so  #是刚刚记录的产生redis.so的路 写在 ?那
     
619. 重启 使之生效：
     . O( `0 a( V9 O' ]# d
620. /usr/local/php/sbin/php-fpm reload
     ! H2 Q& P# P6 b, U0 Z% _$ N# `
621. /usr/local/nginx/sbin/nginx -s reload
     
622. 
     ! [  q/ t* |; t' U
623. 将 Redis 作为 Linux 服务随机启动
     6 E2 z% W) n! R" ~) M/ n5 ~$ g
624. vi /etc/rc.local, 加入代码：
     9 O* r8 O% f1 C* ~
625. /root/redis-2.6.10/src/redis-serve  #路径看情况修改
     ( h# w9 V. U$ G0 ^7 c3 J
626. 
     , N+ W3 v6 G+ R% H
627. redis-cli -h localhost -p 6379 info  #命令要在redis目录下面执行
     $ x2 L: `" H  M, n4 d
628. 提供host为localhost，端口为6379，redis服务的统计信息
     + H, X: j$ i% z7 t3 `7 y
629. 
     
630. 
     . _& {. J: k3 P/ V9 e5 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;
     7 l  E  I. e/ h9 m0 f
635. $_config['memory']['redis']['pconnect'] = 1;
     ; X* A* T) B8 a6 K; i, A+ X, D
636. $_config['memory']['redis']['timeout'] = '0';
     . z2 U4 m5 A$ b0 @
637. $_config['memory']['redis']['serializer'] = 1;
     $ G% b! `, I* u7 [. ]& j5 Y5 {

复制代码