pulumi-azure-native-kotlin/com.pulumi.azurenative.app.kotlin/Build

Build

class Build : KotlinCustomResource

Information pertaining to an individual build. Uses Azure REST API version 2024-10-02-preview. In version 2.x of the Azure Native provider, it used API version 2023-08-01-preview. Other available API versions: 2023-08-01-preview, 2023-11-02-preview, 2024-02-02-preview, 2024-08-02-preview, 2025-02-02-preview. These can be accessed by generating a local SDK package using the CLI command pulumi package add azure-native app [ApiVersion]. See the ../../../version-guide/#accessing-any-api-version-via-local-packages for details.

Example Usage

Builds_CreateOrUpdate_NoConfig

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var build = new AzureNative.App.Build("build", new()
    {
        BuildName = "testBuild",
        BuilderName = "testBuilder",
        ResourceGroupName = "rg",
    });
});
Content copied to clipboard
package main
import (
	app "github.com/pulumi/pulumi-azure-native-sdk/app/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := app.NewBuild(ctx, "build", &app.BuildArgs{
			BuildName:         pulumi.String("testBuild"),
			BuilderName:       pulumi.String("testBuilder"),
			ResourceGroupName: pulumi.String("rg"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.app.Build;
import com.pulumi.azurenative.app.BuildArgs;
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 build = new Build("build", BuildArgs.builder()
            .buildName("testBuild")
            .builderName("testBuilder")
            .resourceGroupName("rg")
            .build());
    }
}
Content copied to clipboard

Builds_CreateOrUpdate_WithConfig

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var build = new AzureNative.App.Build("build", new()
    {
        BuildName = "testBuild-123456789az",
        BuilderName = "testBuilder",
        Configuration = new AzureNative.App.Inputs.BuildConfigurationArgs
        {
            BaseOs = "DebianBullseye",
            EnvironmentVariables = new[]
            {
                new AzureNative.App.Inputs.EnvironmentVariableArgs
                {
                    Name = "foo1",
                    Value = "bar1",
                },
                new AzureNative.App.Inputs.EnvironmentVariableArgs
                {
                    Name = "foo2",
                    Value = "bar2",
                },
            },
            Platform = "dotnetcore",
            PlatformVersion = "7.0",
            PreBuildSteps = new[]
            {
                new AzureNative.App.Inputs.PreBuildStepArgs
                {
                    Description = "First pre build step.",
                    HttpGet = new AzureNative.App.Inputs.HttpGetArgs
                    {
                        FileName = "output.txt",
                        Headers = new[]
                        {
                            "foo",
                            "bar",
                        },
                        Url = "https://microsoft.com",
                    },
                    Scripts = new[]
                    {
                        "echo 'hello'",
                        "echo 'world'",
                    },
                },
                new AzureNative.App.Inputs.PreBuildStepArgs
                {
                    Description = "Second pre build step.",
                    HttpGet = new AzureNative.App.Inputs.HttpGetArgs
                    {
                        FileName = "output.txt",
                        Headers = new[]
                        {
                            "foo",
                        },
                        Url = "https://microsoft.com",
                    },
                    Scripts = new[]
                    {
                        "echo 'hello'",
                        "echo 'again'",
                    },
                },
            },
        },
        DestinationContainerRegistry = new AzureNative.App.Inputs.ContainerRegistryWithCustomImageArgs
        {
            Image = "test.azurecr.io/repo:tag",
            Server = "test.azurecr.io",
        },
        ResourceGroupName = "rg",
    });
});
Content copied to clipboard
package main
import (
	app "github.com/pulumi/pulumi-azure-native-sdk/app/v3"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := app.NewBuild(ctx, "build", &app.BuildArgs{
			BuildName:   pulumi.String("testBuild-123456789az"),
			BuilderName: pulumi.String("testBuilder"),
			Configuration: &app.BuildConfigurationArgs{
				BaseOs: pulumi.String("DebianBullseye"),
				EnvironmentVariables: app.EnvironmentVariableArray{
					&app.EnvironmentVariableArgs{
						Name:  pulumi.String("foo1"),
						Value: pulumi.String("bar1"),
					},
					&app.EnvironmentVariableArgs{
						Name:  pulumi.String("foo2"),
						Value: pulumi.String("bar2"),
					},
				},
				Platform:        pulumi.String("dotnetcore"),
				PlatformVersion: pulumi.String("7.0"),
				PreBuildSteps: app.PreBuildStepArray{
					&app.PreBuildStepArgs{
						Description: pulumi.String("First pre build step."),
						HttpGet: &app.HttpGetArgs{
							FileName: pulumi.String("output.txt"),
							Headers: pulumi.StringArray{
								pulumi.String("foo"),
								pulumi.String("bar"),
							},
							Url: pulumi.String("https://microsoft.com"),
						},
						Scripts: pulumi.StringArray{
							pulumi.String("echo 'hello'"),
							pulumi.String("echo 'world'"),
						},
					},
					&app.PreBuildStepArgs{
						Description: pulumi.String("Second pre build step."),
						HttpGet: &app.HttpGetArgs{
							FileName: pulumi.String("output.txt"),
							Headers: pulumi.StringArray{
								pulumi.String("foo"),
							},
							Url: pulumi.String("https://microsoft.com"),
						},
						Scripts: pulumi.StringArray{
							pulumi.String("echo 'hello'"),
							pulumi.String("echo 'again'"),
						},
					},
				},
			},
			DestinationContainerRegistry: &app.ContainerRegistryWithCustomImageArgs{
				Image:  pulumi.String("test.azurecr.io/repo:tag"),
				Server: pulumi.String("test.azurecr.io"),
			},
			ResourceGroupName: pulumi.String("rg"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.app.Build;
import com.pulumi.azurenative.app.BuildArgs;
import com.pulumi.azurenative.app.inputs.BuildConfigurationArgs;
import com.pulumi.azurenative.app.inputs.ContainerRegistryWithCustomImageArgs;
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 build = new Build("build", BuildArgs.builder()
            .buildName("testBuild-123456789az")
            .builderName("testBuilder")
            .configuration(BuildConfigurationArgs.builder()
                .baseOs("DebianBullseye")
                .environmentVariables(
                    EnvironmentVariableArgs.builder()
                        .name("foo1")
                        .value("bar1")
                        .build(),
                    EnvironmentVariableArgs.builder()
                        .name("foo2")
                        .value("bar2")
                        .build())
                .platform("dotnetcore")
                .platformVersion("7.0")
                .preBuildSteps(
                    PreBuildStepArgs.builder()
                        .description("First pre build step.")
                        .httpGet(HttpGetArgs.builder()
                            .fileName("output.txt")
                            .headers(
                                "foo",
                                "bar")
                            .url("https://microsoft.com")
                            .build())
                        .scripts(
                            "echo 'hello'",
                            "echo 'world'")
                        .build(),
                    PreBuildStepArgs.builder()
                        .description("Second pre build step.")
                        .httpGet(HttpGetArgs.builder()
                            .fileName("output.txt")
                            .headers("foo")
                            .url("https://microsoft.com")
                            .build())
                        .scripts(
                            "echo 'hello'",
                            "echo 'again'")
                        .build())
                .build())
            .destinationContainerRegistry(ContainerRegistryWithCustomImageArgs.builder()
                .image("test.azurecr.io/repo:tag")
                .server("test.azurecr.io")
                .build())
            .resourceGroupName("rg")
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:app:Build testBuild-123456789az /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.App/builders/{builderName}/builds/{buildName}
Content copied to clipboard

Properties

Link copied to clipboard
val azureApiVersion: Output<String>

The Azure API version of the resource.

Link copied to clipboard
val buildStatus: Output<String>

Status of the build once it has been provisioned.

Link copied to clipboard
val configuration: Output<BuildConfigurationResponse>?

Configuration of the build.

Link copied to clipboard
val destinationContainerRegistry: Output<ContainerRegistryWithCustomImageResponse>?

Container registry that the final image will be uploaded to.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val logStreamEndpoint: Output<String>

Endpoint from which the build logs can be streamed.

Link copied to clipboard
val name: Output<String>

The name of the resource

Link copied to clipboard
val provisioningState: Output<String>

Build provisioning state.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val systemData: Output<SystemDataResponse>

Azure Resource Manager metadata containing createdBy and modifiedBy information.

Link copied to clipboard
val tokenEndpoint: Output<String>

Endpoint to use to retrieve an authentication token for log streaming and uploading source code.

Link copied to clipboard
val type: Output<String>

The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"

Link copied to clipboard
val uploadEndpoint: Output<String>

Endpoint to which the source code should be uploaded.

Link copied to clipboard
val urn: Output<String>