Django: Wie verwalte ich Entwicklungs- und Produktionseinstellungen?

Ich habe eine Basis-App entwickelt. In der Bereitstellungsphase wurde klar, dass ich sowohl lokale Einstellungen als auch Produktionseinstellungen benötige.

Es wäre toll, Folgendes zu wissen:

• Wie man am besten mit Entwicklungs- und Produktionseinstellungen umgeht.
• So behalten Sie Apps wie die Django-Debug-Symbolleiste nur in einer Entwicklungsumgebung.
• Alle anderen Tipps und Best Practices für Entwicklungs- und Bereitstellungseinstellungen.

Die DJANGO_SETTINGS_MODULEUmgebungsvariable steuert, welche Einstellungsdatei Django geladen wird.

Sie erstellen daher separate Konfigurationsdateien für Ihre jeweiligen Umgebungen (beachten Sie, dass diese natürlich beide import *aus einer separaten Datei mit gemeinsam genutzten Einstellungen stammen können) und DJANGO_SETTINGS_MODULEsteuern, welche verwendet werden soll.

Hier ist wie:

Wie in der Django-Dokumentation angegeben:

Der Wert von DJANGO_SETTINGS_MODULE sollte in der Python-Pfadsyntax angegeben werden, z. B. mysite.settings. Beachten Sie, dass sich das Einstellungsmodul im Python-Importsuchpfad befinden sollte.

Nehmen wir also an, Sie haben myapp/production_settings.pyund myapp/test_settings.pyin Ihrem Quell-Repository erstellt.

In diesem Fall würden Sie jeweils DJANGO_SETTINGS_MODULE=myapp.production_settingsdie erstere und DJANGO_SETTINGS_MODULE=myapp.test_settingsdie letztere verwenden.

Von hier an läuft das Problem darauf hinaus, die DJANGO_SETTINGS_MODULEUmgebungsvariable festzulegen.

Einstellung DJANGO_SETTINGS_MODULEmit einem Skript oder einer Shell

Sie können dann ein Bootstrap-Skript oder einen Prozessmanager verwenden, um die richtigen Einstellungen zu laden (indem Sie die Umgebung festlegen), oder sie einfach von Ihrer Shell aus ausführen, bevor Sie Django starten : export DJANGO_SETTINGS_MODULE=myapp.production_settings.

Beachten Sie, dass Sie diesen Export jederzeit über eine Shell ausführen können - er muss nicht in Ihrer .bashrcoder einer anderen Umgebung leben.

Einstellung DJANGO_SETTINGS_MODULEmit einem Prozessmanager

Wenn Sie nicht gerne ein Bootstrap-Skript schreiben, das die Umgebung festlegt (und es gibt sehr gute Gründe, sich so zu fühlen!), Würde ich die Verwendung eines Prozessmanagers empfehlen:

• Mit Supervisor können Sie Umgebungsvariablen mithilfe des environmentKonfigurationsschlüssels eines Programms an verwaltete Prozesse übergeben .
• Mit Honcho (ein reines Python-Äquivalent zu Ruby's Foreman) können Sie Umgebungsvariablen in einer "environment" ( .env) - Datei definieren .

Schließlich , dass Anmerkung Sie können die Vorteile des nehmen PYTHONPATHVariable die Einstellungen in einem ganz anderen Ort zu speichern (zB auf einem Produktionsserver, speichern sie in /etc/). Dies ermöglicht das Trennen der Konfiguration von Anwendungsdateien. Sie können das wollen oder nicht, es hängt davon ab, wie Ihre App strukturiert ist.

Verwenden Sie standardmäßig die Produktionseinstellungen, erstellen Sie jedoch eine Datei, die settings_dev.pyim selben Ordner wie Ihre settings.pyDatei aufgerufen wird . Fügen Sie dort Überschreibungen hinzu, z DEBUG=True.

Fügen Sie auf dem Computer, der für die Entwicklung verwendet wird, Folgendes zu Ihrer ~/.bashrcDatei hinzu:

export DJANGO_DEVELOPMENT=true

Fügen Sie am Ende Ihrer settings.pyDatei Folgendes hinzu.

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

(Beachten Sie, dass das Importieren *in Python generell vermieden werden sollte.)

Standardmäßig überschreiben die Produktionsserver nichts. Getan!

Im Vergleich zu den anderen Antworten ist diese Antwort einfacher, da keine Aktualisierung PYTHONPATHoder Einstellung erforderlich ist , mit DJANGO_SETTINGS_MODULEder Sie jeweils nur an einem Django-Projekt arbeiten können.

Normalerweise habe ich eine Einstellungsdatei pro Umgebung und eine freigegebene Einstellungsdatei:

/myproject/
  settings.production.py
  settings.development.py
  shared_settings.py

Jede meiner Umgebungsdateien enthält:

try:
    from shared_settings import *
except ImportError:
    pass

Auf diese Weise kann ich freigegebene Einstellungen bei Bedarf überschreiben (indem ich die Änderungen unter dieser Zeilengruppe hinzufüge).

Ich wähle dann die zu verwendenden Einstellungsdateien aus, indem ich sie mit settings.py verknüpfe:

ln -s settings.development.py settings.py

So mache ich es in 6 einfachen Schritten:

1. Erstellen Sie einen Ordner in Ihrem Projektverzeichnis und benennen Sie ihn settings.

   Projektstruktur:

   myproject/
          myapp1/
          myapp2/              
          myproject/
                 settings/

2. Erstellen Sie vier Python - Dateien innerhalb des settingsVerzeichnisses nämlich __init__.py, base.py, dev.pyundprod.py

   Einstellungsdateien:

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

3. Öffnen Sie es __init__.pyund füllen Sie es mit folgendem Inhalt:

   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. Öffnen Sie es base.pyund füllen Sie es mit allen allgemeinen Einstellungen (die sowohl in der Produktion als auch in der Entwicklung verwendet werden), zum Beispiel:

   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. Öffnen dev.pyund fügen Sie das entwicklungsspezifische Material hinzu, zum Beispiel:

   dev.py:

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

6. Öffnen prod.pyund fügen Sie das produktionsspezifische Material hinzu, zum Beispiel:

   prod.py:

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

Erstellen Sie mehrere settings*.pyDateien und extrapolieren Sie die Variablen, die sich pro Umgebung ändern müssen. Dann am Ende Ihrer Master- settings.pyDatei:

try:
  from settings_dev import *
except ImportError:
  pass

Sie behalten die separaten settings_*Dateien für jede Stufe.

Fügen Sie oben in Ihrer settings_dev.pyDatei Folgendes hinzu:

import sys
globals().update(vars(sys.modules['settings']))

So importieren Sie Variablen, die Sie ändern müssen.

Dieser Wiki-Eintrag enthält weitere Ideen zum Aufteilen Ihrer Einstellungen.

Ich benutze die fantastischen Django-Konfigurationen und alle Einstellungen sind in meinem gespeichert settings.py:

from configurations import Configuration

class Base(Configuration):
    # all the base settings here...
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    ...

class Develop(Base):
    # development settings here...
    DEBUG = True 
    ...

class Production(Base):
    # production settings here...
    DEBUG = False

Um das Django-Projekt zu konfigurieren, habe ich nur die Dokumente befolgt .

Hier ist der Ansatz, den wir verwenden:

• ein settingsModul zum Aufteilen von Einstellungen in mehrere Dateien zur besseren Lesbarkeit;
• eine .env.jsonDatei zum Speichern von Anmeldeinformationen und Parametern, die aus unserem Git-Repository ausgeschlossen werden sollen oder die umgebungsspezifisch sind;
• eine env.pyDatei zum Lesen der .env.jsonDatei

Betrachtet man die folgende Struktur:

...
.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
...

Mit .env.jsonwie:

{
    "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",
}

Und 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()

Wir können die folgenden Einstellungen haben:

<!-- 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',
    }
}

Die Vorteile dieser Lösung sind:

• benutzerspezifische Anmeldeinformationen und Konfigurationen für die lokale Entwicklung, ohne das Git-Repository zu ändern;
• Umgebungsspezifische Konfiguration können Sie beispielsweise drei verschiedene Umgebungen mit drei verschiedenen Umgebungen .env.jsonwie Entwicklung, Staffelung und Produktion haben.
• Anmeldeinformationen befinden sich nicht im Repository

Ich hoffe, das hilft. Lassen Sie mich einfach wissen, wenn Sie bei dieser Lösung Vorbehalte feststellen.

Ich benutze die folgende Dateistruktur:

project/
   ...
   settings/
   settings/common.py
   settings/local.py
   settings/prod.py
   settings/__init__.py -> local.py

So __init__.pyist ein Link (in Unix oder Mklink in Windows) zu local.pyoder kann zu sein, prod.pydamit die Konfiguration noch im project.settingsModul sauber und organisiert ist, und wenn Sie eine bestimmte Konfiguration verwenden möchten, können Sie die Umgebungsvariable verwenden, DJANGO_SETTINGS_MODULEum, project.settings.prodwenn Sie benötigen um einen Befehl für die Produktionsumgebung auszuführen.

In den Dateien prod.pyund local.py:

from .shared import *

DATABASE = {
    ...
}

und die shared.pyDatei bleibt ohne bestimmte Konfigurationen global.

Aufbauend auf der Antwort von cs01:

Wenn Sie Probleme mit der Umgebungsvariablen haben, setzen Sie ihren Wert auf eine Zeichenfolge (z DJANGO_DEVELOPMENT="true". B. habe ich ).

Ich habe auch den Datei-Workflow von cs01 wie folgt geändert:

#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

Auf diese Weise muss Django nicht die gesamte Einstellungsdatei durchlesen, bevor die entsprechende Einstellungsdatei ausgeführt wird. Diese Lösung ist nützlich, wenn Ihre Produktionsdatei Dinge benötigt, die sich nur auf Ihrem Produktionsserver befinden.

Hinweis: in Python 3, importierte Dateien benötigen , um ein .angehängt (z from .settings_dev import *)

Wenn Sie 1 Einstellungsdatei behalten möchten und Ihr Entwicklungsbetriebssystem sich von Ihrem Produktionsbetriebssystem unterscheidet, können Sie dies am Ende Ihrer settings.py einfügen:

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

Lesen Sie mehr: Wie überprüfe ich das Betriebssystem in Python?

Dies scheint beantwortet worden zu sein, aber eine Methode, die ich in Kombination mit der Versionskontrolle verwende, ist die folgende:

Richten Sie eine env.py-Datei im selben Verzeichnis wie die Einstellungen in meiner lokalen Entwicklungsumgebung ein, die ich auch zu .gitignore hinzufüge:

env.py:

#!usr/bin/python

DJANGO_ENV = True
ALLOWED_HOSTS = ['127.0.0.1', 'dev.mywebsite.com']

.gitignore:

mywebsite/env.py

settings.py:

if os.path.exists(os.getcwd() + '/env.py'):
    #env.py is excluded using the .gitignore file - when moving to production we can automatically set debug mode to off:
    from env import *
else:
    DJANGO_ENV = False

DEBUG = DJANGO_ENV

Ich finde nur, dass dies funktioniert und viel eleganter ist - mit env.py ist es einfach, unsere lokalen Umgebungsvariablen zu sehen, und wir können all dies ohne mehrere settings.py-Dateien oder ähnliches verarbeiten. Mit dieser Methode können alle Arten von lokalen Umgebungsvariablen verwendet werden, die nicht auf unserem Produktionsserver festgelegt werden sollen. Durch die Verwendung des .gitignore über die Versionskontrolle halten wir auch alles nahtlos integriert.

Verwendung settings.pyfür die Produktion. Im selben Verzeichnis settings_dev.pyfür Überschreibungen erstellen .

# settings_dev.py

from .settings import * 

DEBUG = False

Führen Sie auf einer Entwicklungsmaschine Ihre Django-App aus mit:

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

Auf einer Prod-Maschine laufen, als ob Sie gerade hatten settings.pyund sonst nichts.

VORTEILE

1. settings.py (für die Produktion verwendet) ist völlig unabhängig von der Tatsache, dass es sogar andere Umgebungen gibt.
2. Um den Unterschied zwischen Prod und Dev zu erkennen, schauen Sie einfach in einen einzelnen Ort - settings_dev.py. Keine Notwendigkeit, Konfigurationen zu sammeln, die über und verstreut settings_prod.pysind .settings_dev.pysettings_shared.py
3. Wenn jemand Ihrer Prod-Konfiguration nach der Behebung eines Produktionsproblems eine Einstellung hinzufügt, können Sie sicher sein, dass diese auch in Ihrer Dev-Konfiguration angezeigt wird (sofern nicht ausdrücklich überschrieben). Dadurch wird die Divergenz zwischen verschiedenen Konfigurationsdateien minimiert.

Für das Problem beim Einstellen von Dateien habe ich mich für das Kopieren entschieden

Project
   |---__init__.py   [ write code to copy setting file from subdir to current dir]
   |---settings.py  (do not commit this file to git)
   |---setting1_dir
   |         |--  settings.py
   |---setting2_dir
   |         |--  settings.py

Wenn Sie django ausführen, wird __init__py ausgeführt. Zu diesem Zeitpunkt settings.py in setting1_dirwird ersetzt settings.py in Project.

Wie wähle ich eine andere Umgebung?

• __init__.pydirekt ändern .
• Erstellen Sie eine Bash-Datei zum Ändern __init__.py.
• Ändern Sie env unter Linux und lassen __init__.pySie diese Variable dann lesen.

Warum auf diese Weise verwenden?

Da ich nicht so viele Dateien im selben Verzeichnis mag, verwirren zu viele Dateien andere Partner und sind für IDE nicht sehr gut. (IDE kann nicht finden, welche Datei wir verwenden.)

Wenn Sie nicht alle diese Details sehen möchten, können Sie das Projekt in zwei Teile teilen.

1. Machen Sie Ihr kleines Tool wie Spring Initializr, nur um Ihr Projekt einzurichten.
2. Ihren Projektcode

Ich verwende eine andere app.yaml-Datei, um die Konfiguration zwischen Umgebungen in der Google Cloud App Engine zu ändern.

Sie können dies verwenden, um eine Proxy-Verbindung in Ihrem Terminalbefehl herzustellen:

./cloud_sql_proxy -instances=<INSTANCE_CONNECTION_NAME>=tcp:1433

https://cloud.google.com/sql/docs/sqlserver/connect-admin-proxy#macos-64-bit

Datei: app.yaml

# [START django_app]
service: development
runtime: python37

env_variables:
  DJANGO_DB_HOST: '/cloudsql/myproject:myregion:myinstance'
  DJANGO_DEBUG: True

handlers:
# This configures Google App Engine to serve the files in the app's static
# directory.
- url: /static
  static_dir: static/

# This handler routes all requests not caught above to your main app. It is
# required when static routes are defined, but can be omitted (along with
# the entire handlers section) when there are no static files defined.
- url: /.*
  script: auto
# [END django_app]

Dies ist meine Lösung mit unterschiedlichen Umgebungen für Entwickler, Test und Produkt

import socket

[...]

DEV_PC = 'PC059'
host_name = socket.gethostname()

if host_name == DEV_PC:
   #do something
   pass
elif [...]