I Can Finally Run Minecraft Server For Me And My 2 Friends

Posted Aug 6, 2025

By Usman Masood Ashraf

views 8 min read

I Can Finally Run Minecraft Server For Me And My 2 Friends

Introduction

Every DevOps engineer and system administrator reaches that pivotal moment when their professional skills collide with personal passion projects. For many of us, running a Minecraft server for friends represents the perfect intersection of technical challenge and practical application. But as the Reddit commentary highlights, what appears simple at first glance - “just run a server for a few friends” - quickly reveals layers of infrastructure complexity that demand proper DevOps methodology.

The viral statement “I can finally run Minecraft server for me and my 2 friends” resonates because it encapsulates a universal truth: even seemingly simple services require careful resource allocation, performance tuning, and operational planning. This challenge becomes particularly acute in homelab environments where hardware resources are finite, yet the desire for professional-grade reliability remains high.

In this comprehensive guide, we’ll dissect exactly what it takes to run a stable Minecraft server for small groups (2-5 players) while applying professional DevOps principles. You’ll learn:

Resource allocation strategies balancing RAM, CPU, and storage
Containerized deployment patterns for maintainability
Performance optimization techniques from JVM tuning to world pre-generation
Security hardening for public-facing game servers
Monitoring and maintenance workflows suitable for small-scale operations

Whether you’re setting up a private server for friends or using Minecraft as a learning platform for infrastructure management, these battle-tested approaches will transform your homelab into a robust gaming platform.

Understanding Minecraft Server Infrastructure

Technical Architecture Overview

At its core, a Minecraft server is a Java application running the Spigot/Bukkit or vanilla server software. Unlike traditional web services, Minecraft’s technical demands are unique:

World Persistence: The entire game state (chunks, entities, player data) resides in memory
Tick-Based Processing: Game logic runs at 20 ticks/second (50ms intervals)
Procedural Generation: New terrain generation spikes CPU usage
Player Proximity Processing: Only loaded chunks consume resources

These characteristics create specific performance requirements that Reddit commenters instinctively recognized:

“The critical factor is the number of cpu/threads you can allow to your server. I’ve allowed 3vcpus…”

Resource Allocation Breakdown

Resource Type	Minimum (2-3 players)	Recommended (5-8 players)	Critical Factors
RAM	2GB	4-6GB	View distance, mods
CPU	2 cores @ 2.5GHz	3+ cores @ 3.0GHz+	Single-thread performance
Storage	10GB HDD	20GB SSD	Chunk loading speed
Network	5 Mbps upload	10 Mbps upload	Player latency

Real-world testing confirms these parameters align with the Reddit user’s report of running 5-8 players on 10GB RAM with 3 vCPUs. The key insight: Minecraft scales vertically, not horizontally - throwing more weak cores at the problem yields diminishing returns compared to fewer faster cores.

Server Software Options

Vanilla (Official)
- Pros: Perfect compatibility, simple setup
- Cons: No optimizations, limited plugins
PaperMC
- Pros: Performance improvements, plugin support
- Cons: Slightly modified gameplay mechanics
Fabric + Lithium/Phosphor
- Pros: Lightweight optimization mods
- Cons: Requires mod management

For small groups, PaperMC provides the best balance of performance and compatibility, typically offering 2-3x better TPS (ticks per second) than vanilla with equivalent resources.

Prerequisites

Hardware Requirements

Minimum (2-3 players):

CPU: Intel i3-8100 / AMD Ryzen 3 1200 (4 threads)
RAM: 4GB DDR4 (2GB allocated to server)
Storage: 20GB free space (SSD recommended)
Network: 5 Mbps upload speed

Recommended (5-8 players):

CPU: Intel i5-10400 / AMD Ryzen 5 3600 (6+ threads)
RAM: 8GB DDR4 (4-6GB allocated)
Storage: 40GB NVMe SSD
Network: 10 Mbps upload, <100ms latency

Software Dependencies

Java Runtime:
- Adoptium Temurin 17 (LTS) for modern versions
- Java 8 for legacy versions (pre-1.17)
  1 2 # Ubuntu/Debian installation sudo apt install temurin-17-jdk
Operating System:
- Ubuntu Server 22.04 LTS (recommended)
- Rocky Linux 9 (alternative)
Network Requirements:
- Port 25565 TCP/UDP forwarded
- Static IP for server
- Reverse proxy optional (for web interfaces)

Security Checklist

Firewall rules restricting SSH access
Non-root user for server operations
Automated security updates enabled
SSH key authentication configured
Fail2ban installed for brute-force protection

Installation & Setup

Manual Server Deployment

Create dedicated user account:

  
sudo useradd -m -s /bin/bash minecraft
sudo passwd minecraft

Install Java 17:

  
sudo apt update && sudo apt install temurin-17-jdk

Download PaperMC server:

  
# Get latest build for 1.21
PAPER_URL=$(curl -s https://api.papermc.io/v2/projects/paper | jq -r '.versions[-1]')
BUILD=$(curl -s https://api.papermc.io/v2/projects/paper/versions/$PAPER_URL | jq '.builds[-1]')
wget https://api.papermc.io/v2/projects/paper/versions/$PAPER_URL/builds/$BUILD/downloads/paper-$PAPER_URL-$BUILD.jar

First-run configuration:

  
java -Xms2G -Xmx2G -jar paper-*.jar nogui
# Accept EULA after first run
nano eula.txt # Change eula=false to true

Docker Deployment (Production-Grade)

For better resource isolation and easier updates:

  
# Create docker-compose.yml
version: '3.8'

services:
  mc:
    image: itzg/minecraft-server
    container_name: mc
    restart: unless-stopped
    environment:
      EULA: "TRUE"
      TYPE: "PAPER"
      VERSION: "1.21.4"
      MEMORY: "4G"
      MAX_PLAYERS: "8"
      VIEW_DISTANCE: "10"
    ports:
      - "25565:25565"
    volumes:
      - ./data:/data
    deploy:
      resources:
        limits:
          cpus: '3.00'
          memory: 4G

Start with:

docker compose up -d

Key configuration parameters:

MAX_PLAYERS: Limits concurrent connections
VIEW_DISTANCE: Controls chunk rendering (major RAM impact)
cpus: Allocates CPU shares (3 cores in this example)

Systemd Service Configuration

For non-Docker deployments, create /etc/systemd/system/mc.service:

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

[Service]
User=minecraft
WorkingDirectory=/opt/mc
ExecStart=/usr/bin/java -Xms4G -Xmx4G -XX:+UseG1GC -XX:+ParallelRefProcEnabled -jar paper-1.21.4.jar nogui
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Enable with:

  
sudo systemctl daemon-reload
sudo systemctl enable mc.service
sudo systemctl start mc.service

Configuration & Optimization

Critical server.properties Settings

  
# /opt/mc/server.properties

max-players=8
view-distance=10 # Reduce to 6-8 if experiencing lag
simulation-distance=8
server-port=25565
online-mode=true # Set false for LAN-only
network-compression-threshold=256 # Reduces CPU usage
enable-jmx-monitoring=false # Security hardening

JVM Tuning Best Practices

Use Aikar’s optimized flags for PaperMC:

  
java -Xms4G -Xmx4G -XX:+UseG1GC -XX:+ParallelRefProcEnabled \
-XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions \
-XX:+DisableExplicitGC -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 \
-jar paper-1.21.4.jar nogui

These settings optimize G1 garbage collection for Minecraft’s memory allocation patterns, reducing lag spikes during GC cycles.

Performance Optimization Techniques

World Pre-generation:

# Install Chunky plugin
chunky radius 5000 # 5k block radius
chunky start

Redstone Limits:

  
# paper-world-defaults.yml
redstone-implementation: alternate
max-auto-save-chunks-per-tick: 8

Entity Activation Ranges:

  
# spigot.yml
entity-activation-range:
  animals: 16
  monsters: 24
  raiders: 48
  misc: 8
  water: 8
  villagers: 16
  flying-monsters: 48

Security Hardening

Firewall Rules:

  
sudo ufw allow 25565/tcp comment 'Minecraft TCP'
sudo ufw allow 25565/udp comment 'Minecraft UDP'
sudo ufw limit 22/tcp comment 'SSH Rate Limit'

Backup Strategy:

  
# Daily incremental backups
0 3 * * * tar -czvf /backups/mc-world-$(date +\%F).tar.gz /opt/mc/world

Access Control:

  
# ops.json
[
  {
    "uuid": "player-uuid-here",
    "name": "TrustedUser",
    "level": 4
  }
]

Usage & Operations

Daily Management Commands

Command	Description	Docker Equivalent
`systemctl status mc`	Check service status	`docker container ls -f name=mc`
`tmux attach -t mc`	Attach to console	`docker attach mc`
`say Server restarting`	Broadcast message	`docker exec mc rcon-cli "say..."`
`save-all`	Force world save	`docker exec mc rcon-cli save-all`

Monitoring Essentials

In-Game Metrics:

/timings report # Generates performance analysis

OS-Level Monitoring:

  
htop -u minecraft # Resource usage
iotop -o -P # Disk I/O
iftop -P # Network traffic

Prometheus Integration: ```yaml
prometheus.yml
scrape_configs:
- job_name: ‘minecraft’ static_configs:
  - targets: [‘mc_exporter:9150’] ```

Use Prometheus JMX Exporter with Minecraft’s JMX monitoring.

Backup and Recovery

Snapshot-Based Backups:

  
# LVM snapshot script
lvcreate -L1G -s -n mc-snapshot /dev/vg00/minecraft
mount /dev/vg00/mc-snapshot /mnt/snapshot
tar -czvf /backups/mc-full-$(date +\%s).tar.gz /mnt/snapshot
umount /mnt/snapshot
lvremove -f /dev/vg00/mc-snapshot

Restoration Process:

  
systemctl stop mc
rm -rf world world_nether world_the_end
tar -xzvf /backups/mc-full-1680000000.tar.gz -C /opt/mc
systemctl start mc

Troubleshooting Common Issues

Server Won’t Start

Symptoms: Java crashes immediately, no logs

Check Java Version:
1 java -version # Must be Java 17+
Verify Port Availability:
1 sudo ss -tulpn | grep 25565

Lag Spikes During Gameplay

Diagnosis Steps:

Check TPS:
1 /tps # Should be 20.0
Analyze timings:
1 2 /timings on /timings paste
Monitor GC activity:
1 jstat -gc $PID 1000

Solutions:

Reduce view-distance in server.properties
Upgrade to SSD storage
Add JVM flags for GC optimization
Pre-generate chunks with Chunky

Connection Timeouts

Network Checklist:

Verify port forwarding:
1 nc -zv your-ip 25565
Check firewall rules:
1 sudo ufw status verbose
Test DNS resolution:
1 dig +short mc.your-domain.com

Conclusion

Running a Minecraft server for small groups exemplifies the DevOps principle that “simple” systems still demand professional-grade infrastructure management. Through this guide, we’ve demonstrated how to:

Right-size hardware allocations based on player count
Implement production-ready deployments via Docker/systemd
Tune JVM and server parameters for optimal performance
Establish monitoring and backup routines
Troubleshoot common operational issues

The journey from “it works on my machine” to a reliable multiplayer experience mirrors professional infrastructure challenges - resource contention, latency optimization, and graceful degradation under load. What starts as a hobby project becomes a masterclass in practical systems administration.

For those looking to expand their setup:

Explore Kubernetes operators for Minecraft clustering
Implement Terraform for cloud-based server provisioning
Integrate with Discord bots using MCDiscordChat
Study PaperMC documentation for advanced tuning

Remember that every environment differs - monitor, measure, and iterate. Your perfect two-friends-and-me server configuration awaits at the intersection of technical rigor and gaming joy.

Open Source, Reddit Guides, Kubernetes

This post is licensed under CC BY 4.0 by the author.

I Can Finally Run Minecraft Server For Me And My 2 Friends

Introduction

Understanding Minecraft Server Infrastructure

Technical Architecture Overview

Resource Allocation Breakdown

Server Software Options

Prerequisites

Hardware Requirements

Software Dependencies

Security Checklist

Installation & Setup

Manual Server Deployment

Docker Deployment (Production-Grade)

Systemd Service Configuration

Configuration & Optimization

Critical server.properties Settings

JVM Tuning Best Practices

Performance Optimization Techniques

Security Hardening

Usage & Operations

Daily Management Commands

Monitoring Essentials

prometheus.yml

Backup and Recovery

Troubleshooting Common Issues

Server Won’t Start

Lag Spikes During Gameplay

Connection Timeouts

Conclusion

Trending Tags