Importa una funzione Lambda come componente () AWS CLI - AWS IoT Greengrass
Fase 1: Definire la configurazione della funzione LambdaFase 2: Creare il componente della funzione Lambda

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Importa una funzione Lambda come componente () AWS CLI

Usa l'CreateComponentVersionoperazione per creare componenti dalle funzioni Lambda. Quando chiamate questa operazione, specificate di lambdaFunction importare una funzione Lambda.

Fase 1: Definire la configurazione della funzione Lambda

  1. Create un file chiamatolambda-function-component.json, quindi copiate il seguente oggetto JSON nel file. Sostituisci lambdaArn con l'ARN della funzione Lambda da importare.

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

    È necessario specificare un ARN che includa la versione della funzione da importare. Non è possibile utilizzare alias di versione come $LATEST.

  2. (Facoltativo) Specificate il nome (componentName) del componente. Se ometti questo parametro, AWS IoT Greengrass crea il componente con il nome della funzione Lambda.

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

  3. (Facoltativo) Specificate la versione (componentVersion) per il componente. Se ometti questo parametro, AWS IoT Greengrass crea il componente con la versione della funzione Lambda come versione semantica valida. Ad esempio, se la versione della funzione è 3, la versione del componente diventa 3.0.0.

    Nota

    Ogni versione del componente che carichi deve essere unica. Assicurati di caricare la versione corretta del componente, perché non puoi modificarla dopo averla caricata.

    AWS IoT Greengrassutilizza versioni semantiche per i componenti. Le versioni semantiche seguono una delle principali. minore. sistema di numerazione delle patch. Ad esempio, la versione 1.0.0 rappresenta la prima release principale di un componente. Per ulteriori informazioni, consultate la specifica della versione semantica.

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

  4. (Facoltativo) Specificate le piattaforme supportate da questa funzione Lambda. Ogni piattaforma contiene una mappa di attributi che identificano una piattaforma. Tutti i dispositivi principali hanno attributi per il sistema operativo (os) e l'architettura (architecture). Il software AWS IoT Greengrass Core può aggiungere altri attributi della piattaforma. È inoltre possibile specificare attributi di piattaforma personalizzati quando si distribuisce il componente Greengrass nucleus su un dispositivo principale. Esegui questa operazione:

    1. Aggiungi un elenco di piattaforme (componentPlatforms) alla funzione Lambda in. 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. Aggiungi ogni piattaforma supportata all'elenco. Ogni piattaforma dispone di un'interfaccia intuitiva name per identificarla e di una mappa di attributi. L'esempio seguente specifica che questa funzione supporta i dispositivi x86 che eseguono Linux.

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

      È lambda-function-component.json possibile che contenga un documento simile all'esempio seguente.

      {
  "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. (Facoltativo) Specificate le dipendenze dei componenti per la funzione Lambda. Quando si distribuisce il componente della funzione Lambda, la distribuzione include queste dipendenze per l'esecuzione della funzione.

    Importante

    Per importare una funzione Lambda creata per l'esecuzione su AWS IoT Greengrass V1, è necessario definire le dipendenze dei singoli componenti per le funzionalità utilizzate dalla funzione, come segreti, ombre locali e gestore di flussi. Definisci questi componenti come dipendenze rigide in modo che il componente della funzione Lambda si riavvii se la dipendenza cambia stato. Per ulteriori informazioni, consulta Importa funzioni Lambda V1.

    Esegui questa operazione:

    1. Aggiungi una mappa delle dipendenze dei componenti (componentDependencies) alla funzione Lambda in. 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. Aggiungi la dipendenza di ogni componente alla mappa. Specificate il nome del componente come chiave e specificate un oggetto con i seguenti parametri:

      • versionRequirement— Il vincolo di versione semantica in stile npm che identifica le versioni compatibili della dipendenza del componente. È possibile specificare una singola versione o un intervallo di versioni. Per ulteriori informazioni sui vincoli di versione semantica, consulta il calcolatore semver npm.

      • dependencyType— (Facoltativo) Il tipo di dipendenza. Scegli tra le seguenti opzioni:

        • SOFT— Il componente della funzione Lambda non si riavvia se la dipendenza cambia stato.

        • HARD— Il componente della funzione Lambda si riavvia se la dipendenza cambia stato.

        Il valore predefinito è HARD.

      L'esempio seguente specifica che questa funzione Lambda dipende da qualsiasi versione della prima versione principale del componente stream manager. Il componente della funzione Lambda si riavvia quando lo stream manager si riavvia o si aggiorna.

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

      È lambda-function-component.json possibile che contenga un documento simile all'esempio seguente.

      {
  "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. (Facoltativo) Configura i parametri della funzione Lambda da utilizzare per eseguire la funzione. È possibile configurare opzioni quali variabili di ambiente, origini degli eventi dei messaggi, timeout e impostazioni del contenitore. Esegui questa operazione:

    1. Aggiungi l'oggetto dei parametri Lambda (componentLambdaParameters) alla funzione Lambda in. 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. (Facoltativo) Specificate le fonti di eventi a cui la funzione Lambda si iscrive per i messaggi di lavoro. È possibile specificare le fonti di eventi per sottoscrivere questa funzione ai messaggi di pubblicazione/sottoscrizione locali e ai messaggi MQTT. AWS IoT Core La funzione Lambda viene chiamata quando riceve un messaggio da un'origine di eventi.

      Nota

      Per sottoscrivere questa funzione ai messaggi di altre funzioni o componenti Lambda, distribuisci il componente precedente del router di sottoscrizione quando distribuisci questo componente della funzione Lambda. Quando distribuisci il componente legacy del router di sottoscrizione, specifica gli abbonamenti utilizzati dalla funzione Lambda.

      Esegui questa operazione:

      1. Aggiungi l'elenco delle fonti di eventi (eventSources) ai parametri della funzione 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. Aggiungi ogni fonte di eventi all'elenco. Ogni fonte di eventi ha i seguenti parametri:

        • topic— L'argomento a cui sottoscrivere i messaggi.

        • type— Il tipo di origine dell'evento. Seleziona una delle opzioni seguenti:

          • PUB_SUB: iscriviti ai messaggi di pubblicazione/sottoscrizione locali.

            Se si utilizza Greengrass nucleus v2.6.0 o versione successiva e Lambda manager v2.2.5 o versione successiva, è possibile utilizzare i caratteri jolly + (and) dell'argomento MQTT quando si specifica questo tipo. # topic

          • IOT_CORE: sottoscrivi i messaggi MQTT di AWS IoT Core.

            È possibile utilizzare i caratteri jolly (e) dell'argomento MQTT quando si specifica questo tipo. + # topic

          L'esempio seguente sottoscrive AWS IoT Core MQTT su argomenti che corrispondono al filtro degli argomenti. hello/world/+

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

          Il tuo lambda-function-component.json potrebbe essere simile all'esempio seguente.

          {
  "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. (Facoltativo) Specificate uno dei seguenti parametri nell'oggetto parametri della funzione Lambda:

      • environmentVariables— La mappa delle variabili di ambiente disponibili per la funzione Lambda durante l'esecuzione.

      • execArgs— L'elenco di argomenti da passare alla funzione Lambda durante l'esecuzione.

      • inputPayloadEncodingType— Il tipo di payload supportato dalla funzione Lambda. Seleziona una delle opzioni seguenti:

        • json

        • binary

        Impostazione predefinita: json

      • pinned— Se la funzione Lambda è bloccata o meno. Il valore predefinito è true.

        • Una funzione Lambda bloccata (o di lunga durata) si AWS IoT Greengrass avvia all'avvio e continua a funzionare nel proprio contenitore.

        • Una funzione Lambda non bloccata (o su richiesta) si avvia solo quando riceve un elemento di lavoro e esce dopo che è rimasto inattivo per un periodo di inattività massimo specificato. Se la funzione ha più elementi di lavoro, il software AWS IoT Greengrass Core crea più istanze della funzione.

        maxIdleTimeInSecondsDa utilizzare per impostare il tempo di inattività massimo per la funzione.

      • timeoutInSeconds— Il periodo di tempo massimo, in secondi, che la funzione Lambda può eseguire prima del timeout. Il valore predefinito è 3 secondi.

      • statusTimeoutInSeconds— L'intervallo in secondi con cui il componente della funzione Lambda invia gli aggiornamenti di stato al componente Lambda manager. Questo parametro si applica solo alle funzioni bloccate. Il valore predefinito è 60 secondi.

      • maxIdleTimeInSeconds— Il tempo massimo, in secondi, in cui una funzione Lambda non bloccata può rimanere inattiva prima che il software AWS IoT Greengrass Core interrompa il processo. Il valore predefinito è 60 secondi.

      • maxInstancesCount— Il numero massimo di istanze che una funzione Lambda non bloccata può eseguire contemporaneamente. L'impostazione predefinita è 100 istanze.

      • maxQueueSize— La dimensione massima della coda di messaggi per il componente della funzione Lambda. Il software AWS IoT Greengrass Core archivia i messaggi in una coda FIFO (first-in-first-out) fino a quando non può eseguire la funzione Lambda per consumare ogni messaggio. L'impostazione predefinita è 1.000 messaggi.

      È lambda-function-component.json possibile che contenga un documento simile al seguente esempio.

      {
  "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. (Facoltativo) Configura le impostazioni del contenitore per la funzione Lambda. Per impostazione predefinita, le funzioni Lambda vengono eseguite in un ambiente di runtime isolato all'interno del software AWS IoT Greengrass Core. Puoi anche scegliere di eseguire la funzione Lambda come processo senza alcun isolamento. Se si esegue la funzione Lambda in un contenitore, si configura la dimensione della memoria del contenitore e le risorse di sistema disponibili per la funzione Lambda. Esegui questa operazione:

      1. Aggiungi l'oggetto dei parametri del processo Linux (linuxProcessParams) all'oggetto parametri Lambda in. 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. (Facoltativo) Specificate se la funzione Lambda viene eseguita o meno in un contenitore. Aggiungete il isolationMode parametro all'oggetto dei parametri di processo e scegliete una delle seguenti opzioni:

        • GreengrassContainer— La funzione Lambda viene eseguita in un contenitore.

        • NoContainer— La funzione Lambda viene eseguita come processo senza alcun isolamento.

        Il valore predefinito è GreengrassContainer.

      3. (Facoltativo) Se si esegue la funzione Lambda in un contenitore, è possibile configurare la quantità di memoria e le risorse di sistema, come volumi e dispositivi, da rendere disponibili al contenitore. Esegui questa operazione:

        1. Aggiungete l'oggetto dei parametri del contenitore (containerParams) all'oggetto dei parametri del processo Linux inlambda-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. (Facoltativo) Aggiungete il memorySizeInKB parametro per specificare la dimensione della memoria del contenitore. L'impostazione predefinita è 16.384 KB (16 MB).

        3. (Facoltativo) Aggiungi il mountROSysfs parametro per specificare se il contenitore può leggere o meno le informazioni dalla cartella del /sys dispositivo. Il valore predefinito è false.

        4. (Facoltativo) Configura i volumi locali a cui può accedere la funzione Lambda containerizzata. Quando definisci un volume, il software AWS IoT Greengrass Core monta i file di origine sulla destinazione all'interno del container. Esegui questa operazione:

          1. Aggiungi l'elenco dei volumi (volumes) ai parametri del contenitore.

            {
  "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. Aggiungi ogni volume all'elenco. Ogni volume presenta i seguenti parametri:

            • sourcePath— Il percorso della cartella di origine sul dispositivo principale.

            • destinationPath— Il percorso della cartella di destinazione nel contenitore.

            • permission— (Facoltativo) L'autorizzazione ad accedere alla cartella di origine dal contenitore. Seleziona una delle opzioni seguenti:

              • ro— La funzione Lambda ha accesso in sola lettura alla cartella di origine.

              • rw— La funzione Lambda ha accesso in lettura/scrittura alla cartella di origine.

              Il valore predefinito è ro.

            • addGroupOwner— (Facoltativo) Se aggiungere o meno il gruppo di sistema che esegue il componente della funzione Lambda come proprietario della cartella di origine. Il valore predefinito è false.

            È lambda-function-component.json possibile che contenga un documento simile al seguente esempio.

            {
  "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. (Facoltativo) Configura i dispositivi del sistema locale a cui può accedere la funzione Lambda containerizzata. Esegui questa operazione:

          1. Aggiungi l'elenco dei dispositivi di sistema (devices) ai parametri del contenitore.

            {
  "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. Aggiungi ogni dispositivo di sistema all'elenco. Ogni dispositivo di sistema presenta i seguenti parametri:

            • path— Il percorso verso il dispositivo di sistema sul dispositivo principale.

            • permission— (Facoltativo) L'autorizzazione ad accedere al dispositivo di sistema dal contenitore. Seleziona una delle opzioni seguenti:

              • ro— La funzione Lambda ha accesso in sola lettura al dispositivo di sistema.

              • rw— La funzione Lambda ha accesso in lettura/scrittura al dispositivo di sistema.

              Il valore predefinito è ro.

            • addGroupOwner— (Facoltativo) Se aggiungere o meno il gruppo di sistema che esegue il componente della funzione Lambda come proprietario del dispositivo di sistema. Il valore predefinito è false.

          Il tuo lambda-function-component.json potrebbe contenere un documento simile al seguente esempio.

          {
  "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. (Facoltativo) Aggiungi tag (tags) per il componente. Per ulteriori informazioni, consulta Tagging delle risorse AWS IoT Greengrass Version 2..

Fase 2: Creare il componente della funzione Lambda

  1. Esegui il comando seguente per creare il componente della funzione Lambda da. lambda-function-component.json

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

    La risposta è simile all'esempio seguente se la richiesta ha esito positivo.

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

    Copia il file arn dall'output per verificare lo stato del componente nel passaggio successivo.

  2. Quando si crea un componente, il suo stato èREQUESTED. Quindi, AWS IoT Greengrass verifica che il componente sia implementabile. È possibile eseguire il comando seguente per interrogare lo stato del componente e verificare che il componente sia distribuibile. Sostituisci arn con l'ARN del passaggio precedente.

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

    Se il componente viene convalidato, la risposta indica che lo stato del 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"
      }
    }
  ]
}

    Dopo aver installato il componenteDEPLOYABLE, puoi distribuire la funzione Lambda sui tuoi dispositivi principali. Per ulteriori informazioni, consulta Implementazione AWS IoT Greengrass dei componenti sui dispositivi.