DEV Community: Sidd B

Microservices Registration and Discovery using Spring Cloud and Eureka

Sidd B — Mon, 18 Jan 2021 01:16:00 +0000

This blog post drives though an implementation pattern and a working setup with multiple microservices where they get registered with Eureka and the client can discover them and invoke them

Table of Content

Microservices Registration and Discovery using Spring Cloud, Eureka

This blog post drives though an implementation pattern and a working setup with multiple microservices where they get registered with Eureka and the client can discover them and invoke them

What is Eureka

Eureka is a REST-based service that provides support for discovering other services so that clients can use the Eureka service to discover services and calling those services.

Why we need Discovery Service

In a Microservices architecture where we have multiple services running, we need a mechanism to know what are the services and how to invoke them. Each service typically will have a different URL or IP address to reach out to. Also, clients of those microservices need to know when a new

microservice is added or an existing microservice was taken down for maintenance. Discovery service provides that mechanism, where services can register themself in the discovery service and clients, can query the discovery service to know more about the available microservices.

Project achievement

In this project, we will go through an end to end use case where we will have a client microservice calling another microservice utilizing Eureka discovery service. Essentially we want to find existing services by looking up in discovery service and then invoking the target service without knowing about their whereabouts like URL, or IP or port, etc. For that, we will build a discovery server one service microservice and one client microservice.

Project Contents

Eureka Discovery Service: Provides the registration and discovery
Article Microservice: Provides REST services for Article CRUD operation
Client Microservice: Invokes the article microservice

Above pictures show what we are going to achieve in very high level

1) We will deploy a Discovery service

2) We will deploy Article Service which registers itself with discovery service with a unique name.

3) We will deploy a consumer application which is another spring boot application which will invoke the

 Article Service by its name.

Technology Used

Java 11

Apache Maven 3.5.0

Spring Boot 2.2.6

Spring Cloud Hoxton.SR1

Netflix Ribbon 2.3.0

Open Feign

JSON

Discovery Server

The following section highlights the important code related to Eureka Server. The details can be looked into in the git repo. Mainly we need to add the maven dependency for Eureka Discovery Server, in the spring boot properties file add the server port and defaultZone and annotate the SpringBoot Application class with @EnableEurekaServer.

We need to include the Netflix Eureka Server dependency in the maven pom file.

pom.xml

<dependency>    <groupId>org.springframework.cloud</groupId>    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId></dependency>

application.properties

server.port=8761##Eureka Relatedeureka.client.serviceUrl.defaultZone=http://127.0.0.1:8761/eureka/eureka.client.healthcheck.enabled=true

The Eureka Discovery Server is a Spring Boot application that is very simple. We need to annotate the application with @EnableEurekaServer. @EnableEurekaServer allows this application to run as a Eureka server, aided by Spring Boot to instantiate Eureka-related beans based on configuration properties.

ServiceDiscovery.java

package com.bootng.service;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;@EnableEurekaServer@SpringBootApplicationpublic class ServiceDiscovery { public static void main(String[] args) { SpringApplication.run(ServiceDiscovery.class, args); }}

Now when we build and start the discovery server and access the server through http://localhost:8761 we would see something like bellow. Notice the following screenshots shows no entries under applications because no other services are up yet.

| |
| Discovery Service UI

|

Article Service

Now we will build and deploy the Article microservice which is another spring boot application that registers itself with the discovery service. The name with which this service is registered is "article-service" and is defined in bootstrap.properties file.

pom.xml

<dependency>    <groupId>org.springframework.cloud</groupId>    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency>

application.properties

## Server Relatedserver.port=9051## Eureka Relatedeureka.client.serviceUrl.defaultZone=http://127.0.0.1:8761/eureka/eureka.client.register-with-eureka=trueeureka.client.fetch-registry=falseeureka.vipAddress=article-service

bootstrap.properties

spring.application.name=article-service

Following is the main application class representing Article Microservice.

ArticleMicroservice

@ComponentScan({ "com.siddb" })@SpringBootApplication@EnableEurekaClient@EnableDiscoveryClientpublic class ArticleMicroservice {    public static void main(String args[]) { SpringApplication.run(ArticleMicroservice.class, args);    }}

This Spring Boot Application exposes the following REST endpoints through the ArticleController.java class. And registers itself with the service discovery with the name "article-service"

ArticleController.java

@RestController@RequestMapping("/api")public class ArticleController { private static final Logger log = LoggerFactory.getLogger(ArticleController.class); @Autowired ArticleService articleService; @RequestMapping(value = {"/articles"}, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<List<Article>> getArticles() throws AppException { List<Article> articles = articleService.getArticles(); return new ResponseEntity<List<Article>>(articles, HttpStatus.OK); } @RequestMapping(value = {"/articles/{id}"}, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<Article> getArticle(@PathVariable(value = "") String id) throws AppException, NotFoundException { Article articles = articleService.getByID(id); return new ResponseEntity<Article>(articles, HttpStatus.OK); } //other methods for POST and Deleted removed from here for readability.}

REST Endpoints

GET http://localhost:9051/api/articles
GET http://localhost:9051/api/articles/ARTICLE\_ID
POST http://localhost:9051/api/articles PAYLOAD
DELETE http://localhost:9051/api/articles/ARTICLE\_ID

Sample Response

GET http://localhost:9051/api/articles

[{ "id": "America-Travel", "name": "America Travel", "description": "Places to travel in AmericaLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum", "category": "Travel" }]

GET http://localhost:9051/api/articles

Sample Response: [{ "id": "America-Travel", "name": "America Travel", "description": "Places to travel in AmericaLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum", "category": "Travel" }]

[{ "id": "America-Travel", "name": "America Travel", "description": "Places to travel in AmericaLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum", "category": "Travel" }]

Article Client Service

Now we will build and deploy the Client Service application which is another Spring Boot application that consumes the REST services deployed by Article Service. Most interesting part

pom.xml

<dependencies>  <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>   </dependency>   <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-loadbalancer</artifactId>    </dependency>   <!--ribbon related -->  <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>  </dependency>   <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId>   </dependency>   <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId>   </dependency></dependencies>

application.properties

hostname=localhostlogging.level.org.springframework=infologging.level.root=infospring.main.banner-mode=offserver.port=9053##Managementmanagement.endpoint.health.show-detailsmanagement.health.key.ping=enabledmanagement.endpoints.web.exposure.include=info,health,mappings##Eureka Relatedeureka.instance.leaseRenewalIntervalInSeconds=1eureka.instance.leaseExpirationDurationInSeconds=90eureka.instance.hostname=${hostname}eureka.instance.hostname.metadataMap.instanceId=${spring.application.name}:${server.port}eureka.client.register-with-eureka=trueeureka.client.fetch-registry=trueeureka.client.serviceUrl.defaultZone=http://127.0.0.1:8761/eureka/eureka.client.healthcheck.enabled=true##Eureka Ribbonarticle-service-consumer.ribbon.NIWSServerListClassName=com.netflix.niws.loadbalancer.DiscoveryEnabledNIWSServerListarticle-service-consumer.ribbon.DeploymentContextBasedVipAddresses=article-service

Following is the Consumer Application Class. We have annotated it with @EnableDiscoveryClient so that it can discover other services registered with the Discovery Server.

ConsumerApplication

@ComponentScan({"com.siddb", "com.siddb.controller"})@SpringBootApplication@EnableDiscoveryClientpublic class ConsumerApplication { public static void main(String args[]) { SpringApplication.run(ConsumerApplication.class, args); }}

Following is the main controller which uses the discovery service internally and invokes services on the service article-service using ribbon. From the ribbon configuration in (application.properties), it knows article-service-consumer is tied to a service with VIP Address (name) article-service.

RibbonController.java

@RestControllerpublic class RibbonController { @Autowired private RestTemplate restTemplate; /** * This method calls the microservice GET article-service/api/articles using Ribbon to get a list of * Articles and returns the same. it uses RestTemplate to make the API calls. * @return * @throws Exception */ @RequestMapping(value = {"render"}, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) public ResponseEntity<String> renderArticles() throws Exception { JsonNode repos = restTemplate.getForObject("http://article-service-consumer/api/articles", JsonNode.class); int counter = 1; StringBuilder result = new StringBuilder("\n List of Articles"); if (repos.isArray()) { for (JsonNode jsonNode : repos) { result.append("\n Repo ").append(counter++).append("::"); result.append(jsonNode.get("name").asText()); } } return new ResponseEntity<String>(result.toString(), HttpStatus.OK); }}

The Consumer Controller uses the ribbon configuration that we have added in the property file to invoke the article service by the ribbon name "article-service-consumer". This is where the Consumer controller will discover the actual API for the corresponding service name. And call GET http://article-service-consumer/api/articles will be actually to http://localhost:9051/api/articles. This is how using the Eureka Discovery service the client becomes independent of the service (IP address, port, etc.). The client simply can refer to the service with its published name.

Start Microservices

Now the fun part, start all the microservices and invoke the /render REST API. We need to start all services (discovery service, article service, consumer service). For that, we first need to check out the repo from git and build/run each project.

1) git clone https://github.com/siddharthagit/spring-boot-sdc.

2) go to the root folder that contains this repo.

3) open 3 Terminals one for each subproject (eureka-service-discovery, ms-article-service, ms-consumer-service).

4) build each project and start the services.

mvn clean install

mvn spring-boot:run

5) Check the status of each service on the discovery server http://localhost:8761

6)Invoke the REST API on consumer service http://localhost:9053/render

This API internally will use the discovery server to resolve the service and will route the call to http://localhost:9051/api/articles.

http://localhost:9053/render

List of Articles Repo 1::America Travel Repo 2::Asia Travel Repo 3::Europe Travel Repo 4::Road Trip Repo 5::Winter Travel Repo 6::Japan Travel

| |
| Discovery Server UI with all services running

|

Conclusion

In this article, we've covered how to use Spring Cloud Eureka for service discovery in the microservice/cloud environment. We created two simple REST services that communicate with each other without hardcoding any hostname/port while making REST calls. Though in this article we have shown how the client can invoke the article service with ribbon, the git repo also contains a Feign client that uses Feign and will be covered in a different article.

References

Git Repo

Spring Cloud Eureka

Spring Boot Rest Template Example

Sidd B — Thu, 18 Jun 2020 23:41:00 +0000

In this article, we will learn how to invoke or call Rest full API's in spring boot. Essentially we are going to write a simple client to consume a few public RESTful API's. RESTTemplate is for just that, Spring's RESTTemplate is used to write client applications to consume RESTful API

Table of Content

Consuming RESTful API in Spring Boot

In our earlier articles, we learned how to create rest full API's . In this article, we will learn how to invoke or call Rest full API's in spring boot. Essentially we are going to write a simple client to consume a few public RESTful API's. RESTTemplate is for just that, Spring's RESTTemplate is used to write client applications to consume RESTful API

In this article, we will consume two different public API. For that, we will write a standalone Spring Boot App, to consumes the REST API's as follows

API 1: Get all GitHub API's

GET https://api.github.com

API 2: Get all Github repositories for user bootng

GET https://api.github.com/users/bootng/repos

Technologies Used

Java 11
Apache Maven 3.5.0
Spring Boot 2.2.6
Eclipse IDE

Main Application Class

package com.javaexp;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.slf4j.Logger;import org.slf4j.LoggerFactory;@SpringBootApplicationpublic class ResttemplateApplication { private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class); public static void main(String args[]) { log.info("about to call ResttemplateApplication.run()"); SpringApplication.run(ResttemplateApplication.class, args); log.info("completed executing ResttemplateApplication.run()"); }}

Our first REST client is as bellow, which calls a REST endpoint and then displays results in the console.

LoadAllGithubEndpoints.java

package com.bootng;import java.util.Iterator;import java.util.Map.Entry;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.boot.CommandLineRunner;import org.springframework.boot.web.client.RestTemplateBuilder;import org.springframework.core.annotation.Order;import org.springframework.http.ResponseEntity;import org.springframework.stereotype.Component;import org.springframework.web.client.RestTemplate;import com.fasterxml.jackson.databind.JsonNode;/** * This Class List all the endpoints from URL https://api.github.com * */@Component@Order(1)public class LoadAllGithubEndpoints implements CommandLineRunner { private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class); @Override public void run(String... args) throws Exception { log.info("about to call LoadAllEndpoint.run()"); RestTemplate restTemplate = new RestTemplateBuilder().build(); ResponseEntity<JsonNode> apis = restTemplate.getForEntity("https://api.github.com", JsonNode.class); StringBuilder result = new StringBuilder("\n List of Public API's"); apis.getBody().fields().next().getValue(); Iterator<Entry<String, JsonNode>> it = apis.getBody().fields(); while (it.hasNext()) { result.append("\n").append(it.next().getValue().asText()); } log.info(result.toString()); }}

Our second REST client is as bellow, which calls a REST endpoint and then displays all the repositories for user bootng in the console.

LoadGithubRepo

package com.bootng;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.boot.CommandLineRunner;import org.springframework.boot.web.client.RestTemplateBuilder;import org.springframework.core.annotation.Order;import org.springframework.http.ResponseEntity;import org.springframework.stereotype.Component;import org.springframework.web.client.RestTemplate;import com.fasterxml.jackson.databind.JsonNode;@Component@Order(2)public class LoadGithubRepo implements CommandLineRunner { private static final Logger log = LoggerFactory.getLogger(ResttemplateApplication.class); @Override public void run(String... args) throws Exception { log.info("about to call LoadGithubRepo.run()"); RestTemplate restTemplate = new RestTemplateBuilder().build(); ResponseEntity<JsonNode> repos = restTemplate .getForEntity("https://api.github.com/users/bootng/repos", JsonNode.class); int counter = 1; StringBuilder result = new StringBuilder("\n List of Repositories"); if (repos.getBody().isArray()) { for(JsonNode jsonNode : repos.getBody()) { result.append("\n Repo ").append(counter++).append("::"); result.append(jsonNode.get("name").asText()); } } log.info(result.toString()); }}

Notice that LoadGithubRepo is marked with annotation Order(2) and LoadAllGithubEndpoints is marked with annotation Order(1). That means Spring will execute LoadAllGithubEndpoints first and then LoadGithubRepo.

Building and Running the application

mvn clean installmvn spring-boot:run

Console Output

20-June-18 16:25:17:627 INFO main c.b.ResttemplateApplication:27 - about to call LoadAllEndpoint.run()
20-June-18 16:25:18:570 INFO main c.b.ResttemplateApplication:40 -
List of Public API's
https://api.github.com/user
https://github.com/settings/connections/applications{/client\_id}
https://api.github.com/authorizations
https://api.github.com/search/code?q={query}{&page,per\_page,sort,order}
https://api.github.com/search/commits?q={query}{&page,per\_page,sort,order}
https://api.github.com/user/emails
https://api.github.com/emojis
https://api.github.com/events
https://api.github.com/feeds
https://api.github.com/user/followers
https://api.github.com/user/following{/target}
https://api.github.com/gists{/gist\_id}
https://api.github.com/hub
https://api.github.com/search/issues?q={query}{&page,per\_page,sort,order}
https://api.github.com/issues
https://api.github.com/user/keys
https://api.github.com/search/labels?q={query}&repository\_id={repository\_id}{&page,per\_page}
https://api.github.com/notifications
https://api.github.com/orgs/{org}
https://api.github.com/orgs/{org}/repos{?type,page,per\_page,sort}
https://api.github.com/orgs/{org}/teams
https://api.github.com/gists/public
https://api.github.com/rate\_limit
https://api.github.com/repos/{owner}/{repo}
https://api.github.com/search/repositories?q={query}{&page,per\_page,sort,order}
https://api.github.com/user/repos{?type,page,per\_page,sort}
https://api.github.com/user/starred{/owner}{/repo}
https://api.github.com/gists/starred
https://api.github.com/users/{user}
https://api.github.com/user/orgs
https://api.github.com/users/{user}/repos{?type,page,per\_page,sort}
https://api.github.com/search/users?q={query}{&page,per\_page,sort,order}
20-June-18 16:25:18:570 INFO main c.b.ResttemplateApplication:21 - about to call LoadGithubRepo.run()
20-June-18 16:25:19:069 INFO main c.b.ResttemplateApplication:36 -
 List of Repositories
 Repo 1::angular-word-merger
 Repo 2::hansini-static-deploy
 Repo 3::JUnit5-examples
 Repo 4::okhttp
 Repo 5::spring-boot-web-start
 Repo 6::springboot\_docker
20-June-18 16:25:19:071 INFO main c.b.ResttemplateApplication:57 - Started ResttemplateApplication in 3.382 seconds (JVM running for 6.625)
20-June-18 16:25:19:071 INFO main c.b.ResttemplateApplication:17 - completed executing ResttemplateApplication.run()

Get source code and build

git clone https://github.com/siddharthagit/spring-boot-resttemplate
cd spring-boot-resttemplate
mvn clean install
mvn spring-boot:run

Summary

In this article, we saw how to write a simple REST client using RESTTEmplate in Spring Boot.
In our next article, we will see more use cases of using RESTTemplate like for POST/PUT, etc.

References

RestTemplate quick guide

Springboot application with Docker

Sidd B — Sat, 07 Mar 2020 01:50:00 +0000

Table of Content

Technology Used
Code Structure
Building Docker Image
Github Source Code

Docker and Spring boot Application

This blog details the steps taken to add docker support to a spring boot application written in java.

This blog is developed with

Java 11
Docker 19.03.5
Spring Boot 1.5.9
Maven

The spring boot application is a simple application to read all the links from a target URL and rendering the links.

Code Structure

SpringBootLinkApplication.java

@ComponentScan({"com.bootng"}) 
@SpringBootApplicationpublic class SpringBootLinkApplication {
 private static final Logger log = LoggerFactory.getLogger(SpringBootLinkApplication.class);
 public static void main(String args[]) {
  log.debug("about to call SpringBootLinkApplication.run()");
  SpringApplication.run(SpringBootLinkApplication.class, args);
 }
 @Bean public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
  return args -> {
   log.info("Let's inspect the beans provided by Spring Boot:");String[] beanNames = ctx.getBeanDefinitionNames();Arrays.sort(beanNames);
   for (String beanName: beanNames) {
    log.info(beanName);
   }
  };
 }
}

LinkController.java

@Controllerpublic class LinkController {
 private static final Logger log = LoggerFactory.getLogger(SpringBootLinkApplication.class);
 @Autowired BlogService blogService;
 @RequestMapping(value = {
  "/"
 }, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) public @ResponseBody Object getHome() {
  log.info("inside getHome ");
  return "GoTo \\links to see all the links \n";
 }
 @RequestMapping(value = {
  "/links"
 }, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) public @ResponseBody Object getHeadLines() {
  log.info("inside blog GET getHeadLines method");
  String sourceLink = "http://www.bootng.com";
  List < String > links = blogService.getAllLinks(sourceLink);
  StringBuilder result = new StringBuilder();
  for (String link: links) {
   result.append(link).append("\n");
  }
  return "Links scanned from bootng.com \n" + result;
 }
 public @ResponseBody Object getHeadLines(@RequestParam String sourceLink) {
  log.info("inside blog GET getHeadLines method");
  List < String > links = blogService.getAllLinks(sourceLink);
  StringBuilder result = new StringBuilder();
  for (String link: links) {
   result.append(link).append("\n");
  }
  return "Links scanned from specified url \n" + result;
 }
 @RequestMapping(value = {
  "/test"
 }, method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE) public @ResponseBody Object isSerivceUp() {
  log.info("inside blog GET method");
  return "Service is Running Fine";
 }
}

BlogLinkService.java

@Servicepublic class BlogLinkService {
 public List < String > getAllLinks(String url) {
   List < String > result = new ArrayList < String > ();
   Document doc;
   try {
    doc = Jsoup.connect(url).get();
    Elements links = doc.select("a[href]");
    for (Element link: links) {
     result.add(String.format(" %s : %s", link.attr("abs:href"), link.text()));
    }
   } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return result; }}

The above files are part of the main Java Classes for the Springboot application. Which defines the Application, Controller, and Service Class. Now we will add docker support to it. For that we need to add a file with name "DockerFile" to the repository as follows.

DockerFile

FROM openjdk:8-jdk-alpine
ARG JAR_FILE=target/*.war

#cd /usr/local/workspace
WORKDIR /usr/local/workspace

COPY ${JAR_FILE} app.jar

# java -jar /usr/local/workspace/app.jar
ENTRYPOINT ["java","-jar","app.jar"]

Building Docker Image

Build Project and Build Docker Image

Following commands will first build our Spring Boot application generate a war file, and then build the docker image containing the war file

mvn install
docker build . -t springboot_docker
Sending build context to Docker daemon  43.16MB
Step 1/5 : FROM openjdk:8-jdk-alpine
 ---> a3562aa0b991
Step 2/5 : ARG JAR_FILE=target/*.war
 ---> Using cache
 ---> e637fbb1ac39
Step 3/5 : WORKDIR /usr/local/workspace
 ---> Using cache
 ---> daa4b4a89727
Step 4/5 : COPY ${JAR_FILE} app.jar
 ---> Using cache
 ---> bd3788117296
Step 5/5 : ENTRYPOINT ["java","-jar","app.jar"]
 ---> Using cache
 ---> 118546685007
Successfully built 118546685007
Successfully tagged springboot_docker:latest

Execute the SpringBoot application inside the docker image with tag "springboot_docker"

Previous step we build the docker image containing our Spring boot applicaiton and tagged the docker image with tag "springboot_docker". To run the dockerized application run the following command.

docker run -p 8080:8080 springboot_docker
 .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.9.RELEASE)
 INFO main c.b.SpringBootLinkApplication:57 - Started SpringBootLinkApplication in 4.813 seconds

Access the Application

Since the Spring boot web application is running on port 8080, open a browser and go to http://localhost:8080/links?sourceLink=http://bootng.com. It should print links somewhat like bellow

 Links scanned from bootng.com 
 https://www.bootng.com/search/label/spring-boot?max-results=3 : spring-boot
 https://www.bootng.com/search/label/gcp?max-results=3 : GCP
 https://www.bootng.com/search/label/angular?max-results=3 : Angular
 https://www.bootng.com/search/label/Agile?max-results=3 : Agile
 https://www.bootng.com/search/label/Java?max-results=3 : Java
 https://www.bootng.com/search/label/Java?max-results=3 : Links

Download Source code Repo

git clone https://github.com/bootng/springboot\_docker.git
cd springboot_docker
mvn install
docker build . - t springboot_docker
docker run -p 8080:8080 springboot_docker

Journey of Google Cloud Professional Cloud Architect Exam

Sidd B — Thu, 12 Dec 2019 05:10:43 +0000

Learning something new is always great. Initially this certification was not my goal. I was learning GCP to know different services it provides specially for hosting and Image processing for my project written in Angular and Java. Later I came to know about the certification and then though to get the Certification done.

I am writing this post to share my journey of getting certified in Google Cloud Architect and material that I found helpful. I hope this post will be useful for me later or others who are interested in this certification.

Exam Details

Exam Guide: Official exam guide link is here https://cloud.google.com/certification/guides/professional-cloud-architect/

Exam consists of 50 multiple choice questions.

Total Duration is 120 Minutes

Exam registration can be scheduled via WebAssessor

I got the exam result after 2 days via email.

Learning GCP In General

Since I was totally new to GCP I found the following courses from coursera very useful. The first course is good specially if new to GCP. The second course is about Networking in details with many hands-on labs.

Coursera GCP Architecture

https://www.coursera.org/specializations/gcp-architecture

Coursera Networking Google Cloud Platform

https://www.coursera.org/specializations/networking-google-cloud-platform

I also signed up for Google Cloud platform and took advantage of the 300 Usd credit to try and learn different products.

Preparation For the Exam

GCP is vast and it is getting more and more product and services.

Exam covers a lot of product and offerings from GCP but not all. Some of them goes deeper which needs good understanding of the product and when/how to use it. There are also questions which touches at surface level, for them having a over all idea is good to choose correct answer.

Understanding in Depth

Case Studies : Know the official case studies and prepare a solution. A lot of questions are asked from the case studies. Going though them before the exam would be helpful.

IAM and Billing : Good understanding of IAM, ACL etc, best practices etc, BigQuery IAM.

Cloud Storage : In-depth knowledge about Cloud storage, storage classes, Lifecycle management, How to delete/change storage class.

Compute Engine : Details about compute engine, Snapshots/Images and how to create vm from them. Preemptible VMs, Shielded VM’s. Now we also have Cloud GPU.

App Engine: Standard vs Flexible.

GKE and Kubernetes : Difference between GKE, Kubernetes, Creating cluster, common K8 commands. Nodes, Pods vs Containers etc. Minimum number of nodes/vms.

Encryption/Security with GCP : Knowledge of CMEK, CSEK, Encryption for Cloud Storage/Bucket etc.

Multi cloud connectivity : Peering, Direct Connect, VPN etc. Usecases when to choose one. Like VPN provides encryption, but for speed Cloud inter connect is better. Also what is the SLA?

VPC : Networking knowledge in depth, GCP provide a number of options/solutions for network design, Shared VPC etc.

Load Balancing

Different kind of LB’s available in GCP

Bigtable : It is proprietary NOSQL database, understanding when to use it and best practices.

BigQuery : When to use BigQuery, best practices, Indexes etc.

Cloud SQL : It is managed Relational Databases, understanding different offerings, configuring replica. Different products available as part of Cloud SQL.

Stack Driver

https://cloud.google.com/stackdriver/

Cloud Datastore : In-depth knowledge about Cloud datastore. How to create index. Google recently added two different mode Datastore mode and native mode.

Disaster Recovery : Design principal for disaster recovery in GCP, different kinds of replicas.

Cloud Pub/Sub: Understanding how and when to best use pubsub.

https://cloud.google.com/functions/docs/tutorials/pubsub

Deployment Manger

For the exam deployment manager is an important topic, understanding what it does and how to configure it would be good. Like Templating, CLI commands.

Different kinds of Deployments

General concepts like Canary deployment, Rolling deployment, Blue/Green Deployment, A/B Testing would be good to know.

Links to some materials for the exam

Best practices for IAM

https://cloud.google.com/docs/enterprise/best-practices-for-enterprise-organizations

A GCP flowchart a day : Good to review how to choose right services

https://medium.com/google-cloud/a-gcp-flowchart-a-day-2d57cc109401

Sample Solution : Following is a sample solution on GCP site, they provide various other architectural solutions which are good to validate the concepts

https://cloud.google.com/solutions/migrating-a-two-tier-web-app-to-gcp

Sample Case studies

Coursera also host a certification preparation course. I did not get much time to complete the full course. But going though the sample case studies would be a good addition to validate own solution.

https://www.coursera.org/learn/preparing-cloud-professional-cloud-architect-exam

Summary

Areas like Compute Engine, Networking, Billing, AIM, Databases, Tools for Analytics etc. are very important. For them we need good understanding of the different options available while architecting a good solution or choosing the appropriate answer in the exam. Apart from that having a good knowledge of the other product/services will be helpful to answer properly.

I took notes so that before the exam i can go over them which is otherwise easy to forget.

Like which products are regional/zonal

Choosing network design for speed requirements.

Different database for capacity, transaction etc.

Network capacities.

Compute engine options.

Cloud Datastore options.

Setting up a static website with GCP and Google Domain

Sidd B — Mon, 01 Jul 2019 06:50:00 +0000

This article will cover the setups required to publish a static website on GCP and using a custom domain from Google domain. It assumes we have some content like html page etc. to publish on GCP as static site. Although it is written for domains registered with Google domain, any other domain providers should also work.
Assumptions

We have some static resources like HTML pages to be published.
We have secured a domain name with ownership.
We will be using CNAME to map the domain name to the static page bucket in GCP.

High level steps

1) Setting up the Custom Domain DNS to forward the request to the
2) Setting up the Buckets on Google cloud

Setting DNS on the custom domain

We want the domain name to be mapped to GCP resource (bucket in our case holding static resources). Setting up the DNS for the custom domain is really simple, we just need to map the CNAME entry in the custom domain DNS section.

Login to Google Domain and go to the DNS setup page for the respective domain. Under the Custom resource records have an entry for www to c.storage.googleapis.com as follows.

Once we save the configuration as above we are good to go to the next section for setting up the static bucket in GCP.

To know more about CNAME and how it works A vs CNAME record explains the advantages of CNAME record and how it works.
A vs CNAME Record

Setting Buckets on Google cloud

Create a bucket whose name matches the CNAME you created for your domain.
For example, if you added a CNAME record pointing www.bootng.com to c.storage.googleapis.com., then create a bucket with the name "www.bootng.com".
To create a bucket:
Open the Cloud Storage browser in the Google Cloud Platform Console.

OPEN THE CLOUD STORAGE BROWSER

Click Create bucket to open the bucket creation form.
Enter your bucket information and click Continue to complete each step:
The Name of your bucket.
The Storage class and Location for your bucket.

Click Create.

Once the bucket is created we need to upload the content of the static site and then give appropriate permissions to the individual objects (files directories) or to the bucket itself.

To assign permission to the bucket:

Go to the list of bucket page and corresponding to the bucket just created click on the last column which will open the action menu like bellow and click on Edit bucket permissions link

Since we want to make the content of this bucket publicly available we need to grant read access to a special group called allUsers

Once this is done the bucket list will show that this bucket is available to public access.

Conclusion

With the above setting now when we type www.bootng.com will map to the content of the bucket www.bootng.com on GCP.

We still need to access resources explicitly for instance if we have welcome.html then we need to type www.bootng.com/welcome.html in the browser

Few things not covered in this article are
1) Mapping default page to the domain name -> so that we can just type www.bootng.com
2) Mapping subdomain to the GCP bucket -> so that we can just type bootng.com

macOS Catalina to have zsh as default shell

Sidd B — Thu, 13 Jun 2019 09:56:08 +0000

Apple's #WWDC2019 (Worldwide Developers Conference) was held on June 3-7.
macOS's next big upgrade will be called Catalina and with it comes a big change for developers.

By default macOS releases till now used bash as the default shell. New user accounts in macOS Catalina will have zsh as the default shell. Zsh is an open source shell very popular and comes with a ton of features.

Zsh is very popular in dev community and can be installed in pre Catalina macOS as well. Zsh and Iterm2 (https://www.iterm2.com) goes very well together and improve the developer productivity.

Deploying Angular App to GCP

Sidd B — Sat, 08 Jun 2019 09:33:00 +0000

This article provide steps that to deploy an Angular App to Google GCP AppEngine.

I will be deploying a frontend Angular App (Angular Word Combiner) with does not need any backend.

Bellow is the screenshot of the Application that we would be deploying.

Google offers 2 options to deploy your application on GCP

Google App Engine
Google Compute Engine

Here I will be using Google App Engine to deploy the Word-Combiner App. App Engine is the Googles managed platform to deploy application. App Engine comes in two flavors Standard and Custom. I will be using App Engine Standard.

First get the Word Combiner APP from git repo to local disk.

git clone https://github.com/siddharthagit/angular-word-merger.git

Now we need to create a config file that will be used by Google Cloud App Engine to deploy the project. Now go to the directory and add the app.yaml file. The name of the file needs to be app.yaml

touch app.yaml

and paste the following content.

# [START runtime]runtime: nodejs8handlers:- url: / static_files: dist/index.html upload: dist/index.html- url: / static_dir: dist# [END runtime]

Now we need to build the Angular app so that it generates the production artifacts that would be deployed to App Engine

ng build --prod

Go to the Google Cloud Console and login with your Google account. Create a new project for your angular app deployment e.g. angular-word-merger

Second step, is to install the Google Cloud SDK. Follow the steps at https://cloud.google.com/sdk/ so that we can deploy our application via command line. For Mac following the instructions in https://cloud.google.com/sdk/docs/quickstart-macos to download the SDK locally.

gcloud app deploy

Now if you goto https://angular-word-merger.appspot.com it should load the Angular App from GCP.

DEV Community: Sidd B

Microservices Registration and Discovery using Spring Cloud and Eureka

Microservices Registration and Discovery using Spring Cloud, Eureka

What is Eureka

Why we need Discovery Service

Project achievement

Technology Used

Discovery Server

Article Service

Sample Response

Article Client Service

Start Microservices

Conclusion

References

Spring Boot Rest Template Example

Consuming RESTful API in Spring Boot

Technologies Used

References

Springboot application with Docker

Table of Content

Docker and Spring boot Application

Code Structure

Building Docker Image

Journey of Google Cloud Professional Cloud Architect Exam

Exam Details

Learning GCP In General

Preparation For the Exam

Understanding in Depth

Other topics that needs to be familiar with

Links to some materials for the exam

Summary

Setting up a static website with GCP and Google Domain

High level steps

Setting DNS on the custom domain

Setting Buckets on Google cloud

Conclusion

macOS Catalina to have zsh as default shell

Deploying Angular App to GCP