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á. # Executar funções AWS Lambda. **nota** No momento, o AWS IoT Greengrass não oferece suporte a esse recurso nos dispositivos principais do Windows. Você pode importar AWS Lambda funções como componentes que são executados nos dispositivos AWS IoT Greengrass principais. Talvez você queira fazer isso nos seguintes casos: + Você tem código de aplicação nas funções do Lambda que deseja implantar nos dispositivos principais. + Você tem aplicações AWS IoT Greengrass V1 que deseja executar nos dispositivos AWS IoT Greengrass V2 principais. Para obter mais informações, consulte [Etapa 2: criar e implantar AWS IoT Greengrass V2 componentes para migrar aplicativos AWS IoT Greengrass V1](set-up-v2-test-device.md#run-v1-applications). As funções do Lambda incluem dependências nos componentes a seguir. Você não precisa definir esses componentes como dependências ao importar a função. Quando você implanta o componente da função do Lambda, a implantação inclui essas dependências do componente Lambda. + O [componente Lambda launcher](lambda-launcher-component.md) (`aws.greengrass.LambdaLauncher`) lida com processos e configurações do ambiente. + O [componente Lambda Manager](lambda-manager-component.md) (`aws.greengrass.LambdaManager`) lida com a comunicação e o escalonamento entre processos. + O [componente de runtimes do Lambda](lambda-runtimes-component.md) (`aws.greengrass.LambdaRuntimes`) fornece artefatos para cada runtime do Lambda compatível. **Topics** + [ ## Requisitos ](#run-lambda-functions-requirements) + [ ## Configurar o ciclo de vida da função do Lambda ](#lambda-lifecycle) + [ ## Configurar a conteinerização de funções do Lambda ](#lambda-containerization) + [ # Importar uma função do Lambda como componente (console) ](import-lambda-function-console.md) + [ # Importar uma função do Lambda como componente (AWS CLI) ](import-lambda-function-cli.md) ## Requisitos Seus dispositivos principais e funções do Lambda devem atender aos seguintes requisitos para que você execute as funções no software AWS IoT Greengrass Core: + O dispositivo principal deve atender aos requisitos para executar as funções do Lambda. Se você deseja que o dispositivo principal execute funções do Lambda em contêiner, o dispositivo deve atender aos requisitos para isso. Para obter mais informações, consulte [Requisitos da função do Lambda](setting-up.md#greengrass-v2-lambda-requirements). + Você deve instalar as linguagens de programação que a função do Lambda usa em seus dispositivos principais. **dica** Você pode criar um componente que instala a linguagem de programação e, em seguida, especificar esse componente como uma dependência do seu componente da função do Lambda. O Greengrass oferece suporte a todas as versões compatíveis com o Lambda dos runtimes Python, Node.js e Java. O Greengrass não impõe nenhuma outra restrição às versões de runtime obsoletas do Lambda. É possível executar funções do Lambda que usam esses runtimes obsoletos no AWS IoT Greengrass, mas não é possível criá-las no AWS Lambda. Para obter mais informações sobre compatibilidade da AWS IoT Greengrass com runtime do Lambda, consulte [Executar funções AWS Lambda.](#run-lambda-functions). ## Configurar o ciclo de vida da função do Lambda 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 o software AWS IoT Greengrass Core retém as variáveis e a lógica de pré-processamento que estão fora do manipulador de funções. O AWS IoT Greengrass oferece suporte a ciclos de vida sob demanda (padrão) e de longa duração: + As funções **sob demanda** começam quando são invocadas e param quando não há tarefas a serem executadas. Cada invocação da função cria um contêiner separado, também chamado de sandbox, para processar as invocações, a menos que um contêiner existente esteja disponível para reutilização. Qualquer um dos contêineres pode processar dados que você envia para a função. Várias invocações de uma função sob demanda podem ser executadas simultaneamente. Variáveis e lógica de pré-processamento que estão definidas fora do manipulador de funções não são mantidas quando novos contêineres são criados. + As funções de **longa duração** (ou *fixadas*) são iniciadas quando o software do AWS IoT Greengrass Core é iniciado e executado em um único contêiner. O mesmo contêiner processa todos os dados que você envia para a função. Várias invocações são colocadas na fila até que o software AWS IoT Greengrass Core execute as invocações anteriores. Variáveis e lógica de pré-processamento que estão definidas fora do manipulador de funções são mantidas para cada invocação do manipulador. Use funções do Lambda de longa duração quando precisar começar a trabalhar sem qualquer entrada inicial. Por exemplo, uma função de longa duração pode carregar e começar a processar um modelo de machine learning para estar pronto quando a função receber dados do dispositivo. **nota** As funções de longa duração têm tempos limite associados a cada invocação de seu manipulador. Se quiser invocar um código que fique em execução indefinidamente, é necessário iniciá-lo fora do manipulador. Certifique-se de não haver nenhum código de bloqueio fora do manipulador que possa impedir a inicialização da função. Essas funções são executadas a menos que o software AWS IoT Greengrass principal pare, como durante uma implantação ou reinicialização. Essas funções não serão executadas se a função encontrar uma exceção não detectada, exceder seus limites de memória ou entrar em um estado de erro, como o tempo limite do manipulador. 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](https://aws.amazon.com/blogs/compute/container-reuse-in-lambda/) no *blog de computação da AWS*. ## Configurar a conteinerização de funções do Lambda Por padrão, as funções do Lambda são executadas em um contêiner do AWS IoT Greengrass. Os contêineres do Greengrass fornecem isolamento entre suas funções e o host. Esse isolamento aumenta a segurança do host e das funções no contêiner. Recomendamos executar funções do Lambda em um contêiner do Greengrass, a menos que o seu caso de uso exija que essas funções sejam executadas sem conteinerização do Greengrass. Ao executar suas funções do Lambda em um contêiner do Greengrass, você terá mais controle sobre como restringir o acesso a recursos. Você pode executar uma função do Lambda sem conteinerização nos casos a seguir: + Você deseja executar AWS IoT Greengrass em um dispositivo que não seja compatível com o modo contêiner. Um exemplo seria se você quisesse usar uma distribuição Linux especial ou ter uma versão anterior do kernel que esteja desatualizada. + Você deseja executar a função do Lambda em outro ambiente de contêiner com seu próprio OverlayFS, mas encontra conflitos de OverlayFS ao executar em um contêiner do Greengrass. + Você precisa de acesso a recursos locais com caminhos que não podem ser determinados no momento da implantação ou cujos caminhos podem mudar após a implantação. Um exemplo desse recurso seria um dispositivo conectável. + Você tem uma aplicação antiga que foi escrita como um processo e encontrou problemas ao executá-la em um contêiner do Greengrass. **Diferenças de conteinerização** | Conteinerização | Observações | | --- | --- | | Contêiner do Greengrass | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/run-lambda-functions.html) | | Nenhum contêiner | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v2/developerguide/run-lambda-functions.html) | Se você alterar a conteinerização para uma função do Lambda quando você a implantar, a função poderá não funcionar conforme o esperado. Se a função do Lambda usar recursos locais que não estão mais disponíveis com a nova configuração de conteinerização, a implantação falhará. + Quando você altera uma função do Lambda da execução em um contêiner do Greengrass para a execução sem conteinerização, os limites de memória da função são descartados. Você deve acessar o sistema de arquivos diretamente em vez de usar recursos locais anexados. Você deve remover todos os recursos anexados antes de implantar a função do Lambda. + Quando você altera uma função do Lambda da execução sem conteinerização para execução em um contêiner, sua função do Lambda perde o acesso direto ao sistema de arquivos. Você deve definir um limite de memória para cada função ou aceitar o padrão de limite de memória de 16 MB. Você pode definir essas configurações para cada função do Lambda ao implantá-la. Para alterar as configurações de conteinerização de um componente da função do Lambda, defina o valor do parâmetro de configuração `containerMode` como uma das seguintes opções ao implantar o componente. + `NoContainer`; o componente não é executado em um ambiente de runtime isolado. + `GreengrassContainer`: o componente é executado em um ambiente de runtime isolado dentro do contêiner do AWS IoT Greengrass. Para obter mais informações sobre como fazer essa implantação e configuração de componentes, consulte [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md) e [Atualizar configurações do componente](update-component-configurations.md). # Importar uma função do Lambda como componente (console) Ao usar o [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass) para criar um componente de função do Lambda, você importa uma função do AWS Lambda existente e a configura para criar um componente que seja executado em seu dispositivo Greengrass. Antes de começar, revise os [requisitos](https://docs.aws.amazon.com/greengrass/v2/developerguide/run-lambda-functions.html#run-lambda-functions-requirements) para executar as funções do Lambda em dispositivos Greengrass. **Topics** + [ ## Etapa 1: escolher uma função do Lambda para importar ](#import-lambda-console-choose-function) + [ ## Etapa 2: configurar os parâmetros da função do Lambda ](#import-lambda-console-configure-function-parameters) + [ ## Etapa 3: (opcional) especificar plataformas compatíveis para a função do Lambda ](#import-lambda-console-configure-platforms) + [ ## Etapa 4: (opcional) especificar as dependências do componente para a função do Lambda ](#import-lambda-console-configure-dependencies) + [ ## Etapa 5: (opcional) executar a função do Lambda em um contêiner ](#import-lambda-console-run-isolated) + [ ## Etapa 6: criar o componente da função do Lambda ](#import-lambda-console-create-deploy) ## Etapa 1: escolher uma função do Lambda para importar 1. No menu de navegação do [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), selecione **Componentes**. 1. Na página **Componentes**, escolha **Criar componente**. 1. Na página **Criar componente**, em **Informações do componente**, escolha **Importar função do Lambda**. 1. Em **Função do Lambda**, pesquise e selecione a função do Lambda para importar. AWS IoT Greengrass cria o componente com o nome da função Lambda. 1. Na **versão da função do Lambda**, escolha a versão a ser importada. Você não pode escolher aliases do Lambda como `$LATEST`. AWS IoT Greengrass cria o componente com a versão da função Lambda como uma versão semântica válida. Por exemplo, se a versão da função for `3`, a versão do componente se tornará `3.0.0`. ## Etapa 2: configurar os parâmetros da função do Lambda Na página **Criar componente**, em **Configuração da função do Lambda**, configure os seguintes parâmetros para usar na execução da função do Lambda. 1. (Opcional) Adicione a lista de fontes de eventos nas quais a função do Lambda se inscreve para receber mensagens de trabalho. Você pode especificar fontes de eventos para inscrever essa função em publish/subscribe mensagens locais e mensagens AWS IoT Core MQTT. A função do Lambda é chamada quando recebe uma mensagem de uma origem de evento. **nota** Para inscrever essa função em mensagens de outras funções ou componentes do Lambda, implante o [componente legado do roteador de assinatura](legacy-subscription-router-component.md) ao implantar esse componente da função do Lambda. Ao implantar o componente legado do roteador de assinatura, especifique as assinaturas que a função do Lambda usa. Em **Fontes de eventos**, faça o seguinte para adicionar uma fonte de eventos: 1. Para cada fonte de evento que você incluir, especifique as seguintes opções: + **Tópico**: o tópico para assinar mensagens. + **Tipo**: o tipo de origem do evento. Escolha uma das seguintes opções: + **Publicação/assinatura local — Assine** mensagens locais publish/subscribe . Se você usa o [núcleo do Greengrass](greengrass-nucleus-component.md) v2.6.0 ou posterior e o [gerenciador do Lambda](lambda-manager-component.md) v2.2.5 ou posterior, você pode usar curingas de tópico do MQTT (`+` e `#`) no **Tópico** ao especificar esse tipo. + **AWS IoT Core MQTT** — Assine as mensagens do AWS IoT Core MQTT. Você pode usar curingas de tópico do MQTT (`+` e `#`) no **Tópico** ao especificar esse tipo. 1. Para adicionar outra fonte de eventos, selecione **Adicionar origem de evento** e repita a etapa anterior. Para remover uma origem do evento, selecione **Remover** ao lado da origem do evento para remover. 1. Em **Timeout (segundos)**, insira o tempo máximo em segundos que uma função do Lambda não fixada pode ser executada antes que o tempo limite seja atingido. O padrão é 3 segundos. 1. Em **Fixado**, escolha se o componente da função do Lambda está fixado. O padrão é **True**. + Uma função Lambda fixa (ou de longa duração) AWS IoT Greengrass começa quando é iniciada e continua sendo executada em seu próprio contêiner. + Uma função do Lambda não fixada (ou sob demanda) só é iniciada quando recebe um item de trabalho e sai depois que permanece ociosa por um tempo de ociosidade máximo especificado. Se a função tiver vários itens de trabalho, o software AWS IoT Greengrass Core cria várias instâncias da função. 1. (Opcional) Em **Parâmetros adicionais**, defina os seguintes parâmetros da função do Lambda. + **Tempo limite do status (segundos)**: o intervalo em segundos no qual o componente de uma função do Lambda envia atualizações de status para o componente do gerenciador do Lambda. Este parâmetro se aplica apenas a funções fixadas. O padrão é 60 segundos. + **Tamanho máximo da fila**: o tamanho máximo da fila de mensagens para o componente de função do Lambda. O software AWS IoT Greengrass Core armazena mensagens em uma fila FIFO (primeiro a entrar, primeiro a sair) até poder executar a função Lambda para consumir cada mensagem. O valor padrão é de 1.000 mensagens. + **Número máximo de instâncias**: o número máximo de instâncias que uma função do Lambda não fixada pode executar ao mesmo tempo. O padrão é 100 instâncias. + **Tempo máximo de inatividade (segundos)** — A quantidade máxima de tempo em segundos que uma função Lambda não fixada pode ficar ociosa antes que AWS IoT Greengrass o software principal interrompa seu processo. O padrão é 60 segundos. + **Tipo de codificação**: o tipo de carga útil compatível com a função do Lambda. Escolha uma das seguintes opções: + **JSON** + **Binário** O padrão é JSON. 1. (Opcional) Especifique a lista de argumentos de linha de comando a serem passados para a função do Lambda quando ela for executada. 1. Em **Parâmetros adicionais, Argumentos de processo**, escolha **Adicionar argumento**. 1. Para cada argumento que você incluir, insira o argumento para passar para a função. 1. Selecione **Remover** ao lado de um argumento para removê-lo. 1. (Opcional) Especifique as variáveis de ambiente que estão disponíveis para a função do Lambda quando ela é executada. As variáveis de ambiente permitem que você armazene e atualize as configurações sem a necessidade de alterar o código da função. 1. Em **Parâmetros adicionais, Variáveis de ambiente**, escolha **Adicionar variável de ambiente**. 1. Para cada variável de ambiente que você incluir, especifique as seguintes opções: + **Chave**: o nome da variável. + **Valor**: o valor padrão para essa variável. 1. Para remover uma variável de ambiente, selecione **Remover** ao lado da variável de ambiente para remover. ## Etapa 3: (opcional) especificar plataformas compatíveis para a função do Lambda Todos os dispositivos principais têm atributos de sistema operacional e arquitetura. Quando você implanta o componente da função Lambda, o software AWS IoT Greengrass Core compara os valores da plataforma que você especifica com os atributos da plataforma no dispositivo principal para determinar se a função Lambda é suportada nesse dispositivo. **nota** Você também pode especificar atributos de plataforma personalizados ao implantar o componente de núcleo do Greengrass em um dispositivo principal. Para obter mais informações, consulte o [parâmetro de substituição da plataforma](greengrass-nucleus-component.md#greengrass-nucleus-component-configuration-platform-overrides) do [componente de núcleo do Greengrass](greengrass-nucleus-component.md). Em **Configuração da função do Lambda, Parâmetros adicionais, Plataformas**, faça o seguinte para especificar as plataformas que essa função do Lambda suporta. 1. Para cada plataforma, especifique as seguintes opções: + **Sistema operacional**: o nome do sistema operacional da plataforma. Atualmente, o único valor compatível é `linux`. + **Arquitetura**: a arquitetura do processador para a plataforma. Os valores compatíveis são: + `amd64` + `arm` + `aarch64` + `x86` 1. Para adicionar outra plataforma, escolha **Adicionar plataforma** e repita a etapa anterior. Para remover uma plataforma compatível, selecione **Remover** ao lado da plataforma que deseja remover. ## Etapa 4: (opcional) especificar as dependências do componente para a função do Lambda As dependências de componentes identificam componentes adicionais AWS fornecidos ou componentes personalizados que sua função usa. Quando você implanta o componente da função do Lambda, a implantação inclui essas dependências para que sua função seja executada. **Importante** Para importar uma função Lambda que você criou para ser executada na AWS IoT Greengrass V1, você deve definir dependências de componentes individuais para os recursos que sua função usa, como segredos, sombras locais e gerenciador de stream. Defina esses componentes como [dependências permanentes](component-recipe-reference.md) para que seu componente da função do Lambda seja reiniciado se a dependência mudar de estado. Para obter mais informações, consulte [Importar funções do Lambda no V1](set-up-v2-test-device.md#run-v1-lambda-functions). Em **Configuração da função do Lambda, Parâmetros adicionais, Dependências de componentes,** conclua as etapas a seguir para especificar as dependências de componentes para sua função do Lambda. 1. Escolha **Adicionar dependência.** 1. Para cada dependência de componente que você incluir, especifique as seguintes opções: + **Nome do componente**: o nome do componente. Por exemplo, insira **aws.greengrass.StreamManager** para incluir o [componente gerenciador de fluxos](stream-manager-component.md). + **Requisito de versão**: a restrição de versão semântica no estilo npm que identifica as versões compatíveis dessa dependência de componente. É possível especificar uma versão ou um intervalo de versões. Por exemplo, insira **^1.0.0** para especificar que essa função do Lambda depende de qualquer versão na primeira versão principal do componente do gerenciador de fluxos. Para obter mais informações sobre restrições de versão semântica, consulte a [calculadora npm semver](https://semver.npmjs.com/). + **Tipo**: o tipo de dependência. Escolha uma das seguintes opções: + **Permanente**: o componente da função do Lambda é reiniciado se a dependência muda de estado. Esta é a seleção padrão. + **Temporário**: o componente da função do Lambda não é reiniciado se a dependência muda de estado. 1. Para remover uma dependência de componente, escolha **Remover** ao lado da dependência do componente ## Etapa 5: (opcional) executar a função do Lambda em um contêiner Por padrão, as funções Lambda são executadas em um ambiente de execução isolado dentro do software AWS IoT Greengrass Core. Você também pode optar por executar a função do Lambda como um processo sem nenhum isolamento (ou seja, no modo **Sem contêiner**). Em **Configuração do processo Linux**, para o **modo de isolamento**, escolha entre as seguintes opções para selecionar a conteinerização para sua função do Lambda: + **Contêiner do Greengrass**: a função do Lambda é executada em um contêiner. Esta é a seleção padrão. + **Sem contêiner**: a função do Lambda é executada como processo sem nenhum isolamento. Se você executar a função do Lambda em um contêiner, conclua as etapas a seguir para definir a configuração do processo para a função do Lambda. 1. Configure a quantidade de memória e os recursos do sistema, como volumes e dispositivos, a serem disponibilizados para o contêiner. Em **Parâmetros de contêiner**, siga as instruções abaixo. 1. Em **Tamanho da memória**, insira o tamanho da memória que você deseja alocar para o contêiner. Você pode especificar o tamanho da memória em **MB** ou **kB**. 1. Em **Pasta sys somente leitura**, escolha se o contêiner pode ou não ler informações da pasta do dispositivo `/sys`. O padrão é **falso**. 1. (Opcional) Configure os volumes locais que a função do Lambda em contêiner pode acessar. Quando você define um volume, o software AWS IoT Greengrass Core monta os arquivos de origem no destino dentro do contêiner. 1. Em **Volumes**, escolha **Adicionar volume**. 1. Para cada volume que você incluir, especifique as seguintes opções: + **Volume físico**: o caminho para a pasta de origem no dispositivo principal. + **Volume lógico**: o caminho para a pasta de destino no contêiner. + **Permissão** (opcional): a permissão para acessar a pasta de origem a partir do contêiner. Escolha uma das seguintes opções: + **Somente leitura**: a função do Lambda tem acesso somente leitura à pasta de origem. Esta é a seleção padrão. + **Leitura/gravação**: a função do Lambda tem acesso de leitura/gravação à pasta de origem. + **Adicionar proprietário do grupo**: (Opcional) Se deve ou não adicionar o grupo do sistema que executa o componente da função do Lambda como proprietário da pasta de origem. O padrão é **falso**. 1. Selecione **Remover** ao lado de um volume para removê-lo. 1. (Opcional) Configure os dispositivos do sistema local que a função do Lambda em contêiner pode acessar. 1. Em **Dispositivos**, escolha **Adicionar dispositivo**. 1. Para cada dispositivo que você incluir, especifique as seguintes opções: + **Caminho de montagem**: o caminho para o dispositivo do sistema no dispositivo principal. + **Permissão** (opcional): a permissão para acessar o dispositivo do sistema a partir do contêiner. Escolha uma das seguintes opções: + **Somente leitura**: a função do Lambda tem acesso somente leitura ao dispositivo do sistema. Esta é a seleção padrão. + **Leitura/gravação**: a função do Lambda tem acesso de leitura/gravação à pasta de origem. + **Adicionar proprietário do grupo**: (opcional) Se deve ou não adicionar o grupo do sistema que executa o componente da função do Lambda como proprietário do dispositivo do sistema. O padrão é **falso**. ## Etapa 6: criar o componente da função do Lambda Depois de definir as configurações do componente da função do Lambda, escolha **Criar** para concluir a criação do novo componente. Para executar a função do Lambda em seu dispositivo principal, você pode então implantar o novo componente em seus dispositivos principais. Para obter mais informações, consulte [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md). # Importar uma função do Lambda como componente (AWS CLI) Use a [CreateComponentVersion](https://docs.aws.amazon.com/greengrass/v2/APIReference/API_CreateComponentVersion.html)operação para criar componentes a partir das funções Lambda. Ao chamar essa operação, especifique `lambdaFunction` para importar uma função do Lambda. **Topics** + [ ## Etapa 1: definir a configuração da função do Lambda ](#create-lambda-function-configuration-cli) + [ ## Etapa 2: criar o componente da função do Lambda ](#create-lambda-component-cli) ## Etapa 1: definir a configuração da função do Lambda 1. Crie um arquivo chamado `lambda-function-component.json` e copie o objeto JSON a seguir no arquivo. Substitua o `lambdaArn` pelo ARN da função do Lambda a ser importada. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1" } } ``` **Importante** É necessário especificar um ARN que inclua a versão da função a ser importada. Você não pode usar aliases de versão, como `$LATEST`. 1. (Opcional) Especifique o nome (`componentName`) do componente. Se você omitir esse parâmetro, AWS IoT Greengrass cria o componente com o nome da função Lambda. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda" } } ``` 1. (Opcional) Especifique a versão (`componentVersion`) do componente. Se você omitir esse parâmetro, AWS IoT Greengrass cria o componente com a versão da função Lambda como uma versão semântica válida. Por exemplo, se a versão da função for `3`, a versão do componente se tornará `3.0.0`. **nota** Cada versão do componente que você carrega deve ser exclusiva. Certifique-se de carregar a versão correta do componente, pois você não poderá editá-la depois de carregá-la. AWS IoT Greengrass usa versões semânticas para componentes. As versões semânticas seguem um sistema de numeração *principal*.*secundária*.*patch*. Por exemplo, a versão `1.0.0` representa a primeira versão principal de um componente. Para mais informações, consulte a [especificação de versão semântica](https://semver.org/). ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0" } } ``` 1. (Opcional) Especifique as plataformas suportadas por essa função do Lambda. Cada plataforma contém um mapa de atributos que identificam uma plataforma. Todos os dispositivos principais têm atributos para sistema operacional (`os`) e arquitetura (`architecture`). O software AWS IoT Greengrass principal pode adicionar outros atributos da plataforma. Você também pode especificar atributos de plataforma personalizados ao implantar o [componente de núcleo do Greengrass](greengrass-nucleus-component.md) em um dispositivo principal. Faça o seguinte: 1. Adicione uma lista de plataformas (`componentPlatforms`) à função do Lambda em `lambda-function-component.json`. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ ] } } ``` 1. Adicione cada plataforma compatível à lista. Cada plataforma tem uma interface amigável `name` para identificá-la e um mapa de atributos. O exemplo a seguir especifica que essa função oferece suporte a dispositivos x86 que executam Linux. ``` { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ``` Você `lambda-function-component.json` pode conter um documento similar ao exemplo a seguir. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ] } } ``` 1. (Opcional) Especifique as dependências do componente para sua função do Lambda. Quando você implanta o componente da função do Lambda, a implantação inclui essas dependências para que sua função seja executada. **Importante** Para importar uma função Lambda que você criou para ser executada na AWS IoT Greengrass V1, você deve definir dependências de componentes individuais para os recursos que sua função usa, como segredos, sombras locais e gerenciador de stream. Defina esses componentes como [dependências permanentes](component-recipe-reference.md) para que seu componente da função do Lambda seja reiniciado se a dependência mudar de estado. Para obter mais informações, consulte [Importar funções do Lambda no V1](set-up-v2-test-device.md#run-v1-lambda-functions). Faça o seguinte: 1. Adicione um mapa das dependências do componente (`componentDependencies`) à função do Lambda em `lambda-function-component.json`. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { } } } ``` 1. Adicione cada dependência do componente ao mapa. Especifique o nome do componente como chave e especifique um objeto com os seguintes parâmetros: + `versionRequirement`: A restrição de versão semântica no estilo npm que identifica as versões compatíveis da dependência do componente. Você pode especificar uma única versão ou um intervalo de versões. Para obter mais informações sobre restrições de versão semântica, consulte a [calculadora npm semver](https://semver.npmjs.com/). + `dependencyType` (opcional): o tipo da dependência. Escolha uma das seguintes opções: + `SOFT`: o componente da função do Lambda não é reiniciado se a dependência muda de estado. + `HARD`: o componente da função do Lambda é reiniciado se a dependência muda de estado. O padrão é `HARD`. O exemplo a seguir especifica que essa função do Lambda depende de qualquer versão na primeira versão principal do componente do [gerenciador de fluxos](stream-manager-component.md). O componente da função do Lambda reinicia quando o gerenciador de fluxos é reiniciado ou atualizado. ``` { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } } ``` Você `lambda-function-component.json` pode conter um documento similar ao exemplo a seguir. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } } } } ``` 1. (Opcional) Configure os parâmetros da função do Lambda a serem usados para executar a função. Você pode configurar opções como variáveis de ambiente, fontes de eventos de mensagens, tempos limite e configurações de contêiner. Faça o seguinte: 1. Adicione o objeto de parâmetros do Lambda (`componentLambdaParameters`) à função do Lambda em `lambda-function-component.json`. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { } } } ``` 1. (Opcional) Especifique as fontes de eventos nas quais a função do Lambda se inscreve para receber mensagens de trabalho. Você pode especificar fontes de eventos para inscrever essa função em publish/subscribe mensagens locais e mensagens AWS IoT Core MQTT. A função do Lambda é chamada quando recebe uma mensagem de uma origem de evento. **nota** Para inscrever essa função em mensagens de outras funções ou componentes do Lambda, implante o [componente legado do roteador de assinatura](legacy-subscription-router-component.md) ao implantar esse componente da função do Lambda. Ao implantar o componente legado do roteador de assinatura, especifique as assinaturas que a função do Lambda usa. Faça o seguinte: 1. Adicione a lista de fontes de eventos (`eventSources`) aos parâmetros da função do Lambda. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ ] } } } ``` 1. Adicione cada fonte de evento à lista. Cada fonte do evento tem os seguintes parâmetros: + `topic`: o tópico para se inscrever para receber mensagens. + `type`: o tipo de origem do evento. Escolha uma das seguintes opções: + `PUB_SUB` – Assine mensagens locais de publicar/assinar. Se você usa o [Greengrass nucleus](greengrass-nucleus-component.md) v2.6.0 ou posterior e o [Lambda](lambda-manager-component.md) manager v2.2.5 ou posterior, você pode usar `+` curingas de tópico do MQTT (e) no ao especificar esse tipo. `#` `topic` + `IOT_CORE`— Assine as mensagens do AWS IoT Core MQTT. Você pode usar curingas de tópico do MQTT (`+`e`#`) no `topic` ao especificar esse tipo. O exemplo a seguir assina o AWS IoT Core MQTT em tópicos que correspondem ao filtro de `hello/world/+` tópicos. ``` { "topic": "hello/world/+", "type": "IOT_CORE" } ``` O arquivo `lambda-function-component.json` pode ser semelhante ao exemplo a seguir. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ { "topic": "hello/world/+", "type": "IOT_CORE" } ] } } } ``` 1. (Opcional) Especifique qualquer um dos seguintes parâmetros no objeto de parâmetros da função do Lambda: + `environmentVariables`: o mapa de variáveis de ambiente que estão disponíveis para a função do Lambda quando ela é executada. + `execArgs`: a lista de argumentos a serem passados para a função do Lambda quando ela é executada. + `inputPayloadEncodingType`: o tipo de carga útil compatível com a função do Lambda. Escolha uma das seguintes opções: + `json` + `binary` Padrão: `json` + `pinned`: se a função do Lambda está fixada ou não. O padrão é `true`. + Uma função Lambda fixa (ou de longa duração) AWS IoT Greengrass começa quando é iniciada e continua sendo executada em seu próprio contêiner. + Uma função do Lambda não fixada (ou sob demanda) só é iniciada quando recebe um item de trabalho e sai depois que permanece ociosa por um tempo de ociosidade máximo especificado. Se a função tiver vários itens de trabalho, o software AWS IoT Greengrass Core cria várias instâncias da função. Use `maxIdleTimeInSeconds` para definir o tempo máximo de inatividade para sua função. + `timeoutInSeconds`: o tempo máximo, em segundos, durante o qual uma função do Lambda pode ser executada. O padrão é 3 segundos. + `statusTimeoutInSeconds`: o intervalo em segundos no qual o componente de uma função do Lambda envia atualizações de status para o componente do gerenciador do Lambda. Esse parâmetro se aplica apenas a funções fixadas. O padrão é 60 segundos. + `maxIdleTimeInSeconds`— O tempo máximo em segundos que uma função Lambda não fixada pode ficar ociosa antes que o software AWS IoT Greengrass Core interrompa seu processo. O padrão é 60 segundos. + `maxInstancesCount`: o número máximo de instâncias que uma função do Lambda não fixada pode executar ao mesmo tempo. O padrão é 100 instâncias. + `maxQueueSize`: o tamanho máximo da fila de mensagens para o componente de função do Lambda. O software AWS IoT Greengrass Core armazena mensagens em uma fila FIFO (first-in-first-out) até poder executar a função Lambda para consumir cada mensagem. O valor padrão é de 1.000 mensagens. Você `lambda-function-component.json` pode conter um documento similar ao exemplo a seguir. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ { "topic": "hello/world/+", "type": "IOT_CORE" } ], "environmentVariables": { "LIMIT": "300" }, "execArgs": [ "-d" ], "inputPayloadEncodingType": "json", "pinned": true, "timeoutInSeconds": 120, "statusTimeoutInSeconds": 30, "maxIdleTimeInSeconds": 30, "maxInstancesCount": 50, "maxQueueSize": 500 } } } ``` 1. (Opcional) Defina as configurações do contêiner da função do Lambda. Por padrão, as funções Lambda são executadas em um ambiente de execução isolado dentro do software AWS IoT Greengrass Core. Você também pode optar por executar a função do Lambda como um processo sem nenhum isolamento. Se você executar a função do Lambda em um contêiner, você configura o tamanho da memória do contêiner e quais recursos do sistema estão disponíveis para a função do Lambda. Faça o seguinte: 1. Adicione o objeto de parâmetros de processo do Linux (`linuxProcessParams`) ao objeto de parâmetros Lambda em `lambda-function-component.json`. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ { "topic": "hello/world/+", "type": "IOT_CORE" } ], "environmentVariables": { "LIMIT": "300" }, "execArgs": [ "-d" ], "inputPayloadEncodingType": "json", "pinned": true, "timeoutInSeconds": 120, "statusTimeoutInSeconds": 30, "maxIdleTimeInSeconds": 30, "maxInstancesCount": 50, "maxQueueSize": 500, "linuxProcessParams": { } } } } ``` 1. (Opcional) Especifique se a função do Lambda é executada ou não em um contêiner. Adicione o parâmetro `isolationMode` ao objeto de parâmetros do processo e escolha entre as seguintes opções: + `GreengrassContainer`: a função do Lambda é executada em um contêiner. + `NoContainer`: a função do Lambda é executada como processo sem nenhum isolamento. O padrão é `GreengrassContainer`. 1. (Opcional) Se você executar a função do Lambda em um contêiner, poderá configurar a quantidade de memória e os recursos do sistema, como volumes e dispositivos, a serem disponibilizados para o contêiner. Faça o seguinte: 1. Adicione o objeto de parâmetros do contêiner (`containerParams`) ao objeto de parâmetros do processo Linux em `lambda-function-component.json`. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ { "topic": "hello/world/+", "type": "IOT_CORE" } ], "environmentVariables": { "LIMIT": "300" }, "execArgs": [ "-d" ], "inputPayloadEncodingType": "json", "pinned": true, "timeoutInSeconds": 120, "statusTimeoutInSeconds": 30, "maxIdleTimeInSeconds": 30, "maxInstancesCount": 50, "maxQueueSize": 500, "linuxProcessParams": { "containerParams": { } } } } } ``` 1. (Opcional) Adicione o parâmetro `memorySizeInKB` para especificar o tamanho da memória do contêiner. O padrão é 16.384 KB (16 MB). 1. (Opcional) Adicione o parâmetro `mountROSysfs` para especificar se o contêiner pode ou não ler informações da pasta `/sys` do dispositivo. O padrão é `false`. 1. (Opcional) Configure os volumes locais que a função do Lambda em contêiner pode acessar. Quando você define um volume, o software AWS IoT Greengrass Core monta os arquivos de origem no destino dentro do contêiner. Faça o seguinte: 1. Adicione a lista de volumes (`volumes`) aos parâmetros do contêiner. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ { "topic": "hello/world/+", "type": "IOT_CORE" } ], "environmentVariables": { "LIMIT": "300" }, "execArgs": [ "-d" ], "inputPayloadEncodingType": "json", "pinned": true, "timeoutInSeconds": 120, "statusTimeoutInSeconds": 30, "maxIdleTimeInSeconds": 30, "maxInstancesCount": 50, "maxQueueSize": 500, "linuxProcessParams": { "containerParams": { "memorySizeInKB": 32768, "mountROSysfs": true, "volumes": [ ] } } } } } ``` 1. Adicione cada volume à lista. Cada volume tem os seguintes parâmetros: + `sourcePath`: o caminho para a pasta de origem no dispositivo principal. + `destinationPath`: o caminho para a pasta de destino no contêiner. + `permission` (opcional): a permissão para acessar a pasta de origem a partir do contêiner. Escolha uma das seguintes opções: + `ro`: a função do Lambda tem acesso somente leitura à pasta de origem. + `rw`: a função do Lambda tem acesso de leitura e gravação à pasta de origem. O padrão é `ro`. + `addGroupOwner` (opcional): se deve ou não ser adicionado o grupo do sistema que executa o componente da função do Lambda como proprietário da pasta de origem. O padrão é `false`. Você `lambda-function-component.json` pode conter um documento similar ao exemplo a seguir. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ { "topic": "hello/world/+", "type": "IOT_CORE" } ], "environmentVariables": { "LIMIT": "300" }, "execArgs": [ "-d" ], "inputPayloadEncodingType": "json", "pinned": true, "timeoutInSeconds": 120, "statusTimeoutInSeconds": 30, "maxIdleTimeInSeconds": 30, "maxInstancesCount": 50, "maxQueueSize": 500, "linuxProcessParams": { "containerParams": { "memorySizeInKB": 32768, "mountROSysfs": true, "volumes": [ { "sourcePath": "/var/data/src", "destinationPath": "/var/data/dest", "permission": "rw", "addGroupOwner": true } ] } } } } } ``` 1. (Opcional) Configure os dispositivos do sistema local que a função do Lambda em contêiner pode acessar. Faça o seguinte: 1. Adicione a lista de dispositivos do sistema (`devices`) aos parâmetros do contêiner. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ { "topic": "hello/world/+", "type": "IOT_CORE" } ], "environmentVariables": { "LIMIT": "300" }, "execArgs": [ "-d" ], "inputPayloadEncodingType": "json", "pinned": true, "timeoutInSeconds": 120, "statusTimeoutInSeconds": 30, "maxIdleTimeInSeconds": 30, "maxInstancesCount": 50, "maxQueueSize": 500, "linuxProcessParams": { "containerParams": { "memorySizeInKB": 32768, "mountROSysfs": true, "volumes": [ { "sourcePath": "/var/data/src", "destinationPath": "/var/data/dest", "permission": "rw", "addGroupOwner": true } ], "devices": [ ] } } } } } ``` 1. Adicione cada dispositivo do sistema à lista. Cada dispositivo do sistema tem os seguintes parâmetros: + `path`: o caminho para o dispositivo do sistema. + `permission` (opcional): a permissão para acessar o dispositivo do sistema a partir do contêiner. Escolha uma das seguintes opções: + `ro`: a função do Lambda tem acesso somente leitura ao dispositivo do sistema. + `rw`: a função do Lambda tem acesso de leitura e gravação ao dispositivo do sistema. O padrão é `ro`. + `addGroupOwner` (opcional): se deve ou não ser adicionado o grupo do sistema que executa o componente da função do Lambda como proprietário do dispositivo do sistema. O padrão é `false`. Você `lambda-function-component.json` pode conter um documento similar ao exemplo a seguir. ``` { "lambdaFunction": { "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "componentPlatforms": [ { "name": "Linux x86", "attributes": { "os": "linux", "architecture": "x86" } } ], "componentDependencies": { "aws.greengrass.StreamManager": { "versionRequirement": "^1.0.0", "dependencyType": "HARD" } }, "componentLambdaParameters": { "eventSources": [ { "topic": "hello/world/+", "type": "IOT_CORE" } ], "environmentVariables": { "LIMIT": "300" }, "execArgs": [ "-d" ], "inputPayloadEncodingType": "json", "pinned": true, "timeoutInSeconds": 120, "statusTimeoutInSeconds": 30, "maxIdleTimeInSeconds": 30, "maxInstancesCount": 50, "maxQueueSize": 500, "linuxProcessParams": { "containerParams": { "memorySizeInKB": 32768, "mountROSysfs": true, "volumes": [ { "sourcePath": "/var/data/src", "destinationPath": "/var/data/dest", "permission": "rw", "addGroupOwner": true } ], "devices": [ { "path": "/dev/sda3", "permission": "rw", "addGroupOwner": true } ] } } } } } ``` 1. (Opcional) Adicione tags (`tags`) ao componente. Para obter mais informações, consulte [Marque seus AWS IoT Greengrass Version 2 recursos](tag-resources.md). ## Etapa 2: criar o componente da função do Lambda 1. Execute o seguinte comando para criar o componente da função do Lambda a partir de `lambda-function-component.json`. ``` aws greengrassv2 create-component-version --cli-input-json file://lambda-function-component.json ``` Se a solicitação for bem-sucedida, a resposta será semelhante ao exemplo a seguir. ``` { "arn": "arn:aws:greengrass:region:123456789012:components:com.example.HelloWorldLambda:versions:1.0.0", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "creationTimestamp": "Mon Dec 15 20:56:34 UTC 2020", "status": { "componentState": "REQUESTED", "message": "NONE", "errors": {} } } ``` Copie o `arn` da saída para verificar o estado do componente na próxima etapa. 1. Quando você cria um componente, seu estado é`REQUESTED`. Em seguida, AWS IoT Greengrass valida se o componente é implantável. Você pode executar o comando a seguir para consultar o status do componente e verificar se ele é implantável. Substitua `arn` pelo ARN da etapa anterior. ``` aws greengrassv2 describe-component \ --arn "arn:aws:greengrass:region:account-id:components:com.example.HelloWorldLambda:versions:1.0.0" ``` Se o componente for validado, a resposta indicará que o estado do componente é`DEPLOYABLE`. ``` { "arn": "arn:aws:greengrass:region:account-id:components:com.example.HelloWorldLambda:versions:1.0.0", "componentName": "com.example.HelloWorldLambda", "componentVersion": "1.0.0", "creationTimestamp": "2020-12-15T20:56:34.376000-08:00", "publisher": "AWS Lambda", "status": { "componentState": "DEPLOYABLE", "message": "NONE", "errors": {} }, "platforms": [ { "name": "Linux x86", "attributes": { "architecture": "x86", "os": "linux" } } ] } ``` Depois que o componente estiver`DEPLOYABLE`, você pode implantar a função do Lambda em seus dispositivos principais. Para obter mais informações, consulte [Implemente AWS IoT Greengrass componentes em dispositivos](manage-deployments.md).