---
title: Building Real-Time Applications with PowerShell Azure Functions, Event Grid, and SignalR
description: Realisieren Sie leistungsstarke Echtzeitanwendungen durch die Kombination von PowerShell Azure Functions, Event Grid und SignalR für sofortige Benutzerbenachrichtigungen.
---

[Experts Inside Blog ](https://blog.expertsinside.com/wissen)

# [Building Real-Time Applications with PowerShell Azure Functions, Event Grid, and SignalR](https://blog.expertsinside.com/wissen/building-real-time-applications-with-powershell-azure-functions-event-grid-and-signalr)

 Geschrieben von [Thomas Torggler](https://blog.expertsinside.com/wissen/author/thomas-torggler) | Sep 25, 2025 9:19:47 AM

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.

[Vollständigen Beitrag anzeigen](https://blog.expertsinside.com/wissen/building-real-time-applications-with-powershell-azure-functions-event-grid-and-signalr)

```json
{
  "@context" : "http://schema.org",
  "@type" : "BlogPosting",
  "author" : {
    "@type" : "Person",
    "name" : "Thomas Torggler"
  },
  "dateModified" : "2025-09-25T09:20:57.231Z",
  "datePublished" : "2025-09-25T09:19:47Z",
  "headline" : "Building Real-Time Applications with PowerShell Azure Functions, Event Grid, and SignalR",
  "image" : {
    "@type" : "ImageObject",
    "height" : 1260,
    "url" : "https://7055280.fs1.hubspotusercontent-eu1.net/hubfs/7055280/TTO_BLOG_SEP_2.png",
    "width" : 2240
  },
  "mainEntityOfPage" : "https://blog.expertsinside.com/wissen/building-real-time-applications-with-powershell-azure-functions-event-grid-and-signalr",
  "publisher" : {
    "@type" : "Organization",
    "logo" : {
      "@type" : "ImageObject",
      "height" : 60,
      "url" : "/hs/hsstatic/content_shared_assets/static-1.4092/img/default-amp-logo.png",
      "width" : 60
    },
    "name" : "Experts Inside Blog"
  }
}
```