A może pozdrowienia dla wszystkich, to mój pierwszy artykuł w <» FromLinux (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
Gunicorn -> Serwer WWW dla Pythona (nie będziemy go jeszcze instalować)
Zakładam, że powinni mieć już zainstalowany i skonfigurowany postgresql
psycopg2 -> łącznik PostgreSQL dla Pythona (na razie go 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 wszystkie nasze działania będą teraz 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 skonfigurujmy to. Aby to zrobić, utworzymy plik o nazwie gunicorn-deploy.py w katalogu głównym naszej aplikacji (choć nazwa może być dowolna) z następującą zawartoś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 skonfigurujmy supervisord ; w tym celu wygenerujmy plik konfiguracyjny za pomocą
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 DEBUG = True i zmieniamy jej wartość , pozostawiając DEBUG = False
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 będziemy się do niej uzyskiwać dostęp. W rezultacie otrzymujemy coś takiego jak ALLOWED_HOSTS=['www.domena.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 „ statics” w ścieżce określonej w pliku settings.py . W tym folderze będą się znajdować wszystkie nasze pliki statyczne.
Na koniec ponownie uruchamiamy przełożonego, aby przyjąć nowe zmiany:
supervisorctl restart nombreApp
I to by było na tyle, w końcu nie była to taka wielka sprawa, prawda? Wydawało mi się to proste
Mam nadzieję, że będzie dla Was przydatny, pozdrawiam