How Miget Fair Scheduler Works

Running multiple applications efficiently on a single resource plan isn't just about containerization - it's about intelligent resource management. Miget's Fair Scheduler is the engine that makes "One Resource. Unlimited Apps." possible.

Here's how it works.

Secure: Workload Isolation on Dedicated Kubernetes Nodes

Each of your applications runs on a different physical Kubernetes node.

This isolation ensures that no single application can monopolize resources, providing stability and consistent performance across all your deployments.

Why This Matters

Security: Applications are physically separated, reducing attack surface
Performance: No noisy neighbor problems - your app's performance isn't affected by others
Reliability: If one node experiences issues, your other apps continue running unaffected

# Example: Your apps distributed across nodes
stress2-ral21-web-7fe7ddfdc-pn4r7    1/1   Running   0   40m   10.42.3.142   kube-node34
stress1-n1lps-web-67e4ddcfc6-gzztq   1/1   Running   0   40m   10.42.3.142   kube-node17
stress2-ral21-web-7fe7ddfdc-pn4r7    1/1   Running   0   40m   10.42.4.135   kube-node22

Each deployment runs on its own dedicated node, ensuring complete isolation.

The Miget Fair Scheduler dynamically allocates CPU resources between your applications based on their real-time needs.

Let's look at a real example using a 1 vCPU plan (1 CPU, 2 GiB RAM) with two applications:

Application A: Web Server

Resource Demand: 0.6 CPU and 1 GiB RAM
Behavior: Handles HTTP requests with occasional CPU spikes during peak traffic

Application B: Background Worker

Resource Demand: 0.4 CPU and 600 MiB RAM
Behavior: Processes background jobs at steady load, occasionally needs more CPU for intensive tasks

How Dynamic Allocation Works

Idle State:

Both applications share the CPU equally, each receiving 0.5 CPU
If Application A is idle, Application B can utilize up to 1.0 CPU, and vice versa

High Demand Period:

During peak traffic, Application A demands more CPU (e.g., 0.8 CPU)
The Fair Scheduler adjusts by allocating 0.8 CPU to Application A and 0.2 CPU to Application B
This ensures the web server remains responsive while the background worker continues operating
When demand subsides, allocation reverts to a balanced state

Burst Handling:

If both applications spike simultaneously, the scheduler ensures fair distribution based on configured limits and current demands
Each receives a portion of the 1.0 CPU, adjusted dynamically to maintain overall system performance

The Result: No wasted resources. Apps that need CPU get it. Apps that don't need it don't hog it. Everyone gets a fair share based on actual demand.

Non-Disruptive Limit Adjustments

Miget CPU Scheduler allows you to adjust the CPU limits of your applications without restarting them.

This means you can dynamically change resource allocations on the fly, ensuring seamless operation and uninterrupted service, providing you with the flexibility to adapt to varying workloads effortlessly.

Dedicated CPU in Pro Plans

For applications that require guaranteed, non-shared CPU resources, Miget Pro plans offer dedicated CPU allocation.

What's the difference?

Hobby Plans: CPU is shared fairly among your apps using the Fair Scheduler. Apps can burst and share resources dynamically.
Pro Plans: Each app gets dedicated CPU cores that are never shared with other applications. Your app always has its full CPU allocation available.

When to use Dedicated CPU:

Production workloads requiring consistent performance
CPU-intensive applications (video processing, ML inference, data analysis)
Applications with strict SLA requirements
Workloads that can't tolerate any CPU contention

With dedicated CPU, you get predictable, isolated performance - perfect for mission-critical applications.

CPU Cap: Fine-Grained Resource Control

Sometimes you want to limit how much CPU a specific application can use, even if more resources are available. That's where CPU caps come in.

How CPU Caps Work:

You can set a maximum CPU limit for any application, telling the Fair Scheduler not to allocate more than that limit - even during idle periods when extra CPU is available.

CPU Cap Example