Book Image

Go Cookbook

By : Aaron Torres

Book Image

Go Cookbook

By: Aaron Torres

Overview of this book

Go (a.k.a. Golang) is a statically-typed programming language first developed at Google. It is derived from C with additional features such as garbage collection, type safety, dynamic-typing capabilities, additional built-in types, and a large standard library. This book takes off where basic tutorials on the language leave off. You can immediately put into practice some of the more advanced concepts and libraries offered by the language while avoiding some of the common mistakes for new Go developers. The book covers basic type and error handling. It explores applications that interact with users, such as websites, command-line tools, or via the file system. It demonstrates how to handle advanced topics such as parallelism, distributed systems, and performance tuning. Lastly, it finishes with reactive and serverless programming in Go.

Preface

What this book covers

What you need for this book

Who this book is for

Reader feedback

Customer support

Free Chapter

I/O and File Systems

I/O and File Systems

Using the common I/O interfaces

Using the bytes and strings packages

Working with directories and files

Working with the CSV format

Working with temporary files

Working with text/template and HTML/templates

Command-Line Tools

Command-Line Tools

Using command-line flags

Using command-line arguments

Reading and setting environment variables

Configuration using TOML, YAML, and JSON

Working with Unix pipes

Catching and handling signals

An ANSI coloring application

Data Conversion and Composition

Data Conversion and Composition

Converting data types and interface casting

Working with numeric data types using math and math/big

Currency conversions and float64 considerations

Using pointers and SQL NullTypes for encoding and decoding

Encoding and decoding Go data

Struct tags and basic reflection in Go

Implementing collections via closures

Error Handling in Go

Error Handling in Go

Handling errors and the Error interface

Using the pkg/errors package and wrapping errors

Using the log package and understanding when to log errors

Structured logging with the apex and logrus packages

Logging with the context package

Using package-level global variables

Catching panics for long running processes

All about Databases and Storage

All about Databases and Storage

The database/sql package with MySQL

Executing a database transaction interface

Connection pooling, rate limiting, and timeouts for SQL

Working with Redis

Using NoSQL with MongoDB and mgo

Creating storage interfaces for data portability

Web Clients and APIs

Web Clients and APIs

Initializing, storing, and passing http.Client structs

Writing a client for a REST API

Executing parallel and async client requests

Making use of OAuth2 clients

Implementing an OAuth2 token storage interface

Wrapping a client in added functionality and function composition

Understanding GRPC clients

Microservices for Applications in Go

Microservices for Applications in Go

Working with web handlers, requests, and ResponseWriters

Using structs and closures for stateful handlers

Validating input for Go structs and user inputs

Rendering and content negotiation

Implementing and using middleware

Building a reverse proxy application

Exporting GRPC as a JSON API

Testing

Mocking using the standard library

Using the Mockgen package

Using table-driven tests to improve coverage

Using third-party testing tools

Practical fuzzing

Behavior testing using Go

Parallelism and Concurrency

Parallelism and Concurrency

Using channels and the select statement

Performing async operations with sync.WaitGroup

Using atomic operations and mutex

Using the context package

Executing state management for channels

Using the worker pool design pattern

Using workers to create pipelines

Distributed Systems

Distributed Systems

Using service discovery with Consul

Implementing basic consensus using Raft

Using containerization with Docker

Orchestration and deployment strategies

Monitoring applications

Collecting metrics

Reactive Programming and Data Streams

Reactive Programming and Data Streams

Goflow for dataflow programming

Reactive programming with RxGo

Using Kafka with Sarama

Using async producers with Kafka

Connecting Kafka to Goflow

Writing a GraphQL server in Go

Serverless Programming

Serverless Programming

Go programming on Lambda with Apex

Apex serverless logging and metrics

Google App Engine with Go

Working with Firebase using zabawaba99/firego

Performance Improvements, Tips, and Tricks

Performance Improvements, Tips, and Tricks

Speeding up compilation and testing cycles

Using the pprof tool

Benchmarking and finding bottlenecks

Memory allocation and heap management

Vendoring and project layout

Using fasthttprouter and fasthttp

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Understanding GRPC clients

GRPC is a high performance RPC framework that is built using protocol buffers (https://developers.google.com/protocol-buffers) and HTTP/2 (https://http2.github.io). Creating a GRPC client in Go has a lot of the same intricacies as working with Go HTTP clients. In order to demonstrate basic client usage, it's easiest to also implement a server. This recipe will create a greeter service, which takes a greeting and a name and returns the sentence <greeting> <name>!. In addition, the server can specify whether to exclaim ! or not ..

This recipe won't explore some details about GRPC such as streaming, but will hopefully serve as an introduction to creating a very basic server and client.

Getting ready

...