ในฐานะวิศวกรการเรียนรู้ของเครื่องและ ผู้เชี่ยวชาญด้านการมองเห็นคอมพิวเตอร์ ฉันพบว่าตัวเองกำลังสร้าง API และแม้แต่เว็บแอปด้วย Flask บ่อยครั้งจนน่าประหลาดใจ ในโพสต์นี้ฉันต้องการแบ่งปันเคล็ดลับและสูตรอาหารที่มีประโยชน์สำหรับการสร้างแอปพลิเคชั่น Flask พร้อมสำหรับการผลิตที่สมบูรณ์

เราจะกล่าวถึงหัวข้อต่อไปนี้:

1. การจัดการการตั้งค่า. แอปพลิเคชันในชีวิตจริงใด ๆ มีวงจรชีวิตที่มีขั้นตอนเฉพาะอย่างน้อยที่สุดก็คือการพัฒนาการทดสอบและการปรับใช้ ในแต่ละขั้นตอนรหัสแอปพลิเคชันควรทำงานในสภาพแวดล้อมที่แตกต่างกันเล็กน้อยซึ่งต้องมีชุดการตั้งค่าที่แตกต่างกันเช่นสตริงการเชื่อมต่อฐานข้อมูลคีย์ API ภายนอกและ URL
2. แอปพลิเคชัน Flask แบบโฮสต์ด้วยตนเองพร้อม Gunicorn แม้ว่า Flask จะมีเว็บเซิร์ฟเวอร์ในตัว แต่อย่างที่เราทราบกันดีว่ามันไม่เหมาะสำหรับการผลิตและจำเป็นต้องวางไว้หลังเว็บเซิร์ฟเวอร์จริงที่สามารถสื่อสารกับ Flask ผ่านโปรโตคอล WSGI ทางเลือกทั่วไปสำหรับสิ่งนั้นคือ Gunicorn - เซิร์ฟเวอร์ Python WSGI HTTP
3. ให้บริการไฟล์คงที่และคำขอพร็อกซีด้วย Nginx . ในขณะที่เป็นเว็บเซิร์ฟเวอร์ HTTP แต่ Gunicorn ก็เป็นแอปพลิเคชันเซิร์ฟเวอร์ที่ไม่เหมาะที่จะเผชิญหน้ากับเว็บ นั่นคือเหตุผลที่เราต้องการ Nginx เป็น reverse proxy และเพื่อให้บริการไฟล์แบบคงที่ ในกรณีที่เราจำเป็นต้องขยายแอปพลิเคชันของเราไปยังเซิร์ฟเวอร์หลายเครื่อง Nginx จะดูแลเรื่องการทำโหลดบาลานซ์ด้วย
4. การปรับใช้แอปภายในคอนเทนเนอร์ Docker บนเซิร์ฟเวอร์ Linux เฉพาะ การปรับใช้ตู้คอนเทนเนอร์เป็นส่วนสำคัญของการออกแบบซอฟต์แวร์มานานแล้ว แอปพลิเคชันของเราไม่แตกต่างกันและจะบรรจุในภาชนะของตัวเองอย่างเรียบร้อย (ในความเป็นจริงหลายตู้)
5. การกำหนดค่าและปรับใช้ฐานข้อมูล PostgreSQL สำหรับแอปพลิเคชัน โครงสร้างฐานข้อมูลและการย้ายข้อมูลจะถูกจัดการโดย Alembic ด้วย SQLAlchemy จัดเตรียมการแม็ปเชิงวัตถุเชิงสัมพันธ์
6. การตั้งค่าไฟล์ ผักชีฝรั่ง คิวงานเพื่อจัดการงานที่รันเป็นเวลานาน ในที่สุดแอปพลิเคชันทุกตัวจะต้องใช้สิ่งนี้เพื่อลดเวลาหรือกระบวนการที่เข้มข้นในการคำนวณไม่ว่าจะเป็นการส่งอีเมลการดูแลฐานข้อมูลอัตโนมัติหรือการประมวลผลภาพที่อัปโหลด - จากเธรดเซิร์ฟเวอร์ของเว็บกับผู้ปฏิบัติงานภายนอก

การสร้างแอพ Flask

เริ่มต้นด้วยการสร้างรหัสแอปพลิเคชันและเนื้อหา โปรดทราบว่าฉันจะไม่กล่าวถึงโครงสร้างแอปพลิเคชัน Flask ที่เหมาะสมในโพสต์นี้ แอปสาธิตประกอบด้วยโมดูลและแพ็คเกจจำนวนน้อยที่สุดเพื่อความกะทัดรัดและความชัดเจน

ความแตกต่างระหว่าง c corp และ s corp และ llc

ขั้นแรกให้สร้างโครงสร้างไดเร็กทอรีและเริ่มต้นที่เก็บ Git ว่าง

mkdir flask-deploy cd flask-deploy # init GIT repo git init # create folder structure mkdir static tasks models config # install required packages with pipenv, this will create a Pipfile pipenv install flask flask-restful flask-sqlalchemy flask-migrate celery # create test static asset echo 'Hello World!' > static/hello-world.txt

ต่อไปเราจะเพิ่มรหัส

config / __ init__.py

ในโมดูลการกำหนดค่าเราจะกำหนดกรอบการจัดการการกำหนดค่าเล็ก ๆ ของเรา แนวคิดคือการทำให้แอปทำงานตามการกำหนดค่าล่วงหน้าที่เลือกโดย APP_ENV ตัวแปรสภาพแวดล้อมบวกเพิ่มตัวเลือกเพื่อแทนที่การตั้งค่าคอนฟิกูเรชันใด ๆ ด้วยตัวแปรสภาวะแวดล้อมเฉพาะหากจำเป็น

import os import sys import config.settings # create settings object corresponding to specified env APP_ENV = os.environ.get('APP_ENV', 'Dev') _current = getattr(sys.modules['config.settings'], '{0}Config'.format(APP_ENV))() # copy attributes to the module for convenience for atr in [f for f in dir(_current) if not '__' in f]: # environment can override anything val = os.environ.get(atr, getattr(_current, atr)) setattr(sys.modules[__name__], atr, val) def as_dict(): res = {} for atr in [f for f in dir(config) if not '__' in f]: val = getattr(config, atr) res[atr] = val return res

config / settings.py

นี่คือชุดของคลาสการกำหนดค่าซึ่งหนึ่งในนั้นถูกเลือกโดย APP_ENV ตัวแปร. เมื่อแอปพลิเคชันทำงานรหัสใน __init__.py จะสร้างอินสแตนซ์หนึ่งในคลาสเหล่านี้โดยแทนที่ค่าฟิลด์ที่มีตัวแปรสภาพแวดล้อมเฉพาะหากมีอยู่ เราจะใช้ออบเจ็กต์การกำหนดค่าขั้นสุดท้ายเมื่อเริ่มต้นการกำหนดค่า Flask และ Celery ในภายหลัง

class BaseConfig(): API_PREFIX = '/api' TESTING = False DEBUG = False class DevConfig(BaseConfig): FLASK_ENV = 'development' DEBUG = True SQLALCHEMY_DATABASE_URI = 'postgresql://db_user: [email protected] :5432/flask-deploy' CELERY_BROKER = 'pyamqp://rabbit_user: [email protected] //' CELERY_RESULT_BACKEND = 'rpc://rabbit_user: [email protected] //' class ProductionConfig(BaseConfig): FLASK_ENV = 'production' SQLALCHEMY_DATABASE_URI = 'postgresql://db_user: [email protected] :5432/flask-deploy' CELERY_BROKER = 'pyamqp://rabbit_user: [email protected] //' CELERY_RESULT_BACKEND = 'rpc://rabbit_user: [email protected] //' class TestConfig(BaseConfig): FLASK_ENV = 'development' TESTING = True DEBUG = True # make celery execute tasks synchronously in the same process CELERY_ALWAYS_EAGER = True

งาน / __ init__.py

แพคเกจงานมีรหัสเริ่มต้นผักชีฝรั่ง แพ็คเกจ Config ซึ่งจะมีการคัดลอกการตั้งค่าทั้งหมดในระดับโมดูลเมื่อเริ่มต้นใช้งานเพื่ออัปเดตออบเจ็กต์การกำหนดค่า Celery ในกรณีที่เราจะมีการตั้งค่าเฉพาะขึ้นฉ่ายในอนาคตตัวอย่างเช่นงานตามกำหนดการและระยะหมดเวลาของผู้ปฏิบัติงาน

from celery import Celery import config def make_celery(): celery = Celery(__name__, broker=config.CELERY_BROKER) celery.conf.update(config.as_dict()) return celery celery = make_celery()

งาน / celery_worker.py

โมดูลนี้จำเป็นในการเริ่มต้นและกำหนดค่าเริ่มต้นของพนักงานขึ้นฉ่ายซึ่งจะทำงานในคอนเทนเนอร์ Docker แยกต่างหาก เริ่มต้นบริบทแอปพลิเคชัน Flask เพื่อให้สามารถเข้าถึงสภาพแวดล้อมเดียวกับแอปพลิเคชัน หากไม่จำเป็นก็สามารถลบบรรทัดเหล่านี้ออกได้อย่างปลอดภัย

from app import create_app app = create_app() app.app_context().push() from tasks import celery

api / __ init__.py

ถัดไปเป็นแพ็คเกจ API ซึ่งกำหนด REST API โดยใช้แพ็คเกจ Flask-Restful แอปของเราเป็นเพียงการสาธิตและจะมีจุดสิ้นสุดเพียงสองจุด:

• /process_data - เริ่มต้นการดำเนินการแบบยาวหลอกกับคนงานขึ้นฉ่ายและส่งคืน ID ของงานใหม่
• /tasks/ - ส่งคืนสถานะของงานตาม ID งาน

import time from flask import jsonify from flask_restful import Api, Resource from tasks import celery import config api = Api(prefix=config.API_PREFIX) class TaskStatusAPI(Resource): def get(self, task_id): task = celery.AsyncResult(task_id) return jsonify(task.result) class DataProcessingAPI(Resource): def post(self): task = process_data.delay() return {'task_id': task.id}, 200 @celery.task() def process_data(): time.sleep(60) # data processing endpoint api.add_resource(DataProcessingAPI, '/process_data') # task status endpoint api.add_resource(TaskStatusAPI, '/tasks/')

รุ่น / __ init__.py

ตอนนี้เราจะเพิ่มโมเดล SQLAlchemy สำหรับ User อ็อบเจ็กต์และโค้ดการเริ่มต้นเอ็นจินฐานข้อมูล User จะไม่ใช้ออบเจ็กต์โดยแอปสาธิตของเราในทางที่มีความหมาย แต่เราจำเป็นต้องใช้เพื่อให้แน่ใจว่าการย้ายฐานข้อมูลทำงานได้ดีและการรวม SQLAlchemy-Flask ได้รับการตั้งค่าอย่างถูกต้อง

import uuid from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy() class User(db.Model): id = db.Column(db.String(), primary_key=True, default=lambda: str(uuid.uuid4())) username = db.Column(db.String()) email = db.Column(db.String(), unique=True)

สังเกตว่า UUID ถูกสร้างขึ้นโดยอัตโนมัติเป็น ID อ็อบเจ็กต์โดยนิพจน์เริ่มต้นอย่างไร

app.py

สุดท้ายมาสร้างไฟล์แอปพลิเคชัน Flask หลักกัน

from flask import Flask logging.basicConfig(level=logging.DEBUG, format='[%(asctime)s]: {} %(levelname)s %(message)s'.format(os.getpid()), datefmt='%Y-%m-%d %H:%M:%S', handlers=[logging.StreamHandler()]) logger = logging.getLogger() def create_app(): logger.info(f'Starting app in {config.APP_ENV} environment') app = Flask(__name__) app.config.from_object('config') api.init_app(app) # initialize SQLAlchemy db.init_app(app) # define hello world page @app.route('/') def hello_world(): return 'Hello, World!' return app if __name__ == '__main__': app = create_app() app.run(host='0.0.0.0', debug=True)

เราอยู่ที่นี่:

• การกำหนดค่าการบันทึกพื้นฐานในรูปแบบที่เหมาะสมพร้อมรหัสเวลาระดับและกระบวนการ
• การกำหนดฟังก์ชันการสร้างแอป Flask ด้วยการเริ่มต้น API และ“ สวัสดีชาวโลก!” หน้า
• การกำหนดจุดเริ่มต้นเพื่อเรียกใช้แอปในช่วงเวลาการพัฒนา

wsgi.py

นอกจากนี้เราจำเป็นต้องมีโมดูลแยกต่างหากเพื่อเรียกใช้แอปพลิเคชัน Flask กับ Gunicorn มันจะมีเพียงสองบรรทัด:

from app import create_app app = create_app()

รหัสแอปพลิเคชันพร้อมแล้ว ขั้นตอนต่อไปของเราคือการสร้างการกำหนดค่า Docker

การสร้างคอนเทนเนอร์ Docker

แอปพลิเคชันของเราจะต้องใช้คอนเทนเนอร์ Docker หลายตัวเพื่อเรียกใช้:

1. คอนเทนเนอร์แอปพลิเคชันเพื่อให้บริการเพจที่มีเทมเพลตและแสดงจุดสิ้นสุด API เป็นความคิดที่ดีที่จะแยกฟังก์ชันทั้งสองนี้ในการผลิต แต่เราไม่มีหน้าเทมเพลตในแอปสาธิตของเรา คอนเทนเนอร์จะเรียกใช้เว็บเซิร์ฟเวอร์ Gunicorn ซึ่งจะสื่อสารกับ Flask ผ่านโปรโตคอล WSGI
2. ภาชนะสำหรับคนงานขึ้นฉ่ายเพื่อทำงานที่ยาวนาน นี่คือคอนเทนเนอร์แอปพลิเคชันเดียวกัน แต่มีคำสั่ง run แบบกำหนดเองเพื่อเปิด Celery แทน Gunicorn
3. คื่นฉ่ายตีภาชนะคล้ายกับข้างบน แต่สำหรับงานที่เรียกตามกำหนดเวลาปกติเช่นการลบบัญชีของผู้ใช้ที่ไม่เคยยืนยันอีเมลของตน
4. RabbitMQ ภาชนะ คื่นฉ่ายต้องการนายหน้าข้อความเพื่อสื่อสารระหว่างคนงานและแอปและจัดเก็บผลลัพธ์ของงาน RabbitMQ เป็นตัวเลือกทั่วไป แต่คุณสามารถใช้ Redis หรือ Kafka ได้เช่นกัน
5. ที่เก็บฐานข้อมูลด้วย PostgreSQL

วิธีง่ายๆในการจัดการคอนเทนเนอร์หลาย ๆ คอนเทนเนอร์คือการใช้ Docker Compose แต่ก่อนอื่นเราจะต้องสร้าง Dockerfile เพื่อสร้างอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชันของเรา มาใส่ไว้ในไดเรกทอรีโครงการ

โหนด js แสดง API ที่สงบ

FROM python:3.7.2 RUN pip install pipenv ADD . /flask-deploy WORKDIR /flask-deploy RUN pipenv install --system --skip-lock RUN pip install gunicorn[gevent] EXPOSE 5000 CMD gunicorn --worker-class gevent --workers 8 --bind 0.0.0.0:5000 wsgi:app --max-requests 10000 --timeout 5 --keep-alive 5 --log-level info

ไฟล์นี้แนะนำ Docker ให้:

• ติดตั้งการอ้างอิงทั้งหมดโดยใช้ Pipenv
• เพิ่มโฟลเดอร์ของแอปพลิเคชันลงในคอนเทนเนอร์
• แสดงพอร์ต TCP 5000 ไปยังโฮสต์
• ตั้งค่าคำสั่งเริ่มต้นเริ่มต้นของคอนเทนเนอร์เป็นการเรียก Gunicorn

เรามาคุยกันเพิ่มเติมว่าจะเกิดอะไรขึ้นในบรรทัดสุดท้าย รัน Gunicorn ระบุคลาสคนงานเป็น ระบาย . Gevent เป็น lib แบบพร้อมกันที่มีน้ำหนักเบาสำหรับการทำงานหลายอย่างพร้อมกันแบบร่วมมือกัน ให้ประสิทธิภาพที่เพิ่มขึ้นอย่างมากในการโหลดที่ถูกผูกไว้ของ I / O ทำให้การใช้งาน CPU ดีขึ้นเมื่อเทียบกับการทำงานหลายอย่างพร้อมกันของระบบปฏิบัติการสำหรับเธรด --workers พารามิเตอร์คือจำนวนกระบวนการของผู้ปฏิบัติงาน เป็นความคิดที่ดีที่จะตั้งค่าให้เท่ากับจำนวนคอร์บนเซิร์ฟเวอร์

เมื่อเรามี Dockerfile สำหรับแอปพลิเคชันคอนเทนเนอร์แล้วเราสามารถสร้าง docker-compose.yml ซึ่งจะกำหนดคอนเทนเนอร์ทั้งหมดที่แอปพลิเคชันจะต้องใช้ในการรัน

version: '3' services: broker-rabbitmq: image: 'rabbitmq:3.7.14-management' environment: - RABBITMQ_DEFAULT_USER=rabbit_user - RABBITMQ_DEFAULT_PASS=rabbit_password db-postgres: image: 'postgres:11.2' environment: - POSTGRES_USER=db_user - POSTGRES_PASSWORD=db_password migration: build: . environment: - APP_ENV=${APP_ENV} command: flask db upgrade depends_on: - db-postgres api: build: . ports: - '5000:5000' environment: - APP_ENV=${APP_ENV} depends_on: - broker-rabbitmq - db-postgres - migration api-worker: build: . command: celery worker --workdir=. -A tasks.celery --loglevel=info environment: - APP_ENV=${APP_ENV} depends_on: - broker-rabbitmq - db-postgres - migration api-beat: build: . command: celery beat -A tasks.celery --loglevel=info environment: - APP_ENV=${APP_ENV} depends_on: - broker-rabbitmq - db-postgres - migration

เรากำหนดบริการดังต่อไปนี้:

• broker-rabbitmq - คอนเทนเนอร์นายหน้าข้อความ RabbitMQ ข้อมูลรับรองการเชื่อมต่อถูกกำหนดโดยตัวแปรสภาพแวดล้อม
• db-postgres - คอนเทนเนอร์ PostgreSQL และข้อมูลประจำตัว
• migration - คอนเทนเนอร์แอปที่จะทำการย้ายฐานข้อมูลด้วย Flask-Migrate และออก คอนเทนเนอร์ API ขึ้นอยู่กับมันและจะทำงานในภายหลัง
• api - คอนเทนเนอร์แอปพลิเคชันหลัก
• api-worker และ api-beat - คอนเทนเนอร์ที่ใช้คนงานขึ้นฉ่ายสำหรับงานที่ได้รับจาก API และงานตามกำหนดเวลา

แต่ละแอปคอนเทนเนอร์จะได้รับ APP_ENV ตัวแปรจาก docker-compose up คำสั่ง

เมื่อเรามีแอปพลิเคชันทั้งหมดพร้อมแล้วให้วางไว้ใน GitHub ซึ่งจะช่วยให้เราใช้งานโค้ดบนเซิร์ฟเวอร์ได้

git add * git commit -a -m 'Initial commit' git remote add origin [email protected] :your-name/flask-deploy.git git push -u origin master

การกำหนดค่าเซิร์ฟเวอร์

ตอนนี้โค้ดของเราอยู่ใน GitHub และสิ่งที่เหลือก็คือการกำหนดค่าเซิร์ฟเวอร์เริ่มต้นและทำให้แอปพลิเคชันใช้งานได้ ในกรณีของฉันเซิร์ฟเวอร์เป็นอินสแตนซ์ AWS ที่ใช้ AMI Linux สำหรับรสชาติของ Linux อื่น ๆ คำแนะนำอาจแตกต่างกันเล็กน้อย ฉันยังถือว่าเซิร์ฟเวอร์มีที่อยู่ IP ภายนอกอยู่แล้ว DNS ถูกกำหนดค่าด้วยระเบียนที่ชี้ไปที่ IP นี้และมีการออกใบรับรอง SSL สำหรับโดเมน

เคล็ดลับความปลอดภัย: อย่าลืมอนุญาตพอร์ต 80 และ 443 สำหรับการรับส่งข้อมูล HTTP (S) พอร์ต 22 สำหรับ SSH ในคอนโซลการโฮสต์ของคุณ (หรือใช้ iptables) และปิดการเข้าถึงพอร์ตอื่น ๆ จากภายนอก! อย่าลืมทำเช่นเดียวกันกับไฟล์ IPv6 มาตรการ!

โค้ดตัวอย่าง php rest api

การติดตั้งการอ้างอิง

ขั้นแรกเราต้องใช้ Nginx และ Docker ที่ทำงานบนเซิร์ฟเวอร์รวมถึง Git เพื่อดึงโค้ด เข้าสู่ระบบผ่าน SSH และใช้ตัวจัดการแพ็คเกจเพื่อติดตั้ง

sudo yum install -y docker docker-compose nginx git

การกำหนดค่า Nginx

ขั้นตอนต่อไปคือการกำหนดค่า Nginx หลัก nginx.conf ไฟล์การกำหนดค่ามักจะดีเหมือนเดิม อย่างไรก็ตามอย่าลืมตรวจสอบว่าเหมาะสมกับความต้องการของคุณหรือไม่ สำหรับแอปของเราเราจะสร้างไฟล์การกำหนดค่าใหม่ใน conf.d โฟลเดอร์ การกำหนดค่าระดับบนสุดมีคำสั่งให้รวม .conf ทั้งหมด ไฟล์จากมัน

เป็นรูปแบบองค์ประกอบหรือหลักการ

cd /etc/nginx/conf.d sudo vim flask-deploy.conf

นี่คือไฟล์การกำหนดค่าไซต์ขวดสำหรับ Nginx รวมแบตเตอรี่ มีคุณสมบัติดังต่อไปนี้:

1. กำหนดค่า SSL แล้ว คุณควรมีใบรับรองที่ถูกต้องสำหรับโดเมนของคุณเช่น มาเข้ารหัสกัน ใบรับรอง.
2. www.your-site.com คำขอจะเปลี่ยนเส้นทางไปที่ your-site.com
3. คำขอ HTTP ถูกเปลี่ยนเส้นทางไปยังพอร์ต HTTPS ที่ปลอดภัย
4. Reverse proxy ถูกกำหนดค่าให้ส่งคำขอไปยังโลคัลพอร์ต 5000
5. Nginx ให้บริการไฟล์คงที่จากโฟลเดอร์ในเครื่อง

server { listen 80; listen 443; server_name www.your-site.com; # check your certificate path! ssl_certificate /etc/nginx/ssl/your-site.com/fullchain.crt; ssl_certificate_key /etc/nginx/ssl/your-site.com/server.key; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_ciphers HIGH:!aNULL:!MD5; # redirect to non-www domain return 301 https://your-site.com$request_uri; } # HTTP to HTTPS redirection server { listen 80; server_name your-site.com; return 301 https://your-site.com$request_uri; } server { listen 443 ssl; # check your certificate path! ssl_certificate /etc/nginx/ssl/your-site.com/fullchain.crt; ssl_certificate_key /etc/nginx/ssl/your-site.com/server.key; ssl_protocols TLSv1 TLSv1.1 TLSv1.2; ssl_ciphers HIGH:!aNULL:!MD5; # affects the size of files user can upload with HTTP POST client_max_body_size 10M; server_name your-site.com; location / { include /etc/nginx/mime.types; root /home/ec2-user/flask-deploy/static; # if static file not found - pass request to Flask try_files $uri @flask; } location @flask { add_header 'Access-Control-Allow-Origin' '*' always; add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, OPTIONS'; add_header 'Access-Control-Allow-Headers' 'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization'; add_header 'Access-Control-Expose-Headers' 'Content-Length,Content-Range'; proxy_read_timeout 10; proxy_send_timeout 10; send_timeout 60; resolver_timeout 120; client_body_timeout 120; # set headers to pass request info to Flask proxy_set_header Host $http_host; proxy_set_header X-Forwarded-Proto $scheme; proxy_set_header X-Forwarded-For $remote_addr; proxy_redirect off; proxy_pass http://127.0.0.1:5000$uri; } }

หลังจากแก้ไขไฟล์แล้วให้เรียกใช้ sudo nginx -s reload และดูว่ามีข้อผิดพลาดหรือไม่

การตั้งค่าข้อมูลรับรอง GitHub

เป็นแนวทางปฏิบัติที่ดีที่จะมีบัญชี VCS 'การปรับใช้' แยกต่างหากสำหรับการปรับใช้โครงการและระบบ CI / CD ด้วยวิธีนี้คุณจะไม่เสี่ยงด้วยการเปิดเผยข้อมูลรับรองบัญชีของคุณเอง เพื่อปกป้องที่เก็บโปรเจ็กต์เพิ่มเติมคุณยังสามารถ จำกัด สิทธิ์ของบัญชีดังกล่าวให้เข้าถึงแบบอ่านอย่างเดียวได้ สำหรับที่เก็บ GitHub คุณจะต้องมีบัญชีองค์กรเพื่อดำเนินการดังกล่าว ในการปรับใช้แอปพลิเคชันสาธิตของเราเราจะสร้างคีย์สาธารณะบนเซิร์ฟเวอร์และลงทะเบียนใน GitHub เพื่อเข้าถึงโครงการของเราโดยไม่ต้องป้อนข้อมูลรับรองทุกครั้ง

ในการสร้างคีย์ SSH ใหม่ให้เรียกใช้:

cd ~/.ssh ssh-keygen -b 2048 -t rsa -f id_rsa.pub -q -N '' -C 'deploy'

จากนั้นเข้าสู่ระบบ GitHub และ เพิ่มคีย์สาธารณะของคุณ จาก ~/.ssh/id_rsa.pub ในการตั้งค่าบัญชี

การปรับใช้แอพ

ขั้นตอนสุดท้ายค่อนข้างตรงไปตรงมาเราต้องรับรหัสแอปพลิเคชันจาก GitHub และเริ่มคอนเทนเนอร์ทั้งหมดด้วย Docker Compose

cd ~ git clone https://github.com/your-name/flask-deploy.git git checkout master APP_ENV=Production docker-compose up -d

อาจเป็นความคิดที่ดีที่จะละ -d (ซึ่งเริ่มต้นคอนเทนเนอร์ในโหมดแยกออก) สำหรับการรันครั้งแรกเพื่อดูผลลัพธ์ของแต่ละคอนเทนเนอร์ในเทอร์มินัลและตรวจสอบปัญหาที่อาจเกิดขึ้น อีกทางเลือกหนึ่งคือการตรวจสอบแต่ละคอนเทนเนอร์ด้วย docker logs หลังจากนั้น มาดูกันว่าคอนเทนเนอร์ทั้งหมดของเราทำงานด้วย docker ps. หรือไม่

เยี่ยมมาก คอนเทนเนอร์ทั้งห้าพร้อมใช้งานแล้ว นักเทียบท่าเขียนชื่อคอนเทนเนอร์ที่กำหนดโดยอัตโนมัติตามบริการที่ระบุใน docker-compose.yml ในที่สุดก็ถึงเวลาทดสอบวิธีการทำงานของการกำหนดค่าทั้งหมด! เป็นการดีที่สุดที่จะทำการทดสอบจากเครื่องภายนอกเพื่อให้แน่ใจว่าเซิร์ฟเวอร์มีการตั้งค่าเครือข่ายที่ถูกต้อง

# test HTTP protocol, you should get a 301 response curl your-site.com # HTTPS request should return our Hello World message curl https://your-site.com # and nginx should correctly send test static file: curl https://your-site.com/hello-world.txt

แค่นั้นแหละ. เรามีการกำหนดค่าที่เรียบง่าย แต่พร้อมใช้งานจริงสำหรับแอปของเราที่ทำงานบนอินสแตนซ์ AWS หวังว่าจะช่วยให้คุณเริ่มสร้างแอปพลิเคชันในชีวิตจริงได้อย่างรวดเร็วและหลีกเลี่ยงข้อผิดพลาดทั่วไป! รหัสที่สมบูรณ์สามารถใช้ได้ บนที่เก็บ GitHub .

สรุป

ในบทความนี้เราได้กล่าวถึงแนวทางปฏิบัติที่ดีที่สุดบางประการในการจัดโครงสร้างกำหนดค่าบรรจุภัณฑ์และการปรับใช้แอปพลิเคชัน Flask ในการผลิต นี่เป็นหัวข้อที่ใหญ่มากซึ่งไม่สามารถครอบคลุมได้ทั้งหมดในบล็อกโพสต์เดียว นี่คือรายการคำถามสำคัญที่เราไม่ได้กล่าวถึง:

บทความนี้ไม่ครอบคลุมถึง:

• การผสานรวมอย่างต่อเนื่องและการปรับใช้อย่างต่อเนื่อง
• การทดสอบอัตโนมัติ
• บันทึกการจัดส่ง
• การตรวจสอบ API
• การขยายแอปพลิเคชันไปยังเซิร์ฟเวอร์หลายเครื่อง
• การป้องกันข้อมูลรับรองในซอร์สโค้ด

อย่างไรก็ตามคุณสามารถเรียนรู้วิธีทำได้โดยใช้แหล่งข้อมูลที่ยอดเยี่ยมอื่น ๆ ในบล็อกนี้ ตัวอย่างเช่นในการสำรวจการบันทึกโปรดดู Python Logging: บทช่วยสอนเชิงลึก หรือสำหรับภาพรวมทั่วไปเกี่ยวกับ CI / CD และการทดสอบอัตโนมัติโปรดดู วิธีสร้างไปป์ไลน์การปรับใช้เริ่มต้นที่มีประสิทธิภาพ . ฉันปล่อยให้การใช้สิ่งเหล่านี้เป็นแบบฝึกหัดสำหรับคุณผู้อ่าน

ขอบคุณที่อ่าน!

ปัญญาธุรกิจกับปัญญาประดิษฐ์

ทำความเข้าใจพื้นฐาน

แอปพลิเคชั่น Flask คืออะไร?

แอปพลิเคชัน Flask เป็นแอปพลิเคชัน Python ที่สร้างขึ้นสำหรับเว็บที่มีไลบรารี Flask

ไหนดีกว่า Flask หรือ Django?

ทั้งสองเฟรมเวิร์กเหมาะสำหรับงานที่เกี่ยวข้องกับเว็บที่หลากหลาย Flask มักใช้ในการสร้างเว็บเซอร์วิสที่ไม่ใช่เว็บไซต์แบบเต็มรูปแบบและขึ้นชื่อเรื่องความยืดหยุ่น

Gunicorn คืออะไร?

Gunicorn เป็นเซิร์ฟเวอร์ Python WSGI HTTP กรณีการใช้งานทั่วไปคือให้บริการแอปพลิเคชัน Flask หรือ Django Python ผ่านอินเทอร์เฟซ WSGI ในการผลิต

คื่นฉ่ายคืออะไรและทำไมถึงใช้กับ Flask?

เว็บเซิร์ฟเวอร์เช่น Flask ไม่เหมาะสำหรับงานที่ต้องใช้เวลานานเช่นการประมวลผลวิดีโอ คื่นฉ่ายเป็นคิวงานสำหรับจัดการงานดังกล่าวในลักษณะที่สะดวกและไม่ตรงกัน ข้อมูลงานจะถูกเก็บไว้ในเครื่องมือจัดเก็บข้อมูลส่วนหลังที่รองรับเช่น RabbitMQ หรือ Redis

ทำไมต้องใช้ Docker Compose

Docker Compose เป็นเครื่องมือที่สะดวกสำหรับนักเทียบท่าซึ่งช่วยให้สามารถทำงานกับคอนเทนเนอร์ในระดับที่สูงขึ้นของนามธรรมโดยการกำหนดบริการ นอกจากนี้ยังจัดการสถานการณ์ทั่วไปของการเริ่มต้นและการหยุดคอนเทนเนอร์

ทำไมเราต้องมีเว็บเซิร์ฟเวอร์ Nginx สำหรับ Flask?

แม้ว่า Gunicorn จะเหมาะกับการเป็นแอปพลิเคชันเซิร์ฟเวอร์ แต่ก็ไม่ควรที่จะให้มันหันหน้าเข้าหาอินเทอร์เน็ตเนื่องจากข้อพิจารณาด้านความปลอดภัยและข้อ จำกัด ในการจัดการคำขอทางเว็บ รูปแบบทั่วไปคือการใช้ Nginx เป็น reverse-proxy หน้า Gunicorn สำหรับการกำหนดเส้นทางการร้องขอระหว่างบริการ

PostgreSQL เป็นทางเลือกที่ดีเมื่อใด

PostgreSQL เป็นเอ็นจิ้นฐานข้อมูลเชิงสัมพันธ์ประสิทธิภาพสูงที่มีปลั๊กอินและไลบรารีมากมายสำหรับภาษาโปรแกรมหลักทั้งหมด เป็นทางเลือกที่สมบูรณ์แบบหากโครงการของคุณไม่ว่าจะเล็กหรือใหญ่เพียงแค่ต้องการฐานข้อมูล นอกจากนี้ยังเป็นโอเพ่นซอร์สและฟรี