使用 Fabric 和 Ansible 自动化 Django 部署

2023-10-12

在里面最后的在这篇文章中，我们介绍了在单个服务器上成功开发和部署 Django 应用程序所需的所有步骤。在本教程中，我们将使用以下命令自动化部署过程织物 (v1.12.0）和安西布尔 (v2.1.3)为了解决这些问题：

缩放：当涉及扩展 Web 应用程序以处理数千个日常请求时，依赖单个服务器并不是一个好方法。简而言之，当服务器接近最大 CPU 利用率时，可能会导致加载速度缓慢，最终导致服务器故障。为了克服这个问题，必须扩展应用程序以在多个服务器上运行，以便服务器可以累积地处理传入的并发请求。
冗余：手动将 Web 应用程序部署到新服务器意味着大量重复工作，并且出现人为错误的可能性更大。自动化该过程是关键。

具体来说，我们将自动化：

添加新的非 root 用户
配置服务器
从 GitHub 存储库中提取 Django 应用程序代码
安装依赖关系
应用程序守护进程

设置和配置

首先启动一个新的数字海洋Droplet，确保使用 Fedora 25 镜像。不要设置预配置的 SSH 密钥；稍后我们将通过 Fabric 自动化此过程脚本。由于部署过程应该是可扩展的，因此创建一个单独的存储库来容纳所有部署脚本。在本地创建一个新的项目目录，并使用 Python 2.7x 创建并激活 virtualenv。

为什么选择Python 2.7？面料不支持Python 3。不用担心：当我们配置服务器时，我们将使用 Python 3.5。

$ mkdir automated-deployments
$ cd automated-deployments
$ virtualenv env
$ source env/bin/activate

面料设置

Fabric 是一个用于通过 SSH 自动执行例行 shell 命令的工具，我们将用它来：

设置 SSH 密钥
硬化用户密码
安装 Ansible 依赖项
升级服务器

首先安装 Fabric：

$ pip install fabric==1.12.0

创建一个名为“prod”的新文件夹，并添加一个名为“prod”的新文件fabfile.py用于保存所有 Fabric 脚本：

# prod/fabfile.py

import os
from fabric.contrib.files import sed
from fabric.api import env, local, run
from fabric.api import env

# initialize the base directory
abs_dir_path = os.path.dirname(
    os.path.dirname(os.path.abspath(__file__)))


# declare environment global variables

# root user
env.user = 'root'

# list of remote IP addresses
env.hosts = ['<remote-server-ip>']

# password for the remote server
env.password = '<remote-server-password>'

# full name of the user
env.full_name_user = '<your-name>'

# user group
env.user_group = 'deployers'

# user for the above group
env.user_name = 'deployer'

# ssh key path
env.ssh_keys_dir = os.path.join(abs_dir_path, 'ssh-keys')

请注意内嵌注释。请务必将远程服务器的 IP 地址添加到env.hosts多变的。更新env.full_name_user以及。暂缓更新env.password;我们很快就会讨论这个问题。看看所有的env变量 - 它们可以根据您的系统设置完全自定义。

设置 SSH 密钥

添加以下代码到fabfile.py:

def start_provision():
    """
    Start server provisioning
    """
    # Create a new directory for a new remote server
    env.ssh_keys_name = os.path.join(
        env.ssh_keys_dir, env.host_string + '_prod_key')
    local('ssh-keygen -t rsa -b 2048 -f {0}'.format(env.ssh_keys_name))
    local('cp {0} {1}/authorized_keys'.format(
        env.ssh_keys_name + '.pub', env.ssh_keys_dir))
    # Prevent root SSHing into the remote server
    sed('/etc/ssh/sshd_config', '^UsePAM yes', 'UsePAM no')
    sed('/etc/ssh/sshd_config', '^PermitRootLogin yes',
        'PermitRootLogin no')
    sed('/etc/ssh/sshd_config', '^#PasswordAuthentication yes',
        'PasswordAuthentication no')

    install_ansible_dependencies()
    create_deployer_group()
    create_deployer_user()
    upload_keys()
    set_selinux_permissive()
    run('service sshd reload')
    upgrade_server()

该函数充当 Fabric 脚本的入口点。除了触发一系列功能（每个功能都在进一步的步骤中进行解释）之外，它还明确-

在本地系统的指定位置生成一对新的 SSH 密钥
将公钥内容复制到授权密钥文件
对遥控器进行更改sshd_配置文件以阻止 root 登录并禁用无密码身份验证

阻止 root 用户进行 SSH 访问是一个可选步骤，但建议这样做，因为它可以确保没有人拥有超级用户权限。

在项目根目录中为 SSH 密钥创建一个目录：

├── prod
│   └── fabfile.py
└── ssh-keys

强化用户密码

此步骤包括添加三个不同的函数，每个函数都串行执行以配置 SSH 密码强化......

创建部署者组

def create_deployer_group():
    """
    Create a user group for all project developers
    """
    run('groupadd {}'.format(env.user_group))
    run('mv /etc/sudoers /etc/sudoers-backup')
    run('(cat /etc/sudoers-backup; echo "%' +
        env.user_group + ' ALL=(ALL) ALL") > /etc/sudoers')
    run('chmod 440 /etc/sudoers')

在这里，我们添加一个名为deployers并授予其sudo权限，以便用户可以以root权限执行进程。

创建用户

def create_deployer_user():
    """
    Create a user for the user group
    """
    run('adduser -c "{}" -m -g {} {}'.format(
        env.full_name_user, env.user_group, env.user_name))
    run('passwd {}'.format(env.user_name))
    run('usermod -a -G {} {}'.format(env.user_group, env.user_name))
    run('mkdir /home/{}/.ssh'.format(env.user_name))
    run('chown -R {} /home/{}/.ssh'.format(env.user_name, env.user_name))
    run('chgrp -R {} /home/{}/.ssh'.format(
        env.user_group, env.user_name))

这个功能——

将新用户添加到deployers用户组，我们在上一个函数中定义的
设置用于保存 SSH 密钥对的 SSH 目录，并授予组和用户访问该目录的权限

上传 SSH 密钥

def upload_keys():
    """
    Upload the SSH public/private keys to the remote server via scp
    """
    scp_command = 'scp {} {}/authorized_keys {}@{}:~/.ssh'.format(
        env.ssh_keys_name + '.pub',
        env.ssh_keys_dir,
        env.user_name,
        env.host_string
    )
    local(scp_command)

在这里，我们-

将本地生成的SSH密钥上传到远程服务器，以便非root用户无需输入密码即可通过SSH登录
将新建的公钥和授权密钥复制到远程服务器ssh 密钥目录

安装 Ansible 依赖项

添加以下函数来安装 Ansible 的依赖包：

def install_ansible_dependencies():
    """
    Install the python-dnf module so that Ansible
    can communicate with Fedora's Package Manager
    """
    run('dnf install -y python-dnf')

请记住，这是特定于 Fedora Linux 发行版的，因为我们将使用地下城与勇士模块用于安装软件包，但它可能因发行版而异。

将 SELinux 设置为宽容模式

下一个功能集SELinux到宽容模式。这样做是为了克服任何潜在的 Nginx 502 Bad Gateway错误.

def set_selinux_permissive():
    """
    Set SELinux to Permissive/Disabled Mode
    """
    # for permissive
    run('sudo setenforce 0')

同样，这是特定于 Fedora Linux 发行版的。

升级服务器

最后，升级服务器：

def upgrade_server():
    """
    Upgrade the server as a root user
    """
    run('dnf upgrade -y')
    # optional command (necessary for Fedora 25)
    run('dnf install -y python')
    run('reboot')

完整性检查

至此，我们就完成了 Fabric 脚本。在运行之前，请确保您以 root 身份通过 SSH 连接到服务器并更改密码：

$ ssh root@<server-ip-address>
You are required to change your password immediately (root enforced)
Changing password for root.
(current) UNIX password:
New password:
Retype new password:

一定要更新env.password使用新密码。退出服务器并返回本地终端，然后执行Fabric：

$ fab -f ./prod/fabfile.py start_provision

如果一切顺利，将生成新的 SSH 密钥，并且系统会要求您创建密码（请务必执行此操作！）：

Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:

将运行许多任务。之后deployer创建用户后，系统将提示您为该用户添加密码 -

[104.236.66.172] out: Changing password for user deployer.

- 上传 SSH 密钥时您必须输入：

deployer@104.236.66.172s password:

该脚本成功退出后，您将无法再以 root 用户身份登录远程服务器。相反，您将只能使用非 root 用户deployer.

试试看：

$ ssh root@<server-ip-address>
Permission denied (publickey,gssapi-keyex,gssapi-with-mic).

这是预料之中的。然后，当你跑步时——

$ ssh -i ./ssh-keys/104.236.66.172_prod_key deployer@104.236.66.172

-您应该能够正常登录：

[deployer@fedora-512mb-nyc2-01 ~]$

Ansible 入门

安西布尔是一种配置管理和配置工具，用于通过 SSH 自动执行部署任务。

你可以开火单独的 Ansible 任务从您的 shell 远程控制应用程序服务器并随时随地执行任务。任务也可以组合成剧本- 多个的集合戏剧，其中每个 play 定义了部署过程中所需的某些特定任务。它们在部署过程中针对应用程序服务器执行。剧本是写在YAML.

剧本

Playbook 由模块化架构组成，如下所示：

主办方指定我们需要编排的远程服务器的所有IP地址或域名。 Playbook 始终在目标主机组上运行。
Roles are divided into sub parts. Let’s look at some sample roles:
- 任务是部署过程中需要执行的多个任务的集合。
- 处理程序提供了一种在模块对远程服务器进行更改时触发一组操作的方法（最好将其视为挂钩）。
- 在这种情况下，模板通常用于指定一些与模块相关的配置文件 - 例如 nginx。
变量只是一个键值对列表，其中每个键（变量）都映射到一个值。此类变量可以在 Playbook 中用作占位符。

示例手册

现在让我们看一下单文件 Playbook 示例：

---
# My Ansible playbook for configuring Nginx
- hosts: all

  vars:
    http_port: 80
    app_name: django_bootstrap

  tasks:
    - name: Install nginx
      dnf: name=nginx state=latest

    - name: Create nginx config file
      template: src=django_bootstrap.conf dest=/etc/nginx/conf.d/{{ app_name }}.conf
      become: yes
      notify:
        - restart nginx

  handlers:
    - name: Restart nginx
      service: name=nginx state=restarted enabled=yes
      become: yes

在这里，我们定义：

主机为hosts: all，这表明 Playbook 将在列出的所有服务器上运行库存/主机文件
变量http_port: 80和app_name: django_bootstrap用于模板
为了安装 nginx，设置 nginx 配置（become表明我们需要管理员权限），并触发重启处理程序
处理程序以重新启动 nginx 服务

剧本设置

现在让我们为 Django 设置 Playbook。添加一个部署.yml文件到“prod”目录：

##
# This playbook deploys the whole app stack
##
- name: apply common configuration to server
  hosts: all
  user: deployer
  roles:
    - common

上面的代码片段将 Ansible 主机、用户和角色粘合在一起。

主办方

添加一个主机（纯文本格式）文件复制到“prod”目录，并在各自的角色名称下列出服务器。我们在这里配置一台服务器：

[common]
<server-ip-address>

在上面的片段中，common指角色名称。在角色下，我们有一个需要配置的 IP 地址列表。确保添加远程服务器的 IP 地址来代替<server-ip-address>.

变量

现在我们定义角色将使用的变量。在“prod”中添加一个名为“group_vars”的新文件夹，然后创建一个名为的新文件all（纯文本格式）在该文件夹中。在这里，指定以下变量：

# App Name
app_name: django_bootstrap

# Deployer User and Groups
deployer_user: deployer
deployer_group: deployers

# SSH Keys Directory
ssh_dir: <path-to-your-ssh-keys>

确保更新<path-to-your-ssh-keys>。要获取正确的路径，请在项目根目录中运行：

$ cd ssh-keys
$ pwd
/Users/michael.herman/repos/realpython/automated-deployments/ssh-keys

有了这些文件，我们现在就可以将我们的部署过程与需要在服务器上执行的所有角色进行协调。

剧本角色

同样，剧本只是不同剧本的集合，所有这些剧本都在特定的角色下运行。在“prod”中创建一个名为“roles”的新目录。

你知道剧中角色的名字吗？部署.yml文件？

然后在“roles”目录中添加一个名为“common”的新目录 - 角色。角色由“任务”、“处理程序”和“模板”组成。为每个添加一个新目录。

完成后，您的文件结构应如下所示：

├── prod
│   ├── deploy.yml
│   ├── fabfile.py
│   ├── group_vars
│   │   └── all
│   ├── hosts
│   └── roles
│       └── common
│           ├── handlers
│           ├── tasks
│           └── templates
└── ssh-keys
    ├── 104.236.66.172_prod_key
    ├── 104.236.66.172_prod_key.pub
    └── authorized_keys

所有的戏剧都定义在“tasks”目录中，以主.yml文件。该文件作为入口点all剧本任务。它只是需要按顺序执行的多个 YAML 文件的列表。

现在在“tasks”目录中创建该文件，然后向其中添加以下内容：

##
# Configure the server for the Django app
##
- include: 01_server.yml
- include: 02_git.yml
- include: 03_postgres.yml
- include: 04_dependencies.yml
- include: 05_migrations.yml
- include: 06_nginx.yml
- include: 07_gunicorn.yml
- include: 08_systemd.yml
# - include: 09_fix-502.yml

现在，让我们创建每个任务。请务必将每个任务的新文件添加到“tasks”目录中，并将随附的代码添加到每个文件中。如果您迷路了，请参阅回购协议.

01_服务器.yml

##
# Update the DNF package cache and install packages as a root user
##
- name: Install required packages
  dnf: name={{item}} state=latest
  become: yes
  with_items:
    - vim
    - fail2ban
    - python3-devel
    - python-virtualenv
    - python3-virtualenv
    - python-devel
    - gcc
    - libselinux-python
    - redhat-rpm-config
    - libtiff-devel
    - libjpeg-devel
    - libzip-devel
    - freetype-devel
    - lcms2-devel
    - libwebp-devel
    - tcl-devel
    - tk-devel
    - policycoreutils-devel

在这里，我们列出了所有需要安装的系统软件包。

02_git.yml

##
# Clone and pull the repo
##
- name: Set up git configuration
  dnf: name=git state=latest
  become: yes

- name: Clone or pull the latest code
  git: repo={{ code_repository_url }}
        dest={{ app_dir }}

将以下变量添加到组变量/全部文件：

# Github Code's Repo URL
code_repository_url: https://github.com/realpython/django-bootstrap

# App Directory
app_dir: /home/{{ deployer_user }}/{{app_name}}

确保分叉然后克隆Django 引导程序回购，然后更新code_repository_url变量到你的fork的URL。

03_postgres.yml

##
# Set up and configure postgres
##
- name: Install and configure db
  dnf: name={{item}} state=latest
  become: yes
  with_items:
    - postgresql-server
    - postgresql-contrib
    - postgresql-devel
    - python-psycopg2

- name: Run initdb command
  raw: postgresql-setup initdb
  become: yes

- name: Start and enable postgres
  service: name=postgresql enabled=yes state=started
  become: yes

- name: Create database
  postgresql_db: name={{ app_name }}
  become_user: postgres
  become: yes

- name: Configure a new postgresql user
  postgresql_user: db={{ app_name }}
                                name={{ db_user }}
                                password={{ db_password }}
                                priv=ALL
                                role_attr_flags=NOSUPERUSER
  become: yes
  become_user: postgres
  notify:
    - restart postgres

更新组变量/全部以及剧本所需的数据库配置：

# DB Configuration
db_url: postgresql://{{deployer_user}}:{{db_password}}@localhost/{{app_name}}
db_password: thisissomeseucrepassword
db_name: "{{ app_name }}"
db_user: "{{ deployer_user }}"

更新db_password具有安全密码的变量。

您是否注意到我们在以下位置重新启动了 postgres 服务主.yml文件以便在配置数据库后应用更改？这是我们的第一个处理程序。创建一个名为的新文件主.yml在“handlers”文件夹中，然后添加以下内容：

- name: restart postgres
  service: name=postgresql state=restarted
  become: yes

04_依赖关系.yml

##
# Set up all the dependencies in a virtualenv required by the Django app
##
- name: Create a virtualenv directory
  file: path={{ venv_dir }} state=directory

- name: Install dependencies
  pip:    requirements={{ app_dir }}/requirements.txt
          virtualenv={{ venv_dir }}
          virtualenv_python=python3.5

- name: Create the .env file for running ad-hoc python commands in our virtualenv
  template: src=env.j2 dest={{ app_dir }}/.env
  become: yes

更新组变量/全部像这样：

# Application Dependencies Setup
venv_dir: '/home/{{ deployer_user }}/envs/{{ app_name }}'
venv_python: '{{ venv_dir }}/bin/python3.5'

添加一个名为的模板环境j2到“templates”文件夹，并添加以下环境变量：

#!/bin/bash
export DEBUG="True"
export DATABASE_URL="postgresql://deployer:thisissomeseucrepassword@localhost/django_bootstrap"
export DJANGO_SECRET_KEY="changeme"
export DJANGO_SETTINGS_MODULE="config.settings.production"

请非常小心环境变量及其值环境j2因为它们用于启动并运行 Django 项目。

05_migrations.yml

##
# Run db migrations and get all static files
##
- name: Make migrations
  shell: ". {{ app_dir }}/.env; {{ venv_python }} {{ app_dir }}/manage.py makemigrations "
  become: yes

- name: Migrate database
  django_manage: app_path={{ app_dir }}
                                 command=migrate
                                 virtualenv={{ venv_dir }}

- name: Get all static files
  django_manage: app_path={{ app_dir }}
                                 command=collectstatic
                                 virtualenv={{ venv_dir }}
  become: yes

06_nginx.yml

##
# Configure nginx web server
##
- name: Set up nginx config
  dnf: name=nginx state=latest
  become: yes

- name: Write nginx conf file
  template: src=django_bootstrap.conf dest=/etc/nginx/conf.d/{{ app_name }}.conf
  become: yes
  notify:
    - restart nginx

添加以下变量组变量/全部:

# Remote Server Details
server_ip: <remote-server-ip>
wsgi_server_port: 8000

别忘了更新<remote-server-ip>。然后将处理程序添加到处理程序/main.yml:

- name: restart nginx
  service: name=nginx state=restarted enabled=yes
  become: yes

然后我们需要添加django_bootstrap.conf模板。在“templates”目录中创建该文件，然后添加代码：

upstream app_server {
    server 127.0.0.1:{{ wsgi_server_port }} fail_timeout=0;
}

server {
    listen 80;
    server_name {{ server_ip }};
    access_log /var/log/nginx/{{ app_name }}-access.log;
    error_log /var/log/nginx/{{ app_name }}-error.log info;

    keepalive_timeout 5;

    # path for staticfiles
    location /static {
            autoindex on;
            alias {{ app_dir }}/staticfiles/;
    }

    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_redirect off;

        if (!-f $request_filename) {
            proxy_pass http://app_server;
            break;
        }
    }
}

07_gunicorn.yml

##
# Set up Gunicorn and configure systemd to execute gunicorn_start script
##
- name: Create a deploy directory
  file: path={{ deploy_dir }} state=directory
  become: yes

- name: Create the gunicorn_start script for running our app from systemd service
  template: src=gunicorn_start
                    dest={{ deploy_dir }}/gunicorn_start
  become: yes

- name: Make the gunicorn_start script executable
  raw: cd {{ deploy_dir }}; chmod +x gunicorn_start
  become: yes

添加更多变量组变量/全部:

# Deploy Dir in App Directory
deploy_dir: '{{ app_dir }}/deploy'

# WSGI Vars
django_wsgi_module: config.wsgi
django_settings_module: config.settings.production
django_secret_key: 'changeme'
database_url: '{{ db_url }}'

添加Gunicorn_start模板：

#!/bin/bash

### Define script variables

# Name of the app
NAME='{{ app_name }}'
# Path to virtualenv
VIRTUALENV='{{ venv_dir }}'
# Django Project Directory
DJANGODIR='{{ app_dir }}'
# The user to run as
USER={{ deployer_user }}
# The group to run as
GROUP={{deployer_group }}
# Number of worker processes Gunicorn should spawn
NUM_WORKERS=3
# Settings file that Gunicorn should use
DJANGO_SETTINGS_MODULE={{django_settings_module}}
# WSGI module name
DJANGO_WSGI_MODULE={{ django_wsgi_module }}


### Activate virtualenv and create environment variables

echo "Starting $NAME as `whoami`"
# Activate the virtual environment
cd $VIRTUALENV
source bin/activate
cd $DJANGODIR
# Defining the Environment Variables
export DJANGO_SECRET_KEY='{{ django_secret_key }}'
export DATABASE_URL='{{ db_url }}'
export DJANGO_SETTINGS_MODULE=$DJANGO_SETTINGS_MODULE
export PYTHONPATH=$DJANGODIR:$PYTHONPATH


### Start Gunicorn

exec gunicorn ${DJANGO_WSGI_MODULE}:application \
        --name $NAME \
        --workers $NUM_WORKERS \
        --user=$USER --group=$GROUP \
        --log-level=debug \
        --bind=127.0.0.1:8000

08_systemd.yml

##
# Set up systemd for executing gunicorn_start script
##
- name: write a systemd service file
  template: src=django-bootstrap.service
                    dest=/etc/systemd/system
  become: yes
  notify:
    - restart app
    - restart nginx

添加模板 -django-bootstrap.service:

#!/bin/sh

[Unit]
Description=Django Web App
After=network.target

[Service]
PIDFile=/var/run/djangoBootstrap.pid
User={{ deployer_user }}
Group={{ deployer_group }}
ExecStart=/bin/sh {{ deploy_dir }}/gunicorn_start
Restart=on-abort

[Install]
WantedBy=multi-user.target

将以下内容添加到处理程序：

- name: restart app
  service: name=django-bootstrap state=restarted enabled=yes
  become: yes

09_fix-502.yml

##
# Fix the 502 nginx error post deployment
#
- name: Fix nginx 502 error
  raw: cd ~; cat /var/log/audit/audit.log | grep nginx | grep denied | audit2allow -M mynginx; semodule -i mynginx.pp
  become: yes

健全性检查（最终）

激活 virtualenv 后，本地安装 Ansible:

$ pip install ansible==2.1.3

创建一个名为的新文件部署产品.sh在项目根目录中运行剧本，确保更新<server-ip>:

#!/bin/bash

ansible-playbook ./prod/deploy.yml --private-key=./ssh_keys<server-ip>_prod_key -K -u deployer -i ./prod/hosts -vvv

然后运行以下命令来执行剧本：

$ sh deploy_prod.sh

如果出现任何错误，请查阅终端以获取如何纠正错误的信息。修复后，再次执行部署脚本。脚本完成后，访问服务器的 IP 地址以验证您的 Django Web 应用程序是否正常运行！

确保取消注释此行产品/角色/常见/任务/main.yml如果看到502错误，则表明nginx和Gunicorn之间的通信出现问题：

# - include: 09_fix-502.yml

然后再次执行剧本。

如果您多次执行该剧本，请确保注释掉Run initdb command在发现03_postgres.yml因为它只需要运行一次。否则，在尝试重新初始化数据库服务器时会抛出错误。

结论

这篇文章提供了如何使用 Fabric 和 Ansible 自动配置服务器的基本了解。 Ansible Playbook 特别强大，因为您可以通过 YAML 文件自动执行服务器上的几乎所有任务。希望您现在可以开始编写自己的 Playbook，甚至在工作场所中使用它们来配置生产就绪服务器。

请在下面添加问题和评论。完整的代码可以在自动部署存储库。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)