Book Image

Hands-On Software Architecture with Golang

By : Jyotiswarup Raiturkar
Book Image

Hands-On Software Architecture with Golang

By: Jyotiswarup Raiturkar

Overview of this book

Building software requires careful planning and architectural considerations; Golang was developed with a fresh perspective on building next-generation applications on the cloud with distributed and concurrent computing concerns. Hands-On Software Architecture with Golang starts with a brief introduction to architectural elements, Go, and a case study to demonstrate architectural principles. You'll then move on to look at code-level aspects such as modularity, class design, and constructs specific to Golang and implementation of design patterns. As you make your way through the chapters, you'll explore the core objectives of architecture such as effectively managing complexity, scalability, and reliability of software systems. You'll also work through creating distributed systems and their communication before moving on to modeling and scaling of data. In the concluding chapters, you'll learn to deploy architectures and plan the migration of applications from other languages. By the end of this book, you will have gained insight into various design and architectural patterns, which will enable you to create robust, scalable architecture using Golang.

Related Content you might be interested in

Current Title:

Small book image
Hands-On Software Architecture with Golang
Jyotiswarup Raiturkar
Dec, 2018 | 500 pages
Small book image
Architectural Patterns
Harihara Subramanian J | Pethuru Raj Chelliah | Anupama Murali
Dec, 2017 | 468 pages
Table of Contents (14 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Building Big with Go
Building Big with Go
Problem solving for the big picture
Software architecture
Microservices
Go
Summary
2
Packaging Code
Packaging Code
Contracts
Object orientation
Modules
Testing
Summary
3
Design Patterns
Design Patterns
Design principles
Creational design patterns
Structural design patterns
Behavioral design patterns
Summary
4
Scaling Applications
Scaling Applications
Scaling algorithms
Scaling data structures
Scaling data
Scalability bottlenecks
Sources
Losing state
Scaling systems
Scaling deployments
Summary
5
Going Distributed
Going Distributed
Topology
Distributed system quirks
Consistency
Consensus
Distributed architectures
Summary
6
Messaging
Messaging
Performance characterization
Broker-based messaging
Apache Kafka deep dive
Brokerless messaging
NSQ deep-dive
Integration patterns
Summary
7
Building APIs
Building APIs
Endpoints
Data serialization
Representational State Transfer (REST)
Building a REST service using Gin
GraphQL
Higher-level patterns
Go kit
Summary
8
Modeling Data
Modeling Data
Entities and relationships
Consistency guarantees
Relational model
Key/value stores
Wide column stores
Column family stores
Patterns for scaling data performance
Summary
9
Anti-Fragile Systems
Anti-Fragile Systems
Reliability metrics
Engineering reliability
Reliability verification
Chaos-engineering
Dependencies
Database-level reliability
Datacenter-level reliability
Summary
10
Case Study – Travel Website
Case Study – Travel Website
The product
Data modeling
High-level architecture
Search
Booking
Summary
11
Planning for Deployment
Planning for Deployment
Deployment architecture
CICD
Monitoring
Clouds
Security
Summary
12
Migrating Applications
Migrating Applications
Reasons for migration
Migration strategy
Building a team
Summary
13
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Topology

A distributed system consists of a bunch of services connected over a network. Each of the services has a specific purpose. Some of the services might be exposed for interactions with the clients (actors, in the use case parlance). Some services might just be hosting data and doing transformations for upstream services. The services communicate with each other to enable macro behavior and fulfil the requirements of the system.

The services interact with one another over the network using either of the following:

  • Application Programming Interface (API)
  • Messaging

Irrespective of the channel, the data is exchanged in a standardized format over the network.

The API paradigm is the most common. As described in Chapter 7, Building APIs, services communicate with each other over the network. They send requests and receive responses from specific endpoints. The most popular...

Previous Section
End of Section 2
Next Section