Eine Lambda-Funktion als Komponente importieren ()AWS CLI - AWS IoT Greengrass
Schritt 1: Definieren Sie die Lambda-FunktionskonfigurationSchritt 2: Erstellen Sie die Lambda-Funktionskomponente

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Eine Lambda-Funktion als Komponente importieren ()AWS CLI

Verwenden Sie die CreateComponentVersionOperation, um Komponenten aus Lambda-Funktionen zu erstellen. Wenn Sie diesen Vorgang aufrufen, geben Sie lambdaFunction an, dass eine Lambda-Funktion importiert werden soll.

Schritt 1: Definieren Sie die Lambda-Funktionskonfiguration

  1. Erstellen Sie eine Datei mit dem Namenlambda-function-component.json, und kopieren Sie dann das folgende JSON Objekt in die Datei. Ersetzen Sie das lambdaArn durch das ARN der Lambda-Funktion, die importiert werden soll.

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

    Sie müssen eine angebenARN, die die Version der zu importierenden Funktion enthält. Sie können keine Versions-Aliase wie $LATEST verwenden.

  2. (Optional) Geben Sie den Namen (componentName) der Komponente an. Wenn Sie diesen Parameter weglassen, AWS IoT Greengrass wird die Komponente mit dem Namen der Lambda-Funktion erstellt.

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

  3. (Optional) Geben Sie die Version (componentVersion) für die Komponente an. Wenn Sie diesen Parameter weglassen, AWS IoT Greengrass wird die Komponente mit der Version der Lambda-Funktion als gültige semantische Version erstellt. Wenn Ihre Funktionsversion beispielsweise 3 lautet, wird die Komponentenversion 3.0.0.

    Anmerkung

    Jede Komponentenversion, die Sie hochladen, muss eindeutig sein. Stellen Sie sicher, dass Sie die richtige Komponentenversion hochladen, da Sie sie nach dem Hochladen nicht mehr bearbeiten können.

    AWS IoT Greengrass verwendet semantische Versionen für Komponenten. Semantische Versionen folgen einem Hauptteil. unbedeutend. Patch-Nummernsystem. Version 1.0.0 steht beispielsweise für die erste Hauptversion einer Komponente. Weitere Informationen finden Sie in der semantischen Versionsspezifikation.

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

  4. (Optional) Geben Sie die Plattformen an, die diese Lambda-Funktion unterstützt. Jede Plattform enthält eine Zuordnung von Attributen, die eine Plattform identifizieren. Alle Kerngeräte haben Attribute für Betriebssystem (os) und Architektur (architecture). Die AWS IoT Greengrass Core-Software kann weitere Plattformattribute hinzufügen. Sie können auch benutzerdefinierte Plattformattribute angeben, wenn Sie die Greengrass Nucleus-Komponente auf einem Core-Gerät bereitstellen. Gehen Sie wie folgt vor:

    1. Fügen Sie der Lambda-Funktion in lambda-function-component.json eine Liste von Plattformen (componentPlatforms) hinzu.

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

    2. Fügen Sie jede unterstützte Plattform zur Liste hinzu. Für jede Plattform gibt es eine name Benutzerschnittstelle zur Identifizierung und eine Zuordnung von Attributen. Das folgende Beispiel gibt an, dass diese Funktion x86-Geräte unterstützt, auf denen Linux ausgeführt wird.

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

      lambda-function-component.jsonMöglicherweise enthalten Sie ein Dokument, das dem folgenden Beispiel ähnelt.

      {
  "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. (Optional) Geben Sie die Komponentenabhängigkeiten für Ihre Lambda-Funktion an. Wenn Sie die Lambda-Funktionskomponente bereitstellen, umfasst die Bereitstellung diese Abhängigkeiten, damit Ihre Funktion ausgeführt werden kann.

    Wichtig

    Um eine Lambda-Funktion zu importieren, die Sie für die Ausführung auf AWS IoT Greengrass V1 erstellt haben, müssen Sie individuelle Komponentenabhängigkeiten für die Funktionen definieren, die Ihre Funktion verwendet, z. B. Geheimnisse, lokale Schatten und Stream-Manager. Definieren Sie diese Komponenten als feste Abhängigkeiten, sodass Ihre Lambda-Funktionskomponente neu gestartet wird, wenn sich der Status der Abhängigkeit ändert. Weitere Informationen finden Sie unter Importieren von V1-Lambda-Funktionen.

    Gehen Sie wie folgt vor:

    1. Fügen Sie der Lambda-Funktion in lambda-function-component.json eine Zuordnung von Komponentenabhängigkeiten (componentDependencies) hinzu.

      {
  "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. Fügen Sie der Map jede Komponentenabhängigkeit hinzu. Geben Sie den Komponentennamen als Schlüssel an und geben Sie ein Objekt mit den folgenden Parametern an:

      • versionRequirement— Die semantische Versionsbeschränkung im NPM-Stil, die die kompatiblen Versionen der Komponentenabhängigkeit identifiziert. Sie können eine einzelne Version oder einen Versionsbereich angeben. Weitere Informationen zu semantischen Versionseinschränkungen finden Sie im npm Semver Calculator.

      • dependencyType— (Optional) Der Typ der Abhängigkeit. Wählen Sie eine der folgenden Optionen aus:

        • SOFT— Die Lambda-Funktionskomponente wird nicht neu gestartet, wenn sich der Status der Abhängigkeit ändert.

        • HARD— Die Lambda-Funktionskomponente wird neu gestartet, wenn sich der Status der Abhängigkeit ändert.

        Der Standardwert ist HARD.

      Das folgende Beispiel gibt an, dass diese Lambda-Funktion von einer beliebigen Version in der ersten Hauptversion der Stream Manager-Komponente abhängt. Die Lambda-Funktionskomponente wird neu gestartet, wenn der Stream-Manager neu gestartet oder aktualisiert wird.

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

      lambda-function-component.jsonMöglicherweise enthalten Sie ein Dokument, das dem folgenden Beispiel ähnelt.

      {
  "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. (Optional) Konfigurieren Sie die Lambda-Funktionsparameter, die zur Ausführung der Funktion verwendet werden sollen. Sie können Optionen wie Umgebungsvariablen, Nachrichtenereignisquellen, Timeouts und Containereinstellungen konfigurieren. Gehen Sie wie folgt vor:

    1. Fügen Sie das Lambda-Parameter-Objekt (componentLambdaParameters) zur Lambda-Funktion in hinzu. 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. (Optional) Geben Sie die Ereignisquellen an, die die Lambda-Funktion für geschäftliche Nachrichten abonniert. Sie können Ereignisquellen angeben, um diese Funktion für lokale Veröffentlichungs-/Abonnementnachrichten und Nachrichten zu abonnieren. AWS IoT Core MQTT Die Lambda-Funktion wird aufgerufen, wenn sie eine Nachricht von einer Ereignisquelle empfängt.

      Anmerkung

      Um diese Funktion für Nachrichten von anderen Lambda-Funktionen oder -Komponenten zu abonnieren, stellen Sie die ältere Abonnement-Router-Komponente bereit, wenn Sie diese Lambda-Funktionskomponente bereitstellen. Wenn Sie die ältere Abonnement-Router-Komponente bereitstellen, geben Sie die Abonnements an, die die Lambda-Funktion verwendet.

      Gehen Sie wie folgt vor:

      1. Fügen Sie die Liste der Ereignisquellen (eventSources) zu den Lambda-Funktionsparametern hinzu.

        {
  "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. Fügen Sie jede Ereignisquelle zur Liste hinzu. Jede Ereignisquelle hat die folgenden Parameter:

        • topic— Das Thema, zu dem Nachrichten abonniert werden sollen.

        • type— Der Typ der Ereignisquelle. Wählen Sie aus den folgenden Optionen aus:

          • PUB_SUB — Abonnieren Sie lokale Veröffentlichen/Abonnement-Nachrichten.

            Wenn Sie Greengrass Nucleus v2.6.0 oder höher und Lambda Manager v2.2.5 oder höher verwenden, können Sie MQTT Topic-Wildcards (+und#) in der verwenden, wenn Sie diesen Typ angeben. topic

          • IOT_CORE— Nachrichten abonnieren. AWS IoT Core MQTT

            Sie können MQTT Themen-Platzhalter (+und#) verwenden, topic wenn Sie diesen Typ angeben.

          Im folgenden Beispiel werden Themen abonniert, die AWS IoT Core MQTT dem Themenfilter entsprechen. hello/world/+

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

          Ihr Beispiel lambda-function-component.json könnte dem folgenden Beispiel ähneln.

          {
  "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. (Optional) Geben Sie einen der folgenden Parameter im Lambda-Funktionsparameterobjekt an:

      • environmentVariables— Die Karte der Umgebungsvariablen, die für die Lambda-Funktion verfügbar sind, wenn sie ausgeführt wird.

      • execArgs— Die Liste der Argumente, die an die Lambda-Funktion übergeben werden sollen, wenn sie ausgeführt wird.

      • inputPayloadEncodingType— Die Art der Nutzlast, die die Lambda-Funktion unterstützt. Wählen Sie aus den folgenden Optionen aus:

        • json

        • binary

        Standard: json

      • pinned— Ob die Lambda-Funktion gepinnt ist oder nicht. Der Standardwert ist true.

        • Eine fixierte (oder langlebige) Lambda-Funktion AWS IoT Greengrass startet beim Start und läuft in ihrem eigenen Container weiter.

        • Eine Lambda-Funktion ohne Fixierung (oder On-Demand-Funktion) startet nur, wenn sie ein Arbeitselement empfängt, und wird beendet, wenn sie für eine festgelegte maximale Leerlaufzeit inaktiv bleibt. Wenn die Funktion mehrere Arbeitselemente hat, erstellt die AWS IoT Greengrass Core-Software mehrere Instanzen der Funktion.

        Verwenden Sie maxIdleTimeInSeconds diese Option, um die maximale Leerlaufzeit für Ihre Funktion festzulegen.

      • timeoutInSeconds— Die maximale Zeit in Sekunden, die die Lambda-Funktion ausführen kann, bevor das Timeout eintritt. Der Standardwert ist 3 Sekunden.

      • statusTimeoutInSeconds— Das Intervall in Sekunden, in dem die Lambda-Funktionskomponente Statusaktualisierungen an die Lambda-Manager-Komponente sendet. Dieser Parameter gilt nur für fixierte Funktionen. Standardmäßig ist ein Zeitraum von 60 Sekunden festgelegt.

      • maxIdleTimeInSeconds— Die maximale Zeit in Sekunden, während der eine Lambda-Funktion ohne Pin inaktiv sein kann, bevor die AWS IoT Greengrass Core-Software ihren Prozess stoppt. Standardmäßig ist ein Zeitraum von 60 Sekunden festgelegt.

      • maxInstancesCount— Die maximale Anzahl von Instanzen, die eine nicht gepinnte Lambda-Funktion gleichzeitig ausführen kann. Die Standardeinstellung ist 100 Instanzen.

      • maxQueueSize— Die maximale Größe der Nachrichtenwarteschlange für die Lambda-Funktionskomponente. Die AWS IoT Greengrass Core-Software speichert Nachrichten in einer FIFO (first-in-first-out) -Warteschlange, bis sie die Lambda-Funktion ausführen kann, um jede Nachricht zu verarbeiten. Die Standardeinstellung ist 1.000 Nachrichten.

      lambda-function-component.jsonMöglicherweise enthält Ihr Dokument ein Dokument, das dem folgenden Beispiel ähnelt.

      {
  "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. (Optional) Konfigurieren Sie die Container-Einstellungen für die Lambda-Funktion. Standardmäßig werden Lambda-Funktionen in einer isolierten Laufzeitumgebung innerhalb der AWS IoT Greengrass Core-Software ausgeführt. Sie können sich auch dafür entscheiden, die Lambda-Funktion als Prozess ohne jegliche Isolierung auszuführen. Wenn Sie die Lambda-Funktion in einem Container ausführen, konfigurieren Sie die Speichergröße des Containers und welche Systemressourcen für die Lambda-Funktion verfügbar sind. Gehen Sie wie folgt vor:

      1. Fügen Sie das Linux-Prozessparameter-Objekt (linuxProcessParams) zum Lambda-Parameter-Objekt in lambda-function-component.json hinzu.

        {
  "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. (Optional) Geben Sie an, ob die Lambda-Funktion in einem Container ausgeführt wird. Fügen Sie den isolationMode Parameter dem Prozessparameter-Objekt hinzu und wählen Sie aus den folgenden Optionen:

        • GreengrassContainer— Die Lambda-Funktion läuft in einem Container.

        • NoContainer— Die Lambda-Funktion läuft als Prozess ohne jegliche Isolierung.

        Der Standardwert ist GreengrassContainer.

      3. (Optional) Wenn Sie die Lambda-Funktion in einem Container ausführen, können Sie die Speichermenge und die Systemressourcen, wie Volumes und Geräte, konfigurieren, die dem Container zur Verfügung gestellt werden sollen. Gehen Sie wie folgt vor:

        1. Fügen Sie das Container-Parameter-Objekt (containerParams) dem Linux-Prozessparameter-Objekt in lambda-function-component.json hinzu.

          {
  "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. (Optional) Fügen Sie den memorySizeInKB Parameter hinzu, um die Speichergröße des Containers anzugeben. Die Standardeinstellung ist 16.384 KB (16 MB).

        3. (Optional) Fügen Sie den mountROSysfs Parameter hinzu, um anzugeben, ob der Container Informationen aus dem /sys Geräteordner lesen kann. Der Standardwert ist false.

        4. (Optional) Konfigurieren Sie die lokalen Volumes, auf die die containerisierte Lambda-Funktion zugreifen kann. Wenn Sie ein Volume definieren, mountet die AWS IoT Greengrass Core-Software die Quelldateien am Ziel innerhalb des Containers. Gehen Sie wie folgt vor:

          1. Fügen Sie die Liste der Volumes (volumes) zu den Container-Parametern hinzu.

            {
  "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. Fügen Sie jedes Volume der Liste hinzu. Jedes Volumen hat die folgenden Parameter:

            • sourcePath— Der Pfad zum Quellordner auf dem Core-Gerät.

            • destinationPath— Der Pfad zum Zielordner im Container.

            • permission— (Optional) Die Berechtigung, vom Container aus auf den Quellordner zuzugreifen. Wählen Sie aus den folgenden Optionen aus:

              • ro— Die Lambda-Funktion hat nur Lesezugriff auf den Quellordner.

              • rw— Die Lambda-Funktion hat Lese- und Schreibzugriff auf den Quellordner.

              Der Standardwert ist ro.

            • addGroupOwner— (Optional) Ob die Systemgruppe, die die Lambda-Funktionskomponente ausführt, als Eigentümer des Quellordners hinzugefügt werden soll oder nicht. Der Standardwert ist false.

            lambda-function-component.jsonMöglicherweise enthalten Sie ein Dokument, das dem folgenden Beispiel ähnelt.

            {
  "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. (Optional) Konfigurieren Sie die lokalen Systemgeräte, auf die die containerisierte Lambda-Funktion zugreifen kann. Gehen Sie wie folgt vor:

          1. Fügen Sie die Liste der Systemgeräte (devices) zu den Container-Parametern hinzu.

            {
  "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. Fügen Sie jedes Systemgerät zur Liste hinzu. Jedes Systemgerät hat die folgenden Parameter:

            • path— Der Pfad zum Systemgerät auf dem Kerngerät.

            • permission— (Optional) Die Erlaubnis, vom Container aus auf das Systemgerät zuzugreifen. Wählen Sie aus den folgenden Optionen aus:

              • ro— Die Lambda-Funktion hat nur Lesezugriff auf das Systemgerät.

              • rw— Die Lambda-Funktion hat Lese- und Schreibzugriff auf das Systemgerät.

              Der Standardwert ist ro.

            • addGroupOwner— (Optional) Ob die Systemgruppe, die die Lambda-Funktionskomponente ausführt, als Besitzer des Systemgeräts hinzugefügt werden soll oder nicht. Der Standardwert ist false.

          lambda-function-component.jsonMöglicherweise enthalten Sie ein Dokument, das dem folgenden Beispiel ähnelt.

          {
  "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. (Optional) Fügen Sie Tags (tags) für die Komponente hinzu. Weitere Informationen finden Sie unter Markieren Ihrer AWS IoT Greengrass Version 2-Ressourcen mit Tags.

Schritt 2: Erstellen Sie die Lambda-Funktionskomponente

  1. Führen Sie den folgenden Befehl aus, um die Lambda-Funktionskomponente von lambda-function-component.json zu erstellen.

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

    Die Antwort sieht ähnlich wie im folgenden Beispiel aus, wenn die Anfrage erfolgreich ist.

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

    Kopieren Sie das arn aus der Ausgabe, um im nächsten Schritt den Status der Komponente zu überprüfen.

  2. Wenn Sie eine Komponente erstellen, lautet ihr StatusREQUESTED. AWS IoT Greengrass Überprüft dann, ob die Komponente bereitgestellt werden kann. Sie können den folgenden Befehl ausführen, um den Status der Komponente abzufragen und zu überprüfen, ob Ihre Komponente bereitgestellt werden kann. Ersetzen Sie die arn durch die ARN aus dem vorherigen Schritt.

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

    Wenn die Komponente validiert wird, gibt die Antwort an, dass der Status der Komponente lautetDEPLOYABLE.

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

    Nachdem die Komponente fertig istDEPLOYABLE, können Sie die Lambda-Funktion auf Ihren Kerngeräten bereitstellen. Weitere Informationen finden Sie unter Bereitstellen von AWS IoT Greengrass Komponenten auf Geräten.