Step-by-Step Guide to Sending Telemetry Using Azure Functions and IoT Hub

You can publish telemetry from Azure Functions to IoT Hub using the Azure IoT device SDK. This allows you to track packages, monitor traffic, or predict when machines might fail. To do this, you need a device identity and must keep your connection string secure. Many beginners find device connections and protocol choices challenging, but you will learn these steps with simple instructions.

Key Takeaways

• First, make your Azure account. Then, make an IoT Hub. Register each device with its own name so you can send telemetry.

• Use Azure Functions and the Azure IoT device SDK. Pick the language you like best. Write code to send telemetry data in a safe way.

• Keep your device connection strings safe. Store them in Azure App Settings or Key Vault. Do not put secrets in your code.

• Make telemetry messages in JSON format. Set the right content type. Keep each message smaller than 256 KB to stop errors.

• Test and watch your telemetry with Azure IoT Explorer. You can also use Azure CLI and Azure Portal metrics. This helps you check if data moves the right way.

Prerequisites

Before you start sending telemetry, you need to set up a few things. These steps make sure you have everything ready for a smooth experience.

Azure Account

You need an active Azure account. If you do not have one, you can sign up for a free trial. Azure gives you credits to get started, so you can try out services without spending money right away. Make sure you can log in to the Azure Portal.

💡 Tip: Use a work or school email for easier access to enterprise features.

IoT Hub and Device Identity

You must create an IoT Hub. This is where your telemetry data will go. Each device that sends data needs a unique identity. You will register a device in your IoT Hub and get a connection string for it. Keep this string safe. It lets your Azure Function talk to the IoT Hub as if it were a real device.

Here is a quick look at IoT Hub pricing:

Note: The Standard tier gives you more features like cloud-to-device messaging and device management. Choose the tier that fits your needs and budget.

You will notice that costs go up in steps, not in a straight line. If you plan to send lots of messages, pick your tier carefully.

Tools and SDKs

You need some tools to build and test your solution. Here is what you should have:

• Azure Functions Core Tools: Lets you create and run functions locally.

• Azure CLI: Helps you manage Azure resources from your terminal.

• Azure IoT Device SDK: Choose the SDK for your favorite language (C#, Python, or Node.js).

• Code Editor: Visual Studio Code works well for most people.

Once you have these tools, you are ready to move on to setting up your IoT Hub and device identity.

Set Up IoT Hub

Create IoT Hub

You need to set up your IoT Hub before you can send any telemetry. Here’s how you do it in the Azure portal:

1. Sign in to the Azure portal.

2. On the homepage, select + Create a resource.

3. Pick Internet of Things from the Categories menu, then choose IoT Hub.

4. On the Basics tab, fill in the details:

   • Choose your subscription.

   • Pick or create a resource group.

   • Enter a unique IoT Hub name. It must be 3–50 letters or numbers. You can use dashes.

   • Select the region closest to you.

   • Pick the tier and set your daily message quota.

5. Go to Next: Networking. You can keep the default settings for now.

6. Move to Next: Management. You can accept the default permission settings.

7. Step through Add-ons and Tags. You can leave these as they are.

8. Review your settings on the Review + create tab.

9. Hit Create to deploy your IoT Hub.

10. When it’s done, open your new IoT Hub to check the details.

🛡️ Tip: Always pick a region close to your users for better speed.

Register Device

Now, you need to register a device so your Azure Function can send data. Each device gets a unique ID and its own keys. This helps keep your data safe. Here’s what you do:

• Go to your IoT Hub in the Azure portal.

• Find the IoT devices menu.

• Add a new device. Give it a unique name.

• Choose an authentication type. Most people use a symmetric key, but you can pick X.509 certificates for more security.

• Let Azure auto-generate the keys.

• Save the device.

You can also set up device twins to store extra info about your device. For extra safety, set up IP filters and audit logs to track what happens.

Get Connection String

You need the device connection string to let your Azure Function talk to IoT Hub. Here’s how you find it:

1. In the Azure portal, go to your IoT Hub.

2. Open the IoT devices menu.

3. Click on your device.

4. Look for the Connection String field. Use the copy button to grab it.

The connection string looks like this:

HostName=YourIoTHub.azure-devices.net;DeviceId=YourDevice;SharedAccessKey=YourDeviceKey

⚠️ Note: Keep this string secret. It lets anyone send data as your device. Never share it in public code or with people you don’t trust.

Now you’re ready to build your Azure Function and start sending telemetry!

Build Azure Function

Create Function App

You can build your Azure Function App right from your computer. This app will help you publish telemetry to your IoT Hub. Here’s a simple way to get started:

1. Open Visual Studio Code, Visual Studio, or your terminal.

2. Create a new Azure Functions project. Pick the Event Grid trigger type. This trigger listens for events from your IoT Hub.

3. Add the needed NuGet packages. You want Azure.DigitalTwins.Core, Azure.Identity, and Microsoft.Azure.WebJobs.Extensions.EventGrid.

4. Write your function code. For example, you can make a file called IoTHubtoTwins.cs. This code will grab device data and update Azure Digital Twins.

5. Publish your project to Azure. You can do this from your editor or with the Azure CLI.

6. Turn on system-assigned managed identity for your function app. Give it the right access so it can talk to Azure Digital Twins.

7. Set up an Event Grid event subscription on your IoT Hub. This step sends device telemetry events to your function app.

8. Test your function app. Use a device simulator to send test data and make sure everything works.

🛠️ Tip: Always test with sample data before you go live. This helps you catch problems early.

Configure Settings

Now, you need to set up your function app so it connects to IoT Hub the right way. Follow these steps:

1. Install the Event Hubs extension for your Azure Functions project. Use the right version for your runtime.

2. Update your host.json file to include the extension bundle. Here’s what it might look like:

{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.0.0, 5.0.0)"
  }
}

1. Pick your authentication method. You can use a connection string or set up a managed identity for better security.

2. Make sure your function app uses a supported runtime version. Version 4.x is a good choice.

3. Choose the right binding type for your code. For new projects, use Azure.Messaging.EventHubs.EventData.

When you finish these steps, your function app will be ready to publish telemetry from your devices to IoT Hub. You can now move on to writing the code that sends your data.

Publish Telemetry

You finished setting up your IoT Hub and Azure Function. Now you can send telemetry from your function to the cloud. This section will show you how to write code, keep secrets safe, and send good telemetry messages.

Write Code with SDK

Azure IoT device SDKs help you send telemetry from almost anywhere. You can use different programming languages. Pick the one you like most. Here are some choices:

Let’s look at how to send telemetry with three popular languages.

💡 Tip: Always use the newest SDK for your language. This gives you new features and better security.

C# Example

Here is how you send telemetry in C# with the Azure IoT device SDK:

using Microsoft.Azure.Devices.Client;
using Newtonsoft.Json;
using System;
using System.Text;
using System.Threading.Tasks;

public static async Task SendTelemetryAsync(string connectionString)
{
    var deviceClient = DeviceClient.CreateFromConnectionString(connectionString, TransportType.Mqtt);
    var telemetryData = new
    {
        timestamp = DateTime.UtcNow,
        tag_name = "temperature",
        tag_value = 25
    };
    string messageString = JsonConvert.SerializeObject(telemetryData);
    var message = new Message(Encoding.UTF8.GetBytes(messageString));
    message.ContentType = "application/json";
    message.ContentEncoding = "utf-8";
    await deviceClient.SendEventAsync(message);
    Console.WriteLine("Telemetry sent!");
}

Python Example

You can also send telemetry in Python. Here is a simple example:

from azure.iot.device import IoTHubDeviceClient, Message
import json
import random
import datetime

def send_telemetry(connection_string):
    client = IoTHubDeviceClient.create_from_connection_string(connection_string)
    temperature = 20 + random.random() * 10
    humidity = 60 + random.random() * 10
    telemetry = {
        "timestamp": datetime.datetime.utcnow().isoformat(),
        "temperature": temperature,
        "humidity": humidity
    }
    msg = Message(json.dumps(telemetry))
    msg.content_encoding = "utf-8"
    msg.content_type = "application/json"
    if temperature > 30:
        msg.custom_properties["temperatureAlert"] = "true"
    else:
        msg.custom_properties["temperatureAlert"] = "false"
    client.send_message(msg)
    print("Telemetry sent!")

Node.js Example

You can use Node.js to send telemetry too. Here are the main steps:

• Install the azure-iot-device and azure-iot-device-mqtt packages.

• Make a client with your connection string.

• Build a message and send it.

const { Client, Message } = require('azure-iot-device');
const { Mqtt } = require('azure-iot-device-mqtt');

function sendTelemetry(connectionString) {
    const client = Client.fromConnectionString(connectionString, Mqtt);
    const telemetry = {
        timestamp: new Date().toISOString(),
        temperature: 22 + Math.random() * 8,
        humidity: 55 + Math.random() * 10
    };
    const message = new Message(JSON.stringify(telemetry));
    message.contentEncoding = "utf-8";
    message.contentType = "application/json";
    client.open((err) => {
        if (!err) {
            client.sendEvent(message, (err) => {
                if (!err) {
                    console.log("Telemetry sent!");
                }
            });
        }
    });
}

Now you can send telemetry from your Azure Function with any of these languages.

Secure Connection String

You must keep your device connection string safe. Never put secrets right in your code. Azure gives you ways to protect your secrets:

• Store connection strings in application settings. Azure keeps these safe and only unlocks them when needed.

• Use Azure Key Vault for even more safety. Key Vault keeps secrets like connection strings, usernames, and passwords.

• Use managed identities if you can. This lets your function connect to other Azure services without saving secrets.

• Lock your local settings file if you work on your own computer.

• Use tools like Terraform or Azure DevOps to handle secrets and deployments.

• Watch your function app with Azure Monitor and Security Center.

Here is how you connect Azure Functions to Key Vault:

⚠️ Note: With this setup, your code never sees the secret. Azure handles the secret for you, so you stay safe.

Send Telemetry Messages

When you send telemetry, you want your messages to be easy to read and use. Azure IoT Hub wants messages in a certain format. Here is what you should know:

• Each message has three parts:

  • System properties: Azure sets these for device identity and security.

  • Application properties: You can add your own key-value pairs here.

  • Message body: This is your telemetry data, usually as a JSON object.

• Always set the content type to application/json;charset=utf-8. This helps Azure know how to handle your messages.

• A good telemetry message looks like this:

{
  "timestamp": "2024-06-01T12:00:00Z",
  "tag_name": "spindle_speed",
  "tag_value": 100
}

• You can add application properties, like alerts, without changing the message body.

• Keep each message under 256 KB. If you need to send more data, split it into smaller messages.

• Your IoT Hub tier sets your daily message limit. If you send too many, you might see errors or slowdowns.

📝 Tip: If you see errors like "ThrottlingException" or "IoTHubUnauthorized," check your message size, daily quota, and connection string.

Now you know how to send telemetry from your Azure Function to IoT Hub. You learned how to write the code, keep secrets safe, and send messages in the right way. This helps you build safe and strong IoT solutions.

Test and Monitor

Verify Telemetry

After you send telemetry from your Azure Function, you need to check if your messages get to IoT Hub. There are a few simple ways to do this.

1. Azure IoT Explorer
   Download Azure IoT Explorer and install it. Open the app and connect it to your IoT Hub with the connection string from the Azure portal. Pick your device from the list. Go to the Telemetry section. Click "Start" to see live messages as they come in. This tool lets you watch your data in real time.

2. Azure CLI
   If you like using the terminal, try Azure CLI. Run this command to see all messages:

az iot hub monitor-events --hub-name YourHubName

1. To see messages from just one device, add the device ID:

az iot hub monitor-events --hub-name YourHubName --device-id YourDeviceId

1. Azure Portal Metrics
   Go to your IoT Hub in the Azure Portal. Under Monitoring, click Metrics. Here, you can see how many messages you get and check if your telemetry is coming in.

💡 Tip: Always use the newest Azure IoT Explorer for the best results.

Troubleshoot Issues

Sometimes things do not work right. If you do not see your telemetry, try these steps:

Check Logs and Insights
Turn on Application Insights for your function app. Use Live Metrics to find problems fast. Set your log level to "Debug" or "Verbose" in the Azure portal for more details. You can also use the Kudu Console to look at logs for deployment and running.

Common Problems Table

Best Practices for Logs

• Use structured logging with the ILogger interface.

• Set log levels to "Warning" or "Error" for normal use. Only use "Debug" if you need more info.

• Do not log private data.

• Use Application Insights to track function runs, failures, and dependencies.

Extra Tips

• Run your function on your computer with Azure Functions Core Tools before you deploy.

• Use deployment slots to test changes safely.

• Set up alerts in Application Insights so you know right away if something fails.

🚦 If you still cannot send telemetry, check your connection strings, device registration, and network settings again. Most problems come from small mistakes in these places.

---

You learned how to set up IoT Hub and make your function. You also learned how to send telemetry and watch your data. Always protect your device credentials so no one else can use them. Here are some ways to keep them safe:

• Use hardware security modules or TPMs to store credentials.

• Pick X.509 certificates instead of shared symmetric keys.

• Make a plan for renewing and managing certificates.

Are you ready to do more? Try making your solution bigger by adding more IoT Hubs. You can use Device Provisioning Service or test with device simulators. You can also connect IoT Hub with Azure Stream Analytics or IoT Edge. This lets you process data right away and make choices close to your devices. If you want to learn more, look at Azure documentation for advanced IoT ideas and services.

FAQ

How do you update your device connection string securely?

Store your connection string in Azure App Settings or Key Vault. Never put it in your code. If you need to change it, update the secret in Key Vault or the setting in Azure. Your function will use the new value right away.

Can you send telemetry from multiple devices with one Azure Function?

Yes, you can. Just loop through your device list and use each device’s connection string. Make sure you keep all connection strings safe. You can use Key Vault to manage them.

What happens if your function sends too many messages?

Azure IoT Hub has daily message limits. If you go over, IoT Hub will throttle your messages. You might see errors or delays. Check your tier and upgrade if you need to send more data.

How do you monitor if your telemetry is working?

You can use Azure IoT Explorer to watch messages in real time. You can also check Azure Portal metrics or use Application Insights for logs and alerts. These tools help you spot problems fast.