Configuring custom domain names for Azure Web Apps

Question

Pulumi · Accepted Answer

To configure a custom domain for an Azure Web App using Pulumi, you'll need to work with several resources. In the example provided, you'll see how to create an Azure Web App and configure a custom domain name for it. This process involves setting up a DNS record to point to the Azure Web App and then configuring the Web App to recognize and use the custom domain.

Pulumi allows you to define your infrastructure using familiar programming languages, in this case, TypeScript. The code will create a Web App in Azure and then register a custom domain to it.

Before you begin, you'll need to have Pulumi installed and configured for use with Azure.

Here's a detailed breakdown of what each part of the script is doing:

1. `WebApp`: This is the Azure Web App resource that represents your application.
2. `CustomDomain`: This resource is used to associate a custom domain with the Azure Web App. The domain name must be verified and the DNS records must be correctly set up for this to work.

Below is an example Pulumi program written in TypeScript that defines these resources:

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

// Create a resource group for the web app and related resources
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

// Create an App Service Plan which defines the underlying VM where the web app will run
const appServicePlan = new azure.web.AppServicePlan("myAppServicePlan", {
    resourceGroupName: resourceGroup.name,
    kind: "App",
    sku: {
        name: "B1",
        tier: "Basic",
    },
});

// Create the Web App with the App Service Plan
const webApp = new azure.web.WebApp("myWebApp", {
    resourceGroupName: resourceGroup.name,
    serverFarmId: appServicePlan.id,
    siteConfig: {
        appSettings: [
            {
                name: "WEBSITE_RUN_FROM_PACKAGE",
                value: "1",
            },
        ],
        // If you're using Linux or container-based deployment, you will need additional settings here.
    },
});

// Associate the Custom Domain with the Web App
const customDomain = new azure.web.WebApp("myCustomDomain", {
    name: "www.mydomain.com", // Replace with your custom domain
    resourceGroupName: resourceGroup.name,
    kind: "app", // Use the appropriate kind for your app; 'app' is for web apps
    enabledHostNames: ["www.mydomain.com", "myWebApp.azurewebsites.net"], // List your custom domain and default domain
    hostNameSslStates: [
        {
            name: "www.mydomain.com",
            sslState: "SniEnabled", // Enable SNI SSL for the custom domain
            hostType: "Standard",
        },
        {
            name: "myWebApp.azurewebsites.net",
            sslState: "SniEnabled", // This will default to using Azure's SSL
            hostType: "Standard",
        }
    ],
    // You may require additional SSL settings such as thumbprint if you're using your own SSL certificates
});

export const webAppUrl = webApp.defaultHostName;
```

In this code:
- First, we import the `@pulumi/pulumi` and `@pulumi/azure-native` modules.
- A new resource group is created to logically group the Azure resources.
- Then, an App Service Plan is defined, which is required to provision the Web App.
- The Web App is created within the defined resource group and linked to the App Service Plan.
- A custom domain is then associated with the Web App by creating another instance of the `WebApp` resource with the required hostname settings.
- Finally, we export the default hostname of the web app for easy access.

Once you have set up your Pulumi program, you would deploy it using the Pulumi CLI tool. Pulumi would then provide the infrastructure-as-code to provision the resources as specified in Azure.

Remember to replace placeholders like `www.mydomain.com` with your actual domain information. Before running the program, ensure that the necessary DNS settings are configured in your domain's DNS management zone (like an A record or a CNAME record pointing to the Azure Web App). This step is critical for domain verification and for the custom domain configuration to function properly.