Go: Building Web Applications. Building Web Applications Nathan Kozyra, Mat Ryer

Spis treści książki

• 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 avatars 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

pokaż cały spis treści

ukryj recenzje