उदाहरण द्वारा फ्लास्क - पोस्टग्रेज, SQLAlchemy, और एलेम्बिक सेट करना

इस भाग में हम डेटाबेस माइग्रेशन को संभालने के लिए हमारे शब्द गणना के परिणामों के साथ-साथ SQLAlchemy, एक ऑब्जेक्ट रिलेशनल मैपर और एलेम्बिक के परिणामों को संग्रहीत करने के लिए एक पोस्टग्रेज डेटाबेस स्थापित करने जा रहे हैं।

मुफ़्त बोनस: एक निःशुल्क फ्लास्क + पायथन वीडियो ट्यूटोरियल तक पहुंच प्राप्त करने के लिए यहां क्लिक करें जो आपको दिखाता है कि फ्लास्क वेब ऐप कैसे बनाया जाता है, चरण-दर-चरण।

अपडेट:

02/09/2020:पायथन संस्करण 3.8.1 के साथ-साथ Psycopg2, फ्लास्क-SQLAlchemy, और फ्लास्क-माइग्रेट के नवीनतम संस्करणों में अपग्रेड किया गया। विवरण के लिए नीचे देखें। फ्लास्क-माइग्रेट आंतरिक इंटरफ़ेस के परिवर्तन के कारण स्पष्ट रूप से फ्लास्क-स्क्रिप्ट को स्थापित और उपयोग करें।
03/22/2016:पाइथॉन संस्करण 3.5.1 और साथ ही Psycopg2, Flask-SQLAlchemy, और Flask-Migrate के नवीनतम संस्करणों में अपग्रेड किया गया। विवरण के लिए नीचे देखें।
02/22/2015:जोड़ा गया पायथन 3 समर्थन।

याद रखें:यहां हम निर्माण कर रहे हैं - एक फ्लास्क ऐप जो किसी दिए गए URL के टेक्स्ट के आधार पर शब्द-आवृत्ति जोड़े की गणना करता है।

भाग एक:एक स्थानीय विकास वातावरण स्थापित करें और फिर हेरोकू पर एक मंचन और एक उत्पादन वातावरण दोनों को तैनात करें।
भाग दो:माइग्रेशन को संभालने के लिए SQLAlchemy और एलेम्बिक के साथ PostgreSQL डेटाबेस सेट करें। (वर्तमान )
भाग तीन:स्क्रैप करने के लिए बैक-एंड लॉजिक जोड़ें और फिर अनुरोधों, ब्यूटीफुल सूप और नेचुरल लैंग्वेज टूलकिट (एनएलटीके) लाइब्रेरी का उपयोग करके वेबपेज से शब्द गणना को संसाधित करें।
भाग चार:पाठ प्रसंस्करण को संभालने के लिए एक रेडिस कार्य कतार लागू करें।
भाग पांच:यह देखने के लिए कि अनुरोध संसाधित किया गया है या नहीं, बैक-एंड को लगातार मतदान करने के लिए फ्रंट-एंड पर एंगुलर सेट करें।
भाग छह:Heroku पर स्टेजिंग सर्वर पर पुश करें - Redis की स्थापना और एक ही Dyno पर दो प्रक्रियाओं (वेब और कार्यकर्ता) को चलाने के तरीके का विवरण देना।
भाग सात:फ़्रंट-एंड को अधिक उपयोगकर्ता-अनुकूल बनाने के लिए अपडेट करें।
भाग आठ:JavaScript और D3 का उपयोग करके आवृत्ति वितरण चार्ट प्रदर्शित करने के लिए एक कस्टम कोणीय निर्देश बनाएं।

<चिह्न>कोड चाहिए? इसे रेपो से प्राप्त करें।

आवश्यकताएं स्थापित करें

इस भाग में प्रयुक्त उपकरण:

पोस्टग्रेएसक्यूएल (11.6)
Psycopg2 (2.8.4) - पोस्टग्रेज के लिए एक पायथन एडेप्टर
फ्लास्क-SQLAlchemy (2.4.1) - फ्लास्क एक्सटेंशन जो SQLAlchemy समर्थन प्रदान करता है
फ्लास्क-माइग्रेट (2.5.2) - एक्सटेंशन जो एलेम्बिक के माध्यम से SQLAlchemy डेटाबेस माइग्रेशन का समर्थन करता है

आरंभ करने के लिए, अपने स्थानीय कंप्यूटर पर पोस्टग्रेज़ स्थापित करें, यदि आपके पास यह पहले से नहीं है। चूंकि हरोकू पोस्टग्रेज का उपयोग करता है, इसलिए हमारे लिए उसी डेटाबेस पर स्थानीय रूप से विकसित करना अच्छा होगा। यदि आपके पास Postgres स्थापित नहीं है, तो Postgres.app Mac OS X उपयोगकर्ताओं के लिए उठने और चलने का एक आसान तरीका है। अधिक जानकारी के लिए डाउनलोड पृष्ठ देखें।

एक बार जब आप Postgres स्थापित और चालू कर लेते हैं, तो wordcount_dev . नामक एक डेटाबेस बनाएं हमारे स्थानीय विकास डेटाबेस के रूप में उपयोग करने के लिए:

$ psql
# create database wordcount_dev;
CREATE DATABASE
# \q

फ्लास्क ऐप के भीतर हमारे नए बनाए गए डेटाबेस का उपयोग करने के लिए हमें कुछ चीजें स्थापित करने की आवश्यकता है:

$ cd flask-by-example

<ब्लॉकक्वॉट>

cd निर्देशिका में प्रवेश करने से वर्चुअल वातावरण को सक्रिय करना चाहिए और .env . में पाए जाने वाले पर्यावरण चर सेट करना चाहिए autoenv के माध्यम से फ़ाइल, जिसे हमने भाग 1 में सेट किया है।

$ python -m pip install psycopg2==2.8.4 Flask-SQLAlchemy===2.4.1 Flask-Migrate==2.5.2
$ python -m pip freeze > requirements.txt

<ब्लॉकक्वॉट>

यदि आप OS X पर हैं और psycopg2 को स्थापित करने में समस्या आ रही है तो इस स्टैक ओवरफ़्लो लेख को देखें।

आपको psycopg2-binary स्थापित करने की आवश्यकता हो सकती है psycopg2 . के बजाय अगर आपकी स्थापना विफल हो जाती है।

कॉन्फ़िगरेशन अपडेट करें

जोड़ें SQLALCHEMY_DATABASE_URI Config() . के लिए फ़ील्ड आपके config.py . में कक्षा विकास (स्थानीय), मंचन और उत्पादन में नव निर्मित डेटाबेस का उपयोग करने के लिए अपने ऐप को सेट करने के लिए फ़ाइल:

import os

class Config(object):
    ...
    SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL']

आपका config.py फ़ाइल अब इस तरह दिखनी चाहिए:

import os
basedir = os.path.abspath(os.path.dirname(__file__))


class Config(object):
    DEBUG = False
    TESTING = False
    CSRF_ENABLED = True
    SECRET_KEY = 'this-really-needs-to-be-changed'
    SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL']


class ProductionConfig(Config):
    DEBUG = False


class StagingConfig(Config):
    DEVELOPMENT = True
    DEBUG = True


class DevelopmentConfig(Config):
    DEVELOPMENT = True
    DEBUG = True


class TestingConfig(Config):
    TESTING = True

अब जब हमारा कॉन्फिगरेशन हमारे ऐप में लोड हो जाएगा तो उपयुक्त डेटाबेस भी इससे कनेक्ट हो जाएगा।

जिस तरह से हमने पिछली पोस्ट में एक पर्यावरण चर जोड़ा था, उसी तरह हम एक DATABASE_URL जोड़ने जा रहे हैं चर। इसे टर्मिनल में चलाएँ:

$ export DATABASE_URL="postgresql:///wordcount_dev"

और फिर उस लाइन को अपने .env . में जोड़ें फ़ाइल।

आपके app.py . में फ़ाइल आयात SQLAlchemy और डेटाबेस से कनेक्ट करें:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import os


app = Flask(__name__)
app.config.from_object(os.environ['APP_SETTINGS'])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

from models import Result


@app.route('/')
def hello():
    return "Hello World!"


@app.route('/<name>')
def hello_name(name):
    return "Hello {}!".format(name)


if __name__ == '__main__':
    app.run()

डेटा मॉडल

एक models.py . जोड़कर एक बुनियादी मॉडल सेट करें फ़ाइल:

from app import db
from sqlalchemy.dialects.postgresql import JSON


class Result(db.Model):
    __tablename__ = 'results'

    id = db.Column(db.Integer, primary_key=True)
    url = db.Column(db.String())
    result_all = db.Column(JSON)
    result_no_stop_words = db.Column(JSON)

    def __init__(self, url, result_all, result_no_stop_words):
        self.url = url
        self.result_all = result_all
        self.result_no_stop_words = result_no_stop_words

    def __repr__(self):
        return '<id {}>'.format(self.id)

यहां हमने शब्द गणना के परिणामों को संग्रहीत करने के लिए एक तालिका बनाई है।

हम सबसे पहले अपने app.py . में बनाए गए डेटाबेस कनेक्शन को आयात करते हैं फ़ाइल और साथ ही JSON SQLAlchemy की PostgreSQL बोलियों से। JSON कॉलम Postgres के लिए बिल्कुल नए हैं और SQLAlchemy द्वारा समर्थित प्रत्येक डेटाबेस में उपलब्ध नहीं हैं, इसलिए हमें इसे विशेष रूप से आयात करने की आवश्यकता है।

इसके बाद हमने एक Result() बनाया वर्ग और इसे results . का एक तालिका नाम सौंपा . फिर हम उन विशेषताओं को सेट करते हैं जिन्हें हम परिणाम के लिए संग्रहीत करना चाहते हैं-

id हमने जो परिणाम संग्रहीत किए हैं उनमें से
url कि हमने शब्दों की गिनती
उन शब्दों की पूरी सूची जिन्हें हमने गिना है
उन शब्दों की सूची जिन्हें हमने माइनस स्टॉप वर्ड्स (इस पर बाद में और अधिक) गिना है

फिर हमने एक __init__() . बनाया पहली बार जब हम एक नया परिणाम बनाते हैं और अंत में, एक __repr__() जब हम इसके लिए क्वेरी करते हैं तो वस्तु का प्रतिनिधित्व करने की विधि।

स्थानीय प्रवास

हम डेटाबेस के स्कीमा को अपडेट करने के लिए डेटाबेस माइग्रेशन को प्रबंधित करने के लिए एलेम्बिक का उपयोग करने जा रहे हैं, जो फ्लास्क-माइग्रेट का हिस्सा है।

<ब्लॉकक्वॉट>

नोट: फ्लास्क-माइग्रेट फ्लास्क के नए सीएलआई टूल का उपयोग करता है। हालाँकि, यह आलेख फ्लास्क-स्क्रिप्ट द्वारा प्रदान किए गए इंटरफ़ेस का उपयोग करता है, जिसका उपयोग पहले फ्लास्क-माइग्रेट द्वारा किया गया था। इसका उपयोग करने के लिए, आपको इसके माध्यम से इसे स्थापित करने की आवश्यकता है:

$ python -m pip install Flask-Script==2.0.6
$ python -m pip freeze > requirements.txt

manage.py . नामक एक नई फ़ाइल बनाएं :

import os
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand

from app import app, db


app.config.from_object(os.environ['APP_SETTINGS'])

migrate = Migrate(app, db)
manager = Manager(app)

manager.add_command('db', MigrateCommand)


if __name__ == '__main__':
    manager.run()

फ्लास्क-माइग्रेट का उपयोग करने के लिए हमने Manager . आयात किया साथ ही Migrate और MigrateCommand हमारे manage.py . को फ़ाइल। हमने app . भी आयात किया है और db इसलिए हमारे पास स्क्रिप्ट के भीतर से उन तक पहुंच है।

सबसे पहले, हम अपने पर्यावरण को प्राप्त करने के लिए अपना कॉन्फ़िगरेशन सेट करते हैं - पर्यावरण चर के आधार पर - एक माइग्रेट इंस्टेंस बनाया, जिसमें app और db तर्क के रूप में, और एक Manager सेट अप करें Manager initialize को प्रारंभ करने के लिए आदेश हमारे ऐप के लिए उदाहरण। अंत में, हमने db . जोड़ा Manager . को आदेश ताकि हम कमांड लाइन से माइग्रेशन चला सकें।

माइग्रेशन चलाने के लिए एलेम्बिक इनिशियलाइज़ करें:

$ python manage.py db init
  Creating directory /flask-by-example/migrations ... done
  Creating directory /flask-by-example/migrations/versions ... done
  Generating /flask-by-example/migrations/alembic.ini ... done
  Generating /flask-by-example/migrations/env.py ... done
  Generating /flask-by-example/migrations/README ... done
  Generating /flask-by-example/migrations/script.py.mako ... done
  Please edit configuration/connection/logging settings in
  '/flask-by-example/migrations/alembic.ini' before proceeding.

डेटाबेस इनिशियलाइज़ेशन चलाने के बाद आपको प्रोजेक्ट में "माइग्रेशन" नामक एक नया फ़ोल्डर दिखाई देगा। यह परियोजना के खिलाफ माइग्रेशन चलाने के लिए एलेम्बिक के लिए आवश्यक सेटअप रखता है। "माइग्रेशन" के अंदर आप देखेंगे कि इसमें "संस्करण" नामक एक फ़ोल्डर है, जिसमें माइग्रेशन स्क्रिप्ट बनाई गई हैं।

आइए migrate . चलाकर अपना पहला माइग्रेशन बनाएं आदेश।

$ python manage.py db migrate
  INFO  [alembic.runtime.migration] Context impl PostgresqlImpl.
  INFO  [alembic.runtime.migration] Will assume transactional DDL.
  INFO  [alembic.autogenerate.compare] Detected added table 'results'
    Generating /flask-by-example/migrations/versions/63dba2060f71_.py
    ... done

अब आप देखेंगे कि आपके "संस्करण" फ़ोल्डर में एक माइग्रेशन फ़ाइल है। यह फ़ाइल मॉडल के आधार पर एलेम्बिक द्वारा स्वतः उत्पन्न होती है। आप इस फ़ाइल को स्वयं उत्पन्न (या संपादित) कर सकते हैं; हालांकि, ज्यादातर मामलों में ऑटो-जेनरेट की गई फाइल काम करेगी।

अब हम db upgrade . का उपयोग करके डेटाबेस में अपग्रेड लागू करेंगे आदेश:

$ python manage.py db upgrade
  INFO  [alembic.runtime.migration] Context impl PostgresqlImpl.
  INFO  [alembic.runtime.migration] Will assume transactional DDL.
  INFO  [alembic.runtime.migration] Running upgrade  -> 63dba2060f71, empty message

डेटाबेस अब हमारे ऐप में उपयोग करने के लिए तैयार है:

$ psql
# \c wordcount_dev
You are now connected to database "wordcount_dev" as user "michaelherman".
# \dt

                List of relations
 Schema |      Name       | Type  |     Owner
--------+-----------------+-------+---------------
 public | alembic_version | table | michaelherman
 public | results         | table | michaelherman
(2 rows)

# \d results
                                     Table "public.results"
        Column        |       Type        |                      Modifiers
----------------------+-------------------+------------------------------------------------------
 id                   | integer           | not null default nextval('results_id_seq'::regclass)
 url                  | character varying |
 result_all           | json              |
 result_no_stop_words | json              |
Indexes:
    "results_pkey" PRIMARY KEY, btree (id)

रिमोट माइग्रेशन

अंत में, आइए हरोकू पर डेटाबेस में माइग्रेशन लागू करें। सबसे पहले, हालांकि, हमें स्टेजिंग और प्रोडक्शन डेटाबेस के विवरण को config.py में जोड़ना होगा। फ़ाइल।

यह जाँचने के लिए कि क्या हमारे पास स्टेजिंग सर्वर रन पर एक डेटाबेस सेट है:

$ heroku config --app wordcount-stage
=== wordcount-stage Config Vars
APP_SETTINGS: config.StagingConfig

<ब्लॉकक्वॉट>

wordcount-stage . को बदलना सुनिश्चित करें अपने स्टेजिंग ऐप के नाम के साथ।

चूंकि हमें डेटाबेस पर्यावरण चर नहीं दिखाई देता है, इसलिए हमें स्टेजिंग सर्वर में पोस्टग्रेज एडऑन जोड़ने की जरूरत है। ऐसा करने के लिए, निम्न आदेश चलाएँ:

$ heroku addons:create heroku-postgresql:hobby-dev --app wordcount-stage
  Creating postgresql-cubic-86416... done, (free)
  Adding postgresql-cubic-86416 to wordcount-stage... done
  Setting DATABASE_URL and restarting wordcount-stage... done, v8
  Database has been created and is available
   ! This database is empty. If upgrading, you can transfer
   ! data from another database with pg:copy
  Use `heroku addons:docs heroku-postgresql` to view documentation.

<ब्लॉकक्वॉट>

hobby-dev Heroku Postgres एडऑन का फ्री टियर है।

अब जब हम heroku config --app wordcount-stage run चलाते हैं फिर से हमें डेटाबेस के लिए कनेक्शन सेटिंग्स को देखना चाहिए:

=== wordcount-stage Config Vars
APP_SETTINGS: config.StagingConfig
DATABASE_URL: postgres://azrqiefezenfrg:Zti5fjSyeyFgoc-U-yXnPrXHQv@ec2-54-225-151-64.compute-1.amazonaws.com:5432/d2kio2ubc804p7

आगे हमें उन परिवर्तनों को करने की आवश्यकता है जो आपने git में किए हैं और अपने स्टेजिंग सर्वर पर पुश करें:

$ git push stage master

हमारे द्वारा बनाए गए माइग्रेशन को heroku run . का उपयोग करके अपने स्टेजिंग डेटाबेस को माइग्रेट करने के लिए चलाएं आदेश:

$ heroku run python manage.py db upgrade --app wordcount-stage
  Running python manage.py db upgrade on wordcount-stage... up, run.5677
  INFO  [alembic.runtime.migration] Context impl PostgresqlImpl.
  INFO  [alembic.runtime.migration] Will assume transactional DDL.
  INFO  [alembic.runtime.migration] Running upgrade  -> 63dba2060f71, empty message

<ब्लॉकक्वॉट>

ध्यान दें कि हमने केवल upgrade कैसे चलाया , नहीं init या migrate पहले की तरह आदेश। हमारे पास पहले से ही हमारी माइग्रेशन फ़ाइल सेट अप है और जाने के लिए तैयार है; हमें इसे हरोकू डेटाबेस के विरुद्ध लागू करने की आवश्यकता है।

आइए अब उत्पादन के लिए भी ऐसा ही करें।

हेरोकू पर अपने प्रोडक्शन ऐप के लिए डेटाबेस सेट करें, ठीक वैसे ही जैसे आपने स्टेजिंग के लिए किया था:heroku addons:create heroku-postgresql:hobby-dev --app wordcount-pro
अपने परिवर्तनों को अपनी उत्पादन साइट पर पुश करें:git push pro master ध्यान दें कि आपको कॉन्फ़िग फ़ाइल में कोई बदलाव नहीं करना है - यह नए बनाए गए DATABASE_URL के आधार पर डेटाबेस को सेट कर रहा है पर्यावरण चर।
माइग्रेशन लागू करें:heroku run python manage.py db upgrade --app wordcount-pro

अब हमारी स्टेजिंग और प्रोडक्शन साइट्स दोनों ने अपने डेटाबेस सेट कर लिए हैं और माइग्रेट हो गए हैं - और जाने के लिए तैयार हैं!

<ब्लॉकक्वॉट>

जब आप उत्पादन डेटाबेस में एक नया माइग्रेशन लागू करते हैं, तो डाउन टाइम हो सकता है। यदि यह एक समस्या है, तो आप "अनुयायी" (आमतौर पर दास के रूप में जाना जाता है) डेटाबेस जोड़कर डेटाबेस प्रतिकृति सेट कर सकते हैं। इस पर अधिक जानकारी के लिए, आधिकारिक हरोकू दस्तावेज़ देखें।

निष्कर्ष

भाग 2 के लिए बस इतना ही। यदि आप फ्लास्क में गहरी खुदाई करना चाहते हैं, तो हमारी साथ में दी गई वीडियो श्रृंखला देखें:

भाग 3 में हम शब्द गणना कार्यक्षमता का निर्माण करने जा रहे हैं और इसे लंबे समय तक चलने वाले शब्द गणना प्रसंस्करण से निपटने के लिए कार्य कतार में भेज दिया है।

फिर मिलते हैं। चीयर्स!

यह स्टार्टअप एडमोंटन के सह-संस्थापक कैम लिंके और रियल पायथन के लोगों के बीच एक सहयोग टुकड़ा है।