Skip to main content

Deployment Using Docker Compose

Eylon Sirotkin
  • Updated

SkylineGlobe Server can be deployed on Linux using Docker Compose to run containerized instances of the application. This method offers a fast, repeatable, and consistent setup, whether you're using a lightweight embedded SQLite database or a scalable external PostgreSQL database. You can expose the service over HTTPS using NGINX and a self-signed certificate.

The following Docker Compose deployment options are available:

  • Basic SQLite setup – A simple deployment using an embedded SQLite database and exposed via HTTP (NodePort). No HTTPS support.
  • SQLite with HTTPS via NGINX – Adds a reverse proxy using NGINX and secures access with a self-signed TLS certificate.
  • PostgreSQL with HTTPS via NGINX – A production-ready setup using an external PostGIS-enabled PostgreSQL database and secure HTTPS routing through NGINX.

Each deployment option includes sample YAML files and detailed setup instructions. The examples assume that you organize all supporting files in a single project directory with the following structure:

project-root/
├── config/           # contains SLSkylineGlobeServer.lic
├── data/             # SQLite data
├── postgres_data/    # PostgreSQL volume
└── nginx/
│   ├── nginx.conf    # NGINX configuration
│   └── certs/        # TLS certificate and key for SSL setups
│       ├── tls.crt          # TLS certificate
│       └── tls.key          # TLS private key

Deployment

  1. Download the Docker-Compose.yaml file for your deployment. This file defines how to deploy the SkylineGlobe Server container using Docker Compose including configuration for the image, ports, public URL, environment variables, and volumes. More about: SGS Deployment Settings
  2. Create a new project folder for the Docker Compose project and copy the downloaded docker-compose.yaml  into this folder.
    md C:\SGS_85_Docker
    copy "C:\...\docker-compose.yaml"
    cd C:\SGS_85_Docker
  3. Create a subfolder named data inside the project folder that will be mounted as a volume inside the container — typically at /app/data to persist data generated or accessed by the SGS application:
    md data
  4. Create a subfolder named config inside the project folder that will be mounted as a volume inside the container — typically at /app/config to persist data generated or accessed by the SGS application, and place the license file (SLSkylineGlobeServer.lic) inside this subfolder. If you don’t already have the file, download it from your Skyline Store account.
    md config
  5. Mount the data and config subfolders in the volumes: section of your docker-compose.yaml file:
        volumes: 
          - ./data:/app/data
          - ./config:/app/config
  6. If you want to apply TerraExplorer Fusion customizations, create the local folders or files that will be mounted inside the container for this purpose and then mount them:
    1. Create the subfolder for multiple customization files (md more data) or prepare a single customization file (e.g., my-config.json).
    2. Mount the created subfolder (keeps the original /app/tef/custom contents) or single file (adds/replaces one file; :ro = read-only). These custom paths are mounted to /app/tef/custom inside the container, in addition to the main mounts (/app/data and /app/config). 
          volumes:  # Mount local folders for data persistence
            # Option 1: Mount a subfolder 
             - ./more-data:/app/tef/custom/more-data
            # Option 2: Mount a single file 
            - ./my-config.json:/app/tef/custom/my-config.json:ro
  7. Enable TLS (commonly referred to as SSL) to secure SGS and ensure access to TerraExplorer Fusion, which operates exclusively over HTTPS.  More about: Generating a TLS certificate and setting up NGINX for secure SGS deployment with SQLite or PostgreSQL >
  8. Set the configuration parameters in the environment: section of your docker-compose.yaml file. More about: SGS Deployment Settings> 
    SGS__ServerConfig__<ParameterName>: <value>
  9. Common parameters include:
    • CatalogDBType: The type of database to use. Options: SQLite (default) or PostgreSQL.
    • PublicUrl: The public-facing service URL used in WMS/WFS/WMTS responses.
    • LicenseServerURL: The URL of the floating license server. This parameter is required only when using a floating license. The license file must be placed in the config subdirectory within the server directory, and this parameter should be set to that location.
  10. Start the containers defined in the file docker-compose. yaml:
    Docker compose up -d
  11. Access SGS at the following unless SGS__ServerConfig__PublicUrl was configured differently in your docker-compose.yaml file:
  12. If a browser security warning appears, click Advanced (or Show details) to reveal the bypass option. Then do the following:
    • Chrome/Edge: Click Continue to sgs.localhost (unsafe).
    • Firefox: Click Accept the Risk and Continue.

Enabling HTTPS with NGINX in a Docker Environment

To expose SkylineGlobe Server over HTTPS in a Docker environment:

  1. Create a subfolder named nginx inside the project folder that will be mounted as a volume inside the container — typically at /app/nginx to hold the nginx.configuration and self-signed certificate (tls.crt) and private key (tls.key) generated below. Then create a certs subfolder inside the nginx folder. In your terminal, run the following commands:
    md nginx
    md nginx\certs
  2. Download the NGINX configuration file (nginx.conf) and place it inside the nginx/ folder in your Docker project. This configuration tells NGINX to do the following:
    • Listen on port 443 for HTTPS traffic
    • Use the self-signed certificate (tls.crt) and key (tls.key)
    • Forward all incoming requests to the SkylineGlobe Server application running inside the container on port 5155
  3. Install an OpenSSL Tool if you don’t already have OpenSSL installed. This tool will be used to create the self-signed certificate:
    • If you're deploying Docker on Windows: Download and install from https://slproweb.com/products/Win32OpenSSL.html (choose the version that matches your system).
    • Alternatively: Use a terminal environment that includes OpenSSL, such as Git Bash or Windows Subsystem for Linux (WSL).
  4. Download the openssl.cfg configuration text file that defines your self-signed certificate settings. Save the file in your Docker project folder (e.g., C:\SGS_85_Docker). This is where you’ll run the OpenSSL command in the next step:
    # openssl.cfg
    [ req ]
    default_bits       = 2048
    prompt             = no
    default_md         = sha256
    distinguished_name = dn

    [ dn ]
    CN = sgs.localhost
    O  = Local Dev
  5. Run the following OpenSSL command in your terminal to create a self-signed certificate (tls.crt) and private key (tls.key) based on the settings in your openssl.cfg file. The files will be saved to the nginx/certs/ folder in your Docker project and used by NGINX to enable secure HTTPS access to SkylineGlobe Server. The NGINX configuration file (nginx.conf) references these files to establish the TLS connection and proxy incoming HTTPS requests to the SGS application running inside the container:
    openssl req -x509 -nodes -days 365 -newkey rsa:2048   -keyout nginx/certs/tls.key -out nginx/certs/tls.crt -config openssl.cfg
  6. In your nginx.conf file, the TLS certificate (tls.crt) and key (tls.key) should be referenced under "server":
server {
    listen 443 ssl;
    server_name sgs.localhost;
    ssl_certificate     /etc/nginx/certs/tls.crt;
    ssl_certificate_key /etc/nginx/certs/tls.key;

Basic Docker Operations:

# Start containers (detached)
docker compose up -d

# Stop and remove containers
docker compose down

# Pull latest images for all services
docker compose pull

# Load a new image from a local tar file
docker load -i <path/to/image.tar>

# Tag the loaded image as "latest"
# (Make sure the repository/name matches the image reference in docker-compose.yml)
docker tag <source_image>:<version> <repository>/<image>:latest

Related articles