ScaleUp

როგორ დავჰოსტოთ Django-ს პროექტი PythonAnywhere-ზე

განათავსეთ/დაჰოსტეთ თქვენი ვებ-საიტი PythonAnywhere-ის სერვერზე. ნაბიჯ-ნაბიჯ ახსნა და რეკომენდაციები.

By გიგი ჩაკაბერია •
როგორ დავჰოსტოთ Django-ს პროექტი PythonAnywhere-ზე

ამ ბლოგში დეტალურად ავხსნით, თუ როგორ უნდა განათავსოთ/დაჰოსტოთ Django-ს პროექტი PythonAnywhere-ზე და დააკონფიგურიროთ ყველაფერი, რაც საჭიროა რეალური საპროდუქციო (production) დეპლოიმენტისთვის:

  • Django
  • Git/GitHub
  • ვირტუალური გარემოები (Virtual environments)
  • გარემოს ცვლადები (Environment variables)
  • SQLite
  • მონაცემთა ბაზის მიგრაციები
  • CSS და JavaScript
  • სტატიკური ფაილები
  • მომხმარებლის მიერ ატვირთული მედია
  • Django Admin
  • WSGI
  • სამომავლო დეპლოიმენტები

მაგალითებში გამოყენებულია შემდეგი პირობითი სახელები (placeholders):

  • yourusername → თქვენი PythonAnywhere-ის მომხმარებლის სახელი
  • yourproject → Django პროექტის პაკეტი, რომელიც შეიცავს settings.py-ს
  • myvirtualenv → თქვენი ვირტუალური გარემოს სახელი

1. მოამზადეთ თქვენი პროექტი განსათავსებლად

პროექტის ატვირთვამდე დარწმუნდით, რომ ის მზად არის საპროდუქციო გარემოსთვის. ტიპური Django პროექტის სტრუქტურა შეიძლება ასე გამოიყურებოდეს:

myproject/
│
├── manage.py
├── requirements.txt
├── .gitignore
├── .env
│
├── myproject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── wsgi.py
│   └── ...
│
├── blog/
├── users/
│
├── static/
└── media/

თქვენი რეალური სტრუქტურა შესაძლოა განსხვავდებოდეს. მთავარია, რომ manage.py მდებარეობდეს პროექტის მთავარ (root) დირექტორიაში.

2. შექმენით .gitignore

სანამ პროექტს GitHub-ზე ატვირთავთ, შექმენით .gitignore ფაილი. მინიმუმ, ის უნდა შეიცავდეს შემდეგს:

__pycache__/
*.py[cod]

db.sqlite3

.env

.venv/
venv/
env/

staticfiles/

media/

რატომ უნდა გამოვტოვოთ db.sqlite3?
თუ იყენებთ SQLite-ს, თქვენი მონაცემთა ბაზა ინახება db.sqlite3-ში. ეს ფაილი არ უნდა დააფიქსიროთ (commit) Git-ში. თქვენი ლოკალური დეველოპმენტის მონაცემთა ბაზა და საპროდუქციო ბაზა ორი განსხვავებული ბაზაა.

მაგალითად:
თქვენი კომპიუტერი → db.sqlite3 → ლოკალური მომხმარებლები/მონაცემები
და:
PythonAnywhere → db.sqlite3 → საპროდუქციო მომხმარებლები/მონაცემები

თუ db.sqlite3-ს Git-ში შეიტანთ, git pull-ის გამოყენებისას შეიძლება შემთხვევით გადააწეროთ ან კონფლიქტი გამოიწვიოთ საპროდუქციო ბაზასთან. ამის ნაცვლად, Git უნდა შეიცავდეს თქვენი მიგრაციის ფაილებს და არა თავად ბაზას.

სწორი სამუშაო პროცესი (workflow) ასეთია:
models.py → makemigrations → მიგრაციის ფაილები → GitHub → PythonAnywhere → migrate → საპროდუქციო მონაცემთა ბაზა

რატომ უნდა გამოვტოვოთ .env?
.env შეიცავს მგრძნობიარე ინფორმაციას, როგორიცაა თქვენი საპროდუქციო SECRET_KEY. არასდროს ატვირთოთ ის GitHub-ზე.

3. დააკონფიგურირეთ requirements.txt

თქვენს პროექტს უნდა ჰქონდეს requirements.txt ფაილი, რომელიც შეიცავს მის დამოკიდებულებებს (dependencies). მაგალითად:

Django
Pillow
python-dotenv

თუ თქვენი პროექტი სხვა პაკეტებს იყენებს, ისინიც აქ უნდა იყოს მითითებული. შეგიძლიათ დააგენერიროთ ეს ფაილი თქვენი დეველოპმენტ გარემოდან შემდეგი ბრძანებით:

pip freeze > requirements.txt

შემდეგ კი დააფიქსიროთ (commit) Git-ში.

4. დააკონფიგურირეთ Django-ს პარამეტრები

გახსენით yourproject/settings.py. თქვენი საპროდუქციო პარამეტრები უნდა შეიცავდეს შესაბამის კონფიგურაციას.

ALLOWED_HOSTS
დაამატეთ თქვენი PythonAnywhere-ის ჰოსტის სახელი:

ALLOWED_HOSTS = [
    "yourusername.pythonanywhere.com",
]

ეს ეუბნება Django-ს, თუ რომელ ჰოსტებს აქვთ აპლიკაციაზე წვდომის უფლება. თუ მოგვიანებით დააკავშირებთ საკუთარ დომენს, ისიც აქ უნდა დაამატოთ. მაგალითად:

ALLOWED_HOSTS = [
    "yourusername.pythonanywhere.com",
    "example.com",
    "www.example.com",
]

5. დააკონფიგურირეთ SECRET_KEY და DEBUG

არ ჩაწეროთ საიდუმლო გასაღები პირდაპირ კოდში (do not hard-code). ამის ნაცვლად, გამოიყენეთ გარემოს ცვლადები (environment variables). settings.py-ს ზედა ნაწილში დაამატეთ:

import os

შემდეგ:

SECRET_KEY = os.getenv("SECRET_KEY")
DEBUG = os.getenv("DEBUG") == "True"

თქვენი საპროდუქციო .env ფაილი შეიცავს შემდეგს:

SECRET_KEY=your-production-secret-key
DEBUG=False

.env ფაილი არ უნდა მოხვდეს Git-ში.

6. დააკონფიგურირეთ სტატიკური ფაილები

Django იყენებს სტატიკურ ფაილებს ისეთი რამეებისთვის, როგორიცაა: CSS, JavaScript, თქვენს აპლიკაციაში ჩართული სურათები და Django admin-ის ფაილები (assets).

გამოიყენეთ:

STATIC_URL = "/static/"
STATIC_ROOT = BASE_DIR / "staticfiles"

თუ თქვენს პროექტს უკვე აქვს BASE_DIR განმარტებული Django-ს მიერ, დატოვეთ ისე როგორც არის. მაგალითად:

from pathlib import Path
BASE_DIR = Path(__file__).resolve().parent.parent

შემდეგ:

STATIC_URL = "/static/"
STATIC_ROOT = BASE_DIR / "staticfiles"

რატომ უნდა გამოვიყენოთ BASE_DIR?
არ გააკეთოთ ასე: STATIC_ROOT = "/home/yourusername/yourproject/staticfiles/" რადგან ეს გზა მხოლოდ PythonAnywhere-ზე იმუშავებს.

ამის ნაცვლად: STATIC_ROOT = BASE_DIR / "staticfiles" მუშაობს Windows-ზე, macOS-ზე, Linux-ზე და PythonAnywhere-ზე. Django ავტომატურად ააწყობს სწორ აბსოლუტურ გზას.

7. დააკონფიგურირეთ მედია ფაილები

მედია ფაილები არის ფაილები, რომლებსაც მომხმარებლები ტვირთავენ. მაგალითები: პროფილის სურათები, ატვირთული ფოტოები, დოკუმენტები, მიმაგრებული ფაილები (attachments).

დაამატეთ:

MEDIA_URL = "/media/"
MEDIA_ROOT = BASE_DIR / "media"

კვლავ, BASE_DIR-ის გამოყენება კონფიგურაციას პორტატიულს ხდის. სხვაობა ასეთია:

STATIC → აპლიკაციის მიერ მოწოდებული ფაილები → CSS, JavaScript, Admin assets.
ხოლო:
MEDIA → მომხმარებლის მიერ ატვირთული ფაილები → პროფილის სურათები, ატვირთული დოკუმენტები, მომხმარებლის სურათები.

8. შექმენით .env ფაილი

თქვენი პროექტის მთავარ დირექტორიაში შექმენით: .env

მაგალითად:

SECRET_KEY=your-production-secret-key
DEBUG=False

თუ თქვენს აპლიკაციას სხვა გარემოს ცვლადებიც სჭირდება, შეგიძლიათ ისინიც აქ დაამატოთ. მაგალითად:

SECRET_KEY=your-production-secret-key
DEBUG=False
DATABASE_URL=...

არ ჩასვათ მნიშვნელობები ბრჭყალებში, თუ კონფიგურაცია ამას კონკრეტულად არ მოითხოვს.

მნიშვნელოვანია: თქვენი .gitignore აუცილებლად უნდა შეიცავდეს .env. ეს თავიდან აგაცილებთ თქვენი საიდუმლო ინფორმაციის GitHub-ზე ატვირთვას.

9. მოამზადეთ Git

თუ Git ჯერ არ გაგიაქტიურებიათ (initialize):

git init

დაამატეთ თქვენი ფაილები:

git add .

შექმენით თქვენი პირველი ქომითი (commit):

git commit -m "Initial project"

შემდეგ დააკავშირეთ რეპოზიტორიუმი GitHub-თან და ატვირთეთ:

git remote add origin https://github.com/yourusername/yourproject.git
git branch -M main
git push -u origin main

თქვენი რეპოზიტორიუმი უნდა შეიცავდეს თქვენს საწყის კოდსა და მიგრაციის ფაილებს, მაგრამ არა შემდეგს: .env, db.sqlite3, media/, staticfiles/.

10. შექმენით PythonAnywhere გარემო

შედით PythonAnywhere-ზე. გახსენით Bash კონსოლი. გადადით თქვენს საწყის (home) დირექტორიაში:

cd /home/yourusername

დააკლონირეთ თქვენი Git რეპოზიტორიუმი:

git clone https://github.com/yourusername/yourproject.git

შემდეგ შედით პროექტის დირექტორიაში:

cd /home/yourusername/yourproject

11. შექმენით ვირტუალური გარემო

შექმენით ვირტუალური გარემო იმ Python-ის ვერსიის გამოყენებით, რომელიც ხელმისაწვდომია თქვენს PythonAnywhere ანგარიშზე. მაგალითად:

mkvirtualenv --python=/usr/bin/python3.10 myvirtualenv

ზუსტი პითონის ვერსია შეიძლება განსხვავდებოდეს იმის მიხედვით, თუ რას გვთავაზობს ამჟამად PythonAnywhere. შეამოწმეთ: python --version. თქვენი ვირტუალური გარემო აცალკევებს (იზოლაციას უკეთებს) პროექტის დამოკიდებულებებს სისტემური პითონის ინსტალაციისგან.

12. დააინსტალირეთ თქვენი დამოკიდებულებები

შექმნის შემდეგ ვირტუალური გარემო აქტიური უნდა იყოს. ამის გადამოწმება შეგიძლიათ ბრძანებით:

which python

მან უნდა აჩვენოს გზა (path) თქვენი ვირტუალური გარემოს შიგნით. ახლა დააინსტალირეთ პროექტის დამოკიდებულებები:

pip install -r requirements.txt

თუ იყენებთ python-dotenv-ს, დარწმუნდით რომ ის requirements.txt-შია. მაგალითად: Django, Pillow, python-dotenv.

თქვენ ზოგადად ცალკე არ უნდა დააინსტალიროთ Django (pip install django), თუ ის უკვე არის მითითებული requirements.txt-ში.

13. შექმენით საპროდუქციო .env

რადგან .env იგნორირებულია Git-ის მიერ, რეპოზიტორიუმის კლონირება მას არ გადმოწერს. თქვენ ის თავად უნდა შექმნათ PythonAnywhere-ზე. პროექტის დირექტორიიდან:

nano .env

დაამატეთ:

SECRET_KEY=your-production-secret-key
DEBUG=False

შეინახეთ ფაილი. მთავარი კონცეფცია არის:
GitHub → კოდი, requirements.txt, მიგრაციის ფაილები → PythonAnywhere.
.env → იქმნება სერვერზე ცალკე.

თქვენი საპროდუქციო საიდუმლო ინფორმაცია არ უნდა მოდიოდეს GitHub-დან.

14. დააკონფიგურირეთ WSGI ფაილი

გადადით Web ჩანართზე PythonAnywhere-ში. დააჭირეთ ბმულს, რათა დაარედაქტიროთ WSGI კონფიგურაციის ფაილი. ჩაანაცვლეთ მისი შიგთავსი შემდეგით:

import os
import sys

path = "/home/yourusername/yourproject"

if path not in sys.path:
    sys.path.insert(0, path)

from dotenv import load_dotenv

load_dotenv(os.path.join(path, ".env"))

os.environ["DJANGO_SETTINGS_MODULE"] = "yourproject.settings"

from django.core.wsgi import get_wsgi_application

application = get_wsgi_application()

შეცვალეთ: yourusername თქვენი PythonAnywhere-ის მომხმარებლის სახელით. შეცვალეთ: yourproject იმ Django პაკეტით, რომელიც შეიცავს settings.py-ს.

მაგალითად, თუ თქვენი სტრუქტურა ასეთია:

myproject/
    manage.py

    config/
        settings.py
        urls.py
        wsgi.py

მაშინ გამოიყენეთ: os.environ["DJANGO_SETTINGS_MODULE"] = "config.settings"

15. გაიგეთ, თუ როგორ მუშაობს WSGI ფაილი

WSGI ფაილი არის ხიდი PythonAnywhere-სა და Django-ს შორის.

os მოდულის იმპორტირება

import os

საშუალებას აძლევს Python-ს იმუშაოს ოპერაციული სისტემის ფუნქციონალთან და გარემოს ცვლადებთან.

sys მოდულის იმპორტირება

import sys

გვაძლევს საშუალებას შევცვალოთ პითონის მოდულების ძიების გზა (search path).

პროექტის მისამართის განსაზღვრა

path = "/home/yourusername/yourproject"

ეს ის დირექტორიაა, რომელიც შეიცავს manage.py-ს.

პროექტის დამატება Python-ის ძიების გზაზე

if path not in sys.path:
    sys.path.insert(0, path)

ეს ეხმარება Python-ს იპოვოს თქვენი Django პროექტი.

dotenv მოდულის იმპორტირება

from dotenv import load_dotenv

იმპორტს უკეთებს ფუნქციას, რომელიც გამოიყენება .env-დან ცვლადების ჩასატვირთად.

.env ფაილის ჩატვირთვა

load_dotenv(os.path.join(path, ".env"))

ეს კითხულობს: /home/yourusername/yourproject/.env და ხდის მის ცვლადებს ხელმისაწვდომს os.getenv()-ის მეშვეობით.

Django-სთვის პარამეტრების მითითება

os.environ["DJANGO_SETTINGS_MODULE"] = "yourproject.settings"

ეს ეუბნება Django-ს, სად მდებარეობს თქვენი პარამეტრების ფაილი (settings).

WSGI აპლიკაციის შექმნა

from django.core.wsgi import get_wsgi_application

application = get_wsgi_application()

ეს ქმნის აპლიკაციის ობიექტს, რომელსაც PythonAnywhere იყენებს Django-სთან საკომუნიკაციოდ.

16. დააკონფიგურირეთ ვირტუალური გარემო

დაბრუნდით PythonAnywhere-ის Web ჩანართზე. იპოვეთ Virtualenv სექცია. შეიყვანეთ:

/home/yourusername/.virtualenvs/myvirtualenv

ეს ეუბნება PythonAnywhere-ს, თუ რომელი ვირტუალური გარემო უნდა გამოიყენოს თქვენი ვებსაიტის გაშვებისას. გარემო, რომელსაც იყენებს თქვენი ვებ აპლიკაცია, უნდა შეიცავდეს Django-ს და პროექტის ყველა სხვა დამოკიდებულებას.

17. გაუშვით მონაცემთა ბაზის მიგრაციები

გახსენით Bash კონსოლი. თუ ეს ახალი კონსოლია, გააქტიურეთ თქვენი ვირტუალური გარემო:

workon myvirtualenv

შემდეგ გადადით თქვენს პროექტში:

cd /home/yourusername/yourproject

გაუშვით:

python manage.py migrate

ეს შექმნის მონაცემთა ბაზის საჭირო ცხრილებს.

აქ ჩვეულებრივ არ გაუშვათ makemigrations
მიგრაციის ფაილები უნდა შეიქმნას დეველოპმენტის პროცესში (python manage.py makemigrations) და შემდეგ უნდა დაფიქსირდეს Git-ში. PythonAnywhere-ზე ჩვეულებრივ მხოლოდ ეს გჭირდებათ: python manage.py migrate. საპროდუქციო სერვერი იყენებს იმ მიგრაციის ფაილებს, რომლებიც უკვე შეიქმნა დეველოპმენტის დროს.

18. შეაგროვეთ სტატიკური ფაილები

დარწმუნდით, რომ თქვენი ვირტუალური გარემო აქტიურია (workon myvirtualenv). გადადით პროექტში და გაუშვით:

python manage.py collectstatic

Django სტატიკურ ფაილებს შეაგროვებს აქ: /home/yourusername/yourproject/staticfiles/ რადგან ჩვენ დავაკონფიგურირეთ STATIC_ROOT = BASE_DIR / "staticfiles". გახსოვდეთ: collectstatic ამუშავებს სტატიკურ ფაილებს და არა მომხმარებლის მიერ ატვირთულ მედიას.

19. დააკონფიგურირეთ სტატიკური ფაილები PythonAnywhere-ზე

გადადით: Web → Static files დაამატეთ:

URL: /static/
Directory: /home/yourusername/yourproject/staticfiles/

კავშირი ასეთია: ბრაუზერი → /static/ → PythonAnywhere → staticfiles/. ახლა PythonAnywhere-ს შეუძლია პირდაპირ მიაწოდოს თქვენი CSS, JavaScript, Django admin-ის ფაილები და სხვა სტატიკური ფაილები მომხმარებელს.

20. დააკონფიგურირეთ მედია ფაილები PythonAnywhere-ზე

იმავე Static files სექციაში დაამატეთ კიდევ ერთი დაკავშირება (mapping):

URL: /media/
Directory: /home/yourusername/yourproject/media/

კავშირი ასეთია: ბრაუზერი → /media/ → PythonAnywhere → media/. ეს საშუალებას იძლევა, მომხმარებლის მიერ ატვირთული ფაილები ხელმისაწვდომი გახდეს. მაგალითად: /media/profile_pictures/photo.jpg შეესაბამება /home/yourusername/yourproject/media/profile_pictures/photo.jpg.

21. დარწმუნდით, რომ მედია დირექტორია არსებობს

თქვენს პროექტს შესაძლოა ჯერ არ ჰქონდეს media დირექტორია. საჭიროების შემთხვევაში შექმენით ის:

mkdir -p /home/yourusername/yourproject/media

Django-ს სჭირდება, რომ შეძლოს ატვირთული ფაილების იქ ჩაწერა.

22. შექმენით Django სუპერმომხმარებელი

თუ თქვენი აპლიკაცია იყენებს Django Admin-ს:

workon myvirtualenv
cd /home/yourusername/yourproject
python manage.py createsuperuser

მიჰყევით ინსტრუქციებს. ამის შემდეგ შეგეძლებათ შეხვიდეთ აქ: https://yourusername.pythonanywhere.com/admin/.

23. შეამოწმეთ საპროდუქციო კონფიგურაცია

ვებსაიტის ჩართვამდე გაუშვით:

python manage.py check --deploy

ეს ამოწმებს Django დეპლოიმენტის გავრცელებულ პრობლემებს. ასევე დარწმუნდით, რომ საპროდუქციო გარემოს აქვს: DEBUG = False და ALLOWED_HOSTS = ["yourusername.pythonanywhere.com",].

24. გადატვირთეთ ვებსაიტი

დაბრუნდით PythonAnywhere-ის Web ჩანართზე. დააჭირეთ მწვანე ღილაკს: Reload. PythonAnywhere გადატვირთავს ვებ აპლიკაციას განახლებული კონფიგურაციით. თქვენი ვებსაიტი ახლა ხელმისაწვდომი იქნება მისამართზე: https://yourusername.pythonanywhere.com/.

25. გატესტეთ დეპლოიმენტი

ნუ გაჩერდებით მხოლოდ იმის შემოწმებით, იტვირთება თუ არა მთავარი გვერდი. გატესტეთ მნიშვნელოვანი ფუნქციონალი.

ვებსაიტი:

  • მთავარი გვერდი
  • URL-ები
  • ფორმები
  • ავტორიზაცია (Authentication)
  • მონაცემთა ბაზა

სტატიკური ფაილები (შეამოწმეთ):

  • CSS
  • JavaScript
  • სურათები
  • Django Admin-ის დიზაინი (styling) — თუ თქვენი ვებსაიტი უდიზაინოდ გამოიყურება, პირველ რიგში სტატიკური ფაილები უნდა შეამოწმოთ.

მედია ფაილები: გაიარეთ ავტორიზაცია და ატვირთეთ პროფილის სურათი ან სხვა ფაილი. დარწმუნდით, რომ ის გამოჩნდება.

Admin: ეწვიეთ /admin/ და დარწმუნდით, რომ შეგიძლიათ სისტემაში შესვლა.

26. სამომავლო დეპლოიმენტები

საწყისი განთავსების დასრულების შემდეგ, სამომავლო დეპლოიმენტები ბევრად მარტივია. დავუშვათ, ცვლილებებს აკეთებთ თქვენს კომპიუტერზე. პირველ რიგში:

git add .
git commit -m "Update project"
git push

შემდეგ გახსენით ახალი Bash კონსოლი PythonAnywhere-ზე.

ნაბიჯი 1 — გააქტიურეთ ვირტუალური გარემო (ეს მნიშვნელოვანია)
workon myvirtualenv

ნაბიჯი 2 — გადადით თქვენს პროექტში
cd /home/yourusername/yourproject

ნაბიჯი 3 — ჩამოტვირთეთ ახალი კოდი
git pull

ნაბიჯი 4 — საჭიროების შემთხვევაში დააინსტალირეთ ახალი დამოკიდებულებები (თუ requirements.txt შეიცვალა)
pip install -r requirements.txt

ნაბიჯი 5 — საჭიროების შემთხვევაში გაუშვით მონაცემთა ბაზის მიგრაციები (თუ დაამატეთ მიგრაციის ფაილები)
python manage.py migrate

ნაბიჯი 6 — საჭიროების შემთხვევაში შეაგროვეთ სტატიკური ფაილები (თუ შეიცვალა)
python manage.py collectstatic

ნაბიჯი 7 — გადატვირთეთ აპლიკაცია
გადადით PythonAnywhere-ის Web ჩანართზე და დააჭირეთ: Reload.

27. სამომავლო დეპლოიმენტის სრული სამუშაო პროცესი

თქვენი სტანდარტული დეპლოიმენტის პროცესი ასეთი ხდება:

ლოკალური კომპიუტერი:
ცვლილებების შეტანა → python manage.py makemigrations (მხოლოდ თუ მოდელები შეიცვალა) → git add . → git commit → git push

PYTHONANYWHERE:
გახსენით Bash კონსოლი → workon myvirtualenv → cd /home/yourusername/yourproject → git pull → pip install -r requirements.txt (საჭიროებისას) → python manage.py migrate (საჭიროებისას) → python manage.py collectstatic (საჭიროებისას) → Web → Reload

28. რა მიდის Git-ში და რა არა?

ეს ერთ-ერთი ყველაზე მნიშვნელოვანი კონცეფციაა გასაგებად.

დააფიქსირეთ (Commit) ესენი:

  • manage.py
  • settings.py
  • urls.py
  • models.py
  • views.py
  • templates/
  • თქვენი Django აპლიკაციები (apps)
  • static/
  • requirements.txt
  • მიგრაციის ფაილები
  • .gitignore

ᲐᲠ დააფიქსიროთ ესენი:

  • .env
  • db.sqlite3
  • media/
  • staticfiles/
  • __pycache__/

მთავარი განსხვავება არის:
საწყისი კოდი (SOURCE CODE) → Git → PythonAnywhere
მაგრამ:
მონაცემთა ბაზა (DATABASE) → მხოლოდ საპროდუქციო სერვერზე
საიდუმლოებები (SECRETS) → .env სერვერზე
მომხმარებლის ატვირთვები (USER UPLOADS) → media/ სერვერზე

29. სრული არქიტექტურის გაგება

განთავსების შემდეგ, საბაზისო არქიტექტურა ასე გამოიყურება:

                    ინტერნეტი
                       │
                       ▼
             PythonAnywhere ვებ სერვერი
                       │
          ┌────────────┼────────────┐
          │            │            │
          ▼            ▼            ▼
       /static/      /media/      Django
          │            │            │
          ▼            ▼            ▼
    staticfiles/     media/        WSGI
                                    │
                                    ▼
                                  Django
                                    │
                                    ▼
                               მონაცემთა ბაზა

სტატიკური ფაილები: /static/ → staticfiles/ წვდომა ხდება პირდაპირ PythonAnywhere-ის მიერ.
მედია ფაილები: /media/ → media/ წვდომა ხდება პირდაპირ PythonAnywhere-ის მიერ.
დინამიკური მოთხოვნები: მაგალითად: /blog/ გადის ამ ჯაჭვს: PythonAnywhere → WSGI → Django → View → მონაცემთა ბაზა → პასუხი (Response)

30. დეპლოიმენტის ფინალური ჩეკლისტი

სანამ განთავსებას დასრულებულად ჩათვლით, გადაამოწმეთ:

Git

  • [ ] db.sqlite3 არის .gitignore-ში
  • [ ] .env არის .gitignore-ში
  • [ ] staticfiles/ არის .gitignore-ში
  • [ ] media/ არის .gitignore-ში
  • [ ] მიგრაციის ფაილები დაფიქსირებულია (committed)
  • [ ] requirements.txt დაფიქსირებულია (committed)

Django პარამეტრები (settings)

  • [ ] DEBUG=False
  • [ ] ALLOWED_HOSTS შეიცავს PythonAnywhere-ის დომენს
  • [ ] SECRET_KEY იკითხება .env-დან
  • [ ] STATIC_URL დაკონფიგურირებულია
  • [ ] STATIC_ROOT იყენებს BASE_DIR-ს
  • [ ] MEDIA_URL დაკონფიგურირებულია
  • [ ] MEDIA_ROOT იყენებს BASE_DIR-ს

PythonAnywhere

  • [ ] პროექტი დაკლონირებულია
  • [ ] ვირტუალური გარემო შექმნილია
  • [ ] requirements.txt დაინსტალირებულია
  • [ ] .env შექმნილია სერვერზე
  • [ ] WSGI დაკონფიგურირებულია
  • [ ] Virtualenv დაკონფიგურირებულია Web ჩანართში
  • [ ] სტატიკური ფაილების დაკავშირება (mapping) დასრულებულია
  • [ ] მედია ფაილების დაკავშირება (mapping) დასრულებულია
  • [ ] მონაცემთა ბაზა მიგრირებულია
  • [ ] collectstatic დასრულებულია
  • [ ] სუპერმომხმარებელი (Superuser) შექმნილია (საჭიროების შემთხვევაში)
  • [ ] ვებ აპლიკაცია გადატვირთულია (reloaded)

ტესტირება

  • [ ] მთავარი გვერდი მუშაობს
  • [ ] CSS მუშაობს
  • [ ] JavaScript მუშაობს
  • [ ] სურათები მუშაობს
  • [ ] ავტორიზაცია (Login) მუშაობს
  • [ ] ფორმები მუშაობს
  • [ ] მონაცემთა ბაზა მუშაობს
  • [ ] Admin პანელი მუშაობს
  • [ ] ფაილების ატვირთვა მუშაობს
  • [ ] ატვირთული სურათები სწორად ჩანს

სამი წესი, რომელიც უნდა გახსოვდეთ:

1. არასდროს ატვირთოთ საპროდუქციო მონაცემთა ბაზა Git-ში
db.sqlite3 → .gitignore
Git-ში უნდა ატვირთოთ მიგრაციის ფაილები და არა მონაცემთა ბაზა.

2. ყოველთვის გააქტიურეთ ვირტუალური გარემო
განსაკუთრებით ახალ Bash კონსოლში:
workon myvirtualenv

3. სტატიკური და მედია ფაილები განსხვავებულია
STATIC → collectstatic → staticfiles/
MEDIA → მომხმარებლის ატვირთვები → media/
Django სტატიკურ ფაილებს აგროვებს collectstatic-ის საშუალებით, ხოლო მომხმარებლის მიერ ატვირთული მედია ინახება ცალკე.

როგორც კი ამ კონცეფციებს გაიგებთ, Django პროექტის PythonAnywhere-ზე განთავსება გაუგებარი კონფიგურაციების ნაცვლად, მარტივად განმეორებადი პროცესი გახდება.

Გ

ავტორის შესახებ

გიგი ჩაკაბერია

Back-end დეველოპერი და მენტორი