Me he movido de mi SECRET_KEY valor de mi archivo de configuración, y se establece cuando puedo cargar mi virtualenv. Puedo confirmar que el valor presente de python manage.py shell.

Cuando ejecuto el Django de la Consola, SECRET_KEY falta, como debe ser. Así, en las preferencias, me voy a la Consola>Django Consola y carga SECRET_KEY y el valor adecuado. Vuelvo al Django Consola, y SECRET_KEY está ahí.

Como era de esperar, yo aún no puedo ejecutar un manage.py Tarea debido a que todavía tiene que encontrar la SECRET_KEY. Así que voy a Ejecutar>Editar las Configuraciones para agregar SECRET_KEY en Django servidor y Django Pruebas, y en el proyecto de servidor. Reinicie Pycharm, confirmar claves.

Cuando ejecuto un manage.py Tarea, como runserver, todavía me KeyError: 'SECRET_KEY'.

Donde puedo poner esta clave?

  • Por qué has hecho esto en primer lugar?
  • Las claves secretas en textos simples archivos, especialmente como parte de un repo en algún lugar, es una mala idea.
  • EnvFile es una extensión que permite leer las variables de entorno desde un archivo. Que permite establecer las variables en un archivo sin tener que gestionar su código…
InformationsquelleAutor Cole | 2014-02-03

14 Comentarios

  1. 41

    Porque Pycharm no es el lanzamiento de un terminal, su entorno no será cargado. En resumen, cualquier programa GUI no heredarán las variables del SHELL. Ver este por razones (suponiendo un Mac).

    Sin embargo, existen varias soluciones a este problema. Como @user3228589 publicado, puede configurar esto como una variable dentro de PyCharm. Esto tiene varios pros y contras. Yo, personalmente, no me gusta este método porque no es un single source. Para solucionar este problema, yo uso una pequeña función en la parte superior de mi settings.py archivo que busca la variable dentro de un local .env archivo. Puse todo de mi «privado» cosas allí. Yo también puede hacer referencia a esto en mi virtualenv.

    Aquí es lo que parece.

    — settings.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')

    A continuación, el env archivo se parece a esto:

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

    Y, finalmente, su virtualenv/bin/postactivate puede fuente de este archivo. Usted podría ir más allá y exportar las variables como se describe aquí si quieres, pero desde el archivo de configuración llama directamente a el .env, no hay realmente una necesidad.

  2. 27

    Para establecer las variables de entorno en PyCharm hacer lo siguiente:

    • Abra el menú ‘Archivo’
    • Haga Clic En ‘Configuración’
    • Haga clic en el signo ‘+’ al lado de ‘Consola’
    • Haga Clic En La Consola De Python
    • Haga clic en el botón ‘…’ junto a las variables de entorno
    • Haga clic en el » + » para agregar variables de entorno
    • Por favor, me puede decir, ¿cómo puedo leer esta variable de entorno de código? ‘os.getenv’ devuelve sólo un completo sistema de variables.
    • Quieres hacer algo como os.environ.get("KEY")
    • En mi PyCharm 2019.1.3 la opción está en el Archivo | Configuración | Construcción, Ejecución, Implementación | Consola | Consola de Python | variables de Entorno
  3. 14

    Mismo aquí, por alguna razón PyCharm no puede ver exportado env variables.
    Por ahora me puse SECRET_KEY en PyCharm Run/Debug Configurations -> «variables de Entorno»

  4. 13

    Otra opción que trabajó para mí:

    1. Abrir un terminal
    2. Activar el virtualenv del proyecto, que hará que los ganchos a ejecutar y establecer las variables de entorno
    3. Lanzamiento PyCharm de esta línea de comandos.

    Pycharm tendrá acceso a las variables de entorno. Probablemente a causa de algo que tiene que ver con la PyCharm proceso de ser un hijo de la concha.

    • Este es el enfoque correcto de la OMI. He ampliado con mi propia respuesta.
  5. 12

    Puede establecer el manage.py la tarea de las variables de entorno a través de:

    Preferencias| Languages&Marcos| Django| Manage.py tareas

    Configuración de la env variables a través de la run/debug/configuración de la consola no afectará a la construida en el pycharm del manage.py tarea.

  6. 7

    En Pycharm manage.py tareas que se ejecutan en un proceso aislado que no tiene acceso a las variables de entorno (no es lo mismo Ejecutar/Depurar).

    La solución más sencilla es hacer que el código de python conscientes de las variables de entorno mediante la lectura de su .env archivo directamente.

    Echa un vistazo a: https://github.com/joke2k/django-environ

    import environ
    
    env = environ.Env.read_env() # reading .env file
    
    SECRET_KEY = env('SECRET_KEY')

    De esa manera se tiene una sola fuente de configuraciones, y menos ajustes en el IDE.

    Espero que ayude,

  7. 2

    Parafraseando @antero-ortiz respuesta, en lugar de utilizar el valor predeterminado de Mac, haga doble clic o de búsqueda de spotlight para el lanzamiento de PyCharm, puedes ejecutarlo directamente desde el terminal. Esto se hereda todas sus variables de entorno de su sesión de terminal para el PyCharm aplicación.

    He aquí cómo puedo resolver este problema.

    1. De su programa de terminal, ejecute el siguiente fragmento.
    2. Validar que las cosas trabajado siguiendo las instrucciones para Editar su Run/Debug Configurations y,
      1. Clic en el ... junto a Environment variables
      2. A continuación, haga clic Show en la parte inferior derecha de la pantalla que aparece. Esto mostrará todos de las variables de entorno heredado por el proceso de Depuración.
      3. Encontrar su SECRET_KEY en esta lista. Si no lo hay, publicar un comentario en esta respuesta y podemos tratar de averiguar!
    3. Es probable que necesite para el lanzamiento de PyCharm de esta manera cada vez que lo inicie.

    Fragmento:

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

    Nota de lado

    Incluyendo las variables de entorno en un archivo que después se source‘d es un patrón común para Django desarrollo, y la discusión de que la mejor práctica es mejor dejar de respuestas.

  8. 1

    basa en @rh0dium increíble respuesta que he hecho de esta clase:

    aquí está mi settings.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

    y dentro de mi runserver.py tengo este código de llamada:

    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']
  9. 0

    Estoy tratando de esta configuración en la actualidad. Tengo una env.local archivo en mi raíz del proyecto. Mi manage.py se parece a esto:

    #!/usr/bin/env python
    import os
    import sys
    if __name__ == "__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)

    Entonces me acaba de pasar --load-env en el PyCharm de diálogo ejecutar y todas las variables de entorno se cargará en el momento de la ejecución.

  10. 0

    Por favor, tenga en cuenta que la respuesta mencionado por «nu everest» funciona, pero usted no podrá ver la ficha de la Consola disponible a menos que crear un proyecto en pycharm. Como los archivos se pueden ejecutar sin necesidad de crear un proyecto en pycharm algunas personas puede ser confuso. Aunque también tenga en cuenta que se pierde la configuración para ejecutar-configuraciones que no pertenecen a un proyecto cuando pycharm es cerrado.

  11. 0

    Aquí está mi manage.py archivo en caso de ayuda. Lee todas las variables .env archivo ubicado en el directorio raíz de mi proyecto.

    Pycharm: establezca la variable de entorno para ejecutar manage.py Tarea

  12. 0

    Considero que un buen método es usar django-environ que le permiten leer las variables de entorno desde una .env archivo.

    Uso

    Instalar en primer lugar, django-environ

    pip install django-environ

    Segundo, crear un .env archivo en el mismo directorio de tu settings.py archivo.

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

    Tercero, agregar las variables de entorno que desea utilizar para .env:

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

    Cuarto, en el archivo de configuración, agregar lo siguiente justo después de que su importación de declaraciones:

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

    Quinto, cargar las variables de entorno:

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

    Que es. Si desea más información acerca de por favor revise el docs.

    Nota: esta configuración también le ayudará a establecer variables de entorno cuando se ejecuta un servidor de PyCharm.

Dejar respuesta

Please enter your comment!
Please enter your name here