{"id":3818,"date":"2025-12-24T10:00:47","date_gmt":"2025-12-24T15:00:47","guid":{"rendered":"https:\/\/www.mymiller.name\/wordpress\/?p=3818"},"modified":"2025-12-24T10:00:47","modified_gmt":"2025-12-24T15:00:47","slug":"navigating-the-microservice-maze-using-the-discovery-client-for-service-instance-identification","status":"publish","type":"post","link":"https:\/\/www.mymiller.name\/wordpress\/spring_discovery\/navigating-the-microservice-maze-using-the-discovery-client-for-service-instance-identification\/","title":{"rendered":"Navigating the Microservice Maze: Using the Discovery Client for Service Instance Identification"},"content":{"rendered":"\n<div class=\"wp-block-jetpack-markdown\"><p>In the world of microservices, applications are broken down into smaller, independent services that communicate with each other over a network. This distributed architecture offers numerous benefits like scalability, resilience, and independent deployments. However, it also introduces the challenge of service discovery \u2013 how do services locate and communicate with their dependencies when their IP addresses and ports can change dynamically?<\/p>\n<p>This article delves into the crucial role of the <strong>discovery client<\/strong> in a microservice ecosystem. We\u2019ll explore how it empowers your services to identify and connect with instances of other services, fostering seamless communication and a robust distributed system.<\/p>\n<p><strong>The Need for Service Discovery<\/strong><\/p>\n<p>Imagine a scenario where your order processing service needs to communicate with the inventory service. In a traditional monolithic application, this would be a simple in-process call. However, in a microservice architecture:<\/p>\n<ul>\n<li><strong>Dynamic IP Addresses and Ports:<\/strong> Service instances can be spun up or down automatically based on load, scaling events, or failures. Their network locations are ephemeral.<\/li>\n<li><strong>Multiple Instances:<\/strong> For scalability and resilience, you\u2019ll likely have multiple instances of each service running. Your order service needs a way to choose which instance of the inventory service to call.<\/li>\n<li><strong>Load Balancing:<\/strong> Distributing requests across multiple instances of a service is essential for performance and availability.<\/li>\n<\/ul>\n<p>This is where a service registry and a discovery client come into play.<\/p>\n<p><strong>Introducing the Service Registry and Discovery Client<\/strong><\/p>\n<p>At the heart of service discovery lies a <strong>service registry<\/strong>. This is a central repository where services register themselves upon startup and deregister upon shutdown. It maintains an up-to-date directory of all available service instances and their network locations. Popular service registries include Netflix Eureka, Consul, and ZooKeeper.<\/p>\n<p>The <strong>discovery client<\/strong> is a library that your microservices integrate with. It interacts with the service registry to:<\/p>\n<ol>\n<li><strong>Discover Instances:<\/strong> When a service needs to communicate with another service, the discovery client queries the service registry for the available instances of that target service.<\/li>\n<li><strong>Retrieve Location Information:<\/strong> The discovery client retrieves the network addresses (hostname\/IP and port) of the discovered instances.<\/li>\n<li><strong>Potentially Integrate with Load Balancers:<\/strong> Some discovery clients work in conjunction with load balancers to distribute requests across the available instances.<\/li>\n<\/ol>\n<p><strong>How the Discovery Client Works (Conceptual)<\/strong><\/p>\n<p>The typical workflow involves these steps:<\/p>\n<ol>\n<li><strong>Service Registration:<\/strong> When a service instance starts, it uses its discovery client to register its metadata (service name, IP address, port, health status, etc.) with the service registry.<\/li>\n<li><strong>Heartbeats\/Health Checks:<\/strong> Registered instances periodically send heartbeats or respond to health checks initiated by the service registry to indicate they are still alive and healthy.<\/li>\n<li><strong>Service Discovery:<\/strong> When a service (the consumer) needs to call another service (the provider), its discovery client queries the service registry for the provider\u2019s service name.<\/li>\n<li><strong>Instance Retrieval:<\/strong> The service registry returns a list of available and healthy instances of the provider service, along with their network addresses.<\/li>\n<li><strong>Load Balancing (Optional):<\/strong> The discovery client or an integrated load balancer can then choose an instance from the list to send the request to, often using a load-balancing algorithm (e.g., round-robin, random, weighted).<\/li>\n<li><strong>Communication:<\/strong> The consumer service then uses the retrieved network address to communicate directly with the chosen provider instance.<\/li>\n<\/ol>\n<p><strong>Example using Spring Cloud Discovery Client<\/strong><\/p>\n<p>For those working within the Spring ecosystem (like yourself, with your preference for Spring and Spring Boot), Spring Cloud provides excellent support for various service discovery solutions through its <code>spring-cloud-starter-discovery<\/code> abstraction.<\/p>\n<p>Let\u2019s consider a scenario with two services: <code>order-service<\/code> and <code>inventory-service<\/code>, registered with a service registry like Eureka.<\/p>\n<ol>\n<li>\n<p><strong>Add Dependency:<\/strong> In your <code>order-service<\/code>\u2019s <code>pom.xml<\/code> or <code>build.gradle<\/code>, add the appropriate Spring Cloud Discovery Client dependency (e.g., for Eureka):<\/p>\n<pre><code class=\"language-xml\">&lt;dependency&gt;\n    &lt;groupId&gt;org.springframework.cloud&lt;\/groupId&gt;\n    &lt;artifactId&gt;spring-cloud-starter-netflix-eureka-client&lt;\/artifactId&gt;\n&lt;\/dependency&gt;\n<\/code><\/pre>\n<pre><code class=\"language-gradle\">\/\/ Gradle\nimplementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client'\n<\/code><\/pre>\n<\/li>\n<li>\n<p><strong>Enable Discovery Client:<\/strong> Annotate your main application class in <code>order-service<\/code> with <code>@EnableDiscoveryClient<\/code>:<\/p>\n<pre><code class=\"language-java\">import org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.cloud.client.discovery.EnableDiscoveryClient;\n\n@SpringBootApplication\n@EnableDiscoveryClient\npublic class OrderServiceApplication {\n\n    public static void main(String[] args) {\n        SpringApplication.run(OrderServiceApplication.class, args);\n    }\n}\n<\/code><\/pre>\n<\/li>\n<li>\n<p><strong>Service Name Configuration:<\/strong> Ensure your <code>inventory-service<\/code> registers itself with a specific application name in the service registry (e.g., <code>inventory-service<\/code>) through its <code>application.properties<\/code> or <code>application.yml<\/code>:<\/p>\n<pre><code class=\"language-properties\">spring.application.name=inventory-service\neureka.client.service-url.defaultZone=http:\/\/localhost:8761\/eureka # Example Eureka server URL\n<\/code><\/pre>\n<\/li>\n<li>\n<p><strong>Using the <code>DiscoveryClient<\/code> in <code>order-service<\/code>:<\/strong> You can inject the <code>DiscoveryClient<\/code> into your <code>order-service<\/code> components to retrieve instances of <code>inventory-service<\/code>:<\/p>\n<pre><code class=\"language-java\">import org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.cloud.client.ServiceInstance;\nimport org.springframework.cloud.client.discovery.DiscoveryClient;\nimport org.springframework.stereotype.Service;\nimport org.springframework.web.client.RestTemplate;\n\nimport java.util.List;\n\n@Service\npublic class InventoryServiceClient {\n\n    @Autowired\n    private DiscoveryClient discoveryClient;\n\n    private final RestTemplate restTemplate = new RestTemplate();\n\n    public String checkInventory(String productId) {\n        List&lt;ServiceInstance&gt; instances = discoveryClient.getInstances(&quot;inventory-service&quot;);\n        if (instances != null &amp;&amp; !instances.isEmpty()) {\n            \/\/ Simple round-robin load balancing (for demonstration)\n            ServiceInstance selectedInstance = instances.get(0);\n            String inventoryServiceUrl = selectedInstance.getUri().toString();\n            return restTemplate.getForObject(inventoryServiceUrl + &quot;\/inventory\/&quot; + productId, String.class);\n        } else {\n            return &quot;Inventory service unavailable&quot;;\n        }\n    }\n}\n<\/code><\/pre>\n<\/li>\n<\/ol>\n<p><strong>Simplified Communication with LoadBalanced <code>WebClient<\/code> or <code>RestTemplate<\/code><\/strong><\/p>\n<p>Spring Cloud further simplifies service-to-service communication by providing the <code>@LoadBalanced<\/code> annotation. When used with a <code>RestTemplate<\/code> or <code>WebClient<\/code>, it automatically integrates with the discovery client and a load balancer (like Ribbon, which is often bundled with Eureka).<\/p>\n<ol>\n<li>\n<p><strong>Enable <code>@LoadBalanced<\/code>:<\/strong><\/p>\n<pre><code class=\"language-java\">import org.springframework.cloud.client.loadbalancer.LoadBalanced;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.web.client.RestTemplate;\n\n@Configuration\npublic class RestTemplateConfig {\n\n    @Bean\n    @LoadBalanced\n    public RestTemplate restTemplate() {\n        return new RestTemplate();\n    }\n}\n<\/code><\/pre>\n<\/li>\n<li>\n<p><strong>Use the <code>RestTemplate<\/code> with the Service Name:<\/strong><\/p>\n<pre><code class=\"language-java\">import org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.stereotype.Service;\nimport org.springframework.web.client.RestTemplate;\n\n@Service\npublic class InventoryServiceClient {\n\n    @Autowired\n    @LoadBalanced\n    private RestTemplate restTemplate;\n\n    public String checkInventory(String productId) {\n        return restTemplate.getForObject(&quot;http:\/\/inventory-service\/inventory\/&quot; + productId, String.class);\n    }\n}\n<\/code><\/pre>\n<p>Notice that instead of using a specific URL, we now use the <strong>service name<\/strong> (<code>inventory-service<\/code>). The <code>@LoadBalanced<\/code> <code>RestTemplate<\/code> will automatically resolve this service name to available instances and load balance the requests.<\/p>\n<\/li>\n<\/ol>\n<p><strong>Benefits of Using a Discovery Client<\/strong><\/p>\n<ul>\n<li><strong>Decoupling:<\/strong> Services don\u2019t need to know the specific network locations of their dependencies, reducing coupling and making the system more flexible.<\/li>\n<li><strong>Dynamic Scalability:<\/strong> As service instances are added or removed, the discovery client automatically updates the available instances, allowing for seamless scaling.<\/li>\n<li><strong>Resilience:<\/strong> If an instance of a service fails, the discovery client can help route traffic to other healthy instances.<\/li>\n<li><strong>Simplified Configuration:<\/strong> You don\u2019t need to manually manage and update the network addresses of your services.<\/li>\n<li><strong>Load Balancing Integration:<\/strong> Many discovery client implementations integrate with load balancers, improving performance and availability.<\/li>\n<\/ul>\n<p><strong>Choosing the Right Discovery Solution<\/strong><\/p>\n<p>The choice of service registry and discovery client depends on your specific needs and the technology stack you are using.<\/p>\n<ul>\n<li><strong>Netflix Eureka:<\/strong> A popular and mature option, well-integrated with the Spring Cloud ecosystem.<\/li>\n<li><strong>Consul:<\/strong> Provides service discovery, health checking, and a distributed key-value store.<\/li>\n<li><strong>ZooKeeper:<\/strong> A highly reliable distributed coordination service that can also be used for service discovery.<\/li>\n<li><strong>Kubernetes DNS:<\/strong> If you are deploying your microservices on Kubernetes, its built-in DNS-based service discovery is a powerful option.<\/li>\n<\/ul>\n<p><strong>Conclusion<\/strong><\/p>\n<p>The discovery client is an indispensable tool in a microservice architecture. It acts as the navigator, enabling your services to seamlessly locate and communicate with each other in a dynamic and distributed environment. By embracing a discovery client, you can build more resilient, scalable, and maintainable microservice ecosystems, paving the way for efficient development and deployment. Understanding its role and implementation is a fundamental step towards mastering the complexities of modern distributed systems.<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":3852,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_coblocks_attr":"","_coblocks_dimensions":"","_coblocks_responsive_height":"","_coblocks_accordion_ie_support":"","jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[432],"tags":[],"series":[],"class_list":["post-3818","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-spring_discovery"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/ai-generated-7945684_1280.avif","jetpack-related-posts":[{"id":3721,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_discovery\/load-balancing-in-spring-gateway-discovery\/","url_meta":{"origin":3818,"position":0},"title":"Load Balancing in Spring: Gateway &amp; Discovery","author":"Jeffery Miller","date":"December 17, 2025","format":false,"excerpt":"Load balancing is crucial in modern applications to distribute traffic across multiple instances of a service, ensuring high availability and fault tolerance. Spring provides robust mechanisms for load balancing, both at the gateway level and through service discovery. This blog post will explore both approaches, highlighting their differences and use\u2026","rel":"","context":"In &quot;Spring Discovery&quot;","block_context":{"text":"Spring Discovery","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_discovery\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/network-8198745_1280-jpg.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/network-8198745_1280-jpg.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/network-8198745_1280-jpg.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/network-8198745_1280-jpg.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/network-8198745_1280-jpg.avif 3x"},"classes":[]},{"id":3701,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_discovery\/simplifying-microservices-communication-with-the-java-spring-discovery-client\/","url_meta":{"origin":3818,"position":1},"title":"Simplifying Microservices Communication with the Java Spring Discovery Client","author":"Jeffery Miller","date":"November 24, 2025","format":false,"excerpt":"In the world of microservices, services need to find and communicate with each other dynamically. This is where the Java Spring Discovery Client comes in, offering a streamlined way to interact with a service registry (like Eureka, Consul, or Zookeeper). Let\u2019s explore its core APIs and illustrate their usage with\u2026","rel":"","context":"In &quot;Spring Discovery&quot;","block_context":{"text":"Spring Discovery","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_discovery\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/compass-4713642_1280-jpg.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/compass-4713642_1280-jpg.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/compass-4713642_1280-jpg.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/compass-4713642_1280-jpg.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2024\/09\/compass-4713642_1280-jpg.avif 3x"},"classes":[]},{"id":3435,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_discovery\/service-discovery-with-spring-cloud-discovery-eureka\/","url_meta":{"origin":3818,"position":2},"title":"Service Discovery with Spring Cloud Discovery Eureka","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Spring Cloud Discovery Eureka is a service registry that enables applications to dynamically discover other applications in a microservice architecture. With Eureka, applications can register themselves with the registry and then retrieve information about other registered applications. This information can be used to load balance requests across multiple instances of\u2026","rel":"","context":"In &quot;Spring Discovery&quot;","block_context":{"text":"Spring Discovery","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_discovery\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/compass-5261062_640.jpg?fit=640%2C427&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/compass-5261062_640.jpg?fit=640%2C427&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/compass-5261062_640.jpg?fit=640%2C427&ssl=1&resize=525%2C300 1.5x"},"classes":[]},{"id":3828,"url":"https:\/\/www.mymiller.name\/wordpress\/spring-gateway\/load-balancing-your-microservices-configuring-spring-cloud-gateway-with-spring-discovery-server\/","url_meta":{"origin":3818,"position":3},"title":"Load Balancing Your Microservices: Configuring Spring Cloud Gateway with Spring Discovery Server","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"In a microservices architecture, ensuring high availability and distributing traffic evenly across multiple instances of a service is paramount. Spring Cloud Gateway, when integrated with a Spring Discovery Server (like Netflix Eureka, Consul, or Spring Cloud Service Registry), provides a powerful and straightforward way to achieve client-side load balancing without\u2026","rel":"","context":"In &quot;Spring Gateway&quot;","block_context":{"text":"Spring Gateway","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring-gateway\/"},"img":{"alt_text":"","src":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/meditation-3814069_1280.avif","width":350,"height":200,"srcset":"https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/meditation-3814069_1280.avif 1x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/meditation-3814069_1280.avif 1.5x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/meditation-3814069_1280.avif 2x, https:\/\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2025\/04\/meditation-3814069_1280.avif 3x"},"classes":[]},{"id":3444,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_discovery\/spring-boot-admin-server-with-spring-cloud-discovery\/","url_meta":{"origin":3818,"position":4},"title":"Spring Boot Admin Server with Spring Cloud Discovery","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Spring Boot Admin Server is a powerful tool for monitoring and managing Spring Boot applications. It provides a centralized dashboard for viewing application health, metrics, and logs. Spring Cloud Discovery, on the other hand, enables service registration and discovery for microservices-based applications. By integrating Spring Boot Admin Server with Spring\u2026","rel":"","context":"In &quot;Spring Discovery&quot;","block_context":{"text":"Spring Discovery","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_discovery\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/manhattan-3866140_640.jpg?fit=640%2C427&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/manhattan-3866140_640.jpg?fit=640%2C427&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/manhattan-3866140_640.jpg?fit=640%2C427&ssl=1&resize=525%2C300 1.5x"},"classes":[]},{"id":3441,"url":"https:\/\/www.mymiller.name\/wordpress\/spring_discovery\/spring-cloud-gateway-with-spring-cloud-discovery\/","url_meta":{"origin":3818,"position":5},"title":"Spring Cloud Gateway with Spring Cloud Discovery","author":"Jeffery Miller","date":"December 24, 2025","format":false,"excerpt":"Spring Cloud Gateway and Spring Cloud Discovery are powerful tools for building microservices architectures. Spring Cloud Gateway acts as an API gateway, routing requests to the appropriate microservices. Spring Cloud Discovery provides a registry for microservices, enabling dynamic service discovery and load balancing. In this comprehensive guide, we'll delve into\u2026","rel":"","context":"In &quot;Spring Discovery&quot;","block_context":{"text":"Spring Discovery","link":"https:\/\/www.mymiller.name\/wordpress\/category\/spring_discovery\/"},"img":{"alt_text":"","src":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/trees-2900064_640.jpg?fit=640%2C427&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/trees-2900064_640.jpg?fit=640%2C427&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/www.mymiller.name\/wordpress\/wp-content\/uploads\/2023\/11\/trees-2900064_640.jpg?fit=640%2C427&ssl=1&resize=525%2C300 1.5x"},"classes":[]}],"jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3818","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/comments?post=3818"}],"version-history":[{"count":1,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3818\/revisions"}],"predecessor-version":[{"id":3819,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/posts\/3818\/revisions\/3819"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media\/3852"}],"wp:attachment":[{"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/media?parent=3818"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/categories?post=3818"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/tags?post=3818"},{"taxonomy":"series","embeddable":true,"href":"https:\/\/www.mymiller.name\/wordpress\/wp-json\/wp\/v2\/series?post=3818"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}