Oracle Cloud Minecraft Server: 13 Steps to $0/Mo [2026]

Running a Minecraft server for a few friends used to mean leaving a spare PC on 24/7 or paying a hosting company $8 to $15 a month for a box you never fully control. Oracle Cloud Infrastructure (OCI) offers a third option that has quietly become one of the most searched setups among self-hosters in 2026: an Ampere A1 Arm compute instance that stays free for the life of the account, with no trial period and no credit card charge once it is running. This tutorial walks through the entire process, from account creation to a 24/7 systemd-managed Paper server with automated backups, using the current Always Free allocation and the latest Minecraft Java Edition release.

·

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

Why Host Your Own Minecraft Server on Oracle Cloud

Oracle Cloud’s Always Free tier is unusual among the major clouds because it is not a 12-month trial. AWS, Google Cloud, and Microsoft Azure all offer free credits or time-limited free instances that expire, after which the meter starts running whether or not anyone is paying attention. Oracle’s Ampere A1 Arm compute allocation, by contrast, is designed to stay free indefinitely in the account’s home region, which is exactly the kind of guarantee a hobby Minecraft server needs. You are not racing a 365-day countdown before the bill arrives.

That durability is also why so many parents and hobbyists have migrated home-hosted servers to OCI over the past few years. Ampere Computing, the company that designs the Arm chips behind the A1 shape, has publicized real user stories about the move. One parent referenced in an Ampere Computing post described the switch directly: “My 14yr old migrated his Minecraft server to @AmpereComputing A1 instances on @OracleCloud and things are working great and saving me about $75/yr on power costs vs an old physical server at home.” The same post quoted the parent again on the broader appeal: “I’m loving the ‘always free’ tier at Oracle Cloud!” Those numbers will vary by household electricity rate, but the pattern, a server that used to run on hardware at home moving to a free cloud instance, is the exact workflow this guide builds.

There is a tradeoff worth stating up front: Oracle reduced the Always Free Ampere A1 allocation in June 2026, cutting it from the long-advertised 4 OCPUs and 24 GB of RAM down to 2 OCPUs and 12 GB of RAM. That is still enough for a small-to-medium survival server with plugins, but it changes the planning math compared to older tutorials still floating around the web. Every spec in this guide reflects the post-cut allocation, not the legacy numbers.

What Oracle Cloud’s Always Free Tier Actually Gives You in 2026

Before touching the console, it helps to know exactly what “free” covers, because the Ampere A1 shape is metered in OCPU-hours and GB-hours rather than a flat instance count. According to Oracle’s own Always Free Resources documentation, the account-wide Ampere A1 allowance is 1,500 OCPU-hours and 9,000 GB-hours per month, which works out to roughly 2 OCPUs and 12 GB of memory running continuously for an entire month. You can split that budget across one or two smaller instances if you want to separate the Minecraft server from, say, a lightweight monitoring box, but for this tutorial everything goes into a single instance to keep things simple.

Storage and networking also come with Always Free allowances. Every OCI compute instance needs a boot volume of at least 47 GB regardless of shape, and the account-wide Always Free block storage allowance is 200 GB total, which includes boot volumes, plus five free volume backups. Those backups matter later when automating world saves. Oracle also states that Always Free resources remain free in the tenancy’s home region for the life of the account, and that Ampere A1 instances can be created in any availability domain except South Korea North (Chuncheon).

Resource	Always Free allowance (post-June 2026)	Why it matters for Minecraft
Ampere A1 OCPU	2 OCPUs (1,500 OCPU-hours/month)	Handles world generation and tick processing for 5-10 concurrent players
Ampere A1 memory	12 GB RAM (9,000 GB-hours/month)	Enough to allocate 6-8 GB to the JVM heap and leave room for the OS
Block storage	200 GB total, including boot volumes	Covers the OS boot volume plus world saves and plugin data
Boot volume minimum	47 GB per instance	Required floor regardless of shape; leaves roughly 150 GB free for worlds and backups
Volume backups	5 free backups	Lets you snapshot the boot volume before risky plugin or version upgrades
Region scope	Home region only, any availability domain except Chuncheon, South Korea	Determines where latency will be lowest for your player base

One more policy detail that catches people off guard: Oracle has reportedly reclaimed or stopped Always Free compute instances that sit below roughly 20% utilization over a rolling week, treating them as idle. A Minecraft server with a handful of regular players rarely trips that threshold during active hours, but an empty server left running for weeks with zero logins theoretically could. Keep at least occasional activity on the instance, or treat that policy as one more reason to actually play on the server you just built.

Oracle Cloud vs. Paid Minecraft Hosts vs. Running It at Home

It is worth comparing the three realistic paths before committing time to any of them. Running Minecraft on a spare PC at home costs nothing in cloud fees but adds measurable electricity draw, ties the server’s uptime to your home internet connection staying up, and usually means exposing a port on your home router, which some ISPs block or complicate with carrier-grade NAT. A paid host like a managed Minecraft provider removes the setup friction almost entirely, usually comes with a control panel and one-click plugin installs, but costs money every single month for as long as the server exists, and the underlying hardware is a black box you cannot inspect or tune.

Oracle Cloud’s Always Free Ampere A1 instance sits in between: it requires the console-and-SSH setup this tutorial walks through, with no managed panel unless you install one yourself, but it costs nothing on an ongoing basis and gives full root access to tune Java flags, install mods, or run a second game server alongside it within the same OCPU and RAM budget. An October 2026 comparison published by unixgaming.org found that after Oracle’s allocation cut, AWS’s own free-tier compute options became comparatively less competitive for small workloads, since AWS historically ties its EC2 free tier to a time-limited trial rather than Oracle’s standing Always Free model, so the “which free cloud” calculus genuinely shifted in 2026 and is worth revisiting if you already have an AWS account sitting idle.

Option	Ongoing cost	Setup effort	Control
Home PC / spare hardware	Electricity only, no cloud fees	Low, but router port forwarding and dynamic DNS add friction	Full, but tied to home uptime and ISP policies
Paid managed Minecraft host	Roughly $8-$15/month for a small plan	Lowest; control panel and one-click plugin installs	Limited to what the panel exposes
Oracle Cloud Always Free Ampere A1	$0/month within Always Free limits	Highest; full console, SSH, and systemd setup as in this guide	Full root access, including JVM flags and OS-level tuning
AWS/GCP/Azure free compute	$0 during trial, then billed, since neither offers a standing always-free ARM tier at this RAM level	Comparable console-based setup to OCI	Full root access during the trial window

The practical takeaway is that Oracle Cloud wins specifically on duration, not necessarily on raw horsepower. A paid host or a beefier paid cloud instance will out-tick an Ampere A1 server under heavy plugin load, but for a server that mainly needs to survive, not scale, the fact that OCI’s allowance does not expire is the entire reason this setup is worth the extra 20 minutes of console clicking compared to a one-click paid host.

Prerequisites and Version Requirements

You do not need deep Linux experience to follow this guide, but you do need patience with the OCI console the first time through. Gather the following before starting.

Requirement	Version / detail used in this guide
Oracle Cloud account	Always Free tier, valid payment method on file for identity verification only
Compute shape	VM.Standard.A1.Flex (Ampere Arm), 2 OCPU / 12 GB RAM
Operating system image	Ubuntu LTS image offered in the Create Compute Instance menu
Minecraft Java Edition	26.3 (current stable release as of October 2026)
Java runtime	Java 25, the version recommended for Minecraft 26.3
Server software	PaperMC, latest build for Minecraft 26.3 from the official downloads API
SSH client	OpenSSH (built into macOS/Linux terminals; PuTTY or Windows Terminal on Windows)
Local Minecraft client	Minecraft Java Edition launcher, same major version as the server (26.3)

Note the server software line: at the time of writing, third-party trackers disagreed on the exact current Paper build number for Minecraft 26.3, with one guide citing build 180 and another citing build 206 within days of each other, because Paper ships new builds constantly. Do not copy a specific build number from any article, including this one. Always pull the latest build straight from PaperMC’s official build listing for Minecraft 26.3 at the moment you run the install command in Step 7.

Step 1: Create and Verify Your Oracle Cloud Account

Go to Oracle’s cloud sign-up page and create a new tenancy. Oracle requires a valid credit or debit card during sign-up purely for identity verification; Always Free resources, used within their stated limits, do not generate charges against that card. Choose your home region carefully during this step, since Always Free resources are tied to that region for the lifetime of the account and cannot be easily moved later. Pick the region geographically closest to the majority of your players to minimize latency.

After verification, log into the OCI console. If this is your first time there, spend five minutes clicking through the hamburger menu so the layout (Compute, Networking, Identity, Storage) is familiar before building anything. Oracle’s own onboarding material, including a walkthrough from Oracle presenters Håkan and Cengiz describing the Minecraft setup, puts it plainly: “In this video we show you how to do it with free components.” That framing matters, because every resource created in the following steps should map directly back to the Always Free table above.

Step 2: Understand the Ampere A1 Always Free Allocation Before You Provision

Before clicking “Create Instance,” decide how to spend the 2-OCPU, 12-GB budget. For a single Minecraft server supporting a handful of regular players plus occasional guests, the most straightforward allocation is to put the entire budget into one instance: 2 OCPUs and 12 GB RAM. Splitting the allowance across two smaller instances, for example a 1 OCPU / 6 GB Minecraft box plus a 1 OCPU / 6 GB monitoring or backup box, is possible, but it leaves less headroom for Java’s garbage collector, which tends to perform better with one larger heap than two small ones.

Also confirm capacity availability before committing to a region. The Ampere A1 Always Free shape has had well-documented capacity shortages in certain availability domains since the resource first launched, and users continue to report “out of host capacity” errors when provisioning in popular regions during peak sign-up periods. If your first provisioning attempt fails with a capacity error, try a different availability domain within the same home region before assuming the feature is unavailable to you.

Step 3: Launch Your Ampere A1 Compute Instance

From the OCI console, navigate to Compute, then Instances, then Create Instance. Give the instance a name such as minecraft-server. Under “Image and shape,” select an Ubuntu LTS image and then change the shape to VM.Standard.A1.Flex. Set the OCPU count to 2 and memory to 12 GB to use the entire Always Free Ampere budget on this single instance.

Under networking, let OCI create a new Virtual Cloud Network and subnet if you do not already have one, and make sure “Assign a public IPv4 address” is checked so the server is reachable from the internet. Under “Add SSH keys,” either upload your own public key or let OCI generate a key pair for you, downloading the private key immediately since it is shown only once. Boot volume size can stay at the default, at least 47 GB, within the 200 GB free block-storage allowance. Click Create, and wait for the instance’s state to move from Provisioning to Running, which typically takes one to two minutes.

While the instance provisions, it is worth double-checking the shape selector one more time. OCI’s console sometimes defaults new instances to VM.Standard.E2.1.Micro, a separate (and far smaller) Always Free x86 shape intended for lightweight web workloads rather than a Java game server. That shape technically also falls under Always Free, but it does not have the OCPU or RAM headroom this guide assumes, and Paper will struggle on it. Confirm the shape field explicitly reads VM.Standard.A1.Flex with 2 OCPUs and 12 GB of memory before clicking Create, since switching shapes after provisioning means terminating and recreating the instance from scratch.

Step 4: Open Port 25565 in the VCN Security List

Minecraft Java Edition communicates over TCP port 25565 by default. OCI blocks all inbound traffic by default at the network layer through security lists, or network security groups if you created one, so this rule has to be added explicitly or no player will ever reach the server, even once Minecraft itself is running correctly.

From the instance details page, click into the VCN, then the subnet, then the default security list. Add an ingress rule with the following values:

Source Type: CIDR
Source CIDR: 0.0.0.0/0
IP Protocol: TCP
Destination Port Range: 25565

This opens the port to any source IP, which is normal for a public Minecraft server. To restrict access to a known set of player IP ranges instead, narrow the Source CIDR accordingly, but remember that most residential ISPs rotate IP addresses, so an overly tight rule will eventually lock out a legitimate player.

Step 5: Connect via SSH and Update the OS

Find the instance’s public IP address on the instance details page, then connect from a local terminal using the private key downloaded in Step 3:

chmod 600 ~/Downloads/ssh-key-minecraft.key
ssh -i ~/Downloads/ssh-key-minecraft.key ubuntu@INSTANCE_PUBLIC_IP

Replace INSTANCE_PUBLIC_IP with the actual address and adjust the default username if the chosen image uses something other than ubuntu. Once connected, immediately update the package index and installed packages so the build is not resting on a stale image:

sudo apt update && sudo apt upgrade -y
sudo reboot

Give the instance a minute to come back up, then reconnect over SSH before continuing.

Step 6: Install Java 25

Minecraft 26.3 and the Paper builds that support it require Java 25, according to current PaperMC server setup guides for 26.3. Install the OpenJDK 25 headless package, which is sufficient for running a server with no GUI:

sudo apt install -y openjdk-25-jdk-headless
java -version

If your Ubuntu LTS image’s default package repository does not yet carry an OpenJDK 25 package, add the Adoptium (Eclipse Temurin) APT repository and install from there instead, since Temurin tends to ship new Java releases to its own repo faster than distro package maintainers. Confirm the java -version output reports a 25.x build before moving on, since running Paper on an older JVM is one of the most common reasons a freshly built server fails to start.

Step 7: Download and Configure PaperMC

Paper is the practical choice for almost every small survival server because it stays compatible with Spigot plugins while shipping performance and configuration improvements the vanilla Mojang server does not offer. Create a dedicated directory, then fetch the current build for 26.3 directly from PaperMC’s official downloads API rather than a mirror site:

mkdir ~/minecraft && cd ~/minecraft
curl -o paper.jar "https://fill.papermc.io/v3/projects/paper/versions/26.3/builds/latest/downloads/paper-26.3-latest.jar"

Double-check the exact endpoint and filename format against PaperMC’s current build listing for 26.3 at the moment you run this, since Paper’s download API has changed shape across versions and build numbers increment constantly as the project ships fixes.

Step 8: Accept the EULA and Tune server.properties

Run the jar once so Paper generates its default configuration files, then accept Mojang’s end-user license agreement, which every legitimate server must do before it will start normally:

java -Xmx1024M -jar paper.jar nogui
sed -i 's/eula=false/eula=true/' eula.txt

Open server.properties and set, at minimum, the following for a small 12-GB-RAM instance: a moderate view-distance (8-10 rather than pushing it higher if RAM headroom is tight), max-players sized to the real expected player count rather than a large default, and motd to something identifiable. To restrict who can join without running a full whitelist workflow yet, leave online-mode=true to keep Mojang account verification on, which blocks unauthenticated connection attempts by default.

Step 9: Open the Instance Firewall for Port 25565

Opening the OCI security list in Step 4 is necessary but not sufficient. Ubuntu images on OCI also ship with an in-guest firewall, iptables, sometimes fronted by ufw, that blocks the same port at the operating-system level. Both layers have to allow TCP 25565, or connections will time out even though the cloud-level rule looks correct.

sudo iptables -I INPUT -p tcp --dport 25565 -j ACCEPT
sudo netfilter-persistent save

If your image uses ufw instead of raw iptables, the equivalent command is sudo ufw allow 25565/tcp. Run sudo iptables -L -n | grep 25565 afterward to confirm the rule is active before testing connectivity from outside the instance.

Step 10: Launch the Server With a Memory-Tuned Startup Script

With 12 GB of total system RAM, a reasonable split leaves 6-8 GB for the Java heap and the rest for the OS, filesystem cache, and any backup or monitoring process running alongside it. Create a startup script rather than typing the full java command every time:

cat > ~/minecraft/start.sh << 'EOF'
#!/bin/bash
cd ~/minecraft
java -Xms4G -Xmx7G -XX:+UseG1GC -XX:+ParallelRefProcEnabled \
  -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions \
  -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 \
  -jar paper.jar nogui
EOF
chmod +x ~/minecraft/start.sh

These G1 garbage collector flags follow the same general pattern recommended across most current Paper performance guides, and they reduce the long GC pauses that otherwise show up as player-visible lag spikes on memory-constrained instances.

Step 11: Keep the Server Running 24/7 With systemd

Running the start script directly in an SSH session means the server dies the moment you disconnect. A systemd unit keeps it running in the background and automatically restarts it after a crash or an instance reboot:

sudo tee /etc/systemd/system/minecraft.service << 'EOF'
[Unit]
Description=Minecraft Paper Server
After=network.target

[Service]
User=ubuntu
WorkingDirectory=/home/ubuntu/minecraft
ExecStart=/home/ubuntu/minecraft/start.sh
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now minecraft.service

Check status with systemctl status minecraft.service and watch live logs with journalctl -u minecraft -f. The first boot takes longer than later restarts because Paper has to generate chunk data and patch its internals against the vanilla Mojang jar it downloads automatically on first run.

Step 12: Automate World Backups to Object Storage

A free server is not worth much if a bad plugin update corrupts the world and there is no backup. The Always Free block storage allowance includes five volume backups, but for a Minecraft world specifically, a lighter-weight approach is a cron job that tars the world directory on a schedule and keeps a rolling window of recent copies:

cat > ~/minecraft/backup.sh << 'EOF'
#!/bin/bash
cd ~/minecraft
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
tar -czf /home/ubuntu/backups/world-$TIMESTAMP.tar.gz world/
find /home/ubuntu/backups -name "world-*.tar.gz" -mtime +7 -delete
EOF
chmod +x ~/minecraft/backup.sh
mkdir -p ~/backups
(crontab -l 2>/dev/null; echo "0 */6 * * * /home/ubuntu/minecraft/backup.sh") | crontab -

This runs a backup every six hours and automatically prunes anything older than seven days, which keeps the archive well inside the free 200 GB block storage allowance for a small-to-medium world. For an extra layer of safety, periodically copy the newest archive off the instance entirely, for example with scp to a laptop, so a full instance failure cannot take both the live world and every backup with it at once.

For a more durable off-instance copy without relying on a laptop being on, OCI's Object Storage also has an Always Free allowance that can hold a weekly archive at effectively no cost given typical Minecraft world sizes. A simple approach is to extend backup.sh with an oci os object put call once a week, uploading the newest tarball to a dedicated bucket, so a world archive survives even if the compute instance itself is somehow terminated or reclaimed. This single addition is the difference between "a backup exists on the same disk that might fail" and "a backup exists somewhere else entirely," which matters more than any other reliability tweak in this guide.

Step 13: Connect From the Minecraft Client and Invite Friends

Open the Minecraft Java Edition launcher on the version matching the server, 26.3, click Multiplayer, then Add Server, and enter the instance's public IP address (append :25565 only if you changed the default port). The server should appear in the list with a ping value; a successful connection confirms both the OCI security list rule and the in-guest firewall rule are working together correctly.

Share the same public IP address with friends so they can add it as a server on their own clients. If the IP ever changes, which can happen if the instance is stopped and restarted without a reserved public IP, update everyone with the new address, or better, reserve a static public IP for the instance in the OCI console so the address never shifts under normal operation.

Common Pitfalls When Hosting Minecraft on Oracle Cloud

• Forgetting the second firewall layer. The single most common failure reported by first-time OCI users is opening the VCN security list but never touching the in-guest iptables or ufw rules, so the server looks reachable in the console but every connection attempt from a client times out.
• Assuming the old 4 OCPU / 24 GB allocation still applies. Plenty of tutorials and forum posts published before June 2026 still describe the larger allocation. Following those specs leads to provisioning requests that get rejected or silently capped at the current 2 OCPU / 12 GB ceiling.
• Allocating too much JVM heap. Setting -Xmx to nearly the full 12 GB of system RAM starves the OS and SSH daemon of memory, which can make the instance unreachable over SSH precisely when something goes wrong with the Minecraft process.
• Running the vanilla Mojang server instead of Paper. Vanilla works, but it lacks Paper's performance tuning and plugin ecosystem, meaning the same hardware supports noticeably fewer concurrent players before tick lag appears.
• Leaving the instance effectively idle for weeks. Given Oracle's reported idle-reclamation policy around the 20% utilization mark, a server nobody logs into for an extended stretch risks being flagged and stopped, which is a frustrating way to discover the world is gone when you finally want to play again.
• Skipping backups because "it's just a hobby server." Hobby servers are exactly the kind of project where there is no IT department to call when a corrupted world file wipes out months of builds; the backup script in Step 12 takes minutes to set up and costs nothing extra.

Troubleshooting Guide

• "Can't connect to server" from the Minecraft client: confirm both the OCI security list ingress rule and the in-guest iptables/ufw rule allow TCP 25565, then verify the instance's public IP has not changed since you last noted it.
• Server starts, then immediately crashes with an OutOfMemoryError: lower the -Xmx value in start.sh; a common cause is setting the heap too close to total system RAM, leaving nothing for the OS.
• "Out of host capacity" error when creating the instance: try a different availability domain within the same home region, or retry provisioning a few hours later during off-peak demand.
• Paper throws an "unsupported class file version" error on startup: the JVM in use predates Java 25; confirm with java -version and reinstall the correct OpenJDK or Temurin package.
• World looks fine but the server shows as "Old version" to clients: the local Minecraft launcher is on a different major version than 26.3; update the client or point it at the matching version profile.
• systemd shows the service as "failed" after a reboot: check journalctl -u minecraft -b for the exact error; a frequent cause is the EULA file reverting to eula=false after a fresh Paper jar replaces an older one.
• Backups are filling the disk faster than expected: reduce the retention window in backup.sh from seven days to three, or move older archives off-instance with scp on a schedule rather than keeping everything local.
• Lag spikes every few minutes despite low player counts: this is usually a garbage-collection symptom; confirm the G1GC flags from Step 10 are actually present in the running process with ps aux | grep java, since a stale start.sh or a manually launched jar can bypass them entirely.

Advanced Tips for a Production-Grade Free Server

Once the base server is stable, a few upgrades push it from "works for friends" toward something closer to a small managed hosting setup, all still inside the free allocation.

Add Bedrock cross-play with Geyser and Floodgate. Dropping the Geyser and Floodgate plugins into Paper's plugins folder lets Minecraft Bedrock Edition players on consoles, phones, and tablets join the same world as Java players, without needing a second server or a second copy of the world.

Reserve a static public IP. By default, an ephemeral public IP can change if the instance is stopped and restarted. Reserving a static IP in the OCI console (included in the Always Free networking allowance) means the server address never shifts, which matters once friends have bookmarked it in their client.

Explore Kubernetes on the same Ampere A1 budget. For readers who want to go further than a single systemd-managed process, an independent write-up documents building an OKE (Oracle Container Engine for Kubernetes) cluster directly on VM.Standard.A1.Flex Always Free instances, which is a reasonable next step if you eventually want to run Minecraft alongside other containerized services with proper orchestration instead of a single flat VM.

Monitor tick time, not just uptime. Install a lightweight plugin such as Spark to profile tick duration under real player load. A server that stays "up" with ping times under 50ms can still feel laggy to players if the tick loop is regularly running over 50ms per tick; Spark's profiler points directly at the plugin or chunk region causing it.

Set a hard player cap before announcing the server publicly. The 2 OCPU / 12 GB Always Free allocation comfortably supports a private group of 5-10 players running typical survival plugins. Advertising the server beyond friends and family without first load-testing concurrent connections is one of the fastest ways to discover the free tier's real ceiling the hard way, mid-session.

Put Cloudflare in front of the IP if griefing becomes a problem. A public Minecraft server's IP address is easy to find once shared, and small servers do occasionally attract random connection floods or scanning traffic rather than genuine players. A lightweight TCP proxy or a Cloudflare Spectrum-style setup in front of port 25565 can absorb that noise before it ever reaches the Ampere A1 instance, keeping the free allocation focused on actual gameplay rather than on filtering junk traffic.

Use tmux as a lighter alternative to systemd during early testing. Before committing to the systemd unit in Step 11, running the server inside a tmux new -s minecraft session makes it easy to attach and detach from the live server console to issue admin commands, tail chat, or watch for errors in real time, without losing the session when the SSH connection drops. Once the configuration is stable, switching over to systemd for unattended restarts is still the right long-term choice.

The Complete Working Project

Put together, the 13 steps above produce a specific, repeatable stack: an Always Free VM.Standard.A1.Flex instance with 2 OCPUs and 12 GB RAM, running Ubuntu LTS, with TCP 25565 opened at both the OCI security-list layer and the in-guest firewall layer. On top of that instance sits Java 25, a current PaperMC build for Minecraft 26.3, a tuned server.properties file, and a start.sh script with G1GC flags sized for a 6-8 GB heap. A systemd unit keeps the java process alive across crashes and reboots, and a cron-driven backup.sh script archives the world directory every six hours with a seven-day retention window.

Every piece of that stack fits inside Oracle's current Always Free limits: the compute shape matches the 2 OCPU / 12 GB Ampere A1 allowance exactly, the boot volume plus world data sits well under the 200 GB block-storage cap, and the backup cadence keeps local storage use bounded rather than growing unchecked. The result is a Minecraft server that costs $0 per month to run indefinitely, survives reboots and crashes without manual intervention, and can be rebuilt from the backup archive in minutes if anything ever goes wrong with the instance itself.

Frequently Asked Questions

Is Oracle Cloud's Always Free tier actually free forever, or does it expire like AWS and Google Cloud?
It is designed to remain free in the account's home region for the life of the tenancy, unlike AWS and Google Cloud's time-limited free trials, as long as usage stays within the stated Ampere A1, storage, and networking limits.

How many players can a 2 OCPU / 12 GB Ampere A1 instance realistically support?
A Paper server on that allocation comfortably handles a private group of roughly 5-10 concurrent players running typical survival-focused plugins; pushing well beyond that without testing is likely to surface tick lag first.

Why was the Always Free allocation cut from 4 OCPUs / 24 GB to 2 OCPUs / 12 GB?
Oracle made the change in June 2026; the company has not published detailed public reasoning for the reduction beyond updating its official Always Free Resources documentation to reflect the new 1,500 OCPU-hour and 9,000 GB-hour monthly allowance.

Do I need to open the port in both the OCI console and the operating system?
Yes. The OCI security list and the in-guest firewall, iptables or ufw, are independent layers, and traffic has to be allowed through both before a Minecraft client can connect successfully.

Can I run Bedrock Edition players alongside Java Edition players on this setup?
Yes, by installing the Geyser and Floodgate plugins on top of Paper, which translate Bedrock protocol traffic so console, mobile, and Windows Bedrock players can join the same Java-based world.

What happens if my instance gets reclaimed for being idle?
Oracle has reportedly reclaimed Always Free instances that sit below roughly 20% utilization over a rolling week; keeping regular player activity, or at minimum avoiding weeks-long total inactivity, is the simplest way to avoid triggering that policy.

Should I use Paper, Spigot, or vanilla for a small server?
Paper is the practical default for most small servers because it is Spigot-plugin compatible while offering better out-of-the-box performance tuning than either Spigot or the vanilla Mojang server on the same hardware.

Is it safe to leave the Oracle Cloud account's payment card on file long-term?
Charges only occur if usage exceeds the Always Free limits or you deliberately provision paid resources; staying within the 2 OCPU / 12 GB Ampere A1 allocation, the 200 GB block storage cap, and the home-region restriction keeps the instance inside the free allowance described in Oracle's own documentation.