When ‘Scalability’ was the priority!

Often, when we start building something, we have amazing ideas! We launch the app, client feedback is amazing, but then slowly problems start creeping in.

“Analytics report says load times are high, app keeps on crashing because database has reached its threshold limit. But at first the test reports were positive, everything was according to the plan, then what might have gone wrong?”

This is the exact situation most of us might have faced.

Now the question arises, what’s the root cause of this problem? 

It’s ‘Scalability,’ which is often ignored. It starts creating problems like poor UX, high maintenance cost etc. So, Scalability should not only be considered, but made mandatory while moving forward with a project.

Similarly, recently one of our clients was interested in building an application which is ‘Scalable’ based on the requested load and can be easily deployed to the required servers.

Being a new entrant, they wanted to build the project with secured and tested components. Expectations were to build an application using the Microsoft technologies, which would be highly secured and available.

Challenges of building the application were:

  • Implementing the desired solution to build the application, test it, deploy the same and then test the deployed application for parameters like high security and minimum downtime.
  • At the same time application needed to be scalable and highly available.

How AFour helped

  • Developed the code in the .Net core technology, because of below mentioned reasons:
    • Open source (Visual Studio code)
    • High performance
    • Supports cross platform: Linux, Mac and Windows
    • Free to use different .Net versions as per the application requirement
  • Used Microsoft Azure Pipeline, reasons are as follows:
    • Visual Studio Team Server to store the code repo, because is highly secure.
    • Cloud-based platform, developer can write and commit a code from any location.
    • Lower maintenance cost.
    • Stakeholder can closely monitor the ongoing project activities.
    • Embed modern DevOps features.
    • Run unit test automatically, which tests all the methods with the expected results.
    • Code coverage, which shows the part of code which is covered by the unit tests.
    • Continuous Integration (CI), as a result of CI, most bugs are found almost immediately after the code change is committed. This leads to better quality.
    • Continuous Deployment: It is a strategy for software releases wherein any commit that passes the automated testing phase is automatically released into the production deployment.
    • Azure Kubernetes Service (AKS) used for flexible, automated and reduced management overhead for administrators as well as developers. AKS supports role-based authentication through Azure Active Directory. Thus, Admin can monitor the health of the containers. Also, AKS is compliant with major regulatory bodies including ISO, HIPPA and HITRUST.
  • Used Microservice architecture for the application, because of the following reasons:
    • Agility: Many small independent teams working on many developments.
    • Scalability: Fine-grained decoupling of microservices is a best practice for building large- scale systems. Properly decoupled services can be scaled horizontally and independently from each other.
    • Code for different services can be written in different languages.
    • Availability: Microservice make it easier to implement failure isolation.
    • Components can be spread across multiple servers or even multiple data centers.
  • Used Azure Service Bus because it’s a generic, cloud-based messaging system for connecting anything – applications, services and devices, irrespective of their location.
    • Used Azure Blob Storage to store any types of data (without any relation)
    • Durable and highly available
    • Secure
    • Scalable
    • Managed
  • Used Azure Key Vault: It allows to securely manage and protect cryptographic keys and secrets that can be used by cloud-enabled applications and services.
  • Used Azure Active Directory: It is Microsoft’s cloud-based identity and access management service. We used it for the following reasons:
    • Single sign-on for multiple applications
    • Azure AD multifactor authentication and conditional access
    • Works with iOS, Mac OS X, Android and Windows devices
    • Protect sensitive data and applications.
  • Used Azure Application Insights: It is an extensible Application Performance Management (APM) service for web developers on multiple platforms. We used it to monitor live web application and to automatically detect performance anomalies.
  • Used Azure API Management: The client had created a private VPN for all the Azure components, so we called it internally without public IP address. As it was a private VPN, no application was exposed to anyone. The Azure API management had public IP, facilitating the third-party service and API.
  • Management called the internal components using the private IP address. Some of the benefits of API management were as follows:
    • API Management abstracts APIs from their implementation and hosts them under the same domain or a static IP address.
    • API Management can also execute rules on APIs.
    • API Management simplifies changing APIs.
    • Using API Management secures APIs by aggregating them in Azure API Management, and not exposing micro-services directly.

As a result, we were able to achieve few milestones: We helped in building a secure and robust application with all its services working independently. Quickly tested and deployed the application on multiple environments while detecting errors at early stages. And the most important attribute was to make application highly scalable.

 



Leave a Reply