Microservices are an application architecture style where independent, self-contained programs with a single purpose each can communicate with each other over a network. Typically, these microservices are able to be deployed independently because they have strong separation of responsibilities via a well-defined specification with significant backwards compatibility to avoid sudden dependency breakage.
Microservices follow in a long trend of software architecture patterns that become all the rage. Previously, CORBA and (mostly XML-based) service-oriented architectures (SOA) were the hip buzzword among ivory tower architects.
However, microservices have more substance because they are typically based on RESTful APIs that are far easier for actual software developers to use compared with the previous complicated XML-based schemas thrown around by enterprise software companies. In addition, successful applications begin with a monolith-first approach using a single, shared application codebase and deployment. Only after the application proves its usefulness is it then broken down into microservice components to ease further development and deployment. This approach is called the "monolith-first" or "MonolithFirst" pattern.
Martin Fowler's microservices article is one of the best in-depth explanations for what microservices are and why to consider them as an architectural pattern.
Why microservices? presents some of the advantages, such as the dramatically increased number of deployments per day, that a well-done microservices architecture can provide in the right situation. Many organizational environments won't allow this level of flexibility but if yours is one that will, it's worth considering these points.
On monoliths and microservices provides some advice on using microservices in a fairly early stage of a software project's lifecycle.
Why Microservices? presents advantages microservices can bring to an existing monolithic application where it is clear what needs to be broken down into smaller components to make it easier to iterate and maintain.
Developing a RESTful microservice in Python is a good story of how an aging Java project was replaced with a microservice built with Python and Flask.
Microservices: The essential practices first goes over what a monolith application looks like then dives into what operations you need to support potential microservices. For example, you really need to have continuous integration and deployment already set up. This is a good high-level overview of the topics many developers aren't aware of when they embark on converting a monolith to microservices.
Using Nginx to Load Balance Microservices explains how an Nginx instance can use configuration values from etcd updated by confd as the values are modified. This setup can be useful for load balancing microservices as the backend services are brought up and taken down.
How Microservices have changed and why they matter is a high level overview of the topic with some quotes from various developers around the industry.
The State of Microservices Today provides some general trends and broad data showing the increasing popularity of microservices heading into 2016. This is more of an overview of the term than a tutorial but useful context for both developers and non-developers.
bla bla microservices bla bla is a transcript for a killer talk on microservices that breaks down the important first principles of distributed systems, including asynchronous communication, isolation, autonomicity, single responsibility, exclusive state, and mobility. The slides along with the accompanying text go into how reality gets messy and how to embrace the constraints inherent in distributed systems.
In the Microservices with Docker, Flask, and React course, you will learn how to quickly spin up a reproducible development environment with Docker to manage a number of microservices. Once the app is up and running locally, you'll learn how to deploy it to an Amazon EC2 instance. Finally, we'll look at scaling the services on Amazon EC2 Container Service (ECS).
Zuul is open source proxy for combining multiple microservices into a unified API call. Check out this post on Using Netflix Zuul to Proxy your Microservices to learn more and get started using it.
The Majestic Monolith explains the advantages of a monolithic architecture and how it's worked amazingly well for the Basecamp small development team.
Documenting microservices has some good thoughts on how to explain your microservice API to other developers such as clearly showing all of the endpoints as well as the intersection of multiple endpoints.
Best practices for building a microservice is an exhaustive (and somewhat exhausting to read!) list with what you should think about as you build your microservice.
The Hardest Part About Microservices: Your Data presents a data-centric view on how to structure and transport data in a microservices architecture.
Making microservices more resilient with circuit breakers provides a solid idea for how to handle issues with microservices so the problems are less likely to cascade through your entire infrastructure.
Fix errors in your Python code before your users see them by monitoring with Rollbar.
Deploy web apps with the Ansible configuration management tool.