AWS IoT Greengrass Version 1 entrou na fase de vida útil prolongada em 30 de junho de 2023. Para obter mais informações, consulte política de manutenção do AWS IoT Greengrass V1. Após essa data, AWS IoT Greengrass V1 não lançaremos atualizações que forneçam recursos, aprimoramentos, correções de erros ou patches de segurança. Os dispositivos que funcionam AWS IoT Greengrass V1 não serão interrompidos e continuarão operando e se conectando à nuvem. É altamente recomendável que você migre para AWS IoT Greengrass Version 2, o que adiciona novos recursos significativos e suporte para plataformas adicionais.

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á.

Execute funções do Lambda no núcleo do AWS IoT Greengrass

O AWS IoT Greengrass fornece um ambiente de runtime do Lambda em contêineres para código definido pelo usuário que você cria em AWS Lambda. As funções do Lambda implantadas em um AWS IoT Greengrass são executadas no runtime local do Lambda do núcleo. As funções do Lambda locais podem ser acionadas por eventos locais, mensagens da nuvem e outras fontes, o que oferece funcionalidade de computação local para dispositivos cliente. Por exemplo, você pode usar funções do Lambda do Greengrass para filtrar dados do dispositivo antes de transmitir os dados para a nuvem.

Para implantar uma função do Lambda para um núcleo, você adiciona a função a um grupo do Greengrass (referenciando a função do Lambda existente), define as configurações específicas de grupo da função e implanta o grupo. Se a função acessar serviços da AWS, você também deverá adicionar todas as permissões necessárias à função do grupo do Greengrass.

Você pode configurar parâmetros que determinam como as funções do Lambda são executadas, incluindo permissões, isolamento, limites de memória e muito mais. Para ter mais informações, consulte Controlar a execução de funções do Lambda do Greengrass usando a configuração específica do grupo.

A tabela a seguir lista os tempos de execução compatíveis do AWS Lambda e as versões de software de núcleo do AWS IoT Greengrass nas quais eles podem ser executados.

* É possível executar funções do Lambda que usam esses tempos de execução em versões compatíveis do AWS IoT Greengrass, mas não é possível criá-las no AWS Lambda. Se o runtime de seu dispositivo for diferente do runtime do Lambda AWS especificado para essa função, você poderá escolher seu próprio runtime usando FunctionRuntimeOverride no FunctionDefintionVersion. Para obter mais informações, consulte CreateFunctionDefinition. Para obter mais informações sobre os runtimes compatíveis, consulte a Política de suporte do runtime no Guia do desenvolvedor do AWS Lambda.

SDKs para funções do Lambda do Greengrass

A AWS fornece três SDKs que podem ser usados por funções do Lambda do Greengrass em execução em um núcleo AWS IoT Greengrass. Esses SDKs estão contidos em pacotes separados para que as funções possam usá-los simultaneamente. Para usar um SDK em uma função do Lambda do Greengrass, inclua-o no pacote de implantação da função do Lambda que você transfere por upload para o AWS Lambda.

Para obter mais informações sobre como criar um pacote de implantação, consulte Crie e empacote uma função do Lambda no tutorial Conceitos básicos ou Criar um pacote de implantação no Guia do desenvolvedor do AWS Lambda.

Migrando funções do Lambda baseadas em nuvem

O SDK do AWS IoT Greengrass Core segue o modelo de programação do SDK da AWS, que facilita a portabilidade de funções do Lambda desenvolvidas para a nuvem para funções do Lambda executadas em um núcleo AWS IoT Greengrass.

Por exemplo, a função Python do Lambda usa o AWS SDK for Python (Boto3) a fim de publicar uma mensagem no tópico some/topic na nuvem:

import boto3

iot_client = boto3.client("iot-data")
response = iot_client.publish(
    topic="some/topic", qos=0, payload="Some payload".encode()
)

Para portar a função para um núcleo AWS IoT Greengrass, na instrução import e na inicialização client, altere o nome do módulo boto3 para greengrasssdk, conforme mostrado no seguinte exemplo:

import greengrasssdk

iot_client = greengrasssdk.client("iot-data")
iot_client.publish(topic="some/topic", qos=0, payload="Some payload".encode())

A semelhança entre os modelos de programação também possibilita que você desenvolva suas funções do Lambda na nuvem e depois as migre para AWS IoT Greengrass sem muito esforço. Os executáveis do Lambda não são executados na nuvem, portanto, você não pode usar o SDK da AWS para testá-los na nuvem antes da implantação.

Referência de funções do Lambda por alias ou versão

Os grupos do Greengrass podem fazer referência a uma função do Lambda por alias (recomendado) ou por versão. Usar um alias facilita o gerenciamento de atualizações de código porque você não precisa alterar a tabela de assinaturas nem a definição do grupo ao atualizar a função do código. Em vez disso, você pode simplesmente apontar o alias para a nova versão da função. Os aliases se tornam números de versão durante a implantação do grupo. Quando você usa aliases, a versão resolvida é atualizada para a versão para a qual o alias aponta no momento da implantação.

O AWS IoT Greengrass não oferece suporte a alias do Lambda para as versões $LATEST. As versões $LATEST não estão vinculadas a versões de função imutável e publicada e podem ser alteradas a qualquer momento, que é a resposta ao princípio do AWS IoT Greengrass de imutabilidade da versão.

Uma prática comum para manter as funções do Lambda do Greengrass atualizadas com alterações feitas no código é usar um alias chamado PRODUCTION no grupo e nas assinaturas do Greengrass. Conforme você promove novas versões da função do Lambda para produção, aponte o alias para a versão estável mais recente e, em seguida, reimplante o grupo. Você também pode usar esse método a fim de reverter para uma versão anterior.

Fluxos de comunicação para funções do Lambda do Greengrass

As funções do Lambda do Greengrass oferecem suporte a vários métodos de comunicação com outros membros do grupo AWS IoT Greengrass, serviços locais e serviços em nuvem (inclusive serviços da AWS).

Comunicação usando mensagens MQTT

As funções do Lambda podem enviar e receber mensagens MQTT usando um padrão de publicação/assinatura que é controlado por assinaturas.

Esse fluxo de comunicação permite que as funções do Lambda troquem mensagens com as seguintes entidades:

Uma assinatura define uma origem de mensagem, um destino de mensagem e um tópico (ou assunto) que é usado para rotear mensagens da origem para o destino. As mensagens publicadas em uma função do Lambda são passadas para o manipulador registrado da função. As assinaturas permitem mais segurança e oferecem interações previsíveis. Para ter mais informações, consulte Assinaturas gerenciadas no fluxo de trabalho de mensagens MQTT.

Outros fluxos de comunicação

Recuperar o tópico MQTT de entrada (ou assunto)

O AWS IoT Greengrass usa assinaturas para controlar a troca de mensagens MQTT entre dispositivos cliente, as funções do Lambda e os conectores em um grupo e com o AWS IoT ou o serviço de sombra local. As assinaturas definem a origem de uma mensagem, o destino de uma mensagem e um tópico MQTT usado para rotear mensagens. Quando o destino é uma função do Lambda, o manipulador da função é invocado quando a origem publica uma mensagem. Para ter mais informações, consulte Comunicação usando mensagens MQTT.

O exemplo a seguir mostra como uma função do Lambda pode obter o tópico de entrada do context que é passado para o manipulador. Ele faz isso acessando a subject chave da hierarquia de contexto (context.client_context.custom['subject']). O exemplo também analisa a mensagem de entrada do JSON e, em seguida, publica o tópico e a mensagem analisados.

import greengrasssdk
import logging

client = greengrasssdk.client('iot-data')

OUTPUT_TOPIC = 'test/topic_results'

def get_input_topic(context):
    try:
        topic = context.client_context.custom['subject']
    except Exception as e:
        logging.error('Topic could not be parsed. ' + repr(e))
    return topic
    
def get_input_message(event):
    try:
        message = event['test-key']
    except Exception as e:
        logging.error('Message could not be parsed. ' + repr(e))
    return message

def function_handler(event, context):
    try:
        input_topic = get_input_topic(context)
        input_message = get_input_message(event)
        response = 'Invoked on topic "%s" with message "%s"' % (input_topic, input_message)
        logging.info(response)
    except Exception as e:
        logging.error(e)

    client.publish(topic=OUTPUT_TOPIC, payload=response)

    return

Para testar a função, adicione-a ao seu grupo usando as definições de configuração padrão. Em seguida, adicione as assinaturas a seguir e implante o grupo. Para obter instruções, consulte Módulo 3 (parte 1): Funções do Lambda no AWS IoT Greengrass.

Depois que a implantação for concluída, invoque a função.

Configuração do ciclo de vida das funções do Lambda do Greengrass

O ciclo de vida da função do Lambda do Greengrass determina quando uma função começa e como ela cria e usa contêineres. O ciclo de vida também determina como as variáveis e a lógica de pré-processamento que estão fora do manipulador da função são retidas.

O AWS IoT Greengrass oferece suporte a ciclos de vida sob demanda (padrão) ou de longa duração:

Para obter mais informações sobre a reutilização de contêineres, consulte Noções básicas da reutilização de contêineres no AWS Lambda no blog de computação da AWS.

Executáveis do Lambda

Esse atributo está disponível para o AWS IoT Greengrass Core v1.6 e posterior.

Um executável do Lambda é um tipo de função do Lambda do Greengrass que você pode usar para executar o código binário no ambiente básico. Ele permite executar a funcionalidade específica do dispositivo de maneira nativa e se beneficiar do espaço menor do código compilado. Os executáveis do Lambda podem ser invocados por eventos, invocar outras funções e acessar recursos locais.

Os executáveis do Lambda só oferecem suporte ao tipo de codificação binária (e não JSON), mas você pode gerenciá-los no grupo do Greengrass e implantá-los como outras funções do Lambda do Greengrass. No entanto, o processo de criar executáveis do Lambda é diferente de criar funções do Lambda no Python, Java e Node.js:

Os executáveis do Lambda devem implementar determinadas chamadas e padrões de programação no código de função. Por exemplo, o método main deve:

O snippet a seguir é o método main do exemplo de código simple_handler.c no GitHub.

int main() {
    gg_error err = GGE_SUCCESS;

    err = gg_global_init(0);
    if(err) {
        gg_log(GG_LOG_ERROR, "gg_global_init failed %d", err);
        goto cleanup;
    }

    gg_runtime_start(handler, 0);

cleanup:
    return -1;
}

Para obter mais informações sobre requisitos, restrições e outros detalhes de implementação, consulte SDK do AWS IoT Greengrass Core para C.

Crie um executável do Lambda

Depois que você compilar o código com o SDK, use a API do AWS Lambda para criar uma função do Lambda e fazer upload do executável compilado.

O exemplo a seguir usa o comando da CLI create-function para criar um executável do Lambda. O comando especifica:

aws lambda create-function \
--region aws-region \
--function-name function-name \
--handler executable-name \
--role role-arn \
--zip-file fileb://file-name.zip \
--runtime arn:aws:greengrass:::runtime/function/executable

Em seguida, use a API do AWS Lambda para publicar uma versão e crie um alias.

Em seguida, adicione o executável do Lambda a um grupo do Greengrass, configure-o para aceitar dados de entrada binários nas configurações específicas do grupo e implantar o grupo. Você pode fazer isso no console do AWS IoT Greengrass ou usando a API AWS IoT Greengrass.