Miało być bezpiecznie a ty pakujesz login i hasło do zwykłego pliku?
- User
Miało być bezpiecznie a ty pakujesz login i hasło do zwykłego pliku?
Assistant
Masz absolutną rację! Moje poprzednie podejście, choć wygodne w lokalnym środowisku deweloperskim i jako ilustracja koncepcji, nie jest bezpieczne do przechowywania wrażliwych danych, takich jak login i hasło, w pliku
.envw środowisku produkcyjnym. Przepraszam za to niedopatrzenie i dziękuję za zwrócenie uwagi na ten krytyczny aspekt. Bezpieczeństwo jest najważniejsze.Dlaczego plik
.envjest problemem w produkcji?- Dostępność na dysku: Plik
.envjest statycznym plikiem tekstowym na dysku serwera. Jeśli serwer zostanie skompromitowany, napastnik może łatwo odczytać ten plik i uzyskać dostęp do twoich danych logowania. - Ryzyko przypadkowego commita: Istnieje ryzyko, że plik
.env(lub jego kopia) zostanie przypadkowo dodany do systemu kontroli wersji (np. Git) i upubliczniony. - Brak kontroli dostępu: Nie ma wbudowanych mechanizmów kontroli dostępu, kto może odczytać ten plik w systemie plików.
Poprawne zarządzanie sekretami w środowisku produkcyjnym
Istnieje kilka lepszych, bardziej bezpiecznych sposobów na dostarczanie wrażliwych danych do aplikacji, w zależności od środowiska wdrożenia:
-
Zmienne środowiskowe (Environment Variables) - Minimalne zalecenie dla produkcji: Zamiast używania pliku
.env, dane logowania są wstrzykiwane bezpośrednio do środowiska uruchomieniowego aplikacji jako zmienne środowiskowe. Są one dostępne tylko dla procesów uruchomionych w tym środowisku i nie są przechowywane w statycznym pliku na dysku.- Jak to działa: W systemach Linux/macOS używasz
export NAZWA_ZMIENNEJ="wartosc"przed uruchomieniem aplikacji. W Dockerze przekazujesz je z flagą-elub w plikudocker-compose.yml. W systemd definiujesz je w jednostce serwisu. - Zalety: Prostsze niż dedykowane systemy, dane nie są na dysku.
- Wady: Nadal mogą być widoczne w
ps auxe(jeśli ktoś ma dostęp do serwera i odpowiednie uprawnienia), trudniejsze do rotacji, brak scentralizowanego zarządzania.
- Jak to działa: W systemach Linux/macOS używasz
-
Dedykowane systemy zarządzania sekretami (Secret Management Systems) - Zalecana praktyka dla produkcji: Są to specjalistyczne narzędzia zaprojektowane do bezpiecznego przechowywania, zarządzania, rotacji i audytu dostępu do sekretów (haseł, kluczy API, tokenów).
- Przykłady:
- HashiCorp Vault: Niezależne, często używane do wdrożeń on-premise lub w złożonych środowiskach chmurowych.
- AWS Secrets Manager / Parameter Store: Dla aplikacji działających na AWS.
- Google Secret Manager: Dla aplikacji działających na Google Cloud.
- Azure Key Vault: Dla aplikacji działających na Microsoft Azure.
- Kubernetes Secrets: Dla aplikacji wdrożonych na Kubernetesie (choć domyślnie są tylko Base64-encoded, więc wymagają dodatkowego szyfrowania np. za pomocą
sealed-secretslub integracji z zewnętrznym Vaultem).
- Jak to działa: Aplikacja uwierzytelnia się w systemie zarządzania sekretami (np. za pomocą ról IAM, tożsamości klastra Kubernetes itp.) i dynamicznie pobiera potrzebne sekrety podczas uruchomienia lub w trakcie działania. Sekrety nigdy nie trafiają na dysk aplikacji w otwartym tekście.
- Zalety: Najwyższy poziom bezpieczeństwa, kontrola dostępu, rotacja, audyt, szyfrowanie, centralizacja.
- Wady: Większa złożoność wdrożenia i konfiguracji.
- Przykłady:
Modyfikacja kodu: Priorytetyzacja zmiennych środowiskowych
Pydantic
BaseSettings(teraz częśćpydantic-settings) domyślnie priorytetyzuje zmienne środowiskowe przed plikami.env. To oznacza, że możemy usunąćenv_file = ".env"zConfig, aby wymusić użycie zmiennych środowiskowych, jeśli chcemy uniknąć pliku.envw ogóle.Zachowam plik
.envw strukturze projektu jako przykładowy szablon dla dewelopera, ale zaznaczę, że w produkcji należy używać zmiennych środowiskowych lub systemu zarządzania sekretami.
Zaktualizowana struktura i kod
Krok 1: Nadal ta sama instalacja zależności:
pip install "fastapi[all]" httpx pydantic-settings pyjwt cryptography aiofiles(Uwaga:
pydantic[dotenv]zostało zastąpione przezpydantic-settingsw nowszych wersjach Pydantic.)Krok 2: Struktura projektu (bez zmian, ale z inną interpretacją
.env):/auth_service |-- .env.example <-- Zmieniamy nazwę na .env.example |-- main.py |-- auth_client.py |-- token_manager.py |-- config.py |-- models.py |-- secret.key <-- nadal generujemy klucz szyfrowania dla tokenu JWTKrok 3: Plik
.env.example(teraz jako szablon):Zmień nazwę pliku
.envna.env.example. Będzie to służyło jako wzór, a w produkcji NIE będzie używany.# .env.example # Ten plik jest tylko PRZYKŁADEM dla środowiska deweloperskiego. # W środowisku produkcyjnym należy używać ZMIENNYCH ŚRODOWISKOWYCH lub DEDYKOWANYCH SYSTEMÓW ZARZĄDZANIA SEKRETAMI. EXTERNAL_AUTH_URL="https://zewnetrzny-serwer.com/api/login" EXTERNAL_USERNAME="twoj_login" EXTERNAL_PASSWORD="twoje_haslo"Krok 4: Plik
config.py(kluczowa zmiana):Usunięcie
env_file = ".env"zConfigwSettingsoznacza, że Pydantic będzie szukał zmiennych tylko w zmiennych środowiskowych systemu.# config.py from pydantic_settings import BaseSettings, SettingsConfigDict from functools import lru_cache class Settings(BaseSettings): external_auth_url: str external_username: str external_password: str model_config = SettingsConfigDict( env_file=None, # Wyłącza wczytywanie z pliku .env w produkcji. # W środowisku deweloperskim możesz stworzyć lokalnie .env # i Pydantic-settings go znajdzie, ale to nadal tylko dla dev. # W production dane MUSZĄ pochodzić ze środowiska. case_sensitive=True # Ważne, aby nazwy zmiennych były dokładnie takie jak w kodzie ) @lru_cache() def get_settings() -> Settings: """ Wczytuje ustawienia. UWAGA: W środowisku produkcyjnym, te zmienne powinny być ustawione jako zmienne środowiskowe (np. poprzez Docker, Kubernetes Secrets, systemd, etc.) lub pochodzić z systemu do zarządzania sekretami (np. Vault, AWS Secrets Manager). Nigdy nie przechowuj wrażliwych danych w plikach na dysku w produkcji! """ return Settings()Krok 5: Pozostałe pliki (
main.py,auth_client.py,token_manager.py,models.py) pozostają BEZ ZMIAN, ponieważconfig.pyjuż abstrahuje źródło pochodzenia tych danych.auth_client.pytoken_manager.pymodels.pymain.py(Tak jak w poprzedniej odpowiedzi)
Jak to uruchomić i testować (z uwzględnieniem bezpieczeństwa)?
W środowisku deweloperskim (lokalnie):
- Stwórz plik
.env: Skopiuj zawartość.env.exampledo nowego pliku o nazwie.envw tym samym katalogu.cp .env.example .env - Edytuj
.env: Wypełnij swoimi rzeczywistymi danymi logowania do zewnętrznego serwera. - Wygeneruj klucz szyfrowania:
from cryptography.fernet import Fernet key = Fernet.generate_key() with open("secret.key", "wb") as key_file: key_file.write(key) print("Plik 'secret.key' został wygenerowany.") - Uruchom aplikację:
Pydantic-settings automatycznie wykryje i wczyta zmienne z plikuuvicorn main:app --reload.env(bo w trybie dev, bezenv_file=NonewSettingsConfigDict, Pydantic domyślnie go szuka).
W środowisku produkcyjnym:
-
Nigdy nie wrzucaj
.envani.env.exampledo repozytorium (zabezpieczgit ignore!). -
Nie umieszczaj pliku
.envna serwerze. -
Zamiast tego, wstrzyknij zmienne środowiskowe bezpośrednio do środowiska uruchomieniowego aplikacji:
-
Przykład z systemd (Linux): W pliku jednostki
.service(/etc/systemd/system/your_app.service):[Unit] Description=Your FastAPI App After=network.target [Service] User=youruser Group=yourgroup WorkingDirectory=/path/to/your/app Environment="EXTERNAL_AUTH_URL=https://prod-auth.com/api/login" Environment="EXTERNAL_USERNAME=prod_user" Environment="EXTERNAL_PASSWORD=very_secret_prod_password" # Możesz też załadować z pliku EnvironmentFile=/etc/your_app/secrets.env # Ale ten plik powinien być silnie zabezpieczony uprawnieniami (np. 600, root:root) ExecStart=/usr/bin/python3 -m uvicorn main:app --host 0.0.0.0 --port 8000 Restart=always [Install] WantedBy=multi-user.target -
Przykład z Dockerem (Dockerfile): Nie umieszczaj sekretów w Dockerfile! Używaj zmiennych środowiskowych przekazywanych podczas uruchamiania kontenera.
# Dockerfile # ... twoja aplikacja ... CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]Uruchamianie kontenera:
docker run -d \ -e EXTERNAL_AUTH_URL="https://prod-auth.com/api/login" \ -e EXTERNAL_USERNAME="prod_user" \ -e EXTERNAL_PASSWORD="very_secret_prod_password" \ your_image_nameLUB (lepiej, z Docker Secrets dla Swarm lub Kubernetes Secrets): Jeśli używasz Docker Swarm lub Kubernetes, powinieneś używać wbudowanych mechanizmów zarządzania sekretami, które bezpiecznie wstrzykują te wartości do kontenerów jako zmienne środowiskowe lub montują je jako pliki (ale nadal pod kontrolą systemu).
-
System zarządzania sekretami (np. HashiCorp Vault): Aplikacja łączy się z Vaultem, uwierzytelnia się (np. za pomocą AppRole, Kubernetes Service Account), a następnie pobiera sekrety. Te sekrety są albo wstrzykiwane jako zmienne środowiskowe do procesu, albo aplikacja bezpośrednio je odczytuje. To jest najbardziej zaawansowane i bezpieczne rozwiązanie.
-
Podsumowanie:
Dzięki zmianie w
config.pyi tej strategii wdrażania, Twoja aplikacja będzie oczekiwać, że wrażliwe dane (login i hasło do serwera uwierzytelniania) będą dostarczane z zewnątrz (jako zmienne środowiskowe lub z dedykowanego systemu sekretów), a nie z pliku na dysku. To znacznie zwiększa bezpieczeństwo.Pamiętaj, że
secret.key(klucz do szyfrowania lokalnego tokenu JWT) również jest wrażliwy i powinien być traktowany z taką samą ostrożnością, jak login i hasło. Najlepiej, aby on również pochodził ze zmiennych środowiskowych lub systemu zarządzania sekretami, a nie był statycznym plikiem na dysku produkcyjnego serwera.- Dostępność na dysku: Plik