Agnasarp

Creating a simple SOAP web service with Spring Boot

2021-10-11T21:30:00.465-07:00

Simple soap service with Spring Boot

Hi guys! Today we will give another useful topic if you are really worried about web services or APIs (Application Programming Interface). Literally, a service delivered via the web will be treated as a web service. It is designed for machine-to-machine (application-to-application) communication over a network with interoperability. Among the two most popular web service groups, SOAP (Simple Object Access Protocol) is a kind of old-fashioned web service that is still used in application development contexts at the enterprise level. The transport mechanism of SOAP services is either HTTP or MQ but the format of the request and the response should be SOAP XML. These are the key things of SOAP services and now we will look at how we can implement simple SOAP services using the contract-first approach with Spring Boot. That is about a course management system.

SOAP web services with Spring Boot

Initialize with spring initializr

Let's take a look at the project initialization with https://start.spring.io/

Spring initialzr - SOAP web service

Project build tool: Maven
Language: Java
Spring boot: 2.5.5
Project Metadata

Group: com.agnasarp
Artifact: agnasarp-soap-course-management
Name: agnasarp-soap-course-management
Description: Simple SOAP service with Spring Boot
Package name: com.agnasarp.soapcoursemanagement
Packaging: Jar
Java version: 11

Dependencies:

Spring Web Services: Facilitates contract-first SOAP development. Allows for the creation of flexible web services using one of the many ways to manipulate XML payloads.
Spring Data JPA: Persist data in SQL stores with Java Persistence API using Spring Data and Hibernate.
H2 Database: Provides a fast in-memory database that supports JDBC API and R2DBC access, with a small (2mb) footprint. Supports embedded and server modes as well as a browser based console application.

Project structure

Project structure of SOAP web service in IntelliJ Idea

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.agnasarp</groupId>
    <artifactId>agnasarp-soap-course-management</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>soap-course-management</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>
        <dependency>
            <groupId>wsdl4j</groupId>
            <artifactId>wsdl4j</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.ws</groupId>
            <artifactId>spring-ws-security</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.security</groupId>
                    <artifactId>spring-security-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.wss</groupId>
            <artifactId>xws-security</artifactId>
            <version>3.0</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.xml.crypto</groupId>
                    <artifactId>xmldsig</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- JAXB2 plugin -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>jaxb2-maven-plugin</artifactId>
                <version>2.5.0</version>
                <executions>
                    <execution>
                        <id>xjc</id>
                        <goals>
                            <goal>xjc</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!-- Schema directory -->
                    <sources>
                        <source>${project.basedir}/src/main/resources/course-details.xsd</source>
                    </sources>
                    <!-- Java class output directory -->
                    <outputDirectory>${project.basedir}/src/main/java</outputDirectory>
                    <!-- Package name for generated classes -->
                    <packageName>com.agnasarp.courses</packageName>
                    <!-- Package clean -> false -->
                    <clearOutputDir>false</clearOutputDir>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

application.properties

Normally, the built-in tomcat is running on port 8080, it may be already assigned for other tasks, so we can change it and the context path of the application as below in the application.properties file

server.port=8180
server.servlet.context-path=/agnasarp-soap-course-management

SoapCourseManagementApplication.java

This is the entry point of the Spring Boot application and now you can run the application on the port 8180.

package com.agnasarp.soapcoursemanagement;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SoapCourseManagementApplication {

    //    This is the entry point of the application.
    public static void main(String[] args) {
        SpringApplication.run(SoapCourseManagementApplication.class, args);
    }

}

In the contract-first approach, we have to define all the structures of the requests and responses, so we will define them in the example-files directory as below.

Request.xml

<?xml version="1.0" encoding="UTF-8" ?>
<GetCourseDetailsRequest xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                         xmlns="https://www.agnasarp.com/courses"
                         xsi:schemaLocation="https://www.agnasarp.com/courses course-details.xsd">
    <id>123</id>
</GetCourseDetailsRequest>

Response.xml

<?xml version="1.0" encoding="UTF-8" ?>
<GetCourseDetailsResponse xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                          xmlns="https://www.agnasarp.com/courses"
                          xsi:schemaLocation="https://www.agnasarp.com/courses course-details.xsd">
    <CourseDetails>
        <id>123</id>
        <name>SOAP Web Services</name>
        <description>SOAP Web Services with Spring Boot</description>
    </CourseDetails>
</GetCourseDetailsResponse>

course-details.xsd

This file is to validate all the parameters of SOAP requests and responses. Need to copy and past the same xsd file to the directory /src/main/resources because it should be in the classpath access just by the file name.

<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:tns="https://www.agnasarp.com/courses" xmlns:xs="http://www.w3.org/2001/XMLSchema"
        targetNamespace="https://www.agnasarp.com/courses"
        elementFormDefault="qualified">
    <xs:element name="GetCourseDetailsRequest">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="id" type="xs:int"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="GetCourseDetailsResponse">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CourseDetails" type="tns:CourseDetails"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="GetAllCourseDetailsRequest">
        <xs:complexType>
        </xs:complexType>
    </xs:element>
    <xs:element name="GetAllCourseDetailsResponse">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="CourseDetails" type="tns:CourseDetails" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="DeleteCourseDetailsRequest">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="id" type="xs:int"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:element name="DeleteCourseDetailsResponse">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="status" type="tns:Status"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    <xs:complexType name="CourseDetails">
        <xs:sequence>
            <xs:element name="id" type="xs:int"/>
            <xs:element name="name" type="xs:string"/>
            <xs:element name="description" type="xs:string"/>
        </xs:sequence>
    </xs:complexType>
    <xs:simpleType name="Status">
        <xs:restriction base="xs:string">
            <xs:enumeration value="SUCCESS"/>
            <xs:enumeration value="FAIL"/>
        </xs:restriction>
    </xs:simpleType>
</xs:schema>

WebServiceConfiguration.java

Now we have to configure all configurations here in the WebServiceConfiguratio.java file. Here we will create few beans for a MessageDispatcherServlet, XSD Schema, DefaultWsdl11Definition as below.

package com.agnasarp.soapcoursemanagement.configuration;


import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.ws.config.annotation.EnableWs;
import org.springframework.ws.config.annotation.WsConfigurerAdapter;
import org.springframework.ws.server.EndpointInterceptor;
import org.springframework.ws.soap.security.xwss.XwsSecurityInterceptor;
import org.springframework.ws.soap.security.xwss.callback.SimplePasswordValidationCallbackHandler;
import org.springframework.ws.transport.http.MessageDispatcherServlet;
import org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition;
import org.springframework.xml.xsd.SimpleXsdSchema;
import org.springframework.xml.xsd.XsdSchema;

import java.util.Collections;
import java.util.List;

//Spring configuration
@Configuration
//Enable Spring Web Service
@EnableWs
public class WebServiceConfiguration extends WsConfigurerAdapter {

    //    Create a MessageDispatcherServlet and map a URI
    @Bean
    ServletRegistrationBean messageDispatcherServlet(ApplicationContext applicationContext) {

        MessageDispatcherServlet messageDispatcherServlet = new MessageDispatcherServlet();
        messageDispatcherServlet.setApplicationContext(applicationContext);
        messageDispatcherServlet.setTransformWsdlLocations(true);

        return new ServletRegistrationBean(messageDispatcherServlet, "/ws/*");
    }

    //    Create XSD schema
    @Bean
    public XsdSchema coursesSchema() {

        return new SimpleXsdSchema(new ClassPathResource("course-details.xsd"));
    }

    //    Create a WSDL from the above schema
    @Bean(name = "courses")
    public DefaultWsdl11Definition defaultWsdl11Definition(XsdSchema coursesSchema) {

        DefaultWsdl11Definition defaultWsdl11Definition = new DefaultWsdl11Definition();

        defaultWsdl11Definition.setPortTypeName("CoursePort");
        defaultWsdl11Definition.setTargetNamespace("https://www.agnasarp.com/courses");
        defaultWsdl11Definition.setLocationUri("/ws");
        defaultWsdl11Definition.setSchema(coursesSchema);

        return defaultWsdl11Definition;
    }

    //XwsSecurityInterceptor
    @Bean
    public XwsSecurityInterceptor securityInterceptor() {
        XwsSecurityInterceptor securityInterceptor = new XwsSecurityInterceptor();
        //Callback Handler -> SimplePasswordValidationCallbackHandler
        securityInterceptor.setCallbackHandler(callbackHandler());
        //Security Policy -> securityPolicy.xml
        securityInterceptor.setPolicyConfiguration(new ClassPathResource("securityPolicy.xml"));
        return securityInterceptor;
    }

    @Bean
    public SimplePasswordValidationCallbackHandler callbackHandler() {
        SimplePasswordValidationCallbackHandler handler = new SimplePasswordValidationCallbackHandler();
        handler.setUsersMap(Collections.singletonMap("user", "password"));
        return handler;
    }

    //Interceptors.add -> XwsSecurityInterceptor
    @Override
    public void addInterceptors(List<EndpointInterceptor> interceptors) {
        interceptors.add(securityInterceptor());
    }
}

Course.java

This DTO class is to communicate course details within the application with getters, setters, a constructor, and a toString() method.

package com.agnasarp.soapcoursemanagement.domain;

//DTO for course details
public class Course {

    private int id;
    private String name;
    private String description;

    public Course(int id, String name, String description) {
        this.id = id;
        this.name = name;
        this.description = description;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Override
    public String toString() {
        return "Course{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", description='" + description + '\'' +
                '}';
    }
}

Now we have to define an endpoint for the service that has methods to get the request and return the response. Apart from those methods, there will be few other mapper methods.

CourseDetailsEndpoint.java

package com.agnasarp.soapcoursemanagement.endpoint;

import com.agnasarp.courses.*;
import com.agnasarp.soapcoursemanagement.domain.Course;
import com.agnasarp.soapcoursemanagement.service.CourseDetailsService;
import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;
import org.springframework.ws.server.endpoint.annotation.RequestPayload;
import org.springframework.ws.server.endpoint.annotation.ResponsePayload;

import java.util.List;

//This marks the class as a SOAP endpoint.
@Endpoint
public class CourseDetailsEndpoint {

    CourseDetailsService courseDetailsService;

    public CourseDetailsEndpoint(CourseDetailsService courseDetailsService) {
        this.courseDetailsService = courseDetailsService;
    }

    //    This method processes the GetCourseDetailsRequest and returns the output.
    @PayloadRoot(namespace = "https://www.agnasarp.com/courses", localPart = "GetCourseDetailsRequest")
    @ResponsePayload
    public GetCourseDetailsResponse processGetCourseDetailsRequest(@RequestPayload GetCourseDetailsRequest getCourseDetailsRequest) {

        return courseResponseMapper(courseDetailsService.getCourseById(getCourseDetailsRequest.getId()));
    }

    //    This method processes the GetAllCourseDetailsRequest and returns the output.
    @PayloadRoot(namespace = "https://www.agnasarp.com/courses", localPart = "GetAllCourseDetailsRequest")
    @ResponsePayload
    public GetAllCourseDetailsResponse processGetAllCourseDetailsRequest(@RequestPayload GetAllCourseDetailsRequest getAllCourseDetailsRequest) {

        List<Course> courses = courseDetailsService.getAllCourses();
        return allCourseResponseMapper(courses);
    }

    //    This method delete a specific course from the course list..
    @PayloadRoot(namespace = "https://www.agnasarp.com/courses", localPart = "DeleteCourseDetailsRequest")
    @ResponsePayload
    public DeleteCourseDetailsResponse processGetAllCourseDetailsRequest(@RequestPayload DeleteCourseDetailsRequest deleteCourseDetailsRequest) {

        DeleteCourseDetailsResponse deleteCourseDetailsResponse = new DeleteCourseDetailsResponse();
        deleteCourseDetailsResponse.setStatus(mapStatus(courseDetailsService.deleteCourseById(deleteCourseDetailsRequest.getId())));
        return deleteCourseDetailsResponse;
    }

    //    Map enum status
    private Status mapStatus(CourseDetailsService.Status status) {

        if (status == CourseDetailsService.Status.SUCCESS) {
            return Status.SUCCESS;
        }
        return Status.FAIL;
    }

    //    Map course to course details
    private CourseDetails courseMapper(Course course) {

        CourseDetails courseDetails = new CourseDetails();
        courseDetails.setId(course.getId());
        courseDetails.setName(course.getName());
        courseDetails.setDescription(course.getDescription());

        return courseDetails;
    }

    //    Map course details to response
    private GetCourseDetailsResponse courseResponseMapper(Course course) {

        GetCourseDetailsResponse getCourseDetailsResponse = new GetCourseDetailsResponse();
        getCourseDetailsResponse.setCourseDetails(courseMapper(course));
        return getCourseDetailsResponse;
    }

    //    Map all course details to response
    private GetAllCourseDetailsResponse allCourseResponseMapper(List<Course> courses) {

        GetAllCourseDetailsResponse getAllCourseDetailsResponse = new GetAllCourseDetailsResponse();
        for (Course course : courses) {
            CourseDetails courseDetails = courseMapper(course);
            getAllCourseDetailsResponse.getCourseDetails().add(courseDetails);
        }

        return getAllCourseDetailsResponse;
    }
}

Endpoint methods will directly call the CourseDetailsService class to get a course by id, get all courses, and delete a specific course. Here we have some static data to demonstrate the functionality of the service.

CourseDetailsService.java

package com.agnasarp.soapcoursemanagement.service;

import com.agnasarp.soapcoursemanagement.domain.Course;
import com.agnasarp.soapcoursemanagement.exception.CourseNotFoundException;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

//Course details service
@Service
public class CourseDetailsService {

    static List<Course> courses = new ArrayList<>();

    static {

        Course course1 = new Course(1, "Java 11", "Java 11 course");
        Course course2 = new Course(2, "Spring 5", "Spring 5 course");
        Course course3 = new Course(3, "Spring boot", "Spring boot course");

        courses.add(course1);
        courses.add(course2);
        courses.add(course3);
    }

    //    Get course by id
    public Course getCourseById(int id) {

        return courses.stream().filter(c -> c.getId() == id).findAny().orElseThrow(() -> new CourseNotFoundException("Invalid course id " + id));
    }

    //    Get all courses
    public List<Course> getAllCourses() {

        return courses;
    }

    //    Delete a specific course
    public Status deleteCourseById(int id) {

        Iterator<Course> courseIterator = courses.iterator();
        while (courseIterator.hasNext()) {
            Course course = courseIterator.next();
            if (course.getId() == id) {
                courseIterator.remove();
                return Status.SUCCESS;
            }
        }
        return Status.FAILS;
    }

    public enum Status {
        SUCCESS, FAILS
    }
}

An exception will occur for getCourseById(int id) method if we request a course that is not available in the hardcoded array list. To handle that exception, we can create a custom exception handler class as below.

CourseNotFoundException.java

 package com.agnasarp.soapcoursemanagement.exception;

import org.springframework.ws.soap.server.endpoint.annotation.FaultCode;
import org.springframework.ws.soap.server.endpoint.annotation.SoapFault;

@SoapFault(faultCode = FaultCode.CUSTOM, customFaultCode = "{https://www.agnasarp.com/courses}0_COURSE_NOT_FOUND")
public class CourseNotFoundException extends RuntimeException {

    /**
     * Constructs a new runtime exception with {@code null} as its
     * detail message.  The cause is not initialized, and may subsequently be
     * initialized by a call to {@link #initCause}.
     */
    public CourseNotFoundException(String message) {

        super(message);
    }
}

There will be one final step to apply an authorization mechanism in the application. We had to create few beans in WebServiceConfiguration.java for this and need to add below xml configuration the resources directory.

securityPolicy.xml

<?xml version="1.0" encoding="UTF-8"?>
<xwss:SecurityConfiguration
        xmlns:xwss="http://java.sun.com/xml/ns/xwss/config">
    <xwss:RequireUsernameToken
            passwordDigestRequired="false" nonceRequired="false" />
</xwss:SecurityConfiguration>

WSDL file

You can load the WSDL file through the below URL.

http://localhost:8180/agnasarp-soap-course-management/ws/courses.wsdl

WSDL file in the browser

You can use the Wisdler chrome extension to test the SOAP services.

GetCourseDetailsRequest

GetCourseDetails - Request

GetCourseDetails - Response

GetAllCourseDetailsRequest

GetAllCourseDetails - Request

GetAllCourseDetails - Response

DeleteCourseDetailsRequest

DeleteCourseDetails - Request

DeleteCourseDetails - Response

That is it for today. Now you can create SOAP services with Spring Boot very quickly with minimal effort than other services. You can follow along with this post and refer complete GitHub project as in given below. Good luck!

Download source from github:

Download agnasarp-soap-course-management/download/button/#2e86de

Creating an AWS EC2 instance and SSH into it

2021-06-12T21:30:00.515-07:00

An EC2 instance is a type of virtual machine, but AWS has a lot of serverless implementations now. However, this is good enough to start learning AWS technologies. The video will also teach you to connect to the new EC2 instance using SSH via putty in Windows OS.

Step 1: Log in to AWS Management Console

As the first step, you need to log in to AWS Management Console with an IAM user using your favorite web browser. Then you will see the console as below

AWS Management Console

Step 2: Click the Launch Instance button

Now you need to search the AWS product EC2. By default the product will be there in the console if you previously searched, otherwise you don't have to worry about it because you can use the search box by just typing ec2.

Launch Instance

EC2 has a region scope, so you should select the region first before you do anything with EC2. Please remember to select the nearest region.

Step 3: Choose an Amazon Machine Image (AMI)

Here, you have to select an AMI. Have you heard about AMI? It is an Amazon-specific implementation of famous Operating Systems. We will select Amazon Linux 2 AMI in this tutorial. It is free tier eligible, so you don't have to pay at least a cent during the first 12 months period.

Choose an AMI

Step 4: Choose an Instance Type

Then select t2 micro as the Instance Type.

Choose an Instance Type

Step 5: Configure Instance Details

Now you have to fill in configuration details about the instance. Better to keep all default values for the first time run.

Configure Instance Details

Step 6: Add Storage Details

You can keep default values for this as well.

Storage details

Step 7: Add Tags

You can add details of the instance as key-value pair. Here, we will add the name of the instance.

Add Tags

Step 8: Configure Security Group

You can attach an existing security group for the instance, but we will create a new group and attach it to our new instance.

Configure Security Group

Step 9: Review Instance Launch

You don't have to do anything here but can just check and review your configurations.

Review Instance Launch

Step 10: Create a Key Pair

We would have a private key of the instance to log in to it in the future. Therefore, we have to create a key pay as in the below image. Download that .pem key file and store it in a safe place. Then click on the Launch Instance button.

Create a Key Pair

Step 11: Launch Instance

As you can see, our new instance is running. These are the main steps to create a new EC2 instance using the Management Console.

Launch Instance

Now we need to have a mechanism to connect to the new instance just we have created. There are mainly two steps. You can use the EC2 Connect within the same browser and you will end up with a new browser tab. Here, we use SSH with the locally installed PuTTY tool.

Step 12: Create a .ppk Private Key

You can load the .pem private key to the PuTTYgen tool and save it as a .ppk file which can be understood by the PuTTY tool.

Create .ppk Private Key

Step 13: Load .ppk Private Key

Now you can open an SSH session with the PuTTY tool. Please go to Connection -> SSH -> Auth and browse the .ppk Private Key file for authentication. and save the session.

Load .ppk Private Key

Step 14: Create an SSH session with the private key

In the same session, provide ec2-user@public-IP-of-the-instance as the hostname. Here you need to use ec2-user as the user of the instance. Mistakenly, we have added the AMI user and got errors few times as in the video.

Open a SSH Session

Step 15: Connect to EC2 instance

If you do all steps properly, then you don't have any concerns about connecting to the instance. If you type whoami, you will get ec2-user as the result and you can ping to www.google.com just to verify your instance has Internet access. Now you can update the instance and install additional software you want to use in your cloud solution.

Connecting to EC2 Instance

These are the main steps of creating a new EC2 instance and connecting to it using SSH via the PuTTY tool. The video will guide you in all the steps clearly. If you are willing to work with Amazon AWS as new implementations or migrating from on-premise services, it is highly recommended to start with EC2 instances. Hope you will enjoy the post and the video, we have given for working with EC2 instances. Please like and comment on the video and subscribe to our Agnasarp YouTube Channel. Feel free to comment if you have any doubt about the post. We will meet you again with a useful topic like this. Until then, bye!

Introduction to responsible browsing

2021-06-12T03:30:00.002-07:00

Responsible Browsing

Hi everyone! today, we have come with another valuable topic that makes you much safer while using the Internet especially in browsing the WWW. The objective of this post is to keep you informed about safe browsing practices, safe sharing while social networking, and the importance of responsible browsing. After reading this post, you will be able to browse the internet responsibly in both personal and professional settings, share information responsibly at social media sites, and mitigate unintended consequences of unsafe browsing practices with responsible browsing awareness.

Responsible browsing

Introduction to Responsible Browsing

What is Responsible Browsing?

Browsing habits that protect your personal information and online activity from cybercriminals, while being accountable for the impacts of your browsing habits on your company's information security.

Safe Browsing Practices

What are Safe Browsing Practices?

All information shared on the internet is easily accessed by the public within a single click, which makes the internet a risky place. Cybercriminals often lurk behind the scenes while internet users browse online, prying to steal sensitive information and execute other malicious activities.
Hence, it is important to understand and follow certain safeguards in order to defend ourselves from the schemes of cybercriminals. These safeguards are known as safe browsing practices, which are simple tips you can take to keep your online activity safe from cybercriminals.
In the next slides, we've put together a list of simple recommendations that you could follow to strengthen your browsing security.

Here are some examples of safe browsing practices:

Create Secure & Unique Passwords
Avoid Public Wi-Fi
Avoid Unsecured Websites
Delete Browsing History
Block & Delete Cookies
Disable Autofill & Save Passwords Features
Be Cautious of Popup Ads
Keep Browser Up-to-date

Create Secure & Unique Passwords.

Creating strong passwords makes it difficult for cybercriminals to crack the password. A strong password should have a mix of the following:

Upper case
Lower case
Number
Special character

Some examples of a weak password are as below:

password123
ThisPasswordIsStrong

Some examples of a strong password are as below:

Th1sPa55wordisStr0ng
tPwdStr0ngIt1s
T0m@toGolfBa11Eat$Cars

Refraining from reusing the same password at multiple sites is equally important as using strong passwords. Most of us are guilty of reusing the same passwords at multiple sites as it is more convenient to do so.
However, this practice would make it easier for cybercriminals to hack multiple accounts e.g. email account, bank account, and social media account upon obtaining this multi-purpose password. The consequences of hacking these accounts are devastating as it involves the loss of a lot of sensitive information.
As such, it is advisable to not only have passwords that are difficult to guess but also having more than one password for multiple accounts.

Avoid Public Wi-Fi

People use public Wi-Fi all the time, at a coffee shop, in a hotel lobby, or while waiting at the airport. However, there are many security dangers that lurk on public Wi-Fi networks. Data sent through public Wi-Fi networks can easily be intercepted by cybercriminals.
If you use public Wi-Fi, your personal data could be at risk. A common danger is fake public Wi-Fi networks. These have similar-sounding names to legitimate public Wi-Fi networks and are meant to trick and confused you.
Once you connect to these fake Wi-Fi networks, everything you do online is monitored by cybercriminals, who scan your activity for banking and social media login information.
Public Wi-Fi connections can also be used to distribute malware. Cybercriminals can easily plant viruses and other malicious software onto your computer via an unsecured Wi-Fi connection, causing serious damage to your computer and jeopardizing your personal information.
Luckily, there are ways to stay safe on public Wi-Fi:

Verify your connection. Be sure to ask the employee what the actual public Wi-Fi is to avoid connecting to a bogus network.
Avoid checking sensitive data. Unless it’s absolutely necessary, hold off on login into your social media, email, and especially your financial accounts while on public Wi-Fi.
Turn off sharing. Be sure to turn off sharing while you are on public Wi-Fi. If you leave it on while in a public place, cybercriminals can easily gain access to sensitive personal information and fields.
Use a VPN. If you need to check sensitive data like your banking account while on public Wi-Fi, use a virtual private network or a VPN. Even if a cybercriminal positions himself in the middle of your connection, your data will be strongly encrypted.
Turn your Wi-Fi off when you’re done. Even if you haven't actively connected to your network, the Wi-Fi hardware and your computer can still be transmitting data with any network in range. If you are through using the internet, ensure that ur Wi-Fi is turned off.

Understanding public Wi-Fi risks will ensure your important data doesn't fall into malicious hands.

Avoid Unsecured Websites

Websites with secured connection will have URLs that start with “https.” instead of “http://”
The “s” suffix indicates that the website information is secured and encrypted. This security is provided by an SSL certificate, which certifies that sensitive information entered into that site is secured.
Without an SSL certificate, that information is highly vulnerable to be exposed and easily accessible by cybercriminals.
Identify a padlock symbol in the browser window frame, which appears when you attempt to log in to your existing accounts or register new accounts. You can click on the padlock icon to verify that your connection is secure.
Check if the company owning the website is real. A legitimate website will have the following:

an “About Us” page: It shows a brief introduction of the company which owns the website, which clearly states their history, goals and describes what they do.
A “Contact Us” page: A legitimate website will display its contact information too. This includes an email address, a phone number, and a physical address.
A “Privacy Policy” page: It communicates how your data is collected, used, and protected by the website, as required by data privacy laws.

If a website does not have these pages, it is likely that it is a fake website created by an organization that does not exist.
Check if the web domain is genuine. Domains are used in URLs to identify particular web pages. For example, in the URL https://www.amazon.com/, the domain name is “amazon”. Knowing this, cybercriminals often create websites that mimic genuine websites to trick people into purchasing something on or logging into their imposter site e.g. https://www.amaz0n.com/.
An example below shows another common cyber-attack scheme, which is tweaking domain names by adding characters like “-tv”.

Domain:

“telegraph.co.uk.”
“telegraph-tv.com.”

Delete Browsing History

Most browsers have default settings on storing a record of sites we have searched, which is known as browsing history.
Browsing history is meant to improve our interface with the search engine for our convenience. However, it is often targeted by cybercriminals because search engines will store the history of searches along with the user’s IP address, which is highly valuable to scam artists.
Let’s explore a few ways to curb the risk of browsing history being exploited.

Configure browser to delete browsing history regularly.
Delete history manually after a browsing session.
Set browser to private browsing mode, which will not track your browsing history.

Block & Delete Cookies

Cookies are files that store on your device, as a history log from websites that store information about you between browsing sessions.
Most cookies are harmless but some are being used to track your browsing habits for advertising, or being used by cybercriminals to build a profile of your interests and activities for criminal purposes.
Similar to browsing history, blocking and deleting cookies is another good practice to mitigate the risk of information stored in the cookies being potentially exploited by criminals.

Disable Autofill & Save Passwords Features

Aside from browsing history and cookies, most browsers and many websites offer to “remember” your details and passwords for future use. This is known as the “autofill” and “save passwords” features.
While these features provide convenience, cybercriminals could use this vulnerability to hijack your browsing session and steal your information as you stay logged in to the website.
As such, disabling these features and clearing your saved passwords could mitigate the risk of exposing your sensitive information and credentials to cybercriminals.

Be Cautious of Popup Ads.

Avoid clicking popup ads. Popup Ads are often made to look like part of a website and are often being used to lure users into a scam.
These ads are typically invasive. They take up the whole page and often require you to take a survey (or complete some other action) before continuing or redirect you to another page.
Turn on your browser’s popup blocker. Popup blocking is now a standard browser feature and should be enabled any time you are surfing the web.
If it must be disabled for a specific program, turn it back on as soon as that activity is complete.
Although popup blocking does not negate the threat hidden in each website, it reduces the chances of users accidentally clicking the ads.

Keep Browser Up-to-date

Keep your browser up to date.
Most updates will include security patches. New patches are often released to fix existing vulnerabilities in browser software, so having the most up-to-date versions is critical.
If you're not installing those updates, you may leave yourself vulnerable to new threats that pop up constantly.
Therefore, always make it a point to update your browser and leave no room for any form of security vulnerabilities.

Safe Sharing Tips for Social Networking

Social networking is the use of internet-based social media programs to make virtual connections with friends, family, classmates, customers, and clients.
While social media is a platform that is often used for information sharing, oversharing certain information online can put your data at risk.
For example, cybercriminals can personalise social engineering attacks and spam emails based on your likes and interests. These emails often appear to be sent from "friends" or coworkers, which can be very deceiving.
Therefore, learning the risks of oversharing and following some safe sharing tips for social networking can help to protect your digital identity and sensitive information.
Be careful about what you share online. Never reveal sensitive personal information. This information can be misused by social engineers such as stealing your identity, applying for credit cards, use current bank accounts, and open new accounts.
Limit what you share online. Get familiar with the privacy policies of the social media channels you use and customize your privacy settings to control who sees what. A private profile is always safer than a public profile.
Be wary of unsolicited contacts. When it comes to friend requests, don’t accept requests particularly from people you don't know. It could be a fake account trying to spread spam emails or viruses into your devices. You should only connect with people that you know and trust in real life.
Remember to log off once you’re done with social networking. Leaving your social media account logged on your device while you are physically away risking your account getting hacked.

Importance of Responsible Browsing

We use web browsers every day to access information and run errands.
What we do not realize is how easily we could expose our sensitive information online while browsing.
Browsing without caution can put you at risk of all sorts of dangers, which include identity theft, data theft, and even computer damage.
Let’s explore more about these dangers.

Dangers of Unsafe Browsing

Identity Theft

Sensitive information (e.g. credit card number, bank accounts, IC number & mobile number) could be stolen & used for malicious purposes.
It can be used to make fraudulent purchases, sign up for new credit cards, and even apply for government benefits.

Data Theft

Files from your computer such as photographs, videos, and documents are stolen & then sold for illicit purposes.

Computer Damage

Viruses are sent to computers to cause damage and make them inoperable.

Importance of Responsible Browsing

Identity theft, data theft, and computer damage are just some of the few dangers of unsafe browsing practices. When cybercriminals get a hold of your credentials and sensitive information, they can use it to access your corporate networks and subsequently steal corporate information too.
Experiencing data breaches will not only give a company a bad reputation and affect its business operations, but it will also compromise its customer’s trust.
Losing customer’s trust is the last thing we have to see happening, which is why everyone in a company plays an essential role in practicing browsing habits that will improve the security of your online activities.

Recap – What Can We Do?

Create secure & unique passwords
Avoid public Wi-Fi & unsecured websites
Delete browsing history
Block & delete cookies
Disable autofill & save passwords features
Be cautious of popup ads
Keep browser up-to-date
Be careful about what you share online
Be wary of unsolicited contacts
Limit what you share online
Remember to log off once you’re done with social networking

Introduction to mobile security and social media

2021-06-12T01:30:00.088-07:00

Mobile security & social media

Introduction to mobile security and social media

Mobile security which is also known as wireless security serves as a protection of smartphones, tablets, laptops, and other portable computing devices and networks they connect to and from threats and vulnerabilities. This will secure mobile devices by authenticating users and protecting or restricting access to data stored on the devices.

On the other hand, when we come to social media, it is a collective of online communications channels dedicated to community-based inputs, interaction, content sharing, and collaboration. Simply, the ability to share photos, opinions, events, etc. in real-time.

Types of mobile devices

Mobile devices have become more than a luxury item to have and it has become a necessity so much so that employees do not just rely on them for day to day to day conversation, they are practically living on them. For many, checking their phones is the first and last thing they do every day.

As a result, its popularity in usage has been a rise in the number of threats and attacks that hackers are still constantly finding more ways and means to break into them. Being aware of what sort of devices you have is the first key to understanding your position and responsibility in making sure you are well guarded against potential digital threats and vulnerabilities.

The list below depicts some of the commonly used mobile devices in the workplace and the risks that may potentially arise from using them.

Smartphones
Laptops
Bluetooth devices
Tablets
BYOD (Bring Your Own Device)

Smartphones

A smartphone:

Is a glorified, compact, and mobile integrated computer that can fit into your pocket
Has touchscreen interface
Has internet access for web browsing
Has the ability to run software applications, making day to day work operations and leisure much more convenient and easy

Smartphones have sensors such as cameras, microphones, GPS receivers, compasses, and accelerometers which could be exploited, and may collect personal information of the user for the benefit and use of the hacker.

As a result, hackers can resort to sneaking in dangerous malware onto your device inconspicuously which could ultimately render your phone useless and exposed to digital theft, such as ransomware.

Laptops

A laptop:

Is a small personal integrated computer designed for portability
Possesses all the functionality and features that of a desktop but smaller and having ease of portability
Runs on AC power or batteries which are rechargeable
Possesses a touchpad or in some cases, a trackball and pointing stick

Desktop computers and laptops are commonly targeted to gather passwords or financial account information or to construct a botnet to attack another target which could disrupt day-to-day businesses, costing millions in losses.

Laptop security solutions can involve physical lock-and-key systems, locator devices, or other kinds of items that make it difficult for thieves to steal laptop computers, both physically and digitally.

Bluetooth devices

Bluetooth devices:

Is any device that communicates with a variety of electronic devices and creates personal networks operating within the unlicensed 2.4 GHz band
Bridge multiple industrial Ethernet networks
Can be used to identify and track object positions with the real-time location system

Many Bluetooth devices connect with each other using a simple numeric PIN number that is usually not encrypted. This means that hackers often only need to crack a numeric code to establish a connection between their devices and yours, and ultimately steal personal data.

Some hackers may use this connection to send you messages as a milder form of disruption and nuisance. Others, however, may use it to access your private data or upload viruses that could jeopardize your personal info and security.

Tablets

Tablets:

Are a wireless touch screen personal computer that is smaller than a notebook but larger than a smartphone
Are built with wireless Internet or local area networks (LAN) and a variety of software applications, including business applications, Web browsers, and games.

Like phones, tablets tend to get carried everywhere and are thus prone to lose and theft. Although some tablets do support hardware data encryption, not all do and many users don't bother to enable PIN locks, much less encryption.

Even users who do lock their own tablets may not realize that data stored there is readily accessible to downloaded apps. Perhaps more importantly, most users don’t even bother reading the warnings displayed when installing apps, giving little thought to potential risk of being hacked.

BYOD (Bring Your Own Device)

Bring your own device (BYOD):

Are any devices of which employees bring their own personal computing devices, be it smartphones, laptops, tablets, pen drives, and such to the workplace for use and connectivity on the secure corporate network

Bring your own device (BYOD) is one of the most complicated issues for IT departments because it exposes the entire organization to huge security risks and vulnerabilities like malware attacks due to the lack of stringent digital security protocols.

It increases the risk of data leakage knowing that mobile devices are the weakest link to its security and are the most susceptible to attacks.

BYOD also makes it difficult to distinguish between personal data and corporate data because they are

both kept on the same device. So if the device is lost, the corporate data will also be accessed by any individual who has gotten the device.

Importance of Mobile Security

Why do we care?

More data may bring more danger with mobile devices
Cyberattacks on mobiles are increasing by the day
Threats have evolved to be more sophisticated (exp: mobile app threats)
Businesses worry about smartphone risks
Dangers of information that can be stolen over wireless networks

Why are we vulnerable?

They are everywhere
Produced by different vendors
Who owns them?
Pre-existence of mobile malware
Device users are often uneducated about risks and how to secure devices

Emergence and Growth of Mobile App Threats

Hackers target smartphones mostly because:

They can create seemingly good (“free”) apps; most of it with your permission, which actually installs malicious code in the background, which can then be used to collect your information and even steal your identity
They can dispatch unwanted text to premium numbers causing nuisances and possibly extract info (also known as spam or phishing)
They can seize your bank account, wipe your phone's data, lock it up and even kill your device altogether

Two major mobile app threats:

Malware/Malicious apps
Legal/Approved apps

You may have already heard about Malware/Malicious Apps so let's talk about Legal/Approved Apps.

Legal/Approved Apps

Legal apps:

Apps that may potentially be used to collect information about you that can be sold to advertisers and could also be used as evidence against you in a legal dispute.

Mobile apps that collect and share information about you are constantly publishing in the background and in this respect have the ability to invade your privacy as well.

So remember when you authorize an app on a mobile device, you're allowing that app to not only perform its functions but also to access information like your calendar, contacts, and location.

Facebook, Instagram, Twitter, and Gmail are mobile apps that read your address book and track your location.

Types of Mobile Threats

Common Attacks

Theft/Gaining Physical Access
Malware
Data Interception
Eavesdropping
Insider Threats

What can we do?

Ways to reduce the risk of mobile security attacks

Enable remote wipe function and consider the “Find Your Device Option”
Be cautious about what you share – text is not inherently secure
Use Strong Passwords
Download only secure applications
Backup and protect your data
Don’t ‘jailbreak’ or ‘root’ your device
Don’t connect to a work system or the network unless you have permission to do so
Report anything suspicious to the security team

Setting up a two/multi-factor authentication

The system works by pushing unique passcodes to your mobile phone to authenticate your identity when you log in, apart from just keying in your password for a user/email/social media account.

As an example, let us take Facebook as the application of our choice in setting up a two/multi-factor authentication

Log into Facebook on your computer or Facebook app on mobile
Open the settings menu
Select the Security option in the left menu
Click the “Login Approvals” option
Check the Login Approvals box
Enter your mobile number (if prompted)
Decide if you want to enable Login Approvals immediately

How to better manage/switch off Geo-Location Tracking apps

The system works by using real-time geo-data (also known as geographical data) from a mobile device or smartphone to provide information, entertainment, or security to the user.

This system relies heavily on the mobile user’s location, the primary objective of the service provider’s system is to determine where the user is.

As an example, let us take Facebook as the application of our choice in managing our geolocation services for both Apple iOS and Google Android.

Apple iOS

Open your iPhone’s Settings
Scroll down until you locate “Facebook” and tap it
Tap on “Settings”
Tap on “Location” (You’ll see this option near the top of the screen)
Tap on “Never” (Blue checkmark will appear to the right of Never; if you wish Facebook to not track your location anymore)

Google Android

Open your Android’s Settings
Scroll down until you locate “Manage apps” and tap it
Tap on “App permissions”
Tap on “Your Location” (You may have to scroll down first to find this option)
Scroll the page down till you locate “Facebook” and slide the switch to the left to switch it off

These are the tips and tricks that we want to share with you about mobile security with social media platforms. Hope you understand what you are currently using as mobile devices and apps run on them and preliminary actions that you can take to protect yourself and corporate data from attackers. Feel free to ask about the topic and share your ideas and suggestions in the comment section below. We will meet again with another valuable tech topic. Until then, bye!

An introduction to Internet of Things (IoT) with AWS

2021-06-09T01:30:00.054-07:00

IoT with AWS

No surprise we are in an era with billions of devices that are positioned in our homes, schools, offices, vehicles, and simply all around the world. We have to have a mechanism to interconnect them and use data generated from them wisely. Old classic solutions will not have the capability to cater to the highly increasing demand. AWS has come up with a full solution set with cloud technology. In their platform, they are mainly concerned about the capabilities of data analysis, security, AI integration, and scalability.

AWS provides comprehensive and in-depth IoT services from edge to cloud. AWS IoT is the only cloud provider that combines comprehensive data management and analytics with simple services vast IoT data combinations. AWS IoT provides services for all levels of security, including security mechanisms such as encryption and access control to device data, and services for continuous monitoring and audit configurations. AWS combines artificial intelligence with the Internet of Things to make devices smarter. Templates run 2x faster than others, so you can create your own templates in the cloud and publish them to devices. AWS IoT is built on a proven and reliable cloud infrastructure that spans billions of devices and billions of messages. AWS IoT integrates with other AWS services to provide a complete solution.

There are lots of use cases that AWS IoT customers have built with a bunch of provided technologies. Customers have built industrial IoT applications for predictive quality and maintenance and to remotely monitor operations, connected home applications for home automation, home security and monitoring, and home networking and commercial applications for traffic monitoring, public safety, and health monitoring. AWS provides a variety of IoT services and solutions.

AWS IoT services

Device software

FreeRTOS

FreeRTOS is an open-source, real-time operating system for microcontrollers that facilitates programming, implementation, security, connectivity, and management of small, low-power devices. FreeRTOS is distributed for free under the MIT Open Source License, and a growing number of software libraries are suitable for use in a variety of industries and applications. This includes securely connecting small, energy-efficient devices to advanced devices using AWS cloud services such as AWS IoT Core and AWS IoT Greengrass. With a focus on stability and ease of use, FreeRTOS provides predictability of long-term support releases.

AWS IoT Greengrass

AWS IoT Greengrass is an open-source IoT service that helps you build, deploy, and manage device software. Customers use AWS IoT Greengrass for IoT applications in millions of homes, factories, vehicles, and enterprise devices. The generated data can be used to plan local device operations, make predictions based on machine learning models, and filter and aggregate device data. Only important information can be sent to the cloud.

Connectivity & control services

AWS IoT Core

AWS IoT Core allows you to connect your IoT devices to the AWS Cloud without the need to set up or manage servers. AWS IoT Core supports billions of devices and billions of messages, ensuring those messages are processed and tracked by AWS and other device endpoints. AWS IoT Core allows your app to monitor and communicate with any device, even when not connected.

AWS IoT Device Defender

AWS IoT Device Defender is a fully managed service that you can use to secure a set of IoT devices. AWS IoT Device Defender continuously monitors your IoT settings to ensure you are not deviating from optimal security measures. A configuration is a set of engineering controls deployed so that information is provided when devices communicate with the cloud and with each other. AWS IoT Device Defender makes it easy to manage and run IoT settings such as device authentication, device authorization, and device data encryption. AWS IoT Device Defender continuously evaluates the IoT settings of your device against a predefined set of security measures. If there are vulnerabilities in your IoT configuration that may pose a security risk, such as the sharing of an identity certificate among multiple devices, or a device with a revoked identity certificate trying to connect to AWS IoT Core, AWS IoT Device Defender will send an alert.

AWS IoT Device Management

When deploying hundreds of IoT devices, it is critical to track, monitor, and manage connected devices that span hundreds of thousands to millions of devices. After deployment, you need to ensure that your IoT devices are functioning properly and securely. You must also have secure access to your device, monitor device health, perform remote troubleshooting, and manage software and operating system updates. AWS IoT Device Management can easily and securely register, organize, monitor, and remotely manage IoT devices on a large scale.

Analytics services

AWS IoT Analytics

AWS IoT Analytics is a fully managed service that makes it easy to create, run, and perform complex analytics on large volumes of IoT data without having to worry about the cost and complexity of running IoT in general. This is the easiest way to analyze IoT data, gain insights, and make more accurate and better decisions for IoT and machine learning applications.

AWS IoT SiteWise

AWS IoT SiteWise is a managed service that facilitates the collection, storage, organization, and monitoring of data in industrial equipment and helps make better data-driven decisions. Use AWS IoT SiteWise to monitor the operations of any equipment, quickly calculate industry-wide performance metrics, analyze industrial equipment data, avoid costly downtime, and reduce production delays. This allows you to continuously collect data across devices, quickly identify remote monitoring issues, and improve multi-site operations with centralized data.

AWS IoT Events

AWS IoT Events is a fully managed service that makes it easy to detect and respond to events using IoT sensors and applications. There are event data models that define more complex situations than expected. Example: Motion detectors use motion signals to activate lights or security cameras when the line is down. Before IoT events, you had to create expensive custom programs that collect data and apply decision logic to identify events and launch other programs that respond to those events. When an IoT incident occurs, the event can be easily detected with thousands of IoT sensors that send various remote data such as freezer temperature, the humidity of respiratory equipment, and belt speed to the engine. You just need to identify the relevant data sources that should be selected, use simple statements to define the logic for each event, and define the alerts or actions to be generated when the event occurs. IoT Events continuously monitors data from multiple IoT sensors and applications and integrates with other services such as AWS IoT Core and AWS IoT Analytics to quickly detect events and gain unique insights. IoT Events automatically generate alerts and actions in response to events based on defined logic to expedite troubleshooting, reduce maintenance costs and improve operational efficiency.

AWS IoT Things Graph

AWS IoT Things Graph is a service that enables you to build IoT applications by enabling visual connections between various devices and web services. Today, applications are designed with a variety of web tools and services to automate tasks in a variety of use cases such as smart home, industrial automation, and enterprise energy management. Currently, there is no widely accepted standard that makes it difficult for developers to interconnect devices from different manufacturers and connect to web services. This requires developers to write a lot of code to connect their web services to any device they need to use the Internet of Things. This tool provides an advanced, visual versioning interface for connecting and controlling interactions between devices and web services, so you can quickly build IoT applications. For example, a commercial agricultural program can define interactions between humidity sensors and temperature sensors and fog cloud weather data for automated irrigation. It represents tools and services that use pre-built, reusable components called models, hiding sub-details such as protocols and interfaces, and combining them into complex working processes.

AWS IoT solutions

AWS IoT Solution Repository

There are billions of devices in homes, factories, oil wells, hospitals, cars, and thousands of other places. As devices grow, more solutions are needed to connect devices and collect, store, and analyze device data. AWS IoT provides the preconfigured solutions, tutorials, and reference architectures in the Solution Repository to get you started with the most popular IoT applications across industries right away.

AWS IoT for the Edge

Building a successful IoT solution requires tens of billions of devices installed in factory homes and offices, oil fields and fields, airplanes, ships, and automobiles. AWS IoT services allow you to act intelligently by leveraging data generated by IoT Edge devices. AWS offers a variety of high-end device services. AWS IoT Greengrass seamlessly extends AWS to high-end devices, enabling you to use the cloud for ongoing management, analytics, and storage while working with locally generated data. FreeRTOS is an open-source, real-time operating system for microcontrollers that facilitates programming, implementation, security, connectivity, and management of small, low-power devices. AWS IoT Device Tester is an IoT device test automation tool that you can use to verify that your device is running FreeRTOS or AWS IoT Greengrass and communicating with AWS IoT services.

Industrial Internet of Things

Industrial IoT (IIoT) connects machines, cloud computing, analytics, and people to improve the performance and efficiency of industrial processes. With IIoT, manufacturing companies are digitizing their processes, shaping companies in transition, improving performance and productivity, and costly companies operating in a variety of industries such as manufacturing, energy, and agriculture. Transportation and facilities participating in IoT projects connect billions of devices. It is used in a variety of applications such as quality forecasting, maintenance analysis, asset monitoring, and process optimization

AWS IoT for the Connected Home

As the use of connected home devices continues to grow, more and more data is moving to the cloud as the latest IoT and machine learning technologies bring new innovations to connected home applications. AWS IoT keeps you away from maintaining a necessary infrastructure to collect, process, analyze, and respond to data generated that can be used by connected home devices. This allows us to focus on developing solutions and experiences that add value to both your business and customers and create a new class of connected home applications that interact with the real world.

AWS IoT and Amazon Alexa

AWS IoT allows you to create connected home products quickly and easily at a low cost. To further enhance the customer experience, you can easily integrate connected products with Alexa and allow customers to control their devices with voice commands. The Alexa Voice Services integration for AWS IoT Core enables Alexa Voice to be used across all types of paired devices in a cost-effective way.

AWS IoT - Migrations

Whatever you use, AWS makes your migration faster and easier. As the IoT industry continues to evolve and bring new innovations to IoT, customers will have the opportunity to create architectures and operating systems. You can improve connectivity and enable IoT devices. AWS has also helped customers such as LG, Traeger Grills, Belkin, Centrica Hive, and Weissbeerger make the faster and easier transition from IoT systems or third-party platforms. These customers migrate to take advantage of the security, scalability, reliability, breadth, and depth of AWS IoT services.

This post is to share an overview of IoT with AWS cloud technologies and wake you up to see some extra features that legacy IoT platforms do not provide. We have covered lots of stuff today and hope you grab some knowledge on AWS IoT through the post. If you have any questions about the AWS IoT or any suggestions that you want to make, please feel free to comment in the comment section below. We will meet you again with this kind of useful topic. Stay tuned!

References

https://aws.amazon.com/iot/?nc=sn&loc=0

AWS IAM user creation

2021-06-05T21:30:00.006-07:00

Step by step video guide for AWS IAM user creation

Hello everyone! Welcome to the Agnasarp! Nowadays software development is heavily dependent on the cloud. Amazon AWS is a super cool platform to learn and use for commercial applications at reasonable rates. Therefore, knowledge about AWS and its products will be really useful for every one of us. Then we can create an AWS account and use it completely free for one year under its free tier. After signing up, you will have a root account so, as the first step, you need to create an IAM user since the root account has all privileges. And you should never ever share the root account with other users. This post will guide you to create an AWS IAM user step by step.

Step 1: Log in to the management console

First, you have to log in to the AWS management console. You can use the root account or an IAM user that has user creation privileges.

Management console URL

Here, we are using an IAM user that has admin permissions.

AWS management console login page

Step 2: Search for IAM in the search box

AWS management console

Step 3: Click on Users

IAM dashboard with global scope

Step 4: Click on Add User button

Add IAM user

Step 5: Type user details

It is better to select both Programmatic access and AWS Management Console access in the Access type.

Set new IAM user details

Step 6: Set permissions for the user

Set the permission of the IAM user

Step 7: Set tags for the user (optional)

This is optional and useful to quickly get an idea about the user if we have multiple users in the user list.

Add tags to IAM user

Step 8: Download user credentials

Need to download and securely save the new user credential in the csv file.

New IAM successful user creation

Step 9: Check user list

IAM user list

Step 10: Check Permission, Groups, Tags, and Security credentials, etc. of the new user

We can check user permissions, groups, tags, security credentials, and access advisor from each tab as in the below images.

IAM user - permission

IAM user - groups

IAM user - tags

IAM user - security credentials

If we open a new tab with the console sign-in URL in the security credentials, the existing page will be logged out automatically as below.

Automatic signing out from the previous page

Step 11: Log in to the management console with new user credentials

New IAM user login

Step 12: Reset the password of the new user

Since we put a tick on autogenerated password in the user creation, the user has to reset the password at the first login as below.

New IAM password reset

Step 13: Use any AWS product

New user in AWS management console

New IAM user in IAM dashboard

That is all from today's post. If you have any questions about the process of this IAM user creation or any suggestion that you want to make, please feel free to comment in the comment section below. We will meet you again with this kind of valuable topic. Until then bye!

Hey buddy, please help me to get rid of this! [Malware]

2021-06-02T01:30:00.012-07:00

Malware

As we have already being interconnected via the Internet, definitely there has been a higher tendency to a malware infection at any time. Most of the time you might not be able to at least know whether your system is a victim of malware infection if you do not have prior knowledge of them. Therefore this post will provide you a few tips to maintain your system as secure as possible. Hope you will grab them and use them in your daily life as well as in your office life if you already work for a company. For a quick garb, we will show you all the tips and tricks in point format.

Objective of the post

Recognize all most all forms of malware.
Identify signs of malware infection.
Understand how to remove malware from your device.
Reduce the risk of exposing your device to malware

Importance

Defend against malware infections that threaten organizational security.
Mitigate personnel vulnerabilities with security awareness.

Content

Introduction to malware
Types of malware
Detecting malware
Preventing malware
Removing malware

Introduction to Malware

Malware means malicious software.
Executes without your permission.
Tricks into thinking it is something else.
Works to remain unnoticed.
Compromise computer functions.
Steal data.
Bypass access controls.
Harms the host computer.

Tyes of Malware

Common behaviors are stealing data, monitoring user activity, modifying user files. The first line of defense is being aware of their tactics.

Bot

Bots are software programs created to automatically perform specific operations such as video gaming, internet auctions, online contests.
Bots can be used in botnets which is a collection of computers to be controlled by a third party for DDoS attacks, as spambots that render advertisements on websites, as web spiders that scrape server data, and for distributing malware disguised as popular search items on download sites.
Can protect websites with CAPTCHA test.

Virus

Copying itself and spreading to other machines via infected programs.
Also spreads via script files, documents, and cross-site scripting vulnerabilities in web apps.
Steal info, harm host computers, and networks, create botnets, steal money, render advertisements, and more.

Trojan

A Trojan distinguishes itself as a normal file or program to trick users into downloading and installing malware. It is typically bundled with games.
It can give a malicious party remote access to an infected computer.
Once the attacker has access to an infected computer, it is possible for the attacker to steal data (logins, financial data, even electronic money), install more malware, modify files, monitor user activity (screen watching, keylogging, etc) use the computer in botnets, and anonymize internet activity by the attacker.

Ransomware

Demands ransom while holding a computer system captive.
Restricts the computer owner by encrypting files on the hard drive or locking down the system and displaying messages that are intended to force the user to pay the malware creator to remove the restrictions and regain access to their computers.
Ransomware typically spreads like a normal worm ending up on a computer via a downloaded file or through some other vulnerability in a network service.

RAT

Stands for Remote Access Trojan.
It has a back door opened for the administrative control of the target computer.
Attached with games and email attachments
The intruder may use the victim to distribute RATs to establish a botnet.
As a RAT enables administrative control, it makes it possible for the intruder to do the following.

Monitor user behavior via keyloggers
Access confidential information
Activate the system's webcam and start recording.
Take screenshots
Distribute viruses and other malware
Format drives.
Delete, download, or modify files and file systems.

Worm

Worms spread over computer networks by exploiting operating system vulnerabilities.
Worms typically cause harm to their host networks by consuming bandwidth and overloading web servers.
It is a type of virus and it has the ability to self-replicate and spread independently but viruses rely on human activity to spread.
Spread by sending mass emails with infected attachments to users' contacts.

Detecting Malware

Detecting malware is not an easy task. Anti-virus software is rarely 100% accurate at detecting malware because malware is designed to self-update and continually hides its presence whenever they start getting detected.

The computer is running slower than usual.
Pop-ups that ask you to download antivirus software or offer freebies.
Computer has been crashing or freezing lately
Antivirus software and firewalls have been disabled without your consent
Emails/messages being sent automatically without the user's knowledge

Preventing Malware

Prevention is better than cure. As malware is getting harder to detect and new threats are seen on regular basis, you must be extra cautious in reducing the risk of getting malware attacks on your computer. Listed below are a few key recommendations to prevent malware.

Install anti-virus, perform scheduled virus scanning and keep virus signature up-to-date.
Keep your operating system current.
Secure your network.
Run a virus scan if your computer is running slower than usual.
Do not click on links, pop-ups, or download files from unsolicited sources.
Enable firewalls.

Removing Malware

Once your computer is infected with malware, you must remove it as soon as you realize it happens. Listed below are some simple steps in removing malware.

Back up all files and data on our computer.
Disconnect your computer from the Internet.
Remove CDs and DVDs, and unplug USB drives from the computer.
Scan the computer first in normal mode.
Scan the computer in safe mode with networking.
Delete temporary files by using the "Disk Cleanup" utility.
Run virus scanner.
Restart the computer normally.
Confirm the results of the anti-malware scan.

AWS DeepRacer League - a retrospective after the race day

2021-05-29T01:30:00.744-07:00

Hello friends! we have come with another useful topic as usual, OK have you heard about DeepRacer? 🤔🤔🤔 Don't worry if you haven't yet. Today we will go through the DeepRacer event with a past result deeply. DeepRacer is a tool created by Amazon AWS to learn machine learning (ML) easily. They use a special learning type called Reinforcement Learning. We can build applications for vehicles for autonomous driving in both virtual and physical environments. All the information is there in the AWS DeepRacer Developer Guide. Here we are going to share our experiences we have got in the training period and the virtual race day, they may be good or bad but will be beneficial for future racers.

AWS DeepRacer League

This is the introduction page created for DeepRacer and it quickly gives you an idea about Reinforcement Learning in the How it works section. The page has all the links to functions that we need to use in the training for the league.

DeepRacer console

This page is also a little bit informative for DeepRacer Virtual Circuit.

Virtual circuit

We have to deal with the open community race created for our company hereon. It is informative and says about the day remaining for the main event/the race day, race type here it is Time-trial, level, sensors, track details here it is Bowtie Track, our rank, and the details about the top racer.

Community races

Now we can get started with the hands-on session for the preparation or training for the virtual race with the provided features in the DeepRacer console.

Get started

Make your car

What we need to do at first in the console, we need to have an agent. Here it is a 1/18th scaled car. In the Your garage section, all cars that are already built are listed and it also provides a button to create new cars as well.

Garage

If we click the button it will ask for all the specifications, action space, and personalization. Here DeepRacer team will recommend selecting the radio button Camera only in Sensor modification.

DeepRacer - build a car

The next step is to set up the action space for the vehicle. Here also DeepRacer team has recommended choosing Discrete as the Action space type. It is better to keep the maximum steering angle that 30 degrees or it is up to you as per your requirement. Steering granularity defines the possible angles of the front wheels. As per the below image, we can have 5 different angles for the wheels for the steering angle granularity 5 as {-30, -15, 0, 15, 30}. If it is 3, the number of angles will be 3 as {-30, 0, 30}, and if it is 7, the angles will be {-30, -20, -10, 0, 10, 20, 30}. Then it asks about the max speed of the car, so here we just keep it as 3 but the DeepRacer team recommended entering the max value, here it is 4. At last, it asks about the granularity of the speed and we keep it as 2, ow we can have 2-speed variations as 3m/s and 1.5m/s.

Action space

As per the aforementioned steering angles and speed values we got the below action list which elaborates all possible states of the vehicle.

Action list

We can give it a name and a color as the last step.

Customize the car

Make you model

We just finished building our car, the next step is to create a model to train. The below page lists all the available models that we have created and a button to create a new model as well.

Models

If we select the button to create a new model, we have to provide all the details about our new model. At first, we need to give it a name and a description (optional) and select a track. DeepRacer team recommended choosing Bowtie Track since we have to play the virtual race day on the same track.

Create model - model name and environment

And the race type is Time trial, again the DeepRacer team asked to select that. Most of the time we keep all the default values in the Training algorithm and hyperparameters section but if you want you can fine-tune them to get a much better result. We can select a car from the garage as the agent for the model.

Create model - training type, training algorithm, and agent

As the last step, we can define a reward function for the model. This is the most tricky part of the model creating. We can remain the default reward function as it is or alter them. Here we have used custom reward functions. We can define the training time in minutes as the Stop condition. 2 to 4 hours is the best training time as per many past racers. but we can go up to 24 hours. By the way, we trained 8 and 10 hours our best models.

Create model - customize reward function

Reward functions

The reward function is the key part of our model training because though the are few other configurable values that we can control to get a better result, this is the main algorithm that we use in model training. As you can see, there are few functions already provided by AWS

1] Time trial - follow the center line (Default)

def reward_function(params):
    '''
    Example of rewarding the agent to follow center line
    '''
    
    # Read input parameters
    track_width = params['track_width']
    distance_from_center = params['distance_from_center']
    
    # Calculate 3 markers that are at varying distances away from the center line
    marker_1 = 0.1 * track_width
    marker_2 = 0.25 * track_width
    marker_3 = 0.5 * track_width
    
    # Give higher reward if the car is closer to center line and vice versa
    if distance_from_center <= marker_1:
        reward = 1.0
    elif distance_from_center <= marker_2:
        reward = 0.5
    elif distance_from_center <= marker_3:
        reward = 0.1
    else:
        reward = 1e-3  # likely crashed/ close to off track
    
    return float(reward)

2] Time trial - stay inside the two borders

def reward_function(params):
    '''
    Example of rewarding the agent to stay inside the two borders of the track
    '''
    
    # Read input parameters
    all_wheels_on_track = params['all_wheels_on_track']
    distance_from_center = params['distance_from_center']
    track_width = params['track_width']
    
    # Give a very low reward by default
    reward = 1e-3

    # Give a high reward if no wheels go off the track and
    # the agent is somewhere in between the track borders
    if all_wheels_on_track and (0.5*track_width - distance_from_center) >= 0.05:
        reward = 1.0

    # Always return a float value
    return float(reward)

3] Time trial - prevent zig-zag

def reward_function(params):
    '''
    Example of penalize steering, which helps mitigate zig-zag behaviors
    '''
    
    # Read input parameters
    distance_from_center = params['distance_from_center']
    track_width = params['track_width']
    steering = abs(params['steering_angle']) # Only need the absolute steering angle

    # Calculate 3 markers that are at varying distances away from the center line
    marker_1 = 0.1 * track_width
    marker_2 = 0.25 * track_width
    marker_3 = 0.5 * track_width

    # Give higher reward if the agent is closer to center line and vice versa
    if distance_from_center <= marker_1:
        reward = 1
    elif distance_from_center <= marker_2:
        reward = 0.5
    elif distance_from_center <= marker_3:
        reward = 0.1
    else:
        reward = 1e-3  # likely crashed/ close to off track

    # Steering penality threshold, change the number based on your action space setting
    ABS_STEERING_THRESHOLD = 15

    # Penalize reward if the agent is steering too much
    if steering > ABS_STEERING_THRESHOLD:
        reward *= 0.8

    return float(reward)

4] Object avoidance and head-to-head - stay on one lane and not crashing (default for OA and h2h)

def reward_function(params):
    '''
    Example of rewarding the agent to stay inside two borders
    and penalizing getting too close to the objects in front
    '''

    all_wheels_on_track = params['all_wheels_on_track']
    distance_from_center = params['distance_from_center']
    track_width = params['track_width']
    objects_distance = params['objects_distance']
    _, next_object_index = params['closest_objects']
    objects_left_of_center = params['objects_left_of_center']
    is_left_of_center = params['is_left_of_center']

    # Initialize reward with a small number but not zero
    # because zero means off-track or crashed
    reward = 1e-3

    # Reward if the agent stays inside the two borders of the track
    if all_wheels_on_track and (0.5 * track_width - distance_from_center) >= 0.05:
        reward_lane = 1.0
    else:
        reward_lane = 1e-3

    # Penalize if the agent is too close to the next object
    reward_avoid = 1.0

    # Distance to the next object
    distance_closest_object = objects_distance[next_object_index]
    # Decide if the agent and the next object is on the same lane
    is_same_lane = objects_left_of_center[next_object_index] == is_left_of_center

    if is_same_lane:
        if 0.5 <= distance_closest_object < 0.8: 
            reward_avoid *= 0.5
        elif 0.3 <= distance_closest_object < 0.5:
            reward_avoid *= 0.2
        elif distance_closest_object < 0.3:
            reward_avoid = 1e-3 # Likely crashed

    # Calculate reward by putting different weights on 
    # the two aspects above
    reward += 1.0 * reward_lane + 4.0 * reward_avoid

    return reward

But we used a customized algorithm in the training as below. Actually, we have tried out multiple algorithms and these are the best two out of them.

Function that we used in the traning before the race day (model M20)

import math

def reward_function(params):    
    progress = params['progress']
    
    # Read input variables
    waypoints = params['waypoints']
    closest_waypoints = params['closest_waypoints']
    heading = params['heading']
    
    reward = 1.0
        
    if progress == 100:
        reward += 100
    
    # Calculate the direction of the center line based on the closest waypoints
    next_point = waypoints[closest_waypoints[1]]
    prev_point = waypoints[closest_waypoints[0]]    

    # Calculate the direction in radius, arctan2(dy, dx), the result is (-pi, pi) in radians
    track_direction = math.atan2(next_point[1] - prev_point[1], next_point[0] - prev_point[0]) 

    # Convert to degree
    track_direction = math.degrees(track_direction)    

    # Calculate the difference between the track direction and the heading direction of the car
    direction_diff = abs(track_direction - heading)    

    # Penalize the reward if the difference is too large
    DIRECTION_THRESHOLD = 10.0
    
    malus=1
    
    if direction_diff > DIRECTION_THRESHOLD:
        malus=1-(direction_diff/50)
        if malus<0 or malus>1:
            malus = 0
        reward *= malus
    
    return reward

Function that we used in the race day (model M11)

import math

def reward_function(params):
    '''
    Use square root for center line - ApiDragons-M11
    '''
	
    track_width = params['track_width']
    distance_from_center = params['distance_from_center']
    speed = params['speed']
    progress = params['progress']
    all_wheels_on_track = params['all_wheels_on_track']
    SPEED_TRESHOLD = 3    

    reward = 1 - (distance_from_center / (track_width/2))**(4)

    if reward < 0:
        reward = 0    

    if speed > SPEED_TRESHOLD:
        reward *= 0.8        

    if not (all_wheels_on_track):
        reward = 0

    if progress == 100:    
        reward += 100        

    return float(reward)

Model training and evaluation

This is one of our best models which has taken 8 hours to train. The model evaluation shows 100% completed 5 laps but it has taken a little longer than our other best model. It has taken around 15 seconds to complete a lap on the track. You can train 4 multiple models at the same time.

Model training and evaluation - M20

We have another model M11, which reported the best lap time 11.141 seconds in the evaluation and 12.057 seconds in the leader board. But it had only 100% one completed lap in the evaluation.

Model training and evaluation - M11

We had just put our model for March Qualifier to get an idea and it secured the below rank 😆. But the track is different and this is not particularly designed for the March Qualifier so we didn't have to worry about it.

March qualifier

Our M11 model secured 4th place out of 35 candidates on the leader board before the race day.

Rank in the community race - before racing day

This is the leader board in the virtual race day. As we have already mentioned this post is a retrospective for the event and we have identified few mistakes we had to corrected before the race day as listed below.

We used 3m/s as the speed but we had to choose the max value, 4m/s for the action space.
We had used a longer period of time like 8, 10 hours as the training time but it is enough to train 2 to 4 hour for better results.
We did not trust default reward functions and always looked for a complex function but it is not correct, the results would be better if the reward function was a little bit simpler than that we have used.
We had just concerned about the best lap time in the leader board before the race day so we had selected model M11 for the race day. but it was not much stable. If we went with model M20 which has already shown a 5 100% completed laps, the final results would rather be joyful though it did not have a better lap time. Because it was a stable model that M11.

Rank in the community race - racing day

However, it was a fun and energetic period of time because it was courageous us when we go up on the leader board. It motivated us to find another good reward function and set of hyperparameter values. We had addicted to training new models again and again before the race day. Hope this news about our experience will be beneficial for your future DeepRacer Leagues. That is all we have to share with you. We will meet you again with this kind of valuable topic. Until then bye bye!

References:

https://docs.aws.amazon.com/deepracer/latest/developerguide/deepracer-reward-function-examples.html

Complete microservices architecture with real examples - Step 7 - Distribute log tracing

2021-05-27T01:30:00.066-07:00

Hello guys! Welcome again to the Agnasarp! Now we are in the last step of the implementation of microservices architecture. Here we are going to implement the distributed log tracing and it will be handled by Sleuth and Zipkin. There are two unique ids that are called Trace ID and Span ID to implement the log tracing and with them, we can find where the request was started, where the request ended, where the request was successful, and where the request got failed, and so on.

We have to download the Zipkin server and implement the Zipkin client and Sleuth in all our microservices.

Download Zipkin Server

Go to https://zipkin.io/ in the browser.
Click Quickstart
Click on the latest release on the Java version. You can run it as a dockerized version but for the sake of simplicity, we have chosen the Java version here.

Download Zipkin

The file name of Zipkin is zipkin-server-2.23.2-exec.jar so we can use the below jar command to start the server.

java -jar zipkin-server-2.23.2-exec.jar

It will run on http://127.0.0.1:9411/ and when we call it using a browser, we get

Zipkin dashboard

Now we have to add Zipkin client and Sleuth in our microservices. Our main microservices are Department Service and User Service so, we have to and these dependencies only to those services.

pom.xml

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

And need to add Zipkin base URL in both the services as highlighted below.

Department Service

application.xml

server:
  port: 8280
spring:
  application:
    name: DEPARTMENT-SERVICE  zipkin:
    base-url: http://127.0.0.1:9411/
management:
  endpoints:
    web:
      exposure:
        include: "*"

User Service

application.xml

server:
  port: 8380
spring:
  application:
    name: USER-SERVICE  zipkin:
    base-url: http://127.0.0.1:9411/
management:
  endpoints:
    web:
      exposure:
        include: "*"

After we run Department Service and User Service with the Zipkin server, it enables the below information in every log that we have already defined.

[Application name, Trace ID, Span ID]

Trace ID is unique across all the microservices for a particular request. Span ID will be changed accordingly in each and every microservices.

If we call Get User API it will call Get Department API as well inside the application. Therefore in User Service, we got

2021-05-28 01:25:47.963 INFO [USER-SERVICE,be5879f5e04b09ea,be5879f5e04b09ea] 6680 --- [nio-8380-exec-6] c.a.user.controller.UserController : Inside getUserById method of UserController

2021-05-28 01:25:47.963 INFO [USER-SERVICE,be5879f5e04b09ea,be5879f5e04b09ea] 6680 --- [nio-8380-exec-6] com.agnasarp.user.service.UserService : Inside getUserWithDepartment method of UserService

And in Department Service, we got

2021-05-28 01:25:48.019 INFO [DEPARTMENT-SERVICE,be5879f5e04b09ea,db2285f8a3a30819] 11236 --- [nio-8280-exec-8] c.a.d.controller.DepartmentController : Inside getDepartmentById method of DepartmentController

2021-05-28 01:25:48.019 INFO [DEPARTMENT-SERVICE,be5879f5e04b09ea,db2285f8a3a30819] 11236 --- [nio-8280-exec-8] c.a.d.service.DepartmentService : Inside getDepartmentById method of DepartmentService

As you can see, the highlighted Trace ID is equal in both the services because this is the same request which went through Get User -> Get Department. The next one which is the Span ID that is unique for the service call within itself.

We will select the user-service as the serviceName.

Zipkin query

We can see the request when we hit the RUN QUERY button.

User Service selection

We can go through all the information provided by Zipkin as below. Service names, trace ids, span ids, durations, HTTP method, resource path, controller class, controller method, client address, etc. can be found as per the below image.

Log tracing with Zipkin

On the dependency page, we can get an idea about dependencies over microservices we created. As per the below image, User Service dependents on Department Service.

Dependency page

Now we have come to the end of our microservices implementation. In summary, we have implemented the Department Service, the User Service, the Service Registry, the API Gateway, the Circuit Breaker Pattern with Hystrix, the Config Server, and at last, the Distributed Log Tracing with Zipkin and Sleuth. These are the basic elements in the microservices architecture and we can implement a lot from these base models. You can get all the source code of all components from GitHub with the below links and reach our past posts through the links below. Hope you guys enjoy our posts on microservices architecture and we wish you all the best! Bye bye!

Download source from github:

Download config-server/download/button/#2e86de Download hystrix-dashboard/download/button/#2e86de Download api-gateway/download/button/#2e86de Download service-registry/download/button/#2e86de Download department-service/download/button/#2e86de Download user-service/download/button/#2e86de

Go to Step 1 - Department Microservice

Go to Step 2 - User Microservice

Go to Step 3 - Service Registry

Go to Step 4 - API Gateway

Go to Step 5 - Circuit Breaker with Hystrix

Go to Step 6 - Config Server

Complete microservices architecture with real examples - Step 6 - Config server

2021-05-25T01:30:00.005-07:00

Hey buddy! Do you have an idea about maintaining properties and configuration easily by spending the least amount of time? Then, definitely, you have to set up a Config Server which is another microservice with a version control system. Let's quickly dive into the implementation of it.

Config server

Step 6 - Config Server

Let's take a look at the project initialization with https://start.spring.io/

Spring Initialzr - Config Server

Project build tool: Maven
Language: Java
Spring boot: 2.4.6
Project Metadata

Group: com.agnasarp
Artifact: agnasarp-config-server
Name: agnasarp-config-server
Description: Agnasarp Config Server
Package name: com.agnasarp.configserver
Packaging: Jar
Java version: 8

Dependencies:

Eureka Discovery Client: A REST based service for locating services for the purpose of load balancing and failover of middle-tier servers.
Config Server: Central management for configuration via Git, SVN, or HashiCorp Vault.

Project structure

Project structure of config server in IntelliJ Idea

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.6</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.agnasarp</groupId>
	<artifactId>agnasarp-config-server</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>agnasarp-config-server</name>
	<description>Agnasarp Config Server</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>2020.0.2</spring-cloud.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-config-server</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

application.yml

server:
  port: 8580

spring:
  application:
    name: CONFIG-SERVER
  cloud:
    config:
      server:
        git:
          uri: https://github.com/Agnasarp/agnasarp-microservice-configurations
          clone-on-start: true
  profiles:
    active: native

AgnasarpConfigServerApplication.java

package com.agnasarp.configserver;

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

@SpringBootApplication
@EnableConfigServer
@EnableEurekaClient
public class AgnasarpConfigServerApplication {

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

}

Now we can create a repository in a version controlling system to manage configurations that may be used in all microservices we have created.

Remote repository for configurations

In that application.yml file, we can place the configurations that we use to connect Eureka Server as below. These can be removed from all other microservices because now we have the configuration centrally.

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
    instance:
      hostname: localhost

Now we have to set up one configuration in each microservice to call Service Registry. We create bootstrap.yml and paste the below lines of code. This is going to be used to call Config Server just we set up.

spring:
  cloud:
    config:
      enabled: true
      uri: http://localhost:8580

Suppose there is a configuration change so we can update it in the GitHub repository and call the refresh method in relevant microservices as below.

curl --location --request POST 'http://localhost:8280/actuator/refresh'

Download source from github:

Go to Step 1 - Department Microservice

Go to Step 2 - User Microservice

Go to Step 3 - Service Registry

Go to Step 4 - API Gateway

Go to Step 5 - Circuit Breaker with Hystrix

Complete microservices architecture with real examples - Step 5 - Circuit breaker with hystrix

2021-04-02T01:30:00.014-07:00

Hi, guys! Welcome to Agnasarp! Today we came here with a very useful concept in the microservices architecture. In the home grid, there is a switch called "breaker" or "circuit breaker" which is automatically switched off while the electricity is flowing off. It will secure our home and everything not letting a bad thing happened. Likewise, we need to have a mechanism to secure our whole microservices echo system without hanging any service because definitely there may be service calls from one microservice to others. Therefore the same concept of circuit braking can be applied to this echo system. Here we have picked up Hystrix from several technologies. We have to setup Hystrix dashboard to see graphically what is going on behind the scene and configure the API gateway to support Hystrix.

Hystrix

Step 5 - Hystrix dashboard

Let's take a look at the project initialization with https://start.spring.io/

Spring Initialzr - Hystrix Dashboard

Project build tool: Maven
Language: Java
Spring boot: 2.3.10 (SNAPSHOT)
Project Metadata

Group: com.agnasarp
Artifact: agnasarp-hystrix-dashboard
Name: agnasarp-hystrix-dashboard
Description: Agnasarp Hystrix Dashboard
Package name: com.agnasarp.hystrixdashboard
Packaging: Jar
Java version: 8

Dependencies:

Eureka Discovery Client: A REST based service for locating services for the purpose of load balancing and failover of middle-tier servers.
Hystrix Dashboard [Maintenance]: Circuit breaker dashboard with Spring Cloud Netflix Hystrix. In maintenance mode with no direct replacement.

Here, we have to pick the right Spring Boot version because Hystrix may not support for few higher versions of Spring Boot. Then, we will import the project into IntelliJ Idea.

Project structure

Project structure of hystrix dashboard in IntelliJ Idea

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.3.10.BUILD-SNAPSHOT</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.agnasarp</groupId>
	<artifactId>agnasarp-hystrix-dashboard</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>agnasarp-hystrix-dashboard</name>
	<description>Agnasarp Hystrix Dashboard</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Hoxton.BUILD-SNAPSHOT</spring-cloud.version>
	</properties>
	<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-netflix-hystrix-dashboard</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
		<repository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</pluginRepository>
		<pluginRepository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
		</pluginRepository>
	</pluginRepositories>

</project>

application.yml

server:
  port: 8480

spring:
  application:
    name: HYSTRIX-DASHBOARD

hystrix:
  dashboard:
    proxy-stream-allow-list: "*"

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
    instance:
      hostname: localhost

AgnasarpHystrixDashboardApplication.java

package com.agnasarp.hystrixdashboard;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

@SpringBootApplication
@EnableEurekaClient
@EnableHystrixDashboard
public class AgnasarpHystrixDashboardApplication {

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

}

Now we have to do few modifications in API Gateway microservice as well. Those changes are highlighted below.

API Gateway modifications

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.10.BUILD-SNAPSHOT</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.agnasarp</groupId>
    <artifactId>agnasarp-cloud-gateway</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>agnasarp-cloud-gateway</name>
    <description>Agnasarp Cloud Gateway</description>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.BUILD-SNAPSHOT</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <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-netflix-hystrix</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </pluginRepository>
        <pluginRepository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

</project>

application.yml

server:
  port:
    9191

spring:
  application:
    name: API-GATEWAY
  cloud:
    gateway:
      routes:
        - id: DEPARTMENT-SERVICE
          uri: lb://DEPARTMENT-SERVICE
          predicates:
            - Path=/departments/**
          filters:
            - name: CircuitBreaker
              args:
                name: DEPARTMENT-SERVICE
                fallbackuri: forward:/departmentServiceFallback
        - id: USER-SERVICE
          uri: lb://USER-SERVICE
          predicates:
            - Path=/users/**
          filters:
            - name: CircuitBreaker
              args:
                name: USER-SERVICE
                fallbackuri: forward:/userServiceFallback

hystrix:
  command:
    fallbackcmd:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 4000

management:
  endpoints:
    web:
      exposure:
        include: hystrix.stream

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
    instance:
      hostname: localhost

AgnasarpCloudGatewayApplication.java

package com.agnasarp.cloudgateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

@SpringBootApplication
@EnableEurekaClient
@EnableHystrix
public class AgnasarpCloudGatewayApplication {

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

}

And a new fallback controller has been added to forward the request when the 3rd party API is not available or unresponsive within the timeout defined in the application.yml file and the fallback method in the controller will give a meaningful message as below.

FallbackController.java

package com.agnasarp.cloudgateway.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FallbackController {
    @GetMapping("/departmentServiceFallback")
    public String departmentServiceFallback(){
        return "DEPARTMENT-SERVICE is not available or unresponsive. Please try again later.";
    }

    @GetMapping("/userServiceFallback")
    public String userServiceFallback(){
        return "USER-SERVICE is not available or unresponsive. Please try again later.";
    }
}

If Service Registry, Department Service, User Service, API Gateway Service, and Hystrix Dashboard Service is up and running we can test whether our circuit breaker is working well or not. We can go to the Hystrix Dashboard with the below link.

http://localhost:8480/hystrix

Hystrix Dashboard

We can see the status of microservices configured in API Gateway via the below hystrix stream endpoint.

http://localhost:9191/actuator/hystrix.stream

Hystrix Stream

When all User Service and Department Service are working fine we can get successful response as below.

User Service - Success Scenario

Hystrix Dashboard will show the circuit as closed as below.

Hystrix Dashboard - Circuit Closed

Now we have down the Department Service which is being called by the User Service and try to call the User Service, so we got the below response hardcoded in the fallback method userServiceFallback.

User Service - Fail Scenario

Then the Hystrix Dashboard shows the status of our services graphically when the circuit opens.

Hystrix Dashboard - Circuit Opened

That is all for today. In summary, we have created a Hystrix Dashboard and configured API Gateway to support Hystrix to implement the circuit breaker pattern in our echo system. You can also try with these and all source code can be downloaded from GitHub using the below links. Hope you have grabbed something from this post and we will meet again with another important concept in microservices. Until then, bye bye!

Download source from github:

Download hystrix-dashboard/download/button/#2e86de Download api-gateway/download/button/#2e86de Download service-registry/download/button/#2e86de Download department-service/download/button/#2e86de Download user-service/download/button/#2e86de

Go to Step 1 - Department Microservice

Go to Step 2 - User Microservice

Go to Step 3 - Service Registry

Go to Step 4 - API Gateway

Complete microservices architecture with real examples - Step 4 - API gateway

2021-03-29T21:30:00.003-07:00

Hi geeks! as per our complete microservices architecture, we have developed two microservices with a service registry. With this implementation, users are calling APIs of these microservices directly. Then there are different entry points for these APIs and to set a single entry point we have to set up an API Gateway service. We can define even this as a microservice. So we will see how can we implement an API gateway and how our existing microservices can be integrated with this with practical examples.

API Gateway

Step 4 - API Gateway

Let's take a look at the project initialization with https://start.spring.io/

Initialization details

Spring Initialzr - API Gateway

Project build tool: Maven
Language: Java
Spring boot: 2.4.2
Project Metadata

Group: com.agnasarp
Artifact: agnasarp-cloud-gateway
Name: agnasarp-cloud-gateway
Description: Agnasarp Cloud Gateway
Package name: com.agnasarp.cloudgateway
Packaging: Jar
Java version: 8

Dependencies:

Eureka Discovery Client: A REST based service for locating services for the purpose of load balancing and failover of middle-tier servers.
Gateway: Provides a simple, yet effective way to route to APIs and provide cross cutting concerns to them such as security, monitoring/metrics, and resiliency.
Spring Boot Actuator: Supports built in (or custom) endpoints that let you monitor and manage your application - such as application health, metrics, sessions, etc.

Then, we will import the project into IntelliJ Idea.

Project structure

Project structure of API Gateway in IntelliJ Idea

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.agnasarp</groupId>
	<artifactId>agnasarp-cloud-gateway</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>agnasarp-cloud-gateway</name>
	<description>Agnasarp Cloud Gateway</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>2020.0.1</spring-cloud.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-gateway</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

application.yml

server:
  port:
    9191

spring:
  application:
    name: API-GATEWAY
  cloud:
    gateway:
      routes:
        - id: DEPARTMENT-SERVICE
          uri: lb://DEPARTMENT-SERVICE
          predicates:
            - Path=/departments/**
        - id: USER-SERVICE
          uri: lb://USER-SERVICE
          predicates:
            - Path=/users/**

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
    instance:
      hostname: localhost

AgnasarpServiceRegistryApplication.java

package com.agnasarp.cloudgateway;

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

@SpringBootApplication
@EnableEurekaClient
public class AgnasarpCloudGatewayApplication {

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

}

Now we can see Department Service, User Service, and API Gateway Service are up and running when you refresh the Service Registry. Instead of using ports of services themselves, we can use the port of API Gateway to contact each service configured in it. Any service can be called via port 9191 already configured but as an example, we will call the get-user-service as below.

Get-User-Service

That is all for today's post. Hope you got the concept of API Gateway in the microservices architecture. If you need the source code of these services, please click the below buttons to get them from GitHub. We will meet again with this kind of tech topic soon. Until then bye bye!

Download source from github:

Download api-gateway/download/button/#2e86de Download service-registry/download/button/#2e86de Download department-service/download/button/#2e86de Download user-service/download/button/#2e86de

Go to Step 1 - Department Microservice

Go to Step 2 - User Microservice

Go to Step 3 - Service Registry

Complete microservices architecture with real examples - Step 3 - Service registry

2021-03-08T00:30:00.006-08:00

Welcome to today's new tech topic. Today, we are going to describe another important component in the microservices architecture, the Service Registry. Both advantageous and disadvantageous are there with the service registry. The main benefit of that is to keep all address details of microservices globally and the ability to ignore each individual hostnames and port details when a service is being called by the end-user or another service. Just we can call services of a microservice only with its name. On the other hand, there is a drawback because we have to add a mandatory configuration in all microservices which are going to be registered with the registry. Anyway, we will quickly look into the practical example of this vastly used component in the microservices architecture. This is an extension of the previous two posts, one was for Department Service and the other for User Service.

Service Registry

Step 3 - Service Registry

Can you guess how we can implement a service registry in the microservices architecture? Again we have to set up another microservice with different dependencies. This is the time to dive into the codebase. Here we go.

Initialization details

Spring Initialzr - Service Registry

Project build tool: Maven
Language: Java
Spring boot: 2.4.2
Project Metadata

Group: com.agnasarp
Artifact: agnasarp-service-registry
Name: agnasarp-service-registry
Description: Agnasarp Service Registry
Package name: com.agnasarp.serviceregistry
Packaging: Jar
Java version: 8

Dependencies:

Eureka Server: spring-cloud-netflix Eureka Server.

Then, we will import the project into IntelliJ Idea.

Project structure

Project structure of service registry in IntelliJ Idea

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.agnasarp</groupId>
    <artifactId>agnasarp-service-registry</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>agnasarp-service-registry</name>
    <description>Agnasarp Service Registry</description>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2020.0.1</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

AgnasarpServiceRegistryApplication.java

package com.agnasarp.serviceregistry;

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

@SpringBootApplication
@EnableEurekaServer
public class AgnasarpServiceRegistryApplication {

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

}

Now, we have to set Department Service and User Service as discovery clients and for that, we need to add one dependency in the pom.xml file and put an annotation in the main class. Ultimately we have to register these services in the registry by adding few configurations in the application.yml file.

Department Service

To work with Service Registry, other microservices like Department Service and User Service need some modifications as below.

pom.xml

Need to add highlighted dependency to the pom.xml file.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.agnasarp</groupId>
    <artifactId>agnasarp-department-microservice</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>agnasarp-department-microservice</name>
    <description>Agnasarp Department Microservice</description>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2020.0.1</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

Need to add highlighted configurations to the application.yml file

server:
  port: 8280

spring:
  application:
    name: DEPARTMENT-SERVICE

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
    instance:
      hostname: localhost

AgnasarpDepartmentMicroserviceApplication.java

Need to add highlighted annotation to AgnasarpDepartmentMicroserviceApplication.java file.

package com.agnasarp.department;

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

@SpringBootApplication
@EnableEurekaClient
public class AgnasarpDepartmentMicroserviceApplication {

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

}

All other source code should remain the same and we have to apply the same above changes to the User Service as well.

User Service

pom.xml

Need to add highlighted dependency to the pom.xml file.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.agnasarp</groupId>
	<artifactId>agnasarp-user-microservice</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>agnasarp-user-microservice</name>
	<description>Agnasarp User Microservice</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>2020.0.1</spring-cloud.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

application.yml

Need to add highlighted configurations to the application.yml file

server:
  port: 8380

spring:
  application:
    name: USER-SERVICE

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
    instance:
      hostname: localhost

AgnasarpUserMicroserviceApplication.java

Need to add highlighted annotation to AgnasarpUserMicroserviceApplication.java file. Here we have to explicitly tell RestTemplate to loadbalance if there are multiple instances of Department Service.

package com.agnasarp.user;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
public class AgnasarpUserMicroserviceApplication {

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

    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

UserService.java

Need to replace IP and Port details in UserService.java file by application name as highlighted.

package com.agnasarp.user.service;

import com.agnasarp.user.entity.User;
import com.agnasarp.user.repository.UserRepository;
import com.agnasarp.user.vo.Department;
import com.agnasarp.user.vo.ResponseTemplateVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class UserService {
    private static final Logger log = LoggerFactory.getLogger(UserService.class);
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private RestTemplate restTemplate;

    public User saveUser(User user) {
        log.info("Inside saveUser method of UserService");
        return userRepository.save(user);
    }

    public ResponseTemplateVo getUserWithDepartment(Long userId) {
        log.info("Inside getUserWithDepartment method of UserService");
        ResponseTemplateVo responseTemplateVo = new ResponseTemplateVo();
        User user = userRepository.getUserByUserId(userId);
        Department department = restTemplate.getForObject("http://DEPARTMENT-SERVICE/" +
                "departments/" + userId, Department.class);
        responseTemplateVo.setUser(user);
        responseTemplateVo.setDepartment(department);
        return responseTemplateVo;
    }

}

If we configure all well, we can see the Service Registry is up and running by using port 8761 on localhost as below. All two microservices are working fine with Service Registry as well.

Eureka Server Dashboard

http://localhost:8761/

Eureka Server Dashboard

That is all for today's post. Hope you have a good understanding of microservices and service registry concepts. If you need the source code of these services, please click the below buttons to get them from GitHub. We will meet again with this kind of tech topic soon. Until then bye bye!

Download source from github:

Download service-registry/download/button/#2e86de Download department-service/download/button/#2e86de Download user-service/download/button/#2e86de

Go to Step 1 - Department Microservice

Go to Step 2 - User Microservice

Complete microservices architecture with real examples - Step 2 - User microservice

2021-02-19T00:30:00.193-08:00

Hi everyone! As in the previous post, we are going to implement a complete microservice architecture and as the first step, we have created a microservice which is called Department Service and for the sake of complexity which can handle with the architecture, we need one more service which has a call to the Department Service within it. So, here in this post, we will try to implement another service called User Service. we will quickly go into the implementation details.

This image is recreated by agnasarp.com and used only for information purposes. This does not have any bind with any real-world products or services. Image source: pixabay.com

Step 2 - User Microservice

Here we will quickly go to the technology stack that we are going to use in our implementation.

Initialization details

Spring Initialzr - User Service

Project build tool: Maven
Language: Java
Spring boot: 2.4.2
Project Metadata

Group: com.agnasarp
Artifact: agnasarp-user-microservice
Name: agnasarp-user-microservice
Description: Agnasarp User Microservice
Package name: com.agnasarp.user
Packaging: Jar
Java version: 8

Dependencies:

Spring Web: Build web, including RESTful, applications using Spring MVC. Uses Apache Tomcat as the default embedded container.
Spring Data JPA: Persist data in SQL stores with Java Persistence API using Spring Data and Hibernate.
H2 Database: Provides a fast in-memory database that supports JDBC API and R2DBC access, with a small (2mb) footprint. Supports embedded and server modes as well as a browser based console application.
Lomok: Java annotation library which helps to reduce boilerplate code.

Then, we will import the project into IntelliJ Idea.

Project structure

Project structure of user service in IntelliJ Idea

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.agnasarp</groupId>
	<artifactId>agnasarp-user-microservice</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>agnasarp-user-microservice</name>
	<description>Agnasarp User Microservice</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

application.yml

server:
  port: 8380

AgnasarpUserMicroserviceApplication.java

package com.agnasarp.user;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class AgnasarpUserMicroserviceApplication {

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

    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

UserController.java

package com.agnasarp.user.controller;

import com.agnasarp.user.entity.User;
import com.agnasarp.user.service.UserService;
import com.agnasarp.user.vo.ResponseTemplateVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {
    private static final Logger log = LoggerFactory.getLogger(UserController.class);
    @Autowired
    private UserService userService;

    @PostMapping("/")
    public User saveUser(@RequestBody User user) {
        log.info("Inside saveUser method of UserController");
        return userService.saveUser(user);
    }

    @GetMapping("/{id}")
    public ResponseTemplateVo getUserById(@PathVariable("id") Long userId) {
        log.info("Inside getUserById method of UserController");
        return userService.getUserWithDepartment(userId);
    }
}

UserService.java

package com.agnasarp.user.service;

import com.agnasarp.user.entity.User;
import com.agnasarp.user.repository.UserRepository;
import com.agnasarp.user.vo.Department;
import com.agnasarp.user.vo.ResponseTemplateVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class UserService {
    private static final Logger log = LoggerFactory.getLogger(UserService.class);
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private RestTemplate restTemplate;

    public User saveUser(User user) {
        log.info("Inside saveUser method of UserService");
        return userRepository.save(user);
    }

    public ResponseTemplateVo getUserWithDepartment(Long userId) {
        log.info("Inside getUserWithDepartment method of UserService");
        ResponseTemplateVo responseTemplateVo = new ResponseTemplateVo();
        User user = userRepository.getUserByUserId(userId);
        Department department = restTemplate.getForObject("http://localhost:8280/" +
                "departments/" + userId, Department.class);
        responseTemplateVo.setUser(user);
        responseTemplateVo.setDepartment(department);
        return responseTemplateVo;
    }

}

UserRepository.java

package com.agnasarp.user.repository;

import com.agnasarp.user.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User getUserByUserId(Long userId);
}

User.java

package com.agnasarp.user.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long userId;
    private String firstName;
    private String lastName;
    private Long departmentId;
}

View Objects

We need the attached department details of the user, therefore we have to create a Department view object here in the user microservice. And we need to show user details and department details collectively in the response, for that we have to create ResponseTemplateVo.

Department.java

package com.agnasarp.user.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Department {
    private Long departmentId;
    private String departmentName;
    private String departmentAddress;
    private String departmentCode;
}

ResponseTemplateVo.java

package com.agnasarp.user.vo;

import com.agnasarp.user.entity.User;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ResponseTemplateVo {
    private User user;
    private Department department;

    public void setUser(User user) {
        this.user = user;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }
}

Service call

Create user scenario

cURL

curl --location --request POST 'http://localhost:8380/users/' \
--header 'Content-Type: application/json' \
--data-raw '{
    "firstName":"John",
    "lastName":"Smith",
    "departmentId":"1"
}'

Postman call

Get user scenario: As we have designed to get user details with the assigned department, we have to create a department first with the save department service as in the previous post. Otherwise, the department object will be null.

cURL

curl --location --request GET 'http://localhost:8380/users/1'

Postman call

Now we have created the User Microservice successfully as same as the Department Service in the previous post. As the next step, we will create a service registry which is another important component in the microservice architecture. You can download the complete source code from GitHub with the below link.

Download source from github:

Download user-service/download/button/#2e86de

Go to Step 1 - Department Microservice

Complete microservices architecture with real examples - Step 1 - Department microservice

2021-02-17T00:30:00.007-08:00

Hello everyone! Today we are going to show you how you can create a microservice as a part of a complete microservices architecture that we will implement step by step in future posts. You can see the full architecture in the below diagram.

Microservices Architecture

As the first step, we will implement Department Service in this post. You can find all details step by step of Department Service with all source code.

Step 1 - Department Microservice

Here we will quickly go to the technology stack that we are going to use in our implementation.

Initialization details

Spring Initialzr - Department Service

Project build tool: Maven
Language: Java
Spring boot: 2.4.2
Project Metadata

Group: com.agnasarp
Artifact: agnasarp-department-microservice
Name: agnasarp-department-microservice
Description: Agnasarp Department Microservice
Package name: com.agnasarp.department
Packaging: Jar
Java version: 8

Dependencies:

Spring Web: Build web, including RESTful, applications using Spring MVC. Uses Apache Tomcat as the default embedded container.
Spring Data JPA: Persist data in SQL stores with Java Persistence API using Spring Data and Hibernate.
H2 Database: Provides a fast in-memory database that supports JDBC API and R2DBC access, with a small (2mb) footprint. Supports embedded and server modes as well as a browser based console application.
Lomok: Java annotation library which helps to reduce boilerplate code.

Then, we will import the project into IntelliJ Idea.

Project structure

Project structure of department service in IntelliJ Idea

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.agnasarp</groupId>
	<artifactId>agnasarp-department-microservice</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>agnasarp-department-microservice</name>
	<description>Agnasarp Department Microservice</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

application.yml

server:
  port: 8280

AgnasarpDepartmentMicroserviceApplication.java

package com.agnasarp.department;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AgnasarpDepartmentMicroserviceApplication {

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

}

DepartmentController.java

package com.agnasarp.department.controller;

import com.agnasarp.department.entity.Department;
import com.agnasarp.department.service.DepartmentService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/departments")

public class DepartmentController {
    private static final Logger log = LoggerFactory.getLogger(DepartmentController.class);
    @Autowired
    private DepartmentService departmentService;

    @PostMapping("/")
    public Department saveDepartment(@RequestBody Department department) {
        log.info("Inside saveDepartment method of DepartmentController");
        return departmentService.saveDepartment(department);
    }

    @GetMapping("/{id}")
    public Department getDepartmentById(@PathVariable("id") Long departmentId) {
        log.info("Inside getDepartmentById method of DepartmentController");
        return departmentService.getDepartmentById(departmentId);
    }
}

DepartmentService.java

package com.agnasarp.department.service;

import com.agnasarp.department.entity.Department;
import com.agnasarp.department.repository.DepartmentRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DepartmentService {

    private static final Logger log = LoggerFactory.getLogger(DepartmentService.class);
    @Autowired
    private DepartmentRepository departmentRepository;

    public Department saveDepartment(Department department) {
        log.info("Inside saveDepartment method of DepartmentService");
        return departmentRepository.save(department);
    }

    public Department getDepartmentById(Long departmentId) {
        log.info("Inside getDepartmentById method of DepartmentService");
        return departmentRepository.getDepartmentByDepartmentId(departmentId);
    }
}

DepartmentRepository.java

package com.agnasarp.department.repository;

import com.agnasarp.department.entity.Department;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface DepartmentRepository extends JpaRepository<Department, Long> {
    Department getDepartmentByDepartmentId(Long departmentId);
}

Department.java

package com.agnasarp.department.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long departmentId;
    private String departmentName;
    private String departmentAddress;
    private String departmentCode;
}

Service call

Create department scenario

cURL

curl --location --request POST 'http://localhost:8280/departments/' \
--header 'Content-Type: application/json' \
--data-raw '{
    "departmentName":"IT",
    "departmentAddress":"Colombo 07, Srilanka",
    "departmentCode":"IT-001"
}'

Postman call

Get department scenario

cURL

curl --location --request GET 'http://localhost:8280/departments/1' \
--data-raw ''

Postman call

Now we have created the Department Microservice successfully. As the next step, we will create another microservice because we need at least two microservices to get an idea about the whole microservices architecture. You can download the complete source code from GitHub with the below link.

Download source from github:

Download department-service/download/button/#2e86de

Go to Step 2 - User Microservice

An introduction to circuit breaker design pattern with a guide for using it practically in day-to-day development

2021-02-08T03:30:00.051-08:00

If your home has been powered by electricity, you have definitely heard about "Breakers" or "Breaker Switch". What does breaker do for us in the home grid? Actually, when there is a short-circuit or leakage the breaker switch will open and electricity will cut down. It will save our home and all appliances from that kind of damages. We can manually close the switch once the circuit came back to normal. This is the fault-tolerant strategy in our home grid.

This image is recreated by agnasarp.com and used only for information purposes. This does not have any bind with any real-world products or services. Image source: pixabay.com

Likewise, we should definitely have a mechanism for fault tolerance in our software applications. Here we are mainly focusing on fault tolerance in microservices. Today's software systems are moving to microservices architecture from monolithic architecture. We will create a number of granular independent microservices that can easily maintain in this architecture. There will be different service consumers like web applications, mobile applications that are calling microservices remotely to serve their customers. We might see even microservices may call other microservices that reside in the same system as well as in different 3rd party systems. More or less we have to face when the calling microservice is unavailable or not responsive. We have to have a successful fault-tolerant mechanism to keep the whole system up and running. The circuit breaker design pattern will come to play as a solution to that problem.

When we talk about a remote service like microservices, we are mainly considering two aspects. They are,

Availability of the remote service
Responsiveness of the remote service

When it comes to responsiveness, the service consumer can wait until the remote service will return a response. But it is not a good idea to wait for a considerably longer period of time because it will affect badly the end-user experience. We need to set some timeout values inside service consumers for remote services. There may be different ways to pick a timeout value. One method of selecting a value is doubling the average response time. For example, if some remote services have a 2000milliseconds(ms) average response time, we can pick the timeout value is 4000ms.

timeout = average response time x 2

= 2000ms x 2

= 4000ms

Though it seems pretty much OK we will face a huge problem when the remote service creates a resource in a backend layer like databases. Suppose that the underlying remote service is placing orders. If there is a delay in responding the service consumer will timeout the request and prompt ultimately a failure to process the request but the order has been taken place in the background. Since the service consumer is not aware of this, it will again place a new request creating finally a duplicate of the request. There should have been a complex logic to catch and eliminate this kind of duplicate requests. As a quick solution, we can optimize the timeout value further. Instead of double the average response time, we can double the maximum response time that takes to serve the request successfully at some point (max under load). Suppose 5000ms as the max underload the timeout value will be,

timeout = max underload x 2

= 5000ms x 2

= 10000ms

The service consumer will have to wait until 10000ms (10s) to get a response. This is completely unacceptable as it may badly affect the user experience. Then the circuit breaker pattern is the solution for the problem we have.

The circuit breaker is residing between the service consumer and the microservice and it is continuously monitoring the microservice.

When there is not anything special, the circuit breaker is in the closed state, and any service request goes to the microservice, and the service consumer gets the expected response. In this scenario, the microservice is available and responsive.
If the microservice is down or unresponsive, the circuit breaker detects that and changes its state to open. Unlike the timeout scenario, the service consumer gets a meaningful response with the unavailability of the microservice to serve the request in just a few milliseconds, for example, in 20ms.
Meanwhile, the circuit breaker checks the availability of the microservice but it is still unavailable or unresponsive.
If the microservice is available, then the circuit breaker will set its status from open to closed and it will route service requests from the service consumer to the microservice and returns the expected responses.

We will look at the function of monitoring the microservice by the circuit breaker. There can be 3 types of monitoring mechanisms, and we can say 3 types of circuit breakers as well for them. They are the simple heartbeat, synthetic transactions, and real-suer monitoring. We will check the capability of each mechanism.

Simple heartbeat

This is really about checking the health of the microservice. When the service is available, the breaker will understand the service is up and running and available to serve but does not have an idea about how long it will take to serve, which means no idea about responsiveness. Therefore this simple heartbeat is not ideal for circuit breaking.

Synthetic transactions

Here, we have to use fake transaction which generates only for testing the microservice whether it is available and responsive. We have to face few problems with this mechanism. One is we can only check very few scenarios. If we apply the strategy to order placing service, we will end up with certain types of orders for these fake transactions so all scenarios will not be covered. On the other hand, we have to request from all downstream systems even from reporting tools not to proceed with these dummy data or payload and that will be really awful.

Real-user monitoring

We use only real transactions for this monitoring. Here it is used trend analysis rather than the timeout. If we suppose there are 10 requests having response time in ms as 1.6, 2.0, 2.3, 1.9, 2.2, 2.3, 2.5, 3.0, 4.5, 5.8. Then there is a trend to increase the response time. Most of the time this analysis will be a standard deviation analysis since there are ups and downs. For example, if the response time is greater than 3 standard deviations from the mean, the circuit will be opened. If the circuit is in this state all the time, then the service consumer is unable to get expected service responses at all. To overcome this the circuit breaker will move from an open to half-open state. Here, it will allow passing through a limited number of requests to microservices. This percentage can be kept as configurable and let's say 1 out of 10 requests. the breaker will try this and if it got 6.9ms as the response time still it will be in a half-open state because the responsiveness is still not aligned with the expected value. If it will suddenly mark 1.6ms as the response time, then the breaker will close the circuit, and the route of the request is back to normal.

Practical implementation

We have created sample microservices with hystrix to describe the circuit breaker functionality. We have used spring initializer to initiate our services and used Web, Rest Repositories, and Actuator dependencies for agnasarp-hystrix-employee-service and Web, Actuator, Hystrix, and Hystrix Dashboard for agnasarp-hystrix-department-service.

Microservice: agnasarp-hystrix-employee-service

Project structure

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.agnasarp</groupId>
	<artifactId>agnasarp-hystrix-employee-service</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>agnasarp-hystrix-employee-service</name>
	<description>Agnasarp Hystrix Employee Service</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-rest</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

application.properties

server.port = 8280

EmployeeServiceApplication.java

package com.agnasarp.employeeservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class EmployeeServiceApplication {

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

}

EmployeeServiceController.java

package com.agnasarp.employeeservice.controller;

import com.agnasarp.employeeservice.domain.Employee;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@RestController
public class EmployeeServiceController {

    private static Map<String, List<Employee>> agnasarpDB = new HashMap<String, List<Employee>>();

    static {
        agnasarpDB = new HashMap<String, List<Employee>>();

        List<Employee> lst = new ArrayList<Employee>();
        Employee std = new Employee("Max", "Male");
        lst.add(std);
        std = new Employee("Lisa", "Female");
        lst.add(std);

        agnasarpDB.put("it-department", lst);

        lst = new ArrayList<Employee>();
        std = new Employee("Steve", "Male");
        lst.add(std);
        std = new Employee("Anne", "Female");
        lst.add(std);

        agnasarpDB.put("finance-department", lst);

    }

    @GetMapping(value = "/getEmployeeDetailsForDepartment/{department}")
    public List<Employee> getEmployees(@PathVariable String department) {
        System.out.println("Getting Employee details for " + department);

        List<Employee> employeeList = agnasarpDB.get(department);
        if (employeeList == null) {
            employeeList = new ArrayList<Employee>();
            Employee std = new Employee("Not Found", "N/A");
            employeeList.add(std);
        }
        return employeeList;
    }
}

Employee.java

package com.agnasarp.employeeservice.domain;

public class Employee {

    private String name;
    private String gender;

    public Employee(String name, String gender) {
        super();
        this.name = name;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

Service call

Request URL: http://localhost:8280/getEmployeeDetailsForDepartment/it-department

Service consumer: agnasarp-hystrix-department-service

Project structure

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.3.9.BUILD-SNAPSHOT</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.agnasarp</groupId>
	<artifactId>agnasarp-hystrix-department-service</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>agnasarp-hystrix-department-service</name>
	<description>Agnasarp Hystrix Department Service</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Hoxton.BUILD-SNAPSHOT</spring-cloud.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-rest</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</repository>
		<repository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
		</pluginRepository>
		<pluginRepository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
		</pluginRepository>
	</pluginRepositories>

</project>

application.properties

server.port = 8380
management.endpoints.web.exposure.include=*
management.endpoints.web.base-path=/

DepartmentServiceApplication.java

package com.agnasarp.departmentservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@EnableHystrixDashboard
@EnableCircuitBreaker
@ComponentScan(basePackages = "com.agnasarp.departmentservice.*")
public class DepartmentServiceApplication {

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

DepartmentServiceController.java

package com.agnasarp.departmentservice.controller;

import com.agnasarp.departmentservice.service.DepartmentServiceDelegate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DepartmentServiceController {

    private DepartmentServiceDelegate departmentServiceDelegate;

    public DepartmentServiceController(DepartmentServiceDelegate departmentServiceDelegate) {
        this.departmentServiceDelegate = departmentServiceDelegate;
    }

    @GetMapping(value = "/getDepartmentDetails/{department}")
    public String getEmployees(@PathVariable String department) {
        System.out.println("Going to call employee service to get data!");
        return departmentServiceDelegate.callEmployeeServiceAndGetData(department);
    }
}

DepartmentServiceDelegate.java

package com.agnasarp.departmentservice.service;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.Date;

@Service
public class DepartmentServiceDelegate {

    @Autowired
    RestTemplate restTemplate;

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @HystrixCommand(fallbackMethod = "callEmployeeServiceAndGetDataFallback")
    public String callEmployeeServiceAndGetData(String department) {

        System.out.println("Getting Department details for " + department);

        String response = restTemplate
                .exchange("http://localhost:8280/getEmployeeDetailsForDepartment/{department}"
                        , HttpMethod.GET
                        , null
                        , new ParameterizedTypeReference<String>() {
                        }, department).getBody();

        System.out.println("Response Received as " + response + " -  " + new Date());

        return "NORMAL FLOW !!! - Department Name -  " + department + " :::  " +
                " Employee Details " + response + " -  " + new Date();
    }

    @SuppressWarnings("unused")
    private String callEmployeeServiceAndGetDataFallback(String department) {

        System.out.println("Employee Service is down!!! fallback route enabled...");

        return "CIRCUIT BREAKER ENABLED!!! No Response From Employee Service at this moment. " +
                " Service will be back shortly - " + new Date();
    }
}

Service call

Request URL: http://localhost:8380/getDepartmentDetails/it-department

When the employee service up and running. the circuit breaker is in its closed state.

When the employee service is down. the circuit breaker is in its open state and the fallback method callEmployeeServiceAndGetDataFallback will be called.

Hystrix stream

Hystrix is continuously monitoring the employee service therefore, once the service is back to normal then the circuit will change its state from open to close and we will get the success response from the department service.

Hystrix dashboard

Visual representation of the circuit in the hystrix dashboard

Unfortunately, it is not working here, but if you configure it properly you will definitely get the visual representation.

Download source from github:

Download employee-service/download/button/#2e86de Download department-service/download/button/#2e86de

The blockchain in a nutshell

2021-02-04T03:30:00.008-08:00

This image is recreated by agnasarp.com and used only for information purposes. This does not have any bind with any real-world products or services. Image source: pixabay.com

What is Blockchain?

It is a way of storing data thus we can say it is a database, but it differs from the generic database technology. Here, data cannot be deleted once records added to the system. All new data is stored in a unit called a block. Once a block filled with data it is chained to the last block in chronological order. This process happens in all nodes in the decentralized peer-to-peer network, then all know the record of the transaction and as a result of that, there is a nearly 0% probability of having a fraud in the system. Blockchain is the underlying technology of any cryptocurrency in the world. Some of the real world cryptocurrencies are XRP, Bitcoin, Ethereum, Dogecoin, Stellar, EOS, Cardano, Uniswap Protocol Token, Litecoin, Bitcoin Cash, Chainlink, Thether, Binance Coin, Polkadot, TRON, OMG Network, BUSD, Sushi, Brand Protocol, and Bitcoin SV. Though blockchain is the underlying technology of cryptocurrencies, both of them are not equal and we cannot perform an apple to apple comparison.

Storage Structure

Normally, a database structures its data into tables whereas a blockchain, like its name implies, structures its data into chunks (blocks) that are chained together. Blocks have certain storage capacities and when filled they are chained to a previously filled block, making a data chain known as a blockchain. All new information that follows after a freshly added block is compiled into a newly formed block that will then be added to the chain when it is filled. This system basically makes an irreversible time sequence of data when applied in a decentralized nature. Each block in the chain gets the exact timestamp when it is added to the chain.

Transaction Process

If we look at the transaction process in blockchain technology, we can see a process that has few steps to validate and add a transaction to the system. When a transaction is entered into the system, it will transmit to all nodes/computers of the system with a peer-to-peer network. Then each node will try to resolve an equation to verify the validity of the transaction. If it can be confirmed as legitimate then it is clustered into a block. The newly created block then is chained together with the previous block in chronological order thus this chain of blocks which is the blockchain will maintain a clear, unchangeable, ordered transaction history across the network. Now the transaction is fully completed.

Attributes of Cryptocurrency

There are few unique attributes of any cryptocurrency. Intrinsicly, blockchain is trustworthy because of the architecture of the system, and as a result of that, almost all cryptocurrencies are using this as the backend technology. There is not central governance like a bank and important decisions such as total supply etc. will be taken by the majority of the network. Always the assets will be maintained digitally and a physical form of them is not available at all. Because of these attributes, this technology can also be used in legal contracts and inventories.

Decentralization

There are few central blockchain systems with a group of computers which are privately owned by organizations. But the majority of blockchain systems are decentralized and not governed by a central bank or any central authority. Instead, computers or group of computers in the network which is a=called as nodes will be maintained by individuals. By this decentralized nature of the system, there is not a possibility of happening a fraud, because if there is an error in a single node, there are multiple nodes with correct data to refer to.

Transparency

Since the decentralized nature of the system, each and every transaction will be known by all nodes in the chain. Every node has its own copy of the chain and once a fresh block confirmed and added to the system, the chain of every node will get updated.

Security

Once a block is added to the end of a blockchain, it is very difficult to go back and modify the contents of the block unless the majority has reached a consensus to do so. This is because each block contains its own hash, along with the hash of the block before it, as well as the previously mentioned timestamp. Hash codes are created by a mathematical function that converts digital information into a series of numbers and letters. If this information is edited in any way, the hash code. also changes. This is why it is important for security. Let’s say a hacker wants to modify a blockchain and steal Bitcoin from everyone else. If they changed their own individual copy, it would no longer match the copy of all the others. If everyone else would otherwise send their copies to each other, they would see that this one copy stands out and that the hacker version of the chain would be thrown out as illegitimate.

Advantages of Blockchain

Accuracy of the Chain: There is not any human involvement in the transaction verification process, if anyone needs to introduce an error to the system, 51% majority of nodes in the chain would accept it, and there is nearly 0% probability for it.
Cost Reductions: Normally in any transaction processing institute like banks, the end-user has to pay a considerable amount for the verification process and governance but n the decentralized blockchain, there is not a 3rd party to verify the transaction, and there is not a processing fee or sometimes it may be a very small amount.
Decentralization: Whenever a new block is added to the blockchain, every computer on the network updates its blockchain to reflect the change. By spreading this information across the network, instead of storing it in a single central database, the blockchain becomes more difficult to compromise. If a copy of the blockchain fell into the hands of hackers, only one copy of the information would be compromised, not the entire network.
Efficient Transactions: Whereas financial institutions operate during business hours, five days a week, blockchain is working 24 hours a day, seven days a week, and 365 days a year. This is especially useful for cross-border trades, which usually take much longer due to time zone problems and the fact that all parties have to confirm payment processing. Transactions placed through a central authority can take up to several days.
Private Transactions: Many blockchain networks act as public databases, which means that anyone with an Internet connection can view a list of network transaction histories. That is, when a user performs public transactions, the blockchain records his unique code called the public key, not his personal data. If a person has made a purchase of Bitcoin on an exchange that requires identification, then the identity of the person is still linked to their blockchain address, but the transaction, even when linked to the person’s name, does not reveal any personal information.
Secure Transactions: After a computer has validated the transaction, it is added to the blockchain block. All blocks in the chain contains its own unique hash, along with the unique hash of the block before it. When information on a block is edited in any way, the hashcode of that block is changed, however, the hash code on the block after it would not.
Transparency: Blockchain has an open-source codebase. It also means that there is no real authority over who controls the Bitcoins code or how it is edited. It gives auditors the ability to review cryptocurrencies like Bitcoin for security. If most network users agree that the new version of the code with the upgrade is correct and valuable, then Bitcoin can be updated.
Banking the Unbanked: According to the world bank, there are nearly 2 billion adults that do not have bank accounts or any means of storing their money or wealth. Almost all of these individuals live in developing countries where the economy is in its infancy and is entirely dependent on cash. Then they need to store this physical cash in hidden places in their homes or places of residence, leaving them with subject to robbery or unnecessary violence. Blockchains of the future are also looking for solutions not only to be a unit of account for the storage of wealth, but also for the storage of medical records, property rights and a number of other legal contracts.

Disadvantages of Blockchain

Technology Cost: Assuming electricity costs of $0.03~$0.05 per kilowatt-hour, mining costs exclusive of hardware expenses are about $5,000~$7,000 per coin. Despite the cost of bitcoin mining, customers continue to increase electricity bills to verify blockchain transactions For example, the poc system that bitcoin uses to validate transactions consumes a huge amount of computational power.
Speed Inefficiency: At that rate, it’s estimated that the blockchain network can only manage about seven transactions per second (TPS). The inefficiency rate of Bitcoin is a perfect case study for the possible inefficiency of blockchain. Although other cryptocurrencies like Ethereum work better than bitcoin, they are still limited by blockchain.
Illegal Activity: The most cited example of a blockchain used for illegal transactions is probably the Silk Road, an online dark web drug market that operated from February 2011 to October 2013, when the FBI shut it down. The website allowed users to search the website without tracking using the Tor browser and make illegal purchases in Bitcoin or other cryptocurrencies. Current US regulations require financial service providers to obtain information about their clients when opening accounts, verify the identity of each client, and confirm that the client does not appear on any list of known terrorist organizations. or suspicious.
Regulation: While it is getting increasingly difficult and near impossible to end something like Bitcoin as its decentralized network grows, governments could theoretically make it illegal to own cryptocurrencies or participate in their networks. Many in the crypto space have expressed concern about government regulation of cryptocurrencies.

What's Next for Blockchain?

Blockchain had begun its journey in 1991 and now it has been almost thirty years being alive in the world. The technology is already utilized in monetary solutions but it has a massive capability of other use cases as well. Therefore, there are no doubt legacy companies will move into the technology but the problem is when it has to happen. While looking into the distant future of blockchain is extremely exciting, new innovations are constantly entering the market promising greater and bolder use of technology. As active blockchain networks continue to bring real transformative change to many industries, we can predict future trends. With the new radical way of storing data, the technology will be used in multiple areas such as banking and finance, currency, healthcare, records of property, smart contracts, supply chains, voting.

Sources:

https://www.investopedia.com/terms/b/blockchain.asp

The real engagement between BMW and Honeywell's H1 for the best supply chain strategy in the era as the first commercial use case in quantum computing.

2021-01-28T03:30:00.016-08:00

This image is recreated by agnasarp.com and used only for information purposes. This does not have any bind with any real-world products or services. Image source: www.pexels.com & www.honeywell.com

One of the most automobile giants, BMW takes a super exciting step into quantum computing which was just theoretical stuff in the recent past. They will work together with Honeywell's system model H1 to empower the speed and accuracy of strategies in their supply chain to streamline the process. They look forward to finding a solution to choose the right supplier at the right time considering all other factors like price and so on. In classical computing, there are limitations to optimize this kind of solutions. We have heard quantum computing as theoretical pieces of stuff in the recent past and now the time came to leverage problem solving with commercial quantum computers. Julius Marcea, a BMW Group IT chief said,

"We are excited to investigate the transformative potential of quantum computing on the automotive industry and are committed to extending the limits of engineering performance,"

BMW started evaluating this radical emerging technology in 2018 and they have a lot of ideas in which this technology can be used. This supply chain empowering is one of the things in that whole bunch of ideas. BMW currently is working with a startup, Entropica Labs and they are mostly working on software that can be run on quantum computers. The power and the capability of quantum computers can offer, will be unveiled with these experiments. In essence, we can get an idea about when can we get real advantages of quantum computing.

A few quantum properties like superposition, entanglement, and interference are used in quantum computing. Normally, there is only 0 or 1 as the state of the basic unit of information, which is a bit at a time in classical computing but the quantum version of bit, which is a Qubit may be either of those or maybe both 0 and 1 at the same time, which is known as superposition. Nowadays quantum computers have few dozens of Qubits but they can do lots of things than classic computers do. As an example, a quantum computer can perform calculations, especially in simulations and optimizations in just a few minutes, which a classic computer may take billions of years to complete. This is the super excitement behind quantum computing.

Sources:
https://www.cnet.com/news/bmw-takes-first-steps-into-the-quantum-computing-revolution/

Another flagship product from Apple Inc. News about Apple's first VR headset

2021-01-26T03:30:00.009-08:00

This image is recreated by agnasarp.com and used only for information purposes. This does not have any bind with any real-world products or services. Image source: pixabay.com

One of the most reputed multinational technology companies, Apple Inc. is currently working on their first VR headset after the perceived obstacle of the development of the Apple Watch. This will be a major product category with a higher price tag as usual with all other Apple products. There is a plan to release the new augmented reality device in 2022 and it has to compete with the market leader, Facebook's Oculus and Sony's Playstation VR set, etc. Like other VR devices, it will create a 3D digital environment for watching videos and gaming.

Typically, Apple look forwards to spend its assets to deliver reliable and easy to use devices like smartphones, tablets, smartwatches, and music players but this time they have shifted into a different segment of the technology world with a different strategy of development with outside developers especially in the development of AR glasses. They expect that this will be a high-end, niche product with respect to the effort that they have put on.

With the highest predicted price tag, Apple stores may sell only a few units per day as per an insider of the company and it will have to compete with the famous Oculus Quest. Apple is always going to use its powerful ingredients to build the product, the CPU and the display unit will have a higher capability in comparison to the rival products. The other special thing with this is, having a fan. To further reduce the device’s weight, Apple is going to use a fabric exterior. That’s a departure from the metal designs Apple uses for many products, though it's used plastic for devices like AirPods, which require to be light, and fabrics for the HomePod speaker to enhance acoustics.

The prototype of the device includes external cameras that can be used to activate some extra AR features. At the same time, Apple is experimenting on how can enter text input into the device but it will not be guaranteed that the feature may come with the first version of the device. And there is another discussion on bundling the App Store with the device which runs on a different Operating System called "rOS". Apple's ultimate target, the AR glasses need small, powerful, and efficient electronics in order to achieve advanced features. That can be achieved if they will deliver a less mainstream device as the first version and as a result of that, they will have the opportunity to develop underlying technologies well to succeed in the ultimate AR glasses.

Sources:

https://www.bloomberg.com/news/articles/2021-01-21/apple-s-first-vr-headset-to-be-niche-precursor-to-eventual-ar-glasses

Agnasarp.com | Tech vlog | Watch our super exciting videos on the Agnasarp YouTube channel!

2021-01-22T03:30:00.026-08:00

Hello everyone! Welcome to our brand new YouTube channel Agnasarp! Let me introduce what Agnasarp is. It is a video blog that gives you an insight into cutting-edge technologies, thus we can simply say it is a 100% technology YouTube channel. If you are super curious about new technologies especially the Internet, Computing, Programming, Mobile, Gadgets, Artificial Intelligence, Machine Learning, Augmented Reality, Virtual Reality, Blockchain, and more, this is the right place for you. Stay with us to watch our super exciting videos.

Introduction to Social Engineering and Strategy to Handle Social Engineering Attacks

2021-01-17T04:51:00.007-08:00

Sometimes you may have heard Social Engineering but sometimes you may not, however, it will not be an excuse for you to become a victim of social engineering attack. That is the main reason to empower you with knowledge of social engineering and the strategy of handling social engineering attacks. The objectives of this post are to share about types of social engineering, understanding identity theft with potential effects, techniques used by social engineers which are phishing attacks and malicious email attachments, etc. You will mitigate personnel vulnerabilities with an awareness of the security and protect against identity theft and double-dealing with social engineering that compromise the security of the organization.

What is Social Engineering?

This is the new face of security compromise therefore it will be the greatest threat to confidentiality today. Here, social engineers manipulate people to expose their private information, and sometimes they will make unauthorized changes to that information. Social engineers will take the advantage of human behavior to pull off a scam. It is a type of deception in which they present themselves as people that you can trust. They do not hesitate if they want to enter a building and they will just ask confidently from you to help them get inside. You will mislead as everything will happen without any compromise with the firewall but it will break all the security if you are tricked into clicking on a malicious link you think came from a Facebook or LinkedIn connection.

Social Engineering's Playbook

Criminals will often take weeks and months to get to know a place before even coming in the door or making a phone call. Their preparation might include finding an organization's phone list or its chart and researching employees on social networking sites like Facebook and LinkedIn.

On the Phone

A social engineer might call and pretended to be a fellow or a trusted outside authority such as law enforcement or an auditor. The criminals try to make the person feel comfortable with familiarity. They might learn the corporate lingo so the person on the end thinks they are an insider.

In the Office

This is a generic tactic used by social engineers when they want to enter a building. How many times do you have heard this kind of request on the organization premises?

Can you hold the door for a second for me? I just forgot to bring my access card today.

Online

Today, there are plenty of social networks like LinkedIn, Facebook, Instagram, and Twitter, therefore, if you want to do company research before you going to face an interview, that will be really easy and you will definitely find loads of valuable information from them. Social engineers use the same strategy to collect information before launching an attack. They can find current employees of an organization from LinkedIn and they will collect everything about them. It is clearly proved by the below quote of a social engineer.

It's now a matter of minutes that I can put together a good social engineering exercise, versus days and weeks in the past. Ad if I send out a hundred spear phishing emails, based on gathered information, it's almost a guarantee that I'm going to get a good hit rate. (Social Engineer)

For online scams, social engineers take advantage of fear, curiosity, and greed, such as sending phishing emails asking if a target has ever seen their video, or a tech support scam claiming that the target's computer has been compromised. Attackers customize phishing attacks to target known areas of interest that can be leveraged to convince users to click on attachments linked by malware such as artists, actors, music, politics, and more. It creates a fake Facebook app designed to collect information. It can be designed to attract users and collect contacts and other information based on items that have already expressed interest. Exactly who you are connected to, whether you are connected to someone who will be another juicy target.

Types of Social Engineering Attacks

There are endless ways an identity thief could use social engineering to steal your personal information. Below is the scratch at the surface, but it covers the majority of common tactics used. The first line of defense is being aware of these tactics.

Pretexting

Pretexting is used in almost every other type of social engineering attack. It is the art of lying t obtain privileged data, typically by researching a person to impersonate them. this may include knowing personal details such as their Identity card number, date of birth, or their wife's name. It may also be as simple as impersonating an insurance salesman. Pretexting is an excellent way to establish legitimacy early in an attack.

Phishing

The origin of the word phishing comes from "phone fishing". It is a technique of fraudulently obtaining private information. Typically, the phisher sends an email that appears to come from a legitimate business such as a bank, or a credit card company. Phishers request verification of information and warning of some dire consequences if it is not provided. The email usually contains a link to a fake web page that seems legitimate and has a form requesting everything from a home address to an ATM card's PIN or a credit card number.

There is another way of phishing called "spear-phishing" and although it is similar to phishing, it is a technique that fraudulently obtains personal information by sending 100% customized emails to targeted users. For these emails, the attacker needs to perform additional research to trick the end-user o the requested activities. spear-phishing has a higher success rate when compared to phishing.

Vishing

Vishing, which is also known as voice fishing is the process of collecting personally identifiable information fraudulently from the general public with the help of telephone systems for the purpose of using a financial reward. Normally, the end-user might receive a telephone call with a voice message from a financial institute or a customer and ask the recipient to call a number and enter their account information or PIN for official use or security. But the number rings right away to the attacker via a voice-over-IP service.

Tailgating

In tailgating, basically, the attacker wants to enter to premises and it might be restricted electronic access control system normally, by RFID card. Then he/she simply asks an employee or customer who has legitimate access to the premises to hold the door for a second to enter or will enter the building just after the employee when the employee opens the door only for himself/herself. Mistakenly the legitimate employee may fail to ask the attacker to present the access token or sometimes the attacker pretends as he/she was forgotten to bring it with. Sometimes they may present a fake access token when someone asks in that kind of situation.

Baiting

In baiting, the attacker uses physical media to make curiosity of the victim. Normally, attackers leave malware-infected USB flash drives or other portable devices in locations people will find them and connect to work networks. This attack can also come in the form of giving you little pieces of information to trigger a response. In a situation of the attacker is asking to transfer a call from an employee to the supervisor of him/her, it shows the attacker baiting the employee where the employee should've asked for more authentication before transferring the phone call to the supervisor.

Quid Pro Quo

This is a variant of baiting. Instead of baiting a target with a device, a quid pro quo attack promises a service or a benefit based on the execution of a specific action. A hacker impersonating an IT staff for a large organization is the most generic quid pro quo attack. The attacker may call the employee of the target organization and offer some kind of system upgrade or software installation. They might request victims to facilitate the operation by disabling the antivirus software temporarily to install the malicious apps.

Detecting Phony Emails

Detecting phony emails is simpler than you may think-common sense is your best defense. If something seems suspicious or does not feel right, it may be an attack. Most of the time, below common clues will include social engineering attacks.

Creating a sense of urgency
Asking for your password
Asking for information they should not have access to
Something too good to be true like winning the lottery.
Pressuring you to bypass or ignore security procedures.
An odd email containing wording that does not sound like your colleague.

We can do the below things to overcome the risk of those emails.

Do not click on links in messages.
Verify with known parties.
Check the email address. Does it match the text of the email?
Use known links and contacts outside those provided in the email.
Do not download files from unsolicited sources.
Watch for poor grammar, misspellings, urgent messages, and please for money.

Handling Social Engineering Attacks

We can see new threats on a regular basis and there are many additional types of social engineering attacks. It is really impossible to stay away from being a target of such attacks, therefore following advice will help to ensure that you will not become a victim though you would have to be the target of someone.

Be cautious when opening attachments.: It is better to research if in doubt or to contact the security team.
Find the URL from links on your own.: If you have a doubt about the legitimacy of the URL, then better go for a manual search with a known search engine.
Ignore unsolicited requests.: Nobody should have to know your passwords or financial info in an email or phone call.
Secure your devices.: Lock your workstation and install the right software and keep applications up-to-date.
Multifactor Authentication: During the phone calls, ask the person on the other end multiple questions to verify identity.
Follow company policy.: Every company should have a standard set of policies and procedures that you must follow.
Ensure antivirus software is updated.: This kind of software is able to give you adequate security warnings and able to prevent further damage.

It is better to call the security team of the organization if you have even a small doubt before getting the problem worst because it is the easiest action we can take in a few minutes.

Sources:

https://www.coursehero.com/file/p7a4ck1/We-have-all-of-the-different-social-network-platforms-we-can-check-now-to/

New Trend of Artificial Intelligence (AI) with Light and In-Memory Computing for a Minimum Latency from IBM

2021-01-14T04:20:00.003-08:00

This image is recreated by agnasarp.com and used only for information purposes. This does not have any bind with any real-world products or services. Image source: pixabay.com

The data transmitting from/to anywhere has a significant delay and the processing may slow down with the present electrical current. This may lead to our favorite streaming applications would show events with a lag and other critical applications like self-driving vehicles and health applications with a deadly delay. With photonic integrated circuits, the IBM research team found a solution for this latency problem.

IBM Research team has developed a way to reduce latency by using photonic integrated circuits that use light instead of electricity for computing. They also present their photonic processing combination as a non-von Neumann, in-memory computing model. That model performs computations with unprecedented, ultra-low latency and computes density. Their model performs computations at even higher speeds, performing key computational primitives associated with AI models, such as deep neural networks for computer vision in a great efficient manner than ever before.

What is Photonic Integrated Circuit (PIC)?

The photonic integrated circuit (also known as a PIC) is a complex integrated circuit that incorporates a large number of optical devices to form a single photonic circuit. The main difference between a PIC and an electronic IC is that the PIC is analogous to an electronic integrated circuit. Many optical devices such as optical amplifiers, multiplexers, demultiplexers, optical lasers, attenuators, and also detectors are integrated into a photonic integrated circuit. For a large-scale operation of such a device, thousands of optical devices will be integrated into the device.

What is Light and In-Memory Computing (IMC)?

The combination of photonic and IMC can solve the problem of lag so that computation in photonic memory plays an important role in critical and important artificial intelligence programs. With computer memory, the photonic process overcomes seemingly obstacles that are too great to be overcome to the bandwidth of artificial intelligence computing systems based on electronic processors.

There is a physical limitation for the electronic processors, as the number of GPUs you can store in a computer or in a self-driving car is not endless. This problem has led developers to turn to photonic for time-critical apps. It incorporates a photonic processor that has a much higher data modulation speed than that of electronics and can run multiple operations at the same time in the same physical core using "wavelength division multiplexing" (WDM). (This is a technology that multiplies numbers of optical carrier signals on a single optical fiber using different wavelengths of laser lights.) In this way, it provides an additional measure by using the frequency area. In essence, they are able to read using different wavelengths or colors, at the same time.

Findings of the Research

They used a measure called TOPS to assess the number of Operations Per Second, in Trillions, that a chip is able to process. In proof of concept, they obtained experimental data with matrices up to 9 × 4 with a maximum input vector of four at a time, they used non-volatile photonic memory devices based on phase-change memory to store the convolution cores on a chip and used photonic chip-based frequency combs to feed the multi-frequency encoded input. Even with the small 9 × 4 matrices, by employing four multiplexed input vectors and a modulation rate of 14GHz, they obtained an enormous processing speed of two trillion MAC operations (multiply-accumulate) per second or 2 TOPS. The result is impressive since the matrix is so small - although they are not doing many operations, they are doing them so fast that the TOPS figure is still very large.

Finally, Abu Sebastian, Distinguished Research Staff Member, IBM Research who involved in this research said,

Our work shows the enormous potential for photonic processing to accelerate certain types of computations such as convolutions. The challenge going forward is to string together these computational primitives and still achieve substantial end-to-end system-level performance. This is what we’re focused on now.

Sources:
https://www.ibm.com/blogs/research/2021/01/latency-ai-photonics/

Introduction to Information Security

2021-01-08T06:30:00.007-08:00

This image is recreated by agnasarp.com and used only for information purposes. This does not have any bind with any real-world products or services. Image source: pixabay.com

In this post, we are going to illustrate the definition of information and information security, the importance of information security and the role which organizational employees have to play, different types of cyber crimes that breach the safety of information, and finally, the ways that we can follow to ensure the information security.

This post will help you to understand the nature of the potential information security threats facing organizations today, recognize why we need to protect the confidential information entrusted to us, understand our responsibilities in supporting our information protection policies, properly handle possible or actual information security incident or data loss, be aware of the existence of the Confidentiality, Integrity, and Availability (CIA) model as the three most crucial components of security, and gain understanding on what are the specific actions to safeguard our information security.

What is Information?

Information is an asset which, like other important business assets, has value to an organization and consequently needs to be suitably protected. Whatever form the information takes, or means by which it is shared or stored, it should always be appropriately protected. All information is valuable but the increasing reliance on sophisticated processes and technology makes it ever more critical to us and an ever more tempting target for those wanting to exploit it. Information can be created; destroyed; processed; lost; stored; transmitted; corrupted; stolen.

What is Information Security?

Information security is sometimes abbreviated as infosec and is a set of practices designed to secure data from unauthorized access or modification as it is stored or transferred from a physical device or location to another location. Sometimes you call this data security. In other words, we can say all the processes and practices we can implement to protect our network, computers, applications, and data from attackers on the C-I-A triad. Efforts to maintain information security while knowledge has become one of the most important assets of the 21st century are becoming increasingly important. As the number of billion dollars of loss associated with Cyber Crime, we should essentially be careful about information security. Unfortunately, information security can be compromised due to the lack of knowledge and understanding of how to work in a comprehensive manner.

In an organization, we have to take information security very seriously. We can implement several controls in place to protect our assets, and securely handle the data of the organization. But the individual employee is the most important line of defense in all these controls.

Administrative Control

Policies
Procedures
Guidelines
Employee screenings
Change control
Security awareness trainings

Technical Control

Access control
Encryption
Firewalls
IDS
IPS
HTTPS
Physical control

Physical Control

Restrict physical access to resources and premises

Most importantly business survival depends on information security therefore each and every employees have a responsibility to help the organization to

Protect information from a range of threats
Ensure business continuity
Minimize potential financial loss
Optimize return on investment
Increase business opportunities.

Know Your Enemy & Protect Yourself

There are several parties who can commit a cybercrime. Those are,

Terrorists: The resulting cyber attack can affect voting processes, electrical grids, and the shutdown of important government facilities.
Insiders: Estimated billions in losses and internal frauds.
Common thieves: Why did you rob the bank? That is where the money is.
Hacktivists: Anonymous people who force political opinion and agenda.
Foreign nations: Stuxnet, Sony attacks, WannaCry
Organized crime: Traditional mafia is outsourcing cybercrime to freelance criminals.

Basically, controls can be applied in an effort to protect the Confidentiality, Integrity, and Availability of information as the information security is based on the C-I-A model.

The C-I-A Model

Confidentiality

Those are measures taken to prevent sensitive information from unwanted people while ensuring the right people have access to it. Employees in the organization must be aware of the risk factors, threats, and how to guard against them.

Integrity

This assures that sensitive data is trustworthy, accurate, and consistent. Security measures are taken to ensure that sensitive data is not being able to modify by unauthorized users.

Availability

If an organization went offline for a short amount of time, there may be a significant loss. Therefore, keeping the business operations is critical and we need to ensure that those who need access can maintain this access at any time.

How Can We Protect Our Facility?

Most of the time, a successful attack may originate with the attacker on the premise. Attackers can use a physical attack as sounding a fire alarm and causing the building to be evacuated. Physical access to the organization's buildings can lead to theft and allow them to launch a network attack. Regulations and laws need to be applied even in the event of an emergency and sensitive data must be protected. We can get the following actions to keep our facilities still protected.

Employees as live beings in the organization should be on alert for who enters and exits buildings.
If the organization provided access cards to the employees, you can consider employees not wearing access cards and accompany them to the security office.
Employees can watch out for suspicious characters hovering around the workplace and the building premises.

How Can We Protect Our Network?

Network attacks are the most common technical threat. This can be a denial of services taking servers of the organization offline. And it can be lead to compromise of customer data resulting in loss of revenue and lawsuits. We can take the below actions to protect our network.

Use secure protocols when transmitting data. ex: HTTPS rather than HTTP
Protect physical access to systems by locking computers.
Do not connect unknown systems to the network
Scan all files before you download and download from only trusted sites.
Encrypt your emails and sensitive files.

How Can We Protect Our Identity?

Personal Identifiable Information which also known as PII is any information that can lead to locating and contacting an individual and identifying that individual uniquely. PII may be full name, mother's maiden name, identification number, address, phone number, driver's license/road tax, biometrics, or other uniquely identifying characteristics. Information sharing leads to compromise as we share more and more about ourselves through various platforms. Our responsibility at work to protect the PII of customers as we protect our own PIIs as well.

Identity theft starts off with the attacker acquiring little information that ultimately leads to a wider array of information. It is the crime of obtaining the personal or financial information of another person for the sole purpose of assuming that person's name or identity to make transactions or purchases. Identity thieves may steal employees' and/or customers' data or even the organization's identity, putting its reputation at a risk. This may lead to

Financial ramifications: Thousands of dollars in debt accrued in your name or scarred credit history or additional cost to resolve financial errors (legal fees etc.)
Life-threatening complications: Medical mistakes due to misinformation linked to your name or trouble getting prescriptions if someone else has already claimed it under your name.
Potential criminal charges: An identity thief may break the law while using your identity, leaving you to deal with the ramifications.

We can do the following to protect our identity.

How to secure your personal info

Be careful of your wallet as it contains all your sensitive information such as your identity card and driver's license.
Review your receipts and compare it with account statemes.
Shred receipts, credit offers, account statements and expired cards to prevent dumpster divers from getting your personal information.
Store personal information in a safe place at home and at work.
Watch out for shoulder surfers specially with coded-access to buildings when using ATMs.

How to secure your work place

Sensitive information must be kept secured.
Ensure the firewalls and virus-detection software are constantly updated on your home or your work computer.

How Can We Protect Against Malicious Websites?

Attackers make millions of dollars by tricking end-users. Rogue websites are used to collect information, intercept information, and distribute malicious software such as keyloggers that track all your keystrokes. In browser hijacking, if a site will not allow you to access any other sites and has homepage or search engine been modified without your permission, be suspicious. You need to be careful about websites "Buy Now" offers and pop-ups,indicates trouble and often "free downloads" install spyware or other applications on your system. Some websites will say that they have "Scanned your computer and havedetected viruses" should always be treated with suspicious. Poorly built websites where it is difficult to find the information you are looking for may be malicious. And if every link seems to lead to an advertisement, find more legitimate website to conduct your business.

Avoid using suspicious websites.
Use secure protocols like HTTPS.
Do not ignore any security warnings that can save you from virus attacks.
Do not download files from peer to peer sites. ex: BitTorrent.
Do not change your browser's default security settings.
Contact your security team if you have to face a difficult situation.

How Can We Protect Our Mobile Devices?

Portability makes mobile devices vulnerable and the Bluetooth is inherently insecure. Applications ofter share information with other applications across different platforms. Apart from that, contacts and other sensitive information are often easily compromised. We can take the necessary actions below to protect our mobile devices.

Use strong passwords or passcodes.
Disable Bluetooth when not in use.
Backup and protect data.
Enable remote wipe function and consider the "Find your device option".
Be cautious about what you share.
Download only secure applications.
Do not enable information sharing between apps unless necessary.
Don't connect to a working system or work network with personal mobile devices unless you have express access.
Report anything which is not trustworthy, to the security team.
Do not root or jailbreak your devices to leave devices open to vulnerabilities.

Good Information Security Practices

It is better to shut down your personal computer when you are not in use and it is the best way to keep your security threats away from your valuable data/information. You can lock or log off the PC as well if you leave it for a short while.
You can keep your systems/os patched and up-to-date.
You can use strong credentials and protect them by not exposing them to any other.
You can encrypt sensitive files to make sure the confidentiality of data.
You can double-check the information that you are going to share or expose to others.
You should never let anyone access your system with your own credentials.
You should be on alert of persons looking for information and physical access to buildings.
You should disable unsecured mechanisms.
You should report any security breach or potential security concerns to your security teams.
You should trust and use your own knowledge/intelligence if you are uncomfortable with anything.

Technology trends in 2021

2020-12-28T14:31:00.005-08:00

This image is recreated by agnasarp.com and used only for information purposes. This does not have any bind with any real-world products or services. Image source: deloitte.com

The coming year 2021 will not be a usual year with the prevailing Covid-19 situation and badly this pandemic already has been created a situation of staying in the home for all of us. Industries all over the world could be survived up to a certain and considerable level with technologies that can be practically used to support the workforce even in a situation like working remotely. Employees have also been able to save their employments with the opportunities that today's technologies created.

According to Deloitte’s 12th annual Tech Trends report, we will quickly look at the insights and inspiration for the digital journey ahead. The report presented 9 tech trends under 6 main areas as below in the table for the year 2021.

Area	Trend
Core Modernization	Core revival
Trust	Zero trust
Business of Technology	Strategy, engineered
	DEI tech: Tools for equity
	Supply unchained
Cloud & Distributed Platforms
Data and Analytics & Artificial Intelligence	Machine data revolution
Data and Analytics & Artificial Intelligence	MLOps: Industrialized AI
Digital Experience & Digital Reality	Rebooting the digital workplace
Digital Experience & Digital Reality	Bespoke for billions

Trend 1: Strategy, engineered

Today's technology has brought new competitive advantages to some organizations, and it has brought continued survival threats to other organizations. As a result, the distinction between company strategy and technology strategy has become blurred-both need to inform each other. Savvy corporate strategists are going beyond the current technological capabilities and competitive landscape of their organizations, considering the broader future possibilities of how technology can expand their business scope and ways to win. However, the complex uncertainty and range of possibilities may make the human brain unable to deal with it on its own. This is why strategists turn to strategic technology platforms with advanced analysis, automation, and artificial intelligence capabilities. Organizations are using these tools to continuously identify internal and external strategic forces, provide information for strategic decisions and monitor results. As a result, the company is transforming strategy development from an infrequent and time-consuming process to a continuous and dynamic process, thereby helping strategists to think more broadly and creatively about the broad possibilities of the future.

Trend 2: Core revival

Modernizing old enterprise systems and migrating them to the cloud can help unlock the organization’s digital potential. Until recently, these efforts could also undermine the digital transformation budget of the same organization. For many, the cost of the required cloud migration and other core modernization strategies may be prohibitive. This will change. In Deloitte’s recognized growth trend, some pioneering companies have begun to use clever outsourcing arrangements to redesign traditional business cases to achieve core modernization. Similarly, some companies are exploring opportunities to transfer core assets to increasingly powerful platforms (including low-code options). Finally, many companies promote their platform-first strategy by solving technical problems in the ERP system and migrating non-essential functions to other platforms. In the business climate defined by historical uncertainty, these innovative methods to obtain more value from traditional core assets may soon become a standard part of every CIO's digital transformation manual.

Trend 3: Supply unchained

For a long time, the supply chain has been regarded as the cost of doing business. It is moving from the back office to the value-added front line of customer segmentation and product differentiation. Future-oriented manufacturers, retailers, distributors, etc. are exploring ways to transform the supply chain cost center into a customer-centric value driver. They are getting more value from the data collected, analyzed, and shared across the supply network. Finally, some of these organizations are exploring opportunities to use robots, drones, and advanced image recognition to make employees’ physical supply chain interactions more efficient, effective, and safe. Of course, transforming an established supply chain into a flexible, customer-centric supply network will be a challenge, and for most organizations, this will be an ongoing journey-vital. The kind of destruction we saw in the COVID-19 pandemic is likely to become the norm. When the next global event arrives, technology and supply chain leaders will not be able to claim that they have not seen the upcoming events.

Trend 4: MLOps: Industrialized AI

Advanced machine learning models can help companies effectively discover patterns, reveal anomalies, make predictions and decisions, and generate insights, and are increasingly becoming a key driver of organizational performance. Companies realize that they need to transform from personal heroes to engineering performance in order to effectively transfer machine learning models from development to production and management. However, due to awkward, fragile development and deployment processes that hinder trials and hinder collaboration between product teams, operations staff, and data scientists, many people's efforts have been hindered. As AI and ML mature, a lot of engineering and operational discipline can help organizations overcome these obstacles and effectively extend AI to achieve business transformation. In order to realize the broader transformative benefits of AI and ML, the manual AI era must give way to one of the industrialized insights of automation. Enter MLOps, also known as ML CI/CD, ModelOps, and ML DevOps: Application of DevOps tools and methods in model development and delivery to achieve industrialization and large-scale machine learning from development and deployment to ongoing model maintenance and management.

Trend 5: Machine data revolution: Feeding the machine

As machine learning prepares to overhaul business operations and decision-making, more and more AI pioneers realize that legacy data models and infrastructure (all designed to support human rather than machine decision-making) may become obstacles to the success of ML. In response, these organizations are taking steps to disrupt the data management value chain from start to finish. As part of a growing trend, they are deploying new technologies and methods, including advanced data capture and structuring capabilities, analysis to identify connections between random data, and next-generation cloud-based data to support complex modeling storage. Together, these tools and technologies can help organizations transform the ever-increasing amount of data into the future foundation of a new era. In the new era, machines can not only enhance human decision-making capabilities but also make real-time and large-scale capabilities that humans cannot make.

Trend 6: Zero trust: Never trust, always verify

Complex cyber attacks and the rapidly changing corporate environment have disrupted traditional (some flawed) castle and moat cybersecurity methods. Zero trusts is rooted in the following concept: modern enterprise environments require different security methods: there is no longer a defined scope within which every user, workload, device, and network is inherently trusted. In a zero-trust architecture, each access request should be validated based on all available data points (including user identity, device, location, and other variables that provide context for each connection and allow more nuances based on risk). Data, applications, workloads, and other resources are treated as a single manageable unit containing vulnerabilities, and access is provided based on the principle of least privilege. The automation and engineering required to properly implement a zero-trust security architecture can help strengthen the security posture, simplify security management, improve the end-user experience, and enable the modern enterprise environment. However, the transition to zero-trust may require tremendous effort and planning, including solving basic network security issues, automating manual processes, and planning changes to security organizations, technological prospects, and the enterprise itself.

Trend 7: Rebooting the digital workplace

As the world's largest unplanned work from home continues, many business leaders are asking unresolved questions: After the dust settles, will remote work be the rule or the exception? Is permanent remote labor sustainable? How will productivity and employee well-being be affected? If there is no face-to-face peer contact, will innovation suffer? What role will the physical office play? By more intentionally embracing the positive aspects of the digital workplace, including data generated by employees’ tools and platforms, companies may be able to overcome the deficiencies and ambiguities of the digital workplace. This can help organizations optimize individual and team performance and customize the employee experience through personalized recommendations, making remote work far more than just a traditional office agent. As on-site workspaces and headquarters grow, organizations can use this data to create thriving, efficient, and cost-effective offices that are seamlessly intertwined with remote experiences.

Trend 8: Bespoke for billions: Digital meets physical

When we look back, 2020 will be a turning point for most people to adapt to digital interaction for daily life, whether it is working from home, studying online, or ordering groceries. However, the proliferation of digital interaction is a day when many of us desire to interact in person. As we look to the future, we hope that consumers will no longer be satisfied with the unique physical or digital brand experience: they want the best combination of the two without sacrificing the convenience of online transactions (a highly personalized personal experience) mix together. In the next 18 to 24 months, we hope that the personal experience and digital experience will become more seamless and intertwined. Online and offline interactions will no longer be separate experiences-the customer’s journey will consist of personal and digital elements, which are integrated and deliberately designed to create a seamless brand experience that adapts to the behaviors and attitudes of individual customers and preferences.

Trend 9: DEI tech: Tools for equity

Many organizations are embracing diversity, equity, and inclusion as business imperatives, with a growing number adopting holistic, organization-wide workforce strategies that address biases and inequities to enhance enterprise and employee performance. While HR professionals often lead DEI strategies, technology leaders play a critical role as a strategic partner by designing, developing, and executing tech-enabled solutions to address increasingly complex DEI workforce challenges. Over the coming months, we expect enterprises to adopt new tools that incorporate advanced analytics, automation, and AI, including natural language processing and machine learning, to help inform, deliver, and measure the impact of DEI.

Sources:
https://www2.deloitte.com/content/dam/insights/articles/6730_TT-Landing-page/DI_2021-Tech-Trends.pdf