Manuel du développeur · 2018-08-31 · Mise en route ... à l'aide du code de la langue...

Amazon TranslateManuel du développeur

Amazon Translate Manuel du développeur

Amazon Translate: Manuel du développeurCopyright © 2018 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

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


Table of ContentsEn quoi consiste Amazon Translate ? .................................................................................................... 1

Vous utilisez Amazon Translate pour la première fois ? .................................................................... 2Fonctionnement .................................................................................................................................. 3

Détection automatique de la langue .............................................................................................. 4Gestion des exceptions ............................................................................................................... 4Étapes suivantes ........................................................................................................................ 5

Mise en route .................................................................................................................................... 6Étape 1 : Configuration d'un compte .............................................................................................. 6

Inscrivez-vous à AWS ......................................................................................................... 6Créer un utilisateur IAM ....................................................................................................... 7Étape suivante ................................................................................................................... 7

Étape 2 : Configuration de l'AWS CLI ............................................................................................ 7Étape suivante ................................................................................................................... 8

Etape 3 : Démarrage (console) ..................................................................................................... 8Étape suivante ................................................................................................................. 10

Etape 4 : Mise en route (AWS CLI) ............................................................................................. 10Traduction d'un texte à l'aide de la ligne de commande .......................................................... 11Traduction d'un texte à l'aide d'un fichier JSON ..................................................................... 11Étape suivante ................................................................................................................. 12

Étape 5 : Mise en route (SDK) .................................................................................................... 12Utilisation du kit SDK pour Java .......................................................................................... 12Utilisation du kit AWS SDK pour Python ............................................................................... 13Utilisation du kit Mobile SDK pour Android ............................................................................ 13Utilisation du kit Mobile SDK for iOS .................................................................................... 15

Exemples ......................................................................................................................................... 17Utiliser Amazon Polly avec Amazon Translate ............................................................................... 17

Code ............................................................................................................................... 18Utilisation d'Amazon Translate pour traduire un canal de discussion .................................................. 21Utiliser Amazon Translate avec DynamoDB .................................................................................. 29

Exemple de code .............................................................................................................. 30Utilisation d'Amazon Translate pour traduire une page Web ............................................................ 33Utilisation d'Amazon Translate pour traduire des documents volumineux ............................................ 35Utilisation de Signature Version 4 avec Amazon Translate ............................................................... 37

Configuration .................................................................................................................... 37Code ............................................................................................................................... 38

Authentification et contrôle d'accès ...................................................................................................... 41Authentification ......................................................................................................................... 41Contrôle d'accès ....................................................................................................................... 42Présentation de la gestion de l'accès ........................................................................................... 42

Gestion de l'accès aux actions ............................................................................................ 43Spécification des éléments d'une stratégie : ressources, actions, effets et mandataires ................. 44Spécification des conditions dans une stratégie ..................................................................... 44

Utilisation des stratégies basées sur une identité (stratégies IAM) pour Amazon Translate ..................... 45Référence des autorisations d'API Amazon Translate ..................................................................... 45

Surveillance ..................................................................................................................................... 47Surveillance avec CloudWatch .................................................................................................... 49

Présentation des métriques CloudWatch pour Amazon Translate .............................................. 49Affichage des métriques Amazon Translate ........................................................................... 50Création d'une alarme ....................................................................................................... 50

Métriques CloudWatch et dimensions pour Amazon Translate .......................................................... 50CloudWatch Metrics for Amazon Translate ............................................................................ 50CloudWatch Dimensions for Amazon Translate ..................................................................... 51

Consignes et limites .......................................................................................................................... 53Régions prises en charge .......................................................................................................... 53

iii


Limitation ................................................................................................................................. 53Consignes ................................................................................................................................ 53Restrictions .............................................................................................................................. 53

Historique du document ..................................................................................................................... 54API Reference .................................................................................................................................. 55

Actions .................................................................................................................................... 55TranslateText ................................................................................................................... 56

Data Types .............................................................................................................................. 59Common Errors ........................................................................................................................ 59Common Parameters ................................................................................................................. 60

Glossaire AWS ................................................................................................................................. 63

iv


En quoi consiste Amazon Translate ?Amazon Translate traduit des documents depuis les douze langues suivantes en anglais et en anglaisdepuis ces langues :

• Arabe• Chinois (simplifié)• Chinois (traditionnel)• Tchèque• Français• Allemand• Italien• Japonais• Portugais• Russe• Espagnol• Turc

Amazon Translate utilise des technologies de Machine Learning (apprentissage machine) avancées pourfournir des traductions de haute qualité à la demande. Utilisez ce service pour traduire des documents textenon structurés ou pour créer des applications qui fonctionnent dans plusieurs langues.

Par exemple, vous pouvez :

• Intégrez Amazon Translate à vos applications pour activer des expériences utilisateur multilingues.• Traduisez des contenus créés par des entreprises, comme des comptes-rendus de réunions, des

rapports de technicien, des articles de base de connaissances, des billets, et bien plus encore.• Traduisez les communications interpersonnelles, comme les e-mails, les discussions dans le jeu, les

discussions avec le service client, et bien plus encore, ce qui permet aux clients et employés de seconnecter dans leur langue préférée.

• Utilisez Amazon Translate dans le cadre du flux de travail de votre entreprise pour les donnéesentrantes.• Analysez les textes, comme ceux des réseaux sociaux et des flux d'actualités, dans de nombreuses

langues.• Recherchez des informations, par exemple pour les cas de découverte électronique, dans de

nombreuses langues.• Intégrez Amazon Translate à d'autres services AWS pour permettre un traitement indépendant de la

langue.• Utilisez-le avec Amazon Comprehend pour extraire des entités nommées, des sentiments et des

expressions clés à partir de textes non structurés, comme des flux de médias sociaux.• Utilisez-le avec Amazon Transcribe pour rendre les sous-titres et le sous-titrage en direct disponibles

dans de nombreuses langues.• Utilisez ce service avec Amazon Polly pour lire à haute voix des contenus traduits.• Utilisez-le avec Amazon S3 pour traduire des référentiels de documents.• Utilisez-le avec Amazon DynamoDB, Amazon Aurora et Amazon Redshift pour traduire des textes

stockés dans des bases de données.• Utilisez-le avec AWS Lambda ou AWS Glue pour une intégration du flux de travail fluide.

1

Amazon Translate Manuel du développeurVous utilisez Amazon Translate pour la première fois ?

Vous utilisez Amazon Translate pour la premièrefois ?

Si c'est le cas, nous vous recommandons de lire les sections suivantes dans l'ordre :

1. Fonctionnement d'Amazon Translate (p. 3) – Présente Amazon Translate.2. Démarrez avec Amazon Translate (p. 6) – Explique comment configurer votre compte AWS et tester

Amazon Translate.3. Exemples (p. 17) – Fournit des exemples de code Java et Python. Utilisez-les pour découvrir

comment Amazon Translate fonctionne.4. API Reference (p. 55) – Contient la documentation de référence pour les opérations Amazon

Translate.

2


Fonctionnement d'Amazon TranslateAmazon Translate est basé sur des réseaux neuronaux qui ont été formés pour traduire de l'anglais versles langues suivantes ou de ces langues vers l'anglais :

• Arabe• Chinois (simplifié)• Chinois (traditionnel)• Tchèque• Français• Allemand• Italien• Japonais• Portugais• Russe• Espagnol• Turc

Vous pouvez également traduire un texte de l'une de ces langues vers une autre de ces langues entraduisant tout d'abord le texte source en anglais, puis en traduisant le texte anglais dans la langue cible.

Lorsque vous travaillez avec Amazon Translate, vous fournissez un texte source et obtenez un texte ensortie :

• Texte source—Le texte à traduire. Vous fournissez le texte source au format UTF-8.• Texte en sortie—Le texte en sortie qu';Amazon Translate a traduit dans la langue cible est également au

format UTF-8. En fonction des langues source et cible, le nombre de caractères du texte en sortie peutêtre supérieur à celui du texte source.

Le modèle de traduction comporte deux composants, l'encodeur et le décodeur. L'encodeur lit la phrasesource mot par mot et crée une représentation sémantique qui en capture la signification. Le décodeurutilise la représentation sémantique pour générer une traduction mot par mot dans la langue cible.

Amazon Translate utilise des mécanismes d'attention pour comprendre le contexte. Cela lui permet dedéterminer les mots du texte source les plus pertinents pour générer la mot cible suivant. Les mécanismesd'attention permettent au décodeur de se concentrer sur les parties les plus pertinentes d'une phrasesource. Cela permet de veiller à ce que le décodeur traduise correctement les mots ou expressionsambigus.

Le mot cible que le modèle génère devient le source pour le décodeur. Le réseau continue de générer desmots jusqu'à ce qu'il atteigne la fin de la phrase.

Pour traduire un texte, vous appelez la méthode TranslateText (p. 56) et fournissez le texte source et lalangue cible, à l'aide du code de la langue répertorié dans le tableau suivant.

Langue Code

Arabe ar

3

Amazon Translate Manuel du développeurDétection automatique de la langue

Langue Code

Chinois (simplifié) zh

Chinois (traditionnel) zh-TW

Tchèque cs

English en

Français fr

Allemand de

Italien it

Japonais ja

Portugais pt

Russe ru

Espagnol es

Turc tr

Pour traduire un texte depuis une autre langue que l'anglais dans le tableau vers une autre langue quel'anglais dans le tableau, vous devez d'abord le traduire en anglais, puis traduire le texte anglais dans lalangue cible.

Amazon Translate peut automatiquement détecter la langue source. Pour la détection automatique de lalangue, spécifiez auto comme langue source. lorsque vous fournissez un texte source. Amazon Translateappelle Amazon Comprehend pour détecter la langue source.

Détection automatique de la langueAmazon Translate peut automatiquement détecter la langue utilisée dans votre texte source. Pourutiliser la détection automatique de la langue, spécifiez auto comme langue source. Amazon Translateappelle Amazon Comprehend en votre nom afin de déterminer la langue utilisée dans le texte source.En choisissant la détection automatique de la langue, vous acceptez les conditions de service et lesaccords pour Amazon Comprehend. Pour plus d'informations sur la tarification pour Amazon Comprehend,consultez Tarification Amazon Comprehend .

Gestion des exceptionsSi vous spécifiez une langue source ou cible qui n'est pas prise en charge, Amazon Translate renvoie l'unedes exceptions suivantes :

• UnsupportedLanguagePairException – Amazon Translate prend en charge la traduction de l'anglais versles six autres langues. La langue source ou la langue cible doit être l'anglais.

• DetectedLanguageLowConfidenceException – Si vous utilisez la détection automatique de la langue,et Amazon Translate possède un niveau de confiance faible quant à la détection correcte de la languesource, il renvoie l'exception suivante. Si un niveau de confiance faible est acceptable, vous pouvezutiliser la langue source renvoyée dans l'exception.

4

https://aws.amazon.com/comprehend/pricing/

Amazon Translate Manuel du développeurÉtapes suivantes

Étapes suivantesMaintenant que vous connaissez Amazon Translate, vous pouvez explorer les sections suivantes pour ensavoir plus sur la création d'une solution.

• Démarrez avec Amazon Translate (p. 6)• Exemples (p. 17)

5

Amazon Translate Manuel du développeurÉtape 1 : Configuration d'un compte

Démarrez avec Amazon TranslatePour démarrer à l'aide d'Amazon Translate, configurez un compte AWS et créez un utilisateur AWS Identityand Access Management (IAM). Pour utiliser l'AWS Command Line Interface (AWS CLI), téléchargez etconfigurez-la.

Rubriques• Étape 1 : Configuration d'un compte AWS et création d'un administrateur (p. 6)• Étape 2 : Configuration de l'AWS Command Line Interface (AWS CLI) (p. 7)• Etape 3 : Démarrage (console) (p. 8)• Etape 4 : Mise en route (AWS CLI) (p. 10)• Étape 5 : Mise en route (SDK) (p. 12)

Étape 1 : Configuration d'un compte AWS etcréation d'un administrateur

Avant d'utiliser Amazon Translate pour la première fois, exécutez les tâches suivantes :

1. Inscrivez-vous à AWS (p. 6)2. Créer un utilisateur IAM (p. 7)

Inscrivez-vous à AWSLorsque vous vous inscrivez à Amazon Web Services (AWS), votre compte AWS est automatiquementinscrit à tous les services AWS, y compris Amazon Translate. Seuls les services que vous utilisez voussont facturés.

Avec Amazon Translate, vous ne payez que les ressources que vous utilisez. Si vous êtes un nouveauclient AWS, vous pouvez démarrer avec Amazon Translate gratuitement. Pour plus d'informations,consultez la page Niveau d'offre gratuite d'AWS.

Si vous possédez déjà un compte AWS, passez à la section suivante.

Pour créer un compte AWS

1. Ouvrez https://aws.amazon.com/, puis choisissez Create an AWS Account.

Note

Il est probable que cette opération soit indisponible dans votre navigateur si vous vousêtes déjà connecté à AWS Management Console auparavant. Dans ce cas, choisissez Seconnecter à un autre compte, puis Créer un nouveau compte AWS.

2. Suivez les instructions en ligne.

Dans le cadre de la procédure d'inscription, vous recevrez un appel téléphonique et vous saisirez uncode PIN en utilisant le clavier numérique du téléphone.

6

https://aws.amazon.com/free/

https://aws.amazon.com/

Amazon Translate Manuel du développeurCréer un utilisateur IAM

Notez votre ID de compte AWS, car vous en aurez besoin lors de la prochaine tâche.

Créer un utilisateur IAMLes services AWS, comme Amazon Translate, nécessitent que vous fournissiez vos informationsd'identification lorsque vous y accédez. Le service peut ainsi déterminer si vous avez les autorisations pouraccéder à ses ressources.

Nous vous recommandons vivement d'accéder à AWS en utilisant AWS Identity and Access Management(IAM), et non les informations d'identification de votre compte AWS. Pour utiliser IAM afin d'accéder àAWS, créez un utilisateur IAM, ajoutez-le à un groupe IAM disposant d'autorisations d'administration, puisattribuez ces autorisations à cet utilisateur IAM. Vous pouvez ensuite accéder à AWS à l'aide d'une URLspéciale et des informations d'identification de l'utilisateur IAM.

Les exercices de ce guide présument que vous disposez d'un l'utilisateur IAM avec des privilègesd'administrateur, appelé adminuser.

Pour créer un utilisateur administrateur

• Dans votre compte AWS, créez un administrateur appelé adminuser. Pour obtenir des instructions,consultez la section Création de votre premier groupe d'utilisateurs et d'administrateurs IAM dans leIAM Guide de l'utilisateur.

Pour plus d'informations sur IAM, consultez les ressources suivantes :

• AWS Identity and Access Management (IAM)• Mise en route• IAM Guide de l'utilisateur

Étape suivanteÉtape 2 : Configuration de l'AWS Command Line Interface (AWS CLI) (p. 7)

Étape 2 : Configuration de l'AWS Command LineInterface (AWS CLI)

Vous utilisez l'AWS CLI pour effectuer des appels interactifs vers Amazon Translate.

Pour configurer l'AWS CLI.

1. Téléchargez et configurez l'AWS CLI. Pour obtenir des instructions, consultez les rubriques suivantesAWS Command Line Interface Guide de l'utilisateur:

• Préparation de l'installation de l'AWS Command Line Interface• Configuration de l'AWS Command Line Interface

2. Dans le fichier config de l'AWS CLI, ajoutez un profil nommé pour l'utilisateur administrateur :

[profile adminuser]aws_access_key_id = adminuser access key IDaws_secret_access_key = adminuser secret access key

7

http://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html

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

http://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started.html

http://docs.aws.amazon.com/IAM/latest/UserGuide/

http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html

http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html

Amazon Translate Manuel du développeurÉtape suivante

region = aws-region

Vous utiliserez ce profil lorsque vous exécuterez les commandes de l'AWS CLI. Pour plusd'informations sur les profils nommés (désignés), consultez Profils nommés dans le AWS CommandLine Interface Guide de l'utilisateur. Pour obtenir la liste des régions AWS, consultez Régions et pointsde terminaison dans le Référence générale d'Amazon Web Services.

3. Vérifiez la configuration en saisissant la commande d'aide suivante à l'invite de commande :

aws translate help

Vous devriez voir une brève description d'Amazon Translate et une liste des commandes disponibles.

Étape suivanteEtape 3 : Démarrage (console) (p. 8)

Etape 3 : Démarrage (console)Le moyen le plus simple de se familiariser avec Amazon Translate est d'utiliser la console pour traduire untexte. La console vous permet de traduire jusqu'à 5 000 caractères. Si vous n'avez pas étudié les conceptset la terminologie dans Fonctionnement d'Amazon Translate (p. 3), nous vous recommandons de le faireavant de continuer.

Pour commencer à traduire du texte, accédez à AWS Management Console et ouvrez la console AmazonTranslate.

Si c'est la première fois que vous utilisez Amazon Translate, choisissez Essayer Amazon Translate.

Dans Traduire un texte, choisissez les langues source et cible. Saisissez le texte à traduire dans la zone detexte de gauche. Le texte traduit s'affiche dans la zone de texte de droite.

8

http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-multiple-profiles

http://docs.aws.amazon.com/general/latest/gr/rande.html

http://docs.aws.amazon.com/general/latest/gr/rande.html

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

Amazon Translate Manuel du développeurEtape 3 : Démarrage (console)

Dans la section Exemples de JSON, vous pouvez consulter les valeurs JSON d'entrée et de sortie pourl'opération TranslateText (p. 56).

9


Étape suivanteEtape 4 : Mise en route (AWS CLI) (p. 10)

Etape 4 : Mise en route (AWS CLI)Dans les exercices suivants, vous utilisez l'interface de ligne de commande AWS (AWS CLI) pour traduireun texte. Pour effectuer ces exercices, vous devez être familiarisé avec l'interface de ligne de commandeet vous devez disposer d'un éditeur de texte. Pour plus d'informations, consultez Étape 2 : Configuration del'AWS Command Line Interface (AWS CLI) (p. 7).

Pour traduire un texte avec Amazon Translate, vous pouvez utiliser l'interface de ligne de commande dedeux manières. Pour un texte court, vous pouvez fournir le texte à traduire en tant que paramètre de lacommande translate-text. Pour un texte plus long, vous pouvez fournir la langue source, la languecible et le texte dans un fichier JSON.

Pour utiliser Amazon Translate à partir de la ligne de commande, vous devez connaître le point determinaison et la région pour le service. Pour obtenir la liste des points de terminaison et des régionsdisponibles, consultez Consignes et limites (p. 53).

10

Amazon Translate Manuel du développeurTraduction d'un texte à l'aide de la ligne de commande

Traduction d'un texte à l'aide de la ligne de commandeL'exemple suivant montre comment utiliser l'opération translate-text à l'aide de l'interface de ligne decommande pour traduire un texte. L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows,remplacez le caractère de continuation Unix, à savoir la barre oblique inversée (\), à la fin de chaque lignepar un accent circonflexe (^). Dans la ligne de commande, saisissez la chaîne suivante.

aws translate translate-text \ --region region \ --source-language-code "en" \ --target-language-code "es" \ --text "hello, world "

La réponse est le code JSON suivant :

{ "TargetLanguageCode": "es", "Text": "Hola, mundo", "SourceLanguageCode": "en"}

Traduction d'un texte à l'aide d'un fichier JSONCet exemple montre comment utiliser l'opération translate-text pour traduire un bloc de texteplus long à partir d'un fichier JSON. Vous pouvez spécifier les langues source et cible dans la ligne decommande, mais dans cet exemple, vous les indiquez dans le fichier JSON.

Note

Le fichier JSON est formaté à des fins de lisibilité. Reformatez le champ "Text" pour supprimerles sauts de ligne.L'exemple est mis en forme pour Unix, Linux et macOS. Pour Windows, remplacez le caractèrede continuation Unix, à savoir la barre oblique inversée (\), à la fin de chaque ligne par un accentcirconflexe (^).

Pour traduire un texte à l'aide d'un fichier JSON

1. Copiez le texte suivant dans un fichier JSON appelé 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. Dans l'AWS CLI, exécutez la commande suivante :

aws translate translate-text \ --region region \ --cli-input-json file://translate.json > translated.json

La commande produit un fichier JSON qui contient le texte JSON suivant :

11


{ "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"}

Étape suivantePour découvrir d'autres manières d'utiliser Amazon Translate consultez Exemples (p. 17).

Étape 5 : Mise en route (SDK)Les exemples suivants montrent comment utiliser l'opération TranslateText (p. 56) Amazon Translate àl'aide de Java et Python. Utilisez-les pour en savoir plus sur l'opération TranslateText et pour concevoirvos propres applications.

Pour exécuter les exemples Java, vous devez installer le kit AWS SDK for Java. Pour obtenir desinstructions pour l'installation du kit SDK pour Java, consultez Configuration du kit AWS SDK pour Java.

Rubriques• Traduction d'un texte à l'aide du kit AWS SDK for Java (p. 12)• Traduction d'un texte à l'aide du kit AWS SDK for Python (Boto) (p. 13)• Traduction d'un texte à l'aide du kit AWS Mobile SDK pour Android (p. 13)• Traduction d'un texte à l'aide du kit AWS Mobile SDK for iOS (p. 15)

Traduction d'un texte à l'aide du kit AWS SDK for JavaL'exemple suivant illustre l'utilisation de l'opération TranslateText (p. 56) dans Java. Pour exécuter cetexemple, vous avez besoin du kit AWS SDK for Java. Pour obtenir des instructions pour l'installation du kitSDK pour Java, consultez Configuration du kit AWS SDK pour Java.

import com.amazonaws.auth.AWSStaticCredentialsProvider;import com.amazonaws.auth.BasicAWSCredentials;import com.amazonaws.client.builder.AwsClientBuilder;import com.amazonaws.services.translate.AmazonTranslate;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();

12

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

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

Amazon Translate Manuel du développeurUtilisation du kit AWS SDK pour Python

AmazonTranslate translate = AmazonTranslateClient.standard() .withCredentials(new AWSStaticCredentialsProvider(awsCreds)) .withRegion(REGION) .build(); TranslateTextRequest request = new TranslateTextRequest() .withText("Hello, world") .withSourceLanguageCode("en") .withTargetLanguageCode("es"); TranslateTextResult result = translate.translateText(request); System.out.println(result.getTranslatedText()); }}

Vous pouvez modifier les langues source et cible, sous réserve des contraintes suivantes :

• Si la langue source est l'anglais, vous pouvez traduire le texte source dans toute autre langue prise encharge. Pour consulter une liste des langages pris en charge, reportez-vous à la section Fonctionnementd'Amazon Translate (p. 3).

• Si la langue source n'est pas l'anglais, la langue cible doit être l'anglais.

Traduction d'un texte à l'aide du kit AWS SDK forPython (Boto)L'exemple suivant illustre l'utilisation de l'opération TranslateText (p. 56) dans Python. Pour l'exécuter,vous devez installer Amazon Translate via l'AWS CLI. Pour obtenir des instructions, consultez the sectioncalled “Étape 2 : Configuration de l'AWS CLI” (p. 7).

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'))

Vous pouvez modifier les langues source et cible, sous réserve des contraintes suivantes :

• Si la langue source est l'anglais, vous pouvez traduire le texte source dans toute autre langueprise en charge. Pour consulter une liste des langages pris en charge, reportez-vous à la sectionFonctionnement (p. 3).

• Si la langue source n'est pas l'anglais, la langue cible doit être l'anglais.

Traduction d'un texte à l'aide du kit AWS Mobile SDKpour AndroidVous pouvez utiliser Amazon Translate dans une application Android pour traduire un texte.

Pour configurer l'exemple

1. Configurez le kit AWS Mobile SDK pour Android. Pour plus d'informations, consultez Android : Optionsde configuration pour le kit SDK dans le Manuel du développeur AWS Mobile

13

http://docs.aws.amazon.com/aws-mobile/latest/developerguide/how-to-android-sdk-setup.html

http://docs.aws.amazon.com/aws-mobile/latest/developerguide/how-to-android-sdk-setup.html

Amazon Translate Manuel du développeurUtilisation du kit Mobile SDK pour Android

2. Créez un utilisateur IAM avec les autorisations minimales requises pour exécuter cet exemple.Pour plus d'informations sur la création d'un utilisateur IAM, consultez Création d'un utilisateur IAMdans votre compte AWS dans le Guide de l'utilisateur AWS Identity and Access Management. Pourles stratégies d'autorisation requises, consultez Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Translate (p. 45). Après avoir créé l'utilisateur, téléchargez lesinformations d'identification ou enregistrez la clé d'accès et la clé d'accès secrète.

3. Créez un nouveau projet avec Android Studio.4. Ajoutez ce qui suit à la section des dépendances de votre fichier build.gradle.

dependencies { implementation 'com.amazonaws:aws-android-sdk-translate:2.6.20'}

5. Ajoutez les autorisations suivantes au fichier AndroidManifest.xml.

<uses-permission android:name="android.permission.INTERNET"/><uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

6. Copiez le code source dans votre projet7. Modifiez la clé d'accès et la clé d'accès secrète en utilisant les clés que vous avez enregistrées lors de

l'étape 1.

CodeUtilisez le code suivant pour créer l'exemple.

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;import com.amazonaws.services.translate.model.TranslateTextRequest;import com.amazonaws.services.translate.model.TranslateTextResult; 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()

14

http://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html


Amazon Translate Manuel du développeurUtilisation du kit Mobile SDK for iOS

.withText("Hello, world") .withSourceLanguageCode("en") .withTargetLanguageCode("es"); 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()); } }); }}

Traduction d'un texte à l'aide du kit AWS Mobile SDKfor iOSVous pouvez utiliser Amazon Translate dans une application iOS pour traduire un texte.


1. Créez un utilisateur IAM avec les autorisations minimales requises pour exécuter cet exemple.Pour plus d'informations sur la création d'un utilisateur IAM, consultez Création d'un utilisateur IAMdans votre compte AWS dans le Guide de l'utilisateur AWS Identity and Access Management. Pourles stratégies d'autorisation requises, consultez Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Translate (p. 45). Après avoir créé l'utilisateur, téléchargez lesinformations d'identification ou enregistrez la clé d'accès et la clé d'accès secrète.

2. Installez Xcode, version 8.0 ou ultérieure. Vous pouvez télécharger la dernière version de Xcode àpartir du site web Apple, https://developer.apple.com/xcode/.

3. Installez Cocoapods. Dans une fenêtre de terminal, exécutez la commande suivante :

sudo gem install cocoapods

4. Créez un projet à l'aide de Xcode. Ensuite, dans une fenêtre de terminal, accédez au répertoire où setrouve le fichier .xcodeproj du projet et exécutez la commande suivante :

pod init

5. Ajoutez les principaux composants Mobile SDK for iOS à votre fichier pod :

platform :ios, '9.0'target :'app name' do use_frameworks! pod 'AWSTranslate', '~> 2.6.19' # other podsend

15



https://developer.apple.com/xcode/

Amazon Translate Manuel du développeurUtilisation du kit Mobile SDK for iOS

6. Installez les dépendances en exécutant la commande suivante dans une fenêtre de terminal :

pod install --repo-update

7. L'exécution de pod install crée un nouveau fichier d'espace de travail. Fermez votre projet Xcodeet rouvrez-le à l'aide du fichier ./nom_projet.xcworkspace. Désormais, vous devrez uniquementutiliser ce fichier pour ouvrir votre projet Xcode

Générez à nouveau votre application après l'avoir rouverte pour résoudre les API des nouvellesbibliothèques appelées dans votre code.

8. Ajoutez l'instruction d'importation suivante à votre contrôleur d'affichage :

import AWSTranslate

9. Copiez le code suivant dans votre projet XCode. Mettez à jour la clé d'accès et la clé secrète avec lesvaleurs que vous avez enregistrées lors de l'étape 1.

CodeUtilisez le code suivant pour créer l'exemple.

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)

16

Amazon Translate Manuel du développeurUtiliser Amazon Polly avec Amazon Translate

ExemplesLes exemples suivants montrent comment utiliser Amazon Translate.

Rubriques• Utilisation d'Amazon Polly avec Amazon Translate (p. 17)• Utilisation d'Amazon Translate pour traduire un canal de discussion (p. 21)• Utilisation d'Amazon Translate avec Amazon DynamoDB (p. 29)• Utilisation d'Amazon Translate pour traduire une page Web (p. 33)• Utilisation d'Amazon Translate pour traduire des documents volumineux (p. 35)• Utilisation de Signature Version 4 avec Amazon Translate (p. 37)

Utilisation d'Amazon Polly avec Amazon TranslatePour lire à haute voix un texte traduit, vous pouvez utiliser Amazon Polly avec Amazon Translate. Danscet exemple, vous allez créer une page web dans laquelle vous pouvez traduire un texte à l'aide d'AmazonTranslate, puis lire ce texte à haute voix avec Amazon Polly. Le code peut être résumé dans les élémentssuivants :

• CSS et HTML pour créer la page web.• Code d'initialisation qui crée des contrôleurs pour Amazon Translate et Amazon Polly.• Une fonction qui lit les données à partir de la page web et appelle Amazon Translate.• Une fonction qui lit les données à partir de la page web et appelle Amazon Polly.• Des fonctions utilitaires pour gérer la page web.


1. Installez et configurez le AWS SDK for JavaScript. Pour obtenir des instructions concernantl'installation du SDK for JavaScript, consultez Installation du kit SDK pour JavaScript.

2. Copiez le code de l'exemple dans un fichier HTML sur votre serveur web.3. Mettez à jour la balise <script> avec l'emplacement auquel vous avez installé le SDK for JavaScript.4. Modifiez la région et le point de terminaison en la région dans laquelle vous voulez exécuter les

opérations Amazon Translate et Amazon Polly. Pour obtenir la liste des régions prises en charge parAmazon Translate, consultez Consignes et limites (p. 53). Pour obtenir la liste des régions prisesen charge pour Amazon Polly, consultez Régions et points de terminaison AWS dans le documentRéférence générale d'Amazon Web Services.

5. Créez un utilisateur IAM avec les autorisations minimales requises pour exécuter cet exemple.Pour plus d'informations sur la création d'un utilisateur IAM, consultez Création d'un utilisateur IAMdans votre compte AWS dans le Guide de l'utilisateur AWS Identity and Access Management. Pourles stratégies d'autorisations requises, consultez Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Translate (p. 45) et Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Polly dans le Manuel du développeur Amazon Polly.

6. Fournissez l'ID d'accès et la clé secrète de l'utilisateur IAM que vous avez créé à l'étape précédente.

17

http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/installing-jssdk.html

http://docs.aws.amazon.com/general/latest/gr/rande.html#pol_region



http://docs.aws.amazon.com/polly/latest/dg/using-identity-based-policies.html


Amazon Translate Manuel du développeurCode

CodeVoici le code complet de l'exemple de page web. Vous pouvez copier ce code dans un fichier HTML pourexécuter l'exemple sur votre propre serveur web.

<!DOCTYPE html><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="cs">cs</option> <option value="de">de</option> <option value="es">es</option> <option value="fr">fr</option> <option value="it">it</option> <option value="ja">ja</option> <option value="pt">pt</option> <option value="ru">ru</option> <option value="tr">tr</option> <option value="zh">zh</option> <option value="zh-TW">zh-TW</option> </select> </th> <th align="left">Target Language Code: <select id="targetLanguageCodeDropdown"> <option value="en">en</option> <option value="ar">ar</option> <option value="cs">cs</option> <option value="de">de</option> <option value="es">es</option> <option value="fr">fr</option> <option value="it">it</option> <option value="ja">ja</option> <option value="pt">pt</option> <option value="ru">ru</option> <option value="tr">tr</option> <option value="zh">zh</option> <option value="zh-TW">zh-TW</option> </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>

18


</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();

/** * Change the region and endpoint. */ AWS.config.region = 'region'; // Region

/** * In a production application you should use a secure method of authenticating uses, such as the ones * described here: * https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-browser.html * * Note that Amazon Translate does not work with Amazon Cognito Identity. * * For this example you place the credentials of an IAM user in the HTML page. 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({region: AWS.config.region}); var polly = new AWS.Polly();

function doTranslate() { var inputText = document.getElementById('inputText').value; if (!inputText) {

19


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; } }); }

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";

20

Amazon Translate Manuel du développeurUtilisation d'Amazon Translate pour

traduire un canal de discussion

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);

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>

Utilisation d'Amazon Translate pour traduire uncanal de discussion

Vous pouvez utiliser Amazon Translate pour la traduction en temps réel de messages instantanés.Cet exemple utilise un canal Twitch, mais vous pouvez vous en servir comme point de départ pourd'autres textes diffusés en temps réel, notamment d'autres plates-formes de discussion instantanée, desinteractions avec le service client, des forums de discussion et bien plus encore.

Cet exemple utilise une page Web qui affiche des messages en temps réel en anglais, ainsi que leurtraduction en temps réel côte à côte. Vous pouvez envoyer les messages à Amazon Polly pour que le textesoit prononcé. Pour suivre une personne dans la messagerie instantanée, tapez son nom d'utilisateur.L'application prononce uniquement les messages de cet utilisateur.

21



Le code peut être résumé comme suit :

• CSS et HTML pour créer la page web.• Code d'initialisation qui crée des contrôleurs pour Amazon Translate et Amazon Polly.• Fonction de rappel exécutée lorsqu'un message instantané est reçu.• Fonction qui envoie un message instantané.• Fonction qui appelle Amazon Translate pour traduire des messages.• Fonction qui appelle Amazon Polly pour la synthèse vocale.• Des fonctions utilitaires pour gérer la page web.


1. Installez et configurez le AWS SDK for JavaScript. Pour obtenir des instructions concernantl'installation du SDK for JavaScript, consultez Installation du kit SDK pour JavaScript.

2. Copiez le code de l'exemple dans un fichier HTML sur votre serveur web.3. Mettez à jour la balise <script> avec l'emplacement auquel vous avez installé le SDK for JavaScript.4. Modifiez la région et le point de terminaison en la région dans laquelle vous voulez exécuter les

opérations Amazon Translate et Amazon Polly. Pour obtenir la liste des régions prises en charge parAmazon Translate, consultez Consignes et limites (p. 53). Pour obtenir la liste des régions prisesen charge pour Amazon Polly, consultez Régions et points de terminaison AWS dans le documentRéférence générale d'Amazon Web Services.

5. Créez un utilisateur IAM avec les autorisations minimales requises pour exécuter cet exemple.Pour plus d'informations sur la création d'un utilisateur IAM, consultez Création d'un utilisateur IAMdans votre compte AWS dans le Guide de l'utilisateur AWS Identity and Access Management. Pourles stratégies d'autorisations requises, consultez Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Translate (p. 45) et Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Polly dans le Manuel du développeur Amazon Polly.

6. Fournissez l'ID d'accès et la clé secrète de l'utilisateur IAM que vous avez créé à l'étape précédente.7. Fournissez un nom d'utilisateur Twitch et le jeton OAuth correspondant à votre compte. Vous pouvez

créer un compte Twitch depuis https://www.twitch.tv. Vous pouvez créer un jeton OAuth Twitch depuishttps://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 }

22

http://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/installing-jssdk.html

http://docs.aws.amazon.com/general/latest/gr/rande.html#pol_region





https://www.twitch.tv

https://twitchapps.com/tmi



.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"> <div class="col-md-12"> <p class="bg-info"> <div id="connecting-div"></div> </p> </div> </div>

<div class="row" style="padding: 10px;"> <div class="col-md-6"> <div class="form-inline"> <div class="form-group"> <input type="text" id="channel" class="form-control" value="" placeholder="Channel"/> </div> <div class="form-group"> <select id="sourceLanguage" class="form-control"> <option value="en">en</option> <option value="ar">ar</option> <option value="de" selected="selected">de</option> <option value="es">es</option> <option value="fr">fr</option> <option value="pt">pt</option> <option value="zh">zh</option> </select> </div> <div class="form-group"> <select id="targetLanguage" class="form-control"> <option value="en" selected="selected">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> </div> <div class="form-group">

23



<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="col-md-6"> <div class="form-inline"> <div class="form-group"> <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="col-md-6"> <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>   <div class="col-md-6"> <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"> <div class="col-md-11"> <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" crossorigin="anonymous"></script>

<script src="aws-js-sdk/dist/aws-sdk-all.js"></script>

24



<script src="http://cdn.tmijs.org/js/1.2.1/tmi.min.js" integrity="sha384-eE0n7sm1W7DOUI2Xh5I4qSpZTe6hupAO0ovLfqEy0yVJtGRBNfssdmjbJhEYm6Bw" crossorigin="anonymous"></script> <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: { 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 = {

25



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****************************/

/**************************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

26



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; 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;

27



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) { 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) { return new Promise(function (resolve, reject) { 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); }); }); }

28

Amazon Translate Manuel du développeurUtiliser Amazon Translate avec DynamoDB

// Play audio stream function playAudioStream(audioStream) { return new Promise(function (resolve, reject) { 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>

Utilisation d'Amazon Translate avec AmazonDynamoDB

Cet exemple montre comment traduire un commentaire sur un produit et l'enregistrer dans AmazonDynamoDB. Si vous demandez le même commentaire plus tard, DynamoDB le renvoie sans qu'il soitnécessaire de le faire traduire à nouveau par Amazon Translate.

Dans cet exemple, vous :

• Utilisez AWS CloudFormation pour créer des tables DynamoDB afin d'enregistrer la traduction et unefonction Lambda qui appelle l'opération TranslateText (p. 56).

• Testez la fonction à l'aide de la console AWS Lambda.

Pour exécuter l'exemple

1. Copiez le contenu de example.py, accessible dans Fonction Lambda Python (p. 30), versun fichier nommé example.py. example.py est une fonction Lambda qui appelle l'opérationTranslateText (p. 56). Compressez le fichier dans une archive ZIP nommée example.zip.Stockez-la dans un compartiment S3 de la même région AWS que celle dans laquelle vous voulezexécuter la fonction.

2. Créez un fichier nommé template.yaml. Copiez dans ce fichier le code du modèle AWSCloudFormation, que vous pouvez trouver dans Modèle AWS CloudFormation (p. 32). AWSCloudFormation utilise le modèle pour créer des ressources pour l'exemple d'application. RemplacezBUCKET_NAME par le nom du compartiment S3 qui contient example.zip. Enregistrez le fichier dansun répertoire local.

3. Connectez-vous à AWS Management Console, puis ouvrez la console AWS CloudFormation àl'adresse https://console.aws.amazon.com/cloudformation.

4. Choisissez Créer une nouvelle pile.5. Sélectionnez Télécharger un modèle sur Amazon S3, puis Choisir un fichier. Choisissez

template.yaml, que vous avez créé à l'étape 2, puis Suivant.

29

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

Amazon Translate Manuel du développeurExemple de code

6. Saisissez un nom pour la pile, puis choisissez Suivant.7. Sur la page Options, choisissez Next.8. Choisissez Je sais qu'AWS CloudFormation peut créer des ressources IAM et Je sais qu'AWS

CloudFormation peut créer des ressources IAM avec des noms personnalisés. Pour plusd'informations, consultez Contrôle de l'accès avec AWS Identity and Access Management dans leGuide de l'utilisateur AWS CloudFormation.

9. Sélectionnez Créer un jeu de modifications.10. Lorsqu'AWS CloudFormation crée le jeu de modifications, sélectionnez Exécuter. Attendez qu'AWS

CloudFormation crée la pile.11. Connectez-vous à la AWS Management Console et ouvrez la console AWS Lambda à l'adresse

https://console.aws.amazon.com/lambda/.12. Choisissez la nouvelle fonction. Son nom commence par TestTranslate-ReviewTranslate.13. Sur la page des détails de la fonction, sélectionnez Test.14. Pour Nom de l'événement, saisissez TestTranslate. Pour Configurer un événement de test,

remplacez le code JSON par le code suivant :

{ "review": "hello world", "target_language": "es", "source_language": "en", "review_id": "1"}

Sélectionnez Create.15. Vérifiez que l'option TestTranslate est sélectionnée, puis choisissez Test. Une fois le test terminé, vous

recevez le message suivant :

Exemple de codeUtilisez le code suivant pour créer l'exemple.

Fonction Lambda PythonL'exemple suivant présente le contenu de la fonction Lambda Python. La fonction Lambda appellel'opération TranlateText et transmet le commentaire, la langue source et la langue cible pour obtenirle commentaire traduit. Enregistrez ce fichier en tant que example.py et compressez-le dans unearchive .zip nommée example.zip. Enregistrez le fichier dans un compartiment S3 de la même régionque celle dans laquelle vous exécutez l'exemple.

import logging

30

http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html

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


import jsonimport boto3import 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, 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)) except Exception as e: logger.error(response) raise Exception("[ErrorMessage]: " + str(e))

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,

31


}, 'language': { 'S': target_language, }, 'review': { 'S': result.get('TranslatedText') } } ) logger.info(response) except Exception as e: logger.error(e) raise Exception("[ErrorMessage]: " + str(e)) return result.get('TranslatedText') else: logger.error(e) raise Exception("[ErrorMessage]: Invalid input ")

Modèle AWS CloudFormationL'exemple qui suit présente le fichier modèle que vous utilisez avec AWS CloudFormation pour créeret configurer la fonction Lambda et les tables DynamoDB. Utilisez ce fichier lorsque vous créez la pileAWS CloudFormation pour cet exemple. Mettez à jour BUCKET_NAME avec le nom du compartimentS3 contenant le fichier example.zip, puis enregistrez-le dans un répertoire local en tant quetemplate.yaml.

AWSTemplateFormatVersion: '2010-09-09'Transform: 'AWS::Serverless-2016-10-31'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

32

Amazon Translate Manuel du développeurUtilisation d'Amazon Translate pour traduire une page Web

Utilisation d'Amazon Translate pour traduire unepage Web

Vous pouvez utiliser Amazon Translate pour traduire le contenu d'une page Web. Le programme Javasuivant traduit une page Web spécifiée de l'anglais vers l'espagnol et crée un fichier HTML qui contient latraduction générée. Ce programme inclut deux fonctions :

• Une fonction qui lit les données de la page Web source, les scinde en éléments HTML, puis appelle laseconde fonction pour la traduction de chaque élément. À la fin du document, elle écrit les résultats dansun fichier HTML.

• Une fonction qui appelle le service Amazon Translate pour traduire le contenu d'un élément HTML.


1. Installez et configurez le kit AWS SDK for Java. Pour obtenir des instructions concernant l'installationdu kit SDK pour Java, consultez Configuration du AWS SDK for Java.

2. Installez l'analyseur Java HTML jsoup. Pour obtenir des instructions, consultez jsoup.3. Créez un utilisateur IAM avec les autorisations minimales requises pour exécuter cet exemple.

Pour plus d'informations sur la création d'un utilisateur IAM, consultez Création d'un utilisateur IAMdans votre compte AWS dans le Guide de l'utilisateur AWS Identity and Access Management. Pourles stratégies d'autorisation requises, consultez Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Translate (p. 45).

4. Configurez les informations d'identification nécessaires à l'exécution de l'exemple. Pour obtenir desinstructions, consultez Configuration des informations d'identification et de la région AWS pour ledéveloppement dans le manuel du développeur AWS SDK for Java.

5. Créez un nouveau projet dans votre IDE Java et copiez le code source.6. Modifiez la région et le point de terminaison en sélectionnant la région dans laquelle vous souhaitez

exécuter l'opération Amazon Translate. Pour obtenir la liste des régions prises en charge par AmazonTranslate, consultez Consignes et limites (p. 53).

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.services.translate.AmazonTranslateClient;import com.amazonaws.services.translate.model.TranslateTextRequest;import com.amazonaws.services.translate.model.TranslateTextResult;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 {

33

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

https://jsoup.org/



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


Amazon Translate Manuel du développeurUtilisation d'Amazon Translate pour traduire une page Web

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); // 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);

34

Amazon Translate Manuel du développeurUtilisation d'Amazon Translate pourtraduire des documents volumineux

// 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 TranslateTextRequest request = new TranslateTextRequest() .withText(text) .withSourceLanguageCode("en") .withTargetLanguageCode("es"); // Retrieve the result TranslateTextResult result = translate.translateText(request); // Record the original and translated text 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. } } }

Utilisation d'Amazon Translate pour traduire desdocuments volumineux

Vous pouvez diviser des documents volumineux en parties plus petites pour maintenir la taille totale dudocument au-dessous de la limite de taille. Pour plus d'informations sur les limites de taille des documents,consultez Restrictions (p. 53). Le programme Java suivant divise les documents texte longs en phrasesindividuelles, puis traduit chaque phrase depuis la langue source vers la langue cible. Le programmecontient deux sections :

• La classe SentenceSegmenter se charge de diviser la chaîne source en phrases individuelles.L'exemple utilise la classe Java BreakIterator.

• La fonction main qui appelle l'opération Translate pour chaque phrase de la chaîne source. Lafonction main gère également l'authentification avec Amazon Translate.

35

Amazon Translate Manuel du développeurUtilisation d'Amazon Translate pourtraduire des documents volumineux


1. Installez et configurez le kit AWS SDK for Java. Pour obtenir des instructions concernant l'installationdu kit SDK pour Java, consultez Configuration du AWS SDK for Java.

2. Créez un utilisateur IAM avec les autorisations minimales requises pour exécuter cet exemple.Pour plus d'informations sur la création d'un utilisateur IAM, consultez Création d'un utilisateur IAMdans votre compte AWS dans le Guide de l'utilisateur AWS Identity and Access Management. Pourles stratégies d'autorisation requises, consultez Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Translate (p. 45).

3. Configurez les informations d'identification nécessaires à l'exécution de l'exemple. Pour obtenir desinstructions, consultez Configuration des informations d'identification et de la région AWS pour ledéveloppement dans le manuel du développeur AWS SDK for Java.

4. Créez un nouveau projet dans votre IDE Java et copiez le code source.5. Modifiez la région dans laquelle vous souhaitez exécuter l'opération Amazon Translate. Pour obtenir la

liste des régions prises en charge par Amazon Translate, consultez Consignes et limites (p. 53).6. Modifiez les langues source et cible pour les langues entre lesquelles traduire.7. Exécutez l'exemple pour voir le texte traduit sur la sortie standard.

import com.amazonaws.auth.AWSCredentialsProviderChain;import com.amazonaws.auth.EnvironmentVariableCredentialsProvider;import com.amazonaws.auth.SystemPropertiesCredentialsProvider;import com.amazonaws.auth.profile.ProfileCredentialsProvider;import com.amazonaws.services.translate.AmazonTranslate;import com.amazonaws.services.translate.AmazonTranslateClient;import com.amazonaws.services.translate.model.TranslateTextRequest;import com.amazonaws.services.translate.model.TranslateTextResult;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()

36

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





Amazon Translate Manuel du développeurUtilisation de Signature Version 4 avec Amazon Translate

);

// 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) { TranslateTextRequest request = new TranslateTextRequest() .withText(sentence) .withSourceLanguageCode(sourceLang) .withTargetLanguageCode(targetLang); TranslateTextResult result = translate.translateText(request); 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<>(); 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; }

}

Utilisation de Signature Version 4 avec AmazonTranslate

Cet exemple de programme Python montre comment utiliser Signature Version 4 pour ajouter desinformations d'authentification à des demandes Amazon Translate. L'exemple exécute une demandePOST, crée une structure JSON qui contient le texte à traduire dans le corps (charge utile) de la demande,et transmet les informations d'authentification dans un en-tête Authorization. Pour en savoir plus surl'utilisation de Signature Version 4, consultez Processus de signature Signature Version 4 dans le manuelRéférence générale d'Amazon Web Services.

ConfigurationPour exécuter l'exemple, effectuez les étapes suivantes :

1. Installez la AWS Command Line Interface (AWS CLI). Le kit AWS SDK for Python (Boto) est incluslorsque vous installez l'AWS CLI. Pour obtenir des instructions, consultez Étape 2 : Configuration del'AWS Command Line Interface (AWS CLI) (p. 7).

37

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


2. Créez un utilisateur AWS Identity and Access Management (IAM) avec la stratégie d'autorisationminimale requise pour exécuter cet exemple. Pour plus d'informations sur la création d'un utilisateurIAM, consultez Création d'un utilisateur IAM dans votre compte AWS dans le Guide de l'utilisateurAWS Identity and Access Management. Pour les stratégies d'autorisation requises, consultezUtilisation des stratégies basées sur une identité (stratégies IAM) pour Amazon Translate (p. 45).Enregistrez l'ID de clé d'accès utilisateur et la clé d'accès secrète.

3. Placez l'ID de clé d'accès et clé d'accès secrète dans les variables d'environnement nomméesAWS_ACCESS_KEY and AWS_SECRET_ACCESS_KEY, respectivement. Comme bonne pratique, nousvous recommandons de ne pas incorporer d'informations d'identification dans le code.

4. Créez un fichier sur votre ordinateur, copiez le code de l'exemple (disponible dans la section suivante),collez-le dans le fichier, puis enregistrez le fichier avec l'extension .py.

5. Dans le code, remplacez region par le nom de la région AWS dans laquelle vous souhaitez exécuterl'opération Amazon Translate TranslateText. Pour la liste des régions prises en charge, consultezRégions et points de terminaison AWS dans le document Amazon Web Services General Reference.

CodeVoici le code complet de l'exemple de programme Python.

Après avoir créé des valeurs de demande comme l'URL du point de terminaison et le corps de la demande,le code effectue les opérations suivantes :

1. Il crée une demande canonique pour l'opération Amazon Translate TranslateText.2. Il crée la chaîne que vous hachez pour créer la signature.3. Calculez la signature.4. Il ajoute la signature à l'en-tête de la demande.5. Il envoie la demande à l'opération TranslateText.

Pour exécuter l'exemple sur votre ordinateur, copiez le code dans un fichier 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, hmacimport 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'

38


http://docs.aws.amazon.com/general/latest/gr/rande.html#translate_region


# 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')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

39


# 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.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

40

Amazon Translate Manuel du développeurAuthentification

Authentification et contrôle d'accèspour Amazon Translate

L'accès à Amazon Translate requiert des informations d'identification qu'AWS peut utiliser pour authentifiervos demandes. Ces informations d'identification doivent être autorisées à accéder à des actions AmazonTranslate. Les sections suivantes fournissent des détails sur la façon dont vous pouvez utiliser AWSIdentity and Access Management (IAM) et Amazon Translate pour contribuer à sécuriser vos ressources encontrôlant qui peut y accéder.

• Authentification (p. 41)• Contrôle d'accès (p. 42)

AuthentificationVous pouvez utiliser les types d'identité suivants pour accéder à AWS :

• Utilisateur racine d'un compte AWS – Lorsque vous créez un compte AWS, vous commencez avecune seule identité de connexion disposant d'un accès complet à tous les services et ressources AWSdu compte. Cette identité est appelée utilisateur racine du compte AWS et elle est accessible aprèsconnexion à l'aide de l'adresse e-mail et du mot de passe utilisés pour la création du compte. Il estvivement recommandé de ne pas utiliser l'utilisateur racine pour vos tâches quotidiennes, y comprispour les tâches administratives. Au lieu de cela, respectez la bonne pratique qui consiste à avoir recoursà l'utilisateur racine uniquement pour créer le premier utilisateur IAM. Ensuite, mettez en sécurité lesinformations d'identification utilisateur racine et utilisez-les pour effectuer uniquement certaines tâches degestion des comptes et des services.

• Utilisateur IAM – Un utilisateur IAM est une identité au sein de votre compte AWS qui disposed'autorisations personnalisées spécifiques (par exemple, des autorisations pour créer a custom glossarydans Amazon Translate). Vous pouvez utiliser un nom d'utilisateur et un mot de passe IAM pour vousconnecter aux pages Web AWS sécurisées telles que AWS Management Console, les forums dediscussion AWS et le AWS Support Center.

En plus de générer un nom utilisateur et un mot de passe, vous pouvez générer des clés d'accèspour chaque utilisateur. Vous pouvez utiliser ces clés lorsque vous accédez aux services AWS parprogrammation, soit par le biais d'un kit SDK soit à l'aide d'AWS Command Line Interface (CLI). Lesoutils de l'interface de ligne de commande et les kits SDK utilisent les clés d'accès pour signer de façoncryptographique votre demande. Si vous n'utilisez pas les outils AWS, vous devez signer la demandevous-même. Amazon Translate supports prend en charge Signature Version 4, un protocole permettantl'authentification des demandes d'API entrantes. Pour plus d'informations sur l'authentification desdemandes, consultez la rubrique Processus de signature Signature Version 4 dans la documentationAWS General Reference.

• Rôle IAM – Un rôle IAM est une identité IAM que vous pouvez créer dans votre compte et qui dispose

d'autorisations spécifiques. Le concept ressemble à celui d'utilisateur IAM, mais le rôle IAM n'est pasassocié à une personne en particulier. Un rôle IAM vous permet d'obtenir des clés d'accès temporaires

41

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


http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

http://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html

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

https://forums.aws.amazon.com/

https://forums.aws.amazon.com/

https://console.aws.amazon.com/support/home#/

http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html

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

https://aws.amazon.com/cli/


http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

Amazon Translate Manuel du développeurContrôle d'accès

qui peuvent être utilisées pour accéder aux ressources et services AWS. Les rôles IAM avec desinformations d'identification temporaires sont utiles dans les cas suivants :

• Accès d'utilisateurs fédérés – Au lieu de créer un utilisateur IAM, vous pouvez utiliser des identités

d'utilisateur existantes d'AWS Directory Service, l'annuaire utilisateurs de votre entreprise, ou d'unfournisseur d'identité web. Ces derniers sont appelés utilisateurs fédérés. AWS attribue un rôle à unutilisateur fédéré lorsque l'accès est demandé via un fournisseur d'identité. Pour plus d'informationssur les utilisateurs fédérés, consultez Utilisateurs fédérés et rôles dans le manuel IAM Guide del'utilisateur.

• Accès d'un service AWS – Vous pouvez utiliser un rôle IAM de votre compte pour autoriser un autre

service AWS à accéder aux ressources de votre compte. Par exemple, vous pouvez créer un rôle quipermet à Amazon Redshift d'accéder à un compartiment Amazon S3 en votre nom, puis de charger lesdonnées stockées dans le compartiment dans un cluster Amazon Redshift. Pour plus d'informations,consultez la rubrique Création d'un rôle pour déléguer des autorisations à un service AWS dans le IAMGuide de l'utilisateur.

• Applications qui s'exécutent sur Amazon EC2 – Vous pouvez utiliser un rôle IAM pour gérer des

informations d'identification temporaires pour les applications qui s'exécutent sur une instance EC2et effectuent des demandes d'API AWS. Cette solution est préférable au stockage des clés d'accèsau sein de l'instance EC2. Pour attribuer un rôle AWS à une instance EC2 et le rendre disponible àtoutes les applications associées, vous pouvez créer un profil d'instance attaché à l'instance. Un profild'instance contient le rôle et permet aux programmes qui s'exécutent sur l'instance EC2 d'obtenir desinformations d'identification temporaires. Pour plus d'informations, consultez Utilisation d'un rôle IAMpour accorder des autorisations à des applications s'exécutant sur des instances Amazon EC2 dans leIAM Guide de l'utilisateur.

Contrôle d'accèsVous pouvez avoir des informations d'identification valides pour authentifier vos demandes. Par exemple,vous devez disposer d'autorisations pour appeler une action Amazon Translate.

Les sections suivantes décrivent comment gérer les autorisations pour Amazon Translate. Nous vousrecommandons de commencer par lire la présentation.

• Présentation de la gestion des autorisations d'accès à vos ressources Amazon Translate (p. 42)• Utilisation des stratégies basées sur une identité (stratégies IAM) pour Amazon Translate (p. 45)

Présentation de la gestion des autorisations d'accèsà vos ressources Amazon Translate

Les autorisations pour accéder à une action sont gérées par des stratégies d'autorisations. Un compteadministrateur peut attacher des stratégies d'autorisations à des identités IAM (c'est-à-dire des utilisateurs,des groupes et des rôles) pour gérer l'accès à des actions.

Note

Un administrateur de compte (ou utilisateur administrateur) est un utilisateur doté des privilègesd'administrateur. Pour plus d'informations, consultez Bonnes pratiques IAM dans le manuel IAMGuide de l'utilisateur.

42

http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html

http://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

http://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html

Amazon Translate Manuel du développeurGestion de l'accès aux actions

Lorsque vous accordez des autorisations, vous choisissez qui obtient les autorisations et pour quellesactions.

Rubriques• Gestion de l'accès aux actions (p. 43)• Spécification des éléments d'une stratégie : ressources, actions, effets et mandataires (p. 44)• Spécification des conditions dans une stratégie (p. 44)

Gestion de l'accès aux actionsUne stratégie d'autorisation décrit qui a accès à quoi. La section suivante explique les options disponiblespour créer des stratégies d'autorisation.

Note

Cette section décrit l'utilisation d'IAM dans le contexte d'Amazon Translate. Elle ne fournit pasd'informations détaillées sur le service IAM. Pour accéder à la documentation complète d'IAM,consultez Qu'est-ce qu'IAM ? du manuel IAM Guide de l'utilisateur. Pour plus d'informations sur lasyntaxe et les descriptions des stratégies IAM, consultez Référence de stratégie AWS IAM dans lemanuel IAM Guide de l'utilisateur.

Les stratégies attachées à une identité IAM sont appelées stratégies basées sur une entité (stratégiesIAM). Les stratégies attachées à une ressource sont appelées stratégies basées sur une ressource.Amazon Translate prend en charge uniquement les stratégies basées sur une identité.

Stratégies basées sur une identité (stratégies IAM)Vous pouvez attacher des stratégies à des identités IAM. Par exemple, vous pouvez effectuer lesopérations suivantes :

• Associer une stratégie d'autorisations à un utilisateur ou à un groupe de votre compte – Pour accorder àun utilisateur ou à un groupe d'utilisateurs des autorisations pour appeler une action Amazon Translate,vous pouvez attacher une stratégie d'autorisations à un utilisateur ou à un groupe auquel l'utilisateurappartient.

• Associer une stratégie d'autorisation à un rôle (accorder des autorisations entre comptes) – Pouraccorder des autorisations entre comptes, vous pouvez associer une stratégie d'autorisation baséesur une identité à un rôle IAM. Par exemple, l'administrateur dans le Compte A peut créer un rôle pouraccorder des autorisations entre comptes à un autre compte AWS (par exemple, le Compte B) ou à unservice AWS comme suit :1. L'administrateur du Compte A crée un rôle IAM et attache une stratégie d'autorisation à ce rôle qui

accorde des autorisations sur les ressources dans le Compte A.2. L'administrateur du Compte A attache une stratégie d'approbation au rôle identifiant le Compte B

comme mandataire pouvant assumer ce rôle.3. L'administrateur du compte B peut alors déléguer les autorisations pour assumer ce rôle à tous les

utilisateurs figurant dans le compte B. Les utilisateurs du compte B sont ainsi autorisés à créer desressources ou à y accéder dans le compte A. Si vous souhaitez accorder à un service AWS desautorisations pour assumer ce rôle, le mandataire dans la stratégie d'approbation peut également êtreun mandataire de service AWS.

Pour plus d'informations sur l'utilisation d'IAM pour déléguer des autorisations, consultez Gestion del'accès dans le manuel IAM Guide de l'utilisateur.

Pour plus d'informations sur l'utilisation des stratégies basées sur une identité avec AmazonTranslate, consultez Utilisation des stratégies basées sur une identité (stratégies IAM) pour Amazon

43


http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html

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

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

Amazon Translate Manuel du développeurSpécification des éléments d'une stratégie :ressources, actions, effets et mandataires

Translate (p. 45). Pour plus d'informations sur les utilisateurs, les groupes, les rôles et les autorisations,consultez Identités (utilisateurs, groupes et rôles) dans le manuel IAM Guide de l'utilisateur.

Stratégies basées sur une ressourceD'autres services, tels qu'Lambda, prennent en charge les stratégies d'autorisations basées sur uneressource. Par exemple, vous pouvez attacher une stratégie à un compartiment S3 pour gérer lesautorisations d'accès à ce compartiment. Amazon Translate ne prend pas en charge les stratégies baséessur une ressource.

Spécification des éléments d'une stratégie :ressources, actions, effets et mandatairesAmazon Translate définit un ensemble d'opérations d'API (voir Actions (p. 55)). Pour accorder desautorisations pour ces opérations d'API, Amazon Translate définit un ensemble d'actions que vous pouvezspécifier dans une stratégie.

Voici les éléments les plus élémentaires d'une stratégie :

• Ressource – Dans une stratégie, vous utilisez un Amazon Resource Name (ARN) pour identifier laressource à laquelle la stratégie s'applique. Pour Amazon Translate, la ressource est toujours *.

• Action – Vous utilisez des mots clés d'action pour identifier les opérations que vous voulez autoriser ourefuser. Par exemple, en fonction de la valeur Effect spécifiée, translate:TranslateText accordeou refuse à l'utilisateur les autorisations pour effectuer l'opération Amazon Translate TranslateText.

• Effet – Spécifiez l'effet produit lorsque l'utilisateur demande cette action spécifique, c'est-à-dire uneautorisation ou un refus. Si vous n'accordez pas explicitement l'accès pour (autoriser) une ressource,l'accès est implicitement refusé. Vous pouvez explicitement refuser l'accès à une ressource. Vouspouvez le faire afin de vous assurer qu'un utilisateur n'y a pas accès, même si une stratégie différenteaccorde cet accès.

• Mandataire – Dans les stratégies basées sur une identité (stratégies IAM), l'utilisateur auquel la stratégieest attachée est le mandataire implicite.

Pour plus d'informations sur la syntaxe des stratégies IAM et pour obtenir des descriptions, consultezRéférence de stratégie AWS IAM dans le manuel IAM Guide de l'utilisateur.

Pour visualiser un tableau répertoriant toutes les actions d'API Amazon Translate, consultez Autorisationsd'API Amazon Translate : référence des actions, ressources et conditions (p. 45).

Spécification des conditions dans une stratégieLorsque vous accordez des autorisations, vous pouvez utiliser le langage des stratégies IAM afin despécifier les conditions définissant à quel moment une stratégie doit prendre effet. Par exemple, il estpossible d'appliquer une stratégie après seulement une date spécifique. Pour plus d'informations sur laspécification de conditions dans un langage de stratégie, consultez Condition dans le manuel IAM Guide del'utilisateur.

AWS fournit un ensemble de clés de condition prédéfinies pour tous les services IAM qui prennent encharge IAM pour le contrôle d'accès. Par exemple, vous pouvez utiliser la clé de condition aws:useridpour exiger un ID AWS spécifique lorsque vous demandez une action. Pour obtenir plus d'informations etla liste des clés à l'échelle d'AWS, consultez Clés disponibles pour les conditions dans le IAM Guide del'utilisateur.

Note

Les clés de condition sont sensibles à la casse.

44

http://docs.aws.amazon.com/IAM/latest/UserGuide/id.html

http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html

http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition

http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys

Amazon Translate Manuel du développeurUtilisation des stratégies basées sur une

identité (stratégies IAM) pour Amazon Translate

Amazon Translate ne fournit aucune clé de condition supplémentaire.

Utilisation des stratégies basées sur une identité(stratégies IAM) pour Amazon Translate

Cette rubrique fournit un exemple de stratégie basée sur l'identité qui montre comment un administrateurde compte peut attacher des stratégies d'autorisations à des identités IAM (autrement dit, des utilisateurs,des groupes et des rôles) et accorder ainsi des autorisations pour effectuer des actions Amazon Translate.

Important

Avant de continuer, nous vous recommandons de passer en revue Présentation de la gestion desautorisations d'accès à vos ressources Amazon Translate (p. 42).

La stratégie d'autorisations suivante est requise pour utiliser Amazon Translate et la console AmazonTranslate :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "translate:TranslateText", "comprehend:DetectDominantLanguage" ], "Resource": "*" } ]}

La stratégie possède deux énoncés. La première accorde des autorisations pour utiliser l'actionTranslateText. La deuxième accorde des autorisations sur l'opération Amazon ComprehendDetectDominantLanguage pour activer la détection automatique de la langue.

La stratégie ne spécifie pas l'élément Principal car, dans une stratégie basée sur l'identité, vous nespécifiez pas le mandataire qui obtient les autorisations. Quand vous attachez une stratégie à un utilisateur,l'utilisateur est le mandataire implicite. Lorsque vous attachez une stratégie d'autorisation à un rôle IAM, lemandataire identifié dans la stratégie d'approbation de ce rôle obtient les autorisations.

Pour consulter un tableau des actions d'API Amazon Translate et les ressources auxquelles elless'appliquent, consultez Autorisations d'API Amazon Translate : référence des actions, ressources etconditions (p. 45).

Autorisations d'API Amazon Translate : référencedes actions, ressources et conditions

Utilisez le tableau ci-dessous comme référence lorsque vous configurez des stratégies d'autorisationsContrôle d'accès (p. 42) et d'écriture que vous pouvez attacher à une identité IAM (stratégie basée surune identité). Cette liste inclut chaque opération d'API Amazon Translate, ainsi que l'action correspondanteet la ressource AWS pour lesquelles vous pouvez accorder des autorisations. Vous spécifiez les actions

45

Amazon Translate Manuel du développeurRéférence des autorisations d'API Amazon Translate

dans le champ Action de la stratégie ainsi que la valeur des ressources dans le champ Resource de lastratégie.

Pour exprimer des conditions, vous pouvez utiliser des clés de condition à l'échelle d'AWS dans lesstratégies Amazon Translate. Pour obtenir la liste complète des clés à l'échelle d'AWS, consultez Clésdisponibles dans le manuel IAM Guide de l'utilisateur.

Note

Pour spécifier une action, utilisez le préfixe translate: suivi du nom de l'opération d'API (parexemple, translate:TranslateText).

46




Surveillance d'Amazon TranslateLa surveillance est essentielle pour assurer la fiabilité, la disponibilité et les performances d'AmazonTranslate et de vos solutions. AWS fournit différents outils que vous pouvez utiliser pour surveiller AmazonTranslate. Vous pouvez configurer certains de ces outils afin de surveiller pour vous vos solutions. Nousvous recommandons d'automatiser le plus possible les tâches de surveillance.

Amazon Translate fournit des graphiques préconfigurés qui vous expliquent les métriques les plusimportantes pour votre solution. Chaque graphique propose une fenêtre sur les performances de votresolution. Vous pouvez modifier la plage de temps affichée par les graphiques afin d'obtenir des vuesdifférentes sur la façon dont votre solution s'exécute avec le temps.

Vous pouvez également utiliser Amazon CloudWatch pour surveiller Amazon Translate. Avec CloudWatch,vous pouvez automatiser la surveillance des métriques spécifiques pour vos solutions. Vous recevezune notification chaque fois qu'une métrique dépasse les seuils définis. Vous pouvez également utiliserl'API CloudWatch pour créer une application de surveillance personnalisée adaptée à vos besoins. Pourplus d'informations, consultez Qu'est-ce qu'Amazon CloudWatch dans le Guide de l'utilisateur AmazonCloudWatch.

Le tableau suivant décrit chacun des graphiques préconfigurés fournis par Amazon Translate.

Graphique Description

Nombre de demandes réussies

Nombre de demandes réussies à AmazonTranslate pendant la période spécifiée.

Nombre de demandes limitées

Nombre de demandes à Amazon Translateayant été limitées pendant la période spécifiée.Utilisez ces informations pour déterminer si votreapplication envoie trop rapidement la demande àAmazon Translate.

47

http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatch.html


Graphique Description

Temps de réponse moyen

Le temps de réponse moyen nécessaire à AmazonTranslate pour traiter votre demande dans lapériode spécifiée.

Nombre de caractères

Le nombre total de caractères envoyés à AmazonTranslate pendant la période spécifiée. Il s'agit dunombre de caractères qui vous sera facturé.

Nombre d'erreurs utilisateur

Nombre d'erreurs utilisateur pendant la périodespécifiée. Les erreurs utilisateur se trouvent dans laplage des codes d'erreur HTTP comprise entre 400et 499.

Nombre d'erreurs système

Nombre d'erreurs système pendant la périodespécifiée. Les erreurs système se trouvent dans laplage des codes d'erreur HTTP comprise entre 500et 599.

48

Amazon Translate Manuel du développeurSurveillance avec CloudWatch

Surveillance d'Amazon TranslateCloudWatch vous permet de générer des métriques relatives à des opérations Amazon Translateindividuelles ou Amazon Translate globales pour votre compte. Utilisez les métriques pour suivre l'étatde votre solution basée sur Amazon Translate et configurer des alarmes pour vous notifier lorsqu'uneou plusieurs métriques dépassent un seuil défini. Par exemple, vous pouvez surveiller le nombre dedemandes envoyées à Amazon Translate pendant une période donnée, consulter la latence des demandesou générer une alarme lorsque les erreurs dépassent un certain seuil. Pour consulter les métriques, vouspouvez utiliser la console Amazon Translate Amazon CloudWatch, l'AWS Command Line Interface, oul'API CloudWatch.

Présentation des métriques CloudWatch pour AmazonTranslatePour générer les métriques relatives à vos opérations Amazon Translate, il vous faut spécifier lesinformations suivantes :

• La dimension de métrique. Une dimension est un ensemble de paires nom-valeur qui vous permetd'identifier une métrique. Amazon Translate compte deux dimensions :• Operation

• Language pair

• Le nom de métrique (par exemple, SuccessfulRequestCount ou RequestCharacters). Pourobtenir une liste complète des métriques, consultez CloudWatch Metrics for Amazon Translate (p. 50).

Vous pouvez obtenir les métriques d'Amazon Translate à l'aide de AWS Management Console de l'AWSCLI, ou de l'API CloudWatch. Vous pouvez également utiliser l'API CloudWatch via l'un des kits SDKAmazon AWS ou via les outils de l'API CloudWatch.

Le tableau suivant répertorie certaines utilisations courantes des métriques CloudWatch. Voici quelquessuggestions pour vous aider à démarrer, qui ne forment pas une liste exhaustive.

Comment... ? Métrique pertinente

Suivez le nombre de demandes réussies Surveillez la statistique sum de la métriqueSuccessfulRequestCount.

Sachez si mon application a atteint son débitmaximum

Surveillez la statistique sum de la métriqueThrottledCount.

Trouvez le temps de réponse pour mon application Surveillez la statistique average de la métriqueResponseTime.

Trouvez le nombre d'erreurs pour mon application Surveillez les sum statistiques duServerErrorCount et les métriques duUserErrorCount.

Recherchez le nombre de caractères facturables Surveillez la statistique sum de la métriqueCharacterCount.

Vous devez disposer des autorisations CloudWatch appropriées pour surveiller Amazon Translate avecCloudWatch. Pour plus d'informations, consultez Authentification et contrôle d'accès pour AmazonCloudWatch dans le Guide de l'utilisateur Amazon CloudWatch.

49

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

http://docs.aws.amazon.com/AmazonCloudWatch/latest/cli/

http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/

http://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/auth-and-access-control-cw.html

http://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/auth-and-access-control-cw.html

Amazon Translate Manuel du développeurAffichage des métriques Amazon Translate

Affichage des métriques Amazon TranslateConsultez les métriques Amazon Translate dans la console CloudWatch.

Pour consulter les métriques (console CloudWatch)

1. Connectez-vous à la AWS Management Console et ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.

2. Choisissez Métriques, Toutes les métriques, puis AWS/Translate.3. Choisissez la dimension, le nom de la métrique, puis Ajouter au graphique.4. Choisissez une valeur pour la plage de dates. Le nombre de métriques pour la plage de dates

spécifiées est affiché dans le graphique.

Création d'une alarmeUne alarme CloudWatch surveille une seule métrique sur une période spécifiée, et envoie une notificationà une rubrique Amazon SNS ou à une stratégie Auto Scaling. Ces actions dépendant de la valeur de lamétrique par rapport à un seuil donné sur un certain nombre de périodes que vous définissez. CloudWatchpeut également vous envoyer un message Amazon Simple Notification Service (Amazon SNS) lorsquel'alarme change d'état.

Les alarmes CloudWatch appellent uniquement des actions lorsque l'état change et persiste pendant lapériode spécifiée.

Pour définir une alarme

1. Connectez-vous à la AWS Management Console et ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.

2. Choisissez Alarmes, et Créer une alarme.3. Choisissez AWS/Translate Metrics, puis sélectionnez une métrique.4. Pour Intervalle de temps, choisissez un intervalle de temps à surveiller, puis choisissez Suivant.5. Tapez un nom et une description.6. Pour Whenever, choisissez >=, puis saisissez une valeur maximale.7. Si vous voulez que CloudWatch vous envoie un e-mail lorsque l'état d'alarme est atteint, choisissez

L'état est ALARME dans le champ Whenever this alarm de la section Actions. Pour Envoyer lesnotifications à, choisissez une liste de diffusion ou cliquez sur Nouvelle liste pour en créer une.

8. Affichez un aperçu de l'alarme dans la section Aperçu de l'alarme. Si elle vous convient, choisissezCréer une alarme.

Métriques CloudWatch et dimensions pour AmazonTranslate

Utilisez les métriques et les dimensions Amazon CloudWatch disponibles pour Amazon Translate afin desurveiller les performances de votre solution.

CloudWatch Metrics for Amazon TranslateMetric Description

CharacterCount The number of billable characters in requests.

50





Amazon Translate Manuel du développeurCloudWatch Dimensions for Amazon Translate

Metric DescriptionValid 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 servererror is 500 to 599.

Valid dimension: Operation

Valid statistics: Average, Sum

Unit: Count

SuccessfulRequestCount The number of successful translation requests. The response code for asuccessful request is 200 to 299.



Unit: Count

ThrottledCount The number of requests subject to throttling. Use ThrottledCount todetermine if your application is sending requests to Amazon Translatefaster than your account is configured to accept them. For moreinformation, see Amazon Translate Limits in the Référence généraled'Amazon Web Services.



Unit: Count

UserErrorCount The number of user errors that occurred. The HTTP response code rangefor a user error is 400 to 499.



Unit: Count

CloudWatch Dimensions for Amazon TranslateUse the following dimensions to filter Amazon Translate metrics. Metrics are grouped by the sourcelanguage and the target language.

51

http://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_amazon_translate

Amazon Translate Manuel du développeurCloudWatch Dimensions for Amazon Translate

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.

52

Amazon Translate Manuel du développeurRégions prises en charge

Consignes et limitesRégions prises en charge

Pour connaître les régions AWS dans lesquelles Amazon Translate est disponible, consultez Régions etpoints de terminaison AWS dans le document Référence générale d'Amazon Web Services.

LimitationPour plus d'informations sur les limitations pour Amazon Translate et pour demander une augmentationde la limite, consultez Limites Amazon Translate dans le document Référence générale d'Amazon WebServices.

ConsignesAmazon Translate peut stocker votre contenu pour améliorer continuellement la qualité de ses modèlesd'analyse. Consultez le Forum Aux Questions (FAQ) Amazon Translate pour en savoir plus. Pour nousdemander de supprimer le contenu qui peut avoir été stocké par Amazon Translate, ouvrez une demandeauprès de Support AWS.

RestrictionsLes restrictions suivantes s'appliquent à Amazon Translate :

• La taille maximum du document est de 5 000 octets de caractères UTF-8 par demande.

53



http://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_amazon_translate

https://aws.amazon.com/translate/faqs/


Historique du document pour AmazonTranslate

Le tableau suivant décrit la documentation de cette version d'Amazon Translate.

• Dernière mise à jour de la documentation : 17 juillet 2018

update-history-change update-history-description update-history-date

Nouvelle fonction Amazon Translate prenddésormais en charge latraduction de six languessupplémentaires. Pour obtenirune liste des langues prises encharge par Amazon Translate,consultez En quoi consisteAmazon Translate.

July 17, 2018

Nouvelle fonction Amazon Translate ajoute laprise en charge pour la détectionautomatique de la languesource. Pour plus d'informations,consultez Fonctionnementd'Amazon Translate.

April 4, 2018

Nouveau guide (p. 54) Il s'agit de la première version duGuide du développeur AmazonTranslate.

November 29, 2017

54

https://docs.aws.amazon.com/translate/latest/dg/what-is.html



https://docs.aws.amazon.com/translate/latest/dg/how-it-works.html



Amazon Translate Manuel du développeurActions

API ReferenceCette section contient la documentation de la référence d'API.

ActionsThe following actions are supported:

• TranslateText (p. 56)

55

Amazon Translate Manuel du développeurTranslateText

TranslateTextTranslates 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 theSourceLanguageCode field. If you specify auto, Amazon Translate will call Amazon Comprehend todetermine the source language.

Request Syntax{ "SourceLanguageCode": "string", "TargetLanguageCode": "string", "Text": "string"}

Request ParametersFor information about the parameters that are common to all actions, see Common Parameters (p. 60).

The request accepts the following data in JSON format.

SourceLanguageCode (p. 56)

One of the supported language codes for the source text. If the TargetLanguageCode is not "en", theSourceLanguageCode must be "en".

To have Amazon Translate determine the source language of your text, you can specify auto in theSourceLanguageCode field. If you specify auto, Amazon Translate will call Amazon Comprehend todetermine the source language.

Type: String

Length Constraints: Minimum length of 2. Maximum length of 5.

Required: YesTargetLanguageCode (p. 56)

One of the supported language codes for the target text. If the SourceLanguageCode is not "en", theTargetLanguageCode must be "en".

56


Type: String


Required: YesText (p. 56)

The text to translate. The text string can be a maximum of 5,000 bytes long. Depending on yourcharacter set, this may be fewer than 5,000 characters.

Type: String


Required: Yes

Response Syntax

{ "SourceLanguageCode": "string", "TargetLanguageCode": "string", "TranslatedText": "string"}

Response ElementsIf 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. 57)

The language code for the language of the input text.

Type: String

Length Constraints: Minimum length of 2. Maximum length of 5.TargetLanguageCode (p. 57)

The language code for the language of the translated text.

Type: String

Length Constraints: Minimum length of 2. Maximum length of 5.TranslatedText (p. 57)

The text translated into the target language.

Type: String

Length Constraints: Minimum length of 1.

ErrorsFor information about the errors that are common to all actions, see Common Errors (p. 59).

57


DetectedLanguageLowConfidenceException

The confidence that Amazon Comprehend accurately detected the source language is low. If a lowconfidence level is acceptable for your application, you can use the language in the exception to callAmazon Translate again. For more information, see the DetectDominantLanguage operation in theAmazon Comprehend Developer Guide.

HTTP Status Code: 400InternalServerException

An internal server error occurred. Retry your request.

HTTP Status Code: 500InvalidRequestException

The request is invalid.

HTTP Status Code: 400ServiceUnavailableException

Amazon Translate is unavailable. Retry your request later.

HTTP Status Code: 400TextSizeLimitExceededException

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

HTTP Status Code: 400TooManyRequestsException

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

HTTP Status Code: 400UnsupportedLanguagePairException

Amazon Translate cannot translate input text in the source language into this target language. Formore information, see Gestion des exceptions (p. 4).

HTTP Status Code: 400

See AlsoFor 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

58

https://docs.aws.amazon.com/comprehend/latest/dg/API_DetectDominantLanguage.html

https://docs.aws.amazon.com/goto/aws-cli/translate-2017-07-01/TranslateText

https://docs.aws.amazon.com/goto/DotNetSDKV3/translate-2017-07-01/TranslateText

https://docs.aws.amazon.com/goto/SdkForCpp/translate-2017-07-01/TranslateText

https://docs.aws.amazon.com/goto/SdkForGoV1/translate-2017-07-01/TranslateText

https://docs.aws.amazon.com/goto/SdkForJava/translate-2017-07-01/TranslateText

https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/translate-2017-07-01/TranslateText

https://docs.aws.amazon.com/goto/SdkForPHPV3/translate-2017-07-01/TranslateText

https://docs.aws.amazon.com/goto/boto3/translate-2017-07-01/TranslateText

https://docs.aws.amazon.com/goto/SdkForRubyV2/translate-2017-07-01/TranslateText

Amazon Translate Manuel du développeurData Types

Data TypesThere are no separate data types in this API.

Common ErrorsThis section lists the errors common to the API actions of all AWS services. For errors specific to an APIaction for this service, see the topic for that API action.

AccessDeniedException

You do not have sufficient access to perform this action.

HTTP Status Code: 400IncompleteSignature

The request signature does not conform to AWS standards.

HTTP Status Code: 400InternalFailure

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

HTTP Status Code: 500InvalidAction

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

HTTP Status Code: 400InvalidClientTokenId

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

HTTP Status Code: 403InvalidParameterCombination

Parameters that must not be used together were used together.

HTTP Status Code: 400InvalidParameterValue

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

HTTP Status Code: 400InvalidQueryParameter

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

HTTP Status Code: 400MalformedQueryString

The query string contains a syntax error.


59

Amazon Translate Manuel du développeurCommon Parameters

MissingAction

The request is missing an action or a required parameter.

HTTP Status Code: 400MissingAuthenticationToken

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

HTTP Status Code: 403MissingParameter

A required parameter for the specified action is not supplied.

HTTP Status Code: 400OptInRequired

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

HTTP Status Code: 403RequestExpired

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

HTTP Status Code: 400ServiceUnavailable

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

HTTP Status Code: 503ThrottlingException

The request was denied due to request throttling.

HTTP Status Code: 400ValidationError

The input fails to satisfy the constraints specified by an AWS service.


Common ParametersThe following list contains the parameters that all actions use for signing Signature Version 4 requests witha query string. Any action-specific parameters are listed in the topic for that action. For more informationabout Signature Version 4, see Signature Version 4 Signing Process in the Amazon Web Services GeneralReference.

Action

The action to be performed.

Type: string

Required: Yes

60



Version

The API version that the request is written for, expressed in the format YYYY-MM-DD.

Type: string

Required: YesX-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 insteadof in the HTTP authorization header.

Type: string

Valid Values: AWS4-HMAC-SHA256

Required: ConditionalX-Amz-Credential

The credential scope value, which is a string that includes your access key, the date, the region youare targeting, the service you are requesting, and a termination string ("aws4_request"). The value isexpressed 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 WebServices General Reference.


Type: string

Required: ConditionalX-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 signingrequests. 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, seeHandling Dates in Signature Version 4 in the Amazon Web Services General Reference.

Type: string

Required: ConditionalX-Amz-Security-Token

The temporary security token that was obtained through a call to AWS Security Token Service (AWSSTS). For a list of services that support temporary security credentials from AWS Security TokenService, 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, youmust include the security token.

Type: string

Required: Conditional

61

http://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html

http://docs.aws.amazon.com/general/latest/gr/sigv4-date-handling.html

http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html


X-Amz-Signature

Specifies the hex-encoded signature that was calculated from the string to sign and the derived signingkey.


Type: string

Required: ConditionalX-Amz-SignedHeaders

Specifies all the HTTP headers that were included as part of the canonical request. For moreinformation about specifying signed headers, see Task 1: Create a Canonical Request For SignatureVersion 4 in the Amazon Web Services General Reference.


Type: string

Required: Conditional

62

http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html

http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html


Glossaire AWSPour la terminologie AWS la plus récente, consultez le Glossaire AWS dans le document AWS GeneralReference.

63

http://docs.aws.amazon.com/general/latest/gr/glos-chap.html

Date post:	13-Sep-2018
Category:	Documents
Upload:	lytram
View:	213 times
Download:	0 times

Manuel du développeur · 2018-08-31 · Mise en route ... à l'aide du code de la langue...

Documents