Django
Distribuzione

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


Esecuzione dell'applicazione Django con Gunicorn

  1. Installa gunicorn

    pip install gunicorn

  1. Dalla cartella del progetto django (stessa cartella in cui si trova manage.py), eseguire il comando seguente per eseguire il progetto django corrente con gunicorn

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

    È possibile utilizzare l'opzione --env per impostare il percorso per caricare le impostazioni

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

    o eseguire come processo demone usando l'opzione -D

  1. All'avvio corretto di gunicorn, le seguenti righe appariranno in console

    Starting gunicorn 19.5.0

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

    .... (altre informazioni aggiuntive sul server gunicorn)

Distribuzione con Heroku

  1. Scarica Heroku Toolbelt .

  2. Passa alla radice dei sorgenti della tua app Django. Avrai bisogno di TK

  3. Digita heroku create [app_name] . heroku create [app_name] . Se non si fornisce un nome app, Heroku ne genererà uno a caso. L'URL della tua app sarà http://[app name].herokuapp.com

  4. Crea un file di testo con il nome Procfile . Non mettere un'estensione alla fine. 

    web: <bash command to start production server>

    Se hai un processo di lavoro, puoi aggiungerlo anche tu. Aggiungi un'altra riga nel formato: worker-name: <bash command to start worker>

  5. Aggiungi un requisito.txt.

  • Se si utilizza un ambiente virtuale, eseguire pip freeze > requirements.txt
  • Altrimenti, ottieni un ambiente virtuale! . Puoi anche elencare manualmente i pacchetti Python di cui hai bisogno, ma questo non sarà trattato in questo tutorial.

  1. È il momento dello spiegamento!

    1. git push heroku master

    Heroku ha bisogno di un repository git o di una cartella dropbox per fare distribuzioni. In alternativa puoi configurare il ricaricamento automatico da un repository GitHub su heroku.com , ma non lo heroku.com in questo tutorial.

    1. heroku ps:scale web=1

    Questo ridimensiona il numero di "dynos" web in uno. Qui puoi saperne di più sui dynos .

    1. heroku open o vai a http://app-name.herokuapp.com

    Suggerimento: heroku open apre l'URL della tua app heroku nel browser predefinito.

  2. Aggiungi componenti aggiuntivi . Dovrai configurare la tua app Django per legare con i database forniti in Heroku come "componenti aggiuntivi". Questo esempio non copre questo, ma un altro esempio è nella pipeline sulla distribuzione di database in Heroku.

Distribuzione remota semplice fabfile.py

Fabric è una libreria Python (2.5-2.7) e uno strumento da riga di comando per semplificare l'uso di SSH per la distribuzione delle applicazioni o le attività di amministrazione dei sistemi. Ti permette di eseguire funzioni arbitrarie di Python tramite la riga di comando.

Installa il tessuto tramite il pip install fabric
Crea fabfile.py nella tua directory principale: 

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

Per eseguire il file, usa semplicemente il comando fab : 

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

Nota: non è possibile configurare le chiavi ssh per github e digitare manualmente login e password, mentre fabfile esegue, lo stesso con le chiavi.

Usando Heroku Django Starter Template.

Se hai intenzione di ospitare il tuo sito Django su Heroku, puoi iniziare il tuo progetto usando il Template di avvio Heroku Django: 

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

Ha una configurazione pronta per la produzione per file statici, impostazioni database, Gunicorn, ecc. E miglioramenti alla funzionalità di file statici di Django tramite WhiteNoise. Questo ti farà risparmiare tempo, è completamente pronto per l'hosting su Heroku. Costruisci il tuo sito web in cima a questo modello

Per distribuire questo modello su Heroku: 

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

heroku create
git push heroku master

heroku run python manage.py migrate

Questo è tutto!

Istruzioni di distribuzione di Django. Nginx + Gunicorn + Supervisor su Linux (Ubuntu)

Tre strumenti di base.

  1. nginx: server HTTP e reverse proxy gratuito, open source e ad alte prestazioni, con prestazioni elevate;
  2. gunicorn - "Green Unicorn" è un server HTTP WSGI Python per UNIX (necessario per gestire il server);
  3. supervisore - un sistema client / server che consente agli utenti di monitorare e controllare un numero di processi su sistemi operativi UNIX-like. Utilizzato quando l'app o il sistema si bloccano, riavvia la tua webcam django / sedano / sedano, ecc;

Per semplificare, supponiamo che la tua app si trovi in ​​questa directory: /home/root/app/src/ e useremo l'utente root (ma dovresti creare un utente separato per la tua app). Anche il nostro ambiente virtuale si troverà in /home/root/app/env/ path.

Nginx

Iniziamo con nginx. Se nginx non è già sulla macchina, installalo con sudo apt-get install nginx . In seguito devi creare un nuovo file di configurazione nella tua directory nginx /etc/nginx/sites-enabled/yourapp.conf . Se c'è un file chiamato default.conf - rimuovilo.

Codice muggito in un file conf nginx, che proverà ad eseguire il tuo servizio usando il file socket; Più avanti ci sarà una configurazione di gunicorn. Il file socket è usato qui per comunicare tra nginx e gunicorn. Può anche essere fatto usando le porte. 

# 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

Ora il nostro script GUNICORN, che sarà responsabile dell'esecuzione dell'applicazione django sul server. La prima cosa è installare gunicorn in ambiente virtuale con 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=-

per poter eseguire lo script di avvio di gunicorn, è necessario che la modalità di esecuzione sia abilitata

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

ora sarai in grado di avviare il tuo server gunicorn semplicemente usando ./gunicorn_start

SUPERVISORE

Come detto all'inizio, vogliamo che la nostra applicazione venga riavviata quando fallisce un supervisore. Se supervisore non è ancora installato sul server con sudo apt-get install supervisor .

Al primo installatore supervisore. Quindi crea un file .conf nella directory principale /etc/supervisor/conf.d/your_conf_file.conf

contenuto del file di configurazione: 

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

Breve brief, [program:youappname] è richiesto all'inizio, sarà il nostro identificatore. anche stdout_logfile è un file in cui verranno memorizzati i registri, sia l'accesso che gli errori.

Fatto ciò, dobbiamo dire al nostro supervisore che abbiamo appena aggiunto un nuovo file di configurazione. Per farlo, c'è un processo diverso per la diversa versione di Ubuntu.

Per Ubuntu version 14.04 or lesser , semplicemente esegui quei comandi:

sudo supervisorctl reread -> rilegge tutti i file di configurazione all'interno del catalogo supervisore che dovrebbe essere stampato: yourappname: available

sudo supervisorctl update -> aggiorna il supervisore ai file di configurazione appena aggiunti; dovrebbe stampare yourappname: aggiunto gruppo di processi

Per Ubuntu 16.04 Esegui: 

sudo service supervisor restart

e per verificare se la tua app funziona correttamente, esegui

sudo supervisorctl status yourappname

Questo dovrebbe mostrare:

yourappname RUNNING pid 18020, uptime 0:00:50

Per ottenere la dimostrazione dal vivo di questa procedura, naviga questo video .

Distribuzione locale senza impostazione di apache / nginx

Il modo consigliato per l'implementazione della produzione richiede l'uso di Apache / Nginx per servire il contenuto statico. Pertanto, quando DEBUG è falso statico e il contenuto multimediale non viene caricato. Tuttavia, possiamo caricare il contenuto statico nella distribuzione senza dover configurare il server Apache / Nginx per la nostra app utilizzando: 

python manage.py runserver --insecure

Questo è destinato esclusivamente per la distribuzione locale (ad esempio, LAN) e non dovrebbe mai essere utilizzato nella produzione ed è disponibile solo se lo staticfiles app è in del progetto INSTALLED_APPS impostazione.



Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow