Django框架项目——redis操作、Celery

1-redis操作

redis介绍

redis安装

"""
1、官网下载：安装包或是绿色面安装
2、安装并配置环境变量
"""

redis VS mysql

"""
redis: 内存数据库(读写快)、非关系型(操作数据方便、数据固定)
mysql: 硬盘数据库(数据持久化)、关系型(操作数据间关系、可以不同组合)

大量访问的临时数据，才有redis数据库更优
"""

redis VS memcache

"""
redis: 操作字符串、列表、字典、无序集合、有序集合 | 支持数据持久化(数据丢失可以找回(默认持久化，主动持久化save)、可以将数据同步给mysql) | 高并发支持
memcache: 操作字符串 | 不支持数据持久化 | 并发量小
"""

Redis操作

启动服务

"""
前提：前往一个方便管理redis持久化文件的逻辑再启动服务：dump.rdb
1）前台启动服务
>: redis-server

2）后台启动服务
>: redis-server --service-start
注）Linux系统后台启动（或是修改配置文件，建议采用方式）
>: redis-server &

3）配置文件启动前台服务
>: redis-server 配置文件的绝对路径

4）配置文件启动后台服务
注）windows系统默认按Redis安装包下的redis.windows-service.conf配置文件启动
>: redis-server --service-start
注）Linux系统可以完全自定义配置文件(redis.conf)后台启动
>: redis-server 配置文件的绝对路径 &
"""


"""
windows系统
1）前台启动
	i）打开终端切换到redis安装目录
	>: cd C:\Apps\Redis
	
	ii）启动服务
	>: redis-server redis.windows.conf

2）后台启动
	i）打开终端切换到redis安装目录
	>: cd C:\Apps\Redis
	
	ii）启动服务（后面的配置文件可以省略）
	>: redis-server --service-start redis.windows-service.conf
"""

密码管理

"""
1）提倡在配置文件中配置，采用配置文件启动
requirepass 密码

2）当服务启动后，并且连入数据库（redis数据库不能轻易重启），可以再改当前服务的密码(服务重启，密码重置)
config set requirepass 新密码

3）已连入数据库，可以查看当前数据库服务密码
config get requirepass
"""

连接数据库

"""
1）默认连接：-h默认127.0.0.1，-p默认6379，-n默认0，-a默认无
>: redis-cli

2）完整连接：
>: redis-cli -h ip地址 -p 端口号 -n 数据库编号 -a 密码

3）先连接，后输入密码
>: redis-cli -h ip地址 -p 端口号 -n 数据库编号
>: auth 密码
"""

切换数据库

"""
1）在连入数据库后执行
>: select 数据库编号
"""

关闭服务

"""
1）先连接数据库，再关闭redis服务
>: redis-cli -h ip地址 -p 端口号 -n 数据库编号 -a 密码
>: shutdown

2）直接连接数据库并关闭redis服务
>: redis-cli -h ip地址 -p 端口号 -n 数据库编号 -a 密码 shutdown
"""

清空redis数据库

"""
1）连接数据库执行
>: flushall
"""

数据持久化

"""
1）配置文件默认配置
save 900 1  # 超过900秒有1个键值对操作，会自动调用save完成数据持久化
save 300 10  # 超过300秒有10个键值对操作，会自动调用save完成数据持久化
save 60 10000  # 超过60秒有10000个键值对操作，会自动调用save完成数据持久化

2）安全机制
# 当redis服务不可控宕机，会默认调用一下save完成数据持久化（如果数据量过大，也可能存在部分数据丢失）

3）主动持久化
>: save  # 连入数据库时，主动调用save完成数据持久化

注：数据持久化默认保存文件 dump.rdb，保存路径默认为启动redis服务的当前路径
"""

redis相关配置

"""
1）绑定的ip地址，多个ip用空格隔开
bind 127.0.0.1

2）端口，默认6379，一般不做修改
port 6379

3）是否以守护进程启动，默认为no，一般改为yes代表后台启动（windows系统不支持）
daemonize no

4）定义日志级别，默认值为notice，有如下4种取值：
	debug（记录大量日志信息，适用于开发、测试阶段）
	verbose（较多日志信息）
	notice（适量日志信息，使用于生产环境）
	warning（仅有部分重要、关键信息才会被记录）
loglevel notice

5）配置日志文件保持地址，默认打印在命令行终端的窗口上
	如果填写 "./redis.log" 就会在启动redis服务的终端所在目录下，用redis.log记录redis日志
logfile ""

eg）终端首先切断到log文件夹所在目录(一般就可以采用redis的安装目录，也可以自定义)，再启动reids服务
logfile "./log/redis.log"

6）数据库个数，默认是16个，没特殊情况，不建议修改
databases 16

7）数据持久化
save 900 1  # 超过900秒有1个键值对操作，会自动调用save完成数据持久化
save 300 10  # 超过300秒有10个键值对操作，会自动调用save完成数据持久化
save 60 10000  # 超过60秒有10000个键值对操作，会自动调用save完成数据持久化

8）数据库持久化到硬盘失败，redis会立即停止接收用户数据，让用户知道redis持久化异常，避免数据灾难发生(重启redis即可)，默认为yes，不能做修改
stop-writes-on-bgsave-error yes

9）消耗cpu来压缩数据进行持久化，数据量小，但会消耗cpu性能，根据实际情况可以做调整
rdbcompression yes

10）增持cpu 10%性能销毁来完成持久化数据的校验，可以取消掉
rdbchecksum yes

11）持久化存储的文件名称
dbfilename dump.rdb

12）持久化存储文件的路径，默认是启动服务的终端所在目录
dir ./

13）reids数据库密码
requirepass 密码
"""

Redis数据类型

"""
数据操作：字符串、列表、哈希(字典)、无序集合、有序(排序)集合
	有序集合：游戏排行榜
	
字符串：
	set key value
	get key
	mset k1 v1 k2 v2 ...
	mget k1 k2 ...
	setex key exp value
	incrby key increment
	
列表：
	rpush key value1 value2 ...
	lpush key value1 value2 ...
	lrange key bindex eindex
	lindex key index
	lpop key | rpop key
	linsert key before|after old_value new_value
	
哈希：
	hset key field value
	hget key field
	hmset key field1 value1 field2 value2 ...
	hmget key field1 field2
	hkeys key
	hvals key
	hdel key field
	
集合：
	sadd key member1 member2 ...
	sdiff key1 key2 ...
	sdiffstore newkey key1 key2 ...
	sinter key1 key2 ...
	sunion key1 key2 ...
	smembers key
	spop key
	
有序集合：
	zadd key grade1 member1 grade2 member2 ...
	zincrby key grade member
	zrange key start end
	zrevrange key start end
"""

python使用redis

依赖

>: pip3 install redis

直接使用

import redis
# decode_responses=True得到的结果会自动解码（不是二进制数据）
r = redis.Redis(host='127.0.0.1', port=6379, db=1, password=None, decode_responses=True)

连接池使用

import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379, db=1, max_connections=100, password=None, decode_responses=True)
r = redis.Redis(connection_pool=pool)

缓存使用：要额外安装 django-redis

# 1.将缓存存储位置配置到redis中：settings.py
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/0",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100},
            "DECODE_RESPONSES": True,
            "PASSWORD": "",
        }
    }
}

# 2.操作cache模块直接操作缓存：views.py
from django.core.cache import cache  # 结合配置文件实现插拔式
# 存放token，可以直接设置过期时间
cache.set('token', 'header.payload.signature', 300)
# 取出token
token = cache.get('token')

Celery

官方

Celery 官网：http://www.celeryproject.org/
Celery 官方文档英文版：http://docs.celeryproject.org/en/latest/index.html
Celery 官方文档中文版：http://docs.jinkan.org/docs/celery/
Celery是一个简单、灵活且可靠的，处理大量消息的分布式系统
专注于实时处理的异步任务队列
同时也支持任务调度
注意：

Celery is a project with minimal funding, so we don’t support Microsoft Windows. Please don’t open any issues related to that platform.

Celery异步任务框架

"""
1）可以不依赖任何服务器，通过自身命令，启动服务(内部支持socket)
2）celery服务为为其他项目服务提供异步解决任务需求的
注：会有两个服务同时运行，一个是项目服务，一个是celery服务，项目服务将需要异步处理的任务交给celery服务，celery就会在需要时异步完成项目的需求

人是一个独立运行的服务 | 医院也是一个独立运行的服务
	正常情况下，人可以完成所有健康情况的动作，不需要医院的参与；但当人生病时，就会被医院接收，解决人生病问题
	人生病的处理方案交给医院来解决，所有人不生病时，医院独立运行，人生病时，医院就来解决人生病的需求
"""

Celery架构

Celery的架构由三部分组成，消息中间件（message broker）、任务执行单元（worker）和 任务执行结果存储（task result store）组成。

消息中间件

Celery本身不提供消息服务，但是可以方便的和第三方提供的消息中间件集成。包括，RabbitMQ, Redis等等

任务执行单元

Worker是Celery提供的任务执行的单元，worker并发的运行在分布式的系统节点中。

任务结果存储

Task result store用来存储Worker执行的任务的结果，Celery支持以不同方式存储任务的结果，包括AMQP, redis等

使用场景

异步执行：解决耗时任务,将耗时操作任务提交给Celery去异步执行，比如发送短信/邮件、消息推送、音视频处理等等
延迟执行：解决延迟任务
定时执行：解决周期(周期)任务,比如每天数据统计

Celery的安装配置

pip install celery
消息中间件：RabbitMQ/Redis
app=Celery(‘任务名’, broker=’xxx’, backend=’xxx’)

两种celery任务结构：提倡用包管理，结构更清晰

# 如果 Celery对象:Celery(...) 是放在一个模块下的
# 1）终端切换到该模块所在文件夹位置：scripts
# 2）执行启动worker的命令：celery worker -A 模块名 -l info -P eventlet
# 注：windows系统需要eventlet支持，Linux与MacOS直接执行：celery worker -A 模块名 -l info
# 注：模块名随意


# 如果 Celery对象:Celery(...) 是放在一个包下的
# 1）必须在这个包下建一个celery.py的文件，将Celery(...)产生对象的语句放在该文件中
# 2）执行启动worker的命令：celery worker -A 包名 -l info -P eventlet
# 注：windows系统需要eventlet支持，Linux与MacOS直接执行：celery worker -A 模块名 -l info
# 注：包名随意

Celery执行异步任务

基本结构

# 创建py文件：celery_app_task.py
import celery
import time
# broker='redis://127.0.0.1:6379/2' 不加密码
backend='redis://:123456@127.0.0.1:6379/1'
broker='redis://:123456@127.0.0.1:6379/2'
cel=celery.Celery('test',backend=backend,broker=broker)
@cel.task
def add(x,y):
    return x+y

包架构封装（多任务结构）

project
    ├── celery_task  	# celery包
    │   ├── __init__.py # 包文件
    │   ├── celery.py   # celery连接和配置相关文件，且名字必须叫celery.py
    │   └── tasks.py    # 所有任务函数
    ├── add_task.py  	# 添加任务
    └── get_result.py   # 获取结果

基本使用

celery.py

# 1）创建app + 任务

# 2）启动celery(app)服务：
# 非windows
# 命令：celery worker -A celery_task -l info
# windows：
# pip3 install eventlet
# celery worker -A celery_task -l info -P eventlet

# 3）添加任务：手动添加，要自定义添加任务的脚本，右键执行脚本

# 4）获取结果：手动获取，要自定义获取任务的脚本，右键执行脚本


from celery import Celery
broker = 'redis://127.0.0.1:6379/1'
backend = 'redis://127.0.0.1:6379/2'
app = Celery(broker=broker, backend=backend, include=['celery_task.tasks'])

tasks.py

from .celery import app
import time
@app.task
def add(n, m):
    print(n)
    print(m)
    time.sleep(10)
    print('n+m的结果：%s' % (n + m))
    return n + m

@app.task
def low(n, m):
    print(n)
    print(m)
    print('n-m的结果：%s' % (n - m))
    return n - m

add_task.py

from celery_task import tasks

# 添加立即执行任务
t1 = tasks.add.delay(10, 20)
t2 = tasks.low.delay(100, 50)
print(t1.id)


# 添加延迟任务
from datetime import datetime, timedelta
eta=datetime.utcnow() + timedelta(seconds=10)
tasks.low.apply_async(args=(200, 50), eta=eta)

get_result.py

from celery_task.celery import app

from celery.result import AsyncResult

id = '21325a40-9d32-44b5-a701-9a31cc3c74b5'
if __name__ == '__main__':
    async = AsyncResult(id=id, app=app)
    if async.successful():
        result = async.get()
        print(result)
    elif async.failed():
        print('任务失败')
    elif async.status == 'PENDING':
        print('任务等待中被执行')
    elif async.status == 'RETRY':
        print('任务异常后正在重试')
    elif async.status == 'STARTED':
        print('任务已经开始被执行')

高级使用

celery.py

# 1）创建app + 任务

# 2）启动celery(app)服务：
# 非windows
# 命令：celery worker -A celery_task -l info
# windows：
# pip3 install eventlet
# celery worker -A celery_task -l info -P eventlet

# 3）添加任务：自动添加任务，所以要启动一个添加任务的服务
# 命令：celery beat -A celery_task -l info

# 4）获取结果


from celery import Celery

broker = 'redis://127.0.0.1:6379/1'
backend = 'redis://127.0.0.1:6379/2'
app = Celery(broker=broker, backend=backend, include=['celery_task.tasks'])


# 时区
app.conf.timezone = 'Asia/Shanghai'
# 是否使用UTC
app.conf.enable_utc = False

# 任务的定时配置
from datetime import timedelta
from celery.schedules import crontab
app.conf.beat_schedule = {
    'low-task': {
        'task': 'celery_task.tasks.low',
        'schedule': timedelta(seconds=3),
        # 'schedule': crontab(hour=8, day_of_week=1),  # 每周一早八点
        'args': (300, 150),
    }
}

tasks.py

from .celery import app

import time
@app.task
def add(n, m):
    print(n)
    print(m)
    time.sleep(10)
    print('n+m的结果：%s' % (n + m))
    return n + m


@app.task
def low(n, m):
    print(n)
    print(m)
    print('n-m的结果：%s' % (n - m))
    return n - m

get_result.py

from celery_task.celery import app

from celery.result import AsyncResult

id = '21325a40-9d32-44b5-a701-9a31cc3c74b5'
if __name__ == '__main__':
    async = AsyncResult(id=id, app=app)
    if async.successful():
        result = async.get()
        print(result)
    elif async.failed():
        print('任务失败')
    elif async.status == 'PENDING':
        print('任务等待中被执行')
    elif async.status == 'RETRY':
        print('任务异常后正在重试')
    elif async.status == 'STARTED':
        print('任务已经开始被执行')

django中使用

celery.py

"""
celery框架django项目工作流程
1）加载django配置环境
2）创建Celery框架对象app，配置broker和backend，得到的app就是worker
3）给worker对应的app添加可处理的任务函数，用include配置给worker的app
4）完成提供的任务的定时配置app.conf.beat_schedule
5）启动celery服务，运行worker，执行任务
6）启动beat服务，运行beat，添加任务

重点：由于采用了django的反射机制，使用celery.py所在的celery_task包必须放置项目的根目录下
"""

# 一、加载django配置环境
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "luffyapi.settings.dev")

# 二、加载celery配置环境
from celery import Celery
# broker
broker = 'redis://127.0.0.1:6379/0'
# backend
backend = 'redis://127.0.0.1:6379/1'
# worker
app = Celery(broker=broker, backend=backend, include=['celery_task.tasks'])


# 时区
app.conf.timezone = 'Asia/Shanghai'
# 是否使用UTC
app.conf.enable_utc = False

# 任务的定时配置
from datetime import timedelta
from celery.schedules import crontab
app.conf.beat_schedule = {
    'update-banner-list': {
        'task': 'celery_task.tasks.update_banner_list',
        'schedule': timedelta(seconds=10),
        'args': (),
    }
}

tasks.py

from .celery import app

from django.core.cache import cache
from home import models, serializers
from django.conf import settings
@app.task
def update_banner_list():
    queryset = models.Banner.objects.filter(is_delete=False, is_show=True).order_by('-orders')[:settings.BANNER_COUNT]
    banner_list = serializers.BannerSerializer(queryset, many=True).data
    # 拿不到request对象，所以头像的连接base_url要自己组装
    for banner in banner_list:
        banner['image'] = 'http://127.0.0.1:8000%s' % banner['image']

    cache.set('banner_list', banner_list, 86400)
    return True