Native microservices on Ruckos Linux

Ruckos Microservices

Run containers directly on Ruckos Linux. Ruckos places each service across the cluster, keeps it at the size you set, and puts it behind one address with Ruckos LB. Kubernetes runs alongside when you want it.

  • Native containers
  • Built-in scheduler
  • Ruckos LB
  • Live scaling
  • Rolling upgrades
  • Kubernetes alongside
Ruckos places a service across the cluster A service called web asks for three replicas. The Ruckos scheduler places web-1 on host 1, web-2 on host 2 and web-3 on host 3. All three are healthy and sit behind one Ruckos LB address. Host 1 Host 2 Host 3 Service: web 3 replicas, 0.5 CPU, 512 MB Ruckos scheduler one for the cluster, on any host web-1 healthy web-2 healthy web-3 healthy Ruckos LB one address for the healthy replicas 203.0.113.1 : 443 Replicas are spread across the hosts that have room for them.
Placed by the scheduler Starting, moving or upgrading
Ruckos Microservices

One platform
for containers and VMs

Run a container where it fits best: directly on the host, inside a VM, or on Kubernetes. All three run on the same Ruckos Linux hosts and are managed through the same API.

Native containers

Containers run directly on Ruckos Linux through containerd, on the host's own kernel. Nothing sits between the service and the hardware.

  • No guest operating system to boot or patch
  • CPU and memory change while it runs
  • Moves to another host while running

Containers in a VM

When a workload needs its own kernel and its own boundary, give it a Ruckos Linux VM on KVM and run its containers inside.

  • A separate kernel for each VM
  • Created from the same console and CLI
  • Runs beside your Linux and Windows VMs

Kubernetes alongside

Kubernetes clusters run on the same hosts, on bare metal or in VMs, and Ruckos Cloud delivers the platform stack through GitOps.

  • Bare-metal or VM nodes
  • A cluster in about two minutes
  • Ruckos Cloud and Lighthouse on top
Services

Say how many,
Ruckos keeps them running

A service is an image, a size and a replica count. Ruckos places the replicas across the cluster, replaces the ones that fail, and upgrades them without taking the service down.

rctl
# three replicas of one image, behind one address
$ rctl service create 192.168.1.11 --name web \
    --image web.tar --replicas 3 \
    --cpus 0.5 --memory 512M \
    --store nfs1 --load-balancer web \
    --max-per-host 1

# later: more replicas, more memory, a new image
$ rctl service scale 192.168.1.11 web 5
$ rctl service set 192.168.1.11 web --memory 1G
$ rctl service upgrade 192.168.1.11 web --image web-2.tar
Image and replicas
Pick the image and how many. Replicas are named and numbered: web-1, web-2, web-3.
CPU and memory
Set for each replica, and changed later while they run.
Store
Shared storage that every host mounts, so a replica can run on any host.
Load balancer
The address the replicas join as they become healthy.
Placement
Placed where the CPU, memory and storage fit, spread across hosts first, with a limit per host that you set.
CPU features
Matched to the CPU features the image needs.
Running it

Scale, upgrade and recover
while it stays up

One scheduler for the cluster keeps every service at its count, with automatic takeover if the scheduler's own host is lost.

Scale

  • Scale out: change the replica count
  • Scale up: change CPU and memory live
  • No restart for a resize
  • Applied to every replica at once

Upgrades

  • A new image, one replica at a time
  • Each new replica is healthy before the next one starts
  • Start the new one first, or replace in place
  • The service stays up throughout

Failover

  • Health checks on every replica
  • A lost host's replicas start on other hosts
  • Draining a host moves its workloads first
  • Unhealthy replicas leave the load balancer
Storage and databases

State that outlives
the host it ran on

Stateless services and databases run the same way. The storage and the balancing you pick decide what follows a replica to its next host.

Shared storage

A service lives on a shared store that every host mounts, so its replicas can run on any of them.

  • A lost host's replicas run elsewhere
  • A running container moves without copying its files

A disk for each replica

Give each replica its own data disk. A replacement picks up the disk of the replica it replaces.

  • Optional, sized for the service
  • Follows the replica to its new host
  • A damaged disk is kept, never deleted for you

A primary and its standbys

For databases, one replica takes all the traffic and the others stand ready to take over.

  • Each replica is told its role when it starts
  • Your promote command runs on failover
  • Upgrades do the standbys first, the primary last
Ruckos LB

One address
for every service

Every service gets one stable address. Ruckos LB spreads its connections across the healthy replicas, on whichever hosts they run. It is part of Ruckos Linux: there is no appliance to add and nothing extra to install.

Spread

Each connection goes to any healthy replica.

For stateless APIs and web tiers

Sticky

Every connection from one client reaches the same replica.

For front ends and apps that keep sessions

Primary

All traffic goes to one replica, with a standby ready.

For databases and other single-writer services
Management

The tools you have,
one API

Services and their load balancers are managed with the tools that already manage your hosts and VMs.

Ruckos products

Built to work together

One operating system underneath all of them.