Aviso de fin del soporte: el 15 de diciembre de 2025, AWS finalizará el soporte para AWS IoT Analytics. Después del 15 de diciembre de 2025, ya no podrás acceder a la AWS IoT Analytics consola ni a AWS IoT Analytics los recursos. Para obtener más información, consulta [AWS IoT Analytics el fin del soporte](https://docs.aws.amazon.com/iotanalytics/latest/userguide/iotanalytics-end-of-support.html).
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.
# AWS Lambda actividad
Puede utilizar una **actividad `lambda`** para realizar un procesamiento complejo de los mensajes. Por ejemplo, puede enriquecer los mensajes con datos de la salida de operaciones de API externas o filtrar los mensajes según la lógica de Amazon DynamoDB. Sin embargo, no se puede utilizar esta actividad de canalización para añadir mensajes adicionales o eliminar los existentes antes de entrar en un almacén de datos.
La AWS Lambda función utilizada en una **`lambda`actividad** debe recibir y devolver una matriz de objetos JSON. Para ver un ejemplo, consulta [Ejemplo de función de Lambda 1](#pipeline-activities-lambda-ex1).
Para conceder AWS IoT Analytics permiso para invocar la función Lambda, debe añadir una política. Por ejemplo, ejecute el siguiente comando CLI y {{exampleFunctionName}} sustitúyalo por el nombre de su función de Lambda, {{123456789012}} sustitúyalo por su ID de AWS cuenta y utilice el nombre de recurso de Amazon (ARN) de la canalización que invoca la función de Lambda en cuestión.
```
aws lambda add-permission --function-name {{exampleFunctionName}} --action lambda:InvokeFunction --statement-id iotanalytics --principal iotanalytics.amazonaws.com --source-account {{123456789012}} --source-arn arn:aws:iotanalytics:{{us-east-1}}:{{123456789012}}:pipeline/{{examplePipeline}}
```
El comando devuelve lo siguiente:
```
{
"Statement": "{\"Sid\":\"iotanalyticsa\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"iotanalytics.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:aws-region:aws-account:function:{{exampleFunctionName}}\",\"Condition\":{\"StringEquals\":{\"AWS:SourceAccount\":\"{{123456789012}}\"},\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:iotanalytics:{{us-east-1}}:{{123456789012}}:pipeline/{{examplePipeline}}\"}}}"
}
```
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 *.
## Ejemplo de función de Lambda 1
En este ejemplo, la función de Lambda añade información adicional en función de los datos en el mensaje original. Un dispositivo publica un mensaje con una carga similar a la del siguiente ejemplo.
```
{
"thingid": "00001234abcd",
"temperature": 26,
"humidity": 29,
"location": {
"lat": 52.4332935,
"lon": 13.231694
},
"ip": "192.168.178.54",
"datetime": "2018-02-15T07:06:01"
}
```
Y el dispositivo tiene la siguiente definición de canalización.
```
{
"pipeline": {
"activities": [
{
"channel": {
"channelName": "foobar_channel",
"name": "foobar_channel_activity",
"next": "lambda_foobar_activity"
}
},
{
"lambda": {
"lambdaName": "MyAnalyticsLambdaFunction",
"batchSize": 5,
"name": "lambda_foobar_activity",
"next": "foobar_store_activity"
}
},
{
"datastore": {
"datastoreName": "foobar_datastore",
"name": "foobar_store_activity"
}
}
],
"name": "foobar_pipeline",
"arn": "arn:aws:iotanalytics:eu-west-1:123456789012:pipeline/foobar_pipeline"
}
}
```
La siguiente función de Python de Lambda (`MyAnalyticsLambdaFunction`) añade la GMaps URL y la temperatura, en grados Fahrenheit, al mensaje.
```
import logging
import sys
# Configure logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
streamHandler = logging.StreamHandler(stream=sys.stdout)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
def c_to_f(c):
return 9.0/5.0 * c + 32
def lambda_handler(event, context):
logger.info("event before processing: {}".format(event))
maps_url = 'N/A'
for e in event:
#e['foo'] = 'addedByLambda'
if 'location' in e:
lat = e['location']['lat']
lon = e['location']['lon']
maps_url = "http://maps.google.com/maps?q={},{}".format(lat,lon)
if 'temperature' in e:
e['temperature_f'] = c_to_f(e['temperature'])
logger.info("maps_url: {}".format(maps_url))
e['maps_url'] = maps_url
logger.info("event after processing: {}".format(event))
return event
```
## Ejemplo de función de Lambda 2
Una técnica útil es comprimir y serializar cargas de mensajes para reducirlos costos de transporte y almacenamiento. En este segundo ejemplo, la función de Lambda asume la carga del mensaje que representa un JSON original, que se ha comprimido y luego codificado (serializado) mediante base64 como una cadena. Devuelve el JSON original:
```
import base64
import gzip
import json
import logging
import sys
# Configure logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
streamHandler = logging.StreamHandler(stream=sys.stdout)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
def decode_to_bytes(e):
return base64.b64decode(e)
def decompress_to_string(binary_data):
return gzip.decompress(binary_data).decode('utf-8')
def lambda_handler(event, context):
logger.info("event before processing: {}".format(event))
decompressed_data = []
for e in event:
binary_data = decode_to_bytes(e)
decompressed_string = decompress_to_string(binary_data)
decompressed_data.append(json.loads(decompressed_string))
logger.info("event after processing: {}".format(decompressed_data))
return decompressed_data
```