Skip to main content

Deployment on Kubernetes

Yaniv Navon
  • Updated

In this article:

SkylineGlobe Server can be deployed on Kubernetes using several configurations depending on your database and security requirements. All deployments use containerized infrastructure and can be managed through standard Kubernetes tools.

Kubernetes provides a robust platform for production environments, offering built-in automation for deploying, scaling, and managing containerized applications. Its features, such as self-healing, service discovery, load balancing, and secure secret management, make it well-suited for maintaining high availability and reliability at scale.

Deploying Kubernetes

To deploy using Kubernetes:

  1. Install kubectl, the command-line tool for interacting with Kubernetes clusters. Download from: https://kubernetes.io/docs/tasks/tools/install-kubectl/
  2. Set up or connect to a running Kubernetes cluster – For local development, you can use either of the following:

  3. Select one of the following deployment examples:

    • Basic SQLite: Uses the embedded SQLite database and exposes SGS through a NodePort service over HTTP. Intended primarily for local development and testing.
    • SQLite with Ingress and HTTPS: Uses the embedded SQLite database and exposes SGS over HTTPS through an Ingress controller.
    • PostgreSQL with Ingress and HTTPS: Uses an external PostGIS-enabled PostgreSQL database and exposes SGS over HTTPS through an Ingress controller.
  4. Download all the YAML files for the selected deployment option and place them in the same project folder. The deployment.yaml defines various settings including the catalog database type (SQLite or PostgreSQL). More about: SGS Deployment Settings >
  5. Basic SQLite (HTTP) SQLite + Ingress (HTTPS) PostgreSQL + Ingress (HTTPS)

    deployment.yaml

    service.yaml

    deployment.yaml

    service.yaml

    ingress.yaml

    openssl.cfg

    postgres-deployment.yaml

    postgres-service.yaml

    deployment.yaml

    service.yaml

    ingress.yaml
  6. Create a new project folder (e.g., SGS_Project_Folder) and place the downloaded files in it.
  7. Add two subfolders inside the project folder:
    • config (for the SLSkylineGlobeServer.lic file)
    • data (for storing application data)

  8. In the deployment.yaml file, update the hostPath volume path to match the specific location of your project folder. When running Kubernetes on Windows, the path should begin with /run/desktop/mnt/host/.

    volumes:
  - name: config-volume
    hostPath:
      path: "/run/desktop/mnt/host/c/sgs/config"
  - name: data-volume
    hostPath:
      path: "/run/desktop/mnt/host/c/sgs/data"

  9. Mount the data-volume and config-volume subfolders in the volumeMounts: section of your deployment.yaml file:

    containers:
    volumeMounts:
      - name: config-volume
        mountPath: /app/config
      - name: data-volume
        mountPath: /app/data
  10. If you want to apply TerraExplorer Fusion customizations, create the local folders or files that will be mounted inside the container for this purpose (Optional). You can do either of the following:

    • Create a subfolder for multiple customization files:

      md C:\sgs\more-data

    • Or prepare a single customization file (e.g., my-config.json).
      Next, add these to the volumeMounts: section of your deployment.yaml to specify where the custom files or folders will appear inside the container, and define the full path to your local customization folder or file in the corresponding hostPath entry under volumes: to specify their source on the host system.

      volumes:
  # Option 1: Host folder to mount as a subfolder inside the container
  - name: more-data-volume
    hostPath:
      path: "/run/desktop/mnt/host/c/sgs/more-data"
  # Option 2: Host file to mount as read-only
  - name: custom-file-volume
    hostPath:
      path: "/run/desktop/mnt/host/c/sgs/custom/my-config.json"

containers:
    volumeMounts:
      # Option 1: Mount a subfolder (keeps the original /app/tef/custom contents)
      - name: more-data-volume
        mountPath: /app/tef/custom/more-data
      # Option 2: Mount a single file (adds/replaces one file)
      - name: custom-file-volume
        mountPath: /app/tef/custom/my-config.json
              readOnly: true
  11. If you have not already downloaded the SLSkylineGlobeServer.lic license file, download it from your Skyline Store account. Place the downloaded file in the config subfolder created above. 
  12. If you selected the SQLite with Ingress or PostgreSQL with Ingress deployment, configure HTTPS as described in Security Configuration Options for Deployment. This includes preparing the certificate, creating the Kubernetes TLS secret, and configuring the Ingress. The Basic SQLite deployment does not require this step.

  13. Set the configuration parameters in the env: section of your deployment.yaml file. More about: SGS Deployment Settings > Use the following format:

    env:
  - name: SGS__ServerConfig__<ParameterName>

    Common parameters include:

    • CatalogDBType: The type of database to use. Options: SQLite (default) or PostgreSQL.
    • LicenseServerURL: The URL of the floating license server. This parameter is required only when using a floating license. Set the LicenseServerURL parameter in the following format: 
      "LicenseServerURL": "https://cloud.skylineglobe.com/sws/[LICENSE_TOKEN]" 
      Replace [LICENSE_TOKEN] in the URL with the token from your subscription email or from your Skyline account page (https://cloud.skylineglobe.com/store/account). 

  14. Apply the YAML files by running the following for each file:

    kubectl apply -f <file-name>.yaml
  15. Access the server at:
    • Basic SQLite - http://localhost:30080 
    • SQLite+Ingress (HTTPS) - https://sgs.localhost 

    • PostgreSQL+Ingress (HTTPS) - https://sgs.localhost
      All files and support folders (e.g., config/, data/, tls/) should be placed in the same project directory for consistent volume mounting. To deploy SkylineGlobe Server using Kubernetes, your project directory should follow the structure below:

      project-root/
      ├── config/                  # Contains SLSkylineGlobeServer.lic
      ├── data/                    # SGS data
      ├── postgres_data/           # PostgreSQL example only
      └── tls/                     # Ingress examples only
         ├── tls.crt
         └── tls.key

 

Basic Kubernetes Operations

# Restart pods and pull the latest image (if imagePullPolicy: Always is set)
kubectl rollout restart deployment/<deployment_name>

# Update the deployment to use a specific image version
kubectl set image deployment/<deployment_name> <container_name>=<repository>/<image>:<version>

# Scale the deployment manually (set a fixed number of replicas)
kubectl scale deployment/<deployment_name> --replicas=<number_of_replicas>

# Enable horizontal pod autoscaling based on CPU usage
# (Requires Metrics Server; if not yet installed, apply it using the next command)
kubectl autoscale deployment/<deployment_name> --cpu-percent=<target_cpu_percent> --min=<min_replicas> --max=<max_replicas>

# Install the metrics server (required for autoscaling)
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

# Cleanup resources created from a manifest
kubectl delete -f <path/to/manifest.yaml>

 

Related articles