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

Running a game server around the clock usually means picking a monthly plan from a hosting company and hoping you never outgrow it. Oracle Cloud Infrastructure (OCI) offers a different path: an Always Free tier that hands out up to 2 ARM-based OCPUs and 12 GB of RAM, permanently, with no trial period and no credit card charge as long as you stay inside the limits. For a Minecraft Java Edition world, a Valheim save, or a small Palworld co-op session, that is more horsepower than most paid $10-a-month plans offer.

This tutorial walks through standing up a dedicated game server on an OCI Ampere A1 instance from a blank account to a running, auto-restarting server process, using Minecraft as the primary worked example (the same VM setup applies to most other Java- or native-binary dedicated servers). You will provision the free-tier compute shape, harden the network path, install the runtime, configure the server to survive reboots, and avoid the handful of mistakes that get free-tier instances reclaimed. Expect to spend 60–90 minutes end to end, most of it waiting on package installs and a Minecraft world to generate.

·

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 Oracle Cloud’s free tier beats the competition for this

AWS, Google Cloud, and Azure all advertise free tiers, but none of them give you enough sustained compute to keep a game server running 24/7 without eventually hitting a wall. AWS’s free tier is built around a 12-month window on a t2.micro/t3.micro instance with 1 GB of RAM, workable for a tiny vanilla world, but underpowered the moment a few friends join at once, and it stops being free after a year. Google Cloud’s Always Free e2-micro instance is permanent but similarly thin on memory. Azure’s free credits expire after 30 days, after which you’re paying list price. Oracle’s Always Free Ampere A1 allocation is still the outlier, permanent and ARM-based rather than a crippled x86 burstable instance, though the allocation itself has shrunk: as recently as January 2025 it included 4 OCPUs, 24 GB of RAM, and 200 GB of storage, and Oracle cut that down to 2 OCPUs and 12 GB of RAM in June 2026, alongside a drop in the monthly Ampere memory budget from 18,000 to 9,000 GB-hours (the 200 GB of free block and boot-volume storage was left untouched). Even at the reduced size, 12 GB of RAM is enough headroom for a real community server, not just a proof of concept, and the shape this guide uses is still VM.Standard.A1.Flex even though Oracle launched A4 Standard Acceleron in April 2026 as its newest listed Ampere generation.

Provider	Free compute	Duration	RAM ceiling
Oracle Cloud (OCI)	2 OCPU Ampere A1 (ARM)	Always Free, permanent	12 GB
AWS	t2.micro/t3.micro	12 months, then billed	1 GB
Google Cloud	e2-micro	Always Free, permanent	~1 GB
Azure	B1s (via credit)	30-day trial credit, then billed	1 GB

The tradeoff is capacity contention. Because the Ampere A1 allowance is genuinely useful, it’s also genuinely popular, which is why “out of host capacity” errors on instance creation are a recurring theme in community troubleshooting threads rather than a rare edge case. Budget a little patience into your first attempt, and the rest of this guide deals with every other rough edge you’re likely to hit.

What you need before you start

Oracle Cloud’s free-tier game server setup has a short list of real prerequisites, but each one matters because free-tier capacity on OCI is first-come, first-served in every region. Gather these before you open the console.

Requirement	Detail
Oracle Cloud account	Free tier sign-up, verified email, and a valid card for identity verification (no charge unless you manually upgrade)
Compute shape	VM.Standard.A1.Flex (Ampere ARM), up to 2 OCPU / 12 GB RAM, Always Free allocation
OS image	Oracle Linux 8 (default tested image) or Ubuntu 22.04/24.04 ARM64
SSH client	Terminal (macOS/Linux) or PuTTY/WSL (Windows), plus an SSH key pair
Java runtime	Java 17 or newer for Minecraft 1.18+; check the exact requirement for your target version before launch
Local time	60–90 minutes, plus a few minutes of patience for ARM capacity in busy regions

You do not need Docker, Kubernetes, or Terraform for this build. That is a deliberate choice: the Always Free tier is aimed at hobbyists and small communities who want a server that is actually free, not a container orchestration exercise. If you later want to run multiple games on the same tenancy, a lightweight panel layered on top of this VM is a reasonable next step, but it is outside the scope of a single always-free instance.

Step 1: Create or sign in to your Oracle Cloud account

Go to Oracle’s cloud sign-up flow and create a tenancy if you don’t already have one. Oracle verifies your identity with a card, but Always Free resources do not generate a charge unless you explicitly upgrade the account to Pay As You Go. Pick a home region carefully: your Always Free Ampere A1 allocation is tied to that region, and you cannot move it later without losing the free allocation in the original region. Choose a region close to your players to cut latency, and avoid regions that frequently report ARM capacity shortages if you have a choice (US East and US West tend to have better A1 availability than some EU regions during peak sign-up periods).

Step 2: Generate an SSH key pair

OCI injects your public key into the instance at boot instead of giving you a password. On macOS or Linux, generate a dedicated key for this server:

ssh-keygen -t ed25519 -C "oci-minecraft-server" -f ~/.ssh/oci_minecraft
chmod 600 ~/.ssh/oci_minecraft

On Windows, use the equivalent command inside WSL, or generate a key pair with PuTTYgen if you prefer the native PuTTY workflow. You’ll upload the resulting .pub file during instance creation in the next step. Keep the private key somewhere you won’t lose it; OCI does not store a recovery copy.

Step 3: Launch the Ampere A1 Always Free instance

From the OCI Console, open Compute → Instances → Create Instance. Give it a name, then configure the following:

• Image: keep the default Oracle Linux 8 image, or click Change Image and select an ARM64 Ubuntu 22.04/24.04 LTS build if you prefer apt-based administration.
• Shape: click Change Shape → Ampere → select VM.Standard.A1.Flex, then set 2 OCPUs and 12 GB memory to use your entire Always Free allocation on one box (you can split it into two smaller VMs instead if you want a second server later).
• Networking: let OCI create a new VCN and subnet if this is your first instance, and make sure “Assign a public IPv4 address” is checked.
• SSH keys: upload the .pub file you generated in Step 2.
• Boot volume: the default 50 GB is enough for a vanilla server; bump it to 100–150 GB if you plan to run a heavily modded pack with frequent world backups.

Click Create. If you see an “Out of host capacity” error on the A1 shape, that region’s free ARM pool is temporarily exhausted, retry every few minutes, try a different availability domain in the same region, or try again at an off-peak hour. This is the single most common failure point reported by people trying this setup in 2025 and 2026, and it is a capacity issue, not a problem with your configuration.

Step 4: Open the network path at the OCI layer

A Minecraft or other game server needs its port open at two separate layers on OCI, and missing either one is the most common reason a freshly launched server looks “up” in the console but is unreachable from outside. First, the cloud-level Security List (or a Network Security Group, if you created one):

• Go to Networking → Virtual Cloud Networks → your VCN → the subnet attached to your instance → Security Lists → Default Security List.
• Add an Ingress Rule: Source CIDR 0.0.0.0/0, IP Protocol TCP, Destination Port Range 25565 (Minecraft Java’s default port).
• If you’re hosting Bedrock-compatible mode or a game that uses UDP, add a second rule with IP Protocol UDP and the matching port (Bedrock defaults to 19132).

Resist the temptation to open every port to 0.0.0.0/0 “just in case.” Keep SSH (port 22) restricted to your own IP address or a small trusted range, leaving SSH open to the entire internet on a public cloud instance is one of the fastest ways to attract automated credential-stuffing traffic.

Step 5: Open the matching port on the instance firewall

The OCI Security List only controls traffic at the cloud network boundary. The guest operating system runs its own firewall, and it blocks the port by default even after step 4. SSH into the instance:

ssh -i ~/.ssh/oci_minecraft opc@YOUR_PUBLIC_IP

On Oracle Linux 8 (which runs firewalld by default), open the port with:

sudo firewall-cmd --permanent --add-port=25565/tcp
sudo firewall-cmd --permanent --add-port=25565/udp
sudo firewall-cmd --reload
sudo firewall-cmd --list-all

If you chose Ubuntu instead, the equivalent is:

sudo ufw allow 25565/tcp
sudo ufw allow 25565/udp
sudo ufw reload
sudo ufw status

Both the Security List rule and the OS-level firewall rule have to exist at the same time. Each one alone will leave the server unreachable, which is exactly the symptom in the “server won’t connect but SSH works fine” troubleshooting thread you’ll find repeated across OCI community forums.

Step 6: Update the system and install Java

With the network path open, update packages and install a Java runtime. On Oracle Linux 8:

sudo dnf update -y
sudo dnf install -y java-21-openjdk java-21-openjdk-devel
java -version

On Ubuntu ARM64:

sudo apt update && sudo apt upgrade -y
sudo apt install -y openjdk-21-jdk
java -version

Check the official requirements page for the exact Minecraft version you’re deploying before you commit to a Java version. Newer Minecraft releases have periodically bumped their minimum JRE (Minecraft Java 26.1.2, for example, requires Java 25 rather than the Java 21 installed above, as of June 2026). Java Edition 26.3 is reportedly the latest stable version, so confirm its requirement before you commit, and treat Java Edition 26.4 Snapshot 5, published on October 20, 2026, as a test build rather than a stable server target. Installing an older Java runtime than the server jar expects is a common cause of a server that refuses to launch with a cryptic UnsupportedClassVersionError.

Step 7: Create a dedicated service account and directory

Don’t run the game server as root. Create a low-privilege user and a working directory:

sudo useradd -m -s /bin/bash mcserver
sudo mkdir -p /opt/minecraft
sudo chown mcserver:mcserver /opt/minecraft
sudo su - mcserver
cd /opt/minecraft

Running the server under its own account limits the blast radius if a plugin or mod has a vulnerability, and it keeps file permissions predictable when you add automated backups later.

Step 8: Download the server jar and accept the EULA

Grab the server jar from the official Minecraft server download page (copy the current download link from the page rather than hard-coding an old URL, since Mojang rotates the link with every release):

wget -O server.jar "PASTE_CURRENT_SERVER_JAR_URL_HERE"
java -Xmx1024M -Xms1024M -jar server.jar nogui
echo "eula=true" > eula.txt

The first launch generates eula.txt, server.properties, and the world files, then exits because the EULA hasn’t been accepted yet. Set eula=true as shown above, then move on to sizing the memory allocation properly before you launch again for real.

Step 9: Size the memory allocation correctly

Your Always Free A1 instance has 12 GB of RAM total if you provisioned the full shape, but you should never hand all of it to the Java heap. Oracle Cloud’s own guides as of June 2026 still treat a 2-OCPU/12-GB VM as suitable for small-to-medium Minecraft servers, which is reassuring given that this is now the ceiling rather than a starting point. The operating system, the JVM’s own native memory overhead, and any backup or monitoring process you add later all need headroom.

Server profile	Recommended heap (-Xmx)	Rough player capacity
Vanilla, small group	2–4 GB	5–10 players
Vanilla, larger group	4–6 GB	10–20 players
Lightly modded	6–10 GB	5–10 players
Large modpack	12–16 GB	5–10 players

On a 12 GB instance, allocating 6–8 GB to the heap for a large modpack while leaving several GB for the OS and JVM overhead is a reasonable starting point. Avoid setting -Xmx12G; a heap that size with no slack left for the OS is a near-guaranteed path to swapping or an out-of-memory kill once the world has been running for a few days.

Step 10: Configure server.properties

Open server.properties in the working directory and set at minimum:

server-port=25565
max-players=20
view-distance=8
simulation-distance=6
online-mode=true
motd=My OCI Always Free Server

Lowering view-distance and simulation-distance from their defaults is the single most effective lever for keeping CPU and memory usage predictable on a shared ARM core count, especially once you have more than a handful of players spread across the map. Leave online-mode=true unless you have a specific reason to allow unauthenticated connections, turning it off opens the server to username spoofing.

Step 11: Run the server as a systemd service

Running the server in a terminal session means it dies the moment your SSH connection drops. Wrap it in a systemd unit instead so it starts on boot and restarts if it crashes. As root, create /etc/systemd/system/minecraft.service:

[Unit]
Description=Minecraft Server
After=network.target

[Service]
User=mcserver
WorkingDirectory=/opt/minecraft
ExecStart=/usr/bin/java -Xmx12288M -Xms4096M -jar server.jar nogui
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

Enable and start it:

sudo systemctl daemon-reload
sudo systemctl enable --now minecraft.service
sudo systemctl status minecraft.service
sudo journalctl -u minecraft.service -f

Restart=on-failure brings the server back automatically if a plugin throws an unhandled exception, and enable means the service comes up again after an instance reboot, including the reboots OCI occasionally performs for host maintenance.

Step 12: Keep the instance from looking idle

Oracle’s Always Free policy allows reclamation of an Ampere A1 instance that stays idle for seven consecutive days, where idle means the 95th-percentile CPU utilization, network utilization, and memory utilization are all below 20% for that whole window. A game server with zero active players for a week on a mostly-asleep host can brush against that threshold, so build in a small safety margin:

• Run a lightweight cron job or a monitoring agent that keeps CPU/network ticking over even with no players connected.
• Avoid shutting the instance down for long stretches “to save resources”, a powered-off instance accumulates idle time toward reclamation faster than one that’s merely quiet.
• Check in on the instance’s metrics in the OCI Console periodically if you expect long gaps between play sessions.

Separately, if you ever provision more A1 capacity than your Always Free allowance covers, Oracle disables the excess instances and deletes them after 30 days unless you upgrade the tenancy to a paid account. That’s a hard allowance limit, not a performance throttle, keep your total OCPU and memory usage across all A1 instances at or under 2 OCPU / 12 GB to stay clear of it.

Step 13: Automate backups

A free server is still worth protecting. Add a simple cron job that archives the world folder on a schedule and ships it somewhere off the instance. OCI Object Storage has a free allowance that is enough for rolling world backups for most small communities:

#!/bin/bash
TIMESTAMP=$(date +%Y%m%d-%H%M)
cd /opt/minecraft
tar -czf /opt/backups/world-$TIMESTAMP.tar.gz world
find /opt/backups -name "world-*.tar.gz" -mtime +7 -delete

Save it as /opt/minecraft/backup.sh, make it executable with chmod +x, and add it to mcserver‘s crontab with crontab -e to run nightly. The retention cleanup at the end stops the boot volume from quietly filling up with months of old archives.

Expected output when everything works

A healthy launch looks like this in journalctl -u minecraft.service -f:

[Server thread/INFO]: Starting minecraft server version 1.21.x
[Server thread/INFO]: Loading properties
[Server thread/INFO]: Preparing level "world"
[Server thread/INFO]: Preparing spawn area: 100%
[Server thread/INFO]: Done (24.812s)! For help, type "help"

At that point, connect from the Minecraft client using the instance’s public IPv4 address and port 25565. If you want a friendlier hostname than a raw IP, point a free DNS record (Cloudflare, DuckDNS, or a domain you already own) at the public IP and share that instead, just remember the IP can change if you stop and restart the instance rather than just rebooting it, unless you reserve it as a persistent public IP in the OCI Console.

Common pitfalls and how to avoid them

Most problems people report with this exact setup trace back to one of the following.

• “Out of host capacity” when launching the A1 shape. The free ARM pool in that availability domain is temporarily full. Retry periodically, try a different availability domain, or try at a different time of day.
• Server runs but nobody can connect. Almost always a missing rule at one of the two firewall layers, double-check both the OCI Security List/NSG ingress rule and the guest OS firewall (firewalld or ufw) for the exact port and protocol.
• Allocating all of the instance’s memory to the JVM heap. Leaves no room for the OS, causes swapping, and can trigger an out-of-memory kill after days of uptime. Always leave several GB of headroom.
• Running the server in a bare SSH session instead of systemd/screen/tmux. The process dies the moment the SSH connection drops. Use a systemd unit (Step 11) or at minimum a detachable terminal multiplexer.
• Letting the instance sit fully idle for a week. Risks the Always Free idle-reclamation policy. Keep a baseline of activity or periodically check instance metrics.
• Provisioning more A1 resources than the Always Free allowance. Extra instances get disabled and deleted after 30 days unless you upgrade. Track your total OCPU/RAM usage across all A1 VMs.
• Installing a Java version older than the Minecraft release requires. Produces an UnsupportedClassVersionError on launch. Verify the required Java version for your exact Minecraft release before installing the runtime.
• Running the service as root. Unnecessary privilege exposure if a plugin or mod has a vulnerability. Use a dedicated low-privilege account as shown in Step 7.
• Opening SSH to 0.0.0.0/0. Invites automated scanning and credential-stuffing attempts against port 22. Restrict the source CIDR to your own IP range.
• Forgetting to reserve a persistent public IP. A dynamically assigned public IP can change if the instance is stopped and started; players relying on a bookmarked IP will suddenly be unable to connect.

Troubleshooting checklist

Work through these in order when something doesn’t behave as expected.

1. Can’t SSH into the instance at all. Confirm you’re using the correct username for the image (opc for Oracle Linux, ubuntu for Ubuntu images) and that your Security List allows port 22 from your current IP.
2. Instance creation fails with a capacity error. This is an OCI-side ARM capacity shortage, not a configuration mistake. Retry later or in a different availability domain.
3. Server process starts then immediately exits. Check eula.txt is set to true and that the Java version matches what the jar requires; read the first lines of the crash log in the logs/ directory.
4. Players can’t connect even though the server is “Done” in the logs. Re-verify both firewall layers (Step 4 and Step 5) with firewall-cmd --list-all or ufw status, and confirm the public IP hasn’t changed.
5. Server lags badly with only a few players online. Lower view-distance and simulation-distance in server.properties, and check top or htop for a runaway plugin or mod consuming CPU.
6. Server crashes after a few days of uptime. Usually a heap sized too close to total RAM. Reduce -Xmx and leave more headroom for the OS.
7. Instance seems to have disappeared from the console. Check whether it was reclaimed for inactivity (Step 12) or whether you exceeded your Always Free A1 allowance with a second instance.
8. World corruption after an unexpected shutdown. Restore from the most recent backup created in Step 13; consider adding a save-all command via RCON before any planned restart.
9. High latency for overseas players. The home region you picked in Step 1 is fixed for your free allocation; latency is inherent to the physical distance and can’t be fixed without a second instance in another region (which uses a separate tenancy’s free tier, not a region move).

Harden the instance beyond the defaults

A publicly reachable game server on a cloud instance is a visible target even if nobody famous is playing on it, automated scanners probe every IP range on the internet looking for open ports and weak SSH configurations, and a game server’s public IP is no exception. A handful of extra steps meaningfully reduce the attack surface without adding real operational overhead.

Disable SSH password authentication entirely and rely solely on the key pair from Step 2. Edit /etc/ssh/sshd_config and confirm these two lines are set:

PasswordAuthentication no
PermitRootLogin no

Restart the SSH service with sudo systemctl restart sshd after confirming your key-based login still works from a second terminal window, test before you close your existing session, since a mistake here can lock you out entirely.

Install fail2ban to automatically block IP addresses that repeatedly fail SSH login attempts:

sudo dnf install -y epel-release fail2ban
sudo systemctl enable --now fail2ban

On Ubuntu, the equivalent is sudo apt install -y fail2ban followed by the same systemctl enable --now command. Finally, turn on unattended security updates (dnf-automatic on Oracle Linux, unattended-upgrades on Ubuntu) so kernel and OpenSSH patches land automatically between the times you remember to log in and run updates by hand.

Advanced tips once the basics are running

Once the base server is stable, a few refinements make it noticeably more pleasant to operate long-term.

Swap the vanilla server jar for a performance-oriented fork if your game/mod ecosystem supports it; Paper and similar forks for Minecraft implement substantial server-side optimizations over vanilla and are generally safe drop-in replacements for plugin-based servers. If you’re running mods rather than plugins, check mod loader compatibility first since forks and vanilla aren’t interchangeable for modded setups.

Add RCON so you can send console commands remotely without an SSH session open, which is useful for scripted restarts or integrating a Discord bot that relays server status to your community. Enable it in server.properties with enable-rcon=true, set a strong rcon.password, and restrict the RCON port at the Security List level the same way you restricted SSH.

If your community outgrows one game, consider layering a lightweight management panel on top of the same instance rather than provisioning a second one, that keeps you inside the single Always Free allocation while letting you run more than one dedicated server side by side, scheduling restarts and resource limits per server rather than per VM.

Finally, set a billing alert in the OCI Console even though you don’t expect to be charged. It costs nothing to configure and gives you an early warning if a future action, like adding a second A1 instance that pushes you over the allowance, or attaching a block volume beyond the free quota, would otherwise generate a surprise invoice.

Set up basic monitoring so problems don’t surprise you

A server with no monitoring tells you something is wrong only after players start complaining in Discord. The OCI Console already tracks CPU, memory, and network utilization for every instance under Compute → Instances → your instance → Metrics, and that same data is what determines whether you’re at risk of idle reclamation, so it’s worth checking periodically even if you don’t set up anything else.

For something more hands-on, install a lightweight monitoring agent directly on the instance rather than paying for a third-party SaaS dashboard you don’t need for a hobby server:

sudo apt install -y htop
htop

htop is enough to spot a runaway process during a live troubleshooting session. If you want historical graphs rather than a live snapshot, Netdata’s single-command installer gives you a local web dashboard with CPU, memory, disk, and network history without needing an external account, though you should restrict access to its web port in the Security List the same way you restricted SSH. For a production-leaning setup, create an OCI Monitoring alarm that notifies you by email when CPU utilization drops near zero for an extended window, that’s an early warning that the server process may have crashed, well before a player tells you it’s down.

Point a free domain name at your server

Sharing a raw IP address with your community works, but it breaks the moment you reserve a new one or move to a different instance. Two practical options fix that without costing anything:

• Reserve a persistent public IP in OCI. Under Networking → IP Management → Reserved Public IPs, create a reserved address and attach it to your instance. This address survives a stop/start cycle, unlike the ephemeral public IP assigned by default.
• Add a free DNS record. If you already own a domain, add an A record pointing a subdomain like mc.yourdomain.com at the reserved IP. If you don’t, a free dynamic DNS service such as DuckDNS gives you a working hostname in a couple of minutes, and most of them include a small update client you can run as a cron job in case your IP ever does change.

Either approach turns “connect to 129.x.x.x” into something your players will actually remember, and it means you can swap the underlying instance later without having to re-announce a new address to everyone.

What it would cost on a paid host instead

It’s worth knowing what you’re actually saving, and what your options look like if your community eventually outgrows the free allocation. Entry-level VPS pricing from the major budget providers in 2026 looks roughly like this for comparable specs:

Provider / tier	Specs	Approximate monthly price
Oracle Cloud Always Free (this guide)	Not listed	$0
DigitalOcean entry droplet	1 vCPU / 1 GB RAM / 25 GB SSD	~$4–$6
Vultr entry instance	1 vCPU / 1 GB RAM / 25 GB SSD	~$2.50–$6
Linode/Akamai entry instance	1 vCPU / 1 GB RAM / 25 GB SSD	~$5
DigitalOcean 4 vCPU / 8 GB tier	4 vCPU / 8 GB RAM	~$48
Managed Minecraft hosting (typical mid-tier)	6–8 GB RAM, managed panel included	~$15–$30

At the specs this guide now provisions on the free tier, 2 OCPU and 12 GB RAM, the closest paid equivalent on a budget VPS provider runs somewhere in the $20–$30/month range. If you want to match the older 4-OCPU/24-GB configuration Oracle offered before its June 2026 cutback, TerminalBytes pegs the ongoing cost of keeping a VM at that larger size at roughly $25–$28 a month now that it no longer falls inside the Always Free allowance, and a comparable managed game-hosting plan with that much memory typically costs more once you factor in their per-GB RAM pricing. Oracle’s paid lineup has also moved on: E6 Standard Acceleron launched in April 2026 with 16% higher per-core CPU performance, and X12 Standard Acceleron, also launched in April 2026 with Intel Xeon 6 processors, offers up to 2.5× bare-metal CPU performance. Running the current free allocation on OCI instead means the only real cost is the setup time this tutorial walks through.

Oracle’s Paid Compute Options Beyond the Free Allocation

Oracle announced general availability of Dynamic Resource Virtual Machines (DRVM) for OCI Compute on October 14, 2026. DRVM initially supports eligible VM.Standard.E6.Flex configurations in eight listed regions and provides a 10% discount on OCPU and memory usage. That discount does not establish free eligibility, so it is a pricing option for a server that has outgrown the Always Free allocation, not a replacement for it.

Oracle’s current comparison page specifically mentions 10 TB of monthly data egress among the Always Free benefits, and Oracle’s current material continues to promote its Always Free tier. For a hobby Minecraft world, that means the practical path is unchanged: keep your A1.Flex instance inside the free limits, watch usage in the console, and look at paid capacity only when the player count genuinely demands it. If you do move up, measure how much CPU and memory your world actually uses first, so you buy only the capacity you need.

Oracle also announced a no-cost early-access program for Quantinuum’s Helios quantum computer and emulators through OCI on October 14, 2026. It is a preview program, not a generally available Always Free service, so it has no bearing on a Minecraft server setup. Oracle stated on October 7, 2026 that OCI had more than 225 live and planned cloud regions, which is a reminder to check regional availability when you pick the home region for your own instance.

Complete working project reference

Putting every step together, the finished deployment consists of: one VM.Standard.A1.Flex instance (2 OCPU / 12 GB RAM, the Always Free ceiling since Oracle’s June 2026 reduction) running Oracle Linux 8 or Ubuntu ARM64; a Security List rule opening TCP/UDP on your game’s port; a matching firewalld/ufw rule on the guest OS; Java 17 or newer installed (Java 25 if you’re deploying Minecraft Java 26.1.2 or later); a dedicated mcserver system account; the server jar with the EULA accepted and server.properties tuned for your expected player count; a systemd unit so the process survives reboots and crashes; and a nightly cron job archiving the world to a backups directory. Here’s the systemd unit and firewall rules together as a single reference you can copy:

# Firewall (Oracle Linux)
sudo firewall-cmd --permanent --add-port=25565/tcp
sudo firewall-cmd --permanent --add-port=25565/udp
sudo firewall-cmd --reload

# systemd unit: /etc/systemd/system/minecraft.service
[Unit]
Description=Minecraft Server
After=network.target
[Service]
User=mcserver
WorkingDirectory=/opt/minecraft
ExecStart=/usr/bin/java -Xmx12288M -Xms4096M -jar server.jar nogui
Restart=on-failure
RestartSec=10
[Install]
WantedBy=multi-user.target

# Enable and start
sudo systemctl daemon-reload
sudo systemctl enable --now minecraft.service

From here, the same VM, firewall pattern, and systemd approach apply almost unchanged to other dedicated-server games, Valheim, Project Zomboid, and most Source-engine servers all follow the identical shape: open the port at both firewall layers, run the binary under a service unit, and back up the save directory on a schedule.

Other dedicated-server games that fit the same instance

Minecraft is the highest-demand use case for this exact setup, but the same Ampere A1 instance, the same dual-layer firewall approach, and the same systemd pattern work for most other dedicated-server games. The only things that change are the binary you run, the default port you open, and how much of the 12 GB of free-tier RAM you allocate. A rough starting point for ports to open in both the Security List and the guest firewall:

Game	Default port(s)	Protocol
Minecraft Java Edition	25565	TCP
Minecraft Bedrock Edition	19132	UDP
Valheim	2456–2458	UDP
Project Zomboid	16261	UDP
Terraria	7777	TCP

Each of these ships its own dedicated-server download separate from the client, usually distributed through SteamCMD rather than a jar file, but the deployment shape is unchanged: install the runtime dependencies, run the server under its own low-privilege user, wrap the launch command in a systemd unit with Restart=on-failure, and schedule a cron job to back up the save directory. If you want to run two of these side by side on the same instance, say Minecraft for one group of friends and Valheim for another, just make sure the combined memory footprint leaves room for the OS, and give each service its own unit file and its own port.

Frequently asked questions

Is Oracle Cloud’s Always Free tier actually free forever, or is it a trial?
It’s a permanent allowance, separate from the 30-day/$300 trial credit new accounts also receive, though the size of that allowance isn’t fixed forever: Oracle reduced the standing Ampere A1 allocation from 4 OCPU/24 GB RAM down to 2 OCPU and 12 GB RAM in June 2026. At the current 2 OCPU/12 GB size, along with 10 TB of monthly outbound transfer, the allocation continues indefinitely as long as your usage stays within those limits and the account isn’t upgraded into paid consumption beyond the free quota.

Can I run more than one game server on the same Always Free instance?
Yes, if the instance has enough headroom. You can run a Minecraft server alongside a smaller game like a Valheim or Project Zomboid instance, as long as combined memory and CPU usage stays within the free allowance and leaves room for the OS. Just give each server its own port and its own systemd unit.

Why can’t I connect even though the server shows “Done” in the logs?
In almost every case this is a missing firewall rule at either the OCI Security List/NSG layer or the guest OS firewall layer. Both have to allow the port; the server process starting successfully only confirms the game itself is running, not that network traffic can reach it.

What happens if Oracle reclaims my instance for being idle?
If CPU, network, and memory utilization all stay below 20% (95th percentile) for seven consecutive days, Oracle’s policy permits reclaiming the instance. Keeping even light background activity running, or checking in periodically if you expect long gaps between sessions, reduces that risk.

Should I use Oracle Linux or Ubuntu for the instance?
Either works. Oracle Linux 8 is the image Oracle’s own documentation uses as the tested default for the A1 shape, which makes it a safe choice if you want the fewest surprises. Ubuntu ARM64 LTS is equally supported and may feel more familiar if you’re used to apt-based administration elsewhere.

How much RAM should I give the Java heap on a 12 GB instance?
Leave meaningful headroom for the OS and JVM overhead. A vanilla server for 10–20 players runs comfortably on a 4–6 GB heap; a lightly modded setup for a small group might need 6–8 GB. Never set the heap to the full 12 GB, and if you want the heavier 12–16 GB heap sizes this guide used to assume, know that those now require paying for capacity beyond the Always Free allowance Oracle set in June 2026.

What if I get an “out of host capacity” error when creating the instance?
That specific availability domain’s free ARM pool is temporarily full. It’s a capacity issue on Oracle’s side, not a mistake in your setup. Retry periodically, try a different availability domain within the same region, or try again at a different time.

Can I use this same setup for games other than Minecraft?
Yes. The VM provisioning, dual-layer firewall configuration, and systemd service pattern are identical for most dedicated-server games. Only the binary, default port, and memory sizing guidance change.