DZ

壹加壹

环境配置
- q3 g( b: U* G7 A( B- i

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

壹加壹

http://www.discuz.net/forum.php? ... 648&highlight=REDIS
& p0 W' @$ Q+ T: z无意间测试 单机状态 redis相当给力 测试1000请求/s  单纯的 get 和set 居然只用了 0.01秒 当时我惊呆了

7 C$ U6 X0 o& v$ J! E: U) Yhttp://www.discuz.net/forum.php? ... 731&highlight=REDIS

9 ?) `" b- e. |$ d) Ghttps://wenku.baidu.com/view/265a5ce176a20029bc642d0b.html
) `6 F$ }# z7 O% T
1 I# A: O: H1 \6 }+ i& J＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

1. 连接上 ssh
   % Q! R" _  Q5 T! X# L
2. 
   4 h0 _$ v. r' p% v# [8 q2 K
3. 
   % `" |/ r' ^" H& D8 M0 p9 N' b1 N
4. 第一步:下载redis
   + X; k) D" T& E- B' g6 \
5. # wget http://redis.googlecode.com/files/redis-2.6.10.tar.gz
   " k; P/ G, f1 @( U
6. # tar zxvf redis-2.6.10.tar.gz
   9 D4 ]3 q: Q9 i0 Z9 \
7. # cd redis-2.6.10
   
8. # make
   
9. # make install  
   2 Y( L* c) Z/ n' a$ T/ l
10. #cp redis.conf  /etc/ #复制配置文件到etc目录下面
    
11. 第二步：修改配置
    
12. #vi /etc/redis.conf
    
13. ######################下面是无措的配置文件 复制过去就成#########
    
14. # Redis configuration file example
    $ i1 j/ r) {; R. M( W, e8 \
15. 
    
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. #
    3 E/ k! |; Q; X2 B
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
    % f& ]; ?! y$ k" ?5 _
25. #
    
26. # units are case insensitive so 1GB 1Gb 1gB are all the same.
    & f# ~2 {3 V0 w* N
27. 
    $ x* W1 k, `3 e6 l( }- T
28. # By default Redis does not run as a daemon. Use 'yes' if you need it.
    
29. # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
    
30. daemonize yes
    
31. 
    4 Y8 O9 ~# F: u/ c7 z6 `) u
32. # When running daemonized, Redis writes a pid file in /var/run/redis.pid by
    " W$ U1 l) B4 ?" c0 H$ y
33. # default. You can specify a custom pid file location here.
    6 N) V& O, b0 o6 j6 J
34. pidfile /var/run/redis.pid
    ) U4 N3 q% j/ I1 j% M4 e
35. 
    % h1 M$ g$ f6 H; W
36. # Accept connections on the specified port, default is 6379.
    / U/ T' q  m$ B
37. # If port 0 is specified Redis will not listen on a TCP socket.
    
38. port 6379
    8 E4 h, ~' V9 D. G2 x# C$ {
39. 
    
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.
    
42. #
    : h0 S5 ^# ~" o& p
43. # bind 127.0.0.1
    
44. 
    & d( K+ a4 b0 y( Z& H
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
    ' i2 o: X% |2 [2 U
47. # on a unix socket when not specified.
    & p9 v+ z6 u2 i: N/ Y& R
48. #
    6 S9 \1 M- D2 W
49. # unixsocket /tmp/redis.sock
    . m5 r5 C1 @( {$ l( O# t3 z0 K
50. # unixsocketperm 755
    
51. 
    5 ^5 ~9 p, H- K9 \
52. # Close the connection after a client is idle for N seconds (0 to disable)
    
53. timeout 300
    
54. 
    
55. # TCP keepalive.
    : `/ G: U2 K! U5 V5 D+ V
56. #
    
57. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
    " R4 Z+ D; U# Y4 W. r: n
58. # of communication. This is useful for two reasons:
    
59. #
    ; ^/ r' o* B" s# d* Y# e6 C* o5 n
60. # 1) Detect dead peers.
    
61. # 2) Take the connection alive from the point of view of network
    - N; r' J6 W1 i/ m" E2 d! D& B
62. #    equipment in the middle.
    & S) U# p7 }+ x+ ]  v" h, E
63. #
    
64. # On Linux, the specified value (in seconds) is the period used to send ACKs.
    ; c, P" r: T5 ]* @7 F! }, m4 @; z
65. # Note that to close the connection the double of the time is needed.
    - q( q5 x) U- K) [; w
66. # On other kernels the period depends on the kernel configuration.
    ) _- i8 D: P4 @
67. #
    
68. # A reasonable value for this option is 60 seconds.
      ?. V0 v; j" G1 o; }4 o8 B+ D
69. tcp-keepalive 0
    6 U9 p$ F1 o" v1 v% C4 Q
70. 
    
71. # Specify the server verbosity level.
    + B3 ]2 ~9 y/ }; _
72. # This can be one of:
    2 D7 [9 y3 s$ h1 t7 O
73. # debug (a lot of information, useful for development/testing)
    
74. # verbose (many rarely useful info, but not a mess like the debug level)
    ! z9 W* x+ C) J: M3 {( [
75. # notice (moderately verbose, what you want in production probably)
    6 k1 T/ F$ M: G. b  L
76. # warning (only very important / critical messages are logged)
    
77. loglevel warning
    
78. 
    
79. # Specify the log file name. Also 'stdout' can be used to force
    + M# Y' n' i$ X! F( z
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,
    5 t0 g% h& r* a% W
85. # and optionally update the other syslog parameters to suit your needs.
    
86. syslog-enabled yes
    
87. 
    
88. # Specify the syslog identity.
    ' @' _8 p- |3 j% {: p0 ^
89. # syslog-ident redis
    
90. 
    7 r4 @' R% @, ]0 d( Z
91. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
    3 u" `) D2 b/ l/ c
92. syslog-facility local0
    
93. 
    
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 ^/ X9 }# M  c7 j; k
97. databases 16
    * a" ?; I" x. q4 k1 X" \$ T  s
98. 
    . v4 k3 {& ]/ C$ e
99. ################################ SNAPSHOTTING  #################################
    
100. #
     $ G6 n( v8 w4 d: c
101. # Save the DB on disk:
     6 [2 l" `5 I' P1 T
102. #
     7 s- f6 Z# T$ W  v8 V' T6 @4 H3 S
103. #   save <seconds> <changes>
     & e! P2 L. h" e( y3 q4 @
104. #
     1 L+ _5 O1 d& S% C
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. #
     5 ^! w6 m% s+ X6 u- B2 Z) F
108. #   In the example below the behaviour will be to save:
     
109. #   after 900 sec (15 min) if at least 1 key changed
     ) L  u- Q; l% }, g
110. #   after 300 sec (5 min) if at least 10 keys changed
     " _/ f' |9 y+ p$ z; F
111. #   after 60 sec if at least 10000 keys changed
     1 L" D6 b: b1 D4 O8 g" U( _
112. #
     
113. #   Note: you can disable saving at all commenting all the "save" lines.
     
114. #
     + a0 R# T% ^! d  I# ^2 ?8 S
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:
     5 z( `: B6 h4 O- M2 [8 u
118. #
     4 S0 ~$ F3 [3 \
119. #   save ""
     8 J6 u9 L) e4 U4 m- E  o
120. 
     3 n0 f7 A$ y( ?0 `
121. save 900 1
     + i0 F  {3 t: _. x+ d
122. save 300 10
     
123. save 60 10000
     0 c( Z2 F! S# f: ~. P6 l+ ^- a
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.
     ! T; x1 O2 h" y9 ~
127. # This will make the user aware (in an hard way) that data is not persisting
     " z& B5 Y6 G1 o( O& C! }# f
128. # on disk properly, otherwise chances are that no one will notice and some
     + m) |; d; t) A$ L
129. # distater will happen.
     
130. #
     - k, Y8 r7 O' V% R
131. # If the background saving process will start working again Redis will
     & Q4 ^& Z* i& n# u9 T$ F
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
     $ C8 ]/ s# ~8 m( Y) Y7 ]
139. 
     . j( v! N, W  [) }, M
140. # Compress string objects using LZF when dump .rdb databases?
     $ ~+ U. E' T- I' T, T
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
     4 r" a. j1 J: n" {
143. # the dataset will likely be bigger if you have compressible values or keys.
     2 }- Y+ y. [5 L! s
144. rdbcompression yes
     0 W- `9 }( a2 I7 s
145. 
     2 I2 |. p$ l5 l+ w8 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
     ! w% y1 _) t$ w# P- e; u
149. # for maximum performances.
     2 E% X3 r5 f, l7 c
150. #
     ( s: C& }$ o- E2 Q/ c% s$ g
151. # RDB files created with checksum disabled have a checksum of zero that will
     
152. # tell the loading code to skip the check.
     # `) r/ {" x0 Z# @; ~2 Q+ x! M4 q7 |
153. rdbchecksum yes
     5 ^: S4 }" U8 C2 x
154. 
     : {) h7 R& i  q+ j
155. # The filename where to dump the DB
     " S. O& [+ \; v6 ^
156. dbfilename dump.rdb
     
157. 
     
158. # The working directory.
     
159. #
     
160. # The DB will be written inside this directory, with the filename specified
     2 [  N+ O6 }, B; a8 K( {/ N
161. # above using the 'dbfilename' configuration directive.
     
162. #
     1 Q$ p6 U7 u3 e" C3 G2 h
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
     7 T0 z5 ^- s; b" A  Q2 @, r
167. 
     
168. ################################# REPLICATION #################################
     
169. 
     / z+ Q- e  U* A/ A! S
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
     ( L5 B8 _( L, w0 _4 ?
172. # so for example it is possible to configure the slave to save the DB with a
     9 E! B1 P3 ^! ~+ e1 M' H& V& a
173. # different interval, or to listen to another port, and so on.
     
174. #
     + F/ {5 H8 N; `2 ~' c+ {
175. # slaveof <masterip> <masterport>
     
176. 
     ' Q1 Y& O& h& O: ]0 ]  Q/ m  E
177. # If the master is password protected (using the "requirepass" configuration
     " j5 P) x; i7 c: U) m+ X4 y
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.
     ( E% F! P; u( v# u
181. #
     0 N. w1 t3 j1 `! A6 n7 ~) M  Y
182. # masterauth <master-password>
     
183. 
     * y1 Y; V3 W8 Y( M' T  u
184. # When a slave loses its connection with the master, or when the replication
     6 z! D# T2 A8 [4 l( s% K9 C
185. # is still in progress, the slave can act in two different ways:
     ' B; ~% B, u8 K  K$ Z& O" X6 q
186. #
     : q$ y) U  d5 f# `6 H
187. # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
     0 V1 [( q: q  }/ Q
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.
     ! w& l( s/ l" P+ `& [
190. #
     / _9 G7 U' F. t! V# _8 ^9 s
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
     4 }8 J5 B; q$ m
193. #    but to INFO and SLAVEOF.
     ! L9 @7 I* u6 p/ q5 Y9 k& \
194. #
     
195. slave-serve-stale-data yes
     5 F+ ]. L5 i, s2 f+ C
196. 
     
197. # You can configure a slave instance to accept writes or not. Writing against
     0 W" ?  s  y* R  @, s$ d  B
198. # a slave instance may be useful to store some ephemeral data (because data
       y- C: T% x! h( A; x9 l
199. # written on a slave will be easily deleted after resync with the master) but
     # ~' h" T+ ~& q  V
200. # may also cause problems if clients are writing to it because of a
     
201. # misconfiguration.
     * D; S' i; x6 ]
202. #
     , b, \' W8 ?7 d- I' N
203. # Since Redis 2.6 by default slaves are read-only.
     3 r9 m; E. A5 v7 m' _3 t
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.
     
207. # Still a read only slave exports by default all the administrative commands
     
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
     ' V# l* a& c; B+ g1 p
210. # administrative / dangerous commands.
     ) l/ \. a; X5 V( S! V$ z
211. slave-read-only yes
     
212. 
     / t8 M# k& |% R; E
213. # Slaves send PINGs to server in a predefined interval. It's possible to change
     9 f8 V; v  `. B9 p  u$ h/ m: {1 d
214. # this interval with the repl_ping_slave_period option. The default value is 10
     8 {0 }) ^; g5 ?( I# Z$ W
215. # seconds.
     / B8 ~) p0 O, @& b# k2 B
216. #
     ( m) @5 |  }1 X, X* U4 f
217. # repl-ping-slave-period 10
     
218. 
     , ^  t+ w, z* T( Q; a! l
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.
     2 a  _* S+ C5 x. v+ U: V
221. #
     ( C' ~( L; c( J7 X; C
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.
     
225. #
     
226. # repl-timeout 60
     & v2 f; X5 x' L1 J) w* U
227. 
     
228. # Disable TCP_NODELAY on the slave socket after SYNC?
     ' W( p: L7 D2 B
229. #
     
230. # If you select "yes" Redis will use a smaller number of TCP packets and
     $ C# N( y' `7 S6 P2 J% q
231. # less bandwidth to send data to slaves. But this can add a delay for
     9 A4 p; r/ S8 P5 M! N
232. # the data to appear on the slave side, up to 40 milliseconds with
     ( j8 Z! }  a1 E: z# m
233. # Linux kernels using a default configuration.
     
234. #
     / l5 H$ L3 X$ ?1 r$ }2 F1 Y
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.
     - W2 O  B; a- u: v* d* V4 [1 X
237. #
     0 Z' B( ?: A0 s! s
238. # By default we optimize for low latency, but in very high traffic conditions
     . w! e% v. t/ u' w
239. # or when the master and slaves are many hops away, turning this to "yes" may
     
240. # be a good idea.
     . s/ L- }2 P. u( P1 p( k
241. repl-disable-tcp-nodelay no
     . F. ^' G2 A9 @1 W
242. 
     
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
     : k0 S/ A: n- A8 ]+ U3 N6 }; M2 ?* Q
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
     2 i; Y! N6 g5 `
248. # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
     
249. # pick the one wtih priority 10, that is the lowest.
     
250. #
     
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
     . w# X: g; m1 P: ]
253. # Redis Sentinel for promotion.
     
254. #
     " ]8 A/ A2 h3 I+ S" }6 i$ I; T
255. # By default the priority is 100.
     + [  m) a9 S6 I" V1 ]  |* n
256. slave-priority 100
     - d6 I4 |- M/ R: |4 o. C7 z
257. 
     
258. ################################## SECURITY ###################################
     $ u3 L( u2 n0 V0 v; }
259. 
     
260. # Require clients to issue AUTH <ASSWORD> before processing any other
     ; u* Q+ `  Z& t! |3 {5 L/ M
261. # commands.  This might be useful in environments in which you do not trust
     6 B  ?: K& Z+ E) W- V/ P0 e5 R
262. # others with access to the host running redis-server.
     
263. #
     4 e" z! w) P6 M3 ~! r; K7 W
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).
     
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
     . P) V) [  m1 U; _
269. # use a very strong password otherwise it will be very easy to break.
     
270. #
     
271. # requirepass foobared
     - C8 \, B8 {6 p6 d1 Y1 X7 X* Y$ z4 A/ F
272. 
     9 H- W4 }" \% n4 B  Z1 m+ X) [
273. # Command renaming.
     
274. #
     
275. # It is possible to change the name of dangerous commands in a shared
     * A! T7 M" d1 h& x9 ^
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
     ' A: k4 G! J/ ~
278. # but not available for general clients.
     5 s% h5 E& R3 t3 U' G; J
279. #
     2 f6 C0 F. k6 R$ d
280. # Example:
     
281. #
     
282. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
     2 ], R+ C4 Y! z+ f' }* R
283. #
     $ G2 {: }# T. U$ S+ v1 Y
284. # It is also possible to completely kill a command by renaming it into
     
285. # an empty string:
     
286. #
     
287. # rename-command CONFIG ""
     
288. 
     
289. ################################### LIMITS ####################################
     
290. 
     - w4 y; V) `6 M+ v- c; h0 C6 i
291. # Set the max number of connected clients at the same time. By default
     5 M0 f& a* X5 ?6 k( ?
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
     8 O7 O4 V) b" O- V6 Q
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. #
     2 p5 u& f/ [2 @* G- d
297. # Once the limit is reached Redis will close all the new connections sending
     
298. # an error 'max number of clients reached'.
     ' T, n6 b! ?0 D0 {- I, ?
299. #
     
300. maxclients 500
     ! W! p: h. L8 q" i9 ?' P2 N( ?/ o
301. 
     # X& ?% ]  f, Y. c
302. # Don't use more memory than the specified amount of bytes.
     - |8 e0 U  k9 ?2 `
303. # When the memory limit is reached Redis will try to remove keys
     . ?1 ]# s; w! I9 W; \
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
     ! e2 C4 B% `- r' a! X: I1 E
308. # that would use more memory, like SET, LPUSH, and so on, and will continue
     : F0 X' j0 c  p" s3 Z4 A# s
309. # to reply to read-only commands like GET.
     ' o5 l  _& `/ d( Q  [5 m- |
310. #
     8 z: g9 A: [4 H; B) Z6 {% m2 ^7 K
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).
     
313. #
     1 j" E) B2 W  ~' ^' B- [
314. # WARNING: If you have slaves attached to an instance with maxmemory on,
     % \0 X) r" @1 Z( b; x
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
     
317. # not trigger a loop where keys are evicted, and in turn the output
     & A6 d- O8 }! @# S5 O3 w
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.
     ' l% V1 h+ F& {. Z% H
320. #
     
321. # In short... if you have slaves attached it is suggested that you set a lower
     + z; N6 J1 l4 ~+ Z1 H
322. # limit for maxmemory so that there is some free RAM on the system for slave
     9 e8 a0 a7 W! g& h% o
323. # output buffers (but this is not needed if the policy is 'noeviction').
     . r5 S& X2 g& }  m2 ^; p& ?! i
324. #
     
325. maxmemory 128000000
     6 e( s) i" u3 K% u1 W7 ?$ m% p9 P: V
326. 
     
327. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
     
328. # is reached. You can select among five behaviors:
     
329. #
     * I  h+ f) A5 n6 A( Y
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
     
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
     - N/ m' w  H9 L0 T' V$ v' I
336. #
     8 y# l4 @, z3 ^5 B
337. # Note: with any of the above policies, Redis will return an error on write
     
338. #       operations, when there are not suitable keys for eviction.
     1 a! o. s$ `, P9 ?) x
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
     / T3 m% v2 Q8 y6 j
342. #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
     ' u# z* [% M+ y" [$ w4 X, z% W
343. #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
     
344. #       getset mset msetnx exec sort
     & c. f& }: _/ q9 A
345. #
     
346. # The default is:
     9 U/ M) t6 d, [. x
347. #
       F4 q$ r( E) r% ~$ n$ b+ ?1 u
348. # maxmemory-policy volatile-lru
     : }' b; ]: g) o; m: L
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
     
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
     ! H: z4 j  p% L
357. 
     3 y8 Q3 p, l1 Q: O- n2 h9 x; P
358. ############################## APPEND ONLY MODE ###############################
     8 w3 C0 R7 J% J
359. 
     
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
     
363. # the configured save points).
     * }& ~3 u3 f+ |2 v9 f$ p4 O
364. #
     
365. # The Append Only File is an alternative persistence mode that provides
     
366. # much better durability. For instance using the default data fsync policy
     ' m0 s$ O  ?; Q) n8 V" F6 G
367. # (see later in the config file) Redis can lose just one second of writes in a
     # ^7 [- `5 v* i
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.
     ( f6 W) `0 O, z) `% Z; H( t
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
     3 J4 ^2 j' `" u
374. # with the better durability guarantees.
     
375. #
     
376. # Please check http://redis.io/topics/persistence for more information.
     + |6 k4 o7 v3 v- ?  r0 v& ^
377. 
     % q1 Q9 S2 `/ d9 G
378. appendonly no
     
379. 
     
380. # The name of the append only file (default: "appendonly.aof")
     
381. # appendfilename appendonly.aof
     5 h5 m) p4 R7 f
382. 
     + n! U0 H1 i+ w1 t, n1 u8 e
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.
     
386. #
     
387. # Redis supports three different modes:
     
388. #
     
389. # no: don't fsync, just let the OS flush the data when it wants. Faster.
     
390. # always: fsync after every write to the append only log . Slow, Safest.
     , j$ Z+ x3 W4 k9 _
391. # everysec: fsync only one time every second. Compromise.
     
392. #
     7 f6 c4 x4 \$ n  L
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
     ) `) ^$ p" |) z
395. # "no" that will let the operating system flush the output buffer when
     & E8 J% v6 q8 a/ i
396. # it wants, for better performances (but if you can live with the idea of
     . J$ x1 @& T! K  O- a6 n
397. # some data loss consider the default persistence mode that's snapshotting),
     $ l. g" N7 Q  v9 g
398. # or on the contrary, use "always" that's very slow but a bit safer than
     , Q1 K: X9 Z- y" _
399. # everysec.
     # b& l- B0 S( E4 A  f* v/ Y
400. #
     
401. # More details please check the following article:
     : N' j7 [4 M  n% b2 a
402. # http://antirez.com/post/redis-persistence-demystified.html
     + S. n( ^- Z$ v  e+ |' j
403. #
     $ G; {' X' B$ ^5 o
404. # If unsure, use "everysec".
     2 i+ |$ L4 j& P; n$ ]9 q+ d) [
405. 
     1 n/ |% r* z3 k1 k+ [8 W/ Z+ H5 A
406. # appendfsync always
     + N) E2 _2 l6 O1 P! _) |
407. appendfsync everysec
     6 }! Z; B! m$ ?: ]
408. # appendfsync no
     
409. 
     
410. # When the AOF fsync policy is set to always or everysec, and a background
     / ]8 ~0 W& Q* V9 D. t% T
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
     - f' d/ n- B+ b  D; t3 t
415. # our synchronous write(2) call.
     
416. #
     . H' C) H' Z9 D; c9 s  f& m
417. # In order to mitigate this problem it's possible to use the following option
     # ~% v$ e  m. F1 _3 B. u8 Y0 ~! r
418. # that will prevent fsync() from being called in the main process while a
     6 G! X1 {6 u' k! n
419. # BGSAVE or BGREWRITEAOF is in progress.
     
420. #
     7 I; i% t/ E9 _# p3 ]0 @
421. # This means that while another child is saving, the durability of Redis is
     ( k3 ~; z6 J9 }- [& R$ q9 Q" L
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).
     6 A/ z: d& }% N8 m# f
425. #
     
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.
     7 g# Q$ V! t, C' V  ~
428. no-appendfsync-on-rewrite no
     
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.
     ! Z  T9 |, V; d4 G4 n8 V
433. #
     
434. # This is how it works: Redis remembers the size of the AOF file after the
     1 i, P( J& U% O& V# ?
435. # latest rewrite (if no rewrite has happened since the restart, the size of
     
436. # the AOF at startup is used).
     5 s% R8 l! G6 z
437. #
     
438. # This base size is compared to the current size. If the current size is
     ' V- `$ r1 C9 A4 Y
439. # bigger than the specified percentage, the rewrite is triggered. Also
       M# t9 A, H2 n, z, G
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.
     ) H) Y. d6 a7 _; ^6 P. K
443. #
     ' V2 K+ H3 W5 T3 h$ Y4 v7 Q
444. # Specify a percentage of zero in order to disable the automatic AOF
     
445. # rewrite feature.
     
446. 
     / \# C$ \) p" L' {+ }4 f. G3 U
447. auto-aof-rewrite-percentage 100
     - C. V7 w2 g9 x7 v" V6 M) r- ~* x
448. auto-aof-rewrite-min-size 64mb
     
449. 
     
450. ################################ LUA SCRIPTING  ###############################
     
451. 
     4 i& U3 ^5 ^* d2 U: [3 q, }5 |
452. # Max execution time of a Lua script in milliseconds.
     
453. #
     
454. # If the maximum execution time is reached Redis will log that a script is
     ; i& v4 `: u& m. x% N! h
455. # still in execution after the maximum allowed time and will start to
     / s- M) S# \3 q0 z* W+ x/ o
456. # reply to queries with an error.
     
457. #
     
458. # When a long running script exceed the maximum execution time only the
     ; s2 ~" W$ |8 W0 d
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
     9 w4 X. Y  ]; _2 o( `% R$ r
461. # is the only way to shut down the server in the case a write commands was
     7 g& _4 k0 e( F& a% i# v1 |6 ^
462. # already issue by the script but the user don't want to wait for the natural
     ; t* l$ J; w. A* M4 J' x( M: [
463. # termination of the script.
     
464. #
     1 }3 X4 w* Z. f9 ~; K! f
465. # Set it to 0 or a negative value for unlimited execution without warnings.
     
466. lua-time-limit 5000
     
467. 
     
468. ################################## SLOW LOG ###################################
     ' D5 d& }  f3 X. \
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,
     
473. # but just the time needed to actually execute the command (this is the only
     8 _8 \& l# z  v& Z
474. # stage of command execution where the thread is blocked and can not serve
     
475. # other requests in the meantime).
     + p6 O+ C1 k/ K, |% O
476. #
     ! ~6 S- h" U3 U- C# u8 e$ S# {8 z
477. # You can configure the slow log with two parameters: one tells Redis
     
478. # what is the execution time, in microseconds, to exceed in order for the
     ! y: {) i3 I( @# ^  s
479. # command to get logged, and the other parameter is the length of the
     ! i3 B3 s- G) S1 Z) k% p0 R
480. # slow log. When a new command is logged the oldest one is removed from the
     
481. # queue of logged commands.
     
482. 
     
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. 
     - |2 P. F: @8 G1 T
488. # There is no limit to this length. Just be aware that it will consume memory.
     5 s3 o) i& K. y& w: Z& E
489. # You can reclaim memory used by the slow log with SLOWLOG RESET.
     
490. slowlog-max-len 128
     
491. 
     * \: p6 P& |0 x/ n" C& F; P% c9 v
492. ############################### ADVANCED CONFIG ###############################
     
493. 
     : C5 |8 A8 Y8 C' I
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
     6 {, A' d% u9 I/ m: X
496. # threshold. These thresholds can be configured using the following directives.
     , q+ k0 b' a) u
497. hash-max-ziplist-entries 512
     
498. hash-max-ziplist-value 64
     ! K( }0 t* h( I! B8 ]
499. 
     ' a- b3 X0 P! q, |4 r9 y* w
500. # Similarly to hashes, small lists are also encoded in a special way in order
     % [" l8 _* _' d! u7 l
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
     , ?0 h. `3 V' c% h; ]( s
505. 
     2 W- i6 m7 z/ P$ \
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
     
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.
     3 ^& C1 H6 |% c: U1 a
511. set-max-intset-entries 512
     
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
     
515. # elements of a sorted set are below the following limits:
     
516. zset-max-ziplist-entries 128
     9 `( T# B4 U1 ?0 f
517. zset-max-ziplist-value 64
     
518. 
     
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
     
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
     2 [! Q- u; A) t' H7 `8 z
523. # that is rehashing, the more rehashing "steps" are performed, so if the
     & O& w  I( k+ y6 f7 s. r# }* s; d! |+ B: V
524. # server is idle the rehashing is never complete and some more memory is used
     
525. # by the hash table.
     
526. #
     ) T0 d& R% ]7 A% k! K0 m9 o
527. # The default is to use this millisecond 10 times every second in order to
     ; H8 A3 L# l% }; D
528. # active rehashing the main dictionaries, freeing memory when possible.
     
529. #
       y: D/ U0 N$ Q* Q8 t3 u
530. # If unsure:
     5 J+ E) U! a+ v# |8 m5 v( H
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
     7 V* A5 [1 E  g9 @: f2 j, I
533. # to queries with 2 milliseconds delay.
     
534. #
     
535. # use "activerehashing yes" if you don't have such hard requirements but
     # ?/ c+ Q" ^8 p2 z% F" ^& n. T  p
536. # want to free memory asap when possible.
     
537. activerehashing yes
     $ A8 E- ~% G- W+ ?
538. 
     * ]5 A% N  j( C2 h  ]
539. # The client output buffer limits can be used to force disconnection of clients
     9 [  |/ p, c$ C' Z  l- n' O
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
     
542. # publisher can produce them).
     - ~- ~$ N  S- x+ I8 r9 C& f2 M
543. #
     
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
     
548. # pubsub -> clients subcribed to at least one pubsub channel or pattern
     , O$ }0 |4 y0 ~$ g" ?. S
549. #
     2 r$ O. h- r( o9 p* [/ V
550. # The syntax of every client-output-buffer-limit directive is the following:
     
551. #
     
552. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
     ( ~  I/ H% `+ N0 V9 o- J: y
553. #
     
554. # A client is immediately disconnected once the hard limit is reached, or if
     ' r$ m. o6 B! I# R; G* [2 l: r8 Q
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
     6 [/ F+ c6 h1 s7 e
558. # 16 megabytes / 10 seconds, the client will get disconnected immediately
     ; e% ]4 w; C3 W/ i5 x
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
     / B2 O- n% D! i; _
561. # the limit for 10 seconds.
     " P5 o3 ]( ~) z$ w, A5 X
562. #
     - l( {# Q$ n+ _  K% D
563. # By default normal clients are not limited because they don't receive data
     
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
     & X5 {& R; a1 X( W# Y. U% D
566. # than it can read.
     # S1 w3 N# ^" X6 N+ I3 J4 ^
567. #
     . B+ z' _; ]8 e4 r% `  y
568. # Instead there is a default limit for pubsub and slave clients, since
     7 A, V+ h' f# a6 V* T
569. # subscribers and slaves receive data in a push fashion.
     - ^, w" w4 e! J5 @
570. #
     8 @. c; m0 M* N0 j  ]( M
571. # Both the hard or the soft limit can be disabled by setting them to zero.
     ( F: t& H  v: k) |4 b
572. client-output-buffer-limit normal 0 0 0
     
573. client-output-buffer-limit slave 256mb 64mb 60
     9 \* k8 P2 a' G/ |
574. client-output-buffer-limit pubsub 32mb 8mb 60
     2 l; I) A! g: o( T# i, R! [( ?$ z
575. 
     # H) z# o+ E+ v3 `( r) [; W
576. ################################## INCLUDES ###################################
     
577. 
     ) Q. \7 E4 O. n, E2 |) ]8 ~
578. # Include one or more other config files here.  This is useful if you
     # U/ Z* m& ?9 S
579. # have a standard template that goes to all Redis server but also need
     
580. # to customize a few per-server settings.  Include files can include
     ) n: x( O$ I- w8 p  z0 a
581. # other files, so use this wisely.
     
582. #
     
583. # include /path/to/local.conf
     
584. # include /path/to/other.conf        
     
585. ##########################配置文件结束################################
     4 v0 _6 N. p5 ~9 F, \( V
586. 第三步：启动进程
     : {9 C6 {" U4 J& B" b6 N1 ?/ a
587. #redis-server /etc/redis.conf
     . t) m+ v/ _: h
588. 查看进程有没有成功启动
     
589. #ps -ef | grep redis
     
590. 测试输入一个键值
     - \% |) i6 G  B, j# O/ A! F
591. #redis-cli set test "testredis"
     + g+ D- A7 z5 ]
592. 获取键值
     . [! g; h6 k5 `' F
593. #redis-cli get test
     
594. 
     . @; O3 j+ ]8 p- _
595. 
     
596. 第四步:关闭redis  (这个是更改配置文件后 正常的重启方式  不重新加载redis配置跳过)
     
597. # redis-cli shutdown      //关闭所有   
     
598. 关闭某个端口上的redis   
     8 n2 s, W! I0 W* t8 u! h
599. # redis-cli -p 6397 shutdown  //关闭6397端口的redis  
     
600. 说明：关闭以后缓存数据会自动dump到硬盘上，硬盘地址见redis.conf中的dbfilename  dump.rdb  
     8 y/ Z! I. j3 ?1 y  m. i! z* h! N! d
601. 
     * |/ W* l; |7 I8 E* W$ O) t, q
602. 
     8 C# U. m7 @2 G& {
603. 第5步:php扩展安装
     
604. phpredis PHP扩展下载地址
     
605. https://github.com/nicolasff/phpredis/tree/2.2.2
     5 G! C8 [6 T8 ~1 {5 t
606. 选择最新版本下载zip
     
607. 
     
608. 然后自己上传zip  用unzip解压到当前目录 unzip 文件名
     
609. 
     
610. # cd owlient-phpredis-90ecd17/   #打开解压后的文件夹里面  这个解压后的目录 要是不知道 可以输入 "dir" 查看
     
611. # /www/nginx_php-5.2.17/bin
     # K8 j7 u  q  e& i, z  K
612. # ./configure --with-php-config=/www/nginx_php-5.2.17/bin/php-config
     
613. #make
     " q& ~5 O! A! ]9 Y
614. #make install   #记录产生的redis.so路径
     
615. 
     ; G6 E2 d. B0 L0 K
616. 修改php.ini文件
     , h- L+ F, R/ ^
617. 在php.ini中添加如下一行：
     . }5 t- {9 _. k7 ^! O
618. extension=/?/redis.so  #是刚刚记录的产生redis.so的路 写在 ?那
     8 |' ~0 Y/ X/ Q8 ~9 C
619. 重启 使之生效：
     
620. /usr/local/php/sbin/php-fpm reload
     % ]+ N, p6 o- {0 G2 d6 K/ g
621. /usr/local/nginx/sbin/nginx -s reload
     
622. 
     
623. 将 Redis 作为 Linux 服务随机启动
     0 [! o8 N: S2 O1 T
624. vi /etc/rc.local, 加入代码：
     , \! B- A; V. y% a
625. /root/redis-2.6.10/src/redis-serve  #路径看情况修改
     $ m- G, F2 e8 j) J% S
626. 
     5 |) i- Y* O  Q
627. redis-cli -h localhost -p 6379 info  #命令要在redis目录下面执行
     4 g( U. z7 J% P% Y( y
628. 提供host为localhost，端口为6379，redis服务的统计信息
     : Q. Z/ K" ~) S: j( S& _+ {
629. 
     8 c' U  j5 {: w) {# @
630. 
     , G! p" e. T4 L# ?4 y$ j0 {
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;
     
635. $_config['memory']['redis']['pconnect'] = 1;
     + U8 s2 i6 _7 `' d. S" F+ h7 m
636. $_config['memory']['redis']['timeout'] = '0';
     . ~) M# e0 J/ @3 _1 U# o( Z
637. $_config['memory']['redis']['serializer'] = 1;
     

复制代码