W większości przypadków przechowuję konfigurację aplikacji programistycznych w katalogu głównym projektu, w następujący sposób:
app
|-- config.json
Ale to nie wydaje się być najlepszym podejściem, ponieważ ta konfiguracja ostatecznie jest przechowywana w systemie kontroli wersji - prawdopodobnie skutkując wyciekiem nazw użytkowników, haseł i innych wrażliwych rzeczy.
12 Przewodnik po aplikacji Factor zaleca całkowite usunięcie plików konfiguracyjnych i użycie zmiennych środowiskowych do konfiguracji konfiguracji:
... przechowuje konfigurację w zmiennych środowiskowych. Zmian środowiska Env można łatwo zmieniać między wdrożeniami bez zmiany kodu; w przeciwieństwie do plików konfiguracyjnych, istnieje niewielkie prawdopodobieństwo przypadkowego sprawdzenia ich w repozytorium kodu; i w przeciwieństwie do niestandardowych plików konfiguracyjnych lub innych mechanizmów konfiguracyjnych, takich jak Java System Properties, są one standardem zależnym od języka i systemu operacyjnego.
To brzmi dla mnie naprawdę miło, ale gdzie przechowuje się wspomniane zmienne środowiskowe, bez sprawdzania ich w kontroli źródła? A jakich narzędzi mogę użyć do przekazania tych zmiennych do aplikacji? Może istnieć kilkadziesiąt opcji konfiguracji, a ręczne wpisywanie ich przy każdym uruchomieniu aplikacji nie jest przyjemne - więc muszą być gdzieś przechowywane w jakimś pliku. Wspomniany plik w ten sposób przejdzie w kontrolę źródła i wrócimy do miejsca, w którym zaczęliśmy.
Czy istnieje jakiś powszechnie akceptowany sposób obsługi opcji konfiguracji, który nie wiąże się z ryzykiem przechowywania konfiguracji lokalnej w kontroli źródła?
.gitignore
gdzie mogę zdefiniować pliki lub foldery, których nie należy sprawdzać w kontroli wersji. Jak mówisz, nie widzę, gdzie Vars var powinien naprawdę pomóc, eith masz skrypt, aby je ustawić i powinny być przechowywane razem z projektem lub masz je gdzieś w systemie (katalog domowy lub nawet przy uruchamianiu maszyn skrypty), które wydają się same w sobie powodować wiele problemów, zwłaszcza jeśli konieczna jest duża konfiguracja. W każdym razie podzieliłbym pliki konfiguracyjne, aby poufne informacje trafiły do różnych plików.Odpowiedzi:
Być może nie ma na to dobrej odpowiedzi. Wydaje się, że musisz przechowywać te dane w bezpiecznym miejscu, ponieważ pewnego dnia będą one potrzebne do odzyskiwania danych po awarii. Dotyczy to również plików właściwości i skryptów, które ustawiają zmienne środowiskowe.
Obecnie szukamy rozwiązań tego problemu i skłaniamy się ku repozytorium kodu z ograniczonym dostępem. To repozytorium zawierałoby tylko dane dotyczące współbieżności. Czy inni mają podzielone doświadczenia?
źródło
Przy badaniu problemów i możliwych rozwiązań pomaga mi metoda spopularyzowana przez Jeffa Atwooda : Gdyby Bóg stworzył sposób przechowywania poufnych informacji konfiguracyjnych, jak by to zrobił?
Cóż, wiedziałby, kto potrzebuje informacji o konfiguracji i przekazuje je tylko tym osobom, a informacje te nigdy nie będą dostępne dla nikogo innego.
Pierwszą część należy już załatwić: Twój system kontroli źródła powinien uwierzytelniać użytkowników. Podejście to zyskuje również ważność zgodnie z 10 w 10 przykazaniach Troy Hunta dotyczących kontroli źródła: „zależności muszą być pod kontrolą źródła”.
Ale jak zabezpieczyć go przed wyciekiem? Cóż, nie trzeba go tam przechowywać w postaci zwykłego tekstu! Użyj szyfrowania. W .NET można wykonać kroki, aby zaszyfrować dane ciągu połączenia w plikach konfiguracyjnych . Musisz znaleźć równoważne metody, aby to zrobić z wybraną przez siebie technologią.
źródło
Wiele osób krytykuje przechowywanie konfiguracji w zwykłych plikach wraz z kodem źródłowym, ale z mojego doświadczenia wynika, że jest to całkiem dobre rozwiązanie:
Tak więc w wielu przypadkach konfiguracja tekstowa przechowywana w kontroli źródła wraz z kodem jest dobrym początkiem.
Jeśli jesteś w systemach rozproszonych lub chcesz mieć możliwość zamiany konfiguracji bez konieczności ponownego wdrażania aplikacji, możesz lepiej znaleźć rozwiązanie oparte na serwerze konfiguracji. Spring Cloud obsługuje takie mechanizmy , a konfiguracjami służącymi do obsługi zaplecza może być repozytorium git lub Eureka . Możesz także rzucić własny za pomocą np . Zookeeper . Każde z tych podejść ułatwi zarządzanie spójnymi konfiguracjami na wielu serwerach w celu aktualizacji konfiguracji bez konieczności przebudowywania i ponownego wdrażania oprogramowania. Kosztem tego jest oczywiście nauka serwera konfiguracji i sposobu korzystania z niego z aplikacji, a także innego systemu do wdrażania i obsługi.
źródło
Walczymy z tym samym problemem, w którym pracuję. Obecnie wszystkie nasze konfiguracje są oparte na plikach i kontrolowane przez źródło za pomocą poszczególnych aplikacji, które ich używają. Prowadzi to do powielania, a programiści mają dostęp do haseł produkcyjnych / qa zamiast do samego programowania.
To powiedziawszy, myślę, że opracowaliśmy dobre rozwiązanie na przyszłość. Przenosimy nasze pliki konfiguracyjne do osobnego repozytorium git (oznaczonego jako repozytorium konfiguracji). Następnie konfigurujemy serwer spring-cloud-config (java), który po prostu obsługuje pliki z repozytorium konfiguracji na podstawie przekazanych mu profili. Jest to idealne rozwiązanie dla aplikacji Java, które mogą korzystać z klienta i pobierać je podczas uruchamiania. W przypadku naszych aplikacji PHP / innych niż Java usuniemy plik bezpośrednio. (Nieidealny). W przyszłości możemy napisać coś, co pozwoli aplikacji PHP na samodzielne pobieranie konfiguracji i buforowanie ich gdzieś, ale nie jest to wysoki priorytet dla pierwszego uruchomienia. Myślę o tym rozwiązaniu jako o usłudze konfiguracji jako usługi, która nie narusza jednoznacznie rekomendacji 12-czynnikowych aplikacji.
Wierzę, że zookeeper może być używany do tego samego (widziałem konfigurację z kubernetes + zookeeper), więc nie jestem pewien, dlaczego ta odpowiedź uzyskała -1 powyżej.
Spinki do mankietów:
https://spring.io/guides/gs/centralized-configuration/
https://cloud.spring.io/spring-cloud-config/
źródło
Zamiast przechowywać całą konfigurację w jednym pliku, przechowuj ją w kilku plikach.
README*
.01-logging.json
.02-database.json
itd.Na najbliższym Linux-ie spójrz na
/etc/sudoers.d
lub/etc/nginx/conf.d
. Pokazuje ten sam wzór.Zarządzanie sekretami to inna bestia. Możesz nimi zarządzać jako krok ręczny, gdy jesteś mały. Możesz używać rzeczy takich jak Zookeeper. Możesz nawet sprawdzić sekrety w VCS w postaci zaszyfrowanej i odszyfrować je jako krok wdrożenia. Istnieje wiele innych opcji.
(Również opinia: JSON nie jest dobrym formatem pliku konfiguracyjnego, ponieważ nie pozwala na komentarze; komentarze są kluczowe. Formaty TOML, YAML, a nawet INI są lepsze w praktyce.)
źródło
Myślę, że twoje opcje są nieco określone przez system operacyjny, w którym wdrażasz
Sugerowałbym, tak, podaj wartości w kontroli źródła. ALE tylko wersje „dev”. Chcesz, aby Twój kod źródłowy się skompilował I działał! nie zawierają dodatkowych tajnych kroków
Proces kompilacji i wdrażania powinien następnie zamienić te wartości na środowisko podczas wdrażania. (ośmiornica ma tego rodzaju model)
źródło
Zookeeper Apache oferuje wspaniałe opcje przechowywania konfiguracji aplikacji dla systemów rozproszonych. Zmiany dokonane w zookeeper mogą być przechwytywane i przetwarzane przez posiadanie kuratora lub nasłuchującego zookeeper na końcu aplikacji.
źródło