webentwicklung-frage-antwort-db.com.de

Pycharm: Umgebungsvariable für run manage.py festlegen

Ich habe meinen SECRET_KEY-Wert aus meiner Einstellungsdatei verschoben und er wird festgelegt, wenn ich meine virtualenv lade. Ich kann bestätigen, dass der Wert von python manage.py Shell vorliegt.

Wenn ich die Django-Konsole starte, fehlt SECRET_KEY, wie es sollte. Also gehe ich in den Einstellungen zu Console> Django Console und lade SECRET_KEY und den entsprechenden Wert. Ich gehe zurück in die Django-Konsole und SECRET_KEY ist da.

Wie erwartet, kann ich noch keine manage.py-Task ausführen, da der SECRET_KEY noch nicht gefunden wurde. Also gehe ich zu Run> Edit Configurations und füge SECRET_KEY zu Django-Server und Django-Tests und zum Projekt-Server hinzu. Starten Sie Pycharm neu, bestätigen Sie die Tasten.

Wenn ich eine manage.py-Task wie runserver starte, erhalte ich trotzdem KeyError: 'SECRET_KEY'.

Wo stecke ich diesen Schlüssel?

33
Cole

Da Pycharm nicht von einem Terminal aus gestartet wird, wird Ihre Umgebung nicht geladen. Kurz gesagt, jedes GUI-Programm erbt die Shell-Variablen nicht. Siehe this für Gründe (unter der Annahme eines Mac).

Es gibt jedoch einige grundlegende Lösungen für dieses Problem. Da @ user3228589 gepostet wurde, können Sie dies in PyCharm als Variable einrichten. Dies hat mehrere Vor- und Nachteile. Ich persönlich mag diesen Ansatz nicht, weil er kein single source ist. Um dies zu beheben, verwende ich eine kleine Funktion oben in meiner Datei settings.py, die die Variable in einer lokalen .env-Datei nachschlägt. Ich habe all meine "privaten" Sachen da rein gelegt. Ich kann das auch in meiner Virtualenv verweisen.

So sieht es aus.

- einstellungen.py

def get_env_variable(var_name, default=False):
    """
    Get the environment variable or return exception
    :param var_name: Environment Variable to lookup
    """
    try:
        return os.environ[var_name]
    except KeyError:
        import StringIO
        import ConfigParser
        env_file = os.environ.get('PROJECT_ENV_FILE', SITE_ROOT + "/.env")
        try:
            config = StringIO.StringIO()
            config.write("[DATA]\n")
            config.write(open(env_file).read())
            config.seek(0, os.SEEK_SET)
            cp = ConfigParser.ConfigParser()
            cp.readfp(config)
            value = dict(cp.items('DATA'))[var_name.lower()]
            if value.startswith('"') and value.endswith('"'):
                value = value[1:-1]
            Elif value.startswith("'") and value.endswith("'"):
                value = value[1:-1]
            os.environ.setdefault(var_name, value)
            return value
        except (KeyError, IOError):
            if default is not False:
                return default
            from Django.core.exceptions import ImproperlyConfigured
            error_msg = "Either set the env variable '{var}' or place it in your " \
                        "{env_file} file as '{var} = VALUE'"
            raise ImproperlyConfigured(error_msg.format(var=var_name, env_file=env_file))

# Make this unique, and don't share it with anybody.
SECRET_KEY = get_env_variable('SECRET_KEY')

Dann sieht die env-Datei so aus:

#!/bin/sh
#
# This should normally be placed in the ${SITE_ROOT}/.env
#
# DEPLOYMENT DO NOT MODIFY THESE..
SECRET_KEY='XXXSECRETKEY'

Und schließlich kann Ihre virtuelle/bin/postactivate-Datei diese Datei als Quelle verwenden. Sie könnten weitergehen und die Variablen exportieren, wie beschrieben mit here , wenn Sie möchten, aber da die Einstellungsdatei die .env direkt aufruft, ist dies nicht unbedingt erforderlich.

41
rh0dium

Um Ihre Umgebungsvariablen in PyCharm festzulegen, gehen Sie folgendermaßen vor:

  • Öffnen Sie das Menü 'Datei'
  • Klicken Sie auf "Einstellungen".
  • Klicken Sie auf das Pluszeichen neben "Konsole".
  • Klicken Sie auf Python Console
  • Klicken Sie auf die Schaltfläche "..." neben Umgebungsvariablen
  • Klicken Sie auf das "+", um Umgebungsvariablen hinzuzufügen
21
nu everest

Das gleiche gilt für PyCharm aus verschiedenen Gründen nicht für exportierte Env-Vars . Für jetzt setze ich SECRET_KEY in PyCharm Run/Debug-Konfigurationen -> "Umgebungsvariablen"

13
ammonium

Eine andere Option, die für mich gearbeitet hat:

  1. Öffnen Sie ein Terminal
  2. Aktivieren Sie die Virtualenv des Projekts, wodurch die Hooks ausgeführt werden, und setzen Sie die Umgebungsvariablen
  3. Starten Sie PyCharm über diese Befehlszeile. 

Pycharm hat dann Zugriff auf die Umgebungsvariablen. Wahrscheinlich weil etwas damit zu tun hat, dass der PyCharm-Prozess ein Kind der Shell ist. 

11
Antero Ortiz

Sie können die Umgebungsvariablen für die task.py-Task festlegen:

Voreinstellungen | Sprachen & Frameworks | Django | Verwalten von.py-Aufgaben

Das Festlegen der env-Werte über die Konfiguration von run/debug/console hat keinen Einfluss auf die in manage.py integrierte Task von pycharm.

11
OmriToptix

In Pycharm manage.py werden Tasks in einem isolierten Prozess ausgeführt, der keinen Zugriff auf Ihre Umgebungsvariablen hat (nicht dasselbe wie Run/Debug).

Die einfachste Lösung besteht darin, den Python-Code auf Umgebungsvariablen aufmerksam zu machen, indem er direkt aus der .env-Datei gelesen wird.

Werfen Sie einen Blick auf: https://github.com/joke2k/Django-environ

import environ

env = environ.Env.read_env() # reading .env file

SECRET_KEY = env('SECRET_KEY')

Auf diese Weise haben Sie eine einzige Konfigurationsquelle und weniger Einstellungen in der IDE.

Hoffentlich hilft das,

7
cvng

Um die Antwort von @ antero-ortiz's zu umschreiben, können Sie PyCharm anstelle der standardmäßigen Mac-Doppelklick- oder Spotlight-Suche zum Starten von PyCharm direkt vom Terminal aus starten. Dadurch werden alle Umgebungsvariablen von Ihrer Terminalsitzung an die PyCharm-App übernommen.

So löse ich dieses Problem.

  1. Führen Sie in Ihrem Terminalprogramm den folgenden Snippet aus. 
  2. Stellen Sie sicher, dass alles funktioniert hat, indem Sie die Anweisungen befolgen, um Bearbeiten Sie die Run/Debug-Konfigurationen und,
    1. Klicken Sie auf ... neben Environment variables.
    2. Klicken Sie dann unten rechts in dem sich öffnenden Bildschirm auf Show. Dies zeigt all der Umgebungsvariablen, die vom Debug-Prozess geerbt wurden.
    3. Finden Sie Ihren SECRET_KEY in dieser Liste. Wenn dies nicht der Fall ist, schreiben Sie einen Kommentar zu dieser Antwort und wir können versuchen, es herauszufinden!
  3. Sie müssen PyCharm wahrscheinlich jedes Mal auf diese Weise starten, wenn Sie es starten. 

Ausschnitt:

# This file would presumably export SECRET_KEY
source /path/to/env/file
# This is just a shortcut to finding out where you installed PyCharm
# If you used brew cask, it's probably in /opt/homebrew-cask/Caskroom/pycharm
open $(locate PyCharm.app | egrep 'PyCharm.app$')

Randnotiz

Das Einfügen von Umgebungsvariablen in eine Datei, die dann sourced ist, ist ein übliches Muster für die Entwicklung von Django, und die Diskussion dieser bewährten Methode wird am besten aus den Antworten herausgelassen.

2
Ben

basierend auf @ rh0dium erstaunliche Antwort habe ich diese Klasse gemacht:

hier meine einstellungen.py:

import os


class EnvironmentSettings():
    """Access to environment variables via system os or .env file for development

    """
    def __init__(self, root_folder_path):
        self._root_folder_path = root_folder_path

    def __getitem__(self, key):
        return self._get_env_variable(key)

    def __setitem__(self, key, value):
        raise InvalidOperationException('Environment Settings are read-only')

    def __delitem__(self, key):
        raise InvalidOperationException('Environment Settings are read-only')

    def _get_env_variable(self, var_name, default=False):
        """
        Get the environment variable or return exception
        :param var_name: Environment Variable to lookup
        """
        try:
            return os.environ[var_name]
        except KeyError:
            from io import StringIO
            from configparser import ConfigParser

            env_file = os.environ.get('PROJECT_ENV_FILE', self._root_folder_path + "/.env")
            try:
                config = StringIO()
                config.write("[DATA]\n")
                config.write(open(env_file).read())
                config.seek(0, os.SEEK_SET)
                cp = ConfigParser()
                cp.readfp(config)
                value = dict(cp.items('DATA'))[var_name.lower()]
                if value.startswith('"') and value.endswith('"'):
                    value = value[1:-1]
                Elif value.startswith("'") and value.endswith("'"):
                    value = value[1:-1]
                os.environ.setdefault(var_name, value)
                return value
            except (KeyError, IOError):
                if default is not False:
                    return default
                error_msg = "Either set the env variable '{var}' or place it in your " \
                            "{env_file} file as '{var} = VALUE'"
                raise ConfigurationError(error_msg.format(var=var_name, env_file=env_file))


class ConfigurationError(Exception):
    pass


class InvalidOperationException(Exception):
    pass

und in meinem runserver.py habe ich diesen Aufrufcode:

from settings import EnvironmentSettings

root_folder_path = os.path.dirname(os.path.abspath(__file__))
env_settings = EnvironmentSettings(root_folder_path)
config_name = env_settings['APP_SETTINGS']
1
danfromisrael

In PyCharm 2018 können Sie in den Einstellungen die Option Umgebungsvariablen Django manage.py verwenden

  • Datei
  • Die Einstellungen
  • Sprache und Frameworks
  • Django
  • Umgebungsvariablen

Sie können in Bild sehen

1

Ich versuche gerade dieses Setup. Ich habe eine env.local-Datei in meinem Projektstamm. Mein manage.py sieht so aus:

#!/usr/bin/env python
import os
import sys


if __== "__main__":
    os.environ.setdefault("Django_SETTINGS_MODULE", "config.settings.local")

    # Load environment variables from env.local, if option --load-env specified.
    # Good for injecting environment into PyCharm run configurations for example and no need to
    # manually load the env values for manage.py commands
    if "--load-env" in sys.argv:
        with open("env.local") as envfile:
            for line in envfile:
                if line.strip():
                    setting = line.strip().split("=", maxsplit=1)
                    os.environ.setdefault(setting[0], setting[1])
        sys.argv.remove("--load-env")

    from Django.core.management import execute_from_command_line

    execute_from_command_line(sys.argv)

Dann übergebe ich einfach --load-env im PyCharm-Laufdialog und alle Umgebungsvariablen werden für die Zeit des Laufs geladen.

0
jaywink

Bitte beachten Sie, dass die von "nu everest" erwähnte Antwort funktioniert. Sie sehen jedoch die Registerkarte "Konsole" nicht, wenn Sie kein Projekt in pycharm erstellen. Da einzelne Dateien ausgeführt werden können, ohne ein Projekt in pycharm zu erstellen, können einige Leute verwirrt sein. Sie müssen jedoch auch beachten, dass die Einstellungen an Laufkonfigurationen verloren gehen, die nicht zu einem Projekt gehören, wenn pycharm geschlossen wird.

0
Part

Die Antwort von @ (Nu Everest) hat bei mir nicht funktioniert. Was auch immer Sie in der Frage beschrieben haben, hat für mich funktioniert. Sie können alle Umgebungsvariablen im Dialogfeld "Run/Debug Configurations" festlegen. Dies ist w.r.t PyCharm 2016.1 und auch gemäß https://www.jetbrains.com/help/pycharm/2016.1/run-debug-configuration-python.html?origin=old_help

0
Nitin

Hier ist meine manage.py-Datei, falls es hilft. Es liest alle Variablen aus der .env-Datei, die sich im Stammverzeichnis des Projekts befindet.

 enter image description here

0
saran3h

Ich denke, dass ein guter Ansatz darin besteht, Django-environ zu verwenden, mit dem Sie Umgebungsvariablen aus einer .env - Datei lesen können.

Verwendungszweck

Installieren Sie zuerst Django-environ

pip install Django-environ

Zweitens erstellen Sie eine .env - Datei im selben Verzeichnis wie Ihre settings.py - Datei.

$ cd project-settings-directory/
$ touch .env

Drittens fügen Sie die Umgebungsvariablen, die Sie verwenden möchten, zu .env Hinzu:

# .env file
DEBUG=on
SECRET_KEY=your-secret-key
DATABASE_URL=psql://urser:[email protected]:8458/database
SQLITE_URL=sqlite:///my-local-sqlite.db

Viertens fügen Sie in Ihrer Einstellungsdatei direkt nach Ihren Importanweisungen Folgendes hinzu:

# other import statements

import environ


# the followin line expects .env file to exist. Otherwise, an IOError exception will be raised.
env = environ.Env.read_env()

Fünftens laden Sie die Umgebungsvariablen:

DEBUG = env('DEBUG')
SECRET_KEY = env('SECRET_KEY')

Das ist es. Wenn Sie weitere Informationen wünschen, lesen Sie bitte die Dokumente .

Hinweis: Mit dieser Konfiguration können Sie auch Umgebungsvariablen festlegen, wenn Sie einen Server in PyCharm ausführen.

0
lmiguelvargasf