Quarkus & Micronaut Hosting on a Managed VM: Deploy JVM Apps Without the Ops Overhead

By /

Quarkus & Micronaut Hosting on a Managed VM: Deploy JVM Apps Without the Ops Overhead

Quarkus and Micronaut are the two leading modern Java frameworks for building fast, low-memory microservices and REST APIs — and they both need a real server to run on. This guide shows you how to deploy either framework on CM Cloud’s Cloud VPS, a managed virtual machine that gives you full root access without hiring a dedicated ops team.

If you missed our earlier comparison of JDK versions for production, check out JDK 17 vs 21 for Production Hosting: Which Java Version Should You Deploy in 2026? before choosing your runtime.

Why Quarkus and Micronaut Need a Real VM

Both frameworks are designed for cloud-native workloads. They compile fast, start in milliseconds (especially in native image mode), and consume far less heap than Spring Boot.

But they are still server-side processes — they bind to a port, handle HTTP traffic, and run continuously. Serverless or shared hosting environments that do not allow persistent processes will not work.

A managed VM (Cloud VPS) is the right environment: you get a persistent Linux machine, full control over the JDK, and the ability to run your app as a systemd service.

CM Cloud VPS: The Managed VM Built for Developers

CM Cloud’s Cloud VPS launches at $7.99/mo (XAF 5,000 / €7.40) and includes:

  • 2 vCPU / 4 GB RAM / 80 GB NVMe — enough headroom for Quarkus or Micronaut in JVM mode, or native image builds
  • Full root SSH access — install any JDK, set ulimits, configure systemd
  • NVMe storage — faster disk I/O for class-loading and native image unpacking
  • AI credits included free on every plan
  • No extreme lock-in commitment — month-to-month pricing

See the full plan details at cmcloudhosting.com/pricing.

Comparison: Managed VM Hosting for Quarkus / Micronaut Apps

Provider Starter Price (USD) XAF EUR Key Feature
CM Cloud VPS $7.99/mo XAF 5,000 €7.40 2vCPU/4GB/80GB NVMe, root SSH, AI credits, no lock-in
DigitalOcean Droplet $12.00/mo ~XAF 7,500 ~€11.10 1vCPU/1GB entry, more RAM at higher tiers
Hostinger VPS $6.99/mo (promo) ~XAF 4,375 ~€6.50 Promotional rate; renews at $12.99+/mo
Render (paid instance) $7.00/mo ~XAF 4,375 ~€6.50 No persistent disk; not ideal for native image binaries

Note on Hostinger pricing: The $6.99/mo promotional rate observed on their live pricing page applies to a 48-month commitment and renews at a significantly higher rate. CM Cloud’s $7.99/mo is the same price month-to-month.

Step 1: Provision Your Cloud VPS

Log in to CM Cloud, select Cloud VPS — Starter, and choose Ubuntu 22.04 LTS or Debian 12. Both have excellent JDK package support.

Once your VPS is live, SSH in as root:

ssh root@your-server-ip

Update the system before installing anything:

apt update && apt upgrade -y

Step 2: Install the JDK

For Quarkus in JVM mode, install JDK 21 (current LTS):

apt install -y openjdk-21-jdk
java -version

For Micronaut, JDK 17 or JDK 21 both work well. Micronaut’s annotation processor is slightly more sensitive to GC tuning, so JDK 21’s virtual threads (Project Loom) are worth targeting if your app uses blocking I/O.

For native image compilation (GraalVM), install GraalVM CE from graalvm.github.io and run gu install native-image. Allow 4–8 GB RAM and 5+ minutes for the native compile step — the Starter VPS handles it, but build on the server during low-traffic windows.

Step 3: Build and Transfer Your App

Quarkus — JVM mode

On your local machine:

./mvnw package -Dquarkus.package.type=uber-jar
scp target/my-app-runner.jar root@your-server-ip:/opt/myapp/

Quarkus — Native image

./mvnw package -Pnative -Dquarkus.native.container-build=true
scp target/my-app-runner root@your-server-ip:/opt/myapp/
chmod +x /opt/myapp/my-app-runner

Micronaut — Shadow JAR

./gradlew shadowJar
scp build/libs/my-app-all.jar root@your-server-ip:/opt/myapp/

Step 4: Run as a systemd Service

systemd is how you keep your Java app running across reboots and auto-restart it on crash. Create /etc/systemd/system/myapp.service:

[Unit]
Description=My Quarkus / Micronaut App
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/opt/myapp
ExecStart=/usr/bin/java -jar /opt/myapp/my-app-runner.jar
Restart=on-failure
RestartSec=5
Environment="JAVA_OPTS=-Xms256m -Xmx1g"

[Install]
WantedBy=multi-user.target

For a native binary, replace the ExecStart line:

ExecStart=/opt/myapp/my-app-runner

Enable and start:

systemctl daemon-reload
systemctl enable myapp
systemctl start myapp
systemctl status myapp

Your app is now supervised. If it crashes, systemd restarts it within 5 seconds.

Step 5: Put nginx in Front

Install nginx as a reverse proxy so you can terminate TLS and expose port 80/443 publicly while your app listens on an internal port (e.g., 8080):

apt install -y nginx certbot python3-certbot-nginx

Create /etc/nginx/sites-available/myapp:

server {
    listen 80;
    server_name api.example.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Enable the site and provision a free Let’s Encrypt certificate:

ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx
certbot --nginx -d api.example.com

Your Quarkus or Micronaut API is now live on HTTPS.

Step 6: Automate Deploys via CI/CD

For repeatable deploys from GitHub Actions, add an SSH deploy step:

- name: Deploy to VPS
  uses: appleboy/ssh-action@v1
  with:
    host: ${{ secrets.VPS_IP }}
    username: root
    key: ${{ secrets.VPS_SSH_KEY }}
    script: |
      scp -r target/my-app-runner.jar root@$HOST:/opt/myapp/
      systemctl restart myapp

Store your SSH private key as a GitHub Actions secret. This gives you a lightweight CI/CD pipeline without any proprietary build platform.

AI Credits: Included Free on Every CM Cloud Plan

Top-up Pack USD XAF EUR Credits
Starter pack $1.00 XAF 500 €0.93 25 credits
All plans Free credits Free credits Free credits Included

AI credits power CM Cloud’s AI Launch and site-builder features. They come free on every plan — including Cloud VPS.

Quarkus vs Micronaut: Which Is Easier to Host?

Quarkus Micronaut
Native image support First-class (GraalVM) Supported (GraalVM)
JVM startup time ~1s JVM, <50ms native ~200ms JVM
RAM (JVM mode) ~180–400 MB ~100–250 MB
Config style application.properties application.yml
Best for REST APIs, Kafka, Reactive Microservices, CLI, AWS Lambda

Both run identically on CM Cloud VPS — the VM does not care which framework produced the JAR or native binary.

Who This Setup Is For

  • Java developers in Cameroon and West Africa building APIs for fintech, logistics, or e-commerce backends
  • Teams migrating off Spring Boot to a lighter framework and wanting full control of the runtime
  • Startups who need predictable pricing — $7.99/mo flat, no surprise renewal jumps
  • Any developer who wants a persistent, supervised Java process without managing a Kubernetes cluster

Get Started Today

CM Cloud’s Cloud VPS gives you the managed VM, the NVMe storage, and the African-ready pricing you need to run Quarkus or Micronaut in production — starting at $7.99/mo (XAF 5,000 / €7.40).

No lock-in. No ops team required. No surprise renewal price.

View Cloud VPS plans at cmcloudhosting.com/pricing and launch your Java API today.

Scroll to Top