Solutions Architect's Handbook

Kick-start your solutions architect career by learning architecture design principles and strategies

Saurabh Shrivastava, Neelanjali Srivastav

• Publisher: Packt Publishing
• Year: 2020
• ISBN:
  9781838647834
• Topic: Computer Science
• Subtopic: Systems Architecture
• Index: Computer Science

From fundamentals and design patterns to the different strategies for creating secure and reliable architectures in AWS cloud, learn everything you need to become a successful solutions architect

Key Features

• Create solutions and transform business requirements into technical architecture with this practical guide
• Understand various challenges that you might come across while refactoring or modernizing legacy applications
• Delve into security automation, DevOps, and validation of solution architecture

Book Description

Becoming a solutions architect gives you the flexibility to work with cutting-edge technologies and define product strategies. This handbook takes you through the essential concepts, design principles and patterns, architectural considerations, and all the latest technology that you need to know to become a successful solutions architect.This book starts with a quick introduction to the fundamentals of solution architecture design principles and attributes that will assist you in understanding how solution architecture benefits software projects across enterprises. You'll learn what a cloud migration and application modernization framework looks like, and will use microservices, event-driven, cache-based, and serverless patterns to design robust architectures. You'll then explore the main pillars of architecture design, including performance, scalability, cost optimization, security, operational excellence, and DevOps. Additionally, you'll also learn advanced concepts relating to big data, machine learning, and the Internet of Things (IoT). Finally, you'll get to grips with the documentation of architecture design and the soft skills that are necessary to become a better solutions architect.By the end of this book, you'll have learned techniques to create an efficient architecture design that meets your business requirements.

What you will learn

• Explore the various roles of a solutions architect and their involvement in the enterprise landscape
• Approach big data processing, machine learning, and IoT from an architect s perspective and understand how they fit into modern architecture
• Discover different solution architecture patterns such as event-driven and microservice patterns
• Find ways to keep yourself updated with new technologies and enhance your skills
• Modernize legacy applications with the help of cloud integration
• Get to grips with choosing an appropriate strategy to reduce cost

Who this book is for

This book is for software developers, system engineers, DevOps engineers, architects, and team leaders working in the information technology industry who aspire to become solutions architect professionals. A good understanding of the software development process and general programming experience with any language will be useful.

]]>

Solution Architecture Design Patterns

There are multiple ways to design a solution. A solution architect needs to take the right approach based on user requirements along with the architecture constraints of cost, performance, scalability, and availability. In this chapter, you will learn about various solution architecture patterns along with reference architectures and how to apply them in real-world scenarios.

In the previous chapters, you learned about the attributes and principles of solution architecture design. This chapter is both exciting and essential as you will be able to apply your learning to various architecture design patterns. In this chapter, you will gain an understanding of some of the significant solution architecture patterns, such as layered, event-driven, microservice, loosely coupled, service-oriented, and RESTful architectures.

You will learn the advantages of various architectural designs and examples that demonstrate when to utilize them. You will also gain an understanding of architecture design anti-patterns in addition to the following architecture design patterns:

• Building an n-tier layered architecture
• Creating a multi-tenant SaaS-based architecture
• Building stateless and stateful architecture designs
• Understanding service-oriented architecture (SOA)
• Building a serverless architecture
• Creating a microservice architecture
• Building a queue-based architecture
• Creating an event-driven architecture

• Building a cache-based architecture
• Understanding the circuit breaker pattern
• Implementing the bulkheads pattern
• Creating a floating IP pattern
• Deploying an application with a container
• Database handling in application architecture
• Avoiding anti-patterns in solution architecture

By the end of the chapter, you will know how to optimize your solution architecture design and apply best practices, making this chapter the center point and core of your learning.

Building an n-tier layered architecture

In n-tier architecture (also known as multitier architecture), you need to apply the principle of loosely coupled design (refer to Chapter 4, Principles of Solution Architecture Design) and attributes of scalability and elasticity (refer to Chapter 3, Attributes of the Solution Architecture). In multilayer architecture, you divide your product functions into multiple layers, such as presentation, business, database, and services, so that each layer can be implemented and scaled independently.

With multitier architecture, it is easy to adopt new technologies and make development more efficient. This layered architecture provides the flexibility to add new features in each layer without disturbing features of other layers. In terms of security, you can keep each layer secure and isolated from others, so if one layer gets compromised, the other layers won't be impacted. Application troubleshooting and management also become manageable as you can quickly pinpoint where the issue is coming from and which part of the application needs to troubleshoot.

The most famous architecture in multilayer design is three-tier architecture, so let's learn more about it. The following diagram shows the most common architecture, where you interact with a web application from the browser and perform the required functions, for example, ordering your favorite T-shirt or reading a blog and leaving a comment:

Three-tier website architecture

In the preceding architecture, you have the following three layers:

• Web Layer: The web layer is the user-facing part of the application. End users interact with the web layer to collect or provide information.
• Application Layer: The application layer mostly contains business logic and acts upon information received from the web layer.
• Database Layer: All kinds of user data and application data are stored in the database layer.

Let's take a look at these layers in more detail.

The web layer

The web layer is also known as the presentation tier. The web layer provides a user interface that helps the end user to interact with the application. The web layer is your user interface (in this case, the website page), where the user enters information or browses for it. Web developers may build a presentation tier user interface in technologies such as HTML, CSS, AngularJS, Java Server Page (JSP), and Active Server Page (ASP). This tier collects the information from the user and passes it to the application layer.

The application layer

The application layer is also known as a logic tier, as this is the core of the product where all the business logic resides. The presentation tier collects the information from the user and passes it to the logic tier to process and get a result. For example, on an e-commerce website such as Amazon.com, users can enter a date range on the order page of the website to find their order summary. In return, the web layer passes the data range information to the application layer. The application layer processes the user input to perform business logic such as the count of orders, the sum of amounts, and the number of items purchased. This returns information to the web layer to render it for the user.

Generally, in three-tier architecture, all algorithms and complex logic live in the logic tier, which includes creating a recommendation engine or showing personalized pages to the user as per their browsing history. Developers may choose to implement this layer in a server-side programming language, for example, C++, Java, .NET, or Node.js. The application layer performs logic on the data, which is stored in the database layer.

The database layer

The database layer, which is also known as the data tier, stores all the information related to user profiles and transactions. Essentially, it contains any data that needs to persist in being stored in the data tier. This information is sent back to the application layer for logic processing and then, eventually, it renders to the user in the web layer. For example, if the user is logged in to a website with their user ID and password, then the application layer verifies the user credentials with information stored in the database. If the credentials match the stored information, the user is allowed to log in and access the authorized area of the website.

The architect may choose to build a data tier in relational databases, for example, PostgreSQL, MariaDB, Oracle Database, MySQL, Microsoft SQL Server, Amazon Aurora, or Amazon RDS. The architect may also add a NoSQL database such as Amazon DynamoDB, MongoDB, or Apache Cassandra. The data tier is not only used to store transaction information but also to hold user-session information and application configuration.

In the n-tier layered architecture diagram, you will notice that each layer has its own auto scaling configuration, which means it can be scaled independently. Also, each layer has a network boundary, which means having access to one layer doesn't allow access to other layers. You will learn more about security considerations in Chapter 8, Security Considerations.

When designing multitier architecture, you need to take careful consideration of how many layers should be added to your design. Each layer requires its own fleet of servers and network configurations. So, adding more layers means increasing the cost and management overhead, whereas keeping fewer layers means creating a tightly coupled architecture. The architect needs to decide the number of tiers based on application complexity and user requirement.

Creating multi-tenant SaaS-based architecture

In the previous section, you learned about multitier architecture; however, the same architecture that is built for a single organization is also called a single tenancy. Multi-tenant architecture is becoming more popular as organizations adopt the digital revolution while keeping the overall application cost low. The Software-as-a-Service (SaaS) model is built on a multi-tenant architecture, where a single instance of the software and the supporting infrastructure serve multiple customers. In this design, each customer shares the application and database, with each tenant isolated by their unique configuration, identity, and data. They remain invisible to each other while sharing the same product.

As multi-tenant SaaS providers own everything from the hardware to the software, SaaS-based products offload an organization's responsibilities to the maintenance and updates of the application, as this is taken care by the SaaS provider. Each customer (tenant) can customize their user interface using a configuration without any code changes. As multiple customers share a common infrastructure, they get the benefit of scale, which lowers the cost further. Some of the most popular SaaS providers are Salesforce CRM, the JIRA bug tracking tool, and Amazon QuickSight.

As shown in the following architecture diagram, there are two organizations (tenants) using the same software and infrastructure. The SaaS vendor provides access to the application layer by allocating a unique tenant ID to each organization. Each tenant can customize their user interface as per their business needs using a simple configuration:

Multi-tenant SaaS architecture

As shown in the preceding architecture design, the presentation layer provides a user interface and the application layer holds the business logic. At the data access layer, each tenant will have data level isolation with one of the following methods:

• Database Level Isolation: In this model, each tenant has its database associated with its tenant ID. When each tenant queries data from the user interface, they are redirected to their database. This model is required if the customer doesn't want a single shared database for compliance and security reasons.
• Table Level...