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á.
# Aqueça os clientes do SDK no AWS SDK for Java 2.x
Use o `SdkWarmUp` utilitário no AWS SDK for Java 2.x para aquecer seus clientes SDK durante a inicialização do aplicativo. Isso reduz a latência da primeira solicitação processada pelo aplicativo após a inicialização ou a restauração.
Um aquecimento exercita o caminho da solicitação do SDK (criando um cliente e invocando uma operação) antes que seu aplicativo processe o tráfego real. Você o usa com recursos de ponto de verificação e restauração, como o Lambda. [ SnapStart ](https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html) Esses recursos capturam um instantâneo do aplicativo inicializado e, em seguida, restauram a partir desse instantâneo para reduzir a latência da inicialização a frio.
Sem isso`SdkWarmUp`, você deve escrever seu próprio código de aquecimento antes de cada ponto de verificação, o que é complicado. Com`SdkWarmUp`, você faz uma única ligação para aquecer todos os seus clientes. Você pode aquecer todos os clientes do SDK em seu classpath ou somente os clientes específicos que seu aplicativo usa.
Neste tópico, você aprenderá a configurar e usar `SdkWarmUp` com CRaC AWS Lambda SnapStart e. Para obter mais informações sobre outras técnicas que reduzem o tempo de inicialização no Lambda, consulte[Reduza o tempo de inicialização do SDK para AWS Lambda](lambda-optimize-starttime.md).
## A SdkWarmUp API
`SdkWarmUp`faz parte do `sdk-core` módulo, portanto, está disponível para todos os clientes de serviços sem uma dependência adicional. Configure seu projeto para usar a versão 2.54.0 ou posterior do AWS SDK for Java 2.x. Em seguida, chame um dos dois métodos estáticos descritos nas seções a seguir. Ao chamar qualquer um dos métodos, `SdkWarmUp` faça uma chamada de rede para aquecer o cliente HTTP. Para aquecer o cliente do serviço, ele usa uma resposta local pronta. Ele não precisa de AWS credenciais ou permissões do IAM e não incorre em AWS cobranças.
### Aqueça todos os clientes SDK no classpath
O `warmUp()` método descobre cada cliente de serviço SDK no classpath e aquece cada um, junto com os clientes HTTP que eles usam. Use esse método quando depender de um pequeno número de módulos de serviço e ligar para a maioria dos clientes que eles fornecem. O exemplo Java de código a seguir chama `warmUp()` sem argumentos:
```
import software.amazon.awssdk.core.warmup.SdkWarmUp;
SdkWarmUp.warmUp();
```
Esse método é executado no máximo uma vez por JVM. Depois de uma chamada bem-sucedida, as chamadas subsequentes retornam imediatamente.
### Aqueça clientes SDK específicos
O `warmUp(Class... clients)` método aquece somente os clientes que você nomeia. Passe uma classe de cliente síncrona para aquecer o caminho síncrono ou uma classe de cliente assíncrona para aquecer o caminho assíncrono.
Use esse método quando o classpath contiver mais clientes de serviço do que as chamadas do aplicativo. Por exemplo, isso acontece quando uma dependência traz módulos de serviço que você não usa. Nomear somente os clientes de que você precisa mantém o tempo de aquecimento proporcional ao uso real do seu aplicativo, e não ao seu classpath completo. O exemplo Java de código a seguir aquece somente as `DynamoDbClient` classes `S3Client` e.
```
import software.amazon.awssdk.core.warmup.SdkWarmUp;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
SdkWarmUp.warmUp(S3Client.class, DynamoDbClient.class);
```
## Use SdkWarmUp com o Lambda SnapStart
[AWS Lambda SnapStart](https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html)melhora o desempenho de inicialização Java das funções. Quando você publica uma nova versão de uma função, o Lambda a SnapStart inicializa e tira um instantâneo da memória e do estado do disco. Em seguida, ele armazena o instantâneo em cache para reutilização. Para obter informações sobre os tempos de execução suportados e como ativá-los SnapStart para sua função, consulte o Guia * do *AWS Lambda desenvolvedor.
Como o Lambda tira o instantâneo após a execução do construtor do seu manipulador, chame `SdkWarmUp.warmUp()` o construtor. Em seguida, o snapshot inclui seus clientes aquecidos, e cada invocação restaurada a partir do snapshot se beneficia do aquecimento. O exemplo de Java código a seguir faz chamadas `SdkWarmUp.warmUp()` em um construtor de manipulador Lambda:
```
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import software.amazon.awssdk.core.warmup.SdkWarmUp;
public class MyHandler implements RequestHandler {
public MyHandler() {
SdkWarmUp.warmUp();
// Your other initialization here.
}
@Override
public String handleRequest(String input, Context context) {
// Your handler logic here.
}
}
```
Se sua função precisar executar um código personalizado antes do Lambda tirar o snapshot ou depois de restaurá-lo, implemente ganchos de tempo de execução SnapStart . Para obter mais informações, consulte ganchos [ SnapStart de tempo de execução para Java ](https://docs.aws.amazon.com/lambda/latest/dg/snapstart-runtime-hooks-java.html) no Guia * do *AWS Lambda desenvolvedor.
## Use SdkWarmUp com CRaC autônomo
Você também pode usar `SdkWarmUp` com CRaC diretamente, em um aplicativo que gerencia seus próprios pontos de verificação. Esta seção mostra onde a chamada de aquecimento pertence em um aplicativo que já está configurado. CRaC Para configurar um aplicativo paraCRaC, consulte o suporte do [ Step-by-step CRaC ](https://github.com/CRaC/docs/blob/master/STEP-BY-STEP.md) em. GitHub Esse passo a passo abrange as distribuições JDK suportadas, os pré-requisitos da plataforma e a dependência que as interfaces de ciclo de vida exigem. `org.crac:crac`
### Aqueça-se antes do posto de controle
Ligue `SdkWarmUp.warmUp()` durante a inicialização, antes de pegar o ponto de verificação. Seu aplicativo já se registra como um CRac `Resource` para fechar e reabrir conexões no ponto de verificação. Adicione a chamada de aquecimento ao mesmo construtor, conforme mostrado no exemplo de código a seguir: Java
```
import org.crac.Context;
import org.crac.Core;
import org.crac.Resource;
import software.amazon.awssdk.core.warmup.SdkWarmUp;
public class MyApp implements Resource {
public MyApp() {
SdkWarmUp.warmUp();
// Your other initialization here.
Core.getGlobalContext().register(this);
}
@Override
public void beforeCheckpoint(Context context) throws Exception {
// Close your service clients here.
}
@Override
public void afterRestore(Context context) throws Exception {
// Create your service clients again here.
}
}
```
**nota**
O CRaC não assume um ponto de verificação enquanto qualquer descritor de arquivo está aberto. Se você usa o cliente AWS CRT-based HTTP, fechar seus clientes de serviço por si só não é suficiente, pois o cliente mantém aberto um loop de eventos compartilhado. `beforeCheckpoint`Libere-o conforme mostrado no seguinte exemplo de código Java:
```
import org.crac.Context;
import org.crac.Resource;
import software.amazon.awssdk.crt.CrtResource;
import software.amazon.awssdk.crt.io.EventLoopGroup;
@Override
public void beforeCheckpoint(Context context) {
EventLoopGroup.closeStaticDefault();
CrtResource.waitForNoResources();
}
```
Os clientes HTTP Netty Apache baseados e baseados liberam seus recursos quando você fecha o cliente de serviço, portanto, não precisam de desmontagem adicional.
Pegue o posto de controle como faria normalmente.
## Recursos adicionais do
Os recursos a seguir fornecem mais informações sobre os tópicos abordados nesta seção:
+ [Documentação do CRaC sobre ](https://github.com/CRaC/docs) GitHub