Flacon: Comment gérer les différents environnements des bases de données?

Je suis en train de travailler sur une application qui ressemble à

facebook/
         __init__.py
         feed/
             __init__.py
             business.py
             views.py
             models/
                    persistence.py
                    user.py
         chat/
             __init__.py
             models.py
             business.py
             views.py
         config/
                dev.py
                test.py
                prod.py

Je veux avoir trois environnements Dev, Test et Production.

J'ai les conditions suivantes:

un.) Lorsque je démarre le serveur python runserver.py, je voudrais mentionner l'environnement auquel je veux me connecter - Dev, Test ou Production.

b.) Dev & Production devrait avoir le schéma construit et ont juste besoin de se connecter à la machine

c.) Je tiens aussi pour mon test pour vous connecter à sqlite db, et de créer le schéma, d'exécuter des tests

Comment puis-je réaliser cela dans une configuration de sorte que je n'ai pas à coder en dur tout ce qui est lié à la base de données.

Y a de bons modèles disponibles en flacon?

Actuellement mon runerver.py a coder en dur pour l'environnement que je n'aime pas,

app = Flask(__name__)
app.config['SECRET_KEY'] = dev.SECRET_KEY

Je suis à la recherche de meilleures idées que j'ai

flacon fournit quelques exemples pour vous aider à démarrer dans leur documentation flask.pocoo.org/docs/config/#development-production

OriginalL'auteur daydreamer | 2013-03-24

18

Solution que j'utilise:
```
#__init__.py
app = Flask(__name__)
app.config.from_object('settings')
app.config.from_envvar('MYCOOLAPP_CONFIG',silent=True)
```
Sur le même niveau à partir duquel l'application de charges:
```
#settings.py
SERVER_NAME="dev.app.com"
DEBUG=True
SECRET_KEY='xxxxxxxxxx'


#settings_production.py
SERVER_NAME="app.com"
DEBUG=False
```
.
Si la Variable d'Environnement MYCOOLAPP_CONFIG n'existe pas -> seulement settings.py charge, qui se réfère aux paramètres par défaut (serveur de développement comme pour moi)

C'est la raison pour laquelle "silence=True", deuxième fichier de configuration n'est requis, tout en settings.py par défaut pour le développement et avec les valeurs par défaut pour la commune de la config des touches de

Si d'autres settings_file sera chargé en outre à la première des valeurs à l'intérieur, il remplace les valeurs dans l'original. (dans mon exemple, le DÉBOGAGE et le SERVER_NAME sera surdéfini, tandis que SECRET_KEY reste identique pour tous les serveurs)

La seule chose que vous devez découvrir par vous-même dépend de la façon dont vous lancez votre application

Avant de lancer ENVVAR MYCOOLAPP_CONFIG doit être définie

Par exemple, je lance avec le superviseur de démon et sur le serveur de production, j'ai mis tout cela dans le superviseur de fichier de configuration:
```
environment=MYCOOLAPP_CONFIG="/home/tigra/mycoolapp/settings_production.py"
```
Avec cette façon, vous pouvez gérer facilement tous vos fichiers de configuration, en outre, de cette façon, vous pouvez exclure ces fichiers à partir de git ou toute autre version de l'utilitaire de contrôle de la

par défaut de Linux façon est-ce un dans la console avant de lancer:

export MYCOOLAPP_CONFIG="/home/tigra/mycoolapp/settings_production.py"

merci! cette es d'une grande aide!
flask.pocoo.org/docs/config/#configuring-from-files c'est une bonne source pour plus d'informations sur ce

OriginalL'auteur
6

Je pense que c'est ce que vous cherchez:

http://flask.pocoo.org/docs/config/#configuring-from-files

Mais aussi la caisse de la fiole vide projet, c'est un passe-partout pour flacon applications avec l'environnement des configurations spécifiques.

https://github.com/italomaia/flask-empty

Vous spécifiez vos configurations dans config.py comme:
```
class Dev(Config):
    DEBUG = True
    MAIL_DEBUG = True
    SQLALCHEMY_ECHO = True
    SQLALCHEMY_DATABASE_URI = "sqlite:////tmp/%s_dev.sqlite" % project_name
```
Ce hérite de la configuration de la classe qui peut contenir vos paramètres par défaut. À partir de là, main.py a des méthodes pour la création d'un flacon instance de la config.py fichier, manage.py détermine la config est chargé.

Voici un extrait de main.py ainsi, vous obtenez l'idée:
```
def app_factory(config, app_name=None, blueprints=None):
    app_name = app_name or __name__
    app = Flask(app_name)

    config = config_str_to_obj(config)
    configure_app(app, config)
    configure_blueprints(app, blueprints or config.BLUEPRINTS)
    configure_error_handlers(app)
    configure_database(app)
    configure_views(app)

    return app
```
Et puis manage.py poignées de configuration de l'environnement en se fondant sur des arguments de ligne de commande passé, cependant vous pouvez obtenir une idée de comment cela fonctionne (à noter qu'il nécessite en flacon de script):
```
from flask.ext import script

import commands

if __name__ == "__main__":
    from main import app_factory
    import config

    manager = script.Manager(app_factory)
    manager.add_option("-c", "--config", dest="config", required=False, default=config.Dev)
    manager.add_command("test", commands.Test())
    manager.run() 
```
À partir d'ici, vous pouvez choisir l'requis Config classe à partir d'une variable d'environnement, ou une autre méthode de votre choix.

OriginalL'auteur
2

Vous pouvez créer une "config" du module qui contient la configuration pour chaque environnement. Par la suite, en cours d'exécution de l'environnement peut être spécifiée en paramètre une variable du shell.

Si vous initialisez votre ballon d'application dans les principaux init fichier, la configuration peut également être définies. C'est de cette façon j'ai mis ma configuration:
```
def setup_config(app):
    """Set the appropriate config based on the environment settings"""
    settings_map = {'development': DevelopmentSettings,
                    'staging': StagingSettings,
                    'testing': TestingSettings,
                    'production': ProductionSettings}
    env = environ['ENV'].lower()
    settings = settings_map[env]
    app.config.from_object(settings)
```
La configuration de la variable d'environnement avant de lancer le serveur de développement ou même les tests peuvent être une corvée, donc je automatiser ces actions avec un makefile.

Aussi jeter un oeil à en flacon de script http://flask-script.readthedocs.org/en/latest/.

Thumbs up pour avoir l'environnement dans un env var, pas du nom du module.

OriginalL'auteur
2

Flacon a quelque chose qui s'appelle Dossiers d'Instance, ce qui permet d'avoir différentes configurations possibles et de les charger en conséquence.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.