Django 速查表

# 创建并访问项目文件夹
~$  mkdir project_name
~$  cd project_name

# 创建 Python 虚拟环境
~$  python3 -m venv venv

# 激活虚拟环境
~$  source venv/bin/activate

# 如果你想停用虚拟环境
~$  deactivate

# 安装 django (~= 等同于 4.2.*)
~$  pip install django~=4.2.0

# 新建 django 项目 (在 project_name 文件夹内)
~$  django-admin startproject config

# 创建应用 (在 project_name 文件夹内)
~$  python manage.py startapp app_name

Django 使用这些命令为应用中存在的每个模型创建数据库表：

Makemigrations: 在 app_name/migrations 目录下创建一个文件，其中包含要创建的数据库结构。

~$  python manage.py makemigrations

Migrate: 将读取迁移文件并创建实际的数据库和表。

~$  python manage.py migrate

~$  python manage.py createsuperuser

~$  python manage.py runserver  => 例如 http://127.0.0.1:8000

# 创建一个包含所有项目依赖的 requirements 文件
~$  pip freeze > requirements.txt

# 安装项目依赖 (如果 requirements 文件存在)
~$  pip install -r requirements.txt

# Django shell (直接运行项目代码)
~$ python manage.py shell

# 在 shell 中运行的代码示例:
 >>> from app_name.models import User
 >>> user1 = User.objects.first()

# 为生产环境准备静态文件夹
~$ python manage.py collectstatic

# 从应用 blog 中获取所有数据并导出为 json
~$ python manage.py dumpdata blog > myapp.json

# 将 json 文件中的所有数据导入到应用数据表中
~$ python manage.py loaddata myapp.json

# 创建或更新翻译的消息文件，运行此命令
~$ django-admin makemessages -l de
# 更新消息文件
~$ django-admin compilemessages

关键字	描述
contains	包含短语
icontains	与 contains 相同，但不区分大小写
date	匹配日期
day	匹配日期 (月份中的天，1-31) (用于日期)
endswith	以...结尾
iendswith	与 endswith 相同，但不区分大小写
exact	精确匹配
iexact	与 exact 相同，但不区分大小写
in	匹配其中一个值
isnull	匹配 NULL 值
gt	大于
gte	大于或等于
hour	匹配小时 (用于日期时间)
lt	小于
lte	小于或等于
minute	匹配分钟 (用于日期时间)
month	匹配月份 (用于日期)
quarter	匹配年份的季度 (1-4) (用于日期)
range	匹配范围
regex	匹配正则表达式
iregex	与 regex 相同，但不区分大小写
second	匹配秒 (用于日期时间)
startswith	以...开头
istartswith	与 startswith 相同，但不区分大小写
time	匹配时间 (用于日期时间)
week	匹配周数 (1-53) (用于日期)
week_day	匹配星期几 (1-7) 1 是星期日
iso_week_day	匹配 ISO 8601 星期几 (1-7) 1 是星期一
year	匹配年份 (用于日期)
iso_year	匹配 ISO 8601 年份 (用于日期)

Django 路由信息存储在 project_folder/urls.py 文件中

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
        path('admin/', admin.site.urls), # 预先创建的管理 URL 路由
        path('', include('app_name.urls')) # 包含您的应用 URL
]

include() 方法允许链接到在您的应用文件夹中创建的另一个 urls.py 文件 (app_name/urls.py)

from django.urls import path
from app_name import views

urlpatterns = [
        path('posts', views.index, name='posts.index'),
        path('posts/create/', views.create, name='posts.create'),
        path('posts/<int:id>/', views.show, name='posts.show'),
        path('posts/<int:id>/edit/', views.edit, name='posts.edit'),
        path('posts/<int:id>/delete/', views.delete, name='posts.delete'),
        path('posts/<int:id>/<int:state>/', views.status, name='posts.status'), # 两个参数
]

模板存储在 project_folder/templates 或您的 app_folder/templates/app_name/*.html 中

<!-- 继承自另一个模板 -->
<!-- 可以为不同的模板使用 HTML 的相同部分 -->
{% extends 'base.html' %}

<!-- 父模板中定义的一部分，在子模板中被替换 -->
{% block contents %} {% endblock contents %}

<!-- 包含模板 -->
{% include 'partials/header.html' %}
<!-- 包含带有一个或多个参数的模板 -->
{% include 'body.html' with key1=value1 key2=value2 %}

<!-- 模板中的 If 语句 -->
{% if user.username = 'Mike' %}
你好管理员
{% elif user.username = 'john' %}
你好 John Doe
{% else %}
你好用户
{% endif %}

<!-- 模板中的 for 循环 -->
{% for product in products %}
行: {{ forloop.counter }} # 起始索引 1 {{ forloop.counter0 }} # 起始索引 0
产品名称是 {{ product.name }}

产品价格是 {{ product.price }}

    {% endfor %}

    <!-- 访问模板中的变量 -->
    {{ var_name }}

    <!-- 模板变量格式化 -->
    {{ title | lower }} {{ blog.post | truncatewords:50 }} {{ order.date | date:"D M Y" }} {{ list_items | slice:":3" }} {{
    total | default:"nil" }}

    <!-- 当前路径 (例如 posts/1/show) -->
    {{ request.path }}

    <!-- 按名称生成带参数的 URL -->
    {% url 'posts.delete' id=post.id %}

    <!-- 在模板中使用 static： -->
    {% load static %} {% static 'css/main.css' %}

    <!-- 在模板中定义变量 -->
    {% with name="World" %}
    
        
你好 {{ name }}!
    
    {% endwith %}

    <!-- 模板翻译文本 -->
    {% load i18n %}
    <title>{% trans "This is the title." %}</title> <!-- 这是标题。 -->
    <!-- 在模板中使用变量翻译 -->
    <title>{% trans object.title %}</title>

    <!-- 在模板中定义列表 -->
    <input type="number" <!--swig31-->>

    <!-- 在 Django 模板中安全地将数据传递给 JavaScript： -->
    <!--+ 对于简单值使用 data 属性 -->
    <script data-username="{{ username }}">
        const data = document.currentScript.dataset;
        const username = data.username;
    </script>

    <!-- + 单独的脚本文件：对于单独的脚本文件可以使用 document.currentScript -->
    <script src="{% static 'index.js' %}" data-username="{{ username }}"></script>

    <!-- + 大小写转换 -->
    <script src="{% static 'index.js' %}" data-full-name="{{ full_name }}"></script>
    <!--  在 JavaScript 中以 fullName 读取： -->
    <script>
        const data = document.currentScript.dataset;
        const fullName = data.fullName;
    </script>

    <!-- + 非字符串类型 -->
    <script src="{% static 'index.js' %}" data-follower-count="{{ follower_count }}"></script>

    <!--  使用 parseInt() 将此值从字符串转换： -->
    <script>
        const data = document.currentScript.dataset;
        const followerCount = parseInt(data.followerCount, 10);
    </script>

    <!-- + 没有限制：一个 <script> 可以有任意数量的 data 属性： -->
    <script
        src="{% static 'index.js' %}"
        defer
        data-settings-url="{% url 'settings' %}"
        data-configuration-url="{% url 'configuration' %}"
        data-options-url="{% url 'options' %}"
        data-preferences-url="{% url 'preferences' %}"
        data-setup-url="{% url 'setup' %}"
    ></script>
</p>

例如，如果您的自定义标签/过滤器位于名为 basetags.py 的文件中，您的应用布局可能如下所示：

app_name/
└─── templatetags/
         └─── basetags.py
         __init__.py
         models.py
         views.py

• 在您的模板中，您将使用以下内容：

{% load basetags %}

• 该模块必须包含一个名为 register 的模块级变量，它是一个 template.Library 实例，所有标签和过滤器都在其中注册。因此，在模块的顶部附近，放置以下内容：

自定义过滤器是接受一个或两个参数的 Python 函数：变量的值 (输入) – 不一定是字符串。参数的值 – 这可以有一个默认值，或者完全省略。例如，在过滤器 {{ var|foo:"bar" }} 中，过滤器 foo 将传递变量 var 和参数 "bar"。

Library.filter() 方法接受两个参数：过滤器的名称 – 一个字符串。编译函数 – 一个 Python 函数 (而不是作为字符串的函数名称)。您可以改用 register.filter() 作为装饰器：

# basetags.py
from django import template

register = template.Library()

@register.filter(name="cut")
def cut(value, arg):
        """从给定字符串中移除所有 arg 的值"""
        return value.replace(arg, "")

# 大多数过滤器不接受参数。在这种情况下，请从函数中省略参数
@register.filter()
def lower(value): # 只有一个参数。
        """将字符串转换为全小写"""
        return value.lower()


@register.simple_tag
def to_class_name(object):
        return str(object.__class__.__name__)

# 模板
# 以下是如何在模板中使用该过滤器的示例：
<!--swig18-->

# 将 simple tag 的结果放入变量中
<!--swig56-->
<p>模型类名: <!--swig19--></p>

模型管理器允许模型数据库的读写操作

# 一行创建并保存
Article.objects.create(name='Item 1', price=19.95)

# 读取所有
Article.objects.all()

# 创建
user = User.objects.first()
article = Article(user=user, name='Item 1', price=19.95)

# 保存
article.save()

# 读取一个
Article.objects.get(id=1)

# Select Related (避免 n+1 查询)
posts = Post.objects.select_related('user', 'category').all()

# 读取或渲染 404 未找到页面
from django.shortcuts import get_object_or_404
article = get_object_or_404(Article, id=512)

# 过滤
Article.objects.filter(model='dyson', name__icontains='dyson') # __icontains 不区分大小写包含
Article.objects.filter(year__gt=2016) # __gt = 大于
Article.objects.filter(year__lt=2001) # __lt = 小于

# 根据关系子模型字段过滤
Article.objects.get(user__username='mike')

# 排序
Article.objects.order_by('name')     # 升序
Article.objects.order_by('-name')   # 降序

# 切片返回第一个
Article.objects.all().order_by('name')[0]

# 切片返回最后一个
Article.objects.all().order_by('-name')[0]

# 切片限制/偏移
Article.objects.all().order_by('name')[1:10] # 原文是 1..10，Python 切片语法是 [1:10]

# 更新
article = Article.objects.first()
article.name = 'new name'
article.save()

# 一行更新
Article.objects.filter(id=4).update(name='new name')

# 删除
article = Article.objects.first()
article.delete()

# 一行删除
Article.objects.get(id=1).delete() # 原文是 article.objects.get(id=1).delete()，应该是 Article.objects.get(id=1).delete()

# 删除所有
Article.objects.all().delete()

# 设置外键字段值
model1 = Model(name='dyson')
article.model = model1

# 获取外键值
article1.model.name
model1.article_set.all()

# 添加多对多关系
article1.tags.add(tag1)
article1.tags.all()
tag1.article_set.all() # 原文是 tag1.articles_set.all()，Django 默认反向名称是 modelname_set

# forms.py
from django.core.exceptions import ValidationError

# 字段验证
def clean_first_name(self):
        data = self.cleaned_data['first_name']
        if data == 'Mike': # 原文 data = 'Mike'，应为 data == 'Mike'
                raise ValidationError('Your name must not be Mike') # 您的名字不能是 Mike
        return data

# 表单验证
def clean(self):
        first_name = self.cleaned_data['first_name']
        last_name = self.cleaned_data['last_name']
        if first_name + last_name == 'MikeTaylor': # 原文 first_name + last_name = 'MikeTaylor'，应为 ==
                raise ValidationError('Your name must not be Mike Taylor') # 您的名字不能是 Mike Taylor

用户模型 (预创建)

# 获取对 Django 预创建用户模型的引用
from django.contrib.auth import get_user_model

User = get_user_model()

# 或者如果您想自定义用户模型
from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
        # 添加自定义字段和方法
        pass # 原文没有 pass，添加以使其成为有效的类定义

# 要让 Django 使用该模型，请转到 settings.py 并添加：AUTH_USER_MODEL = 'app_name.User'

# LoginView 已由 Django 预创建
from django.contrib.auth.views import LoginView

# 添加一个 URL 以访问该视图
path('login/', LoginView.as_view(), name='login')

# 默认情况下，LoginView 将尝试打开名为 'registration/login.html' 的模板并向其发送登录表单。

<!-- 在 registration/login.html 下创建模板 -->
{% extends "base.html" %} {% block content %}
<form method="post">
    {% csrf_token %} {{ form }}
    <button type="submit">登录</button>
</form>
{% endblock content %}

<!-- 当用户单击“登录”按钮时，LoginView 将尝试使用表单中的用户名和密码对用户进行身份验证 -->

<!-- 如果成功，它将登录用户并重定向到 settings.py 中指定的 LOGIN_REDIRECT_URL -->

#认证：LogoutView

# LogoutView 已由 Django 预创建
from django.contrib.auth.views import LogoutView

# 添加一个 URL 以访问该视图
path('logout/', LogoutView.as_view(), name='logout') # 原文 LoginView.as_view()，应为 LogoutView.as_view()

# 在模板中包含一个链接
<a href="{% url 'logout' %}">登出</a>

# 链接执行后，用户将被登出并重定向到 settings.py 中指定的 LOGOUT_REDIRECT_URL

#认证：SignupView

# 创建一个 SignupView (该视图默认未创建)
# 导入 Django 预创建的注册表单
from django.contrib.auth.forms import UserCreationForm
from django.views.generic import CreateView
from django.urls import reverse # 导入 reverse

class SignupView(CreateView):
        template_name = 'registration/signup.html'
        form_class = UserCreationForm

        def get_success_url(self):
                return reverse("login")

<!-- 创建模板：registration/signup.html -->
{% extends "base.html" %} {% block content %}
<form method="post">
    {% csrf_token %} {{ form }}
    <button type="submit">注册</button>
</form>
{% endblock content %}

# 添加一个 URL 以访问该视图
from posts.views import SignupView # 假设 SignupView 在 posts.views 中

path('signup/', SignupView.as_view(), name='signup')

# 可选：自定义 UserCreationForm
# (forms.py)
from django.contrib.auth import get_user_model
from django.contrib.auth.forms import UserCreationForm, UsernameField # 导入 UsernameField

User = get_user_model()
class CustomUserCreationForm(UserCreationForm): # 原文 UserCreattionForm，应为 UserCreationForm
        class Meta:
                model = User
                fields = ['username']
                field_classes = {'username': UsernameField} # 原文 fields_classes，应为 field_classes

#可选的预创建认证路由

# urls.py
urlpatterns += [path('', include('django.contrib.auth.urls'))] # 原文 urlpatterns += path(...)
# /login, /logout, /signup, 等。

#模板认证助手

<!-- 认证链接 -->
<a href="{% url 'login' %}">登录</a>
<a href="{% url 'signup' %}">注册</a>
<a href="{% url 'logout' %}">登出</a>

<!-- 检查用户是否登录 -->
{% if request.user.is_authenticated %} 已登录为: {{ request.user.username }} {% endif %}

#授权：LoginRequiredMixin 和 login_required

from django.contrib.auth.mixins import LoginRequiredMixin
from django.views import generic # 假设 generic 被使用

# 仅限已认证用户访问视图 (views.py)
class PostsCreateView(LoginRequiredMixin, generic.CreateView):
        ...
        ...


from django.contrib.auth.decorators import login_required

@login_required(login_url='/login')
def search_page(request):
        ...
        ...

#手动认证、登录和登出

from django.contrib.auth import authenticate, login, logout # 导入 logout
from django.shortcuts import redirect, render # 导入 render, redirect

def login_page(request):
        if request.method == "POST":
                username = request.POST.get("username")
                password = request.POST.get("password")
                user = authenticate(request, username=username, password=password)
                if user is not None:
                        login(request, user)
                        return redirect("index") # 假设 "index" 是一个有效的 URL 名称

        return render(request, "registration/login.html", {})


def logout_page(request):
        logout(request)
        return redirect("index") # 假设 "index" 是一个有效的 URL 名称

#用户更改密码

# set_password 会对密码进行哈希处理
user.set_password('raw password')

$ pip install python-decouple

在项目根文件夹中创建一个名为 .env 的文件

SECRET_KEY='your secret key'
ALLOWED_HOSTS='127.0.0.1,localhost,your_domain.com' # ALLOWED_HOSTS 是一个列表，decouple 可以处理
DEBUG=True # 示例
DATABASE_URL='postgres://user:password@host:port/dbname' # 示例

在 settings.py 中更改与安全相关的设置以指向 .env 文件

from decouple import config, Csv

SECRET_KEY = config('SECRET_KEY')
# ALLOWED_HOSTS 应该是一个列表
ALLOWED_HOSTS = config('ALLOWED_HOSTS', cast=Csv())
DEBUG = config('DEBUG', default=False, cast=bool) # 示例
# DATABASE_URL = config('DATABASE_URL') # 示例，如果使用 dj-database-url

Celery 是一个分布式任务队列，可以在主程序之外收集、记录、调度和执行任务。

#步骤 1：使用 pip 安装 Celery

~$ pip install celery redis # 同时安装 redis 依赖，或者 pip install celery[redis]

#步骤 2：在您的项目模块中添加 celery.py 文件

# your_project_name/celery.py (与 settings.py 同级)
import os
from celery import Celery

# 设置 Django 设置模块的默认环境变量。
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project_name.settings')

app = Celery('your_project_name')

# 使用字符串参数，这样 worker 就不必序列化配置对象。
# - namespace='CELERY' 表示所有 Celery 相关的配置键都应该有一个 `CELERY_` 前缀。
app.config_from_object('django.conf:settings', namespace='CELERY')

# 从所有已注册的 Django app configs 中自动发现任务。
app.autodiscover_tasks()

@app.task(bind=True)
def debug_task(self):
        print(f'Request: {self.request!r}')

#步骤 3：将 Celery 应用导入 Django

为确保 Django 启动时加载 Celery 应用，请将以下代码添加到项目模块中 settings.py 文件旁边的 __init__.py 文件中。

# your_project_name/__init__.py
from .celery import app as celery_app

__all__ = ('celery_app',)

#步骤 4：下载并运行 Redis 作为 Celery 的 ‘broker’

~$ redis-server

您可以通过在终端中输入以下内容来测试 Redis 是否正常工作：

~$ redis-cli ping

Redis 应该回复 PONG - 试试看！

#步骤 5：在 Django 项目中添加 Redis 作为依赖项：

~$ pip install redis # 如果步骤1中已安装 celery[redis] 或 redis，则此步骤可省略

#步骤 6：将 Celery 相关配置添加到 Django 设置文件

一旦 Redis 启动，将以下代码添加到您的 settings.py 文件中，并使用 django-celery-results 来存储结果。

~$ pip install django-celery-results

此扩展使您能够使用 Django ORM 存储 Celery 任务结果。
它定义了一个用于存储任务结果的单一模型 (django_celery_results.models.TaskResult)，您可以像查询任何其他 Django 模型一样查询此数据库表。

# settings.py

INSTALLED_APPS = [
                                … ,
                                'django_celery_results',
                                ]

# Celery 配置
CELERY_BROKER_URL = 'redis://localhost:6379/0' # /0 表示 Redis 的第0个数据库
CELERY_RESULT_BACKEND = 'redis://localhost:6379/0' # 也可以使用 'django-db'
CELERY_ACCEPT_CONTENT = ['application/json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TIMEZONE = TIME_ZONE # TIME_ZONE 是 Django settings.py 中已定义的
# 如果使用 django-celery-results 作为结果后端
# CELERY_RESULT_BACKEND = 'django-db'
# CELERY_CACHE_BACKEND = 'django-cache' # 如果使用 Django 缓存作为 Celery 缓存后端

# Django 缓存配置 (如果 CELERY_CACHE_BACKEND = 'django-cache')
# CACHES = {
#     'default': {
#         'BACKEND': 'django_redis.cache.RedisCache', # 使用 django-redis
#         'LOCATION': 'redis://127.0.0.1:6379/1', # 使用不同的 Redis 数据库用于缓存
#         "OPTIONS": {
#             "CLIENT_CLASS": "django_redis.client.DefaultClient",
#         }
#     }
# }
# 如果 CELERY_RESULT_BACKEND = 'django-db'，则不需要 CACHES 配置，除非项目其他部分需要
# 确保运行迁移以创建 django_celery_results 所需的表
# python manage.py migrate django_celery_results

#就是这样！您现在应该能够将 Celery 与 Django 一起使用了

测试 Celery worker 是否准备好接收任务：

~$ celery -A your_project_name worker -l info

最重要的任务是：始终需要运行一个 worker 来执行 celery 任务，如果 Redis 抛出任何错误，例如：

AttributeError: 'str' object has no attribute 'items'

• 解决方案是：您可能需要检查 Celery 和 Redis 的版本兼容性，或者配置序列化问题。

#步骤 1：在您的 Django 应用中添加 tasks.py 文件。

# app_name/tasks.py
from celery import shared_task
# from celery.decorators import task # shared_task 是推荐的方式
from time import sleep
import time # 导入 time 模块

@shared_task(name='my_first_task') # 使用 shared_task 更好，因为它不需要直接访问 celery app 实例
def my_first_task(duration):
        sleep(duration)
        return('第一个任务完成')

@shared_task
def test_func():
        for i in range(10):
                print(i)
                sleep(0.1) # 添加少量延迟以便观察
        return '测试函数结束_OK'

@shared_task
def adding(x, y):
        time.sleep(10) # 确保 time 已导入
        result = x + y
        return result

#步骤 2：将任务分配给 Celery。

您需要将任务分配给 celery。要分配此任务，您需要以不同的方式调用此函数。celery 提供了 delay() 和 apply_async() 方法来调用任务。

# Python 中的普通函数调用
~$ my_first_task() # 这不会通过 Celery 执行

# 通过函数调用将任务添加到 celery
~$ my_first_task.delay()

您可以使用 delay 方法向函数发送参数。要查看 celery 的运行情况，请打开终端的另一个选项卡，然后转到项目目录 (如果您正在使用虚拟环境，请激活它) 并再次运行此命令

~$ celery -A your_project_name worker -l info

# app_name/views.py
from django.http import HttpResponse
from .tasks import my_first_task, test_func, adding # 使用相对导入

def index(request):
        my_first_task.delay(10)
        task_result = adding.delay(x=4, y=5)
        # task_result.id 可以用来稍后查询任务状态或结果
        return HttpResponse(f'响应完成。任务 ID: {task_result.id}')

def test(request):
        test_func.delay()
        return HttpResponse("测试任务已分派")

#然后从您的应用 URL 调用视图

# app_name/urls.py
from django.urls import path
from .views import index, test # 使用相对导入

app_name = 'app_name' # 定义 app_name 以便在模板或重定向中使用命名空间

urlpatterns = [
        path('celery-index/', index, name='celery_index_url'),
        path('celery-test/', test, name='celery_test_url'),
]

#步骤 1：在 Ubuntu 服务器上安装 Supervisor

~$ sudo apt-get update
~$ sudo apt-get install supervisor

#步骤 2：在 Supervisor 中添加 .conf 文件

~$ sudo nano /etc/supervisor/conf.d/your_project_name_celery.conf

your_project_name_celery 可以是任何您喜欢的名称，但最好与您的项目相关。

#步骤 3：在 your_project_name_celery.conf 中添加一些配置

[program:your_project_name_celery]
command=/path/to/your/virtualenv/bin/celery -A your_project_name worker -l INFO
directory=/path/to/your/django_project_directory/
user=your_user # 运行 celery worker 的用户，例如 www-data 或您的部署用户
numprocs=1
autostart=true
autorestart=true
startsecs=10
stopwaitsecs=600
killasgroup=true
stdout_logfile=/path/to/your/django_project_directory/logs/celery_worker.log
stderr_logfile=/path/to/your/django_project_directory/logs/celery_worker_err.log

描述配置文件：

[program:your_project_name_celery]
# 您的 supervisord 程序名称

command=/path/to/your/virtualenv/bin/celery -A your_project_name worker -l INFO
# 如果使用虚拟环境，请设置 celery 程序的完整路径

directory=/path/to/your/django_project_directory/
# 您的 Django 项目目录

user=your_user
# 运行 celery worker 的用户。该用户必须存在。

numprocs=1
# 启动的进程数 (通常为1，除非您了解 Celery 并发模型)

autostart=true
# 如果为 true，则在 supervisord 启动时此程序将自动启动

autorestart=true
# 可以是 false、unexpected 或 true。如果为 false，则进程永远不会自动重启。如果为 unexpected，则当程序以非此进程配置关联的退出代码 (参见 exitcodes) 退出时，进程将重新启动。如果为 true，则当进程退出时，无论其退出代码如何，都将无条件重新启动。

startsecs=10
# 程序启动后需要保持运行的秒数，以认为启动成功

stopwaitsecs=600
# 发送 SIGTERM 后等待进程退出的秒数，之后发送 SIGKILL

killasgroup=true
# 如果为 true，当停止或杀死主进程时，也会杀死其整个进程组

stdout_logfile=/path/to/your/django_project_directory/logs/celery_worker.log
# 将进程标准输出放入此文件

stderr_logfile=/path/to/your/django_project_directory/logs/celery_worker_err.log
# 将进程标准错误输出放入此文件 (如果 redirect_stderr=false)
# redirect_stderr=true # 如果为 true，则将进程的 stderr 输出发送回 supervisord 的 stdout 文件描述符 (在 UNIX shell 术语中，这相当于执行 /the/program 2>&1)。如果使用此选项，则不需要 stderr_logfile。

#步骤 4：通知服务器配置更改

添加新程序后，我们应该运行以下两个命令，以通知服务器重新读取配置文件并应用任何更改。

~$ sudo supervisorctl reread
~$ sudo supervisorctl update

#管理 Supervisor 应用

~$ sudo supervisorctl

您将看到已注册进程的列表。您应该会看到一个名为 your_project_name_celery 的进程，状态为 RUNNING。

your_project_name_celery      RUNNING   pid 6853, uptime 0:22:30
supervisor>

输入 help 获取可用命令列表。

supervisor> help
default commands (type help <topic>):
=====================================
add    exit      open  reload  restart   start   tail
avail  fg        pid   remove  shutdown  status  update
clear  maintail  quit  reread  signal    stop    version

简而言之，我们可以通过将程序名称作为参数传递给相应命令来 start、stop 和 restart 程序。我们还可以使用 tail 命令查看程序输出。完成后，您可以 quit。

supervisor> quit

#步骤 1 — 从 Ubuntu 存储库安装软件包

sudo apt update
sudo apt install python3-venv python3-dev libpq-dev postgresql postgresql-contrib nginx curl

#步骤 2 — 创建 PostgreSQL 数据库和用户

sudo -u postgres psql

• 首先，为您的项目创建一个数据库：

postgres=# CREATE DATABASE myproject;

• 接下来，为我们的项目创建一个数据库用户。确保选择一个安全的密码：

postgres=# CREATE USER myprojectuser WITH PASSWORD 'password';

• 之后，您将修改刚创建的用户的一些连接参数

postgres=# ALTER ROLE myprojectuser SET client_encoding TO 'utf8';
postgres=# ALTER ROLE myprojectuser SET default_transaction_isolation TO 'read committed';
postgres=# ALTER ROLE myprojectuser SET timezone TO 'UTC';

• 现在，您可以授予新用户管理新数据库的权限：

postgres=# GRANT ALL PRIVILEGES ON DATABASE myproject TO myprojectuser;

• 完成后，通过键入以下命令退出 PostgreSQL 提示符：

postgres=# \q

#步骤 3 — 为您的项目创建 Python 虚拟环境

• 在项目目录中，通过键入以下命令创建 Python 虚拟环境：

mkdir ~/myprojectdir
cd ~/myprojectdir

• 在项目目录中，通过键入以下命令创建 Python 虚拟环境：

python3 -m venv myprojectenv

• 在安装项目的 Python 依赖项之前，您需要激活虚拟环境。您可以通过键入以下命令来执行此操作：

source myprojectenv/bin/activate

• 激活虚拟环境后，使用本地 pip 实例安装 Django、Gunicorn 和 psycopg2 PostgreSQL 适配器

(myprojectenv)$ pip install django gunicorn psycopg2-binary

#步骤 4 — 创建和配置新的 Django 项目

• 安装 Python 组件后，您现在可以创建实际的 Django 项目文件。

(myprojectenv)$ django-admin startproject myprojectname ~/myprojectdir # myprojectname 是项目名
# 注意：上面的命令会在 ~/myprojectdir 内部创建一个名为 myprojectname 的目录，
# 并在该目录内创建 manage.py 和另一个 myprojectname 目录 (包含 settings.py 等)。
# 如果希望项目文件直接在 ~/myprojectdir 中，可以使用：
# (myprojectenv)$ django-admin startproject myprojectname .
# (在 cd ~/myprojectdir 之后)

• 对于新创建的项目文件，您应该做的第一件事是调整设置。在文本编辑器中打开设置文件：

(myprojectenv)$ nano ~/myprojectdir/myprojectname/settings.py # 路径取决于上面的 startproject 命令

• 首先找到 ALLOWED_HOSTS 指令。

# ~/myprojectdir/myprojectname/settings.py
ALLOWED_HOSTS = ['your_server_domain_or_IP', 'second_domain_or_IP', '. . .', 'localhost']

• 接下来，找到配置数据库访问的部分。它将以 DATABASES 开头。文件中的配置适用于 SQLite 数据库。

. . .
DATABASES = {
        'default': {
                'ENGINE': 'django.db.backends.postgresql_psycopg2', # 或 'django.db.backends.postgresql'
                'NAME': 'myproject', # 之前创建的数据库名
                'USER': 'myprojectuser', # 之前创建的用户名
                'PASSWORD': 'password', # 用户的密码
                'HOST': 'localhost', # 或 PostgreSQL 服务器的 IP 地址
                'PORT': '', # 默认为 5432，如果不同则指定
        }
}
. . .

• 接下来，移至文件底部并添加一个设置，指示应放置静态文件的位置。

. . .
STATIC_URL = '/static/' # URL 前缀，用于在模板中引用静态文件

# https://docs.djangoproject.com/en/4.0/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

import os
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles') # collectstatic 将收集静态文件到此目录
# MEDIA_URL = '/media/' # 如果使用媒体文件
# MEDIA_ROOT = os.path.join(BASE_DIR, 'mediafiles') # 存储上传的媒体文件
. . .

#步骤 5 — 完成初始项目设置

• 现在，您可以使用管理脚本将初始数据库模式迁移到我们的 PostgreSQL 数据库：

(myprojectenv)$ python ~/myprojectdir/manage.py makemigrations
(myprojectenv)$ python ~/myprojectdir/manage.py migrate

• 通过键入以下命令为项目创建一个管理用户：

(myprojectenv)$ python ~/myprojectdir/manage.py createsuperuser

• 您可以通过键入以下命令将所有静态内容收集到您配置的目录位置：

(myprojectenv)$ python ~/myprojectdir/manage.py collectstatic

#步骤 6 — 测试 Gunicorn 服务项目的能力

(myprojectenv)$ cd ~/myprojectdir
(myprojectenv)$ gunicorn --bind 0.0.0.0:8000 myprojectname.wsgi:application # myprojectname.wsgi

• 您现在已完成 Django 应用程序的配置。您可以通过键入以下命令退出我们的虚拟环境：

(myprojectenv)$ deactivate

#步骤 7 — 为 Gunicorn 创建 systemd Socket 和服务文件

sudo nano /etc/systemd/system/gunicorn.socket

• 在内部，您将创建一个 [Unit] 部分来描述套接字，一个 [Socket] 部分来定义套接字位置，以及一个 [Install] 部分来确保在正确的时间创建套接字：

# /etc/systemd/system/gunicorn.socket
[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

• 完成后保存并关闭文件。
• 接下来，在文本编辑器中使用 sudo 权限为 Gunicorn 创建并打开一个 systemd 服务文件。服务文件名应与套接字文件名匹配，但扩展名除外：

sudo nano /etc/systemd/system/gunicorn.service

# /etc/systemd/system/gunicorn.service
[Unit]
Description=gunicorn daemon
Requires=gunicorn.socket
After=network.target

[Service]
User=sammy # 替换为运行 Gunicorn 的用户
Group=www-data # 替换为适当的组，通常是用户的主组或 www-data
WorkingDirectory=/home/sammy/myprojectdir # 替换为您的项目目录
ExecStart=/home/sammy/myprojectdir/myprojectenv/bin/gunicorn \
                    --access-logfile - \
                    --workers 3 \
                    --bind unix:/run/gunicorn.sock \
                    myprojectname.wsgi:application # 替换为您的项目名.wsgi:application

[Install]
WantedBy=multi-user.target

• 您现在可以启动并启用 Gunicorn 套接字。这将在 /run/gunicorn.sock 创建套接字文件，并在启动时创建。当连接到该套接字时，systemd 将自动启动 gunicorn.service 来处理它

sudo systemctl start gunicorn.socket
sudo systemctl enable gunicorn.socket

#步骤 8 — 检查 Gunicorn 套接字文件

• 检查进程的状态以了解它是否能够启动：

sudo systemctl status gunicorn.socket

• 接下来，检查 /run 目录中是否存在 gunicorn.sock 文件：

file /run/gunicorn.sock

#步骤 9 — 测试套接字激活

sudo systemctl status gunicorn # 此时可能未运行，因为还没有连接

• 要测试套接字激活机制，您可以通过 curl 向套接字发送连接，方法是键入：

curl --unix-socket /run/gunicorn.sock localhost

• 您应该在终端中收到应用程序的 HTML 输出。这表明 Gunicorn 已启动并且能够为您的 Django 应用程序提供服务。您可以通过键入以下命令来验证 Gunicorn 服务是否正在运行：

sudo systemctl status gunicorn

• 检查您的 /etc/systemd/system/gunicorn.service 文件是否有问题。如果您对 /etc/systemd/system/gunicorn.service 文件进行了更改，请重新加载守护程序以重新读取服务定义，并通过键入以下命令重新启动 Gunicorn 进程

sudo systemctl daemon-reload
sudo systemctl restart gunicorn

#步骤 10 — 配置 Nginx 以代理传递到 Gunicorn

• 首先在 Nginx 的 sites-available 目录中创建并打开一个新的服务器块：

sudo nano /etc/nginx/sites-available/myproject # myproject 是配置文件名

server {
        listen 80;
        server_name your_server_domain_or_IP; # 替换为您的域名或 IP

        location = /favicon.ico { access_log off; log_not_found off; }
        location /static/ {
                alias /home/sammy/myprojectdir/staticfiles/; # 替换为您的 STATIC_ROOT 路径
        }

        location /media/ { # 如果使用媒体文件
                alias /home/sammy/myprojectdir/mediafiles/; # 替换为您的 MEDIA_ROOT 路径
        }

        location / {
                include proxy_params;
                proxy_pass http://unix:/run/gunicorn.sock;
        }
}

• 完成后保存并关闭文件。现在，您可以通过将其链接到 sites-enabled 目录来启用该文件：

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled/

• 通过键入以下命令测试 Nginx 配置是否存在语法错误：

sudo nginx -t

• 如果没有报告错误，请通过键入以下命令重新启动 Nginx：

sudo systemctl restart nginx

• 您需要为端口 80 上的正常流量打开防火墙

sudo ufw allow 'Nginx Full'

您现在应该能够转到服务器的域或 IP 地址来查看您的应用程序。

#步骤 11 — Nginx 和 Gunicorn 故障排除

• Nginx 显示默认页面而不是 Django 应用程序

sudo tail -F /var/log/nginx/error.log

• Django 显示：“could not connect to server: Connection refused”（无法连接到服务器：连接被拒绝）

sudo systemctl status postgresql

• 如果它没有运行，您可以通过键入以下命令启动它并使其在启动时自动启动 (如果尚未配置为这样做)：

sudo systemctl start postgresql
sudo systemctl enable postgresql

如果您更改 Gunicorn 套接字或服务文件，请重新加载守护程序并通过键入以下命令重新启动进程：

sudo systemctl daemon-reload
sudo systemctl restart gunicorn.socket gunicorn.service

如果您更改 Nginx 服务器块配置，请测试配置然后通过键入以下命令重新启动 Nginx：

sudo nginx -t && sudo systemctl restart nginx