3 research outputs found
Supporting Massive Mobility with stream processing software
The goal of this project is to design a solution for massive mobility using LISP protocol
and scalable database systems like Apache Kafka. The project consists of three steps:
rst, understanding the requirements of the massive mobility scenario; second, designing
a solution based on a stream processing software that integrates with OOR (open-source
LISP implementation). Third, building a prototype with OOR and a stream processing
software (or a similar technology) and evaluating its performance.
Our objectives are: Understand the requirements in an environment for massive mo-
bility;Learn and evaluate the architecture of Apache Kafka and similar broker messages
to see if these tools could satisfy the requirements; Propose an architecture for massive
mobility using protocol LISP and Kafka as mapping system, and nally; Evaluate the
performance of Apache Kafka using such architecture.
In chapters 3 and 4 we will provide a summary of LISP protocol, Apache Kafka and
other message brokers. On these chapters we describe the components of these tools and
how we can use such components to achieve our objective. We will be evaluating the
di erent mechanisms to 1) authenticate users, 2) access control list, 3) protocols to assure
the delivery of the message, 4)integrity and 5)communication patterns. Because we are
interested only in the last message of the queue, it is very important that the broker
message provides a capability to obtain this message.
Regarding the proposed architecture, we will see how we adapted Kafka to store the
information managed by the mapping system in LISP. The EID in LISP will be repre-
sented by topics in Apache Kafka., It will use the pattern publish-subscribe to spread the
noti cation between all the subscribers. xTRs or Mobile devices will be able to play the
role of Consumers and Publisher of the message brokers. Every topic will use only one
partition and every subscriber will have its own consumer group to avoid competition to
consume the messages.
Finally we evaluate the performance of Apache Kafka. As we will see, Kafka escalates
in a Linear way in the following cases: number of packets in the network in relation with
the number of topics, number of packets in the network in relation with the number of
subscribers, number of opened les by the server in relation with the number of topics
time elapsed between the moment when publisher sends a message and subscriber receives
it, regarding to the number of topics.
In the conclusion we explain which objectives were achieved and why there are some
challenges to be faced by kafka especially in two points: 1) we need only the last location
(message) stored in the broker since Kafka does not provide an out of the box mechanism
to obtain such messages, and 2) the amount of opened les that have to be managed
simultaneously by the server. More study is required to compare the performance of
Kafka against other tools