TL;DR Le code

Introduction

Since I am a big fan of Minecraft and Pulumi I wanted to combine both and see If I am able to use Scala as programming language. As we all know, Pulumi is a multi-language framework and supports many languages. And since now a while, also Java. Scala is a JVM language and compiles to Java bytecode. So I thought, why not give it a try.

Prerequisites

To follow this tutorial you need to have the following installed:

• The Pulumi CLI and a backend to host your state. I am using the Pulumi Service. It is free for open source projects.
• Scala
• DigitalOcean Account and API Token. You can create here an account and get $200 credit for 60 days.
• IDE of your choice. I am using IntelliJ IDEA. Add the Scala plugin to your IDE, for a more pleasant experience.

What is Scala?

I shamelessly copied this from the Scala website:

Scala combines object-oriented and functional programming in one concise, high-level language. Scala's static types help avoid bugs in complex applications, and its JVM and JavaScript runtimes let you build high-performance systems with easy access to huge ecosystems of libraries.

There you go, I could not better explain this myself.

Install Scala

I am using homebrew to install Scala on my Mac. So the installation is as easy as:

brew install coursier/formulas/coursier && cs setup

Create a new Pulumi project

After the installation of Scala I create a new Scala project with the following command:

sbt new scala/scala3.g8

And use as project name pulumi-scala-minecraft. This will create a new directory with the name pulumi-scala-minecraft and some files in it. We will change this files, no worries.

To add Pulumi, I just added a Pulumi.yaml file with the following content:

name: pulumi-scala-minecraft
description: A minimal Java Pulumi program with Maven builds
runtime:
  name: java

Now we can add the Pulumi dependencies to our project. We need the Pulumi core library and the Pulumi DigitalOcean provider.

Open the build.sbt file and add the following dependencies after the exiting libraryDependencies line:

val scala3Version = "3.2.1"

lazy val root = project.in(file(".")).settings(
  name := "pulumi-scala-minecraft",
  version := "0.1.0-SNAPSHOT",

  scalaVersion := scala3Version,

  libraryDependencies += "org.scalameta" %% "munit" % "0.7.29" % Test,
  libraryDependencies += "com.pulumi" % "pulumi" % "0.6.0",
  libraryDependencies += "com.pulumi" % "digitalocean" % "4.16.0",
  libraryDependencies += "com.pulumi" % "command" % "4.5.0",
)

Some remarks: I am using Scala 3.2.1 for this tutorial.

Now I create a package io.dirien.minecraft in the src/main/scala directory and add a file App$.scala to it. This will be our main class. Add the following content to the file:

package io.dirien.minecraft


import com.pulumi.{Context, Pulumi}
import io.dirien.minecraft.MinecraftServer

object App {

  final val region = "fra1"
  final val size = "c2-4vcpu-8gb"
  final val image = "ubuntu-22-04-x64"


  def main(args: Array[String]): Unit = {
    Pulumi.run { (ctx: Context) =>

      val minecraftServer = new MinecraftServer(image, region, size)
      val ip = minecraftServer.infrastructure()

      ctx.`export`("public ip", ip)
    }
  }
}

As you can see, we created a new Object App with a main method. In this method we create a new instance of our MinecraftServer class and call the infrastructure method. This method will create the infrastructure for our Minecraft Server. The infrastructure method returns the public IP address of the Droplet. We export this IP address with the export method of the Context class. This will make the IP address available as output of our Pulumi program.

Create the MinecraftServer class

The MinecraftServer class is the heart of our Pulumi program. It will create the infrastructure for our Minecraft Server. We will use the DigitalOcean provider to create a Droplet and a Floating IP. The Droplet will use cloud-init to download, install and configure the Minecraft Server.

Create a new file MinecraftServer.scala in the src/main/scala/io/dirien/minecraft directory and add the following content:

package io.dirien.minecraft

import com.pulumi.core.Output
import com.pulumi.digitalocean.{Droplet, DropletArgs, SshKey, SshKeyArgs}
import com.pulumi.{Context, Pulumi}
import com.pulumi.command.remote.{Command, CommandArgs}
import com.pulumi.command.remote.inputs.ConnectionArgs

import scala.io.Source

class MinecraftServer(image: String, region: String, size: String) {

  def readFile(path: String): String = {
    val file = Source.fromFile(path)
    val fileContent = try file.mkString finally file.close()
    fileContent
  }

  def infrastructure(): Output[String] = {
    val cloudInit = readFile("src/main/resources/cloud-init.yaml")
    val sshPublicKeyString = readFile("src/main/resources/minecraft.pub")

    val sshKey = new SshKey("minecraft-scala", SshKeyArgs.builder
      .publicKey(sshPublicKeyString)
      .build())

    val fingerprints: Output[java.util.List[String]] = sshKey.fingerprint().apply(fingerprint => {
      Output.listBuilder().add(fingerprint).build()
    })

    val minecraftServer = new Droplet("minecraft", DropletArgs.builder
      .image(this.image)
      .region(this.region)
      .size(this.size)
      .userData(cloudInit)
      .sshKeys(
        fingerprints
      )
      .build())

    val privateKey = readFile("src/main/resources/minecraft")

    new Command("install-minecraft", CommandArgs.builder()
      .connection(ConnectionArgs.builder()
        .host(minecraftServer.ipv4Address())
        .privateKey(privateKey)
        .user("root")
        .build())
      .create("cloud-init status --wait")
      .build())

    minecraftServer.ipv4Address()
  }
}

You can see that we have a constructor with three parameters: image, region and size. These parameters are used to create the Droplet.

As you may have spotted, we have a method readFile which reads a file from any given path and takes care of closing the Source.

There is one convenience Pulumi resource called Command. This resource allows us to execute a command on a remote host. In this case, we use it to wait for the cloud-init script to finish.

Before I forget, you need to create an ssh key pair. You can do this with the following command:

ssh-keygen -f $PWD/minecraft

and copy both files minecraft and minecraft.pub to the src/main/resources directory. Of course, you can use any other name and path, but you need to adjust the calls to readFile in the MinecraftServer class.

That's it from the code side. Now we can run our Pulumi program.

Run the Pulumi program

Set the DIGITALOCEAN_TOKEN environment variable to your DigitalOcean API token.

export DIGITALOCEAN_TOKEN=your-token

Now you can run the Pulumi program with the following command:

sbt update
pulumi up -f -y

The first command will download all dependencies. The second command will run the Pulumi program.

After a few minutes, you should see the following output:

❯ pulumi up -f -y     
Please choose a stack, or create a new one: dev
Updating (dev)

View Live: https://app.pulumi.com/dirien/pulumi-scala-minecraft/dev/updates/22

     Type                           Name                        Status             
 +   pulumi:pulumi:Stack            pulumi-scala-minecraft-dev  created (44s)      
 +   ├─ digitalocean:index:SshKey   minecraft-scala             created (1s)       
 +   ├─ digitalocean:index:Droplet  minecraft                   created (41s)      
 +   └─ command:remote:Command      install-minecraft           created (122s)     


Outputs:
    public ip: "xx.yy.zz.aa"

Resources:
    + 4 created

Duration: 2m53s

You can see that we created a new stack called dev. The stack contains the resources we created. You can see the IP address of the Droplet in the output section.

Connect to the Minecraft Server

Copy the IP address from the output section and connect to the server in your Minecraft client.

Enjoy your Minecraft Server!

Clean up

To clean up the resources, run the following command:

pulumi destroy -f -y

Conclusion

It was very interesting to create a Pulumi program with Scala. I can see why so many developers love Scala. And it works really well with Pulumi. I hope you enjoyed this article. If you have any questions or comments, please let me know in the comments section.