Book Image

Go for DevOps

By : John Doak, David Justice
5 (1)
Book Image

Go for DevOps

5 (1)
By: John Doak, David Justice

Overview of this book

Go is the go-to language for DevOps libraries and services, and without it, achieving fast and safe automation is a challenge. With the help of Go for DevOps, you'll learn how to deliver services with ease and safety, becoming a better DevOps engineer in the process. Some of the key things this book will teach you are how to write Go software to automate configuration management, update remote machines, author custom automation in GitHub Actions, and interact with Kubernetes. As you advance through the chapters, you'll explore how to automate the cloud using software development kits (SDKs), extend HashiCorp's Terraform and Packer using Go, develop your own DevOps services with gRPC and REST, design system agents, and build robust workflow systems. By the end of this Go for DevOps book, you'll understand how to apply development principles to automate operations and provide operational insights using Go, which will allow you to react quickly to resolve system failures before your customers realize something has gone wrong.

Related Content you might be interested in

Current Title:

Small book image
Go for DevOps
John Doak | David Justice
Jul, 2022 | 634 pages
Small book image
The Kubernetes Operator Framework Book
Michael Dame
Jul, 2022 | 328 pages
Small book image
HashiCorp Infrastructure Automation Certification Guide
Ravi Mishra
Jul, 2021 | 350 pages
Small book image
Effective Concurrency in Go
Burak Serdar
Apr, 2023 | 212 pages
Table of Contents (22 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Share your thoughts
Download a Free PDF copy of this book
1
Section 1: Getting Up and Running with Go
Section 1: Getting Up and Running with Go
Free Chapter
2
Chapter 1: Go Language Basics
Chapter 1: Go Language Basics
Technical requirements
Using the Go Playground
Utilizing Go packages
Using Go's variable types
Looping in Go
Using conditionals
Learning about functions
Defining public and private
Using arrays and slices
Understanding Go pointers
Getting to know about structs
Comprehending Go interfaces
Summary
3
Chapter 2: Go Language Essentials
Chapter 2: Go Language Essentials
Handling errors in Go
Utilizing Go constants
Using defer, panic, and recover
Utilizing goroutines for concurrency
Understanding Go's Context type
Utilizing Go's testing framework
Generics – the new kid on the block
Summary
4
Chapter 3: Setting Up Your Environment
Chapter 3: Setting Up Your Environment
Technical requirements
Installing Go on your machine
Building code locally
Summary
5
Chapter 4: Filesystem Interactions
Chapter 4: Filesystem Interactions
All I/O in Go are files
Reading and writing to files
Streaming file content
OS-agnostic pathing
OS-agnostic filesystems
Summary
6
Chapter 5: Using Common Data Formats
Chapter 5: Using Common Data Formats
Technical requirements
CSV files
Popular encoding formats
Summary
7
Chapter 6: Interacting with Remote Data Sources
Chapter 6: Interacting with Remote Data Sources
Technical requirements
Accessing SQL databases
Developing REST services and clients
Developing gRPC services and clients
Summary
8
Chapter 7: Writing Command-Line Tooling
Chapter 7: Writing Command-Line Tooling
Technical requirements
Implementing application I/O
Using Cobra for advanced CLI applications
Handling OS signals
Summary
9
Chapter 8: Automating Command-Line Tasks
Chapter 8: Automating Command-Line Tasks
Technical requirements
Using os/exec to automate local changes
Using SSH in Go to automate remote changes
Designing safe, concurrent change automations
Writing a system agent
Summary
10
Section 2: Instrumenting, Observing, and Responding
Section 2: Instrumenting, Observing, and Responding
11
Chapter 9: Observability with OpenTelemetry
Chapter 9: Observability with OpenTelemetry
Technical requirements
An introduction to OpenTelemetry
Logging with context
Instrumenting for distributed tracing
Instrumenting for metrics
Alerting on metrics abnormalities
Summary
12
Chapter 10: Automating Workflows with GitHub Actions
Chapter 10: Automating Workflows with GitHub Actions
Technical requirements
Understanding the basics of GitHub Actions
Building a continuous integration workflow
Building a release workflow
Creating a custom GitHub Action using Go
Publishing a custom Go GitHub Action
Summary
13
Chapter 11: Using ChatOps to Increase Efficiency
Chapter 11: Using ChatOps to Increase Efficiency
Technical requirements
Environment architecture
Using an Ops service
Building a basic chatbot
Creating event handlers
Creating our Slack application
Summary
14
Section 3: Cloud ready Go
Section 3: Cloud ready Go
15
Chapter 12: Creating Immutable Infrastructure Using Packer
Chapter 12: Creating Immutable Infrastructure Using Packer
Technical requirements
Building an Amazon Machine Image
Validating images with Goss
Customizing Packer with plugins
Summary
16
Chapter 13: Infrastructure as Code with Terraform
Chapter 13: Infrastructure as Code with Terraform
Technical requirements
An introduction to IaC
Understanding the basics of Terraform
Understanding the basics of Terraform providers
Building a pet store Terraform provider
Summary
17
Chapter 14: Deploying and Building Applications in Kubernetes
Chapter 14: Deploying and Building Applications in Kubernetes
Technical requirements
Interacting with the Kubernetes API
Deploying a load-balanced HTTP application using Go
Extending Kubernetes with custom resources and operators
Building a pet store operator
Summary
18
Chapter 15: Programming the Cloud
Chapter 15: Programming the Cloud
Technical requirements
What is the cloud?
Learning the basics of the Azure APIs
Building infrastructure using Azure Resource Manager
Using provisioned Azure infrastructure
Summary
19
Chapter 16: Designing for Chaos
Chapter 16: Designing for Chaos
Technical requirements
Using overload prevention mechanisms
Using rate limiters to prevent runaway workflows
Building workflows that are repeatable and never lost
Using policies to restrict tools
Building systems with an emergency stop
Summary
20
Index
Index
Why subscribe?
21
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share your thoughts
Download a Free PDF copy of this book

Creating event handlers

The HandleFunc type we defined in the last sections handles the core of our functionality. This is also where we decide on how we want to turn a bunch of text into a command to run.

There are a few ways to interpret raw text:

  • Regexes via the regexp package
  • String manipulation via the strings package
  • Designing or using a lexer and parser

Regexes and string manipulation are the fastest ways for an application of this type where we have single lines of text.

Lexers and parsers are great when you need to deal with complex inputs or multi-line text and cannot afford mistakes. This is the method that compilers use to read your textual code into instructions that eventually lead to a compiled binary. Rob Pike has a great talk on writing one in Go that you can view here: https://www.youtube.com/watch?v=HxaD_trXwRE. The downside is that they are tedious to build and hard to train new people on. If you need to watch that video a few times...

Previous Section
End of Section 6
Next Section