Django
Déploiement

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


Lancer l'application Django avec Gunicorn

  1. Installez gunicorn

    pip install gunicorn

  1. À partir du dossier de projet django (même dossier où se trouve manage.py), exécutez la commande suivante pour exécuter le projet django actuel avec gunicorn

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

    Vous pouvez utiliser l'option --env pour définir le chemin d'accès aux paramètres

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

    ou exécuter en tant que processus démon en utilisant l'option -D

  1. Après un démarrage réussi du gunicorn, les lignes suivantes apparaîtront dans la console

    Starting gunicorn 19.5.0

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

    .... (autres informations supplémentaires sur le serveur gunicorn)

Déploiement avec Heroku

  1. Téléchargez Heroku Toolbelt .

  2. Accédez à la racine des sources de votre application Django. Vous aurez besoin de tk

  3. Tapez heroku create [app_name] . Si vous ne donnez pas de nom à une application, Heroku en générera un au hasard pour vous. L'URL de votre application sera http://[app name].herokuapp.com

  4. Créez un fichier texte nommé Procfile . Ne mettez pas une extension à la fin. 

    web: <bash command to start production server>

    Si vous avez un processus de travail, vous pouvez l’ajouter également. Ajoutez une autre ligne au format suivant: worker-name: <bash command to start worker>

  5. Ajouter un requirements.txt.

  • Si vous utilisez un environnement virtuel, exécutez pip freeze > requirements.txt
  • Sinon, obtenez un environnement virtuel! . Vous pouvez également lister manuellement les paquets Python dont vous avez besoin, mais cela ne sera pas couvert dans ce tutoriel.

  1. C'est le temps de déploiement!

    1. git push heroku master

    Heroku a besoin d'un référentiel git ou d'un dossier déroulant pour effectuer des déploiements. Vous pouvez également configurer le rechargement automatique à partir d'un dépôt GitHub sur heroku.com , mais nous ne couvrirons pas cela dans ce tutoriel.

    1. heroku ps:scale web=1

    Cela fait passer le nombre de "dynos" Web à un. Vous pouvez en apprendre plus sur les dynos ici.

    1. heroku open ou naviguer sur http://app-name.herokuapp.com

    Astuce: heroku open ouvre l'URL de votre application heroku dans le navigateur par défaut.

  2. Ajouter des modules complémentaires . Vous devrez configurer votre application Django pour la lier aux bases de données fournies dans Heroku en tant que "modules complémentaires". Cet exemple ne couvre pas cela, mais un autre exemple est en préparation pour le déploiement de bases de données dans Heroku.

Déploiement à distance simple fabfile.py

Fabric est une bibliothèque et un outil de ligne de commande Python (2.5-2.7) permettant de rationaliser l'utilisation de SSH pour les tâches de déploiement d'applications ou d'administration de systèmes. Il vous permet d'exécuter des fonctions Python arbitraires via la ligne de commande.

Installez le tissu à l’aide du pip install fabric
Créez fabfile.py dans votre répertoire racine: 

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

Pour exécuter le fichier, utilisez simplement la commande fab : 

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

Remarque: vous ne pouvez pas configurer les clés ssh pour github et tapez simplement login et mot de passe manuellement, alors que fabfile fonctionne, de même avec les clés.

Utilisation du modèle de démarrage Heroku Django.

Si vous envisagez d’héberger votre site Web Django sur Heroku, vous pouvez démarrer votre projet en utilisant le modèle de démarrage Heroku Django: 

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

Il a une configuration prête pour la production pour les fichiers statiques, les paramètres de base de données, Gunicorn, etc. Cela vous fera gagner du temps, c'est tout prêt pour l'hébergement sur Heroku, construisez simplement votre site web en haut de ce modèle.

Pour déployer ce modèle sur Heroku: 

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

heroku create
git push heroku master

heroku run python manage.py migrate

C'est tout!

Instructions de déploiement Django. Nginx + Gunicorn + Superviseur sur Linux (Ubuntu)

Trois outils de base.

  1. nginx - un serveur HTTP et un proxy inversé open source, haute performance et gratuit, avec de hautes performances;
  2. gunicorn - 'Green Unicorn' est un serveur HTTP WSGI Python pour UNIX (nécessaire pour gérer votre serveur);
  3. supervisor - un système client / serveur qui permet à ses utilisateurs de surveiller et de contrôler un certain nombre de processus sur des systèmes d'exploitation de type UNIX. Utilisé lorsque votre application ou le système tombe en panne, redémarre votre caméra django / celery / celery, etc.

Pour que ce soit simple, supposons que votre application se trouve dans ce répertoire: /home/root/app/src/ et nous allons utiliser root utilisateur root (mais vous devez créer un utilisateur séparé pour votre application). De plus, notre environnement virtuel sera situé dans /home/root/app/env/ path.

NGINX

Commençons par nginx. Si nginx n'est pas déjà sur la machine, installez-le avec sudo apt-get install nginx . Plus tard, vous devez créer un nouveau fichier de configuration dans votre répertoire nginx /etc/nginx/sites-enabled/yourapp.conf . S'il existe un fichier nommé default.conf , supprimez-le.

Code ci-dessous dans un fichier de configuration nginx, qui essaiera d'exécuter votre service en utilisant un fichier de socket; Plus tard, il y aura une configuration de gunicorn. Le fichier Socket est utilisé ici pour communiquer entre nginx et gunicorn. Cela peut aussi être fait avec les ports. 

# 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

Maintenant, notre script GUNICORN, qui sera responsable de l'exécution de l'application django sur le serveur. La première chose à faire est d'installer gunicorn dans un environnement virtuel avec 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=-

afin de pouvoir exécuter le script de démarrage gunicorn, il doit avoir le mode d'exécution activé pour

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

maintenant vous pourrez démarrer votre serveur ./gunicorn_start utilisant simplement ./gunicorn_start

SUPERVISEUR

Comme indiqué au début, nous voulons que notre application soit redémarrée en cas d’échec d’un superviseur. Si superviseur pas encore sur le serveur, installez avec le sudo apt-get install supervisor .

Au premier installez le superviseur. Ensuite, créez un fichier .conf dans votre répertoire principal /etc/supervisor/conf.d/your_conf_file.conf

contenu du fichier de configuration: 

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

Bref bref, [program:youappname] est requis au début, ce sera notre identifiant. Le fichier stdout_logfile est également un fichier dans lequel les journaux seront stockés, à la fois l’accès et les erreurs.

Cela fait, nous devons dire à notre superviseur que nous venons d'ajouter un nouveau fichier de configuration. Pour ce faire, il existe différents processus pour différentes versions d'Ubuntu.

Pour Ubuntu version 14.04 or lesser , lancez simplement ces commandes:

sudo supervisorctl reread -> relit tous les fichiers de configuration du catalogue des superviseurs, cela devrait s'imprimer: votre nomappli: disponible

sudo supervisorctl update -> met à jour le superviseur pour les fichiers de configuration nouvellement ajoutés; devrait imprimer votre nomapplication: groupe de processus ajouté

Pour Ubuntu 16.04 Exécuter: 

sudo service supervisor restart

et pour vérifier si votre application fonctionne correctement, exécutez simplement

sudo supervisorctl status yourappname

Cela devrait afficher:

yourappname RUNNING pid 18020, uptime 0:00:50

Pour obtenir une démonstration en direct de cette procédure, naviguez sur cette vidéo .

Déployer localement sans configurer apache / nginx

Déploiement recommandé du mode de production pour utiliser Apache / Nginx pour servir le contenu statique. Ainsi, lorsque DEBUG est faux, le contenu statique et le contenu du support ne peuvent pas être chargés. Cependant, nous pouvons charger le contenu statique en déploiement sans avoir à configurer le serveur Apache / Nginx pour notre application en utilisant: 

python manage.py runserver --insecure

Ceci est uniquement destiné au déploiement local (par exemple LAN) et ne doit jamais être utilisé en production et n'est disponible que si l'application staticfiles trouve dans le paramètre INSTALLED_APPS votre projet.



Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow