.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

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (19)

Ähnlich wie .NET Fest 2019. Alex Pshul. When IoT Meets Serverless

Ähnlich wie .NET Fest 2019. Alex Pshul. When IoT Meets Serverless (20)

Mehr von NETFest

Mehr von NETFest (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

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