अपने Django प्रोजेक्ट को हरोकू में माइग्रेट करना

इस ट्यूटोरियल में, हम एक साधारण स्थानीय Django प्रोजेक्ट लेंगे, जो एक MySQL डेटाबेस द्वारा समर्थित है, और इसे हरोकू पर चलाने के लिए परिवर्तित करेगा। Amazon S3 का उपयोग हमारी स्थिर फ़ाइलों को होस्ट करने के लिए किया जाएगा, जबकि फ़ैब्रिक परिनियोजन प्रक्रिया को स्वचालित करेगा।

परियोजना एक साधारण संदेश प्रणाली है। यह एक टूडू ऐप या ब्लॉग या ट्विटर क्लोन भी हो सकता है। वास्तविक-लाइव परिदृश्य का अनुकरण करने के लिए, प्रोजेक्ट को पहले एक MySQL बैकएंड के साथ बनाया जाएगा, फिर हेरोकू पर परिनियोजन के लिए पोस्टग्रेज़ में परिवर्तित किया जाएगा। मेरे पास व्यक्तिगत रूप से पाँच या छह प्रोजेक्ट हैं जहाँ मुझे यह सटीक काम करना पड़ा:एक स्थानीय प्रोजेक्ट को MySQL के साथ समर्थित, हरोकू पर एक लाइव ऐप में परिवर्तित करें।

सेटअप

पूर्वापेक्षाएँ

1. हेरोकू में आधिकारिक Django Quick Start गाइड पढ़ें। बस इसे पढ़ो। इससे आपको यह महसूस करने में मदद मिलेगी कि हम इस ट्यूटोरियल में क्या हासिल करेंगे। हम आधिकारिक ट्यूटोरियल का उपयोग अपनी स्वयं की, अधिक उन्नत परिनियोजन प्रक्रिया के लिए एक मार्गदर्शिका के रूप में करेंगे।
2. एक AWS खाता बनाएं और एक सक्रिय S3 बकेट सेट करें।
3. MySQL स्थापित करें।

शुरू करते हैं

यहां परीक्षण प्रोजेक्ट डाउनलोड करके प्रारंभ करें, अनज़िप करें, फिर वर्चुअलएन्व सक्रिय करें:

$ cd django_heroku_deploy
$ virtualenv --no-site-packages myenv
$ source myenv/bin/activate

Github पर एक नया रिपॉजिटरी बनाएं:

$ curl -u 'USER' https://api.github.com/user/repos -d '{"name":"REPO"}'

सभी कैप्स कीवर्ड्स को अपनी सेटिंग्स से बदलना सुनिश्चित करें। उदाहरण के लिए:curl -u 'mjhea0' https://api.github.com/user/repos -d '{"name":"django-deploy-heroku-s3"}'

एक रीडमी फ़ाइल जोड़ें, स्थानीय गिट रेपो को इनिशियलाइज़ करें, फिर स्थानीय कॉपी को जीथब पर पुश करें:

$ touch README.md
$ git init
$ git add .
$ git commit -am "initial"
$ git remote add origin https://github.com/username/Hello-World.git
$ git push origin master

यूआरएल को अपने रेपो के यूआरएल में बदलना सुनिश्चित करें जिसे आपने पिछले चरण में बनाया था।

एक नया MySQL डेटाबेस सेट करें जिसे django_deploy . कहा जाता है :

$ mysql.server start
$ mysql -u root -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g. Your MySQL connection id is 1
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql>
mysql> CREATE DATABASE django_deploy;
Query OK, 1 row affected (0.01 sec)
mysql>
mysql> quit
Bye

अपडेट करें settings.py :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'django_deploy',
        'USER': 'root',
        'PASSWORD': 'your_password',
    }
}

निर्भरताएँ स्थापित करें:

$ pip install -r requirements.txt
$ python manage.py syncdb
$ python manage.py runserver

सर्वर को http://localhost:8000/admin/ पर चलाएँ, और सुनिश्चित करें कि आप व्यवस्थापक में लॉग इन कर सकते हैं। Whatever में कुछ आइटम जोड़ें वस्तु। सर्वर को मार डालो।

MySQL से Postgres में कनवर्ट करें

नोट: इस काल्पनिक स्थिति में, मान लें कि आप कुछ समय से MySQL का उपयोग करके इस प्रोजेक्ट पर काम कर रहे हैं और अब आप इसे Postgres में बदलना चाहते हैं।

निर्भरताएं स्थापित करें:

$ pip install psycopg2
$ pip install py-mysql2pgsql

पोस्टग्रेज़ डेटाबेस सेट करें:

$ psql -h localhost
psql (9.2.4)
Type "help" for help.
michaelherman=# CREATE DATABASE django_deploy;
CREATE DATABASE
michaelherman=# \q

डेटा माइग्रेट करें:

$ py-mysql2pgsql

यह कमांड mysql2pgsql.yml . नामक फ़ाइल बनाता है , जिसमें निम्नलिखित जानकारी है:

mysql:
  hostname: localhost
  port: 3306
  socket: /tmp/mysql.sock
  username: foo
  password: bar
  database: your_database_name
  compress: false
destination:
  postgres:
    hostname: localhost
    port: 5432
    username: foo
    password: bar
    database: your_database_name

अपने कॉन्फ़िगरेशन के लिए इसे अपडेट करें। यह उदाहरण केवल मूल रूपांतरण को कवर करता है। आप कुछ तालिकाओं को शामिल या बहिष्कृत भी कर सकते हैं। पूरा उदाहरण यहां देखें।

डेटा ट्रांसफर करें:

$ py-mysql2pgsql -v -f mysql2pgsql.yml

एक बार डेटा स्थानांतरित हो जाने के बाद, अपनी settings.py को अपडेट करना सुनिश्चित करें फ़ाइल:

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql_psycopg2",
        "NAME": "your_database_name",
        "USER": "foo",
        "PASSWORD": "bar",
        "HOST": "localhost",
        "PORT": "5432",
    }
}

अंत में, डेटाबेस को फिर से सिंक करें, परीक्षण सर्वर चलाएं, और रूपांतरण सफल होने के लिए डेटाबेस में एक और आइटम जोड़ें।

एक local_settings.py फ़ाइल जोड़ें

एक local_settings.py जोड़कर फ़ाइल, आप settings.py का विस्तार कर सकते हैं आपके स्थानीय परिवेश के लिए प्रासंगिक सेटिंग्स वाली फ़ाइल, जबकि मुख्य settings.py फ़ाइल का उपयोग केवल आपके मंचन और उत्पादन परिवेश के लिए किया जाता है।

सुनिश्चित करें कि आप local_settings.py जोड़ते हैं आपके .gitignore . को फ़ाइल को अपने रिपॉजिटरी से बाहर रखने के लिए फ़ाइल करें। जो लोग आपकी परियोजना का उपयोग करना या उसमें योगदान देना चाहते हैं, वे रेपो का क्लोन बना सकते हैं और अपना स्वयं का local_settings.py बना सकते हैं। उनके अपने स्थानीय परिवेश के लिए विशिष्ट फ़ाइल।

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

सेटिंग अपडेट करें.py

हमें अपनी वर्तमान settings.py . में तीन परिवर्तन करने होंगे फ़ाइल:

बदलें DEBUG मोड से असत्य:

DEBUG = False

फ़ाइल के निचले भाग में निम्न कोड जोड़ें:

# Allow all host hosts/domain names for this site
ALLOWED_HOSTS = ['*']

# Parse database configuration from $DATABASE_URL
import dj_database_url

DATABASES = { 'default' : dj_database_url.config()}

# Honor the 'X-Forwarded-Proto' header for request.is_secure()
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')

# try to load local_settings.py if it exists
try:
  from local_settings import *
except Exception as e:
  pass

डेटाबेस सेटिंग अपडेट करें:

# we only need the engine name, as heroku takes care of the rest
DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql_psycopg2",
    }
}

अपनी local_settings.py बनाएं फ़ाइल:

$ touch local_settings.py
$ pip install dj_database_url

फिर निम्नलिखित कोड जोड़ें:

from settings import PROJECT_ROOT, SITE_ROOT
import os

DEBUG = True
TEMPLATE_DEBUG = True

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql_psycopg2",
        "NAME": "django_deploy",
        "USER": "foo",
        "PASSWORD": "bar",
        "HOST": "localhost",
        "PORT": "5432",
    }
}

यह सुनिश्चित करने के लिए कि सब कुछ अभी भी काम करता है, परीक्षण सर्वर को फायर करें। डेटाबेस में कुछ और रिकॉर्ड जोड़ें।

हेरोकू सेटअप

मुख्य निर्देशिका में एक प्रोफ़ाइल जोड़ें:

$ touch Procfile

और फ़ाइल में निम्न कोड जोड़ें:

web: python manage.py runserver 0.0.0.0:$PORT --noreload

हेरोकू टूलबेल्ट स्थापित करें:

$ pip install django-toolbelt

निर्भरता को फ़्रीज़ करें:

$ pip freeze > requirements.txt

wsgi.py को अपडेट करें फ़ाइल:

from django.core.wsgi import get_wsgi_application
from dj_static import Cling

application = Cling(get_wsgi_application())

स्थानीय रूप से अपनी हरोकू सेटिंग का परीक्षण करें:

$ foreman start

http://localhost:5000/ पर नेविगेट करें।

फब लगीं? आइए Amazon S3 को चालू करें।

अमेज़न S3

यद्यपि आपके हेरोकू रेपो में स्थिर फ़ाइलों को होस्ट करना काल्पनिक रूप से संभव है, तीसरे पक्ष के होस्ट का उपयोग करना सबसे अच्छा है, खासकर यदि आपके पास ग्राहक-सामना करने वाला एप्लिकेशन है। S3 का उपयोग करना आसान है, और इसके लिए आपकी settings.py . में केवल कुछ बदलावों की आवश्यकता है फ़ाइल।

निर्भरताएं स्थापित करें:

$ pip install django-storages
$ pip install boto

storagesजोड़ें और boto आपके INSTALLED_APPS . पर "सेटिंग्स.py" में

निम्नलिखित कोड को “settings.py” के नीचे जोड़ें:

# Storage on S3 settings are stored as os.environs to keep settings.py clean
if not DEBUG:
   AWS_STORAGE_BUCKET_NAME = os.environ['AWS_STORAGE_BUCKET_NAME']
   AWS_ACCESS_KEY_ID = os.environ['AWS_ACCESS_KEY_ID']
   AWS_SECRET_ACCESS_KEY = os.environ['AWS_SECRET_ACCESS_KEY']
   STATICFILES_STORAGE = 'storages.backends.s3boto.S3BotoStorage'
   S3_URL = 'http://%s.s3.amazonaws.com/' % AWS_STORAGE_BUCKET_NAME
   STATIC_URL = S3_URL

AWS पर्यावरण-निर्भर सेटिंग्स को पर्यावरण चर के रूप में संग्रहीत किया जाता है। इसलिए हर बार जब हम विकास सर्वर चलाते हैं तो हमें इन्हें टर्मिनल से सेट करने की आवश्यकता नहीं होती है, हम इन्हें अपने virtualenv activate में सेट कर सकते हैं लिखी हुई कहानी। S3 से AWS बकेट का नाम, एक्सेस की आईडी और सीक्रेट एक्सेस की को पकड़ो। खोलें myenv/bin/activate और निम्नलिखित कोड संलग्न करें (सुनिश्चित करें कि आपने अभी-अभी S3 से खींची गई अपनी विशिष्ट जानकारी में जोड़ा है):

# S3 deployment info
export AWS_STORAGE_BUCKET_NAME=[YOUR AWS S3 BUCKET NAME]
export AWS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXX
export AWS_SECRET_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXX

अपने वर्चुअलएन्व को निष्क्रिय और पुन:सक्रिय करें, फिर यह सुनिश्चित करने के लिए स्थानीय सर्वर लॉन्च करें कि परिवर्तन प्रभावित हुए हैं:

$ foreman start

सर्वर को बंद करें, फिर requirements.txt को अपडेट करें फ़ाइल:

$ pip freeze > requirements.txt

Github और Heroku पर पुश करें

आइए हरोकू को पुश करने से पहले अपनी फाइलों को जीथब में बैकअप लें:

$ git add .
$ git commit -m "update project for heroku and S3"
$ git push -u origin master

एक हेरोकू प्रोजेक्ट/रेपो बनाएं:

$ heroku create <name>

आप जो चाहें उसे नाम दें।

हरोकू को पुश करें:

$ git push heroku master

हेरोकू को एडब्ल्यूएस पर्यावरण चर भेजें

$ heroku config:set AWS_STORAGE_BUCKET_NAME=[YOUR AWS S3 BUCKET NAME]
$ heroku config:set AWS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXX
$ heroku config:set AWS_SECRET_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXX

स्थिर फ़ाइलें एकत्र करें और Amazon को भेजें:

$ heroku run python manage.py collectstatic

विकास डेटाबेस जोड़ें:

$ heroku addons:add heroku-postgresql:dev
Adding heroku-postgresql on deploy_django... done, v13 (free)
Attached as HEROKU_POSTGRESQL_COPPER_URL
Database has been created and is available
! This database is empty. If upgrading, you can transfer
! data from another database with pgbackups:restore.
Use `heroku addons:docs heroku-postgresql` to view documentation.
$ heroku pg:promote HEROKU_POSTGRESQL_COPPER_URL
Promoting HEROKU_POSTGRESQL_COPPER_URL to DATABASE_URL... done

अब DB को सिंक करें:

$ heroku run python manage.py syncdb

डेटा ट्रांसफर

हमें डेटा को स्थानीय डेटाबेस से उत्पादन डेटाबेस में स्थानांतरित करने की आवश्यकता है।

Heroku PGBackups ऐड-ऑन इंस्टॉल करें:

$ heroku addons:add pgbackups

अपना स्थानीय डेटाबेस डंप करें:

$ pg_dump -h localhost  -Fc library  > db.dump

हरोकू को डीबी डंप तक पहुंचने के लिए, आपको इसे कहीं इंटरनेट पर अपलोड करने की आवश्यकता है। आप एक निजी वेबसाइट, ड्रॉपबॉक्स या S3 का उपयोग कर सकते हैं। मैंने इसे केवल S3 बकेट में अपलोड किया है।

डंप को हरोकू में आयात करें:

$ heroku pgbackups:restore DATABASE http://www.example.com/db.dump

परीक्षा

आइए यह सुनिश्चित करने के लिए परीक्षण करें कि सब कुछ काम करता है।

सबसे पहले, अपने अनुमत होस्ट को settings.py . में अपने विशिष्ट डोमेन में अपडेट करें :

ALLOWED_HOSTS = ['[your-project-name].herokuapp.com']

अपना ऐप देखें:

$ heroku open

कपड़ा

फैब्रिक का उपयोग आपके एप्लिकेशन के स्वचालित परिनियोजन के लिए किया जाता है।

इंस्टॉल करें:

$ pip install fabric

फ़ैबफ़ाइल बनाएं:

$ touch fabfile.py

फिर निम्नलिखित कोड जोड़ें:

from fabric.api import local

def deploy():
   local('pip freeze > requirements.txt')
   local('git add .')
   print("enter your git commit comment: ")
   comment = raw_input()
   local('git commit -m "%s"' % comment)
   local('git push -u origin master')
   local('heroku maintenance:on')
   local('git push heroku master')
   local('heroku maintenance:off')

परीक्षण:

$ fab deploy

प्रश्न या टिप्पणियाँ हैं? नीचे चर्चा में शामिल हों।