{"id":1074,"date":"2019-11-29T14:50:42","date_gmt":"2019-11-29T13:50:42","guid":{"rendered":"https:\/\/blog.besharp.it\/?p=1074"},"modified":"2021-03-24T17:21:20","modified_gmt":"2021-03-24T16:21:20","slug":"writing-microservices-the-right-way-2","status":"publish","type":"post","link":"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/","title":{"rendered":"Writing microservices, the right way."},"content":{"rendered":"<p><span style=\"font-weight: 400;\">In this final article of our 3 part analysis (you can read here <a href=\"https:\/\/blog.besharp.it\/en\/break-the-monolith-into-microservices-like-a-pro-our-guide-to-a-almost-seamless-transition\/\" target=\"_blank\" rel=\"noopener noreferrer\">the first part<\/a> and the <a href=\"https:\/\/blog.besharp.it\/en\/turning-monoliths-into-microservices-tips-and-tricks-2\/\" target=\"_blank\" rel=\"noopener noreferrer\">second part<\/a>) on how to break down a Monolithic application we will exploit some insights on how a microservice can be created from an existing one, what can we do to solve problems related to legacy code with high toxicity and in general what rules can be applied to decide when to migrate to microservices. <\/span><\/p>\n<p><span style=\"font-weight: 400;\">Let\u2019s get started!<\/span><\/p>\n<h2><span style=\"font-weight: 400;\">HOW TO WRITE A MICROSERVICE<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">In practice when we want to create a microservice we have two development choices:\u00a0<\/span><\/p>\n<ol>\n<li><b>Code porting<\/b><\/li>\n<li><b>Writing new code<\/b><span style=\"font-weight: 400;\">.<\/span><\/li>\n<\/ol>\n<h3><span style=\"font-weight: 400;\">CODE PORTING<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">At first Code porting may seems a logical solution, mainly because the Dev team has a <\/span><b>cognitive bias<\/b><span style=\"font-weight: 400;\"> towards its own code BUT it can conceal some critical aspects that have <\/span><b>high cost<\/b><span style=\"font-weight: 400;\"> and <\/span><b>low value<\/b><span style=\"font-weight: 400;\">:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">There is a <\/span><b>large amount of boilerplate code that deals with environmental dependencies<\/b><span style=\"font-weight: 400;\">, such as accessing application configuration at runtime, accessing data stores, caching, and is built with old frameworks. This can be safely rewritten because the microservice will surely approach things differently in a different environment.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Existing capabilities may be built around uncertain domain concepts. This results in undergoing a big restructuring.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">An old legacy code that has gone through many iterations of change could have high <\/span><b>code toxicity<\/b><span style=\"font-weight: 400;\"> and low value for reuse.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">So to sum it up always verify if the code you want to reuse has <\/span><b>High Intellectual complexity value <\/b><span style=\"font-weight: 400;\">and <\/span><b>Low Toxicity <\/b><span style=\"font-weight: 400;\">in terms of stickiness and technical debt<\/span><b>: this is a good candidate<\/b><span style=\"font-weight: 400;\"> for code extraction and reuse. An example can be a complex recommendation system for a customer with a lot of interactions, personalizations, machine learning algorithms and so on.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">WRITING NEW CODE<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">Writing new code is a very good approach in the sense that enforce the Dev team and the Business team to review the core logic of the functionality they want to rewrite and thus:<\/span><\/p>\n<ol>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Approach it with a clear understanding of the domain and with a lot more experience, resulting most probably in a smaller tidier solution.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Search for a <\/span><b>technology refresh<\/b><span style=\"font-weight: 400;\">, implementing the new service with a programming language and technology stack that is more modern and surely more suitable.<\/span><\/li>\n<\/ol>\n<p><span style=\"font-weight: 400;\">This approach can also be beneficial in the sense that the microservice will probably <\/span><b>be delivered faster<\/b><span style=\"font-weight: 400;\">. An example can be <\/span><b>CRUD operations<\/b><span style=\"font-weight: 400;\"> because they don\u2019t contain any intellectual properties and may depend on new technologies and frameworks.<\/span><\/p>\n<h2><span style=\"font-weight: 400;\">HOW TO APPROACH STICKY CODE INSIDE THE MONOLITH<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">After rewriting most of your application with microservices, you\u2019ll be faced with the remaining of the legacy code for which the domain knowledge is uncertain. In this case, extracting your code and also your <\/span><b>data from the data layer<\/b><span style=\"font-weight: 400;\"> can be difficult although we would recommend approaching this part of your infrastructure as fast as possible because decoupling your entire data layer is by far the most important part of your job in migrating towards a microservice-ecosystem.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">We can safely say that if your data is somehow coupled you don\u2019t have a real microservice.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">A technique that can help you in this process is called <\/span><b>Reification, <\/b><span style=\"font-weight: 400;\">which is a process to redefine context boundaries through the decomposition of uncertain part of logical domain by deconstructing legacy code in well separated and simpler structures which infer from more defined data models as well.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">You can also use <\/span><b>dependency and structural code analysis<\/b><span style=\"font-weight: 400;\"> tools such as <\/span><a href=\"http:\/\/structure101.com\/\"><b>Structure101<\/b><\/a><span style=\"font-weight: 400;\"> to identify the most coupling and constraining factor capabilities in the monolith.<\/span><\/p>\n<h2><span style=\"font-weight: 400;\">HOW AWS CAN HELP WITH ITS SERVICES<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">AWS can really help in giving you the instruments for an easy transition to a microservice approach, at least from an infrastructural point of view.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">BUILDING, TESTING AND DEPLOYING LEVEL:<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">CodeCommit, CodeBuild, and CodeDeploy.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">MONITORING AND DEBUGGING:<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">CloudWatch, ElasticSearch with Kibana integration, X-Ray.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">DEPLOY AND RECOVERY:<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">CloudFormation.<\/span><\/p>\n<h3><span style=\"font-weight: 400;\">LOGIC:<\/span><\/h3>\n<p><span style=\"font-weight: 400;\">AWS Lambda Functions and Layers, ECS and AWS Step Functions that coordinate workers.<\/span><\/p>\n<h2><span style=\"font-weight: 400;\">WHY YOU WOULD AVOID MICROSERVICE APPROACH INSTEAD<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">We talked a lot about how good microservices are and how many benefits you would have by implementing this paradigm but there are some situations in which you may reconsider the idea of switching to microservices.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">For example, if you have a small project that will probably not evolve in the future the effort of decoupling it may not be worth as making microservices is, as we have seen, not a simple task at all.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">If the application serves a <\/span><b>mission-critical function<\/b><span style=\"font-weight: 400;\">, such as <\/span><b>maintaining an irreplaceable legacy database<\/b><span style=\"font-weight: 400;\">, you are maybe not likely to be able to replace it entirely in a few years, in other words, your strategic team can\u2019t afford <\/span><b>a long-term strategy<\/b><span style=\"font-weight: 400;\">.<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Some applications by <\/span><b>their nature <\/b><span style=\"font-weight: 400;\">require <\/span><b>tight integration<\/b><span style=\"font-weight: 400;\"> between <\/span><b>individual components and services<\/b><span style=\"font-weight: 400;\">. This is often true, for example, for applications that <\/span><b>process rapid streams of real-time data<\/b><span style=\"font-weight: 400;\">. Any added layers of communication between services <\/span><b>may slow real-time processing<\/b> <b>down<\/b><span style=\"font-weight: 400;\">.<\/span><\/p>\n<h2><span style=\"font-weight: 400;\">CONCLUSIONS<\/span><\/h2>\n<p><span style=\"font-weight: 400;\">To sum up what we have said up to this point let us reassume the most important key points of our discussion:<\/span><\/p>\n<ul>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Understand your technological target as clearly as possible to make your transition as fitting as possible<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Make your transitioning steps as <\/span><b>atomic<\/b><span style=\"font-weight: 400;\"> as possible and always remember the <\/span><b>three steps approach<\/b><span style=\"font-weight: 400;\"> in the <\/span><b>Strangler<\/b><span style=\"font-weight: 400;\"> Technique, especially to <\/span><b>decommission<\/b><span style=\"font-weight: 400;\"> old codebase once it is not used anymore.<\/span><\/li>\n<li style=\"font-weight: 400;\"><b>Define which microservices to implement as first <\/b><span style=\"font-weight: 400;\">to start working with the right attitude and to see the results of your work as soon as possible. Also, this approach is very good to start<\/span><b> developing experience in the migration process<\/b><span style=\"font-weight: 400;\"> before attacking more difficult parts of your codebase<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Use the <\/span><b>Reify<\/b><span style=\"font-weight: 400;\"> Technique extensively to help you redefine your most obscure code parts<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Always <\/span><b>strive to isolate meaningful parts of your data<\/b><span style=\"font-weight: 400;\"> in order to split it in per-microservice database (if the microservice needs it, it can be stateless). This step is very crucial.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Always check for the<\/span><b> microservice to live up to its atomic property of isolation<\/b><span style=\"font-weight: 400;\"> both at infrastructure and logic level.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Don\u2019t be afraid to make <\/span><b>extensive use of tools such as Structure101 or in general of AWS services<\/b><span style=\"font-weight: 400;\"> to help you in the migration process.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Try to <\/span><b>rewrite your microservices from scratch as much as possible<\/b><span style=\"font-weight: 400;\"> (apart from code with <\/span><b>high intellectual value<\/b><span style=\"font-weight: 400;\">), to involve your strategic team more and to define a better approach to solve a problem. Rewriting your code also avoid bringing along eventual technical debt.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Remember that in order to start your microservices migration journey your DevTeam and in general your company must adhere to the DevOps Culture and must be in possession of some prerequisite experience.<\/span><\/li>\n<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Finally, remember that there are some situations in which trying to migrate to a microservice approach may not be the ideal solution for cases like real-time applications in which communication of layers must be as fast as possible.<\/span><\/li>\n<\/ul>\n<p><span style=\"font-weight: 400;\">With this summary we end our long journey on how we can deconstruct a big monolithic application in several microservices in order to maintain it better, develop, deploy and eventually recovery it very fast, thus focusing much more on your business value. We hope you enjoyed reading this far.\u00a0<\/span><\/p>\n<p><span style=\"font-weight: 400;\">Satisfied? Feel free to <a href=\"https:\/\/www.besharp.it\/en\/contact-us\/\" target=\"_blank\" rel=\"noopener noreferrer\">contact us<\/a>, we will be happy to have a chat!<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"<p>In this final article of our 3 part analysis (you can read here the first part and the second part) [&hellip;]<\/p>\n","protected":false},"author":6,"featured_media":1039,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[482],"tags":[310,306],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v21.9.1 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Writing microservices, the right way. - Proud2beCloud Blog<\/title>\n<meta name=\"description\" content=\"How to write microservices, the right way: our guide to deconstruct monolithic applications into microservices.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Writing microservices, the right way.\" \/>\n<meta property=\"og:description\" content=\"How to write microservices, the right way: our guide to deconstruct monolithic applications into microservices.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/\" \/>\n<meta property=\"og:site_name\" content=\"Proud2beCloud Blog\" \/>\n<meta property=\"article:published_time\" content=\"2019-11-29T13:50:42+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-03-24T16:21:20+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/blog.besharp.it\/wp-content\/uploads\/2019\/10\/blogharottoilcazzo-21.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1668\" \/>\n\t<meta property=\"og:image:height\" content=\"1251\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Alessandro Gaggia\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:title\" content=\"Writing microservices, the right way.\" \/>\n<meta name=\"twitter:description\" content=\"How to write microservices, the right way: our guide to deconstruct monolithic applications into microservices.\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/blog.besharp.it\/wp-content\/uploads\/2019\/10\/blogharottoilcazzo-21.png\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Alessandro Gaggia\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/\",\"url\":\"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/\",\"name\":\"Writing microservices, the right way. - Proud2beCloud Blog\",\"isPartOf\":{\"@id\":\"https:\/\/blog.besharp.it\/#website\"},\"datePublished\":\"2019-11-29T13:50:42+00:00\",\"dateModified\":\"2021-03-24T16:21:20+00:00\",\"author\":{\"@id\":\"https:\/\/blog.besharp.it\/#\/schema\/person\/f27fc12d10867c6ea6e0158ce4dd8924\"},\"description\":\"How to write microservices, the right way: our guide to deconstruct monolithic applications into microservices.\",\"breadcrumb\":{\"@id\":\"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/blog.besharp.it\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Writing microservices, the right way.\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/blog.besharp.it\/#website\",\"url\":\"https:\/\/blog.besharp.it\/\",\"name\":\"Proud2beCloud Blog\",\"description\":\"il blog di beSharp\",\"alternateName\":\"Proud2beCloud Blog\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/blog.besharp.it\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/blog.besharp.it\/#\/schema\/person\/f27fc12d10867c6ea6e0158ce4dd8924\",\"name\":\"Alessandro Gaggia\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/blog.besharp.it\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/f58dc28050f26409e22ab60346d06220?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/f58dc28050f26409e22ab60346d06220?s=96&d=mm&r=g\",\"caption\":\"Alessandro Gaggia\"},\"description\":\"Head of software development di beSharp, Full-Stack developer, mi occupo di garantire lo stato dell\u2019arte di tutta la nostra codebase. Scrivo codice in quasi ogni linguaggio, ma prediligo Typescript. Respiro Informatica, Game design, Cinema, Fumetti e buona cucina. Disegno per passione!\",\"url\":\"https:\/\/blog.besharp.it\/author\/alessandro-gaggia\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Writing microservices, the right way. - Proud2beCloud Blog","description":"How to write microservices, the right way: our guide to deconstruct monolithic applications into microservices.","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:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/","og_locale":"en_US","og_type":"article","og_title":"Writing microservices, the right way.","og_description":"How to write microservices, the right way: our guide to deconstruct monolithic applications into microservices.","og_url":"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/","og_site_name":"Proud2beCloud Blog","article_published_time":"2019-11-29T13:50:42+00:00","article_modified_time":"2021-03-24T16:21:20+00:00","og_image":[{"width":1668,"height":1251,"url":"https:\/\/blog.besharp.it\/wp-content\/uploads\/2019\/10\/blogharottoilcazzo-21.png","type":"image\/png"}],"author":"Alessandro Gaggia","twitter_card":"summary_large_image","twitter_title":"Writing microservices, the right way.","twitter_description":"How to write microservices, the right way: our guide to deconstruct monolithic applications into microservices.","twitter_image":"https:\/\/blog.besharp.it\/wp-content\/uploads\/2019\/10\/blogharottoilcazzo-21.png","twitter_misc":{"Written by":"Alessandro Gaggia","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/","url":"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/","name":"Writing microservices, the right way. - Proud2beCloud Blog","isPartOf":{"@id":"https:\/\/blog.besharp.it\/#website"},"datePublished":"2019-11-29T13:50:42+00:00","dateModified":"2021-03-24T16:21:20+00:00","author":{"@id":"https:\/\/blog.besharp.it\/#\/schema\/person\/f27fc12d10867c6ea6e0158ce4dd8924"},"description":"How to write microservices, the right way: our guide to deconstruct monolithic applications into microservices.","breadcrumb":{"@id":"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/blog.besharp.it\/writing-microservices-the-right-way-2\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/blog.besharp.it\/"},{"@type":"ListItem","position":2,"name":"Writing microservices, the right way."}]},{"@type":"WebSite","@id":"https:\/\/blog.besharp.it\/#website","url":"https:\/\/blog.besharp.it\/","name":"Proud2beCloud Blog","description":"il blog di beSharp","alternateName":"Proud2beCloud Blog","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/blog.besharp.it\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/blog.besharp.it\/#\/schema\/person\/f27fc12d10867c6ea6e0158ce4dd8924","name":"Alessandro Gaggia","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/blog.besharp.it\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/f58dc28050f26409e22ab60346d06220?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/f58dc28050f26409e22ab60346d06220?s=96&d=mm&r=g","caption":"Alessandro Gaggia"},"description":"Head of software development di beSharp, Full-Stack developer, mi occupo di garantire lo stato dell\u2019arte di tutta la nostra codebase. Scrivo codice in quasi ogni linguaggio, ma prediligo Typescript. Respiro Informatica, Game design, Cinema, Fumetti e buona cucina. Disegno per passione!","url":"https:\/\/blog.besharp.it\/author\/alessandro-gaggia\/"}]}},"_links":{"self":[{"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/posts\/1074"}],"collection":[{"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/comments?post=1074"}],"version-history":[{"count":0,"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/posts\/1074\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/media\/1039"}],"wp:attachment":[{"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/media?parent=1074"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/categories?post=1074"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.besharp.it\/wp-json\/wp\/v2\/tags?post=1074"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}