{"id":76,"date":"2017-03-29T16:55:25","date_gmt":"2017-03-29T08:55:25","guid":{"rendered":"http:\/\/www.jsjs.org\/?p=76"},"modified":"2017-03-29T16:55:25","modified_gmt":"2017-03-29T08:55:25","slug":"microservices-with-continuous-delivery-using-docker-and-jenkins","status":"publish","type":"post","link":"https:\/\/blog.jsjs.org\/?p=76","title":{"rendered":"Microservices With Continuous Delivery Using Docker and Jenkins"},"content":{"rendered":"
Download \u201cThe DevOps Journey – From Waterfall to Continuous Delivery\u201d<\/a> to learn\u00a0learn about the importance of integrating automated testing into the DevOps workflow, brought to you in partnership with Sauce Labs<\/a>.<\/div>\n
\n
\n

Docker, microservices, Continuous Delivery are currently some of\u00a0the most popular topics in the world of programming.\u00a0In an environment consisting of dozens of microservices\u00a0communicating with each other, it seems to be particularly important\u00a0the automation of the testing, building, and deployment process. Docker is an\u00a0excellent solution for microservices\u00a0because\u00a0it can create and run isolated containers with service.<\/span><\/p>\n

Today, I’m going to present you how to create a\u00a0basic Continuous Delivery pipeline for sample microservices using a popular software\u00a0automation tool: Jenkins.<\/span><\/p>\n

Sample Microservices<\/span><\/h2>\n

Before I get into the main topic of this article, I’ll say a few words about<\/span> structure and tools used for\u00a0sample microservices creation. The sample application consists of two sample\u00a0microservices communicating with each other (account, customer), a discovery server (Eureka), and an API gateway (Zuul).\u00a0It was implemented using Spring Boot and Spring Cloud frameworks. Its source code is available on GitHub<\/a>. Spring Cloud has support for microservices discovery\u00a0and gateway out of the box \u2014 we only have to define right dependencies inside maven project\u00a0configuration file (pom.xml<\/code><\/span>).<\/span><\/p>\n

The picture illustrating the adopted solution architecture is visible\u00a0below. Customer, account REST\u00a0API services, discovery server, and gateway are running inside separated\u00a0Docker containers. Gateway is the entry point to the microservices system. It is interacting with all other services. It proxies requests to the selected microservices searching its addresses in discovery service. In the\u00a0case of there being more than one instance of each account or customer\u00a0microservice, the request is load balanced with Ribbon<\/code>\u00a0<\/span>and Feign<\/code>\u00a0clients.<\/span><\/p>\n

Account and customer services are registering themselves into the discovery server after startup. There is also a possibility of interaction between them \u2014 for example, if we would like to find and return\u00a0all\u00a0customer’s account details.<\/span><\/p>\n

\"Image<\/p>\n

I\u00a0wouldn’t like\u00a0to go into the details of those microservices\u00a0implementation with\u00a0Spring Boot and Spring\u00a0Cloud frameworks. If you are interested in a\u00a0detailed description of the sample application development, you can read it in my blog post here<\/a>.\u00a0Generally, Spring framework\u00a0has a full support for microservices with all Netflix OSS tools like Ribbon, Hystrix, and Eureka. In the blog post, I described how to implement service discovery, distributed tracing, load balancing, logging\u00a0trace ID propagation, and API gateway for microservices\u00a0with those solutions.<\/span><\/p>\n

Dockerfiles<\/h2>\n

Each service in the sample source code has a\u00a0Dockerfile<\/code>\u00a0with a Docker\u00a0image build definition. It’s really simple. Here’s Dockerfile for account service. We use OpenJDK as a base image. A JAR file from the target is added to the image and then run using the\u00a0java -jar<\/code>\u00a0<\/em>command. Service is running on port 2222<\/em>,\u00a0<\/em>which is exposed outside.<\/p>\n

\n
\n
\n
\n
\n
\n
\n
\n
<\/div>\n
FROM openjdk<\/pre>\n<\/div>\n
\n
<\/div>\n
MAINTAINER Piotr Minkowski <piotr.minkowski@gmail.com><\/pre>\n<\/div>\n
\n
<\/div>\n
ADD target\/account-service.jar account-service.jar<\/pre>\n<\/div>\n
\n
<\/div>\n
ENTRYPOINT [\"java\", \"-jar\", \"\/account-service.jar\"]<\/pre>\n<\/div>\n
\n
<\/div>\n
EXPOSE 2222<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n<\/div>\n<\/div>\n
We also had to set main class in the JAR manifest. We achieve it using spring-boot-maven-plugin<\/em> in module\u00a0pom.xml<\/code>. The fragment is visible below. We also set build finalName<\/code>\u00a0<\/em>to cut off version number from target JAR file. The Dockerfile and Maven\u00a0build definition is pretty similar\u00a0for all other microservices.<\/p>\n
\n
\n
\n
\n
\n
\n
\n
\n
<\/div>\n
<<\/span>build<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
  <<\/span>finalName<\/span>><\/span>account-service<\/<\/span>finalName<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
  <<\/span>plugins<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
    <<\/span>plugin<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
      <<\/span>groupId<\/span>><\/span>org.springframework.boot<\/<\/span>groupId<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
      <<\/span>artifactId<\/span>><\/span>spring-boot-maven-plugin<\/<\/span>artifactId<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
      <<\/span>version<\/span>><\/span>1.5.2.RELEASE<\/<\/span>version<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
      <<\/span>configuration<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        <<\/span>mainClass<\/span>><\/span>pl.piomin.microservices.account.Application<\/<\/span>mainClass<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        <<\/span>addResources<\/span>><\/span>true<\/<\/span>addResources<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
      <\/<\/span>configuration<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
      <<\/span>executions<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        <<\/span>execution<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
          <<\/span>goals<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
            <<\/span>goal<\/span>><\/span>repackage<\/<\/span>goal<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
          <\/<\/span>goals<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        <\/<\/span>execution<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
      <\/<\/span>executions<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
    <\/<\/span>plugin<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
  <\/<\/span>plugins<\/span>><\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
<\/<\/span>build<\/span>><\/span><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n<\/div>\n<\/div>\n
Jenkins Pipelines<\/h2>\n
We use Pipeline Plugin<\/a> for building Continuous Delivery for our microservices.\u00a0In addition to the standard plugins set on Jenkins,<\/span> we also need Docker Pipeline Plugin by CloudBees<\/a>. There are four pipelines defined, as you can see in the picture below.<\/p>\n
\"Image<\/p>\n
Here’s the pipeline definition written in Groovy language for discovery\u00a0service. We have five stages of execution. Inside the Checkout stage, we are pulling changes for remote Git repository of the project. Then project is built with the MVN clean install command and the Maven version is read from\u00a0pom.xml<\/code><\/span>. In the Image stage, we build a Docker image from discovery service Dockerfile and then push that image to local registry. In the fourth step, we are running the built image with default port exposed and hostname visible for linked docker containers. Finally, the account pipeline is started with no wait option, which means that source pipeline is finished and won’t wait for account pipeline execution finish.<\/p>\n
\n
\n
\n
\n
\n
\n
\n
\n
<\/div>\n
node<\/span> {<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
    withMaven<\/span>(maven:<\/span>'maven'<\/span>) {<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span>('Checkout'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            git<\/span> url:<\/span> 'https:\/\/github.com\/piomin\/sample-spring-microservices.git'<\/span>, credentialsId:<\/span> 'github-piomin'<\/span>, branch:<\/span> 'master'<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span>('Build'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            sh<\/span> 'mvn clean install'<\/span><\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
            def<\/span> pom<\/span> =<\/span> readMavenPom<\/span> file:<\/span>'pom.xml'<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
            print<\/span> pom<\/span>.version<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
            env<\/span>.version<\/span> =<\/span> pom<\/span>.version<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span>('Image'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            dir<\/span> ('discovery-service'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
                def<\/span> app<\/span> =<\/span> docker<\/span>.build<\/span> \"localhost:5000\/discovery-service:${<\/span>env<\/span>.version<\/span>}\"<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
                app<\/span>.push<\/span>()<\/pre>\n<\/div>\n
\n
<\/div>\n
            }<\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span> ('Run'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            docker<\/span>.image<\/span>(\"localhost:5000\/discovery-service:${<\/span>env<\/span>.version<\/span>}\"<\/span>).run<\/span>('-p 8761:8761 -h discovery --name discovery'<\/span>)<\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span> ('Final'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            build<\/span> job:<\/span> 'account-service-pipeline'<\/span>, wait:<\/span> false<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
    }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
}<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n<\/div>\n<\/div>\n
Account pipeline is very similar. The main difference is inside the fourth stage where account service container is linked to discovery container. We need to link those containers\u00a0because\u00a0account-service<\/code>\u00a0is registering itself in discovery server and must be able to connect it using hostname.<\/p>\n
\n
\n
\n
\n
\n
\n
\n
\n
<\/div>\n
node<\/span> {<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
    withMaven<\/span>(maven:<\/span>'maven'<\/span>) {<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span>('Checkout'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            git<\/span> url:<\/span> 'https:\/\/github.com\/piomin\/sample-spring-microservices.git'<\/span>, credentialsId:<\/span> 'github-piomin'<\/span>, branch:<\/span> 'master'<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span>('Build'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            sh<\/span> 'mvn clean install'<\/span><\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
            def<\/span> pom<\/span> =<\/span> readMavenPom<\/span> file:<\/span>'pom.xml'<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
            print<\/span> pom<\/span>.version<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
            env<\/span>.version<\/span> =<\/span> pom<\/span>.version<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span>('Image'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            dir<\/span> ('account-service'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
                def<\/span> app<\/span> =<\/span> docker<\/span>.build<\/span> \"localhost:5000\/account-service:${<\/span>env<\/span>.version<\/span>}\"<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
                app<\/span>.push<\/span>()<\/pre>\n<\/div>\n
\n
<\/div>\n
            }<\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span> ('Run'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            docker<\/span>.image<\/span>(\"localhost:5000\/account-service:${<\/span>env<\/span>.version<\/span>}\"<\/span>).run<\/span>('-p 2222:2222 -h account --name account --link discovery'<\/span>)<\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
        stage<\/span> ('Final'<\/span>) {<\/pre>\n<\/div>\n
\n
<\/div>\n
            build<\/span> job:<\/span> 'customer-service-pipeline'<\/span>, wait:<\/span> false<\/span><\/pre>\n<\/div>\n
\n
<\/div>\n
        }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
    }<\/pre>\n<\/div>\n
<\/div>\n
\n
<\/div>\n
}<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n<\/div>\n<\/div>\n
Similar pipelines are also defined for customer and gateway service. They are available in main project\u00a0catalog on each microservice as a\u00a0Jenkinsfile<\/code><\/span>. Every image which is\u00a0built during pipeline execution is also\u00a0pushed to local Docker registry. To enable local registry on our host, we need to pull and\u00a0run Docker registry image and also use that registry address as an image name prefix while pulling or pushing. The local registry is exposed on its default 5000<\/em> port. You can see the list of pushed images to the\u00a0local registry by calling its REST API, for example, http:\/\/localhost:5000\/v2\/_catalog<\/em>.<\/p>\n
\n
\n
\n
\n
\n
\n
\n
\n
<\/div>\n
docker run -d<\/span> --name<\/span> registry -p<\/span> 5000<\/span>:5000 registry<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n<\/div>\n<\/div>\n
Testing<\/h2>\n
You should launch the\u00a0build on discovery-service-pipeline<\/code>. This pipeline will not only run build for discovery\u00a0service but also\u00a0call start next\u00a0pipeline build (account-service-pipeline<\/code>) at the end.<\/p>\n
The same rule is configured for account-service-pipeline<\/code>\u00a0which callscustomer-service-pipeline<\/code>\u00a0and for customer-service-pipeline<\/code>, which callgateway-service-pipeline<\/code>.<\/p>\n
So, after all\u00a0of the pipelines finish, you can check the list of running docker containers by calling the\u00a0docker ps<\/code>\u00a0<\/span>command. You should have seen five containers: local registry and our four microservices.<\/p>\n
You can also check the logs of each container by running command docker logs<\/code>\u00a0\u2014 for example,docker logs account<\/code><\/span>. If everything works fine, you should be able to call a service like http:\/\/localhost:2222\/accounts<\/em> or via the\u00a0Zuul gateway http:\/\/localhost:8765\/account\/account<\/em>.<\/p>\n
\n
\n
\n
\n
\n
\n
\n
\n
<\/div>\n
CONTAINER ID        IMAGE                                           COMMAND                  CREATED             STATUS              PORTS                    NAMES<\/pre>\n<\/div>\n
\n
<\/div>\n
fa3b9e408bb4        localhost:5000\/gateway-service:1.0-SNAPSHOT     \"java -<\/span>jar \/gatewa...<\/span>\"<\/span>   About an hour ago   Up About an hour    0.0.0.0:8765<\/span>-<\/span>>8765\/tcp   gateway<\/pre>\n<\/div>\n
\n
<\/div>\n
cc9e2b44fe44        localhost:5000\/customer-service:1.0-SNAPSHOT    \"java -<\/span>jar \/custom...<\/span>\"<\/span>   About an hour ago   Up About an hour    0.0.0.0:3333<\/span>-<\/span>>3333\/tcp   customer<\/pre>\n<\/div>\n
\n
<\/div>\n
49657f4531de        localhost:5000\/account-service:1.0-SNAPSHOT     \"java -<\/span>jar \/accoun...<\/span>\"<\/span>   About an hour ago   Up About an hour    0.0.0.0:2222<\/span>-<\/span>>2222\/tcp   account<\/pre>\n<\/div>\n
\n
<\/div>\n
fe07b8dfe96c        localhost:5000\/discovery-service:1.0-SNAPSHOT   \"java -<\/span>jar \/discov...<\/span>\"<\/span>   About an hour ago   Up About an hour    0.0.0.0:8761<\/span>-<\/span>>8761\/tcp   discovery<\/pre>\n<\/div>\n
\n
<\/div>\n
f9a7691ddbba        registry                                        \"\/entrypoint.sh \/e...\"   About an hour ago   Up About an hour    0.0.0.0:5000->5000\/tcp   registry<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n<\/div>\n<\/div>\n
Conclusion<\/h2>\n
I have presented the basic sample of Continuous Delivery environment for microservices using Docker and Jenkins. You can easily find out the limitations of presented solution. For example, we have\u00a0linked Docker containers with each other to enable communication between them or all of the tools and microservices are running on the same machine.<\/p>\n
For a more advanced sample, we could use Jenkins slaves running on different machines or Docker containers (more here<\/a>), tools like Kubernetes<\/a> for orchestration and\u00a0clustering, or maybe Docker-in-Docker containers for simulating multiple Docker machines. I hope that this article is\u00a0a fine introduction to microservices and Continuous Delivery and helps you to understand the basics of this idea. I think that you can expect more of my\u00a0advanced articles about this subject near the future.<\/p>\n<\/div>\n<\/div>\n
Discover how to optimize your DevOps workflows<\/a> with our cloud-based automated testing infrastructure, brought to you in partnership with Sauce Labs<\/a>.<\/div>\n","protected":false},"excerpt":{"rendered":"
Download \u201cThe DevOps Journey – From Waterfall to Continuous Delivery\u201d to learn\u00a0learn about the importance of integrating automated testing into […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[1],"tags":[],"class_list":["post-76","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=\/wp\/v2\/posts\/76","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=76"}],"version-history":[{"count":0,"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=\/wp\/v2\/posts\/76\/revisions"}],"wp:attachment":[{"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=76"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=76"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jsjs.org\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=76"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}