JOpt TourOptimizer – Enterprise Deployment with Terraform

This document describes a production-grade, enterprise deployment model for JOpt TourOptimizer, a stateless, reactive Spring Boot 3.4.x application, using:

Java 17
Spring Boot (WebFlux, Security, Actuator)
Prebuilt container images
Infrastructure as Code (Terraform)
Optional MongoDB persistence
Cloud or on-premise environments

The document targets architects, DevOps engineers, and platform teams.
All examples are vendor-neutral reference implementations and can be adapted to AWS, Azure, GCP, OpenStack, or bare-metal environments.

1. Application Characteristics

1.1 Technical Stack Summary

Configuration status: January 2026

Runtime
- Java 17
- Spring Boot 3.4.2
- Reactive WebFlux stack
API
- REST + OpenAPI 3.0 (springdoc)
- Streaming endpoints (SSE)
Security
- Optional HTTP Basic authentication
- IP whitelisting
- License-based access control
State
- Stateless core
- Optional MongoDB persistence for fire-and-forget workflows
Compute Profile
- CPU-bound optimization workloads
- Memory-intensive problem graphs
Packaging
- Prebuilt container image
- No build tooling required by the customer

The application is explicitly designed for horizontal scaling and external orchestration.

2. Target Architecture

2.1 Logical Architecture

Client Systems
     |
     |  HTTPS / REST / SSE
     v
Load Balancer / Ingress
     |
     v
JOpt TourOptimizer Containers / Pods
     |
     +--> Optional MongoDB (Persistence Layer)

Key properties:

No sticky sessions required
No in-memory shared state
Horizontal scaling increases throughput, not single-run speed
Optimization jobs are CPU-bound and long-running

3. Container Image Consumption Model

3.1 Image Ownership and Responsibility

In enterprise setups, customers do not build container images themselves.

DNA Evolutions provides:

Prebuilt, versioned container images
Tested Java runtime and JVM tuning
Consistent startup behavior
Security-reviewed base images

Customers are responsible for:

Infrastructure provisioning
Runtime configuration
Networking and access control
Scaling and observability

Container images are typically obtained from:

Docker Hub
A private enterprise container registry

3.2 Reference Dockerfile (Informational Only)

The following Dockerfile is shown for transparency only.
It is not required for deployment and is not expected to be used by customers.

FROM eclipse-temurin:17-jre-alpine

RUN addgroup -S jopt && adduser -S jopt -G jopt
USER jopt

WORKDIR /app
COPY joptTourOptimizerSpringApp.jar app.jar

EXPOSE 8081

ENTRYPOINT ["java","-XX:MaxRAMPercentage=75","-jar","/app/app.jar"]

4. Configuration Model

4.1 Configuration Philosophy

JOpt follows strict 12-factor application principles:

No configuration baked into the image
All runtime behavior controlled via environment variables
Safe defaults for local execution
Explicit configuration for production behavior

4.2 Key Environment Variables

Purpose	Variable
Server Port	`SERVER_PORT`
Debug Mode	`DNA_IS_DEBUG`
Security Enable	`DNA_SECURITY_ENABLED`
API User	`DNA_USER`
API Password	`DNA_USER`
License	`DNA_DEFAULT_LIC`
Mongo Enabled	`DNA_DATABASE_ACTIVE`
Mongo URI	`DNA_DATABASE_URI`

5. Terraform-Based Infrastructure

5.1 Terraform Scope

Terraform is used to provision infrastructure only, including:

Compute (VMs or Kubernetes clusters)
Networking
Firewall rules / security groups
Persistent storage (optional MongoDB)
DNS and load balancing

Terraform does not build images and does not manage application internals.

6. Terraform – Single Node / Local Example

This example demonstrates local or single-node orchestration using a prebuilt image.

6.1 Providers

terraform {
  required_version = ">= 1.6.0"

  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "~> 3.0"
    }
  }
}

6.2 Variables

variable "jopt_image" {
  type    = string
  default = "dna-evolutions/jopt-touroptimizer:latest"
}

variable "jopt_port" {
  type    = number
  default = 8081
}

variable "cpu_limit" {
  type    = number
  default = 2
}

variable "memory_mb" {
  type    = number
  default = 4096
}

variable "jopt_license" {
  type      = string
  sensitive = true
}

6.3 JOpt Container Definition

resource "docker_container" "jopt" {
  name  = "jopt-touroptimizer"
  image = var.jopt_image

  ports {
    internal = 8081
    external = var.jopt_port
  }

  env = [
    "DNA_SECURITY_ENABLED=true",
    "DNA_DEFAULT_LIC=${var.jopt_license}",
    "DNA_DATABASE_ACTIVE=false"
  ]

  memory = var.memory_mb
  cpus   = var.cpu_limit
}

This model is suitable for:

Development
Proof-of-concepts
Controlled on-premise execution

7. Terraform + Kubernetes (Recommended for Production)

7.1 Responsibility Split

Layer	Responsibility
Terraform	Cluster, networking, IAM
Kubernetes	Scheduling, scaling, rollout
JOpt (Spring)	Optimization logic

Terraform provisions the cluster; Kubernetes runs JOpt.

7.2 Terraform Kubernetes Deployment (Excerpt)

resource "kubernetes_deployment" "jopt" {
  metadata {
    name = "jopt-touroptimizer"
  }

  spec {
    replicas = 2

    selector {
      match_labels = {
        app = "jopt"
      }
    }

    template {
      metadata {
        labels = {
          app = "jopt"
        }
      }

      spec {
        container {
          name  = "jopt"
          image = var.jopt_image

          port {
            container_port = 8081
          }

          resources {
            limits = {
              cpu    = "2"
              memory = "4Gi"
            }
            requests = {
              cpu    = "1"
              memory = "2Gi"
            }
          }

          env {
            name  = "DNA_SECURITY_ENABLED"
            value = "true"
          }
        }
      }
    }
  }
}