1, banco de dados de memória Redis
Antecedentes
Com o advento da grande era de dados da Internet +, o banco de dados relacional tradicional não pode mais grandes sites no volume crescente de tráfego de dados e se encontram. Desta vez, precisamos de uma maneira para acessar rapidamente os dados do componente para aliviar a pressão sobre o servidor de banco de dados I / O, e para resolver o gargalo no desempenho do sistema.
História do desenvolvimento da base de dados
-
1. Antes da era de dados da Internet + grande, algum sistema de gestão de informação corporativa interna, uma única instância de banco de dados será capaz de atender às necessidades do sistema de
banco de dados instância única -
2. Com o aumento do acesso ao sistema do usuário, aumento da quantidade de dados, uma única instância do sistema de banco de dados falhou para atender as necessidades da leitura
tampão (memcache) + instância banco de dados único -
3. O cache de leitura pode aliviar a pressão do sistema, mas a quantidade de dados gravados para a pressão continua a aumentar;
tampão + + banco de dados lidos a partir do separador principal -
4. A quantidade de dados aumenta novamente, após a leitura e de gravação separado, escrever pressão biblioteca de base de dados principais gargalos;
base de dados do cluster do cache de + + + sub-biblioteca de sub-tabela de leitura e de gravação separado o mestre -
5. Internet + grande era de dados, bancos de dados relacionais não podem acessar alguns dos muito boa alta concorrência, elevada em tempo real, e o formato de dados não são dados fixo. + + NoSQL separado ler e escrever a partir do cluster de banco de dados sub-table + sub-biblioteca principal
2 Redis
Redis é um alto desempenho, de código aberto, o desenvolvimento da linguagem C, chave de banco de dados NoSQL para armazenar dados.
NoSQL: não só SQL, refere-se a base de dados relacional não-Redis / MongoDB / HBase Hadoop
bases de dados relacionais: MySQL, Oracle, SqlServer
Propriedades Redis
- Quando a persistência de dados de apoio Redis, dados na memória podem ser salvos em disco, reiniciar pode ser carregado novamente usando
- Redis suporta não apenas tipos de dados de valor-chave simples, ao mesmo tempo proporcionar List, conjunto de tipos de dados
- Redis suporta dados de backup
Redis que é o uso?
O principal papel dos Redis: Acesso rápido
cenários de aplicação Redis
on-line lista de amigos polegares para cima de plataforma / spike / broadcast / produto escalão / single sign-on
Redis como usar?
Oficial endereço do site: site oficial
Comando Endereço: Comando Endereço
Redis cinco tipos de dados e cenários de
corda / list / set / haxixe / zset
instalação Redis e partida
no sistema Ubuntu
sudo apt-get install redis-servidor
Ver ajuda do comando
redis-servidor --help
Redis editar o arquivo de configuração
sudo vim /etc/redis/redis.conf
vai daemonize há sim mudança daemonize
para salvar e sair
Iniciar
redis-servidor
Abra os redis serviço sudo serviço começar
Fechar serviço sudo serviço Redis parada
Redis processos abertos no sistema Windows : diretamente extraído, as janelas não suportam daemonize
o perfil de Redis
/etc/redis/redis.conf
Quando Redis executado como um daemon, ele vai escrever um arquivo pid para dentro /var/run/redis.pid.
daemonize não
Ouvir o número da porta, o padrão é 6379, se você definir a 0, Redis vai ouvir qualquer cliente não está ligado à tomada.
porto 6379
Definir número de bancos de dados.
bases de dados 16
O número de vezes que um determinado intervalo de tempo e salvar os dados de gravação para o disco
O exemplo a seguir destina-se:
se pelo menos uma mudança-chave valor, em seguida, armazenada a cerca de 900 segundos
tecla de mudança de valor 10 se existem pelo menos 300 segundos, os armazenados
60 segundos se pelo menos 10.000 mudança chave valor, o armazenadas
save 900. 1
save 300 10
save 60 10000
Ouvir o número da porta, o padrão é 6379, se você definir a 0, Redis vai ouvir qualquer cliente não está ligado à tomada.
porto 6379
Redis permite apenas ligações locais por padrão, não permite que outras máquinas conectadas a
ligar 127.0.0.1
Mais perfil: https: //www.cnblogs.com/kreo/p/4423362.html
Simples de usar banco de dados Redis
DBSIZE ------------------------- ver o número atual chave de bases de dados
chaves * ---------------- ----------- visualizar o conteúdo chave
FLUSHDB --------------------- limpar o número atual de banco de dados chave
fLUSHALL ----- --------------- limpar todas chave bibliotecas (cuidado)
EXISTE Key ----------------------- juiz se existem chave
3, Redis cinco tipos comuns de dados
1.redis-string
Redis cadeia é o tipo mais básico, uma chave que corresponde a um valor de
cadeia pode conter quaisquer dados, não exceder o valor máximo 512M
set / get / del / append / strlen
set ---- 设置值
get ---- 获取值
mset ---- 设置多个值
mget ---- 获取多个值
append ---- 添加字段
del ---- 删除
strlen ---- 返回字符串长度
incr / decr / incrby / decrby
incr ---- 增加
decr ---- 减少
incrby ----- 制定增加多少
decrby ----- 制定减少多少
GetRange / SetRange
getrange ---- 获取指定区间范围内的值,类似between....and的关系
setrange ---- 代表从第几位开始替换,下脚本从零开始从0 -1表示全部
2.redis-list (um único valor do multi valor)
List (lista)
lista é uma lista simples de cordas, a fim ordenação por inserção, os elementos podem adicionar uma cabeça da lista (esquerda) ou uma parte da cauda (lado direito)
, que é uma lista do real subjacente
Lpus / Rpus / Lrange
lpush/rpush/lrange ---- 从左/从右/获取指定长度
lpush list01 1 2 3 4 5 倒序排列
rpush list02 1 2 3 4 5 正序排列
lrange list01 0 -1 获取list01 中的所有值
lpop / RPOP
lpop/rpop ---- 移除最左/最右
lpop list01 删除最左元素
rpop list01 删除最右元素
lindex, obtido de acordo com o elemento de indexação subscrito (de cima para baixo)
lrange list01 0 -1
lindex list01 1
llen, comprimento buscando lista
llen list01
chave lrem
删N个value
lrem list01 2 1 在list01中删除2个1
chave ltrim
ltrim ---- 开始index结束index,截取指定范围的值后在赋值给key
ltrim list01 0 2 截取list01 从0到2的数据在赋值给list01
rpoplpush list1 list2 para list1 última empurrado pela primeira vez em list2
lrange list01 0 -1
lrange list02 0 -1
rpoplpush list1 list2
LSet valor chave de índice
lset list01 0 x 将list02中第一位换成x
chave lColoque antes / depois
linsert list01b before x php 在x之前加字段php
3.redis-Hash
é um conjunto de chave de hash
hash é um tipo de cadeia e o valor da tabela de mapeamento de campo, de hash particularmente adequado para o armazenamento de objectos
HColoque / hget / hmset / hmget / hgetall / HDEL
设值/取值/设值多个值/取多个值/取全部值/删除值
hset user id 11
hget user id
hmset customer id 11 name juran age 26
hmget customer id name age 只返回相应的值
hgetall customer 返回全部
hdel user id 删除id
hlen comprimento busca de hash
hlen customer
chave hexists
hexists ---- 在key里面的某个值
存在返回1 ，不存在返回0
HKEY / baleia
hkeys students
hvals students
4.redis-conjunto (não duplicado)
Set (set)
SET coleção desordenada do tipo string, há elementos duplicados
Sadd / smembers / sismember
sadd/smembers/sismember ---- 添加/查看集合/查看是否存在
sadd set01 1 2 2 3 3 去掉重复添加
smembers set01 得到set01
sismember set01 1 如果存在返回1 不存在返回0
scard
scard ---- 获取集合里面的元素个数
scard set01
valor de chave srem
srem ---- 删除集合中元素
srem set01 3
SMEMBERS set01 3已经被删除掉
chave srandmember
srandmembe ---- 随机出几个数
sadd set02 1 2 3 4 5 6 7 8
srandmember set02 2
chave POCA
spop ---- 随机出栈
spop set01
smove key1 key2
sadd set03 x y z
smove set01 set03 2 将set01中的2 移动到set03中
coleções matemáticos
sadd set01 1 2 3 4 5
sadd set02 1 2 3 a b
差集
SDIFF set01 set02 返回 4 5 在第一个set中不在第二个set中
交集
SINTER set01 set02 返回 1 2 3
并集
SUNION set01 set02 返回set01 set02 中的值 去掉重复
5.redis-Zset
Zset (conjunto ordenado)
Zadd / zrange
zadd zset01 60 v1 70 v2 80 v3 90 v4 100 v5
zrange zset01 0 -1
带分数返回 withscores
zrangebyscore tecla terminar início
zrangebyscore key start end----根据开始结束来取值
zrangebyscore zset01 60 70
zrangebyscore zset01 60 (90 表示不包含90
zrangebyscore zset01 60 90 limit 1 2 从第一条开始截取2条
chave zrem
zrem key value---- 某score下对应的value值,作用是删除元素
zrem zset01 v1
zcard / zcount pontuação chave 区间 / zrank valores-chave
zcard 求zset01 总条数
zcount zset01 60 90 求60-90个数
zrank zset01 v2 返回1 返回对应下角标，从0开始
4, o Python operação Redis
redispy conexão instalação e
instalação
pip install redis
conexão
r = redis.StrictRedis(host='localhost',port=6379,db=0)
operações relacionadas com corda
import redis
class TestString(object):
def __init__(self):
self.r = redis.StrictRedis(host='127.0.0.1', port=6379)
# 设置值
def string_set(self, keys, items):
res = self.r.set(keys, items)
print(res) # 返回的是布尔类型的值
# 取值
def string_get(self, keys):
res = self.r.get(keys)
return res
# 设置多个值
def string_mset(self, items):
if isinstance(items, dict):
res = self.r.mset(items)
print(res)
# 取多个值
def string_mget(self, keys):
if isinstance(keys, dict):
res = self.r.mget(keys)
print(res)
# 删除
def string_del(self, keys):
if self.r.exists(keys):
self.r.delete(keys)
else:
# return "{} is not found".format(keys)
raise ValueError("{} is not found".format(keys))
if __name__ == '__main__':
s = TestString()
d = {
"user": "123",
"user1": "1"
}
s.string_mset(d)
print(s.string_del("user"))
Uma lista de operações relacionadas
import redis
class List_Redis(object):
def __init__(self):
self.r = redis.StrictRedis(host='127.0.0.1', port=6379)
# 添加值
def list_lpush(self, keys, items):
res = self.r.lpush(keys, items)
return res
# 删除元素
def list_lpop(self, keys):
result = self.r.lpop(keys)
return result
if __name__ == '__main__':
l = List_Redis()
# l.list_lpush('li9', '1 2 3 4 5 6 7 8 8 9')
l.list_lpop("li9")
Uma coleção de operações relacionadas
import redis
class Set_Redis(object):
def __init__(self):
self.r = redis.StrictRedis(host='127.0.0.1', port=6379)
# 添加数据
def set_sadd(self,keys, items):
result = self.r.sadd(keys, items)
return result
# 删除数据
def set_srem(self, keys, values):
res = self.r.srem(keys, values)
return res
# 随机删除元素
def set_pop(self, keys):
res = self.r.spop(keys)
return res
if __name__ == '__main__':
s = Set_Redis()
s.set_sadd('s1', '1 2 3 4 5')
s.set_pop('s1')
operações relacionadas com Hash
import redis
class Hash_Redis(object):
def __init__(self):
self.r = redis.StrictRedis(host='127.0.0.1', port=6379)
# 设置值
def hash_hset(self, keys, items,values):
result = self.r.hset(keys, items, values)
return result
# 取值
def hash_hgetall(self, keys):
result = self.r.hgetall(keys)
return result
# 判断是否存在 存在返回1 不存在返回0
def hash_hexists(self, keys, values):
res = self.r.hexists(keys, values)
print(res)
if __name__ == '__main__':
h = Hash_Redis()
h.hash_hset('h1', 'id', '1')
5, a configuração Redis mestre-escravo
- ⼀ um mestre pode ter mais do que um escravo, uma garantia escravo ⼀ separada pode ter mais do que um escravo, ele continua, formando uma forte arquitetura de cluster servidor ampliada multi-nível
- mestre usado para gravar dados, escravo para ler os dados, as estatísticas: local taxa de alfabetização é de 10: 1
- A configuração pode ser implementada por separado ler e escrever a partir do primário
- mestre e escravo é um exemplo redis (serviço redis)
configuração master-slave
configurar o mestre
Modificar Redis arquivo etc / / redis.conf
ligam 0.0.0.0 ou mudança para um IP nativa
configuração de
Copie etc / Redis / redis.conf arquivo
cp redis.conf slave.conf
Modificar Redis / slave.conf arquivo
vim slave.conf
ligam-se 192.168.154.131 (hospedeiro PI)
slaveof 192.168.154.131 (IP hospedeiro) 6379 (porta do host)
Porto 6378 (porta escravo)
Ligue o serviço de acolhimento
src / Redis-servidor slave.conf
src / Redis-cli -h 0.0.0.0 -p 6379
Digite a partir do cliente
src / Redis-cli -h 192.168.154.131 -p 6378
