DEV Community: Coding Saint

Spring Kafka Stream with Custom Objects

Coding Saint — Tue, 10 Mar 2020 02:23:00 +0000

Kafka is most sought after event system today. In this series we will look at Kafka event messaging and streaming.

Github Repository link : https://github.com/CODINGSAINT/kafka-stream-spring

What will we be creating

We will create a streaming application using Spring and kafka streams.
We will have a continuously coming stream of famous quotes which will be continously produced at quote topic. Every quote can be tagged with multiple categories i.e. business,education,faith,famous-quotes,friendship,future,happiness,inspirational,life,love,nature,politics,proverb,religion,science,success,technology .
We will have topics related to each of the category. Once a quote comes we will be streaming them to respective category. To keep things simple for demo we have one listener listening to all of the topics
We have taken quotes from https://github.com/lukePeavey/quotable/blob/master/data/sample/quotes.json

These quotes will be streamed and will be sent to respective topic based on their category.
Listener will keep track of all the quotes which are streamed to these topics.

Installing kafka

### Download
To start kafka we require zookeeper , on kafka website we have different versions you can get the latest stable vesion from Kafka download page Say you have downloaded kafka_2.11-2.4.0.tgz

wget http://mirrors.estointernet.in/apache/kafka/2.4.0/kafka_2.11-2.4.0.tgz

Unzip

Use below command to unzip the downloaded file tar xzf kafka_2.11-2.4.0.tgz
### Move to user directory Move content to user directory

mv kafka_2.11-2.4.0/* /usr/local/kafka
### Run Zookeeper
Go to kafka directory and run

cd /usr/local/kafka bin/zookeeper-server-start.sh config/zookeeper.properties ### Run Kafka Server Use below command to run kafka server

bin/kafka-server-start.sh config/server.properties You will see logs confirming the kafka is up an running.

Test kafka installation

#### Create a topic
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic kafka-test-topic

Verify if topic got created

bin/kafka-topics.sh --list --zookeeper localhost:2181 kafka-test-topic
#### Send messages to topic

Use below command to activate message terminal to kafka-test-topic. Below command will activate message sending to a topic , key in some interesting messages. Lets call it producer window

bin/kafka-console-producer.sh --broker-list localhost:9092 --topic kafka-test-topic >Welcome to Kafka

Consume the topic Open another terminal to consume messages

 bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic kafka-test-topic --from-beginning

Now whatever you key in to producer window will be consumed to consumer window

Other ways to install kafka

There could be many other ways to install and run like using apt installer on Ubuntu , using a docker image etc. The above one is a generic setup .

Create Topics for for app

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic quotes  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic business  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic education  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic faith  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic famous-quotes  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic famous-quotes  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic friendship  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic future  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic happiness  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic inspirational  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic life  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic love  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic nature  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic politics  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic proverb  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic religion  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic science  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic success  
bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic technology

Creating Spring Boot Kafka Stream project

We will create project using https://start.spring.io .
Go to website and dependencies

Download the project and open in your favourite IDE and open it.
Now we have Kafka installed up and running , as a First step we should be creating Quote bean which will flow the quotes from producer to consumer.

@Getter
@Setter
@ToString
public class Quote {
private String content;
private Set<String> tags;
private String author;
}

Let's add required configurations for Kafka. This includes Serializer and Deserializer
for Quotes.We have configurations for Spring Kafka template , producer and consumer.
Serialization and Deserialiation for key and value objects(POJO) have been mentioned seperately.

spring:
  kafka:
    listener:
      missing-topics-fatal: false
    client-id : quotes-app
    bootstrap-server:
      - localhost:9091
      - localhost:9001
      - localhost:9092
    template:
      default-topic: quotes
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: com.codingsaint.learning.kafkastreamspring.QuoteSerializer
    consumer:
      properties:
        partition:
          assignment:
            strategy: org.apache.kafka.clients.consumer.RoundRobinAssignor
      group-id: random-consumer
      auto-offset-reset: earliest
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: com.codingsaint.learning.kafkastreamspring.QuoteDeserializer
---
kafka:
  topic:
    input: quotes
    output: business,education,faith,famous-quotes,friendship,future,happiness,inspirational,life,love,nature,politics,proverb,religion,science,success,technology

We will create QuoteSerializer , QuoteDeserializer and QuoteSerde which will have both serializer and deserializer
.We are using simple ObjectMapper to serialize and deserialize

QuoteSerializer

public class QuoteSerializer implements Serializer<Quote> {

    @Override
    public byte[] serialize(String s, Quote quote) {
        byte[] retVal = null;
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            retVal = objectMapper.writeValueAsString(quote).getBytes();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return retVal;
    }
}

QuoteDeserializer

public class QuoteDeserializer implements Deserializer<Quote> {

    @Override
    public Quote deserialize(String s, byte[] bytes) {
        ObjectMapper mapper = new ObjectMapper();
        Quote quote = null;
        try {
            quote = mapper.readValue(bytes, Quote.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return quote;
    }

}

QuoteSerde

public class QuoteSerde implements Serde<Quote> {
    public QuoteSerde() {
    }

    @Override
    public Serializer<Quote> serializer() {
        return new QuoteSerializer();
    }

    @Override
    public Deserializer<Quote> deserializer() {
        return new QuoteDeserializer();
    }
}

Now Let us see the AppConfig class for configuring Producer and Consumer configurations.

@Configuration
@EnableKafka
@EnableKafkaStreams
public class AppConfig {
    private static final Logger LOGGER= LoggerFactory.getLogger(AppConfig.class);

    @Value("${kafka.topic.input}")
    private String inputTopic;

    @Value("#{'${kafka.topic.output}'.split(',')}")
    private List<String> allTopics;


    @Autowired
    private KafkaProperties kafkaProperties;

    /**
     * Configurations for KafkaStreams
     * @param kafkaProperties Will take defaults from application YAML or Properties file with spring.kafka
     * @return kafkaConfiguration
     */
    @Bean(name= KafkaStreamsDefaultConfiguration.DEFAULT_STREAMS_CONFIG_BEAN_NAME)
    public KafkaStreamsConfiguration kafkaConfiguration(final KafkaProperties kafkaProperties){
        Map<String, Object> config = new HashMap<>();
        config.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaProperties.getBootstrapServers());
        config.put(StreamsConfig.APPLICATION_ID_CONFIG, kafkaProperties.getClientId());
        config.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
        config.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, QuoteSerde.class.getName() );
        config.put(StreamsConfig.DEFAULT_DESERIALIZATION_EXCEPTION_HANDLER_CLASS_CONFIG, LogAndContinueExceptionHandler.class);
        return new KafkaStreamsConfiguration(config);
    }

    /**
     * The Stream which delegates each incoming topic to respective destination topic
     * @param kStreamsBuilder
     * @return
     */
    @Bean
    public KStream<String,Quote> kStream(StreamsBuilder kStreamsBuilder){
        KStream<String,Quote> stream=kStreamsBuilder.stream(inputTopic);
        for(String topic:allTopics){
            stream.filter((s, quote) -> quote.getTags().contains(topic)).to(topic);
        }
        return stream;

    }

    /**
     * Kafka ConsumerFactory configurations
     * @return
     */
    @Bean
    public ConsumerFactory<String, Quote> consumerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(
                ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
                kafkaProperties.getBootstrapServers());
        props.put(
                ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class);
        props.put(
                ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
                BytesDeserializer.class);
        return new DefaultKafkaConsumerFactory<>(props);
    }

    /**
     * Required Configuration for POJO to JSON
     * @return ConcurrentKafkaListenerContainerFactory
     */
    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, Quote>
    kafkaListenerContainerFactory() {

        ConcurrentKafkaListenerContainerFactory<String, Quote> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        factory.setMessageConverter(new StringJsonMessageConverter());
        return factory;
    }
}

Since we have injected default KafkaProperties will have required bindings from application.yml .
Beans for default Kafka Stream ,consumer factory and ConcurrentKafkaListenerContainerFactory is created where ConcurrentKafkaListenerContainerFactory bean help us to convert incoming message from String to Json using StringJsonMessageConverter
KStream bean helps to create a stream on input topic (quotes) and filter based on tags. For each tag we already have created topics.

Now Let us look at Listener configuration which will listen all the topics

@Component
public class TopicConsumers {
    private static final Logger LOGGER = LoggerFactory.getLogger(TopicConsumers.class);

    @Value("#{'${kafka.topic.output}'.split(',')}")
    private List<String> allTopics;

    /**
     * For simplicity we are listening all topics at one listener
     */

    @KafkaListener(id = "allTopics", topics = "#{'${kafka.topic.output}'.split(',')}",
            containerFactory = "kafkaListenerContainerFactory")
    public void consume(@Payload Quote quote,
                        @Header(KafkaHeaders.RECEIVED_PARTITION_ID) int partition,
                        @Header(KafkaHeaders.RECEIVED_TOPIC) String incomingTopic,
                        @Header(KafkaHeaders.RECEIVED_TIMESTAMP) long ts
    ) {
        LOGGER.info("Incoming quote {}-> {}", incomingTopic, quote);
    }
}

For simplicity we are listening all of these topics at one Listener

Once we run the application we will see logs confirming publishing of quotes with different tags and streams sending them to their respective category. Listener will listen incoming quotes.

Spring Microservices

Coding Saint — Thu, 27 Feb 2020 13:10:20 +0000

Welcome to Micoservices by Coding Saint!

The new buzzword in industry is microservices. This repository is the source code for the step by step tutorial at online course Spring REST API and Microserivces . You can follow above link and can get the step by step video reference at 90% discount.
https://www.udemy.com/course/spring-boot-and-rest-api/?referralCode=61F8139662DFDFE6DB67

Table of Content

Introduction
Advantages and Drawbacks of Microservices
User Service
ToDo Service
Feign Declarative REST Client
Ribbon Load Balancer
Service Discovery in Microservices using Eureka
Use of Config Server
Zuul API gateway
Distributed Tracing
Zipkins UI to view traces
Hystrix Fault tolerance

Introduction

From inception of software design what needed to be improved which brought this new concept . We need to understand a work “Monolith”

Monolith refers a kind of software which keeps all the component required by it within itself. Say we have to create a E Commerce we need to have User authentication, product services, cart management, payment integration ,recommendation service etc. A monolith is one application which has all of them embedded to it.

Microservices

Microservices as certainly a buzz word all around. We have been in an era where distributed and scaleable systems have need of the hour. As the business grows the number the pressure on systems also increases. In order to keep up with increased load we scale our application. In this process we end up scaling entire monolith. In monolith we have all modules added to single application. While our load will be for certain modules ,we still end up scaling entire application.

Scaling Monolith

In above example , if we have a E commerce service as monolith, it is expected to have more hits at product and search modules rather cart and delivery tracking modules but when we scale up we will end up scaling all of the modules. This will increase memory and heap size and will require unnecessary resources.

Microservices solves exact same problem. In microservices we have well defined modules as a separate service all of them talking independently via HTTP/MQ or any protocol. Now once we notice increase in product services and search module, we will scale only that component.

Microservices scaling

Advantages and Drawbacks of Microservice

Advantages of Microservices

Improved fault tolerance
Easy to understand
No vendor or technology lock in
Easy to add new modules ##### Improved fault tolerance

Microservices helps you to be highly available. Since once we adopt microservices , we move towards distributed systems , In case of a monolith if a the system or network is down typically entire system is down. In Monolith as we know services are tightly coupled , error at one service will impact other one too. In Microservices , we design in a way that even if one component is down , entire service will not be impacted. We can use fault tolerance and write code for fallbacks. For example if we have fallback for some critical modules , in case of the service being down fallbacks will be invoked , say in a e-commerce microservice recommendation-service is down, we can have fallbacks with static recommendations. It improves our fault tolerance.

Easy to understand

Each module is granular. It has it’s own domain, All it has to do is to take care of itself. Obviously it is easy to understand a smaller piece than entire monolith system4

No vendor or technology lock in

The is no vendor lock in , Each module can have it’s own database, a different programming language and still communicate via HTTP REST protocol , or messaging queues etc.

Easy to add new modules

Once a new feature is required we don’t have to write in same monolith with a fear of breaking changes. We can easily spin up a new microservices and it doesn’t have to break existing system.

All your files and folders are presented as a tree in the file explorer. You can switch from one to another by clicking a file in the tree.

Drawbacks of Microservices

Distributed systems are complex to understand
Multiple database make it complex to maintain transactional consistency.
Tough to test
Could be tough to deploy

Distributed systems are complex to understand

Distributed system are complex. Tough a individual module could be very easy to understand but how it fit in entire big microservice landscape ,interacting with each other could be tough to understand.

Multiple database make it complex to maintain transactional consistency.

This is one of the most talked about problem of a microservice architecture . In a monolith , it is one database where all modules related tables are there . It is easy to maintain transactional consistency . For example , if one the operation fails we can easily rollback entire transaction. In microservices , all services have different databases. Many a times one operation requires interaction with multiple services. To guarantee a transaction in all databases over different servers it not possible. To avoid it we use eventual consistency but still transaction consistency is complex.We need to design fail over scenarios well in advance.

Tough to test

One single database , one application , single source to to test is obviously easy than to test one operation where multiple miroservices with multiple database are interacting.

Could be tough to deploy

So many microservices , and over that one depending on another , with so many different technology stack is challenging for sure.

Now after reading above , if you are designing microservices you must ask is it required. Do I have to deal with so many transaction and incming requests that we need to decompose monolith. Will I have infrastructure ready at will to scale microservices or new one. If your answer is yes, please go ahead but always remember MICROSERVICES are not silver bullet.

User Service

This microservice will help us to create user and call another microservice i.e. TODO microservice to get all the todos assigned to user and return user along with its todos.

A simple microservice .
Manages users
- Create /Update/Delete User

User service in this tutorial runs on port 8082.

Important APIs of User Service

Create User

URL : http://localhost:8082/v1/user
METHOD TYPE: POST
Request Body :

{
  "firstName":"Ray",
  "lastName":"mcfallen",    
   "userName":"ray",
  "email":"ray@codingsaint.com"
}

Response Body:

{
'id':2,
"firstName":"Ray",
"lastName":"mcfallen",  
"userName":"ray",
"email":"ray@codingsaint.com"
}

Get User With tasks

URL : http://localhost:8082/v1/user/2/tasks
METHOD TYPE: GET
Response Body

TODO Service

ToDo Service will be used to create task for users, It create task and assign it to particular user based on user id.

Important APIs of User Service

Create Task

URL : http://localhost:8083/task
METHOD TYPE: POST
Request Body :

{ 
"name":"Create Micoservice Couse : Config Server", 
"description":"Create Video tutorial task service",   
"isDone":false, 
  "targetDate":"2019-08-05", 
    "userId":2, 
      "categories":[   
         {"name":"Microservice Tutorial"
         }
         ]
}

Response Body:

{ 
"id":2,
"name":"Create Micoservice Couse : Config Server", 
"description":"Create Video tutorial task service",   
"isDone":false, 
  "targetDate":"2019-08-05", 
    "userId":2, 
      "categories":[   
         {"name":"Microservice Tutorial"
         }
         ]
}

Get tasks of a User

URL : http://localhost:8083/user/2/tasks
METHOD TYPE: GET

Feign Declarative REST Client

Feign Declarative REST client helps us to remove boilerplate code of REST API.
We will use it in User Service to remove rest call to task service where we had been using rest template.
In order to do that

add openfeign at pom.xml

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Add annotation at User application main class

 @EnableFeignClients

Create a Service class with annotation @FeignClient and method for Feign as below

@Service
@FeignClient(name="task-service" ,url="http://localhost:8083/")
public interface TaskService {
@RequestMapping("user/{id}/tasks")
ResponseEntity<List<Task> > userTasks(@PathVariable ("id") Long userId);
}

Remove Rest call at Controller and user TaskService method

ResponseEntity<List<Task>> tasks =taskService.userTasks(id);

Ribbon Load Balancer

Load balancing is important factor when communicating between multiple microservices.
In our example We will be running 2 instances of Todo Service and 1 User Service , We will add ribbon at user service toload balance Todo service calls.
Steps to add Ribbon load balancer.

Add Ribbon dependency

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

Modify TaskService as below. Notice that FeignClient with URL is commented , its just for your reference ,it can be removed

@Service
//@FeignClient(name="task-service" ,url="http://localhost:8083/")
@FeignClient(name="task-service" )
@RibbonClient(name="task-service")
public interface TaskService {
    @RequestMapping("user/{id}/tasks")
    ResponseEntity<List<Task> > userTasks(@PathVariable ("id") Long userId);
}

Now add List of servers for Task Service at application.yml

task-service:
  ribbon:
    listOfServers: http://localhost:8083/,http://localhost:8085/

This will enable the task service instances to be picked from yaml file.

Service Discovery in Microservices using Eureka

The problem with above approach is to define list of servers with every new instances coming up and down. We would certainly not want to do it as it will require to restart services after change in application.yml
We can use Eureka Service discovery to avoid it.

Steps to create Eureka Service Discovery Server

Go to https://start.spring.io
Select Eureka as dependency and download the project
Import project to IDE
At Main class add @EnableEurekaServer annotation.
Add server.port =8761 to start at different port. #### Connecting clients to Eureka for discovery At User service and Task service pom
Add dependency for Eureka client

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

Add Eureka server location to connect at application.yml

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

Use of Config Server

To manage configuration of different services effectively we use config server. Config server is a separate microservice which keeps track of configurations.

Steps to create config server

Go to https://start.spring.io
Select config server as dependency and download the project
Import project to IDE
At Main class add @EnableConfigServer annotation.
Add server.port =9000 to start at different port.
Create another git project and add configuration files to it. For example user service should have a file names user-service.yml and task-service should have a file named task-service.yml
Add location of git in application.yml of config-server

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/CODINGSAINT/config.git
  application:
    name: config-server

Connecting clients to Config server

At User service and Task service pom

Add dependency for config client

 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

Create a file bootstrap.yml and add config server location to connect at bootstrap.yml

spring:
  application:
    name: user-service
  cloud:
    config:
      uri: 
        - http://localhost:9000

Now at start up services will connect to config server to get there configurations.*

Zuul API gateway

Different microservices will have different ports and many times we require to perform operations (filters) before these incoming requests even hit our services.
To perform better operations for incoming request we will add a gateway . We call it Zuul API gateway in our case.
#### Create API gateway

Go to https://start.spring.io
- Select Zuul API gateway as dependency and download the project
- Import project to IDE
- At Main class add @@EnableZuulProxy annotation.
- create file bootstrap.yml and delete application.yml
- Add below configuration for it

 spring:
  application:
    name: api-gateway
  cloud:
    config:
      uri: 
        - http://localhost:9000

Create file named api-gateway.yml and commit at config git project created above
Below are content for api-gateway.yml

  spring:
  application:
    name: api-gateway
  cloud:
    config:
      uri: 
        - http://localhost:9000

zuul:
  prefix: /api
  routes:
    user-service:
      path: /user-service/**
      service-id: user-service
    task-service:
      path: /task-service/**
      service-id: task-service

#Eureka
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

In above configuration routes configurations will help us to add routes for different services.
To access URL of any service we can add service-name and hit postman for example to access user-service url for getting user-service and its respective task we can use
http://localhost:8080/user-service/v1/user/2/tasks
Where user service URL was
http://localhost:8082/v1/user/2/tasks

Developing First Spring Boot Application

Coding Saint — Wed, 19 Feb 2020 09:35:50 +0000

Spring Boot currently support Java, Kotlin and Groovy as language preference to create an application. You can also choose Maven or Gradle as a build automation tool. You can choose your favourite IDE ranging from Netbeans, IntelliJ ,Eclipse or Spring Tool Suite.

We will be using Java and Maven with Spring Tool Suite.

We can create a Spring Boot application in different ways.

Creating a maven project and adding dependencies
Using Spring Tool Suite (STS )/IntelliJ built in feature
Using Spring Initializr : https://start.spring.io

We will be using STS built in feature and will also look at Spring Initializr. In order to create first spring boot application using STS , click on File → New → Spring Starter Project.

It will open a popup , where default values can be modified.

We have modified name, group ,artifact and package default values.

Once modified as per your requirement ,click “Next”.

Now select Web from web stack and Devtools from Core stack.

Selecting Dev Tool is optional. It is just because of personal choice of not starting application again and again on saving the files. We will learn about DevTool later.

Web is an obvious choice as we are going to learn a web based Spring Boot application.

Click Finish. Now we have a sample Spring boot application ready to go.

After clicking on finish , we will have project structure as shown in figure below.

Here UserServiceApplication.java inside com.codingsaint.userservice is the main class and entry point to our application.

Every Spring Boot Application has a main class, which acts as the entry point to application.

Let’s run it and see if Spring Boot application is really this easy to start and run. You can run it as a Java Application by right clicking on file and selecting Run as from menu and selecting “ Java Application” or “Spring Boot App” as an option.

Once you run it , you can see output as below on console ,where it does tell that application is running on port 8080.

In browser open http://localhost:8080/ and verify if server is up. Following output with 404 (default 404 of Spring Boot application) tells that server is up and running and obviously we have nothing mapped to be displayed for base URL so we are seeing this 404 error page.

In Next section , we will see how to handle incoming requests properly. We will also dive in Spring Boot Basics

Quarkus IO : Supersonic Subatomic Mircoservices Introduction

Coding Saint — Tue, 18 Feb 2020 09:32:03 +0000

Quarkus IO : Supersonic Subatomic Mircoservices ready framework course

Introduction

Quarkus IO is a microservices based java framework. According to QuarkusIO website , Quarkus is "A Kubernetes Native Java stack tailored for OpenJDK HotSpot & GraalVM, crafted from the best of breed Java libraries and standards". This course will talks about creating microservices based on Quarkus. We will be going through

Installing required software for understanding full features of Quarkus
Building Todo and User Microservices using Quarkus
Building superfast native images
Writing test cases
Using Hibernate and Mongodb database as backend
Creating microservices architecture using Fallbacks and distributed logginh
deploying them in cloud

Installing Software

In this section we will look at installing software required for this course. This is a prerequisite if you want to follow along this course. We will be installing . We will be installing on Linux based system but you can install on your desired operation system

JDK 1.8+
Maven 3.6.X
GraalVM
Docker

JDK

To install JDK go to official website and download the latest version for your operating system.On a linux laptop with Ubuntu you can follow the steps as well

Open terminal

write following commands

        sudo add-apt-repository ppa:openjdk-r/ppa
        sudo apt update
        sudo apt install open-jdk-8-jdk
        export JAVA_HOME=/usr/lib/jvm/java-8-openjdk
        export PATH=$PATH:$JAVA_HOME/bin

Check the installed version

java -version

Maven 3.6.X

Maven is a build tool it will help us to create builds effectively. To install maven visit maven website and download latest maven. Unzip it and add to path. JAVA_HOME must be set to use maven

unzip apache-maven-3.6.3-bin.zip
            export PATH=/opt/apache-maven-3.6.3/bin:$PATH

GraalVM

GraalVM is a virtual machine by oracle which enables user to create native images. Native images are faster and has lower memory footprint. GraamVM enable local executables and the binary created by it is independent of JVM it runs faster. It must be noticed that while creating native builds GraalVM do analyse all the classes your code will use at its entire life cycle and the compiles to byte code , the entire process is a bit slow. Run below commands to install GraalVM on linux (ubuntu)

            sudo apt-get install build-essential libz-dev zlib1g-dev

You can install GraamVM community edition or can download enterprise edition from oracle website. If you have a enterprise edition tar file downloaded

            tar -xvf graalvm-ee-java11-linux-amd64-19.3.1.tar.gz
            export GRAALVM_HOME=/home/coding/Documents/Softwares/graalvm-ee-java11-19.3.1/

If you have enterprise edition installed download native jar and run following command

            ${GRAALVM_HOME}/bin/gu install native-image --filr native-image-installable-svm-svmee-java11-linux-amd64-19.3.1.jar

Docker

To install docker at Ubuntu we can use following commands

         sudo apt install apt-transport-https ca-certificates curl software-properties-common
         curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
         sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic test"
         sudo apt update
         sudo apt install docker-ce

For detailed documentation of installation on any platform https://docs.docker.com/

Creating User Microservices

In this section we will create our first microservice. We will create user-service which will help us to perform crud operations on user. User service will have mogodb as back end . We will create it using maven command ,Alternatively we can also use generator site i.e https://code.quarkus.io

Creating user-service using maven

Open terminal and type following command.

        mvn io.quarkus:quarkus-maven-plugin:1.2.0.Final:create \
            -DprojectGroupId=com.codingsaint.learning.quarkus \
            -DprojectArtifactId=user-service \
            -DclassName="com.codingsaint.learning.quarkus.UserResource" \
            -Dpath="/user"

While the above command will only a bare project which you can run using simple maven command. We will be adding the dependencies later , just to understand how can we use quarkus maven extension to add dependencies ,Obviously both steps can be combined together.

         cd user-service
         mvn quarkus:dev

Running application in dev mode

The command to run in dev mode is

         mvn quarkus:dev

This will start the server in dev mode.In dev mode if you edit the code and do a change it will stop quarkus (not JVM), recompile and start quarkus . This works as live reload and is very helpful in dev mode

building native image

Quarkus comes with integrated support for building native images , you can build bare metal or docker based images.To create a image run the below command

mvn package -Pnative

It must be noted that this is a maven profile for building native images and to support this GraalVM must be installed with native jar as mentioned above. To build native for docker image add

-Dnative-image.docker-build=true

Adding dependencies

We will be using below command to add dependecies

mvn quarkus:add-extension -Dextensions=hibernate-validator,mongodb-panache,resteasy-jsonb

It must be noted that we could have added extensions while creating the project itself adding -D extension , this is just to show , how to add dependencies using maven. You can find list of all the available dependencies at https://quarkus.io/extensions/

Creating User entity

        `package com.codingsaint.learning.quarkus;

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;

    import javax.validation.Valid;
    import javax.ws.rs.*;
    import javax.ws.rs.core.MediaType;
    import javax.ws.rs.core.Response;
    import java.util.UUID;

    @Path("/users")
    public class UserResource {

        private static final Logger LOGGER = LoggerFactory.getLogger(UserResource.class);

        /**
         * Get all of the users
         *
         * @return Response> users
         */
        @GET
        @Produces(MediaType.APPLICATION_JSON)
        public Response users() {
            return Response.ok(User.listAll()).build();
        }

        /**
         * Create the user
         *
         * @param user
         * @return
         */
        @POST
        @Produces(MediaType.APPLICATION_JSON)
        @Consumes(MediaType.APPLICATION_JSON)
        public Response users(final @Valid User user) {
            user.setUserId(UUID.randomUUID().toString());
            user.setActive(true);
            User.persist(user);
            return Response.ok().build();
        }

        /**
         * Update the user
         *
         * @param user
         * @return
         */
        @PUT
        @Produces(MediaType.APPLICATION_JSON)
        @Consumes(MediaType.APPLICATION_JSON)
        public Response update(final @Valid User user) {
            user.update();
            return Response.ok(user).build();
        }

        /**
         * retrieve user based on userId
         *
         * @param userId
         * @return Response */
        @GET
        @Produces(MediaType.APPLICATION_JSON)
        @Consumes(MediaType.APPLICATION_JSON)
        @Path("id/{id}")
        public Response getUserByUserId(@PathParam("id") String userId) {
            User user = User.findByUserId(userId);
            LOGGER.info(" finding user based on userId {}", userId);
            return Response.ok(user).build();
        }

        /**
         * delete user based on userId
         * @param userId
         * @return
         */
        @DELETE
        @Path("id/{id}")
        public Response deleteUser(@PathParam("id") String userId) {
            LOGGER.info(" delete user based on userId {}", userId);
            User.delete("userId",userId);
            return Response.noContent().build();
        }

    }`

Adding UserResource

            package com.codingsaint.learning.quarkus;

            import javax.validation.Valid;
            import javax.ws.rs.*;
            import javax.ws.rs.core.MediaType;
            import javax.ws.rs.core.Response;
            import java.util.UUID;

            @Path("/user")
            public class UserResource {

            @GET
            @Path("/all")
            @Produces(MediaType.APPLICATION_JSON)
            public Response users() {
            return Response.ok(User.findAll().list()).build();
            }
            @POST
            @Produces(MediaType.APPLICATION_JSON)
            @Consumes(MediaType.APPLICATION_JSON)
            public Response users(final @Valid User user) {
            user.setUserId(UUID.randomUUID().toString());
            user.setActive(true);
            User.persist(user);
            return Response.ok().build();
            }
            }

Adding application properties

            quarkus.mongodb.connection-string = mongodb://localhost:27017
            quarkus.mongodb.database=todo-users

Running the server

Run the server using below command

            mvn quarkus:dev

Add a user

Add following curl command or use postman or other software to do a post

curl -X POST \
            http://localhost:8080/user \
            -H 'Content-Type: application/json' \
            -d '{
            "firstName":"Kumar",
            "lastName":"Pallav",
            "dateOfBirth":"1987-08-05",
            "email":"codingsaint@gmail.com"

Retrieve all users

Use a get request http://localhost:8080/user/all or do a curl as below

            curl -X GET \
            http://localhost:8080/user/all \

You will get a response like

            [{

            "id": "5e430af58cd12948d22faa9a",

            "active": true,

            "dateOfBirth": "1987-08-05",

            "email": "codingsaint@gmail.com",

            "firstName": "Kumar",

            "lastName": "Pallav",

            "userId": "10905021-e7c5-43e2-a29e-8a42f69d4fb2"

            }]