Amazon Simple Queue Service - AWS Documentation · Amazon Simple Queue Service Guia do...

Amazon Simple Queue ServiceGuia do desenvolvedor

Amazon Simple Queue Service Guia do desenvolvedor

Amazon Simple Queue Service: Guia do desenvolvedorCopyright © 2018 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any mannerthat is likely to cause confusion among customers, or in any manner that disparages or discredits Amazon. All other trademarks notowned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to, or sponsored byAmazon.


Table of ContentsO que é o Amazon SQS? .................................................................................................................... 1

Quais são os principais benefícios do Amazon SQS? ...................................................................... 1Como o Amazon SQS é diferente do Amazon MQ ou do Amazon SNS? ............................................. 2De que tipo de fila eu preciso? ..................................................................................................... 2Como posso começar a usar o Amazon SQS? ............................................................................... 3Deixe seu comentário ................................................................................................................. 3

Tópicos novos e exibidos frequentemente .............................................................................................. 4Guia do desenvolvedor do Amazon Simple Queue Service ............................................................... 4Amazon Simple Queue Service API Reference ............................................................................... 4

Configuração ...................................................................................................................................... 6Etapa 1: Criação de uma conta da AWS ........................................................................................ 6Etapa 2: Criar um usuário do IAM ................................................................................................. 6Etapa 3: Obter ID de chave de acesso e a chave de acesso secreta .................................................. 7Etapa 4: Preparar-se para usar o código de exemplo ....................................................................... 8Próximas etapas ......................................................................................................................... 8

Conceitos básicos ............................................................................................................................... 9Pré-requisitos ............................................................................................................................. 9Etapa 1: Criar uma fila ................................................................................................................ 9Etapa 2: Enviar uma mensagem ................................................................................................. 10Etapa 3: Receber e excluir sua mensagem ................................................................................... 11Etapa 4: Excluir sua fila ............................................................................................................. 13Próximas etapas ....................................................................................................................... 14

Tutoriais .......................................................................................................................................... 16Criação de filas ........................................................................................................................ 16

Criação de uma fila ........................................................................................................... 16Criação de uma fila com a SSE .......................................................................................... 20

Como listar todas as filas ........................................................................................................... 24Console de gerenciamento da AWS .................................................................................... 24AWS SDK for Java ........................................................................................................... 24

Como adicionar permissões a uma fila ......................................................................................... 25Console de gerenciamento da AWS .................................................................................... 25

Adicionar, atualizar e remover tags de uma fila ............................................................................. 27Console de gerenciamento da AWS .................................................................................... 27AWS SDK for Java ........................................................................................................... 27

Envio de mensagens ................................................................................................................. 28Envio de uma mensagem .................................................................................................. 28Envio de uma mensagem com atributos ............................................................................... 32Envio de uma mensagem com um temporizador .................................................................... 36

Recebimento e exclusão de uma mensagem ................................................................................ 38Console de gerenciamento da AWS .................................................................................... 39AWS SDK for Java ........................................................................................................... 41

Inscrição de uma fila em um tópico ............................................................................................. 43Console de gerenciamento da AWS .................................................................................... 43

Configuração de um trigger do Lambda ....................................................................................... 45Pré-requisitos ................................................................................................................... 45Console de gerenciamento da AWS .................................................................................... 45

Como limpar uma fila ................................................................................................................ 47Console de gerenciamento da AWS .................................................................................... 47

Exclusão de uma fila ................................................................................................................. 48Console de gerenciamento da AWS .................................................................................... 48AWS SDK for Java ........................................................................................................... 49

Configuração de filas ................................................................................................................. 49Configuração da SSE para uma fila ..................................................................................... 50Configuração de sondagem longa para uma fila .................................................................... 53

iii


Configuração de uma dead letter queue ............................................................................... 56Configuração do tempo limite de visibilidade para uma fila ...................................................... 60Configuração de uma fila de atraso do Amazon SQS ............................................................. 63

Como Amazon SQS funciona ............................................................................................................. 67Arquitetura básica ..................................................................................................................... 67

Filas distribuídas ............................................................................................................... 67Ciclo de vida de mensagens .............................................................................................. 68

Filas Padrão ............................................................................................................................. 69Ordenação de mensagens ................................................................................................. 69Entrega pelo menos uma vez ............................................................................................. 69Consumo de mensagens usando sondagem breve ................................................................ 70Exemplo de Java funcional para filas Padrão ........................................................................ 70

Filas FIFO ............................................................................................................................... 72Ordenação de mensagens ................................................................................................. 73Termos-chave .................................................................................................................. 74Lógica da entrega FIFO ..................................................................................................... 74Processamento exatamente uma vez ................................................................................... 75Mudança de uma fila Padrão para uma fila FIFO ................................................................... 75Compatibilidade ................................................................................................................ 76Exemplo de Java funcional para filas FIFO ........................................................................... 77

Identificadores de filas e mensagens ........................................................................................... 79Identificadores de filas Padrão e FIFO ................................................................................. 79Identificadores adicionais para filas FIFO .............................................................................. 81

Atributos de mensagem ............................................................................................................. 81Componentes de atributos de mensagem ............................................................................. 81Tipos de dados de atributos de mensagem ........................................................................... 82Cálculo do resumo de mensagens MD5 para atributos de mensagem ....................................... 82

Recursos necessários para processar mensagens ......................................................................... 84Tags de alocação de custos ....................................................................................................... 84Sondagem longa ....................................................................................................................... 85

Diferenças entre sondagens longa e curta ............................................................................ 85Dead Letter Queues .................................................................................................................. 86

Como as dead letter queues funcionam? .............................................................................. 86Quais são os benefícios de dead letter queues? .................................................................... 87Como os diferentes tipos de fila tratam as falhas de mensagens? ............................................ 87Quando devo usar uma dead letter queue? .......................................................................... 88Solução de problemas com dead letter queues ..................................................................... 88

Tempo limite de visibilidade ....................................................................................................... 89Mensagens em trânsito ...................................................................................................... 90Definição do tempo limite de visibilidade .............................................................................. 90Alteração do tempo limite de visibilidade de uma mensagem ................................................... 91Término do tempo limite de visibilidade de uma mensagem ..................................................... 91

Filas de atraso ......................................................................................................................... 91Temporizadores de mensagem ................................................................................................... 92Gerenciamento de mensagens grandes ....................................................................................... 92

Java funcional de exemplo para usar o Amazon S3 ............................................................... 93Como trabalhar com o JMS ........................................................................................................ 96

Pré-requisitos ................................................................................................................... 96Conceitos básicos do Biblioteca do Sistema de mensagens Java ............................................. 97Uso do Cliente JMS com outros clientes do Amazon SQS ..................................................... 102Exemplo funcional de Java para uso do JMS com filas Padrão do Amazon SQS ....................... 103Suporte para implementações do JMS 1.1 .......................................................................... 117

Melhores práticas ............................................................................................................................ 119Recomendações para filas Padrão e FIFO .................................................................................. 119

Trabalhar com mensagens ............................................................................................... 119Redução de custos ......................................................................................................... 121Mudança de uma fila Padrão para uma fila FIFO ................................................................. 122

iv


Recomendações adicionais para filas FIFO ................................................................................. 122Uso do ID de eliminação de duplicação de mensagens ......................................................... 122Uso do ID do grupo de mensagens ................................................................................... 124Uso do ID de tentativa de solicitação de recebimento ........................................................... 124

Limites ........................................................................................................................................... 125Limites relacionados a filas ....................................................................................................... 125Limites relacionados a mensagens ............................................................................................ 126Limites relacionados a políticas ................................................................................................. 127

Monitoramento, registro em log e automação ...................................................................................... 128Monitoramento de filas usando o CloudWatch ............................................................................. 128

Acesso às métricas do CloudWatch para Amazon SQS ........................................................ 128Criação de alertas do CloudWatch para métricas do Amazon SQS ......................................... 130Métricas do CloudWatch disponíveis para Amazon SQS ....................................................... 131

Registro em log de chamadas à API usando o CloudTrail ............................................................. 134Informações sobre o Amazon SQS no CloudTrail ................................................................. 135Exemplo de entradas do arquivo de log do Amazon SQS ...................................................... 136

Automação de notificações usando o Eventos do CloudWatch ....................................................... 139Segurança ...................................................................................................................................... 140

Autenticação e controle de acesso ............................................................................................ 140Autenticação ................................................................................................................... 140Controle de acesso ......................................................................................................... 141Visão geral do gerenciamento de acesso ............................................................................ 142Uso de políticas com base em identidade (IAM) .................................................................. 147Uso de políticas personalizadas com o Access Policy Language ............................................. 155Uso de credenciais de segurança temporárias ..................................................................... 163Referência de permissões da API ...................................................................................... 165

Criptografia do lado do servidor ................................................................................................ 167O que a SSE faz para a criptografia do Amazon SQS? ......................................................... 168Termos-chave ................................................................................................................. 169Como o período de reutilização de chaves de dados funciona? .............................................. 170Como estimar meus custos de utilização do AWS KMS? ....................................................... 170De quais permissões do AWS KMS eu preciso para usar a SSE para o Amazon SQS? ............... 171Erros ............................................................................................................................. 174

Trabalhar com APIs ......................................................................................................................... 175Envio de solicitações da API de consulta .................................................................................... 175

Criar um endpoint ........................................................................................................... 175Como fazer uma solicitação GET ...................................................................................... 176Como fazer uma solicitação POST .................................................................................... 176Autenticação de solicitações ............................................................................................. 177Interpretação de respostas ............................................................................................... 179

Ações em lote ........................................................................................................................ 181Ativar buffer por parte do cliente e processamento de solicitações em lotes .............................. 181Aumento da taxa de transferência usando escalabilidade horizontal e processamento em lotesde ação da .................................................................................................................... 185

Recursos relacionados ..................................................................................................................... 195Notas de release ............................................................................................................................ 196

Histórico de documentos .......................................................................................................... 201AWS Glossary ................................................................................................................................ 215

v

Amazon Simple Queue Service Guia do desenvolvedorQuais são os principais benefícios do Amazon SQS?

O que é o Amazon Simple QueueService?

O Amazon Simple Queue Service (Amazon SQS) oferece uma fila hospedada segura, durável e disponívelque permite integrar e desassociar sistemas de software e componentes distribuídos. O Amazon SQSoferece constructos comuns, como dead letter queues (p. 86) e tags de alocação de custos (p. 84).Ele fornece uma API de web services genérica e pode ser acessado por qualquer linguagem deprogramação compatível com o SDK da AWS.

O Amazon SQS oferece suporte a filas padrão (p. 69) e FIFO (p. 72). Para obter mais informações,consulte De que tipo de fila eu preciso? (p. 2)

Tópicos• Quais são os principais benefícios do Amazon SQS? (p. 1)• Como o Amazon SQS é diferente do Amazon MQ ou do Amazon SNS? (p. 2)• De que tipo de fila eu preciso? (p. 2)• Como posso começar a usar o Amazon SQS? (p. 3)• Deixe seu comentário (p. 3)

Quais são os principais benefícios do AmazonSQS?

• Segurança – Você controla (p. 140) quem pode enviar e receber mensagens em uma fila do AmazonSQS.

O Criptografia do lado do servidor (SSE) (p. 167) permite transmitir dados confidenciais protegendoo conteúdo das mensagens nas filas usando chaves gerenciadas no AWS Key Management Service(AWS KMS).

• Durabilidade – Para garantir a segurança de suas mensagens, o Amazon SQS as armazena em váriosservidores. As filas Padrão oferecem suporte à entrega de mensagens pelo menos uma vez (p. 69), eas filas FIFO oferecem suporte ao processamento de mensagens exatamente uma vez (p. 75).

• Disponibilidade o – Amazon SQS usa infraestrutura redundante (p. 67) para fornecer acessoaltamente simultâneo às mensagens, e alta disponibilidade para produzir e consumir mensagens.

• Escalabilidade – Amazon SQS pode processar cada solicitação em buffer (p. 181) de formaindependente, escalando de forma transparente para lidar com qualquer aumento ou pico de carga semnenhuma instrução de provisionamento.

• Confiabilidade o – Amazon SQS bloqueia suas mensagens durante o processamento, de forma quevários produtores podem enviar e vários consumidores podem receber mensagens ao mesmo tempo.

• Personalização – suas filas não precisam ser exatamente iguais —, por exemplo, você pode definir umatraso padrão em uma fila (p. 91). Você pode armazenar o conteúdo de mensagens maiores que 256KB usando o Amazon Simple Storage Service (Amazon S3) (p. 92) ou o Amazon DynamoDB, com oAmazon SQS mantendo um ponteiro no objeto do Amazon S3, ou pode dividir uma mensagem grandeem mensagens menores.

1

Amazon Simple Queue Service Guia do desenvolvedorComo o Amazon SQS é diferente doAmazon MQ ou do Amazon SNS?

Como o Amazon SQS é diferente do Amazon MQou do Amazon SNS?

O Amazon SQS e o Amazon SNS são serviços de filas e de tópicos altamente escaláveis, simples deusar e não exigem a configuração de agentes de mensagens. Recomendamos esses serviços para novosaplicativos que podem se beneficiar de uma escalabilidade praticamente ilimitada e de APIs simples.

O Amazon MQ é um serviço gerenciado de agente de mensagens que fornece compatibilidade com muitosoperadores de mensagens populares. Recomendamos o Amazon MQ para migrar aplicativos de agentesde mensagens existentes que dependem da compatibilidade com APIs, como o JMS, ou de protocolos,como o AMQP, o MQTT, o OpenWire e o STOMP.

De que tipo de fila eu preciso?Fila Padrão Fila FIFO

Disponível em todas as regiões.

Taxa de transferência ilimitada – As filas Padrãooferecem suporte a um número quase ilimitado detransações por segundo (TPS) por ação de

Entrega pelo menos uma vez – uma mensagem éentregue pelo menos uma vez, mas às vezes maisde uma cópia da mensagem é entregue.

Melhor ordenação possível – às vezes, asmensagens podem ser entregues em uma ordemdiferente da qual elas foram enviadas.

Disponível nas regiões the Leste dos EUA (Norteda Virgínia), Leste dos EUA (Ohio), Oeste dos EUA(Oregon), e UE (Irlanda).Alta taxa de transferência – Por padrão, filas FIFOadmitem até 3.000 mensagens por segundo como agrupamento em lotes (p. 181). Para solicitarum aumento de limite, envie uma solicitação desuporte. As filas FIFO podem admitir até 300mensagens por segundo (300 operações de envio,recebimento ou exclusão por segundo) sem oagrupamento em lotes.

Processamento exatamente uma vez – umamensagem é entregue uma vez e permanecedisponível até que um consumidor a processe eexclua. As duplicações não são introduzidas nafila.

Entrega FIFO –a ordem em que as mensagens sãoenviadas e recebidas é preservada estritamente.

Enviar dados entre aplicativos quando a taxa detransferência for importante, por exemplo:

• Desacoplar solicitações de usuário em temporeal do intenso trabalho em segundo plano:permite que os usuários façam upload de mídiaenquanto a redimensionam ou a codificam.

• Alocar tarefas para vários nós operadores:processa um número elevado de solicitações devalidação de cartão de crédito.

Enviar dados entre aplicativos quando a ordem doseventos for importante, por exemplo:

• Verificar se os comandos inseridos pelo usuáriosão executados na ordem correta.

• Exibir o preço do produto correto enviandomodificações de preço na ordem correta.

• Impedir que um aluno se inscreva em um cursoantes de criar uma conta.

2

sns/

amazon-mq/

https://console.aws.amazon.com/support/v1?#/case/create


Amazon Simple Queue Service Guia do desenvolvedorComo posso começar a usar o Amazon SQS?

Fila Padrão Fila FIFO• Organizar as mensagens em lote para

processamento futuro: programa várias entradaspara adicioná-las ao banco de dados.

Como posso começar a usar o Amazon SQS?• Para criar sua primeira fila com o Amazon SQS e enviar, receber e excluir uma mensagem, consulte

Conceitos básicos do Amazon SQS (p. 9).• Para saber mais sobre a funcionalidade e a arquitetura do Amazon SQS, consulte Como Amazon SQS

funciona (p. 67).• Para conhecer as diretrizes e advertências que ajudarão você a aproveitar ao máximo o Amazon SQS,

consulte Práticas recomendadas para o Amazon SQS (p. 119).• Para saber mais sobre as ações do Amazon SQS, consulte Amazon Simple Queue Service API

Reference.• Para saber mais sobre os comandos da AWS CLI do Amazon SQS, consulte Amazon SQS na AWS CLI

Command Reference.

Deixe seu comentárioOs seus comentários são bem-vindos. Para entrar em contato conosco, visite o Fórun de discussão doAmazon SQS.

3

sqs/index.html

sqs/index.html

forum.jspa?forumID=12


Amazon Simple Queue Service Guia do desenvolvedorGuia do desenvolvedor do Amazon Simple Queue Service

Tópicos do Amazon SQS novos evisualizados com frequência

Última atualização: 10 de setembro de 2018

Guia do desenvolvedor do Amazon Simple QueueService

Novos tópicos sobre recursos de serviços Tópicos visualizados com mais frequência

1. Criação de alertas do CloudWatch para métricasdo Amazon SQS (p. 130)

2. Configuração de mensagens que chegam emuma fila para acionar uma função (p. 45)

3. Configuração do tempo limite de visibilidadepara uma fila (p. 60)

4. Configuração da sondagem longa para umafila (p. 53)

5. Configuração de uma dead letterqueue (p. 56)

6. Envio de uma mensagem com atributos a umafila (p. 32)

7. Atributos de mensagens do AmazonSQS (p. 81)

8. Habilitar a compatibilidade entre os serviços daAWS e as filas com (p. 173)

9. Como trabalhar com o JMS e o AmazonSQS (p. 96)

10.Tags de alocação de custos do AmazonSQS (p. 84)

1. Tempo limite de visibilidade do AmazonSQS (p. 89)

2. Dead-Letter Queues do Amazon SQS (p. 86)3. Filas FIFO (ordem de chegada) do Amazon

SQS (p. 72)4. Sondagem longa do Amazon SQS (p. 85)5. Limites do Amazon SQS (p. 125)6. Como Amazon SQS funciona (p. 67)7. Atributos de mensagens do Amazon

SQS (p. 81)8. Conceitos básicos do Amazon SQS (p. 9)9. Filas Padrão do Amazon SQS (p. 69)10.Uso de políticas personalizadas com a Access

Policy Languagedo Amazon SQS (p. 155)

Amazon Simple Queue Service API ReferenceNovos tópicos sobre recursos de serviços Tópicos visualizados com mais frequência

1. SendMessageBatch (Temporizadores demensagem)

2. SendMessage (Temporizadores de mensagem)3. CreateQueue (filas SSE, FIFO e de atraso)4. SetQueueAttributes (sondagem longa, filas

de atraso, Dead Letter Queues)

1. ReceiveMessage2. SendMessage3. GetQueueAttributes4. SendMessageBatch5. DeleteMessage

4

API_SendMessageBatch.html

API_SendMessage.html

API_CreateQueue.html

API_SetQueueAttributes.html

API_ReceiveMessage.html


API_GetQueueAttributes.html


API_DeleteMessage.html

Amazon Simple Queue Service Guia do desenvolvedorAmazon Simple Queue Service API Reference

Novos tópicos sobre recursos de serviços Tópicos visualizados com mais frequência5. ReceiveMessage (FIFO, sondagem longa)6. ListQueueTags7. UntagQueue8. TagQueue9. SetQueueAttributes (SSE, FIFO)10.GetQueueAttributes (SSE, FIFO)

6. ChangeMessageVisibility7. CreateQueue8. SetQueueAttributes9. GetQueueUrl10.AddPermission

5


API_ListQueueTags.html

API_UntagQueue.html

API_TagQueue.html



API_ChangeMessageVisibility.html



API_GetQueueUrl.html

API_AddPermission.html

Amazon Simple Queue Service Guia do desenvolvedorEtapa 1: Criação de uma conta da AWS

Configuração do Amazon SQSAntes de usar o Amazon SQS pela primeira vez, siga as etapas a seguir.

Etapa 1: Criação de uma conta da AWSPara acessar qualquer serviço da AWS, você precisa primeiro criar uma conta da AWS, uma conta daAmazon.com que possa usar os produtos da AWS. Você pode usar sua conta da AWS para visualizar seusrelatórios de atividades e de uso e para gerenciar autenticação e acesso.

Para evitar o uso do usuário raiz de sua conta da AWS para ações do Amazon SQS, é uma melhor práticacriar um usuário do IAM para cada pessoa que precisa de acesso administrativo ao Amazon SQS.

Para configurar uma nova conta

1. Abra https://aws.amazon.com/ e escolha Create an AWS Account (Criar uma conta da AWS).

Note

Se você fez login no Console de gerenciamento da AWS usando credenciais do Usuárioraiz da conta da AWS, escolha Sign in to a different account (Fazer login em uma contadiferente). Se você fez login no console usando as credenciais do IAM, escolha Sign-in usingroot account credentials (Fazer login usando credenciais da conta raiz). Em seguida, escolhaCreate a new AWS account (Criar uma conta da AWS).

2. Siga as instruções online.

Parte do procedimento de cadastro envolve receber uma chamada telefônica e digitar um código deverificação usando o teclado do telefone.

Etapa 2: Criar um usuário do IAMPara criar um usuário IAM para você mesmo e adicionar o usuário a um grupo de Administradores

1. Use seu endereço de e-mail e senha da conta da AWS para fazer login como Usuário raiz da conta daAWS no console do IAM em https://console.aws.amazon.com/iam/.

Note

Recomendamos que você siga as melhores práticas para utilizar o usuário do IAMAdministrador abaixo e armazene as credenciais do usuário raiz com segurança.Cadastre-se como usuário raiz para executar somente algumas tarefas de gerenciamento deserviços e contas.

2. No painel de navegação do console, escolha Users e Add user.3. Para User name, digite Administrator.4. Marque a caixa de seleção ao lado do acesso do Console de gerenciamento da AWS, selecione

Personalizar senha e digite nova senha de usuário na caixa de texto. Também é possível selecionarRequire password reset (Exigir redefinição de senha) para forçar o usuário a criar uma nova senha napróxima vez em que fizer login.

5. Escolha Próximo: Permissões.

6

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html

https://console.aws.amazon.com/iam/

https://docs.aws.amazon.com/general/latest/gr/aws_tasks-that-require-root.html

https://docs.aws.amazon.com/general/latest/gr/aws_tasks-that-require-root.html

Amazon Simple Queue Service Guia do desenvolvedorEtapa 3: Obter ID de chave de

acesso e a chave de acesso secreta

6. Na página Set permissions, escolha Add user to group.7. Escolha Criar grupo.8. Na caixa de diálogo Create group (Criar grupo), em Group name (Nome do grupo), digite

Administradores.9. Em Filter policies (Filtrar políticas), marque a caixa de seleção em AWS managed - job function

(Função de trabalho gerenciada pela AWS).10. Na lista de políticas, marque a caixa de seleção AdministratorAccess. A seguir escolha Criar grupo.11. Suporte a lista de grupos, selecione a caixa de seleção para seu novo grupo. Escolha Atualizar caso

necessário, para ver o grupo na lista.12. Escolha Próximo: Análise para ver uma lista de associações de grupos a serem adicionadas ao novo

usuário. Quando você estiver pronto para continuar, selecione Criar usuário.

Você pode usar esse mesmo processo para criar mais grupos e usuários, e conceder aos seus usuáriosacesso aos seus recursos de conta AWS. Para obter informações sobre como usar políticas para restringiras permissões de usuários a funcionalidades específicas da AWS, acesse Access Management e ExamplePolicies.

Etapa 3: Obter ID de chave de acesso e a chave deacesso secreta

Para usar ações do Amazon SQS (por exemplo, usando o Java ou por meio da AWS Command LineInterface), você precisa de um ID de chave de acesso e de uma chave de acesso secreta.

Note

O ID de chave de acesso e a chave de acesso secreta são específicos ao AWS Identity andAccess Management. Não os confunda com credenciais para outros serviços da AWS, como ospares de chaves do Amazon EC2.

Para obter o ID de chave de acesso e a chave de acesso secreta para um usuário do IAM

As chaves de acesso consistem em um ID de chave de acesso e uma chave de acesso secreta, que sãousados para assinar as solicitações programáticas que você faz à AWS. Se você não tiver chaves deacesso, poderá criá-las no Console de gerenciamento da AWS. Recomendamos que você use as chavesde acesso do IAM em vez de usar as chaves de acesso de Usuário raiz da conta da AWS. O IAM permiteque você controle com segurança o acesso aos serviços e recursos da AWS em sua conta da AWS.

A única ocasião em que você poderá visualizar ou fazer download das chaves de acesso secretas équando você criar as chaves. Não será possível recuperá-las posteriormente. No entanto, você pode criarnovas chaves de acesso a qualquer momento. Você também deve ter permissões para realizar as açõesdo IAM necessárias. Para obter mais informações sobre permissões e políticas, consulte Permissõesnecessárias para acessar os recursos do IAM no Guia do usuário do IAM.

1. Abra o console do IAM.2. No painel de navegação do console, escolha Users.3. Selecione seu nome de usuário do IAM (não a caixa de seleção).4. Escolha a guia Credenciais de segurança e escolha Criar chave de acesso.5. Para ver a nova chave de acesso, escolha Mostrar. Suas credenciais terão a seguinte aparência:

• ID de chave de acesso: AKIAIOSFODNN7EXAMPLE• Chave de acesso secreta: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

6. Para baixar o par de chaves, escolha Baixar arquivo .csv. Armazene as chaves em um lugar seguro.

7

https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_examples.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_examples.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html

https://console.aws.amazon.com/iam/home?#home

Amazon Simple Queue Service Guia do desenvolvedorEtapa 4: Preparar-se para usar o código de exemplo

Mantenha a confidencialidade das chaves para proteger sua conta da AWS e nunca envie-as por e-mail. Não compartilhe as chaves fora da sua organização, mesmo se uma pesquisa parecer vir daAWS ou da Amazon.com. Alguém que legitimamente represente a Amazon jamais pedirá a você suachave secreta.

Tópicos relacionados

• O que é o IAM? no Guia do usuário do IAM• Credenciais de segurança da AWS no AWS General Reference

Etapa 4: Preparar-se para usar o código deexemplo

Esse guia mostra como trabalhar com Amazon SQS usando o Console de gerenciamento da AWS e Java.Se você quiser usar o código de exemplo, deve instalar o Java Standard Edition Development Kit e fazeralgumas alterações de configurações para o código de exemplo.

Você pode gravar o código em outras linguagens de programação. Para obter mais informações, consultea documentação dos SDKs da AWS.

Note

Você pode explorar Amazon SQS sem código de gravação com ferramentas como AWSCommand Line Interface (AWS CLI) ou o Windows PowerShell. Você pode localizar exemplosde AWS CLI na seção Amazon SQS do AWS CLI Command Reference. Você pode encontrarexemplos do Windows PowerShell na seção Amazon Simple Queue Service do AWS Tools paraPowerShell Cmdlet Reference.

Próximas etapasAgora que está preparado para trabalhar com o Amazon SQS, você pode começar a usar (p. 9) ogerenciamento de mensagens e filas do Amazon SQS usando o Console de gerenciamento da AWS. Vocêtambém pode experimentar os tutoriais (p. 16) mais avançados do Amazon SQS.

8

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html

https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html

http://www.oracle.com/technetwork/java/javase/downloads/

https://aws.amazon.com//tools/#sdk

https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html

https://docs.aws.amazon.com/powershell/latest/reference/


Amazon Simple Queue Service Guia do desenvolvedorPré-requisitos

Conceitos básicos do Amazon SQSEsta seção ajudará você a se familiarizar com o Amazon SQS mostrando como gerenciar filas emensagens usando o Console de gerenciamento da AWS.

Pré-requisitosAntes de começar, conclua as tarefas em Configuração do Amazon SQS (p. 6).

Etapa 1: Criar uma filaA primeira e mais comum de tarefa do Amazon SQS é criar filas. Neste tutorial, você saberá como criar econfigurar uma fila.

1. Faça login no console do Amazon SQS.2. Selecione Criar nova fila.3. Na página Criar nova fila, assegure-se de que você esteja na região correta e digite o Nome da fila.

Note

O nome de uma fila FIFO deve terminar com o sufixo .fifo. as filas FIFO estão disponíveisnas regiões Leste dos EUA (Norte da Virgínia), Leste dos EUA (Ohio), Oeste dos EUA(Oregon), e UE (Irlanda).

4. Padrão é selecionado por padrão. Escolha FIFO.5. Para criar a fila com os parâmetros padrão, escolha Fila Quick-Create.

Sua nova fila é criada e selecionada na lista de filas.

Note

Quando você cria uma fila, pode demorar um breve período para a fila se propagar peloAmazon SQS..

A coluna Tipo de fila o ajuda a diferenciar as filas padrão das filas FIFO de uma só vez. Para fila FIFO,a coluna Desduplicação baseada em conteúdo exibe se você tiver habilitado o processamento exactly-once (p. 75).

O Nome, URL e ARN de sua fila são exibidos na guia Detalhes.

9

https://console.aws.amazon.com/sqs/

Amazon Simple Queue Service Guia do desenvolvedorEtapa 2: Enviar uma mensagem

Etapa 2: Enviar uma mensagemApós criar sua fila, você pode enviar uma mensagem para ela. O exemplo a seguir mostra o envio de umamensagem uma fila existente.

1. Na lista da fila, selecione a fila que você criou.

2. Em Ações da fila, selecione Enviar uma mensagem.

Será exibida a caixa de diálogo Enviar mensagem para QueueName.

O exemplo a seguir mostra os parâmetros ID do grupo de mensagem e ID de desduplicação demensagens específicos de filas FIFO (a desduplicação baseada em conteúdo (p. 75) estádesativada).

10

Amazon Simple Queue Service Guia do desenvolvedorEtapa 3: Receber e excluir sua mensagem

3. Para enviar uma mensagem a uma fila FIFO, digite o Corpo da mensagem, a ID do grupode mensagens MyMessageGroupId1234567890e a ID de desduplicação de mensagemMyMessageDeduplicationId1234567890. Em seguida, selecione Enviar mensagem. Para obtermais informações, consulte Lógica da entrega FIFO (p. 74).

Note

A ID do grupo de mensagens é sempre necessária. Contudo, se a desduplicação baseadaem conteúdo estiver ativada, ela será opcional.

Sua mensagem será enviada e a caixa de diálogo Enviar uma mensagem para QueueName seráexibida, mostrando os atributos da mensagem enviada.

O exemplo a seguir mostra o atributo Número de sequência específico para as filas FIFO.

4. Escolha Fechar.

Etapa 3: Receber e excluir sua mensagemApós enviar uma mensagem em uma fila, você pode consumi-la (recuperá-la da fila). Ao solicitar umamensagem de uma fila, você não pode especificar qual mensagem obter. Em vez disso, você especifica onúmero de mensagens máximo (até 10) que deseja obter.

Neste tutorial, você saberá como receber e excluir uma mensagem.

1. Na lista da fila, selecione a fila que você criou.2. Em Ações da fila, selecione Exibir/Excluir mensagens.

11

Amazon Simple Queue Service Guia do desenvolvedorEtapa 3: Receber e excluir sua mensagem

É exibido Exibir/excluir mensagens na caixa de diálogo QueueName.

Note

Na primeira vez que você realizar essa ação, será exibida uma tela de informações. Paraocultar a tela, marque a caixa de seleção Não mostrar isso novamente.

3. Selecione Iniciar seleção de mensagens.

O Amazon SQS começa a consultar as mensagens na fila. A caixa de diálogo exibe uma mensagemda fila. Um barra de andamento na parte inferior da caixa de diálogo exibe o status do tempo-limite devisibilidade da mensagem.

O exemplo a seguir mostra as colunas ID do grupo de mensagens, ID de desduplicação demensagens e Número de sequência específicas das filas FIFO.

4. Antes de o tempo limite de visibilidade expirar, selecione a mensagem que você deseja excluir eescolha Excluir 1 mensagem.

12

Amazon Simple Queue Service Guia do desenvolvedorEtapa 4: Excluir sua fila

A caixa de diálogo Excluir mensagens será exibida.

5. Confirme se a mensagem que você deseja excluir está marcada e escolha Sim, excluir mensagensmarcadas.

A mensagem selecionada é excluída.

Quando a barra de andamento estiver preenchida, o tempo limite de visibilidade (p. 89) vai expirare a mensagem ficará visível para consumidores.

6. Selecione Fechar.

Etapa 4: Excluir sua filaSe você não usar a fila Amazon SQS (e não prever usar no futuro próximo), é uma prática recomendadaexcluí-la do Amazon SQS. Neste tutorial, você saberá como excluir uma fila.

1. Na lista da fila, selecione a fila que você criou.

2. Em Ações da fila, selecione Excluir fila.

13

Amazon Simple Queue Service Guia do desenvolvedorPróximas etapas

A caixa de diálogo Excluir filas será exibida.

3. Escolha Sim, excluir fila.

A fila é excluída.

Próximas etapasAgora que você criou uma fila e aprendeu como enviar, receber e excluir mensagens e como excluir umafila, você pode querer experimentar o seguinte:

• Ativar o criptografia do lado do servidor (SSE) para uma nova fila (p. 20) ou configurar o SSE parauma fila existente. (p. 50)

• Adicionar permissões a uma fila. (p. 25)• Adicionar, atualizar ou remover tags de uma fila. (p. 27)• Configure a sondagem longa para uma fila. (p. 53)• Enviar uma mensagem com atributos. (p. 32)• Enviar uma mensagem com um temporizador. (p. 36)• Configurar uma dead-letter queue. (p. 56)• Configure o tempo limite de visibilidade para uma fila. (p. 60)• Configurar uma fila de atraso. (p. 63)• Inscrever uma fila em um tópico do Amazon SNS. (p. 43)• Configurar mensagens que chegam em uma fila para acionar uma função do Lambda. (p. 45)• Depurar uma fila. (p. 47)• Saiba mais sobre os fluxos de trabalho e processos do Amazon SQS: leia Como as filas

funcionam (p. 67), Práticas recomendadas (p. 119) e Limites (p. 125). Você também podeexplorar Artigos e tutoriais do Amazon SQS. Se você tiver alguma dúvida, procure as Perguntasfrequentes do Amazon SQS ou participe dos Fóruns de desenvolvedores do Amazon SQS.

• Saiba como interagir com o Amazon SQS de forma programática: leia Trabalhar com APIs (p. 175) eexplore Código de exemplo e bibliotecas e os centros de desenvolvedor:• Java

14

articles/Amazon-SQS?browse=1

sqs/faqs/

sqs/faqs/


code/Amazon-SQS?browse=1

java/

Amazon Simple Queue Service Guia do desenvolvedorPróximas etapas

• JavaScript• PHP• Python• Ruby• Windows e .NET

• Saiba mais sobre como acompanhar custos e recursos na seção Monitoramento, registro em log eautomação (p. 128).

• Saiba mais sobre como proteger seus dados e o acesso aos dados na seção Segurança (p. 140).

15

javascript/

php/

python/

ruby/

net/

Amazon Simple Queue Service Guia do desenvolvedorCriação de filas

Tutoriais do Amazon SQSEsse guia mostra como trabalhar com Amazon SQS usando o Console de gerenciamento da AWS e Java.Se você quiser usar o código de exemplo, deve instalar o Java Standard Edition Development Kit e fazeralgumas alterações de configurações para o código de exemplo.

Você pode gravar o código em outras linguagens de programação. Para obter mais informações, consultea documentação dos SDKs da AWS.

Note

Você pode explorar Amazon SQS sem código de gravação com ferramentas como AWSCommand Line Interface (AWS CLI) ou o Windows PowerShell. Você pode localizar exemplosde AWS CLI na seção Amazon SQS do AWS CLI Command Reference. Você pode encontrarexemplos do Windows PowerShell na seção Amazon Simple Queue Service do AWS Tools paraPowerShell Cmdlet Reference.

Tópicos• Tutoriais: Criação de filas do Amazon SQS (p. 16)• Tutorial: Como listar todas as filas do Amazon SQS em uma região (p. 24)• Tutorial: Adição de permissões para uma fila do Amazon SQS (p. 25)• Tutorial: Adição, atualização e remoção de tags de alocação de custos de uma fila do Amazon

SQS (p. 27)• Tutoriais: Envio de mensagens a filas do Amazon SQS (p. 28)• Tutorial: Recebimento e exclusão de uma mensagem de uma fila do Amazon SQS (p. 38)• Tutorial: Inscrição de uma fila do Amazon SQS em um tópico do Amazon SNS (p. 43)• Tutorial: Configuração de mensagens que chegam em uma fila do Amazon SQS para acionar uma

função do AWS Lambda (p. 45)• Tutorial: Limpeza de mensagens de uma fila do Amazon SQS (p. 47)• Tutorial: Exclusão de uma fila do Amazon SQS (p. 48)• Tutoriais: Configuração de filas do Amazon SQS (p. 49)

Tutoriais: Criação de filas do Amazon SQSOs tutoriais a seguir mostram como criar filas do Amazon SQS de várias maneiras.

Tópicos• Tutorial: Criação de uma fila do Amazon SQS (p. 16)• Tutorial: Criação de uma fila do Amazon SQS com a Criptografia do lado do servidor (SSE) (p. 20)

Tutorial: Criação de uma fila do Amazon SQSA primeira e mais comum de tarefa do Amazon SQS é criar filas. Neste tutorial, você saberá como criar econfigurar uma fila.

Tópicos• Console de gerenciamento da AWS (p. 17)• AWS SDK for Java (p. 18)• AWS CloudFormation (p. 19)

16

http://www.oracle.com/technetwork/java/javase/downloads/

https://aws.amazon.com//tools/#sdk

https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html



Amazon Simple Queue Service Guia do desenvolvedorCriação de uma fila

Console de gerenciamento da AWS1. Faça login no console do Amazon SQS.2. Selecione Criar nova fila.3. Na página Criar nova fila, assegure-se de que você esteja na região correta e digite o Nome da fila.

Note


4. Padrão é selecionado por padrão. Escolha FIFO.5. Crie sua fila.

• Para criar a fila com os parâmetros padrão, escolha Fila Quick-Create.• Para configurar os parâmetros da fila, escolha Configurar fila. Quando você encerrar a configuração

dos parâmetros, escolha Criar fila. Para obter mais informações sobre a criação de uma fila comSSE, consulte Criação de uma fila com (p. 20).

,O exemplo a seguir mostra o parâmetro Desduplicação baseada em conteúdo específico das filasFIFO.

Sua nova fila é criada e selecionada na lista de filas.

Note

Quando você cria uma fila, pode demorar um breve período para a fila se propagar peloAmazon SQS.


17




AWS SDK for JavaAntes de você começar a trabalhar com o código de exemplo, especifique suas credenciais da AWS. Paramais informações, consulte Configurar credenciais e a região da AWS para desenvolvimento em AWSSDK for Java Developer Guide.

Para criar uma fila padrão

1. Copie o programa de exemplo (p. 70).

A seção do código a seguir cria a fila MyQueue:

// Create a queueSystem.out.println("Creating a new SQS queue called MyQueue.\n");final CreateQueueRequest createQueueRequest = new CreateQueueRequest("MyQueue");final String myQueueUrl = sqs.createQueue(createQueueRequest).getQueueUrl();

2. Compile e execute o exemplo.

A fila é criada.

Para criar uma fila FIFO


A seção do código a seguir cria a fila MyFifoQueue.fifo:

// Create a FIFO queueSystem.out.println("Creating a new Amazon SQS FIFO queue called " + "MyFifoQueue.fifo.\n");final Map<String, String> attributes = new HashMap<String, String>();

// A FIFO queue must have the FifoQueue attribute set to Trueattributes.put("FifoQueue", "true");

// If the user doesn't provide a MessageDeduplicationId, generate a MessageDeduplicationId based on the content.attributes.put("ContentBasedDeduplication", "true");

// The FIFO queue name must end with the .fifo suffixfinal CreateQueueRequest createQueueRequest = new CreateQueueRequest("MyFifoQueue.fifo") .withAttributes(attributes);final String myQueueUrl = sqs.createQueue(createQueueRequest).getQueueUrl();


A fila é criada.

18

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html


AWS CloudFormationVocê pode usar o console do AWS CloudFormation ou um modelo JSON (ou YAML) para criar umafila do Amazon SQS. Para obter mais informações, consulte Como trabalhar com modelos do AWSCloudFormation e o Recurso do AWS::SQS::Queue no Guia do usuário do AWS CloudFormation.

1. Copie o seguinte código JSON em um arquivo denominado MyQueue.json. Para criar uma filapadrão, omita as propriedades FifoQueue e ContentBasedDeduplication. Para obter maisinformações sobre a eliminação de duplicação baseada em conteúdo, consulte Processamentoexatamente uma vez (p. 75).

Note


{ "AWSTemplateFormatVersion": "2010-09-09", "Resources": { "MyQueue": { "Properties": { "QueueName": "MyQueue.fifo", "FifoQueue": true, "ContentBasedDeduplication": true }, "Type": "AWS::SQS::Queue" } }, "Outputs": { "QueueName": { "Description": "The name of the queue", "Value": { "Fn::GetAtt": [ "MyQueue", "QueueName" ] } }, "QueueURL": { "Description": "The URL of the queue", "Value": { "Ref": "MyQueue" } }, "QueueARN": { "Description": "The ARN of the queue", "Value": { "Fn::GetAtt": [ "MyQueue", "Arn" ] } } }}

2. Faça login no console do AWS CloudFormation e, em seguida, selecione Create Stack (Criar pilha).3. Na página Select Template (Selecionar modelo), escolha Upload a template to Amazon S3 (Fazer

upload de um modelo no &S3;), selecione o arquivo MyQueue.json e escolha Next (Avançar).4. Na página Specify Details, digite MyQueue em Stack Name e escolha Next.5. Na página Options, selecione Next.

19

template-guide.html

template-guide.html

aws-properties-sqs-queues.html

cloudformation

Amazon Simple Queue Service Guia do desenvolvedorCriação de uma fila com a SSE

6. Na página Revisão, selecione Criar.

O AWS CloudFormation começa a criar a pilha MyQueue e exibe o status CREATE_IN_PROGRESS.Quando o processo é concluído, o AWS CloudFormation exibe o status CREATE_COMPLETE.

7. (Opcional) Para exibir o nome, a URL e o nome de recurso da Amazon (ARN) da fila, escolha o nomeda pilha e, em seguida, na próxima página, expanda a seção Outputs.

Tutorial: Criação de uma fila do Amazon SQS com aCriptografia do lado do servidor (SSE)Criptografia do lado do servidor (SSE) de Amazon SQS está disponível em todas as regiões comerciaisonde Amazon SQS está disponível, exceto por Regiões da China. Você pode habilitar a SSE para uma filapara proteger seus dados. Para obter mais informações sobre o uso de SSE, consulte Proteção de dadosusando criptografia no lado do servidor (SSE) e AWS KMS (p. 167).

Important

Todas as solicitações para filas com SSE ativado devem usar HTTPS e Signature versão 4.

Neste tutorial, você aprenderá como criar uma fila do Amazon SQS com a SSE habilitada. Embora oexemplo use uma fila FIFO, a SSE funciona com as filas padrão e FIFO.

Tópicos• Console de gerenciamento da AWS (p. 20)• AWS SDK for Java (p. 22)

Console de gerenciamento da AWS1. Faça login no console do Amazon SQS.

20

https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html



2. Selecione Criar nova fila.3. Na página Criar nova fila, assegure-se de que você esteja na região correta e digite o Nome da fila.

Note


4. Padrão é selecionado por padrão. Escolha FIFO.5. Escolha Configure Queue e, em seguida, escolha Use SSE.6. Especifique o ID da chave mestra do cliente (CMK). Para obter mais informações, consulte Termos-

chave (p. 169).

Para cada tipo de CMK, a Descrição, a Conta e a Chave do ARN da CMK são exibidas.

Important

Se você não for o proprietário da CMK ou se fizer login com uma conta que não tenhapermissões kms:ListAliases e kms:DescribeKey, não será possível visualizar asinformações sobre a CMK no console do Amazon SQS.Peça ao proprietário da CMK para conceder essas permissões a você. Para obter maisinformações, consulte Permissões de API do AWS KMS: referência a ações e recursos noAWS Key Management Service Developer Guide.

• A CMK gerenciada pela AWS para o Amazon SQS é selecionada por padrão.

Note

Mantenha o seguinte em mente:• Se você não especificar uma CMK personalizada, o Amazon SQS usará a CMK

gerenciada pela AWS para o Amazon SQS. Para obter instruções sobre como criarCMKs personalizadas, consulte Criação de chaves no AWS Key Management ServiceDeveloper Guide.

• A primeira vez que você usar o Console de gerenciamento da AWS para especificar aCMK gerenciada pela AWS para o Amazon SQS para uma fila, o AWS KMS criará aCMK gerenciada pela AWS para o Amazon SQS.

• Como alternativa, a primeira vez que você usar a ação da SendMessage ouSendMessageBatch em uma fila com SSE habilitada, o AWS KMS criará a CMKgerenciada pela AWS para o Amazon SQS.

• Para usar uma CMK personalizada de sua conta da AWS, selecione-a na lista.

Note

Para obter instruções sobre como criar CMKs personalizadas, consulte Criação de chavesno AWS Key Management Service Developer Guide.

• Para usar um ARN da CMK personalizada de sua conta da AWS ou de outra conta da AWS,selecione Inserir um ARN da CMK existente na lista e digite ou copie a CMK.

21

https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html

https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html



7. (Opcional) Para o Período de reutilização da chave de dados, especifique um valor entre 1 minutoe 24 horas. O padrão é 5 minutos. Para obter mais informações, consulte Como o período dereutilização de chaves de dados funciona? (p. 170).

8. Escolha Create Queue.

Sua nova fila é criada com a SSE. O status da criptografia, o alias da CMK, a Description, a Account, oKey ARN e o Data Key Reuse Period são exibidos na guia Encryption.


Antes que possa usar a SSE, você deve configurar as políticas de chaves do AWS KMS para permitira criptografia de filas e a criptografia e a descriptografia de mensagens. Você também deve garantirque as políticas de chave da chave mestra do cliente (CMK) forneçam as permissões necessárias. Paraobter mais informações, consulte De quais permissões do AWS KMS eu preciso para usar a SSE para oAmazon SQS? (p. 171)

1. Obtenha o ID da chave mestra do cliente (CMK). Para obter mais informações, consulte Termos-chave (p. 169).

Note

Mantenha o seguinte em mente:

• Se você não especificar uma CMK personalizada, o Amazon SQS usará a CMKgerenciada pela AWS para o Amazon SQS. Para obter instruções sobre como criar CMKspersonalizadas, consulte Criação de chaves no AWS Key Management Service DeveloperGuide.

• A primeira vez que você usar o Console de gerenciamento da AWS para especificar aCMK gerenciada pela AWS para o Amazon SQS para uma fila, o AWS KMS criará a CMKgerenciada pela AWS para o Amazon SQS.


2. Para habilitar a criptografia do lado do servidor, especifique o ID da CMK configurando o atributoKmsMasterKeyId da ação CreateQueue ou SetQueueAttributes.

22






O código de exemplo a seguir cria uma nova fila com a SSE usando a CMK gerenciada pela AWSpara o Amazon SQS:

final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();final CreateQueueRequest createRequest = new CreateQueueRequest("MyQueue");final Map<String, String> attributes = new HashMap<String, String>(); // Enable criptografia do lado do servidor by specifying the alias ARN of the// AWS managed CMK for Amazon SQS.final String kmsMasterKeyAlias = "arn:aws:kms:us-east-2:123456789012:alias/aws/sqs";attributes.put("KmsMasterKeyId", kmsMasterKeyAlias); // (Optional) Specify the length of time, in seconds, for which Amazon SQS can reuse attributes.put("KmsDataKeyReusePeriodSeconds", "60");

final CreateQueueResult createResult = client.createQueue(createRequest);

O código de exemplo a seguir cria uma nova fila com a SSE usando uma CMK personalizada:

final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();final CreateQueueRequest createRequest = new CreateQueueRequest("MyQueue");final Map<String, String> attributes = new HashMap<String, String>(); // Enable criptografia do lado do servidor by specifying the alias ARN of the custom CMK.final String kmsMasterKeyAlias = "arn:aws:kms:us-east-2:123456789012:alias/MyAlias";attributes.put("KmsMasterKeyId", kmsMasterKeyAlias); // (Optional) Specify the length of time, in seconds, for which Amazon SQS can reuse // a data key to encrypt or decrypt messages before calling AWS KMS again.attributes.put("KmsDataKeyReusePeriodSeconds", "864000"); final CreateQueueResult createResult = client.createQueue(createRequest);

3. (Opcional) Especifique o tempo, em segundos, durante o qual o Amazon SQS pode reutilizar umachave de dados (p. 169) para criptografar ou descriptografar as mensagens antes de chamar o AWSKMS novamente. Defina o atributo KmsDataKeyReusePeriodSeconds da ação CreateQueue ouSetQueueAttributes. Os valores possíveis podem estar entre 60 segundos (1 minuto) e 86.400segundos (24 horas). Se você não especificar um valor, o valor padrão de 300 segundos (5 minutos)será usado.

O primeiro exemplo de código acima define o período de reutilização de chaves de dados como 60segundos (1 minuto). O segundo exemplo de código define como 86.400 segundos (24 horas). Oexemplo de código a seguir define o período de reutilização de chaves de dados como 60 segundos (1minuto):

// (Optional) Specify the length of time, in seconds, for which Amazon SQS can reuse // a data key to encrypt or decrypt messages before calling AWS KMS again.attributes.put("KmsDataKeyReusePeriodSeconds", "60");

Para obter informações sobre a recuperação de atributos de uma fila, consulte Exemplos no AmazonSimple Queue Service API Reference.

Para recuperar o ID da CMK ou o período de reutilização da chave de dados para uma fila específica, useos atributos KmsMasterKeyId e KmsDataKeyReusePeriodSeconds da ação GetQueueAttributes.

Para obter informações sobre a alternância de uma fila para uma CMK diferente com o mesmo alias,consulte Atualização de um alias no AWS Key Management Service Developer Guide.

23



https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html#API_GetQueueAttributes_Examples

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html

https://docs.aws.amazon.com/kms/latest/developerguide/programming-aliases.html#update-alias

Amazon Simple Queue Service Guia do desenvolvedorComo listar todas as filas

Tutorial: Como listar todas as filas do Amazon SQSem uma região

Quando você cria uma fila, pode demorar um breve período para a fila se propagar pelo Amazon SQS.Neste tutorial, você saberá como confirmar a existência de sua fila listando todas as filas na região atual.


Console de gerenciamento da AWS1. Faça login no console do Amazon SQS.2. Suas filas na região atual são listadas.




Note

Essa ação é idêntica para filas padrão e FIFO.

1. Copie o programa de exemplo de fila padrão (p. 70) ou o programa de exemplo de filaFIFO (p. 77).

A seção a seguir do código lista todas as filas na região atual:

// List queuesSystem.out.println("Listing all queues in your account.\n");for (final String queueUrl : sqs.listQueues().getQueueUrls()) { System.out.println(" QueueUrl: " + queueUrl);}System.out.println();


24



Amazon Simple Queue Service Guia do desenvolvedorComo adicionar permissões a uma fila

Todas as filas na região atual criada usando a versão de API 2012-11-05 são listadas. A respostainclui os seguintes itens:

• O URL da fila exclusivo.• O ID de solicitação que Amazon SQS atribuiu à sua solicitação.

Tutorial: Adição de permissões para uma fila doAmazon SQS

Você pode especificar a quem permitir (ou negar explicitamente) a capacidade de interagir com sua filade maneiras específicas ao adicionar permissões a uma fila. O exemplo a seguir mostra como adicionar apermissão para qualquer pessoa para obter a URL de uma fila.

Note

Uma política do Amazon SQS pode ter no máximo sete ações.

Console de gerenciamento da AWS1. Faça login no console do Amazon SQS.2. Na lista de filas, selecione uma fila.

3. Em Queue Actions, selecione Add a Permission.

A caixa de diálogo Add a Permission é exibida.4. Neste exemplo, você permite que qualquer pessoa obtenha a URL da fila:

25


Amazon Simple Queue Service Guia do desenvolvedorConsole de gerenciamento da AWS

Ao lado de Effect, selecione Allow.

Ao lado de Principal, selecione a caixa Everybody.

Na lista suspensa Actions, selecione a caixa GetQueueUrl.

Escolha Add Permission.

A permissão é adicionada à fila.

As opções Effect, Principals, Actions e Conditions da política de suas filas são exibidas na guiaPermissions da fila.

26

Amazon Simple Queue Service Guia do desenvolvedorAdicionar, atualizar e remover tags de uma fila

Tutorial: Adição, atualização e remoção de tags dealocação de custos de uma fila do Amazon SQS

Você pode adicionar tags de alocação de custos a suas filas do Amazon SQS para ajudar a organizá-lase identificá-las. O exemplo a seguir mostram como adicionar, atualizar e remover tags de uma fila. Paraobter mais informações, consulte Tags de alocação de custos do Amazon SQS (p. 84).


Console de gerenciamento da AWSAs etapas a seguir presumem que você já criou uma fila do Amazon SQS (p. 16).

1. Faça login no console do Amazon SQS.2. Na lista de filas, selecione uma fila.

3. Escolha a guia Tags.

As tags adicionadas à fila são listadas.

4. Escolha Add/Edit Tags.5. Modificar tags de fila:

• Para adicionar uma tag, escolha Add New Tag, insira uma Key e Value e, em seguida, escolhaApply Changes.

• Para atualizar uma tag, altere sua Key e Value e, em seguida, escolha Apply Changes.• Para remover uma tag, escolha ao lado de um par chave-valor e, em seguida, escolha Apply

Changes (Aplicar alterações).

As alterações da tag de fila são aplicadas.


27



Amazon Simple Queue Service Guia do desenvolvedorEnvio de mensagens

Para adicionar, atualizar e remover tags de uma fila1. Copie o programa de exemplo para uma fila padrão (p. 70)ou para uma fila FIFO (p. 77).2. Para listar as tags adicionadas a uma fila, adicione o código a seguir que usa a ação da

ListQueueTags:

final ListQueueTagsRequest listQueueTagsRequest = new ListQueueTagsRequest(queueUrl);final ListQueueTagsResult listQueueTagsResult = SQSClientFactory.newSQSClient() .listQueueTags(listQueueTagsRequest);System.out.println(String.format("ListQueueTags: \tTags for queue %s are %s.\n", QUEUE_NAME, listQueueTagsResult.getTags()));

3. Para adicionar ou atualizar os valores das tags da fila usando a chave da tag, adicione o código aseguir que usa a ação da TagQueue:

final Map<String, String> addedTags = new HashMap<>();addedTags.put("Team", "Development");addedTags.put("Priority", "Beta");addedTags.put("Accounting ID", "456def");final TagQueueRequest tagQueueRequest = new TagQueueRequest(queueUrl, addedTags);

System.out.println(String.format("TagQueue: \t\tAdd tags %s to queue %s.\n", addedTags, QUEUE_NAME));SQSClientFactory.newSQSClient().tagQueue(tagQueueRequest);

4. Para remover uma tag da fila usando a chave da tag, adicione o código a seguir que usa a ação daUntagQueue:

final List<String> tagKeys = Arrays.asList("Accounting ID");final UntagQueueRequest untagQueueRequest = new UntagQueueRequest(queueUrl, tagKeys);System.out.println(String.format("UntagQueue: \tRemove tags %s from queue %s.\n", tagKeys, QUEUE_NAME));SQSClientFactory.newSQSClient().untagQueue(untagQueueRequest);

5. Compile e execute o programa.

As tags existentes são listadas, três são atualizadas e uma tag é removida da fila.

Tutoriais: Envio de mensagens a filas do AmazonSQS

Os tutoriais a seguir mostram como enviar mensagens às filas do Amazon SQS de várias maneiras.

Tópicos• Tutorial: Envio de uma mensagem a uma fila do Amazon SQS (p. 28)• Tutorial: Envio de uma mensagem com atributos a uma fila do Amazon SQS (p. 32)• Tutorial: Envio de uma mensagem com um temporizador a uma fila do Amazon SQS (p. 36)

Tutorial: Envio de uma mensagem a uma fila doAmazon SQSApós criar sua fila, você pode enviar uma mensagem para ela. O exemplo a seguir mostra o envio de umamensagem uma fila existente.

28

Amazon Simple Queue Service Guia do desenvolvedorEnvio de uma mensagem






29



4. Para enviar uma mensagem a uma fila FIFO, digite o Corpo da mensagem, a ID do grupode mensagens MyMessageGroupId1234567890e a ID de desduplicação de mensagemMyMessageDeduplicationId1234567890. Em seguida, selecione Enviar mensagem. Para obtermais informações, consulte Lógica da entrega FIFO (p. 74).

Note

A ID do grupo de mensagens é sempre necessária. Contudo, se a desduplicação baseadaem conteúdo estiver ativada, ela será opcional.


O exemplo a seguir mostra o atributo Número de sequência específico para as filas FIFO.

30


5. Escolha Fechar.


Para enviar uma mensagem a uma fila do padrão


A seção do código a seguir envia a mensagem This is my message text. para a sua fila:

// Send a messageSystem.out.println("Sending a message to MyQueue.\n");sqs.sendMessage(new SendMessageRequest(myQueueUrl, "This is my message text."));


A mensagem é enviada para a fila. A resposta inclui os seguintes itens:

• O ID de mensagem (p. 80) que Amazon SQS atribui à mensagem.• Um resumo MD5 do corpo da mensagem, usado para confirmar que o Amazon SQS recebeu a

mensagem corretamente (para obter mais informações, consulte RFC1321).• O ID de solicitação que Amazon SQS atribuiu à sua solicitação.

Para enviar uma mensagem a uma fila do FIFO


A seção do código a seguir envia a mensagem This is my message text. para a sua fila:

// Send a messageSystem.out.println("Sending a message to MyFifoQueue.fifo.\n");final SendMessageRequest sendMessageRequest = new SendMessageRequest(myQueueUrl, "This is my message text.");

// When you send messages to a FIFO queue, you must provide a non-empty MessageGroupId.sendMessageRequest.setMessageGroupId("messageGroup1");

// Uncomment the following to provide the MessageDeduplicationId//sendMessageRequest.setMessageDeduplicationId("1");final SendMessageResult sendMessageResult = sqs.sendMessage(sendMessageRequest);final String sequenceNumber = sendMessageResult.getSequenceNumber();

31


http://faqs.org/rfcs/rfc1321.html

Amazon Simple Queue Service Guia do desenvolvedorEnvio de uma mensagem com atributos

final String messageId = sendMessageResult.getMessageId();System.out.println("SendMessage succeed with messageId " + messageId + ", sequence number " + sequenceNumber + "\n");


A mensagem é enviada para a sua fila.

Tutorial: Envio de uma mensagem com atributos auma fila do Amazon SQSVocê pode incluir metadados estruturados (como carimbos de data e hora, dados geoespaciais,assinaturas e identificadores) com mensagens usando os atributos de mensagem. Neste tutorial, vocêaprenderá como enviar uma mensagem com atributos a uma fila existente. Para obter mais informações,consulte Atributos de mensagens do Amazon SQS (p. 81).

Para obter uma explicação mais detalhada de como enviar mensagens a filas padrão e FIFO, consulteEnvio de uma mensagem a uma fila (p. 28).






32



4. Para enviar uma mensagem a uma fila FIFO, digite o Message Body (Corpo da mensagem),o Message Group ID (ID do grupo de mensagens) MyMessageGroupId1234567890e o Message Deduplication ID (ID de eliminação de duplicação de mensagens)MyMessageDeduplicationId1234567890 e, em seguida, selecione Message Attributes (Atributosde mensagens).

5. Defina os parâmetros do atributo de mensagem. Para obter mais informações, consulte Componentesde atributos de mensagem (p. 81) e Tipos de dados de atributos de mensagem (p. 82).

33


a. Em Name (Nome) do atributo de mensagem, digite MyMessageAttribute.b. Em Type (Tipo) de dados do atributo de mensagem, selecione Number (Número) e digite byte

para o tipo personalizado opcional.c. Em Value (Valor) do atributo de mensagem, digite 24.

Selecione Add attribute (Adicionar atributo).

O atributo é adicionado à mensagem como Number.byte.

Você pode modificar o valor antes de enviar a mensagem. Para excluir o atributo, escolha .6. Ao concluir a adição de atributos à mensagem, selecione Send Message (Enviar mensagem).


O exemplo a seguir mostra o MD5 of Message Attributes (MD5 de atributos de mensagens) específicoao atributo de mensagem personalizado e o atributo Sequence Number (Número de sequência)específico a filas FIFO.

7. Escolha Fechar.


Para enviar uma mensagem com atributos a uma fila


2. Para definir um atributo para uma mensagem, adicione o código a seguir que usa o tipo de dadosMessageAttributeValue. Para obter mais informações, consulte Componentes de atributos demensagem (p. 81) e Tipos de dados de atributos de mensagem (p. 82).

Note

O AWS SDK for Java calcula automaticamente as somas de verificação do corpo damensagem e dos atributos da mensagem e compara-as com os dados retornados peloAmazon SQS. Para obter mais informações, consulte AWS SDK for Java Developer Guide eCálculo do resumo de mensagens MD5 para atributos de mensagem (p. 82) para outraslinguagens de programação.

34


API_MessageAttributeValue.html


String

Este exemplo define um atributo String chamado Name com o valor Jane.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("Name", new MessageAttributeValue() .withDataType("String") .withStringValue("Jane"));

Number

Este exemplo define um atributo Number chamado AccurateWeight com o valor230.000000000000000001.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("AccurateWeight", new MessageAttributeValue() .withDataType("Number") .withStringValue("230.000000000000000001"));

Binary

Este exemplo define um atributo Binary chamado ByteArray com o valor de uma matriz de 10bytes não inicializada.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("ByteArray", new MessageAttributeValue() .withDataType("Binary") .withBinaryValue(ByteBuffer.wrap(new byte[10])));

String (Custom)

Este exemplo define o atributo personalizado String.EmployeeId chamado EmployeeId como valor ABC123456.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("EmployeeId", new MessageAttributeValue() .withDataType("String.EmployeeId") .withStringValue("ABC123456"));

Number (Custom)

Este exemplo define o atributo personalizado Number.AccountId chamado AccountId com ovalor 0023456.

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("AccountId", new MessageAttributeValue() .withDataType("Number.AccountId") .withStringValue("000123456"));

Note

Como o tipo de dados base é Number, a ação ReceiveMessage retorna 123456.Binary (Custom)

Este exemplo define um atributo personalizado Binary.JPEG chamado ApplicationIcon como valor de uma matriz de 10 bytes não inicializada.

35


Amazon Simple Queue Service Guia do desenvolvedorEnvio de uma mensagem com um temporizador

final Map<String, MessageAttributeValue> messageAttributes = new HashMap<>();messageAttributes.put("ApplicationIcon", new MessageAttributeValue() .withDataType("Binary.JPEG") .withBinaryValue(ByteBuffer.wrap(new byte[10])));

3. Substitua a seção do código que envia a mensagem pelo seguinte:

// Send a message with an attributefinal SendMessageRequest sendMessageRequest = new SendMessageRequest();sendMessageRequest.withMessageBody("This is my message text.");sendMessageRequest.withQueueUrl(myQueueUrl);sendMessageRequest.withMessageAttributes(messageAttributes);sqs.sendMessage(sendMessageRequest);

Important

Se você enviar uma mensagem a uma fila FIFO, verifique se o método sendMessage éexecutado depois que você fornecer o ID do grupo de mensagens.Se usar a ação SendMessageBatch, em vez de SendMessage, você deverá especificar osatributos da mensagem de cada mensagem individual no lote.




mensagem corretamente (para obter mais informações, consulte RFC1321).• Um resumo do MD5 dos atributos de mensagens, usado para confirmar se o Amazon SQS recebeu

os atributos da mensagem corretamente.• O ID de solicitação que Amazon SQS atribuiu à sua solicitação.

Tutorial: Envio de uma mensagem com umtemporizador a uma fila do Amazon SQSOs temporizadores de mensagem permitem que você especifique um período de invisibilidade inicial deuma mensagem adicionada à uma fila. Por exemplo, se você enviar uma mensagem com um temporizadorde 45 segundos, a mensagem não fica visível aos consumidores pelos primeiros 45 segundos na fila. Opadrão é 0 segundos. Neste tutorial, você aprenderá como enviar uma mensagem com um temporizadora uma fila existente. Para obter mais informações, consulte Temporizadores de mensagem do AmazonSQS (p. 92).

Note

As filas FIFO não são compatíveis com temporizadores em mensagens individuais.

Para obter uma explicação mais detalhada de como enviar mensagens a filas padrão e FIFO, consulteEnvio de uma mensagem a uma fila (p. 28).


36




Amazon Simple Queue Service Guia do desenvolvedorEnvio de uma mensagem com um temporizador




4. Para enviar uma mensagem a uma fila padrão, insira o Message Body (Corpo da mensagem), escolhaDelay delivery of this message by (Atrasar a entrega desta mensagem por) e digite um valor, porexemplo, 60 segundos.

5. Escolha Send Message.


37


Amazon Simple Queue Service Guia do desenvolvedorRecebimento e exclusão de uma mensagem

6. Escolha Fechar.


Para enviar uma mensagem com um temporizador a uma fila

1. Copie o programa de exemplo da fila padrão (p. 70).2. Altere a assinatura do método main para o seguinte:

public static void main(String[] args) throws InterruptedException

3. Substitua a seção do código que envia a mensagem pelo seguinte:

// Send a message with a 5-second timer.System.out.println("Sending a message with a 5-second timer to MyQueue.\n");SendMessageRequest request = new SendMessageRequest(myQueueUrl, "This is my message text.");request.setDelaySeconds(5);sqs.sendMessage(request);

// Wait for 10 seconds.System.out.println("Waiting for 10 seconds.");Thread.sleep(10000L);




mensagem corretamente (para obter mais informações, consulte RFC1321).• O ID de solicitação que Amazon SQS atribuiu à sua solicitação.

Tutorial: Recebimento e exclusão de umamensagem de uma fila do Amazon SQS

Após enviar uma mensagem em uma fila, você pode consumi-la da fila. Ao solicitar uma mensagem deuma fila, você não pode especificar qual mensagem obter. Em vez disso, você especifica o número demensagens máximo (até 10) que deseja obter.

38




Note

Como o Amazon SQS é um sistema distribuído, uma fila com muito poucas mensagens podemexibir uma resposta vazia a uma solicitação de recepção. Nesse caso, você pode executarnovamente a solicitação para receber sua mensagem. Dependendo das necessidades da suaaplicação, você pode ter que usar brevemente sondagem (p. 85) curta ou longa para recebermensagens.

O Amazon SQS não exclui uma mensagem automaticamente após recebê-la para você, caso não receba amensagem com êxito (por exemplo, os consumidores podem falhar ou perder conectividade). Para excluiruma mensagem, você deverá enviar uma solicitação separada que reconheça que você não precisa maisda mensagem porque recebeu e processou com êxito.

Neste tutorial, você saberá como receber e excluir uma mensagem.



3. Em Ações da fila, selecione Exibir/Excluir mensagens.

É exibido Exibir/excluir mensagens na caixa de diálogo QueueName.

Note

Na primeira vez que você realizar essa ação, será exibida uma tela de informações. Paraocultar a tela, marque a caixa de seleção Não mostrar isso novamente.

4. Selecione Iniciar seleção de mensagens.

39



O Amazon SQS começa a consultar as mensagens na fila. A caixa de diálogo exibe uma mensagemda fila. Um barra de andamento na parte inferior da caixa de diálogo exibe o status do tempo-limite devisibilidade da mensagem.

O exemplo a seguir mostra as colunas ID do grupo de mensagens, ID de desduplicação demensagens e Número de sequência específicas das filas FIFO.

5. Antes de o tempo limite de visibilidade expirar, selecione a mensagem que você deseja excluir eescolha Excluir 1 mensagem.

A caixa de diálogo Excluir mensagens será exibida.

40

Amazon Simple Queue Service Guia do desenvolvedorAWS SDK for Java

6. Confirme se a mensagem que você deseja excluir está marcada e escolha Sim, excluir mensagensmarcadas.

A mensagem selecionada é excluída.

Quando a barra de andamento estiver preenchida, o tempo limite de visibilidade (p. 89) vai expirare a mensagem ficará visível para consumidores.

7. Selecione Fechar.

AWS SDK for JavaPara especificar a mensagem para excluir, forneça o identificador de recebimento (p. 80) que o AmazonSQS apresentou ao receber a mensagem. Você pode excluir somente uma mensagem por ação. Paraexcluir uma fila inteira, você deve usar a ação DeleteQueue. (Você pode excluir uma fila inteira mesmose a fila tiver mensagens.)

Note

Se você não tiver o identificador de recebimento da mensagem, você pode chamar a açãoReceiveMessage para receber novamente a mensagem. Sempre que receber a mensagem,você obtém um identificador de recebimento diferente. Use o identificador de recebimento maisrecente ao usar a ação DeleteMessage. Caso contrário, sua mensagem não pode ser excluídada fila.

Antes de você começar a trabalhar com o código de exemplo, especifique suas credenciais da AWS. Paramais informações, consulte Configurar credenciais e a região da AWS para desenvolvimento em AWSSDK for Java Developer Guide.

Para receber e excluir uma mensagem de uma fila padrão1. Copie o programa de exemplo (p. 70).

A seção do código a seguir recebe uma mensagem da sua fila:

// Receive messagesSystem.out.println("Receiving messages from MyQueue.\n");final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl);final List<Message> messages = sqs.receiveMessage(receiveMessageRequest).getMessages();for (final Message message : messages) { System.out.println("Message"); System.out.println(" MessageId: " + message.getMessageId()); System.out.println(" ReceiptHandle: " + message.getReceiptHandle()); System.out.println(" MD5OfBody: " + message.getMD5OfBody()); System.out.println(" Body: " + message.getBody()); for (final Entry<String, String> entry : message.getAttributes().entrySet()) { System.out.println("Attribute"); System.out.println(" Name: " + entry.getKey()); System.out.println(" Value: " + entry.getValue()); }

41



}System.out.println();

A seção do código a seguir exclui a mensagem:

// Delete the messageSystem.out.println("Deleting a message.\n");final String messageReceiptHandle = messages.get(0).getReceiptHandle();sqs.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle));


A fila é votada e apresenta 0 ou mais mensagens. O exemplo imprime os seguintes itens:

• O ID de mensagem (p. 80) que você recebeu quando você enviou a mensagem para a fila.• O identificador de recebimento (p. 80) que você usará depois para excluir a mensagem.• Um resumo MD5 do corpo da mensagem (para obter mais informações, consulte RFC1321).• O corpo da mensagem.• O ID de solicitação que Amazon SQS atribuiu à sua solicitação

Se não houver mensagens recebidas nesta chamada específica, a resposta incluirá somente o ID desolicitação.

A mensagem é excluída. A resposta inclui a ID da solicitação que o Amazon SQS atribuiu à suasolicitação.

Para receber e excluir uma mensagem de uma fila FIFO1. Copie o programa de exemplo (p. 77).

A seção do código a seguir recebe uma mensagem da sua fila:

// Receive messagesSystem.out.println("Receiving messages from MyFifoQueue.fifo.\n");final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl);

// Uncomment the following to provide the ReceiveRequestDeduplicationId//receiveMessageRequest.setReceiveRequestAttemptId("1");final List<Message> messages = sqs.receiveMessage(receiveMessageRequest).getMessages();for (final Message message : messages) { System.out.println("Message"); System.out.println(" MessageId: " + message.getMessageId()); System.out.println(" ReceiptHandle: " + message.getReceiptHandle()); System.out.println(" MD5OfBody: " + message.getMD5OfBody()); System.out.println(" Body: " + message.getBody()); for (final Entry<String, String> entry : message.getAttributes().entrySet()) { System.out.println("Attribute"); System.out.println(" Name: " + entry.getKey()); System.out.println(" Value: " + entry.getValue()); }}System.out.println();

A seção do código a seguir exclui a mensagem:

// Delete the message

42


Amazon Simple Queue Service Guia do desenvolvedorInscrição de uma fila em um tópico

System.out.println("Deleting the message.\n");final String messageReceiptHandle = messages.get(0).getReceiptHandle();sqs.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle));


A mensagem é recebida e excluída.

Tutorial: Inscrição de uma fila do Amazon SQS emum tópico do Amazon SNS

Você pode inscrever uma ou mais filas do Amazon SQS em um tópico do Amazon SNS a partir de umalista de tópicos disponíveis para a fila selecionada. O Amazon SQS gerencia a assinatura e todas aspermissões necessárias. Quando você publica uma mensagem em um tópico, o Amazon SNS envia amensagem para cada fila inscrita. Para obter mais informações sobre o Amazon SNS, consulte O que é oAmazon Simple Notification Service? no Guia do desenvolvedor do Amazon Simple Notification Service.

Important

Amazon SNS não é atualmente compatível com filas FIFO.Para obter informações sobre como usar o Amazon SNS com filas criptografadas do AmazonSQS, consulte Habilitar a compatibilidade entre os serviços da AWS e as filas com (p. 173).Quando você inscreve uma fila do Amazon SQS em um tópico do Amazon SNS, o Amazon SNSusa HTTPS para encaminhar mensagens para o Amazon SQS.

Neste tutorial, você aprenderá como inscrever uma fila existente do Amazon SQS em um tópico existentedo Amazon SNS.

Console de gerenciamento da AWS1. Faça login no console do Amazon SQS.2. Na lista de filas, selecione a fila (ou filas) que você deseja inscrever em um tópico do Amazon SNS.

3. Em Queue Actions, selecione Subscribe Queue to SNS Topic (ou Subscribe Queues to SNS Topic).

A caixa de diálogo Subscribe to a Topic é exibida.4. Na lista suspensa Choose a Topic (Escolher um tópico), selecione um tópico do Amazon SNS no qual

você deseja inscrever a fila (ou filas), selecione a Topic Region (Região do tópico) (opcional) e, emseguida, escolha Subscribe (Inscrever).

43

welcome.html

welcome.html



Note

Digitar um Topic ARN (ARN de tópico) diferente é útil quando você deseja inscrever uma filaem um tópico do Amazon SNS a partir de uma outra conta da AWS, diferente daquela usadapara criar sua fila do Amazon SQS.Isso também será útil se o tópico do Amazon SNS não estiver na lista suspensa Choose aTopic (Escolher um tópico).

A caixa de diálogo Topic Subscription Result é exibida.5. Analise a lista de filas do Amazon SQS que estão inscritas no tópico do Amazon SNS e escolha OK.

A fila está inscrito no tópico.

Note

Se a fila do Amazon SQS e um tópico do Amazon SNS estiverem em contas da AWSdiferentes, o proprietário do tópico deverá confirmar primeiramente a assinatura. Para obtermais informações, consulte Confirm the Subscription no Guia do desenvolvedor do AmazonSimple Notification Service.Para listar suas assinaturas, cancelar a inscrição em tópicos e excluir tópicos, use o consoledo Amazon SNS. Para obter mais informações, consulte Limpeza.

Para verificar o resultado da assinatura, você pode publicar no tópico e, em seguida, visualizar amensagem que o tópico envia para a fila. Para obter mais informações, consulte Envio de mensagensdo Amazon SNS para filas do Amazon SQS no Guia do desenvolvedor do Amazon Simple NotificationService.

44

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToHttp.html#SendMessageToHttp.confirm

CleanUp.html

SendMessageToSQS.html

SendMessageToSQS.html

Amazon Simple Queue Service Guia do desenvolvedorConfiguração de um trigger do Lambda

Tutorial: Configuração de mensagens que chegamem uma fila do Amazon SQS para acionar umafunção do AWS Lambda

Neste tutorial, você aprenderá como configurar uma fila existente do Amazon SQS para acionar umafunção do AWS Lambda quando novas mensagens chegarem em uma fila.

As funções do Lambda permitem que você execute código sem provisionar nem gerenciar um servidor. Porexemplo, você pode configurar uma função do Lambda para processar mensagens de uma fila, enquantooutra fila funciona como uma dead letter queue para mensagens que sua função do Lambda não podeprocessar com êxito. Ao resolver o problema, você pode redirecionar as mensagens da dead letter queuepor meio da função do Lambda. Para obter mais informações, consulte Dead-Letter Queues do AmazonSQS (p. 86) e também O que é o AWS Lambda? e Uso do AWS Lambda com Amazon SQS no AWSLambda Developer Guide.

Note

A fila e a função Lambda devem estar na mesma região da AWS.As filas FIFO não são compatíveis com triggers de função Lambda.Você pode associar somente uma fila a uma ou mais funções Lambda.Não é possível associar uma fila criptografada (p. 167) que usa uma chave mestre de clientegerenciada pela AWS para o Amazon SQS a uma função Lambda em outra conta da AWS.

Pré-requisitosPara configurar triggers de função do Lambda usando o console, você deve verificar o seguinte:

• Sua função do Amazon SQS deve incluir as seguintes permissões:• lambda:CreateEventSourceMapping

• lambda:ListEventSourceMappings

• lambda:ListFunction

• Sua função do Lambda deve incluir as seguintes permissões:• sqs:ChangeMessageVisibility

• sqs:DeleteMessage

• sqs:GetQueueAttributes

• sqs:ReceiveMessage

Para obter mais informações, consulte Visão geral do gerenciamento de permissões de acesso a seusrecursos do Amazon Simple Queue Service (p. 142).

Console de gerenciamento da AWS1. Faça login no console do Amazon SQS.2. Na lista de filas, selecione a fila a qual você deseja que acione uma função do Lambda.

3. Em Queue Actions (Ações de fila), selecione Configure Trigger for Function (Configurar trigger parafunção do Lambda)

45

welcome.html

with-sqs.html



4. Na caixa de diálogo Configure Incoming Messages to Trigger a Lambda Function (Configurarmensagens de entrada para acionar uma função do Lambda), execute uma das seguintes ações:

• Para usar uma função do Lambda existente, Select a Lambda Function (Selecionar uma função doLambda) na lista.

• Para criar uma nova função do Lambda no console do AWS Lambda, selecione Create New (Criarnova). Para obter mais informações, consulte Criar uma função simples do Lambda no AWSLambda Developer Guide.

5. Escolha Salvar.6. Na caixa de diálogo Lambda Function Trigger Configuration Result (Resultado da configuração de

trigger da função do Lambda), verifique a função do Lambda que será acionada pela fila do AmazonSQS e selecione OK.

Note

Demora aproximadamente 1 minuto para a função do Lambda se tornar associada à sua fila.

A função do Lambda e seu status são exibidos na guia Lambda Triggers (Triggers do Lambda).

46

get-started-create-function.html

Amazon Simple Queue Service Guia do desenvolvedorComo limpar uma fila

• Para verificar os resultados da configuração, você pode enviar uma mensagem à fila (p. 28) e,em seguida, visualizar a função do Lambda acionada no console do Lambda.

• Para excluir a associação entre uma função do Lambda e sua fila, escolha ao lado do ARN deuma função do Lambda.

Tutorial: Limpeza de mensagens de uma fila doAmazon SQS

Se não quiser excluir uma fila do Amazon SQS, mas precisar excluir todas as mensagens dela, vocêpoderá limpar a fila. Neste tutorial, você saberá como limpar uma fila.

Important

Quando você limpar uma fila, não poderá recuperar quaisquer mensagens excluídas a partir dela.O processo de exclusão de mensagens pode levar até 60 segundos. Recomendamos aguardar 60segundos, qualquer que seja o tamanho da fila.


3. Em Queue Actions, selecione Purge Queue.

A caixa de diálogo Purge Queues será exibida.

4. Escolha Yes, Purge Queue.

Todas as mensagens são removidas da fila.

47


Amazon Simple Queue Service Guia do desenvolvedorExclusão de uma fila

A caixa de diálogo de confirmação Purge Queues será exibida.

5. Escolha OK.

Tutorial: Exclusão de uma fila do Amazon SQSSe você não usar a fila Amazon SQS (e não prever usar no futuro próximo), é uma prática recomendadaexcluí-la do Amazon SQS. Neste tutorial, você saberá como excluir uma fila.

Note

Você pode excluir uma fila, mesmo quando ela não estiver vazia. Para excluir as mensagens emuma fila, mas não a própria fila, você pode limpar a fila (p. 47).Por padrão, uma fila retém uma mensagem por quatro dias depois que ela é enviada. Você podeconfigurar uma fila para reter as mensagens por até 14 dias.



3. Em Ações da fila, selecione Excluir fila.

A caixa de diálogo Excluir filas será exibida.

48



4. Escolha Sim, excluir fila.



Note

Essa ação é idêntica para filas padrão e FIFO.


A seção do código a seguir exclui a fila:

// Delete the queueSystem.out.println("Deleting the test queue.\n");sqs.deleteQueue(new DeleteQueueRequest(myQueueUrl));



Tutoriais: Configuração de filas do Amazon SQSOs tutoriais a seguir mostram como configurar filas do Amazon SQS de várias maneiras.

Tópicos• Tutorial: Configuração da Criptografia do lado do servidor (SSE) para uma fila existente do Amazon

SQS (p. 50)• Tutorial: Configuração da sondagem longa para uma fila do Amazon SQS (p. 53)• Tutorial: Configuração de uma dead letter queue do Amazon SQS (p. 56)• Tutorial: Configuração do tempo limite de visibilidade para uma fila do Amazon SQS (p. 60)• Tutorial: Configuração de uma fila de atraso do Amazon SQS (p. 63)

49


Amazon Simple Queue Service Guia do desenvolvedorConfiguração da SSE para uma fila

Tutorial: Configuração da Criptografia do lado doservidor (SSE) para uma fila existente do AmazonSQSCriptografia do lado do servidor (SSE) de Amazon SQS está disponível em todas as regiões comerciaisonde Amazon SQS está disponível, exceto por Regiões da China. Você pode habilitar a SSE para uma filapara proteger seus dados. Para obter mais informações sobre o uso de SSE, consulte Proteção de dadosusando criptografia no lado do servidor (SSE) e AWS KMS (p. 167).

Important

Todas as solicitações para filas com SSE ativado devem usar HTTPS e Signature versão 4.Quando você desabilita a SSE, as mensagens permanecem criptografadas. Você deve receber edescriptografar uma mensagem para visualizar seu conteúdo.

Neste tutorial, você saberá como habilitar, desabilitar e configurar a SSE para uma fila existente doAmazon SQS.



3. Em Queue Actions, selecione Configure Queue.

A caixa de diálogo Configure QueueName é exibida.4. Para habilitar ou desabilitar a SSE, use a caixa de seleção Use SSE (Usar SSE).5. Especifique o ID da chave mestra do cliente (CMK). Para obter mais informações, consulte Termos-

chave (p. 169).

Para cada tipo de CMK, a Descrição, a Conta e a Chave do ARN da CMK são exibidas.Important

Se você não for o proprietário da CMK ou se fizer login com uma conta que não tenhapermissões kms:ListAliases e kms:DescribeKey, não será possível visualizar asinformações sobre a CMK no console do Amazon SQS.

50




Peça ao proprietário da CMK para conceder essas permissões a você. Para obter maisinformações, consulte Permissões de API do AWS KMS: referência a ações e recursos noAWS Key Management Service Developer Guide.

• Para usar a CMK gerenciada pela AWS para o Amazon SQS, selecione-a na lista.

Note


gerenciada pela AWS para o Amazon SQS. Para obter instruções sobre como criarCMKs personalizadas, consulte Criação de chaves no AWS Key Management ServiceDeveloper Guide.

• A primeira vez que você usar o Console de gerenciamento da AWS para especificar aCMK gerenciada pela AWS para o Amazon SQS para uma fila, o AWS KMS criará aCMK gerenciada pela AWS para o Amazon SQS.


• Para usar uma CMK personalizada de sua conta da AWS, selecione-a na lista.

Note

Para obter instruções sobre como criar CMKs personalizadas, consulte Criação de chavesno AWS Key Management Service Developer Guide.

• Para usar um ARN da CMK personalizada de sua conta da AWS ou de outra conta da AWS,selecione Inserir um ARN da CMK existente na lista e digite ou copie a CMK.

6. (Opcional) Para o Período de reutilização da chave de dados, especifique um valor entre 1 minutoe 24 horas. O padrão é 5 minutos. Para obter mais informações, consulte Como o período dereutilização de chaves de dados funciona? (p. 170).

7. Escolha Save Changes (Salvar alterações).

Suas alterações são aplicadas à fila.


51

https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html





Antes que possa usar a SSE, você deve configurar as políticas de chaves do AWS KMS para permitira criptografia de filas e a criptografia e a descriptografia de mensagens. Você também deve garantirque as políticas de chave da chave mestra do cliente (CMK) forneçam as permissões necessárias. Paraobter mais informações, consulte De quais permissões do AWS KMS eu preciso para usar a SSE para oAmazon SQS? (p. 171)

1. Obtenha o ID da chave mestra do cliente (CMK). Para obter mais informações, consulte Termos-chave (p. 169).

Note

Mantenha o seguinte em mente:

• Se você não especificar uma CMK personalizada, o Amazon SQS usará a CMKgerenciada pela AWS para o Amazon SQS. Para obter instruções sobre como criar CMKspersonalizadas, consulte Criação de chaves no AWS Key Management Service DeveloperGuide.



2. Para habilitar a criptografia do lado do servidor, especifique o ID da CMK configurando o atributoKmsMasterKeyId da ação CreateQueue ou SetQueueAttributes.

O código de exemplo a seguir habilita a SSE para uma fila existente usando a CMK gerenciada pelaAWS para o Amazon SQS:

final SetQueueAttributesRequest setAttributesRequest = new SetQueueAttributesRequest();setAttributesRequest.setQueueUrl(queueUrl); // Enable criptografia do lado do servidor by specifying the alias ARN of the// AWS managed CMK for Amazon SQS.final String kmsMasterKeyAlias = "arn:aws:kms:us-east-2:123456789012:alias/aws/sqs";attributes.put("KmsMasterKeyId", kmsMasterKeyAlias); final SetQueueAttributesResult setAttributesResult = client.setQueueAttributes(setAttributesRequest);

Para desabilitar a criptografia do lado do servidor para uma fila existente, defina o atributoKmsMasterKeyId como uma string vazia usando a ação SetQueueAttributes.

Important

null não é um valor válido para KmsMasterKeyId.3. (Opcional) Especifique o tempo, em segundos, durante o qual o Amazon SQS pode reutilizar uma

chave de dados (p. 169) para criptografar ou descriptografar as mensagens antes de chamaro AWS KMS. Defina o atributo KmsDataKeyReusePeriodSeconds da ação CreateQueue ouSetQueueAttributes. Os valores possíveis podem estar entre 60 segundos (1 minuto) e 86.400segundos (24 horas). Se você não especificar um valor, o valor padrão de 300 segundos (5 minutos)será usado.

O exemplo de código a seguir define o período de reutilização de chaves de dados como 60 segundos(1 minuto):

// (Optional) Specify the length of time, in seconds, for which Amazon SQS can reuse // a data key to encrypt or decrypt messages before calling AWS KMS again.

52






Amazon Simple Queue Service Guia do desenvolvedorConfiguração de sondagem longa para uma fila

attributes.put("KmsDataKeyReusePeriodSeconds", "60");

Para obter informações sobre a recuperação de atributos de uma fila, consulte Exemplos no AmazonSimple Queue Service API Reference.

Para recuperar o ID da CMK ou o período de reutilização da chave de dados para uma fila específica, useos atributos KmsMasterKeyId e KmsDataKeyReusePeriodSeconds da ação GetQueueAttributes.

Para obter informações sobre a alternância de uma fila para uma CMK diferente com o mesmo alias,consulte Atualização de um alias no AWS Key Management Service Developer Guide.

Tutorial: Configuração da sondagem longa para umafila do Amazon SQSA sondagem longa ajuda a reduzir os custos de uso do Amazon SQS eliminando a quantidade derespostas vazias (quando não há mensagens disponíveis para uma solicitação ReceiveMessage) erespostas vazias falsas (quando mensagens estão disponíveis, mas não são incluídas em uma resposta).Neste tutorial, você saberá como configurar a sondagem longa para uma fila do Amazon SQS. Para obtermais informações, consulte Sondagem longa do Amazon SQS (p. 85).



Note


4. Padrão é selecionado por padrão. Escolha FIFO.5. Selecione Configure Queue.6. Em Receive Message Wait Time (Tempo de espera de mensagem de recebimento), digite um número

entre 1 e 20.

Note

Definir o valor como 0 configura a sondagem breve. Para obter mais informações, consulteDiferenças entre sondagens longa e curta (p. 85).


Sua nova fila é configurada para usar uma sondagem longa criada e selecionada na lista de filas.

Note


53

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html#API_GetQueueAttributes_Examples

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueAttributes.html

https://docs.aws.amazon.com/kms/latest/developerguide/programming-aliases.html#update-alias

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html




Para configurar a sondagem longa para uma fila

Pré-requisitos

Adicione o pacote aws-java-sdk-sqs.jar ao caminho da classe Java. O exemplo a seguir mostra essadependência em um arquivo pom.xml do projeto Maven.

<dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-sqs</artifactId> <version><replaceable>LATEST</replaceable></version> </dependency></dependencies>

SQSLongPollingExample.java

O exemplo de código Java a seguir cria uma fila padrão e configura a sondagem longa para ela.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */ import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.CreateQueueRequest;import com.amazonaws.services.sqs.model.QueueAttributeName;

import java.util.Scanner;

public class SQSLongPollingExample { public static void main(String[] args) {

final Scanner input = new Scanner(System.in);

System.out.print("Enter the queue name: "); final String queueName = input.nextLine();

System.out.print("Enter the ReceiveMessage wait time (1-20 seconds): "); final String receiveMessageWaitTime = input.nextLine();

/*

54



* Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

try { // Create a queue with long polling. final CreateQueueRequest createQueueRequest = new CreateQueueRequest() .withQueueName(queueName) .addAttributesEntry(QueueAttributeName.ReceiveMessageWaitTimeSeconds .toString(), receiveMessageWaitTime); sqs.createQueue(createQueueRequest);

System.out.println("Created queue " + queueName + " with " + "ReceiveMessage wait time set to " + receiveMessageWaitTime + " seconds.");

} catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } }}

Para configurar a sondagem longa para uma fila e enviar, receber e excluir umamensagem

1. Copie o programa de exemplo para uma fila padrão (p. 70)ou para uma fila FIFO (p. 77).2. Recupere a URL da fila:

final String queueUrl = sqs.getQueueUrl(queueName).getQueueUrl();

3. Use a ação SetQueueAttributesRequest para configurar a sondagem longa para uma filaexistente:

final SetQueueAttributesRequest setQueueAttributesRequest = new SetQueueAttributesRequest() .withQueueUrl(queueUrl) .addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");sqs.setQueueAttributes(setQueueAttributesRequest);

4. Use a ação ReceiveMessageRequest para configurar a sondagem longa para um recebimento demensagem:

final ReceiveMessageRequest receive_request = new ReceiveMessageRequest() .withQueueUrl(queueUrl) .withWaitTimeSeconds(20);sqs.receiveMessage(receive_request);

55

Amazon Simple Queue Service Guia do desenvolvedorConfiguração de uma dead letter queue


A sondagem longa para a fila é configurada, e a mensagem é enviada, recebida e excluída.

Tutorial: Configuração de uma dead letter queue doAmazon SQSUma dead letter queue é uma fila para a qual outras filas (origem) podem enviar mensagens que nãopodem ser processadas (consumidas) com êxito. Neste tutorial, você saberá como criar uma fila de origemdo Amazon SQS e como configurar uma segunda fila como uma dead letter queue para ela. Para obtermais informações, consulte Dead-Letter Queues do Amazon SQS (p. 86).

Important

Este tutorial pressupõe que você já tem uma fila FIFO normal denominadaMyDeadLetterQueue.fifo.A dead letter queue de uma fila FIFO também deve ser uma fila FIFO. Da mesma forma, a deadletter queue de uma fila padrão também deve ser uma fila padrão.



Note


4. Padrão é selecionado por padrão. Escolha FIFO.5. Selecione Configure Queue.6. Neste exemplo, você ativa a política de redirecionamento para a sua nova fila, define a fila

MyDeadLetterQueue.fifo como a dead letter queue e define o número máximo de recebimentoscomo 50.

56



Para configurar a dead letter queue, escolha Use Redrive Policy.

Insira o nome da Dead Letter Queue existente para onde as filas de origem enviarão as mensagens.

Para configurar o número de vezes que uma mensagem pode ser recebida antes de ser enviada auma dead letter queue, defina Maximum Receives como um valor entre 1 e 1.000.

Note

A configuração de Maximum Receives aplica-se somente a mensagens individuais.

Escolha Create Queue.

Sua nova fila é configurada para usar uma dead letter queue é criada e selecionada na lista de filas.Note


O nome de recurso da Amazon (ARN) de Maximum Receives e Dead Letter Queue da fila é exibido naguia Redrive Policy.


Para configurar uma dead letter queuePré-requisitos


<dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-sqs</artifactId>

57



<version><replaceable>LATEST</replaceable></version> </dependency></dependencies>

SQSDeadLetterQueueExample.java

O exemplo de código Java a seguir cria duas filas padrão e configura uma fila para atuar como uma fila deorigem para a outra fila — uma dead letter queue.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */

import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.GetQueueAttributesRequest;import com.amazonaws.services.sqs.model.GetQueueAttributesResult;import com.amazonaws.services.sqs.model.QueueAttributeName;import com.amazonaws.services.sqs.model.SetQueueAttributesRequest;

import java.util.Scanner;

public class SQSDeadLetterQueueExample { public static void main(String[] args) {


System.out.print("Enter the source queue name: "); final String sourceQueueName = input.nextLine();

System.out.print("Enter the dead-letter queue name: "); final String deadLetterQueueName = input.nextLine();

/* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

try { // Create a source queue. sqs.createQueue(sourceQueueName);

// Create a dead-letter queue. sqs.createQueue(deadLetterQueueName);

// Get the dead-letter queue ARN. final String deadLetterQueueUrl = sqs.getQueueUrl(deadLetterQueueName) .getQueueUrl();

58


final GetQueueAttributesResult deadLetterQueueAttributes = sqs.getQueueAttributes( new GetQueueAttributesRequest(deadLetterQueueUrl) .withAttributeNames("QueueArn")); final String deadLetterQueueArn = deadLetterQueueAttributes.getAttributes().get("QueueArn");

// Set the dead letter queue for the source queue using the redrive policy. final String sourceQueueUrl = sqs.getQueueUrl(sourceQueueName) .getQueueUrl(); final SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(sourceQueueUrl) .addAttributesEntry(QueueAttributeName.RedrivePolicy.toString(), "{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\"" + deadLetterQueueArn + "\"}"); sqs.setQueueAttributes(request);

System.out.println("Set queue " + sourceQueueName + " as source queue " + "for dead-letter queue " + deadLetterQueueName + ".");

} catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } }}

Para configurar a dead letter queue e enviar, receber e excluir uma mensagem

1. Copie o programa de exemplo para uma fila padrão (p. 70)ou para uma fila FIFO (p. 77).2. Defina uma string que contenha os parâmetros formatados por JSON e valores para o atributo da fila

RedrivePolicy:

final String redrivePolicy = "{\"maxReceiveCount\":\"5\", \"deadLetterTargetArn\":\"arn:aws:sqs:us-east-2:123456789012:MyDeadLetterQueue\"}";

3. Use a ação CreateQueue ou SetQueueAttributesRequest para configurar o atributo de filaRedrivePolicy:

final SetQueueAttributesRequest queueAttributes = new SetQueueAttributesRequest();final Map<String,String> attributes = new HashMap<String,String>(); attributes.put("RedrivePolicy", redrivePolicy); queueAttributes.setAttributes(attributes);queueAttributes.setQueueUrl(myQueueUrl);sqs.setQueueAttributes(queueAttributes);


A dead letter queue é configurada, e a mensagem é enviada, recebida e excluída.

59

Amazon Simple Queue Service Guia do desenvolvedorConfiguração do tempo limite de visibilidade para uma fila

Tutorial: Configuração do tempo limite de visibilidadepara uma fila do Amazon SQSLogo após o recebimento de uma mensagem, ela permanece na fila. Para evitar que outros consumidoresprocessem a mensagem novamente, o Amazon SQS define um tempo limite de visibilidade, um períododurante o qual o Amazon SQS impede que outros consumidores recebam e processem a mensagem. Otempo limite de visibilidade padrão para uma mensagem é de 30 segundos. O máximo é 12 horas. Nestetutorial, você saberá como configurar o tempo limite de visibilidade para uma fila usando o Console degerenciamento da AWS e para uma única ou várias mensagens usando o AWS SDK for Java. Para obtermais informações, consulte Tempo limite de visibilidade do Amazon SQS (p. 89).

Note

Você pode usar o Console de gerenciamento da AWS para configurar o tempo limite devisibilidade apenas para filas, não para uma ou várias mensagens. Para fazer isso, você deveusar um dos SDKs da AWS. Para obter mais informações, consulte o segundo código de exemploJava a seguir.



Note


4. Padrão é selecionado por padrão. Escolha FIFO.5. Selecione Configure Queue.6. Neste exemplo, você define o tempo limite de visibilidade padrão como 1 minuto.


Sua nova fila é configurada para usar um tempo limite de visibilidade de 1 minuto, criada eselecionada na lista de filas.

Note


O Default Visibility Timeout (Tempo limite de visibilidade padrão) da fila é exibido na guia Details(Detalhes).

60




Para configurar o tempo limite de visibilidade para uma fila

Pré-requisitos



SQSVisibilityTimeoutExample.java

O exemplo de código Java a seguir cria uma fila padrão e define o tempo limite de visibilidade dela como 1minuto.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */ import com.amazonaws.AmazonClientException; import com.amazonaws.AmazonServiceException; import com.amazonaws.services.sqs.AmazonSQS; import com.amazonaws.services.sqs.AmazonSQSClientBuilder; import com.amazonaws.services.sqs.model.CreateQueueRequest; import com.amazonaws.services.sqs.model.QueueAttributeName; import com.amazonaws.services.sqs.model.SetQueueAttributesRequest; import java.util.Scanner; public class SQSVisibilityTimeoutExample { public static void main(String[] args) { final Scanner input = new Scanner(System.in); System.out.print("Enter the queue name: "); final String queueName = input.nextLine(); System.out.print("Enter the visibility timeout in seconds " + "(0 seconds to 12 hours): ");

61



final String visibilityTimeout = input.nextLine(); /* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient(); try { // Create a queue. final CreateQueueRequest createQueueRequest = new CreateQueueRequest() .withQueueName(queueName); sqs.createQueue(createQueueRequest); // Set the visibility timeout for the queue. final String queueUrl = sqs.getQueueUrl(queueName) .getQueueUrl(); final SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(queueUrl) .addAttributesEntry(QueueAttributeName.VisibilityTimeout .toString(), visibilityTimeout); sqs.setQueueAttributes(request); System.out.println("Created queue " + queueName + " with " + "visibility timeout set to " + visibilityTimeout + " seconds."); } catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } } }

Para configurar o tempo limite de visibilidade para uma única mensagem ou paravárias mensagens e enviar, receber e excluir mensagens

1. Copie o programa de exemplo para uma fila padrão (p. 70)ou para uma fila FIFO (p. 77).2. Para configurar o tempo limite de visibilidade para uma única mensagem, passar a URL da fila, o

identificador de recebimento da mensagem e o valor de tempo limite de visibilidade em segundos.

// Get the message receipt handle. String receiptHandle = sqs.receiveMessage(myQueueUrl) .getMessages() .get(0) .getReceiptHandle(); // Pass the queue URL, the message receipt handle, and the visibility timeout value. sqs.changeMessageVisibility(myQueueUrl, receiptHandle, timeoutValue);

62

Amazon Simple Queue Service Guia do desenvolvedorConfiguração de uma fila de atraso do Amazon SQS

3. Para configurar o tempo limite de visibilidade para várias mensagens (por exemplo, se você desejardefinir valores de tempo limite diferentes para diferentes mensagens), crie uma ArrayList, adicionemensagens a ela com o valor de tempo limite de visibilidade em segundos e, em seguida, passe aURL da fila e a ArrayList de mensagens.

// Create an ArrayList for batched messages. List<ChangeMessageVisibilityBatchRequestEntry> entries = new ArrayList<ChangeMessageVisibilityBatchRequestEntry>(); // Add the first message to the ArrayList with a visibility timeout value. entries.add(new ChangeMessageVisibilityBatchRequestEntry( "uniqueMessageId123", sqs.receiveMessage(myQueueUrl) .getMessages() .get(0) .getReceiptHandle()) .withVisibilityTimeout(timeoutValue)); // Add the second message to the ArrayList with a different timeout value. entries.add(new ChangeMessageVisibilityBatchRequestEntry( "uniqueMessageId456", sqs.receiveMessage(myQueueUrl) .getMessages() .get(0) .getReceiptHandle()) .withVisibilityTimeout(timeoutValue + 60)); sqs.changeMessageVisibilityBatch(myQueueUrl, entries);


O tempo limite de visibilidade para uma única mensagem ou para várias mensagens é configurado, ea mensagem é enviada, recebida e excluída.

Tutorial: Configuração de uma fila de atraso doAmazon SQSAs filas de atraso permitem adiar a entrega de novas mensagens para uma fila por alguns segundos. Sevocê criar uma fila de atraso, quaisquer mensagens enviadas para essa fila permanecem invisíveis paraos consumidores durante o período de atraso. The minimum delay for a queue is 0 seconds. The maximumis 15 minutes. Neste tutorial, você aprenderá como configurar uma fila de atraso usando o Console degerenciamento da AWS ou o AWS SDK for Java. Para obter mais informações, consulte Filas de atraso doAmazon SQS (p. 91).

Tópicos• Console de gerenciamento da AWS (p. 63)• AWS SDK for Java (p. 64)• Para configurar uma fila de atraso e enviar, receber e excluir mensagens (p. 66)


63



Note


4. Padrão é selecionado por padrão. Escolha FIFO.5. Selecione Configure Queue.6. Neste exemplo, você define o atraso de entrega como 1 minuto.


Sua nova fila é configurada para usar um atraso de 1 minuto, criada e selecionada na lista de filas.Note


O Delivery Delay (Atraso de Entrega) da fila é exibido na guia Details (Detalhes).


Para configurar uma fila de atraso

Pré-requisitos



SQSDelayQueueExample.java

O exemplo de código Java a seguir cria uma fila padrão e define o atraso dela como 1 minuto.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed

64



* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */ import com.amazonaws.AmazonClientException; import com.amazonaws.AmazonServiceException; import com.amazonaws.services.sqs.AmazonSQS; import com.amazonaws.services.sqs.AmazonSQSClientBuilder; import com.amazonaws.services.sqs.model.CreateQueueRequest; import com.amazonaws.services.sqs.model.QueueAttributeName; import com.amazonaws.services.sqs.model.SetQueueAttributesRequest; import java.util.Scanner; public class SQSDelayQueueExample { public static void main(String[] args) { final Scanner input = new Scanner(System.in); System.out.print("Enter the queue name: "); final String queueName = input.nextLine(); System.out.print("Enter the delay in seconds (0 seconds to 15 minutes): "); final String queueDelay = input.nextLine(); /* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient(); try { // Create a queue. final CreateQueueRequest createQueueRequest = new CreateQueueRequest() .withQueueName(queueName); sqs.createQueue(createQueueRequest); // Set the delay for the queue. final String queueUrl = sqs.getQueueUrl(queueName) .getQueueUrl(); final SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(queueUrl) .addAttributesEntry(QueueAttributeName.DelaySeconds .toString(), queueDelay); sqs.setQueueAttributes(request); System.out.println("Created queue " + queueName + " with " + "delay set to " + queueDelay + " seconds."); } catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network.");

65


System.out.println("Error Message: " + ace.getMessage()); } } }

Para configurar uma fila de atraso e enviar, receber e excluirmensagens1. Copie o programa de exemplo para uma fila padrão (p. 70)ou para uma fila FIFO (p. 77).2. Para configurar uma fila de atraso, transmita o valor de atraso em segundos.

// Set the delay for the queue. final String queueUrl = sqs.getQueueUrl(queueName).getQueueUrl(); final SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(queueUrl) .addAttributesEntry(QueueAttributeName.DelaySeconds.toString(), queueDelay); sqs.setQueueAttributes(request);


A fila de atraso é configurada, e a mensagem é enviada, recebida e excluída.

66

Amazon Simple Queue Service Guia do desenvolvedorArquitetura básica

Como Amazon SQS funcionaEsta seção descreve os tipos de filas do Amazon SQS e suas propriedades básicas. Descreve também osidentificadores de filas e mensagens e vários fluxos de trabalho de gerenciamento de filas e mensagens.

Tópicos• Arquitetura básica do Amazon SQS (p. 67)• Filas Padrão do Amazon SQS (p. 69)• Filas FIFO (ordem de chegada) do Amazon SQS (p. 72)• Identificadores de filas e mensagens do Amazon SQS (p. 79)• Atributos de mensagens do Amazon SQS (p. 81)• Recursos necessários para processar mensagens do Amazon SQS (p. 84)• Tags de alocação de custos do Amazon SQS (p. 84)• Sondagem longa do Amazon SQS (p. 85)• Dead-Letter Queues do Amazon SQS (p. 86)• Tempo limite de visibilidade do Amazon SQS (p. 89)• Filas de atraso do Amazon SQS (p. 91)• Temporizadores de mensagem do Amazon SQS (p. 92)• Gerenciamento de mensagens grandes do Amazon SQS usando o Amazon S3 (p. 92)• Como trabalhar com o JMS e o Amazon SQS (p. 96)

Arquitetura básica do Amazon SQSEsta seção descreve as partes de um sistema de mensagens distribuído e explica o ciclo de vida de umamensagem do Amazon SQS.

Filas distribuídasHá três partes principais em um sistema de mensagens distribuído: os componentes do sistemadistribuído, a fila (distribuída em servidores do Amazon SQS) e as mensagens na fila.

No cenário a seguir, o sistema tem vários componentes que enviam mensagens para a fila e recebemmensagens da fila. A fila (que contém as mensagens de A a E) armazena as mensagens de formaredundante em vários servidores do Amazon SQS.

67

Amazon Simple Queue Service Guia do desenvolvedorCiclo de vida de mensagens

Ciclo de vida de mensagensO cenário a seguir descreve o ciclo de vida de uma mensagem do Amazon SQS em uma fila, da criação àexclusão.

Um produtor (componente 1) envia a mensagem A para uma fila, e a mensagem é distribuída pelosservidores do Amazon SQS de forma redundante.

Quando um consumidor (componente 2) está pronto para processar mensagens, ele consume asmensagens da fila, e a mensagem A é devolvida. Enquanto a mensagem A está sendo processada, elapermanece na fila e não é devolvida para as solicitações de recebimento subsequentes durante todo otempo limite de visibilidade (p. 89).

O consumidor (componente 2) exclui a mensagem A da fila para impedir que a mensagem seja recebidae processada novamente quando o tempo limite de visibilidade for esgotado.

Note

O Amazon SQS exclui automaticamente as mensagens que estiverem em uma fila pormais tempo que o período de retenção máximo de mensagens. O período de retenção demensagens padrão é de quatro dias. No entanto, você pode configurar o período de retençãode mensagens em um valor de 60 segundos a 1.209.600 segundos (14 dias) usando a açãoSetQueueAttributes

68


Amazon Simple Queue Service Guia do desenvolvedorFilas Padrão

Filas Padrão do Amazon SQSO Amazon SQS oferece padrão como o tipo de fila padrão. As filas Padrão do As filas Padrão oferecemsuporte a um número quase ilimitado de transações por segundo (TPS) por ação de oferecem suportea entrega de mensagens pelo menos uma vez. No entanto, às vezes (devido à arquitetura altamentedistribuída que permite uma taxa de transferência praticamente ilimitada), mais de uma cópia de umamensagem pode ser entregue fora de ordem. As filas Padrão fornecem a melhor ordenação possível, oque geralmente garante que as mensagens sejam entregues na mesma ordem em que foram enviadas.

Para obter informações sobre como criar filas padrão com ou sem criptografia do lado do servidorusando o Console de gerenciamento da AWS, o AWS SDK for Java (e a ação CreateQueue) ou o AWSCloudFormation, consulte Criação de uma fila (p. 16) e Criação de uma fila com (p. 20).

É possível usar filas de mensagens padrão em vários cenários, contanto que o aplicativo possa processaras mensagens que chegam mais de uma vez e fora de ordem, por exemplo:

• Desacoplar solicitações do usuário de trabalhos intensos em segundo plano – permitir que os usuáriosfaçam upload de mídia redimensionando-a ou codificando-a.

• Alocar tarefas para nós com vários operadores – processar uma alto número de solicitações devalidação de cartão de crédito.

• Mensagens em lotes para processamento futuro – agendar várias entradas para adicioná-las ao bancode dados.

Para obter as práticas recomendadas para trabalhar com filas padrão, consulte Recomendações para filasAmazon SQS Padrão e FIFO (ordem de chegada) (p. 119).

Tópicos• Ordenação de mensagens (p. 69)• Entrega pelo menos uma vez (p. 69)• Consumo de mensagens usando sondagem breve (p. 70)• Exemplo de Java funcional para filas Padrão (p. 70)

Ordenação de mensagensUma fila padrão faz o possível para preservar a ordem das mensagens, mas mais de uma cópia deuma mensagem pode ser entregue fora de ordem. Se o sistema exigir que a ordem seja preservada,recomendamos usar uma fila FIFO (ordem de chegada) (p. 72) ou adicionar informações sobre osequenciamento em cada mensagem para que você possa reordenar as mensagens quando elas foremrecebidas.

Entrega pelo menos uma vezO Amazon SQS armazena cópias de suas mensagens em vários servidores para obter redundância e altadisponibilidade. Em raras ocasiões, um dos servidores que armazena a cópia de uma mensagem poderáficar indisponível quando você receber ou excluir uma mensagem.

Se isso acontecer, a cópia da mensagem não será excluída no servidor indisponível, e você poderá obter acópia da mensagem novamente quando receber mensagens. Projete aplicativos para serem idempotentes(ou seja, eles não devem ser afetados de modo adverso durante o processamento da mesma mensagemmais de uma vez).

69


Amazon Simple Queue Service Guia do desenvolvedorConsumo de mensagens usando sondagem breve

Consumo de mensagens usando sondagem breveO processo de consumo de mensagens de uma fila depende do método de comportamento que vocêusa: sondagem breve (padrão) ou sondagem longa. Para obter mais informações sobre sondagem longa,consulte Sondagem longa do Amazon SQS (p. 85).

Quando você consome as mensagens de uma fila usando a sondagem breve, o Amazon SQS obtémamostras de um subconjunto de seus servidores (com base em uma distribuição aleatória ponderada) eretorna mensagens apenas desses servidores. Assim, uma determinada solicitação de recebimento podenão retornar todas as suas mensagens. No entanto, se você tiver menos de 1.000 mensagens na fila,uma solicitação subsequente retornará suas mensagens. Se você continuar consumindo em suas filas, oAmazon SQS obterá amostras de todos os seus servidores, e você receberá todas as mensagens.

O diagrama a seguir mostra o comportamento da sondagem breve de mensagens retornadas de uma filapadrão depois que um dos componentes do sistema faz uma solicitação de recebimento. O Amazon SQSanalisa vários de seus servidores (em cinza) e retorna as mensagens A, C, D e B desses servidores. Amensagem E não é retornada para essa solicitação, mas é retornada para uma solicitação subsequente.

Exemplo de Java funcional para filas PadrãoConheça a funcionalidade da fila Amazon SQS do padrão usando os pré-requisitos fornecidos pelo Mavene o código Java de exemplo.

Pré-requisitosAdicione o pacote aws-java-sdk-sqs.jar ao caminho da classe Java. O exemplo a seguir mostra essadependência em um arquivo pom.xml do projeto Maven.


SQSSimpleJavaClientExample.javaO seguinte exemplo de código Java cria uma fila e envia, recebe e exclui uma mensagem.

/*

70

Amazon Simple Queue Service Guia do desenvolvedorExemplo de Java funcional para filas Padrão

* Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */

import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.*;

import java.util.List;import java.util.Map.Entry;

/** * This sample demonstrates how to make basic requests to Amazon SQS using the * AWS SDK for Java. * <p> * Prerequisites: You must have a valid Amazon Web Services developer account, * and be signed up to use Amazon SQS. For more information about Amazon SQS, * see https://aws.amazon.com/sqs * <p> * Make sure that your credentials are located in ~/.aws/credentials */public class SQSSimpleJavaClientExample { public static void main(String[] args) { /* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

System.out.println("==============================================="); System.out.println("Getting Started with Amazon SQS Padrão Queues"); System.out.println("===============================================\n");

try { // Create a queue. System.out.println("Creating a new SQS queue called MyQueue.\n"); final CreateQueueRequest createQueueRequest = new CreateQueueRequest("MyQueue"); final String myQueueUrl = sqs.createQueue(createQueueRequest) .getQueueUrl();

// List all queues. System.out.println("Listing all queues in your account.\n"); for (final String queueUrl : sqs.listQueues().getQueueUrls()) { System.out.println(" QueueUrl: " + queueUrl); } System.out.println();

// Send a message. System.out.println("Sending a message to MyQueue.\n"); sqs.sendMessage(new SendMessageRequest(myQueueUrl, "This is my message text."));

71

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/creating-clients.html

Amazon Simple Queue Service Guia do desenvolvedorFilas FIFO

// Receive messages. System.out.println("Receiving messages from MyQueue.\n"); final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl); final List<Message> messages = sqs.receiveMessage(receiveMessageRequest) .getMessages(); for (final Message message : messages) { System.out.println("Message"); System.out.println(" MessageId: " + message.getMessageId()); System.out.println(" ReceiptHandle: " + message.getReceiptHandle()); System.out.println(" MD5OfBody: " + message.getMD5OfBody()); System.out.println(" Body: " + message.getBody()); for (final Entry<String, String> entry : message.getAttributes() .entrySet()) { System.out.println("Attribute"); System.out.println(" Name: " + entry .getKey()); System.out.println(" Value: " + entry .getValue()); } } System.out.println();

// Delete the message. System.out.println("Deleting a message.\n"); final String messageReceiptHandle = messages.get(0).getReceiptHandle(); sqs.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle));

// Delete the queue. System.out.println("Deleting the test queue.\n"); sqs.deleteQueue(new DeleteQueueRequest(myQueueUrl)); } catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } }}

Filas FIFO (ordem de chegada) do Amazon SQSAs filas FIFO do as filas FIFO estão disponíveis nas regiões Leste dos EUA (Norte da Virgínia), Leste dosEUA (Ohio), Oeste dos EUA (Oregon), e UE (Irlanda). têm os recursos da fila padrão (p. 69).

72

Amazon Simple Queue Service Guia do desenvolvedorOrdenação de mensagens

Para obter informações sobre como criar filas FIFO com ou sem criptografia do lado do servidor usandoo Console de gerenciamento da AWS, o AWS SDK for Java (e a ação CreateQueue) ou o AWSCloudFormation, consulte Criação de uma fila (p. 16) e Criação de uma fila com (p. 20).

As filas FIFO (ordem de chegada) são projetadas para aprimorar o sistema de mensagens entre aplicativosquando a ordem das operações e dos eventos é crítica ou quando duplicatas não podem ser toleradas, porexemplo:

• Verificar se os comandos inseridos pelo usuário são executados na ordem correta.• Exibir o preço do produto correto enviando modificações de preço na ordem correta.• Impedir que um aluno se inscreva em um curso antes de criar uma conta.

As filas FIFO também fornecem processamento exatamente uma vez, mas são limitadas a umdeterminado número de transações por segundo (TPS):

• Por padrão, filas FIFO admitem até 3.000 mensagens por segundo com o agrupamento emlotes (p. 181). Para solicitar um aumento de limite, envie uma solicitação de suporte.

• As filas FIFO podem admitir até 300 mensagens por segundo (300 operações de envio, recebimento ouexclusão por segundo) sem o agrupamento em lotes.

Note

O nome de uma fila FIFO deve terminar com o sufixo .fifo. O sufixo conta para o limite de 80caracteres do nome da fila. Para determinar se uma fila é FIFO (p. 72), você pode verificar se onome da fila termina com o sufixo.

Para obter as práticas recomendadas para trabalhar com filas FIFO, consulte Recomendações adicionaispara filas Amazon SQS FIFO (p. 122) e Recomendações para filas Amazon SQS Padrão e FIFO (ordemde chegada) (p. 119).

Para obter informações sobre a compatibilidade de clientes e serviços com filas FIFO, consulteCompatibilidade (p. 76).

Tópicos• Ordenação de mensagens (p. 73)• Termos-chave (p. 74)• Lógica da entrega FIFO (p. 74)• Processamento exatamente uma vez (p. 75)• Mudança de uma fila Padrão para uma fila FIFO (p. 75)• Compatibilidade (p. 76)• Exemplo de Java funcional para filas FIFO (p. 77)

Ordenação de mensagensA fila FIFO aprimora e complementa a fila padrão (p. 69). Os recursos mais importantes desse tipo defila são entrega FIFO (ordem de chegada) (p. 74) e processamento exatamente uma vez (p. 75):

• A ordem em que as mensagens são enviadas e recebidas é preservada estritamente, e uma mensagemé entregue uma vez e permanece disponível até que um consumidor a processe e a exclua.

• As duplicações não são introduzidas na fila.

Além disso, as filas FIFO também oferecem suporte a grupos de mensagens que permitem vários gruposde mensagens ordenadas em uma única fila.

73



Amazon Simple Queue Service Guia do desenvolvedorTermos-chave

Termos-chaveOs seguintes termos-chave podem ajudar você a entender melhor a funcionalidade das filas FIFO. Paraobter mais informações, consulte a Amazon Simple Queue Service API Reference.

ID de eliminação de duplicação de mensagem

The token usado para desduplicação de mensagens enviadas. Se uma mensagem com uma ID dedesduplicação de mensagem particular for enviada com êxito, todas as mensagens enviadas coma mesma ID de desduplicação serão aceitas com êxito, mas não serão entregues no intervalo dedesduplicação de 5 minutos.

Note

A desduplicação de mensagens se aplica a uma fila inteira, não a grupos individuais demensagens.O Amazon SQS continua mantendo o ID de desduplicação da mensagem mesmo após amensagem ser recebida e excluída.

ID do grupo de mensagens

A tag especificando que uma mensagem pertence a um grupo específico de mensagens. Asmensagens que pertencem ao mesmo grupo de mensagens são processadas sempre uma por uma,em uma ordem estrita em relação ao grupo de mensagens (porém, as mensagens que pertençam agrupos diferentes de mensagens podem ser processadas fora de ordem).

ID de tentativa de solicitação de recebimento

O token usado para o desduplicação de chamadas de ReceiveMessage.Número de sequência

As filas número grande não consecutivo que o Amazon SQS distribui a cada mensagem.

Lógica da entrega FIFOOs conceitos a seguir podem ajudar a entender melhor o envio e o recebimento de mensagens em FIFO.

Envio de mensagens

Se várias mensagens forem enviadas em sucessão a uma fila FIFO, cada uma com um ID deeliminação de duplicação de mensagem distinto, o Amazon SQS armazenará as mensagens ereconhecerá a transmissão. Em seguida, cada mensagem pode ser recebida e processada na ordemexata em que as mensagens foram transmitidas.

Em filas FIFO, as mensagens são ordenadas com base no ID do grupo de mensagens. Se várioshosts (ou threads diferentes no mesmo host) enviarem mensagens com o mesmo ID de grupo demensagens para uma fila FIFO, o Amazon SQS armazenará as mensagens na ordem de chegadapara processamento. Para garantir que o Amazon SQS preserve a ordem na qual as mensagens sãoenviadas e recebidas, verifique se cada produtor usa um ID de grupo de mensagens exclusivo paraenviar todas as mensagens.

A lógica da fila FIFO se aplica apenas por ID de grupo de mensagens. Cada ID de grupo demensagens representa um grupo de mensagens ordenadas diferente em uma fila do Amazon SQS.Para cada ID de grupo de mensagens, todas as mensagens são enviadas e recebidas na ordemestrita. No entanto, as mensagens com valores de ID de grupo de mensagens diferentes podemser enviadas e recebidas fora de ordem. Você deve associar um ID de grupo de mensagens a umamensagem. Se você não fornecer um ID de grupo de mensagens, a ação resultará em falha. Se vocêprecisar de um único grupo de mensagens ordenadas, forneça o mesmo ID de grupo de mensagenspara a fila FIFO.

74

Amazon Simple Queue Service Guia do desenvolvedorProcessamento exatamente uma vez

Recebimento de mensagens

Você não pode solicitar o recebimento de mensagens com um ID de grupo de mensagens específico.

Ao receber mensagens de uma fila FIFO com vários IDs de grupos de mensagens, o Amazon SQSprimeiro tenta retornar o máximo possível de mensagens com o mesmo ID de grupo de mensagens.Isso permite que outros clientes processem mensagens com um ID de grupo de mensagens diferente.

Note

É possível receber até 10 mensagens em uma única chamada usando o parâmetro desolicitação MaxNumberOfMessages da ReceiveMessage ação de Essas mensagensmantêm a ordem FIFO e podem ter o mesmo ID de grupo de mensagens. Portanto, se houvermenos de 10 mensagens disponíveis com o mesmo ID de grupo de mensagens, você poderáreceber mensagens de outro ID de grupo de mensagens, no mesmo lote de 10 mensagens,mas ainda na ordem FIFO.

Repetir várias vezes

As filas FIFO permitem que o produtor ou o consumidor façam várias tentativas:• Se o produtor detectar uma ação falha de SendMessage, ele poderá tentar enviar novamente

quantas vezes forem necessárias usando a mesma ID de desduplicação de mensagens. Supondoque o produtor recebe pelo menos uma confirmação antes de o intervalo de desduplicação expirar,várias tentativas nem afetam a ordem das mensagem nem introduzem duplicações.

• Se o consumidor detectar uma ação falha de ReceiveMessage, ele poderá tentar enviarnovamente quantas vezes forem necessárias usando a mesma ID de tentativa de solicitação derecebimento. Supondo que o consumidor recebe pelo menos uma confirmação antes de o intervalode visibilidade expirar, várias tentativas não afetam a ordem das mensagens.

• Quando você receber uma mensagem com um ID de grupo de mensagem, nenhuma outramensagem para a mesma ID de grupo será retornada, a menos que você exclua a mensagem ouela fique visível.

Processamento exatamente uma vezAo contrário das filas padrão, as filas FIFO não apresentam mensagens duplicadas. As filas FIFO ajudama evitar o envio de duplicações para uma fila. Se você tentar novamente a ação SendMessage dentro dointervalo de eliminação de duplicação de 5 minutos, o Amazon SQS não apresentará duplicações na fila.

Para configurar a eliminação de duplicação, você deve realizar umas das seguintes ações:

• Ativar a eliminação de duplicação baseada em conteúdo. Isso faz com que o Amazon SQS use um hashSHA-256 para gerar o ID de eliminação de duplicação de mensagem usando o corpo da mensagem, —mas não os atributos da mensagem. Para obter mais informações, consulte a documentação das açõesCreateQueue, GetQueueAttributes e SetQueueAttributes no Amazon Simple Queue ServiceAPI Reference.

• Forneça explicitamente o ID de eliminação de duplicação da mensagem (ou visualize o número desequência) para a mensagem. Para obter mais informações, consulte a documentação das açõesSendMessage, SendMessageBatch e ReceiveMessage no Amazon Simple Queue Service APIReference.

Mudança de uma fila Padrão para uma fila FIFOSe houver um aplicativo que usa filas padrão e quiser aproveitar os recursos de ordenação ouprocessamento exatamente uma vez de filas FIFO, você precisará configurar a fila e seu aplicativocorretamente.

75








Amazon Simple Queue Service Guia do desenvolvedorCompatibilidade

Note

Não é possível converter uma fila padrão em uma fila FIFO. Para fazer a mudança, você precisacriar uma nova fila FIFO para o aplicativo ou excluir uma fila padrão existente e recriá-la comouma fila FIFO.

Use a seguinte lista de verificação para garantir que seu aplicativo funcione corretamente com uma filaFIFO.

• Por padrão, filas FIFO admitem até 3.000 mensagens por segundo com o agrupamento emlotes (p. 181). Para solicitar um aumento de limite, envie uma solicitação de suporte. As filas FIFOpodem admitir até 300 mensagens por segundo (300 operações de envio, recebimento ou exclusão porsegundo) sem o agrupamento em lotes.

• As filas FIFO não dão suporte a atrasos por mensagem, apenas a atrasos por fila. Se seu aplicativodefine o mesmo valor do parâmetro DelaySeconds em cada mensagem, você deve modificar oaplicativo para remover o atraso por mensagem e definir DelaySeconds em toda a fila.

• Cada mensagem enviada a uma fila FIFO exige um ID de grupo de mensagens. Se você não precisarde vários grupos de mensagens ordenadas, especifique o mesmo ID de grupo para todas as suasmensagens.

• Antes de enviar mensagens para uma fila FIFO, confirme o seguinte:• Se seu aplicativo pode enviar mensagens com corpos de mensagem idênticos, você pode modificar

o aplicativo para fornecer um ID de eliminação de duplicação de mensagem exclusivo para cadamensagem enviada.

• Se seu aplicativo envia mensagens com corpos de mensagem exclusivos, você pode ativar aeliminação de duplicação baseada em conteúdo.

• Você não precisa fazer alterações de código para seu consumidor. No entanto, se levar muito tempopara processar mensagens e o tempo limite de visibilidade for definido como um valor alto, considere aadição de um ID de tentativa de solicitação de recebimento a cada ação ReceiveMessage. Isso permiteque você repita tentativas de recebimento em caso de falhas de rede e impede que as filas pausemdevido a tentativas de recebimento com falha.

Para obter mais informações, consulte Amazon Simple Queue Service API Reference.

CompatibilidadeClientes

O Cliente assíncrono armazenado em buffer do Amazon SQS não oferece suporte às filas FIFO.Serviços

Se seu aplicativo usar vários serviços da AWS ou uma combinação de serviços da AWS e externos, éimportante compreender qual funcionalidade de serviço não oferece suporte a filas FIFO.

Alguns serviços da AWS ou externos que enviam notificações para Amazon SQS podem não sercompatíveis com filas FIFO, mesmo permitindo que você defina uma fila FIFO como destino.

As seguintes características dos serviços da AWS não são atualmente compatíveis com filas FIFO:• Ganchos de ciclo de vida Auto Scaling• Ações de regra AWS IoT• Dead Letter Queues AWS Lambda

Para obter informações sobre a compatibilidade de outros serviços com filas FIFO, consulte adocumentação de serviço.

76


https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html

https://docs.aws.amazon.com/iot/latest/developerguide/iot-rule-actions.html

https://docs.aws.amazon.com/lambda/latest/dg/dlq.html

Amazon Simple Queue Service Guia do desenvolvedorExemplo de Java funcional para filas FIFO

Exemplo de Java funcional para filas FIFOConheça a funcionalidade da fila Amazon SQS do FIFO usando os pré-requisitos fornecidos pelo Maven eo código Java de exemplo.

Pré-requisitosAdicione o pacote aws-java-sdk-sqs.jar ao caminho da classe Java. O exemplo a seguir mostra essadependência em um arquivo pom.xml do projeto Maven.


SQSFIFOJavaClientExample.javaO seguinte exemplo de código Java cria uma fila e envia, recebe e exclui uma mensagem.


import com.amazonaws.AmazonClientException;import com.amazonaws.AmazonServiceException;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.*;

import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Map.Entry;

public class SQSFIFOJavaClientExample { public static void main(String[] args) { /* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

System.out.println("==========================================="); System.out.println("Getting Started with Amazon SQS FIFO Queues"); System.out.println("===========================================\n");

77

Amazon Simple Queue Service Guia do desenvolvedorExemplo de Java funcional para filas FIFO

try {

// Create a FIFO queue. System.out.println("Creating a new Amazon SQS FIFO queue called " + "MyFifoQueue.fifo.\n"); final Map<String, String> attributes = new HashMap<>();

// A FIFO queue must have the FifoQueue attribute set to true. attributes.put("FifoQueue", "true");

/* * If the user doesn't provide a MessageDeduplicationId, generate a * MessageDeduplicationId based on the content. */ attributes.put("ContentBasedDeduplication", "true");

// The FIFO queue name must end with the .fifo suffix. final CreateQueueRequest createQueueRequest = new CreateQueueRequest("MyFifoQueue.fifo") .withAttributes(attributes); final String myQueueUrl = sqs.createQueue(createQueueRequest).getQueueUrl();

// List all queues. System.out.println("Listing all queues in your account.\n"); for (final String queueUrl : sqs.listQueues().getQueueUrls()) { System.out.println(" QueueUrl: " + queueUrl); } System.out.println();

// Send a message. System.out.println("Sending a message to MyFifoQueue.fifo.\n"); final SendMessageRequest sendMessageRequest = new SendMessageRequest(myQueueUrl, "This is my message text.");

/* * When you send messages to a FIFO queue, you must provide a * non-empty MessageGroupId. */ sendMessageRequest.setMessageGroupId("messageGroup1");

// Uncomment the following to provide the MessageDeduplicationId //sendMessageRequest.setMessageDeduplicationId("1"); final SendMessageResult sendMessageResult = sqs .sendMessage(sendMessageRequest); final String sequenceNumber = sendMessageResult.getSequenceNumber(); final String messageId = sendMessageResult.getMessageId(); System.out.println("SendMessage succeed with messageId " + messageId + ", sequence number " + sequenceNumber + "\n");

// Receive messages. System.out.println("Receiving messages from MyFifoQueue.fifo.\n"); final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl);

// Uncomment the following to provide the ReceiveRequestDeduplicationId //receiveMessageRequest.setReceiveRequestAttemptId("1"); final List<Message> messages = sqs.receiveMessage(receiveMessageRequest) .getMessages(); for (final Message message : messages) { System.out.println("Message"); System.out.println(" MessageId: " + message.getMessageId()); System.out.println(" ReceiptHandle: " + message.getReceiptHandle());

78

Amazon Simple Queue Service Guia do desenvolvedorIdentificadores de filas e mensagens

System.out.println(" MD5OfBody: " + message.getMD5OfBody()); System.out.println(" Body: " + message.getBody()); for (final Entry<String, String> entry : message.getAttributes() .entrySet()) { System.out.println("Attribute"); System.out.println(" Name: " + entry.getKey()); System.out.println(" Value: " + entry.getValue()); } } System.out.println();

// Delete the message. System.out.println("Deleting the message.\n"); final String messageReceiptHandle = messages.get(0).getReceiptHandle(); sqs.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle));

// Delete the queue. System.out.println("Deleting the queue.\n"); sqs.deleteQueue(new DeleteQueueRequest(myQueueUrl)); } catch (final AmazonServiceException ase) { System.out.println("Caught an AmazonServiceException, which means " + "your request made it to Amazon SQS, but was " + "rejected with an error response for some reason."); System.out.println("Error Message: " + ase.getMessage()); System.out.println("HTTP Status Code: " + ase.getStatusCode()); System.out.println("AWS Error Code: " + ase.getErrorCode()); System.out.println("Error Type: " + ase.getErrorType()); System.out.println("Request ID: " + ase.getRequestId()); } catch (final AmazonClientException ace) { System.out.println("Caught an AmazonClientException, which means " + "the client encountered a serious internal problem while " + "trying to communicate with Amazon SQS, such as not " + "being able to access the network."); System.out.println("Error Message: " + ace.getMessage()); } }}

Identificadores de filas e mensagens do AmazonSQS

Esta seção descreve os identificadores de filas padrão e FIFO. Esses identificadores podem ajudar alocalizar e manipular filas e mensagens específicas.

Tópicos• Identificadores de filas Padrão e FIFO do Amazon SQS (p. 79)• Identificadores adicionais para filas FIFO do Amazon SQS (p. 81)

Identificadores de filas Padrão e FIFO do AmazonSQSPara obter mais informações sobre os identificadores a seguir, consulte Amazon Simple Queue ServiceAPI Reference.

79

Amazon Simple Queue Service Guia do desenvolvedorIdentificadores de filas Padrão e FIFO

Nome e URL da filaQuando cria uma nova fila, você deve especificar um nome de fila exclusivo para sua conta e região daAWS. O Amazon SQS atribui a cada fila que você cria um identificador chamado URL de fila, que inclui onome da fila e outros componentes do Amazon SQS. Sempre que você desejar executar uma ação emuma fila, forneça o URL da fila.

O nome de uma fila FIFO deve terminar com o sufixo .fifo. O sufixo conta para o limite de 80 caracteresdo nome da fila. Para determinar se uma fila é FIFO (p. 72), você pode verificar se o nome da filatermina com o sufixo.

O seguinte URL é de uma fila chamada MyQueue, de propriedade de um usuário com o número de contada AWS 123456789012.

https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue

Important

Em seu sistema, sempre armazene a URL inteira da fila exatamente como oAmazon SQS a retorna quando você cria a fila (por exemplo, https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue). Não crie a URL da fila a partir deseus componentes separados a cada vez que você precisar especificar a URL da fila em umasolicitação, pois o Amazon SQS pode alterar os componentes que compõem a URL da fila.

Você também pode obter o URL da fila listando suas filas. Para obter mais informações, consulteListQueues.

ID de mensagemCada mensagem recebe um ID de mensagem atribuído pelo sistema que o Amazon SQS retorna paravocê na resposta de SendMessage. Esse identificador é útil para identificar mensagens. No entanto, paraexcluir uma mensagem, você precisa do identificador de recebimento da mensagem. O tamanho máximode um ID de mensagem é 100 caracteres.

Identificador de recebimentoToda vez que você recebe uma mensagem de uma fila, recebe um identificador de recebimento dessamensagem. Esse identificador é associado à ação de recebimento da mensagem, e não à mensagem.Para excluir a mensagem ou alterar a visibilidade da mensagem, você deve fornecer o identificador derecebimento (não o ID de mensagem). Desse modo, você sempre deve receber uma mensagem antes deexcluí-la (você não pode colocar uma mensagem na fila e, em seguida, recuperá-la). O tamanho máximode um identificador de recebimento é 1024 caracteres.

Important

Se você receber uma mensagem mais de uma vez, cada vez que recebê-la, obterá umidentificador de recebimento diferente. Você deve fornecer o identificador de recebimentorecebido mais recentemente ao solicitar a exclusão da mensagem (caso contrário, a mensagempode não ser excluída).

Veja a seguir um exemplo de um identificador de recebimento (quebrado em três linhas).

MbZj6wDWli+JvwwJaBV+3dcjk2YW2vA3+STFFljTM8tJJg6HRG6PYSasuWXPJB+CwLj1FjgXUv1uSj1gUPAWV66FU/WeR4mq2OKpEGYWbnLmpRCJVAyeMjeU5ZBdtcQ+QEauMZc8ZRv37sIW2iJKq3M9MFx1YvV11A2x/KSbkJ0=

80

API_ListQueues.html


Amazon Simple Queue Service Guia do desenvolvedorIdentificadores adicionais para filas FIFO

Identificadores adicionais para filas FIFO do AmazonSQSPara obter mais informações sobre os identificadores a seguir, consulte Processamento exatamente umavez (p. 75) e Amazon Simple Queue Service API Reference.

ID de eliminação de duplicação de mensagemThe token usado para desduplicação de mensagens enviadas. Se uma mensagem com uma ID dedesduplicação de mensagem particular for enviada com êxito, todas as mensagens enviadas coma mesma ID de desduplicação serão aceitas com êxito, mas não serão entregues no intervalo dedesduplicação de 5 minutos.

ID do grupo de mensagensA tag especificando que uma mensagem pertence a um grupo específico de mensagens. As mensagensque pertencem ao mesmo grupo de mensagens são processadas sempre uma por uma, em uma ordemestrita em relação ao grupo de mensagens (porém, as mensagens que pertençam a grupos diferentes demensagens podem ser processadas fora de ordem).

Número de sequênciaAs filas número grande não consecutivo que o Amazon SQS distribui a cada mensagem.

Atributos de mensagens do Amazon SQSO Amazon SQS permite que você incluir metadados estruturados (como carimbos de data e hora, dadosgeoespaciais, assinaturas e identificadores) com mensagens usando os atributos de mensagem. Cadamensagem pode ter até dez atributos. Os atributos de mensagem são opcionais e separados do corpo damensagem (no entanto, são enviados junto com o corpo da mensagem). O consumidor pode usar atributosde mensagem para tratar uma mensagem de uma forma específica sem precisar primeiro processar ocorpo da mensagem. Para obter informações sobre como enviar mensagens com atributos usando oConsole de gerenciamento da AWS ou o AWS SDK for Java, consulte Envio de uma mensagem comatributos a uma fila (p. 32).

Tópicos• Componentes de atributos de mensagem (p. 81)• Tipos de dados de atributos de mensagem (p. 82)• Cálculo do resumo de mensagens MD5 para atributos de mensagem (p. 82)

Componentes de atributos de mensagemImportant

Todos os componentes de um atributo de mensagem estão incluídos na restrição de tamanho de256 KB da mensagem.O Name, Type, Value e o corpo da mensagem não devem estar vazios ou serem nulos.

Cada atributo de mensagem consiste nos seguintes componentes:

• Nome – o nome do atributo da mensagem pode conter os seguintes caracteres: A-Z, a-z, 0-9,sublinhado (_), hífen (-) e ponto (.). As seguintes restrições são aplicáveis:• Pode ter até 256 caracteres

81

Amazon Simple Queue Service Guia do desenvolvedorTipos de dados de atributos de mensagem

• Não pode começar com AWS. ou Amazon. (ou qualquer variação no uso de maiúsculas e minúsculas)• Diferencia maiúsculas de minúsculas• Deve ser exclusivo entre todos os nomes de atributos da mensagem• Não deve começar ou terminar com um ponto• Não deve ter pontos em uma sequência

• Tipo – o tipo de dados do atributo da mensagem. Os tipos compatíveis incluem String, Number eBinary. Você também pode adicionar informações personalizadas para qualquer tipo de dados. O tipode dados tem as mesmas restrições que o corpo da mensagem (para obter mais informações, consulteSendMessage na Amazon Simple Queue Service API Reference). Além disso, aplicam-se as seguintesrestrições:• Pode ter até 256 caracteres• Diferencia maiúsculas de minúsculas

• Valor – o valor do atributo da mensagem. Para tipos de dados String, os valores dos atributos têm asmesmas restrições que o corpo da mensagem.

Tipos de dados de atributos de mensagemOs tipos de dados de atributos de mensagens indicam ao Amazon SQS, como tratar valores de atributosde mensagens correspondentes. Por exemplo, se o tipo for Number, o Amazon SQS validará valoresnuméricos.

O Amazon SQS oferece suporte aos tipos de dados lógicos String, Number e Binary com rótulos detipos de dados personalizados opcionais com o formato .custom-data-type

• String – os atributos String podem armazenar texto Unicode com codificação binária UTF-8. Para obtermais informações, consulte Caracteres ASCII imprimíveis.

• Número – os atributos Number podem armazenar valores numéricos positivos ou negativos. Um númeropode ter até 38 dígitos de precisão, e pode ser entre 10^-128 e 10^+126.

Note

O Amazon SQS remove zeros iniciais e finais.• Binário – os atributos binários podem armazenar qualquer dado binário, como dados compactados,

dados criptografados ou imagens.• Personalizado – para criar um tipo de dados personalizado, acrescente um rótulo de tipo personalizado a

qualquer tipo de dados. Por exemplo:• Number.byte, Number.short, Number.int e Number.float podem ajudar a diferenciar entre

tipos numéricos.• Binary.gif e Binary.png podem ajudar a diferenciar entre tipos de arquivos.

Note

O Amazon SQS não interpreta, valida ou usa os dados acrescentados.O rótulo de tipo personalizado tem as mesmas restrições que o corpo da mensagem.

Cálculo do resumo de mensagens MD5 para atributosde mensagemAo usar o AWS SDK for Java, você pode ignorar esta seção. A classe MessageMD5ChecksumHandlerdo SDK para Java oferece suporte a resumos de mensagens MD5 para atributos de mensagens doAmazon SQS.

82


http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters

Amazon Simple Queue Service Guia do desenvolvedorCálculo do resumo de mensagensMD5 para atributos de mensagem

Ao usar a API de consulta ou um dos SDKs da AWS que não oferecem suporte ao resumo de mensagensMD5 para atributos de mensagens do Amazon SQS, use as seguintes diretrizes para executar o cálculo doresumo de mensagens MD5.

Note

Inclua sempre os sufixos de tipo de dados personalizados no cálculo do resumo de mensagensMD5.

Visão geralO seguinte é uma visão geral do algoritmo de cálculo do resumo de mensagens MD5:

1. Classificar todos os atributos de mensagem por nome em ordem crescente.2. Codificar as partes individuais de cada atributo (Name, Type e Value) em um buffer.3. Calcular o resumo de mensagem de todo o buffer.

O seguinte diagrama mostra a codificação do resumo de mensagens MD5 para um único atributo demensagem:

Para codificar um único atributo de mensagem do Amazon SQS1. Codifique o nome: o comprimento (4 bytes) e os bytes UTF-8 do nome.2. Codifique o tipo de dados: o comprimento (4 bytes) e os bytes UTF-8 do tipo de dados.3. Codifique o tipo de transporte (String ou Binary) do valor (1 byte).

Note

Os tipos de dados lógicos String e Number usam o tipo de transporte String.Os tipos de dados lógicos Binary usam o tipo de transporte Binary.

a. Para o tipo de transporte String, codifique 1.b. Para o tipo de transporte Binary, codifique 2.

4. Codifique o valor do atributo.

a. Para o tipo de transporte String, codifique o valor do atributo: o comprimento (4 bytes) e osbytes UTF-8 do valor.

b. Para o tipo de transporte Binary, codifique o valor do atributo: o comprimento (4 bytes) e osbytes brutos do valor.

83

Amazon Simple Queue Service Guia do desenvolvedorRecursos necessários para processar mensagens

Recursos necessários para processar mensagensdo Amazon SQS

Para ajudá-lo a estimar os recursos necessários para processar mensagens na fila, o Amazon SQS podedeterminar o número aproximado de mensagens em atraso, visíveis e não visíveis em uma fila. Para obtermais informações sobre visibilidade, consulte Tempo limite de visibilidade do Amazon SQS (p. 89).

Note

Para filas padrão, o resultado é aproximado, por conta da arquitetura distribuída de Amazon SQS.Na maioria dos casos, a contagem deve estar próxima ao número real de mensagens na fila.Para filas FIFO, o resultado é preciso.

A tabela a seguir lista o nome do atributo a ser usado com a ação GetQueueAttributes:

Tarefa Nome do atributo

Obter o número de mensagens disponíveis pararecuperação na fila.

ApproximateNumberOfMessages

Obter o número de mensagens na fila queestão atrasadas e indisponíveis para leituraimediata. Isso pode acontecer quando a fila tema configuração de fila com atraso ou quando umamensagem foi enviada com um parâmetro deatraso.

ApproximateNumberOfMessagesDelayed

Obter o número de mensagens que estão emprocessamento. As mensagens são consideradascomo em processamento quando foram enviadasa um cliente, mas ainda não foram excluídasou ainda não atingiram o final de sua janela devisibilidade.

ApproximateNumberOfMessagesNotVisible

Tags de alocação de custos do Amazon SQSPara organizar e identificar suas filas do Amazon SQS para alocação de custos, você pode adicionar tagsde metadados que identificam o objetivo de uma fila, proprietário ou ambiente. — Isso é especialmenteútil quando você tem várias filas. Para obter informações sobre como gerenciar tags de filas do AmazonSQS usando o Console de gerenciamento da AWS ou o AWS SDK for Java (e as ações TagQueue,UntagQueue e ListQueueTags), consulte o tutorial Adição, atualização e remoção de tags de umafila (p. 27).

Você pode usar tags de alocação de custos para organizar sua fatura da AWS para refletir sua própriaestrutura de custos. Para isso, cadastre-se para obter a fatura de sua conta da AWS para incluir chavese valores de tags. Para obter mais informações, consulte Configuração de seu relatório de alocação decustos mensal em Guia do usuário do AWS Billing and Cost Management.

Toda tag é composta de um par de valores de chave, que são definidos por você. Por exemplo, você podeidentificar facilmente suas filas de produção e teste se você marcar suas filas da seguinte forma:

Fila Chave Valor

MyQueueA QueueType Production

84


API_TagQueue.html

API_UntagQueue.html


configurecostallocreport.html#allocation-report

configurecostallocreport.html#allocation-report

Amazon Simple Queue Service Guia do desenvolvedorSondagem longa

Fila Chave Valor

MyQueueB QueueType Testing

Note

Quando utilizar tags de fila, mantenha as seguintes diretrizes em mente:

• Não recomendamos adicionar mais de 50 tags a uma fila.• As tags não têm nenhum significado semântico. O Amazon SQS interpreta tags como cadeias

de caráteres.• As tags diferenciam maiúsculas e minúsculas.• Uma nova tag com uma chave idêntica àquela de uma tag existente substituirá a tag existente.• Ações de de marcação são limitadas a 5 TPS por conta da AWS. Se o aplicativo exigir

throughput mais alto, arquive uma solicitação de suporte técnico.

Para uma lista completa de restrições de tags, consulte Limites relacionados a filas (p. 125).

Você não pode adicionar tags a uma nova fila ao criá-la usando o Console de gerenciamento da AWS(você pode adicionar tags após a criação da fila). No entanto, você pode adicionar, atualizar ou removertags de filas a qualquer momento usando as ações do Amazon SQS.

Sondagem longa do Amazon SQSA sondagem longa ajuda a reduzir os custos de uso do Amazon SQS eliminando a quantidade derespostas vazias (quando não há mensagens disponíveis para uma solicitação ReceiveMessage)e respostas vazias falsas (quando mensagens estão disponíveis, mas não são incluídas em umaresposta). Para obter informações sobre como habilitar a sondagem longa para uma fila nova ou existenteusando o Console de gerenciamento da AWS ou o AWS SDK for Java (e as ações CreateQueue,SetQueueAttributes e ReceiveMessage), consulte o tutorial Configuração da sondagem longa parauma fila (p. 53). Para ver as melhores práticas, consulte Configuração da sondagem longa (p. 120).

A sondagem longa oferece os seguintes benefícios:

• Eliminar respostas vazias permitindo que o Amazon SQS espere até que uma mensagem estejadisponível em uma fila para enviar uma resposta. A menos que uma conexão expire, a resposta àsolicitação ReceiveMessage contém pelo menos uma das mensagens disponíveis, até o númeromáximo de mensagens especificado na ação ReceiveMessage.

• Eliminar respostas vazias falsas consultando todos — em vez de um subconjunto — de servidores doAmazon SQS.

Note

• Retornar mensagens assim que se tornam disponíveis.

Diferenças entre sondagens longa e curtaPor padrão, o Amazon SQS usa a sondagem curta, consultando somente um subconjunto de seusservidores (com base em uma distribuição aleatória ponderada) para determinar se há alguma mensagemdisponível para uma resposta.

A sondagem curta ocorre quando o parâmetro WaitTimeSeconds de uma solicitação ReceiveMessageé definido como 0 de uma de duas maneiras:

85

https://console.aws.amazon.com/support/home#/case/create?issueType=technical






Amazon Simple Queue Service Guia do desenvolvedorDead Letter Queues

• A chamada ReceiveMessage define WaitTimeSeconds como 0.• A chamada ReceiveMessage não define WaitTimeSeconds, mas o atributo da filaReceiveMessageWaitTimeSeconds é definido como 0.

Note

Para o parâmetro WaitTimeSeconds da ação ReceiveMessage, um valordefinido entre 1 e 20 tem prioridade sobre qualquer valor definido para o atributoReceiveMessageWaitTimeSeconds da fila.

Dead-Letter Queues do Amazon SQSO Amazon SQS oferece suporte a dead-letter queues, que outras filas (filas de origem) podem usarcomo destinos para mensagens que não podem ser processadas (consumidas) com êxito. As dead letterqueues são úteis para depurar seu aplicativo ou sistema de mensagens, pois permitem que você isolemensagens problemáticas para determinar por que seu processamento não obteve êxito. Para obterinformações sobre como criar uma fila e configurar uma dead letter queue para essa fila usando o Consolede gerenciamento da AWS ou o AWS SDK for Java (e as ações CreateQueue, SetQueueAttributes eGetQueueAttributes), consulte Configuração de uma dead letter queue (p. 56).

Important

Tópicos• Como as dead letter queues funcionam? (p. 86)• Quais são os benefícios de dead letter queues? (p. 87)• Como os diferentes tipos de fila tratam as falhas de mensagens? (p. 87)• Quando devo usar uma dead letter queue? (p. 88)• Solução de problemas com dead letter queues (p. 88)

Como as dead letter queues funcionam?Algumas vezes, as mensagens não podem ser processadas devido a uma variedade de possíveisproblemas, como condições de erro dos aplicativos de produtores/consumidores ou uma mudança deestado inesperada que causa um problema com o código do seu aplicativo. Por exemplo, se um usuáriofizer um pedido na web com um ID de produto específico, mas esse ID do produto for excluído, o código daloja da web falhará e exibirá um erro. Além disso, a mensagem com a solicitação do pedido será enviadapara uma dead-letter queue.

Ocasionalmente, os produtores e os consumidores podem não conseguir interpretar aspectos do protocoloque eles usam para se comunicar, causando a perda ou corrupção de mensagens. Além disso, os erros dehardware do consumidor podem corromper o conteúdo da mensagem.

A política de redirecionamento especifica a fila de origem, a dead letter queue e as condições sob as quaiso Amazon SQS move mensagens da fila anterior para a última se o consumidor da fila de origem nãopuder processar uma mensagem por um número especificado de vezes. Quando o ReceiveCount deuma mensagem excede o maxReceiveCount de uma fila, o Amazon SQS move a mensagem para umadead letter queue (com o ID da mensagem original). Por exemplo, se a fila de origem tiver uma política deredirecionamento com maxReceiveCount definido como 5, e o consumidor da fila de origem receber umamensagem 5 vezes sem nunca excluí-la, o Amazon SQS moverá a mensagem para a dead letter queue.

Para especificar uma dead letter queue, você pode usar o Console de gerenciamento da AWS ou o AWSSDK for Java (p. 56). Você deve fazer isso para cada fila que envia mensagens para uma dead letter

86





Amazon Simple Queue Service Guia do desenvolvedorQuais são os benefícios de dead letter queues?

queue. Várias filas podem visar uma única dead letter queue. Para obter mais informações, consulteConfiguração de uma dead letter queue (p. 56) e o atributo RedrivePolicy da ação da CreateQueue ouSetQueueAttributes.

Important

A dead letter queue de uma fila FIFO também deve ser uma fila FIFO. Da mesma forma, a deadletter queue de uma fila padrão também deve ser uma fila padrão.Você deve usar a mesma conta da AWS para criar a dead letter queue e outras filas que enviammensagens para a dead letter queue. Além disso, as dead letter queues devem residir na mesmaregião que as outras filas que usam a dead letter queue. Por exemplo, se você criar uma fila naregião Leste dos EUA (Ohio) e desejar usar uma dead letter queue com essa fila, a segunda filatambém deverá estar na região Leste dos EUA (Ohio).A expiração de uma mensagem é baseada sempre em seu timestamp em fila original. Quandouma mensagem é movida para uma dead-letter queue (p. 86), o timestamp em fila permaneceinalterado. Por exemplo, se uma mensagem passar 1 dia na fila original antes de ser movida parauma dead-letter queue, e o período de retenção da fila de dead-letter queue estiver definido em4 dias, a mensagem é excluída da fila de dead-letter queue após 3 dias. Por isso, uma práticarecomendada é definir sempre o período de retenção de uma dead-letter queue mais longo que operíodo de retenção da fila original.

Quais são os benefícios de dead letter queues?A principal tarefa de uma dead letter queue é lidar com falhas de mensagem. Uma dead letter queuepermite que você separe e isole mensagens que não podem ser processadas corretamente paradeterminar por que seu processamento não obteve êxito. Configurar uma dead letter queue permite quevocê faça o seguinte:

• Configurar um alarme para todas as mensagens entregues para uma dead letter queue.• Examinar logs para encontrar as exceções que podem ter causado a entrega de mensagens a uma

dead letter queue.• Analisar o conteúdo de mensagens entregues a uma dead letter queue para diagnosticar problemas de

software ou de hardware do produtor ou consumidor.• Determinar se você concedeu ao consumidor tempo suficiente para processar mensagens.

Como os diferentes tipos de fila tratam as falhas demensagens?Filas PadrãoAs filas Padrão (p. 69) processam mensagens até a expiração do período de retenção. Isso garanteo processamento contínuo de mensagens, o que minimiza as chances de sua fila ser bloqueada pormensagens que não podem ser processadas. Também garante uma recuperação rápida da fila.

Em um sistema que processa milhares de mensagens, ter um grande número de mensagens que oconsumidor repetidamente falha em confirmar e excluir pode aumentar os custos e colocar uma cargaextra no hardware. Em vez de tentar processar mensagens com falha até que elas expirem, é melhormovê-las para uma dead letter queue após algumas tentativas de processamento.

Note

As filas Padrão permitem um grande número de mensagens em trânsito. Se a maioria de suasmensagens não puder ser consumida e não for enviada para uma dead letter queue, sua taxa deprocessamento de mensagens válidas poderá diminuir. Assim, para manter a eficiência da fila,você deve garantir que seu aplicativo lide com o processamento de mensagens corretamente.

87

API_CreateQueue.html#API_CreateQueue_RequestParameters

API_SetQueueAttributes.html#API_SetQueueAttributes_RequestParameters

Amazon Simple Queue Service Guia do desenvolvedorQuando devo usar uma dead letter queue?

Filas FIFOAs filas FIFO (p. 72) garantem o processamento exatamente uma vez consumindo mensagens de umgrupo de mensagens em sequência. Assim, embora o consumidor possa continuar a recuperar mensagensordenadas de um outro grupo de mensagens, o primeiro grupo de mensagens permanece indisponível atéque a mensagem que está bloqueando a fila seja processada com êxito.

Note

As filas FIFO permitem um número menor de mensagens em trânsito. Assim, para evitar que afila FIFO seja bloqueada por uma mensagem, você deve garantir que seu aplicativo lide com oprocessamento de mensagens corretamente.

Quando devo usar uma dead letter queue?

Use dead letter queues com filas padrão. Você deve tirar proveito das dead letter queues sempreque seus aplicativos não dependerem de ordenação. As dead letter queues podem ajudá-lo a solucionaras operações de transmissão de mensagens incorretas.

Note

Mesmo quando você usa dead letter queues, deve continuar a monitorar suas filas e tentar enviarmensagens que falham por razões transitórias.

Utilize as dead letter queues para diminuir o número de mensagens e reduzir a possibilidade deexposição de seu sistema a mensagens poison-pill (mensagens que podem ser recebidas, mas que nãopodem ser processadas).

Não use uma dead letter queue com filas padrão quando quiser repetir a transmissão de umamensagem indefinidamente. Por exemplo, não use uma dead letter queue se o programa precisar esperarque um processo dependente se torne ativo ou disponível.

Não use uma dead letter queue com uma fila FIFO se não quiser quebrar a ordem exata demensagens ou das operações. Por exemplo, não use uma dead letter queue com instruções em uma EditDecision List (EDL) para um pacote de edição de vídeo, onde a alteração da ordem de edições muda ocontexto de edições subsequentes.

Solução de problemas com dead letter queuesEm alguns casos, as dead letter queues do Amazon SQS podem não se comportar como esperado. Estaseção fornece uma visão geral dos problemas comuns e mostra como resolvê-los.

Visualizar mensagens usando o Console de gerenciamento daAWS pode fazer com que as mensagens sejam movidas parauma dead letter queueO Amazon SQS considera a visualização de uma mensagem no Console de gerenciamento da AWScontra a política de redirecionamento da fila correspondente. Dessa forma, se você visualizar umamensagem no Console de gerenciamento da AWS o número de vezes especificado na política de

88

Amazon Simple Queue Service Guia do desenvolvedorTempo limite de visibilidade

redirecionamento da fila correspondente, a mensagem será movida para a dead letter queue da filacorrespondente.

Para ajustar esse comportamento, você pode executar uma das seguintes ações:

• Aumentar a definição de Maximum Receives da política de redirecionamento da fila correspondente.• Evitar a visualização de mensagens da fila correspondente no Console de gerenciamento da AWS.

O NumberOfMessagesSent e oNumberOfMessagesReceived de uma dead letter queue nãocorrespondemSe você enviar uma mensagem para uma dead letter queue manualmente, ela será capturada pela métricaNumberOfMessagesSent. No entanto, uma mensagem enviada para uma dead letter queue comoresultado de uma falha na tentativa de processamento não é capturada por essa métrica. Assim, é possívelque os valores de NumberOfMessagesSent e NumberOfMessagesReceived sejam diferentes.

Tempo limite de visibilidade do Amazon SQSQuando um consumidor recebe e processa uma mensagem de uma fila, a mensagem permanece nafila. O Amazon SQS não exclui a mensagem automaticamente. Como o Amazon SQS é um sistemadistribuído, não há garantia de que o consumidor realmente receba a mensagem (por exemplo, devidoa um problema de conectividade ou devido a um problema no aplicativo consumidor). Desse modo, oconsumidor deve excluir a mensagem da fila após o recebimento e processamento.

Logo após o recebimento de uma mensagem, ela permanece na fila. Para evitar que outros consumidoresprocessem a mensagem novamente, o Amazon SQS define um tempo limite de visibilidade, um períododurante o qual o Amazon SQS impede que outros consumidores recebam e processem a mensagem. Otempo limite de visibilidade padrão para uma mensagem é de 30 segundos. O máximo é 12 horas. Paraobter informações sobre como configurar o tempo limite de visibilidade para uma fila usando o Consolede gerenciamento da AWS e para uma ou várias mensagens usando o AWS SDK for Java (e as açõesSetQueueAttributes. GetQueueAttributes, ReceiveMessage, ChangeMessageVisibility eChangeMessageVisibilityBatch), consulte Configuração do tempo limite de visibilidade para umafila (p. 60).

Note

Para filas padrão, o tempo limite de visibilidade não é uma garantia contra o recebimento deuma mensagem duas vezes. Para obter mais informações, consulte Entrega pelo menos umavez (p. 69).As filas FIFO permitem que o produtor ou o consumidor façam várias tentativas:

• Se o produtor detectar uma ação falha de SendMessage, ele poderá tentar enviar novamentequantas vezes forem necessárias usando a mesma ID de desduplicação de mensagens.

89





API_ChangeMessageVisibilityBatch.html

Amazon Simple Queue Service Guia do desenvolvedorMensagens em trânsito

Supondo que o produtor recebe pelo menos uma confirmação antes de o intervalo dedesduplicação expirar, várias tentativas nem afetam a ordem das mensagem nem introduzemduplicações.

• Se o consumidor detectar uma ação falha de ReceiveMessage, ele poderá tentar enviarnovamente quantas vezes forem necessárias usando a mesma ID de tentativa de solicitaçãode recebimento. Supondo que o consumidor recebe pelo menos uma confirmação antes de ointervalo de visibilidade expirar, várias tentativas não afetam a ordem das mensagens.

• Quando você receber uma mensagem com um ID de grupo de mensagem, nenhuma outramensagem para a mesma ID de grupo será retornada, a menos que você exclua a mensagemou ela fique visível.

Tópicos• Mensagens em trânsito (p. 90)• Definição do tempo limite de visibilidade (p. 90)• Alteração do tempo limite de visibilidade de uma mensagem (p. 91)• Término do tempo limite de visibilidade de uma mensagem (p. 91)

Mensagens em trânsitoUma mensagem do Amazon SQS tem três estados básicos: 1. Enviada a uma fila por um produtor,2. Recebida de fila durante um consumidor e 3. Excluída da fila. Uma mensagem é considerada emprocessamento depois que é received from a queue by a consumer, but not yet deleted from the queue (ouseja, entre os estados 2 e 3). Não há limite para o número de mensagens em uma fila que está entre osestados 1 e 2.

Para filas padrão, pode haver no máximo 120.000 mensagens em processamento (received from a queueby a consumer, but not yet deleted from the queue). Se você atingir o limite, o Amazon SQS retornará amensagem de erro OverLimit. Para evitar atingir o limite, você deve excluir mensagens da fila depoisde serem processadas. Você também pode aumentar o número de filas que usar para processar asmensagens. Para solicitar um aumento de limite, envie uma solicitação de suporte.

Para filas FIFO, pode haver no máximo 20.000 mensagens em processamento (received from a queue bya consumer, but not yet deleted from the queue). Se você atingir o limite, o Amazon SQS não retornarámensagens de erro.

Definição do tempo limite de visibilidadeO tempo limite de visibilidade começa quando o Amazon SQS retorna uma mensagem. Durante esseperíodo, o consumidor processa e exclui a mensagem. No entanto, se o consumidor falhar antes de excluira mensagem e seu sistema não chamar a ação DeleteMessage para essa mensagem antes que o tempolimite de visibilidade expire, a mensagem ficará visível para outros consumidores e a mensagem serárecebida novamente. Se uma mensagem só deve ser recebida uma vez, o consumidor deverá excluí-ladurante o tempo limite de visibilidade.

Toda fila do Amazon SQS tem a configuração padrão de 30 segundos para o tempo limite de visibilidade.Você pode alterar essa configuração para toda a fila. Normalmente, você deve definir o tempo limitede visibilidade como o tempo máximo de que o seu aplicativo precisa para processar e excluir umamensagem da fila. Ao receber mensagens, você também pode definir um tempo limite de visibilidadeespecial para as mensagens retornadas sem alterar o tempo limite de fila geral. Para obter maisinformações, consulte as melhores práticas na seção Processar mensagens em tempo hábil (p. 119).

Se você não sabe quanto tempo demora para processar uma mensagem, crie um heartbeat para oprocesso dos consumidores: especifique o tempo limite de visibilidade inicial (por exemplo, 2 minutos) e,

90



Amazon Simple Queue Service Guia do desenvolvedorAlteração do tempo limite de visibilidade de uma mensagem

em seguida, contanto que o consumidor ainda trabalhe na mensagem, continue estendendo o tempo limitede visibilidade em 2 minutos a cada minuto.

Alteração do tempo limite de visibilidade de umamensagemQuando você recebe uma mensagem de uma fila e começa a processá-la, o tempo limite de visibilidadepara a fila pode ser insuficiente (por exemplo, você pode precisar processar e excluir uma mensagem).Você pode reduzir ou estender a visibilidade da mensagem especificando um novo valor de tempo limiteusando a ação ChangeMessageVisibility.

Por exemplo, se o tempo limite padrão de uma fila é 60 segundos, 15 segundos tiverem decorridodesde que você recebeu a mensagem, e você enviar uma chamada ChangeMessageVisibilitycom VisibilityTimeout definido como 10 segundos, os 10 segundos começam a contar a partir domomento em que você faz a chamada ChangeMessageVisibility. Portanto, qualquer tentativa dealterar o tempo limite de visibilidade ou excluir essa mensagem 10 segundos após inicialmente alterar otempo limite de visibilidade (um total de 25 segundos) pode resultar em um erro.

Note

O novo tempo limite entra em vigor quando você chama a ação ChangeMessageVisibility.Além disso, o novo tempo limite se aplica apenas ao recebimento específico da mensagem.ChangeMessageVisibility não afeta o tempo limite de recebimentos posteriores damensagem ou de filas posteriores.

Término do tempo limite de visibilidade de umamensagemQuando recebe uma mensagem de uma fila, você pode descobrir que realmente não quer processar eexcluir essa mensagem. O Amazon SQS permite que você encerre o tempo limite de visibilidade para umamensagem específica. Isso torna a mensagem imediatamente visível para outros componentes no sistemae disponível para processamento.

Para terminar o tempo limite de visibilidade de uma mensagem depois de chamar ReceiveMessage,chame ChangeMessageVisibility com VisibilityTimeout definido como 0 segundos.

Filas de atraso do Amazon SQSAs filas de atraso permitem adiar a entrega de novas mensagens para uma fila por alguns segundos.Se você criar uma fila de atraso, quaisquer mensagens enviadas para essa fila permanecem invisíveispara os consumidores durante o período de atraso. The minimum delay for a queue is 0 seconds.The maximum is 15 minutes. Para obter informações sobre como configurar filas de atraso usando oConsole de gerenciamento da AWS ou o AWS SDK for Java (e a ação SetQueueAttributes), consulteConfiguração de uma fila de atraso (p. 63).

Note

Para filas padrão, a configuração de atraso por fila não é retroativa — a alteração da definiçãonão afeta o atraso de mensagens que já estão na fila.Para filas FIFO, a configuração de atraso por fila é retroativa — a alteração da configuração afetao atraso de mensagens que já estão na fila.

As filas de atraso são semelhantes a tempos limite de visibilidade (p. 89), pois os dois recursos tornamas mensagens indisponíveis para os consumidores por um período específico. A diferença entre os doisé que, para filas de atraso, uma mensagem é ocultada quando é adicionada à fila pela primeira vez,

91




Amazon Simple Queue Service Guia do desenvolvedorTemporizadores de mensagem

enquanto que para os tempos limite de visibilidade uma mensagem é ocultada somente depois que amensagem é consumida na fila. O diagrama a seguir ilustra a relação entre filas de atraso e os temposlimite de visibilidade.

Para definir segundos de atraso em mensagens individuais, em vez de em uma fila inteira, usetemporizadores de mensagem (p. 92) para permitir que o Amazon SQS use o valor DelaySeconds dotemporizador de mensagem em vez do valor DelaySeconds da fila.

Temporizadores de mensagem do Amazon SQSOs temporizadores de mensagem permitem que você especifique um período de invisibilidade inicial deuma mensagem adicionada à uma fila. Por exemplo, se você enviar uma mensagem com um temporizadorde 45 segundos, a mensagem não fica visível aos consumidores pelos primeiros 45 segundos na fila.O padrão é 0 segundos. Para obter informações sobre como enviar mensagens com temporizadoresusando o Console de gerenciamento da AWS ou o AWS SDK for Java (e a ação SetQueueAttributes),consulte Envio de uma mensagem com um temporizador a uma fila (p. 36).

Note

As filas FIFO não são compatíveis com temporizadores em mensagens individuais.

Para definir um período de atraso em uma fila inteira, em vez de mensagens individuais, use filas deatraso (p. 91). Uma configuração de temporizador de mensagem para uma mensagem individualsubstitui qualquer valor DelaySeconds em uma fila de atraso do Amazon SQS.

Gerenciamento de mensagens grandes do AmazonSQS usando o Amazon S3

Você usa o Amazon S3 e o Biblioteca de cliente estendida do Amazon SQS para Java para gerenciarmensagens do Amazon SQS. Isso é especialmente útil para armazenar e consumir mensagens com até 2GB de tamanho. A menos que o aplicativo exija repetidamente a criação de filas deixando-as inativas ouarmazenando grandes quantidades de dados na fila, considere usar o Amazon S3 para armazenar seusdados.

Você pode usar a biblioteca do Biblioteca de cliente estendida do Amazon SQS para Java para fazer oseguinte:

• Especificar se as mensagens são sempre armazenadas no Amazon S3 ou apenas quando umamensagem tiver mais de 256 KB.

• Enviar uma mensagem que faça referência a um único objeto de mensagem armazenado em um bucketdo Amazon S3.

• Obter o objeto de mensagem correspondente em um bucket do Amazon S3.• Excluir o objeto de mensagem correspondente de um bucket do Amazon S3.

92


Amazon Simple Queue Service Guia do desenvolvedorJava funcional de exemplo para usar o Amazon S3

Note

The SDK para Java and Biblioteca de cliente estendida do Amazon SQS para Java require theJ2SE Development Kit 8.0 or later.Você usa o Biblioteca de cliente estendida do Amazon SQS para Java para gerenciar mensagensdo Amazon SQS usando o Amazon S3. No entanto, você não pode fazer isso usando a AWS CLI,o console do Amazon SQS, a API HTTP do Amazon SQS ou qualquer um dos SDKs da AWS —com exceção do SDK para Java.

Java funcional de exemplo para usar o Amazon S3para mensagens grandes do Amazon SQSPré-requisitosAdicione os pacotes amazon-sqs-java-extended-client-lib.jar, aws-java-sdk-sqs.jar eaws-java-sdk-s3.jar ao caminho da classe Java. O exemplo a seguir mostra essas dependências emum arquivo pom.xml do projeto Maven.

<dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>amazon-sqs-java-extended-client-lib</artifactId> <version>1.0.1</version> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-sqs</artifactId> <version>LATEST</version> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-s3</artifactId> <version>LATEST</version> </dependency></dependencies>

SQSExtendedClientExample.javaEste código de exemplo cria um bucket do Amazon S3 com um nome aleatório e adiciona uma regrade ciclo de vida para excluir permanentemente objetos após 14 dias. Em seguida, o código cria uma filachamada MyQueue e envia uma mensagem aleatória com mais de 256 KB de tamanho para a fila; amensagem é armazenada no bucket do Amazon S3. Por fim, o código consome a mensagem, retornainformações sobre a mensagem e exclui a mensagem, a fila e o bucket.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. *

93

https://aws.amazon.com/sdkforjava/


*/

import com.amazon.sqs.javamessaging.AmazonSQSExtendedClient;import com.amazon.sqs.javamessaging.ExtendedClientConfiguration;import com.amazonaws.services.s3.AmazonS3;import com.amazonaws.services.s3.AmazonS3ClientBuilder;import com.amazonaws.services.s3.model.*;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.*;import org.joda.time.DateTime;import org.joda.time.format.DateTimeFormat;

import java.util.Arrays;import java.util.List;import java.util.UUID;

public class SQSExtendedClientExample {

// Create an Amazon S3 bucket with a random name. private final static String S3_BUCKET_NAME = UUID.randomUUID() + "-" + DateTimeFormat.forPattern("yyMMdd-hhmmss").print(new DateTime());

public static void main(String[] args) {

/* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see * Creating Service Clients in the AWS SDK for Java Developer Guide. */ final AmazonS3 s3 = AmazonS3ClientBuilder.defaultClient();

/* * Set the Amazon S3 bucket name, and then set a lifecycle rule on the * bucket to permanently delete objects 14 days after each object's * creation date. */ final BucketLifecycleConfiguration.Rule expirationRule = new BucketLifecycleConfiguration.Rule(); expirationRule.withExpirationInDays(14).withStatus("Enabled"); final BucketLifecycleConfiguration lifecycleConfig = new BucketLifecycleConfiguration().withRules(expirationRule);

// Create the bucket and allow message objects to be stored in the bucket. s3.createBucket(S3_BUCKET_NAME); s3.setBucketLifecycleConfiguration(S3_BUCKET_NAME, lifecycleConfig); System.out.println("Bucket created and configured.");

/* * Set the Amazon SQS extended client configuration with large payload * support enabled. */ final ExtendedClientConfiguration extendedClientConfig = new ExtendedClientConfiguration() .withLargePayloadSupportEnabled(s3, S3_BUCKET_NAME);

final AmazonSQS sqsExtended = new AmazonSQSExtendedClient(AmazonSQSClientBuilder .defaultClient(), extendedClientConfig);

/* * Create a long string of characters for the message object which will * be stored in the bucket. */ int stringLength = 300000; char[] chars = new char[stringLength];

94

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/creating-clients.html


Arrays.fill(chars, 'x'); final String myLongString = new String(chars);

// Create a message queue for this example. final String QueueName = "MyQueue" + UUID.randomUUID().toString(); final CreateQueueRequest createQueueRequest = new CreateQueueRequest(QueueName); final String myQueueUrl = sqsExtended .createQueue(createQueueRequest).getQueueUrl(); System.out.println("Queue created.");

// Send the message. final SendMessageRequest myMessageRequest = new SendMessageRequest(myQueueUrl, myLongString); sqsExtended.sendMessage(myMessageRequest); System.out.println("Sent the message.");

// Receive the message. final ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(myQueueUrl); List<Message> messages = sqsExtended .receiveMessage(receiveMessageRequest).getMessages();

// Print information about the message. for (Message message : messages) { System.out.println("\nMessage received."); System.out.println(" ID: " + message.getMessageId()); System.out.println(" Receipt handle: " + message.getReceiptHandle()); System.out.println(" Message body (first 5 characters): " + message.getBody().substring(0, 5)); }

// Delete the message, the queue, and the bucket. final String messageReceiptHandle = messages.get(0).getReceiptHandle(); sqsExtended.deleteMessage(new DeleteMessageRequest(myQueueUrl, messageReceiptHandle)); System.out.println("Deleted the message.");

sqsExtended.deleteQueue(new DeleteQueueRequest(myQueueUrl)); System.out.println("Deleted the queue.");

deleteBucketAndAllContents(s3); System.out.println("Deleted the bucket."); }

private static void deleteBucketAndAllContents(AmazonS3 client) {

ObjectListing objectListing = client.listObjects(S3_BUCKET_NAME);

while (true) { for (S3ObjectSummary objectSummary : objectListing .getObjectSummaries()) { client.deleteObject(S3_BUCKET_NAME, objectSummary.getKey()); }

if (objectListing.isTruncated()) { objectListing = client.listNextBatchOfObjects(objectListing); } else { break; } }

final VersionListing list = client.listVersions( new ListVersionsRequest().withBucketName(S3_BUCKET_NAME));

for (S3VersionSummary s : list.getVersionSummaries()) {

95

Amazon Simple Queue Service Guia do desenvolvedorComo trabalhar com o JMS

client.deleteVersion(S3_BUCKET_NAME, s.getKey(), s.getVersionId()); }

client.deleteBucket(S3_BUCKET_NAME); }}

Como trabalhar com o JMS e o Amazon SQSO Amazon SQS Biblioteca do Sistema de mensagens Java é uma interface do JMS para o Amazon SQSque permite tirar proveito do Amazon SQS em aplicativos que já usam o JMS. A interface permite que vocêuse o Amazon SQS como o provedor de JMS com o mínimo de alterações de código. Junto com o AWSSDK for Java, a Biblioteca de mensagens Java do Amazon SQS permite criar conexões e sessões JMS,bem como produtores e consumidores que enviam e recebem mensagens de e para filas do Amazon SQS.

A biblioteca oferece suporte ao envio e recebimento de mensagens para uma fila (o modelo ponto a pontoJMS) de acordo com a especificação JMS 1.1. A biblioteca oferece suporte ao envio de mensagens detexto, de byte ou de objeto de forma síncrona para filas do Amazon SQS. A biblioteca também dá suporteao recebimento de objetos de forma síncrona ou assíncrona.

Para obter informações sobre os recursos da Amazon SQS Biblioteca do Sistema de mensagens Javaque oferecem suporte ao JMS 1.1, consulte Suporte para implementações do JMS 1.1 (p. 117) e asPerguntas frequentes do Amazon SQS.

Tópicos• Pré-requisitos (p. 96)• Conceitos básicos do Amazon SQS Biblioteca do Sistema de mensagens Java (p. 97)• Uso do Cliente Java Message Service (JMS) Amazon SQS com outros clientes do Amazon

SQS (p. 102)• Exemplo funcional de Java para uso do JMS com filas Padrão do Amazon SQS (p. 103)• Suporte para implementações do JMS 1.1 (p. 117)

Pré-requisitosAntes de começar, você deve cumprir os seguintes pré-requisitos:

• SDK para Java

Há duas maneiras de incluir o SDK para Java em seu projeto:• Fazer download e instalar o SDK para Java.• Usar o Maven para obter o Amazon SQS Biblioteca do Sistema de mensagens Java.

Note

O SDK para Java é incluído como uma dependência.The SDK para Java and Biblioteca de cliente estendida do Amazon SQS para Java requirethe J2SE Development Kit 8.0 or later.

Para obter informações sobre como fazer download do SDK para Java, consulte SDK para Java.• Amazon SQS Biblioteca do Sistema de mensagens Java

Se você não usar o Maven, é necessário adicionar o pacote amazon-sqs-java-messaging-lib.jarao caminho da classe Java. Para obter informações sobre como fazer download da biblioteca, consulteAmazon SQS Biblioteca do Sistema de mensagens Java.

96

http://docs.oracle.com/javaee/6/api/javax/jms/package-summary.html

sqs/faqs/


sdkforjava/

https://github.com/awslabs/amazon-sqs-java-messaging-lib

Amazon Simple Queue Service Guia do desenvolvedorConceitos básicos do Bibliotecado Sistema de mensagens Java

Note

A Amazon SQS Biblioteca do Sistema de mensagens Java inclui suporte para o Maven e oSpring Framework.Para obter exemplos de código que usam o Maven, o Spring Framework e a Amazon SQSBiblioteca do Sistema de mensagens Java, consulte Exemplo funcional de Java para uso doJMS com filas Padrão do Amazon SQS (p. 103).

<dependency> <groupId>com.amazonaws</groupId> <artifactId>amazon-sqs-java-messaging-lib</artifactId> <version>1.0.4</version> <type>jar</type></dependency>

• Fila do Amazon SQS

Crie uma fila usando o Console de gerenciamento da AWS do Amazon SQS, a API CreateQueue ou ocliente do Amazon SQS encapsulado incluído na Biblioteca de mensagens Java do Amazon SQS.• Para obter informações sobre como criar uma fila com o Amazon SQS usando o Console de

gerenciamento da AWS ou a API CreateQueue, consulte Criação de uma fila (p. 16).• Para obter informações sobre como usar a Amazon SQS Biblioteca do Sistema de mensagens Java,

consulte Conceitos básicos do Amazon SQS Biblioteca do Sistema de mensagens Java (p. 97).

Conceitos básicos do Amazon SQS Biblioteca doSistema de mensagens JavaPara começar a usar o JMS com o Amazon SQS, use os exemplos de código desta seção. As seções aseguir mostram como criar uma conexão e uma sessão JMS, e como enviar e receber uma mensagem.

O objeto de cliente encapsulado do Amazon SQS incluído na Amazon SQS Biblioteca do Sistema demensagens Java verifica se existe uma fila do Amazon SQS. Se a fila não existir, o cliente a criará.

Criação de uma conexão JMS1. Crie uma connection factory e chame o método createConnection contra a factory.

// Create a new connection factory with all defaults (credentials and region) set automaticallySQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.defaultClient() ); // Create the connection.SQSConnection connection = connectionFactory.createConnection();

A classe SQSConnection estende javax.jms.Connection. Junto com os métodos de conexãoJMS padrão, SQSConnection oferece métodos adicionais, como getAmazonSQSClient egetWrappedAmazonSQSClient. Os dois métodos permitem que você execute operaçõesadministrativas não incluídas na especificação JMS, como a criação de novas filas. Contudo, ométodo getWrappedAmazonSQSClient também fornece uma versão encapsulada do cliente doAmazon SQS usada pela conexão atual. O wrapper transforma cada exceção de um cliente em umJMSException, permitindo que ele seja mais facilmente usado pelo código existente que esperaocorrências de JMSException.

97

http://maven.apache.org/

http://projects.spring.io/spring-framework/


2. Você pode usar objetos de cliente retornados de getAmazonSQSClient e degetWrappedAmazonSQSClient para executar operações administrativas não incluídas naespecificação JMS (por exemplo, você pode criar uma fila do Amazon SQS).

Se você tiver um código que espera exceções JMS, deve usar getWrappedAmazonSQSClient:

• Se você usar getWrappedAmazonSQSClient, o objeto de cliente retornado transformará todas asexceções em exceções JMS.

• Se você usar getAmazonSQSClient, todas as exceções serão exceções do Amazon SQS.

Criação de uma fila do Amazon SQSO objeto de cliente encapsulado verifica se existe uma fila do Amazon SQS.

Se a fila não existir, o cliente a criará. Se a fila existir, a função não retornará nada. Paraobter mais informações, consulte a seção "Criar uma fila, se necessário" no exemploTextMessageSender.java (p. 105).

Para criar uma fila padrão

// Get the wrapped clientAmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient(); // Create an SQS queue named MyQueue, if it doesn't already existif (!client.queueExists("MyQueue")) { client.createQueue("MyQueue");}

Para criar uma fila FIFO

// Get the wrapped clientAmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();

// Create an Amazon SQS FIFO queue named MyQueue.fifo, if it doesn't already existif (!client.queueExists("MyQueue.fifo")) { Map<String, String> attributes = new HashMap<String, String>(); attributes.put("FifoQueue", "true"); attributes.put("ContentBasedDeduplication", "true"); client.createQueue(new CreateQueueRequest().withQueueName("MyQueue.fifo").withAttributes(attributes));}

Note

O nome de uma fila FIFO deve terminar com o sufixo .fifo.Para obter mais informações sobre o atributo ContentBasedDeduplication, consulteProcessamento exatamente uma vez (p. 75).

Envio de mensagens de forma síncrona1. Quando a conexão e a fila do Amazon SQS subjacente estiverem prontas, crie uma sessão JMS sem

transação com o modo AUTO_ACKNOWLEDGE.

// Create the nontransacted session with AUTO_ACKNOWLEDGE modeSession session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

98


2. Para enviar uma mensagem de texto para a fila, crie uma identidade de fila JMS e um produtor demensagem.

// Create a queue identity and specify the queue name to the sessionQueue queue = session.createQueue("MyQueue"); // Create a producer for the 'MyQueue'MessageProducer producer = session.createProducer(queue);

3. Crie uma mensagem de texto e envie-a para a fila.

• Para enviar uma mensagem a uma fila padrão, você não precisa definir nenhum parâmetroadicional.

// Create the text messageTextMessage message = session.createTextMessage("Hello World!"); // Send the messageproducer.send(message);System.out.println("JMS Message " + message.getJMSMessageID());

• Para enviar uma mensagem a uma fila FIFO, você deve definir o ID do grupo de mensagens.Você também pode definir um ID de eliminação de duplicação de mensagem. Para obter maisinformações, consulte Termos-chave (p. 74).

// Create the text messageTextMessage message = session.createTextMessage("Hello World!");

// Set the message group IDmessage.setStringProperty("JMSXGroupID", "Default");

// You can also set a custom message deduplication ID// message.setStringProperty("JMS_SQS_DeduplicationId", "hello");// Here, it's not needed because content-based deduplication is enabled for the queue

// Send the messageproducer.send(message);System.out.println("JMS Message " + message.getJMSMessageID());System.out.println("JMS Message Sequence Number " + message.getStringProperty("JMS_SQS_SequenceNumber"));

Recebimento de mensagens de forma síncrona1. Para receber mensagens, crie um consumidor para a mesma fila e invoque o método start.

Você também pode chamar o método start na conexão a qualquer momento. No entanto, oconsumidor não começa a receber mensagens até você chamá-lo.

// Create a consumer for the 'MyQueue'MessageConsumer consumer = session.createConsumer(queue);// Start receiving incoming messagesconnection.start();

2. Chame o método receive no consumidor com um tempo limite definido como 1 segundo e imprima oconteúdo da mensagem recebida.

• Após receber uma mensagem de uma fila padrão, você pode acessar o conteúdo da mensagem.

// Receive a message from 'MyQueue' and wait up to 1 second

99


Message receivedMessage = consumer.receive(1000); // Cast the received message as TextMessage and display the textif (receivedMessage != null) { System.out.println("Received: " + ((TextMessage) receivedMessage).getText());}

• Após receber uma mensagem de uma fila FIFO, você pode acessar o conteúdo da mensagem eoutros atributos de mensagem específicos ao FIFO, como o ID do grupo de mensagens, o ID deeliminação de duplicação de mensagem e o número de sequência. Para obter mais informações,consulte Termos-chave (p. 74).

// Receive a message from 'MyQueue' and wait up to 1 secondMessage receivedMessage = consumer.receive(1000);

// Cast the received message as TextMessage and display the textif (receivedMessage != null) { System.out.println("Received: " + ((TextMessage) receivedMessage).getText()); System.out.println("Group id: " + receivedMessage.getStringProperty("JMSXGroupID")); System.out.println("Message deduplication id: " + receivedMessage.getStringProperty("JMS_SQS_DeduplicationId")); System.out.println("Message sequence number: " + receivedMessage.getStringProperty("JMS_SQS_SequenceNumber"));}

3. Feche a conexão e a sessão.

// Close the connection (and the session).connection.close();

A saída será semelhante à seguinte:

JMS Message ID:8example-588b-44e5-bbcf-d816example2Received: Hello World!

Note

Você pode usar o Spring Framework para inicializar esses objetos.Para obter mais informações, consulte SpringExampleConfiguration.xml,SpringExample.java e as outras classes auxiliares em ExampleConfiguration.java eExampleCommon.java na seção Exemplo funcional de Java para uso do JMS com filas Padrãodo Amazon SQS (p. 103).

Para exemplos completos de envio e recebimento de objetos, consulte TextMessageSender.java (p. 105)e SyncMessageReceiver.java (p. 106).

Recebimento de mensagens de forma assíncronaNo exemplo em Conceitos básicos do Amazon SQS Biblioteca do Sistema de mensagens Java (p. 97),uma mensagem é enviada para MyQueue e recebida de forma síncrona.

O exemplo a seguir mostra como receber as mensagens de forma assíncrona por meio de um listener.

1. Implemente a interface MessageListener.

class MyListener implements MessageListener { @Override

100


public void onMessage(Message message) { try { // Cast the received message as TextMessage and print the text to screen. System.out.println("Received: " + ((TextMessage) message).getText()); } catch (JMSException e) { e.printStackTrace(); } }}

O método onMessage da interface MessageListener é chamado quando você recebe umamensagem. Nesta implementação de listener, o texto armazenado na mensagem é impresso.

2. Em vez de explicitamente chamar o método receive no consumidor, defina o listener da mensagemdo consumidor como uma instância da implementação MyListener. O thread principal aguarda umsegundo.

// Create a consumer for the 'MyQueue'.MessageConsumer consumer = session.createConsumer(queue); // Instantiate and set the message listener for the consumer.consumer.setMessageListener(new MyListener()); // Start receiving incoming messages.connection.start(); // Wait for 1 second. The listener onMessage() method is invoked when a message is received.Thread.sleep(1000);

As demais etapas são idênticas às do exemplo Conceitos básicos do Amazon SQS Biblioteca do Sistemade mensagens Java (p. 97). Para um exemplo completo de um consumidor assíncrono, consulteAsyncMessageReceiver.java em Exemplo funcional de Java para uso do JMS com filas Padrão doAmazon SQS (p. 103).

A saída deste exemplo é similar ao seguinte:

JMS Message ID:8example-588b-44e5-bbcf-d816example2Received: Hello World!

Uso do modo de reconhecimento do clienteO exemplo em Conceitos básicos do Amazon SQS Biblioteca do Sistema de mensagens Java (p. 97)usa o modo AUTO_ACKNOWLEDGE onde cada mensagem recebida é confirmada automaticamente (e,portanto, excluída da fila do Amazon SQS subjacente).

1. Para explicitamente reconhecer as mensagens depois de processadas, você deve criar a sessão como modo CLIENT_ACKNOWLEDGE.

// Create the non-transacted session with CLIENT_ACKNOWLEDGE mode.Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);

2. Quando a mensagem é recebida, exiba-a e confirme-a explicitamente.

// Cast the received message as TextMessage and print the text to screen. Also acknowledge the message.if (receivedMessage != null) { System.out.println("Received: " + ((TextMessage) receivedMessage).getText()); receivedMessage.acknowledge();

101

Amazon Simple Queue Service Guia do desenvolvedorUso do Cliente JMS com outros clientes do Amazon SQS

System.out.println("Acknowledged: " + message.getJMSMessageID());}

Note

Nesse modo, quando uma mensagem é confirmada, todas as mensagens recebidas antesdesta mensagem são implicitamente confirmadas. Por exemplo, se 10 mensagens sãorecebidas e apenas a 10ª mensagem é reconhecida (na ordem em que as mensagens sãorecebidas), todas as nove mensagens anteriores também são reconhecidas.

As demais etapas são idênticas às do exemplo Conceitos básicos do Amazon SQS Biblioteca do Sistemade mensagens Java (p. 97). Para um exemplo completo de um consumidor síncrono com modo dereconhecimento do cliente, consulte SyncMessageReceiverClientAcknowledge.java em Exemplofuncional de Java para uso do JMS com filas Padrão do Amazon SQS (p. 103).

A saída deste exemplo é similar ao seguinte:

JMS Message ID:4example-aa0e-403f-b6df-5e02example5Received: Hello World!Acknowledged: ID:4example-aa0e-403f-b6df-5e02example5

Uso do modo de reconhecimento não ordenadoAo usar o modo CLIENT_ACKNOWLEDGE, todas as mensagens recebidas antes de uma mensagemexplicitamente reconhecida são automaticamente reconhecidas. Para obter mais informações, consulteUso do modo de reconhecimento do cliente (p. 101).

A Amazon SQS Biblioteca do Sistema de mensagens Java fornece outro modo de confirmação. Ao usar omodo UNORDERED_ACKNOWLEDGE, todas as mensagens recebidas devem ser individual e explicitamentereconhecidas pelo cliente, independentemente de sua ordem de recebimento. Para fazer isso, cria umasessão com o modo UNORDERED_ACKNOWLEDGE.

// Create the non-transacted session with UNORDERED_ACKNOWLEDGE mode.Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE);

As etapas restantes são idênticas às do exemplo Uso do modo de reconhecimento do cliente (p. 101).Para um exemplo completo de um consumidor síncrono com o modo UNORDERED_ACKNOWLEDGE,consulte SyncMessageReceiverUnorderedAcknowledge.java.

Neste exemplo, a saída é similar ao seguinte:

JMS Message ID:dexample-73ad-4adb-bc6c-4357example7Received: Hello World!Acknowledged: ID:dexample-73ad-4adb-bc6c-4357example7

Uso do Cliente Java Message Service (JMS) AmazonSQS com outros clientes do Amazon SQSO uso do Cliente Java Message Service (JMS) Amazon SQS com o SDK do AWS limita o tamanhodas mensagens do Amazon SQS a 256 KB. No entanto, você pode criar um provedor JMS usandoqualquer cliente do Amazon SQS. Por exemplo, você pode usar o Cliente JMS com o Biblioteca de clienteestendida do Amazon SQS para Java para enviar uma mensagem do Amazon SQS que contenha umareferência à carga de uma mensagem (até 2 GB) no Amazon S3. Para obter mais informações, consulteGerenciamento de mensagens grandes do Amazon SQS usando o Amazon S3 (p. 92).

102

Amazon Simple Queue Service Guia do desenvolvedorExemplo funcional de Java para uso doJMS com filas Padrão do Amazon SQS

O exemplo de código Java a seguir cria o provedor JMS para o Biblioteca de cliente estendida:

AmazonS3 s3 = new AmazonS3Client(credentials);Region s3Region = Region.getRegion(Regions.US_WEST_2);s3.setRegion(s3Region); // Set the Amazon S3 bucket name, and set a lifecycle rule on the bucket to// permanently delete objects a certain number of days after each object's creation date.// Next, create the bucket, and enable message objects to be stored in the bucket.BucketLifecycleConfiguration.Rule expirationRule = new BucketLifecycleConfiguration.Rule();expirationRule.withExpirationInDays(14).withStatus("Enabled");BucketLifecycleConfiguration lifecycleConfig = new BucketLifecycleConfiguration().withRules(expirationRule); s3.createBucket(s3BucketName);s3.setBucketLifecycleConfiguration(s3BucketName, lifecycleConfig);System.out.println("Bucket created and configured.");

// Set the SQS extended client configuration with large payload support enabled.ExtendedClientConfiguration extendedClientConfig = new ExtendedClientConfiguration() .withLargePayloadSupportEnabled(s3, s3BucketName); AmazonSQS sqsExtended = new AmazonSQSExtendedClient(new AmazonSQSClient(credentials), extendedClientConfig);Region sqsRegion = Region.getRegion(Regions.US_WEST_2);sqsExtended.setRegion(sqsRegion);

O exemplo de código Java a seguir cria a connection factory:

// Create the connection factory using the environment variable credential provider.// Pass the configured Amazon SQS Extended Client to the JMS connection factory.SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), sqsExtended ); // Create the connection.SQSConnection connection = connectionFactory.createConnection();

Exemplo funcional de Java para uso do JMS com filasPadrão do Amazon SQSOs exemplos de código a seguir mostram como usar JMS com filas padrão do Amazon SQS. Para obtermais informações sobre como trabalhar com filas FIFO, consulte Para criar uma fila FIFO (p. 98), Enviode mensagens de forma síncrona (p. 98) e Recebimento de mensagens de forma síncrona (p. 99). Orecebimento de mensagens de forma síncrona é igual para filas padrão e FIFO. No entanto, as mensagensem filas FIFO contêm mais atributos.

ExampleConfiguration.javaO seguinte exemplo de código Java define o nome de fila padrão, a região e as credenciais a seremusadas com outros exemplos de Java.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at

103


* * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */

public class ExampleConfiguration { public static final String DEFAULT_QUEUE_NAME = "SQSJMSClientExampleQueue"; public static final Region DEFAULT_REGION = Region.getRegion(Regions.US_EAST_2); private static String getParameter( String args[], int i ) { if( i + 1 >= args.length ) { throw new IllegalArgumentException( "Missing parameter for " + args[i] ); } return args[i+1]; } /** * Parse the command line and return the resulting config. If the config parsing fails * print the error and the usage message and then call System.exit * * @param app the app to use when printing the usage string * @param args the command line arguments * @return the parsed config */ public static ExampleConfiguration parseConfig(String app, String args[]) { try { return new ExampleConfiguration(args); } catch (IllegalArgumentException e) { System.err.println( "ERROR: " + e.getMessage() ); System.err.println(); System.err.println( "Usage: " + app + " [--queue <queue>] [--region <region>] [--credentials <credentials>] "); System.err.println( " or" ); System.err.println( " " + app + " <spring.xml>" ); System.exit(-1); return null; } } private ExampleConfiguration(String args[]) { for( int i = 0; i < args.length; ++i ) { String arg = args[i]; if( arg.equals( "--queue" ) ) { setQueueName(getParameter(args, i)); i++; } else if( arg.equals( "--region" ) ) { String regionName = getParameter(args, i); try { setRegion(Region.getRegion(Regions.fromName(regionName))); } catch( IllegalArgumentException e ) { throw new IllegalArgumentException( "Unrecognized region " + regionName ); } i++; } else if( arg.equals( "--credentials" ) ) { String credsFile = getParameter(args, i); try { setCredentialsProvider( new PropertiesFileCredentialsProvider(credsFile) ); } catch (AmazonClientException e) {

104


throw new IllegalArgumentException("Error reading credentials from " + credsFile, e ); } i++; } else { throw new IllegalArgumentException("Unrecognized option " + arg); } } } private String queueName = DEFAULT_QUEUE_NAME; private Region region = DEFAULT_REGION; private AWSCredentialsProvider credentialsProvider = new DefaultAWSCredentialsProviderChain(); public String getQueueName() { return queueName; } public void setQueueName(String queueName) { this.queueName = queueName; } public Region getRegion() { return region; } public void setRegion(Region region) { this.region = region; } public AWSCredentialsProvider getCredentialsProvider() { return credentialsProvider; } public void setCredentialsProvider(AWSCredentialsProvider credentialsProvider) { // Make sure they're usable first credentialsProvider.getCredentials(); this.credentialsProvider = credentialsProvider; }}

TextMessageSender.javaO seguinte exemplo de código Java cria um produtor de mensagem de texto.


public class TextMessageSender { public static void main(String args[]) throws JMSException {

105


ExampleConfiguration config = ExampleConfiguration.parseConfig("TextMessageSender", args); ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection(); // Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer producer = session.createProducer( session.createQueue( config.getQueueName() ) ); sendMessages(session, producer); // Close the connection. This closes the session automatically connection.close(); System.out.println( "Connection closed" ); } private static void sendMessages( Session session, MessageProducer producer ) { BufferedReader inputReader = new BufferedReader( new InputStreamReader( System.in, Charset.defaultCharset() ) ); try { String input; while( true ) { System.out.print( "Enter message to send (leave empty to exit): " ); input = inputReader.readLine(); if( input == null || input.equals("" ) ) break; TextMessage message = session.createTextMessage(input); producer.send(message); System.out.println( "Send message " + message.getJMSMessageID() ); } } catch (EOFException e) { // Just return on EOF } catch (IOException e) { System.err.println( "Failed reading input: " + e.getMessage() ); } catch (JMSException e) { System.err.println( "Failed sending message: " + e.getMessage() ); e.printStackTrace(); } }}

SyncMessageReceiver.javaO seguinte exemplo de código Java cria um consumidor de mensagem síncrona.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. *

106


* Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */

public class SyncMessageReceiver {public static void main(String args[]) throws JMSException { ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiver", args); ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection(); // Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer( session.createQueue( config.getQueueName() ) );

connection.start(); receiveMessages(session, consumer);

// Close the connection. This closes the session automatically connection.close(); System.out.println( "Connection closed" );}

private static void receiveMessages( Session session, MessageConsumer consumer ) { try { while( true ) { System.out.println( "Waiting for messages"); // Wait 1 minute for a message Message message = consumer.receive(TimeUnit.MINUTES.toMillis(1)); if( message == null ) { System.out.println( "Shutting down after 1 minute of silence" ); break; } ExampleCommon.handleMessage(message); message.acknowledge(); System.out.println( "Acknowledged message " + message.getJMSMessageID() ); } } catch (JMSException e) { System.err.println( "Error receiving from SQS: " + e.getMessage() ); e.printStackTrace(); }

107


}}

AsyncMessageReceiver.javaO seguinte exemplo de código Java cria um consumidor de mensagem assíncrona.


public class AsyncMessageReceiver { public static void main(String args[]) throws JMSException, InterruptedException { ExampleConfiguration config = ExampleConfiguration.parseConfig("AsyncMessageReceiver", args); ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection(); // Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer( session.createQueue( config.getQueueName() ) ); ReceiverCallback callback = new ReceiverCallback(); consumer.setMessageListener( callback );

// No messages are processed until this is called connection.start(); callback.waitForOneMinuteOfSilence(); System.out.println( "Returning after one minute of silence" );

// Close the connection. This closes the session automatically connection.close(); System.out.println( "Connection closed" ); }

108


private static class ReceiverCallback implements MessageListener { // Used to listen for message silence private volatile long timeOfLastMessage = System.nanoTime(); public void waitForOneMinuteOfSilence() throws InterruptedException { for(;;) { long timeSinceLastMessage = System.nanoTime() - timeOfLastMessage; long remainingTillOneMinuteOfSilence = TimeUnit.MINUTES.toNanos(1) - timeSinceLastMessage; if( remainingTillOneMinuteOfSilence < 0 ) { break; } TimeUnit.NANOSECONDS.sleep(remainingTillOneMinuteOfSilence); } }

@Override public void onMessage(Message message) { try { ExampleCommon.handleMessage(message); message.acknowledge(); System.out.println( "Acknowledged message " + message.getJMSMessageID() ); timeOfLastMessage = System.nanoTime(); } catch (JMSException e) { System.err.println( "Error processing message: " + e.getMessage() ); e.printStackTrace(); } } }}

SyncMessageReceiverClientAcknowledge.javaO seguinte exemplo de código Java cria um consumidor síncrono com modo de reconhecimento do cliente.


/** * An example class to demonstrate the behavior of CLIENT_ACKNOWLEDGE mode for received messages. This example * complements the example given in {@link SyncMessageReceiverUnorderedAcknowledge} for UNORDERED_ACKNOWLEDGE mode. * * First, a session, a message producer, and a message consumer are created. Then, two messages are sent. Next, two messages * are received but only the second one is acknowledged. After waiting for the visibility time out period, an attempt to * receive another message is made. It's shown that no message is returned for this attempt since in CLIENT_ACKNOWLEDGE mode,

109


* as expected, all the messages prior to the acknowledged messages are also acknowledged. * * This ISN'T the behavior for UNORDERED_ACKNOWLEDGE mode. Please see {@link SyncMessageReceiverUnorderedAcknowledge} * for an example. */public class SyncMessageReceiverClientAcknowledge { // Visibility time-out for the queue. It must match to the one set for the queue for this example to work. private static final long TIME_OUT_SECONDS = 1; public static void main(String args[]) throws JMSException, InterruptedException { // Create the configuration for the example ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiverClientAcknowledge", args); // Setup logging for the example ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection(); // Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session with client acknowledge mode Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); // Create the producer and consume MessageProducer producer = session.createProducer(session.createQueue(config.getQueueName())); MessageConsumer consumer = session.createConsumer(session.createQueue(config.getQueueName())); // Open the connection connection.start(); // Send two text messages sendMessage(producer, session, "Message 1"); sendMessage(producer, session, "Message 2"); // Receive a message and don't acknowledge it receiveMessage(consumer, false); // Receive another message and acknowledge it receiveMessage(consumer, true); // Wait for the visibility time out, so that unacknowledged messages reappear in the queue System.out.println("Waiting for visibility timeout..."); Thread.sleep(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS)); // Attempt to receive another message and acknowledge it. This results in receiving no messages since // we have acknowledged the second message. Although we didn't explicitly acknowledge the first message,

110


// in the CLIENT_ACKNOWLEDGE mode, all the messages received prior to the explicitly acknowledged message // are also acknowledged. Therefore, we have implicitly acknowledged the first message. receiveMessage(consumer, true); // Close the connection. This closes the session automatically connection.close(); System.out.println("Connection closed."); } /** * Sends a message through the producer. * * @param producer Message producer * @param session Session * @param messageText Text for the message to be sent * @throws JMSException */ private static void sendMessage(MessageProducer producer, Session session, String messageText) throws JMSException { // Create a text message and send it producer.send(session.createTextMessage(messageText)); } /** * Receives a message through the consumer synchronously with the default timeout (TIME_OUT_SECONDS). * If a message is received, the message is printed. If no message is received, "Queue is empty!" is * printed. * * @param consumer Message consumer * @param acknowledge If true and a message is received, the received message is acknowledged. * @throws JMSException */ private static void receiveMessage(MessageConsumer consumer, boolean acknowledge) throws JMSException { // Receive a message Message message = consumer.receive(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS)); if (message == null) { System.out.println("Queue is empty!"); } else { // Since this queue has only text messages, cast the message object and print the text System.out.println("Received: " + ((TextMessage) message).getText()); // Acknowledge the message if asked if (acknowledge) message.acknowledge(); } }}

SyncMessageReceiverUnorderedAcknowledge.javaO seguinte exemplo de código Java cria um consumidor síncrono com modo de reconhecimento nãoordenado.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License").

111


* You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */

/** * An example class to demonstrate the behavior of UNORDERED_ACKNOWLEDGE mode for received messages. This example * complements the example given in {@link SyncMessageReceiverClientAcknowledge} for CLIENT_ACKNOWLEDGE mode. * * First, a session, a message producer, and a message consumer are created. Then, two messages are sent. Next, two messages * are received but only the second one is acknowledged. After waiting for the visibility time out period, an attempt to * receive another message is made. It's shown that the first message received in the prior attempt is returned again * for the second attempt. In UNORDERED_ACKNOWLEDGE mode, all the messages must be explicitly acknowledged no matter what * the order they're received. * * This ISN'T the behavior for CLIENT_ACKNOWLEDGE mode. Please see {@link SyncMessageReceiverClientAcknowledge} * for an example. */public class SyncMessageReceiverUnorderedAcknowledge { // Visibility time-out for the queue. It must match to the one set for the queue for this example to work. private static final long TIME_OUT_SECONDS = 1; public static void main(String args[]) throws JMSException, InterruptedException { // Create the configuration for the example ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiverUnorderedAcknowledge", args); // Setup logging for the example ExampleCommon.setupLogging(); // Create the connection factory based on the config SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.standard() .withRegion(config.getRegion().getName()) .withCredentials(config.getCredentialsProvider()) ); // Create the connection SQSConnection connection = connectionFactory.createConnection(); // Create the queue if needed ExampleCommon.ensureQueueExists(connection, config.getQueueName()); // Create the session with unordered acknowledge mode Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE); // Create the producer and consume

112


MessageProducer producer = session.createProducer(session.createQueue(config.getQueueName())); MessageConsumer consumer = session.createConsumer(session.createQueue(config.getQueueName())); // Open the connection connection.start(); // Send two text messages sendMessage(producer, session, "Message 1"); sendMessage(producer, session, "Message 2"); // Receive a message and don't acknowledge it receiveMessage(consumer, false); // Receive another message and acknowledge it receiveMessage(consumer, true); // Wait for the visibility time out, so that unacknowledged messages reappear in the queue System.out.println("Waiting for visibility timeout..."); Thread.sleep(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS)); // Attempt to receive another message and acknowledge it. This results in receiving the first message since // we have acknowledged only the second message. In the UNORDERED_ACKNOWLEDGE mode, all the messages must // be explicitly acknowledged. receiveMessage(consumer, true); // Close the connection. This closes the session automatically connection.close(); System.out.println("Connection closed."); } /** * Sends a message through the producer. * * @param producer Message producer * @param session Session * @param messageText Text for the message to be sent * @throws JMSException */ private static void sendMessage(MessageProducer producer, Session session, String messageText) throws JMSException { // Create a text message and send it producer.send(session.createTextMessage(messageText)); } /** * Receives a message through the consumer synchronously with the default timeout (TIME_OUT_SECONDS). * If a message is received, the message is printed. If no message is received, "Queue is empty!" is * printed. * * @param consumer Message consumer * @param acknowledge If true and a message is received, the received message is acknowledged. * @throws JMSException */ private static void receiveMessage(MessageConsumer consumer, boolean acknowledge) throws JMSException { // Receive a message Message message = consumer.receive(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS));

113

if (message == null) { System.out.println("Queue is empty!"); } else { // Since this queue has only text messages, cast the message object and print the text System.out.println("Received: " + ((TextMessage) message).getText()); // Acknowledge the message if asked if (acknowledge) message.acknowledge(); } }}

SpringExampleConfiguration.xmlO seguinte exemplo de código XML é um arquivo de configuração bean paraSpringExample.java (p. 115).



<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd "> <bean id="CredentialsProviderBean" class="com.amazonaws.auth.DefaultAWSCredentialsProviderChain"/> <bean id="ClientBuilder" class="com.amazonaws.services.sqs.AmazonSQSClientBuilder" factory-method="standard"> <property name="region" value="us-east-2"/> <property name="credentials" ref="CredentialsProviderBean"/> </bean> <bean id="ProviderConfiguration" class="com.amazon.sqs.javamessaging.ProviderConfiguration"> <property name="numberOfMessagesToPrefetch" value="5"/> </bean> <bean id="ConnectionFactory" class="com.amazon.sqs.javamessaging.SQSConnectionFactory"> <constructor-arg ref="ProviderConfiguration" /> <constructor-arg ref="ClientBuilder" /> </bean>

114


<bean id="Connection" class="javax.jms.Connection" factory-bean="ConnectionFactory" factory-method="createConnection" init-method="start" destroy-method="close" /> <bean id="QueueName" class="java.lang.String"> <constructor-arg value="SQSJMSClientExampleQueue"/> </bean></beans>

SpringExample.javaO seguinte exemplo de código Java usa o arquivo de configuração bean para inicializar seus objetos.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. * */ public class SpringExample { public static void main(String args[]) throws JMSException { if( args.length != 1 || !args[0].endsWith(".xml")) { System.err.println( "Usage: " + SpringExample.class.getName() + " <spring config.xml>" ); System.exit(1); } File springFile = new File( args[0] ); if( !springFile.exists() || !springFile.canRead() ) { System.err.println( "File " + args[0] + " doesn't exist or isn't readable."); System.exit(2); } ExampleCommon.setupLogging(); FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext( "file://" + springFile.getAbsolutePath() ); Connection connection; try { connection = context.getBean(Connection.class); } catch( NoSuchBeanDefinitionException e ) { System.err.println( "Can't find the JMS connection to use: " + e.getMessage() ); System.exit(3); return; } String queueName; try {

115


queueName = context.getBean("QueueName", String.class); } catch( NoSuchBeanDefinitionException e ) { System.err.println( "Can't find the name of the queue to use: " + e.getMessage() ); System.exit(3); return; } if( connection instanceof SQSConnection ) { ExampleCommon.ensureQueueExists( (SQSConnection) connection, queueName ); } // Create the session Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer( session.createQueue( queueName) ); receiveMessages(session, consumer); // The context can be setup to close the connection for us context.close(); System.out.println( "Context closed" ); } private static void receiveMessages( Session session, MessageConsumer consumer ) { try { while( true ) { System.out.println( "Waiting for messages"); // Wait 1 minute for a message Message message = consumer.receive(TimeUnit.MINUTES.toMillis(1)); if( message == null ) { System.out.println( "Shutting down after 1 minute of silence" ); break; } ExampleCommon.handleMessage(message); message.acknowledge(); System.out.println( "Acknowledged message" ); } } catch (JMSException e) { System.err.println( "Error receiving from SQS: " + e.getMessage() ); e.printStackTrace(); } }}

ExampleCommon.javaO código de exemplo Java a seguir verifica se existe uma fila do Amazon SQS e, se não existir, cria uma.Ele também inclui código de registro de exemplo.

/* * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * https://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. *

116

Amazon Simple Queue Service Guia do desenvolvedorSuporte para implementações do JMS 1.1

*/

public class ExampleCommon { /** * A utility function to check the queue exists and create it if needed. For most * use cases this is usually done by an administrator before the application is run. */ public static void ensureQueueExists(SQSConnection connection, String queueName) throws JMSException { AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient(); /** * In most cases, you can do this with just a createQueue call, but GetQueueUrl * (called by queueExists) is a faster operation for the common case where the queue * already exists. Also many users and roles have permission to call GetQueueUrl * but don't have permission to call CreateQueue. */ if( !client.queueExists(queueName) ) { client.createQueue( queueName ); } } public static void setupLogging() { // Setup logging BasicConfigurator.configure(); Logger.getRootLogger().setLevel(Level.WARN); } public static void handleMessage(Message message) throws JMSException { System.out.println( "Got message " + message.getJMSMessageID() ); System.out.println( "Content: "); if( message instanceof TextMessage ) { TextMessage txtMessage = ( TextMessage ) message; System.out.println( "\t" + txtMessage.getText() ); } else if( message instanceof BytesMessage ){ BytesMessage byteMessage = ( BytesMessage ) message; // Assume the length fits in an int - SQS only supports sizes up to 256k so that // should be true byte[] bytes = new byte[(int)byteMessage.getBodyLength()]; byteMessage.readBytes(bytes); System.out.println( "\t" + Base64.encodeAsString( bytes ) ); } else if( message instanceof ObjectMessage ) { ObjectMessage objMessage = (ObjectMessage) message; System.out.println( "\t" + objMessage.getObject() ); } }}

Suporte para implementações do JMS 1.1O Amazon SQS Biblioteca do Sistema de mensagens Java oferece suporte às seguintes implementaçõesdo JMS 1.1. Para obter mais informações sobre os recursos e funcionalidades compatíveis do AmazonSQS Biblioteca do Sistema de mensagens Java, consulte as Perguntas frequentes do Amazon SQS.

Suporte para interfaces comuns• Connection

• ConnectionFactory

• Destination

117



sqs/faqs/

Amazon Simple Queue Service Guia do desenvolvedorSuporte para implementações do JMS 1.1

• Session

• MessageConsumer

• MessageProducer

Suporte para tipos de mensagem• ByteMessage

• ObjectMessage

• TextMessage

Suporte para modos de reconhecimento de mensagens• AUTO_ACKNOWLEDGE

• CLIENT_ACKNOWLEDGE

• DUPS_OK_ACKNOWLEDGE

• UNORDERED_ACKNOWLEDGE

Note

O modo UNORDERED_ACKNOWLEDGE não faz parte da especificação JMS 1.1. Esse modo ajuda oAmazon SQS a permitir que um cliente JMS reconheça explicitamente uma mensagem.

Cabeçalhos definidos pelo JMS e propriedades reservadasPara enviar mensagens

Ao enviar mensagens, você pode definir os seguintes cabeçalhos e propriedades para cada mensagem:

• JMSXGroupID (obrigatório para filas FIFO, não permitido para filas padrão)• JMS_SQS_DeduplicationId (opcional para filas FIFO, não permitido para filas padrão)

Depois de enviar mensagens, o Amazon SQS define os seguintes cabeçalhos e propriedades para cadamensagem:

• JMSMessageID

• JMS_SQS_SequenceNumber (somente para filas FIFO)

Para recebimento de mensagens

Ao receber mensagens, o Amazon SQS define os seguintes cabeçalhos e propriedades para cadamensagem:

• JMSDestination

• JMSMessageID

• JMSRedelivered

• JMSXDeliveryCount

• JMSXGroupID (somente para filas FIFO)• JMS_SQS_DeduplicationId (somente para filas FIFO)• JMS_SQS_SequenceNumber (somente para filas FIFO)

118

Amazon Simple Queue Service Guia do desenvolvedorRecomendações para filas Padrão e FIFO

Práticas recomendadas para oAmazon SQS

Essas práticas recomendadas podem ajudá-lo a obter o máximo do Amazon SQS.

Tópicos• Recomendações para filas Amazon SQS Padrão e FIFO (ordem de chegada) (p. 119)• Recomendações adicionais para filas Amazon SQS FIFO (p. 122)

Recomendações para filas Amazon SQS Padrão eFIFO (ordem de chegada)

As práticas recomendadas a seguir podem ajudar a reduzir custos e a processar mensagens comeficiência usando o Amazon SQS.

Tópicos• Trabalhar com mensagens do Amazon SQS (p. 119)• Redução de custos do Amazon SQS (p. 121)• Mudança de uma fila Amazon SQS Padrão para uma uma fila FIFO (p. 122)

Trabalhar com mensagens do Amazon SQSAs diretrizes a seguir podem ajudar a processar mensagens com eficiência usando o Amazon SQS.

Tópicos• Processar mensagens em tempo hábil (p. 119)• Gerenciar erros de solicitação (p. 120)• Configuração da sondagem longa (p. 120)• Capturar mensagens problemáticas (p. 120)• Configurar a retenção de dead letter queue (p. 121)• Evitar o processamento inconsistente de mensagens (p. 121)• Implementação de sistemas de solicitação-resposta (p. 121)

Processar mensagens em tempo hábilDefinir o tempo limite de visibilidade depende do tempo de que o seu aplicativo precisa para processar eexcluir uma mensagem. Por exemplo, se seu aplicativo exigir 10 segundos para processar uma mensageme você definir o tempo limite de visibilidade como 15 minutos, deverá esperar por um tempo relativamentelongo para tentar processar a mensagem novamente se a tentativa de processamento anterior falhar.Como alternativa, se o aplicativo exigir 10 segundos para processar uma mensagem, mas você definir otempo limite de visibilidade como apenas 2 segundos, uma mensagem duplicada será recebida por outroconsumidor enquanto o consumidor original ainda estiver trabalhando na mensagem.

Para garantir que haja tempo suficiente para processar mensagens, use uma das seguintes estratégias:

119

Amazon Simple Queue Service Guia do desenvolvedorTrabalhar com mensagens

• Se você souber (ou puder razoavelmente estimar) quanto tempo leva para processar uma mensagem,amplie o tempo limite de visibilidade da mensagem para o máximo de tempo necessário para processare excluir a mensagem. Para obter mais informações, consulte Configuração do tempo limite devisibilidade (p. 90) e Alteração do tempo limite de visibilidade de uma mensagem (p. 91).

• Se você não sabe quanto tempo demora para processar uma mensagem, crie um heartbeat para oprocesso dos consumidores: especifique o tempo limite de visibilidade inicial (por exemplo, 2 minutos)e, em seguida, contanto que o consumidor ainda trabalhe na mensagem, continue estendendo o tempolimite de visibilidade em 2 minutos a cada minuto.

Note

Se você precisar estender o tempo limite de visibilidade por mais de 12 horas, considere o uso doAWS Step Functions.

Gerenciar erros de solicitaçãoPara gerenciar erros de solicitação, use uma das seguintes estratégias:

• Se você usa um AWS SDK, já tem a lógica de repetição e recuo à sua disposição. Para obter maisinformações, consulte Repetições de erro e recuo exponencial na AWS no Referência geral do AmazonWeb Services.

• Se você não usar os recursos do SDK da AWS para repetição e recuo, faça uma pausa (porexemplo, 200 ms) antes de tentar novamente a ação ReceiveMessage depois de não recebernenhuma mensagem, de um tempo limite ou de uma mensagem de erro do Amazon SQS. Para o usosubsequente de ReceiveMessage que oferece os mesmos resultados, faça uma pausa maior (porexemplo, 400 ms).

Configuração da sondagem longaA sondagem longa ajuda a reduzir os custos de uso do Amazon SQS eliminando a quantidade derespostas vazias (quando não há mensagens disponíveis para uma solicitação ReceiveMessage) erespostas vazias falsas (quando mensagens estão disponíveis, mas não são incluídas em uma resposta).Para obter mais informações, consulte Sondagem longa do Amazon SQS (p. 85).

Para garantir o processamento ideal de mensagens, use as seguintes estratégias:

• Na maioria dos casos, você pode definir o tempo de espera de ReceiveMessage como 20 segundos.Se 20 segundos for muito longo para seu aplicativo, defina um tempo de espera ReceiveMessage maiscurto (no mínimo, 1 segundo). Se você não usar um SDK da AWS para acessar o Amazon SQS ou setiver configurado um SDK da AWS com um tempo limite mais curto, poderá ser necessário modificar ocliente do Amazon SQS para permitir solicitações mais longas ou para usar um tempo limite menor parasondagem longa.

• Se você implementar a sondagem longa para várias filas, use um thread para cada fila, em vez de umúnico thread para todas as filas. O uso de um único thread para cada fila permite que seu aplicativoprocesse as mensagens em cada uma das filas conforme se tornam disponíveis, enquanto o uso deum único thread para sondar várias filas pode fazer com que seu aplicativo não possa processar asmensagens disponíveis em outras filas enquanto o aplicativo aguarda (até 20 segundos) por uma filaque não tem mensagens disponíveis.

Capturar mensagens problemáticasPara capturar todas as mensagens que não podem ser processadas e garantir que as métricas doCloudWatch estejam corretas, configure uma dead letter queue (p. 86).

120

step-functions/

api-retries.html



Amazon Simple Queue Service Guia do desenvolvedorRedução de custos

• A política de redirecionamento redireciona mensagens para uma dead letter queue depois que a fila deorigem falha em processar uma mensagem um número de vezes especificado.

• O uso da dead letter queue diminui o número de mensagens e reduz a possibilidade de exposição amensagens poison pill (mensagens que podem ser recebidas, mas que não podem ser processadas).

• A inclusão de uma mensagem com conteúdo malicioso em uma fila pode distorcer a métricaApproximateAgeOfOldestMessage (p. 131) do CloudWatch fornecendo uma idade incorreta damensagem com conteúdo malicioso. Configurar uma dead letter queue ajuda a evitar alarmes falsos aousar essa métrica.

Configurar a retenção de dead letter queueA expiração de uma mensagem é baseada sempre em seu timestamp em fila original. Quando umamensagem é movida para uma dead-letter queue (p. 86), o timestamp em fila permanece inalterado. Porexemplo, se uma mensagem passar 1 dia na fila original antes de ser movida para uma dead-letter queue,e o período de retenção da fila de dead-letter queue estiver definido em 4 dias, a mensagem é excluídada fila de dead-letter queue após 3 dias. Por isso, uma prática recomendada é definir sempre o período deretenção de uma dead-letter queue mais longo que o período de retenção da fila original.

Evitar o processamento inconsistente de mensagensPara evitar o processamento inconsistente de mensagens pelas filas padrão, evite definir o númeromáximo de recebimentos como 1 ao configurar uma dead letter queue.

Important

Em alguns cenários improváveis, se você definir o número máximo de recebimentos como 1,sempre que uma chamada ReceiveMessage falhar, uma mensagem poderá ser movida parauma dead letter queue sem ter sido recebida.

Implementação de sistemas de solicitação-respostaAo implementar um sistema de solicitação-resposta ou chamada de procedimento remoto (RPC), lembre-se das seguintes melhores práticas:

• Não crie filas de respostas por mensagem. Em vez disso, crie filas de respostas na inicialização, porprodutor e use um atributo de mensagem de ID de correlação para mapear respostas para solicitações.

• Não permita que os produtores compartilhem filas de respostas. Isso pode fazer com que um produtorreceba mensagens de resposta destinadas a outro produtor.

Redução de custos do Amazon SQSAs melhores práticas a seguir podem ajudar a reduzir custos e a aproveitar outras possibilidades deredução de custos e obter resposta quase instantânea.

Colocar as ações de mensagem em lotesPara reduzir custos, coloque suas ações de mensagem em lotes:

• Para enviar, receber e excluir mensagens, e para alterar o tempo limite de visibilidade de váriasmensagens com uma única ação, use as ações da API em lotes do Amazon SQS (p. 181).

• Para combinar o armazenamento em buffer no lado do cliente com o envio de solicitações em lotes, usea sondagem longa junto com l cliente assíncrono armazenado em buffer (p. 181) incluído com o AWSSDK for Java.

121

Amazon Simple Queue Service Guia do desenvolvedorMudança de uma fila Padrão para uma fila FIFO

Note

A Cliente assíncrono armazenado em buffer do Amazon SQSnão suportam atualmente as filasFIFO.

Usar o modo de sondagem apropriado• A sondagem longa permite que você consuma mensagens da fila do Amazon SQS assim que se tornam

disponíveis.• Para reduzir o custo do uso do Amazon SQS e diminuir o número de recebimentos vazios em uma

fila vazia (respostas à ação ReceiveMessage que não retornam nenhuma mensagem), habilite asondagem longa. Para obter mais informações, consulte Sondagem longa do Amazon SQS (p. 85).

• Para aumentar a eficiência ao sondar vários threads com vários recebimentos, diminua o número dethreads.

• A sondagem longa é melhor do que a sondagem curta na maioria dos casos.• A sondagem curta retorna respostas imediatamente, mesmo que a fila sondada do Amazon SQS esteja

vazia.• Para satisfazer os requisitos de um aplicativo que espera respostas imediatas para a solicitaçãoReceiveMessage, use a sondagem curta.

• A sondagem curta é cobrada pelo mesmo custo de uma sondagem longa.

Mudança de uma fila Amazon SQS Padrão para umauma fila FIFOSe não estiver configurando o parâmetro DelaySeconds em cada mensagem, você poderá mover parauma fila FIFO fornecendo um ID de grupo de mensagens para cada mensagem enviada.

Para obter mais informações, consulte Mudança de uma fila Padrão para uma fila FIFO (p. 75).

Recomendações adicionais para filas Amazon SQSFIFO

As melhores práticas a seguir podem ajudar a usar o ID de eliminação de duplicação de mensagens e o IDde grupo de mensagens de forma ideal. Para obter mais informações, consulte as ações SendMessage eSendMessageBatch em Amazon Simple Queue Service API Reference.

Tópicos• Uso do ID de eliminação de duplicação de mensagens do Amazon SQS (p. 122)• Uso do ID do grupo de mensagens do Amazon SQS (p. 124)• Uso do ID de tentativa de solicitação de recebimento do Amazon SQS (p. 124)

Uso do ID de eliminação de duplicação de mensagensdo Amazon SQSO ID de eliminação de duplicação de mensagens é o token usado para desduplicação de mensagensenviadas. Se uma mensagem com uma ID de desduplicação de mensagem particular for enviada com

122



Amazon Simple Queue Service Guia do desenvolvedorUso do ID de eliminação de duplicação de mensagens

êxito, todas as mensagens enviadas com a mesma ID de desduplicação serão aceitas com êxito, mas nãoserão entregues no intervalo de desduplicação de 5 minutos.

Note

A desduplicação de mensagens se aplica a uma fila inteira, não a grupos individuais demensagens.O Amazon SQS continua mantendo o ID de desduplicação da mensagem mesmo após amensagem ser recebida e excluída.

Fornecer o ID de eliminação de duplicação de mensagensO produtor deve fornecer valores de ID de eliminação de duplicação de mensagem para cada mensagemenviada nos seguintes cenários:

• Mensagens enviadas com corpos idênticos que o Amazon SQS deve tratar como exclusivas.• Mensagens enviadas com conteúdo idêntico, mas com diferentes atributos que o Amazon SQS deve

tratar como exclusivas.• Mensagens enviadas com conteúdo diferente (por exemplo, contagens de repetições incluídas no corpo

da mensagem) que o Amazon SQS deve tratar como duplicações.

Ativar a eliminação de duplicação para um sistema de produtor/consumidor únicoSe você tiver um único produtor e um único consumidor e as mensagens forem exclusivas porque um IDde mensagem específico do aplicativo foi incluído no corpo da mensagem, siga estas melhores práticas:

• Ative a eliminação de duplicação baseada em conteúdo para a fila (cada uma de suas mensagens temum único corpo). O produtor pode omitir o ID de eliminação de duplicação de mensagem.

• Embora o consumidor não seja obrigado a fornecer um ID de tentativa de solicitação de recebimento,isso é uma prática recomendada porque permite que sequências de tentativa de recuperação de falhassejam executadas mais rapidamente.

• Você pode tentar enviar ou receber solicitações novamente porque elas não interferem na ordem dasmensagens em filas FIFO.

Projetar para cenários de recuperação de interrupçãoO processo de eliminação de duplicação em filas FIFO é sensível ao tempo. Ao projetar seu aplicativo,garanta que o produtor e o consumidor possam se recuperar em caso de interrupção do cliente ou da rede.

• O produtor deve estar ciente do intervalo de eliminação de duplicação da fila. O Amazon SQS tem umintervalo mínimo de eliminação de duplicação de 5 minutos. Repetir solicitações SendMessage apósa expiração do intervalo da eliminação de duplicação pode introduzir mensagens duplicadas na fila.Por exemplo, um dispositivo móvel em um carro envia mensagens cuja ordem é importante. Se o carroperder a conectividade celular por um período antes de receber uma confirmação, tentar novamente asolicitação depois de recuperada a conectividade celular pode criar uma duplicação.

• O consumidor deve ter um tempo limite de visibilidade que minimize o risco de não conseguirprocessar as mensagens antes que o tempo limite de visibilidade expire. Você pode estender otempo limite de visibilidade enquanto as mensagens estão sendo processadas chamando a açãoChangeMessageVisibility. No entanto, se o tempo limite de visibilidade expirar, outro consumidorpoderá começar imediatamente a processar as mensagens, fazendo com que uma mensagem sejaprocessada várias vezes. Para evitar esse cenário, configure uma dead letter queue (p. 86).

123

Amazon Simple Queue Service Guia do desenvolvedorUso do ID do grupo de mensagens

Uso do ID do grupo de mensagens do Amazon SQSO ID do grupo de mensagens é a tag especificando que uma mensagem pertence a um grupo específicode mensagens. As mensagens que pertencem ao mesmo grupo de mensagens são processadas sempreuma por uma, em uma ordem estrita em relação ao grupo de mensagens (porém, as mensagens quepertençam a grupos diferentes de mensagens podem ser processadas fora de ordem).

Intercalar vários grupos de mensagens ordenadasPara intercalar vários grupos de mensagens ordenadas em uma única fila FIFO, use valores de IDs degrupos de mensagens (por exemplo, os dados da sessão de vários usuários). Nesse cenário, váriosconsumidores podem processar a fila, mas os dados da sessão de cada usuário são processados em umaforma FIFO.

Note

Quando as mensagens que pertencem a um determinado ID de grupo de mensagens sãoinvisíveis, nenhum outro consumidor pode processar mensagens com o mesmo ID de grupo demensagens.

Evitar o processamento de duplicações em um sistema de váriosprodutores/consumidoresPara evitar o processamento de mensagens duplicadas em um sistema com vários produtores econsumidores em que a taxa de transferência e latência são mais importantes do que a ordenação, oprodutor deve gerar um ID de grupo de mensagens exclusivo para cada mensagem.

Note

Nesse cenário, duplicações são eliminadas. No entanto, a ordem da mensagem não pode sergarantida.Qualquer cenário com vários produtores e consumidores aumenta o risco de entregaracidentalmente uma mensagem duplicada se um operador não processa a mensagem dentro dotempo limite de visibilidade e a mensagem se torna disponível para outro operador.

Uso do ID de tentativa de solicitação de recebimentodo Amazon SQSO ID de tentativa de solicitação de recebimento é o token usado para o desduplicação de chamadas deReceiveMessage.

Durante uma interrupção de rede de longa duração que causa problemas de conectividade entre o SDKe o Amazon SQS, é uma melhor prática fornecer o ID de tentativa de solicitação de recebimento e repetircom o mesmo ID de tentativa de solicitação de recebimento, se a operação do SDK falhar.

124

Amazon Simple Queue Service Guia do desenvolvedorLimites relacionados a filas

Limites do Amazon SQSEste tópico lista os limites no Amazon Simple Queue Service (Amazon SQS).

Tópicos• Limites relacionados a filas (p. 125)• Limites relacionados a mensagens (p. 126)• Limites relacionados a políticas (p. 127)

Limites relacionados a filasA tabela a seguir lista os limites relacionados a filas.

Limite Descrição

Fila de atraso The minimum delay for a queue is 0 seconds. The maximumis 15 minutes.

Para filas padrão, pode haver no máximo 120.000 mensagensem processamento (received from a queue by a consumer,but not yet deleted from the queue). Se você atingir o limite,o Amazon SQS retornará a mensagem de erro OverLimit.Para evitar atingir o limite, você deve excluir mensagensda fila depois de serem processadas. Você também podeaumentar o número de filas que usar para processar asmensagens. Para solicitar um aumento de limite, envie umasolicitação de suporte.

Mensagens em trânsito por fila

Para filas FIFO, pode haver no máximo 20.000 mensagensem processamento (received from a queue by a consumer,but not yet deleted from the queue). Se você atingir o limite, oAmazon SQS não retornará mensagens de erro.

Um nome de fila pode ter até 80 caracteres. Os seguintescaracteres são aceitos: caracteres alfanuméricos, hifens (-) esublinhados (_).

Note

Os nomes de fila diferenciam maiúsculas eminúsculas (por exemplo, Test-queue e test-queue são filas diferentes).

Nome da fila

O nome de uma fila FIFO deve terminar com o sufixo .fifo.O sufixo conta para o limite de 80 caracteres do nome dafila. Para determinar se uma fila é FIFO (p. 72), você podeverificar se o nome da fila termina com o sufixo.

Tag de fila Não recomendamos adicionar mais de 50 tags a uma fila.

125



Amazon Simple Queue Service Guia do desenvolvedorLimites relacionados a mensagens

Limite Descrição

A tag Key é necessária, mas a tag Value é opcional.

A tag Key e a tag Value diferenciam maiúsculas deminúsculas.

A tag Key e a tag Value podem incluir caracteresalfanuméricos Unicode em UTF-8 e espaços em branco. Osseguintes caracteres especiais são permitidos: _ . : / = +- @

A tag Key ou Value não pode incluir o prefixo reservadoaws: (não é possível excluir chaves ou valores de tag comesse prefixo).

O comprimento máximo da tag Key é de 128 caracteresUnicode em UTF-8. A tag Key não pode estar vazia nem sernula.

O comprimento máximo da tag Value é de 256 caracteresUnicode em UTF-8. A tag Value pode estar vazia ou sernula.

Ações de de marcação são limitadas a 5 TPS por conta daAWS. Se o aplicativo exigir throughput mais alto, arquive umasolicitação de suporte técnico.

Limites relacionados a mensagensA tabela a seguir lista os limites relacionados a mensagens.

Limite Descrição

ID de mensagem em lote ID de mensagem em lotes pode ter até 80 caracteres. Osseguintes caracteres são aceitos: caracteres alfanuméricos,hifens (-) e sublinhados (_).

Atributos de mensagem Uma mensagem pode conter até 10 atributos de metadados.

Lote de mensagens Uma única solicitação em lote de mensagens pode incluir ummáximo de 10 mensagens. Para mais informações, consulteConfigurar o AmazonSQSBufferedAsyncClient (p. 182) naseção Ações em lote do Amazon SQS (p. 181).

Conteúdo da mensagem Uma mensagem pode incluir apenas XML, JSON e texto nãoformatado. Os seguintes caracteres Unicode são permitidos:#x9 | #xA | #xD | #x20 até #xD7FF | #xE000 até #xFFFD |#x10000 até #x10FFFF

Os caracteres não incluídos nesta lista serão rejeitados. Paraobter mais informações, consulte a Especificação W3C paracaracteres.

Retenção da mensagem Por padrão, uma mensagem será retida por 4 dias. A duraçãomínima é de 60 segundos (1 minuto). A configuração máximaé de 1.209.600 seconds (14 dias).

126

https://console.aws.amazon.com/support/home#/case/create?issueType=technical

https://www.w3.org/TR/REC-xml/#charsets

https://www.w3.org/TR/REC-xml/#charsets

Amazon Simple Queue Service Guia do desenvolvedorLimites relacionados a políticas

Limite Descrição

As filas Padrão oferecem suporte a um número quaseilimitado de transações por segundo (TPS) por ação de

Taxa de transferência da mensagem

• Por padrão, filas FIFO admitem até 3.000 mensagens porsegundo com o agrupamento em lotes (p. 181). Parasolicitar um aumento de limite, envie uma solicitação desuporte.

• As filas FIFO podem admitir até 300 mensagens porsegundo (300 operações de envio, recebimento ouexclusão por segundo) sem o agrupamento em lotes.

Temporizador de mensagem

Tamanho da mensagem O tamanho mínimo da mensagem é de 1 byte (1 caractere). Ocomprimento máximo é de 262.144 bytes (256 KB).

Para enviar mensagens maiores que 256 KB, você pode usara Biblioteca de cliente estendida do Amazon SQS para Java.Essa biblioteca permite que você envie uma mensagem doAmazon SQS que contém uma referência à carga de umamensagem no Amazon S3. O tamanho máximo de carga é 2GB.

Tempo limite de visibilidade damensagem

O tempo limite de visibilidade padrão para uma mensagem éde 30 segundos. O máximo é 12 horas.

Informações de política O limite máximo é 8.192 bytes, 20 declarações, 50 principaisou 10 condições. Para obter mais informações, consulteLimites relacionados a políticas (p. 127).

Limites relacionados a políticasA tabela a seguir lista os limites relacionados a políticas.

Nome Máximo

Ações 7

Bytes 8,192

Condições 10

Principais 50

Declarações 20

127



https://github.com/awslabs/amazon-sqs-java-extended-client-lib

Amazon Simple Queue Service Guia do desenvolvedorMonitoramento de filas usando o CloudWatch

Monitoramento, registro em log eautomação de filas do Amazon SQS

Esta seção fornece informações sobre o monitoramento, o registro em log e a automação de filas doAmazon SQS.

Tópicos• Monitoramento de filas do Amazon SQS usando o CloudWatch (p. 128)• Registro em log de chamadas à API do Amazon SQS usando o AWS CloudTrail (p. 134)• Automação de notificações nos serviços da AWS para Amazon SQS usando o Eventos do

CloudWatch (p. 139)

Monitoramento de filas do Amazon SQS usando oCloudWatch

O Amazon SQS e o Amazon CloudWatch são integrados, para que você possa usar o CloudWatchpara visualizar e analisar métricas para suas filas do Amazon SQS. Você pode visualizar e analisar asmétricas das filas no console do Amazon SQS (p. 129), no console do CloudWatch (p. 129), usandoa AWS CLI (p. 130) ou usando a API do CloudWatch (p. 130). Você também pode definir alarmes doCloudWatch (p. 130) para métricas do Amazon SQS.

As métricas do CloudWatch para as filas do Amazon SQS são coletadas e enviadas automaticamente parao CloudWatch a cada cinco minutos. Essas métricas são coletadas em todas as filas que estiverem deacordo com as diretrizes do CloudWatch por estarem ativas. O CloudWatch considera uma fila como ativapor até seis horas se ela contiver mensagens, ou se ela for acessada por qualquer ação.

Note

Não há cobranças pelas métricas do Amazon SQS informadas no CloudWatch. Elas sãofornecidas como parte do serviço Amazon SQS.O monitoramento detalhado (ou métricas de um minuto) não está disponível no momento para oAmazon SQS. Fazer solicitações para o CloudWatch nesta resolução pode não retornar nenhumdado.As métricas de CloudWatch são compatíveis com filas padrão e FIFO.

Tópicos• Acesso às métricas do CloudWatch para Amazon SQS (p. 128)• Criação de alertas do CloudWatch para métricas do Amazon SQS (p. 130)• Métricas do CloudWatch disponíveis para Amazon SQS (p. 131)

Acesso às métricas do CloudWatch para AmazonSQSO Amazon SQS e o Amazon CloudWatch são integrados, para que você possa usar o CloudWatchpara visualizar e analisar métricas para suas filas do Amazon SQS. Você pode visualizar e analisar asmétricas das filas no console do Amazon SQS (p. 129), no console do CloudWatch (p. 129), usandoa AWS CLI (p. 130) ou usando a API do CloudWatch (p. 130). Você também pode definir alarmes doCloudWatch (p. 130) para métricas do Amazon SQS.

128

Amazon Simple Queue Service Guia do desenvolvedorAcesso às métricas do CloudWatch para Amazon SQS

Console da Amazon SQS1. Faça login no console do Amazon SQS.2. Na lista de filas, escolha (selecione) as caixas das filas cujas métricas você deseja acessar. Você

pode exibir métricas para até 10 filas.3. Escolha a guia Monitoring.

Vários gráficos são exibidos na seção SQS metrics.4. Para entender o que um determinado gráfico representa, passe o mouse sobre ao lado do gráfico

desejado ou consulte Métricas do CloudWatch disponíveis para Amazon SQS (p. 131).5. Para alterar o intervalo de tempo para todos os gráficos ao mesmo tempo, em Time Range, escolha o

intervalo de tempo desejado (por exemplo, Last Hour).6. Para exibir estatísticas adicionais para um gráfico individual, selecione o gráfico.7. Na caixa de diálogo CloudWatch Monitoring Details (Detalhes de monitoramento do ClowdWatch),

selecione uma Statistic (Estatística), (por exemplo, Sum (Soma)). Para obter uma lista de estáticassuportadas, consulte Métricas do CloudWatch disponíveis para Amazon SQS (p. 131).

8. Para alterar o intervalo de tempo que um gráfico individual exibe (por exemplo, para mostrar umintervalo de tempo das últimas 24 horas em vez dos últimos 5 minutos, ou mostrar um período dehora em vez de um período de 5 minutos), com a caixa de diálogo do gráfico ainda exibida, em TimeRange, escolha o intervalo de tempo desejado (por exemplo, Last 24 Hours). Em Period, escolha operíodo desejado no intervalo de tempo especificado (por exemplo, 1 Hour). Ao terminar de visualizaro gráfico, clique em Close.

9. (Opcional) Para trabalhar com outros recursos do CloudWatch, na guia Monitoring (Monitoramento),escolha View all CloudWatch metrics (Visualizar todas as métricas do CloudWatch) e, em seguida,siga as instruções no procedimento Console do Amazon CloudWatch (p. 129).

Console do Amazon CloudWatch1. Faça login no console do CloudWatch.2. No painel de navegação, selecione Métricas.3. Selecione o namespace de métrica do SQS.

4. Selecione a dimensão de métrica Queue Metrics.

129


cloudwatch/

Amazon Simple Queue Service Guia do desenvolvedorCriação de alertas do CloudWatch

para métricas do Amazon SQS

5. Agora você pode examinar as métricas do Amazon SQS:

• Para classificar a métrica, use o cabeçalho da coluna.• Para criar um gráfico de uma métrica, marque a caixa de seleção ao lado da métrica.• Para filtrar por métrica, selecione o nome da métrica e depois escolha Add to search.

Para obter mais informações e opções, consulte Métricas do gráfico e Uso de painéis do AmazonCloudWatch no Guia do usuário do Amazon CloudWatch.

AWS Command Line InterfacePara acessar métricas do Amazon SQS usando a AWS CLI, execute o comando get-metric-statistics.

Para obter mais informações, consulte Obter as estatísticas de uma métrica no Guia do usuário doAmazon CloudWatch.

API do CloudWatchPara acessar as métricas do Amazon SQS usando a API do CloudWatch, use a açãoGetMetricStatistics.

Para obter mais informações, consulte Obter as estatísticas de uma métrica no Guia do usuário doAmazon CloudWatch.

Criação de alertas do CloudWatch para métricas doAmazon SQSO CloudWatch permite que você acione alertas com base em um limite de métrica. Por exemplo,você pode criar um alarme para a métrica NumberOfMessagesSent. Por exemplo, se mais de 100mensagens são enviadas à fila MyQueue em 1 hora, uma notificação por e-mail é enviada. Para obtermais informações, consulte Como criar alertas do Amazon CloudWatch no Guia do usuário do AmazonCloudWatch.

1. Faça login no Console de gerenciamento da AWS e abra o console da CloudWatch em https://console.aws.amazon.com/cloudwatch/.

130

graph_metrics.html

CloudWatch_Dashboards.html

CloudWatch_Dashboards.html

cloudwatch/get-metric-statistics.html

cloudwatch/get-metric-statistics.html

getting-metric-statistics.html

API_GetMetricStatistics.html

getting-metric-statistics.html

AlarmThatSendsEmail.html

https://console.aws.amazon.com/cloudwatch/

https://console.aws.amazon.com/cloudwatch/

Amazon Simple Queue Service Guia do desenvolvedorMétricas do CloudWatch disponíveis para Amazon SQS

2. Escolha Alarms e, em seguida, Create Alarm.3. Na seção Select Metric (Selecionar métrica) da caixa de diálogo Create Alarm (Criar alerta), selecione

Browse Metrics (Procurar métricas), SQS.4. Em SQS > Queue Metrics (SQS > Métricas de fila), selecione QueueName (Nome da fila) e Metric

Name (Nome da métrica) para o qual definir um alerta e, em seguida, selecione Next (Avançar). Paraver uma lista das métricas disponíveis, consulte Métricas do CloudWatch disponíveis para AmazonSQS (p. 131).

No exemplo a seguir, a seleção é de um alarme para a métrica NumberOfMessagesSent para a filaMyQueue. O alarme é acionado quando.

5. Na seção Define Alarm (Definir alerta) da caixa de diálogo Create Alarm (Criar alerta), faça o seguinte:

a. Em Alarm Threshold (Limite de alerta), digite Name (Nome) e Description (Descrição) para oalerta.

b. Defina is como > 100.c. Defina for (para) como 1 out of 1 datapoints (1 de 1 ponto de dados).d. Em Alarm preview (Visualização do alerta), defina Period (Período) como 1 Hour (1 hora).e. Defina Statistic (Estatística) como Standard (Padrão), Sum (Soma).f. Em Actions (Ações), defina Whenever this alarm (Sempre que esse alerta) como State is ALARM

(Estado é ALERTA).

Se desejar que o CloudWatch envie uma notificação quando o alerta for acionado, selecione umtópico existente do Amazon SNS ou selecione New list (Nova lista) e insira os endereços de e-mail separados com vírgulas.

Note

Se você criar um novo tópico do Amazon SNS, o endereços de e-mail deverão serverificados para que recebam notificações. Se o estado de alarme for alterado antes queos endereços de e-mail sejam verificados, as notificações não serão recebidas.

6. Escolha Create Alarm.

O alarme é criado.

Métricas do CloudWatch disponíveis para AmazonSQSO Amazon SQS envia as seguintes métricas para o CloudWatch.

Note

Para filas padrão, o resultado é aproximado, por conta da arquitetura distribuída de Amazon SQS.Na maioria dos casos, a contagem deve estar próxima ao número real de mensagens na fila.Para filas FIFO, o resultado é preciso.

Métricas do Amazon SQSO namespace AWS/SQS inclui as métricas a seguir.

Métrica Descrição

ApproximateAgeOfOldestMessage A idade aproximada de mensagem nãoexcluída mais velha na fila.

131



Note

Para dead letter queues, o valor deApproximateAgeOfOldestMessageé o tempo mais longo que umamensagem esteve na fila.

Unidade: segundos

Estatísticas válidas: média, mínimo, máximo,soma, amostragens de dados (exibidas comocontagem de amostra no console do AmazonSQS)

ApproximateNumberOfMessagesDelayed O número de mensagens na fila que estãoatrasadas e indisponíveis para leituraimediata. Isso pode acontecer quando a filatem a configuração de fila com atraso ouquando uma mensagem foi enviada com umparâmetro de atraso.

Unidade: contagem


ApproximateNumberOfMessagesNotVisible O número de mensagens que estão emtrânsito. As mensagens são consideradascomo em processamento quando foramenviadas a um cliente, mas ainda não foramexcluídas ou ainda não atingiram o final desua janela de visibilidade.

Unidade: contagem


ApproximateNumberOfMessagesVisible O número de mensagens disponíveis pararecuperação da fila.

Unidade: contagem


132



NumberOfEmptyReceives O número de chamadas de APIReceiveMessage que não retornaram umamensagem.

Unidade: contagem


NumberOfMessagesDeleted O número de mensagens excluídas da fila.

Unidade: contagem


O Amazon SQS emite a métricaNumberOfMessagesDeleted para cadaoperação bem-sucedida de exclusão usandoum identificador de recebimento sqs-queue-message-identifiers.html#receipt-handle válido, incluindo exclusõesduplicadas. Os seguintes cenáriospodem fazer com que o valor da métricaNumberOfMessagesDeleted seja superiorao esperado:

• Acionando a ação DeleteMessage nosdiversos identificadores de recebimentoque pertencem à mesma mensagem: sea mensagem não for processada antesde o tempo limite de visibilidade expirar,a mensagem se torna disponível paraoutros clientes que podem processá-laexcluir novamente, aumentando o valor damétrica NumberOfMessagesDeleted.

• Acionando a ação DeleteMessage nomesmo identificador de recebimento:se a mensagem for processada eexcluída, mas você acionar umaação DeleteMessage usando omesmo identificador de recebimentonovamente, um status de sucesso seráretornado, aumentando o valor da métricaNumberOfMessagesDeleted.

133

sqs-queue-message-identifiers.html#receipt-handle



sqs-visibility-timeout.html

Amazon Simple Queue Service Guia do desenvolvedorRegistro em log de chamadas à API usando o CloudTrail


NumberOfMessagesReceived O número de mensagens retornadaspor chamadas para a ação deReceiveMessage.

Unidade: contagem


NumberOfMessagesSent O número de mensagens adicionadas a umafila.

Unidade: contagem


SentMessageSize O tamanho das mensagens adicionadas auma fila.

Unidade: bytes


Observe que SentMessageSize não éexibido como uma métrica disponível noconsole do CloudWatch até que pelo menosuma mensagem seja enviada para a filacorrespondente.

Dimensões para métricas do Amazon SQSA única dimensão enviada pelo Amazon SQS para o CloudWatch é QueueName. Isso significa que todasas estatísticas disponíveis são filtradas por QueueName.

Registro em log de chamadas à API do AmazonSQS usando o AWS CloudTrail

O Amazon SQS é integrado com o AWS CloudTrail, um serviço que fornece um registro das chamadasdo Amazon SQS que um usuário, função ou serviço da AWS faz. O CloudTrail captura as chamadas àAPI relacionadas às filas do Amazon SQS como eventos, incluindo as chamadas do console do AmazonSQS e as chamadas de código de APIs do Amazon SQS. Para obter mais informações sobre o CloudTrail,consulte o AWS CloudTrail User Guide.

134

Amazon Simple Queue Service Guia do desenvolvedorInformações sobre o Amazon SQS no CloudTrail

Note

O registro em log do CloudTrail oferece suporte a filas padrão e FIFO.

Usando as informações que o CloudTrail coleta, é possível identificar uma solicitação específica parauma API do Amazon SQS, o endereço IP do solicitante, a identidade do solicitante, a data e a hora dasolicitação etc. Se você configurar uma trilha, poderá habilitar a entrega contínua de eventos do CloudTrailpara um bucket do Amazon S3. Se não configurar uma trilha, você poderá visualizar os eventos maisrecentes no histórico de eventos do console do CloudTrail. Para obter mais informações, consulte Visãogeral de como criar uma trilha no AWS CloudTrail User Guide.

Informações sobre o Amazon SQS no CloudTrailQuando você cria sua conta da AWS, o CloudTrail é habilitado. Quando ocorre uma atividade do evento doAmazon SQS com suporte, ela é registrada em um evento do CloudTrail com outros eventos de serviçosda AWS no histórico de eventos. Você pode visualizar, pesquisar e fazer download de eventos recentespara a sua conta da AWS. Para obter mais informações, consulte Visualização de eventos com o históricode eventos do CloudTrail no AWS CloudTrail User Guide.

Uma trilha permite que o CloudTrail entregue arquivos de log para um bucket do Amazon S3. Você podecriar uma trilha para manter um registro contínuo de eventos em sua conta da AWS. Por padrão, quandovocê cria uma trilha usando o Console de gerenciamento da AWS, ela é aplicada a todas as regiões daAWS. A trilha registra os eventos em log de todas as regiões da AWS e entrega os arquivos de log para obucket do Amazon S3 especificado. Também é possível configurar outros serviços da AWS para analisare atuar mais profundamente sobre os dados de eventos coletados nos logs do CloudTrail. Para obter maisinformações, consulte um dos tópicos a seguir no AWS CloudTrail User Guide.

• Serviços e integrações suportados do CloudTrail• Configuração de notificações do Amazon SNS para o CloudTrail• Recebimento de arquivos de log do CloudTrail de várias regiões• Recebimento de arquivos de log do CloudTrail de várias contas

O Amazon SQS oferece suporte ao registro em log das seguintes ações:

• AddPermission

• CreateQueue

• DeleteQueue

• PurgeQueue

• RemovePermission

• SetQueueAttributes

Cada evento ou entrada de log contém informações sobre o solicitante. As informações ajudam aidentificar:

• A solicitação foi feita com credenciais de usuário raiz ou do IAM?• A solicitação foi feita com credenciais de segurança temporárias de uma função ou de um usuário

federado?• A solicitação foi feita por outro serviço da AWS?

Para obter mais informações, consulte o Elemento userIdentity do CloudTrail no AWS CloudTrail UserGuide.

135

cloudtrail-create-and-update-a-trail.html

cloudtrail-create-and-update-a-trail.html

view-cloudtrail-events.html

view-cloudtrail-events.html

cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations

getting_notifications_top_level.html

receive-cloudtrail-log-files-from-multiple-regions.html

cloudtrail-receive-logs-from-multiple-accounts.html



API_DeleteQueue.html

API_PurgeQueue.html

API_RemovePermission.html


cloudtrail-event-reference-user-identity.html

Amazon Simple Queue Service Guia do desenvolvedorExemplo de entradas do arquivo de log do Amazon SQS

Exemplo de entradas do arquivo de log do AmazonSQSOs arquivos de log do CloudTrail podem conter uma ou mais entradas de log, e cada entrada é compostapor vários eventos em formato JSON. Uma entrada de log representa uma única solicitação de qualquerorigem e inclui informações sobre a ação solicitada, quaisquer parâmetros, a data e hora da ação e assimpor diante. Não é garantido que as entradas de log estejam em uma ordem específica. Ou seja, elas nãosão um rastreamento de pilha ordenada das chamadas de API públicas.

AddPermissionO exemplo a seguir mostra uma entrada do log do CloudTrail de uma chamada à API AddPermission.

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Alice", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Alice" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "AddPermission", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.0", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "actions": [ "SendMessage" ], "AWSAccountIds": [ "123456789012" ], "label": "MyLabel", "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "responseElements": null, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ]}

CreateQueueO exemplo a seguir mostra uma entrada do log do CloudTrail de uma chamada à API CreateQueue.

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE",

136


"arn": "arn:aws:iam::123456789012:user/Alejandro", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Alejandro" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "CreateQueue", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.1", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "queueName": "MyQueue" }, "responseElements": { "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ]}

DeleteQueueO exemplo a seguir mostra uma entrada do log do CloudTrail de uma chamada à API DeleteQueue.

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Carlos", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Carlos" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "DeleteQueue", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.2", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "responseElements": null, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ]}

RemovePermissionO exemplo a seguir mostra uma entrada do log do CloudTrail de uma chamada à APIRemovePermission.

{

137


"Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Jane", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Jane" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "RemovePermission", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.3", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "label": "label", "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "responseElements": null, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ]}

SetQueueAttributesO exemplo a seguir mostra uma entrada de log do CloudTrail para SetQueueAttributes:

{ "Records": [ { "eventVersion": "1.06", "userIdentity": { "type": "IAMUser", "principalId": "AKIAI44QH8DHBEXAMPLE", "arn": "arn:aws:iam::123456789012:user/Maria", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "Maria" }, "eventTime": "2018-06-28T22:23:46Z", "eventSource": "sqs.amazonaws.com", "eventName": "SetQueueAttributes", "awsRegion": "us-east-2", "sourceIPAddress": "203.0.113.4", "userAgent": "Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Firefox/24.0", "requestParameters": { "attributes": { "VisibilityTimeout": "100" }, "queueUrl": "https://sqs.us-east-2.amazon.com/123456789012/MyQueue" }, "responseElements": null, "requestID": "123abcde-f4gh-50ij-klmn-60o789012p30", "eventID": "0987g654-32f1-09e8-d765-c4f3fb2109fa" } ]}

138

Amazon Simple Queue Service Guia do desenvolvedorAutomação de notificações

usando o Eventos do CloudWatch

Automação de notificações nos serviços daAWS para Amazon SQS usando o Eventos doCloudWatch

O Eventos do Amazon CloudWatch permite automatizar os serviços da AWS e responder aos eventosdo sistema, como problemas de disponibilidade do aplicativo ou alterações de recursos. Os eventos dosserviços da AWS são entregues ao Eventos do CloudWatch quase em tempo real. Você pode criar regrassimples para indicar quais eventos são de seu interesse, e quais ações automatizadas devem ser tomadasquando um evento corresponder a uma regra.

O Eventos do CloudWatch permite definir vários destinos — como filas padrão e FIFO do Amazon SQS— que recebem eventos no formato JSON. Para obter mais informações, consulte o Guia do usuário doEventos do Amazon CloudWatch.

139

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/

Amazon Simple Queue Service Guia do desenvolvedorAutenticação e controle de acesso

Segurança do Amazon SQSEsta seção fornece informações sobre a segurança, a autenticação e o controle de acesso do AmazonSQS e a Access Policy Language do Amazon SQS.

Tópicos• Autenticação e controle de acesso do Amazon SQS (p. 140)• Proteção de dados usando criptografia no lado do servidor (SSE) e AWS KMS (p. 167)

Autenticação e controle de acesso do Amazon SQSO acesso ao Amazon SQS exige credenciais que a AWS possa usar para autenticar suas solicitações.Essas credenciais devem ter permissões para acessar recursos da AWS, como filas e mensagens doAmazon SQS. As seções a seguir fornecem detalhes sobre como é possível usar o AWS Identity andAccess Management (IAM) e o Amazon SQS para ajudar a proteger seus recursos controlando quem podeacessá-los.

Tópicos

• Autenticação (p. 140)• Controle de acesso (p. 141)

AutenticaçãoVocê pode acessar a AWS como alguns dos seguintes tipos de identidade:

• Usuário raiz da conta da AWS – Ao criar uma conta do AWS pela primeira vez, você começa com umaúnica identidade de login que tem acesso completo a todos os serviços e recursos da AWS na conta.Essa identidade é denominada usuário raiz da conta da AWS e é acessada pelo login com o endereçode e-mail e a senha que você usou para criar a conta. Recomendamos que não use o usuário raiz parasuas tarefas diárias, nem mesmo as administrativas. Em vez disso, siga as melhores práticas de usaro usuário raiz apenas para criar seu primeiro usuário do IAM. Depois, armazene as credenciais usuárioraiz com segurança e use-as para executar apenas algumas tarefas de gerenciamento de contas e deserviços.

• Usuário IAM – um usuário IAM é uma identidade na sua conta da AWS que tem permissõespersonalizadas específicas (por exemplo, para criar a queue no Amazon SQS). Você pode usar umnome e uma senha de usuário IAM para fazer login em páginas Web seguras da AWS, como Console degerenciamento da AWS, Fóruns de discussão AWS ou o AWS Support Center.

Além de um nome e uma senha de usuário, você também pode gerar chaves de acesso para cadausuário. Você pode usar essas chaves ao acessar serviços da AWS de forma programática, seja comum dos vários SDKs ou usando a AWS Command Line Interface (CLI). As ferramentas de SDK e deCLI usam as chaves de acesso para o cadastramento criptográfico da sua solicitação. Se você nãoutilizar ferramentas da AWS, cadastre a solicitação você mesmo. Amazon SQS supports Assinaturaversão 4, um protocolo para autenticar solicitações de API de entrada. Para mais informações sobre

140

introduction.html

introduction.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html

https://console.aws.amazon.com/

https://console.aws.amazon.com/

https://forums.aws.amazon.com/

https://console.aws.amazon.com/support/home#/

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html

https://aws.amazon.com/tools/

https://aws.amazon.com/cli/

Amazon Simple Queue Service Guia do desenvolvedorControle de acesso

autenticação de solicitações, consulte Processo de cadastramento de Assinatura versão 4 no AWSGeneral Reference.

• IAM role – Uma função do IAM é uma identidade do IAM que você pode criar em sua conta que tenha

permissões específicas. É semelhante a um usuário IAM, mas não está associada a uma pessoaespecífica. Uma função do IAM permite obter chaves de acesso temporárias que podem ser usadas paraacessar os serviços e recursos da AWS. As funções do IAM com credenciais temporária são úteis nasseguintes situações:

• Acesso de usuário federado – Em vez de criar um usuário do IAM, você pode usar identidades de

usuário existentes do AWS Directory Service da sua empresa ou de um provedor de identidadesda web. Estes são conhecidos como usuários federados. A AWS atribui uma função a um usuáriofederado quando o acesso é solicitado por meio de um provedor de identidades. Para obter maisinformações sobre usuários federados, consulte Usuários federados e funções em Guia do usuário doIAM.

• Acesso de serviço à AWS – Você pode usar uma função do IAM em sua conta para conceder

permissões a um serviço da AWS para acessar os recursos da sua conta. Por exemplo, você podecriar uma função que permita que Amazon Redshift acesse um bucket do Amazon S3 em seu nomee carregue dados desse bucket em um cluster Amazon Redshift. Para mais informações, consulteCriação de uma função para delegar permissões a um serviço da AWS no Guia do usuário do IAM.

• Aplicativos em execução no Amazon EC2 – Você pode usar uma função do IAM para gerenciar

credenciais temporárias para aplicativos que estão sendo executados em uma instância do EC2 eque fazem solicitações de API da AWS. É preferível fazer isso do que armazenar chaves de acessona instância do EC2. Para atribuir uma função da AWS a uma instância do EC2 e disponibilizá-lapara todos os seus aplicativos, crie um perfil de instância que esteja anexado à instância. Um perfilde instância contém a função e permite que programas que estão em execução na instância do EC2obtenham credenciais temporárias. Para mais informações, consulte Uso de uma função do IAM paraconceder permissões aos aplicativos em execução nas instâncias do Amazon EC2 no Guia do usuáriodo IAM.

Controle de acessoO Amazon SQS tem seu próprio sistema de permissões com base em recursos que usa políticas escritasna mesma linguagem usada para políticas do AWS Identity and Access Management (IAM). Isso significaque você pode realizar coisas semelhantes com as políticas do Amazon SQS e do IAM.

Note

É importante entender que todas as contas da AWS podem delegar suas permissões parausuários em suas contas. O acesso entre contas permite compartilhar o acesso a seus recursosda AWS sem a necessidade de gerenciar usuários adicionais. Para obter informações sobre comousar o acesso entre contas, consulte Ativação do acesso entre contas no Guia do usuário do IAM.Permissões entre contas não são aplicáveis às ações a seguir:

• AddPermission

• CreateQueue

• DeleteQueue

• ListQueues

• ListQueueTags

141


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

Delegation.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_AddPermission.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueueTags.html

Amazon Simple Queue Service Guia do desenvolvedorVisão geral do gerenciamento de acesso



• TagQueue

• UntagQueue

Atualmente, o Amazon SQS oferece suporte a um subconjunto limitado das chaves decondição disponíveis no IAM. Para obter mais informações, consulte Referência de ações erecursos (p. 165).

As seções a seguir descrevem como gerenciar permissões para o Amazon SQS. Recomendamos quevocê leia a visão geral primeiro.

• Visão geral do gerenciamento de permissões de acesso a seus recursos do Amazon Simple QueueService (p. 142)

• Uso de políticas com base em identidade (IAM) para o Amazon SQS (p. 147)• Uso de políticas personalizadas com a Access Policy Languagedo Amazon SQS (p. 155)• Uso de credenciais de segurança temporárias (p. 163)• Referência de ações e recursos (p. 165)

Visão geral do gerenciamento de permissões deacesso a seus recursos do Amazon Simple QueueServiceCada recurso da AWS é de propriedade de uma conta da AWS, e as permissões para criar ou acessarum recurso são regidas por políticas de permissões. Um administrador da conta pode anexar políticas depermissões a identidades do IAM (usuários, grupos e funções), e alguns serviços (como o Amazon SQS)também oferecem suporte à anexação de políticas de permissões aos recursos.

Note

O administrador da conta (ou usuário administrador) é um usuário com privilégios administrativos.Para obter mais informações, consulte Melhores práticas do IAM no Guia do usuário do IAM.

Ao conceder permissões, você especifica os usuários que recebem permissões, o recurso para o qual aspermissões são concedidas e as ações específicas que você deseja permitir no recurso.

Tópicos• Recurso e operações do Amazon Simple Queue Service (p. 142)• Entender a propriedade de recursos (p. 143)• Gerenciar o acesso aos recursos (p. 143)• Especificação de elementos da política: ações, efeitos, recursos e principais (p. 146)• Especificação de condições em uma política (p. 146)

Recurso e operações do Amazon Simple Queue ServiceNo Amazon SQS, o único recurso é a fila. Em uma política, use um nome de recurso da Amazon (ARN)para identificar o recurso ao qual a política se aplica. O seguinte recurso tem um ARN exclusivo associadoa ele:

142

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_RemovePermission.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SetQueueAttributes.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_TagQueue.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_UntagQueue.html

reference_policies_elements.html#AvailableKeys

reference_policies_elements.html#AvailableKeys

best-practices.html


Tipo de recurso Formato de Nome de região da Amazon (ARN)

Fila arn:aws:sqs:region:account_id:queue_name

Veja a seguir exemplos do formato do ARN para filas:

• Um ARN para uma fila denominada my_queue na região Leste dos EUA (Ohio), pertencente a umaconta da AWS 123456789012:

arn:aws:sqs:us-east-2:123456789012:my_queue

• Um ARN para uma fila denominada my_queue em cada uma das diferentes regiões com suporte doAmazon SQS:

arn:aws:sqs:*:123456789012:my_queue

• Um ARN que usa * ou ? como um curinga para o nome da fila. No exemplo a seguir, o ARNcorresponde a todas as filas prefixadas com my_prefix_:

arn:aws:sqs:*:123456789012:my_prefix_*

Você pode obter o valor do ARN para uma fila existente chamando a ação GetQueueAttributes. Ovalor do atributo QueueArn é o ARN da fila. Para obter mais informações sobre ARNs, consulte ARNs doIAM no Guia do usuário do IAM.

O Amazon SQS fornece um conjunto de ações que funcionam com o recurso de fila. Para obter maisinformações, consulte Referência de ações e recursos (p. 165).

Entender a propriedade de recursosA conta da AWS possui os recursos criados na conta, independentemente de quem os criou. Maisespecificamente, o proprietário do recurso é a conta da AWS da entidade principal (ou seja, a conta-raiz, um usuário do IAM ou uma função do IAM) que autentica a solicitação de criação de recursos. Osexemplos a seguir ilustram como isso funciona:

• Se você usar as credenciais da conta raiz de sua conta da AWS para criar uma fila do Amazon SQS, suaconta da AWS será a proprietária do recurso (no Amazon SQS, o recurso é a fila do Amazon SQS).

• Se você criar um usuário do IAM em sua conta da AWS e conceder permissões para criar uma fila parao usuário, o usuário poderá criar a fila. No entanto, a conta da AWS, (à qual o usuário pertence), é aproprietária do recurso de fila.

• Se você criar uma função do IAM na conta da AWS com permissões para criar uma fila do AmazonSQS, qualquer pessoa que puder assumir a função poderá criar uma fila. A conta da AWS (à qual afunção pertence) é a proprietária do recurso de fila.

Gerenciar o acesso aos recursosA política de permissões descreve as permissões concedidas às contas. A seção a seguir explica asopções disponíveis para a criação das políticas de permissões.

Note

Esta seção discute como usar o IAM no contexto do Amazon SQS. Não são fornecidasinformações detalhadas sobre o serviço do IAM. Para obter a documentação completa do IAM,

143


reference_identifiers.html#identifiers-arns

reference_identifiers.html#identifiers-arns


consulte O que é o IAM? no Guia do usuário do IAM. Para obter mais informações sobre a sintaxee as descrições da política do IAM, consulte Referência de políticas do AWS IAM no Guia dousuário do IAM.

As políticas anexadas a uma identidade do IAM são conhecidas como políticas baseadas em identidade(políticas do IAM) e as políticas anexadas a um recurso são conhecidas como políticas baseadas emrecurso.

Políticas baseadas em identidade (políticas do IAM e do Amazon SQS)

Há duas maneiras de conceder aos usuários permissões às suas filas do Amazon SQS: usando o sistemade políticas do Amazon SQS e do IAM. Você pode usar um dos sistemas, ou ambos, para anexar políticasa usuários ou funções. Na maioria dos casos, você pode atingir o mesmo resultado usando um dossistemas. Por exemplo, você pode fazer o seguinte:

• Anexar uma política de permissões a um usuário ou grupo na sua conta – para conceder a um usuáriopermissões para criar uma fila do Amazon SQS, anexe uma política de permissões a um usuário ou aogrupo ao qual o usuário pertence.

• Anexar uma política de permissões a um usuário em outra conta da AWS – para conceder permissõesde usuário para criar uma fila do Amazon SQS, anexe uma política de permissões do Amazon SQS, aum usuário em outra conta da AWS.

• Anexar uma política de permissões a uma função (conceder permissões entre contas) – para concederpermissões entre contas, anexe uma política de permissões baseada em identidade a uma funçãodo IAM. Por exemplo, o administrador da conta A da AWS pode criar uma função para concederpermissões entre contas à conta B da AWS (ou um serviço da AWS) da seguinte forma:• O administrador da conta A cria uma função do IAM e anexa uma política de permissões — que

concede permissões em recursos na conta A — à função.• O administrador da conta A anexa uma política de confiança à função que identifica a conta B como a

entidade principal, que pode assumir a função.• O administrador da conta B delega a permissão para assumir a função a qualquer usuário na conta B.

Isso permite que os usuários na conta B criem ou acessem filas na conta A.

Note

Para conceder a permissão para assumir a função a um serviço da AWS, a entidade principalda política de confiança também pode ser uma entidade principal do serviço da AWS.

Para obter mais informações sobre o uso do IAM para delegar permissões, consulte Gerenciamento deacesso no Guia do usuário do IAM.

Embora o Amazon SQS funcione com políticas do IAM, ele tem sua própria infraestrutura de políticas.Você pode usar uma política do Amazon SQS com uma fila para especificar quais contas da AWS têmacesso à fila. Você pode especificar o tipo de acesso e condições (por exemplo, uma condição queconceda permissões para usar SendMessage, ReceiveMessage se a solicitação for feita antes de31 de dezembro de 2010). As ações específicas para as quais você pode conceder permissões sãoum subconjunto de toda a lista de ações do Amazon SQS. Ao gravar uma política do Amazon SQS eespecificar * para "permitir todas as ações do Amazon SQS", isso indica que um usuário pode executartodas as ações nesse subconjunto.

O diagrama a seguir ilustra o conceito de uma dessas políticas básicas do Amazon SQS que abrangem osubconjunto de ações. A política é para queue_xyz e fornece às contas 1 da AWS e à conta 2 da AWSpermissões para usar qualquer uma das ações permitidas com a fila especificada.

Note

O recurso na política é especificado como 123456789012/queue_xyz, em que 123456789012é o ID da conta da AWS que é a proprietária da fila.

144

introduction.html

reference_policies.html

access.html

access.html


Com a introdução do IAM e os conceitos de Usuários e nomes de recursos da Amazon (ARNs), algumascoisas foram alteradas nas políticas do SQS. O diagrama e a tabela a seguir descrevem as alterações.

Além de especificar quais contas da AWS têm acesso a uma fila, você pode especificar quais usuáriosem sua própria conta da AWS têm acesso à fila. Se os usuários estiverem em contas diferentes, consulte oTutorial: Delegar acesso entre contas da AWS usando funções do IAM no Guia do usuário do IAM.

O subconjunto de ações incluídas no * foi expandido. Para obter uma lista de ações permitidas, consulteReferência de ações e recursos (p. 165).

Você pode especificar o recurso usando o nome de recurso da Amazon (ARN), a forma padrão deespecificar recursos nas políticas do IAM. Para obter informações sobre o formato do ARN para filas doAmazon SQS, consulte Recurso e operações do Amazon Simple Queue Service (p. 142).

Por exemplo, de acordo com a política do Amazon SQS no diagrama anterior, qualquer pessoa quepossua credenciais de segurança para a conta 1 da AWS e a conta 2 da AWS pode acessar queue_xyz.Além disso, os usuários Bob e Susan em sua própria conta da AWS (com o ID 123456789012) podemacessar a fila.

Antes da introdução do IAM, o Amazon SQS concedia automaticamente ao criador de uma fila o controletotal sobre a fila (ou seja, o acesso a todas as ações possíveis do Amazon SQS nessa fila). Isso não émais verdadeiro, a menos que o criador use credenciais de segurança da AWS. Qualquer usuário quetenha permissões para criar uma fila também deve ter permissões para usar outras ações do Amazon SQSpara fazer qualquer coisa com as filas criadas.

Veja a seguir uma política de exemplo que permite que um usuário use todas as ações do Amazon SQS,mas apenas com as filas cujos nomes estejam prefixados com a string literal bob_queue_.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:123456789012:bob_queue_*" }]}

145

tutorial_cross-account-with-roles.html


Para obter mais informações, consulte Uso de políticas com base em identidade (IAM) para o AmazonSQS (p. 147) e Identidades (usuários, grupos e funções) no Guia do usuário do IAM.

Políticas com base em recurso

Outros serviços da AWS, como o Amazon S3, oferecem suporte a políticas de permissões com base emrecursos. Por exemplo: para gerenciar permissões de acesso para um bucket do S3, você pode anexaruma política ao bucket do S3.

O Amazon SQS não oferece suporte a permissões em nível de recurso em políticas com base emidentidade (anexadas a um usuário ou função), nas quais você pode especificar recursos nos quais osusuários têm permissão para executar ações específicas. Para obter mais informações, consulte Visãogeral de permissões do AWS IAM no Guia do usuário do IAM.

Especificação de elementos da política: ações, efeitos, recursose principaisPara cada recurso do Amazon Simple Queue Service (p. 142), o serviço define um conjunto de ações.Para conceder permissões a essas ações, o Amazon SQS define um conjunto de ações que podem serespecificadas em uma política.

Note

A execução de uma ação de pode exigir permissões para mais de uma ação. Ao concederpermissões para ações específicas, você também identifica o recurso para o qual as ações sãopermitidas ou recusadas.

Estes são os elementos de política mais básicos:

• Recurso – em uma política, você usa um nome de recurso da Amazon (ARN) para identificar o recursoao qual a política se aplica.

• Ação – você usa palavras-chave de ação para identificar as ações do recurso que deseja permitirou negar. Por exemplo, a permissão sqs:CreateQueue permite que o usuário execute a açãoCreateQueue do Amazon Simple Queue Service.

• Efeito – você especifica o efeito quando o usuário solicita a ação específica — que pode ser permitirou negar. Se você não conceder explicitamente acesso a um recurso, o acesso estará implicitamentenegado. Você também pode negar explicitamente o acesso a um recurso a fim de ter certeza de que umusuário não conseguirá acessá-lo, mesmo que uma política diferente conceda acesso.

• Entidade principal – em políticas baseadas em identidade (políticas do IAM), o usuário ao qual a políticaestá anexada é implicitamente a entidade principal. Para as políticas baseadas em recursos, vocêespecifica quais usuários, contas, serviços ou outras entidades deseja que recebam permissões (aplica-se somente a políticas baseadas em recursos).

Para saber mais sobre a sintaxe e as descrições de políticas do Amazon SQS, consulte Referência depolítica do IAM da AWS no Guia do usuário do IAM.

Para ver uma tabela com todas as ações da Amazon Simple Queue Service e os recursos aos quais elasse aplicam, consulte Referência de ações e recursos (p. 165).

Especificação de condições em uma políticaAo conceder permissões, você pode usar a Amazon SQS do Access Policy Language para especificar ascondições de quando uma política deve entrar em vigor. Por exemplo, convém que uma política só sejaaplicada após uma data específica. Para obter mais informações sobre como especificar condições emuma linguagem de política, consulte Condição no Guia do usuário do IAM.

146

id.html

access_permissions.html

access_permissions.html

API_Operations.html



reference_policies_elements.html#Condition

Amazon Simple Queue Service Guia do desenvolvedorUso de políticas com base em identidade (IAM)

Para expressar condições, você usa chaves de condição predefinidas. Não existem chaves de condiçãoespecíficas ao Amazon SQS. No entanto, existem chaves de condição de toda a AWS que você pode usarcom o Amazon SQS. O , Amazon SQS suporta atualmente um conjunto limitado de chaves de condiçõesdisponíveis no IAM:

• aws:CurrentTime

• aws:EpochTime

• aws:SecureTransport

• aws:SourceArn

• aws:SourceIP

• aws:UserAgent

• aws:MultiFactorAuthAge

• aws:MultiFactorAuthPresent

• aws:TokenAge

Uso de políticas com base em identidade (IAM) para oAmazon SQSEste tópico fornece exemplos de políticas baseadas em identidade em que um administrador de contapode anexar políticas de permissões a identidades do IAM (usuários, grupos e funções).

Important

Recomendamos primeiro analisar os tópicos introdutórios que explicam os conceitos básicos eas opções disponíveis para gerenciar o acesso aos recursos do Amazon Simple Queue Service.Para obter mais informações, consulte Visão geral do gerenciamento de permissões de acesso aseus recursos do Amazon Simple Queue Service (p. 142).Com exceção de ListQueues, todas ações do Amazon SQS oferecem suporte a permissõesno nível do recurso. Para obter mais informações, consulte Referência de ações erecursos (p. 165).

Tópicos• Uso de políticas do Amazon SQS e do IAM (p. 147)• Permissões necessárias para usar o console do Amazon SQS (p. 149)• Políticas (predefinidas) gerenciadas pela AWS para o Amazon SQS (p. 149)• Exemplos básicos de políticas do Amazon SQS (p. 149)• Exemplos avançados de políticas do Amazon SQS (p. 151)

Uso de políticas do Amazon SQS e do IAMHá duas maneiras de conceder aos usuários permissões a seus recursos do Amazon SQS: usando osistema de políticas do Amazon SQS e do IAM. Você pode usar um, o outro ou ambos. Na maioria doscasos, você obtém o mesmo resultado com qualquer um deles.

Por exemplo, o diagrama a seguir mostra uma política do IAM e uma política equivalente do Amazon SQS.A política do IAM concede os direitos às ações ReceiveMessage e SendMessage do Amazon SQS paraa fila denominada queue_xyz em sua conta da AWS, e a política é anexada aos usuários Bob e Susan(Bob e Susan têm as permissões declaradas na política). Essa política do Amazon SQS também concedea Bob e Susan direitos às ações ReceiveMessage e SendMessage para a mesma fila.

147

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys


Note

Esse exemplo mostra políticas simples sem condições. Você pode especificar uma determinadacondição na política e obter o mesmo resultado.

Há uma diferença importante entre as políticas do IAM e do Amazon SQS: o sistema de política doAmazon SQS permite conceder permissões a outras contas da AWS, enquanto o IAM não permite.

Você é quem decide como usar os dois sistemas para gerenciar suas permissões. Os exemplos a seguirmostram como os dois sistemas de política funcionam em conjunto.

• No primeiro exemplo, Bob tem uma política do IAM e uma política do Amazon SQS que se aplicamà sua conta. A política do IAM concede à sua conta permissão para a ação ReceiveMessageem queue_xyz, enquanto a política do Amazon SQS fornece à sua conta permissão para a açãoSendMessage na mesma fila. O seguinte diagrama ilustra o conceito.

Se Bob enviar uma solicitação ReceiveMessage a queue_xyz, a política do IAM permitirá a ação. SeBob enviar uma solicitação SendMessage a queue_xyz, a política do Amazon SQS permitirá a ação.

• No segundo exemplo, Bob abusa de seu acesso a queue_xyz, para que seja necessário remover todoo seu acesso à fila. O mais fácil a fazer é adicionar uma política que negue a ele acesso a todas asações para a fila. Essa política substitui as outras duas, pois uma deny explícita sempre substitui umaallow. Para obter mais informações sobre a lógica de avaliação da política, consulte Uso de políticaspersonalizadas com a Access Policy Languagedo Amazon SQS (p. 155). O seguinte diagrama ilustra oconceito.

148


Você também pode adicionar outra instrução à política do Amazon SQS que nega a Bob qualquer tipode acesso à fila. Ela tem o mesmo efeito que a adição de uma política do IAM que nega o acesso deBob à fila. Para obter exemplos de políticas que abrangem ações e recursos do Amazon SQS, consulteExemplos avançados de políticas do Amazon SQS (p. 151). Para obter mais informações sobre comoescrever políticas do Amazon SQS, consulte Uso de políticas personalizadas com a Access PolicyLanguagedo Amazon SQS (p. 155).

Permissões necessárias para usar o console do Amazon SQSUm usuário que queira trabalhar com o console do Amazon SQS deve ter o conjunto mínimo depermissões para trabalhar com as filas do Amazon SQS na conta da AWS do usuário. Por exemplo,o usuário deve ter a permissão para chamar a ação ListQueues a fim de poder listar as filas, ou apermissão para chamar a ação CreateQueue para poder criar filas. Além de permissões do AmazonSQS, para inscrever uma fila do Amazon SQS em um tópico do Amazon SNS, o console também exigepermissões para ações do Amazon SNS.

Se você criar uma política do IAM que seja mais restritiva que as permissões mínimas necessárias, oconsole poderá não funcionar como pretendido para os usuários com essa política do IAM.

Você não precisa conceder permissões mínimas do console aos usuários que fazem chamadas apenaspara as ações da AWS CLI ou do Amazon SQS.

Políticas (predefinidas) gerenciadas pela AWS para o AmazonSQSA AWS resolve muitos casos de uso comuns fornecendo políticas do IAM autônomas, gerenciadas pelaAWS. Essas políticas gerenciadas pela AWS simplificam o trabalho com permissões por conceder aspermissões necessárias para casos de uso comuns. Para obter mais informações, consulte Políticasgerenciadas pela AWS no Guia do usuário do IAM.

As seguintes políticas gerenciadas pela AWS, que você pode associar a usuários em sua conta, sãoespecíficas ao Amazon SQS:

• AmazonSQSReadOnlyAccess – concede acesso somente leitura às filas do Amazon SQS usando oConsole de gerenciamento da AWS.

• AmazonSQSFullAccess – concede acesso total às filas do Amazon SQS usando o Console degerenciamento da AWS.

Você pode pesquisar e analisar políticas disponíveis no console do IAM. Você também pode criar suaspróprias políticas personalizadas do IAM para permitir permissões para ações e filas do Amazon SQS.Você pode anexar essas políticas personalizadas a usuários ou grupos do IAM que exijam permissões.

Exemplos básicos de políticas do Amazon SQSOs exemplos a seguir fornecem uma introdução às políticas de permissão do Amazon SQS.

Exemplo 1: Permitir que um usuário crie filas

No exemplo a seguir, criamos uma política para Bob que lhe permite acessar todas as ações do AmazonSQS, mas apenas com as filas cujos nomes estejam prefixados com a string literal bob_queue_.

O Amazon SQS não concede automaticamente ao criador de uma fila permissões para usar a fila.Portanto, devemos conceder explicitamente permissões a Bob para usar todas as ações do Amazon SQS,além da ação CreateQueue na política do IAM.

149

access_policies_managed-vs-inline.html#aws-managed-policies

access_policies_managed-vs-inline.html#aws-managed-policies


{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:123456789012:bob_queue_*" }]}

Exemplo 2: Permitir que desenvolvedores gravem mensagens em uma filacompartilhada

No exemplo a seguir, criamos um grupo para desenvolvedores e anexamos uma política que permite queo grupo use a ação SendMessage do Amazon SQS, mas apenas com a fila que pertence à conta da AWSespecificada e é denominada MyCompanyQueue.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:*:123456789012:MyCompanyQueue" }]}

Você pode usar * em vez de SendMessage para conceder as seguintes ações a um principal emuma fila compartilhada: ChangeMessageVisibility, DeleteMessage, GetQueueAttributes,GetQueueUrl, ReceiveMessage e SendMessage.

Note

Embora * inclua o acesso fornecido por outros tipos de permissão, o Amazon SQS considera aspermissões separadamente. Por exemplo, é possível conceder permissões * e SendMessage aum usuário, embora * inclua o acesso fornecido pelo SendMessage.Esse conceito também se aplica quando você remove uma permissão. Se uma entidade principaltiver apenas uma permissão *, a solicitação de remoção de uma permissão SendMessage nãodeixará a entidade principal com uma permissão do tipo tudo, exceto. Em vez disso, a solicitaçãonão fará nada, pois a entidade principal não tinha uma permissão SendMessage explícita. Paradeixar a entidade principal apenas com a permissão ReceiveMessage, adicione primeiro apermissão ReceiveMessage e, em seguida, remova a permissão *.

Exemplo 3: Permitir que gerentes obtenham o tamanho geral de filas

No exemplo a seguir, criamos um grupo para gerentes e anexamos uma política que permite que o grupouse a ação GetQueueAttributes do Amazon SQS com todas as filas que pertencem à conta da AWSespecificada.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:GetQueueAttributes", "Resource": "*" }]}

150


Exemplo 4: Permitir que um parceiro envie mensagens para uma fila específica

Você pode realizar essa tarefa usando uma política do Amazon SQS ou do IAM. Se o parceiro tiver umaconta da AWS, pode ser mais fácil usar uma política do Amazon SQS. No entanto, qualquer usuário daempresa do parceiro que possua as credenciais de segurança da AWS pode enviar mensagens à fila. Paralimitar o acesso a um determinado usuário ou aplicativo, você deve tratar o parceiro como um usuário emsua própria empresa e usar uma política do IAM em vez de uma política do Amazon SQS.

Esse exemplo executa as seguintes ações:

1. Criar um grupo chamado WidgetCo para representar a empresa do parceiro.2. Criar um usuário para o usuário ou aplicativo específico na empresa do parceiro que precisa de

acesso.3. Adicionar o usuário ao grupo.4. Anexar uma política que ofereça ao grupo acesso apenas à ação SendMessage somente para a fila

denominada WidgetPartnerQueue.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:*:123456789012:WidgetPartnerQueue" }]}

Exemplos avançados de políticas do Amazon SQSEsta seção mostra políticas de exemplo para casos de uso comuns do Amazon SQS.

Você pode usar o console para verificar os efeitos de cada política à medida que anexa a política aousuário. Inicialmente, o usuário não tem permissões e, portanto, não poderá fazer nada no console. Àmedida que você anexar políticas ao usuário, poderá verificar se o usuário pode executar várias ações noconsole.

Note

Recomendamos usar duas janelas do navegador: uma para conceder as permissões e a outrapara fazer login no Console de gerenciamento da AWS usando as credenciais do usuário paraverificar as permissões conforme forem concedidas ao usuário.

Exemplo 1: Conceder uma permissão a uma conta da AWS

A política de exemplo a seguir concede ao número de conta da AWS 111122223333 a permissãoSendMessage para a fila denominada 444455556666/queue1 na região Leste dos EUA (Ohio).

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_SendMessage", "Effect": "Allow", "Principal": { "AWS": [ "111122223333" ]

151


}, "Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:us-east-2:444455556666:queue1" }] }

Exemplo 2: Conceder duas permissões a uma conta da AWS

A política de exemplo a seguir concede ao número de conta da AWS 111122223333 as permissõesSendMessage e ReceiveMessage para a fila denominada 444455556666/queue1.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_Send_Receive", "Effect": "Allow", "Principal": { "AWS": [ "111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:*:444455556666:queue1" }]}

Exemplo 3: Conceder todas as permissões a duas contas da AWS

A política de exemplo a seguir concede a dois números de contas da AWS diferentes (111122223333e 444455556666) permissão para usar todas as ações às quais o Amazon SQS permite acessocompartilhado para a fila denominada 123456789012/queue1 na região Leste dos EUA (Ohio).

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AllActions", "Effect": "Allow", "Principal": { "AWS": [ "111122223333", "444455556666" ] }, "Action": "sqs:*", "Resource": "arn:aws:sqs:us-east-2:123456789012:queue1" }]}

Exemplo 4: Conceder permissões entre contas a uma função e um nome deusuário

A política de exemplo a seguir concede a role1 e username1 sob o número de conta da AWS111122223333 permissão entre contas para usar todas as ações às quais o Amazon SQS permite acessocompartilhado para a fila denominada 123456789012/queue1 na região Leste dos EUA (Ohio).

152


Permissões entre contas não são aplicáveis às ações a seguir:

• AddPermission

• CreateQueue

• DeleteQueue

• ListQueues

• ListQueueTags



• TagQueue

• UntagQueue

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AllActions", "Effect": "Allow", "Principal": { "AWS": [ "arn:aws:iam::111122223333:role/role1", "arn:aws:iam::111122223333:user/username1" ] }, "Action": "sqs:*", "Resource": "arn:aws:sqs:us-east-2:123456789012:queue1" }]}

Exemplo 5: Conceder uma permissão a todos os usuários

O exemplo de política a seguir concede a todos os usuários (anônimos) a permissão ReceiveMessagepara a fila denominada 111122223333/queue1.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AnonymousAccess_ReceiveMessage", "Effect": "Allow", "Principal": "*", "Action": "sqs:ReceiveMessage", "Resource": "arn:aws:sqs:*:111122223333:queue1" }]}

Exemplo 6: Conceder uma permissão de tempo limitado a todos os usuários

O exemplo de política a seguir concede a todos os usuários (anônimos) a permissão ReceiveMessagepara a fila denominada 111122223333/queue1, mas apenas das 12h (meio dia) às 15h em 31 de janeirode 2009.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID",

153











"Statement": [{ "Sid":"Queue1_AnonymousAccess_ReceiveMessage_TimeLimit", "Effect": "Allow", "Principal": "*", "Action": "sqs:ReceiveMessage", "Resource": "arn:aws:sqs:*:111122223333:queue1", "Condition" : { "DateGreaterThan" : { "aws:CurrentTime":"2009-01-31T12:00Z" }, "DateLessThan" : { "aws:CurrentTime":"2009-01-31T15:00Z" } } }]}

Exemplo 7: Conceder todas as permissões a todos os usuários em um intervaloCIDR

A política de exemplo a seguir concede a todos os usuários (anônimos) permissão para usar todas asações possíveis do Amazon SQS que podem ser compartilhadas para a fila denominada 111122223333/queue1, mas somente se a solicitação vier do intervalo CIDR 192.168.143.0/24.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AnonymousAccess_AllActions_WhitelistIP", "Effect": "Allow", "Principal": "*", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:111122223333:queue1", "Condition" : { "IpAddress" : { "aws:SourceIp":"192.168.143.0/24" } } }]}

Exemplo 8: Lista de permissões e lista negra de permissões para usuários emdiferentes intervalos CIDR

O exemplo de política a seguir contém duas instruções:

• A primeira instrução concede a todos os usuários (anônimos) no intervalo 192.168.143.0/24 CIDR(exceto para 192.168.143.188) permissão para usar a ação SendMessage para a fila denominada111122223333/queue1.

• A segunda instrução proíbe que todos os usuários (anônimos) no intervalo 10.1.2.0/24 CIDR usem afila.

{ "Version": "2012-10-17", "Id": "Queue1_Policy_UUID", "Statement": [{ "Sid":"Queue1_AnonymousAccess_SendMessage_IPLimit", "Effect": "Allow",

154

Amazon Simple Queue Service Guia do desenvolvedorUso de políticas personalizadascom o Access Policy Language

"Principal": "*", "Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:*:111122223333:queue1", "Condition" : { "IpAddress" : { "aws:SourceIp":"192.168.143.0/24" }, "NotIpAddress" : { "aws:SourceIp":"192.168.143.188/32" } } }, { "Sid":"Queue1_AnonymousAccess_AllActions_IPLimit_Deny", "Effect": "Deny", "Principal": "*", "Action": "sqs:*", "Resource": "arn:aws:sqs:*:111122223333:queue1", "Condition" : { "IpAddress" : { "aws:SourceIp":"10.1.2.0/24" } } }]}

Uso de políticas personalizadas com a Access PolicyLanguagedo Amazon SQSPara permitir acesso ao Amazon SQS com base apenas em um ID de conta da AWS e permissões básicas(como SendMessage ou ReceiveMessage), você não precisa criar suas próprias políticas. Você só podeusar a ação AddPermission do Amazon SQS.

Para negar ou permitir explicitamente o acesso com base em condições mais específicas (comoo momento em que a solicitação é recebida ou o endereço IP do solicitante), precisa criar suaspróprias políticas do Amazon SQS e obtê-las por upload no sistema da AWS usando a açãoSetQueueAttributes do Amazon SQS.

Tópicos• Arquitetura do controle de acesso do Amazon SQS (p. 155)• Fluxo de trabalho do processo de controle de acesso do Amazon SQS (p. 156)• Conceitos principais da Access Policy Language do Amazon SQS (p. 157)• Lógica de avaliação da Access Policy Language do Amazon SQS (p. 158)• Relações entre negações explícitas e padrão na Access Policy Language do Amazon SQS (p. 160)• Exemplos personalizados da Access Policy Language do Amazon SQS (p. 161)

Arquitetura do controle de acesso do Amazon SQSO diagrama a seguir descreve o controle de acesso para seus recursos do Amazon SQS.

155





Você, o proprietário do recurso.

Seus recursos contidos no serviço da AWS, (por exemplo, filas do Amazon SQS).

Suas políticas. É uma boa prática ter uma política por recurso. O próprio serviço da AWS fornece umaAPI que você usa para fazer upload e gerenciar suas políticas.

Os solicitantes e suas solicitações de entrada para o serviço da AWS.

O código de avaliação do access policy language. Esse é o conjunto de códigos dentro do serviço daAWS que avalia as solicitações de entrada em relação às políticas aplicáveis e determina se o solicitantetem o acesso permitido ao recurso.

Fluxo de trabalho do processo de controle de acesso do AmazonSQSO diagrama a seguir descreve o fluxo de trabalho geral do controle de acesso com a access policylanguage do Amazon SQS.

156


Você grava uma política do Amazon SQS para a fila.

Você carrega a política na AWS. O serviço da AWS fornece uma API que você usa para fazer upload desuas políticas. Por exemplo, você usa a ação SetQueueAttributes do Amazon SQS para fazer uploadde uma política para uma determinada fila do Amazon SQS.

Alguém envia uma solicitação para usar sua fila do Amazon SQS.

O Amazon SQS examina todas as políticas do Amazon SQS disponíveis e determina quais sãoaplicáveis.

O Amazon SQS avalia as políticas e determina se o solicitante tem permissão para usar sua fila.

Com base no resultado da avaliação da política, o Amazon SQS retorna um erro Access denied parao solicitante ou continua a processar a solicitação.

Conceitos principais da Access Policy Language do AmazonSQSPara criar suas próprias políticas, você deve estar familiarizado com JSON e um número de conceitos-chave.

permitir

O resultado de uma instrução (p. 158) que tenha efeito; (p. 157) definido como allow.action

A atividade que o principal (p. 158) tem permissão para executar, normalmente uma solicitação paraa AWS.

negação padrão

O resultado de uma instrução (p. 158) que não tenha as configurações permitir (p. 157) nemnegação explícita (p. 158).

condição

Qualquer restrição ou detalhe sobre uma permissão (p. 158). Condições comuns são relacionadas adata e hora e a endereços IP.

efeito;

O resultado que você deseja que a instrução (p. 158) de uma política (p. 158) retorno nomomento da avaliação. Você especifica o valor deny ou allow ao gravar a declaração de política.Há três resultados possíveis no momento da avaliação da política: negação padrão (p. 157),permitir (p. 157) e negação explícita (p. 158).

157

http://json.org/


negação explícita

O resultado de uma instrução (p. 158) que tenha efeito; (p. 157) definido como deny.avaliação

O processo que o Amazon SQS usa para determinar se uma solicitação recebida deve ser negada oupermitida com base em uma política (p. 158).

emissor

O usuário que grava uma política (p. 158) para conceder permissões a um recurso. O emissor, pordefinição, é sempre o proprietário do recurso. A AWS não permite que usuários do Amazon SQScriem políticas para recursos dos quais não são proprietários.

chave

A característica específica que é a base para a restrição de acesso.permissão

O conceito de permissão ou não de acesso a um recurso usando uma condição (p. 157) e umachave (p. 158).

política

O documento que atua como um contêiner para uma ou mais instruções (p. 158).

O Amazon SQS usa a política para determinar se deve conceder acesso a um usuário para umrecurso.

principal

O usuário que recebe permissão (p. 158) na política (p. 158).recurso

O objeto ao qual a principal (p. 158) solicita acesso.instrução

A descrição formal de uma única permissão, escrita na access policy language como parte de umdocumento de política (p. 158) mais amplo.

solicitante

O usuário que envia uma solicitação de acesso a um recurso (p. 158).

Lógica de avaliação da Access Policy Language do Amazon SQSNo momento da avaliação, o Amazon SQS determina se uma solicitação de alguém que não seja oproprietário do recurso deve ser permitida ou negada. A lógica de avaliação segue várias regras básicas:

158


• Por padrão, todas as solicitações para usar o recurso que venham de outras pessoas, e não de você,serão negadas.

• Um permitir (p. 157) substitui qualquer negação padrão (p. 157).• Uma negação explícita (p. 158) substitui qualquer permissão.• A ordem em que as políticas são avaliadas não é importante.

O diagrama a seguir descreve em detalhes como o Amazon SQS avalia decisões sobre permissões deacesso.

A decisão começa com uma negação padrão.

O código de aplicação avalia todas as políticas que são aplicáveis à solicitação (com base no recurso,na entidade principal, na ação e nas condições). A ordem em que o código de aplicação avalia as políticasnão é importante.

O código de imposição procura uma instrução de negação explícita que possa ser aplicada à solicitação.Se encontrar um código, o código de aplicação retornará uma decisão de negação e o processo seráconcluído.

159


Se nenhuma instrução de negação explícita for encontrada, o código de imposição procurará qualquerinstrução de permissão que possa ser aplicada à solicitação. Se encontrar uma instrução "permitir", ocódigo de aplicação retornará uma decisão de permitir, e o processo será concluído (o serviço continua aprocessar a solicitação).

Se nenhuma instrução de permissão for encontrada, a decisão final será negar (como não há nenhumanegação explícita ou permissão, isso é considerado uma negação padrão).

Relações entre negações explícitas e padrão na Access PolicyLanguage do Amazon SQSSe uma política do Amazon SQS não se aplicar diretamente a uma solicitação, a solicitação resultará emuma negação padrão (p. 157). Por exemplo, se um usuário solicitar permissão para usar o Amazon SQS,mas a única política que se aplica ao usuário puder usar o DynamoDB, as solicitações resultarão em umanegação padrão.

Se uma condição em uma instrução não for atendida, a solicitação resultará em uma negação padrão. Setodas as condições em uma instrução forem atendidas, a solicitação resultará em uma permitir (p. 157)ou com base no valor do elemento da política. negação explícita (p. 158)efeito; (p. 157) As políticasnão especificam o que fazer se uma condição não for atendida, portanto, o resultado padrão nesse casoé uma negação padrão. Por exemplo, digamos que você deseje evitar solicitações da Antártica. Vocêelabora uma Política A1 que permite uma solicitação apenas se não vier da Antártica. O diagrama a seguirilustra a política do Amazon SQS.

Se um usuário enviar uma solicitação dos EUA, a condição será atendida (a solicitação não será daAntártica) e a solicitação resultará em uma permissão. No entanto, se um usuário enviar uma solicitaçãoda Antártica, a condição não será atendida, e a solicitação será padronizada para uma solicitação padrão.Você pode alterar o resultado para uma negação explícita criando a Política A2 que nega explicitamenteuma solicitação quando ela for recebida da Antártica. O seguinte diagrama ilustra a política.

Se um usuário enviar uma solicitação da Antártica, a condição será atendida, e a solicitação resultará emuma negação explícita.

A distinção entre uma negação padrão e uma negação explícita é importante porque uma permissão podesubstituir a anterior, mas não a última. Por exemplo, a Política B permite solicitações que cheguem em 1ºde junho de 2010. O diagrama a seguir compara a combinação dessa política com Política A1 e PolíticaA2.

160


No Cenário 1, a Política A1 resulta em uma negação padrão e a Política B resulta em uma permissãoporque a política permite solicitações recebidas em primeiro de junho de 2010. A permissão da Política Bsubstitui a negação padrão da Política A1, e a solicitação é permitida.

No Cenário 2, a Política B2 resulta em uma negação explícita, e a Política B resulta em uma permissão. Anegação explícita da Política A2 substitui a permissão da Política B, e a solicitação é negada.

Exemplos personalizados da Access Policy Language doAmazon SQSOs seguintes são exemplos de políticas de acesso típicas do Amazon SQS.

161


Exemplo 1: Conceder permissão a uma contaO exemplo de política do Amazon SQS a seguir concede à conta da AWS 111122223333 permissão paraenviar para e receber da queue2 de propriedade da conta 444455556666 da AWS.

{ "Version": "2012-10-17", "Id": "UseCase1", "Statement" : [{ "Sid": "1", "Effect": "Allow", "Principal": { "AWS": [ "111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:us-east-2:444455556666:queue2" }]}

Exemplo 2: Conceder permissão a uma ou mais contasA política de exemplo do Amazon SQS a seguir fornece a uma ou mais contas da AWS acesso a filas depropriedade de sua conta por um período específico. É necessário escrever essa política e fazer uploadpara o Amazon SQS usando a ação SetQueueAttributes porque a ação AddPermission não permiteespecificar uma restrição de tempo ao conceder acesso a uma fila.

{ "Version": "2012-10-17", "Id": "UseCase2", "Statement" : [{ "Sid": "1", "Effect": "Allow", "Principal": { "AWS": [ "111122223333", "444455556666" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:us-east-2:444455556666:queue2", "Condition": { "DateLessThan": { "AWS:CurrentTime": "2009-06-30T12:00Z" } } }]}

Exemplo 3: Conceder permissão para solicitações de instâncias do Amazon EC2A política de exemplo do Amazon SQS a seguir fornece acesso a solicitações provenientes de instânciasdo Amazon EC2. Esse exemplo se baseia no exemplo "Exemplo 2: Conceder permissão a uma ou maiscontas (p. 162)": ele restringe o acesso a antes de 30 de junho de 2009 ao meio-dia (UTC), que restringeo acesso ao intervalo de IP 10.52.176.0/24. É necessário escrever essa política e fazer upload para

162



Amazon Simple Queue Service Guia do desenvolvedorUso de credenciais de segurança temporárias

o Amazon SQS usando a ação SetQueueAttributes porque a ação AddPermission não permiteespecificar uma restrição de endereço IP ao conceder acesso a uma fila.

{ "Version": "2012-10-17", "Id": "UseCase3", "Statement" : [{ "Sid": "1", "Effect": "Allow", "Principal": { "AWS": [ "111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:us-east-2:444455556666:queue2", "Condition": { "DateLessThan": { "AWS:CurrentTime": "2009-06-30T12:00Z" }, "IpAddress": { "AWS:SourceIp": "10.52.176.0/24" } } }]}

Exemplo 4: Negar acesso a uma conta específicaA política de exemplo do Amazon SQS a seguir nega a uma conta específica da AWS acesso à sua fila.Esse exemplo se baseia no exemplo "Exemplo 1: Conceder permissão a uma conta (p. 162)": ele negao acesso à conta da AWS especificada. É necessário escrever essa política e fazer upload para o AmazonSQS usando a ação SetQueueAttributes porque a ação AddPermission não permite negar acesso auma fila (permite apenas conceder acesso a uma fila).

{ "Version": "2012-10-17", "Id": "UseCase4", "Statement" : [{ "Sid": "1", "Effect": "Deny", "Principal": { "AWS": [ "111122223333" ] }, "Action": [ "sqs:SendMessage", "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:us-east-2:444455556666:queue2" }]}

Uso de credenciais de segurança temporáriasAlém de criar usuários do IAM com suas próprias credenciais de segurança, o IAM também permiteconceder credenciais de segurança temporárias a qualquer usuário, permitindo que o usuário acesse os

163





Amazon Simple Queue Service Guia do desenvolvedorUso de credenciais de segurança temporárias

serviços e recursos da AWS. Você pode gerenciar os usuários que têm contas da AWS (usuários do IAM).Você também pode gerenciar usuários do sistema que não têm contas da AWS (usuários federados).Além disso, os aplicativos criados para acessar seus recursos da AWS também podem ser considerados"usuários".

Use essas credenciais de segurança temporárias para fazer solicitações ao Amazon SQS. As bibliotecasde API calculam o valor de assinatura necessário usando essas credenciais para autenticar suasolicitação. Se você enviar solicitações usando credenciais expiradas, o Amazon SQS negará asolicitação.

Note

Você não pode definir uma política com base em credenciais temporárias.

Pré-requisitos1. Use o IAM para criar credenciais de segurança temporárias:

• Token de segurança• Access Key ID• Secret Access Key

2. Prepare sua string para assinar com o ID da chave de acesso temporária e o token de segurança.3. Use a chave de acesso secreta temporária em vez de sua própria chave de acesso secreta para

assinar a solicitação de API de consulta.

Note

Quando você enviar a solicitação de API de consulta assinada, use o ID da chave de acessotemporária em vez de seu próprio ID da chave de acesso e para incluir o token de segurança.Para obter mais informações sobre o suporte do IAM a credenciais de segurança temporárias,consulte Concessão de acesso temporário a seus recursos da AWS no Guia do usuário do IAM.

Para chamar uma ação de API de consulta do Amazon SQSusando credenciais de segurança temporárias1. Solicite um token de segurança temporário usando o AWS Identity and Access Management. Para

obter mais informações, consulte Criação de credencias de segurança temporárias para habilitar oacesso para usuários do IAM no Guia do usuário do IAM.

O IAM retorna um token de segurança, um ID de chave de acesso e uma chave de acesso secreta.2. Prepare sua consulta usando o ID da chave de acesso temporária em vez de seu próprio ID da chave

de acesso e para incluir o token de segurança. Assine sua solicitação usando a chave de acessosecreta temporária em vez de sua própria.

3. Envie sua string de consulta assinada com o ID da chave de acesso temporária e o token desegurança.

O exemplo a seguir demonstra como usar credenciais de segurança temporárias para autenticar umasolicitação do Amazon SQS. A estrutura de AUTHPARAMS depende da assinatura de solicitação deAPI. Para obter mais informações, consulte Assinatura de solicitações de API da AWS na Referênciageral da Amazon Web Services.

https://sqs.us-east-2.amazonaws.com/?Action=CreateQueue&DefaultVisibilityTimeout=40&QueueName=MyQueue&Attribute.1.Name=VisibilityTimeout

164

TokenBasedAuth.html

CreatingSessionTokens.html

CreatingSessionTokens.html

https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html

Amazon Simple Queue Service Guia do desenvolvedorReferência de permissões da API

&Attribute.1.Value=40&Expires=2020-12-18T22%3A52%3A43PST&SecurityToken=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Version=2012-11-05&AUTHPARAMS

O exemplo a seguir usa credenciais de segurança temporárias para enviar duas mensagens usando aação SendMessageBatch.

https://sqs.us-east-2.amazonaws.com/?Action=SendMessageBatch&SendMessageBatchRequestEntry.1.Id=test_msg_001&SendMessageBatchRequestEntry.1.MessageBody=test%20message%20body%201&SendMessageBatchRequestEntry.2.Id=test_msg_002&SendMessageBatchRequestEntry.2.MessageBody=test%20message%20body%202&SendMessageBatchRequestEntry.2.DelaySeconds=60&Expires=2020-12-18T22%3A52%3A43PST&SecurityToken=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY&AWSAccessKeyId=AKIAI44QH8DHBEXAMPLE&Version=2012-11-05&AUTHPARAMS

Permissões da API Amazon SQS: referência de açõese recursosAo configurar o Controle de acesso (p. 141) e escrever políticas de permissões que você pode anexara uma identidade do IAM, você pode usar a tabela a seguir como referência. A lista inclui cada ação daAmazon Simple Queue Service, as ações correspondentes às quais você pode conceder permissões pararealizar a ação, e o recurso da AWS ao qual você pode conceder as permissões.

Especifique as ações no campo Action da política e o valor do recurso no campo Resource dapolítica. Para especificar uma ação, use o prefixo sqs: seguido do nome da ação da (por exemplo,sqs:CreateQueue).

O , Amazon SQS suporta atualmente um conjunto limitado de chaves de condições disponíveis no IAM:

• aws:CurrentTime

• aws:EpochTime

• aws:SecureTransport

• aws:SourceArn

• aws:SourceIP

• aws:UserAgent

• aws:MultiFactorAuthAge

• aws:MultiFactorAuthPresent

• aws:TokenAge

API Amazon Simple Queue Service e permissões necessárias para ações

AddPermission

Ação/Ações: sqs:AddPermission

Recurso: arn:aws:sqs:region:account_id:queue_name

165

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys


Amazon Simple Queue Service Guia do desenvolvedorReferência de permissões da API

ChangeMessageVisibility

Ação/Ações: sqs:ChangeMessageVisibility

Recurso: arn:aws:sqs:region:account_id:queue_nameChangeMessageVisibilityBatch

Ação/Ações: sqs:ChangeMessageVisibilityBatch

Recurso: arn:aws:sqs:region:account_id:queue_nameCreateQueue

Ação/Ações: sqs:CreateQueue

Recurso: arn:aws:sqs:region:account_id:queue_nameDeleteMessage

Ação/Ações: sqs:DeleteMessage

Recurso: arn:aws:sqs:region:account_id:queue_nameDeleteMessageBatch

Ação/Ações: sqs:DeleteMessageBatch

Recurso: arn:aws:sqs:region:account_id:queue_nameDeleteQueue

Ação/Ações: sqs:DeleteQueue

Recurso: arn:aws:sqs:region:account_id:queue_nameGetQueueAttributes

Ação/Ações: sqs:GetQueueAttributes

Recurso: arn:aws:sqs:region:account_id:queue_nameGetQueueUrl

Ação/Ações: sqs:GetQueueUrl

Recurso: arn:aws:sqs:region:account_id:queue_nameListDeadLetterSourceQueues

Ação/Ações: sqs:ListDeadLetterSourceQueues

Recurso: arn:aws:sqs:region:account_id:queue_nameListQueues

Ação/Ações: sqs:ListQueues

Recurso: arn:aws:sqs:region:account_id:queue_nameListQueueTags

Ação/Ações: sqs:ListQueueTags

Recurso: arn:aws:sqs:region:account_id:queue_namePurgeQueue

Ação/Ações: sqs:PurgeQueue

166





API_DeleteMessageBatch.html

API_DeleteQueue.html


API_GetQueueUrl.html

API_ListDeadLetterSourceQueues.html

API_ListQueues.html


API_PurgeQueue.html

Amazon Simple Queue Service Guia do desenvolvedorCriptografia do lado do servidor

Recurso: arn:aws:sqs:region:account_id:queue_nameReceiveMessage

Ação/Ações: sqs:ReceiveMessage

Recurso: arn:aws:sqs:region:account_id:queue_nameRemovePermission

Ação/Ações: sqs:RemovePermission

Recurso: arn:aws:sqs:region:account_id:queue_nameSendMessage e SendMessageBatch

Ação/Ações: sqs:SendMessage

Recurso: arn:aws:sqs:region:account_id:queue_nameSetQueueAttributes

Ação/Ações: sqs:SetQueueAttributes

Recurso: arn:aws:sqs:region:account_id:queue_nameTagQueue

Ação/Ações: sqs:TagQueue

Recurso: arn:aws:sqs:region:account_id:queue_nameUntagQueue

Ação/Ações: sqs:UntagQueue

Recurso: arn:aws:sqs:region:account_id:queue_name

Proteção de dados usando criptografia no lado doservidor (SSE) e AWS KMS

O SSE permite transmitir dados confidenciais em filas criptografadas. O SSE protege o conteúdo dasmensagens em filas Amazon SQS usando chaves gerenciadas no AWS Key Management Service (AWSKMS). Para obter informações sobre como gerenciar SSE usando o Console de gerenciamento da AWSou o AWS SDK for Java (e as ações CreateQueue, SetQueueAttributes e GetQueueAttributes),consulte os tutoriais a seguir:

• Criação de uma fila com (p. 20)• Configuração de uma fila existente. (p. 50)• Habilitar a compatibilidade entre os serviços da AWS e as filas com (p. 173)

A SSE criptografa mensagens assim que o Amazon SQS as recebe. As mensagens são armazenadas noformato criptografado e o Amazon SQS as descriptografa apenas quando elas são enviadas a um usuárioautorizado.

Important

Todas as solicitações para filas com SSE ativado devem usar HTTPS e Signature versão 4.Não é possível associar uma fila criptografada (p. 167) que usa uma chave mestre de clientegerenciada pela AWS para o Amazon SQS a uma função Lambda em outra conta da AWS.

167


API_RemovePermission.html




API_TagQueue.html

API_UntagQueue.html





Amazon Simple Queue Service Guia do desenvolvedorO que a SSE faz para a criptografia do Amazon SQS?

Alguns recursos dos serviços da AWS que podem enviar notificações para Amazon SQS usandoa ação AWS Security Token Service AssumeRole de que sejam compatíveis com SSE masfuncionam somente com as filas padrão:

• Ganchos de ciclo de vida Auto Scaling• Dead Letter Queues AWS Lambda

Outros recursos dos serviços da AWS ou serviços de terceiros, que enviam notificações aoAmazon SQS que não sejam compatíveis com SSE, apesar de permitirem que você defina umafila criptografada como destino:

• Ações de regra AWS IoT

Para obter informações sobre a compatibilidade de outros serviços com as filas criptografadas,consulte Habilitar a compatibilidade entre os serviços da AWS e as filas com (p. 173) e adocumentação do serviço.

O AWS KMS combina hardware e software seguros e altamente disponíveis para fornecer um sistema degerenciamento de chaves escalado para a nuvem. Quando você usa o Amazon SQS com o AWS KMS,as chaves de dados (p. 169) que criptografam os dados da mensagem também são criptografadas earmazenadas com os dados que protegem.

Os benefícios de usar o AWS KMS são os seguintes:

• Você mesmo pode criar e gerenciar CMKs (Customer master keys – Chaves principais docliente) (p. 169).

• Você também pode usar a CMK gerenciada pela AWS para o Amazon SQS, que é exclusiva para cadaconta e região.

• Os padrões de segurança do AWS KMS podem ajudá-lo a atender aos requisitos de compatibilidaderelacionados à criptografia.

Para obter mais informações, consulte O que é o AWS Key Management Service? no AWS KeyManagement Service Developer Guide e o whitepaper Detalhes da criptografia do AWS Key ManagementService.

Tópicos• O que a SSE faz para a criptografia do Amazon SQS? (p. 168)• Termos-chave (p. 169)• Como o período de reutilização de chaves de dados funciona? (p. 170)• Como estimar meus custos de utilização do AWS KMS? (p. 170)• De quais permissões do AWS KMS eu preciso para usar a SSE para o Amazon SQS? (p. 171)• Erros (p. 174)

O que a SSE faz para a criptografia do Amazon SQS?A SSE criptografa o corpo de uma mensagem em uma fila do Amazon SQS.

A SSE não criptografa o seguinte:

• Metadados de fila (nome e atributos da fila)• Metadados de mensagens (ID de mensagem, carimbo de data/hora e atributos)• Métricas por fila

168

https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html




overview.html

https://d0.awsstatic.com/whitepapers/KMS-Cryptographic-Details.pdf

https://d0.awsstatic.com/whitepapers/KMS-Cryptographic-Details.pdf

Amazon Simple Queue Service Guia do desenvolvedorTermos-chave

A criptografia de uma mensagem indisponibiliza seu conteúdo para usuários não autorizados ou anônimos.Isso não afeta o funcionamento normal do Amazon SQS:

• Uma mensagem só será criptografada se for enviada após a habilitação da criptografia de uma fila. OAmazon SQS não criptografa mensagens com lista de pendências.

• Qualquer mensagem criptografada permanecerá dessa forma mesmo se a criptografia de sua fila fordesabilitada.

A transferência de uma mensagem para uma dead letter queue (p. 86) não afeta sua criptografia:

• Quando o Amazon SQS move uma mensagem de uma fila de origem criptografada para uma dead letterqueue não criptografada, a mensagem permanece criptografada.

• Quando o Amazon SQS move uma mensagem de uma fila de origem não criptografada para uma deadletter queue criptografada, a mensagem permanece descriptografada.

Termos-chaveOs seguintes termos-chave podem ajudar você a entender melhor a funcionalidade da SSE. Para obterdescrições detalhadas, consulte Amazon Simple Queue Service API Reference.

Chave de dados

A chave de criptografia de dados (DEK) responsável por criptografar o conteúdo de mensagens doAmazon SQS.

Para obter mais informações, consulte Chaves de dados no AWS Key Management Service DeveloperGuide e Criptografia de envelope no Guia do desenvolvedor do SDK de criptografia da AWS.

Período de reutilização de chaves de dados

O tempo, em segundos, durante o qual o Amazon SQS pode reutilizar uma chave de dados paracriptografar ou descriptografar mensagens antes de chamar o AWS KMS novamente. Um númerointeiro que representa segundos, entre 60 segundos (1 minuto) e 86.400 segundos (24 horas). Opadrão é 300 (5 minutos). Para obter mais informações, consulte Como o período de reutilização dechaves de dados funciona? (p. 170).

Note

No evento improvável de não poder acessar o AWS KMS, o Amazon SQS continua a usar achave de dados armazenada em cache até que uma conexão seja restabelecida.

ID da chave mestra do cliente

O alias, o ARN do alias, o ID de chave ou o ARN da chave de uma chave mestra do cliente (CMK)gerenciada pela AWS ou uma CMK personalizada — em sua conta ou em outra conta. Embora oalias da CMK gerenciada pela AWS para o Amazon SQS seja sempre alias/aws/sqs, o alias deuma CMK personalizada pode, por exemplo, ser alias/MyAlias. Você pode usar essas CMKs paraproteger as mensagens em filas do Amazon SQS.

Note


gerenciada pela AWS para o Amazon SQS. Para obter instruções sobre como criar CMKspersonalizadas, consulte Criação de chaves no AWS Key Management Service DeveloperGuide.


169

concepts.html#data-keys

how-it-works.html#envelope-encryption


Amazon Simple Queue Service Guia do desenvolvedorComo o período de reutilizaçãode chaves de dados funciona?


Você pode criar CMKs, definir as políticas que controlam como as CMKs podem ser usadas e auditaro uso da CMK utilizando a seção Chaves de criptografia do console do AWS KMS ou usando açõesdo AWS KMS. Para obter mais informações sobre CMKs, consulte Chaves mestras do cliente no AWSKey Management Service Developer Guide. Para obter mais exemplos de identificadores de CMK,consulte KeyId no AWS Key Management Service API Reference.

Important

Não há custos adicionais por usar o AWS KMS. Para obter mais informações, consulte Comoestimar meus custos de utilização do AWS KMS? (p. 170) e Definição de preço do AWSKey Management Service.

Como o período de reutilização de chaves de dadosfunciona?O Amazon SQS usa uma única chave mestra do cliente, (a CMK gerenciada pela AWS para o AmazonSQS ou uma CMK personalizada) para fornecer criptografia de envelope e descriptografia de váriasmensagens do Amazon SQS durante o período de reutilização de chaves de dados. Para aproveitar aomáximo o período de reutilização de chaves de dados (p. 169), lembre-se do seguinte:

• Um período menor de reutilização fornece mais segurança, mas resulta em mais chamadas para o AWSKMS, o que pode ser cobrado além do nível gratuito.

• Embora a chave de dados seja armazenada em cache separadamente para a criptografia e adescriptografia, o período de reutilização se aplica a ambas as cópias da chave de dados.

• Entidades principais (contas da AWS ou usuários do IAM) não compartilham chaves de dados(mensagens enviadas por entidades principais exclusivas sempre obtêm chaves de dados exclusivas).Portanto, o volume de chamadas para o AWS KMS é um múltiplo do número de entidades principaisexclusivas em uso durante o período de reutilização de chaves de dados:• Quando você envia mensagens usando a ação SendMessage ou SendMessageBatch, o Amazon

SQS normalmente chama as ações GenerateDataKey e Decrypt do AWS KMS uma vez a cadaperíodo de reutilização de chaves de dados.

Note

Para cada chave de dados que o AWS KMS gera, a SSE chama a ação Decrypt paraverificar a integridade da chave de dados antes de usá-la.

• Quando você recebe mensagens usando a ação ReceiveMessage, o Amazon SQS normalmentechama a ação Decrypt do AWS KMS uma vez a cada período de reutilização de chaves de dados.

Como estimar meus custos de utilização do AWSKMS?Para prever custos e entender melhor sua fatura da AWS, é recomendável saber com que frequência oAmazon SQS usa sua chave mestra de cliente (CMK).

Note

Embora a fórmula a seguir possa dar a você uma boa ideia sobre os custos esperados, os custosreais poderão ser mais altos por conta da natureza distribuída do Amazon SQS.

Para calcular o número de solicitações de APIs (R) por fila, use a seguinte fórmula:

170

concepts.html#master_keys

API_DescribeKey.html#API_DescribeKey_RequestParameters

kms/pricing

kms/pricing

workflow.html#envelope_encryption

reference_policies_elements.html#Principal

Amazon Simple Queue Service Guia do desenvolvedorDe quais permissões do AWS KMS eu preciso

para usar a SSE para o Amazon SQS?

R = B / D * (2 * P + C)

B é o período de faturamento (em segundos).

D é o período de reutilização da chave de dados (p. 169) (em segundos).

P é o número de entidades principais de produção que enviam para a fila do Amazon SQS.

C é o número de entidades principais de consumo que recebem da fila do Amazon SQS.Important

De modo geral, os principais de produção geram o dobro do custo das entidades principais deconsumo. Para obter mais informações, consulte Como o período de reutilização de chaves dedados funciona? (p. 170)Se o produtor e o consumidor tiverem usuários diferentes do IAM, o custo aumentará.

Estes são cálculos de exemplo. Para obter informações exatas sobre definição de preço, consulte a Definição de preço do AWS Key Management Service.

Exemplo 1: Cálculo do número de chamadas à API do AWS KMSpor duas entidades principais e uma filaEste exemplo supõe o seguinte:

• O período de faturamento é de 1 a 31 de janeiro (2.678.400 segundos).• O período de reutilização de chave de dados é definido como 5 minutos (300 segundos).• Há 1 fila.• Há 1 entidade principal de produção e 1 entidade principal de consumo.

2,678,400 / 300 * (2 * 1 + 1) = 26,784

Exemplo 2: Cálculo do número de chamadas à API do AWS KMSpara vários produtores e consumidores e duas filasEste exemplo supõe o seguinte:

• O período de faturamento é de 1 a 28 de fevereiro (2.419.200 segundos).• O período de reutilização de chave de dados é definido como 24 horas (86.400 segundos).• Há duas filas.• A primeira fila tem 3 entidades principais de produção e 1 entidade principal de consumo.• A segunda fila tem 5 entidades principais de produção e 2 entidades principais de consumo.

(2,419,200 / 86,400 * (2 * 3 + 1)) + (2,419,200 / 86,400 * (2 * 5 + 2)) = 532

De quais permissões do AWS KMS eu preciso parausar a SSE para o Amazon SQS?Antes que possa usar a SSE, você deve configurar as políticas de chaves do AWS KMS para permitira criptografia de filas e a criptografia e a descriptografia de mensagens. Para obter exemplos e mais

171

reference_policies_elements.html#Principal

kms/pricing/

kms/pricing/



informações sobre as permissões do AWS KMS, consulte Permissões da API do AWS KMS: referência deações e recursos no AWS Key Management Service Developer Guide.

Note

Você também pode gerenciar permissões para chaves do KMS usando políticas do IAM. Paraobter mais informações, consulte Uso de políticas do IAM com o AWS KMS.Embora você possa configurar permissões globais para enviar e receber do Amazon SQS, o AWSKMS requer explicitamente a indicação do ARN completo das CMKs em regiões específicas naseção Resource de uma política do IAM.

Você também deve garantir que as políticas de chave da chave mestra do cliente (CMK) forneçam aspermissões necessárias. Para fazer isso, indique as entidades principais que produzem e consomemmensagens criptografadas no Amazon SQS como usuários na política de chaves CMK.

Como alternativa, você pode especificar as ações necessárias do AWS KMS e o ARN da CMK em umapolítica do IAM atribuída às entidades principais que produzem e consomem mensagens criptografadas noAmazon SQS. Para obter mais informações, consulte Gerenciamento do acesso às CMKs do AWS KMSno AWS Key Management Service Developer Guide.

Exemplo 1: Permitir que um usuário envie mensagens únicas ouem lotes a uma fila com a SSEO produtor deve ter as permissões kms:GenerateDataKey e kms:Decrypt para a chave mestra docliente (CMK).

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [ "kms:GenerateDataKey", "kms:Decrypt" ], "Resource": "arn:aws:kms:us-east-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab" }, { "Effect": "Allow", "Action": [ "sqs:SendMessage", "sqs:SendMessageBatch" ], "Resource": "arn:aws:sqs:*:123456789012:MyQueue" }]}

Exemplo 2: Permitir que um usuário receba mensagens de umafila com a SSEO consumidor deve ter a permissão kms:Decrypt para qualquer chave mestra do cliente (CMK) que éusada para criptografar as mensagens na fila específica. Se a fila agir como uma dead letter queue (p. 86),o consumidor também deverá ter a permissão kms:Decrypt para qualquer CMK que for usada paracriptografar as mensagens na fila de origem.

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [

172

kms-api-permissions-reference.html

kms-api-permissions-reference.html

iam-policies.html

control-access-overview.html#managing-access



"kms:Decrypt" ], "Resource": "arn:aws:kms:us-east-2:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab" }, { "Effect": "Allow", "Action": [ "sqs:ReceiveMessage" ], "Resource": "arn:aws:sqs:*:123456789012:MyQueue" }]}

Exemplo 3: Habilitar a compatibilidade entre os serviços da AWS,como o Eventos do Amazon CloudWatch, o Amazon S3 e oAmazon SNS e as filas com a SSEPara permitir que o Eventos do Amazon CloudWatch, as notificações de eventos do Amazon S3 ouas assinaturas de tópicos do Amazon SNS funcionem com filas criptografadas, você deve executar asseguintes etapas:

1. Crie uma chave mestra de cliente (CMK).2. Para que o recurso de serviço da AWS tenha as permissões kms:GenerateDataKey* e

kms:Decrypt, adicione a seguinte instrução à política da CMK.

Note

• Para Eventos do Amazon CloudWatch, use events• Para notificações de eventos do Amazon S3, use o s3• Para assinaturas de tópicos do Amazon SNS, use o sns

{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": { "Service": "service.amazonaws.com" }, "Action": [ "kms:GenerateDataKey*", "kms:Decrypt" ], "Resource": "*" }]}

3. Crie uma nova fila da SSE (p. 20) ou configure uma fila existente da SSE (p. 50) usando o ARN de suaCMK.

Saiba mais

• Inscrever-se em um tópico no Guia do desenvolvedor do Amazon Simple Notification Service• Criação de uma regra de eventos do CloudWatch que é acionada por um evento no Guia do usuário do

Eventos do Amazon CloudWatch• Configuração de notificações de eventos do Amazon S3 no Guia do desenvolvedor do Amazon Simple

Storage Service

173

create-keys.html#create-keys-console

SubscribeTopic.html

Create-CloudWatch-Events-Rule.html

NotificationHowTo.html

Amazon Simple Queue Service Guia do desenvolvedorErros

ErrosAo trabalhar com o Amazon SQS e o AWS KMS, você pode encontrar erros. A lista a seguir descreve oserros e as possíveis soluções de problemas.

KMSAccessDeniedException

O texto cifrado faz referência a uma chave que não existe ou à qual você não tem acesso.

Código de status HTTP: 400KMSDisabledException

A solicitação foi recusada porque a CMK especificada não está habilitada.

Código de status HTTP: 400KMSInvalidStateException

A solicitação foi rejeitada porque o estado do recurso especificado não é válido para essa solicitação.Para obter mais informações, consulte Como o estado da chave afeta o uso de uma chave mestra decliente no AWS Key Management Service Developer Guide.

Código de status HTTP: 400KMSNotFoundException

A solicitação foi rejeitada porque a entidade ou o recurso especificado não pôde ser encontrado.

Código de status HTTP: 400KMSOptInRequired

O ID da chave de acesso da AWS precisa de uma assinatura do serviço.

Código de status HTTP: 403KMSThrottlingException

A solicitação foi negada devido à limitação da solicitação. Para obter mais informações sobre controlede utilização, consulte Limites no AWS Key Management Service Developer Guide.

Código de status HTTP: 400

174

key-state.html

key-state.html

limits.html#requests-per-second

Amazon Simple Queue Service Guia do desenvolvedorEnvio de solicitações da API de consulta

Como trabalhar com APIs do AmazonSQS

Esta seção fornece informações sobre a criação de endpoints do Amazon SQS, criando solicitações daAPI de consulta com os métodos GET e POST e usando ações em lotes da API. Para obter informaçõesdetalhadas sobre ações do Amazon SQS — incluindo parâmetros, erros, exemplos e tipos de dados —consulte o Amazon Simple Queue Service API Reference.

Para acessar o Amazon SQS usando várias linguagens de programação, você também pode usar osSDKs da AWS que contêm a seguinte funcionalidade automática:

• Assinar criptograficamente suas solicitações de serviço• Recuperar solicitações• Lidar com respostas de erro

Para obter informações sobre a ferramenta de linha de comando, consulte as seções do Amazon SQS naReferência de comandos da AWS CLI e o AWS Tools para PowerShell Cmdlet Reference.

Tópicos• Envio de solicitações da API de consulta (p. 175)• Ações em lote do Amazon SQS (p. 181)

Envio de solicitações da API de consultaNesta seção, você aprenderá a criar um endpoint do Amazon SQS, a fazer solicitações GET e POST e ainterpretar respostas.

Tópicos• Criar um endpoint (p. 175)• Como fazer uma solicitação GET (p. 176)• Como fazer uma solicitação POST (p. 176)• Autenticação de solicitações (p. 177)• Interpretação de respostas (p. 179)

Criar um endpointPara trabalhar com filas do Amazon SQS, você deve criar um endpoint. Para obter mais informações sobreendpoints do Amazon SQSespecíficos a regiões, consulte a Referência geral do Amazon Web Services.

Todos os endpoints do Amazon SQS são independentes. Por exemplo, se duas filas forem nomeadasMyQueue, uma tiver um endpoint sqs.us-east-2.amazonaws.com e a outra tiver o endpoint sqs.eu-west-2.amazonaws.com, elas não compartilham dados entre si.

Veja a seguir um exemplo de um endpoint que faz uma solicitação para criar uma fila.

https://sqs.eu-west-2.amazonaws.com/ ?Action=CreateQueue&DefaultVisibilityTimeout=40&QueueName=MyQueue

175

API_Operations.html

API_Types.html

tools/#sdk

sqs/index.html

#sqs_region

Amazon Simple Queue Service Guia do desenvolvedorComo fazer uma solicitação GET

&Version=2012-11-05&AUTHPARAMS

Note

Os nomes de filas e URLs de fila diferenciam maiúsculas e minúsculas.A estrutura de AUTHPARAMS depende da assinatura de solicitação de API. Para obter maisinformações, consulte Assinatura de solicitações de API da AWS na Referência geral da AmazonWeb Services.

Como fazer uma solicitação GETUma solicitação GET do Amazon SQS é estruturada como um URL que consiste no seguinte:

• Endpoint – o recurso no qual a solicitação está agindo (o nome da fila e a URL (p. 80)), por exemplo:https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue

• Ação – a ação que você quer executar no endpoint. Um ponto de interrogação (?) separa o endpoint daação, por exemplo: ?Action=SendMessage&MessageBody=Your%20Message%20Text

• Parâmetros – qualquer parâmetro de solicitação — cada parâmetro é separado por um E comercial (&),por exemplo: &Version=2012-11-05&AUTHPARAMS

Veja a seguir um exemplo de uma solicitação GET que envia uma mensagem para uma fila do AmazonSQS.

https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue?Action=SendMessage&MessageBody=Your%20message%20text&Version=2012-11-05&AUTHPARAMS

Note

Os nomes de filas e URLs de fila diferenciam maiúsculas e minúsculas.Como as solicitações GET são URLs, você deve codificar todos os valores de parâmetro no URL.Como não são permitidos espaços nos URLs, cada espaço é codificado no URL como %20. (Oresto do exemplo não foi codificado no URL para facilitar a leitura.)

Como fazer uma solicitação POSTAs solicitações POST do Amazon SQS enviam parâmetros de consulta como um formulário no corpo deuma solicitação HTTP.

Veja a seguir o exemplo de um cabeçalho HTTP com Content-Type definido como application/x-www-form-urlencoded.

POST /MyQueue HTTP/1.1Host: sqs.us-east-2.amazonaws.comContent-Type: application/x-www-form-urlencoded

O cabeçalho é seguido por uma solicitação POST form-urlencoded que envia uma mensagem a umafila do Amazon SQS. Cada parâmetro é separado por um E comercial (&).

Action=SendMessage&MessageBody=Your+Message+Text&Expires=2020-10-15T12%3A00%3A00Z&Version=2012-11-05&AUTHPARAMS

176

https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html

API_Operations.html

https://www.w3.org/MarkUp/html-spec/html-spec_8.html#SEC8.2

Amazon Simple Queue Service Guia do desenvolvedorAutenticação de solicitações

Note

Somente o cabeçalho HTTP Content-Type é obrigatório. AUTHPARAMS é o mesmo para asolicitação GET.Seu cliente HTTP pode adicionar outros itens à solicitação HTTP, de acordo com a versão doHTTP do cliente.

Autenticação de solicitaçõesA autenticação é o processo para identificar e verificar quem envia uma solicitação. Durante a primeiraetapa de autenticação, a AWS verifica a identidade do produtor e se ele está registrado para usar a AWS(para obter mais informações, consulte Criar uma conta (p. 6) e Criar um usuário (p. 6)). Em seguida, aAWS segue o procedimento a seguir:

1. O produtor (remetente) obtém as credenciais necessárias.2. O produtor envia uma solicitação e a credencial para o consumidor (destinatário).3. O consumidor usa a credencial para verificar se o produtor enviou a solicitação.4. Uma das seguintes situações acontece:

• Se a autenticação for bem-sucedida, o consumidor processará a solicitação.• Se a autenticação falhar, o consumidor rejeitará a solicitação e retornará um erro.

Tópicos• Processo de autenticação básica com HMAC-SHA (p. 177)• Parte 1: a solicitação do usuário (p. 178)• Parte 2: a resposta da AWS (p. 179)

Processo de autenticação básica com HMAC-SHAAo acessar o Amazon SQS usando API de consulta, você deve fornecer os seguinte itens para que asolicitação seja autenticada:

• O ID da chave de acesso da AWS que identifica a conta da AWS que a AWS usa para procurar suachave de acesso secreta.

• A assinatura da solicitação HMAC-SHA, que é calculada usando sua chave de acesso secreta(um segredo compartilhado do qual somente você e a AWS têm conhecimento — para obter maisinformações, consulte RFC2104). O SDK da AWS lida com o processo de assinatura. No entanto, sevocê enviar uma solicitação de consulta por meio de HTTP ou HTTPS, precisará incluir uma assinaturaem cada solicitação de consulta.

1. Derive uma chave de assinatura Signature versão 4. Para obter mais informações, consulte Derivara chave de assinatura com Java.

Note

O Amazon SQS oferece suporte ao Signature versão 4, que fornece segurança eperformance aprimorados com base em SHA256 em relação às versões anteriores. Aocriar novos aplicativos que usam o Amazon SQS, você deve usar o Signature versão 4.

2. Codifique a assinatura da solicitação usando base64. Este exemplo do código Java faz o seguinte:

package amazon.webservices.common;

// Define common routines for encoding data in AWS requests.

177

http://www.faqs.org/rfcs/rfc2104.html

code/

signature-v4-examples.html#signature-v4-examples-java

signature-v4-examples.html#signature-v4-examples-java

Amazon Simple Queue Service Guia do desenvolvedorAutenticação de solicitações

public class Encoding {

/* Perform base64 encoding of input bytes. * rawData is the array of bytes to be encoded. * return is the base64-encoded string representation of rawData. */ public static String EncodeBase64(byte[] rawData) { return Base64.encodeBytes(rawData); }}

• O timestamp (ou a expiração) da solicitação. O timestamp que você usa na solicitação deve serum objeto dateTime, com a data completa, incluindo horas, minutos e segundos. Por exemplo:2007-01-31T23:59:59Z Embora isso não seja necessário, recomendamos que você informe o objetousando o fuso horário Tempo Universal Coordenado (Horário de Greenwich).

Note

Certifique-se de que a hora do servidor esteja definida corretamente. Se você especificar umtimestamp (em vez de uma expiração), a solicitação expirará automaticamente 15 minutosapós o horário especificado (a AWS não processa solicitações com timestamps superiores a 15minutos antes da hora atual nos servidores da AWS).Se você está usando .NET, não deve enviar timestamps excessivamente específicos (devidoa interpretações diferentes em relação a como a precisão de tempo extra deve ser aplicada).Neste caso, você deve criar objetos dateTime manualmente com precisão inferior a ummilissegundo.

Parte 1: a solicitação do usuárioVeja a seguir o processo que você deve seguir para autenticar solicitações da AWS usando umaassinatura de solicitação HMAC-SHA.

178

http://www.w3.org/TR/xmlschema-2/#dateTime

Amazon Simple Queue Service Guia do desenvolvedorInterpretação de respostas

1. Crie uma solicitação para a AWS.2. Calcule uma assinatura com código de autenticação de mensagem de hash com chave (HMAC-SHA)

usando sua chave de acesso secreta.3. Inclua a assinatura e o ID da chave de acesso na solicitação e, em seguida, envie a solicitação para a

AWS.

Parte 2: a resposta da AWSA AWS inicia este processo em resposta.

1. A AWS usa o ID da chave de acesso para pesquisar sua chave de acesso secreta.2. A AWS gera uma assinatura a partir dos dados da solicitação e da chave de acesso secreta usando o

mesmo algoritmo usado para calcular a assinatura enviada na solicitação.3. Uma das seguintes situações acontece:

• Se a assinatura gerada pela AWS corresponder àquela enviada na solicitação, a AWS considerará asolicitação como autêntica.

• Se a comparação falhar, a solicitação será descartada e a AWS retornará uma resposta de erro.

Interpretação de respostasEm resposta a uma solicitação de ação, o Amazon SQS retorna uma estrutura de dados XML que contémos resultados da solicitação. Para obter mais informações, consulte as ações individuais na AmazonSimple Queue Service API Reference.

Tópicos• Estrutura de resposta bem-sucedida (p. 180)• Estrutura da resposta de erro (p. 180)

179

Amazon Simple Queue Service Guia do desenvolvedorInterpretação de respostas

Estrutura de resposta bem-sucedidaSe a solicitação foi bem-sucedida, o elemento de resposta principal receberá o nome da ação, mas comResponse anexada (ActionNameResponse).

Esse elemento contém os seguintes elementos filho:

• ActionNameResult – contém um elemento específico à ação. Por exemplo, o elementoCreateQueueResult contém o elemento QueueUrl que, por sua vez, contém o URL da fila criada.

• ResponseMetadata – contém o RequestId que, por sua vez, contém o UUID da solicitação.

Veja a seguir um exemplo de uma resposta bem-sucedida no formato XML:

<CreateQueueResponse xmlns=https://sqs.us-east-2.amazonaws.com/doc/2012-11-05/ xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xsi:type=CreateQueueResponse> <CreateQueueResult> <QueueUrl>https://sqs.us-east-2.amazonaws.com/770098461991/queue2</QueueUrl> </CreateQueueResult> <ResponseMetadata> <RequestId>cb919c0a-9bce-4afe-9b48-9bdf2412bb67</RequestId> </ResponseMetadata></CreateQueueResponse>

Estrutura da resposta de erroSe uma solicitação não tiver êxito, o Amazon SQS retornará o elemento de resposta principalErrorResponse. Esse elemento contém um elemento Error e um elemento RequestId.

O elemento Error contém os seguintes elementos filhos:

• Type – especifica se o erro foi de um produtor ou de um consumidor.• Code – especifica o tipo de erro.• Message – especifica a condição do erro em um formato legível.• Detail – (opcional) especifica detalhes adicionais sobre o erro.

O elemento RequestId contém o UUID do pedido.

Veja a seguir um exemplo de uma resposta com erro no formato XML:

<ErrorResponse> <Error> <Type>Sender</Type> <Code>InvalidParameterValue</Code> <Message> Value (quename_nonalpha) for parameter QueueName is invalid. Must be an alphanumeric String of 1 to 80 in length. </Message> </Error> <RequestId>42d59b56-7407-4c4a-be0f-4c88daeea257</RequestId></ErrorResponse>

180

Amazon Simple Queue Service Guia do desenvolvedorAções em lote

Ações em lote do Amazon SQSPara reduzir custos ou para manipular até 10 mensagens com uma única ação, você pode usar asseguintes ações:

• SendMessageBatch

• DeleteMessageBatch

• ChangeMessageVisibilityBatch

Aproveite a funcionalidade de lotes usando a API de consulta ou um SDK da AWS que oferece suporte àsnovas ações em lotes do Amazon SQS.

Note

O tamanho total de todas as mensagens que você envia em uma única chamadaSendMessageBatch não pode exceder 262.144 bytes (256 KB).Não é possível definir permissões para SendMessageBatch, DeleteMessageBatchou ChangeMessageVisibilityBatch explicitamente. A definição de permissões paraSendMessage, DeleteMessage ou ChangeMessageVisibility define permissões para asversões de lote correspondentes dessas ações.O console do Amazon SQS não oferece suporte a ações em lotes.

Tópicos• Ativar buffer por parte do cliente e processamento de solicitações em lotes (p. 181)• Aumento da taxa de transferência usando escalabilidade horizontal e processamento em lotes de ação

da (p. 185)

Ativar buffer por parte do cliente e processamento desolicitações em lotesO AWS SDK for Java inclui o AmazonSQSBufferedAsyncClient que acessa o Amazon SQS. Essecliente permite o envio de solicitações em lotes usando armazenamento em buffer no lado do cliente —as chamadas feitas pelo cliente são primeiro armazenadas em buffer e, em seguida, enviadas como umasolicitação em lotes para o Amazon SQS.

O armazenamento em buffer no lado do cliente permite que até 10 solicitações sejam armazenadas embuffer e enviadas como uma solicitação em lotes, diminuindo o custo de uso do Amazon SQS e reduzindoo número de solicitações enviadas. O AmazonSQSBufferedAsyncClient armazena as chamadassíncronas e assíncronas em buffer. Solicitações em lote e suporte para sondagem longa (p. 85) tambémpodem ajudar a aumentar a taxa de transferência. Para obter mais informações, consulte Aumento da taxade transferência usando escalabilidade horizontal e processamento em lotes de ação da (p. 185).

como o AmazonSQSBufferedAsyncClient implementa a mesma interfaceque o AmazonSQSAsyncClient, migrar de AmazonSQSAsyncClient paraAmazonSQSBufferedAsyncClient normalmente requer apenas pequenas mudanças no seu códigoexistente.

Note

A Cliente assíncrono armazenado em buffer do Amazon SQSnão suportam atualmente as filasFIFO.

Tópicos• Usar o AmazonSQSBufferedAsyncClient (p. 182)• Configurar o AmazonSQSBufferedAsyncClient (p. 182)

181




sdkforjava/

Amazon Simple Queue Service Guia do desenvolvedorAtivar buffer por parte do cliente e

processamento de solicitações em lotes

Usar o AmazonSQSBufferedAsyncClientAntes de começar, conclua as tarefas em Configuração do Amazon SQS (p. 6).

Você pode criar um novo AmazonSQSBufferedAsyncClient com base em AmazonSQSAsyncClient,por exemplo:

// Create the basic Amazon SQS async clientfinal AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient(); // Create the buffered clientfinal AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync);

Depois de criar o novo AmazonSQSBufferedAsyncClient, você pode usá-lo para enviar váriassolicitações ao Amazon SQS (da mesma forma que com o AmazonSQSAsyncClient), por exemplo:

final CreateQueueRequest createRequest = new CreateQueueRequest().withQueueName("MyQueue"); final CreateQueueResult res = bufferedSqs.createQueue(createRequest); final SendMessageRequest request = new SendMessageRequest();final String body = "Your message text" + System.currentTimeMillis();request.setMessageBody( body );request.setQueueUrl(res.getQueueUrl()); final SendMessageResult sendResult = bufferedSqs.sendMessageAsync(request); final ReceiveMessageRequest receiveRq = new ReceiveMessageRequest() .withMaxNumberOfMessages(1) .withQueueUrl(queueUrl);final ReceiveMessageResult rx = bufferedSqs.receiveMessage(receiveRq);

Configurar o AmazonSQSBufferedAsyncClientO AmazonSQSBufferedAsyncClient é pré-configurado com configurações que funcionarão para amaioria dos casos de uso. Você pode configurar ainda mais o AmazonSQSBufferedAsyncClient, porexemplo:

1. Crie uma instância da classe QueueBufferConfig com os parâmetros de configuração necessários.2. Informe a instância para o construtor AmazonSQSBufferedAsyncClient.

// Create the basic Amazon SQS async clientfinal AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient(); final QueueBufferConfig config = new QueueBufferConfig() .withMaxInflightReceiveBatches(5) .withMaxDoneReceiveBatches(15); // Create the buffered clientfinal AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync, config);

Parâmetros configuração QueueBufferConfig

Parâmetro Valor padrão Descrição

longPoll true Quando longPoll estádefinido como true,AmazonSQSBufferedAsyncClient

182



Parâmetro Valor padrão Descriçãotenta usar a sondagem longa aoconsumir mensagens.

longPollWaitTimeoutSeconds 20 s A quantidade máxima de tempo,em segundos, em que umachamada ReceiveMessageé bloqueada no servidoraguardando as mensagensaparecerem na fila antes deretornar com um resultado derecebimento vazio.

Note

Quando a sondagemlonga está desativada,essa configuração nãotem efeito.

maxBatchOpenMs 200ms A quantidade máxima de tempo(em milissegundos) que umachamada de saída aguardaoutras chamadas com as quaisela coloca mensagens do mesmotipo em lote.

Quanto maior for a configuração,menos lotes serão necessáriospara executar a mesmaquantidade de trabalho (noentanto, a primeira chamada emum lote deve passar mais tempoem espera).

Quando esse parâmetro édefinido como 0, as solicitaçõesenviadas não aguardam outrassolicitações, desativandoefetivamente o processamentoem lotes.

maxBatchSize 10 solicitações por lote O número máximo demensagens que sãoarmazenadas em lote em umaúnica solicitação. Quanto maior aconfiguração, menos lotes serãonecessários para executar omesmo número de solicitações.

Note

10 solicitações porlote é o valor máximopermitido para oAmazon SQS.

183




maxBatchSizeBytes 256 KB O tamanho máximo de um lotede mensagens, em bytes, que ocliente tenta enviar ao AmazonSQS.

Note

256 KB é o valormáximo permitido para oAmazon SQS.

maxDoneReceiveBatches 10 lotes O número máximo delotes de recebimento queAmazonSQSBufferedAsyncClientpré-busca e armazena no ladodo cliente.

Quanto maior for a configuração,mais solicitações de recebimentopoderão ser atendidas sema necessidade de fazer umachamada para o AmazonSQS (no entanto, quanto maismensagens forem buscadaspreviamente, mais tempo elaspermanecerão no buffer, fazendocom que o tempo limite devisibilidade expire).

Note

0 indica que toda a pré-busca de mensagensestá desativada eas mensagens sãoconsumidas apenas sobdemanda.

maxInflightOutboundBatches 5 lotes O número máximo de lotes desaída ativos que podem serprocessados ao mesmo tempo.

Quanto maior for a configuração,mais rapidamente os lotes desaída poderão ser enviados(sujeito a outros limites, comoCPU ou largura de banda) e maisthreads serão consumidos peloAmazonSQSBufferedAsyncClient.

184

Amazon Simple Queue Service Guia do desenvolvedorAumento da taxa de transferência usando escalabilidade

horizontal e processamento em lotes de ação da


maxInflightReceiveBatches 10 lotes O número máximo de lotes derecebimento ativos que podemser processados ao mesmotempo.

Quanto maior for a configuração,mais mensagens serãorecebidas (sujeito a outroslimites, como CPU ou largurade banda) e mais threadsserão consumidos peloAmazonSQSBufferedAsyncClient.

Note

0 indica que toda a pré-busca de mensagensestá desativada eas mensagens sãoconsumidas apenas sobdemanda.

visibilityTimeoutSeconds -1 Quando esse parâmetro édefinido como um valor positivoe diferente de zero, o tempolimite de visibilidade definidoaqui substitui o tempo limite devisibilidade definido na fila apartir da qual as mensagens sãoconsumidas.

Note

-1 indica que aconfiguração padrão foiselecionada para a fila.Não é possívelconfigurar o tempo limitede visibilidade para 0.

Aumento da taxa de transferência usandoescalabilidade horizontal e processamento em lotesde ação daAs filas do Amazon SQS podem fornecer uma taxa de transferência muito alta. As filas Padrão oferecemsuporte a um número quase ilimitado de transações por segundo (TPS) por ação de Por padrão, filas FIFOadmitem até 3.000 mensagens por segundo com o agrupamento em lotes (p. 181). Para solicitar umaumento de limite, envie uma solicitação de suporte. As filas FIFO podem admitir até 300 mensagens porsegundo (300 operações de envio, recebimento ou exclusão por segundo) sem o agrupamento em lotes.

Para atingir uma taxa de transferência alta, você deve dimensionar os produtores de mensagens e osconsumidores horizontalmente (adicionar mais produtores e consumidores).

185




Tópicos• Escalabilidade horizontal (p. 186)• Processamento em lotes de ações (p. 186)• Exemplo funcional Java para operações únicas e solicitações em lote (p. 187)

Escalabilidade horizontalComo você acessa o Amazon SQS por meio de um protocolo HTTP de solicitação-resposta, a latênciada solicitação (o intervalo de tempo entre o início de uma solicitação e o recebimento de uma resposta)limita a taxa de transferência que você pode obter de um único thread através de uma única conexão. Porexemplo, se a latência média de um cliente com base no Amazon EC2 para o Amazon SQS na mesmaregião for de cerca de 20 ms, a taxa de transferência máxima de um único thread através de uma únicaconexão será em média de 50 TPS.

A escalabilidade horizontal envolve o aumento do número de produtores de mensagem (que fazema solicitação SendMessage) e dos consumidores (que fazem solicitações ReceiveMessagee DeleteMessage) para aumentar sua taxa de transferência de fila geral. Você pode escalarhorizontalmente de três formas:

• Aumentar o número de threads por cliente• Adicionar mais clientes• Aumentar o número de threads por cliente e adicionar mais clientes

Ao adicionar mais clientes, você obtém ganhos essencialmente lineares na taxa de transferência da fila.Por exemplo, se você dobrar o número de clientes, terá duas vezes a taxa de transferência.

Note

À medida que você escala horizontalmente, é necessário garantir que a fila do Amazon SQSusada tenha conexões ou threads suficientes para oferecer suporte ao número de produtores econsumidores de mensagens simultâneos que enviarão solicitações e receberão respostas. Porexemplo, por padrão, as instâncias da classe AmazonSQSClient do AWS SDK for Java mantêm,no máximo, 50 conexões para o Amazon SQS. Para criar produtores e consumidores simultâneosadicionais, você precisa ajustar o número máximo de threads de produtores e consumidorespermitidos em um objeto AmazonSQSClientBuilder, por exemplo:

final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard() .withClientConfiguration(new ClientConfiguration() .withMaxConnections(producerCount + consumerCount)) .build();

Para AmazonSQSAsyncClient, você também precisa ter certeza de que há threads suficientesdisponíveis.

Processamento em lotes de açõesO processamento em lotes executa mais trabalho durante a ida e a volta do serviço (por exemplo, quandovocê envia várias mensagens com uma única solicitação SendMessageBatch). As ações em lotes doAmazon SQS são SendMessageBatch, DeleteMessageBatch e ChangeMessageVisibilityBatch.Para aproveitar o processamento em lotes sem alterar os produtores ou consumidores, você pode usar oCliente assíncrono armazenado em buffer do Amazon SQS (p. 181).

Note

Como ReceiveMessage pode processar 10 mensagens por vez, não há nenhuma açãoReceiveMessageBatch.

186




com/amazonaws/services/sqs/AmazonSQSClient.html

com/amazonaws/services/sqs/AmazonSQSAsyncClient.html







O processamento em lotes distribui a latência da ação de lote nas várias mensagens de uma solicitaçãoem lote em vez de aceitar toda a latência para uma única mensagem (por exemplo, uma solicitaçãoSendMessage). Como cada ida e volta carrega mais trabalho, as solicitações de lote tornam mais eficienteo uso de threads e conexões, melhorando, dessa forma, a taxa de transferência.

Você pode combinar processamentos em lote com escalabilidade horizontal para fornecer taxa detransferência com menos threads, conexões e solicitações em comparação com as solicitações demensagens individuais. Você pode usar ações em lotes do Amazon SQS para enviar, receber ou excluiraté 10 mensagens por vez. Como o Amazon SQS cobra por solicitação, o processamento em lotes podereduzir substancialmente os custos.

O processamento em lotes pode criar certa complexidade para o seu aplicativo (por exemplo, o aplicativoprecisa acumular as mensagens antes de enviá-las e, às vezes, precisará esperar mais por uma resposta).No entanto, o processamento em lotes pode ser eficaz nos seguintes casos:

• Seu aplicativo gera muitas mensagens em um curto intervalo de tempo, portanto, o atraso nunca é muitolongo.

• Um consumidor de mensagem busca as mensagens de uma fila a seu critério, ao contrário deprodutores de mensagem típicos que precisam enviar mensagens em resposta a eventos que eles nãocontrolam.

Important

Uma solicitação de lote pode ser bem-sucedida, mesmo que ocorra falha nas mensagensindividuais no lote. Após uma solicitação de lote, você sempre deve verificar a existência de falhasem mensagens individuais e repetir a ação, se necessário.

Exemplo funcional Java para operações únicas e solicitações emlotePré-requisitosAdicione os pacotes aws-java-sdk-sqs.jar, aws-java-sdk-ec2.jar e commons-logging.jarao caminho da classe de compilação do Java. O exemplo a seguir mostra essas dependências em umarquivo pom.xml do projeto Maven.

<dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-sqs</artifactId> <version>LATEST</version> </dependency> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-ec2</artifactId> <version>LATEST</version> </dependency> <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>LATEST</version> </dependency></dependencies>

SimpleProducerConsumer.javaO exemplo de código Java a seguir implementa um padrão simples de produtor-consumidor. O threadprincipal gera um número de threads de produtor e consumidor que processam mensagens de 1 KB em

187




um determinado momento. Ele inclui produtores e os consumidores que fazem solicitações de operaçãoúnicas e outros que fazem solicitações de lote.


import com.amazonaws.AmazonClientException;import com.amazonaws.ClientConfiguration;import com.amazonaws.services.sqs.AmazonSQS;import com.amazonaws.services.sqs.AmazonSQSClientBuilder;import com.amazonaws.services.sqs.model.*;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;

import java.math.BigInteger;import java.util.ArrayList;import java.util.List;import java.util.Random;import java.util.Scanner;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicBoolean;import java.util.concurrent.atomic.AtomicInteger;

/** * Start a specified number of producer and consumer threads, and produce-consume * for the least of the specified duration and 1 hour. Some messages can be left * in the queue because producers and consumers might not be in exact balance. */public class SimpleProducerConsumer {

// The maximum runtime of the program. private final static int MAX_RUNTIME_MINUTES = 60; private final static Log log = LogFactory.getLog(SimpleProducerConsumer.class);

public static void main(String[] args) throws InterruptedException {


System.out.print("Enter the queue name: "); final String queueName = input.nextLine();

System.out.print("Enter the number of producers: "); final int producerCount = input.nextInt();

System.out.print("Enter the number of consumers: "); final int consumerCount = input.nextInt();

System.out.print("Enter the number of messages per batch: "); final int batchSize = input.nextInt();

System.out.print("Enter the message size in bytes: "); final int messageSizeByte = input.nextInt();

188



System.out.print("Enter the run time in minutes: "); final int runTimeMinutes = input.nextInt();

/* * Create a new instance of the builder with all defaults (credentials * and region) set automatically. For more information, see Creating * Service Clients in the AWS SDK for Java Developer Guide. */ final ClientConfiguration clientConfiguration = new ClientConfiguration() .withMaxConnections(producerCount + consumerCount);

final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard() .withClientConfiguration(clientConfiguration) .build();

final String queueUrl = sqsClient .getQueueUrl(new GetQueueUrlRequest(queueName)).getQueueUrl();

// The flag used to stop producer, consumer, and monitor threads. final AtomicBoolean stop = new AtomicBoolean(false);

// Start the producers. final AtomicInteger producedCount = new AtomicInteger(); final Thread[] producers = new Thread[producerCount]; for (int i = 0; i < producerCount; i++) { if (batchSize == 1) { producers[i] = new Producer(sqsClient, queueUrl, messageSizeByte, producedCount, stop); } else { producers[i] = new BatchProducer(sqsClient, queueUrl, batchSize, messageSizeByte, producedCount, stop); } producers[i].start(); }

// Start the consumers. final AtomicInteger consumedCount = new AtomicInteger(); final Thread[] consumers = new Thread[consumerCount]; for (int i = 0; i < consumerCount; i++) { if (batchSize == 1) { consumers[i] = new Consumer(sqsClient, queueUrl, consumedCount, stop); } else { consumers[i] = new BatchConsumer(sqsClient, queueUrl, batchSize, consumedCount, stop); } consumers[i].start(); }

// Start the monitor thread. final Thread monitor = new Monitor(producedCount, consumedCount, stop); monitor.start();

// Wait for the specified amount of time then stop. Thread.sleep(TimeUnit.MINUTES.toMillis(Math.min(runTimeMinutes, MAX_RUNTIME_MINUTES))); stop.set(true);

// Join all threads. for (int i = 0; i < producerCount; i++) { producers[i].join(); }

for (int i = 0; i < consumerCount; i++) {

189



consumers[i].join(); }

monitor.interrupt(); monitor.join(); }

private static String makeRandomString(int sizeByte) { final byte[] bs = new byte[(int) Math.ceil(sizeByte * 5 / 8)]; new Random().nextBytes(bs); bs[0] = (byte) ((bs[0] | 64) & 127); return new BigInteger(bs).toString(32); }

/** * The producer thread uses {@code SendMessage} * to send messages until it is stopped. */ private static class Producer extends Thread { final AmazonSQS sqsClient; final String queueUrl; final AtomicInteger producedCount; final AtomicBoolean stop; final String theMessage;

Producer(AmazonSQS sqsQueueBuffer, String queueUrl, int messageSizeByte, AtomicInteger producedCount, AtomicBoolean stop) { this.sqsClient = sqsQueueBuffer; this.queueUrl = queueUrl; this.producedCount = producedCount; this.stop = stop; this.theMessage = makeRandomString(messageSizeByte); }

/* * The producedCount object tracks the number of messages produced by * all producer threads. If there is an error, the program exits the * run() method. */ public void run() { try { while (!stop.get()) { sqsClient.sendMessage(new SendMessageRequest(queueUrl, theMessage)); producedCount.incrementAndGet(); } } catch (AmazonClientException e) { /* * By default, AmazonSQSClient retries calls 3 times before * failing. If this unlikely condition occurs, stop. */ log.error("Producer: " + e.getMessage()); System.exit(1); } } }

/** * The producer thread uses {@code SendMessageBatch} * to send messages until it is stopped. */ private static class BatchProducer extends Thread { final AmazonSQS sqsClient; final String queueUrl; final int batchSize; final AtomicInteger producedCount;

190



final AtomicBoolean stop; final String theMessage;

BatchProducer(AmazonSQS sqsQueueBuffer, String queueUrl, int batchSize, int messageSizeByte, AtomicInteger producedCount, AtomicBoolean stop) { this.sqsClient = sqsQueueBuffer; this.queueUrl = queueUrl; this.batchSize = batchSize; this.producedCount = producedCount; this.stop = stop; this.theMessage = makeRandomString(messageSizeByte); }

public void run() { try { while (!stop.get()) { final SendMessageBatchRequest batchRequest = new SendMessageBatchRequest().withQueueUrl(queueUrl);

final List<SendMessageBatchRequestEntry> entries = new ArrayList<SendMessageBatchRequestEntry>(); for (int i = 0; i < batchSize; i++) entries.add(new SendMessageBatchRequestEntry() .withId(Integer.toString(i)) .withMessageBody(theMessage)); batchRequest.setEntries(entries);

final SendMessageBatchResult batchResult = sqsClient.sendMessageBatch(batchRequest); producedCount.addAndGet(batchResult.getSuccessful().size());

/* * Because SendMessageBatch can return successfully, but * individual batch items fail, retry the failed batch items. */ if (!batchResult.getFailed().isEmpty()) { log.warn("Producer: retrying sending " + batchResult.getFailed().size() + " messages"); for (int i = 0, n = batchResult.getFailed().size(); i < n; i++) { sqsClient.sendMessage(new SendMessageRequest(queueUrl, theMessage)); producedCount.incrementAndGet(); } } } } catch (AmazonClientException e) { /* * By default, AmazonSQSClient retries calls 3 times before * failing. If this unlikely condition occurs, stop. */ log.error("BatchProducer: " + e.getMessage()); System.exit(1); } } }

/** * The consumer thread uses {@code ReceiveMessage} and {@code DeleteMessage} * to consume messages until it is stopped. */ private static class Consumer extends Thread { final AmazonSQS sqsClient; final String queueUrl; final AtomicInteger consumedCount;

191



final AtomicBoolean stop;

Consumer(AmazonSQS sqsClient, String queueUrl, AtomicInteger consumedCount, AtomicBoolean stop) { this.sqsClient = sqsClient; this.queueUrl = queueUrl; this.consumedCount = consumedCount; this.stop = stop; }

/* * Each consumer thread receives and deletes messages until the main * thread stops the consumer thread. The consumedCount object tracks the * number of messages that are consumed by all consumer threads, and the * count is logged periodically. */ public void run() { try { while (!stop.get()) { try { final ReceiveMessageResult result = sqsClient .receiveMessage(new ReceiveMessageRequest(queueUrl));

if (!result.getMessages().isEmpty()) { final Message m = result.getMessages().get(0); sqsClient.deleteMessage(new DeleteMessageRequest(queueUrl, m.getReceiptHandle())); consumedCount.incrementAndGet(); } } catch (AmazonClientException e) { log.error(e.getMessage()); } } } catch (AmazonClientException e) { /* * By default, AmazonSQSClient retries calls 3 times before * failing. If this unlikely condition occurs, stop. */ log.error("Consumer: " + e.getMessage()); System.exit(1); } } }

/** * The consumer thread uses {@code ReceiveMessage} and {@code * DeleteMessageBatch} to consume messages until it is stopped. */ private static class BatchConsumer extends Thread { final AmazonSQS sqsClient; final String queueUrl; final int batchSize; final AtomicInteger consumedCount; final AtomicBoolean stop;

BatchConsumer(AmazonSQS sqsClient, String queueUrl, int batchSize, AtomicInteger consumedCount, AtomicBoolean stop) { this.sqsClient = sqsClient; this.queueUrl = queueUrl; this.batchSize = batchSize; this.consumedCount = consumedCount; this.stop = stop; }

192



public void run() { try { while (!stop.get()) { final ReceiveMessageResult result = sqsClient .receiveMessage(new ReceiveMessageRequest(queueUrl) .withMaxNumberOfMessages(batchSize));

if (!result.getMessages().isEmpty()) { final List<Message> messages = result.getMessages(); final DeleteMessageBatchRequest batchRequest = new DeleteMessageBatchRequest() .withQueueUrl(queueUrl);

final List<DeleteMessageBatchRequestEntry> entries = new ArrayList<DeleteMessageBatchRequestEntry>(); for (int i = 0, n = messages.size(); i < n; i++) entries.add(new DeleteMessageBatchRequestEntry() .withId(Integer.toString(i)) .withReceiptHandle(messages.get(i) .getReceiptHandle())); batchRequest.setEntries(entries);

final DeleteMessageBatchResult batchResult = sqsClient .deleteMessageBatch(batchRequest); consumedCount.addAndGet(batchResult.getSuccessful().size());

/* * Because DeleteMessageBatch can return successfully, * but individual batch items fail, retry the failed * batch items. */ if (!batchResult.getFailed().isEmpty()) { final int n = batchResult.getFailed().size(); log.warn("Producer: retrying deleting " + n + " messages"); for (BatchResultErrorEntry e : batchResult .getFailed()) {

sqsClient.deleteMessage( new DeleteMessageRequest(queueUrl, messages.get(Integer .parseInt(e.getId())) .getReceiptHandle()));

consumedCount.incrementAndGet(); } } } } } catch (AmazonClientException e) { /* * By default, AmazonSQSClient retries calls 3 times before * failing. If this unlikely condition occurs, stop. */ log.error("BatchConsumer: " + e.getMessage()); System.exit(1); } } }

/** * This thread prints every second the number of messages produced and * consumed so far. */ private static class Monitor extends Thread { private final AtomicInteger producedCount;

193



private final AtomicInteger consumedCount; private final AtomicBoolean stop;

Monitor(AtomicInteger producedCount, AtomicInteger consumedCount, AtomicBoolean stop) { this.producedCount = producedCount; this.consumedCount = consumedCount; this.stop = stop; }

public void run() { try { while (!stop.get()) { Thread.sleep(1000); log.info("produced messages = " + producedCount.get() + ", consumed messages = " + consumedCount.get()); } } catch (InterruptedException e) { // Allow the thread to exit. } } }}

Monitorar métricas de volume da execução de exemplo

O Amazon SQS gera automaticamente métricas de volume para mensagens enviadas, recebidas eexcluídas. Você pode acessar essas métricas e outras por meio da guia Monitoring (Monitoramento) desua fila ou no console do CloudWatch.

Note

As métricas podem levar até 15 minutos após a fila começar para ficar disponíveis.

194

cloudwatch/home


Recursos relacionados do AmazonSQS

A tabela a seguir lista os recursos relacionados que serão úteis à medida que você utilizar este serviço.

Recurso Descrição

Amazon Simple Queue Service APIReference

Descrições de ações de , parâmetros e tipos de dados, alémde uma lista de erros que o serviço retorna.

Amazon SQS na AWS CLI CommandReference

Descrições dos comandos da AWS CLI que você pode usarpara trabalhar com filas.

Regiões e endpoints Informações sobre regiões e endpoints do Amazon SQS

Páginas do produtos A principal página da web para obter informações sobre oAmazon SQS.

Fórum de discussão Um fórum da comunidade para os desenvolvedoresdiscutirem questões técnicas relacionadas ao Amazon SQS.

Informações sobre o AWS PremiumSupport

A principal página da web para obter informações sobre oAWS Premium Support, um canal de suporte de respostarápida e com atendimento individual, para ajudá-lo adesenvolver e executar aplicativos nos AWS InfrastructureServices.

195

sqs/index.html

sqs/index.html

rande.html#sqs_region

sqs



Notas de release do Amazon SQSA tabela a seguir relaciona os releases e as melhorarias dos recursos do Amazon SQS. Para obter asalterações feitas em Guia do desenvolvedor do Amazon Simple Queue Service, consulte Histórico dedocumentos do Amazon SQS (p. 201).

Data Lançamento de recursos

28 de agosto de2018

Criptografia do lado do servidor (SSE) de Amazon SQS está disponível em todasas regiões comerciais onde Amazon SQS está disponível, exceto por Regiões daChina. Para obter mais informações sobre a criptografia do lado do servidor e sobrecomo começar a usá-la, consulte Proteção de dados usando criptografia no lado doservidor (SSE) e AWS KMS (p. 167).

28 de junho de2018

Você pode configurar as mensagens de entrada para acionar uma função doLambda. Para obter mais informações, consulte Configuração de mensagens quechegam em uma fila para acionar uma função (p. 45).

Note

A fila e a função Lambda devem estar na mesma região da AWS.As filas FIFO não são compatíveis com triggers de função Lambda.Você pode associar somente uma fila a uma ou mais funções Lambda.Não é possível associar uma fila criptografada (p. 167) que usa umachave mestre de cliente gerenciada pela AWS para o Amazon SQS a umafunção Lambda em outra conta da AWS.

24 de maio de2018

Para obter mais informações sobre a criptografia do lado do servidor e sobre comocomeçar a usá-la, consulte Proteção de dados usando criptografia no lado doservidor (SSE) e AWS KMS (p. 167).

20 de março de2018

O Eventos do Amazon CloudWatch pode usar filas Amazon SQS FIFO comodestinos. Para obter mais informações, consulte Automação de notificações nosserviços da AWS para Amazon SQS usando o Eventos do CloudWatch (p. 139).

23 de janeiro de2018

As notificações de eventos do Amazon S3 são compatíveis com o Amazon SQSSSE. Para mais informações, consulte a seção Habilitar a compatibilidade entre osserviços da AWS e as filas com (p. 173) atualizada.

2 de janeiro de2018

Os seguintes recursos dos serviços da AWS são compatíveis com o Amazon SQSSSE:

• Notificações de eventos do Amazon CloudWatch• Assinaturas de tópicos do Amazon SNS

19 de outubro de2017

Você pode rastrear a alocação de custos adicionando, atualizando, removendoe listando as tags de metadados das filas do Amazon SQS usando as açõesTagQueue, UntagQueue e ListQueueTags e o Console de gerenciamentoda AWS. Para obter mais informações, consulte Tags de alocação de custos doAmazon SQS (p. 84) e o tutorial Adição, atualização e remoção de tags de umafila (p. 27).

1 de setembro de2017

O conjunto completo de ações do Amazon SQS é exibido na lista Actions (Ações)na caixa de diálogo Add a Permission to MyQueue (Adicionar uma permissão aMinha fila). Para mais informações, consulte o tutorial Adição de permissões parauma fila. (p. 25).

196

NotificationHowTo.html

Create-CloudWatch-Events-Rule.html

SubscribeTopic.html

API_TagQueue.html

API_UntagQueue.html




14 de junho de2017

As filas FIFO (ordem de chegada) estão disponíveis na região Leste dos EUA(Norte da Virgínia), além das regiões UE (Irlanda), Leste dos EUA (Ohio) eOeste dos EUA (Oregon). Para obter mais informações sobre como as filas FIFOfuncionam e sobre como começar a usá-las, consulte Filas FIFO (ordem dechegada) do Amazon SQS (p. 72).

8 de junho de 2017 As filas FIFO (ordem de chegada) estão disponíveis na região UE (Irlanda), alémdas regiões UE (Irlanda), Leste dos EUA (Ohio) e Oeste dos EUA (Oregon). Paraobter mais informações sobre como as filas FIFO funcionam e sobre como começara usá-las, consulte Filas FIFO (ordem de chegada) do Amazon SQS (p. 72).

23 de maio de2017

Criptografia do lado do servidor (SSE) for Amazon SQS está disponível nas regiõesLeste dos EUA (Norte da Virgínia), além das regiões Leste dos EUA (Ohio) e Oestedos EUA (Oregon). Para obter mais informações sobre a criptografia do lado doservidor e sobre como começar a usá-la, consulte Proteção de dados usandocriptografia no lado do servidor (SSE) e AWS KMS (p. 167).

19 de maio de2017

• Você pode usar o Biblioteca de cliente estendida do Amazon SQS para Javajunto com o Cliente Java Message Service (JMS) Amazon SQS.

• O Amazon SQS Biblioteca do Sistema de mensagens Java foi atualizado para1.0.3. Para obter mais informações, consulte Como trabalhar com o JMS e oAmazon SQS (p. 96).

• Atualizada a seção Como trabalhar com o JMS e o Amazon SQS (p. 96).

1 de maio de 2017 A AWS expandiu seu programa de compatibilidade com a HIPAA para incluir oAmazon SQS como serviço qualificado pela HIPAA.

197

compliance/hipaa-compliance/



28 de abril de 2017 Criptografia do lado do servidor (SSE) para Amazon SQS está disponível nasregiões Leste dos EUA (Ohio) e Oeste dos EUA (Oregon). SSE permite proteger oconteúdo de mensagens em filas do Amazon SQS usando chaves gerenciadas noAWS Key Management Service (AWS KMS). Para obter mais informações sobre acriptografia do lado do servidor e sobre como começar a usá-la, consulte Proteçãode dados usando criptografia no lado do servidor (SSE) e AWS KMS (p. 167). Paratutoriais, consulte o seguinte:

• Criação de uma fila com (p. 20)• Configuração de uma fila existente. (p. 50)

SSE adiciona os atributos KmsMasterKeyId eKmsDataKeyReusePeriodSeconds às ações CreateQueue,GetQueueAttributes e SetQueueAttributes.

Important

Alguns recursos dos serviços da AWS que podem enviar notificações paraAmazon SQS usando a ação AWS Security Token Service AssumeRolede que sejam compatíveis com SSE mas funcionam somente com as filaspadrão:


Outros recursos dos serviços da AWS ou serviços de terceiros, queenviam notificações ao Amazon SQS que não sejam compatíveis comSSE, apesar de permitirem que você defina uma fila criptografada comodestino:


Para obter informações sobre a compatibilidade de outros serviços com asfilas criptografadas, consulte Habilitar a compatibilidade entre os serviçosda AWS e as filas com (p. 173) e a documentação do serviço.

24 de abril de 2017 • O Biblioteca de cliente estendida do Amazon SQS para Java e o Cliente JavaMessage Service (JMS) Amazon SQS oferecem suporte a filas FIFO.

• O Amazon SQS Biblioteca do Sistema de mensagens Java foi atualizado para1.0.2.


28 de março de2017

O AWS CloudFormation deixa você criar filas FIFO. O tutorial AWSCloudFormation (p. 19) foi adicionado.

198










17 de novembrode 2016

As filas FIFO (ordem de chegada) ou as filas padrão (outro nome para filasexistentes) estão disponíveis Nas regiões Oeste dos EUA (Oregon) e Leste dosEUA (Ohio). Para obter mais informações sobre como as filas FIFO funcionam esobre como começar a usá-las, consulte o seguinte:

• Filas FIFO (ordem de chegada) do Amazon SQS (p. 72)• Mudança de uma fila Padrão para uma fila FIFO (p. 75)• Recomendações adicionais para filas Amazon SQS FIFO (p. 122)

Para obter os tutoriais revisados do Amazon SQS, consulte o seguinte:

• Criação de uma fila (p. 16)• Envio de uma mensagem a uma fila (p. 28)• Recebimento e exclusão de uma mensagem de uma fila (p. 38)

As filas FIFO adicionam a seguinte funcionalidade de API:

• Os atributos FifoQueue e ContentBasedDeduplication das açõesCreateQueue, GetQueueAttributes e SetQueueAttributes.

• Os parâmetros de solicitação MessageDeduplicationId e MessageGroupIddas ações SendMessage e SendMessageBatch e atributos da açãoReceiveMessage.

• O parâmetro de solicitação ReceiveRequestAttemptId da açãoReceiveMessage.

• O parâmetro da resposta SequenceNumber e SendMessage eações SendMessageBatch e o atributo SequenceNumber da açãoReceiveMessage.

Important

A partir de 17 de novembro de 2016, o Amazon SQS não publica mais umWSDL.O Cliente assíncrono armazenado em buffer do Amazon SQS não oferecesuporte às filas FIFO.Alguns serviços da AWS ou externos que enviam notificações paraAmazon SQS podem não ser compatíveis com filas FIFO, mesmopermitindo que você defina uma fila FIFO como destino.As seguintes características dos serviços da AWS não são atualmentecompatíveis com filas FIFO:

• Ganchos de ciclo de vida Auto Scaling• Ações de regra AWS IoT• Dead Letter Queues AWS Lambda

Para obter informações sobre a compatibilidade de outros serviços comfilas FIFO, consulte a documentação de serviço.As filas FIFO não são compatíveis com temporizadores em mensagensindividuais.

199





API_SendMessageBatchRequestEntry.html




API_SendMessageBatchResultEntry.html







31 de agosto de2016

A métrica ApproximateAgeOfOldestMessage do CloudWatch permite quevocê descubra a idade aproximada da mensagem não excluída mais antiga na fila.Para obter mais informações, consulte Métricas do CloudWatch disponíveis paraAmazon SQS (p. 131).

12 de fevereiro de2016

Você pode visualizar as métricas do CloudWatch no console do Amazon SQS paraaté 10 filas por vez. Para obter mais informações, consulte Monitoramento de filasdo Amazon SQS usando o CloudWatch (p. 128).


O Biblioteca de cliente estendida do Amazon SQS para Java permite que vocêgerencie mensagens Amazon SQS com Amazon S3. Para obter mais informações,consulte Gerenciamento de mensagens grandes do Amazon SQS usando oAmazon S3 (p. 92) na Guia do desenvolvedor do Amazon Simple Queue Service.

29 de dezembrode 2014

O Amazon SQS permite que você use JMS (Java Message Service) com filas doAmazon SQS. Para obter mais informações, consulte Como trabalhar com o JMSe o Amazon SQS (p. 96) na Guia do desenvolvedor do Amazon Simple QueueService.

8 de dezembro de2014

O Amazon SQS permite que você exclua as mensagens de uma fila usando a açãoPurgeQueue. Para obter mais informações, consulte PurgeQueue em AmazonSimple Queue Service API Reference.

16 de julho de2014

O Amazon SQS permite registrar ações em log usando o AWS CloudTrail. Paraobter mais informações, consulte Registro em log de chamadas à API do AmazonSQS usando o AWS CloudTrail (p. 134).

6 de maio de 2014 O Amazon SQS oferece suporte a atributos de mensagens. Para obter maisinformações, consulte Atributos de mensagens do Amazon SQS (p. 81).


O Amazon SQS oferece suporte a dead letter queues. Para obter maisinformações, consulte Dead-Letter Queues do Amazon SQS (p. 86).

21 de novembrode 2012

Você pode inscrever uma fila do Amazon SQS em um tópico do Amazon SNSusando o console do Amazon SQS. Para obter mais informações, consulteInscrição de uma fila em um tópico (p. 43).

5 de novembro de2012

A versão da API 2012-11-05 do Amazon SQS adiciona suporte ao Signature versão4, que fornece maior segurança e performance. Para obter mais informaçõessobre Signature Versão 4, consulte Processo de autenticação básica com HMAC-SHA (p. 177).


O AWS SDK for Java inclui um cliente assíncrono armazenado em buffer, oAmazonSQSBufferedAsyncClient, para acesso ao Amazon SQS. Esse clientefacilita a criação de lotes de solicitação, permitindo a ativação de buffer do ladodo cliente, onde as chamadas feitas pelo cliente são primeiro alocadas no buffere enviadas como uma solicitação em lotes para o Amazon SQS. Para obter maisinformações sobre o armazenamento em buffer no lado do cliente e a criação delotes de solicitação, consulte Ativar buffer por parte do cliente e processamento desolicitações em lotes (p. 181).


A versão da API 2012-11-05 do Amazon SQS adiciona suporte à sondagem longa.A sondagem longa permite que o Amazon SQS espere um período específico paraque uma mensagem esteja disponível, em vez de retornar uma resposta vazia, seuma resposta não estiver disponível. Para obter mais informações sobre sondagemlonga, consulte Sondagem longa do Amazon SQS (p. 85).

200

API_PurgeQueue.html

Amazon Simple Queue Service Guia do desenvolvedorHistórico de documentos

Histórico de documentos do Amazon SQSA tabela a seguir relaciona as alterações no Guia do desenvolvedor do Amazon Simple Queue Service.Para ver os releases e as melhorias de recursos do Amazon SQS, consulte Notas de release do AmazonSQS (p. 196).

Data Atualização da documentação


Atualizada a seção Tópicos do Amazon SQS novos e visualizados comfrequência (p. 4).


• Corrigidas as informações nas seguintes seções:• Habilitar a compatibilidade entre os serviços da AWS e as filas com (p. 173)• Como as dead letter queues funcionam? (p. 86)

• Esclarecimento do preâmbulo na seção Inscrição de uma fila em umtópico (p. 43).

• Revisão adicional à declaração a seguir sobre o tempo limite devisibilidade (p. 89) ao longo deste guia: O tempo limite de visibilidade padrãopara uma mensagem é de 30 segundos. O máximo é 12 horas.

• A seção Mensagens em trânsito (p. 90) foi reescrita.

28 de agosto de2018

Atualizada a seção Proteção de dados usando criptografia no lado do servidor(SSE) e AWS KMS (p. 167).

27 de agosto de2018

Informações corrigidas na seção Referência de ações e recursos (p. 165).

22 de agosto de2018

A seção Registro em log de chamadas à API do Amazon SQS usando o AWSCloudTrail (p. 134) foi reescrita.

21 de agosto de2018

Revisada a tabela de atributos na seção Recursos necessários para processarmensagens do Amazon SQS (p. 84).

20 de agosto de2018

Adicionada a seguinte nota nas seções Dead-Letter Queues do AmazonSQS (p. 86) e Configuração de uma dead letter queue (p. 56):

15 de agosto de2018

Adicionada a seguinte nota na seção Sondagem longa do Amazon SQS (p. 85):

7 de agosto de2018

Esclarecimento das informações na seção Mensagens em trânsito (p. 90).

3 de agosto de2018


25 de julho de2018

• A seção Criação de alertas do CloudWatch para métricas do AmazonSQS (p. 130) foi reescrita, e as capturas de tela desatualizadas foram removidas.

• A seção Acesso às métricas do CloudWatch para Amazon SQS (p. 128) foirenomeada.

6 de julho de 2018 As seguintes instruções foram revisadas neste guia:

• Tempo limite de visibilidade (p. 89): O tempo limite de visibilidade padrão parauma mensagem é de 30 segundos. O máximo é 12 horas.

• Temporizadores de mensagens (p. 92):

201


Data Atualização da documentação• Filas de atraso (p. 91): The minimum delay for a queue is 0 seconds. The

maximum is 15 minutes.

5 de julho de 2018 • Atualizada a seção Tópicos do Amazon SQS novos e visualizados comfrequência (p. 4).

• Adicionada a seguinte nota sobre a métricaApproximateAgeOfOldestMessage na seção Métricas do CloudWatchdisponíveis para Amazon SQS (p. 131): para dead letter queues (p. 86), ovalor de ApproximateAgeOfOldestMessage é o período mais longo depermanência de uma mensagem na fila.

3 de julho de 2018 • Corrigidos os links para preenchimento de solicitações de suporte em todo esteguia.

• Corrigidos alguns erros menores na seção Tutoriais do Amazon SQS (p. 16).

28 de junho de2018

O tutorial Configuração de mensagens que chegam em uma fila para acionar umafunção (p. 45) foi criado.

26 de junho de2018

Informações corrigidas na seção Como as dead letter queues funcionam? (p. 86).

11 de junho de2018

• Adicionadas as seguintes informações à seção Limites relacionados amensagens (p. 126): Um ID de mensagem em lotes pode ter até 80 caracteres.Os seguintes caracteres são aceitos: caracteres alfanuméricos, hifens (-) esublinhados (_).

• As informações na seção Usar o AmazonSQSBufferedAsyncClient (p. 182) foramelucidadas e corrigidas.

8 de junho de 2018 Atualizada a seção Tópicos do Amazon SQS novos e visualizados comfrequência (p. 4).

5 de junho de 2018 Além do GitHub, do HTML, do PDF e do Kindle, as notas de release do Guia dodesenvolvedor do Amazon MQ estão disponíveis como um RSS feed.

29 de maio de2018

• O exemplo de Java foi melhorado nas seguintes seções:• SQSExtendedClientExample.java (p. 93)• SimpleProducerConsumer.java (p. 187)

24 de maio de2018

Atualizada a seção Proteção de dados usando criptografia no lado do servidor(SSE) e AWS KMS (p. 167).

22 de maio de2018

• Informações corrigidas em todas as seções de dependência Java.• A seguinte instrução foi revisada: Para filas padrão, pode haver no máximo

120.000 mensagens em processamento (received from a queue by a consumer,but not yet deleted from the queue). Se você atingir o limite, o Amazon SQSretornará a mensagem de erro OverLimit. Para evitar atingir o limite, vocêdeve excluir mensagens da fila depois de serem processadas. Você tambémpode aumentar o número de filas que usar para processar as mensagens. Parasolicitar um aumento de limite, envie uma solicitação de suporte.

202

support/home#/case/create?issueType=service-limit-increase&limitType=service-code-sqs




15 de maio de2018

Esclarecimento das informações na seção Processar mensagens em tempohábil (p. 119).

10 de maio de2018

• O tutorial Envio de uma mensagem com um temporizador a uma fila (p. 36) foicriado.

• A seção Para enviar uma mensagem com um temporizador a uma fila (p. 38) foicriada com um exemplo de código Java.

• Tutoriais relacionados agrupados em seções:• Criação de filas (p. 16)• Envio de mensagens a filas (p. 28)• Configuração de filas (p. 49)

9 de maio de 2018 A seção Temporizadores de mensagem do Amazon SQS (p. 92) foi reescrita.

8 de maio de 2018 • A seção Filas de atraso do Amazon SQS (p. 91) foi reescrita.• O tutorial Configuração de uma fila de atraso (p. 63) foi criado.• Criadas as seguintes seções com um exemplo de código Java:

• Para configurar uma fila de atraso (p. 64)• Para configurar uma fila de atraso e enviar, receber e excluir

mensagens (p. 66)

4 de maio de 2018 Atualizada a seção Tópicos do Amazon SQS novos e visualizados comfrequência (p. 4).

3 de maio de 2018 • Criadas as seguintes seções com um exemplo de código Java:• Para configurar o tempo limite de visibilidade para uma fila (p. 61)• Para configurar o tempo limite de visibilidade para uma única mensagem ou

para várias mensagens e enviar, receber e excluir mensagens (p. 62)• O exemplo de código Java foi melhorado nas seguintes seções:

• SQSSimpleJavaClientExample.java (p. 70)• SQSFIFOJavaClientExample.java (p. 77)• SQSLongPollingExample.java (p. 54)• SQSDeadLetterQueueExample.java (p. 58)

2 de maio de 2018 • As informações da seção Tempo limite de visibilidade do Amazon SQS (p. 89)foram corrigidas e elucidadas.

• O tutorial Configuração do tempo limite de visibilidade para uma fila (p. 60) foicriado.

1 de maio de 2018 As informações da seção Limites relacionados a filas (p. 125) foram corrigidas eelucidadas.

203



25 de abril de 2018 • As informações das seções a seguir foram corrigidas e elucidadas:• Configuração da sondagem longa para uma fila (p. 53)• Identificadores de filas Padrão e FIFO do Amazon SQS (p. 79)• Conceitos básicos do Amazon SQS (p. 9)

• A seguinte observação foi adicionada ao longo do guia:

Permissões entre contas não são aplicáveis às ações a seguir:• AddPermission

• CreateQueue

• DeleteQueue

• ListQueues

• ListQueueTags



• TagQueue

• UntagQueue

• Um pequeno erro no exemplo Java na seçãoSQSLongPollingExample.java (p. 54) foi corrigido.

24 de abril de 2018 • A seção Sondagem longa do Amazon SQS (p. 85) foi reescrita.• O tutorial Configuração da sondagem longa para uma fila (p. 53) foi criado.• Criada a seção Configuração da sondagem longa (p. 120).

23 de abril de 2018 A seção Processar mensagens em tempo hábil (p. 119) foi reescrita.

11 de abril de 2018 • Informações desatualizadas foram removidas nas seções a seguir e referênciascruzadas foram adicionadas aos tutoriais relacionados:• Filas Padrão do Amazon SQS (p. 69)• Filas FIFO (ordem de chegada) do Amazon SQS (p. 72)• Dead-Letter Queues do Amazon SQS (p. 86)• Tags de alocação de custos do Amazon SQS (p. 84)• Proteção de dados usando criptografia no lado do servidor (SSE) e AWS

KMS (p. 167)• As seguintes seções foram reestruturadas:

• Gerenciamento de mensagens grandes do Amazon SQS usando o AmazonS3 (p. 92)

• Envio de solicitações da API de consulta (p. 175)• Ações em lote do Amazon SQS (p. 181)

204












10 de abril de 2018 • A seção Para configurar uma dead letter queue (p. 57) foi criada com umexemplo de código Java.

• As seguintes seções foram reestruturadas:• Filas FIFO (ordem de chegada) do Amazon SQS (p. 72)• Trabalhar com mensagens do Amazon SQS (p. 119)• Redução de custos do Amazon SQS (p. 121)• Recomendações adicionais para filas Amazon SQS FIFO (p. 122)

• As seguintes seções foram reescritas:• Ordenação de mensagens (p. 73)• Para configurar a dead letter queue e enviar, receber e excluir uma

mensagem (p. 59)

9 de abril de 2018 • As seguintes seções foram reescritas:• Diferenças entre sondagens longa e curta (p. 85)• Filas de atraso do Amazon SQS (p. 91)

• Movidos os exemplos da API de consulta para os seguintes conceitos para oAmazon Simple Queue Service API Reference:• Dead-Letter Queues do Amazon SQS (p. 86)• Sondagem longa do Amazon SQS (p. 85)• Filas de atraso do Amazon SQS (p. 91)• Temporizadores de mensagem do Amazon SQS (p. 92)

6 de abril de 2018 • As seguintes seções foram reescritas:• Lógica de avaliação da Access Policy Language do Amazon SQS (p. 158)• Relações entre negações explícitas e padrão na Access Policy Language do

Amazon SQS (p. 160)• Uso de credenciais de segurança temporárias (p. 163)

• As seguintes seções foram reestruturadas:• Uso de políticas com base em identidade (IAM) para o Amazon SQS (p. 147)• Uso de políticas personalizadas com a Access Policy Languagedo Amazon

SQS (p. 155)• Atualizada a seção Tópicos do Amazon SQS novos e visualizados com

frequência (p. 4).

5 de abril de 2018 • Exemplos de Java (p. 34) foram adicionados ao tutorial Envio de uma mensagemcom atributos a uma fila (p. 32).

• A seção Cálculo do resumo de mensagens MD5 para atributos demensagem (p. 82) foi reescrita.

• As instruções para o exemplo de Java (p. 27) foram corrigidas no tutorial Adição,atualização e remoção de tags de uma fila (p. 27).

4 de abril de 2018 • O tutorial Envio de uma mensagem com atributos a uma fila (p. 32) foi criado.• As seguintes seções foram reescritas:

• Componentes de atributos de mensagem (p. 81)• Tipos de dados de atributos de mensagem (p. 82)• Próximas etapas (p. 14) (Conceitos básicos)

205

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/



29 de março de2018

Adicionada a seguinte nota na seção Cálculo do resumo de mensagens MD5para atributos de mensagem (p. 82): Inclua sempre os sufixos de tipo de dadospersonalizados no cálculo do resumo de mensagens MD5.

27 de março de2018

• Criada a seção Como posso começar a usar o Amazon SQS? (p. 3).• A seção Ciclo de vida de mensagens (p. 68) foi reescrita e movida.• As seguintes seções foram reestruturadas para melhorar a leitura:

• Práticas recomendadas para o Amazon SQS (p. 119)• Como Amazon SQS funciona (p. 67)

26 de março de2018

• Implementação de sistemas de solicitação-resposta (p. 121) foi adicionado àseção Práticas recomendadas para o Amazon SQS (p. 119).

• A seção Quais são os principais benefícios do Amazon SQS? (p. 1) foi reescritapara incluir informações sobre os recursos lançados recentemente.

• O conteúdo da seção Pré-requisitos do Amazon SQS foi refatorado em seçõesexistentes, e a seção foi removida.• Observações explanatórias foram adicionadas à seção Exclusão de uma

fila (p. 48).• A introdução à seção Gerenciamento de mensagens grandes do Amazon SQS

usando o Amazon S3 (p. 92) foi esclarecida.

23 de março de2018

• A seção O que é o Amazon Simple Queue Service? (p. 1) foi reestruturada ereescrita.

• A seção Como o Amazon SQS é diferente do Amazon MQ ou do AmazonSNS? (p. 2) foi adicionada.

• A seção Arquitetura básica do Amazon SQS (p. 67) foi movida.

22 de março de2018

• A seção Monitoramento e registro em log Monitoramento, registro em log eautomação (p. 128) foi renomeada.

• Criada a seção Automação de notificações nos serviços da AWS para AmazonSQS usando o Eventos do CloudWatch (p. 139).

• Os títulos dos exemplos na seção De quais permissões do AWS KMS eu precisopara usar a SSE para o Amazon SQS? (p. 171) foram esclarecidos.

20 de março de2018

• A seguinte instrução foi esclarecida em todo este guia:• Capturas de telas desnecessárias foram removidas, e a explicação de

diagramas nas seções Tutoriais do Amazon SQS (p. 16), Como Amazon SQSfunciona (p. 67) e Segurança do Amazon SQS (p. 140) foi melhorada.

• Um preâmbulo da seção Identificadores de filas e mensagens do AmazonSQS (p. 79) foi adicionado, e foi esclarecido a quais tipos de fila os váriosidentificadores do Amazon SQS correspondem.

• As informações foram corrigidas e esclarecidas e o realce da sintaxe foi corrigidonas seções Registro em log de chamadas à API do Amazon SQS usando o AWSCloudTrail (p. 134) e Segurança do Amazon SQS (p. 140).

19 de março de2018

Foi esclarecido nas seções Limites relacionados a políticas (p. 127) e Adição depermissões para uma fila. (p. 25) que uma política do Amazon SQS pode ter ummáximo de sete ações.

14 de março de2018

• As capturas de telas foram atualizadas e otimizadas em todo este guia paramelhorar a usabilidade.

• A navegação foi melhorada em todos os tutoriais.

206



13 de março de2018

A taxa de transferência de itens em lotes e não em lotes foi esclarecida para filasFIFO em todo este guia.

7 de março de2018


2 de março de2018

• As permissões sqs:ListQueueTags, sqs:TagQueue e sqs:UntagQueueforam adicionadas à seção Referência de ações e recursos (p. 165).

• Esclarecimento das permissões das ações de API a seguir:• ChangeMessageVisibilityBatch (sqs:ChangeMessageVisibility)• DeleteMessageBatch (sqs:DeleteMessage)• SendMessageBatch (sqs:SendMessage)


Exibição de imagem corrigida no GitHub.


Além do HTML, do PDF e do Kindle, o Guia do desenvolvedor do Amazon SimpleQueue Service está disponível no GitHub. Para deixar um comentário, escolha oícone do GitHub no canto superior direito.


• As regiões ficaram consistentes em todos os exemplos.• Links otimizados para o console da AWS e para páginas do produto.


• A seção Envio de solicitações da API de consulta (p. 175) foi reescrita.• Corrigidas as amostras de código Java na seção Ativar buffer por parte do cliente

e processamento de solicitações em lotes (p. 181).• http:// foi substituído por https:// em todos os exemplos de endpoints do

Amazon SQS.


• Corrigida a amostra de código Java na seção Usar oAmazonSQSBufferedAsyncClient (p. 182).

• Esclarecimento das informações na seção Limpeza de mensagens de umafila (p. 47).


• Esclarecimento das informações na seção Mudança de uma fila Padrão parauma fila FIFO (p. 75).

• Amostra de código Java otimizada nas seções a seguir:• AWS SDK for Java (p. 18)• Criar uma fila usando (p. 22)• Configurar para uma fila usando (p. 51)• AWS SDK for Java (p. 24)• AWS SDK for Java (p. 31)• AWS SDK for Java (p. 41)• AWS SDK for Java (p. 57)• AWS SDK for Java (p. 27)

207







O código Java de exemplo foi otimizado e os pré-requisitos de pom.xml foramcorrigidos nas seções a seguir:

• Java funcional de exemplo para usar o Amazon S3 para mensagens grandes doAmazon SQS (p. 93)

• Exemplo de Java funcional para filas Padrão (p. 70)• Exemplo de Java funcional para filas FIFO (p. 77)


O código Java de exemplo foi otimizado e os pré-requisitos de pom.xml foramadicionados às seções:

• Exemplo de Java funcional para filas Padrão (p. 70)• Exemplo de Java funcional para filas FIFO (p. 77)


Atualizada a seção Recursos relacionados do Amazon SQS (p. 195).


• Esclarecimento das informações na seção Consumo de mensagens usandosondagem breve (p. 70).

• A seção Limites do Amazon SQS (p. 125) foi reestruturada.


• A seguinte instrução foi esclarecida: Você não pode adicionar tags a uma novafila ao criá-la usando o Console de gerenciamento da AWS (você pode adicionartags após a criação da fila). No entanto, você pode adicionar, atualizar ouremover tags de filas a qualquer momento usando as ações do Amazon SQS.

• As informações na seção Definição do tempo limite de visibilidade (p. 90) eProcessar mensagens em tempo hábil (p. 119) foram elucidadas e corrigidas.

• Atualizada a seção Recursos relacionados do Amazon SQS (p. 195).• A seção Deixe seu comentário (p. 3) foi adicionada.


• Exemplo Java na seção Exemplo funcional Java para operações únicas esolicitações em lote (p. 187) agora é independente e foi adicionado aos pré-requisitos de pom.xml.

• Explicação adicionada para monitorar a execução do exemplo (p. 194).


Exemplo Java reescrito na seção Exemplo funcional Java para operações únicas esolicitações em lote (p. 187).


As seguintes seções foram reescritas:

• Aumento da taxa de transferência usando escalabilidade horizontal eprocessamento em lotes de ação da (p. 185)



• Ações em lote do Amazon SQS (p. 181)• Ativar buffer por parte do cliente e processamento de solicitações em

lotes (p. 181)


Esclarecimento das informações na seção Configuração de uma dead letterqueue (p. 56).


Criada a seção Tópicos do Amazon SQS novos e visualizados comfrequência (p. 4).

208




• Esclarecimento das informações na seção Lógica da entrega FIFO (p. 74).• Os exemplos de código foram corrigidos em — e as seguintes seções foram

renomeadas —:• Exemplo de Java funcional para filas Padrão (p. 70)• Exemplo de Java funcional para filas FIFO (p. 77)• Java funcional de exemplo para usar o Amazon S3 para mensagens grandes

do Amazon SQS (p. 93)• Exemplo funcional de Java para uso do JMS com filas Padrão do Amazon

SQS (p. 103)


As informações nas seguintes seções foram elucidadas:

• Permitir que os desenvolvedores gravem mensagens em uma filacompartilhada (p. 150)

• Ações em lote do Amazon SQS (p. 181)• Como as dead letter queues funcionam? (p. 86)



• Processo de autenticação básica com HMAC-SHA (p. 177)• Interpretação de respostas (p. 179)



• Envio de solicitações da API de consulta (p. 175)• Criar um endpoint (p. 175)• Como fazer uma solicitação GET (p. 176)• Autenticação de solicitações (p. 177)


• Foram adicionados links para explicar o motivo pelo qual os construtores declientes estão obsoletos no AWS SDK para Java em todo este guia. Para obtermais informações, consulte Criação de clientes de serviço no AWS SDK for JavaDeveloper Guide.

• A seguinte instrução foi esclarecida na seção Monitoramento de filas do AmazonSQS usando o CloudWatch (p. 128): O monitoramento detalhado (ou métricasde um minuto) não está disponível no momento para o Amazon SQS. Fazersolicitações para o CloudWatch nesta resolução pode não retornar nenhumdado.


O texto sobre ações do Amazon SQS foi esclarecido em todo este guia.


A seção Habilitar a compatibilidade entre os serviços da AWS e as filas com (p. 173) foi adicionada.


Esclarecimento das informações na seção Como as dead letter queuesfuncionam? (p. 86).

209

developer/client-constructors-now-deprecated/


creating-clients.html




• O código na seção the section called “Criação de uma conexão JMS” (p. 97)foi reescrito, substituindo o construtor AmazonSQSClient obsoleto peloAmazonSQSClientBuilder. Use a seguinte sintaxe para criar uma novafábrica de conexão com todas as configurações padrão (como credenciais eregião):

final SQSConnectionFactory connectionFactory = new SQSConnectionFactory( new ProviderConfiguration(), AmazonSQSClientBuilder.defaultClient());

• O código na seção Escalabilidade horizontal (p. 186) foi reescrito. Use a seguintesintaxe para ajustar o número máximo de threads de produtores e consumidorespermitidos em um objeto AmazonSQSClientBuilder:

final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard() .withClientConfiguration(new ClientConfiguration() .withMaxConnections(producerCount + consumerCount)) .build();


• Os códigos nas seções Exemplo de Java funcional para filas Padrão (p. 70)e Exemplo de Java funcional para filas FIFO (p. 77) foram reescritos esimplificados, substituindo o construtor AmazonSQSClient obsoleto peloAmazonSQSClientBuilder. Use a seguinte sintaxe para criar uma novainstância do construtor com todas as configurações padrão (como credenciais eregião):

final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

• O código na seção Java funcional de exemplo para usar o AmazonS3 para mensagens grandes do Amazon SQS (p. 93) foi reescrito esimplificado, substituindo o construtor AmazonS3Client obsoleto peloAmazonS3ClientBuilder:

final AmazonSQS s3 = AmazonS3ClientBuilder.defaultClient();


• Mais referências cruzadas para ID de mensagem (p. 80) e Identificador derecebimento (p. 80) foram adicionadas a este guia.

• A seção Gerenciamento de mensagens grandes do Amazon SQS usando oAmazon S3 (p. 92) foi reescrita.

210







• Nas seções Gerenciamento de mensagens grandes do Amazon SQS usandoo Amazon S3 (p. 92) e Como trabalhar com o JMS e o Amazon SQS (p. 96), aseguinte explicação foi esclarecida: The SDK para Java and Biblioteca de clienteestendida do Amazon SQS para Java require the J2SE Development Kit 8.0 orlater.

• Foram adicionadas subseções à seção Práticas recomendadas para o AmazonSQS (p. 119). Além disso, o conteúdo foi esclarecido e reorganizado.

• A explicação a seguir foi adicionada à seção Configurar a retenção de dead letterqueue (p. 121):

A expiração de uma mensagem é baseada sempre em seu timestamp em filaoriginal. Quando uma mensagem é movida para uma dead-letter queue (p. 86),o timestamp em fila permanece inalterado. Por exemplo, se uma mensagempassar 1 dia na fila original antes de ser movida para uma dead-letter queue, eo período de retenção da fila de dead-letter queue estiver definido em 4 dias, amensagem é excluída da fila de dead-letter queue após 3 dias. Por isso, umaprática recomendada é definir sempre o período de retenção de uma dead-letterqueue mais longo que o período de retenção da fila original.

• Esclarecimento das informações na seção Como as dead letter queuesfuncionam? (p. 86).

• A explicação a seguir foi adicionada à seção Tempo limite de visibilidade doAmazon SQS (p. 89): O tempo limite de visibilidade padrão para uma mensagemé de 30 segundos. O máximo é 12 horas.

3 de janeiro de2018

A taxa de transferência de filas FIFO foi mais esclarecida em todo este guia.


• Adicionada a seguinte nota na seção Uso de políticas com base em identidade(IAM) para o Amazon SQS (p. 147): Com exceção de ListQueues, todas açõesdo Amazon SQS oferecem suporte a permissões no nível do recurso. Para obtermais informações, consulte Referência de ações e recursos (p. 165).

• O vídeo "Apresentação de filas FIFO do Amazon Simple Queue Service (SQS)"foi adicionado à seção Filas FIFO (ordem de chegada) do Amazon SQS (p. 72).

• Adição do vídeo "Apresentação da criptografia do lado do servidor do AmazonSimple Queue Service (SQS)" à seção Proteção de dados usando criptografia nolado do servidor (SSE) e AWS KMS (p. 167).

• Adição do vídeo "Apresentação das tags de alocação de custos do AmazonSimple Queue Service (SQS)" na seção Tags de alocação de custos do AmazonSQS (p. 84).

211





• Foi sugerido o uso do Step Functions, em vez do Amazon SWF, para temposlimite de visibilidade maiores que 12 horas na seção Práticas recomendadaspara o Amazon SQS (p. 119).

• A seguinte explicação foi esclarecida na seção Limites relacionados amensagens (p. 126): O tempo limite de visibilidade padrão para uma mensagemé de 30 segundos. O máximo é 12 horas.

• Adicionada a seguinte nota na seção Inscrição de uma fila em um tópico (p. 43):Se a fila do Amazon SQS e um tópico do Amazon SNS estiverem em contasda AWS diferentes, o proprietário do tópico deverá confirmar primeiramente aassinatura. Para obter mais informações, consulte Confirm the Subscription noGuia do desenvolvedor do Amazon Simple Notification Service.

• Adicionada a seguinte nota na seção Termos-chave (p. 74): O Amazon SQScontinua mantendo o ID de desduplicação da mensagem mesmo após amensagem ser recebida e excluída.

• Foram esclarecidas e reorganizadas as informações nas seções Envio desolicitações da API de consulta (p. 175) e Monitoramento de filas do AmazonSQS usando o CloudWatch (p. 128).


Foram esclarecidas e reorganizadas as informações na seção Monitoramento defilas do Amazon SQS usando o CloudWatch (p. 128).


• Índice corrigido e reorganizado.• A seção Tempo limite de visibilidade do Amazon SQS (p. 89) foi reescrita.


A explicação da taxa de transferência para filas FIFO foi esclarecida na seção FilasFIFO (ordem de chegada) do Amazon SQS (p. 72).


Uma nota sobre o Cliente assíncrono armazenado em buffer do Amazon SQS foiadicionada na seção Aumento da taxa de transferência usando escalabilidadehorizontal e processamento em lotes de ação da (p. 185).


Correção dos diagramas na seção Uso de políticas do Amazon SQS e doIAM (p. 147).

29 de agosto de2017

Esclarecimento das informações na seção Alteração do tempo limite de visibilidadede uma mensagem (p. 91).

17 de agosto de2017

Esclarecimento das permissões das ações de SendMessage eSendMessageBatch em Referência de ações e recursos (p. 165).

15 de agosto de2017

Informações atualizadas sobre dead letter queues na seção Recomendações parafilas Amazon SQS Padrão e FIFO (ordem de chegada) (p. 119).

9 de agosto de2017



27 de julho de2017

O construtor AmazonSQSClient obsoleto foi alterado paraAmazonSQSClientBuilder, e a região de especificação correspondente naseção Exemplo de Java funcional para filas Padrão (p. 70) foi revisada.

25 de julho de2017

A taxa de transferência de filas padrão e FIFO foi esclarecida em todo este guia.

212

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToHttp.html#SendMessageToHttp.confirm




20 de julho de2017

Esclarecida a compatibilidade entre filas do Amazon SQS SSE e recursos deserviços da AWS e de terceiros em todo este guia:

Alguns recursos dos serviços da AWS que podem enviar notificações para AmazonSQS usando a ação AWS Security Token Service AssumeRole de que sejamcompatíveis com SSE mas funcionam somente com as filas padrão:


Outros recursos dos serviços da AWS ou serviços de terceiros, que enviamnotificações ao Amazon SQS que não sejam compatíveis com SSE, apesar depermitirem que você defina uma fila criptografada como destino:


Para obter informações sobre a compatibilidade de outros serviços com as filascriptografadas, consulte Habilitar a compatibilidade entre os serviços da AWS e asfilas com (p. 173) e a documentação do serviço.

23 de junho de2017

Informações corrigidas na seção Limites relacionados a mensagens (p. 126).

20 de junho de2017

Esclarecimento das informações na seção Dead-Letter Queues do AmazonSQS (p. 86).

2 de junho de 2017 • Reestruturada e atualizada a seção Dead-Letter Queues do AmazonSQS (p. 86).

• Criada a seção Configuração de uma dead letter queue (p. 56).

1 de junho de 2017 Atualizada a seção O que é o Amazon Simple Queue Service? (p. 1).

24 de maio de2017

• A seção Como trabalhar com o JMS e o Amazon SQS (p. 96) foi reestruturada.• Criada a seção Uso do Amazon SQS Java Message Service (JMS) Client com

outros clientes do Amazon SQS (p. 102).

23 de maio de2017

Criptografia do lado do servidor (SSE) for Amazon SQS está disponível nas regiõesLeste dos EUA (Norte da Virgínia), além das regiões Leste dos EUA (Ohio) e Oestedos EUA (Oregon). Para obter mais informações sobre a criptografia do lado doservidor e sobre como começar a usá-la, consulte Proteção de dados usandocriptografia no lado do servidor (SSE) e AWS KMS (p. 167).

19 de maio de2017

• Você pode usar o Biblioteca de cliente estendida do Amazon SQS para Javajunto com o Cliente Java Message Service (JMS) Amazon SQS.



25 de abril de 2017 Reestruturada e atualizada a seção Sondagem longa do Amazon SQS (p. 85).


Atualizada a seção Controle de acesso e autenticação (p. 140).

213







16 de dezembrode 2016

O Guia de conceitos básicos do Amazon Simple Queue Servicefoi removido e partede seu conteúdo foi incorporado nas seguintes seções deste guia:

• Configuração do Amazon SQS (p. 6)• Conceitos básicos do Amazon SQS (p. 9)• Tutoriais do Amazon SQS (p. 16)


Reestruturada e atualizada a seção Controle de acesso e autenticação (p. 140).


Renomeada a seção de demonstrações de exemplo para Tutoriais do AmazonSQS (p. 16).

27 de maio de2016

A seção Práticas recomendadas para o Amazon SQS (p. 119) foi adicionada.

12 de maio de2016

A seção Limites do Amazon SQS (p. 125) foi adicionada.


Atualizadas as capturas de tela do console do Amazon SQS.

4 de agosto de2014

Informações atualizadas sobre as chaves de acesso. Para obter mais informações,consulte Autenticação de solicitações (p. 177).

214


AWS GlossaryFor the latest AWS terminology, see the AWS Glossary in the AWS General Reference.

215

https://docs.aws.amazon.com/general/latest/gr/glos-chap.html

Amazon Simple Queue Service - AWS Documentation · Amazon Simple Queue Service Guia do...

Documents

Transcript of Amazon Simple Queue Service - AWS Documentation · Amazon Simple Queue Service Guia do...