O HTTP utiliza uma arquitetura cliente-servidor para transferência de informações e dados. Um dos recursos das linguagens de programação do lado do servidor, como Rust, é desenvolver servidores e aplicativos clientes para interagir com serviços baseados em HTTP.

O Rust é adequado para construir servidores HTTP devido aos seus recursos de segurança, desempenho e confiabilidade. As caixas de terceiros da Rust, como Actix e Rocket, são populares para a construção de servidores da Web sofisticados que podem lidar com alto tráfego.

Por que você deve usar Rust para desenvolvimento de servidor Web HTTP?

Rust ganhou popularidade para o desenvolvimento de servidores web, pois alguns dos recursos da linguagem são exatamente os requisitos para a construção da maioria dos servidores web.

O uso do Rust garante que seu aplicativo seja dimensionado com eficiência, tornando a linguagem ideal para a criação de aplicativos de alto desempenho. Aqui estão razões específicas para considerar o uso do Rust para seu servidor web e outros aplicativos do lado do servidor.

Rust's High Performance

O alto desempenho é uma das razões pelas quais o Rust é uma excelente escolha para a construção de servidores da Web HTTP. O Rust fornece acesso de baixo nível aos recursos do sistema, incluindo a memória e a CPU, permitindo que você escreva um código que seja executado mais rapidamente com menos recursos do que outras linguagens do lado do servidor.

Além disso, o sistema de propriedade do Rust elimina a necessidade de coleta de lixo em tempo de compilação, que é uma das razões pelas quais algumas linguagens do lado do servidor são lentas.

Segurança e proteção

O sistema de gerenciamento de memória da Rust torna a linguagem segura para o desenvolvimento do servidor web. Você não encontra referências de ponteiro nulas ou oscilantes que podem levar a vazamentos de memória e outras vulnerabilidades de segurança.

Sistema de propriedade de Rust evita esses erros comuns para manter seu servidor e aplicativos seguros. Rust também se concentra na prevenção de estouros de buffer e outros erros relacionados à memória.

Simultaneidade

Simultaneidade é a capacidade de executar várias unidades de um programa fora de ordem sem afetar a saída. A saída de um programa concorrente deve ser igual à saída de um programa assíncrono.

A simultaneidade pode afetar significativamente o desempenho do seu aplicativo, pois os servidores precisam lidar com várias solicitações simultaneamente. Rust fornece suporte para coexistência com um modelo de threading leve.

O molho da programação simultânea em Rust é que o sistema de propriedade permite que você escreva código thread-safe sem a necessidade de bloqueios e outras primitivas de sincronização.

A biblioteca padrão do Rust e pacotes de terceiros no ecossistema Rust fornecem ferramentas modernas para desenvolvimento de servidor web.

Cargo, o gerenciador de pacotes do Rust, simplifica o gerenciamento de dependências e cria processos. Além disso, o Rust tem excelente suporte IDE com ferramentas como o Rust Analyzer, que fornecem conclusão de código perfeita, destaque de erros e outros recursos.

Visão geral das bibliotecas Actix e Rocket

A biblioteca padrão do Rust tem a maior parte do utilitário que você precisa para construir servidores web. Bibliotecas de terceiros como Foguete e Actix simplifique a criação de aplicativos do lado do servidor com Rust.

Actix e Foguete são frameworks web Rust populares, mas as bibliotecas diferem em design e recursos.

O Rocket é um framework web de alto nível que prioriza a produtividade e a facilidade de uso. O Rocket fornece muitas abstrações e açúcar de sintaxe para criar aplicativos da Web em Rust. O Rocket também é popular por sua digitação forte e design de API intuitivo.

Você pode adicionar o Rocket como uma dependência do projeto em seu Cargo.toml arquivo para começar a criar aplicativos da web em Rust:

[dependências]
foguete = "0.4.11"

Por outro lado, o Actix-web é uma estrutura de baixo nível que prioriza o desempenho e a escalabilidade. O Actix utiliza um modelo de simultaneidade baseado em ator e fornece E/S sem bloqueio que torna o pacote ideal para criar aplicativos da Web de alto desempenho.

Adicione o Actix como uma dependência do projeto no dependências seção do seu Cargo.toml arquivo:

[dependências]
actix-web = "4.3.1"

A escolha de uma biblioteca para o seu projeto dependerá das especificações do seu projeto, dos recursos da biblioteca e da sua experiência com Rust e HTTP.

Construindo um Servidor Web Simples em Rust

Depois de criar um projeto Rust e adicionar qualquer um dos frameworks Rocket ou Actix às dependências do seu projeto no Cargo.toml arquivo, você está pronto para começar a construir um servidor web em Rust.

Construindo um Servidor Web Simples com Actix

Você pode usar um serializador para solicitações ao criar serviços da Web em Rust.

Serde é uma biblioteca Rust popular para serializar e desserializar dados entre tipos Rust e formatos de dados como JSON, YAML e TOML. Serde fornece uma estrutura para definir a conversão de dados entre estruturas de dados Rust e representações correspondentes em outros formatos de dados.

Aqui está a diretiva para adicionar o Serde como um pacote de terceiros para o seu projeto.

[dependências]
serde = { versão = "1.0.159", características = ["derivar"] }

Depois de adicionar Serde e Actix como dependências do projeto, você pode gerar um servidor web básico com Rust. Veja como você pode configurar um simples Olá Mundo! servidor web que grava uma string para o cliente com o Actix:

Primeiro, importe os módulos e tipos necessários do actix_web e serde caixotes:

usar actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
usar serde::{Deserialize, Serialize};

você vai usar serde para serializar uma mensagem para o cliente com um struct. O Serde converterá a estrutura em JSON para o cliente. Aqui está a estrutura para a mensagem:

#[derivar (depurar, serializar, desserializar)]
estruturaMensagem {
 mensagem: Corda,
}

Agora você pode definir a função do manipulador para o endpoint. Na parte superior da função do manipulador, você pode adicionar decoradores para comportamentos personalizados:

#[pegar("/")]
assíncronofnolá() -> implicar Respondente {
 HttpResponse::OK().json (Mensagem {
 mensagem: "Olá Mundo!".to_own(),
 })
}

O olá A função de manipulador lida com solicitações GET. A função retorna um tipo que implementa o respondente traço do Actix pacote.

O json método do HttpResponse:: Ok() tipo leva em uma instância struct que serde lida sob o capô e retorna a resposta ao cliente.

Depois de definir o endpoint, você pode iniciar uma instância do servidor e montar o endpoint em uma rota.

#[actix_web:: principal]
assíncronofnprincipal() -> padrão:: io::Resultado {
 HttpServer:: new(|| App:: new().service (olá))
 .vincular("127.0.0.1:8080")?
 .correr()
 .aguardam
}

O HttpServer:: novo função é uma nova instância do servidor. O principal a função é iniciada e o servidor monta o olá função de manipulador com a nova instância do aplicativo. O vincular método vincula o servidor ao URL especificado e o correr A função executa o servidor.

Construindo um Servidor Web Simples com Rocket

O Rocket é minimalista, então você pode configurar um servidor web simples sem quaisquer dependências além do Foguete engradado.

Veja como configurar um servidor simples com um Olá Mundo! endpoint usando o Rocket:

Primeiro, importe as dependências necessárias para o seu servidor.

#![recurso (proc_macro_hygiene, decl_macro)]
#[macro_use]
externocaixote foguete;
// importa da caixa Rocket
usar foguete:: resposta:: conteúdo;
usar foguete:: Estado;

O #![recurso (proc_macro_hygiene, decl_macro)] O atributo ativa os recursos experimentais do Rust para a estrutura do Rocket. O #[macro_use] atributo importa macros do foguete módulo.

Aqui está uma função de manipulador que serve HTML mediante solicitação:

#[pegar("/")]
fnOlá Mundo() -> conteúdo:: Html'estáticostr> {
 conteúdo:: Html("
Olá Mundo!
")
}

O Olá Mundo A função retorna uma string estática HTML com o conteúdo:: HTML função.

Aqui está uma declaração de struct de configuração para o servidor (convenção do framework Rocket):

estruturaconfiguração {
 porta: u16,
}
#[pegar("/porta")]
fnporta(configuração: estado) -> Corda {
formatar!("Servidor rodando na porta {}", config.port)
}

Ao executar o servidor, você pode fazer solicitações ao /port endpoint para o status da porta.

Por fim, você criará uma instância de servidor com o acender função. Adicione as configurações, monte as rotas e inicie o servidor:

fnprincipal() {
deixar config = config { porta: 8000 };
 foguete:: inflamar()
 .manage (configuração)
 .mount("/", rotas![hello_world, porta])
 .lançar();
}

O configuração variável é uma instância do configuração struct. O acender função inicia uma instância do servidor, o gerenciar método adiciona a configuração ao servidor e o montar O método monta a função do manipulador nas rotas base. finalmente, o lançar O método inicia o servidor para escutar na porta especificada.

Você pode construir aplicativos Web poderosos em Rust com WASM

WebAssembly (WASM) é um formato de instrução binária projetado para execução em navegadores e outros dispositivos. O WASM fornece um formato de bytecode de baixo nível que linguagens de programação de alto nível, como Rust, podem usar como destino de compilação.

Com o WASM, você pode compilar seu código Rust em um formato binário que os navegadores mais populares podem executar. O WASM abre um mundo de possibilidades para a construção de aplicativos Web robustos em Rust, incluindo aplicativos Web full-stack.