Microservices is a software architecture style and has a revolutionary approach to apps. Now they are not in the monolithic structure, but a complex system composed of small particles and independent processes which communicate with each other via APIs. These processes are represented by various services which are decoupled and are designed to run small tasks. You can easily replace all microservices as they are of symmetrical architecture instead of common hierarchical. The potential of microservices is huge, so we will describe them from the perspective of e-commerce and Magento. In this article, we will know about docker containers and see how we can split a large web application into manageable microservices running within docker containers.
What is a Microservice?
Micros service is a small subsystem independently executable within a container. For e.g. in the web application, microservice could be the caching mechanism. It could be the execution mechanism like Ruby backend, node backend, or PHP backend or it can be the database. So each of these should be able to run independently using TCP/IP it can talk to the other service or the parent service if there is any. Microservice allows us to relocate these units within different hosting environments or virtual environments, and these units become extremely manageable.
- One Subsystem of an Application – That can be safely detached
- Independently Scalable – Monitored and scaled-up
- Relocated – Can be hosted elsewhere
- Manageable – Updated and upgraded easily
What is a Docker Container?
Major players are coming into Docker these days including Google, Amazon, and even Microsoft. For practical purposes, you can treat a docker container as a thin super-fast virtual machine. That is it, just like a vagrant. Let’s not look at the complexities of what are the technical differences but for practical purposes, a docker container is just like a virtual machine but it is essentially meant to run just one process. So you don’t run MySQL, Apache or Nginx etc. within one container though you can run it’s not meant to be done so. So a docker container is just like a think very fast virtual machine. You can launch a container within milliseconds. Another very important aspect of docker container is that it is very easy to configure, just a few of code. So the parent code comes from certified or good quality repository and you just need to make a few changes or few configuration to make it available to you. This also makes it very portable. You can run it on any server platform be it cloud or be locally hosted. Another thing is a complex and the entire infrastructure running docker container is repeatable.
- Super Quick to launch: Very fast virtual environment
- Simple to Configure: Fine-tune infrastructure, scale upon demand
- Portability: Make it platform/version independent
- Repeatability: Infrastructure as code, versioning & rollback
Advantages of Microservices using Docker:
It immensely simplifies DevOps. For e.g., if you are using Jenkins for the CI CV pipeline. Jenkin can execute your application pulled from the git repo within a container and destroy the container. So in a fraction of a second, that container can come up and your application can run and can be launched within the container and it can be taken away. So this gives a huge potential for varied testing. For instance, you can test your application in CentOS, Ubuntu or Debian just by running a few docker containers. You don’t need to dedicate hardware for it. So this lowers cost. It also tremendously simplifies the infrastructure.
- Simplify DevOps: Simplify CI & CD pipeline
- Lower Costs: Fine-tune infrastructure, scale-up only on demand
- Simplify Infrastructure: Software-driven load balancing & auto-scaling
How do we start the Microservices Journey?
Firstly, you need to look at a sample application. Take the application and see what the major components are, for instance, identify the caching mechanism and further split the caching mechanism in the front-end caching, block-level caching, sessions caching. Identify the database persistent areas, identify the execution part of the engine that is executing the code, identify the static content and the webserver. You also need to identify the platforms and ports because these microservices will be using TCP/IP basically to take to each other on the specific force you need to identify the ports and also the IP address through a certain mechanism so that these individual microservice mode micro-units can talk to each other. You also need to know the dependencies for instance when you launch your platform you should know that certain services should be ready before certain services are activated for instance database service and the caching mechanism should be ready before your web server comes up etc. So that the UX should not be disturbed.
- Identify the Software components: Use of TCP/IP protocol to interact
- Identify the Platforms and Ports: Decide the processing, memory and ports
- Identify the Dependencies: Decide sync/async natures
- Locate the Persistence Needs: Locate the transient and persistent areas
An Example UseCase for Magento 2 CE/EE and Docker:
Now let’s look at a sample use case where we see how we can split a complex PHP-based very popular e-commerce platform called Magento 2 big community edition or the enterprise edition in two separate docker containers. Suppose there is a fully working Magento implementation running on a dedicated server. The goal is to split this into two separate docker unions or micro-services. You need to separate out the database part of the Magento into a separate container. This can be a container or it can be an Amazon RDS etc. but you are splitting it. So the database part goes away from this. As a micro-service running within a docker container for instance. Now the caching mechanism beat Memcache behaves the radius separate it out into another doc one or multiple docker containers. This could also be Amazon’s elastic cache. Now the front-end caching mechanism varnish for instance if you are using front-end caching. You can also split that up into a set of microservices that are running behind even a load balancer so that 90% of the users visiting your site hits these microservices units through a load balancer. The Nginx web server lit it out again into docker containers as microservices even behind a load balance. Next is the execution part PHP engine being PHP fpm. Separate that out also into even a vertically scalable powerful docker container. Let’s separate out the Magento source code into a set of docker containers and here the code that you developed or the extensions that you build on top of Magento and the Magento source repository both can be a test and these volumes can be mapped so that the CICV pipeline can be attached. In the nutshell, this is how we split Magento software into a set of microservices.