Sitecore and StyleLabs

The big announcement at Sitecore Symposium this year was Sitecore’s acquisition of StyleLabs, a marketing technology company that provides several software-as-a-service tools:

  • Digital Asset Management (DAM)
  • Marketing Resource Management (MRM)
  • Product Information Management (PIM)
  • Digital Rights Management (DRM)

It wouldn’t be enterprise software without all the acronyms, would it?

Sitecore aquires StyleLabs
Sitecore CEO Mark Frost talks with StyleLabs’ co-founders at Sitecore Symposium 2018

This announcement was a big deal for Sitecore, because its current tool for handling media assets — the Sitecore Media Library — was increasingly showing its age. The structure and features of the Media Library haven’t changed much in 10 years. It’s one of the first things that partners needed to extend or replace for any company that was serious about managing digital media. And it had nothing to offer in terms of workflow tools apart from the simple “publishing approval” style of workflow used for web pages.

There were a few go-to solutions for DAM integrations — both Digizuite and ADAM Software (now part of Aprimo) have decent integrations with software. For any of the other capabilities listed above, you most likely would need to build your own solution.

So customers and partners were really pleased that Sitecore will have something first-party to offer in these areas. If the schedule holds, StyleLabs integration as a plug-in within by the end of 2018, with a full integration planned in the first half of 2019.

More than a product line extension?

While addressing a gap in its offering is important — especially since Sitecore often goes head-to-head with Adobe Experience Manager in big deals — I’m more excited about the long-term potential.

This acquisition brings some new technologies, new approaches, and new team members into the Sitecore family.

StyleLabs was founded in 2011, and its cloud-hosted, SaaS offerings reflect a later technology generation than Sitecore,  whose roots go back before the turn of the millennium. (It says a lot about the strength of Sitecore’s fundamentals that it has lasted this long!) As Sitecore modernizes its architecture stack, having the StyleLabs’ expertise in SaaS technologies and business model will be invaluable.

While Sitecore was always great about storing and managing content and digital assets, in really didn’t address the production of those assets in the first place. StyleLabs understands the creative workflow that goes into making these digital artifacts, and I hope to see their knowledge reflected in future versions of the Sitecore platform.

I also expect a strong of cross-pollination of ideas. Sitecore and StyleLabs execute similar concepts in different ways. For example, Sitecore structures information in a hierarchy or tree, which works extremely well for managing URLs in a website. StyleLabs takes a relational approach to content, which offers more flexibility but perhaps less consistency.

So there are a lot of cues — from software architecture to user interface — that these teams can take from each other. While filling gaps in the product line may boost the short-term, I’m really curious what this means for Sitecore over the long term.

 

 

 

Sitecore Symposium and MVP Summit 2018

I’ve just returned from the Sitecore Symposium 2018 in Orlando, FL. It’s been two years since I attended the last one (in New Orleans). My, how it’s grown! There were more than 3000 attendees at Disney’s Swan and Dolphin, with breakout sessions divided into 5 different tracks, ranging from marketing, to technology, to getting started with the platform. It was an intense 3 days of sessions and networking.

There’s so much to talk about, I think I’ll need to break it up into a series of posts over the next few weeks. But I’ll start with how thankful I am to have attended the MVP Summit in the day and half after the closing Symposium keynote.

Symposium_2018_Badge

This was my first year as a Sitecore Commerce MVP, so I’d never been to the MVP Summit. I’d heard great things about it from lots of other MVPs. It’s an opportunity for Sitecore insiders to share upcoming preview releases and talk candidly with community leaders about what’s coming next. It’s also a chance for MVPs to provide face-to-face feedback to Sitecore employees about what’s working well and what can be improved. And it’s naturally a time for MVPs to network with each other.

Part of what makes the MVP Summit work is that it has a smaller number of attendees — about 300 — but a wide diversity of backgrounds. There were MVPs from around the world, some from implementation partners, some from Sitecore’s customers, and some from makes of tools and extensions that work with Sitecore. Many of these were names I recognized from their blog articles, Slack chats, or forum posts. It was great to finally match faces with the names.

Another part of what makes the Summit work is that there’s a huge diversity of topics covered, from Commerce (my focus at the moment) to developer tools, to strategy, to documentation, to the operation of the Sitecore MVP program itself. Some of the best sessions and conversations I participated in were the ones I hadn’t planned on attending.

Finally, there’s a diversity of formats, from presentations, to Q&A sessions, roundtables, and even a “special event” where MVPs can just hang out together and swap stories. Symposium itself tends to either be large presentations or the scrum within the booths at the partner pavilion. So it was nice to have sessions that were less formal and less pressured — I certainly got more out of it than I anticipated. And that’s despite my expectations having been raised by several other MVPs.

So now my task is to figure out how to stay in the club next year!

Sitecore Solr Cloud Support

On the roadmap for future releases of Sitecore 9 is true SolrCloud support. This has been a sticking point with many scaled implementations of Sitecore since SolrCloud was first introduced in 2013. For the most part, Sitecore implementations have relied upon either the Solr Master-Slave model to ensure high availability and load balancing (at least for queries) or have muddled through with Solr Cloud approximations.

A history lesson

To understand where Sitecore stands with regard to Solr Cloud support, you have to know a little history behind how search was implemented in Sitecore. There are two mechanisms for finding items in Sitecore. The first is to use Sitecore’s database query mechanisms, which rely on an XPath-like syntax for traversing the content tree. This is a slow method, but is used for simple queries to traverse parent-child relationships and is often used with Sitecore’s field types that display hierarchical relations: the treelist, droplist, and droptree, for example.

The second method is to use a full text search provider. Back in the Sitecore 4 or 5 days, this was dtSearch, but Lucene quickly became the default full text search provider, due to the extensive documentation and examples available. Like dtSearch, Lucene was a full-text indexing engine meant to be used in embedded applications. These tools worked great on a developer machine, or on a single-sever “all-in-one” demo configuration, but caused issues when deploying into a multi-server environment. Since each server maintained its own index, issues with out-of-sync indexes were extremely common.

Solr, an extension of the Apache Lucene project, was introduced to solve this scalability issue. It offered an enterprise platform that used the Lucene API and supported many of the extensions and plugins developed by that community, and allowed indexing and search functions to run on a separate instance. Since the API was largely compatible with Lucene, it was easy for Sitecore and other CMS platforms to transition to Solr.

Solr scalability models

The early approach to Solr scalability was the master-slave model. One server in a Solr cluster — the master — performs all the write operations, but any server in the cluster can respond to queries. This approach is one of eventual consistency for read operations. If a slave fails, the load can be redistributed to the other members of the cluster. If the master fails, however, no new write operations can be performed until one of the slaves can be reconfigured to act as the new master.

Master-slave was a challenge for Sitecore for two reasons.

  1. Sitecore assumes that its indexing and search server shares a single URL. But really, it should know of two URLs: the load-balanced URL used for reads, and the single URL that points to the primary Solr server for writes.
  2. To recover from a master failure, manual intervention was required to promote a slave to a master. This requires a reboot of the slave Solr server, which is why a true high-availability Solr master-slave arrangement should really have been called a “master-slave-slave” configuration, and needs to contain a minimum of three instances.

To address the first problem, you need to configure your load balancer to spread all GET requests across all of your master and slave instances, but to route POST requests only to the master server. Or you need to modify the Sitecore code and configuration to separate writes from reads, and send each to a different URL. (The second approach may be required if your query parameters become so complex that you run into the GET request character limit for the query string.)

To address the second problem — which was an issue for all systems using Solr, not just Sitecore — the Solr project introduced SolrCloud.

SolrCloud has nothing to do with cloud computing, despite its name. You can have on-premise datacenter deployments of SolrCloud. It’s just the name given to the new high availability and scalability model that replaces the old master-slave-slave approach.

In a SolrCloud, ZooKeeper nodes are used to determine which Solr instance acts as the primary instance responsible for write operations. If the primary fails, one of the secondaries is promoted to act as the new primary automatically. There may be a few write errors as the problem gets detected, a new election of a primary occurs, and the new primary takes over write responsibilities, but this is generally a short interval. No manual intervention is required.

This is a great approach, except for one problem: Sitecore (and the Solr libraries it depends on) don’t understand ZooKeeper.

Who’s in charge of this zoo?

In the Java world, the Solr4j library has had support for ZooKeeper “baked-in” so that clients don’t have to figure out which Solr node is the primary. The CloudSolrClient in the Solr4j library client communicates with the Zookeeper nodes to discover Solr endpoints. For write operations, it helps determine which Solr instance will handle the write requests, and all index update operations are transparently sent to that instance. For read operations, the CloudSolrClient uses the LBHttpSolrClient class as a software load balancer. There’s no additional work required!

But Sitecore is a Microsoft.NET application, and its ContentSearch API ultimately relies upon a library called Solr.NET. Solr.NET is not maintained by the Apache Solr project itself, but by a group of open source developers. As a result, Solr.NET support for Solr versions often lag behind that of the Java client libraries. This is why Sitecore only supports up to the Solr 6 series, even though Solr 8 will be released very soon.

And for a long time, Solr.NET didn’t fully support Solr 6 — which is why it didn’t have the CloudSolrClient baked in, or any knowledge of how to communicate with Zookeeper. But as of January 2018, developers can finally get a version of Solr.NET with support for SolrCloud and versions up to Solr 7. There’s even a SolrNet.Cloud NuGet package.

Now all we have to do is wait for Sitecore to incorporate it into the .NET platform. What about it Sitecore? Can we have it in time for Symposium this year? Or at least by Christmas?

 

SCpbMD Catalog Sync Explained

I’ve been meaning to post this diagram for a while. I’ve used this to explain the Sitecore Commerce catalog data sync operation to at least three different clients since I drafted it this summer. And although I created it for the Microsoft Dynamics 365 version of the connector, it’s similar for Dynamics AX and other PIM systems as well.

SCpbMD_DataSync_2017-11-27.png

In the D365 box, you have the UI application, which admins can use to publish catalog data once it has been validated. There are a lot of elements that must be configured an working correctly to have a valid catalog, but a few of the key pieces are:

  • An online navigation hierarchy for your online channel
  • An assortment for your online channel containing released products
  • A catalog associated with the online channel
  • Products assigned to nodes on the online navigation hierarchy
  • Product attributes defined and attached to nodes on your online navigation hierarchy

Once the catalog is published, it’s ready to go as far as the “headquarters” database is concerned. But in Dynamics AX / D365, it also has to be distributed — sent to the online channel database using distribution jobs.

Once the catalog is in the online channel database, the D365 Retail Server can read from it. External applications can read catalog data from the online channel database using the Retail Server APIs, a curious mix of web services that aren’t quite WCF and aren’t quite REST.

This is where the Sitecore part of the picture comes into play. Sitecore provides a sample console application that uses Sitecore’s Data Exchange Framework to fetch data from the Dynamics Retail server. It transforms it into an XML file that can then be imported into Sitecore’s Commerce Server. (Sitecore 9 also uses this catalog.xml file format, though the old commerce server components are no longer used.)

This places the product and category definitions and data into the product catalog database. This product catalog database acts as an “edge cache” that keeps just the products the site will use close to the infrastructure of the website itself. It provides some redundancy in case that communications problems occur between Sitecore and D365.

The last step in the process is the catalog data provider. Sitecore XP uses a data provider to access the product catalog database, creating virtual Sitecore items that appear within the Sitecore UI. Product and category data are not stored as “real Sitecore items” in the sense that they live in the standard Sitecore master or web databases.

Watch the arrows!

Note the color and direction of the arrows in the diagram above. The orange arrows are the ones controlled by the Sitecore console app and Data Exchange Framework. The arrows in blue are either part of standard D365 functionality or belong to extensions to the Sitecore platform. The orange arrows could have been labeled “Extract, Transform, and Load” because that’s exactly the operations performed by the catalog sync. (If I ever redraw the diagram, I might update the labels to say just that!)

The direction of the arrows are important, too. Catalog information must be sent from AX HQ to the channel database by those batch distribution jobs. If those jobs aren’t running, then no updates occur in the channel DB, and no updates will be returned in by the Retail Server API.

Once the data is available at the Retail Server, it’s up to the Sitecore catalog sync process to fetch the latest data from the Retail Server. This can be run manually or as a scheduled job, but note that there are no notifications here — D365 doesn’t push the data to Sitecore, Sitecore pulls the data when it needs to.

A sequence of batches

This is definitely not a real-time process. As you might imaging from the number of batches, pushes, and pulls shown in the diagram, it can take a significant amount of time to move an update — like a adding a new product to the catalog or setting up a new product attribute for a category — from D365 HQ into Sitecore XP. If every batch job involved executed on a 15 minute timer, it could take 45-60 minutes for that product to appear on the site. The interval could be longer depending on the size of the catalog and the number of changes made.

There’s more than one way to do it

Although Sitecore provides the catalog sync code as part of its commerce connectors, it’s really just an example or starter kit for us to use. In practice, you’ll need to modify the logic used to generate the catalog.xml file to import into Sitecore. You may also need to move the data sync process to other servers for scalability or performance reasons. Or you could replace Sitecore’s Data Exchange Framework with another ETL framework or a business process orchestration suite like BizTalk.

The connector is just a starting point for implementation, and hopefully the diagram and my explanation of it makes a good starting point for discussion with your team or client about how the process of syncing catalogs might work.

Sitecore Wildcard Items

In a recent presentation to the DC Sitecore User Group, I was surprised to learn that most of the technical attendees didn’t know about Sitecore Wildcard Items. This hidden gem has been in Sitecore since at least Sitecore 4, and allows you to resolve item data however you like. For those of you with an ASP.NET MVC background, it’s like defining a route parameter at a particular URL segment. It’s an interesting example of what you can do with an httpRequestProcessor in Sitecore’s httpBeginRequestPipeline.

The original implementation was described by John West, former CTO of Sitecore, but his original blog post is lost to the Internet. You can find a discussion of Wildcard Items on page 39 of his book, Professional Sitecore Development.

Here’s how it works: Within the Sitecore content tree, you give an item a name of “*”. This item will act as a wildcard, matching any item at that level that doesn’t already have a sibling whose name explicitly matches that URL segment.

The beauty of this is that you can treat these items as regular Sitecore items — you can set presentation details, add them to workflow, etc. — but you can map the data to other Sitecore items or even an external database. For example, Sitecore uses wildcard items to resolve products within their Sitecore Commerce Reference Storefront implementation.

To implement a Wildcard Item, you’ll need to create two things:

  1. A Sitecore Wildcard Item Resolver
  2. An optional LinkProvider, so you can generate valid URLs for these items and reference them elsewhere in the site.

If you want to take a crack at implementing this yourself, have a look at Gaurav Agarwal’s post on Resolving the Wildcard Item, which has some code snippets to get you started.

There’s also an old Sitecore Wildcard Module, which does essentially the same thing, but uses the Sitecore Rules Engine to resolve the correct item from the Sitecore content tree. See Adam Conn’s post on Wildcards and Data-Driven URLs for details. It’s been available since 2011 with Sitecore 6, but could be modified to work in modern versions of Sitecore with a little work. I found a developer that created a revised wildcard module for Sitecore 7, for example.

Also, when using ASP.NET MVC, keep in mind that sometimes other pipelines might reset the Sitecore context item after your custom wildcard item resolver finishes its work. See Kamruz Jaman’s post on the Sitecore MVC Context Item for help troubleshooting this issue.

Wildcard items are a powerful technique, and can save a lot of hassles — I’ve seen many implementations “break out” of Sitecore to use MVC routing, then hack back in a Sitecore context or session object. But wildcard resolution keeps you within  within the Sitecore stack and are a more natural approach to this problem. You can learn a lot about how Sitecore’s request handling pipelines operate by studying how it works and applying it in your own solutions.

Sitecore Commerce Catalogs at Scale

Last week, I gave a presentation to the DC Sitecore User Group on Sitecore Commerce Catalogs. It was a small crowd due to some thunderstorms in the area, and I had a tough act to follow. Phil Wickland, Sitecore MVP and author of several books on Sitecore, gave a talk on Personalization for Impact, which is worth seeing.

My talk was about how and why Sitecore imports catalog data from a PIM, using the Sitecore Commerce and Microsoft D365 integration as an example.

Here’s a link to the video:

The audio is a bit hard to hear at times, but I’ve posted my slides to slideshare here:

Blue Green Deployments

I’m surprised that in 2017 more developers and IT departments haven’t heard about blue-green deployment. But apparently that’s been a problem since at least 2010, when Martin Fowler noted that blue-green deployment hadn’t gotten the recognition it deserved. This is a DevOps pattern used widely for testing and deploying websites and webservices with minimal downtime in the cloud. Amazon Web Services now has a Code Deploy template for blue-green deployments. Microsoft lists the blue-green deployment technique first in its Azure Continuous Deployment whitepaper. It’s safe to say that blue-green deployments have graduated from an edge technique to current state-of-the-art.

The idea behind blue-green deployment strategy is simple. When you want to test a new build of your website, you create a copy of your “blue” production instance in a stand-by or “green” environment. Then you deploy the latest code to the new green environment and perform a battery of tests on it. Once the green environment passes your load, performance, security and other tests, your direct traffic from the live “blue” infrastructure to the “green” instead.

You can leave the original blue infrastructure in place temporarily, just in case you want to roll back to the previous build. You could also decommission the blue infrastructure to save operating costs. When it is time for the next release, you make a new blue environment, deploy the release to it, and perform the tests again. If the release passes, you cut over from the currently live green environment to blue.

If releases are frequent enough or if you are doing this with physical servers, you can skip the decommissioning step, and simply alternate releases between the two environments. As long as you make sure to “reset” the standby environment back to a known baseline before your deploy your latest release to it.

There are three huge advantages to performing releases this way:

  1. Your standby environment is a copy of production and fully scaled. You can run full acceptance, performance and load tests on this environment and be guaranteed that it will work the same in production — because it will be production, as soon as you direct traffic to it.
  2. Cutover to a new build is almost instantaneous, since all you need to do is redirect traffic. There should be no downtime.
  3. Rolling back to the previous is almost instantaneous, since all you need to do is redirect traffic to the previous environment. Disaster recovery is easy and your disaster recovery process is tested with every release.

Of course, there are some challenges to this approach:

  1. You do have to have a fully scaled standby environment, which will increase hardware and software costs. You can minimize these in a cloud setting, however, because that standby environment can be decommissioned when it isn’t needed.
  2. You have to invest in DevOps. If you are building and tearing down environments on a regular basis, you’ll need automated scripts for provisioning infrastructure, deploying code, and making configuration changes.
  3. Your platform should be as stateless as possible. When a cutover happens, a user’s next request will be handled by the new environment. Any state that must be maintained from one request to the next must be shared by both environments.
  4. Handling schema updates for databases must be handled differently from regular code deployments.

Of the challenges, the most resistance to the idea usually comes with the hardware and software costs, usually because companies haven’t embraced consumption pricing yet. With physical hardware or perpetual software licensing, you do wind up paying double for your production setup. But for critical applications it’s probably worth the expense.

Schema updates remain a difficult engineering challenge too, but they always have been, regardless of the deployment model.

Here’s a few other links on the blue-green deployment pattern, if you’d like to learn more:

 

Learning Software Architecture

Like many web developers, I learned the art of writing code by trial and error, rather than through formal instruction. I’d look at examples on the Internet, read forum and blog posts, and occasionally consult a book or two. This worked surprisingly well — I’ve made a career out of it, and gained a lot of knowhow through hard-won experience.

You can’t learn everything by trial and error, though. Sometimes the experiments take too long to run, or you can’t afford to have the results blow up in your face. Although I’d figured out basic software architecture principles by observing what worked about past projects and what didn’t, I wasn’t very systematic about it. But hey, I could scribble a boxes-and-arrows diagram on a whiteboard and talk folks through it, and that was enough for most web applications.

My current employer, EPAM, takes software architecture seriously. I found this out when I was invited to serve on an assessment panel for Solution Architects seeking promotion, and I developed a bad case of impostor syndrome. It turns out that there are names for the different kinds of diagrams I’d been doodling, and methods for determining which customer requirements were architecturally significant. You could subject these ideas to analysis and evaluate tradeoffs in a systematic way instead of, you know, by gut feel.

spidey-sense-lg.jpg

My spidey-sense for software project disasters is pretty well attuned by this stage in my career, so I think I was able to ask reasonable questions of our crop of upcoming architects. But I could tell that several of our candidates were winging it, and I wondered if it was obvious that I was groping my way along as well.

So I decided to do something about it. After a bit of Googling, I found out about TOGAF and the SEI, and the fact that there’s an international standard for software architecture, ISO/IEC 42010. Neat. And then I found the book Software Architecture in Practice.

SoftwareArchitectureInPractice_cover.jpg
Software Architecture in Practice

I’ve spent the last few weeks reading it through, chapter by chapter. As textbooks go, it’s well-written. It’s also (as befits a book about architecture) very well-structured, so it’s something I plan on using as a handy reference when I want to know about tactics for improving performance, or about tradeoffs between usability and security.

It’s also interesting to see a bit of what software architecture looks like in other domains. As a web developer, I don’t often need to think about the constraints imposed on real-time or embedded systems. But I do think a lot about scalability, availability, and some of the other quality attributes described in the book. It’s nice to have these cataloged, with approaches for how to address these needs and what the implications are.

I agree with the authors that the term “quality attributes” is much better than the more commonly used “non-functional requirements.” Most people seem to assume that the non-functional requirements are non-interesting and non-important, when in fact they mark the difference between unicorn and fail whale.

Later chapters address documenting and evaluating software architecture, and software architecture’s relationship to modern software development methodologies, like the various flavors of Agile.

I was really glad to have found a book that captured so much of what I’d learned in the school of hard knocks, and that offered a few new ideas and tools for me to apply to future projects. Naturally, I loaned it out to one of my coworkers and immediately recommended it to another Solution Architect I’d been mentoring at EPAM.

“Oh yes,” he said, “I know that book. It’s on the curriculum for EPAM’s Software Architecture University. That’s a good one.”

On the curriculum…? I guess I still have a way to go before I can ditch that impostor syndrome.

Hello World

computer bits

It’s taken me quite a while to set up a professional blog, despite the fact that creating one is extremely easy these days. It isn’t the effort, but the motivation.

There are two types of programmers in the world: starters and finishers. Your starters can’t wait for the next project, the next technology or the next brilliant idea to come along. That drive toward novelty makes them ideal designers, prototypers, and R&D staff. But please don’t bother them with details, edge cases, or error conditions. Don’t ask them to maintain a piece of code, or tune an operational system. There are always a million more interesting things to pursue!

I’m a finisher. That means the blinking prompt or the blank page terrifies me. Where a starter sees endless greenfields and boundless opportunities, I see a beautiful, elegant white starkness about to be marred by my amateur scribblings.

So I didn’t want to start a new blog. What I really wanted to do was rebuild my old blog. The one from my ill-fated attempt to start a software company during the Global Financial Crisis. There are good articles there, posts I’m proud of writing. I’m sure I could salvage those, update them, refactor them, improve them… yes, I’m a finisher all right.

But sometimes you do need to start over, let go of the baggage, and begin again.

Hello, world.