Dos cucharadas de Django configuración del archivo de configuración recomendada y Requisitos

El principio básico

Django 1.8 aproximadamente 140 artículos se pueden establecer por el módulo de opciones de configuración. la configuración de inicialización del módulo cada vez que se inicia el servicio de Django, por lo que el settings.py archivo modificado, Django debe reiniciar el servidor para tener efecto.

1. Todo el archivo de configuración debe ser el control de versiones, los elementos de configuración, incluyendo la información de la fecha de modificación / hora y los comentarios de control de versiones

2. SECO, por import base_settingsheredar, evitar copiar y pegar

3. La información confidencial no en el control de versiones

El uso de múltiples archivos de configuración

settings/
    __init__.py
    base.py
    local.py
    staging.py
    test.py
    production.py

Los ajustes correspondientes a cada archivo y unos requisitos de archivo

configuración de nombre de archivo | finalidad
----------------------- |
local.py , dev.py | configuración del entorno de desarrollo de contenidos locales, tales como DEBUG=Trueabierta django-debug- barra de herramientas, etc.
staging.py | contenido configure para la estadificación etapa
test.py | contenido configurar para ejecutar pruebas
production.py , prod.py | contenido de configuración en entornos de producción
ci.py | Configurar contenido para el servidor de integración continua

Modo de empleo:

1. la cáscara

python manage.py shell --settings=twoscoops.settings.local

2. Servicio de inicio

python manage.py runserver --settings=twoscoops.settings.local

3. Conjunto DJANGO_SETTINGS_MODULE y PYTHONPATH variable de entorno. Si se utiliza el virtualenv , se puede ajustar a las secuencias de comandos Activar para cada entorno DJANGO_SETTINGS_MODULE y la PYTHONPATH .

Un ejemplo de archivo de configuración en el entorno de desarrollo:

# settings/local.py
from .base import *

DEBUG = True

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql_psycopg2",
        "NAME": "twoscoops",
        "USER": "",
        "PASSWORD": "",
        "HOST": "localhost",
        "PORT": "",
    }
}

INSTALLED_APPS += ("debug_toolbar", )

En el ejemplo anterior tiene from .base import *, que es import *a favor de la utilización Django es el único lugar. Porque queremos cubrir todo el espacio de nombres en el archivo de configuración.

Para el entorno de desarrollo también puede tener varios archivos de configuración

El principio básico es que cada archivo de configuración necesita el control de versiones. Puede crear los archivos de configuración apropiados para diferentes desarrolladores, tales como:

# settings/dev_pydanny.py
from .dev import *

# Set short cache timeout
CACHE_TIMEOUT = 30

Y después de todos los ajustes de los archivos creados serían:

settings/
    __init__.py
    base.py
    dev.py
    dev_audreyr.py
    dev_pydanny.py
    local.py
    staging.py
    test.py
    production.py

La separación de la información de configuración desde el código

El SECRET_KEY , API KEY y otra información almacenada en la base de código tiene los siguientes problemas:

1. La información de cada despliegue cambio debe

2. Secret_key valores de configuración equivalentes, no el código

3. El código almacenado en la biblioteca, hay librerías de código de acceso a personas que pueden ver

4. La mayoría PaaS no proporciona capacidades de configuración para un único servidor

La solución es utilizar variables de entorno .

Ambiente del uso variable para contener SECRET_KEY beneficia información tal como:

1. Dado que esta información sensible se ha guardado en otro lugar, que no dudarán en el control de versiones para cada archivo

2. Para cada despliegue, lo que elimina la necesidad de modificar la información de configuración

3. Se recomienda la mayor plataforma PaaS utilizar variables de entorno, y proporciona herramientas de configuración y administración corresponde

Cómo establecer variables de entorno en el local de

En Linux / Mac la fiesta agregado por código de configuración a .bashrc , .bash_profile o .profile detrás de los otros archivos de configuración. El uso virtualenv , puede estar en el virtualenv bin / active configure añadiendo el código de configuración en la secuencia de comandos:

código de configuración:

$ export SOME_SECRET_KEY=1c3-cr3am-15-yummy

$ export AUDREY_FREEZER_KEY=y34h-r1ght-d0nt-t0uch-my-1c3-cr34m

En Win, puede cmd.exe por el setx comando de configuración puede estar en el virtualenv bin / activate.bat script de configuración.

código de configuración:

> set SOME_SECRET_KEY 1c3-cr3am-15-yummy

PowerShell de cmd.exe más potente, disponible en Vista y versiones superiores. variable ambiental se establece para utilizar PowerShell:

Sólo para el usuario actual:

[Environment]::SetEnvironmentVariable("SOME_SECRET_KEY",
                                     "1c3-cr3am-15-yummy", "User")
[Environment]::SetEnvironmentVariable("AUDREY_FREEZER_KEY",
                        "y34h-r1ght-d0nt-t0uch-my-1c3-cr34m", "User")

Para todos los usuarios de la máquina:

[Environment]::SetEnvironmentVariable("SOME_SECRET_KEY",
                                "1c3-cr3am-15-yummy", "Machine")
[Environment]::SetEnvironmentVariable("AUDREY_FREEZER_KEY",
                        "y34h-r1ght-d0nt-t0uch-my-1c3-cr34m", "Machine")

las variables de entorno de producción Ejemplo de configuración

1. Se configura en Heroku

$ heroku config:set SOME_SECRET_KEY=1c3-cr3am-15-yummy

2. La información de configuración visitada en Python

>>> import os
>>> os.environ["SOME_SECRET_KEY"]
"1c3-cr3am-15-yummy"

3. Estos parámetros de acceso del archivo de configuración

# Top of settings/production.py
import os
SOME_SECRET_KEY = os.environ["SOME_SECRET_KEY"]

excepción SECRET_KEY no se proporciona en el procesamiento

Si lo hace el valor no superior SECRET_KEY código de acceso lanzará KeyError , el proyecto no puede comenzar. Sin embargo, la excepción no proporciona un mensaje efectivo no es propicio para la depuración.

En la configuración / base.py siguiente código para el procesamiento:

# settings/base.py
import os

# Normally you should not import ANYTHING from Django directly
# into your settings, but ImproperlyConfigured is an exception.
from django.core.exceptions import ImproperlyConfigured

def get_env_variable(var_name):
    """Get the environment variable or return exception."""
    try:
        return os.environ[var_name]
    except KeyError:
        error_msg = "Set the {} environment variable".format(var_name)
        raise ImproperlyConfigured(error_msg)

A continuación, en el archivo de configuración, utilice:

SOME_SECRET_KEY = get_env_variable("SOME_SECRET_KEY")

Después de eso, si no hay SOME_SECRET_KEY esta variable de entorno, aparece el siguiente mensaje de error:

django.core.exceptions.ImproperlyConfigured: Set the SOME_SECRET_KEY
environment variable.

manage.pyEl valor por defecto DJANGO_SETTINGS_MODULE punto settings.py , se recomienda su uso en el archivo-settings múltiples django-admin, utilizando el archivo de configuración única manage.py, estos dos comandos básicos son equivalentes:

$ django-admin <command> [options]
$ manage.py <command> [options]

Cuando no establecer variables de entorno

Apache, etc. utilizando sus variables de entorno, variables tales como el método de ajuste medio ambiente para el sistema anterior no es válida, entonces la información sensible puede ser almacenado en un archivo no ejecutable, y no se realiza el control de versión de archivo:

1. Generar un archivo para guardar información sensible, el formato JSON puede ser, Config, YAML o XML.

2. Añadir un cargador para gestionar la información

3. El nombre del archivo se incrementa .gitignore y .hgignore

formato JSON

1. Generar archivo secrets.json:

{
    "FILENAME": "secrets.json",
    "SECRET_KEY": "I've got a secret!",
    "DATABASES_HOST": "127.0.0.1",
    "PORT": "5432"
}

2. Añadir la configuración del cargador / base.py, el acceso a esta información:

# settings/base.py

import json

# Normally you should not import ANYTHING from Django directly
# into your settings, but ImproperlyConfigured is an exception.
from django.core.exceptions import ImproperlyConfigured

# JSON-based secrets module
with open("secrets.json") as f:
    secrets = json.loads(f.read())

def get_secret(setting, secrets=secrets):
    """Get the secret variable or return explicit exception."""
    try:
        return secrets[setting]
    except KeyError:
        error_msg = "Set the {0} environment variable".format(setting)
        raise ImproperlyConfigured(error_msg)

SECRET_KEY = get_secret("SECRET_KEY")

El uso de múltiples documentos de los requisitos

Los ajustes correspondientes a cada archivo debe tener un documento de requisitos, y que corresponden a diferentes configuraciones, instalar sólo las dependencias correspondientes.

requisitos de documentos, por ejemplo:

requirements/
    base.txt
    local.txt
    staging.txt
    production.txt

base.txt almacena la dependencia mundial, tales como:

Django==1.8.0
psycopg2==2.6
djangorestframework==3.1.1

Y para el entorno de desarrollo local Local.txt , puede base.txt añadir otro dependiente en función de:

-r base.txt # includes the base.txt requirements file

coverage==3.7.1
django-debug-toolbar==1.3.0

Para el servidor de integración continua ci.txt puede ser:

-r base.txt # includes the base.txt requirements file

coverage==3.7.1
django-jenkins==0.16.4

El production.txt voluntad básica y base.txt misma podrían ser:

-r base.txt # includes the base.txt requirements file

instalar

Para el desarrollo local:

$ pip install -r requirements/local.txt

Para un entorno de producción:

$ pip install -r requirements/production.txt

Todas las dependencias de los archivos requisitos son asignados a una versión específica, esto asegurará que el proyecto es más estable.

Procesamiento de archivos ruta del archivo de configuración

No difícil que el código de la ruta del archivo

1. Utilice Unipath para la ruta de procesamiento de archivos

# At the top of settings/base.py
from unipath import Path

BASE_DIR = Path(__file__).ancestor(3)
MEDIA_ROOT = BASE_DIR.child("media")
STATIC_ROOT = BASE_DIR.child("static")
STATICFILES_DIRS = (
    BASE_DIR.child("assets"),
)
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        DIRS = (BASE_DIR.child("templates"),)
    },
]

2. Uso os.path para la ruta de procesamiento de archivos

# At the top of settings/base.py
from os.path import join, abspath, dirname

here = lambda *dirs: join(abspath(dirname(__file__)), *dirs)
BASE_DIR = here("..", "..")
root = lambda *dirs: join(abspath(BASE_DIR), *dirs)

# Configuring MEDIA_ROOT
MEDIA_ROOT = root("media")

# Configuring STATIC_ROOT
STATIC_ROOT = root("collected_static")

# Additional locations of static files
STATICFILES_DIRS = (
    root("assets"),
)

# Configuring TEMPLATE_DIRS
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        DIRS = (root("templates"),)
    },
]

Para averiguar la diferencia entre el archivo de configuración y la configuración por defecto de Django, el uso de Django diffsettingscomando.

Referencias: dos bolas de la Django: Las mejores prácticas para el Django 1.8