Jak wdrożyć aplikację Django:

Witam wszystkich. To mój pierwszy artykuł w <» DesdeLinux (z kilku, które mam w swoich wersjach roboczych xD), mam nadzieję, że się Wam przyda 😀

No cóż, w mojej nowej i obecnej pracy, w tej chwili trwa migracja kilku systemów do Django (jakie dziwne eh ?? xD) i jednym z moich zadań poza rozwojem jest ich wprowadzenie do produkcji, to jako dobry praktykant, ponieważ po raz pierwszy wprowadzałem aplikację do produkcji na prawdziwym serwerze: $ Zacząłem czytać oficjalną dokumentację każdego z wymaganych pakietów stosu (przede wszystkim Gunicorn i Supervisord) i widząc, że tutoriale W języku hiszpańskim nie były dla mnie zbyt jasne w niektórych aspektach, zdecydowałem się stworzyć mini przewodnik z krokami, które wykonałem, aby wprowadzić aplikację do produkcji, oparty na stosie Django, Gunicorn, Supervisord, Nginx i Postgresql.

W przypadku, gdy pracuję, serwery nadal działają na Debian Squeeze, ale przewodnik powinien być w pełni ważny dla innych dystrybucji ... więc przejdźmy od razu do sedna i zacznijmy:

Będę pracował jako superużytkownik. Przede wszystkim wymagane są następujące pakiety:

PIP -> Narzędzie do instalacji i zarządzania pakietami dla Pythona
aptitude install python-pip

nginx -> Serwer WWW (użyjemy go jako odwrotnego proxy i buforujemy statyczne pliki img, js, css) Instalujemy go za pomocą:
aptitude install nginx

Supervisord -> Aplikacja do zarządzania i monitorowania naszej aplikacji, chociaż jest używana do znacznie więcej. Instalujemy go za pomocą:
aptitude install supervisor

Wirtualne środowisko -> Pomaga nam stworzyć niestandardowe wirtualne środowisko wykonawcze dla naszej aplikacji. Instalujemy go za pomocą:
aptitude install python-virtualenv

pistolet -> serwer WWW dla Pythona (nie będziemy tego jeszcze instalować)

Zakładam, że powinni mieć już zainstalowany i skonfigurowany postgresql

psychopg2 -> Złącze Postgresql dla Pythona (też go jeszcze nie zainstalujemy)

Utwórz środowisko wirtualne z virtualenv:

Najpierw przejdziemy do katalogu roboczego, którego użyjemy do wprowadzenia do produkcji:
cd /var/www/

Następnie w tym katalogu stworzymy środowisko wirtualne:
virtualenv ENV-nombreApp

Przechodzimy do katalogu, który właśnie utworzyłem virtualenv
cd ENV-nombreAPP

Kopiujemy aplikację w tym katalogu i przystępujemy do aktywacji środowiska za pomocą:
source bin/activate

Monit powinien teraz wyglądać tak (ENV)usuario@host:

Dzięki temu wszystko, co robimy, będzie przechowywane w katalogu / var / www / ENV-appname / bez wpływu na pakiety systemowe

Teraz przechodzimy do katalogu aplikacji:
cd nombreApp

Przystępujemy do instalacji listy zależności aplikacji (jeśli to konieczne), w której są one określone w pliku wymagania.txt:
pip install -r requirements.txt

Możemy również instalować pakiety indywidualnie, na przykład, aby zainstalować złącze PostgreSQL:
pip install psycopg2

Instalacja i konfiguracja GUnicorn:

Aby go zainstalować, robimy to w ten sam sposób:
pip install gunicorn

Teraz mamy zamiar go skonfigurować, w tym celu utworzymy plik o nazwie gunicorn-deploy.py w katalogu głównym naszej aplikacji (chociaż nazwa może być dowolna) o następującej treści:

bind = "127.0.0.1:8001" # dirección a donde accederá Nginx
logfile = "/var/www/logs/nombreApp/gunicorn.log" # dirección donde estarán los logs de la aplicación
workers = 1 # dependerá en medida de la carga de trabajo que tenga la aplicación, también depende del hardware con que se cuente
loglevel = 'info' # tipo de logging

Konfiguracja nadzorcy:

Teraz ustawmy supervisord, w tym celu generujemy plik konfiguracyjny z

echo_supervisord_conf > /etc/supervisord.conf

Teraz edytujemy plik konfiguracyjny:
vim /etc/supervisord.conf

Odkomentujemy następujące wiersze, usuwając; (średnik):

[unix_http_server] file = / tmp / supervisor.sock [supervisord] logfile = / var / log / supervisord.log logfile_maxbytes = 50 MB logfile_backups = 10 loglevel = debug pidfile = / var / run / supervisord.pid nodaemon = false minfds = 1024 minprocs = 200 [rpcinterface: supervisor] supervisor.rpcinterface_factory = supervisor.rpcinterface: make_main_rpcinterface [supervisorctl] serverurl = unix: [program: appname] command = / var / www / ENV-appname / bin / django_unicorn -c / var / www / ENV -appname / appname / gunicorn-deploy.py directory = / var / www / ENV-appname / appname / autostart = true autorestart = true user = username redirect_stderr = true stdout_logfile = / var / www / logs / appname / supervisord.log

Teraz stworzymy skrypt dla nadzorcy, który rozpocznie pracę z systemem, w tym celu utworzymy plik:
vim /etc/init.d/supervisord

I dodajemy następującą treść:

 # Automatyczne uruchamianie nadzorcy # # opis: Automatyczne uruchamianie supervisord # nazwa procesu: supervisord # plik pid: /var/run/supervisord.pid SUPERVISORD = / usr / local / bin / supervisord SUPERVISORCTL = / usr / local / bin / supervisorctl case $ 1 na początku) echo -n "Uruchamianie nadzorcy:" $ SUPERVISORD echo ;; stop) echo -n "Zatrzymywanie nadzorującego:" $ SUPERVISORCTL wyłączanie echa ;; restart) echo -n "Zatrzymywanie nadzorującego:" $ SUPERVISORCTL zamykanie wyłączania echo echo -n "Uruchamianie nadzorującego:" $ SUPERVISORD echo ;; to C

A teraz dajemy uprawnienia do wykonania pliku, aby mógł się uruchomić z systemem:
sudo chmod +x /etc/init.d/supervisord

Aktualizujemy linki, aby uruchomić usługę:
sudo update-rc.d supervisord defaults

Rozpoczynamy usługę:
sudo /etc/init.d/supervisord start

Konfigurowanie nginx:

Ten krok jest również dość prosty, utworzymy następujący plik konfiguracyjny nginx dla naszej aplikacji:

vim /etc/nginx/sites-enabled/nombreApp

Dodamy do Ciebie następującą treść

serwer {nasłuchuj 9001; # port, na którym nginx nazwa_serwera nasłuchuje www.domain.com; # lub 192.168.0.100, adres, do którego uzyskamy dostęp do access_log /var/log/nginx/Appname.access.log; # gdzie będziemy mieć lokalizację dziennika aplikacji / {# gdzie nginx zadzwoni podczas uzyskiwania dostępu do www.dominio.com/proxy_pass http://127.0.0.1:8001; proxy_set_header Host $ http_host; } location / static / {# gdzie nginx uzyska dostęp, gdy wejdziemy na www.dominio.com/static/ alias / var / www / ENV-appname / appname / staticfiles /; }}

I ponownie uruchamiamy nginx:
service nginx restart

Konfigurowanie Django:

Zmodyfikujmy plik konfiguracyjny django:
vim nombreApp/settings.py

Szukamy linii, która mówi DEBUGUJ = Prawda i zmieniamy wartośćpozostała DEBUG = Fałsz

Dodajemy parametry DB:

DATABASES = {'default': {'ENGINE': 'django.db.backends.postgresql_psycopg2', # lub mysql, czy cokolwiek innego 'NAME': 'DBName', 'USER': 'DBUser', 'PASSWORD' używają: 'password DB', 'HOST': 'localhost', # lub ten, którego potrzebują 'PORT': '', # lub ten, którego używają}}

Szukamy linii ALLOWED_HOSTS = [] i dodajemy domenę lub adres, przez który uzyskamy dostęp, pozostawiając coś w rodzaju ALLOWED_HOSTS = [„www.domain.com”]

Konfigurujemy katalog dla plików statycznych, szukamy wiersza, który mówi STATIC_ROOT = ' ' i zmieniamy wartość, umieszczając bezwzględną ścieżkę, w której chcemy, aby były nasze pliki statyczne, w moim przypadku zostawiłem to mniej więcej tak STATIC_ROOT='/var/www/ENV-nombreApp/nombreApp/statics/'

Prawie skończyliśmy, wykonujemy następujące polecenie:
./manage.py collectstatic

Spowoduje to utworzenie folderu o nazwie „statyka w ścieżce, którą określamy w settings.py ", tutaj będą znajdować się wszystkie nasze pliki statyczne.

Na koniec ponownie uruchamiamy przełożonego, aby przyjąć nowe zmiany:
supervisorctl restart nombreApp

I to by było wszystko, w końcu to nie była prawda? wydawało mi się to proste 😀

Mam nadzieję, że Ci się przyda, pozdrawiam 😉

Dokumentacja GUnicorn

Dokumentacja nadzorcza