Aviso de fim do suporte: em 15 de dezembro de 2025, AWS encerrará o suporte para AWS IoT Analytics. Depois de 15 de dezembro de 2025, você não poderá mais acessar o AWS IoT Analytics console ou os AWS IoT Analytics recursos. Para obter mais informações, consulte [AWS IoT Analytics Fim do suporte](https://docs.aws.amazon.com/iotanalytics/latest/userguide/iotanalytics-end-of-support.html).
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# AWS Lambda atividade
Você pode usar uma **atividade `lambda`** para realizar processamento mais complexo na mensagem. Por exemplo, você pode enriquecer mensagens com dados da saída de operações externas de API ou filtrar mensagens com base na lógica do Amazon DynamoDB. No entanto, você não pode usar essa atividade de pipeline para adicionar mensagens adicionais ou remover mensagens existentes antes de entrar em um datastore.
A AWS Lambda função usada em uma **`lambda`atividade** deve receber e retornar uma matriz de objetos JSON. Para obter um exemplo, consulte [Exemplo 1 da função do Lambda](#pipeline-activities-lambda-ex1).
Para conceder AWS IoT Analytics permissão para invocar sua função Lambda, você deve adicionar uma política. Por exemplo, execute o seguinte comando da CLI e {{exampleFunctionName}} substitua pelo nome da sua função Lambda, {{123456789012}} substitua pelo ID da AWS conta e use o Amazon Resource Name (ARN) do pipeline que invoca a função Lambda em questão.
```
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}}
```
O comando retorna o seguinte:
```
{
"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 mais informações, consulte [Uso de políticas com base em recursos AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) em *Guia do desenvolvedor AWS Lambda *.
## Exemplo 1 da função do Lambda
Neste exemplo, a função do Lambda adiciona informações com base nos dados da mensagem original. Um dispositivo publica uma mensagem com uma carga semelhante ao exemplo a seguir.
```
{
"thingid": "00001234abcd",
"temperature": 26,
"humidity": 29,
"location": {
"lat": 52.4332935,
"lon": 13.231694
},
"ip": "192.168.178.54",
"datetime": "2018-02-15T07:06:01"
}
```
E o dispositivo tem a seguinte definição de pipeline.
```
{
"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"
}
}
```
A função Lambda Python a seguir (`MyAnalyticsLambdaFunction`) adiciona a GMaps URL e a temperatura, em Fahrenheit, à mensagem.
```
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
```
## Exemplo 2 da função do Lambda
Uma técnica útil é compactar e serializar cargas de mensagens para reduzir os custos de transporte e armazenamento. Neste segundo exemplo, a função do Lambda supõe que a carga da mensagem representa um JSON original que foi compactado e codificado em base64 (serializado) como uma string. Ela retorna o 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
```