OPS - Rethinking Cloud Infrastructure
Tags: unikernels, serverless, containers, virtualization
Published: 2019-01-22 21:46:39

---
title: OPS - Rethinking Cloud Infrastructure
published: true
description: Unikernels used to be in-accessible to the average developer due to their low level nature. OPS is a free open source tool created to fix that problem and let even non-developers run them locally on their laptop or cloud.
tags: unikernels, serverless, containers, virtualization
---

Unikernels have been a technology that have been predicted for the past few years to be the future of software infrastructure.

Wait - hold up - what's a unikernel!? One way to think of a unikernel is what would happen if you converted your application into it's own operating system. It is a single purpose operating system versus a general purpose one like Linux. Another really large difference is that a unikernel is meant to only run one application per server. Since practically everything that is deployed to day is deployed onto virtual machines (eg: *all* of public cloud) unikernels propose that you don't need a full blown operating system for each application you want to deploy. This makes them run faster, more secure and they become way tinier.

However, unikernels have not been without their problems. One of these problems that unikernels have traditionally suffered from is that to truly utilize them in the past you had to have been a systems developer or a low level c programmer.

Not anymore.

[OPS](https://ops.city) is a tool to help anyone build and run unikernels in whatever language or as whatever application they want. OPS simply loads ELF binaries just like Linux does but with unikernel benefits. Before 'unikernels' we had what were known as 'library operating systems'. OPS and the kernel that it uses 'Nanos' embraces that concept. They are both under heavy active development and have a full time team of paid kernel engineers working on it. (This has also been historically a big problem for the ecosystem.)

For local development OPS works on linux or mac currently.

To get started you'll want to install the cli tool - if you aren't a Go user you can just download the binary from the site but if you are a Go user than you can build it yourself as well once you obtain the [source](https://github.com/nanovms/ops) .

### Install

```
$ curl https://ops.city/get.sh -sSfL | sh
```

Let's try out a quick Node.js hello world.

Put this into a file:

```
  console.log("Hello World!");
```

Then you can run it.

```
  $ ops load node_v11.15.0 -a ex.js
```

Easy huh? Want to try something a bit more complicated? Let's try a Go webserver.

Put this into main.go:

```
  package main

  import (
      "log"
      "net/http"
  )

  func main() {
      fs := http.FileServer(http.Dir("static"))
      http.Handle("/", fs)

      log.Println("Listening...on 8080")
      http.ListenAndServe(":8080", nil)
  }
```

If you are on a mac specify the os as 'linux'. It's important to note that it's not running linux underneath - at all. Unikernels aren't containers. The only reason we specify GOOS as linux is that Nanos implements the POSIX standard (to some degree) and loads our programs as ELFs.

```
  $ GOOS=linux go build main.go
```

You can verify this by looking at the filetype:

```
➜  twe  file main
main: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
```

Note that I built this on a mac whose native file type is a Mach-O. We mainly support ELF since that is what is deployed to production.

```
➜  twe  file main
main: Mach-O 64-bit executable x86_64
```

Now let's create a folder to put our static assets in:

```
  $ mkdir static
  $ cd static
```

```
  <!doctype html>
  <html>
  <head>
  <meta charset="utf-8">
      <title>A static page</title>
  </head>
  <body>
      <h1>Hello from a static page</h1>
  </body>
  </html>
```

Then let's specify a config.json for this:

```
 {
      "Dirs" : ["static"]
  }
```

This simply states that we wish to put the directory 'static' into /static as a folder in our filesystem. There are many advanced options that you can explore with OPS config.json but please be aware that it is under active development and a lot of it can and will change.

Now we are going to run it. OPS implements a very small wrapper around QEMU. Qemu allows us to run the resulting built image as a virtual machine. The virtual machine is the output of ops building your app as it's own unique little operating system. Have you ever wondered to build your own operating system? Well you just did.

By default OPS will run your unikernel in what's known as 'user-mode' networking without KVM acceleration. Usermode networking is a bit slower than a proper bridged network (what you'd get on AWS or GCE) but we are playing around on your laptop so this is easy to get started with. Also, keep in mind that we run this as a non-root user by default and by default KVM will want root privileges. As a more advanced lesson later we'll show you how to configure that properly. Also keep in mind that on mac we don't have access to KVM, however, there is an equivalent - Intel HAX which we can use if we want.

```
  $ ops run -p 8080 -c config.json server
```

Now that it is running you should be able to run curl against your server and wah-lah!

```
  curl http://localhost:8080/hello.html
```

You've just built and ran your first Go webserver as a unikernel! How cool is that?

Check out the github repo, star it and let's see what else can be created!

{% github nanovms/ops %}