Python 21

Tradutor da Amazon
Guia do desenvolvedor
Tradutor da Amazon Guia do desenvolvedor
Tradutor da Amazon: Guia do desenvolvedor

Copyright © 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 manner
that is likely to cause confusion among customers, or in any manner that disparages or discredits Amazon. All other trademarks not
owned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to, or sponsored by
Amazon.
Table of Contents
O que é o Amazon Translate? ............................................................................................................. 1
Você é um usuário iniciante do Amazon Translate? ......................................................................... 1
Como funcionam os bancos de dados públicos ....................................................................................... 2
Detecção automática de idioma .................................................................................................... 3
Processamento de exceções ........................................................................................................ 3
Próximas etapas ......................................................................................................................... 3
Conceitos básicos ............................................................................................................................... 4
Etapa 1: configurar uma conta ..................................................................................................... 4
Cadastre-se na AWS .......................................................................................................... 4
Criar um usuário do IAM ..................................................................................................... 5
Próxima etapa .................................................................................................................... 5
Etapa 2: Configurar a AWS CLI .................................................................................................... 5
Próxima etapa .................................................................................................................... 6
Etapa 3: Conceitos básicos (console) ............................................................................................ 6
Próxima etapa .................................................................................................................... 8
Etapa 4: Conceitos básicos (AWS CLI) .......................................................................................... 8
Traduzir textos usando a linha de comando ............................................................................ 9
Traduzir textos usando um arquivo JSON .............................................................................. 9
Próxima etapa .................................................................................................................. 10
Etapa 5: Conceitos básicos (SDK) ............................................................................................... 10
Uso do SDK para Java ...................................................................................................... 10
Como usar o AWS SDK para Python ................................................................................... 11
Usar Mobile SDK para Android ........................................................................................... 11
Uso do Mobile SDK for iOS ............................................................................................... 13
Exemplos ......................................................................................................................................... 15
Usar o Amazon Polly com o Amazon Translate ............................................................................. 15
Code ............................................................................................................................... 15
Usar o Amazon Translate para traduzir um canal de bate-papo ........................................................ 19
Usar o Amazon Translate com o DynamoDB ................................................................................ 27
Código de exemplo ........................................................................................................... 28
Usar o Amazon Translate para traduzir uma página da Web ........................................................... 30
Uso do Amazon Translate para traduzir grandes documentos .......................................................... 33
Uso do Signature versão 4 com o Amazon Translate ..................................................................... 35
Configuração .................................................................................................................... 35
Code ............................................................................................................................... 35
Autenticação e controle de acesso ...................................................................................................... 39
Autenticação ............................................................................................................................ 39
Controle de acesso ................................................................................................................... 40
Visão geral do gerenciamento de acesso ..................................................................................... 40
Gerenciar o acesso a ações ............................................................................................... 41
Como especificar elementos da política: recursos, ações, efeitos e entidades de segurança .......... 42
Especificação de condições em uma política ......................................................................... 42
Uso de políticas baseadas em identidade (políticas do IAM) para o Amazon Translate ......................... 42
Referência de permissões da API do Amazon Translate ................................................................. 43
Monitoramento .................................................................................................................................. 44
Monitoramento com o CloudWatch .............................................................................................. 46
Compreender métricas do CloudWatch para o Amazon Translate ............................................. 46
Como visualizar métricas do Amazon Translate ..................................................................... 47
Criar um alarme ............................................................................................................... 47
Métricas e dimensões do CloudWatch para o Amazon Translate ...................................................... 47
CloudWatch Metrics for Amazon Translate ............................................................................ 47
CloudWatch Dimensions for Amazon Translate ..................................................................... 48
Diretrizes e limites ............................................................................................................................ 50
Regiões compatíveis ................................................................................................................. 50
iii
Limitação ................................................................................................................................. 50
Diretrizes ................................................................................................................................. 50
Limites .................................................................................................................................... 50
Histórico do documento ..................................................................................................................... 51
API Reference .................................................................................................................................. 52
Actions .................................................................................................................................... 52
TranslateText ................................................................................................................... 53
Data Types .............................................................................................................................. 56
Common Errors ........................................................................................................................ 56
Common Parameters ................................................................................................................. 57
AWS Glossary .................................................................................................................................. 60
iv
Você é um usuário iniciante do Amazon Translate?
O que é o Amazon Translate?

O Amazon Translate traduz documentos de seis idiomas para o inglês e do inglês para seis idiomas:
• Árabe
• Chinês simplificado
• Francês
• Alemão
• Português
• Espanhol
O Amazon Translate usa tecnologias avançadas de machine learning para fornecer traduções de alta
qualidade sob demanda. Use-o para traduzir documentos ou texto não estruturado ou para criar aplicativos
que funcionem em vários idiomas.
Por exemplo, é possível:
• Integrar o Amazon Translate a seus aplicativos para habilitar experiências de usuário multilíngues.
• Traduza conteúdo da empresa, como atas de reunião, relatórios técnicos, artigos da base de
conhecimento, postagens e muito mais.
• Traduza comunicações interpessoais, como e-mail, bate-papo no jogo, bate-papo de atendimento ao
cliente e muito mais, permitindo que clientes e funcionários se conectem no idioma preferido.
• Usar o Amazon Translate como parte do fluxo de trabalho da sua empresa para dados de entrada.
• Analise texto, como mídias sociais e feeds de notícias, em vários idiomas.
• Informações de pesquisa, como para casos de eDiscovery, em vários idiomas.
• Integrar o Amazon Translate a outros serviços da AWS para habilitar o processamento independente de
idioma.
• Usá-lo com o Amazon Comprehend para extrair entidades nomeadas, sentimentos e frases-chave de
texto não estruturado, como streamings de mídia social.
• Use-o com o Amazon Transcribe para disponibilizar legendas e captions em vários idiomas.
• Usá-lo com o Amazon Polly falar conteúdo traduzido.
• Usá-lo com o Amazon S3 para traduzir repositórios de documentos.
• Usá-lo com o Amazon DynamoDB, o Amazon Aurora e o Amazon Redshift para traduzir textos
armazenados em bancos de dados.
• Usá-lo com o AWS Lambda ou o AWS Glue para obter uma perfeita integração de fluxo de trabalho.
Você é um usuário iniciante do Amazon Translate?

Caso seja um usuário iniciante, recomendamos que você leia as seções a seguir em ordem:
1. Como o Amazon Translate funciona (p. 2) - Apresenta o Amazon Translate.

2. Conceitos básicos do Amazon Translate (p. 4) - Explica como configurar sua Conta da AWS e testar
o Amazon Translate.
3. Exemplos (p. 15) - Fornece exemplos de código em Java e Python. Use-os para descobrir como o
Amazon Translate funciona.
4. API Reference (p. 52) - Contém a documentação de referência das operações do Amazon Translate.
1
Como o Amazon Translate funciona

O Amazon Translate é baseado em redes neurais que foram treinadas para traduzir do inglês e os
seguintes idiomas, ou destes idiomas para o inglês:
• Árabe
• Chinês (simplificado)
• Francês
• Alemão
• Português
• Espanhol
Você também pode traduzir o texto de qualquer um desses idiomas para outro. Para isso, basta traduzir o
texto original para o inglês e, depois, para o idioma de destino.
Ao trabalhar com o Amazon Translate, você fornecerá texto de origem e obterá o texto de saída:
• Texto de origem — O texto que você deseja traduzir. O texto de origem deve ser inserido no formato
UTF-8.
• Texto de saída — O texto que o Amazon Translate traduziu para o idioma de destino, que também está
no formato UTF-8. Dependendo dos idiomas de origem e de destino, pode haver mais caracteres no
texto de saída do que no texto de entrada.
O modelo de tradução tem dois componentes: o codificador e o decodificador. O codificador lê uma palavra
por vez na frase original e cria uma representação semântica que captura seu significado. O decodificador
usa a representação semântica para gerar uma tradução, uma palavra por vez, no idioma de destino.
O Amazon Translate usa mecanismos de atenção para entender o contexto. Isso ajuda a decidir quais
palavras no texto de origem são mais relevantes para gerar a próxima palavra no texto de destino. Os
mecanismos de atenção permitem que o decodificador se concentre nas partes mais relevantes de uma
sentença do texto de origem. Isso garante que o decodificador traduza corretamente palavras ou frases
ambíguas.
A palavra do texto de destino que o modelo gera se torna entrada para o decodificador. A rede continua
gerando palavras até chegar ao final da frase.
Para traduzir o texto, você chama o método TranslateText (p. 53), fornece o texto de origem e informa o
idioma de destino, usando o código de idioma listado na tabela a seguir.
Idioma Code
Árabe ar
Chinês (simplificado) zh
Inglês en
Francês fr
Alemão de
Português pt
2
Detecção automática de idioma
Idioma Code
Espanhol es
Para traduzir texto de qualquer idioma diferente do inglês para outro, traduza-o para o inglês primeiro e,
em seguida, traduza o texto de saída em inglês para o idioma de destino.
O Amazon Translate pode detectar automaticamente o idioma de origem. Para detecção automática de
idioma, especifique auto como o idioma de origem ao informar o texto de origem. O Amazon Translate
chama o Amazon Comprehend para detectar o idioma de origem.
Detecção automática de idioma

O Amazon Translate pode detectar automaticamente o idioma usado no seu texto de origem. Para usar
a detecção automática de idioma, especifique auto como o idioma de origem O Amazon Translate
chama o Amazon Comprehend em seu nome para determinar o idioma usado no texto de origem. Ao
escolher a detecção automática de idioma, você concorda com os termos e acordos de serviço do Amazon
Comprehend. Para obter mais informações sobre a definição de preço do Amazon Comprehend, consulte
Definição de preço do Amazon Comprehend.
Processamento de exceções
Se você especificar um idioma de origem ou de destino que não seja compatível, o Amazon Translate
retorna uma das seguintes exceções:
• UnsupportedLanguagePairException – O Amazon Translate oferece suporte à tradução entre inglês e

outros seis idiomas. O idioma de origem ou o idioma de destino precisa ser inglês.
• DetectedLanguageLowConfidenceException – Se você usar a detecção automática de idioma e o
Amazon Translate tiver pouca confiança em relação à detecção do idioma de origem, ele retornará essa
exceção. Se um nível de confiança baixo for aceitável, você poderá usar o idioma de origem retornado
na exceção.
Próximas etapas
Agora que você aprendeu sobre o Amazon Translate poderá explorar as seções a seguir para saber mais
sobre como criar uma solução.
• Conceitos básicos do Amazon Translate (p. 4)

• Exemplos (p. 15)
3
Etapa 1: configurar uma conta
Conceitos básicos do Amazon

Translate
Para começar a usar o Amazon Translate, configure uma conta da AWS e crie um usuário do AWS Identity
and Access Management (IAM). Para usar a AWS Command Line Interface (AWS CLI), faça download
dela e configure-a.
Tópicos
• Etapa 1: configurar uma conta da AWS e criar um usuário administrador (p. 4)
• Etapa 2: configurar a AWS Command Line Interface (AWS CLI) (p. 5)
• Etapa 3: Conceitos básicos (console) (p. 6)
• Etapa 4: Conceitos básicos (AWS CLI) (p. 8)
• Etapa 5: Conceitos básicos (SDK) (p. 10)
Etapa 1: configurar uma conta da AWS e criar um

usuário administrador
Antes de usar o Amazon Translate pela primeira vez, execute as seguintes tarefas:
1. Cadastre-se na AWS (p. 4)

2. Criar um usuário do IAM (p. 5)
Cadastre-se na AWS
Quando você se cadastra na Amazon Web Services (AWS), sua conta da AWS é cadastrada
automaticamente em todos os serviços da AWS, inclusive o Amazon Translate. Você será cobrado apenas
pelos serviços que usar.
Com o Amazon Translate, você paga apenas pelos recursos que usa. Se você for um cliente novo da
AWS, poderá começar a usar o Amazon Translate gratuitamente. Para obter mais informações, consulte
Nível de uso gratuito da AWS.
Se você já tem uma conta da AWS, vá para a próxima seção.
Para criar uma conta da AWS
1. Abra o https://aws.amazon.com/ e escolha em Criar uma conta da AWS.

Note
Isso pode estar indisponível no seu navegador se, anteriormente, você iniciou a sessão
no Console de gerenciamento da AWS. Nesse caso, escolha Fazer login com uma conta
diferente e, em seguida, Criar uma nova conta da AWS.
2. Siga as instruções online.
Parte do procedimento de cadastro envolve uma chamada telefônica e a digitação de um PIN usando
o teclado do telefone.
4
Criar um usuário do IAM
Registre o ID de sua conta da AWS, pois precisará dele na próxima tarefa.
Criar um usuário do IAM

Os serviços da AWS, como o Amazon Translate, exigem que você forneça credenciais quando acessá-los.
Isso permite que o serviço determine se você tem permissões para acessar os recursos dele.
Recomendamos veementemente que você acesse a AWS usando o AWS Identity and Access
Management (IAM), em vez das credenciais de sua conta da AWS. Para usar o IAM a fim de acessar a
AWS, crie um usuário do IAM, adicione o usuário a um grupo do IAM com permissões administrativas e,
em seguida, conceda permissões administrativas ao usuário do IAM. Em seguida, você pode acessar a
AWS usando um URL especial e as credenciais do usuário do IAM.
Os exercícios deste guia pressupõem que você tenha um usuário do IAM chamado adminuser com
privilégios de administrador.
Para criar um usuário administrador
• Em sua conta da AWS, crie um usuário administrador chamado adminuser. Para obter instruções,
consulte Criação do primeiro usuário do IAM e do grupo de administradores no Guia do usuário do
IAM.
Para obter mais informações sobre IAM, consulte o seguinte:
• AWS Identity and Access Management (IAM)

• Conceitos básicos
• Guia do usuário do IAM
Próxima etapa
Etapa 2: configurar a AWS Command Line Interface (AWS CLI) (p. 5)
Etapa 2: configurar a AWS Command Line Interface

(AWS CLI)
Use a AWS CLI para fazer chamadas interativas para o Amazon Translate.
Para configurar a AWS CLI
1. Faça download e configure a AWS CLI. Para obter instruções, consulte os seguintes tópicos no Guia
do usuário do AWS Command Line Interface:
• Configurar com a AWS Command Line Interface

• Configurar o AWS Command Line Interface
2. No arquivo config da AWS CLI, adicione um perfil nomeado para o usuário administrador:
[profile adminuser]
aws_access_key_id = adminuser access key ID
aws_secret_access_key = adminuser secret access key
region = aws-region
5
Próxima etapa
Você pode usar esse perfil ao executar os comandos da AWS CLI. Para obter mais informações sobre
perfis nomeados, consulte Perfis nomeados no Guia do usuário do AWS Command Line Interface.
Para obter uma lista de regiões da AWS, consulte Regiões e endpoints no Referência geral do
Amazon Web Services.
3. Verifique a configuração digitando o seguinte comando de ajuda no prompt de comando:
aws translate help
Você deve ver uma breve descrição do Amazon Translate e uma lista dos comandos disponíveis.
Próxima etapa
Etapa 3: Conceitos básicos (console) (p. 6)
Etapa 3: Conceitos básicos (console)

A maneira mais fácil de começar a usar o Amazon Translate é traduzir um texto por meio do console.
Você pode traduzir até 1.000 caracteres usando o console. Se você ainda não revisou os conceitos e a
terminologia em Como o Amazon Translate funciona (p. 2), recomendamos fazer isso antes de continuar.
Para começar a traduzir um texto, faça login no Console de Gerenciamento da AWS e abra o console
do Amazon Translate. Se esta é a sua primeira vez usando o Amazon Translate, selecione Try Amazon
Translate.
Em Translate text, selecione os idiomas de origem e de destino. Insira o texto que você deseja traduzir na
caixa de texto à esquerda. O texto traduzido é exibido na caixa de texto à direita.
6
Etapa 3: Conceitos básicos (console)
Na seção JSON samples, você pode ver a entrada e a saída JSON para a operação
TranslateText (p. 53).
7
Próxima etapa
Próxima etapa
Etapa 4: Conceitos básicos (AWS CLI) (p. 8)
Etapa 4: Conceitos básicos (AWS CLI)

Nos exercícios a seguir, use a interface de linha de comando da AWS (AWS CLI) para traduzir o texto.
Para concluir esses exercícios, você precisa estar familiarizado com a CLI e ter um editor de texto.
Para obter mais informações, consulte Etapa 2: configurar a AWS Command Line Interface (AWS
CLI) (p. 5).
Há duas maneiras de usar a CLI para traduzir o texto com o Amazon Translate. Para textos curtos, você
pode fornecer o texto que deseja traduzir como um parâmetro do comando translate-text. Para textos
mais longos, você pode fornecer o idioma de origem, o idioma de destino e o texto em um arquivo JSON.
Para usar o Amazon Translate a partir da linha de comando, você precisa saber o endpoint e a região do
serviço. Para obter uma lista de endpoints e regiões disponíveis, consulte Diretrizes e limites (p. 50).
8
Traduzir textos usando a linha de comando
Traduzir textos usando a linha de comando

O exemplo a seguir mostra como usar a operação translate-text na linha de comando para traduzir
o texto. O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de
continuação Unix de barra invertida (\) no final de cada linha por um circunflexo (^). Na linha de comando,
digite o conteúdo a seguir.
aws translate translate-text \

--region region \
--source-language-code "en" \
--target-language-code "es" \
--text "hello, world "
A resposta é o seguinte JSON:
{
"TargetLanguageCode": "es",
"Text": "Hola, mundo",
"SourceLanguageCode": "en"
}
Traduzir textos usando um arquivo JSON

Este exemplo mostra como usar a operação translate-text para traduzir um bloco de texto maior a
partir de um arquivo JSON. Você pode especificar os idiomas de origem e de destino na linha de comando,
mas neste exemplo, especifique-os no arquivo JSON.
Note
O arquivo JSON é formatado visando a capacidade de leitura. Reformate o campo "Text" para
remover as quebras de linha.
O exemplo é formatado para Unix, Linux e macOS. Para Windows, substitua o caractere de
continuação Unix de barra invertida (\) no final de cada linha por um circunflexo (^).
Para traduzir o texto usando um arquivo JSON
1. Copie o seguinte texto em um arquivo JSON chamado translate.json:
{
"Text": "Amazon Translate translates documents into English from
six languages and vice versa in real time. It uses
advanced machine learning technologies to provide
high-quality real-time translation. Use it to translate
documents or to build applications that work in multiple
languages.",
"SourceLanguageCode": "en",
"TargetLanguageCode": "fr"
}
2. Na AWS CLI, execute o seguinte comando:
aws translate translate-text \

--region region \
--cli-input-json file://translate.json > translated.json
O comando resulta em um arquivo JSON que contém o seguinte texto de JSON:
9
Próxima etapa
"TargetLanguageCode": "fr",
"Text": "Amazon Translate traduit les documents en anglais à partir
de six langues et vice versa en temps réel. Il utilise des
technologies avancées d'apprentissage de la machine pour
fournir une traduction en temps réel de haute qualité.
Utilisez-le pour traduire des documents ou pour créer des
applications qui fonctionnent en plusieurs langues.",
"SourceLanguageCode": "en"
}
Próxima etapa
Para ver outras formas de usar o Amazon Translate, consulte Exemplos (p. 15).
Etapa 5: Conceitos básicos (SDK)

Os exemplos a seguir demonstram como usar a operação TranslateText (p. 53) do Amazon Translate
usando Java e Python. Use-os para saber mais sobre a operação TranslateText e como criar blocos
para seus próprios aplicativos.
Para executar os exemplos de Java, você precisa instalar o AWS SDK for Java. Para obter instruções para
instalar o SDK para Java, consulte Configurar o AWS SDK para Java.
Tópicos
• Tradução de texto usando o AWS SDK for Java (p. 10)
• Tradução de texto usando o AWS SDK for Python (Boto) (p. 11)
• Traduzir textos usando o AWS Mobile SDK para Android (p. 11)
• Traduzir textos usando o AWS Mobile SDK for iOS (p. 13)
Tradução de texto usando o AWS SDK for Java

O exemplo a seguir demonstra como usar a TranslateText (p. 53) operação em Java. Para executar
esse exemplo, é necessário ter o AWS SDK for Java. Para obter instruções para instalar o SDK para Java,
consulte Configurar o AWS SDK para Java.
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.translate.AWSTranslate;
import com.amazonaws.services.translate.AmazonTranslateClient;
import com.amazonaws.services.translate.model.TranslateTextRequest;
import com.amazonaws.services.translate.model.TranslateTextResult;
public class App {

private static final String REGION = "region";
public static void main( String[] args ) {
// Create credentials using a provider chain. For more information, see

// https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html
AWSCredentialsProvider awsCreds = DefaultAWSCredentialsProviderChain.getInstance();
AWSTranslate translate = AmazonTranslateClient.standard()

.withCredentials(new AWSStaticCredentialsProvider(awsCreds))
10
Como usar o AWS SDK para Python
.withRegion(REGION)
.build();
TranslateTextRequest request = new TranslateTextRequest()

.withText("Hello, world")
.withSourceLanguageCode("en")
.withTargetLanguageCode("es");
TranslateTextResult result = translate.translateText(request);
System.out.println(result.getTranslatedText());
}
}
Você pode alterar os idiomas de origem e de destino de acordo com as restrições a seguir:
• Se o idioma de origem for o inglês, você pode traduzir o texto de origem para qualquer um dos
outros idiomas compatíveis. Para ver uma lista das linguagens, consulte Como o Amazon Translate
funciona (p. 2).
• Se o idioma de origem não for inglês, o idioma de destino deverá ser inglês.
Tradução de texto usando o AWS SDK for Python

(Boto)
O exemplo a seguir demonstra como usar a operação TranslateText (p. 53) em Python. Para executá-
la, você deve primeiro instalar o Amazon Translate por meio da AWS CLI. Para obter instruções, consulte
the section called “Etapa 2: Configurar a AWS CLI” (p. 5).
import boto3
translate = boto3.client(service_name='translate', region_name='region', use_ssl=True)
result = translate.translate_text(Text="Hello, World",

SourceLanguageCode="en", TargetLanguageCode="de")
print('TranslatedText: ' + result.get('TranslatedText'))
print('SourceLanguageCode: ' + result.get('SourceLanguageCode'))
print('TargetLanguageCode: ' + result.get('TargetLanguageCode'))
Você pode alterar os idiomas de origem e de destino de acordo com as restrições a seguir:
• Se o idioma de origem for o inglês, você pode traduzir o texto de origem para qualquer um dos outros
idiomas compatíveis. Para ver uma lista das linguagens, consulte Como funcionam os bancos de dados
públicos (p. 2).
• Se o idioma de origem não for inglês, o idioma de destino deverá ser inglês.
Traduzir textos usando o AWS Mobile SDK para

Android
Você pode usar o Amazon Translate em um aplicativo Android para traduzir textos.
Para configurar o exemplo
1. Configure o AWS Mobile SDK para Android. Para obter instruções, consulte Android: opções de
configuração para o SDK no Guia do desenvolvedor do AWS Mobile
2. Crie um usuário do IAM com as permissões mínimas necessárias para executar esse exemplo. Para
obter informações sobre como criar um usuário do IAM, consulte Criação de um usuário do IAM
11
Usar Mobile SDK para Android
na sua conta da AWS no Guia do usuário do AWS Identity and Access Management. Para ver as
políticas de permissões necessárias, consulte Uso de políticas baseadas em identidade (políticas
do IAM) para o Amazon Translate (p. 42). Após criar o usuário, baixe as credenciais ou registre a
chave de acesso e a chave de acesso secreta.
3. Crie um novo projeto com o Android Studio.
4. Adicione o seguinte à seção de dependências do arquivo build.gradle.
dependencies {
implementation 'com.amazonaws:aws-android-sdk-translate:2.6.20'
}
5. Adicione as permissões a seguir ao arquivo AndroidManifest.xml.
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
6. Copie o código-fonte no seu projeto

7. Altere a chave de acesso e a chave de acesso secreta para as chaves que você registrou na etapa
um.
Code
Use o seguinte código para criar o exemplo:
package com.amazonaws.amazontranslatetester;
import android.app.Activity;
import android.util.Log;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.handlers.AsyncHandler;
import com.amazonaws.services.translate.AmazonTranslateAsyncClient;
public class MainActivity extends Activity {
private static final String LOG_TAG = MainActivity.class.getSimpleName();
@Override
protected void onCreate(Bundle savedInstanceState) {
AWSCredentials awsCredentials = new AWSCredentials() {
@Override
public String getAWSAccessKeyId() {
return "access key";
}
@Override
public String getAWSSecretKey() {
return "secret key";
}
};
AmazonTranslateAsyncClient translateAsyncClient = new

AmazonTranslateAsyncClient(awsCredentials);
TranslateTextRequest translateTextRequest = new TranslateTextRequest()
.withText("Hello, world")
12
Uso do Mobile SDK for iOS
translateAsyncClient.translateTextAsync(translateTextRequest, new
AsyncHandler<TranslateTextRequest, TranslateTextResult>() {
@Override
public void onError(Exception e) {
Log.e(LOG_TAG, "Error occurred in translating the text: " +
e.getLocalizedMessage());
}
@Override
public void onSuccess(TranslateTextRequest request, TranslateTextResult
translateTextResult) {
Log.d(LOG_TAG, "Original Text: " + request.getText());
Log.d(LOG_TAG, "Translated Text: " +
translateTextResult.getTranslatedText());
}
});
}
}
Traduzir textos usando o AWS Mobile SDK for iOS

Você pode usar o Amazon Translate em um aplicativo iOS para traduzir textos.
políticas de permissões necessárias, consulte Uso de políticas baseadas em identidade (políticas
do IAM) para o Amazon Translate (p. 42). Após criar o usuário, baixe as credenciais ou registre a
chave de acesso e a chave de acesso secreta.
2. Instalar o Xcode versão 8.0 ou posterior. Você pode baixar a versão mais recente do Xcode no site da
Apple, https://developer.apple.com/xcode/.
3. Instalar o Cocoapods. Em uma janela de terminal, execute o seguinte comando:
sudo gem install cocoapods
4. Crie um projeto usando o Xcode. Em seguida, em uma janela de terminal, navegue até o diretório que
contém o arquivo .xcodeproj do seu projeto e execute o seguinte comando:
pod init
5. Adicione os principais componentes do Mobile SDK for iOS ao arquivo pod:
platform :ios, '9.0'

target :'app name' do
use_frameworks!
pod 'AWSTranslate', '~> 2.6.19'
# other pods
end
6. Instale as dependências executando o seguinte comando em uma janela de terminal:
pod install --repo-update
13
Uso do Mobile SDK for iOS
7. A execução de pod install cria um novo arquivo do Workspace. Feche o projeto Xcode e, em
seguida, abra-o usando o arquivo /project_name.xcworkspace. A partir de agora, você deve usar
esse arquivo somente para abrir o projeto Xcode
Compile o aplicativo novamente após abri-lo para resolver as APIs das novas bibliotecas chamadas no
código.
8. Adicione a seguinte instrução de importação ao controlador de visualização:
import AWSTranslate
9. Copie o seguinte código no seu projeto XCode. Atualize a chave de acesso e a chave secreta para os
valores que você registrou na etapa 1.
Code
var credentialsProvider = AWSStaticCredentialsProvider(accessKey: "access key", secretKey:

"secret key")
var configuration = AWSServiceConfiguration(region: AWSRegionUSEast1, credentialsProvider:

credentialsProvider)
AWSServiceManager.default().defaultServiceConfiguration = configuration
let translateClient = AWSTranslate.default()

let translateRequest = AWSTranslateTranslateTextRequest()
translateRequest?.sourceLanguageCode = "en"
translateRequest?.targetLanguageCode = "es"
translateRequest?.text = "Hello World"
let callback: (AWSTranslateTranslateTextResponse?, Error?) -> Void = { (response, error) in

guard let response = response else {
print("Got error \(error)")
return
}
if let translatedText = response.translatedText {

print(translatedText)
}
}
translateClient.translateText(translateRequest!, completionHandler: callback)
14
Usar o Amazon Polly com o Amazon Translate
Exemplos
Os exemplos a seguir mostram formas de você usar o Amazon Translate.
Tópicos
• Usar o Amazon Polly com o Amazon Translate (p. 15)
• Usar o Amazon Translate para traduzir um canal de bate-papo (p. 19)
• Uso do Amazon Translate com o Amazon DynamoDB (p. 27)
• Usar o Amazon Translate para traduzir uma página da Web (p. 30)
• Uso do Amazon Translate para traduzir grandes documentos (p. 33)
• Uso do Signature versão 4 com o Amazon Translate (p. 35)
Usar o Amazon Polly com o Amazon Translate

Para fazer a leitura do texto traduzido, você pode usar o Amazon Polly com o Amazon Translate. Neste
exemplo, você cria uma página da Web em que pode traduzir o texto usando o Amazon Translate e, em
seguida, fazer a leitura desse texto usando o Amazon Polly. O código pode ser resumido no seguinte:
• CSS e HTML para criar a página da Web.

• Código de inicialização que cria controladores para o Amazon Translate e o Amazon Polly.
• Uma função que lê dados da página da Web e chama o Amazon Translate.
• Uma função que lê dados da página da Web e chama o Amazon Polly.
• As funções do utilitário para gerenciar a página da Web.
1. Instale e configure o AWS SDK for JavaScript. Para obter instruções para instalar o SDK for
JavaScript, consulte Instalar o SDK para JavaScript.
2. Copie o código de exemplo para um arquivo HTML em seu servidor da Web.
3. Atualize a tag <script> para o local onde você instalou o SDK for JavaScript.
4. Altere a região e o endpoint para a região onde você deseja executar as operações do Amazon
Translate e do Amazon Polly. Para obter uma lista das regiões com suporte do Amazon Translate,
consulte Diretrizes e limites (p. 50). Para obter uma lista das regiões com suporte do Amazon Polly,
consulte Regiões e endpoints da AWS na Referência geral da Amazon Web Services.
5. Crie um usuário do IAM com as permissões mínimas necessárias para executar esse exemplo.
Para obter informações sobre como criar um usuário do IAM, consulte Criação de um usuário do
IAM na sua conta da AWS no Guia do usuário do AWS Identity and Access Management. Para as
permissões necessárias, consulte Uso de políticas baseadas em identidade (políticas do IAM) para
o Amazon Translate (p. 42) e Uso de políticas baseadas em identidade (políticas do IAM) para o
Amazon Polly no Guia do desenvolvedor do Amazon Polly.
6. Forneça o ID de acesso e a chave secreta do usuário do IAM criados na etapa anterior.
Code
A seguir você encontra o código completo da página da Web de exemplo. Você pode copiar esse código
em um arquivo HTML para executar o exemplo no seu próprio servidor da Web.
<!DOCTYPE html>
15
Code
<html>
<head>
<title>Amazon Translate</title>
<script src="aws-sdk/dist/aws-sdk.js"></script>
</head>
<body>
<h1 style="text-align: left">Amazon Translate Demo</h1>
<br/>
<table class="tg">
<tr>
<th align="left">
Source Language Code:
<select id="sourceLanguageCodeDropdown">
<option value="en">en</option>
<option value="ar">ar</option>
<option value="de">de</option>
<option value="es">es</option>
<option value="fr">fr</option>
<option value="pt">pt</option>
<option value="zh">zh</option>
</select>
</th>
<th align="left">
Target Language Code:
<select id="targetLanguageCodeDropdown">
</select>
</th>
</tr>
<tr>
<th>
<textarea id="inputText" name="inputText" rows="10" cols="50"
placeholder="Text to translate..."></textarea>
</th>
<th>
<textarea id="outputText" name="outputText" rows="10" cols="50"
placeholder="Translated text..."></textarea>
</th>
</tr>
<tr>
<th align="left">
<button type="button" name="translateButton"
onclick="doTranslate()">Translate</button>
<button type="button" name="synthesizeButton"
onclick="doSynthesizeInput()">Synthesize Input Speech</button>
<button type="button" name="clearButton" onclick="clearInputs()">Clear</
button>
</th>
<th align="left">
<button type="button" name="synthesizeButton"
onclick="doSynthesizeOutput()">Synthesize Output Speech</button>
</th>
</tr>
</table>
<script type="text/javascript">
// set the focus to the input box
document.getElementById("inputText").focus();
16
Code
/**
* Change the region and endpoint.
AWS.config.region = 'region'; // Region
var ep = new AWS.Endpoint('endpoint');
/**
* Place your credentials here. The IAM user associated with these credentials must
have permissions to call
* Amazon Translate. We recommend using the following permissions policy and
nothing more, as anyone that has
* access to this HTML page will also have access to these hard-coded credentials.
* {
* "Version": "2012-10-17",
* "Statement": [
* {
* "Action": [
* "translate:TranslateText",
* "polly:SynthesizeSpeech"
* ],
* "Resource": "*",
* "Effect": "Allow"
* }
* ]
* }
*
* For more information about the AWS Credentials object, see:
* http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Credentials.html
*/
AWS.config.credentials = new AWS.Credentials("access key", "secret key);
var translate = new AWS.Translate({endpoint: ep, region: AWS.config.region});

var polly = new AWS.Polly();
function doTranslate() {
var inputText = document.getElementById('inputText').value;
if (!inputText) {
alert("Input text cannot be empty.");
exit();
}
// get the language codes

var sourceDropdown = document.getElementById("sourceLanguageCodeDropdown");
var sourceLanguageCode =
sourceDropdown.options[sourceDropdown.selectedIndex].text;
var targetDropdown = document.getElementById("targetLanguageCodeDropdown");

var targetLanguageCode =
targetDropdown.options[targetDropdown.selectedIndex].text;
var params = {
Text: inputText,
SourceLanguageCode: sourceLanguageCode,
TargetLanguageCode: targetLanguageCode
};
translate.translateText(params, function(err, data) {

if (err) {
console.log(err, err.stack);
alert("Error calling Amazon Translate. " + err.message);
return;
}
if (data) {
var outputTextArea = document.getElementById('outputText');
outputTextArea.value = data.TranslatedText;
}
});
17
Code
function doSynthesizeInput() {
var text = document.getElementById('inputText').value.trim();
if (!text) {
return;
}
var sourceLanguageCode =
document.getElementById("sourceLanguageCodeDropdown").value;
doSynthesize(text, sourceLanguageCode);
}
function doSynthesizeOutput() {
var text = document.getElementById('outputText').value.trim();
if (!text) {
return;
}
var targetLanguageCode =
document.getElementById("targetLanguageCodeDropdown").value;
doSynthesize(text, targetLanguageCode);
}
function doSynthesize(text, languageCode) {

var voiceId;
switch (languageCode) {
case "de":
voiceId = "Marlene";
break;
case "en":
voiceId = "Joanna";
break;
case "es":
voiceId = "Penelope";
break;
case "fr":
voiceId = "Celine";
break;
case "pt":
voiceId = "Vitoria";
break;
default:
voiceId = null;
break;
}
if (!voiceId) {
alert("Speech synthesis unsupported for language code: \"" + languageCode +
"\"");
return;
}
var params = {
OutputFormat: "mp3",
SampleRate: "8000",
Text: text,
TextType: "text",
VoiceId: voiceId
};
polly.synthesizeSpeech(params, function(err, data) {
if (err) {
console.log(err, err.stack); // an error occurred
alert("Error calling Amazon Polly. " + err.message);
}
else {
var uInt8Array = new Uint8Array(data.AudioStream);
var arrayBuffer = uInt8Array.buffer;
var blob = new Blob([arrayBuffer]);
var url = URL.createObjectURL(blob);
18
Usar o Amazon Translate para
traduzir um canal de bate-papo
audioElement = new Audio([url]);

audioElement.play();
}
});
}
function clearInputs() {
document.getElementById('inputText').value = "";
document.getElementById('outputText').value = "";
document.getElementById("sourceLanguageCodeDropdown").value = "en";
document.getElementById("targetLanguageCodeDropdown").value = "en";
}
</script>
</body>
</html>
Usar o Amazon Translate para traduzir um canal de

bate-papo
Você pode usar o Amazon Translate para tradução em tempo real de mensagens de bate-papo. Este
exemplo usa um canal do Twitch, mas você pode usá-lo como um ponto de partida para outros textos de
streaming em tempo real, como outras plataformas de bate-papo, interações de atendimento ao cliente,
quadros de mensagens e outros.
Este exemplo usa uma página da web que mostra mensagens em inglês em tempo real e suas traduções
em tempo real lado a lado. Você pode enviar as mensagens para o Amazon Polly fazer a leitura do texto
em voz alta. Para seguir uma pessoa no bate-papo, digite o nome do usuário. O aplicativo fará a leitura em
voz alta de mensagens apenas desse usuário.
O código pode ser resumido da seguinte forma:
• CSS e HTML para criar a página da Web.

• Código de inicialização que cria controladores do Amazon Translate e Amazon Polly.
• Uma função de retorno de chamada que é executada quando uma mensagem de bate-papo é recebida.
• Uma função que envia mensagens de bate-papo.
• Uma função que chama o Amazon Translate para traduzir mensagens.
• Uma função que chama o Amazon Polly para sintetizar fala.
• As funções do utilitário para gerenciar a página da Web.
1. Instale e configure o AWS SDK for JavaScript. Para obter instruções para instalar o SDK for
JavaScript, consulte Instalar o SDK para JavaScript.
2. Copie o código de exemplo para um arquivo HTML em seu servidor da Web.
3. Atualize a tag <script> para o local onde você instalou o SDK for JavaScript.
4. Altere a região e o endpoint para a região onde você deseja executar as operações do Amazon
Translate e do Amazon Polly. Para obter uma lista das regiões com suporte do Amazon Translate,
consulte Diretrizes e limites (p. 50). Para obter uma lista das regiões com suporte do Amazon Polly,
consulte Regiões e endpoints da AWS na Referência geral da Amazon Web Services.
5. Crie um usuário do IAM com as permissões mínimas necessárias para executar esse exemplo.
Para obter informações sobre como criar um usuário do IAM, consulte Criação de um usuário do
19
IAM na sua conta da AWS no Guia do usuário do AWS Identity and Access Management. Para as
permissões necessárias, consulte Uso de políticas baseadas em identidade (políticas do IAM) para
o Amazon Translate (p. 42) e Uso de políticas baseadas em identidade (políticas do IAM) para o
Amazon Polly no Guia do desenvolvedor do Amazon Polly.
6. Forneça o ID de acesso e a chave secreta do usuário do IAM criados na etapa anterior.
7. Insira um nome de usuário do Twitch e um token OAuth para sua conta. Você pode criar uma conta do
Twitch em https://www.twitch.tv. Você pode criar um token OAuth do Twitch em https://twitchapps.com/
tmi.
<!doctype html>
<html lang="en">
<head>
<title>Amazon Translate</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">


<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/
bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/
K68vbdEjh4u" crossorigin="anonymous">


<style>
.topHeader
{
background-color: #6441a4;
padding: 10px;
border-bottom: solid 1px #cacaca;
color: white
}
.panelHeading
{
background-color: #6441a4 !important;
}
.panelBody
{
min-height: 450px; max-height: 450px;overflow-y: scroll;
}
body{
margin-left: 0px;
margin-right: 0px;
height: 100%;
}
</style>
</head>
<body>
<div class="container-fluid">

<div class="row topHeader">
<div class="col-md-12">
<h4>Amazon Translate - Artificial Intelligence on AWS - Powerful machine learning
for all Developers and Data Scientists</h4>
</div>
</div>

<div class="row">
<p class="bg-info">
20
<div id="connecting-div"></div>
</p>
</div>
</div>
<div class="row" style="padding: 10px;">

<div class="form-inline">
<div class="form-group">
<input type="text" id="channel" class="form-control" value=""
placeholder="Channel"/>
</div>
<select id="sourceLanguage" class="form-control">
<option value="de" selected="selected">de</option>
</select>
</div>
<select id="targetLanguage" class="form-control">
<option value="en" selected="selected">en</option>
</select>
</div>
<button type="button" class="form-control" id="btn-go"
onclick="connect()">Go</button>
<button type="button" class="form-control" id="btn-stop"
onclick="location.href='index.html';">Stop</button>
<span id="status"></span>
</div>
</div>
</div>
<div class="form-inline">
<input type="checkbox" id="cbSpeak" value="Speak"> Speak Live Translation
<input type="text" id="follow" class="form-control" value=""
placeholder="follow"/>
</div>
</div>
</div>
</div>

<div class="row">

<div class="panel panel-primary">
<div class="panel-heading panelHeading">Live Chat</div>
<div id="livechatc" class="panel-body panelBody">
<div class="subscribe" id="livechat"></div>
</div>
</div>
</div>

21

<div class="panel panel-primary">
<div class="panel-heading panelHeading">Live Translation</div>
<div id="livetranslationc" class="panel-body panelBody">
<div class="imageDetected" id="livetranslation"></div>
</div>
</div>
</div>

</div>

<div class="row">
<input type="text" id="message" class="form-control"/>
</div>
<div class=" col-md-1">
<button type="button" class="form-control btn btn-default" id="btn-send"
onclick="sendMessage()">Send</button>
</div>
</div>
</div>



<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
crossorigin="anonymous"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"
integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa"
<script src="aws-js-sdk/dist/aws-sdk-all.js"></script>
<script src="http://cdn.tmijs.org/js/1.2.1/tmi.min.js" integrity="sha384-
eE0n7sm1W7DOUI2Xh5I4qSpZTe6hupAO0ovLfqEy0yVJtGRBNfssdmjbJhEYm6Bw"
<script>
cred = {
twitchUsername: "Twitch user name",
twitchOAuthToken: "Twitch OAuth token",
awsAccessKeyId: "access key",
awsSecretAccessKey: "secret key"
};
AWS.config.region = 'region';
ep = new AWS.Endpoint('endpoint');
AWS.config.credentials = new AWS.Credentials(cred.awsAccessKeyId,

cred.awsSecretAccessKey);
window.translator = new AWS.Translate({endpoint: ep, region: AWS.config.region});
/**************************Init and Connect to Chat****************************/

function connect(){
init();
//Twitch Client
var options = {
options: {
debug: false
},
connection: {
cluster: "aws",
reconnect: true
},
identity: {
22
username: cred.twitchUsername,
password: cred.twitchOAuthToken
},
channels: [con.channel]
};
window.client = tmi.client(options);
window.client.connect();
//Attached Handlers
window.client.on("chat", onChat);
window.client.on("connecting", onConnecting);
window.client.on("connected", onConnected);
//Disable UI Elements
document.getElementById("sourceLanguage").disabled = true;
document.getElementById("targetLanguage").disabled = true;
document.getElementById("channel").disabled = true;
document.getElementById("btn-go").disabled = true;
}
function init(){
//Get UI Controls
var lc = document.getElementById("livechat");
var lt = document.getElementById("livetranslation")
var lcc = document.getElementById("livechatc");
var ltc = document.getElementById("livetranslationc")
var cbspeak = document.getElementById("cbSpeak")
var follow = document.getElementById("follow");
var sendMessage = document.getElementById("message");
//Cache values
con = {
channel: document.getElementById("channel").value,
sourceLanguage: document.getElementById("sourceLanguage").value,
targetLanguage: document.getElementById("targetLanguage").value,
liveChatUI: lc,
liveTranslationUI: lt,
liveChatUIContainer: lcc,
liveTranslationUIContainer: ltc,
cbSpeak: cbspeak,
follow: follow,
sendMessage: sendMessage
}
lc.innerHTML = '';
lt.innerHTML = '';
//Speaker
var voiceId = "Joanna";
if(con.targetLanguage == "en")
voiceId = "Joanna";
else if(con.targetLanguage == "de")
voiceId = "Marlene";
else if(con.targetLanguage == "es")
voiceId = "Conchita";
else if(con.targetLanguage == "fr")
voiceId = "Celine";
else if(con.targetLanguage == "pt")
voiceId = "Ines";
else
voiceId = "Joanna";
window.audioPlayer = AudioPlayer(voiceId);
}
/**************************Init and Connect to Chat****************************/
23
/**************************Receive and Translate Chat****************************/

function onChat (channel, userstate, message, self) {
// Don't listen to my own messages..
if (self) return;
//Translate
if (message) {
var username = userstate['username'];
var params = {
Text: message,
SourceLanguageCode: con.sourceLanguage,
TargetLanguageCode: con.targetLanguage
};
window.translator.translateText(params, function onIncomingMessageTranslate(err,

data) {
if (err) {
console.log("Error calling Translate. " + err.message + err.stack);
}
if (data) {
console.log("M: " + message);
console.log("T: " + data.TranslatedText);
//Print original message in chat UI

con.liveChatUI.innerHTML += '<strong>' + username + '</strong>: ' +
message + '<br>';
//Print translation in translation UI

con.liveTranslationUI.innerHTML += '<strong>' + username + '</strong>: '
+ data.TranslatedText + '<br>';
//If speak translation in enabled, speak translated message

if(con.cbSpeak.checked){
if(con.follow.value == "" || username == con.follow.value)
audioPlayer.Speak(username + " says " + data.TranslatedText);
}
//Scroll chat and translated UI to bottom to keep focus on latest

messages
con.liveChatUIContainer.scrollTop = con.liveChatUIContainer.scrollHeight;
con.liveTranslationUIContainer.scrollTop =
con.liveTranslationUIContainer.scrollHeight;
}
});
}
}
/**************************Receive and Translate Chat****************************/
/**************************Client Connecting****************************/
function onConnecting (address, port) {
document.getElementById("status").innerHTML = " [ Connecting...]"
}
function onConnected (address, port) {

document.getElementById("status").innerHTML = " [ Connected ]"
window.audioPlayer.Speak("Connected to channel " + con.channel + ". You should now
be getting live chat messages.");
}
/**************************Client Connecting****************************/
/**************************Send Message****************************/
function sendMessage(){
if(con.sendMessage.value){
message = con.sendMessage.value;
24
var params = {
Text: con.sendMessage.value,
SourceLanguageCode: con.targetLanguage,
TargetLanguageCode: con.sourceLanguage
};
window.translator.translateText(params, function onSendMessageTranslate(err,

data) {
if (err) {
console.log("Error calling Translate. " + err.message + err.stack);
}
if (data) {
console.log("M: " + message);
console.log("T: " + data.TranslatedText);
//Send message to chat

window.client.action(con.channel, data.TranslatedText);
//Clear send message UI

con.sendMessage.value = "";
//Print original message in Translated UI

con.liveTranslationUI.innerHTML += '<strong> ME: </strong>: ' +
message + '<br>';
//Print translated message in Chat UI

con.liveChatUI.innerHTML += '<strong> ME: </strong>: ' +
data.TranslatedText + '<br>';
//Scroll chat and translated UI to bottom to keep focus on latest

messages
con.liveChatUIContainer.scrollTop =
con.liveChatUIContainer.scrollHeight;
con.liveTranslationUIContainer.scrollTop =
con.liveTranslationUIContainer.scrollHeight;
}
});
}
}
/**************************Send Message****************************/
/**************************Audio player****************************/
function AudioPlayer(voiceId) {
var audioPlayer = document.createElement('audio');
audioPlayer.setAttribute("id", "audioPlayer");
document.body.appendChild(audioPlayer);
var isSpeaking = false;
var speaker = {
self: this,
playlist:[],
Speak: function (text) {

//If currently speaking a message, add new message to the playlist
if (isSpeaking) {
this.playlist.push(text);
} else {
speakTextMessage(text).then(speakNextTextMessage)
}
}
}
// Speak text message

function speakTextMessage(text) {
return new Promise(function (resolve, reject) {
25
isSpeaking = true;
getAudioStream(text).then(playAudioStream).then(resolve);
});
}
// Speak next message in the list

function speakNextTextMessage() {
var pl = speaker.playlist;
if (pl.length > 0) {
var txt = pl[0];
pl.splice(0, 1);
speakTextMessage(txt).then(speakNextTextMessage);
}
}
// Get synthesized speech from Amazon polly

function getAudioStream(textMessage) {
var polly = new AWS.Polly();
var params = {
OutputFormat: 'mp3',
Text: textMessage,
VoiceId: voiceId
}
polly.synthesizeSpeech(params, function (err, data) {
if (err)
reject(err);
else
resolve(data.AudioStream);
});
});
}
// Play audio stream

function playAudioStream(audioStream) {
var uInt8Array = new Uint8Array(audioStream);
var arrayBuffer = uInt8Array.buffer;
var blob = new Blob([arrayBuffer]);
var url = URL.createObjectURL(blob);

audioPlayer.src = url;
audioPlayer.addEventListener("ended", function () {
isSpeaking = false;
resolve();
});
audioPlayer.play();
});
}
return speaker;
}
/**************************Audio player****************************/
</script>
</body>
</html>
26
Usar o Amazon Translate com o DynamoDB
Uso do Amazon Translate com o Amazon

DynamoDB
Este exemplo mostra como traduzir uma análise de produto e armazená-la no Amazon DynamoDB.
Se você solicitar a mesma análise posteriormente, o DynamoDB recupera o texto sem que o Amazon
Translate precise traduzi-lo novamente.
Neste exemplo:
• Use o AWS CloudFormation para criar tabelas do DynamoDB para armazenar a tradução e uma função
Lambda que chama a operação TranslateText (p. 53).
• Teste a função usando o console do AWS Lambda.
Para executar o exemplo da
1. Copie o conteúdo do example.py, que você pode encontrar no Função Lambda em

Python (p. 28), para um arquivo chamado example.py. example.py é uma função Lambda
que chama a operação TranslateText (p. 53). Compacte o arquivo em um arquivo zip chamado
example.zip. Armazene-o em um bucket do S3 na mesma região da AWS em que você deseja
executar a função.
2. Crie um novo arquivo denominado template.yaml. Copie o código de modelo do AWS
CloudFormation, que você pode encontrar no Modelo do AWS CloudFormation (p. 29), no arquivo.
O AWS CloudFormation usa o modelo para criar recursos para o aplicativo de exemplo. Altere o
BUCKET_NAME para o nome do bucket do S3 que contém o example.zip. Salve o arquivo em um
diretório local.
3. Faça login no Console de gerenciamento da AWS e abra o console do AWS CloudFormation em
https://console.aws.amazon.com/cloudformation.
4. Selecione Create new stack.
5. Selecione Upload a template to Amazon S3 e, em seguida, selecione Choose file. Selecione o
template.yaml que você criou na etapa 2 e, em seguida, selecione Next.
6. Digite um nome para a pilha e selecione Next.
7. Na página Options, selecione Next.
8. Selecione I acknowledge that AWS CloudFormation might create IAM resources e I acknowledge that
AWS CloudFormation might create IAM resources with custom names. Para obter mais informações,
consulte Controlar acesso com o AWS Identity and Access Management no Guia do usuário do AWS
CloudFormation.
9. Selecione Create Change Set.
10. Após o AWS CloudFormation criar o conjunto de alterações, selecione Execute. Aguarde até que o
AWS CloudFormation crie a pilha.
11. Faça login no Console de gerenciamento da AWS e abra o console AWS Lambda em https://
console.aws.amazon.com/lambda/.
12. Selecione a nova função. O nome começa com TestTranslate-ReviewTranslate.
13. Na página de detalhes da função, selecione Test.
14. Em Event name, digite TestTranslate. Em Configure test event, substitua o JSON pelo seguinte:
{
"review": "hello world",
"target_language": "es",
"source_language": "en",
"review_id": "1"
}
27
Código de exemplo
Escolha Criar.
15. Verifique se TestTranslate está marcada e, em seguida, selecione Test. Quando o teste for concluído,
você receberá a seguinte mensagem:
Código de exemplo
Função Lambda em Python

O conteúdo da função Lambda em Python é exibido a seguir. A função Lambda chama a operação
TranlateText e repassa a análise, o idioma de origem e o de destino para obter a análise traduzida.
Salve esse arquivo como example.py e compacte-o em um arquivo .zip chamado example.zip. Salve
o arquivo em um bucket do S3 na mesma região em que você está executando o exemplo.
import logging
import json
import boto3
import os
translate = boto3.client('translate')
dynamodb = boto3.client('dynamodb')
firehose = boto3.client('firehose')
TABLE_NAME = os.getenv('TABLE_NAME')
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def lambda_handler(event, context):
logger.info(event)
if 'source_language' in event and 'target_language' in event and 'review' in event and

'review_id' in event:
review_id = event['review_id']
source_language = event['source_language']
target_language = event['target_language']
review = event['review']
try:
# The Lambda function queries the Amazon DynamoDB table to check whether
# the review has already been translated. If the translated review
# is already stored in Amazon DynamoDB, the function returns it.
response = dynamodb.get_item(
TableName=TABLE_NAME,
28
Código de exemplo
Key={
'review_id': {
'N': review_id,
},
'language': {
'S': target_language,
},
}
)
logger.info(response)
if 'Item' in response:
return response['Item']['review']['S']
except Exception as e:
logger.error(response)
raise Exception("[ErrorMessage]: " + str(e))
try:
# The Lambda function calls the TranslateText operation and passes the
# review, the source language, and the target language to get the
# translated review.
result = translate.translate_text(Text=review,
SourceLanguageCode=source_language, TargetLanguageCode=target_language)
logging.info("Translation output: " + str(result))
logger.error(response)
try:
# After the review is translated, the function stores it using
# the Amazon DynamoDB putItem operation. Subsequent requests
# for this translated review are returned from Amazon DynamoDB.
response = dynamodb.put_item(
TableName=TABLE_NAME,
Item={
'review_id': {
'N': review_id,
},
'language': {
'S': target_language,
},
'review': {
'S': result.get('TranslatedText')
}
}
)
logger.info(response)
logger.error(e)
return result.get('TranslatedText')
else:
logger.error(e)
raise Exception("[ErrorMessage]: Invalid input ")
Modelo do AWS CloudFormation

O modelo de arquivo a seguir é o que você usa com o AWS CloudFormation para criar e configurar a
função Lambda e as tabelas do DynamoDB. Use este arquivo ao criar a pilha do AWS CloudFormation
para o exemplo. Atualize o BUCKET_NAME para o nome do bucket do S3 que contém o arquivo
example.zip e, em seguida, salve-o em um diretório local como template.yaml.
AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
29
Usar o Amazon Translate para traduzir uma página da Web
Resources: ReviewTranslate:
Type: 'AWS::Serverless::Function'
Properties:
Handler: example.lambda_handler
Runtime: python2.7
CodeUri:
Bucket: BUCKET_NAME
Key: example.zip
Policies:
- AWSLambdaFullAccess
- TranslateReadOnly
Environment:
Variables:
TABLE_NAME: !Ref ReviewTable
Tracing: "Active"
ReviewTable:
Type: 'AWS::DynamoDB::Table'
Properties:
AttributeDefinitions:
- AttributeName: "review_id"
AttributeType: "N"
- AttributeName: "language"
AttributeType: "S"
KeySchema:
- AttributeName: "review_id"
KeyType: "HASH"
- AttributeName: "language"
KeyType: "RANGE"
ProvisionedThroughput:
ReadCapacityUnits: 5
WriteCapacityUnits: 5
Usar o Amazon Translate para traduzir uma página

da Web
Você pode usar o Amazon Translate para traduzir o conteúdo de uma página da Web. O seguinte
programa Java traduz uma página da Web especificada do inglês para o espanhol e cria um arquivo HTML
que contém o resultado da tradução. O programa tem duas funções:
• Uma função que lê os dados da página da Web de origem, os separa em elementos HTML and chama a
segunda função para traduzir o elemento. Ao final do documento, ele grava os resultados em um arquivo
HTML.
• Uma função que chama o serviço do Amazon Translate para traduzir o conteúdo de um elemento HTML.
1. Instale e configure o AWS SDK for Java. Para obter instruções para instalar o SDK para Java,
consulte Configurar o AWS SDK for Java.
2. Instale o analisador de Java HTML jsoup. Para obter instruções, consulte jsoup.
políticas de permissões necessárias, consulte Uso de políticas baseadas em identidade (políticas do
IAM) para o Amazon Translate (p. 42).
30
4. Configure as credenciais necessárias para executar a amostra. Para obter instruções, consulte
Configurar credenciais e a região da AWS para desenvolvimento no Guia do desenvolvedor do AWS
SDK for Java.
5. Crie um novo projeto em seu Java IDE e copie o código-fonte.
6. Altere a região e o endpoint para a região onde você deseja executar a operação do Amazon
Translate. Para obter uma lista das regiões com suporte do Amazon Translate, consulte Diretrizes e
limites (p. 50).
package com.amazonaws.translateweb;
import com.amazonaws.auth.AWSCredentialsProviderChain;
import com.amazonaws.auth.EnvironmentVariableCredentialsProvider;
import com.amazonaws.auth.SystemPropertiesCredentialsProvider;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.services.translate.AmazonTranslate;
import com.amazonaws.AmazonServiceException;
import java.io.IOException;
import java.io.PrintWriter;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
public class TranslateWebPage {
public static void main(String[] args) throws InterruptedException {
// Define the URL of the HTML content to translate

String url = "http://example.com/source.html";
// Create credentials using a provider chain that will evaluate in order;

// a) Any Java system properties
// b) Any environment variables
// c) Any profile file
AWSCredentialsProviderChain DefaultAWSCredentialsProviderChain = new
AWSCredentialsProviderChain(
new SystemPropertiesCredentialsProvider(),
new EnvironmentVariableCredentialsProvider(),
new ProfileCredentialsProvider()
);
// Create an endpoint configuration for the Translate service

AwsClientBuilder.EndpointConfiguration endpointConfiguration = new
AwsClientBuilder.EndpointConfiguration(
"endpoint", "region");
// Create a client for the Translate service

AmazonTranslate translate = AmazonTranslateClient.builder()
.withCredentials(DefaultAWSCredentialsProviderChain)
.withEndpointConfiguration(endpointConfiguration).build();
// Record the beginning of translating the HTML content at the url

System.out.println("Translating URL: " + url);
31
// Create an empty HTML document to store the parsed data

Document doc;
try {
// Retrieve the HTML located at the URL
doc = Jsoup.connect(url).get();
// Select all of the elements in the HTML

Elements eles = doc.select("*");
// For each element

for (Element ele : eles) {
// Translate the element

translateElement(ele, translate);
// If you encounter service throttling when translating large web

// pages, you can request a service limit increase. For details,
// see https://aws.amazon.com/premiumsupport/knowledge-center/manage-service-
limits/,
// or you can throttle your requests by inserting a sleep statement.
// Thread.sleep(1000);
}
// Configure an output file for the translated HTML

String fname = "output HTML file name";
PrintWriter pw = new PrintWriter(fname, "UTF-8");
// Write our translated HTML to the output file

pw.println(doc);
pw.close();
// Record that the file has been saved

System.out.println("Saved file "+fname);
// Catch any exceptions in retrieving the HTML

} catch (IOException e1) {
e1.printStackTrace();
}
}
// This function is used to translate each individual element

public static void translateElement(Element ele, AmazonTranslate translate) {
// Check if the element has any text

if (!ele.ownText().isEmpty()) {
// Retrieve the text of the HTML element

String text = ele.ownText();
// Now translate the element's text

try {
// Translate from English to Spanish

.withText(text)
// Retrieve the result

// Record the original and translated text
32
Uso do Amazon Translate para
traduzir grandes documentos
System.out.println("Original text: " + text + " - Translated text: "+

result.getTranslatedText());
// Update the HTML element with the translated text

ele.text(result.getTranslatedText());
// Catch any translation errors

} catch (AmazonServiceException e) {
System.err.println(e.getErrorMessage());
System.exit(1);
}
} else {
// We have found a non-text HTML element. No action required.
}
}
}
Uso do Amazon Translate para traduzir grandes

documentos
Você pode dividir grandes documentos em partes menores para que o tamanho total do documento se
mantenha abaixo do limite de tamanho de documentos. Para obter mais informações sobre limites de
tamanho de documentos, consulte Limites (p. 50). O programa Java a seguir fragmenta documentos de
textos longos em frases individuais e, em seguida, traduz cada frase do idioma de origem para o idioma de
destino. O programa contém duas seções:
• A classe SentenceSegmenter, que é responsável por fragmentar a string de origem em frases

individuais. O exemplo usa a classe Java BreakIterator.
• A função main que chama a operação Translate para cada frase na string de origem. A função main
também lida com a autenticação com o Amazon Translate.
1. Instale e configure o AWS SDK for Java. Para obter instruções para instalar o SDK para Java,
consulte Configurar o AWS SDK for Java.
políticas de permissões necessárias, consulte Uso de políticas baseadas em identidade (políticas do
IAM) para o Amazon Translate (p. 42).
3. Configure as credenciais necessárias para executar a amostra. Para obter instruções, consulte
Configurar credenciais e a região da AWS para desenvolvimento no Guia do desenvolvedor do AWS
SDK for Java.
4. Crie um novo projeto em seu Java IDE e copie o código-fonte.
5. Altere a região para a região em que você deseja executar a operação do Amazon Translate. Para
obter uma lista das regiões com suporte do Amazon Translate, consulte Diretrizes e limites (p. 50).
6. Altere os idiomas de origem e de destino para os idiomas envolvidos na tradução.
7. Execute o exemplo para ver o texto traduzido na saída padrão.
import com.amazonaws.auth.AWSCredentialsProviderChain;
33
Uso do Amazon Translate para
traduzir grandes documentos
import com.amazonaws.auth.EnvironmentVariableCredentialsProvider;
import com.amazonaws.auth.SystemPropertiesCredentialsProvider;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.translate.AmazonTranslate;
import java.text.BreakIterator;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
public class MultiSentenceTranslator {
public static void main(String[] args) {

// Define the text to be translated here
String region = "region";
String text = "Text to be translated";
String sourceLang = "source language";

String targetLang = "target language";
// Break text into sentences

SentenceSegmenter sentenceSegmenter = new SentenceSegmenter();
List<String> sentences = new ArrayList<>();
try {
sentences = sentenceSegmenter.segment(text, sourceLang);
} catch (Exception e) {
System.out.println(e);
System.exit(1);
}
// Create credentials using a provider chain that will evaluate in order;

// a) Any Java system properties
// b) Any environment variables
// c) Any profile file
AWSCredentialsProviderChain DefaultAWSCredentialsProviderChain = new
AWSCredentialsProviderChain(
new SystemPropertiesCredentialsProvider(),
new EnvironmentVariableCredentialsProvider(),
new ProfileCredentialsProvider()
);
// Create an Amazon Translate client

AmazonTranslate translate = AmazonTranslateClient.builder()
.withCredentials(DefaultAWSCredentialsProviderChain)
.withRegion(region)
.build();
// Translate sentences and print the results to stdout

for (String sentence : sentences) {
.withText(sentence)
.withSourceLanguageCode(sourceLang)
.withTargetLanguageCode(targetLang);
System.out.println("Original text: " + sentence);
System.out.println("Translated text: " + result.getTranslatedText());
}
}
class SentenceSegmenter {
public List<String> segment(final String text, final String lang) throws Exception {
List<String> res = new ArrayList<>();
34
Uso do Signature versão 4 com o Amazon Translate
BreakIterator sentenceIterator = BreakIterator.getSentenceInstance(new

Locale(lang));
sentenceIterator.setText(text);
int prevBoundary = sentenceIterator.first();
int curBoundary = sentenceIterator.next();
while (curBoundary != BreakIterator.DONE) {
String sentence = text.substring(prevBoundary, curBoundary);
res.add(sentence);
prevBoundary = curBoundary;
curBoundary = sentenceIterator.next();
}
return res;
}
Uso do Signature versão 4 com o Amazon

Translate
Este programa Python de exemplo mostra como usar o Signature versão 4 para adicionar informações
de autenticação às solicitações do Amazon Translate. O exemplo faz uma solicitação POST, cria
uma estrutura JSON que contém o texto a ser traduzido no corpo (carga) da solicitação e repassa as
informações de autenticação em um cabeçalho de autorização. Para obter mais informações sobre como
usar o Signature versão 4, consulte o Processo de assinatura do Signature versão 4 na Referência geral
da Amazon Web Services.
Configuração
Para executar o exemplo, siga as seguintes etapas:
1. Instale a AWS Command Line Interface (AWS CLI). O AWS SDK for Python (Boto) é incluído ao
instalar a AWS CLI. Para obter instruções, consulte Etapa 2: configurar a AWS Command Line
Interface (AWS CLI) (p. 5).
2. Crie um usuário do AWS Identity and Access Management (IAM) com a política de permissões
mínimas necessárias para executar esse exemplo. Para obter informações sobre como criar um
usuário do IAM, consulte Criar um usuário do IAM na sua conta da AWS no Guia do usuário do AWS
Identity and Access Management. Para ver as políticas de permissões necessárias, consulte Uso de
políticas baseadas em identidade (políticas do IAM) para o Amazon Translate (p. 42). Registre o ID
de chave de acesso e a chave de acesso secreta.
3. Coloque o ID de chave de acesso e a chave de acesso secreta em variáveis de ambiente chamadas
AWS_ACCESS_KEY and AWS_SECRET_ACCESS_KEY, respectivamente. Como prática recomendada,
recomendamos que você não incorpore credenciais no código.
4. Crie um novo arquivo no seu computador, copie o código para o exemplo (o qual você pode encontrar
na próxima seção), cole-o no arquivo e salve o arquivo com a extensão .py.
5. No código, substitua region pelo nome da região da AWS na qual você deseja executar a operação
do Amazon Translate TranslateText. Para obter uma lista das regiões compatíveis, consulte
Regiões e endpoints da AWS na Referência geral da Amazon Web Services.
Code
Veja a seguir o código completo do programa Python de exemplo.
35
Code
Após criar os valores de solicitação, como o URL do endpoint e o corpo da solicitação, o código faz o
seguinte:
1. Crie uma solicitação canônica para a operação do Amazon Translate TranslateText.

2. Crie a string que em que você adiciona um hash para criar a assinatura.
3. Calcule a assinatura.
4. Adicione a assinatura ao cabeçalho da solicitação.
5. Envie a solicitação à operação TranslateText.
Para executar o exemplo no seu computador, copie o código em um arquivo Python.
# AWS Version 4 signing example
# Translate API (TranslateText)
# For more information about using Signature Version 4, see http://docs.aws.amazon.com/

general/latest/gr/sigv4_signing.html.
# This example makes a POST request to Amazon Translate and
# passes the text to translate JSON in the body (payload)
# of the request. Authentication information is passed in an
# Authorization header.
import sys, os, base64, datetime, hashlib, hmac
import requests # pip install requests
# ************* REQUEST VALUES *************

method = 'POST'
service = 'translate'
region = 'region'
host = service + '.' + region + '.amazonaws.com'
endpoint = 'https://' + host + '/'
# POST requests use a content type header. For Amazon Translate,

# the content is JSON.
content_type = 'application/x-amz-json-1.1'
# Amazon Translate requires an x-amz-target header that has this format:
# AWSShineFrontendService_20170701.<operationName>.
amz_target = 'AWSShineFrontendService_20170701.TranslateText'
# Pass request parameters for the TranslateText operation in a JSON block.

request_parameters = '{'
request_parameters += '"Text": "Hello world.",'
request_parameters += '"SourceLanguageCode": "en",'
request_parameters += '"TargetLanguageCode": "de"'
request_parameters += '}'
# The following functions derive keys for the request. For more information, see
# http://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-
examples-python.
def sign(key, msg):
return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()
def getSignatureKey(key, date_stamp, regionName, serviceName):

kDate = sign(('AWS4' + key).encode('utf-8'), date_stamp)
kRegion = sign(kDate, regionName)
kService = sign(kRegion, serviceName)
kSigning = sign(kService, 'aws4_request')
return kSigning
# Python can read the AWS access key from environment variables or the configuration file.
# In this example, keys are stored in environment variables. As a best practice, do not
# embed credentials in code.
access_key = os.environ.get('AWS_ACCESS_KEY_ID')
36
Code
secret_key = os.environ.get('AWS_SECRET_ACCESS_KEY')
if access_key is None or secret_key is None:
print 'No access key is available.'
sys.exit()
# Create a timestamp for headers and the credential string.

t = datetime.datetime.utcnow()
amz_date = t.strftime('%Y%m%dT%H%M%SZ')
date_stamp = t.strftime('%Y%m%d') # The date without time is used in the credential scope.
# ************* TASK 1: CREATE A CANONICAL REQUEST *************

# For information about creating a canonical request, see http://docs.aws.amazon.com/
general/latest/gr/sigv4-create-canonical-request.html.
# Step 1: Define the verb (GET, POST, etc.), which you have already done.
# Step 2: Create a canonical URI. A canonical URI is the part of the URI from domain to
query.
# string (use '/' if no path)
canonical_uri = '/'
## Step 3: Create the canonical query string. In this example, request

# parameters are passed in the body of the request and the query string
# is blank.
canonical_querystring = ''
# Step 4: Create the canonical headers. Header names must be trimmed,

# lowercase, and sorted in code point order from low to high.
# Note the trailing \n.
canonical_headers = 'content-type:' + content_type + '\n' + 'host:' + host + '\n' + 'x-amz-
date:' + amz_date + '\n' + 'x-amz-target:' + amz_target + '\n'
# Step 5: Create the list of signed headers by listing the headers

# in the canonical_headers list, delimited with ";" and in alphabetical order.
# Note: The request can include any headers. Canonical_headers and
# signed_headers should contain headers to include in the hash of the
# request. "Host" and "x-amz-date" headers are always required.
# For Amazon Translate, content-type and x-amz-target are also required.
signed_headers = 'content-type;host;x-amz-date;x-amz-target'
# Step 6: Create the payload hash. In this example, the request_parameters

# variable contains the JSON request parameters.
payload_hash = hashlib.sha256(request_parameters).hexdigest()
# Step 7: Combine the elements to create a canonical request.

canonical_request = method + '\n' + canonical_uri + '\n' + canonical_querystring + '\n' +
canonical_headers + '\n' + signed_headers + '\n' + payload_hash
# ************* TASK 2: CREATE THE STRING TO SIGN*************

# Set the algorithm variable to match the hashing algorithm that you use, either SHA-256
(recommended) or SHA-1.
#
algorithm = 'AWS4-HMAC-SHA256'
credential_scope = date_stamp + '/' + region + '/' + service + '/' + 'aws4_request'
string_to_sign = algorithm + '\n' + amz_date + '\n' + credential_scope + '\n' +
hashlib.sha256(canonical_request).hexdigest()
# ************* TASK 3: CALCULATE THE SIGNATURE *************

# Create the signing key using the getSignaturKey function defined above.
signing_key = getSignatureKey(secret_key, date_stamp, region, service)
# Sign the string_to_sign using the signing_key.
37
Code
signature = hmac.new(signing_key, (string_to_sign).encode('utf-8'),

hashlib.sha256).hexdigest()
# ************* TASK 4: ADD SIGNING INFORMATION TO THE REQUEST *************

# Put the signature information in a header named Authorization.
authorization_header = algorithm + ' ' + 'Credential=' + access_key + '/' +
credential_scope + ', ' + 'SignedHeaders=' + signed_headers + ', ' + 'Signature=' +
signature
# For Amazon Translate, the request can include any headers, but it must include "host,"
"x-amz-date,"
# "x-amz-target," "content-type," and "Authorization" headers. Except for the authorization
# header, the headers must be included in the canonical_headers and signed_headers values,
as
# noted earlier. Header order is not significant.
# Note: The Python 'requests' library automatically adds the 'host' header.
headers = {'Content-Type':content_type,
'X-Amz-Date':amz_date,
'X-Amz-Target':amz_target,
'Authorization':authorization_header}
# ************* TASK 5: SEND THE REQUEST *************

print 'Request:\n\t' + request_parameters
response = requests.post(endpoint, data=request_parameters, headers=headers)

print 'Response:\n\t' + response.text
38
Autenticação
Autenticação e controle de acesso

para o Amazon Translate
O acesso ao Amazon Translate exige credenciais que a AWS possa usar para autenticar suas solicitações.
Essas credenciais devem ter permissões para acessar ações do Amazon Translate. As seções a seguir
fornecem detalhes sobre como usar o AWS Identity and Access Management (IAM) e o Amazon Translate
para ajudar a proteger seus recursos, controlando quem pode acessá-los.
• Autenticação (p. 39)

• Controle de acesso (p. 40)
Autenticação
Você 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ço
de e-mail e a senha que você usou para criar a conta. Recomendamos que não use o usuário raiz para
suas tarefas diárias, nem mesmo as administrativas. Em vez disso, siga as melhores práticas de usar
o usuário raiz apenas para criar seu primeiro usuário do IAM. Depois, armazene as credenciais usuário
raiz com segurança e use-as para executar apenas algumas tarefas de gerenciamento de contas e de
serviços.
• Usuário IAM – um usuário IAM é uma identidade na sua conta da AWS que tem permissões
personalizadas específicas (por exemplo, para criar a custom glossary no Amazon Translate). Você
pode usar um nome e uma senha de usuário IAM para fazer login em páginas Web seguras da AWS,
como Console de gerenciamento 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 cada
usuário. Você pode usar essas chaves ao acessar serviços da AWS de forma programática, seja com
um dos vários SDKs ou usando a AWS Command Line Interface (CLI). As ferramentas de SDK e de
CLI usam as chaves de acesso para o cadastramento criptográfico da sua solicitação. Se você não
utilizar ferramentas da AWS, cadastre a solicitação você mesmo. Amazon Translate supports Assinatura
versão 4, um protocolo para autenticar solicitações de API de entrada. Para mais informações sobre
autenticação de solicitações, consulte Processo de cadastramento de Assinatura versão 4 no AWS
General 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 pessoa
específica. Uma função do IAM permite obter chaves de acesso temporárias que podem ser usadas para
acessar os serviços e recursos da AWS. As funções do IAM com credenciais temporária são úteis nas
seguintes 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 identidades
39
Controle de acesso
da web. Estes são conhecidos como usuários federados. A AWS atribui uma função a um usuário
federado quando o acesso é solicitado por meio de um provedor de identidades. Para obter mais
informações sobre usuários federados, consulte Usuários federados e funções em Guia do usuário do
IAM.

• 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ê pode
criar uma função que permita que Amazon Redshift acesse um bucket do Amazon S3 em seu nome
e carregue dados desse bucket em um cluster Amazon Redshift. Para mais informações, consulte
Criaçã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 e
que fazem solicitações de API da AWS. É preferível fazer isso do que armazenar chaves de acesso
na instância do EC2. Para atribuir uma função da AWS a uma instância do EC2 e disponibilizá-la
para todos os seus aplicativos, crie um perfil de instância que esteja anexado à instância. Um perfil
de instância contém a função e permite que programas que estão em execução na instância do EC2
obtenham credenciais temporárias. Para mais informações, consulte Uso de uma função do IAM para
conceder permissões aos aplicativos em execução nas instâncias do Amazon EC2 no Guia do usuário
do IAM.
Controle de acesso
Você pode ter credenciais válidas para autenticar suas solicitações. Por exemplo, você deve ter
permissões para chamar uma ação do Amazon Translate.
As seções a seguir descrevem como gerenciar permissões para o Amazon Translate. Recomendamos que
você leia a visão geral primeiro.
• Visão geral do gerenciamento de permissões de acesso aos seus recursos do Amazon

Translate (p. 40)
• Uso de políticas baseadas em identidade (políticas do IAM) para o Amazon Translate (p. 42)
Visão geral do gerenciamento de permissões de

acesso aos seus recursos do Amazon Translate
As permissões para acessar uma ação são controladas por políticas de permissões. Um administrador
de conta pode anexar políticas de permissões a identidades do IAM (usuários, grupos e funções) para
gerenciar o acesso a ações.
Note
Um administrador da conta (ou usuário administrador) é um usuário com privilégios de

administrador. Para obter mais informações, consulte as Melhores práticas do IAM no Guia do
usuário do IAM.
Ao conceder permissões, você decide quem receberá as permissões e as ações para as quais eles obtêm
permissões.
Tópicos
• Gerenciar o acesso a ações (p. 41)
40
Gerenciar o acesso a ações
• Como especificar elementos da política: recursos, ações, efeitos e entidades de segurança (p. 42)
• Especificação de condições em uma política (p. 42)
Gerenciar o acesso a ações

A política de permissões descreve quem tem acesso a quê. A seção a seguir explica as opçõ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 Translate. Não são fornecidas
informações detalhadas sobre o serviço IAM. Para obter a documentação completa do IAM,
consulte O que é IAM? no Guia do usuário do IAM. Para obter mais informações sobre a sintaxe
e as descrições da política do IAM, consulte Referência de política do IAM da AWS no Guia do
usuá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). As políticas anexadas a um recurso são conhecidas como políticas baseadas em
recurso. O Amazon Translate oferece suporte apenas a políticas baseadas em identidade.
Políticas com base em identidade (políticas do IAM)

Você pode anexar políticas a identidades do IAM. 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ário
ou grupo de usuários permissões para chamar uma ação do Amazon Translate, você pode anexar uma
política de permissões a um usuário ou grupo ao qual o usuário pertença.
• Anexar uma política de permissões a uma função (conceder permissões entre contas) – para conceder
permissões entre contas, você pode anexar uma política de permissões baseada em identidade a
uma função do IAM. Por exemplo, o administrador na Conta A pode criar uma função para conceder
permissões entre contas a outra conta da AWS (por exemplo, Conta B) ou um serviço da AWS da
seguinte forma:
1. Um administrador da Conta A cria uma função do IAM e associa uma política de permissões à função
que concede permissões em recursos da Conta A.
2. Um administrador da Conta A anexa uma política de confiança à função identificando a Conta B como
a principal, que pode assumir a função.
3. O administrador da Conta B poderá então delegar permissões para assumir a função para todos os
usuários na Conta B. Isso permitirá que os usuários da Conta B criem ou acessem recursos da Conta
A. Se você quiser conceder a um serviço da AWS permissões para assumir a função, o principal na
política de confiança também poderá ser o principal do serviço da AWS.
Para obter mais informações sobre o uso do IAM para delegar permissões, consulte Gerenciamento do
acesso no Guia do usuário do IAM.
Para obter mais informações sobre como usar políticas baseadas em identidade com o Amazon Translate,
consulte Uso de políticas baseadas em identidade (políticas do IAM) para o Amazon Translate (p. 42).
Para obter mais informações sobre usuários, grupos, funções e permissões, consulte Identidades
(usuários, grupos e funções) no Guia do usuário do IAM.
Políticas com base em recurso

Outros serviços, como o Lambda, oferecem suporte às políticas de permissões baseadas em recursos. Por
exemplo: você pode anexar uma política a um bucket do S3 para gerenciar permissões de acesso a esse
bucket. O Amazon Translate não é compatível com as políticas baseadas em recursos.
41
Como especificar elementos da política: recursos,
ações, efeitos e entidades de segurança
Como especificar elementos da política: recursos,

ações, efeitos e entidades de segurança
O Amazon Translate define um conjunto de operações da API (consulte Actions (p. 52)). Para conceder
permissões para essas operações da API, o Amazon Translate define um conjunto de ações que você
pode especificar em uma política.
Estes são os elementos de política mais básicos:
• Recurso – Em uma política, um Nome de recurso da Amazon (ARN) é usado para identificar o recurso
ao qual a política se aplica. Para o Amazon Translate, o recurso é sempre *.
• Ação – Você usa palavras-chave de ações para identificar operações que deseja permitir ou negar. Por
exemplo, dependendo do Effect especificado, o translate:TranslateText permite ou nega as
permissões de usuário para realizar a operação TranslateText do Amazon Translate.
• Efeito – você especifica o efeito da ação que ocorre quando o usuário solicita a ação específica — que
pode ser permitir ou negar. Se você não conceder (permitir) explicitamente acesso a um recurso, o
acesso estará implicitamente negado. Você também pode negar acesso explicitamente a um recurso.
Você poderia fazer isso para garantir que um usuário não possa acessar o recurso, mesmo se uma
política diferente conceder o acesso.
• Principal – Em políticas com base em identidade (políticas do IAM), o usuário ao qual a política está
anexada é automática e implicitamente o principal.
Para saber mais sobre a sintaxe da política do IAM e as descrições, consulte Referência de política do IAM
da AWS no Guia do usuário do IAM.
Para obter uma tabela que mostra todas as ações de API do Amazon Translate, consulte Permissões da
API do Amazon Translate: referência de ações, recursos e condições (p. 43).
Especificação de condições em uma política

Ao conceder permissões, você usa a linguagem da política do IAM para especificar as condições sob as
quais uma política deverá entrar em vigor. Por exemplo, convém que uma política só seja aplicada após
uma data específica. Para obter mais informações sobre como especificar condições em uma linguagem
de política, consulte Condição no Guia do usuário do IAM.
A AWS fornece um conjunto de chaves de condição predefinidas para todos os serviços da AWS que
oferecem suporte ao IAM para controle de acesso. Por exemplo, você pode usar a chave de condição
aws:userid para exigir um ID da AWS específico ao solicitar uma ação. Para obter mais informações e
uma lista completa das chaves em toda a AWS, consulte Chaves disponíveis para condições no Guia do
usuário do IAM.
Note
As chaves de condição diferenciam maiúsculas de minúsculas.
O Amazon Translate não fornece quaisquer chaves de condição adicionais.
Uso de políticas baseadas em identidade (políticas

do IAM) para o Amazon Translate
Este tópico fornece um exemplo de política baseada em identidade que demonstram como um
administrador de conta pode anexar políticas de permissões às identidades do IAM (usuários, grupos e
funções) e, assim, conceder permissões para executar ações do Amazon Translate.
42
Referência de permissões da API do Amazon Translate
Important
Antes de continuar, recomendamos que você confira Visão geral do gerenciamento de

permissões de acesso aos seus recursos do Amazon Translate (p. 40).
A política de permissões a seguir é necessária para usar o Amazon Translate e o console do Amazon
Translate:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"translate:TranslateText",
"comprehend:DetectDominantLanguage"
],
"Resource": "*"
}
]
}
A política tem duas instruções. A primeira concede permissões para usar a ação TranslateText. A
segunda concede permissões à operação do Amazon Comprehend DetectDominantLanguage para
habilitar a detecção automática de idioma.
A política não especifica o elemento Principal, pois você não especifica o principal que obtém as
permissões em uma política baseada em identidade. Quando você anexar uma política a um usuário, o
usuário será o principal implícito. Quando uma política de permissões é anexada a uma função do IAM, o
principal identificado na política de confiança da função obtém as permissões.
Para ver uma tabela com todas as ações da API do Amazon Translate e os recursos aos quais elas
se aplicam, consulte Permissões da API do Amazon Translate: referência de ações, recursos e
condições (p. 43).
Permissões da API do Amazon Translate:

referência de ações, recursos e condições
Use a tabela a seguir como referência ao configurar Controle de acesso (p. 40) e escrever uma política
de permissões que você possa anexar a uma identidade do IAM (uma política baseada em identidade).
A lista inclui cada operação da API do Amazon Translate, a ação correspondente à qual você pode
conceder permissões para realizar a ação e o recurso da AWS ao qual pode conceder as permissões.
Você especifica as ações no campo Action da política e o valor do recurso no campo Resource da
política.
Para expressar as condições, use as chaves de condição em toda a AWS nas suas políticas de Amazon
Translate. Para obter uma lista completa de chaves em toda a AWS, consulte Chaves disponíveis no Guia
do usuário do IAM.
Note
Para especificar uma ação, use o prefixo translate: seguido do nome da operação da API, por
exemplo, translate:TranslateText.
43
Monitorar o Amazon Translate

Monitoramento é uma parte importante da manutenção da confiabilidade, da disponibilidade e do
desempenho do Amazon Translate e das suas soluções. A AWS fornece várias ferramentas que você
pode usar para monitorar o Amazon Translate. Você pode configurar algumas dessas ferramentas
para monitorar suas soluções para você. Recomendamos que as tarefas de monitoramento sejam
automatizadas ao máximo possível.
O Amazon Translate fornece gráficos pré-configurados que mostram as métricas mais importantes para
a sua solução. Cada gráfico oferece uma janela para o desempenho da sua solução. Você pode alterar o
período exibido pelos gráficos para obter visualizações diferentes de como sua solução está funcionando
ao longo do tempo.
Você também pode usar o Amazon CloudWatch para monitorar o Amazon Translate. Com o CloudWatch,
você pode automatizar o monitoramento de métricas específicas para as suas soluções. Você recebe
um aviso sempre que uma métrica está fora dos limites definidos. Você também pode usar a API do
CloudWatch para criar um aplicativo de monitoramento personalizado adequado às suas necessidades.
Para obter mais informações, consulte O que é o Amazon CloudWatch no Guia do usuário do Amazon
CloudWatch.
A tabela a seguir descreve cada um dos gráficos pré-configurados fornecidos pelo Amazon Translate.
Gráfico Descrição
Contagem de solicitações bem-sucedidas
A quantidade de solicitações bem-sucedidas para

Amazon Translate durante o período especificado.
Contagem de solicitações limitadas
A quantidade de solicitações para Amazon

Translate que foram limitadas durante o período
especificado. Utilize essas informações para
determinar se seu aplicativo está enviando uma
solicitação para o Amazon Translate de maneira
muito rápida.
44
Gráfico Descrição
Tempo médio de resposta
O tempo médio que levou para o Amazon

Translate processar sua solicitação no período
especificado.
Contagem de caracteres
A quantidade total de caracteres que você enviou

para o Amazon Translate durante o período em
questão. Essa é a quantidade de caracteres pela
qual você será cobrado.
Contagem de erros do usuário
O número de erros do usuário no período

especificado. Erros do usuário estão no intervalo
400 a 499 de código de erros HTTP.
Contagem de erros do sistema
O número de erros do sistema no período

especificado. Erros do sistema estão no intervalo
500 a 599 de código de erros HTTP.
45
Monitoramento com o CloudWatch
Monitorar o Amazon Translate

Com o CloudWatch, você pode obter métricas para operações individuais do Amazon Translate ou
métricas globais do Amazon Translate para sua conta. Use métricas para rastrear a integridade da sua
solução baseada em Amazon Translate e configurar alarmes para notificação quando uma ou mais
métricas estiverem fora de um limite definido. Por exemplo, você pode monitorar o número de solicitações
feitas para o Amazon Translate em um determinado período, além de ver a latência das solicitações ou
disparar um alarme quando os erros excederem um limite. Para ver métricas, você pode usar o console do
Amazon Translate, Amazon CloudWatch e AWS Command Line Interface ou a API do CloudWatch.
Compreender métricas do CloudWatch para o Amazon

Translate
Para obter métricas para as operações do Amazon Translate, você precisa especificar as seguintes
informações:
• A dimensão da métrica. Uma dimensão é um conjunto de pares de nome-valor que você usa para
identificar uma métrica. O Amazon Translate tem duas dimensões:
• Operation
• Language pair
• O nome da métrica, como SuccessfulRequestCount ou RequestCharacters. Para obter uma lista
completa de métricas, consulte CloudWatch Metrics for Amazon Translate (p. 47).
Você pode obter as métricas para o Amazon Translate usando o Console de gerenciamento da AWS,
a AWS CLI ou a API do CloudWatch. Você também pode usar a API do CloudWatch por meio de um
dos Kits de desenvolvimento de software (SDKs) da AWS da Amazon ou das ferramentas de API do
CloudWatch.
A tabela a seguir lista alguns usos comuns para as métricas do CloudWatch. Essas são sugestões para
você começar, e não uma lista abrangente.
Como eu faço para... Métrica relevante
Acompanhar o número de solicitações bem- Monitore a estatística sum da métrica

sucedidas SuccessfulRequestCount.
Verificar se meu aplicativo atingiu a taxa de Monitore a estatística sum da métrica

transferência máxima ThrottledCount.
Verificar o tempo de resposta do meu aplicativo Monitore a estatística average da métrica

ResponseTime.
Encontrar a quantidade de erros do meu aplicativo Monitore a estatística sum das métricas
ServerErrorCount e UserErrorCount.
Encontrar a quantidade de caracteres faturáveis Monitore a estatística sum da métrica

CharacterCount.
Você deve ter as permissões apropriadas do CloudWatch para monitorar o Amazon Translate com o
CloudWatch. Para obter mais informações, consulte Autenticação e controle de acesso para o Amazon
CloudWatch no Guia do usuário do Amazon CloudWatch.
46
Como visualizar métricas do Amazon Translate
Como visualizar métricas do Amazon Translate

Visualizar métricas do Amazon Translate no console do CloudWatch
Para visualizar as métricas (console do CloudWatch)
1. Faça login no Console de gerenciamento da AWS e abra o console da CloudWatch em https://

console.aws.amazon.com/cloudwatch/.
2. Escolha Metrics, All Metrics e, em seguida, selecione AWS/Translate.
3. Escolha a dimensão, informe um nome de métrica e selecione Add to graph.
4. Escolha um valor para o intervalo de datas. A contagem da métrica para o intervalo de datas
específico é exibida no gráfico.
Criar um alarme
O alarme do CloudWatch observa uma única métrica durante um período de tempo especificado e envia
uma notificação para um tópico do Amazon SNS ou uma política da Auto Scaling. A ação ou ações são
baseadas no valor da métrica relativa a um limite determinado durante um número de períodos de tempo
que você especificar. O CloudWatch também pode enviar a você uma mensagem do Amazon Simple
Notification Service (Amazon SNS) quando o estado do alarme é alterado.
Os alarmes do CloudWatch invocam ações somente quando o estado muda e persiste pelo período que
você especificar.
Para definir um alarme
1. Faça login no Console de gerenciamento da AWS e abra o console da CloudWatch em https://

console.aws.amazon.com/cloudwatch/.
2. Escolha Alarms e depois Create Alarm.
3. Escolha AWS/Translate Metrics e, em seguida, escolha uma métrica.
4. Para Time Range, escolha um intervalo de tempo para monitorar e, em seguida, selecione Next.
5. Digite um Name e Description.
6. Para Whenever, escolha >= e digite um valor máximo.
7. Se você quiser que o CloudWatch envie um e-mail quando o estado do alarme for atingido, na seção
Actions, para Whenever this alarm, escolha State is ALARM. Para Send notification to, escolha uma
lista de correspondência ou New list e crie uma nova lista.
8. Visualize o alarme na seção Alarm Preview. Se você estiver satisfeito com o alarme, selecione Create
Alarm.
Métricas e dimensões do CloudWatch para o

Amazon Translate
Use métricas e dimensões do Amazon CloudWatch que estão disponíveis para o Amazon Translate
monitorar o desempenho da sua solução.
CloudWatch Metrics for Amazon Translate

Metric Description
CharacterCount The number of billable characters in requests.
47
CloudWatch Dimensions for Amazon Translate
Metric Description
Valid dimensions: Language pair, Operation
Valid statistics: Average, Maximum, Minimum, Sum
Unit: Count
ResponseTime The time that it took to respond to a request.
Valid dimensions: Language pair, Operation
Valid statistics: Data samples, Average
Unit: For Data samples, count. For Average statistics, milliseconds.
ServerErrorCount The number of server errors. The HTTP response code range for a server
error is 500 to 599.
Valid dimension: Operation
Valid statistics: Average, Sum
Unit: Count
SuccessfulRequestCount The number of successful translation requests. The response code for a
successful request is 200 to 299.
Unit: Count
ThrottledCount The number of requests subject to throttling. Use ThrottledCount to

determine if your application is sending requests to Amazon Translate
faster than your account is configured to accept them. For more
information, see Amazon Translate Limits in the Referência geral do
Amazon Web Services.
Unit: Count
UserErrorCount The number of user errors that occurred. The HTTP response code range
for a user error is 400 to 499.
Unit: Count

Use the following dimensions to filter Amazon Translate metrics. Metrics are grouped by the source
language and the target language.
48
Dimension Description
LanguagePair Restricts the metrics to only those that contain the specified languages.
Operation Restricts the metrics to only those with the specified operation.
49
Regiões compatíveis
Diretrizes e limites
Regiões compatíveis
Para obter uma lista de regiões da AWS onde o Amazon Translate está disponível, consulte Regiões e
endpoints da AWS na Referência geral da Amazon Web Services.
Limitação
Para obter informações sobre limitação do Amazon Translate e para solicitar um aumento de limite,
consulte Limites de tradução da Amazon no Referência geral do Amazon Web Services.
Diretrizes
O Amazon Translate pode armazenar seu conteúdo para melhorar continuamente a qualidade dos
modelos de análise. Consulte as Perguntas frequentes do Amazon Translate para saber mais. Para
solicitar a exclusão do conteúdo que pode ter sido armazenado pelo Amazon Translate, abra um caso com
o AWS Support.
Limites
O Amazon Translate tem as seguintes limitações:
• O tamanho máximo de documentos é 5,000 bytes de caracteres UTF-8 por solicitação.
50
Histórico do documento para o

Amazon Translate
A tabela a seguir descreve a documentação desta versão do Amazon Translate.
• Última atualização de documentação: 4 de abril de 2018
Alteração Descrição Data
Novo recurso O Amazon Translate adiciona 4 de abril de 2018

suporte para detecção
automática do idioma de origem.
Para obter mais informações,
consulte Como o Amazon
Translate funciona (p. 2).
Novo guia Este é o primeiro lançamento 29 de novembro de 2017

do Guia do desenvolvedor do
Amazon Translate.
51
Actions
API Reference
Esta seção contém a documentação de referência da API.
Actions
The following actions are supported:
• TranslateText (p. 53)
52
TranslateText
TranslateText
Translates input text from the source language to the target language. You can translate between English
(en) and one of the following languages, or between one of the following languages and English.
• Arabic (ar)
• Chinese (Simplified) (zh)
• Chinese (Traditional) (zh-TW)
• Czech (cs)
• French (fr)
• German (de)
• Italian (it)
• Japanese (ja)
• Portuguese (pt)
• Russian (ru)
• Spanish (es)
• Turkish (tr)
To have Amazon Translate determine the source language of your text, you can specify auto in the
SourceLanguageCode field. If you specify auto, Amazon Translate will call Amazon Comprehend to
determine the source language.
Request Syntax
{
"SourceLanguageCode": "string",
"TargetLanguageCode": "string",
"Text": "string"
}
Request Parameters
For information about the parameters that are common to all actions, see Common Parameters (p. 57).
The request accepts the following data in JSON format.
SourceLanguageCode (p. 53)
One of the supported language codes for the source text. If the TargetLanguageCode is not "en", the
SourceLanguageCode must be "en".
To have Amazon Translate determine the source language of your text, you can specify auto in the
SourceLanguageCode field. If you specify auto, Amazon Translate will call Amazon Comprehend to
determine the source language.
Type: String
Length Constraints: Minimum length of 2. Maximum length of 5.
Required: Yes
TargetLanguageCode (p. 53)
One of the supported language codes for the target text. If the SourceLanguageCode is not "en", the
TargetLanguageCode must be "en".
53
TranslateText
Type: String
Required: Yes
Text (p. 53)
The text to translate. The text string can be a maximum of 5,000 bytes long. Depending on your
character set, this may be fewer than 5,000 characters.
Type: String
Required: Yes
Response Syntax
{
"SourceLanguageCode": "string",
"TargetLanguageCode": "string",
"TranslatedText": "string"
}
Response Elements
If the action is successful, the service sends back an HTTP 200 response.
The following data is returned in JSON format by the service.
SourceLanguageCode (p. 54)
The language code for the language of the input text.
Type: String

TargetLanguageCode (p. 54)
The language code for the language of the translated text.
Type: String

TranslatedText (p. 54)
The text translated into the target language.
Type: String
Length Constraints: Minimum length of 1.
Errors
For information about the errors that are common to all actions, see Common Errors (p. 56).
54
TranslateText
DetectedLanguageLowConfidenceException
The confidence that Amazon Comprehend accurately detected the source language is low. If a low
confidence level is acceptable for your application, you can use the language in the exception to call
Amazon Translate again. For more information, see the DetectDominantLanguage operation in the
Amazon Comprehend Developer Guide.
HTTP Status Code: 400

InternalServerException
An internal server error occurred. Retry your request.

InvalidRequestException
The request is invalid.

ServiceUnavailableException
Amazon Translate is unavailable. Retry your request later.

TextSizeLimitExceededException
The size of the input text exceeds the length constraint for the Text field. Try again with a shorter text.

TooManyRequestsException
The number of requests exceeds the limit. Resubmit your request later.

UnsupportedLanguagePairException
Amazon Translate cannot translate input text in the source language into this target language. For
more information, see Processamento de exceções (p. 3).
See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:
• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V2
55
Data Types
Data Types
There are no separate data types in this API.
Common Errors
This section lists the errors common to the API actions of all AWS services. For errors specific to an API
action for this service, see the topic for that API action.
AccessDeniedException
You do not have sufficient access to perform this action.

IncompleteSignature
The request signature does not conform to AWS standards.

InternalFailure
The request processing has failed because of an unknown error, exception or failure.

InvalidAction
The action or operation requested is invalid. Verify that the action is typed correctly.

InvalidClientTokenId
The X.509 certificate or AWS access key ID provided does not exist in our records.

InvalidParameterCombination
Parameters that must not be used together were used together.

InvalidParameterValue
An invalid or out-of-range value was supplied for the input parameter.

InvalidQueryParameter
The AWS query string is malformed or does not adhere to AWS standards.

MalformedQueryString
The query string contains a syntax error.
56
Common Parameters
MissingAction
The request is missing an action or a required parameter.

MissingAuthenticationToken
The request must contain either a valid (registered) AWS access key ID or X.509 certificate.

MissingParameter
A required parameter for the specified action is not supplied.

OptInRequired
The AWS access key ID needs a subscription for the service.

RequestExpired
The request reached the service more than 15 minutes after the date stamp on the request or more
than 15 minutes after the request expiration date (such as for pre-signed URLs), or the date stamp on
the request is more than 15 minutes in the future.

ServiceUnavailable
The request has failed due to a temporary failure of the server.

ThrottlingException
The request was denied due to request throttling.

ValidationError
The input fails to satisfy the constraints specified by an AWS service.
Common Parameters
The following list contains the parameters that all actions use for signing Signature Version 4 requests with
a query string. Any action-specific parameters are listed in the topic for that action. For more information
about Signature Version 4, see Signature Version 4 Signing Process in the Amazon Web Services General
Reference.
Action
The action to be performed.
Type: string
Required: Yes
57
Common Parameters
Version
The API version that the request is written for, expressed in the format YYYY-MM-DD.
Type: string
Required: Yes
X-Amz-Algorithm
The hash algorithm that you used to create the request signature.
Condition: Specify this parameter when you include authentication information in a query string instead
of in the HTTP authorization header.
Type: string
Valid Values: AWS4-HMAC-SHA256
Required: Conditional
X-Amz-Credential
The credential scope value, which is a string that includes your access key, the date, the region you
are targeting, the service you are requesting, and a termination string ("aws4_request"). The value is
expressed in the following format: access_key/YYYYMMDD/region/service/aws4_request.
For more information, see Task 2: Create a String to Sign for Signature Version 4 in the Amazon Web
Services General Reference.
Type: string
X-Amz-Date
The date that is used to create the signature. The format must be ISO 8601 basic format
(YYYYMMDD'T'HHMMSS'Z'). For example, the following date time is a valid X-Amz-Date value:
20120325T120000Z.
Condition: X-Amz-Date is optional for all requests; it can be used to override the date used for signing
requests. If the Date header is specified in the ISO 8601 basic format, X-Amz-Date is not required.
When X-Amz-Date is used, it always overrides the value of the Date header. For more information, see
Handling Dates in Signature Version 4 in the Amazon Web Services General Reference.
Type: string
X-Amz-Security-Token
The temporary security token that was obtained through a call to AWS Security Token Service (AWS
STS). For a list of services that support temporary security credentials from AWS Security Token
Service, go to AWS Services That Work with IAM in the IAM User Guide.
Condition: If you're using temporary security credentials from the AWS Security Token Service, you
must include the security token.
Type: string
58
Common Parameters
X-Amz-Signature
Specifies the hex-encoded signature that was calculated from the string to sign and the derived signing
key.
Type: string
X-Amz-SignedHeaders
Specifies all the HTTP headers that were included as part of the canonical request. For more
information about specifying signed headers, see Task 1: Create a Canonical Request For Signature
Version 4 in the Amazon Web Services General Reference.
Type: string
59
AWS Glossary
For the latest AWS terminology, see the AWS Glossary in the AWS General Reference.
60

Python 21

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Python 21

Загружено:

Авторское право:

Доступные форматы

Tradutor da Amazon

Tradutor da Amazon: Guia do desenvolvedor

O que é o Amazon Translate?

Por exemplo, é possível:

Você é um usuário iniciante do Amazon Translate?

1. Como o Amazon Translate funciona (p. 2) - Apresenta o Amazon Translate.

Como o Amazon Translate funciona

Detecção automática de idioma

• UnsupportedLanguagePairException – O Amazon Translate oferece suporte à tradução entre inglês e

• Conceitos básicos do Amazon Translate (p. 4)

Conceitos básicos do Amazon

Etapa 1: configurar uma conta da AWS e criar um

1. Cadastre-se na AWS (p. 4)

Se você já tem uma conta da AWS, vá para a próxima seção.

Para criar uma conta da AWS

1. Abra o https://aws.amazon.com/ e escolha em Criar uma conta da AWS.

Registre o ID de sua conta da AWS, pois precisará dele na próxima tarefa.

Criar um usuário do IAM

Para criar um usuário administrador

Para obter mais informações sobre IAM, consulte o seguinte:

• AWS Identity and Access Management (IAM)

Etapa 2: configurar a AWS Command Line Interface

Para configurar a AWS CLI

• Configurar com a AWS Command Line Interface

aws translate help

Etapa 3: Conceitos básicos (console)

Etapa 4: Conceitos básicos (AWS CLI)

Traduzir textos usando a linha de comando

aws translate translate-text \

A resposta é o seguinte JSON:

Traduzir textos usando um arquivo JSON

Para traduzir o texto usando um arquivo JSON

1. Copie o seguinte texto em um arquivo JSON chamado translate.json:

2. Na AWS CLI, execute o seguinte comando:

aws translate translate-text \

O comando resulta em um arquivo JSON que contém o seguinte texto de JSON:

Etapa 5: Conceitos básicos (SDK)

Tradução de texto usando o AWS SDK for Java

public class App {

public static void main( String[] args ) {

// Create credentials using a provider chain. For more information, see

AWSTranslate translate = AmazonTranslateClient.standard()

TranslateTextRequest request = new TranslateTextRequest()

Tradução de texto usando o AWS SDK for Python

translate = boto3.client(service_name='translate', region_name='region', use_ssl=True)

result = translate.translate_text(Text="Hello, World",

Traduzir textos usando o AWS Mobile SDK para

Para configurar o exemplo

5. Adicione as permissões a seguir ao arquivo AndroidManifest.xml.

6. Copie o código-fonte no seu projeto

public class MainActivity extends Activity {

private static final String LOG_TAG = MainActivity.class.getSimpleName();

AmazonTranslateAsyncClient translateAsyncClient = new

Traduzir textos usando o AWS Mobile SDK for iOS

Para configurar o exemplo

sudo gem install cocoapods

5. Adicione os principais componentes do Mobile SDK for iOS ao arquivo pod:

platform :ios, '9.0'

6. Instale as dependências executando o seguinte comando em uma janela de terminal:

pod install --repo-update

var credentialsProvider = AWSStaticCredentialsProvider(accessKey: "access key", secretKey:

var configuration = AWSServiceConfiguration(region: AWSRegionUSEast1, credentialsProvider:

let translateClient = AWSTranslate.default()

let callback: (AWSTranslateTranslateTextResponse?, Error?) -> Void = { (response, error) in

/Init and Connect to Chat**/

/Receive and Translate Chat**/