🚀 OrbitDeck: A Full-Stack Kubernetes-Native Deployment & Analytics Platform

Overview

OrbitDeck is a full-featured, Kubernetes-native deployment automation and analytics platform. Designed to offer seamless microservice deployment, monitoring, and insights, OrbitDeck leverages Go, Spring Boot, React, Redis, PostgreSQL, and Kubernetes to deliver a production-ready, cloud-native experience.

This blog post offers an in-depth look into the architecture, implementation strategies, and technologies behind OrbitDeck — perfect for developers looking to explore distributed systems, infrastructure automation, and cross-service analytics.

🧱 Architecture at a Glance

OrbitDeck is split into 3 major services:

The services interact through structured APIs and Redis Pub/Sub for event propagation. All components are containerized and deployed via Helm charts on Kubernetes.

🧠 Backend (Go): Deployment Engine & Queue Orchestration

1. Service Responsibilities

• Accept deployment configurations (including components, resources, env, and ingress).
• Queue Helm chart deployments using Asynq.
• Emit detailed structured events to Redis Pub/Sub.
• Track and expose task progress using Asynq Inspector API.
• Apply RBAC using Paseto tokens and cookies.

2. Task Processing via Asynq

• Tasks like generate_helm and uninstall_helm are handled by worker processes.
• Queued tasks are processed asynchronously and report state back.
• Redis is used as both the broker and status store.

// Go backend example: Queue a task
task := asynq.NewTask("generate_helm", payload)
asynqClient.Enqueue(task, asynq.Queue("generate"))

3. Task Status Polling

• Each deployment stores the Asynq task ID.
• The frontend polls /deployment/:id/status to show live updates.
• State transitions (pending, active, completed, failed) drive frontend UX.

4. Event Publishing to Redis Pub/Sub

Events are published for:

• Deployment creation
• Helm success/failure
• Component addition
• Uninstall initiation

These events are pushed to the orbitdeck:events Redis channel.

publisher.PublishDeploymentEvent(ctx, publish.EventPayload{
  EventType: "component_added",
  DeploymentID: id,
  Repository: "nginx",
  Meta: componentData,
  Timestamp: time.Now().Unix(),
})

📊 Analytics (Spring Boot): Logging & Metrics Service

1. Event Subscription

• A RedisMessageListenerContainer subscribes to orbitdeck:events.

@RedisListener(channel = "orbitdeck:events")
public void handle(String raw) {
    DeploymentEvent event = objectMapper.readValue(raw, DeploymentEvent.class);
    EventLog log = new EventLog(...); // includes userEmail, component, status, timestamp
    eventRepo.save(log);
}

• Each JSON message is parsed and mapped to EventLog JPA entities.

2. Database Logging

• Logs structured metadata like:
  • DeploymentID
  • Component name and resource usage
  • Event type
  • User email
  • Timestamps

objectMapper.readValue(payload, DeploymentEvent.class);
    eventLogRepo.save(new EventLog(...));

3. Insightful Endpoints

REST endpoints like:

• /events/recent
• /events/stats
• /events/component/usage
• /events/errors
• /events/timeline

provide real-time, user-specific insights to the frontend.

🌐 Frontend (React): Dashboard & Deployment UI

1. Dynamic Form-Based Deployment

• Users can add multiple components.
• Each component can configure:
  • Image & tag
  • Resource limits/requests
  • Environment variables
  • Ingress rules

2. Live Deployment Status

• Polls Asynq task status for in-progress deployments.
• Status badges are animated and automatically update to “installed” or “failed”.
• Gracefully falls back to DB-stored status if Asynq task no longer exists.

3. Analytics Page

• Timeline of deployment activity
• Top components & most-used repositories
• Deployment success/failure breakdown
• Real-time polling of active events

4. User Profile & Auth

• Cookie-based session using Paseto.
• Profile page summarizes user-specific analytics.
• Logout, token refresh, and role-based filtering supported.

🚢 Kubernetes, Docker & Helm

Each service is containerized:

• Go Core Service : orbitdeck-core
• Spring Boot Analytics : orbitdeck-analytics
• React Frontend : orbitdeck-client
• PostgreSQL, Redis as base infrastructure

All are deployed via Helm charts using Skaffold in dev mode:

skaffold.yaml>
 - core-svc
 - analytics-svc
 - client-svc

Ingress routing is handled via nginx.ingress.kubernetes.io/rewrite-target.

☁️ Terraform + Azure AKS Infrastructure OrbitDeck is deployed on Azure using Terraform to provision:

✅ Azure Kubernetes Service (AKS)

✅ Azure AD Group for RBAC

✅ Autoscaling node pools

Example: azurerm_kubernetes_cluster

resource "azurerm_kubernetes_cluster" "aks_cluster" {
  name                = "${azurerm_resource_group.aks_rg.name}-cluster"
  location            = azurerm_resource_group.aks_rg.location
  resource_group_name = azurerm_resource_group.aks_rg.name
  dns_prefix          = "${azurerm_resource_group.aks_rg.name}-cluster"

  default_node_pool {
    name                 = "systempool"
    vm_size              = "Standard_DS2_v2"
    enable_auto_scaling  = true
    min_count            = 1
    max_count            = 3
  }

  identity {
    type = "SystemAssigned"
  }

  azure_active_directory_role_based_access_control {
    managed                = true
    admin_group_object_ids = [azuread_group.aks_administrators.id]
  }

  oms_agent {
    log_analytics_workspace_id = azurerm_log_analytics_workspace.insights.id
  }

  tags = {
    Environment = var.environment
  }
}

You can spin up an entire production-grade AKS cluster with autoscaling and monitoring in just one command: terraform apply.

🔐 Authentication

OrbitDeck uses:

• Paseto tokens (stored in secure cookies)
• Gin middleware to enforce auth
• Tokens passed via header or cookie
• Shared claims used to personalize backend responses

📈 What’s Logged for Analytics?

These events are filtered and visualized in the React analytics dashboard.

✨ Final Thoughts

OrbitDeck was to combine developer-friendly deployment with real-time observability . It demonstrates:

• Inter-service communication via Redis Pub/Sub
• Task orchestration via Go + Asynq
• Decoupled analytics layer via Spring Boot
• Dynamic multi-component form-based deployment UX
• Full PaaS-like functionality — built from scratch

The codebase is modular and can be extended to support:

• Canary deployments
• Role-based dashboards
• GitOps pipeline integration

If you're interested in the project or want to contribute, feel free to check out the OrbitDeck GitHub Repo or drop me a message on LinkedIn.