Hands-On Software Architecture with Golang: Design and architect highly scalable and robust applications using Go

Cover
Title Page
Copyright and Credits
About Packt
Contributors
Table of Contents
Preface
Chapter 1: Building Big with Go
	Problem solving for the big picture
		The role of the architect
			Requirements clarification
			True North
			Technology selection
			Leadership in the kitchen
			Coaching and mentoring
			Target state versus current state
	Software architecture
		Architecture versus design
		What does architecture look like?
	Microservices
		The challenges for microservices – efficiency
		The challenges for microservices – programming complexity
	Go
		Hello World!
		Data types and structures
		Functions and methods
		Flow control
		Packaging
		Concurrency
		Garbage collection
		Object-orientation
	Summary
Chapter 2: Packaging Code
	Contracts
	Object orientation
		Object orientation in Go – the struct
		Object orientation in Go – visibility
		Object oriented in Go – the interface
		Object oriented in Go – embedding
	Modules
		Code layout
		Third-party dependencies
		Framework
	Testing
		Structuring tests
	Summary
Chapter 3: Design Patterns
	Design principles
		Single Responsibility Principle (S)
		Open/Closed Principle (O)
		Liskov Substitution Principle (L)
		Interface Segregation Principle (I)
		Dependency Inversion Principle (D)
	Creational design patterns
		Factory method
		Builder
		Abstract factory
		Singleton
	 Structural design patterns
		Adaptor
		Bridge
		Composite
		Decorator
		Facade
		Proxy
	Behavioral design patterns
		Command
		Chain of Responsibility
		Mediator
		Memento
		Observer
		Visitor
		Strategy
		State
	Summary
Chapter 4: Scaling Applications
	Scaling algorithms
		Algorithm complexity
		Distributed algorithms
	Scaling data structures
		Profiling data structures
		Probabilistic data structures
	Scaling data
	Scalability bottlenecks
		The C10K problem
		The Thundering Herd problem
	Sources
		Programming
		Operating systems
		Memory usage
	Losing state
	Scaling systems
		X-axis scaling
		Y-axis scaling
		Z-axis scaling
	Scaling deployments
	Summary
Chapter 5: Going Distributed
	Topology
	Distributed system quirks
		The network is reliable
		The latency is zero
		The bandwidth is infinite
		The network is secure
		The topology doesn't change
		There is one administrator
		The transport cost is zero
		The network is homogeneous
	Consistency
		ACID
		Client-centric consistency models
			Strong consistency
			Weak consistency
			Eventual consistency
				Sequential consistency
				Causal consistency
				Session consistency
				Monotonic read consistency
				Monotonic write consistency
		Storage system-centric consistency model
		CAP theorem
	Consensus
		The two generals problem
		Consensus based on time – causality
		Multi-phase commit
			Two-phase commit
			Three-phase commit
		Paxos
		Raft
		Leader-election
	Distributed architectures
		Object-based systems
		Layered architectures
		Peer-2-peer (P2P) architecture
		Distributed computations
		Event-driven architecture (EDA)
		The Actor model
		Stream processing
	Summary
Chapter 6: Messaging
	Performance characterization
	Broker-based messaging
		The queuing model
		The Pub/Sub model
		Delivery semantics
			Acknowledgement
				At-least-once delivery
				At-most-once delivery
				Exactly-once delivery
		Resilience
		AMQP
	Apache Kafka deep dive
		Concepts
		Publishing messages
			The AsyncProducer interface
			The Sync producer
		Consuming messages
		Stream processing
	Brokerless messaging
	NSQ deep-dive
		Concepts
		Publishing messages
		Consuming messages
	Integration patterns
		The request-reply pattern
		The correlation identifier pattern
		The pipes and filters pattern
		The content-based router pattern
		The fan-in pattern
		The fan-out pattern
		The background worker pattern
	Summary
Chapter 7: Building APIs
	Endpoints
		Networking basics
		Service discovery
			Server-side service discovery
			Client-side service discovery
	Data serialization
		XML
		JSON
		Protobuf
		Performance
	Representational State Transfer (REST)
		Concepts
		Constraints
			Client-server model
			Stateless
			Cacheability
			Uniform interface
		Richardson Maturity Model
			Level 0 – swamp of POX
			Level 1 – resources
			Level 2 – HTTP verbs
			Level 3 – hypermedia controls
	Building a REST service using Gin
		Gin introduction
		Sample application
		Router
		Create
		Read
		Update
		Delete
	GraphQL
		Schema
		Endpoints
			Queries
			Mutations
			Subscriptions
	Higher-level patterns
		Model-View-Controller (MVC)
		Load balancing health checks
		API gateway
	Go kit 
	Summary
Chapter 8: Modeling Data
	Entities and relationships
	Consistency guarantees
		ACID (Atomicity, Consistency, Isolation, Durability)
			Atomicity
			Consistency
			Isolation
			Durability
		BASE (Basically Available, Soft state, Eventual consistency)
	Relational model
		The first normal form
		The second normal form
		The third normal form
		The Boyce-Codd normal form
		The fourth normal form
		SQL
		Indices
		Views
			Inner join
			Left outer join
			Right outer join
			Full outer join
		MySQL deep-dive
			Connection management
			Query execution
			Storage engines
				InnoDB
				MyISAM
				Other plugins
			High availability/scalability
		Object Relational Mappers (ORMs)
	Key/value stores
		Concepts
		Redis deep-dive
			Architecture
			Data structures
			Persistence
			Clustering
			Use cases
			Golang usage
	Wide column stores
	Column family stores
		Cassandra deep-dive
			Data distribution
			Write paths
			Read paths
			Golang usage
	Patterns for scaling data performance
		Sharding
		Denormalization
		Materialized views
	Summary
Chapter 9: Anti-Fragile Systems
	Reliability metrics
		Dynamic metrics
		Static metrics
	Engineering reliability
		Rugged services
		High availability
		Messaging
			The asynchronous computation pattern
			The orchestrator pattern
			The compensating-transaction pattern
			The pipes and filter pattern
			Hotspots
		The sidecar pattern
		Throttling
		Versioning 
	Reliability verification
		Unit tests
		Integration tests
		UI tests
		Performance tests
	Chaos-engineering
	Dependencies
		Failure multiplication
		Cascading failures
		Dependency resilience
			An introduction to Hystrix
			Hystrix – fallback
			Hystrix – circuit breaker
			Hystrix in Golang
			Hystrix monitoring
	Database-level reliability
	Datacenter-level reliability
		Consistency
		Routing and cutover
	Summary
Chapter 10: Case Study – Travel Website
	The product
		Actors
		Requirements
	Data modeling
	High-level architecture
	Search
		Flights
		Hotels
	Booking
		Payment
		Reservation
	Summary
Chapter 11: Planning for Deployment
	Deployment architecture
		Components
			Computes
				Physical Servers
				Virtual machines
				Containers
				Compute Attributes
			Storage
			Networking
			Load Balancers
			API Gateways
			Reverse proxies
			Messaging brokers
		Environments
		Capacity Planning and Sizing
		Disaster recovery
	CICD
		Overview
		Jenkins
			Sample Code
			Installing Jenkins
			Installing Docker
			Setting up Plugins
			Creating a project
			Running the Build
		Target Configuration
		Tooling
			go fmt
			golint
			go build
		Footnote
	Monitoring
		Logs
		Metrics
		Application Performance Monitoring/Dashboards
		Alerts
		Team
	Clouds
		Infrastructure as a Service (IaaS)
		Platform as a Service (PaaS)
		Software as a service (SaaS)
	Security
	Summary
Chapter 12: Migrating Applications
	Reasons for migration
		Python
		Java
	Migration strategy
		Phase 1 – Learning Go
		Phase 2 – Piloting a service
		Phase 3 – Defining packages
		Phase 4 – Porting main
		Phase 5 – Porting packages
		Phase 6 – Improving computation
	Building a team
	Summary
Other Books You May Enjoy
Index