Django: Comment gérer le développement et la production de paramètres?

Par défaut pour utiliser les paramètres de production, mais de créer un fichier appelé settings_dev.py dans le même dossier que votre settings.py fichier. Ajouter remplace là, comme DEBUG=True.

Sur l'ordinateur qui sera utilisé pour le développement, ajoutez ceci à votre ~/.bashrc fichier:

export DJANGO_DEVELOPMENT=true

Au bas de votre settings.py fichier, ajoutez la ligne suivante.

# Override production variables if DJANGO_DEVELOPMENT env variable is set
if os.environ.get('DJANGO_DEVELOPMENT') is not None:
    from settings_dev import * 

(Noter que l'importation de * doit généralement être évitée en Python, mais c'est un cas unique)

Par défaut, les serveurs de production ne sera pas remplacer quoi que ce soit. Fait!

Par rapport aux autres réponses, c'est plus simple car elle ne nécessite pas de mise à jour PYTHONPATH, ou la mise en DJANGO_SETTINGS_MODULE qui ne vous permet de travailler sur un projet django à la fois.

C'est comment je le faire en 6 étapes faciles:

1. Créer un dossier à l'intérieur de votre projet, le répertoire et le nom settings.

   structure de projet:

   myproject/
          myapp1/
          myapp2/              
          myproject/
                 settings/

2. Créer quatre fichiers python à l'intérieur de la settings répertoire à savoir __init__.py, base.py, dev.py et prod.py

   fichiers de paramètres:

   settings/
        __init__.py
        base.py
        prod.py
        dev.py 

3. Ouvrir __init__.py et de le remplir avec le contenu suivant:

   __init__.py:

   from .base import *
   # you need to set "myproject = 'prod'" as an environment variable
   # in your OS (on which your website is hosted)
   if os.environ['myproject'] == 'prod':
      from .prod import *
   else:
      from .dev import *

4. Ouvrir base.py et de le remplir avec tous les paramètres communs (qui sera utilisé dans la production ainsi que le développement.) par exemple:

   base.py:

   import os
   ...
   INSTALLED_APPS = [...]
   MIDDLEWARE = [...]
   TEMPLATES = [{...}]
   ...
   STATIC_URL = '/static/'
   STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
   MEDIA_ROOT = os.path.join(BASE_DIR, '/path/')
   MEDIA_URL = '/path/'

5. Ouvrir dev.py et de l'inclure stuff, qui est un développement spécifique par exemple:

   dev.py:

   DEBUG = True
   ALLOWED_HOSTS = ['localhost']
   ...

6. Ouvrir prod.py et comprennent ce genre de choses qui est de la production spécifique par exemple:

   prod.py:

   DEBUG = False
   ALLOWED_HOSTS = ['www.example.com']
   LOGGING = [...]
   ...

Ici est l'approche que nous utilisons :

• un settings module de paramètres de split en plusieurs fichiers pour des raisons de lisibilité ;
• un .env.json fichier pour stocker les informations d'identification et les paramètres que nous voulons exclus de notre dépôt git, ou qui sont spécifiques d'environnement ;
• un env.py fichier à lire le .env.json fichier

Compte tenu de la structure suivante :

...
.env.json           # the file containing all specific credentials and parameters
.gitignore          # the .gitignore file to exclude `.env.json`
project_name/       # project dir (the one which django-admin.py creates)
  accounts/         # project's apps
    __init__.py
    ...
  ...
  env.py            # the file to load credentials
  settings/
    __init__.py     # main settings file
    database.py     # database conf
    storage.py      # storage conf
    ...
venv                # virtualenv
...

Avec .env.json comme :

{
    "debug": false,
    "allowed_hosts": ["mydomain.com"],
    "django_secret_key": "my_very_long_secret_key",
    "db_password": "my_db_password",
    "db_name": "my_db_name",
    "db_user": "my_db_user",
    "db_host": "my_db_host",
}

Et project_name/env.py :

<!-- language: lang-python -->
import json
import os


def get_credentials():
    env_file_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    with open(os.path.join(env_file_dir, '.env.json'), 'r') as f:
        creds = json.loads(f.read())
    return creds


credentials = get_credentials()

Nous pouvons avoir les paramètres suivants:

<!-- language: lang-py -->
# project_name/settings/__init__.py
from project_name.env import credentials
from project_name.settings.database import *
from project_name.settings.storage import *
...

SECRET_KEY = credentials.get('django_secret_key')

DEBUG = credentials.get('debug')

ALLOWED_HOSTS = credentials.get('allowed_hosts', [])

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    ...
]

if DEBUG:
    INSTALLED_APPS += ['debug_toolbar']

...

# project_name/settings/database.py
from project_name.env import credentials

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': credentials.get('db_name', ''),
        'USER': credentials.get('db_user', ''),
        'HOST': credentials.get('db_host', ''),
        'PASSWORD': credentials.get('db_password', ''),
        'PORT': '5432',
    }
}

les avantages de cette solution sont :

• spécifique à l'utilisateur, les informations d'identification et les configurations pour le développement local, sans modifier le dépôt git ;
• environnement de configuration spécifiques, vous pouvez avoir par exemple trois environnements différents, avec trois différents .env.json comme dev, stagging et de la production ;
• informations d'identification ne sont pas dans le référentiel

J'espère que cette aide, laissez-moi savoir si vous voyez des mises en garde avec cette solution.

construction d'cs01 réponse:

si vous rencontrez des problèmes avec la variable d'environnement, de définir sa valeur à une chaîne de caractères (par exemple, je n'ai DJANGO_DEVELOPMENT="true").

J'ai aussi changé cs01 du fichier de flux de travail comme suit:

#settings.py
import os
if os.environ.get('DJANGO_DEVELOPMENT') is not None:
    from settings_dev import * 
else:
    from settings_production import *
#settings_dev.py
development settings go here
#settings_production.py
production settings go here

De cette façon, Django n'a pas de lire l'intégralité d'un fichier de paramètres avant de lancer les paramètres appropriés de fichier. Cette solution est très pratique si votre fichier de production les besoins de trucs qui sont seulement sur votre serveur de production.

Remarque: en Python 3, les fichiers importés doivent avoir une . ajoutée (par exemple,from .settings_dev import *)

Si vous voulez garder 1 fichier de paramètres, et le développement de votre système d'exploitation est différent de celui de votre production, système d'exploitation, vous pouvez le placer au fond de votre settings.py:

from sys import platform
if platform == "linux" or platform == "linux2":
    # linux
    # some special setting here for when I'm on my prod server
elif platform == "darwin":
    # OS X
    # some special setting here for when I'm developing on my mac
elif platform == "win32":
    # Windows...
    # some special setting here for when I'm developing on my pc

Lire la suite: Comment puis-je vérifier le système d'exploitation en Python?

Utilisation settings.py pour la production. Dans le même répertoire créer settings_dev.py pour des remplacements.

# settings_dev.py

from .settings import * 

DEBUG = False

Sur une machine de dev exécuter votre Django app avec:

DJANGO_SETTINGS_MODULE=<your_app_name>.settings_dev python3 manage.py runserver

Sur une prod de la machine comme si vous veniez settings.py et rien d'autre.

AVANTAGES

1. settings.py (utilisé pour la production) est complètement agnostique au fait que tous les autres environnements existent encore.
2. Pour voir la différence entre la prod et dev vous regardez simplement dans un emplacement unique - settings_dev.py. Pas besoin de recueillir des configurations dispersés à travers settings_prod.py, settings_dev.py et settings_shared.py.
3. Si quelqu'un ajoute un paramètre à votre prod config après le dépannage d'un problème de production, vous pouvez être assuré qu'il apparaîtra dans votre dev config comme bien (sauf s'il est explicitement remplacée). Ainsi, la divergence entre les différents fichiers de configuration seront réduits au minimum.