Using azure logicapps with relay

Question

Pulumi · Accepted Answer

To integrate Azure Logic Apps with Azure Relay, you would typically utilize Azure Relay's Hybrid Connections as a bridge between your Logic Apps and your on-premise services, allowing for secure communication without opening up a public endpoint or changing your firewall configuration.

Here’s a step-by-step explanation of how you can set up a Logic App and a Hybrid Connection to enable this integration:

1. **HybridConnection**: This is the Azure Relay resource that you'll be creating. It allows you to securely connect Azure App Services, or Logic Apps, to on-premise services without making any changes to your corporate firewall. It is a sort of secure tunnel from the cloud to your on-premise data center.

2. **Workflow**: This represents your Logic App. A Logic App in Azure is used to automate workflows and business processes. You can use a Logic App to define a series of steps or actions to be taken when a specific trigger is fired.

3. **Integration between Logic Apps and Hybrid Connection**: You can configure the Logic App to listen for events or trigger actions that interact with the services you have on-premise through the Hybrid Connection.

Here's what a simple Pulumi program might look like using TypeScript to set up a Hybrid Connection and a Logic App:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
import * as azureNative from "@pulumi/azure-native";

// Set up an Azure resource group
const resourceGroup = new azure.core.ResourceGroup("resourceGroup");

// Set up a Hybrid Connection inside of the Azure Relay namespace
const namespace = new azureNative.relay.Namespace("namespace", {
    namespaceName: pulumi.interpolate`${resourceGroup.name}-relay-ns`,
    resourceGroupName: resourceGroup.name,
    sku: {
        name: "Standard", // Standard SKU supports Hybrid Connections
        tier: "Standard",
    },
});

const hybridConnection = new azureNative.relay.HybridConnection("hybridConnection", {
    namespaceName: namespace.name,
    resourceGroupName: resourceGroup.name,
    hybridConnectionName: "my-hybrid-connection",
    requiresClientAuthorization: true, // Requires clients to authorize
});

// Define a Logic App workflow to interact with the Hybrid Connection
const logicApp = new azureNative.logic.Workflow("logicApp", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    definition: {
        // Logic Apps definition (JSON format), defining the triggers and actions of your workflow
    }
});

// Output the resource names
export const namespaceName = namespace.name;
export const hybridConnectionName = hybridConnection.name;
export const logicAppName = logicApp.name;
```

In this Pulumi program, a new Azure Relay namespace and a Hybrid Connection are created within a resource group. Then, a Logic App is set up with a simple definition. The specifics of the Logic App definition depend on the actual workflow you're trying to automate, which can include connecting to the Hybrid Connection endpoint.

You'll need to flesh out the Logic Apps definition `logicApp.definition` with the actual steps you want your Logic App to perform. This often involves defining triggers (such as an HTTP request, a schedule, etc.) and actions (such as sending or receiving messages via the Hybrid Connection).

Please adjust the placeholders and values per your actual use-case requirements and note that you may need to set up the on-premise part of the Hybrid Connection, which typically involves installing and configuring the Hybrid Connection Manager on your on-premises network.