<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Balachandar Palaniappan on Medium]]></title>
        <description><![CDATA[Stories by Balachandar Palaniappan on Medium]]></description>
        <link>https://medium.com/@balachandar.gct?source=rss-9f3437e746d6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*PvduJWPrDp1hSMcP</url>
            <title>Stories by Balachandar Palaniappan on Medium</title>
            <link>https://medium.com/@balachandar.gct?source=rss-9f3437e746d6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 03:19:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@balachandar.gct/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Multi Repo, Mono Repo, Multi-Module Repo and Multi-Module Mono Repo architectures]]></title>
            <link>https://medium.com/@balachandar.gct/multi-repo-mono-repo-multi-module-repo-and-multi-module-mono-repo-architectures-a5a81613d522?source=rss-9f3437e746d6------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5a81613d522</guid>
            <dc:creator><![CDATA[Balachandar Palaniappan]]></dc:creator>
            <pubDate>Fri, 28 Jun 2024 09:22:04 GMT</pubDate>
            <atom:updated>2024-06-28T09:22:04.692Z</atom:updated>
            <content:encoded><![CDATA[<p>“Modern software development relies heavily on the structure and organization of code repositories to ensure project efficiency, scalability, and maintainability. In this article, I would like to share my experiences with four main types of approaches: Multi Repo, Mono Repo, Multi-Module Repo, and Multi-Module Mono Repo. Each of these strategies has its advantages and challenges. Understanding these structures and their relevant use cases can help development teams select the most suitable strategy for their projects, leading to improved collaboration, streamlined workflows, and optimized resource management.”</p><p>The examples I have used in this are Java.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/577/1*1iqJRiwLQJzRUzghn48Uyg.jpeg" /></figure><h3>Multi Repo</h3><p>Multi Repo(multiple repositories) is an approach where each project, service, or component is stored in its dedicated repository. This structure is often favoured for its:</p><blockquote><strong><em>Isolation:</em></strong><em> Each repository is isolated, making it easier to manage, especially for large teams working on distinct projects.</em></blockquote><blockquote><strong><em>Independent CI/CD:</em></strong><em> Each project can have its own CI/CD pipeline, tailored to its specific needs, without affecting other projects.</em></blockquote><blockquote><strong><em>Focused Access Control:</em></strong><em> Permissions can be managed at a granular level, giving access only to the repositories relevant to each team member.</em></blockquote><p>However, multi repos also have their drawbacks:</p><blockquote><strong><em>Integration Complexity:</em></strong><em> Integrating changes across multiple repositories can be more challenging, requiring additional tools and processes.</em></blockquote><blockquote><strong><em>Code Duplication:</em></strong><em> Without careful management, code duplication can occur as shared libraries and components are replicated across repositories.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/1*JtH4h1Y4HTIg9nq7r_GVJQ.jpeg" /><figcaption>Multi Repo</figcaption></figure><h3>Mono Repo</h3><p>Mono Repo (monolithic repository) is an approach where all code for multiple projects or services is stored in a single, unified repository. This structure is popular among large tech companies, including Google, Facebook, and Microsoft, due to several key benefits:</p><blockquote><strong>Unified Code Base:</strong> All code is stored in one place, making it easier to share libraries, tools, and components across different projects.</blockquote><blockquote><strong>Consistent Standards:</strong> Enforcing coding standards, version control practices, and dependency management is more straightforward in a mono repo.</blockquote><blockquote><strong>Simplified CI/CD:</strong> Continuous Integration and Continuous Deployment (CI/CD) processes can be more streamlined since all code changes are tracked in a single repository.</blockquote><p>However, mono repos can also present challenges, such as:</p><blockquote><strong>Scalability Issues:</strong> As the repository grows, it may become harder to manage, with longer build times and more complex dependency graphs.</blockquote><blockquote><strong>Access Control:</strong> Managing permissions can be more complex since contributors need access to the entire repository, even if they work on only a small part of it.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/270/1*YPOkIKThkU0zhR9GhkuCnA.jpeg" /><figcaption>Mono Repo</figcaption></figure><h3>Explanation:</h3><blockquote><strong>ProjectA, ProjectB</strong>: Separate projects within the mono repo. Each project has its source (src) and test (test) directories and its pom.xml file if using Maven for build management.</blockquote><blockquote><strong>SharedLibrary</strong>: A shared library used by both ProjectA and ProjectB. It has its own source and test directories and pom.xml.</blockquote><blockquote><strong>Root </strong><strong>pom.xml</strong>: The root-level pom.xml that manages dependencies and builds for the entire mono repo.</blockquote><blockquote><strong>README.md</strong>: A root-level readme file that typically provides an overview of the mono repo.</blockquote><p>This structure ensures that all projects share the same repository, which simplifies dependency management and version control but requires robust build and CI/CD systems to handle the complexity of multiple projects in one repository.</p><h3>Multi-Module Repo</h3><p>Multi-Module Repo refers to a repository structure where a single repository contains multiple modules or sub-projects, each representing a distinct functionality or service. This approach strikes a balance between the monolithic nature of mono repos and the distributed nature of multi repos:</p><blockquote><strong>Modular Organization:</strong> Each module can be developed, tested, and deployed independently, yet they all exist within a single repository.</blockquote><blockquote><strong>Encapsulation:</strong> Modules can encapsulate specific functionality, reducing the risk of unintended code interactions.</blockquote><blockquote><strong>Reusability:</strong> Shared modules can be reused across different parts of the project, promoting code reuse and reducing duplication.</blockquote><p>Despite its advantages, the multi-module repo structure can face issues such as:</p><blockquote><strong>Complex Dependency Management:</strong> Managing dependencies between modules can become complex, especially as the number of modules increases.</blockquote><blockquote><strong>Build Coordination:</strong> Ensuring that all modules are built and tested in a coordinated manner can require sophisticated build tools and processes.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/1*DbBmVb4N1NOYtZZwpqDkOA.jpeg" /><figcaption>Multi Module Repo</figcaption></figure><h3>Explanation:</h3><blockquote><strong>Project A &amp; Project B</strong>: The root directory of the multi-module repository.</blockquote><blockquote><strong>module1, module2</strong>: Sub-modules within the parent project. Each module has its source (src) and test (test) directories and its pom.xml file for build management.</blockquote><blockquote><strong>shared</strong>: A shared library module that contains utilities or common code used by other modules. It also has its own source and test directories and pom.xml.</blockquote><blockquote><strong>pom.xml</strong>: The root-level pom.xml that manages dependencies and builds for the entire parent project and its sub-modules.</blockquote><blockquote><strong>README.md</strong>: A root-level readme file that typically provides an overview of the multi-module repository.</blockquote><p>This structure allows for modular development, where different functionalities are split into separate modules. Each module can be developed, built, and tested independently, while the parent pom.xml coordinates the dependencies and overall build process.</p><h3>Multi-Module Mono Repo</h3><p>A Multi-Module Mono Repo is a single repository that contains multiple projects, each with multiple modules. This structure helps manage complex projects efficiently, allowing shared code and dependencies to be maintained centrally while still supporting independent development and deployment of different modules.</p><blockquote><strong>Centralized Management</strong>: All code is in one place, making it easier to manage dependencies and perform code reviews.</blockquote><blockquote><strong>Shared Code</strong>: Common code can be placed in shared modules, promoting reuse and reducing duplication.</blockquote><blockquote><strong>Consistent Builds</strong>: Having a single build process for the entire repository ensures consistency.</blockquote><blockquote><strong>Simplified Dependency Management</strong>: Dependencies between modules and projects are easier to manage and version.</blockquote><p>However, multi-module mono repo can also present challenges, such as:</p><blockquote><strong>Increased Complexity:</strong> Managing a large number of modules within a single repository can become complex. Developers need to understand the relationships and dependencies between modules.</blockquote><blockquote><strong>Longer Build Times:</strong> As the repository grows, the build times can increase significantly. Even with incremental builds, large projects can take a considerable amount of time to compile and test.</blockquote><blockquote><strong>Merge Conflicts:</strong> With many developers working in the same repository, the likelihood of merge conflicts increases. This can slow down development and complicate the merging process.</blockquote><blockquote><strong>Dependency Management:</strong> Keeping track of dependencies and ensuring compatibility between different modules can be challenging. Changes in one module may have unintended effects on other modules.</blockquote><blockquote><strong>Scalability Issues: </strong>As the number of modules and the size of the repository grow, tools and processes that work well for smaller repositories may not scale effectively. This includes version control systems, CI/CD pipelines, and development tools.</blockquote><blockquote><strong>Repository Size:</strong> Over time, the repository size can become very large, making cloning and fetching operations slow. This can also consume significant disk space.</blockquote><blockquote><strong>Reduced Autonomy: </strong>Teams may have less autonomy since changes to shared modules or configurations can affect other teams. Coordination and communication become more critical.</blockquote><blockquote><strong>Tooling Limitations: </strong>Some development tools and IDEs may struggle with very large projects, causing performance issues or limiting functionality.</blockquote><blockquote><strong>Complex Testing: </strong>Writing and maintaining tests that span multiple modules can be difficult. Ensuring comprehensive test coverage and handling cross-module dependencies in tests can be challenging.</blockquote><blockquote><strong>Permission Management:</strong> Managing permissions and access control becomes more complicated. It’s harder to restrict access to specific parts of the codebase within a single repository.</blockquote><blockquote><strong>Onboarding New Developers:</strong> New developers may find it overwhelming to get up to speed with a large, multi-module repository. The learning curve can be steep due to the complexity and volume of the codebase.</blockquote><blockquote><strong>Branch Management:</strong> Managing feature branches, hotfixes, and releases can become complicated with many modules. Coordinating branch strategies across teams requires careful planning.</blockquote><blockquote><strong>Monolithic Deployment: </strong>Although the repository is modular, there’s a risk of deploying changes monolithically. This can lead to larger, more complex deployments, increasing the risk of deployment failures.</blockquote><blockquote><strong>Version Control Challenges: </strong>Handling the versioning of individual modules within a mono repo can be tricky. Deciding when to increment versions and how to manage dependencies between modules requires a well-thought-out strategy.</blockquote><p>While the drawbacks are significant, many can be mitigated with careful planning and the right tools:</p><blockquote><strong>Modular Builds: </strong>Use build tools that support incremental builds and can handle large projects efficiently.</blockquote><blockquote><strong>Continuous Integration: </strong>Implement a robust CI/CD pipeline to automate testing and deployments, ensuring that changes are tested in isolation and as part of the whole system.</blockquote><blockquote><strong>Code Ownership:</strong> Define clear ownership for different modules to ensure accountability and streamline decision-making.</blockquote><blockquote><strong>Communication:</strong> Foster good communication practices among teams to coordinate changes and manage dependencies effectively.</blockquote><blockquote><strong>Documentation: </strong>Maintain comprehensive documentation to help new developers get up to speed and provide clarity on module dependencies and relationships.</blockquote><blockquote><strong>Tooling: </strong>Invest in tools and infrastructure that can handle large repositories, such as advanced version control systems, powerful build servers, and efficient CI/CD pipelines.</blockquote><blockquote><strong>Branching Strategy: </strong>Develop a branching strategy that works for your team, such as GitFlow or trunk-based development, to manage changes and releases effectively.</blockquote><blockquote><strong>Incremental Refactoring: </strong>Regularly refactor the codebase to keep it manageable and reduce technical debt.</blockquote><p>By addressing these challenges proactively, you can leverage the benefits of a Multi-Module Mono Repo while minimizing the potential downsides.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/1*FiGqewY8-cIvRiPnIxJKLA.jpeg" /></figure><h3>Explanation:</h3><p><strong>ProjectA</strong>: A multi-module project with its own pom.xml.</p><blockquote><strong>module1</strong>: A module within ProjectA with its source code, resources, and tests.</blockquote><blockquote><strong>module2</strong>: Another module within ProjectA.</blockquote><blockquote><strong>shared</strong>: A shared library used by modules in ProjectA.</blockquote><p><strong>ProjectB</strong>: Another multi-module project with its pom.xml.</p><blockquote><strong>module1</strong>: A module within ProjectB with its source code, resources, and tests.</blockquote><blockquote><strong>module2</strong>: Another module within ProjectB.</blockquote><blockquote><strong>shared</strong>: A shared library used by modules in ProjectB.</blockquote><p><strong>README.md</strong>: A root-level readme file that provides an overview of the repository and its structure.</p><p>In a real-world application, the pom.xml files would be configured to manage dependencies, build processes, and inter-module relationships. This structure allows for efficient development and maintenance of multiple related projects within a single repository, promoting code reuse and streamlined builds.</p><h3><strong>Conclusion</strong></h3><p>Choosing the right repository structure is critical for the success of software projects. Each approach —Multi Repo, Mono Repo, Multi-Module Repo and Multi-Module Mono Repo — offers unique benefits and challenges. By understanding these structures, development teams can make informed decisions that enhance collaboration, streamline workflows, and ultimately deliver higher-quality software.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5a81613d522" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How To Setup DynamoDB Locally(Behind Corporate Proxy)]]></title>
            <link>https://medium.com/@balachandar.gct/how-to-setup-dynamodb-locally-behind-corporate-proxy-80e787d00f1d?source=rss-9f3437e746d6------2</link>
            <guid isPermaLink="false">https://medium.com/p/80e787d00f1d</guid>
            <dc:creator><![CDATA[Balachandar Palaniappan]]></dc:creator>
            <pubDate>Mon, 24 Apr 2023 13:31:20 GMT</pubDate>
            <atom:updated>2023-04-25T04:18:48.948Z</atom:updated>
            <content:encoded><![CDATA[<p>DynamoDB is a NoSQL database service provided by Amazon Web Services. DynamoDB is known for its scalability and latencies.</p><p>As per AWS, DynamoDB cuts costs and makes it easy to store and retrieve any amount of data. Furthermore, it can also serve any level of request traffic. The data is stored on solid-state drives which offer high I/O performance along with efficiently handling high-scale requests.</p><p>DynamoDB uses a NoSQL database model which is nonrelational. Apart from that, it also allows graphs, documents, and columnar among its data model.</p><p>A user first stores the data in DynamoDB tables and then interact with it through PUT and GET queries which are written and read operations respectively.</p><p>DynamoDB supports conditional operations and basic CRUD operations. Every DynamoDB query is executed with the help of a primary key which is identified by the user. Each key uniquely identifies each item.</p><p>Users don’t make DynamoDB API calls directly. Rather, they integrate an AWS SDK into the application which handles the backend communications with the server.</p><p>As DynamoDB has emerged as one of the most popular databases among developers. We have planned to use DynamoDB for one of my project’s data storage.</p><p>For quick development and validation of my implementation, we have planned to set up DynamoDB locally(in a development environment which is behind a corporate proxy) to do integration testing and development.</p><p>We referred to the AWS documents to set up the DynamoDB locally (<a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.DownloadingAndRunning.html">https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.DownloadingAndRunning.html</a>) and carefully followed all the steps. But when we started it, it was showing the below error</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CToS55DePtfZcfVznk22Mg.png" /><figcaption>Error Accessing the DynamoDB</figcaption></figure><p>We have tried to find answers to fix the issue but couldn’t. All the reference documents to which we referred have the same content as the AWS official document. We tried setting up the proxy and running it before executing the above command, which was not working out. Later we figured out how to skip the proxy and run this locally. I wanted to share a solution that we have tried that would help someone trying to set it up locally.</p><p><strong>Step 1:</strong> <em>Execute the below commands as mentioned in the AWS official document.</em></p><pre>java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -sharedDb</pre><p><strong>Step 2: </strong><em>Run the below command in order to skip the proxy validation locally.</em></p><pre>set NO_PROXY= localhost</pre><p><strong>Step 3: </strong><em>Run the below command in order to validate that the setup is done locally and working.</em></p><pre>aws dynamodb list-tables - endpoint-url http://localhost:8000</pre><p><strong>Step 4: </strong><em>Create the below sample table and execute Step 3 again which will return the table details.</em></p><pre>aws dynamodb create-table - table-name Music - attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S - key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE - provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 - table-class STANDARD - endpoint-url http://localhost:8000</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*_pLMY9z_N3b-utBVSfO5HA.png" /><figcaption>After Applying the No Proxy setting.</figcaption></figure><p>Also for the Code implementation use the local dynamodb URL and use dummy credentials <strong><em>AWS Access Key ID: “fakeMyKeyId” , and AWS Secret Access Key: “fakeSecretAccessKey” </em></strong>which will work.</p><pre>amazon.dynamodb.endpoint: http://localhost:8000/<br>amazon.aws.accesskey: fakeMyKeyId<br>amazon.aws.secretkey: fakeSecretAccessKey</pre><pre>#Spring Boot Example<br>@Configuration<br>@EnableDynamoDBRepositories<br>  (basePackages = &quot;com.example.spring.data.dynamodb.repositories&quot;)<br>public class DynamoDBConfig {<br><br>    @Value(&quot;${amazon.dynamodb.endpoint}&quot;)<br>    private String amazonDynamoDBEndpoint;<br><br>    @Value(&quot;${amazon.aws.accesskey}&quot;)<br>    private String amazonAWSAccessKey;<br><br>    @Value(&quot;${amazon.aws.secretkey}&quot;)<br>    private String amazonAWSSecretKey;<br><br>    @Bean<br>    public AmazonDynamoDB amazonDynamoDB() {<br>        AmazonDynamoDB amazonDynamoDB <br>          = new AmazonDynamoDBClient(amazonAWSCredentials());<br>        <br>        if (!StringUtils.isEmpty(amazonDynamoDBEndpoint)) {<br>            amazonDynamoDB.setEndpoint(amazonDynamoDBEndpoint);<br>        }<br>        <br>        return amazonDynamoDB;<br>    }<br><br>    @Bean<br>    public AWSCredentials amazonAWSCredentials() {<br>        return new BasicAWSCredentials(<br>          amazonAWSAccessKey, amazonAWSSecretKey);<br>    }<br>}</pre><p>I’ve personally found to test locally is really useful, before committing to pushing API changes.</p><p>If you enjoyed please leave a comment, I’m interested to hear how you are using dynamodb-local.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80e787d00f1d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes Setup With Docker Desktop In Windows-Behind Corporate Proxy]]></title>
            <link>https://medium.com/@balachandar.gct/kubernetes-setup-with-docker-desktop-in-windows-10-behind-corporate-proxy-d551afe2c861?source=rss-9f3437e746d6------2</link>
            <guid isPermaLink="false">https://medium.com/p/d551afe2c861</guid>
            <dc:creator><![CDATA[Balachandar Palaniappan]]></dc:creator>
            <pubDate>Thu, 12 Jan 2023 07:12:45 GMT</pubDate>
            <atom:updated>2023-05-17T08:58:09.453Z</atom:updated>
            <content:encoded><![CDATA[<p>My recent project is on microservices architecture. We are using Kubernetes services for the application deployment. One of the challenges I have faced is testing my service with the local Kubernetes cluster, I wanted to set it up in my local (Windows 10) corporate machine and test it.</p><p>I have tried to set up a minikube cluster, but I was always facing an issue running kubectl commands, which was always thrown an error “<strong>Unable to connect to the server: Proxy Authentication Required”</strong>. Even after setting up the corporate proxy as mentioned in the following link <a href="https://minikube.sigs.k8s.io/docs/handbook/vpn_and_proxy/">Proxies and VPNs | minikube (k8s.io)</a>. I couldn’t find any consolidated documents with details which could help me to set that up. I was not able to set up the local Kubernetes cluster. So gave that up and tested that in QA setup all the time, until I recently set up the docker desktop version 4.15.0 in my local corporate machine. Where I could successfully set up the single-node Kubernetes cluster.</p><p>I would like to share the steps and how I have solved that in my corporate machine.</p><p><strong>Step 1:</strong> Download the docker desktop and install it in your windows system. Details can be found in the below link<strong> </strong><a href="https://docs.docker.com/desktop/install/windows-install/"><strong>https://docs.docker.com/desktop/install/windows-install/</strong></a></p><p><strong>Step 2:</strong> Setup proxy details as mentioned below. Replace HTTP &amp; HTTPS proxy details with your corporate <em>P</em><strong><em>roxy IP &amp; Port </em></strong>details. Once it is set up restart the docker desktop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JtvzD5qcxkBJTUHhx7tIoQ.png" /><figcaption>Enable Manual Proxy</figcaption></figure><p><strong>Step 3: </strong>Go to the below path User folder and delete<strong> </strong>the<strong> .kube </strong>folder and enable the below flag in the docker desktop and click on the <strong>Apply &amp; Restart </strong>button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VjZLhBe30NO9pFjVlEwzpQ.png" /><figcaption>Enable Kubernetes Service</figcaption></figure><p><strong>Step 4: </strong>Verify after the restart Kubernetes is running and showing it as below. If not repeat Step 3 along with clicking the Reset Kubernetes Cluster option.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IIQ3aREq2zS8hxulr8iLcQ.png" /><figcaption>Kubernetes running</figcaption></figure><p><strong>Step 5:</strong> Open the power shell terminal and run the below script.Replace the values accordingly based on your proxy details</p><p><strong>$proxy=’http://&lt;UserName&gt;:&lt;Password&gt;</strong><a href="http://twitter.com/proxy"><strong>@proxy</strong></a><strong>.com:8080&#39;<br>$ENV:HTTP_PROXY=$proxy<br>$ENV:HTTPS_PROXY=$proxy<br>$ENV:NO_PROXY=”localhost,127.0.0.1,192.168.49.2,*.docker.internal”</strong></p><p><strong>Step 6: </strong>Run and test any kubectl command in the power shell. It should work. <strong>Note: </strong>whenever you open a new terminal rerun step 5 always. This will set up the proxy details otherwise you will get the below error <strong>Unable to connect to the server: Proxy Authentication Required.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nAZf7zrJeAPzSQGDWQDrLA.png" /><figcaption>Kubectl command status</figcaption></figure><p>I hope the above-consolidated details I have used to successfully set up the Kubernetes Cluster in my local machine would help the next person trying to set up and make working with these tools a little easier. The thoughts in this article are mine, I am simply motivated to give back to the tech community. Thank you for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d551afe2c861" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Architecture Patterns]]></title>
            <link>https://medium.com/@balachandar.gct/software-architecture-patterns-facfec3978ad?source=rss-9f3437e746d6------2</link>
            <guid isPermaLink="false">https://medium.com/p/facfec3978ad</guid>
            <dc:creator><![CDATA[Balachandar Palaniappan]]></dc:creator>
            <pubDate>Wed, 10 Aug 2022 11:32:37 GMT</pubDate>
            <atom:updated>2022-08-10T11:32:37.411Z</atom:updated>
            <content:encoded><![CDATA[<p>How as an architect one would decide to choose the architecture pattern to solve or determine the architectural characteristics of an application. Also as an architect one must justify the architecture decisions, Particularly to choosing the architecture pattern or an approach to use certain architecture pattern. Knowing the characteristics, strengths, and weaknesses of each architecture pattern is necessary in order to choose the one that meets your specific business needs and goals.</p><p>Type of software architecture patterns</p><p><strong>N-Tier architecture pattern:(Monolithic architecture)</strong></p><p>Layered architecture pattern are organized into horizontal layers, each layer performing a specific role within the application (e.g., presentation logic or business logic). Although the layered architecture pattern does not specify the number and types of layers that must exist in the pattern, most layered architectures consist of four standard layers: presentation, business, persistence, and database.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*kULlMbhIB9Wpn7SewevKEw.jpeg" /></figure><p><strong>Event-Driven architecture pattern: (Message based architecture)</strong></p><p>The event-driven architecture pattern is a popular distributed asynchronous architecture pattern used to produce highly scalable applications. It is also highly adaptable and can be used for small applications and as well as large, complex ones. The event-driven architecture is made up of highly decoupled, single-purpose event processing components that asynchronously receive and process events.</p><p>The event-driven architecture pattern consists of two types topologies, the mediator and the broker. The mediator is commonly used when you need to orchestrate multiple steps within an event through a central mediator, whereas the broker is used when you want to chain events together without the use of a central mediator. Because the architecture characteristics and implementation strategies differ between these two topologies, it is important to understand each one to know which is best suited for your particular situation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*J2rEuLMUrlQlZgBWxigxnA.jpeg" /></figure><p><strong>Microservices Architecture Pattern :(Micro Services or Mini Services)</strong></p><p>The most important concept of micro service architecture pattern is the notion of a service component. Rather than think about services within a microservices architecture, it is better to think about service components, which can vary in granularity from a single module to a large portion of the application. Service components contain one or more modules that represent either a single-purpose function or a portion of a large business application.</p><p>Microservices architecture is evolved from two main sources: monolithic applications developed using the layered architecture pattern and distributed applications developed through the service-oriented architecture pattern. Also it is a distributed architecture, meaning that all the components within the architecture are fully decoupled from one other and accessed through some sort of remote access protocol (e.g., JMS, AMQP, REST, SOAP, RMI, etc.). The distributed nature of this architecture pattern is how it achieves some of its superior scalability and deployment characteristics.</p><p>Most common ways to implement micro service architecture pattern are below 1. API REST-based , 2. Application REST-based , 3. Centralized messaging.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/1*E-TYv_kv1I71XviMkjUyyg.jpeg" /></figure><p><strong>Microkernel Architecture Patterns:</strong></p><p>The microkernel architecture pattern consists of two types of architecture components: a core system and plug-in modules. Application logic is divided between independent plug-in modules and the basic core system, providing extensibility, flexibility, and isolation of application features and custom processing logic.</p><p>The core system of the microkernel architecture pattern traditionally contains only the minimal functionality required to make the system operational. The core system is defined as the general business logic , custom code for special cases, special rules, or complex conditional processing. The plug-in modules are stand-alone, independent components that contain specialized processing, additional features, and custom code that is meant to enhance or extend the core system to produce additional business capabilities.</p><p>One of the important concept in this patterns is the core system should know about which plug-in modules are available and how to get to them. example plugin registry way where this registry contains information about each plug-in module, including things like its name, data contract, and remote access protocol details (depending on how the plug-in is connected to the core system).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/462/1*3nfvE-d_I07QtbdZ15qTQw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=facfec3978ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Async API Documentation]]></title>
            <link>https://medium.com/@balachandar.gct/async-api-documentation-7846a9541f36?source=rss-9f3437e746d6------2</link>
            <guid isPermaLink="false">https://medium.com/p/7846a9541f36</guid>
            <dc:creator><![CDATA[Balachandar Palaniappan]]></dc:creator>
            <pubDate>Mon, 01 Aug 2022 06:37:50 GMT</pubDate>
            <atom:updated>2022-08-01T06:37:50.707Z</atom:updated>
            <content:encoded><![CDATA[<p>When I have started working on building the Event-Driven Architectures (EDA) for my solutions, I was very excited and very curious to build the system using message brokers and defining the async api’s . Things were very fine until the time we had integrated small number of micro services likes 5 to 10. But we started integrating more number application where we wanted to communicate the microservices with async way using using message broker it got into complication. Because we always have to make sure that the event definition’s and the details has to be aggreged upon between the microservices and there is no common place where we can see what the Async Api definition are like how we do provide the details of synchronous API’s using OpenAPI (<a href="https://www.openapis.org/">https://www.openapis.org)</a> Specification.</p><p>On the search to solve the above issue where we came to know that <a href="https://www.asyncapi.com/">AsyncAPI Initiative for event-driven APIs</a>. We have started using the definition ‘s now we are able to build the <a href="https://www.asyncapi.com/">AsyncAPI</a> definitions with out worrying that how can the details be easily share to other team.</p><p>An AsyncAPI document is a file that defines and annotates the different components of a specific Event-Driven API. The format of the file must be JSON or YAML; however, only the subset of YAML that matches the JSON capabilities is allowed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/193/1*m0NBjWrq8JOpQ0ULtuyq6g.jpeg" /></figure><p>Sample details &amp; tool detail can be found on the below link <a href="https://studio.asyncapi.com/#introduction">AsyncAPI Studio</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mom8lrHH1YzMelzjOdGsRw.jpeg" /><figcaption>Example for microservice async api documentation</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7846a9541f36" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>