Atmosphere:

The Atmosphere Framework contains client and server-side components for building Asynchronous Web Applications. Realtime client-server framework for the JVM, supporting WebSocket and cross-browser fallbacks support. The Atmosphere Framework supports all major Browsers and Servers. The Atmosphere framework is the most popular asynchronous application development framework for enterprise Java.
Atmosphere’s Java Client is called wAsync.

Why to choose Atmosphere Framework?

Based on the requirement we need a framework that supports bi-directional communication so, we have selected Atmosphere Framework. The main advantage is that it provides two-way communication between client and server over a single TCP connection. Generally, a client will send a request to the server then the server returns the response. For every request from the same client to the same server, a new connection needs to be opened. WebSocket will maintain a single connection between the client and the server. It also keeps the connection alive with all it’s clients until they disconnect.

Tomcat Configuration Steps:

Used runtime – native as atmosphere dependency for maven tool and tomcat -v9 as a server

Step 1: Download and Install Tomcat.

Step 2: Create an Environment Variable JAVA_HOME.

Step 3: Configure the Tomcat Server.

Step 4: Start Tomcat Server.

Step 5: Develop and Deploy an App.

Maven Tool:

A maven is a build tool that provides different dependencies. Here dependency means the external libraries required to build a project.

It does the following:

1. Generates source code (if auto-generated code is used).
2. Generates documentation from source code.
3. Compiles source code.
4. Packages compiled code into JAR or ZIP file.
5. Installs the packaged code in a local repository, server repository, or central repository.

How to Broadcast Message from JAVA server to JAVA Client in Atmosphere Framework:

1. Used Atmosphere Framework
2. Used runtime-native as atmosphere dependency for maven tool
3. Tomcat-v9 as a server

Long polling :

 Long polling is the simplest way of having a persistent connection with a server that doesn’t use any specific protocol like WebSocket or Server Side Events. Easy to implement, and delivers messages without delays.

The Flow:

1. A request is sent to the server.
2. The server doesn’t close the connection until it has a message to send.
3. When a message appears – the server responds to the request with it.

Server:

Broadcasting the messages to clients-

BroadcasterFactory.getDefault().lookup(“URL to broadcast”, true).scheduleFixedBroadcast(message, 2, TimeUnit.SECONDS);

Client:

We have used the AsyncHttpProvider library to establish a connection with the Server in async mode.

AtmosphereRequest request = atmosphereResource.getRequest();

String IncomingMessage = request.getReader().readLine();

To use Atmosphere, add the following dependency:

 1.

<dependency>
<groupId>org.atmosphere</groupId>
<artifactId>atmosphere-runtime</artifactId>
<version>2.4.21</version>
</dependency

 2.

<dependency>
<groupId>org.atmosphere</groupId>
<artifactId>atmosphere-spring</artifactId>
<version>2.4.3</version>
</dependency>

Benefits of Atmosphere:

1. Provide High Availability.
2. Scalability.
3. Fault Tolerance.

Conclusion:

The Atmosphere framework makes the development easier to build applications. The Atmosphere Framework is portable and can be deployed to any web server.

Active directory turns 20 this year! 

There is a lot of talk in the community about whether AD is outdated and whether other Cloud-based directory services will replace AD. Before we jump to any conclusion, lets first understand AD in its entirety. 

Active Directory (AD) is a Microsoft’s Directory Service for Windows domain networks. Active Directory handles centralized domain management and directory-based identity-related services. It is a framework on which other services such as Certificate Services, Federated Services deployed.

How does Active Directory work?

Active Directory stores data as objects. An object is an element, which may be user, group, application, or device, such as a printer. Objects are general resources –such as printers or computers — or security principals — such as users or groups.

The server which runs Active Directory Domain Service(AD DS) is called a domain controller. Authenticating and authorizing all users and computers in a Windows domain type network is done by AD DS. When a user login into a computer then the active directory checks the submitted user and password and determines whether the user is a system administrator or user. It manages and stores information, provides authentication and authorization mechanisms, and makes a framework to deploy related services: Certificate Services, Active Directory Federation Services, Lightweight Directory Services, and Rights Management Services.

Active Directory Services :

Following are the services provided by Active Directory :

1. Domain Services – stores information of members such as users, devices, their access rights, and credentials. The server running this service is called a domain controller.

2. Lightweight Directory Services – it is an implementation of LDAP protocol

3. Directory Federation Services – It is a single-sign-on (SSO) service. It may be useful when a user is registered with several web services with the same credentials. So federation services enable us to use the same credentials for different networks.

4. Certificate Services – It creates and validates public key certificates for an organization. We can use these certificates to encrypt files, emails, and network traffic.

5. Rights Management – It provides development and management tools to help organizations to protect information.

AD objects :

The individual component of an organization is called Objects in Active Directory. Active Directory stores data as objects. Following is the list of AD Objects :

• Contact: A contact object is used to store the contact of vendors or suppliers, who are not in the employ of the organization. Only the name of the person and the contact details are stored.
• User: Member of the organization in the AD is denoted by a User. The user contains information about the first name, last name, email address, and associated groups.
• Printer: This object contains information about all the printers in the network
• Computer: This object contains information about all the computers in the network
• Shared folder: This allows users to access folders from other computers on the network that have been marked as shared. Only folders, and not individual files, can be shared. If you want to share an individual file then it should be placed inside a shared folder.
• Group: It is a collection of directory objects. It contains computers, users, other groups, and other AD objects. Group has 2 types
  • Distribution groups – used with emails application to send emails to the collection of users.
  • Security groups– used to assign access to resources on the network

E.g For your organization, if you want to give access to certain documents to only particular departments. Network administrators will create a group containing all members of the department and provide them to access file servers containing that document.

• Organizational units (OUs): OUs help in structuring your network resources in an easy to locate manner. In OU you can place users, printers, computers, groups, and other OUs.Each domain can create its own OUs.
• Builtin: Several user accounts and group accounts are automatically created when you install an active directory for the first time.

Benefits of Active Directory :

Here are some benefits of AD:

• Central Storage– Active Directory provides a centralized storage repository for users’ files. If you save your files on the central server then other users of the domain can access them.
• Better Backup– If a user’s machine is attacked by a cyberattack, all of the files on that machine may become inaccessible. However, if they were saved to a central storage location, it would be easily recovered from central storage.
• Cut Costs– Active Directory is easy to scale up or down.
• Improved Security– As the network administrator has control over the domain in AD, they can implement new security measures when necessary. This can include installing new antivirus software onto each machine, or making sensitive documents inaccessible so they don’t fall into the wrong hands.  

Cloud-based Directory Services:

There have been many new entrants in this space with the likes of Okta, JumpCloud, and others that are providing alternatives to what was the market-leading directory service. Enterprises are more distributed than ever before and applications are being deployed in Cloud making it imperative to have a directory service that can be centrally administered and managed. Microsoft with its Federated AD service in Azure (ADFS) has provided an extension of AD in the cloud. Okta, a pure SaaS service provider,  is another alternative for businesses looking at a cloud based SSO solution. 

Neova has expertise in Active Directory, Azure ADFS, Okta, and JumpCloud and can help organizations integrate their application with one or multiple of these directory service providers.

What is Docker?

Docker is an open-source platform for developing, shipping, and running applications which enables to separate applications from infrastructure, and software that can deliver quickly. Docker provides many benefits such as runtime environment isolation, consistency via code, and portability.

What are Containers?

Containers are the organizational units of Docker. When we build an image and start running it; we are running in a container. The container analogy is used because of the portability of the software we have running in our container. The isolation and security allow you to run many containers simultaneously on a given host. There is no need for an extra load of a hypervisor so containers are lightweight, & it runs directly within the host machine’s kernel. 

Difference between virtual machines and dockers:

Docker Engine

Docker Engine lets  you to develop, assemble, ship, and run application usage of the following components:

1. Docker Daemon

It is a persistent background process that listens for Docker API requests and processes them & manages Docker images, containers, networks, and storage volumes. 

2. Docker Engine REST API

An API utilized by programs to engage with the Docker daemon; it could be accessed with the aid of an HTTP client.

3. Docker CLI

A command-line interface purchaser for interacting with the Docker daemon. It substantially simplifies how you manage container times and is one of the key reasons why developers love the use of Docker.

Docker architecture

• Docker uses a client-server architecture.
• The Docker patron talks to the Docker daemon, which does the heavy lifting of building, running, and dispensing your Docker containers.
• The Docker patron and daemon can run on the same system, or you may join a Docker consumer to a remote Docker daemon.
• The Docker client and daemon talk about the use of a REST API, over UNIX sockets, or a community interface.

1. Docker daemon

A chronic background process that manages Docker images, containers, networks, and storage volumes. The Docker daemon constantly listens for Docker API requests and methods them.

2. Docker client

Docker users can engage with Docker via a client. When any docker commands run, the client sends them to docker daemon, which carries them out. Docker API is used by Docker commands. It is possible for Docker clients to communicate with more than one daemon.

3. Docker registries

A Docker registry stores Docker images. There are public and private registries. Docker has a public registry called Docker hub, where you could also store photos privately.

If you are using Docker Datacenter (DDC), it includes Docker Trusted Registry (DTR).

docker pull or docker run commands, images are pulled from the configured registry. 

docker push command, image is pushed to the configured registry.

Docker objects

While working with Dockers, we use the following Docker objects.

Images

Docker images are read-most effective templates with instructions to create a docker container. Docker images may be pulled from a Docker hub and used or you may add additional instructions to the base image and create a new and modified docker image. Using dockerfile users can create their own docker images.

Containers

Using Docker API or CLI users can create, start, stop, move, or delete a container. Containers are runnable instances of image.

After you run a docker image, it creates a docker container. All the applications and their surroundings run inside this container. Use Docker API or CLI to start, stop, delete a docker container.

Networking

Docker implements networking in an application-driven manner and provides various options even as maintaining enough abstraction for utility developers. There are basically two styles of networks available – the default Docker network and user-described networks. By default, you get 3 specific networks on the set up of Docker – none, bridge, and host.

Storage

Data can store within the writable layer of a container but it requires a storage driver. Being non-persistent, it perishes whenever the container is not running. So it is not easy to transfer this data. Docker supports the following four options for persistent storage:

• Data Volumes
• Data Volume Container
• Directory Mounts
• Storage Plugins

.NET AND DOCKER

Containers offer a lightweight way to isolate your software from the relaxation of the host system, sharing simply the kernel, and the usage of sources given on your software.

Build a .NET Core image

You can build and run a .NET Core-based container image using the following instructions:

docker build --pull -t dotnetapp
docker run --rm dotnetapp Dockers in .Net Core

You can use the docker images command to see a listing of your image, as you can see in the following example.

% docker images dotnetapp

Package an ASP.NET Core app in the container:

To package an ASP.NET Core app in a container, there are 3 steps.

1. Create ASP.NET Core project
2. Write a Dockerfile that will describe how to construct your image
3. Create a container in order to make your image alive or permit the execution of your image like one process.

Create your ASP.NET Core Project

Step 1: Run the following commands in the Command Prompt,

mkdir dockerapp
cd dockerapp
dotnet new webapi

After that, you will have a functional API. To test it, run this command.

dotnet build
dotnet run

Type below address to get the values from ValuesController –

localhost: 5000/api/values

Here we have our WebAPI that returns [“value1”, ”value2”] in JSON.

Step 2: Deployment Environment

Here, we do not need a compiler because we will have to build our application externally from our image, integrate all built files in the image, and just use a lightweight image containing the .NET Core runtime Microsoft/aspnetcore to execute our application.

Copy and paste below instructions in your Dockerfile:

#Development Environment Process 
FROM Microsoft/aspnetcore-build:latest AS build-env 
WORKDIR /app 

#copy csproj and restore distinct layers, make sure that we all dependencies 
COPY *.csproj ./ 
RUN dotnet restore 

#Copy everything else and build the project in the container 
COPY . ./ 
RUN dotnet publish --configuration Release --output dist 

#Deployment Environment Process 
#Build runtime image 
FROM microsoft/aspnetcore:latest 
WORKDIR /app 
COPY --from=build-env /app/dist ./ 
EXPOSE 80/tcp 
ENTRYPOINT [ "dotnet","dockerapp.dll" ] 

Step 3: In command prompt type:

docker build. –t rootandadmin/dockerapp –f Dockerfile

Step 4: Create a Container

Now, we have our image rootandadmin/dockerapp but as this image is not active we should make it alive. For this we need to create a container.

There is a big difference between Image and Container; a container is a process that contains an image and executes it.

To create a container from our image type below command:

docker create command –p 555:80 –name rootandadmin/dockerapp01 rootandadmin/dockerapp

docker start rootandadmin/dockerapp01

Access your API in the browser using the following address:

localhost: 555/api/values

Benefits of containerization

Containers solved an important problem: how to make sure that software runs correctly when it is moved from one computing environment to another.

Agile methodologies are based on frequent and incremental changes in the code versions, such that frequent testing and deployment are required.

DevOps engineers frequently move software from a test environment to a production environment and to ensure that the required resources for provisioning and getting the appropriate deployment model are in place, and also validating and monitoring the performance.

The initial solution for this was Virtualization. Virtualization allows multiple operating systems to be run completely independently on a single machine.

The virtualization Idea is extended using containers. In virtualization, the hypervisor creates and runs multiple instances of an operating system so that multiple operating systems can be run on a single physical machine sharing the hardware resources.

The container model eliminates hypervisors entirely. Instead of hypervisors, containers are essentially applications, and all their dependencies packaged into virtual containers. Each application shares a single instance of the operating system and runs on the “bare metal” of the server. 

Advantages of Container:

1. All the containers share the resources of the single operating system and there is no virtualized hardware. Since the operating system is shared by means of all containers, they’re much more light-weight than traditional virtual machines. It’s possible to host far more containers on a single host than fully-fledged virtual machines.
2. Containers share a single operating system kernel start-up in a few seconds, instead of the minutes required to start-up a virtual machine.
3.  Containers are also very easy to share.

Conclusion

Docker is a mature technology that helps you package your applications. It reduces the time necessary to bring applications to production and simplifies reasoning about them. Furthermore, Docker encourages a deployment style that’s scripted and automatic. As such, it promotes reproducible deployments.

Introduction

Rapidly increasing count of electronic gadgets connected to the internet has given birth to a new IT jargon, Internet-of-things (IoT). It is a system of interconnected computing devices, digital and mechanical machines identified by a unique number/name, and its facility to transfer data over a network without requiring human-to-computer or human-to-human interaction. Therefore, this requirement of improving system integration triggered the development of Message-Brokers, which facilitate the inter-application communication technology to support building a common integration mechanism to support cloud native, microservices-based, serverless and hybrid cloud architectures. 

Why Did Message Brokers emerge?

Can you imagine the existing volume of data for gadgets connected to the internet across the globe? Nowadays, approximately 12 billion Smart-Machines are connected to it. Bearing in mind that currently, around 7 billion people live on this planet, it is almost one-and-a-half devices per person. By the end of this year, this number could presumably surge to 200 billion, or even further. With technological development, like the building of Smart-Houses and other automatic systems, our everyday life becomes more and more digitized.

What is a message broker?

Wikipedia’s formal definition says: “A message broker translates a message from the formal messaging protocol of the sender to the formal messaging protocol of the receiver.” 

Functional features for a message broker

• A message broker is computer software that enables apps, systems, and services to communicate with each other by exchanging information, irrespective of programming languages used to build them up or software/hardware platforms wherein they are deployed.
• Message brokers are software programs deployed in messaging middleware or message-oriented middleware (MOM) solutions.
• Message brokers can validate, store, route, and deliver messages to the intended destinations. This enables decoupling of services and processes within systems.
• Built-in “Message-Queues” hold intact messages until not delivered to intended destinations and ensure message reliability and guaranteed delivery. 
• Message brokers provide queue managers to handle the interactions between multiple message queues, as well as services providing data routing, message translation, persistence, and client state management functionalities.
• Supports Asynchronous messaging, which prevents the loss of valuable data and enables systems to continue functioning even in the face of the intermittent connectivity or latency issues common on public networks. 

Message broker implementation patterns

Message brokers can be configured in two basic message distribution patterns:

• Point-to-point messaging: Each message in the queue is sent to only one recipient and is consumed only once, so it represents a one-to-one relationship between the message’s sender and receiver. Suitable use cases for this messaging pattern include payroll and financial transaction processing. In these systems, both senders and receivers need an assurance that each payment will be sent once and once only.

• Publish/subscribe messaging: Often referred to as “Publisher/Subscriber”, wherein the producer of each message publishes it to a queue, and multiple message consumers subscribe to a queue from which they want to receive messages. All messages published to a queue are distributed to all the applications subscribed to it. It is a broadcast-style distribution method, depicting a one-to-many relationship between the message’s publisher and its consumers. For example, an airline was to circulate updates about the landing times or delay status of its flights, multiple parties could make use of the information: ground crews performing aircraft maintenance and refuelling, baggage handlers, flight attendants and pilots preparing for the plane’s next trip, and the operators of visual displays notifying the public. A pub/sub messaging style would be suitable for this scenario.

Note: Third possible pattern could be – Hybrid of both

Best Message Broker Software Tools

These tools are typically leveraged by IT professionals like system administrators, and software developers. Business organizations use this software to synchronise distributed applications, simplify coding dissimilar applications, improve performance, and automate communication-related tasks. 

A software tool must possess below given to qualify as a Message Broker:

• Facilitate asynchronous messaging
• Store, deliver, and delete messages
• Document communication information
• Allow administrative control over messaging permissions

Major available tools

• RabbitMQ
• Apache Kafka
• IBM MQ
• Apache ActiveMQ

There are numerous message broker software tools available in the market which can be the best candidate for a given factors like Flexible Message Routing and Priority configurations, Message Replay, UI to monitor messages etc. E.g. RabbitMQ is a great fit for Flexible Message Routing and Priority configurations and Kafka is a great choice for message replay. Next, we will explore RabbitMQ as it covers the maximum share in the current market.

RabbitMQ a most widely deployed open source message broker

RabbitMQ is the most popular open-source message broker, having a huge number of production deployments world-wide. It is lightweight, and easy to deploy on-premises and in the cloud and execute on all major operating systems. It supports multiple messaging protocols, maximum developer platforms and can be deployed in distributed and federated configurations to satisfy high-scale, high-availability requirements.

RabbitMQ Features

Asynchronous Messaging

It supports multiple messaging protocols, message queuing, multiple exchange types, delivery acknowledgement, flexible routing to queues.

Developer Experience

It allows developers to deploy with Docker, BOSH, Chef and Puppet. Cross-language messaging with favourite programming languages such as: .NET, Java, PHP, Python, JavaScript, Ruby, and many others.

Distributed Deployment

Offers Clustered deployment for high availability and throughput and federate across multiple availability zones and regions.

Enterprise & Cloud Ready

It supports pluggable authentication, authorisation as well as supports LDAP and TLS. Lightweight and easy to deploy across public and private clouds.

Tools & Plugins

Variety of plugins and tools supporting continuous integration, operational metrics, and integration with other enterprise systems. Flexible plug-in approach for extending its functionality.

Management & Monitoring

It supports HTTP-API, command line tool, and UI for managing and monitoring itself.

.NET Libraries for RabbitMQ

Below are given two client libraries which help to integrate .NET applications with RabbitMQ very easily.

• RabbitMQ .NET Client (supports .NET Core and .NET 4.5.1+)
• RawRabbit, a higher-level client that targets ASP.NET next and supports .NET Core.

Note: Here in, I will be covering only RawRabbit by highlighting its core features and providing essential code snippets.

RawRabbit

It is a modern .NET framework for communication over RabbitMQ. The modular design and middleware-oriented architecture makes the client highly customizable while providing workable default for topology, routing and more.

Easily Configurable and extendable

RawRabbit can be easily configured with RawRabbitOptions, an option specifying object which allows registering client configuration, plugins, and permits overriding internal services.

var client = RawRabbitFactory.CreateSingleton(new RawRabbitOptions
{
ClientConfiguration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("rawrabbit.json")
.Build()
.Get<RawRabbitConfiguration>(),
Plugins = plugin => plugin
.UseProtobuf()
.UsePolly(config => config
.UsePolicy(queueBindPolicy, PolicyKeys.QueueBind)
.UsePolicy(queueDeclarePolicy, PolicyKeys.QueueDeclare)
.UsePolicy(exchangeDeclarePolicy, PolicyKeys.ExchangeDeclare)
),
DependencyInjection = ioc => ioc
.AddSingleton<IChannelFactory, CustomChannelFactory>()
});

Configuring Publish/Subscribe

Just a few lines of code and you can set up strongly typed publish/subscribe.

var rawClient = RawRabbitFactory.CreateSingleton();
await rawClient.SubscribeAsync<BasicMessage>(async message =>
{
Console.WriteLine($"Received: { message.Prop}.");
});

await rawClient.PublishAsync(new BasicMessage { Prop = "Hello, world!"});

Configuring Request/Response

RawRabbit’s (RPC) request/response configuration uses the direct reply-to feature for better performance and lower resource allocation.

var rawClient = RawRabbitFactory.CreateSingleton();
rawClient.RespondAsync<BasicRequest, BasicResponse>(async request =>
{
return new BasicResponse();
});
var rawResponse = await client.RequestAsync<BasicRequest, BasicResponse>();

Configuring Ack, Nack, Reject and Retry

Unlike many other clients, basic.ack, basic.nack and basic.reject are first class citizens in the message handling.

var client = RawRabbitFactory.CreateSingleton();
await client.SubscribeAsync<BasicMessage>(async message =>
{
if(UnableToProcessMessage(message))
{
return new Nack(requeue: true);
}
ProcessMessage(message)
return new Ack();
});

In addition to the essential acknowledgements, RawRabbit also supports delayed retries

var client = RawRabbitFactory.CreateSingleton();
await client.SubscribeAsync<BasicMessage>(async message =>
{
try
{
ProcessMessage(message)
return new Ack();
}
catch (Exception e)
{
return Retry.In(TimeSpan.FromSeconds(30));
}
});

Granular control over each call

Allow users to add or change properties in the IPipeContext to adapt calls for specific types of messages. This makes it possible to modify the topology features for calls, publish confirm timeout, consumer concurrency.

await subscriber.SubscribeAsync<BasicMessage>(received =>
{
receivedTcs.TrySetResult(received);
return Task.FromResult(true);
}, context => context
.UseSubscribeConfiguration(config => config
.Consume(consume => consume
.WithRoutingKey("CustomKey")
.WithConsumerTag("CustomTag")
.WithPrefetchCount(2)
.WithNoLocal(false))
.FromDeclaredQueue(queue => queue
.WithName("CustomQueue")
.WithAutoDelete()
.WithArgument(QueueArgument.DeadLetterExchange, "dlx"))
.OnDeclaredExchange(exchange=> exchange
.WithName("CustomExchange")
.WithType(ExchangeType.Topic))
));

Conclusion

Neova Solutions Pvt Ltd has the expertise to integrate Message Broker Software, like Kafka, RabbitMQ, into business applications to meet high-scale, high-availability requirements.