在 AWS Lightsail 上部署 Django 应用程序：Docker、Docker Compose、PostgreSQL、Nginx 和 Github 操作

那么，您已经编写了 Django 应用程序并准备部署它了吗？

尽管已经有像 Heroku 这样的现有解决方案来帮助您轻松快速地部署应用程序，但对于开发人员来说，了解如何在私有服务器上部署应用程序总是有益的。

今天，我们将学习如何在 AWS Lightsail 上部署 Django 应用。*这也适用于其他 VPS 提供商。*

1 - 设置

对于这个项目，我们将使用一个已经配置好的 Django 应用程序。它是为这篇关于FullStack React 和 Django 身份验证的文章而制作的项目：Django REST、TypeScript、Axios、Redux 和 React Router。

您可以直接在此处克隆 repo 。

完成后，请确保创建虚拟环境并运行以下命令。



cd django-auth-react-tutorial 
virtualenv --python=/usr/bin/python3.8 venv
source venv/bin/activate

添加 PostgreSQL

其实项目是在 sqlite3 上运行的，在本地和开发环境中都运行得很好。我们切换到 PostgreSQL 吧。

使用这个，我假设你已经在你的机器上安装了 PostgreSQL，并且服务器正在运行。
如果不是这样，请随时查看此资源来安装服务器。

完成后，让我们创建本教程将使用的数据库。打开 shell psql，输入一些 SQL 命令。

CREATE DATABASE 命令让我们在 PostgreSQL 中创建一个新的数据库。



CREATE DATABASE coredb;

CREATE USER 命令让我们为数据库创建一个用户并设置密码。



CREATE USER core WITH PASSWORD '12345678';

最后，让我们授予新用户访问之前创建的数据库的权限。



GRANT ALL PRIVILEGES ON DATABASE coredb TO core;

现在让我们psycopg2安装pip install psycopg2一个流行的 Python PostgreSQL 数据库适配器。



pip install psycopg2

下一步，让我们设置项目以使用 PostgreSQL 数据库而不是 Sqlite3。



DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

将上面的代码片段更改为：



DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'coredb',
        'USER': 'core',
        'PASSWORD': '12345678',
        'HOST': 'localhost',
        'PORT': 5432,
    }
}

我们做了什么？

ENGINEpostgresql_psycopg2：我们已将数据库引擎改为使用sqlite3。
NAME：是我们为项目创建的数据库的名称。
USER：是我们在创建数据库时创建的数据库用户。
PASSWORD：是我们创建的数据库的密码。

现在，确保 Django 应用程序已连接到 PostgreSQL 数据库。为此，我们将运行migrate负责执行迁移文件中指定的 SQL 命令的命令。



python manage.py migrate

您将得到类似的输出：



  Applying auth.0001_initial... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  ...
  Applying core_user.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying sessions.0001_initial... OK

现在，让我们运行服务器来检查应用程序是否运行良好。



python manage.py runserver

http://127.0.0.1:8000当您在浏览器中点击时，您将看到类似的内容。

太棒了！我们已成功配置 Django 应用以使用 PostgresSQL。

现在，让我们准备部署应用程序。

2 - 准备部署应用程序

在这里，我们将配置应用程序以使用环境变量，同时也配置Docker。

环境变量

保护 API 密钥、密码和密钥等敏感代码免遭窥探至关重要。
最好的方法是什么？使用环境变量。以下是如何在我们的应用程序中执行此操作。

首先，让我们安装一个名为的 python 包django-environ。



pip install django-environ

然后，在settings.py文件中导入它，我们来初始化环境变量。



# CoreRoot/settings.py

import environ

# Initialise environment variables

env = environ.Env()

environ.Env.read_env()

下一步，创建两个文件：

包含.env所有环境变量的文件django-environ
以及一个env.example包含与相同内容的文件.env。

实际上，该.env文件会被 git 忽略。这里的文件代表一个框架，我们可以用它在另一台机器上env.example创建我们的文件。.env

它是可见的，因此请确保不包含敏感信息。



# ./.env
SECRET_KEY=django-insecure-97s)x3c8w8h_qv3t3s7%)#k@dpk2edr0ed_(rq9y(rbb&_!ai%
DEBUG=0
DJANGO_ALLOWED_HOSTS="localhost 127.0.0.1 [::1]"
DB_ENGINE=django.db.backends.postgresql_psycopg2
DB_NAME=coredb
DB_USER=core
DB_PASSWORD=12345678
DB_HOST=localhost
DB_PORT=5432
CORS_ALLOWED_ORIGINS="http://localhost:3000 http://127.0.0.1:3000"

现在，让我们复制内容并粘贴进去.env.example，但一定要删除值。



./env.example
SECRET_KEY=
DEBUG=
DJANGO_ALLOWED_HOSTS=
DB_ENGINE=
DB_NAME=
DB_USER=
DB_PASSWORD=
DB_HOST=
DB_PORT=
CORS_ALLOWED_ORIGINS=

现在，让我们回到设置文件并添加环境变量配置。



# ./CoreRoot/settings.py

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env('SECRET_KEY', default='qkl+xdr8aimpf-&x(mi7)dwt^-q77aji#j*d#02-5usa32r9!y')

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = int(env("DEBUG", default=1))


ALLOWED_HOSTS = env("DJANGO_ALLOWED_HOSTS").split(" ")

DATABASES = {
    'default': {
        'ENGINE': env('DB_ENGINE', default='django.db.backends.postgresql_psycopg2'),
        'NAME': env('DB_NAME', default='coredb'),
        'USER': env('DB_USER', default='core'),
        'PASSWORD': env('DB_PASSWORD', default='12345678'),
        'HOST': env('DB_HOST', default='localhost'),
        'PORT': env('DB_PORT', default='5432'),
    }
}

CORS_ALLOWED_ORIGINS = env("CORS_ALLOWED_ORIGINS").split(" ")

测试

在应用程序中进行测试是确保 Django 服务器可维护性和可靠性的首要保证。
我们将进行测试，以确保在正式部署之前一切顺利。

让我们为登录和刷新端点编写测试。
我们还将向中添加一个测试UserViewSet。
首先，test_runner.py在CoreRoot目录中创建一个名为的文件。

这里的目标是重写DiscoverRunner，以便在测试数据库中加载我们的自定义装置。



# ./CoreRoot/test_runner.py
from importlib import import_module

from django.conf import settings
from django.db import connections
from django.test.runner import DiscoverRunner


class CoreTestRunner(DiscoverRunner):
    def setup_test_environment(self, **kwargs):
        """We set the TESTING setting to True. By default, it's on False."""
        super().setup_test_environment(**kwargs)
        settings.TESTING = True

    def setup_databases(self, **kwargs):
        """We set the database"""
        r = super().setup_databases(**kwargs)
        self.load_fixtures()
        return r

    @classmethod
    def load_fixtures(cls):
        try:
            module = import_module(f"core.fixtures")
            getattr(module, "run_fixtures")()
        except ImportError:
            return

完成后，我们可以在settings.py文件中添加测试配置。



# CoreRoot/settings.py
...
TESTING = False
TEST_RUNNER = "CoreRoot.test_runner.CoreTestRunner"

现在，我们可以开始编写测试了。

让我们从身份验证测试开始。首先，让我们添加要使用的 URL 和数据。



# core/auth/tests.py

from django.urls import reverse
from rest_framework.test import APITestCase
from rest_framework import status


class AuthenticationTest(APITestCase):
    base_url_login = reverse("core:auth-login-list")
    base_url_refresh = reverse("core:auth-refresh-list")

    data_register = {"username": "test", "password": "pass", "email": "test@appseed.us"}

    data_login = {
        "email": "testuser@yopmail.com",
        "password": "12345678",
    }

太棒了！我们现在可以添加登录测试了。



# core/auth/tests.py
...
       def test_login(self):
        response = self.client.post(f"{self.base_url_login}", data=self.data_login)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

要运行测试，请打开终端并输入以下命令。



python manage.py test

您应该会看到类似的输出：



Creating test database for alias 'default'...
System check identified no issues (0 silenced).
.
----------------------------------------------------------------------
Ran 1 test in 0.287s

OK
Destroying test database for alias 'default'...

让我们为刷新端点添加一个测试。



# core/auth/tests.py
...

    def test_refresh(self):
        # Login

        response = self.client.post(f"{self.base_url_login}", data=self.data_login)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        response_data = response.json()

        access_token = response_data.get('access')
        refresh_token = response_data.get('refresh')

        # Refreshing the token

        response = self.client.post(f"{self.base_url_refresh}", data={
            "refresh": refresh_token
        })

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        response_data = response.json()
        self.assertNotEqual(access_token, response_data.get('access'))

我们在这里做的事情非常简单：

登录以检索访问和刷新令牌
使用刷新令牌发出请求以获取新的访问令牌
比较旧的访问令牌和新获得的访问令牌，以确保它们不相等。

现在让我们转到Docker配置。

Docker化我们的应用程序

Docker是一个用于在容器内开发、交付和运行应用程序的开放平台。
为什么要使用 Docker？因为
它可以帮助您将应用程序与基础架构分离，并有助于更快地交付代码。

如果这是您第一次使用 Docker，我强烈建议您阅读快速教程并阅读一些相关文档。

以下是一些对我有帮助的优秀资源：

Dockerfile

代表Dockerfile一个文本文档，其中包含可以在命令行上调用以创建图像的所有命令。

将 Dockerfile 添加到项目根目录：



# pull official base image
FROM python:3.9-alpine

# set work directory
WORKDIR /app

# set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# install psycopg2 dependencies
RUN apk update \
    && apk add postgresql-dev gcc python3-dev musl-dev

# install python dependencies
COPY requirements.txt /app/requirements.txt
RUN pip install --upgrade pip
RUN pip install --no-cache-dir -r requirements.txt


# copy project
COPY . .

这里，我们首先从基于 Alpine 的 Python Docker 镜像开始。它是一个轻量级的 Linux 发行版，专为安全性和资源效率而设计。
之后，我们设置了一个工作目录，并设置了两个环境变量：

1 -PYTHONDONTWRITEBYTECODE防止 Python 将.pyc文件写入磁盘
2 -PYTHONUNBUFFERED防止 Python 缓冲stdout和stderr

之后，我们执行如下操作：

设置环境变量
安装 Postgres 服务器
将requirements.txt文件复制到我们的应用程序路径，升级 pip，并安装 python 包来运行我们的应用程序
最后复制整个项目

另外，让我们添加一个.dockerignore文件。



env
venv
.dockerignore
Dockerfile

Docker Compose

Docker Compose是一款很棒的工具（<3）。你可以使用它来定义和运行多容器 Docker 应用程序。

我们需要什么？嗯，只需要一个包含我们应用程序服务所有配置的 YAML 文件。
然后，使用docker-compose命令，我们可以创建并启动所有这些服务。

这里，该docker-compose.dev.yml文件将包含构成我们应用程序的三个服务：nginx、web 和 db。

该文件将用于开发。

正如你所猜测的：



version: '3.7'
services:
  nginx:
    container_name: core_web
    restart: on-failure
    image: nginx:stable
    volumes:
      - ./nginx/nginx.dev.conf:/etc/nginx/conf.d/default.conf
      - static_volume:/app/static
    ports:
      - "80:80"
    depends_on:
      - web
  web:
    container_name: core_app
    build: .
    restart: always
    env_file: .env
    ports:
      - "5000:5000"
    command: >
      sh -c " python manage.py migrate &&
          gunicorn CoreRoot.wsgi:application --bind 0.0.0.0:5000"
    volumes:
     - .:/app
     - static_volume:/app/static
    depends_on:
     - db
  db:
    container_name: core_db
    image: postgres:12.0-alpine
    env_file: .env
    volumes:
      - postgres_data:/var/lib/postgresql/data/

volumes:
  static_volume:
  postgres_data:

nginx：NGINX是一款用于 Web 服务、反向代理、缓存、负载平衡、媒体流等的开源软件。
web：我们将通过 Gunicorn 运行并提供 Django 应用程序的端点。
db：正如您所猜测的，这项服务与我们的 PostgreSQL 数据库有关。

下一步，让我们创建 NGINX 配置文件来代理到后端应用程序的请求。
在根目录中，创建一个nginx目录并创建一个nginx.dev.conf文件。



upstream webapp {
    server core_app:5000;
}
server {

    listen 80;
    server_name localhost;

    location / {
        proxy_pass http://webapp;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_redirect off;
    }

    location /static/ {
     alias /app/static/;
    }
}

在构建我们的图像之前，让我们添加gunicorn一些配置。



pip install gunicorn

并将其作为要求添加在requirements.txt。
这是我的requirements.txt文件的样子：



Django==3.2.4
djangorestframework==3.12.4
djangorestframework-simplejwt==4.7.1
django-cors-headers==3.7.0
psycopg2==2.9.1
django-environ==0.4.5
gunicorn==20.1.0

最后，让我们添加STATIC_ROOT文件settings.py。

Docker 构建

设置已完成。让我们构建容器并测试一切是否在本地正常运行。



docker-compose -f docker-compose.dev.yml up -d --build

完成后，点击localhost/api/auth/login/查看应用程序是否正常运行。
你应该会看到类似的页面。

太棒了！我们的 Django 应用程序已成功在容器内运行。

让我们转到 Github Actions，以便在每次分支上有推送时运行测试main。

Github Actions（测试）

GitHub 操作是 Github 最棒的功能之一。它可以帮助您构建、测试或部署应用程序等等。

在这里，我们将创建一个名为的 YAML 文件django.yml来运行一些 Django 测试。

在根项目中，创建一个名为的目录.github。在该目录内，创建另一个名为的目录workflows并创建django.yml文件。



name: Django CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:

    runs-on: ubuntu-latest
    strategy:
      max-parallel: 4
      matrix:
        python-version: [3.9]
    services:
      postgres:
        image: postgres:12
        env:
          POSTGRES_USER: core
          POSTGRES_PASSWORD: 12345678
          POSTGRES_DB: coredb
        ports:
          - 5432:5432
        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5

    steps:
    - uses: actions/checkout@v2
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v2
      with:
        python-version: ${{ matrix.python-version }}
    - name: psycopg2 prerequisites
      run: sudo apt-get install python-dev libpq-dev
    - name: Install Dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run Tests
      run: |
        python manage.py test

基本上，我们在这里所做的是为GitHub 操作工作流设置规则、安装依赖项并运行测试。

确保仅当主分支上有 push 或 pull_request 时才会触发此工作流程
选择ubuntu-latest操作系统并精确指定此工作流程将在其上运行的 Python 版本。
接下来，我们创建一个 Postgres 服务，该数据库将用于运行我们的测试。
之后我们安装 python 依赖项并运行测试。

如果您将代码推送到存储库中，则当您转到存储库页面时会看到类似的内容。

片刻之后，黄色将变为绿色，表示检查已成功完成。

设置AWS服务器

我将在这里使用Lightsail 服务器。请注意，这些配置适用于任何 VPS 提供商。

如果您想设置 Lightsail 实例，请参阅 AWS文档。

就我个人而言，我的 VPS 在 Ubuntu 20.04.3 LTS 上运行。

此外，您还需要在机器上安装Docker和docker-compose 。

之后，如果您想将您的服务器链接到域名，请确保将其添加到您的 DNS 配置面板。

完成后，我们就可以开始部署过程了。

Docker 构建脚本

为了实现这里的自动化，我们将编写一个 bash 脚本来从 repo 中提取更改，并构建 docker 镜像并运行容器。

在再次拉出并重建容器之前，我们还将检查是否有任何即将发生的变化。



#!/usr/bin/env bash

TARGET='main'

cd ~/app || exit

ACTION='\033[1;90m'
NOCOLOR='\033[0m'

# Checking if we are on the main branch

echo -e ${ACTION}Checking Git repo
BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$BRANCH" != ${TARGET} ]
then
  exit 0
fi

# Checking if the repository is up to date.

git fetch
HEADHASH=$(git rev-parse HEAD)
UPSTREAMHASH=$(git rev-parse ${TARGET}@{upstream})

if [ "$HEADHASH" == "$UPSTREAMHASH" ]
then
  echo -e "${FINISHED}"Current branch is up to date with origin/${TARGET}."${NOCOLOR}"
  exit 0
fi

# If that's not the case, we pull the latest changes and we build a new image

git pull origin main;

# Docker

docker-compose up -d --build

exit 0;

好！使用 SSH 登录你的服务器。我们将创建一些新目录：一个用于代码库，另一个用于脚本。



mkdir app .scripts
cd .scripts
vim docker-deploy.sh

只需粘贴先前脚本的内容并根据需要进行修改即可。



cd ~/app
git clone <your_repository> .

不要忘记添加.。使用它，它将简单地克隆当前目录中存储库的内容。

太棒了！现在我们需要编写docker-compose.yml将在此服务器上运行的默认文件。

顺便说一下，我们将添加 SSL 证书，因此我们需要创建另一个nginx.conf文件。

这是docker-compose.yml文件。



version: '3.7'
services:
  nginx:
    container_name: core_web
    restart: on-failure
    image: jonasal/nginx-certbot:latest
    env_file:
      - .env.nginx
    volumes:
      - nginx_secrets:/etc/letsencrypt
      - ./nginx/user_conf.d:/etc/nginx/user_conf.d
    ports:
      - "80:80"
      - "443:443"
    depends_on:
      - web

  web:
    container_name: core_app
    build: .
    restart: always
    env_file: .env
    ports:
      - "5000:5000"
    command: >
      sh -c " python manage.py migrate &&
          gunicorn CoreRoot.wsgi:application --bind 0.0.0.0:5000"
    volumes:
     - .:/app
     - static_volume:/app/static
    depends_on:
     - db
  db:
    container_name: core_db
    image: postgres:12.0-alpine
    env_file: .env
    volumes:
      - postgres_data:/var/lib/postgresql/data/

volumes:
  static_volume:
  postgres_data:
  nginx_secrets:

如果您注意到，我们已经更改了nginx服务。现在，我们正在使用docker-nginx-certbot镜像。它将使用Let's Encrypt免费 CA（证书颁发机构）及其客户端自动创建和更新 SSL 证书certbot。

user_conf.d在目录内创建一个新目录nginx并创建一个新文件nginx.conf。



upstream webapp {
    server core_app:5000;
}

server {

    listen 443 default_server reuseport;
    listen [::]:443 ssl default_server reuseport;
    server_name dockerawsdjango.koladev.xyz;
    server_tokens off;
    client_max_body_size 20M;


    ssl_certificate /etc/letsencrypt/live/dockerawsdjango.koladev.xyz/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/dockerawsdjango.koladev.xyz/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/dockerawsdjango.koladev.xyz/chain.pem;
    ssl_dhparam /etc/letsencrypt/dhparams/dhparam.pem;

    location / {
        proxy_pass http://webapp;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_redirect off;
    }

    location /static/ {
     alias /app/static/;
    }
}

确保dockerawsdjango.koladev.xyz用您自己的域名替换...

没问题！我会解释我做了什么。



server {
    listen 443 default_server reuseport;
    listen [::]:443 ssl default_server reuseport;
    server_name dockerawsdjango.koladev.xyz;
    server_tokens off;
    client_max_body_size 20M;

和往常一样，我们监听 HTTPS 端口443。我们添加了一个，即域名。我们将设置为 off，这样错误页面上就不会显示服务器版本。最后，我们将请求大小设置为最大值 20MB。这意味着大于 20MB 的请求将导致HTTP 413（请求实体过大）错误。
server_nameserver_tokens

现在，我们来在 Github Action 中编写部署作业。



...
  deploy:
    name: Deploying
    needs: [test]
    runs-on: ubuntu-latest
    steps:
    - name: Deploying Application
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.SSH_AWS_SERVER_IP }}
        username: ${{ secrets.SSH_SERVER_USER }}
        key: ${{ secrets.SSH_PRIVATE_KEY }}
        passphrase: ${{ secrets.SSH_PASSPHRASE }}
        script: |
          cd ~/.scripts
          ./docker-deploy.sh

请注意这里 Github Secrets 的用法。它允许在你的仓库中存储敏感信息。查看此文档了解更多信息。

我们还在这里使用了一个 GitHub 操作，该操作需要主机名、用户名、密钥和密码。您也可以将此操作与密码一起使用，但需要进行一些配置。您
可以查看此操作的文档以了解更多详细信息。

另外，请注意这一needs: [build]行。它可以帮助我们确保在部署新版本的应用程序之前，先前的作业已经成功。

完成后，通过 ssh 登录您的服务器并创建一个 .env 文件。



cd app/
vim .env # or nano or whatever

最后，创建一个.env.nginx文件。它将包含创建 SSL 证书所需的配置。



# Required
CERTBOT_EMAIL=

# Optional (Defaults)
STAGING=1
DHPARAM_SIZE=2048
RSA_KEY_SIZE=2048
ELLIPTIC_CURVE=secp256r1
USE_ECDSA=0
RENEWAL_INTERVAL=8d