Ir al contenido

Crear el componente

Desde el directorio que contendrá el workspace, ejecuta:

Cree su espacio de trabajo@aws/nx-workspace

pnpm create @aws/nx-workspace greengrass-tutorial --iac=cdk
Opciones de este paso2

Requerido

Luego cambia a él:

Ventana de terminal
cd greengrass-tutorial

El nombre del workspace establece el scope npm @greengrass-tutorial y el namespace Python greengrass_tutorial. Los nombres de proyectos generados llevan esos prefijos, y nx run necesita el nombre completo, por lo que el resto de este tutorial usa greengrass_tutorial.telemetry y @greengrass-tutorial/infra.

Crea el proyecto Python que aloja el componente:

Ejecute este generador@aws/nx-plugin:py#project

pnpm nx g @aws/nx-plugin:py#project --name=telemetry --no-interactive
Opciones de este paso1

Requerido

Esto crea el proyecto greengrass_tutorial.telemetry en packages/telemetry.

Agrega el componente Greengrass a él:

Ejecute este generador@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
Opciones de este paso9

Requerido

Requerido

Cada valor importa más adelante en el tutorial:

  • platform: linux-amd64 coincide con la instancia x86_64 que aprovisionas en el módulo 2. El valor predeterminado es linux-arm64, y una receta construida para una arquitectura no se ejecuta en la otra.
  • componentVersion: NEXT_PATCH asigna la versión en el momento del despliegue. El primer despliegue publica 1.0.0; el módulo 3 publica 1.0.1 desde un cambio de código fuente sin editar la receta.
  • ipc: true es explícito porque este tutorial cambia el componente para publicar a través de Greengrass IPC.
  • infra: component-version con iac: cdk agrega los constructos reutilizables de Greengrass core a packages/common/constructs y un constructo de aplicación Pulse que publica el artefacto de este componente.

Crea la aplicación CDK que contendrá el despliegue:

Ejecute este generador@aws/nx-plugin:ts#infra

pnpm nx g @aws/nx-plugin:ts#infra --name=infra --no-interactive
Opciones de este paso1

Requerido

Los archivos que este tutorial toca:

  • Directoriopackages
    • Directoriotelemetry
      • Directoriogreengrass
        • Directoriopulse
          • main.py the component entrypoint
          • recipe.yaml the component recipe
      • Directoriotests
        • Directoriogreengrass
          • test_pulse.py the component’s unit test
      • project.json pulse-vendor, pulse-artifact, pulse-deploy-local and pulse-logs targets
    • Directoriocommon
      • Directorioconstructs
        • Directoriosrc
          • core/greengrass artifact bucket, component version, deployment and version resolver constructs
          • app/greengrass/pulse.ts the Pulse construct
    • Directorioinfra
      • Directoriosrc
        • Directoriostacks
          • application-stack.ts where module 3 composes the deployment

Tarea 3: Publicar a AWS IoT Core en lugar de pub/sub local

Sección titulada «Tarea 3: Publicar a AWS IoT Core en lugar de pub/sub local»

El main.py generado publica un heartbeat con publish_to_topic, que alcanza otros componentes en el mismo dispositivo core a través del servicio local de pub/sub de Greengrass. Nunca sale del dispositivo. Para ver el heartbeat en AWS IoT Core, el componente debe usar publish_to_iot_core del cliente IPC, y tanto la receta como la política IoT del dispositivo deben permitirlo.

Reemplaza el packages/telemetry/greengrass/pulse/main.py generado:

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 toma el nombre del topic, un QoS de "1" (al menos una vez), y un payload de bytes. El topic tutorial/greengrass/heartbeat aparece nuevamente en la receta, en la política IoT del dispositivo que el módulo 2 crea, y en la suscripción del cliente de prueba MQTT en el módulo 3.

Reemplaza el bloque de control de acceso en 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

El servicio IPC para AWS IoT Core MQTT es aws.greengrass.ipc.mqttproxy, y publicar es la operación aws.greengrass#PublishToIoTCore. El recurso es el topic exacto. Esta autorización es aplicada por el nucleus en el dispositivo. La política IoT adjunta al certificado del dispositivo es aplicada por AWS IoT Core, y necesita iot:Publish en el mismo topic. El módulo 2 crea esa política.

Actualiza la prueba generada, porque el build del proyecto host la ejecuta y la construcción de los constructos compartidos depende de la construcción del host:

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}

Ejecuta la prueba y construye el artefacto del componente:

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

pulse-artifact empaqueta las dependencias Python para x86_64-manylinux_2_28, empaqueta pulse.zip, y escribe la receta resuelta:

  • Directoriodist/packages/telemetry/greengrass/pulse/greengrass-build
    • Directoriorecipes
      • com.example.Pulse-NEXT_PATCH.yaml the recipe with the mqttproxy authorization
    • Directorioartifacts
      • Directoriocom.example.Pulse
        • DirectorioNEXT_PATCH
          • pulse.zip

Continúa con Aprovisionar el dispositivo core.