Altair EEvision™

Installation in a Docker

A Linux Docker image (as explained in this document) can simplify the deployment of EEvision installations. This document explains how to build a Docker image from the provided scripts and configuration files. The Docker image will contain a readily configured Apache web server together with the EEvision CGI extensions.

Licensing Options

Altair License Checker: The new EEvision packages come with Altair License Units. They require an Altair License Manager to run; please check out the corresponding Altair License documentation. The "guard" process in the srv directory usually needs the environment variable ALTAIR_LICENSE_PATH pointing to the Altair License Server. Each interactive EEvision session requires Altair License Units for the life-time of the session (which is the time, the Browser tab with main.html is open).
FlexNet License Checker: Each interactive EEvision session requires a FlexNet floating license for the life-time of the session (which is the time during which the Browser tab with main.html is open). This requires a FlexNet license server and a floating license key. For FlexNet-related installation – especially how to install FlexNet-based license keys – please check The FlexNet Installation Guide.
Altair Engineering's Customer-specific Call-home License Checker: Certain EEvision customers may get access to https://io.concept.de/eevlic/ for call-home license keys. For that purpose, customers need login credentials that are manually issued by Altair Engineering. For this approach, the eev.conf's "license" entry must define "https://io.concept.de/eevlic/eevlic.cgi" (the URL path to Altair Engineering's call-home license checker).

Creating the EEvision Docker Image

For licensing reasons, Altair Engineering cannot ship a readily built Docker image. Instead, all required files for creating the Docker image in the customer's environment are provided in the "docker" folder:

Dockerfile – the instructions for creating the image,
httpd.conf, httpd-ssl.conf, and htaccess.txt – configuration files for the Apache web server
start.sh – the start-up script for running the Apache web server within the Docker container.
create_docker.sh – a shell script that executes the necessary commands to create the Docker image.

Modifying these files should not be necessary. To create the Docker image, the shell script create_docker.sh needs to be executed in the sub-directory docker/ of EEvision's release package.

Afterwards the list of images (execute “docker image ls”) should contain an image with the name altair/eevision:. The next section explains how to run this image.

Running the EEvision Docker Image

We now describe the necessary configuration for deploying the EEvision Docker image. This mainly affects environment variables and mounted directories.

Environment Variables

Configuration information is passed to the Docker container via environment variables. They have to be specified when deploying the container. The following variables are needed:

LM_LICENSE_FILE
This environment variable should point to the address of the FlexNet license server. In our environment, the value is
```
LM_LICENSE_FILE=1700@license.company.org
```
LM_LICENSE_FILE may be set to an arbitrary value, if the call-home license checker is used instead of a FlexNet license server.
SERVER_NAME
The environment variable SERVER_NAME stores the name of the server. This server name must be consistent with the SSL certificate, which is used for encrypted https connections. In our test environment, we have
```
SERVER_NAME=eevision.company.org
```
SERVER_ADMIN
This variable stores the e-mail address of the server administrator who should be contacted in case of problems. In our test environment:
```
SERVER_ADMIN=admin@company.org
```

Persistent Directories

EEvision needs two mounted directories. The first one must contain the SSL certificates for the encryption of https connections, the second one stores the datasets.

SSL Certificate Files
- Directory (in the Docker): /usr/local/apache2/certs
- Required files: server.crt, server.key (SSL Certificates)
Data directory (for storing the loaded datasets)
- Directory (in the Docker): /usr/local/apache2/htdocs/eevision/data
- Required files: – none –
- Optional files: eev.conf
If an EEvision configuration file named eev.conf is provided in the data directory, it is used by EEvision instead of the provided default file. Configuration changes require a restart of the Docker image.

Using the `docker` daemon

The EEvision image can be run using the docker executable, for example, by adapting and running the following shell script. Please modify the lines 3–8 as needed.

    #!/usr/bin/sh

    VERSION=
    CERT_DIR=<Path to the certificate directory>
    DATA_DIR=<Path to the data directory>
    LM_LICENSE_FILE=1700@license.company.org
    SERVER_NAME=eevision.company.org
    SERVER_ADMIN=admin@company.org
    
    docker run \
        -p 443:443 \
        -p 80:80 \
        -v $CERT_DIR:/usr/local/apache2/certs \
        -v $DATA_DIR:/usr/local/apache2/htdocs/eevision/data \
        -e LM_LICENSE_FILE=$LM_LICENSE_FILE \
        -e SERVER_NAME=$SERVER_NAME \
        -e SERVER_ADMIN=$SERVER_ADMIN \
        --rm \
        --name eevision \
        altair/eevision:$VERSION

Using `docker-compose`

It is also possible to use docker-compose to start the EEvision server. The same information (environment variables, mounted directories) has to be provided by the administrator.

The docker-compose.yaml file looks as follows. It assumes that the following environment variables are set:

VERSION
CERT_DIR
DATA_DIR
LM_LICENSE_FILE
SERVER_NAME
SERVER_ADMIN

The values of the variables can also be provided in a file. Please consult the manual of docker-compose for details.

version: "3"
services:
  eevision:
    image: "altair/eevision:${VERSION}"
    ports:
      - 443:443
      - 80:80
    volumes:
      - ${CERT_DIR}:/usr/local/apache2/certs:ro
      - ${DATA_DIR}:/usr/local/apache2/htdocs/eevision/data
    environment:
      - LM_LICENSE_FILE=${LM_LICENSE_FILE}
      - SERVER_NAME=${SERVER_NAME}
      - SERVER_ADMIN=${SERVER_ADMIN}

The EEvision server can then be started by executing

docker-compose up

It makes EEvision available via port 80 (HTTP is redirected to HTTPS on the default port 443) and port 443 (via HTTPS).