Importer une fonction Lambda en tant que composant () AWS CLI - AWS IoT Greengrass
Étape 1 : Définition de la configuration de la fonction LambdaÉtape 2 : Création du composant de fonction Lambda

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Importer une fonction Lambda en tant que composant () AWS CLI

Utilisez cette CreateComponentVersionopération pour créer des composants à partir de fonctions Lambda. Lorsque vous appelez cette opération, spécifiez d'lambdaFunctionimporter une fonction Lambda.

Étape 1 : Définition de la configuration de la fonction Lambda

  1. Créez un fichier appelélambda-function-component.json, puis copiez l'objet JSON suivant dans le fichier. Remplacez le lambdaArn par l'ARN de la fonction Lambda à importer.

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

    Vous devez spécifier un ARN qui inclut la version de la fonction à importer. Vous ne pouvez pas utiliser des alias de version tels que $LATEST.

  2. (Facultatif) Spécifiez le nom (componentName) du composant. Si vous omettez ce paramètre, AWS IoT Greengrass crée le composant avec le nom de la fonction Lambda.

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

  3. (Facultatif) Spécifiez la version (componentVersion) du composant. Si vous omettez ce paramètre, AWS IoT Greengrass crée le composant avec la version de la fonction Lambda en tant que version sémantique valide. Par exemple, si la version de votre fonction équivaut à 3, la version du composant devient 3.0.0.

    Note

    Chaque version de composant que vous chargez doit être unique. Assurez-vous de télécharger la bonne version du composant, car vous ne pourrez pas la modifier après l'avoir chargée.

    AWS IoT Greengrassutilise des versions sémantiques pour les composants. Les versions sémantiques suivent une majeure. mineur. système de numéro de patch. Par exemple, la version 1.0.0 représente la première version majeure d'un composant. Pour plus d'informations, consultez la spécification de version sémantique.

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

  4. (Facultatif) Spécifiez les plateformes prises en charge par cette fonction Lambda. Chaque plateforme contient une carte des attributs qui l'identifient. Tous les appareils principaux ont des attributs pour le système d'exploitation (os) et l'architecture (architecture). Le logiciel AWS IoT Greengrass de base peut ajouter d'autres attributs de plate-forme. Vous pouvez également spécifier des attributs de plate-forme personnalisés lorsque vous déployez le composant Greengrass nucleus sur un appareil principal. Procédez comme suit :

    1. Ajoutez une liste de plateformes (componentPlatforms) à la fonction Lambda dans. 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. Ajoutez chaque plateforme prise en charge à la liste. Chaque plateforme dispose d'un outil convivial name permettant de l'identifier et d'une carte des attributs. L'exemple suivant indique que cette fonction prend en charge les périphériques x86 qui exécutent Linux.

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

      Vous lambda-function-component.json pouvez contenir un document similaire à l'exemple suivant.

      {
  "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. (Facultatif) Spécifiez les dépendances des composants pour votre fonction Lambda. Lorsque vous déployez le composant de fonction Lambda, le déploiement inclut ces dépendances pour l'exécution de votre fonction.

    Important

    Pour importer une fonction Lambda que vous avez créée pour être exécutée sur la version AWS IoT Greengrass 1, vous devez définir les dépendances des composants individuels pour les fonctionnalités utilisées par votre fonction, telles que les secrets, les ombres locales et le gestionnaire de flux. Définissez ces composants comme des dépendances fixes afin que le composant de votre fonction Lambda redémarre si la dépendance change d'état. Pour plus d’informations, consultez Importer les fonctions Lambda de la V1.

    Procédez comme suit :

    1. Ajoutez une carte des dépendances des composants (componentDependencies) à la fonction Lambda dans. 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. Ajoutez chaque dépendance des composants à la carte. Spécifiez le nom du composant comme clé et spécifiez un objet avec les paramètres suivants :

      • versionRequirement— La contrainte de version sémantique de style npm qui identifie les versions compatibles de la dépendance du composant. Vous pouvez spécifier une version unique ou une série de versions. Pour plus d'informations sur les contraintes de version sémantiques, consultez le calculateur npm semver.

      • dependencyType— (Facultatif) Type de dépendance. Choisissez parmi les options suivantes :

        • SOFT— Le composant de la fonction Lambda ne redémarre pas si la dépendance change d'état.

        • HARD— Le composant de la fonction Lambda redémarre si la dépendance change d'état.

        L’argument par défaut est HARD.

      L'exemple suivant indique que cette fonction Lambda dépend de n'importe quelle version de la première version majeure du composant du gestionnaire de flux. Le composant de la fonction Lambda redémarre lorsque le gestionnaire de flux redémarre ou est mis à jour.

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

      Vous lambda-function-component.json pouvez contenir un document similaire à l'exemple suivant.

      {
  "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. (Facultatif) Configurez les paramètres de la fonction Lambda à utiliser pour exécuter la fonction. Vous pouvez configurer des options telles que les variables d'environnement, les sources d'événements des messages, les délais d'expiration et les paramètres des conteneurs. Procédez comme suit :

    1. Ajoutez l'objet de paramètres Lambda (componentLambdaParameters) à la fonction Lambda dans. 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. (Facultatif) Spécifiez les sources d'événements auxquelles la fonction Lambda s'abonne pour les messages professionnels. Vous pouvez spécifier des sources d'événements pour abonner cette fonction aux messages de publication/d'abonnement locaux et aux messages AWS IoT Core MQTT. La fonction Lambda est appelée lorsqu'elle reçoit un message d'une source d'événement.

      Note

      Pour abonner cette fonction à des messages provenant d'autres fonctions ou composants Lambda, déployez l'ancien composant routeur d'abonnement lorsque vous déployez ce composant de fonction Lambda. Lorsque vous déployez l'ancien composant routeur d'abonnement, spécifiez les abonnements utilisés par la fonction Lambda.

      Procédez comme suit :

      1. Ajoutez la liste des sources d'événements (eventSources) aux paramètres de la fonction 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. Ajoutez chaque source d'événement à la liste. Chaque source d'événements possède les paramètres suivants :

        • topic— Le sujet pour s'abonner aux messages.

        • type— Type de source d'événement. Sélectionnez parmi les options suivantes :

          • PUB_SUB – Abonnez-vous aux messages locaux de publication/abonnement.

            Si vous utilisez Greengrass nucleus v2.6.0 ou version ultérieure et Lambda Manager v2.2.5 ou version ultérieure, vous pouvez utiliser des caractères génériques de sujet MQTT (+et) lorsque vous spécifiez ce type. # topic

          • IOT_CORE : abonnement aux messages MQTT AWS IoT Core.

            Vous pouvez utiliser des caractères génériques de rubrique MQTT (+et#) topic lorsque vous spécifiez ce type.

          L'exemple suivant s'abonne à AWS IoT Core MQTT sur des sujets qui correspondent au filtre de hello/world/+ sujet.

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

          Votre lambda-function-component.json image peut ressembler à l'exemple suivant.

          {
  "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. (Facultatif) Spécifiez l'un des paramètres suivants dans l'objet de paramètres de la fonction Lambda :

      • environmentVariables— La carte des variables d'environnement disponibles pour la fonction Lambda lors de son exécution.

      • execArgs— Liste des arguments à transmettre à la fonction Lambda lors de son exécution.

      • inputPayloadEncodingType— Le type de charge utile pris en charge par la fonction Lambda. Sélectionnez parmi les options suivantes :

        • json

        • binary

        Par défaut : json

      • pinned— Indique si la fonction Lambda est épinglée ou non. L’argument par défaut est true.

        • Une fonction Lambda épinglée (ou à longue durée de vie) démarre au démarrage et continue de s'AWS IoT Greengrassexécuter dans son propre conteneur.

        • Une fonction Lambda non épinglée (ou à la demande) démarre uniquement lorsqu'elle reçoit un élément de travail et s'arrête une fois qu'elle est restée inactive pendant une durée d'inactivité maximale spécifiée. Si la fonction comporte plusieurs éléments de travail, le logiciel AWS IoT Greengrass Core crée plusieurs instances de la fonction.

        maxIdleTimeInSecondsÀ utiliser pour définir le temps d'inactivité maximal de votre fonction.

      • timeoutInSeconds— Durée maximale en secondes pendant laquelle la fonction Lambda peut être exécutée avant son expiration. Le durée par défaut est de 3 secondes.

      • statusTimeoutInSeconds— Intervalle en secondes pendant lequel le composant de la fonction Lambda envoie des mises à jour de statut au composant du gestionnaire Lambda. Ce paramètre s'applique uniquement aux fonctions épinglées. Le durée par défaut est 60 secondes.

      • maxIdleTimeInSeconds— Durée maximale en secondes pendant laquelle une fonction Lambda non épinglée peut être inactive avant que le logiciel AWS IoT Greengrass Core n'arrête son processus. Le durée par défaut est 60 secondes.

      • maxInstancesCount— Le nombre maximum d'instances qu'une fonction Lambda non épinglée peut exécuter simultanément. La valeur par défaut est de 100 instances.

      • maxQueueSize— Taille maximale de la file d'attente de messages pour le composant de fonction Lambda. Le logiciel AWS IoT Greengrass Core stocke les messages dans une file d'attente FIFO (first-in-first-out) jusqu'à ce qu'il puisse exécuter la fonction Lambda pour consommer chaque message. La valeur par défaut est de 1 000 messages.

      Vous lambda-function-component.json pouvez contenir un document similaire à l'exemple suivant.

      {
  "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. (Facultatif) Configurez les paramètres du conteneur pour la fonction Lambda. Par défaut, les fonctions Lambda s'exécutent dans un environnement d'exécution isolé au sein du logiciel AWS IoT Greengrass Core. Vous pouvez également choisir d'exécuter la fonction Lambda en tant que processus sans aucune isolation. Si vous exécutez la fonction Lambda dans un conteneur, vous configurez la taille de la mémoire du conteneur et les ressources système disponibles pour la fonction Lambda. Procédez comme suit :

      1. Ajoutez l'objet de paramètres de processus Linux (linuxProcessParams) à l'objet de paramètres Lambda dans. 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. (Facultatif) Spécifiez si la fonction Lambda s'exécute ou non dans un conteneur. Ajoutez le isolationMode paramètre à l'objet des paramètres de processus et choisissez l'une des options suivantes :

        • GreengrassContainer— La fonction Lambda s'exécute dans un conteneur.

        • NoContainer— La fonction Lambda s'exécute comme un processus sans aucune isolation.

        L’argument par défaut est GreengrassContainer.

      3. (Facultatif) Si vous exécutez la fonction Lambda dans un conteneur, vous pouvez configurer la quantité de mémoire et les ressources système, telles que les volumes et les périphériques, à mettre à la disposition du conteneur. Procédez comme suit :

        1. Ajoutez l'objet de paramètres de conteneur (containerParams) à l'objet de paramètres de processus Linux danslambda-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. (Facultatif) Ajoutez le memorySizeInKB paramètre pour spécifier la taille de la mémoire du conteneur. La valeur par défaut est 16 384 Ko (16 Mo).

        3. (Facultatif) Ajoutez le mountROSysfs paramètre pour spécifier si le conteneur peut ou non lire les informations du /sys dossier du périphérique. L’argument par défaut est false.

        4. (Facultatif) Configurez les volumes locaux auxquels la fonction Lambda conteneurisée peut accéder. Lorsque vous définissez un volume, le logiciel AWS IoT Greengrass Core monte les fichiers source sur la destination à l'intérieur du conteneur. Procédez comme suit :

          1. Ajoutez la liste des volumes (volumes) aux paramètres du conteneur.

            {
  "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. Ajoutez chaque volume à la liste. Chaque volume possède les paramètres suivants :

            • sourcePath— Le chemin d'accès au dossier source sur le périphérique principal.

            • destinationPath— Le chemin d'accès au dossier de destination dans le conteneur.

            • permission— (Facultatif) L'autorisation d'accéder au dossier source depuis le conteneur. Sélectionnez parmi les options suivantes :

              • ro— La fonction Lambda dispose d'un accès en lecture seule au dossier source.

              • rw— La fonction Lambda dispose d'un accès en lecture-écriture au dossier source.

              L’argument par défaut est ro.

            • addGroupOwner— (Facultatif) S'il faut ou non ajouter le groupe système qui exécute le composant de fonction Lambda en tant que propriétaire du dossier source. L’argument par défaut est false.

            Vous lambda-function-component.json pouvez contenir un document similaire à l'exemple suivant.

            {
  "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. (Facultatif) Configurez les périphériques du système local auxquels la fonction Lambda conteneurisée peut accéder. Procédez comme suit :

          1. Ajoutez la liste des périphériques système (devices) aux paramètres du conteneur.

            {
  "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. Ajoutez chaque périphérique du système à la liste. Chaque périphérique du système possède les paramètres suivants :

            • path— Le chemin d'accès au périphérique système sur le périphérique principal.

            • permission— (Facultatif) L'autorisation d'accéder au périphérique système depuis le conteneur. Sélectionnez parmi les options suivantes :

              • ro— La fonction Lambda dispose d'un accès en lecture seule au périphérique système.

              • rw— La fonction Lambda dispose d'un accès en lecture-écriture au périphérique système.

              L’argument par défaut est ro.

            • addGroupOwner— (Facultatif) S'il faut ou non ajouter le groupe système qui exécute le composant de fonction Lambda en tant que propriétaire du périphérique système. L’argument par défaut est false.

          Vous lambda-function-component.json pouvez contenir un document similaire à l'exemple suivant.

          {
  "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. (Facultatif) Ajoutez des balises (tags) pour le composant. Pour plus d’informations, consultez Baliser vos ressources AWS IoT Greengrass Version 2.

Étape 2 : Création du composant de fonction Lambda

  1. Exécutez la commande suivante pour créer le composant de fonction Lambda à partir de. lambda-function-component.json

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

    La réponse ressemble à l'exemple suivant si la demande aboutit.

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

    Copiez le arn depuis la sortie pour vérifier l'état du composant à l'étape suivante.

  2. Lorsque vous créez un composant, son état estREQUESTED. AWS IoT GreengrassVérifie ensuite que le composant est déployable. Vous pouvez exécuter la commande suivante pour connaître l'état du composant et vérifier que celui-ci est déployable. Remplacez le arn par l'ARN de l'étape précédente.

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

    Si le composant est validé, la réponse indique que l'état du composant estDEPLOYABLE.

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

    Une fois le composant activéDEPLOYABLE, vous pouvez déployer la fonction Lambda sur vos appareils principaux. Pour plus d'informations, consultez Déployer AWS IoT Greengrass des composants sur des appareils.