DEV Community: Djomkam Kevin

Covid Symptom Reporting using Amazon Connect, Lex and Lambda (High Level View)

Djomkam Kevin — Thu, 19 Aug 2021 18:43:52 +0000

Amazon Connect

Amazon Connect makes it easy for you to set up and manage a customer contact center and provide reliable customer engagement at any scale. With Amazon Connect you can deploy a customer contact center with just a few clicks in the AWS management console, on-board agents from anywhere, and quickly begin to engage with your customers.

Amazon Connect provides a seamless experience across voice and chat for your customers and agents. This includes one set of tools for skills-based routing, task management, powerful real-time and historical analytics, and intuitive management tools – all with pay-as-you-go pricing, which means Amazon Connect simplifies contact center operations, improves agent efficiency, and lowers costs.

After creating a contact flow on connect, you can set up a phone number which customers will use to interact with our applications or our agents for support.

For this use case, we are setting up a covid symptom reporting through which users can call to report their status or ask for information related to Covid.

When user calls they are linked to the contact flow which proposes the different options available for them select what they are interested in.

If the users wants to report their covid status, they select 1 on their phone and they will be taken to the status reporting flow.

As shown in the figure above, Amazon Lex enables us to create a chatbot which we can link to our contact flow in connect.

Lex is backed by a lambda function which performs all the necessary processing and can also interact with an API hosted on premises or at any other server. After the processing is done, a successful message is returned to the user who can hangup or ask for other information.

This post is a high level view of what is possible with amazon connect; in futur posts more details will be provided on how to create a contact flow, how to create a queue in a contact flow, how to create a bot in amazon lex and link to connect and how to create a lambda function to process requests from Lex.

Installing ELK stack on ubuntu 14.04

Djomkam Kevin — Thu, 19 Aug 2021 02:29:43 +0000

Pre-requisite

Make sure java 8 is installed and also set java_home to /etc/default/elasticsearch

Installing Elasticsearch

Before starting, you will need to import the Elasticsearch public GPG key into apt. You can do this with the following command:

sudo wget -qO - https://packages.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

Then, you will need to add Elastic's package source list to apt.
To do this open the sources.list file:

sudo nano /etc/apt/sources.list

Add the following line:

deb http://packages.elastic.co/elasticsearch/2.x/debian stable main

Save the file and update the repository with the following command:

sudo apt-get update

Now, install the Elasticsearch with the following command:

sudo apt-get -y install elasticsearch

Once elasticsearch is installed, you will need to restrict outside access to the Elasticsearch instance, you can do this by editing the elasticsearch.yml file.

sudo /etc/elasticsearch/elasticsearch.yml

Find the line network.host and replace its value with localhost (previous value is 192.168.0.1)

Save the file and start elasticsearch service:

sudo /etc/init.d/elasticsearch start

Next, enable elasticsearch service to start at boot with the following command:

sudo update-rc.d elasticsearch defaults

Now, elasticsearch is up and running, it's time to test elasticsearch.
You can test elasticsearch with the following curl command:

curl localhost:9200

Installing Logstash

By default Logstash is not available in Ubutnu repository, so you will need to add Logstash source list to apt.

sudo nano /etc/apt/sources.list

Add the following line:

deb http://packages.elastic.co/logstash/2.2/debian stable main

Save the file and update the repository:

sudo apt-get update

Now, install the logstash with the following command:

sudo apt-get install logstash

Configure Logstash

Once logstash is installed, you will need to configure the logstash file located at /etc/logstash/conf.d directory. The configuration consists of three parts: inputs, filters, and outputs.
Before configuring logstash, create a directory for storing certificate and key for logstash.

sudo mkdir -p /etc/pki/tls/certs sudo mkdir /etc/pki/tls/private

Next, add IP address of ELK server to OpenSSL configuration file:

sudo nano /etc/ssl/openssl.cnf

Find the section [ v3_ca] and add the following line:

subjectAltName = IP: 192.168.1.7

Save the file and generate SSL certificate by running the following command:
Where 192.168.1.7 is your ELK server IP address.

cd /etc/pki/tls sudo openssl req -config /etc/ssl/openssl.cnf -x509 -days 3650 -batch -nodes -newkey rsa:2048 -keyout private/filebeat.key -out certs/filebeat.crt

Note that you will need to copy this certificate to every client whose logs you want to send to the ELK server.

Now, create the filebeat input configuration file with the following command:

sudo nano /etc/logstash/conf.d/beats-input.conf

Add the following lines:

input {  
      beats {
        port => 5044
        type => "logs"
        ssl => true
        ssl_certificate => "/etc/pki/tls/certs/filebeat.crt"
        ssl_key => "/etc/pki/tls/private/filebeat.key"
      }
    }

Next, create logstash filters config file:

sudo nano /etc/logstash/conf.d/syslog-filter.conf

Add the following lines:

filter {  
      if [type] == "syslog" {
        grok {
          match => { "message" => "%{SYSLOGTIMESTAMP:syslog_timestamp} %{SYSLOGHOST:syslog_hostname} %{DATA:syslog_program}(?:[%{POSINT:syslog_pid}])?: %{GREEDYDATA:syslog_message}" }
          add_field => [ "received_at", "%{@timestamp}" ]
          add_field => [ "received_from", "%{host}" ]
        }
        syslog_pri { }
        date {
          match => [ "syslog_timestamp", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
        }
      }
    }

Last, create logstash outputs config file:

sudo nano /etc/logstash/conf.d/output.conf

Add the following lines:

output {  
      elasticsearch {
        hosts => ["localhost:9200"]
      }
      stdout { codec => rubydebug }
    }

Save the file.
Edit the file /etc/default/logstash with the below:

JAVACMD=/home/djomkam/Desktop/jdk1.8.0_162 /bin/java
export  JAVACMD

Test your Logstash configuration with the following command:

sudo service logstash configtest

The output will display Configuration OK if there are no errors. Otherwise, check the logstash log to troubleshoot problems.

Next, restart logstash service and enable logstash service to run automatically at bootup:

sudo /etc/init.d/logstash restart 
sudo update-rc.d logstash defaults

Installing Kibana

To install Kibana, you will need to add Elastic's package source list to apt.
You can create kibana source list file with the following command:

sudo echo "deb http://packages.elastic.co/kibana/4.4/debian stable main" | sudo tee -a /etc/apt/sources.list.d/kibana-4.4.x.list

Next, update the apt repository with the following command:

sudo apt-get update

Finally, install Kabana by running the following command:

sudo apt-get -y install kibana

Once kibana is installed, you will need to configure kibana. You can do this by editing it's configuration file:

sudo nano /opt/kibana/config/kibana.yml

Change the following line:

server.port: 5601
server.host: localhost

Now, start the kibana service and enable it to start at boot:

sudo /etc/init.d/kibana start 
sudo update-rc.d kibana defaults

You can verify whether kibana is running or not with the following command:

netstat –pltn

Once kibana is installed, you will need to download sample Kibana dashboards and Beats index patterns. You can download the sample dashboard with the following command:

curl -L -O https://download.elastic.co/beats/dashboards/beats-dashboards-1.1.0.zip

Once download is complete, unzip the downloaded file with the following command:

unzip beats-dashboards-1.1.0.zip

Now, load the sample dashboards, visualizations and Beats index patterns into Elasticsearch by running the following command:

cd beats-dashboards-1.1.0 
./load.sh

You will find the following index patterns in the the kibana dashboard:

packetbeat-*
topbeat-*
filebeat-*
winlogbeat-*

Here, we will use only filebeat to forward logs to Elasticsearch, so we will load a filebeat index template into the elasticsearch.
To do this, download the filebeat index template.

curl -O https://gist.githubusercontent.com/thisismitch/3429023e8438cc25b86c/raw/d8c479e2a1adcea8b1fe86570e42abab0f10f364/filebeat-index-template.json

Now load the following template by running the following command:

curl -XPUT 'http://localhost:9200/_template/filebeat?pretty' -d@filebeat-index-template.json

If the template loaded properly, you should see the following output:

{
      "acknowledged" : true
}

Installing Nginx

ou will also need to install Nginx to set up a reverse proxy to allow
To install Nginx, run the following command:

sudo apt-get install nginx

You will also need to install apache2-utils for htpasswd utility:

sudo apt-get install apache2-utils

Now, Create admin user to access Kibana web interface using htpasswd utility:

sudo htpasswd -c /etc/nginx/htpasswd.users admin

Enter password as you wish, you will need this password to access Kibana web interface.
Next, open Nginx default configuration file:

sudo nano /etc/nginx/sites-available/default

Delete all the lines and add the following lines:

server {
        listen 80;
        server_name 192.168.1.7;
        auth_basic "Restricted Access";
        auth_basic_user_file /etc/nginx/htpasswd.users;
        location / {
        proxy_pass http://localhost:5601;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        }
}

Save and exit the file. Nginx now directs your server's traffic to the Kibana server, which is listening on localhost:5601. Now restart Nginx service and enable it to start at boot:

sudo systemctl start nginx
sudo systemctl enable nginx

Now, Kibana is accessible via the public IP address of your ELK server. The ELK server is now ready to receive filebeat data, now it's time to set up Filebeat on each client server.

Setup Filebeat on the Client Server

You will also need to setup filebeat on each Ubuntu server that you want to send logs to Logstash on your ELK Server.

Before setting up filebeat on the client server, you will need to copy the SSL certificate from ELK server to your client server.

On the ELK server, run the following command to copy SSL certificate to client server:

scp /etc/pki/tls/certs/filebeat.crt user@client-server-ip:/tmp/

Where user is the username of the client server and client-server-ip is the IP address of the client server

Now, on client server, copy ELK server's SSL certificate into appropriate location:
First, create directory structure for SSL certificate:

sudo mkdir -p /etc/pki/tls/certs/

Then, copy certificate into it:

sudo cp /tmp/filebeat.crt /etc/pki/tls/certs/

Now, it's time to install the filebeat package on the client server.

To install filebeat, you will need to create source list for filebeat, you can do this with the following command:

echo "deb https://packages.elastic.co/beats/apt stable main" | sudo tee -a /etc/apt/sources.list.d/beats.list

Then, add the GPG key with the following command:

wget -qO - https://packages.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

Next, update the repository with the following command:

sudo apt-get update

Finally install filebeat by running the following command:

sudo apt-get install filebeat

Once filebeat is installed, start filebeat service and enable it to start at boot:

sudo /etc/init.d/filebeat start sudo update-rc.d filebeat defaults

Next, you will need to configure Filebeat to connect to Logstash on our ELK Server. You can do this by editing the Filebeat configuration file located at /etc/filebeat/filebeat.yml.

sudo nano /etc/filebeat/filebeat.yml

Change the file as shown below:

filebeat:
      prospectors:
        -
          paths:
            - /var/log/auth.log
            - /var/log/syslog
          #  - /var/log/*.loginput_type: logdocument_type: syslogregistry_file: /var/lib/filebeat/registryoutput:
      logstash:
        hosts: ["192.168.1.7:5044"]
        bulk_max_size: 1024tls:
          certificate_authorities: ["/etc/pki/tls/certs/filebeat.crt"]shipper:
logging:
      files:
        rotateeverybytes: 10485760 # = 10MB

Save the file and restart filebeat service:

sudo /etc/init.d/filebeat restart

Now Filebeat is sending syslog and auth.log to Logstash on your ELK server.

Once everything is up-to-date, you will need to test whether Filebeat on your client server should be shipping your logs to Logstash on your ELK server.

To do this, run the following command on your ELK server:

curl -XGET 'http://localhost:9200/filebeat-*/_search?pretty'

You can also test filebeat by running the following command on Client Server:

sudo filebeat -c /etc/filebeat/filebeat.yml -e –v

Allow ELK Through Your Firewall

Next, you will need to configure your firewall to allow traffic to the following ports. You can do this by running the following command:

sudo iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 5601 -j ACCEPT sudo iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 9200 -j ACCEPT sudo iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 80 -j ACCEPT sudo iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 5044 -j ACCEPT

Now, save the iptables rules with the following command:

sudo service iptables save

Finally, restart iptables service with the following command:

sudo service iptables restart

Access the Kibana Web Interface

When everything is up-to-date, it's time to access the Kibana web interface.

On the client computer, open your web browser and type the URL http://your-elk-server-ip, Enter "kibana" credentials that you have created earlier, you will be redirected to Kibana welcome page.

Then, click filebeat* in the top left sidebar, and click on the status of the ELK server. You should see the status of the ELK server.

How to Set Up Distributed Tracing in Microservices with Spring Boot, Zipkin or the ELK Stack

Djomkam Kevin — Wed, 18 Aug 2021 22:42:00 +0000

Pre-requisite

Have Basic understanding of how to set up a microservice using spring boot and spring cloud.
Install the zipkin server
Install Elasticsearch, logstash and kibana

Installing and running Zipkin Server

In order to install the zipkin server, there are two ways:

If you have Java 8 or higher installed, the quickest way to get started is to fetch the Latest release as a self-contained executable jar:

curl -sSL https://zipkin.io/quickstart.sh | bash -s java -jar zipkin.jar

If you have docker installed, you can use the following to run the latest image directly:

docker run -d -p 9411:9411 openzipkin/zipkin

Install Elsaticsearch, Logstash, Kibana

There are also two ways to install and use the ELK stack:

The elk stack can be run through docker by running the following commands:

docker run -d --name elasticsearch --net es -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:6.7.2

Create a file logstash.conf with the following content:

input {
  tcp {
    port => 5000
    codec => json
  }
}
output {
  elasticsearch {
    hosts => ["http://elasticsearch:9200"]
    index => "micro-%{appname}"
  }
}

Then run the following command:

docker run -d --name logstash --net es -p 5044:5044 -v ~/logstash.conf:/usr/share/logstash/pipeline/logstash.conf docker.elastic.co/logstash/logstash:6.7.2

Finally, run kibana with the following:

docker run -d --name kibana --net es -e "ELASTICSEARCH_URL=http://elasticsearch:9200" -p 5601:5601 docker.elastic.co/kibana/kibana:6.7.2

The ELK stack can also be installed by navigating to https://www.elastic.co/downloads/ and downloading elasticsearch, logstash and kibana on the filesystem and unzipping them.

ElasticSearch

Unzip the archive
Run bin/elasticsearch (or bin\elasticsearch.bat on Windows)
Run curl http://localhost:9200/ or Invoke-RestMethod http://localhost:9200 with PowerShell

Kibana

Unzip the archive
Open config/kibana.yml in an editor
Set elasticsearch.hosts to point at your Elasticsearch instance
Run bin/kibana (or bin\kibana.bat on Windows)
Point your browser at http://localhost:5601

LogStash

Unzip the archive
Prepare a logstash.conf config file
Run bin/logstash -f logstash.conf

Building the Microservice architecture and integrating tracing

STEP 1: Building the config server with spring cloud config

To enable Spring Cloud Config feature for an application, first include spring-cloud-config-server to your project dependencies.

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

Then enable running embedded configuration server during application boot use @EnableConfigServer annotation.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }

}

By default Spring Cloud Config Server store the configuration data inside Git repository. This is very good choice in production mode, but for the purpose of this tutorial a file system backend will be enough. It is really easy to start with config server, because we can place all the properties in the classpath. Spring Cloud Config by default search for property sources inside the following locations: classpath:/, classpath:/config, file:./, file:./config.

We place all the property sources inside src/main/resources/config. The YAML filename will be the same as the name of service. For example, YAML file for discovery-service will be located here: src/main/resources/config/discovery-service.yml.

And last two important things. If you would like to start config server with file system backend you have to activate the native profile. It may be achieved by setting parameter --spring.profiles.active=native during application boot or setting it in the properties file. Set the server port by setting property server.port in bootstrap.yml file but we will use 8888. Now, all other applications, including discovery-service, need to add spring-cloud-starter-config dependency in order to enable config client.

STEP 2: Building the discovery Service with spring cloud Netflix Eureka

In order for us to set up the discovery service, we also have to include the dependency to spring-cloud-starter-netflix-eureka-server.

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

Then you should enable running embedded discovery server during application boot by setting @EnableEurekaServer annotation on the main class.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class DiscoveryServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(DiscoveryServiceApplication.class, args);
    }

}

Application has to fetch property source from configuration server. The minimal configuration required on the client side is an application name and config server’s connection settings.

spring:
  application:
    name: discovery-service
  cloud:
    config:
      uri: http://localhost:8888

The configuration file discovery-service.yml should contain the below configurations and should be placed inside the config-service module. For standalone Eureka instances we have to disable the registration and fetching registry.

server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

STEP 3: Building Microservice using spring boot and spring cloud

Our microservice has to perform some operations during boot. It needs to fetch configuration from config-service, register itself in discovery-service and expose HTTP API. To enable all these mechanisms we need to include some dependencies in pom.xml. To enable config client we should include starter spring-cloud-starter-config. Discovery client will be enabled for microservice after including spring-cloud-starter-netflix-eureka-client and annotating the main class with @EnableDiscoveryClient. Here is the list of dependencies required for the sample microservice:

<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-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

And here is the main class of application that enables Discovery Client for the microservice.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class SiteServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(SiteServiceApplication.class, args);
    }

}

Application has to fetch configuration from a remote server, so we should only provide bootstrap.yml file with service name and server URL. In fact, this is the example of Config First Bootstrap approach, when an application first connects to a config server and takes a discovery server address from a remote property source. There is also Discovery First Bootstrap approach, where a config server address is fetched from a discovery server.
bootstrap.yml

spring:
  application:
    name: site-service
  cloud:
    config:
      uri: http://localhost:8888

There are not many configuration settings. Here's the application's configuration file (site-service.yml) stored on a config server. It stores only the HTTP running port and Eureka URL.

site-service.yml

server:
  port: 8090

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

Here’s the code with implementation of REST controller class.

import java.util.List;
import java.util.Optional;

import com.cinema.site.model.Site;
import com.cinema.site.repository.SiteRepository;

import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import lombok.AllArgsConstructor;
import lombok.NonNull;

@AllArgsConstructor
@RestController
@RefreshScope
@RequestMapping("/api")
public class SiteController {

    private final SiteRepository siteRepository;

    @GetMapping("/sites/{userId}")
    public ResponseEntity<List<Site>> getSitesByUser(@NonNull @PathVariable Long userId) {
        return new ResponseEntity<>(siteRepository.findByUserId(userId) ,HttpStatus.OK);
    }
}

STEP 4: Communication between microservices with spring cloud and open feign

Now, we will add another microservice (user service) that communicates with the site service. The user service needs to get the list of sites for a given user ID. That’s why we need to include additional dependency for those modules: spring-cloud-starter-openfeign. Spring Cloud Open Feign is a declarative REST client that uses Ribbon client-side load balancer in order to communicate with other microservice.

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

The alternative solution to Open Feign is Spring RestTemplate with @LoadBalanced. However, Feign provides more elegant way of defining client, so I prefer using it instead of RestTemplate. After including the required dependency we should also enable Feign clients using @EnableFeignClients annotation.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class UserServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }

}

Now, we need to define a client interface. Because user-service communicates with site-service we should create an interface. Every client’s interface should be annotated with @FeignClient. One field inside annotation is required – name. This name should be the same as the name of target service registered in service discovery. Here’s the interface of the client that calls endpoint GET /api/sites/{userId} exposed by user-service.

import java.util.List;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "site-service", fallbackFactory = SiteClientFallbackFactory.class)
public interface SiteClient {

    @GetMapping("/api/sites/{userId}")
    List findAllByUser(@PathVariable(value="userId") Long userId);
}

Sometimes we want to create a fallback method to be executed if the feign client is not able to reach the target service. SiteClientFallbackFactory helps in archiving that.

import java.util.ArrayList;
import java.util.List;

import org.springframework.stereotype.Component;

import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;

@Component
@Slf4j
public class SiteClientFallbackFactory implements FallbackFactory<SiteClient> {
    @Override
    public SiteClient create(Throwable cause) {
        return new SiteClient() {
            @Override
            public List findAllByUser(Long id) {
                log.error(cause.getMessage(), cause);
                return new ArrayList<>();
            }
        };
    }
}

Finally, we have to inject the Feign client’s beans to the REST controller through the service. Now, we may call the methods defined inside SiteClient, which is equivalent to calling REST endpoints.

import java.util.List;
import java.util.Optional;

import com.cinema.user.client.SiteClient;
import com.cinema.user.model.User;
import com.cinema.user.repository.UserRepository;

import org.springframework.stereotype.Service;

import lombok.AllArgsConstructor;

@AllArgsConstructor
@Service
public class UserServiceImpl implements UserService {

    private final UserRepository userRepository;
    private final SiteClient siteClient;

    @Override
    public List<User> findAll() {
        return userRepository.findAll();
    }

    @Override
    public List findAllSitesByUser(final Long userId) {
        return siteClient.findAllByUser(userId);
    }
}

import java.util.List;
import java.util.Optional;

import com.cinema.user.model.User;
import com.cinema.user.service.UserService;

import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import lombok.AllArgsConstructor;
import lombok.NonNull;

@AllArgsConstructor
@RestController
@RefreshScope
@RequestMapping("/api")
public class UserController {

    private final UserService userService;

    @GetMapping("/users")
    public ResponseEntity<List<User>> getUsers() {
        return new ResponseEntity<>(userService.findAll(), HttpStatus.OK);
    }

    @GetMapping("/users/sites/{userId}")
    public ResponseEntity<List> getUserSites(@PathVariable("userId") Long id) {
        Optional<User> user = userService.findOne(id);
        if(user.isPresent())
            return new ResponseEntity<>(userService.findAllSitesByUser(id), HttpStatus.OK);
        else
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
    }
}

STEP 5: Building API gateway using spring cloud Netflix Zuul (edge-service)

Spring Cloud Netflix Zuul is a Spring Cloud project providing API gateway for microservices. API gateway is implemented inside module edge-service. First, we should include starter spring-cloud-starter-netflix-zuul to the project dependencies.

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

We also need to have discovery client enabled, because edge-service integrates with Eureka in order to be able to perform routing to the downstream services.

spring:
  application:
    name: edge-service
  cloud:
    config:
      uri: http://localhost:8888

Here's the application's configuration file (edge-service.yml) stored on a config server. It stores only the HTTP running port and Eureka URL.

server:
  port: 8190

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.liquibase.LiquibaseProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableDiscoveryClient
@EnableZuulProxy
@EnableConfigurationProperties({LiquibaseProperties.class, ApplicationProperties.class})
public class EdgeServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(EdgeServiceApplication.class, args);
    }

}

STEP 6: Correlating Logs between different microservices using spring cloud sleuth and zipkin

Correlating logs between different microservice using Spring Cloud Sleuth is very easy. In fact, the only thing you have to do is to add starter spring-cloud-starter-sleuth to the dependencies of every single microservice and gateway.

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

In order to configure zipkin, add the dependency below to every microservice's pom.xml file

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

Then add the following to the yml file of each microservice in the config server:

spring:
  zipkin:
    baseUrl: http://localhost:9411/
  sleuth:
    sampler:
      probability: 1

Assuming the zipkin server is responding on localhost at port 9411

STEP 7: Configuring microservices to send logs to logstash

Sending microservice logs to logstash requires the following dependencies to be added to each and every microservice.

<dependency>
    <groupId>net.logstash.logback</groupId>
    <artifactId>logstash-logback-encoder</artifactId>
    <version>5.3</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>
    <version>1.2.3</version>
</dependency>

The next configuration to add is to create a file called logback.xml in resource folder of every microservice with the following contents:

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <include resource="org/springframework/boot/logging/logback/base.xml"/>
    <appender name="logstash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <destination>localhost:5044</destination>
        <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <mdc/>
                <context/>
                <version/>
                <logLevel/>
                <loggerName/>
                <message/>
                <pattern>
                    <pattern>
                        {
                            "appName": "site-service"
                        }
                    </pattern>
                </pattern>
                <threadName/>
                <stackTrace/>
            </providers>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="logstash"/>
    </root>
    <logger name="org.springframework" level="INFO"/>
    <logger name="com.cinema" level="INFO"/>
</configuration>

The steps outlined above if followed diligently will enable you to put in a place distributed tracing in your micro services architectures and be able to visualise your logs through kibana and search through them using elasticsearch.