How to Accelerate your Microservices Journey with Choreo

  • By Chanaka Fernando
  • 5 Jul, 2021


Microservice architecture is an evolutionary approach to build robust, scalable, and highly available distributed applications. According to Martin Fowler,

“Microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies”.

Some of its notable advantages include the following:

  • The ability to build fault-tolerant applications - With the componentized architecture, each functional capability is implemented as a separate microservice and hence failure of one component does not affect the entire application. Rather, it will only disable certain functionalities, and with proper error handling, these components can recover quickly.
  • Supports scalability demands - Since each microservice can be deployed and scaled independently, only the required components can be scaled as and when required without scaling the entire application. With container-based deployments, automated scalability policies can be implemented according to the needs of the particular microservices.
  • Help utilizing infrastructure in an optimal manner - Instead of scaling the entire application, microservices architecture enables scaling only the required service. Hence, it avoids the over-provisioning of resources. At the same time, containers allow the applications to run with minimal overhead, since no guest operating system is required to run these microservices as separate processes.
  • Accelerate innovation with improved software delivery process - By automating development, testing, and deployment process with CICD pipelines, the software delivery process can be vastly improved and the time to release applications can be reduced. This helps organizations to release new services faster and speed up innovation.
  • Build systems that are easy to support and maintain- Since microservices has a comparatively smaller scope than a monolithic application, each microservice can be supported and maintained easily. With proper observability built into the microservices, this task becomes much easier.

When building systems with microservices architecture, we should consider both the “Inner Architecture” and “Outer Architecture” of the solution as depicted in the following diagram.

Figure 1: Microservices Inner and Outer Architecture

The “Inner Architecture” discusses implementation details of individual microservices and focuses on the aspects of defining scope (breaking the monolith if applicable), such as selecting programming languages and formulating teams.

The “Outer Architecture” focuses on the overall “platform” aspect of the solution and how these microservices can be delivered to end-customers and managed over a long period of time. Most of the time, people tend to focus on “Inner Architecture” and spend much of their time arguing about it. They find it difficult to deal with “Outer Architecture” down the line. You can find more information on this architecture separation in this post.

Challenges of microservices architecture

The natural inertia to the change that people demonstrate can cause many challenges when driving a project that uses a microservices architecture. Let’s identify these challenges first before discussing the approaches to face them with Choreo.

  • Steep learning curve on technologies, such as containers, Docker, and Kubernetes
  • Implementing underlying infrastructure for automation and provisioning
  • Integrating with existing infrastructure
  • Discovering services and collaboration across teams
  • Securing microservices
  • Observability of microservices
  • Inter-service communication
  • Organizational structures

Let’s take a closer look at each of these challenges so that we can address them with the proper tools and architecture.

Steep learning curve

Most organizations use on-premises hardware or virtualization technologies to deploy their applications. But microservices suggests using a container-based approach to deploy microservices and manage these containers using tools such as Docker and Kubernetes. These tools are not the easiest to learn and developers now have to learn these technologies, in addition to the programming languages and tools they use. This can cause a lot of people to turn away from going ahead with microservices, unless we can convince them with the right tools that can help them to quickly learn and adopt these technologies.

Infrastructure automation and provisioning

Microservices architecture encourages automated deployments with Continuous Integration and Continuous Deployment (CICD). Setting up these CICD pipelines requires a lot of effort to purchase the tools, install them, configure them, integrate them and finally manage all these tools. The IT operations teams have to learn these tools and set up these tools on their infrastructure along with other technologies such as Docker and Kubernetes to implement an end to end automated release process. This will require a lot of time and effort to build such an infrastructure and a separate team to manage it.

Integrating with existing infrastructure

Most enterprises have many other systems and applications that help to run business operations in addition to the microservices that we build. Hence, it is an essential requirement to integrate with these existing systems. If these systems support basic REST style communication mechanisms, then the microservices can communicate with these systems as and when required in a point to point manner. But it is not a scalable solution, and most of these systems won’t communicate over simple REST interfaces. In such a situation, an intermediate component that takes care of the communication between microservices and existing services is required. We call this pattern the anti-corruption layer pattern, and most of the time we use an ESB or an integration platform to support this use case.

Service discovery and collaboration

Once the microservices based development process kicks off and multiple teams start building the services, there should be a mechanism to collaborate among these teams and share their services with each other and external consumers. Without having a central repository, individual teams will build their own services without reusing the already existing services and hence cause delays to the releases of the products and services. A service registry or a developer portal will help the teams to register these services and share experiences with each other and send change requests, so that the overall objectives of the solution can be met while working on individual microservices. It also helps other teams to reuse existing capabilities rather than building from scratch.

Securing microservices

Microservices architecture allows a polyglot type of a programming approach where individual microservices can be developed with different programming languages. There are some common functionalities that are required by each microservice regardless of their choice of technologies. Security is such a common requirement and implementing security using different technologies would be a waste of time and can cause issues with the incompatibility of different implementations. Hence, having a common, standards based security for all the microservices will help reduce the complexity of implementing security at each microservice and helps consumers to follow the standards based model to consumer services with minimum effort.

Observability of microservices

Observability is a characteristic of the platform that defines how well internal states of a system can be inferred from knowledge of its external outputs. A solution without proper observability is hard to recover and troubleshoot when things do not go as expected. In the world of distributed systems, failure is inevitable and systems need to be designed in such a way that they can withstand failures. It is the responsibility of each microservices team to have proper observability in their own implementations and share a common set of tools to monitor the applications.

Inter-service communication

Even though microservices are implemented in such a way that each microservice has a defined scope and it operates independently to offer that functionality to consumers, it does not mean that it cannot reuse an already existing service. In a typical layered architecture, there are different levels of functionality implemented by these microservices. There will be a set of core microservices that are fully independent and won’t require interaction with any other microservices. But there can be a second level of microservices that communicates with these core services and produce output that are further consumed by top level microservices that communicate with frontend applications. Hence, it is essential to have proper mechanisms to support inter-service communication.

Organizational structures

In addition to the technical challenges we mentioned above,there are organization level challenges when forming the teams to develop microservices. In most organizations, teams are used to work in silos and each team acts as a center of excellence (CoE) team within the organization. But with the microservices approach, these CoE teams need to be dissolved and new teams that consist of people from multiple CoE teams need to be formed. These new teams should be provided with the required level of isolation and independence to work towards their common goals.

That is a considerable list of challenges to face when implementing microservices architecture at your organisation. It does not look like a three- or six-month project. Let’s discuss how Choreo can help you to reduce some of these challenges and accelerate your journey towards a microservices architecture.

How Choreo helps with a microservices-based development approach

Choreo is an enterprise integration platform as a service (iPaas) that allows organizations to rapidly develop applications using a low-code or pro-code approach. It helps developers to choose whatever approach they prefer (low-code or pro-code) and start building applications and deploying them to production with minimal effort. As shown in the below diagram, Choreo helps organizations to focus on the “Inner Architecture”, while providing all the surrounding capabilities that are defined by the “Outer Architecture” of the microservices architecture.

Figure 2: Microservices Architecture - Outer Architecture focused

The “Outer Architecture” components highlighted in the preceding figure are provided by the Choreo platform while allowing developers to focus on their implementation details. In addition to that, the “Anti-Corruption” capability also can be achieved with the Choreo platform with its built-in integration platform using Ballerina.

Let’s discuss how Choreo can help an organization to build an effective microservices architecture by tackling the challenges mentioned above.

Choreo helps developers to bootstrap quickly

Choreo is a platform built from the ground up to automate the deployment of applications on containers and Kubernetes. This means that developers do not need to deal with the complexities of creating containers, writing Kubernetes deployment files and doing the relevant configuration. In fact, they don’t need to learn any of these things to develop applications and deploy them on containers in the Choreo platform. This helps developers to quickly get acquainted with the Choreo platform and start building their business applications and release them at speed.

Choreo uses Ballerina as the underlying framework to implement business logic and integration tasks. Ballerina is a programming language that was developed for network-based applications development. Choreo provides a low-code interface to Ballerina by providing a GUI based development mode as well as a full blown code based development mode. Depending on the experience and the preference of the developers, they can choose the best suited mode to get started.

Automated CICD pipelines built-in to Choreo

In a previous section, we discussed how complicated it is to build an end-to-end automated release pipeline for microservices delivery. The Choreo team has taken a lot of time and effort to build such a pipeline, so that users do not need to worry about it. From the moment developers start writing their microservice to the moment it is released to production, the entire process is automated using industry standard tools. The high level automation flow can be stated as below.

  • Microservices development
  • Commit to the SCM (Git)
  • Build the container
  • Deploy to the test environment
  • Execute the tests
  • Deploy to the production environment
  • Monitor

From the starting point of microservices development to the production deployment and monitoring phase, everything is automated and developers can execute these tasks with a click of a button within the Choreo platform. In the case of increased traffic, the underlying Kubernetes platform will automatically scale the microservices according to the needs of the increased usage.

Integration is the core functionality of Choreo

Microservices architecture cannot live without integrating with existing applications and services. Hence, it is necessary to integrate with internal applications as well as cloud services that are used by the enterprise. Choreo is a platform that is built on an integration programming language (Ballerina). It comes with a set of built-in language constructs and connectors that integrate with these internal and external applications. It reduces the complexity of managing a plethora of libraries to implement these integrations, since the language itself has these capabilities built in and the Choreo runtime is fully loaded with these connectors.

In addition to the core microservices, Choreo allows developers to implement integrations as microservices (we refer to them as integration microservices) and manage them in a fully automated manner. Choreo comes with advanced capabilities such as:

  • AI-driven data mapping - Allows developers to quickly develop microservices that requires data transformation functionality
  • AI-driven performance analysis - Provides insights to the performance of the service when deployed, so that developers can optimize the code while implementing
  • Visual representation of integration logic - Complex integration processes can be easily recognized with the sequence diagram representation of the code
  • Pre-built integration templates - Common integration tasks are available as pre-built templates so that developers can get started quickly

These capabilities allow developers to build integrations with improved performance and also reduces time to market.

API management and marketplace for service discovery and collaboration

Microservices architecture allows teams to work independently and release their services according to their own timelines. But these teams are working towards achieving a common goal and hence they need to collaborate as and when required. Choreo allows teams to automatically publish their services into the service registry and create an API out of the microservices automatically. This allows other teams to discover these services and consume those services via the APIs using the developer portal. These APIs can be reused across teams and it will help those teams to take their service to market quickly without rebuilding what has already been built by other teams.

API marketplace functionality is an extension of the developer portal functionality where different organizations or different business units at the same organization can share their APIs with each other via a public API developer portal.

Microservices security via API gateways

Security is a cross-cutting functional requirement of the microservices architecture that is required by every microservice. Choreo makes the life easier for developers by automatically creating an API for each microservice developed in the platform. This API can then be configured to enable security for that service. Choreo allows securing microservices via features such as:

  • OAuth2 based authentication and authorization
  • Token based authentication
  • Control access via rate-limiting policies
  • Username/password based authentication
  • Control access via subscription policies

These built-in features allow microservices developers to enable security for microservices at a fine-grained level without writing any code. All of these options are configured through the user interface with a few clicks.

Advanced monitoring in Choreo

One of the most challenging aspects of microservices architecture is monitoring the platform and identifying the failures and troubleshooting them to recover the application. That requires a significant amount of effort from different microservices teams to work closely and follow common standards. Choreo provides this capability as a built-in feature for microservices developers. Every microservice you build in the Choreo platform is instrumented and the required details are captured during the runtime. If there is a failure in one of the services, the Choreo platform provides several details to troubleshoot the issue. The monitoring details provided by Choreo includes:

  • Log entries during that time period
  • Diagnostic view to analyze the issue
    • Error
    • TPS
    • Latency
    • CPU
    • Memory
  • Method calls during the failure

These details are captured in the production environment and hence provide enough information to troubleshoot the issues. The ability to start/stop new services with a few button clicks allows the services to be reverted back quickly in such scenarios.

Built-in service orchestration capabilities helps implementing inter-service communication

Inter-service communication is critical in microservices architecture since individual microservices need to work with each other to provide integrated functionality to end users. Hence, services should be able to talk to each other without much difficulty. Choreo allows the services to be discovered via the service registry as well as developer portal. In addition, it provides built-in constructs to implement inter-service communication via various protocol connectors, such as HTTP, gRPC and WebSocket. With the visual representation of integration microservices, these orchestrations can be easily recognized by looking at the diagram. In addition, with the advanced observability capabilities built-in to the platform, maintaining complex inter-service communication topologies becomes easier with Choreo.

Manage development teams with organizations

Microservices promotes the concept of autonomous teams that have total control over development and delivery of the services. These teams are not permanent teams with a set of people allocated for long periods of time. Rather these are dynamic teams with people sharing their time across multiple teams. Hence the same team member (e.g., an architect) can be a part of multiple microservices teams. Choreo allows managing teams with the organization feature where users can be invited to the organization and these users can be of different roles such as developer or administrator. The same person can become part of different teams (organizations) and work closely with those team members to deliver the individual microservices.

These capabilities along with the other features, such as API lifecycle management and DevOps process management, means Choreo can accelerate your journey towards a microservices architecture.

Advantages of Choreo

In addition to the advantages related to microservices architecture mentioned in the preceding paragraphs, Choreo comes with capabilities comparable to those of other platforms available in the market. These include the following.

  • A serverless platform to build microservices without worrying about the underlying infrastructure
  • A low-code approach with a sequence diagram-based programming model to develop microservices rapidly
  • Strong API management capabilities built-in to the platform to secure and govern microservices delivery
  • Automated deployment of microservices with built-in CICD pipelines that deploy services to a kubernetes runtime
  • AI-driven assistance with automated performance analysis and data mapping for developing microservices with optimized performance
  • Advanced observability features enabled automatically to troubleshoot production incidents directly from the platform
  • An API marketplace to share microservices and APIs across teams, BUs, and organizations and expand to an API economy

Closing thoughts

Choreo is a platform created from the ground up to help organizations to innovate. Microservices architecture is a great, modern approach to bring innovation to the enterprises. In this article, we discussed how Choreo can help organizations to accelerate their microservices adoption and become a fully agile, innovative enterprise with minimal effort and time spent on building the infrastructure. We went through the challenges of the microservices architecture and identified specific Choreo features that would help us to tackle those challenges and come up with an effective microservices architecture.

Click here to find out more on how Choreo gives organizations a single, all-inclusive platform for creating integrations, services and APIs; managing APIs; and deploying services and APIs—going from ideas to production in hours.

Sign in to get started

An intelligent iPaaS that does not make you choose between code and low-code

Create your first Choreo App

This website uses cookies so that we can provide you with the best user experience. Read our Cookie Policy to find out more.

If you wish to disable cookies you can do so from your browser.

I Understand