Was ist Docker und wie erleichtert es die Bereitstellung von Anwendungen?

Docker ist eine Open-Source-Plattform, die die Entwicklung und Bereitstellung von Anwendungen mithilfe von Containern vereinfacht. Container sind leichte, tragbare Einheiten, die eine Anwendung mit allen ihren Abhängigkeiten bündeln und einen konsistenten Ablauf in verschiedenen Umgebungen gewährleisten.

Wie unterstützt Docker Compose die Verwaltung komplexer Anwendungen?

Docker Compose ist ein Tool zur Verwaltung von Multi-Container-Docker-Anwendungen mithilfe einer `docker-compose.yml`-Datei. Es vereinfacht die Konfiguration und Koordination von Diensten, Images, Netzwerken und Volumes und ist ideal zur Verwaltung komplexer Anwendungen wie Microservices.

Welche Schritte gibt es, um eine React JS-Anwendung mit ASP.NET Core unter Verwendung von Docker in Visual Studio zu erstellen?

Um eine React JS-Anwendung mit ASP.NET Core unter Verwendung von Docker in Visual Studio zu erstellen, stellen Sie sicher, dass Sie Visual Studio 2022 oder später mit den erforderlichen Workloads und Docker Desktop installiert haben. Erstellen Sie das Projekt, fügen Sie Docker-Support hinzu und verwenden Sie Docker Compose-Befehle, um die Anwendung zu verwalten.

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

IronSecureDoc kann mit Docker integriert werden, indem das Docker-Image gezogen und innerhalb eines Containers ausgeführt wird. Dieses Setup ermöglicht sichere Dokumentenverarbeitungsoperationen wie Verschlüsselung und Redaktion über seine REST-API und verbessert die Sicherheit in containerisierten Anwendungen.

Welche Vorteile bietet die Verwendung von Docker Compose mit IronSecureDoc für die Dokumentenverarbeitung?

Durch die Integration von Docker Compose mit IronSecureDoc wird die Effizienz und Zuverlässigkeit von Anwendungen verbessert, indem Abhängigkeiten und Dienste in einer containerisierten Umgebung verwaltet werden. Dies gewährleistet eine sichere und skalierbare Dokumentenverarbeitung, was für Anwendungen erforderlich ist, die eine robuste Dokumentensicherheit erfordern.

Wie fügt man einem bestehenden Visual-Studio-Projekt Docker-Support hinzu?

Um einem bestehenden Visual-Studio-Projekt Docker-Support hinzuzufügen, klicken Sie mit der rechten Maustaste auf den Projektnotiz, wählen Sie Hinzufügen > Docker-Support und wählen Sie die entsprechenden Containeroptionen. Dies integriert Docker-Fähigkeiten in Ihr Projekt und ermöglicht eine containerisierte Entwicklung.

Wie ist der Prozess, um IronSecureDoc in einem Docker-Container auszuführen?

Um IronSecureDoc in einem Docker-Container auszuführen, verwenden Sie den 'docker pull'-Befehl, um das Image zu erhalten, und führen dann 'docker container run' mit den erforderlichen Umgebungsvariablen wie Lizenzschlüssel und Ports aus. Diese Einrichtung erleichtert die sichere Dokumentenverarbeitung innerhalb eines Containers.

Wie kann ich ein Dokument mit IronSecureDoc in einer Docker-Umgebung verschlüsseln?

Sie können ein Dokument mit IronSecureDoc verschlüsseln, indem Sie eine POST-Anfrage an dessen API senden. Verwenden Sie den 'curl'-Befehl, um das Dokument hochzuladen und den lokalen Dateipfad sowie die Verschlüsselungsparameter anzugeben. Dieser Vorgang sichert das Dokument innerhalb eines Docker-Containers.

Can Docker run both development and production environments?

Yes, Docker allows applications to be easily deployed and run in consistent environments across development, testing, and production, making it ideal for versatile workflows.

How does the IronSecureDoc REST API work?

Once IronSecureDoc is running in a Docker container, its REST API can be used for document processing tasks like encryption. Developers send requests to specific API endpoints, such as encrypting a document via a POST request.

Iron Suite for .NET

10 .NET-Bibliotheken. Eine komplette Dokumenten-Suite.

Entdecken Sie Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

VERWENDUNG VON IRONSECUREDOC

Docker Compose Build (Entwickler-Tutorial)

Curtis Chau

Updated: 28. Juni 2026

Was ist Docker?

Docker ist eine Open-Source-Plattform, die den Prozess der Entwicklung, Bereitstellung und Ausführung von Anwendungen mithilfe von Containerisierung vereinfacht. Container sind ultraleichte, tragbare Einheiten, die eine Anwendung zusammen mit ihren Abhängigkeiten verpacken, was eine konsistente Ausführung in verschiedenen Umgebungen ermöglicht, von einem lokalen System des Entwicklers bis hin zu Produktionsservern. Im Gegensatz zu traditionellen virtuellen Maschinen nutzen Container den Kernel des Host-Betriebssystems, was ihre Geschwindigkeit und Effizienz verbessert.

Docker Compose Build (Entwickler-Tutorial): Abbildung 1

Docker bietet mithilfe von Docker-Images eine virtualisierte Vorlage, um Container-Sets zu erstellen und zu verwalten. Es umfasst den Docker Hub, eine Art Container-Image-Repository. Der große Reiz dieser Technologie liegt in ihrer Skalierbarkeit, Portabilität und Effizienz, was sie in DevOps und cloudzentrierten Entwicklungsworkflows sehr beliebt macht.

Wie funktioniert Docker?

Der Docker-Daemon wartet auf Anfragen vom Docker-Client, die docker build, docker pull oder docker run enthalten können.
Der Docker-Daemon verwaltet die Erstellung, Verwaltung und Überwachung von Containern. Er ruft auch die benötigten Docker-Images aus einem Registry wie dem Docker Hub ab.
Mithilfe des heruntergeladenen Images erstellt der Daemon einen isolierten Container, effektiv eine laufende Instanz der Anwendung.
Container teilen sich den OS-Kernel der Hostmaschine, bleiben jedoch voneinander isoliert, was es der Software ermöglicht, in einer einzigartigen Umgebung mit ihren Abhängigkeiten zu operieren.

+--------------------+
|   Docker Client   |
|  (CLI/API)        |
+--------------------+
         |
          v
+--------------------+               +---------------------+
|   Docker Daemon    |   -------->   |   Docker Registry  |
|  (manages resources|               |  (stores images)   |
|  & runs containers)|               +---------------------+
+--------------------+
         |
          v
+---------------------+
|      Container      |  
|  (App Instance)    |
+---------------------+
         |
          v
+---------------------+
| Docker Image        |  
| (App Blueprint)    |
+---------------------+

+--------------------+
|   Docker Client   |
|  (CLI/API)        |
+--------------------+
         |
          v
+--------------------+               +---------------------+
|   Docker Daemon    |   -------->   |   Docker Registry  |
|  (manages resources|               |  (stores images)   |
|  & runs containers)|               +---------------------+
+--------------------+
         |
          v
+---------------------+
|      Container      |  
|  (App Instance)    |
+---------------------+
         |
          v
+---------------------+
| Docker Image        |  
| (App Blueprint)    |
+---------------------+

Text

Was ist Docker Compose?

Docker Compose bietet eine einfache Möglichkeit, eine Multi-Container-Docker-Anwendung über eine einzige Datei zu verwalten: docker-compose.yml. Diese YAML-Datei ermöglicht die Konfiguration mehrerer Dienste, einschließlich Aspekten wie Docker-Images, Umgebungsvariablen, Netzwerken und Volumes. Sie können Docker Compose-Befehle wie docker-compose up oder docker-compose down verwenden, um alle Container in einer Anwendung mit einer einzigen Aktion zu verwalten.

+--------------------------+
|   docker-compose.yml     |  (Configuration file)
+--------------------------+
           |
            v
+----------------+    +----------------+    +----------------+
|   Service 1    |    |   Service 2    |    |   Service 3   |
|  (e.g. web)    |    |  (e.g. db)     |    |  (e.g. cache) |
+----------------+    +----------------+    +----------------+
            |                  |                  |
            -----------------------------------------
                         Docker Application

+--------------------------+
|   docker-compose.yml     |  (Configuration file)
+--------------------------+
           |
            v
+----------------+    +----------------+    +----------------+
|   Service 1    |    |   Service 2    |    |   Service 3   |
|  (e.g. web)    |    |  (e.g. db)     |    |  (e.g. cache) |
+----------------+    +----------------+    +----------------+
            |                  |                  |
            -----------------------------------------
                         Docker Application

Text

Docker Compose ist besonders vorteilhaft für komplexe Anwendungen wie Microservices mit zahlreichen Containerinstanzen. Es wird effektiv in Entwicklungs-, Test- und Produktionsumgebungen eingesetzt.

Eine neue React JS-Anwendung mit ASP.NET Core erstellen

Folgen Sie diesen Schritten, um eine neue Visual Studio React-Anwendung mit einem ASP.NET Core-Backend zu erstellen und Docker-Unterstützung hinzuzufügen:

Voraussetzungen

Visual Studio: Stellen Sie sicher, dass Visual Studio 2022 oder neuer mit den erforderlichen Workloads installiert ist:
- Webentwicklung und ASP.NET
- Node.js-Entwicklung (React)
- Docker-Unterstützung
Docker Desktop: Muss installiert und ausgeführt werden.

Neues Projekt erstellen

Öffnen Sie Visual Studio und wählen Sie Neues Projekt aus dem Menü.
Suchen Sie im Dialogfeld 'Neues Projekt erstellen' nach 'React und ASP.NET Core-Webanwendung' und wählen Sie es aus. Drücken Sie Weiter.
Geben Sie einen Namen für das Projekt an, wählen Sie einen Lösungsnamen und den Speicherort aus. Drücken Sie Weiter.
Stellen Sie sicher, dass Docker-Unterstützung aktiviert ist. Wählen Sie das gewünschte Framework und klicken Sie auf Erstellen.
Nach der Projekterstellung fügen Sie Docker-Unterstützung hinzu, indem Sie mit der rechten Maustaste auf den Projektknoten klicken und Add > Docker Support auswählen.
Wählen Sie den Container-Namen und -Typ, dann klicken Sie auf Ok.

Nachdem das neu erstellte Projekt dem Docker-Container hinzugefügt wurde, können Docker Compose-Befehle es ausführen. Unten ist eine Beispielausgabe aus dem React JS-Clientseitencode.

Docker Compose Build (Entwickler-Tutorial): Abbildung 8

Unten ist der API-Serverseitencode, der aus dem Docker-Container ausgeführt wird.

Docker Compose Build (Entwickler-Tutorial): Abbildung 9

IronSecureDoc

IronSecureDoc ermöglicht es Entwicklern, eine sichere Dokumentenverarbeitung effizient in containerisierte Anwendungen einzubetten. Mit der Unterstützung von Docker kapseln Sie Ihre ASP.NET Core-App mit IronSecureDoc ein, um nahtlose Bereitstellung und Skalierung zu fördern. Erstellen Sie eine Dockerfile, um IronSecureDoc mit Ihrer ASP.NET Core-App zu integrieren, zusammen mit den notwendigen Skripten oder Konfigurationen.

Docker Compose Build (Entwickler-Tutorial): Abbildung 10 - IronSecureDoc

Darüber hinaus kann eine docker-compose.yml Datei Dienstabhängigkeiten und Umgebungsvariablen zur einfachen Zugänglichkeit umreißen, was bei der effizienten Bewältigung von Dokumentensicherheitsaufgaben in unterschiedlichen Bereitstellungsumgebungen hilft. Die Installation und Konfiguration von IronSecureDoc sicherzustellen, wie auch von Docker, ist entscheidend, um Funktionen wie Dokumentenverschlüsselung und Schwärzung bereitzustellen.

Installation und Ausführung von IronSecureDoc

Rufen Sie das IronSecureDoc-Docker-Image mit diesem Befehl ab:

docker pull ironsoftwareofficial/ironsecuredoc

docker pull ironsoftwareofficial/ironsecuredoc

SHELL

Docker Compose Build (Entwickler-Tutorial): Abbildung 11

Nach dem Herunterladen des Images verwenden Sie den folgenden Befehl, um IronSecureDoc in einem neuen Container zu starten:

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 Build (Entwickler-Tutorial): Abbildung 12

Verwendung von IronSecureDoc mit Docker-Container

Die REST-API von IronSecureDoc ermöglicht Dokumentoperationen wie Schwärzung, Zertifizierung und Verschlüsselung, sobald sie in Docker installiert und ausgeführt wird. Für weitere Informationen zu API-Endpunkten prüfen Sie die Dokumentation.

Um ein Dokument zu verschlüsseln, senden Sie eine POST-Anfrage an die IronSecureDoc-API:

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

Dieser Befehl übermittelt das Dokument an IronSecureDoc zur Verschlüsselung.

Abschluss

Die Integration von Docker Compose mit IronSecureDoc verbessert erheblich die Effizienz und Zuverlässigkeit von Anwendungen, die eine sichere Dokumentenbearbeitung erfordern. Docker Compose verwaltet effektiv Multi-Container-Anwendungen, vereinfacht die Koordination von Abhängigkeiten und Diensten, einschließlich IronSecureDoc, was Konsistenz in der Entwicklungsumgebung, vereinfachte Konfigurationen und gesteigerte Skalierbarkeit sicherstellt.

In dieser Konfiguration können Entwickler die volle Bandbreite an Dokumentensicherheitsfunktionen wie Verschlüsselung und Schwärzung innerhalb eines containerisierten Rahmens nutzen. Insgesamt bereichert die Kombination von Docker Compose mit IronSecureDoc den Entwicklungsprozess und bietet eine sichere, effiziente Methode für den Umgang mit sensiblen Dokumenten in modernen Anwendungen. Für Informationen zur Lizenzierung von IronSecureDoc besuchen Sie diese Seite. Klicken Sie hier, um mehr über Iron Software-Produkte zu entdecken.