Django
Despliegue

AngularJS CSS HTML JavaScript jQuery MongoDB MySQL postgresql Python Language SQL
Buscar..


Ejecutando la aplicación Django con Gunicorn

  1. Instalar gunicorn

    pip install gunicorn

  1. Desde la carpeta del proyecto django (la misma carpeta donde reside manage.py), ejecute el siguiente comando para ejecutar el proyecto actual de django con gunicorn

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

    Puede usar la opción --env para configurar la ruta de acceso para cargar la configuración

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

    o ejecutar como proceso daemon usando la opción -D

  1. Al iniciar con éxito gunicorn, las siguientes líneas aparecerán en la consola

    Starting gunicorn 19.5.0

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

    .... (otra información adicional sobre el servidor gunicorn)

Desplegando con Heroku

  1. Descargar Heroku Toolbelt .

  2. Navegue a la raíz de las fuentes de su aplicación Django. Necesitarás tk

  3. Escribe heroku create [app_name] . Si no das un nombre de aplicación, Heroku generará una aleatoriamente para ti. La URL de su aplicación será http://[app name].herokuapp.com

  4. Haga un archivo de texto con el nombre Procfile . No pongas una extensión al final. 

    web: <bash command to start production server>

    Si tiene un proceso de trabajo, puede agregarlo también. Agregue otra línea en el formato: worker-name: <bash command to start worker>

  5. Añadir un requisito.txt.

  • Si está utilizando un entorno virtual, ejecute pip freeze > requirements.txt
  • De lo contrario, consigue un entorno virtual! . También puede listar manualmente los paquetes de Python que necesita, pero eso no se tratará en este tutorial.

  1. ¡Es tiempo de despliegue!

    1. git push heroku master

    Heroku necesita un repositorio git o una carpeta de Dropbox para realizar implementaciones. Alternativamente, puede configurar la recarga automática desde un repositorio de GitHub en heroku.com , pero no lo cubriremos en este tutorial.

    1. heroku ps:scale web=1

    Esto escala el número de web "dynos" a uno. Puedes aprender más sobre dynos aquí.

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

    Consejo: heroku open abre la URL de su aplicación heroku en el navegador predeterminado.

  2. Añadir complementos . Tendrá que configurar su aplicación Django para enlazar con las bases de datos proporcionadas en Heroku como "complementos". Este ejemplo no cubre esto, pero otro ejemplo está en la tubería de implementación de bases de datos en Heroku.

Despliegue remoto simple fabfile.py

Fabric es una biblioteca de Python (2.5-2.7) y una herramienta de línea de comandos para agilizar el uso de SSH para la implementación de aplicaciones o tareas de administración de sistemas. Te permite ejecutar funciones de Python arbitrarias a través de la línea de comandos.

Instalar la tela a través de la pip install fabric
Crea fabfile.py en tu directorio raíz: 

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

Para ejecutar el archivo, simplemente use el comando fab : 

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

Nota: no puede configurar las claves ssh para github y simplemente escriba inicio de sesión y contraseña manualmente, mientras se ejecuta fabfile, lo mismo que con las claves.

Usando Heroku Django Starter Template.

Si planea alojar su sitio web de Django en Heroku, puede comenzar su proyecto usando la plantilla de inicio de Heroku Django: 

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

Tiene una configuración lista para producción para archivos estáticos, configuraciones de base de datos, Gunicorn, etc. y mejoras en la funcionalidad de servicio de archivos estáticos de Django a través de WhiteNoise. Esto le ahorrará tiempo, está listo para hospedarse en Heroku, simplemente cree su sitio web en la parte superior de esta plantilla

Para desplegar esta plantilla en Heroku: 

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

heroku create
git push heroku master

heroku run python manage.py migrate

¡Eso es!

Instrucciones de despliegue de Django. Nginx + Gunicorn + Supervisor en Linux (Ubuntu)

Tres herramientas básicas.

  1. nginx: servidor HTTP de alto rendimiento, de código abierto y gratuito, y proxy inverso, con alto rendimiento;
  2. gunicorn - 'Green Unicorn' es un servidor HTTP WSGI de Python para UNIX (necesario para administrar su servidor);
  3. supervisor: un sistema cliente / servidor que permite a sus usuarios monitorear y controlar una serie de procesos en sistemas operativos similares a UNIX. Se utiliza cuando la aplicación o el sistema se bloquea, reinicia la cámara de django / celery / apio, etc .;

Para simplificarlo, supongamos que su aplicación se encuentra en este directorio: /home/root/app/src/ y usaremos un usuario root (pero debe crear un usuario separado para su aplicación). También nuestro entorno virtual se ubicará en /home/root/app/env/ path.

NGINX

Vamos a empezar con nginx. Si nginx no está ya en la máquina, instálelo con sudo apt-get install nginx . Más adelante, tendrá que crear un nuevo archivo de configuración en su directorio nginx /etc/nginx/sites-enabled/yourapp.conf . Si hay un archivo llamado default.conf , elimínelo.

Bellow código a un archivo conf nginx, que intentará ejecutar su servicio con el uso de archivo de socket; Más adelante habrá una configuración de gunicorn. El archivo de socket se usa aquí para comunicarse entre nginx y gunicorn. También se puede hacer utilizando puertos. 

# 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

Ahora nuestro script GUNICORN, que será responsable de ejecutar la aplicación django en el servidor. Lo primero es instalar gunicorn en un entorno virtual 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=-

para poder ejecutar el script de inicio gunicorn tiene que tener el modo de ejecución habilitado para que

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

ahora podrá iniciar su servidor gunicorn con solo usar ./gunicorn_start

SUPERVISOR

Como se dijo al principio, queremos que nuestra aplicación se reinicie cuando un supervisor falla. Si el supervisor aún no está en el servidor, instale con sudo apt-get install supervisor .

Al principio instalar supervisor. Luego cree un archivo .conf en su directorio principal /etc/supervisor/conf.d/your_conf_file.conf

contenido del archivo de configuración: 

[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 [program:youappname] se requiere [program:youappname] al principio, será nuestro identificador. también stdout_logfile es un archivo donde se almacenarán los registros, tanto de acceso como de errores.

Una vez hecho esto, tenemos que decirle a nuestro supervisor que acabamos de agregar un nuevo archivo de configuración. Para hacerlo, hay diferentes procesos para diferentes versiones de Ubuntu.

Para la Ubuntu version 14.04 or lesser , simplemente ejecute esos comandos:

sudo supervisorctl reread -> vuelve a leer todos los archivos de configuración dentro del catálogo de supervisor, esto debería imprimirse: nombre de aplicación: disponible

sudo supervisorctl update -> actualiza supervisor a los archivos de configuración recién agregados; debe imprimir su nombre de aplicación: grupo de proceso agregado

Para Ubuntu 16.04 Ejecutar: 

sudo service supervisor restart

y para comprobar si su aplicación se está ejecutando correctamente, simplemente ejecute

sudo supervisorctl status yourappname

Esto debería mostrar:

yourappname RUNNING pid 18020, uptime 0:00:50

Para obtener una demostración en vivo de este procedimiento, navegue este video .

Despliegue localmente sin configurar apache / nginx

La forma recomendada de implementación de producción requiere el uso de Apache / Nginx para servir el contenido estático. Por lo tanto, cuando DEBUG es falsa estática y los contenidos de los medios no se cargan. Sin embargo, podemos cargar el contenido estático en la implementación sin tener que configurar el servidor Apache / Nginx para nuestra aplicación usando: 

python manage.py runserver --insecure

Esto solo está destinado a la implementación local (por ejemplo, LAN) y nunca debe usarse en producción y solo está disponible si la aplicación staticfiles está en la configuración INSTALLED_APPS su proyecto.



Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow