CodeSigningConfig class

Manages an AWS Lambda Code Signing Config. Use this resource to define allowed signing profiles and code-signing validation policies for Lambda functions to ensure code integrity and authenticity.

For information about Lambda code signing configurations and how to use them, see configuring code signing for Lambda functions.

Example Usage

Basic Usage

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

// Create signing profiles for different environments
const prod = new aws.signer.SigningProfile("prod", {
    platformId: "AWSLambda-SHA384-ECDSA",
    namePrefix: "prod_lambda_",
    tags: {
        Environment: "production",
    },
});
const dev = new aws.signer.SigningProfile("dev", {
    platformId: "AWSLambda-SHA384-ECDSA",
    namePrefix: "dev_lambda_",
    tags: {
        Environment: "development",
    },
});
// Code signing configuration with enforcement
const example = new aws.lambda.CodeSigningConfig("example", {
    allowedPublishers: {
        signingProfileVersionArns: [
            prod.versionArn,
            dev.versionArn,
        ],
    },
    policies: {
        untrustedArtifactOnDeployment: "Enforce",
    },
    description: "Code signing configuration for Lambda functions",
    tags: {
        Environment: "production",
        Purpose: "code-signing",
    },
});

import pulumi
import pulumi_aws as aws

# Create signing profiles for different environments
prod = aws.signer.SigningProfile("prod",
    platform_id="AWSLambda-SHA384-ECDSA",
    name_prefix="prod_lambda_",
    tags={
        "Environment": "production",
    })
dev = aws.signer.SigningProfile("dev",
    platform_id="AWSLambda-SHA384-ECDSA",
    name_prefix="dev_lambda_",
    tags={
        "Environment": "development",
    })
# Code signing configuration with enforcement
example = aws.lambda_.CodeSigningConfig("example",
    allowed_publishers={
        "signing_profile_version_arns": [
            prod.version_arn,
            dev.version_arn,
        ],
    },
    policies={
        "untrusted_artifact_on_deployment": "Enforce",
    },
    description="Code signing configuration for Lambda functions",
    tags={
        "Environment": "production",
        "Purpose": "code-signing",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Create signing profiles for different environments
    var prod = new Aws.Signer.SigningProfile("prod", new()
    {
        PlatformId = "AWSLambda-SHA384-ECDSA",
        NamePrefix = "prod_lambda_",
        Tags =
        {
            { "Environment", "production" },
        },
    });

    var dev = new Aws.Signer.SigningProfile("dev", new()
    {
        PlatformId = "AWSLambda-SHA384-ECDSA",
        NamePrefix = "dev_lambda_",
        Tags =
        {
            { "Environment", "development" },
        },
    });

    // Code signing configuration with enforcement
    var example = new Aws.Lambda.CodeSigningConfig("example", new()
    {
        AllowedPublishers = new Aws.Lambda.Inputs.CodeSigningConfigAllowedPublishersArgs
        {
            SigningProfileVersionArns = new[]
            {
                prod.VersionArn,
                dev.VersionArn,
            },
        },
        Policies = new Aws.Lambda.Inputs.CodeSigningConfigPoliciesArgs
        {
            UntrustedArtifactOnDeployment = "Enforce",
        },
        Description = "Code signing configuration for Lambda functions",
        Tags =
        {
            { "Environment", "production" },
            { "Purpose", "code-signing" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/signer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create signing profiles for different environments
		prod, err := signer.NewSigningProfile(ctx, "prod", &signer.SigningProfileArgs{
			PlatformId: pulumi.String("AWSLambda-SHA384-ECDSA"),
			NamePrefix: pulumi.String("prod_lambda_"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("production"),
			},
		})
		if err != nil {
			return err
		}
		dev, err := signer.NewSigningProfile(ctx, "dev", &signer.SigningProfileArgs{
			PlatformId: pulumi.String("AWSLambda-SHA384-ECDSA"),
			NamePrefix: pulumi.String("dev_lambda_"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("development"),
			},
		})
		if err != nil {
			return err
		}
		// Code signing configuration with enforcement
		_, err = lambda.NewCodeSigningConfig(ctx, "example", &lambda.CodeSigningConfigArgs{
			AllowedPublishers: &lambda.CodeSigningConfigAllowedPublishersArgs{
				SigningProfileVersionArns: pulumi.StringArray{
					prod.VersionArn,
					dev.VersionArn,
				},
			},
			Policies: &lambda.CodeSigningConfigPoliciesArgs{
				UntrustedArtifactOnDeployment: pulumi.String("Enforce"),
			},
			Description: pulumi.String("Code signing configuration for Lambda functions"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("production"),
				"Purpose":     pulumi.String("code-signing"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

# Create signing profiles for different environments
resource "aws_signer_signingprofile" "prod" {
  platform_id = "AWSLambda-SHA384-ECDSA"
  name_prefix = "prod_lambda_"
  tags = {
    "Environment" = "production"
  }
}
resource "aws_signer_signingprofile" "dev" {
  platform_id = "AWSLambda-SHA384-ECDSA"
  name_prefix = "dev_lambda_"
  tags = {
    "Environment" = "development"
  }
}
# Code signing configuration with enforcement
resource "aws_lambda_codesigningconfig" "example" {
  allowed_publishers = {
    signing_profile_version_arns = [aws_signer_signingprofile.prod.version_arn, aws_signer_signingprofile.dev.version_arn]
  }
  policies = {
    untrusted_artifact_on_deployment = "Enforce"
  }
  description = "Code signing configuration for Lambda functions"
  tags = {
    "Environment" = "production"
    "Purpose"     = "code-signing"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.signer.SigningProfile;
import com.pulumi.aws.signer.SigningProfileArgs;
import com.pulumi.aws.lambda.CodeSigningConfig;
import com.pulumi.aws.lambda.CodeSigningConfigArgs;
import com.pulumi.aws.lambda.inputs.CodeSigningConfigAllowedPublishersArgs;
import com.pulumi.aws.lambda.inputs.CodeSigningConfigPoliciesArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Create signing profiles for different environments
        var prod = new SigningProfile("prod", SigningProfileArgs.builder()
            .platformId("AWSLambda-SHA384-ECDSA")
            .namePrefix("prod_lambda_")
            .tags(Map.of("Environment", "production"))
            .build());

        var dev = new SigningProfile("dev", SigningProfileArgs.builder()
            .platformId("AWSLambda-SHA384-ECDSA")
            .namePrefix("dev_lambda_")
            .tags(Map.of("Environment", "development"))
            .build());

        // Code signing configuration with enforcement
        var example = new CodeSigningConfig("example", CodeSigningConfigArgs.builder()
            .allowedPublishers(CodeSigningConfigAllowedPublishersArgs.builder()
                .signingProfileVersionArns(
                    prod.versionArn(),
                    dev.versionArn())
                .build())
            .policies(CodeSigningConfigPoliciesArgs.builder()
                .untrustedArtifactOnDeployment("Enforce")
                .build())
            .description("Code signing configuration for Lambda functions")
            .tags(Map.ofEntries(
                Map.entry("Environment", "production"),
                Map.entry("Purpose", "code-signing")
            ))
            .build());

    }
}

resources:
  # Create signing profiles for different environments
  prod:
    type: aws:signer:SigningProfile
    properties:
      platformId: AWSLambda-SHA384-ECDSA
      namePrefix: prod_lambda_
      tags:
        Environment: production
  dev:
    type: aws:signer:SigningProfile
    properties:
      platformId: AWSLambda-SHA384-ECDSA
      namePrefix: dev_lambda_
      tags:
        Environment: development
  # Code signing configuration with enforcement
  example:
    type: aws:lambda:CodeSigningConfig
    properties:
      allowedPublishers:
        signingProfileVersionArns:
          - ${prod.versionArn}
          - ${dev.versionArn}
      policies:
        untrustedArtifactOnDeployment: Enforce
      description: Code signing configuration for Lambda functions
      tags:
        Environment: production
        Purpose: code-signing

Warning Only Configuration

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

const example = new aws.lambda.CodeSigningConfig("example", {
    allowedPublishers: {
        signingProfileVersionArns: [dev.versionArn],
    },
    policies: {
        untrustedArtifactOnDeployment: "Warn",
    },
    description: "Development code signing configuration",
    tags: {
        Environment: "development",
        Purpose: "code-signing",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.lambda_.CodeSigningConfig("example",
    allowed_publishers={
        "signing_profile_version_arns": [dev["versionArn"]],
    },
    policies={
        "untrusted_artifact_on_deployment": "Warn",
    },
    description="Development code signing configuration",
    tags={
        "Environment": "development",
        "Purpose": "code-signing",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Lambda.CodeSigningConfig("example", new()
    {
        AllowedPublishers = new Aws.Lambda.Inputs.CodeSigningConfigAllowedPublishersArgs
        {
            SigningProfileVersionArns = new[]
            {
                dev.VersionArn,
            },
        },
        Policies = new Aws.Lambda.Inputs.CodeSigningConfigPoliciesArgs
        {
            UntrustedArtifactOnDeployment = "Warn",
        },
        Description = "Development code signing configuration",
        Tags =
        {
            { "Environment", "development" },
            { "Purpose", "code-signing" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lambda.NewCodeSigningConfig(ctx, "example", &lambda.CodeSigningConfigArgs{
			AllowedPublishers: &lambda.CodeSigningConfigAllowedPublishersArgs{
				SigningProfileVersionArns: pulumi.StringArray{
					dev.VersionArn,
				},
			},
			Policies: &lambda.CodeSigningConfigPoliciesArgs{
				UntrustedArtifactOnDeployment: pulumi.String("Warn"),
			},
			Description: pulumi.String("Development code signing configuration"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("development"),
				"Purpose":     pulumi.String("code-signing"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_lambda_codesigningconfig" "example" {
  allowed_publishers = {
    signing_profile_version_arns = [dev.versionArn]
  }
  policies = {
    untrusted_artifact_on_deployment = "Warn"
  }
  description = "Development code signing configuration"
  tags = {
    "Environment" = "development"
    "Purpose"     = "code-signing"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.CodeSigningConfig;
import com.pulumi.aws.lambda.CodeSigningConfigArgs;
import com.pulumi.aws.lambda.inputs.CodeSigningConfigAllowedPublishersArgs;
import com.pulumi.aws.lambda.inputs.CodeSigningConfigPoliciesArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new CodeSigningConfig("example", CodeSigningConfigArgs.builder()
            .allowedPublishers(CodeSigningConfigAllowedPublishersArgs.builder()
                .signingProfileVersionArns(dev.versionArn())
                .build())
            .policies(CodeSigningConfigPoliciesArgs.builder()
                .untrustedArtifactOnDeployment("Warn")
                .build())
            .description("Development code signing configuration")
            .tags(Map.ofEntries(
                Map.entry("Environment", "development"),
                Map.entry("Purpose", "code-signing")
            ))
            .build());

    }
}

resources:
  example:
    type: aws:lambda:CodeSigningConfig
    properties:
      allowedPublishers:
        signingProfileVersionArns:
          - ${dev.versionArn}
      policies:
        untrustedArtifactOnDeployment: Warn
      description: Development code signing configuration
      tags:
        Environment: development
        Purpose: code-signing

Multiple Environment Configuration

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

// Production signing configuration
const prod = new aws.lambda.CodeSigningConfig("prod", {
    allowedPublishers: {
        signingProfileVersionArns: [prodAwsSignerSigningProfile.versionArn],
    },
    policies: {
        untrustedArtifactOnDeployment: "Enforce",
    },
    description: "Production code signing configuration with strict enforcement",
    tags: {
        Environment: "production",
        Security: "strict",
    },
});
// Development signing configuration
const dev = new aws.lambda.CodeSigningConfig("dev", {
    allowedPublishers: {
        signingProfileVersionArns: [
            devAwsSignerSigningProfile.versionArn,
            test.versionArn,
        ],
    },
    policies: {
        untrustedArtifactOnDeployment: "Warn",
    },
    description: "Development code signing configuration with warnings",
    tags: {
        Environment: "development",
        Security: "flexible",
    },
});

import pulumi
import pulumi_aws as aws

# Production signing configuration
prod = aws.lambda_.CodeSigningConfig("prod",
    allowed_publishers={
        "signing_profile_version_arns": [prod_aws_signer_signing_profile["versionArn"]],
    },
    policies={
        "untrusted_artifact_on_deployment": "Enforce",
    },
    description="Production code signing configuration with strict enforcement",
    tags={
        "Environment": "production",
        "Security": "strict",
    })
# Development signing configuration
dev = aws.lambda_.CodeSigningConfig("dev",
    allowed_publishers={
        "signing_profile_version_arns": [
            dev_aws_signer_signing_profile["versionArn"],
            test["versionArn"],
        ],
    },
    policies={
        "untrusted_artifact_on_deployment": "Warn",
    },
    description="Development code signing configuration with warnings",
    tags={
        "Environment": "development",
        "Security": "flexible",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Production signing configuration
    var prod = new Aws.Lambda.CodeSigningConfig("prod", new()
    {
        AllowedPublishers = new Aws.Lambda.Inputs.CodeSigningConfigAllowedPublishersArgs
        {
            SigningProfileVersionArns = new[]
            {
                prodAwsSignerSigningProfile.VersionArn,
            },
        },
        Policies = new Aws.Lambda.Inputs.CodeSigningConfigPoliciesArgs
        {
            UntrustedArtifactOnDeployment = "Enforce",
        },
        Description = "Production code signing configuration with strict enforcement",
        Tags =
        {
            { "Environment", "production" },
            { "Security", "strict" },
        },
    });

    // Development signing configuration
    var dev = new Aws.Lambda.CodeSigningConfig("dev", new()
    {
        AllowedPublishers = new Aws.Lambda.Inputs.CodeSigningConfigAllowedPublishersArgs
        {
            SigningProfileVersionArns = new[]
            {
                devAwsSignerSigningProfile.VersionArn,
                test.VersionArn,
            },
        },
        Policies = new Aws.Lambda.Inputs.CodeSigningConfigPoliciesArgs
        {
            UntrustedArtifactOnDeployment = "Warn",
        },
        Description = "Development code signing configuration with warnings",
        Tags =
        {
            { "Environment", "development" },
            { "Security", "flexible" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Production signing configuration
		_, err := lambda.NewCodeSigningConfig(ctx, "prod", &lambda.CodeSigningConfigArgs{
			AllowedPublishers: &lambda.CodeSigningConfigAllowedPublishersArgs{
				SigningProfileVersionArns: pulumi.StringArray{
					prodAwsSignerSigningProfile.VersionArn,
				},
			},
			Policies: &lambda.CodeSigningConfigPoliciesArgs{
				UntrustedArtifactOnDeployment: pulumi.String("Enforce"),
			},
			Description: pulumi.String("Production code signing configuration with strict enforcement"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("production"),
				"Security":    pulumi.String("strict"),
			},
		})
		if err != nil {
			return err
		}
		// Development signing configuration
		_, err = lambda.NewCodeSigningConfig(ctx, "dev", &lambda.CodeSigningConfigArgs{
			AllowedPublishers: &lambda.CodeSigningConfigAllowedPublishersArgs{
				SigningProfileVersionArns: pulumi.StringArray{
					devAwsSignerSigningProfile.VersionArn,
					test.VersionArn,
				},
			},
			Policies: &lambda.CodeSigningConfigPoliciesArgs{
				UntrustedArtifactOnDeployment: pulumi.String("Warn"),
			},
			Description: pulumi.String("Development code signing configuration with warnings"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("development"),
				"Security":    pulumi.String("flexible"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

# Production signing configuration
resource "aws_lambda_codesigningconfig" "prod" {
  allowed_publishers = {
    signing_profile_version_arns = [prodAwsSignerSigningProfile.versionArn]
  }
  policies = {
    untrusted_artifact_on_deployment = "Enforce"
  }
  description = "Production code signing configuration with strict enforcement"
  tags = {
    "Environment" = "production"
    "Security"    = "strict"
  }
}
# Development signing configuration
resource "aws_lambda_codesigningconfig" "dev" {
  allowed_publishers = {
    signing_profile_version_arns = [devAwsSignerSigningProfile.versionArn, test.versionArn]
  }
  policies = {
    untrusted_artifact_on_deployment = "Warn"
  }
  description = "Development code signing configuration with warnings"
  tags = {
    "Environment" = "development"
    "Security"    = "flexible"
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.CodeSigningConfig;
import com.pulumi.aws.lambda.CodeSigningConfigArgs;
import com.pulumi.aws.lambda.inputs.CodeSigningConfigAllowedPublishersArgs;
import com.pulumi.aws.lambda.inputs.CodeSigningConfigPoliciesArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Production signing configuration
        var prod = new CodeSigningConfig("prod", CodeSigningConfigArgs.builder()
            .allowedPublishers(CodeSigningConfigAllowedPublishersArgs.builder()
                .signingProfileVersionArns(prodAwsSignerSigningProfile.versionArn())
                .build())
            .policies(CodeSigningConfigPoliciesArgs.builder()
                .untrustedArtifactOnDeployment("Enforce")
                .build())
            .description("Production code signing configuration with strict enforcement")
            .tags(Map.ofEntries(
                Map.entry("Environment", "production"),
                Map.entry("Security", "strict")
            ))
            .build());

        // Development signing configuration
        var dev = new CodeSigningConfig("dev", CodeSigningConfigArgs.builder()
            .allowedPublishers(CodeSigningConfigAllowedPublishersArgs.builder()
                .signingProfileVersionArns(
                    devAwsSignerSigningProfile.versionArn(),
                    test.versionArn())
                .build())
            .policies(CodeSigningConfigPoliciesArgs.builder()
                .untrustedArtifactOnDeployment("Warn")
                .build())
            .description("Development code signing configuration with warnings")
            .tags(Map.ofEntries(
                Map.entry("Environment", "development"),
                Map.entry("Security", "flexible")
            ))
            .build());

    }
}

resources:
  # Production signing configuration
  prod:
    type: aws:lambda:CodeSigningConfig
    properties:
      allowedPublishers:
        signingProfileVersionArns:
          - ${prodAwsSignerSigningProfile.versionArn}
      policies:
        untrustedArtifactOnDeployment: Enforce
      description: Production code signing configuration with strict enforcement
      tags:
        Environment: production
        Security: strict
  # Development signing configuration
  dev:
    type: aws:lambda:CodeSigningConfig
    properties:
      allowedPublishers:
        signingProfileVersionArns:
          - ${devAwsSignerSigningProfile.versionArn}
          - ${test.versionArn}
      policies:
        untrustedArtifactOnDeployment: Warn
      description: Development code signing configuration with warnings
      tags:
        Environment: development
        Security: flexible

Import

For backwards compatibility, the following legacy pulumi import command is also supported:

$ pulumi import aws:lambda/codeSigningConfig:CodeSigningConfig example arn:aws:lambda:us-west-2:123456789012:code-signing-config:csc-0f6c334abcdea4d8b

Constructors

CodeSigningConfig(String name, {CodeSigningConfigArgs? args, CustomResourceOptions? options}): Creates a new CodeSigningConfig. name The Pulumi resource name. args Arguments used to configure this CodeSigningConfig. The set of arguments for CodeSigningConfig. options Resource options controlling this resource's behavior.
CodeSigningConfig.reference(String urn): Creates a typed reference to an existing CodeSigningConfig resource.

Properties

allowedPublishers ↔ Output<CodeSigningConfigAllowedPublishers>: Configuration block of allowed publishers as signing profiles for this code signing configuration. See below.
latefinal
arn ↔ Output<String>: ARN of the code signing configuration.
latefinal
childResources → Set<Resource>: finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>: latefinalinherited
configId ↔ Output<String>: Unique identifier for the code signing configuration.
latefinal
description ↔ Output<String?>: Descriptive name for this code signing configuration.
latefinal
hashCode → int: The hash code for this object.
no setterinherited
id ↔ Output<String>: getter/setter pairinherited
isCustom → bool: Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool: Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool: Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool: Whether this instance represents a resource value returned over RPC.
finalinherited
lastModified ↔ Output<String>: Date and time that the code signing configuration was last modified.
latefinal
policies ↔ Output<CodeSigningConfigPolicies>: Configuration block of code signing policies that define the actions to take if the validation checks fail. See below.
latefinal
region ↔ Output<String>: Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>: Inherited/explicit async transforms.
no setterinherited
runtimeType → Type: A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>: Map of tags to assign to the object. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>: Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>: Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>: latefinalinherited

Methods

failId(Object error) → void: Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void: Completes all output properties with error.
inherited
failUrn(Object error) → void: Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?: Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String: Returns this resource's logical name.
inherited
getResourceType() → String: Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic: Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>: Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void: Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void: Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void: Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>: Serializes resource properties for RPC transmission.
inherited
toString() → String: A string representation of this object.
inherited

Operators

operator ==(Object other) → bool: The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {CodeSigningConfigState? state, CustomResourceOptions? options}) → CodeSigningConfig: Gets an existing CodeSigningConfig resource's state with the given name and id.