Création de canaux personnalisées dans Amazon Pinpoint - Amazon Pinpoint
Création d'une campagne qui envoie des messages à travers un canal personnaliséComprendre les données d'événementConfiguration de webhooksConfiguration des fonctions Lambda

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Création de canaux personnalisées dans Amazon Pinpoint

Amazon Pinpoint inclut la prise en charge intégrée de l'envoi de messages via les canaux de notification push, e-mail, SMS et voix. Vous pouvez également configurer Amazon Pinpoint pour l'envoi de messages à travers d'autres canaux en créant des canaux personnalisés. Les canaux personnalisés dans Amazon Pinpoint vous permettent d'envoyer des messages à travers n'importe quel service possédant une API, y compris des services tiers. Vous pouvez interagir avec les API en utilisant un webhook ou en appelant une AWS Lambda fonction.

Les segments vers lesquels vous envoyez des campagnes de canaux personnalisées peuvent contenir des points de terminaison de tous les types (c'est-à-dire des points de terminaison dont la valeur de l'attribut ChannelType est EMAIL, VOICE, SMS, CUSTOM ou l'un des différents types de point de terminaison de notification push).

Création d'une campagne qui envoie des messages à travers un canal personnalisé

Pour attribuer une fonction Lambda ou un webhook à une campagne individuelle, utilisez l'API Amazon Pinpoint pour créer ou mettre à jour un objet de campagne.

L'objet MessageConfiguration de la campagne doit également contenir un objet CustomMessage. Cet objet a un membre, Data. La valeur de Data est une chaîne JSON qui contient la charge utile du message que vous souhaitez envoyer au canal personnalisé.

La campagne doit contenir un objet CustomDeliveryConfiguration. Dans l'objet CustomDeliveryConfiguration, spécifiez ce qui suit :

  • EndpointTypes : tableau contenant tous les types de point de terminaison auxquels la campagne de canal personnalisé doit être envoyée. Il peut contenir un tous les types de canaux suivants :

    • ADM

    • APNS

    • APNS_SANDBOX

    • APNS_VOIP

    • APNS_VOIP_SANDBOX

    • BAIDU

    • CUSTOM

    • EMAIL

    • GCM

    • SMS

    • VOICE

  • DeliveryUri : destination vers laquelle les points de terminaison sont envoyés. Vous pouvez spécifier uniquement l'une des options suivantes :

    • L'Amazon Resource Name (ARN) d'une fonction Lambda que vous souhaitez exécuter lors de l'exécution de la campagne.

    • URL du webhook auquel vous souhaitez envoyer des données de point de terminaison lors de l'exécution de la campagne.

Note

L'objet Campaign peut également contenir un objet Hook. Cet objet est uniquement utilisé pour créer des segments qui sont personnalisés par une fonction Lambda lors de l'exécution d'une campagne. Pour plus d’informations, consultez Personnalisation des segments avec AWS Lambda.

Comprendre les données d'événement qu'Amazon Pinpoint envoie vers des canaux personnalisés

Avant de créer une fonction Lambda qui envoie des messages à travers un canal personnalisé, vous devez vous familiariser avec les données émises par Amazon Pinpoint. Lorsqu'une campagne Amazon Pinpoint envoie des messages à travers un canal personnalisé, elle envoie une charge utile à la fonction Lambda cible semblable à l'exemple suivant :

{
  "Message":{},
  "Data":"The payload that's provided in the CustomMessage object in MessageConfiguration",
  "ApplicationId":"3a9b1f4e6c764ba7b031e7183example",
  "CampaignId":"13978104ce5d6017c72552257example",
  "TreatmentId":"0",
  "ActivityId":"575cb1929d5ba43e87e2478eeexample",
  "ScheduledTime":"2020-04-08T19:00:16.843Z",
  "Endpoints":{
    "1dbcd396df28ac6cf8c1c2b7fexample":{
      "ChannelType":"EMAIL",
      "Address":"mary.major@example.com",
      "EndpointStatus":"ACTIVE",
      "OptOut":"NONE",
      "Location":{
        "City":"Seattle",
        "Country":"USA"
      },
      "Demographic":{
        "Make":"OnePlus",
        "Platform":"android"
      },
      "EffectiveDate":"2020-04-01T01:05:17.267Z",
      "Attributes":{
        "CohortId":[
          "42"
        ]
      },
      "CreationDate":"2020-04-01T01:05:17.267Z"
    }
  }
}

Les données d’événements fournissent les attributs suivants :

  • ApplicationId : ID du projet Amazon Pinpoint auquel la campagne appartient.

  • CampaignId : ID de la campagne Amazon Pinpoint pour laquelle la fonction Lambda est invoquée.

  • TreatmentId : ID de la variante de campagne. Si vous avez créé une campagne standard, cette valeur est toujours 0. Si vous avez créé une campagne de test A/B, cette valeur est un entier compris entre 0 et 4.

  • ActivityId : ID de l'activité effectuée par la campagne.

  • ScheduledTime : heure à laquelle Amazon Pinpoint exécute la campagne, affichée au format ISO 8601.

  • Endpoints : liste des points de terminaison ciblés par la campagne. Chaque charge utile peut contenir jusqu'à 50 points de terminaison. Si le segment vers lequel la campagne a été envoyée contient plus de 50 points de terminaison, Amazon Pinpoint appelle la fonction à plusieurs reprises, avec un maximum de 50 points de terminaison à la fois, jusqu'à ce que tous les points de terminaison aient été traités.

Vous pouvez utiliser cet échantillon de données lors de la création et du test de votre fonction Lambda de canal personnalisé.

Configuration de webhooks

Si vous utilisez un webhook pour envoyer des messages de canal personnalisé, l'URL du webhook doit commencer par « https :// ». L'URL du webhook peut uniquement contenir des caractères alphanumériques, plus les symboles suivants : tiret (-), point (.), trait de soulignement (_), tilde (~), point d'interrogation ( ?) , barre oblique ou solidus (/), dièse ou signe de hachage (#) et point-virgule ( ;). L’URL doit être conforme à la norme RFC3986.

Lorsque vous créez une campagne qui spécifie une URL de webhook, Amazon Pinpoint émet un HTTP HEAD vers cette URL. La réponse à la demande HEAD doit contenir un en-tête appelé X-Amz-Pinpoint-AccountId. La valeur de cet en-tête doit être égale à votre identifiant de AWS compte.

Configuration des fonctions Lambda

Cette section présente les étapes à suivre pour créer une fonction Lambda qui envoie des messages à travers un canal personnalisé. Tout d'abord, vous créez la fonction. Ensuite, vous ajoutez une stratégie d'exécution à cette dernière. Cette stratégie permet à Amazon Pinpoint d'exécuter la stratégie lors de l'exécution d'une campagne.

Pour une introduction à la création de fonctions Lambda, consultez Création de fonctions Lambda dans le Guide du développeur AWS Lambda .

Exemple de fonction Lambda

L'exemple de code suivant traite la charge utile et enregistre le nombre de points de terminaison de chaque type de point de terminaison. CloudWatch

import boto3
import random
import pprint
import json
import time

cloudwatch = boto3.client('cloudwatch')
    
def lambda_handler(event, context):
    customEndpoints = 0
    smsEndpoints = 0
    pushEndpoints = 0
    emailEndpoints = 0
    voiceEndpoints = 0
    numEndpoints = len(event['Endpoints'])
    
    print("Payload:\n", event)
    print("Endpoints in payload: " + str(numEndpoints))

    for key in event['Endpoints'].keys():
        if event['Endpoints'][key]['ChannelType'] == "CUSTOM":
            customEndpoints += 1
        elif event['Endpoints'][key]['ChannelType'] == "SMS":
            smsEndpoints += 1
        elif event['Endpoints'][key]['ChannelType'] == "EMAIL":
            emailEndpoints += 1
        elif event['Endpoints'][key]['ChannelType'] == "VOICE":
            voiceEndpoints += 1
        else:
            pushEndpoints += 1
            
    response = cloudwatch.put_metric_data(
        MetricData = [
            {
                'MetricName': 'EndpointCount',
                'Dimensions': [
                    {
                        'Name': 'CampaignId',
                        'Value': event['CampaignId']
                    },
                    {
                        'Name': 'ApplicationId',
                        'Value': event['ApplicationId']
                    }
                ],
                'Unit': 'None',
                'Value': len(event['Endpoints'])
            },
            {
                'MetricName': 'CustomCount',
                'Dimensions': [
                    {
                        'Name': 'CampaignId',
                        'Value': event['CampaignId']
                    },
                    {
                        'Name': 'ApplicationId',
                        'Value': event['ApplicationId']
                    }
                ],
                'Unit': 'None',
                'Value': customEndpoints
            },
            {
                'MetricName': 'SMSCount',
                'Dimensions': [
                    {
                        'Name': 'CampaignId',
                        'Value': event['CampaignId']
                    },
                    {
                        'Name': 'ApplicationId',
                        'Value': event['ApplicationId']
                    }
                ],
                'Unit': 'None',
                'Value': smsEndpoints
            },
            {
                'MetricName': 'EmailCount',
                'Dimensions': [
                    {
                        'Name': 'CampaignId',
                        'Value': event['CampaignId']
                    },
                    {
                        'Name': 'ApplicationId',
                        'Value': event['ApplicationId']
                    }
                ],
                'Unit': 'None',
                'Value': emailEndpoints
            },
            {
                'MetricName': 'VoiceCount',
                'Dimensions': [
                    {
                        'Name': 'CampaignId',
                        'Value': event['CampaignId']
                    },
                    {
                        'Name': 'ApplicationId',
                        'Value': event['ApplicationId']
                    }
                ],
                'Unit': 'None',
                'Value': voiceEndpoints
            },
            {
                'MetricName': 'PushCount',
                'Dimensions': [
                    {
                        'Name': 'CampaignId',
                        'Value': event['CampaignId']
                    },
                    {
                        'Name': 'ApplicationId',
                        'Value': event['ApplicationId']
                    }
                ],
                'Unit': 'None',
                'Value': pushEndpoints
            },
            {
                'MetricName': 'EndpointCount',
                'Dimensions': [
                ],
                'Unit': 'None',
                'Value': len(event['Endpoints'])
            },
            {
                'MetricName': 'CustomCount',
                'Dimensions': [
                ],
                'Unit': 'None',
                'Value': customEndpoints
            },
            {
                'MetricName': 'SMSCount',
                'Dimensions': [
                ],
                'Unit': 'None',
                'Value': smsEndpoints
            },
            {
                'MetricName': 'EmailCount',
                'Dimensions': [
                ],
                'Unit': 'None',
                'Value': emailEndpoints
            },
            {
                'MetricName': 'VoiceCount',
                'Dimensions': [
                ],
                'Unit': 'None',
                'Value': voiceEndpoints
            },
            {
                'MetricName': 'PushCount',
                'Dimensions': [
                ],
                'Unit': 'None',
                'Value': pushEndpoints
            }
        ],
        Namespace = 'PinpointCustomChannelExecution'
    )
    print("cloudwatchResponse:\n",response)

Lorsqu'une campagne Amazon Pinpoint exécute cette fonction Lambda, Amazon Pinpoint envoie à la fonction une liste de membres du segment. La fonction compte le nombre de points de terminaison de chacun ChannelType. Il envoie ensuite ces données à Amazon CloudWatch. Vous pouvez consulter ces statistiques dans la section Métriques de la CloudWatch console. Les métriques sont disponibles dans l'espace de PinpointCustomChannelExecutionnoms.

Vous pouvez modifier cet exemple de code pour qu'il se connecte également à l'API d'un service externe, afin d'envoyer des messages à travers ce service.

Format de réponse de fonction Lambda pour Amazon Pinpoint

Si vous souhaitez utiliser le parcours multivarié ou le partage oui/non pour déterminer le chemin du point de terminaison après une activité de canal personnalisée, vous devez structurer la réponse de votre fonction Lambda dans un format compréhensible par Amazon Pinpoint, puis envoyer les points de terminaison sur le bon chemin.

La structure de la réponse doit être au format suivant :

{ 
    <Endpoint ID 1>:{
        EventAttributes: {
            <Key1>: <Value1>,
            <Key2>: <Value2>, 
            ...
        } 
    }, 
    <Endpoint ID 2>:{ 
        EventAttributes: {
            <Key1>: <Value1>,
            <Key2>: <Value2>, 
            ...
        } 
    }, 
... 
}

Cela vous permettra ensuite de sélectionner une clé et une valeur que vous souhaitez utiliser pour déterminer le chemin du point de terminaison.

Exemple de division multivariée personnalisée.

Accorder une autorisation Amazon Pinpoint pour invoquer la fonction Lambda

Vous pouvez utiliser le AWS Command Line Interface (AWS CLI) pour ajouter des autorisations à la politique de fonction Lambda attribuée à votre fonction Lambda. Pour autoriser Amazon Pinpoint à invoquer une fonction, utilisez la commande Lambda ajouter autorisation, comme illustré dans l'exemple suivant :

aws lambda add-permission \
--function-name myFunction \ 
--statement-id sid0 \
--action lambda:InvokeFunction \
--principal pinpoint.us-east-1.amazonaws.com \
--source-arn arn:aws:mobiletargeting:us-east-1:111122223333:apps/*
--source-account 111122223333

Dans la commande précédente, procédez comme suit :

  • Remplacez myFunction par le nom de la fonction Lambda.

  • Remplacez us-east-1 par la région dans laquelle vous utilisez Amazon AWS Pinpoint.

  • Remplacez 111122223333 par votre ID de compte AWS .

Lorsque vous exécutez la commande add-permission de Lambda, celui-ci renvoie le résultat suivant :

{
  "Statement": "{\"Sid\":\"sid\",
    \"Effect\":\"Allow\",
    \"Principal\":{\"Service\":\"pinpoint.us-east-1.amazonaws.com\"},
    \"Action\":\"lambda:InvokeFunction\",
    \"Resource\":\"arn:aws:lambda:us-east-1:111122223333:function:myFunction\",
    \"Condition\":
      {\"ArnLike\":
        {\"AWS:SourceArn\":
         \"arn:aws:mobiletargeting:us-east-1:111122223333:apps/*\"}},
      {\"StringEquals\": 
        {\"AWS:SourceAccount\": 
          \"111122223333\"}}}
}

La valeur Statement est une version de chaîne JSON correspondant à l'instruction ajoutée à la stratégie de la fonction Lambda.

Restrictions supplémentaires concernant la stratégie d'exécution

Vous pouvez modifier la stratégie d'exécution en la limitant à un projet Amazon Pinpoint spécifique. Pour ce faire, remplacez le * dans l'exemple précédent par l'ID unique du projet. Vous pouvez restreindre davantage la stratégie en la limitant à une campagne spécifique. Par exemple, pour restreindre la stratégie de manière à autoriser uniquement une campagne avec l'ID de campagne 95fee4cd1d7f5cd67987c1436example dans un projet avec l'ID de projet dbaf6ec2226f0a9a8615e3ea5example, utilisez la valeur suivante pour l'attribut source-arn :

arn:aws:mobiletargeting:us-east-1:111122223333:apps/dbaf6ec2226f0a9a8615e3ea5example/campaigns/95fee4cd1d7f5cd67987c1436example
Note

Si vous limitez l'exécution de la fonction Lambda à une campagne spécifique, vous devez d'abord créer la fonction avec une stratégie moins restrictive. Ensuite, vous devez créer la campagne dans Amazon Pinpoint et choisir la fonction. Enfin, vous devez mettre à jour la stratégie d'exécution pour faire référence à la campagne spécifiée.