Skip to main content
SimilarExport ZIP
100%

List Azure File Shared Storage using the REST API and Powershell

✓ Published0🌍 Public
HHugoberry
Last edited Sep 16, 2019
Created on Sep 16, 2019

This example demonstrates how to list Azure File Shared Storage contents using the REST API and PowerShell. It constructs a signed request by building a canonicalized signature string with the account key and HMAC-SHA256 encryption, then sends a GET request through `Invoke-RestMethod`. The code explicitly sets required headers such as `x-ms-date`, `x-ms-version`, and `Authorization`, and outputs the signature for inspection. The script uses PowerShell’s `System.Security.Cryptography.HMACSHA256` and `System.Uri` classes to compute authentication and parse the endpoint.

AI-generated description

Similar vizzes

Loading thumbnail…

Fetching the Mandelbrot Set from the execution of Azure Functions

This example visualizes the Mandelbrot set by fetching precomputed JSON blobs from an Azure Storage container. The Power Query code uses the `AzureStorage.Blobs` API to connect to the storage account, filters the blobs by a folder named "ZZZ", and retrieves their content. Each blob is parsed with `Json.Document` to extract the set’s data, which is then combined into a single table via `Table.FromRecords` and `List.Combine`. The visualization shows how distributed execution of Azure Functions can fragment and reassemble complex mathematical data, presenting the classic fractal shape through a straightforward data-fetching pipeline.

HHugoberry
55% match
Loading thumbnail…

Exposing #shared construct in Azure Analysis Services (change DatabaseID accordingly)

This example shows how to expose the contents of Power Query's `#shared` intrinsic constant inside an Azure Analysis Services tabular model, turning the built-in M function and value registry into a queryable table. The workflow uses three XMLA/TMSL scripts: first, an XMLA `Create` command injects a shared expression named `SharedExpression` that returns `#shared`; second, a TMSL `create` operation defines a table with `Name` and `Value` string columns, pulling data through an M partition expression that references the injected shared expression; finally, a TMSL `refresh` command processes the new table. The result is then viewed with a DAX `evaluate` statement against the `SharedExpressionTable`, demonstrating a round-trip from M metadata to a usable relational structure. The code relies on the XMLA protocol, TMSL JSON APIs, and the M expression engine, with no external visualization library involved.

HHugoberry
54% match
Loading thumbnail…

Power Query CurrentUser via a lightweight PowerShell HTTP API

This example demonstrates how Power Query can obtain the current Windows user by querying a lightweight PowerShell HTTP API. It shows the result of a `whoami` command wrapped in a JSON response. The Power Query code uses `Web.Contents` to call the local HTTP endpoint at `http://localhost:8888/?command=whoami`, and then parses the returned JSON with `Json.Document`. The underlying HTTP API service is built from a PowerShell script, based on the referenced blog post, which executes commands and returns their output. This approach provides a simple bridge between Power Query’s data-fetching capabilities and PowerShell’s system introspection.

HHugoberry
53% match
Loading thumbnail…

Playing with Azure Functions

This example visualizes how three Azure Functions HTTP triggers enqueue messages to a shared storage queue, showing the sequential flow from request to queue insertion. The code uses the `ICollector<string>` interface to add messages named "Larry", "Moe", and "Curly" to an Azure Storage queue, with each function call triggering the enqueue operation. The visualization highlights the request–response cycle via the `HttpRequestMessage` and `HttpResponseMessage` objects, while `TraceWriter` logs the incoming URI. It demonstrates the serverless event-driven pattern where HTTP calls produce queue entries, though the rendering itself is not shown in the provided code.

HHugoberry
53% match
Loading thumbnail…

Schedule an Mandelbrot Set calculation in Azure Functions

This example shows a Power Query script that calculates a Mandelbrot set by sending a POST request to an Azure Functions HTTP endpoint. The code defines a URI with a query parameter for the authentication code, constructs a JSON body specifying the coordinate bounds (XMin, YMin, XMax, YMax) and a resolution of 1000, then uses `Web.Contents` to post the request with a JSON content type header. The response, parsed via `Json.Document`, contains the resulting set. The visualization demonstrates how to offload compute-intensive fractal generation to a serverless function and retrieve the outcome as structured data.

HHugoberry
53% match
Loading thumbnail…

Azure function HTTP trigger for Mandelbrot calculation

This example demonstrates a serverless Azure Function that calculates Mandelbrot set coordinates in parallel by partitioning the rendering job into discrete units. The HTTP-triggered PowerShell script (`AzzureFunctionHTTP.ps1`) accepts a JSON payload via `$req`, parses it with `ConvertFrom-Json`, and splits the requested resolution into 1000 sub-jobs, each assigned a unique step interval along the x-axis. Each sub-job is packaged with its folder, request parameters, and computed step value, then serialized with `ConvertTo-Json` and written to an output queue (`$outputQueueItem`). The code relies on the Azure Functions runtime and standard PowerShell cmdlets (`Out-File`, `[guid]::newguid()`) for blob folder naming and output handling, without external visualization libraries.

HHugoberry
52% match
Loading thumbnail…

Gist bae6758b4e3645b55f022e6432f29458

This visualization demonstrates the interaction between R and PowerShell, showing how a system call from an R environment triggers a PowerShell script that manipulates data. The code uses the `system2` function to execute a PowerShell command with a specified file path, passing arguments to run `coolScript.ps1`. The example highlights the practical integration of two scripting environments, where R serves as the orchestrator for external process execution. The rendering relies on the command-line interface rather than graphical libraries, focusing on the workflow of invoking and managing external scripts from within an R session. The data flow is implicit in the script's execution, emphasizing interoperability over visual output.

HHugoberry
49% match
Loading thumbnail…

http://stackoverflow.com/questions/11696944/powershell-v3-invoke-webrequest-https-error

This example demonstrates a PowerShell workaround for bypassing SSL certificate validation errors when using `Invoke-WebRequest` to access an HTTPS resource by IP address. The script defines a custom C# class, `TrustAllCertsPolicy`, which implements the `ICertificatePolicy` interface and overrides `CheckValidationResult` to always return `true`. It then assigns an instance of this policy to `[System.Net.ServicePointManager]::CertificatePolicy` before making the web request. The visualization would likely show the request succeeding where it previously failed, highlighting the difference in error handling for untrusted certificates. The code relies on .NET’s `System.Net` and `System.Security.Cryptography.X509Certificates` namespaces.

HHugoberry
49% match