从开发环境到生产环境，部署 Tornado 应用程序

Tornado 是一个功能强大的非阻塞 Python Web 服务器和 Web 应用程序框架，非常适合处理异步操作和实时通信。有效部署 Tornado 应用程序对于确保您的应用程序在生产环境中表现良好至关重要。本博文将指导您完成部署 Tornado 应用程序的过程，从开发环境到生产环境，并通过实际演示来说明每个步骤。

1. 设置开发环境

在部署之前，您必须确保正确设置了开发环境。Tornado 应用程序需要特定配置，包括设置虚拟环境、管理依赖项以及在本地测试应用程序。

演示：设置虚拟环境并安装 Tornado

# Create a virtual environment
python3 -m venv tornado_env


# Activate the virtual environment
source tornado_env/bin/activate


# Install Tornado
pip install tornado

示例 Tornado 应用程序 (app.py)：

import tornado.ioloop
import tornado.web


class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, Tornado!")


def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])


if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

您可以通过运行 python app.py 并导航到 http://localhost:8888 在本地进行测试。

2. 准备生产

一旦您的应用程序经过测试并准备就绪，您就需要准备生产。这涉及设置环境变量、配置日志记录以及确保应用程序安全高效。

演示：配置日志记录和环境变量

修改 app.py 以包含日志记录和环境变量。

import os
import logging
import tornado.ioloop
import tornado.web


class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, Tornado in Production!")


def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ], debug=False)


if __name__ == "__main__":
    port = int(os.environ.get("PORT", 8888))
    logging.basicConfig(level=logging.INFO)
    app = make_app()
    app.listen(port)
    logging.info(f"Starting Tornado server on port {port}")
    tornado.ioloop.IOLoop.current().start()

您可以在运行应用程序之前设置 PORT 的环境变量：

export PORT=8000
python app.py

3. 部署到生产服务器

要部署 Tornado 应用程序部署到生产环境时，您可以使用各种方法，例如部署到云服务、使用 Docker 等容器化工具或部署到传统服务器上。

演示：使用 Docker 部署

Docker 是一种流行的将应用程序部署为容器的工具。以下是如何容器化和部署 Tornado 应用程序的方法。

Dockerfile：

# Use an official Python runtime as a parent image
FROM python:3.9-slim


# Set the working directory in the container
WORKDIR /app


# Copy the current directory contents into the container at /app
COPY . /app


# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt


# Make port 8888 available to the world outside this container
EXPOSE 8888


# Define environment variable
ENV PORT=8888


# Run app.py when the container launches
CMD ["python", "app.py"]

requirements.txt:

tornado

构建和运行 Docker 容器：

# Build the Docker image
docker build -t tornado-app .


# Run the Docker container
docker run -p 8888:8888 tornado-app

现在，您的 Tornado 应用程序正在 Docker 容器内运行，您可以通过 http://localhost:8888 访问它。

4. 部署到云服务

部署到 AWS、Google Cloud 或 Heroku 等云平台可提供可扩展性和易于管理性。让我们以部署到 Heroku 为例。

演示：部署到 Heroku

步骤 1：安装 Heroku CLI

curl https://cli-assets.heroku.com/install.sh | sh

步骤 2：创建 Procfile

web: python app.py

步骤 3：部署应用程序

# Login to Heroku
heroku login


# Create a new Heroku app
heroku create tornado-app-demo


# Push the code to Heroku
git push heroku master


# Open the app in the browser
heroku open

您的 Tornado 应用程序现已部署在 Heroku 上，可通过提供的 URL 访问。

5. 监控和扩展

部署后，您需要监控您的 Tornado 应用程序以确保其运行顺畅并根据流量进行扩展。

演示：使用 Prometheus 设置监控

您可以集成 Prometheus 等监控工具来监控您的 Tornado 应用程序的性能。

步骤 1：安装 prometheus_client

pip install prometheus_client

步骤 2：将 Prometheus 集成到您的应用程序中

修改 app.py 以公开指标。

from prometheus_client import start_http_server, Summary


# Create a metric to track time spent and requests made.
REQUEST_TIME = Summary('request_processing_seconds', 'Time spent processing request')


class MainHandler(tornado.web.RequestHandler):
    @REQUEST_TIME.time()
    def get(self):
        self.write("Hello, Tornado with Prometheus!")


def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])


if __name__ == "__main__":
    start_http_server(8000)  # Prometheus will scrape metrics from this port
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

扩展

要在云平台上扩展您的应用程序，您可以根据流量负载调整 dynos (Heroku) 或实例 (AWS、GCP) 的数量。

以下是一些额外的演示，可进一步增强 Tornado 应用程序的部署，重点介绍使用反向代理、设置 SSL、优化性能以及使用 CI/CD 管道进行部署等高级主题。

1. 使用 Nginx 作为 Tornado 的反向代理

在 Nginx 等反向代理后面部署 Tornado 是提高性能、安全性和负载平衡的常见做法。

演示：将 Nginx 配置为反向代理

步骤 1：安装 Nginx

sudo apt-get update
sudo apt-get install nginx

步骤 2：配置 Nginx

编辑 Nginx 配置文件以设置 Tornado 应用程序的反向代理。

sudo nano /etc/nginx/sites-available/tornado_app

添加以下配置：

server {
    listen 80;
    server_name your_domain.com;


    location / {
        proxy_pass http://127.0.0.1:8888;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

步骤 3：启用配置并重新启动 Nginx

sudo ln -s /etc/nginx/sites-available/tornado_app /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

现在，您的 Tornado 应用程序可以通过充当反向代理的 Nginx 访问。

2. 为您的 Tornado 应用程序设置 SSL

使用 SSL 保护您的 Tornado 应用程序对于保护用户数据和确保安全通信至关重要。

演示：使用 Let's Encrypt 配置 SSL

步骤 1：安装 Certbot

sudo apt-get install certbot python3-certbot-nginx

步骤 2：获取 SSL 证书

sudo certbot --nginx -d your_domain.com -d www.your_domain.com

步骤 3：自动 SSL 续订

Let's Encrypt 证书需要每 90 天续订一次。使用 cron 作业设置自动续订。

sudo crontab -e

将以下行添加到 crontab 文件：

0 3 * * * /usr/bin/certbot renew --quiet

此设置可确保您的 Tornado 应用程序通过 HTTPS 提供服务，从而提高安全性。

3. 优化 Tornado 的生产性能

为了最大限度地提高 Tornado 应用程序在生产中的性能，您可以优化进程数、缓存和数据库连接等设置。

演示：使用多个进程和缓存

步骤 1：使用多个进程运行 Tornado

Tornado 可以处理多个进程以利用多核 CPU。

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()
    tornado.process.fork_processes(4)  # Run 4 processes

这允许您的应用程序通过利用多个 CPU 核心同时处理更多请求。

步骤 2：实现缓存

使用 Redis 等缓存解决方案来减少 Tornado 应用程序的负载。

安装 Redis 和 tornado-redis：

sudo apt-get install redis-server
pip install tornado-redis

示例用法：

import tornadoredis
import tornado.web


class MainHandler(tornado.web.RequestHandler):
    def initialize(self, cache):
        self.cache = cache


    async def get(self):
        cached_value = await self.cache.get("key")
        if cached_value:
            self.write(f"Cached: {cached_value}")
        else:
            value = "Hello, Tornado with Redis!"
            await self.cache.set("key", value)
            self.write(value)


def make_app():
    cache = tornadoredis.Client()
    return tornado.web.Application([
        (r"/", MainHandler, dict(cache=cache)),
    ])


if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

此演示缓存响应以减少重复计算并加快响应速度。

4. 使用持续集成/持续部署 (CI/CD) 部署 Tornado

使用 CI/CD 管道可自动执行部署过程，确保您的 Tornado 应用程序以最少的手动干预持续交付。

演示：使用 GitHub Actions 设置 CI/CD 管道

步骤 1：创建 .github/workflows/deploy.yml 文件

name: Deploy Tornado Application


on:
  push:
    branches:
      - main


jobs:
  deploy:
    runs-on: ubuntu-latest


    steps:
    - uses: actions/checkout@v2


    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'


    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt


    - name: Run Tests
      run: |
        pytest


    - name: Deploy to Server
      env:
        SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
      run: |
        ssh -o StrictHostKeyChecking=no user@your_server_ip "cd /path/to/your/app && git pull origin main && sudo systemctl restart tornado_app"

第 2 步：将 SSH 密钥添加到 GitHub Secrets

1. 使用 ssh-keygen 生成 SSH 密钥对。
2. 将私钥添加到 GitHub Secrets (SSH_PRIVATE_KEY)。
3. 将公钥添加到服务器的 ~/.ssh/authorized_keys。

使用此设置，每次推送到主分支都会触发 CI/CD 管道，自动将您的 Tornado 应用程序部署到服务器。

5. 使用 Gunicorn 作为 Tornado 的应用程序服务器

Gunicorn 是适用于 UNIX 的 Python WSGI HTTP 服务器，以高性能而闻名。虽然 Tornado 是一个异步框架，但您仍然可以使用 Gunicorn 来管理多个 Tornado 工作程序，从而提高应用程序的可扩展性。

演示：使用 Gunicorn 运行 Tornado

步骤 1：安装 Gunicorn

pip install gunicorn

步骤 2：修改您的 Tornado 应用程序以实现 WSGI 兼容性

Tornado 本身并不兼容 WSGI，但您可以使用 tornado.wsgi.WSGIAdapter 类对其进行调整。

import tornado.wsgi
import tornado.web


class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, Tornado with Gunicorn!")


def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])


if __name__ == "__main__":
    app = make_app()
    wsgi_app = tornado.wsgi.WSGIApplication(app)
    server = tornado.httpserver.HTTPServer(wsgi_app)
    server.bind(8888)
    server.start(0)  # Forks multiple sub-processes
    tornado.ioloop.IOLoop.current().start()

步骤 3：使用 Gunicorn 运行应用程序

gunicorn -w 4 -b 127.0.0.1:8888 app:wsgi_app

此命令使用以下命令运行您的 Tornado 应用程序4 个由 Gunicorn 管理的工作程序，提供更好的负载管理和扩展。

这些额外的演示涵盖了在生产环境中部署 Tornado 应用程序的各个方面，从使用反向代理和 SSL 到设置 CI/CD 管道和优化性能。实施这些策略将有助于确保您的 Tornado 应用程序强大、安全且可扩展。将 Tornado 应用程序从开发部署到生产涉及几个关键步骤，包括环境设置、生产准备、部署和监控。通过遵循本博客中提供的指南和演示，您可以确保您的 Tornado 应用程序稳健、可扩展且可用于实际流量。