AWS Data Pipeline n'est plus disponible pour les nouveaux clients. Les clients existants de AWS Data Pipeline peuvent continuer à utiliser le service normalement. [En savoir plus](https://aws.amazon.com/blogs/big-data/migrate-workloads-from-aws-data-pipeline/)
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.
# Expressions et fonctions de pipeline
Cette section explique la syntaxe d'utilisation des expressions et des fonctions dans les pipelines, y compris les types de données associés.
## Types de données simples
Les types de données suivants peuvent être définis comme valeurs de champ.
**Topics**
+ [DateTime](#dp-datatype-datetime)
+ [Numérique](#dp-datatype-numeric)
+ [Références d'objet](#dp-datatype-object-reference)
+ [Period](#dp-datatype-period)
+ [String](#dp-datatype-section)
### DateTime
AWS Data Pipeline prend en charge la date et l'heure exprimées au format « YYYY-MM-DDTHH:MM:SS » uniquement. UTC/GMT L'exemple suivant définit le `startDateTime` champ d'un `Schedule` objet sur`1/15/2012, 11:59 p.m.`, dans le UTC/GMT fuseau horaire.
```
"startDateTime" : "2012-01-15T23:59:00"
```
### Numérique
AWS Data Pipeline prend en charge à la fois les nombres entiers et les valeurs à virgule flottante.
### Références d'objet
Objet dans la définition du pipeline. Il peut s'agir de l'objet actuel, du nom d'un objet défini ailleurs dans le pipeline ou d'un objet qui répertorie l'objet actuel dans un champ, référencé par le mot clé `node`. Pour plus d’informations sur `node`, consultez [Référencement des champs et des objets](dp-pipeline-expressions.md#dp-pipeline-expressions-reference). Pour plus d'informations sur les types d'objet des pipelines, consultez [Référence d'objet de pipeline](dp-pipeline-objects.md).
### Period
Indique la fréquence à laquelle un événement planifié doit s'exécuter. Elle est exprimée au format « *N* [`years`\$1`months`\$1`weeks`\$1`days`\$1`hours`\$1`minutes`] », où *N* est une valeur entière positive.
La période minimale est de 15 minutes et la durée maximale de 3 ans.
L'exemple suivant définit le champ `period` de l'objet `Schedule` sur 3 heures. Cette action crée une planification qui s'exécute toutes les trois heures.
```
"period" : "3 hours"
```
### String
Valeurs de chaîne standard. Les chaînes doivent être entourées de guillemets ("). Vous pouvez utiliser la barre oblique inverse (\$1) pour introduire une séquence d'échappement devant les caractères d'une chaîne. Les chaînes multilignes ne sont pas prises en charge.
Les exemples suivants montrent des exemples de valeurs de chaîne valides pour le champ `id`.
```
"id" : "My Data Object"
"id" : "My \"Data\" Object"
```
Les chaînes peuvent également contenir des expressions qui correspondent à des valeurs de chaîne. Celles-ci sont insérées dans la chaîne et délimitées comme suit : « \$1\$1 » et « \$1 ». L'exemple suivant utilise une expression pour insérer le nom de l'objet courant dans un chemin.
```
"filePath" : "s3://amzn-s3-demo-bucket/#{name}.csv"
```
Pour plus d'informations sur l'utilisation des expressions, consultez [Référencement des champs et des objets](dp-pipeline-expressions.md#dp-pipeline-expressions-reference) et [Evaluation d'expression](dp-pipeline-expressions.md#dp-datatype-functions).
# Expressions
Les expressions vous permettent de partager une valeur entre objets associés. Les expressions sont traitées par le service AWS Data Pipeline Web lors de l'exécution, ce qui garantit que toutes les expressions sont remplacées par la valeur de l'expression.
Les expressions sont délimitées par : « \$1\$1 » et « \$1 ». Vous pouvez utiliser une expression dans n'importe quel objet de définition de pipeline où une chaîne est légale. Si un emplacement est une référence ou est de type ID, NAME, TYPE, SPHERE, sa valeur n'est pas évaluée et il est utilisé tel quel.
L'expression suivante appelle l'une des AWS Data Pipeline fonctions. Pour de plus amples informations, veuillez consulter [Evaluation d'expression](#dp-datatype-functions).
```
#{format(myDateTime,'YYYY-MM-dd hh:mm:ss')}
```
## Référencement des champs et des objets
Les expressions peuvent utiliser les champs de l'objet actuel où l'expression existe, ou les champs d'un autre objet qui est lié par une référence.
Le format d'emplacement se compose de l'heure de création suivie par l'heure de création d'objet, par exemple : `@S3BackupLocation_2018-01-31T11:05:33`.
Vous pouvez également faire référence à l'ID de slot exact spécifié dans la définition du pipeline, tel que l'ID de slot de l'emplacement de sauvegarde Amazon S3. Pour référencer l'ID d'emplacement, utilisez `#{parent.@id}`.
Dans l'exemple suivant, le champ `filePath` fait référence au champ `id` du même objet pour former un nom de fichier. La valeur de `filePath` correspond à « `s3://amzn-s3-demo-bucket/ExampleDataNode.csv` ».
```
{
"id" : "ExampleDataNode",
"type" : "S3DataNode",
"schedule" : {"ref" : "ExampleSchedule"},
"filePath" : "s3://amzn-s3-demo-bucket/#{parent.@id}.csv",
"precondition" : {"ref" : "ExampleCondition"},
"onFail" : {"ref" : "FailureNotify"}
}
```
Pour utiliser un champ qui existe sur un autre objet lié par une référence, utilisez le mot clé `node`. Ce mot clé n'est disponible qu'avec les objets d'alarme (alarm) et de condition préalable (precondition).
Dans l'exemple précédent, une expression d'un objet `SnsAlarm` peut faire référence à la plage de dates et à la plage d'heures d'un objet `Schedule`, car `S3DataNode` fait référence aux deux.
En particulier, le champ `message` d'un `FailureNotify` peut utiliser les champs liés à l'exécution `@scheduledStartTime` et `@scheduledEndTime` d'`ExampleSchedule`, car le champ `onFail` d'`ExampleDataNode` fait référence à `FailureNotify` et que son champ `schedule` fait référence à `ExampleSchedule`.
```
{
"id" : "FailureNotify",
"type" : "SnsAlarm",
"subject" : "Failed to run pipeline component",
"message": "Error for interval #{node.@scheduledStartTime}..#{node.@scheduledEndTime}.",
"topicArn":"arn:aws:sns:us-east-1:28619EXAMPLE:ExampleTopic"
},
```
**Note**
Vous pouvez créer des pipelines ayant des dépendances, telles que les tâches de votre pipeline qui dépendent du travail d'autres systèmes ou tâches. Si votre pipeline nécessite certaines ressources, ajoutez ces dépendances au pipeline à l'aide de conditions préalables que vous associez à des nœuds de données et à des tâches. Cette étape rend vos pipelines plus faciles à déboguer et plus résistants. De plus, conservez vos dépendances au sein d'un seul pipeline chaque fois que possible, car la résolution des problèmes de pipeline est difficile.
## Expressions imbriquées
AWS Data Pipeline vous permet d'imbriquer des valeurs pour créer des expressions plus complexes. Par exemple, pour effectuer un calcul de temps (soustraire 30 minutes de `scheduledStartTime`) et mettre en forme le résultat à utiliser dans une définition de pipeline, vous pouvez utiliser l'expression suivante dans une activité :
```
#{format(minusMinutes(@scheduledStartTime,30),'YYYY-MM-dd hh:mm:ss')}
```
et en utilisant le `node` préfixe si l'expression fait partie d'une précondition SnsAlarm ou :
```
#{format(minusMinutes(node.@scheduledStartTime,30),'YYYY-MM-dd hh:mm:ss')}
```
## Lists
Les expressions peuvent être évaluées sur les listes et les fonctions sur les listes. Par exemple, supposons que la liste soit définie comme suit : `"myList":["one","two"]`. Si cette liste est utilisée dans l'expression `#{'this is ' + myList}`, elle est analysée en `["this is one", "this is two"]`. Si vous avez deux listes, Data Pipeline les aplatit lors de leur évaluation. Par exemple, si `myList1` est défini comme `[1,2]` et `myList2` comme `[3,4]`, l'expression `[#{myList1}, #{myList2}]` est analysée comme `[1,2,3,4]`.
## Expression de nœud
AWS Data Pipeline utilise l'`#{node.*}`expression dans l'un `SnsAlarm` ou `PreCondition` l'autre ou comme référence rétrospective à l'objet parent d'un composant de pipeline. Comme `SnsAlarm` et `PreCondition` sont référencés depuis une activité ou une ressource sans référence arrière à leur encontre, `node` offre le moyen de faire référence au référent. Par exemple, la définition de pipeline suivante illustre comment une notification d'échec peut utiliser `node` pour effectuer une référence à son parent, dans ce cas `ShellCommandActivity`, et inclure les heures de début et de fin planifiées du parent dans le message `SnsAlarm`. La scheduledStartTime référence sur ShellCommandActivity ne nécessite pas le `node` préfixe car elle scheduledStartTime fait référence à elle-même.
**Note**
Les champs précédés par le signe AT (@) indiquent que ces champs sont des champs liés à l'exécution.
```
{
"id" : "ShellOut",
"type" : "ShellCommandActivity",
"input" : {"ref" : "HourlyData"},
"command" : "/home/userName/xxx.sh #{@scheduledStartTime} #{@scheduledEndTime}",
"schedule" : {"ref" : "HourlyPeriod"},
"stderr" : "/tmp/stderr:#{@scheduledStartTime}",
"stdout" : "/tmp/stdout:#{@scheduledStartTime}",
"onFail" : {"ref" : "FailureNotify"},
},
{
"id" : "FailureNotify",
"type" : "SnsAlarm",
"subject" : "Failed to run pipeline component",
"message": "Error for interval #{node.@scheduledStartTime}..#{node.@scheduledEndTime}.",
"topicArn":"arn:aws:sns:us-east-1:28619EXAMPLE:ExampleTopic"
},
```
AWS Data Pipeline prend en charge les références transitives pour les champs définis par l'utilisateur, mais pas pour les champs d'exécution. Une référence transitive est une référence entre deux composants d'un pipeline qui dépend d'un autre composant de pipeline comme intermédiaire. L'exemple suivant montre une référence à un champ transitif défini par l'utilisateur et une référence à un champ lié à l'exécution non transitif, les deux étant valides. Pour de plus amples informations, veuillez consulter [Champs définis par l'utilisateur](dp-writing-pipeline-definition.md#dp-userdefined-fields).
```
{
"name": "DefaultActivity1",
"type": "CopyActivity",
"schedule": {"ref": "Once"},
"input": {"ref": "s3nodeOne"},
"onSuccess": {"ref": "action"},
"workerGroup": "test",
"output": {"ref": "s3nodeTwo"}
},
{
"name": "action",
"type": "SnsAlarm",
"message": "S3 bucket '#{node.output.directoryPath}' succeeded at #{node.@actualEndTime}.",
"subject": "Testing",
"topicArn": "arn:aws:sns:us-east-1:28619EXAMPLE:ExampleTopic",
"role": "DataPipelineDefaultRole"
}
```
## Evaluation d'expression
AWS Data Pipeline fournit un ensemble de fonctions que vous pouvez utiliser pour calculer la valeur d'un champ. L'exemple suivant utilise la fonction `makeDate` pour définir le champ `startDateTime` d'un objet `Schedule` avec la valeur `"2011-05-24T0:00:00"` (GMT/UTC).
```
"startDateTime" : "makeDate(2011,5,24)"
```
# Fonctions mathématiques
Les fonctions suivantes peuvent être utilisées avec des valeurs numériques.
****
| Fonction | Description |
| --- | --- |
| \$1 | Addition. Exemple : `#{1 + 2}` Résultat: `3` |
| - | Soustraction. Exemple : `#{1 - 2}` Résultat: `-1` |
| \$1 | Multiplication. Exemple : `#{1 * 2}` Résultat: `2` |
| / | Division. Si vous divisez deux nombres entiers, le résultat est tronqué. Exemple : `#{1 / 2}`, résultat : `0` Exemple : `#{1.0 / 2}`, résultat : `.5` |
| ^ | Exposant. Exemple : `#{2 ^ 2}` Résultat: `4.0` |
# Fonctions de chaîne
Les fonctions suivantes peuvent être utilisées avec des valeurs chaîne (string).
****
| Fonction | Description |
| --- | --- |
| \$1 | Concaténation. Les valeurs autres que les valeurs chaîne sont converties d'abord en chaînes. Exemple : `#{"hel" + "lo"}` Résultat: `"hello"` |
# Fonctions de date et d'heure
Les fonctions suivantes sont disponibles pour travailler avec des DateTime valeurs. A titre d'exemple, `myDateTime` a pour valeur `May 24, 2011 @ 5:10 pm GMT`.
**Note**
Le date/time format de AWS Data Pipeline est Joda Time, qui remplace les classes de date et d'heure de Java. Pour plus d'informations, voir [Joda Time - Class DateTimeFormat](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).
****
| Fonction | Description |
| --- | --- |
| `int day(DateTime myDateTime)` | Obtient le jour de la DateTime valeur sous forme d'entier. Exemple : `#{day(myDateTime)}` Résultat: `24` |
| `int dayOfYear(DateTime myDateTime)` | Obtient le jour de l'année de la DateTime valeur sous forme d'entier. Exemple : `#{dayOfYear(myDateTime)}` Résultat: `144` |
| `DateTime firstOfMonth(DateTime myDateTime)` | Crée un DateTime objet pour le début du mois dans le champ spécifié DateTime. Exemple : `#{firstOfMonth(myDateTime)}` Résultat: `"2011-05-01T17:10:00z"` |
| `String format(DateTime myDateTime,String format)` | Crée un objet String résultant de la conversion de la valeur spécifiée à DateTime l'aide de la chaîne de format spécifiée. Exemple : `#{format(myDateTime,'YYYY-MM-dd HH:mm:ss z')}` Résultat: `"2011-05-24T17:10:00 UTC"` |
| `int hour(DateTime myDateTime)` | Obtient l'heure de la DateTime valeur sous forme d'entier. Exemple : `#{hour(myDateTime)}` Résultat: `17` |
| `DateTime makeDate(int year,int month,int day)` | Crée un DateTime objet, en UTC, avec l'année, le mois et le jour spécifiés, à minuit. Exemple : `#{makeDate(2011,5,24)}` Résultat: `"2011-05-24T0:00:00z"` |
| `DateTime makeDateTime(int year,int month,int day,int hour,int minute)` | Crée un DateTime objet, en UTC, avec l'année, le mois, le jour, l'heure et la minute spécifiés. Exemple : `#{makeDateTime(2011,5,24,14,21)}` Résultat: `"2011-05-24T14:21:00z"` |
| `DateTime midnight(DateTime myDateTime)` | Crée un DateTime objet pour minuit en cours, par rapport à la valeur spécifiée DateTime. Par exemple, lorsque `MyDateTime` est `2011-05-25T17:10:00z`, le résultat est le suivant. Exemple : `#{midnight(myDateTime)}` Résultat: `"2011-05-25T0:00:00z"` |
| `DateTime minusDays(DateTime myDateTime,int daysToSub)` | Crée un DateTime objet résultant de la soustraction du nombre de jours spécifié au nombre spécifié. DateTime Exemple : `#{minusDays(myDateTime,1)}` Résultat: `"2011-05-23T17:10:00z"` |
| `DateTime minusHours(DateTime myDateTime,int hoursToSub)` | Crée un DateTime objet résultant de la soustraction du nombre d'heures spécifié au nombre spécifié. DateTime Exemple : `#{minusHours(myDateTime,1)}` Résultat: `"2011-05-24T16:10:00z"` |
| `DateTime minusMinutes(DateTime myDateTime,int minutesToSub)` | Crée un DateTime objet résultant de la soustraction du nombre de minutes spécifié par rapport au nombre spécifié. DateTime Exemple : `#{minusMinutes(myDateTime,1)}` Résultat: `"2011-05-24T17:09:00z"` |
| `DateTime minusMonths(DateTime myDateTime,int monthsToSub)` | Crée un DateTime objet résultant de la soustraction du nombre de mois spécifié au nombre spécifié. DateTime Exemple : `#{minusMonths(myDateTime,1)}` Résultat: `"2011-04-24T17:10:00z"` |
| `DateTime minusWeeks(DateTime myDateTime,int weeksToSub)` | Crée un DateTime objet résultant de la soustraction du nombre de semaines spécifié au nombre spécifié. DateTime Exemple : `#{minusWeeks(myDateTime,1)}` Résultat: `"2011-05-17T17:10:00z"` |
| `DateTime minusYears(DateTime myDateTime,int yearsToSub)` | Crée un DateTime objet qui est le résultat de la soustraction du nombre d'années spécifié à partir du nombre spécifié. DateTime Exemple : `#{minusYears(myDateTime,1)}` Résultat: `"2010-05-24T17:10:00z"` |
| `int minute(DateTime myDateTime)` | Obtient la minute de la DateTime valeur sous forme d'entier. Exemple : `#{minute(myDateTime)}` Résultat: `10` |
| `int month(DateTime myDateTime)` | Obtient le mois de la DateTime valeur sous forme d'entier. Exemple : `#{month(myDateTime)}` Résultat: `5` |
| `DateTime plusDays(DateTime myDateTime,int daysToAdd)` | Crée un DateTime objet résultant de l'ajout du nombre de jours spécifié au nombre spécifié DateTime. Exemple : `#{plusDays(myDateTime,1)}` Résultat: `"2011-05-25T17:10:00z"` |
| `DateTime plusHours(DateTime myDateTime,int hoursToAdd)` | Crée un DateTime objet résultant de l'ajout du nombre d'heures spécifié au nombre spécifié DateTime. Exemple : `#{plusHours(myDateTime,1)}` Résultat: `"2011-05-24T18:10:00z"` |
| `DateTime plusMinutes(DateTime myDateTime,int minutesToAdd)` | Crée un DateTime objet résultant de l'ajout du nombre de minutes spécifié au nombre spécifié DateTime. Exemple : `#{plusMinutes(myDateTime,1)}` Résultat: `"2011-05-24 17:11:00z"` |
| `DateTime plusMonths(DateTime myDateTime,int monthsToAdd)` | Crée un DateTime objet résultant de l'ajout du nombre de mois spécifié au nombre spécifié DateTime. Exemple : `#{plusMonths(myDateTime,1)}` Résultat: `"2011-06-24T17:10:00z"` |
| `DateTime plusWeeks(DateTime myDateTime,int weeksToAdd)` | Crée un DateTime objet résultant de l'ajout du nombre de semaines spécifié au nombre spécifié DateTime. Exemple : `#{plusWeeks(myDateTime,1)}` Résultat: `"2011-05-31T17:10:00z"` |
| `DateTime plusYears(DateTime myDateTime,int yearsToAdd)` | Crée un DateTime objet résultant de l'ajout du nombre d'années spécifié au nombre spécifié DateTime. Exemple : `#{plusYears(myDateTime,1)}` Résultat: `"2012-05-24T17:10:00z"` |
| `DateTime sunday(DateTime myDateTime)` | Crée un DateTime objet pour le dimanche précédent, par rapport au dimanche spécifié DateTime. Si la valeur spécifiée DateTime est un dimanche, le résultat est le même DateTime. Exemple : `#{sunday(myDateTime)}` Résultat: `"2011-05-22 17:10:00 UTC"` |
| `int year(DateTime myDateTime)` | Obtient l'année de la DateTime valeur sous forme d'entier. Exemple : `#{year(myDateTime)}` Résultat: `2011` |
| `DateTime yesterday(DateTime myDateTime)` | Crée un DateTime objet pour le jour précédent, par rapport à l'objet spécifié DateTime. Le résultat est le même que celui de minusDays(1). Exemple : `#{yesterday(myDateTime)}` Résultat: `"2011-05-23T17:10:00z"` |
# Caractères spéciaux
AWS Data Pipeline utilise certains caractères qui ont une signification particulière dans les définitions de pipeline, comme indiqué dans le tableau suivant.
****
| Caractère spécial | Description | Exemples |
| --- | --- | --- |
| @ | Champ disponible à l'exécution. Ce caractère est un préfixe de nom de champ dans le cas d'un champ qui n'est disponible que lorsqu'un pipeline s'exécute. | @actualStartTime @failureReason @resourceStatus |
| \$1 | Expression. Les expressions sont délimitées par : « \$1 \$1» et «\$1 » et le contenu des accolades est évalué par. AWS Data Pipeline Pour de plus amples informations, veuillez consulter [Expressions](dp-pipeline-expressions.md). | \$1 \$1format (myDateTime, 'YYYY-MM-dd hh:mm:ss')\$1 s3://amzn-s3-demo-bucket/\$1\$1id\$1.csv |
| \$1 | Champ chiffré. Ce caractère est un préfixe de nom de champ qui indique que le contenu de ce champ AWS Data Pipeline doit être chiffré pendant le transit entre la console ou la CLI et le AWS Data Pipeline service. | \$1password |