Construction de Docker Compose (Tutoriel pour développeurs)

Qu'est-ce que Docker ?

Docker est une plateforme open-source qui simplifie le processus de développement, de déploiement et d'exécution d'applications en utilisant la conteneurisation. Les conteneurs sont des unités ultra-légères et portables qui emballent une application avec ses dépendances, permettant une exécution cohérente à travers divers environnements, du système local d'un développeur aux serveurs de production. Contrairement aux machines virtuelles traditionnelles, les conteneurs utilisent le noyau du système d'exploitation hôte, améliorant ainsi leur rapidité et leur efficacité.

Docker offre un modèle virtualisé via les images Docker pour créer et gérer des ensembles de conteneurs. Il inclut le Docker Hub, une forme de référentiel d'images de conteneurs. Le grand attrait de cette technologie réside dans sa scalabilité, sa portabilité et son efficacité, la rendant très populaire dans les workflows de développement DevOps et centrés sur le cloud.

Comment fonctionne Docker ?

• Le démon Docker écoute les requêtes du client Docker, qui peuvent inclure docker build, docker pull ou docker run.
• Le daemon Docker gère la création, la gestion et la surveillance des conteneurs. Il récupère également les images Docker nécessaires à partir d'un registre, tel que Docker Hub.
• En utilisant l'image téléchargée, le daemon crée un conteneur isolé, effectuant effectivement une instance en cours d'exécution de l'application.
• Les conteneurs partagent le noyau du système d'exploitation de la machine hôte mais restent isolés les uns des autres, permettant au logiciel de fonctionner dans un environnement unique avec ses dépendances.

+--------------------+
|   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)    |
+---------------------+

Qu'est-ce que Docker Compose ?

Docker Compose offre un moyen simple de gérer une application Docker multi-conteneurs à l'aide d'un seul fichier : docker-compose.yml. Ce fichier YAML permet de configurer plusieurs services, en spécifiant des aspects tels que les images Docker, les variables d'environnement, les réseaux et les volumes. Vous pouvez utiliser des commandes Docker Compose telles que docker-compose up ou docker-compose down pour gérer tous les conteneurs d'une application en une seule action.

+--------------------------+
|   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

Docker Compose est particulièrement avantageux pour les applications complexes comme les microservices avec de nombreux instances de conteneurs. Il est effectivement utilisé dans des environnements de développement, de test et de production.

Créer une nouvelle application React JS avec ASP.NET Core

Suivez ces étapes pour créer une nouvelle application React dans Visual Studio avec un backend ASP.NET Core et ajouter le support Docker :

Prérequis

• Visual Studio : Assurez-vous que Visual Studio 2022 ou une version plus récente est installé avec les charges de travail nécessaires :
  • Développement web et ASP.NET
  • Développement Node.js (React)
• Support Docker
• Docker Desktop : Doit être installé et en cours d'exécution.

Créer un nouveau projet

1. Ouvrez Visual Studio et choisissez Nouveau Projet dans le menu.

   

2. Recherchez "React et ASP.NET Core Web Application" dans la boîte de dialogue "Créer un nouveau projet" et sélectionnez-le. Cliquez sur Suivant.

   

3. Donnez un nom au projet, sélectionnez un nom de solution et choisissez l'emplacement de sauvegarde. Cliquez sur Suivant.

   

4. Assurez-vous que le support Docker est activé. Sélectionnez le framework souhaité et cliquez sur Créer.

   

5. Après la création du projet, ajoutez le support Docker en cliquant avec le bouton droit sur le nœud du projet et en sélectionnant Ajouter > Support Docker.

   

6. Choisissez le nom et le type de conteneur, puis cliquez sur Ok.

   

Maintenant que le projet nouvellement créé est ajouté au conteneur Docker, les commandes Docker Compose peuvent l'exécuter. Ci-dessous se trouve un exemple de sortie générée à partir du code côté client React JS.

Ci-dessous se trouve le code côté serveur API s'exécutant depuis le conteneur Docker.

IronSecureDoc

IronSecureDoc permet aux développeurs d'intégrer efficacement le traitement sécurisé des documents dans des applications conteneurisées. Avec le support de Docker, encapsulez votre application ASP.NET Core en utilisant IronSecureDoc, encourageant un déploiement fluide et une scalabilité. Construisez un Dockerfile pour intégrer IronSecureDoc à votre application ASP.NET Core, ainsi que les scripts ou configurations nécessaires.

De plus, un fichier docker-compose.yml peut définir les dépendances de service et les variables d'environnement pour un accès facile, aidant à gérer efficacement les tâches de sécurité des documents dans différents environnements de déploiement. S'assurer de l'installation et de la configuration d'IronSecureDoc, comme Docker, est essentiel pour fournir des fonctionnalités telles que le chiffrement et l'obscurcissement de documents.

Installer et exécuter IronSecureDoc

Récupérez l'image Docker d'IronSecureDoc avec cette commande :

docker pull ironsoftwareofficial/ironsecuredoc

docker pull ironsoftwareofficial/ironsecuredoc

Après avoir tiré l'image, utilisez la commande suivante pour lancer IronSecureDoc dans un nouveau conteneur :

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

Utiliser IronSecureDoc avec un conteneur Docker

L'API REST d'IronSecureDoc permet des opérations sur les documents telles que l'obscurcissement, la certification et le chiffrement une fois installé et exécuté dans Docker. Pour plus d'informations sur les points d'accès API, consultez la documentation.

Pour chiffrer un document, envoyez une requête POST à l'API IronSecureDoc :

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'

Cette commande soumet le document à IronSecureDoc pour le chiffrement.

Conclusion

L'intégration de Docker Compose avec IronSecureDoc améliore grandement l'efficacité et la fiabilité des applications nécessitant une gestion sécurisée des documents. Docker Compose gère efficacement les applications multi-conteneurs, rationalisant les dépendances et la coordination des services, y compris IronSecureDoc, ce qui garantit la cohérence de l'environnement de développement, simplifie les configurations et augmente la scalabilité.

Dans cette configuration, les développeurs peuvent pleinement tirer parti des fonctionnalités de sécurité des documents, telles que le chiffrement et l'obscurcissement, dans un cadre conteneurisé. Dans l'ensemble, combiner Docker Compose avec IronSecureDoc enrichit le processus de développement, offrant une méthode sécurisée et efficace pour gérer les documents sensibles dans les applications modernes. Pour des informations sur la licence IronSecureDoc, visitez cette page. Cliquez ici pour explorer plus de produits Iron Software.