Django
Rozlokowanie

AngularJS CSS HTML JavaScript jQuery MongoDB MySQL postgresql Python Language SQL
Szukaj…


Uruchamianie aplikacji Django z Gunicorn

  1. Zainstaluj gunicorn

    pip install gunicorn

  1. Z folderu projektu django (ten sam folder, w którym znajduje się manage.py), uruchom następującą komendę, aby uruchomić bieżący projekt django z gunicorn

    gunicorn [projectname].wsgi:application -b 127.0.0.1:[port number]

    Możesz użyć opcji --env , aby ustawić ścieżkę ładowania ustawień

    gunicorn --env DJANGO_SETTINGS_MODULE=[projectname].settings [projectname].wsgi

    lub uruchom jako proces demona za pomocą opcji -D

  1. Po pomyślnym uruchomieniu gunicorn w konsoli pojawią się następujące wiersze

    Starting gunicorn 19.5.0

    Listening at: http://127.0.0.1:[port number] ([pid])

    .... (inne dodatkowe informacje o serwerze gunicorn)

Wdrażanie za pomocą Heroku

  1. Pobierz Heroku Toolbelt .

  2. Przejdź do katalogu głównego źródeł aplikacji Django. Będziesz potrzebował tk

  3. Wpisz heroku create [app_name] . Jeśli nie podasz nazwy aplikacji, Heroku losowo ją wygeneruje. Twój adres URL aplikacji to http://[app name].herokuapp.com

  4. Utwórz plik tekstowy o nazwie Procfile . Nie umieszczaj rozszerzenia na końcu. 

    web: <bash command to start production server>

    Jeśli masz proces roboczy, możesz go również dodać. Dodaj kolejny wiersz w formacie: worker-name: <bash command to start worker>

  5. Dodaj wymagania.txt.

  • Jeśli używasz środowiska wirtualnego, uruchom pip freeze > requirements.txt
  • W przeciwnym razie uzyskaj wirtualne środowisko! . Możesz także ręcznie wyświetlić listę potrzebnych pakietów Pythona, ale nie zostaną one omówione w tym samouczku.

  1. Czas na wdrożenie!

    1. git push heroku master

    Heroku potrzebuje repozytorium git lub folderu dropbox do wdrażania. Możesz również skonfigurować automatyczne przeładowywanie z repozytorium GitHub na heroku.com , ale nie omówimy tego w tym samouczku.

    1. heroku ps:scale web=1

    Skaluje to liczbę „dynos” do jednego. Możesz dowiedzieć się więcej o dynos tutaj.

    1. heroku open lub przejdź do http://app-name.herokuapp.com

    Wskazówka: heroku open otwiera adres URL twojej aplikacji heroku w domyślnej przeglądarce.

  2. Dodaj dodatki . Musisz skonfigurować aplikację Django do łączenia się z bazami danych udostępnianymi w Heroku jako „dodatki”. Ten przykład nie obejmuje tego, ale inny przykład jest w trakcie wdrażania baz danych w Heroku.

Proste zdalne wdrożenie fabfile.py

Fabric to biblioteka Pythona (2.5–2.7) i narzędzie wiersza polecenia do usprawnienia korzystania z SSH do wdrażania aplikacji lub zadań administracyjnych w systemie. Pozwala wykonywać dowolne funkcje Pythona za pomocą wiersza poleceń.

Zainstaluj materiał za pomocą pip install fabric
Utwórz fabfile.py w swoim katalogu głównym: 

#myproject/fabfile.py    
from fabric.api import *

@task
def dev():
    # details of development server
    env.user = # your ssh user
    env.password = #your ssh password
    env.hosts = # your ssh hosts (list instance, with comma-separated hosts)
    env.key_filename = # pass to ssh key for github in your local keyfile

@task
def release():
    # details of release server
    env.user = # your ssh user
    env.password = #your ssh password
    env.hosts = # your ssh hosts (list instance, with comma-separated hosts)
    env.key_filename = # pass to ssh key for github in your local keyfile

@task
def run():
    with cd('path/to/your_project/'):
        with prefix('source ../env/bin/activate'): 
        # activate venv, suppose it appear in one level higher
            # pass commands one by one
            run('git pull')
            run('pip install -r requirements.txt')
            run('python manage.py migrate --noinput')
            run('python manage.py collectstatic --noinput')
            run('touch reload.txt')

Aby uruchomić plik, po prostu użyj polecenia fab : 

$ fab dev run  # for release server, `fab release run`

Uwaga: nie możesz skonfigurować kluczy ssh dla github i po prostu ręcznie wpisać login i hasło, podczas gdy fabfile działa tak samo z kluczami.

Korzystanie z szablonu startowego Heroku Django.

Jeśli planujesz hostować swoją stronę Django na Heroku, możesz rozpocząć swój projekt za pomocą szablonu startowego Heroku Django: 

django-admin.py startproject --template=https://github.com/heroku/heroku-django-template/archive/master.zip --name=Procfile YourProjectName

Posiada gotową do produkcji konfigurację plików statycznych, ustawień bazy danych, Gunicorn itp. Oraz Ulepszenia funkcji statycznego wyświetlania plików Django za pośrednictwem WhiteNoise. Pozwoli ci to zaoszczędzić czas, wszystko jest gotowe do hostowania na Heroku, po prostu zbuduj swoją stronę internetową na szczycie tego szablonu

Aby wdrożyć ten szablon na Heroku: 

git init
git add -A
git commit -m "Initial commit"

heroku create
git push heroku master

heroku run python manage.py migrate

Otóż to!

Instrukcje wdrażania Django. Nginx + Gunicorn + Supervisor on Linux (Ubuntu)

Trzy podstawowe narzędzia.

  1. nginx - darmowy, otwarty serwer HTTP o wysokiej wydajności i zwrotny serwer proxy o wysokiej wydajności;
  2. gunicorn - „Zielony jednorożec” to serwer HTTP Python WSGI dla systemu UNIX (potrzebny do zarządzania serwerem);
  3. supervisor - system klient / serwer, który pozwala użytkownikom monitorować i kontrolować wiele procesów w systemach operacyjnych typu UNIX. Używany, gdy aplikacja lub system ulega awarii, ponownie uruchamia django / celery / celery cam itp .;

Aby to uprościć, załóżmy, że twoja aplikacja znajduje się w tym katalogu: /home/root/app/src/ i będziemy używać użytkownika root (ale powinieneś utworzyć osobnego użytkownika dla swojej aplikacji). Również nasze środowisko wirtualne będzie znajdować się w /home/root/app/env/ path.

NGINX

Zacznijmy od nginx. Jeśli nginx nie jest jeszcze zainstalowany na komputerze, zainstaluj go za pomocą sudo apt-get install nginx . Później musisz utworzyć nowy plik konfiguracyjny w katalogu nginx /etc/nginx/sites-enabled/yourapp.conf . Jeśli istnieje plik o nazwie default.conf - usuń go.

Poniżej kod do pliku conf nginx, który spróbuje uruchomić twoją usługę przy użyciu pliku gniazda; Później będzie konfiguracja gunicorn. Plik gniazda służy tutaj do komunikacji między nginx a gunicorn. Można to również zrobić za pomocą portów. 

# your application name; can be whatever you want
upstream yourappname {
    server        unix:/home/root/app/src/gunicorn.sock fail_timeout=0;
}

server {
    # root folder of your application
    root        /home/root/app/src/;
 
    listen        80;
    # server name, your main domain, all subdomains and specific subdomains
    server_name   yourdomain.com *.yourdomain.com somesubdomain.yourdomain.com
 
    charset       utf-8;

    client_max_body_size                        100m;
 
    # place where logs will be stored;
    # folder and files have to be already located there, nginx will not create
    access_log        /home/root/app/src/logs/nginx-access.log; 
    error_log         /home/root/app/src/logs/nginx-error.log;
    
    # this is where your app is served (gunicorn upstream above)
    location / {
        uwsgi_pass  yourappname;
        include     uwsgi_params; 
    }

    # static files folder, I assume they will be used
    location /static/ {
        alias         /home/root/app/src/static/;
    }
 
    # media files folder
    location /media/ {
        alias         /home/root/app/src/media/;
    }

}

GUNICORN

Teraz nasz skrypt GUNICORN, który będzie odpowiedzialny za uruchamianie aplikacji django na serwerze. Pierwszą rzeczą jest instalacja gunicorn w środowisku wirtualnym za pomocą pip install gunicorn . 

#!/bin/bash

ME="root"
DJANGODIR=/home/root/app/src # django app dir
SOCKFILE=/home/root/app/src/gunicorn.sock # your sock file - do not create it manually
USER=root
GROUP=webapps
NUM_WORKERS=3 
DJANGO_SETTINGS_MODULE=yourapp.yoursettings
DJANGO_WSGI_MODULE=yourapp.wsgi  
echo "Starting $NAME as `whoami`"
 
# Activate the virtual environment
cd $DJANGODIR

source /home/root/app/env/bin/activate
export DJANGO_SETTINGS_MODULE=$DJANGO_SETTINGS_MODULE
export PYTHONPATH=$DJANGODIR:$PYTHONPATH
 
# Create the run directory if it doesn't exist
RUNDIR=$(dirname $SOCKFILE)
test -d $RUNDIR || mkdir -p $RUNDIR
 
# Start your Django Gunicorn
# Programs meant to be run under supervisor should not daemonize themselves (do not use --daemon)
exec /home/root/app/env/bin/gunicorn ${DJANGO_WSGI_MODULE}:application \
  --name root \
  --workers $NUM_WORKERS \
  --user=$USER --group=$GROUP \
  --bind=unix:$SOCKFILE \
  --log-level=debug \
  --log-file=-

aby móc uruchomić skrypt startowy gunicorn, musi mieć włączony tryb wykonywania

sudo chmod u+x /home/root/app/src/gunicorn_start

teraz będziesz mógł uruchomić serwer gunicorn za pomocą ./gunicorn_start

KIEROWNIK

Jak powiedziano na początku, chcemy, aby nasza aplikacja została uruchomiona ponownie, gdy przełożony nie powiedzie się. Jeśli superwizor nie jest jeszcze zainstalowany na serwerze, zainstaluj sudo apt-get install supervisor .

Najpierw zainstaluj nadzorcę. Następnie utwórz plik .conf w katalogu głównym /etc/supervisor/conf.d/your_conf_file.conf

zawartość pliku konfiguracyjnego: 

[program:yourappname]
command = /home/root/app/src/gunicorn_start
user = root
stdout_logfile = /home/root/app/src/logs/gunicorn_supervisor.log
redirect_stderr = true

Krótkie streszczenie [program:youappname] jest wymagane na początku, będzie to nasz identyfikator. stdout_logfile to plik, w którym będą przechowywane dzienniki, zarówno dostępu, jak i błędów.

Po wykonaniu tej czynności musimy powiedzieć naszemu przełożonemu, że właśnie dodaliśmy nowy plik konfiguracyjny. Aby to zrobić, istnieje inny proces dla różnych wersji Ubuntu.

W przypadku Ubuntu version 14.04 or lesser , po prostu uruchom następujące polecenia:

sudo supervisorctl reread -> sudo supervisorctl reread czyta wszystkie pliki konfiguracyjne w katalogu superwizora powinno to zostać wydrukowane: twoja nazwa aplikacji: dostępna

sudo supervisorctl update -> aktualizuje superwizora do nowo dodanych plików konfiguracyjnych; powinien wydrukować swoją nazwę aplikacji: dodana grupa procesów

W przypadku Ubuntu 16.04 Run: 

sudo service supervisor restart

i aby sprawdzić, czy aplikacja działa poprawnie, po prostu uruchom

sudo supervisorctl status yourappname

Powinno to wyświetlić:

yourappname RUNNING pid 18020, uptime 0:00:50

Aby zobaczyć demonstrację tej procedury na żywo, przejrzyj ten film .

Wdrażanie lokalne bez konfigurowania apache / nginx

Zalecany sposób wdrożenia produkcyjnego wymaga użycia Apache / Nginx do obsługi zawartości statycznej. Dlatego też, gdy DEBUG jest fałszywy, a zawartość nośnika nie ładuje się. Możemy jednak załadować zawartość statyczną podczas wdrażania bez konieczności konfigurowania serwera Apache / Nginx dla naszej aplikacji przy użyciu: 

python manage.py runserver --insecure

Jest to przeznaczone wyłącznie do wdrażania lokalnego (np. LAN) i nigdy nie powinno być używane w środowisku produkcyjnym i jest dostępne tylko wtedy, gdy aplikacja staticfiles znajduje się w ustawieniu INSTALLED_APPS projektu.



Modified text is an extract of the original Stack Overflow Documentation
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow