DEV Community: TrueLime

How to Delete a Code Wiki in Azure DevOps

Jeroen Fürst — Mon, 06 Oct 2025 06:26:17 +0000

In one of my projects, I initially created a Code Wiki next to the regular project Wiki in Azure DevOps, thinking it might be useful, but later realized I didn’t really need it. Everything seemed fine until I decided to clean it up and deleted all the content from the Code Wiki. That’s when things got weird.

Whenever I clicked on Wiki in the left navigation, I ended up on a blank screen where I could only create a new document. After saving it, nothing happened, no navigation options, no way to switch back to my main project Wiki. The only workaround I found was to manually add .wiki to the query string in the URL to reach the regular Wiki again. 🤦‍♂️

Even after digging through Azure DevOps project settings, there was no option to delete or reset the broken Code Wiki from the UI.

After some research, I discovered that you can actually remove a Code Wiki using the Azure DevOps CLI, and that finally solved it. 🚀

🧰 Steps to Delete a Code Wiki

Open your terminal or PowerShell and run the following command (adjust it to your setup):

az devops wiki delete --wiki <wikiName> --project <projectName> --yes

Replace <wikiName> with the name or ID of your Code Wiki, and <projectName> with your Azure DevOps project name (if it’s not already set as default).

The --yes parameter simply skips the confirmation prompt.

⚙️ Installing the Azure DevOps CLI

If you haven’t installed the Azure DevOps extension yet, you can do so in PowerShell with:

az extension add --name azure-devops

You can explore all available extensions using:

az extension list-available --output table

Just sharing this in case anyone else runs into the same problem, hopefully this saves you a few hours of head-scratching. 💡

Vibe Coding: Revolutionizing Software Development with GitHub Copilot Agents

Jeroen Fürst — Fri, 11 Apr 2025 05:59:22 +0000

Ever had those days when coding felt like a grind, as if you were stuck in a cycle of repetitive tasks and endless screen time? Yeah, I know the feeling. 😩 But things might just be changing for the better. Recently, I've discovered an exciting concept: vibe coding. It's introducing a new era where coding integrates more seamlessly into our daily lives. The idea is to balance focusing on code with participating in everyday activities—a kind of part-time presence that maintains full-time productivity. Let me explain how GitHub Copilot Agents in VS Code are making this possible.

Enter the Agents: More Than Just Code Completion

GitHub Copilot got attention when it debuted as an assistant capable of completing code snippets. However, the introduction of Agents takes it a step further—from suggesting lines of code to managing comprehensive coding tasks. Imagine having a coding buddy that doesn't just write code but also coordinates multiple steps in a workflow. 🛠️ All you need to do is sketch out your goal, jot down some clarifying remarks, and watch as the Agent takes your idea and runs with it. Intriguing, isn't it?

Vibe Coding: Multitasking's New Friend

Ever tried cooking dinner while bug-fixing a component? I've often faced a choice between a properly cooked meal or functional markup. But with vibe coding, those tough choices are no longer an issue. Picture this: you're enjoying your favorite series and simply pause to approve a refactor that your Agent handled while you were distracted. It's more like directing than coding, and that's the charm. It's letting coding fit into scenarios once thought impossible while maintaining quality. 🍕 + 🎥 + 👨‍💻

A Few Speed Bumps: Speed and Autonomy 😅

Before you get too excited, vibe coding isn't without its quirks. The Agents might resemble a talented junior developer: excellent work, but needing a bit more time, especially with complex tasks. Still, considering the trade-off of outsourcing some cognitive load, the extra moments aren't too steep a price.

Moreover, Agents aren't fully autonomous yet. The Agent still checks in with you for key decisions, asking for clarification or direction when it’s unsure how to proceed. In a way, it keeps you involved and ensures your expertise remains a critical part of the process—at least for now.

Tip: VS Code's Agent Mode is available. Consider testing it to experience vibe coding firsthand: VS Code Agent Mode.

What's more, you can even let Copilot generate your commit messages. It's a small way to harmonize with vibe coding and avoid bland entries like "fixed bug." 🎶

Wrapping Up: Looking Ahead

So what does this mean for the future of coding? Perhaps it will become less of a task and more of a harmonious process, with its subtle warmth and humanity 🌍. I'm curious to see how this fits into my daily rhythm. If you're interested, fire up VS Code, enable Agent Mode, and give vibe coding a try. Let the machine handle the typing while you focus on strategizing about the grand picture.

Thanks for reading, code less and vibe more!

Integrating AI Agents with n8n: Enhance Your Workflow Automation

Jeroen Fürst — Thu, 10 Apr 2025 06:58:40 +0000

As someone deeply immersed in digital experience architecture, I've always been fascinated by the idea of integrating AI agents into workflow automation. It's like adding a touch of intelligence to your workflows, almost as if they can think for themselves! 😃 Recently, I've been exploring n8n to see how much AI agents can elevate automation, and it's been an exciting journey!

The Challenge of Crafting Effective System Prompts

The success of AI agent integration in n8n hinges on one crucial element: the system prompt. This is not just any piece of text; it defines the message that guides your agent's behavior, setting the tone, outlining its tasks, and determining its scope. A well-crafted system prompt can be the difference between your agent performing expertly or straying into unpredictable territory. Imagine instructing your agent like a helpful colleague, minus the coffee breaks. ☕

Designing the Perfect System Message

Creating an effective system prompt can be quite the art form. The objective is to clearly describe the behaviors you wish to see, without letting the logic become overly complex. ✨ Here's a little insight: I've been refining my prompts with a custom GPT assistant, enhancing their clarity and reliability. It's not about using sophisticated language, but about fine-tuning the nuances and intent—a dynamic puzzle that keeps me engaged.

Testing AI agents directly within n8n is a great strategy. It's akin to working with clay; you mold, test, and tweak until your AI agent behaves as envisioned. This approach allows for experimentation and re-running system messages to continually adjust the agent's behavior before putting it into action.

💡 Pro tip: Always test your AI agents within n8n for direct feedback, making it easier to refine prompts and behaviors.

Expanding Capabilities: Connecting the Dots

A feature that significantly enhances n8n’s capabilities is the ability for AI agents to interact with external tools or trigger sub-workflows. This paves the way for dynamic processes, like auto-generating documents, managing APIs, or orchestrating multi-layer operations. Precise system prompts ensure your AI understands user intent accurately, thus enabling reliable, multi-step automations.

The Endless Cycle: From Experiences to Innovations

As I reflect on this integration journey, the rewards are inherently tied to the learning curve. Each adjustment brings new insights, but there's always room for enhancement. I'm curious about how others navigate this realm—have you approached prompt design differently or discovered unique hacks for validation processes? Let’s share experiences—I'm eager for a knowledge exchange! 🔄

For those interested in elevating their automation capabilities, n8n offers an array of integrations worth exploring. Visit n8n.io if you're intrigued.

Hope this gives your setup a boost. Let me know how the experience works for you!

Mastering Azure DevOps Pipeline Variables and Secrets: Tips and Best Practices

Jeroen Fürst — Wed, 09 Apr 2025 06:03:18 +0000

I recently found myself deeply immersed in optimizing our Azure DevOps pipelines. It's that moment when you uncover little hacks and best practices that make you wish you'd thought of them sooner. Aligning variable management with appsettings.json led to a genuine "eureka" moment. It's like stumbling upon that perfectly fitting puzzle piece that was hiding in plain sight. 😅

The Organizational Challenge

Managing the multitude of configurations across different environments can rapidly transform pipeline management into a headache 😫. When unchecked, variables can become chaotic, sabotaging the very efficiency they're supposed to bolster. Thankfully, Azure DevOps offers a feature called variable libraries, which help bring order to this chaos.

Structuring Variables with Dot Notation

To enhance clarity and organization, I started aligning our variable naming conventions with our appsettings.json file using dot notation. Instead of opting for vague variable names, I designed a structure like AppSettings.Database.ConnectionString. This tidy approach intuitively maps to application configurations. It also adds a layer of control over what flows into the pipeline—a true game changer! 💡

Seamless YAML Integration

A standout benefit is how easily these variable groups integrate with YAML pipelines. By linking variable groups, we automate and simplify environment-specific configurations. Imagine making a change in an environment without causing a storm in your pipeline ecosystem. With this approach, maintaining pipelines feels more like a pleasant stroll rather than a frantic sprint. I've noticed a significant reduction in our pipeline complexity, making maintenance and scaling so much easier.

💡 Security First: Guard Your Secrets

Securing sensitive information isn't just advisable—it's essential. Azure DevOps offers a nifty feature to mark sensitive variables as secrets, with the lock icon 💼. This ensures they remain secure and hidden, protecting them from scrutiny, whether in logs or the interface. By playing safe, we can prevent unwanted surprises.

Key Vault Integration: A Seamless Experience

Integrating Azure Key Vault with Azure DevOps was another exciting discovery. By enabling the Key Vault option, secrets are safely incorporated without being directly stored within DevOps. You simply select your Azure subscription and pick the relevant Key Vault. Such integrations elevate variable management, offering unparalleled security and control.

For those interested in delving deeper into the mechanics, Azure’s documentation provides valuable insights: Variable Group Management in Azure DevOps.

Wrapping Up

This journey through optimizing Azure DevOps pipelines taught me how a bit of structure significantly reduces complexity and enhances security. If we tech folks can prioritize maintainability and scalability in our configs, maybe we'll spend more time enjoying coffee—and less time debugging 🤔.

With security and organization in our pipelines strengthened, I'm eager to explore more automation possibilities with Azure DevOps. As cloud environments become increasingly intricate, keeping our pipeline management lean and efficient will undoubtedly be critical.

Thanks for reading, happy building!

Revolutionizing Prototyping with AI: How Lovable Enhances Efficiency

Jeroen Fürst — Tue, 08 Apr 2025 11:12:17 +0000

As a digital experience architect, I'm always on the lookout for new ways to streamline the prototyping phase. Recently, I discovered an intriguing AI-driven tool called Lovable, which has genuinely changed how I approach building application solutions. 🌟 I wanted to experiment with AI-driven development using a simple e-commerce app, and Lovable seemed perfectly suited for the job.

The Challenge: Fast and Functional Prototyping

Prototyping has always felt like meticulously carving a sculpture from stone: rewarding yet labor-intensive. Traditionally, it meant laboring over architectural decisions, writing boilerplate code, and layering on necessary features just to test the viability of an idea. However, Lovable changes this dynamic by transforming well-structured prompts into vivid application prototypes. 🚀

A Guided Tour Through AI-Powered Creation

Lovable breaks down the barriers to swift prototype generation. With it, turning intents into functional applications feels like engaging in a conversation. Whether creating a Progressive Web App or a simple shopping cart-enabled e-commerce site, Lovable constructs prototypes while offloading features like user authentication or data storage. 🌐 It helps your app stand independently with minimal input.

But there's more: Lovable navigates architectural choices, initiates code generation, and anticipates needs you might not have explicitly detailed in your prompts. 🛠️ Its iterative refinement ability through follow-up prompts makes developing with Lovable resemble chatting with a well-informed assistant.

Keeping Things Real with GitHub Copilot

Integrating Lovable into my workflow felt seamless when paired with GitHub Copilot. Typically, I start by using Lovable to rapidly generate prototype versions for assessment. After uploading to GitHub, Copilot lets me refine and personalize the prototypes with minimal friction, efficiently handling tricky corner cases. 📈 By naturally compartmentalizing tasks between these two AI tools, my development process becomes streamlined and balanced.

Catching Your Creative Waves (But Watch the Credits!)

While Lovable impresses with its functional elegance, it's important to be cautious when enjoying generous prompt use, as credits can deplete faster than expected. Within limited thresholds, Lovable offers sufficient room to experiment without a commitment.

The AI-powered prototyping wave has undeniably arrived, bringing both possibilities and caution. Lovable makes this wave intuitive and enjoyable, shifting development towards more playful and vibe-centric coding. I strongly advocate diving into Lovable and embracing this lively approach.

Check out Lovable for yourself: Lovable Official Site

Final Thoughts: The Playful Dance of AI Development

Reflecting on my experience with Lovable, I've learned that AI can transform technical barriers into creative pathways, offering a welcoming starting point for developers eager to innovate. As we steer towards more AI-driven solutions, understanding the balance between automated scaffolding and creative coding remains crucial. The dance of creativity and efficiency continues to fascinate me, and I'm excited to see where this journey leads next. 🎉

Thanks for reading, happy building!

Harnessing AI Automation with n8n for Seamless Blog Writing

Jeroen Fürst — Mon, 07 Apr 2025 14:38:31 +0000

Over the past few weeks, I've been perfecting the way I create and share technical blog posts 📘. Introducing AI automation into my writing routine has truly transformed the process. As I explored ways to optimize my approach, I turned to n8n, a comprehensive workflow automation tool that fits well with my tech-savvy mindset.

Simplifying the Writing Process with n8n

I started by designing a custom workflow using n8n. If you haven't tried it yet, it's worth a look. This tool helped me develop a seamless AI-powered system that takes a rough idea and turns it into a polished article through several intelligent steps 🔄.

The workflow begins by identifying the core message within the concept text. It then crafts a draft that captures the essence of what I aim to convey. This is not just a basic conversion; it refines the tone to match my personal writing style. And yes, my subtle use of emojis makes it through 😉.

Structuring for Success: JSON and the dev.to API

Once the article feels ready, the workflow prepares it in a neat JSON format. This formatting is key for the next step—publishing via the dev.to API. You can learn more about the API here 🌐.

This structured approach has greatly simplified the writing and publishing process for me. In the past, writing in English wasn't my strongest suit and often felt like an obstacle 🎯. Thanks to AI, that hurdle is now removed. Writing in English has become smooth, efficient, and even enjoyable.

The Role of Transparency: #digitaljeroen

To maintain transparency, I've introduced the #digitaljeroen tag for each AI-assisted post. This tag is a nod to my digital counterpart, crucial in bringing these blog entries to life 📌. It's a fun way to acknowledge the digital help that allows me to share thoughts and insights more consistently.

Encouraging Exploration with n8n

If you're thinking of exploring similar automation paths, I highly recommend n8n. It's an excellent platform that offers great flexibility to build your AI workflows. Check it out at n8n.io and see how it might simplify your processes as it has mine. 🚀

Wrapping It Up

Leveraging AI and n8n in my blogging system has transformed writing and publishing into a more streamlined experience ✨. If you're interested in enhancing your workflow with AI, trying n8n might open new doors for you. Don't hesitate to share your thoughts or experiences, and if you want to connect on LinkedIn, I'd love to hear from you! 😊

Connect with me: LinkedIn

Tips for Migrating from KX13 to Xperience by Kentico

Jeroen Fürst — Thu, 26 Sep 2024 13:27:47 +0000

Transitioning from Kentico Xperience 13 (KX13) to XbyK is a significant move that requires careful planning. While you might be satisfied with your current platform and are a fan of Kentico 😉, considering a migration now can help you make the transition more cost-effectively in the future. Think of it like maintaining your car 🚗—regular check-ups and part replacements keep it running smoothly. Similarly, modernizing or replacing components of your platform over time sets a solid foundation for the next generation.

Starting early allows your organization to strategize the best approach, and your agency or friendly neighbourhood Kentico Partner 🦸 can offer valuable guidance 🤝. There's no need to do everything at once; gradual preparation can make the process much smoother.

Key Considerations for a Successful Migration

Here are 10 essential steps to guide you through a smooth and efficient migration from Kentico Xperience 13 to Xperience by Kentico:

1. Understand that Migration is necessary 🛠️
An upgrade from KX13 to XbyK isn't possible due to significant technological changes. The biggest shift is the replacement of the CMS based on webforms with a modern, super-fast frontend technology—React ⚛️. This change means certain concepts and functionalities work differently in XbyK.

2. Evaluate the Kentico Roadmap 🗺️
Don't hesitate to get started—being informed puts you in control. By regularly checking roadmap.kentico.com, you'll stay up to date with upcoming features and monthly updates. This helps you plan your migration more effectively, especially with XbyK’s composable architecture. If certain functionalities can be replaced or updated within your current platform, it could make the transition smoother. Whenever possible, prioritize features already available in XbyK to streamline the process and ensure a seamless migration.

3. Prepare your MVC Application 🧰
Ensure your MVC application is running on modern .NET. If you're currently using .NET MVC 5, your first step should be migrating to .NET Core MVC. Since XbyK also uses .NET Core MVC, this will make your API easier to migrate.

4. Align your Frontend Stack 🖥️
Make sure your frontend stack is compatible with .NET Core MVC and React. While the CMS is based on React, your frontend doesn't have to be. However, adopting React could offer additional benefits. Examine your current frontend code to see how it can be migrated to XbyK. If you're still storing unstructured HTML/markup in the database, prioritize updating these before beginning the migration.

5. Utilize Standard Modules 🧩
Replace custom-made solutions with standard modules from KX13. For example, if you use a custom URL module, consider switching to Kentico's standard solution called content tree-based routing. This change will allow you to benefit immediately from XbyK's architectural setup.

6. Allocate Time for Content Migration ⏳
Since a direct upgrade isn't possible, use migration toolkits to transfer your content to XbyK. A great tool for this is the Kentico Migration Tool📦. An advantage of this approach is that necessary content models are created automatically. This method isn't limited to KX13; you can migrate from other platforms as well via the Universal Migration Tool. Using a universal format like JSON can expedite the process. Familiarize yourself with content modeling concepts in XbyK, such as the content hub and reusable content, to maximize benefits.

7. Leverage Page Builder and Widgets 🛠️
If you're already using the Page Builder and widgets, you'll be pleased to know they're compatible with XbyK. While KX13 widgets can be used in XbyK’s compatibility mode with minimal changes, you may want to explore the new UI Form Components for enhanced editing capabilities. The migration can be done smoothly using the Kentico Migration Tool, which helps convert the Page Builder JSON data structure to be compatible with the new components. Keep in mind that while widget properties may need some adjustments, the views and view models will require little to no rewriting, ensuring a seamless transition.

8. Clean up unused content and functionalities 🧹
Reducing the amount of content and unused functionalities before migration can save significant time. Now is an excellent opportunity to phase out or remove elements that are no longer necessary.

9. Modernize your .NET Code 🔄
Update old .NET code to modern standards. This includes not only MVC but also any functionalities using packages based on outdated development techniques.

10. Rethink your Infrastructure and Deployment ☁️
With XbyK's different structure, you no longer need two app services to host the application. Reflect on how you want to handle hosting in the future. Consider whether setting up infrastructure yourself is still the best use of your resources. Kentico SaaS could offer substantial benefits by handling much of the heavy lifting. With just a few clicks, you can have a complete environment ready, allowing you to focus on developing your application.

Final Thoughts 💡

By starting preparations now, you can make the migration to XbyK a smoother and more cost-effective process. Regularly updating and modernizing components of your platform ensures you're ready for future advancements, such as expanding into other channels or leveraging AI 🤖. Kentico remains an excellent choice for organizations aiming to achieve digital growth without the need for complete replatforming. Reach out to your agency or Kentico Partner for advice tailored to your specific needs—they're there to help you navigate this significant transition.

Embracing the Headless Channel in Xperience by Kentico

Jeroen Fürst — Mon, 08 Jan 2024 14:20:07 +0000

In December last year, Xperience by Kentico rolled out 🎁 a significant refresh, introducing the Headless Channel functionality. This innovative feature is designed to enhance content delivery and management in the digital ecosystem. By leveraging the Headless Channel, users can now seamlessly distribute content across various platforms, including campaign websites, mobile apps, and microsites. This development marks a significant shift in how content is managed and delivered, offering greater flexibility and efficiency 💪. In this article, we'll dive into the Headless Channel and discover how it enhances digital content strategies.

Channel Management in Xperience by Kentico

In Xperience by Kentico, channels are a pivotal concept for organizing and delivering content. These channels include website channels for traditional web content, email channels for digital marketing, and the brand new headless channels for API-driven content delivery.

Each channel type serves a specific purpose: website channels focus on content for web presentations, email channels are dedicated to managing and delivering marketing communications 📣, and headless channels provide greater flexibility for content distribution across various platforms. This segmentation not only refines content management and delivery strategies but also facilitates seamless integrations ⚙️, enhancing the effectiveness of digital content across various platforms.

Advantages of the Headless Channel

The Headless Channel in Xperience by Kentico is designed to simplify content management and distribution. This functionality, which requires minimal development effort to implement, can be easily activated and configured. It enables the efficient distribution of specific content across various applications, services, and online platforms.

This approach is particularly beneficial for teams looking to enhance their digital presence without the need for extensive coding or software development. By leveraging the GraphQL API endpoint, developers can prepare and execute queries to retrieve the desired content. This makes the Headless Channel a valuable tool 🔨 for content managers and developers, offering ease of use and practicality.

The differences between REST and Headless

If you're familiar with the REST service in Kentico Xperience, the Headless functionality is a notable enhancement, offering performance benefits and greater flexibility. While the REST service facilitates the management of system objects or pages, the Headless approach, using a GraphQL API endpoint, streamlines content distribution across multiple channels. Furthermore, it provides content editors with full control 💯 over the content they wish to distribute via the headless channel. This not only improves performance but also simplifies the process of repurposing existing content for different platforms.

Secured by default

In Xperience by Kentico, the security of the Headless channel is organized through token authentication. This model enhances data protection by securing the GraphQL API endpoint, requiring valid API keys 🔑 for access and permitting only authenticated requests with authorized security tokens.

Furthermore, Xperience by Kentico's headless API enables Cross-Origin Resource Sharing (CORS), allowing for effortless integration with web applications across different domains. Configuring the CorsAllowedOrigins setting allows you to specify which domains are authorized to access the API, ensuring that responses include the necessary Access-Control-Allow-Origin header.

Configuration of Headless content

To effectively utilize the Headless Channel in Xperience by Kentico, it's essential to configure headless items. These items are key in determining what content types will be available through the GraphQL API. The approach involves identifying and setting up the specific content types required for your headless channel.

For existing content stored in the Content Hub, these headless items play a pivotal role. They need to configured to link with reusable content from the Content Hub, ensuring that this content, along with all its associated fields, is readily accessible through GraphQL queries.

Explained through an example scenario

Consider the following example use case for Xperience by Kentico's headless capabilities, which involves the management and distribution of location data as reusable content. In this example, a 'location' 🌍 content model contains details such as address and directions, and it is utilized across multiple web pages through various web channels.

With the headless functionality, this location data can now also be made available to external sources. By creating a headless item with a content item selector, these locations can be easily selected and offered from a central source.

Through the built-in GraphQL UI, it is possible to easily extract the entered location data from the system. Only a few configuration adjustments are needed, such as enabling the GraphQL API endpoints. Activating GraphQL introspection is not mandatory, but it is quite handy as it makes the GUI tools available for exploring the schema.

Enhance your channel's API security by using the GraphQlEndpointPath property to specify a custom and less predictable URL endpoint.

Then, we can easily retrieve our location data, including the data from the linked address content item from the content hub.

In conclusion

The introduction of headless functionality in Xperience by Kentico is expected to significantly impact future projects. Headless activity tracking is already on the roadmap, and there's hope for expanding its capabilities to include various types of content from different channels. This indicates Kentico's commitment to evolving its headless capabilities to meet complex future needs. And with such advancements, opting for the headless channel will surely become a 'no-brainer' 😉

Kentico SaaS: First Contact

Jeroen Fürst — Tue, 19 Sep 2023 10:45:08 +0000

In this article, we will take a first look 👀 into the exciting new world of Kentico SaaS. Kentico SaaS offers customers a worry-free way to host their Xperience by Kentico websites. It provides a cloud environment equipped with all the essential components needed to run your platform smoothly. Furthermore, I will also walk you through setting up a new Xperience by Kentico project from scratch, preparing it for SaaS deployment, integrating it with a CI/CD pipeline via Azure DevOps, and automatically rolling it out to various environments within Kentico SaaS. Finally I will also touch on the topic of Continuous Deployment, a much-anticipated new feature in Xperience by Kentico.

Exploring hosting options: Engage

In today's world 🌎, customers expect to operate their websites seamlessly, whether it's to meet performance and scalability demands during peak moments or to ensure the security of sensitive data. Meeting these expectations is no longer an option but a fundamental requirement. Fortunately, services like Microsoft's Azure cloud ☁️ address many of these concerns when used as a platform-as-a-service. This is an area where we have been diligently working on and making improvements for years.

There are situations where it can be difficult to keep up with all the technological changes. If your agency lacks the resources to tackle this, such as providing education 🎓 for Certified DevOps Engineers, offering independent hosting services can be challenging. Organizations are increasingly looking for SaaS solutions with straightforward service levels.

This is where Kentico SaaS can offer an appealing alternative 💪. Kentico SaaS offers secure, scalable, and cost-effective hosting for your platform. This service is specifically designed for Xperience by Kentico, ensuring that only essential components are deployed to run your platform. Furthermore, the platform undergoes continuous improvement, reducing the necessity for ongoing knowledge investments. If a new cloud 👽 technology becomes available, there's a good chance that it will be adopted and made available, ensuring your platform remains up-to-date.

However, it's important to note that there are a few considerations, especially if you're accustomed to taking matters into your own hands and conducting thorough analyses 🧠. In such situations, you may find it necessary to enlist additional support to address any challenges in understanding platform errors, as obtaining comprehensive diagnostic info can be demanding, even though monitoring tools are available. On the other hand, you can also leverage this to your advantage 😉.

Creating Kentico SaaS projects: Make it so

Getting your application ready for Kentico SaaS was easier than I had anticipated. By running a few commands, you can make your Xperience by Kentico SaaS-ready 💯.

Add the --cloud parameter when creating your Xperience by Kentico project. This parameter installs a boilerplate project suitable for SaaS deployments.

The next steps involve building and configuring your application, and then preparing it for deployment. Kentico offers a PowerShell script for generating the Kentico SaaS deployment package. This package can be uploaded via the Xperience Portal, and then rolled out to different environments. This process can also be automated, as we'll discuss shortly.

Of course, the prerequisite is to subscribe to Kentico SaaS. There are several editions with various functionalities and features to consider. In this example, I'll be using the medium tier, which provides QA, UAT, and PROD environments, as I prefer a robust DTAP approach.

Streamlined Deployment: The Final Frontier

Release pipelines have become essential building blocks for DevOps engineers. We typically use pipelines for two purposes:

Compiling and automatically testing the application with each commit.
Automatically building and deploying release-ready code.

Kentico has thoughtfully integrated these aspects into the Kentico SaaS service, offering APIs to deliver deployment packages, making it remarkably straightforward to seamlessly integrate into your own release pipeline.

Send the package via a POST request to the deployment API endpoint: https://xperience-portal.com/api/deployment/upload/PROJECT_GUID.

Once a deployment package is received, Kentico immediately starts deploying 🚀 it to the target environment. This process takes a few minutes, and the environment is updated. Error handling is also built in, should the package encounter deployment issues.

Once tests are successful and you have the green light ✅ for the release, you can proceed to the next environment via the Xperience Portal. The portal provides all the necessary information to manage this process effectively, including an audit trail to ensure only authorized personnel can push releases.

The past is written, but the future is left for us to write

Xperience by Kentico introduces a new feature called Continuous Deployment. The purpose of Continuous Deployment is to facilitate incremental deployments. It shares similarities with Kentico's Continuous Integration but has some significant distinctions. The Continuous Integration feature serializes content and objects into XML files to maintain synchronization 🔄 across developer environments. While this approach is effective for version control, it was not suitable for deploying to other environments. Typically, additional tools like the BizStream Toolkit, Content Staging, or custom deployment tools were used 😉.

The workflow for Continuous Deployment is as follows: First, you need to generate the Continuous Deployment configuration file. The configuration file enables you to specify the restore mode (Create/CreateUpdate/Full) for each object, which determines the operations required in the target database during repository restoration. The next step is to generate the Continuous Deployment files. This can be achieved by using the following command:

dotnet run --no-build -- --kxp-cd-store

When a release is submitted to the Xperience Portal, the Continuous Deployment files will be processed automatically. Once the release is completed, you will notice that the changes are available. This automation is an additional advantage when you use Kentico SaaS 😍.

To Boldly Go ✨

So far, you've been able to read about my initial experiences with Kentico SaaS. I've demonstrated how simple it is to make a project SaaS-ready. I've also covered the generation of a deployment package and how to submit it to the Xperience Portal. What has pleasantly surprised 🎁 me, in particular, is the straightforwardness of the deployment process. You can see that Kentico has put considerable thought into keeping this process as simple as possible. Additionally, I find the new Continuous Deployment feature personally very appealing. It will be very interesting to see how it performs in upcoming Xperience by Kentico projects. To be continued!

Troubleshooting "Our Services Aren't Available Right Now" Error in Safari with Azure Front Door

Jeroen Fürst — Tue, 29 Aug 2023 11:13:48 +0000

Introduction

In my line of work, which often involves managing projects hosted on Azure and utilizing DXP platforms like Kentico and Umbraco, Azure Front Door has become an vital component of our setup. We are strong advocates of this service and have utilized its capabilities to enhance various aspects of our applications. A great example of this is the built-in Web Application Firewall (WAF) capabilities and protection against DDoS attacks.

However, a recent development has brought a new challenge to our attention, particularly concerning users who access our websites via Safari browsers. Interestingly, these users have reported encountering an unexpected issue. On occasion, they are met with a seemingly generic error message from Azure Front Door:

"Our services aren't available right now. We're working to restore all services as soon as possible. Please check back soon."

This issue is interesting because the Azure Front Door is configured in detection mode, with the aim of analyzing incoming traffic without actively blocking it. To determine the cause, a thorough analysis is necessary.

Root cause of the error

Investigating the issue proved to be somewhat of a puzzle due to its sporadic behavior. However, we managed to make progress by reproducing the situation on a Mac. During testing, we noticed something intriguing: when Safari displayed the "Our Services Aren't Available Right Now" error message, we also observed a "421 Misdirected Request" response in the browser. This helped guide our search for more information and led us to the following relevant post on Stack Overflow. This post introduced us to the concept of "Domain Fronting," a behavior inherent in Azure Front Door.

Essentially, domain fronting is a security measure in Azure Front Door that blocks certain HTTP requests. Specifically, if the host header of a request doesn't match the original TLS SNI extension, it can be blocked. Understanding this behavior shed light on the root cause behind the "Our Services Aren't Available Right Now" error experienced by Safari users and helped determine the next steps to be taken.

Hello, IT

Reaching out to Microsoft was a logical step that provided valuable insights into the problem's cause, especially regarding its connection to the way Safari interprets TLS mismatches. In the course of our communication with Microsoft, we discussed the possibility of disabling domain fronting, as mentioned in the Stack Overflow post, as a potential measure to address the issue. This collaborative approach helped us to gain a more comprehensive understanding of the problem and explore potential solutions.

It became clear that in our setup, the use of a multi-domain SSL certificate played a crucial role in the Safari-Azure Front Door relationship. The problem appears to be connected to how Safari interprets TLS mismatches and is not a bug within Azure Front Door. Microsoft suggested a potential solution, which involves using distinct certificates for each custom domain or considering the utilization of Azure Front Door managed certificates, incorporating individual Subject Alternative Names (SANs).

Fixing the problem

As a solution to the problem, we ultimately opted to use a separate SSL certificate for each domain hosted on the platform. Luckily the SSL certificate management can be automated within Azure Front Door. Initially, we encountered difficulties in provisioning the SSL certificates. Once again, Microsoft came to the rescue.

To provision the SSL certificates, it's important that the domains are mapped to Azure Front Door via DNS. Additionally, you need to either add "digicert.com" to the CAA (Certification Authority Authorization) record or remove the CAA record altogether (leaving it blank and unlinked to any CA). Once this step is completed, Digicert can seamlessly issue the necessary SSL certificates.

Conclusion

In this article, you've been able to read about how we went from a vague browser-specific issue to the eventual solution by implementing individual SSL certificates for the website domains in question. Along the way, it provided us with numerous insights into the capabilities of Azure Front Door. Hopefully, this article will help you if you encounter the same issue. If you have any tips or suggestions, please feel free to share them in the comments below.

Essential Insights into Kentico Xperience's Hotfix Methodology for Developers

Jeroen Fürst — Fri, 23 Jun 2023 12:35:18 +0000

Introduction

In this blog post, I cover some hidden magic of Kentico Xperience, specifically an internal method that silently operates in the background whenever a hotfix is implemented. While developers may not directly witness this process, it executes significant changes that can have a profound impact on the functionality of Kentico Xperience. Understanding and correctly executing this hotfix procedure is crucial to avoid potential problems that could arise within the system.

In this post, I will explore the detailed workings of Kentico Xperience's hotfix methodology. By the end of this article, you will have a thorough grasp of the inner workings of Kentico Xperience's hotfix methodology, allowing you to confidently apply hotfixes with ease and avoid any potential errors, ensuring a smooth and trouble-free experience.

Understanding the Hotfix Procedure

The Kentico Xperience hotfix procedure involves several steps to ensure a successful implementation. First, you need to download and install the Kentico hotfix utility, which serves as a tool to facilitate the process. Once installed, you can launch the utility and follow the provided wizard, which guides you through the necessary steps. This includes executing the required database SQL scripts and updating the Kentico Xperience files, particularly the CMS files. Afterward, you need to open the live site application (MVC) in Visual Studio, where you will update the NuGet packages to the target hotfix version. To complete the procedure, you rebuild the solution and start the application to apply the hotfix effectively. By following these steps, you can ensure a smooth and error-free experience during the Kentico Xperience hotfix process.

Potential Challenges and Solutions during the Hotfix Procedure

During the execution of the hotfix procedure in Kentico Xperience, various issues can arise that are immediately visible and require attention before proceeding to the next step. For instance, when executing the SQL script, it is possible for it to fail and provide instant feedback about the error encountered. Such errors need to be addressed and resolved before proceeding further.

Similarly, when updating the NuGet packages and building the solution, compilation errors can occur, necessitating their resolution. Another potential area where errors can occur is when updating the administration interface through the hotfix wizard. In some cases, certain files may require manual comparison and updating, especially if they have been intentionally modified.

Each of these steps collectively forms the foundation of the hotfix procedure, and it is crucial to perform them correctly. Once these steps are completed accurately, the next phase involves launching the CMS and the live site (MVC) application.

Testing and Validating the Hotfix

To ensure a smooth production rollout, it is advisable to execute the SQL script on multiple database copies, preferably with representative data. This allows for thorough testing and helps identify any potential issues that may arise from variations in data between different environments. By closely mimicking the production environment, we can proactively address discrepancies and prevent complications during the hotfix deployment process.

The Hidden Operations of Kentico Xperience Hotfixes

Upon launching the hotfixed application, it is important to note that background tasks might still be in progress. Although not immediately visible during the loading process, these tasks can be traced in the event log, indicating the execution of additional operations specific to a particular hotfix version.

A deeper analysis of the source code reveals the background execution to update class form definitions. These updates involve modifying or expanding table structures with new database fields. An example is the introduction of the DocumentUnpublishedRedirectUrl field, which was added in refresh 8, also known as hotfix version 13.0.94. These updates are performed through the internal Kentico Xperience API, ensuring consistent synchronization of the database across all relevant locations.

Exploring the Importance of Class Form Definitions Updates

The process of updating class form definitions in Kentico Xperience involves an additional level of complexity. It relies on a temporary table named [Temp_FormDefinition], which is populated with corresponding changes by the hotfix SQL script (see screenshot below). This step is particularly relevant for refreshes that introduce new functionalities to Kentico Xperience.

The [Temp_FormDefinition] table contains an XML value that stores the class form definition. When Kentico Xperience detects the execution of a hotfix, it reads and processes this temporary table in the background. At the end of the process, the table is cleaned up and removed. Simultaneously, a Kentico Xperience setting is updated to store the hotfix version.

Kentico Xperience utilizes two settings for this purpose: CMSHotfixVersion and CMSHotfixDataVersion. When the Kentico Xperience application starts, it compares the values of these settings. If they differ, the method responsible for reading the temporary table and processing the class form definitions is triggered. This ensures that any necessary updates are applied seamlessly during the startup process.

Pitfalls of the Temporary Table in Kentico Xperience

It is crucial to highlight the potential pitfalls that can occur if the temporary table, [Temp_FormDefinition], is empty but has not been fully processed. Incorrect execution can result in error messages, as previously illustrated by the example of the new DocumentUnpublishedRedirectUrl field. For instance:

Caused exception: Invalid column name 'DocumentUnpublishedRedirectUrl'. , StackTrace: at CMS.DataEngine.AbstractDataConnection.HandleError(String queryText, Exception ex)

In a recent project, we encountered this exact issue. We had automated the hotfix rollout process, which included the automatic execution of the SQL script. However, for unknown reasons, the temporary table was either not updated or not updated completely. Despite the absence of any hotfix-related notifications in the event log, we found that the two settings, CMSHotfixVersion and CMSHotfixDataVersion, were still identical. As a result, we observed abnormal behavior and encountered error messages due to the failure to update the source table structures.

This showed us once again the crucial importance of maintaining the correct sequence and order of operations during the hotfix procedure to avoid such issues.

Conclusion

In conclusion, this blog post has shed light on the under the hood background tasks that are crucial for a successful hotfix procedure in Kentico Xperience. While the more visible tasks are important, it is equally vital to recognize and ensure correct execution of these background tasks. Neglecting them can lead to unexpected issues and complications within the applications.

Hope this helps. Happy developing!

Tackle 0 Byte files in Azure Blob Storage with ease using Azure PowerShell

Jeroen Fürst — Tue, 03 Aug 2021 13:10:33 +0000

Introduction

Have you ever felt like you were facing a challenge that would take you a long time to solve? I had that feeling recently when I had to track down corrupted files in Azure Blob Storage. Fortunately, with the help of some PowerShell scripts for Azure, I was able to easily trace and fix the files, by in my case deleting them.

If this sounds familiar to you and if you are looking for a step-by-step plan to handle files in bulk, then you have come to the right place. In this article I will briefly discuss how the files got corrupted. I will then cover the manual approach that I took to locate the files. Finally, I will present a step-by-step plan of PowerShell scripts to find and delete the 0 Byte files.

Cause of the problem: out of memory

The application in question is a Digital eXperience Platform (Kentico Xperience) that consists of typical Azure components such as an Azure Web App, Azure SQL Database and Azure Blob Storage for the storage of media files. Synchronization with the Product Information Management System takes place every night via a scheduled task, whereby the latest product data including images are updated and stored in Azure Blob Storage. The synchronization went smoothly until at some point the error message: Exception type: System.OutOfMemoryException occurred.

The synchronization failure was not directly linked to the broken images. Only after reports came in that images were randomly missing on the website, it became clear that there was more going on. Debugging the image processor showed that, due to the memory exception, thumbnails were generated as 0 Byte images spread over dozens of folders 😱.
And since only the updated products are synced, searching for broken thumbnail images is like searching for a needle in a haystack.

Manual approach to find and delete broken images

In the search for the 0 Byte files I came across Azure temp and Azure cache folders on the Azure Web App. The application uses these folders to store temporary data from Azure Blob Storage. Through Kudu Console, a service available for Azure Web Apps, it is possible to navigate through these folders using the command prompt. By executing the following command line script all 0 Byte files will be searched and written to a txt file:

forfiles /S /M *.* /C "cmd /c if @fsize EQU 0 (if @isdir EQU FALSE echo @path)" > list.txt

Source: How to find and list zero byte files in Windows and Linux

Now that we have a list of broken files, we can track them down in the Azure Blob Storage media container. For this I can highly recommend the Microsoft Azure Storage Explorer 💯.

This approach works fine if you only need to go through a reasonable amount of files and folders. In my case it concerned dozens of files in even more folders. That is why I went looking for a way to search and delete all 0 Byte files in a single go. Azure PowerShell to the rescue!

Azure PowerShell step-by-step guide to find and remove 0 Byte files

This guide is based on Azure PowerShell commands. For more info check out how you can install the Azure Az PowerShell module. The steps consist of Azure PowerShell commands to:

Access the Azure subscription
Specify the Azure Storage account
Execute a search command to find the files
Extend the search command with instruction to delete

In the following steps we will need to provide some data from Azure. It is recommended to check whether you have the required permissions to access the above-mentioned Azure resources via Azure PowerShell.

Note: I recommend testing the scripts extensively in a test environment first before getting going wild on production.

Step 1: Connect to your Azure account
You can optionally specify the desired Azure tenant by passing in the -TenantId parameter. See the documentation for more info.

Connect-AzAccount

Step 2: Create the Azure storage context
Next, we will indicate which Azure Blob Storage we are going to target. This can be done using an Azure storage context. Since we need the context in the next steps, we store the Azure storage context in the $Context variable.

$Context = New-AzStorageContext -StorageAccountName "< Account Name >" -StorageAccountKey "< Storage Key ends with == >"

Step 3: Search for the files
Using the Azure storage context stored in the previous step, we can retrieve files from a desired Azure container. By extending the Get-AzStorageBlob command with a Where-Object pipeline we can specify exactly what we need, namely all 0 Byte files.

Get-AzStorageBlob -Context $Context -Container "< Container Name >"  | Where-Object {$_.Length -eq 0}

You could extend the where condition to filter only images (jpg) by additionally passing in the content type:

Get-AzStorageBlob -Context $Context -Container "< Container Name >"  | Where-Object {$_.Length -eq 0 -and $_.ContentType -eq "image/jpeg"}

Step 4: Remove the 0 Byte files
If you have tracked down the broken images, deleting them should be super simple. You only need to add the Remove-AzStorageBlob pipeline at the end of the command from the previous step:

Get-AzStorageBlob -Context $Context -Container "< Container Name >"  | Where-Object {$_.Length -eq 0} | Remove-AzStorageBlob

In case of the additional jpg images content type filter:

Get-AzStorageBlob -Context $Context -Container "< Container Name >"  | Where-Object {$_.Length -eq 0 -and $_.ContentType -eq "image/jpeg"} | Remove-AzStorageBlob

And with that you have all the scripts needed to find the broken files and delete them in bulk 😊.

Conclusion

In this article I shared my approach to tackle the issue that I faced in which images became corrupted due to memory problems of the Azure web application. In the first part of the article I provided a solution to manually detect and delete the broken files by the combined forces of Kudu Console and the Microsoft Azure Storage Explorer. Because in my case it involved a substantial amount of files, I also provided a step-by-step guide consisting of Azure PowerShell commands to search for the relevant files and delete them in one go.

In the end I hope that you don't run into these situations and that your application continues to run smoothly. In all other cases I hope this post was helpful.

Thank you for reading!