Jak zarządzać application.conf w kilku środowiskach przy użyciu play 2.0?

Question

z luzem 1.2, mogę prefiks klawiszy konfiguracji z identyfikatorem ramowej lub w trybie aplikacji w następujący sposób:

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

Ale nie wydaje się do pracy z 2.0.

Czy istnieje sposób, aby to zadziałało?

Answer 1

Musisz określić inny plik konfiguracyjny z odpowiednimi właściwościami

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

Istnieje również mechanizm integracji, który pomaga określić wartości domyślne w application.conf i nadpisuje tylko to, co jest potrzebne do produkcji

Answer 2

Mam również to pytanie od dłuższego czasu, a poniżej jest najlepsze podejście, jakiego nauczyłem się do tej pory, otrzymałem podpowiedź, gdy zadaję podobne pytanie w grupie google 2 Play.

W application.config użyć następującej składni, aby zastąpić wartość parametru konfiguracyjnego, gdy system jest obecny:

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

Znak zapytania oznacza, że ​​nie zastępują ze zmienną env jeśli nie jest zestaw. Jeśli użyjesz $ {MONGOLAB_URI}, spodziewasz się, że zmienna zostanie ustawiona i, jak przypuszczam, otrzymasz wyjątek, jeśli nie jest ustawiony.

Dla kompletności, tutaj jest przykładem, jak chcesz odczytać wartość:

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

Z takim podejściem jest jedna uwaga: upewnij się zachować konfigurację systemu param w SCM pewnego rodzaju.

Answer 3

Po prostu mamy wiele plików application.conf, domyślnie jest używany podczas programowania i mamy prod-applicaton.conf, który po prostu kopiujemy na miejsce podczas wdrażania.

Answer 4

Gra 2 nie zmusza do użycia żadnej konkretnej metody do zarządzania otoczeniem. Ale zapewnia potężne i elastyczne narzędzia do samodzielnego wdrożenia zgodnie z potrzebami twojego projektu.

Na przykład wspólny wzorzec zachowuje wspólne ustawienia środowiska w jednym pliku i posiada nadpisania specyficzne dla środowiska w innych plikach. Aby to zrobić, będziesz potrzebował custom Global object (możesz umieścić go bezpośrednio w ./app/Global.scala). Poniższy kod jest ważny jako of Play 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) 
    } 
} 

Teraz można umieścić application.dev.conf, application.test.conf i application.prod.conf do swojej ./conf ze środowiskiem określone przesłonięcia (przy zachowaniu typowych ustawień w application.conf).

W tym przykładzie polegamy na własnej grze mode, która zwykle ma sens, ale możesz być tak ziarnisty, jak chcesz i używać zmiennych środowiskowych lub cokolwiek chcesz.

Zobacz także: Typesafe Config

Answer 5

Używam tego rozwiązania:

w application.conf Mam zdefiniowane konfiguracje domyślne, w myUsername.conf podaję domyślnej konfiguracji i nadpisane konfigurację konkretnego użytkownika:

include "application.conf" 
logger.application=DEBUG 

wówczas Global.java I załadowaniu konfiguracji określonego użytkownika (jeśli istnieje)

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; 
    } 

} 

Answer 6

Jeśli chcesz zachować niezależność od ograniczonych trybów Scala Run, możesz użyć właściwości JVM. Put zmodyfikowany @coffesnake przykład ./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) 
    } 
} 

Następny bieg zabaw play

i uruchomić aplikację ze środowiskiem param run -Denvironment=prod-server1

nie przyłączają zarówno polecenia, to nie robi 't work then

Konfiguracja globalna zostanie zastąpiona właściwościami właściwymi dla środowiska z pliku:

./conf/application.prod-server1.conf 

EDIT:

Z perspektywy czasu widziałem tego obejścia jest niepotrzebna. Lepiej jest używać play wbudowany mechanizm config ładunkowej -Dconfig.file=/etc/play-application/foo-production.conf