Hei, Habr-innbyggere! BPF-virtuelmaskinen er en av de viktigste komponentene i Linux-kjernen. Riktig bruk av den vil gjøre at systemingeniører kan identifisere feil og løse selv de mest komplekse problemene. Du vil lære å lage programmer som overvåker og endrer kjernens oppførsel, trygt implementere kode for overvåking av hendelser i kjernen, og mye mer. David Calavera og Lorenzo Fontana vil hjelpe deg med å avdekke mulighetene med BPF. Utvid kunnskapen din om ytelsesoptimalisering, nettverk og sikkerhet. — Bruk BPF for å overvåke og endre kjernens oppførsel. — Implementer kode for sikker overvåking av hendelser i kjernen — uten behov for å kompilere kjernen på nytt eller starte systemet på nytt. — Bruk praktiske kodeeksempler i C, Go eller Python. — Ha kontroll ved å mestre livssyklusen til BPF-programmet.
Sikkerheten i Linux-kjernen, dens muligheter og Seccomp
BPF gir en kraftig måte å utvide kjernen uten å kompromittere stabilitet, sikkerhet og hastighet. Av denne grunn tenkte kjernens utviklere at det ville være en god idé å bruke dens allsidighet til å forbedre prosessisoleringen i Seccomp ved å implementere Seccomp-filtre støttet av BPF-programmer, kjent som Seccomp BPF. I dette capitel vil vi forklare hva Seccomp er og hvordan det brukes. Deretter vil du lære å skrive Seccomp-filtre ved hjelp av BPF-programmer. Til slutt ser vi på de innebygde BPF-fallene som finnes i kjernen for sikkerhetsmoduler i Linux.
Linux-sikkerhetsmoduler (LSM) er en plattform som gir et sett med funksjoner som kan brukes for standardisert implementering av ulike sikkerhetsmodeller. LSM kan brukes direkte i kjernens kildekode, for eksempel Apparmor, SELinux og Tomoyo.
La oss begynne med å diskutere Linux' muligheter.
Funksjoner
Essensen i mulighetene til Linux ligger i at du trenger å gi en uprivilegert prosess tillatelse til å utføre en bestemt oppgave, men uten å bruke suid for dette formålet, eller på annen måte gjøre prosessen privilegert, noe som reduserer muligheten for angrep og gir prosessen mulighet til å utføre bestemte oppgaver. For eksempel, hvis applikasjonen din trenger å åpne en privilegert port, si 80, kan du i stedet for å kjøre prosessen som root, bare gi den muligheten CAP_NET_BIND_SERVICE.
La oss se på et Go-program kalt main.go:
package main
import (
"net/http"
"log"
)
func main() {
log.Fatalf("%v", http.ListenAndServe(":80", nil))
}Dette programmet setter opp en HTTP-server på port 80 (dette er en privilegert port). Vi kjører vanligvis det umiddelbart etter kompilering:
$ go build -o capabilities main.go
$ ./capabilitiesMen siden vi ikke gir root-rettigheter, vil denne koden gi en feil ved binding av port:
2019/04/25 23:17:06 listen tcp :80: bind: permission denied
exit status 1capsh (et verktøy for å håndtere skall) er et verktøy som kjører et skall med et bestemt sett av muligheter.
I dette tilfellet, som nevnt, i stedet for å gi full root-rettighet, kan vi tillate binding av privilegerte porter ved å gi muligheten cap_net_bind_service sammen med alle de andre som allerede finnes i programmet. For dette kan vi kjøre programmet vårt i capsh:
# capsh --caps='cap_net_bind_service+eip cap_setpcap,cap_setuid,cap_setgid+ep'
--keep=1 --user="nobody"
--addamb=cap_net_bind_service -- -c "./capabilities"La oss se litt nærmere på denne kommandoen.
- capsh – vi bruker capsh som skall.
- –caps='cap_net_bind_service+eip cap_setpcap,cap_setuid,cap_setgid+ep' – siden vi må bytte bruker (vi vil ikke kjøre med root-rettigheter), spesifiserer vi cap_net_bind_service og muligheten til faktisk å endre bruker-ID fra root til nobody, nemlig cap_setuid og cap_setgid.
- –keep=1 – vi ønsker å bevare de etablerte mulighetene når vi bytter fra root-konto.
- –user="nobody" – den endelige brukeren som kjører programmet vil være nobody.
- –addamb=cap_net_bind_service – vi spesifiserer renselse av relaterte muligheter etter bytte fra root-modus.
- – -c "./capabilities" – vi kjører ganske enkelt programmet.
Relaterte muligheter er en spesiell type muligheter som arves av datterprogrammer når det nåværende programmet utfører dem med execve(). Bare muligheter som er tillatt som relaterte, eller med andre ord, som miljømuligheter, kan arves.
Du lurer sikkert på hva +eip betyr etter at muligheten er angitt i alternativet —caps. Disse flaggene brukes til å bestemme hva muligheten:
-må aktiveres (p);
-er tilgjengelig for bruk (e);
-kan arves av barneprosesser (i).
Siden vi ønsker å bruke cap_net_bind_service, må vi gjøre dette med flagget e. Deretter starter vi et skall i kommandoen. Som et resultat vil et binært fil med capabilities kjøre, og vi må merke det med flagget i. Til slutt ønsker vi at muligheten skal være aktivert (vi gjorde dette uten å endre UID) ved hjelp av p. Dette ser ut som cap_net_bind_service+eip.
Du kan sjekke resultatet med ss. Vi skal forkorte outputen litt slik at den får plass på siden, men den vil vise tilknyttede porter og bruker-ID-er som ikke er 0, i dette tilfellet 65 534:
# ss -tulpn -e -H | cut -d' ' -f17-
128 *:80 *:*
users:(("capabilities",pid=30040,fd=3)) uid:65534 ino:11311579 sk:2c v6only:0I dette eksemplet brukte vi capsh, men du kan skrive et skall med libcap. For mer informasjon, se man 3 libcap.
Når utviklere skriver programmer, vet de ofte ikke på forhånd hvilke muligheter de trenger under kjøring; dessuten kan disse mulighetene endre seg i nye versjoner.
For å bedre forstå mulighetene til programmet vårt, kan vi bruke BCC-verktøyet capable, som setter kprobe for kjernens funksjon cap_capable:
/usr/share/bcc/tools/capable
TIME UID PID TID COMM CAP NAME AUDIT
10:12:53 0 424 424 systemd-udevd 12 CAP_NET_ADMIN 1
10:12:57 0 1103 1101 timesync 25 CAP_SYS_TIME 1
10:12:57 0 19545 19545 capabilities 10 CAP_NET_BIND_SERVICE 1Vi kan oppnå det samme ved å bruke bpftrace med en en-linjers kprobe i kjernens funksjon cap_capable:
bpftrace -e
'kprobe:cap_capable {
time("%H:%M:%S ");
printf("%-6d %-6d %-16s %-4d %dn", uid, pid, comm, arg2, arg3);
}'
| grep -i capabilitiesDette vil gi noe lignende det følgende, hvis programmets muligheter er aktivert etter kprobe:
12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 21 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 12 0
12:01:56 1000 13524 capabilities 10 1Den femte kolonnen viser hvilke muligheter prosessen trenger, og siden disse dataene inkluderer ikke-revisjonerte hendelser, ser vi alle ikke-revisjonskontroller, og til slutt den nødvendige muligheten med revisjonsflagget (den siste i outputen) satt til 1. Muligheten vi er interessert i er CAP_NET_BIND_SERVICE, som er definert som en konstant i kildekoden til kjernen i filen include/uapi/linux/ability.h med identifikator 10:
/* Allows binding to TCP/UDP sockets below 1024 */
/* Allows binding to ATM VCIs below 32 */
#define CAP_NET_BIND_SERVICE 10<source lang="go">Muligheter brukes ofte under containerkjøring, som runC eller Docker, for å operere i ikke-privilegert modus, men kun med de tillatelsene som er nødvendige for å kjøre de fleste applikasjoner. Når en applikasjon krever spesifikke tillatelser, kan disse gis i Docker ved hjelp av —cap-add:
docker run -it --rm --cap-add=NET_ADMIN ubuntu ip link add dummy0 type dummyDenne kommandoen gir containeren CAP_NET_ADMIN tillatelsen, som lar den konfigurere nettverkslenken for å legge til dummy0-grensesnittet.
I neste avsnitt vises hvordan slike muligheter kan filtreres, men med en annen metode som lar oss implementere våre egne filtre programmessig.
Seccomp
Seccomp står for Secure Computing, et sikkerhetsnivå implementert i Linux-kjernen som tillater utviklere å filtrere bestemte systemanrop. Selv om Seccomp kan sammenlignes med Linux-tillatelser, gir dens evne til å kontrollere spesifikke systemanrop en mye mer fleksibel tilnærming.
Seccomp og Linux-tillatelser utelukker ikke hverandre, de brukes ofte sammen for å dra nytte av begge tilnærmingene. For eksempel kan du ønske å gi en prosess CAP_NET_ADMIN-tillatelsen, men ikke la den akseptere tilkoblinger via socket ved å blokkere systemanropene accept og accept4.
Filtreringsmetoden til Seccomp er basert på BPF-filtre som kjører i SECCOMP_MODE_FILTER, og filtrering av systemanrop utføres på samme måte som for pakker.
Seccomp-filtre lastes opp med prctl ved hjelp av operasjonen PR_SET_SECCOMP. Disse filtrene har formen av et BPF-program som kjøres for hver Seccomp-pakke presentert med strukturen seccomp_data. Denne strukturen inneholder arkitektoniske referanser, en peker til instruksjoner i prosessoren under systemanropet og maksimum seks argumenter til systemanropet uttrykt som uint64.
Her er hvordan strukturen seccomp_data ser ut fra kildekoden til kjernen i filen linux/seccomp.h:
struct seccomp_data {
int nr;
__u32 arch;
__u64 instruction_pointer;
__u64 args[6];
};Som vist i denne strukturen kan vi filtrere etter systemanrop, dets argumenter eller en kombinasjon av dem.
Etter å ha mottatt hver pakke, er Seccomp-filteret forpliktet til å utføre en behandling for å ta en endelig beslutning og informere kjernen om hva som skal gjøres videre. Den endelige beslutningen uttrykkes med en av returverdiene (statuskoder).
— SECCOMP_RET_KILL_PROCESS — avslutning av hele prosessen umiddelbart etter at systemanropet er filtrert, som dermed ikke utføres.
— SECCOMP_RET_KILL_THREAD — avslutning av gjeldende tråd umiddelbart etter at systemanropet er filtrert, som dermed ikke utføres.
— SECCOMP_RET_KILL — alias for SECCOMP_RET_KILL_THREAD, bevart for bakoverkompatibilitet.
— SECCOMP_RET_TRAP — systemanropet er forbudt, og signalet SIGSYS (Bad System Call) sendes til oppgaven som kalte det.
— SECCOMP_RET_ERRNO — systemanropet utføres ikke, og en del av returverdien fra filteret SECCOMP_RET_DATA overføres til brukerrens rom som en errno-verdi. Avhengig av årsaken til feilen returneres ulike errno-verdier. Listen over feilkoder finnes i neste seksjon.
— SECCOMP_RET_TRACE — brukes til å varsle sporingsprogrammet ptrace med — PTRACE_O_TRACESECCOMP for å avlytte når et systemanrop utføres, for å se og kontrollere denne prosessen. Hvis sporeren ikke er koblet til, returneres en feil, errno settes til -ENOSYS, og systemanropet utføres ikke.
— SECCOMP_RET_LOG — systemanropet er tillatt og loggført.
— SECCOMP_RET_ALLOW — systemanropet er simpelthen tillatt.
ptrace er et systemanrop for implementering av sporingsmekanismer i en prosess kalt tracee, med mulighet for å observere og kontrollere utførelsen av prosessen. Sporingsprogrammet kan effektivt påvirke utførelsen og endre registrene i tracee. I konteksten av Seccomp brukes ptrace når det aktiveres av statuskoden SECCOMP_RET_TRACE, dermed kan sporeren hindre utførelsen av systemanropet og implementere egen logikk.
Seccomp-feil
Fra tid til annen, når du arbeider med Seccomp, vil du støte på forskjellige feil som identifiseres av returverdien med typen SECCOMP_RET_ERRNO. For å rapportere en feil, vil systemanropet seccomp returnere -1 i stedet for 0.
Følgende feil kan oppstå:
— EACCESS — system call is not permitted for the calling party. This usually happens because it lacks CAP_SYS_ADMIN privileges or no_new_privs is set using prctl (we'll discuss this later);
— EFAULT — the passed arguments (args in the seccomp_data structure) do not have a valid address;
— EINVAL — there can be four reasons for this:
- the requested operation is unknown or unsupported by the kernel in the current configuration;
- the specified flags are invalid for the requested operation;
- the operation involves BPF_ABS, but there are issues with the specified offset, which may exceed the size of the seccomp_data structure;
- the number of instructions passed to the filter exceeds the maximum;
— ENOMEM — not enough memory to execute the program;
— EOPNOTSUPP — the operation indicated that with SECCOMP_GET_ACTION_AVAIL the action was available, but the kernel does not support returning in arguments;
— ESRCH — there was a problem synchronizing another thread;
— ENOSYS — there is no tracer attached to the SECCOMP_RET_TRACE action.
prctl is a system call that allows user-space programs to manage (set and retrieve) specific aspects of a process, such as the byte order, thread names, secure computation mode (Seccomp), privileges, perf events, etc.
Seccomp may seem like a sandbox technology, but it is not. Seccomp is a utility that allows users to develop a sandboxing mechanism. Now let's look at how user interaction programs are created using a filter invoked directly by the seccomp system call.
Example of a Seccomp BPF filter
Here we will show how to combine the two actions discussed earlier, namely:
— we will write a Seccomp BPF program that will be used as a filter with various return codes depending on the decisions made;
— we will load the filter using prctl.
First, we need the headers from the standard library and the Linux kernel:
#include <errno.h>
#include <linux/audit.h>
#include <linux/bpf.h>
#include <linux/filter.h>
#include <linux/seccomp.h>
#include <linux/unistd.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/prctl.h>
#include <unistd.h>Before trying to execute this example, we must ensure that the kernel is compiled with CONFIG_SECCOMP and CONFIG_SECCOMP_FILTER set to y. This can be checked on a working machine as follows:
cat /proc/config.gz| zcat | grep -i CONFIG_SECCOMP
Den resterende del av koden er en install_filter-funksjon, som består av to deler. Den første delen inneholder vår liste over BPF-filtreringsinstruksjoner:
static int install_filter(int nr, int arch, int error) {
struct sock_filter filter[] = {
BPF_STMT(BPF_LD + BPF_W + BPF_ABS, (offsetof(struct seccomp_data, arch))),
BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arch, 0, 3),
BPF_STMT(BPF_LD + BPF_W + BPF_ABS, (offsetof(struct seccomp_data, nr))),
BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, nr, 0, 1),
BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ERRNO | (error & SECCOMP_RET_DATA)),
BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW),
}; Instruksjonene settes med makroene BPF_STMT og BPF_JUMP, definert i filen linux/filter.h.
La oss se nærmere på instruksjonene.
— BPF_STMT(BPF_LD + BPF_W + BPF_ABS (offsetof(struct seccomp_data, arch))) — systemet laster og akkumulerer med BPF_LD i ordformat BPF_W, pakket data plasseres med fast forskyvning BPF_ABS.
— BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arch, 0, 3) — sjekker med BPF_JEQ om arkitekturen i konstantakkumulatoren BPF_K er lik arch. Hvis det er tilfellet, går det med forskyvning 0 til neste instruksjon, ellers hopper det for å returnere en feil med forskyvning 3 (i dette tilfellet), fordi arch ikke stemmer.
— BPF_STMT(BPF_LD + BPF_W + BPF_ABS (offsetof(struct seccomp_data, nr))) — laster og akkumulerer med BPF_LD i ordformat BPF_W, som er systemanropsnummeret plassert med fast forskyvning BPF_ABS.
— BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, nr, 0, 1) — sammenligner systemanropsnummeret med verdien til variabelen nr. Hvis de er like, går det til neste instruksjon og nekter systemanropet, ellers tillater det systemanropet med SECCOMP_RET_ALLOW.
— BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ERRNO | (error & SECCOMP_RET_DATA)) — avslutter programmet med BPF_RET og returnerer en SECCOMP_RET_ERRNO-feil med nummeret fra variabelen err.
— BPF_STMT(BPF_RET + BPF_K, SECCOMP_RET_ALLOW) — avslutter programmet med BPF_RET og tillater utførelse av systemanropet med SECCOMP_RET_ALLOW.
SECCOMP ER CBPF
Du lurer kanskje på hvorfor det brukes en instruksjonsliste i stedet for et kompilert ELF-objekt eller et C-program som er kompilert med JIT.Det er to grunner til dette.
• For det første, Seccomp bruker cBPF (klassisk BPF), ikke eBPF, noe som betyr: det har ingen registre, bare en akkumulator for å lagre det siste resultatet av beregninger, som vist i eksempelet.
For the second point, Seccomp takes a pointer to an array of BPF instructions directly and nothing more. The macros we used merely help specify these instructions in a programmer-friendly format.
If you need further assistance understanding this assembly, consider the pseudocode that does the same thing:
if (arch != AUDIT_ARCH_X86_64) {
return SECCOMP_RET_ALLOW;
}
if (nr == __NR_write) {
return SECCOMP_RET_ERRNO;
}
return SECCOMP_RET_ALLOW;After defining the filter code in the socket_filter structure, you need to define sock_fprog, which contains the code and the calculated length of the filter. This data structure is necessary as an argument for declaring the operation of the process later:
struct sock_fprog prog = {
.len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),
.filter = filter,
};There is only one thing left to do in the install_filter function — load the program itself! For this, we use prctl, using PR_SET_SECCOMP as the option to enter secured computing mode. Then we will specify the mode to load the filter with SECCOMP_MODE_FILTER, which is contained in the prog variable of type sock_fprog:
if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {
perror("prctl(PR_SET_SECCOMP)");
return 1;
}
return 0;
}Finally, we can use our install_filter function, but first we need to call prctl to set PR_SET_NO_NEW_PRIVS for the current execution, thus avoiding a situation where child processes gain wider privileges than the parent. This allows us to make the following prctl calls in the install_filter function without having root permissions.
Now we can call the install_filter function. We will block all write system calls related to the X86-64 architecture and simply permit blocking all attempts. After setting the filter, we continue execution using the first argument:
int main(int argc, char const *argv[]) {
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
perror("prctl(NO_NEW_PRIVS)");
return 1;
}
install_filter(__NR_write, AUDIT_ARCH_X86_64, EPERM);
return system(argv[1]);
}Let's get started. To compile our program, we can use either clang or gcc; in any case, it's just compiling the main.c file without special options:
clang main.c -o filter-writeAs noted, we have blocked all writes in the program. To test this, we need a program that outputs something — ls seems like a good candidate. Here’s how it typically behaves:
ls -la
total 36
drwxr-xr-x 2 fntlnz users 4096 Apr 28 21:09 .
drwxr-xr-x 4 fntlnz users 4096 Apr 26 13:01 ..
-rwxr-xr-x 1 fntlnz users 16800 Apr 28 21:09 filter-write
-rw-r--r-- 1 fntlnz users 19 Apr 28 21:09 .gitignore
-rw-r--r-- 1 fntlnz users 1282 Apr 28 21:08 main.c
Flott! Slik ser bruken av programvaren vår ut: vi sender bare programmet vi ønsker å teste som det første argumentet:
.\/filter-write "ls -la"Når programmet er utført, gir det helt tom utdata. Likevel kan vi bruke strace for å se hva som skjer:
strace -f .\/filter-write "ls -la"Utdataene er betydelig forkortet, men den relevante delen viser at skrivene mislykkes med feil EPERM — den vi har konfigurert. Dette betyr at programmet ikke gir noen utdata fordi det ikke kan få tilgang til systemanropet write:
[pid 25099] write(2, "ls: ", 4) = -1 EPERM (Operation not permitted)
[pid 25099] write(2, "write error", 11) = -1 EPERM (Operation not permitted)
[pid 25099] write(2, "n", 1) = -1 EPERM (Operation not permitted)Nå forstår du hvordan Seccomp BPF fungerer og har en god idé om hva du kan gjøre med det. Men ville det ikke vært fint å oppnå det samme med eBPF i stedet for cBPF, for å utnytte all kraften?
Når folk tenker på eBPF-programmer, antar de fleste at de bare skriver og laster dem opp med administratorrettigheter. Selv om det generelt er sant, implementerer kjernen et sett med mekanismer for å beskytte eBPF-objekter på forskjellige nivåer. Disse mekanismene kalles BPF LSM-feller.
BPF LSM-feller
For å sikre arkitektur-uavhengig kontroll av systemhendelser implementerer LSM konseptet med feller. Teknisk sett er et fellestøyelsesanrop likt et systemanrop, men det er uavhengig av systemet og integrert med infrastrukturen. LSM gir et nytt konsept der abstraksjonsnivået kan bidra til å unngå problemer som oppstår når man arbeider med systemanrop på forskjellige arkitekturer.
På tidspunktet for skrivingen av boken hadde kjernen syv feller relatert til BPF-programmer, og SELinux var den eneste innebygde LSM som implementerte dem.
Kildekoden for fellene ligger i kjernens tre i filen include\/linux\/security.h:
extern int security_bpf(int cmd, union bpf_attr *attr, unsigned int size);
extern int security_bpf_map(struct bpf_map *map, fmode_t fmode);
extern int security_bpf_prog(struct bpf_prog *prog);
extern int security_bpf_map_alloc(struct bpf_map *map);
extern void security_bpf_map_free(struct bpf_map *map);
extern int security_bpf_prog_alloc(struct bpf_prog_aux *aux);
extern void security_bpf_prog_free(struct bpf_prog_aux *aux);Hver av dem blir kalt på forskjellige stadier av utførelsen:
— security_bpf — utfører en innledende sjekk av utførte systemkall for BPF;
— security_bpf_map — sjekker når kjernen returnerer en filbeskrivelse for kartet;
— security_bpf_prog — sjekker når kjernen returnerer en filbeskrivelse for eBPF-programmet;
— security_bpf_map_alloc — sjekker om sikkerhetsfeltet er initialisert inne i BPF-kartene;
— security_bpf_map_free — sjekker om sikkerhetsfeltet blir renset inne i BPF-kartene;
— security_bpf_prog_alloc — sjekker om sikkerhetsfeltet blir initialisert inne i BPF-programmene;
— security_bpf_prog_free — sjekker om sikkerhetsfeltet blir renset inne i BPF-programmene.
Nå, når vi ser alt dette, forstår vi: ideen bak LSM BPF-håndtakene er at de kan gi beskyttelse til hvert eBPF-objekt, og sikre at bare de som har riktige privilegier kan utføre operasjoner på kartene og programmene.
Sammendrag
Sikkerhet er ikke noe du kan implementere på en universell måte for alt du ønsker å beskytte. Det er viktig å kunne beskytte systemer på forskjellige nivåer og på ulike måter. Enten du liker det eller ei, er den beste måten å sikre systemet på å organisere forskjellige sikkerhetsnivåer fra ulike posisjoner, slik at en nedgang i sikkerhet på et nivå ikke gir tilgang til hele systemet. Kjerneutviklerne har gjort en stor innsats for å gi oss et sett med forskjellige lag og samhandlingspunkter. Vi håper vi har gitt deg en god forståelse av hva lagene er og hvordan du kan bruke BPF-programmer til å arbeide med dem.
Om forfatterne
David Calavera er teknisk direktør i Netlify. Han har jobbet i Docker-support og deltatt i utviklingen av verktøy som Runc, Go, BCC og andre open source-prosjekter. Han er kjent for sitt arbeid med Docker-prosjekter og utviklingen av Docker-plugin-økosystemet. David elsker flamme-diagrammer og jobber alltid med ytelsesoptimalisering.
Lorenzo Fontana Han jobber i et team av programvareutviklere med åpen kildekode hos Sysdig, hvor han hovedsakelig arbeider med Falco — et prosjekt fra Cloud Native Computing Foundation, som sikrer sikkerheten til containerkjøringsmiljøer og oppdager avvik gjennom kjernermodulen og eBPF. Han er fascinert av distribuerte systemer, programvaredefinerte nettverk, Linux-kjernen og ytelsesanalyse.
» Du kan lese mer om boken på
»
»
For Habr-brukere er det 25% rabatt med kupongen — Linux
Når den trykte versjonen av boken er betalt, vil e-boken bli sendt til e-posten din.
Kilde: habr.com
