

**Aviso de fin de soporte:** el 30 de octubre de 2026, AWS finalizará el soporte para Amazon Pinpoint. Después del 30 de octubre de 2026, ya no podrá acceder a la consola de Amazon Pinpoint ni a los recursos de Amazon Pinpoint (puntos de conexión, segmentos, campañas, recorridos y análisis). Para obtener más información, consulte [Fin de soporte de Amazon Pinpoint](https://docs.aws.amazon.com/console/pinpoint/migration-guide). **Nota: en** lo APIs que respecta a los SMS, este cambio no afecta a los mensajes de voz, a las notificaciones push móviles, a las OTP y a la validación de números de teléfono, y son compatibles con la mensajería para el usuario AWS final.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Crear o importar segmentos en Amazon Pinpoint.
<a name="segments"></a>

Un *segmento* de usuarios representa un subconjunto de usuarios basado en ciertas características compartidas, como, por ejemplo, la forma en la que han usado recientemente la aplicación o qué plataforma de dispositivos utilizan. Un segmento designa qué usuarios reciben los mensajes enviados por una campaña. Defina segmentos para llegar al público correcto cuando desee invitar a usuarios a volver a la aplicación, hacer ofertas especiales o aumentar de otro modo las compras de los usuarios y su implicación.

Después de crear un segmento, puede utilizarlo en una o varias campañas. Una campaña envía mensajes personalizados a los usuarios del segmento.

Para obtener más información, consulte [Segmentos](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-segments.html).

**Topics**
+ [Generar segmentos en Amazon Pinpoint](segments-dimensional.md)
+ [Importar segmentos en Amazon Pinpoint.](segments-importing.md)
+ [Personalice los segmentos de Amazon Pinpoint mediante una función AWS Lambda](segments-dynamic.md)

# Generar segmentos en Amazon Pinpoint
<a name="segments-dimensional"></a>

Para llegar al público previsto de una campaña, cree un segmento basado en los datos notificados por la aplicación. Por ejemplo, para llegar a los usuarios que no hayan usado la aplicación recientemente, puede definir un segmento para los usuarios que no la hayan utilizado en los últimos 30 días.

Para ver más ejemplos de código, consulte [Ejemplos de código](https://docs.aws.amazon.com/pinpoint/latest/developerguide/service_code_examples.html).

## Cree segmentos con AWS SDK para Java
<a name="segments-dimensional-example-java"></a>

El siguiente ejemplo muestra cómo crear un segmento con AWS SDK para Java. El ejemplo crea un segmento de usuarios cuyo equipo es los `Lakers` y han estado activos durante los últimos 30 días. Una vez creado el segmento, puede usarlo como parte de una campaña o un recorrido. Para ver un ejemplo del uso de un segmento con una campaña, consulte [Crear campañas de Amazon Pinpoint mediante programación](campaigns.md). 

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.AttributeDimension;
import software.amazon.awssdk.services.pinpoint.model.SegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.AttributeType;
import software.amazon.awssdk.services.pinpoint.model.RecencyDimension;
import software.amazon.awssdk.services.pinpoint.model.SegmentBehaviors;
import software.amazon.awssdk.services.pinpoint.model.SegmentDemographics;
import software.amazon.awssdk.services.pinpoint.model.SegmentLocation;
import software.amazon.awssdk.services.pinpoint.model.SegmentDimensions;
import software.amazon.awssdk.services.pinpoint.model.WriteSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;
import java.util.HashMap;
import java.util.Map;
```

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.AttributeDimension;
import software.amazon.awssdk.services.pinpoint.model.SegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.AttributeType;
import software.amazon.awssdk.services.pinpoint.model.RecencyDimension;
import software.amazon.awssdk.services.pinpoint.model.SegmentBehaviors;
import software.amazon.awssdk.services.pinpoint.model.SegmentDemographics;
import software.amazon.awssdk.services.pinpoint.model.SegmentLocation;
import software.amazon.awssdk.services.pinpoint.model.SegmentDimensions;
import software.amazon.awssdk.services.pinpoint.model.WriteSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;
import java.util.HashMap;
import java.util.Map;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class CreateSegment {
        public static void main(String[] args) {
                final String usage = """

                                Usage:   <appId>

                                Where:
                                  appId - The application ID to create a segment for.

                                """;

                if (args.length != 1) {
                        System.out.println(usage);
                        System.exit(1);
                }

                String appId = args[0];
                PinpointClient pinpoint = PinpointClient.builder()
                                .region(Region.US_EAST_1)
                                .build();

                SegmentResponse result = createSegment(pinpoint, appId);
                System.out.println("Segment " + result.name() + " created.");
                System.out.println(result.segmentType());
                pinpoint.close();
        }

        public static SegmentResponse createSegment(PinpointClient client, String appId) {
                try {
                        Map<String, AttributeDimension> segmentAttributes = new HashMap<>();
                        segmentAttributes.put("Team", AttributeDimension.builder()
                                        .attributeType(AttributeType.INCLUSIVE)
                                        .values("Lakers")
                                        .build());

                        RecencyDimension recencyDimension = RecencyDimension.builder()
                                        .duration("DAY_30")
                                        .recencyType("ACTIVE")
                                        .build();

                        SegmentBehaviors segmentBehaviors = SegmentBehaviors.builder()
                                        .recency(recencyDimension)
                                        .build();

                        SegmentDemographics segmentDemographics = SegmentDemographics
                                        .builder()
                                        .build();

                        SegmentLocation segmentLocation = SegmentLocation
                                        .builder()
                                        .build();

                        SegmentDimensions dimensions = SegmentDimensions
                                        .builder()
                                        .attributes(segmentAttributes)
                                        .behavior(segmentBehaviors)
                                        .demographic(segmentDemographics)
                                        .location(segmentLocation)
                                        .build();

                        WriteSegmentRequest writeSegmentRequest = WriteSegmentRequest.builder()
                                        .name("MySegment")
                                        .dimensions(dimensions)
                                        .build();

                        CreateSegmentRequest createSegmentRequest = CreateSegmentRequest.builder()
                                        .applicationId(appId)
                                        .writeSegmentRequest(writeSegmentRequest)
                                        .build();

                        CreateSegmentResponse createSegmentResult = client.createSegment(createSegmentRequest);
                        System.out.println("Segment ID: " + createSegmentResult.segmentResponse().id());
                        System.out.println("Done");
                        return createSegmentResult.segmentResponse();

                } catch (PinpointException e) {
                        System.err.println(e.awsErrorDetails().errorMessage());
                        System.exit(1);
                }
                return null;
        }
}
```

Cuando se ejecuta este ejemplo, se muestra lo siguiente en la ventana de la consola de su IDE:

```
Segment ID: 09cb2967a82b4a2fbab38fead8d1f4c4
```

Para ver el ejemplo completo del SDK, consulta [CreateSegment.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateSegment.java) en [GitHub](https://github.com/).

# Importar segmentos en Amazon Pinpoint.
<a name="segments-importing"></a>

Con Amazon Pinpoint, puede definir un segmento de usuarios mediante la importación de información acerca de los puntos de conexión que pertenecen al segmento. Un *punto de enlace* es un único destino de mensajería, como un token de inserción en dispositivos móviles, un número de teléfono móvil o una dirección de correo electrónico.

La importación de segmentos resulta útil si ya se han creado segmentos de los usuarios fuera de Amazon Pinpoint, pero se desea conectar con los usuarios en campañas de Amazon Pinpoint.

Al importar un segmento, Amazon Pinpoint obtiene los puntos de conexión del segmento desde Amazon Simple Storage Service (Amazon S3). Antes de importar, se agregan los puntos de conexión a Amazon S3 y se crea un rol de IAM que concede a Amazon Pinpoint acceso a Amazon S3. A continuación, se proporciona a Amazon Pinpoint la ubicación de Amazon S3 en la que se almacenan los puntos de conexión y Amazon Pinpoint agrega cada punto de conexión al segmento.

Para crear el rol de IAM, consulte [Rol de IAM para importar puntos de conexión o segmentos](permissions-import-segment.md). Para obtener información sobre la importación de un segmento mediante la consola de Amazon Pinpoint, consulte [Importación de segmentos](https://docs.aws.amazon.com/pinpoint/latest/userguide/segments-importing.html) en la *Guía del usuario de Amazon Pinpoint*.

Para ver más ejemplos de código, consulte [Ejemplos de código](https://docs.aws.amazon.com/pinpoint/latest/developerguide/service_code_examples.html).

## Importar un segmento con AWS SDK para Java
<a name="segments-importing-example-java"></a>

En el siguiente ejemplo se muestra cómo importar un segmento mediante AWS SDK para Java.

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.ImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.ImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.Format;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;
```

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.ImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.ImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.Format;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class ImportSegment {
    public static void main(String[] args) {
        final String usage = """

                Usage:   <appId> <bucket> <key> <roleArn>\s

                Where:
                  appId - The application ID to create a segment for.
                  bucket - The name of the Amazon S3 bucket that contains the segment definitons.
                  key - The key of the S3 object.
                  roleArn - ARN of the role that allows Amazon Pinpoint to access S3. You need to set trust management for this to work. See https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html
                  """;

        if (args.length != 4) {
            System.out.println(usage);
            System.exit(1);
        }

        String appId = args[0];
        String bucket = args[1];
        String key = args[2];
        String roleArn = args[3];

        PinpointClient pinpoint = PinpointClient.builder()
                .region(Region.US_EAST_1)
                .build();

        ImportJobResponse response = createImportSegment(pinpoint, appId, bucket, key, roleArn);
        System.out.println("Import job for " + bucket + " submitted.");
        System.out.println("See application " + response.applicationId() + " for import job status.");
        System.out.println("See application " + response.jobStatus() + " for import job status.");
        pinpoint.close();
    }

    public static ImportJobResponse createImportSegment(PinpointClient client,
            String appId,
            String bucket,
            String key,
            String roleArn) {

        try {
            ImportJobRequest importRequest = ImportJobRequest.builder()
                    .defineSegment(true)
                    .registerEndpoints(true)
                    .roleArn(roleArn)
                    .format(Format.JSON)
                    .s3Url("s3://" + bucket + "/" + key)
                    .build();

            CreateImportJobRequest jobRequest = CreateImportJobRequest.builder()
                    .importJobRequest(importRequest)
                    .applicationId(appId)
                    .build();

            CreateImportJobResponse jobResponse = client.createImportJob(jobRequest);
            return jobResponse.importJobResponse();

        } catch (PinpointException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }
}
```

Para ver el ejemplo completo del SDK, consulte [ImportingSegments.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/pinpoint/src/main/java/com/example/pinpoint/ImportSegment.java/) en [GitHub](https://github.com/).

# Personalice los segmentos de Amazon Pinpoint mediante una función AWS Lambda
<a name="segments-dynamic"></a>


|  | 
| --- |
| Esta es una documentación preliminar para una característica en versión beta pública. Está sujeta a cambios. | 

Puede utilizarla AWS Lambda para personalizar la forma en que una campaña de Amazon Pinpoint atrae a su público objetivo. Con AWS Lambda, puede modificar el segmento de la campaña en el momento en que Amazon Pinpoint envía el mensaje de la campaña.

AWS Lambda es un servicio informático que puede utilizar para ejecutar código sin aprovisionar ni administrar servidores. Puede empaquetar el código y cargarlo en Lambda como *funciones de Lambda*. Lambda ejecuta una función cuando se invoca la función, lo que se podría hacer de forma manual o automática en respuesta a eventos. Para obtener más información, consulte la [Guía para desarrolladores de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

Para asignar una función de Lambda a una campaña, defina la configuración `CampaignHook` de la campaña mediante el recurso de [campaña](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-campaigns-campaign-id.html) en la API de Amazon Pinpoint. Entre estos ajustes se incluye el nombre de la función de Lambda. También se incluye el modo `CampaignHook`, que establece si Amazon Pinpoint recibe un valor de retorno de la función.

Una función de Lambda que asigne a una campaña se conoce como una *extensión* de Amazon Pinpoint.

Con la configuración de `CampaignHook` definida, Amazon Pinpoint invoca automáticamente la función de Lambda cuando ejecuta la campaña, antes de enviar el mensaje de la campaña. Cuando Amazon Pinpoint invoca la función, proporciona *datos de eventos* sobre el envío de mensajes. Estos datos incluyen el segmento de la campaña, que es la lista de puntos de conexión a los que Amazon Pinpoint envía el mensaje.

Si el modo `CampaignHook` está establecido en `FILTER`, Amazon Pinpoint permite que la función modifique y devuelva el segmento antes de enviar el mensaje. Por ejemplo, la función podría actualizar las definiciones del punto de conexión con atributos que contienen datos de un origen externo a Amazon Pinpoint. O bien, la función podría filtrar el segmento quitando ciertos puntos de enlace dependiendo de las condiciones del código de la función. Una vez Amazon Pinpoint reciba el segmento modificado de la función, envía el mensaje a cada uno de los puntos de conexión del segmento utilizando el canal de entrega de la campaña.

Al procesar tus segmentos con ellos AWS Lambda, tienes más control sobre a quién envías los mensajes y qué contienen esos mensajes. Puede adaptar sus campañas en tiempo real, en el momento en que los mensajes de la campaña se envíen. Filtrar segmentos le permite atraer a subconjuntos de los segmentos definidos más concretamente. Agregar o actualizar los atributos de los puntos de enlace también permite que haya nuevos datos disponibles para las variables de mensajes.

**nota**  
También puede utilizar la configuración de `CampaignHook` para asignar una función de Lambda que administre la entrega de mensajes. Este tipo de función resulta útil para la entrega de mensajes a través de canales personalizadas que Amazon Pinpoint no admite, como, por ejemplo, las plataformas de redes sociales. Para obtener más información, consulte [Crear un canal personalizado en Amazon Pinpoint mediante un webhook o una función de Lambda](channels-custom.md).  
Al invocar un enlace de Lambda mediante Amazon Pinpoint, la función de Lambda también debe estar en la misma región que el proyecto de Amazon Pinpoint. 

Para modificar los segmentos de la campaña AWS Lambda, cree primero una función que procese los datos de eventos enviados por Amazon Pinpoint y devuelva un segmento modificado. A continuación, autorice a Amazon Pinpoint a invocar la función asignando una política de función de Lambda. Por último, asigne la función a una o varias campañas definiendo configuraciones de `CampaignHook`.

Para ver más ejemplos de código, consulte [Ejemplos de código](https://docs.aws.amazon.com/pinpoint/latest/developerguide/service_code_examples.html).

## Datos de evento
<a name="segments-dynamic-payload"></a>

Cuando Amazon Pinpoint invoca la función de Lambda, proporciona la siguiente carga como los datos de eventos:

```
{
  "MessageConfiguration": {Message configuration}
  "ApplicationId": ApplicationId,
  "CampaignId": CampaignId,
  "TreatmentId": TreatmentId,
  "ActivityId": ActivityId,
  "ScheduledTime": Scheduled Time,
  "Endpoints": {
    EndpointId: {Endpoint definition}
    . . .
  }
}
```

AWS Lambda pasa los datos del evento a su código de función. Los datos de eventos proporciona los siguientes atributos:
+ `MessageConfiguration`: tiene la misma estructura que el objeto `DirectMessageConfiguration` del recurso de [mensajes](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-messages.html) en la API de Amazon Pinpoint. 
+ `ApplicationId`: el ID del proyecto de Amazon Pinpoint al que pertenece la campaña.
+ `CampaignId`: el ID de la campaña de Amazon Pinpoint para la que se invocó la función.
+ `TreatmentId`— El ID de una variante de la campaña que se utiliza para A/B realizar pruebas.
+ `ActivityId`: el ID de la actividad que está realizando la campaña.
+ `ScheduledTime`: la fecha y hora, en formato ISO 8601, en que se enviarán los mensajes de la campaña.
+ `Endpoints`— Un mapa que asocia el punto final IDs con las definiciones del punto final. Cada carga de datos de eventos contiene hasta 50 puntos de enlace. Si el segmento de la campaña contiene más de 50 puntos de conexión, Amazon Pinpoint invoca la función reiteradamente, de 50 en 50 puntos de conexión, hasta que se hayan procesado todos ellos. 

## Crear una función de Lambda
<a name="segments-dynamic-lambda-create"></a>

Para obtener información sobre cómo crear una función de Lambda, consulte [Introducción](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) en la *Guía para desarrolladores de AWS Lambda *. Al crear la función, recuerde que la entrega de mensajes produce un error en las siguientes condiciones:
+ La función de Lambda tarda más de 15 segundos en devolver el segmento modificado.
+ Amazon Pinpoint no puede decodificar el valor de retorno de la función.
+ La función requiere más de 3 intentos de Amazon Pinpoint para invocarla correctamente.

Amazon Pinpoint solo acepta las definiciones de punto de conexión del valor de retorno de la función. La función no puede modificar otros elementos de los datos de eventos.

### Ejemplo de función de Lambda
<a name="segments-dynamic-lambda-example"></a>

La función de Lambda procesa los datos de eventos enviados por Amazon Pinpoint y devuelve los puntos de conexión modificados, tal y como se muestra en el siguiente controlador de ejemplo, escrito en Node.js:

```
'use strict';
 
exports.handler = (event, context, callback) => {
    for (var key in event.Endpoints) {
        if (event.Endpoints.hasOwnProperty(key)) {
            var endpoint = event.Endpoints[key];
            var attr = endpoint.Attributes;
            if (!attr) {
                attr = {};
                endpoint.Attributes = attr;
            }
            attr["CreditScore"] = [ Math.floor(Math.random() * 200) + 650];
        }
    }
    console.log("Received event:", JSON.stringify(event, null, 2));
    callback(null, event.Endpoints);
};
```

Lambda transfiere los datos de eventos al controlador según el parámetro `event`.

En este ejemplo, el controlador itera mediante cada punto de enlace en el objeto `event.Endpoints` y añade un nuevo atributo, `CreditScore`, en el punto de enlace. El valor del atributo `CreditScore` es simplemente un número aleatorio.

La `console.log()` declaración registra el evento en CloudWatch los registros.

La instrucción `callback()` devuelve los puntos de conexión modificados a Amazon Pinpoint. Normalmente, el parámetro `callback` es opcional en las funciones de Lambda de Node.js, pero es obligatorio en este contexto porque la función debe devolver los puntos de conexión actualizados a Amazon Pinpoint.

La función debe devolver los puntos finales en el mismo formato que proporcionan los datos del evento, es decir, un mapa que asocia los puntos finales IDs con las definiciones de los puntos finales, como en el siguiente ejemplo:

```
{
    "eqmj8wpxszeqy/b3vch04sn41yw": {
        "ChannelType": "GCM",
        "Address": "4d5e6f1a2b3c4d5e6f7g8h9i0j1a2b3c",
        "EndpointStatus": "ACTIVE",
        "OptOut": "NONE",
        "Demographic": {
            "Make": "android"
        },
        "EffectiveDate": "2017-11-02T21:26:48.598Z",
        "User": {}
    },
    "idrexqqtn8sbwfex0ouscod0yto": {
        "ChannelType": "APNS",
        "Address": "1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f",
        "EndpointStatus": "ACTIVE",
        "OptOut": "NONE",
        "Demographic": {
            "Make": "apple"
        },
        "EffectiveDate": "2017-11-02T21:26:48.598Z",
        "User": {}
    }
}
```

La función de ejemplo modifica y devuelve el objeto `event.Endpoints` que recibió en los datos de evento.

Si lo prefiere, puede incluir los atributos `BodyOverride` y `TitleOverride` en las definiciones de los puntos de enlace que se devuelven.

**nota**  
Cuando se utiliza esta solución para enviar mensajes, Amazon Pinpoint solo respeta los atributos `TitleOverride` y `BodyOverride` de los puntos de conexión cuando el valor del atributo `ChannelType` es uno de los siguientes: `ADM`, `APNS`, `APNS_SANDBOX`, `APNS_VOIP`, `APNS_VOIP_SANDBOX`, `BAIDU`, `GCM` o `SMS`.  
Amazon Pinpoint **no** respeta estos atributos de los puntos de conexión cuando el valor del atributo `ChannelType` es `EMAIL`.

## Asignar una política de función de Lambda
<a name="segments-dynamic-lambda-trust-policy"></a>

Antes de poder utilizar la función de Lambda para procesar los puntos de conexión, debe autorizar a Amazon Pinpoint a invocar la función de Lambda. Para conceder permiso de invocación, asigne una *política de función de Lambda* a la función. Una política de función de Lambda consiste en una política de permisos basada en el recurso que designa qué entidades pueden usar la función y qué acciones pueden realizar dichas entidades.

Para obtener más información, consulte [Uso de políticas basadas en recursos para AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) en la *Guía del desarrollador de AWS Lambda *.

### Política de función de ejemplo
<a name="segments-dynamic-lambda-trust-policy-example"></a>

La siguiente política otorga permiso al director del servicio Amazon Pinpoint para usar la `lambda:InvokeFunction` acción en una campaña específica ()*campaign-id*:

```
{
  "Sid": "sid",
  "Effect": "Allow",
  "Principal": {
    "Service": "pinpoint.us-east-1.amazonaws.com"
  },
  "Action": "lambda:InvokeFunction",
  "Resource": "{arn:aws:lambda:us-east-1:account-id:function:function-name}",
  "Condition": {
    "StringEquals": {
      "AWS:SourceAccount": "111122223333"
    },
    "ArnLike": {
      "AWS:SourceArn": "arn:aws:mobiletargeting:us-east-1:account-id:apps/application-id/campaigns/campaign-id"
    }
  }
}
```

La política de función requiere un bloque `Condition` que incluye una clave `AWS:SourceArn`. Este código indica qué campaña de Amazon Pinpoint tiene permitido invocar la función. En este ejemplo, la política concede permiso solo a una única campaña. El `Condition` bloqueo también debe incluir una `AWS:SourceAccount` clave que controle qué AWS cuenta puede invocar la acción.

Para escribir una política más genérica, use caracteres comodín (\$1) que sustituyan a varios caracteres. Por ejemplo, puede usar el siguiente `Condition` bloque para permitir que cualquier campaña de un proyecto específico de Amazon Pinpoint (*application-id*) invoque la función:

```
...
"Condition": {
  "StringEquals": {
    "AWS:SourceAccount": "111122223333"
  },
  "ArnLike": {
    "AWS:SourceArn": "arn:aws:mobiletargeting:us-east-1:account-id:apps/application-id/campaigns/*"
  }
}
...
```

Si desea que la función de Lambda sea la función predeterminada que utilizan todas las campañas de un proyecto, le recomendamos que configure el bloque `Condition` para la política de la forma anterior. Para obtener información sobre la configuración de una función de Lambda como predeterminada para todas las campañas de un proyecto, consulte [Asignar una función de Lambda a una campaña](#segments-dynamic-assign).

### Conceder el permiso de invocación de Amazon Pinpoint
<a name="segments-dynamic-lambda-trust-policy-assign"></a>

Puede usar AWS Command Line Interface (AWS CLI) para añadir permisos a la política de funciones de Lambda asignada a su función de Lambda. Para permitir que Amazon Pinpoint invoque una función para una campaña específica, use el comando [https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) de Lambda, como se muestra en el siguiente ejemplo:

```
$ aws lambda add-permission \
> --function-name function-name \
> --statement-id sid \
> --action lambda:InvokeFunction \
> --principal pinpoint.us-east-1.amazonaws.com \
> --source-account 111122223333
> --source-arn arn:aws:mobiletargeting:us-east-1:account-id:apps/application-id/campaigns/campaign-id
```

Puedes buscar tu campaña IDs mediante el comando [get-campaigns de](https://docs.aws.amazon.com/cli/latest/reference/pinpoint/get-campaigns.html). AWS CLI También puede buscar el ID de la aplicación mediante el comando [get-apps](https://docs.aws.amazon.com/cli/latest/reference/pinpoint/get-apps.html).

Cuando ejecuta el comando `add-permission` de Lambda, Lambda devuelve la siguiente salida:

```
{
  "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:function-name\",
    \"Condition\":
      {\"ArnLike\":
        {\"AWS:SourceArn\":
         \"arn:aws:mobiletargeting:us-east-1:111122223333:apps/application-id/campaigns/campaign-id\"}}
      {\"StringEquals\": 
        {\"AWS:SourceAccount\": 
          \"111122223333\"}}}
}
```

El valor de `Statement` es una versión de cadena JSON de la instrucción que se agregó a la política de la función de Lambda.

## Asignar una función de Lambda a una campaña
<a name="segments-dynamic-assign"></a>

Puede asignar una función de Lambda a una campaña de Amazon Pinpoint individual. O bien, puede configurar la función de Lambda como la predeterminada que utilizan todas las campañas de un proyecto, excepto en el caso de las campañas a las que se le asigne una función de manera individual.

Para asignar una función de Lambda a una campaña individual, use la API de Amazon Pinpoint a fin de crear o actualizar un objeto [https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-campaigns.html](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-campaigns.html) y defina su atributo `CampaignHook`. Para establecer una función de Lambda como la predeterminada de todas las campañas de un proyecto, cree o actualice el recurso [https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-settings.html](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-settings.html) de ese proyecto y defina su objeto `CampaignHook`.

 En ambos casos, establezca los siguientes atributos `CampaignHook`:
+ `LambdaFunctionName`: el nombre o ARN de la función de Lambda que Amazon Pinpoint invoca antes de enviar mensajes para la campaña.
+ `Mode`: se establece en `FILTER`. Con este modo, Amazon Pinpoint invoca la función y espera a que devuelva los puntos de conexión modificados. Tras recibirlos, Amazon Pinpoint envía el mensaje. Amazon Pinpoint espera hasta 15 segundos antes de que se produzca un error en el envío del mensaje.

Con la configuración de `CampaignHook` definida para una campaña, Amazon Pinpoint invoca la función de Lambda especificada antes de enviar los mensajes de la campaña. Amazon Pinpoint espera a recibir los puntos de conexión modificados de la función. Si Amazon Pinpoint recibe los puntos de conexión actualizados, continúa con el envío de mensajes, mediante los datos de punto de conexión actualizados.