1. IronSecureDoc
  2. IronSecureDoc Blog
  3. Utilisation d'IronSecureDoc
  4. Graylog Docker
UTILISATION D'IRONSECUREDOC

Graylog Docker (Comment cela fonctionne pour les développeurs en matière de sécurité des PDF)

Publié mars 5, 2025
Partager:

Qu'est-ce que Graylog Docker ?

Graylogest un outil open-source pour la gestion et l'analyse des journaux. La journalisation centralisée est possible, y compris l'enrichissement des données et la présentation de perspectives en temps réel dans les systèmes informatiques. L'image Docker de Graylog facilite le déploiement de Graylog dans des environnements containerisés grâce à Docker. Cela simplifie la configuration et la mise à l'échelle, rendant l'outil plus populaire pour le modernemicroservicesarchitectures basées sur la gestion des journaux.

Image cassée Ajouter depuis Pixabay, sélectionner depuis vos fichiers ou glisser-déposer une image ici.

Généralement, l'image Docker de Graylog est utilisée avec d'autres conteneurs, tels qu'Elasticsearch, qui contiendra le journal et exécutera la fonction de recherche, et MongoDB, qui stocke les métadonnées. Comme Docker Compose, tous ces composants peuvent être orchestrés pour créer une pile de journalisation complète. Graylog peut utiliser plusieurs protocoles, comme Syslog, GELF(Format de journal étendu Graylog)et Beats, pour ingérer des données de journal provenant de serveurs, d'applications, de dispositifs réseau et de plateformes cloud.

Exigence Docker GrayLog

De plus, pour utiliser Graylog Docker, nous avons besoin des images Docker suivantes dans le répertoire de configuration.

  • MongoDB

    OpenSearch

  • Graylog

Qu'est-ce que MongoDB Docker ?

MongoDB Docker est une base de données NoSQL par MongoDB, principalement dédiée aux données non structurées, fournie aux clients comme une solution allégée et évolutive de portage d'instances MongoDB sur Docker. Graylog nécessite des métadonnées sous forme de fichiers de configuration par défaut, de données utilisateur, de variables d'environnement et d'autres données importantes, qui sont cruciales pour son bon fonctionnement. MongoDB entre donc en jeu en contenant toutes les métadonnées requises. L'utilisation de MongoDB dans un conteneur Docker peut faciliter la configuration, garantir que les environnements de développement et de production sont cohérents, et permettre de mettre à l'échelle et de gérer plus facilement les applications.

Qu'est-ce qu'OpenSearch Docker ?

OpenSearch, un moteur de recherche et d'analyse distribué également basé sur Elasticsearch, est en fait une version conteneurisée d'OpenSearch Docker. OpenSearch est un index pour l'indexation, le stockage et la recherche de données de journal dans les configurations Docker de Graylog. C'est le composant principal permettant à Graylog d'ingérer, de requêter et d'analyser les journaux de manière efficace.

Lorsqu'OpenSearch est intégré dans un environnement Docker pour Graylog, il fonctionne très bien avec le serveur Graylog, gérant de forts volumes de transformation de données de journal et offrant des capacités de recherche rapide. OpenSearch Docker simplifie le déploiement et la gestion du back-end en exécutant un moteur de recherche à l'intérieur d'un conteneur, offrant portabilité, évolutivité et facilité de configuration.

Installer Graylog et d'autres composants Docker

Créez un fichier docker-compose en utilisant le code ci-dessous, qui aide à stocker les données de configuration. Et nommez-le docker-compose.yml.

version: '3'
services:
  # MongoDB: https://hub.docker.com/_/mongo/
  mongodb:
    image: "mongo:6.0.18"
    ports:
      - "27017:27017"   
    restart: "on-failure"
    networks:
      - graylog
    volumes:
      - "mongodb_data:/data/db"  
  opensearch:
    image: "opensearchproject/opensearch:2.15.0"
    environment:
      - "OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g"
      - "bootstrap.memory_lock=true"
      - "discovery.type=single-node"
      - "action.auto_create_index=false"
      - "plugins.security.ssl.http.enabled=false"
      - "plugins.security.disabled=true"
      # Can generate a password for `OPENSEARCH_INITIAL_ADMIN_PASSWORD` using a Linux device via:
      # tr -dc A-Z-a-z-0-9_@#%^-_=+ < /dev/urandom 
 head -c${1:-32}
      - "OPENSEARCH_INITIAL_ADMIN_PASSWORD=+_8r#wliY3Pv5-HMIf4qzXImYzZf-M=M"
    ulimits:
      memlock:
        hard: -1
        soft: -1
      nofile:
        soft: 65536
        hard: 65536
    ports:
      - "9203:9200"
      - "9303:9300"    
    restart: "on-failure"
    networks:
      - graylog
    volumes:
      - "opensearch:/usr/share/opensearch/data"  
  # Graylog: https://hub.docker.com/r/graylog/graylog/
  graylog:
    hostname: "server"
    image: "graylog/graylog-enterprise:6.0"
    # To install Graylog Open: "graylog/graylog:6.0"
    depends_on:
      mongodb:
        condition: "service_started"
      opensearch:
        condition: "service_started"
    entrypoint: "/usr/bin/tini -- wait-for-it opensearch:9200 -- /docker-entrypoint.sh"
    environment:
      GRAYLOG_NODE_ID_FILE: "/usr/share/graylog/data/config/node-id"
      GRAYLOG_HTTP_BIND_ADDRESS: "0.0.0.0:9000"
      GRAYLOG_ELASTICSEARCH_HOSTS: "http://opensearch:9200"
      GRAYLOG_MONGODB_URI: "mongodb://mongodb:27017/graylog"
      # To make reporting (headless_shell) work inside a Docker container
      GRAYLOG_REPORT_DISABLE_SANDBOX: "true"
      # CHANGE ME (must be at least 16 characters)!
      GRAYLOG_PASSWORD_SECRET: "somepasswordpepper"
      # Password: "admin"
      GRAYLOG_ROOT_PASSWORD_SHA2: "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918"
      GRAYLOG_HTTP_EXTERNAL_URI: "http://127.0.0.1:9000/"
    ports:
      # Graylog web interface and REST API
      - "9000:9000/tcp"
      # Beats
      - "5044:5044/tcp"
      # Syslog TCP
      - "5140:5140/tcp"
      # Syslog UDP
      - "5140:5140/udp"
      # GELF TCP
      - "12201:12201/tcp"
      # GELF UDP
      - "12201:12201/udp"
      # Forwarder data
      - "13301:13301/tcp"
      # Forwarder config
      - "13302:13302/tcp"
    restart: "on-failure"
    networks:
      - graylog
    volumes:
      - "graylog_data:/usr/share/graylog/data/data"
      - "graylog_config:/usr/share/graylog/data/config"
      - "graylog_journal:/usr/share/graylog/data/journal"  
networks:
  graylog:
    driver: "bridge"
volumes:
  mongodb_data:
  opensearch:
  graylog_data:
  graylog_config:
  graylog_journal:
version: '3'
services:
  # MongoDB: https://hub.docker.com/_/mongo/
  mongodb:
    image: "mongo:6.0.18"
    ports:
      - "27017:27017"   
    restart: "on-failure"
    networks:
      - graylog
    volumes:
      - "mongodb_data:/data/db"  
  opensearch:
    image: "opensearchproject/opensearch:2.15.0"
    environment:
      - "OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g"
      - "bootstrap.memory_lock=true"
      - "discovery.type=single-node"
      - "action.auto_create_index=false"
      - "plugins.security.ssl.http.enabled=false"
      - "plugins.security.disabled=true"
      # Can generate a password for `OPENSEARCH_INITIAL_ADMIN_PASSWORD` using a Linux device via:
      # tr -dc A-Z-a-z-0-9_@#%^-_=+ < /dev/urandom 
 head -c${1:-32}
      - "OPENSEARCH_INITIAL_ADMIN_PASSWORD=+_8r#wliY3Pv5-HMIf4qzXImYzZf-M=M"
    ulimits:
      memlock:
        hard: -1
        soft: -1
      nofile:
        soft: 65536
        hard: 65536
    ports:
      - "9203:9200"
      - "9303:9300"    
    restart: "on-failure"
    networks:
      - graylog
    volumes:
      - "opensearch:/usr/share/opensearch/data"  
  # Graylog: https://hub.docker.com/r/graylog/graylog/
  graylog:
    hostname: "server"
    image: "graylog/graylog-enterprise:6.0"
    # To install Graylog Open: "graylog/graylog:6.0"
    depends_on:
      mongodb:
        condition: "service_started"
      opensearch:
        condition: "service_started"
    entrypoint: "/usr/bin/tini -- wait-for-it opensearch:9200 -- /docker-entrypoint.sh"
    environment:
      GRAYLOG_NODE_ID_FILE: "/usr/share/graylog/data/config/node-id"
      GRAYLOG_HTTP_BIND_ADDRESS: "0.0.0.0:9000"
      GRAYLOG_ELASTICSEARCH_HOSTS: "http://opensearch:9200"
      GRAYLOG_MONGODB_URI: "mongodb://mongodb:27017/graylog"
      # To make reporting (headless_shell) work inside a Docker container
      GRAYLOG_REPORT_DISABLE_SANDBOX: "true"
      # CHANGE ME (must be at least 16 characters)!
      GRAYLOG_PASSWORD_SECRET: "somepasswordpepper"
      # Password: "admin"
      GRAYLOG_ROOT_PASSWORD_SHA2: "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918"
      GRAYLOG_HTTP_EXTERNAL_URI: "http://127.0.0.1:9000/"
    ports:
      # Graylog web interface and REST API
      - "9000:9000/tcp"
      # Beats
      - "5044:5044/tcp"
      # Syslog TCP
      - "5140:5140/tcp"
      # Syslog UDP
      - "5140:5140/udp"
      # GELF TCP
      - "12201:12201/tcp"
      # GELF UDP
      - "12201:12201/udp"
      # Forwarder data
      - "13301:13301/tcp"
      # Forwarder config
      - "13302:13302/tcp"
    restart: "on-failure"
    networks:
      - graylog
    volumes:
      - "graylog_data:/usr/share/graylog/data/data"
      - "graylog_config:/usr/share/graylog/data/config"
      - "graylog_journal:/usr/share/graylog/data/journal"  
networks:
  graylog:
    driver: "bridge"
volumes:
  mongodb_data:
  opensearch:
  graylog_data:
  graylog_config:
  graylog_journal:
Private version:
  #MongoDB: https: 'hub.docker.com/_/mongo/
	  #Can generate a password for `OPENSEARCH_INITIAL_ADMIN_PASSWORD` using a Linux device via:
	  #tr -dc A-Z-a-z-0-9_@#% Xor -_=+ < /dev/urandom
"3"c services: mongodb: image: "mongo:6.0.18" ports: - "27017:27017" restart: "on-failure" networks: - graylog volumes: - "mongodb_data:/data/db" opensearch: image: "opensearchproject/opensearch:2.15.0" environment: - "OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g" - "bootstrap.memory_lock=true" - "discovery.type=single-node" - "action.auto_create_index=false" - "plugins.security.ssl.http.enabled=false" - "plugins.security.disabled=true" head - ReadOnly Property c$() As
	1:-32
End Property
  #Graylog: https: 'hub.docker.com/r/graylog/graylog/
	#To install Graylog Open: "graylog/graylog:6.0"
	  #To make reporting (headless_shell) work inside a Docker container
	  #CHANGE ME (must be at least 16 characters)!
	  #Password: "admin"
	  #Graylog web interface and REST API
	  #Beats
	  #Syslog TCP
	  #Syslog UDP
	  #GELF TCP
	  #GELF UDP
	  #Forwarder data
	  #Forwarder config
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'- "OPENSEARCH_INITIAL_ADMIN_PASSWORD=+_8r#wliY3Pv5-HMIf4qzXImYzZf-M=M" ulimits: memlock: hard: -1 soft: -1 nofile: soft: 65536 hard: 65536 ports: - "9203:9200" - "9303:9300" restart: "on-failure" networks: - graylog volumes: - "opensearch:/usr/share/opensearch/data" graylog: hostname: "server" image: "graylog/graylog-enterprise:6.0" depends_on: mongodb: condition: "service_started" opensearch: condition: "service_started" entrypoint: "/usr/bin/tini -- wait-for-it opensearch:9200 -- /docker-entrypoint.sh" environment: GRAYLOG_NODE_ID_FILE: "/usr/share/graylog/data/config/node-id" GRAYLOG_HTTP_BIND_ADDRESS: "0.0.0.0:9000" GRAYLOG_ELASTICSEARCH_HOSTS: "http://opensearch:9200" GRAYLOG_MONGODB_URI: "mongodb://mongodb:27017/graylog" GRAYLOG_REPORT_DISABLE_SANDBOX: "true" GRAYLOG_PASSWORD_SECRET: "somepasswordpepper" GRAYLOG_ROOT_PASSWORD_SHA2: "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918" GRAYLOG_HTTP_EXTERNAL_URI: "http://127.0.0.1:9000/" ports: - "9000:9000/tcp" - "5044:5044/tcp" - "5140:5140/tcp" - "5140:5140/udp" - "12201:12201/tcp" - "12201:12201/udp" - "13301:13301/tcp" - "13302:13302/tcp" restart: "on-failure" networks: - graylog volumes: - "graylog_data:/usr/share/graylog/data/data" - "graylog_config:/usr/share/graylog/data/config" - "graylog_journal:/usr/share/graylog/data/journal" networks: graylog: driver: "bridge" volumes: mongodb_data: opensearch: graylog_data: graylog_config: graylog_journal:
$vbLabelText   $csharpLabel

Ce fichier de configuration Docker Compose configurera une pile de solution de journalisation centralisée avec trois services principaux : MongoDB, OpenSearch et Graylog. Ces services sont interconnectés via un réseau de pont partagé nommé Graylog.

MongoDB est utilisé ici avec l'image mongo:6.0.18 comme magasin de métadonnées ; il persiste les données dans le volume mongodb_data et expose le port 27017. OpenSearch utilise l'image opensearchproject/opensearch:2.15.0, un moteur d'indexation et de stockage de journaux ; les variables d'environnement configurent l'application en tant qu'installation monoposte avec les plugins de sécurité désactivés pour le développement, optimisations mémorielles, protection par mot de passe, avec les données persistantes dans le volume OpenSearch et exposant les ports 9203 et 9303.

La configuration de Graylog fonctionne sur l'image Graylog/Graylog-enterprise:6.0 comme mentionné dans le fichier Docker Compose ci-dessus. Il est utilisé ici comme interface centrale de journalisation. Pour fonctionner, MongoDB et OpenSearch sont nécessaires. Ceux-ci sont utilisés pour configurer un nœud, chiffrer les mots de passe et créer un URI externe. Graylog ouvre divers ports, comme le 9000, pour l'interface web et d'autres protocoles liés à l'ingestion de journaux. Ce faisant, il persiste les données, les configurations, les fichiers par défaut et le journal dans les volumes correspondants. Cela garantit le redémarrage des conteneurs en cas d'échec et constitue le cœur d'un écosystème de journalisation fiable.

Exécutez la composition en utilisant la commande up pour télécharger toutes les images et créer le conteneur :

docker-compose up

Graylog Docker(Comment cela fonctionne pour les développeurs pour la sécurité des PDF) : Figure 2 - Docker Compose

Une fois l'installation terminée, nous pouvons nous connecter en utilisant l'URL suivante http://localhost:9000/ avec les identifiants par défaut.

Graylog Docker(Comment cela fonctionne pour les développeurs pour la sécurité PDF) : Figure 3 - Connexion Graylog

Ci-dessous se trouve la page du tableau de bord de Graylog une fois connecté.

Image cassée Ajouter depuis Pixabay, sélectionner depuis vos fichiers ou glisser-déposer une image ici.

Qu'est-ce qu'IronSecureDoc ?

IronSecureDocest un outil utilitaire de gestion et de sécurité des documents qui utilise le chiffrement avancé, la manipulation complexe de PDF et la signature numérique. Il offre aux entreprises et aux développeurs un accès fluide et permet une gestion plus facile des documents PDF sans aucune dépendance directe ou indirecte. Si ses fonctionnalités permettent aux développeurs de créer, télécharger, manipuler et sécuriser automatiquement des fichiers et documents PDF de manière programmatique, on peut la qualifier d'API PDF agressive.

Graylog Docker(Comment cela fonctionne pour les développeurs en matière de sécurité PDF) : Figure 5 - IronSecureDoc : Le serveur de sécurité et de conformité PDF

IronPDF est une API PDF qui permet de créer des fichiers PDF à partir de tout type d'entrée de données et d'ajouter ou de modifier du contenu via des paramètres tels que le texte, les images ou les métadonnées. Il intègre également des fonctionnalités permettant de fusionner plusieurs PDF, de créer des fichiers composés, de diviser des documents et même d'ajouter des commentaires, des surlignements ou des filigranes pour les annotations.

Installer IronSecureDoc

Vous pouvez récupérer l'image Docker d'IronSecureDoc en utilisant la commande suivante dans l'invite de commande ou une fenêtre de terminal ouverte en fonction du dépôt indiqué ci-dessous.

docker pull ironsoftwareofficial/ironsecuredoc

Graylog Docker(Comment cela fonctionne pour les développeurs en matière de sécurité PDF) : Figure 6 - IronSecureDoc

Exécutez IronSecureDoc avec Graylog

docker container run -dit --log-driver=gelf --log-opt gelf-address=udp://127.0.0.1:12201 --rm -p 8080:8080 -e ENVIRONMENT=Development -e HTTP_PORTS=8080 ironsoftwareofficial/ironsecuredoc:latest

Cette commande Docker lance un conteneur à partir de l'image ironsoftwareofficial/ironsecuredoc:latest avec l'aide du pilote de journalisation GELF en mode interactif détaché.(-dit)et transfère les journaux de conteneurs au serveur Graylog qui écoute à l'adresse udp://127.0.0.1:12201. Lorsqu'il se termine, l'option --rm supprime automatiquement ce conteneur.

Étant donné que le conteneur associe le port 8080 de l'hôte au port 8080 à l'intérieur du conteneur(-p 8080:8080), l'application peut être accessible localement sur le port désigné. Deux variables d'environnement sont définies : HTTP_PORTS=8080, qui est la configuration du port HTTP du conteneur, et ENVIRONMENT=Development, qui est l'environnement de développement. Dans un environnement de développement, cette configuration permet une gestion efficace des journaux en utilisant Graylog tout en exécutant une application web accessible sur le port 8080.

Graylog Docker(Comment ça fonctionne pour les développeurs en matière de sécurité des PDF) : Figure 7 - Conteneur Docker

Connexion à Graylog en utilisant IronSecureDoc

Pour intégrer les données de journalisation réelles d'IronSecureDoc dans Graylog à l'aide de la fonctionnalité Système/Input, suivez ces étapes :

  • Dans la barre latérale gauche, cliquez sur Système > Entrées.

  • Sous Type d'entrée, cliquez sur GELF UDP ou GELF TCP si TCP est préféré. Cliquez sur Lancer une nouvelle entrée.

    Configurer l'entrée :

  • Titre : Donnez-lui un nom descriptif approprié, tel que IronSecureDoc Logs.
  • Adresse de liaison : Ajoutez 0.0.0.0 pour recevoir des journaux de n'importe quelle IP ou utilisez 127.0.0.1 pour les journaux locaux.
  • Port : Sélectionnez 12201 comme port GELF par défaut.

  • Enregistrer : puis lancer pour activer l'entrée.

    Graylog Docker(Comment ça fonctionne pour les développeurs pour la sécurité PDF) : Figure 8 - Graylog avec IronSecureDoc

    Si IronSecureDoc dispose d'une interface web, ouvrez l'adresse IP du serveur dans votre navigateur avec le port spécifié, par exemple, http://:8080. Complétez toute configuration initiale requise pour l'application.

    Ci-dessous l'interface web et l'API REST d'IronSecureDoc :

    Graylog Docker(Comment cela fonctionne pour les développeurs pour la sécurité des PDF) : Figure 9 - Interface Web IronSecureDoc

Chiffrer PDF en utilisant IronSecureDoc

Utilisez un outil comme Curl ou Postman pour envoyer une demande de cryptage à l'API IronSecureDoc. Par exemple :

curl -X 'POST' \
  'http://localhost:8080/encrypt?user_password=demo' \
  -H 'accept: */*' \
  -H 'Content-Type: multipart/form-data' \
  -F 'pdf_file=@test.pdf;type=application/pdf'

Cela publierait vers leIronSecureDoc API, et nous pourrions même vouloir demander un mot de passe d'autorisation pour chiffrer une requête avec un mot de passe utilisateur à un document.

L'action ci-dessus sera enregistrée dans toutes les actions du conteneur ironsecuredoc. Et il crée des métriques.

Graylog Docker(Comment cela fonctionne pour les développeurs pour la sécurité PDF): Figure 10 - Chiffrer le PDF

Conclusion

Cette intégration avec Graylog vous offre une solution puissante de journalisation et de surveillance qui permet une gestion centralisée et fournit une vision en temps réel des activités de cryptage et du comportement des applications. Il peut bénéficier des puissantes capacités de Graylog en matière de recherche, d'alerte et de visualisation, lui permettant de suivre les journaux IronSecureDoc plus efficacement, d'identifier les problèmes en temps réel et d'assurer un traitement fluide et sécurisé des documents. L'intégration de IronSecureDoc avec Graylog améliore la transparence opérationnelle, facilite le dépannage et renforce la fiabilité globale du système, en faisant un ajout essentiel pour une gestion des journaux sécurisée et efficace.

Il peut effectuer un audit complet avec une sécurité maximale. Désormais, l'impression sécurisée, le format PDF efficace et la gestion des erreurs peuvent être facilement intégrés dans les applications développées par les développeurs de systèmes web, mobiles et d'entreprise en utilisant l'API REST IronSecureDoc. Pour obtenir des informations sur la licence d'IronSecureDoc, veuillez visiter lepage d'autorisation. Pour des informations détaillées sur la configuration des produits d'Iron Software, veuillez suivre la suite de bibliothèquespage.

Kannaopat Udonpant

Kannapat Udonpant

Ingénieur logiciel

 LinkedIn

Avant de devenir ingénieur logiciel, Kannapat a obtenu un doctorat en ressources environnementales à l'université d'Hokkaido au Japon. Tout en poursuivant ses études, Kannapat est également devenu membre du Vehicle Robotics Laboratory, qui fait partie du Department of Bioproduction Engineering (département d'ingénierie de la bioproduction). En 2022, il a mis à profit ses compétences en C# pour rejoindre l'équipe d'ingénieurs d'Iron Software, où il se concentre sur IronPDF. Kannapat apprécie son travail car il apprend directement auprès du développeur qui écrit la majeure partie du code utilisé dans IronPDF. Outre l'apprentissage par les pairs, Kannapat apprécie l'aspect social du travail chez Iron Software. Lorsqu'il n'écrit pas de code ou de documentation, Kannapat peut généralement être trouvé en train de jouer sur sa PS5 ou de revoir The Last of Us.
< PRÉCÉDENT
Guacamole Docker (Comment ça fonctionne pour les développeurs pour la sécurité PDF)
SUIVANT >
immich Docker Compose (Comment cela fonctionne pour les développeurs)

docker pull irSoftwareofficial/ironSecureDoc

Signaler un problème

Prêt à commencer ? Version : 2024.10 vient de paraître

Téléchargement gratuit
Commencer gratuitement
Téléchargement gratuit Démarrer l'essai gratuit
Voir les licences > ;