qvera/qie repository overview

⁠Quick Reference

• Where to get help: Qvera Support Request⁠, Qvera Knowledge Base⁠, or the Qvera Customer Portal⁠

• Also published on: AWS ECR Public, public.ecr.aws/qvera/qie — the same images and tags

• Product page: Qvera Interface Engine⁠

⁠Before you start

QIE is commercial software, and three things are needed before a container is useful.

A database. This image ships no embedded database, so an external MariaDB, MySQL or Microsoft SQL Server must be reachable and its connection settings supplied at start. The MariaDB and MSSQL JDBC drivers are on the image; the MySQL driver is not, and must be mounted into /java/qie/jdbcDriver. See Where to Store Data below.

A license. Channels can be created without one, but cannot be started until the engine is licensed. Activation needs a QIE customer ID and password, which are issued by Qvera — contact us⁠ if you do not have them.

Outbound network access. QIE checks in nightly with the Qvera license servers and must be able to reach qvera.com and qiecheckin.com over HTTPS. Both are required. After eight consecutive failed check-ins running channels are stopped each morning, and after twenty-two they are stopped permanently.

The first run also creates or upgrades the database schema, which on a large database can take several minutes to hours. Allow for it in any health check or startup probe — see the start_period in the Compose example below.

⁠What is the Qvera Interface Engine (QIE)?

Qvera has built healthcare integration software since 2008. The Qvera Interface Engine (QIE)⁠ connects clinical, imaging and administrative systems for hospitals, health systems, imaging centers, and the software vendors who embed it in their own products.

One engine handles HL7 v2 and v3, FHIR, DICOM including native DIMSE, X12, NCPDP, ASTM, CDA and IHE profiles, over MLLP, REST, SFTP, file, database, message queue and SMB network share, so imaging and clinical interfaces run on one platform instead of separate tools.

Interfaces are scripted in JavaScript with a built-in Code Wizard, not a proprietary language, and you choose the database: MSSQL, MySQL or MariaDB. The Remote Management Hub monitors and controls QIE instances inside separate customer networks from one console. A built-in AI Companion helps your team build and troubleshoot interfaces.

QIE is in production today at more than 1,000 sites, running more than 25,000 interfaces and processing more than 50 million messages a day. SOC 2 Type 2 attested.

⁠How to use this image

⁠Start a QIE node instance

QIE needs a database connection supplied at start, so there is no single-argument run command. The Compose stack in the next section is the shortest complete working example; the settings it passes are documented individually under Where to Store Data below.

In its simplest form the container is started with:

    $ docker run -p 80:80 <database settings> qvera/qie:tag

... where tag is the tag specifying the QIE version you want. QIE can then be accessed via http://localhost⁠ or http://host-ip⁠ in a browser, and signed into with the default credentials admin / admin, which must be changed on first login.

An alternative listening port can be defined using the JETTY_PORT environment variable:

    $ docker run -p 8080:8080 -e JETTY_PORT=8080 qvera/qie:tag

To stop QIE, use the following command:

    $ docker stop -t 300 [CONTAINER...]

QIE needs up to five minutes to properly shutdown.

⁠... via docker stack⁠ deploy or docker-compose⁠

Example stack.yml for QIE running with MariaDB database:

version: "3.7"

services:
  qie:
    image: qvera/qie:latest
    restart: always
    ports:
      - "80:80"
    environment:
      JAVA_OPTIONS: -Xmx2048m
      connection_driver: org.mariadb.jdbc.Driver
      connection_url: jdbc:mariadb://db:3306/qie
      connection_username: root
      connection_password: root
      hibernate_dialect: com.qvera.qie.persistence.MariaDB114QieDialect
      qie_haEngine: EnterpriseHAServiceImpl
    stop_grace_period: 5m
    healthcheck:
      test: curl --fail -s http://localhost/qieStatus || exit 1
      interval: 10s
      timeout: 10s
      retries: 3
      start_period: "6h"
    depends_on:
      - db

  db:
    image: mariadb:11.4
    environment:
      MYSQL_ROOT_PASSWORD: root
    restart: always
    volumes:
      - init_data:/docker-entrypoint-initdb.d/
      - db_data:/var/lib/mysql:rw
    depends_on:
      - dbSetup

  dbSetup:
    image: alpine:latest
    command:
      - "/bin/sh"
      - "-c"
      - "echo \"create schema if not exists qie;\" > /init_script/schema.sql"
    volumes:
      - init_data:/init_script

volumes:
  init_data:
  db_data:

Run docker stack deploy -c stack.yml qie (or docker-compose -f stack.yml up), wait for it to initialize completely, and visit http://swarm-ip:80⁠, http://localhost:80⁠, or http://host-ip:80⁠ (as appropriate).

NOTE: The healthcheck has a delay of 6 hours to give the image time to update the schema on a large database in the event of an upgrade.

NOTE2: The dbSetup image is to create a 'schema.sql' script that will create the QIE schema in the new MariaDB database.

⁠Passing Java Options to QIE

Java VM Options can be passed to QIE via the JAVA_OPTIONS environment variable:

    $ docker run -p 80:80 \
       -e "JAVA_OPTIONS=-Xmx2048m -XX:+HeapDumpOnOutOfMemoryError" \
       -e connection_driver=org.mariadb.jdbc.Driver \
       -e connection_url=jdbc:mariadb://127.0.0.1:3306/qie \
       -e connection_username=root \
       -e connection_password=root \
       -e hibernate_dialect=com.qvera.qie.persistence.MariaDB114QieDialect \
        qvera/qie:tag

JVM specific options can be passed to the JVM via the JAVA_OPTIONS environment variable. Multiple options can be specified by separating each with a space. Additionally, QIE specific options can be added here, but it is cleaner to provide them through environment variables.

QIE specific Java Options can be provided via environment variables. Values that contain spaces need to be in double quotes.

⁠Where to Store Data

QIE can be configured to use MariaDB, MySQL or Microsoft SQL Server by specifying the database connection parameter to the database you want to connect to.

    $ docker run -p 80:80 \
       -e connection_driver=myConnectionDriver \
       -e connection_url=myConnectionUrl \
       -e connection_username=myConnectionUsername \
       -e connection_password=myConnectionPassword \
       -e hibernate_dialect=myHibernateDialect \
       -v /java/qie/jdbcDriver:/java/qie/jdbcDriver:rw \
       qvera/qie:tag

When running MySQL the JDBC driver needs to be added as a volume (QIE has the JDBC driver already on the image when running MariaDB or Microsoft SQL Server). Information on how to setup these databases to be used by QIE can be found in one of the following URLs:

MariaDB: https://www.qvera.com/kb/index.php/2442⁠

MySQL: https://www.qvera.com/kb/index.php/2501⁠

Microsoft SQL Server: https://www.qvera.com/kb/index.php/2503⁠

⁠Where to Store QIE Backups

QIE performs nightly backups of your system configuration. To retain backups when this container is stopped, add the following volume.

    $ docker run -p 80:80 \
        -v /java/qie/backup:/java/qie/backup:rw \
        qvera/qie:tag

Additionally, QIE provides the ability to backup to an alternative location. This is defined under System Configuration -> System Configuration Nightly Backup -> Alternate Path. If you are using this feature, a volume will need to be added for this as well.

⁠Where to Store QIE Logs

QIE logs to both STDOUT and to files. If you want to retain logs when this container is stopped, the following volume will need to be added.

    $ docker run -p 80:80 \
        -v /java/qie/logs:/java/qie/logs:rw \
        qvera/qie:tag

⁠External Libraries

JAR files can be added and then used in QIE. All external JAR files must be stored in the /java/qie/lib folder.

Individual JAR files can be added as a volume. Adding the VTD library to QIE can be done with the following:

    $ docker run -p 80:80 \
        -v ./vtd-xml-qvera-2.11.3.jar:/java/qie/lib/vtd-xml-qvera-2.11.3.jar:ro \
        qvera/qie:tag

For multiple libraries, a lib directory containing all external JAR files can be used instead of having to specify each individual JAR file. This folder can contain individual JAR files, or folders that contain JAR files.

    $ docker run -p 80:80 \
        -v /java/qie/lib:/java/qie/lib:ro \
        qvera/qie:tag

⁠High Availability

To allow QIE to run in a clustered environment, the database you are using must have In-Memory tables setup. These tables are automatically setup when running with a MySQL or MariaDB database, but if you are running with a Microsoft SQL Server database, the In-Memory tables need to be setup by following the instructions here⁠. After they are setup, the following environment variable needs to be provided to the QIE container.

    $ docker run -p 80:80 \
        -e qie_haEngine=EnterpriseHAServiceImpl \
        qvera/qie:tag

When upgrading a QIE cluster with a new build of QIE, all containers need to be updated at the same time.