As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Configurar tempos limite no AWS SDK para Rust

O AWS SDK para Rust fornece várias configurações para gerenciar tempos limite de solicitação em AWS service (Serviço da AWS) e fluxos de dados paralisados. Isso ajuda sua aplicação a se comportar de maneira ideal quando ocorrem atrasos e falhas inesperadas na rede.

Tempos limite da API

Quando há problemas transitórios que podem fazer com que as tentativas de solicitação demorem muito ou falhem completamente, é importante revisar e definir tempos limite a aplicação poder antecipar-se à falha rapidamente e se comportar de maneira ideal. Solicitações que falham podem ser automaticamente repetidas pelo SDK. Uma prática recomendada é definir tempos limite para as tentativas individuais e para toda a solicitação.

O SDK para Rust fornece um tempo limite padrão para estabelecer uma conexão para uma solicitação. O SDK não tem nenhum tempo de espera máximo padrão definido para receber uma resposta para uma tentativa de solicitação ou para toda a solicitação. As seguintes opções de tempo limite estão disponíveis:

O seguinte exemplo exibe a configuração de um cliente do Amazon S3 com valores de tempo limite personalizados:

let config = aws_config::defaults(BehaviorVersion::latest())
    .timeout_config(
        TimeoutConfig::builder()
            .operation_timeout(Duration::from_secs(5))
            .operation_attempt_timeout(Duration::from_millis(1500))
            .build()
    )
    .load()
    .await;

let s3 = aws_sdk_s3::Client::new(&config);
        

Ao usar os tempos limite de operação e tentativa juntos, você define um limite rígido para o tempo total gasto em todas as novas tentativas. Você também configura uma solicitação HTTP individual para se antecipar à falha rapidamente em uma solicitação lenta.

Como alternativa para definir esses valores de tempo limite no cliente de serviço para todas as operações, você pode configurar ou substituí-las por uma única solicitação.

Proteção de fluxo paralisado

O SDK para Rust fornece outra forma de tempo limite relacionada à detecção de fluxos paralisados. Um fluxo paralisado é um fluxo de upload ou download que não produz dados por mais do que um período de carência configurado. Isso ajuda a evitar que as aplicações sejam interrompidas indefinidamente e nunca progridam.

A proteção de fluxo paralisado retornará um erro quando um fluxo ficar inativo por mais tempo do que o período aceitável.

Por padrão, o SDK para Rust habilita a proteção de fluxos paralisados para uploads e downloads e busca pelo menos 1 byte/seg de atividade com um generoso período de carência de 20 segundos.

O seguinte exemplo exibe um StalledStreamProtectionConfig personalizado que desabilita a proteção de upload e altera o período de carência para nenhuma atividade para 10 segundos:

let config = aws_config::defaults(BehaviorVersion::latest())
    .stalled_stream_protection(
        StalledStreamProtectionConfig::enabled()
            .upload_enabled(false)
            .grace_period(Duration::from_secs(10))
            .build()
    )
    .load()
    .await;
        

Desabilitar a proteção de fluxo paralisado

O seguinte exemplo mostra como desabilitar completamente a proteção de fluxo parado:

let config = aws_config::defaults(BehaviorVersion::latest())
    .stalled_stream_protection(StalledStreamProtectionConfig::disabled())
    .load()
    .await;