Zmienne środowiskowe Docker Compose (samouczek dla programistów)
Wdrażanie aplikacji w różnych środowiskach często prowadzi do problemów z kompatybilnością. Aplikacja może działać idealnie na komputerze programisty, ale napotkać problemy podczas testów lub w środowisku produkcyjnym z powodu różnic w systemach operacyjnych, zależnościach lub konfiguracjach. Docker rozwiązuje ten problem, pakując aplikacje w samodzielne jednostki, które zawierają wszystko, co jest potrzebne do uruchomienia aplikacji, zapewniając jej spójne działanie wszędzie, od etapu rozwoju po produkcję.
Docker Compose zapewnia ogromne korzyści dla aplikacji kontenerowych, zwłaszcza dzięki wykorzystaniu zmiennych środowiskowych, które upraszczają konfigurację w różnych ustawieniach. Dzięki możliwości zarządzania kluczowymi ustawieniami poza kodem Docker Compose sprawia, że wdrażanie złożonych aplikacji jest prostsze i bezpieczniejsze. Opierając się na tych zaletach, w tym artykułe pokażemy również, jak można wykorzystać IronSecureDoc do bezpiecznego przetwarzania dokumentów, korzystając z elastyczności Docker Compose w celu wydajnego zarządzania konfiguracjami szyfrowania i redagowania.
Czym jest Docker?
Docker to system typu open source, który ułatwia tworzenie, wdrażanie i uruchamianie aplikacji w systemie poprzez konteneryzację. Kontenery to ultralekkie, przenośne jednostki zawierające zarówno aplikację, jak i jej zależności, dzięki czemu działają one jednakowo wszędzie — od komputera programisty po serwery produkcyjne. W porównaniu z tradycyjnymi maszynami wirtualnymi kontenery współdzielą jądro systemu operacyjnego hosta, dzięki czemu są znacznie szybsze i wydajniejsze.

Oznaczałoby to wirtualizowany szablon w postaci obrazów Docker do tworzenia i utrzymywania tego zestawu kontenerów. Ponadto platforma zawiera Docker Hub, który jest w pewnym sensie repozytorium obrazów kontenerów. Piękno tej technologii polega na jej łatwości użytkowania w zakresie skalowalności, przenośności i wydajności, co jest jednym z powodów, dla których zyskała ona taką popularność wśród wielu środowisk DevOps i procesów programistycznych opartych na chmurze.
Czym są zmienne środowiskowe w Docker-Compose?
W Dockerze do konfiguracji ustawień w aplikacji kontenerowej używana jest zmienna środowiskowa w postaci pary klucz-wartość. Takie zmienne mogą być przydatne do kontrolowania zachowania samej aplikacji bez modyfikowania jej kodu, ponieważ można łatwo zmieniać konfiguracje, takie jak poświadczenia bazy danych i klucze API lub tryby środowiska (na przykład: programowanie, produkcja).
W Dockerze atrybut środowiska można zdefiniować w pliku Dockerfile, w pliku docker-compose.yml lub przekazać w czasie wykonywania za pomocą polecenia docker run. Dzięki wykorzystaniu zmiennych środowiskowych Docker umożliwia spójne i elastyczne wdrażanie aplikacji w różnych środowiskach oraz pozwala na bardziej efektywne zarządzanie danymi wrażliwymi, takimi jak hasła i tokeny API.
Jak utworzyć zmienne środowiskowe w Dockerze?
W Dockerze możemy definiować zmienne środowiskowe na kilka sposobów. Można je zdefiniować za pomocą pliku Docker Compose, pliku docker-compose.yml, w pliku Środowiska, a nawet w czasie wykonywania, podczas uruchamiania polecenia docker run. Pamiętaj, że oddzielenie zmiennych środowiskowych od głównego pliku konfiguracyjnego ułatwia organizację zmiennych! Oto lista różnych metod, które można zastosować do zdefiniowania zmiennych.
Ustawianie zmiennych środowiskowych w pliku Dockerfile
Zmienne środowiskowe można zdefiniować bezpośrednio w pliku Dockerfile, używając instrukcji ENV. Może to być pomocne, jeśli chcesz uwzględnić wartości domyślne dla zmiennych w swoim obrazie Docker.
# Dockerfile
# Set the application environment
ENV APP_ENV=development
# Set the database URL
ENV DATABASE_URL=postgres://user:password@db:1234/mydev
Ustawienie zmiennych środowiskowych o wartościach zdefiniowanych w pliku Dockerfile zostanie automatycznie zastosowane w czasie działania kontenera.
Ustaw zmienne środowiskowe w pliku Docker-Compose.yml
Możemy zdefiniować zmienne środowiskowe dla każdej usługi w pliku docker-compose.yml za pomocą słowa kluczowego environment. Jest to przydatne, gdy używasz Docker Compose do zarządzania kilkoma usługami.
version: '3.8'
services:
myapp:
image: myapp:latest
environment:
- APP_ENV=development
- DATABASE_URL=postgres://user:password@db:1234/mydev
version: '3.8'
services:
myapp:
image: myapp:latest
environment:
- APP_ENV=development
- DATABASE_URL=postgres://user:password@db:1234/mydev
Ustawianie zmiennych środowiskowych w czasie wykonywania
Możemy określić zmienne środowiskowe podczas uruchamiania kontenera, używając flagi -e wraz z poleceniem docker run. Jest to przydatne w przypadku wartości przejściowych i dynamicznych, których prawdopodobnie nie dodawałbyś do pliku Dockerfile.
docker run -e APP_ENV=development -e DATABASE_URL=postgres://user:password@db:1234/mydev myapp:latest
docker run -e APP_ENV=development -e DATABASE_URL=postgres://user:password@db:1234/mydev myapp:latest
Korzystanie z plików środowiskowych (.env)
Możemy przechowywać zmienne środowiskowe w pliku takim jak .env i wczytywać je do kontenerów Docker. W Docker Compose będziemy odnosić się do niego za pomocą dyrektywy env_file.
# .env file
APP_ENV=production
DATABASE_URL=postgres://user:password@db:1234/mydev
# .env file
APP_ENV=production
DATABASE_URL=postgres://user:password@db:1234/mydev
Możemy zarządzać wieloma plikami, z zmiennymi środowiskowymi poza plikami konfiguracyjnymi, dzięki plikom env.
Czym jest IronSecureDoc?
IronSecureDoc dla Docker pozwala programistom w łatwy sposób dodać funkcję bezpiecznego przetwarzania dokumentów do swoich aplikacji kontenerowych. Po opanowaniu Docker możesz zamknąć swoją aplikację ASP.NET Core w IronSecureDoc w jednolitym środowisku, które ułatwia wdrażanie i skalowanie. W tym celu należy utworzyć plik Dockerfile, który koordynuje tworzenie aplikacji ASP.NET Core przy użyciu biblioteki IronSecureDoc oraz ewentualnie innych skryptów instalacyjnych lub konfiguracji niezbędnych do prawidłowego działania.

Ponadto zawiera plik docker-compose.yml, w którym zadeklarowano zależności usług, zmienne środowiskowe oraz zmapowane porty, z których należy korzystać. Dzięki temu wykonywanie zadań związanych z bezpieczeństwem dokumentów staje się znacznie łatwiejsze, co pozwala na wydajne i skuteczne działanie aplikacji w środowisku innym niż to używane podczas tworzenia lub produkcji. Instalacja i konfiguracja IronSecureDoc Podobnie jak w przypadku Docker, aby w pełni wykorzystać możliwości IronSecureDoc, konieczna będzie jego prawidłowa instalacja i konfiguracja: szyfrowanie dokumentów, redagowanie itp.
Najważniejsze cechy IronSecureDoc
IronSecureDoc oferuje szereg zaawansowanych funkcji zapewniających bezpieczeństwo plików PDF i zarządzanie dokumentami:
- Szyfrowanie: Zapewnia 128- lub 256-bitowe szyfrowanie z zabezpieczeniem opartym na haśle w celu ochrony poufności dokumentów.
- Redakcja: usuwa poufne informacje, takie jak dane osobowe, w celu spełnienia standardów i przepisów dotyczących prywatności.
- Podpis cyfrowy: Obsługuje podpis cyfrowy i poświadczenie notarialne przy użyciu certyfikatów .pfx lub .p12 w celu zapewnienia autentyczności dokumentu.
- REST API: Elastyczny interfejs API umożliwia płynną integrację z innym oprogramowaniem i procesami roboczymi.
- Integracja z Dockerem: Natywna obsługa Docker upraszcza wdrażanie i skalowanie aplikacji w chmurze lub lokalnie.
Te cechy sprawiają, że IronSecureDoc jest doskonałym wyborem dla sektorów zajmujących się dokumentami wrażliwymi, takich jak sektor prawny, opieka zdrowotna i finanse.
Instalacja i uruchamianie IronSecureDoc
Krok 1
Aby zainstalować IronSecureDoc, uruchom następujące polecenie w oknie terminala lub wierszu poleceń, aby pobrać obraz Docker IronSecureDoc z repozytorium.
docker pull ironsoftwareofficial/ironsecuredoc
docker pull ironsoftwareofficial/ironsecuredoc

Krok 2
Po pobraniu obrazu IronSecureDoc możemy użyć następującego polecenia docker-compose, aby uruchomić obraz w kontenerze Docker.
docker container run --rm -p 8080:8080 -e IronSecureDoc_LicenseKey=<IRONSECUREDOC_LICENSE_KEY> -e ENVIRONMENT=Development -e HTTP_PORTS=8080 ironsoftwareofficial/ironsecuredoc:latest
docker container run --rm -p 8080:8080 -e IronSecureDoc_LicenseKey=<IRONSECUREDOC_LICENSE_KEY> -e ENVIRONMENT=Development -e HTTP_PORTS=8080 ironsoftwareofficial/ironsecuredoc:latest

Używamy kontenera Docker do uruchamiania oficjalnego repozytorium IronSoftware. Powyższe polecenie dzieli się na kilka części, które wyjaśniono poniżej.
Wyjaśnienie polecenia
docker container run- To polecenie wykorzystuje podany obraz do utworzenia i uruchomienia nowego kontenera Docker.--rm- Automatycznie czyści kontener natychmiast po zakończeniu jego działania. Usuwa wszystkie nieużywane kontenery w momencie zakończenia dowolnego procesu.-p 8080:8080- Publikuje port 8080 kontenera, dzięki czemu można uzyskać do niego dostęp na swoim komputerze pod adresem http://localhost:8080.-e IronSecureDoc_LicenseKey=<IRONSECUREDOC_LICENSE_KEY>- Ustaw w uruchomionym kontenerze zmienną środowiskową o nazwie IronSecureDoc_LicenseKey, która pozwala włączyć i korzystać z licencjonowanych funkcji IronSecureDoc. Zastąp<IRONSECUREDOC_LICENSE_KEY>swoim rzeczywistym kluczem.-e ENVIRONMENT=Development- Zmienna środowiskowa jest ustawiona na Development. Oznacza to, że kontener musi być uruchomiony w trybie programistycznym. Zazwyczaj ten kontener jest używany do przypadków testowych lub debugowania; poza tym różni się od konfiguracji nieprodukcyjnych.-e HTTP_PORTS=8080- Ta zmienna środowiskowa służy do określenia, że kontener powinien udostępniać i nasłuchiwać na porcie 8080 w celu obsługi ruchu HTTP. Zapewnia to dostęp do usługi wewnątrz kontenera poprzez ten konkretny port.ironsoftwareofficial/ironsecuredoc:latest- To jest obraz Docker. Oznacza to, że należy użyć najnowszej wersji obrazu z rejestru Docker dla IronSecureDoc.
IronSecureDoc Container
Interfejs API REST IronSecureDoc pozwala użytkownikom na redagowanie, certyfikowanie i szyfrowanie dokumentów po uruchomieniu w Dockerze. Oto link do punktów końcowych API i dokumentacji z interfejsem Swagger UI, dostępny po uruchomieniu IronSecureDoc w kontenerze Docker: http://localhost:8080/swagger/index.html.

Na podstawie powyższego przykładu możemy wysłać żądanie POST do interfejsu API IronSecureDoc w celu przesłania dokumentu do szyfrowania:
curl -X 'POST' \
'http://localhost:8080/v1/document-services/pdfs/encrypt?user_password=demo' \
-H 'accept: */*' \
-H 'Content-Type: multipart/form-data' \
-F 'pdf_file=@test.pdf;type=application/pdf'
curl -X 'POST' \
'http://localhost:8080/v1/document-services/pdfs/encrypt?user_password=demo' \
-H 'accept: */*' \
-H 'Content-Type: multipart/form-data' \
-F 'pdf_file=@test.pdf;type=application/pdf'
W ten sposób IronSecureDoc otrzyma dokument i odpowiednio go zaszyfruje.
Wnioski
Podsumowując, zmienne środowiskowe Docker Compose umożliwiają konfigurację aplikacji w bardzo elastyczny i wydajny sposób, ponieważ szczegóły konfiguracji są automatycznie oddzielone od kodu aplikacji. W rezultacie zarządzanie różnymi środowiskami, takimi jak środowisko programistyczne, testowe i produkcyjne, jest prostsze, ponieważ zamiast kodu aplikacji wystarczy zmienić jedynie zmienne, takie jak klucze API, dane uwierzytelniające do bazy danych oraz ustawienia aplikacji.
Wykorzystanie Docker Compose do wdrożenia IronSecureDoc wykorzystuje zmienne środowiskowe do bezpiecznego przetwarzania informacji licencyjnych, na przykład IronSecureDoc_LicenseKey, a także do określenia portów HTTP lub preferowanego trybu środowiska (rozwojowego lub produkcyjnego) za pomocą zmiennych środowiskowych. Wykorzystanie zmiennych środowiskowych do konfiguracji ułatwia wdrożenie IronSecureDoc, zmniejszając liczbę nieuporządkowanych i trudnych do skalowania ustawień oraz zwiększając bezpieczeństwo.
Zaawansowane funkcje stają się dostępne dzięki ważnej licencji IronSecureDoc. Korzystanie z narzędzia jest ściśle uzależnione od określonych warunków użytkowania. Można również skorzystać z innych wysokowydajnych bibliotek oferowanych przez Iron Software, aby ułatwić i przyspieszyć proces tworzenia oprogramowania, zapewniając solidne funkcje do pracy z plikami PDF, rozpoznawania tekstu i BarCode dla każdej możliwej aplikacji.

Często Zadawane Pytania
Jak Docker Compose może poprawić wdrażanie aplikacji?
Docker Compose zwiększa wydajność wdrażania aplikacji poprzez wykorzystanie zmiennych środowiskowych do zarządzania konfiguracjami zewnętrznymi, co pozwala na łatwe skalowanie i adaptację w różnych środowiskach bez modyfikowania kodu aplikacji.
Jaką rolę odgrywają zmienne środowiskowe w Docker?
Zmienne środowiskowe w Docker to pary klucz-wartość, które konfigurują ustawienia aplikacji niezależnie od kodu, umożliwiając bezpieczne zarządzanie poufnymi informacjami, takimi jak hasła i klucze API.
Jak IronSecureDoc integruje się z Dockerem do bezpiecznego przetwarzania dokumentów?
IronSecureDoc integruje się z Docker, zapewniając obraz Docker, który można pobrać i uruchomić za pomocą poleceń Docker. Wykorzystuje zmienne środowiskowe do konfigurowania funkcji bezpiecznego przetwarzania dokumentów, takich jak szyfrowanie, redakcja i podpis cyfrowy.
Jakie są korzyści z używania zmiennych środowiskowych w Docker Compose?
Używanie zmiennych środowiskowych w Docker Compose pozwala na elastyczne zarządzanie konfiguracją, podnosi bezpieczeństwo przez trzymanie wrażliwych danych poza kodem aplikacji i upraszcza procesy wdrożeniowe w różnych środowiskach.
Jak można uruchomić IronSecureDoc w środowisku Docker?
Aby uruchomić IronSecureDoc w środowisku Docker, można użyć polecenia docker container run --rm -p 8080:8080 -e IronSecureDoc_LicenseKey=, określając niezbędne zmienne środowiskowe dla konfiguracji.
Jakie funkcje zapewnia IronSecureDoc dla bezpieczeństwa dokumentów?
IronSecureDoc oferuje funkcje takie jak szyfrowanie dokumentów, redakcja, podpis cyfrowy oraz płynną integrację z Docker dla bezpiecznego przetwarzania dokumentów w środowiskach konteneryzowanych.
W jaki sposób ustawia się zmienne środowiskowe w konfiguracji Docker Compose?
Zmienne środowiskowe można ustawić w Docker Compose za pomocą pliku docker-compose.yml, plików środowiskowych lub poleceń uruchomieniowych, co zapewnia elastyczność i bezpieczeństwo w zarządzaniu konfiguracjami aplikacji.
Dlaczego oddzielenie konfiguracji od kodu jest ważne w wdrożeniach Docker?
Oddzielenie konfiguracji od kodu za pomocą zmiennych środowiskowych jest ważne w wdrożeniach Docker, ponieważ zwiększa bezpieczeństwo, upraszcza zarządzanie w różnych środowiskach i zmniejsza ryzyko ujawnienia poufnych informacji.




