AWS IoT Core Getting Started Guide

Overview

The ALPON X4 is an industrial-grade edge computing device based on the Raspberry Pi platform, designed for reliable IoT deployments. Featuring LTE connectivity, eSIM support, and multi-level network redundancy, it ensures secure data transmission in challenging conditions. Its open architecture supports seamless application integration, while a cloud-based suite enables remote access, device monitoring, and fleet management. Ideal for industrial and IoT applications, the ALPON X4 meets diverse needs across various sectors.

The hardware walkthrough in this guide describes the ALPON X4 kit. The AWS account, provisioning, build, deployment, and verification steps are the same on ALPON X5 AI and ALPON X4: both run arm64 containers managed through ALPON Cloud.

Document information

Hardware

Datasheet

The datasheet and all information about ALPON X4 can be found in the Sixfab ALPON X4 Product Sheet.

Standard kit contents

The standard ALPON X4 shipping kit includes the following hardware components:

Third-party purchasable items

The following third-party products for ALPON X4 are available for purchase:

Additional hardware references

All additional hardware and software related documents are available in the ALPON X4 documentation.

1. 1

   Set up your development environment

   Tools installations (IDEs, toolchains, SDKs)

   ALPON X4 does not require any specific SDK, IDE, or toolchain for application development. It is designed to operate in a container-based environment, and while containerization is optional, we strongly recommend containerizing applications and deploying them through the ALPON Cloud platform for ease of deployment and management. However, applications can still be developed and run directly on the device without containers if preferred. The only critical requirement is that your application must be properly containerized for the ARM64 architecture and the container must run seamlessly on the target hardware, such as an ARM64-based development board or server.

   IDE-based development · supported IDEs Not applicable, as the device does not require a specific IDE for development.

   IDE-based development · IDE setup instructions Not applicable.

   IDE-based development · SDK integration with IDE Not applicable.

   CLI based (e.g. CMake) Not applicable.

   Required toolchains Not applicable. ALPON X4 does not require a specific toolchain for development.

   Specific compiler options ALPON X4 has the arm64 architecture. Applications must support arm64, and compilers must compile applications for the arm64 architecture.
2. 2

   Set up the device hardware

   Box content

   1. ALPON X4 Micro Edge Computer
   2. USB Type-C Power Adapter (27W PD) with Plug Adapters (x4)
   3. Screw Terminal Block

   Contents vary by variant

   Please note that contents may vary by product variant, including differences in RAM, storage, PoE availability, and Wi-Fi features.

   

   Layout

   

   

   1. User Programmable Push Button (PB1)
   2. 4x LED
   3. USB Type-C PD Power Input
   4. Screw Terminal Power Input (9-30V DC)
   5. Display (HDMI 2.0 port)
   6. 2x USB 2.0 Port

   

   7. Watchdog, Boot/Burn Switches
   8. User Programmable Push Button (PB2)
   9. 100 Mbps Ethernet Port
   10. 1 Gbps Ethernet Port*
   11. GPIO Port

   * PoE-enabled variants

   On PoE-enabled variants, PoE+ adds power on the same 1 Gbps ETH/G data port; it does not replace Ethernet data. The 100 Mbps ETH port is data-only.

   12. Mounting Hole — Our product features 2x 4mm mounting holes. For industrial applications, these can be used to attach the device to a DIN rail with the appropriate accessories. For other uses, such as wall mounting, the necessary accessories can be purchased, and these holes can be utilized for secure installation. For more details on mounting options, please refer to the Accessories page.

   

   13. Antennas

   

   14. Passive Cooling Case

   Device registration

   Register the device by scanning the QR code on its bottom label or by entering the serial number manually in ALPON Cloud. Registration links the device to your account; activation is a separate step.

   Scanning the QR code

   • Locate the QR code on the bottom of the ALPON X4 and scan it using your device's camera.
   • After scanning, you will be automatically redirected to the ALPON Cloud website.
   • Log in to ALPON Cloud.
   • After logging in, your device will be automatically registered to your account.

   Manual registration (alternative)

   • Log in to ALPON Cloud.
   • Navigate to Assets → + Register Asset.

   

   • Enter your ALPON X4's serial number.

   

   • Complete the registration process by clicking the Register button.

   Activating the asset

   • After registering the asset, navigate to the Assets section.
   • Locate the registered device in the list.
   • Click the Details button for that asset.
   • Set the Active / Inactive toggle at the top right to Active.

   

   Power connection

   Connect the supported USB-C PD adapter (15 V, 1.8 A, 27 W). Boot and provisioning time depend on the network; use the Connection LED and ALPON Cloud status rather than a fixed timer.

   

   For more information on the available power options for this device, please refer to the Technical Details — Power section.

   Ready to use

   The Connection LED is green when the device is connected to ALPON Cloud and off when disconnected. The Cellular LED reports modem state. See Physical Layout & I/O for the complete LED reference.

   

   Device update

   After successfully registering your device, it is recommended to check for updates to ensure optimal performance.

   • Log in to your ALPON Cloud account and navigate to the Assets section.
   • Select your device from the list and go to the Device tab.
   • In the Device Maintenance section, click the Update Device button.

   Follow the prompts to install any updates to keep your device running with the latest features and improvements.

   Application deployment on ALPON

   For optimal performance and scalability, we strongly recommend encapsulating your applications within Docker containers and managing them via ALPON Cloud. This approach not only ensures the highest level of reliability but also facilitates seamless scaling. By using Docker containers, you isolate your application environment, streamline deployment processes, and enhance operational consistency across different devices.

   By adopting this method, you benefit from:

   • Enhanced reliability: Containerized applications are less likely to interfere with one another, which significantly reduces the risk of system-wide failures.
   • Scalability: Effortlessly scale your operations by managing multiple container instances across several devices without the need for extensive configuration adjustments.
   • Maintainability: Simplify updates and maintenance with minimal disruption to your existing operations, ensuring continuous service availability.

   We encourage you to leverage the ALPON platform’s capabilities to maximize the effectiveness and efficiency of your application deployments.

   After the device registration, to deploy and manage your own application, go to the Deploy Applications page for instructions. It covers setting up and running container-based applications on the ALPON. Sixfab Field Application Engineers are always open to help you with your software containerization. Please contact our support team if you need assistance.

3. 3

   Set up your AWS account and permissions

   If you do not have an existing AWS account and user, refer to the online AWS documentation at Set up your AWS Account. To get started, follow the steps outlined in the sections below:

   • Sign up for an AWS account
   • Create an administrative user
   • Open the AWS IoT console

   Pay special attention to the Notes.

4. 4

   Create resources in AWS IoT

   Refer to the online AWS documentation at Create AWS IoT Resources. Follow the steps outlined in these sections to provision resources for your device:

   • Create an AWS IoT Policy
   • Create a thing object

   Pay special attention to the Notes.

5. 5

   Provision the device with credentials

   The device can be provisioned using multiple approaches. For AWS IoT Core integration, we recommend downloading only the necessary certificate files specific to AWS IoT Core. After downloading the files to the device, we will use them while deploying through ALPON Cloud. Therefore, make sure to save the full file paths for reference.

   Getting a shell on the device

   To connect to the device, use the Open Remote Terminal button on the relevant asset in ALPON Cloud to obtain an SSH terminal. You can then perform your operations directly from there.

   Obtain AWS IoT Core certificates

   1. Navigate to the AWS IoT Core Console.
   2. Create a new device (Thing) and generate certificates.
   3. Download the following files:
      • Device Certificate (.pem.crt)
      • Private Key (.pem.key)
      • Amazon Root CA Certificate

   Load certificates onto the device

   1. Transfer the downloaded certificate and key files to the device.
   2. Create a directory and store the certificate files in it (e.g., /etc/aws-iot/).
6. 6

   Build the demo

   This step builds a Docker container that enables the device to communicate with AWS IoT Core. It is run on a personal computer, not on the ALPON. Docker Buildx must be pre-installed on your personal computer.

   Create the example Python file

   Create an example.py file with the following content:

   example.py

   import sys
   import os
   import random
   import time
   import string
   from awscrt import io, mqtt, auth, http
   from awsiot import mqtt_connection_builder
   import uuid
   
   endpoint = os.environ.get("ENDPOINT", "")
   cert_filepath = os.environ.get("CERT_FILENAME", "/certs/certificate.pem.crt")
   key_filepath = os.environ.get("KEY_FILENAME", "/certs/private.pem.key")
   ca_filepath = os.environ.get("CA_FILENAME", "/certs/AmazonRootCA1.pem")
   client_id = os.environ.get("CLIENT_ID", "alponx4_thing")
   
   mqtt_connection = mqtt_connection_builder.mtls_from_path(
       endpoint=endpoint,
       cert_filepath=cert_filepath,
       pri_key_filepath=key_filepath,
       ca_filepath=ca_filepath,
       client_id=client_id,
       clean_session=True,
       keep_alive_secs=60
   )
   
   print(f"Connecting to {endpoint} with client ID '{client_id}'...")
   connect_future = mqtt_connection.connect()
   
   try:
       connect_future.result(10)
       print("Connected!")
   except Exception as e:
       print(f"Connection failed: {e}")
       sys.exit(1)
   
   def generate_random_message():
       message = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
       return '{"random_message":"' + message + '"}'
   
   topic = os.environ.get("TOPIC", "demo/test")
   
   try:
       while True:
           message = generate_random_message()
           print(f"Publishing message: {message}")
   
           publish_future = mqtt_connection.publish(
               topic=topic,
               payload=message,
               qos=mqtt.QoS.AT_LEAST_ONCE
           )
           time.sleep(5)
   except KeyboardInterrupt:
       print("Terminating...")
   except Exception as e:
       print(f"An error occurred: {e}")
   finally:
       # Disconnect
       try:
           disconnect_future = mqtt_connection.disconnect()
           disconnect_future.result()
           print("Disconnected successfully.")
       except Exception as e:
           print(f"Disconnect error: {e}")

   Create the Dockerfile

   Create a Dockerfile with the following content:

   Dockerfile

   FROM alpine:latest
   
   RUN apk update && apk add python3 py3-pip wget
   
   WORKDIR /app
   COPY ./example.py /app
   RUN python3 -m pip install awsiotsdk --break-system-packages
   CMD python3 example.py

   Build the Docker image

   1. Navigate to the directory containing the Dockerfile and example.py file, then build the image for arm64:

   bash · build the image

   cd /path/to/folder
   docker buildx build --platform=linux/arm64 -t aws-iot-demo .

   2. In ALPON Cloud, navigate to the Registry tab of your asset.
   3. Click + Add Container and follow the prompts to add the image you just built to your registry.
7. 7

   Run the demo

   Access the device interface

   1. Go to ALPON Cloud.
   2. Navigate to the Applications tab of your asset and select Deploy App.

   Deployment configuration

   In the Deploy App window, configure the deployment as follows:

   Container Name awstest

   Image Select the image and tag of the AWS IoT test container you pushed to the registry.

   Environments Add the six variables in the table below. Replace the placeholder values with your own AWS IoT Core endpoint, topic, client ID, and certificate file names.

   Volumes Mount the certificate folder you created in step 5 to /certs (second table below).

   Key	Value
   ENDPOINT	AWS_IOT_CORE_ENDPOINT
   TOPIC	ExampleTopicName
   CLIENT_ID	ALPONX4_Client
   CA_FILENAME	/certs/CACertFileName.pem
   CERT_FILENAME	/certs/CertFileName.pem.crt
   KEY_FILENAME	/certs/PrivateKeyFileName.pem.key

   Read/Write	From	To
   Read/Write	/path/to/your/cert/folder/on/alpon	/certs

   Certificate paths are container paths

   example.py reads CA_FILENAME, CERT_FILENAME, and KEY_FILENAME as paths inside the container, so they must start with the volume target /certs/. If you leave them unset, the script falls back to /certs/AmazonRootCA1.pem, /certs/certificate.pem.crt, and /certs/private.pem.key — name your files accordingly or set the variables.

   Click Deploy to start the container on the device.

8. 8

   Verify messages in AWS IoT Core

   To verify that your demo works successfully by observing the MQTT messages received by AWS IoT Core, use the IoT Core MQTT test client:

   1. Log in to the AWS Management Console
      • Go to the AWS Management Console.
      • Navigate to IoT Core.
   2. Navigate to the MQTT test client
      • In the left-hand sidebar, under Test, click MQTT test client. This opens the MQTT test interface where you can send and receive MQTT messages.
   3. Get your MQTT client endpoint
      • In the MQTT test client tab, click Connection details.
      • Copy the Endpoint (xxxxxx.iot.<region>.amazonaws.com). This is the value for the ENDPOINT environment variable.
   4. Subscribe to the topic
      • In the Topic field, type the topic name that your demo is using to publish messages (the TOPIC environment variable), for example demo/topic.
      • Click Subscribe. This allows you to receive messages published to that topic.
   5. Observe the incoming MQTT messages
      • If your demo is successfully publishing messages to the topic, they appear in the Message log section after the test client receives them.
      • Verify that the message format and content match the expected output of your demo.
   6. Verify the demo
      • If you see the messages in the MQTT test client, your demo is working: it is sending and receiving MQTT messages via AWS IoT Core.

Troubleshooting

Common failure modes when connecting the demo container to AWS IoT Core, and how to resolve each.

chmod 644 /path/to/certificate.pem.crt
chmod 600 /path/to/private.pem.key
chmod 644 /path/to/AmazonRootCA1.pem

You can find more information in the AWS IoT troubleshooting guide.

ALPON X4 box content.

ALPON X4 layout — front view.

ALPON X4 layout — display and USB side.

ALPON X4 layout — Ethernet and GPIO side.

ALPON X4 layout — mounting holes.

On the side of the antennas, G is for GNSS, W is for Wi-Fi, and L (x2) is for LTE.

Assets → + Register Asset in ALPON Cloud.

The serial number (S/N) is on the bottom of the device.

Activating the asset from its Details page.

Powering the ALPON X4 from the USB-C PD adapter.

The Connection LED turns green once the device is online in ALPON Cloud.