Serving up video content via Azure Blob Storage

Question

Pulumi · Accepted Answer

To serve up video content using Azure Blob Storage, you'll need to create a storage account, then a container within that storage account, and finally upload your video files as blobs into that container. The uploaded videos can then be accessed through the Blob Storage REST API or served directly to clients if the container is made publicly accessible.

Here's a step-by-step breakdown of a Pulumi program written in TypeScript that accomplishes this:

1. **Create a new Azure Resource Group**: This resource group will contain and manage the lifecycle of all resources you create for serving video content.
2. **Create an Azure Storage Account**: This account will be used to store and serve your video blobs.
3. **Create a Blob Container**: Within the storage account, we create a container where the videos will reside.
4. **Upload Video Blobs**: For the actual video content, blobs will be created within the container.

Below is the complete TypeScript program:

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

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("videoContentResourceGroup");

// Create an Azure Storage Account
const storageAccount = new azure_native.storage.StorageAccount("videosStorageAccount", {
    resourceGroupName: resourceGroup.name,
    kind: azure_native.storage.Kind.StorageV2,
    sku: {
        name: azure_native.storage.SkuName.Standard_LRS, // Using locally-redundant storage for cost efficiency
    },
});

// Create a Blob Container in the Storage Account where we'll upload the videos
const videosContainer = new azure_native.storage.BlobContainer("videosContainer", {
    resourceGroupName: resourceGroup.name,
    accountName: storageAccount.name,
    publicAccess: azure_native.storage.PublicAccess.Blob, // Making container publicly accessible
});

// Creating a blob (video file) within the container
// This is an example for a single video; in a real-world scenario,
// you would have a mechanism to upload multiple videos
const videoBlob = new azure_native.storage.Blob("sampleVideo", {
    resourceGroupName: resourceGroup.name,
    accountName: storageAccount.name,
    containerName: videosContainer.name,
    source: "./path/to/your/video.mp4", // Path to the video file you want to upload
    contentType: "video/mp4", // Setting the content type for the video
});

export const storageAccountName = storageAccount.name;
export const containerName = videosContainer.name;
export const blobUrl = pulumi.interpolate`${storageAccount.primaryEndpoints.blob}${videosContainer.name}/sampleVideo.mp4`;
```

This program will perform the following actions:
- The `azure_native.resources.ResourceGroup` creates a new resource group in your Azure subscription.
- The `azure_native.storage.StorageAccount` creates a new storage account within that resource group with locally-redundant storage (LRS) for cost efficiency.
- The `azure_native.storage.BlobContainer` creates a blob container with public access, so that the blobs (videos) can be served publicly.
- The `azure_native.storage.Blob` represents a video file that you want to upload to the blob storage.

Please note that you need to replace `./path/to/your/video.mp4` with the actual path to the video file you want to upload. The path is relative to where you are running the Pulumi program.

The final exported `blobUrl` is the URL through which the uploaded video can be accessed.

Remember that serving content directly from Blob Storage works well for simple use cases. If you have significant traffic or need advanced functionality like content delivery networks (CDN), geo-redundancy, or streaming services, you will want to explore additional Azure services.