Importar uma função do Lambda como componente (AWS CLI) - AWS IoT Greengrass
Etapa 1: definir a configuração da função do LambdaEtapa 2: criar o componente da função do Lambda

Importar uma função do Lambda como componente (AWS CLI)

Use a operação CreateComponentVersion para criar componentes a partir das funções do Lambda. Ao chamar essa operação, especifique lambdaFunction para importar uma função do Lambda.

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

  2. (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 do Lambda.

    {
  "lambdaFunction": {
    "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
    "componentName": "com.example.HelloWorldLambda"
  }
}

  3. (Opcional) Especifique a versão (componentVersion) do componente. Caso o parâmetro seja omitido, o componente é AWS IoT Greengrass criado com a versão da função do Lambda como 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.

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

    {
  "lambdaFunction": {
    "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1",
    "componentName": "com.example.HelloWorldLambda",
    "componentVersion": "1.0.0"
  }
}

  4. (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 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": [
    
    ]
  }
}

    2. 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"
        }
      }
    ]
  }
}

  5. (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 do Lambda que você criou para ser executada no 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 fluxos. Defina esses componentes como dependências permanentes para que seu componente da função do Lambda seja reiniciado se a dependência mudar de estado. Para ter mais informações, consulte Importar funções do Lambda no V1.

    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": {
      
    }
  }
}

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

      • 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. 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"
      }
    }
  }
}

  6. (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": {
    
    }
  }
}

    2. (Opcional) Especifique as fontes de eventos nas quais a função do Lambda se inscreve para receber mensagens de trabalho. Você pode especificar origens de eventos para inscrever essa função em mensagens locais de publicação/assinatura e mensagens MQTT do AWS IoT Core. 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 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": [
      
      ]
    }
  }
}

      2. 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 v2.6.0 ou posterior e o Lambda manager v2.2.5 ou posterior, você pode usar + curingas de tópico do MQTT (e) no ao especificar esse tipo. # topic

          • IOT_CORE: assinar mensagens MQTT do AWS IoT Core.

            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"
        }
      ]
    }
  }
}

    3. (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 do Lambda fixada (ou de longa duração) começa quando o AWS IoT Greengrass é iniciado 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 criará 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 do Lambda não fixada pode permanecer 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 do AWS IoT Greengrass Core armazena mensagens em uma fila FIFO (primeiro a entrar, primeiro a sair) até que possa executar a função do Lambda para ingerir 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
    }
  }
}

    4. (Opcional) Defina as configurações do contêiner da função do Lambda. Por padrão, as funções do Lambda são executadas em um ambiente de runtime 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": {
      
      }
    }
  }
}

      2. (Opcional) Especifique se a função do Lambda é executada ou não em um contêiner. Adicione o isolationMode parâmetro 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.

      3. (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 emlambda-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": {
        
        }
      }
    }
  }
}

        2. (Opcional) Adicione o memorySizeInKB parâmetro para especificar o tamanho da memória do contêiner. O padrão é 16.384 KB (16 MB).

        3. (Opcional) Adicione o mountROSysfs parâmetro para especificar se o contêiner pode ou não ler informações da /sys pasta do dispositivo. O padrão é false.

        4. (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": [
          
          ]
        }
      }
    }
  }
}

          2. 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
            }
          ]
        }
      }
    }
  }
}

        5. (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": [
          
          ]
        }
      }
    }
  }
}

          2. 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
            }
          ]
        }
      }
    }
  }
}

  7. (Opcional) Adicione tags (tags) ao componente. Para ter mais informações, consulte Marcar com tag os recursos do AWS IoT Greengrass Version 2.

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.

  2. 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 estiverDEPLOYABLE, você pode implantar a função do Lambda em seus dispositivos principais. Para ter mais informações, consulte Implantar componentes AWS IoT Greengrass em dispositivos.