Share on Twitter Share on Facebook Share on LinkedIn Share on Reddit

Building A Minecraft Server With 12 Year Old PC + Tutorial (PaperMC, Docker, DDNS, Port Forwarding)

One Sentence Summary

This video explores running a Minecraft server on a 12-year-old PC, demonstrating feasibility, setup, and performance insights.

Main Points

The creator repurposed a 12-year-old PC found in the trash for this project.
Hardware includes an Athlon 2 X4640 CPU, 8GB RAM, and a 640GB hard drive.
Ubuntu Server Linux and Docker were used to simplify server setup and management.
The process involved creating bootable USB, installing Ubuntu, and configuring network settings.
Docker containers were used to run both the Minecraft server and Duck DNS for dynamic IP handling.
Port forwarding and Duck DNS setup enabled access over the internet for players outside the local network.
Installing plugins like Essentials X enhanced server functionality and permissions management.
The server was tested with friends, revealing some lag and chunk rendering delays.
Power consumption was around 55W idle, costing approximately $50-$60 annually if run constantly.
The project demonstrated that old hardware can host a playable Minecraft server cost-effectively.

Takeaways

Old hardware can be repurposed for modern server projects with Linux and Docker.
Dynamic DNS services like Duck DNS are essential for hosting servers on changing IP addresses.
Proper network configuration, including port forwarding and IP reservation, is crucial for remote access.
Running a server on old hardware can be cost-effective compared to paid hosting or realms.
Experimenting with server settings and plugins can improve performance and user experience.

Step by Step

Step 1: Prepare your old PC

Use any old PC with at least 4–8GB of RAM. The video uses a Compaq CQ5720F with an AMD Athlon II X4 640 CPU and 8GB DDR3 RAM.
Make sure it has a working hard drive and can boot from USB.

Step 2: Download Ubuntu Server and flash it

Go to the Ubuntu Server website and download version 20.04.4 LTS.
Download Rufus to create a bootable USB.
Plug in a USB stick (8GB+), open Rufus, and:
- Select your USB device.
- Choose the Ubuntu ISO as the boot image.
- Leave the rest of the settings as default and hit "Start".

Step 3: Install Ubuntu Server

Boot the old PC from the USB stick.
Follow the Ubuntu Server installation:
- Choose your language and keyboard layout.
- Leave network settings as default (DHCP).
- Write down your assigned local IP address (e.g., 192.168.1.xxx).
- Use the entire disk but uncheck "Use as LVM group" to avoid issues.
- Create a user account and enable OpenSSH server (important for remote access).
- When prompted, select "Install Docker".
- Let the install finish, then reboot and remove the USB stick.

Step 4: Connect to your server via SSH

From another PC on the same network (Windows):
- Open PowerShell or Terminal.
- Connect using:
```
ssh [email protected]
```
- Type yes to confirm and enter your password.
- (Optional) Use a GUI client like PuTTY or Solar-PuTTY.

Step 5: Update and configure Ubuntu

Run these commands:

sudo apt-get update
sudo apt-get upgrade

Add your user to the Docker group:

sudo groupadd docker
sudo usermod -aG docker your-username
sudo reboot

After reboot, SSH in again and test Docker:
```
docker ps
```

Step 6: Set up your Minecraft server with Docker

Create a directory for your server config:
```
mkdir ~/mc-docker
```
Go to Docker Hub and search for itzg/minecraft-server or markv/minecraft-papermc.

Use this command to run the server (modify as needed):

docker run -d \
  --name mcserver \
  -e EULA=TRUE \
  -e MEMORY=6G \
  -v /home/your-username/mc-docker:/data \
  -p 25565:25565 \
  --restart unless-stopped \
  itzg/minecraft-server:1.18

Confirm it works:
```
docker logs mcserver
```
On Minecraft (Java Edition), add a server:
- Name: Local Minecraft
- Address: 192.168.1.xxx

Step 7: Set up external access (so friends can join)

Reserve your local IP in your router's DHCP settings (so it doesn’t change).
Set up port forwarding:
- External port: 25565
- Internal port: 25565
- Internal IP: your server’s local IP.
Go to DuckDNS and:
- Create an account and log in.
- Choose a custom subdomain (e.g., myserver123).
- Note the token it gives you.

Step 8: Set up dynamic DNS with DuckDNS and Docker

Create a config folder:
```
mkdir ~/duckdns-docker
```

Run the DuckDNS container:

docker run -d \
  --name duckdns \
  -e PUID=1000 \
  -e PGID=1000 \
  -e TZ=America/New_York \
  -e SUBDOMAINS=myserver123 \
  -e TOKEN=your-duckdns-token \
  -v /home/your-username/duckdns-docker:/config \
  --restart unless-stopped \
  ghcr.io/linuxserver/duckdns

Test it:
```
docker logs duckdns
```
Now your Minecraft server is publicly available at:
```
myserver123.duckdns.org
```

Step 9: Add plugins (like EssentialsX)

Navigate to your plugins folder:
```
cd ~/mc-docker/plugins
```

Download a plugin:

wget https://github.com/EssentialsX/Essentials/releases/download/2.19.4/EssentialsX-2.19.4.jar

Restart your server:

docker stop mcserver
docker start mcserver

Step 10: Make yourself a server operator

Attach to the server:
```
docker attach mcserver
```
In the console:
```
op your-minecraft-username
```
To safely detach from the console:
- Press Ctrl + P, then Ctrl + Q.

Step 11: Enjoy and tune

Invite friends using your DuckDNS address.
Adjust settings in server.properties (found in ~/mc-docker) to tweak performance.
Monitor usage with:
```
top
```

Tips

Power use: Expect ~50–60 watts idle, ~$50–$60/year in electricity.
Backup: Back up your mc-docker folder to avoid losing your world.
Performance: Consider tweaking PaperMC settings or adding more RAM for better chunk loading.

Let me know if you want a printable version or help customizing your server (e.g., mod support, whitelist, backups, etc.).