Go: Building Web Applications E-Book

Nathan Kozyra

• Herausgeber: Packt Publishing
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Englisch

Seitenzahl: 794

Veröffentlichungsjahr: 2016

Beschreibung

Build real-world, production-ready solutions by harnessing the powerful features of Go

About This Book

• An easy-to-follow guide that provides everything a developer needs to know to build end-to-end web applications in Go
• Write interesting and clever, but simple code, and learn skills and techniques that are directly transferable to your own projects
• A practical approach to utilize application scaffolding to design highly scalable programs that are deeply rooted in go routines and channels

Who This Book Is For

This book is intended for developers who are new to Go, but have previous experience of building web applications and APIs.

What You Will Learn

• Build a fully featured REST API to enable client-side single page apps
• Utilize TLS to build reliable and secure sites
• Learn to apply the nuances of the Go language to implement a wide range of start-up quality projects
• Create websites and data services capable of massive scale using Go's net/http package, exploring RESTful patterns as well as low-latency WebSocket APIs
• Interact with a variety of remote web services to consume capabilities ranging from authentication and authorization to a fully functioning thesaurus
• Explore the core syntaxes and language features that enable concurrency in Go
• Understand when and where to use concurrency to keep data consistent and applications non-blocking, responsive, and reliable
• Utilize advanced concurrency patterns and best practices to stay low-level without compromising the simplicity of Go itself

In Detail

Go is an open source programming language that makes it easy to build simple, reliable, and efficient software. It is a statically typed language with syntax loosely derived from that of C, adding garbage collection, type safety, some dynamic-typing capabilities, additional built-in types such as variable-length arrays and key-value maps, and a large standard library.

This course starts with a walkthrough of the topics most critical to anyone building a new web application. Whether it's keeping your application secure, connecting to your database, enabling token-based authentication, or utilizing logic-less templates, this course has you covered.

Scale, performance, and high availability lie at the heart of the projects, and the lessons learned throughout this course will arm you with everything you need to build world-class solutions. It will also take you through the history of concurrency, how Go utilizes it, how Go differs from other languages, and the features and structures of Go's concurrency core. It will make you feel comfortable designing a safe, data-consistent, and high-performance concurrent application in Go.

This course is an invaluable resource to help you understand Go's powerful features to build simple, reliable, secure, and efficient web applications.

Style and approach

This course is a step-by-step guide, which starts off with the basics of go programming to build web applications and will gradually move on to cover intermediate and advanced topics. You will be going through this smooth transition by building interesting projects along with the authors, discussing significant options, and decisions at each stage, while keeping the programs lean, uncluttered, and as simple as possible.

Leseprobe

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

Go: Building Web Applications

Go: Building Web Applications

Build real-world, production-ready solutions by harnessing the powerful features of Go

A course in three modules

BIRMINGHAM - MUMBAI

Go: Building Web Applications

Copyright © 2016 Packt Publishing

All rights reserved. No part of this course may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this course to ensure the accuracy of the information presented. However, the information contained in this course is sold without warranty, either express or implied. Neither the authors, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this course.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this course by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

Published on: August 2016

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham B3 2PB, UK.

ISBN 978-1-78712-349-6

www.packtpub.com

Credits

Authors

Nathan Kozyra

Mat Ryer

Reviewers

Karthik Nayak

Tyler Bunnell

Michael Hamrah

Nimish Parmar

Jeremy R. Budnack

János Fehér

Aleksandar S. Sokolovski

Michele Della Torre

Content Development Editor

Arun Nadar

Graphics

Abhinash Sahu

Production Coordinator

Melwyn D'sa

Preface

Since the late 1980s and early 1990s, there has been a slow flood of powerful new languages and paradigms—Perl, Python, Ruby, PHP, and JavaScript—have taken an expanding user base by storm and has become one of the most popular languages (up there with stalwarts such as C, C++, and Java). Multithreading, memory caching, and APIs have allowed multiple processes, dissonant languages, applications, and even separate operating systems to work in congress.

And while this is great, there's a niche that until very recently was largely unserved: powerful, compiled, cross-platform languages with concurrency support that are geared towards systems programmers.

So when Google announced Go in 2009, which included some of the best minds in language design (and programming in general)—Rob Pike and Ken Thompson of Bell Labs fame and Robert Griesemer, who worked on Google's JavaScript implementation V8—to design a modern, concurrent language with development ease at the forefront.

For Go programming bright future, the team focused on some sore spots in the alternatives, which are as follows:

Dynamically typed languages have—in recent years—become incredibly popular. Go eschews the explicit, "cumbersome" type systems of Java or C++. Go uses type inference, which saves development time, but is still also strongly typed.Concurrency, parallelism, pointers/memory access, and garbage collection are unwieldy in the aforementioned languages. Go lets these concepts be as easy or as complicated as you want or need them to be.As a newer language, Go has a focus on multicore design that was a necessary afterthought in languages such as C++.Go's compiler is super-fast; it's so fast that there are implementations of it that treat Go code as interpreted.Although Google designed Go to be a systems language, it's versatile enough to be used in a myriad of ways. Certainly, the focus on advanced, cheap concurrency makes it ideal for network and systems programming.Go is loose with syntax, but strict with usage. By this we mean that Go will let you get a little lazy with some lexer tokens, but you still have to produce fundamentally tight code. As Go provides a formatting tool that attempts to clarify your code, you can also spend less time on readability concerns as you're coding

What this learning path covers

Module 1, Learning Go Web Development, starts off with introducing and setting up Go before you move on to produce responsive servers that react to certain web endpoint. You will then implement database connections to acquire data and then present it to our users using different template packages. Later on, you will learn about sessions and cookies to retain information before delving with the basics of microservices. By the end of this module, we will be covering the testing, debugging, and the security aspect.

Module 2, Go Programming Blueprints, has a project-based approach where you will be building chat application, adding authentication, and adding your own profile pictures in different ways. You will learn how Go makes it easy to build powerful command-line tools to find domain names before building a highly scalable Twitter polling and vote counting engine powered by NSQ and MongoDB. Later on it covers the functionalities of RESTful Data Web Service API and Google Places API before you move on to build a simple but powerful filesystem backup tool for our code projects.

Module 3, Mastering Concurrency in Go, introduces you to Concurrency in Go where you will be understanding the Concurrency model and developing a strategy for designing applications. You will learn to create basic and complex communication channels between our goroutines to manage data not only across single or multithreaded systems but also distributed systems. Later on you will be tackling a real-world problem, that is, being able to develop a high performance web server that can handle a very large volume of live, active traffic. You will then learn how to scale your application and make it capable of being expanded in scope, design, and/or capacity. It will then focus on when and where to implement concurrent patterns, utilize parallelism, and ensure data consistency. At the end of this module, we will be logging and testing concurrency before we finally look at the best practices on how to implement complicated and advanced techniques offered by Go.

What you need for this learning path

For this course, any modern computers running a standard Linux flavor, OS X or Windows should be enough to get started. You can find a full list of requirements at https://golang.org/dl/. Later on, you'll also need to have the following software installed:

MySQL (http://dev.mysql.com/downloads/)Couchbase (http://www.couchbase.com/download)

Your choice of IDE is a matter of personal preference.

Who this learning path is for

This course is intended for developers who are new to Go but have previous experience of building web applications and APIs. It is also targeted towards systems or network programmer with some knowledge of Go and concurrency, but would like to know about the implementation of concurrent systems written in Go

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this course—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail <[email protected]>, and mention the course's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt course, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this course from your account at http://www.packtpub.com. If you purchased this course elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

You can download the code files by following these steps:

Log in or register to our website using your e-mail address and password.Hover the mouse pointer on the SUPPORT tab at the top.Click on Code Downloads & Errata.Enter the name of the course in the Search box.Select the course for which you're looking to download the code files.Choose from the drop-down menu where you purchased this course from.Click on Code Download.

You can also download the code files by clicking on the Code Files button on the course's webpage at the Packt Publishing website. This page can be accessed by entering the course's name in the Search box. Please note that you need to be logged in to your Packt account.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

WinRAR / 7-Zip for WindowsZipeg / iZip / UnRarX for Mac7-Zip / PeaZip for Linux

The code bundle for the course is also hosted on GitHub at https://github.com/PacktPublishing/repository-name. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our courses—maybe a mistake in the text or the code—we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this course. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your course, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.

To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the course in the search field. The required information will appear under the Errata section.

Piracy

Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at <[email protected]> with a link to the suspected pirated material.

We appreciate your help in protecting our authors and our ability to bring you valuable content.

Questions

If you have a problem with any aspect of this course, you can contact us at <[email protected]>, and we will do our best to address the problem.

Part 1. Module 1

Learning Go Web Development

Build frontend-to-backend web applications using the best practices of a powerful, fast, and easy-to-deploy server language

Chapter 1. Introducing and Setting Up Go

When starting with Go, one of the most common things you'll hear being said is that it's a systems language.

Indeed, one of the earlier descriptions of Go, by the Go team itself, was that the language was built to be a modern systems language. It was constructed to combine the speed and power of languages, such as C with the syntactical elegance and thrift of modern interpreted languages, such as Python. You can see that goal realized when you look at just a few snippets of Go code.

From the Go FAQ on why Go was created:

"Go was born out of frustration with existing languages and environments for systems programming."

Perhaps the largest part of present-day Systems programming is designing backend servers. Obviously, the Web comprises a huge, but not exclusive, percentage of that world.

Go hasn't been considered a web language until recently. Unsurprisingly, it took a few years of developers dabbling, experimenting, and finally embracing the language to start taking it to new avenues.

While Go is web-ready out of the box, it lacks a lot of the critical frameworks and tools people so often take for granted with web development now. As the community around Go grew, the scaffolding began to manifest in a lot of new and exciting ways. Combined with existing ancillary tools, Go is now a wholly viable option for end-to-end web development. But back to that primary question: Why Go? To be fair, it's not right for every web project, but any application that can benefit from high-performance, secure web-serving out of the box with the added benefits of a beautiful concurrency model would make for a good candidate.

In this book, we're going to explore those aspects and others to outline what can make Go the right language for your web architecture and applications.

We're not going to deal with a lot of the low-level aspects of the Go language. For example, we assume you're familiar with variable and constant declaration. We assume you understand control structures.

In this chapter we will cover the following topics:

Installing GoStructuring a projectImporting packagesIntroducing the net packageHello, Web

Installing Go

The most critical first step is, of course, making sure that Go is available and ready to start our first web server.

Note

While one of Go's biggest selling points is its cross-platform support (both building and using locally while targeting other operating systems), your life will be much easier on a Nix compatible platform.

If you're on Windows, don't fear. Natively, you may run into incompatible packages, firewall issues when running using go run command and some other quirks, but 95% of the Go ecosystem will be available to you. You can also, very easily, run a virtual machine, and in fact that is a great way to simulate a potential production environment.

In-depth installation instructions are available at https://golang.org/doc/install, but we'll talk about a few quirky points here before moving on.

For OS X and Windows, Go is provided as a part of a binary installation package. For any Linux platform with a package manager, things can be pretty easy.

Note

To install via common Linux package managers:

Ubuntu: sudo apt-get golang

CentOS: sudo yum install golang

On both OS X and Linux, you'll need to add a couple of lines to your path—the GOPATH and PATH. First, you'll want to find the location of your Go binary's installation. This varies from distribution to distribution. Once you've found that, you can configure the PATH and GOPATH, as follows:

export PATH=$PATH:/usr/local/go/binexport GOPATH="/usr/share/go"

While the path to be used is not defined rigidly, some convention has coalesced around starting at a subdirectory directly under your user's home directory, such as $HOME/go or ~Home/go. As long as this location is set perpetually and doesn't change, you won't run into issues with conflicts or missing packages.

You can test the impact of these changes by running the go env command. If you see any issues with this, it means that your directories are not correct.

Note that this may not prevent Go from running—depending on whether the GOBIN directory is properly set—but will prevent you from installing packages globally across your system.

To test the installation, you can grab any Go package by a go get command and create a Go file somewhere. As a quick example, first get a package at random, we'll use a package from the Gorilla framework, as we'll use this quite a bit throughout this book.

go get github.com/gorilla/mux

If this runs without any issue, Go is finding your GOPATH correctly. To make sure that Go is able to access your downloaded packages, draw up a very quick package that will attempt to utilize Gorilla's mux package and run it to verify whether the packages are found.

package main import ( "fmt" "github.com/gorilla/mux" "net/http" ) func TestHandler(w http.ResponseWriter, r *http.Request) { } func main() { router := mux.NewRouter() router.HandleFunc("/test", TestHandler) http.Handle("/", router) fmt.Println("Everything is set up!") }

Run go run test.go in the command line. It won't do much, but it will deliver the good news as shown in the following screenshot:

Importing packages

Beyond the absolute and the most trivial application—one that cannot even produce a Hello World output—you must have some imported package in a Go application.

To say Hello World, for example, we'd need some sort of a way to generate an output. Unlike in many other languages, even the core language library is accessible by a namespaced package. In Go, namespaces are handled by a repository endpoint URL, which is github.com/nkozyra/gotest, which can be opened directly on GitHub (or any other public location) for the review.

Handling private repositories

The go get tool easily handles packages hosted at the repositories, such as GitHub, Bitbucket, and Google Code (as well as a few others). You can also host your own projects, ideally a git project, elsewhere, although it might introduce some dependencies and sources for errors, which you'd probably like to avoid.

But what about the private repos? While go get is a wonderful tool, you'll find yourself looking at an error without some additional configuration, SSH agent forwarding, and so on.

You can work around this in a couple of ways, but one very simple method is to clone the repository locally, using your version control software directly.

Dealing with versioning

You may have paused when you read about the way namespaces are defined and imported in a Go application. What happens if you're using version 1 of the application but would like to bring in version 2? In most cases, this has to be explicitly defined in the path of the import. For example:

import ( "github.com/foo/foo-v1" )

versus:

import ( "github.com/foo/foo-v2" )

As you might imagine, this can be a particularly sticky aspect of the way Go handles the remote packages.

Unlike a lot of other package managers, go get is decentralized—that is, nobody maintains a canonical reference library of packages and versions. This can sometimes be a sore spot for new developers.

For the most part, packages are always imported via the go get command, which reads the master branch of the remote repository. This means that maintaining multiple versions of a package at the same endpoint is, for the most part, impossible.

It's the utilization of the URL endpoints as namespaces that allows the decentralization, but it's also what provides a lack of internal support for versioning.

Your best bet as a developer is to treat every package as the most up-to-date version when you perform a go get command. If you need a newer version, you can always follow whatever pattern the author has decided on, such as the preceding example.

As a creator of your own packages, make sure that you also adhere to this philosophy. Keeping your master branch HEAD as the most up-to-date will make sure your that the code fits with the conventions of other Go authors.

Introducing the net package

At the heart of all network communications in Go is the aptly-named net package, which contains subpackages not only for the very relevant HTTP operations, but also for other TCP/UDP servers, DNS, and IP tools.

In short, everything you need to create a robust server environment.

Of course, what we care about for the purpose of this book lies primarily in the net/http package, but we'll look at a few other functions that utilize the rest of the package, such as a TCP connection, as well as WebSockets.

Let's quickly take a look at just performing that Hello World (or Web, in this case) example we have been talking about.

Summary

This chapter serves as an introduction to the most basic concepts of Go and producing for the Web in Go, but these points are critical foundational elements for being productive in the language and in the community.

We've looked at coding conventions and package design and organization, and we've produced our first program—the all-too-familiar Hello, World application—and accessed it via our localhost.

Obviously, we're a long way from a real, mature application for the Web, but the building blocks are essential to getting there.

In Chapter 2, Serving and Routing, we'll look at how to direct different requests to different application logic using the built-in routing functionality in Go's net/http package, as well as a couple of third party router packages.

Basic routing

In Chapter 1, Introducing and Setting Up, we produced a very basic URL endpoint that allowed static file serving.

The following are the simple routes we produced for that example:

func main() { http.HandleFunc("/static",serveStatic) http.HandleFunc("/",serveDynamic) http.ListenAndServe(Port,nil) }

In review, you can see two endpoints, /static and /, which either serve a single static file or generate output to the http.ResponseWriter.

We can have any number of routers sitting side by side. However, consider a scenario where we have a basic website with about, contact, and staff pages, with each residing in /var/www/about/index.html, /var/www/contact.html, and /var/www/staff/home.html. While it's an intentionally obtuse example, it demonstrates the limitations of Go's built-in and unmodified routing system. We cannot route all requests to the same directory locally, we need something that provides more malleable URLs.

Redirecting requests

Before we look at simple and incredibly common errors like 404s, let's address the idea of redirecting requests, something that's very common. Although not always for reasons that are evident or tangible for the average user.

So we might we want to redirect requests to another request? Well there are quite a few reasons, as defined by the HTTP specification that could lead us to implement automatic redirects on any given request. Here are a few of them with their corresponding HTTP status codes:

A non-canonical address may need to be redirected to the canonical one for SEO purposes or for changes in site architecture. This is handled by 301 Moved Permanently or 302 Found.Redirecting after a successful or unsuccessful POST. This helps us to prevent re-POSTing of the same form data accidentally. Typically, this is defined by 307 Temporary Redirect.The page is not necessarily missing, but it now lives in another location. This is handled by the status code 301 Moved Permanently.

Executing any one of these is incredibly simple in basic Go with net/http, but as you might expect, it is facilitated and improved with more robust frameworks, such as Gorilla.

Summary

We can now produce not only the basic routes from the net/http package but more complicated ones using the Gorilla toolkit. By utilizing Gorilla, we can now create regular expressions and implement pattern-based routing and allow much more flexibility to our routing patterns.

With this increased flexibility, we also have to be mindful of errors now, so we've looked at handling error-based redirects and messages, including a custom 404, Page not found message to produce more customized error messages.

Now that we have the basics down for creating endpoints, routes, and handlers; we need to start doing some non-trivial data serving.

In Chapter 3, Connecting to Data, we'll start getting dynamic information from databases, so we can manage data in a smarter and more reliable fashion. By connecting to a couple of different, commonly-used databases, we'll be able to build robust, dynamic, and scalable web applications.