Azure Static Website

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

// Import the program's configuration settings.
const config = new pulumi.Config();
const path = config.get("path") || "www";
const indexDocument = config.get("indexDocument") || "index.html";
const errorDocument = config.get("errorDocument") || "error.html";

// Create a resource group for the website.
const resourceGroup = new azure_native.resources.ResourceGroup("resource-group", {});

// Create a blob storage account.
const account = new azure_native.storage.StorageAccount("account", {
    resourceGroupName: resourceGroup.name,
    kind: "StorageV2",
    sku: {
        name: "Standard_LRS",
    },
});

// Configure the storage account as a website.
const website = new azure_native.storage.StorageAccountStaticWebsite("website", {
    resourceGroupName: resourceGroup.name,
    accountName: account.name,
    indexDocument: indexDocument,
    error404Document: errorDocument,
});

// Use a synced folder to manage the files of the website.
const syncedFolder = new synced_folder.AzureBlobFolder("synced-folder", {
    path: path,
    resourceGroupName: resourceGroup.name,
    storageAccountName: account.name,
    containerName: website.containerName,
});

// Pull the hostname out of the storage-account endpoint.
const originHostname = account.primaryEndpoints.apply(endpoints => new URL(endpoints.web)).hostname;

// Export the URL and hostname of the storage account's website.
export const originURL = account.primaryEndpoints.apply(endpoints => endpoints.web);
export { originHostname };

from urllib.parse import urlparse
import pulumi
import pulumi_azure_native as azure_native
import pulumi_synced_folder as synced_folder

# Import the program's configuration settings.
config = pulumi.Config()
path = config.get("path") or "www"
index_document = config.get("indexDocument") or "index.html"
error_document = config.get("errorDocument") or "error.html"

# Create a resource group for the website.
resource_group = azure_native.resources.ResourceGroup("resource-group")

# Create a blob storage account.
account = azure_native.storage.StorageAccount(
    "account",
    resource_group_name=resource_group.name,
    kind="StorageV2",
    sku={
        "name": "Standard_LRS",
    },
)

# Configure the storage account as a website.
website = azure_native.storage.StorageAccountStaticWebsite(
    "website",
    resource_group_name=resource_group.name,
    account_name=account.name,
    index_document=index_document,
    error404_document=error_document,
)

# Use a synced folder to manage the files of the website.
synced_folder = synced_folder.AzureBlobFolder(
    "synced-folder",
    path=path,
    resource_group_name=resource_group.name,
    storage_account_name=account.name,
    container_name=website.container_name,
)

# Pull the hostname out of the storage-account endpoint.
origin_hostname = account.primary_endpoints.web.apply(
    lambda endpoint: urlparse(endpoint).hostname
)

# Export the URL and hostname of the storage account's website.
pulumi.export("originURL", account.primary_endpoints.web)
pulumi.export("originHostname", origin_hostname)

package main

import (
  "net/url"

  resources "github.com/pulumi/pulumi-azure-native-sdk/resources/v3"
  storage "github.com/pulumi/pulumi-azure-native-sdk/storage/v3"
  synced "github.com/pulumi/pulumi-synced-folder/sdk/go/synced-folder"
  "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
  "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
  pulumi.Run(func(ctx *pulumi.Context) error {

    // Import the program's configuration settings.
    cfg := config.New(ctx, "")
    path := "www"
    if param := cfg.Get("path"); param != "" {
      path = param
    }
    indexDocument := "index.html"
    if param := cfg.Get("indexDocument"); param != "" {
      indexDocument = param
    }
    errorDocument := "error.html"
    if param := cfg.Get("errorDocument"); param != "" {
      errorDocument = param
    }

    // Create a resource group for the website.
    resourceGroup, err := resources.NewResourceGroup(ctx, "resource-group", nil)
    if err != nil {
      return err
    }

    // Create a blob storage account.
    account, err := storage.NewStorageAccount(ctx, "account", &storage.StorageAccountArgs{
      ResourceGroupName: resourceGroup.Name,
      Kind:              pulumi.String("StorageV2"),
      Sku: &storage.SkuArgs{
        Name: pulumi.String("Standard_LRS"),
      },
    })
    if err != nil {
      return err
    }

    // Configure the storage account as a website.
    website, err := storage.NewStorageAccountStaticWebsite(ctx, "website", &storage.StorageAccountStaticWebsiteArgs{
      ResourceGroupName: resourceGroup.Name,
      AccountName:       account.Name,
      IndexDocument:     pulumi.String(indexDocument),
      Error404Document:  pulumi.String(errorDocument),
    })
    if err != nil {
      return err
    }

    // Use a synced folder to manage the files of the website.
    _, err = synced.NewAzureBlobFolder(ctx, "synced-folder", &synced.AzureBlobFolderArgs{
      Path:               pulumi.String(path),
      ResourceGroupName:  resourceGroup.Name,
      StorageAccountName: account.Name,
      ContainerName:      website.ContainerName,
    })
    if err != nil {
      return err
    }

    // Pull the hostname out of the storage-account endpoint.
    originHostname := account.PrimaryEndpoints.ApplyT(func(endpoints storage.EndpointsResponse) (string, error) {
      parsed, err := url.Parse(endpoints.Web)
      if err != nil {
        return "", err
      }
      return parsed.Hostname(), nil
    }).(pulumi.StringOutput)

    // Export the URL and hostname of the storage account's website.
    ctx.Export("originURL", account.PrimaryEndpoints.ApplyT(func(endpoints storage.EndpointsResponse) (string, error) {
      return endpoints.Web, nil
    }).(pulumi.StringOutput))
    ctx.Export("originHostname", originHostname)

    return nil
  })
}

using System;
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
using SyncedFolder = Pulumi.SyncedFolder;

return await Deployment.RunAsync(() =>
{
    // Import the program's configuration settings.
    var config = new Config();
    var path = config.Get("path") ?? "www";
    var indexDocument = config.Get("indexDocument") ?? "index.html";
    var errorDocument = config.Get("errorDocument") ?? "error.html";

    // Create a resource group for the website.
    var resourceGroup = new AzureNative.Resources.ResourceGroup("resource-group");

    // Create a blob storage account.
    var account = new AzureNative.Storage.StorageAccount("account", new()
    {
        ResourceGroupName = resourceGroup.Name,
        Kind = "StorageV2",
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_LRS",
        },
    });

    // Configure the storage account as a website.
    var website = new AzureNative.Storage.StorageAccountStaticWebsite("website", new()
    {
        ResourceGroupName = resourceGroup.Name,
        AccountName = account.Name,
        IndexDocument = indexDocument,
        Error404Document = errorDocument,
    });

    // Use a synced folder to manage the files of the website.
    var syncedFolder = new SyncedFolder.AzureBlobFolder("synced-folder", new()
    {
        Path = path,
        ResourceGroupName = resourceGroup.Name,
        StorageAccountName = account.Name,
        ContainerName = website.ContainerName,
    });

    // Pull the hostname out of the storage-account endpoint.
    var originHostname = account.PrimaryEndpoints.Apply(endpoints => new Uri(endpoints.Web).Host);

    // Export the URL and hostname of the storage account's website.
    return new Dictionary<string, object?>
    {
        ["originURL"] = account.PrimaryEndpoints.Apply(primaryEndpoints => primaryEndpoints.Web),
        ["originHostname"] = originHostname,
    };
});

name: my-project
description: A Pulumi YAML program to deploy a static website on Azure
runtime: yaml

# Import the program's configuration settings.
config:
  path:
    type: string
    default: www
  indexDocument:
    type: string
    default: index.html
  errorDocument:
    type: string
    default: error.html

# Pull the hostname out of the storage-account endpoint.
variables:
  originHostname:
    fn::select:
      - 2
      - fn::split:
        - /
        - ${account.primaryEndpoints.web}

resources:

  # Create a resource group for the website.
  resource-group:
    type: azure-native:resources:ResourceGroup

  # Create a blob storage account.
  account:
    type: azure-native:storage:StorageAccount
    properties:
      resourceGroupName: ${resource-group.name}
      kind: StorageV2
      sku:
        name: Standard_LRS

  # Configure the storage account as a website.
  website:
    type: azure-native:storage:StorageAccountStaticWebsite
    properties:
      resourceGroupName: ${resource-group.name}
      accountName: ${account.name}
      indexDocument: ${indexDocument}
      error404Document: ${errorDocument}

  # Use a synced folder to manage the files of the website.
  synced-folder:
    type: synced-folder:index:AzureBlobFolder
    properties:
      path: ${path}
      resourceGroupName: ${resource-group.name}
      storageAccountName: ${account.name}
      containerName: ${website.containerName}

# Export the URL and hostname of the storage account's website.
outputs:
  originURL: ${account.primaryEndpoints.web}
  originHostname: ${originHostname}

terraform {
  required_providers {
    azure-native = {
      source = "pulumi/azure-native"
    }
    synced-folder = {
      source = "pulumi/synced-folder"
    }
  }
}

variable "path" {
  description = "The path to the folder containing the website"
  type        = string
  default     = "www"
}

variable "index_document" {
  description = "The file to use for top-level pages"
  type        = string
  default     = "index.html"
}

variable "error_document" {
  description = "The file to use for error pages"
  type        = string
  default     = "error.html"
}

# Create a resource group for the website.
resource "azure-native_resources_resource_group" "resource-group" {}

# Create a blob storage account.
resource "azure-native_storage_storage_account" "account" {
  resource_group_name = azure-native_resources_resource_group.resource-group.name
  kind                = "StorageV2"
  sku = {
    name = "Standard_LRS"
  }
}

# Configure the storage account as a website.
resource "azure-native_storage_storage_account_static_website" "website" {
  resource_group_name = azure-native_resources_resource_group.resource-group.name
  account_name        = azure-native_storage_storage_account.account.name
  index_document      = var.index_document
  error404_document   = var.error_document
}

# Use a synced folder to manage the files of the website.
resource "synced-folder_azure_blob_folder" "synced-folder" {
  path                 = var.path
  resource_group_name  = azure-native_resources_resource_group.resource-group.name
  storage_account_name = azure-native_storage_storage_account.account.name
  container_name       = azure-native_storage_storage_account_static_website.website.container_name
}

# Export the URL and hostname of the storage account's website.
output "origin_url" {
  value = azure-native_storage_storage_account.account.primary_endpoints.web
}

output "origin_hostname" {
  value = split("/", azure-native_storage_storage_account.account.primary_endpoints.web)[2]
}