Every resource, explained

Kobblestone adds a set of custom resources to your cluster. Here is what each one does. Each example is a complete manifest you can apply.

Alpha and highly experimental. All resources are in the v1alpha1 API version. Some features and concepts are not fully implemented yet, and fields and behavior can change between releases, sometimes with manual migration steps. Don't rely on Kobblestone for production worlds yet.

Run servers

Servers and the proxies that join them into networks.

Server

A single Minecraft server with its own storage. Pick from Vanilla, Paper, Purpur, Folia, Fabric, Quilt, Forge and more, set a game version, and Kobblestone handles the rest. Auto sleep pauses empty servers, or hibernates them until a player connects through a Router.

server.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Server
metadata:
name: survival
spec:
eula: true
type: Purpur
version: "26.2"
storage:
size: 5Gi
resources:
limits:
memory: 4Gi
autoSleep:
mode: Hibernate
timeoutSeconds: 300

Network

A Velocity proxy and the servers behind it, so players can move between them without reconnecting. The network creates its servers from a shared template and keeps them compatible with the proxy: forwarding, offline mode and access only through the proxy are set up for you. Existing servers can join with their data.

network.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Network
metadata:
name: my-network
spec:
serverTemplate:
eula: true
type: Paper
version: "26.2"
storage:
size: 2Gi
servers:
- name: lobby
- name: survival
hostname: survival.example.com
spec:
storage:
size: 20Gi

Route traffic

Expose one endpoint and route by hostname, or attach directly to your Gateway.

Router

One entry point for all your servers. The Router reads the hostname players connect to and forwards them to the matching backend, so servers can stay cluster-internal. Routers scale horizontally, can be exposed with a LoadBalancer Service or the Gateway API, and speak the PROXY protocol in both directions, so backends still see the real player IPs.

router.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Router
metadata:
name: my-router
spec:
replicas: 2
hostnames:
- "*.example.com"
service:
type: LoadBalancer
# or attach to a Gateway instead:
# tcpRoute:
# parentRefs:
# - name: my-gateway
# sectionName: minecraft
networking:
proxyProtocol:
# Accept PROXY protocol from your load balancer to keep real player IPs ...
receive: true
trustedProxies:
- 10.0.0.0/8
# ... and pass them on to backends that accept it (e.g. Velocity with haproxy-protocol)
send: true

Route

Maps a hostname on a Router to a backend: a Server, Network, another Router or any Service. Servers and Networks can also create their Route for you through spec.route.

route.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Route
metadata:
name: survival
spec:
parentRef:
name: my-router
hostname: survival.example.com
backendRef:
kind: Server
name: survival

Protect your worlds

Backups and restores, queued safely per server.

BackupRepo

Where backups go: any S3-compatible bucket, or a PersistentVolumeClaim inside the cluster.

backuprepo.yaml
apiVersion: kobblestone.io/v1alpha1
kind: BackupRepo
metadata:
name: offsite
spec:
type: S3
s3:
endpoint: https://s3.example.com
bucket: minecraft-backups
credentialsSecretRef:
name: offsite-credentials

Backup

A snapshot of a server in a BackupRepo. Running servers are backed up live, coordinated over RCON. Stopped servers are backed up offline. Backups and restores of one server run one after another.

backup.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Backup
metadata:
name: before-update
spec:
repoRef:
name: offsite
targetRef:
name: survival
retainPolicy: RequireDelete

Restore

Puts a Backup back onto a server. Stop the server first: the restore waits until it is stopped and keeps it stopped while it runs.

restore.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Restore
metadata:
name: rollback
spec:
backupRef:
name: before-update
targetRef:
name: survival
existingDataPolicy: Overwrite

Operate

Server commands as resources, so automation can use kubectl instead of a console.

Command

Runs one RCON command on a server and stores the response in the resource's status.

command.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Command
metadata:
name: announce
spec:
targetRef:
name: survival
command: say Restarting in 5 minutes

CommandGroup

Runs several commands on a server in order.

commandgroup.yaml
apiVersion: kobblestone.io/v1alpha1
kind: CommandGroup
metadata:
name: event-setup
spec:
targetRef:
name: survival
commands:
- command: time set day
- command: weather clear
- command: say Let the games begin!

Automate players

Real accounts and scriptable bots.

Account

A Microsoft account. Kobblestone starts the device code sign-in and shows the code in the Account's status. Once signed in, the session is kept fresh and stored in a Secret in a documented format, so any workload can mount it. The refresh token lives in a separate Secret.

account.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Account
metadata:
name: farmhand
spec: {}

Bot

A Minecraft-Console-Client instance connected to a Server, Network or host. Program it with MCC's own configuration, command scripts and C# scripts, inline or from ConfigMaps and Secrets. Bots that use an Account restart automatically with each refreshed session.

bot.yaml
apiVersion: kobblestone.io/v1alpha1
kind: Bot
metadata:
name: farmer
spec:
target:
targetRef:
kind: Server
name: survival
auth:
accountRef:
name: farmhand
config:
inline: |
[ChatBot.AutoEat]
Enabled = true
scripts:
- name: greet.txt
runOnLogin: true
inline: |
send Hello from Kobblestone!

Every field is documented in the CRDs themselves, so kubectl explain works out of the box. Browse the API reference or the documentation for all options.