In this book, you will learn to use the Go programming language to build robust, production-ready software applications. You will learn just enough to build command line tools and applications communicating over HTTP and gRPC.

Practical Go: Building Scalable Network and Non-Network Applications

Preface

In this chapter, you will learn about the building blocks of writing command-line applications. You will use standard library packages to construct command-line interfaces, accept user input, and learn techniques to test your applications. Let's get started!

Writing Command-Line Applications

In this chapter, you will learn how to use the flag package to implement command-line applications with sub-commands. Then, you will see how you can enforce predictable behavior in your command-line applications using contexts. Finally, you will learn how to combine contexts and handling operating system signals in your application. Let's jump in.

Advanced Command-Line Applications

In this chapter, you are going to learn about the building blocks of writing testable HTTP clients. You will become familiar with key concepts—sending and receiving data, serialization and deserialization, and working with binary data. Once you grasp these concepts, you will be able to write stand-alone client applications and a Go client for your service's HTTP API and make HTTP API calls as part of a service-to-service communication architecture. As you progress through the chapter, you will be enhancing the mync http sub-command by implementing these features and techniques. Let's get started!

Writing HTTP Clients

In this chapter, you are going to do a deep dive into writing HTTP clients. The last chapter focused on performing various operations over HTTP. This chapter focuses on the techniques used to write HTTP clients that are robust and scale well. You will learn to enforce time-outs in your clients, create client middleware, and explore connection pooling. Let's get started!

Advanced HTTP Clients

In this chapter, you will dive into the basics of writing HTTP servers. You will learn how handler functions work, discover more about processing requests, and study how to read and write streaming data. You scratched the surface of these topics a bit in the previous chapter. Now it's time to dive in.

Building HTTP Servers

In this chapter, you will learn techniques that will be useful when you are writing production-quality HTTP server applications. You will start by learning about the http.Handler type, and you will use it to share data across handler functions. Then you will learn how to implement common server functionality as middleware. You will learn about the http.HandlerFunc type and use it to define and chain together middleware. You will end the chapter by looking at a strategy to organize your server application and test the various components. Let's get started!

Advanced HTTP Server Applications

In this chapter, you will learn about techniques to improve the robustness and stability of HTTP server applications. You will learn how to implement time-outs at various points of your server's request handling life cycle, abort request processing to preserve server resources, and implement graceful shutdowns. Finally, you will learn how to configure your HTTP server so that there is a secure communication channel between a client and your server. Let's get started!

Production-Ready HTTP Servers

In this chapter, you will learn to build network applications that use Remote Procedure Call ( RPC) for communication. Although the standard library supports building such applications, we will do so using gRPC, an open-source universal RPC framework. We will start off with a quick background discussion of RPC frameworks, and we will end the chapter having learned to write completely testable gRPC applications. Along the way, you will also learn to use Protocol Buffers, an interface description language and a data interchange format that enables client-server communication over gRPC. Let's jump right in.

Building RPC Applications with gRPC

In the first half of this chapter, you will learn how to implement streaming communication patterns in gRPC applications. In the latter half, you will learn to implement common server and client functionality as middleware components. Along the way, you will learn how to send and receive binary data and understand more about Protocol Buffers. Let's jump in!

Advanced gRPC Applications

In this chapter, you will start by learning how to implement TLS-enabled secure gRPC applications. Then you will study techniques to implement health checks, handle runtime errors, and cancel processing in your server applications. After that, you will learn about techniques to improve the robustness of your client applications, such as configuring time-outs for various operations and handling transient failures. In the final section, you will learn how connections between clients and servers are internally managed by the gRPC library. Let's dive in!

Production-Ready gRPC Applications

In this chapter, you will learn to interact with data stores from your applications. I have chosen two types of data stores based on their general applicability to different kinds of applications. You will first learn to interact with object storage services, which allow storing unstructured data blobs. Then you will learn to interact with relational databases. We will use an example HTTP server as the sample application, where we will implement various functionality related to interacting with data stores. We will implement a server to store software packages, first introduced in Chapter 3, “Writing HTTP Clients.” It will offer the following features to its clients:

Working with Data Stores

In this appendix, I will provide some guidelines around implementing techniques to make your application behavior observable via telemetry data . These data are usually categorized into logs , metrics , and traces . All three kinds of data can help you understand what your application is doing and help you answer different kinds of questions about its internal state at a given point of time. First, we will go over the categories of telemetry data that are useful to emit from an application and Go packages that help you implement them. Then we will look at examples of how you can integrate them into your applications.

APPENDIX A: Making Your Applications Observable

In this appendix, we are going to discuss strategies to manage the configuration, distribution, and deployment of your applications. The landscape is vast, and the specific strategies that you follow are usually determined by the infrastructure into which you are deploying your applications. By no means do I aim to be exhaustive; rather, I only seek to provide you with generic guidelines.

APPENDIX B: Deploying Applications

A accessing underlying driver types, 325–327 adding headers to all requests, 96–99 Amazon Web Services Simple Storage Service (S3), 312, 313 Apache Thrift, 194 apiHandler() function handler functions and, 109 testing handler functions, 153 AppendToOutgoingContext() function, 259, 260 applications command-line, 1–32 deploying, 367–373 distributing, 370–372 gRPC, 193–272, 275–309, 364–365 making observable, 349–365 required vs. optional options, 15 server, 372–373 arbitrary bytes, receiving and sending, 247–256 architecture, for sub-command-driven applications, 37–43 As() method, 326 Atoi() function, 4 attaching metadata to requests, 118–121 autocert (website), 278 

Community Questions