Cette page a été traduite par l'API Cloud Translation.

Recevoir des messages avec l'API Mail

Ce guide explique comment utiliser l'API Mail pour recevoir des e-mails.

Les e-mails envoyés à l'application sont mis en œuvre sous forme de requêtes HTTP contenant des données MIME. Pour traiter les e-mails entrants, associez des adresses e-mail aux gestionnaires de scripts dans la configuration de l'application, puis ajoutez les gestionnaires au code de l'application.

Les e-mails entrants génèrent des requêtes HTTP qui sont transmises aux scripts appropriés. Les scripts qui gèrent les e-mails entrants doivent résider dans le service par défaut.

Pour en savoir plus sur le service de messagerie, consultez la Présentation de l'API Mail.

Avant de commencer

Vous devez enregistrer vos adresses e-mail d'expédition en tant qu'expéditeurs autorisés. Pour en savoir plus, consultez la section Utilisateurs autorisés à envoyer des e-mails.

Configurer votre application pour recevoir des e-mails

Lorsque vous créez une application, le traitement des e-mails entrants est désactivé par défaut. Pour activer les e-mails entrants, vous devez modifier votre fichier app.yaml dans votre service par défaut.

Ajoutez une section inbound_services pour activer le service de messagerie entrante. Exemple :
```
inbound_services:
- mail
```
Si vous n'activez pas le traitement des e-mails entrants en incluant cette section dans le fichier de configuration, le traitement des e-mails entrants est désactivé et les e-mails envoyés à l'application sont ignorés.
Ajoutez des mises en correspondance afin d'associer des adresses e-mail déjà mappées sur des URL à des gestionnaires de script.

Pour le service par défaut, l'adresse e-mail destinée à la réception des e-mails est au format suivant :
```
[STRING]@[Google Cloud project ID].appspotmail.com
```
Pour les services autres que ceux par défaut, l'adresse e-mail est au format suivant :
```
[STRING]@[servicename]-dot-[Google Cloud project ID].appspotmail.com
```
Les e-mails sont envoyés à l'application en tant que requêtes HTTP POST à l'aide de l'URL suivante, où [ADDRESS] est une adresse e-mail complète, incluant le nom de domaine :
```
/_ah/mail/[ADDRESS]
```
Pour gérer les e-mails entrants dans votre application, mappez les URL de messagerie aux gestionnaires dans le fichier app.yaml :
```
- url: /_ah/mail/.+
  script: handle_incoming_email.app
  login: admin
```
Dans l'exemple ci-dessus, /_ah/mail/.+ correspond à tous les e-mails adressés à l'application. Si vous préférez, vous pouvez configurer plusieurs gestionnaires pour différentes adresses e-mail, comme dans l'exemple suivant :
```
- url: /_ah/mail/owner@.*your_app_id\.appspotmail\.com
  script: handle_owner.app
  login: admin
- url: /_ah/mail/support@.*your_app_id\.appspotmail\.com
  script: handle_support.app
  login: admin
- url: /_ah/mail/.+
  script: handle_catchall.app
  login: admin
```
Les URL des e-mails entrants sont mises en correspondance avec cette liste, de la première à la dernière. Ainsi, si une URL de messagerie correspond à plusieurs modèles, le premier gestionnaire correspondant est exécuté. Cette option vous permet d'inclure un gestionnaire "collecteur" comme dernière mise en correspondance. Les gestionnaires s'exécutent dans le module par défaut (ou la version de l'application).

Gérer les e-mails reçus

Lorsque vous utilisez des frameworks Web Python, le constructeur InboundEmailMessage accepte les octets du corps de la requête HTTP. Il existe plusieurs façons de créer l'objet InboundEmailMessage dans Python. Dans Flask, request.get_data() indique les octets de la requête. L'objet InboundEmailMessage contient le message. Sa méthode bodies() renvoie les corps contenus dans l'e-mail. Si vous appelez bodies() sans arguments, un itérateur qui génère d'abord les corps HTML puis les corps en texte brut est renvoyé. Si vous ne souhaitez que du HTML ou que du texte brut, vous pouvez transmettre un argument à bodies() :

@app.route("/_ah/mail/<path>", methods=["POST"])
def receive_mail(path):
    message = mail.InboundEmailMessage(request.get_data())

    # Do something with the message
    print(
        f"Received greeting for {escape(message.to)} at {escape(message.date)} from {escape(message.sender)}"
    )
    for content_type, payload in message.bodies("text/plain"):
        print(f"Text/plain body: {payload.decode()}")
        break

    return "OK", 200

L'objet InboundEmailMessage comprend des attributs qui permettent d'accéder à d'autres champs du message :

subject contient l'objet du message.
sender est l'adresse de l'expéditeur, par exemple, "Nobody <nobody@example.com>".
to est une liste des principaux destinataires du message séparés par une virgule, par exemple, "Joe <joe@example.com>, Bill <bill@example.com>".
cc contient une liste des destinataires en copie séparés par des virgules, par exemple, "Joe <joe@example.com>, Bill <bill@example.com>".
date renvoie la date du message.
attachments est une liste d'objets Attachment, éventuellement vide.
original est le message complet, y compris les données non exposées par les autres champs, tels que les en-têtes d'e-mails, sous la forme email.message.Message Python.

Simuler des e-mails entrants avec le serveur de développement local

Une fois que vous avez configuré l'application pour la gestion des e-mails entrants, vous pouvez utiliser la console du serveur de développement pour simuler des e-mails entrants :

Accédez au serveur de développement en tant qu'administrateur via http://localhost:8080/console, et sélectionnez Se connecter en tant qu'administrateur.
Sur le serveur de développement, cliquez sur Messagerie entrante dans la navigation.
Remplissez le formulaire qui apparaît et cliquez sur Envoyer un e-mail.

Pour l'exécution du serveur de développement, consultez la section Serveur de développement local.

Pour en savoir plus sur les migrations pour l'API Mail, consultez le guide sur les gestionnaires de messagerie.