DZ

壹加壹

环境配置


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

壹加壹

http://www.discuz.net/forum.php? ... 648&highlight=REDIS
" K# K3 r; d/ ~; @! N1 u# m5 |无意间测试 单机状态 redis相当给力 测试1000请求/s  单纯的 get 和set 居然只用了 0.01秒 当时我惊呆了
2 s2 j" q: q* q3 J7 \! B7 \1 v
* A$ d+ {" g2 m2 A4 e* e7 \http://www.discuz.net/forum.php? ... 731&highlight=REDIS
. A& U2 _. m: }
/ V3 o/ j4 |$ e6 d8 x# N. H5 ahttps://wenku.baidu.com/view/265a5ce176a20029bc642d0b.html

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

1. 连接上 ssh
   
2. 
   " c/ M* d2 k- P5 p+ C/ P
3. 
   
4. 第一步:下载redis
   
5. # wget http://redis.googlecode.com/files/redis-2.6.10.tar.gz
   # S) u- Z. n1 D, K4 k. T; l4 F& q# A
6. # tar zxvf redis-2.6.10.tar.gz
   
7. # cd redis-2.6.10
   
8. # make
   , \3 ^5 b: c+ S" z& ^0 P
9. # make install  
   6 E" J- ?" W! W$ @* G0 v6 |
10. #cp redis.conf  /etc/ #复制配置文件到etc目录下面
    
11. 第二步：修改配置
    & k( S7 ]* |' U5 g
12. #vi /etc/redis.conf
    4 D: K) Z/ o) _6 |; L
13. ######################下面是无措的配置文件 复制过去就成#########
    
14. # Redis configuration file example
    # r; Y6 X" ~. v5 a4 n4 A5 T
15. 
    
16. # Note on units: when memory size is needed, it is possible to specify
    . q3 s5 W# N6 e- n
17. # it in the usual form of 1k 5GB 4M and so forth:
    
18. #
    
19. # 1k => 1000 bytes
    
20. # 1kb => 1024 bytes
    * G( |: a/ B5 D
21. # 1m => 1000000 bytes
    
22. # 1mb => 1024*1024 bytes
    
23. # 1g => 1000000000 bytes
    
24. # 1gb => 1024*1024*1024 bytes
    
25. #
    % w; q) U  ]  H
26. # units are case insensitive so 1GB 1Gb 1gB are all the same.
    - q  M' S0 K' {, e4 m$ C
27. 
    
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. 
    
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.
    . F# O6 C+ H& q4 F) g2 S- `& m0 h
34. pidfile /var/run/redis.pid
    3 M$ V& {3 g6 P0 A' S( p* p
35. 
    & p# j7 i& c, t) q* m1 d
36. # Accept connections on the specified port, default is 6379.
    & Q( k; S: ~0 n3 ^5 E
37. # If port 0 is specified Redis will not listen on a TCP socket.
    
38. port 6379
    
39. 
    
40. # If you want you can bind a single interface, if the bind option is not
    $ ^; k! C4 N' l8 _
41. # specified all the interfaces will listen for incoming connections.
    ; t  l0 x) R2 }: O8 B# z3 S; n
42. #
    ' i1 i7 G, J+ @9 S% S
43. # bind 127.0.0.1
    
44. 
    9 `3 |+ R- Y/ \8 a1 k
45. # Specify the path for the unix socket that will be used to listen for
    
46. # incoming connections. There is no default, so Redis will not listen
    
47. # on a unix socket when not specified.
    
48. #
    $ s3 |9 O: Y4 f! M; N# Q
49. # unixsocket /tmp/redis.sock
    
50. # unixsocketperm 755
    " Q' ?* z2 I9 j% r+ m6 G5 w
51. 
    ' d& H( Z1 x5 r- g: G, p% A
52. # Close the connection after a client is idle for N seconds (0 to disable)
    
53. timeout 300
    
54. 
    
55. # TCP keepalive.
    
56. #
    
57. # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
    ) I7 s. k9 B7 j  v  E3 C3 e
58. # of communication. This is useful for two reasons:
    
59. #
    
60. # 1) Detect dead peers.
    ( l2 Q0 f( X4 ]: ~7 d6 x  Z* u$ ~, W1 z
61. # 2) Take the connection alive from the point of view of network
    
62. #    equipment in the middle.
    
63. #
    
64. # On Linux, the specified value (in seconds) is the period used to send ACKs.
    
65. # Note that to close the connection the double of the time is needed.
    , q" j& W$ m; Z
66. # On other kernels the period depends on the kernel configuration.
    
67. #
    # b$ y0 I6 o" R0 [  m
68. # A reasonable value for this option is 60 seconds.
    6 {1 E* L# N0 j+ H8 h. e. u
69. tcp-keepalive 0
    
70. 
    
71. # Specify the server verbosity level.
    5 q8 c! e/ H' @" K1 O
72. # This can be one of:
    
73. # debug (a lot of information, useful for development/testing)
    
74. # verbose (many rarely useful info, but not a mess like the debug level)
    / @# }! o* }& |' Q
75. # notice (moderately verbose, what you want in production probably)
    & y" j5 A* b( T2 j  X
76. # warning (only very important / critical messages are logged)
    & {' {( D4 f! [/ Q; M
77. loglevel warning
    ' o1 {5 `7 F  ?# Y3 M6 X$ Q
78. 
    
79. # Specify the log file name. Also 'stdout' can be used to force
    
80. # Redis to log on the standard output. Note that if you use standard
    % _* j4 Q7 \# e  E
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,
    ! w$ Z0 W0 z+ L  B" J6 ?" F
85. # and optionally update the other syslog parameters to suit your needs.
    
86. syslog-enabled yes
    
87. 
    5 d% Q* [/ n1 M; G- \
88. # Specify the syslog identity.
    
89. # syslog-ident redis
    
90. 
    
91. # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
    4 X* N/ @! a" m7 T* c' T7 z
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
    
97. databases 16
    
98. 
    ' B! E' V% C3 H3 j. n# H( D2 A
99. ################################ SNAPSHOTTING  #################################
    
100. #
     
101. # Save the DB on disk:
     ( q) |! q7 I+ i6 E
102. #
     6 K. r& ~- f8 k' ~
103. #   save <seconds> <changes>
     & ^9 o, R5 j8 {/ l; A7 ]
104. #
     - U" r# |7 Y: g6 r. {- H
105. #   Will save the DB if both the given number of seconds and the given
     * X6 [* e# X% a3 E
106. #   number of write operations against the DB occurred.
     4 o  P( S$ O: ]
107. #
     
108. #   In the example below the behaviour will be to save:
     
109. #   after 900 sec (15 min) if at least 1 key changed
     2 G1 ]: ?* Q1 W" G
110. #   after 300 sec (5 min) if at least 10 keys changed
     
111. #   after 60 sec if at least 10000 keys changed
     
112. #
     
113. #   Note: you can disable saving at all commenting all the "save" lines.
     0 i. K1 ]$ M9 s% j
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
     $ R: Z0 L7 F4 d- t2 k" V" [
117. #   like in the following example:
     
118. #
     ) j. K$ [+ m' C  S. H+ y" ^
119. #   save ""
     : E3 C  [& |7 d
120. 
     
121. save 900 1
     - R$ u2 z$ ?" a8 q
122. save 300 10
     
123. save 60 10000
     ( x8 y$ t3 [( O. P, E$ ], y7 H
124. 
     - h, ?9 K, R: p/ L5 _- }
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.
     , v6 p( _. v  b
127. # This will make the user aware (in an hard way) that data is not persisting
     3 N* A' J  b& i) q  V
128. # on disk properly, otherwise chances are that no one will notice and some
     0 F4 n9 ]( C$ }
129. # distater will happen.
     
130. #
     + f! u8 N: F% S1 L, ?2 b1 k
131. # If the background saving process will start working again Redis will
     
132. # automatically allow writes again.
     
133. #
     2 a5 ]+ E* ?2 Y1 W5 n. K
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
     
139. 
     
140. # Compress string objects using LZF when dump .rdb databases?
     + n% w5 l& S) v0 O; \. s
141. # For default that's set to 'yes' as it's almost always a win.
     5 Q3 o* e0 Q2 L2 _% N" z7 T; {
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.
     ( G& E. ~7 E) v' |
144. rdbcompression yes
     
145. 
     
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
     / I+ \7 m; s0 l% J
149. # for maximum performances.
     
150. #
     ! l3 [+ H. A# F1 l
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
     8 ^: ~4 |# v4 O% U
154. 
     
155. # The filename where to dump the DB
     6 V1 H; W0 P" f: q3 U. G* Q! `9 K, @
156. dbfilename dump.rdb
     : J4 t& ^9 `/ V6 O+ C$ j+ d; Q
157. 
     $ k$ M. o, z( i" s3 H
158. # The working directory.
     
159. #
     0 Q# u9 ^5 G* E( L/ g
160. # The DB will be written inside this directory, with the filename specified
     
161. # above using the 'dbfilename' configuration directive.
     
162. #
     
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.
     $ x) M' ^6 J4 k
166. dir /var/db/redis
     
167. 
     
168. ################################# REPLICATION #################################
     
169. 
     * c5 u* I# U9 [; W/ Y% [
170. # Master-Slave replication. Use slaveof to make a Redis instance a copy of
     8 ^8 Z6 P% b7 Y) H
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
     7 W$ }8 c# o- u  `9 O
173. # different interval, or to listen to another port, and so on.
     
174. #
     7 G3 ^- q; D& E; T# Q2 ?: }: O
175. # slaveof <masterip> <masterport>
     
176. 
     ; {' E" ~& }/ [5 K6 J7 C
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. #
     
182. # masterauth <master-password>
     
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. #
     
187. # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
     ) A1 D2 ~7 {; Q( S& t
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.
     7 w2 r, p5 {3 l# ^
190. #
       u( P8 _) x! g( z  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
     - Y/ ?( j7 V/ [, h# A1 q
193. #    but to INFO and SLAVEOF.
     
194. #
     
195. slave-serve-stale-data yes
     ' @8 e* e! R+ p( S' ]9 N
196. 
     
197. # You can configure a slave instance to accept writes or not. Writing against
     0 G1 }7 k4 G9 ?! y( |
198. # a slave instance may be useful to store some ephemeral data (because data
     
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
     
201. # misconfiguration.
     
202. #
     % e+ n( ~- u* X% u4 K! E
203. # Since Redis 2.6 by default slaves are read-only.
     8 T, y! Y7 _! ^6 }+ r, [( L* g
204. #
     " _8 d& ?9 L: r" R' _0 y
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
     ! ~' |* t" c2 N- ^! M9 L
209. # security of read only slaves using 'rename-command' to shadow all the
     / M8 _* l3 N( L" n6 U7 v
210. # administrative / dangerous commands.
     # d" s4 `6 G3 x# B; k9 {
211. slave-read-only yes
     
212. 
     ( Q: V9 X* Y" P# `
213. # Slaves send PINGs to server in a predefined interval. It's possible to change
     7 I: }* a, m) @2 T
214. # this interval with the repl_ping_slave_period option. The default value is 10
     , f& A) ?+ o2 W& M" i
215. # seconds.
     
216. #
     
217. # repl-ping-slave-period 10
     3 k" f" h) t7 |3 T4 _
218. 
     
219. # The following option sets a timeout for both Bulk transfer I/O timeout and
     , N! H& M1 \# }7 ]7 r' `  n, H4 `
220. # master data or ping response timeout. The default value is 60 seconds.
     , j3 K9 N# y) U2 D+ u
221. #
     ; f, ]! U! e! N" @
222. # It is important to make sure that this value is greater than the value
     
223. # specified for repl-ping-slave-period otherwise a timeout will be detected
     # h8 A5 q4 Y2 W: d" q5 D
224. # every time there is low traffic between the master and the slave.
     & v% s4 N$ g( T5 s$ a  T5 H! G4 t
225. #
       M1 {, ]3 I5 e
226. # repl-timeout 60
     
227. 
     
228. # Disable TCP_NODELAY on the slave socket after SYNC?
     
229. #
     
230. # If you select "yes" Redis will use a smaller number of TCP packets and
     6 d7 i9 s( S; }/ ~3 N3 D  r
231. # less bandwidth to send data to slaves. But this can add a delay for
     
232. # the data to appear on the slave side, up to 40 milliseconds with
     " B1 I/ U. A. w, M, F
233. # Linux kernels using a default configuration.
     1 C- v2 H7 H) C4 E! D
234. #
     0 {# v0 H0 }* S: u1 M3 T" v' q
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
     , h7 ^* E+ H4 F# y+ }
240. # be a good idea.
     ( N7 V6 J+ {. b2 z
241. repl-disable-tcp-nodelay no
     : c' a, ~! J# j  d1 P, T
242. 
     9 n( {4 c! M1 T) O$ t/ |
243. # The slave priority is an integer number published by Redis in the INFO output.
     , R  G" o& P5 W& m- L& x
244. # It is used by Redis Sentinel in order to select a slave to promote into a
     5 M$ I+ K8 q' v
245. # master if the master is no longer working correctly.
     
246. #
     7 i. K2 q+ a: h$ g" |! \
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
     * a# Z- Q% c- z. w
249. # pick the one wtih priority 10, that is the lowest.
     
250. #
     8 K8 u! k/ @" f  S' g5 ]" d
251. # However a special priority of 0 marks the slave as not able to perform the
     ! E, l( R# l4 V/ {8 M7 |
252. # role of master, so a slave with priority of 0 will never be selected by
     
253. # Redis Sentinel for promotion.
     # d) ?6 \5 B, v4 [  M7 i1 `3 {' v
254. #
     / P( K8 x( W* l- s. N% [% d( n8 d, f
255. # By default the priority is 100.
     # L; v9 V3 P, d0 F  n9 B- g3 Y' F
256. slave-priority 100
     % B- |2 ]0 |( I" _- o
257. 
     
258. ################################## SECURITY ###################################
     
259. 
     / W8 z! v6 r: V3 }  @* H) y9 L
260. # Require clients to issue AUTH <ASSWORD> before processing any other
     5 d8 F/ h: z$ P9 Y4 C' A
261. # commands.  This might be useful in environments in which you do not trust
     
262. # others with access to the host running redis-server.
     
263. #
     / L. E9 K2 s5 h) n+ O/ N1 q% l5 W
264. # This should stay commented out for backward compatibility and because most
     2 r$ D* G/ K# [3 }2 q- y$ j2 z
265. # people do not need auth (e.g. they run their own servers).
     
266. #
       s' U( t* L! B0 R# ~8 B
267. # Warning: since Redis is pretty fast an outside user can try up to
       H  D( F3 {8 u2 q
268. # 150k passwords per second against a good box. This means that you should
     / u3 v* l* d9 h& }, a; d
269. # use a very strong password otherwise it will be very easy to break.
     
270. #
     
271. # requirepass foobared
     
272. 
     # ]1 h: E# c% }1 J- e
273. # Command renaming.
     & C) {/ n3 Q, X' B6 m
274. #
     
275. # It is possible to change the name of dangerous commands in a shared
     ( G6 v" \8 |* d0 ]7 x
276. # environment. For instance the CONFIG command may be renamed into something
     . v' g, r+ Q* l/ v- w7 w# g8 k" }
277. # hard to guess so that it will still be available for internal-use tools
     # ^6 j% z6 k; c: o; Z- g4 Q' F, w
278. # but not available for general clients.
     * m7 u) u& I7 I, _
279. #
     
280. # Example:
     
281. #
     
282. # rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
     ' S. J) ?. `$ D3 a& ]/ b
283. #
     3 G  i( a! p. J/ w1 }- [  C
284. # It is also possible to completely kill a command by renaming it into
     
285. # an empty string:
     3 E+ S7 i- f9 r" ?  K2 {7 B5 L
286. #
     
287. # rename-command CONFIG ""
     9 g9 }, J! E# O" P
288. 
     1 \' }" Y0 `+ _. A' o& x* I
289. ################################### LIMITS ####################################
     
290. 
     5 p7 t; h6 t' n+ [% l5 p6 P" T  F
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
     
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).
     . }! N: {2 L& C) U- F% |
296. #
     
297. # Once the limit is reached Redis will close all the new connections sending
     * h( H& j9 N; f7 G! T9 D6 S
298. # an error 'max number of clients reached'.
     
299. #
     
300. maxclients 500
     
301. 
     
302. # Don't use more memory than the specified amount of bytes.
     5 D  v6 y7 h! Q; u) r5 b7 ]: f2 y' V
303. # When the memory limit is reached Redis will try to remove keys
     
304. # accordingly to the eviction policy selected (see maxmemmory-policy).
     
305. #
     & {; y$ z4 Y0 z) z! N  k
306. # If Redis can't remove keys according to the policy, or if the policy is
     ) }6 q7 N: m. x
307. # set to 'noeviction', Redis will start to reply with errors to commands
     
308. # that would use more memory, like SET, LPUSH, and so on, and will continue
     
309. # to reply to read-only commands like GET.
     
310. #
     : c, L# S! u* i" Z7 o
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).
     ) M' `; B( h- V
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
     
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
     9 l$ J& y2 h  ^( z, @7 X  q
319. # of more keys, and so forth until the database is completely emptied.
     
320. #
     
321. # In short... if you have slaves attached it is suggested that you set a lower
     * d5 l$ h6 Q& @$ N5 b6 i
322. # limit for maxmemory so that there is some free RAM on the system for slave
     
323. # output buffers (but this is not needed if the policy is 'noeviction').
     3 p' Q6 c6 Z0 ~- A) n/ \) y/ O
324. #
     . _( }# i1 G+ F. b* P
325. maxmemory 128000000
     " e% {* W1 l! W
326. 
     
327. # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
     : }# J$ F2 \' P5 l( g% }
328. # is reached. You can select among five behaviors:
     
329. #
     
330. # volatile-lru -> remove the key with an expire set using an LRU algorithm
     
331. # allkeys-lru -> remove any key accordingly to the LRU algorithm
     
332. # volatile-random -> remove a random key with an expire set
     : U# M7 _- h6 f0 d$ J
333. # allkeys-random -> remove a random key, any key
     9 j$ m% E: _+ D  f' v
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
     $ I( ?, H2 y* F1 H4 z& b; B- G4 H
336. #
     + L3 S8 d) _. R; H, f
337. # Note: with any of the above policies, Redis will return an error on write
     9 m3 a! w% \. m5 g0 h/ I
338. #       operations, when there are not suitable keys for eviction.
     
339. #
     3 t# C1 ^* E7 L7 I1 h) Y
340. #       At the date of writing this commands are: set setnx setex append
     
341. #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
     " F; @' O' v' Y' P. ^
342. #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
     3 Z' ^2 v! p( E
343. #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
     
344. #       getset mset msetnx exec sort
     1 ^# }. q/ A. q  R7 |
345. #
     
346. # The default is:
     
347. #
     ( v5 O0 c- Z/ H; n' E- g
348. # maxmemory-policy volatile-lru
     
349. 
     
350. # LRU and minimal TTL algorithms are not precise algorithms but approximated
     6 B6 U& H: [) Y
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
     8 `! T. H! M- `* }8 r; f2 ?7 \
354. # using the following configuration directive.
     ' G/ X& e, U# K8 ^2 F: ^
355. #
     % i6 U0 r6 O) Y* x& a: y
356. # maxmemory-samples 3
     9 ^( d; a. {9 n# a3 m! `
357. 
     * ~9 v% H9 h  M
358. ############################## APPEND ONLY MODE ###############################
     
359. 
     0 d! k1 E( T2 ]9 n) F. q
360. # By default Redis asynchronously dumps the dataset on disk. This mode is
     7 @7 z7 [. y4 b- e) w; h
361. # good enough in many applications, but an issue with the Redis process or
     5 Q0 p$ x) J. a9 V
362. # a power outage may result into a few minutes of writes lost (depending on
     
363. # the configured save points).
     
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
     
367. # (see later in the config file) Redis can lose just one second of writes in a
     , n5 ^  g  N' I# a3 ]7 m* [- T
368. # dramatic event like a server power outage, or a single write if something
     6 Z, L8 D, G5 l! ~3 t: N
369. # wrong with the Redis process itself happens, but the operating system is
     
370. # still running correctly.
       V* {0 k3 n4 ^* l7 n0 ]& w
371. #
     6 U" j4 J$ p6 E" l6 d( ]. j6 L4 Z1 y
372. # AOF and RDB persistence can be enabled at the same time without problems.
     2 L: c: S) Q/ |* r  p
373. # If the AOF is enabled on startup Redis will load the AOF, that is the file
     
374. # with the better durability guarantees.
     1 |# h3 L2 o7 k$ f! E, V: Y/ L
375. #
       ^* c9 a( j' Q& L: ]; j% w
376. # Please check http://redis.io/topics/persistence for more information.
     5 F6 R3 u9 F3 k8 ?, ?2 w$ S
377. 
     2 W+ g  o8 d8 o3 p2 d' M1 q
378. appendonly no
     
379. 
     ( ^+ f) }, d& U' {- a5 A% P( S
380. # The name of the append only file (default: "appendonly.aof")
     6 }. p1 q# q4 e) V
381. # appendfilename appendonly.aof
     
382. 
     7 Y' e" W0 t/ r7 \/ m3 S
383. # The fsync() call tells the Operating System to actually write data on disk
     0 W. N' D  h+ v& g4 @3 J  E; s; R* T
384. # instead to wait for more data in the output buffer. Some OS will really flush
     ) m  j5 n& C! j( D6 j" Q3 c: r
385. # data on disk, some other OS will just try to do it ASAP.
     7 u* C; `# |, L! L! I
386. #
     
387. # Redis supports three different modes:
     
388. #
     
389. # no: don't fsync, just let the OS flush the data when it wants. Faster.
     0 j$ L  {4 s5 P/ ~# {# N
390. # always: fsync after every write to the append only log . Slow, Safest.
     
391. # everysec: fsync only one time every second. Compromise.
     
392. #
     9 i! ]& @+ o$ {
393. # The default is "everysec", as that's usually the right compromise between
     ; K/ \  M2 I) @$ p0 w$ z. l
394. # speed and data safety. It's up to you to understand if you can relax this to
     ! E2 m! `8 ]6 P7 c; ]# m
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
     ' Z3 F" S% W+ F5 _
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
     % g% e, A, S- x6 L/ y, T
399. # everysec.
     ) C) K! |# E% o6 Q+ O& W
400. #
     
401. # More details please check the following article:
     ( B0 M% y9 @; W/ N" d: J
402. # http://antirez.com/post/redis-persistence-demystified.html
     # J/ v7 c3 g# \1 U6 ?5 ?- h
403. #
     
404. # If unsure, use "everysec".
     / q3 W- N! Z$ y2 K: N% M0 n! X
405. 
     * k, ?$ J( z$ N4 p
406. # appendfsync always
     1 _# l+ g1 z/ [  f1 J
407. appendfsync everysec
     % v2 k; e2 W7 [1 \" U) t  e
408. # appendfsync no
     ' D' _/ P3 S, x# ~
409. 
     
410. # When the AOF fsync policy is set to always or everysec, and a background
     5 J. h8 V# {8 Z
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
     . \, E8 I5 ~3 t! {5 l# }
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
     7 J% ?/ O. t2 \) i
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
     ( k  Z# \$ H% L
419. # BGSAVE or BGREWRITEAOF is in progress.
     
420. #
     ! }2 ~4 D) t6 T/ r4 U8 z0 F
421. # This means that while another child is saving, the durability of Redis is
     0 @3 D/ b  ^3 o2 y$ J4 K4 u
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. #
     8 c) R  ?9 \1 s# Q
426. # If you have latency problems turn this to "yes". Otherwise leave it as
     " L- _2 ~5 u( H0 c* k
427. # "no" that is the safest pick from the point of view of durability.
     
428. no-appendfsync-on-rewrite no
     
429. 
     
430. # Automatic rewrite of the append only file.
     ) q: T( ^( ]2 O0 b9 P' F: D# c
431. # Redis is able to automatically rewrite the log file implicitly calling
     : V# t, m8 i% A, r
432. # BGREWRITEAOF when the AOF log size grows by the specified percentage.
       D- e3 H3 U4 x8 H
433. #
     2 a  Z' l5 X2 N
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).
     / D+ [$ A! c$ X4 B
437. #
     7 n, a( v0 B/ J9 S# }
438. # This base size is compared to the current size. If the current size is
     
439. # bigger than the specified percentage, the rewrite is triggered. Also
     
440. # you need to specify a minimal size for the AOF file to be rewritten, this
     
441. # is useful to avoid rewriting the AOF file even if the percentage increase
       v1 P) ]* ~6 b9 Y" |+ \8 G1 S
442. # is reached but it is still pretty small.
     
443. #
     
444. # Specify a percentage of zero in order to disable the automatic AOF
     # D  j" B  O' `/ ]' V+ p
445. # rewrite feature.
     
446. 
     
447. auto-aof-rewrite-percentage 100
     
448. auto-aof-rewrite-min-size 64mb
     ( d/ t3 Q& c1 D( t7 A
449. 
     
450. ################################ LUA SCRIPTING  ###############################
     
451. 
     : k5 y$ K/ x4 w7 t- ]7 z9 ?; S. b. v
452. # Max execution time of a Lua script in milliseconds.
     
453. #
     + c2 B& C8 Z6 _
454. # If the maximum execution time is reached Redis will log that a script is
     * m; ~. u; O0 Y9 S  V' r2 ~
455. # still in execution after the maximum allowed time and will start to
     7 w$ o8 ^+ e3 ~0 l7 F1 K  h  U
456. # reply to queries with an error.
     % f$ P! q/ y% r: _, h. _3 w4 c
457. #
     3 J- Y  ?2 j" \  A( J0 V
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
     1 y4 \, A# A% @" w6 Y) m! B
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
     + S0 N; e3 R0 }/ y4 W
462. # already issue by the script but the user don't want to wait for the natural
     
463. # termination of the script.
     6 o3 ]$ x9 Z  [
464. #
     - |$ u  p3 C% M+ ^* A1 e
465. # Set it to 0 or a negative value for unlimited execution without warnings.
     # A6 U5 W4 P" V( c2 ]
466. lua-time-limit 5000
     
467. 
     
468. ################################## SLOW LOG ###################################
     ; V) T4 w, Y4 U& M* w
469. 
     . E% }) M& j) I4 X4 g3 J
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,
     4 n# J" J) r, A. V" z
473. # but just the time needed to actually execute the command (this is the only
     ! ^9 n' ]7 I5 ~+ c, x
474. # stage of command execution where the thread is blocked and can not serve
     2 c: D! k, y* l& k8 M$ o! S0 x
475. # other requests in the meantime).
     
476. #
     $ c3 E4 X& Y7 a" P
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
     & [; [6 ^* ?- A2 `
479. # command to get logged, and the other parameter is the length of the
     , F8 D, J" C2 x3 F4 Y: \
480. # slow log. When a new command is logged the oldest one is removed from the
     
481. # queue of logged commands.
     4 d' t( M) e2 e
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
     7 H. {) H& C) A  \) E- B& J/ t
485. # a value of zero forces the logging of every command.
     ; K! G% C1 V) Q$ G2 Y; K
486. slowlog-log-slower-than 10000
     
487. 
     # M/ o) `/ a8 |+ `  U; E
488. # There is no limit to this length. Just be aware that it will consume memory.
     3 }% K& @4 w  b; M3 _; Y' [4 D
489. # You can reclaim memory used by the slow log with SLOWLOG RESET.
     " M2 S) F9 Q/ Z% k
490. slowlog-max-len 128
     
491. 
     $ E: q' B5 E5 Q, P! B5 p- V
492. ############################### ADVANCED CONFIG ###############################
     
493. 
     
494. # Hashes are encoded using a memory efficient data structure when they have a
     9 N4 \0 P$ h/ u% _! M5 _1 i+ w
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.
     + P: [% i( r$ v! }, @2 |& _
497. hash-max-ziplist-entries 512
     
498. hash-max-ziplist-value 64
     & W4 P) Q9 i4 x7 E
499. 
     
500. # Similarly to hashes, small lists are also encoded in a special way in order
     % M1 V  s' T1 V2 T# H, F
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
     ; v1 N, j$ p" L2 _* i
504. list-max-ziplist-value 64
     
505. 
     7 Q) i$ T' L" n$ J
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
     7 ^8 L  V5 E3 l' o% R
508. # of 64 bit signed integers.
     
509. # The following configuration setting sets the limit in the size of the
     % r. P4 W- j; r+ u5 ?% f' j
510. # set in order to use this special memory saving encoding.
     - e% Y/ w# [, c( A6 a9 [/ r
511. set-max-intset-entries 512
     , M/ C) C5 v* U! H
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:
     6 z& _- O3 b  t" R
516. zset-max-ziplist-entries 128
     
517. zset-max-ziplist-value 64
     
518. 
     
519. # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
     6 v; _- M+ G  l1 d
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
     
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.
     
526. #
     
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. #
     ! o' C6 T" z% @) d+ @6 O( `- R
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
     3 x2 B* ?) `& m: r- H" O+ q
533. # to queries with 2 milliseconds delay.
     % q( H1 E3 t; O0 c/ t9 j
534. #
     
535. # use "activerehashing yes" if you don't have such hard requirements but
     ( d: F  X2 ]1 A: h$ ^/ I
536. # want to free memory asap when possible.
     ! ?- B$ }5 p- m
537. activerehashing yes
     ) [- Y7 `4 W# @. {
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
     ! x, }! \- }0 Q& R6 f$ }; u. @% i. l
541. # common reason is that a Pub/Sub client can't consume messages as fast as the
     
542. # publisher can produce them).
     
543. #
     8 D" C% y+ V4 S5 E- m
544. # The limit can be set differently for the three different classes of clients:
     + E- Y. o1 r# b) j+ g
545. #
     4 j5 L) E# b0 H; H1 K
546. # normal -> normal clients
     
547. # slave  -> slave clients and MONITOR clients
     
548. # pubsub -> clients subcribed to at least one pubsub channel or pattern
     4 K3 ]7 b7 ^" {. I% g
549. #
     
550. # The syntax of every client-output-buffer-limit directive is the following:
     2 C4 l) q2 k$ f7 ~+ T) i
551. #
     
552. # client-output-buffer-limit <class> <hard limit> <soft limit> <soft seconds>
     * M# x+ p6 t6 G, s$ i: l
553. #
     
554. # A client is immediately disconnected once the hard limit is reached, or if
     , i' H! s( T% Z/ f/ a7 ?6 h. W
555. # the soft limit is reached and remains reached for the specified number of
     
556. # seconds (continuously).
     ( _+ w/ Z1 Y! R$ }+ O& j
557. # So for instance if the hard limit is 32 megabytes and the soft limit is
     1 ?7 F/ l% L5 a) |' G1 Z
558. # 16 megabytes / 10 seconds, the client will get disconnected immediately
     0 ?; ~3 I: J. Z& p
559. # if the size of the output buffers reach 32 megabytes, but will also get
     ) b8 S& }% ?4 P3 Q/ ?6 c
560. # disconnected if the client reaches 16 megabytes and continuously overcomes
     8 M& S. o" ^" V7 a* v0 s* Z
561. # the limit for 10 seconds.
     
562. #
     
563. # By default normal clients are not limited because they don't receive data
     ! F/ Q; ~9 }' c2 r
564. # without asking (in a push way), but just after a request, so only
     ! R% p! n% Y7 ?" d
565. # asynchronous clients may create a scenario where data is requested faster
     
566. # than it can read.
     + r; n  S* l- K1 X! e- f8 W( u
567. #
     
568. # Instead there is a default limit for pubsub and slave clients, since
     " F$ d8 F/ Z3 K
569. # subscribers and slaves receive data in a push fashion.
     
570. #
     - V5 y+ c: w* X) _( F
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
     3 h5 l* S1 j2 F4 Z
575. 
     
576. ################################## INCLUDES ###################################
     
577. 
     : D% {; g" x" n9 B( l
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
     , j% h& d0 i4 S' Z& f7 {
580. # to customize a few per-server settings.  Include files can include
     
581. # other files, so use this wisely.
     ) h+ R: s( G1 f+ E/ A6 B& M7 f) x
582. #
     2 I5 {/ C) B8 g! S+ a
583. # include /path/to/local.conf
     
584. # include /path/to/other.conf        
     
585. ##########################配置文件结束################################
     
586. 第三步：启动进程
     2 W$ O" L7 i# k* Y8 c' @- {, R
587. #redis-server /etc/redis.conf
     ) L  ?4 J% A. V. A) k" n
588. 查看进程有没有成功启动
     + U9 K8 `# t0 I
589. #ps -ef | grep redis
     
590. 测试输入一个键值
     
591. #redis-cli set test "testredis"
     
592. 获取键值
     * _' u( _) i/ L0 D' X2 V- g" n
593. #redis-cli get test
     
594. 
     
595. 
     , ^: b+ d' X% g6 ^
596. 第四步:关闭redis  (这个是更改配置文件后 正常的重启方式  不重新加载redis配置跳过)
     ' J: F  M$ x6 O, N
597. # redis-cli shutdown      //关闭所有   
     
598. 关闭某个端口上的redis   
     
599. # redis-cli -p 6397 shutdown  //关闭6397端口的redis  
     & ^; C- o( `6 k! Z
600. 说明：关闭以后缓存数据会自动dump到硬盘上，硬盘地址见redis.conf中的dbfilename  dump.rdb  
     & B; x# y9 `) w  B. a: Q: @0 w1 I
601. 
     
602. 
     ; l5 U& M6 z" s4 H/ H
603. 第5步:php扩展安装
     
604. phpredis PHP扩展下载地址
     . Z" y# ]9 x8 ]# L5 z2 B5 `) B  V
605. https://github.com/nicolasff/phpredis/tree/2.2.2
     0 C; z- q1 d' X  k( F* ~
606. 选择最新版本下载zip
     4 c; Q3 y' K- H# A8 s; b: r6 j
607. 
     4 ?. A9 }7 g" j- F) N5 j# D, L, X! N
608. 然后自己上传zip  用unzip解压到当前目录 unzip 文件名
       r+ Y! \, \, a
609. 
     
610. # cd owlient-phpredis-90ecd17/   #打开解压后的文件夹里面  这个解压后的目录 要是不知道 可以输入 "dir" 查看
     
611. # /www/nginx_php-5.2.17/bin
     ) D9 x' h! t/ ~* K
612. # ./configure --with-php-config=/www/nginx_php-5.2.17/bin/php-config
     
613. #make
     7 B. q& {) E; N% A1 R6 I
614. #make install   #记录产生的redis.so路径
     
615. 
     
616. 修改php.ini文件
     ! t  R' \' M6 W! u  o* m, P% w
617. 在php.ini中添加如下一行：
     
618. extension=/?/redis.so  #是刚刚记录的产生redis.so的路 写在 ?那
     7 |+ q7 N, H' c1 S
619. 重启 使之生效：
     * u. E" m: y  q! `
620. /usr/local/php/sbin/php-fpm reload
     
621. /usr/local/nginx/sbin/nginx -s reload
     $ [2 ?" U/ ^: F% o) B
622. 
     0 ^  F% w" D/ h' |! Y+ I, I& ]
623. 将 Redis 作为 Linux 服务随机启动
     ) Q: t; w, Q+ x7 B9 w6 l
624. vi /etc/rc.local, 加入代码：
     
625. /root/redis-2.6.10/src/redis-serve  #路径看情况修改
     
626. 
     
627. redis-cli -h localhost -p 6379 info  #命令要在redis目录下面执行
     1 j- Q; F! _+ C$ `' W% b" N
628. 提供host为localhost，端口为6379，redis服务的统计信息
     
629. 
     ( g2 v5 o; e( r1 \8 L
630. 
     1 j9 g: A# B$ M; \( j/ @
631. 就这样你的web服务器就支持redis了 记得要在 给dz 的配置文件 加上12.0.0.1哦
     : j  A$ Y1 `( v9 T5 i; t
632. dz配置文件在 config目录下面的 config_global.php
     
633. $_config['memory']['redis']['server'] = '127.0.0.1';
     ! y+ G6 u/ ?% j2 Y! i) p& p- B- K. m
634. $_config['memory']['redis']['port'] = 6379;
     
635. $_config['memory']['redis']['pconnect'] = 1;
     & w1 n' H- w* j/ E3 j5 f
636. $_config['memory']['redis']['timeout'] = '0';
     + e+ b& g6 [4 d2 c3 s
637. $_config['memory']['redis']['serializer'] = 1;
     # Y# s5 ~; f2 s) c  a( m

复制代码