Building Real-Time Applications with PowerShell Azure Functions, Event Grid, and SignalR

As an IT professional, you’re already familiar with PowerShell for automation and Azure Functions for serverless computing. But did you know you can leverage these same skills to build powerful real-time applications? This post shows how to combine PowerShell Azure Functions with Event Grid and SignalR to create responsive, event-driven systems that notify users instantly when changes occur.

The Power of Event-Driven Architecture

Traditional polling-based solutions are inefficient and create unnecessary load. Instead, we can build an elegant event-driven architecture that reacts instantly to changes:

1. Event Grid detects changes in Azure Storage
2. Azure Functions process events using familiar PowerShell
3. SignalR Service pushes real-time notifications to connected clients

Setting Up Event Grid Storage Triggers

Event Grid makes it easy to subscribe to storage account events. Here’s how to configure blob creation triggers:

Infrastructure as Code (Bicep)

// Event Grid subscription for PDF uploads
resource eventSubscription 'Microsoft.EventGrid/eventSubscriptions@2023-12-15-preview' = {
  name: 'pdf-blob-subscription'
  scope: storageAccount
  properties: {
    destination: {
      endpointType: 'AzureFunction'
      properties: {
        resourceId: functionApp.id
        maxEventsPerBatch: 1
      }
    }
    filter: {
      includedEventTypes: [
        'Microsoft.Storage.BlobCreated'
      ]
      subjectBeginsWith: '/blobServices/default/containers/pdfs/'
      subjectEndsWith: '.pdf'
    }
  }
}

This configuration ensures your function only triggers for PDF files in the specified container, allowing you to process only the events you need.

PowerShell Azure Function: Event Processing

Here’s where your PowerShell expertise shines. The function receives Event Grid events and processes them with PowerShell syntax:

Function Configuration (function.json)

 {
  "bindings": [
    {
      "type": "eventGridTrigger",
      "name": "eventGridEvent",
      "direction": "in"
    },
    {
      "type": "signalR",
      "name": "signalRMessages",
      "hubName": "pdfhub",
      "direction": "out",
      "connectionStringSetting": "AzureSignalRConnectionString"
    }
  ]
}

PowerShell Implementation (run.ps1)

 param($eventGridEvent, $TriggerMetadata)

# Extract blob information from Event Grid event
$blobUrl = $eventGridEvent.data.url
$fileName = Split-Path $blobUrl -Leaf
$containerName = ($blobUrl -split '/')[4]

Write-Host "Processing new PDF: $fileName in container: $containerName"

# Create SignalR message for real-time notification
$signalRMessage = @{
    target = "newPdfUploaded"
    arguments = @(
        @{
            fileName = $fileName
            blobUrl = $blobUrl
            containerName = $containerName
            uploadTime = $eventGridEvent.eventTime
        }
    )
}

# Send to all connected clients
Push-OutputBinding -Name signalRMessages -Value $signalRMessage

SignalR Integration: Real-Time Communication Made Simple

SignalR Service handles the complex real-time communication infrastructure. Your PowerShell function simply pushes messages, and SignalR delivers them to all connected web clients instantly.

Key Benefits for IT Pros

• No WebSocket Management: SignalR handles connections, reconnections, and scaling
• Familiar Output Binding: Use PowerShell’s Push-OutputBinding like any other Azure Function output
• Serverless Scaling: Automatically handles thousands of concurrent connections
• Multiple Client Support: Web browsers, mobile apps, desktop applications

Frontend Integration

On the client side, connecting to SignalR is straightforward:

 const connection = new signalR.HubConnectionBuilder()
    .withUrl("/api")  // Your function app's SignalR endpoint
    .build();

// Listen for new PDF notifications
connection.on("newPdfUploaded", (data) => {
    console.log(`New PDF uploaded: ${data.fileName}`);
    // Update UI in real-time
    updatePdfList(data);
});

await connection.start();

Infrastructure Deployment

Using Azure Verified Modules (AVM), you can deploy the entire infrastructure with a single command:

 az deployment group create \
  --resource-group rg-myapp-prod \
  --template-file main.bicep \
  --parameters workloadName="myapp" environmentName="prod"

Why This Architecture Works for IT Pros

1. Leverage Existing Skills

• Use PowerShell for business logic
• Apply familiar Azure Functions patterns
• No need to learn complex real-time programming

2. Enterprise-Ready

• Built-in authentication and authorization
• Managed identities for secure access
• Automatic scaling and high availability

3. Cost-Effective

• Pay only for what you use
• Event Grid: 0.87€ per million operations
• SignalR Service: Serverless pricing starts free
• Azure Functions: Consumption plan available

4. Monitoring and Debugging

• Application Insights integration
• PowerShell logging you already know
• Event Grid event tracking

Real-World Use Cases

This pattern works excellently for:

• Document Processing: Notify users when reports are ready
• Data Pipeline Updates: Real-time ETL job status
• System Monitoring: Push alerts for critical events
• Collaboration Tools: Live updates in team applications

Conclusion

By combining Event Grid’s event detection, PowerShell Azure Functions’ familiar scripting environment, and SignalR’s real-time capabilities, you can build sophisticated real-time applications without leaving your PowerShell comfort zone. This serverless approach scales automatically, costs only what you use, and leverages the Azure skills you already have.