azure.appservice.PublicCertificate

using System;
using System.Collections.Generic;
using System.IO;
using Pulumi;
using Azure = Pulumi.Azure;

	private static string ReadFileBase64(string path) {
		return Convert.ToBase64String(Encoding.UTF8.GetBytes(File.ReadAllText(path)))
	}

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

    var examplePlan = new Azure.AppService.Plan("examplePlan", new()
    {
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        Sku = new Azure.AppService.Inputs.PlanSkuArgs
        {
            Tier = "Standard",
            Size = "S1",
        },
    });

    var exampleAppService = new Azure.AppService.AppService("exampleAppService", new()
    {
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        AppServicePlanId = examplePlan.Id,
    });

    var examplePublicCertificate = new Azure.AppService.PublicCertificate("examplePublicCertificate", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        AppServiceName = exampleAppService.Name,
        CertificateName = "example-public-certificate",
        CertificateLocation = "Unknown",
        Blob = ReadFileBase64("app_service_public_certificate.cer"),
    });

});

package main

import (
	"encoding/base64"
	"os"

	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/appservice"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func filebase64OrPanic(path string) pulumi.StringPtrInput {
	if fileData, err := os.ReadFile(path); err == nil {
		return pulumi.String(base64.StdEncoding.EncodeToString(fileData[:]))
	} else {
		panic(err.Error())
	}
}

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
		}
		examplePlan, err := appservice.NewPlan(ctx, "examplePlan", &appservice.PlanArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			Sku: &appservice.PlanSkuArgs{
				Tier: pulumi.String("Standard"),
				Size: pulumi.String("S1"),
			},
		})
		if err != nil {
			return err
		}
		exampleAppService, err := appservice.NewAppService(ctx, "exampleAppService", &appservice.AppServiceArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			AppServicePlanId:  examplePlan.ID(),
		})
		if err != nil {
			return err
		}
		_, err = appservice.NewPublicCertificate(ctx, "examplePublicCertificate", &appservice.PublicCertificateArgs{
			ResourceGroupName:   exampleResourceGroup.Name,
			AppServiceName:      exampleAppService.Name,
			CertificateName:     pulumi.String("example-public-certificate"),
			CertificateLocation: pulumi.String("Unknown"),
			Blob:                filebase64OrPanic("app_service_public_certificate.cer"),
		})
		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.appservice.Plan;
import com.pulumi.azure.appservice.PlanArgs;
import com.pulumi.azure.appservice.inputs.PlanSkuArgs;
import com.pulumi.azure.appservice.AppService;
import com.pulumi.azure.appservice.AppServiceArgs;
import com.pulumi.azure.appservice.PublicCertificate;
import com.pulumi.azure.appservice.PublicCertificateArgs;
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());

        var examplePlan = new Plan("examplePlan", PlanArgs.builder()        
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .sku(PlanSkuArgs.builder()
                .tier("Standard")
                .size("S1")
                .build())
            .build());

        var exampleAppService = new AppService("exampleAppService", AppServiceArgs.builder()        
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .appServicePlanId(examplePlan.id())
            .build());

        var examplePublicCertificate = new PublicCertificate("examplePublicCertificate", PublicCertificateArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .appServiceName(exampleAppService.name())
            .certificateName("example-public-certificate")
            .certificateLocation("Unknown")
            .blob(Base64.getEncoder().encodeToString(Files.readAllBytes(Paths.get("app_service_public_certificate.cer"))))
            .build());

    }
}

import pulumi
import base64
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_plan = azure.appservice.Plan("examplePlan",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    sku=azure.appservice.PlanSkuArgs(
        tier="Standard",
        size="S1",
    ))
example_app_service = azure.appservice.AppService("exampleAppService",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    app_service_plan_id=example_plan.id)
example_public_certificate = azure.appservice.PublicCertificate("examplePublicCertificate",
    resource_group_name=example_resource_group.name,
    app_service_name=example_app_service.name,
    certificate_name="example-public-certificate",
    certificate_location="Unknown",
    blob=(lambda path: base64.b64encode(open(path).read().encode()).decode())("app_service_public_certificate.cer"))

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

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const examplePlan = new azure.appservice.Plan("examplePlan", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    sku: {
        tier: "Standard",
        size: "S1",
    },
});
const exampleAppService = new azure.appservice.AppService("exampleAppService", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    appServicePlanId: examplePlan.id,
});
const examplePublicCertificate = new azure.appservice.PublicCertificate("examplePublicCertificate", {
    resourceGroupName: exampleResourceGroup.name,
    appServiceName: exampleAppService.name,
    certificateName: "example-public-certificate",
    certificateLocation: "Unknown",
    blob: Buffer.from(fs.readFileSync("app_service_public_certificate.cer"), 'binary').toString('base64'),
});