Zum Fußzeileninhalt springen
VERWENDUNG VON IRONSECUREDOC

Docker Compose Umgebungsvariablen (Entwickler-Tutorial)

Die Bereitstellung von Anwendungen in verschiedenen Umgebungen führt häufig zu Kompatibilitätsproblemen. Eine App könnte auf dem Computer des Entwicklers perfekt laufen, aber beim Testen oder im Produktionsmodus auf Schwierigkeiten stoßen, weil sich Betriebssysteme, Abhängigkeiten oder Konfigurationen unterscheiden. Docker löst dieses Problem, indem es Anwendungen in eigenständige Einheiten verpackt, die alles Notwendige enthalten, um die App auszuführen, und so sicherstellt, dass sie überall konsistent funktioniert, von der Entwicklung bis zur Produktion.

Docker Compose bringt mächtige Vorteile für containerisierte Anwendungen, insbesondere durch die Verwendung von Umgebungsvariablen zur Vereinfachung der Konfiguration über verschiedene Setups hinweg. Indem es ermöglicht, wichtige Einstellungen außerhalb des Codes zu verwalten, macht Docker Compose die Bereitstellung komplexer Anwendungen unkomplizierter und sicherer. Aufbauend auf diesen Vorteilen zeigt dieser Artikel auch, wie Sie IronSecureDoc für die sichere Dokumentenverarbeitung verwenden können, indem Sie die Flexibilität von Docker Compose nutzen, um Konfigurationen für Verschlüsselung und Schwärzung effizient zu handhaben.

Was ist Docker?

Docker ist ein Open-Source-System, um die Anwendungsentwicklung, Bereitstellung und Ausführung in einem System durch Containerisierung zu erleichtern. Container sind ultraleichte tragbare Einheiten, die sowohl eine Anwendung als auch deren Abhängigkeiten enthalten, sodass sie überall einheitlich laufen - von der Entwicklermaschine bis zu Produktionsservern. Container teilen sich den Kernel des Betriebssystems des Hosts im Vergleich zu traditionellen virtuellen Maschinen und sind daher viel schneller und effizienter.

Docker Compose Environment Variables (Developer Tutorial): Abbildung 1 - Docker-Webseite

Dies würde eine virtualisierte Vorlage in Form von Docker-Images bedeuten, um dieses Set von Containern zu erstellen und zu verwalten. Darüber hinaus enthält die Plattform Docker Hub, das in gewisser Weise ein Container-Image-Repository ist. Die Schönheit dieser Technologie liegt in ihrer Benutzerfreundlichkeit in Bezug auf Skalierbarkeit, Portabilität und Effizienz, was einer der Gründe ist, warum sie bei vielen DevOps- und cloud-basierten Entwicklungs-Workflows so beliebt geworden ist.

Was sind Umgebungsvariablen in Docker-Compose?

In Docker wird eine Umgebungsvariable in Form eines Schlüssel-Wert-Paares verwendet, um Einstellungen in der containerisierten Anwendung zu konfigurieren. Solche Variablen können nützlich sein, um das Verhalten der Anwendung selbst ohne Änderung ihres Codes zu steuern, da sich leicht Konfigurationen wie Datenbankanmeldeinformationen und API-Schlüssel oder Umgebungsmodi (z.B. Entwicklung, Produktion) ändern lassen.

In Docker kann ein Umgebungsattribut innerhalb der Dockerfile, innerhalb der docker-compose.yml-Datei oder zur Laufzeit mit dem docker run-Befehl definiert werden. Die Verwendung von Umgebungsvariablen ermöglicht Docker eine konsistente und flexible Bereitstellung von Anwendungen in verschiedenen Umgebungen und verwaltet sensible Daten wie Passwörter und API-Tokens effektiver.

Wie erstelle ich Umgebungsvariablen in Docker?

Wir können Umgebungsvariablen in Docker auf verschiedene Weisen definieren. Sie können mit einer Docker Compose-Datei, der docker-compose.yml-Datei, in einer Umgebungsdatei oder sogar zur Laufzeit definiert werden, während Sie den docker run-Befehl ausführen. Denken Sie daran, Umgebungsvariablen getrennt von der Hauptkonfigurationsdatei zu halten, führt zu einer einfacheren Organisation der Variablen! Hier ist eine Liste der verschiedenen Methoden, die angewendet werden können, um Ihre Variablen zu definieren.

Umgebungsvariablen in der Dockerfile setzen

Wir können Umgebungsvariablen direkt in der Dockerfile unter Verwendung der ENV-Anweisung definieren. Das kann hilfreich sein, wenn Sie Standardwerte für die Variablen in Ihrem Docker-Image einbeziehen möchten.

# Dockerfile
# Set the application environment
ENV APP_ENV=development
# Set the database URL
ENV DATABASE_URL=postgres://user:password@db:1234/mydev

Das Festlegen von Umgebungsvariablen mit den in der Dockerfile definierten Werten wird automatisch zur Laufzeit des Containers angewendet.

Umgebungsvariablen in Docker-Compose.yml setzen

Wir können Umgebungsvariablen für jeden Dienst innerhalb einer docker-compose.yml mit Hilfe des environment-Schlüsselworts definieren. Das ist praktisch, wenn Sie Docker Compose verwenden, um ein paar Dienste zu verwalten.

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
YAML

Umgebungsvariablen zur Laufzeit setzen

Wir können Umgebungsvariablen bei der Ausführung eines Containers angeben, indem wir das -e-Flag zusammen mit dem docker run-Befehl verwenden. Das ist gut für vorübergehende und dynamische Werte, die Sie wahrscheinlich nicht zur Dockerfile hinzufügen würden.

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
SHELL

Verwendung von Umgebungsdateien (.env)

Wir können Umgebungsvariablen in einer Datei wie .env speichern und in Ihre Docker-Container laden. In Docker Compose beziehen wir uns darauf mit der env_file-Direktive.

# .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
SHELL

Wir verwalten mehrere Dateien mit Umgebungsvariablen außerhalb der Konfigurationsdateien mithilfe von env-Dateien.

Was ist IronSecureDoc?

IronSecureDoc für Docker ermöglicht es Entwicklern, leicht eine sichere Dokumentenverarbeitungskapazität zu ihren containerisierten Anwendungen hinzuzufügen. Nachdem Sie Docker gelernt haben, können Sie Ihre ASP.NET Core-Anwendung mit IronSecureDoc in einer homogenen Umgebung kapseln, die die Bereitstellung und Skalierung vereinfacht. Hierfür erstellen Sie eine Dockerfile, die den Aufbau Ihrer ASP.NET Core-Anwendung mithilfe der IronSecureDoc-Bibliothek und möglicherweise anderer Installationsskripte oder Konfigurationen orchestriert, die benötigt werden, um alles funktionsfähig zu machen.

Docker Compose Environment Variables (Developer Tutorial): Abbildung 2 - IronSecureDoc-Webseite

Außerdem enthält es eine docker-compose.yml-Datei, die die Dienstabhängigkeiten und Umgebungsvariablen sowie zugeordnete Ports deklariert. Dies macht die Durchführung von Dokumentensicherheitsaufgaben viel zugänglicher, sodass Ihre Anwendung effizient und effektiv in einer anderen Umgebung als der während der Entwicklung oder Produktion genutzten ausgeführt werden kann. Installation und Konfiguration von IronSecureDoc Genau wie bei Docker wird eine ordnungsgemäße Installation und Konfiguration von IronSecureDoc erforderlich sein, um seine Fähigkeiten richtig zu realisieren: Dokumentverschlüsselung, Schwärzung, usw.

Hauptfunktionen von IronSecureDoc

IronSecureDoc bietet eine Reihe leistungsstarker Funktionen für PDF-Sicherheit und Dokumentenmanagement:

  • Verschlüsselung: Bietet 128- oder 256-Bit-Verschlüsselung mit passwortbasierter Sicherheit zum Schutz der Dokumentgeheimhaltung.
  • Schwärzung: Entfernt sensible Informationen, wie persönliche Kennungen, um Datenschutzstandards und -verordnungen zu erfüllen.
  • Digitale Signatur: Unterstützt digitale Signaturen und Beurkundung mit .pfx- oder .p12-Zertifikaten, um die Dokumentenauthentizität sicherzustellen.
  • REST API: Flexibles API ermöglicht nahtlose Integration mit anderen Software und Workflows.
  • Docker-Integration: Native Unterstützung für Docker vereinfacht die Bereitstellung und Skalierung für Cloud- oder On-Premise-Anwendungen.

Diese Funktionen machen IronSecureDoc zu einer ausgezeichneten Wahl für Sektoren, die mit sensiblen Dokumenten arbeiten, wie z.B. Recht, Gesundheitswesen und Finanzen.

Installation und Ausführung von IronSecureDoc

Schritt 1

Um IronSecureDoc zu installieren, führen Sie den folgenden Befehl in einem Terminalfenster oder der Eingabeaufforderung aus, um das IronSecureDoc Docker-Image aus dem Repository zu holen.

docker pull ironsoftwareofficial/ironsecuredoc
docker pull ironsoftwareofficial/ironsecuredoc
SHELL

Docker Compose Environment Variables (Developer Tutorial): Abbildung 3 - Konsolenausgabe für das Abrufen des IronSecureDoc-Images

Schritt 2

Sobald das IronSecureDoc-Image heruntergeladen wurde, können wir den folgenden docker-compose-Befehl verwenden, um das Image in den Docker-Container zu laden.

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
SHELL

Docker Compose Environment Variables (Developer Tutorial): Abbildung 4 - Konsolenausgabe vom Ausführen des IronSecureDoc-Images

Wir verwenden den Docker-Container, um IronSoftwares offizielles Repository auszuführen. Die oben gezeigte Befehlszeile unterteilt sich in mehrere Teile, die im Folgenden erläutert werden.

Befehlsanalyse

  • docker container run - Dieser Befehl verwendet das angegebene Image, um einen neuen Docker-Container zu erstellen und zu starten.
  • --rm - Bereinigt automatisch den Container sofort, nachdem er nicht mehr läuft. Es entfernt alle ungenutzten Container zum Zeitpunkt des Abschlusses eines Prozesses.
  • -p 8080:8080 - Veröffentlicht den Port 8080 des Containers, sodass Sie darauf über Ihre Maschine unter http://localhost:8080 zugreifen können.
  • -e IronSecureDoc_LicenseKey=<IRONSECUREDOC_LICENSE_KEY> - Setzt eine Umgebungsvariable im laufenden Container namens IronSecureDoc_LicenseKey, die es Ihnen ermöglicht, lizenzierte Funktionen von IronSecureDoc zu aktivieren und zu nutzen. Ersetzen Sie <IRONSECUREDOC_LICENSE_KEY> durch Ihren tatsächlichen Schlüssel.
  • -e ENVIRONMENT=Development - Die Umgebungsvariable ist auf Entwicklung gesetzt. Das bedeutet, dass der Container im Entwicklungsmodus ausgeführt werden muss. Normalerweise wird dieser Container für Test- oder Debug-Fälle verwendet; ansonsten unterscheidet er sich von nicht-produktiven Konfigurationen.
  • -e HTTP_PORTS=8080 - Diese Umgebungsvariable wird verwendet, um anzugeben, dass der Container den Port 8080 für HTTP-Verkehr ausgeben und abhören soll. Es gewährleistet den Zugriff auf den Dienst innerhalb des Containers, indem er durch diesen bestimmten Port weitergeleitet wird.
  • ironsoftwareofficial/ironsecuredoc:latest - Dies ist das Docker-Image. Es spezifiziert, dass die neueste Version des Images aus dem Docker-Registrierungsdienst für IronSecureDoc verwendet werden soll.

IronSecuredoc-Container

Die REST API von IronSecureDoc ermöglicht es Benutzern, Dokumente nach ihrem Start in Docker zu schwärzen, zertifizieren und zu verschlüsseln. Hier ist ein Link zu den API-Endpunkten und der Dokumentation mit Swagger UI, sobald Sie IronSecureDoc in einem Docker-Container gestartet haben: http://localhost:8080/swagger/index.html.

Docker Compose Environment Variables (Developer Tutorial): Abbildung 5 - Swagger UI, um mit API-Endpunkten zu interagieren

Aus dem obigen Beispiel können wir eine POST-Anfrage an die IronSecureDoc-API senden, um ein Dokument zur Verschlüsselung einzureichen:

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'
SHELL

Durch diese Handlung wird IronSecureDoc das Dokument empfangen und richtig verschlüsseln.

Abschluss

Zusammengefasst ermöglichen die Umgebungsvariablen von Docker Compose die Konfiguration von Anwendungen auf eine sehr flexible und effiziente Weise, da die Konfigurationsdetails automatisch vom Anwendungscode getrennt sind. Folglich ist es einfacher, verschiedene Umgebungen wie Entwicklung, Test und Produktion zu verwalten, da nur Variablen wie API-Schlüssel, Datenbankanmeldeinformationen und Einstellungen einer Anwendung geändert werden müssen, anstatt ihres Codes.

Die Verwendung von Docker Compose zur Implementierung von IronSecureDoc nutzt Umgebungsvariablen, um sicher die Lizenzinformationen zu handhaben, zum Beispiel den IronSecureDoc_LicenseKey, sowie zur Angabe der HTTP-Ports oder des bevorzugten Umgebungsmodus als entweder Entwicklung oder Produktion mittels Umgebungsvariablen. Die Verwendung von Umgebungsvariablen beim Setup macht es einfacher, IronSecureDoc mit deutlich weniger überladenen und schwer zu skalierenden Konfigurationen bereitzustellen und erhöht die Sicherheit.

Erweiterte Funktionen werden durch eine gültige Lizenz von IronSecureDoc zugänglich. Die Anwendung des Werkzeugs ist streng von bestimmten Nutzungsbedingungen abhängig. Sie können auch andere leistungsstarke Bibliotheken nutzen, die Iron Software anbietet, um den Entwicklungsprozess einfacher und schneller zu gestalten und robuste Funktionalitäten beim Arbeiten mit PDFs, Texterkennung und Barcodes für jede erdenkliche Anwendung bereitzustellen.

Docker Compose Environment Variables (Developer Tutorial): Abbildung 6 - IronSecureDoc-Lizenzseite

Häufig gestellte Fragen

Wie kann Docker Compose die Anwendungsbereitstellung verbessern?

Docker Compose verbessert die Anwendungsbereitstellung, indem es Umgebungsvariablen verwendet, um Konfigurationen extern zu verwalten. Dies ermöglicht eine einfache Skalierung und Anpassung über verschiedene Umgebungen hinweg, ohne den Anwendungscode zu ändern.

Welche Rolle spielen Umgebungsvariablen in Docker?

Umgebungsvariablen in Docker sind Schlüssel-Wert-Paare, die Anwendungseinstellungen unabhängig vom Code konfigurieren. Dadurch wird das sichere Management sensibler Informationen wie Passwörter und API-Schlüssel ermöglicht.

Wie integriert sich IronSecureDoc mit Docker für die sichere Dokumentenverarbeitung?

IronSecureDoc integriert sich mit Docker, indem es ein Docker-Image bereitstellt, das mithilfe von Docker-Befehlen abgerufen und ausgeführt werden kann. Es verwendet Umgebungsvariablen zur Konfiguration sicherer Dokumentverarbeitungsfunktionen wie Verschlüsselung, Schwärzung und digitale Signatur.

Was sind die Vorteile der Verwendung von Umgebungsvariablen in Docker Compose?

Die Verwendung von Umgebungsvariablen in Docker Compose ermöglicht eine flexible Konfigurationsverwaltung, verbesserte Sicherheit durch das Halten sensibler Daten außerhalb des Anwendungscodes und optimierte Bereitstellungsprozesse über verschiedene Umgebungen hinweg.

Wie kann man IronSecureDoc in einer Docker-Umgebung ausführen?

Um IronSecureDoc in einer Docker-Umgebung auszuführen, können Sie den Befehl docker container run --rm -p 8080:8080 -e IronSecureDoc_LicenseKey= -e ENVIRONMENT=Development -e HTTP_PORTS=8080 ironsoftwareofficial/ironsecuredoc:latest verwenden und notwendige Umgebungsvariablen für die Einrichtung angeben.

Welche Funktionen bietet IronSecureDoc zur Dokumentensicherheit?

IronSecureDoc bietet Funktionen wie Dokumentverschlüsselung, Schwärzung, digitale Signatur und nahtlose Integration mit Docker für sichere Dokumentenverarbeitung in containerisierten Umgebungen.

Wie werden Umgebungsvariablen in einem Docker Compose-Setup gesetzt?

Umgebungsvariablen können in Docker Compose unter Verwendung einer docker-compose.yml-Datei, Umgebungsdateien oder Laufzeitbefehlen gesetzt werden, was Flexibilität und Sicherheit in der Verwaltung von Anwendungskonfigurationen bietet.

Warum ist es wichtig, Konfiguration vom Code in Docker-Bereitstellungen zu trennen?

Die Trennung von Konfiguration und Code durch Umgebungsvariablen ist in Docker-Bereitstellungen wichtig, da sie die Sicherheit erhöht, die Verwaltung über verschiedene Umgebungen hinweg vereinfacht und das Risiko einer Offenlegung sensibler Informationen reduziert.

Curtis Chau
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen