Using azure-native logic with netapp

Question

Pulumi · Accepted Answer

To integrate Azure-native logic with NetApp using Pulumi, you would typically create a workflow that involves operations on NetApp resources such as creating volumes, snapshots, or backup policies. Azure Logic Apps is a cloud service that helps you schedule, automate, and orchestrate tasks, business processes, and workflows when you need to integrate apps, data, systems, and services across enterprises or organizations.

In this example, we will create a simple workflow with Azure Logic Apps that triggers on a schedule to create a snapshot of a NetApp volume. The steps include creating an Azure NetApp account, a capacity pool, and a volume where snapshots will be taken according to a recurring Logic Apps workflow.

Let's start with creating a NetApp account, capacity pool, and volume using the azure-native/netapp resources. After that, we'll set up an Azure Logic Apps workflow using azure-native.logic.Workflow to automate snapshot creation.

Here's the TypeScript program that demonstrates these actions:

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

// Create a resource group if not already existing
const resourceGroup = new azure_native.resources.ResourceGroup("myResourceGroup", {
    location: "westus", // Replace with your desired location
});

// Create an Azure NetApp Files account
const netappAccount = new azure_native.netapp.Account("myNetappAccount", {
    accountName: "my-unique-netapp-account-name",
    location: resourceGroup.location,
    resourceGroupName: resourceGroup.name,
});

// Create a capacity pool within the NetApp account
const pool = new azure_native.netapp.Pool("myCapacityPool", {
    poolName: "mypool",
    location: resourceGroup.location,
    accountName: netappAccount.name,
    resourceGroupName: resourceGroup.name,
    size: 4398046511104, // 4 TiB - Change as required
    serviceLevel: "Premium", // Change as required (Standard/Premium/Ultra)
});

// Create a volume within the capacity pool
const volume = new azure_native.netapp.Volume("myVolume", {
    volumeName: "myvolume",
    location: resourceGroup.location,
    accountName: netappAccount.name,
    poolName: pool.name,
    resourceGroupName: resourceGroup.name,
    usageThreshold: 107374182400, // 100 GiB - Change as required
    creationToken: "my-unique-creation-token",
    subnetId: "/subscriptions/<subscription-id>/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/myVnet/subnets/mySubnet",
    // Replace with actual VNet and subnet IDs
});

// Create a Logic App Workflow to trigger snapshot creation on a schedule
const workflow = new azure_native.logic.Workflow("myNetappWorkflow", {
    location: resourceGroup.location,
    resourceGroupName: resourceGroup.name,
    workflowName: "my-workflow",
    definition: {
        "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
        "actions": {
            "Create_NetApp_Snapshot": {
                "type": "ApiConnection",
                "inputs": {
                    "host": { "connection": { "name": "azurenetappfiles" } }, // Connection reference to Azure NetApp Files
                    "method": "post",
                    "body": {
                        "location": volume.location,
                        // More properties for snapshot creation can be added here
                    },
                    "path": `/subscriptions/${pulumi.interpolate
                      (resourceGroup.id)}/resourceGroups/${resourceGroup.name}/providers/Microsoft.NetApp/netAppAccounts/
                      ${netappAccount.name}/capacityPools/${pool.name}/volumes/${volume.name}/snapshots/`, 
                    "authentication": "@parameters('$connections')['azurenetappfiles']['connectionId']" // Authentication details for ANF API
                },
                "runAfter": {}, // This would be populated if you want it to run after another action
            },
        },
        "triggers": {
            "Recurrence": {
                "type": "Recurrence",
                "recurrence": {
                    "frequency": "Day",
                    "interval": 1, // Trigger daily; modify as needed
                },
            },
        },
        "contentVersion": "1.0.0.0",
        "outputs": {},
    },
    // Parameters not listed can be added as needed, such as connections and integration account references
});

// Export the required outputs
export const resourceGroupName = resourceGroup.name;
export const netappAccountName = netappAccount.name;
export const poolName = pool.name;
export const volumeName = volume.name;
export const workflowName = workflow.name;

In the above program, we define several resources:

Resource Group: We first define a resource group, which is a container that holds related resources for an Azure solution.
NetApp Account: Next, we create a NetApp account within the resource group. The account is an Azure NetApp Files resource that serves as a management boundary.
Capacity Pool: We then create a capacity pool which serves as an allocation pool of storage capacity within a NetApp account.
NetApp Volume: Within the capacity pool, we create a volume that represents a scalable and secure file storage volume.
Logic App Workflow: Finally, we define a Logic App Workflow resource. The workflow includes a trigger that runs on a specified schedule (e.g., daily) and defines an action that performs the API call to create a snapshot of the NetApp volume.

The workflow uses a Logic Apps standard definition structure where you set the type of trigger, action details, and the action path to the Azure NetApp Files service we aim to invoke. The authentication and connectionId would need to be appropriately set up based on your Azure environment to authenticate to the Azure NetApp Files API.

Remember to replace placeholders such as <subscription-id> with your actual Azure Subscription ID and other parameters with valid values appropriate for your environment.

This program provides a foundational workflow that can be extended or refined to meet more complex NetApp operational needs with Logic Apps, such as handling snapshot lifecycle, managing data protection, and orchestration of multiple resources.