Introduction to App Modernization
Traditional Applications are less agile as services and all their features are packaged into a single exe file making it harder to scale and perform maintenance on them as years go by.
Microservices
The microservices architecture breaks a bulky app into a small set of decentralized, discrete apps that are loosely coupled and can be deployed as individual services that can be managed independently. Developers can quickly change, replace, and scale applications quickly without taking down the entire service when individual functionalities (eg: payment gateway) are individually deployed as containers.
In short, the term Microservices simply means an application that was once bulky is split and now comprised of several small, independent components or services managed separately.
What are Monolithic Apps
These are the apps that we know today that all services and features are packaged into a single executable file.
The testing of such apps is very complicated as the entire service needs to be taken down so the maintenance becomes hard in the long run.
It’s also quite inefficient to scale these services beyond a certain limit.
What are Modern Apps
In the modern application deployment model, as apps are deployed as microservices it offers these advantages
- New releases can be developed and tested much faster
- Scale apps easily
- Management and maintenance are easy as the entire service doesn’t need to be taken offline.
Application Modernization Techniques
- Cloud – Deploying Apps in Cloud ( AWS, GCP)
- Containers – Apps are always suitable for multi and hybrid cloud.
- Microservices – Apps aren’t built as a single application file. Services are decoupled into smaller units and managed independently.
- Orchestration and Automation
Virtual Machines vs Containers
A virtual machine has an underlying OS such as Windows or Linux and apps are installed on top of it.
A Container on the other hand has just 1 base OS from runs from a container host and this container host will be on a standard OS such as Ubuntu/Windows etc. New containers are launched from here which are managed by a container engine (Kubernetes /Docker). Containers in short are ready-to-run software packages containing everything needed to run an application. All the elements that are required to perform a particular process in an app are packaged into a file called Docker file which is a code that can be deployed anywhere so it’s a cloud-centric method. A container thus offers an isolated context in which the app and its environment can be run. A container workflow engine would be as shown here.
Kubernetes Architecture
The more containers, the more difficult its to manage them, and hence we use Kubernetes as one such tool to manage containers. Similar to Docker Swarm, Kubernetes is an orchestration solution that helps in the deployment, life cycle management, maintaining the desired state of deployed containers, and scaling of containerized applications from a central UI ( much like a vCenter). Kubernetes is responsible for spinning up the containers we need. Like Docker needs a file called Docker file, Kubernetes relies on a YAML file ( ie: manifest ) which is a configuration file that needs to be run to deploy containers.
Kubernetes Pod
All containers that sit inside a pod that is self-managed units having their own IP address, config data, storage resources, etc are all configured in pods. Apps are deployed across pods.
Kubernetes Node
Pods run on the usual virtual machines and its also known as nodes in Kubernetes.
Kubernetes Cluster
Few Kubernetes node forms a Kubernetes cluster
Kubernetes Control Plane
This is the brain of Kubernetes that’s responsible for acting as a manager controlling all the pods, workers, nodes, etc.
