Avant de commencer Exemples Informations connexes

Avis de fin de support : le 30 octobre 2026, le support d'Amazon Pinpoint AWS prendra fin. Après le 30 octobre 2026, vous ne pourrez plus accéder à la console Amazon Pinpoint ni aux ressources Amazon Pinpoint (points de terminaison, segments, campagnes, parcours et analyses). Pour plus d'informations, consultez la page de fin de support d'Amazon Pinpoint. Remarque : en ce qui APIs concerne les SMS, la voix, le push mobile, l'OTP et la validation des numéros de téléphone ne sont pas concernés par cette modification et sont pris en charge par AWS la messagerie utilisateur final.

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.

Importer des points de terminaison dans Amazon Pinpoint

Vous pouvez ajouter ou mettre à jour des points de terminaison en nombre en les important à partir d'un compartiment Amazon S3. L'importation de points de terminaison est utile si vous disposez d'enregistrements sur votre audience en dehors d'Amazon Pinpoint, et si vous souhaitez ajouter ces informations à un projet Amazon Pinpoint. Dans ce cas, vous devez :

Créer des définitions de point de terminaison basées sur les données de votre propre public.
Enregistrez ces définitions de point de terminaison dans un ou plusieurs fichiers, et chargez les fichiers dans un compartiment Amazon S3.
Ajoutez les points de terminaison à votre projet Amazon Pinpoint en les important à partir du compartiment.

Chaque tâche d'importation peut transférer jusqu'à 1 Go de données. Lors d'une tâche courante, au cours de laquelle chaque point de terminaison a une taille inférieure ou égale à 4 Ko, vous pouvez importer environ 250 000 points de terminaison. Vous pouvez exécuter jusqu'à deux tâches d'importation simultanées par AWS compte. Si vous avez besoin de plus de bande passante pour vos tâches d'importation, vous pouvez envoyer une demande d'augmentation du quota de service à Support. Pour de plus amples informations, veuillez consulter Demande d’augmentation de quota.

Avant de commencer

Avant de pouvoir importer des points de terminaison, vous devez disposer des ressources suivantes dans votre compte AWS :

Un compartiment Amazon S3. Pour créer un compartiment, consultez la section Créer un compartiment dans le Guide de l'utilisateur Amazon Simple Storage Service.
Rôle AWS Identity and Access Management (IAM) qui accorde à Amazon Pinpoint des autorisations de lecture pour votre compartiment Amazon S3. Pour créer ce rôle, consultez Rôle IAM pour l'importation de points de terminaison ou de segments.

Exemples

Les exemples suivants expliquent comment ajouter des définitions de point de terminaison à votre compartiment Amazon S3, puis comment les importer dans un projet Amazon Pinpoint.

Fichiers avec définitions de point de terminaison

Les fichiers que vous ajoutez à votre compartiment Amazon S3 peuvent contenir des définitions de point de terminaison au format CSV ou JSON délimité par des nouvelles lignes. Pour connaître les attributs que vous pouvez utiliser pour définir vos points de terminaison, consultez le schéma EndpointRequestJSON dans le manuel Amazon Pinpoint API Reference.

Demandes de tâche d'importation

Les exemples suivants vous indiquent comment ajouter des définitions de point de terminaison à Amazon S3 en chargeant un fichier local dans un compartiment. Ensuite, les exemples importent les définitions de point de terminaison dans un projet Amazon Pinpoint.

AWS CLI

Vous pouvez utiliser Amazon Pinpoint en exécutant des commandes avec l' AWS CLI.

Exemple Commande CP S3

Pour charger un fichier local dans un compartiment Amazon S3, utilisez la commande cp d'Amazon S3 :


$ aws s3 cp ./endpoints-file s3://bucket-name/prefix/

Où :

./endpoints-file correspond au chemin d'accès à un fichier local qui contient les définitions de point de terminaison.
bucket-name/prefix/ correspond au nom de votre compartiment Amazon S3 et, éventuellement, un préfixe vous permettant d'organiser les objets de votre compartiment de manière hiérarchique. Par exemple, un préfixe utile peut être pinpoint/imports/endpoints/.

Exemple Commande de création d'une tâche d'importation

Pour importer des définitions de points de terminaison à partir d'un compartiment Amazon S3, utilisez la commande create-import-job :


$ aws pinpoint create-import-job \
> --application-id application-id \
> --import-job-request \
> S3Url=s3://bucket-name/prefix/key,\
> RoleArn=iam-import-role-arn,\
> Format=format,\
> RegisterEndpoints=true

Où :

application-id correspond à l'ID du projet Amazon Pinpoint pour lequel vous importez des points de terminaison.
bucket- name/prefix/key est l'emplacement dans Amazon S3 qui contient un ou plusieurs objets à importer. L'emplacement peut se terminer par la clé d'un objet individuel, ou il peut se terminer par un préfixe qui qualifie plusieurs objets.
iam-import-role-arnest le nom de ressource Amazon (ARN) d'un rôle IAM qui accorde à Amazon Pinpoint un accès en lecture au bucket.
format peut être JSON ou CSV, selon le format utilisé pour définir vos points de terminaison. Si l'emplacement Amazon S3 inclut plusieurs objets de formats mixtes, Amazon Pinpoint importe uniquement les objets correspondant au format spécifié.

RegisterEndpoints peut avoir la valeur true ou false. Lorsque le paramètre est défini sur true, la tâche d'importation enregistre les points de terminaison auprès d'Amazon Pinpoint, lorsque les définitions de points de terminaison sont importées.

RegisterEndpoints et DefineSegments combinaisons
RegisterEndpoints	DefineSegments	Description
true	true	Amazon Pinpoint importera les points de terminaison et créera un segment contenant les points de terminaison.
vrai	false	Amazon Pinpoint importera les points de terminaison et ne créera pas de segment.
false	true	Amazon Pinpoint importera les points de terminaison et créera un segment contenant les points de terminaison. Les points de terminaison ne seront pas enregistrés et ne remplaceront pas les points de terminaison existants.
false	false	Amazon Pinpoint rejettera cette demande.

La réponse inclut des détails sur la tâche d'importation :


{
    "ImportJobResponse": {
        "CreationDate": "2018-05-24T21:26:33.995Z",
        "Definition": {
            "DefineSegment": false,
            "ExternalId": "463709046829",
            "Format": "JSON",
            "RegisterEndpoints": true,
            "RoleArn": "iam-import-role-arn",
            "S3Url": "s3://bucket-name/prefix/key"
        },
        "Id": "d5ecad8e417d498389e1d5b9454d4e0c",
        "JobStatus": "CREATED",
        "Type": "IMPORT"
    }
}

La réponse fournit l’ID de tâche avec l’attribut Id. Vous pouvez utiliser cet ID pour vérifier le statut actuel de la tâche d'importation.

Exemple Commande de génération d'une tâche d'importation

Pour vérifier le statut actuel d'une tâche d'importation, utilisez la commande get-import-job :


$ aws pinpoint get-import-job \
> --application-id application-id \
> --job-id job-id

Où :

application-id correspond à l'ID du projet Amazon Pinpoint pour lequel la tâche d'importation a été initiée.
job-id correspond à l'ID de la tâche d'importation que vous vérifiez.

La réponse à cette commande fournit l'état actuel de la tâche d'importation :


{
    "ImportJobResponse": {
        "ApplicationId": "application-id",
        "CompletedPieces": 1,
        "CompletionDate": "2018-05-24T21:26:45.308Z",
        "CreationDate": "2018-05-24T21:26:33.995Z",
        "Definition": {
            "DefineSegment": false,
            "ExternalId": "463709046829",
            "Format": "JSON",
            "RegisterEndpoints": true,
            "RoleArn": "iam-import-role-arn",
            "S3Url": "s3://s3-bucket-name/prefix/endpoint-definitions.json"
        },
        "FailedPieces": 0,
        "Id": "job-id",
        "JobStatus": "COMPLETED",
        "TotalFailures": 0,
        "TotalPieces": 1,
        "TotalProcessed": 3,
        "Type": "IMPORT"
    }
}

La réponse fournit le statut de la tâche avec l’attribut JobStatus.

AWS SDK pour Java

Vous pouvez utiliser l'API Amazon Pinpoint dans vos applications Java en utilisant le client fourni par AWS SDK pour Java.

Exemple Code

Pour charger un fichier avec des définitions de point de terminaison dans Amazon S3, utilisez la méthode putObject du client AmazonS3.

Pour importer les points de terminaison dans un projet Amazon Pinpoint, initialisez un objet CreateImportJobRequest. Transmettez ensuite cet objet à la méthode createImportJob du client AmazonPinpoint.



package com.amazonaws.examples.pinpoint;

import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.CreateImportJobRequest;
import com.amazonaws.services.pinpoint.model.CreateImportJobResult;
import com.amazonaws.services.pinpoint.model.Format;
import com.amazonaws.services.pinpoint.model.GetImportJobRequest;
import com.amazonaws.services.pinpoint.model.GetImportJobResult;
import com.amazonaws.services.pinpoint.model.ImportJobRequest;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class ImportEndpoints {

    public static void main(String[] args) {

        final String USAGE = "\n" +
                "ImportEndpoints - Adds endpoints to an Amazon Pinpoint application by: \n" +
                "1.) Uploading the endpoint definitions to an Amazon S3 bucket. \n" +
                "2.) Importing the endpoint definitions from the bucket to an Amazon Pinpoint " +
                "application.\n\n" +
                "Usage: ImportEndpoints <endpointsFileLocation> <s3BucketName> <iamImportRoleArn> " +
                "<applicationId>\n\n" +
                "Where:\n" +
                "  endpointsFileLocation - The relative location of the JSON file that contains the " +
                "endpoint definitions.\n" +
                "  s3BucketName - The name of the Amazon S3 bucket to upload the JSON file to. If the " +
                "bucket doesn't exist, a new bucket is created.\n" +
                "  iamImportRoleArn - The ARN of an IAM role that grants Amazon Pinpoint read " +
                "permissions to the S3 bucket.\n" +
                "  applicationId - The ID of the Amazon Pinpoint application to add the endpoints to.";

        if (args.length < 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String endpointsFileLocation = args[0];
        String s3BucketName = args[1];
        String iamImportRoleArn = args[2];
        String applicationId = args[3];

        Path endpointsFilePath = Paths.get(endpointsFileLocation);
        File endpointsFile = new File(endpointsFilePath.toAbsolutePath().toString());
        uploadToS3(endpointsFile, s3BucketName);

        importToPinpoint(endpointsFile.getName(), s3BucketName, iamImportRoleArn, applicationId);

    }

    private static void uploadToS3(File endpointsFile, String s3BucketName) {

        // Initializes Amazon S3 client.
        final AmazonS3 s3 = AmazonS3ClientBuilder.defaultClient();

        // Checks whether the specified bucket exists. If not, attempts to create one.
        if (!s3.doesBucketExistV2(s3BucketName)) {
            try {
                s3.createBucket(s3BucketName);
                System.out.format("Created S3 bucket %s.\n", s3BucketName);
            } catch (AmazonS3Exception e) {
                System.err.println(e.getErrorMessage());
                System.exit(1);
            }
        }

        // Uploads the endpoints file to the bucket.
        String endpointsFileName = endpointsFile.getName();
        System.out.format("Uploading %s to S3 bucket %s . . .\n", endpointsFileName, s3BucketName);
        try {
            s3.putObject(s3BucketName, "imports/" + endpointsFileName, endpointsFile);
            System.out.println("Finished uploading to S3.");
        } catch (AmazonServiceException e) {
            System.err.println(e.getErrorMessage());
            System.exit(1);
        }
    }

    private static void importToPinpoint(String endpointsFileName, String s3BucketName,
            String iamImportRoleArn, String applicationId) {

        // The S3 URL that Amazon Pinpoint requires to find the endpoints file.
        String s3Url = "s3://" + s3BucketName + "/imports/" + endpointsFileName;

        // Defines the import job that Amazon Pinpoint runs.
        ImportJobRequest importJobRequest = new ImportJobRequest()
                .withS3Url(s3Url)
                .withRegisterEndpoints(true)
                .withRoleArn(iamImportRoleArn)
                .withFormat(Format.JSON);
        CreateImportJobRequest createImportJobRequest = new CreateImportJobRequest()
                .withApplicationId(applicationId)
                .withImportJobRequest(importJobRequest);

        // Initializes the Amazon Pinpoint client.
        AmazonPinpoint pinpointClient = AmazonPinpointClientBuilder.standard()
                .withRegion(Regions.US_EAST_1).build();

        System.out.format("Importing endpoints in %s to Amazon Pinpoint application %s . . .\n",
                endpointsFileName, applicationId);

        try {

            // Runs the import job with Amazon Pinpoint.
            CreateImportJobResult importResult = pinpointClient.createImportJob(createImportJobRequest);

            String jobId = importResult.getImportJobResponse().getId();
            GetImportJobResult getImportJobResult = null;
            String jobStatus = null;

            // Checks the job status until the job completes or fails.
            do {
                getImportJobResult = pinpointClient.getImportJob(new GetImportJobRequest()
                        .withJobId(jobId)
                        .withApplicationId(applicationId));
                jobStatus = getImportJobResult.getImportJobResponse().getJobStatus();
                System.out.format("Import job %s . . .\n", jobStatus.toLowerCase());
                TimeUnit.SECONDS.sleep(3);
            } while (!jobStatus.equals("COMPLETED") && !jobStatus.equals("FAILED"));

            if (jobStatus.equals("COMPLETED")) {
                System.out.println("Finished importing endpoints.");
            } else {
                System.err.println("Failed to import endpoints.");
                System.exit(1);
            }

            // Checks for entries that failed to import.
            // getFailures provides up to 100 of the first failed entries for the job, if
            // any exist.
            List<String> failedEndpoints = getImportJobResult.getImportJobResponse().getFailures();
            if (failedEndpoints != null) {
                System.out.println("Failed to import the following entries:");
                for (String failedEndpoint : failedEndpoints) {
                    System.out.println(failedEndpoint);
                }
            }

        } catch (AmazonServiceException | InterruptedException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }

    }

}

HTTP

Vous pouvez utiliser Amazon Pinpoint en effectuant des demandes HTTP directement à l'API REST.

Exemple Demande PUT Object S3

Pour ajouter vos définitions de point de terminaison à un compartiment, utilisez l'opération Amazon S3 PUT Object et fournissez les définitions de point de terminaison en tant que corps :


PUT /prefix/key HTTP/1.1
Content-Type: text/plain
Accept: application/json
Host: bucket-name.s3.amazonaws.com
X-Amz-Content-Sha256: c430dc094b0cec2905bc88d96314914d058534b14e2bc6107faa9daa12fdff2d
X-Amz-Date: 20180605T184132Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20180605/us-east-1/s3/aws4_request, SignedHeaders=accept;cache-control;content-length;content-type;host;postman-token;x-amz-content-sha256;x-amz-date, Signature=c25cbd6bf61bd3b3667c571ae764b9bf2d8af61b875cacced95d1e68d91b4170
Cache-Control: no-cache

{"ChannelType":"SMS","Address":"2065550182","Location":{"Country":"CAN"},"Demographic":{"Platform":"Android","Make":"LG"},"User":{"UserId":"example-user-id-1"}}
{"ChannelType":"APNS","Address":"1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f","Location":{"Country":"USA"},"Demographic":{"Platform":"iOS","Make":"Apple"},"User":{"UserId":"example-user-id-2"}}
{"ChannelType":"EMAIL","Address":"john.stiles@example.com","Location":{"Country":"USA"},"Demographic":{"Platform":"iOS","Make":"Apple"},"User":{"UserId":"example-user-id-2"}}

Où :

/prefix/key correspond au préfixe et au nom de clé de l'objet qui contient les définitions de point de terminaison après le chargement. Vous pouvez utiliser le préfixe pour organiser vos objets de manière hiérarchique. Par exemple, un préfixe utile peut être pinpoint/imports/endpoints/.
bucket-name correspond au nom du compartiment Amazon S3 auquel vous ajoutez les définitions de point de terminaison.

Exemple Demande de tâche d'importation POST

Pour importer des définitions de points de terminaison à partir d'un compartiment Amazon S3, envoyez une demande POST à la ressource Tâches d'importation. Dans votre demande, incluez les en-têtes requis et fournissez le ImportJobRequestJSON comme corps :


POST /v1/apps/application_id/jobs/import HTTP/1.1
Content-Type: application/json
Accept: application/json
Host: pinpoint.us-east-1.amazonaws.com
X-Amz-Date: 20180605T214912Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20180605/us-east-1/mobiletargeting/aws4_request, SignedHeaders=accept;cache-control;content-length;content-type;host;postman-token;x-amz-date, Signature=c25cbd6bf61bd3b3667c571ae764b9bf2d8af61b875cacced95d1e68d91b4170
Cache-Control: no-cache

{
  "S3Url": "s3://bucket-name/prefix/key",
  "RoleArn": "iam-import-role-arn",
  "Format": "format",
  "RegisterEndpoints": true
}

Où :

application-id correspond à l'ID du projet Amazon Pinpoint pour lequel vous importez des points de terminaison.
bucket- name/prefix/key est l'emplacement dans Amazon S3 qui contient un ou plusieurs objets à importer. L'emplacement peut se terminer par la clé d'un objet individuel, ou il peut se terminer par un préfixe qui qualifie plusieurs objets.
iam-import-role-arnest le nom de ressource Amazon (ARN) d'un rôle IAM qui accorde à Amazon Pinpoint un accès en lecture au bucket.
format peut être JSON ou CSV, selon le format utilisé pour définir vos points de terminaison. Si l'emplacement Amazon S3 inclut plusieurs fichiers de formats mixtes, Amazon Pinpoint importe uniquement les fichiers correspondant au format spécifié.

Si votre demande aboutit, vous recevez une réponse similaire à ce qui suit :


{
    "Id": "a995ce5d70fa44adb563b7d0e3f6c6f5",
    "JobStatus": "CREATED",
    "CreationDate": "2018-06-05T21:49:15.288Z",
    "Type": "IMPORT",
    "Definition": {
        "S3Url": "s3://bucket-name/prefix/key",
        "RoleArn": "iam-import-role-arn",
        "ExternalId": "external-id",
        "Format": "JSON",
        "RegisterEndpoints": true,
        "DefineSegment": false
    }
}

La réponse fournit l’ID de tâche avec l’attribut Id. Vous pouvez utiliser cet ID pour vérifier le statut actuel de la tâche d'importation.

Exemple Demande de tâche d'importation GET

Pour vérifier le statut actuel d'une tâche d'importation, envoyez une demande GET à la ressource Tâche d'importation :


GET /v1/apps/application_id/jobs/import/job_id HTTP/1.1
Content-Type: application/json
Accept: application/json
Host: pinpoint.us-east-1.amazonaws.com
X-Amz-Date: 20180605T220744Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20180605/us-east-1/mobiletargeting/aws4_request, SignedHeaders=accept;cache-control;content-type;host;postman-token;x-amz-date, Signature=c25cbd6bf61bd3b3667c571ae764b9bf2d8af61b875cacced95d1e68d91b4170
Cache-Control: no-cache

Où :

application-id correspond à l'ID du projet Amazon Pinpoint pour lequel la tâche d'importation a été initiée.
job-id correspond à l'ID de la tâche d'importation que vous vérifiez.

Si votre demande aboutit, vous recevez une réponse similaire à ce qui suit :


{
    "ApplicationId": "application_id",
    "Id": "70a51b2cf442447492d2c8e50336a9e8",
    "JobStatus": "COMPLETED",
    "CompletedPieces": 1,
    "FailedPieces": 0,
    "TotalPieces": 1,
    "CreationDate": "2018-06-05T22:04:49.213Z",
    "CompletionDate": "2018-06-05T22:04:58.034Z",
    "Type": "IMPORT",
    "TotalFailures": 0,
    "TotalProcessed": 3,
    "Definition": {
        "S3Url": "s3://bucket-name/prefix/key.json",
        "RoleArn": "iam-import-role-arn",
        "ExternalId": "external-id",
        "Format": "JSON",
        "RegisterEndpoints": true,
        "DefineSegment": false
    }
}

La réponse fournit le statut de la tâche avec l’attribut JobStatus.

Pour plus d'informations concernant la ressource Tâches d'importation dans l'API Amazon Pinpoint, notamment les méthodes HTTP prises en charge et les paramètres de demande, consultez Tâches d'importation dans la Référence de l'API Amazon Pinpoint.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Ajouter un lot de points de terminaison

Exporter des points de terminaison depuis Amazon Pinpoint vers des compartiments Amazon S3