MVC and CRUD make software easier to write, but harder to change. Microservice-based architectures can help even the smallest of projects remain agile in the long term, but most tutorials meander in theory or completely miss the point of what it means to be microservice-based. Roll up your sleeves with real projects and learn the most important concepts of evented architectures. You'll have your own deployable, testable project and a direction for where to go next.

Much ink has been spilled on the topic of microservices, but all of this writing fails to accurately identity what makes a system a monolith, define what microservices are, or give complete, practical examples, so you're probably left thinking they have nothing to offer you. You don't have to be at Google or Facebook scale to benefit from a microservice-based architecture. Microservices will keep even small and medium teams productive by keeping the pieces of your system focused and decoupled.

Discover the basics of message-based architectures, render the same state in different shapes to fit the task at hand, and learn what it is that makes something a monolith (it has nothing to do with how many machines you deploy to). Conserve resources by performing background jobs with microservices. Deploy specialized microservices for registration, authentication, payment processing, e-mail, and more. Tune your services by defining appropriate service boundaries. Deploy your services effectively for continuous integration. Master debugging techniques that work across different services. You'll finish with a deployable system and skills you can apply to your current project.

Add the responsiveness and flexibility of microservices to your project, no matter what the size or complexity.

What You Need:

While the principles of this book transcend programming language, the code examples are in Node.js because JavaScript, for better or worse, is widely read. You'll use PostgreSQL for data storage, so familiarity with it is a plus. The books does provide Docker images to make working with PostgreSQL a bit easier, but extensive Docker knowledge is not required.

About This Book

Separating Principles from Implementations

This is the book that I wish had been written years ago when I first started learning service-based architecture. Finding information on high-level principles is pretty easy, but there weren’t any hands-on tutorials. But by getting so low-level in this book, my biggest fear is that you interpret this particular implementation as microservices gospel. The details here serve only to show what the principles might look like in practice.

Using This Book

The chapters in the book build on top of one another. In Chapter 1, you start writing a project that we add to as we go throughout the book. I can’t imagine a reading order other than “each chapter in order” that makes sense. Maybe I’m lacking in imagination, but that’s my recommendation to you.

As you’re reading through the code, I can’t stress highly enough the value of creating your own project folder, creating each file, and typing its contents yourself. Is that tedious? Possibly. But it’s tedium with a purpose. Reading code is nice, but I want to get the concepts in this book into your brain, and typing code will do so much more of that transfer than merely reading.

In addition, you should also be sure to complete the exercises in the chapters.

What This Book Is

This is a hands-on tutorial. In this book, you’re going to build a system according to a different set of principles—ones that will allow you to build systems where your productivity will not come to an encumbered halt. You’re going to build microservices, focused units of autonomous functionality.

Chapter 1, ​You Have a New Project​ introduces the project you’re going to build, and we’ll take a crack at it using the traditional CRUD-based approach, seeing how it paints us into a corner. Following that, in Chapter 2, ​Writing Messages​ we’ll unmask the monolith, and you’ll see why most writing on microservices misses the point. We’ll conclude this part of the book by writing code to interact with a piece of technology called a message store—a database optimized for storing asynchronous messages. These messages will form the basis of your architecture.

With the fundamentals in place, you’ll leverage this message store to add features to your system by building microservices and other autonomous components. You’ll send emails (Chapter 9, ​Adding an Email Component​) and even transcode videos (Chapter 10, ​Performing Background Jobs with Microservices​). Along the way, the architecture you implement will allow you to slice and dice the same data in varied and interesting ways.

Once the bulk of the system is in place, in Chapter 12, ​Deploying Components​, you’ll deploy your microservices-based system into the wild. In Chapter 13, ​Debugging Components​ you’ll learn how this message-based architecture helps you keep a health system running. You’ll even get exposure to how this architecture alters how you test your system in Chapter 14, ​Testing in a Microservices Architecture

What This Book Isn’t

This is a hands-on tutorial, not a reference book or The Definitive Guide to microservices. There are topics we won’t cover in detail. In Chapter 15, ​Continuing the Journey​, the final chapter, we call out some of these topics, and you’ll have pointers on how to continue your learning.

This isn’t a book about flashy technology. You’re going to use PostgreSQL, a world-class relational database, and that’s about as exciting as the tools get. The excitement, instead, is in the principles.

About the Author

Ethan's love of computer programming began at age 4 when his dad taught him to make the family TI-99/4A beep. For the past 12 years Ethan has worked professionally up and down the abstraction hierarchy, from junior developer up to platform architect, finally settling into microservice-based architectures for the past 3 years.