PACS and VIEW installation

If a PACS system is already present in your scenario, the PACS component can work as a temporary cache for VIEW.

Requirements

Server-side requirements

Operating system

The application can run on any 64-bit Linux OS compatible with Docker Engine.

The recommended Linux operating systems are:

Ubuntu 22.04 LTS or 24.04 LTS
RHEL-based OS

Minimal hardware requirements

Concurrent users	CPU cores*	RAM
10	6 cores	12 GB
20	10 cores	20 GB
50	18 cores	36 GB
50+	+1 core per 10 concurrent users	+4 GB per 10 concurrent users

* Equivalent of 7th generation Intel i5 2.4 GHz CPU core.

To ensure optimal perfomance, digital pathology projects require 1.5 CPU cores per concurrent user.

The hardware requirements above refer to a load of fewer than 150 exams per day (each containing 200 images). If the load is higher, more resources must be provided for the PACS.

The storage is used for software and temporary data cache. At least 50 GB of storage size is recommended.

Since the network bandwidth directly affects opening speed, we recommend at least 100 Mbit/s.

Client-side requirements

	Desktop Web HTML5
CPU	Intel i3 4 core CPU or better
RAM	8+ GB of RAM, 256+ MB of video memory
Storage space	10+ GB
Network bandwidth	100+ Mbit/s
Web Browsers	Google Chrome 112+**, Microsoft Edge 112+, Mozilla Firefox 112+, Safari 16+

** To reach the best performance we recommend the use of Google Chrome.

Installation

Installation prerequisites

The installation requires Docker Engine installed on the operating system. For instructions on how to install Docker Engine see the official website: Install Docker Engine.

Ensure to install all the packages, including docker-compose.

Installation procedure

Docker login

The ready-to-use Docker image of the system is available in the shared repository europe-west1-docker.pkg.dev/o3-cloud-internal/partner.

To authenticate to the repository, a Service account key will be provided via e-mail as a JSON file.

Copy the file on the target machine and execute the following command, by replacing the parameter KEY-FILE with the path to the provided JSON file:

CODE

cat {KEY-FILE} | sudo docker login -u _json_key --password-stdin europe-west1-docker.pkg.dev

Environment setup

After the Docker login, it's advisable to create an environment file and a docker-compose.yml file.

This facilitates easier control and deployment of the container. Alongside the YAML file, we recommend using an environment file to store variables that the docker-compose files will utilize. This approach allows for convenient modification of variable values in the environment file, which will automatically be reflected in the YAML files, as they can be configured to read from this environment file.

The environment file should be located in the same directory as the docker-compose.yml, and its name should start with a dot. Typically, we name it .env.

.env file

Below is an example of a .env file that can be used for PACS and VIEW installation. Please replace the value of the following variables with the appropriate one:

COMPOSE_FILE: specify which docker-compose files should be read from this environment file;
STORAGE: specify the path where the integrated storage will store all the DICOM files and images. Create the directory if it is not already present;
PATHDC: specify where the docker-compose.yml file and the .env file are located;
DB_IMAGE: specify the MySQL image to use. We also support MySQL 5.7, but we highly recommend using MySQL 8.0;
DB_PASSWORD: specify the password for the DB 'root' user;
TIMEZONE: specify the local timezone;
PACS_IMAGE: at the end of the line, instead of {X.Y.Z}, fill the designated PACS image;
VIEW_IMAGE: at the end of the line, instead of {X.Y.Z}, fill in the designated VIEW image.

System versions

The proper version of the PACS and VIEW images will be provided by your O3 Enterprise contact. Alternatively, it can be requested by contacting partner@o3enterprise.com.

CODE

## This is an example of the enviroment file to store all the variables used by the docker-compose.yml and the applications.
COMPOSE_FILE=docker-compose.yml     ## Specify which docker-compose files should be read from this environment file.
STORAGE={pathToStorage}            ## Path where the PACS system will store all the DICOM files and images. Create the directory if not already present.
PATHDC={pathToDocker-ComposeFiles}  ## Location of the docker-compose.yml and .env files.
DB_IMAGE=mysql:8.0.34               ## MySQL image to use. We support also MySQL 5.7, but we highly recommend using MySQL 8.0.
DB_PASSWORD={dbPassword}            ## Password for the DB 'root' user.
TIMEZONE={timezone}                 ## Local timezone.

PACS_IMAGE=europe-west1-docker.pkg.dev/o3-cloud-internal/partner/pacs-cloud:{X.Y.Z}  ## Replace {X.Y.Z} with the proper version of the PACS system.
VIEW_IMAGE=europe-west1-docker.pkg.dev/o3-cloud-internal/partner/view:{X.Y.Z}  ## Replace {X.Y.Z} with the proper version of the VIEW system.

## The next line is a configuration option for MySQL database. Here is possible to define preferences for the data storage.
VARMYSQL=--sql_mode="STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION,ALLOW_INVALID_DATES" --character_set_server=utf8 --collation_server=utf8_general_ci

## The lines below are the connection strings the applications will use to connect to the database ('db' is the name of the container defined in the YAML file).
NGV_CONNECTION_STRING=driverClassName=com.mysql.cj.jdbc.Driver;jdbcUrl=jdbc:mysql://db:3306/public_view;username=root;password=${DB_PASSWORD}  
DPACS_CONNECTION_STRING=driverClassName=com.mysql.cj.jdbc.Driver;jdbcUrl=jdbc:mysql://db:3306/;schema=public_pacs;username=root;password=${DB_PASSWORD}
ULTIMATE_CONNECTION_STRING=driverClassName=com.mysql.cj.jdbc.Driver;jdbcUrl=jdbc:mysql://db:3306;schema=public_pacs;username=root;password=${DB_PASSWORD}

docker-compose.yml file

Below is a ready-to-use example of a docker-compose.yml file that can be used for PACS and VIEW installation. In it, every value that begins with a $ represents a variable stored in the environment file (no modifications are necessary).

CODE

version: '3.2'
services:
  db:
    image: ${DB_IMAGE}
    container_name: db
    restart: always
    env_file:
      - .env
    volumes:
      - "${STORAGE}/compose/db:/var/lib/mysql:rw"
    environment:
      - "MYSQL_ROOT_PASSWORD=${DB_PASSWORD}"
      - TZ=${TIMEZONE}
    command: mysqld ${VARMYSQL}
    healthcheck:
        test: ["CMD", "mysql", "-h", "db", "-u", "root", "-p${DB_PASSWORD}"]
        interval: 2s
        timeout: 10s
        retries: 5
    ports:
      - "3306:3306"
    ulimits:
      nproc: 65535
      nofile:
        soft: 26677
        hard: 46677
    networks:
      - o3net
  
  pacs:
    image: ${PACS_IMAGE}
    container_name: pacs
    restart: always
    env_file:
      - .env
    volumes:
      - ${STORAGE}/compose/storage:/opt/storagePacs
      - ${STORAGE}/compose/pacs/log:/opt/ipm/log
      - ${STORAGE}/compose/pacs/shared-persist:/opt/ipm/shared-persist 
    environment:
      - LOG_TO=FILE
      - TZ=${TIMEZONE}
      - DPACS_CONNECTION_STRING=${DPACS_CONNECTION_STRING}
    depends_on:
      db:
        condition: service_healthy
    ports:
      - 8080:8080
      - 4568:4568
    networks:
      - o3net
      
      
  pacs-singleton:
    image: ${PACS_IMAGE}
    container_name: pacs-singleton
    restart: always
    env_file:
      - .env
    volumes:
      - ${STORAGE}/compose/storage:/opt/storagePacs
      - ${STORAGE}/compose/pacs/log:/opt/ipm/log
    environment:
      - LOG_TO=FILE
      - TZ=${TIMEZONE}
      - DPACS_CONNECTION_STRING=${DPACS_CONNECTION_STRING}
      - START_PERIODIC_SERVICES=true
    depends_on:
      db:
        condition: service_healthy
    networks:
      - o3net
  
  
  view:
    image: ${VIEW_IMAGE}
    container_name: view
    restart: always
    env_file:
      - .env
    volumes:
      - ${STORAGE}/compose/storage:/opt/storagePacs
      - ${STORAGE}/compose/view/shared-persist:/opt/ipv/shared-persist
      - ${STORAGE}/compose/view/log:/opt/ipv/log
    environment:
      - TZ=${TIMEZONE}
      - LOG_TO=FILE
      - NGV_CONNECTION_STRING=${NGV_CONNECTION_STRING}
      - ULTIMATE_CONNECTION_STRING=${ULTIMATE_CONNECTION_STRING}
    depends_on:
      db:
        condition: service_healthy
    ports:
      - 8181:8181
    networks:
      - o3net
networks:
  o3net:
    driver: bridge
    ipam:
      driver: default
      config:
      - subnet: 172.16.1.0/24

Once both files are finalized and ready, execute the following command within the directory where these files are located to start the database container:

CODE

sudo docker compose up -d db

Once the image is pulled from the repository and the container is running, execute the command that creates the PACS and VIEW schemas:

CODE

sudo docker exec db mysql -u root -p${DB_PASSWORD} -e "create schema public_pacs";

CODE

sudo docker exec db mysql -u root -p${DB_PASSWORD} -e "create schema public_view";

If this process completes without any errors, the database should be ready for connections.

After the schema creation, it is possible to start all the other containers by executing the following command:

CODE

sudo docker compose up -d

Provided that all steps were executed correctly and the configuration is accurate, the containers should start, and the applications will run.

To access the applications' interface and configure the systems, see PACS configuration and VIEW configuration .

Logs

If the containers aren't active or if the application's interfaces are inaccessible, it indicates an issue has occurred.

To diagnose the problem, you can consult and analyze specific files found in the /{pathToStorage}/{view|pacs}/log directory, as defined in the volumes part of the YAML file.

Alternatively, the docker logs -f {view|pacs} command can be used to check the logs and gain insights into what might have gone wrong.

Updates

To update the application’s version simply substitute in the .env file the tag of the VIEW_IMAGE|PACS_IMAGE variable with the new one and execute the following command:

CODE

sudo docker compose up -d

Tip

To reduce the downtime of the application we suggest first pulling the image from the shared repository and then modifying the .env file.