Home Page Icon
Home Page
Table of Contents for
Hands-On Software Architecture with Golang
Close
Hands-On Software Architecture with Golang
by Jyotiswarup Raiturkar
Hands-On Software Architecture with Golang
Title Page
Copyright and Credits
Hands-On Software Architecture with Golang
About Packt
Why subscribe?
Packt.com
Contributors
About the author
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
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
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
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
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
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
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
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
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
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
Case Study – Travel Website
The product
Actors
Requirements
Data modeling
High-level architecture
Search
Flights
Hotels
Booking
Payment
Reservation
Summary
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
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
Leave a review - let other readers know what you think
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Next
Next Chapter
Title Page
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset