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.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Section 1: Introduction to Microservices

Section 1: Introduction to Microservices

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

Further reading

Section 2: Designing and Operating a Single Service – Creating a Docker Container

Section 2: Designing and Operating a Single Service – Creating a Docker Container

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

Further reading

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

Further reading

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

Further reading

Section 3:Working with Multiple Services – Operating the System through Kubernetes

Section 3:Working with Multiple Services – Operating the System through Kubernetes

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

Further reading

Local Development with Kubernetes

Local Development with Kubernetes

Technical requirements

Implementing multiple services

Configuring the services

Deploying the full system locally

Further reading

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

Further reading

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

Further reading

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

Further reading

Section 4: Production-Ready System – Making It Work in Real-Life Environments

Section 4: Production-Ready System – Making It Work in Real-Life Environments

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

Further reading

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

Further reading

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

Further reading

Assessments

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Understanding the life cycle of a feature

Following on from agile principles, the main objective of any team is to be able to implement new features quickly, without compromising the quality or stability of the system. The first element of change comes in the shape of a feature request.

A feature request is a description of a change in the system in non-technical terms. Feature requests are normally generated by non-engineers (product owners, managers, and CEOs) who are looking to improve the system for business-related reasons, such as making a better product or increasing revenue.

Feature requests can be simple, such as updating the logo of the company in the main page, or big and complicated, such as adding support to the new 5G network. Feature requests may include bug reports. While they don't usually, they will for the purpose of this chapter.

Complicated feature requests...