Netty from the trenches

Netty
from the trenches
June 2015
@jordi9

Netty is an
asynchronous
event-driven
network
application
framework

for rapid
development of
maintainable high
performance
protocol servers &
clients.

Netty is a NIO
client server
framework which
enables quick and
easy development
of network

applications such
as protocol servers
and clients. It
greatly simplifies
and streamlines
network

network
programming such
as TCP and UDP
socket server.

You’ve heard of:
Event driven
frameworks

You’ve heard of:
non-blocking
operations

You’ve heard of:
Node is
cooler
because...

I/O, approx:
CPU
Memory
Device

read()
//wait...
keepWorkingBro()

You know what
I’m talking
about

Webserver
Request
Database
//wait...

Webserver
Request
Database
//wait...
Request
Database
//wait...

Webserver
Request
Database
//wait...
Request
Database
//wait...
Request
Database
//wait.

read()
keepWorkingBro()
//I’m
//done!

You (kinda) did this:
Listeners

Guava’s
EventBus

Javascript
callbacks

Hollywood principle
“Don’t call us,
we’ll call you”

Keep working,
instead of
waiting

Dependecy-haters:
Just
JDK 1.6+

Maybe, you’re
trying to
implement a
protocol

Netty:
Tool to
implement network
applications

Netty:
Both from server
and client side

Netty has been
designed carefully
with the
experiences
earned from the
implementation of

a lot of protocols
such as FTP,
SMTP, HTTP, and
various binary and
text-based legacy
protocols. As a

protocols. As a
result, Netty has
succeeded to find
a way to achieve...

“Implementing
a protocol”
NOT THAT HARD

Most common
protocols:
out-of-the-box

Downers:
Constant API
changes*

Downers:
Constant API
changes*
*For the best

Downers:
Learning
curve...
Buy Netty in Action :P

Downers:
Join the
mailing list

Downers:
Join the
mailing list
You’ll see how
STUPID you are

Downers:
Join the
mailing list
But you’ll learn ALOT ;)

class SimpleDaytimeHandler extends
ChannelInboundHandlerAdapter {
}
The Hand e

// Handler = Business Logic
}
The Hand e

// ChannelHandler: handles operations
// for that Channel, duh
}
The Hand e

// Inbound handler: incoming traffic,
// dispatch events to next handler
// If we have inbound...
}
The Hand e

// Outbound handler: same, but the
// other direction. Yeah, there’s some
// flow between Handlers (eg: Pipeline)
}
The Hand e

// Inbound + Outbound...
}
The Hand e

// Inbound + Outbound..
// 5.0: DEPRECATED!
// [NOTE: Insert a grumpy cat here]
}
The Hand e

@Override
public void channelRead(
ChannelHandlerContext ctx, Object msg) {
// Will trigger when we receive
// some data
}
Hand e me hod

@Override
public void channelActive(
ChannelHandlerContext ctx, Object msg) {
// Will a Channel is opened, this
// method will be called
}
Hand e me hod

@Override
public void channelActive(ChannelHandlerContext ctx, Object msg) {
String date = DATE_TIME.print(new DateTime());
// Get the date
}
Hand e wo

@Override
ctx.writeAndFlush(ByteBufUtil.encodeString(
ctx.alloc(), CharBuffer.wrap(date),
CharsetUtil.US_ASCII));
}
Hand e wo

Network
standard way of
working?
byte[]

@Override
// We need to encode the String
}
Hand e wo

@Override
// We allocate some space
// +Netty: Keeps internal pools
}
Hand e wo

@Override
// Write the message
// Request to actually flush the data
// back to the Channel
}
Hand e wo

Ma n ass
public class DaytimeServer {
void run() throws Exception {
// fun stuff
}
public static void main(String[] args) throws Exception {
DaytimeServer daytimeServer = new DaytimeServer();
daytimeServer.run();
}
}

java -jar daytimeserver-fat.jar

un()
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();

E en LoopG oup
Netty’s way to
handle threads

E en LoopG oup
EventLoopGroup
contains some
EventLoops

E en Loop
EventLoop
handles many
Channels

E en LoopG oup
E en Loop
hanne
hanne
hanne
hanne
hanne hanne
hanne
hanne
hanne
hanne
hanne hanne
E en Loop

This immutable
assignment is
the key

un()
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
// Boss group accepts connections
// Work group handles the work

Se e Boo s ap
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.localAddress(8080)
.option(ChannelOption.SO_BACKLOG, 100)

Se e Boo s ap
.localAddress(8080)
// We assign both event loops

Se e Boo s ap
.localAddress(8080)
// We use a ServerSocketChannel
// to accept TCP/IP connections
// as the RFC says

Se e Boo s ap
.localAddress(8080)
// Simply bind the local address

Se e Boo s ap
.localAddress(8080)
// Set some Socket options... why not?
// Just remember: This is not handled
// by Netty or the JVM, it’s the OS

hanne P pe ne
b.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch)
throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(new SimpleDaytimeHandler());
}
});

hanne P pe ne
@Override
throws Exception {
}
});
// ChannelPipeline to define your
// application workflow

hanne P pe ne
@Override
throws Exception {
}
});
// Append our handlers
// ProTip: use LoggingHandler to
// understand Netty

hanne P pe ne
@Override
throws Exception {
}
});
// Finally, we add our handler

RUN!
@Override
throws Exception {
}
});
ChannelFuture f = b.bind().sync();
f.channel().closeFuture().sync();
// It works!

.I.A.
Futures
ByteBuf API
Codecs
Transports
Zero-file-copy

We can also
create
client code

We’re using Netty for
Real-Time Bidding

Don’t be afraid
of “low-level”

Integrate things
you love. In my
case: GUICE

Gu e
@Inject
DaytimeService(Provider<DaytimeServer> daytimeProvider) {}
b.childHandler(() → {
p.addLast(daytimeProvider.get());
});
// Inject a Provider<T> and get
// instances

* Without network latency
2ms*

Yah but… what
volume are you
talking about?

1 node*
+3k QPS
*Fou 2.79GHz In e Pen um Xeon P o esso s, 7.5GB RAM

Parse example
http://blog.parse.com/learn/how-we-moved-our-api-from-ruby-to-go-and-saved-our-sanity/
(From Ruby to Go) A year and a
half in, at the end of 2012, we had
200 API servers running on m1.
xlarge instance types with 24
unicorn workers per instance. This
was to serve 3000 requests per
second for 60,000 mobile apps

We have 16 nodes!
4x Netty nodes
10x Kafka, DNS, the
usual suspects…

I KNOW IT’S
NOT FAIR,
but it’s good stuff
for your ego BRO

Lovely ecosystem
like Ratpack,
or users,
with vert.x or akka

It will change the
way you program
some of your apps

(It’s 5:00 in the
morning and I had
to say it)

(did you notice the
“Apple
background”?)

JUST KIDDING
It doesn’ really
matter!

Q & A
#HiddenTrovitTrac@jordi9

Netty from the trenches

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Netty from the trenches

Similar to Netty from the trenches (20)

More from Jordi Gerona

More from Jordi Gerona (7)

Recently uploaded

Recently uploaded (20)

Netty from the trenches

Editor's Notes