Pesquisa de site

Modernize o desenvolvimento de funções de rede com esta estrutura baseada em Rust

Capsule é uma estrutura para processamento de pacotes e gravação de funções de rede que visa diminuir o nível de entrada para o desenvolvimento de funções de rede.

O mundo das redes passou por mudanças monumentais na última década, especialmente na mudança contínua de hardware especializado para funções de rede definidas por software (NFV) para plano de dados1 e processamento de pacotes. Embora a transição para o software tenha moldado o surgimento das redes SDN (redes definidas por software) e das redes programáveis, surgiram novos desafios para tornar essas funções flexíveis, eficientes, mais fáceis de usar e rápidas (ou seja, pouco a sem sobrecarga de desempenho). Nossa equipe na Comcast queria aproveitar o que a rede faz de melhor, especialmente no que diz respeito à sua capacidade de transporte e mecanismos de roteamento, e ao mesmo tempo ser capaz de desenvolver programas de rede através de lentes de software modernas - enfatizando testes, rapidez iteração e implantação. Portanto, com esses objetivos em mente, desenvolvemos o Capsule, uma nova estrutura para desenvolvimento de funções de rede, escrita em Rust, inspirada na pesquisa NetBricks de Berkeley e integrada no Data Plane Development Kit (DPDK) da Intel.

Muitas redes hoje ainda são programadas usando linguagens de baixo nível que podem carecer de proteção contra erros lógicos. Estudos mostraram até que erros lógicos são os erros mais comumente encontrados em programas de processamento de pacotes, incluindo falha na verificação das condições de ramificação esperadas, esquecimento de verificações ou validações condicionais e erros nas somas de verificação. Embora tenha havido um influxo de estruturas de linguagem de alto nível e modelos de programação entrando no espaço, especialmente da pesquisa e da academia, muitos tendem a ser difíceis para os desenvolvedores de aplicativos começarem, estenderem para seus próprios propósitos, testes unitários e/ou executado em um ambiente de produção.

Com o Capsule, pretendemos oferecer uma estrutura ergonômica para o desenvolvimento de funções de rede que tradicionalmente apresenta altas barreiras de entrada para desenvolvedores. Criamos uma ferramenta para construir e executar funções de rede, manipulando pacotes de rede com eficiência e ao mesmo tempo protegendo o tipo, a memória e o thread. Com base no DPDK e no Rust, o Capsule oferece:

  • um processador de pacotes rápido que usa um número mínimo de ciclos de CPU.
  • um sistema rico de tipo de pacote que garante segurança de memória e segurança de thread.
  • um modelo de programação declarativa que enfatiza a simplicidade.
  • uma estrutura extensível e testável que é fácil de desenvolver e manter.

Começando

A maneira mais fácil de começar a desenvolver aplicativos Capsule é usar a máquina virtual (VM) Vagrant da Capsule e a sandbox Docker. O sandbox é pré-configurado com todas as ferramentas e bibliotecas necessárias para o desenvolvimento do Capsule, incluindo:

  • DPDK 19.11
  • Clang e LLVM
  • Ferrugem 1.43
  • rr 5,3

Primeiro, instale o Vagrant e o VirtualBox em seu sistema. Além disso, instale os plug-ins Vagrant necessários com:

host$ vagrant plugin install vagrant-reload vagrant-disksize vagrant-vbguest

Em seguida, clone o repositório sandbox do Capsule, inicie e ssh na VM Vagrant:

host$ git clone https://github.com/capsule-rs/sandbox.git
host$ cd sandbox
host$ vagrant up
host$ vagrant ssh

Quando estiver dentro da VM Debian criada com o Docker instalado, execute o sandbox com:

vagrant$ docker run -it --rm \
    --privileged \
    --network=host \
    --name sandbox \
    --cap-add=SYS_PTRACE \
    --security-opt seccomp=unconfined \
    -v /lib/modules:/lib/modules \
    -v /dev/hugepages:/dev/hugepages \
    getcapsule/sandbox:19.11.1-1.43 /bin/bash

Lembre-se de montar também o diretório de trabalho do seu projeto como um volume para o sandbox. Então você pode usar os comandos Rust Cargo dentro do contêiner normalmente.

Por fim, adicione Capsule como uma dependência ao seu Cargo.toml e comece a escrever sua aplicação:

[dependencies]
capsule = "0.1"

Se você deseja desenvolver o Capsule sem usar o Docker no Vagrant, confira o repositório de sandbox do Capsule para obter instruções sobre como executar nosso ambiente de VM do Vagrant, bem como outras opções que não dependem do Vagrant ou do Docker. A caixa Capsule Rust está disponível em crates.io.

Envolver-se

O projeto Capsule está procurando colaboradores para ajudar a desenvolver e aprimorar ainda mais a estrutura, incluindo novos protocolos, recursos e otimizações. Se você estiver interessado em participar, consulte o guia de contribuição para se envolver. Também adoraríamos ver quais casos de uso e aplicativos são explorados com a estrutura. Para ver como são os programas Capsule, confira nossos exemplos, incluindo um utilitário ping e funções de rede que exercitam tradução e encaminhamento de endereços de rede, geração de inundação TCP SYN com métricas expostas e nossa abordagem declarativa geral para processamento de pacotes.

O projeto e todos os participantes dele concordam e são regidos pelo Código de Conduta da Cápsula.

Os atuais mantenedores com funções para mesclar solicitações pull são:

  • Pedro Cline
  • Daniel Jin (co-mantenedor líder)
  • Zeeshan Lakhani (co-mantenedor líder)
  • André Wang

Você pode entrar em contato com a equipe através do Discord ou e-mail.

1Refere-se ao encaminhamento e modificação do tráfego de rede. Leia Planos de dados de rede programáveis para uma visão contemporânea sobre projetos e pesquisas da indústria de programabilidade de planos de dados.