Amazon Polly - Manuel du développeur

Transcription

Amazon Polly
Manuel du développeur
Amazon Polly Manuel du développeur
Amazon Polly: Manuel du développeur
Copyright © 2017 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any
manner that is likely to cause confusion among customers, or in any manner that disparages or discredits Amazon. All other
trademarks not owned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to,
or sponsored by Amazon.
Table of Contents
Définition d'Amazon Polly ............................................................................................................... 1
Vous utilisez Amazon Polly pour la première fois ? .................................................................... 2
Fonctionnement ............................................................................................................................ 3
Quelle est la prochaine étape ? .............................................................................................. 3
Mise en route ............................................................................................................................... 5
Étape 1 : Configurer un compte et un utilisateur ........................................................................ 5
Étape 1.1 : S'inscrire à AWS .......................................................................................... 5
Étape 1.2 : Création d'un utilisateur IAM ........................................................................... 6
Étape suivante ............................................................................................................. 7
Étape 2 : Démarrer à l'aide de la console ................................................................................. 7
Exercice 1 : Procédure de démarrage rapide Synthèse vocale (Console) ............................... 7
Exercice 2 : Synthèse vocale (entrée de texte brut) ............................................................ 7
Étape suivante ............................................................................................................. 8
Étape 3 : Démarrer à l'aide de l'AWS CLI ................................................................................. 8
Étape 3.1 : Configuration de l'AWS CLI ............................................................................ 8
Étape 3.2 : Exercice de mise en route ............................................................................ 10
Quelle est la prochaine étape ? ............................................................................................. 12
Configuration de Python et test d'un exemple .................................................................. 12
Utilisation de SSML ..................................................................................................................... 14
Utilisation de SSML avec la console ...................................................................................... 14
Utilisation de SSML avec la console Amazon Polly ........................................................... 14
Étape suivante ............................................................................................................ 15
Utilisation de SSML avec l'AWS CLI ...................................................................................... 15
Exemple 1 : Transmission de SSML via la commande de synthèse vocale ............................ 15
Exemple 2 : Synthétiser un document SSML entier ........................................................... 16
Exemple 3 : Utilisation des balises SSML courantes ......................................................... 16
Exemple 4 : Contrôle de la prononciation ........................................................................ 19
Gestion des lexiques ................................................................................................................... 21
Application de plusieurs lexiques ........................................................................................... 21
Gestion des lexiques à l'aide de la console ............................................................................. 22
Chargement des lexiques à l'aide de la console ............................................................... 23
Application de lexiques à l'aide de la console (Synthèse vocale) ......................................... 23
Filtrage de la liste des lexiques à l'aide de la console ....................................................... 24
Téléchargement des lexiques à l'aide de la console .......................................................... 25
Suppression d'un lexique à l'aide de la console ............................................................... 25
Gestion des lexiques à l'aide d'AWS CLI ................................................................................ 25
PutLexicon ................................................................................................................. 26
GetLexicon ................................................................................................................. 31
ListLexicons ................................................................................................................ 33
DeleteLexicon ............................................................................................................. 34
Exemples d'applications ............................................................................................................... 36
Exemple Python .................................................................................................................. 37
Exemple Python : index.html ......................................................................................... 38
Exemple Python : server.py .......................................................................................... 41
Exemple Android ................................................................................................................. 48
Exemple iOS ...................................................................................................................... 50
Restrictions ................................................................................................................................ 52
Régions prises en charge ..................................................................................................... 52
Limitation ........................................................................................................................... 52
Lexiques de prononciation .................................................................................................... 53
Opération API SynthesizeSpeech .......................................................................................... 53
Synthèse vocale SSML (Markup Language) ............................................................................ 53
Intégration de CloudTrail .............................................................................................................. 54
Informations relatives à Amazon Polly dans CloudTrail .............................................................. 54
Présentation des entrées des fichiers journaux Amazon Polly ..................................................... 55
iv
Intégration de CloudWatch ........................................................................................................... 57
Métriques CloudWatch (Console) ........................................................................................... 57
Métriques CloudWatch (Interface de ligne de commande) .......................................................... 57
Métriques Amazon Polly ....................................................................................................... 58
Dimensions pour les métriques Amazon Polly .......................................................................... 59
API Reference ............................................................................................................................ 60
Actions .............................................................................................................................. 60
DeleteLexicon ............................................................................................................. 61
DescribeVoices ........................................................................................................... 63
GetLexicon ................................................................................................................. 65
ListLexicons ................................................................................................................ 67
PutLexicon ................................................................................................................. 69
SynthesizeSpeech ....................................................................................................... 71
Data Types ........................................................................................................................ 73
Lexicon ...................................................................................................................... 74
LexiconAttributes ......................................................................................................... 75
LexiconDescription ...................................................................................................... 76
Voice ......................................................................................................................... 77
Authentification et contrôle d'accès ................................................................................................ 78
Authentification ................................................................................................................... 78
Contrôle d'accès ................................................................................................................. 79
Présentation de la gestion de l'accès ..................................................................................... 80
Ressources et opérations Amazon Polly ......................................................................... 80
Présentation de la propriété des ressources .................................................................... 81
Gestion de l'accès aux ressources ................................................................................. 81
Spécification des éléments d'une stratégie : actions, effets et mandataires ............................ 82
Spécification des conditions dans une stratégie ............................................................... 83
Utilisation des stratégies basées sur une identité (stratégies IAM) ............................................... 83
Autorisations requises pour utiliser la console Amazon Polly .............................................. 84
Stratégies gérées par AWS (stratégies prédéfinies) pour Amazon Polly ................................ 85
Exemples de stratégies gérées par le client .................................................................... 85
Référence des autorisations de l'API Amazon Polly .................................................................. 88
Historique du document ............................................................................................................... 90
Glossaire AWS ........................................................................................................................... 91
v
Définition d'Amazon Polly
Amazon Polly est un service de cloud qui convertit un texte en un discours réaliste. Vous pouvez
utiliser Amazon Polly pour développer des applications qui optimisent l'implication et améliorent
l'accessibilité. Amazon Polly prend en charge plusieurs langues et propose différentes voix réelles, ce
qui vous permet d'élaborer des synthèses vocales adaptées à plusieurs endroits et d'utiliser la voix
idéale pour vos clients. Avec Amazon Polly, vous ne payez que pour le texte que vous avez synthétisé.
Vous pouvez également mettre en cache et réécouter le discours généré d'Amazon Polly sans frais
supplémentaire.
Les cas d'utilisation courants d'Amazon Polly incluent, sans s'y limiter, des applications mobiles telles
que des lecteurs, des jeux, des plateformes d'apprentissage en ligne, des applications pour personnes
malvoyantes, ainsi que le secteur en forte expansion de l'Internet des objets (IdO).
Amazon Polly n'est pas certifié pour être utilisé avec des charges de travail réglementées comme
la norme PCI (Payment Card Industry) DSS (Data Security Standard), HIPAA (Health Insurance
Portability and Accountability Act de 1996) ou FedRAMP.
Parmi les avantages liés à l'utilisation d'Amazon Polly, on note :
• Haute qualité – Amazon Polly utilise une technologie de synthèse vocale (TTS) de première
qualité pour synthétiser le discours naturel avec une précision élevée de prononciation (comprenant
notamment les abréviations, les expansions d'acronymes, les interprétations de date/heure et la
désambiguïsation des homographes).
• Faible latence – Amazon Polly garantit des temps de réponse rapides, qui en font une option viable
pour des cas d'utilisation à faible latence tels que les systèmes de dialogue.
• Prise en charge d'un large éventail de langues et de voix – Amazon Polly prend en charge
47 voix et 24 langues, avec des options de voix d'hommes et de femmes pour la plupart des
langues.
• Rentabilité – Le modèle de paiement uniquement à l'utilisation d'Amazon Polly implique qu'il n'y a
aucun coût d'installation. Vous pouvez commencer sur une petite échelle et augmenter au fur et à
mesure du développement de votre application.
• Solution basée sur le Cloud – Solutions de synthèse vocale sur l'appareil qui nécessitent des
ressources informatiques conséquentes, notamment la puissance de l'UC, la mémoire RAM
1
Vous utilisez Amazon Polly pour la première fois ?
et l'espace disque. Elles peuvent entraîner des coûts de développement plus élevés et une
consommation d'énergie plus importante sur des appareils tels que des tablettes, des smartphones,
etc. En revanche, la conversion d'un texte en voix effectuée dans le cloud permet de réduire
considérablement les besoins en ressources locales. Cela permet de prendre en charge toutes
les langues et les voix disponibles avec la meilleure qualité possible. En outre, des améliorations
au niveau des discours sont instantanément disponibles pour tous les utilisateurs finaux et ne
requièrent pas d'autres mises à jour au niveau des appareils.
Vous utilisez Amazon Polly pour la première fois ?
Si vous utilisez le service Amazon Polly pour la première fois, nous vous recommandons de lire les
sections suivantes dans l'ordre indiqué :
1. Amazon Polly : fonctionnement (p. 3) – Cette section présente différentes données à saisir et
différentes options d'Amazon Polly que vous pouvez utiliser tout au long du processus.
2. Mise en route avec Amazon Polly (p. 5)– Dans cette section, vous configurez votre compte et
testez la synthèse vocale d'Amazon Polly.
3. Exemples d'applications (p. 36) – Cette section fournit des exemples supplémentaires que
vous pouvez utiliser pour explorer Amazon Polly.
2
Quelle est la prochaine étape ?
Amazon Polly : fonctionnement
Amazon Polly convertit le texte saisi en discours avec une voix humaine. Vous devez simplement
appeler la méthode SynthesizeSpeech, saisir le texte à synthétiser, sélectionner l'une des voix de
synthèse vocale (TTS) disponibles et spécifier un format de sortie audio. Amazon Polly synthétise
ensuite le texte fourni dans un flux audio de transmission vocale de grande qualité.
• Texte saisi – fournit le texte que vous voulez synthétiser, et Amazon Polly retourne un flux de
données audio. Vous pouvez fournir les données d'entrée sous forme de texte brut ou au format de
synthèse vocale SSML (Markup Language). Avec SSML, vous pouvez contrôler différents aspects
du discours tels que la prononciation, le volume, le contenu audio et le débit de parole. Pour plus
d'informations, consultez Utilisation de SSML (p. 14).
• Voix disponibles – Amazon Polly vous propose toute un éventail de langues et de voix. Pour
la plupart des langues, différentes voix vous sont proposées, notamment des voix d'hommes et
de femmes. Vous devez spécifier uniquement le nom de la voix lorsque vous appelez l'opération
SynthesizeSpeech, le service utilise alors cette voix pour convertir le texte en discours. Amazon
Polly n'est pas un service de traduction — la synthèse vocale est dans la langue du texte. Les
nombres utilisant des chiffres (par exemple, 53, et non cinquante-trois) sont synthétisées dans la
langue de la voix.
• Format de sortie – Amazon Polly peut fournir une synthèse vocale dans plusieurs formats. Vous
pouvez sélectionner le format audio adapté à vos besoins. Par exemple, vous pouvez demander
le discours au format MP3 ou Ogg Vorbis pour l'utiliser dans les applications web et mobiles. Vous
pouvez également demander le format de sortie PCM pour les appareils AWS IoT et les solutions de
téléphonie.
Si vous utilisez Amazon Polly pour la première fois, nous vous conseillons de lire les rubriques
suivantes dans l'ordre indiqué :
• Mise en route avec Amazon Polly (p. 5)
• Exemples d'applications (p. 36)
• Limites d'Amazon Polly (p. 52)
3
4
Étape 1 : Configurer un compte et un utilisateur
Mise en route avec Amazon Polly
Amazon Polly fournit des opérations API simples que vous pouvez intégrer facilement à vos
applications existantes. Pour une liste des opérations prises en charge, consultez Actions (p. 60).
Vous pouvez utiliser l'une des options suivantes :
• AWS SDK – lorsque vous utilisez les kits de développement logiciel, vos demandes adressées
à Amazon Polly sont automatiquement signées et authentifiées à l'aide des informations
d'identification fournies. Ce choix est recommandé dans le cadre du développement de vos
applications.
• AWS CLI – vous pouvez utiliser l'interface AWS CLI pour accéder à n'importe quelle fonctionnalité
Amazon Polly sans écrire de code.
Les sections suivantes décrivent comment préparer et fournir un exercice d'introduction.
Rubriques
• Étape 1 : Configurer un compte AWS et créer un utilisateur (p. 5)
• Étape 2 : Démarrer à l'aide de la console (p. 7)
• Étape 3 : Démarrer à l'aide de l'AWS CLI (p. 8)
• Quelle est la prochaine étape ? (p. 12)
Étape 1 : Configurer un compte AWS et créer un
utilisateur
Avant d'utiliser Amazon Polly pour la première fois, effectuez les tâches suivantes :
1. Étape 1.1 : S'inscrire à AWS (p. 5)
2. Étape 1.2 : Création d'un utilisateur IAM (p. 6)
Étape 1.1 : S'inscrire à AWS
Lors de votre inscription à Amazon Web Services (AWS), votre compte AWS est automatiquement
inscrit à tous les services AWS, y compris Amazon Polly. Seuls les services que vous utilisez vous
sont facturés.
5
Étape 1.2 : Création d'un utilisateur IAM
Avec Amazon Polly, vous ne payez que les ressources que vous utilisez. Si vous êtes un nouveau
client AWS, vous pouvez commencer à utiliser Amazon Polly gratuitement. Pour plus d'informations,
consultez la page Niveau d'offre gratuite d'AWS.
Si vous possédez déjà un compte AWS, vous pouvez ignorer la prochaine étape. Si ce vous ne
disposez pas d'un compte AWS, effectuez les étapes de la procédure suivante pour en créer un.
Pour créer un compte AWS
1.
2.
Ouvrez https://aws.amazon.com/, puis choisissez Create an AWS Account.
Suivez les instructions en ligne.
Dans le cadre de la procédure d'inscription, vous recevrez un appel téléphonique et vous saisirez
un code PIN en utilisant le clavier numérique du téléphone.
Notez votre ID de compte AWS, car vous en aurez besoin lors de la prochaine étape.
Étape 1.2 : Création d'un utilisateur IAM
Pour accéder à un service d'AWS, comme Amazon Polly, vous devez fournir vos informations
d'identification afin que le service puisse déterminer si vous êtes autorisé à accéder à ses ressources.
La console exige votre mot de passe. Vous pouvez créer des clés d'accès pour votre compte AWS afin
d'accéder à l'AWS CLI ou à l'API. Cependant, nous vous déconseillons d'accéder à AWS à l'aide des
informations d'identification de votre compte AWS. Au lieu de cela, nous vous recommandons d'utiliser
AWS Identity and Access Management (IAM). Créez un utilisateur IAM, ajoutez-le à un groupe IAM
disposant d'autorisations d'administration, puis attribuez ces autorisations à cet utilisateur. Vous
pouvez ensuite accéder à AWS à l'aide d'une URL spéciale et des informations d'identification de cet
utilisateur IAM.
Si vous êtes inscrit à AWS, mais que vous n'avez pas créé d'utilisateur IAM pour vous-même, vous
pouvez le faire avec la console IAM.
Les exercices de mise en route de ce guide présument que l'utilisateur (adminuser) dispose de
privilèges d'administrateur. Suivez la procédure pour créer adminuser dans votre compte.
Pour créer un administrateur et vous connecter à la console
1.
2.
Créez un administrateur appelé adminuser dans votre compte AWS. Pour obtenir
des instructions, consultez la section Création de votre premier groupe d'utilisateurs et
d'administrateurs IAM dans le IAM Guide de l'utilisateur.
Un utilisateur peut se connecter à la AWS Management Console à l'aide d'une URL spéciale. Pour
plus d'informations, consultez Comment les utilisateurs se connectent à votre compte dans le IAM
Guide de l'utilisateur.
Important
Les exercices de mise en route utilisent les informations d'identification adminuser. Pour plus
de sécurité, lors du développement et des tests de vérification de l'application de production,
nous vous recommandons de créer un administrateur spécifique aux services qui dispose
d'autorisations uniquement pour les actions d'Amazon Polly. Pour obtenir un exemple de
stratégie qui accorde des autorisations spécifiques Amazon Polly, consultez la page Exemple
1 : Autoriser toutes les actions Amazon Polly (p. 86).
Pour plus d'informations sur IAM, consultez les ressources suivantes :
• Identity and Access Management (IAM)
• Mise en route
6
Étape suivante
• IAM Guide de l'utilisateur
Étape suivante
Étape 2 : Démarrer à l'aide de la console (p. 7)
Étape 2 : Démarrer à l'aide de la console
La console Amazon Polly est le moyen le plus simple pour commencer à tester et à utiliser la synthèse
vocale d'Amazon Polly. La console Amazon Polly prend en charge la synthèse vocale à partir d'un
texte brut ou d'une entrée SSML.
Rubriques
• Exercice 1 : Procédure de démarrage rapide Synthèse vocale (Console) (p. 7)
• Exercice 2 : Synthèse vocale (entrée de texte brut) (p. 7)
• Étape suivante (p. 8)
Exercice 1 : Procédure de démarrage rapide
Synthèse vocale (Console)
Cette procédure est le moyen le plus rapide pour tester la qualité audio de la synthèse vocale
d'Amazon Polly. Lorsque vous sélectionnez l'onglet Text-to-Speech, le champ de saisie de votre texte
est préchargé avec l'exemple de texte afin que vous puissiez tester rapidement Amazon Polly.
Pour tester rapidement Amazon Polly
1.
2.
Connectez-vous à AWS Management Console et ouvrez la console Amazon Polly à partir de
l'adresse https://console.aws.amazon.com/polly/.
Choisissez l'onglet Text-to-Speech.
3.
4.
Vous pouvez également choisir SSML.
Sélectionnez une langue et une région, puis sélectionnez une voix.
5.
Choisissez Listen to speech.
Pour des tests plus approfondis, veuillez consulter les rubriques suivantes :
• Utilisation de SSML avec la console Amazon Polly (p. 14)
• Application de lexiques à l'aide de la console (Synthèse vocale) (p. 23)
Exercice 2 : Synthèse vocale (entrée de texte brut)
La procédure suivante résume le discours à partir d'un texte brut. Notez la façon dont « W3C » et la
date « 10/3 » (3 octobre) sont synthétisés.
Pour synthétiser le discours à partir d'un texte brut
1.
2.
Une fois que vous vous êtes connecté à la console Amazon Polly, choisissez Get started, puis
l'onglet Text-to-Speech.
Choisissez l'onglet Plain text.
7
Étape suivante
3.
Entrez ou collez ce texte dans la zone d'entrée.
He was caught up in the game.
In the middle of the 10/3/2014 W3C meeting
he shouted, "Score!" quite loudly.
4.
Dans Choose a language and region, choisissez English US, puis choisissez la voix que vous
voulez utiliser pour ce texte.
5.
6.
Pour écouter le discours immédiatement, choisissez Listen to speech.
Pour enregistrer le discours dans un fichier, exécutez l'une des actions suivantes :
a.
Choisissez Save speech to MP3.
b.
Pour opter pour un format de fichier différent, choisissez Change file format, sélectionnez le
format de fichier que vous souhaitez, puis choisissez Change.
Pour obtenir des exemples plus détaillés, choisissez les rubriques suivantes :
• Utilisation de SSML avec la console Amazon Polly (p. 14)
Étape suivante
Étape 3 : Démarrer à l'aide de l'AWS CLI (p. 8)
Étape 3 : Démarrer à l'aide de l'AWS CLI
A l'aide de l'AWS CLI, vous pouvez exécuter presque toutes les opérations Amazon Polly que vous
pouvez exécuter à l'aide de la console Amazon Polly. Vous ne pouvez pas écouter la synthèse vocale
à l'aide de l'AWS CLI. Au lieu de cela, vous devez l'enregistrer dans un fichier, puis ouvrir le fichier
dans une application qui peut lire ce fichier.
Rubriques
• Étape 3.1 : Configuration de l'AWS Command Line Interface (AWS CLI) (p. 8)
• Étape 3.2 : Effectuer un exercice de mise en route à l'aide d'AWS CLI (p. 10)
Étape 3.1 : Configuration de l'AWS Command Line
Interface (AWS CLI)
Suivez les étapes pour télécharger et configurer l'AWS Command Line Interface (AWS CLI).
Important
Vous n'avez pas besoin de l'AWS CLI pour effectuer les étapes de cet exercice de mise en
route. Cependant, quelques-uns des exercices de ce guide l'utilisent l'AWS CLI. Vous pouvez
ignorer cette étape et passer à Étape 3.2 : Effectuer un exercice de mise en route à l'aide
d'AWS CLI (p. 10), puis configurer l'AWS CLI plus tard lorsque vous en aurez besoin.
Pour configurer l'AWS CLI.
1.
Téléchargez et configurez l'AWS CLI. Pour obtenir des instructions, consultez les rubriques
suivantes AWS Command Line Interface Guide de l'utilisateur:
• Préparation de l'installation de l'AWS Command Line Interface
8
Étape 3.1 : Configuration de l'AWS CLI
• Configuration de l'AWS Command Line Interface
2.
Ajoutez un profil désigné pour l'utilisateur administrateur dans le fichier de configuration de
l'AWS CLI. Vous utiliserez ce profil lorsque vous exécuterez les commandesAWS CLI. Pour
plus d'informations sur les profils nommés (désignés), consultez Profils nommés dans le AWS
Command Line Interface Guide de l'utilisateur.
[profile adminuser]
aws_access_key_id = adminuser access key ID
aws_secret_access_key = adminuser secret access key
region = aws-region
Pour obtenir la liste des régions AWS disponibles et celles qui sont prises en charge par Amazon
Polly, consultez la section Régions et points de terminaison dans le Référence générale d'Amazon
Web Services.
Si vous spécifiez l'une des régions prises en charge par Amazon Polly lorsque vous configurez
l'AWS CLI, vous pouvez ignorer la ligne suivante à partir des de exemples de code AWS CLI. Si
vous spécifiez une région non prise en charge par Amazon Polly dans votre configuration AWS
CLI (par exemple, si vous êtes un client AWS existant utilisant d'autres services dans des régions
qui ne prennent en charge Amazon Polly), vous devez inclure la ligne suivante :
--region polly-supported-aws-region
3.
Vérifiez la configuration en saisissant la commande d'aide suivante à l'invite de commande :
aws help
Une liste de commandes AWS valides doit apparaître dans la fenêtre AWS CLI.
Pour activer Amazon Polly dans l'AWS CLI (facultatif)
Si vous avez déjà téléchargé et configuré l'AWS CLI, Amazon Polly peut ne pas être disponible si vous
ne reconfigurez pas l'AWS CLI. Cette procédure vérifie si cette étape est nécessaire et fournit des
instructions si Amazon Polly n'est pas disponible automatiquement.
1.
Vérifiez la disponibilité d'Amazon Polly en saisissant la commande d'aide suivante à l'invite de
commande :
aws polly help
Si une description d'Amazon Polly et une liste des commandes valides s'affichent, elles sont
visibles dans la fenêtre AWS CLI. Si Amazon Polly est disponible dans l'AWS CLI, le service peut
être utilisé immédiatement. Dans ce cas, vous pouvez ignorer le reste de cette procédure. Si ces
informations ne sont pas affichées, passez à l'étape 2.
2.
Utilisez l'une des deux options suivantes pour activer Amazon Polly :
• Désinstallez, puis réinstallez l'AWS CLI.
Pour obtenir des instructions, consultez la rubrique suivante dans le AWS Command Line
Interface Guide de l'utilisateur : Installation de l'AWS Command Line Interface.
ou
• Ajoutez le service Amazon Polly séparément à l'AWS CLI
9
Étape 3.2 : Exercice de mise en route
a.
Téléchargez le fichier service-2.json.
b.
A l'invite de commande, exécutez la commande suivante :
aws configure add-model --service-model file://service-2.json -service-name polly
<step>
Revérifiez la disponibilité d'Amazon Polly :
aws polly help
La description d'Amazon Polly doit être visible.
</step>
Étape suivante
Étape 3.2 : Effectuer un exercice de mise en route à l'aide d'AWS CLI (p. 10)
Étape 3.2 : Effectuer un exercice de mise en route à
l'aide d'AWS CLI
Vous pouvez désormais tester la synthèse vocale fournie par Amazon Polly. Dans cet exercice, vous
appelez l'opération SynthesizeSpeech en fournissant l'exemple de texte. Vous pouvez enregistrer le
son qui en résulte dans un fichier et vérifier son contenu.
Si vous avez spécifié l'une des régions prises en charge par Amazon Polly lorsque vous avez configuré
l'AWS CLI, vous pouvez ignorer la ligne suivante à partir des de exemples de code AWS CLI. Si vous
avez spécifié une région non prise en charge par Amazon Polly dans votre configuration AWS CLI
(par exemple, si vous êtes un client AWS existant qui utilise d'autres services dans des régions qui ne
prennent pas en charge Amazon Polly), vous devez inclure la ligne suivante :
--region polly-supported-aws-region
1.
Exécutez la commande AWS CLI synthesize-speech pour synthétiser l'exemple de texte dans
un fichier audio (hello.mp3).
L'exemple d'AWS CLI suivant est mis en forme pour OS X, Linux et Unix. Pour exécuter cet
exemple à l'invite de commande Windows, remplacez le caractère de continuation Unix (\) à la fin
de chaque ligne par le caractère de continuation Windows (^).
aws polly synthesize-speech \
--output-format mp3 \
--voice-id Joanna \
--text "Hello, my name is Joanna. I learned about the W3C on 10/3 of
last year." \
hello.mp3
Dans l'appel de synthesize-speech, vous fournissez le texte modèle pour la synthèse, la voix
à utiliser (en fournissant un ID vocal, comme expliqué dans l'étape 3 suivante), ainsi que le format
de sortie. La commande enregistre l'audio qui en résulte dans le fichier hello.mp3.
10
Étape 3.2 : Exercice de mise en route
En plus du fichier MP3, l'opération, ci-dessus, génère la sortie suivante dans la console.
{
"ContentType": "audio/mpeg",
"RequestCharacters": "71"
}
2.
Lisez le fichier hello.mp3 pour vérifier la synthèse vocale.
3.
Vous pouvez obtenir la liste des voix disponibles en utilisant l'opération DescribeVoices.
Exécutez la commande AWS CLI describe-voices suivante.
aws polly describe-voices
En réponse, Amazon Polly renvoie la liste de toutes les voix disponibles. Pour chaque voix, la
réponse fournit les métadonnées suivantes : ID vocal, code et nom de la langue, et genre de la
voix. Voici un exemple de réponse :
{
"Voices": [
{
"Gender": "Female",
"Name": "Salli",
"LanguageName": "US English",
"Id": "Salli",
"LanguageCode": "en-US"
},
{
"Gender": "Female",
"Name": "Joanna",
"LanguageName": "US English",
"Id": "Kendra",
"LanguageCode": "en-US"
}
]
}
Le cas échéant, vous pouvez spécifier le code de langue pour trouver les voix disponibles pour
une langue spécifique. Amazon Polly prend en charge 47 voix. L'exemple suivant répertorie toutes
les voix pour le portugais brésilien.
aws polly describe-voices \
--language-code pt-BR
Pour obtenir la liste des codes de langue, consultez la page DescribeVoices (p. 63). Ces
codes de langue sont des balises d'identification de langue W3C (code ISO 639 pour le nom
de la langue-code du pays ISO 3166). Par exemple, en-US (anglais Etats-Unis), en-GB
(anglais Royaume-Uni) et es-ES (Espagnol), etc.
Vous pouvez également utiliser l'option help dans l'AWS CLI pour obtenir la liste des codes de
langue :
aws polly describe-voices help
11
Ce guide fournit des exemples supplémentaires, dont certains sont des exemples de code Python qui
utilisent AWS SDK for Python (Boto) pour effectuer des appels d'API vers Amazon Polly. Nous vous
recommandons de configurer Python et de tester l'exemple de code fourni dans la section suivante.
Pour accéder à des exemples supplémentaires, consultez Exemples d'applications (p. 36).
Configuration de Python et test d'un exemple
Pour tester le code d'exemple Python, vous devez utiliser AWS SDK for Python (Boto). Pour obtenir
des instructions, consultez la page AWS SDK pour Python (Boto3).
Pour tester le code d'exemple Python
L'exemple de code Python suivant exécute les tâches suivantes :
• Utilise le AWS SDK for Python (Boto) pour envoyer une demande SynthesizeSpeech à Amazon
Polly (en fournissant un texte simple comme entrée).
• Accède au flux audio résultant dans la réponse et enregistre l'audio dans un fichier sur votre disque
local (speech.mp3).
• Lit le fichier audio avec le lecteur audio par défaut de votre système local.
Enregistre le code dans un fichier (example.py) et l'exécute.
"""Getting Started Example for Python 2.7+/3.3+"""
from boto3 import Session
from botocore.exceptions import BotoCoreError, ClientError
from contextlib import closing
import os
import sys
import subprocess
from tempfile import gettempdir
# Create a client using the credentials and region defined in the [adminuser]
# section of the AWS credentials file (~/.aws/credentials).
session = Session(profile_name="adminuser")
polly = session.client("polly")
try:
# Request speech synthesis
response = polly.synthesize_speech(Text="Hello world!",
OutputFormat="mp3",
VoiceId="Joanna")
except (BotoCoreError, ClientError) as error:
# The service returned an error, exit gracefully
print(error)
sys.exit(-1)
# Access the audio stream from the response
if "AudioStream" in response:
# Note: Closing the stream is important as the service throttles on the
# number of parallel connections. Here we are using contextlib.closing to
# ensure the close method of the stream object will be called
automatically
# at the end of the with statement's scope.
with closing(response["AudioStream"]) as stream:
output = os.path.join(gettempdir(), "speech.mp3")
12
Configuration de Python et test d'un exemple
try:
# Open a file for writing the output as a binary stream
with open(output, "wb") as file:
file.write(stream.read())
except IOError as error:
# Could not write to file, exit gracefully
print(error)
sys.exit(-1)
else:
# The response didn't contain audio data, exit gracefully
print("Could not stream audio")
sys.exit(-1)
# Play the audio using the platform's default player
if sys.platform == "win32":
os.startfile(output)
else:
# the following works on Mac and Linux. (Darwin = mac, xdg-open = linux).
opener = "open" if sys.platform == "darwin" else "xdg-open"
subprocess.call([opener, output])
Pour obtenir des exemples supplémentaires, notamment un exemple d'application, consultez la page
Exemples d'applications (p. 36).
13
Utilisation de SSML avec la console
Utilisation de SSML
Amazon Polly génère du discours à partir de documents SSML de texte brut (Markup Language) qui
sont conformes à la version 1.1 de SSML. A l'aide de balises SSML, vous pouvez personnaliser et
contrôler les aspects de discours tels que la prononciation, le volume et le débit de parole.
Amazon Polly prend en charge SSML 1.1, tel que défini dans la recommandation W3C suivante :
• Synthèse vocale SSML (Markup Language) Version 1.1, recommandation W3C 7 septembre 2010
Certains des éléments de la recommandation W3C SSML ne sont pas pris en charge. Pour plus
d'informations, consultez Limites d'Amazon Polly (p. 52).
Cette section fournit des exemples simples de SSML qui peuvent être utilisés pour générer et contrôler
la sortie vocale. Les exemples fournissent également la commande AWS CLI synthesize-speech
pour tester ces exemples.
Utilisation de SSML avec la console Amazon
Polly
Amazon Polly prend en charge le langage SSML version 1.1, tel que défini par le W3C. Cette section
explique comment utiliser l'entrée SSML pour la synthèse vocale dans la console Amazon Polly.
Utilisation de SSML avec la console Amazon Polly
La procédure suivante synthétise le discours à l'aide d'une entrée SSML. A l'exception des étapes 3 et
4 ci-dessous, les étapes de cet exemple sont identiques à celles de Exercice 2 : Synthèse vocale
(entrée de texte brut) (p. 7).
Pour synthétiser le discours à l'aide de la console Amazon Polly (entrée SSML)
Dans cet exemple, nous vous présentons le balisage SSML pour remplacer « World Wide Web
Consortium » par « W3C ». Comparez les résultats de cet exercice à ceux de Application de lexiques
à l'aide de la console (Synthèse vocale) (p. 23) à la fois pour l'anglais (Etats-Unis) et pour une autre
langue.
1.
14
Étape suivante
2.
Choisissez Get started, puis, si nécessaire, l'onglet Text-to-Speech.
3.
Choisissez l'onglet SSML.
4.
Tapez ou collez le texte suivant dans la zone de texte :
<speak>He was caught up in the game.<break time="1s"/>
In the middle of the 10/3/2014 <sub alias="World Wide
Web
Consortium">W3C</sub> meeting
he shouted, "Score!" quite loudly.</speak>
Les balises SSML informent Amazon Polly que le texte doit être rendu dans une manière
spécifiée.
• <break time="1s"/> indique à Amazon Polly de marquer une pause d'1 seconde entre les
phrases.
• <sub alias="World Wide Web Consortium">W3C</sub> indique à Amazon Polly de
remplacer « World Wide Web Consortium » par « W3C ».
5.
Pour plus d'informations sur SSML avec des exemples, consultez Utilisation de SSML avec l'AWS
CLI (p. 15)
Pour Choose a language and region, choisissez English US, puis choisissez la voix souhaitée.
6.
7.
Pour enregistrer le discours dans un fichier, choisissez Save speech to MP3.
Exemples de console liés
Étape suivante
Application de lexiques à l'aide de la console (Synthèse vocale) (p. 23)
Utilisation de SSML avec l'AWS CLI
Les rubriques suivantes expliquent comment utiliser une entrée SSML avec l'AWS CLI pour Amazon
Polly.
Exemple 1 : Transmission de SSML via la
commande de synthèse vocale
Dans la commande synthesize-speech suivante, vous spécifiez une chaîne SSML simple avec
uniquement les balises <speak></speak> d'ouverture et de fermeture requises (vous pouvez
également indiquer l'en-tête de document complet). Étant donné que le texte brut est la valeur par
défaut, la commande spécifie également le paramètre --text-type pour indiquer que le texte
d'entrée est SSML. Les seuls éléments nécessaires pour une chaîne SSML sont le texte d'entrée (ciblé
par le discours généré), output-format et voice-id.
15
Exemple 2 : Synthétiser un document SSML entier
L'exemple d'AWS CLI suivant est mis en forme pour OS X, Linux et Unix. Pour exécuter cet exemple à
l'invite de commande Windows, remplacez le caractère de continuation Unix (\) à la fin de chaque ligne
par le caractère de continuation Windows (^).
--text-type ssml \
--text "<speak>Hello world</speak>" \
--voice-id Joanna \
speech.mp3
Lisez le fichier speech.mp3 obtenu pour vérifier la synthèse vocale.
Exemple 2 : Synthétiser un document SSML entier
Dans cet exemple, vous enregistrez du contenu SSML dans un fichier et spécifiez le nom du fichier
dans la commande synthesize-speech. Cet exemple utilise le SSML suivant.
<?xml version="1.0"?>
<speak version="1.1"
xmlns="http://www.w3.org/2001/10/synthesis"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/2001/10/synthesis http://
www.w3.org/TR/speech-synthesis11/synthesis.xsd"
xml:lang="en-US">Hello World</speak>
Notez que l'attribut xml:lang indique en-US (US English) comme langue du texte saisi. Pour
plus d'informations sur la façon dont la langue du texte et celle de la voix ont un impact sur
l'opération SynthesizeSpeech, consultez la page Utilisation de l'attribut xml:lang de l'élément
<speak> (p. 19).
Pour tester le langage SSML
1.
2.
Enregistrez le SSML dans un fichier (example.xml).
Exécutez la commande synthesize-speech suivante depuis le chemin d'accès où le fichier
XML est stocké et spécifiez le SSML comme entrée.
L'exemple d'AWS CLI suivant est mis en forme pour OS X, Linux et Unix. Pour exécuter cet
exemple à l'invite de commande Windows, remplacez le caractère de continuation Unix (\) à la fin
de chaque ligne par le caractère de continuation Windows (^).
--text-type ssml \
--text file://example.xml \
--voice-id Joanna \
speech.mp3
3.
Lisez le fichier speech.mp3 pour vérifier la synthèse vocale.
Exemple 3 : Utilisation des balises SSML courantes
Cette section explique comment utiliser certaines balises SSML courantes pour obtenir des résultats
spécifiques. Pour plus d'exemples, consultez la page Synthèse vocale SSML (Markup Language)
Version 1.1.
16
Vous pouvez utiliser la commande synthesize-speech pour tester les exemples dans cette section.
Utilisation de l'élément <break>
La commande synthesize-speech suivante utilise l'élément <break> pour ajouter un délai de
300 millisecondes entre les mots « Hello » et « World » dans le discours qui en résulte.
"<speak>Hello <break time='300ms'/> World</speak>"
--text-type ssml \
--text "<speak>Hello <break time='300ms'/> World</speak>" \
--voice-id Joanna \
speech.mp3
Utilisation de l'élément <prosody>
Cet élément vous permet de contrôler le contenu audio, le débit de parole et le volume de discours.
• Le SSML suivant utilise l'élément <prosody> pour contrôler le volume :
"<speak><prosody volume='+20dB'>Hello world</prosody></speak>"
L'exemple d'AWS CLI suivant est mis en forme pour OS X, Linux et Unix. Pour exécuter cet exemple
à l'invite de commande Windows, remplacez le caractère de continuation Unix (\) à la fin de chaque
ligne par le caractère de continuation Windows (^).
--text-type ssml \
--text "<speak><prosody volume='+20dB'>Hello world</prosody></speak>" \
--voice-id Joanna \
speech.mp3
• Le SSML suivant utilise l'élément <prosody> pour contrôler le contenu audio :
"<speak><prosody pitch='x-high'>Hello world</prosody></speak>"
--text-type ssml \
--text "<speak><prosody pitch='x-high'>Hello world</prosody></speak>" \
17
--voice-id Joanna \
speech.mp3
• Le SSML suivant utilise l'élément <prosody> pour spécifier le débit de parole :
"<speak><prosody rate='x-fast'>Hello world</prosody></speak>"
--text-type ssml \
--text "<speak><prosody rate='x-fast'>Hello world</prosody></speak>" \
--voice-id Joanna \
speech.mp3
• Vous pouvez spécifier plusieurs attributs dans un élément <prosody>, comme illustré dans
l'exemple suivant :
"<speak><prosody volume='x-loud' pitch='x-high' rate='x-fast'>Hello world</
prosody></speak>"
--text-type ssml \
--text "<speak><prosody volume='x-loud' pitch='x-high' rate='x-fast'>Hello
world</prosody></speak>" \
--voice-id Joanna \
speech.mp3
Utilisation de l'élément <emphasis>
Cet élément vous permet de spécifier l'accentuation ou l'importance à appliquer lors de la
prononciation d'un mot ou d'une phrase spécifiques.
"<speak><emphasis level='strong'>Hello</emphasis> world how are you?</speak>"
--text-type ssml \
--text "<speak><emphasis level='strong'>Hello</emphasis> world how are you?</
speak>" \
18
Exemple 4 : Contrôle de la prononciation
--voice-id Joanna \
speech.mp3
Cet exemple montre quelques-unes des balises SSML courantes que vous pouvez utiliser pour
contrôler la prononciation.
Utilisation de l'élément <say-as>
Cet élément vous permet de fournir des informations sur le type de texte contenu dans l'élément. Dans
le SSML suivant SSML, <say-as> indique que le texte 4/6 doit être traité comme une valeur de date
avec le format jour/mois.
"<speak>Today is <say-as interpret-as='date' format='dm' >4/6</say-as></
speak>"
--text-type ssml \
--text "<speak>Today is <say-as interpret-as='date' format='dm' >4/6</sayas></speak>" \
--voice-id Joanna \
speech.mp3
Le discours qui en résulte dit « Today is June 4th ». La balise <say-as> décrit comment le texte doit
être interprété en fournissant un contexte supplémentaire grâce à l'attribut interpret-as.
Utilisation de l'attribut xml:lang de l'élément <speak>
Vous pouvez améliorer la prononciation des mots qui sont étrangers à la langue du texte saisi en
spécifiant la langue cible à l'aide de l'attribut xml:lang de l'élément <speak>. Cela incite le moteur
TTS à appliquer différentes règles de prononciation pour les mots qui sont spécifiques à la langue
cible. Les exemples suivants présentent différentes combinaisons de langues pour le texte saisi et les
voix que vous pouvez indiquer dans l'appel synthesize-speech. Vous pouvez tester ces exemples à
l'aide de la commande synthesize-speech pour vérifier les résultats.
Dans cet exemple, la voix choisie est une voix US English (anglais Etats-Unis). Amazon Polly suppose
que la langue du texte saisi est la même que celle de la voix sélectionnée. Pour une prononciation
espagnole de mots spécifiques, vous devez indiquer les mots ciblés comme étant Spanish (espagnol).
--text-type ssml \
--text "<speak>That restaurant is terrific. <xml:lang=\"es-ES\">Mucho gusto</
xml:lang>!</speak>" \
--voice-id Joanna \
19
speech.mp3
Étant donné que la langue du texte saisi est spécifiée, Amazon Polly établit une correspondance entre
les phonèmes espagnols obtenus et les phonèmes anglais de la plus petite distance acoustique.
Par conséquent, Salli lit le texte comme un interlocuteur de langue maternelle américaine qui sait
prononcer correctement l'espagnol, mais avec un accent américain.
Note
Cet usage est limité aux paires de langues disponibles dans la gamme de langues proposée
par Amazon Polly. Certaines paires de langues fonctionnent mieux que d'autres en raison de
la structure phonologique des langues.
Lisez le fichier speech.mp3 obtenu pour écouter la synthèse vocale.
20
Application de plusieurs lexiques
Gestion des lexiques
Les lexiques de prononciation vous permettent de personnaliser la prononciation des mots. Amazon
Polly fournit des opérations d'API que vous pouvez utiliser pour stocker les lexiques dans une région
AWS. Ces lexiques sont spécifiques à cette région particulière. Vous pouvez utiliser un ou plusieurs
des lexiques de cette région lors de la synthèse du texte grâce à l'opération SynthesizeSpeech.
Le lexique spécifié est alors appliqué au texte saisi avant le début de la synthèse. Pour plus
d'informations, consultez SynthesizeSpeech (p. 71).
Note
Ces lexiques doivent être conformes à la recommandation W3C Pronunciation Lexicon
Specification (PLS). Pour plus d'informations, consultez la recommandation Pronunciation
Lexicon Specification (PLS) Version 1.0 sur le site Web de W3C.
Voici des exemples d'utilisation des lexiques avec des moteurs de synthèse vocale :
• Des mots courants sont parfois stylisés en utilisant des chiffres à la place des lettres, comme dans
l'exemple « g3t sm4rt » (get smart). Les humains sont capables de lire ces mots correctement.
Cependant, un moteur de synthèse vocale (TTS) lit le texte de façon littérale, c'est-à-dire en
prononçant toutes les lettres du nom. C'est dans ce contexte que les lexiques peuvent vous être
utiles afin de personnaliser la synthèse vocale lors de l'utilisation d'Amazon Polly. Dans cet exemple,
vous pouvez spécifier un alias (get smart) pour le mot « g3t sm4rt » dans le lexique.
• Votre texte peut inclure un acronyme, tel que W3C. Vous pouvez utiliser un lexique afin de définir
un alias pour le mot W3C qui sera lu sous sa forme complète, développée (World Wide Web
Consortium).
Les lexiques vous permettent de contrôler davantage la façon dont Amazon Polly prononce des mots
rares dans la langue sélectionnée. Par exemple, vous pouvez spécifier la prononciation à l'aide d'un
alphabet phonétique. Pour plus d'informations, consultez la recommandation Pronunciation Lexicon
Specification (PLS) Version 1.0 sur le site Web de W3C.
Rubriques
• Application de plusieurs lexiques (p. 21)
• Gestion des lexiques à l'aide de la console Amazon Polly (p. 22)
• Gestion des lexiques à l'aide d'AWS CLI (p. 25)
Application de plusieurs lexiques
Vous pouvez appliquer jusqu'à cinq lexiques à votre texte. Si le même graphème apparaît dans
plusieurs lexiques que vous appliquez à votre texte, l'ordre selon lequel ils sont appliqués peut
21
Gestion des lexiques à l'aide de la console
produire un discours différent. Par exemple, étant donné le texte suivant, « Hello, my name is Bob. » et
deux lexèmes dans différents lexiques qui utilisent tous deux le graphème Bob.
LexA
<lexeme>
<grapheme>Bob</grapheme>
<alias>Robert</alias>
</lexeme>
LexB
<lexeme>
<grapheme>Bob</grapheme>
<alias>Bobby</alias>
</lexeme>
Si les lexiques sont répertoriés selon l'ordre LexA, puis LexB, la synthèse vocale sera « Hello, my
name is Robert. » S'ils sont répertoriés selon l'ordre LexB, puis LexA, la synthèse vocale sera « Hello,
my name is Bobby. »
Example – Appliquer LexA avant LexB
--lexicon-names LexA LexB \
--text "Hello, my name is Bob" \
--voice-id Justin \
bobAB.mp3
Sortie vocale : « Hello, my name is Robert. »
Example – Appliquer LexB avant LexA
--lexicon-names LexB LexA \
--text "Hello, my name is Bob" \
--voice-id Justin \
bobBA.mp3
Sortie vocale : « Hello, my name is Bobby. »
Pour plus d'informations sur l'application des lexiques via la console Amazon Polly, consultez
Application de lexiques à l'aide de la console (Synthèse vocale) (p. 23).
Gestion des lexiques à l'aide de la console
Amazon Polly
Vous pouvez utiliser la console Amazon Polly pour charger, télécharger, appliquer, filtrer et supprimer
des lexiques. Les procédures suivantes illustrent chacun de ces processus.
22
Chargement des lexiques à l'aide de la console
Chargement des lexiques à l'aide de la console
Pour utiliser un lexique de prononciation, vous devez commencer par le charger. Il y a deux
emplacements sur la console à partir desquels vous pouvez charger un lexique, l'onglet Text-toSpeech et l'onglet Lexicons.
Les procédures suivantes expliquent comment ajouter des lexiques que vous pouvez utiliser pour
personnaliser la prononciation de mots et de phrases rares dans la langue choisie.
Pour ajouter un lexique à partir de l'onglet Lexicons
1.
2.
Choisissez l'onglet Lexicons.
3.
Choisissez Upload.
4.
Recherchez le lexique que vous souhaitez charger. Vous pouvez utiliser uniquement les fichiers
PLS qui utilisent les extensions .pls et xml.
5.
Choisissez Open. Si un lexique du même nom (fichier .pls ou xml) existe déjà, le chargement du
lexique permettra de remplacer le lexique existant.
Pour ajouter un lexique à partir de l'onglet Text-to-Speech
1.
2.
Choisissez l'onglet Text-to-Speech.
3.
Choisissez Customize pronunciation of words or phrases using lexicons, puis Upload
lexicon.
4.
Recherchez le lexique que vous souhaitez charger. Vous pouvez utiliser uniquement les fichiers
PLS qui utilisent les extensions .pls et xml.
5.
Choisissez Open. Si un lexique du même nom (fichier .pls ou xml) existe déjà, le chargement du
lexique permettra de remplacer le lexique existant.
Application de lexiques à l'aide de la console
(Synthèse vocale)
La procédure suivante montre comment appliquer un lexique au texte que vous avez saisi en
appliquant le lexique W3c.pls pour remplacer par « World Wide Web Consortium » par « W3C ». Si
vous appliquez plusieurs lexiques à votre texte, ils seront appliqués dans un ordre descendant ; la
première correspondance étant prioritaire par rapport aux suivantes. Un lexique est appliqué au texte
uniquement si la langue spécifiée dans le lexique est la même que la langue choisie.
Vous pouvez appliquer un lexique à un texte brut ou à une entrée SSML.
23
Filtrage de la liste des lexiques à l'aide de la console
Example – Appliquer le lexique W3C.pls
Pour créer le lexique dont vous aurez besoin pour cet exercice, consultez Utilisation de l'opération
PutLexicon (p. 26). Utilisez un éditeur de texte brut pour créer le lexique W3C.pls affiché en haut de
la rubrique. Gardez cela à l'esprit lorsque vous enregistrez ce fichier.
Pour appliquer le lexique W3C.pls à votre entrée
Dans cet exemple, nous vous présentons des lexiques pour remplacer « World Wide Web
Consortium » par « W3C ». Comparez les résultats de cet exercice à ceux de Utilisation de SSML avec
la console Amazon Polly (p. 14) à la fois pour l'anglais (Etats-Unis) et pour une autre langue.
1.
2.
Effectuez l'une des actions suivantes :
• Choisissez l'onglet Plain text, puis tapez ou collez ce texte dans la zone d'entrée de texte.
He was caught up in the game.
he shouted, "Score!" quite loudly.
• Choisissez l'onglet SSML, puis tapez ou collez ce texte dans la zone d'entrée de texte.
<speak>He wasn't paying attention.<break time="1s"/>
he shouted, "Score!" quite loudly.</speak>
3.
Dans la liste Choose a language and region, sélectionnez English US, puis choisissez une voix
que vous voulez utiliser pour ce texte.
4.
Choisissez Customize pronunciation of words or phrases using lexicons.
5.
Dans la liste des lexiques, choisissez W3C (English, US).
Si le lexique W3C (English, US) n'apparaît pas, choisissez Upload lexicon, chargez-le, puis
sélectionnez-le dans la liste.
6.
7.
Pour enregistrer le discours dans un fichier,
a.
Choisissez Save speech to MP3.
b.
Répétez les étapes précédentes, mais choisissez une autre langue et notez la différence dans le
résultat obtenu.
Filtrage de la liste des lexiques à l'aide de la console
La procédure suivante décrit comment filtrer la liste de lexiques afin d'afficher uniquement les lexiques
de la langue choisie.
Pour filtrer les lexiques par langue
1.
2.
24
Téléchargement des lexiques à l'aide de la console
3.
Choisissez Filter.
4.
Dans la liste des langues, sélectionnez la langue sur laquelle vous voulez filtrer.
La liste affiche uniquement les lexiques pour la langue choisie.
Téléchargement des lexiques à l'aide de la console
Le processus suivant décrit comment télécharger un ou plusieurs lexiques. Vous pouvez ajouter,
supprimer ou modifier des entrées de lexique dans le fichier, puis le chargez à nouveau pour avoir un
lexique toujours à jour.
Pour télécharger un ou plusieurs lexiques
1.
2.
3.
Choisissez le ou les lexiques à télécharger.
a.
Pour télécharger un seul lexique, choisissez son nom dans la liste.
b.
Pour télécharger plusieurs lexiques en un seul fichier d'archive compressé, cochez la case
située en regard de chaque entrée de la liste que vous souhaitez télécharger.
4.
Choisissez Téléchargement.
5.
Ouvrez le dossier dans lequel vous souhaitez télécharger le lexique.
6.
Choisissez Save.
Suppression d'un lexique à l'aide de la console
Pour supprimer un lexique
Le processus suivant décrit comment supprimer un lexique. Après avoir supprimé le lexique, vous
devez l'ajouter à nouveau avant de pouvoir le réutiliser. Vous pouvez supprimer un ou plusieurs
lexiques en même temps en sélectionnant les cases à cocher en regard des différents lexiques
concernés.
1.
2.
3.
Sélectionnez un ou plusieurs lexiques à supprimer dans la liste.
4.
Sélectionnez Delete.
5.
Choisissez Delete pour supprimer le lexique de la région ou Cancel pour le conserver.
Gestion des lexiques à l'aide d'AWS CLI
Les rubriques suivantes couvrent les commandes AWS CLI indispensables pour gérer vos lexiques de
prononciation.
Rubriques
• Utilisation de l'opération PutLexicon (p. 26)
• Utilisation de l'opération GetLexicon (p. 31)
25
PutLexicon
• Utilisation des opérations ListLexicons (p. 33)
• Utilisation de l'opération DeleteLexicon (p. 34)
Utilisation de l'opération PutLexicon
Avec Amazon Polly, vous pouvez utiliser PutLexicon (p. 69) pour stocker des lexiques de
prononciation dans une région AWS spécifique pour votre compte. Vous pouvez ensuite indiquer un
ou plusieurs de ces lexiques stockés dans votre demande SynthesizeSpeech (p. 71) que vous
souhaitez appliquer avant que le service ne démarre la synthèse du texte. Pour plus d'informations,
consultez Gestion des lexiques (p. 21).
Cette section fournit des exemples de lexiques, ainsi que des instructions pas à pas pour les stocker et
les tester.
Note
Ces lexiques doivent être conformes à la recommandation W3C Pronunciation Lexicon
Specification (PLS). Pour plus d'informations, consultez la recommandation Pronunciation
Lexicon Specification (PLS) Version 1.0 sur le site Web de W3C.
Exemple 1 : Lexique avec un lexème
Considérez le lexique W3C compatible PLS.
<?xml version="1.0" encoding="UTF-8"?>
<lexicon version="1.0"
xmlns="http://www.w3.org/2005/01/pronunciation-lexicon"
xsi:schemaLocation="http://www.w3.org/2005/01/pronunciation-lexicon
http://www.w3.org/TR/2007/CR-pronunciation-lexicon-20071212/pls.xsd"
alphabet="ipa"
xml:lang="en-US">
<lexeme>
<grapheme>W3C</grapheme>
<alias>World Wide Web Consortium</alias>
</lexeme>
</lexicon>
Remarques :
• Les deux attributs spécifiés dans l'élément <lexicon> :
• L'attribut xml:lang spécifie le code de langue, en-US, auquel le lexique s'applique. Amazon Polly
peut utiliser ce lexique si la voix que vous spécifiez dans l'appel SynthesizeSpeech a le même
code de langue (en-US).
Note
Vous pouvez utiliser l'opération DescribeVoices pour trouver le code de langue
associé à une voix.
• L'attribut alphabet indique IPA, ce qui signifie que l'alphabet phonétique international (API) est
utilisé pour les prononciations. API est l'un des alphabets utilisés pour la transcription phonétique
des sons. Amazon Polly prend également en charge l'alphabet X-SAMPA (Extended Speech
Assessment Methods Phonetic Alphabet).
26
PutLexicon
• L'élément <lexeme> décrit le mappage entre <grapheme> (qui est une représentation de texte du
mot) et <alias>.
Pour tester ce lexique, procédez comme suit :
1.
Enregistrez le lexique sous le nom example.pls.
2.
Exécutez la commande d'AWS CLI put-lexicon pour stocker le lexique (avec le nom w3c), dans
la région us-east-1.
aws polly put-lexicon \
--name w3c \
--content file://example.pls
3.
Exécutez la commande synthesize-speech pour synthétiser l'exemple de texte dans un flux
audio (speech.mp3) et indiquez le paramètre facultatif lexicon-name.
--text "W3C is a Consortium" \
--voice-id Joanna \
--lexicon-names="w3c" \
speech.mp3
4.
Lisez le fichier speech.mp3 obtenu et notez que le mot W3C dans le texte est remplacé par
« World Wide Web Consortium ».
L'exemple de lexique précédent utilise un alias. L'alphabet API mentionné dans le lexique n'est pas
utilisé. Le lexique suivant spécifie une prononciation phonétique à l'aide de l'élément <phoneme> avec
l'alphabet API.
alphabet="ipa"
xml:lang="en-US">
<lexeme>
<grapheme>pecan</grapheme>
<phoneme>p##k##n</phoneme>
</lexeme>
</lexicon>
Suivez la même procédure pour tester ce lexique. Assurez-vous d'indiquer le texte saisi comportant le
mot « pecan » (par exemple, « Pecan pie is delicious »).
Exemple 2 : Lexique avec plusieurs lexèmes
Dans cet exemple, le lexème que vous spécifiez dans le lexique s'applique exclusivement au texte
saisi pour la synthèse. Prenez en compte le lexique suivant :
27
PutLexicon
alphabet="ipa" xml:lang="en-US">
<lexeme>
</lexeme>
<lexeme>
<alias>WWW Consortium</alias>
</lexeme>
<lexeme>
<grapheme>Consortium</grapheme>
<alias>Community</alias>
</lexeme>
</lexicon>
Le lexique indique trois lexèmes, dont deux d'entre eux définissent un alias pour le graphème W3C
comme suit :
• Le premier élément <lexeme> définit un alias (World Wide Web Consortium).
• Le deuxième <lexeme> définit un autre alias (WWW Consortium).
Amazon Polly utilise le premier remplacement pour tout graphème donné dans un lexique.
Le troisième <lexeme> définit un remplacement (Community) pour le mot Consortium.
Tout d'abord, nous allons tester ce lexique. Supposons que vous vouliez résumer l'exemple de
texte suivant dans un fichier audio (speech.mp3), et que vous indiquiez le lexique dans un appel à
SynthesizeSpeech.
The W3C is a Consortium
SynthesizeSpeech applique d'abord le lexique comme suit :
• Pour le premier lexème, le mot W3C est révisé en tant que « WWW Consortium ». Le texte révisé
apparaît comme suit :
The WWW Consortium is a Consortium
• L'alias défini dans le troisième lexème s'applique uniquement au mot Consortium qui faisait partie du
texte original, générant le texte suivant :
The World Wide Web Consortium is a Community.
Vous pouvez le tester en utilisant l'AWS CLI comme suit :
1.
2.
Enregistrez le lexique sous le nom example.pls.
Exécutez la commande put-lexicon pour stocker le lexique avec le nom « w3c », dans la région
us-east-1.
--name w3c \
28
PutLexicon
--content file://example.pls
3.
Exécutez la commande list-lexicons pour vérifier que le lexique « w3c » figure dans la liste
des lexiques renvoyés.
aws polly list-lexicons
4.
Exécutez la commande synthesize-speech pour synthétiser l'exemple de texte dans un fichier
audio (speech.mp3) et indiquez le paramètre facultatif lexicon-name.
--text "W3C is a Consortium" \
--voice-id Joanna \
--lexicon-names="w3c" \
speech.mp3
5.
Lisez le fichier speech.mp3 obtenu pour vérifier que le discours synthétisé reflète les
modifications de texte.
Exemple 3 : Spécification de plusieurs lexiques
Dans un appel à SynthesizeSpeech, vous pouvez spécifier plusieurs lexiques. Dans ce cas, le
premier lexique spécifié (de gauche à droite) remplace tous les lexiques précédents.
Considérez les deux lexiques suivants. Veuillez noter que chaque lexique décrit différents alias pour le
même graphème W3C.
• Lexique 1 : w3c.pls
<lexeme>
</lexeme>
</lexicon>
• Lexique 2 : w3cAlternate.pls
<lexeme>
<alias>WWW Consortium</alias>
29
PutLexicon
</lexeme>
</lexicon>
Supposons que vous stockiez ces lexiques respectivement sous les noms w3c et w3cAlternate. Si
vous spécifiez des lexiques selon l'ordre (w3c suivi de w3cAlternate) dans un appel à la commande
SynthesizeSpeech, l'alias pour W3C défini dans le premier lexique a la priorité par rapport au
deuxième. Pour tester ces lexiques, procédez comme suit :
1.
Enregistrez les lexiques localement dans des fichiers appelés w3c.pls et w3cAlternate.pls.
2.
Chargez ces lexiques à l'aide de la commande d'AWS CLI put-lexicon.
• Chargez le lexique w3c.pls et stockez-le en tant que w3c.
--name w3c \
--content file://w3c.pls
• Chargez le lexique w3cAlternate.pls dans le service en tant que w3cAlternate.
--name w3cAlternate \
--content file://w3cAlternate.pls
3.
Exécutez la commande synthesize-speech pour synthétiser l'exemple de texte dans un flux
audio (speech.mp3) et indiquez les deux lexiques à l'aide du paramètre lexicon-name.
--text "PLS is a W3C recommendation" \
--voice-id Joanna \
--lexicon-names '["w3c","w3cAlternative"]' \
speech.mp3
4.
Testez le fichier speech.mp3 obtenu. Il doit se lire comme suit :
PLS is a World Wide Web Consortium recommendation
Exemple 4 : Code Python pour PutLexicon
L'exemple de code Python suivant utilise AWS SDK for Python (Boto) pour stocker un lexique.
Remarques :
• Vous devez mettre à jour le code en fournissant un nom de fichier de lexique local et un nom de
lexique stocké.
• L'exemple suppose que vous avez créé des fichiers de lexique dans un sous-répertoire appelé pls.
Vous devez mettre à jour le chemin d'accès, comme il convient.
L'exemple de code suivant utilise des informations d'identification par défaut stockées dans le fichier
de configuration AWS SDK. Pour plus d'informations sur la création du fichier de configuration,
consultez Étape 3.1 : Configuration de l'AWS Command Line Interface (AWS CLI) (p. 8).
30
GetLexicon
from argparse import ArgumentParser
# Define and parse the command line arguments
cli = ArgumentParser(description="PutLexicon example")
cli.add_argument("path", type=str, metavar="FILE_PATH")
cli.add_argument("-n", "--name", type=str, required=True,
metavar="LEXICON_NAME", dest="name")
arguments = cli.parse_args()
# Create a client using the credentials and region defined in the adminuser
# section of the AWS credentials and configuration files
# Open the PLS lexicon file for reading
try:
with open(arguments.path, "r") as lexicon_file:
# Read the pls file contents
lexicon_data = lexicon_file.read()
# Store the PLS lexicon on the service.
# If a lexicon with that name already exists,
# its contents will be updated
response = polly.put_lexicon(Name=arguments.name,
Content=lexicon_data)
except (IOError, BotoCoreError, ClientError) as error:
# Could not open/read the file or the service returned an error,
# exit gracefully
cli.error(error)
print(u"The \"{0}\" lexicon is now available for
use.".format(arguments.name))
Utilisation de l'opération GetLexicon
Amazon Polly fournit l'opération API GetLexicon (p. 65) pour récupérer le contenu d'un lexique de
prononciation que vous avez enregistré dans votre compte dans une région spécifique.
La commande AWS CLI get-lexicon suivante récupère le contenu du lexique example.
aws polly get-lexicon \
--name example
Si vous n'avez pas encore de lexique enregistré dans votre compte, vous pouvez utiliser l'opération
PutLexicon pour en enregistrer un. Pour plus d'informations, consultez Utilisation de l'opération
PutLexicon (p. 26).
Voici un exemple de réponse. Outre le contenu du lexique, la réponse renvoie les métadonnées,
telles que le code de langue auquel le lexique s'applique, le nombre de lexèmes définis dans le
lexique, l'Amazon Resource Name (ARN) de la ressource et la taille du lexique en octets. La valeur
LastModified est un horodatage Unix.
31
GetLexicon
{
"Lexicon": {
"Content": "lexicon content in plain text PLS format",
"Name": "example"
},
"LexiconAttributes": {
"LanguageCode": "en-US",
"LastModified": 1474222543.989,
"Alphabet": "ipa",
"LexemesCount": 1,
"LexiconArn": "arn:aws:polly:us-east-1:account-id:lexicon/example",
"Size": 495
}
}
Le code Python suivant utilise le AWS SDK for Python (Boto) pour récupérer tous les lexiques stockés
dans une région AWS. L'exemple prend en charge un nom de lexique comme un paramètre de ligne
de commande et récupère uniquement ce lexique, imprimant le chemin d'accès tmp où il y a été
enregistré localement.
from os import path
from tempfile import gettempdir
cli = ArgumentParser(description="GetLexicon example")
cli.add_argument("name", type=str, metavar="LEXICON_NAME")
print(u"Fetching {0}...".format(arguments.name))
try:
# Fetch lexicon by name
response = polly.get_lexicon(Name=arguments.name)
cli.error(error)
# Get the lexicon data from the response
lexicon = response.get("Lexicon", {})
# Access the lexicon's content
if "Content" in lexicon:
output = path.join(gettempdir(), u"%s.pls" % arguments.name)
print(u"Saving to %s..." % output)
32
ListLexicons
try:
# Save the lexicon contents to a local file
with open(output, "w") as pls_file:
pls_file.write(lexicon["Content"])
except IOError as error:
# Could not write to file, exit gracefully
cli.error(error)
else:
# The response didn't contain lexicon data, exit gracefully
cli.error("Could not fetch lexicons contents")
print("Done.")
Utilisation des opérations ListLexicons
Amazon Polly fournit l'opération API ListLexicons (p. 67) que vous pouvez utiliser pour obtenir la
liste des lexiques de prononciation dans votre compte dans une région spécifique d'AWS. L'appel de
l'AWS CLI suivant répertorie les lexiques dans votre compte dans la région us-east-1.
aws polly list-lexicons
Voici un exemple de réponse, affichant deux lexiques nommés w3c et tomato. Pour chaque lexique,
la réponse renvoie des métadonnées comme le code de langue auquel le lexique s'applique, le
nombre de lexèmes définis dans le lexique, la taille en octets, etc. Le code de langue décrit une langue
et des paramètres régionaux auxquels les lexèmes définis dans le lexique s'appliquent.
{
"Lexicons": [
{
"Attributes": {
"LastModified": 1474222543.989,
"Alphabet": "ipa",
"LexemesCount": 1,
"LexiconArn": "arn:aws:polly:aws-region:account-id:lexicon/
w3c",
"Size": 495
},
"Name": "w3c"
},
{
"Attributes": {
"LastModified": 1473099290.858,
"Alphabet": "ipa",
"LexemesCount": 1,
"LexiconArn": "arn:aws:polly:aws-region:account-id:lexicon/
tomato",
"Size": 645
},
"Name": "tomato"
}
]
}
33
DeleteLexicon
L'exemple de code Python suivant utilise le AWS SDK for Python (Boto) pour Python (Boto) pour
répertorier les lexiques dans votre compte dans la région spécifiée dans votre configuration AWS
locale. Pour plus d'informations sur la création du fichier de configuration, consultez Étape 3.1 :
Configuration de l'AWS Command Line Interface (AWS CLI) (p. 8).
import sys
try:
# Request the list of available lexicons
response = polly.list_lexicons()
print(error)
sys.exit(-1)
# Get the list of lexicons in the response
lexicons = response.get("Lexicons", [])
print("{0} lexicon(s) found".format(len(lexicons)))
# Output a formatted list of lexicons with some of the attributes
for lexicon in lexicons:
print((u" - {Name} ({Attributes[LanguageCode]}), "
"{Attributes[LexemesCount]} lexeme(s)").format(**lexicon))
Utilisation de l'opération DeleteLexicon
Amazon Polly fournit l'opération API DeleteLexicon (p. 61) pour supprimer un lexique de
prononciation à partir d'une région spécifique AWS dans votre compte. L'AWS CLI suivante supprime
le lexique spécifié.
aws polly delete-lexicon \
--name example
L'exemple de code Python suivant utilise le AWS SDK for Python (Boto) pour supprimer un lexique
dans la région spécifiée dans votre configuration AWS locale. L'exemple supprime uniquement le
lexique spécifié. Il vous est demandé de confirmer l'opération avant de supprimer réellement le lexique
34
DeleteLexicon
from sys import version_info
cli = ArgumentParser(description="DeleteLexicon example")
cli.add_argument("name", type=str, metavar="LEXICON_NAME")
# Request confirmation
prompt = input if version_info >= (3, 0) else raw_input
proceed = prompt((u"This will delete the \"{0}\" lexicon,"
" do you want to proceed? [y,n]: ").format(arguments.name))
if proceed in ("y", "Y"):
print(u"Deleting {0}...".format(arguments.name))
try:
# Request deletion of a lexicon by name
response = polly.delete_lexicon(Name=arguments.name)
cli.error(error)
print("Done.")
else:
print("Cancelled.")
35
Exemples d'applications
Cette section fournit des exemples supplémentaires que vous pouvez utiliser pour explorer Amazon
Polly. Avant de commencer à utiliser ces exemples, nous vous recommandons de lire tout d'abord
Amazon Polly : fonctionnement (p. 3) et de suivre les étapes décrites dans Mise en route avec Amazon
Polly (p. 5).
Rubriques
• Exemple de Python (client HTML5 et serveur Python) (p. 37)
• Exemple Android (p. 48)
• Exemple iOS (p. 50)
36
Exemple Python
Exemple de Python (client HTML5 et serveur
Python)
Cet exemple d'application comprend les éléments suivants :
• Un serveur HTTP 1.1 utilisant l'encodage de transfert en bloc HTTP (voir Encodage de transfert en
bloc)
• Une simple interface utilisateur HTML5 qui interagit avec le serveur HTTP 1.1 (voir ci-dessous) :
L'objectif de cet exemple est de montrer comment utiliser Amazon Polly pour diffuser la voix à partir
d'une application HTML5 basée sur un navigateur. Pour les cas d'utilisation où la réactivité est très
importante (par exemple, systèmes de dialogue, lecteurs d'écran, etc.), l'approche recommandée est
de consommer le flux audio généré par Amazon Polly au fur et à mesure que le texte est synthétisé.
Pour exécuter cet exemple d'application, vous avez besoin des éléments suivants :
• Navigateur Web conforme aux normes HTML5 et EcmaScript5 (par exemple, Chrome 23.0 ou
supérieur, Firefox 21.0 ou supérieur, Internet Explorer 9.0 ou supérieur)
• Version de Python supérieure à la version 3.0
Pour tester l'application
1.
Enregistrez le code de serveur sous le nom server.py. Pour le code , consultez Exemple de
Python : Code du serveur Python (server.py) (p. 41).
2.
Enregistrez le code de client HTML5 sous le nom index.html. Pour le code , consultez Exemple
Python : Interface utilisateur HTML5 (index.html) (p. 38).
3.
Exécutez la commande suivante à partir du chemin d'accès où vous avez enregistré server.py
pour démarrer l'application (sur certains systèmes, vous devrez peut-être utiliser python3 au lieu
de python lors de l'exécution la commande).
37
Exemple Python : index.html
$ python
server.py
Une fois que l'application a démarré, une URL s'affiche dans le terminal.
4.
Ouvrez l'URL affiché dans le terminal dans un navigateur web.
Vous pouvez transmettre l'adresse et le port du serveur d'application à utiliser comme paramètre
dans server.py. Pour de plus amples informations, exécutez python server.py -h.
5.
Pour écouter le discours, choisissez une voix dans la liste, tapez un texte, puis choisissez Read.
La lecture du discours commence dès que Amazon Polly transfère le premier segment utilisable
de données audio.
6.
Pour arrêter le serveur Python lorsque vous avez terminé de tester l'application, appuyez sur
Ctrl + C (Ctrl + Z sous Windows) dans le terminal du serveur.
Note
Le serveur crée un client Boto3 à l'aide de AWS SDK for Python (Boto). Le client utilise les
informations d'identification stockées dans le fichier de configuration AWS sur votre ordinateur
pour signer et identifier les demandes dans Amazon Polly. Pour plus d'informations sur la
façon de créer le fichier de configuration AWS et de stocker les informations d'identification,
consultez la page Configuration de l'interface de ligne de commande AWS dans le AWS
Command Line Interface Guide de l'utilisateur.
Exemple Python : Interface utilisateur HTML5
(index.html)
Cette section fournit le code pour le client HTML5 décrit dans Exemple de Python (client HTML5 et
serveur Python) (p. 37).
<html>
<head>
<title>Text-to-Speech Example Application</title>
<script>
/*
* This sample code requires a web browser with support for both the
* HTML5 and ECMAScript 5 standards; the following is a noncomprehensive
* list of compliant browsers and their minimum version:
*
* - Chrome 23.0+
* - Firefox 21.0+
* - Internet Explorer 9.0+
* - Edge 12.0+
* - Opera 15.0+
* - Safari 6.1+
* - Android (stock web browser) 4.4+
* - Chrome for Android 51.0+
* - Firefox for Android 48.0+
* - Opera Mobile 37.0+
* - iOS (Safari Mobile and Chrome) 3.2+
* - Internet Explorer Mobile 10.0+
* - Blackberry Browser 10.0+
*/
38
// Mapping of the OutputFormat parameter of the SynthesizeSpeech API
// and the audio format strings understood by the browser
var AUDIO_FORMATS = {
'ogg_vorbis': 'audio/ogg',
'mp3': 'audio/mpeg',
'pcm': 'audio/wave; codecs=1'
};
/**
* Handles fetching JSON over HTTP
*/
function fetchJSON(method, url, onSuccess, onError) {
var request = new XMLHttpRequest();
request.open(method, url, true);
request.onload = function () {
// If loading is complete
if (request.readyState === 4) {
// if the request was successful
if (request.status === 200) {
var data;
// Parse the JSON in the response
try {
data = JSON.parse(request.responseText);
} catch (error) {
onError(request.status, error.toString());
}
onSuccess(data);
} else {
onError(request.status, request.responseText)
}
}
};
request.send();
}
/**
* Returns a list of audio formats supported by the browser
*/
function getSupportedAudioFormats(player) {
return Object.keys(AUDIO_FORMATS)
.filter(function (format) {
var supported =
player.canPlayType(AUDIO_FORMATS[format]);
return supported === 'probably' || supported === 'maybe';
});
}
// Initialize the application when the DOM is loaded and ready to be
// manipulated
document.addEventListener("DOMContentLoaded", function () {
var input = document.getElementById('input'),
voiceMenu = document.getElementById('voice'),
text = document.getElementById('text'),
player = document.getElementById('player'),
submit = document.getElementById('submit'),
supportedFormats = getSupportedAudioFormats(player);
39
// Display a message and don't allow submitting the form if the
// browser doesn't support any of the available audio formats
if (supportedFormats.length === 0) {
submit.disabled = true;
alert('The web browser in use does not support any of the' +
' available audio formats. Please try with a different'
+
' one.');
}
// Play the audio stream when the form is submitted successfully
input.addEventListener('submit', function (event) {
// Validate the fields in the form, display a message if
// unexpected values are encountered
if (voiceMenu.selectedIndex <= 0 || text.value.length === 0)
{
alert('Please fill in all the fields.');
} else {
var selectedVoice = voiceMenu
.options[voiceMenu.selectedIndex]
.value;
// Point the player to the streaming server
player.src = '/read?voiceId=' +
encodeURIComponent(selectedVoice) +
'&text=' + encodeURIComponent(text.value) +
'&outputFormat=' + supportedFormats[0];
player.play();
}
// Stop the form from submitting,
// Submitting the form is allowed only if the browser doesn't
// support Javascript to ensure functionality in such a case
event.preventDefault();
});
// Load the list of available voices and display them in a menu
fetchJSON('GET', '/voices',
// If the request succeeds
function (voices) {
var container = document.createDocumentFragment();
// Build the list of options for the menu
voices.forEach(function (voice) {
var option = document.createElement('option');
option.value = voice['Id'];
option.innerHTML = voice['Name'] + ' (' +
voice['Gender'] + ', ' +
voice['LanguageName'] + ')';
container.appendChild(option);
});
// Add the options to the menu and enable the form field
voiceMenu.appendChild(container);
voiceMenu.disabled = false;
},
// If the request fails
function (status, response) {
40
Exemple Python : server.py
// Display a message in case loading data from the server
// fails
alert(status + ' - ' + response);
});
});
</script>
<style>
#input {
min-width: 100px;
max-width: 600px;
margin: 0 auto;
padding: 50px;
}
#input div {
margin-bottom: 20px;
}
#text {
width: 100%;
height: 200px;
display: block;
}
#submit {
width: 100%;
}
</style>
</head>
<body>
<form id="input" method="GET" action="/read">
<div>
<label for="voice">Select a voice:</label>
<select id="voice" name="voiceId" disabled>
<option value="">Choose a voice...</option>
</select>
</div>
<div>
<label for="text">Text to read:</label>
<textarea id="text" maxlength="1000" minlength="1" name="text"
placeholder="Type some text here..."></textarea>
</div>
<input type="submit" value="Read" id="submit" />
</form>
<audio id="player"></audio>
</body>
</html>
Exemple de Python : Code du serveur Python
(server.py)
Cette section fournit le code du serveur Python décrit dans Exemple de Python (client HTML5 et
serveur Python) (p. 37).
41
"""
Example Python 2.7+/3.3+ Application
This application consists of a HTTP 1.1 server using the HTTP chunked
transfer
coding (https://tools.ietf.org/html/rfc2616#section-3.6.1) and a minimal
HTML5
user interface that interacts with it.
The goal of this example is to start streaming the speech to the client (the
HTML5 web UI) as soon as the first consumable chunk of speech is returned in
order to start playing the audio as soon as possible.
For use cases where low latency and responsiveness are strong requirements,
this is the recommended approach.
The service documentation contains examples for non-streaming use cases where
waiting for the speech synthesis to complete and fetching the whole audio
stream
at once are an option.
To test the application, run 'python server.py' and then open the URL
displayed in the terminal in a web browser (see index.html for a list of
supported browsers). The address and port for the server can be passed as
parameters to server.py. For more information, run: 'python server.py -h'
"""
from collections import namedtuple
from contextlib import closing
from io import BytesIO
from json import dumps as json_encode
import os
import sys
if sys.version_info >= (3, 0):
from http.server import BaseHTTPRequestHandler, HTTPServer
from socketserver import ThreadingMixIn
from urllib.parse import parse_qs
else:
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
from SocketServer import ThreadingMixIn
from urlparse import parse_qs
ResponseStatus = namedtuple("HTTPStatus",
["code", "message"])
ResponseData = namedtuple("ResponseData",
["status", "content_type", "data_stream"])
# Mapping the output format used in the client to the content type for the
# response
AUDIO_FORMATS = {"ogg_vorbis": "audio/ogg",
"mp3": "audio/mpeg",
"pcm": "audio/wave; codecs=1"}
CHUNK_SIZE = 1024
HTTP_STATUS = {"OK": ResponseStatus(code=200, message="OK"),
42
"BAD_REQUEST": ResponseStatus(code=400, message="Bad
request"),
"NOT_FOUND": ResponseStatus(code=404, message="Not found"),
"INTERNAL_SERVER_ERROR": ResponseStatus(code=500,
message="Internal server error")}
PROTOCOL = "http"
ROUTE_INDEX = "/index.html"
ROUTE_VOICES = "/voices"
ROUTE_READ = "/read"
class HTTPStatusError(Exception):
"""Exception wrapping a value from http.server.HTTPStatus"""
def __init__(self, status, description=None):
"""
Constructs an error instance from a tuple of
(code, message, description), see http.server.HTTPStatus
"""
super(HTTPStatusError, self).__init__()
self.code = status.code
self.message = status.message
self.explain = description
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
"""An HTTP Server that handle each request in a new thread"""
daemon_threads = True
class ChunkedHTTPRequestHandler(BaseHTTPRequestHandler):
""""HTTP 1.1 Chunked encoding request handler"""
# Use HTTP 1.1 as 1.0 doesn't support chunked encoding
protocol_version = "HTTP/1.1"
def query_get(self, queryData, key, default=""):
"""Helper for getting values from a pre-parsed query string"""
return queryData.get(key, [default])[0]
def do_GET(self):
"""Handles GET requests"""
# Extract values from the query string
path, _, query_string = self.path.partition('?')
query = parse_qs(query_string)
response = None
print(u"[START]: Received GET for %s with query: %s" % (path, query))
try:
# Handle the possible request paths
if path == ROUTE_INDEX:
43
response
elif path ==
response
elif path ==
response
else:
response
= self.route_index(path, query)
ROUTE_VOICES:
= self.route_voices(path, query)
ROUTE_READ:
= self.route_read(path, query)
= self.route_not_found(path, query)
self.send_headers(response.status, response.content_type)
self.stream_data(response.data_stream)
except HTTPStatusError as err:
# Respond with an error and log debug
# information
if sys.version_info >= (3, 0):
self.send_error(err.code, err.message, err.explain)
else:
self.send_error(err.code, err.message)
self.log_error(u"%s %s %s - [%d] %s", self.client_address[0],
self.command, self.path, err.code, err.explain)
print("[END]")
def route_not_found(self, path, query):
"""Handles routing for unexpected paths"""
raise HTTPStatusError(HTTP_STATUS["NOT_FOUND"], "Page not found")
def route_index(self, path, query):
"""Handles routing for the application's entry point'"""
try:
return ResponseData(status=HTTP_STATUS["OK"],
content_type="text_html",
# Open a binary stream for reading the index
# HTML file
data_stream=open(os.path.join(sys.path[0],
path[1:]),
"rb"))
except IOError as err:
# Couldn't open the stream
raise HTTPStatusError(HTTP_STATUS["INTERNAL_SERVER_ERROR"],
str(err))
def route_voices(self, path, query):
"""Handles routing for listing available voices"""
params = {}
voices = []
while True:
try:
# Request list of available voices, if a continuation token
# was returned by the previous call then use it to continue
# listing
response = polly.describe_voices(**params)
except (BotoCoreError, ClientError) as err:
# The service returned an error
str(err))
44
# Collect all the voices
voices.extend(response.get("Voices", []))
# If a continuation token was returned continue, stop iterating
# otherwise
if "NextToken" in response:
params = {"NextToken": response["NextToken"]}
else:
break
json_data = json_encode(voices)
bytes_data = bytes(json_data, "utf-8") if sys.version_info >= (3, 0)
\
else bytes(json_data)
content_type="application/json",
# Create a binary stream for the JSON data
data_stream=BytesIO(bytes_data))
def route_read(self, path, query):
"""Handles routing for reading text (speech synthesis)"""
# Get the parameters from the query string
text = self.query_get(query, "text")
voiceId = self.query_get(query, "voiceId")
outputFormat = self.query_get(query, "outputFormat")
# Validate the parameters, set error flag in case of unexpected
# values
if len(text) == 0 or len(voiceId) == 0 or \
outputFormat not in AUDIO_FORMATS:
raise HTTPStatusError(HTTP_STATUS["BAD_REQUEST"],
"Wrong parameters")
else:
try:
# Request speech synthesis
response = polly.synthesize_speech(Text=text,
VoiceId=voiceId,
OutputFormat=outputFormat)
except (BotoCoreError, ClientError) as err:
# The service returned an error
str(err))
content_type=AUDIO_FORMATS[outputFormat],
# Access the audio stream in the response
data_stream=response.get("AudioStream"))
def send_headers(self, status, content_type):
"""Send out the group of headers for a successful request"""
# Send HTTP headers
self.send_response(status.code, status.message)
self.send_header('Content-type', content_type)
self.send_header('Transfer-Encoding', 'chunked')
self.send_header('Connection', 'close')
self.end_headers()
45
def stream_data(self, stream):
"""Consumes a stream in chunks to produce the response's output'"""
print("Streaming started...")
if stream:
# Note: Closing the stream is important as the service throttles
on
# the number of parallel connections. Here we are using
# contextlib.closing to ensure the close method of the stream
object
# will be called automatically at the end of the with statement's
# scope.
with closing(stream) as managed_stream:
# Push out the stream's content in chunks
while True:
data = managed_stream.read(CHUNK_SIZE)
self.wfile.write(b"%X\r\n%s\r\n" % (len(data), data))
# If there's no more data to read, stop streaming
if not data:
break
# Ensure any buffered output has been transmitted and close
the
# stream
self.wfile.flush()
print("Streaming completed.")
else:
# The stream passed in is empty
self.wfile.write(b"0\r\n\r\n")
print("Nothing to stream.")
cli = ArgumentParser(description='Example Python Application')
cli.add_argument(
"-p", "--port", type=int, metavar="PORT", dest="port", default=8000)
cli.add_argument(
"--host", type=str, metavar="HOST", dest="host", default="localhost")
# If the module is invoked directly, initialize the application
if __name__ == '__main__':
# Create and configure the HTTP server instance
server = ThreadedHTTPServer((arguments.host, arguments.port),
ChunkedHTTPRequestHandler)
print("Starting server, use <Ctrl-C> to stop...")
print(u"Open {0}://{1}:{2}{3} in a web browser.".format(PROTOCOL,
arguments.host,
arguments.port,
ROUTE_INDEX))
try:
# Listen for requests indefinitely
server.serve_forever()
except KeyboardInterrupt:
# A request to terminate has been received, stop the server
print("\nShutting down...")
46
server.socket.close()
47
Exemple Android
Exemple Android
L'exemple suivant utilise le SDK Android pour Amazon Polly pour lire le texte spécifié à l'aide d'une
voix sélectionnée dans une liste de voix.
Le code, affiché ici, couvre les tâches principales, mais ne gère pas les d'erreurs. Pour obtenir le code
complet, consultez la démonstration Amazon Polly AWS SDK pour Android.
Initialiser
// Cognito pool ID. Pool needs to be unauthenticated pool with
// Amazon Polly permissions.
String COGNITO_POOL_ID = "YourCognitoIdentityPoolId";
// Region of Amazon Polly.
Regions MY_REGION = Regions.US_EAST_1;
// Initialize the Amazon Cognito credentials provider.
CognitoCachingCredentialsProvider credentialsProvider = new
CognitoCachingCredentialsProvider(
getApplicationContext(),
COGNITO_POOL_ID,
MY_REGION
);
// Create a client that supports generation of presigned URLs.
AmazonPollyPresigningClient client = new
AmazonPollyPresigningClient(credentialsProvider);
Obtenir la liste des voix disponibles
// Create describe voices request.
DescribeVoicesRequest describeVoicesRequest = new DescribeVoicesRequest();
// Synchronously ask Amazon Polly to describe available TTS voices.
DescribeVoicesResult describeVoicesResult =
client.describeVoices(describeVoicesRequest);
List<Voice> voices = describeVoicesResult.getVoices();
Obtenir l'URL du flux audio
// Create speech synthesis request.
SynthesizeSpeechPresignRequest synthesizeSpeechPresignRequest =
new SynthesizeSpeechPresignRequest()
// Set the text to synthesize.
.withText("Hello world!")
// Select voice for synthesis.
.withVoiceId(voices.get(0).getId()) // "Joanna"
// Set format to MP3.
.withOutputFormat(OutputFormat.Mp3);
// Get the presigned URL for synthesized speech audio stream.
URL presignedSynthesizeSpeechUrl =
48
Exemple Android
client.getPresignedSynthesizeSpeechUrl(synthesizeSpeechPresignRequest);
Lire la synthèse vocale
// Use MediaPlayer: https://developer.android.com/guide/topics/media/
mediaplayer.html
// Create a media player to play the synthesized audio stream.
MediaPlayer mediaPlayer = new MediaPlayer();
mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
try {
// Set media player's data source to previously obtained URL.
mediaPlayer.setDataSource(presignedSynthesizeSpeechUrl.toString());
} catch (IOException e) {
Log.e(TAG, "Unable to set data source for the media player! " +
e.getMessage());
}
// Prepare the MediaPlayer asynchronously (since the data source is a network
stream).
mediaPlayer.prepareAsync();
// Set the callback to start the MediaPlayer when it's prepared.
mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
@Override
public void onPrepared(MediaPlayer mp) {
mp.start();
}
});
// Set the callback to release the MediaPlayer after playback is completed.
mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
mp.release();
}
});
49
Exemple iOS
Exemple iOS
L'exemple suivant utilise le kit SDK iOS pour Amazon Polly pour lire le texte spécifié à l'aide d'une voix
sélectionnée dans une liste de voix.
Le code, affiché ici, couvre les tâches principales, mais ne gère pas les d'erreurs. Pour obtenir le code
complet, consultez la démonstration Amazon Polly AWS SDK pour iOS.
Initialiser
// Region of Amazon Polly.
let AwsRegion = AWSRegionType.usEast1
// Cognito pool ID. Pool needs to be unauthenticated pool with
// Amazon Polly permissions.
let CognitoIdentityPoolId = "YourCognitoIdentityPoolId"
// Initialize the Amazon Cognito credentials provider.
let credentialProvider = AWSCognitoCredentialsProvider(regionType: AwsRegion,
identityPoolId: CognitoIdentityPoolId)
// Create an audio player
var audioPlayer = AVPlayer()
Obtenir la liste des voix disponibles
// Use the configuration as default
AWSServiceManager.default().defaultServiceConfiguration = configuration
// Get all the voices (no parameters specified in input) from Amazon Polly
// This creates an async task.
let task = AWSPolly.default().describeVoices(AWSPollyDescribeVoicesInput())
// When the request is done, asynchronously do the following block
// (we ignore all the errors, but in a real-world scenario they need
// to be handled)
task.continue(successBlock: { (awsTask: AWSTask) -> Any? in
// awsTask.result is an instance of AWSPollyDescribeVoicesOutput in
// case of the "describeVoices" method
let voices = (awsTask.result! as AWSPollyDescribeVoicesOutput).voices
return nil
})
Synthèse vocale
// First, Amazon Polly requires an input, which we need to prepare.
// Again, we ignore the errors, however this should be handled in
// real applications. Here we are using the URL Builder Request,
// since in order to make the synthesis quicker we will pass the
// presigned URL to the system audio player.
let input = AWSPollySynthesizeSpeechURLBuilderRequest()
// Text to synthesize
50
Exemple iOS
input.text = “Sample text”
// We expect the output in MP3 format
input.outputFormat = AWSPollyOutputFormat.mp3
// Choose the voice ID
input.voiceId = AWSPollyVoiceId.joanna
// Create an task to synthesize speech using the given synthesis input
let builder =
AWSPollySynthesizeSpeechURLBuilder.default().getPreSignedURL(input)
// Request the URL for synthesis result
builder.continue(successBlock: { (awsTask: AWSTask<NSURL>) -> Any? in
// The result of getPresignedURL task is NSURL.
// Again, we ignore the errors in the example.
let url = awsTask.result!
// Try playing the data using the system AVAudioPlayer
self.audioPlayer.replaceCurrentItem(with: AVPlayerItem(url: url as URL))
self.audioPlayer.play()
return nil
})
51
Régions prises en charge
Limites d'Amazon Polly
Ci-après, figurent les limites à prendre en compte lors de l'utilisation d'Amazon Polly.
Régions prises en charge
Pour obtenir la liste des régions AWS où Amazon Polly est disponible, consultez la page Régions et
points de terminaison AWS dans le Référence générale d'Amazon Web Services.
Limitation
• Taux de limitation par adresse IP : 20 requêtes par seconde (rps) avec une limite en mode rafale de
40 rps.
• Taux de limitation par compte : 10 requêtes par seconde (rps) avec une limite en mode rafale de
20 rps.
Connexions simultanées par compte : 30
• Taux de limitation par opération :
Opération
Limite
Lexique
DeleteLexicon
2 requêtes par seconde (rps) à partir de ces opérations
combinées.
PutLexicon
Maximum autorisé en mode rafale de 4 rps.
GetLexicon
ListLexicons
Discours
DescribeVoices
10 rps avec une limite en mode rafale de 20 rps
SynthesizeSpeech
10 rps avec une limite en mode rafale de 20 rps
52
Lexiques de prononciation
Lexiques de prononciation
• Vous pouvez stocker jusqu'à 100 lexiques par compte.
• Les noms des lexiques peuvent être constitués d'une chaîne alphanumérique de 20 caractères
maximum.
• Chaque lexique peut comporter jusqu'à 4 000 caractères maximum.
• Vous pouvez spécifier jusqu'à 100 caractères pour chaque remplacement de phonème<> ou
d'alias<> dans un lexique.
Pour plus d'informations sur l'utilisation des lexiques, consultez Gestion des lexiques (p. 21).
Opération API SynthesizeSpeech
Notez les limites suivantes liées à l'utilisation de l'opération API SynthesizeSpeech :
• Le texte d'entrée peut comporter un maximum de 1 500 caractères facturés (3 000 caractères au
total). Les balises SSML ne sont pas considérées comme des caractères facturés.
• Vous pouvez spécifier jusqu'à cinq lexiques à appliquer au texte saisi.
• Le flux audio de sortie (synthèse) est limité à 5 minutes, au-delà desquelles, le discours restant est
coupé.
Pour plus d'informations, consultez SynthesizeSpeech (p. 71).
Synthèse vocale SSML (Markup Language)
Notez les limites suivantes liées à l'utilisation du langage SSML :
• Les balises <audio>, <lexicon>, <lookup> et <voice> ne sont pas prises en charge.
• Les éléments <break> peuvent spécifier une durée maximale de 10 secondes chacun.
• La balise <prosody> ne prend pas en charge les valeurs inférieures à -80 % pour l'attribut de taux.
Pour plus d'informations, consultez Utilisation de SSML (p. 14).
53
Informations relatives à Amazon Polly dans CloudTrail
Journalisation des appels d'API
Amazon Polly avec AWS CloudTrail
Amazon Polly est intégré dans CloudTrail, un service qui enregistre tous les appels APIAmazon Polly
et transmet les fichiers-journaux dans un compartiment Amazon S3 que vous spécifiez. CloudTrail
enregistré les appels d'API provenant de la console Amazon Polly ou de votre code aux API Amazon
Polly. Les informations collectées par CloudTrail vous permettent de déterminer quelle demande a été
envoyée à Amazon Polly, l'adresse IP source à partir de laquelle la demande a été effectuée, qui a
effectué la demande, quand, etc.
Pour en savoir plus sur CloudTrail, y compris la façon de le configurer et de l'activer, consultez le
manuel AWS CloudTrail User Guide.
Informations relatives à Amazon Polly dans
CloudTrail
Lorsque la journalisation CloudTrailest activée dans votre compte AWS, les appels d'API effectués à
destination des actions Amazon Polly sont suivis dans les fichiers journaux CloudTrail, où ils sont écrits
avec d'autres enregistrements de services AWS. CloudTrail détermine quand créer un fichier et écrire
dedans en fonction d'une période et d'une taille de fichier.
Toutes les actions Amazon Polly sont consignées par CloudTrail et sont documentées dans la
Référence de l'API Amazon Polly (p. 60). Les actions suivantes sont prises en charge.
• DeleteLexicon (p. 61)
• DescribeVoices (p. 63)
• GetLexicon (p. 65)
• ListLexicons (p. 67)
• PutLexicon (p. 69)
• SynthesizeSpeech (p. 71)
Chaque entrée du journal contient des informations sur la personne qui a généré la demande. Les
informations d'identité de l'utilisateur dans l'entrée de journal permettent de déterminer les éléments
suivants :
54
Présentation des entrées des
fichiers journaux Amazon Polly
• Si la demande a été effectuée avec les informations d'identification utilisateur racine ou IAM
• Si la demande a été effectuée avec des informations d'identification de sécurité temporaires pour un
rôle ou un utilisateur fédéré
• Si la demande a été effectuée par un autre service AWS
Pour plus d'informations, consultez la section CloudTrail userIdentity Element.
Vous pouvez stocker vos fichiers journaux dans votre compartiment Amazon S3 aussi longtemps que
vous le souhaitez, mais vous pouvez également définir des règles de cycle de vie Amazon S3 pour
archiver ou supprimer automatiquement les fichiers journaux. Par défaut, vos fichiers journaux sont
chiffrés avec le chiffrement côté serveur (SSE) de Amazon S3.
Si vous souhaitez être averti de la remise des fichiers journaux, vous pouvez configurer CloudTrail
pour qu'il publie des notifications Amazon SNS lorsque de nouveaux fichiers journaux sont remis. Pour
plus d'informations, consultez Configuring Amazon SNS Notifications for CloudTrail.
Vous pouvez également regrouper des fichiers journaux Amazon Polly provenant de plusieurs régions
AWS et de plusieurs comptes AWS dans un compartiment Amazon S3 unique.
Pour plus d'informations, consultez Receiving CloudTrail Log Files from Multiple Regions et Receiving
CloudTrail Log Files from Multiple Accounts.
Présentation des entrées des fichiers journaux
Amazon Polly
Les fichiers journaux CloudTrail peuvent contenir une ou plusieurs des entrées de journal. Chaque
entrée répertorie plusieurs événements au format JSON. Une entrée de journal représente une
demande individuelle à partir de n'importe quelle source et comprend des informations sur l'action
demandée, sur la date et l'heure de l'action, sur les paramètres de la demande, etc. Les entrées de
journal ne sont pas des arborescences des appels de procédure des appels d'API publique. Elle ne
s'affichent donc dans aucun ordre précis.
En raison des éventuels problèmes de confidentialité, les entrées de journal ne contiennent pas le
texte synthétisé. A la place, ce texte est consigné dans l'entrée de journal.
L'exemple suivant montre une entrée de journal CloudTrail qui illustre l'action SynthesizeSpeech.
{
"Records": [
{
"awsRegion": "us-east-1",
"eventID": "19bd70f7-5e60-4cdc-9825-936c552278ae",
"eventName": "SynthesizeSpeech",
"eventSource": "tts.amazonaws.com",
"eventTime": "2016-11-02T03:49:39Z",
"eventType": "AwsApiCall",
"eventVersion": "1.05",
"recipientAccountId": "123456789012",
"requestID": "414288c2-a1af-11e6-b17f-d7cfc06cb461",
"requestParameters": {
"lexiconNames": [
"SampleLexicon"
],
"outputFormat": "mp3",
"sampleRate": "22050",
55
Présentation des entrées des
fichiers journaux Amazon Polly
"text": "**********",
"textType": "text",
"voiceId": "Kendra"
},
"responseElements": {
"contentType": "audio/mpeg",
"requestCharacters": 25
},
"sourceIPAddress": "1.2.3.4",
"userAgent": "Amazon CLI/Polly 1.10 API 2016-06-10",
"userIdentity": {
"accessKeyId": "EXAMPLE_KEY_ID",
"accountId": "123456789012",
"arn": "arn:aws:iam::123456789012:user/Alice",
"principalId": "EX_PRINCIPAL_ID",
"type": "IAMUser",
"userName": "Alice"
}
}
]
}
L'élément eventName identifie l'action qui s'est produite et il peut inclure des informations de date et
de version, telles que "SynthesizeSpeech20161128". Néanmoins, il fait toujours référence à la
même API publique.
56
Métriques CloudWatch (Console)
Intégration de CloudWatch avec
Amazon Polly
Lorsque vous interagissez avec Amazon Polly, les métriques et les dimensions suivantes sont
envoyées à CloudWatch toutes les minutes. Vous pouvez utiliser les procédures suivantes pour
afficher les métriques d'Amazon Polly.
Vous pouvez contrôler Amazon Polly à l'aide de CloudWatch, qui recueille et traite les données brutes
de Amazon Polly en métriques lisibles et disponibles pratiquement en temps réel. Ces statistiques
sont enregistrées pour une durée de deux semaines et, par conséquent, vous pouvez accéder aux
historical information et acquérir un meilleur point de vue sur les performances de votre
service ou application Web. Par défaut, les données des métriques Amazon Polly sont envoyées
à CloudWatch chaque minute. Pour plus d'informations, consultez la page Qu'est-ce qu'Amazon
CloudWatch du guide de l'utilisateur CloudWatch Amazon.
Métriques CloudWatch (Console)
1.
Ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.
2.
Dans le volet de navigation, choisissez Metrics.
3.
Dans le volet CloudWatch Metrics by Category, sous la catégorie de métriques Amazon Polly,
sélectionnez une catégorie de métriques, puis, dans le volet supérieur, faites défiler l'écran pour
afficher la liste complète des métriques.
Métriques CloudWatch (Interface de ligne de
commande)
Le code suivant affiche les métriques disponibles pour Amazon Polly.
aws cloudwatch list-metrics --namespace "AWS/Polly"
57
Métriques Amazon Polly
La commande précédente retourne une liste des métriques Amazon Polly similaires à ce qui suit.
L'élément MetricName identifie ce qu'est la métrique.
{
"Metrics": [
{
"Namespace": "AWS/Polly",
"Dimensions": [
{
"Name": "Operation",
"Value": "SynthesizeSpeech"
}
],
"MetricName": "ResponseLatency"
},
{
"Namespace": "AWS/Polly",
"Dimensions": [
{
"Name": "Operation",
"Value": "SynthesizeSpeech"
}
],
"MetricName": "RequestCharacters"
}
Pour plus d'informations, consultez GetMetricStatistics dans la Référence de l'API Amazon
CloudWatch.
Métriques Amazon Polly
Amazon Polly produit les métriques suivantes pour chaque demande. Ces métriques sont regroupées
et envoyées, par intervalles d'une minute, à CloudWatch où elles sont disponibles.
Métrique
Description
RequestCharacters
Nombre de caractères de la demande. Il s'agit de
caractères facturables uniquement ; les balises SSML
ne sont pas incluses.
Dimension valide : Opération
Statistiques valides : Minimum, Maximum, Moyenne,
Exemple de comptage, Somme
Unité : nombre
ResponseLatency
Latence entre le moment où la demande a été faite et
le début de la réponse de diffusion en continu.
Dimensions valides : Operation
Statistiques valides : Minimum, Maximum, Moyenne,
Exemple de comptage
Unité : millisecondes
58
Dimensions pour les métriques Amazon Polly
Métrique
Description
2XXCount
Code HTTP 200 retourné lors d'une réponse positive.
Statistiques valides : Moyenne, Exemple de comptage,
Somme
Unité : nombre
4XXCount
Code erreur HTTP 400 retourné en cas d'erreur. Pour
chaque réponse aboutie, un zéro (0) est émis.
Somme
Unité : nombre
5XXCount
Code erreur HTTP 500 retourné en cas d'erreur. Pour
chaque réponse aboutie, un zéro (0) est émis.
Somme
Unité : nombre
Dimensions pour les métriques Amazon Polly
Les métriques Amazon Polly utilisent l'espace de noms AWS/Polly et fournissent les métriques pour
les dimensions suivantes :
Dimension
Description
Operation
Les métriques sont regroupées par la méthode
d'API à laquelle elles font référence. Les valeurs
possibles sont SynthesizeSpeech, PutLexicon,
DescribeVoices, etc.
59
Actions
Référence de l'API Amazon Polly
Cette section contient la référence de l'API Amazon Polly.
Note
Les appels d'API authentifiés doivent être signés à l'aide du processus de signature
« Signature Version 4 ». Pour plus d'informations, consultez Signature des requêtes d'API
AWS du Référence générale d'Amazon Web Services.
Rubriques
• Actions (p. 60)
• Data Types (p. 73)
Actions
The following actions are supported:
• DeleteLexicon (p. 61)
• DescribeVoices (p. 63)
• GetLexicon (p. 65)
• ListLexicons (p. 67)
• PutLexicon (p. 69)
• SynthesizeSpeech (p. 71)
60
DeleteLexicon
DeleteLexicon
Deletes the specified pronunciation lexicon stored in an AWS Region. A lexicon which has been
deleted is not available for speech synthesis, nor is it possible to retrieve it using either the
GetLexicon or ListLexicon APIs.
For more information, see Managing Lexicons.
Request Syntax
DELETE /v1/lexicons/LexiconName HTTP/1.1
URI Request Parameters
The request requires the following URI parameters.
Name (p. 61)
The name of the lexicon to delete. Must be an existing lexicon in the region.
Pattern: [0-9A-Za-z]{1,20}
Request Body
The request does not have a request body.
Response Syntax
HTTP/1.1 200
Response Elements
If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.
Errors
LexiconNotFoundException
Amazon Polly can't find the specified lexicon. This could be caused by a lexicon that is missing, its
name is misspelled or specifying a lexicon that is in a different region.
Verify that the lexicon exists, is in the region (see ListLexicons (p. 67)) and that you spelled its
name is spelled correctly. Then try again.
HTTP Status Code: 404
ServiceFailureException
An unknown condition has caused a service failure.
See Also
For more information about using this API in one of the language-specific AWS SDKs, see the
following:
• AWS Command Line Interface
• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
61
DeleteLexicon
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V2
62
DescribeVoices
DescribeVoices
Returns the list of voices that are available for use when requesting speech synthesis. Each voice
speaks a specified language, is either male or female, and is identified by an ID, which is the ASCII
version of the voice name.
When synthesizing speech ( SynthesizeSpeech ), you provide the voice ID for the voice you want
from the list of voices returned by DescribeVoices.
For example, you want your news reader application to read news in a specific language, but giving a
user the option to choose the voice. Using the DescribeVoices operation you can provide the user
with a list of available voices to select from.
You can optionally specify a language code to filter the available voices. For example, if you specify
en-US, the operation returns a list of all available US English voices.
This operation requires permissions to perform the polly:DescribeVoices action.
Request Syntax
GET /v1/voices?LanguageCode=LanguageCode&NextToken=NextToken HTTP/1.1
LanguageCode (p. 63)
The language identification tag (ISO 639 code for the language name-ISO 3166 country code) for
filtering the list of voices returned. If you don't specify this optional parameter, all available voices
are returned.
Valid Values: cy-GB | da-DK | de-DE | en-AU | en-GB | en-GB-WLS | en-IN | enUS | es-ES | es-US | fr-CA | fr-FR | is-IS | it-IT | ja-JP | nb-NO | nl-NL
| pl-PL | pt-BR | pt-PT | ro-RO | ru-RU | sv-SE | tr-TR
NextToken (p. 63)
An opaque pagination token returned from the previous DescribeVoices operation. If present,
this indicates where to continue the listing.
Request Body
Response Syntax
HTTP/1.1 200
Content-type: application/json
{
"NextToken": "string",
"Voices": [
{
"Gender": "string",
"Id": "string",
"LanguageCode": "string",
"LanguageName": "string",
"Name": "string"
}
]
}
63
DescribeVoices
Response Elements
If the action is successful, the service sends back an HTTP 200 response.
The following data is returned in JSON format by the service.
NextToken (p. 63)
The pagination token to use in the next request to continue the listing of voices. NextToken is
returned only if the response is truncated.
Type: String
Voices (p. 63)
A list of voices with their properties.
Type: array of Voice (p. 77) objects
Errors
InvalidNextTokenException
The NextToken is invalid. Verify that it's spelled correctly, and then try again.
See Also
following:
• AWS SDK for C++
• AWS SDK for Go
64
GetLexicon
GetLexicon
Returns the content of the specified pronunciation lexicon stored in an AWS Region. For more
information, see Managing Lexicons.
Request Syntax
GET /v1/lexicons/LexiconName HTTP/1.1
Name (p. 65)
Name of the lexicon.
Request Body
Response Syntax
HTTP/1.1 200
{
"Lexicon": {
"Content": "string",
"Name": "string"
},
"LexiconAttributes": {
"Alphabet": "string",
"LastModified": number,
"LexemesCount": number,
"LexiconArn": "string",
"Size": number
}
}
Response Elements
Lexicon (p. 65)
Lexicon object that provides name and the string content of the lexicon.
Type: Lexicon (p. 74) object
LexiconAttributes (p. 65)
Metadata of the lexicon, including phonetic alphabetic used, language code, lexicon ARN, number
of lexemes defined in the lexicon, and size of lexicon in bytes.
Type: LexiconAttributes (p. 75) object
65
GetLexicon
Errors
See Also
following:
• AWS SDK for C++
• AWS SDK for Go
66
ListLexicons
ListLexicons
Returns a list of pronunciation lexicons stored in an AWS Region. For more information, see Managing
Lexicons.
Request Syntax
GET /v1/lexicons?NextToken=NextToken HTTP/1.1
NextToken (p. 67)
An opaque pagination token returned from previous ListLexicons operation. If present,
indicates where to continue the list of lexicons.
Request Body
Response Syntax
HTTP/1.1 200
{
"Lexicons": [
{
"Attributes": {
"Alphabet": "string",
"LastModified": number,
"LexemesCount": number,
"LexiconArn": "string",
"Size": number
},
"Name": "string"
}
],
"NextToken": "string"
}
Response Elements
Lexicons (p. 67)
A list of lexicon names and attributes.
Type: array of LexiconDescription (p. 76) objects
NextToken (p. 67)
The pagination token to use in the next request to continue the listing of lexicons. NextToken is
returned only if the response is truncated.
Type: String
67
ListLexicons
Errors
InvalidNextTokenException
The NextToken is invalid. Verify that it's spelled correctly, and then try again.
See Also
following:
• AWS SDK for C++
• AWS SDK for Go
68
PutLexicon
PutLexicon
Stores a pronunciation lexicon in an AWS Region. If a lexicon with the same name already exists in the
region, it is overwritten by the new lexicon. Lexicon operations have eventual consistency, therefore, it
might take some time before the lexicon is available to the SynthesizeSpeech operation.
Request Syntax
PUT /v1/lexicons/LexiconName HTTP/1.1
{
"Content": "string"
}
Name (p. 69)
Name of the lexicon. The name must follow the regular express format [0-9A-Za-z]{1,20}. That is,
the name is a case-sensitive alphanumeric string up to 20 characters long.
Request Body
The request accepts the following data in JSON format.
Content (p. 69)
Content of the PLS lexicon as string data.
Type: String
Required: Yes
Response Syntax
HTTP/1.1 200
Response Elements
If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.
Errors
InvalidLexiconException
Amazon Polly can't find the specified lexicon. Verify that the lexicon's name is spelled correctly,
and then try again.
LexiconSizeExceededException
The maximum size of the specified lexicon would be exceeded by this operation.
MaxLexemeLengthExceededException
The maximum size of the lexeme would be exceeded by this operation.
69
PutLexicon
MaxLexiconsNumberExceededException
The maximum number of lexicons would be exceeded by this operation.
UnsupportedPlsAlphabetException
The alphabet specified by the lexicon is not a supported alphabet. Valid values are x-sampa and
ipa.
UnsupportedPlsLanguageException
The language specified in the lexicon is unsupported. For a list of supported languages, see
Lexicon Attributes.
See Also
following:
• AWS SDK for C++
• AWS SDK for Go
70
SynthesizeSpeech
SynthesizeSpeech
Synthesizes UTF-8 input, plain text or SSML, to a stream of bytes. SSML input must be valid, wellformed SSML. Some alphabets might not be available with all the voices (for example, Cyrillic might
not be read at all by English voices) unless phoneme mapping is used. For more information, see How
it Works.
Request Syntax
POST /v1/speech HTTP/1.1
{
"LexiconNames": [ "string" ],
"OutputFormat": "string",
"SampleRate": "string",
"Text": "string",
"TextType": "string",
"VoiceId": "string"
}
The request does not use any URI parameters.
Request Body
The request accepts the following data in JSON format.
LexiconNames (p. 71)
List of one or more pronunciation lexicon names you want the service to apply during synthesis.
Lexicons are applied only if the language of the lexicon is the same as the language of the voice.
For information about storing lexicons, see PutLexicon.
Type: array of Strings
Array Members: Maximum number of 5 items.
Required: No
OutputFormat (p. 71)
The audio format in which the resulting stream will be encoded.
Type: String
Valid Values: mp3 | ogg_vorbis | pcm
Required: Yes
SampleRate (p. 71)
The audio frequency specified in Hz.
The valid values for mp3 and ogg_vorbis are "8000", "16000", and "22050". The default value is
"22050".
Valid values for pcm are "8000" and "16000" The default value is "16000".
Type: String
Required: No
Text (p. 71)
Input text to synthesize. If you specify ssml as the TextType, follow the SSML format for the input
text.
Type: String
Required: Yes
71
SynthesizeSpeech
TextType (p. 71)
Specifies whether the input text is plain text or SSML. The default value is plain text. For more
information, see Using SSML.
Type: String
Valid Values: ssml | text
Required: No
VoiceId (p. 71)
Voice ID to use for the synthesis. You can get a list of available voice IDs by calling the
DescribeVoices operation.
Type: String
Valid Values: Geraint | Gwyneth | Mads | Naja | Hans | Marlene | Nicole |
Russell | Amy | Brian | Emma | Raveena | Ivy | Joanna | Joey | Justin
| Kendra | Kimberly | Salli | Conchita | Enrique | Miguel | Penelope |
Chantal | Celine | Mathieu | Dora | Karl | Carla | Giorgio | Mizuki | Liv
| Lotte | Ruben | Ewa | Jacek | Jan | Maja | Ricardo | Vitoria | Cristiano
| Ines | Carmen | Maxim | Tatyana | Astrid | Filiz
Required: Yes
Response Syntax
HTTP/1.1 200
Content-Type: ContentType
x-amzn-RequestCharacters: RequestCharacters
AudioStream
Response Elements
The response returns the following HTTP headers.
ContentType (p. 72)
Specifies the type audio stream. This should reflect the OutputFormat parameter in your request.
• If you request mp3 as the OutputFormat, the ContentType returned is audio/mpeg.
• If you request ogg_vorbis as the OutputFormat, the ContentType returned is audio/ogg.
• If you request pcm as the OutputFormat, the ContentType returned is audio/pcm in a signed
16-bit, 1 channel (mono), little-endian format.
RequestCharacters (p. 72)
Number of characters synthesized.
The response returns the following as the HTTP body.
<varlistentry> AudioStream (p. 72)
Stream containing the synthesized speech.
</varlistentry>
Errors
InvalidSampleRateException
The specified sample rate is not valid.
72
Data Types
InvalidSsmlException
The SSML you provided is invalid. Verify the SSML syntax, spelling of tags and values, and then
try again.
TextLengthExceededException
The value of the "Text" parameter is longer than the accepted limits. The limit for input text is a
maximum of 3000 characters total, of which no more than 1500 can be billed characters. SSML
tags are not counted as billed characters.
See Also
following:
• AWS SDK for C++
• AWS SDK for Go
Data Types
The following data types are supported:
• Lexicon (p. 74)
• LexiconAttributes (p. 75)
• LexiconDescription (p. 76)
• Voice (p. 77)
73
Lexicon
Lexicon
Provides lexicon name and lexicon content in string format. For more information, see Pronunciation
Lexicon Specification (PLS) Version 1.0.
Contents
Content
Lexicon content in string format. The content of a lexicon must be in PLS format.
Type: String
Required: No
Name
Type: String
Required: No
See Also
following:
• AWS SDK for C++
• AWS SDK for Go
74
LexiconAttributes
LexiconAttributes
Contains metadata describing the lexicon such as the number of lexemes, language code, and so on.
Contents
Alphabet
Phonetic alphabet used in the lexicon. Valid values are ipa and x-sampa.
Type: String
Required: No
LanguageCode
Language code that the lexicon applies to. A lexicon with a language code such as "en" would be
applied to all English languages (en-GB, en-US, en-AUS, en-WLS, and so on.
Type: String
Required: No
LastModified
Date lexicon was last modified (a timestamp value).
Type: Timestamp
Required: No
LexemesCount
Number of lexemes in the lexicon.
Type: Integer
Required: No
LexiconArn
Amazon Resource Name (ARN) of the lexicon.
Type: String
Required: No
Size
Total size of the lexicon, in characters.
Type: Integer
Required: No
See Also
following:
• AWS SDK for C++
• AWS SDK for Go
75
LexiconDescription
LexiconDescription
Describes the content of the lexicon.
Contents
Attributes
Provides lexicon metadata.
Type: LexiconAttributes (p. 75) object
Required: No
Name
Type: String
Required: No
See Also
following:
• AWS SDK for C++
• AWS SDK for Go
76
Voice
Voice
Description of the voice.
Contents
Gender
Gender of the voice.
Type: String
Valid Values: Female | Male
Required: No
Id
Amazon Polly assigned voice ID. This is the ID that you specify when calling the
SynthesizeSpeech operation.
Type: String
Valid Values: Geraint | Gwyneth | Mads | Naja | Hans | Marlene | Nicole |
Russell | Amy | Brian | Emma | Raveena | Ivy | Joanna | Joey | Justin
| Kendra | Kimberly | Salli | Conchita | Enrique | Miguel | Penelope |
Chantal | Celine | Mathieu | Dora | Karl | Carla | Giorgio | Mizuki | Liv
| Lotte | Ruben | Ewa | Jacek | Jan | Maja | Ricardo | Vitoria | Cristiano
| Ines | Carmen | Maxim | Tatyana | Astrid | Filiz
Required: No
LanguageCode
Language code of the voice.
Type: String
Required: No
LanguageName
Human readable name of the language in English.
Type: String
Required: No
Name
Name of the voice (for example, Salli, Kendra, etc.). This provides a human readable voice name
that you might display in your application.
Type: String
Required: No
See Also
following:
•
•
•
•
AWS SDK for C++
AWS SDK for Go
AWS SDK for Java
AWS SDK for Ruby V2
77
Authentification
Authentification et contrôle d'accès
pour Amazon Polly
L'accès à Amazon Polly requiert des informations d'identification. Ces informations d'identification
doivent disposer d'autorisations pour accéder aux ressources AWS, telles qu'une table Amazon Polly
lexicon ou une instance Amazon Elastic Compute Cloud (Amazon EC2). Les sections suivantes
décrivent comment utiliser AWS Identity and Access Management (IAM) et Amazon Polly pour
contribuer à sécuriser l'accès à vos ressources.
• Authentification (p. 78)
• Contrôle d'accès (p. 79)
Authentification
Vous pouvez utiliser les types d'identité suivants pour accéder à AWS :
• Utilisateur racine du compte AWS – Lorsque vous vous inscrivez à AWS, vous fournissez une
adresse de messagerie et un mot de passe qui sont associés à votre compte AWS. Il s'agit de
vos informations d'identification racine et elles fournissent un accès complet à l'ensemble de vos
ressources AWS.
Important
Pour des raisons de sécurité, nous vous conseillons d'utiliser les informations
d'identification racine uniquement pour créer un utilisateur administrateur, qui est un
utilisateur IAM disposant des autorisations complètes sur votre compte AWS. Vous pouvez
ensuite utiliser cet utilisateur administrateur pour créer d'autres utilisateurs IAM et des rôles
dotés d'autorisations limitées. Pour plus d'informations, consultez Bonnes pratiques IAM
et Création d'un utilisateurs administrateur et d'un groupe dans le manuel IAM Guide de
l'utilisateur.
• Utilisateur IAM; – Un utilisateur IAM est simplement une identité au sein de votre compte AWS qui
dispose d'autorisations personnalisées spécifiques (par exemple, des autorisations pour créer a
lexicon dans Amazon Polly). Vous pouvez utiliser un nom utilisateur et un mot de passe IAM pour
vous connecter aux pages Web AWS sécurisées telles que AWS Management Console, les forums
de discussion 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ès
pour chaque utilisateur. Vous pouvez utiliser ces clés lorsque vous accédez aux services AWS par
78
Contrôle d'accès
programmation, soit par le biais d'un kit SDK soit à l'aide d'AWS Command Line Interface (CLI). Les
outils de l'interface de ligne de commande et les kits SDK utilisent les clés d'accès pour signer de
façon cryptographique votre demande. Si vous n'utilisez pas les outils AWS, vous devez signer la
demande vous-même. Amazon Polly prend en charge Signature Version 4, un protocole permettant
l'authentification des demandes d'API entrantes. Pour plus d'informations sur l'authentification des
demandes, consultez la rubrique Processus de signature Signature Version 4 dans la documentation
AWS General Reference.
• Rôle IAM – Un rôle IAM est une autre 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 pas associé à une personne en particulier. Un rôle IAM vous permet d'obtenir des clés d'accès
temporaires qui peuvent être utilisées pour accéder aux ressources et services AWS. Les rôles IAM
avec des informations d'identification temporaires sont utiles dans les cas suivants :
• Accès par des utilisateurs fédérés : au lieu de créer un utilisateur IAM, vous pouvez utiliser
des identités d'utilisateur préexistantes provenant d'AWS Directory Service, de votre répertoire
utilisateur d'entreprise ou d'un fournisseur d'identité web. Ces derniers sont appelés utilisateurs
fédérés. AWS attribue un rôle à un utilisateur fédéré lorsque l'accès est demandé via un
fournisseur d'identité. Pour plus d'informations sur les utilisateurs fédérés, consultez Utilisateurs
fédérés et rôles dans le manuel IAM Guide de l'utilisateur.
• Accès entre comptes : vous pouvez utiliser un rôle IAM de votre compte pour autoriser un autre
compte AWS à accéder aux ressources de votre compte. Pour obtenir un exemple, consultez le
Didacticiel : Déléguer l'accès entre des comptes AWS à l'aide de rôles IAM dans le manuel IAM
• Accès au service AWS : vous pouvez utiliser un rôle IAM de votre compte pour autoriser un
service AWS à accéder aux ressources de votre compte. Par exemple, vous pouvez créer un rôle
qui permet à Amazon Redshift d'accéder à un compartiment Amazon S3 en votre nom, puis de
charger les données stockées dans le compartiment dans un cluster Amazon Redshift. Pour plus
d'informations, consultez Création d'un rôle pour déléguer des autorisations à un service AWS
dans la documentation IAM Guide de l'utilisateur.
• Applications qui s'exécutent sur Amazon EC2 : au lieu de stocker des clés d'accès au sein
de l'instance EC2 afin qu'elles soient utilisées par les applications s'exécutant sur l'instance et
d'émettre des demandes d'API AWS, vous pouvez utiliser un rôle IAM pour gérer des informations
d'identification temporaires pour ces applications. Pour attribuer un rôle AWS à une instance EC2
et le rendre disponible pour toutes ses applications, vous pouvez créer un profil d'instance attaché
à l'instance. Un profil d'instance contient le rôle et permet aux programmes qui s'exécutent sur
l'instance EC2 d'obtenir des informations d'identification temporaires. Pour plus d'informations,
consultez Utilisation de rôles pour des applications s'exécutant sur Amazon EC2 dans le manuel
IAM Guide de l'utilisateur.
Contrôle d'accès
Vous pouvez disposer d'informations d'identification valides pour authentifier vos demandes, mais
à moins d'avoir les autorisations requises, vous ne pouvez pas créer de ressources Amazon Polly
79
Présentation de la gestion de l'accès
ni accéder à de telles ressources. Par exemple, vous devez disposer d'autorisations pour créer une
application Amazon Polly lexicon.
Les sections suivantes expliquent comment gérer les autorisations pour Amazon Polly. Nous vous
recommandons de commencer par lire la présentation.
• Présentation de la gestion des autorisations d'accès à vos ressources Amazon Polly (p. 80)
• Utilisation des stratégies basées sur l'identité (stratégies IAM) pour Amazon Polly (p. 83)
• Autorisations d'API Amazon Polly : Référence des actions, des autorisations et des
ressources (p. 88)
Présentation de la gestion des autorisations
d'accès à vos ressources Amazon Polly
Chaque ressource AWS appartient à un compte AWS et les autorisations permettant de créer des
ressources et d'y accéder sont régies par les stratégies d'autorisation. Un administrateur de compte
peut attacher des stratégies d'autorisation aux identités IAM (c'est-à-dire aux utilisateurs, groupes et
rôles), et certains services (tels que AWS Lambda) prennent également en charge l'attachement de
stratégies d'autorisation aux ressources.
Note
Un administrateur de compte (ou utilisateur administrateur) est un utilisateur doté des
privilèges d'administrateur. Pour plus d'informations, consultez Bonnes pratiques IAM dans le
manuel IAM Guide de l'utilisateur.
Lorsque vous accordez des autorisations, vous décidez qui doit les obtenir, à quelles ressources ces
autorisations s'appliquent et les actions spécifiques que vous souhaitez autoriser sur ces ressources.
Rubriques
• Ressources et opérations Amazon Polly (p. 80)
• Présentation de la propriété des ressources (p. 81)
• Gestion de l'accès aux ressources (p. 81)
• Spécification des éléments d'une stratégie : actions, effets et mandataires (p. 82)
• Spécification des conditions dans une stratégie (p. 83)
Ressources et opérations Amazon Polly
Dans Amazon Polly, la ressource principale est a lexicon. Dans votre stratégie, vous utilisez un
Amazon Resource Name (ARN) pour identifier la ressource à laquelle la stratégie s'applique.
Ces ressources et sous-ressources ont un ARN (Amazon Resource Name) unique qui leur est associé,
comme illustré dans le tableau suivant.
Type de ressource
Format ARN
Lexique
arn:aws:polly:region:account-id:lexicon/LexiconName
Amazon Polly fournit un ensemble d'opérations à utiliser avec des ressources Amazon Polly. Pour
obtenir une liste des opérations disponibles, consultez Amazon Polly Référence de l'API Amazon
Polly (p. 60).
80
Présentation de la propriété des ressources
Présentation de la propriété des ressources
Le compte AWS possède les ressources qui sont créés dans le compte, indépendamment de la
personne qui a créé les ressources. Plus spécifiquement, le propriétaire des ressources est le compte
AWS de l'entité principale (à savoir, le compte racine, un utilisateur IAM ou un rôle IAM) qui authentifie
la demande de création des ressources. Les exemples suivants illustrent comment cela fonctionne :
• Si vous utilisez les informations d'identification du compte racine de votre compte AWS pour créer a
lexicon, votre compte AWS est le propriétaire de la ressource (dans Amazon Polly, la ressource est
a lexicon).
• Si vous créez un utilisateur IAM dans votre compte AWS et autorisez cet utilisateur à créer a
lexicon il peut créer a lexicon. Toutefois, votre compte AWS, auquel l'utilisateur appartient, détient la
ressource lexicon.
• Si vous créez un rôle IAM dans votre compte AWS avec des autorisations pour créer a lexicon,
quiconque capable d'assumer le rôle peut créer a lexicon. Votre compte AWS, auquel l'utilisateur
appartient, détient la ressource lexicon.
Gestion de l'accès aux ressources
Une stratégie d'autorisation décrit qui a accès à quoi. La section suivante explique les options
disponibles pour créer des stratégies d'autorisation.
Note
Cette section décrit l'utilisation d'IAM dans le contexte de Amazon Polly. Elle ne fournit pas
d'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 la syntaxe et les descriptions des stratégies IAM, consultez Référence de stratégie AWS
IAM dans le manuel IAM Guide de l'utilisateur.
Les stratégies attachées à une identité IAM sont qualifiées de stratégies basées sur une entité
(stratégies IAM) et les stratégies attachées à une ressource sont qualifiées de stratégies basées sur
une ressource. Amazon Polly prend uniquement en charge les stratégies basées sur une identité.
Rubriques
• Stratégies basées sur une identité (stratégies IAM) (p. 81)
• Stratégies basées sur une ressource (p. 82)
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 les
opérations suivantes :
• Lier une stratégie d'autorisations à un utilisateur ou à un groupe de votre compte – pour
accorder à un utilisateur l'autorisation relative à la création d'une ressource Amazon Polly, comme
a lexicon, vous pouvez lier une stratégie d'autorisations à un utilisateur ou à un groupe auquel
l'utilisateur appartient.
• Attacher une stratégie d'autorisation à un rôle (accorder des autorisations entre comptes)
– Vous pouvez attacher une stratégie d'autorisation basée sur une identité à un rôle IAM pour
accorder des autorisations entre comptes. Par exemple, l'administrateur dans le compte A peut créer
un rôle pour accorder des autorisations entre comptes à un autre compte AWS (par exemple, le
compte B) ou à un service AWS comme suit :
1. L'administrateur du compte A crée un rôle IAM et lie une stratégie d'autorisation au rôle qui
accorde des autorisations sur les ressources dans le compte A.
81
Spécification des éléments d'une
stratégie : actions, effets et mandataires
2. L'administrateur du compte A lie 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 des autorisations pour assumer le rôle à tous
les utilisateurs figurant dans le compte B. Les utilisateurs du compte B sont ainsi autorisés à créer
des ressources ou à y accéder dans le compte A. Le mandataire dans la stratégie d'approbation
peut également être un mandataire de service AWS si vous souhaitez accorder à un service AWS
des autorisations pour assumer ce rôle.
Pour plus d'informations sur l'utilisation d'IAM pour déléguer des autorisations, consultez Gestion de
l'accès dans le manuel IAM Guide de l'utilisateur.
Voici un exemple de stratégie qui accorde des autorisations pour ajouter et obtenir des lexiques, et
pour indiquer la liste des lexiques actuellement disponibles.
Amazon Polly prend en charge des stratégies basées sur une identité pour des actions au niveau
des ressources. Par conséquent, la valeur Resource est indiquée par l'ARN. A titre d'exemple,
arn:aws:polly:us-east-1:account-id:lexicon/* en tant que valeur Resource indique les
autorisations sur tous les lexiques détenus au sein de la région us-east-1.
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowPut-Get-ListActions",
"Effect": "Allow",
"Action": [
"polly:PutLexicon",
"polly:GetLexicon",
"polly:ListLexicons"],
"Resource": "arn:aws:polly:us-east-1:account-id:lexicon/*"
}
]
}
Pour plus d'informations sur l'utilisation des stratégies basées sur une identité avec Amazon Polly,
consultez Utilisation des stratégies basées sur l'identité (stratégies IAM) pour Amazon Polly (p. 83).
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 ressource
D'autres services, tels que Amazon S3, prennent également en charge les stratégies d'autorisation
basées sur une ressource. Par exemple, vous pouvez attacher une stratégie à un compartiment S3
pour gérer les autorisations d'accès à ce compartiment. Amazon Polly ne prend pas en charge les
stratégies basées sur les ressources.
Spécification des éléments d'une stratégie : actions,
effets et mandataires
Pour chaque ressource Amazon Polly, le service définit un ensemble d'opérations d'API. Pour accorder
des autorisations pour ces opérations d'API, Amazon Polly définit un ensemble d'actions que vous
pouvez spécifier dans une stratégie. Certaines opérations d'API peuvent exiger des autorisations pour
plusieurs actions afin de réaliser l'opération d'API. Pour plus d'informations sur les ressources et les
opérations de l'API, consultez Ressources et opérations Amazon Polly (p. 80) et Référence de l'API
Amazon Polly (p. 60).
82
Spécification des conditions dans une stratégie
Voici les éléments les plus élémentaires d'une stratégie :
• Ressource – Un Amazon Resource Name (ARN) identifie la ressource à laquelle la stratégie basée
sur une identité s'applique. Pour plus d'informations, consultez Ressources et opérations Amazon
Polly (p. 80).
• Action – Vous utilisez des mots clés d'action pour identifier les opérations de ressource que vous
voulez accorder ou refuser. Par exemple, vous pouvez utiliser polly:PutLexicon pour ajouter un
lexique à la région.
• Effet – Vous spécifiez l'effet produit, soit un accord ou un refus, lorsque l'utilisateur demande l'action
spécifique. Si vous n'accordez pas explicitement l'accès pour (autoriser) une ressource, l'accès est
implicitement refusé. Vous pouvez aussi explicitement refuser l'accès à une ressource, ce que vous
pouvez faire afin de vous assurer qu'un utilisateur n'y a pas accès, même si une stratégie différente
accorde l'accès.
• Mandataire – Dans les stratégies basées sur une identité (stratégies IAM), l'utilisateur auquel la
stratégie est attachée est le mandataire implicite. Pour les stratégies basées sur une ressource,
vous spécifiez l'utilisateur, le compte, le service ou une autre entité qui doit recevoir les autorisations
(s'applique uniquement aux stratégies basées sur une ressource). Amazon Polly ne prend pas en
charge les stratégies basées sur les ressources.
Pour plus d'informations sur la syntaxe des stratégies IAM et pour obtenir des descriptions, consultez
Référence de stratégie AWS IAM dans le manuel IAM Guide de l'utilisateur.
Pour obtenir une des tableaux présentant toutes les opérations API d' Amazon Polly ainsi que les
ressources auxquelles elles s'appliquent, consultez Autorisations d'API Amazon Polly : Référence des
actions, des autorisations et des ressources (p. 88).
Spécification des conditions dans une stratégie
Lorsque vous accordez des autorisations, vous pouvez utiliser le langage d'access policy pour
spécifier les conditions définissant quand une stratégie doit prendre effet. Par exemple, il est possible
d'appliquer une stratégie après seulement une date spécifique. Pour plus d'informations sur la
spécification de conditions dans un langage de stratégie, consultez Condition dans le manuel IAM
Pour exprimer des conditions, vous utilisez des clés de condition prédéfinies. Il n'existe pas de clés de
condition spécifiques à Amazon Polly. Il existe toutefois des clés de condition à l'échelle d'AWS que
vous pouvez utiliser selon vos besoins. Pour une liste complète des clés à l'échelle d'AWS, consultez
Clés disponibles pour les conditions dans le IAM Guide de l'utilisateur.
Utilisation des stratégies basées sur l'identité
(stratégies IAM) pour Amazon Polly
Cette rubrique fournit des exemples de stratégies basées sur l'identité qui montrent comment un
administrateur de compte peut attacher des stratégies d'autorisation à des identités IAM (autrement dit,
des utilisateurs, groupes et rôles) et ainsi accorder des autorisations pour effectuer des opérations sur
les ressources Amazon Polly.
Important
Nous vous recommandons, tout d'abord, d'examiner les rubriques de présentation
qui détaillent les concepts de base et les options disponibles pour gérer l'accès à vos
ressources Amazon Polly. Pour plus d'informations, consultez Présentation de la gestion des
autorisations d'accès à vos ressources Amazon Polly (p. 80).
Rubriques
83
Autorisations requises pour
utiliser la console Amazon Polly
• Autorisations requises pour utiliser la console Amazon Polly (p. 84)
• Stratégies gérées par AWS (stratégies prédéfinies) pour Amazon Polly (p. 85)
• Exemples de stratégies gérées par le client (p. 85)
Un exemple de stratégie d'autorisation est exposé ci-dessous.
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowGet-Delete-ListActions",
"Effect": "Allow",
"Action": [
"polly:GetLexicon",
"polly:DeleteLexicon",
"Resource": "*"
}
],
"Statement": [{
"Sid": "NoOverrideMyLexicons",
"Effect": "Deny",
"Action": [
"polly:PutLexicon"],
"Resource": "arn:aws:polly:us-east-1:123456789012:lexicon/my*"
}
]
}
La stratégie possède deux énoncés:
• La première instruction accorde l'autorisation d'effectuer les trois actions Polly
(polly:GetLexicon, polly:DeleteLexicon et polly:ListLexicons) dans n'importe quel
lexique. L'utilisation du caractère générique (*) en tant que ressource accorde des autorisations
universelles pour ces actions sur toutes les régions et tous les lexiques détenus par ce compte.
• La deuxième instruction refuse explicitement l'autorisation d'effectuer une action Polly
(polly:PutLexicon). L'ARN affiché comme étant la ressource applique spécifiquement cette
autorisation à tous les lexiques commençant par les lettres « my » qui se trouvent dans la région
us-east-1.
Pour visualiser un tableau répertoriant toutes les opérations d'API Amazon Polly et les ressources
auxquelles elles s'appliquent, consultez Autorisations d'API Amazon Polly : Référence des actions, des
autorisations et des ressources (p. 88).
Autorisations requises pour utiliser la console
Amazon Polly
Pour qu'un utilisateur puisse utiliser la console Amazon Polly, il doit disposer d'un ensemble minimal
d'autorisations pour pouvoir décrire les ressources Amazon Polly de son compte AWS.
Si vous créez une stratégie IAM plus restrictive que les autorisations minimales requises, la console ne
fonctionnera pas comme prévu pour les utilisateurs dotés de cette stratégie IAM.
Vous n'avez pas besoin d'accorder des autorisations de console minimales aux utilisateurs qui
effectuent des appels uniquement à l'AWS CLI ou à l'API Amazon Polly.
84
Stratégies gérées par AWS (stratégies
prédéfinies) pour Amazon Polly
Pour utiliser la console Amazon Polly, vous devez accorder des autorisations à toutes les API Amazon
Polly. Aucune autorisation supplémentaire n'est nécessaire. La stratégie d'autorisations suivante
permet, à elle seule, d'utiliser la console Amazon Polly.
}
"Version": "2012-10-17",
"Statement": [{
"Sid": "Console-AllowAllPollyActions",
"Effect": "Allow",
"Action": [
"polly:*"],
"Resource": "*"
}
]
}
Stratégies gérées par AWS (stratégies prédéfinies)
pour Amazon Polly
AWS est approprié pour de nombreux cas d'utilisation courants et fournit des stratégies IAM
autonomes qui sont créées et administrées par AWS. Ces stratégies gérées AWS octroient les
autorisations requises dans les cas d'utilisation courants pour que vous évitiez d'avoir à réfléchir aux
autorisations qui sont requises. Pour plus d'informations, consultez Stratégies gérées par AWS dans le
manuel IAM Guide de l'utilisateur.
Les stratégies gérées par AWS suivantes, que vous pouvez attacher aux utilisateurs de votre compte,
sont propres à Amazon Polly :
• AmazonPollyReadOnlyAccess - Permet d'accéder aux ressources en lecture seule, ainsi que
de faire une liste de léxiques, d'extraire des léxiques, de faire une liste de voix disponibles et de
synthétiser celles-ci (y compris, d'appliquer des léxiques aux voix synthétisées).
• AmazonPollyFullAccess - Permet un accès total aux ressources ainsi qu'à toutes les opérations
prises en charge.
Note
Vous pouvez consulter ces stratégies d'autorisations en vous connectant à la console IAM et
en y recherchant des stratégies spécifiques.
Vous pouvez également créer vos propres stratégies IAM personnalisées afin d'accorder des
autorisations pour les actions et les ressources Amazon Polly. Vous pouvez attacher ces stratégies
personnalisées aux utilisateurs ou groupes IAM qui nécessitent ces autorisations.
Exemples de stratégies gérées par le client
Dans cette section, vous trouverez des exemples de stratégies utilisateur qui accordent des
autorisations pour diverses actions Amazon Polly. Ces stratégies fonctionnent lorsque vous utilisez les
kits SDK AWS ou l'AWS CLI. Lorsque vous utilisez la console, vous devez accorder des autorisations
à toutes les API Amazon Polly. Cela est indiqué dans Autorisations requises pour utiliser la console
Amazon Polly (p. 84).
Note
Tous les exemples utilisent la région us-east-1 et ils contiennent des ID de comptes fictifs.
Exemples
• Exemple 1 : Autoriser toutes les actions Amazon Polly (p. 86)
85
• Exemple 2 : Autoriser toutes les actions Polly à l'exception de DeleteLexicon (p. 86)
• Exemple 3 : Autoriser DeleteLexicon (p. 87)
• Exemple 4 : Autoriser la suppression de lexique dans une région donnée (p. 87)
• Exemple 5 : Autoriser DeleteLexicon pour un lexique donné (p. 87)
Exemple 1 : Autoriser toutes les actions Amazon Polly
Une fois que vous êtes inscrit (voir Étape 1.1 : S'inscrire à AWS (p. 5)) vous créez un utilisateur
administrateur pour gérer votre compte, y compris pour créer des utilisateurs et gérer leurs
autorisations.
Vous pouvez choisir de créer un utilisateur qui dispose des autorisations pour toutes les actions
Amazon Polly (définissez cet utilisateur en tant qu'administrateur spécifique au service) pour utiliser
Amazon Polly. Vous pouvez alors lier la stratégie d'autorisations suivante à cet utilisateur.
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowAllPollyActions",
"Effect": "Allow",
"Action": [
"polly:*"],
"Resource": "*"
}
]
}
Exemple 2 : Autoriser toutes les actions Polly à l'exception de
DeleteLexicon
La stratégie d'autorisations suivante accorde à l'utilisateur les autorisations lui permettant d'exécuter
toutes les actions à l'exception de DeleteLexicon. Les autorisations de suppression sont refusées
dans toutes les régions.
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowAllActions-DenyDelete",
"Effect": "Allow",
"Action": [
"polly:DescribeVoices",
"polly:GetLexicon",
"polly:PutLexicon",
"polly:SynthesizeSpeech",
"Resource": "*"
}
{
"Sid": "DenyDeleteLexicon",
"Effect": "Deny",
"Action": [
"polly:DeleteLexicon"],
"Resource": "*"
}
86
]
}
Exemple 3 : Autoriser DeleteLexicon
La stratégie d'autorisations suivante accorde à l'utilisateur les autorisations pour supprimer tout lexique
qu'il détient, quel que soit le projet ou la région dans lequel il se trouve.
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowDeleteLexicon",
"Effect": "Allow",
"Action": [
"Resource": "*"
}
]
}
Exemple 4 : Autoriser la suppression de lexique dans une
région donnée
La stratégie d'autorisations suivante accorde à l'utilisateur des autorisations pour supprimer n'importe
quel lexique dans n'importe quel projet qu'il détient dans une même région (dans ce cas, us-east-1).
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowDeleteSpecifiedRegion",
"Effect": "Allow",
"Action": [
"Resource": "arn:aws:polly:us-east-1:123456789012:lexicon/*"
}
]
}
Exemple 5 : Autoriser DeleteLexicon pour un lexique donné
La stratégie d'autorisations suivante accorde à l'utilisateur des autorisations pour supprimer un lexique
spécifique qu'il détient (dans ce cas, myLexicon) dans une région spécifique (dans ce cas, us-east-1).
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowDeleteForSpecifiedLexicon",
"Effect": "Allow",
"Action": [
"Resource": "arn:aws:polly:us-east-1:123456789012:lexicon/myLexicon"
}
]
}
87
Référence des autorisations de l'API Amazon Polly
Autorisations d'API Amazon Polly : Référence des
actions, des autorisations et des ressources
Lorsque vous configurez Contrôle d'accès (p. 79) et que vous créez une stratégie d'autorisation
que vous pouvez attacher à une identité IAM (stratégies basées sur une identité), vous pouvez utiliser
la de tableaux ci-dessous comme référence. Le La liste inclut chaque opération API Amazon Polly,
les actions correspondantes pour lesquelles vous pouvez accorder des autorisations d'exécution de
l'action et la ressource AWS pour laquelle vous pouvez accorder des autorisations. Vous spécifiez
les actions dans le champ Action de la stratégie ainsi que la valeur des ressources dans le champ
Resource de la stratégie.
Pour exprimer des conditions, vous pouvez utiliser des clés de condition au niveau d'AWS dans les
stratégies Amazon Polly. Pour obtenir la liste complète des clés à l'échelle d'AWS, consultez Clés
disponibles dans le manuel IAM Guide de l'utilisateur.
Note
Pour spécifier une action, utilisez le préfixe polly suivi du nom de l'opération d'API (par
exemple, polly:GetLexicon).
Amazon Polly prend en charge des stratégies basées sur une identité pour des actions au niveau
des ressources. Par conséquent, la valeur Resource est indiquée par l'ARN. A titre d'exemple,
arn:aws:polly:us-east-1:account-id:lexicon/* en tant que valeur Resource indique les
autorisations sur tous les lexiques détenus au sein de la région us-east-1.
Étant donné que Amazon Polly ne prend pas en charge les autorisations pour des actions au
niveau des ressources, la plupart des stratégies indiquent un caractère générique (*) comme valeur
Resource. Toutefois, s'il est nécessaire de limiter les autorisations à une région spécifique, ce
caractère générique est remplacé par l'ARN approprié : arn:aws:polly:region:accountid:lexicon/*.
API Amazon Polly et autorisations requises pour les actions
Opération d'API : DeleteLexicon (p. 61)
Autorisations requises (Action d'API) :polly:DeleteLexicon
Ressources : arn:aws:polly:region:account-id:lexicon/LexiconName
Opération API : DescribeVoices (p. 63)
Autorisations requises (Action d'API) :polly:DescribeVoices
Ressources : arn:aws:polly:region:account-id:lexicon/voice-name
Opération API : GetLexicon (p. 65)
Autorisations requises (Action d'API) :polly:GetLexicon
Ressources : arn:aws:polly:region:account-id:lexicon/voice-name
Opération API : ListLexicons (p. 67)
Autorisations requises (Action d'API) :polly:ListLexicons
Ressources : arn:aws:polly:region:account-id:lexicon/*
Opération API : PutLexicon (p. 69)
Autorisations requises (Action d'API) :polly:ListLexicons
Ressources : *
Opération API : SynthesizeSpeech (p. 71)
Autorisations requises (Action d'API) :polly:SynthesizeSpeech
88
Référence des autorisations de l'API Amazon Polly
Ressources : *
89
Historique du document d'Amazon
Polly
Le tableau suivant décrit la documentation de cette version d'Amazon Polly.
• Dernière date de mise à jour de la documentation : 30 novembre 2016
Modification
Description
Date
Nouveau guide et service
C'est la première version du
service AWS de synthèse
vocale, Amazon Polly et
du manuel du développeur
Amazon Polly.
30 novembre 2016
90
Glossaire AWS
Pour la terminologie AWS la plus récente, consultez le Glossaire AWS dans le document AWS
General Reference.
91

Amazon Polly - Manuel du développeur

Transcription

Documents pareils

Inventaire des jeux

Ce document, obsolète, a été entièrement réécrit et remplacé par

Les filles

Les candidats pourront adresser leurs CV à l`adresse suivante

Le cas Amazon une entreprise emblématique du commerce

Association Polly musique production

Baby Club - Les Ateliers d`Alice

chaises hautes polly de marque chicco

MATTEL FRANCE rappelle 28 types de produits POLLY POCKET

Pour un look branché et high-tech,Devenez Cendrillon grâce à Polly