प्री-प्रोविज़न्ड Function App के अंतर्गत टेम्पलेट HTTP trigger का उपयोग करके नया Function बनाएँ.
मौजूदा फंक्शन कोड बदलें और निम्नलिखित का उपयोग करें:
using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Error "PowerShell HTTP trigger function processed a request."

# Application Insights logging function
function Write-AppInsightsLog {
    param(
        [string]$Message,
        [string]$Level = "Information",
        [hashtable]$Properties = @{}
    )

    # Write to standard log (which goes to App Insights automatically)
    Write-Host "[$Level] $Message"

    # Add custom properties for App Insights
    if ($Properties.Count -gt 0) {
        $propsJson = $Properties | ConvertTo-Json -Compress
        Write-Host "Properties: $propsJson"
    }
}

# Function to create Azure Storage authentication header
function Get-StorageAuthHeader {
    param(
        [string]$StorageAccount,
        [string]$StorageKey,
        [string]$Method,
        [string]$Resource,
        [string]$ContentType = "",
        [int]$ContentLength = 0,
        [switch]$ForBlob
    )

    $date = [System.DateTime]::UtcNow.ToString("R")

    # Build string to sign for Azure Storage REST API
    $stringToSign = $Method + "`n" +                    # HTTP Verb
                   "`n" +                               # Content-Encoding
                   "`n" +                               # Content-Language  
                   $ContentLength + "`n" +              # Content-Length
                   "`n" +                               # Content-MD5
                   $ContentType + "`n" +                # Content-Type
                   "`n" +                               # Date (empty when using x-ms-date)
                   "`n" +                               # If-Modified-Since
                   "`n" +                               # If-Match
                   "`n" +                               # If-None-Match
                   "`n" +                               # If-Unmodified-Since
                   "`n"                                 # Range

    # Add canonicalized headers (must be sorted alphabetically)
    if ($ForBlob) {
        $stringToSign += "x-ms-blob-type:BlockBlob" + "`n"
    }
    $stringToSign += "x-ms-date:" + $date + "`n"
    $stringToSign += "x-ms-version:2020-04-08" + "`n"
    $stringToSign += "/" + $StorageAccount + $Resource     # CanonicalizedResource

    $hmac = New-Object System.Security.Cryptography.HMACSHA256
    $hmac.Key = [Convert]::FromBase64String($StorageKey)
    $signature = [Convert]::ToBase64String($hmac.ComputeHash([Text.Encoding]::UTF8.GetBytes($stringToSign)))

    $headers = @{
        "Authorization" = "SharedKey " + $StorageAccount + ":" + $signature
        "x-ms-date" = $date
        "x-ms-version" = "2020-04-08"
    }

    if ($ForBlob) {
        $headers["x-ms-blob-type"] = "BlockBlob"
    }

    return $headers
}

try {
    # Log function start and capture start time
    $startTime = Get-Date
    Write-AppInsightsLog -Message "Order processing function started" -Level "Information" -Properties @{
        "FunctionName" = "ProcessOrder"
        "RequestId" = $TriggerMetadata.InvocationId
        "StartTime" = $startTime.ToString("yyyy-MM-dd HH:mm:ss.fff UTC")
    }

    # Get the request body
    $requestBody = $Request.Body

    # Extract order details
    $product = $requestBody.product
    $name = $requestBody.name
    $orderDate = $requestBody.order_date

    Write-AppInsightsLog -Message "Processing order" -Level "Information" -Properties @{
        "Product" = $product
        "CustomerName" = $name
        "OrderDate" = $orderDate
        "RequestId" = $TriggerMetadata.InvocationId
    }

    # Get storage account connection string from environment
    $storageConnectionString = $env:AzureWebJobsStorage

    if (-not $storageConnectionString) {
        Write-AppInsightsLog -Message "AzureWebJobsStorage environment variable not found" -Level "Error"
        throw "AzureWebJobsStorage environment variable not found"
    }

    # Check if it's UseDevelopmentStorage (local emulator)
    if ($storageConnectionString -eq "UseDevelopmentStorage=true") {
        Write-AppInsightsLog -Message "Development storage detected - switching to alternative approach" -Level "Warning"
        throw "Development storage not supported in this function"
    }

    Write-AppInsightsLog -Message "Storage connection string retrieved successfully" -Level "Information" -Properties @{
        "ConnectionStringLength" = $storageConnectionString.Length
        "ConnectionStringPreview" = $storageConnectionString.Substring(0, [Math]::Min(50, $storageConnectionString.Length)) + "..."
        "StartsWithDefaultEndpointsProtocol" = $storageConnectionString.StartsWith("DefaultEndpointsProtocol")
    }

    # Parse connection string to get account name and SAS token
    $connectionParams = @{}
    $storageConnectionString -split ';' | ForEach-Object {
        $part = $_.Trim()
        if ($part -and $part.Contains('=')) {
            $kvp = $part -split '=', 2
            if ($kvp.Length -eq 2) {
                $key = $kvp[0].Trim()
                $value = $kvp[1].Trim()
                $connectionParams[$key] = $value
                # Only log non-sensitive parameters
                if ($key -ne "AccountKey" -and $key -ne "SharedAccessSignature") {
                    Write-AppInsightsLog -Message "Found connection parameter" -Level "Information" -Properties @{
                        "ParameterName" = $key
                        "ValueLength" = $value.Length
                        "ValuePreview" = $value.Substring(0, [Math]::Min(10, $value.Length)) + "..."
                    }
                } else {
                    Write-AppInsightsLog -Message "Found auth parameter" -Level "Information" -Properties @{
                        "ParameterName" = $key
                        "ValueLength" = $value.Length
                    }
                }
            }
        }
    }

    Write-AppInsightsLog -Message "Connection string parsed" -Level "Information" -Properties @{
        "ParameterCount" = $connectionParams.Count
        "HasAccountName" = $connectionParams.ContainsKey('AccountName')
        "HasAccountKey" = $connectionParams.ContainsKey('AccountKey')
        "HasSAS" = $connectionParams.ContainsKey('SharedAccessSignature')
        "HasBlobEndpoint" = $connectionParams.ContainsKey('BlobEndpoint')
        "ParameterKeys" = ($connectionParams.Keys -join ", ")
    }

    $accountName = $connectionParams['AccountName']
    $accountKey = $connectionParams['AccountKey']
    $sasToken = $connectionParams['SharedAccessSignature']
    $blobEndpoint = $connectionParams['BlobEndpoint']

    Write-AppInsightsLog -Message "Retrieved credentials from connection string" -Level "Information" -Properties @{
        "AccountName" = $accountName
        "AccountNameLength" = if ($accountName) { $accountName.Length } else { 0 }
        "HasAccountKey" = [bool]$accountKey
        "AccountKeyLength" = if ($accountKey) { $accountKey.Length } else { 0 }
        "HasSAS" = [bool]$sasToken
        "SASLength" = if ($sasToken) { $sasToken.Length } else { 0 }
        "HasBlobEndpoint" = [bool]$blobEndpoint
    }

    # If we have a SAS token, extract account name from BlobEndpoint if needed
    if ($sasToken -and -not $accountName -and $blobEndpoint) {
        if ($blobEndpoint -match 'https://([^.]+)\.blob\.core\.windows\.net') {
            $accountName = $matches[1]
            Write-AppInsightsLog -Message "Extracted account name from BlobEndpoint" -Level "Information" -Properties @{
                "ExtractedAccountName" = $accountName
                "BlobEndpoint" = $blobEndpoint
            }
        }
    }

    if (-not $accountName) {
        Write-AppInsightsLog -Message "Unable to extract storage account name" -Level "Error" -Properties @{
            "ConnectionStringLength" = $storageConnectionString.Length
            "AllParameters" = ($connectionParams.Keys -join ", ")
        }
        throw "Unable to extract storage account name from connection string"
    }

    if (-not $accountKey -and -not $sasToken) {
        Write-AppInsightsLog -Message "No authentication method found" -Level "Error" -Properties @{
            "HasAccountKey" = [bool]$accountKey
            "HasSAS" = [bool]$sasToken
        }
        throw "No valid authentication method found (AccountKey or SharedAccessSignature)"
    }

    Write-AppInsightsLog -Message "Storage account credentials parsed successfully" -Level "Information" -Properties @{
        "StorageAccount" = $accountName
        "AccountNameLength" = $accountName.Length
        "HasAccountKey" = [bool]$accountKey
        "HasSAS" = [bool]$sasToken
        "AuthMethod" = if ($sasToken) { "SAS" } elseif ($accountKey) { "SharedKey" } else { "Unknown" }
    }

    # Container name
    $containerName = "orders"

    # Build URLs with validation - ensure account name is safe for URL
    if (-not $accountName -or $accountName.Length -eq 0) {
        throw "Account name is empty or null"
    }

    # Sanitize account name (just in case)
    $cleanAccountName = $accountName.ToLower().Trim()

    # Build URLs using string concatenation instead of interpolation
    $baseUrl = "https://" + $cleanAccountName + ".blob.core.windows.net"
    $containerUrl = $baseUrl + "/" + $containerName

    Write-AppInsightsLog -Message "URL construction completed" -Level "Information" -Properties @{
        "CleanAccountName" = $cleanAccountName
        "BaseUrl" = $baseUrl
        "ContainerUrl" = $containerUrl
        "UrlLength" = $containerUrl.Length
    }

    Write-AppInsightsLog -Message "Checking container existence" -Level "Information" -Properties @{
        "ContainerUrl" = $containerUrl
        "ContainerName" = $containerName
        "StorageAccount" = $cleanAccountName
    }

    # Skip container existence check - Azure will create it automatically if needed
    Write-AppInsightsLog -Message "Creating container if it doesn't exist" -Level "Information" -Properties @{
        "ContainerName" = $containerName
        "StorageAccount" = $cleanAccountName
    }

    # Create container first (it's okay if it already exists)
    try {
        $containerUrl = $baseUrl + "/" + $containerName + "?restype=container"
        $createHeaders = Get-StorageAuthHeader -StorageAccount $cleanAccountName -StorageKey $accountKey -Method "PUT" -Resource "/$containerName?restype=container" -ContentType "" -ContentLength 0

        Invoke-RestMethod -Uri $containerUrl -Method PUT -Headers $createHeaders | Out-Null
        Write-AppInsightsLog -Message "Container created successfully" -Level "Information" -Properties @{
            "ContainerName" = $containerName
        }
    }
    catch {
        if ($_.Exception.Response.StatusCode -eq 409) {
            Write-AppInsightsLog -Message "Container already exists" -Level "Information" -Properties @{
                "ContainerName" = $containerName
            }
        }
        else {
            Write-AppInsightsLog -Message "Container creation failed but continuing" -Level "Warning" -Properties @{
                "ContainerName" = $containerName
                "Error" = $_.Exception.Message
                "StatusCode" = if ($_.Exception.Response) { $_.Exception.Response.StatusCode } else { "Unknown" }
            }
        }
    }

    # Generate unique filename
    $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
    $guid = [System.Guid]::NewGuid().ToString("N").Substring(0, 8)
    $fileName = "order_${timestamp}_${guid}.txt"

    # Create order content
    $orderContent = @"
ORDER DETAILS
=============
Product: $product
Customer: $name
Order Date: $orderDate
Processed Date: $(Get-Date -Format "yyyy-MM-dd HH:mm:ss UTC")
Order ID: $guid

This order was processed by Azure Function (PowerShell Core)
"@

    # Convert content to bytes
    $contentBytes = [System.Text.Encoding]::UTF8.GetBytes($orderContent)

    # Upload to blob storage using REST API
    $blobUrl = $baseUrl + "/" + $containerName + "/" + $fileName
    $uploadHeaders = Get-StorageAuthHeader -StorageAccount $cleanAccountName -StorageKey $accountKey -Method "PUT" -Resource "/$containerName/$fileName" -ContentType "text/plain" -ContentLength $contentBytes.Length -ForBlob
    $uploadHeaders["Content-Type"] = "text/plain"

    try {
        Write-AppInsightsLog -Message "Attempting blob upload" -Level "Information" -Properties @{
            "BlobUrl" = $blobUrl
            "ContentLength" = $contentBytes.Length
            "FileName" = $fileName
            "StorageAccount" = $cleanAccountName
            "AuthMethod" = "SharedKey"
        }

        Invoke-RestMethod -Uri $blobUrl -Method PUT -Headers $uploadHeaders -Body $contentBytes | Out-Null

        Write-AppInsightsLog -Message "Order file uploaded successfully to blob storage" -Level "Information" -Properties @{
            "FileName" = $fileName
            "ContainerName" = $containerName
            "StorageAccount" = $cleanAccountName
            "Product" = $product
            "CustomerName" = $name
            "OrderId" = $guid
            "FileSizeBytes" = $contentBytes.Length
        }

        $storageSuccess = $true
        $storageMessage = "Successfully saved to Azure Blob Storage"
    }
    catch {
        Write-AppInsightsLog -Message "Failed to upload file to blob storage" -Level "Error" -Properties @{
            "FileName" = $fileName
            "Error" = $_.Exception.Message
            "StatusCode" = if ($_.Exception.Response) { $_.Exception.Response.StatusCode } else { "Unknown" }
            "BlobUrl" = $blobUrl
            "StorageAccount" = $cleanAccountName
        }

        # Don't throw - continue with local processing
        $storageSuccess = $false
        $storageMessage = "Blob storage failed but order processed: " + $_.Exception.Message
    }

    # Prepare response
    $responseBody = @{
        status = "success"
        message = "Order processed successfully"
        orderId = $guid
        fileName = $fileName
        timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss UTC"
        storageStatus = $storageMessage
        blobStorageSuccess = $storageSuccess
    } | ConvertTo-Json

    # Calculate processing time safely
    $endTime = Get-Date
    $processingTimeMs = ($endTime - $startTime).TotalMilliseconds

    Write-AppInsightsLog -Message "Order processing completed successfully" -Level "Information" -Properties @{
        "OrderId" = $guid
        "FileName" = $fileName
        "Product" = $product
        "CustomerName" = $name
        "ProcessingTimeMs" = $processingTimeMs
        "RequestId" = $TriggerMetadata.InvocationId
        "EndTime" = $endTime.ToString("yyyy-MM-dd HH:mm:ss.fff UTC")
    }

    $statusCode = [HttpStatusCode]::OK
}
catch {
    Write-AppInsightsLog -Message "Error processing order" -Level "Error" -Properties @{
        "ErrorMessage" = $_.Exception.Message
        "StackTrace" = $_.ScriptStackTrace
        "RequestId" = $TriggerMetadata.InvocationId
        "Product" = $product
        "CustomerName" = $name
    }

    $responseBody = @{
        status = "error"
        message = $_.Exception.Message
        timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss UTC"
    } | ConvertTo-Json

    $statusCode = [HttpStatusCode]::InternalServerError
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $statusCode
    Body = $responseBody
    Headers = @{
        "Content-Type" = "application/json"
    }
})
रिप्लेस करने के बाद फंक्शन को सेव ज़रूर करें.
अगर आप कीबोर्ड उपयोग कर रहे हैं तो Ctrl + V का उपयोग करें, भले ही आपके पास Macbook हो.
यह कोड Web App से आने वाले ऑर्डर्स को प्रोसेस करने के लिए फंक्शन को कॉन्फ़िगर करेगा.
समापन

Create Your Free Account
