1.6 What is a microservices application?
1.7 What’s wrong with the monolith?
1.8 Why are microservices popular now?
1.10 Drawbacks of microservices
1.11 Modern tooling for microservices
1.12 Designing a microservices application
2 Creating your first microservice
2.1 New tools
2.2 Getting the code
2.3 Why Node.js?
2.4 Our philosophy of development
2.5 Establishing our single-service development environment
Getting Visual Studio (VS) Code
2.6 Building an HTTP server for video streaming
Creating the Express boilerplate
Live reloading for fast iteration
Running the finished code from this chapter
2.7 Node.js review
3 Publishing your first microservice
3.1 New tools
3.2 Getting the code
3.5 Why Docker?
3.6 What are we doing with Docker?
3.7 Extending our development environment with Docker
Checking your Docker installation
3.8 Packaging our microservice
Packaging and checking our Docker image
Booting our microservice in a container
3.9 Publishing our microservice
Creating a private container registry
Pushing our microservice to the registry
Booting our microservice from the registry
3.10 Docker review
4 Data management for microservices
4.1 New tools
4.2 Getting the code
4.3 Developing microservices with Docker Compose
Creating our Docker Compose file
Booting our microservices application
Can we use Docker Compose for production?
4.4 Adding file storage to our application
Updating the video-streaming microservice
Adding our new microservice to the Docker Compose file
Testing the updated application
Cloud storage vs. cluster storage
4.5 Adding a database to our application
Adding a database server in development
Adding a database server in production
Database-per-microservice or database-per-application?
5 Communication between microservices
5.2 Getting the code
5.3 Getting our microservices talking
5.4 Introducing the history microservice
5.5 Live reload for fast iterations
Creating a stub for the history microservice
Augmenting the microservice for live reload
Splitting our Dockerfile for development and production
Updating the Docker Compose file for live reload
Testing production mode in development
5.6 Methods of communication for microservices
5.7 Direct messaging with HTTP
Directly targeting messages at particular microservices
Sending a message with HTTP POST
Receiving a message with HTTP POST
Testing the updated application
5.8 Indirect messaging with RabbitMQ
Indirectly targeting messages to microservices
Investigating the RabbitMQ dashboard
Connecting our microservice to the message queue
Single-recipient indirect messaging
5.9 Microservices communication review
6 Creating your production environment
6.1 New tools
6.2 Getting the code
6.5 Hosting microservices on Kubernetes
6.6 Working with the Azure CLI
6.7 Creating infrastructure with Terraform
6.8 Creating an Azure resource group for your application
Evolutionary architecture with Terraform
Scripting infrastructure creation
By-products of Terraform initialization
Fixing provider version numbers
Destroying and recreating your infrastructure
6.9 Creating your container registry
Continuing the evolution of our infrastructure
Creating the container registry
6.10 Refactoring to share configuration data
Continuing the evolution of our infrastructure
Introducing Terraform variables
6.11 Creating our Kubernetes cluster
Scripting creation of your cluster
Cluster authentication with Azure
6.12 Interacting with Kubernetes
6.13 Terraform review
7 Getting to continuous delivery
7.2 Getting the code
7.3 Continuing to evolve our infrastructure
7.5 Deploying containers with Terraform
Configuring the Kubernetes provider
Preparing for continuous delivery
Testing the new database server
Deploying and testing RabbitMQ
7.6 Deploying our first microservice with Terraform
Using local variables to compute configuration
Building and publishing the Docker image
Authentication with the container registry
Deploying the video-streaming microservice
7.7 Continuous delivery with Bitbucket Pipelines
Importing the example code to Bitbucket
Creating a deployment shell script
The Bitbucket Pipelines script
Configuring environment variables
Testing your deployment pipeline
Debugging your deployment pipeline
8 Automated testing for microservices
8.1 New tools
8.2 Getting the code
8.6 Unit testing
Creating an integration test with Jest
Creating an end-to-end test with Cypress
8.9 Automated testing in the CD pipeline
8.10 Review of testing
9.1 No new tools!
9.2 Getting the code
9.3 Revisiting essential skills
Microservice project structure
9.5 Running FlixTube in development
9.6 Testing FlixTube in development
Testing a microservice with Jest
Testing the application with Cypress
9.8 Manually deploying FlixTube to production with Terraform
The Terraform scripts structure
9.9 Continuous delivery to production
Setting up your code repository
Testing the continuous delivery (CD) pipeline
9.10 Review
10.1 Maintaining healthy microservices
10.2 Monitoring your microservices
Roll your own log aggregation for Kubernetes
Enterprise logging, monitoring and alerts
Automatic restarts with Kubernetes health checks
Debugging production microservices
Practice defensive programming
Fault isolation and graceful degradation
Simple techniques for fault tolerance
Advanced techniques for fault tolerance
11.2 Scaling the development process
Splitting the continuous delivery (CD) pipeline
Creating multiple environments
11.3 Scaling performance
Vertically scaling the cluster
Horizontally scaling the cluster
Horizontally scaling an individual microservice
Elastic scaling for the cluster
Elastic scaling for an individual microservice
Managing changes to infrastructure
11.4 Security
11.5 Refactoring to microservices
11.6 Microservices on a budget
11.7 From simple beginnings ...
appendix A. Creating a development environment with Vagrant
appendix B. Bootstrapping Microservices cheat sheet