SigningProfile class

Creates a Signer Signing Profile. A signing profile contains information about the code signing configuration parameters that can be used by a given code signing user.

Example Usage

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

const testSp = new aws.signer.SigningProfile("test_sp", {platformId: "AWSLambda-SHA384-ECDSA"});
const prodSp = new aws.signer.SigningProfile("prod_sp", {
    signatureValidityPeriod: {
        value: 5,
        type: "YEARS",
    },
    platformId: "AWSLambda-SHA384-ECDSA",
    namePrefix: "prod_sp_",
    tags: {
        tag1: "value1",
        tag2: "value2",
    },
});
import pulumi
import pulumi_aws as aws

test_sp = aws.signer.SigningProfile("test_sp", platform_id="AWSLambda-SHA384-ECDSA")
prod_sp = aws.signer.SigningProfile("prod_sp",
    signature_validity_period={
        "value": 5,
        "type": "YEARS",
    },
    platform_id="AWSLambda-SHA384-ECDSA",
    name_prefix="prod_sp_",
    tags={
        "tag1": "value1",
        "tag2": "value2",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var testSp = new Aws.Signer.SigningProfile("test_sp", new()
    {
        PlatformId = "AWSLambda-SHA384-ECDSA",
    });

    var prodSp = new Aws.Signer.SigningProfile("prod_sp", new()
    {
        SignatureValidityPeriod = new Aws.Signer.Inputs.SigningProfileSignatureValidityPeriodArgs
        {
            Value = 5,
            Type = "YEARS",
        },
        PlatformId = "AWSLambda-SHA384-ECDSA",
        NamePrefix = "prod_sp_",
        Tags =
        {
            { "tag1", "value1" },
            { "tag2", "value2" },
        },
    });

});
package main

import (
	"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 {
		_, err := signer.NewSigningProfile(ctx, "test_sp", &signer.SigningProfileArgs{
			PlatformId: pulumi.String("AWSLambda-SHA384-ECDSA"),
		})
		if err != nil {
			return err
		}
		_, err = signer.NewSigningProfile(ctx, "prod_sp", &signer.SigningProfileArgs{
			SignatureValidityPeriod: &signer.SigningProfileSignatureValidityPeriodArgs{
				Value: pulumi.Int(5),
				Type:  pulumi.String("YEARS"),
			},
			PlatformId: pulumi.String("AWSLambda-SHA384-ECDSA"),
			NamePrefix: pulumi.String("prod_sp_"),
			Tags: pulumi.StringMap{
				"tag1": pulumi.String("value1"),
				"tag2": pulumi.String("value2"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_signer_signingprofile" "test_sp" {
  platform_id = "AWSLambda-SHA384-ECDSA"
}
resource "aws_signer_signingprofile" "prod_sp" {
  signature_validity_period = {
    value = 5
    type  = "YEARS"
  }
  platform_id = "AWSLambda-SHA384-ECDSA"
  name_prefix = "prod_sp_"
  tags = {
    "tag1" = "value1"
    "tag2" = "value2"
  }
}
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.signer.inputs.SigningProfileSignatureValidityPeriodArgs;
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 testSp = new SigningProfile("testSp", SigningProfileArgs.builder()
            .platformId("AWSLambda-SHA384-ECDSA")
            .build());

        var prodSp = new SigningProfile("prodSp", SigningProfileArgs.builder()
            .signatureValidityPeriod(SigningProfileSignatureValidityPeriodArgs.builder()
                .value(5)
                .type("YEARS")
                .build())
            .platformId("AWSLambda-SHA384-ECDSA")
            .namePrefix("prod_sp_")
            .tags(Map.ofEntries(
                Map.entry("tag1", "value1"),
                Map.entry("tag2", "value2")
            ))
            .build());

    }
}
resources:
  testSp:
    type: aws:signer:SigningProfile
    name: test_sp
    properties:
      platformId: AWSLambda-SHA384-ECDSA
  prodSp:
    type: aws:signer:SigningProfile
    name: prod_sp
    properties:
      signatureValidityPeriod:
        value: 5
        type: YEARS
      platformId: AWSLambda-SHA384-ECDSA
      namePrefix: prod_sp_
      tags:
        tag1: value1
        tag2: value2

Import

Using pulumi import, import Signer signing profiles using the name. For example:

$ pulumi import aws:signer/signingProfile:SigningProfile test_signer_signing_profile test_sp_DdW3Mk1foYL88fajut4mTVFGpuwfd4ACO6ANL0D1uIj7lrn8adK

Constructors

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

Properties

arn ↔ Output<String>
ARN for the signing profile.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
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
name ↔ Output<String>
A unique signing profile name. By default generated by Terraform. Signing profile names are immutable and cannot be reused after canceled.
latefinal
namePrefix ↔ Output<String>
A signing profile name prefix. Terraform will generate a unique suffix. Conflicts with name.
latefinal
platformDisplayName ↔ Output<String>
A human-readable name for the signing platform associated with the signing profile.
latefinal
platformId ↔ Output<String>
The ID of the platform that is used by the target signing profile.
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
revocationRecords ↔ Output<List<SigningProfileRevocationRecord>>
Revocation information for a signing profile. See revocationRecord Block below for details.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
signatureValidityPeriod ↔ Output<SigningProfileSignatureValidityPeriod>
The validity period for a signing job. See signatureValidityPeriod Block below for details.
latefinal
signingMaterial ↔ Output<SigningProfileSigningMaterial>
The AWS Certificate Manager certificate that will be used to sign code with the new signing profile. See signingMaterial Block below for details.
latefinal
signingParameters ↔ Output<Map<String, String>?>
Map of key-value pairs for signing. These can include any information that you want to use during signing.
latefinal
status ↔ Output<String>
The status of the target signing profile.
latefinal
tags ↔ Output<Map<String, String>?>
A list of tags associated with the signing profile. 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>>
A 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
version ↔ Output<String>
The current version of the signing profile.
latefinal
versionArn ↔ Output<String>
The signing profile ARN, including the profile version.
latefinal

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, {SigningProfileState? state, CustomResourceOptions? options}) → SigningProfile
Gets an existing SigningProfile resource's state with the given name and id.