Миллион WebSocket и pub/sub / Сергей Камардин (MailRu Group)

Миллион WebSocket
и pub/sub
Сергей Камардин, MailRu Group.

Состояние и события

Состояние и события
• Состояние – любая хранимая информация программы.
• Событие – информация об изменении состояния.

Скорость реакции на событие, как и ее
отсутствие, имеет свою цену.

Состояние в почте
Какая информация является состоянием в любом почтовом
сервисе?
• письма в ящике
• пометки о прочтении
• срок жизни сессии
• …

События в почте
Как пользователь узнает об изменении ящика?
HTTP polling каждые 2 минуты:

• 3 миллиона запросов в минуту

• 50 тысяч запросов в секунду

• 50 тысяч запросов в секунду
• 60% ответов - 304 Not Modified

План
Хочется, чтобы сервер сам посылал сообщение о том, что его
состояние изменилось.

Publisher/Subscriber
Способ реагирования на изменение состояния при помощи
шины событий.
• Издатель отправляет множество событий в шину.
• Подписчик интересуется подмножеством событий из шины.

Как было
+-----------+ +-----------+ +-----------+
| | | | ◄-------+ | |
| Storage | | API | HTTP | Browser |
| | | | | |
+-----------+ +-----------+ +-----------+

Как было
+-----------+ +-----------+ +-----------+
| | ◄-------+ | | ◄-------+ | |
| | | | | |
+-----------+ +-----------+ +-----------+

Как было
+-----------+ +-----------+ +-----------+
| | ◄-------+ | | ◄-------+ | |
| | +-------► | | | |
+-----------+ +-----------+ +-----------+

Как было
+-----------+ +-----------+ +-----------+
| | ◄-------+ | | ◄-------+ | |
| | +-------► | | +-------► | |
+-----------+ +-----------+ +-----------+

План
+-------------+ +---------+ +-----------+
+-------------+ +---------+ +-----------+
+---------------------------------+
| Bus |
+---------------------------------+

План
+-------------+ +---------+ WebSocket +-----------+
| Storage | | API | ○-----------○ | Browser |
+-------------+ +---------+ +-----------+
+---------------------------------+
| Bus |
+---------------------------------+

План
+-------------+ +---------+ WebSocket +-----------+
| Storage | | API | ◄-----------○ | Browser |
+-------------+ +---------+ +-----------+
+---------------------------------+
| Bus |
+---------------------------------+

План
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
+---------------------------------+
| Bus |
+---------------------------------+
*

План
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
|
|
▼
+---------------------------------+
| Bus |
+---------------------------------+
*

План
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
+---------------------------------+
| Bus |
+---------------------------------+
*
*

План
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
|
|
▼
+---------------------------------+
| Bus |
+---------------------------------+
*
*

План
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
▲
|
|
+---------------------------------+
| Bus |
+---------------------------------+
*
*

План
+-------------+ +---------+ WebSocket +-----------+
| Storage | | API | ○-----------► | Browser |
+-------------+ +---------+ +-----------+
+---------------------------------+
| Bus |
+---------------------------------+
*
*

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ +-----------+
+-------------+ +---------+ +-----------+
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
| Storage | | API | ◄-----------○ | Browser |
+-------------+ +---------+ +-----------+
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
|
|
▼
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
|
+------+
▼
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*
*

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
|
+------------------+
▼
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*
**

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*
***

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
|
+--------+
▼
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*
***

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
▲
+------+
|
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*
***

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
| Storage | | API | ○-----------► | Browser |
+-------------+ +---------+ +-----------+
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*
***

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
|
+--------------------+
▼
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*
***

План
+-------------+ +---------+
| Storage | | API |
+-------------+ +---------+
+-------------+ +---------+ WebSocket +-----------+
+-------------+ +---------+ +-----------+
▲
|
|
+---------+ +---------+ +---------+
| Bus | | Bus | | Bus |
+---------+ +---------+ +---------+
*
***

Маршрутизация
Стратегии:
• flooding

Стратегии:
• flooding
• gossiping

Стратегии:
• flooding
• gossiping } Много трафика, большая задержка

Стратегии:
• flooding
• gossiping
• filtering
} Много трафика, большая задержка

Маршрутизация событий
Filtering можно сделать по-разному
• с помощью таблиц и деревьев в памяти
• можно не париться и взять подходящую базу данных
• издатели публикуют полный набор параметров
• подписчики подписываются на любой набор параметров

Как применяем фильтры?
• издатели публикуют полный набор параметров
• подписчики подписываются на любой набор параметров

└──*──[ 1 ]
│
├──Email
│ │
│ └──"bus@mail.ru"──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]

└──*──[ 1 ]
│
├──Email
│ │
│ └──"bus@mail.ru"──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]
[ ]
storage:change { email: "bus@mail.ru" }

└──*──[ 1 ]
│
├──Email
│ │
│ └──”bus@mail.ru”──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]
[ ]

└──*──[ 1 ]
│
├──Email
│ │
│ └──”bus@mail.ru”──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]
[ 1 ]

└──*──[ 1 ]
│
├──Email
│ │
│ └──"bus@mail.ru"──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]
[ 1 ]

└──*──[ 1 ]
│
├──Email
│ │
│ └──"bus@mail.ru"──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]
[ 1, 8 ]

└──*──[ 1 ]
│
├──Email
│ │
│ └──"bus@mail.ru"──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]
[ 1, 8, 2 ]

└──*──[ 1 ]
│
├──Email
│ │
│ └──"bus@mail.ru"──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]
[ 1, 8, 2, 3, 7 ]

└──*──[ 1 ]
│
├──Email
│ │
│ └──"bus@mail.ru"──[ 8 ]
│
└──Publisher
│
└──"storage"──[ 2 ]
│
└──Event
│
└──"change"──[ 3, 7 ]
│
└──Email
├──"bus@mail.ru"──[ 4 ]
└──"bar@mail.ru"──[ 5 ]
[ 1, 8, 2, 3, 7, 4 ]

[ 1, 8, 2, 3, 7, 4 ]

WebSocket
Бинарный двухсторонний протокол общения между браузером
и сервером.
• Стандартизован в 2011г. как RFC6455.
• Поддерживается всеми современными браузерами.

WebSocket
Использует HTTP для Upgrade.
После оперирует «фреймами» внутри соединения:
• Контрольные: ping, pong, close
• Пользовательские: text, binary

WebSocket
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| |Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+

0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| |Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
WebSocket

WebSocket
Браузеры по-разному реализуют RFC6455.
• Chrome не дожидается ответного Close фрейма и сразу
закрывает соединение

WebSocket
Браузеры по-разному реализуют RFC6455.
• Firefox периодически посылает Ping фреймы, ожидая в
ответ Pong

WebSocket
Браузеры по-разному реализуют RFC6455:
• Firefox периодически посылает Ping фреймы, ожидая в
ответ Pong
• IE периодически посылает.. Pong фреймы (но это не
противоречит спецификации)

Трудности
• 3 миллиона «живых» соединений
• время жизни соединения от нескольких секунд до
нескольких дней
• при разрыве соединений клиенты (браузер)
переподключаются

Go
• Компилируемый, со строгой статической типизацией
• Только структуры и интерфейсы
• Управление памятью с помощью сборщика мусора
• Каналы и «горутины» для конкурентного программирования

Idiomatic реализация

Go net.Conn
package "net"
type Conn interface {
Read(b []byte) (n int, err error)
Write(b []byte) (n int, err error)
...
}

WebSocket Channel
type Channel struct {
conn net.Conn
}

WebSocket Channel
conn net.Conn
out chan Packet // Output packet queue.
}

WebSocket Channel
conn net.Conn
out chan Packet
}
func NewChannel(conn net.Conn) *Channel {
c := &Channel{...}
}

WebSocket Channel
conn net.Conn
out chan Packet
}
c := &Channel{...}
go c.reader()
}

WebSocket Channel
conn net.Conn
out chan Packet
}
c := &Channel{...}
go c.reader()
go c.writer()
}

conn net.Conn
out chan Packet
}
c := &Channel{...}
go c.reader() // stack size += 4KB
go c.writer()
}
WebSocket Channel

conn net.Conn
out chan Packet
}
c := &Channel{...}
go c.reader() // stack size += 4KB
go c.writer() // stack size += 4KB
}
WebSocket Channel

24GB(4KB + 4KB) * 3M
WebSocket Channel

WebSocket Channel
func (c *Channel) reader() {
}

WebSocket Channel
buf := bufio.NewReader(c.conn)
}

WebSocket Channel
buf := bufio.NewReader(c.conn) // heap size += 4KB
}

WebSocket Channel
for {
}
}

WebSocket Channel
for {
buf.Read()
}
}

WebSocket Channel
for {
buf.Read() // wait incoming bytes
}
}

WebSocket Channel
func (c *Channel) writer() {
}

WebSocket Channel
buf := bufio.NewWriter(c.conn)
}

WebSocket Channel
buf := bufio.NewWriter(c.conn) // heap size += 4KB
}

WebSocket Channel
for packet := range c.out {
}
}

WebSocket Channel
for packet := range c.out {
buf.Write(...)
}
}

for packet := range c.out { // wait outgoing packets
buf.Write(...)
}
}
WebSocket Channel

48GB(4KB + 4KB) * 3M
(4KB + 4KB) * 3M
WebSocket Channel

WebSocket Channel
import "net/http"
http.HandleFunc("/ws",
)

WebSocket Channel
import "net/http"
func(w http.ResponseWriter, r *http.Request) {
},
)

WebSocket Channel
import “net/http"
// response write buffer; heap size += 4KB
// request read buffer; heap size += 4KB
},
)

WebSocket Channel
import “net/http"
},
)

WebSocket Channel
import "net/http"
import "some/websocket"
// Upgrade HTTP conn to WebSocket somehow.
conn := websocket.Upgrade(r, w)
},
)

72GB(4KB + 4KB) * 3M
(4KB + 4KB) * 3M
(4KB + 4KB) * 3M
WebSocket Channel

epoll
epoll - I/O event notification facility (c) man epoll.

Как работает go runtime?
for {
conn.Read() // wait incoming bytes
}
}

func read(c *conn, p []byte) (int, error) {
}

n, err := syscall.Read(c.fd, p)
}

if err.IsTemp() {
}
}

if err.IsTemp() {
// EAGAIN || EWOULDBLOCK
}
}

if err.IsTemp() {
pollWait(c.descriptor, 'r')
}
}

• сокеты в Go неблокирующие
• runtime_pollWait на Linux реализован с помощью Epoll
• почему бы не использовать похожий подход?

epoll
ch := NewChannel(conn)
epoll.Add(conn, func() {
})

epoll
// EPOLLIN | EPOLLONESHOT
})

epoll
epoll.Resume(conn)
})

epoll
epoll.Resume(conn)
})
func Receive(ch *Channel) {
}

epoll
epoll.Resume(conn)
})
buf := bufio.NewReader(ch.conn)
buf.Read()
}

epoll
Receive(ch)
epoll.Resume(conn)
})
buf := bufio.NewReader(ch.conn)
buf.Read()
}

Запись
С отправкой пакетов дело обстоит проще – мы всегда знаем,
когда хотим что-то записать в соединение.
Единственный сложный момент – синхронизация записи из
разных горутин.

Запись
func (ch *Channel) Send(p Packet) {
}

Запись
if notSpawnedYet {
}
}

Запись
if notSpawnedYet {
go ch.writer()
}
}

Запись
if notSpawnedYet {
go ch.writer()
}
ch.out <- p
}

-48GB(4KB + 4KB) * 3M
(4KB + 4KB) * 3M

Контроль ресурсов

Контроль ресурсов
Что, если вдруг все соединения решат отправить нам
сообщение?
Тогда реализация с epoll ничем не будет отличаться от
изначальной idiomatic реализации.

Goroutine pool
p := pool.New(128)
pool.Schedule(func() {
// Do some work.
})
pool.ScheduleTimeout(time.Second, func() {
// Do some work or return error.
})

Goroutine pool
Receive(ch)
epoll.Resume(conn)
})

Goroutine pool
p := pool.New(128)
pool.Schedule(func() {
Receive(ch)
})
epoll.Resume(conn)
})

Запись
p := pool.New(128)
if notSpawnedYet {
p.Schedule(ch.writer)
}
ch.out <- p
}

Zero-copy upgrade
GET /ws HTTP/1.1
Host: mail.ru
Connection: Upgrade
Sec-Websocket-Key: A3xNe7sEB9HixkmBhVrYaA==
Sec-Websocket-Version: 13
Upgrade: websocket
HTTP/1.1 101 Switching Protocols
Connection: Upgrade
Sec-Websocket-Accept: ksu0wXWG+YmkVx+KQR2agP0cQn4=
Upgrade: websocket

Zero-copy upgrade
import "net/http"
import "some/websocket"
conn := websocket.Upgrade(r, w)
},
)

Zero-copy upgrade
import "net"
ln := net.Listen("tcp", ":8080")
for {
conn := ln.Accept()
}

Zero-copy upgrade
import "net"
for {
conn := ln.Accept()
// How to upgrade raw bytes?
}

Время запилить свою либу
В Go существуют две реализации WebSocket.
И обе они не позволяют полностью контролировать работу с
аллокацией памяти.
Поэтому пришлось реализовать RFC6455 с более
низкоуровневым API.

github.com/gobwas/ws
• работает с io.Reader, io.Writer
• умеет zero-copy upgrade
• позволяет кешировать фреймы
• проходит autobahn test suite

Zero-copy upgrade
BenchmarkUpgradeHTTP 5156 ns/op 8576 B/op 9 allocs/op
BenchmarkUpgradeTCP 973 ns/op 0 B/op 0 allocs/op
В случае простого Upgrade без сохранения значений заголовков.
Код бенчмарков: http://bit.ly/2svISpr.

Все вместе
При использовании goroutine pool можно вообще не
принимать соединения, если ресурсов больше нет.
Это решает многие проблемы DDOS в случае нештатных
ситуаций.

import "net"
import "github.com/gobwas/ws"
for {
}

import "net"
for {
err := pool.ScheduleTimeout(
)
}

import "net"
for {
time.Millisecond,
func() {
},
)
}

import "net"
for {
time.Millisecond,
func() {
conn := ln.Accept()
ws.UpgradeConn(conn)
},
)
}

import "net"
for {
time.Millisecond,
func() {
conn := ln.Accept()
},
)
if err != nil {
}
}

import "net"
for {
time.Millisecond,
func() {
conn := ln.Accept()
},
)
if err != nil {
time.Sleep(time.Millisecond)
}
}

Все вместе
• При большом количестве бездействующих соединений
лучше использовать epoll и отказаться от читающей
горутины
• При большом количестве соединений отказаться от
пишущей горутины
• Goroutine pool позволяет зафиксировать количество
максимально потребляемой памяти
• Goroutine pool позволяет ограничить количество
обрабатываемых соединений

Итого
Событийная модель позволяет:
• реализовать действительно интерактивный сервис
• предлагать пользователям множество дополнительных
функций
• снизить сопряженность сервисов и упростить
взаимодействие

Цифры
• 3 миллиона “живых” соединений
• 30 тысяч уведомлений в секунду от storage
• 9 тысяч из которых доходят до пользователей ежесекундно
• 75 тысяч событий EPOLLIN (доступность для чтения) в
секунду
• 1 тысяча Upgrade запросов в секунду
• в ходе оптимизаций количество памяти на одно соединение
сократилось с 60KB до 10KB (и это не все!)

github.com/gobwas/ws
github.com/gobwas/httphead
Сергей Камардин
MailRu Group
s.kamardin@corp.mail.ru
Спасибо!

Миллион WebSocket и pub/sub / Сергей Камардин (MailRu Group)

Recomendados

Recomendados

Mais conteúdo relacionado

Mais de Ontico

Mais de Ontico (20)

Миллион WebSocket и pub/sub / Сергей Камардин (MailRu Group)