Go · Building Web Applications by Kozyra, Nathan -- Read -- Imperial Library of Trantor

Index

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

← Prev
Back
Next →

← Prev
Back
Next →