azure.appplatform.SpringCloudCertificate

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
using AzureAD = Pulumi.AzureAD;

return await Deployment.RunAsync(() => 
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new()
    {
        Location = "West Europe",
    });

    var current = Azure.Core.GetClientConfig.Invoke();

    var exampleServicePrincipal = AzureAD.GetServicePrincipal.Invoke(new()
    {
        DisplayName = "Azure Spring Cloud Resource Provider",
    });

    var exampleKeyVault = new Azure.KeyVault.KeyVault("exampleKeyVault", new()
    {
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        TenantId = current.Apply(getClientConfigResult => getClientConfigResult.TenantId),
        SkuName = "standard",
        AccessPolicies = new[]
        {
            new Azure.KeyVault.Inputs.KeyVaultAccessPolicyArgs
            {
                TenantId = current.Apply(getClientConfigResult => getClientConfigResult.TenantId),
                ObjectId = current.Apply(getClientConfigResult => getClientConfigResult.ObjectId),
                SecretPermissions = new[]
                {
                    "Set",
                },
                CertificatePermissions = new[]
                {
                    "Create",
                    "Delete",
                    "Get",
                    "Update",
                },
            },
            new Azure.KeyVault.Inputs.KeyVaultAccessPolicyArgs
            {
                TenantId = current.Apply(getClientConfigResult => getClientConfigResult.TenantId),
                ObjectId = exampleServicePrincipal.Apply(getServicePrincipalResult => getServicePrincipalResult.ObjectId),
                SecretPermissions = new[]
                {
                    "Get",
                    "List",
                },
                CertificatePermissions = new[]
                {
                    "Get",
                    "List",
                },
            },
        },
    });

    var exampleCertificate = new Azure.KeyVault.Certificate("exampleCertificate", new()
    {
        KeyVaultId = exampleKeyVault.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[]
            {
                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 = new[]
                {
                    "cRLSign",
                    "dataEncipherment",
                    "digitalSignature",
                    "keyAgreement",
                    "keyCertSign",
                    "keyEncipherment",
                },
                Subject = "CN=contoso.com",
                ValidityInMonths = 12,
            },
        },
    });

    var exampleSpringCloudService = new Azure.AppPlatform.SpringCloudService("exampleSpringCloudService", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
    });

    var exampleSpringCloudCertificate = new Azure.AppPlatform.SpringCloudCertificate("exampleSpringCloudCertificate", new()
    {
        ResourceGroupName = exampleSpringCloudService.ResourceGroupName,
        ServiceName = exampleSpringCloudService.Name,
        KeyVaultCertificateId = exampleCertificate.Id,
        ExcludePrivateKey = true,
    });

});

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/appplatform"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/keyvault"
	"github.com/pulumi/pulumi-azuread/sdk/v5/go/azuread"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		current, err := core.GetClientConfig(ctx, nil, nil)
		if err != nil {
			return err
		}
		exampleServicePrincipal, err := azuread.LookupServicePrincipal(ctx, &azuread.LookupServicePrincipalArgs{
			DisplayName: pulumi.StringRef("Azure Spring Cloud Resource Provider"),
		}, nil)
		if err != nil {
			return err
		}
		exampleKeyVault, err := keyvault.NewKeyVault(ctx, "exampleKeyVault", &keyvault.KeyVaultArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			TenantId:          *pulumi.String(current.TenantId),
			SkuName:           pulumi.String("standard"),
			AccessPolicies: keyvault.KeyVaultAccessPolicyArray{
				&keyvault.KeyVaultAccessPolicyArgs{
					TenantId: *pulumi.String(current.TenantId),
					ObjectId: *pulumi.String(current.ObjectId),
					SecretPermissions: pulumi.StringArray{
						pulumi.String("Set"),
					},
					CertificatePermissions: pulumi.StringArray{
						pulumi.String("Create"),
						pulumi.String("Delete"),
						pulumi.String("Get"),
						pulumi.String("Update"),
					},
				},
				&keyvault.KeyVaultAccessPolicyArgs{
					TenantId: *pulumi.String(current.TenantId),
					ObjectId: *pulumi.String(exampleServicePrincipal.ObjectId),
					SecretPermissions: pulumi.StringArray{
						pulumi.String("Get"),
						pulumi.String("List"),
					},
					CertificatePermissions: pulumi.StringArray{
						pulumi.String("Get"),
						pulumi.String("List"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		exampleCertificate, err := keyvault.NewCertificate(ctx, "exampleCertificate", &keyvault.CertificateArgs{
			KeyVaultId: exampleKeyVault.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=contoso.com"),
					ValidityInMonths: pulumi.Int(12),
				},
			},
		})
		if err != nil {
			return err
		}
		exampleSpringCloudService, err := appplatform.NewSpringCloudService(ctx, "exampleSpringCloudService", &appplatform.SpringCloudServiceArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
		})
		if err != nil {
			return err
		}
		_, err = appplatform.NewSpringCloudCertificate(ctx, "exampleSpringCloudCertificate", &appplatform.SpringCloudCertificateArgs{
			ResourceGroupName:     exampleSpringCloudService.ResourceGroupName,
			ServiceName:           exampleSpringCloudService.Name,
			KeyVaultCertificateId: exampleCertificate.ID(),
			ExcludePrivateKey:     pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.core.CoreFunctions;
import com.pulumi.azuread.AzureadFunctions;
import com.pulumi.azuread.inputs.GetServicePrincipalArgs;
import com.pulumi.azure.keyvault.KeyVault;
import com.pulumi.azure.keyvault.KeyVaultArgs;
import com.pulumi.azure.keyvault.inputs.KeyVaultAccessPolicyArgs;
import com.pulumi.azure.keyvault.Certificate;
import com.pulumi.azure.keyvault.CertificateArgs;
import com.pulumi.azure.keyvault.inputs.CertificateCertificatePolicyArgs;
import com.pulumi.azure.keyvault.inputs.CertificateCertificatePolicyIssuerParametersArgs;
import com.pulumi.azure.keyvault.inputs.CertificateCertificatePolicyKeyPropertiesArgs;
import com.pulumi.azure.keyvault.inputs.CertificateCertificatePolicySecretPropertiesArgs;
import com.pulumi.azure.keyvault.inputs.CertificateCertificatePolicyX509CertificatePropertiesArgs;
import com.pulumi.azure.appplatform.SpringCloudService;
import com.pulumi.azure.appplatform.SpringCloudServiceArgs;
import com.pulumi.azure.appplatform.SpringCloudCertificate;
import com.pulumi.azure.appplatform.SpringCloudCertificateArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()        
            .location("West Europe")
            .build());

        final var current = CoreFunctions.getClientConfig();

        final var exampleServicePrincipal = AzureadFunctions.getServicePrincipal(GetServicePrincipalArgs.builder()
            .displayName("Azure Spring Cloud Resource Provider")
            .build());

        var exampleKeyVault = new KeyVault("exampleKeyVault", KeyVaultArgs.builder()        
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .tenantId(current.applyValue(getClientConfigResult -> getClientConfigResult.tenantId()))
            .skuName("standard")
            .accessPolicies(            
                KeyVaultAccessPolicyArgs.builder()
                    .tenantId(current.applyValue(getClientConfigResult -> getClientConfigResult.tenantId()))
                    .objectId(current.applyValue(getClientConfigResult -> getClientConfigResult.objectId()))
                    .secretPermissions("Set")
                    .certificatePermissions(                    
                        "Create",
                        "Delete",
                        "Get",
                        "Update")
                    .build(),
                KeyVaultAccessPolicyArgs.builder()
                    .tenantId(current.applyValue(getClientConfigResult -> getClientConfigResult.tenantId()))
                    .objectId(exampleServicePrincipal.applyValue(getServicePrincipalResult -> getServicePrincipalResult.objectId()))
                    .secretPermissions(                    
                        "Get",
                        "List")
                    .certificatePermissions(                    
                        "Get",
                        "List")
                    .build())
            .build());

        var exampleCertificate = new Certificate("exampleCertificate", CertificateArgs.builder()        
            .keyVaultId(exampleKeyVault.id())
            .certificatePolicy(CertificateCertificatePolicyArgs.builder()
                .issuerParameters(CertificateCertificatePolicyIssuerParametersArgs.builder()
                    .name("Self")
                    .build())
                .keyProperties(CertificateCertificatePolicyKeyPropertiesArgs.builder()
                    .exportable(true)
                    .keySize(2048)
                    .keyType("RSA")
                    .reuseKey(true)
                    .build())
                .lifetimeActions(CertificateCertificatePolicyLifetimeActionArgs.builder()
                    .action(CertificateCertificatePolicyLifetimeActionActionArgs.builder()
                        .actionType("AutoRenew")
                        .build())
                    .trigger(CertificateCertificatePolicyLifetimeActionTriggerArgs.builder()
                        .daysBeforeExpiry(30)
                        .build())
                    .build())
                .secretProperties(CertificateCertificatePolicySecretPropertiesArgs.builder()
                    .contentType("application/x-pkcs12")
                    .build())
                .x509CertificateProperties(CertificateCertificatePolicyX509CertificatePropertiesArgs.builder()
                    .keyUsages(                    
                        "cRLSign",
                        "dataEncipherment",
                        "digitalSignature",
                        "keyAgreement",
                        "keyCertSign",
                        "keyEncipherment")
                    .subject("CN=contoso.com")
                    .validityInMonths(12)
                    .build())
                .build())
            .build());

        var exampleSpringCloudService = new SpringCloudService("exampleSpringCloudService", SpringCloudServiceArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .build());

        var exampleSpringCloudCertificate = new SpringCloudCertificate("exampleSpringCloudCertificate", SpringCloudCertificateArgs.builder()        
            .resourceGroupName(exampleSpringCloudService.resourceGroupName())
            .serviceName(exampleSpringCloudService.name())
            .keyVaultCertificateId(exampleCertificate.id())
            .excludePrivateKey(true)
            .build());

    }
}

import pulumi
import pulumi_azure as azure
import pulumi_azuread as azuread

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
current = azure.core.get_client_config()
example_service_principal = azuread.get_service_principal(display_name="Azure Spring Cloud Resource Provider")
example_key_vault = azure.keyvault.KeyVault("exampleKeyVault",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    tenant_id=current.tenant_id,
    sku_name="standard",
    access_policies=[
        azure.keyvault.KeyVaultAccessPolicyArgs(
            tenant_id=current.tenant_id,
            object_id=current.object_id,
            secret_permissions=["Set"],
            certificate_permissions=[
                "Create",
                "Delete",
                "Get",
                "Update",
            ],
        ),
        azure.keyvault.KeyVaultAccessPolicyArgs(
            tenant_id=current.tenant_id,
            object_id=example_service_principal.object_id,
            secret_permissions=[
                "Get",
                "List",
            ],
            certificate_permissions=[
                "Get",
                "List",
            ],
        ),
    ])
example_certificate = azure.keyvault.Certificate("exampleCertificate",
    key_vault_id=example_key_vault.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=contoso.com",
            validity_in_months=12,
        ),
    ))
example_spring_cloud_service = azure.appplatform.SpringCloudService("exampleSpringCloudService",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location)
example_spring_cloud_certificate = azure.appplatform.SpringCloudCertificate("exampleSpringCloudCertificate",
    resource_group_name=example_spring_cloud_service.resource_group_name,
    service_name=example_spring_cloud_service.name,
    key_vault_certificate_id=example_certificate.id,
    exclude_private_key=True)

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

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const current = azure.core.getClientConfig({});
const exampleServicePrincipal = azuread.getServicePrincipal({
    displayName: "Azure Spring Cloud Resource Provider",
});
const exampleKeyVault = new azure.keyvault.KeyVault("exampleKeyVault", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    tenantId: current.then(current => current.tenantId),
    skuName: "standard",
    accessPolicies: [
        {
            tenantId: current.then(current => current.tenantId),
            objectId: current.then(current => current.objectId),
            secretPermissions: ["Set"],
            certificatePermissions: [
                "Create",
                "Delete",
                "Get",
                "Update",
            ],
        },
        {
            tenantId: current.then(current => current.tenantId),
            objectId: exampleServicePrincipal.then(exampleServicePrincipal => exampleServicePrincipal.objectId),
            secretPermissions: [
                "Get",
                "List",
            ],
            certificatePermissions: [
                "Get",
                "List",
            ],
        },
    ],
});
const exampleCertificate = new azure.keyvault.Certificate("exampleCertificate", {
    keyVaultId: exampleKeyVault.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=contoso.com",
            validityInMonths: 12,
        },
    },
});
const exampleSpringCloudService = new azure.appplatform.SpringCloudService("exampleSpringCloudService", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
});
const exampleSpringCloudCertificate = new azure.appplatform.SpringCloudCertificate("exampleSpringCloudCertificate", {
    resourceGroupName: exampleSpringCloudService.resourceGroupName,
    serviceName: exampleSpringCloudService.name,
    keyVaultCertificateId: exampleCertificate.id,
    excludePrivateKey: true,
});

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    properties:
      location: West Europe
  exampleKeyVault:
    type: azure:keyvault:KeyVault
    properties:
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      tenantId: ${current.tenantId}
      skuName: standard
      accessPolicies:
        - tenantId: ${current.tenantId}
          objectId: ${current.objectId}
          secretPermissions:
            - Set
          certificatePermissions:
            - Create
            - Delete
            - Get
            - Update
        - tenantId: ${current.tenantId}
          objectId: ${exampleServicePrincipal.objectId}
          secretPermissions:
            - Get
            - List
          certificatePermissions:
            - Get
            - List
  exampleCertificate:
    type: azure:keyvault:Certificate
    properties:
      keyVaultId: ${exampleKeyVault.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=contoso.com
          validityInMonths: 12
  exampleSpringCloudService:
    type: azure:appplatform:SpringCloudService
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
  exampleSpringCloudCertificate:
    type: azure:appplatform:SpringCloudCertificate
    properties:
      resourceGroupName: ${exampleSpringCloudService.resourceGroupName}
      serviceName: ${exampleSpringCloudService.name}
      keyVaultCertificateId: ${exampleCertificate.id}
      excludePrivateKey: true
variables:
  current:
    fn::invoke:
      Function: azure:core:getClientConfig
      Arguments: {}
  exampleServicePrincipal:
    fn::invoke:
      Function: azuread:getServicePrincipal
      Arguments:
        displayName: Azure Spring Cloud Resource Provider