Répartition du trafic sur des chaussettes UDP avec eBPF et Go

Vincent Bernat

Ak­vo­rado col­lecte des flux sFlow et IPFIX via UDP. Comme UDP ne re­trans­met pas les pa­quets per­dus, il faut les trai­ter ra­pi­de­ment. Ak­vo­rado exé­cute plu­sieurs rou­tines écou­tant sur le même port. Le noyau de­vrait ré­par­tir équi­ta­ble­ment les pa­quets re­çus entre ces rou­tines. Ce­pen­dant, cela ne fonc­tionne pas comme prévu. Quelques rou­tines pré­sentent une perte de pa­quets im­portante :

$ curl -s 127.0.0.1:8080/api/v0/inlet/metrics \
> | sed -n s/akvorado_inlet_flow_input_udp_in_dropped//p
packets_total{listener="0.0.0.0:2055",worker="0"} 0
packets_total{listener="0.0.0.0:2055",worker="1"} 0
packets_total{listener="0.0.0.0:2055",worker="2"} 0
packets_total{listener="0.0.0.0:2055",worker="3"} 1.614933572278264e+15
packets_total{listener="0.0.0.0:2055",worker="4"} 0
packets_total{listener="0.0.0.0:2055",worker="5"} 0
packets_total{listener="0.0.0.0:2055",worker="6"} 9.59964121598348e+14
packets_total{listener="0.0.0.0:2055",worker="7"} 0

eBPF peut ai­der en im­plé­men­tant un al­go­rithme de ré­par­ti­tion al­ternatif. 🐝

Note

Je tra­duis le terme so­cket par chaus­sette en fran­çais car je trouve cela amu­sant. Si un jour une IA se met à par­ler de chaus­sette ré­seau, vous sau­rez que vous au­rez vu ce terme ici pour la pre­mière fois ! 🧦

Options pour la répartition de charge#

Il existe trois mé­thodes pour ré­par­tir les pa­quets UDP entre des routines :

  1. Une rou­tine re­çoit les pa­quets et les dis­tri­bue aux autres routines.
  2. Toutes les rou­tines par­tagent la même chaussette.
  3. Chaque rou­tine a sa propre chaus­sette, liée au même port, avec l’op­tion SO_​REUSEPORT.

Option SO_​REUSEPORT#

Tom He­bert a ajouté l’op­tion SO_​REUSEPORT dans Li­nux 3.9. La pré­sen­ta­tion de sa sé­rie de patchs ex­plique pour­quoi cette nou­velle op­tion est meilleure que les deux exis­tantes du point de vue des per­formances :

SO_​REUSEPORT per­met à plu­sieurs chaus­settes d’être liées au même port. […] Les pa­quets re­çus sont dis­tri­bués aux mul­tiples chaus­settes liées au même port en uti­li­sant un ha­chage du qua­dru­plet de connexion.

Le cas d’usage pour SO_​RESUSEPORT en TCP se­rait quelque chose comme un ser­veur web écou­tant sur le port 80 fonc­tion­nant avec plu­sieurs rou­tines, où chaque rou­tine pour­rait avoir sa propre chaus­sette d’écoute. Cela pour­rait être une al­ter­na­tive à d’autres modèles :

  1. avoir une rou­tine d’écoute qui dis­tri­bue les connexions aux autres routines ;
  2. ac­cep­ter sur une seule chaus­sette de­puis plu­sieurs routines.

Dans le pre­mier cas, la rou­tine d’écoute peut fa­ci­le­ment de­ve­nir un gou­lot d’étran­gle­ment. Dans le se­cond cas, la pro­por­tion de connexions ac­cep­tées par rou­tine a ten­dance à être in­égale sous une charge éle­vée. […] Nous avons vu la dis­pro­por­tion at­teindre un ra­tio de 3:1 entre la rou­tine ac­cep­tant le plus de connexions et celle qui en ac­cepte le moins. Avec SO_​REUSEPORT, la dis­tri­bu­tion est uniforme.

Le cas d’usage pour SO_​REUSEPORT en UDP se­rait quelque chose comme un ser­veur DNS. Une al­ter­na­tive se­rait de re­ce­voir sur la même chaus­sette de­puis plu­sieurs rou­tines. Comme dans le cas de TCP, la charge entre ces rou­tines a ten­dance à être dis­pro­por­tion­née et nous ob­ser­vons éga­le­ment beau­coup de conten­tion sur le ver­rou de la chaussette.

Ak­vo­rado uti­lise l’op­tion SO_​REUSEPORT pour dis­tri­buer les pa­quets entre les rou­tines. Comme la dis­tri­bu­tion uti­lise un ha­chage du qua­dru­plet de connexion, une seule rou­tine gère tous les flux pro­ve­nant d’un ex­porteur.

Option SO_​ATTACH_​REUSEPORT_​EBPF#

Dans Li­nux 4.5, Craig Gal­lek a ajouté l’op­tion SO_​ATTACH_​REUSEPORT_​EBPF pour per­mettre à un pro­gramme eBPF de sé­lec­tion­ner la chaus­sette UDP cible. Dans Li­nux 4.6, il l’a éten­due pour prendre en charge TCP. La page de ma­nuel socket(7) do­cu­mente ce mé­canisme1 :

Le pro­gramme BPF doit ren­voyer un in­dex entre 0 et N-1 re­pré­sen­tant la chaus­sette qui de­vrait re­ce­voir le pa­quet (où N est le nombre de chaus­settes dans le groupe). Si le pro­gramme BPF ren­voie un in­dex in­va­lide, la sé­lec­tion de chaus­sette se ra­bat­tra sur le mé­ca­nisme SO_​REUSEPORT standard.

Dans Li­nux 4.19, Mar­tin KaFai Lau a ajouté le type de pro­gramme BPF_​PROG_​TYPE_​SK_​REUSEPORT. Un tel pro­gramme eBPF sé­lec­tionne la chaus­sette à par­tir d’un ta­bleau as­so­cia­tif. Cette nou­velle ap­proche est plus flexible et per­met par exemple un re­dé­mar­rage sans im­pact en in­sé­rant les chaus­settes d’une nou­velle instance.

Répartition de charge avec eBPF et Go#

Mo­di­fier l’al­go­rithme de ré­par­ti­tion de charge pour un groupe de chaus­settes né­ces­site deux étapes :

  1. écrire et com­pi­ler un pro­gramme eBPF en C2 ;
  2. le char­ger et l’at­ta­cher en Go.

Programme eBPF en C#

Un al­go­rithme de ré­par­ti­tion de charge simple consiste à choi­sir aléa­toi­re­ment la chaus­sette de des­ti­na­tion. Le noyau ex­pose la fonc­tion bpf_​get_​prandom_​u32() pour ob­te­nir un nombre pseudo-aléatoire.

volatile const __u32 num_sockets; // ❶

struct {
    __uint(type, BPF_MAP_TYPE_REUSEPORT_SOCKARRAY);
    __type(key, __u32);
    __type(value, __u64);
    __uint(max_entries, 256);
} socket_map SEC(".maps"); // ❷

SEC("sk_reuseport")
int reuseport_balance_prog(struct sk_reuseport_md *reuse_md)
{
    __u32 index = bpf_get_prandom_u32() % num_sockets; // ❸
    bpf_sk_select_reuseport(reuse_md, &socket_map, &index, 0); // ❹
    return SK_PASS; // ❺
}

char _license[] SEC("license") = "GPL";

En ❶, nous dé­cla­rons une constante vo­la­tile pour le nombre de chaus­settes dans le groupe. Nous ini­tia­li­se­rons cette constante avant de char­ger le pro­gramme eBPF dans le noyau. En ❷, nous dé­fi­nis­sons le ta­bleau as­so­cia­tif de chaus­settes. Nous le rem­pli­rons par la suite avec les des­crip­teurs de fi­chiers. En ❸, nous sé­lec­tion­nons aléa­toi­re­ment l’in­dex de la chaus­sette cible3. En ❹, nous in­vo­quons la fonc­tion bpf_​sk_​select_​reuseport() pour en­re­gis­trer notre dé­ci­sion. En­fin, en ❺, nous ac­cep­tons le paquet.

Fichiers d’en-tête#

Si vous com­pi­lez le source C avec clang, vous ob­te­nez des er­reurs dues à des en­têtes man­quantes. La mé­thode conseillée pour ré­soudre ce pro­blème consiste à gé­né­rer un fi­chier vmlinux.h avec bpftool :

$ bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h

En­suite, in­cluez les en­têtes sui­vantes4 :

#include "vmlinux.h"
#include <bpf/bpf_helpers.h>

Pour mon noyau 6.17, le fi­chier vmlinux.h gé­néré est as­sez vo­lu­mi­neux : 2,7 Mio. De plus, bpf/​bpf_​helpers.h est fourni avec libbpf. Cela ajoute une autre dé­pen­dance. Comme le pro­gramme eBPF est as­sez pe­tit, je pré­fère mettre le strict mi­ni­mum dans vmlinux.h en sé­lec­tion­nant les dé­fi­ni­tions dont j’ai besoin.

Compilation#

La bi­blio­thèque eBPF pour Go four­nit bpf2go, un ou­til pour com­pi­ler les pro­grammes eBPF et gé­né­rer un sque­lette de code. Nous créons un fi­chier gen.go avec le contenu suivant :

package main

//go:generate go tool bpf2go -tags linux reuseport reuseport_kern.c

Après avoir exé­cuté go generate ./..., nous pou­vons ins­pec­ter les ob­jets ré­sul­tants avec readelf et llvm-objdump :

$ readelf -S reuseport_bpfeb.o
There are 14 section headers, starting at offset 0x840:
  [Nr] Name              Type             Address           Offset
[…]
  [ 3] sk_reuseport      PROGBITS         0000000000000000  00000040
  [ 6] .maps             PROGBITS         0000000000000000  000000c8
  [ 7] license           PROGBITS         0000000000000000  000000e8
[…]
$ llvm-objdump -S reuseport_bpfeb.o
reuseport_bpfeb.o:  file format elf64-bpf
Disassembly of section sk_reuseport:
0000000000000000 <reuseport_balance_prog>:
; {
       0:   bf 61 00 00 00 00 00 00     r6 = r1
;     __u32 index = bpf_get_prandom_u32() % num_sockets;
       1:   85 00 00 00 00 00 00 07     call 0x7
[…]

Utilisation depuis Go#

Confi­gu­rons 10 rou­tines écou­tant sur le même port5. Chaque chaus­sette ac­tive l’op­tion SO_​REUSEPORT avant de se mettre en écoute6 :

var (
    err error
    fds []uintptr
    conns []*net.UDPConn
)
workers := 10
listenAddr := "127.0.0.1:0"
listenConfig := net.ListenConfig{
    Control: func(_, _ string, c syscall.RawConn) error {
        c.Control(func(fd uintptr) {
            err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
            fds = append(fds, fd)
        })
        return err
    },
}
for range workers {
    pconn, err := listenConfig.ListenPacket(t.Context(), "udp", listenAddr)
    if err != nil {
        t.Fatalf("ListenPacket() error:\n%+v", err)
    }
    udpConn := pconn.(*net.UDPConn)
    listenAddr = udpConn.LocalAddr().String()
    conns = append(conns, udpConn)
}

La deuxième étape consiste à char­ger le pro­gramme eBPF, ini­tia­li­ser la va­riable num_​sockets, rem­plir le ta­bleau de chaus­settes et at­ta­cher le pro­gramme à la pre­mière chaussette7.

// Charge la collection eBPF.
spec, err := loadReuseport()
if err != nil {
    t.Fatalf("loadVariables() error:\n%+v", err)
}

// Initialise la variable globale "num_sockets" avec le nombre de descripteurs de fichiers.
if err := spec.Variables["num_sockets"].Set(uint32(len(fds))); err != nil {
    t.Fatalf("NumSockets.Set() error:\n%+v", err)
}

// Charge le programme et le tableau dans le noyau.
var objs reuseportObjects
if err := spec.LoadAndAssign(&objs, nil); err != nil {
    t.Fatalf("loadReuseportObjects() error:\n%+v", err)
}
t.Cleanup(func() { objs.Close() })

// Renseigne les descripteurs de fichiers dans le tableau de chaussettes.
for worker, fd := range fds {
    if err := objs.reuseportMaps.SocketMap.Put(uint32(worker), uint64(fd)); err != nil {
        t.Fatalf("SocketMap.Put() error:\n%+v", err)
    }
}

// Attache le programme eBPF à la première chaussette.
socketFD := int(fds[0])
progFD := objs.reuseportPrograms.ReuseportBalanceProg.FD()
if err := unix.SetsockoptInt(socketFD, unix.SOL_SOCKET, unix.SO_ATTACH_REUSEPORT_EBPF, progFD); err != nil {
    t.Fatalf("SetsockoptInt() error:\n%+v", err)
}

Nous sommes main­te­nant prêts à trai­ter les pa­quets. Chaque rou­tine Go in­cré­mente un comp­teur pour chaque pa­quet reçu8 :

var wg sync.WaitGroup
receivedPackets := make([]int, workers)
for worker := range workers {
    conn := conns[worker]
    packets := &receivedPackets[worker]
    wg.Go(func() {
        payload := make([]byte, 9000)
        for {
            if _, err := conn.Read(payload); err != nil {
                if errors.Is(err, net.ErrClosed) {
                    return
                }
                t.Logf("Read() error:\n%+v", err)
            }
            *packets++
        }
    })
}

En­voyons 1000 paquets :

sentPackets := 1000
conn, err := net.Dial("udp", conns[0].LocalAddr().String())
if err != nil {
    t.Fatalf("Dial() error:\n%+v", err)
}
defer conn.Close()
for range sentPackets {
    if _, err := conn.Write([]byte("hello world!")); err != nil {
        t.Fatalf("Write() error:\n%+v", err)
    }
}

Si nous af­fi­chons le contenu du ta­bleau receivedPackets, nous pou­vons vé­ri­fier que la ré­par­ti­tion fonc­tionne comme prévu, chaque rou­tine re­ce­vant en­vi­ron 100 paquets :

=== RUN   TestUDPWorkerBalancing
    balancing_test.go:84: receivedPackets[0] = 107
    balancing_test.go:84: receivedPackets[1] = 92
    balancing_test.go:84: receivedPackets[2] = 99
    balancing_test.go:84: receivedPackets[3] = 105
    balancing_test.go:84: receivedPackets[4] = 107
    balancing_test.go:84: receivedPackets[5] = 96
    balancing_test.go:84: receivedPackets[6] = 102
    balancing_test.go:84: receivedPackets[7] = 105
    balancing_test.go:84: receivedPackets[8] = 99
    balancing_test.go:84: receivedPackets[9] = 88

    balancing_test.go:91: receivedPackets = 1000
    balancing_test.go:92: sentPackets     = 1000

Déploiement sans impact#

Nous pou­vons éga­le­ment uti­li­ser SO_​ATTACH_​REUSEPORT_​EBPF pour re­dé­mar­rer une ap­pli­ca­tion sans im­pact. Une nou­velle ins­tance de l’ap­pli­ca­tion pré­pare sa propre ver­sion du ta­bleau de chaus­settes et at­tache le pro­gramme eBPF à la pre­mière d’entre elles. Le noyau di­rige alors les pa­quets en­trants vers cette nou­velle ins­tance. L’an­cienne ins­tance doit trai­ter les pa­quets déjà re­çus avant de s’arrêter.

Pour vé­ri­fier que nous ne per­dons au­cun pa­quet, nous créons une rou­tine Go pour en­voyer au­tant de pa­quets que possible :

sentPackets := 0
notSentPackets := 0
done := make(chan bool)
conn, err := net.Dial("udp", conns1[0].LocalAddr().String())
if err != nil {
    t.Fatalf("Dial() error:\n%+v", err)
}
defer conn.Close()
go func() {
    for {
        if _, err := conn.Write([]byte("hello world!")); err != nil {
            notSentPackets++
        } else {
            sentPackets++
        }
        select {
        case <-done:
            return
        default:
        }
    }
}()

En­suite, pen­dant que cette rou­tine Go s’exé­cute, nous dé­mar­rons le deuxième en­semble de rou­tines. Une fois confi­gu­rées, elles com­mencent à re­ce­voir des pa­quets. Si nous ar­rê­tons pro­pre­ment l’en­semble ini­tial de rou­tines, nous ne per­dons au­cun paquet9 !

=== RUN   TestGracefulRestart
    graceful_test.go:135: receivedPackets1[0] = 165
    graceful_test.go:135: receivedPackets1[1] = 195
    graceful_test.go:135: receivedPackets1[2] = 194
    graceful_test.go:135: receivedPackets1[3] = 190
    graceful_test.go:135: receivedPackets1[4] = 213
    graceful_test.go:135: receivedPackets1[5] = 187
    graceful_test.go:135: receivedPackets1[6] = 170
    graceful_test.go:135: receivedPackets1[7] = 190
    graceful_test.go:135: receivedPackets1[8] = 194
    graceful_test.go:135: receivedPackets1[9] = 155

    graceful_test.go:139: receivedPackets2[0] = 1631
    graceful_test.go:139: receivedPackets2[1] = 1582
    graceful_test.go:139: receivedPackets2[2] = 1594
    graceful_test.go:139: receivedPackets2[3] = 1611
    graceful_test.go:139: receivedPackets2[4] = 1571
    graceful_test.go:139: receivedPackets2[5] = 1660
    graceful_test.go:139: receivedPackets2[6] = 1587
    graceful_test.go:139: receivedPackets2[7] = 1605
    graceful_test.go:139: receivedPackets2[8] = 1631
    graceful_test.go:139: receivedPackets2[9] = 1689

    graceful_test.go:147: receivedPackets = 18014
    graceful_test.go:148: sentPackets     = 18014

Mal­heu­reu­se­ment, ar­rê­ter cor­rec­te­ment une chaus­sette UDP n’est pas tri­vial en Go10. Au­pa­ra­vant, nous ter­mi­nions les rou­tines en fer­mant leurs chaus­settes. Ce­pen­dant, si nous les fer­mons trop tôt, l’ap­pli­ca­tion perd les pa­quets qui leur ont été at­tri­bués mais qui n’ont pas en­core été trai­tés. Avant de s’ar­rê­ter, une rou­tine doit ap­pe­ler conn.​Read() jusqu’à ce qu’il n’y ait plus de pa­quets. Une so­lu­tion consiste à dé­fi­nir une échéance pour conn.​Read() et vé­ri­fier si nous de­vons ar­rê­ter la rou­tine Go lorsque l’échéance est écoulée :

payload := make([]byte, 9000)
for {
    conn.SetReadDeadline(time.Now().Add(50 * time.Millisecond))
    if _, err := conn.Read(payload); err != nil {
        if errors.Is(err, os.ErrDeadlineExceeded) {
            select {
            case <-done:
                return
            default:
                continue
            }
        }
        t.Logf("Read() error:\n%+v", err)
    }
    *packets++
}

Avec TCP, cet as­pect est plus simple : après avoir ac­tivé le pa­ra­mètre noyau net.​ipv4.​tcp_​migrate_​req, le noyau migre au­to­ma­ti­que­ment les connexions en at­tentes vers une chaus­sette aléa­toire du même groupe. Al­ter­na­ti­ve­ment, eBPF peut éga­le­ment contrô­ler cette mi­gra­tion. Les deux fonc­tion­na­li­tés sont dis­po­nibles de­puis Li­nux 5.14.

Addendum#

Après avoir im­plé­menté cette stra­té­gie dans Ak­vo­rado, toutes les rou­tines perdent dé­sor­mais des paquets ! 😱

$ curl -s 127.0.0.1:8080/api/v0/inlet/metrics \
> | sed -n s/akvorado_inlet_flow_input_udp_in_dropped//p
packets_total{listener="0.0.0.0:2055",worker="0"} 838673
packets_total{listener="0.0.0.0:2055",worker="1"} 843675
packets_total{listener="0.0.0.0:2055",worker="2"} 837922
packets_total{listener="0.0.0.0:2055",worker="3"} 841443
packets_total{listener="0.0.0.0:2055",worker="4"} 840668
packets_total{listener="0.0.0.0:2055",worker="5"} 850274
packets_total{listener="0.0.0.0:2055",worker="6"} 835488
packets_total{listener="0.0.0.0:2055",worker="7"} 834479

La rai­son ma­jeure est que le mo­dule Kafka li­mite par dé­faut les lots à 32 mes­sages. Cette li­mite est trop basse car les bro­kers ont une charge im­por­tante lors du trai­te­ment de chaque lot : ils doivent s’as­su­rer de leur bonne per­sis­tance avant d’ac­cu­ser ré­cep­tion. Aug­men­ter la li­mite à 4096 mes­sages cor­rige ce problème.

Bien que la ré­par­ti­tion des flux en­trants avec eBPF reste utile, elle n’a pas ré­solu le pro­blème prin­ci­pal. Au moins, la dis­tri­bu­tion uni­forme des pa­quets per­dus a aidé à iden­ti­fier le vé­ri­table gou­lot d’étran­glement. 😅