{"id":44617,"date":"2021-07-02T09:00:38","date_gmt":"2021-07-02T13:00:38","guid":{"rendered":"https:\/\/sdtimes.com\/?p=44617"},"modified":"2021-07-06T09:43:48","modified_gmt":"2021-07-06T13:43:48","slug":"microservices-at-scale-a-complexity-management-issue","status":"publish","type":"post","link":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/","title":{"rendered":"Microservices at scale: A complexity management issue"},"content":{"rendered":"

The benefits of microservices have been touted for years, and their popularity is clear when you consider the explosion in use of technologies, such as Kubernetes, over the last few years. It seems that based on the number of successful implementations, that popularity is deserved.\u00a0<\/span><\/p>\n

For example, according to a <\/span>2020 survey<\/span><\/a> by O\u2019Reilly, 92% of respondents reported some success with microservices, with 54% describing their experience as \u201cmostly successful\u201d and under 10% describing a \u201ccomplete success.\u201d\u00a0<\/span><\/p>\n

But building and managing all of these smaller units containing code adds a lot of complexity to the equation, and it\u2019s important to get it right to achieve those successes. Developers can create as many of these microservices as they need, but it\u2019s important to have good management over those, especially as the number of microservices increases.\u00a0<\/span><\/p>\n

According to Mike Tria, head of platform engineering at <\/span>Atlassian<\/span><\/a>, there are two schools of thought when it comes to managing proliferation of microservices. One idea is just to keep the number of microservices to a minimum so that developers don\u2019t have to think about things like scale and security.<\/span><\/p>\n

\u201cEvery time they’re spinning up a new microservice they try to keep them small,” Tria said. “That works fine for a limited number of use cases and specific domains, because what will happen is those microservices will become large. You’ll end up with, as they say, a distributed monolith.”<\/span><\/p>\n

The other option is to let developers spin up microservices whenever they want, which requires some additional considerations, according to Tria. Incorporating automation into the process is the key to ensuring this can be done successfully.\u00a0<\/span><\/p>\n

\u201cIf every time you’re building some new microservice, you have to think about all of those concerns about security, where you’re going to host it, what’s the IAM user and role that you need access to, what other services can it talk to\u2014If developers need to figure all that stuff out every time, then you’re going to have a real scaling challenge. So the key is through automating those capabilities away, make it such that you could spin up microservices without having to do all of those things,\u201d said Tria.<\/span><\/p>\n

According to Tria, the main benefits of automation are scalability, reliability, and speed. Automation provides the ability to scale because new microservices can be created without burdening developers. Second, reliability is encapsulated in each microservice, which means the whole system becomes more reliable. Finally, nimbleness and speed are gained because each team is able to build microservices at their own pace.\u00a0<\/span><\/p>\n

At Atlassian, they built their own tool for managing their microservices, but Tria recommends starting small with some off-the-shelf tool. This will enable you to get to know your microservices and figure out your needs, rather than trying to predict your needs and buying some expensive solution that might have features you don\u2019t need or is missing features you do.\u00a0<\/span><\/p>\n

\u201cIt’s way too easy with microservices to overdo it right at the start,\u201d Tria said. \u201cHonestly, I think that’s the mistake more companies make getting started. They go too heavy on microservices, and right at the start they throw too much on the compute layer, too much service mesh, Kubernetes, proxy, etc. People go too, too far. And so what happens is they get bogged down in process, in bureaucracy, in too much configuration when people just want to build features really, really fast.\u201d<\/span><\/p>\n

In addition to incorporating automation, there are a number of other ways to ensure success with scaling microservices.<\/span><\/p>\n

    \n
  1. Incorporate security\u00a0<\/b><\/li>\n<\/ol>\n

    Because of the nature of microservices, they tend to evoke additional security concerns, according to Tzury Bar Yochay, CTO and co-founder of application security company <\/span>Reblaze<\/span><\/a>. Traditional software architectures use a castle-and-moat approach with a limited number of ingress points, which makes it possible to just secure the perimeter with a security solution.\u00a0<\/span><\/p>\n

    Microservices, however, are each independent entities that are Internet-facing. \u201cEvery microservice that can accept incoming connections from the outside world is potentially exposed to threats within the incoming traffic stream, and it has other security requirements as well (such as integrating with authentication and authorization services). These requirements are much more challenging than the ones typically faced by traditional applications,\u201d said Bar Yochay.\u00a0<\/span><\/p>\n

    According to Bar Yochay, new and better approaches are constantly being invented to secure cloud native architectures. For example, service meshes can build traffic filtering right into the mesh itself, and block hostile requests before the microservice receives them. Service meshes are an addition to microservices architectures that enable services to communicate with each other. In addition to added security, they offer benefits like load balancing, discovery, failure recovery, metrics, and more.<\/span><\/p>\n

    These advantages of service meshes will seem greater when they are deployed across a larger number of microservices, but smaller architectures can also benefit from them, according to Bar Yochay.\u00a0<\/span><\/p>\n

    Of course, the developers in charge of these microservices are also responsible for security, but there are a lot of challenges in their way. For example, there can often be friction between developers and security teams because developers want to add new features, while security wants to slow things down and be more cautious. \u201cAs more apps and services are being maintained, there are more opportunities for these cultural issues to arise,\u201d Bar Yochay said.\u00a0<\/span><\/p>\n

    In order to alleviate the friction between developers and security, Bar Yochay recommends investing in developer-friendly security tools for microservices. According to him, there are many solutions on the market today that allow for security to be built directly into containers or into service meshes. In addition, security vendors are also advancing their use of technology, such as by applying machine learning to behavioral analysis and threat detection.\u00a0<\/span><\/p>\n

      \n
    1. Make sure your microservices don\u2019t get too big<\/b><\/li>\n<\/ol>\n

      \u201cWe’ve seen microservices turn into monolithic microservices and you get kind of a macroservice pretty quickly if you don\u2019t keep and maintain it and keep on top of those things,\u201d said Bob Quillin, chief ecosystem officer at <\/span>vFunction<\/span><\/a>, a company that helps migrate applications to microservices architectures.\u00a0<\/span><\/p>\n

      Dead code is one thing that can quickly lead to microservices that are bigger than they need to be.\u00a0 \u201cThere is a lot of software where you’re not quite sure what it does,\u201d said Quillin. \u201cYou and your team are maintaining it because it’s safer to keep it than to get rid of it. And that’s what I think that eventually creates these larger and larger microservices that become almost like monoliths themselves.\u201d\u00a0<\/span><\/p>\n

        \n
      1. Be clear about ownership<\/b><\/li>\n<\/ol>\n

        Tria recommends that rather than having individuals own a microservice, it\u2019s best to have a team own it.\u00a0<\/span><\/p>\n

        \u201cLike in the equivalent of it takes a village, it takes a team to keep a microservice healthy, to upgrade it to make sure it’s checking in on its dependencies, on its rituals, around things like reliability and SLO. So I think the good practices have a team on it,\u201d said Tria.\u00a0<\/span><\/p>\n

        For example, Atlassian has about 3,000 developers and roughly 1,400 microservices. Assuming teams of five to 10 developers, this works out to every team owning two or three microservices, on average, Tria explained.<\/span><\/p>\n

          \n
        1. Don\u2019t get too excited about the polyglot nature of microservices<\/b><\/li>\n<\/ol>\n

          One of the benefits of microservices\u2014being polyglot\u2014is also one of the downsides. According to Tria, one of Atlassian\u2019s initial attractions to microservices was that they could be written using any language.\u00a0<\/span><\/p>\n

          \u201cWe had services written in Go, Kotlin, Java, Python, Scala, you name it. There’s languages I’ve never even heard of that we had microservices written in, which from an autonomy perspective and letting those teams run was really great. Individual teams could all run off on their own and go and build their services,\u201d said Tria.<\/span><\/p>\n

          However this flexibility led to a language and service transferability problem across teams. In addition, microservices written in a particular language needed developers familiar with that language to maintain them. Eventually Tria\u2019s team realized they needed to standardize down to two or three languages.<\/span><\/p>\n

          Another recommendation Tria has based on his team\u2019s experience is to understand the extent of how much the network can do for you. He recommends investing in things like service discovery early on. \u201c[At the start] all of our services found each other just through DNS. You would reach another service through a domain name. What that did is it put a lot of pressure on our own internal networking systems, specifically DNS,\u201d said Tria.\u00a0<\/span><\/p>\n

          Figuring out a plan for microservices automation at Atlassian\u00a0<\/b><\/h5>\n

          Atlassian’s Tria is a proponent of incorporating automation into microservices management, but his team had to learn that the hard way.\u00a0<\/span><\/p>\n

          According to Tria, when Atlassian first started using microservices back in early 2016, it had about 50 to 60 microservices total and all of the microservices were written on a Confluence page. They listed every microservice, who owned it, whether it had passed SOC2 compliance yet, and the on-call contact for that microservice.<\/span><\/p>\n

          \u201cI remember at that time we had this long table, and we kept adding columns to the table and the columns were things like when was the last time a performance test was run against it, or another column was what are all the services that depend on it? What are all the services it depends on? What reliability tier is it for uptime? Is it tier one where it needs very high uptime, tier two where it needs less? And we just kept expanding those columns.\u201d<\/span><\/p>\n

          Once the table hit 100 columns, the team realized that wouldn\u2019t be maintainable for very long. Instead, they created a new project to take the capabilities they had in Confluence and turn them into a tool.<\/span><\/p>\n

          \u201cThe idea was we would have a system where when you build a microservice, the system essentially registers it into a central repository that we have,\u201d said Tria. \u201cThat repository has a list of all of our services. It has the owners, it has the reliability, tiers, and anyone within the company can just search and look up a surface and we made the tool pretty plugable so that when we have new capabilities that we’re adding to our service.\u201d\u00a0<\/span><\/p>\n

           <\/p>\n","protected":false},"excerpt":{"rendered":"

          The benefits of microservices have been touted for years, and their popularity is clear when you consider the explosion in use of technologies, such as Kubernetes, over the last few years. It seems that based on the number of successful implementations, that popularity is deserved.\u00a0 For example, according to a 2020 survey by O\u2019Reilly, 92% … continue reading<\/a><\/p>\n","protected":false},"author":752,"featured_media":44618,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"om_disable_all_campaigns":false,"cybocfi_hide_featured_image":"","footnotes":"","_links_to":"","_links_to_target":""},"categories":[1],"tags":[318,5246,15781,15782],"coauthors":[11687],"acf":[],"yoast_head":"\nMicroservices at scale: A complexity management issue - SD Times<\/title>\n<meta name=\"description\" content=\"Microservices have a number of benefits, but it\u2019s important to manage their complexity as well in order to have a successful implementation.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Microservices at scale: A complexity management issue - SD Times\" \/>\n<meta property=\"og:description\" content=\"Microservices have a number of benefits, but it\u2019s important to manage their complexity as well in order to have a successful implementation.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/\" \/>\n<meta property=\"og:site_name\" content=\"SD Times\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/SDTimesD2\" \/>\n<meta property=\"article:published_time\" content=\"2021-07-02T13:00:38+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-07-06T13:43:48+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"660\" \/>\n\t<meta property=\"og:image:height\" content=\"371\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Jenna Barron\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@sdtimes\" \/>\n<meta name=\"twitter:site\" content=\"@sdtimes\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Jenna Barron\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/\"},\"author\":{\"name\":\"Jenna Barron\",\"@id\":\"https:\/\/sdtimes.com\/#\/schema\/person\/f2524e55ae19da07ea3613577da9f786\"},\"headline\":\"Microservices at scale: A complexity management issue\",\"datePublished\":\"2021-07-02T13:00:38+00:00\",\"dateModified\":\"2021-07-06T13:43:48+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/\"},\"wordCount\":1695,\"publisher\":{\"@id\":\"https:\/\/sdtimes.com\/#organization\"},\"image\":{\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg\",\"keywords\":[\"Atlassian\",\"microservices\",\"reblaze\",\"vfunction\"],\"articleSection\":[\"Latest News\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/\",\"url\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/\",\"name\":\"Microservices at scale: A complexity management issue - SD Times\",\"isPartOf\":{\"@id\":\"https:\/\/sdtimes.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg\",\"datePublished\":\"2021-07-02T13:00:38+00:00\",\"dateModified\":\"2021-07-06T13:43:48+00:00\",\"description\":\"Microservices have a number of benefits, but it\u2019s important to manage their complexity as well in order to have a successful implementation.\",\"breadcrumb\":{\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#primaryimage\",\"url\":\"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg\",\"contentUrl\":\"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg\",\"width\":660,\"height\":371},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/sdtimes.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Microservices at scale: A complexity management issue\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/sdtimes.com\/#website\",\"url\":\"https:\/\/sdtimes.com\/\",\"name\":\"SD Times\",\"description\":\"Software Development News\",\"publisher\":{\"@id\":\"https:\/\/sdtimes.com\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/sdtimes.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/sdtimes.com\/#organization\",\"name\":\"SD Times\",\"url\":\"https:\/\/sdtimes.com\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/sdtimes.com\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/sdtimes.com\/wp-content\/uploads\/2014\/05\/deafaultlogo.png\",\"contentUrl\":\"https:\/\/sdtimes.com\/wp-content\/uploads\/2014\/05\/deafaultlogo.png\",\"width\":225,\"height\":90,\"caption\":\"SD Times\"},\"image\":{\"@id\":\"https:\/\/sdtimes.com\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/SDTimesD2\",\"https:\/\/x.com\/sdtimes\",\"https:\/\/www.linkedin.com\/company\/sdtimes\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/sdtimes.com\/#\/schema\/person\/f2524e55ae19da07ea3613577da9f786\",\"name\":\"Jenna Barron\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/sdtimes.com\/#\/schema\/person\/image\/b4be3423b187642936e62f121111345e\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/b128943929626cdcafccbac86bd306f9?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/b128943929626cdcafccbac86bd306f9?s=96&d=mm&r=g\",\"caption\":\"Jenna Barron\"},\"description\":\"Jenna Barron is News Editor of SD Times.\",\"url\":\"https:\/\/sdtimes.com\/author\/jennifer-sargent\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Microservices at scale: A complexity management issue - SD Times","description":"Microservices have a number of benefits, but it\u2019s important to manage their complexity as well in order to have a successful implementation.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/","og_locale":"en_US","og_type":"article","og_title":"Microservices at scale: A complexity management issue - SD Times","og_description":"Microservices have a number of benefits, but it\u2019s important to manage their complexity as well in order to have a successful implementation.","og_url":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/","og_site_name":"SD Times","article_publisher":"https:\/\/www.facebook.com\/SDTimesD2","article_published_time":"2021-07-02T13:00:38+00:00","article_modified_time":"2021-07-06T13:43:48+00:00","og_image":[{"width":660,"height":371,"url":"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg","type":"image\/jpeg"}],"author":"Jenna Barron","twitter_card":"summary_large_image","twitter_creator":"@sdtimes","twitter_site":"@sdtimes","twitter_misc":{"Written by":"Jenna Barron","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#article","isPartOf":{"@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/"},"author":{"name":"Jenna Barron","@id":"https:\/\/sdtimes.com\/#\/schema\/person\/f2524e55ae19da07ea3613577da9f786"},"headline":"Microservices at scale: A complexity management issue","datePublished":"2021-07-02T13:00:38+00:00","dateModified":"2021-07-06T13:43:48+00:00","mainEntityOfPage":{"@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/"},"wordCount":1695,"publisher":{"@id":"https:\/\/sdtimes.com\/#organization"},"image":{"@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#primaryimage"},"thumbnailUrl":"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg","keywords":["Atlassian","microservices","reblaze","vfunction"],"articleSection":["Latest News"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/","url":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/","name":"Microservices at scale: A complexity management issue - SD Times","isPartOf":{"@id":"https:\/\/sdtimes.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#primaryimage"},"image":{"@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#primaryimage"},"thumbnailUrl":"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg","datePublished":"2021-07-02T13:00:38+00:00","dateModified":"2021-07-06T13:43:48+00:00","description":"Microservices have a number of benefits, but it\u2019s important to manage their complexity as well in order to have a successful implementation.","breadcrumb":{"@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#primaryimage","url":"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg","contentUrl":"https:\/\/sdtimes.com\/wp-content\/uploads\/2021\/07\/second-jukebox.jpg","width":660,"height":371},{"@type":"BreadcrumbList","@id":"https:\/\/sdtimes.com\/microservices\/microservices-at-scale-a-complexity-management-issue\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/sdtimes.com\/"},{"@type":"ListItem","position":2,"name":"Microservices at scale: A complexity management issue"}]},{"@type":"WebSite","@id":"https:\/\/sdtimes.com\/#website","url":"https:\/\/sdtimes.com\/","name":"SD Times","description":"Software Development News","publisher":{"@id":"https:\/\/sdtimes.com\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/sdtimes.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/sdtimes.com\/#organization","name":"SD Times","url":"https:\/\/sdtimes.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/sdtimes.com\/#\/schema\/logo\/image\/","url":"https:\/\/sdtimes.com\/wp-content\/uploads\/2014\/05\/deafaultlogo.png","contentUrl":"https:\/\/sdtimes.com\/wp-content\/uploads\/2014\/05\/deafaultlogo.png","width":225,"height":90,"caption":"SD Times"},"image":{"@id":"https:\/\/sdtimes.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/SDTimesD2","https:\/\/x.com\/sdtimes","https:\/\/www.linkedin.com\/company\/sdtimes\/"]},{"@type":"Person","@id":"https:\/\/sdtimes.com\/#\/schema\/person\/f2524e55ae19da07ea3613577da9f786","name":"Jenna Barron","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/sdtimes.com\/#\/schema\/person\/image\/b4be3423b187642936e62f121111345e","url":"https:\/\/secure.gravatar.com\/avatar\/b128943929626cdcafccbac86bd306f9?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/b128943929626cdcafccbac86bd306f9?s=96&d=mm&r=g","caption":"Jenna Barron"},"description":"Jenna Barron is News Editor of SD Times.","url":"https:\/\/sdtimes.com\/author\/jennifer-sargent\/"}]}},"_links":{"self":[{"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/posts\/44617"}],"collection":[{"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/users\/752"}],"replies":[{"embeddable":true,"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/comments?post=44617"}],"version-history":[{"count":4,"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/posts\/44617\/revisions"}],"predecessor-version":[{"id":44640,"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/posts\/44617\/revisions\/44640"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/media\/44618"}],"wp:attachment":[{"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/media?parent=44617"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/categories?post=44617"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/tags?post=44617"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/sdtimes.com\/wp-json\/wp\/v2\/coauthors?post=44617"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}