Aller au contenu

Créer le composant

Depuis le répertoire qui contiendra l’espace de travail, exécutez :

Créez votre espace de travail@aws/nx-workspace

pnpm create @aws/nx-workspace greengrass-tutorial --iac=cdk
Options de cette étape2

Requis

Puis accédez-y :

Fenêtre de terminal
cd greengrass-tutorial

Le nom de l’espace de travail définit le scope npm @greengrass-tutorial et l’espace de noms Python greengrass_tutorial. Les noms de projets générés portent ces préfixes, et nx run nécessite le nom complet, donc le reste de ce tutoriel utilise greengrass_tutorial.telemetry et @greengrass-tutorial/infra.

Créez le projet Python qui héberge le composant :

Exécuter ce générateur@aws/nx-plugin:py#project

pnpm nx g @aws/nx-plugin:py#project --name=telemetry --no-interactive
Options de cette étape1

Requis

Cela crée le projet greengrass_tutorial.telemetry dans packages/telemetry.

Ajoutez-y le composant Greengrass :

Exécuter ce générateur@aws/nx-plugin:greengrass#component

pnpm nx g @aws/nx-plugin:greengrass#component --project=telemetry --name=pulse --platform=linux-amd64 --infra=component-version --iac=cdk --language=python --componentName=com.example.Pulse --componentVersion=NEXT_PATCH --ipc=true --no-interactive
Options de cette étape9

Requis

Requis

Chaque valeur est importante plus tard dans le tutoriel :

  • platform: linux-amd64 correspond à l’instance x86_64 que vous provisionnez dans le module 2. La valeur par défaut est linux-arm64, et une recette construite pour une architecture ne fonctionne pas sur l’autre.
  • componentVersion: NEXT_PATCH alloue la version au moment du déploiement. Le premier déploiement publie 1.0.0 ; le module 3 publie 1.0.1 à partir d’un changement de source sans modifier la recette.
  • ipc: true est explicite car ce tutoriel modifie le composant pour publier via Greengrass IPC.
  • infra: component-version avec iac: cdk ajoute les constructs de base Greengrass réutilisables à packages/common/constructs et un construct d’application Pulse qui publie l’artefact de ce composant.

Créez l’application CDK qui contiendra le déploiement :

Exécuter ce générateur@aws/nx-plugin:ts#infra

pnpm nx g @aws/nx-plugin:ts#infra --name=infra --no-interactive
Options de cette étape1

Requis

Les fichiers que ce tutoriel modifie :

  • Répertoirepackages
    • Répertoiretelemetry
      • Répertoiregreengrass
        • Répertoirepulse
          • main.py the component entrypoint
          • recipe.yaml the component recipe
      • Répertoiretests
        • Répertoiregreengrass
          • test_pulse.py the component’s unit test
      • project.json pulse-vendor, pulse-artifact, pulse-deploy-local and pulse-logs targets
    • Répertoirecommon
      • Répertoireconstructs
        • Répertoiresrc
          • core/greengrass artifact bucket, component version, deployment and version resolver constructs
          • app/greengrass/pulse.ts the Pulse construct
    • Répertoireinfra
      • Répertoiresrc
        • Répertoirestacks
          • application-stack.ts where module 3 composes the deployment

Tâche 3 : Publier vers AWS IoT Core au lieu du pub/sub local

Section intitulée « Tâche 3 : Publier vers AWS IoT Core au lieu du pub/sub local »

Le main.py généré publie un heartbeat avec publish_to_topic, qui atteint d’autres composants sur le même appareil de base via le service pub/sub local Greengrass. Il ne quitte jamais l’appareil. Pour voir le heartbeat dans AWS IoT Core, le composant doit utiliser publish_to_iot_core du client IPC, et la recette et la politique IoT de l’appareil doivent toutes deux l’autoriser.

Remplacez le packages/telemetry/greengrass/pulse/main.py généré :

import json
import logging
import time
from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("com.example.Pulse")
TOPIC = "tutorial/greengrass/heartbeat"
PUBLISH_INTERVAL_SECONDS = 30
GREETING = "hello from pulse"
def publish_heartbeat(client: GreengrassCoreIPCClientV2, sequence: int) -> None:
payload = json.dumps({"sequence": sequence, "greeting": GREETING}).encode("utf-8")
client.publish_to_iot_core(topic_name=TOPIC, qos="1", payload=payload)
logger.info("Published heartbeat %s to %s", sequence, TOPIC)
def main() -> None:
client = GreengrassCoreIPCClientV2()
sequence = 0
while True:
publish_heartbeat(client, sequence)
sequence += 1
time.sleep(PUBLISH_INTERVAL_SECONDS)
if __name__ == "__main__":
main()

publish_to_iot_core prend le nom du topic, un QoS de "1" (au moins une fois), et une charge utile en octets. Le topic tutorial/greengrass/heartbeat apparaît à nouveau dans la recette, dans la politique IoT de l’appareil que le module 2 crée, et dans l’abonnement du client de test MQTT dans le module 3.

Remplacez le bloc access-control dans packages/telemetry/greengrass/pulse/recipe.yaml :

RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.Pulse
ComponentVersion: NEXT_PATCH
ComponentDescription: com.example.Pulse Greengrass component using Python 3.14, generated by greengrass#component.
ComponentPublisher: greengrass-tutorial
ComponentConfiguration:
DefaultConfiguration:
accessControl:
aws.greengrass.ipc.mqttproxy:
com.example.Pulse:mqttproxy:1:
policyDescription: Allow publishing tutorial heartbeats to AWS IoT Core.
operations:
- aws.greengrass#PublishToIoTCore
resources:
- tutorial/greengrass/heartbeat
Manifests:
- Platform:
os: linux
architecture: amd64
Artifacts:
# Placeholders are substituted at publish time. The basename must stay
# pulse.zip, which is what the Run script below unarchives to.
- Uri: s3://BUCKET_NAME/COMPONENT_NAME/COMPONENT_VERSION/pulse.zip
Unarchive: ZIP
Lifecycle:
Run: python3.14 {artifacts:decompressedPath}/pulse/main.py

Le service IPC pour AWS IoT Core MQTT est aws.greengrass.ipc.mqttproxy, et la publication est l’opération aws.greengrass#PublishToIoTCore. La ressource est le topic exact. Cette autorisation est appliquée par le nucleus sur l’appareil. La politique IoT attachée au certificat de l’appareil est appliquée par AWS IoT Core, et elle nécessite iot:Publish sur le même topic. Le module 2 crée cette politique.

Mettez à jour le test généré, car le build du projet hôte l’exécute et la construction des constructs partagés dépend de la construction de l’hôte :

import importlib.util
import json
from pathlib import Path
# main.py lives beside recipe.yaml under greengrass/<component>/, outside this
# project's importable package, so it is loaded directly by file path.
PROJECT_ROOT = Path(__file__).resolve().parents[2]
MAIN_PATH = PROJECT_ROOT / "greengrass" / "pulse" / "main.py"
def _load_main():
spec = importlib.util.spec_from_file_location("pulse_main", MAIN_PATH)
assert spec is not None and spec.loader is not None
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
def test_publish_heartbeat_publishes_to_iot_core():
module = _load_main()
calls = []
class FakeClient:
def publish_to_iot_core(self, **kwargs):
calls.append(kwargs)
module.publish_heartbeat(FakeClient(), 1)
assert len(calls) == 1
assert calls[0]["topic_name"] == "tutorial/greengrass/heartbeat"
assert calls[0]["qos"] == "1"
assert json.loads(calls[0]["payload"]) == {"sequence": 1, "greeting": module.GREETING}

Exécutez le test et construisez l’artefact du composant :

Terminal window
pnpm nx run greengrass_tutorial.telemetry:test
pnpm nx run greengrass_tutorial.telemetry:pulse-artifact

pulse-artifact vend les dépendances Python pour x86_64-manylinux_2_28, empaquette pulse.zip, et écrit la recette résolue :

  • Répertoiredist/packages/telemetry/greengrass/pulse/greengrass-build
    • Répertoirerecipes
      • com.example.Pulse-NEXT_PATCH.yaml the recipe with the mqttproxy authorization
    • Répertoireartifacts
      • Répertoirecom.example.Pulse
        • RépertoireNEXT_PATCH
          • pulse.zip

Continuez avec Provisionner l’appareil de base.