1. IronSecureDoc
  2. Blog IronSecureDoc
  3. Uso de IronSecureDoc
  4. Docker de Graylog
USO DE IRONSECUREDOC

Graylog Docker (Cómo funciona para los desarrolladores en la seguridad de PDF)

Publicado en 5 de marzo, 2025
Compartir:

¿Qué es Graylog Docker?

Grayloges una herramienta de código abierto para la gestión y análisis de registros. Es posible el registro centralizado, incluyendo el enriquecimiento de datos y la presentación de información en tiempo real sobre los sistemas de TI. La imagen de Docker de Graylog facilita el despliegue de Graylog en entornos de contenedores con la ayuda de Docker. Esto simplifica la configuración y el escalado, haciendo que la herramienta sea más popular para los entornos modernos.microserviciosarquitecturas basadas en la gestión de registros.

Imagen rota Añadir desde Pixabay, seleccionar de tus archivos o arrastrar y soltar una imagen aquí.

Generalmente, la imagen de Docker de Graylog se utiliza con otros contenedores, como Elasticsearch, que tendrá el registro y realizará la funcionalidad de búsqueda, y MongoDB, que almacena metadatos. Como Docker Compose, todos estos componentes pueden orquestarse para crear una pila de registro completa. Graylog puede usar múltiples protocolos, como Syslog, GELF(Formato Extendido de Registro de Graylog), y Beats, para ingerir datos de registro desde servidores, aplicaciones, dispositivos de red y plataformas en la nube.

Requisito de Docker de GrayLog

Además, para usar Graylog Docker, necesitamos las siguientes imágenes de Docker en el directorio de configuración.

  • MongoDB

    OpenSearch

  • Graylog

¿Qué es MongoDB Docker?

MongoDB Docker es una base de datos NoSQL de MongoDB, principalmente para datos no estructurados, ofrecida a los clientes como una solución ligera y escalable de instancias de MongoDB portadas sobre Docker. Graylog necesita algunos metadatos en forma de archivos de configuración predeterminados, datos de usuario, variables de entorno y otros datos importantes, que son cruciales para ejecutarlo con éxito, por lo que entra en juego MongoDB, que contiene todos los metadatos necesarios. Usar MongoDB en un contenedor de Docker puede facilitar la configuración, asegurar que los entornos de desarrollo y producción sean consistentes, y escalar y gestionar aplicaciones más fácilmente.

¿Qué es OpenSearch Docker?

OpenSearch, un motor de búsqueda y análisis distribuido también basado en Elasticsearch, es, de hecho, una versión en contenedor de OpenSearch Docker. OpenSearch es un índice para indexar, almacenar y buscar datos de registro en configuraciones de Docker de Graylog. Es el componente principal que permite a Graylog ingerir, consultar y analizar registros de manera eficiente.

Cuando OpenSearch se integra en un entorno Docker para Graylog, funciona bastante bien con el servidor de Graylog, manejando grandes volúmenes de transformación de datos de registro y capacidades de búsqueda rápida. OpenSearch Docker simplifica el despliegue y la gestión del back-end al ejecutar un motor de búsqueda dentro de un contenedor, ofreciendo portabilidad, escalabilidad y facilidad de configuración.

Instalar Graylog y otro componente de Docker

Crear un archivo docker-compose utilizando el siguiente código, que ayuda a almacenar datos de configuración. Y nombrarlo 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

Este archivo de configuración de Docker Compose configurará un paquete de solución de registro centralizado con tres servicios principales: MongoDB, OpenSearch y Graylog. Estos servicios están interconectados a través de una red de puente compartida llamada Graylog.

MongoDB se utiliza aquí con la imagen mongo:6.0.18 como el almacén de metadatos; se mantiene los datos en el volumen mongodb_data y expone el puerto 27017. OpenSearch utiliza la imagen opensearchproject/opensearch:2.15.0, un motor de indexación y almacenamiento de registros; las variables de entorno configuran la aplicación como una instalación de un solo nodo con plugins de seguridad deshabilitados para desarrollo, optimizaciones de memoria, protección de contraseñas, con los datos persistiendo en el volumen OpenSearch y exponiendo los puertos 9203 y 9303.

La configuración de Graylog se ejecuta en la imagen Graylog/Graylog-enterprise:6.0 como se menciona en el archivo Docker Compose anterior. Se utiliza aquí como una interfaz central de registros. Para funcionar, se requieren MongoDB y OpenSearch. Estos se usan para configurar un nodo, cifrar contraseñas y crear un URI externo. Graylog abre varios puertos, como el 9000, para la interfaz web y otros protocolos relacionados con la ingesta de registros. Al hacerlo, persiste los datos, configuraciones, archivos predeterminados y el diario en volúmenes correspondientes. Esto asegura que los contenedores se reinicien en caso de fallo y es el corazón de un ecosistema de registro confiable.

Ejecute la composición usando el comando up para descargar todas las imágenes y crear el contenedor:

docker-compose up

Graylog Docker(Cómo funciona para desarrolladores para la seguridad PDF): Figura 2 - Docker Compose

Una vez que la instalación se haya completado, ahora podemos iniciar sesión utilizando la URL http://localhost:9000/ con las credenciales predeterminadas.

Graylog Docker(Cómo funciona para desarrolladores en la seguridad de PDF): Figura 3 - Inicio de sesión en Graylog

A continuación se muestra la página del panel de control de Graylog una vez iniciada la sesión.

Imagen rota Añadir desde Pixabay, seleccionar de tus archivos o arrastrar y soltar una imagen aquí.

¿Qué es IronSecureDoc?

IronSecureDoces una herramienta de gestión y seguridad de documentos que utiliza cifrado avanzado, manipulación compleja de PDF y firma digital. Ofrece a las empresas y desarrolladores un acceso fluido y permite un procesamiento más fácil de documentos PDF sin dependencias directas o indirectas. Si sus características permiten a los desarrolladores crear, cargar, manipular y asegurar automáticamente archivos y documentos PDF de manera programática, se puede considerar como una API de PDF agresiva.

Graylog Docker(Cómo funciona para los desarrolladores en seguridad de PDF): Figura 5 - IronSecureDoc: El servidor de seguridad y cumplimiento de PDF

IronPDF es una API de PDF que permite crear PDFs a partir de cualquier tipo de entrada de datos y agregar o editar contenido mediante parámetros como texto, imágenes o metadatos. También incorpora funcionalidades para fusionar varios PDFs, crear archivos compuestos, dividir documentos e incluso agregar comentarios, resaltados o marcas de agua para anotaciones.

Instalar IronSecureDoc

Puedes extraer la imagen Docker de IronSecureDoc utilizando el siguiente comando en el símbolo del sistema o en una ventana de terminal abierta, basándote en el repositorio que se proporciona a continuación.

docker pull ironsoftwareofficial/ironsecuredoc

Graylog Docker(Cómo funciona para desarrolladores para la seguridad de PDF): Figura 6 - IronSecureDoc

Ejecute IronSecureDoc con 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

Este comando de Docker lanza un contenedor desde la imagen ironsoftwareofficial/ironsecuredoc:latest con la ayuda del controlador de registro GELF en modo interactivo y separado.(-dit)y reenvía los registros del contenedor al servidor Graylog que está escuchando en udp://127.0.0.1:12201. Cuando termina, la bandera --rm hace que ese contenedor se elimine automáticamente.

Dado que el contenedor asigna el puerto 8080 en el host al puerto 8080 dentro del contenedor(-p 8080:8080), la aplicación puede ser accedida localmente en el puerto designado. Se establecen dos variables de entorno: HTTP_PORTS=8080, que es la configuración del puerto HTTP del contenedor, y ENVIRONMENT=Development, que es el entorno de desarrollo. En un entorno de desarrollo, esta configuración permite una gestión efectiva de registros utilizando Graylog mientras se ejecuta una aplicación web accesible en el puerto 8080.

Docker de Graylog (Cómo funciona para desarrolladores para la seguridad de PDF): Figura 7 - Contenedor de Docker

Registro en Graylog usando IronSecureDoc

Para integrar los datos de registro reales de IronSecureDoc en Graylog utilizando la función del Sistema/Entrada, siga estos pasos:

  • En la barra lateral izquierda, haz clic en Sistema > Entradas.

  • En Tipo de entrada, haz clic en GELF UDP o GELF TCP si se prefiere TCP. Haga clic en Lanzar nueva entrada.

    Configurar la entrada:

  • Título: Dale un buen nombre descriptivo, como IronSecureDoc Logs.
  • Dirección de enlace: Agrega 0.0.0.0 para recibir registros de cualquier IP o usa 127.0.0.1 para registros locales.
  • Puerto: Seleccione 12201 como el puerto GELF por defecto.

  • Guardar: Luego lanzar para habilitar la entrada.

    Graylog Docker(Cómo funciona para desarrolladores para la seguridad de PDF): Figura 8 - Graylog con IronSecureDoc

    Si IronSecureDoc tiene una interfaz web, abre la dirección IP del servidor en tu navegador con el puerto especificado, por ejemplo, http://:8080. Completa cualquier configuración inicial requerida para la aplicación.

    A continuación se muestra la interfaz web y API REST de IronSecureDoc:

    Graylog Docker(Cómo funciona para desarrolladores para la seguridad de PDF): Figura 9 - IronSecureDoc Web Interface

Encripta PDF usando IronSecureDoc

Utilice una herramienta como Curl o Postman para enviar una solicitud de cifrado a la API de IronSecureDoc. Por ejemplo:

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'

Esto se publicaría en elIronSecureDoc APIy es posible que incluso queramos solicitar una contraseña de permisos para encriptar una solicitud con una contraseña de usuario a un documento.

La acción anterior se registrará en todas las acciones de contenedores ironsecuredoc. Y crea métricas.

Graylog Docker(Cómo funciona para desarrolladores en Seguridad de PDF): Figura 10 - Encriptar PDF

Conclusión

Esta integración con Graylog le ofrece una potente solución de registro y monitoreo que permite la gestión centralizada y proporciona una visión en tiempo real de las actividades de cifrado y el comportamiento de la aplicación. Puede beneficiarse de las potentes capacidades de Graylog en búsqueda, alertas y visualización, lo que le permite rastrear los registros de IronSecureDoc de manera más eficiente, identificar problemas en tiempo real y garantizar un procesamiento de documentos fluido y seguro. La integración de IronSecureDoc con Graylog mejora la transparencia operativa, optimiza la resolución de problemas y fortalece la fiabilidad general del sistema, convirtiéndola en una adición esencial para una gestión de registros segura y eficiente.

Puede realizar una auditoría completa con máxima seguridad. Ahora, la impresión segura en formato PDF eficiente y el manejo de errores pueden integrarse fácilmente en las aplicaciones desarrolladas por desarrolladores de sistemas web, móviles y corporativos utilizando la API REST de IronSecureDoc. Para obtener información sobre la licencia de IronSecureDoc, por favor visite elpágina de licencias. Para obtener información detallada sobre la configuración de los productos de Iron Software, siga la suite de bibliotecaspágina.

Kannaopat Udonpant

Kannapat Udonpant

Ingeniero de software

 LinkedIn

Antes de convertirse en ingeniero de software, Kannapat realizó un doctorado en Recursos Medioambientales en la Universidad de Hokkaido (Japón). Mientras cursaba su licenciatura, Kannapat también se convirtió en miembro del Laboratorio de Robótica Vehicular, que forma parte del Departamento de Ingeniería de Bioproducción. En 2022, aprovechó sus conocimientos de C# para unirse al equipo de ingeniería de Iron Software, donde se centra en IronPDF. Kannapat valora su trabajo porque aprende directamente del desarrollador que escribe la mayor parte del código utilizado en IronPDF. Además del aprendizaje entre iguales, Kannapat disfruta del aspecto social de trabajar en Iron Software. Cuando no está escribiendo código o documentación, Kannapat suele jugar con su PS5 o volver a ver The Last of Us.
< ANTERIOR
Guacamole Docker (Cómo funciona para desarrolladores para la seguridad PDF)
SIGUIENTE >
immich Docker Compose (Cómo funciona para los desarrolladores)

docker pull ironsoftwareofficial/ironsecuredoc

Informar un Problema

¿Listo para empezar? Versión: 2024.10 acaba de salir

Descargar gratis
Empezar gratis
Descargar gratis Iniciar prueba gratuita
Ver licencias >