Every homelab eventually gets the same request from a kid, a sibling, or a friend: "can we play Minecraft together?" You could pay for hosting from one of the big Minecraft server companies, but that's a recurring bill for something your Proxmox box can run in its sleep. A small Minecraft server barely tickles a modern CPU, and once it's tucked away in its own LXC container, it won't touch anything else running on your node.
This guide builds a Minecraft Java Edition server from a bare Debian 13 container, using PaperMC instead of vanilla Minecraft for better performance. No Docker, no third-party helper script doing the work behind your back. You'll type every command yourself, so when a plugin update breaks something at 11 p.m., you'll actually know where to look.
What You'll Learn
By the end of this tutorial you'll have a Minecraft server running in its own container, reachable from your LAN (or the internet, if you choose to open it up), and set to survive a reboot on its own. Specifically, you'll learn how to:
- Create a right-sized LXC container for a small-to-medium Minecraft server
- Install the correct Java version for modern Minecraft releases
- Download and run a PaperMC server, and accept the EULA correctly
- Set up a systemd service so the server starts automatically after a reboot
- Open the right port through the Proxmox firewall without exposing your whole network
- Fix the handful of errors almost everyone runs into on their first attempt
What Is a Minecraft Server (and What Is PaperMC)?
A Minecraft server is just a Java program. Run it, and it opens a network port, loads (or generates) a world, and waits for Minecraft clients to connect. Everyone who connects shares the same world, in real time, whether they're on the same Wi-Fi or on the other side of the planet.
Vanilla Minecraft ships its own server jar straight from Mojang, and it works fine. PaperMC is a modified version of that server that's become the de facto standard for anyone hosting for more than one or two players. It fixes a long list of performance issues in the vanilla server, supports plugins (things like Essentials for basic admin commands, or Chunky for pre-generating terrain), and is a near drop-in replacement — your world files and player data work the same way. That's why this guide uses Paper instead of vanilla.
Why Run It Inside an LXC Container?
You could just install Java directly on the Proxmox host and run the server there. Don't. The Proxmox host should be dedicated to running VMs and containers, not application workloads — one crashed or misbehaving process on the host can affect everything else on that node.
An LXC container gives you a clean, isolated Linux environment that shares the host's kernel instead of running its own, which is exactly why containers start in a second or two and use only the RAM the application inside actually needs — unlike a VM, which reserves memory for its own kernel and won't give it back. For something as CPU-and-RAM-hungry as a Minecraft world, that efficiency matters. You get a server you can stop, snapshot, resize, or throw away without touching anything else on the node.
Prerequisites
Before you start, make sure you have:
- A working Proxmox VE 9.x installation (these steps also work on 8.x with minor template naming differences)
- At least 4 GB of free RAM on the host for a small server with a handful of players — 2 GB is survivable for a single-player or two-player world, but Paper will run noticeably smoother with more headroom
- At least 10 GB of free storage for the container, more if you plan to run a large explored world or add plugins
- Basic comfort typing commands in a Linux shell — you don't need to be an expert, just willing to follow along
- A Debian 13 (or Ubuntu) LXC template already downloaded, or access to download one
If you haven't created an LXC container before, it's worth reading through how to create your first LXC container in Proxmox VE first — this guide moves a bit faster since it assumes you've seen the container creation wizard at least once.
Step-by-Step Tutorial
1. Download the Debian 13 template
If you don't already have a Debian 13 template cached locally, grab one from the Proxmox VE web interface: click your node, then local storage, then CT Templates, then Templates, and search for debian-13. Or do it from the shell:
pveam update
pveam available --section system | grep debian-13
pveam download local debian-13-standard_13.1-1_amd64.tar.zstThe exact filename will change as Proxmox rebuilds templates, so check the output of the available command for the current version rather than copying the filename above blindly.
2. Create the container
Open a shell on your Proxmox host (or use the GUI's Create CT wizard, which does the same thing with clicking instead of typing) and run something like:
pct create 210 local:vztmpl/debian-13-standard_13.1-1_amd64.tar.zst \
--hostname mc-server \
--cores 2 \
--memory 4096 \
--swap 512 \
--rootfs local-lvm:16 \
--net0 name=eth0,bridge=vmbr0,ip=dhcp \
--unprivileged 1 \
--features nesting=0 \
--onboot 1210 is just the container ID — pick any number that isn't already in use on your node. Two cores and 4 GB of RAM is a comfortable starting point for a handful of players; you can always bump both up later with pct set if the world grows or more friends join.
Start it and log in:
pct start 210
pct enter 2103. Install Java
Modern Minecraft (1.20.5 and newer) needs Java 21. Debian 13's default repositories carry it, so this is refreshingly simple compared to older Debian releases where you had to add a third-party repo:
apt update && apt upgrade -y
apt install -y openjdk-21-jre-headless curlConfirm it installed correctly:
java -versionYou should see something reporting openjdk version "21...". If you're deliberately running an older Minecraft version (1.18 or earlier, for instance), you'll want openjdk-17-jre-headless instead — check the version requirements on the PaperMC downloads page for the Minecraft version you're targeting.
4. Create a dedicated user and directory
Don't run the server as root. It doesn't need to be, and if a plugin ever gets compromised, you don't want it doing so with full permissions over the container:
adduser --system --group --home /opt/minecraft minecraft
mkdir -p /opt/minecraft
chown minecraft:minecraft /opt/minecraft
cd /opt/minecraft5. Download the PaperMC server jar
PaperMC publishes builds through a public API. Head to papermc.io/software/paper in a browser first to see the current Minecraft version and the latest stable build number for it — these change often enough that hardcoding a specific number here would be wrong within weeks. Once you have both, download it as the minecraft user:
su - minecraft
cd /opt/minecraft
curl -o paper.jar https://api.papermc.io/v2/projects/paper/versions/VERSION/builds/BUILD/downloads/paper-VERSION-BUILD.jarReplace VERSION and BUILD with the values from the downloads page — for example, version 1.21.4 and whatever build number is currently marked as the latest stable release.
6. Accept the EULA and do a first run
Mojang requires you to explicitly accept their end-user license agreement before the server will run. Do the first launch, let it fail, then fix the EULA file:
java -Xms1024M -Xmx3072M -jar paper.jar noguiIt'll generate some files and exit with a message telling you to agree to the EULA. Open eula.txt and change eula=false to eula=true, or just do it in one line:
sed -i 's/eula=false/eula=true/' eula.txtRun the jar again and this time it'll actually start, generate your world, and print Done once it's ready. Type stop at the prompt to shut it down cleanly for now — you'll want it running as a proper service, not attached to your terminal session.
7. Set up a systemd service
Exit back to root (exit) and create /etc/systemd/system/minecraft.service:
[Unit]
Description=Minecraft PaperMC Server
After=network.target
[Service]
User=minecraft
Group=minecraft
WorkingDirectory=/opt/minecraft
ExecStart=/usr/bin/java -Xms1024M -Xmx3072M -jar paper.jar nogui
Restart=on-failure
RestartSec=10
[Install]
WantedBy=multi-user.targetEnable and start it:
systemctl daemon-reload
systemctl enable --now minecraftCheck that it actually came up:
systemctl status minecraft
journalctl -u minecraft -f8. Open the port through the Proxmox firewall
Minecraft Java Edition listens on TCP port 25565 by default. If you've enabled the Proxmox firewall on this container's network interface, add a rule to allow it — from the container's Firewall tab in the web GUI, add an inbound rule for TCP, destination port 25565, action ACCEPT. If you haven't touched the Proxmox firewall before, this walkthrough of firewall rules covers the basics.
If you want friends outside your home network to connect, you'll also need to forward TCP port 25565 on your home router to this container's IP address. It's worth giving the container a static IP first, so the port forward doesn't break the next time it grabs a new DHCP lease.
9. Connect from a Minecraft client
Open Minecraft Java Edition, go to Multiplayer, then Add Server, and enter the container's IP address (and :25565 if you're prompted for a port separately from the address). If everything above worked, you should see the server respond within a second or two.
Commands Explained
| Command | What it does |
|---|---|
pveam download | Downloads an LXC template to local storage so pct create can use it |
pct create | Builds a new container from a template with the CPU, memory, disk, and network settings you specify |
pct enter | Drops you into a root shell inside a running container, without needing SSH set up first |
adduser --system | Creates a service account with no login shell or password — exactly what a background process needs |
java -Xms / -Xmx | Sets the starting and maximum heap size Java is allowed to use — this is your real memory ceiling for the server |
systemctl enable --now | Enables a service to start on boot and starts it immediately, in one step |
journalctl -u minecraft -f | Tails the live log output for the service, which is where crashes and startup errors show up |
Common Errors
"Unsupported class file major version" — you're running an older Java than the server jar needs. Check java -version and install openjdk-21-jre-headless if you're still on 17.
Server starts, then immediately stops with no obvious error — nine times out of ten this is the EULA. Check that eula.txt actually says eula=true and doesn't still have a trailing space or wrong value from a copy-paste.
Clients can't connect, but the server log shows "Done" — this is almost always the firewall, not Minecraft. Test whether the port is actually reachable from another machine on your LAN before touching anything in the server config:
nc -zv 192.168.1.50 25565"java.lang.OutOfMemoryError: Java heap space" — your -Xmx value is too small for the world size and player count. Bump the container's memory allocation with pct set 210 --memory 6144, then raise -Xmx to match, leaving some headroom for the container's own OS overhead.
"Outdated server! I'm still on version..." — the client and server Minecraft versions don't match. Either update your client or download the matching Paper build for your client's version.
Troubleshooting
Start with journalctl -u minecraft -n 100 — the last hundred lines almost always contain the actual error, not just the symptom. If the service won't stay running, temporarily stop it and run the jar manually in the foreground with su - minecraft -c "java -jar paper.jar nogui" so you can see errors in real time instead of digging through logs.
If the container itself seems sluggish, check its actual resource usage from the host rather than guessing:
pct exec 210 -- free -h
pct exec 210 -- topA Minecraft server that's constantly generating new terrain as players explore will spike CPU usage in short bursts — that's normal. Sustained high CPU with no one exploring new chunks usually means a misbehaving plugin, or a redstone contraption someone built that's running in a tight loop.
Best Practices
Set -Xms and -Xmx to the same value once you know your real usage pattern — letting the heap grow and shrink constantly costs you a bit of performance for no real benefit on a dedicated server.
Back up the world folder before every Paper or plugin update, not just on a schedule. A bad plugin update is the single most common way homelab Minecraft servers lose player builds. A quick pct snapshot before major changes, on top of your regular Proxmox backup schedule, covers you both ways.
Keep the container unprivileged. Minecraft doesn't need any special kernel access, and there's no good reason to take on the extra risk of a privileged container for it.
If you're going to open the server to the internet, at minimum enable a whitelist (whitelist.txt plus white-list=true in server.properties) so random players can't just wander in and grief the world.
Frequently Asked Questions
How much RAM does a Minecraft server actually need?
For 1-4 players on a normal-sized world, 2-4 GB is plenty. Larger worlds, heavy plugin use, or more than 6-8 concurrent players usually push that to 6-8 GB.
Can I run this in a VM instead of an LXC container?
Yes, and the steps inside the guest are identical. You'll just pay for a full guest kernel's worth of overhead, which is wasted on something as lightweight as a Java process.
Does this work for Bedrock Edition instead of Java Edition?
Not directly — Bedrock uses a different server binary (like PocketMine-MP or the official Bedrock Dedicated Server) and a different network protocol on UDP port 19132. The container setup is similar, but the software and port are different.
Do I need port forwarding if everyone playing is on my home network?
No. Port forwarding on your router is only needed for players connecting from outside your LAN. Local players just need the container's LAN IP address.
Can I run more than one Minecraft server on the same Proxmox host?
Yes — that's one of the real advantages of the container approach. Just give each one its own container ID, its own memory allocation, and its own port if you want them all reachable from outside at once.
Conclusion
What you've got now is a Minecraft server that starts on its own after a reboot, runs isolated from everything else on your Proxmox node, and cost you nothing beyond electricity and a bit of disk space. It's a small project, but it's a good one for getting comfortable with the pattern you'll reuse for almost every other self-hosted app you run in LXC containers going forward: build the container, install the runtime, wire up a systemd service, open the one port you actually need.
From here, the obvious next steps are picking a couple of plugins for the features your players actually want, and setting a real backup routine before anyone builds something they'd be upset to lose.