DEV Community: ALLWIN

Embarking on Sitecore Headless: Our First Project

ALLWIN — Sun, 09 Jul 2023 08:54:26 +0000

We recently undertook our first headless project using Sitecore Headless 10.2 and Next.js SDK with SSR. This shift in our tech stack brought significant changes to our development processes.

Previously, Sitecore MVC development relied heavily on C#, .NET, and the Sitecore SDK and APIs. Now, with Sitecore Headless Services, most of the implementation has moved to the consumer, namely our Next.js application. The front-end had to display data from various sources, including layout and components from Sitecore, as well as marketing and business data from other API sources.

To overcome dependencies and unblock front-end development, we adopted an approach that emphasized front-end independence. Leveraging Sitecore JSS SDK's "disconnected" mode, frontend developers worked with YAML mock files representing page data. OpenAPI documentation allowed us to easily mock 3rd party APIs using Next.js, enabling us to switch between mocked and live data. API contracts were crucial in resolving development dependencies and synchronizing workflows between teams, facilitating the testing of full user stories.

While transitioning to the new tech stack, we faced technical challenges as Sitecore developers. Understanding Sitecore Headless Services and Next.js SDK was crucial. Sitecore's robust client library support for Headless made it easier to grasp and utilize. Frontend developers needed to learn about essential Sitecore concepts such as page structure, layouts, placeholders, renderings, and various field types. This foundational knowledge allowed them to create page mock-ups that could be reviewed and adjusted by the Sitecore team. Additionally, selecting the right rendering method and hosting solution on the frontend presented further challenges.

Ultimately, embracing a headless approach and leveraging JavaScript on the client side streamlined our development process, with clearer roles for different teams and faster iteration compared to deploying .NET assemblies for each change.

Read the full article HERE!

Achieving Zero-Downtime Deployment with Azure Kubernetes Service: A Step-by-Step Guide

ALLWIN — Fri, 23 Jun 2023 14:38:57 +0000

This blog post provides a solution for achieving zero-downtime deployment in Azure Kubernetes Service (AKS). We'll explore different deployment strategies and choose the one that best fits our requirements. We'll then outline the necessary Kubernetes objects in AKS and present an Azure DevOps deployment pipeline for achieving zero-downtime deployment.

There are several deployment strategies available for deploying applications to production or other environments. Each strategy has its own use cases, benefits, and drawbacks.

Let's explore some of these strategies:

Recreate: This strategy involves removing instances with the old version and rolling out instances with the new version. It is commonly used during development and downtime does not matter. Kubernetes services natively support this strategy.
Ramped: The ramped strategy replaces instances of the old version with the new version one by one. This strategy ensures zero downtime, but it can be time-consuming and may not have full control over traffic. Kubernetes services support this strategy.
Blue/Green: In the blue/green strategy, new version instances are deployed while traffic is routed to the old instances. Once the new version is verified, the traffic is switched to the new instances, and the old instances are removed. This strategy offers zero downtime, fast rollout/rollback, and control over traffic, but it requires additional resources. It is not supported by Kubernetes services out of the box.
Canary: The canary strategy involves routing weighted traffic to the new instances gradually until all traffic is directed to the new version. This allows for fast rollback, measurable performance, and more control over traffic. However, it has a slow rollout and can be expensive. It is not supported by Kubernetes services out of the box but can be implemented using an ingress controller like NGINX.
A/B testing: Similar to the canary strategy, A/B testing allows for routing a subset of users to the new instances using canary cookies or headers. This strategy provides complete control over traffic but has a slow rollout and requires a Layer-7 load balancer like NGINX. It is not supported by Kubernetes services out of the box.
Shadow: The shadow strategy involves deploying new instances alongside the old instances and mirroring traffic to both versions. This allows for quick performance tests without impacting users but requires doubling the required resources.

For more information on these deployment strategies, check out this link: https://thenewstack.io/deployment-strategies/.

Choosing the Right Deployment Strategy

To achieve our requirements of fast rollout and rollback, the ability to check the new version while users are still routed to the old version, zero-downtime switch, and suitability for a production environment, we combined the Blue/Green and A/B testing strategies.

We’ll follow this with an overview of the components involved in achieving zero-downtime deployment using Kubernetes services. Let’s briefly discuss deployment objects, service objects, ingress objects, and the Ingress controller.

Deployment Objects: To implement the Blue/Green strategy, we utilized Kubernetes Deployment objects, which represent slots for blue and green versions of the component. Each deployment object is responsible for managing pods that contain a specific version of the component. Helm charts are used to define the deployment objects in code.

Service Objects: For A/B testing, we needed to operate two different versions of a component simultaneously. To accomplish this, we employed Kubernetes Service objects. These service objects exposed a set of pods as a network service. We had a service pointing to pods running a current version and a canary service pointing to pods running the next version of the component.

Ingress Objects: To route traffic from outside the cluster to the services within, we utilized Kubernetes Ingress objects. Ingress objects define HTTP and HTTPS routes and control the traffic routing based on defined rules. We created separate Ingress objects for both the service and canary service.

Ingress Controller: An Ingress controller is essential for handling Ingress objects. In our solution, we used the NGINX Ingress Controller, which allowed us to route traffic to the appropriate services based on the defined rules.

Deployment Pipeline with Azure DevOps: To automate the rollout of our component to Azure Kubernetes Service (AKS), we set up a deployment pipeline using Azure DevOps.

The pipeline consisted of several jobs:

Deploy Job: This job pulls the necessary helm charts from Azure Container Registry (ACR) and deploys the component to the desired slot using helm. It also updates the ingress release to have the canary service selectors pointing to the proper set of pods.
User Check Job: This job pauses the deployment process and allows the user to check if the new component version works properly. The user can decide to proceed or initiate a rollback.
Clean Up Deployment Job: In case of a failed deployment, this job removes the new version of the component and its slot.
Swap Deployment Slots and Cleanup Job: This job completes the deployment process by swapping the service and canary service to the new version of pods and removing the previous version's deployment.

The deployment process was visualized through a diagram, showcasing the various steps involved in achieving zero-downtime deployment.

Conclusion

Zero-downtime deployment is achievable in the Azure cloud using Kubernetes services. By understanding your requirements and employing different deployment strategies, you can ensure uninterrupted application availability.

All the presented source codes are available for download from the following link.

Read the whole article HERE!

My Journey of Contributing to the ASP.NET Core Repository

ALLWIN — Mon, 19 Jun 2023 09:54:35 +0000

Márton, our genius software architect, shared his story of contributing to the ASP.NET Core repository. In this blog post, he recounted the challenges faced while working on a project involving an API and two React applications. Debugging efforts led him to discover issues with hosting the applications in a subdirectory, prompting him to explore the code and identify a solution.

During development, Márton noticed that the admin application failed to load properly due to a problem with the proxy code. After thorough debugging, he realized that the Map middleware in ASP.NET Core did not include the prefix provided in the first parameter. Additionally, the concatenation of URI segments differed from the expected behavior with strings. He found an existing GitHub issue but decided to propose his own solution to address the problem.

Márton’s initial attempt at submitting a code change incited integration test failures, which were unrelated to his modifications. After resolving the test issues by merging the latest main branch, he received approval and awaited inclusion in the main branch release with .NET 7.0. Surprisingly, another issue emerged, mirroring the previous problem with the same line of code. Driven by determination, Márton embarked on resolving both issues simultaneously.

During the process, Márton collaborated with code owners who provided feedback and requested assistance with manual testing. To facilitate testing and future maintenance, he took the initiative to write unit tests for the code. Despite the complexity of testing an extension method for the HttpContext class, Márton succeeded in verifying the correctness of the URL using an HTTP client with a mocked HTTP message handler.

With his tests passing and necessary adjustments made, Márton’s code was eventually merged into the main branch. His conclusion and takeaway emphasize the importance of a cautious mindset when contributing to open-source projects, especially those as complex as ASP.NET Core. The significance of semantic versioning, automated tests, and meticulous code reviews is highlighted in his blog post as essential elements for maintaining robust libraries.
Read the full story HERE!

Introducing Sitecore's New Product Portfolio: Unlocking the Power of Experience

ALLWIN — Thu, 08 Jun 2023 13:04:22 +0000

Curious about Sitecore's latest offerings? From Content Hub One to Sitecore Search, OrderCloud, and XM Cloud, these products have been making waves in recent years. Let's explore each one from both a client and implementation perspective, gaining a deeper understanding of their purpose and where they fit within Sitecore's services.

In the past, Sitecore had on-premises products like Sitecore XM and Sitecore XP, but now, they have evolved into a Managed Cloud service. In short, this DevOps and hosting solution simplifies infrastructure setup, release pipelines, and environments, allowing developers to focus on delivering solutions using ASP .NET MVC or the headless approach with Sitecore Headless Services.

Sitecore's Software as a Service (SaaS) products offer cloud-based, API-first solutions that are developed and maintained by Sitecore. The Content Cloud category includes products like XM Cloud, a robust CMS for enterprise needs, and Content Hub One, a lightweight solution for effective content management. Content Hub DAM serves as a dedicated Digital Asset Management platform, while Sitecore Search enhances website search capabilities with AI and personalization.

In the Engagement Cloud category, Sitecore CDP collects and utilizes data to optimize customer journeys, while Sitecore Personalize enables personalized experiences based on that data. Sitecore Send offers a SaaS Email Marketing Service, and Sitecore Connect facilitates low-code integration between multiple systems.

For e-commerce excellence, Commerce Cloud presents Sitecore OrderCloud, an API-first e-commerce engine, and Sitecore Discover, an AI-based search engine optimized for e-commerce solutions.

Sitecore's SaaS products are flexible and compatible with non-Sitecore solutions, providing integration possibilities through their API-first approach.

Choose the platform that best suits your needs and consider reaching out to us for portal implementation partnership. Unleash the power of experience with Sitecore's innovative product portfolio and take your digital experiences to new heights!

Unleashing the Power of Nearshoring: Two Recent Case Studies of Client Success

ALLWIN — Thu, 01 Jun 2023 09:20:18 +0000

Nearshoring at Its Best

Imagine that you are a software development company, faced with the challenge of staying current with emerging technologies to meet client demands. We have brought you two of our recent case studies which showcase our successful utilization of Azure and the MS Teams API.

In the first case study, we developed a B2B platform that required the creation of Power BI reports to provide top-level management with key performance indicators. We opted to embed the reports using Power BI Embedded, allowing flexible access rights and future scalability. By implementing row-level security and embedded tokens, we achieved targeted access control and automated role definition.

In the second case study, we integrated the MS Teams API to address limitations of Zoom. We used Teams invitation links to conduct conversations, providing an alternative solution for B2B users. Leveraging our expertise in MS Graph API and app registration, we programmatically managed meetings and addressed challenges related to recording and phone access.

These case studies highlight the advantages of nearshoring and seeking external expertise. By collaborating with experienced teams, companies can overcome technological complexities and meet strict deadlines. Nearshoring not only ensures successful project delivery but also fosters knowledge transfer and adaptability to new technologies.

In conclusion, nearshoring offers significant benefits in software development, as demonstrated by our successful integration of Azure and the MS Teams API. By leveraging external expertise, companies can navigate complex technologies and achieve project goals efficiently.