AWS Data Pipeline ya no está disponible para nuevos clientes. Los clientes actuales de AWS Data Pipeline pueden seguir utilizando el servicio con normalidad. [Más información](https://aws.amazon.com/blogs/big-data/migrate-workloads-from-aws-data-pipeline/)
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.
# Expresiones y funciones de canalizaciones
En esta sección, se explica la sintaxis para utilizar expresiones y funciones en canalizaciones, incluidos los tipos de datos asociados.
## Tipos de datos simples
Los siguientes tipos de datos se pueden establecer como valores de campo.
**Topics**
+ [DateTime](#dp-datatype-datetime)
+ [Numérico](#dp-datatype-numeric)
+ [Referencias de objetos](#dp-datatype-object-reference)
+ [Periodo](#dp-datatype-period)
+ [Cadena](#dp-datatype-section)
### DateTime
AWS Data Pipeline solo admite la fecha y la hora expresadas en formato «YYYY-MM-DDTHH:MM:SS». UTC/GMT El siguiente ejemplo establece el campo de un objeto en, en la zona horaria. `startDateTime` `Schedule` `1/15/2012, 11:59 p.m.` UTC/GMT
```
"startDateTime" : "2012-01-15T23:59:00"
```
### Numérico
AWS Data Pipeline admite valores enteros y de punto flotante.
### Referencias de objetos
Un objeto en la definición de la canalización. Puede ser el objeto actual, el nombre de un objeto definido en cualquier parte de la canalización o un objeto que muestra el objeto actual en un campo, al que se hace referencia con la palabra clave `node`. Para obtener más información acerca de `node`, consulte [Objetos y campos de referencia](dp-pipeline-expressions.md#dp-pipeline-expressions-reference). Para obtener más información acerca de los tipos de objetos de canalización, consulte [Referencia de objeto de canalización](dp-pipeline-objects.md).
### Periodo
Indica la frecuencia con la que debe ejecutarse un evento programado. Se expresa en el formato "*N* [`years`\$1`months`\$1`weeks`\$1`days`\$1`hours`\$1`minutes`]", donde *N* es un valor positivo entero.
El período mínimo es de 15 minutos y el período máximo es de 3 años.
En el siguiente ejemplo, se establece el campo `period` del objeto `Schedule` en 3 horas. Esto crea una programación que se ejecuta cada tres horas.
```
"period" : "3 hours"
```
### Cadena
Valores de cadena estándar. Las cadenas deben ir entre comillas dobles ("). Puede utilizar la barra oblicua inversa (\$1) para escapar caracteres en una cadena. No se admiten cadenas de varias líneas.
A continuación, se muestran ejemplos de valores de cadenas válidos para el campo `id`.
```
"id" : "My Data Object"
"id" : "My \"Data\" Object"
```
Las cadenas también pueden contener expresiones que se evalúan en valores de cadena. Se insertan en la cadena y están delimitados con: "\$1\$1" y "\$1". En el siguiente ejemplo, se utiliza una expresión para insertar el nombre del objeto actual en una ruta.
```
"filePath" : "s3://amzn-s3-demo-bucket/#{name}.csv"
```
Para obtener más información acerca del uso de expresiones, consulte [Objetos y campos de referencia](dp-pipeline-expressions.md#dp-pipeline-expressions-reference) y [Evaluación de expresiones](dp-pipeline-expressions.md#dp-datatype-functions).
# Expressions
Las expresiones le permiten compartir un valor entre objetos relacionados. El servicio AWS Data Pipeline web procesa las expresiones en tiempo de ejecución, lo que garantiza que todas las expresiones se sustituyan por el valor de la expresión.
Las expresiones están delimitadas por: "\$1\$1" y "\$1". Puede utilizar una expresión en cualquier objeto de definición de canalización donde una cadena sea legal. Si un slot es una referencia o de tipo ID, NAME, TYPE o SPHERE, su valor no se evalúa y se utiliza literalmente.
La siguiente expresión llama a una de las AWS Data Pipeline funciones. Para obtener más información, consulte [Evaluación de expresiones](#dp-datatype-functions).
```
#{format(myDateTime,'YYYY-MM-dd hh:mm:ss')}
```
## Objetos y campos de referencia
Las expresiones pueden utilizar campos del objeto actual en el que existe la expresión o los campos de otro objeto que está vinculado mediante una referencia.
Un formato de slot consta de una hora de creación, seguida de la hora de creación del objeto, como `@S3BackupLocation_2018-01-31T11:05:33`.
También puede hacer referencia al ID de slot exacto especificado en la definición de la canalización; por ejemplo, el ID de slot de la ubicación de copia de seguridad de Amazon S3. Para hacer referencia al ID de slot, utilice `#{parent.@id}`.
En el siguiente ejemplo, el campo `filePath` hace referencia al campo `id` en el mismo objeto para formar un nombre de archivo. El valor de `filePath` se evalúa como "`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"}
}
```
Para utilizar un campo que existe en otro objeto vinculado mediante una referencia, utilice la palabra clave `node`. Esta palabra clave solo está disponible con objetos de alarma y condición previa.
Continuando con el ejemplo anterior, una expresión de una `SnsAlarm` puede hacer referencia al rango de fecha y hora de una `Schedule`, porque `S3DataNode` hace referencia a ambas.
En concreto, el campo `message` de `FailureNotify` puede utilizar los campos en tiempo de ejecución `@scheduledStartTime` y `@scheduledEndTime` desde `ExampleSchedule`, porque el campo `onFail` de `ExampleDataNode` hace referencia a `FailureNotify` y su campo `schedule` hace referencia a `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"
},
```
**nota**
Puede crear canalizaciones que tengan dependencias, como las tareas de la canalización que dependen del trabajo de otros sistemas o tareas. Si la canalización necesita determinados recursos, añada esas dependencias a la canalización con condiciones previas que se asociarán a los nodos de datos y las tareas. Esto hace que las canalizaciones sean más fáciles de depurar y más resistentes. Además, mantenga las dependencias dentro de una única canalización cuando sea posible, ya que es difícil solucionar problemas entre canalizaciones.
## Expresiones anidadas
AWS Data Pipeline permite anidar valores para crear expresiones más complejas. Por ejemplo, para realizar un cálculo de tiempo (restar 30 minutos de `scheduledStartTime`) y formatear el resultado para utilizarlo en una definición de canalización, puede utilizar la siguiente expresión en una actividad:
```
#{format(minusMinutes(@scheduledStartTime,30),'YYYY-MM-dd hh:mm:ss')}
```
y usar el `node` prefijo si la expresión forma parte de una condición previa SnsAlarm o:
```
#{format(minusMinutes(node.@scheduledStartTime,30),'YYYY-MM-dd hh:mm:ss')}
```
## Listas
Las expresiones pueden evaluarse en listas y funciones en listas. Por ejemplo, supongamos que una lista se define de la siguiente forma: `"myList":["one","two"]`. Si esta lista se utiliza en la expresión `#{'this is ' + myList}`, se evaluará en `["this is one", "this is two"]`. Si tiene dos listas, Data Pipeline al final las nivela en su evaluación. Por ejemplo, si `myList1` se define como `[1,2]` y `myList2` se define como `[3,4]`, la expresión `[#{myList1}, #{myList2}]` se evalúa en `[1,2,3,4]`.
## Expresión de nodo
AWS Data Pipeline utiliza la `#{node.*}` expresión en una `SnsAlarm` o `PreCondition` para hacer una referencia inversa al objeto principal de un componente de la canalización. Dado que se hace referencia a `SnsAlarm` y `PreCondition` desde una actividad o recurso sin ninguna referencia de vuelta desde ellos, `node` proporciona la manera de hacer referencia al remitente. Por ejemplo, la siguiente definición de canalización demuestra cómo una notificación de error puede utilizar `node` para hacer referencia a su principal, en este caso `ShellCommandActivity`, e incluye las horas de inicio y finalización programadas del principal en el mensaje `SnsAlarm`. La scheduledStartTime referencia on no ShellCommandActivity requiere el `node` prefijo porque scheduledStartTime se refiere a sí misma.
**nota**
Los campos precedidos por el signo AT (@) indican que esos campos son campos de tiempo de ejecución.
```
{
"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 admite referencias transitivas para campos definidos por el usuario, pero no para campos de tiempo de ejecución. Una referencia transitiva es una referencia entre dos componentes de la canalización que dependen de otro componente de la canalización como intermediario. El siguiente ejemplo muestra una referencia a un campo definido por el usuario transitivo y una referencia a un campo en tiempo de ejecución no transitivo, ambos válidos. Para obtener más información, consulte [Campos definidos por el usuario](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"
}
```
## Evaluación de expresiones
AWS Data Pipeline proporciona un conjunto de funciones que puede utilizar para calcular el valor de un campo. En el siguiente ejemplo, se utiliza la función `makeDate` para establecer el campo `startDateTime` de un objeto `Schedule` en `"2011-05-24T0:00:00"` GMT/UTC.
```
"startDateTime" : "makeDate(2011,5,24)"
```
# Funciones matemáticas
Las funciones siguientes están disponibles para trabajar con valores numéricos.
****
| Función | Description (Descripción) |
| --- | --- |
| \$1 | Suma. Ejemplo: `#{1 + 2}` Resultado: `3` |
| - | Resta. Ejemplo: `#{1 - 2}` Resultado: `-1` |
| \$1 | Multiplicación. Ejemplo: `#{1 * 2}` Resultado: `2` |
| / | División. Si dividimos dos valores enteros, el resultado se trunca. Ejemplo: `#{1 / 2}`, Resultado: `0` Ejemplo: `#{1.0 / 2}`, Resultado: `.5` |
| ^ | Exponente. Ejemplo: `#{2 ^ 2}` Resultado: `4.0` |
# Funciones de cadena
Las funciones siguientes sirven para trabajar con valores de cadena.
****
| Función | Description (Descripción) |
| --- | --- |
| \$1 | Concatenación. Los valores que no son de cadena se convierten primero en cadenas. Ejemplo: `#{"hel" + "lo"}` Resultado: `"hello"` |
# Funciones de fecha y hora
Las siguientes funciones están disponibles para trabajar con DateTime valores. Para los ejemplos, el valor de `myDateTime` es `May 24, 2011 @ 5:10 pm GMT`.
**nota**
El date/time formato AWS Data Pipeline es Joda Time, que sustituye a las clases de fecha y hora de Java. Para obtener más información, consulte [Joda Time - Class](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html). DateTimeFormat
****
| Función | Description (Descripción) |
| --- | --- |
| `int day(DateTime myDateTime)` | Obtiene el día del DateTime valor en forma de entero. Ejemplo: `#{day(myDateTime)}` Resultado: `24` |
| `int dayOfYear(DateTime myDateTime)` | Obtiene el día del año del DateTime valor en forma de entero. Ejemplo: `#{dayOfYear(myDateTime)}` Resultado: `144` |
| `DateTime firstOfMonth(DateTime myDateTime)` | Crea un DateTime objeto para el inicio del mes en el lugar especificado DateTime. Ejemplo: `#{firstOfMonth(myDateTime)}` Resultado: `"2011-05-01T17:10:00z"` |
| `String format(DateTime myDateTime,String format)` | Crea un objeto String que es el resultado de convertir lo especificado DateTime utilizando la cadena de formato especificada. Ejemplo: `#{format(myDateTime,'YYYY-MM-dd HH:mm:ss z')}` Resultado: `"2011-05-24T17:10:00 UTC"` |
| `int hour(DateTime myDateTime)` | Obtiene la hora del DateTime valor en forma de entero. Ejemplo: `#{hour(myDateTime)}` Resultado: `17` |
| `DateTime makeDate(int year,int month,int day)` | Crea un DateTime objeto, en UTC, con el año, el mes y el día especificados, a medianoche. Ejemplo: `#{makeDate(2011,5,24)}` Resultado: `"2011-05-24T0:00:00z"` |
| `DateTime makeDateTime(int year,int month,int day,int hour,int minute)` | Crea un DateTime objeto, en UTC, con el año, el mes, el día, la hora y el minuto especificados. Ejemplo: `#{makeDateTime(2011,5,24,14,21)}` Resultado: `"2011-05-24T14:21:00z"` |
| `DateTime midnight(DateTime myDateTime)` | Crea un DateTime objeto para la medianoche actual, en relación con la especificada DateTime. Por ejemplo, si `MyDateTime` es `2011-05-25T17:10:00z`, el resultado es el siguiente. Ejemplo: `#{midnight(myDateTime)}` Resultado: `"2011-05-25T0:00:00z"` |
| `DateTime minusDays(DateTime myDateTime,int daysToSub)` | Crea un DateTime objeto que es el resultado de restar el número de días especificado del especificado. DateTime Ejemplo: `#{minusDays(myDateTime,1)}` Resultado: `"2011-05-23T17:10:00z"` |
| `DateTime minusHours(DateTime myDateTime,int hoursToSub)` | Crea un DateTime objeto que es el resultado de restar el número de horas especificado del especificado. DateTime Ejemplo: `#{minusHours(myDateTime,1)}` Resultado: `"2011-05-24T16:10:00z"` |
| `DateTime minusMinutes(DateTime myDateTime,int minutesToSub)` | Crea un DateTime objeto que es el resultado de restar el número de minutos especificado del especificado. DateTime Ejemplo: `#{minusMinutes(myDateTime,1)}` Resultado: `"2011-05-24T17:09:00z"` |
| `DateTime minusMonths(DateTime myDateTime,int monthsToSub)` | Crea un DateTime objeto que es el resultado de restar el número de meses especificado del especificado. DateTime Ejemplo: `#{minusMonths(myDateTime,1)}` Resultado: `"2011-04-24T17:10:00z"` |
| `DateTime minusWeeks(DateTime myDateTime,int weeksToSub)` | Crea un DateTime objeto que es el resultado de restar el número de semanas especificado del especificado. DateTime Ejemplo: `#{minusWeeks(myDateTime,1)}` Resultado: `"2011-05-17T17:10:00z"` |
| `DateTime minusYears(DateTime myDateTime,int yearsToSub)` | Crea un DateTime objeto que es el resultado de restar el número de años especificado del especificado. DateTime Ejemplo: `#{minusYears(myDateTime,1)}` Resultado: `"2010-05-24T17:10:00z"` |
| `int minute(DateTime myDateTime)` | Obtiene el minuto del DateTime valor en forma de entero. Ejemplo: `#{minute(myDateTime)}` Resultado: `10` |
| `int month(DateTime myDateTime)` | Obtiene el mes del DateTime valor en forma de entero. Ejemplo: `#{month(myDateTime)}` Resultado: `5` |
| `DateTime plusDays(DateTime myDateTime,int daysToAdd)` | Crea un DateTime objeto que es el resultado de sumar el número de días especificado al especificado DateTime. Ejemplo: `#{plusDays(myDateTime,1)}` Resultado: `"2011-05-25T17:10:00z"` |
| `DateTime plusHours(DateTime myDateTime,int hoursToAdd)` | Crea un DateTime objeto que es el resultado de añadir el número de horas especificado al especificado DateTime. Ejemplo: `#{plusHours(myDateTime,1)}` Resultado: `"2011-05-24T18:10:00z"` |
| `DateTime plusMinutes(DateTime myDateTime,int minutesToAdd)` | Crea un DateTime objeto que es el resultado de añadir el número de minutos especificado al especificado DateTime. Ejemplo: `#{plusMinutes(myDateTime,1)}` Resultado: `"2011-05-24 17:11:00z"` |
| `DateTime plusMonths(DateTime myDateTime,int monthsToAdd)` | Crea un DateTime objeto que es el resultado de añadir el número de meses especificado al especificado DateTime. Ejemplo: `#{plusMonths(myDateTime,1)}` Resultado: `"2011-06-24T17:10:00z"` |
| `DateTime plusWeeks(DateTime myDateTime,int weeksToAdd)` | Crea un DateTime objeto que es el resultado de añadir el número de semanas especificado al especificado DateTime. Ejemplo: `#{plusWeeks(myDateTime,1)}` Resultado: `"2011-05-31T17:10:00z"` |
| `DateTime plusYears(DateTime myDateTime,int yearsToAdd)` | Crea un DateTime objeto que es el resultado de añadir el número de años especificado al especificado DateTime. Ejemplo: `#{plusYears(myDateTime,1)}` Resultado: `"2012-05-24T17:10:00z"` |
| `DateTime sunday(DateTime myDateTime)` | Crea un DateTime objeto para el domingo anterior, relativo al especificado DateTime. Si el especificado DateTime es un domingo, el resultado es el especificado DateTime. Ejemplo: `#{sunday(myDateTime)}` Resultado: `"2011-05-22 17:10:00 UTC"` |
| `int year(DateTime myDateTime)` | Obtiene el año del DateTime valor en forma de entero. Ejemplo: `#{year(myDateTime)}` Resultado: `2011` |
| `DateTime yesterday(DateTime myDateTime)` | Crea un DateTime objeto para el día anterior, relativo al especificado DateTime. El resultado es el mismo que minusDays(1). Ejemplo: `#{yesterday(myDateTime)}` Resultado: `"2011-05-23T17:10:00z"` |
# Caracteres especiales
AWS Data Pipeline utiliza determinados caracteres que tienen un significado especial en las definiciones de canalización, como se muestra en la siguiente tabla.
****
| Carácter especial | Description (Descripción) | Ejemplos |
| --- | --- | --- |
| @ | Campo de tiempo de ejecución. Este carácter es un prefijo del nombre de campo que solo está disponible cuando se ejecuta una canalización. | @actualStartTime @failureReason @resourceStatus |
| \$1 | Expresión. Las expresiones se delimitan mediante: «\$1 \$1» y «\$1» y el contenido de las llaves se evalúa mediante. AWS Data Pipeline Para obtener más información, consulte [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 | Campo cifrado. Este carácter es un prefijo de nombre de campo que indica que se AWS Data Pipeline debe cifrar el contenido de este campo en tránsito entre la consola o la CLI y el AWS Data Pipeline servicio. | \$1password |