blog-ahmza-com/content/posts/mc-server-on-docker/index.md

---
title: Minecraft Server on Docker ⛏ 🐳
description: Ever wanted to build a Minecraft server in docker !! Start here
tags:
  - docker
  - games
author: ahmza
date: 2022-05-24
draft: false
weight:
featureimage: feature.webp
lastmod: 2024-07-20
---

## Introduction

Minecraft is a great game that becomes even more enjoyable when played with
friends. One of the best ways to do this is by setting up a dedicated server.
This guide will help you do just that!

Setting up and running a Minecraft server does not require a lot of resources,
but based on my experience, allocating more resources significantly enhances
performance, especially when you start to add mods and increase player count.

## Prerequisites

- Docker
- Docker Compose

For more information about my Docker setup, see [Pi Cluster](/posts/pi-docker-swarm/)

## Requirements

_Requirements Gathered from [here](https://minecraft.fandom.com/wiki/Server/Requirements/Dedicated#Unix_.28Linux.2C_BSD.2C_macOS.29)_

### Minimum (1-5 Players)

```
- Intel Pentium 4 or AMD Athlon based CPU
- 512 MB RAM
- 2 GB Storage space
```

### Recommended (10-15 Players)

```
- Intel Core or AMD K8 based CPU
- 3 GB RAM
- 16 GB Storage Space
```

### Optimal (20+ Players)

```
- Intel i5/i7 or AMD Ryzen 5/7 Based CPU
- 6 GB RAM
- 35 GB Storage Space
```

**My opinion:**

I personally went with the optimal settings as I wanted to run mods as well as
have the capacity for ~10 players. This gives the server breathing room.

However, if you will be running no mods or only a few lightweight mods and only
a few players, there is no need to go higher than 3-4 GB.

## Building the Container

Let's get started on building the Minecraft server.

1. **Create a directory for the Minecraft server files:**

```bash
# Make the folder
mkdir minecraft-server
# Enter the folder
cd minecraft-server
```

2. **Create an environment file for the Docker Container:**
- The `.env` file allows us to specify variables used in the build process.

```bash
# Create a .env file
touch .env
# Open in a text editor
vim .env
# Enter the following variables
CONTAINER_NAME=minecraft-server
SERVER_MEM=4096 # Change this to your desired value (in MB)
SERVER_JAR=<downloaded-server-file>.jar # Minecraft server jar file. Change this later
```

3. **Create the `docker-compose.yml` file:**

```bash
# Create the file
touch docker-compose.yml
# Open in a text editor
vim docker-compose.yml
```

- `docker-compose.yml` specifies the configuration of our Minecraft server:
		- Build a Docker image using the current context and pass some arguments.
		- Attach the volume .server-data where Minecraft's files will be stored.
		- Open network ports to access the Docker container.
		- Name the Docker container.
		- Ensure the container always restarts unless explicitly stopped.

```yaml
services:
  minecraft-server:
    build:
      context: .
      args:
        SERVER_MEM: ${SERVER_MEM}
        SERVER_JAR: ${SERVER_JAR}
    volumes:
      - .server-data:/server
    ports:
      - 25565:25565 # Game
      - 25575:25575 # RCON
    container_name: ${CONTAINER_NAME}
    restart: unless-stopped

volumes:
  server-data:
```

4. **Create the `Dockerfile`:**

- Referenced in the `docker-compose.yml` build stage as context `.`.
- The `Dockerfile` specifies the software running inside the container.

```bash
# Create the file
touch Dockerfile
# Open the file in a text editor
vim Dockerfile
```

- Use the [eclipse-temurin:21](https://hub.docker.com/_/eclipse-temurin) image to provide the Java JRE
		- Use the required Java version for the version of Minecraft you are running.
- Collect the arguments from the .env file.
- Set the environment variables.
- Set the working directory to /server, on our local system is .server-data.
- Run the Minecraft server jar with the environment variables.

```Dockerfile
FROM eclipse-temurin:21

ARG SERVER_MEM
ARG SERVER_JAR

ENV SERVER_MEM=${SERVER_MEM}
ENV SERVER_JAR=${SERVER_JAR}

WORKDIR /server

CMD echo "Minecraft Server is starting\n" && java -Xms128M -Xmx${SERVER_MEM}M -jar ${SERVER_JAR} nogui
```

## Setup the Server Files

We're almost there, just a few steps to go.

When you try to start the container, you might encounter the following error:

```bash
Minecraft Server is starting

Error: Unable to access jarfile server.jar
```

This happens because we haven't downloaded the server jar file yet. Let's do that now.

1. **Create a folder in the `minecraft-server` directory called `.server-data`:**

```bash
mkdir .server-data
cd .server-data
```

2. **Download a Minecraft server jar file:**

- [Vanilla Minecraft Server](https://www.minecraft.net/en-us/download/server)
		- Right-click the green link that says minecraft_server.<version>.jar and copy the link address.
		- Download with: curl -o server.jar <link you copied here>
- [Fabric Mod loader server](https://fabricmc.net/use/server/)
		- Select the Minecraft version, Fabric Loader Version, and the Installer Version of your choice. I tend to go with the latest.
		- Download with: Copy the curl command under CLI download

3. **Go back to the root `minecraft-server` directory:**

```bash
cd ..
```

4. **Edit `SERVER_JAR in` `.env` with the name of the server file you just downloaded:**

```bash
# Open in a text editor
vim .env
# Enter the following variables
CONTAINER_NAME=minecraft-server
SERVER_MEM=4096
SERVER_JAR=<downloaded-server-file>.jar # Change this to the name of the .jar you downloaded
```

5. **Run the container to generate necessary files like `eula.txt`:**

```bash
docker compose up
```

You will see something like this:

```bash

minecraft-server  | Starting net.minecraft.server.Main
minecraft-server  | [18:05:50] [ServerMain/INFO]: You need to agree to the EULA in order to run the server. Go to eula.txt for more info.
minecraft-server exited with code 0
```

6. **Accept the EULA:**

```bash

# Edit eula.txt in a text editor
vim .server-data/eula.txt
# Change `eula=false` to `eula=true`
eula=true
```

7. **Make any additional changes you want:**
- Notable files:
		- server.properties - Configure server name, game mode, world type, etc.
		- ops.json - Server operators (can be set in-game).
		- whitelist.json - Players allowed to join the server (can be set in-game).

## Run the Server

**Run the container in detached mode:**

```bash
# The -d flag allows the container to run in detached mode, i.e., in the background
docker compose up -d
```

**To monitor the logs as the server starts:**

```bash
# Monitor the logs as the server starts. Use CTRL+C to exit
docker logs minecraft-server --follow
# If you see the following lines, your server is up and running:
    [18:17:01] [Server thread/INFO]: Time elapsed: 25529 ms
    [18:17:01] [Server thread/INFO]: Done (34.571s)! For help, type "help"
```

## Conclusion

Congratulations! You've successfully set up a Minecraft server. Now it's time
to play!

There are many exciting possibilities from here, such as installing mods or
creating scripts to manage the server. Enjoy your Minecraft adventures!