Book Image

Hands-On Docker for Microservices with Python

By : Jaime Buelta
Book Image

Hands-On Docker for Microservices with Python

By: Jaime Buelta

Overview of this book

Microservices architecture helps create complex systems with multiple, interconnected services that can be maintained by independent teams working in parallel. This book guides you on how to develop these complex systems with the help of containers. You’ll start by learning to design an efficient strategy for migrating a legacy monolithic system to microservices. You’ll build a RESTful microservice with Python and learn how to encapsulate the code for the services into a container using Docker. While developing the services, you’ll understand how to use tools such as GitHub and Travis CI to ensure continuous delivery (CD) and continuous integration (CI). As the systems become complex and grow in size, you’ll be introduced to Kubernetes and explore how to orchestrate a system of containers while managing multiple services. Next, you’ll configure Kubernetes clusters for production-ready environments and secure them for reliable deployments. In the concluding chapters, you’ll learn how to detect and debug critical problems with the help of logs and metrics. Finally, you’ll discover a variety of strategies for working with multiple teams dealing with different microservices for effective collaboration. By the end of this book, you’ll be able to build production-grade microservices as well as orchestrate a complex system of services using containers.

Related Content you might be interested in

Current Title:

Small book image
Hands-On Docker for Microservices with Python
Jaime Buelta
Nov, 2019 | 408 pages
Small book image
Python Architecture Patterns
Jaime Buelta
Jan, 2022 | 594 pages
Small book image
Docker on Amazon Web Services
Justin Menga
Aug, 2018 | 822 pages
Small book image
Kubernetes on AWS
Edward Robinson
Nov, 2018 | 270 pages
Table of Contents (19 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Section 1: Introduction to Microservices
Section 1: Introduction to Microservices
2
Making the Move – Design, Plan, and Execute
Making the Move – Design, Plan, and Execute
Technical requirements
The traditional monolith approach and its problems
The characteristics of a microservices approach
Parallel deployment and development speed
Challenges and red flags
Analyzing the current system
Preparing and adapting by measuring usage
Strategic planning to break the monolith
Executing the move
Summary
Questions
Further reading
3
Section 2: Designing and Operating a Single Service – Creating a Docker Container
Section 2: Designing and Operating a Single Service – Creating a Docker Container
4
Creating a REST Service with Python
Creating a REST Service with Python
Technical requirements
Analyzing the Thoughts Backend microservice
Designing the RESTful API
Defining the database schema
Implementing the service
Testing the code
Summary
Questions
Further reading
5
Build, Run, and Test Your Service Using Docker
Build, Run, and Test Your Service Using Docker
Technical requirements
Building your service with a Dockerfile
Operating with an immutable container
Configuring your service
Deploying the Docker service locally
Pushing your Docker image to a remote registry
Summary
Questions
Further reading
6
Creating a Pipeline and Workflow
Creating a Pipeline and Workflow
Technical requirements
Understanding continuous integration practices
Configuring Travis CI
Configuring GitHub
Pushing Docker images from Travis CI
Summary
Questions
Further reading
7
Section 3:Working with Multiple Services – Operating the System through Kubernetes
Section 3:Working with Multiple Services – Operating the System through Kubernetes
8
Using Kubernetes to Coordinate Microservices
Using Kubernetes to Coordinate Microservices
Technical requirements
Defining the Kubernetes orchestrator
Understanding the different Kubernetes elements
Performing basic operations with kubectl
Troubleshooting a running cluster
Summary
Questions
Further reading
9
Local Development with Kubernetes
Local Development with Kubernetes
Technical requirements
Implementing multiple services
Configuring the services
Deploying the full system locally
Summary
Questions
Further reading
10
Configuring and Securing the Production System
Configuring and Securing the Production System
Technical requirements
Using Kubernetes in the wild
Setting up the Docker registry
Creating the cluster
Using HTTPS and TLS to secure external access
Being ready for migration to microservices
Deploying a new Docker image smoothly
Autoscaling the cluster
Summary
Questions
Further reading
11
Using GitOps Principles
Using GitOps Principles
Technical requirements
Understanding the description of GitOps
Setting up Flux to control the Kubernetes cluster
Configuring GitHub
Making a Kubernetes cluster change through GitHub
Working in production
Summary
Questions
Further reading
12
Managing Workflows
Managing Workflows
Understanding the life cycle of a feature
Reviewing and approving a new feature
Setting up multiple environments
Scaling the workflow and making it work
Summary
Questions
Further reading
13
Section 4: Production-Ready System – Making It Work in Real-Life Environments
Section 4: Production-Ready System – Making It Work in Real-Life Environments
14
Monitoring Logs and Metrics
Monitoring Logs and Metrics
Technical requirements
Observability of a live system
Setting up logs
Detecting problems through logs
Setting up metrics
Being proactive
Summary
Questions
Further reading
15
Handling Change, Dependencies, and Secrets in the System
Handling Change, Dependencies, and Secrets in the System
Technical requirements
Understanding shared configurations across microservices
Handling Kubernetes secrets
Defining a new feature affecting multiple services
Dealing with service dependencies
Summary
Questions
Further reading
16
Collaborating and Communicating across Teams
Collaborating and Communicating across Teams
Keeping a consistent architectural vision
Dividing the workload and Conway's Law
Balancing new features and maintenance
Designing a broader release process
Summary
Questions
Further reading
17
Assessments
Assessments
Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
18
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Chapter 6

  1. What are the three microservices that we are deploying?

The following are the three microservices that we are deploying:

  • The Users Backend, which controls authentication and how users are handled.
  • The Thoughts Backend, which stores thoughts and allows us to create and search for them.
  • The Frontend, which provides us with a user interface so that we can interact with the system. It calls the other two microservices through RESTful calls.
  1. Which of the three microservices requires the other two microservices to be available?

The Frontend calls the other two microservices, so they need to be available for the Frontend to work.

  1. Why do we need to use external IPs to connect to microservices while they're running in docker-compose?

docker-compose creates an internal network for each microservice, so they need to communicate using an external IP so that they&apos...

Previous Section
End of Section 7
Next Section