Go: Building Web Applications电子书

Go: Building Web Applications

Table of Contents

Go: Building Web Applications

Go: Building Web Applications

Credits

Preface

What this learning path covers

What you need for this learning path

Who this learning path is for

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Module 1

1. Introducing and Setting Up Go

Installing Go

Structuring a project

Code conventions

Importing packages

Handling private repositories

Dealing with versioning

Introducing the net package

Hello, Web

Summary

2. Serving and Routing

Serving files directly

Basic routing

Using more complex routing with Gorilla

Redirecting requests

Serving basic errors

Summary

3. Connecting to Data

Connecting to a database

Creating a MySQL database

Using GUID for prettier URLs

Handling 404s

Summary

4. Using Templates

Introducing templates, context, and visibility

HTML templates and text templates

Displaying variables and security

Using logic and control structures

Summary

5. Frontend Integration with RESTful APIs

Setting up the basic API endpoint

RESTful architecture and best practices

Creating our first API endpoint

Implementing security

Creating data with POST

Modifying data with PUT

Summary

6. Sessions and Cookies

Setting cookies

Capturing user information

Creating users

Enabling sessions

Letting users register

Letting users log in

Initiating a server-side session

Creating a store

Utilizing flash messages

Summary

7. Microservices and Communication

Introducing the microservice approach

Pros and cons of utilizing microservices

Understanding the heart of microservices

Communicating between microservices

Putting a message on the wire

Reading from another service

Summary

8. Logging and Testing

Introducing logging in Go

Logging to IO

Multiple loggers

Formatting your output

Using panics and fatal errors

Introducing testing in Go

Summary

9. Security

HTTPS everywhere – implementing TLS

Preventing SQL injection

Protecting against XSS

Preventing cross-site request forgery (CSRF)

Securing cookies

Using the secure middleware

Summary

10. Caching, Proxies and Improved Performance

Identifying bottlenecks

Implementing reverse proxies

Implementing caching strategies

Using Least Recently Used

Caching by file

Caching in memory

Implementing HTTP/2

Summary

2. Module 2

1. Chat Application with Web Sockets

A simple web server

Templates

Doing things once

Using your own handlers

Properly building and executing Go programs

Modeling a chat room and clients on the server

Modeling the client

Modeling a room

Concurrency programming using idiomatic Go

Turning a room into an HTTP handler

Use helper functions to remove complexity

Creating and using rooms

Building an HTML and JavaScript chat client

Getting more out of templates

Tracing code to get a look under the hood

Writing a package using TDD

Interfaces

Unit tests

Red-green testing

Implementing the interface

Unexported types being returned to users

Using our new trace package

Making tracing optional

Clean package APIs

Summary

2. Adding Authentication

Handlers all the way down

Making a pretty social sign-in page

Endpoints with dynamic paths

OAuth2

Open source OAuth2 packages

Tell the authentication providers about your app

Implementing external logging in

Logging in

Handling the response from the provider

Presenting the user data

Augmenting messages with additional data

Summary

3. Three Ways to Implement Profile Pictures

Avatars from the authentication server

Getting the avatar URL

Transmitting the avatar URL

Adding the avatar to the user interface

Logging out

Making things prettier

Implementing Gravatar

Abstracting the avatar URL process

The authentication service and avatar's implementation

Using an implementation

Gravatar implementation

Uploading an avatar picture

User identification

An upload form

Handling the upload

Serving the images

The Avatar implementation for local files

Supporting different file types

Refactoring and optimizing our code

Replacing concrete types with interfaces

Changing interfaces in a test-driven way

Fixing existing implementations

Global variables versus fields

Implementing our new design

Tidying up and testing

Combining all three implementations

Summary

4. Command-line Tools to Find Domain Names

Pipe design for command-line tools

Five simple programs

Sprinkle

Exercise – configurable transformations

Domainify

Exercise – making top-level domains configurable

Coolify

Synonyms

Using environment variables for configuration

Consuming a web API

Getting domain suggestions

Available

Composing all five programs

One program to rule them all

Summary

5. Building Distributed Systems and Working with Flexible Data

System design

Database design

Installing the environment

NSQ

NSQ driver for Go

MongoDB

MongoDB driver for Go

Starting the environment

Votes from Twitter

Authorization with Twitter

Extracting the connection

Reading environment variables

Reading from MongoDB

Reading from Twitter

Signal channels

Publishing to NSQ

Gracefully starting and stopping

Testing

Counting votes

Connecting to the database

Consuming messages in NSQ

Keeping the database updated

Responding to Ctrl + C

Running our solution

Summary

6. Exposing Data and Functionality through a RESTful Data Web Service API

RESTful API design

Sharing data between handlers

Wrapping handler functions

API key

Database session

Per request variables

Cross-browser resource sharing

Responding

Understanding the request

A simple main function to serve our API

Using handler function wrappers

Handling endpoints

Using tags to add metadata to structs

Many operations with a single handler

Reading polls

Creating a poll

Deleting a poll

CORS support

Testing our API using curl

A web client that consumes the API

An index page showing a list of polls

A page to create a new poll

A page to show details of the poll

Running the solution

Summary

7. Random Recommendations Web Service

Project overview

Project design specifics

Representing data in code

Public views of Go structs

Generating random recommendations

Google Places API key

Enumerators in Go

Test-driven enumerator

Querying the Google Places API

Building recommendations

Handlers that use query parameters

CORS

Testing our API

Web application

Summary

8. Filesystem Backup

Solution design

Project structure

Backup package

Obvious interfaces?

Implementing ZIP

Has the filesystem changed?

Checking for changes and initiating a backup

Hardcoding is OK for a short while

The user command-line tool

Persisting small data

Parsing arguments

Listing the paths

String representations for your own types

Adding paths

Removing paths

Using our new tool

The daemon backup tool

Duplicated structures

Caching data

Infinite loops

Updating filedb records

Testing our solution

Summary

3. Module 3

1. An Introduction to Concurrency in Go

Introducing goroutines

A patient goroutine

Implementing the defer control mechanism

Using Go's scheduler

Using system variables

Understanding goroutines versus coroutines

Implementing channels

Channel-based sorting at the letter capitalization factory

Cleaning up our goroutines

Buffered or unbuffered channels

Using the select statement

Closures and goroutines

Building a web spider using goroutines and channels

Summary

2. Understanding the Concurrency Model

Understanding the working of goroutines

Synchronous versus asynchronous goroutines

Designing the web server plan

Visualizing concurrency

RSS in action

An RSS reader with self diagnostics

Imposing a timeout

A little bit about CSP

The dining philosophers problem

Go and the actor model

Object orientation

Demonstrating simple polymorphism in Go

Using concurrency

Managing threads

Using sync and mutexes to lock data

Summary

3. Developing a Concurrent Strategy

Applying efficiency in complex concurrency

Identifying race conditions with race detection

Using mutual exclusions

Exploring timeouts

Importance of consistency

Synchronizing our concurrent operations

The project – multiuser appointment calendar

Visualizing a concurrent pattern

Developing our server requirements

Web server

The Gorilla toolkit

Using templates

Time

Endpoints

Custom structs

A multiuser Appointments Calendar

A note on style

A note on immutability

Summary

4. Data Integrity in an Application

Getting deeper with mutexes and sync

The cost of goroutines

Working with files

Getting low – implementing C

Touching memory in cgo

The structure of cgo

The other way around

Getting even lower – assembly in Go

Distributed Go

Some common consistency models

Distributed shared memory

First-in-first-out – PRAM

Looking at the master-slave model

The producer-consumer problem

Looking at the leader-follower model

Atomic consistency / mutual exclusion

Release consistency

Using memcached

Circuit

Summary

5. Locks, Blocks, and Better Channels

Understanding blocking methods in Go

Blocking method 1 – a listening, waiting channel

Sending more data types via channels

Creating a function channel

Using an interface channel

Using structs, interfaces, and more complex channels

The net package – a chat server with interfaced channels

Handling direct messages

Examining our client

Blocking method 2 – the select statement in a loop

Cleaning up goroutines

Blocking method 3 – network connections and reads

Creating channels of channels

Pprof – yet another awesome tool

Handling deadlocks and errors

Summary

6. C10K – A Non-blocking Web Server in Go

Attacking the C10K problem

Failing of servers at 10,000 concurrent connections

Using concurrency to attack C10K

Taking another approach

Building our C10K web server

Benchmarking against a blocking web server

Handling requests

Routing requests

Serving pages

Parsing our template

External dependencies

Connecting to MySQL

Multithreading and leveraging multiple cores

Exploring our web server

Timing out and moving on

Summary

7. Performance and Scalability

High performance in Go

Getting deeper into pprof

Parallelism's and concurrency's impact on I/O pprof

Using the App Engine

Distributed Go

Types of topologies

Type 1 – star

Type 2 – mesh

The Publish and Subscribe model

Serialized data

Remote code execution

Other topologies

Message Passing Interface

Some helpful libraries

Nitro profiler

Heka

GoFlow

Memory preservation

Garbage collection in Go

Summary

8. Concurrent Application Architecture

Designing our concurrent application

Identifying our requirements

Using NoSQL as a data store in Go

MongoDB

Redis

Tiedot

CouchDB

Cassandra

Couchbase

Setting up our data store

Monitoring filesystem changes

Managing logfiles

Handling configuration files

Detecting file changes

Sending changes to clients

Checking records against Couchbase

Backing up our files

Designing our web interface

Reverting a file's history – command line

Using Go in daemons and as a service

Checking the health of our server

Summary

9. Logging and Testing Concurrency in Go

Handling errors and logging

Breaking out goroutine logs

Using the LiteIDE for richer and easier debugging

Sending errors to screen

Logging errors to file

Logging errors to memory

Using the log4go package for robust logging

Panicking

Recovering

Logging our panics

Catching stack traces with concurrent code

Using the runtime package for granular stack traces

Summary

10. Advanced Concurrency and Best Practices

Going beyond the basics with channels

Building workers

Implementing nil channel blocks

Using nil channels

Implementing more granular control over goroutines with tomb

Timing out with channels

Building a load balancer with concurrent patterns

Choosing unidirectional and bidirectional channels

Using receive-only or send-only channels

Using an indeterminate channel type

Using Go with unit testing

GoCheck

Ginkgo and Gomega

Using Google App Engine

Utilizing best practices

Structuring your code

Documenting your code

Making your code available via go get

Keeping concurrency out of your packages

Summary

A. Bibliography

Index