The most important conversations about the cloud are more about architecture than technology.
This is the book I wish I could have read myself when I was starting to learn about cloud and Azure, or even ten years ago when I was learning about scaling. Because such a book did not materialize on its own, I have written it. The principles, concepts, and patterns in this book are growing more important every day, making this book more relevant than ever.
Assumptions This Book Makes
This book assumes that the reader knows what the cloud is and has some familiarity with how cloud services can be used to build applications with Windows Azure, Amazon Web Services, Google App Engine, or similar public or private cloud platforms. The reader is not expected to be familiar with the concept of a cloud-native application and how cloud platform services can be used to build one.
This book is written to educate and inform. While this book will help the reader understand cloud architecture, it is not actually advising the use of any particular patterns. The goal of the book is to provide readers with enough information to make informed decisions.
This book focuses on concepts and patterns, and does not always directly discuss costs. Readers should consider the costs of using cloud platform services, as well as trade-offs in development effort. Get to know the pricing calculator for your cloud platform of choice.
This book includes patterns useful for architecting cloud-native applications. This book is not focused on how to (beyond what is needed to understand), but rather about when and why you might want to apply certain patterns, and then which features in Windows Azure you might find useful. This book intentionally does not delve into the detailed implementation level because there are many other resources for those needs, and that would distract from the real focus: architecture.
This book does not provide a comprehensive treatment of how to build cloud applications. The focus of the pattern chapters is on understanding each pattern in the context of its value in building cloud-native applications. Thus, not all facets are covered; emphasis is on the big picture. For example, in , techniques such as optimizing queries and examining query plans are not discussed because they are no different in the cloud. Further, this book is not intended to guide development, but rather provide some options for architecture; some references are given pointing to more resources for realizing many of the patterns, but that is not otherwise intended to be part of this book.
Contents of This Book
There are two types of chapters in this book: primers and patterns.
Individual chapters include:
This primer explains scalability with an emphasis on the key differences between vertical and horizontal scaling.
This fundamental pattern focuses on horizontally scaling compute nodes.
This essential pattern for loose coupling focuses on asynchronous delivery of command requests sent from the user interface to a processing service. This pattern is a subset of the CQRS pattern.
This essential pattern for automating operations makes horizontal scaling more practical and cost-efficient.
This primer introduces eventual consistency and explains some ways to use it.
This pattern focuses on applying the MapReduce data processing pattern.
This advanced pattern focuses on horizontally scaling data through sharding.
This primer introduces multitenancy and commodity hardware and explains why they are used by cloud platforms.