azure.apimanagement.CustomDomain

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
        });
        var exampleService = new Azure.ApiManagement.Service("exampleService", new Azure.ApiManagement.ServiceArgs
        {
            Location = azurerm_resource_group.Test.Location,
            ResourceGroupName = azurerm_resource_group.Test.Name,
            PublisherName = "pub1",
            PublisherEmail = "pub1@email.com",
            SkuName = "Developer_1",
        });
        var exampleCertificate = new Azure.KeyVault.Certificate("exampleCertificate", new Azure.KeyVault.CertificateArgs
        {
            KeyVaultId = azurerm_key_vault.Test.Id,
            CertificatePolicy = new Azure.KeyVault.Inputs.CertificateCertificatePolicyArgs
            {
                IssuerParameters = new Azure.KeyVault.Inputs.CertificateCertificatePolicyIssuerParametersArgs
                {
                    Name = "Self",
                },
                KeyProperties = new Azure.KeyVault.Inputs.CertificateCertificatePolicyKeyPropertiesArgs
                {
                    Exportable = true,
                    KeySize = 2048,
                    KeyType = "RSA",
                    ReuseKey = true,
                },
                LifetimeActions = 
                {
                    new Azure.KeyVault.Inputs.CertificateCertificatePolicyLifetimeActionArgs
                    {
                        Action = new Azure.KeyVault.Inputs.CertificateCertificatePolicyLifetimeActionActionArgs
                        {
                            ActionType = "AutoRenew",
                        },
                        Trigger = new Azure.KeyVault.Inputs.CertificateCertificatePolicyLifetimeActionTriggerArgs
                        {
                            DaysBeforeExpiry = 30,
                        },
                    },
                },
                SecretProperties = new Azure.KeyVault.Inputs.CertificateCertificatePolicySecretPropertiesArgs
                {
                    ContentType = "application/x-pkcs12",
                },
                X509CertificateProperties = new Azure.KeyVault.Inputs.CertificateCertificatePolicyX509CertificatePropertiesArgs
                {
                    KeyUsages = 
                    {
                        "cRLSign",
                        "dataEncipherment",
                        "digitalSignature",
                        "keyAgreement",
                        "keyCertSign",
                        "keyEncipherment",
                    },
                    Subject = "CN=api.example.com",
                    ValidityInMonths = 12,
                    SubjectAlternativeNames = new Azure.KeyVault.Inputs.CertificateCertificatePolicyX509CertificatePropertiesSubjectAlternativeNamesArgs
                    {
                        DnsNames = 
                        {
                            "api.example.com",
                            "portal.example.com",
                        },
                    },
                },
            },
        });
        var exampleCustomDomain = new Azure.ApiManagement.CustomDomain("exampleCustomDomain", new Azure.ApiManagement.CustomDomainArgs
        {
            ApiManagementId = exampleService.Id,
            Proxies = 
            {
                new Azure.ApiManagement.Inputs.CustomDomainProxyArgs
                {
                    HostName = "api.example.com",
                    KeyVaultId = azurerm_key_vault_certificate.Test.Secret_id,
                },
            },
            DeveloperPortals = 
            {
                new Azure.ApiManagement.Inputs.CustomDomainDeveloperPortalArgs
                {
                    HostName = "portal.example.com",
                    KeyVaultId = azurerm_key_vault_certificate.Test.Secret_id,
                },
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/apimanagement"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/keyvault"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleService, err := apimanagement.NewService(ctx, "exampleService", &apimanagement.ServiceArgs{
			Location:          pulumi.Any(azurerm_resource_group.Test.Location),
			ResourceGroupName: pulumi.Any(azurerm_resource_group.Test.Name),
			PublisherName:     pulumi.String("pub1"),
			PublisherEmail:    pulumi.String("pub1@email.com"),
			SkuName:           pulumi.String("Developer_1"),
		})
		if err != nil {
			return err
		}
		_, err = keyvault.NewCertificate(ctx, "exampleCertificate", &keyvault.CertificateArgs{
			KeyVaultId: pulumi.Any(azurerm_key_vault.Test.Id),
			CertificatePolicy: &keyvault.CertificateCertificatePolicyArgs{
				IssuerParameters: &keyvault.CertificateCertificatePolicyIssuerParametersArgs{
					Name: pulumi.String("Self"),
				},
				KeyProperties: &keyvault.CertificateCertificatePolicyKeyPropertiesArgs{
					Exportable: pulumi.Bool(true),
					KeySize:    pulumi.Int(2048),
					KeyType:    pulumi.String("RSA"),
					ReuseKey:   pulumi.Bool(true),
				},
				LifetimeActions: keyvault.CertificateCertificatePolicyLifetimeActionArray{
					&keyvault.CertificateCertificatePolicyLifetimeActionArgs{
						Action: &keyvault.CertificateCertificatePolicyLifetimeActionActionArgs{
							ActionType: pulumi.String("AutoRenew"),
						},
						Trigger: &keyvault.CertificateCertificatePolicyLifetimeActionTriggerArgs{
							DaysBeforeExpiry: pulumi.Int(30),
						},
					},
				},
				SecretProperties: &keyvault.CertificateCertificatePolicySecretPropertiesArgs{
					ContentType: pulumi.String("application/x-pkcs12"),
				},
				X509CertificateProperties: &keyvault.CertificateCertificatePolicyX509CertificatePropertiesArgs{
					KeyUsages: pulumi.StringArray{
						pulumi.String("cRLSign"),
						pulumi.String("dataEncipherment"),
						pulumi.String("digitalSignature"),
						pulumi.String("keyAgreement"),
						pulumi.String("keyCertSign"),
						pulumi.String("keyEncipherment"),
					},
					Subject:          pulumi.String("CN=api.example.com"),
					ValidityInMonths: pulumi.Int(12),
					SubjectAlternativeNames: &keyvault.CertificateCertificatePolicyX509CertificatePropertiesSubjectAlternativeNamesArgs{
						DnsNames: pulumi.StringArray{
							pulumi.String("api.example.com"),
							pulumi.String("portal.example.com"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = apimanagement.NewCustomDomain(ctx, "exampleCustomDomain", &apimanagement.CustomDomainArgs{
			ApiManagementId: exampleService.ID(),
			Proxies: apimanagement.CustomDomainProxyArray{
				&apimanagement.CustomDomainProxyArgs{
					HostName:   pulumi.String("api.example.com"),
					KeyVaultId: pulumi.Any(azurerm_key_vault_certificate.Test.Secret_id),
				},
			},
			DeveloperPortals: apimanagement.CustomDomainDeveloperPortalArray{
				&apimanagement.CustomDomainDeveloperPortalArgs{
					HostName:   pulumi.String("portal.example.com"),
					KeyVaultId: pulumi.Any(azurerm_key_vault_certificate.Test.Secret_id),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleService = new azure.apimanagement.Service("exampleService", {
    location: azurerm_resource_group.test.location,
    resourceGroupName: azurerm_resource_group.test.name,
    publisherName: "pub1",
    publisherEmail: "pub1@email.com",
    skuName: "Developer_1",
});
const exampleCertificate = new azure.keyvault.Certificate("exampleCertificate", {
    keyVaultId: azurerm_key_vault.test.id,
    certificatePolicy: {
        issuerParameters: {
            name: "Self",
        },
        keyProperties: {
            exportable: true,
            keySize: 2048,
            keyType: "RSA",
            reuseKey: true,
        },
        lifetimeActions: [{
            action: {
                actionType: "AutoRenew",
            },
            trigger: {
                daysBeforeExpiry: 30,
            },
        }],
        secretProperties: {
            contentType: "application/x-pkcs12",
        },
        x509CertificateProperties: {
            keyUsages: [
                "cRLSign",
                "dataEncipherment",
                "digitalSignature",
                "keyAgreement",
                "keyCertSign",
                "keyEncipherment",
            ],
            subject: "CN=api.example.com",
            validityInMonths: 12,
            subjectAlternativeNames: {
                dnsNames: [
                    "api.example.com",
                    "portal.example.com",
                ],
            },
        },
    },
});
const exampleCustomDomain = new azure.apimanagement.CustomDomain("exampleCustomDomain", {
    apiManagementId: exampleService.id,
    proxies: [{
        hostName: "api.example.com",
        keyVaultId: azurerm_key_vault_certificate.test.secret_id,
    }],
    developerPortals: [{
        hostName: "portal.example.com",
        keyVaultId: azurerm_key_vault_certificate.test.secret_id,
    }],
});

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_service = azure.apimanagement.Service("exampleService",
    location=azurerm_resource_group["test"]["location"],
    resource_group_name=azurerm_resource_group["test"]["name"],
    publisher_name="pub1",
    publisher_email="pub1@email.com",
    sku_name="Developer_1")
example_certificate = azure.keyvault.Certificate("exampleCertificate",
    key_vault_id=azurerm_key_vault["test"]["id"],
    certificate_policy=azure.keyvault.CertificateCertificatePolicyArgs(
        issuer_parameters=azure.keyvault.CertificateCertificatePolicyIssuerParametersArgs(
            name="Self",
        ),
        key_properties=azure.keyvault.CertificateCertificatePolicyKeyPropertiesArgs(
            exportable=True,
            key_size=2048,
            key_type="RSA",
            reuse_key=True,
        ),
        lifetime_actions=[azure.keyvault.CertificateCertificatePolicyLifetimeActionArgs(
            action=azure.keyvault.CertificateCertificatePolicyLifetimeActionActionArgs(
                action_type="AutoRenew",
            ),
            trigger=azure.keyvault.CertificateCertificatePolicyLifetimeActionTriggerArgs(
                days_before_expiry=30,
            ),
        )],
        secret_properties=azure.keyvault.CertificateCertificatePolicySecretPropertiesArgs(
            content_type="application/x-pkcs12",
        ),
        x509_certificate_properties=azure.keyvault.CertificateCertificatePolicyX509CertificatePropertiesArgs(
            key_usages=[
                "cRLSign",
                "dataEncipherment",
                "digitalSignature",
                "keyAgreement",
                "keyCertSign",
                "keyEncipherment",
            ],
            subject="CN=api.example.com",
            validity_in_months=12,
            subject_alternative_names=azure.keyvault.CertificateCertificatePolicyX509CertificatePropertiesSubjectAlternativeNamesArgs(
                dns_names=[
                    "api.example.com",
                    "portal.example.com",
                ],
            ),
        ),
    ))
example_custom_domain = azure.apimanagement.CustomDomain("exampleCustomDomain",
    api_management_id=example_service.id,
    proxies=[azure.apimanagement.CustomDomainProxyArgs(
        host_name="api.example.com",
        key_vault_id=azurerm_key_vault_certificate["test"]["secret_id"],
    )],
    developer_portals=[azure.apimanagement.CustomDomainDeveloperPortalArgs(
        host_name="portal.example.com",
        key_vault_id=azurerm_key_vault_certificate["test"]["secret_id"],
    )])