Fundamentos para o AWS SDK para Rust - AWS SDK para Rust
Pré-requisitosFundamentos do Rustfundamentos da caixa do AWS SDK para RustConfiguração do projeto para trabalhar com Serviços da AWSRuntime do Tokio

Fundamentos para o AWS SDK para Rust

Aprenda os fundamentos da programação com o AWS SDK para Rust, como: fundamentos da linguagem de programação Rust, informações sobre as caixas do SDK para Rust, configuração do projeto e o uso do runtime do Tokio pelo SDK para Rust.

Pré-requisitos

Para usar o AWS SDK para Rust, você deve ter Rust e Cargo instalados.

As seguintes ferramentas opcionais podem ser instaladas em seu IDE para ajudar no preenchimento de código e na solução de problemas.

Fundamentos do Rust

A seguir estão alguns princípios básicos da linguagem de programação Rust que seria útil conhecer. Todas as referências para obter mais informações vêm da linguagem de programação Rust.

  • Cargo.toml é o arquivo de configuração padrão do projeto Rust, ele contém as dependências e alguns metadados sobre o projeto. Os arquivos de origem do Rust têm uma extensão de arquivo .rs. Consulte Hello, Cargo!.

    • O Cargo.toml pode ser personalizado com perfis, consulte Customizing Builds with Release Profiles. Esses perfis são completamente independentes e não relacionadas ao uso da AWS de perfis no arquivo compartilhado AWS config.

    • Uma forma comum de adicionar dependências de biblioteca ao seu projeto e a esse arquivo é usar cargo add. Consulte cargo-add.

  • O Rust tem uma estrutura funcional básica como a exibida a seguir. A palavra-chave let declara uma variável e pode ser combinada com a atribuição (=). Se você não especificar um tipo depois de let, o compilador inferirá um. Consulte Variables and Mutability.

    fn main() {
    let w = "world";
    println!("Hello {}!", w);
}

  • Para declarar uma variável x com um tipo explícito T, o Rust usa a sintaxe x: T. Consulte Tipos de dados.

  • struct X {} define o novo tipo X. Os métodos são implementados no tipo X de estrutura personalizada. Os métodos de tipo X são declarados com blocos de implementação prefixados com a palavra-chave impl. Dentro do bloco de implementação, self refere-se à instância da estrutura na qual o método foi chamado. Consulte Keyword impl and Method Syntax.

  • Se for um ponto de exclamação (“!”) segue o que parece ser uma definição de função ou chamada de função e, em seguida, o código está definindo ou chamando uma macro. Consulte Macros.

  • No Rust, os erros irrecuperáveis são representados pela macro panic!. Quando um programa encontra um panic!, ele para de ser executado, imprime uma mensagem de falha, desenrola, limpa a pilha e sai. Consulte Unrecoverable Errors with panic!.

  • O Rust não é compatível com a herança de funcionalidades de classes de base, como outras linguagens de programação. traits é como o Rust fornece a sobrecarga de métodos. As características podem ser consideradas conceitualmente semelhantes a uma interface. No entanto, características e interfaces verdadeiras têm diferenças e geralmente são usadas de modo diferente no processo de design. Consulte Traits: Defining Shared Behavior.

    • Polimorfismo se refere ao código que oferece suporte à funcionalidade de vários tipos de dados sem precisar escrever cada um individualmente. O Rust é compatível com polimorfismo por enumerações, características e genéricos. Consulte Inheritance as a Type System and as Code Sharing.

  • Rust é muito explícito sobre memória. Os ponteiros inteligentes “são estruturas de dados que agem como um ponteiro, mas também têm metadados e recursos adicionais”. Consulte Smart Pointers.

    • O tipo Cow é um ponteiro inteligente clone em gravação que ajuda a transferir a propriedade da memória para o chamador quando necessário. Consulte Enum std::borrow::Cow.

    • O tipo Arc é um ponteiro inteligente com contagem de referência atômica que conta as instâncias alocadas. Consulte Struct std::sync::Arc.

  • O SDK para Rust frequentemente usa o padrão builder para criar tipos complexos.

fundamentos da caixa do AWS SDK para Rust

  • A caixa principal da funcionalidade do SDK para Rust é aws-config. Isso está incluído na maioria dos projetos porque fornece funcionalidade para ler a configuração do ambiente.

    $ cargo add aws-config

    • Não confunda isso com o AWS service (Serviço da AWS) que é chamado AWS Config. Por se tratar de um serviço, ele segue a convenção padrão de caixas do AWS service (Serviço da AWS) e é chamado aws-sdk-config.

  • A biblioteca SDK para Rust é separada em caixas de biblioteca diferentes por cada AWS service (Serviço da AWS). Essas caixas estão disponíveis em https://docs.rs/.

  • As caixas do AWS service (Serviço da AWS) seguem a convenção de nomenclatura de aws-sdk-[servicename], como aws-sdk-s3 e aws-sdk-dynamodb.

Configuração do projeto para trabalhar com Serviços da AWS

  • Você precisará adicionar uma caixa ao seu projeto para cada AWS service (Serviço da AWS) que você deseja que sua aplicação use.

  • A forma recomendada de adicionar uma caixa é usando a linha de comando no diretório do seu projeto executando cargo add [crateName], como cargo add aws-sdk-s3.

    • Isso adicionará uma linha ao item Cargo.toml abaixo do seu projeto[dependencies].

    • Por padrão, isso adicionará a versão mais recente da caixa ao seu projeto.

  • Em seu arquivo de origem, use a declaração use para trazer itens de suas caixas para o escopo. Consulte Using External Packages do site da linguagem de programação Rust Programming Language.

    • Os nomes das caixas geralmente são hifenizados, mas os hifens são convertidos em sublinhados ao realmente usar a caixa. Por exemplo, a caixa do aws-config é usada na instrução use de código como use aws_config.

  • A configuração é um tópico complexo. A configuração pode ocorrer diretamente no código ou ser especificada externamente em variáveis de ambiente ou arquivos de configuração. Para obter mais informações, consulte Configurar clientes do serviço AWS SDK para Rust externamente.

    • Quando o SDK carrega sua configuração, valores inválidos são registrados em vez de interromper a execução porque a maioria das configurações tem padrões razoáveis. Para aprender a habilitar o registro em logs, consulte Configurar e usar o registro em log no AWS SDK para Rust.

    • A maioria das variáveis de ambiente e configurações do arquivo de configuração são carregadas uma vez quando o programa é iniciado. Todas as atualizações nos valores não serão vistas até que você reinicie o programa.

Runtime do Tokio

  • O Tokio é um runtime assíncrono para a linguagem de programação SDK para Rust que executa as tarefas async. Consulte tokio.rs e docs.rs/tokio.

  • O SDK para Rust requer um runtime assíncrono. Recomendamos que você adicione a caixa a seguir aos seus projetos:

    $ cargo add tokio --features=full

  • A macro de atributos tokio::main cria um ponto de entrada principal assíncrono para seu programa. Para usar essa macro, adicione-a à linha antes do método main, conforme mostrado a seguir:

    #[tokio::main]
async fn main() -> Result<(), Error> {