Setting Up Your Own Minecraft Server in 2026: Complete Guide

Want to play Minecraft with your friends, your class, or your community without going through a turnkey host that limits your plugins and charges you 15 EUR a month for 2 GB of RAM? Good news: in 2026, setting up your own Minecraft Java Edition server on the cloud has become accessible to anyone — even if you've never touched Linux in your life. This guide works with any European or global provider, and we're using Scaleway as an example to stick with a sovereign French cloud. Set aside a couple of hours, grab a bank card, and be ready to follow the steps in order.

This tutorial is written for true beginners — not terminal pros. We'll explain everything as we go: what SSH does, what a firewall is for, why you should never run a server as root, what each command line we type actually means. By the end, you'll have an official Minecraft server, secured, that restarts on its own if it crashes, with automatic backups replicated off-server, and a fixed IP reachable from anywhere. All for about 24 EUR per month, or much less if you shut it down when nobody's playing.

What you'll be able to do by the end: create a Scaleway instance running Ubuntu 24.04 LTS, secure it with an SSH key and a firewall, install Java 25, install PaperMC 26.1.2, set up a systemd service, configure cron backups replicated to an S3 bucket, and connect from the Minecraft client like a pro.

1. Why the cloud instead of a turnkey host?

Specialized Minecraft hosts (Aternos, BisectHosting, Nitrado, OMGServ, Shockbyte…) offer a web interface where you click a button and boom, your server is online. That's simple, sure, but there are several catches:

• High price for little RAM: expect 8 to 20 EUR/month for 2 to 4 GB of RAM. On the cloud, the same setup costs half as much.
• Restricted plugins: some hosts block the installation of custom plugins, or server mods (Forge, Fabric).
• Zero system control: you can't install an additional tool, change the Java version, or hook up an S3 backup.
• The IP isn't yours: the server address often changes, which breaks all the links you've given your players.

On a general-purpose cloud like Scaleway (a French company, with datacenters in Paris, Amsterdam, and Warsaw), you rent an actual Linux virtual machine. You can literally do whatever you want with it. The trade-off? You need to learn how to type a few commands in a terminal. And guess what, that's exactly the point of this guide.

Tip: Aternos is free and handy for testing Minecraft with friends once a month. As soon as you want a permanent, customized server, or one that can handle more than 5 players at once, the cloud wins hands down.

Why Scaleway? Sovereign French cloud, and alternatives

In this guide, we're choosing Scaleway, a French host whose datacenters are located in Paris, Amsterdam, and Warsaw. This isn't a technical choice but a matter of sovereignty: your data stays in Europe, under French and European jurisdiction (strict GDPR, no US Cloud Act applying), and you support the European cloud ecosystem. A small gesture, but one that adds up over months of subscription.

Rest assured: all the commands that follow work identically on any other cloud as long as you pick an Ubuntu 24.04 LTS instance. Here are the main alternatives if you prefer:

• OVHcloud (French, Roubaix / Gravelines / Strasbourg) — a sovereign alternative, with pricing close to that of VPS and Public Cloud instances.
• Hetzner (German) — probably the best value for money in Europe for a Minecraft server, but the interface is a bit more austere.
• Infomaniak (Swiss) — a sovereign Swiss cloud, slightly higher pricing but with Swiss neutrality and a strong environmental commitment.
• DigitalOcean, Vultr, Linode / Akamai — American, popular with gamers, but fall under US jurisdiction.
• AWS, Google Cloud, Microsoft Azure — hyperscalers, largely overkill (and priced accordingly) for a Minecraft server among friends.

The main thing to remember: only creating the instance in the console (chapter 4) changes from one cloud to another. All the SSH commands, the installation of Java 25, Paper, the systemd service and automatic backups work identically. If you're already with another provider, skip straight to chapter 5.

2. What you need before you start

• A computer running Windows 10/11, macOS or Linux. No special software to install: the built-in terminal is enough.
• A bank card. Scaleway isn't free, mind you. Expect to pay 20 to 25 EUR for the first month if you leave the server running 24/7, or just a few euros if you turn it off when nobody's playing (see chapter 18).
• A valid email address to create your Scaleway account and receive invoices.
• About 2 hours to spare. The first time, take the time to understand everything. The following times, it'll take just 15 minutes flat.
• The Minecraft Java Edition game installed on the players' computers. Watch out for this trap: the Bedrock version (Xbox, PS5, mobile, Switch) is not compatible with a Java server. This guide only covers Java Edition.

Creating your Scaleway account

Head to console.scaleway.com and click on "Sign up". Enter your email and a strong password. Scaleway will send you a verification link by email: click on it. Then, in the console, go to Billing » Payment methods and add your bank card. A small test charge of 1 EUR will be made and then refunded a few days later. Once your card is validated, your account switches to "Verified" and you can create instances.

3. Choosing the right Scaleway instance

An "instance" is just the fancy word for virtual machine: a computer you can rent by the hour. Scaleway offers several ranges. Here are the ones that concern us in 2026, with pricing verified on scaleway.com/fr/pricing (excluding VAT):

Add to that a flexible IPv4 at 0.005 EUR/hour (around 3.60 EUR/month). This is the fixed public address your friends will use to connect. Without it, your server is only reachable over IPv6, and let's be honest: few ISPs support it properly today.

Recommendation: for a server of 5 to 10 players among friends with a few Paper plugins, go for the PLAY2-NANO. It offers the best price/performance ratio in 2026. You can always upgrade later without reinstalling — we'll cover that in the very last chapter.

4. Creating your Scaleway instance step by step

Okay, theory is all well and good, but now it's time to click. Follow the steps in order, it's really guided:

1. Log in at console.scaleway.com.
2. At the top left, check that you're in an Organization and a Project (the “default” project works just fine).
3. In the left-hand menu, go to Compute » Instances, then click “Create Instance”.
4. Availability zone: choose PAR-1 (Paris) if you're playing from France, for minimal ping.
5. Instance type: select the PLAY2 range, then PLAY2-NANO.
6. Image: choose InstantApp / OS » Ubuntu » 24.04 Noble Numbat. This is the LTS (Long Term Support) version recommended in 2026.
7. Volumes: leave the default SSD disk (at least 20 GB, more than enough for a Minecraft world).
8. SSH keys: we'll generate one right after, in chapter 5. For now, leave this section alone, we'll come back to it.
9. Name: name the instance minecraft-server so you can find it easily once you've got ten projects running in parallel.
10. Click “Create instance.” It will be ready in about 30 seconds.

Once the instance is created, Scaleway assigns it a temporary public IPv4. We'll replace it with a flexible IP in chapter 8, so it never changes again.

5. Generating and registering an SSH key

SSH (Secure Shell) is the protocol that lets you control the remote machine from your computer by typing commands in a terminal. An SSH key is a secret file that replaces a password: it's both more secure and more convenient (you don't have to remember anything).

An SSH key pair is two files that go together like a lock and its key:

• id_ed25519: the private key. It stays on your computer, and you NEVER share it with anyone, not even your grandmother.
• id_ed25519.pub: the public key. This one gets copied onto the Scaleway server. It's the lock: only the private key can open it.

On Windows 10/11, macOS, or Linux

Open a terminal (on Windows: PowerShell, available via the Start menu). Type the following command, which generates a modern key pair in Ed25519 format:

$ ssh-keygen -t ed25519 -C "minecraft-scaleway"

The program asks you where to save the key: press Enter to accept the default location (~/.ssh/id_ed25519). It also asks for a passphrase (an optional password to protect the key). For a first server, you can leave it blank (press Enter twice), but it's safer to set one — like your cat's name.

To display the content of the public key so you can copy it:

$ cat ~/.ssh/id_ed25519.pub
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI... minecraft-scaleway

Select the entire displayed line (it starts with ssh-ed25519 AAAA…) and copy it with Ctrl+C (or Cmd+C on Mac).

Adding the public key to Scaleway

In the Scaleway console, click your name in the top right corner, then "SSH Keys". Click "Add an SSH key", paste the content of id_ed25519.pub, name the key my-pc and confirm.

Then go back to your minecraft-server instance and, in the SSH keys tab, add the key to the instance. Scaleway will automatically install it into the root account of the VM.

Checkpoint - Where am I at? I have a Scaleway account, a PLAY2-NANO instance running, and my public SSH key is registered on it. All that's left is to connect. Take a breath, you're doing great.

6. Connecting via SSH for the first time

Get the public IP of your instance from the Scaleway console (Public IP column). We'll use 51.15.42.100 as an example here — replace it with yours wherever you see it.

In your terminal (PowerShell on Windows, Terminal on Mac/Linux), type:

$ ssh root@51.15.42.100

This command basically says: "connect via SSH to machine 51.15.42.100, with the user root". The very first time, SSH will display a message like "The authenticity of host…". Type yes and press Enter to accept the server's key (this is a fingerprint that guarantees you're really talking to your machine and not to an intruder who stole its IP).

If everything works, you'll see a prompt like root@minecraft-server:~#. Congratulations: you're now inside your remote Linux server, as if you were sitting right in front of it. It feels strange the first few times, but you'll quickly get used to it.

Windows note: if ssh isn't recognized, open Settings » Apps » Optional Features, then install OpenSSH Client. Restart PowerShell afterward and try again.

7. Updating and securing the system

A freshly installed machine should always be updated before anything else. On Ubuntu, we use apt, the package manager (the equivalent of an app store, but in the command line). Two essential commands to remember:

$ apt update
$ apt upgrade -y

apt update refreshes the list of available packages; apt upgrade -y installs the security updates (the -y answers "yes" to the prompts on your behalf). The operation takes 1 to 3 minutes, a good time to go grab a glass of water.

Creating a non-root user

Golden rule of Linux: never run a service (like Minecraft) under the root account. Root has full power; if the service gets hacked, the attacker takes over the entire machine. Be careful, this is where 90% of the free tutorials on YouTube go wrong: they run everything as root and expose you to an avoidable compromise. We're going to create a dedicated minecraft user with limited privileges:

$ adduser --disabled-password --gecos "" minecraft

This command creates the minecraft user, without a password (you'll only connect via SSH key) and without asking the usual questions (full name, phone number…). A /home/minecraft folder is automatically created along the way, and that's where the server will live.

Copy your public SSH key for this user:

$ mkdir -p /home/minecraft/.ssh
$ cp /root/.ssh/authorized_keys /home/minecraft/.ssh/authorized_keys
$ chown -R minecraft:minecraft /home/minecraft/.ssh
$ chmod 700 /home/minecraft/.ssh
$ chmod 600 /home/minecraft/.ssh/authorized_keys

This sequence duplicates root's authorized key to the minecraft user, then sets the permissions so that SSH accepts the key (0700 on the folder, 0600 on the file: readable only by its owner). It's a bit finicky, but SSH is very strict about this, and it's for your own good.

Disabling root SSH login

Now that you can log in as minecraft, we'll disable root SSH logins to reduce the risks. Edit the SSH config:

$ nano /etc/ssh/sshd_config

nano is a simple text editor that runs directly in the terminal — perfect for beginners (the shortcuts are shown at the bottom of the screen). Look for the line #PermitRootLogin prohibit-password (or similar), and replace it with:

PermitRootLogin no
PasswordAuthentication no

Save with Ctrl+O then Enter, exit with Ctrl+X. Reload SSH to apply the changes:

$ systemctl reload ssh

DO NOT CLOSE your current SSH session! The classic mistake is to reload SSH, close the window out of habit, and then realize you no longer have access to your own machine. Open a new terminal window and test the connection as the minecraft user:

$ ssh minecraft@51.15.42.100

If it works, you're all set. If not, go back to the still-open root session and fix the config before you lose access. Seriously, don't skip this testing step — it's your safety net.

fail2ban tip (optional): to block SSH brute-force attempts, install fail2ban with apt install -y fail2ban. It automatically bans IPs that make too many failed login attempts. It takes five minutes to set up and saves you from thousands of bot login attempts cluttering your logs.

8. Configuring Scaleway Security Groups

A firewall is a rule that filters what's allowed to enter and leave the machine. Scaleway offers Security Groups: a filtering layer that kicks in before traffic even reaches your VM. By default, everything is open. We're going to restrict it to the strict minimum necessary, because leaving everything wide open is never a good idea on the Internet.

1. Scaleway console » Instances » Security groups.
2. Click “Create security group”, name it sg-minecraft.
3. Inbound rules: allow only:
   • TCP port 22 from your personal IP (get it from mon-ip.com). This is for SSH.
   • TCP port 25565 from 0.0.0.0/0. This is the official Minecraft Java Edition port.
4. Outbound rules: leave everything allowed (the server needs outbound Internet access for updates and backup uploads).
5. Attach the group to your instance: instance's Overview tab » Security group » sg-minecraft.

Attaching a flexible IPv4

In the Network » Public IPs menu, click “Reserve IP”, choose flexible IPv4, then attach it to the minecraft-server instance. This IP will remain your permanent address even if you turn the instance off and on a thousand times. This is what you'll give your players.

9. Installing Java

Alright, the machine is ready and secured. Now comes the fun part: installing what makes Minecraft run. Java Edition 26.2 (released June 16, 2026) requires Java SE 25. We'll install the headless version (no graphical interface, lighter), as a JRE since we only need to run code, not compile it:

$ sudo apt install -y software-properties-common
$ sudo add-apt-repository -y universe
$ sudo apt update
$ sudo apt install -y openjdk-25-jre-headless

On Ubuntu 24.04, OpenJDK 25 is found in the universe repository, which needs to be enabled before installation. Check the installed version:

$ java -version
openjdk version "25.0.1" 2026-01-21
OpenJDK Runtime Environment (build 25.0.1+9)
OpenJDK 64-Bit Server VM (build 25.0.1+9, mixed mode)

You should see something like openjdk version "25.0.x". If so, perfect, we can move on.

10. Installing Paper (the optimized Minecraft server)

Paper vs Vanilla, in 30 seconds

Vanilla is Mojang's official server. It works, sure, but it's slow, single-threaded on quite a few operations, and doesn't support any plugins. PaperMC is a fork of Spigot that reimplements the server with massive optimizations (async chunk loading, native anti-lag, tick freeze…) and supports Bukkit/Spigot plugins. For a multiplayer server, Paper is the default choice in 2026, without a doubt.

Downloading Paper

Switch to the minecraft user, create a working folder, and download the latest stable build. As of July 15, 2026, the latest stable Paper version is 26.1.2 build 74 (the stable build for Minecraft 26.2 is currently being released; check papermc.io/downloads/paper).

$ sudo -iu minecraft
$ mkdir -p ~/server && cd ~/server
$ wget -O paper.jar https://api.papermc.io/v2/projects/paper/versions/26.1.2/builds/74/downloads/paper-26.1.2-74.jar

sudo -iu minecraft opens a shell session as the minecraft user (think of it as "switching hats"). wget -O paper.jar downloads the jar file and renames it paper.jar to simplify the commands that follow.

Accepting the EULA

Mojang requires you to accept the EULA (End User License Agreement). On first launch, the server creates an eula.txt file with eula=false. We set it to true explicitly, without even launching it:

$ echo "eula=true" > eula.txt

By doing this, you declare that you have read and accepted the Minecraft EULA (account.mojang.com/documents/minecraft_eula). Take two minutes to skim through it, it never hurts.

First launch (test)

We launch Paper manually once to check that everything works and to generate the configuration files. We allocate 3 GB of RAM (Xmx3G) and start with 1 GB (Xms1G) on a PLAY2-NANO that has 4 GB total (we keep 1 GB for the OS, otherwise Linux chokes):

$ java -Xms1G -Xmx3G -jar paper.jar --nogui

The first startup takes a minute (world generation, downloading libraries). When you see the line "Done! For help, type "help"", type stop and Enter to shut down properly. Whatever you do, don't press Ctrl+C, otherwise the world could get corrupted.

11. Configuring server.properties

The server.properties file contains all the gameplay settings. Open it with nano:

$ nano ~/server/server.properties

Here are the main lines to adjust for a friendly 10-player server:

motd=Welcome to our Playnews server!
difficulty=normal
gamemode=survival
max-players=10
view-distance=8
simulation-distance=6
spawn-protection=8
online-mode=true
enable-command-block=false
pvp=true
white-list=false

Quick explanations, so you're not just following along blindly:

• motd: Message Of The Day, displayed in the server list of the Minecraft client.
• difficulty: peaceful, easy, normal or hard.
• view-distance: chunks loaded around the player. 8 is a good performance/immersion compromise on PLAY2-NANO. 10-12 on PLAY2-MICRO.
• simulation-distance: chunks where mobs and redstone "live". Smaller = less lag.
• online-mode=true: requires players to have a valid Minecraft account. Leave it at true, unless you know exactly what you're doing.

12. Creating a systemd service

Running the server by hand in an SSH session works, sure. But as soon as you close the window, the server stops dead. We want it to run in the background, restart automatically when the machine boots, and start back up on its own if it crashes in the middle of the night. systemd is Ubuntu's service management system; we write it a .service file to tell it what to do.

Switch back to root temporarily (or use sudo) to create the file:

$ sudo nano /etc/systemd/system/minecraft.service

Paste the following content:

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

[Service]
Type=simple
User=minecraft
Group=minecraft
WorkingDirectory=/home/minecraft/server
ExecStart=/usr/bin/java -Xms1G -Xmx3G -jar paper.jar --nogui
Restart=on-failure
RestartSec=15
SuccessExitStatus=0 143

[Install]
WantedBy=multi-user.target

Breakdown of the key lines:

• User=minecraft: the service runs under the unprivileged user, not root. Security, always.
• Restart=on-failure: if Paper crashes, systemd restarts it after 15 seconds. You can sleep easy.
• SuccessExitStatus=0 143: 143 is the normal exit code when you type stop in the console.

Reload systemd, enable the service at boot, and start it:

$ sudo systemctl daemon-reload
$ sudo systemctl enable minecraft
$ sudo systemctl start minecraft

Check that it's running properly:

$ sudo systemctl status minecraft
● minecraft.service - Minecraft Paper Server
     Loaded: loaded (/etc/systemd/system/minecraft.service; enabled)
     Active: active (running) since ...

You should see Active: active (running) in green. To watch the logs live (super handy for debugging):

$ sudo journalctl -u minecraft -f

(Ctrl+C to exit the log view, it doesn't stop the server.)

13. Automatic backups

A server without backups is playing with fire: a plugin bug, a misplaced /fill command at 2 a.m., a failing disk… and months of building vanish. A friend of mine told me he lost three months of castle building with his friends because he hadn't set anything up. Don't make that mistake. We'll set up a backup every 6 hours with a 7-day rotation.

Create a folder for the backups and a bash script:

$ sudo mkdir -p /var/backups/minecraft
$ sudo chown minecraft:minecraft /var/backups/minecraft
$ sudo -iu minecraft nano ~/backup.sh

Script content:

#!/bin/bash
DATE=$(date +%Y-%m-%d_%Hh%M)
BACKUP_DIR=/var/backups/minecraft
SERVER_DIR=/home/minecraft/server

# Compress the worlds and plugins
tar -czf "$BACKUP_DIR/mc-$DATE.tar.gz" -C "$SERVER_DIR" world world_nether world_the_end plugins server.properties

# Delete backups older than 7 days
find "$BACKUP_DIR" -name "mc-*.tar.gz" -mtime +7 -delete

Make it executable and test it:

$ chmod +x ~/backup.sh
$ ~/backup.sh
$ ls -lh /var/backups/minecraft/
-rw-r--r-- 1 minecraft minecraft 42M ... mc-2026-07-15_15h30.tar.gz

You should see a file named mc-2026-07-15_15h30.tar.gz or similar. Now set up cron to run the script automatically every 6 hours:

$ crontab -e

Add the line:

0 */6 * * * /home/minecraft/backup.sh >> /home/minecraft/backup.log 2>&1

This cron syntax means: at minute 0, every 6 hours, every day. Logs are appended to backup.log. There you go, you now have local backups every 6 hours. But well, they're on the same machine as the server, which is only half a safety net. Let's move on to the next chapter to really lock this down.

14. Backing up off-server with Scaleway Object Storage (S3)

Watch out, this is where 90% of people trip up the first time — the classic mistake is thinking "I've got local backups, I'm fine, no worries". Except if your instance crashes, gets corrupted, or is accidentally deleted (it happens more often than you'd think), the backups go down with it. We want to put them elsewhere, somewhere isolated, replicated, and cheap.

So what is S3 storage, really?

S3 is originally the name of Amazon Web Services' storage service ("Simple Storage Service"). But nowadays, it's become a standard: any service that speaks the "S3 API" can be used with the same tools. Scaleway, OVH, Cloudflare R2, Backblaze B2… all compatible.

The big difference from a regular hard drive is the mental model:

• A disk is a hierarchy of folders and files, attached to one machine. If the machine dies, the disk dies with it.
• An S3 bucket is a big bucket (literally, "bucket" in English) in which you drop objects identified by a key (the file name). Each object is automatically replicated across several disks in the datacenter, often even across several datacenters (Multi-AZ). A machine can fry, but the bucket just carries on with its life.
• You don't "mount" a bucket like a disk. You talk to it over HTTPS, sending PUT (drop), GET (retrieve), LIST (list) requests. Your tools take care of the details.

The key point for us: a bucket is independent from your instance. You can destroy the entire VM, reinstall Ubuntu from scratch, and get your Minecraft worlds back from the bucket in five minutes. That changes everything.

Why Scaleway Object Storage?

Scaleway offers its own S3-compatible service, hosted in the same French datacenters (PAR-1, PAR-2, PAR-3). Billed per GB and per month, with free incoming traffic. You keep everything within the sovereign ecosystem, and you pay peanuts.

According to Scaleway's pricing sheet as of July 15, 2026:

• Standard Multi-AZ: EUR 0.01606 / GB / month excluding tax (data replicated across several availability zones)
• Incoming traffic (upload): free
• Outgoing traffic (download): free up to a generous monthly quota

In concrete terms: for a reasonably sized Minecraft server (say, 10 GB of backups stacked over 7 days), we're talking about roughly 16 cents a month. The price of a text message.

Step 1 — Create a bucket in the console

1. Scaleway console » left-hand menu » Object Storage » Buckets.
2. Click "Create bucket".
3. Region: choose PAR (Paris) to stay close to your instance (faster upload).
4. Bucket name: for example mon-bucket-minecraft-backups. Names are globally unique on Scaleway, so add a suffix if yours is already taken.
5. Storage class: Standard. We want the data available at all times.
6. Visibility: Private. Of course, you don't want just anyone downloading your worlds.
7. Confirm. The bucket is ready in 5 seconds.

Step 2 — Create an API key

A tool that uploads to the bucket needs an identity to prove it's allowed to. That's a key/secret pair, like a machine-to-machine login/password.

1. Click on your name in the top right » "API keys".
2. "Generate an API key". Name: minecraft-backup. Preferred project: the project where your bucket lives.
3. Scaleway shows you the Access key and the Secret key only once. Copy them right away somewhere safe (not on a sticky note on your desk, okay). If you lose the Secret key, you'll have to generate a new one.

Step 3 — Install and configure s3cmd on the instance

There are two popular CLI clients for talking to S3: s3cmd (simple, file-oriented) and rclone (richer, rsync-style). We'll go with s3cmd, it's the most readable for a beginner.

$ sudo apt install -y s3cmd

Two ways to configure s3cmd: the interactive version (s3cmd --configure, which asks you 12 questions) or the direct version by writing the ~/.s3cfg file by hand. We'll do the second, faster and reproducible.

Switch to the minecraft user and create the file:

$ nano ~/.s3cfg

Paste this content, replacing VOTRE_ACCESS_KEY and VOTRE_SECRET_KEY with the values Scaleway displayed for you:

[default]
access_key = VOTRE_ACCESS_KEY
secret_key = VOTRE_SECRET_KEY
host_base = s3.fr-par.scw.cloud
host_bucket = %(bucket)s.s3.fr-par.scw.cloud
bucket_location = fr-par
use_https = True
signature_v2 = False

Then lock down the file (it contains a secret, and we don't want another user to be able to read it):

$ chmod 600 ~/.s3cfg

The Scaleway endpoint for the PAR-1 region is s3.fr-par.scw.cloud — that's the URL s3cmd will contact. For AMS or WAW, it's s3.nl-ams.scw.cloud and s3.pl-waw.scw.cloud.

Step 4 — Testing the connection

A quick ping to the bucket to check everything's talking to each other properly:

$ s3cmd ls
2026-07-15 14:22  s3://my-minecraft-backups-bucket

If your bucket name shows up, you're golden: the key works. If not, double-check the access key, secret key, and endpoint in ~/.s3cfg.

Send a first test file:

$ echo "hello from minecraft" > /tmp/test.txt
$ s3cmd put /tmp/test.txt s3://my-minecraft-backups-bucket/test.txt
$ s3cmd ls s3://my-minecraft-backups-bucket/

If you see test.txt listed, you're officially hooked up to cloud storage. Give your cat a little high-five.

Step 5 — Editing the backup script to upload automatically

Take the ~/backup.sh script from chapter 13 and add the upload to the bucket, plus a retention policy on the bucket side (we keep 30 days in the cloud, versus 7 days locally — it's cheap, so might as well keep more). Final version:

#!/bin/bash
DATE=$(date +%Y-%m-%d_%Hh%M)
BACKUP_DIR=/var/backups/minecraft
SERVER_DIR=/home/minecraft/server
BUCKET=s3://mon-bucket-minecraft-backups/backups
ARCHIVE="$BACKUP_DIR/mc-$DATE.tar.gz"

# Compress the worlds and plugins
tar -czf "$ARCHIVE" -C "$SERVER_DIR" world world_nether world_the_end plugins server.properties

# Upload to Scaleway Object Storage
s3cmd put "$ARCHIVE" "$BUCKET/mc-$DATE.tar.gz"

# Local rotation: keep 7 days
find "$BACKUP_DIR" -name "mc-*.tar.gz" -mtime +7 -delete

# Remote rotation: keep 30 days
CUTOFF=$(date -d "30 days ago" +%Y-%m-%d)
s3cmd ls "$BUCKET/" | awk '{print $2, $4}' | while read d f; do
  fdate=$(echo "$f" | grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}' | head -1)
  if [[ -n "$fdate" && "$fdate" < "$CUTOFF" ]]; then
    s3cmd del "$f"
  fi
done

Note something: retention on the bucket side can also be managed via a lifecycle policy directly on Scaleway (Console » Bucket » Lifecycle tab), which automatically deletes objects older than X days. It's cleaner and doesn't involve any script. But if you're just starting out, the version in the script works perfectly fine.

Test the new script:

$ ~/backup.sh
$ s3cmd ls s3://mon-bucket-minecraft-backups/backups/
2026-07-15 15:30  42M  s3://mon-bucket-minecraft-backups/backups/mc-2026-07-15_15h30.tar.gz

Your world now lives in three different physical locations within the Scaleway datacenter. You'll sleep much better tonight.

Restoring from S3 in case of a crash

Let's imagine the worst: your instance is dead, or you want to start everything over on a clean new VM. Here's the restoration procedure, from a freshly installed machine:

$ sudo apt install -y s3cmd
$ sudo -iu minecraft
$ nano ~/.s3cfg   # paste back the config from the previous chapter
$ chmod 600 ~/.s3cfg

$ s3cmd ls s3://my-bucket-minecraft-backups/backups/
... list of available backups ...

$ mkdir -p ~/server && cd ~/server
$ s3cmd get s3://my-bucket-minecraft-backups/backups/mc-2026-07-15_15h30.tar.gz .
$ tar -xzf mc-2026-07-15_15h30.tar.gz

You'll find world/, world_nether/, world_the_end/, plugins/ and server.properties exactly as they were at the time of the backup. Re-download paper.jar, put the systemd service from chapter 12 back in place, and run systemctl start minecraft — you're back at the last save point. All of it in about ten minutes.

Peace-of-mind bonus: to go even further, you can enable versioning on the bucket (Console » Bucket » Settings). Every overwrite of a file is kept — a player who broke everything and rebuilt on top of it could no longer overwrite your backup. Three clicks in the console.

15. Connecting from the Minecraft client

Alright, you've set up a server worthy of a mini hosting provider. Now it gets fun: it's finally time to play on it.

1. Launch the official Minecraft launcher and select version Java Edition 26.1.2 (matching your Paper build). Click Play.
2. On the home screen, click Multiplayer » Add server.
3. Server Name: My Scaleway server. Server Address: 51.15.42.100 (your flexible IP).
4. Click Done, then double-click on the server. You should be in-game within seconds.

Domain name tip: to avoid giving your friends an IP address (ugly to remember), buy a domain (5 EUR/year from Gandi or OVH), create an A DNS record mc.my-domain.fr pointing to your flexible IP. They'll connect with a readable name, and if you ever change IP, you just need to update the DNS.

16. Paper optimizations (paper.yml, spigot.yml, bukkit.yml)

Paper generates several configuration files in ~/server/config/ after the first launch. The most worthwhile settings for reducing lag:

paper-world-defaults.yml

• chunks.entity-per-chunk-save-limit: limits the entities saved per chunk (avoids abusive mob farms that slow everyone down).
• tick-rates.mob-spawner: lengthening the mob spawner tick reduces CPU usage.
• collisions.max-entity-collisions: 2 (default 8): fewer collision calculations in crowds of mobs.

bukkit.yml

spawn-limits:
  monsters: 40
  animals: 8
  water-animals: 3
  ambient: 1

Reducing these limits (default: 70, 10, 5, 15) drastically decreases the number of active mobs, and therefore CPU usage. You won't notice any difference as a player, promise.

Aikar's JVM flags

Aikar's flags are a set of JVM options optimized for Minecraft, put together by Aikar (a longtime Paper dev). Copy-paste them, don't try to understand every single flag line by line, you'll be at it all night. Replace the ExecStart line of your systemd service with:

ExecStart=/usr/bin/java -Xms3G -Xmx3G -XX:+UseG1GC -XX:+ParallelRefProcEnabled -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+DisableExplicitGC -XX:+AlwaysPreTouch -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 -XX:G1HeapRegionSize=8M -XX:G1ReservePercent=20 -XX:G1HeapWastePercent=5 -XX:G1MixedGCCountTarget=4 -XX:InitiatingHeapOccupancyPercent=15 -XX:G1MixedGCLiveThresholdPercent=90 -XX:G1RSetUpdatingPauseTimePercent=5 -XX:SurvivorRatio=32 -XX:+PerfDisableSharedMem -XX:MaxTenuringThreshold=1 -Dusing.aikars.flags=https://mcflags.emc.gs -Daikars.new.flags=true -jar paper.jar --nogui

Note that Xms and Xmx are set to the same value: this is recommended by Aikar to avoid memory reallocation cycles, which cause micro-freezes in-game.

17. How much does it cost per month?

Let's add it up for a PLAY2-NANO running 24/7 in 2026:

• PLAY2-NANO instance: EUR 20.00/month (2 vCPU, 4 GB RAM)
• Flexible IPv4: about EUR 3.60/month
• SSD Volume (20 GB included, negligible beyond that)
• Bandwidth: free at Scaleway up to several TB/month
• Object Storage bucket (10 GB of backups): about EUR 0.16/month

Total: about 24 EUR/month excl. VAT for a server available 24/7 with replicated backups. Split between 5 players, that's less than 5 EUR per person. And you can stop the instance when you're not playing (see chapter 18) to bring the cost down even further.

On PLAY2-MICRO (8 GB RAM), expect more like ~42 EUR/month with the IP.

18. Turning the instance off and on to save money

Scaleway bills instances by the hour, only when they are Running. If you stop them properly, you no longer pay for CPU/RAM (just storage and the IP, a few cents a day). A killer trick for a server shared with friends that's only played on weekends: you pay for 2 days out of 7 instead of 7 days out of 7.

Two ways to stop it:

• From the console: the instance's Overview tab » Power off button.
• From SSH: sudo systemctl stop minecraft && sudo shutdown now.

To turn it back on: the Power on button in the console. The Minecraft service restarts on its own thanks to systemd (about 30 seconds). Magic.

Warning: whatever you do, don't destroy the instance without an S3 backup in hand! Stopping and terminating are two different actions. "Power off" keeps everything; "Delete" wipes the disk. That's the kind of mistake that costs you dearly.

19. Troubleshooting: the most common errors

"Connection timed out" on the Minecraft client side

Traffic isn't reaching port 25565 on the server. Check, in order: (1) the service is running: sudo systemctl status minecraft. (2) the port is open in the Scaleway security group. (3) the IP is correct (watch out for typos, we've never managed to connect to a server by typing the wrong octet). Test from the outside:

$ nmap -p 25565 51.15.42.100

"java.lang.OutOfMemoryError: Java heap space"

You don't have enough RAM allocated. On PLAY2-NANO (4 GB), keep -Xmx3G. On PLAY2-MICRO (8 GB), switch to -Xmx6G. On PLAY2-PICO (2 GB), cap it at -Xmx1500M and avoid heavy modpacks.

"Unable to bind to port 25565"

Another process is already using the port. Check:

$ sudo ss -tulnp | grep 25565

If it's an old Paper instance still alive, kill it: sudo systemctl stop minecraft then sudo pkill -u minecraft java. Then restart the service.

"Outdated server / outdated client"

The version of Paper installed on the server doesn't match the version of the Minecraft client. Check the file name paper-26.1.2-74.jar and select the same version in the Minecraft launcher. Paper 26.2 experimental works with Minecraft 26.2 client, but for a beginner, stick with the stable version, no need to play the hero here.

"Permission denied (publickey)"

SSH refuses the connection. Check that: (1) you're using the right user (minecraft@, not root@). (2) the ~/.ssh/authorized_keys file on the server does contain your public key. (3) permissions on the ~/.ssh folder are set to 700 and the authorized_keys file to 600. All three need to be right, otherwise SSH will sulk.

20. Going further

Essential Paper plugins

Drop the .jar files into ~/server/plugins/ and restart the service.

• EssentialsX: /home, /tpa, /back commands, kits, economy… the Swiss Army knife.
• LuckPerms: fine-grained permission management by group (guest, player, VIP, moderator, admin).
• WorldEdit: massive builds, copy/paste entire regions.
• CoreProtect: action history, roll-back in case of griefing.
• DiscordSRV: bridge the Minecraft chat with a Discord channel. Friends outside the game can see what's happening.

Whitelist

For a private server between friends, enable the whitelist so that only authorized usernames can connect. In the server console (or via SSH with screen/tmux):

whitelist on
whitelist add PlayerUsername

Migrating to a bigger instance

The day your PLAY2-NANO gets overloaded (spoiler: that happens when you have too many players or you go for a heavy modpack), stop the instance in the console, click Change instance type, choose PLAY2-MICRO or PLAY2-SMALL. Restart it: your world and your config stay exactly the same. No reinstallation. Two minutes flat.