redis的安裝與配置

官網

http://redis.io/download

 

管理工具

http://docs.redisdesktop.com/en/latest/quick-start/

https://redisdesktop.com/download

https://github.com/uglide/RedisDesktopManager

 

卸載
rm -rf /usr/bin/redis-*
或者
rm -rf /usr/local/bin/redis-*

配置文件
redis-server /etc/redis/redis.conf


容許遠程訪問
　原來是redis默認只能localhost登陸，因此須要開啓遠程登陸。解決方法以下：

　在redis的配置文件redis.conf中，找到#bind localhost註釋掉。

　註釋掉本機,局域網內的全部計算機都能訪問。

band localhost 只能本機訪問,局域網內計算機不能訪問。

bind 局域網IP 只能局域網內IP的機器訪問, 本地localhost都沒法訪問。

修改配置文件 中的 bind 節點
bind 0.0.0.0
接受內網地址遠程訪問
記得打開防火牆
ufw allow 6379



最新源碼地址
http://download.redis.io/releases/redis-3.2.3.tar.gz

 

 

一、下載源碼，解壓縮後編譯源碼。
[root@Redis ~]# wget http://download.redis.io/releases/redis-2.8.3.tar.gz
[root@Redis ~]# tar xzf redis-2.8.3.tar.gz
[root@Redis ~]# cd redis-2.8.3
[root@Redis ~]# make
[root@Redis ~]# make install
二、編譯完成後，在Src目錄下，有四個可執行文件redis-server、redis-benchmark、redis-cli和redis-2.8.3目錄下的redis.conf。而後拷貝到一個目錄下。
[root@Redis ~]# mkdir /usr/redis
[root@Redis ~]# cp redis-server /usr/redis
[root@Redis ~]# cp redis-benchmark /usr/redis
[root@Redis ~]# cp redis-cli /usr/redis
[root@Redis ~]# cp redis.conf /etc
[root@Redis ~]# cd /usr/redis
三、啓動Redis服務。
[root@Redis redis]# redis-server /etc/redis.conf
四、而後用客戶端測試一下是否啓動成功。
[root@Redis redis]# redis-cli
redis> set foo bar
OK
redis> get foo
「bar」.

redis有0-15庫，在實際使用過程當中，緩存的數據在這16個庫裏面怎麼分佈的？
redis有0-15庫，在實際使用過程當中，緩存的數據在這16個庫裏面怎麼分佈的，好比用戶的信息緩存在0庫，評論信息緩存在1庫，商品信息緩存在2庫？
添加評論 分享
查看所有 2 個回答

0
贊同反對，不會顯示你的姓名
用過
謝邀，

Redis 數據庫的做用只是提供一個簡單的命名空間（name space），以便將不一樣用途的數據分開而已，在同一個服務器進行分庫不會帶來任何效率上的提高。

若是使用多庫的話，每次讀寫操做都要使用Select命令選擇具體的庫。

建議使用默認的db0單庫，不一樣的業務數據使用不一樣的Key區分，好比：User:XX Product:XXX Comment:XXX。

 

 

 

redis配置文件redis.conf詳細說明

# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
#Redis默認不是以守護進程的方式運行，能夠經過該配置項修改，使用yes啓用守護進程（守護進程（daemon）是指在UNIX或其餘多任務操做系統中在後臺執行的電腦程序，並不會接受電腦用戶的直接操控。）
daemonize no



# When running daemonized, Redis writes a pid file in /var/run/redis.pid by
# default. You can specify a custom pid file location here.
#當 Redis 以守護進程的方式運行的時候,Redis 默認會把 pid 文件放在/var/run/redis.pid,你能夠配置到其餘地址。當運行多個 redis 服務時,須要指定不一樣的 pid 文件和端口
pidfile /var/run/redis.pid

# Accept connections on the specified port, default is 6379.
# If port 0 is specified Redis will not listen on a TCP socket.
#端口沒什麼好說的
port 6379

# If you want you can bind a single interface, if the bind option is not
# specified all the interfaces will listen for incoming connections.
#指定Redis可接收請求的IP地址,不設置將處理全部請求,建議生產環境中設置
# bind 127.0.0.1

# Close the connection after a client is idle for N seconds (0 to disable)
#客戶端鏈接的超時時間,單位爲秒,超時後會關閉鏈接
timeout 0

# Specify the log file name. Also 'stdout' can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
#配置 log 文件地址,默認打印在命令行終端的窗口上
logfile stdout

# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT <dbid> where
# dbid is a number between 0 and 'databases'-1
#設置數據庫的個數,可使用 SELECT <dbid>命令來切換數據庫。默認使用的數據庫是 0
databases 16



#
# Save the DB on disk:
#
# save <seconds> <changes>
#
# Will save the DB if both the given number of seconds and the given
# number of write operations against the DB occurred.
#
# In the example below the behaviour will be to save:
# after 900 sec (15 min) if at least 1 key changed
# after 300 sec (5 min) if at least 10 keys changed
# after 60 sec if at least 10000 keys changed
#
# Note: you can disable saving at all commenting all the "save" lines.
#設置 Redis 進行數據庫鏡像的頻率。
#900秒以內有1個keys發生變化時
#30秒以內有10個keys發生變化時
#60秒以內有10000個keys發生變化時
save 900 1
save 300 10
save 60 10000

# Compress string objects using LZF when dump .rdb databases?
# For default that's set to 'yes' as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
#在進行鏡像備份時,是否進行壓縮
rdbcompression yes

# The filename where to dump the DB
#鏡像備份文件的文件名
dbfilename dump.rdb

# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the 'dbfilename' configuration directive.
# 
# Also the Append Only File will be created inside this directory.
# 
# Note that you must specify a directory here, not a file name.
#數據庫鏡像備份的文件放置的路徑。這裏的路徑跟文件名要分開配置是由於 Redis 在進行備份時,先會將當前數據庫的狀態寫入到一個臨時文件中,等備份完成時,再把該該臨時文件替換爲上面所指定的文件,
#而這裏的臨時文件和上面所配置的備份文件都會放在這個指定的路徑當中
dir ./

# Master-Slave replication. Use slaveof to make a Redis instance a copy of
# another Redis server. Note that the configuration is local to the slave
# so for example it is possible to configure the slave to save the DB with a
# different interval, or to listen to another port, and so on.
#設置該數據庫爲其餘數據庫的從數據庫
# slaveof <masterip> <masterport>

# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the slave to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the slave request.
#指定與主數據庫鏈接時須要的密碼驗證
# masterauth <master-password>

# Require clients to issue AUTH <PASSWORD> before processing any other
# commands. This might be useful in environments in which you do not trust
# others with access to the host running redis-server.
#
# This should stay commented out for backward compatibility and because most
# people do not need auth (e.g. they run their own servers).
# 
# Warning: since Redis is pretty fast an outside user can try up to
# 150k passwords per second against a good box. This means that you should
# use a very strong password otherwise it will be very easy to break.
#設置客戶端鏈接後進行任何其餘指定前須要使用的密碼。
警告:redis速度至關快,一個外部的用戶能夠在一秒鐘進行150K次的密碼嘗試,你須要指定很是很是強大的密碼來防止暴力破解。

# requirepass foobared


# Set the max number of connected clients at the same time. By default there
# is no limit, and it's up to the number of file descriptors the Redis process
# is able to open. The special value '0' means no limits.
# Once the limit is reached Redis will close all the new connections sending
# an error 'max number of clients reached'.
#限制同時鏈接的客戶數量。當鏈接數超過這個值時,redis 將再也不接收其餘鏈接請求,客戶端嘗試鏈接時將收到 error 信息
# maxclients 128

# Don't use more memory than the specified amount of bytes.
# When the memory limit is reached Redis will try to remove keys
# accordingly to the eviction policy selected (see maxmemmory-policy).
#
# If Redis can't remove keys according to the policy, or if the policy is
# set to 'noeviction', Redis will start to reply with errors to commands
# that would use more memory, like SET, LPUSH, and so on, and will continue
# to reply to read-only commands like GET.
#
# This option is usually useful when using Redis as an LRU cache, or to set
# an hard memory limit for an instance (using the 'noeviction' policy).
#
# WARNING: If you have slaves attached to an instance with maxmemory on,
# the size of the output buffers needed to feed the slaves are subtracted
# from the used memory count, so that network problems / resyncs will
# not trigger a loop where keys are evicted, and in turn the output
# buffer of slaves is full with DELs of keys evicted triggering the deletion
# of more keys, and so forth until the database is completely emptied.
#
# In short… if you have slaves attached it is suggested that you set a lower
# limit for maxmemory so that there is some free RAM on the system for slave
# output buffers (but this is not needed if the policy is 'noeviction').
#設置redis可以使用的最大內存。當內存滿了的時候,若是還接收到set命令,redis將先嚐試剔除設置過expire信息的key,而無論該key的過時時間尚未到達。
#在刪除時,將按照過時時間進行刪除,最先將要被過時的key將最早被刪除。若是帶有expire信息的key都刪光了,那麼將返回錯誤。
#這樣,redis將再也不接收寫請求,只接收get請求。maxmemory的設置比較適合於把redis看成於相似memcached 的緩存來使用
# maxmemory <bytes>

# By default Redis asynchronously dumps the dataset on disk. If you can live
# with the idea that the latest records will be lost if something like a crash
# happens this is the preferred way to run Redis. If instead you care a lot
# about your data and don't want to that a single record can get lost you should
# enable the append only mode: when this mode is enabled Redis will append
# every write operation received in the file appendonly.aof. This file will
# be read on startup in order to rebuild the full dataset in memory.
#
# Note that you can have both the async dumps and the append only file if you
# like (you have to comment the "save" statements above to disable the dumps).
# Still if append only mode is enabled Redis will load the data from the
# log file at startup ignoring the dump.rdb file.
#
# IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
# log file in background when it gets too big.
#默認狀況下,redis 會在後臺異步的把數據庫鏡像備份到磁盤,可是該備份是很是耗時的,並且備份也不能很頻繁,若是發生諸如拉閘限電、拔插頭等情況,那麼將形成比較大範圍的數據丟失。
#因此redis提供了另一種更加高效的數據庫備份及災難恢復方式。
#開 啓append only 模式以後,redis 會把所接收到的每一次寫操做請求都追加到appendonly.aof 文件中,當redis從新啓動時,會從該文件恢復出以前的狀態。
#可是這樣會形成 appendonly.aof 文件過大,因此redis還支持了BGREWRITEAOF 指令,對appendonly.aof進行從新整理
appendonly no

# The fsync() call tells the Operating System to actually write data on disk
# instead to wait for more data in the output buffer. Some OS will really flush 
# data on disk, some other OS will just try to do it ASAP.
#
# Redis supports three different modes:
#
# no: don't fsync, just let the OS flush the data when it wants. Faster.
# always: fsync after every write to the append only log . Slow, Safest.
# everysec: fsync only if one second passed since the last fsync. Compromise.
#
# The default is "everysec" that's usually the right compromise between
# speed and data safety. It's up to you to understand if you can relax this to
# "no" that will will let the operating system flush the output buffer when
# it wants, for better performances (but if you can live with the idea of
# some data loss consider the default persistence mode that's snapshotting),
# or on the contrary, use "always" that's very slow but a bit safer than
# everysec.
#
# If unsure, use "everysec".
#設置對 appendonly.aof 文件進行同步的頻率。always 表示每次有寫操做都進行同步,everysec 表示對寫操做進行累積,每秒同步一次。
# appendfsync always
appendfsync everysec
# appendfsync no

# Virtual Memory allows Redis to work with datasets bigger than the actual
# amount of RAM needed to hold the whole dataset in memory.
# In order to do so very used keys are taken in memory while the other keys
# are swapped into a swap file, similarly to what operating systems do
# with memory pages.
#
# To enable VM just set 'vm-enabled' to yes, and set the following three
# VM parameters accordingly to your needs.
#是否開啓虛擬內存支持。由於 redis 是一個內存數據庫,並且當內存滿的時候,沒法接收新的寫請求,因此在redis2.0中,提供了虛擬內存的支持。
#可是須要注意的是,redis中,全部的key都會放在內存中,在內存不夠時,只會把value 值放入交換區。
#這樣保證了雖然使用虛擬內存,但性能基本不受影響,同時,你須要注意的是你要把vm-max-memory設置到足夠來放下你的全部的key
vm-enabled no
# vm-enabled yes

# This is the path of the Redis swap file. As you can guess, swap files
# can't be shared by different Redis instances, so make sure to use a swap
# file for every redis process you are running. Redis will complain if the
# swap file is already in use.
#
# The best kind of storage for the Redis swap file (that's accessed at random) 
# is a Solid State Disk (SSD).
#
# *** WARNING *** if you are using a shared hosting the default of putting
# the swap file under /tmp is not secure. Create a dir with access granted
# only to Redis user and configure Redis to create the swap file there.
#設置虛擬內存的交換文件路徑
vm-swap-file /tmp/redis.swap

# vm-max-memory configures the VM to use at max the specified amount of
# RAM. Everything that deos not fit will be swapped on disk *if* possible, that
# is, if there is still enough contiguous space in the swap file.
#
# With vm-max-memory 0 the system will swap everything it can. Not a good
# default, just specify the max amount of RAM you can in bytes, but it's
# better to leave some margin. For instance specify an amount of RAM
# that's more or less between 60 and 80% of your free RAM.
#這裏設置開啓虛擬內存以後,redis將使用的最大物理內存的大小。默認爲0,redis將把他全部的能放到交換文件的都放到交換文件中,以儘可能少的使用物理內存。
#在生產環境下,須要根據實際狀況設置該值,最好不要使用默認的 0
vm-max-memory 0

# Redis swap files is split into pages. An object can be saved using multiple
# contiguous pages, but pages can't be shared between different objects.
# So if your page is too big, small objects swapped out on disk will waste
# a lot of space. If you page is too small, there is less space in the swap
# file (assuming you configured the same number of total swap file pages).
#
# If you use a lot of small objects, use a page size of 64 or 32 bytes.
# If you use a lot of big objects, use a bigger page size.
# If unsure, use the default 
#設置虛擬內存的頁大小,若是你的 value 值比較大,好比說你要在 value 中放置博客、新聞之類的全部文章內容,就設大一點,若是要放置的都是很小的內容,那就設小一點
vm-page-size 32

# Number of total memory pages in the swap file.
# Given that the page table (a bitmap of free/used pages) is taken in memory,
# every 8 pages on disk will consume 1 byte of RAM.
#
# The total swap size is vm-page-size * vm-pages
#
# With the default of 32-bytes memory pages and 134217728 pages Redis will
# use a 4 GB swap file, that will use 16 MB of RAM for the page table.
#
# It's better to use the smallest acceptable value for your application,
# but the default is large in order to work in most conditions.
#設置交換文件的總的 page 數量,須要注意的是,page table信息會放在物理內存中,每8個page 就會佔據RAM中的 1 個 byte。
#總的虛擬內存大小 = vm-page-size * vm-pages
vm-pages 134217728

# Max number of VM I/O threads running at the same time.
# This threads are used to read/write data from/to swap file, since they
# also encode and decode objects from disk to memory or the reverse, a bigger
# number of threads can help with big objects even if they can't help with
# I/O itself as the physical device may not be able to couple with many
# reads/writes operations at the same time.
#
# The special value of 0 turn off threaded I/O and enables the blocking
# Virtual Memory implementation.
#設置 VM IO 同時使用的線程數量。
vm-max-threads 4

# Hashes are encoded in a special way (much more memory efficient) when they
# have at max a given numer of elements, and the biggest element does not
# exceed a given threshold. You can configure this limits with the following
# configuration directives.
#redis 2.0 中引入了 hash 數據結構。 
#hash 中包含超過指定元素個數而且最大的元素當沒有超過臨界時,hash 將以zipmap(又稱爲 small hash大大減小內存使用)來存儲,這裏能夠設置這兩個臨界值
hash-max-zipmap-entries 512
hash-max-zipmap-value 64

# Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
# order to help rehashing the main Redis hash table (the one mapping top-level
# keys to values). The hash table implementation redis uses (see dict.c)
# performs a lazy rehashing: the more operation you run into an hash table
# that is rhashing, the more rehashing "steps" are performed, so if the
# server is idle the rehashing is never complete and some more memory is used
# by the hash table.
# 
# The default is to use this millisecond 10 times every second in order to
# active rehashing the main dictionaries, freeing memory when possible.
#
# If unsure:
# use "activerehashing no" if you have hard latency requirements and it is
# not a good thing in your environment that Redis can reply form time to time
# to queries with 2 milliseconds delay.
#
# use "activerehashing yes" if you don't have such hard requirements but
# want to free memory asap when possible.
#開啓以後,redis 將在每 100 毫秒時使用 1 毫秒的 CPU 時間來對 redis 的 hash 表進行從新 hash,能夠下降內存的使用。
#當你的使用場景中,有很是嚴格的實時性須要,不可以接受 Redis 時不時的對請求有 2 毫秒的延遲的話,把這項配置爲 no。
#若是沒有這麼嚴格的實時性要求,能夠設置爲 yes,以便可以儘量快的釋放內存
activerehashing yes

 

 

How to Install and configure Redis on Ubuntu 14.04

What is Redis

Quoting Introduction to Redis page :

Redis is an open source (BSD licensed), in-memory data structure store, used as database, cache and message broker.

Redis supports multiple types of data structures. You can find data structures that Redis support below :

• Binary-safe strings
• Lists
• Sets
• Hashes
• Bit arrays (or bitmaps)
• Hyperloglogs

Installing Redis From Repository

Now, let's install Redis from the Ubuntu repository. Before installing Redis, let's update the system to latest update first.

$ sudo apt-get update $ sudo apt-get upgrade

After updating the system, it's time to install Redis from the repository.

$ sudo apt-get -y install redis-server

By default, redis-server is started after installation. You can check using the service command :

$ sudo service redis-server status redis-server is running

We can also check using the netstat command whether redis-server is already listening on a port or not.

$ sudo netstat -naptu | grep LISTEN tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 887/sshd tcp 0 0 127.0.0.1:6379 0.0.0.0:* LISTEN 20478/redis-server tcp6 0 0 :::22 :::* LISTEN 887/sshd

From output above we learned that redis server is already listening on port 6379 and bind to localhost or127.0.0.1.

Configuring Redis

Redis configuration is located in the /etc/redis/redis.conf file. In this tutorial we'll change one Redis configuration directive so that it will listen to all network interfaces instead of only on localhost. This is useful if you have a dedicated redis server and you're connecting from other servers, such as an application server.

Open /etc/redis/redis.conf. Find line below:

bind 127.0.0.1

Change the line above with

bind 0.0.0.0

Restart Redis service

$ sudo service redis-server restart

Now check where Redis is listening.

$ sudo netstat -naptu | grep LISTEN tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 906/sshd tcp 0 0 0.0.0.0:6379 0.0.0.0:* LISTEN 7650/redis-server 0 tcp6 0 0 :::22 :::* LISTEN 906/sshd

We see above that redis is listening on all interfaces on port 6379 (0.0.0.0:6379).

There are a lot more configuration directive on redis.conf file. You can read the comment above each directive to see how you can customize Redis configuration.

Securing Redis

By default Redis is not secure. It assumes that it runs on a secure environment or network. From Redis security page :

Redis is designed to be accessed by trusted clients inside trusted environments. This means that usually it is not a good idea to expose the Redis instance directly to the internet or, in general, to an environment where untrusted clients can directly access the Redis TCP port or UNIX socket.

In this section we'll discuss how-to secure Redis.

Setting up a Firewall

The first method that you can use to secure Redis is by setting up a firewall. You can use a firewall on a host level using iptables or on a network level from a Firewall device. If you are using a cloud service you can also use a Firewall service that your provider provides on a host or a network level.

Configure a Password for Redis

By default Redis does not ask the user to authenticate. To add more security to your Redis installation you can enable authentication on your Redis server.

Open /etc/redis/redis.conf file, find the line below

```

requirepass foobared

```

Replace foobared the line above with your own password. You can also use a fully random password like the line below

requirepass nl6Cq8mthJrrXbqlDqLaPgtFkeq12zqB7Sb5j5UJ

Restart redis-server to make the change take effect :

$ sudo service redis-server restart Stopping redis-server: redis-server. Starting redis-server: redis-server.

Now let's test the new configuration. Open redis-cli

$ redis-cli Run PING on redis console

127.0.0.1:6379> PING (error) NOAUTH Authentication required.

Now use AUTH and input your password.

127.0.0.1:6379> AUTH nl6Cq8mthJrrXbqlDqLaPgtFkeq12zqB7Sb5j5UJ OK

If authentication is successful it will return OK. Now if you run PING again, it will return PONG as expected.

127.0.0.1:6379> PING PONG 127.0.0.1:6379>

If you need to generate a random password you can use the hash of your easily remembered password / passphrase using md5sum, sha1sum, or sha256sum. You can find the sample below :

Creating an MD5 Hash for a Redis password

$ echo "Rogue Nation" | md5sum 003dab87555ea8267ce713a50d3525b9 -

Creating an SHA1 Hash for a Redis password

sumodirjo@labs:~$ echo "Rogue Nation" | sha1sum ebb963281b7515aae2ce185c2f455023654db240 -

Creating a SHA256 Hash for Redis password

sumodirjo@labs:~$ echo "Rogue Nation" | sha256sum 342fd6c5b14db8c969ca7901cf03b1fd81bb01e445e5b3b9a034a68c48277a23 -

As an alternative, you can also get the random password online from GRC's Ultra High Security Password Generator.

Rename or Disable Some Dangerous Commands

Additional methods that you can employ to secure your redis installation is by renaming or disabling some dangerous commands. This configuration is also located on the SECURITY section on the/etc/redis/redis.conf file. For example the config below will change the CONFIG commmand with123aqCONFGG.

rename-command CONFIG 123aqCONFGG

We also can disable a command. To disable the CONFIG command you can put empty quotes ("") as the replacement of CONFIG command

rename-command CONFIG ""

Don't forget to restart redis-server after changing the configuration by running command below

$ sudo service redis-server restart

Benchmarking Redis

Redis comes with the redis-benchmark tool. You can try benchmarking redis by running redis-benchmarkwithout options

``` $ redis-benchmark ====== PING_INLINE ====== 10000 requests completed in 0.17 seconds 50 parallel clients 3 bytes payload keep alive: 1

99.08% <= 1 milliseconds 99.51% <= 2 milliseconds 99.83% <= 3 milliseconds 100.00% <= 4 milliseconds 58139.53 requests per second

====== PING_BULK ====== 10000 requests completed in 0.11 seconds 50 parallel clients 3 bytes payload keep alive: 1

100.00% <= 0 milliseconds 91743.12 requests per second

...The output above is truncated since it's quite long. You can see the complete options of redis-benchmark using-h``` option.

Another example below is if you want to use the 1000 concurent connection (-c) option with total request (-n) 100000, you can run command below :

$ redis-benchmark -c 1000 -n 100000

Using Redis

Now let's use Redis. The most basic usage of redis is as key-value store. Let store a key and its value.

$ redis-cli 127.0.0.1:6379> set name "Muhamad Panji" OK 127.0.0.1:6379> get name "Muhamad Panji"

The distinguishing feature of Redis is that the value can be a data structure instead of only a value.

We will put four city names using lpush and rpush below from the redis-cli. If you have already set authentication up you will have to authenticate first before running the command below.

$ redis-cli 127.0.0.1:6379> lpush cities "Yogyakarta" (integer) 1 127.0.0.1:6379> lpush cities "Jakarta" (integer) 2 127.0.0.1:6379> rpush cities "Bogor" (integer) 3 127.0.0.1:6379> lpush cities "Bandung" (integer) 4

Now let's check the values of cities using the lrange command.

$ redis-cli 127.0.0.1:6379> lrange cities 0 -1 1) "Bandung" 2) "Jakarta" 3) "Yogyakarta" 4) "Bogor"

As you can see above the 2nd and 3rd cities inserted on the left (before the 1st city), and the 4th city inserted from the right (after the 1st city).

Futher Learning Resources

If you want to learn more about how-to use Redis, you can follow some tutorial below :

• Try Redis is online tutorial where you can learn by typing redis command on the website.
• The Little Redis Book
• Redis Cookbook

Summary

In this tutorial we learned how-to install Redis on Ubuntu 14.04 from the Ubuntu repository. We also learned how to manage the Redis service, configuring the service, securing Redis, and also Benchmarking Redis. We also learned the basic usage of Redis.