Importar una función Lambda como componente () AWS CLI - AWS IoT Greengrass
Paso 1: Definir la configuración de la función LambdaPaso 2: Crear el componente de la función Lambda

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Importar una función Lambda como componente () AWS CLI

Utilice la CreateComponentVersionoperación para crear componentes a partir de funciones Lambda. Cuando llame a esta operación, especifique lambdaFunction la importación de una función Lambda.

Paso 1: Definir la configuración de la función Lambda

  1. Cree un archivo llamado ylambda-function-component.json, a continuación, copie el siguiente objeto JSON en el archivo. Sustituya el lambdaArn por el ARN de la función Lambda que se va a importar.

    {
  "lambdaFunction": {
    "lambdaArn": "arn:aws:lambda:region:account-id:function:HelloWorld:1"
  }
}
    importante

    Debe especificar un ARN que incluya la versión de la función que se va a importar. No puede utilizar alias de versión como $LATEST.

  2. (Opcional) Especifique el nombre (componentName) del componente. Si omite este parámetro, AWS IoT Greengrass crea el componente con el nombre de la función Lambda.

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

  3. (Opcional) Especifique la versión (componentVersion) del componente. Si omite este parámetro, AWS IoT Greengrass crea el componente con la versión de la función Lambda como una versión semántica válida. Por ejemplo, si la versión de la función es 3, la versión del componente se convierte en 3.0.0.

    nota

    Cada versión de componente que cargue debe ser única. Asegúrese de cargar la versión del componente correcta, ya que no podrá editarla después de cargarla.

    AWS IoT Greengrassusa versiones semánticas para los componentes. Las versiones semánticas siguen un sistema de números de principal.secundario.parche. Por ejemplo, la versión 1.0.0 representa la primera versión principal de un componente. Para obtener más información, consulte la especificación de la versión semántica.

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

  4. (Opcional) Especifique las plataformas compatibles con esta función Lambda. Cada plataforma contiene un mapa de atributos que la identifican. Todos los dispositivos principales tienen atributos de sistema operativo (os) y arquitectura (architecture). El software AWS IoT Greengrass principal puede añadir otros atributos de plataforma. También puede especificar atributos de plataforma personalizados al implementar el componente núcleo de Greengrass en un dispositivo principal. Haga lo siguiente:

    1. Añada una lista de plataformas (componentPlatforms) a la función Lambda en. 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. Añada cada plataforma compatible a la lista. Cada plataforma tiene un amigable name para identificarla y un mapa de atributos. El siguiente ejemplo especifica que esta función es compatible con dispositivos x86 que ejecutan Linux.

      {
  "name": "Linux x86",
  "attributes": {
    "os": "linux",
    "architecture": "x86"
  }
}

      lambda-function-component.jsonPuede contener un documento similar al siguiente ejemplo.

      {
  "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 las dependencias de los componentes de la función Lambda. Al implementar el componente de la función Lambda, la implementación incluye estas dependencias para que la función se ejecute.

    importante

    Para importar una función Lambda que haya creado para ejecutarse en la AWS IoT Greengrass V1, debe definir las dependencias de los componentes individuales para las funciones que utiliza la función, como los secretos, las sombras locales y el administrador de flujos. Defina estos componentes como dependencias rígidas para que el componente de la función Lambda se reinicie si la dependencia cambia de estado. Para obtener más información, consulte Importación de funciones Lambda V1.

    Haga lo siguiente:

    1. Añada un mapa de las dependencias de los componentes (componentDependencies) a la función Lambda en. 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. Agregue cada dependencia de los componentes al mapa. Especifique el nombre del componente como clave y especifique un objeto con los siguientes parámetros:

      • versionRequirement— La restricción de versión semántica de estilo npm que identifica las versiones compatibles de la dependencia del componente. Puede especificar una versión única o un rango de versiones. Para obtener más información sobre las restricciones de las versiones semánticas, consulte la calculadora npm semver.

      • dependencyType— (Opcional) El tipo de dependencia. Elija una de las siguientes opciones:

        • SOFT— El componente de la función Lambda no se reinicia si la dependencia cambia de estado.

        • HARD— El componente de la función Lambda se reinicia si la dependencia cambia de estado.

        El valor predeterminado es HARD.

      El siguiente ejemplo especifica que esta función Lambda depende de cualquier versión de la primera versión principal del componente stream manager. El componente de la función Lambda se reinicia cuando el administrador de transmisiones se reinicia o se actualiza.

      {
  "aws.greengrass.StreamManager": {
    "versionRequirement": "^1.0.0",
    "dependencyType": "HARD"
  }
}

      lambda-function-component.jsonPuede contener un documento similar al siguiente ejemplo.

      {
  "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 los parámetros de la función Lambda que se utilizarán para ejecutar la función. Puede configurar opciones como las variables de entorno, las fuentes de eventos de los mensajes, los tiempos de espera y la configuración del contenedor. Haga lo siguiente:

    1. Agregue el objeto de parámetros de Lambda (componentLambdaParameters) a la función Lambda en. 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 las fuentes de eventos a las que se suscribe la función Lambda para los mensajes de trabajo. Puede especificar las fuentes de eventos para suscribir esta función a los mensajes locales de publicación/suscripción y a los mensajes MQTT. AWS IoT Core Se llama a la función Lambda cuando recibe un mensaje de una fuente de eventos.

      nota

      Para suscribir esta función a los mensajes de otras funciones o componentes de Lambda, implemente el componente de enrutador de suscripciones heredado al implementar este componente de función de Lambda. Al implementar el componente del router de suscripciones heredado, especifique las suscripciones que utiliza la función Lambda.

      Haga lo siguiente:

      1. Añada la lista de fuentes de eventos (eventSources) a los parámetros de la función 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. Añada cada fuente de eventos a la lista. Cada fuente de eventos tiene los siguientes parámetros:

        • topic— El tema al que suscribirse a los mensajes.

        • type— El tipo de fuente del evento. Puede elegir entre las siguientes opciones:

          • PUB_SUB — Suscribirse a mensajes locales de publicación/suscripción.

            Si usa Greengrass nucleus v2.6.0 o posterior y Lambda manager v2.2.5 o posterior, puede usar los comodines (+y) de los temas MQTT cuando especifique este tipo. # topic

          • IOT_CORE: Suscribirse a mensajes MQTT de AWS IoT Core.

            Al especificar este tipo, puede utilizar los caracteres comodín de los temas MQTT (+y). # topic

          En el siguiente ejemplo, se suscribe a AWS IoT Core MQTT los temas que coincidan con el filtro de temas. hello/world/+

          {
  "topic": "hello/world/+",
  "type": "IOT_CORE"
}

          El tuyo lambda-function-component.json podría tener un aspecto similar al del siguiente ejemplo.

          {
  "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 cualquiera de los siguientes parámetros en el objeto de parámetros de la función Lambda:

      • environmentVariables— El mapa de variables de entorno que están disponibles para la función Lambda cuando se ejecuta.

      • execArgs— La lista de argumentos que se van a pasar a la función Lambda cuando se ejecuta.

      • inputPayloadEncodingType— El tipo de carga útil que admite la función Lambda. Puede elegir entre las siguientes opciones:

        • json

        • binary

        Valor predeterminado: json

      • pinned— Si la función Lambda está fija o no. El valor predeterminado es true.

        • Una función Lambda anclada (o de larga duración) se inicia cuando se AWS IoT Greengrass inicia y sigue ejecutándose en su propio contenedor.

        • Una función Lambda no anclada (o bajo demanda) se inicia solo cuando recibe un elemento de trabajo y se cierra después de permanecer inactiva durante un tiempo de inactividad máximo especificado. Si la función tiene varios elementos de trabajo, el software de AWS IoT Greengrass Core crea varias instancias de la función.

        Se utiliza maxIdleTimeInSeconds para establecer el tiempo máximo de inactividad de la función.

      • timeoutInSeconds— El tiempo máximo en segundos que la función Lambda puede ejecutarse antes de que se agote el tiempo de espera. El valor predeterminado es de 3 segundos.

      • statusTimeoutInSeconds— El intervalo en segundos en el que el componente de la función Lambda envía las actualizaciones de estado al componente del administrador de Lambda. Este parámetro solo se aplica a las funciones ancladas. El valor predeterminado es de 60 segundos.

      • maxIdleTimeInSeconds— El tiempo máximo en segundos que una función Lambda no anclada puede permanecer inactiva antes de que el software AWS IoT Greengrass Core detenga su proceso. El valor predeterminado es de 60 segundos.

      • maxInstancesCount— El número máximo de instancias que una función Lambda no anclada puede ejecutar al mismo tiempo. El valor predeterminado es 100 instancias.

      • maxQueueSize— El tamaño máximo de la cola de mensajes para el componente de la función Lambda. El software AWS IoT Greengrass Core almacena los mensajes en una cola FIFO (first-in-first-out) hasta que pueda ejecutar la función Lambda para consumir cada mensaje. El valor predeterminado es 1000 mensajes.

      lambda-function-component.jsonPuede contener un documento similar al siguiente ejemplo.

      {
  "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) Configure los ajustes del contenedor para la función Lambda. De forma predeterminada, las funciones Lambda se ejecutan en un entorno de ejecución aislado dentro del software AWS IoT Greengrass Core. También puede optar por ejecutar la función Lambda como un proceso sin ningún tipo de aislamiento. Si ejecuta la función Lambda en un contenedor, configura el tamaño de memoria del contenedor y los recursos del sistema disponibles para la función Lambda. Haga lo siguiente:

      1. Agregue el objeto de parámetros de proceso de Linux (linuxProcessParams) al objeto de parámetros de Lambda en. 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 si la función Lambda se ejecuta o no en un contenedor. Añada el isolationMode parámetro al objeto de parámetros del proceso y elija una de las siguientes opciones:

        • GreengrassContainer— La función Lambda se ejecuta en un contenedor.

        • NoContainer— La función Lambda se ejecuta como un proceso sin ningún tipo de aislamiento.

        El valor predeterminado es GreengrassContainer.

      3. (Opcional) Si ejecuta la función Lambda en un contenedor, puede configurar la cantidad de memoria y los recursos del sistema, como los volúmenes y los dispositivos, que se pondrán a disposición del contenedor. Haga lo siguiente:

        1. Agregue el objeto de parámetros del contenedor (containerParams) al objeto de parámetros de proceso de Linux enlambda-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) Agregue el memorySizeInKB parámetro para especificar el tamaño de memoria del contenedor. El valor predeterminado es 16.384 KB (16 MB).

        3. (Opcional) Agregue el mountROSysfs parámetro para especificar si el contenedor puede leer o no la información de la /sys carpeta del dispositivo. El valor predeterminado es false.

        4. (Opcional) Configure los volúmenes locales a los que puede acceder la función Lambda en contenedores. Cuando define un volumen, el software de AWS IoT Greengrass Core monta los archivos de origen en el destino dentro del contenedor. Haga lo siguiente:

          1. Añada la lista de volúmenes (volumes) a los parámetros del contenedor.

            {
  "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. Añada cada volumen a la lista. Cada volumen tiene los siguientes parámetros:

            • sourcePath— La ruta a la carpeta de origen del dispositivo principal.

            • destinationPath— La ruta a la carpeta de destino del contenedor.

            • permission— (Opcional) El permiso para acceder a la carpeta de origen desde el contenedor. Puede elegir entre las siguientes opciones:

              • ro— La función Lambda tiene acceso de solo lectura a la carpeta de origen.

              • rw— La función Lambda tiene acceso de lectura y escritura a la carpeta de origen.

              El valor predeterminado es ro.

            • addGroupOwner— (Opcional) Si se debe añadir o no el grupo de sistemas que ejecuta el componente de la función Lambda como propietario de la carpeta de origen. El valor predeterminado es false.

            lambda-function-component.jsonPuede contener un documento similar al siguiente ejemplo.

            {
  "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 los dispositivos del sistema local a los que puede acceder la función Lambda en contenedor. Haga lo siguiente:

          1. Añada la lista de dispositivos del sistema (devices) a los parámetros del contenedor.

            {
  "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. Añada cada dispositivo del sistema a la lista. Cada dispositivo del sistema tiene los siguientes parámetros:

            • path— La ruta al dispositivo del sistema en el dispositivo principal.

            • permission— (Opcional) El permiso para acceder al dispositivo del sistema desde el contenedor. Puede elegir entre las siguientes opciones:

              • ro— La función Lambda tiene acceso de solo lectura al dispositivo del sistema.

              • rw— La función Lambda tiene acceso de lectura y escritura al dispositivo del sistema.

              El valor predeterminado es ro.

            • addGroupOwner— (Opcional) Si se debe añadir o no el grupo de sistemas que ejecuta el componente de la función Lambda como propietario del dispositivo del sistema. El valor predeterminado es false.

          lambda-function-component.jsonPuede contener un documento similar al siguiente ejemplo.

          {
  "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) Añada etiquetas (tags) para el componente. Para obtener más información, consulte Etiquetar los recursos de AWS IoT Greengrass Version 2.

Paso 2: Crear el componente de la función Lambda

  1. Ejecute el siguiente comando para crear el componente de la función Lambda desde. lambda-function-component.json

    aws greengrassv2 create-component-version --cli-input-json file://lambda-function-component.json

    La respuesta es similar a la del siguiente ejemplo si la solicitud se realiza correctamente.

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

    arnCopie el elemento del resultado para comprobar el estado del componente en el siguiente paso.

  2. Al crear un componente, su estado esREQUESTED. A continuación, AWS IoT Greengrass valida que el componente sea desplegable. Puede ejecutar el siguiente comando para consultar el estado del componente y comprobar que el componente se puede implementar. Sustituya el arn por el ARN del paso anterior.

    aws greengrassv2 describe-component \
  --arn "arn:aws:greengrass:region:account-id:components:com.example.HelloWorldLambda:versions:1.0.0"

    Si el componente se valida, la respuesta indica que el estado del componente es. 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"
      }
    }
  ]
}

    Una vez creado el componenteDEPLOYABLE, puede implementar la función Lambda en sus dispositivos principales. Para obtener más información, consulte Implemente AWS IoT Greengrass componentes en los dispositivos.