Private cloud platform on Ruckos Linux

Ruckos Cloud

Kubernetes, GitOps, observability and zero-trust security, plus the Ruckos developer tools, on any enterprise hardware, in your datacenter.

  • Kubernetes
  • GitOps
  • Observability
  • Zero trust
  • Developer tools
  • On-prem
Everything in Ruckos Cloud From the bottom up: Ruckos Cloud runs on bare metal, Ruckos Virtualization, Hyper-V or Azure. Ruckos Linux is the same immutable image on every node. On it run your Kubernetes clusters, dev, qa and prod. On those run the platform services: GitOps, observability, security, AI and a registry. On top are the developer tools: Sandbox, Renderer, git-drop and the Migration Assistant. It is managed with Ruckos-V Manager, rctl and Lighthouse. Developer tools Sandbox Renderer git-drop Migration Assistant Platform services GitOps Observability Security AI Registry Kubernetes Your clusters, kept matching Git dev qa prod Ruckos LinuxThe same immutable, signed image on every node Runs on Bare metal Ruckos Virtualization Hyper-V Azure Managed with Ruckos-V Manager rctl Lighthouse One platform, from the hardware up to the developer.
Cloud native defined

Cloud-native development allows your organization to build and run apps engineered to take advantage of cloud computing. Using modern architectures, technologies, and practices, teams can quickly ship cloud-native applications, update them as fast as customer needs change, and scale them on demand. Delivered with high availability and security, cloud-native systems operate in a variety of computing environments, including public, private, and hybrid clouds and on-premises infrastructure.

Complexities of hosting k8s

It's been a barrier for some organizations that don't have the expertise or resources to manage the complexities of hosting Kubernetes. We aim to simplify the process and provide a platform that allows organizations to focus on building and deploying their applications without worrying about the underlying infrastructure. Our platform is designed to be user-friendly, scalable, and secure, making it easier for teams to adopt cloud-native practices and take advantage of the benefits of cloud computing.

Integration

Easy to install,
simple to manage

Boot Ruckos Linux on bare metal, Ruckos Virtualization or Hyper-V, and it becomes a running Kubernetes cluster with GitOps, observability and security already installed. Developers self-serve from the portal.

Bootstrap

Bootstrap a private cloud in minutes

Ruckos automation bootstraps a private cloud and installs the platform services.

etcd node ×3

vCPU
2
Memory
4 GB
Disk
50 GB SSD

Control plane ×3

vCPU
4
Memory
8 GB
Disk
100 GB SSD

GPU worker LLM

GPU
NVIDIA RTX PRO 5000
VRAM
72 GB
Disk
1 TB NVMe
as Ruckos Linux VMs, on
Fleet

Manage, update, and deploy
across Kubernetes clusters

Create nodes and clusters, deploy from Git, and keep every cluster matching what's declared, from rctl or the Lighthouse web console.

Cluster engine

A container management and deployment engine built to give teams real control over the cluster. It doesn’t just scale — it gives you continuous visibility into exactly what is installed and running, monitored through GitOps so the live state always matches what’s declared in Git.

Fleet state stays declarative, visible, and reversible.

Deployment management

Deploy from Git using raw Kubernetes YAML, Helm charts, Kustomize, or any mix of the three. Every source is normalised into a Helm release and deployed through a single, consistent engine — giving you control, repeatability, and a full audit trail across every cluster.

Every path lands in the same repeatable delivery system.

Configuration management

Define policies and configuration once, then apply them across multiple clusters. Drift is detected and the live state reconciled back to Git, so you can be confident that every cluster is running exactly what you expect.

Policy and environment changes propagate without configuration sprawl.
GitOps

Automation
from the first boot

A root application fanning out to four child applications

App-of-Apps

A single root Application points at your cluster's folder in the gitops repo. From there ArgoCD owns everything — platform services, projects, and workloads all unfold declaratively.

Per-cluster folders scaffolded from a template, never overwritten

Platform Services

An opinionated, fixed set of services installed the same way on every cluster: cert-manager, an in-cluster registry, Keycloak, Grafana, Loki, and Tetragon — all governed by ArgoCD AppProjects.

Identical, drift-free deployments across every environment

Environment Fencing

AppProjects for dev, qa, prod, sandbox, and platform fence what each tier may deploy — sandbox is restricted to its own namespaces and a whitelist of resource kinds.

Least-privilege boundaries enforced by ArgoCD, not convention

Self-Service Provisioning

Developers provision workloads through a catalog. The platform renders manifests and commits them to git; ArgoCD detects the new path and syncs it live.

Provision → commit → sync → live, with git always authoritative
Ruckos tools

Tools for
every developer

Four small tools take a developer from nothing to a running service, or bring an existing project across.

Sandbox

Developer sandbox

Self-service catalog that provisions databases, caches and starter projects into each developer's own namespace. Sign-in is single sign-on through Keycloak, brokered to Active Directory.

  • .NET API
  • Postgres
  • MySQL
  • Redis
  • Neo4j

git-drop

Short-lived repos

Starter projects come prebuilt and open straight in VS Code through short-lived git-drop repos that expire on their own.

  • Clone link
  • Opens in VS Code
  • Expires on its own

Renderer

Manifest renderer

Scans a repo, builds a profile, validates it and renders Kubernetes manifests for dev, qa or prod, ready for GitOps.

  • ui
  • app
  • db
  • dev, qa, prod

Migration Assistant

Azure DevOps to GitHub

Moves a developer's Azure DevOps repositories to GitHub: clones them, creates and fills the new repos, and records the app's owner and details.

  • Azure DevOps
  • GitHub

Each tool is a container. It runs on Kubernetes, or natively on Ruckos Linux as a Ruckos Microservice.

Developer Experience

Built for
Microservices

Ruckos Platform makes it easy for developers and engineers to securely build and deploy containerized applications no matter what your devops or gitops experience is. We obscure all of the complexities so you can spend more time in the IDE.

Works with the tools you already love

The CLI tool seamlessly integrates with established CI/CD pipelines.

Confidently deploy complex microservices

Our powerful UI and CLI help you build complex workloads at scale, giving you easy access to your Kubernetes environments, hosts, stacks, services, and containers.

Maximize developer productivity

When cluster deployment and management is automated and immutable across clouds, on-prem, and the edge, developers can focus on writing code that delivers differentiating services — not the infrastructure that runs them.

Customization & extensibility

Customize and extend the Ruckos platform to fit specific use cases and development requirements with our extension catalog and integrations library.

Observability

See everything
running everywhere

Grafana dashboards, Prometheus metrics, and Loki logs converging into one view

Metrics & dashboards

Prometheus scrapes every workload and node; Grafana ships pre-loaded with dashboards for cluster health, GitOps sync status, and resource usage.

Centralized logging

Loki aggregates logs across every namespace and cluster so you can search and correlate without shipping data off-platform.

eBPF runtime visibility

Tetragon watches process execution, network flows, and file access at the kernel level, giving you security observability without sidecars or agents.

Alerting built in

Alert rules ship with the platform and route through Grafana, so you know about a failed sync or a struggling pod before your users do.

Security

Zero Trust
from the kernel up

RBAC is enforced at the API level, network policy is enforced at the kernel level, and every workload certificate is issued and rotated automatically.

eBPF policy enforcement

Tetragon enforces process, network, and file-access policy at the kernel level in real time — not just logging violations after the fact.

Zero-trust networking

Cilium enforces network policy and encrypts pod-to-pod traffic with eBPF — no service mesh, no sidecars, no added latency.

Automated certificate lifecycle

cert-manager issues and rotates every workload certificate from your own CA — no manual renewals, no expired certs taking down production.

Immutable attack surface

No SSH, no systemd, no package managers on nodes. A read-only root filesystem means nothing to patch and nowhere for an attacker to persist.

Leaf-spine network fabric connecting three nodes to two switches

Cilium

Cilium is the only networking layer on the cluster. It routes pods, replaces kube-proxy, terminates Gateway API traffic, and enforces identity-based network policy — all from eBPF programs attached to the datapath.

Hubble

Hubble reads flow data straight from Cilium's eBPF datapath. Every connection, DNS lookup, HTTP request, and policy drop is visible with the pod identity attached — without a packet capture or a sidecar.

Tetragon

Tetragon attaches eBPF programs to process, file, and network syscalls. It can observe them, or it can kill the process in the kernel before the syscall returns. The agent that marries those events to Kubernetes metadata runs once per node, not once per pod.

Business Value

Faster to market
ready for what's next

The platform allows operations teams to focus on infrastructure and developers to write code, Ruckos Platform helps you bring products to market faster and accelerate your organization's digital transformation.

Our Clients Achieve

32%
Infrastructure cost reduction
94% ↑
Deployment speed
99.999%
Infrastructure reliability
88% ↑
Operational efficiency
Ruckos Cloud

Easier to run,
smarter than ever

Private clouds are adapting to support Microservices and local LLMs. By using technology that simplifies how services and apps are packaged and managed, businesses can develop and launch software more efficiently across private, hybrid, and Azure clouds — making it easier to integrate new technologies, streamline workflows, and respond to changing business needs.

Reduce or eliminate VMware licensing

With Ruckos Linux, organizations can reduce or eliminate the need for costly VMware licensing, optimizing their IT budgets.

Reduce or eliminate virtual machine maintenance and cost

With Ruckos Linux, organizations can reduce or eliminate virtual machine maintenance, patching, and associated costs, streamlining IT operations.

Built for highly regulated industries

When organizations need full control over their infrastructure, single-tenant deployments are ideal. These setups are owned or dedicated entirely to one organization and can be hosted on-premises or off-premises.

Ruckos Hybrid Cloud

Extend capability,
into Microsoft Azure

Ruckos Hybrid Cloud allows organizations to extend their on-premises infrastructure into Microsoft Azure, enabling them to leverage the scalability and flexibility of the cloud while maintaining control over their data and applications. This hybrid approach provides the best of both worlds, allowing businesses to optimize their IT resources and respond quickly to changing demands.

Connect over VPN or ExpressRoute

Stand up an encrypted Site-to-Site VPN in minutes, or step up to a private ExpressRoute circuit for dedicated bandwidth and predictable latency that never touches the public internet.

Burst to GPU-enabled Azure VMs

Extend Ruckos onto Azure's NC- and ND-series GPU virtual machines for on-demand training and inference capacity, without buying, racking, or cooling GPU hardware yourself.

Offload managed data services

Point pipelines at Azure Databricks and other managed data services that were never meant to run on-prem, while Ruckos keeps compute, orchestration, and control on infrastructure you own.