{"id":11310,"date":"2013-06-23T21:20:00","date_gmt":"2013-06-23T20:20:00","guid":{"rendered":"http:\/\/zygm0nt.github.com\/blog\/2013\/06\/23\/zookeeper-curator"},"modified":"2023-03-20T15:19:01","modified_gmt":"2023-03-20T14:19:01","slug":"zookeeper-curator-distributed-sync","status":"publish","type":"post","link":"https:\/\/touk.pl\/blog\/2013\/06\/23\/zookeeper-curator-distributed-sync\/","title":{"rendered":"Zookeeper + Curator = Distributed sync"},"content":{"rendered":"

An application developed for one of my recent projects at TouK involved multiple servers. There was a requirement to ensure failover for the system\u2019s components. Since I had already a few separate components I didn\u2019t want to add more of that, and since there already was a Zookeeper ensemble running – required by one of the services, I\u2019ve decided to go that way with my solution.<\/p>\n

<\/p>\n

What is Zookeeper?<\/h2>\n

Just a crude distributed synchronization framework. However, it implements Paxos-style algorithms (http:\/\/en.wikipedia.org\/wiki\/Paxos_(computer_science)<\/a><\/span>) to ensure no split-brain scenarios would occur. This is quite an important feature, since I don\u2019t have to care about that kind of problems while using this app. You just need to create an ensemble of a couple of its instances – to ensure high availability. It is basically a virtual filesystem, with files, directories and stuff. One could ask why another filesystem? Well this one is a rather special one, especially for distributed systems. The reason why creating all the locking algorithms on top of Zookeeper is easy is its Ephemeral Nodes – which are just files that exist as long as connection for them exists. After it disconnects – such file disappears.<\/p>\n

With such paradigms in place it\u2019s fairly easy to create some high level algorithms for synchronization.<\/p>\n

Having that in place, it\u00a0can\u00a0safely integrate multiple services ensuring loose coupling in a distributed way.<\/p>\n

Zookeeper from developer\u2019s POV<\/h2>\n

With all the base services for Zookeeper started, it seems there is nothing else, than just connect to it and start implementing necessary algorithms. Unfortunately, the API is quite basic and offers files and directories abstractions with the addition of different node type (file types) – ephemeral and sequence. It is also possible to watch a node for changes.<\/p>\n

Using bare Zookeeper is hard!<\/h2>\n

Creating connections is tedious – and there is lots of things to take care of. Handling an established connection is hard – when establishing connection to ensemble, it\u2019s necessary to negotiate a session also. During the whole process a number of exceptions can occur – these are \u201crecoverable\u201d
\nexceptions, that can be gracefully handled and not break the connection.<\/p>\n

So, Zookeeper API is hard. Even if one is proficient with that API, then there come recipes. The reason for using Zookeeper is to be able to implement some more sophisticated algorithms on top of it. Unfortunately those aren’t trivial and it is again quite hard to implement them without bugs.<\/p>\n

And since distributed systems are hard, why would anyone want another difficult to handle tool?<\/p>\n

Enter Curator<\/h2>\n

Happily, guys from Netflix implemented a nice abstraction for dealing with Zookeeper internals. They called it Curator and use it extensively in the company’s environment. Curator offers consistent API for Zookeeper’s functionality. It even implements a couple of recipes for distributed systems.<\/p>\n

File read\/write<\/h2>\n

The basic use of Zookeeper is as a distributed configuration repository. For this scenario I only need read\/write capabilities, to be able to write and read files from the Zookeeper filesystem. This code snippet writes a sample json to a file on ZK filesystem.<\/a><\/p>\n

EnsurePath ensurePath = new EnsurePath(markerPath);\r\nensurePath.ensure(client.getZookeeperClient());\r\nString json = \u201c...\u201d;\r\nif (client.checkExists().forPath(statusFile(core)) != null)\r\n     client.setData().forPath(statusFile(core), json.getBytes());\r\nelse\r\n     client.create().forPath(statusFile(core), json.getBytes());<\/pre>\n
Distributed locking<\/h2>\n
Having multiple systems there may be a need of using an exclusive lock for some resource, or perhaps some big system requires it\u2019s components to synchronize based on locks. This \u201crecipe\u201d
\nis an ideal match for those situations.<\/a><\/p>\n
lock = new InterProcessSemaphoreMutex(client, lockPath);\r\nlock.acquire(5, TimeUnit.MINUTES);\r\n\u2026 do sth \u2026\r\nlock.release();<\/pre>\n
\u00a0(from https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/LockingRemotely.java<\/a><\/span>)<\/p>\n
Sevice Advertisement<\/h2>\n
This is quite an interesting use case. With many small services on different servers it is not wise to exchange ip addresses and ports between them. When some of those services may go down, while other will try to replace them – the task gets even harder.<\/p>\n
That\u2019s why, with Zookeeper in place, it can be utilised as a registry of existing services.<\/p>\n
If a service starts, it registers into the ServiceRegistry, offering basic information, like it\u2019s purpose, role, address, and port.<\/p>\n
Services that want to use a specific kind of service request an access to some instance. This way of configuring easily decouples services from their configuration.<\/p>\n
Basically this scenario needs ? steps:<\/p>\n
1. Service starts and registers its presence (https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/WorkerAdvertiser.java#L44<\/a><\/p>\n
ServiceDiscovery discovery = getDiscovery();\r\n            discovery.start();\r\n            ServiceInstance si = getInstance();\r\n            log.info(si);\r\n            discovery.registerService(si);\r\n<\/pre>\n
<\/a><\/p>\n
2. Another service – on another host or in another JVM on the same machine tries to discover who is implementing the service (https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/WorkerFinder.java#L50<\/a><\/span>):<\/p>\n
instances = discovery.queryForInstances(serviceName);\r\n<\/pre>\n
<\/a><\/p>\n
The whole concept here is ridiculously simple – the service advertising its presence just stores a file with its whereabouts. The service that is looking for service providers just look into specific directory and read stored definitions.<\/p>\n
In my example, the structure advertised by services looks like this (+ some getters and constructor – the rest is here: https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/model\/WorkerMetadata.java<\/a><\/span>):<\/p>\n
public final class WorkerMetadata {\r\n    private final UUID workerId;\r\n    private final String listenAddress;\r\n    private final int listenPort;\r\n}\r\n<\/pre>\n
<\/a><\/p>\n
Source code<\/h2>\n
The above recipes are available in Curator library (http:\/\/curator.incubator.apache.org\/<\/a>
\nusage examples are in my github repo at https:\/\/github.com\/zygm0nt\/curator-playground<\/a><\/p>\n
Conclusion<\/h2>\n
If you’re in need of a reliable platform for exchanging data and managing synchronization, and you need to do it in a distributed fashion – just choose Zookeeper. Then add Curator for the ease of using it. Enjoy!<\/p>\n
\n
    \n
  1. image comes from: http:\/\/www.flickr.com\/photos\/jfgallery\/2993361148<\/a><\/span><\/li>\n
  2. all source code fragments taken from this repo: https:\/\/github.com\/zygm0nt\/curator-playground<\/a><\/span><\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"\n\n\n\n    An application developed for one of my recent projects at TouK involved multiple servers. There was a requirement to ensure failover for the system’s components. Since I had already a few separate components I didn’t want to add more of that, and since there already was a Zookeeper ensemble running – required by one of the services, I’ve decided to go that way with my solution.\n\nWhat is Zookeeper?\nJust a crude distributed synchronization framework. However, it implements Paxos-style algorithms (http:\/\/en.wikipedia.org\/wiki\/Paxos_(computer_science)) to ensure no split-brain scenarios would occur. This is quite an important feature, since I don’t have to care about that kind of problems while using this app. You just need to create an ensemble of a couple of its instances – to ensure high availability. It is basically a virtual filesystem, with files, directories and stuff. One could ask why another filesystem? Well this one is a rather special one, especially for distributed systems. The reason why creating all the locking algorithms on top of Zookeeper is easy is its Ephemeral Nodes – which are just files that exist as long as connection for them exists. After it disconnects – such file disappears. \n\nWith such paradigms in place it’s fairly easy to create some high level algorithms for synchronization.\n\n\nHaving that in place, it can safely integrate multiple services ensuring loose coupling in a distributed way.\n\n\nZookeeper from developer’s POV\n\nWith all the base services for Zookeeper started, it seems there is nothing else, than just connect to it and start implementing necessary algorithms. Unfortunately, the API is quite basic and offers files and directories abstractions with the addition of different node type (file types) – ephemeral and sequence. It is also possible to watch a node for changes.\n\nUsing bare Zookeeper is hard!\nCreating connections is tedious – and there is lots of things to take care of. Handling an established connection is hard – when establishing connection to ensemble, it’s necessary to negotiate a session also. During the whole process a number of exceptions can occur – these are “recoverable”\n    exceptions, that can be gracefully handled and not break the connection.\n\n    class=\"c8\"><span>So, Zookeeper API is hard.<\/span><\/p><p class=\"c1\"><span><\/span><\/p><p class=\"c8\"><span>Even if one is proficient with that API, then there come recipes. The reason for using Zookeeper is to be able to implement some more sophisticated algorithms on top of it. Unfortunately those aren&rsquo;t trivial and it is again quite hard to implement them without bugs.<\/span>\r\n\n\n\nAnd since distributed systems are hard, why would anyone want another difficult to handle tool? \n\n\nEnter Curator\n<p\n    class=\"c8\"><span>Happily, guys from Netflix implemented a nice abstraction for dealing with Zookeeper internals. They called it Curator and use it extensively in the company&rsquo;s environment. Curator offers consistent API for Zookeeper&rsquo;s functionality. It even implements a couple of recipes for distributed systems.<\/span>\r\n\n\n\nFile read\/write\n<p\n    class=\"c8\"><span>The basic use of Zookeeper is as a distributed configuration repository. For this scenario I only need read\/write capabilities, to be able to write and read files from the Zookeeper filesystem. This code snippet writes a sample json to a file on ZK filesystem.<\/span>\r\n\n\n\n<a href=”#”\n                                                                                                  name=\"0\"><\/a>\r\n\n\r\n\r\nEnsurePath ensurePath = new EnsurePath(markerPath);\r\nensurePath.ensure(client.getZookeeperClient());\r\nString json = “...”;\r\nif (client.checkExists().forPath(statusFile(core)) != null)\r\n     client.setData().forPath(statusFile(core), json.getBytes());\r\nelse\r\n     client.create().forPath(statusFile(core), json.getBytes());\r\n\r\n\r\n\n\nDistributed locking\nHaving multiple systems there may be a need of using an exclusive lock for some resource, or perhaps some big system requires it’s components to synchronize based on locks. This “recipe”\n    is an ideal match for those situations.\n\nref=\"#\"\r\n                                                                                    name=\"b0329bbbf14b79ffaba1139881914aea887ef6a3\"><\/a>\r\n\n\n\r\n\r\n\r\nlock = new InterProcessSemaphoreMutex(client, lockPath);\r\nlock.acquire(5, TimeUnit.MINUTES);\r\n… do sth …\r\nlock.release();\r\n\r\n\r\n\n (from https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/LockingRemotely.java)\n\n\nSevice Advertisement\n<p\n    class=\"c8\"><span>This is quite an interesting use case. With many small services on different servers it is not wise to exchange ip addresses and ports between them. When some of those services may go down, while other will try to replace them - the task gets even harder. <\/span>\r\n\n\nThat’s why, with Zookeeper in place, it can be utilised as a registry of existing services.\n\n\nIf a service starts, it registers into the ServiceRegistry, offering basic information, like it’s purpose, role, address, and port. \n\nServices that want to use a specific kind of service request an access to some instance. This way of configuring easily decouples services from their configuration.\n\n\nBasically this scenario needs ? steps:\n\n<span>1. Service starts and registers its presence (<\/span><span class=\"c5\"><a class=\"c0\"\r\n                                                                               href=\"https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/WorkerAdvertiser.java#L44\">https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/WorkerAdvertiser.java#L44<\/a><\/span><span>)<\/span><span>:<\/span>\r\n\n\n\n\n\r\n\r\n\r\nServiceDiscovery discovery = getDiscovery();\r\n            discovery.start();\r\n            ServiceInstance si = getInstance();\r\n            log.info(si);\r\n            discovery.registerService(si);\r\n\r\n\r\n\r\n\n\n2. Another service – on another host or in another JVM on the same machine tries to discover who is implementing the service (https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/WorkerFinder.java#L50):\n\n\n<a href=”#”\n                                                                                                  name=\"3\"><\/a>\r\n\n\r\n\r\ninstances = discovery.queryForInstances(serviceName);\r\n\r\n\nThe whole concept here is ridiculously simple – the service advertising its presence just stores a file with its whereabouts. The service that is looking for service providers just look into specific directory and read stored definitions.\n\n\nIn my example, the structure advertised by services looks like this (+ some getters and constructor – the rest is here: https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/model\/WorkerMetadata.java):\n\n\n\n\r\n\r\n\r\npublic final class WorkerMetadata {\r\n    private final UUID workerId;\r\n    private final String listenAddress;\r\n    private final int listenPort;\r\n}\r\n\r\n\r\n\n\nSource code\n<p\n    class=\"c8\"><span>The above recipes are available in Curator library (<\/span><span class=\"c5\"><a class=\"c0\"\r\n                                                                                                    href=\"http:\/\/curator.incubator.apache.org\/\">http:\/\/curator.incubator.apache.org\/<\/a><\/span><span>). Recipes&rsquo;\r\nusage examples are in my github repo at <\/span><span class=\"c5\"><a class=\"c0\"\r\n                                                                   href=\"https:\/\/github.com\/zygm0nt\/curator-playground\">https:\/\/github.com\/zygm0nt\/curator-playground<\/a><\/span>\r\n\n\n\nConclusion\n<p\n    class=\"c8\"><span>If you&rsquo;re in need of a reliable platform for exchanging data and managing synchronization, and you need to do it in a distributed fashion - just choose Zookeeper. Then add Curator for the ease of using it. Enjoy!<\/span>\r\n\n\n\n\n\n\n\nimage comes from: http:\/\/www.flickr.com\/photos\/jfgallery\/2993361148\n    \nall source code fragments taken from this repo: https:\/\/github.com\/zygm0nt\/curator-playground\n    \n\n\n\n\n\n    An application developed for one of my recent projects at TouK involved multiple servers. There was a requirement to ensure failover for the system’s components. Since I had already a few separate components I didn’t want to add more of that, and since there already was a Zookeeper ensemble running – required by one of the services, I’ve decided to go that way with my solution.\n\nWhat is Zookeeper?\nJust a crude distributed synchronization framework. However, it implements Paxos-style algorithms (http:\/\/en.wikipedia.org\/wiki\/Paxos_(computer_science)) to ensure no split-brain scenarios would occur. This is quite an important feature, since I don’t have to care about that kind of problems while using this app. You just need to create an ensemble of a couple of its instances – to ensure high availability. It is basically a virtual filesystem, with files, directories and stuff. One could ask why another filesystem? Well this one is a rather special one, especially for distributed systems. The reason why creating all the locking algorithms on top of Zookeeper is easy is its Ephemeral Nodes – which are just files that exist as long as connection for them exists. After it disconnects – such file disappears. \n\nWith such paradigms in place it’s fairly easy to create some high level algorithms for synchronization.\n\n\nHaving that in place, it can safely integrate multiple services ensuring loose coupling in a distributed way.\n\n\nZookeeper from developer’s POV\n\nWith all the base services for Zookeeper started, it seems there is nothing else, than just connect to it and start implementing necessary algorithms. Unfortunately, the API is quite basic and offers files and directories abstractions with the addition of different node type (file types) – ephemeral and sequence. It is also possible to watch a node for changes.\n\nUsing bare Zookeeper is hard!\nCreating connections is tedious – and there is lots of things to take care of. Handling an established connection is hard – when establishing connection to ensemble, it’s necessary to negotiate a session also. During the whole process a number of exceptions can occur – these are “recoverable”\n    exceptions, that can be gracefully handled and not break the connection.\n\n    class=\"c8\"><span>So, Zookeeper API is hard.<\/span><\/p><p class=\"c1\"><span><\/span><\/p><p class=\"c8\"><span>Even if one is proficient with that API, then there come recipes. The reason for using Zookeeper is to be able to implement some more sophisticated algorithms on top of it. Unfortunately those aren&rsquo;t trivial and it is again quite hard to implement them without bugs.<\/span>\r\n\n\n\nAnd since distributed systems are hard, why would anyone want another difficult to handle tool? \n\n\nEnter Curator\n<p\n    class=\"c8\"><span>Happily, guys from Netflix implemented a nice abstraction for dealing with Zookeeper internals. They called it Curator and use it extensively in the company&rsquo;s environment. Curator offers consistent API for Zookeeper&rsquo;s functionality. It even implements a couple of recipes for distributed systems.<\/span>\r\n\n\n\nFile read\/write\n<p\n    class=\"c8\"><span>The basic use of Zookeeper is as a distributed configuration repository. For this scenario I only need read\/write capabilities, to be able to write and read files from the Zookeeper filesystem. This code snippet writes a sample json to a file on ZK filesystem.<\/span>\r\n\n\n\n<a href=”#”\n                                                                                                  name=\"0\"><\/a>\r\n\n\r\n\r\nEnsurePath ensurePath = new EnsurePath(markerPath);\r\nensurePath.ensure(client.getZookeeperClient());\r\nString json = “...”;\r\nif (client.checkExists().forPath(statusFile(core)) != null)\r\n     client.setData().forPath(statusFile(core), json.getBytes());\r\nelse\r\n     client.create().forPath(statusFile(core), json.getBytes());\r\n\r\n\r\n\n\nDistributed locking\nHaving multiple systems there may be a need of using an exclusive lock for some resource, or perhaps some big system requires it’s components to synchronize based on locks. This “recipe”\n    is an ideal match for those situations.\n\nref=\"#\"\r\n                                                                                    name=\"b0329bbbf14b79ffaba1139881914aea887ef6a3\"><\/a>\r\n\n\n\r\n\r\n\r\nlock = new InterProcessSemaphoreMutex(client, lockPath);\r\nlock.acquire(5, TimeUnit.MINUTES);\r\n… do sth …\r\nlock.release();\r\n\r\n\r\n\n (from https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/LockingRemotely.java)\n\n\nSevice Advertisement\n<p\n    class=\"c8\"><span>This is quite an interesting use case. With many small services on different servers it is not wise to exchange ip addresses and ports between them. When some of those services may go down, while other will try to replace them - the task gets even harder. <\/span>\r\n\n\nThat’s why, with Zookeeper in place, it can be utilised as a registry of existing services.\n\n\nIf a service starts, it registers into the ServiceRegistry, offering basic information, like it’s purpose, role, address, and port. \n\nServices that want to use a specific kind of service request an access to some instance. This way of configuring easily decouples services from their configuration.\n\n\nBasically this scenario needs ? steps:\n\n<span>1. Service starts and registers its presence (<\/span><span class=\"c5\"><a class=\"c0\"\r\n                                                                               href=\"https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/WorkerAdvertiser.java#L44\">https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/WorkerAdvertiser.java#L44<\/a><\/span><span>)<\/span><span>:<\/span>\r\n\n\n\n\n\r\n\r\n\r\nServiceDiscovery discovery = getDiscovery();\r\n            discovery.start();\r\n            ServiceInstance si = getInstance();\r\n            log.info(si);\r\n            discovery.registerService(si);\r\n\r\n\r\n\r\n\n\n2. Another service – on another host or in another JVM on the same machine tries to discover who is implementing the service (https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/curator\/WorkerFinder.java#L50):\n\n\n<a href=”#”\n                                                                                                  name=\"3\"><\/a>\r\n\n\r\n\r\ninstances = discovery.queryForInstances(serviceName);\r\n\r\n\nThe whole concept here is ridiculously simple – the service advertising its presence just stores a file with its whereabouts. The service that is looking for service providers just look into specific directory and read stored definitions.\n\n\nIn my example, the structure advertised by services looks like this (+ some getters and constructor – the rest is here: https:\/\/github.com\/zygm0nt\/curator-playground\/blob\/master\/src\/main\/java\/pl\/touk\/model\/WorkerMetadata.java):\n\n\n\n\r\n\r\n\r\npublic final class WorkerMetadata {\r\n    private final UUID workerId;\r\n    private final String listenAddress;\r\n    private final int listenPort;\r\n}\r\n\r\n\r\n\n\nSource code\n<p\n    class=\"c8\"><span>The above recipes are available in Curator library (<\/span><span class=\"c5\"><a class=\"c0\"\r\n                                                                                                    href=\"http:\/\/curator.incubator.apache.org\/\">http:\/\/curator.incubator.apache.org\/<\/a><\/span><span>). Recipes&rsquo;\r\nusage examples are in my github repo at <\/span><span class=\"c5\"><a class=\"c0\"\r\n                                                                   href=\"https:\/\/github.com\/zygm0nt\/curator-playground\">https:\/\/github.com\/zygm0nt\/curator-playground<\/a><\/span>\r\n\n\n\nConclusion\n<p\n    class=\"c8\"><span>If you&rsquo;re in need of a reliable platform for exchanging data and managing synchronization, and you need to do it in a distributed fashion - just choose Zookeeper. Then add Curator for the ease of using it. Enjoy!<\/span>\r\n\n\n\n\n\n\n\nimage comes from: http:\/\/www.flickr.com\/photos\/jfgallery\/2993361148\n    \nall source code fragments taken from this repo: https:\/\/github.com\/zygm0nt\/curator-playground\n    \n\n\n","protected":false},"author":11,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11],"tags":[],"class_list":{"0":"post-11310","1":"post","2":"type-post","3":"status-publish","4":"format-standard","6":"category-development-design"},"_links":{"self":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/11310","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/users\/11"}],"replies":[{"embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/comments?post=11310"}],"version-history":[{"count":13,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/11310\/revisions"}],"predecessor-version":[{"id":15440,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/posts\/11310\/revisions\/15440"}],"wp:attachment":[{"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/media?parent=11310"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/categories?post=11310"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/touk.pl\/blog\/wp-json\/wp\/v2\/tags?post=11310"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}