Skip to content

OctoProctor system installation and upgrade Guide

1. System architecture

The architecture of the proctoring system is shown in the figure below.

Architecture diagram: application server connected to S3, MongoDB, recognition API, TURN server and users

The server part consists of the following components:

  • Application server — Node.js environment for launching server applications; a web server and the core of the proctoring system are launched in it.
  • DBMS server — MongoDB database management system server, you can use your own server or cloud service with API support for MongoDB.
  • File storage — AWS S3 compatible storage of downloaded files to the proctoring system; The bundled on-premise installation uses Silo, a community-maintained fork of the open-source MinIO server; you can also use your own S3-compatible server or a cloud service with a compatible API.
  • TURN server — a server to support the operation of the video communication module via WebRTC, you can use your own server (for example, coturn)
  • Face and Document Recognition API — facial recognition and document recognition software is part of the proctoring system.

Use the hardware calculator to calculate the computing power of the server based on the expected load.

The server part of the system requires an operating system (OS) based on a 64-bit Linux distribution. Ubuntu, Debian, CentOS or other similar distributions can be used. The proctoring system requires Docker software (software) or other environment to run Docker containers. However, you can use cloud services for DBMS server (MongoDB-compatible) and file storage (S3-compatible).

2. Running the system via Docker Compose

This is the preferred way to run the system on a single server.

2.1. Server preparation

This section of the instructions describes how to run all system components via Docker Compose (see Docker Compose installation instructions).

2.2. Preparing a configuration file

All settings for running proctoring components (containers) are written in the Docker Compose file (docker-compose.yml) and the environment variables file (.env). The script for launching containers is designed so that, for the specified domain (the DOMAIN_NAME variable), Certbot automatically issues an SSL certificate from Let's Encrypt for 90 days.

This is a typical docker-compose.yml file for running all containers:

services:
  node:
    depends_on:
      mongo:
        condition: service_healthy
      silo:
        condition: service_healthy
      recognizer:
        condition: service_healthy
    image: public.ecr.aws/s8z4o5f0/node:latest
    restart: always
    networks:
      - backend
    ports:
      - "0.0.0.0:80:80/tcp"
      - "0.0.0.0:443:443/tcp"
    volumes:
      - cert:/etc/letsencrypt
      - webroot:/var/www
    environment:
      DISTRIB_URL: ${DISTRIB_URL}
      DISTRIB_KEY: ${DISTRIB_KEY}
      MONGO_URI: mongodb://admin:${MONGO_SECRET:-secret}@mongo:27017/proctoring?authSource=admin
      S3_URI: http://minioadmin:${MINIO_SECRET:-minioadmin}@silo:9000/proctoring
      RECOGNIZER_URI: http://${RECOGNIZER_SECRET:-secret}@recognizer:8080/recognize
      TURN_URI: turn://webrtc:${TURN_SECRET:-webrtc}@${DOMAIN_NAME:-localhost}:3478?transport=udp+tcp
      SESSION_KEY: ${SESSION_KEY:-secret}
      #SSL_KEY: -----BEGIN RSA PRIVATE KEY-----\n...
      #SSL_CERT: -----BEGIN CERTIFICATE-----\n...
      SSL_KEY: /etc/letsencrypt/live/${DOMAIN_NAME:-localhost}/privkey.pem
      SSL_CERT: /etc/letsencrypt/live/${DOMAIN_NAME:-localhost}/cert.pem
      SSL_CA: /etc/letsencrypt/live/${DOMAIN_NAME:-localhost}/chain.pem
      PORT: 443
      HTTP_PORT: 80
      HTTP_WEBROOT: /var/www
      MANAGER_USERNAME: ${MANAGER_USERNAME:-manager}
      MANAGER_PASSWORD: ${MANAGER_PASSWORD:-ChangeMe12345}
      MANAGER_HOST: ${DOMAIN_NAME}
      PASSWORD_RULE: ${PASSWORD_RULE:-}
    healthcheck:
      test: [ "CMD", "curl", "-sS", "-m", "10", "http://127.0.0.1/ping" ]
  recognizer:
    image: public.ecr.aws/s8z4o5f0/recognizer:latest
    restart: always
    networks:
      - backend
    #ports:
    #  - "0.0.0.0:8080:8080/tcp"
    environment:
      PORT: 8080
      API_KEY: ${RECOGNIZER_SECRET:-secret}
    healthcheck:
      test: [ "CMD", "curl", "-sS", "-m", "10", "http://127.0.0.1:8080/ping" ]
  mongo:
    image: docker.io/library/mongo:8.0
    restart: always
    networks:
      - backend
    #ports:
    #  - "0.0.0.0:27017:27017/tcp"
    volumes:
      - db:/data/db
      - configdb:/data/configdb
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_SECRET:-secret}
    #command: mongod --replSet rs0 --keyFile /data/configdb/mongo.keyfile
    healthcheck:
      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
  silo:
    image: docker.io/pgsty/silo:latest
    restart: always
    networks:
      - backend
    #ports:
    #  - "0.0.0.0:9000:9000/tcp"
    #  - "0.0.0.0:9001:9001/tcp"
    volumes:
      - storage:/data
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: ${MINIO_SECRET:-minioadmin}
    command: server /data --address ":9000" --console-address ":9001"
    healthcheck:
      test: [ "CMD", "curl", "-sS", "-m", "10", "http://127.0.0.1:9000/minio/health/live" ]
  turn:
    image: coturn/coturn:latest
    restart: always
    network_mode: host
    volumes:
      - turn:/var/lib/coturn
    environment:
      REAL_EXTERNAL_IP: ""
    command: --no-cli --log-file=stdout --lt-cred-mech --fingerprint --max-allocate-timeout=60 --listening-port=3478 --min-port=49152 --max-port=65535 --realm=${DOMAIN_NAME:-localhost} --user=webrtc:${TURN_SECRET:-webrtc} --external-ip=$(detect-external-ip)
  certbot:
    image: certbot/certbot:latest
    network_mode: host
    depends_on:
      node:
        condition: service_healthy
    volumes:
      - cert:/etc/letsencrypt
      - webroot:/var/www
    command: certonly --agree-tos --keep-until-expiring --webroot --webroot-path=/var/www --email=admin@${DOMAIN_NAME:-localhost} --no-eff-email --domains=${DOMAIN_NAME:-localhost}
networks:
  backend:
volumes:
  db:
  configdb:
  storage:
  turn:
  cert:
  webroot:

The .env file contains environment variables in the format VARIABLE=VALUE, which are described in the table below:

Parameter Description
DISTRIB_URL Distribution archive URL (issued by supplier)
DISTRIB_KEY Distribution archive password (issued by supplier)
DOMAIN_NAME Server public domain
MONGO_SECRET MongoDB database password for admin
MINIO_SECRET Silo storage password
TURN_SECRET Password to connect to the TURN server
RECOGNIZER_SECRET Recognition API access key
SESSION_KEY Session secret key
MANAGER_USERNAME Manager username
MANAGER_PASSWORD Manager user password
PASSWORD_RULE '^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{12,}$'

WARNING: Environment variables MONGO_SECRET, MINIO_SECRET, TURN_SECRET and RECOGNIZER_SECRET must not contain special characters, only the following characters are allowed: a-zA-Z0-9

All user passwords must follow PASSWORD_RULE: at least 12 characters, including at least one uppercase letter, one lowercase letter, and one number.

2.3. Launching containers

You can create and run all containers at once with the following command from the directory where the docker-compose.yml file is located:

docker compose up -d

2.4. Stopping containers

You can stop and remove all containers at once with the following command from the directory where the docker-compose.yml file is located:

docker compose down

3. Running the system via Docker CLI

You can use this method to manage Docker containers more flexibly without using Docker Compose.

3.1. Server preparation

This section of the manual describes how to run all system components in Docker (see Docker installation instructions).

3.2. MongoDB server

3.2.1. Single server

Create a volume on the host where the database files will be stored:

docker volume create db
docker volume create configdb

Run container mongo:

docker run -d --name mongo --network host --restart always \
  -v db:/data/db \
  -v configdb:/data/configdb \
  -e "MONGO_INITDB_ROOT_USERNAME=admin" \
  -e "MONGO_INITDB_ROOT_PASSWORD=secret" \
  mongo:8.0

Environment variables (set in the -e parameter):

# database administrator login
MONGO_INITDB_ROOT_USERNAME=admin
# database administrator password
MONGO_INITDB_ROOT_PASSWORD=secret

DB connection string:

mongodb://admin:secret@127.0.0.1:27017/proctoring?authSource=admin

3.2.2. Cluster configuration

Create volumes on the host in which the database files and configs will be stored:

docker volume create db
docker volume create configdb

For MongoDB, the cluster configuration is configured using the Replica Set as one Primary node and one or more Secondary nodes. In order for the nodes of the MongoDB cluster to communicate with each other, the same key must be registered on all cluster nodes. You can generate a key with the command:

KEYFILE=/var/lib/docker/volumes/configdb/_data/mongo.keyfile
if [ ! -e "$KEYFILE" ]
then
  openssl rand -base64 756 | tee $KEYFILE
  chmod 400 $KEYFILE
fi

Run a "mongo" container on a replica named "rs0" on each host (for example, "mongodb01" and "mongodb02"):

docker run -d --name mongo --network host --restart always \
  -v db:/data/db \
  -v configdb:/data/configdb \
  -e "MONGO_INITDB_ROOT_USERNAME=admin" \
  -e "MONGO_INITDB_ROOT_PASSWORD=secret" \
  mongo:8.0 \
  mongod --replSet rs0 --keyFile /data/configdb/mongo.keyfile

Environment variables (set in the -e parameter):

# database administrator login
MONGO_INITDB_ROOT_USERNAME=admin
# database administrator password
MONGO_INITDB_ROOT_PASSWORD=secret

Command parameters:

# name of replica set
--replSet rs0
# path to the replica key file
--keyFile /data/configdb/mongo.keyfile

Initialize the cluster with the command:

docker exec -it mongo mongosh -u admin -p secret --authenticationDatabase admin

> rs.initiate(
  {
    _id: "rs0",
    version: 1,
    members: [
      { _id: 0, host: "mongodb01:27017" },
      { _id: 1, host: "mongodb02:27017" }
    ]
  }
)

DB connection string:

mongodb://admin:secret@mongodb01:27017,mongodb02:27017/proctoring?authSource=admin&replicaSet=rs0

3.3. File storage

3.3.1. Local storage Silo

Create a volume on the host where the repository files will be stored:

docker volume create storage

Run container minio:

docker run -d --name silo --network host --restart always \
  -v "storage:/data" \
  -e "MINIO_ROOT_USER=minioadmin" \
  -e "MINIO_ROOT_PASSWORD=minioadmin" \
  docker.io/pgsty/silo:latest \
  server /data --address ":9000" --console-address ":9001"

Environment variables (set in the -e parameter):

# login to access the storage
MINIO_ROOT_USER=minioadmin
# password to access the storage
MINIO_ROOT_PASSWORD=minioadmin

Command parameters:

# listening port
--address ":9000"
# port for console
--console-address ":9001"

Storage connection string:

http://minioadmin:minioadmin@127.0.0.1:9000/proctoring

3.3.2. Silo storage tiers

When storing large amounts of data, in some cases it may be worthwhile to configure two data storage tiers: "hot" storage and "cold" storage. This allows you to use a small amount of "hot" storage with fast disks to ensure correct operation of the system under heavy load, and store archived data in "cold" storage on slower and cheaper disks. At the same time, set up a rule for automatically moving data from "hot" storage to "cold" storage, for example, after 1 day, without losing access to this data through the proctoring system.

Below are step-by-step instructions on how to configure two Silo servers with automatic data transition according to the rule from one server to another:

  1. Launch two Silo servers. Let it be minio1 (port 9000, on fast disks) and minio2 (port 9100, on slow disks).
  2. Download Silo Client (mc).
  3. Configure mc to interact with the minio1 server:

    mc alias set minio1 http://127.0.0.1:9000 <user> <password>
    mc alias set minio2 http://127.0.0.1:9100 <user> <password>
    

    where <user> and <password> are storage access keys.

  4. Create buckets on both hot and cold storage:

    mc mb minio1/proctoring
    mc mb minio2/proctoring
    
  5. Create Lifecycle and Tier Management Policy:

    cat > lifecycle-policy.json << 'EOF'
     {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "s3:GetLifecycleConfiguration",
            "s3:PutLifecycleConfiguration",
            "s3:ListBucket"
          ],
          "Resource": ["arn:aws:s3:::proctoring"]
        },
        {
          "Effect": "Allow",
          "Action": [
            "admin:SetTier",
            "admin:ListTier"
          ],
          "Resource": ["arn:aws:s3:::proctoring"]
        }
      ]
    }
    EOF
    
  6. Configure Lifecycle and Tier Management Policy:

    mc admin policy create minio1 LifecycleAdminPolicy lifecycle-policy.json
    mc admin user add minio1 <minio1LifecycleAdmin> <LongRandomSecretKey>
    mc admin policy attach minio1 LifecycleAdminPolicy --user=minio1LifecycleAdmin
    

    where <minio1LifecycleAdmin> is the policy administrator login, <LongRandomSecretKey> is the policy administrator password.

  7. Configure remote storage tier:

    mc ilm tier add minio minio1 MINIO_COLD_TIER \
      --endpoint http://127.0.0.1:9100 \
      --access-key <user> \
      --secret-key <password> \
      --bucket proctoring \
      --storage-class STANDARD
    

    where <user> and <password> are access keys to the second MinIO server, proctoring is the name of the bucket, http://127.0.0.1:9100 is the address of the second MinIO server.

  8. Create and apply the transition rule (1 day after files are uploaded) with the name "MINIO_COLD_TIER":

    mc ilm rule add minio1/proctoring \
      --transition-tier MINIO_COLD_TIER \
      --transition-days 1 \
      --noncurrent-transition-tier MINIO_COLD_TIER \
      --noncurrent-transition-days 1
    
  9. Check the transition rule:

    mc ilm rule ls minio1/proctoring --transition
    

You can read more about setting up storage levels and transfer rules in the official Silo documentation.

3.3.3. Amazon S3

You can use Amazon S3 as storage, you don't need to install anything extra for this. Storage connection string ("proctoring" bucket):

https://access_key_id:secret_key@s3.eu-west-1.amazonaws.com/proctoring?region=eu-west-1

NOTE:

  • eu-west-1 should be your S3 region that you really use;
  • access_key_id and secret_key can only be uppercase or lowercase Latin characters and numbers, if not regenerate it;
  • proctoring is a bucket name in S3 that must be created before.

3.4. Face and Document Recognition API

Run container recognizer:

docker run -d --name recognizer \
  --network host --restart always \
  -e "API_KEY=secret" \
  public.ecr.aws/s8z4o5f0/recognizer:latest

Environment variables (set in the -e parameter):

# server IP
HOST=0.0.0.0
# server port
PORT=8080
# number of workers (auto if not set)
THREADS=4
# API access key
API_KEY=secret
# flag for rebuilding if the processor
# does not support AVX instructions
DLIB_REBUILD=1

Recognition API connection string:

http://secret@127.0.0.1:8080/recognize

Recognition API connection string for multiple servers (for example "recognizer01" and "recognizer02"):

http://secret@recognizer01:8080,recognizer02:8080/recognize

3.5. TURN server

Run container turn:

docker run -d --name turn --network host --restart always \
  coturn/coturn:latest \
  --no-cli --log-file=stdout --lt-cred-mech --fingerprint \
  --max-allocate-timeout=60 --listening-port=3478 --min-port=49152 --max-port=65535 \
  --user=webrtc:webrtc --realm=proctoring --external-ip='$(detect-external-ip)'

Ports used (should be available from clients):

  • 3478/tcp
  • 3478/udp
  • 49152-65535/udp (optional)

Command parameters:

# TURN server port
--listening-port=3478
# range of UDP ports
--min-port=49152
--max-port=65535
# user credentials as <username>:<password>
--user=webrtc:webrtc
# external IP address (or determine automatically)
--external-ip='$(detect-external-ip)'

TURN connection string:

turn://webrtc:webrtc@<external-ip>:3478?transport=tcp+udp

where <external-ip> is the external IP address of TURN server, if there are several servers, their addresses should be separated by comma; webrtc:webrtc is the default username and password to connect to TURN; 3478 is the port of TURN server; transport is the used transport tcp or udp, tcp+udp indicates the need to use both transports.

To check the operation of the TURN server in the browser we can use the Trickle ICE page. To do this you need to enter the connection parameters to the server on this page:

  • TURN URI: turn:<external-ip>:3478?transport=udp
  • TURN username: webrtc
  • TURN password: webrtc

Then click on "Add Server" and "Gather candidates". As a result, the table on this page should list the following connection types in the "Component Type" field:

  • host — client's local IP address;
  • srflx — external IP address of the client;
  • relay — external IP address of the TURN server, must match <external-ip>.

If at least one type is not on the list, the access to the TURN server is configured incorrectly. Check if the connections are not blocked by the firewall or intermediate routers in the network.

If the TURN check fails, then the reason may be blocking UDP traffic between the client and the server. You can check the transmission of UDP traffic between clients and the server on a specific port using the following commands:

Server

nc -u -l -p <udp-port>

Client

echo -n "ping" | nc -u -w 5 <external-ip> <udp-port>

3.6. Application server

3.6.1. Let's Encrypt SSL certificate

The system requires a valid SSL certificate for the domain. You can issue a free Let's Encrypt SSL certificate valid for 3 months. To do this, just use the Certbot tool:

docker volume create cert
docker volume create webroot
docker run --network host \
  -v "cert:/etc/letsencrypt" \
  -v "webroot:/var/www" \
  certbot/certbot:latest \
  certonly --agree-tos --keep-until-expiring \
  --webroot --webroot-path=/var/www \
  --email=admin@<your-domain> --no-eff-email \
  --domains=<your-domain>

After successful execution of the command, the certificate will be available in the /etc/letsencrypt/live/<your-domain>/ directory:

  • certificate: cert.pem
  • chain: chain.pem
  • private key: privkey.pem

In this example, Certbot uses a webroot directory to share the files required for the HTTP challenge. This means that you need to start the application server first. Alternatively, you can run Certbot in standalone mode (use --standalone parameter instead of --webroot), which runs an internal web server.

3.6.2. Running instance

The application server instance must be bound to a single domain, and a license will be issued for that domain. The application server can be run on one node or multiple nodes (horizontal scaling). When running the application server on multiple nodes, all instances must have the same parameters specified in the environment variables.

Start the container node:

docker run -d --name node --network host --restart always \
  --tmpfs /tmp \
  -v "cert:/etc/letsencrypt" \
  -v "webroot:/var/www" \
  -e "DISTRIB_URL=https://files.proctoring.app/dist/proctoring-vXYZ.zip" \
  -e "DISTRIB_KEY=secret" \
  -e "MONGO_URI=mongodb://admin:secret@127.0.0.1:27017/proctoring?authSource=admin" \
  -e "S3_URI=http://minioadmin:minioadmin@127.0.0.1:9000/proctoring" \
  -e "RECOGNIZER_URI=http://secret@127.0.0.1:8080/recognize" \
  -e "TURN_URI=turn://webrtc:webrtc@<external-ip>:3478?transport=tcp+udp" \
  -e "SESSION_KEY=secret" \
  -e "SSL_KEY=/etc/letsencrypt/live/<your-domain>/privkey.pem" \
  -e "SSL_CERT=/etc/letsencrypt/live/<your-domain>/cert.pem" \
  -e "SSL_CA=/etc/letsencrypt/live/<your-domain>/chain.pem" \
  -e "PORT=443" \
  -e "HTTP_PORT=80" \
  -e "HTTP_WEBROOT=/var/www" \
  -e "MANAGER_USERNAME=manager" \
  -e "MANAGER_PASSWORD=ChangeMe12345" \
  -e "MANAGER_HOST=<your-domain>" \
  public.ecr.aws/s8z4o5f0/node:latest

Environment variables (set in the -e parameter):

# proctoring system distribution kit URL
DISTRIB_URL=https://files.proctoring.app/dist/proctoring-vX_Y_Z.zip
# distribution kit password (issued separately)
DISTRIB_KEY=secret
# server IP
HOST=0.0.0.0
# server port
PORT=443
# port forwarding from http to https
HTTP_PORT=80
# server response timeout
HTTP_TIMEOUT=60
# directory for /.well-known/acme-challenge
HTTP_WEBROOT=/var/www
# number of threads, by default equal to the number of vCPUs
THREADS=4
# MongoDB connection string
MONGO_URI=mongodb://admin:secret@127.0.0.1:27017/proctoring?authSource=admin
# S3 storage connection string
S3_URI=http://minioadmin:minioadmin@127.0.0.1:9000/proctoring
# recognition API connection string
RECOGNIZER_URI=http://secret@127.0.0.1:8080/recognize
# TURN Server connection string
TURN_URI=turn://webrtc:webrtc@<external-ip>:3478?transport=tcp+udp
# secret key for sessions (random character set)
SESSION_KEY=secret
# session lifetime in minutes
SESSION_EXPIRES=180
# private key (content or file path)
SSL_KEY=/etc/letsencrypt/live/<your-domain>/privkey.pem
# SSL certificate (content or file path)
SSL_CERT=/etc/letsencrypt/live/<your-domain>/cert.pem
# certification authority bundle (content or file path)
SSL_CA=/etc/letsencrypt/live/<your-domain>/chain.pem
# limit on the size of uploaded files in MiB
UPLOAD_LIMIT=100
# storage time of unused downloaded files in minutes
UPLOAD_EXPIRES=60
# time of caching statics on the client in minutes
STATIC_EXPIRES=60
# directory of static files
STATIC_DIR=/path/to/dir
# manager login
MANAGER_USERNAME=manager
# manager password
MANAGER_PASSWORD=ChangeMe12345
# host (and port, if non-standard) to login under the manager role
MANAGER_HOST=<your-domain>
# password complexity with a regular expression
# minimum 12 chars, at least one uppercase, one lowercase, one number
PASSWORD_RULE=^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{12,}$
# number of unsuccessful authentication attempts
PASSWORD_ATTEMPTS=5
# lock account after maximum login attempts for N minutes
PASSWORD_HOLDOFF=5
# maximum depth of old password history for checking used passwords
PASSWORD_HISTORY=5

Note that you should replace the <your-domain> string with your actual domain name.

4. Setting up a reverse proxy

Usually the following settings are not required. However, if you are already using a reverse proxy server, you may need to configure the proctoring system to work through it.

4.1. Installing and configuring Nginx

Access to the system from the Internet can be configured through the proxy server Nginx, you can install it in Ubuntu as follows:

sudo apt-get install -y nginx

Virtual host configuration in nginx:

location / {
    client_max_body_size 100m;
    proxy_pass http://127.0.0.1:3000;
    proxy_redirect off;
    proxy_http_version 1.1;
    proxy_pass_request_headers on;
    proxy_set_header Host $host;
    proxy_set_header Origin $http_origin;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Authorization $http_authorization;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-By $server_addr:$server_port;
    proxy_set_header X-Forwarded-Proto $scheme;
}

4.2. Installing and configuring Apache

Installing Apache Web Server on Ubuntu:

sudo apt-get install -y apache2

Apache 2.4 virtual host configuration:

RewriteEngine On
RewriteCond %{REQUEST_URI}  ^/ws                   [NC]
RewriteRule /(.*)           ws://127.0.0.1:3000/$1 [P,L]
<Location "/">
    # RequestHeader set Host "your-proctoring-domain"
    ProxyPreserveHost On
    ProxyPass "http://127.0.0.1:3000/"
    ProxyPassReverse "http://127.0.0.1:3000/"
</Location>

Apache must have mod_proxy, mod_proxy_http, mod_proxy_wstunnel, and mod_rewrite modules enabled.

5. System upgrade

Below are the actions that you have to perform consistently to update the version of the proctoring system. It is not always necessary to update all components. If only the application server has been updated, then it is sufficient to update only the "node" container.

5.1. Upgrade notes

Keep in mind that upgrading individual system components may require additional migration actions.

5.1.1. Upgrade MongoDB

Before upgrading to the next version of MongoDB, you should change the compatibility version in your database:

  • Connect to database by client (e.g. mongosh)

    docker exec -it mongo mongosh -u admin -p secret --authenticationDatabase admin
    
  • To set or update "featureCompatibilityVersion", run the following command:

    db.adminCommand( { setFeatureCompatibilityVersion: "5.0" } )
    

See more details in the official upgrade guide.

5.1.2. Switching file storage to Silo (OctoProctor v. 5.13.0)

This applies only to installations created before version 5.13.0, which use the minio/minio image for file storage. These images have been removed from Docker Hub, so such an installation cannot be reinstalled or upgraded with its old configuration.

To switch to Silo, replace your docker-compose.yml with the file from Section 2.2:

  1. Make sure that all passwords and keys are set in the .env file. If your current docker-compose.yml contains them directly, move them to .env first.
  2. Place the new docker-compose.yml in the same directory as the old one. This keeps your existing data volumes.
  3. Transfer any changes you made to the old file yourself, such as additional ports or environment variables.
  4. Start the new version with the --remove-orphans parameter (see Section 5.5) to remove the old minio container.

Silo is a community-maintained fork of MinIO: it serves your existing storage volume in place, so no data migration is required.

5.1.3. Upgrade Recognizer

You should use the "latest" tag of the Recognizer Docker image public.ecr.aws/s8z4o5f0/recognizer:latest with the proctoring system v4.13 and higher. For older versions you should use the "old" tag.

5.2. Database backup

To back up the database:

docker exec <mongo_container> mongodump -u <user> -p <password> \
  --authenticationDatabase admin -d <db> --archive --gzip > /path/to/backup/db.dump

where <mongo_container> is the name of the "mongo" container, which can be viewed using the command docker ps; <user> is the username of the database user; <password> is the DB user password; <db> is the name of the database ("proctoring" by default); /path/to/backup/db.dump is the dump file.

If the mongo image has not been updated, then this step is not necessary.

5.3. File storage backup

To back up the file storage:

wget -qO- <mc_archive_url> | tar -xz -O mcli > /usr/local/bin/mc
chmod +x /usr/local/bin/mc
mc alias set local http://127.0.0.1:9000 <access_key> <access_secret>
mc mirror local/proctoring /path/to/backup/s3

where <mc_archive_url> is the link to the latest client archive for your platform (for example, mcli_..._linux_amd64.tar.gz) from the Silo Client releases page; <access_key> is the storage access key; <access_secret> is the storage access password; proctoring is the name of the proctoring bucket; /path/to/backup/s3 is the directory for saving the storage backup.

5.4. Uninstalling a previous version

Stop and remove all containers, remove all images:

docker compose down

5.5. Installing a new version

Start a new installation:

docker compose up -d --force-recreate --pull always --remove-orphans

5.6. Reading logs

Read the specified container log:

docker logs -f <container_name>

where <container_name> is the name of the container, which can be viewed using the command docker ps.

5.7. Database recovery

To restore the database:

cat /path/to/backup/db.dump | docker exec -i <mongo_container> mongorestore \
  -u <user> -p <password> --authenticationDatabase admin --archive --gzip

where <mongo_container> is the name of the "mongo" container, which can be viewed using the command docker ps; <user> is the DB user login; <password> is the DB user password; /path/to/backup/db.dump is the dump file.

If you have not made a backup copy of the database, then this step should be skipped.

5.8. File storage recovery

To restore the file storage data:

mc alias set local http://127.0.0.1:9000 <access_key> <access_secret>
mc mirror /path/to/backup/s3/ local/proctoring

where <access_key> is the storage access key; <access_secret> is the storage access password; proctoring is the name of the proctoring bucket; /path/to/backup/s3/ is the directory for saving the storage backup.

If you have not made a backup copy of the file storage, then this step should be skipped.

6. Log in

The system can be accessed at the address specified during deployment (for example, https://your-domain). Authorization parameters for the manager by default are as follows:

  • login: manager
  • password: ChangeMe12345

After the first login under the manager, you need to add a host configuration based on a license key that is issued by supplier for a specific domain, term and volume.