English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 12h 59m | 1.77 GB
Build a microservices application from scratch using industry standard tools and battle-tested best practices.
The best way to learn microservices development is to build something! Bootstrapping Microservices with Docker, Kubernetes, GitHub Actions, and Terraform, Second Edition guides you from zero through to a complete microservices project, including fast prototyping, development, and deployment.
In Bootstrapping Microservices, Second Edition you’ll get hands-on experience with microservices development skills like:
- Creating, configuring, and running a microservice with Node.js
- Building and publishing a microservice using Docker
- Applying automated testing
- Running a microservices application in development with Docker Compose
- Deploying microservices to a production Kubernetes cluster
- Implementing infrastructure as code and setting up a continuous delivery pipeline
- Monitoring, managing, and troubleshooting
Bootstrapping Microservices with Docker, Kubernetes, GitHub Action, and Terraform has helped thousands of developers create their first microservices applications. This fully revised second edition introduces the industry-standard tools and practical skills you’ll use for every microservices application. Author Ashley Davis’s friendly advice and guidance helps cut down the learning curve for Docker, Terraform, and Kubernetes, showing you just what you need to know to start building.
Taking a microservices application from proof of concept to production requires many steps and a host of tools like Kubernetes, Terraform, and GitHub Actions. But where do you start? With clear, practical introductions to each concept and tool, this book guides you hands-on through designing and building your first microservices application.
Bootstrapping Microservices, Second Edition is your microservices mentor. It teaches you to use industry-standard tools to create a working video streaming application from the ground up. You’ll learn the pillars of cloud-native development, including Terraform for configuration, Docker for packaging, and a basic Kubernetes deployment. Plus, this second edition includes coverage of GitHub Actions, continuous delivery, and Infrastructure as Code.
What’s inside
- Deploying microservices to Kubernetes
- Automated testing and continuous delivery
- Monitoring, managing, and troubleshooting
Table of Contents
1 An example application
2 Benefits of microservices
3 Designing a microservices application
4 Drawbacks of microservices
5 Managing complexity
6 Modern tooling for microservices
7 Not just microservices
8 Summary
9 The spectrum of possibilities
10 What do you need to know
11 What is a microservice
12 What is a microservices application
13 What s wrong with the monolith
14 What will you learn
15 Why are microservices popular now
16 Why microservices
17 Building an HTTP server for video streaming
18 Continue your learning
19 Creating your first microservice
20 Establishing our single-service development environment
21 Getting the code
22 Node.js review
23 Our philosophy of development
24 Summary
25 Why Node.js
26 Adding Docker to our development environment
27 Continue your learning
28 Docker review
29 Getting the code
30 Packaging our microservice
31 Publishing our microservice
32 Publishing your first microservice
33 Summary
34 What is a container
35 What is an image
36 Why Docker
37 Why do we need Docker
38 Adding a database to our application
39 Adding file storage to our application
40 Continue your learning
41 Data management for microservices
42 Developing microservices with Docker Compose
43 Docker Compose review
44 Getting the code
45 Summary
46 Communication between microservices
47 Continue your learning
48 Direct messaging with HTTP
49 Getting our microservices talking
50 Getting the code
51 Indirect messaging with RabbitMQ
52 Introducing the history microservice
53 Live reload for fast iterations
54 Methods of communication for microservices
55 Microservices communication review
56 Summary
57 Azure CLI tool review
58 Continue your learning
59 Creating a managed Kubernetes cluster in Azure
60 Deploying to the local Kubernetes instance
61 Deploying to the production cluster
62 Enabling your local Kubernetes instance
63 Getting the code
64 Going to production
65 Hosting microservices on Kubernetes
66 Installing the Kubernetes CLI
67 Kubectl review
68 Project structure
69 Summary
70 The road to production
71 Working with the Azure CLI
72 Authenticate with your Azure account
73 Continue your learning
74 Creating an Azure resource group for your application
75 Creating our Kubernetes cluster
76 Creating our container registry
77 Creating the infrastructure with Terraform
78 Deploying to our cluster
79 Destroying our infrastructure
80 Getting the code
81 Infrastructure as code (1)
82 Infrastructure as code
83 Prototyping our infrastructure
84 Refactoring to share configuration data
85 Summary
86 Terraform review
87 Which version of Kubernetes
88 An introduction to automation with GitHub Actions
89 Continue your learning
90 Continuous deployment
91 Continuous deployment for a microservice
92 Getting the code
93 Running the examples in this chapter
94 Summary
95 What is continuous deployment
96 What is continuous integration
97 Why automate deployment
98 Implementing continuous integration
99 Automated testing
100 Automated testing for microservices
101 Automated testing in the CICD pipeline
102 Automated testing with Jest
103 Continue your learning
104 End-to-end testing
105 Getting the code
106 Integration testing
107 Review of testing
108 Summary
109 Testing for microservices
110 Unit testing for microservices
111 Continue your learning
112 Continuous deployment to production
113 Deploying FlixTube to our local Kubernetes
114 FlixTube deep dive
115 FlixTube in the future
116 Getting the code
117 Manually deploying FlixTube to production
118 Overview of FlixTube
119 Revisiting essential skills
120 Running FlixTube in development
121 Shipping FlixTube
122 Summary
123 Testing FlixTube in development
124 Continue your learning
125 Debugging microservices
126 Healthy microservices
127 Monitoring and managing microservices
128 Reliability and recovery
129 Summary
130 Basic security
131 Continue your learning
132 From simple beginnings . .
133 Microservices on a budget
134 Mitigating problems caused by changes
135 Pathways to scalability
136 Refactoring to microservices
137 Scaling performance
138 Scaling the development process
139 Summary
140 The spectrum of possibilities
Resolve the captcha to access the links!