.NET Fest 2019. Alex Pshul. When IoT Meets Serverless

@AlexPshul
When IoT Meets Serverless
From Design to Production and Monitoring
Alex Pshul
Software Architect & Consultant
@AlexPshul
alex@pshul.com
http://pshul.com
http://codevalue.net

@AlexPshul
About Me
Alex Pshul
 Architect, Consultant and lecturer
 More than 9 years of hands on experience
 Talk to me about:
 Software Development
 Hardware and Gadgets
 Gaming
 Animals

@AlexPshul
CodeValue is great! But…

@AlexPshul
Traditional Architecture
Devices communicators
WebApp
Service A
Load balancer
Service B Service C
Backend Services
Storage

@AlexPshul
How About Serverless? WebApp

@AlexPshul
Serverless
Save time and money

@AlexPshul
Time & Money
 Pay per use
 Don’t worry about server management
 Quicker time to release
 Faster to deploy new functionality
 Don’t have to manage scaling and load balancing
 Focus on business logic instead of servers and boilerplate.
 Inherent Auto-Scalability

@AlexPshul
When to Serverless
 Logic can be disassembled into small modules
 Irregular Workloads
 Hard to predict load peaks
 Run closer to the user
 Kyiv to USA
 Kyiv to China

@AlexPshul
When not to Serverless
 Latency is important
 A consistently high and predictable workload
 Long running tasks that can’t be split into sub-tasks or multiple cycles
 Complex computing with high memory/CPU requirements.

@AlexPshul
Migrating to Serverless WebApp

@AlexPshul
Compute - FaaS
 FaaS – Function as a Service
 First mentioned by D. J. Wheeler in 1952- ‘The use of sub-routines in programmes’.
 Event-Driven serverless compute
 Examples:
 Azure Functions
 AWS Lambda
 Google Cloud Functions

@AlexPshul
FaaS – Azure Functions
 Trigger Oriented
 Input & Output Binding
 Dependency Injection
 Tackle Cold-Start performance hits by leaving host loaded
 Premium Plan
 AppService Plan
 Supports several frameworks and languages
 C#, JavaScript, Java, Python, F#, PowerShell & TypeScript

@AlexPshul
FaaS – Azure Functions

@AlexPshul
FaaS - Azure Functions
[FunctionName("EchoFunc")]
public static Task<IActionResult> EchoFunc(
[HttpTrigger(AuthorizationLevel.Anonymous, "get")]
HttpRequest request,
ILogger log)
{
string message = request.Query["message"];
//Do Something
var result = new OkObjectResult($"Message received: {message}");
return Task.FromResult((IActionResult) result);
}

@AlexPshul
FaaS – Azure Functions - Deployment
 Different ways to deploy your functions
 Visual Studio
 Using FTP
 Uploading a zip
 Continues deployment
 GitHub
 Dropbox
 Azure DevOps
 More…

@AlexPshul
Events
 Process a high number of events per second
 Decouple communication between components
 Store and transform events
 Integrate with other services

@AlexPshul
Events – Azure EventHub
 Can receive and process millions of events per second
 Support Apache Kafka clients
 Integrate with other azure services
 Provide SDKs for several frameworks
 .Net, Node.js, Java, Python, Go, C, Apache Storm
 Enable capturing and storing events
 Partitioning

@AlexPshul
Events – Azure EventHub

@AlexPshul
Communication
 Real-time
 Bi-directional
 Scale
 Secure

@AlexPshul
Communication – SignalR Service
 Fully managed
 Cross Platform
 Easily integrated with other Azure resources
 Such as Azure Functions
 Provides abstractions
 WebSockets, Long Polling or Server-sent events (SSE)
 Send message to all or to a subset of users

@AlexPshul
Integration
[FunctionName("UpdateUsers")]
public static Task OnDeviceUpdated(
[EventHubTrigger("device-updates", Connection = "EventHubConnectionAppSetting")] EventData myEventHubMessage,
[SignalR(HubName = "updates")]IAsyncCollector<SignalRMessage> signalRMessages,
ILogger log)
{
string message = Encoding.UTF8.GetString(myEventHubMessage.Body);
//Do something
return signalRMessages.AddAsync(new SignalRMessage
{
Target = "updateReceived",
Arguments = new[] { message }
});
}

@AlexPshul
IoT
Avoid reinventing the wheel

@AlexPshul
Do Not Reinvent the Wheel
D2C
Messages
C2D
Messages
Devices
Management
Security
Message
Routing
Deployment

@AlexPshul
IoT Hub
 One of Microsoft`s PaaS solutions for building IoT solutions
 Provides the infrastructure for working with devices
 Most of the work is defining the devices and coding
 SDKs for various languages (.NET, Java, Node.js, Python, C, iOS)
 Exposes various endpoints
 Integration with other Azure services

@AlexPshul
IoT Hub - Tiers
 Each tier has 3 paid editions
 Each tier provides higher throughput
 Makes the service more expensive
 Basic tier
 Limited features
 Cheaper (compared with same standard tier edition)
 Standard tier
 All features are available
 More expensive (compared with same basic tier edition)
 Contains a free edition
 Standard Free edition
 1 free IoT Hub allowed per subscription
 Encourages PoC projects
 Same features as the Standard tier (Not same throughput)

@AlexPshul
Device to Cloud Messages
 Send device telemetry to the cloud
 Using an SDK
 Send a message directly using a protocol
 MQTT (+ over WebSocket)
 AMQP (+ over WebSocket)
 HTTPS
 Uses a connection string to identify the device in the IoT Hub
 Stored by IoT Hub, up to 7 days
 Up to 256-KB messages
 Frequency depends on the selected IoT Hub edition

@AlexPshul
Device to Cloud Messages
static async Task Main(string[] args)
{
// Initialize the device client object
DeviceClient deviceClient =
DeviceClient.CreateFromConnectionString("Device_Connection_String");
// Create the message
var data = new { Temperature = 30, Humidity = 37 };
var messageString = JsonConvert.SerializeObject(data);
Message message = new Message(Encoding.ASCII.GetBytes(messageString));
// Send the message
await deviceClient.SendEventAsync(message);
}

@AlexPshul
D2C
Messages
C2D
Messages
Devices
Management
Security
Message
Routing
Deployment
D2C
Messages

@AlexPshul
Cloud to Device Messages – Regular Messages
 Not awaited
 Stored in the device queue
 If queue is full (>50) - results in an error
 Can Reject or Abandon messages (unless MQTT)
 Can set feedback for each message

@AlexPshul
Cloud to Device Messages
{
DeviceClient deviceClient =
DeviceClient.CreateFromConnectionString("Device_Connection_String");
// Read message
Message receivedMessage = await deviceClient.ReceiveAsync();
string messageString = Encoding.ASCII.GetString(receivedMessage.GetBytes());
Console.WriteLine($"Received message: {messageString}");
// Acknowledge completion
await deviceClient.CompleteAsync(receivedMessage);}
}
Device

@AlexPshul
{
// Initialize the service client object
ServiceClient serviceClient =
ServiceClient.CreateFromConnectionString("Service_Connection_String");
// Create the message
byte[] messageBytes = Encoding.ASCII.GetBytes("Cloud to device message.");
Message message = new Message(messageBytes);
// Send to a specific device
await serviceClient.SendAsync("myDeviceId", message);
}
Backend

@AlexPshul
Cloud to Device Messages – Direct Methods
 Initiate an action on the device
 Receive immediate response
 Response contains
 Status Code
 Payload

@AlexPshul
{
DeviceClient deviceClient = DeviceClient.CreateFromConnectionString("Device_Connection_String");
// Register Method
await deviceClient.SetMethodHandlerAsync("GetData", GetData, null);
}
private static Task<MethodResponse> GetData(MethodRequest request, object userContext)
{
string someData = "My Cool Response!";
byte[] dataBytes = Encoding.ASCII.GetBytes(someData);
MethodResponse response = new MethodResponse(dataBytes, 200);
return Task.FromResult(response);
}
Device

@AlexPshul
{
// Initialize the service client object
ServiceClient serviceClient =
ServiceClient.CreateFromConnectionString("Service_Connection_String");
// Create method object
var methodInvocation = new CloudToDeviceMethod("GetData");
methodInvocation.SetPayloadJson("10");
// Invoke the direct method asynchronously and get the response from the simulated device.
CloudToDeviceMethodResult response =
await serviceClient.InvokeDeviceMethodAsync("MyDotnetDevice", methodInvocation);
Console.WriteLine($"Status: {response.Status}. Payload: {response.GetPayloadAsJson()}");
}
Backend

@AlexPshul
C2D
Messages
Devices
Management
Security
Message
Routing
Deployment
D2C
Messages
C2D
Messages

@AlexPshul
Devices Management – Twin Properties
 Devices can have states
 No feedback, unless subscribing to IoT Hub messages
 Desired Properties
 C2D
 Shouldn’t represent device state
 Reported Properties
 D2C
 Should reflect the current device state

@AlexPshul
Devices Management – Query Devices
 Devices can be queried
 Example: Get only the devices that were installed today
 Supports queries by twin properties as well
 Built in functions that allow more complex scenarios
 Simple example
 SELECT * FROM devices
 Returns all devices and their data

@AlexPshul
Devices Management – Device Provisioning Service
 Zero-Touch Provisioning
 Single IoT Hub
 Multitenancy
 Solution Isolation
 Geo-Sharding
 Much more scenarios…

@AlexPshul
Devices Management – Device Provisioning Service
Enrollment List
Device Provisioning ServiceDevice IoT Hub

@AlexPshul
C2D
Messages
Devices
Management
Security
Message
Routing
Deployment
D2C
Messages
Devices
Management

@AlexPshul
Security
 Uses permissions to grant access to each IoT Hub endpoint
 RegistryRead
 RegistryReadWrite
 ServiceConnect
 DeviceConnect
 X.509 certificates
 Existing device certificate
 CA-signed certificate
 Self-generated and self-signed certificate

@AlexPshul
Security – Custom device authentication
 Use the identity registry to configure credentials

@AlexPshul
C2D
Messages
Devices
Management
Security
Message
Routing
Deployment
D2C
Messages
Security

@AlexPshul
Message Routing
 Messages have a common format across protocols
 Routes send messages to different endpoints based on a query
 IoT Hub handles routing duplication
 Supports various endpoint types
 Built-in endpoint
 Azure Blob Storage
 Service Bus Queues and Service Bus Topics
 Event Hubs

@AlexPshul
Message Routing – Built-in endpoint & Event Hubs
 The Build-in endpoint is just like any other Event Hub endpoint
 Monitor build-in endpoint messages using Azure IoT Hub Toolkit extension
for VS/VS Code
 Stops receiving messages when another route is created
 Unless a route to the default endpoint is created explicitly
 Can add other Event Hubs for different routes

@AlexPshul
Message Routing – Azure Blob Storage
 Writes batches of data to the blob storage
 When size is reached
 When a certain time windows has passed
 Supports AVRO format only
 JSON format available as a preview
(Not supported in East US, West US and West Europe)
 A file is created for each batch of data

@AlexPshul
Message Routing – Service Bus Queues and Topics
 Session and Duplicate Detection must be disabled
 Endpoint will appear as unreachable if above is not met

@AlexPshul
C2D
Messages
Devices
Management
Security
Message
Routing
Deployment
D2C
Messages
Message
Routing

@AlexPshul
Demo
IoT Hub
Device Deployment
*Show a picture of IoT Hub*

@AlexPshul
Monitoring
Full Solution

@AlexPshul
The Problem
 It is hard to debug remote resources
 Applications are built of small little modules
 Resources can be created and disposed of according to scale
 A monitoring approach is easier to achieve
 And is needed in any case

@AlexPshul
Monitor – Azure Functions
 Logging is your friend
 An ILogger object can be injected to your function
 Use Application Insights to view logs

@AlexPshul
Integration
[FunctionName("UpdateUsers")]
public static Task OnDeviceUpdated(
[EventHubTrigger("device-updates", Connection = "EventHubConnectionAppSetting")] EventData myEventHubMessage,
[SignalR(HubName = "updates")]IAsyncCollector<SignalRMessage> signalRMessages,
ILogger log)
{
log.LogDebug($"Body received with {myEventHubMessage.Body.Count} bytes");
string message = Encoding.UTF8.GetString(myEventHubMessage.Body);
log.LogInformation($"Message Extracted: {message}");
//Do something
return signalRMessages.AddAsync(new SignalRMessage
{
Target = "updateReceived",
Arguments = new[] { message }
});
}

@AlexPshul
Demo
End-to-end
scenario

@AlexPshul
Serverless Architecture WebApp

@AlexPshul
Summary
 Exists on all major cloud providers
 Serverless is not always the option
 But very useful
 Saves money and time
 IoT solutions are available as PaaS
 Don’t reinvent the wheel
 Debugging is not easy, but it is possible
 Monitoring is your friend

Alex Pshul
Software Architect & Consultant
@AlexPshul
alex@pshul.com
http://pshul.com
http://codevalue.net

.NET Fest 2019. Alex Pshul. When IoT Meets Serverless

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

Similaire à .NET Fest 2019. Alex Pshul. When IoT Meets Serverless

Similaire à .NET Fest 2019. Alex Pshul. When IoT Meets Serverless (20)

Plus de NETFest

Plus de NETFest (20)

Dernier

Dernier (20)

.NET Fest 2019. Alex Pshul. When IoT Meets Serverless