Skip to main content
Servers Are Up
Virtual Datacenter
PricingFree Tools
Sign inBrowse catalog
Servers Are Up
Virtual Datacenter
PricingFree Tools
Sign inBrowse catalog
Servers Are Up

Your apps, automation and data on hardware we own. Build a private stack with predictable capacity and access through your dashboard, API or SSH.

SLA with service creditsOwned hardwareUS-based

Make room for your next idea

Explore the capacity, apps and access options that fit your workload. Check current availability and your total before you buy.

Sign up freeView Pricing

Products

  • Linux VPS
  • Windows VPS
  • Cloud & SaaS Services
  • Cloud Storage (Azure)
  • Virtual Datacenter
  • AI & Agent Hosting
  • Containers
  • Instant Apps
  • Software Platforms
  • Network builder
  • Game Servers
  • Pricing

Resources

  • Free Network Tools
  • 2026 Pricing Benchmark
  • Live SVG Badges
  • Latency & Speed Test
  • Guides & Tutorials
  • Documentation
  • API Reference
  • MCP Server
  • CLI & SDKs
  • OpenAPI & llms.txt
  • Use Cases
  • Free Migration
  • Uptime & Reliability
  • Datacenter
  • System Status
  • Network
  • Provider Comparisons Hub
  • Compare Providers

Company

  • About Us
  • Enterprise
  • Security Architecture
  • Trust Center
  • Blog
  • FAQ
  • Compliance
  • Startup Program
  • Open-Source Sponsorship
  • Press & Media Kit
  • Referral Program
  • Help Center
  • Contact Us
© Servers Are Up
TermsPrivacySLARefund PolicyDPAAcceptable Use
Service information
Back to Engineering BlogSystems, Linux & KVM
Servers Are Up Engineering·Published 2026-11-16·11 min read·Technical Review Verified

Java Hosting in Production: JVM Memory Anatomy, Generational ZGC, and Hardened Linux Deployment

hosting in java java hosting java website hosting host java website hosting for java web hosting services java

Engineering Summary & Direct Answer

Deploy Java 21+ services on Linux KVM without OOM kills: JVM off-heap memory math, Generational ZGC vs G1GC, virtual thread pinning, systemd, and Caddy TLS.

Instant 60s deploy · Browser SSH & WebRDP included
Deploy Linux VPS Compare Full PricingVirtual Datacenter Pools ($12–$380/mo)
On this page (7 sections)
  1. JVM Process Memory Anatomy on Linux KVM
  2. Java 21+ Garbage Collection: Generational ZGC vs. G1GC
  3. Virtual Threads (Project Loom) and the Carrier-Pinning Trap
  4. Hardened systemd Unit and cgroup v2 Containment
  5. Loopback Isolation and Caddy TLS 1.3 Reverse Proxy
  6. Sizing Java Deployments on Servers Are Up
  7. Frequently Asked Questions
  8. Why did the Linux OOM-killer kill my Java process when heap usage was only 75% of -Xmx?
  9. Should I set -Xms lower than -Xmx to save RAM on a single-app Linux VPS?
  10. When does G1GC outperform Generational ZGC on Java 21?
  11. How does Java game server sizing (such as PaperMC) differ from Spring Boot web apps?

Production Java outages on Linux virtual machines rarely begin inside application business logic; they overwhelmingly start with a mismatch between how the HotSpot JVM allocates virtual address space and how the Linux kernel accounts for resident physical memory. A classic failure pattern plays out across Spring Boot, Quarkus, Micronaut, and Jakarta EE deployments: an engineer provisions a 4 GB Linux KVM instance, sets -Xmx4g on the java command line, sees green health checks under synthetic smoke tests, and wakes up days later to Out of memory: Killed process (java) in journalctl -k. Because the Java object heap is only one segment of a JVM process's resident set size (VmRSS), assigning 100% of host RAM to -Xmx guarantees that class metadata, thread stacks, direct NIO buffers, JIT-compiled machine code, and garbage-collector data structures will push total RSS past physical memory and invoke the Linux kernel OOM-killer.

Running Java 21+ workloads reliably in production requires deterministic off-heap memory math, selecting the right collector between G1GC and Generational ZGC for your vCPU count, eliminating Project Loom virtual-thread carrier pinning, enforcing cgroup v2 boundaries in a hardened systemd unit, and terminating TLS 1.3 at a loopback-isolated reverse proxy.

JVM Process Memory Anatomy on Linux KVM

When the Linux kernel evaluates memory exhaustion, mm/oom_kill.c does not inspect JVM heap occupancy—it scores tasks by anonymous resident pages (AnonPages), page-table footprint, and swap consumption. For a HotSpot Java 21+ server process, steady-state resident memory follows the sum:

$$M_{\text{RSS}} = M_{\text{Heap}} + M_{\text{Metaspace}} + (N_{\text{threads}} \times S_{\text{stack}}) + M_{\text{Direct}} + M_{\text{CodeCache}} + M_{\text{GC}} + M_{\text{Native}}$$

Every non-heap component grows according to distinct runtime triggers that -Xmx never constrains:

  • Java Heap (-Xms / -Xmx or -XX:MaxRAMPercentage): Stores Java object instances. Once HotSpot commits heap regions and touches backing 4 KiB or 2 MiB transparent huge pages, those pages remain counted against VmRSS unless the collector explicitly uncommits idle memory back to the OS via madvise(MADV_DONTNEED).
  • Metaspace (-XX:MaxMetaspaceSize): Native memory holding loaded class metadata, constant pools, method counters, and annotations. Metaspace is uncapped by default. Frameworks heavy on runtime bytecode generation—Hibernate proxies, Jackson polymorphic serializers, Spring AOP advisors, and GraphQL schema generators—routinely consume 180–350 MB of Metaspace.
  • Platform Thread Stacks (-Xss): On 64-bit Linux, HotSpot reserves 1024 KB of virtual stack per OS platform thread, faulting physical 4 KiB pages on demand as call depth increases. A servlet container running 250 HTTP worker threads plus 80 Kafka consumer, Netty event-loop, and scheduled pool threads easily commits 150–250 MB of stack pages. Setting -Xss512k halves stack ceiling risk for typical web services without breaking standard recursion depths.
  • Direct NIO Buffers (-XX:MaxDirectMemorySize): Netty, Undertow, gRPC-Java, and modern HTTP clients allocate off-heap memory via ByteBuffer.allocateDirect() so socket writes avoid copying payloads out of GC-relocatable Java heap pages. Left unset, MaxDirectMemorySize defaults to -Xmx, meaning an unthrottled streaming upload or gRPC fan-out spike can legally attempt to double JVM RAM consumption.
  • JIT Code Cache (-XX:ReservedCodeCacheSize): Stores native x86_64 instructions emitted by the tiered C1 and C2 compilers. Defaults to 240 MB and stays pinned in RAM once hot call paths compile.
  • GC Bookkeeping and glibc Allocator Arenas: G1GC remembered sets (RSet) and card tables consume roughly 5–8% of total heap size; Generational ZGC multi-mapped page tables and forwarding structures add comparable native overhead. Simultaneously, GNU glibc malloc creates up to $8 \times \text{vCPU}$ native memory arenas by default to reduce lock contention, retaining fragmented native blocks from zlib compression (GZIPOutputStream), TLS OpenSSL/JNI buffers, or image libraries unless bounded via MALLOC_ARENA_MAX=2.

How should you choose between -XX:MaxRAMPercentage=70.0 and explicit -Xms/-Xmx? Inside container orchestrators where one OCI image deploys across staging (2 GiB) and production (8 GiB), -XX:InitialRAMPercentage=65.0 -XX:MaxRAMPercentage=70.0 lets HotSpot read cgroup v2 /sys/fs/cgroup/memory.max dynamically—remembering that MaxRAMPercentage bounds only the Java heap, not total RSS. On a dedicated Linux Cloud VPS with fixed RAM, setting -Xms equal to -Xmx at 60–65% of host RAM with -XX:+AlwaysPreTouch faults every heap page at boot rather than stalling live traffic during surges.

Instead of guessing from htop, enable HotSpot Native Memory Tracking (NMT) and diff allocations via jcmd:

# 1. Capture live JVM native memory breakdown by subsystem (~2% CPU overhead)
sudo -u javaapp jcmd $(pgrep -f java-api.jar) VM.native_memory summary scale=MB

# 2. Record a baseline after warmup, then inspect growth after 24 hours of traffic
sudo -u javaapp jcmd $(pgrep -f java-api.jar) VM.native_memory baseline
sudo -u javaapp jcmd $(pgrep -f java-api.jar) VM.native_memory summary.diff scale=MB

# 3. Compare HotSpot accounting against Linux kernel VmRSS, VmSwap, and THP pages
pid=$(pgrep -f java-api.jar)
awk '/VmPeak|VmRSS|RssAnon|VmSwap|Threads/ {printf "%-12s %s %s\n", $1, $2, $3}' /proc/"$pid"/status
grep -E 'AnonHugePages|ShmemPmdMapped' /proc/"$pid"/smaps_rollup

Java 21+ Garbage Collection: Generational ZGC vs. G1GC

Upgrading production runtimes to OpenJDK 21 LTS unlocks Generational ZGC (-XX:+UseZGC -XX:+ZGenerational), fundamentally changing latency engineering for JVM backends. Earlier single-generation ZGC had to scan the entire heap every collection cycle, demanding large CPU and heap-headroom budgets under high object-allocation rates. Generational ZGC partitions short-lived request allocations (JSON AST nodes, HTTP headers, DTOs, Hibernate query projections) from long-lived tenured caches, collecting young regions frequently with load/store colored-pointer barriers while keeping stop-the-world safepoint pauses consistently below 1 ms—even on 16–32 GB heaps.

Choosing between G1GC and Generational ZGC depends directly on your instance's vCPU concurrency and latency SLO:

  • 2 vCPU Instances (2–4 GB RAM, e.g., Linux Basic at $10/mo): Concurrent GC threads share the exact same two vCPU cores executing servlet filters, TLS encryption, and Jackson serialization. G1GC (-XX:+UseG1GC -XX:MaxGCPauseMillis=100) maintains a compact native footprint and higher raw request throughput per core when CPU cores are scarce, trading occasional 15–45 ms young/mixed evacuation pauses for lower background CPU burn.
  • 4–16 vCPU Instances (8–48 GB RAM, e.g., Linux Standard at $18/mo and Linux Pro at $28/mo): Concurrent ZGC worker threads (-XX:ConcGCThreads, typically $\approx 12.5%\text{–}25%$ of vCPUs) run alongside application carrier threads without starving request execution. Generational ZGC eliminates mixed-GC p99 latency cliffs completely. Ensure -Xmx provides at least 20–25% headroom above your steady-state live object set so concurrent relocation finishes before fast allocators exhaust free ZPages.

Virtual Threads (Project Loom) and the Carrier-Pinning Trap

Java 21 virtual threads (spring.threads.virtual.enabled=true in Spring Boot 3.2+) decouple request concurrency from OS kernel threads. Instead of dedicating one 1 MB OS thread to block idle for 40 ms awaiting a PostgreSQL query or upstream Stripe webhook, the JVM multiplexes tens of thousands of lightweight heap-allocated continuations onto a small ForkJoinPool of platform carrier threads (defaulting to Runtime.getRuntime().availableProcessors()).

Despite the ergonomics, enabling virtual threads blindly introduces two production failure modes if dependencies are not audited:

  1. Carrier Thread Pinning (synchronized + Blocking I/O): In Java 21, HotSpot cannot unmount a virtual thread from its underlying OS carrier thread if the call stack is currently inside a synchronized block or native JNI frame. If an older JDBC driver, legacy Apache Commons pool, or custom token-refresh cache wraps a blocking socket call inside synchronized (lock), just 4 concurrent slow calls on a 4 vCPU VM pin all 4 carrier threads, freezing health checks and unrelated endpoints across the entire JVM. Audit staging runs with -Djdk.tracePinnedThreads=short, replace synchronized around I/O paths with java.util.concurrent.locks.ReentrantLock, and verify modern Loom-ready drivers (org.postgresql:postgresql 42.7+).
  2. Downstream Resource Stampedes: Previously, a 200-thread Tomcat pool acted as an accidental concurrency limiter protecting your database and downstream REST dependencies. With virtual threads, 10,000 simultaneous inbound requests will happily spawn 10,000 virtual threads instantaneously. Keep HikariCP connection pools strictly bounded to database core capacity (maximum-pool-size: 16–32) and wrap external HTTP fan-out calls in explicit Semaphore bulkheads.
# /opt/javaapp/config/application-prod.yml
server:
  address: 127.0.0.1
  port: 8080
  shutdown: graceful
  tomcat:
    threads:
      max: 200 # Ignored for request workers when virtual threads are enabled
    accept-count: 512
    max-connections: 10000
    mbeanregistry:
      enabled: false

spring:
  threads:
    virtual:
      enabled: true
  lifecycle:
    timeout-per-shutdown-phase: 30s
  datasource:
    hikari:
      # Size to DB CPU cores (cores * 2 + effective disks), NEVER to HTTP concurrency
      maximum-pool-size: 20
      minimum-idle: 20
      connection-timeout: 2500
      validation-timeout: 1000
      max-lifetime: 1800000

management:
  server:
    address: 127.0.0.1
    port: 8081
  endpoints:
    web:
      exposure:
        include: health,prometheus,threaddump

Hardened systemd Unit and cgroup v2 Containment

Starting a production JAR via nohup or screen leaves the daemon running with unconfined filesystem write permissions, default 1024/4096 file descriptor limits on some PAM paths, and ungraceful teardown during host reboots. A hardened systemd unit binds cgroup v2 MemoryHigh (soft reclaim backpressure) below MemoryMax (hard cgroup limit), isolates /usr and /etc read-only via ProtectSystem=strict, strips Linux capabilities, and acknowledges JVM exit code 143 (128 + SIGTERM) so Spring's 30s graceful drain finishes in-flight transactions cleanly.

# /etc/systemd/system/java-api.service
[Unit]
Description=Production Java 21 Spring Boot API
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=javaapp
Group=javaapp
WorkingDirectory=/opt/javaapp
Environment="MALLOC_ARENA_MAX=2"
EnvironmentFile=/etc/javaapp/java-api.env

# Tuned for Linux Standard ($18/mo: 4 vCPU, 8 GB RAM, 160 GB persistent storage)
# Budget: 4800M Heap + 256M Metaspace + 512M Direct + 240M CodeCache + ~600M GC/Stacks = ~6.4 GB max RSS
ExecStart=/usr/lib/jvm/temurin-21-jdk-amd64/bin/java \
  -server \
  -XX:+UseZGC \
  -XX:+ZGenerational \
  -Xms4800m \
  -Xmx4800m \
  -XX:+AlwaysPreTouch \
  -XX:MaxMetaspaceSize=256m \
  -XX:MaxDirectMemorySize=512m \
  -XX:ReservedCodeCacheSize=240m \
  -Xss512k \
  -XX:+ExitOnOutOfMemoryError \
  -XX:ErrorFile=/var/log/javaapp/hs_err_pid%p.log \
  -Xlog:gc*,safepoint:file=/var/log/javaapp/gc.log:time,uptime,level,tags:filecount=5,filesize=20M \
  -jar /opt/javaapp/java-api.jar \
  --spring.config.additional-location=file:/opt/javaapp/config/application-prod.yml

# HotSpot exits with 143 on SIGTERM after graceful shutdown hooks complete
SuccessExitStatus=143
TimeoutStopSec=35
Restart=on-failure
RestartSec=3s

# cgroup v2 memory guardrails (leaves >1.2 GB for OS kernel, page cache, and Caddy)
MemoryHigh=6500M
MemoryMax=6900M
LimitNOFILE=65535

# Filesystem & privilege sandboxing
NoNewPrivileges=true
PrivateTmp=true
PrivateDevices=true
ProtectSystem=strict
ProtectHome=true
ProtectKernelTunables=true
ProtectControlGroups=true
ReadWritePaths=/var/log/javaapp /var/lib/javaapp

[Install]
WantedBy=multi-user.target

Always include -XX:+ExitOnOutOfMemoryError. Once a thread throws OutOfMemoryError, internal executors or Netty arenas can remain wedged while /health still returns 200 OK; exiting immediately lets systemd respawn a clean JVM while preserving /var/log/javaapp/gc.log.

Loopback Isolation and Caddy TLS 1.3 Reverse Proxy

Exposing Tomcat or Netty directly on port 443 forces you to manage PKCS12 keystores and absorb slow-client TLS handshakes inside JVM buffers. Binding your app to 127.0.0.1:8080 behind Caddy automates certificate rotation, negotiates HTTP/3 (QUIC) and zstd compression, and isolates actuator port 8081 from external interfaces:

# /etc/caddy/Caddyfile
api.example.com {
    encode zstd gzip

    # Explicitly reject external requests to management paths even if misconfigured upstream
    @internal path /actuator* /internal* /swagger-ui*
    respond @internal 403

    reverse_proxy 127.0.0.1:8080 {
        health_uri /actuator/health/readiness
        health_port 8081
        health_interval 10s
        health_timeout 2s
        header_up X-Real-IP {remote_host}
        transport http {
            keepalive 90s
            keepalive_idle_conns 256
        }
    }

    header {
        Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
        X-Content-Type-Options "nosniff"
        X-Frame-Options "DENY"
        -Server
    }

    log {
        output file /var/log/caddy/java-api-access.json {
            roll_size 50MiB
            roll_keep 5
        }
        format json
    }
}

Sizing Java Deployments on Servers Are Up

Whether you ship an executable JAR onto a dedicated Ubuntu 24.04 KVM server or build a container directly from GitHub, size the host by calculating target live heap plus a 35–40% off-heap and OS reserve:

Servers Are Up Tier Allocation Monthly Price Recommended Heap (-Xms/-Xmx) Recommended Collector Ideal Production Workload
Custom GitHub App 2 vCPU, 4 GB RAM, 50 GB persistent storage $10/mo 2200m (MaxRAMPercentage=60.0) -XX:+UseG1GC Containerized Spring Boot / Quarkus microservice built automatically from GitHub
Linux Basic 2 vCPU, 4 GB RAM, 80 GB persistent storage $10/mo 2400m -XX:+UseG1GC Single JVM REST API, Caddy TLS reverse proxy, and scheduled cron workers
Linux Standard 4 vCPU, 8 GB RAM, 160 GB persistent storage $18/mo 4800m -XX:+UseZGC -XX:+ZGenerational Sub-millisecond pause APIs, virtual-thread gateways, and co-located Redis cache
Linux Pro 8 vCPU, 16 GB RAM, 320 GB persistent storage $28/mo 10240m -XX:+UseZGC -XX:+ZGenerational High-concurrency JVM monoliths, Kafka stream processors, or OpenSearch nodes

Teams operating separate API, background worker, and PostgreSQL instances can also allocate from a pooled Virtual Datacenter (Developer Studio at $24/mo for 8 vCPU / 16 GB RAM, or Team Workspace at $95/mo for 24 vCPU / 64 GB RAM) and tail gc.log side by side with jcmd diagnostics in the browser SSH console. If you package your JVM inside multi-stage OCI images instead of systemd units, pair these heap rules with our production Docker container hosting guide and server capacity planning methodology.

Frequently Asked Questions

Why did the Linux OOM-killer kill my Java process when heap usage was only 75% of -Xmx?

HotSpot commits virtual pages up to -Xmx regardless of current live object occupancy, and the Linux kernel adds Metaspace (~250 MB), JIT Code Cache (240 MB), direct NIO buffers, thread stacks, GC card/forwarding tables, and glibc native arenas on top. On a 4 GB VM, -Xmx3200m routinely exceeds 4.1 GB total RSS under load. Cap -Xmx to 60–65% of physical RAM (2400m on 4 GB; 4800m on 8 GB) and explicitly bound -XX:MaxMetaspaceSize and -XX:MaxDirectMemorySize.

Should I set -Xms lower than -Xmx to save RAM on a single-app Linux VPS?

On a dedicated single-app VPS, set -Xms equal to -Xmx with -XX:+AlwaysPreTouch. Dynamic heap resizing adds safepoint overhead during traffic bursts without saving host RAM, since the VM's memory is already dedicated to your kernel.

When does G1GC outperform Generational ZGC on Java 21?

On small 1–2 vCPU servers (Linux Starter $6/mo or Linux Basic $10/mo) where every CPU cycle spent on concurrent ZGC barrier/relocation threads directly reduces HTTP request throughput, G1GC achieves higher requests per second with lower native memory overhead, provided your latency SLO tolerates 20–50 ms GC pauses. Once you reach 4+ vCPUs (Linux Standard $18/mo and up), Generational ZGC eliminates tail-latency spikes cleanly.

How does Java game server sizing (such as PaperMC) differ from Spring Boot web apps?

Web APIs scale horizontally across all vCPUs via virtual or platform worker pools, making total RAM and multi-core concurrency primary bottlenecks. Tick-based Java game servers execute primary world entity and chunk logic on a single main tick thread (50 ms budget for 20 TPS), meaning Intel Xeon single-core IPC and Generational ZGC / Aikar G1GC pause discipline matter far more than raw core counts above 4–6 vCPUs.

US-Owned Dell PowerEdge R940 KVM Infrastructure

Test & Run Production Workloads on Predictable KVM Compute

Linux VMs from $6/mo · 4 vCPU / 8 GB ECC RAM $18/mo · 8 vCPU / 16 GB RAM $28/mo · Pooled Virtual Datacenters from $12/mo with built-in Browser SSH & WebRDP.

Deploy Linux VPS Compare Full Pricing

Explore With AI & Cite This Page

Open a grounded prompt in your AI assistant or copy a clean Markdown, HTML, or APA reference link.

Ask ChatGPT Ask Perplexity Ask Claude
Share:HN·Reddit·X·LinkedIn
Newer Article

Secure Remote Access to Your Servers From a Browser

Older Article

Inside Managed Cloud Storage on ServersAreUp: Client-Side AES-256-GCM Double-Envelope Encryption, Azure Geo-Redundancy & WORM Immutability

Related Diagnostic Tools & Engineering Guides

Validate protocols and subnets directly in your browser or continue reading related architecture notes.

Free Browser Tool

Cron to Systemd .timer & .service Generator

Launch utility
Free Browser Tool

Free IP Subnet Calculator & CIDR Cheat Sheet

Launch utility
Free Browser Tool

Unix Timestamp Converter & Ms to Minutes

Launch utility

Best Cheap VPS Hosting Providers (2026): Exposing Prepay Traps, CPU Steal, and Benchmarking Real Value

How to evaluate affordable Linux VPS providers in 2026 by real month-to-month vCPU, RAM, and disk IOPS—exposing 36-month prepay traps, CPU steal (%st), and comparing ServersAreUp ($6/$10/$18) vs DO, Vultr, Linode, and Hetzner.

Cloud Hosting Advantages and Disadvantages: Elasticity vs. Egress Taxes, CPU Steal & Repatriation

An engineering breakdown of cloud hosting pros and cons: programmable APIs, snapshots, and remote consoles versus hyperscaler egress markups, %st CPU steal, IAM sprawl, and hybrid repatriation.

Website Hosting Infrastructure Architecture: From Edge Static & cPanel LVE to Isolated KVM VPS, K3s & Cloud Blob Storage

A systems architecture comparison of website hosting tiers: CDN static PoPs, CloudLinux cPanel LVE throttling, serverless PaaS, isolated KVM Linux VPS, K3s clusters, and Azure-backed /cloud-storage.

Docker Container Hosting in Production: Daemon Hardening, UFW Port Traps, Compose Limits, and Security

Run Docker containers safely in production: compose.yaml cgroup limits, daemon.json live-restore, fixing the UFW 0.0.0.0 port-binding bypass, and non-root builds.

On this page

  1. JVM Process Memory Anatomy on Linux KVM
  2. Java 21+ Garbage Collection: Generational ZGC vs. G1GC
  3. Virtual Threads (Project Loom) and the Carrier-Pinning Trap
  4. Hardened systemd Unit and cgroup v2 Containment
  5. Loopback Isolation and Caddy TLS 1.3 Reverse Proxy
  6. Sizing Java Deployments on Servers Are Up
  7. Frequently Asked Questions
  8. Why did the Linux OOM-killer kill my Java process when heap usage was only 75% of -Xmx?
  9. Should I set -Xms lower than -Xmx to save RAM on a single-app Linux VPS?
  10. When does G1GC outperform Generational ZGC on Java 21?
  11. How does Java game server sizing (such as PaperMC) differ from Spring Boot web apps?
Self-Serve Infrastructure

Test & Run Production Workloads on Predictable KVM Compute

Linux VMs from $6/mo · 4 vCPU / 8 GB ECC RAM $18/mo · 8 vCPU / 16 GB RAM $28/mo · Pooled Virtual Datacenters from $12/mo with built-in Browser SSH & WebRDP.

Deploy Linux VPS Compare Full Pricing