Sure, here is the updated version of the wiki document:

Combined Explainer Wiki: Device Provisioning and Deployment in AWS with Edge AI
Tools

Introduction:

This wiki document provides a comprehensive guide on provisioning and deploying devices to
AWS, incorporating the integration of Edge AI tools for enhanced on-device processing
capabilities. By following these steps, you can establish secure communication between your
devices and AWS IoT Core, enabling them to leverage both cloud-based and Edge AI
functionalities.

Prerequisites:

● An AWS Account with the necessary permissions to access and configure AWS IoT Core
services, including Greengrass.
● The device you intend to provision needs to have a stable internet connection to
communicate with AWS during the setup process.
● You'll also require the AWS SDK for Javascript (version 2) integrated into your application.
This library provides functionalities to interact with AWS services from your application code.
● Ensure that the Edge AI tools you intend to use are compatible with the device's hardware
and operating system.

Step-by-Step Guide:

1. Configuration (Perform once):

● Within your application code, configure the AWS credentials retrieved from your AWS
account. These credentials typically include your access key ID, secret access key, session
token (if applicable), and the specific AWS region you'll be using. The AWS SDK for
Javascript will use these credentials to authenticate your application and grant it permission
to interact with AWS services.

2. Device Registration:

● The next step involves registering your device with AWS IoT Core. This can be achieved
through your application code by creating a new "Thing" in the AWS IoT registry. A "Thing"
essentially represents a physical or virtual device that can be managed by AWS IoT Core.
● When creating the Thing, assign a unique device name that adheres to the following
guidelines:
○ Allowed characters: Letters (a-z, A-Z), numbers (0-9), underscore (_), and hyphen (-).
○ Minimum length: 6 characters
○ Maximum length: 50 characters
○ Choose a descriptive name that reflects the purpose or function of the device. For
instance, "sensor-123" or "camera-west-gate" can be appropriate names depending on
your use case.

3. Thing Group Selection (Optional):

● AWS IoT Core allows you to organize your devices into logical groups called "Thing Groups."
Assigning a device to a Thing Group can simplify management tasks like certificate issuance
and updating configurations across multiple devices with similar functionalities.
● During the registration process, you can optionally assign the newly created Thing to a
specific Thing Group within your AWS IoT registry. This step is beneficial if you have multiple
devices serving similar purposes and want to manage them collectively.

4. Device IP Address and Connectivity:

● Your application will need the device's IP address to establish a connection and configure it
for AWS IoT communication. Ensure the device is connected to the network and accessible
by your application. You can typically retrieve the IP address through your device's network
settings or management console.

5. Confirmation and Deployment:

● Once you've entered the device details (name, IP address, Thing Group selection), carefully
review the information for accuracy before proceeding.
● Upon confirmation, your application will initiate communication with the device and configure
it for secure interaction with AWS IoT Core. This process might involve generating and
deploying security certificates to the device. These certificates establish a trusted connection
between the device and AWS, ensuring the authenticity and privacy of data being
exchanged.

6. Edge AI Tools Integration (Optional):

● If you've selected to include Edge AI tools during deployment, your application will proceed
with the following steps:
○ Greengrass Component Creation: A Greengrass component is created on the device,
containing the necessary configuration and dependencies for your chosen Edge AI tools.
○ Artifact Deployment: The required artifacts, such as Docker images and configuration
files, are deployed to the device.
○ Component Execution: The Greengrass component is started on the device, enabling
the execution of Edge AI models and algorithms.

Technical Explainer for preload.js:

The preload.js script plays a crucial role in the Edge AI tools integration process. It performs the
following tasks:

● Exposes AWS Functions: It exposes a createGreengrassComponent function to the main

renderer process, allowing the application to interact with AWS services for component
creation.
● AWS SDK Initialization: It initializes the AWS CognitoIdentity and AWS IoT clients using the
provided credentials and region information.
● Cognito Identity and Policy Attachment: It obtains the Cognito Identity ID associated with
the user's idToken and attaches the necessary IoT policy to grant the device the required
permissions.
● Greengrass Component Creation: It creates a new Greengrass component on the device
using the provided component recipe, which defines the component's metadata, artifacts,
and lifecycle configuration.
● Error Handling: It includes error handling mechanisms to catch and log any exceptions that
may occur during the component creation process.

Additional Considerations:

● Choosing the Right Edge AI Tools: Carefully select Edge AI tools that are compatible with
the device's hardware, operating system, and your specific use case. Consider factors such
as performance, power consumption, and model size when making your selection.
● Optimizing Model Deployment: Optimize your Edge AI models for deployment on the
device. This might involve techniques like model quantization, pruning, or distillation to
reduce model size and improve inference speed.
● Data Privacy and Security: Implement robust security measures to protect sensitive data
and prevent unauthorized access to the device and its Edge AI capabilities. Consider
encryption, access controls, and regular security updates.
● Monitoring and Management: Establish monitoring and management procedures to track
the performance of your Edge AI deployments. This includes monitoring resource usage,
model accuracy, and overall system health.
● Continuous Improvement: Regularly evaluate and refine your Edge AI deployments based
on performance metrics and feedback. Consider updating models, optimizing configurations,
and addressing any issues that arise.

By following these steps and understanding the technical concepts involved, you can
successfully provision and deploy devices to AWS, effectively integrating Edge AI tools to
enhance your applications' capabilities and reduce latency.

Additional Explainer on the Recipe Part:

The recipe part in the preload.js script defines the metadata, artifacts, and lifecycle configuration
for the Greengrass component that will be created on the device. It provides the necessary
information for AWS Greengrass to understand the component's structure, dependencies, and
execution behavior.

Key components of the recipe:

1. ComponentName: This specifies a unique name for the Greengrass component. The
name should be descriptive and follow AWS naming conventions.
2. ComponentVersion: This indicates the version of the component. It's essential to use a
versioning scheme to track changes and updates to the component.
3. Manifests: This section contains an array of manifests, each defining the component's
configuration for a specific platform. In the provided example, there's a single manifest for
the Linux platform.
4. Platform: This specifies the operating system of the target platform. In this case, it's set to
'linux' as the component is intended for a Linux-based device.
5. Name: This provides a human-readable name for the platform.
6. Artifacts: This array specifies the URIs of the artifacts (files or Docker images) that the
component requires. These artifacts are downloaded and deployed to the device during
component creation.
○ Uri: The URI of the artifact. It can point to an S3 bucket or a Docker registry.
7. Lifecycle: This section defines the lifecycle configuration for the component, specifying the
actions that should be taken when the component is deployed and run.
○ Run: This subsection defines the actions to be performed when the component is run.
 ■ Script: The script to be executed. In the example, it's a shell script that pulls the
required Docker images and runs them using Docker Compose.
■ RequiresPrivilege: This flag indicates whether the script requires elevated privileges
to execute. In this case, it's set to true as the script needs to run Docker commands.

Example:

JSON

{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "EdgeAITools-myDevice",
"ComponentVersion": "1.0.0",
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Name": "Linux",
"Artifacts": [
{
"Uri":
"s3://sagemaker-us-east-1-903372721275/EdgeAITools/docker-compose.yml"
},
{
"Uri": "docker:903372721275.dkr.ecr.us-east-
1.amazonaws.com/mtk_edge_app_backend:latest"
},
{
"Uri": "docker:903372721275.dkr.ecr.us-east-
1.amazonaws.com/mtk_edge_app_dlstreamer:latest"
},
{
"Uri": "docker:903372721275.dkr.ecr.us-east-
1.amazonaws.com/mtk_edge_app_frontend:latest"
}
],
"