Conceitos básicos

Modo de foco

Conceitos básicos - AWS SDK para Rust

Pré-requisitos Fundamentos da ferrugem AWS SDK para Rust fundamentos da criação Configuração do projeto para trabalhar com Serviços da AWS Tempo de execução do Tokio

Pré-requisitos

Para usar o AWS SDK para Rust, você deve ter o Rust and Cargo instalado.

Instale o conjunto de ferramentas Rust: https://www.rust-lang. org/tools/install
Instale a cargo-component ferramenta executando o comando: cargo install cargo-component

Ferramentas recomendadas:

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

A extensão rust-analyzer, consulte Rust no Visual Studio Code.
Amazon Q Developer, consulte Instalação da extensão ou plug-in Amazon Q Developer em seu IDE.

Fundamentos da ferrugem

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 .rs de arquivo. Veja Hello, Cargo! .
- Eles Cargo.toml podem ser personalizados com perfis, consulte Personalização de compilações com perfis de versão. Esses perfis são completamente independentes e independentes AWS do uso de perfis no AWS config arquivo compartilhado.
- Uma forma comum de adicionar dependências de biblioteca ao seu projeto e a esse arquivo é usarcargo add. Consulte cargo-add.
Rust tem uma estrutura de funções básica como a seguinte. A let palavra-chave declara uma variável e pode ser combinada com a atribuição (=). Se você não especificar um tipo depoislet, o compilador inferirá um. Consulte Variáveis e mutabilidade.
```
fn main() {
    let w = "world";
    println!("Hello {}!", w);
}
```
Para declarar uma variável x com um tipo explícitoT, o Rust usa a sintaxe. x: T Consulte Tipos de dados.
struct X {}define o novo tipoX. 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-chaveimpl. Dentro do bloco de implementação, self refere-se à instância da estrutura na qual o método foi chamado. Consulte impl Sintaxe de palavra-chave e método.
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, se desenrola, limpa a pilha e sai. Consulte Erros irrecuperáveis com. panic!
O Rust não suporta a herança de funcionalidades de classes base, como outras linguagens de programação; traits é assim que 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 forma diferente no processo de design. Consulte Traços: Definindo o comportamento compartilhado.
- Polimorfismo se refere ao código que oferece suporte à funcionalidade de vários tipos de dados sem precisar escrever cada um individualmente. O Rust suporta polimorfismo por meio de enumerações, características e genéricos. Veja Herança como um sistema de tipos e como compartilhamento de código.
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 Ponteiros inteligentes.
- O tipo Cow é um ponteiro clone-on-write inteligente 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.

AWS SDK para Rust fundamentos da criação

A caixa principal da funcionalidade SDK for 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 AWS service (Serviço da AWS) caixas e é chamadoaws-sdk-config.
A biblioteca SDK para Rust é separada em caixas de biblioteca diferentes por cada uma. AWS service (Serviço da AWS) Essas caixas estão disponíveis em https://docs.rs/.
AWS service (Serviço da AWS) as caixas seguem a convenção de nomenclatura deaws-sdk-[servicename], como e. aws-sdk-s3 aws-sdk-dynamodb

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

Você precisará adicionar uma caixa ao seu projeto para cada uma AWS service (Serviço da AWS) que você deseja que seu aplicativo use.
A forma recomendada de adicionar uma caixa é usando a linha de comando no diretório do seu projeto executandocargo add [crateName], comocargo 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 use declaração para trazer itens de suas caixas para o escopo. Consulte Usando pacotes externos no site da linguagem de programação Rust.
- Os nomes das caixas geralmente são hifenizados, mas os hífens são convertidos em sublinhados ao realmente usar a caixa. Por exemplo, a aws-config caixa é usada na use instrução 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 Opções de configuração.
- 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 saber como ativar o registro, consulteAtivar o registro do AWS SDK para Rust código.
- 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.

Tempo de execução do Tokio

O Tokio é um tempo de execução assíncrono para a linguagem de programação SDK for Rust, ele executa as tarefas. async Veja tokio.rs e docs.rs/tokio.
O SDK para Rust requer um tempo de execução assíncrono. Recomendamos que você adicione a seguinte caixa aos seus projetos:
```
$ cargo add tokio --features=full
```
A macro de tokio::main atributos cria um ponto de entrada principal assíncrono para seu programa. Para usar essa macro, adicione-a à linha antes do main método, conforme mostrado a seguir:
```
#[tokio::main]
async fn main() -> Result<(), Error> {
```