Où stocker les clés secrètes DJANGO

Question

J'ai cherché cette question partout et je n'ai pas trouvé la réponse. J'espère que je ne poste pas un doublon.

Il est conseillé partout de conserver vos clés secrètes dans un fichier distinct de votre fichier settings.py général. De plus, vous ne devez jamais livrer votre fichier "secret.py" qui contient des clés telles que SECRET_KEY, AWS_SECRET_KEY, etc.

Ma question est la suivante : dans votre serveur de production, vous devez référencer vos clés secrètes, ce qui signifie que votre fichier de paramètres "secret.py" doit se trouver quelque part sur le serveur, n'est-ce pas ? Si oui, comment protégez-vous vos clés secrètes en production ?

Answer 1

Je voulais ajouter une nouvelle réponse car, en tant que débutant, la réponse acceptée précédemment n'avait pas beaucoup de sens pour moi (elle ne représentait qu'une partie du puzzle).

Voici donc comment je stocke mes clés à la fois LOCALEMENT et en PRODUCTION (Heroku, et autres).

Nota: Vous ne devez vraiment le faire que si vous prévoyez de mettre votre projet en ligne. Si c'est juste un projet local, ce n'est pas nécessaire.

J'ai aussi fait un tutoriel vidéo pour les personnes qui préfèrent ce format.

1) Installez python-dotenv pour créer un environnement de projet local pour stocker votre clé secrète.

pip install python-dotenv

2) Créer un .env dans votre répertoire de base (où manage.py est).

YourDjangoProject
project
   __init__.py
   asgi.py
   settings.py
   urls.py
   wsgi.py
.env
manage.py
db.sqlite3

Si vous avez un projet Heroku, il devrait ressembler à quelque chose comme ceci :

YourDjangoProject
.git
project
   __init__.py
   asgi.py
   settings.py
   urls.py
   wsgi.py
venv
.env
.gitignore
manage.py
Procfile
requirements.txt
runtime.txt

3) Ajouter .env à votre .gitignore fichier.

echo .env > .gitignore  # Or just open your .gitignore and type in .env

C'est ainsi que votre clé secrète est plus sûre, car vous ne téléchargez pas votre fichier .env sur git ou heroku (ou ailleurs).

4) Ajoutez votre SECRET_KEY de votre fichier settings.py dans le fichier .env comme suit (sans guillemets)

**Inside of your .env file**
SECRET_KEY=qolwvjicds5p53gvod1pyrz*%2uykjw&a^&c4moab!w=&16ou7 # <- Example key, SECRET_KEY=yoursecretkey

5) Dans votre fichier settings.py, ajoutez les paramètres suivants :

import os
import dotenv # <- New

# Add .env variables anywhere before SECRET_KEY
dotenv_file = os.path.join(BASE_DIR, ".env")
if os.path.isfile(dotenv_file):
    dotenv.load_dotenv(dotenv_file)

# UPDATE secret key
SECRET_KEY = os.environ['SECRET_KEY'] # Instead of your actual secret key

ou, grâce à La réponse de @Ashkay Chandran :

from dotenv import load_dotenv, find_dotenv

load_dotenv(find_dotenv())

SECRET_KEY = os.environ['SECRET_KEY']

Et maintenant votre clé secrète est stockée localement avec succès.

Mise à jour : J'ai découvert que vous pouvez aussi utiliser le config du paquet python-decouple qui semble être un peu plus facile :

from decouple import config

SECRET_KEY = config('SECRET_KEY')

Maintenant, vous n'avez plus besoin de import os ou utiliser dotenv car il s'occupe de ces parties pour vous ET utilise toujours le fichier .env. J'ai commencé à l'utiliser dans tous mes projets.

6) Ajoutez la variable d'environnement SECRET_KEY sur votre hôte (tel que Heroku).

---

Je travaille principalement avec des sites Heroku, donc si vous souhaitez utiliser Heroku pour un projet Django, cette partie est pour vous.

Cela suppose que vous avez déjà configuré un projet Heroku et que vous avez téléchargé Heroku CLI sur votre ordinateur.

Vous avez deux options :

1. Depuis la ligne de commande / le terminal, vous pouvez entrer la commande suivante dans le répertoire de votre projet :

   heroku config:set SECRET_KEY=yoursecretkey # Again, no quotes.

2. Vous pouvez aller dans votre tableau de bord Heroku, cliquer sur votre application, aller dans les paramètres de votre application, et voir la section "Config Vars" et cliquer sur "Reveal Vars" ou "Add Vars" et ajouter votre SECRET_KEY là.

Ensuite, lorsque vous poussez votre projet vers Heroku via git, il devrait fonctionner correctement sans aucun problème.

et c'est tout !

Cette réponse s'adresse aux débutants et aux intermédiaires afin de dissiper toute confusion (parce que c'était vraiment déroutant pour moi).

J'espère que cela vous aidera !

Bon codage.

Answer 2

Voir le Documents sur le déploiement de Django pour une discussion à ce sujet. .

Il y a plusieurs options pour la production. La façon dont je le fais est de définir mes variables de données sensibles comme variables d'environnement sur les environnements de production. Ensuite, je récupère les variables dans le settings.py via os.environ comme ça :

import os
SECRET_KEY = os.environ['SECRET_KEY']

Une autre option possible est de copier dans le secret.py via votre script de déploiement.

Je suis sûr qu'il existe également d'autres options spécifiques pour différents serveurs web.

Answer 3

Vous devez stocker vos paramètres de manière modulaire. J'entends par là que vous devez répartir vos paramètres sur plusieurs fichiers.

Par exemple, vous pouvez avoir base_settings.py pour stocker tous vos paramètres de base ; dev_settings.py pour les paramètres de votre serveur de développement ; et enfin prod_base_settings.py pour tous les paramètres de production. Tous les fichiers de paramètres autres que ceux de base importeront tous les paramètres de base et ne modifieront que ce qui est nécessaire :

# base_settings.py
...

# dev_settings.py
from base_settings import *
DEBUG = TRUE
...

# prod_base_settings.py
from base_settings import *
DEBUG = FALSE
...

Cette approche vous permet d'avoir des paramètres différents pour différentes configurations. Vous pouvez également valider tous ces fichiers, sauf que sur le serveur de production, vous pouvez créer le fichier de paramètres de production réel. prod_settings.py où vous spécifierez tous les paramètres sensibles. Ce fichier ne doit être engagé nulle part et son contenu doit rester sécurisé :

# prod_settings.py
from prod_base_settings import *
SECRET_KEY = 'foo'

En ce qui concerne les noms de fichiers, vous pouvez utiliser les noms de fichiers qui vous semblent appropriés. Personnellement, je crée un paquet Python pour les paramètres et je conserve les différents paramètres dans ce paquet :

project/
  project/
    settings/
      __init__.py
      base.py
      dev.py
      ...
  app1/
    models.py
    ...
  app2/
    models.py
    ...

Answer 4

Stocker des secrets dans l'environnement les place toujours dans l'environnement ; ce qui peut être exploité si un utilisateur non autorisé obtient l'accès à l'environnement. C'est un effort trivial de lister les variables d'environnement, et de nommer un SECRET est d'autant plus utile et évident pour un mauvais acteur un utilisateur indésirable.

Pourtant, les secrets sont nécessaires en production, alors comment y accéder tout en minimisant la surface d'attaque ? Cryptez chaque secret dans un fichier avec un outil tel que git-secret puis autoriser les utilisateurs autorisés à lire le fichier, comme indiqué dans la section La documentation de django . Puis "dire" à un utilisateur non-Root le secret afin qu'il puisse être lu pendant l'initialisation.

(Alternativement, on pourrait aussi utiliser le Vault d'Hashicorp, et accéder aux secrets stockés dans le Vault via la fonction CVC python module.)

Une fois que cet utilisateur non-Root est informé, quelque chose comme ceci est facile :

# Remember that './secret_key.txt' is encrypted until it's needed, and only read by a non-root user
with open('./secret_key.txt') as f:
    SECRET_KEY = f.read().strip() 

Ce n'est pas parfait, et, oui, un attaquant pourrait énumérer les variables et y accéder - mais il est très difficile de le faire pendant l'exécution, et Django fait un bon travail de protection de ses clés contre un tel vecteur de menace.

Il s'agit d'une approche beaucoup plus sûre que le stockage de secrets dans l'environnement.

Answer 5

Je sais que cela fait longtemps, mais je viens d'ouvrir une petite application Django que j'utilise pour générer une nouvelle clé secrète si elle n'existe pas encore. Elle s'appelle django-generate-secret-key .

pip install django-generate-secret-key

Ensuite, lors du provisionnement/déploiement d'un nouveau serveur exécutant mon projet Django, j'exécute la commande suivante (depuis Ansible) :

python manage.py generate_secret_key

C'est tout simplement :

• vérifie si une clé secrète doit être générée
• le génère dans un secretkey.txt fichier (peut être personnalisé)

Il vous suffit alors d'avoir dans votre fichier de paramètres :

with open('/path/to/the/secretkey.txt') as f:
    SECRET_KEY = f.read().strip()

Vous pouvez désormais bénéficier d'un entièrement automatisé processus de provisionnement sans avoir à stocker une clé secrète statique dans votre dépôt.