web-dev-qa-db-fra.com

Comment gérer application.conf dans plusieurs environnements avec play 2.0?

Avec Play 1.2, je peux préfixer les clés de configuration avec l'ID du framework ou le mode d'application comme suit:

# Production configuration
%prod.http.port=80
%prod.application.log=INFO
%prod.application.mode=prod

Mais cela ne semble pas fonctionner avec la version 2.0.

Y a-t-il un moyen de le faire fonctionner?

playframework-2.0
22
tototoshi

Play 2 ne vous oblige pas à utiliser une méthode particulière pour gérer vos environnements. Mais il vous fournit des outils puissants et flexibles pour l'implémenter vous-même en fonction des besoins de votre projet.

Par exemple, un modèle courant consiste à conserver les paramètres d'environnement communs dans un fichier et à avoir des remplacements spécifiques à l'environnement dans d'autres fichiers. Pour ce faire, vous aurez besoin d'un objet global personnalisé (vous pouvez le placer directement dans le ./app/Global.scala). Le code suivant est valide à partir du Jeu 2.1.1 (Scala 2.10):

import Java.io.File
import play.api._
import com.typesafe.config.ConfigFactory

object Global extends GlobalSettings {
  override def onLoadConfig(config: Configuration, path: File, classloader: ClassLoader, mode: Mode.Mode): Configuration = {
    val modeSpecificConfig = config ++ Configuration(ConfigFactory.load(s"application.${mode.toString.toLowerCase}.conf"))
    super.onLoadConfig(modeSpecificConfig, path, classloader, mode)
  }
}

Vous pouvez maintenant insérer application.dev.conf, application.test.conf et application.prod.conf dans votre ./conf avec des remplacements spécifiques à l'environnement (tout en conservant les paramètres communs dans application.conf).

Dans cet exemple, nous nous basons sur la variable mode de la pièce, qui est généralement logique, mais vous pouvez être aussi granulaire que vous le souhaitez et utiliser des variables d'environnement ou tout ce que vous souhaitez.

Voir aussi: Typesafe Config

43
coffeesnake

Cette question existe aussi depuis longtemps et voici la meilleure approche que j’ai apprise jusqu’à présent, j’ai un indice pour poser une question similaire sur le groupe Google Play 2.

Dans votre application.config, utilisez la syntaxe suivante pour remplacer une valeur de configuration lorsqu'un paramètre système est présent:

# Local machine fallback URI
mongodb.uri="mongodb://192.168.56.101:27017/application"
# Env variable override
mongodb.uri=${?MONGOLAB_URI}

Le point d'interrogation signifie que vous ne remplacez pas la variable env si elle n'est pas définie. Si vous n'utilisez que $ {MONGOLAB_URI}, vous vous attendez à ce que la variable soit définie et, je suppose, vous obtenez une exception d'une certaine sorte si elle n'est pas définie.

Pour être complet, voici un exemple de lecture de la valeur:

lazy val mongoUri = current.configuration.getString("mongodb.uri").getOrElse("mongodb:///")

Avec cette approche, une mise en garde s'impose: veillez à conserver la configuration de vos paramètres système dans un SCM quelconque.

13
Magnus

Vous devez définir un fichier de configuration différent avec les propriétés appropriées

http://www.playframework.org/documentation/2.0/Configuration

Il existe également un mécanisme d'inclusion qui vous aide à définir les valeurs par défaut dans application.conf et remplace uniquement ce qui est nécessaire pour la production.

6
Seb Cesbron

Si vous souhaitez être indépendant des modes d'exécution scala restreints, vous pouvez utiliser les propriétés de la machine virtuelle Java. Placez l'exemple @coffesnake modifié à ./app/Global.scala:

import Java.io.File

import play.api._
import com.typesafe.config.ConfigFactory

object Global extends GlobalSettings {
  override def onLoadConfig(config: Configuration, path: File, classloader: ClassLoader, mode: Mode.Mode): Configuration = {
    val environment = System.getProperty("environment")
    val environmentSpecificConfig = config ++ Configuration(ConfigFactory.load(s"application.${environment}.conf"))
    super.onLoadConfig(environmentSpecificConfig, path, classloader, mode)
  }
}

Jeu suivant play

et démarrez l'application avec l'environnement param run -Denvironment=prod-server1

Ne pas joindre les deux commandes, cela ne fonctionne pas alors 

La configuration globale sera remplacée par les propriétés spécifiques à l'environnement à partir du fichier:

./conf/application.prod-server1.conf

MODIFIER:

Du point de vue du temps, j'ai vu que cette solution de contournement est inutile. Il est préférable d’utiliser le mécanisme de chargement de la configuration intégrée de Play -Dconfig.file=/etc/play-application/foo-production.conf

4
mgosk

J'utilise cette solution:

dans application.conf j'ai défini les configurations par défaut, dans myUsername.conf j'ai inclus la configuration par défaut et remplacé la configuration spécifique à l'utilisateur:

include "application.conf"
logger.application=DEBUG

puis dans Global.Java j'ai chargé la configuration spécifique à l'utilisateur (s'il existe):

public Configuration onLoadConfig(Configuration config, File path,
        ClassLoader classloader) {

    String username = System.getProperty("user.name");
    File confFile = new File(new File(path, "conf"), username + ".conf");

    if (confFile.exists()) {
        Logger.info("configuration file {} found", confFile.getName());
        return new Configuration(ConfigFactory.load(confFile.getName()));
    } else {
        Logger.info(
                "configuration file {} not found, using default application.conf",
                confFile.getAbsolutePath());
        return null;
    }

}
1
Antonio Salvati

Nous avons juste plusieurs fichiers application.conf, la valeur par défaut est utilisée pendant le développement et nous avons un prod-applicaton.conf que nous copions simplement à la place lorsque nous déployons.

0
nylund