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.

# Importación de elementos de forma individual
<a name="importing-items"></a>

Una vez que haya terminado [Creación de un esquema y un conjunto de datos](data-prep-creating-datasets.md) para crear un conjunto de datos de elementos, puede importar individualmente uno o más elementos nuevos en el conjunto de datos. La importación individual de elementos le permite mantener actualizado su conjunto de datos de elementos con importaciones de lotes pequeños a medida que su catálogo crece. Puede importar hasta 10 elementos a la vez. Si tiene una gran cantidad de elementos nuevos, le recomendamos que primero importe los datos de forma masiva y, a continuación, los importe individualmente según sea necesario. Consulte [Importación de datos masivos en Amazon Personalize con un trabajo de importación de conjuntos de datos](bulk-data-import-step.md).

Puedes usar la consola Amazon Personalize, la AWS Command Line Interface (AWS CLI) o AWS SDKs para importar artículos. Si importa un elemento con el mismo `itemId` que un elemento que ya se encuentra en su conjunto de datos de elementos, Amazon Personalize lo sustituye por el nuevo elemento.

 Para obtener información sobre cómo Amazon Personalize actualiza los filtros de los nuevos registros y cómo los nuevos registros influyen en las recomendaciones, consulte [Importación de registros individuales a un conjunto de datos de Amazon Personalize](incremental-data-updates.md). 

**Topics**
+ [Importación de elementos de forma individual (consola)](#importing-items-console)
+ [Importación de elementos de forma individual (AWS CLI)](#importing-items-cli)
+ [Importación de elementos de forma individual (AWS SDKs)](#importing-items-cli-sdk)

## Importación de elementos de forma individual (consola)
<a name="importing-items-console"></a>

Puede importar hasta 10 elementos en un conjunto de datos de elementos a la vez. En este procedimiento, se asume que ya ha creado un conjunto de datos de elementos. Para obtener información sobre cómo crear conjuntos de datos, consulte [Creación de un esquema y un conjunto de datos](data-prep-creating-datasets.md).

**Para importar elementos de forma individual (consola)**

1. Abre la consola Amazon Personalize en [https://console.aws.amazon.com/personalize/casa](https://console.aws.amazon.com/personalize/home) e inicia sesión en tu cuenta.

1. En la página **Grupos de conjuntos de datos**, elija el grupo de conjuntos de datos con el conjunto de datos de elementos al que desee importar los elementos. 

1. Elija **Conjuntos de datos** en el panel de navegación. 

1. En la página **Conjuntos de datos**, elija el conjunto de datos de elementos. 

1. En la parte superior derecha de la página de detalles del conjunto de datos, elija **Modificar conjunto de datos** y, a continuación, **Crear registro**. 

1. En la página **Crear registros de elementos**, en **Entrada de registro**, introduzca los detalles del elemento en formato JSON. Los nombres y valores de los campos del elemento deben coincidir con el esquema que utilizó al crear el conjunto de datos de elementos. Amazon Personalize proporciona una plantilla JSON con nombres de campos y tipos de datos de este esquema.

1. Elija **Crear registros**. En **Respuesta**, se muestra el resultado de la importación y un mensaje de éxito o error.

## Importación de elementos de forma individual (AWS CLI)
<a name="importing-items-cli"></a>

Agregue uno o más elementos a su conjunto de datos de elementos mediante la operación [PutItems](API_UBS_PutItems.md). Puede importar hasta 10 elementos con una sola llamada `PutItems`. En esta sección, se asume que ya ha creado un conjunto de datos de elementos. Para obtener información sobre cómo crear conjuntos de datos, consulte [Creación de un esquema y un conjunto de datos](data-prep-creating-datasets.md).

Use el siguiente comando `put-items` para agregar uno o más elementos con la AWS CLI. Sustituya `dataset arn` por el nombre de recurso de Amazon (ARN) de su conjunto de datos y `item Id` por el ID del elemento. Si un elemento con el mismo `itemId` ya se encuentra en su conjunto de datos de elementos, Amazon Personalize lo sustituye por el nuevo.

Para `properties`, para cada campo de su conjunto de datos de elementos, sustituya `propertyName` por el nombre del campo de su esquema en formato camel case. Por ejemplo, GENRES sería `genres` y CREATION\_TIMESTAMP sería creationTimestamp. Sustituya los `item data` por los datos del elemento. Los datos de `CREATION_TIMESTAMP` deben estar en [formato de tiempo Unix](interactions-datasets.md#timestamp-data) y en segundos. En el caso de los datos de cadena categóricos, para incluir varias categorías para un sola propiedad, separe cada categoría con un separador vertical (`|`). Por ejemplo, `\"Horror|Action\"`.

```
aws personalize-events put-items \
  --dataset-arn {{dataset arn}} \
  --items '[{
      "itemId": "{{item Id}}", 
      "properties": "{\"{{propertyName}}\": "\{{item data}}\"}" 
    }, 
    {
      "itemId": "{{item Id}}", 
      "properties": "{\"{{propertyName}}\": "\{{item data}}\"}" 
    }]'
```

## Importación de elementos de forma individual (AWS SDKs)
<a name="importing-items-cli-sdk"></a>

Agregue uno o más elementos a su conjunto de datos de elementos mediante la operación [PutItems](API_UBS_PutItems.md). Puede importar hasta 10 elementos con una sola llamada `PutItems`. Si un elemento con el mismo `itemId` ya se encuentra en su conjunto de datos de elementos, Amazon Personalize lo sustituye por el nuevo. En esta sección, se asume que ya ha creado un conjunto de datos de elementos. Para obtener información sobre cómo crear conjuntos de datos, consulte [Creación de un esquema y un conjunto de datos](data-prep-creating-datasets.md).

 El siguiente código muestra cómo añadir uno o más elementos a su conjunto de datos de elementos. Para cada parámetro de nombre de propiedad, pase el nombre del campo de su esquema en formato camel case. Por ejemplo, GENRES sería `genres` y CREATION\_TIMESTAMP sería `creationTimestamp`. Para cada parámetro de valor de la propiedad, pase los datos para el elemento. Los datos de `CREATION_TIMESTAMP` deben estar en [formato de tiempo Unix](interactions-datasets.md#timestamp-data) y en segundos. 

En el caso de los datos de cadena categóricos, para incluir varias categorías para un sola propiedad, separe cada categoría con un separador vertical (`|`). Por ejemplo, `"Horror|Action"`.

------
#### [ SDK for Python (Boto3) ]

```
import boto3

personalize_events = boto3.client(service_name='personalize-events')

personalize_events.put_items(
    datasetArn = '{{dataset arn}}',
    items = [{
      'itemId': '{{item ID}}',
      'properties': "{\"{{propertyName}}\": \"{{item data}}\"}"   
      },
      {
      'itemId': '{{item ID}}',
      'properties': "{\"{{propertyName}}\": \"{{item data}}\"}"   
      }]
)
```

------
#### [ SDK for Java 2.x ]

```
public static int putItems(PersonalizeEventsClient personalizeEventsClient,
                           String datasetArn,
                           String item1Id,
                           String item1PropertyName,
                           String item1PropertyValue,
                           String item2Id,
                           String item2PropertyName,
                           String item2PropertyValue) {

    int responseCode = 0;
    ArrayList<Item> items = new ArrayList<>();

    try {
        Item item1 = Item.builder()
                .itemId(item1Id)
                .properties(String.format("{\"%1$s\": \"%2$s\"}",
                        item1PropertyName, item1PropertyValue))
                .build();

        items.add(item1);

        Item item2 = Item.builder()
                .itemId(item2Id)
                .properties(String.format("{\"%1$s\": \"%2$s\"}",
                        item2PropertyName, item2PropertyValue))
                .build();

        items.add(item2);

        PutItemsRequest putItemsRequest = PutItemsRequest.builder()
                .datasetArn(datasetArn)
                .items(items)
                .build();

        responseCode = personalizeEventsClient.putItems(putItemsRequest).sdkHttpResponse().statusCode();
        System.out.println("Response code: " + responseCode);
        return responseCode;

    } catch (PersonalizeEventsException e) {
        System.out.println(e.awsErrorDetails().errorMessage());
    }
    return responseCode;
    }
```

------
#### [ SDK for JavaScript v3 ]

```
import {
  PutItemsCommand,
  PersonalizeEventsClient,
} from "@aws-sdk/client-personalize-events";

const personalizeEventsClient = new PersonalizeEventsClient({
  region: "{{REGION}}",
});

// set the put items parameters
var putItemsParam = {
  datasetArn:
    "{{DATASET ARN}}",
  items: [
    {
      itemId: "{{itemId}}", 
      properties: '{"{{column1Name}}": "{{value}}", "{{column2Name}}": "{{value}}"}',
    },
    {
      itemId: "{{itemId}}",
      properties: '{"{{column1Name}}": "{{value}}", "{{column2Name}}": "{{value}}"}',
    },
  ],
};
export const run = async () => {
  try {
    const response = await personalizeEventsClient.send(
      new PutItemsCommand(putItemsParam)
    );
    console.log("Success!", response);
    return response; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------