Languages
Pages
Legal
AWS SDK para Java versão 2Guia do desenvolvedor
AWS SDK para Java versão 2: Guia do desenvolvedorCopyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
AWS SDK para Java versão 2 Guia do desenvolvedor
Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.
AWS SDK para Java versão 2 Guia do desenvolvedor
Table of ContentsGuia do desenvolvedor do AWS SDK for Java 2.0 ................................................................................. 1
Novidades da versão 2 ............................................................................................................... 1Recursos ainda não disponíveis no AWS SDK for Java 2.0 ............................................................... 1Recursos adicionais .................................................................................................................... 1Contribuição para o SDK ............................................................................................................. 2Suporte ao IDE do Eclipse ........................................................................................................... 2Desenvolver aplicativos da AWS para Android ................................................................................ 2
Conceitos básicos ............................................................................................................................... 3Cadastrar-se na AWS e criar um usuário do IAM ........................................................................... 3Fazer download do SDK .............................................................................................................. 4
Pré-requisitos ..................................................................................................................... 4Fazer download do SDK em seu projeto ................................................................................ 4Compilar o SDK ................................................................................................................. 4Instalar um ambiente de desenvolvimento do Java .................................................................. 5Escolher uma JVM ............................................................................................................. 5
Configurar credenciais e região da AWS ........................................................................................ 5Definir credenciais da &AWS ................................................................................................ 6Atualizar as credenciais do IMDS ......................................................................................... 6Definir a região da AWS ...................................................................................................... 7
Usar o SDK com o Apache Maven .............................................................................................. 8Pré-requisitos ..................................................................................................................... 4Criar um projeto Maven ....................................................................................................... 8Configurar o compilador Java para Maven ............................................................................. 8Declarar o SDK como dependência ....................................................................................... 9Definir dependências para módulos do SDK ......................................................................... 10Compilar o projeto ............................................................................................................ 11
Usar o SDK com o Gradle ........................................................................................................ 11Uso da SDK .................................................................................................................................... 13
Criar clientes de serviço ........................................................................................................... 13Obter um compilador de cliente .......................................................................................... 13Usar DefaultClient ............................................................................................................. 14Ciclo de vida do cliente ..................................................................................................... 14
Fornecer e recuperar credenciais da AWS .................................................................................. 14Usar a cadeia de fornecedores de credenciais padrão ............................................................ 14Usar um provedor de credenciais ou uma cadeia de fornecedores ............................................ 17Fornecer credenciais explicitamente .................................................................................... 17
Seleção da região da AWS ....................................................................................................... 18Escolher uma região ......................................................................................................... 18Escolher um endpoint específico ......................................................................................... 18Determinar automaticamente a região da AWS pelo ambiente ................................................. 19Verificar disponibilidade do serviço em uma região da AWS .................................................... 19
Configuração do cliente ............................................................................................................. 20Configuração do transporte HTTP ...................................................................................... 20Otimize o desempenho de inicialização a frio para o AWS Lambda .......................................... 21
Programação assíncrona .......................................................................................................... 22Operação sem streaming ................................................................................................... 22Operações de streaming .................................................................................................... 24Operações avançadas ....................................................................................................... 26
Programação de HTTP/2 .......................................................................................................... 27Processamento de exceções ..................................................................................................... 27
Por que exceções desmarcadas? ........................................................................................ 27SdkServiceException (e subclasses) .................................................................................... 28SdkClientException ............................................................................................................ 28
Registrar chamadas do AWS SDK for Java ................................................................................. 28
iii
AWS SDK para Java versão 2 Guia do desenvolvedor
Adicionar o Log4J JAR ...................................................................................................... 28Arquivo de configuração do Log4j ....................................................................................... 29Definir o classpath ............................................................................................................ 29Erros e avisos específicos do serviço .................................................................................. 29Registro em log do resumo de requisição/resposta ................................................................ 30Registro em log detalhado ................................................................................................. 30
Configurar o JVM TTL para pesquisas de nome DNS .................................................................... 31Como definir o TTL da JVM ............................................................................................... 31
Configurar funções do IAM para o Amazon EC2 (Avançado) .......................................................... 32Cadeia de fornecedores padrão e perfis de instância do Amazon EC2 ...................................... 32Demonstração: usar funções do IAM em instâncias do Amazon EC2 ........................................ 33
Exemplos de código .......................................................................................................................... 34Exemplos do Amazon CloudWatch .............................................................................................. 34
Obter métricas do CloudWatch .......................................................................................... 35Publicar dados de métrica personalizada ............................................................................. 36Trabalhar com alarmes do CloudWatch ............................................................................... 37Use ações de alarme no CloudWatch ................................................................................. 40Enviar eventos para o CloudWatch ..................................................................................... 41
Exemplos do Amazon Cognito .................................................................................................... 44Criar um grupo de usuários ................................................................................................ 44Listar usuários de um grupo de usuários .............................................................................. 44Criar um grupo de identidades ............................................................................................ 45Adicionar um cliente de aplicativo ....................................................................................... 46Adicionar um provedor de identidade de terceiros .................................................................. 47Obter credenciais para um ID ............................................................................................. 48
Exemplos do Amazon DynamoDB ............................................................................................... 48Trabalhar com tabelas no DynamoDB ................................................................................. 49Trabalhar com itens no DynamoDB .................................................................................... 55Mapear itens em tabelas do DynamoDB ............................................................................. 60
Exemplos do Amazon EC2 ......................................................................................................... 67Gerenciar instâncias do Amazon EC2 ................................................................................. 67Usar endereços IP elásticos no Amazon EC2 ...................................................................... 72Utilizar regiões e zonas de disponibilidade ........................................................................... 74Trabalhar com pares de chaves do Amazon EC2 ................................................................. 76Trabalhar com grupos de segurança no Amazon EC2 ........................................................... 78
Exemplos do AWS Identity and Access Management (IAM) ............................................................. 81Gerenciar chaves de acesso do IAM .................................................................................. 82Gerenciar usuários do IAM ................................................................................................ 85Usar aliases de conta do IAM ........................................................................................... 88Trabalhar com políticas do IAM ......................................................................................... 90Trabalhar com certificados de servidor do IAM ..................................................................... 95
Exemplos do Amazon Kinesis ..................................................................................................... 98Assinar streamings de dados do Amazon Kinesis ................................................................. 99
Exemplos do Amazon Lambda .................................................................................................. 104Operações de serviço ...................................................................................................... 104
Exemplos do Amazon Pinpoint .................................................................................................. 107Criar um projeto .............................................................................................................. 107Criar um segmento dinâmico ............................................................................................ 108Importar um segmento estático ......................................................................................... 109Listar segmentos para o projeto ........................................................................................ 111Criar uma campanha ....................................................................................................... 111Enviar uma mensagem .................................................................................................... 113
Exemplos do Amazon S3 ......................................................................................................... 114Operações de buckets ..................................................................................................... 115Operações de objetos ...................................................................................................... 118
Exemplos pré-assinados do Amazon S3 ..................................................................................... 123Gerar uma URL pré-assinada e fazer upload de um objeto .................................................... 124
iv
AWS SDK para Java versão 2 Guia do desenvolvedor
Obter um objeto pré-assinado ........................................................................................... 125Exemplos do Amazon SNS ...................................................................................................... 127
Criar um tópico ............................................................................................................... 127Listar os tópicos do SNS .................................................................................................. 127Inscrever um endpoint em um tópico ................................................................................. 128Publicar uma mensagem em um tópico .............................................................................. 129Cancelar a inscrição de um endpoint de um tópico ............................................................... 129Excluir um tópico ............................................................................................................ 130
Exemplos do Amazon SQS ...................................................................................................... 131Operações de filas .......................................................................................................... 131Operações de mensagens ................................................................................................ 134
Exemplos do Amazon Transcribe .............................................................................................. 136Como trabalhar com o Amazon Transcribe ........................................................................ 137
Exemplos de paginação ........................................................................................................... 140Paginação síncrona ......................................................................................................... 141Paginação assíncrona ...................................................................................................... 143
Segurança ...................................................................................................................................... 147Proteção de dados .................................................................................................................. 147Impor o TLS 1.2 ..................................................................................................................... 148
Suporte ao TLS no Java .................................................................................................. 148Como verificar a versão do TLS ........................................................................................ 148Como definir a versão do TLS .......................................................................................... 148
Identity and Access Management .............................................................................................. 149Validação de conformidade ....................................................................................................... 149Resiliência .............................................................................................................................. 150Segurança da infraestrutura ...................................................................................................... 150
Histórico do documento .................................................................................................................... 151
v
AWS SDK para Java versão 2 Guia do desenvolvedorNovidades da versão 2
Guia do desenvolvedor do AWS SDKfor Java 2.0
O AWS SDK for Java fornece uma API do Java para o Amazon Web Services. Usando o SDK, você podecompilar facilmente aplicativos Java que funcionem com Amazon S3, Amazon EC2, DynamoDB e muitomais. Sempre adicionamos suporte para novos serviços ao AWS SDK for Java. Para obter uma lista dealterações e recursos em uma versão específica, visualize o log de alterações.
Novidades da versão 2O AWS SDK for Java 2.0 é uma importante reescrita do código base da versão 1.x. Ele foi criado combase no Java 8+ e adiciona vários recursos frequentemente solicitados. Entre eles, suporte para E/Ssem bloqueio e capacidade de conectar uma implementação HTTP diferente em tempo de execução.Para obter mais informações, consulte o Blog da AWS. Para obter orientações sobre a migração de seuaplicativo de 1.11.x para 2.x, consulte o guia de migração.
Recursos ainda não disponíveis no AWS SDK forJava 2.0
Veja os problemas do Github a seguir para obter detalhes sobre os recursos adicionais que ainda nãoestão na versão 2.x. Comentários e feedback também são bem-vindos.
• Bibliotecas de alto nível• Gerenciador de transferências do S3• Cliente de criptografia do S3• APIs de documentos do DynamoDB• Cliente de criptografia do DynamoDB• Buffer do lado do cliente do SQS
• Waiters• Métricas do SDK• Listeners de progresso
Recursos adicionaisAlém deste guia, os seguintes recursos online são importantes para desenvolvedores do AWS SDK forJava:
• Referência do AWS SDK para Java 2.x• Blog de desenvolvedor Java• Fóruns de desenvolvedor Java• GitHub:
1
AWS SDK para Java versão 2 Guia do desenvolvedorContribuição para o SDK
• Fonte da documentação• Fonte do SDK
• O catálogo de exemplos de código da AWS• @awsforjava (Twitter)
Contribuição para o SDKOs desenvolvedores também podem contribuir com comentários por meio destes canais:
• Enviar problemas no GitHub:• Enviar problemas da documentação• Enviar problemas do SDK
• Participar de um bate-papo informal sobre o SDK no Canal Gitter do AWS SDK para Java 2.x• Enviar comentários anonimamente para [email protected]. Este e-mail é
monitorado pela equipe do AWS SDK para Java.• Enviar solicitações de extração da documentação ou dos repositórios GitHub da fonte do SDK para
contribuir para o desenvolvimento do SDK.
Suporte ao IDE do EclipseO AWS Toolkit for Eclipse não oferece suporte ao AWS SDK for Java 2.0 no momento. Para usar o AWSToolkit for Eclipse com o AWS SDK for Java 2.0, você deve utilizar as ferramentas do Maven no Eclipse eadicionar uma dependência no SDK 2.x.
Desenvolver aplicativos da AWS para AndroidSe você for um desenvolvedor para Android, a Amazon Web Services publicará um SDK feitoespecificamente para desenvolvimento em Android: o AWS Mobile SDK para Android. Consulte o Guia dodesenvolvedor do AWS Mobile SDK para Android para obter a documentação completa.
2
AWS SDK para Java versão 2 Guia do desenvolvedorCadastrar-se na AWS e criar um usuário do IAM
Conceitos básicos do AWS SDK forJava 2.0
Esta seção fornece informações sobre como instalar, configurar e usar o AWS SDK for Java.
Tópicos• Cadastrar-se na AWS e criar um usuário do IAM (p. 3)• Fazer download do AWS SDK for Java 2.0 (p. 4)• Configurar credenciais e região da AWS para desenvolvimento (p. 5)• Usar o SDK com o Apache Maven (p. 8)• Usar o SDK com o Gradle (p. 11)
Cadastrar-se na AWS e criar um usuário do IAMPara usar o AWS SDK for Java a fim de acessar a Amazon Web Services (AWS), você precisará de umaconta e de credenciais da AWS. Para aumentar a segurança da conta da AWS, recomendamos usar umusuário do IAM para fornecer credenciais de acesso, em vez de usar as credenciais de sua conta da AWS.
Note
Para obter uma visão geral dos usuários do IAM e por que eles são importantes para a segurançada sua conta, consulte Credenciais de segurança da AWS no Amazon Web Services GeneralReference.
Para cadastrar-se na AWS
1. Abra https://aws.amazon.com/ e clique em Sign Up (Cadastrar-se).2. Siga as instruções da tela. Parte do procedimento de cadastro envolve o recebimento de uma
chamada telefônica e a inserção de um PIN usando o teclado do telefone.
Em seguida, crie um usuário do IAM e faça download (ou copie) da chave de acesso secreta.
Para criar um usuário do IAM
1. Vá até o console do IAM (talvez você precise fazer login na AWS primeiro).2. Clique em Users (Usuários) na barra lateral para exibir os usuários do IAM.3. Se não possuir nenhum usuário do IAM configurado, clique em Create New Users (Criar usuários)
para criar um.4. Selecione o usuário do IAM na lista que você usará para acessar a AWS.5. Abra a guia Security Credentials (Credenciais de segurança) e clique em Create Access Key (Criar
chave de acesso).Note
Você pode ter, no máximo, duas chaves de acesso ativas para um dado usuário do IAM. Se ousuário do IAM já possui duas chaves de acesso, será necessário excluir uma delas antes decriar uma chave.
6. Na caixa de diálogo resultante, clique no botão Download Credentials (Fazer download decredenciais) para fazer download do arquivo de credencial no computador ou clique em Show User
3
AWS SDK para Java versão 2 Guia do desenvolvedorFazer download do SDK
Security Credentials (Mostrar credenciais de segurança do usuário) para visualizar o ID de chave deacesso e a chave de acesso secreta do usuário do IAM (que você pode copiar e colar).
Important
Não haverá como obter a chave de acesso secreta assim que você fechar a caixa de diálogo.No entanto, você pode excluir o ID de chave de acesso associado e criar um novo.
Em seguida, defina suas credenciais (p. 5) no arquivo de credenciais compartilhado da AWS ou noambiente.
Fazer download do AWS SDK for Java 2.0Este tópico descreve como fazer download do AWS SDK for Java em seu projeto.
Pré-requisitosPara usar o AWS SDK for Java, você deve ter:
• Um ambiente de desenvolvimento do Java (p. 5) apropriado.• Uma conta da AWS e chaves de acesso. Para obter instruções, consulte Cadastrar-se na AWS e criar
um usuário do IAM (p. 3).• As credenciais da AWS (chaves de acesso) definidas no ambiente ou que usam o arquivo de credenciais
utilizado na ILC da AWS e outros SDKs. Para obter mais informações, consulte Configurar ascredenciais e a região da AWS para desenvolvimento (p. 5).
Fazer download do SDK em seu projetoDependendo do seu sistema de compilação ou IDE, use um dos seguintes métodos para fazer downloaddo SDK no seu projeto usando o Apache Maven ou o Gradle:
• Apache Maven– Se usar Apache Maven, você poderá especificar somente os componentes do SDK deque precisa ou todo o SDK (não recomendado) como dependências no projeto. Consulte Usar o SDKcom o Apache Maven (p. 8).
• Gradle – ao usar o Gradle, você poderá importar a Bill of Materials (BOM – Lista de materiais) do Mavenno projeto do Gradle para gerenciar automaticamente as dependências do SDK. Consulte Usar o SDKcom Gradle (p. 11).
Note
Qualquer sistema de compilação que ofereça suporte ao MavenCentral como um artefato deorigem pode ser usado.
Se você estiver usando um dos métodos acima (por exemplo, o Maven), não será necessário baixar einstalar os arquivos AWS JAR (você pode ignorar a seção seguinte). Se você quiser compilar os projetosusando um IDE diferente, com o Apache Ant, ou por qualquer outro meio, faça download e extraia o SDKconforme mostrado na próxima seção.
Compilar o SDKVocê pode compilar o AWS SDK for Java usando o Maven. O Maven faz download de todasas dependências necessárias, compila e instala o SDK em uma única etapa. Consulte http://maven.apache.org/ para obter instruções de instalação e mais informações.
4
AWS SDK para Java versão 2 Guia do desenvolvedorInstalar um ambiente de desenvolvimento do Java
Para compilar o SDK
1. Abra o AWS SDK para Java 2.x (GitHub).
Note
A versão 1.0 do SDK também está disponível no GitHub em AWS SDK para Java 1.x(GitHub).
2. Clique no botão Clone or download (Clonar ou fazer download) para escolher sua opção de download.3. Em uma janela de terminal, navegue até o diretório em que você fez download da fonte do SDK.4. Compile e instale o SDK usando o seguinte comando (Maven obrigatório).
mvn clean install
O arquivo .jar resultante foi compilado no diretório target.5. (Opcional) Compile a documentação de referência da API usando o seguinte comando.
mvn javadoc:javadoc
A documentação foi compilada nos diretórios target/site/apidocs/ de cada serviço.
Instalar um ambiente de desenvolvimento do JavaO AWS SDK for Java requer o Java 8.0 ou posterior. Você pode fazer download do software do Java SEDevelopment Kit mais recente em http://www.oracle.com/technetwork/java/javase/downloads/.
O AWS SDK for Java também funciona com o OpenJDK e o Amazon Corretto, uma distribuição do OpenJava Development Kit (OpenJDK). Faça download da versão mais recente do OpenJDK em https://openjdk.java.net/install/index.html. Faça download da versão mais recente do Amazon Corretto 11 ouAmazon Corretto 8 em https://aws.amazon.com/corretto/.
Escolher uma JVMTendo em vista o melhor desempenho dos aplicativos baseados em servidor com o AWS SDK for Java,recomendamos usar a versão de 64 bits da Java Virtual Machine (JVM – Máquina virtual do Java). EssaJVM somente é executada em modo de servidor, mesmo se você especificar a opção -Client em tempode execução.
Configurar credenciais e região da AWS paradesenvolvimento
Para se conectar a qualquer um dos serviços compatíveis com o AWS SDK for Java, você deve forneceras credenciais da AWS. Os SDKs e as ILCs da AWS usam cadeias de fornecedores para procurarcredenciais da AWS em vários lugares diferentes, inclusive variáveis de sistema/ambiente do usuário earquivos locais de configuração da AWS.
Este tópico fornece informações básicas sobre como configurar as credenciais da AWS paradesenvolvimento de aplicativos locais usando o AWS SDK for Java. Se você precisar configurarcredenciais a serem usadas dentro de uma instância do Amazon EC2 ou se estiver usando o IDE doEclipse para desenvolvimento, consulte os seguintes tópicos:
5
AWS SDK para Java versão 2 Guia do desenvolvedorDefinir credenciais da &AWS
• Ao usar uma instância do EC2, crie uma função do IAM e dê à instância do EC2 acesso a essafunção conforme mostrado no artigo sobre como configurar funções do IAM para o Amazon EC2(avançado) (p. 32).
• Configure credenciais da AWS dentro do Eclipse usando o AWS Toolkit for Eclipse. Consulte Configurarcredenciais da AWS no Guia do usuário do AWS Toolkit for Eclipse.
Definir credenciais da &AWSVocê pode definir as credenciais a serem usadas pelo AWS SDK for Java de várias maneiras. Porém,estas são as abordagens recomendadas:
• Defina credenciais no arquivo de perfil de credenciais da AWS no sistema local, localizado em:• ~/.aws/credentials no Linux, macOS, or Unix• C:\Users\USERNAME\.aws\credentials no Windows
Esse arquivo deve conter linhas no seguinte formato:
[default]aws_access_key_id = your_access_key_idaws_secret_access_key = your_secret_access_key
Substitua os próprios valores de credenciais da AWS pelos valores your_access_key_id eyour_secret_access_key.
• Defina as variáveis de ambiente AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY.
Para definir essas variáveis no Linux, macOS, or Unix, use export :
export AWS_ACCESS_KEY_ID=your_access_key_idexport AWS_SECRET_ACCESS_KEY=your_secret_access_key
Para definir essas variáveis no Windows, use set :
set AWS_ACCESS_KEY_ID=your_access_key_idset AWS_SECRET_ACCESS_KEY=your_secret_access_key
• Para uma instância do EC2, especifique uma função do IAM e dê à instância do EC2 acesso a essafunção. Consulte Funções do IAM para o Amazon EC2 no Amazon EC2 User Guide for Linux Instancespara ver uma discussão detalhada sobre como isso funciona.
Depois que você tiver definido as credenciais da AWS usando um desses métodos, o AWS SDK for Javaas carregarão automaticamente usando a cadeia de fornecedores de credencial padrão. Para obter maisinformações sobre como trabalhar com credenciais da AWS nos aplicativos Java, consulte Fornecer erecuperar credenciais da AWS (p. 14).
Atualizar as credenciais do IMDSO AWS SDK for Java permite atualizar credenciais do IMDS em segundo plano a cada minuto,independentemente do tempo de expiração da credencial. Isso permite que você atualize as credenciaiscom mais frequência e reduz a chance de que não atingir o IMDS afete a disponibilidade percebida daAWS.
1. // Refresh credentials using a background thread, automatically every minute. This will log an error if IMDS is down during
6
AWS SDK para Java versão 2 Guia do desenvolvedorDefinir a região da AWS
2. // a refresh, but your service calls will continue using the cached credentials until the credentials are refreshed 3. // again one minute later. 4. 5. InstanceProfileCredentialsProvider credentials = 6. InstanceProfileCredentialsProvider.builder() 7. .asyncCredentialUpdateEnabled(true) 8. .build(); 9. 10. S3Client client = S3Client.builder() 11. .credentialsProvider(credentials) 12. .build(); 13. 14. // This is new: When you are done with the credentials provider, you must close it to release the background thread. 15. credentials.close();
Definir a região da AWSVocê deve definir uma região da AWS padrão a ser usada para acessar serviços da AWS com oAWS SDK for Java. Tendo em vista o melhor desempenho da rede, você deve escolher uma regiãogeograficamente próxima de você (ou dos clientes).
Note
Se você não selecionar uma região, as chamadas de serviço que exigem uma região falharão.
Você pode usar técnicas semelhantes àquelas para configuração de credenciais para definir a região daAWS padrão:
• Defina a região da AWS no arquivo de configuração da AWS no sistema local, localizado em:• ~/.aws/config no Linux, macOS, or Unix• C:\Users\USERNAME\.aws\config no Windows
Esse arquivo deve conter linhas no seguinte formato:
[default]region = your_aws_region
Substitua a região da AWS desejada (por exemplo, "us-west-2") para your_aws_region.• Defina a variável de ambiente AWS_REGION.
Em Linux, macOS, or Unix use export :
export AWS_REGION=your_aws_region
No Windows, use set :
set AWS_REGION=your_aws_region
Em que your_aws_region é o nome da região da AWS desejado.
Para obter informações sobre a seleção de uma região, consulte Escolher uma região da AWS (p. 18).
7
AWS SDK para Java versão 2 Guia do desenvolvedorUsar o SDK com o Apache Maven
Usar o SDK com o Apache MavenVocê pode usar o Apache Maven para configurar e compilar projetos do AWS SDK for Java ou compilar opróprio SDK.
Pré-requisitosPara usar o AWS SDK for Java com o Maven, você precisa do seguinte:
• Java 8.0 ou posterior. Você pode fazer download do software do Java SE Development Kit mais recenteem http://www.oracle.com/technetwork/java/javase/downloads/. O AWS SDK for Java também funcionacom o OpenJDK e o Amazon Corretto, uma distribuição do Open Java Development Kit (OpenJDK).Faça download da versão mais recente do OpenJDK em https://openjdk.java.net/install/index.html.Faça download da versão mais recente do Amazon Corretto 11 ou Amazon Corretto 8 em https://aws.amazon.com/corretto/.
• Apache Maven. Se você precisar instalar o Maven, acesse http://maven.apache.org/ para baixá-lo.
Criar um projeto MavenPara criar um projeto Maven pela linha de comando, abra uma janela de terminal ou prompt de comando,digite ou cole o comando abaixo e pressione Enter ou Return.
mvn -B archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-lambda -Dservice=s3 -Dregion=US_WEST_2 \ -DgroupId=com.example.myapp \ -DartifactId=myapp
Note
Substitua com.example.myapp pelo namespace do pacote completo do aplicativo. Substituamyapp pelo nome do projeto. Esse será o nome do diretório do projeto.
Esse comando cria um projeto Maven usando o arquétipo de projeto do AWS Lambda. Esse arquétipo deprojeto é pré-configurado para compilar com o Java SE 8 e inclui uma dependência para o AWS SDK forJava.
Para obter mais informações sobre como criar e configurar projetos do Maven, consulte o Maven GettingStarted Guide.
Configurar o compilador Java para MavenSe você criou seu projeto usando o arquétipo do projeto do AWS Lambda conforme descrito anteriormente,isso já foi feito para você.
Para verificar se a configuração está presente, primeiro abra o arquivo pom.xml da pasta do projeto quevocê criou (por exemplo, myapp) ao executar o comando anterior. Veja as linhas 11 e 12 para confirmara configuração da versão do compilador Java desse projeto Maven, e a inclusão necessária do plugin docompilador Maven nas linhas 71-75.
<project> <properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target>
8
AWS SDK para Java versão 2 Guia do desenvolvedorDeclarar o SDK como dependência
</properties> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>${maven.compiler.plugin.version}</version> </plugin> </plugins> </build></project>
Se você criar seu projeto com um arquétipo diferente ou por outro método, certifique-se de que o plug-in docompilador Maven faz parte da compilação e que suas propriedades de origem e destino estão definidascomo 1.8 no pom.xml arquivo.
Consulte o snippet anterior para ver uma maneira de definir essas configurações necessárias.
Como opção, você pode configurar o compilador em linha com a declaração do plugin, como a seguir.
<project> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin> </plugins> </build></project>
Declarar o SDK como dependênciaPara usar o AWS SDK for Java no seu projeto, você precisa declará-lo como uma dependência no arquivopom.xml do projeto.
Se você criou seu projeto usando o arquétipo de projeto conforme descrito anteriormente, o SDK jáestá configurado como dependência no projeto. Recomendamos atualizar essa configuração para fazerreferência à versão mais recente do AWS SDK for Java. Para fazer isso, abra o arquivo pom.xml e alterea propriedade aws.java.sdk.version (na linha 16) para a versão mais recente. Veja um exemplo aseguir.
<project> <properties> <aws.java.sdk.version>2.13.7</aws.java.sdk.version> </properties></project>
Encontre a versão mais recente do AWS SDK for Java na Referência de API do AWS SDK para Javaversão 2.x.
Se você criou seu projeto do Maven de maneira diferente, configure a versão mais recente do SDK paraseu projeto garantindo que o arquivo pom.xml contenha o seguinte.
<project>
9
AWS SDK para Java versão 2 Guia do desenvolvedorDefinir dependências para módulos do SDK
<dependencyManagement> <dependencies> <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>bom</artifactId> <version>2.X.X</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement></project>
Note
Substitua 2.X.X no arquivo pom.xml por uma versão válida da versão 2 do AWS SDK for Java.
Definir dependências para módulos do SDKAgora que você configurou o SDK, pode adicionar dependências para um ou mais módulos do AWS SDKfor Java para usar no projeto.
Como você já declarou a versão do SDK na seção dependencyManagement, não é necessárioespecificar o número da versão de cada componente. Para carregar uma versão personalizada de ummódulo, especifique um número de versão para a dependência dele.
Se você criou o projeto usando o arquétipo de projeto conforme descrito anteriormente, ele já estáconfigurado com várias dependências. Elas incluem dependências para o Lambda e o AmazonDynamoDB, como a seguir.
<project> <dependencies> <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>dynamodb</artifactId> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-lambda-java-core</artifactId> <version>1.2.0</version> </dependency> </dependencies></project>
Adicione os módulos ao projeto do serviço e dos recursos da AWS necessários para ele. Os módulos(dependências) que são gerenciados pela BOM do AWS SDK for Java estão listados no repositório centraldo Maven (https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest).
Note
Para determinar quais dependências você precisa para o projeto, veja o arquivo pom.xml de umexemplo de código. Por exemplo, se você estiver interessado nas dependências do serviço doAmazon S3, consulte este exemplo no Repositório de exemplos de código da AWS no GitHub.(Procure o arquivo pom.xml em /java2/example_code/s3.)
Desenvolver todo o SDK no projetoPara otimizar o aplicativo, recomendamos que você extraia apenas os componentes de que precisa, emvez de todo o SDK. No entanto, para criar o AWS SDK for Java inteiro no projeto, declare-o no arquivopom.xml, da seguinte forma.
10
AWS SDK para Java versão 2 Guia do desenvolvedorCompilar o projeto
<project> <dependencies> <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>aws-sdk-java</artifactId> <version>2.X.X</version> </dependency> </dependencies></project>
Compilar o projetoDepois de configurar o arquivo pom.xml, você poderá usar o Maven para desenvolver o projeto.
Para criar o projeto Maven pela linha de comando, abra uma janela de terminal ou prompt de comando,navegue até o diretório dele (por exemplo, myapp), insira ou cole o comando abaixo e pressione Enter ouReturn.
mvn package
Isso criará um único arquivo (JAR) .jar no diretório target (por exemplo, myapp/target). Esse JARconterá todos os módulos SDK especificados como dependências no arquivo pom.xml.
Usar o SDK com o GradleVocê pode usar o Gradle para configurar e criar projetos do AWS SDK para Java.
Para gerenciar dependências do SDK para seu projeto Gradle, importe a Bill of Materials (BOM - Lista demateriais) do Maven do AWS SDK for Java para o arquivo build.gradle.
Note
Nos exemplos a seguir, substitua 2.X.X no arquivo build.gradle por uma versão válida doAWS SDK para Java v2. Encontre a versão mais recente na Referência de API do AWS SDK paraJava versão 2.x.
Como configurar o AWS SDK for Java para Gradle versão 5.0 ou posterior
1. Adicione a BOM à seção dependencies do arquivo.
...dependencies { implementation platform('software.amazon.awssdk:bom:2.X.X')
// Declare individual SDK dependencies without version ...}
2. Especifique os módulos do SDK a serem usados na seção dependencies. Por exemplo, o seguinteinclui uma dependência para o Amazon Kinesis.
...dependencies { ... implementation 'software.amazon.awssdk:kinesis' ...
11
AWS SDK para Java versão 2 Guia do desenvolvedorUsar o SDK com o Gradle
}
O Gradle resolve automaticamente a versão correta das dependências do SDK usando as informações daBOM.
Veja a seguir um exemplo de um arquivo build.gradle completo que inclui uma dependência para oKinesis.
group 'aws.test'version '1.0'
apply plugin: 'java'
sourceCompatibility = 1.8
repositories { mavenCentral()}
dependencies { implementation platform('software.amazon.awssdk:bom:2.X.X') implementation 'software.amazon.awssdk:kinesis' testImplementation group: 'junit', name: 'junit', version: '4.11'}
Note
No exemplo anterior, substitua a dependência para o Kinesis pelas dependências dos serviços daAWS que você usará no seu projeto. Os módulos (dependências) que são gerenciados pela BOMdo AWS SDK for Java estão listados no repositório central do Maven (https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest).
Para obter mais informações sobre como especificar dependências do SDK usando a BOM, consulte Usaro SDK com o Apache Maven (p. 8).
12
AWS SDK para Java versão 2 Guia do desenvolvedorCriar clientes de serviço
Usar o AWS SDK para Java 2.0Esta seção fornece informações gerais importantes sobre a programação com o AWS SDK for Java que seaplicam a todos os serviços que você pode usar com o SDK.
Tópicos• Criar clientes de serviço (p. 13)• Fornecer e recuperar credenciais da AWS (p. 14)• Seleção da região da AWS (p. 18)• Configuração do cliente (p. 20)• Programação assíncrona (p. 22)• Programação de HTTP/2 (p. 27)• Processamento de exceções (p. 27)• Registrar chamadas do AWS SDK for Java (p. 28)• Configurar o JVM TTL para pesquisas de nome DNS (p. 31)• Configurar funções do IAM para o Amazon EC2 (Avançado) (p. 32)
Criar clientes de serviçoPara fazer requisições ao Amazon Web Services, você primeiro cria um objeto do cliente de serviço. Naversão 2.x do SDK, você pode criar clientes apenas usando os compiladores de cliente do serviço.
Cada serviço da AWS tem uma interface de serviço com métodos para cada ação na API de serviço.Por exemplo, a interface de serviço do Amazon DynamoDB se chama DynamoDbClient. Cada interfacede serviço tem um método do compilador de fábrica estático que você pode usar para construir umaimplementação da interface de serviço.
Obter um compilador de clientePara obter uma instância do cliente, use o método de fábrica estático builder. Em seguida, personalize-ausando os setters no compilador, conforme mostrado no exemplo a seguir.
No AWS SDK for Java 2.0, os setters são nomeados sem o prefixo with.
DynamoDbClient client = DynamoDbClient.builder() .region(Region.US_WEST_2) .credentialsProvider(ProfileCredentialsProvider.builder() .profileName("myProfile") .build()) .build();
Note
Os métodos setter fluentes retornam o objeto builder, de maneira que você possa vincularas chamadas ao método por conveniência e obter um código mais legível. Depois de configuraras propriedades desejadas, você poderá chamar o método build para criar o cliente. A partir
13
AWS SDK para Java versão 2 Guia do desenvolvedorUsar DefaultClient
do momento que o cliente é criado, ele será imutável. A única maneira de criar um cliente comdiferentes configurações é compilar um novo cliente.
Usar DefaultClientOs compiladores de cliente têm outro método de fábrica chamado create. Esse método cria um cliente deserviço com a configuração padrão. Ele usa a cadeia de fornecedores padrão para carregar as credenciaise a região da AWS. Se as credenciais ou a região não puderem ser determinadas pelo ambiente no qual oaplicativo estiver em execução, a chamada a create falhará. Consulte Fornecer e recuperar credenciaisda AWS (p. 14) e Seleção da região da AWS (p. 18) para obter mais informações sobre como ascredenciais e a região são determinadas.
Para criar um cliente padrãoDynamoDbClient client = DynamoDbClient.create();
Ciclo de vida do clienteOs clientes de serviço no SDK devem ser livres de thread. Para obter uma melhor performance, trate-oscomo objetos de longa duração. Cada cliente tem o próprio recurso do grupo de conexões, que é liberadoquando o lixo do cliente é coletado. Os clientes no AWS SDK for Java 2.0 agora estendem a interface doAutoClosable. Para obter melhores práticas, explicitamente feche um cliente chamando o método close.
Para fechar um clienteDynamoDbClient client = DynamoDbClient.create();client.close();
Fornecer e recuperar credenciais da AWSPara fazer solicitações à Amazon Web Services (AWS), é necessário fornecer as credenciais da AWS aoAWS SDK for Java. Isso pode ser feito usando um dos seguintes métodos:
• Use a cadeia de fornecedores de credenciais padrão (recomendado).• Use um provedor de credenciais ou uma cadeia de fornecedores.• Forneça as credenciais explicitamente.
Cada um desses métodos é descrito nas seções a seguir.
Usar a cadeia de fornecedores de credenciais padrãoQuando você inicializa um novo cliente de serviço sem fornecer argumentos, o AWS SDK for Java tentaencontrar as credenciais da AWS. Ele usa a cadeia de fornecedores de credenciais padrão implementadapela classe DefaultCredentialsProvider.
O exemplo a seguir cria um novo cliente de serviço que usa a cadeia de fornecedores de credenciaispadrão:
S3Client s3 = S3Client.builder() .region(Region.US_WEST_2)
14
AWS SDK para Java versão 2 Guia do desenvolvedorUsar a cadeia de fornecedores de credenciais padrão
.build();
Ordem de recuperação de credenciaisÉ possível usar uma técnica de recuperação de credenciais com suporte para recuperar as credenciaisnecessárias para executar operações da AWS. Por exemplo, o código Java a seguir mostra como criar umobjeto DynamoDbClient usando um objeto EnvironmentVariableCredentialsProvider.
Region region = Region.US_WEST_2;DynamoDbClient ddb = DynamoDbClient.builder() .region(region) .credentialsProvider(EnvironmentVariableCredentialsProvider.create()) .build();
A lista a seguir mostra as técnicas de recuperação de credenciais com suporte:
1. Propriedades do sistema Java–aws.accessKeyId e aws.secretAccessKey. O AWS SDK for Javausa a classe SystemPropertyCredentialsProvider para carregar essas credenciais.
2. Variáveis de ambiente–AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY. O AWS SDK for Java usaa classe EnvironmentVariableCredentialsProvider para carregar essas credenciais.
3. O arquivo de perfis de credencial padrão – o local específico desse arquivo pode variar de acordocom a plataforma, mas normalmente está localizado em ~/.aws/credentials. Este arquivoé compartilhado por muitos AWS SDKs e pela CLI da AWS. O AWS SDK for Java usa a classeProfileCredentialsProvider para carregar essas credenciais.
Você pode criar um arquivo de credenciais usando o comando aws configure fornecido pela CLIda AWS. Também é possível criá-lo ao editar o arquivo com um editor de texto. Para obter maisinformações sobre o formato do arquivo de credenciais, consulte Formato do arquivo de credenciais daAWS (p. 16).
4. Credenciais de contêiner do Amazon ECS – serão carregadas do Amazon ECS se a variável deambiente AWS_CONTAINER_CREDENTIALS_RELATIVE_URI estiver definida. O AWS SDK for Java usaa classe ContainerCredentialsProvider para carregar essas credenciais.
5. Credenciais de perfil de instância – são usadas em instâncias do Amazon EC2 edistribuídas pelo serviço de metadados do Amazon EC2. O AWS SDK for Java usa a classeInstanceProfileCredentialsProvider para carregar essas credenciais.
Definir credenciaisPara usar credenciais da AWS, forneça-as em pelo menos um dos locais anteriores. Para obterinformações sobre como configurar credenciais, consulte os seguintes tópicos:
• Para fornecer credenciais no ambiente ou no arquivo de perfis de credencial padrão, consulte Configuraras credenciais e a região da AWS para desenvolvimento (p. 5).
• Para definir as propriedades de sistema do Java, consulte o tutorial Propriedades do sistema no siteTutoriais do Java oficial.
• Para configurar e usar as credenciais de perfil da instância com as instâncias do EC2, consulte o arquivopara configurar funções do IAM para o Amazon EC2 (avançado) (p. 32).
Configurar um perfil de credenciais alternativoO AWS SDK for Java usa o perfil padrão, mas existem maneiras de personalizar qual perfil se origina doarquivo de credenciais.
Você pode usar a variável de ambiente AWS_PROFILE para alterar o perfil carregado pelo SDK.
15
AWS SDK para Java versão 2 Guia do desenvolvedorUsar a cadeia de fornecedores de credenciais padrão
Por exemplo, no Linux, macOS, or Unix, execute o comando a seguir a fim de alterar o perfil paramyProfile.
export AWS_PROFILE="myProfile"
No Windows, execute o comando a seguir.
set AWS_PROFILE="myProfile"
Configurar a variável de ambiente AWS_PROFILE afeta o carregamento da credencial em todos osAWS SDKs e ferramentas compatíveis oficialmente, por exemplo, a CLI da AWS e o AWS Tools paraPowerShell. Para alterar somente o perfil de um aplicativo Java, use a propriedade do sistema aws.profileem seu lugar.
Configurar um local de arquivo de credenciais alternativoO AWS SDK for Java carrega credenciais da AWS automaticamente do local de arquivo de credenciaispadrão. No entanto, você também pode especificar o local configurando a variável de ambienteAWS_CREDENTIAL_PROFILES_FILE com o caminho completo para o arquivo de credenciais.
É possível usar esse recurso para alterar temporariamente o local em que o AWS SDK for Java procuraseu arquivo de credenciais. Por exemplo, defina essa variável com a linha de comando. Tambémé possível definir a variável de ambiente no ambiente do usuário ou do sistema a fim de alterá-laespecificamente para o usuário ou em todo o sistema.
Para substituir o local do arquivo de credenciais padrão
• Defina a variável de ambiente AWS_CREDENTIAL_PROFILES_FILE como o local do arquivo decredenciais da AWS.• Em Linux, macOS, or Unix use export :
export AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
• No Windows, use set :
set AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
Formato do arquivo de credenciais da AWSQuando você usa o comando aws configure para criar um arquivo de credenciais da AWS, o comandocria um arquivo com o formato a seguir.
[default]aws_access_key_id={YOUR_ACCESS_KEY_ID}aws_secret_access_key={YOUR_SECRET_ACCESS_KEY}
[profile2]aws_access_key_id={YOUR_ACCESS_KEY_ID}aws_secret_access_key={YOUR_SECRET_ACCESS_KEY}
O nome do perfil é especificado entre colchetes (por exemplo, [default]), seguido dos camposconfiguráveis nesse perfil como pares de chave/valor. Você pode ter vários perfis no seu arquivode credenciais. É possível adicionar ou editar os perfis usando aws configure --profilePROFILE_NAME para selecionar o perfil a ser configurado. Além da chave de acesso e chaves de acessosecretas, você pode especificar um token de sessão usando o campo aws_session_token.
16
AWS SDK para Java versão 2 Guia do desenvolvedorUsar um provedor de credenciaisou uma cadeia de fornecedores
Usar um provedor de credenciais ou uma cadeia defornecedoresVocê pode usar um provedor de credenciais diferente da cadeia de fornecedores de credenciais padrãousando o compilador de cliente.
Você fornece uma instância de um provedor de credenciais ou uma cadeia de fornecedores para umcompilador de cliente que utiliza uma interface AWSCredentialsProvider como entrada.
O exemplo a seguir cria um novo cliente de serviço que usa as credenciais de ambiente fornecidas,chamadas EnvironmentVariableCredentialsProvider:
S3Client s3 = S3Client.builder() .credentialsProvider(EnvironmentVariableCredentialsProvider.create()) .build();
Para obter a lista completa de cadeias de fornecedores e fornecedores de credenciais do AWS SDK forJava, consulte Todas as classes de implementação conhecidas em AWSCredentialsProvider.
Note
Forneça provedores de credenciais ou cadeias de fornecedores criadas por você usando seupróprio fornecedor de credenciais que implementa a interface AwsCredentialsProvider.
Fornecer credenciais explicitamenteSe a cadeia de credenciais padrão, um provedor personalizado ou específico ou a cadeia de fornecedoresnão funcionar para o código, você poderá fornecer as credenciais que desejar. Elas podem ser credenciaisda conta da AWS, credenciais do IAM ou credenciais temporárias recuperadas do AWS Security TokenService (AWS STS). Se você tiver recuperado credenciais temporárias usando o AWS STS, use essemétodo para especificar as credenciais para acesso à AWS.
Important
Por questões de segurança, é altamente recomendado que você utilize as credenciais da contado IAM em vez das credenciais da conta da AWS para acessar. Para obter mais informações,consulte Credenciais de segurança da AWS na Amazon Web Services General Reference.
Para fornecer credenciais explicitamente a um cliente da AWS
1. Instancie uma classe que forneça a interface AwsCredentials, como AwsSessionCredentials. Forneçaa chave de acesso e a chave secreta da AWS que serão usadas para a conexão.
2. Crie um StaticCredentialsProvider com o objeto AwsCredentials.3. Configure o compilador de cliente com o StaticCredentialsProvider e compilar o cliente.
O exemplo a seguir cria um novo cliente de serviço que usa as credenciais fornecidas:
AwsSessionCredentials awsCreds = AwsSessionCredentials.create( "your_access_key_id_here", "your_secret_key_id_here", "your_session_token_here");
S3Client s32 = S3Client.builder() .credentialsProvider(StaticCredentialsProvider.create(awsCreds)) .build();
17
AWS SDK para Java versão 2 Guia do desenvolvedorSeleção da região da AWS
Seleção da região da AWSAs regiões permitem acessar os serviços da AWS que residam fisicamente em uma área geográficaespecífica. Isso pode ser útil para redundância e para manter seus dados e aplicativos em execuçãopróximo ao lugar onde você e os usuários os acessarão.
No AWS SDK for Java 2.0, todas as diferentes classes relacionadas a região da versão 1.x foramrecolhidas em uma classe de região. Você pode usar essa classe para todas as ações relacionadas aregião, como recuperar metadados sobre uma região ou verificar se um serviço está disponível em umaregião.
Escolher uma regiãoVocê pode especificar o nome de uma região, e o SDK escolherá automaticamente um endpointapropriado.
Para definir explicitamente uma região, recomendamos que você use as constantes definidas na classeRegion. Esta é uma enumeração de todas as regiões disponíveis publicamente. Para criar um cliente comuma região da classe, use o código a seguir.
Ec2Client ec2 = Ec2Client.builder() .region(Region.US_WEST_2) .build();
Se a região que você está tentando usar não for uma das constantes na classe Region, você poderá criaruma região usando o método of. Esse recurso permite que você acesse as novas regiões sem atualizar oSDK.
Region newRegion = Region.of("us-east-42");Ec2Client ec2 = Ec2Client.builder() .region(newRegion) .build();
Note
Depois que você compilar um cliente com o compilador, ele será imutável, e a região não poderáser alterada. Se estiver trabalhando com várias regiões da AWS para o mesmo serviço, vocêdeverá criar vários clientes — uma por região.
Escolher um endpoint específicoCada cliente da AWS pode ser configurado para usar um endpoint específico dentro de uma regiãochamando o método endpointOverride.
Por exemplo, para configurar o cliente do Amazon EC2 a fim de usar o Região da Europa (Irlanda), use ocódigo a seguir.
Ec2Client ec2 = Ec2Client.builder() .region(Region.EU_WEST_1) .endpointOverride(URI.create("https://ec2.eu-west-1.amazonaws.com")) .build();
Consulte Regiões e endpoints para obter a lista atual de regiões e os endpoints correspondentes de todosos serviços da AWS.
18
AWS SDK para Java versão 2 Guia do desenvolvedorDeterminar automaticamente aregião da AWS pelo ambiente
Determinar automaticamente a região da AWS peloambienteAo executar no Amazon EC2 ou no AWS Lambda, você pode configurar os clientes para usar a mesmaregião na qual o código está em execução. Isso desvincula o código do ambiente no qual está emexecução e facilita ainda mais a implantação do aplicativo em várias regiões tendo em vista menos latênciaou redundância.
Para usar a cadeia de provedores de credencial/região padrão a fim de determinar a região do ambiente,use o método create do compilador de cliente.
Ec2Client ec2 = Ec2Client.create();
Se você não definir explicitamente uma região usando o método region, o SDK consultará a cadeia defornecedores da região padrão para tentar e determinar a região a ser usada.
Cadeia de fornecedores da região padrãoEste é o processo de pesquisa da região:
1. Qualquer região explícita definida usando-se region no compilador propriamente dito tem precedênciasobre todo o resto.
2. A variável de ambiente AWS_REGION está marcada. Se estiver definida, essa região será usada paraconfigurar o cliente.
Note
Essa variável de ambiente é definida pelo contêiner do Lambda.3. O SDK verifica o arquivo de configuração compartilhado da AWS (normalmente localizado em ~/.aws/
config). Se a propriedade da região estiver presente, o SDK a usará.• A variável de ambiente AWS_CONFIG_FILE pode ser usada para personalizar o local do arquivo de
configuração compartilhado.• A variável de ambiente AWS_PROFILE ou a propriedade do sistema aws.profile podem ser usadas
para personalizar o perfil que o SDK carrega.4. O SDK tentar usar o serviço de metadados da instância do Amazon EC2 para determinar a região da
instância do Amazon EC2 em execução no momento.5. Se o SDK ainda não tiver encontrado uma região a esta altura, a criação do cliente falhará com uma
exceção.
Durante o desenvolvimento de aplicativos da AWS, uma abordagem comum é usar o arquivo deconfiguração compartilhado (descrito em Usar a cadeia de fornecedores de credenciais padrão (p. 14))a fim de definir a região para o desenvolvimento local e contar com a cadeia de fornecedores da regiãopadrão para determinar a região durante a execução na infraestrutura da AWS. Isso simplifica muito acriação do cliente e mantém a portabilidade do aplicativo.
Verificar disponibilidade do serviço em uma região daAWSPara saber se um serviço da AWS específico está disponível em uma região, use o métodoserviceMetadata e region no serviço que você gostaria de verificar.
DynamoDbClient.serviceMetadata().regions().forEach(System.out::println);
19
AWS SDK para Java versão 2 Guia do desenvolvedorConfiguração do cliente
Consulte a documentação da classe Region das regiões que você pode especificar, e use o prefixo deendpoint do serviço a ser consultado.
Configuração do clienteO AWS SDK for Java permite alterar a configuração do cliente padrão. Isso pode ser útil quando vocêdeseja especificar configurações como as do transporte HTTP. Esta seção fornece informações sobrecomo definir essas configurações.
Tópicos• Configuração do transporte HTTP (p. 20)• Otimize o desempenho de inicialização a frio para o AWS Lambda (p. 21)
Configuração do transporte HTTPVocê pode usar o NettyNioAsyncHttpClient para clientes assíncronos ou o ApacheHttpClient para clientessíncronos para definir as configurações do transporte HTTP. Para obter uma lista completa de opções quevocê pode definir com esses clientes, consulte a Referência de API do AWS SDK para Java 2.x.
Note
Para obter mais informações sobre o Apache HTTPClient, consulte Visão geral do HttpClient.
Adicione uma dependência no netty-nio-client no POM para usar o NettyNioAsyncHttpClient.
Entrada POM
<dependency> <artifactId>netty-nio-client</artifactId> <groupId>software.amazon.awssdk</groupId> <version>2.0.0</version></dependency>
Conexões máximasVocê pode definir o número máximo permitido de conexões HTTP abertas usando o métodomaxConcurrency. O método maxPendingConnectionAcquires permite definir as solicitaçõesmáximas permitidas a serem colocadas na fila quando a simultaneidade máxima for atingida.
• Padrão para maxConcurrency: 50• Padrão para maxPendingConnectionAcquires: 10_000
Important
Defina o número máximo de conexões para o número de transações simultâneas de modo aevitar disputas de conexão e baixo desempenho.
Use o criador de cliente HTTP para que o SDK gerencie o ciclo de vida. O cliente HTTP será fechadoquando o serviço do cliente for desligado.
Importações
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
20
AWS SDK para Java versão 2 Guia do desenvolvedorOtimize o desempenho de inicialização
a frio para o AWS Lambda
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;import software.amazon.awssdk.services.kinesis.KinesisAsyncClient;
Código
KinesisAsyncClient client = KinesisAsyncClient.builder() .httpClientBuilder(NettyNioAsyncHttpClient.builder() .maxConcurrency(100) .maxPendingConnectionAcquires(10_000)) .build();
Você também poderá transmitir o cliente HTTP diretamente para o cliente do serviço se quiser gerenciar ociclo de vida por conta própria.
Código
SdkAsyncHttpClient httpClient = NettyNioAsyncHttpClient.builder() .maxConcurrency(100) .maxPendingConnectionAcquires(10_000) .build();
KinesisAsyncClient kinesisClient = KinesisAsyncClient.builder() .httpClient(httpClient) .build();
httpClient.close();
Otimize o desempenho de inicialização a frio para oAWS LambdaEntre as melhorias no AWS SDK for Java 2.0, há o tempo de inicialização a frio do SDK para funções emJava no Lambda. Este é o tempo necessário para uma função em Java do Lambda inicializar e responderà sua primeira solicitação.
A versão 2.x inclui três alterações principais que contribuem para essa melhoria:
• Uso de jackson-jr, que é uma biblioteca de serialização que melhora o tempo de inicialização.• Uso de bibliotecas java.time para objetos de data e hora.• Uso de Slf4j para uma fachada de registro em log.
Você pode obter uma melhoria de tempo de inicialização do SDK adicional ao definir valores deconfiguração específicos no criador do cliente. Eles economizam tempo durante a inicialização ao reduzir aquantidade de informações que o seu aplicativo precisa encontrar para inicializar.
No compilador de cliente, especifique uma região, use o provedor de credenciais de Variável de ambientee especifique UrlConnectionClient como o httpClient. Veja o trecho de código abaixo para obter umexemplo.
• O processo de pesquisa de região para o SDK leva tempo. Ao especificar uma região, é possíveleconomizar até 80 ms de tempo de inicialização.
Note
Ao especificar uma região da AWS, o código não será executado em outras regiões semmodificação.
21
AWS SDK para Java versão 2 Guia do desenvolvedorProgramação assíncrona
• O processo que o SDK usa para procurar credenciais pode levar até 90 ms. Usando oEnvironmentVariableCredentialsProvider
Note
O uso deste provedor de credenciais permite que o código seja usado em funções do Lambda,mas pode não funcionar no Amazon EC2 ou em outros sistemas.
• O tempo de instanciação da biblioteca do JDK URLConnection é muito menor que o tempo do ApacheHTTP Client ou Netty. É possível economizar até 1 segundo usando este cliente HTTP.
Exemplo de configuração do clienteS3Client client = S3Client.builder() .region(Region.US_WEST_2) .credentialsProvider(EnvironmentVariableCredentialsProvider.create()) .httpClient(UrlConnectionHttpClient.builder().build()) .build();
Programação assíncronaO AWS SDK for Java 2.0 inclui clientes realmente assíncronos sem bloqueio que implementam altasimultaneidade em alguns threads. O AWS SDK for Java 1.11.x tem clientes assíncronos que sãowrappers em torno de um grupo de threads e clientes síncronos com bloqueio que não oferecem obenefício completo de E/S sem bloqueio.
Os métodos síncronos bloqueiam a execução do seu thread até o cliente receber uma resposta do serviço.Os métodos assíncronos retornam imediatamente, devolvendo o controle ao thread de chamada semaguardar uma resposta.
Como um método assíncrono retorna antes de uma resposta estar disponível, você precisa de umamaneira de obter a resposta quando ela estiver pronta. Os métodos de cliente assíncrono do AWS SDKfor Java 2.0 retornam objetos CompletableFuture que permitem que você acesse a resposta quando elaestiver pronta.
Operação sem streamingPara as operações que não são de streaming, as chamadas de método assíncrono são semelhantesaos métodos síncronos. No entanto, os métodos assíncronos no AWS SDK for Java retornam um objetoCompletableFuture que contém os resultados da operação assíncrona no futuro.
Chame o método CompletableFuture whenComplete() com uma ação a ser concluída quando oresultado estiver disponível. CompletableFuture implementa a interface Future para que você possaobter o objeto de resposta chamando o método get() também.
Veja a seguir um exemplo de uma operação assíncrona que chama uma função do Amazon DynamoDBpara obter uma lista de tabelas, recebendo um CompletableFuture capaz de manter um objetoListTablesResponse. A ação definida na chamada para whenComplete() é feita somente quando achamada assíncrona é concluída.
Importações
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;
22
AWS SDK para Java versão 2 Guia do desenvolvedorOperação sem streaming
import software.amazon.awssdk.utils.FunctionalUtils;
import java.util.List;import java.util.concurrent.CompletableFuture;
Código
public class DynamoDBAsync {
public static void main(String[] args) throws InterruptedException { // Creates a default async client with credentials and regions loaded from the environment DynamoDbAsyncClient client = DynamoDbAsyncClient.create(); CompletableFuture<ListTablesResponse> response = client.listTables(ListTablesRequest.builder() .build());
// Map the response to another CompletableFuture containing just the table names CompletableFuture<List<String>> tableNames = response.thenApply(ListTablesResponse::tableNames); // When future is complete (either successfully or in error) handle the response tableNames.whenComplete((tables, err) -> { try { if (tables != null) { tables.forEach(System.out::println); } else { // Handle error err.printStackTrace(); } } finally { // Lets the application shut down. Only close the client when you are completely done with it. client.close(); } });
tableNames.join(); }}
O exemplo de código a seguir mostra como recuperar um item de uma tabela usando o cliente assíncrono.Invoque o método getItem do DynamoDbAsyncClient e passe um objeto GetItemRequest para ele como nome da tabela e o valor da chave primária do item desejado. Normalmente, é assim que você passadados exigidos pela operação. Neste exemplo, observe que um valor String é passado.
Importações
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;import software.amazon.awssdk.services.dynamodb.model.AttributeValue;import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;import java.util.HashMap;import java.util.Map;import java.util.Set;import java.util.stream.Collectors;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
Código
//Get both input argumentsString tableName = args[0];
23
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de streaming
String name = args[1];System.out.format("Retrieving item \"%s\" from \"%s\"\n", name, tableName );
HashMap<String, AttributeValue> keyToGet = new HashMap<String, AttributeValue>();
keyToGet.put("Name", AttributeValue.builder().s(name).build());
try {
DynamoDbAsyncClient client = DynamoDbAsyncClient.create();
//Create a GetItemRequest instance GetItemRequest request = GetItemRequest.builder() .key(keyToGet) .tableName(tableName) .build();
//Invoke the DynamoDbAsyncClient object's getItem java.util.Collection<software.amazon.awssdk.services.dynamodb.model.AttributeValue> returnedItem = client.getItem(request).join().item().values();
//Convert Set to Map Map<String, AttributeValue> map = returnedItem.stream().collect(Collectors.toMap(AttributeValue::s, s->s)); Set<String> keys = map.keySet(); for (String key : keys) { System.out.format("%s: %s\n", key, map.get(key).toString()); }
} catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1);}
Veja o exemplo completo no GitHub.
Operações de streamingPara operações de streaming, é necessário fornecer um AsyncRequestBody para fornecer o conteúdo deforma incremental ou um AsyncResponseTransformer para receber e processar a resposta.
O exemplo a seguir faz upload de um arquivo para o Amazon S3 de forma assíncrona usando a operaçãoPutObject.
Importações
import software.amazon.awssdk.core.async.AsyncRequestBody;import software.amazon.awssdk.services.s3.S3AsyncClient;import software.amazon.awssdk.services.s3.model.PutObjectRequest;import software.amazon.awssdk.services.s3.model.PutObjectResponse;import software.amazon.awssdk.utils.FunctionalUtils;
import java.nio.file.Paths;import java.util.concurrent.CompletableFuture;
Código
public class S3AsyncOps {
private static final String BUCKET = "sample-bucket";
24
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de streaming
private static final String KEY = "testfile.in";
public static void main(String[] args) { S3AsyncClient client = S3AsyncClient.create(); CompletableFuture<PutObjectResponse> future = client.putObject( PutObjectRequest.builder() .bucket(BUCKET) .key(KEY) .build(), AsyncRequestBody.fromFile(Paths.get("myfile.in")) ); future.whenComplete((resp, err) -> { try { if (resp != null) { System.out.println("my response: " + resp); } else { // Handle error err.printStackTrace(); } } finally { // Lets the application shut down. Only close the client when you are completely done with it. client.close(); } });
future.join(); }}
O exemplo a seguir obtém um arquivo do Amazon S3 de forma assíncrona usando a operaçãoGetObject.
Importações
import software.amazon.awssdk.core.async.AsyncResponseTransformer;import software.amazon.awssdk.services.s3.S3AsyncClient;import software.amazon.awssdk.services.s3.model.GetObjectRequest;import software.amazon.awssdk.services.s3.model.GetObjectResponse;import java.nio.file.Paths;import java.util.concurrent.CompletableFuture;
Código
public class S3AsyncStreamOps {
public static void main(String[] args) {
final String USAGE = "\n" + "Usage:\n" + " S3AsyncOps <bucketname> <objectname> <path>\n\n" + "Where:\n" + " bucketname - the name of the bucket (i.e., bucket1)\n\n" + " objectname - the name pf the object object (i.e., book.pdf)\n" + " path - the local path to the file (i.e., C:\\AWS\\book.pdf)\n" + "Example:\n" + " bucket1 book.pdf C:\\AWS\\book.pdf\n";
String bucketName = args[0]; String objectKey = args[1]; String path = args[2];
25
AWS SDK para Java versão 2 Guia do desenvolvedorOperações avançadas
S3AsyncClient client = S3AsyncClient.create(); final CompletableFuture<GetObjectResponse> futureGet = client.getObject( GetObjectRequest.builder() .bucket(bucketName) .key(objectKey) .build(), AsyncResponseTransformer.toFile(Paths.get(path))); futureGet.whenComplete((resp, err) -> { try { if (resp != null) { System.out.println(resp); } else { // Handle error err.printStackTrace(); } } finally { // Lets the application shut down. Only close the client when you are completely done with it client.close(); } });
futureGet.join(); }}
Operações avançadasO AWS SDK for Java 2.0 usa Netty, uma estrutura de aplicativo de rede assíncrona orientada a eventos,para lidar com threads de E/S. O AWS SDK for Java 2.0 cria um ExecutorService por trás da Netty,para concluir os futuros retornados da solicitação do cliente HTTP até o cliente Netty. Essa abstraçãoreduz o risco de um aplicativo quebrar o processo assíncrono se os desenvolvedores optarem porinterromper ou suspender threads. Por padrão, 50 threads são gerados para cada cliente assíncrono egerenciados em uma fila no ExecutorService.
Os usuários avançados podem especificar o tamanho do grupo de threads ao criar um cliente assíncronousando a opção a seguir durante a compilação.
Código
S3AsyncClient clientThread = S3AsyncClient.builder() .asyncConfiguration( b -> b.advancedOption(SdkAdvancedAsyncClientOption .FUTURE_COMPLETION_EXECUTOR, Executors.newFixedThreadPool(10) ) ) .build();
Para otimizar o desempenho, você pode gerenciar seu próprio executor de grupo de threads e incluí-lo aoconfigurar seu cliente.
ThreadPoolExecutor executor = new ThreadPoolExecutor(50, 50, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10_000), new ThreadFactoryBuilder() .threadNamePrefix("sdk-async-response").build());
// Allow idle core threads to time outexecutor.allowCoreThreadTimeOut(true);
26
AWS SDK para Java versão 2 Guia do desenvolvedorProgramação de HTTP/2
S3AsyncClient clientThread = S3AsyncClient.builder() .asyncConfiguration( b -> b.advancedOption(SdkAdvancedAsyncClientOption .FUTURE_COMPLETION_EXECUTOR, executor ) ) .build();
Se preferir não usar um grupo de threads, use Runnable::run em vez de usar um executor de grupo dethreads.
S3AsyncClient clientThread = S3AsyncClient.builder() .asyncConfiguration( b -> b.advancedOption(SdkAdvancedAsyncClientOption .FUTURE_COMPLETION_EXECUTOR, Runnable::run ) ) .build();
Programação de HTTP/2HTTP/2 é uma grande revisão do protocolo HTTP. Esta nova versão tem vários aprimoramentos paramelhorar o desempenho:
• A codificação de dados binários proporciona uma transferência de dados mais eficiente.• A compactação de cabeçalho reduz a sobrecarga de bytes baixados pelo cliente, ajudando a obter
o conteúdo para o cliente mais cedo. Isso é especialmente útil para clientes móveis que já tenhamrestrição na largura de banda.
• A comunicação assíncrona bidirecional (multiplexação) permite que várias solicitações e mensagensde respostas entre o cliente e a AWS estejam em andamento ao mesmo tempo por meio de uma únicaconexão, em vez de várias conexões, o que melhora o desempenho.
Os desenvolvedores atualizando para os SDKs mais recentes usarão automaticamente HTTP/2 quandoele for compatível com o serviço com que estiverem trabalhando. Novas interfaces de programaçãoaproveitam perfeitamente os recursos do HTTP/2 e fornecem novas maneiras de criar aplicativos.
O AWS SDK for Java 2.0 apresenta novas APIs para o streaming de eventos que implementam o protocoloHTTP/2. Para obter exemplos de como usar essas novas APIs, consulte Exemplos do Kinesis usando oAWS SDK para Java (p. 98).
Processamento de exceçõesCompreender como e quando o AWS SDK for Java lança exceções é importante para compilar aplicativosde alta qualidade usando o SDK. As seções a seguir descrevem os casos diferentes de exceções lançadaspelo SDK e como processá-las da maneira apropriada.
Por que exceções desmarcadas?O AWS SDK for Java usa exceções de tempo de execução (ou desmarcadas), em vez de exceçõesmarcadas por estes motivos:
27
AWS SDK para Java versão 2 Guia do desenvolvedorSdkServiceException (e subclasses)
• Como permitir que desenvolvedores controlem os erros que desejam processar sem forçá-los aprocessar casos excepcionais com os quais não estão preocupados (e tornar o código excessivamentedetalhado)
• Para evitar problemas de escalabilidade inerentes a exceções marcadas em aplicativos grandes
Em geral, as exceções marcadas funcionam bem em escalas pequenas, mas podem se tornarproblemáticas à medida que os aplicativos crescem e se tornam mais complexos.
SdkServiceException (e subclasses)SdkServiceException é a exceção mais comum que você enfrentará ao usar o AWS SDK for Java. Essaexceção representa uma resposta de erro de um serviço da AWS. Por exemplo, se você tentar encerraruma instância do Amazon EC2 que não existe, o EC2 retornará uma resposta de erro, e todos os detalhesdessa resposta de erro serão incluídos no SdkServiceException lançado. Para alguns casos, umasubclasse de SdkServiceException é lançada para permitir que os desenvolvedores controlem casosde erro por meio de blocos catch.
Ao encontrar um SdkServiceException, você sabe que a requisição foi enviada com êxito parao serviço da AWS, mas não foi possível processá-la com êxito. Isso pode ocorrer devido a erros nosparâmetros da solicitação ou problemas no lado do serviço.
SdkServiceException fornece informações como:
• Código de status HTTP retornado• Código de erro da AWS retornado• Mensagem de erro detalhada do serviço• ID de requisição da AWS para a requisição com falha
SdkClientExceptionSdkClientException indica que um problema ocorreu dentro do código cliente do Java, durante a tentativade enviar uma requisição para a AWS ou durante a tentativa de analisar uma resposta da AWS. UmSdkClientException normalmente é mais grave do que um SdkServiceException, e indica umproblema grave que esteja evitando que o cliente faça chamadas de serviço para serviços da AWS. Porexemplo, o AWS SDK for Java lançará um SdkClientException se nenhuma conexão de rede estiverdisponível quando você tentar chamar uma operação em um dos clientes.
Registrar chamadas do AWS SDK for JavaO AWS SDK for Java é instrumentalizado com o Slf4j, que é uma camada de abstração que permite o usode qualquer um dos diversos sistemas de registro em log em tempo de execução.
Entre os sistemas de registro em log compatíveis estão o Java Logging Framework e o Apache Log4j,entre outros. Este tópico mostra como usar o Log4j. Você pode usar a funcionalidade de registro em log doSDK sem fazer alterações no código do aplicativo.
Para saber mais sobre o Log4j, consulte o site do Apache.
Adicionar o Log4J JARPara usar o Log4j com o SDK, você precisa fazer download do Log4j JAR no site do Log4j ou usar oMaven, adicionando uma dependência do Log4j no arquivo pom.xml. O SDK não inclui o JAR.
28
AWS SDK para Java versão 2 Guia do desenvolvedorArquivo de configuração do Log4j
Arquivo de configuração do Log4jO Log4j usa um arquivo de configuração, o log4j2.xml. Os arquivos de configuração de exemplo sãomostrados abaixo. Para saber mais sobre os valores usados no arquivo de configuração, consulte omanual de configuração do Log4j.
Coloque seu arquivo de configuração em um diretório no classpath. O Log4j JAR e o arquivo log4j2.xmlnão precisam estar no mesmo diretório.
O arquivo de configuração log4j2.xml especifica propriedades como nível de registro em log, em que asaída do registro em log é enviada (por exemplo, para um arquivo ou para o console) e o formato da saída.O nível de registro em log é a granularidade de saída gerada pelo registrador em log. O Log4j dá suporteao conceito de várias hierarquias de registro em log. O nível de registro em log é definido de maneiraindependente para cada hierarquia. As duas seguintes hierarquias de registro em log estão disponíveis noAWS SDK for Java:
• software.amazon.awssdk• org.apache.http.wire
Definir o classpathO Log4j JAR e o arquivo log4j2.xml devem estar localizados em seu classpath. Para configurar avinculação log4j para Sl4j no Maven, você pode adicionar o pom.xml a seguir:
<dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-core</artifactId></dependency><dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-api</artifactId></dependency><dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-slf4j-impl</artifactId></dependency>
Se estiver usando o IDE do Eclipse, você poderá definir o classpath abrindo o menu e navegando atéProject (Projeto) | Properties (Propriedades) | Java Build Path.
Erros e avisos específicos do serviçoRecomendamos sempre deixar a hierarquia do registrador em log "software.amazon.awssdk" definidacomo "WARN" para interceptar todas as mensagens importantes das bibliotecas de cliente. Por exemplo,se o cliente do Amazon S3 detectar que o aplicativo não fechou corretamente um InputStream e possaestar vazando recursos, o cliente do S3 informará isso por meio de uma mensagem de aviso para os logs.Isso também garante que as mensagens serão registradas em log se o cliente enfrentar algum problemaao processar requisições ou respostas.
O arquivo log4j2.xml a seguir define o rootLogger como WARN, o que faz com que as mensagens deerro e aviso de todos os registradores em log na hierarquia "software.amazon.awssdk" sejam incluídas.Você também pode definir explicitamente o registrador em log software.amazon.awssdk como WARN.
<Configuration status="WARN"> <Appenders> <Console name="ConsoleAppender" target="SYSTEM_OUT">
29
AWS SDK para Java versão 2 Guia do desenvolvedorRegistro em log do resumo de requisição/resposta
<PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" /> </Console> </Appenders>
<Loggers> <Root level="WARN"> <AppenderRef ref="ConsoleAppender"/> </Root> <Logger name="software.amazon.awssdk" level="WARN" /> </Loggers></Configuration>
Registro em log do resumo de requisição/respostaCada requisição para um serviço da AWS gera um ID de requisição da AWS exclusivo, o que será útil sevocê enfrentar um problema com a maneira como um serviço da AWS processa uma requisição. Os IDsde requisição da AWS estão acessíveis de maneira programática por meio de objetos Exception no SDKem qualquer chamada de serviço com falha, e também podem ser informados por meio do nível de logDEBUG no registrador em log "software.amazon.awssdk".
O arquivo log4j2.xml a seguir permite um resumo de requisições e respostas.
<Configuration status="WARN"> <Appenders> <Console name="ConsoleAppender" target="SYSTEM_OUT"> <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" /> </Console> </Appenders>
<Loggers> <Root level="WARN"> <AppenderRef ref="ConsoleAppender"/> </Root> <Logger name="software.amazon.awssdk" level="WARN" /> <Logger name="software.amazon.awssdk.request" level="DEBUG" /> </Loggers></Configuration>
Aqui está um exemplo da saída do log:
2018-01-28 19:31:56 [main] DEBUG software.amazon.awssdk.request:Logger.java:78 - Sending Request: software.amazon.awssdk.http.DefaultSdkHttpFullRequest@3a80515c
Registro em log detalhadoEm alguns casos, pode ser útil ver as requisições e as respostas exatas enviadas e recebidas peloAWS SDK for Java. Se realmente precisar de acesso a essas informações, você poderá habilitá-lotemporariamente por meio do registrador em log do Apache HttpClient Habilitar o nível DEBUG noregistrador em log apache.http.wire permite o registro em log de todos os dados de requisição eresposta.
Warning
Recomendamos que você use o arquivo de log somente para fins de depuração. Desative-oem seus ambientes de produção, pois ele pode registrar dados confidenciais. Ele registra asolicitação ou resposta completa sem criptografia, até mesmo para uma chamada HTTPS. Paragrandes solicitações (por exemplo, para fazer upload de um arquivo para o Amazon S3) ourespostas, o log detalhado da conexão também pode afetar significativamente o desempenho doaplicativo.
30
AWS SDK para Java versão 2 Guia do desenvolvedorConfigurar o JVM TTL para pesquisas de nome DNS
O arquivo log4j2.xml a seguir ativa o registro em log completo no Apache HttpClient.
<Configuration status="WARN"> <Appenders> <Console name="ConsoleAppender" target="SYSTEM_OUT"> <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" /> </Console> </Appenders>
<Loggers> <Root level="WARN"> <AppenderRef ref="ConsoleAppender"/> </Root> <Logger name="software.amazon.awssdk" level="WARN" /> <Logger name="software.amazon.awssdk.request" level="DEBUG" /> <Logger name="org.apache.http.wire" level="DEBUG" /> </Loggers></Configuration>
Outras dependências do Maven no log4j-1.2-api são necessárias para o arquivo de log com o Apache, poisele usa a 1.2 internamente. Adicione o seguinte ao arquivo pom.xml se você habilitar o arquivo de log.
<dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-1.2-api</artifactId></dependency>
Configurar o JVM TTL para pesquisas de nomeDNS
A JVM armazena em cache pesquisas de nome DNS. Ao resolver um nome de host para um endereço IP,a JVM armazena em cache o endereço IP para um período especificado, conhecido como Time-To-Live(TTL – Tempo de duração).
Como recursos da AWS usam entradas de nome DNS que acabam mudando, recomendamos configurara JVM com um valor TTL de até 60 segundos. Isso garante que, quando o endereço IP de um recursomudar, o aplicativo poderá receber e usar o novo endereço IP do recurso consultando novamente o DNS.
Em algumas configurações do Java, o TTL padrão da JVM é definido de maneira que jamais atualizaráentradas DNS até a JVM ser reiniciada. Por isso, se o endereço IP de um recurso da AWS mudarenquanto o aplicativo ainda estiver em execução, não será possível usar esse recurso até você reiniciarmanualmente a JVM e as informações de IP armazenadas em cache serem atualizadas. Nesse caso, écrucial definir o TTL da JVM, de forma que ele atualize periodicamente as informações de IP armazenadasem cache.
Note
O TTL padrão pode variar de acordo com a versão da JVM e a possibilidade de um gerenciadorde segurança estar instalado. Muitas JVMs oferecem um TTL padrão menor que 60 segundos. Seestiver usando uma JVM como essa, e não um gerenciador de segurança, será possível ignorar orestante deste tópico.
Como definir o TTL da JVMPara modificar o TTL da JVM, defina o valor da propriedade networkaddress.cache.ttl. Use um dosseguintes métodos, dependendo das necessidades:
31
AWS SDK para Java versão 2 Guia do desenvolvedorConfigurar funções do IAM para o Amazon EC2 (Avançado)
• globalmente, para todos os aplicativos que usam a JVM. Defina networkaddress.cache.ttl noarquivo $JAVA_HOME/jre/lib/security/java.security:
networkaddress.cache.ttl=60
• somente para o aplicativo, defina networkaddress.cache.ttl no código de inicialização doaplicativo:
java.security.Security.setProperty("networkaddress.cache.ttl" , "60");
Configurar funções do IAM para o Amazon EC2(Avançado)
Todas as solicitações aos serviços da AWS devem ser assinadas de forma criptográfica usando ascredenciais emitidas pela AWS. Você pode usar funções do IAM para conceder acesso seguro de maneiraprática a recursos da AWS das instâncias do Amazon EC2.
Este tópico fornece informações sobre como usar as funções do IAM com aplicativos do AWS SDK forJava em execução no Amazon EC2. Para obter mais informações sobre instâncias do IAM, consulteFunções do IAM para Amazon EC2 no Amazon EC2 User Guide for Linux Instances.
Cadeia de fornecedores padrão e perfis de instânciado Amazon EC2Se o aplicativo criar um cliente da AWS usando o método create, o cliente vai procurar credenciaisusando a cadeia de fornecedores de credenciais padrão, na ordem a seguir:
1. Nas propriedades do sistema Java: aws.accessKeyId e aws.secretAccessKey.2. Em variáveis de ambiente do sistema: AWS_ACCESS_KEY_ID e AWS_SECRET_ACCESS_KEY.3. No arquivo de credenciais padrão (o local desse arquivo varia de acordo com a plataforma).4. Na variável do ambiente do Amazon ECS: AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.5. Nas credenciais de perfil da instância, que existem dentro dos metadados da instância associados à
função do IAM para a instância do EC2.
A etapa final na cadeia de fornecedores padrão está disponível somente durante a execução do aplicativoem uma instância do Amazon EC2. No entanto, ele proporciona a maior facilidade de uso e a melhorsegurança durante o trabalho com instâncias do Amazon EC2. Você também pode passar uma instânciaInstanceProfileCredentialsProvider diretamente para o construtor cliente para obter as credenciais do perfilda instância sem avançar em toda a cadeia de fornecedores padrão.
Por exemplo:
S3Client s3 = S3Client.builder() .credentialsProvider(InstanceProfileCredentialsProvider.builder().build()) .build();
Quando você usa essa abordagem, o SDK recupera credenciais temporárias da AWS que tenhamas mesmas permissões das associadas à função do IAM que está associada à instância do AmazonEC2 no perfil da instância. Embora essas credenciais sejam temporárias e acabem expirando, o
32
AWS SDK para Java versão 2 Guia do desenvolvedorDemonstração: usar funções do
IAM em instâncias do Amazon EC2
InstanceProfileCredentialsProvider as atualiza periodicamente para você, de maneira que ascredenciais obtidas continuem permitindo o acesso à AWS.
Demonstração: usar funções do IAM em instâncias doAmazon EC2Esta demonstração mostra como recuperar um objeto do Amazon S3 usando uma função do IAM paragerenciar acesso.
Criar uma função do IAMCrie uma função do IAM que conceda acesso somente leitura ao Amazon S3.
Para criar a função do IAM
1. Abra o console do IAM.2. No painel de navegação, escolha Roles (Funções), Create New Role (Criar nova função).3. Na página Select Role Type (Selecionar tipo de função), em AWS Service Roles (Funções do serviço
da AWS), selecione Amazon EC2.4. Na página Attach Policy (Anexar política), escolha Amazon S3 Read Only Access (Acesso somente
leitura) e depois Next Step (Próxima etapa).5. Insira um nome para a função e selecione Next Step (Próxima etapa). Lembre-se deste nome,
pois será necessário ao executar sua instância do Amazon EC2.6. Na página Revisar, selecione Criar função.
Iniciar uma instância do EC2 e especificar a função do IAMVocê pode ativar uma instância do Amazon EC2 com uma função do IAM usando o console do AmazonEC2.
Para ativar uma instância do Amazon EC2 usando o console, siga as orientações em Conceitos básicosdas instâncias do Linux do Amazon EC2 no Amazon EC2 User Guide for Linux Instances.
Quando você chegar à página Review Instance Launch (Revisar ativação da instância), selecione Editinstance details (Editar detalhes da instância). Em IAM role (Função do IAM), escolha a função do IAMcriada por você anteriormente. Conclua o procedimento conforme indicado.
Note
Você precisará criar ou usar um grupo de segurança e par de chaves para se conectar àinstância.
Com essa configuração do IAM e do Amazon EC2, você pode implantar o aplicativo na instância do EC2 eter acesso de leitura ao serviço do Amazon S3.
33
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon CloudWatch
Exemplos de código do AWS SDK forJava 2.0
Esta seção fornece exemplos de programação usando o AWS SDK for Java 2.0 que se aplica a casos deuso específicos.
Encontre o código-fonte para esses exemplos e outros no repositório de exemplos de código no GitHub dadocumentação da AWS.
Para sugerir um novo exemplo de código para a equipe de documentação da AWS considerar a produção,crie uma solicitação. A equipe está buscando produzir exemplos de código que abrangem cenários ecasos de uso mais amplos, em vez de trechos de código simples que abrangem apenas chamadas de APIindividuais. Para obter instruções, consulte a seção “Propor novos exemplos de código” no Readme noGitHub.
Tópicos• Exemplos do CloudWatch usando o AWS SDK for Java (p. 34)• Exemplos do Amazon Cognito (p. 44)• Exemplos do DynamoDB usando o AWS SDK for Java (p. 48)• Amazon EC2 Exemplos usando o AWS SDK for Java (p. 67)• Exemplos do IAM usando o AWS SDK for Java (p. 81)• Exemplos do Kinesis usando o AWS SDK for Java (p. 98)• Exemplos do AWS Lambda para o AWS SDK for Java (p. 104)• Exemplos do Amazon Pinpoint (p. 107)• Amazon S3 Exemplos usando o AWS SDK for Java (p. 114)• Trabalhar com URLs pré-assinadas do Amazon S3 (p. 123)• Exemplos do Amazon Simple Notification Service (p. 127)• Amazon SQS Exemplos usando o AWS SDK for Java (p. 131)• Exemplos do Amazon Transcribe usando o AWS SDK for Java (p. 136)• Recuperar resultados paginados (p. 140)
Exemplos do CloudWatch usando o AWS SDK forJava
Esta seção fornece exemplos de como programar o CloudWatch usando o AWS SDK for Java 2.0.
O Amazon CloudWatch monitora seus recursos da Amazon Web Services (AWS) e os aplicativos que vocêexecuta na AWS em tempo real. Você pode usar o CloudWatch para coletar e monitorar métricas, que sãoas variáveis que podem ser medidas para avaliar seus recursos e aplicativos. Os alarmes do CloudWatchenviam notificações ou fazem alterações automaticamente nos recursos que você está monitorando combase nas regras definidas.
Para obter mais informações sobre o CloudWatch, consulte o Guia do usuário do Amazon CloudWatch.
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O códigode exemplo completo está disponível no GitHub. A partir daí, você pode fazer download de um único
34
AWS SDK para Java versão 2 Guia do desenvolvedorObter métricas do CloudWatch
arquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilaçãoe execução.
Tópicos• Obter métricas do CloudWatch (p. 35)• Publicar dados de métrica personalizada (p. 36)• Trabalhar com alarmes do CloudWatch (p. 37)• Use ações de alarme no CloudWatch (p. 40)• Enviar eventos para o CloudWatch (p. 41)
Obter métricas do CloudWatchListar métricasPara listar métricas do CloudWatch, crie um ListMetricsRequest e chame o método listMetrics doCloudWatchClient. Você pode usar o ListMetricsRequest para filtrar as métricas retornadas pornamespace, nome da métrica ou dimensões.
Note
Uma lista de métricas e dimensões publicadas por serviços da AWS pode ser encontrada naReferência de métricas e dimensões do Amazon CloudWatch no Amazon CloudWatch UserGuide.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;import software.amazon.awssdk.services.cloudwatch.model.ListMetricsRequest;import software.amazon.awssdk.services.cloudwatch.model.ListMetricsResponse;import software.amazon.awssdk.services.cloudwatch.model.Metric;
Código
public static void listMets( CloudWatchClient cw, String namespace) {
boolean done = false; String nextToken = null;
while(!done) {
ListMetricsResponse response;
if (nextToken == null) { ListMetricsRequest request = ListMetricsRequest.builder() .namespace(namespace) .build();
response = cw.listMetrics(request); } else { ListMetricsRequest request = ListMetricsRequest.builder() .namespace(namespace) .nextToken(nextToken) .build();
response = cw.listMetrics(request); }
35
AWS SDK para Java versão 2 Guia do desenvolvedorPublicar dados de métrica personalizada
for (Metric metric : response.metrics()) { System.out.printf( "Retrieved metric %s", metric.metricName()); System.out.println(); }
if(response.nextToken() == null) { done = true; } else { nextToken = response.nextToken(); } }
As métricas são retornadas em um ListMetricsResponse chamando o método getMetrics.
Os resultados podem ser paginados. Para recuperar o próximo lote de resultados, chame nextToken noobjeto de resposta e use o valor do token para compilar um novo objeto de solicitação. Em seguida, chameo método listMetrics novamente com a nova solicitação.
Veja o exemplo completo no GitHub.
Mais informações• ListMetrics na Amazon CloudWatch API Reference
Publicar dados de métrica personalizadaVários serviços da AWS publicam as próprias métricas em namespaces que começam com "AWS/"Também é possível publicar dados de métricas personalizadas usando seu próprio namespace (contantoque não comece com "AWS/").
Publicar dados de métrica personalizadaPara publicar os próprios dados de métrica, chame o método putMetricData do CloudWatchClient comum PutMetricDataRequest. O PutMetricDataRequest deve incluir o namespace personalizado a serusado para os dados e as informações sobre o próprio ponto de dados em um objeto MetricDatum.
Note
Você não pode especificar um namespace que começa com "AWS/". Namespaces que começamcom "AWS/" são reservados para serem usados por produtos da Amazon Web Services.
Importações
package com.example.cloudwatch;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;import software.amazon.awssdk.services.cloudwatch.model.Dimension;import software.amazon.awssdk.services.cloudwatch.model.MetricDatum;import software.amazon.awssdk.services.cloudwatch.model.StandardUnit;import software.amazon.awssdk.services.cloudwatch.model.PutMetricDataRequest;import software.amazon.awssdk.services.cloudwatch.model.PutMetricDataResponse;import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;
Código
public static void putMetData(CloudWatchClient cw, Double dataPoint ) {
try {
36
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com alarmes do CloudWatch
Dimension dimension = Dimension.builder() .name("UNIQUE_PAGES") .value("URLS").build();
MetricDatum datum = MetricDatum.builder() .metricName("PAGES_VISITED") .unit(StandardUnit.NONE) .value(dataPoint) .dimensions(dimension).build();
PutMetricDataRequest request = PutMetricDataRequest.builder() .namespace("SITE/TRAFFIC") .metricData(datum).build();
PutMetricDataResponse response = cw.putMetricData(request);
} catch (CloudWatchException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.printf("Successfully put data point %f", dataPoint);
Veja o exemplo completo no GitHub.
Mais informações• Usar métricas do Amazon CloudWatch no Amazon CloudWatch User Guide.• Namespaces da AWS no Amazon CloudWatch User Guide.• PutMetricData na Amazon CloudWatch API Reference.
Trabalhar com alarmes do CloudWatchCriar um alarmePara criar um alarme com base em uma métrica do CloudWatch, chame o método putMetricAlarm doCloudWatchClient com um PutMetricAlarmRequest preenchido com as condições de alarme.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;import software.amazon.awssdk.services.cloudwatch.model.Dimension;import software.amazon.awssdk.services.cloudwatch.model.PutMetricAlarmRequest;import software.amazon.awssdk.services.cloudwatch.model.ComparisonOperator;import software.amazon.awssdk.services.cloudwatch.model.Statistic;import software.amazon.awssdk.services.cloudwatch.model.StandardUnit;import software.amazon.awssdk.services.cloudwatch.model.PutMetricAlarmResponse;import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;
Código
public static void putMetricAlarm(CloudWatchClient cw, String alarmName, String instanceId) {
try { Dimension dimension = Dimension.builder() .name("InstanceId") .value(instanceId).build();
37
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com alarmes do CloudWatch
PutMetricAlarmRequest request = PutMetricAlarmRequest.builder() .alarmName(alarmName) .comparisonOperator( ComparisonOperator.GREATER_THAN_THRESHOLD) .evaluationPeriods(1) .metricName("CPUUtilization") .namespace("AWS/EC2") .period(60) .statistic(Statistic.AVERAGE) .threshold(70.0) .actionsEnabled(false) .alarmDescription( "Alarm when server CPU utilization exceeds 70%") .unit(StandardUnit.SECONDS) .dimensions(dimension) .build();
PutMetricAlarmResponse response = cw.putMetricAlarm(request);
} catch (CloudWatchException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
System.out.printf( "Successfully created alarm with name %s", alarmName);
Veja o exemplo completo no GitHub.
Listar alarmesPara listar os alarmes do CloudWatch criados por você, chame o método describeAlarms doCloudWatchClient com um DescribeAlarmsRequest que pode ser usado para definir opções para oresultado.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;import software.amazon.awssdk.services.cloudwatch.model.DescribeAlarmsRequest;import software.amazon.awssdk.services.cloudwatch.model.DescribeAlarmsResponse;import software.amazon.awssdk.services.cloudwatch.model.MetricAlarm;
Código
public static void deleteCWAlarms( CloudWatchClient cw) {
try {
boolean done = false; String newToken = null;
while(!done) { DescribeAlarmsResponse response;
if (newToken == null) { DescribeAlarmsRequest request = DescribeAlarmsRequest.builder().build(); response = cw.describeAlarms(request); } else { DescribeAlarmsRequest request = DescribeAlarmsRequest.builder() .nextToken(newToken)
38
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com alarmes do CloudWatch
.build(); response = cw.describeAlarms(request); }
for(MetricAlarm alarm : response.metricAlarms()) { System.out.printf("\n Retrieved alarm %s", alarm.alarmName()); }
if(response.nextToken() == null) { done = true; } else { newToken = response.nextToken(); } }
} catch (CloudWatchException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.printf("Done");
A lista de alarmes pode ser obtida chamando MetricAlarms no DescribeAlarmsResponse retornado pordescribeAlarms.
Os resultados podem ser paginados. Para recuperar o próximo lote de resultados, chame nextToken noobjeto de resposta e use o valor do token para compilar um novo objeto de solicitação. Em seguida, chameo método describeAlarms novamente com a nova solicitação.
Note
Você também pode recuperar alarmes para uma métrica específica usando o métododescribeAlarmsForMetric do CloudWatchClient. O uso é semelhante a describeAlarms.
Veja o exemplo completo no GitHub.
Excluir alarmesPara excluir os alarmes do CloudWatch, chame o método deleteAlarms do CloudWatchClient com umDeleteAlarmsRequest contendo um ou mais nomes de alarmes que você deseja excluir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;import software.amazon.awssdk.services.cloudwatch.model.DeleteAlarmsRequest;
Código
public static void deleteCWAlarm(CloudWatchClient cw, String alarmName) {
try { DeleteAlarmsRequest request = DeleteAlarmsRequest.builder() .alarmNames(alarmName).build();
cw.deleteAlarms(request); System.out.printf("Successfully deleted alarm %s", alarmName);
} catch (CloudWatchException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
39
AWS SDK para Java versão 2 Guia do desenvolvedorUse ações de alarme no CloudWatch
Veja o exemplo completo no GitHub.
Mais informações• Criar alarmes do Amazon CloudWatch no Amazon CloudWatch User Guide• PutMetricAlarm na Amazon CloudWatch API Reference• DescribeAlarms na Amazon CloudWatch API Reference• DeleteAlarms na Amazon CloudWatch API Reference
Use ações de alarme no CloudWatchUsando ações de alarme do CloudWatch, você pode criar alarmes que realizam ações como interromper,encerrar, reinicializar ou recuperar automaticamente instâncias do Amazon EC2.
Note
As ações de alarme podem ser adicionadas a um alarme usando-se o método alarmActions dePutMetricAlarmRequest quando se cria um alarme (p. 37).
Habilitar ações de alarmePara habilitar ações de um alarme do CloudWatch, chame o enableAlarmActions de CloudWatchClientcom um EnableAlarmActionsRequest contendo um ou mais nomes de alarmes cujas ações você desejahabilitar.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;import software.amazon.awssdk.services.cloudwatch.model.EnableAlarmActionsRequest;import software.amazon.awssdk.services.cloudwatch.model.EnableAlarmActionsResponse;
Código
public static void enableActions(CloudWatchClient cw, String alarm) {
try { EnableAlarmActionsRequest request = EnableAlarmActionsRequest.builder() .alarmNames(alarm).build();
EnableAlarmActionsResponse response = cw.enableAlarmActions(request);
} catch (CloudWatchException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Desabilitar ações de alarmePara desabilitar ações de um alarme do CloudWatch, chame o disableAlarmActions deCloudWatchClient com um DisableAlarmActionsRequest contendo um ou mais nomes de alarmes cujasações você deseja desabilitar.
40
AWS SDK para Java versão 2 Guia do desenvolvedorEnviar eventos para o CloudWatch
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;import software.amazon.awssdk.services.cloudwatch.model.DisableAlarmActionsRequest;import software.amazon.awssdk.services.cloudwatch.model.DisableAlarmActionsResponse;
Código
public static void disableActions(CloudWatchClient cw, String alarmName) {
try { DisableAlarmActionsRequest request = DisableAlarmActionsRequest.builder() .alarmNames(alarmName).build();
DisableAlarmActionsResponse response = cw.disableAlarmActions(request);
} catch (CloudWatchException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
System.out.printf( "Successfully disabled actions on alarm %s", alarmName);}
Veja o exemplo completo no GitHub.
Mais informações• Criar alarmes para interromper, encerrar, reinicializar ou recuperar uma instância no Amazon
CloudWatch User Guide• PutMetricAlarm na Amazon CloudWatch API Reference• EnableAlarmActions na Amazon CloudWatch API Reference• DisableAlarmActions na Amazon CloudWatch API Reference
Enviar eventos para o CloudWatchO CloudWatch Events distribui um fluxo quase em tempo real de eventos do sistema que descrevemalterações feitas em recursos da AWS para instâncias do Amazon EC2, funções Lambda, fluxos doKinesis, tarefas do Amazon ECS, máquinas de estado do Step Functions, tópicos do Amazon SNS, filasdo Amazon SQS ou alvos internos. Você pode comparar eventos e roteá-los para um ou mais fluxos oufunções de destino usando regras simples.
Adicionar eventosPara adicionar eventos do CloudWatch personalizados, chame o método putEvents doCloudWatchEventsClient com um objeto PutEventsRequest que contenha um ou mais objetosPutEventsRequestEntry que fornecem detalhes sobre cada evento. Você pode especificar váriosparâmetros para a entrada, como a origem e o tipo do evento, recursos associados ao evento e assim pordiante.
Note
Você pode especificar um máximo de dez eventos por chamada para putEvents.
41
AWS SDK para Java versão 2 Guia do desenvolvedorEnviar eventos para o CloudWatch
Importações
import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;import software.amazon.awssdk.services.cloudwatchevents.CloudWatchEventsClient;import software.amazon.awssdk.services.cloudwatchevents.model.PutEventsRequest;import software.amazon.awssdk.services.cloudwatchevents.model.PutEventsRequestEntry;import software.amazon.awssdk.services.cloudwatchevents.model.PutEventsResponse;
Código
public static void putCWEvents(CloudWatchEventsClient cwe, String resourceArn ) {
try {
final String EVENT_DETAILS = "{ \"key1\": \"value1\", \"key2\": \"value2\" }";
PutEventsRequestEntry requestEntry = PutEventsRequestEntry.builder() .detail(EVENT_DETAILS) .detailType("sampleSubmitted") .resources(resourceArn) .source("aws-sdk-java-cloudwatch-example").build();
PutEventsRequest request = PutEventsRequest.builder() .entries(requestEntry).build();
PutEventsResponse response = cwe.putEvents(request);
} catch (CloudWatchException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Adicionar regrasPara criar ou atualizar uma regra, chame o método putRule do CloudWatchEventsClient com umPutRuleRequest com o nome da regra e os parâmetros opcionais, como o padrão de evento, a função doIAM a ser associada à regra e uma expressão de programação que descreva com que frequência a regraé executada.
Importações
import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;import software.amazon.awssdk.services.cloudwatchevents.CloudWatchEventsClient;import software.amazon.awssdk.services.cloudwatchevents.model.PutRuleRequest;import software.amazon.awssdk.services.cloudwatchevents.model.PutRuleResponse;import software.amazon.awssdk.services.cloudwatchevents.model.RuleState;
Código
public static void putCWRule(CloudWatchEventsClient cwe, String ruleName, String roleArn) {
PutRuleResponse response = null;
try { PutRuleRequest request = PutRuleRequest.builder() .name(ruleName) .roleArn("arn:aws:iam::335446330391:role/testRole1") .scheduleExpression("rate(5 minutes)")
42
AWS SDK para Java versão 2 Guia do desenvolvedorEnviar eventos para o CloudWatch
.state(RuleState.ENABLED) .build();
response = cwe.putRule(request); } catch ( CloudWatchException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1);}
System.out.printf( "Successfully created CloudWatch events rule %s with ARN %s", roleArn, response.ruleArn());}
Veja o exemplo completo no GitHub.
Adicionar destinosDestinos são os recursos invocados quando uma regra é disparada. Entre os destinos de exemploestão instâncias do Amazon EC2, funções do Lambda, streamings do Kinesis, tarefas do Amazon ECS,máquinas de estado do Step Functions e destinos integrados.
Para adicionar um destino a uma regra, chame o método putTargets do CloudWatchEventsClient comum PutTargetsRequest que contenha a regra a ser atualizada e uma lista de destinos a serem adicionadosà regra.
Importações
import software.amazon.awssdk.services.cloudwatchevents.CloudWatchEventsClient;import software.amazon.awssdk.services.cloudwatchevents.model.PutTargetsRequest;import software.amazon.awssdk.services.cloudwatchevents.model.PutTargetsResponse;import software.amazon.awssdk.services.cloudwatchevents.model.Target;
Código
public static void putCWTargets(CloudWatchEventsClient cwe, String ruleName, String functionArn, String targetId ) {
Target target = Target.builder() .arn(functionArn) .id(targetId) .build();
PutTargetsRequest request = PutTargetsRequest.builder() .targets(target) .rule(ruleName) .build();
PutTargetsResponse response = cwe.putTargets(request);
Veja o exemplo completo no GitHub.
Mais informações• Adicionar eventos com PutEvents no Amazon CloudWatch Events User Guide• Programar expressões para regras no Amazon CloudWatch Events User Guide• Tipos de evento para eventos do CloudWatch no Amazon CloudWatch Events User Guide• Eventos e padrões de evento no Amazon CloudWatch Events User Guide
43
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon Cognito
• PutEvents na Amazon CloudWatch Events API Reference• PutTargets na Amazon CloudWatch Events API Reference• PutRule na Amazon CloudWatch Events API Reference
Exemplos do Amazon CognitoCom o Amazon Cognito, é possível adicionar rapidamente o recurso de cadastro ou login do usuário aoaplicativo web ou móvel. Os exemplos aqui demonstram algumas das funcionalidades básicas do Cognito.
Criar um grupo de usuáriosUm grupo de usuários é um diretório de usuários que você pode configurar para o aplicativo web ou móvel.
Para criar um grupo de usuários, comece compilando um objeto CreateUserPoolRequest com o nomedo grupo de usuários como o valor do poolName(). Chame o método createUserPool() deCreateUserPoolRequest transmitindo o objeto CreateUserPoolRequest. É possível capturar o resultadodessa solicitação como um objeto CreateUserPoolResponse, conforme demonstrado no trecho de códigoa seguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cognitoidentityprovider.CognitoIdentityProviderClient;import software.amazon.awssdk.services.cognitoidentityprovider.model.CognitoIdentityProviderException;import software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserPoolRequest;import software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserPoolResponse;
Código
public static String createPool(CognitoIdentityProviderClient cognitoclient,String userPoolName ) {
try { CreateUserPoolResponse repsonse = cognitoclient.createUserPool( CreateUserPoolRequest.builder() .poolName(userPoolName) .build() );
return repsonse.userPool().id();
} catch (CognitoIdentityProviderException e){ System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return "";
Veja o exemplo completo no GitHub.
Listar usuários de um grupo de usuáriosPara listar usuários dos seus grupos de usuários, comece compilando um objeto ListUserPoolsRequestcom o número de resultados máximos como o valor de maxResults(). Chame o método
44
AWS SDK para Java versão 2 Guia do desenvolvedorCriar um grupo de identidades
listUserPools() do CognitoIdentityProviderClient transmitindo o objetoListUserPoolsRequest. É possível capturar o resultado dessa solicitação como um objetoListUserPoolsResponse, conforme demonstrado no trecho de código a seguir. Crie um objetoUserPoolDescriptionType para iterar facilmente sobre resultados e extrair os atributos de cada usuário.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cognitoidentityprovider.CognitoIdentityProviderClient;import software.amazon.awssdk.services.cognitoidentityprovider.model.CognitoIdentityProviderException;import software.amazon.awssdk.services.cognitoidentityprovider.model.ListUserPoolsResponse;import software.amazon.awssdk.services.cognitoidentityprovider.model.ListUserPoolsRequest;import software.amazon.awssdk.services.cognitoidentityprovider.model.UserPoolDescriptionType;
Código
public static void listAllUserPools(CognitoIdentityProviderClient cognitoclient ) {
try { ListUserPoolsResponse response = cognitoclient .listUserPools( ListUserPoolsRequest.builder() .maxResults(10) .build() );
for (UserPoolDescriptionType userpool : response.userPools()) { System.out.println("UserPool " + userpool.name() + ", User ID " + userpool.id() + ", Status " + userpool.status()); } } catch (CognitoIdentityProviderException e){ System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Criar um grupo de identidadesUm grupo de identidades é um contêiner que organiza os IDs do provedor de identidade externo,mantendo um identificador exclusivo para cada usuário. Para criar um grupo de identidades, comececompilando um objeto CreateIdentityPoolRequest com o nome do grupo de usuários como o valor deidentityPoolName(). Defina allowUnauthenticatedIdentities() como true ou false.Chame o método createIdentityPool() do objeto CognitoIdentityClient transmitindo o objetoCreateIdentityPoolRequest. É possível capturar o resultado dessa solicitação como um objetoCreateIdentityPoolResponse, conforme demonstrado no trecho de código a seguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cognitoidentity.CognitoIdentityClient;import software.amazon.awssdk.services.cognitoidentity.model.CreateIdentityPoolRequest;import software.amazon.awssdk.services.cognitoidentity.model.CreateIdentityPoolResponse;import software.amazon.awssdk.services.cognitoidentityprovider.model.CognitoIdentityProviderException;
Código
45
AWS SDK para Java versão 2 Guia do desenvolvedorAdicionar um cliente de aplicativo
public static String createIdPool(CognitoIdentityClient cognitoclient, String identityPoolName ) {
try { CreateIdentityPoolResponse response = cognitoclient.createIdentityPool( CreateIdentityPoolRequest.builder() .allowUnauthenticatedIdentities(false) .identityPoolName(identityPoolName) .build() );
return response.identityPoolId();} catch (CognitoIdentityProviderException e){ System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1);} return "";
Veja o exemplo completo no GitHub.
Adicionar um cliente de aplicativoPara habilitar a interface de usuário da web hospedada de cadastro ou login para o aplicativo,crie um cliente de aplicativo. Para criar um cliente de aplicativo, comece compilando um objetoCreateUserPoolClientRequest com o nome do cliente como o valor de clientName(). DefinauserPoolId() como o ID do grupo de usuários ao qual você deseja anexar esse cliente de aplicativo.Chame o método createUserPoolClient() do CognitoIdentityProviderClient transmitindoo objeto CreateUserPoolClientRequest. É possível capturar o resultado dessa solicitação como umobjeto CreateUserPoolClientResponse, conforme demonstrado no trecho de código a seguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cognitoidentityprovider.CognitoIdentityProviderClient;import software.amazon.awssdk.services.cognitoidentityprovider.model.CognitoIdentityProviderException;import software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserPoolClientRequest;import software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserPoolClientResponse;
Código
public static void createPoolClient ( CognitoIdentityProviderClient cognitoclient, String clientName, String userPoolId ) {
try {
CreateUserPoolClientResponse repsonse = cognitoclient.createUserPoolClient( CreateUserPoolClientRequest.builder() .clientName(clientName) .userPoolId(userPoolId) .build() );
System.out.println("User Pool " + repsonse.userPoolClient().clientName() + " created. ID: " + repsonse.userPoolClient().clientId());
46
AWS SDK para Java versão 2 Guia do desenvolvedorAdicionar um provedor de identidade de terceiros
} catch (CognitoIdentityProviderException e){ System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Adicionar um provedor de identidade de terceirosAdicionar um provedor de identidade externo (IdP) permite que seus usuários façam login noaplicativo usando o mecanismo de login desse serviço. Para adicionar um IdP de terceiros, comececompilando um objeto UpdateIdentityPoolRequest com o nome do grupo de identidades comoo valor de identityPoolName(). Defina allowUnauthenticatedIdentities() comotrue ou false, especifique o identityPoolId() e defina quais provedores de login serãocompatíveis com supportedLoginProviders(). Chame o método updateIdentityPool() doCognitoIdentityClient transmitindo o objeto UpdateIdentityPoolRequest. É possível capturaro resultado dessa solicitação como um objeto UpdateIdentityPoolResponse, conforme demonstrado notrecho de código a seguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cognitoidentity.CognitoIdentityClient;import software.amazon.awssdk.services.cognitoidentity.model.CognitoIdentityProvider;import software.amazon.awssdk.services.cognitoidentity.model.UpdateIdentityPoolRequest;import software.amazon.awssdk.services.cognitoidentity.model.UpdateIdentityPoolResponse;import software.amazon.awssdk.services.cognitoidentityprovider.model.CognitoIdentityProviderException;import java.util.HashMap;
Código
public static void setLoginProvider(CognitoIdentityClient cognitoclient, String appId, String identityPoolName, String identityPoolId) {
HashMap<String, String> potentialProviders = new HashMap<>(); potentialProviders.put("facebook", "graph.facebook.com"); potentialProviders.put("google", "accounts.google.com"); potentialProviders.put("amazon", "www.amazon.com"); potentialProviders.put("twitter", "api.twitter.com"); potentialProviders.put("digits", "www.digits.com");
HashMap<String, String> loginProvider = new HashMap<>(); loginProvider.put(potentialProviders.get("amazon"), appId);
try {
UpdateIdentityPoolResponse response = cognitoclient .updateIdentityPool( UpdateIdentityPoolRequest.builder() .allowUnauthenticatedIdentities(false) .identityPoolName(identityPoolName) .identityPoolId(identityPoolId) .supportedLoginProviders(loginProvider) .build() );
for (CognitoIdentityProvider cip : response.cognitoIdentityProviders()) {
47
AWS SDK para Java versão 2 Guia do desenvolvedorObter credenciais para um ID
System.out.println("Client ID for " + cip.providerName() + " = " + cip.clientId()); } } catch (CognitoIdentityProviderException e){ System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Obter credenciais para um IDPara obter as credenciais de uma identidade em um grupo de identidades, primeiro compile um objetoGetCredentialsForIdentityRequest com o ID do grupo de identidades como o valor de identityId().Chame o método getCredentialsForIdentity() do CognitoIdentityClient transmitindo oobjeto GetCredentialsForIdentityRequest. É possível capturar o resultado dessa solicitação comoum objeto GetCredentialsForIdentityResponse, conforme demonstrado no trecho de código a seguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.cognitoidentity.CognitoIdentityClient;import software.amazon.awssdk.services.cognitoidentity.model.GetCredentialsForIdentityRequest;import software.amazon.awssdk.services.cognitoidentity.model.GetCredentialsForIdentityResponse;import software.amazon.awssdk.services.cognitoidentityprovider.model.CognitoIdentityProviderException;
Código
public static void getCredsForIdentity( CognitoIdentityClient cognitoclient,String identityPoolId) {
try{ GetCredentialsForIdentityResponse response = cognitoclient.getCredentialsForIdentity(GetCredentialsForIdentityRequest.builder() .identityId(identityPoolId) .build());
System.out.println("Identity ID " + response.identityId() + ", Access Key Id " + response.credentials().accessKeyId() );
} catch (CognitoIdentityProviderException e){ System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Para obter mais informações, consulte o Guia do desenvolvedor do Amazon Cognito.
Exemplos do DynamoDB usando o AWS SDK forJava
Esta seção fornece exemplos que mostram como programar o DynamoDB usando o AWS SDK for Java2.0.
48
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com tabelas no DynamoDB
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O códigode exemplo completo está disponível no GitHub. A partir daí, você pode fazer download de um únicoarquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilaçãoe execução.
Tópicos• Trabalhar com tabelas no DynamoDB (p. 49)• Trabalhar com itens no DynamoDB (p. 55)• Mapear itens em tabelas do DynamoDB (p. 60)
Trabalhar com tabelas no DynamoDBTabelas são os contêineres de todos os itens em um banco de dados do DynamoDB. Para adicionar ouremover dados do DynamoDB, você deve criar uma tabela.
Para cada tabela, você deve definir:
• Um nome de tabela é exclusivo para a conta e a região.• Uma chave primária para a qual cada valor deve ser único; dois itens na tabela não podem ter o mesmo
valor de chave primária.
Uma chave primária pode ser simples, consistindo em uma única chave de partição (HASH) oucomposta, que consiste em uma partição e uma chave de classificação (RANGE).
Cada valor de chave tem um tipo de dados associado, enumerados pela classe ScalarAttributeType.O valor da chave pode ser binário (B), numérico (N) ou uma string (S). Para obter mais informações,consulte Regras de nomenclatura e tipos de dados no Amazon DynamoDB Developer Guide.
• Throughput provisionado são valores que definem o número de unidades de capacidade de leitura/gravação reservado para a tabela.
Note
A definição de preço do Amazon DynamoDB se baseia nos valores de taxa de transferênciaprovisionada definidas por você nas tabelas. Dessa forma, reserve somente a capacidademáxima de que você imagina precisar para a tabela.O throughput provisionado para uma tabela pode ser modificado a qualquer momento. Dessaforma, você poderá ajustar a capacidade conforme suas necessidades mudam.
Criar uma tabelaUse o método createTable do DynamoDbClient para criar uma tabela do DynamoDB. Você precisaconstruir atributos de tabela e um esquema de tabela, ambos usados para identificar a chave primária databela. Você também deve fornecer valores de throughput provisionado iniciais e um nome de tabela.
Note
Se uma tabela com o nome escolhido por você já existir, um DynamoDbException será lançado.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.AttributeDefinition;import software.amazon.awssdk.services.dynamodb.model.CreateTableRequest;
49
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com tabelas no DynamoDB
import software.amazon.awssdk.services.dynamodb.model.CreateTableResponse;import software.amazon.awssdk.services.dynamodb.model.KeySchemaElement;import software.amazon.awssdk.services.dynamodb.model.KeyType;import software.amazon.awssdk.services.dynamodb.model.ProvisionedThroughput;import software.amazon.awssdk.services.dynamodb.model.ScalarAttributeType;
Criar uma tabela com uma chave primária simples
Esse código cria uma tabela com uma chave primária simples ("Name").
Código
public static String createTable(DynamoDbClient ddb, String tableName, String key) {
// Create the CreateTableRequest object CreateTableRequest request = CreateTableRequest.builder() .attributeDefinitions(AttributeDefinition.builder() .attributeName(key) .attributeType(ScalarAttributeType.S) .build()) .keySchema(KeySchemaElement.builder() .attributeName(key) .keyType(KeyType.HASH) .build()) .provisionedThroughput(ProvisionedThroughput.builder() .readCapacityUnits(new Long(10)) .writeCapacityUnits(new Long(10)) .build()) .tableName(tableName) .build();
String newTable =""; try { CreateTableResponse response = ddb.createTable(request); newTable = response.tableDescription().tableName(); return newTable; } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Criar uma tabela com uma chave primária composta
Adicione outro AttributeDefinition e KeySchemaElement a CreateTableRequest.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.services.dynamodb.model.AttributeDefinition;import software.amazon.awssdk.services.dynamodb.model.CreateTableRequest;import software.amazon.awssdk.services.dynamodb.model.CreateTableResponse;import software.amazon.awssdk.services.dynamodb.model.KeySchemaElement;import software.amazon.awssdk.services.dynamodb.model.KeyType;import software.amazon.awssdk.services.dynamodb.model.ProvisionedThroughput;import software.amazon.awssdk.services.dynamodb.model.ScalarAttributeType;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
Código
50
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com tabelas no DynamoDB
public static String createTableComKey(DynamoDbClient ddb, String tableName) { CreateTableRequest request = CreateTableRequest.builder() .attributeDefinitions( AttributeDefinition.builder() .attributeName("Language") .attributeType(ScalarAttributeType.S) .build(), AttributeDefinition.builder() .attributeName("Greeting") .attributeType(ScalarAttributeType.S) .build()) .keySchema( KeySchemaElement.builder() .attributeName("Language") .keyType(KeyType.HASH) .build(), KeySchemaElement.builder() .attributeName("Greeting") .keyType(KeyType.RANGE) .build()) .provisionedThroughput( ProvisionedThroughput.builder() .readCapacityUnits(new Long(10)) .writeCapacityUnits(new Long(10)).build()) .tableName(tableName) .build();
String tableId = "";
try { CreateTableResponse result = ddb.createTable(request); tableId = result.tableDescription().tableId(); return tableId; } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Listar tabelasVocê pode listar as tabelas em uma determinada região chamando o método listTables doDynamoDbClient.
Note
Se a tabela nomeada não existir para a conta e a região, um ResourceNotFoundException serálançado.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import java.util.List;
Código
51
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com tabelas no DynamoDB
public static void listAllTables(DynamoDbClient ddb){
boolean moreTables = true; String lastName = null;
while(moreTables) { try { ListTablesResponse response = null; if (lastName == null) { ListTablesRequest request = ListTablesRequest.builder().build(); response = ddb.listTables(request); } else { ListTablesRequest request = ListTablesRequest.builder() .exclusiveStartTableName(lastName).build(); response = ddb.listTables(request); }
List<String> tableNames = response.tableNames();
if (tableNames.size() > 0) { for (String curName : tableNames) { System.out.format("* %s\n", curName); } } else { System.out.println("No tables found!"); System.exit(0); }
lastName = response.lastEvaluatedTableName(); if (lastName == null) { moreTables = false; } } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); } }
Por padrão, até 100 tabelas são retornadas por chamada — use lastEvaluatedTableName no objetoListTablesResponse retornado para obter a tabela mais recentemente avaliada. Você pode usar esse valorpara iniciar a listagem depois do último valor retornado da listagem anterior.
Veja o exemplo completo no GitHub.
Descrever (obter informações sobre) uma tabelaChame o método describeTable do DynamoDbClient.
Note
Se a tabela nomeada não existir para a conta e a região, um ResourceNotFoundException serálançado.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.AttributeDefinition;import software.amazon.awssdk.services.dynamodb.model.DescribeTableRequest;import software.amazon.awssdk.services.dynamodb.model.ProvisionedThroughputDescription;import software.amazon.awssdk.services.dynamodb.model.TableDescription;
52
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com tabelas no DynamoDB
import java.util.List;
Código
public static void describeDymamoDBTable(DynamoDbClient ddb,String tableName ) {
DescribeTableRequest request = DescribeTableRequest.builder() .tableName(tableName) .build();
try { TableDescription tableInfo = ddb.describeTable(request).table();
if (tableInfo != null) { System.out.format("Table name : %s\n", tableInfo.tableName()); System.out.format("Table ARN : %s\n", tableInfo.tableArn()); System.out.format("Status : %s\n", tableInfo.tableStatus()); System.out.format("Item count : %d\n", tableInfo.itemCount().longValue()); System.out.format("Size (bytes): %d\n", tableInfo.tableSizeBytes().longValue());
ProvisionedThroughputDescription throughputInfo = tableInfo.provisionedThroughput(); System.out.println("Throughput"); System.out.format(" Read Capacity : %d\n", throughputInfo.readCapacityUnits().longValue()); System.out.format(" Write Capacity: %d\n", throughputInfo.writeCapacityUnits().longValue());
List<AttributeDefinition> attributes = tableInfo.attributeDefinitions(); System.out.println("Attributes");
for (AttributeDefinition a : attributes) { System.out.format(" %s (%s)\n", a.attributeName(), a.attributeType()); } } } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Modificar (atualizar) uma tabelaVocê pode modificar os valores de taxa de transferência provisionada da tabela a qualquer momentochamando o método updateTable do DynamoDbClient.
Note
Se a tabela nomeada não existir para a conta e a região, um ResourceNotFoundException serálançado.
Importações
import software.amazon.awssdk.regions.Region;
53
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com tabelas no DynamoDB
import software.amazon.awssdk.services.dynamodb.model.ProvisionedThroughput;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.UpdateTableRequest;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
Código
public static void updateDynamoDBTable(DynamoDbClient ddb, String tableName, Long readCapacity, Long writeCapacity) {
System.out.format( "Updating %s with new provisioned throughput values\n", tableName); System.out.format("Read capacity : %d\n", readCapacity); System.out.format("Write capacity : %d\n", writeCapacity);
ProvisionedThroughput tableThroughput = ProvisionedThroughput.builder() .readCapacityUnits(readCapacity) .writeCapacityUnits(writeCapacity) .build();
UpdateTableRequest request = UpdateTableRequest.builder() .provisionedThroughput(tableThroughput) .tableName(tableName) .build();
try { ddb.updateTable(request); } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Excluir uma tabelaChame o método deleteTable do DynamoDbClient e passe o nome da tabela para ele.
Note
Se a tabela nomeada não existir para a conta e a região, um ResourceNotFoundException serálançado.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.DeleteTableRequest;
Código
public static void deleteDynamoDBTable(DynamoDbClient ddb, String tableName) {
DeleteTableRequest request = DeleteTableRequest.builder() .tableName(tableName)
54
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com itens no DynamoDB
.build();
try { ddb.deleteTable(request);
} catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Mais informações• Diretrizes para trabalhar com tabelas no Amazon DynamoDB Developer Guide• Trabalhar com tabelas no DynamoDB no Amazon DynamoDB Developer Guide
Trabalhar com itens no DynamoDBNo DynamoDB, um item é um conjunto de atributos, e cada um tem um nome e um valor. Um valor deatributo pode ser uma escalar, um conjunto ou um tipo de documento. Para obter mais informações,consulte Regras de nomenclatura e tipos de dados no Amazon DynamoDB Developer Guide.
Recuperar (obter) um item de uma tabelaChame o método getItem do DynamoDbClient e passe um objeto GetItemRequest para ele com onome da tabela e o valor da chave primária do item desejado. Ele retorna um objeto GetItemResponsecom todos os atributos para esse item. Você pode especificar uma ou mais expressões de projeção noGetItemRequest para recuperar atributos específicos.
Você pode usar o método item() do objeto GetItemResponse retornado para recuperar um Mapa dospares de chave (String) e valor (AttributeValue) associados ao item.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.AttributeValue;import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;import java.util.HashMap;import java.util.Map;import java.util.Set;
Código
public static void getDynamoDBItem(DynamoDbClient ddb,String tableName,String key,String keyVal ) {
HashMap<String,AttributeValue> keyToGet = new HashMap<String,AttributeValue>();
keyToGet.put(key, AttributeValue.builder() .s(keyVal).build());
// Create a GetItemRequest object GetItemRequest request = GetItemRequest.builder() .key(keyToGet)
55
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com itens no DynamoDB
.tableName(tableName) .build();
try { Map<String,AttributeValue> returnedItem = ddb.getItem(request).item();
if (returnedItem != null) { Set<String> keys = returnedItem.keySet(); System.out.println("Table Attributes: \n");
for (String key1 : keys) { System.out.format("%s: %s\n", key1, returnedItem.get(key1).toString()); } } else { System.out.format("No item found with the key %s!\n", key); } } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Recuperar (Get) um item de uma tabela usando o clienteassíncronoInvoque o método getItem do DynamoDbAsyncClient e passe um objeto GetItemRequest para ele com onome da tabela e o valor da chave primária do item desejado.
Você pode retornar uma instância de Collection com todos os atributos desse item (consulte o exemplo aseguir).
Importações
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;import software.amazon.awssdk.services.dynamodb.model.AttributeValue;import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;import java.util.HashMap;import java.util.Map;import java.util.Set;import java.util.stream.Collectors;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
Código
//Get both input argumentsString tableName = args[0];String name = args[1];System.out.format("Retrieving item \"%s\" from \"%s\"\n", name, tableName );
HashMap<String, AttributeValue> keyToGet = new HashMap<String, AttributeValue>();
keyToGet.put("Name", AttributeValue.builder().s(name).build());
try {
DynamoDbAsyncClient client = DynamoDbAsyncClient.create();
//Create a GetItemRequest instance
56
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com itens no DynamoDB
GetItemRequest request = GetItemRequest.builder() .key(keyToGet) .tableName(tableName) .build();
//Invoke the DynamoDbAsyncClient object's getItem java.util.Collection<software.amazon.awssdk.services.dynamodb.model.AttributeValue> returnedItem = client.getItem(request).join().item().values();
//Convert Set to Map Map<String, AttributeValue> map = returnedItem.stream().collect(Collectors.toMap(AttributeValue::s, s->s)); Set<String> keys = map.keySet(); for (String key : keys) { System.out.format("%s: %s\n", key, map.get(key).toString()); }
} catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1);}
Veja o exemplo completo no GitHub.
Adicionar um novo item a uma tabelaCrie um Mapa de pares de chave/valor que representem os atributos do item. Eles devem incluir valorespara os campos de chave primária da tabela. Se o item identificado pela chave primária já existir, oscampos serão atualizados pela requisição.
Note
Se a tabela nomeada não existir para a conta e a região, um ResourceNotFoundException serálançado.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.AttributeValue;import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;import java.util.HashMap;
Código
public static void putItemInTable(DynamoDbClient ddb, String tableName, String key, String keyVal, String albumTitle, String albumTitleValue, String awards, String awardVal, String songTitle, String songTitleVal){
HashMap<String,AttributeValue> itemValues = new HashMap<String,AttributeValue>();
// Add all content to the table itemValues.put(key, AttributeValue.builder().s(keyVal).build());
57
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com itens no DynamoDB
itemValues.put(songTitle, AttributeValue.builder().s(songTitleVal).build()); itemValues.put(albumTitle, AttributeValue.builder().s(albumTitleValue).build()); itemValues.put(awards, AttributeValue.builder().s(awardVal).build());
// Create a PutItemRequest object PutItemRequest request = PutItemRequest.builder() .tableName(tableName) .item(itemValues) .build();
try { ddb.putItem(request); System.out.println(tableName +" was successfully updated");
} catch (ResourceNotFoundException e) { System.err.format("Error: The table \"%s\" can't be found.\n", tableName); System.err.println("Be sure that it exists and that you've typed its name correctly!"); System.exit(1); } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Atualizar um item existente em uma tabelaVocê pode atualizar um atributo para um item já existente em uma tabela usando o método updateItemdo DynamoDbClient, fornecendo um nome de tabela, o valor da chave primária e um mapa de campos aser atualizado.
Note
Se a tabela nomeada não existir para a conta e a região, ou se o item identificado pela chaveprimária passada não existir, uma ResourceNotFoundException será lançada.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.services.dynamodb.model.AttributeAction;import software.amazon.awssdk.services.dynamodb.model.AttributeValue;import software.amazon.awssdk.services.dynamodb.model.AttributeValueUpdate;import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import java.util.HashMap;
Código
public static void updateTableItem(DynamoDbClient ddb, String tableName, String key, String keyVal, String name, String updateVal){
HashMap<String,AttributeValue> itemKey = new HashMap<String,AttributeValue>();
itemKey.put(key, AttributeValue.builder().s(keyVal).build());
58
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com itens no DynamoDB
HashMap<String,AttributeValueUpdate> updatedValues = new HashMap<String,AttributeValueUpdate>();
// Update the column specified by name with updatedVal updatedValues.put(name, AttributeValueUpdate.builder() .value(AttributeValue.builder().s(updateVal).build()) .action(AttributeAction.PUT) .build());
UpdateItemRequest request = UpdateItemRequest.builder() .tableName(tableName) .key(itemKey) .attributeUpdates(updatedValues) .build();
try { ddb.updateItem(request); } catch (ResourceNotFoundException e) { System.err.println(e.getMessage()); System.exit(1); } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Excluir um item existente em uma tabelaVocê pode excluir um item que existe em uma tabela usando o método deleteItem do DynamoDbCliente fornecendo um nome de tabela, bem como o valor da chave primária.
Note
Se a tabela nomeada não existir para a conta e a região, ou se o item identificado pela chaveprimária passada não existir, uma ResourceNotFoundException será lançada.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.AttributeValue;import software.amazon.awssdk.services.dynamodb.model.DeleteItemRequest;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import java.util.HashMap;
Código
public static void deleteDymamoDBItem(DynamoDbClient ddb, String tableName, String key, String keyVal) {
HashMap<String,AttributeValue> keyToGet = new HashMap<String,AttributeValue>();
keyToGet.put(key, AttributeValue.builder() .s(keyVal) .build());
DeleteItemRequest deleteReq = DeleteItemRequest.builder() .tableName(tableName) .key(keyToGet) .build();
59
AWS SDK para Java versão 2 Guia do desenvolvedorMapear itens em tabelas do DynamoDB
try { ddb.deleteItem(deleteReq); } catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Mais informações• Diretrizes para trabalhar com itens no Amazon DynamoDB Developer Guide• Trabalhar com itens no DynamoDB no Amazon DynamoDB Developer Guide
Mapear itens em tabelas do DynamoDBO cliente avançado do Amazon DynamoDB é uma biblioteca de alto nível que faz parte do AWS SDK forJava versão 2 (v2). Ele oferece uma maneira simples de mapear classes do lado do cliente para tabelas doDynamoDB. Defina as relações entre as tabelas e suas classes de modelo correspondentes no seu código.Depois, você poderá executar intuitivamente várias operações de criação, leitura, atualização ou exclusão(CRUD) em tabelas ou itens do DynamoDB.
O AWS SDK for Java v2 inclui um conjunto de anotações que você pode usar com um bean Java paragerar rapidamente um TableSchema para mapear suas classes para tabelas. Como opção, se vocêdeclarar cada TableSchema explicitamente, não será necessário incluir anotações em suas classes.
Para trabalhar com itens em uma tabela do DynamoDB usando o cliente avançado, primeiro crie umDynamoDbEnhancedClient de um objeto DynamoDbClient existente.
Region region = Region.US_EAST_1;DynamoDbClient ddb = DynamoDbClient.builder() .region(region) .build();
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder() .dynamoDbClient(ddb) .build();
createDynamoDBTable(enhancedClient);
Criar uma tabela usando o cliente avançadoPara criar facilmente um TableSchema usando o cliente avançado, comece criando uma classe de dadosJava que inclua um construtor público padrão e nomes padronizados de getters e setters para cadapropriedade na classe. Inclua uma anotação no nível da classe para indicar que é uma DynamoDbBean e,no mínimo, inclua uma anotação DynamoDbPartitionKey no getter ou setter para a chave primária doregistro da tabela.
Uma vez que essa classe de dados tenha sido definida, chame TableSchema fromBean() com essaclasse de dados para criar o esquema de tabela.
Veja o trecho de código abaixo para obter um exemplo de como fazer isso.
Importações
60
AWS SDK para Java versão 2 Guia do desenvolvedorMapear itens em tabelas do DynamoDB
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;import software.amazon.awssdk.enhanced.dynamodb.TableSchema;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;import java.time.Instant;import java.time.LocalDate;import java.time.LocalDateTime;import java.time.ZoneOffset;
Código
// Put an item into a DynamoDB tablepublic static void putRecord(DynamoDbEnhancedClient enhancedClient) {
try { // Create a DynamoDbTable object DynamoDbTable<Customer> custTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
// Create an Instant object LocalDate localDate = LocalDate.parse("2020-04-07"); LocalDateTime localDateTime = localDate.atStartOfDay(); Instant instant = localDateTime.toInstant(ZoneOffset.UTC);
// Populate the table Customer custRecord = new Customer(); custRecord.setCustName("Susan Blue"); custRecord.setId("id103"); custRecord.setEmail("[email protected]"); custRecord.setRegistrationDate(instant) ;
// Put the customer data into a DynamoDB table custTable.putItem(custRecord);
} catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); } System.out.println("done");}
// Create the Customer table@DynamoDbBeanpublic static class Customer {
private String id; private String name; private String email; private Instant regDate;
@DynamoDbPartitionKey public String getId() { return this.id; };
public void setId(String id) {
this.id = id;
61
AWS SDK para Java versão 2 Guia do desenvolvedorMapear itens em tabelas do DynamoDB
}
@DynamoDbSortKey public String getCustName() { return this.name;
}
public void setCustName(String name) {
this.name = name; }
public String getEmail() { return this.email; }
public void setEmail(String email) {
this.email = email; }
public Instant getRegistrationDate() { return regDate; } public void setRegistrationDate(Instant registrationDate) {
this.regDate = registrationDate; }}
Veja o exemplo completo no GitHub.
Recuperar (obter) um item de uma tabelaPara obter um item de uma tabela do DynamoDB, crie um objeto DynamoDbTable e chame getItem()com um objeto GetItemEnhancedRequest para obter o item real.
Por exemplo, o seguinte trecho de código mostra uma maneira de usar o cliente avançado para obterinformações de um item em uma tabela do DynamoDB.
Importações
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;import software.amazon.awssdk.enhanced.dynamodb.Key;import software.amazon.awssdk.enhanced.dynamodb.TableSchema;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import java.time.Instant;
Código
public static String getItem(DynamoDbEnhancedClient enhancedClient) { try { // Create a DynamoDbTable object DynamoDbTable<Customer> mappedTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
62
AWS SDK para Java versão 2 Guia do desenvolvedorMapear itens em tabelas do DynamoDB
// Create a KEY object Key key = Key.builder() .partitionValue("id110") .build();
// Get the item by using the key Customer result = mappedTable.getItem(r->r.key(key)); return "The record id is "+result.getId();
} catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Agrupar itens de criação (inserção) e exclusão em loteÉ possível agrupar em lote uma variedade de solicitações de inserção (PutItemEnhancedRequest) e deexclusão (DeleteItemEnhancedRequest) para uma ou mais tabelas e enviar todas as alterações em umaúnica solicitação.
No seguinte trecho de código, um objeto DynamoDbTable é criado, dois itens são enfileirados paraserem adicionados à tabela e, depois, os itens são gravados na tabela em uma única chamada.Inclua várias entradas de addDeleteItem() e addPutItem() (parte do WriteBatch.Builder) emcada lote, conforme necessário. Para enfileirar alterações em uma tabela diferente, adicione outrainstância do WriteBatch.builder() e forneça um objeto DynamoDbTable correspondente nomappedTableResource().
Importações
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;import software.amazon.awssdk.enhanced.dynamodb.TableSchema;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;import software.amazon.awssdk.enhanced.dynamodb.model.BatchWriteItemEnhancedRequest;import software.amazon.awssdk.enhanced.dynamodb.model.WriteBatch;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;import java.time.Instant;import java.time.LocalDate;import java.time.LocalDateTime;import java.time.ZoneOffset;
Código
public static void putBatchRecords(DynamoDbEnhancedClient enhancedClient) { try {
// Create a DynamoDbTable object DynamoDbTable<Customer> mappedTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
// Create an Instant object LocalDate localDate = LocalDate.parse("2020-04-07"); LocalDateTime localDateTime = localDate.atStartOfDay(); Instant instant = localDateTime.toInstant(ZoneOffset.UTC);
63
AWS SDK para Java versão 2 Guia do desenvolvedorMapear itens em tabelas do DynamoDB
// Populate the table Customer record2 = new Customer(); record2.setCustName("Fred Pink"); record2.setId("id110"); record2.setEmail("[email protected]"); record2.setRegistrationDate(instant) ;
Customer record3 = new Customer(); record3.setCustName("Susan Pink"); record3.setId("id120"); record3.setEmail("[email protected]"); record3.setRegistrationDate(instant) ;
// Create a BatchWriteItemEnhancedRequest object BatchWriteItemEnhancedRequest batchWriteItemEnhancedRequest = BatchWriteItemEnhancedRequest.builder() .writeBatches( WriteBatch.builder(Customer.class) .mappedTableResource(mappedTable) .addPutItem(r -> r.item(record2)) .addPutItem(r -> r.item(record3)) .build()) .build();
// Add these two items to the table enhancedClient.batchWriteItem(batchWriteItemEnhancedRequest); System.out.println("done");
} catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); }}
// Create the Customer table@DynamoDbBeanpublic static class Customer {
private String id; private String name; private String email; private Instant regDate;
@DynamoDbPartitionKey public String getId() { return this.id; };
public void setId(String id) {
this.id = id; }
@DynamoDbSortKey public String getCustName() { return this.name; }
public void setCustName(String name) { this.name = name; }
public String getEmail() { return this.email; }
64
AWS SDK para Java versão 2 Guia do desenvolvedorMapear itens em tabelas do DynamoDB
public void setEmail(String email) { this.email = email; }
public Instant getRegistrationDate() { return regDate; } public void setRegistrationDate(Instant registrationDate) {
this.regDate = registrationDate; }}
Veja o exemplo completo no GitHub.
Usar uma consulta filtrada para obter itens de uma tabelaÉ possível obter itens de uma tabela com base em consultas filtráveis e, então, executar operações (porexemplo, retornar valores de item) em um ou mais dos itens nos resultados da consulta.
No trecho de código a seguir, você cria um filtro definindo primeiro o valor ou os valores que você estáprocurando como um objeto AttributeValue. Depois, coloque em um HashMap e compile uma Expressãodo classname:HashMap. Crie um objeto QueryConditional para especificar a chave primária paracorresponder na consulta e execute a consulta no objeto DynamoDbTable.
Note
A interface QueryConditional tem vários métodos que você pode usar para criar suas consultas,incluindo instruções condicionais comuns como maior que, menor que e entre.
Importações
import java.time.Instant;import java.util.Map;import java.util.Iterator;import java.util.HashMap;import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;import software.amazon.awssdk.enhanced.dynamodb.Expression;import software.amazon.awssdk.enhanced.dynamodb.Key;import software.amazon.awssdk.enhanced.dynamodb.TableSchema;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;import software.amazon.awssdk.services.dynamodb.model.AttributeValue;import software.amazon.awssdk.enhanced.dynamodb.model.QueryConditional;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
Código
public static void queryTableFilter(DynamoDbEnhancedClient enhancedClient) {
try{ // Create a DynamoDbTable object DynamoDbTable<EnhancedQueryRecords.Customer> mappedTable = enhancedClient.table("Customer", TableSchema.fromBean(EnhancedQueryRecords.Customer.class));
65
AWS SDK para Java versão 2 Guia do desenvolvedorMapear itens em tabelas do DynamoDB
// Get the row where email is [email protected] AttributeValue att = AttributeValue.builder() .s("[email protected]") .build();
Map<String, AttributeValue> expressionValues = new HashMap<>(); expressionValues.put(":value", att);
Expression expression = Expression.builder() .expression("email = :value") .expressionValues(expressionValues) .build();
// Create a QueryConditional object that's used in the query operation QueryConditional queryConditional = QueryConditional .keyEqualTo(Key.builder().partitionValue("id103") .build());
// Get items in the Customer table and write out the ID value Iterator<EnhancedQueryRecords.Customer> results = mappedTable.query(r -> r.queryConditional(queryConditional).filterExpression(expression)).items().iterator();
while (results.hasNext()) {
EnhancedQueryRecords.Customer rec = results.next(); System.out.println("The record id is "+rec.getId()); }
} catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); } System.out.println("Done");
Veja o exemplo completo no GitHub.
Recuperar (obter) todos os itens de uma tabelaQuando você quiser recuperar todos os registros de uma tabela do DynamoDB, use o método scan() doobjeto DynamoDbTable e o método items() para criar um conjunto de resultados nos quais você podeexecutar várias operações de item. Por exemplo, o trecho de código a seguir imprime o valor de ID decada item na tabela Registro .
Importações
import java.time.Instant;import java.util.Iterator;import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;import software.amazon.awssdk.enhanced.dynamodb.TableSchema;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
Código
public static void scan( DynamoDbEnhancedClient enhancedClient) {
try{
66
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon EC2
// Create a DynamoDbTable object DynamoDbTable<Customer> custTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
// Get items in the Record table and write out the ID values Iterator<Customer> results = custTable.scan().items().iterator();
while (results.hasNext()) {
Customer rec = results.next(); System.out.println("The record id is "+rec.getId()); }
} catch (DynamoDbException e) { System.err.println(e.getMessage()); System.exit(1); } System.out.println("Done");}
Veja o exemplo completo no GitHub.
Para obter mais informações, consulte Trabalhar com itens no DynamoDB no Amazon DynamoDBDeveloper Guide.
Amazon EC2 Exemplos usando o AWS SDK forJava
Esta seção fornece exemplos de como programar o Amazon EC2 que usa o AWS SDK for Java 2.0.
Tópicos• Gerenciar instâncias do Amazon EC2 (p. 67)• Usar endereços IP elásticos no Amazon EC2 (p. 72)• Utilizar regiões e zonas de disponibilidade (p. 74)• Trabalhar com pares de chaves do Amazon EC2 (p. 76)• Trabalhar com grupos de segurança no Amazon EC2 (p. 78)
Gerenciar instâncias do Amazon EC2Criar uma instânciaCrie uma instância do Amazon EC2 chamando o método runInstances do Ec2Client, fornecendoum RunInstancesRequest contendo a imagem de máquina da Amazon (AMI) a ser usada e um tipo deinstância.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.InstanceType;import software.amazon.awssdk.services.ec2.model.RunInstancesRequest;import software.amazon.awssdk.services.ec2.model.RunInstancesResponse;import software.amazon.awssdk.services.ec2.model.Tag;
67
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar instâncias do Amazon EC2
import software.amazon.awssdk.services.ec2.model.CreateTagsRequest;import software.amazon.awssdk.services.ec2.model.Ec2Exception;
Código
public static String createEC2Instance(Ec2Client ec2,String name, String amiId ) {
RunInstancesRequest runRequest = RunInstancesRequest.builder() .imageId(amiId) .instanceType(InstanceType.T1_MICRO) .maxCount(1) .minCount(1) .build();
RunInstancesResponse response = ec2.runInstances(runRequest); String instanceId = response.instances().get(0).instanceId();
Tag tag = Tag.builder() .key("Name") .value(name) .build();
CreateTagsRequest tagRequest = CreateTagsRequest.builder() .resources(instanceId) .tags(tag) .build();
try { ec2.createTags(tagRequest); System.out.printf( "Successfully started EC2 instance %s based on AMI %s", instanceId, amiId);
return instanceId;
} catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Iniciar uma instânciaPara iniciar uma instância do Amazon EC2, chame o método startInstances do Ec2Client, fornecendoum StartInstancesRequest contendo o ID da instância para iniciar.
Importações
import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.StartInstancesRequest;import software.amazon.awssdk.services.ec2.model.StopInstancesRequest;
Código
public static void startInstance(Ec2Client ec2, String instanceId) {
StartInstancesRequest request = StartInstancesRequest.builder() .instanceIds(instanceId) .build();
68
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar instâncias do Amazon EC2
ec2.startInstances(request);
Veja o exemplo completo no GitHub.
Interromper uma instânciaPara interromper uma instância do Amazon EC2, chame o método stopInstances do Ec2Client,fornecendo um StopInstancesRequest contendo o ID da instância para interromper.
Importações
import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.StartInstancesRequest;import software.amazon.awssdk.services.ec2.model.StopInstancesRequest;
Código
public static void stopInstance(Ec2Client ec2, String instanceId) {
StopInstancesRequest request = StopInstancesRequest.builder() .instanceIds(instanceId) .build();
ec2.stopInstances(request);
Veja o exemplo completo no GitHub.
Reinicializar uma instânciaPara reinicializar uma instância do Amazon EC2, chame o método rebootInstances do Ec2Client,fornecendo um RebootInstancesRequest contendo o ID da instância para reinicializar.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.Ec2Exception;import software.amazon.awssdk.services.ec2.model.RebootInstancesRequest;
Código
public static void rebootEC2Instance(Ec2Client ec2, String instanceId) {
try {
RebootInstancesRequest request = RebootInstancesRequest.builder() .instanceIds(instanceId).build();
ec2.rebootInstances(request); System.out.printf( "Successfully rebooted instance %s", instanceId);} catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
69
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar instâncias do Amazon EC2
Veja o exemplo completo no GitHub.
Descrever instânciasPara listar as instâncias, crie um DescribeInstancesRequest e chame o método describeInstancesdo Ec2Client. Isso retornará um objeto DescribeInstancesResponse, que poderá ser usado para listar asinstâncias do Amazon EC2 para a conta e a região.
As instâncias são agrupadas por reserva. Cada reserva corresponde à chamada a startInstancesque iniciou a instância. Para listar as instâncias, você deve primeiro chamar o método reservations daclasse DescribeInstancesResponse e chamar instances em cada objeto Reservation retornado.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.DescribeInstancesRequest;import software.amazon.awssdk.services.ec2.model.DescribeInstancesResponse;import software.amazon.awssdk.services.ec2.model.Instance;import software.amazon.awssdk.services.ec2.model.Reservation;import software.amazon.awssdk.services.ec2.model.Ec2Exception;
Código
public static void describeEC2Instances( Ec2Client ec2){
boolean done = false; String nextToken = null;
try {
do { DescribeInstancesRequest request = DescribeInstancesRequest.builder().maxResults(6).nextToken(nextToken).build(); DescribeInstancesResponse response = ec2.describeInstances(request);
for (Reservation reservation : response.reservations()) { for (Instance instance : reservation.instances()) { System.out.printf( "Found reservation with id %s, " + "AMI %s, " + "type %s, " + "state %s " + "and monitoring state %s", instance.instanceId(), instance.imageId(), instance.instanceType(), instance.state().name(), instance.monitoring().state()); System.out.println(""); } } nextToken = response.nextToken(); } while (nextToken != null);
} catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
70
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar instâncias do Amazon EC2
Os resultados são paginados; você pode obter mais resultados passando o valor retornado do métodonextToken do objeto de resultado para o método nextToken do objeto de uma solicitação nova eusando o objeto da nova solicitação na próxima chamada para describeInstances.
Veja o exemplo completo no GitHub.
Monitorar uma instânciaVocê pode monitorar diversos aspectos das instâncias do Amazon EC2, como utilização de CPU e rede,memória disponível e espaço em disco restante. Para saber mais sobre o monitoramento de instâncias,consulte Monitorar o Amazon EC2 no Amazon EC2 User Guide for Linux Instances.
Para iniciar o monitoramento de uma instância, você deve criar um MonitorInstancesRequest com o ID dainstância para monitorar e passá-lo para o método monitorInstances do Ec2Client.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.MonitorInstancesRequest;import software.amazon.awssdk.services.ec2.model.UnmonitorInstancesRequest;
Código
MonitorInstancesRequest request = MonitorInstancesRequest.builder() .instanceIds(instanceId).build();
ec2.monitorInstances(request);
Veja o exemplo completo no GitHub.
Interromper o monitoramento de instânciasPara interromper o monitoramento de uma instância, crie um UnmonitorInstancesRequest com o IDda instância para interromper o monitoramento e passá-lo para o método unmonitorInstances doEc2Client.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.MonitorInstancesRequest;import software.amazon.awssdk.services.ec2.model.UnmonitorInstancesRequest;
Código
UnmonitorInstancesRequest request = UnmonitorInstancesRequest.builder() .instanceIds(instanceId).build();
ec2.unmonitorInstances(request);
Veja o exemplo completo no GitHub.
Mais informações• RunInstances na Amazon EC2 API Reference
71
AWS SDK para Java versão 2 Guia do desenvolvedorUsar endereços IP elásticos no Amazon EC2
• DescribeInstances na Amazon EC2 API Reference• StartInstances na Amazon EC2 API Reference• StopInstances na Amazon EC2 API Reference• RebootInstances na Amazon EC2 API Reference• DescribeInstances na Amazon EC2 API Reference• MonitorInstances na Amazon EC2 API Reference• UnmonitorInstances na Amazon EC2 API Reference
Usar endereços IP elásticos no Amazon EC2Alocar um endereço IP elásticoPara usar um endereço IP elástico, você primeiro aloca um para sua conta e o associa à instância ou auma interface de rede.
Para alocar um endereço IP elástico, chame o método allocateAddress do Ec2Client com um objetoAllocateAddressRequest contendo o tipo de rede (EC2 ou VPC clássico).
O AllocateAddressResponse retornado contém um ID de alocação que pode ser usado paraassociar o endereço a uma instância, passando o ID de alocação e o ID de instância em umAssociateAddressRequest para o método associateAddress do Ec2Client.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.AllocateAddressRequest;import software.amazon.awssdk.services.ec2.model.DomainType;import software.amazon.awssdk.services.ec2.model.AllocateAddressResponse;import software.amazon.awssdk.services.ec2.model.AssociateAddressRequest;import software.amazon.awssdk.services.ec2.model.AssociateAddressResponse;import software.amazon.awssdk.services.ec2.model.Ec2Exception;
Código
public static String getAllocateAddress( Ec2Client ec2, String instanceId) {
try { AllocateAddressRequest allocateRequest = AllocateAddressRequest.builder() .domain(DomainType.VPC) .build();
AllocateAddressResponse allocateResponse = ec2.allocateAddress(allocateRequest);
String allocationId = allocateResponse.allocationId();
AssociateAddressRequest associateRequest = AssociateAddressRequest.builder() .instanceId(instanceId) .allocationId(allocationId) .build();
AssociateAddressResponse associateResponse = ec2.associateAddress(associateRequest); return associateResponse.associationId();
72
AWS SDK para Java versão 2 Guia do desenvolvedorUsar endereços IP elásticos no Amazon EC2
} catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return "";
Veja o exemplo completo no GitHub.
Descrever endereços IP elásticosPara listar os endereços IP elásticos atribuídos à conta, chame o método describeAddresses doEc2Client. Ele retorna um DescribeAddressesResponse que pode ser usado para obter uma lista deobjetos Address que representam os endereços IP elásticos na conta.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.Address;import software.amazon.awssdk.services.ec2.model.DescribeAddressesResponse;
Código
public static void describeEC2Address(Ec2Client ec2 ) {
DescribeAddressesResponse response = ec2.describeAddresses();
for(Address address : response.addresses()) { System.out.printf( "Found address with public IP %s, " + "domain %s, " + "allocation id %s " + "and NIC id %s", address.publicIp(), address.domain(), address.allocationId(), address.networkInterfaceId()); }
Veja o exemplo completo no GitHub.
Liberar um endereço IP elásticoPara liberar um endereço IP elástico, chame o método releaseAddress do Ec2Client, passando umReleaseAddressRequest contendo o ID de alocação do endereço IP elástico que você deseja liberar.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.Ec2Exception;import software.amazon.awssdk.services.ec2.model.ReleaseAddressRequest;import software.amazon.awssdk.services.ec2.model.ReleaseAddressResponse;
Código
public static void releaseEC2Address(Ec2Client ec2,String allocId) {
73
AWS SDK para Java versão 2 Guia do desenvolvedorUtilizar regiões e zonas de disponibilidade
try { ReleaseAddressRequest request = ReleaseAddressRequest.builder() .allocationId(allocId).build();
ReleaseAddressResponse response = ec2.releaseAddress(request);
System.out.printf( "Successfully released elastic IP address %s", allocId); } catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } }
Depois que você liberar um endereço IP elástico, ele será liberado para o grupo de endereços IP daAWS e poderá estar indisponível em seguida. Não se esqueça de atualizar os registros DNS e todos osservidores ou dispositivos que se comunicam com o endereço.
Se você estiver usando o EC2-Classic ou uma VPC padrão, liberar um endereço IP elástico odesassociará automaticamente de qualquer instância a qual esteja associada. Para desassociar umendereço IP elástico sem liberá-lo, use o método disassociateAddress do Ec2Client.
Se estiver usando uma VPC não padrão, você deverá usar disassociateAddress para desassociaro endereço IP elástico antes de tentar liberá-lo. Do contrário, o Amazon EC2 retornará um erro(InvalidIPAddress.InUse).
Veja o exemplo completo no GitHub.
Mais informações• Endereços IP elásticos no Amazon EC2 User Guide for Linux Instances• AllocateAddress na Amazon EC2 API Reference• DescribeAddresses na Amazon EC2 API Reference• ReleaseAddress na Amazon EC2 API Reference
Utilizar regiões e zonas de disponibilidadeDescrever regiõesPara listar as regiões disponíveis para a conta, chame o método describeRegions do Ec2Client. Eleretorna um DescribeRegionsResponse. Chame o método regions do objeto retornado para obter umalista de objetos Region que representam cada região.
Importações
import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.DescribeRegionsResponse;import software.amazon.awssdk.services.ec2.model.Region;import software.amazon.awssdk.services.ec2.model.AvailabilityZone;import software.amazon.awssdk.services.ec2.model.Ec2Exception;import software.amazon.awssdk.services.ec2.model.DescribeAvailabilityZonesResponse;
Código
try {
74
AWS SDK para Java versão 2 Guia do desenvolvedorUtilizar regiões e zonas de disponibilidade
DescribeRegionsResponse regionsResponse = ec2.describeRegions();
for(Region region : regionsResponse.regions()) { System.out.printf( "Found region %s " + "with endpoint %s", region.regionName(), region.endpoint()); System.out.println();
Veja o exemplo completo no GitHub.
Descrever zonas de disponibilidadePara listar cada zona de disponibilidade disponível para a conta, chame o métododescribeAvailabilityZones do Ec2Client. Ele retorna um DescribeAvailabilityZonesResponse.Chame o método availabilityZones para obter uma lista de objetos AvailabilityZone que representamcada zona de disponibilidade.
Importações
import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.DescribeRegionsResponse;import software.amazon.awssdk.services.ec2.model.Region;import software.amazon.awssdk.services.ec2.model.AvailabilityZone;import software.amazon.awssdk.services.ec2.model.Ec2Exception;import software.amazon.awssdk.services.ec2.model.DescribeAvailabilityZonesResponse;
Código
Crie o Ec2Client.
Ec2Client ec2 = Ec2Client.create();
Em seguida, chame describeAvailabilityZones() e recupere os resultados.
DescribeAvailabilityZonesResponse zonesResponse = ec2.describeAvailabilityZones();
for(AvailabilityZone zone : zonesResponse.availabilityZones()) { System.out.printf( "Found availability zone %s " + "with status %s " + "in region %s", zone.zoneName(), zone.state(), zone.regionName()); System.out.println();
Veja o exemplo completo no GitHub.
Descrever contasPara descrever a conta, chame o método describeAccountAttributes do Ec2Client. Esse métodoretorna um objeto DescribeAccountAttributesResponse. Invoque o método accountAttributes dessesobjetos para obter uma lista de objetos AccountAttribute. É possível percorrer a lista para recuperar umobjeto AccountAttribute.
75
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com pares de chaves do Amazon EC2
É possível obter os valores de atributo da conta invocando o método attributeValues do objetoAccountAttribute. Esse método retorna uma lista de objetos AccountAttributeValue. É possível percorreressa segunda lista para exibir o valor dos atributos (veja o exemplo de código a seguir).
Importações
import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.DescribeRegionsResponse;import software.amazon.awssdk.services.ec2.model.Region;import software.amazon.awssdk.services.ec2.model.AvailabilityZone;import software.amazon.awssdk.services.ec2.model.Ec2Exception;import software.amazon.awssdk.services.ec2.model.DescribeAvailabilityZonesResponse;
Código
try {
DescribeRegionsResponse regionsResponse = ec2.describeRegions();
for(Region region : regionsResponse.regions()) { System.out.printf( "Found region %s " + "with endpoint %s", region.regionName(), region.endpoint()); System.out.println();
Veja o exemplo completo no GitHub.
Mais informações• Regiões e zonas de disponibilidade no Amazon EC2 User Guide for Linux Instances• DescribeRegions na Amazon EC2 API Reference• DescribeAvailabilityZones na Amazon EC2 API Reference
Trabalhar com pares de chaves do Amazon EC2Criar um par de chavesPara criar um par de chaves, chame o método createKeyPair do Ec2Client com umCreateKeyPairRequest que contenha o nome da chave.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.CreateKeyPairRequest;import software.amazon.awssdk.services.ec2.model.CreateKeyPairResponse;import software.amazon.awssdk.services.ec2.model.Ec2Exception;
Código
public static void createEC2KeyPair(Ec2Client ec2,String keyName ) {
try {
76
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com pares de chaves do Amazon EC2
CreateKeyPairRequest request = CreateKeyPairRequest.builder() .keyName(keyName).build();
CreateKeyPairResponse response = ec2.createKeyPair(request); System.out.printf( "Successfully created key pair named %s", keyName);
} catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Descrever pares de chavesPara listar os pares de chaves ou obter informações sobre eles, chame o método describeKeyPairs doEc2Client. Ele retorna um DescribeKeyPairsResponse que pode ser usado para acessar a lista de paresde chaves chamando o método keyPairs, que retorna uma lista de objetos KeyPairInfo.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.DescribeKeyPairsResponse;import software.amazon.awssdk.services.ec2.model.KeyPairInfo;import software.amazon.awssdk.services.ec2.model.Ec2Exception;
Código
public static void describeEC2Keys( Ec2Client ec2){
try { DescribeKeyPairsResponse response = ec2.describeKeyPairs();
for(KeyPairInfo keyPair : response.keyPairs()) { System.out.printf( "Found key pair with name %s " + "and fingerprint %s", keyPair.keyName(), keyPair.keyFingerprint()); System.out.println(""); } } catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Excluir um par de chavesPara excluir um par de chaves, chame o método deleteKeyPair do Ec2Client, passando umDeleteKeyPairRequest que contenha o nome do par de chaves a ser excluído.
Importações
import software.amazon.awssdk.regions.Region;
77
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com grupos de segurança no Amazon EC2
import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.DeleteKeyPairRequest;import software.amazon.awssdk.services.ec2.model.DeleteKeyPairResponse;import software.amazon.awssdk.services.ec2.model.Ec2Exception;
Código
public static void deleteKeys(Ec2Client ec2, String keyName) {
try {
DeleteKeyPairRequest request = DeleteKeyPairRequest.builder() .keyName(keyName) .build();
DeleteKeyPairResponse response = ec2.deleteKeyPair(request);
Veja o exemplo completo no GitHub.
Mais informações• Pares de chaves do Amazon EC2 no Amazon EC2 User Guide for Linux Instances• CreateKeyPair na Amazon EC2 API Reference• DescribeKeyPairs na Amazon EC2 API Reference• DeleteKeyPair na Amazon EC2 API Reference
Trabalhar com grupos de segurança no Amazon EC2Crie um grupo de segurançaPara criar um grupo de segurança, chame o método createSecurityGroup do Ec2Client com umCreateSecurityGroupRequest que contenha o nome da chave.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.CreateSecurityGroupRequest;import software.amazon.awssdk.services.ec2.model.AuthorizeSecurityGroupIngressRequest;import software.amazon.awssdk.services.ec2.model.AuthorizeSecurityGroupIngressResponse;import software.amazon.awssdk.services.ec2.model.Ec2Exception;import software.amazon.awssdk.services.ec2.model.IpPermission;import software.amazon.awssdk.services.ec2.model.CreateSecurityGroupResponse;import software.amazon.awssdk.services.ec2.model.IpRange;
Código
CreateSecurityGroupRequest createRequest = CreateSecurityGroupRequest.builder() .groupName(groupName) .description(groupDesc) .vpcId(vpcId) .build();
CreateSecurityGroupResponse resp= ec2.createSecurityGroup(createRequest);
78
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com grupos de segurança no Amazon EC2
Veja o exemplo completo no GitHub.
Configurar um grupo de segurançaUm grupo de segurança pode controlar os tráfegos de entrada e saída para as instâncias do Amazon EC2.
Para adicionar regras de entrada ao grupo de segurança, use o métodoauthorizeSecurityGroupIngress do Ec2Client, fornecendo o nome do grupo de segurançae as regras de acesso (IpPermission) que você deseja atribuir a ele dentro de um objetoAuthorizeSecurityGroupIngressRequest. O exemplo a seguir mostra como adicionar permissões de IP aum grupo de segurança.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.CreateSecurityGroupRequest;import software.amazon.awssdk.services.ec2.model.AuthorizeSecurityGroupIngressRequest;import software.amazon.awssdk.services.ec2.model.AuthorizeSecurityGroupIngressResponse;import software.amazon.awssdk.services.ec2.model.Ec2Exception;import software.amazon.awssdk.services.ec2.model.IpPermission;import software.amazon.awssdk.services.ec2.model.CreateSecurityGroupResponse;import software.amazon.awssdk.services.ec2.model.IpRange;
Código
Primeiro, crie um Ec2Client
Region region = Region.US_WEST_2;Ec2Client ec2 = Ec2Client.builder() .region(region) .build();
Depois, use o método authorizeSecurityGroupIngress do Ec2Client.
IpRange ipRange = IpRange.builder() .cidrIp("0.0.0.0/0").build();
IpPermission ipPerm = IpPermission.builder() .ipProtocol("tcp") .toPort(80) .fromPort(80) .ipRanges(ipRange) .build();
IpPermission ipPerm2 = IpPermission.builder() .ipProtocol("tcp") .toPort(22) .fromPort(22) .ipRanges(ipRange) .build();
AuthorizeSecurityGroupIngressRequest authRequest = AuthorizeSecurityGroupIngressRequest.builder() .groupName(groupName) .ipPermissions(ipPerm, ipPerm2) .build();
AuthorizeSecurityGroupIngressResponse authResponse = ec2.authorizeSecurityGroupIngress(authRequest);
79
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com grupos de segurança no Amazon EC2
Para adicionar uma regra de saída ao grupo de segurança, forneça dados semelhantes em umAuthorizeSecurityGroupEgressRequest ao método authorizeSecurityGroupEgress do Ec2Client.
Veja o exemplo completo no GitHub.
Descrever grupos de segurançaPara descrever os grupos de segurança ou obter informações sobre eles, chame o métododescribeSecurityGroups do Ec2Client. Ele retorna um DescribeSecurityGroupsResponse que podeser usado para acessar a lista de grupos de segurança chamando o método securityGroups, queretorna uma lista de objetos SecurityGroup.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;import software.amazon.awssdk.services.ec2.model.DescribeSecurityGroupsRequest;import software.amazon.awssdk.services.ec2.model.DescribeSecurityGroupsResponse;import software.amazon.awssdk.services.ec2.model.SecurityGroup;import software.amazon.awssdk.services.ec2.model.Ec2Exception;
Código
public static void describeEC2SecurityGroups(Ec2Client ec2, String groupId) {
try {
DescribeSecurityGroupsRequest request = DescribeSecurityGroupsRequest.builder() .groupIds(groupId).build();
DescribeSecurityGroupsResponse response = ec2.describeSecurityGroups(request);
for(SecurityGroup group : response.securityGroups()) { System.out.printf( "Found security group with id %s, " + "vpc id %s " + "and description %s", group.groupId(), group.vpcId(), group.description()); } } catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Excluir um security groupPara excluir um grupo de segurança, chame o método deleteSecurityGroup do Ec2Client, passandoum DeleteSecurityGroupRequest que contenha o ID do grupo de segurança a ser excluído.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.ec2.Ec2Client;
80
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do AWS Identity and Access Management (IAM)
import software.amazon.awssdk.services.ec2.model.DeleteSecurityGroupRequest;import software.amazon.awssdk.services.ec2.model.DeleteSecurityGroupResponse;import software.amazon.awssdk.services.ec2.model.Ec2Exception;
Código
public static void deleteEC2SecGroup(Ec2Client ec2,String groupId) {
try { DeleteSecurityGroupRequest request = DeleteSecurityGroupRequest.builder() .groupId(groupId) .build();
DeleteSecurityGroupResponse response = ec2.deleteSecurityGroup(request);
System.out.printf( "Successfully deleted security group with id %s", groupId);
} catch (Ec2Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Mais informações• Grupos de segurança do Amazon EC2 no Amazon EC2 User Guide for Linux Instances• Autorizar tráfego de entrada para as instâncias do Linux no Amazon EC2 User Guide for Linux Instances• CreateSecurityGroup na Amazon EC2 API Reference• DescribeSecurityGroups na Amazon EC2 API Reference• DeleteSecurityGroup na Amazon EC2 API Reference• AuthorizeSecurityGroupIngress na Amazon EC2 API Reference
Exemplos do IAM usando o AWS SDK for JavaEsta seção fornece exemplos de como programar o IAM usando o AWS SDK for Java 2.0.
O AWS Identity and Access Management (IAM) permite que você controle com segurança o acesso aosserviços e recursos da AWS para seus usuários. Usando o IAM, você pode criar e gerenciar usuários egrupos da AWS, além de usar permissões para permitir e negar acesso a recursos da AWS. Para obter umguia completo do IAM, visite o Guia do usuário do IAM.
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O códigode exemplo completo está disponível no GitHub. A partir daí, você pode fazer download de um únicoarquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilaçãoe execução.
Tópicos• Gerenciar chaves de acesso do IAM (p. 82)• Gerenciar usuários do IAM (p. 85)• Usar aliases de conta do IAM (p. 88)• Trabalhar com políticas do IAM (p. 90)• Trabalhar com certificados de servidor do IAM (p. 95)
81
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar chaves de acesso do IAM
Gerenciar chaves de acesso do IAMCriar uma chave de acessoPara criar uma chave de acesso do IAM, chame o método createAccessKey do IamClient com umobjeto CreateAccessKeyRequest.
Note
Você deve definir a região como AWS_GLOBAL para chamadas do IamClient para trabalhar,porque o IAM é um serviço global.
Importações
import software.amazon.awssdk.services.iam.model.CreateAccessKeyRequest;import software.amazon.awssdk.services.iam.model.CreateAccessKeyResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static String createIAMAccessKey(IamClient iam,String user) {
try { CreateAccessKeyRequest request = CreateAccessKeyRequest.builder() .userName(user).build();
CreateAccessKeyResponse response = iam.createAccessKey(request); String keyId = response.accessKey().accessKeyId(); return keyId;
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return "";}
Veja o exemplo completo no GitHub.
Listar chaves de acessoPara listar as chaves de acesso de um determinado usuário, crie um objeto ListAccessKeysRequest quecontenha o nome de usuário cujas chaves listar e passá-lo para o método listAccessKeys no IamClient.
Note
Se você não fornecer um nome de usuário para listAccessKeys, ele tentará listar chaves deacesso associadas à conta da AWS que assinou a requisição.
Importações
import software.amazon.awssdk.services.iam.model.AccessKeyMetadata;import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.ListAccessKeysRequest;import software.amazon.awssdk.services.iam.model.ListAccessKeysResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;
82
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar chaves de acesso do IAM
Código
public static void listKeys( IamClient iam,String username ){
try { boolean done = false; String newMarker = null;
while (!done) { ListAccessKeysResponse response;
if(newMarker == null) { ListAccessKeysRequest request = ListAccessKeysRequest.builder() .userName(username).build(); response = iam.listAccessKeys(request); } else { ListAccessKeysRequest request = ListAccessKeysRequest.builder() .userName(username) .marker(newMarker).build(); response = iam.listAccessKeys(request); }
for (AccessKeyMetadata metadata : response.accessKeyMetadata()) { System.out.format("Retrieved access key %s", metadata.accessKeyId()); }
if (!response.isTruncated()) { done = true; } else { newMarker = response.marker(); } }} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1);} System.out.println("Done");
Os resultados de listAccessKeys são paginados (com um máximo de 100 registros por chamada).Você pode chamar isTruncated no objeto ListAccessKeysResponse retornado para ver se aconsulta retornou menos resultados do que estão disponíveis. Se esse for o caso, chame marker noListAccessKeysResponse e use-o ao criar uma nova solicitação. Use essa nova solicitação na próximainvocação de listAccessKeys.
Veja o exemplo completo no GitHub.
Recuperar a hora do uso mais recente de uma chave de acessoPara obter a hora em que uma chave de acesso foi usada pela última vez, chame o métodogetAccessKeyLastUsed do IamClient com o ID de chave de acesso, que pode ser passado usando umobjeto GetAccessKeyLastUsedRequest.
Depois, você pode usar o objeto GetAccessKeyLastUsedResponse retornado para recuperar a hora emque a chave foi usada pela última vez.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;
83
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar chaves de acesso do IAM
import software.amazon.awssdk.services.iam.model.GetAccessKeyLastUsedRequest;import software.amazon.awssdk.services.iam.model.GetAccessKeyLastUsedResponse;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void getAccessKeyLastUsed(IamClient iam, String accessId ){
try { GetAccessKeyLastUsedRequest request = GetAccessKeyLastUsedRequest.builder() .accessKeyId(accessId).build();
GetAccessKeyLastUsedResponse response = iam.getAccessKeyLastUsed(request);
System.out.println("Access key was last used at: " + response.accessKeyLastUsed().lastUsedDate());
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done");
Veja o exemplo completo no GitHub.
Ativar ou desativar chaves de acessoVocê pode ativar ou desativar uma chave de acesso criando um objeto UpdateAccessKeyRequest,fornecendo o ID de chave de acesso, como opção o nome do usuário e o Status desejado e passando oobjeto de solicitação para o método updateAccessKey do IamClient.
Importações
import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.StatusType;import software.amazon.awssdk.services.iam.model.UpdateAccessKeyRequest;import software.amazon.awssdk.services.iam.model.UpdateAccessKeyResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;
Código
public static void updateKey(IamClient iam, String username, String accessId, String status ) {
try { if (status.toLowerCase().equalsIgnoreCase("active")) { statusType = StatusType.ACTIVE; } else if (status.toLowerCase().equalsIgnoreCase("inactive")) { statusType = StatusType.INACTIVE; } else { statusType = StatusType.UNKNOWN_TO_SDK_VERSION; } UpdateAccessKeyRequest request = UpdateAccessKeyRequest.builder() .accessKeyId(accessId) .userName(username) .status(statusType) .build();
UpdateAccessKeyResponse response = iam.updateAccessKey(request);
84
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar usuários do IAM
Veja o exemplo completo no GitHub.
Excluir uma chave de acessoPara excluir permanentemente uma chave de acesso, chame o método deleteKey do IamClient,fornecendo um DeleteAccessKeyRequest que contenha o ID e o nome de usuário da chave de acesso.
Note
Depois de excluída, uma chave não poderá mais ser recuperada ou usada. Para desativartemporariamente uma chave de maneira que ela possa ser reativado mais tarde, use o métodoupdateAccessKey (p. 84) em seu lugar.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.DeleteAccessKeyRequest;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void deleteKey(IamClient iam ,String username, String accessKey ) {
try { DeleteAccessKeyRequest request = DeleteAccessKeyRequest.builder() .accessKeyId(accessKey) .userName(username).build();
iam.deleteAccessKey(request); System.out.println("Successfully deleted access key " + accessKey + " from user " + username);
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }}
Veja o exemplo completo no GitHub.
Mais informações• CreateAccessKey na IAM API Reference• ListAccessKeys na IAM API Reference• GetAccessKeyLastUsed na IAM API Reference• UpdateAccessKey na IAM API Reference• DeleteAccessKey na IAM API Reference
Gerenciar usuários do IAMCriação de um usuárioCrie um usuário do IAM fornecendo o nome de usuário para o método createUser do IamClient, usandoum objeto CreateUserRequest que contém o nome do usuário.
85
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar usuários do IAM
Importações
import software.amazon.awssdk.services.iam.model.CreateUserRequest;import software.amazon.awssdk.services.iam.model.CreateUserResponse;import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;
Código
public static String createIAMUser(IamClient iam, String username ) {
try { CreateUserRequest request = CreateUserRequest.builder() .userName(username).build();
CreateUserResponse response = iam.createUser(request); return response.user().userName();
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return "";}
Veja o exemplo completo no GitHub.
Listar usuáriosPara listar os usuários do IAM da conta, crie um ListUsersRequest e passe para o método listUsersdo IamClient. Você pode recuperar a lista de usuários chamando users no objeto ListUsersResponseretornado.
A lista de usuários retornados por listUsers é paginada. Você pode verificar se há mais resultadosa serem recuperados chamando o método isTruncated do objeto de resposta. Se ele retornar true,chame o método marker() do objeto de resposta. Use o valor do marcador para criar um novo objeto desolicitação. Em seguida, chame o método listUsers novamente com a nova solicitação.
Importações
import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.ListUsersRequest;import software.amazon.awssdk.services.iam.model.ListUsersResponse;import software.amazon.awssdk.services.iam.model.User;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;
Código
public static void listAllUsers(IamClient iam ) {
try {
boolean done = false; String newMarker = null;
while(!done) { ListUsersResponse response;
86
AWS SDK para Java versão 2 Guia do desenvolvedorGerenciar usuários do IAM
if (newMarker == null) { ListUsersRequest request = ListUsersRequest.builder().build(); response = iam.listUsers(request); } else { ListUsersRequest request = ListUsersRequest.builder() .marker(newMarker).build(); response = iam.listUsers(request); }
for(User user : response.users()) { System.out.format("\n Retrieved user %s", user.userName()); }
if(!response.isTruncated()) { done = true; } else { newMarker = response.marker(); } } } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done");
Veja o exemplo completo no GitHub.
Atualizar um usuárioPara atualizar um usuário, chame o método updateUser do objeto de IamClient, que utiliza um objetoUpdateUserRequest que pode ser usado por você para alterar o nome ou o caminho do usuário.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.UpdateUserRequest;import software.amazon.awssdk.services.iam.model.UpdateUserResponse;
Código
public static void updateIAMUser(IamClient iam, String curName,String newName ) {
try { UpdateUserRequest request = UpdateUserRequest.builder() .userName(curName) .newUserName(newName).build();
UpdateUserResponse response = iam.updateUser(request); System.out.printf("Successfully updated user to username %s", newName); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done"); }
Veja o exemplo completo no GitHub.
87
AWS SDK para Java versão 2 Guia do desenvolvedorUsar aliases de conta do IAM
Excluir um usuárioPara excluir um usuário, chame a requisição deleteUser do IamClient com um objetoUpdateUserRequest definido com o nome de usuário a ser excluído.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.DeleteUserRequest;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void deleteIAMUser(IamClient iam, String username) {
try { DeleteUserRequest request = DeleteUserRequest.builder() .userName(username).build();
iam.deleteUser(request); System.out.println("Successfully deleted IAM user " + username); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done");}
Veja o exemplo completo no GitHub.
Mais informações• Usuários do IAM no IAM User Guide• Gerenciar usuários do IAM no IAM User Guide• CreateUser na IAM API Reference• ListUsers na IAM API Reference• UpdateUser na IAM API Reference• DeleteUser na IAM API Reference
Usar aliases de conta do IAMSe deseja que o URL para sua página de login contenha o nome da sua empresa (ou outro identificadoramigável) em vez do da sua conta da AWS, você pode criar um alias para o ID de sua conta da AWS.
Note
A AWS dá suporte a exatamente um alias por conta.
Criar um alias de contaPara criar um alias de conta, chame o método createAccountAlias do IamClient com um objetoCreateAccountAliasRequest que contém o nome de alias.
Importações
88
AWS SDK para Java versão 2 Guia do desenvolvedorUsar aliases de conta do IAM
import software.amazon.awssdk.services.iam.model.CreateAccountAliasRequest;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void createIAMAccountAlias(IamClient iam, String alias) {
try { CreateAccountAliasRequest request = CreateAccountAliasRequest.builder() .accountAlias(alias).build();
iam.createAccountAlias(request); System.out.println("Successfully created account alias: " + alias);
} catch ( IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done");}
Veja o exemplo completo no GitHub.
Listar aliases de contaPara listar o alias da conta, se houver, chame o método listAccountAliases do IamClient.
Note
O ListAccountAliasesResponse retornado oferece suporte aos mesmos métodos isTruncatede marker como outros métodos list do AWS SDK for Java, mas uma conta da AWS pode tersomente um alias de conta.
Importações
import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.ListAccountAliasesResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;
Código
public static void listAliases(IamClient iam) {
try { ListAccountAliasesResponse response = iam.listAccountAliases();
for (String alias : response.accountAliases()) { System.out.printf("Retrieved account alias %s", alias); }
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done");}
89
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com políticas do IAM
Veja o exemplo completo no GitHub.
Excluir um alias de contaPara excluir o alias da conta, chame o método deleteAccountAlias do IamClient. Ao excluir um aliasde conta, você deve fornecer o nome usando um objeto DeleteAccountAliasRequest.
Importações
import software.amazon.awssdk.services.iam.model.DeleteAccountAliasRequest;import software.amazon.awssdk.services.iam.model.DeleteAccountAliasResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void deleteIAMAccountAlias(IamClient iam,String alias ) {
try { DeleteAccountAliasRequest request = DeleteAccountAliasRequest.builder() .accountAlias(alias).build();
DeleteAccountAliasResponse response = iam.deleteAccountAlias(request); System.out.println("Successfully deleted account alias " + alias);
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done");
Veja o exemplo completo no GitHub.
Mais informações• ID da conta da AWS e o alias no IAM User Guide• CreateAccountAlias na IAM API Reference• ListAccountAliases na IAM API Reference• DeleteAccountAlias na IAM API Reference
Trabalhar com políticas do IAMCriar uma políticaPara criar uma política, forneça o nome da política e um documento de política formatado em JSON em umCreatePolicyRequest para o método createPolicy do IamClient.
Importações
import software.amazon.awssdk.services.iam.model.CreatePolicyRequest;import software.amazon.awssdk.services.iam.model.CreatePolicyResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;
90
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com políticas do IAM
Código
public static String createIAMPolicy(IamClient iam, String policyName ) {
try { CreatePolicyRequest request = CreatePolicyRequest.builder() .policyName(policyName) .policyDocument(PolicyDocument).build();
CreatePolicyResponse response = iam.createPolicy(request);
return response.policy().arn(); } catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return "" ;}
Veja o exemplo completo no GitHub.
Obter uma políticaPara recuperar uma política existente, chame o método getPolicy do IamClient fornecendo o ARN dapolítica em um objeto GetPolicyRequest.
Importações
import software.amazon.awssdk.services.iam.model.GetPolicyRequest;import software.amazon.awssdk.services.iam.model.GetPolicyResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void getIAMPolicy(IamClient iam, String policyArn) {
try {
GetPolicyRequest request = GetPolicyRequest.builder() .policyArn(policyArn).build();
GetPolicyResponse response = iam.getPolicy(request);
System.out.format("Successfully retrieved policy %s", response.policy().policyName());
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1);} System.out.println("Done");}
Veja o exemplo completo no GitHub.
Anexar uma política de funçãoVocê pode anexar uma política a uma função do IAM chamando o método attachRolePolicy doIamClient, fornecendo o nome da função e o ARN da política em um AttachRolePolicyRequest.
91
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com políticas do IAM
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.AttachRolePolicyRequest;import software.amazon.awssdk.services.iam.model.AttachedPolicy;import software.amazon.awssdk.services.iam.model.ListAttachedRolePoliciesRequest;import software.amazon.awssdk.services.iam.model.ListAttachedRolePoliciesResponse;import java.util.ArrayList;import java.util.List;import java.util.stream.Collectors;
Código
public static void attachIAMRolePolicy(IamClient iam,String roleName, String policyArn ) {
try {
List<AttachedPolicy> matchingPolicies = new ArrayList<>();
boolean done = false; String newMarker = null;
while(!done) {
ListAttachedRolePoliciesResponse response;
if (newMarker == null) { ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder() .roleName(roleName).build(); response = iam.listAttachedRolePolicies(request); } else { ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder() .roleName(roleName) .marker(newMarker).build(); response = iam.listAttachedRolePolicies(request); }
matchingPolicies.addAll( response.attachedPolicies() .stream() .filter(p -> p.policyName().equals(roleName)) .collect(Collectors.toList()));
if(!response.isTruncated()) { done = true;
} else { newMarker = response.marker(); } }
if (matchingPolicies.size() > 0) { System.out.println(roleName + " policy is already attached to this role."); return; }
AttachRolePolicyRequest attachRequest = AttachRolePolicyRequest.builder() .roleName(roleName)
92
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com políticas do IAM
.policyArn(policyArn).build();
iam.attachRolePolicy(attachRequest);
System.out.println("Successfully attached policy " + policyArn + " to role " + roleName);
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Listar políticas de função anexadasListe políticas anexadas em uma função chamando o método listAttachedRolePolicies doIamClient. Ele utiliza um objeto ListAttachedRolePoliciesRequest que contém o nome da função para listaras políticas.
Chame getAttachedPolicies no objeto ListAttachedRolePoliciesResponse retornadopara obter a lista de políticas anexadas. Os resultados podem estar truncados; se o métodoListAttachedRolePoliciesResponse do objeto isTruncated retornar true, chame o métodoListAttachedRolePoliciesResponse do objeto marker. Use o marcador retornado para criar umanova solicitação e use-o para chamar listAttachedRolePolicies novamente a fim de obter o próximolote de resultados.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.AttachRolePolicyRequest;import software.amazon.awssdk.services.iam.model.AttachedPolicy;import software.amazon.awssdk.services.iam.model.ListAttachedRolePoliciesRequest;import software.amazon.awssdk.services.iam.model.ListAttachedRolePoliciesResponse;import java.util.ArrayList;import java.util.List;import java.util.stream.Collectors;
Código
public static void attachIAMRolePolicy(IamClient iam,String roleName, String policyArn ) {
try {
List<AttachedPolicy> matchingPolicies = new ArrayList<>();
boolean done = false; String newMarker = null;
while(!done) {
ListAttachedRolePoliciesResponse response;
if (newMarker == null) { ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder() .roleName(roleName).build(); response = iam.listAttachedRolePolicies(request); } else {
93
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com políticas do IAM
ListAttachedRolePoliciesRequest request = ListAttachedRolePoliciesRequest.builder() .roleName(roleName) .marker(newMarker).build(); response = iam.listAttachedRolePolicies(request); }
matchingPolicies.addAll( response.attachedPolicies() .stream() .filter(p -> p.policyName().equals(roleName)) .collect(Collectors.toList()));
if(!response.isTruncated()) { done = true;
} else { newMarker = response.marker(); } }
if (matchingPolicies.size() > 0) { System.out.println(roleName + " policy is already attached to this role."); return; }
AttachRolePolicyRequest attachRequest = AttachRolePolicyRequest.builder() .roleName(roleName) .policyArn(policyArn).build();
iam.attachRolePolicy(attachRequest);
System.out.println("Successfully attached policy " + policyArn + " to role " + roleName);
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Desanexar uma política de funçãoPara desanexar uma política de uma função, chame o método detachRolePolicy do IamClientfornecendo o nome da função e o ARN da política em um DetachRolePolicyRequest.
Importações
import software.amazon.awssdk.services.iam.model.DetachRolePolicyRequest;import software.amazon.awssdk.services.iam.model.DetachRolePolicyResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void detachPolicy(IamClient iam, String roleName, String policyArn ) {
try {
94
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com certificados de servidor do IAM
DetachRolePolicyRequest request = DetachRolePolicyRequest.builder() .roleName(roleName) .policyArn(policyArn).build();
DetachRolePolicyResponse response = iam.detachRolePolicy(request);
System.out.println("Successfully detached policy " + policyArn + " from role " + roleName);
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Mais informações• Visão geral de políticas do IAM no IAM User Guide.• Referência de política do AWS IAM no IAM User Guide.• CreatePolicy na IAM API Reference• GetPolicy na IAM API Reference• AttachRolePolicy na IAM API Reference• ListAttachedRolePolicies na IAM API Reference• DetachRolePolicy na IAM API Reference
Trabalhar com certificados de servidor do IAMPara permitir conexões HTTPS com o site ou o aplicativo na AWS, você precisa de um certificado deservidor SSL/TLS. Você pode usar um certificado de servidor fornecido pelo AWS Certificate Manager ouum obtido junto a um provedor externo.
Recomendamos usar o ACM para provisionar, gerenciar e implantar os certificados de servidor. Como ACM você pode solicitar um certificado, implantá-lo nos recursos da AWS e deixar o ACM processarrenovações de certificado para você. Os certificados fornecidos pelo ACM são gratuitos. Para obter maisinformações sobre o ACM, consulte o Guia do usuário do ACM.
Obter um certificado do servidorVocê pode recuperar um certificado de servidor chamando o método getServerCertificate deIamClient, passando um GetServerCertificateRequest com o nome do certificado.
Importações
import software.amazon.awssdk.services.iam.model.GetServerCertificateRequest;import software.amazon.awssdk.services.iam.model.GetServerCertificateResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void getCertificate(IamClient iam,String certName ) {
try {
95
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com certificados de servidor do IAM
GetServerCertificateRequest request = GetServerCertificateRequest.builder() .serverCertificateName(certName).build();
GetServerCertificateResponse response = iam.getServerCertificate(request);
System.out.format("Successfully retrieved certificate with body %s", response.serverCertificate().certificateBody());
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1);} System.out.println("Done");}
Veja o exemplo completo no GitHub.
Listar certificados do servidorPara listar os certificados de servidor, chame o método listServerCertificates de IamClient com umListServerCertificatesRequest. Ele retorna um ListServerCertificatesResponse.
Chame o método serverCertificateMetadataList do objeto ListServerCertificateResponsepara obter uma lista de objetos ServerCertificateMetadata usados por você para obter informações sobrecada certificado.
Os resultados podem estar truncados; se o método ListServerCertificateResponse doobjeto isTruncated retornar true, chame o método ListServerCertificatesResponse doobjeto marker e use o marcador para criar uma solicitação. Use a nova solicitação para chamarlistServerCertificates novamente a fim de obter o próximo lote de resultados.
Importações
import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.ListServerCertificatesRequest;import software.amazon.awssdk.services.iam.model.ListServerCertificatesResponse;import software.amazon.awssdk.services.iam.model.ServerCertificateMetadata;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;
Código
public static void listCertificates(IamClient iam) {
try { boolean done = false; String newMarker = null;
while(!done) { ListServerCertificatesResponse response;
if (newMarker == null) { ListServerCertificatesRequest request = ListServerCertificatesRequest.builder().build(); response = iam.listServerCertificates(request); } else { ListServerCertificatesRequest request = ListServerCertificatesRequest.builder() .marker(newMarker).build(); response = iam.listServerCertificates(request); }
96
AWS SDK para Java versão 2 Guia do desenvolvedorTrabalhar com certificados de servidor do IAM
for(ServerCertificateMetadata metadata : response.serverCertificateMetadataList()) { System.out.printf("Retrieved server certificate %s", metadata.serverCertificateName()); }
if(!response.isTruncated()) { done = true; } else { newMarker = response.marker(); } }} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1);} System.out.println("Done");
Veja o exemplo completo no GitHub.
Atualizar um certificado do servidorVocê pode atualizar o nome ou o caminho de um certificado de servidor chamando o métodoupdateServerCertificate do IamClient. Ele utiliza um objeto UpdateServerCertificateRequest definidocom o nome atual do certificado de servidor e um novo nome ou caminho a ser usado.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;import software.amazon.awssdk.services.iam.model.UpdateServerCertificateRequest;import software.amazon.awssdk.services.iam.model.UpdateServerCertificateResponse;
Código
public static void updateCertificate(IamClient iam, String curName, String newName) {
try { UpdateServerCertificateRequest request = UpdateServerCertificateRequest.builder() .serverCertificateName(curName) .newServerCertificateName(newName) .build();
UpdateServerCertificateResponse response = iam.updateServerCertificate(request);
System.out.printf("Successfully updated server certificate to name %s", newName);
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done");}
Veja o exemplo completo no GitHub.
97
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon Kinesis
Excluir um certificado do servidorPara excluir um certificado de servidor, chame o método deleteServerCertificate de IamClient comum DeleteServerCertificateRequest contendo o nome do certificado.
Importações
import software.amazon.awssdk.services.iam.model.DeleteServerCertificateRequest;import software.amazon.awssdk.services.iam.model.DeleteServerCertificateResponse;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.iam.IamClient;import software.amazon.awssdk.services.iam.model.IamException;
Código
public static void deleteCert(IamClient iam,String certName ) {
try { DeleteServerCertificateRequest request = DeleteServerCertificateRequest.builder() .serverCertificateName(certName).build();
DeleteServerCertificateResponse response = iam.deleteServerCertificate(request);
System.out.println("Successfully deleted server certificate " + certName);
} catch (IamException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } System.out.println("Done");}
Veja o exemplo completo no GitHub.
Mais informações• Trabalhar com certificados de servidor no IAM User Guide• GetServerCertificate na IAM API Reference• ListServerCertificates na IAM API Reference• UpdateServerCertificate na IAM API Reference• DeleteServerCertificate na IAM API Reference• Guia do usuário do ACM
Exemplos do Kinesis usando o AWS SDK for JavaEsta seção apresenta exemplos de como programar o Amazon Kinesis usando o AWS SDK for Java 2.0.
Para obter mais informações sobre o Kinesis, consulte o Guia do desenvolvedor do Amazon Kinesis.
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O códigode exemplo completo está disponível no GitHub. A partir daí, você pode fazer download de um únicoarquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilaçãoe execução.
98
AWS SDK para Java versão 2 Guia do desenvolvedorAssinar streamings de dados do Amazon Kinesis
Tópicos• Assinar streamings de dados do Amazon Kinesis (p. 99)
Assinar streamings de dados do Amazon KinesisOs exemplos a seguir mostram como recuperar e processar dados do Amazon Kinesis DataStreams usando o método subscribeToShard. O Kinesis Data Streams agora emprega o recurso"fanout" aprimorado uma API de recuperação de dados HTTP/2 de baixa latência, o que facilita paradesenvolvedores executar vários aplicativos de alto desempenho e baixa latência no mesmo fluxo dedados do Kinesis.
ConfigurarPrimeiro, crie um cliente do Kinesis assíncrono e um objeto SubscribeToShardRequest. Esses objetos sãousados em cada um dos exemplos a seguir para se inscrever em eventos do Kinesis.
Importações
import java.util.concurrent.CompletableFuture;import java.util.concurrent.atomic.AtomicInteger;import org.reactivestreams.Subscriber;import org.reactivestreams.Subscription;import software.amazon.awssdk.core.async.SdkPublisher;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.kinesis.KinesisAsyncClient;import software.amazon.awssdk.services.kinesis.model.ShardIteratorType;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardEvent;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardEventStream;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardRequest;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardResponse;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardResponseHandler;
Código
Region region = Region.US_EAST_1;KinesisAsyncClient client = KinesisAsyncClient.builder().region(region).build();
SubscribeToShardRequest request = SubscribeToShardRequest.builder() .consumerARN(CONSUMER_ARN) .shardId("arn:aws:kinesis:us-east-1:814548047983:stream/StockTradeStream") .startingPosition(s -> s.type(ShardIteratorType.LATEST)).build();
Usar a interface do construtorVocê pode usar o método builder para simplificar a criação de SubscribeToShardResponseHandler.
Usando o construtor, você pode definir cada retorno de chamada do ciclo de vida com um método dechamada em vez de implementar a interface completa.
Código
private static CompletableFuture<Void> responseHandlerBuilder(KinesisAsyncClient client, SubscribeToShardRequest request) { SubscribeToShardResponseHandler responseHandler = SubscribeToShardResponseHandler
99
AWS SDK para Java versão 2 Guia do desenvolvedorAssinar streamings de dados do Amazon Kinesis
.builder() .onError(t -> System.err.println("Error during stream - " + t.getMessage())) .onComplete(() -> System.out.println("All records stream successfully")) // Must supply some type of subscriber .subscriber(e -> System.out.println("Received event - " + e)) .build(); return client.subscribeToShard(request, responseHandler);}
Para ter mais controle do editor, você pode usar o método publisherTransformer para personalizar oeditor.
Código
private static CompletableFuture<Void> responseHandlerBuilderPublisherTransformer(KinesisAsyncClient client, SubscribeToShardRequest request) { SubscribeToShardResponseHandler responseHandler = SubscribeToShardResponseHandler .builder() .onError(t -> System.err.println("Error during stream - " + t.getMessage())) .publisherTransformer(p -> p.filter(e -> e instanceof SubscribeToShardEvent).limit(100)) .subscriber(e -> System.out.println("Received event - " + e)) .build(); return client.subscribeToShard(request, responseHandler);}
Veja o exemplo completo no GitHub.
Usar um manipulador de respostas personalizadoPara ter o controle total do assinante e do editor, implemente a interfaceSubscribeToShardResponseHandler.
Neste exemplo, você implementa o método onEventStream, que permite o acesso total ao editor. Issodemonstra como transformar o editor em registros de eventos para impressão pelo assinante.
Código
private static CompletableFuture<Void> responseHandlerBuilderClassic(KinesisAsyncClient client, SubscribeToShardRequest request) { SubscribeToShardResponseHandler responseHandler = new SubscribeToShardResponseHandler() {
@Override public void responseReceived(SubscribeToShardResponse response) { System.out.println("Receieved initial response"); }
@Override public void onEventStream(SdkPublisher<SubscribeToShardEventStream> publisher) { publisher // Filter to only SubscribeToShardEvents .filter(SubscribeToShardEvent.class) // Flat map into a publisher of just records .flatMapIterable(SubscribeToShardEvent::records) // Limit to 1000 total records .limit(1000) // Batch records into lists of 25 .buffer(25) // Print out each record batch .subscribe(batch -> System.out.println("Record Batch - " + batch));
100
AWS SDK para Java versão 2 Guia do desenvolvedorAssinar streamings de dados do Amazon Kinesis
}
@Override public void complete() { System.out.println("All records stream successfully"); }
@Override public void exceptionOccurred(Throwable throwable) { System.err.println("Error during stream - " + throwable.getMessage()); } }; return client.subscribeToShard(request, responseHandler);}
Veja o exemplo completo no GitHub.
Usar a interface do visitanteVocê pode usar um objeto Visitante para se inscrever em eventos específicos que tenha interesse emassistir.
Código
private static CompletableFuture<Void> responseHandlerBuilderVisitorBuilder(KinesisAsyncClient client, SubscribeToShardRequest request) { SubscribeToShardResponseHandler.Visitor visitor = SubscribeToShardResponseHandler.Visitor .builder() .onSubscribeToShardEvent(e -> System.out.println("Received subscribe to shard event " + e)) .build(); SubscribeToShardResponseHandler responseHandler = SubscribeToShardResponseHandler .builder() .onError(t -> System.err.println("Error during stream - " + t.getMessage())) .subscriber(visitor) .build(); return client.subscribeToShard(request, responseHandler);}
Veja o exemplo completo no GitHub.
Usar um assinante personalizadoVocê também pode implementar seu próprio assinante personalizado para se inscrever no streaming.
Este trecho de código mostra um exemplo de assinante.
Código
private static class MySubscriber implements Subscriber<SubscribeToShardEventStream> {
private Subscription subscription; private AtomicInteger eventCount = new AtomicInteger(0);
@Override public void onSubscribe(Subscription subscription) { this.subscription = subscription; this.subscription.request(1); }
101
AWS SDK para Java versão 2 Guia do desenvolvedorAssinar streamings de dados do Amazon Kinesis
@Override public void onNext(SubscribeToShardEventStream shardSubscriptionEventStream) { System.out.println("Received event " + shardSubscriptionEventStream); if (eventCount.incrementAndGet() >= 100) { // Cancel the subscription at any time to stop receiving events subscription.cancel(); } subscription.request(1); }
@Override public void onError(Throwable throwable) { System.err.println("Error occurred while stream - " + throwable.getMessage()); }
@Override public void onComplete() { System.out.println("Finished streaming all events"); }}
Você pode passar esse assinante personalizado para o método subscribe, de forma semelhante aosexemplos de visualização. O trecho de código a seguir mostra esse exemplo.
Código
private static CompletableFuture<Void> responseHandlerBuilderSubscriber(KinesisAsyncClient client, SubscribeToShardRequest request) { SubscribeToShardResponseHandler responseHandler = SubscribeToShardResponseHandler .builder() .onError(t -> System.err.println("Error during stream - " + t.getMessage())) .subscriber(MySubscriber::new) .build(); return client.subscribeToShard(request, responseHandler);}
Veja o exemplo completo no GitHub.
Gravar registros de dados em um stream de dados do KinesisVocê pode usar o objeto KinesisClient para gravar registros de dados em um stream de dados do Kinesisusando o método putRecords. Para chamar esse método com êxito, crie um objeto PutRecordsRequest. Passe o nome do fluxo de dados para o método streamName. Além disso, passe os dados usando ométodo putRecords (como mostrado no exemplo de código a seguir).
Importações
import java.net.URI;import java.util.concurrent.CompletableFuture;
import io.reactivex.Flowable;import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;import software.amazon.awssdk.core.async.SdkPublisher;import software.amazon.awssdk.http.Protocol;import software.amazon.awssdk.http.SdkHttpConfigurationOption;import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.kinesis.KinesisAsyncClient;import software.amazon.awssdk.services.kinesis.model.ShardIteratorType;import software.amazon.awssdk.services.kinesis.model.StartingPosition;
102
AWS SDK para Java versão 2 Guia do desenvolvedorAssinar streamings de dados do Amazon Kinesis
import software.amazon.awssdk.services.kinesis.model.SubscribeToShardEvent;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardRequest;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardResponseHandler;import software.amazon.awssdk.utils.AttributeMap;
No exemplo de código Java a seguir, observe que o objeto StockTrade é usado como os dados que serãogravado no stream de dados do Kinesis. Antes de executar o exemplo, certifique-se de que você criou ofluxo de dados.
Código
private static CompletableFuture<Void> responseHandlerBuilderSubscriber(KinesisAsyncClient client, SubscribeToShardRequest request) { SubscribeToShardResponseHandler responseHandler = SubscribeToShardResponseHandler .builder() .onError(t -> System.err.println("Error during stream - " + t.getMessage())) .subscriber(MySubscriber::new) .build(); return client.subscribeToShard(request, responseHandler);}
Veja o exemplo completo no GitHub.
Usar uma biblioteca de terceirosVocê pode usar outras bibliotecas de terceiros em vez de implementar um assinante personalizado. Esteexemplo demonstra como usar a implementação RxJava, mas você pode usar qualquer biblioteca queimplemente interfaces de streams reativos. Consulte a página da Wikipédia RxJava no GitHub para obtermais informações sobre essa biblioteca.
Para usar a biblioteca, adicione-a como uma dependência. Se estiver usando o Maven, o exemplo mostrao trecho POM a ser usado.
Entrada POM
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.1</version> <configuration>
Importações
import java.net.URI;import java.util.concurrent.CompletableFuture;
import io.reactivex.Flowable;import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;import software.amazon.awssdk.core.async.SdkPublisher;import software.amazon.awssdk.http.Protocol;import software.amazon.awssdk.http.SdkHttpConfigurationOption;import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.kinesis.KinesisAsyncClient;import software.amazon.awssdk.services.kinesis.model.ShardIteratorType;import software.amazon.awssdk.services.kinesis.model.StartingPosition;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardEvent;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardRequest;import software.amazon.awssdk.services.kinesis.model.SubscribeToShardResponseHandler;
103
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon Lambda
import software.amazon.awssdk.utils.AttributeMap;
Este exemplo usa RxJava no método do ciclo de vida onEventStream. Assim, você tem acesso total aoeditor, que pode ser usado para criar um Rx Flowable.
Código
SubscribeToShardResponseHandler responseHandler = SubscribeToShardResponseHandler .builder() .onError(t -> System.err.println("Error during stream - " + t.getMessage())) .onEventStream(p -> Flowable.fromPublisher(p) .ofType(SubscribeToShardEvent.class) .flatMapIterable(SubscribeToShardEvent::records) .limit(1000) .buffer(25) .subscribe(e -> System.out.println("Record batch = " + e))) .build();
Você também pode usar o método publisherTransformer com o editor Flowable. Você deve adaptaro editor Flowable para um SdkPublisher, conforme mostrado no exemplo a seguir.
Código
SubscribeToShardResponseHandler responseHandler = SubscribeToShardResponseHandler .builder() .onError(t -> System.err.println("Error during stream - " + t.getMessage())) .publisherTransformer(p -> SdkPublisher.adapt(Flowable.fromPublisher(p).limit(100))) .build();
Veja o exemplo completo no GitHub.
Mais informações• SubscribeToShardEvent na Amazon Kinesis API Reference• SubscribeToShard na Amazon Kinesis API Reference
Exemplos do AWS Lambda para o AWS SDK forJava
Esta seção apresenta exemplos de como programar o Lambda usando o AWS SDK for Java 2.0.
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O códigode exemplo completo está disponível no GitHub. A partir daí, você pode fazer download de um únicoarquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilaçãoe execução.
Tópicos• Invocar, listar e excluir funções do AWS Lambda (p. 104)
Invocar, listar e excluir funções do AWS LambdaEsta seção fornece exemplos de programação com o cliente de serviço do Lambda usando o AWS SDKpara Java 2.0.
104
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de serviço
Tópicos• Invocar uma função do Lambda (p. 105)• Listar as funções do Lambda (p. 106)• Excluir uma função do Lambda (p. 106)
Invocar uma função do LambdaÉ possível invocar uma função do Lambda criando um objeto LambdaClient e chamando o métodoinvoke. Crie um objeto InvokeRequest para especificar informações adicionais, como o nome da funçãoe a carga útil a serem transmitidas para a função do Lambda. Os nomes da função aparecem comoarn:aws:lambda:us-west-2:555556330391:function:HelloFunction. É possível recuperar o valor examinandoa função no Console AWS.
Para passar dados de conteúdo para uma função, crie um objeto SdkBytes que contenha informações. Porexemplo, no exemplo de código a seguir, observe os dados JSON passados para a função do Lambda.
Importações
import software.amazon.awssdk.services.lambda.LambdaClient;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.lambda.model.InvokeRequest;import software.amazon.awssdk.core.SdkBytes;import software.amazon.awssdk.services.lambda.model.InvokeResponse;import software.amazon.awssdk.services.lambda.model.ServiceException;
Código
O exemplo de código a seguir demonstra como invocar uma função do Lambda.
/* Function names appear as arn:aws:lambda:us-west-2:335556330391:function:HelloFunction you can retrieve the value by looking at the function in the AWS Console */ String functionName = args[0];
InvokeResponse res = null ; try { Region region = Region.US_WEST_2; LambdaClient awsLambda = LambdaClient.builder().region(region).build();
//Need a SdkBytes instance for the payload SdkBytes payload = SdkBytes.fromUtf8String("{\n" + " \"Hello \": \"Paris\",\n" + " \"countryCode\": \"FR\"\n" + "}" ) ;
//Setup an InvokeRequest InvokeRequest request = InvokeRequest.builder() .functionName(functionName) .payload(payload) .build();
//Invoke the Lambda function res = awsLambda.invoke(request);
//Get the response String value = res.payload().asUtf8String() ;
//write out the response
105
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de serviço
System.out.println(value);
} catch(ServiceException e) { e.getStackTrace(); }
Veja o exemplo completo no GitHub.
Listar as funções do LambdaCrie um objeto LambdaClient e invoque seu método listFunctions. Este método retorna um objetoListFunctionsResponse. É possível invocar o método functions desse objeto para retornar uma lista deobjetos FunctionConfiguration. É possível percorrer a lista para recuperar informações sobre as funções.Por exemplo, o exemplo de código Java a seguir mostra como obter cada nome de função.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.lambda.LambdaClient;import software.amazon.awssdk.services.lambda.model.ListFunctionsResponse;import software.amazon.awssdk.services.lambda.model.FunctionConfiguration;import software.amazon.awssdk.services.lambda.model.ServiceException;import java.util.Iterator;import java.util.List;
Código
O exemplo de código Java a seguir demonstra como recuperar uma lista de nomes de função.
ListFunctionsResponse functionResult = null ; try { Region region = Region.US_WEST_2; LambdaClient awsLambda = LambdaClient.builder().region(region).build();
//Get a list of all functions functionResult = awsLambda.listFunctions();
List<FunctionConfiguration> list = functionResult.functions();
for (Iterator iter = list.iterator(); iter.hasNext(); ) { FunctionConfiguration config = (FunctionConfiguration)iter.next(); System.out.println("The function name is "+config.functionName()); } } catch(ServiceException e) { e.getStackTrace(); }
Veja o exemplo completo no GitHub.
Excluir uma função do LambdaCrie um objeto LambdaClient e invoque seu método deleteFunction. Crie um objetoDeleteFunctionRequest e transmita-o ao método deleteFunction. Esse objeto contém informaçõescomo o nome da função a ser excluída. Os nomes da função aparecem como arn:aws:lambda:us-west-2:555556330391:function:HelloFunction. É possível recuperar o valor examinando a função noConsole AWS.
Importações
import software.amazon.awssdk.services.lambda.LambdaClient;
106
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon Pinpoint
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.lambda.model.DeleteFunctionRequest;import software.amazon.awssdk.services.lambda.model.ServiceException;
Código
O seguinte código Java demonstra como excluir uma função do Lambda.
String functionName = args[0]; try { Region region = Region.US_WEST_2; LambdaClient awsLambda = LambdaClient.builder().region(region).build();
//Setup an DeleteFunctionRequest DeleteFunctionRequest request = DeleteFunctionRequest.builder() .functionName(functionName) .build();
//Invoke the Lambda deleteFunction method awsLambda.deleteFunction(request); System.out.println("Done"); } catch(ServiceException e) { e.getStackTrace(); }
Veja o exemplo completo no GitHub.
Exemplos do Amazon PinpointÉ possível usar o Amazon Pinpoint para enviar mensagens relevantes e personalizadas para seus clientespor meio de vários canais de comunicação, como notificações por push, SMS e e-mail.
Criar um projetoUm projeto (ou aplicativo) no Amazon Pinpoint é um conjunto de configurações, dados de clientes,segmentos e campanhas.
Para criar um projeto, comece compilando um objeto CreateApplicationRequest com o nome doprojeto como o valor do name(). Compile um objeto CreateAppRequest transmitindo o objetoCreateApplicationRequest como o valor do método createApplicationRequest(). Chame ométodo createApp() do PinpointClient transmitindo o objeto CreateAppRequest. Capture o resultadodessa solicitação como um objeto CreateAppResponse, conforme demonstrado no trecho de código aseguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.pinpoint.PinpointClient;import software.amazon.awssdk.services.pinpoint.model.CreateAppRequest;import software.amazon.awssdk.services.pinpoint.model.CreateAppResponse;import software.amazon.awssdk.services.pinpoint.model.CreateApplicationRequest;import software.amazon.awssdk.services.pinpoint.model.PinpointException;
Código
public static String createApplication(PinpointClient pinpoint, String appName) {
107
AWS SDK para Java versão 2 Guia do desenvolvedorCriar um segmento dinâmico
try { CreateApplicationRequest appRequest = CreateApplicationRequest.builder() .name(appName) .build();
CreateAppRequest request = CreateAppRequest.builder() .createApplicationRequest(appRequest) .build();
CreateAppResponse result = pinpoint.createApp(request);
return result.applicationResponse().id();
} catch (PinpointException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return "";
Veja o exemplo completo no GitHub.
Criar um segmento dinâmicoUm segmento é um conjunto de clientes que compartilham atributos específicos, como a cidade em quevivem ou a frequência com que visitam seu site. Um segmento dinâmico é aquele que é baseado ematributos definidos por você e que pode mudar ao longo do tempo.
Para criar um segmento dinâmico, primeiro compile todas as dimensões desejadas para esse segmento.Por exemplo, o seguinte trecho de código está definido para incluir clientes que estavam ativos no sitenos últimos 30 dias. É possível fazer isso primeiro compilando um objeto RecencyDimension com aduration() e o recencyType() que você deseja (ou seja, ACTIVE ou INACTIVE) e transmitindo esseobjeto para um objeto do compilador SegmentBehaviors como o valor de recency().
Quando você tiver definido seus atributos de segmento, compile-os em um objeto SegmentDimensions.Compile um objeto WriteSegmentRequest transmitindo o objeto SegmentDimensions como ovalor de dimensions(). Depois, compile um objeto CreateSegmentRequest transmitindo o objetoWriteSegmentRequest como o valor de writeSegmentRequest(). Finalmente, chame o métodocreateSegment() do PinpointClient transmitindo o objeto CreateSegmentRequest. Capture oresultado dessa solicitação como um objeto CreateSegmentResponse.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.pinpoint.PinpointClient;import software.amazon.awssdk.services.pinpoint.model.AttributeDimension;import software.amazon.awssdk.services.pinpoint.model.SegmentResponse;import software.amazon.awssdk.services.pinpoint.model.AttributeType;import software.amazon.awssdk.services.pinpoint.model.RecencyDimension;import software.amazon.awssdk.services.pinpoint.model.SegmentBehaviors;import software.amazon.awssdk.services.pinpoint.model.SegmentDemographics;import software.amazon.awssdk.services.pinpoint.model.SegmentLocation;import software.amazon.awssdk.services.pinpoint.model.SegmentDimensions;import software.amazon.awssdk.services.pinpoint.model.WriteSegmentRequest;import software.amazon.awssdk.services.pinpoint.model.CreateSegmentRequest;import software.amazon.awssdk.services.pinpoint.model.CreateSegmentResponse;import software.amazon.awssdk.services.pinpoint.model.PinpointException;import java.util.HashMap;import java.util.Map;
Código
108
AWS SDK para Java versão 2 Guia do desenvolvedorImportar um segmento estático
public static SegmentResponse createSegment(PinpointClient client, String appId) {
try { Map<String, AttributeDimension> segmentAttributes = new HashMap<>(); segmentAttributes.put("Team", AttributeDimension.builder() .attributeType(AttributeType.INCLUSIVE) .values("Lakers") .build());
RecencyDimension recencyDimension = RecencyDimension.builder() .duration("DAY_30") .recencyType("ACTIVE") .build();
SegmentBehaviors segmentBehaviors = SegmentBehaviors.builder() .recency(recencyDimension) .build();
SegmentDemographics segmentDemographics = SegmentDemographics .builder() .build();
SegmentLocation segmentLocation = SegmentLocation .builder() .build();
SegmentDimensions dimensions = SegmentDimensions .builder() .attributes(segmentAttributes) .behavior(segmentBehaviors) .demographic(segmentDemographics) .location(segmentLocation) .build();
WriteSegmentRequest writeSegmentRequest = WriteSegmentRequest.builder() .name("MySegment") .dimensions(dimensions) .build();
CreateSegmentRequest createSegmentRequest = CreateSegmentRequest.builder() .applicationId(appId) .writeSegmentRequest(writeSegmentRequest) .build();
CreateSegmentResponse createSegmentResult = client.createSegment(createSegmentRequest); System.out.println("Segment ID: " + createSegmentResult.segmentResponse().id()); System.out.println("Done"); return createSegmentResult.segmentResponse();
} catch (PinpointException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return null;}
Veja o exemplo completo no GitHub.
Importar um segmento estáticoUm segmento estático é aquele que você cria e importa de fora do Amazon Pinpoint. O código de exemploa seguir mostra como criar um segmento estático importando-o do Amazon S3.
109
AWS SDK para Java versão 2 Guia do desenvolvedorImportar um segmento estático
Pré-requisitoAntes de concluir este exemplo, é necessário criar uma função do IAM que conceda ao Amazon Pinpointacesso ao Amazon S3. Para obter mais informações, consulte a função do IAM para importar endpoints ousegmentos no Amazon Pinpoint Developer Guide.
Para importar um segmento estático, comece compilando um objeto ImportJobRequest. No compilador,especifique o s3Url(), o roleArn() e o format().
Note
Para obter mais informações sobre as propriedades de um objeto ImportJobRequest, consultea seção ImportJobRequest de Trabalhos de importação no Amazon Pinpoint API Reference.
Compile um objeto CreateImportJobRequest transmitindo o objeto ImportJobRequest como ovalor de importJobRequest() e o ID do projeto como o applicationId(). Chame o métodocreateImportJob() do PinpointClient transmitindo o objeto CreateImportJobRequest. Captureo resultado dessa solicitação como um objeto CreateImportJobResponse, conforme demonstrado notrecho de código a seguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.pinpoint.PinpointClient;import software.amazon.awssdk.services.pinpoint.model.CreateImportJobRequest;import software.amazon.awssdk.services.pinpoint.model.ImportJobResponse;import software.amazon.awssdk.services.pinpoint.model.ImportJobRequest;import software.amazon.awssdk.services.pinpoint.model.Format;import software.amazon.awssdk.services.pinpoint.model.CreateImportJobResponse;import software.amazon.awssdk.services.pinpoint.model.PinpointException;
Código
public static ImportJobResponse createImportSegment(PinpointClient client, String appId, String bucket, String key, String roleArn) {
try {
// Create the job ImportJobRequest importRequest = ImportJobRequest.builder() .defineSegment(true) .registerEndpoints(true) .roleArn(roleArn) .format(Format.JSON) .s3Url("s3://" + bucket + "/" + key) .build();
CreateImportJobRequest jobRequest = CreateImportJobRequest.builder() .importJobRequest(importRequest) .applicationId(appId) .build();
CreateImportJobResponse jobResponse = client.createImportJob(jobRequest);
return jobResponse.importJobResponse();
} catch (PinpointException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1);
110
AWS SDK para Java versão 2 Guia do desenvolvedorListar segmentos para o projeto
} return null;}
Veja o exemplo completo no GitHub.
Listar segmentos para o projetoPara listar os segmentos associados a um projeto específico, comece compilando um objetoGetSegmentsRequest com o ID do projeto como o valor do applicationId(). Depois, chame ométodo getSegments() do PinpointClient transmitindo o objeto GetSegmentsRequest. Captureo resultado dessa solicitação como um objeto GetSegmentsResponse. Finalmente, instancie umobjeto List upcasted para a classe SegmentResponse. Chame o segmentsResponse().item() deGetSegmentsResponse, como demonstrado no seguinte trecho de código. A partir daí, é possível iteraros resultados.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.pinpoint.PinpointClient;import software.amazon.awssdk.services.pinpoint.model.GetSegmentsRequest;import software.amazon.awssdk.services.pinpoint.model.GetSegmentsResponse;import software.amazon.awssdk.services.pinpoint.model.PinpointException;import software.amazon.awssdk.services.pinpoint.model.SegmentResponse;import java.util.List;
Código
public static void listSegs( PinpointClient pinpoint, String appId) {
try { GetSegmentsRequest request = GetSegmentsRequest.builder() .applicationId(appId) .build();
GetSegmentsResponse response = pinpoint.getSegments(request); List<SegmentResponse> segments = response.segmentsResponse().item();
for(SegmentResponse segment: segments) { System.out.println("Segement " + segment.id() + " " + segment.name() + " " + segment.lastModifiedDate()); } } catch ( PinpointException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Criar uma campanhaUma campanha é uma iniciativa destinada a envolver um determinado segmento de público enviandomensagens para esses clientes.
Para criar uma campanha, primeiro compile todas as configurações desejadas para esta campanha. Notrecho de código a seguir, por exemplo, a campanha será iniciada imediatamente porque o startTime()da Programação está definido como IMMEDIATE. Para configurá-la para iniciar em um horário específico,especifique uma hora no formato ISO 8601.
111
AWS SDK para Java versão 2 Guia do desenvolvedorCriar uma campanha
Note
Para obter mais informações sobre as configurações disponíveis para campanhas, consulte aseção Programação de Campanhas no Amazon Pinpoint API Reference.
Depois de definir a configuração da campanha, compile-a em um objeto WriteCampaignRequest. Nenhumdos métodos do builder() da WriteCampaignRequest são necessários. Porém, é necessário incluirqualquer uma das definições de configuração (MessageConfiguration) definidas para a campanha.Também recomendamos que você inclua um name e uma description para a campanha para quevocê possa distingui-la facilmente de outras campanhas. Chame o método createCampaign() doPinpointClient transmitindo o objeto WriteCampaignRequest. Capture o resultado dessa solicitaçãocomo um objeto CreateCampaignResponse.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.pinpoint.PinpointClient;import software.amazon.awssdk.services.pinpoint.model.CampaignResponse;import software.amazon.awssdk.services.pinpoint.model.Message;import software.amazon.awssdk.services.pinpoint.model.Schedule;import software.amazon.awssdk.services.pinpoint.model.Action;import software.amazon.awssdk.services.pinpoint.model.MessageConfiguration;import software.amazon.awssdk.services.pinpoint.model.WriteCampaignRequest;import software.amazon.awssdk.services.pinpoint.model.CreateCampaignResponse;import software.amazon.awssdk.services.pinpoint.model.CreateCampaignRequest;import software.amazon.awssdk.services.pinpoint.model.PinpointException;
Código
public static void createPinCampaign(PinpointClient pinpoint, String appId, String segmentId) {
CampaignResponse result = createCampaign(pinpoint, appId, segmentId); System.out.println("Campaign " + result.name() + " created."); System.out.println(result.description());
}
public static CampaignResponse createCampaign(PinpointClient client, String appID, String segmentID) {
try { Schedule schedule = Schedule.builder() .startTime("IMMEDIATE") .build();
Message defaultMessage = Message.builder() .action(Action.OPEN_APP) .body("My message body.") .title("My message title.") .build();
MessageConfiguration messageConfiguration = MessageConfiguration.builder() .defaultMessage(defaultMessage) .build();
WriteCampaignRequest request = WriteCampaignRequest.builder() .description("My description") .schedule(schedule) .name("MyCampaign")
112
AWS SDK para Java versão 2 Guia do desenvolvedorEnviar uma mensagem
.segmentId(segmentID) .messageConfiguration(messageConfiguration) .build();
CreateCampaignResponse result = client.createCampaign( CreateCampaignRequest.builder() .applicationId(appID) .writeCampaignRequest(request).build() );
System.out.println("Campaign ID: " + result.campaignResponse().id());
return result.campaignResponse();
} catch (PinpointException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
return null;}
Veja o exemplo completo no GitHub.
Enviar uma mensagemPara enviar uma mensagem de texto SMS pelo Amazon Pinpoint, primeiro compile um objetoAddressConfiguration para especificar o channelType(). (No exemplo a seguir, ele está definidocomo ChannelType.SMS para indicar que a mensagem será enviada via SMS.) Inicialize um HashMappara armazenar o número de telefone de destino e o objeto AddressConfiguration. Compile umobjeto SMSMessage que contém os valores relevantes. Eles incluem o originationNumber, o tipo demensagem (messageType) e o body da própria mensagem.
Quando você tiver criado a mensagem, compile o objeto SMSMessage em um objetoDirectMessageConfiguration. Compile o objeto Map e o objeto DirectMessageConfigurationem um objeto MessageRequest. Compile um objeto SendMessagesRequest incluindo o ID doprojeto (applicationId) e o objeto MessageRequest. Chame o método sendMessages() doPinpointClient transmitindo o objeto SendMessagesRequest. Capture o resultado dessa solicitaçãocomo um objeto SendMessagesResponse.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.pinpoint.PinpointClient;import software.amazon.awssdk.services.pinpoint.model.DirectMessageConfiguration;import software.amazon.awssdk.services.pinpoint.model.SMSMessage;import software.amazon.awssdk.services.pinpoint.model.AddressConfiguration;import software.amazon.awssdk.services.pinpoint.model.ChannelType;import software.amazon.awssdk.services.pinpoint.model.MessageRequest;import software.amazon.awssdk.services.pinpoint.model.SendMessagesRequest;import software.amazon.awssdk.services.pinpoint.model.SendMessagesResponse;import software.amazon.awssdk.services.pinpoint.model.MessageResponse;import software.amazon.awssdk.services.pinpoint.model.PinpointException;import java.util.HashMap;import java.util.Map;
Código
public static void sendSMSMessage(PinpointClient pinpoint, String message) {
113
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon S3
try {
Map<String, AddressConfiguration> addressMap = new HashMap<String, AddressConfiguration>();
AddressConfiguration addConfig = AddressConfiguration.builder() .channelType(ChannelType.SMS) .build();
addressMap.put(destinationNumber, addConfig);
SMSMessage smsMessage = SMSMessage.builder() .body(message) .messageType(messageType) .originationNumber(originationNumber) .senderId(senderId) .keyword(registeredKeyword) .build();
// Create a DirectMessageConfiguration object DirectMessageConfiguration direct = DirectMessageConfiguration.builder() .smsMessage(smsMessage) .build();
MessageRequest msgReq = MessageRequest.builder() .addresses(addressMap) .messageConfiguration(direct) .build();
// create a SendMessagesRequest object SendMessagesRequest request = SendMessagesRequest.builder() .applicationId(appId) .messageRequest(msgReq) .build();
SendMessagesResponse response= pinpoint.sendMessages(request);
MessageResponse msg1 = response.messageResponse(); Map map1 = msg1.result();
//Write out the result of sendMessage map1.forEach((k, v) -> System.out.println((k + ":" + v)));
} catch (PinpointException e) { e.getStackTrace();}
Veja o exemplo completo no GitHub.
Para obter mais informações, consulte o Guia do desenvolvedor do Amazon Pinpoint.
Amazon S3 Exemplos usando o AWS SDK for JavaEsta seção apresenta exemplos de como programar o Amazon S3 usando o AWS SDK for Java 2.0.
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O códigode exemplo completo está disponível no GitHub. A partir daí, você pode fazer download de um únicoarquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilaçãoe execução.
Tópicos
114
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de buckets
• Criar, listar e excluir buckets do Amazon S3 (p. 115)• Trabalhar com objetos do Amazon S3 (p. 118)
Criar, listar e excluir buckets do Amazon S3Cada objeto (arquivo) no Amazon S3 deve residir em um bucket. Um bucket representa um conjunto(contêiner) de objetos. Cada bucket deve ter uma chave (nome) exclusiva. Para obter informaçõesdetalhadas sobre buckets e a configuração, consulte Trabalhar com buckets do Amazon S3 no Amazon S3Developer Guide.
Note
Melhor práticaRecomendamos habilitar a regra de ciclo de vida AbortIncompleteMultipartUpload nos buckets doAmazon S3.Essa regra leva o Amazon S3 a anular multipart uploads que não sejam concluídos dentro deum número específico de dias depois de serem iniciados. Quando o limite de tempo definido éexcedido, o Amazon S3 anula o upload e exclui os dados de uploads incompletos.Para obter mais informações, consulte Configuração do ciclo de vida de um bucket comversionamento no Amazon S3 User Guide.
Note
Esses trechos de código pressupõem que você compreende o material em Usar o AWS SDK paraJava 2.0 (p. 13) e configurou credenciais padrão da AWS usando as informações em Configurarcredenciais e região da AWS para desenvolvimento (p. 5).
Tópicos• Crie um bucket (p. 115)• Listar buckets (p. 116)• Excluir um Bucket (p. 116)
Crie um bucketCrie um CreateBucketRequest e forneça um nome de bucket. Passe-o para o método createBucketdo S3Client. Use o S3Client para realizar operações adicionais, como listar ou excluir buckets, conformemostrado nos exemplos mais adiante.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.ListBucketsRequest;import software.amazon.awssdk.services.s3.model.ListBucketsResponse;
Código
Primeiro, crie um S3Client.
Region region = Region.US_WEST_2; S3Client s3 = S3Client.builder().region(region).build();
115
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de buckets
Faça uma solicitação de criação de bucket.
Region region = Region.US_WEST_2;S3Client s3 = S3Client.builder().region(region).build();String bucket = "bucket" + System.currentTimeMillis();System.out.println(bucket);
// Create bucketCreateBucketRequest createBucketRequest = CreateBucketRequest .builder() .bucket(bucket) .createBucketConfiguration(CreateBucketConfiguration.builder() .locationConstraint(region.id()) .build()) .build();s3.createBucket(createBucketRequest);
Veja o exemplo completo no GitHub.
Listar bucketsCrie um ListBucketsRequest. Use o método listBuckets do S3Client para recuperar a lista de buckets.Se a solicitação for bem-sucedida, um ListBucketsResponse será retornado. Use este objeto de respostapara recuperar a lista de buckets.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.ListBucketsRequest;import software.amazon.awssdk.services.s3.model.ListBucketsResponse;
Código
Primeiro, crie um S3Client.
Region region = Region.US_WEST_2; S3Client s3 = S3Client.builder().region(region).build();
Faça uma solicitação de listagem de buckets.
// List bucketsListBucketsRequest listBucketsRequest = ListBucketsRequest.builder().build();ListBucketsResponse listBucketsResponse = s3.listBuckets(listBucketsRequest);listBucketsResponse.buckets().stream().forEach(x -> System.out.println(x.name()));
Veja o exemplo completo no GitHub.
Excluir um BucketPara que você possa excluir um bucket do Amazon S3, deverá verificar se o bucket está vazio, ou oserviço retornará um erro. Se você tiver um bucket versionado, deverá também excluir todos os objetosversionados que estão no bucket.
116
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de buckets
Tópicos• Excluir objetos em um bucket (p. 117)• Excluir um bucket vazio (p. 117)
Excluir objetos em um bucket
Crie um ListObjectsV2Request e use o método listObjects do S3Client para recuperar a lista deobjetos no bucket. Em seguida, use o método deleteObject em cada objeto para excluí-lo.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.ListBucketsRequest;import software.amazon.awssdk.services.s3.model.ListBucketsResponse;
Código
Primeiro, crie um S3Client.
Region region = Region.US_WEST_2; S3Client s3 = S3Client.builder().region(region).build();
DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucket).build();s3.deleteBucket(deleteBucketRequest);
Veja o exemplo completo no GitHub.
Excluir um bucket vazio
Crie um DeleteBucketRequest com um nome de bucket e passe-o para o método deleteBucket doS3Client.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.ListBucketsRequest;import software.amazon.awssdk.services.s3.model.ListBucketsResponse;
Código
Primeiro, crie um S3Client.
DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucket).build();
117
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de objetos
s3.deleteBucket(deleteBucketRequest);
Excluir todos os objetos no bucket.
DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucket).build();s3.deleteBucket(deleteBucketRequest);
Veja o exemplo completo no GitHub.
Trabalhar com objetos do Amazon S3Um objeto do Amazon S3 representa um arquivo ou um conjunto de dados. Cada objeto deve estar contidoem um bucket (p. 115).
Note
Melhor práticaRecomendamos habilitar a regra de ciclo de vida AbortIncompleteMultipartUpload nos buckets doAmazon S3.Essa regra leva o Amazon S3 a anular multipart uploads que não sejam concluídos dentro deum número específico de dias depois de serem iniciados. Quando o limite de tempo definido éexcedido, o Amazon S3 anula o upload e exclui os dados de uploads incompletos.Para obter mais informações, consulte Configuração do ciclo de vida de um bucket comversionamento no Amazon S3 User Guide.
Note
Esses trechos de código pressupõem que você compreende o material em Usar o AWS SDK paraJava 2.0 (p. 13) e configurou credenciais padrão da AWS usando as informações em Configurarcredenciais e região da AWS para desenvolvimento (p. 5).
Tópicos• Fazer upload de um objeto (p. 118)• Fazer upload de objetos em várias partes (p. 119)• Fazer download de um objeto (p. 120)• Excluir um objeto (p. 121)• Copiar um objeto (p. 122)• List objects (p. 123)
Fazer upload de um objetoCrie um PutObjectRequest e forneça um nome do bucket e nome da chave. Depois, use o métodoputObject do S3Client com um RequestBody que inclua o conteúdo do objeto e o objetoPutObjectRequest. O bucket deve existir, ou o serviço retornará um erro.
Importações
import java.io.IOException;import java.nio.ByteBuffer;import java.nio.file.Paths;import java.util.Random;
118
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de objetos
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;import software.amazon.awssdk.services.s3.model.CompletedPart;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;import software.amazon.awssdk.services.s3.model.GetObjectRequest;import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;import software.amazon.awssdk.services.s3.model.PutObjectRequest;import software.amazon.awssdk.services.s3.model.S3Object;import software.amazon.awssdk.services.s3.model.UploadPartRequest;import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;import software.amazon.awssdk.core.sync.RequestBody;import software.amazon.awssdk.core.sync.ResponseTransformer;
Código
Region region = Region.US_WEST_2;s3 = S3Client.builder().region(region).build();
String bucket = "bucket" + System.currentTimeMillis();String key = "key";
createBucket(s3,bucket, region);
// Put Objects3.putObject(PutObjectRequest.builder().bucket(bucket).key(key) .build(), RequestBody.fromByteBuffer(getRandomByteBuffer(10_000)));
Veja o exemplo completo no GitHub.
Fazer upload de objetos em várias partesUse o método createMultipartUpload do S3Client para obter um ID de upload. Emseguida, use o método uploadPart para fazer upload de cada parte. Por fim, use o métodocompleteMultipartUpload do S3Client para informar ao Amazon S3 que mescle todas as partescarregadas e conclua a operação de upload.
Importações
import java.io.IOException;import java.nio.ByteBuffer;import java.nio.file.Paths;import java.util.Random;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;import software.amazon.awssdk.services.s3.model.CompletedPart;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;
119
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de objetos
import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;import software.amazon.awssdk.services.s3.model.GetObjectRequest;import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;import software.amazon.awssdk.services.s3.model.PutObjectRequest;import software.amazon.awssdk.services.s3.model.S3Object;import software.amazon.awssdk.services.s3.model.UploadPartRequest;import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;import software.amazon.awssdk.core.sync.RequestBody;import software.amazon.awssdk.core.sync.ResponseTransformer;
Código
// First create a multipart upload and get upload idCreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder() .bucket(bucketName).key(key) .build();CreateMultipartUploadResponse response = s3.createMultipartUpload(createMultipartUploadRequest);String uploadId = response.uploadId();System.out.println(uploadId);
// Upload all the different parts of the objectUploadPartRequest uploadPartRequest1 = UploadPartRequest.builder().bucket(bucketName).key(key) .uploadId(uploadId) .partNumber(1).build();String etag1 = s3.uploadPart(uploadPartRequest1, RequestBody.fromByteBuffer(getRandomByteBuffer(5 * MB))).eTag();CompletedPart part1 = CompletedPart.builder().partNumber(1).eTag(etag1).build();
UploadPartRequest uploadPartRequest2 = UploadPartRequest.builder().bucket(bucketName).key(key) .uploadId(uploadId) .partNumber(2).build();String etag2 = s3.uploadPart(uploadPartRequest2, RequestBody.fromByteBuffer(getRandomByteBuffer(3 * MB))).eTag();CompletedPart part2 = CompletedPart.builder().partNumber(2).eTag(etag2).build();
// Finally call completeMultipartUpload operation to tell S3 to merge all uploaded// parts and finish the multipart operation.CompletedMultipartUpload completedMultipartUpload = CompletedMultipartUpload.builder().parts(part1, part2).build();CompleteMultipartUploadRequest completeMultipartUploadRequest = CompleteMultipartUploadRequest.builder().bucket(bucketName).key(key).uploadId(uploadId) .multipartUpload(completedMultipartUpload).build();s3.completeMultipartUpload(completeMultipartUploadRequest);
Veja o exemplo completo no GitHub.
Fazer download de um objetoCrie um GetObjectRequest e forneça um nome do bucket e nome da chave. Use o método getObjectdo S3Client, passando o objeto GetObjectRequest e um objeto ResponseTransformer para ele. OResponseTransformer cria um manipulador de resposta que grava o conteúdo de resposta no arquivoou fluxo especificado.
O exemplo a seguir especifica um nome de arquivo para gravar o conteúdo do objeto.
120
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de objetos
Importações
import java.io.IOException;import java.nio.ByteBuffer;import java.nio.file.Paths;import java.util.Random;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;import software.amazon.awssdk.services.s3.model.CompletedPart;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;import software.amazon.awssdk.services.s3.model.GetObjectRequest;import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;import software.amazon.awssdk.services.s3.model.PutObjectRequest;import software.amazon.awssdk.services.s3.model.S3Object;import software.amazon.awssdk.services.s3.model.UploadPartRequest;import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;import software.amazon.awssdk.core.sync.RequestBody;import software.amazon.awssdk.core.sync.ResponseTransformer;
Código
s3.getObject(GetObjectRequest.builder().bucket(bucket).key(key).build(), ResponseTransformer.toFile(Paths.get("multiPartKey")));
Veja o exemplo completo no GitHub.
Excluir um objetoCrie um DeleteObjectRequest e forneça um nome do bucket e nome da chave. Use o métododeleteObject do S3Client e passe o nome de um bucket e o objeto a ser excluído para ele. O bucket e achave de objeto especificados devem existir, ou o serviço retornará um erro.
Importações
import java.io.IOException;import java.nio.ByteBuffer;import java.nio.file.Paths;import java.util.Random;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;import software.amazon.awssdk.services.s3.model.CompletedPart;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;import software.amazon.awssdk.services.s3.model.GetObjectRequest;import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;
121
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de objetos
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;import software.amazon.awssdk.services.s3.model.PutObjectRequest;import software.amazon.awssdk.services.s3.model.S3Object;import software.amazon.awssdk.services.s3.model.UploadPartRequest;import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;import software.amazon.awssdk.core.sync.RequestBody;import software.amazon.awssdk.core.sync.ResponseTransformer;
Código
DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder().bucket(bucket).key(key).build();s3.deleteObject(deleteObjectRequest);
Veja o exemplo completo no GitHub.
Copiar um objetoCrie um CopyObjectRequest e forneça um nome de bucket no qual o objeto é copiado, um valor destring codificado por URL (consulte o método URLEncoder.encode) e o nome da chave do objeto. Use ométodo copyObject do S3Client e passe o objeto CopyObjectRequest. O bucket e a chave de objetoespecificados devem existir, ou o serviço retornará um erro.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CopyObjectRequest;import software.amazon.awssdk.services.s3.model.CopyObjectResponse;import software.amazon.awssdk.services.s3.model.S3Exception;import java.io.UnsupportedEncodingException;import java.net.URLEncoder;import java.nio.charset.StandardCharsets;
Código
public static String CopyBucketObject (S3Client s3, String fromBucket, String objectKey, String toBucket) {
String encodedUrl = null; try { encodedUrl = URLEncoder.encode(fromBucket + "/" + objectKey, StandardCharsets.UTF_8.toString()); } catch (UnsupportedEncodingException e) { System.out.println("URL could not be encoded: " + e.getMessage()); } CopyObjectRequest copyReq = CopyObjectRequest.builder() .copySource(encodedUrl) .bucket(toBucket) .key(objectKey) .build();
try { CopyObjectResponse copyRes = s3.copyObject(copyReq); return copyRes.copyObjectResult().toString(); } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
122
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos pré-assinados do Amazon S3
Veja o exemplo completo no GitHub.
List objectsCrie um ListObjectsRequest e forneça o nome do bucket. Depois, invoque o método listObjects doS3Client e passe o objeto ListObjectsRequest. Esse método retorna um ListObjectsResponse que contémtodos os objetos do bucket. Você pode invocar o método contents desse objeto para obter uma lista deobjetos. É possível percorrer essa lista para exibir os objetos, conforme mostrado no exemplo de código aseguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.ListObjectsRequest;import software.amazon.awssdk.services.s3.model.ListObjectsResponse;import software.amazon.awssdk.services.s3.model.S3Exception;import software.amazon.awssdk.services.s3.model.S3Object;import java.util.List;import java.util.ListIterator;
Código
public static void ListBucketObjects( S3Client s3, String bucketName ) {
try { ListObjectsRequest listObjects = ListObjectsRequest .builder() .bucket(bucketName) .build();
ListObjectsResponse res = s3.listObjects(listObjects); List<S3Object> objects = res.contents();
for (ListIterator iterVals = objects.listIterator(); iterVals.hasNext(); ) { S3Object myValue = (S3Object) iterVals.next(); System.out.print("\n The name of the key is " + myValue.key()); System.out.print("\n The object is " + calKb(myValue.size()) + " KBs"); System.out.print("\n The owner is " + myValue.owner()); } } catch (S3Exception e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }}//convert bytes to kbsprivate static long calKb(Long val) { return val/1024;
}
Veja o exemplo completo no GitHub.
Trabalhar com URLs pré-assinadas do Amazon S3Você pode usar um objeto S3Presigner para assinar um SdkRequest do Amazon S3, para que ele sejaexecutado sem a necessidade de autenticação por parte do chamador. Por exemplo, vamos supor queAlice tenha acesso a um objeto do S3 e queira compartilhar temporariamente o acesso a esse objeto com
123
AWS SDK para Java versão 2 Guia do desenvolvedorGerar uma URL pré-assinada e fazer upload de um objeto
Bob. Alice pode gerar um objeto GetObjectRequest pré-assinado para compartilhamento seguro com Bob,para que ele possa baixar o objeto sem exigir acesso às credenciais de Alice.
Tópicos• Gerar uma URL pré-assinada e fazer upload de um objeto (p. 124)• Obter um objeto pré-assinado (p. 125)
Gerar uma URL pré-assinada e fazer upload de umobjetoCrie um objeto S3Presigner que represente o objeto cliente. Depois, crie um objetoPresignedPutObjectRequest que possa ser executado posteriormente sem exigir assinatura ouautenticação adicionais. Ao criar esse objeto, você pode especificar o nome do bucket e o nome da chave.Além disso, você também pode especificar o tempo em minutos que o bucket pode ser acessado semusar credenciais invocando o método signatureDuration (conforme mostrado no exemplo de código aseguir).
É possível usar o objeto PresignedPutObjectRequest para obter a URL invocando seu método url.
Importações
import java.io.IOException;import java.io.OutputStreamWriter;import java.net.HttpURLConnection;import java.net.URL;import java.time.Duration;import software.amazon.awssdk.services.s3.model.S3Exception;import software.amazon.awssdk.services.s3.presigner.model.PresignedPutObjectRequest;import software.amazon.awssdk.services.s3.presigner.S3Presigner;
Código
O exemplo de código Java a seguir faz upload do conteúdo em um bucket do S3 pré-assinado.
public static void signBucket( S3Presigner presigner, String bucketName, String keyName) {
try { PresignedPutObjectRequest presignedRequest = presigner.presignPutObject(z -> z.signatureDuration(Duration.ofMinutes(10)) .putObjectRequest(por -> por.bucket(bucketName).key(keyName)));
System.out.println("Pre-signed URL to upload a file to: " + presignedRequest.url()); System.out.println("Which HTTP method needs to be used when uploading a file: " + presignedRequest.httpRequest().method());
// Upload content to the bucket by using this URL URL url = presignedRequest.url();
// Create the connection and use it to upload the new object by using the pre-signed URL HttpURLConnection connection = (HttpURLConnection) url.openConnection(); connection.setDoOutput(true); connection.setRequestProperty("Content-Type","text/plain"); connection.setRequestMethod("PUT");
124
AWS SDK para Java versão 2 Guia do desenvolvedorObter um objeto pré-assinado
OutputStreamWriter out = new OutputStreamWriter(connection.getOutputStream()); out.write("This text uploaded as an object via presigned URL."); out.close();
connection.getResponseCode(); System.out.println("HTTP response code: " + connection.getResponseCode());
/* * It's recommended that you close the S3Presigner when it is done being used, because some credential * providers (e.g. if your AWS profile is configured to assume an STS role) require system resources * that need to be freed. If you are using one S3Presigner per application (as recommended), this * usually isn't needed */ presigner.close();
} catch (S3Exception e) { e.getStackTrace(); } catch (IOException e) { e.getStackTrace(); }
Veja o exemplo completo no GitHub.
Obter um objeto pré-assinadoCrie um objeto S3Presigner que represente o objeto cliente. Depois, crie um objeto GetObjectRequest eespecifique o nome do bucket e o nome da chave. Além disso, crie um objeto GetObjectPresignRequestque possa ser executado posteriormente sem exigir assinatura ou autenticação adicionais. Ao criar esseobjeto, você pode especificar o tempo em minutos que o bucket pode ser acessado sem usar credenciaisinvocando o método signatureDuration (conforme mostrado no exemplo de código a seguir).
Invoque o método presignGetObject que pertence ao objeto S3Presigner para criar um objetoPresignedPutObjectRequest. Você pode invocar o método url desse objeto para obter a URL a serusada. Quando tiver a URL, você poderá usar a lógica Java HTTP padrão para ler o conteúdo do bucket,conforme mostrado no exemplo de código Java a seguir.
Importações
import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.HttpURLConnection;import java.time.Duration;import software.amazon.awssdk.services.s3.model.GetObjectRequest;import software.amazon.awssdk.services.s3.model.S3Exception;import software.amazon.awssdk.services.s3.presigner.model.GetObjectPresignRequest;import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest;import software.amazon.awssdk.services.s3.presigner.S3Presigner;import software.amazon.awssdk.utils.IoUtils;
Código
O exemplo de código Java a seguir lê o conteúdo de um bucket do S3 pré-assinado.
public static void getPresignedUrl( S3Presigner presigner, String bucketName,String keyName ) {
try {
125
AWS SDK para Java versão 2 Guia do desenvolvedorObter um objeto pré-assinado
// Create a GetObjectRequest to be pre-signed GetObjectRequest getObjectRequest = GetObjectRequest.builder() .bucket(bucketName) .key(keyName) .build();
// Create a GetObjectPresignRequest to specify the signature duration GetObjectPresignRequest getObjectPresignRequest = GetObjectPresignRequest.builder() .signatureDuration(Duration.ofMinutes(10)) .getObjectRequest(getObjectRequest) .build();
// Generate the presigned request PresignedGetObjectRequest presignedGetObjectRequest = presigner.presignGetObject(getObjectPresignRequest);
// Log the presigned URL System.out.println("Presigned URL: " + presignedGetObjectRequest.url());
// Create a JDK HttpURLConnection for communicating with S3 HttpURLConnection connection = (HttpURLConnection) presignedGetObjectRequest.url().openConnection();
// Specify any headers that the service needs (not needed when isBrowserExecutable is true) presignedGetObjectRequest.httpRequest().headers().forEach((header, values) -> { values.forEach(value -> { connection.addRequestProperty(header, value); }); });
// Send any request payload that the service needs (not needed when isBrowserExecutable is true) if (presignedGetObjectRequest.signedPayload().isPresent()) { connection.setDoOutput(true); try (InputStream signedPayload = presignedGetObjectRequest.signedPayload().get().asInputStream(); OutputStream httpOutputStream = connection.getOutputStream()) { IoUtils.copy(signedPayload, httpOutputStream); } }
// Download the result of executing the request try (InputStream content = connection.getInputStream()) { System.out.println("Service returned response: "); IoUtils.copy(content, System.out); }
/* * It's recommended that you close the S3Presigner when it is done being used, because some credential * providers (e.g. if your AWS profile is configured to assume an STS role) require system resources * that need to be freed. If you are using one S3Presigner per application (as recommended), this * usually isn't needed */ presigner.close();
} catch (S3Exception e) { e.getStackTrace(); } catch (IOException e) { e.getStackTrace();
126
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon SNS
}
Veja o exemplo completo no GitHub.
Exemplos do Amazon Simple Notification ServiceCom o Amazon Simple Notification Service, é possível enviar facilmente mensagens de notificação emtempo real dos aplicativos aos assinantes em vários canais de comunicação. Este tópico descreve comoexecutar algumas das funções básicas do SNS.
Criar um tópicoUm tópico é um agrupamento lógico de canais de comunicação que define para quais sistemas enviaruma mensagem, por exemplo, espalhando uma mensagem do AWS Lambda e um webhook HTTP. Vocêenvia mensagens para o Amazon SNS, e elas são distribuídas para os canais definidos no tópico. Issodisponibiliza as mensagens para os assinantes.
Para criar um tópico, primeiro compile um objeto CreateTopicRequest com o nome do conjunto de tópicosusando o método name() no compilador. Envie o objeto de solicitação para o Amazon SNS usando ométodo createTopic() do SnsClient. É possível capturar o resultado dessa solicitação como um objetoCreateTopicResponse, conforme demonstrado no trecho de código a seguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sns.SnsClient;import software.amazon.awssdk.services.sns.model.CreateTopicRequest;import software.amazon.awssdk.services.sns.model.CreateTopicResponse;import software.amazon.awssdk.services.sns.model.SnsException;
Código
public static String createSNSTopic(SnsClient snsClient, String topicName ) {
CreateTopicResponse result = null; try { CreateTopicRequest request = CreateTopicRequest.builder() .name(topicName) .build();
result = snsClient.createTopic(request); return result.topicArn(); } catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); } return "";
Veja o exemplo completo no GitHub.
Listar os tópicos do SNSPara recuperar uma lista dos tópicos existentes do Amazon SNS, compile um objeto ListTopicsRequest.Envie o objeto de solicitação para o Amazon SNS usando o método listTopics() do SnsClient. Épossível capturar o resultado dessa solicitação como um objeto ListTopicsResponse.
127
AWS SDK para Java versão 2 Guia do desenvolvedorInscrever um endpoint em um tópico
O trecho de código a seguir imprime o código de status HTTP da solicitação e uma lista de nomes derecurso da Amazon (ARNs) para os tópicos do Amazon SNS.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sns.SnsClient;import software.amazon.awssdk.services.sns.model.ListTopicsRequest;import software.amazon.awssdk.services.sns.model.ListTopicsResponse;import software.amazon.awssdk.services.sns.model.SnsException;
Código
public static void listSNSTopics(SnsClient snsClient) {
try { ListTopicsRequest request = ListTopicsRequest.builder() .build();
ListTopicsResponse result = snsClient.listTopics(request); System.out.println("Status was " + result.sdkHttpResponse().statusCode() + "\n\nTopics\n\n" + result.topics());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1);}
Veja o exemplo completo no GitHub.
Inscrever um endpoint em um tópicoDepois de criar um tópico, é possível configurar quais canais de comunicação serão endpoints para essetópico. As mensagens são distribuídas para esses endpoints após o Amazon SNS recebê-las.
Para configurar um canal de comunicação como um endpoint para um tópico, inscreva esse endpointno tópico. Para iniciar, compile um objeto SubscribeRequest. Especifique o canal de comunicação (porexemplo, lambda ou email) como o protocol(). Defina o endpoint() no local de saída relevante(por exemplo, o ARN de uma função do Lambda ou um endereço de e-mail) e defina o ARN do tópicoque você deseja inscrever como o topicArn(). Envie o objeto de solicitação para o SNS usando ométodo subscribe() do SnsClient. É possível capturar o resultado dessa solicitação como um objetoSubscribeResponse.
O trecho de código a seguir mostra como inscrever um endereço de e-mail em um tópico.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sns.SnsClient;import software.amazon.awssdk.services.sns.model.SnsException;import software.amazon.awssdk.services.sns.model.SubscribeRequest;import software.amazon.awssdk.services.sns.model.SubscribeResponse;
Código
public static void subEmail(SnsClient snsClient, String topicArn, String email) {
try {
128
AWS SDK para Java versão 2 Guia do desenvolvedorPublicar uma mensagem em um tópico
SubscribeRequest request = SubscribeRequest.builder() .protocol("email") .endpoint(email) .returnSubscriptionArn(true) .topicArn(topicArn) .build();
SubscribeResponse result = snsClient.subscribe(request); System.out.println("Subscription ARN: " + result.subscriptionArn() + "\n\n Status was " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Publicar uma mensagem em um tópicoDepois de ter um tópico e um ou mais endpoints configurados para ele, será possível publicar umamensagem nele. Para iniciar, compile um objeto PublishRequest. Especifique a message() a ser enviadae o ARN do tópico (topicArn()) para o qual enviá-la. Envie o objeto de solicitação para o Amazon SNSusando o método publish() do SnsClient. É possível capturar o resultado dessa solicitação como umobjeto PublishResponse.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sns.SnsClient;import software.amazon.awssdk.services.sns.model.PublishRequest;import software.amazon.awssdk.services.sns.model.PublishResponse;import software.amazon.awssdk.services.sns.model.SnsException;
Código
public static void pubTopic(SnsClient snsClient, String message, String topicArn) {
try { PublishRequest request = PublishRequest.builder() .message(message) .topicArn(topicArn) .build();
PublishResponse result = snsClient.publish(request); System.out.println(result.messageId() + " Message sent. Status was " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Cancelar a inscrição de um endpoint de um tópicoVocê pode remover os canais de comunicação configurados como endpoints de um tópico. Depoisde fazer isso, o tópico em si continua a existir e distribuir mensagens para quaisquer endpoints finaisconfigurados para esse tópico.
129
AWS SDK para Java versão 2 Guia do desenvolvedorExcluir um tópico
Para remover um canal de comunicação como um endpoint de um tópico, cancele a inscrição desseendpoint do tópico. Para começar, compile um objeto UnsubscribeRequest e defina o ARN do tópico doqual você deseja cancelar a inscrição como o subscriptionArn(). Envie o objeto de solicitação para oSNS usando o método unsubscribe() do SnsClient. É possível capturar o resultado dessa solicitaçãocomo um objeto UnsubscribeResponse.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sns.SnsClient;import software.amazon.awssdk.services.sns.model.SnsException;import software.amazon.awssdk.services.sns.model.UnsubscribeRequest;import software.amazon.awssdk.services.sns.model.UnsubscribeResponse;
Código
public static void unSub(SnsClient snsClient, String subscriptionToken) {
try { UnsubscribeRequest request = UnsubscribeRequest.builder() .subscriptionArn(subscriptionToken) .build();
UnsubscribeResponse result = snsClient.unsubscribe(request);
System.out.println("\n\nStatus was " + result.sdkHttpResponse().statusCode() + "\n\nSubscription was removed for " + request.subscriptionArn());
} catch (SnsException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Excluir um tópicoPara excluir um tópico do Amazon SNS, primeiro compile um objeto DeleteTopicRequest com o ARN dotópico definido como o método topicArn() no compilador. Envie o objeto de solicitação para o AmazonSNS usando o método deleteTopic() do SnsClient. É possível capturar o resultado dessa solicitaçãocomo um objeto DeleteTopicResponse, conforme demonstrado no trecho de código a seguir.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sns.SnsClient;import software.amazon.awssdk.services.sns.model.DeleteTopicRequest;import software.amazon.awssdk.services.sns.model.DeleteTopicResponse;import software.amazon.awssdk.services.sns.model.SnsException;
Código
public static void deleteSNSTopic(SnsClient snsClient, String topicArn ) {
try { DeleteTopicRequest request = DeleteTopicRequest.builder() .topicArn(topicArn) .build();
DeleteTopicResponse result = snsClient.deleteTopic(request);
130
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon SQS
System.out.println("\n\nStatus was " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) { System.err.println(e.awsErrorDetails().errorMessage()); System.exit(1); }
Veja o exemplo completo no GitHub.
Para obter mais informações, consulte o Guia do desenvolvedor do Amazon SNS.
Amazon SQS Exemplos usando o AWS SDK forJava
Esta seção apresenta exemplos de como programar o Amazon SQS usando o AWS SDK for Java 2.0.
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O códigode exemplo completo está disponível no GitHub. A partir daí, você pode fazer download de um únicoarquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilaçãoe execução.
Tópicos• Trabalhar com filas de mensagens do Amazon SQS (p. 131)• Enviar, receber e excluir mensagens do Amazon SQS (p. 134)
Trabalhar com filas de mensagens do Amazon SQSUma fila de mensagens é o contêiner lógico usado para enviar mensagens de maneira confiável noAmazon SQS. Existem dois tipos de filas: padrão e First-In, First-Out (FIFO – Primeiro a entrar, primeiro asair). Para saber mais sobre as filas e as diferenças entre esses tipos, consulte o Guia do desenvolvedordo Amazon SQS.
Este tópico descreve como criar, listar, excluir e obter o URL de uma fila do Amazon SQS usando o AWSSDK for Java.
Criar uma filaUse o método createQueue do SqsClient e forneça um objeto CreateQueueRequest que descreve osparâmetros da fila.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sqs.SqsClient;import software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest;import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;import software.amazon.awssdk.services.sqs.model.DeleteMessageRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;import software.amazon.awssdk.services.sqs.model.ListQueuesRequest;import software.amazon.awssdk.services.sqs.model.ListQueuesResponse;import software.amazon.awssdk.services.sqs.model.Message;import software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry;
131
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de filas
import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
Código
CreateQueueRequest createQueueRequest = CreateQueueRequest.builder() .queueName(queueName) .build();
sqsClient.createQueue(createQueueRequest);
Consulte a amostra completa no GitHub.
Listar filasPara listar as filas do Amazon SQS da conta, chame o método listQueues do SqsClient com um objetoListQueuesRequest.
Usar a sobrecarga listQueues sem parâmetros retorna todas as filas, até 1.000 filas. Você pode fornecerum prefixo de nome da fila para o objeto ListQueuesRequest a fim de limitar os resultados para filasque correspondem a esse prefixo.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sqs.SqsClient;import software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest;import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;import software.amazon.awssdk.services.sqs.model.DeleteMessageRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;import software.amazon.awssdk.services.sqs.model.ListQueuesRequest;import software.amazon.awssdk.services.sqs.model.ListQueuesResponse;import software.amazon.awssdk.services.sqs.model.Message;import software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry;import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
Código
String prefix = "que";ListQueuesRequest listQueuesRequest = ListQueuesRequest.builder().queueNamePrefix(prefix).build();ListQueuesResponse listQueuesResponse = sqsClient.listQueues(listQueuesRequest);for (String url : listQueuesResponse.queueUrls()) { System.out.println(url);}
Consulte a amostra completa no GitHub.
Obter o URL de uma filaChame o método getQueueUrl do SqsClient com um objeto GetQueueUrlRequest.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sqs.SqsClient;
132
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de filas
import software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest;import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;import software.amazon.awssdk.services.sqs.model.DeleteMessageRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;import software.amazon.awssdk.services.sqs.model.ListQueuesRequest;import software.amazon.awssdk.services.sqs.model.ListQueuesResponse;import software.amazon.awssdk.services.sqs.model.Message;import software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry;import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
Código
GetQueueUrlResponse getQueueUrlResponse = sqsClient.getQueueUrl(GetQueueUrlRequest.builder().queueName(queueName).build());String queueUrl = getQueueUrlResponse.queueUrl();return queueUrl;
Consulte a amostra completa no GitHub.
Excluir uma filaForneça o URL (p. 132) da fila para o objeto DeleteMessageRequest. Depois, chame o métododeleteQueue do SqsClient.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sqs.SqsClient;import software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest;import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;import software.amazon.awssdk.services.sqs.model.DeleteMessageRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;import software.amazon.awssdk.services.sqs.model.ListQueuesRequest;import software.amazon.awssdk.services.sqs.model.ListQueuesResponse;import software.amazon.awssdk.services.sqs.model.Message;import software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry;import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
Código
public static void deleteSQSQueue(SqsClient sqsClient, String queueName) {
try {
GetQueueUrlRequest getQueueRequest = GetQueueUrlRequest.builder() .queueName(queueName) .build();
String queueUrl = sqsClient.getQueueUrl(getQueueRequest).queueUrl();
DeleteQueueRequest deleteQueueRequest = DeleteQueueRequest.builder() .queueUrl(queueUrl) .build();
sqsClient.deleteQueue(deleteQueueRequest);
133
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de mensagens
} catch (QueueNameExistsException e) { e.printStackTrace(); System.exit(1); }
Consulte a amostra completa no GitHub.
Mais informações• Como as filas do Amazon SQS funcionam no Amazon SQS Developer Guide• CreateQueue na Amazon SQS API Reference• GetQueueUrl na Amazon SQS API Reference• ListQueues na Amazon SQS API Reference• DeleteQueues na Amazon SQS API Reference
Enviar, receber e excluir mensagens do Amazon SQSUma mensagem é um trecho de dados que pode ser enviado e recebido por componentes distribuídos. Asmensagens são sempre entregues usando-se uma fila do SQS (p. 131).
Enviar uma mensagemAdicione uma mensagem única a uma fila do Amazon SQS chamando o método SqsClient de cliente dosendMessage. Forneça um objeto SendMessageRequest que contenha o URL (p. 132) da fila, o corpoda mensagem e o valor de atraso opcional (em segundos).
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sqs.SqsClient;import software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest;import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;import software.amazon.awssdk.services.sqs.model.DeleteMessageRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;import software.amazon.awssdk.services.sqs.model.ListQueuesRequest;import software.amazon.awssdk.services.sqs.model.ListQueuesResponse;import software.amazon.awssdk.services.sqs.model.Message;import software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry;import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
Código
sqsClient.sendMessage(SendMessageRequest.builder() .queueUrl(queueUrl) .messageBody("Hello world!") .delaySeconds(10) .build());
Enviar várias mensagens em uma solicitaçãoEnvie mais de uma mensagem em uma única solicitação usando o método do sendMessageBatch doSqsClient. Esse método utiliza um SendMessageBatchRequest contendo o URL da fila e uma lista de
134
AWS SDK para Java versão 2 Guia do desenvolvedorOperações de mensagens
mensagens para enviar. (Cada mensagem é um SendMessageBatchRequestEntry). Você também podeatrasar o envio de uma mensagem específica, configurando um valor de atraso na mensagem.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sqs.SqsClient;import software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest;import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;import software.amazon.awssdk.services.sqs.model.DeleteMessageRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;import software.amazon.awssdk.services.sqs.model.ListQueuesRequest;import software.amazon.awssdk.services.sqs.model.ListQueuesResponse;import software.amazon.awssdk.services.sqs.model.Message;import software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry;import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
Código
SendMessageBatchRequest sendMessageBatchRequest = SendMessageBatchRequest.builder() .queueUrl(queueUrl) .entries(SendMessageBatchRequestEntry.builder().id("id1").messageBody("Hello from msg 1").build(), SendMessageBatchRequestEntry.builder().id("id2").messageBody("msg 2").delaySeconds(10).build()) .build();sqsClient.sendMessageBatch(sendMessageBatchRequest);
Consulte a amostra completa no GitHub.
Recuperar mensagensRecupere todas as mensagens que estejam atualmente na fila chamando o método do receiveMessagedo SqsClient. Esse método utiliza um ReceiveMessageRequest que contém o URL da fila. Você tambémpode especificar o número máximo de mensagens para retornar. As mensagens são retornadas como umalista de objetos Message.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sqs.SqsClient;import software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest;import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;import software.amazon.awssdk.services.sqs.model.DeleteMessageRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;import software.amazon.awssdk.services.sqs.model.ListQueuesRequest;import software.amazon.awssdk.services.sqs.model.ListQueuesResponse;import software.amazon.awssdk.services.sqs.model.Message;import software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry;import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
Código
ReceiveMessageRequest receiveMessageRequest = ReceiveMessageRequest.builder() .queueUrl(queueUrl)
135
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos do Amazon Transcribe
.maxNumberOfMessages(5) .build();List<Message> messages = sqsClient.receiveMessage(receiveMessageRequest).messages();
return messages;
Excluir uma mensagem após o recebimentoApós receber uma mensagem e processar o conteúdo, exclua a mensagem da fila enviando o identificadorde recebimento da mensagem e o URL da fila para o método deleteMessage do SqsClient.
Importações
import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.sqs.SqsClient;import software.amazon.awssdk.services.sqs.model.ChangeMessageVisibilityRequest;import software.amazon.awssdk.services.sqs.model.CreateQueueRequest;import software.amazon.awssdk.services.sqs.model.DeleteMessageRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;import software.amazon.awssdk.services.sqs.model.ListQueuesRequest;import software.amazon.awssdk.services.sqs.model.ListQueuesResponse;import software.amazon.awssdk.services.sqs.model.Message;import software.amazon.awssdk.services.sqs.model.ReceiveMessageRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequest;import software.amazon.awssdk.services.sqs.model.SendMessageBatchRequestEntry;import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
Código
for (Message message : messages) { DeleteMessageRequest deleteMessageRequest = DeleteMessageRequest.builder() .queueUrl(queueUrl) .receiptHandle(message.receiptHandle()) .build(); sqsClient.deleteMessage(deleteMessageRequest);}
Consulte a amostra completa no GitHub.
Mais informações• Como as filas do Amazon SQS funcionam no Amazon SQS Developer Guide• SendMessage na Amazon SQS API Reference• SendMessageBatch na Amazon SQS API Reference• ReceiveMessage na Amazon SQS API Reference• DeleteMessage na Amazon SQS API Reference
Exemplos do Amazon Transcribe usando o AWSSDK for Java
Esta seção fornece exemplos de como programar o Amazon Transcribe usando o AWS SDK for Java 2.0.
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O códigode exemplo completo está disponível no GitHub. A partir daí, você pode fazer download de um único
136
AWS SDK para Java versão 2 Guia do desenvolvedorComo trabalhar com o Amazon Transcribe
arquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilaçãoe execução.
Tópicos• Como trabalhar com o Amazon Transcribe (p. 137)
Como trabalhar com o Amazon TranscribeO exemplo a seguir mostra como o streaming bidirecional funciona usando o Amazon Transcribe. Ostreaming bidirecional indica que há um streaming de dados que vai para o serviço e que é recebido devolta em tempo real. O exemplo usa o transcrição de streaming do Amazon Transcribe para enviar umstreaming de áudio e receber um streaming de texto transcrito em tempo real.
Consulte Transcrição de streaming no Amazon Transcribe Developer Guide para saber mais sobre esserecurso.
Consulte Conceitos básicos no Amazon Transcribe Developer Guide para começar a usar o AmazonTranscribe.
Configurar o microfoneEsse código usa o pacote javax.sound.sampled para fazer streaming de áudio de um dispositivo deentrada.
Código
import javax.sound.sampled.AudioFormat;import javax.sound.sampled.AudioSystem;import javax.sound.sampled.DataLine;import javax.sound.sampled.TargetDataLine;
public class Microphone {
public static TargetDataLine get() throws Exception { AudioFormat format = new AudioFormat(16000, 16, 1, true, false); DataLine.Info datalineInfo = new DataLine.Info(TargetDataLine.class, format);
TargetDataLine dataLine = (TargetDataLine) AudioSystem.getLine(datalineInfo); dataLine.open(format);
return dataLine; }}
Consulte o exemplo completo no GitHub.
Criar um editorEsse código implementa um editor que publica dados de áudio do streaming de áudio do AmazonTranscribe.
Código
import java.io.IOException;import java.io.InputStream;import java.io.UncheckedIOException;
137
AWS SDK para Java versão 2 Guia do desenvolvedorComo trabalhar com o Amazon Transcribe
import java.nio.ByteBuffer;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.atomic.AtomicLong;import org.reactivestreams.Publisher;import org.reactivestreams.Subscriber;import org.reactivestreams.Subscription;import software.amazon.awssdk.core.SdkBytes;import software.amazon.awssdk.services.transcribestreaming.model.AudioEvent;import software.amazon.awssdk.services.transcribestreaming.model.AudioStream;
public class AudioStreamPublisher implements Publisher<AudioStream> { private final InputStream inputStream;
public AudioStreamPublisher(InputStream inputStream) { this.inputStream = inputStream; }
@Override public void subscribe(Subscriber<? super AudioStream> s) { s.onSubscribe(new SubscriptionImpl(s, inputStream)); }
private class SubscriptionImpl implements Subscription { private static final int CHUNK_SIZE_IN_BYTES = 1024 * 1; private ExecutorService executor = Executors.newFixedThreadPool(1); private AtomicLong demand = new AtomicLong(0);
private final Subscriber<? super AudioStream> subscriber; private final InputStream inputStream;
private SubscriptionImpl(Subscriber<? super AudioStream> s, InputStream inputStream) { this.subscriber = s; this.inputStream = inputStream; }
@Override public void request(long n) { if (n <= 0) { subscriber.onError(new IllegalArgumentException("Demand must be positive")); }
demand.getAndAdd(n);
executor.submit(() -> { try { do { ByteBuffer audioBuffer = getNextEvent(); if (audioBuffer.remaining() > 0) { AudioEvent audioEvent = audioEventFromBuffer(audioBuffer); subscriber.onNext(audioEvent); } else { subscriber.onComplete(); break; } } while (demand.decrementAndGet() > 0); } catch (Exception e) { subscriber.onError(e); } }); }
@Override
138
AWS SDK para Java versão 2 Guia do desenvolvedorComo trabalhar com o Amazon Transcribe
public void cancel() {
}
private ByteBuffer getNextEvent() { ByteBuffer audioBuffer; byte[] audioBytes = new byte[CHUNK_SIZE_IN_BYTES];
int len = 0; try { len = inputStream.read(audioBytes);
if (len <= 0) { audioBuffer = ByteBuffer.allocate(0); } else { audioBuffer = ByteBuffer.wrap(audioBytes, 0, len); } } catch (IOException e) { throw new UncheckedIOException(e); }
return audioBuffer; }
private AudioEvent audioEventFromBuffer(ByteBuffer bb) { return AudioEvent.builder() .audioChunk(SdkBytes.fromByteBuffer(bb)) .build(); } }}
Consulte o exemplo completo no GitHub.
Criar o cliente e iniciar o streamingNo método principal, crie um objeto de solicitação, inicie o streaming da entrada de áudio e instancie oeditor com a entrada de áudio.
Você também deve criar um StartStreamTranscriptionResponseHandler para especificar como lidar com aresposta do Amazon Transcribe.
Depois, use o método startStreamTranscription do TranscribeStreamingAsyncClient para iniciar ostreaming bidirecional.
Importações
import javax.sound.sampled.AudioFormat;import javax.sound.sampled.AudioSystem;import javax.sound.sampled.DataLine;import javax.sound.sampled.TargetDataLine;
import javax.sound.sampled.AudioInputStream;import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;import software.amazon.awssdk.services.transcribestreaming.TranscribeStreamingAsyncClient;import software.amazon.awssdk.services.transcribestreaming.model.LanguageCode;import software.amazon.awssdk.services.transcribestreaming.model.MediaEncoding;import software.amazon.awssdk.services.transcribestreaming.model.StartStreamTranscriptionRequest;import software.amazon.awssdk.services.transcribestreaming.model.StartStreamTranscriptionResponseHandler;import software.amazon.awssdk.services.transcribestreaming.model.TranscriptEvent;
139
AWS SDK para Java versão 2 Guia do desenvolvedorExemplos de paginação
Código
public static void main(String[] args) throws Exception { TranscribeStreamingAsyncClient client = TranscribeStreamingAsyncClient.builder().credentialsProvider(ProfileCredentialsProvider.create()).build();
StartStreamTranscriptionRequest request = StartStreamTranscriptionRequest.builder() .mediaEncoding(MediaEncoding.PCM) .languageCode(LanguageCode.EN_US) .mediaSampleRateHertz(16_000).build();
TargetDataLine mic = Microphone.get(); mic.start();
AudioStreamPublisher publisher = new AudioStreamPublisher(new AudioInputStream(mic));
StartStreamTranscriptionResponseHandler response = StartStreamTranscriptionResponseHandler.builder().subscriber(e -> { TranscriptEvent event = (TranscriptEvent) e; event.transcript().results().forEach(r -> r.alternatives().forEach(a -> System.out.println(a.transcript()))); }).build();
client.startStreamTranscription(request, publisher, response).join(); }
Consulte o exemplo completo no GitHub.
Mais informações• Como funciona no Amazon Transcribe Developer Guide.• Conceitos básicos do streaming de áudio no Amazon Transcribe Developer Guide.• Diretrizes e limites no Amazon Transcribe Developer Guide.
Recuperar resultados paginadosMuitas operações da AWS retornam os resultados paginados quando o objeto de resposta é muito grandepara retornar em uma única resposta. No AWS SDK for Java 1.0, a resposta continha um token que vocêprecisava usar para recuperar a próxima página de resultados. A novidade no AWS SDK for Java 2.0são os métodos de autopaginação, que fazem várias chamadas de serviço para obter a próxima páginade resultados para você automaticamente. Você precisa somente escrever um código que processaos resultados. Além disso, os dois tipos de métodos têm versões síncrona e assíncrona. ConsulteProgramação assíncrona (p. 22) para obter mais detalhes sobre clientes assíncronos.
Os exemplos a seguir usam as operações do Amazon S3 e Amazon DynamoDB para demonstrar os váriosmétodos de recuperação de seus dados de respostas paginadas.
Note
Esses trechos de código pressupõem que você compreende o material em Usar o AWS SDK paraJava 2.0 (p. 13) e configurou credenciais padrão da AWS usando as informações em Configurarcredenciais e região da AWS para desenvolvimento (p. 5).
140
AWS SDK para Java versão 2 Guia do desenvolvedorPaginação síncrona
Paginação síncronaEstes exemplos usam os métodos de paginação síncrona para listar objetos em um bucket do Amazon S3.
Iterar sobre páginasCrie um ListObjectsV2Request e forneça um nome de bucket. Como opção, você pode fornecero número máximo de chaves a serem recuperadas de uma só vez. Passe-o para o métodolistObjectsV2Paginator do S3Client. Esse método retorna um objeto ListObjectsV2Iterable que é umIterable da classe ListObjectsV2Response.
O primeiro exemplo demonstra o uso do objeto paginador para percorrer todas as páginas de respostacom o método stream. Você pode fazer o streaming diretamente pelas páginas de resposta, convertero streaming de resposta em um streaming de conteúdo S3Object e processar o conteúdo do objeto doAmazon S3.
Importações
import java.io.IOException;import java.nio.ByteBuffer;import java.nio.file.Paths;import java.util.Random;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.s3.S3Client;import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;import software.amazon.awssdk.services.s3.model.CompletedPart;import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;import software.amazon.awssdk.services.s3.model.CreateBucketRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;import software.amazon.awssdk.services.s3.model.GetObjectRequest;import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;import software.amazon.awssdk.services.s3.model.PutObjectRequest;import software.amazon.awssdk.services.s3.model.S3Object;import software.amazon.awssdk.services.s3.model.UploadPartRequest;import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;import software.amazon.awssdk.core.sync.RequestBody;import software.amazon.awssdk.core.sync.ResponseTransformer;
Código
// Build the list objects requestListObjectsV2Request listReq = ListObjectsV2Request.builder() .bucket(bucket) .maxKeys(1) .build();
ListObjectsV2Iterable listRes = s3.listObjectsV2Paginator(listReq);// Process response pageslistRes.stream() .flatMap(r -> r.contents().stream()) .forEach(content -> System.out.println(" Key: " + content.key() + " size = " + content.size()));
Veja o exemplo completo no GitHub.
141
AWS SDK para Java versão 2 Guia do desenvolvedorPaginação síncrona
Iterar sobre objetosOs exemplos a seguir mostram maneiras de iterar sobre os objetos retornados na resposta e não naspáginas de resposta.
Usar um streamUse o método stream no conteúdo de resposta para iterar sobre a coleção de itens paginados.
Código
// Helper method to work with paginated collection of items directlylistRes.contents().stream() .forEach(content -> System.out.println(" Key: " + content.key() + " size = " + content.size()));
Veja o exemplo completo no GitHub.
Usar um For LoopUse um loop for padrão para percorrer o conteúdo da resposta.
Código
// Use simple for loop if stream is not necessaryfor (S3Object content : listRes.contents()) { System.out.println(" Key: " + content.key() + " size = " + content.size());}
Veja o exemplo completo no GitHub.
Paginação manualSe seu caso de uso exigir isto, a paginação manual ainda estará disponível. Use o próximo token no objetode resposta para as solicitações subsequentes. Aqui está um exemplo usando um loop while:
Código
// Use manual paginationListObjectsV2Request listObjectsReqManual = ListObjectsV2Request.builder() .bucket(bucket) .maxKeys(1) .build();
boolean done = false;while (!done) { ListObjectsV2Response listObjResponse = s3.listObjectsV2(listObjectsReqManual); for (S3Object content : listObjResponse.contents()) { System.out.println(content.key()); }
if (listObjResponse.nextContinuationToken() == null) { done = true; }
listObjectsReqManual = listObjectsReqManual.toBuilder() .continuationToken(listObjResponse.nextContinuationToken()) .build();}
142
AWS SDK para Java versão 2 Guia do desenvolvedorPaginação assíncrona
Veja o exemplo completo no GitHub.
Paginação assíncronaEstes exemplos usam os métodos de paginação assíncrona para listar tabelas no DynamoDB. Umexemplo de paginação manual está disponível no tópico Programação assíncrona (p. 22).
Iterar sobre páginas de nomes de tabelasPrimeiro, crie um cliente assíncrono do DynamoDB. Em seguida, chame o métodolistTablesPaginator para obter um ListTablesPublisher. Esta é uma implementação da interface destreams reativos do editor. Para saber mais sobre o modelo de streams reativo, consulte o repositório destreams reativos do GitHub.
Chame o método subscribe no ListTablesPublisher e passe uma implementação de assinante. Nesteexemplo, o assinante tem um método onNext que solicita um item de cada vez no editor. Este método échamado repetidamente até que todas as páginas sejam recuperadas. O método onSubscribe chamao método Subscription.request para iniciar solicitações de dados do editor. Esse método deve serchamado para iniciar a obtenção de dados do editor. O método onError será acionado se ocorrer um errodurante a recuperação de dados. Por fim, o método onComplete será chamado quando todas as páginastiverem sido solicitadas.
Usar um assinante
Importações
import java.util.List;import java.util.concurrent.CompletableFuture;import java.util.concurrent.ExecutionException;
import org.reactivestreams.Subscriber;import org.reactivestreams.Subscription;
import software.amazon.awssdk.core.async.SdkPublisher;import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;import software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher;import io.reactivex.Flowable;import reactor.core.publisher.Flux;
Código
Primeiro, crie um cliente asyc
// Creates a default client with credentials and regions loaded from the environmentfinal DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();
ListTablesRequest listTablesRequest = ListTablesRequest.builder().limit(3).build();
Em seguida, use o Subscriber para obter resultados.
// Or subscribe method should be called to create a new Subscription.// A Subscription represents a one-to-one life-cycle of a Subscriber subscribing to a Publisher.publisher.subscribe(new Subscriber<ListTablesResponse>() { // Maintain a reference to the subscription object, which is required to request data from the publisher
143
AWS SDK para Java versão 2 Guia do desenvolvedorPaginação assíncrona
private Subscription subscription;
@Override public void onSubscribe(Subscription s) { subscription = s; // Request method should be called to demand data. Here we request a single page subscription.request(1); }
@Override public void onNext(ListTablesResponse response) { response.tableNames().forEach(System.out::println); // Once you process the current page, call the request method to signal that you are ready for next page subscription.request(1); }
@Override public void onError(Throwable t) { // Called when an error has occurred while processing the requests }
@Override public void onComplete() { // This indicates all the results are delivered and there are no more pages left }
Veja o exemplo completo no GitHub.
Usar um For Loop
Usar um loop for para percorrer páginas com casos de uso simples ao criar um novo assinante podecausar muita sobrecarga. O objeto do editor de resposta tem um método auxiliar forEach para essafinalidade.
Código
ListTablesPublisher publisher = asyncClient.listTablesPaginator(listTablesRequest);
// Use a for-loop for simple use casesCompletableFuture<Void> future = publisher.subscribe(response -> response.tableNames() .forEach(System.out::println));
Veja o exemplo completo no GitHub.
Iterar sobre nomes de tabelaOs exemplos a seguir mostram maneiras de iterar sobre os objetos retornados na resposta e não naspáginas de resposta. Semelhante ao resultado síncrono, a classe de resultado assíncrono tem um métodopara interagir com a coleção de itens subjacentes. O tipo de retorno do método de conveniência é umeditor que pode ser usado para solicitar itens em todas as páginas.
Usar um assinante
Código
Primeiro, crie um cliente asyc
System.out.println("running AutoPagination - iterating on item collection...\n");
144
AWS SDK para Java versão 2 Guia do desenvolvedorPaginação assíncrona
// Creates a default client with credentials and regions loaded from the environmentfinal DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();
ListTablesRequest listTablesRequest = ListTablesRequest.builder().limit(3).build();
Em seguida, use o Subscriber para obter resultados.
// Use subscriberpublisher.subscribe(new Subscriber<String>() { private Subscription subscription;
@Override public void onSubscribe(Subscription s) { subscription = s; subscription.request(1); }
@Override public void onNext(String tableName) { System.out.println(tableName); subscription.request(1); }
@Override public void onError(Throwable t) { }
@Override public void onComplete() { }
Veja o exemplo completo no GitHub.
Usar um For LoopUse o método de conveniência forEach para percorrer resultados.
Código
// Use forEachCompletableFuture<Void> future = publisher.subscribe(System.out::println);future.get();
Veja o exemplo completo no GitHub.
Usar biblioteca de terceirosVocê pode usar outras bibliotecas de terceiros em vez de implementar um assinante personalizado.Este exemplo demonstra como usar a implementação RxJava, mas qualquer biblioteca que implementainterfaces de stream reativo pode ser usada. Consulte a página da Wikipédia RxJava no GitHub para obtermais informações sobre essa biblioteca.
Para usar a biblioteca, adicione-a como uma dependência. Se estiver usando o Maven, o exemplo mostrao trecho POM a ser usado.
Entrada POM
<dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>dynamodb-enhanced</artifactId> <version>2.11.4-PREVIEW</version>
145
AWS SDK para Java versão 2 Guia do desenvolvedorPaginação assíncrona
</dependency>
Importações
import java.util.List;import java.util.concurrent.CompletableFuture;import java.util.concurrent.ExecutionException;
import org.reactivestreams.Subscriber;import org.reactivestreams.Subscription;
import software.amazon.awssdk.core.async.SdkPublisher;import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;import software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher;import io.reactivex.Flowable;import reactor.core.publisher.Flux;
Código
System.out.println("running AutoPagination - using third party subscriber...\n");
DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.create();ListTablesPublisher publisher = asyncClient.listTablesPaginator(ListTablesRequest.builder() .build());
// The Flowable class has many helper methods that work with any reactive streams compatible publisher implementationList<String> tables = Flowable.fromPublisher(publisher) .flatMapIterable(ListTablesResponse::tableNames) .toList() .blockingGet();System.out.println(tables);
146
AWS SDK para Java versão 2 Guia do desenvolvedorProteção de dados
Segurança para this AWS Product orService
A segurança da nuvem na Amazon Web Services (AWS) é a nossa maior prioridade. Como cliente daAWS, você se beneficiará de um datacenter e de uma arquitetura de rede criados para atender aosrequisitos das empresas com as maiores exigências de segurança. A segurança é uma responsabilidadecompartilhada entre a AWS e você. O modelo de responsabilidade compartilhada descreve isso como aSegurança da nuvem e a Segurança na nuvem.
Segurança da nuvem– a AWS é responsável pela proteção da infraestrutura que executa todos osserviços oferecidos na Nuvem AWS e por fornecer serviços que você pode usar com segurança. Nossaresponsabilidade de segurança é a maior prioridade na AWS, e a eficácia da nossa segurança é testadaregularmente e verificada por auditores externos como parte dos Programas de conformidade da AWS.
Segurança na nuvem– sua responsabilidade é determinada pelo serviço da AWS que você está usandoe por outros fatores, incluindo a confidencialidade dos dados, os requisitos da organização e as leis eregulamentos aplicáveis.
Tópicos• Proteção de dados no this AWS Product or Service (p. 147)• Suporte do AWS SDK para Java para TLS 1.2 (p. 148)• Identity and Access Management para este produto ou serviço da AWS (p. 149)• Validação de conformidade para este produto ou serviço da AWS (p. 149)• Resiliência para este produto ou serviço da AWS (p. 150)• Segurança de infraestrutura para este produto ou serviço da AWS (p. 150)
Proteção de dados no this AWS Product or ServiceO This AWS product or service está em conformidade com o modelo de responsabilidade compartilhada,que inclui regulamentos e diretrizes de proteção de dados. A Amazon Web Services (AWS) é responsávelpor proteger a infraestrutura global que executa todos os serviços da AWS. A AWS mantém controle dosdados hospedados nessa infraestrutura, incluindo os controles de configuração de segurança para lidarcom o conteúdo e com os dados pessoais do cliente. Os clientes da AWS e os parceiros do APN, atuandocomo controladores ou processadores de dados, são responsáveis por todos os dados pessoais quecolocam na Nuvem AWS.
Para fins de proteção de dados, recomendamos que você proteja as credenciais da sua conta da AWSe configure contas de usuário individuais com o AWS Identity and Access Management (IAM), de modoque cada usuário receba somente as permissões necessárias para cumprir suas funções. Recomendamostambém que você proteja seus dados das seguintes formas:
• Use uma autenticação multifator (MFA) com cada conta.• Use SSL/TLS para se comunicar com os recursos da AWS. Para usar uma versão TLS mínima de 1.2,
consulte Impor o TLS 1.2.• Configure a API e o registro em log das atividades do usuário com o AWS CloudTrail.• Use as soluções de criptografia da AWS, juntamente com todos os controles de segurança padrão nos
serviços da AWS.• Use serviços gerenciados de segurança avançada, como o Amazon Macie, que ajuda a localizar e
proteger dados pessoais que são armazenados no Amazon S3.
147
AWS SDK para Java versão 2 Guia do desenvolvedorImpor o TLS 1.2
É altamente recomendável que você nunca coloque informações de identificação confidenciais, comonúmeros de conta dos seus clientes, em campos de formato livre, como um campo Name (Nome). Issoinclui quando você trabalhar com o this AWS product or service ou outros serviços da AWS usando oconsole, a API, a AWS CLI ou os AWS SDKs. Todos os dados inseridos por você no this AWS product orservice ou em outros serviços podem ser separados para inclusão em logs de diagnóstico. Ao fornecer umURL para um servidor externo, não inclua informações de credenciais no URL para validar a solicitação aesse servidor.
Para obter mais informações sobre proteção de dados, consulte a publicação AWS Shared ResponsibilityModel and GDPR no Blog de segurança da AWS.
Suporte do AWS SDK para Java para TLS 1.2As informações a seguir se aplicam somente à implementação Java SSL (a implementação SSL padrãono AWS SDK para Java). Se você estiver usando uma implementação SSL diferente, consulte suaimplementação SSL específica para saber como impor versões do TLS.
Suporte ao TLS no JavaO TLS 1.2 tem suporte a partir do Java 7.
Como verificar a versão do TLSPara verificar qual versão do TLS é compatível com a sua máquina virtual Java (JVM), você pode usar ocódigo a seguir.
System*.out.println(*Arrays*.toString(*SSLContext*.getDefault().getSupportedSSLParameters().getProtocols()));
Para ver o handshake do SSL em ação e qual versão do TLS é usada, use a propriedade do sistemajavax.net.debug.
java app.jar -Djavax.net.debug=ssl
Como definir a versão do TLSAWS SDK para Java 1.x
• Cliente Apache HTTP: o SDK sempre prefere o TLS 1.2 (se houver suporte para ele na plataforma).
AWS SDK para Java 2.x
• ApacheHttpClient: o SDK sempre prefere o TLS 1.2 (se houver suporte para ele na plataforma).• UrlHttpConnectionClient: para impor somente o TLS 1.2, você pode usar este comando Java.
java app.jar -Djdk.tls.client.protocols=TLSv1.2
Ou use este código.
System.setProperty("jdk.tls.client.protocols", "TLSv1.2");
148
AWS SDK para Java versão 2 Guia do desenvolvedorIdentity and Access Management
• NettyNioHttpClient: a dependência do SDK para Netty é o TLS 1.2 (se houver suporte para ele naplataforma).
Identity and Access Management para este produtoou serviço da AWS
O AWS Identity and Access Management (IAM) é um serviço da Amazon Web Services (AWS) que ajudaum administrador a controlar de forma segura o acesso aos recursos da AWS. Os administradores do IAMcontrolam quem pode ser autenticado (conectado) e autorizado (com permissões) para usar recursos nosserviços da AWS. O IAM é um serviço da AWS que pode ser usado sem custo adicional.
Para usar esse produto ou serviço da AWS para acessar a AWS, você precisa de uma conta da AWS ecredenciais da AWS. Para aumentar a segurança da conta da AWS, recomendamos usar um usuário doIAM para fornecer credenciais de acesso, em vez de usar as credenciais de sua conta da AWS.
Para obter detalhes sobre como trabalhar com o IAM, consulte AWS Identity and Access Management.
Para obter uma visão geral dos usuários do IAM e por que eles são importantes para a segurança de suaconta, consulte Credenciais de segurança da AWS na Referência geral da Amazon Web Services.
Esse produto ou serviço da AWS segue o modelo de responsabilidade compartilhada por meio dosserviços específicos da Amazon Web Services (AWS) compatíveis. Para obter informações de segurançado serviço da AWS, consulte a página de documentação de segurança do serviço da AWS e Serviços daAWS que estão no escopo dos esforços de conformidade da AWS por programa de conformidade.
Validação de conformidade para este produto ouserviço da AWS
Esse produto ou serviço da AWS segue o modelo de responsabilidade compartilhada por meio dosserviços específicos da Amazon Web Services (AWS) compatíveis. Para obter informações de segurançado serviço da AWS, consulte a página de documentação de segurança do serviço da AWS e Serviços daAWS que estão no escopo dos esforços de conformidade da AWS por programa de conformidade.
A segurança e a conformidade dos serviços da AWS são avaliadas por auditores terceiros como partede vários programas de conformidade da AWS. Isso inclui SOC, PCI, FedRAMP, HIPAA e outros. AAWS fornece uma lista atualizada com frequência de serviços da AWS no escopo de programas deconformidade específicos em Serviços da AWS no escopo do programa de conformidade.
Os relatórios de auditoria de terceiros estão disponíveis para download no AWS Artifact. Para obter maisinformações, consulte Download de relatórios no AWS Artifact.
Para obter mais informações sobre programas de conformidade da AWS, consulte Programas deconformidade da AWS.
Sua responsabilidade de conformidade ao usar esse produto ou serviço da AWS para acessar um serviçoda AWS é determinada pela confidencialidade de seus dados, pelas metas de conformidade da suaempresa e pelas regulamentações e leis aplicáveis. Se o seu uso de um serviço da AWS estiver sujeito àconformidade com padrões, como HIPAA, PCI ou FedRAMP, a AWS fornecerá os recursos para ajudar:
• Guias do Quick Start de segurança e conformidade – guias de implantação que discutem asconsiderações de arquitetura e fornecem etapas para implantação de ambientes de linha de basefocados em conformidade e segurança na AWS.
149
AWS SDK para Java versão 2 Guia do desenvolvedorResiliência
• Arquitetura para segurança e conformidade com HIPAA – um whitepaper que descreve como asempresas podem usar a AWS para criar aplicativos em conformidade com a HIPAA.
• Recursos de conformidade da AWS – uma coleção de manuais e guias que pode ser aplicada ao seusetor e local.
• AWS Config – um serviço que avalia até que ponto suas configurações de recursos estão emconformidade com práticas internas, diretrizes do setor e regulamentações.
• AWS Security Hub – uma visão abrangente do estado da segurança na AWS que ajuda você a verificara conformidade com os padrões do setor de segurança e as práticas recomendadas.
Resiliência para este produto ou serviço da AWSA infraestrutura global da Amazon Web Services (AWS) é baseada em regiões e zonas de disponibilidadeda AWS.
As regiões da AWS fornecem várias zonas de disponibilidade separadas e isoladas fisicamente, que sãoconectadas com baixa latência, altas taxas de transferência e redes altamente redundantes.
Com as zonas de disponibilidade, você pode projetar e operar aplicativos e bancos de dados queexecutam o failover automaticamente entre as zonas de disponibilidade sem interrupção. As zonas dedisponibilidade são mais altamente disponíveis, tolerantes a falhas e escaláveis que uma ou váriasinfraestruturas de data center tradicionais.
Para obter mais informações sobre regiões da AWS e zonas de disponibilidade, consulte Infraestruturaglobal da AWS.
Esse produto ou serviço da AWS segue o modelo de responsabilidade compartilhada por meio dosserviços específicos da Amazon Web Services (AWS) compatíveis. Para obter informações de segurançado serviço da AWS, consulte a página de documentação de segurança do serviço da AWS e Serviços daAWS que estão no escopo dos esforços de conformidade da AWS por programa de conformidade.
Segurança de infraestrutura para este produto ouserviço da AWS
Esse produto ou serviço da AWS segue o modelo de responsabilidade compartilhada por meio dosserviços específicos da Amazon Web Services (AWS) compatíveis. Para obter informações de segurançado serviço da AWS, consulte a página de documentação de segurança do serviço da AWS e Serviços daAWS que estão no escopo dos esforços de conformidade da AWS por programa de conformidade.
150
AWS SDK para Java versão 2 Guia do desenvolvedor
Histórico do documentoEste tópico descreve alterações importantes feitas no AWS SDK for Java Developer Guide ao longo do seuhistórico.
Esta documentação foi criada em: 15 de junho de 2020
19 de março de 2020
O TLS 1.2 foi adicionado à seção de segurança.2 de agosto de 2018
Adição de exemplos de fluxo do Kinesis.5 de abril de 2018
Adição do tópico de paginação automática.29 de dezembro de 2017
Adição de tópicos de exemplo do IAM, Amazon EC2, Cloudwatch e DynamoDB7 de agosto de 2017
Adição de exemplo de getobjects para o S3.4 de agosto de 2017
Adição do tópico assíncrono.28 de junho de 2017
Lançada a nova versão do SDK 2.0.
151
Top Related