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

---
title: Minecraft Server on Docker ⛏ 🐳
date: 2022-05-24
lastmod: 2024-07-20
author: "ahmza"
draft: false
weight:

tags: ["games", "docker"]
description: "Ever wanted to build a Minecraft server in docker !! Start here"
---

## **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

See [Pi Cluster](/posts/pi-docker-swarm/)
for more information about my docker setup.

## **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 runing no mods or a few light weight mods and only a few
players then there really is no need to go higher than 3-4 GB.

## **Building the Container**

Lets 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_ is the spec of our Minecraft server.
  - Build a docker image using context . and pass some ARGS.
  - Attach volume .server-data, where Minecraft's files will be stored.
  - Open network ports to  access to the Docker container
  - Give the docker container a name
  - The container will always restart unless we tell it to stop.

```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_ file**:

- requested in docker-compose.yml build stage as context .
- The _Dockerfile_ is the spec for software running inside the container

```bash
# Create the file
touch Dockerfile
# Open the file in a text editor
vim Dockerfile
```
- We 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 ARGs from the .env file
- Set the environment variables
- Set the working directory to /server which on our local system is .server-data
- Run the minecraft server jar with the ENV 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 folder 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 folder**

```bash
cd ..
```

4. **Edit SERVER_JAR in .env with the name of the .jar 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 Minecraft Server

1. **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
```

```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!