Django => Spridning

Kör Django-applikation med Gunicorn

Installera gunicorn
pip install gunicorn

Från django-projektmappen (samma mapp där manage.py finns), kör följande kommando för att köra aktuellt django-projekt med gunicorn
gunicorn [projectname].wsgi:application -b 127.0.0.1:[port number]

Du kan använda alternativet --env att ställa in sökvägen för att ladda inställningarna
gunicorn --env DJANGO_SETTINGS_MODULE=[projectname].settings [projectname].wsgi

eller kör som daemon-process med -D alternativet

Efter en lyckad start av gunicorn kommer följande rader att visas i konsolen
Starting gunicorn 19.5.0

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

.... (annan ytterligare information om gunicorn-server)

Distribuera med Heroku

Ladda ner Heroku Toolbelt .
Navigera till roten till källorna till din Django-app. Du behöver tk
Skriv heroku create [app_name] . Om du inte anger ett appnamn genererar Heroku slumpmässigt ett för dig. Din app-URL kommer att vara http://[app name].herokuapp.com
Skapa en textfil med namnet Procfile . Lägg inte en förlängning i slutet.
```
web: <bash command to start production server>
```
Om du har en arbetarprocess kan du lägga till den också. Lägg till en annan rad i formatet: worker-name: <bash command to start worker>
Lägg till ett krav.txt.

Om du använder en virtuell miljö, kör pip freeze > requirements.txt
Annars få en virtuell miljö! . Du kan också lista de Python-paket du behöver manuellt, men det kommer inte att täckas i denna handledning.

Det är distributionstid!
1. git push heroku master
Heroku behöver ett git-arkiv eller en dropbox-mapp för att göra uttag. Du kan alternativt ställa in automatisk omlastning från ett GitHub-arkiv på heroku.com , men det täcker vi inte i den här handledningen.
1. heroku ps:scale web=1
Detta skalar antalet webbdynos till en. Du kan lära dig mer om dynos här.
1. heroku open eller navigera till http://app-name.herokuapp.com
Tips: heroku open öppnar URL: n till din heroku-app i standardwebbläsaren.
Lägg till tillägg . Du måste konfigurera din Django-app så att den binds med databaser som tillhandahålls i Heroku som "tillägg". Det här exemplet täcker inte detta, men ett annat exempel finns i pipeline för att distribuera databaser i Heroku.

Enkel fjärrinstallation fabfile.py

Fabric är ett Python (2.5-2.7) bibliotek och kommandoradsverktyg för att effektivisera användningen av SSH för applikationsdistribution eller systemadministrationsuppgifter. Det låter dig köra godtyckliga Python-funktioner via kommandoraden.

Installera tyg via pip install fabric
Skapa fabfile.py i din rotkatalog:

#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')

För att köra filen använder du bara fab kommandot:

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

Obs! Du kan inte konfigurera ssh-nycklar för github och bara skriva in inloggning och lösenord manuellt, medan fabfile körs, samma med nycklar.

Använda Heroku Django-startmall.

Om du planerar att vara värd för din Django-webbplats på Heroku kan du starta ditt projekt med Heroku Django Starter Mall:

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

Den har produktionsklar konfiguration för statiska filer, databasinställningar, Gunicorn osv. Och förbättringar till Djangos statiska filtjänstfunktioner via WhiteNoise. Detta sparar din tid, det är helt klart för värd på Heroku. Bygg bara din webbplats högst upp i den här mallen

För att distribuera denna mall på Heroku:

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

heroku create
git push heroku master

heroku run python manage.py migrate

Det är allt!

Django-installationsinstruktioner. Nginx + Gunicorn + Supervisor på Linux (Ubuntu)

Tre grundläggande verktyg.

nginx - gratis, öppen källkod, högpresterande HTTP-server och omvänd proxy, med hög prestanda;
gunicorn - 'Green Unicorn' är en Python WSGI HTTP-server för UNIX (behövs för att hantera din server);
handledare - ett klient / serversystem som gör det möjligt för sina användare att övervaka och kontrollera ett antal processer på UNIX-liknande operativsystem. Används när din app eller system kraschar, startar om din django / selleri / selleri cam, etc;

För att göra det enkelt, låt oss anta att din app finns i den här katalogen: /home/root/app/src/ och vi ska använda root användare (men du bör skapa en separat användare för din app). Vårt virtuella miljö kommer också att finnas i /home/root/app/env/ path.

Nginx

Låt oss börja med nginx. Om nginx inte redan finns på maskinen, installera det med sudo apt-get install nginx . Senare måste du skapa en ny konfigurationsfil i din nginx-katalog /etc/nginx/sites-enabled/yourapp.conf . Om det finns en fil med namnet default.conf - ta bort den.

Bälgkod till en nginx conf-fil, som kommer att försöka köra din tjänst med hjälp av socket-fil; Senare kommer det att finnas en konfiguration av gunicorn. Socket-fil används här för att kommunicera mellan nginx och gunicorn. Det kan också göras med användning av portar.

# 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

Nu är vårt GUNICORN-skript, som kommer att ansvara för att köra django-applikation på servern. Det första är att installera gunicorn i virtuell miljö med 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=-

för att kunna köra gunicorn-startskript måste det ha körningsläge aktiverat så

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

nu kommer du att kunna starta din gunicorn-server med bara att använda ./gunicorn_start

HANDLEDARE

Som sagt i början vill vi att vår ansökan ska startas om när en handledare misslyckas. Om handledare ännu inte på serverinstallation med sudo apt-get install supervisor .

Först installerar handledaren. .conf en .conf fil i din huvudkatalog /etc/supervisor/conf.d/your_conf_file.conf

konfigurationsfilens innehåll:

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

Snabböversikt, [program:youappname] krävs i början, det kommer att vara vår identifierare. stdout_logfile är också en fil där loggar kommer att lagras, både åtkomst och fel.

Efter att ha gjort det måste vi berätta för vår handledare att vi just har lagt till en ny konfigurationsfil. För att göra det finns det olika processer för olika Ubuntu-versioner.

För Ubuntu version 14.04 or lesser än den, kör helt enkelt dessa kommandon:

sudo supervisorctl reread -> läser om alla konfigurationsfiler i handledarkatalogen. Detta bör skriva ut: dittappnamn: tillgängligt

sudo supervisorctl update -> uppdaterar handledaren till nyligen tillagda konfigurationsfiler; ska skriva ut ditt namn: tillagd processgrupp

För Ubuntu 16.04 Run:

sudo service supervisor restart

och för att kontrollera om din app körs korrekt kör du bara

sudo supervisorctl status yourappname

Detta bör visa:

yourappname RUNNING pid 18020, uptime 0:00:50

För att få live demonstration av denna procedur, surfa på den här videon .

Distribuera lokalt utan att konfigurera apache / nginx

Rekommenderat sätt att producera distribution kräver att Apache / Nginx används för att betjäna det statiska innehållet. Således, när DEBUG är falskt statiskt och mediainnehållet inte laddas. Vi kan dock ladda det statiska innehållet i distributionen utan att behöva installera Apache / Nginx-servern för vår app med:

python manage.py runserver --insecure

Detta är endast avsett för lokal distribution (t.ex. LAN) och ska aldrig användas i produktion och är endast tillgängligt om staticfiles appen finns i inställningen INSTALLED_APPS ditt projekt.

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

Django
Spridning

Sök…