Go Language for Ops and Site Reliability Engineering

Operations vs Site Reliability Engineering

Operations

• Interrupt driven
• Repetitive
• Hard to scale

Site Reliability Engineering

• Project oriented
• Values automation
• Focus on scale

Go Programming Language

"Go is an open source programming environment that makes it easy to build simple,
reliable, and efficient software." -- golang.org

Hello OSCON

package main

import (
    "flag"
    "fmt"
)

var message = flag.String("message", "Hello, OSCON!", "what to say")

func main() {
    flag.Parse()
    fmt.Println(*message)
}

$ go run hello.go -help
Usage of /tmp/go-build212699297/command-line-arguments/_obj/a.out:
  -message="Hello, OSCON!": what to say
exit status 2

Programming for SRE and Ops - State of the Union

• "I will just write a small throw away script for that"

• "I don't want to learn a new language"

• "Language X is awesome and solves everything"

Programming for SRE and Ops - Where do we go?

• One liners are here to stay

• Throw away scripts too so let's make them better

• Think of languages you can read as a toolkit

• Get very good at writing in just a few of them

Agenda

• Why Go for Ops and SRE?

• Go features

• Go in production at Google

• Go in production outside Google

• Q&A

Why Go for Ops and SRE? Simple, reliable and efficient

• Open Source

• One binary to rule them all

• No need for a Makefile, import defined dependencies

• Very fast compilation

Why Go for Ops and SRE? Simple, reliable and efficient

• Garbage collection

• Readability is easy to achieve via gofmt

• RE2 regular expressions

• Testing, benchmarking and profiling built-in

Why Go for Ops and SRE? Standard library examples

fmt

io/ioutil

net/http

os/exec

path/filepath

regexp

strings

text/tabwriter

time

pkg.go.dev to your needs beyond the standard library

Why Go for Ops and SRE? Concurrency via Goroutines

package main

import (
    "fmt"
    "time"
)

func main() {
    go say("ho!", 2*time.Second)  // &
    go say("hey!", 1*time.Second) // &

    // Make main sleep for 4 seconds so goroutines can finish
    time.Sleep(4 * time.Second)
}

// say prints text after sleeping for X secs
func say(text string, secs time.Duration) {
    time.Sleep(secs)
    fmt.Println(text)
}

Why Go for Ops and SRE? Concurrency and Channels

// +build ignore,OMIT

package main

import (
	"fmt"
	"time"
)

func main() {
    textChannel := make(chan string)
    words := []string{"ho!", "hey!"}
    secs := []int{2, 1}
    // Create a goroutine per word
    for i, word := range words {
        go say(word, secs[i], textChannel) // &
    }
    // Wait for response via channel N times
    for _ = range words {
        fmt.Println(<-textChannel)
    }
}

// say sends word back via channel after sleeping for X secs
func say(word string, secs int, textChannel chan string) {
    time.Sleep(time.Duration(secs) * time.Second)
    textChannel <- word
}

Go features

• Hashes or dicts? Maps

• Arrays? Yes, but you will probably want to use Slices instead

• Modules are called Packages

• Structs

• Methods

• Pointers without arithmetic operations

Go grows with you - see interfaces and reflection

Go in production at Google

dl.google.com - OSCON talk by Brad Fitzpatrick Friday, 10:00am

Vitess

vtocc: front-end to MySQL that improves scalability

Emtail

Whitebox monitoring data from logs to a timeseries database

Go Commander

Command line library for Go

Machine lifecycle management

via App Engine

Go in production outside Google

Pipe

Unix-like pipelines for Go

Gocircuit

Inter host Goroutines

Juju

Service orchestration management tool

Docker

Containers management tool

Packer

Tool for creating identical machine images for multiple platforms

Q&A

Take the tour - [[tour.golang.org]]

Thank you