

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.

# API Neptune Loader Get-Status
<a name="load-api-reference-status"></a>

Obtient le statut d'une tâche `loader`.

Pour obtenir le statut de chargement, vous devez envoyer une demande `GET` HTTP au point de terminaison `https://your-neptune-endpoint:port/loader`. Pour obtenir le statut d'une demande de chargement particulière, vous devez inclure l'`loadId` comme paramètre d'URL ou ajouter l'`loadId` au chemin d'URL.

Neptune ne conserve une trace que des 1 024 tâches de chargement en bloc les plus récentes et ne stocke que les 10 000 dernières informations détaillées d'erreur par tâche. 

Consultez [Message d'erreur et de flux liés au chargeur Neptune](loader-message.md) pour obtenir la liste des messages d'erreur et de flux renvoyés par le chargeur en cas d'erreur.

**Contents**
+ [Demandes de Neptune Loader Get-Status](load-api-reference-status-requests.md)
  + [Syntaxe de Get-Status demande du chargeur](load-api-reference-status-requests.md#load-api-reference-status-request-syntax)
  + [Paramètres de demande du Neptune Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters)
+ [Réponses du Neptune Loader Get-Status](load-api-reference-status-response.md)
  + [Disposition JSON du Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout)
  + [Neptune Loader Get-Status `overallStatus` et `failedFeeds` objets de réponse](load-api-reference-status-response.md#load-api-reference-status-response-objects)
  + [Objet de réponse Neptune Loader Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors)
  + [Objet de réponse Neptune Loader Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs)
+ [Exemples de chargeurs Neptune Get-Status](load-api-reference-status-examples.md)
  + [Exemple de demande de statut de chargement](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request)
  + [Exemple de demande d'ID de chargement](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request)
  + [Exemple de demande de statut de détaillé](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request)
+ [Exemples de Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md)
  + [Exemple de réponse de statut détaillée en cas d'erreur](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors)
  + [Exemple d'erreur `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted)

# Demandes de Neptune Loader Get-Status
<a name="load-api-reference-status-requests"></a>

## Syntaxe de Get-Status demande du chargeur
<a name="load-api-reference-status-request-syntax"></a>

```
GET https://your-neptune-endpoint:port/loader?loadId=loadId
```

```
GET https://your-neptune-endpoint:port/loader/loadId
```

```
GET https://your-neptune-endpoint:port/loader
```

## Paramètres de demande du Neptune Loader Get-Status
<a name="load-api-reference-status-parameters"></a>
+ **`loadId`** : ID de la tâche de chargement. Si vous ne spécifiez pas a`loadId`, une liste de charges IDs est renvoyée.
+ **`details`** : inclut des détails autres que le statut global.

  *Valeurs autorisées* : `TRUE`, `FALSE`.

  *Valeur par défaut* : `FALSE`.
+ **`errors`** : inclut la liste d'erreurs.

  *Valeurs autorisées* : `TRUE`, `FALSE`.

  *Valeur par défaut* : `FALSE`.

  La liste d'erreurs est paginée. Les paramètres `page` et `errorsPerPage` vous permettent de parcourir toutes les erreurs.
+ **`page`** : numéro de page de l'erreur. Valide uniquement si le paramètre `errors` est défini sur `TRUE`.

  *Valeurs autorisées* : Entiers positifs

  *Valeur par défaut* : 1.
+ **`errorsPerPage`** : nombre d'erreurs par page. Valide uniquement si le paramètre `errors` est défini sur `TRUE`.

  *Valeurs autorisées* : Entiers positifs

  *Valeur par défaut* : 10.
+ **`limit`** : nombre d'ID de chargement à répertorier. Valable uniquement lorsque vous demandez une liste de charges IDs en envoyant une `GET` demande sans `loadId` spécification.

  *Valeurs autorisées* : nombre entier positif compris entre 1 et 100.

  *Valeur par défaut* : 100.
+ **`includeQueuedLoads`**— Paramètre facultatif qui peut être utilisé pour exclure le chargement IDs des demandes de chargement en file d'attente lorsqu'une liste de chargements IDs est demandée.

  Par défaut, le chargement IDs de toutes les tâches de chargement ayant un statut `LOAD_IN_QUEUE` est inclus dans une telle liste. Ils apparaissent avant le chargement IDs des autres tâches, triés selon l'heure à laquelle ils ont été ajoutés à la file d'attente, du plus récent au plus ancien.

  *Valeurs autorisées* : `TRUE`, `FALSE`.

  *Valeur par défaut* : `TRUE`.

# Réponses du Neptune Loader Get-Status
<a name="load-api-reference-status-response"></a>

 L'exemple de réponse suivant de l' Get-Status API Neptune décrit la structure globale de la réponse, explique les différents champs et leurs types de données, ainsi que le traitement des erreurs et les détails du journal des erreurs. 

## Disposition JSON du Neptune Loader Get-Status Response
<a name="load-api-reference-status-response-layout"></a>

La structure générale d'une réponse de statut du chargeur est la suivante :

```
{
    "status" : "200 OK",
    "payload" : {
        "feedCount" : [
            {
                "LOAD_FAILED" : number
            }
        ],
        "overallStatus" : {
            "fullUri" : "s3://bucket/key",
            "runNumber" : number,
            "retryNumber" : number,
            "status" : "string",
            "totalTimeSpent" : number,
            "startTime" : number,
            "totalRecords" : number,
            "totalDuplicates" : number,
            "parsingErrors" : number,
            "datatypeMismatchErrors" : number,
            "insertErrors" : number,
        },
        "failedFeeds" : [
            {
                "fullUri" : "s3://bucket/key",
                "runNumber" : number,
                "retryNumber" : number,
                "status" : "string",
                "totalTimeSpent" : number,
                "startTime" : number,
                "totalRecords" : number,
                "totalDuplicates" : number,
                "parsingErrors" : number,
                "datatypeMismatchErrors" : number,
                "insertErrors" : number,
            }
        ],
        "errors" : {
            "startIndex" : number,
            "endIndex" : number,
            "loadId" : "string,
            "errorLogs" : [ ]
        }
    }
}
```

## Neptune Loader Get-Status `overallStatus` et `failedFeeds` objets de réponse
<a name="load-api-reference-status-response-objects"></a>

Les réponses possibles renvoyées pour chaque flux ayant échoué, avec une description de l'erreur, sont les mêmes que pour l'objet `overallStatus` dans une réponse `Get-Status`.

Ces champs apparaissent dans l'objet `overallStatus` pour tous les chargements, et le champ `failedFeeds` pour chaque flux ayant échoué.
+ **`fullUri`** : URI du ou des fichiers à charger.

  *Type* : *chaîne*

  *Format* : `s3://bucket/key`.
+ **`runNumber`** : nombre d'exécutions de ce chargement ou flux. Ce nombre est incrémenté lorsque le chargement est redémarré.

  *Type :* *long non signé*.
+ **`retryNumber`** : nombre de nouvelles tentatives de ce chargement ou flux. Ce nombre est incrémenté lorsque le chargeur relance automatiquement un flux ou un chargement.

  *Type :* *long non signé*.
+ **`status`** : statut renvoyé du chargement ou du flux. `LOAD_COMPLETED` indique la réussite du chargement, sans problèmes. Pour obtenir la liste des autres messages relatifs au statut du chargement, consultez [Message d'erreur et de flux liés au chargeur Neptune](loader-message.md).

  *Type* : *chaîne*
+ **`totalTimeSpent`** : temps, en secondes, consacré à analyser et insérer les données pour le chargement ou le flux. N'inclut pas le temps consacré à l'extraction de la liste de fichiers source.

  *Type :* *long non signé*.
+ **`totalRecords`** : nombre total d'enregistrements chargés ou de tentatives de chargement.

  *Type :* *long non signé*.

  Notez que lors du chargement à partir d'un fichier CSV, le nombre d'enregistrements ne fait pas référence au nombre de lignes chargées, mais plutôt au nombre d'enregistrements individuels contenus dans ces lignes. Par exemple, prenons un petit fichier CSV comme celui-ci :

  ```
  ~id,~label,name,team
  'P-1','Player','Stokes','England'
  ```

  Neptune considérerait que ce fichier contient trois enregistrements, à savoir :

  ```
  P-1  label Player
  P-1  name  Stokes
  P-1  team  England
  ```
+ **`totalDuplicates`** : nombre d'enregistrements en double détectés.

  *Type :* *long non signé*.

  Comme dans le cas du décompte `totalRecords`, cette valeur contient le nombre d'enregistrements en double individuels dans un fichier CSV, et non le nombre de lignes dupliquées. Prenons, par exemple, ce petit fichier CSV :

  ```
  ~id,~label,name,team
  P-2,Player,Kohli,India
  P-2,Player,Kohli,India
  ```

  Le statut renvoyé après le chargement ressemblerait à ceci, indiquant six enregistrements au total, dont trois sont des doublons :

  ```
  {
    "status": "200 OK",
    "payload": {
      "feedCount": [
        {
          "LOAD_COMPLETED": 1
        }
      ],
      "overallStatus": {
        "fullUri": "(the URI of the CSV file)",
        "runNumber": 1,
        "retryNumber": 0,
        "status": "LOAD_COMPLETED",
        "totalTimeSpent": 3,
        "startTime": 1662131463,
        "totalRecords": 6,
        "totalDuplicates": 3,
        "parsingErrors": 0,
        "datatypeMismatchErrors": 0,
        "insertErrors": 0
      }
    }
  }
  ```

  Pour les chargements openCypher, un doublon est compté dans les situations suivantes :
  + Le chargeur détecte qu'une ligne d'un fichier de nœud possède un ID sans espace d'ID identique à une autre valeur d'ID sans espace d'ID, que ce soit sur une autre ligne ou appartenant à un nœud existant.
  + Le chargeur détecte qu'une ligne d'un fichier de nœud possède un ID avec un espace d'ID identique à une autre valeur d'ID avec un espace d'ID, que ce soit sur une autre ligne ou appartenant à un nœud existant.

  Consultez [Considérations spéciales relatives au chargement de données openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher).
+ **`parsingErrors`** : nombre d'erreurs d'analyse détectées.

  *Type :* *long non signé*.
+ **`datatypeMismatchErrors`** : nombre d'enregistrements avec un type de données qui ne correspond pas aux données fournies.

  *Type :* *long non signé*.
+ **`insertErrors`** : nombre d'enregistrements qui n'ont pas pu être insérés en raison d'erreurs.

  *Type :* *long non signé*.

## Objet de réponse Neptune Loader Get-Status `errors`
<a name="load-api-reference-status-errors"></a>

Les erreurs sont réparties dans les catégories suivantes :
+ **`Error 400`** : une erreur non valide `loadId` renvoie une erreur de requête HTTP `400` incorrecte. Le message décrit l'erreur.
+ **`Error 500`** : une demande valide qui ne peut pas être traitée renvoie une erreur de serveur interne HTTP `500`. Le message décrit l'erreur.

Consultez [Message d'erreur et de flux liés au chargeur Neptune](loader-message.md) pour obtenir la liste des messages d'erreur et de flux renvoyés par le chargeur en cas d'erreur.

Lorsqu'une erreur se produit, un objet JSON `errors` est renvoyé dans le corps (`BODY`) de la réponse.
+ **`startIndex`** : index de la première erreur incluse.

  *Type :* *long non signé*.
+ **`endIndex`** : index de la dernière erreur incluse.

  *Type :* *long non signé*.
+ **`loadId`** : ID du chargement. Vous pouvez utiliser cet ID pour afficher les erreurs du chargement en définissant le paramètre `errors` sur `TRUE`.

  *Type* : *chaîne*
+ **`errorLogs`** : liste des erreurs.

  *Type :* *liste*.

## Objet de réponse Neptune Loader Get-Status `errorLogs`
<a name="load-api-reference-error-logs"></a>

L'objet `errorLogs` sous `errors` dans la réponse Get-Status du chargeur contient un objet décrivant chaque erreur à l'aide des champs suivants :
+ **`errorCode`** : identifie la nature de l'erreur.

  Il peut avoir l'une des valeurs suivantes :
  + `PARSING_ERROR`
  + `S3_ACCESS_DENIED_ERROR`
  + `FROM_OR_TO_VERTEX_ARE_MISSING`
  + `ID_ASSIGNED_TO_MULTIPLE_EDGES`
  + `SINGLE_CARDINALITY_VIOLATION`
  + `FILE_MODIFICATION_OR_DELETION_ERROR`
  + `OUT_OF_MEMORY_ERROR`
  + `INTERNAL_ERROR` (renvoyé lorsque le chargeur en bloc ne parvient pas à déterminer le type d'erreur).
+ **`errorMessage`** : message décrivant l'erreur.

  Il peut s'agir d'un message générique associé au code d'erreur ou d'un message spécifique contenant des détails, par exemple sur un from/to sommet manquant ou sur une erreur d'analyse.
+ **`fileName`** : nom du flux.
+ **`recordNum`** : dans le cas d'une erreur d'analyse, il s'agit du numéro dans le fichier de l'enregistrement qui n'a pas pu être analysé. Il correspond à zéro si le numéro d'enregistrement n'est pas applicable à l'erreur ou s'il n'a pas pu être déterminé.

Par exemple, le chargeur en bloc générerait une erreur d'analyse s'il détectait une ligne défectueuse telle que la suivante dans un fichier RDF `nquads` :

```
<http://base#subject> |http://base#predicate> <http://base#true> .
```

Comme vous pouvez le constater, le deuxième `http` de la ligne ci-dessus devrait être précédé de `<` au lieu de `|`. L'objet d'erreur généré sous `errorLogs` dans une réponse de statut ressemble à ceci :

```
{
    "errorCode" : "PARSING_ERROR",
    "errorMessage" : "Expected '<', found: |",
    "fileName" : "s3://bucket/key",
    "recordNum" : 12345
},
```

# Exemples de chargeurs Neptune Get-Status
<a name="load-api-reference-status-examples"></a>

 Les exemples suivants illustrent l'utilisation de l'API Get-Status du chargeur Neptune, qui vous permet de récupérer des informations sur l'état de vos chargements de données dans la base de données de graphes Amazon Neptune. Ces exemples couvrent trois scénarios principaux : récupérer l'état d'une charge spécifique, répertorier la charge IDs disponible et demander des informations détaillées sur l'état d'une charge spécifique. 

## Exemple de demande de statut de chargement
<a name="load-api-reference-status-examples-status-request"></a>

Voici une demande envoyée via HTTP `GET` à l'aide de la commande `curl`.

```
curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)'
```

**Example Réponse**  

```
{
    "status" : "200 OK",
    "payload" : {
        "feedCount" : [
            {
                "LOAD_FAILED" : 1
            }
        ],
        "overallStatus" : {
            "datatypeMismatchErrors" : 0,
            "fullUri" : "s3://bucket/key",
            "insertErrors" : 0,
            "parsingErrors" : 5,
            "retryNumber" : 0,
            "runNumber" : 1,
            "status" : "LOAD_FAILED",
            "totalDuplicates" : 0,
            "totalRecords" : 5,
            "totalTimeSpent" : 3.0
        }
    }
}
```

## Exemple de demande d'ID de chargement
<a name="load-api-reference-status-examples-loadId-request"></a>

Voici une demande envoyée via HTTP `GET` à l'aide de la commande `curl`.

```
curl -X GET 'https://your-neptune-endpoint:port/loader?limit=3'
```

**Example Réponse**  

```
{
    "status" : "200 OK",
    "payload" : {
         "loadIds" : [
            "a2c0ce44-a44b-4517-8cd4-1dc144a8e5b5",
            "09683a01-6f37-4774-bb1b-5620d87f1931",
            "58085eb8-ceb4-4029-a3dc-3840969826b9"
        ]
    }
}
```

## Exemple de demande de statut de détaillé
<a name="load-api-reference-status-examples-details-request"></a>

Voici une demande envoyée via HTTP `GET` à l'aide de la commande `curl`.

```
curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)?details=true'
```

**Example Réponse**  

```
{
    "status" : "200 OK",
    "payload" : {
        "failedFeeds" : [
            {
                "datatypeMismatchErrors" : 0,
                "fullUri" : "s3://bucket/key",
                "insertErrors" : 0,
                "parsingErrors" : 5,
                "retryNumber" : 0,
                "runNumber" : 1,
                "status" : "LOAD_FAILED",
                "totalDuplicates" : 0,
                "totalRecords" : 5,
                "totalTimeSpent" : 3.0
            }
        ],
        "feedCount" : [
            {
                "LOAD_FAILED" : 1
            }
        ],
        "overallStatus" : {
            "datatypeMismatchErrors" : 0,
            "fullUri" : "s3://bucket/key",
            "insertErrors" : 0,
            "parsingErrors" : 5,
            "retryNumber" : 0,
            "runNumber" : 1,
            "status" : "LOAD_FAILED",
            "totalDuplicates" : 0,
            "totalRecords" : 5,
            "totalTimeSpent" : 3.0
        }
    }
}
```

# Exemples de Neptune Loader Get-Status `errorLogs`
<a name="load-api-reference-error-logs-examples"></a>

 Les exemples suivants présentent la réponse d'état détaillée du chargeur Neptune lorsque des erreurs se sont produites pendant le processus de chargement des données. Les exemples illustrent la structure de la réponse, notamment les informations sur les flux défaillants, l'état général et les journaux d'erreurs détaillés. 

## Exemple de réponse de statut détaillée en cas d'erreur
<a name="load-api-reference-status-examples-details-request-errors"></a>

Il s'agit d'une demande envoyée via HTTP `GET` avec `curl` :

```
curl -X GET 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802?details=true&errors=true&page=1&errorsPerPage=3'
```

**Example Exemple d'une réponse détaillée en cas d'erreur**  
Voici un exemple de la réponse que vous pourriez obtenir à la suite de la requête ci-dessus, avec un objet `errorLogs` répertoriant les erreurs de chargement détectées :  

```
{
    "status" : "200 OK",
    "payload" : {
        "failedFeeds" : [
            {
                "datatypeMismatchErrors" : 0,
                "fullUri" : "s3://bucket/key",
                "insertErrors" : 0,
                "parsingErrors" : 5,
                "retryNumber" : 0,
                "runNumber" : 1,
                "status" : "LOAD_FAILED",
                "totalDuplicates" : 0,
                "totalRecords" : 5,
                "totalTimeSpent" : 3.0
            }
        ],
        "feedCount" : [
            {
                "LOAD_FAILED" : 1
            }
        ],
        "overallStatus" : {
            "datatypeMismatchErrors" : 0,
            "fullUri" : "s3://bucket/key",
            "insertErrors" : 0,
            "parsingErrors" : 5,
            "retryNumber" : 0,
            "runNumber" : 1,
            "status" : "LOAD_FAILED",
            "totalDuplicates" : 0,
            "totalRecords" : 5,
            "totalTimeSpent" : 3.0
        },
        "errors" : {
            "endIndex" : 3,
            "errorLogs" : [
                {
                    "errorCode" : "PARSING_ERROR",
                    "errorMessage" : "Expected '<', found: |",
                    "fileName" : "s3://bucket/key",
                    "recordNum" : 1
                },
                {
                    "errorCode" : "PARSING_ERROR",
                    "errorMessage" : "Expected '<', found: |",
                    "fileName" : "s3://bucket/key",
                    "recordNum" : 2
                },
                {
                    "errorCode" : "PARSING_ERROR",
                    "errorMessage" : "Expected '<', found: |",
                    "fileName" : "s3://bucket/key",
                    "recordNum" : 3
                }
            ],
            "loadId" : "0a237328-afd5-4574-a0bc-c29ce5f54802",
            "startIndex" : 1
        }
    }
}
```

## Exemple d'erreur `Data prefetch task interrupted`
<a name="load-api-reference-status-examples-task-interrupted"></a>

Parfois, lorsque vous obtenez un statut `LOAD_FAILED`, puis demandez des informations plus détaillées, l'erreur renvoyée peut être `PARSING_ERROR` avec un message `Data prefetch task interrupted`, comme suit :

```
"errorLogs" : [
    {
        "errorCode" : "PARSING_ERROR",
        "errorMessage" : "Data prefetch task interrupted: Data prefetch task for 11467 failed",
        "fileName" : "s3://amzn-s3-demo-bucket/some-source-file",
        "recordNum" : 0
    }
]
```

Cette erreur se produit en cas d'interruption temporaire du processus de chargement des données qui n'est généralement pas provoquée par votre demande ni vos données. Elle peut généralement être résolue simplement en réexécutant la demande de chargement par lot. Si vous utilisez les paramètres par défaut, à savoir `"mode":"AUTO"` et `"failOnError":"TRUE"`, le chargeur ignore les fichiers qu'il a déjà chargés avec succès et reprend le chargement des fichiers qu'il n'avait pas encore chargés lorsque l'interruption s'est produite.