If you’re designing a new application architecture, there are a few critical things to consider.
First, it’s important that you choose the right patterns and tools from the get-go. After all, you only have one opportunity to lay that architecture — at the beginning of the product lifecycle. Any changes down the road can be challenging to implement.
At the same time, to meet business requirements and respond to changes, that architecture must meet all the necessary standards and be modern.
In addition, there’s cost. The cost of development, making changes, and so on.
These are some hefty considerations for any architect at the beginning of the product lifecycle. On the one hand, you want to use proven solutions, but given the lengthy lifecycle of the product — potentially five years — you don’t want the solution to become obsolete before the life span of your chosen solution ends. On the other hand, there are a huge number of up-to-the-minute solutions that modernize your applications. However, as these are new, not yet proven solution with little to no vendor support, they greatly increase technological risk.
It’s a tough trade-off. Choosing the optimal solution is the task of the architect. It’s up to you to design and architecture (or lay the technological basis) of a modern solution.
Here’s how you do it.
Step 1: Start with Microservices and the Cloud
Of course, a good starting point is a microservice architecture which is inherently mature from a technological point of view. Your next consideration is the use of the cloud. However, cloud services greatly increase the probability of vendor lock-in, so it’s not always the best approach. If you need maximum flexibility in the future, cloud infrastructure (not services) are a useful option. A cloud infrastructure is recommended over a cloud service if you are sure that you will stay in the cloud for the long-haul or steer away from shifting cloud vendors. Amazon Web Services (AWS), Microsoft Azure, and Google all play in this arena.
Step 2: Select your System Host
This step involves selecting the next layer of your solution — the system that will host your applications. In addition, at this point, it’s important to consider ancillary tasks such as monitoring, collection, and analysis of logs, reallocation of the resource between applications, security, recovery from crashes, and CI/CD.
A reasonable choice is to use a Docker / Kubernetes bundle. This offers the right balance between novelty and the required functionality and reliability, as well as tried-and-tested industry use.
Kubernetes can help automate many tasks (networking, storage, autoscaling, logs, alerting, etc.) and brings new levels of availability and performance to your applications. The only drawback to Kubernetes is that it can be a difficult adjustment. Despite its many benefits, as we previously discussed when offering tips on choosing the best Kubernetes management platform, Kubernetes is still relatively difficult to set-up and use. Nevertheless, there are several solutions and companies that can help solve this issue.
The takeaway here is that, by itself, a cloud-Docker-Kubernetes architecture doesn’t make your solution a microservice, they just give it a fundamental foundation — the foundation on which the microservice application should work.
Step 3: Choose the Right Patterns
To achieve a true microservice foundation and a properly designed modern and future-ready architecture, you need to use the right patterns. Microservices presents itself as a series of patterns. It’s your task to select the pattern that makes sense for your own business, goals, and culture. To do this, there are many books, articles, etc. that can help, but there are also add-ons to Kubernetes that automate away the complexity of patterns and ensure your microservice implementation is successful.
One such solution is Istio. Relatively new, Istio helps you design applications in such a way that the business logic is removed — the things that relate to the function of the application in the microservice environment. Essentially, all the functionality that is needed in the microservice environment is placed outside the scope of your application, saving time and money on the one hand, and ease the design of applications on the other. This allows you to write the business logic of the application in any programming language, container it, and Istio takes care of the not-so-insignificant things like authentication, authorization, discovery, intelligent routing and load balancing, traffic control, and security.
The Bottom Line
Follow the steps above and you’ll achieve a balanced and modern application architecture that saves money and ensures a long lifecycle, without sacrificing quality and safety. Plus, developers using this methodology and tools will be more motivated and productive. After all, developers love working with cutting technologies that provide them with the flexibility to dev where they want and run where they please.