Docker

Docker or Docker Desktop is required for Monolith on-premises deployments. Installation instructions can be found here.

Hardware

The following hardware is required to properly run the Monolith API backend within Docker:

• Microsoft Windows 10/11, MacOS, or Ubuntu 20 system

• 4GB of RAM

• 2-core CPU

• At least 100 GB of storage (>500 GB recommended)

SMTP (Email Use)

To enable Monolith’s email capabilities, an email account is required with SMTP credentials:

• SMTP host

• SMTP port

• SMTP user

• SMTP password

These values are supplied to the Monolith API server/Docker container at run-time.

Amazon AWS S3 Integration

If you want to store Monolith files in AWS S3, you will need to have the following to integrate S3:

• AWS Access Key

• AWS Secret Key

• AWS Region & Endpoint

On-Premises Package

Once you have purchased Monolith and are ready to deploy - you will be provided with a Monolith On-premises deployment package. This package will contain configuration files necessary to run the deployment.

Package Contents

The package will contain the following items:

• .env

  • This is an environment file that will contain variables that are injected into your Monolith deployment at run time. This is where your licensing information will be location along with other settings.

• docker-compose.yml

  • This is a Docker deployment configuration file. This file dictates how the various Monolith containers will be built and deployed.

  • This allows you to use a pre-defined configuration so that you don't need to build the Monolith Docker deployment from scratch.

• init folder

  • This contains additional configuration files needed for successful deployment.

Example

This is an environment variables file that is loaded into the Monolith Docker deployment at build/run time. These values determine various setup options and licensing information for your Monolith deployment.

The values are typically set for you when you purchase Monolith.

### Application Settings ###

### Mandatory Options ###

### Monolith License key
# Used to activate license

MONOLITH_LICENSE_KEY=
MONOLITH_LICENSE_TOKEN=

### API Token Secrets
# Used to generate secure access tokens and refresh tokens
# Set these to long, random alphanumeric strings

ACCESS_TOKEN_SECRET=
REFRESH_TOKEN_SECRET=


### Monolith Database Config

MONOLITH_DB_NAME=monolith
MONOLITH_DB_USER=monolith
MONOLITH_DB_PORT=3306
MONOLITH_DB_HOST=mysql
MONOLITH_DB_PASSWORD=

### Initial Monolith User - Only needed for initial setup

MONOLITH_ADMIN_FIRST_NAME=
MONOLITH_ADMIN_LAST_NAME=
MONOLITH_ADMIN_EMAIL=
MONOLITH_ADMIN_PASSWORD=

### Monolith Forms Settings

FORM_TENANT_NAME=
FORM_ORG_NAME=
FORM_TENANT_SLUG=
FORM_TENANT_EMAIL=

### OPTIONAL SETTINGS ###

### API Instance Total
# Set the number of API cluster instances to run
# default is 1 - which should be plenty for most deployments

#API_INSTANCE_COUNT=1

### File Service
# Choose the file service you wish to use
# Options are "S3" and "LOCAL"
# Defaults to "LOCAL" if not set
# S3 keys required if using S3 service

# FILE_SERVICE=S3
# FILE_SERVICE=LOCAL



### AWS S3 Config

# AWS_ENDPOINT={aws_endpoint}
# MONOLITH_FORMS_BUCKET={aws_bucket_name}
# MONOLITH_CLOUD_BUCKET={aws_bucket_name}
# S3_ACCESS_KEY={s3_access_key}
# S3_SECRET_KEY={s3_secret_key}

### SMTP settings
SMTP_HOST=
SMTP_PORT=
SMTP_USER=
SMTP_PASSWORD=

Values

MONOLITH_LICENSE_KEY

This is a license key that allows for your Monolith deployment to get licensing information from our online license server. Using this value ensures that your Monolith deployment always has up to date license info.

This key will be provided to you upon purchase.

MONOLITH_LICENSE_TOKEN

This is a signed token that contains licensing information for your Monolith purchase. This can be used to utilize cached license info without needed to query our licensing server for license info.

This is a good option for Monolith deployments that exist in air-gapped environments.

If this value is provided, Monolith will use this instead of the license key value.

ACCESS_TOKEN_SECRET

This should be a long alphanumeric string. This value is used for various cryptographic operations related to access tokens, encryption, and session management.

REFRESH_TOKEN_SECRET

This should be a long alphanumeric string. This value is used for various cryptographic operations related to access tokens, encryption, and session management.

MONOLITH_DB_NAME

This is the name of the MySQL schema that the Monolith API server should connect to.

MONOLITH_DB_HOST

This is the domain or IP address of the MySQL database host that the Monolith API server should connect to.

MONOLITH_DB_USER

This is the MySQL user name that should be used for database connections.

MONOLITH_DB_PORT

The port that should be used for database connections. The default MySQL port is 3306.

MONOLITH_DB_PASSWORD

MySQL password used to establish database connections.

MONOLITH_ADMIN_FIRST_NAME

First name of initial Monolith user. Only required for first time setup/deployment.

MONOLITH_ADMIN_LAST_NAME

Last name of initial Monolith user. Only required for first time setup/deployment.

MONOLITH_ADMIN_EMAIL

Email of initial Monolith user. Only required for first time setup/deployment.

MONOLITH_ADMIN_PASSWORD

Password of initial Monolith user - this will be used for firs time login to Monolith. Only required for first time setup/deployment.

FORM_TENANT_NAME

Initial tenant name for your Relay deployment. Only required for first time setup/deployment.

FORM_ORG_NAME

Organization name for your Relay deployment. Only required for first time setup/deployment.

FORM_TENANT_SLUG

URL slug for your Relay deployment. Only required for first time setup/deployment.

my-forensic-company

FORM_TENANT_EMAIL

Initial tenant email for your Relay deployment. Only required for first time setup/deployment.

API_INSTANCE_COUNT

The Monolith API server runs in "cluster" mode. This allows multiple instances to run at the same time, which increases scalability. This value defaults to 1 and is disabled by default. You will likely not need to use this value, but contact support if you think this is needed.

FILE_SERVICE

This value determines whether Monolith will use a local file system or Amazon S3 to store Monolith files. Allowed values are "S3" or "Local". The default value is "Local". If you set this to "S3", you will also need to set the S3 access key values.

AWS_ENDPOINT

This value configures Monolith to use the correct AWS region with your S3 bucket.

MONOLITH_FORMS_BUCKET

The S3 bucket where you would like to store files uploaded to Relay.

MONOLITH_CLOUD_BUCKET

The S3 bucket where you would like to store files uploaded to Monolith.

S3_ACCESS_KEY

AWS access key to use S3 APIs for file storage.

S3_SECRET_KEY

AWS secret key to use S3 APIs for file storage.

SMTP_HOST

Email host domain to enable email capabilities in Monolith.

SMTP_PORT

Email port to enable email capabilities in Monolith. This value is typically 587.

SMTP_USER

User value to enable email capabilities in Monolith. May not be required if you are using an SMTP relay.

SMTP_PASSWORD

User password to enable email capabilities in Monolith. May not be required if using an SMTP relay.

Where your license is managed

Currently, your on-premises license to Monolith is managed within the ".env" file that is within your Monolith package deployment folder.

There are two values within the ".env" file that related to your Monolith License:

MONOLITH_LICENSE_KEY=
MONOLITH_LICENSE_TOKEN=

When the Monolith server starts up, it derives your license from one of these two values.

Monolith License Token (Preferred - Offline Licensing)

The Monolith license token is a long string that is a securely signed token that contains your licensing information.

This method works in both online and offline environments and does not use the internet to operate.

The Monolith server derives your license details from this token.

This is the preferred method, because it does not rely on our licensing server to work and will keep your Monolith deployment operational even during internet outages.

Monolith License Key (Online Licensing)

The Monolith license key is a short, unique string that is associated with your Monolith customer account. Monolith uses this value to retrieve your licensing information from our online licensing server on the internet.

Updating your license

To update your license, simply replace the License key or token value in your ".env" file with a new one and restart your Monolith Docker deployment.

You can restart your Monolith Docker deployment with the following commands:

docker compose down
docker compose up -d

File Example

This file is used to define the deployment options for the various Docker containers that make up the Monolith on-premises deployment.

Unless you require an advanced deployment, you will not need to modify this file.

services:
  monolith-api:
    container_name: monolith-api
    image: monolithforensics/monolith-api:latest
    restart: always
    volumes:
      - ./data/logs:/usr/src/app/data/logs
      - ./data/Monolith:/usr/src/app/data/Monolith
      - ./data/Monolith-forms:/usr/src/app/data/Monolith-forms
    ports:
      - "3001:3001"
    env_file:
      - .env
    mem_limit: 512m

  monolith-forms:
    container_name: monolith-forms
    image: monolithforensics/monolith-forms:on-prem
    restart: always
    volumes:
      - ./data/logs:/usr/src/app/data/logs
    ports:
      - "3003:3003"
    mem_limit: 150m

  monolith:
    container_name: monolith
    image: monolithforensics/monolith:on-prem
    restart: always
    volumes:
      - ./data/logs:/usr/src/app/data/logs
    ports:
      - "3005:3005"
    mem_limit: 150m

  mysql:
    container_name: mysql2
    image: mysql:8.0.16
    command: --default-authentication-plugin=mysql_native_password --sql_mode=""
    security_opt:
      - seccomp:unconfined
    restart: always
    ports:
     - "3307:3306"
    environment:
      MYSQL_ROOT_PASSWORD: ${MONOLITH_DB_PASSWORD}
      MYSQL_USER: ${MONOLITH_DB_USER}
      MYSQL_PASSWORD: ${MONOLITH_DB_PASSWORD}
      MYSQL_DATABASE: ${MONOLITH_DB_NAME}
    volumes:
      - ./data/mysql:/var/lib/mysql
      - ./init:/docker-entrypoint-initdb.d
    mem_limit: 512m

  nginx:
    container_name: nginx
    image: monolithforensics/nginx:latest
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
     - ./data/logs/nginx:/var/log/nginx/
    # - /etc/nginx:/etc/nginx
    # - /etc/letsencrypt:/etc/letsencrypt/

  watchtower:
    container_name: watchtower
    image: containrrr/watchtower:latest
    restart: always
    environment:
     - WATCHTOWER_CLEANUP=true
    command: --interval 30
    volumes:
     - /var/run/docker.sock:/var/run/docker.sock
    mem_limit: 512m

How this file works

This file is used with the following commands to build, re-build, and remove the containers that run Monolith.

// Deploy Monolith
docker compose up -d

// Remove All Monolith Containers
docker compose down

Docker

Docker is a platform that uses OS-level virtualization to deliver software in packages called "containers". Docker is used to deploy, manage, and run containers within a variety of environments.

Monolith is deployed in on-premises environments using containers and Docker is recommended as the container management system to run and manage Monolith.

How Monolith Works

Monolith runs in a server-client configuration where users access and manage data via the Monolith desktop client or web application. A Monolith API server runs on a centralized host and handles HTTP requests from the desktop clients and web application. The API server communicates with a database to create, update, delete, and read data from the database.

The image above illustrates the basic setup of containers within an on-premises deployment. The containerized nature of Monolith allows for flexible and scalable on-premises deployment options.

Monolith Containers

NGINX proxy

This is a web server container that handles incoming requests from clients and proxies traffic to one of 3 containers: Monolith Web App,Monolith API, or the Relay App. This container can be configured to include custom domain TLS certificates.

Monolith App

This is the Monolith web application that can be access via a web browser. To access this application, you just need to navigate to the host system IP address or assigned domain name in a web browser - Ex: https://192.168.1.12

Monolith API

This container hosts an API server that can send authenticated requests for data to and from the Monolith and Relay web applications. This container connects directly to the MySQL server to store data and a file system to store files uploaded to Monolith.

Relay App

The Relay app container runs the Relay application. Relay is a web-based request system that allows non-monolith users to submit requests for forensic services.

MySQL DB

This container runs a MySQL database that stores data accessed and managed by users of Monolith and Relay. The MySQL database does not have to be a container inside Docker. You can use an external hosted MySQL database if you wish.

File System

This is not a container, it represents your chosen file system component to store files that are uploaded to Monolith and Relay. This can be the file system on the host system, AWS S3 object storage, or a network file share.

Watchtower

Watchtower is an optional container that manages automatic updates for the other containers. Watchtower checks for container updates every 30 seconds. When an update is available, Watchtower downloads the new container images and replaces the current containers with new containers built from the updates container images.

Windows

To Install Docker on Windows, you need to install Docker Desktop for Windows. This installer can be downloaded from here:

WSL

To deploy Monolith on Windows, you will need to install the WSL package for Windows. This allows Windows to run Linux containers. During the Docker Desktop install, Docker typically prompts you to install this. If not, here is a direct link to download and install WSL:

MacOS

To Install Docker on MacOS, you need to install Docker Desktop for MacOS. This installer can be downloaded from here:

Linux

To install Docker on a Linux OS, refer to the following Docker documentation for Linux installations:

Default Deployment

Deploying Monolith with the default configuration is a simple matter.

1. Install Docker -

2. Pick a location to store your on-premises package files.

3. Open a command terminal.

4. Navigate to the location of your Monolith On-premises package files.

   • This is the folder that contains the .env and docker-compose.yml files.

5. Run the following command to download, deploy, and run the Monolith containers referenced in the docker-compose.yml file:

   • docker compose up -d

6. This will download the Monolith container images which may take a few minutes.

7. Once downloaded, the containers will launch and build the initial Monolith system.

8. You can then navigate to Monolith in a web browser using the IP address of the host system running Monolith:

   • https://{host_server_ip}

To remove the docker containers, you can use the following command:

docker compose down

Example

Starting and Stopping Monolith Server

// Deploy and Run Monolith Containers
// Must be run in same directory as docker-compose.yml
docker compose up -d

// Remove Monolith containers
// ust be run in same directory as docker-compose.yml
docker compose down

These commands can be used together to conduct a "hard" restart of Monolith.

Various Docker Commands

// Show resource usage of docker containers
docker stats

// Show running containers
docker container ls -a

// Show downloaded container images
docker image ls -a

// Download fresh container image
docker pull [container-name]

// Restart container
docker container restart [container-name]

Docker CLI Reference

Additional Docker commands can be reviewed on Dockers official documentation pages:

https://docs.docker.com/engine/reference/run/

Docker Compose CLI Reference

Additional Docker compose commands can be reviewed on Docker's official documentations pages:

https://docs.docker.com/compose/reference/

Monolith On-premises deployments do not include a native backup solution.

The customer is responsible for creating and managing backups for data stored in the Monolith deployment.

The customer should set up a backup system that creates backups of the "data" folder maintained by the Monolith server. A backup solution for the MySQL Monolith database should also be implemented. The MySQL backup process should create something similar to SQL dumps of the databases stored by Monolith in MySQL.

This section will cover restoring a database backup of your Monolith MySQL database.

Backup Data

This restore process assumes you have previously created a SQL dump of your Monlith databse from MySQL. A SQL dump file is a plain text file that contains your database data in a SQL format.

Database Schemas

MySQL has a concept called "schemas". Schemas are the data segements within MySQL that store tables and data. You can have any number of schemas within a MySQL database. Your Monolith data is stored within a single schema within MySQL.

Schemas are the data object that we will backup and restore from backups.

Restore Steps

Recommended Tools:

• MySQL Workbench

  • This is a free tool provided by the MySQL team to access and manage MySQL databases. It also has several useful utilities including database backup and backup import services.

1. Open MySQL Workbench

2. Ensure that Workbench has a connection to your Monolith database.

3. Open your Monolith database in MySQL workbench.

4. Select "Server >> Data Import" from the Workbench menu bar.

5. The import wizard should start at the "Import from Disk" tab - select this tab if its not selected.

6. Under "Import Options", check the radio button for "Import from Self-Contained file".

7. Use the file select browser to locate and choose your Monolith database backup, which should have a ".sql" extension.

8. (Optional) Select a default target schema or create a new one.

   1. This is optional because your SQL dump file likely already has a directive to create a new schema with the correct name.

9. Click the "Start Import" button.

This process will create a new "schema" and populate it with tables and data from your Monolith database backup.

Automatic Updates

If you have deployed Monolith with the Watchtower container, the Monolith API server, Monolith web app, and Relay web app will automatically update if the host system has internet access.

Watchtower checks for updates to these container every 30 seconds.

You may disable these automatic updates by simply removing the Watchtower container from your Monolith deployment.

Force an Update

If you don't want to wait for Watchtower or if you want to buld updates into a recurring script, you can force an update with a couple of commands.

The following commands use Docker compose to pull down the latest Monolith images, and rebuild the entire Monolith deployment with the new images.

## destroy currently running Monolith containers
docker compose down

## Pull latest images
docker compose pull

## Deploy Monolith containers with new images
docker compose up -d

You can imbed these commands within a bash or batch script if you would like to implement your own scheduled updates instead of using watchtower.

Manual Updates

You can also update the Monolith server containers manually. This can be useful in air-gapped environments or if you do not wish to deploy with automatic updates.

Download Latest Container Images

Run the following commands to download the latest container images for Monolith deployment or updates:

docker pull monolithforensics/nginx:latest
docker pull monolithforensics/monolith:on-prem 
docker pull monolithforensics/monolith-api:latest
docker pull monolithforensics/monolith-forms:on-prem
docker pull mysql:8.0.16

Export Container Images for Transfer

Run the following commands to export the container images to TAR files that can be transferred to the the host running the Monolith server:

docker image save -o monolithfornesics_nginx.tar monolithforensics/nginx:latest
docker image save -o monolithforensics_monolith.tar monolithforensics/monolith:on-prem
docker image save -o monolithforensics_monolith-api.tar monolithforensics/monolith-api:latest
docker image save -o monolithforensics_relay.tar monolithforensics/monolith-forms:on-prem
docker image save -o mysql_8.0.16.tar mysql:8.0.16

You can now transfer these TAR files to the host system that runs your Monolith deployment.

Import Container Images to Server

To import the TAR files, run the following commands on the host system that is using Docker to deploy the Monolith containers:

docker image load -i monolithfornesics_nginx.tar
docker image load -i monolithforensics_monolith.tar
docker image load -i monolithforensics_monolith-api.tar
docker image load -i monolithforensics_relay.tar
docker image load -i mysql_8.0.16.tar

Restart the Monolith Server

To restart Monolith with the new containers, run the following commands on your Monolith host and from the directory that includes your docker-compose.yml file:

docker compose down
docker compose up -d

To use an external database instead of using the MySQL Docker container that is included with the default Monolith deployment, just set the following values in the .env file to the connection details for your external MySQL database:

MONOLITH_DB_NAME=
MONOLITH_DB_USER=
MONOLITH_DB_PORT=
MONOLITH_DB_HOST=
MONOLITH_DB_PASSWORD=

Once deployed, Monolith will store data in a folder called "data". This folder contains log files, files uploaded to Monolith, files uploaded to Relay, and database files generated by MySQL.

This data folder is important to maintain and create backups as the data that you store in Monolith will reside in this location.

Setting up a custom domain for Monolith requires just a couple of item and steps:

1. Setup the domain that you want to use.

2. Create SSL certificates with any necessary intermediate certs that are required for the domain.

3. Add those SSL certificates to your Monolith deployment.

   1. Update the docker-compose.yml file

   2. Copy the SSL certs to your Monolith deployment folder.

Setting up a Custom Domain

This process will be different for everyone, but usually your IT department can establish a specific Domain for you to use to access your Monolith deployment in a web browser.

This is helpful because it allows you to use domain resolution in your browser instead of a plain IP address that points at your Monolith server.

This also lets you setup SSL that can be verified by your browser and create secure and encrypted web traffic between your Monolith users and the Monolith server.

Generating SSL certificates

Again, this process varies, but you will need to generate two SSL certificates that are associated with your custom domain. These certificate file comprise of a certificate file and a key file.

This is also a process that your IT department can help you with.

Update your docker-compose.yml

Before we can use the new SSL certificates, we need to update our Monolith deployment config so that it will override the built in self-signed certificates that Monolith uses by default.

Under the "nginx" block of the docker-compose.yml file, add the following line under "volumes":

./data/nginx/certs:/etc/nginx/certs

The entire "nginx" block should look like this:

  nginx:
    container_name: nginx
    image: monolithforensics/nginx:latest
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./data/logs/nginx:/var/log/nginx/
      - ./data/nginx/certs:/etc/nginx/certs

Rename the SSL certificates

When using custom SSL certs, Monolith is looking for certificates with specific names - rename your SSL certs to the following file names:

// Cert file
default_monolith.crt

// Key File
default_monolith.key

Copy SSL certs to Monolith Deployment Folder

Copy the SSL certs to "data" folder within your Monolith deployment, the final cert locations should look like this:

// Some code
{monolith-deployment-folder}/data/nginx/certs/default_monolith.crt
{monolith-deployment-folder}/data/nginx/certs/default_monolith.key

Re-deploy the Monolith Server

In order for Monolith to start using the new certs, we need to redeploy/restart the Monolith server so that it will indest the cert files.

Open a terminal or command prompt in the location of the docker-compose.yml file.

Enter the following commands, in order, to re-deploy and restart the Monolith server:

// shut down current deployment
docker compose down

// wait for process to complete

// Restart Monolith deployment
docker compose up -d

Conclusion

Now, Monolith will start using these certs and your custom domain to create a secure and encrypted connection between the server and your clients systems; both in the web browser and the Monolith desktop client.

If a user's email has changed and you need to update it in Monolith, the change must be made directly in the Monolith database.

Here are the steps to make that change.

Install MySQL Workbench, open it, and create a connection to your Monolith database.

Open the Monolith database connection in MySQL workbench.

Navigate to your Monolith Database under the "schemas" tab and expand the schema and tables list. The Monolith db is usally called "monolith_db".

Scroll to the "users" table and open the table in Workbench to reveal the user records.

Find the user record that you want to update and click into that user's email column. Then type in the new email.

Click the "apply" button at the bottom right in Workbench, then click apply again in the confirm dialog that appears.

Once this is completed, the user's email has been updated and they can start logging into Monolith with that email address.

Watch the email update process:

Default Monolith deployments store files on the local file system of the host that is running Monolith's Docker containers.

If you want to use an external file share, you will need to adjust the docker-compose.yml file to include configuration settings for the file share you would like to use.

Windows/CIFS Share

To connect to a basic Windows file share, add the following configuration to the bottom of your docker-compose.yml file:

volumes:
  monolith:
    driver: local
    driver_opts:
      type: cifs
      o: "username=your_username,password=your_password,domain=your_domain"
      device: "//<SHARE_IP_ADDRESS>/share/data"

• Replace your_username, your_password, your_domain with the appropriate credentials for accessing the CIFS share. your_domain is not required if your share does not have a specific domain, so you can omit this value.

• Replace //<SHARE_IP_ADDRESS>/share with the network path to your CIFS share, but append the "/data" location at the end.

To utilize this new volume, we need adjust the current volumes listed in each service block of the docker-compose.yml file.

// Some code
monolith-api:
  container_name: monolith-api
  image: monolithforensics/monolith-api:latest
  restart: always
  volumes:
    - monolith:/usr/src/app/data
  ports:
    - "3001:3001"
  env_file:
    - .env
  mem_limit: 512m

Final docker-compose.yml File with CIFS

The following demonstrates the final docker-compose.yml file once a CIFS share has been configured:

services:
  monolith-api:
    container_name: monolith-api
    image: monolithforensics/monolith-api:latest
    restart: always
    volumes:
      - monolith:/usr/src/app/data
    ports:
      - "3001:3001"
    env_file:
      - .env
    mem_limit: 512m

  monolith-forms:
    container_name: monolith-forms
    image: monolithforensics/monolith-forms:on-prem
    restart: always
    volumes:
       - monolith:/usr/src/app/data
    ports:
      - "3003:3003"
    mem_limit: 150m

  monolith:
    container_name: monolith
    image: monolithforensics/monolith:on-prem
    restart: always
    volumes:
      - monolith:/usr/src/app/data
    ports:
      - "3005:3005"
    mem_limit: 150m

  mysql:
    container_name: mysql2
    image: mysql:8.0.16
    command: --default-authentication-plugin=mysql_native_password --sql_mode=""
    security_opt:
      - seccomp:unconfined
    restart: always
    ports:
     - "3307:3306"
    environment:
      MYSQL_ROOT_PASSWORD: ${MONOLITH_DB_PASSWORD}
      MYSQL_USER: ${MONOLITH_DB_USER}
      MYSQL_PASSWORD: ${MONOLITH_DB_PASSWORD}
      MYSQL_DATABASE: ${MONOLITH_DB_NAME}
    volumes:
      - ./data/mysql:/var/lib/mysql
      - ./init:/docker-entrypoint-initdb.d
    mem_limit: 512m

  nginx:
    container_name: nginx
    image: monolithforensics/nginx:latest
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
     - monolith:/usr/src/app/data

  watchtower:
    container_name: watchtower
    image: containrrr/watchtower:latest
    restart: always
    environment:
      - WATCHTOWER_CLEANUP=true
    command: --interval 30
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    mem_limit: 512m

# Connect CIFS share
volumes:
  monolith:
    driver_opts:
      type: cifs
      o: username={username},password={password},vers=3.0
      device: //192.168.1.12/Monolith/data

When running MySQL in Docker or as a container, you may need to update the version of MySQL from time to time.

Ex: Update from MySQL 8.0.16 to 8.0.31 -

To update MySQL within Docker using Docker compose, you need to update your "docker-compose.yml" file.

1 - Edit "docker-compose.yml" file:

Find this line in the MySQL block:

image: mysql:8.0.16

Update the MySQL version in this line to the next version:

image: mysql:8.0.31

This will tell Docker which version of MySQL to use when deploying Monolith.

2 - Redeploy Monolith

Redeploy Monolith using the standard Docker compose command syntax:

docker compose down
docker compose up -d

This will stop the current Monolith deployment and restart it fresh containers. You should see the new version of MySQL download as a Docker image during this process.

Once redeployed, MySQL will go through a breif process of updating itself that may last a minute or two, so it may take a minute or two for Monolith to be available for use.

Conclusion

After completing steps 1 and 2, you should have a new version of MySQL installed and deployed for use with your Monolith deployment.