codeartifact

package
v3.21.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 16, 2020 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Domain 

type Domain struct {
	pulumi.CustomResourceState

	// The ARN of Domain.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The total size of all assets in the domain.
	AssetSizeBytes pulumi.IntOutput `pulumi:"assetSizeBytes"`
	// A timestamp that represents the date and time the domain was created in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8).
	CreatedTime pulumi.StringOutput `pulumi:"createdTime"`
	// The name of the domain to create. All domain names in an AWS Region that are in the same AWS account must be unique. The domain name is used as the prefix in DNS hostnames. Do not use sensitive information in a domain name because it is publicly discoverable.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The encryption key for the domain. This is used to encrypt content stored in a domain. The KMS Key Amazon Resource Name (ARN).
	EncryptionKey pulumi.StringOutput `pulumi:"encryptionKey"`
	// The AWS account ID that owns the domain.
	Owner pulumi.StringOutput `pulumi:"owner"`
	// The number of repositories in the domain.
	RepositoryCount pulumi.IntOutput `pulumi:"repositoryCount"`
	// Key-value map of resource tags.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides a CodeArtifact Domain Resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKey, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			Description: pulumi.String("domain key"),
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewDomain(ctx, "exampleDomain", &codeartifact.DomainArgs{
			Domain:        pulumi.String("example"),
			EncryptionKey: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

CodeArtifact Domain can be imported using the CodeArtifact Domain arn, e.g.

```sh 

$ pulumi import aws:codeartifact/domain:Domain example arn:aws:codeartifact:us-west-2:012345678912:domain/tf-acc-test-8593714120730241305

```

func GetDomain 

func GetDomain(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainState, opts ...pulumi.ResourceOption) (*Domain, error)

GetDomain gets an existing Domain resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDomain 

func NewDomain(ctx *pulumi.Context,
	name string, args *DomainArgs, opts ...pulumi.ResourceOption) (*Domain, error)

NewDomain registers a new resource with the given unique name, arguments, and options.

func (Domain) ElementType added in v3.13.0 

func (Domain) ElementType() reflect.Type

func (Domain) ToDomainOutput added in v3.13.0 

func (i Domain) ToDomainOutput() DomainOutput

func (Domain) ToDomainOutputWithContext added in v3.13.0 

func (i Domain) ToDomainOutputWithContext(ctx context.Context) DomainOutput

type DomainArgs 

type DomainArgs struct {
	// The name of the domain to create. All domain names in an AWS Region that are in the same AWS account must be unique. The domain name is used as the prefix in DNS hostnames. Do not use sensitive information in a domain name because it is publicly discoverable.
	Domain pulumi.StringInput
	// The encryption key for the domain. This is used to encrypt content stored in a domain. The KMS Key Amazon Resource Name (ARN).
	EncryptionKey pulumi.StringInput
	// Key-value map of resource tags.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Domain resource.

func (DomainArgs) ElementType 

func (DomainArgs) ElementType() reflect.Type

type DomainInput added in v3.13.0 

type DomainInput interface {
	pulumi.Input

	ToDomainOutput() DomainOutput
	ToDomainOutputWithContext(ctx context.Context) DomainOutput
}

type DomainOutput added in v3.13.0 

type DomainOutput struct {
	*pulumi.OutputState
}

func (DomainOutput) ElementType added in v3.13.0 

func (DomainOutput) ElementType() reflect.Type

func (DomainOutput) ToDomainOutput added in v3.13.0 

func (o DomainOutput) ToDomainOutput() DomainOutput

func (DomainOutput) ToDomainOutputWithContext added in v3.13.0 

func (o DomainOutput) ToDomainOutputWithContext(ctx context.Context) DomainOutput

type DomainPermissions 

type DomainPermissions struct {
	pulumi.CustomResourceState

	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringOutput `pulumi:"domainOwner"`
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringOutput `pulumi:"policyDocument"`
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringOutput `pulumi:"policyRevision"`
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
}

Provides a CodeArtifact Domains Permissions Policy Resource.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKey, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			Description: pulumi.String("domain key"),
		})
		if err != nil {
			return err
		}
		exampleDomain, err := codeartifact.NewDomain(ctx, "exampleDomain", &codeartifact.DomainArgs{
			Domain:        pulumi.String("example.com"),
			EncryptionKey: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewDomainPermissions(ctx, "test", &codeartifact.DomainPermissionsArgs{
			Domain: exampleDomain.Domain,
			PolicyDocument: exampleDomain.Arn.ApplyT(func(arn string) (string, error) {
				return fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2012-10-17\",\n", "    \"Statement\": [\n", "        {\n", "            \"Action\": \"codeartifact:CreateRepository\",\n", "            \"Effect\": \"Allow\",\n", "            \"Principal\": \"*\",\n", "            \"Resource\": \"", arn, "\"\n", "        }\n", "    ]\n", "}\n"), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

CodeArtifact Domain Permissions Policies can be imported using the CodeArtifact Domain ARN, e.g.

```sh 

$ pulumi import aws:codeartifact/domainPermissions:DomainPermissions example arn:aws:codeartifact:us-west-2:012345678912:domain/tf-acc-test-1928056699409417367

```

func GetDomainPermissions 

func GetDomainPermissions(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainPermissionsState, opts ...pulumi.ResourceOption) (*DomainPermissions, error)

GetDomainPermissions gets an existing DomainPermissions resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDomainPermissions 

func NewDomainPermissions(ctx *pulumi.Context,
	name string, args *DomainPermissionsArgs, opts ...pulumi.ResourceOption) (*DomainPermissions, error)

NewDomainPermissions registers a new resource with the given unique name, arguments, and options.

func (DomainPermissions) ElementType added in v3.13.0 

func (DomainPermissions) ElementType() reflect.Type

func (DomainPermissions) ToDomainPermissionsOutput added in v3.13.0 

func (i DomainPermissions) ToDomainPermissionsOutput() DomainPermissionsOutput

func (DomainPermissions) ToDomainPermissionsOutputWithContext added in v3.13.0 

func (i DomainPermissions) ToDomainPermissionsOutputWithContext(ctx context.Context) DomainPermissionsOutput

type DomainPermissionsArgs 

type DomainPermissionsArgs struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
}

The set of arguments for constructing a DomainPermissions resource.

func (DomainPermissionsArgs) ElementType 

func (DomainPermissionsArgs) ElementType() reflect.Type

type DomainPermissionsInput added in v3.13.0 

type DomainPermissionsInput interface {
	pulumi.Input

	ToDomainPermissionsOutput() DomainPermissionsOutput
	ToDomainPermissionsOutputWithContext(ctx context.Context) DomainPermissionsOutput
}

type DomainPermissionsOutput added in v3.13.0 

type DomainPermissionsOutput struct {
	*pulumi.OutputState
}

func (DomainPermissionsOutput) ElementType added in v3.13.0 

func (DomainPermissionsOutput) ElementType() reflect.Type

func (DomainPermissionsOutput) ToDomainPermissionsOutput added in v3.13.0 

func (o DomainPermissionsOutput) ToDomainPermissionsOutput() DomainPermissionsOutput

func (DomainPermissionsOutput) ToDomainPermissionsOutputWithContext added in v3.13.0 

func (o DomainPermissionsOutput) ToDomainPermissionsOutputWithContext(ctx context.Context) DomainPermissionsOutput

type DomainPermissionsPolicy 

type DomainPermissionsPolicy struct {
	pulumi.CustomResourceState

	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringOutput `pulumi:"domainOwner"`
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringOutput `pulumi:"policyDocument"`
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringOutput `pulumi:"policyRevision"`
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
}

Provides a CodeArtifact Domains Permissions Policy Resource.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKey, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			Description: pulumi.String("domain key"),
		})
		if err != nil {
			return err
		}
		exampleDomain, err := codeartifact.NewDomain(ctx, "exampleDomain", &codeartifact.DomainArgs{
			Domain:        pulumi.String("example.com"),
			EncryptionKey: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewDomainPermissionsPolicy(ctx, "test", &codeartifact.DomainPermissionsPolicyArgs{
			Domain: exampleDomain.Domain,
			PolicyDocument: exampleDomain.Arn.ApplyT(func(arn string) (string, error) {
				return fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "    \"Version\": \"2012-10-17\",\n", "    \"Statement\": [\n", "        {\n", "            \"Action\": \"codeartifact:CreateRepository\",\n", "            \"Effect\": \"Allow\",\n", "            \"Principal\": \"*\",\n", "            \"Resource\": \"", arn, "\"\n", "        }\n", "    ]\n", "}\n"), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetDomainPermissionsPolicy 

func GetDomainPermissionsPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DomainPermissionsPolicyState, opts ...pulumi.ResourceOption) (*DomainPermissionsPolicy, error)

GetDomainPermissionsPolicy gets an existing DomainPermissionsPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDomainPermissionsPolicy 

func NewDomainPermissionsPolicy(ctx *pulumi.Context,
	name string, args *DomainPermissionsPolicyArgs, opts ...pulumi.ResourceOption) (*DomainPermissionsPolicy, error)

NewDomainPermissionsPolicy registers a new resource with the given unique name, arguments, and options.

type DomainPermissionsPolicyArgs 

type DomainPermissionsPolicyArgs struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
}

The set of arguments for constructing a DomainPermissionsPolicy resource.

func (DomainPermissionsPolicyArgs) ElementType 

func (DomainPermissionsPolicyArgs) ElementType() reflect.Type

type DomainPermissionsPolicyState 

type DomainPermissionsPolicyState struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringPtrInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringPtrInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringPtrInput
}

func (DomainPermissionsPolicyState) ElementType 

func (DomainPermissionsPolicyState) ElementType() reflect.Type

type DomainPermissionsState 

type DomainPermissionsState struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringPtrInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringPtrInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringPtrInput
}

func (DomainPermissionsState) ElementType 

func (DomainPermissionsState) ElementType() reflect.Type

type DomainState 

type DomainState struct {
	// The ARN of Domain.
	Arn pulumi.StringPtrInput
	// The total size of all assets in the domain.
	AssetSizeBytes pulumi.IntPtrInput
	// A timestamp that represents the date and time the domain was created in [RFC3339 format](https://tools.ietf.org/html/rfc3339#section-5.8).
	CreatedTime pulumi.StringPtrInput
	// The name of the domain to create. All domain names in an AWS Region that are in the same AWS account must be unique. The domain name is used as the prefix in DNS hostnames. Do not use sensitive information in a domain name because it is publicly discoverable.
	Domain pulumi.StringPtrInput
	// The encryption key for the domain. This is used to encrypt content stored in a domain. The KMS Key Amazon Resource Name (ARN).
	EncryptionKey pulumi.StringPtrInput
	// The AWS account ID that owns the domain.
	Owner pulumi.StringPtrInput
	// The number of repositories in the domain.
	RepositoryCount pulumi.IntPtrInput
	// Key-value map of resource tags.
	Tags pulumi.StringMapInput
}

func (DomainState) ElementType 

func (DomainState) ElementType() reflect.Type

type GetAuthorizationTokenArgs added in v3.7.0 

type GetAuthorizationTokenArgs struct {
	// The name of the domain that is in scope for the generated authorization token.
	Domain string `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner *string `pulumi:"domainOwner"`
	// The time, in seconds, that the generated authorization token is valid. Valid values are `0` and between `900` and `43200`.
	DurationSeconds *int `pulumi:"durationSeconds"`
}

A collection of arguments for invoking getAuthorizationToken.

type GetAuthorizationTokenResult added in v3.7.0 

type GetAuthorizationTokenResult struct {
	// Temporary authorization token.
	AuthorizationToken string `pulumi:"authorizationToken"`
	Domain             string `pulumi:"domain"`
	DomainOwner        string `pulumi:"domainOwner"`
	DurationSeconds    *int   `pulumi:"durationSeconds"`
	// The time in UTC RFC3339 format when the authorization token expires.
	Expiration string `pulumi:"expiration"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
}

A collection of values returned by getAuthorizationToken.

func GetAuthorizationToken added in v3.7.0 

func GetAuthorizationToken(ctx *pulumi.Context, args *GetAuthorizationTokenArgs, opts ...pulumi.InvokeOption) (*GetAuthorizationTokenResult, error)

The CodeArtifact Authorization Token data source generates a temporary authentication token for accessing repositories in a CodeArtifact domain.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codeartifact.GetAuthorizationToken(ctx, &codeartifact.GetAuthorizationTokenArgs{
			Domain: aws_codeartifact_domain.Test.Domain,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetRepositoryEndpointArgs added in v3.8.0 

type GetRepositoryEndpointArgs struct {
	// The name of the domain that contains the repository.
	Domain string `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner *string `pulumi:"domainOwner"`
	// Which endpoint of a repository to return. A repository has one endpoint for each package format: `npm`, `pypi`, `maven`, and `nuget`.
	Format string `pulumi:"format"`
	// The name of the repository.
	Repository string `pulumi:"repository"`
}

A collection of arguments for invoking getRepositoryEndpoint.

type GetRepositoryEndpointResult added in v3.8.0 

type GetRepositoryEndpointResult struct {
	Domain      string `pulumi:"domain"`
	DomainOwner string `pulumi:"domainOwner"`
	Format      string `pulumi:"format"`
	// The provider-assigned unique ID for this managed resource.
	Id         string `pulumi:"id"`
	Repository string `pulumi:"repository"`
	// The URL of the returned endpoint.
	RepositoryEndpoint string `pulumi:"repositoryEndpoint"`
}

A collection of values returned by getRepositoryEndpoint.

func GetRepositoryEndpoint added in v3.8.0 

func GetRepositoryEndpoint(ctx *pulumi.Context, args *GetRepositoryEndpointArgs, opts ...pulumi.InvokeOption) (*GetRepositoryEndpointResult, error)

The CodeArtifact Repository Endpoint data source returns the endpoint of a repository for a specific package format.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codeartifact.GetRepositoryEndpoint(ctx, &codeartifact.GetRepositoryEndpointArgs{
			Domain:     aws_codeartifact_domain.Test.Domain,
			Repository: aws_codeartifact_repository.Test.Repository,
			Format:     "npm",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type Repository 

type Repository struct {
	pulumi.CustomResourceState

	// The account number of the AWS account that manages the repository.
	AdministratorAccount pulumi.StringOutput `pulumi:"administratorAccount"`
	// The ARN of the repository.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The description of the repository.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The domain that contains the created repository.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringOutput `pulumi:"domainOwner"`
	// An array of external connections associated with the repository. Only one external connection can be set per repository. see External Connections.
	ExternalConnections RepositoryExternalConnectionsPtrOutput `pulumi:"externalConnections"`
	// The name of the repository to create.
	Repository pulumi.StringOutput `pulumi:"repository"`
	// Key-value map of resource tags.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A list of upstream repositories to associate with the repository. The order of the upstream repositories in the list determines their priority order when AWS CodeArtifact looks for a requested package version. see Upstream
	Upstreams RepositoryUpstreamArrayOutput `pulumi:"upstreams"`
}

Provides a CodeArtifact Repository Resource.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/kms"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKey, err := kms.NewKey(ctx, "exampleKey", &kms.KeyArgs{
			Description: pulumi.String("domain key"),
		})
		if err != nil {
			return err
		}
		exampleDomain, err := codeartifact.NewDomain(ctx, "exampleDomain", &codeartifact.DomainArgs{
			Domain:        pulumi.String("example"),
			EncryptionKey: exampleKey.Arn,
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewRepository(ctx, "test", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("example"),
			Domain:     exampleDomain.Domain,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### With Upstream Repository

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		upstream, err := codeartifact.NewRepository(ctx, "upstream", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("upstream"),
			Domain:     pulumi.Any(aws_codeartifact_domain.Test.Domain),
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewRepository(ctx, "test", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("example"),
			Domain:     pulumi.Any(aws_codeartifact_domain.Example.Domain),
			Upstreams: codeartifact.RepositoryUpstreamArray{
				&codeartifact.RepositoryUpstreamArgs{
					RepositoryName: upstream.Repository,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### With External Connection

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/codeartifact"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codeartifact.NewRepository(ctx, "upstream", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("upstream"),
			Domain:     pulumi.Any(aws_codeartifact_domain.Test.Domain),
		})
		if err != nil {
			return err
		}
		_, err = codeartifact.NewRepository(ctx, "test", &codeartifact.RepositoryArgs{
			Repository: pulumi.String("example"),
			Domain:     pulumi.Any(aws_codeartifact_domain.Example.Domain),
			ExternalConnections: &codeartifact.RepositoryExternalConnectionsArgs{
				ExternalConnectionName: pulumi.String("public:npmjs"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

CodeArtifact Repository can be imported using the CodeArtifact Repository ARN, e.g.

```sh 

$ pulumi import aws:codeartifact/repository:Repository example arn:aws:codeartifact:us-west-2:012345678912:repository/tf-acc-test-6968272603913957763/tf-acc-test-6968272603913957763

```

func GetRepository 

func GetRepository(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryState, opts ...pulumi.ResourceOption) (*Repository, error)

GetRepository gets an existing Repository resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRepository 

func NewRepository(ctx *pulumi.Context,
	name string, args *RepositoryArgs, opts ...pulumi.ResourceOption) (*Repository, error)

NewRepository registers a new resource with the given unique name, arguments, and options.

func (Repository) ElementType added in v3.13.0 

func (Repository) ElementType() reflect.Type

func (Repository) ToRepositoryOutput added in v3.13.0 

func (i Repository) ToRepositoryOutput() RepositoryOutput

func (Repository) ToRepositoryOutputWithContext added in v3.13.0 

func (i Repository) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput

type RepositoryArgs 

type RepositoryArgs struct {
	// The description of the repository.
	Description pulumi.StringPtrInput
	// The domain that contains the created repository.
	Domain pulumi.StringInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// An array of external connections associated with the repository. Only one external connection can be set per repository. see External Connections.
	ExternalConnections RepositoryExternalConnectionsPtrInput
	// The name of the repository to create.
	Repository pulumi.StringInput
	// Key-value map of resource tags.
	Tags pulumi.StringMapInput
	// A list of upstream repositories to associate with the repository. The order of the upstream repositories in the list determines their priority order when AWS CodeArtifact looks for a requested package version. see Upstream
	Upstreams RepositoryUpstreamArrayInput
}

The set of arguments for constructing a Repository resource.

func (RepositoryArgs) ElementType 

func (RepositoryArgs) ElementType() reflect.Type

type RepositoryExternalConnections added in v3.10.0 

type RepositoryExternalConnections struct {
	// The name of the external connection associated with a repository.
	ExternalConnectionName string  `pulumi:"externalConnectionName"`
	PackageFormat          *string `pulumi:"packageFormat"`
	Status                 *string `pulumi:"status"`
}

type RepositoryExternalConnectionsArgs added in v3.10.0 

type RepositoryExternalConnectionsArgs struct {
	// The name of the external connection associated with a repository.
	ExternalConnectionName pulumi.StringInput    `pulumi:"externalConnectionName"`
	PackageFormat          pulumi.StringPtrInput `pulumi:"packageFormat"`
	Status                 pulumi.StringPtrInput `pulumi:"status"`
}

func (RepositoryExternalConnectionsArgs) ElementType added in v3.10.0 

func (RepositoryExternalConnectionsArgs) ElementType() reflect.Type

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutput added in v3.10.0 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutput() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutputWithContext added in v3.10.0 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsOutputWithContext(ctx context.Context) RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutput added in v3.10.0 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutputWithContext added in v3.10.0 

func (i RepositoryExternalConnectionsArgs) ToRepositoryExternalConnectionsPtrOutputWithContext(ctx context.Context) RepositoryExternalConnectionsPtrOutput

type RepositoryExternalConnectionsInput added in v3.10.0 

type RepositoryExternalConnectionsInput interface {
	pulumi.Input

	ToRepositoryExternalConnectionsOutput() RepositoryExternalConnectionsOutput
	ToRepositoryExternalConnectionsOutputWithContext(context.Context) RepositoryExternalConnectionsOutput
}

RepositoryExternalConnectionsInput is an input type that accepts RepositoryExternalConnectionsArgs and RepositoryExternalConnectionsOutput values. You can construct a concrete instance of `RepositoryExternalConnectionsInput` via: 

RepositoryExternalConnectionsArgs{...}

type RepositoryExternalConnectionsOutput added in v3.10.0 

type RepositoryExternalConnectionsOutput struct{ *pulumi.OutputState }

func (RepositoryExternalConnectionsOutput) ElementType added in v3.10.0 

func (RepositoryExternalConnectionsOutput) ElementType() reflect.Type

func (RepositoryExternalConnectionsOutput) ExternalConnectionName added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ExternalConnectionName() pulumi.StringOutput

The name of the external connection associated with a repository.

func (RepositoryExternalConnectionsOutput) PackageFormat added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) PackageFormat() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsOutput) Status added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) Status() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutput added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutput() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutputWithContext added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsOutputWithContext(ctx context.Context) RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutput added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutputWithContext added in v3.10.0 

func (o RepositoryExternalConnectionsOutput) ToRepositoryExternalConnectionsPtrOutputWithContext(ctx context.Context) RepositoryExternalConnectionsPtrOutput

type RepositoryExternalConnectionsPtrInput added in v3.10.0 

type RepositoryExternalConnectionsPtrInput interface {
	pulumi.Input

	ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput
	ToRepositoryExternalConnectionsPtrOutputWithContext(context.Context) RepositoryExternalConnectionsPtrOutput
}

RepositoryExternalConnectionsPtrInput is an input type that accepts RepositoryExternalConnectionsArgs, RepositoryExternalConnectionsPtr and RepositoryExternalConnectionsPtrOutput values. You can construct a concrete instance of `RepositoryExternalConnectionsPtrInput` via: 

        RepositoryExternalConnectionsArgs{...}

or:

        nil

func RepositoryExternalConnectionsPtr added in v3.10.0 

func RepositoryExternalConnectionsPtr(v *RepositoryExternalConnectionsArgs) RepositoryExternalConnectionsPtrInput

type RepositoryExternalConnectionsPtrOutput added in v3.10.0 

type RepositoryExternalConnectionsPtrOutput struct{ *pulumi.OutputState }

func (RepositoryExternalConnectionsPtrOutput) Elem added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) Elem() RepositoryExternalConnectionsOutput

func (RepositoryExternalConnectionsPtrOutput) ElementType added in v3.10.0 

func (RepositoryExternalConnectionsPtrOutput) ElementType() reflect.Type

func (RepositoryExternalConnectionsPtrOutput) ExternalConnectionName added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) ExternalConnectionName() pulumi.StringPtrOutput

The name of the external connection associated with a repository.

func (RepositoryExternalConnectionsPtrOutput) PackageFormat added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) PackageFormat() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsPtrOutput) Status added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) Status() pulumi.StringPtrOutput

func (RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutput added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutput() RepositoryExternalConnectionsPtrOutput

func (RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutputWithContext added in v3.10.0 

func (o RepositoryExternalConnectionsPtrOutput) ToRepositoryExternalConnectionsPtrOutputWithContext(ctx context.Context) RepositoryExternalConnectionsPtrOutput

type RepositoryInput added in v3.13.0 

type RepositoryInput interface {
	pulumi.Input

	ToRepositoryOutput() RepositoryOutput
	ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput
}

type RepositoryOutput added in v3.13.0 

type RepositoryOutput struct {
	*pulumi.OutputState
}

func (RepositoryOutput) ElementType added in v3.13.0 

func (RepositoryOutput) ElementType() reflect.Type

func (RepositoryOutput) ToRepositoryOutput added in v3.13.0 

func (o RepositoryOutput) ToRepositoryOutput() RepositoryOutput

func (RepositoryOutput) ToRepositoryOutputWithContext added in v3.13.0 

func (o RepositoryOutput) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput

type RepositoryPermissionsPolicy added in v3.7.0 

type RepositoryPermissionsPolicy struct {
	pulumi.CustomResourceState

	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringOutput `pulumi:"domain"`
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringOutput `pulumi:"domainOwner"`
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringOutput `pulumi:"policyDocument"`
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringOutput `pulumi:"policyRevision"`
	// The name of the repository to set the resource policy on.
	Repository pulumi.StringOutput `pulumi:"repository"`
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringOutput `pulumi:"resourceArn"`
}

Provides a CodeArtifact Repostory Permissions Policy Resource.

## Import

CodeArtifact Repository Permissions Policies can be imported using the CodeArtifact Repository ARN, e.g.

```sh 

$ pulumi import aws:codeartifact/repositoryPermissionsPolicy:RepositoryPermissionsPolicy example arn:aws:codeartifact:us-west-2:012345678912:repository/tf-acc-test-6968272603913957763/tf-acc-test-6968272603913957763

```

func GetRepositoryPermissionsPolicy added in v3.7.0 

func GetRepositoryPermissionsPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryPermissionsPolicyState, opts ...pulumi.ResourceOption) (*RepositoryPermissionsPolicy, error)

GetRepositoryPermissionsPolicy gets an existing RepositoryPermissionsPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewRepositoryPermissionsPolicy added in v3.7.0 

func NewRepositoryPermissionsPolicy(ctx *pulumi.Context,
	name string, args *RepositoryPermissionsPolicyArgs, opts ...pulumi.ResourceOption) (*RepositoryPermissionsPolicy, error)

NewRepositoryPermissionsPolicy registers a new resource with the given unique name, arguments, and options.

func (RepositoryPermissionsPolicy) ElementType added in v3.13.0 

func (RepositoryPermissionsPolicy) ElementType() reflect.Type

func (RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutput added in v3.13.0 

func (i RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutput() RepositoryPermissionsPolicyOutput

func (RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutputWithContext added in v3.13.0 

func (i RepositoryPermissionsPolicy) ToRepositoryPermissionsPolicyOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyOutput

type RepositoryPermissionsPolicyArgs added in v3.7.0 

type RepositoryPermissionsPolicyArgs struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
	// The name of the repository to set the resource policy on.
	Repository pulumi.StringInput
}

The set of arguments for constructing a RepositoryPermissionsPolicy resource.

func (RepositoryPermissionsPolicyArgs) ElementType added in v3.7.0 

func (RepositoryPermissionsPolicyArgs) ElementType() reflect.Type

type RepositoryPermissionsPolicyInput added in v3.13.0 

type RepositoryPermissionsPolicyInput interface {
	pulumi.Input

	ToRepositoryPermissionsPolicyOutput() RepositoryPermissionsPolicyOutput
	ToRepositoryPermissionsPolicyOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyOutput
}

type RepositoryPermissionsPolicyOutput added in v3.13.0 

type RepositoryPermissionsPolicyOutput struct {
	*pulumi.OutputState
}

func (RepositoryPermissionsPolicyOutput) ElementType added in v3.13.0 

func (RepositoryPermissionsPolicyOutput) ElementType() reflect.Type

func (RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutput added in v3.13.0 

func (o RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutput() RepositoryPermissionsPolicyOutput

func (RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutputWithContext added in v3.13.0 

func (o RepositoryPermissionsPolicyOutput) ToRepositoryPermissionsPolicyOutputWithContext(ctx context.Context) RepositoryPermissionsPolicyOutput

type RepositoryPermissionsPolicyState added in v3.7.0 

type RepositoryPermissionsPolicyState struct {
	// The name of the domain on which to set the resource policy.
	Domain pulumi.StringPtrInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// A JSON policy string to be set as the access control resource policy on the provided domain.
	PolicyDocument pulumi.StringPtrInput
	// The current revision of the resource policy to be set. This revision is used for optimistic locking, which prevents others from overwriting your changes to the domain's resource policy.
	PolicyRevision pulumi.StringPtrInput
	// The name of the repository to set the resource policy on.
	Repository pulumi.StringPtrInput
	// The ARN of the resource associated with the resource policy.
	ResourceArn pulumi.StringPtrInput
}

func (RepositoryPermissionsPolicyState) ElementType added in v3.7.0 

func (RepositoryPermissionsPolicyState) ElementType() reflect.Type

type RepositoryState 

type RepositoryState struct {
	// The account number of the AWS account that manages the repository.
	AdministratorAccount pulumi.StringPtrInput
	// The ARN of the repository.
	Arn pulumi.StringPtrInput
	// The description of the repository.
	Description pulumi.StringPtrInput
	// The domain that contains the created repository.
	Domain pulumi.StringPtrInput
	// The account number of the AWS account that owns the domain.
	DomainOwner pulumi.StringPtrInput
	// An array of external connections associated with the repository. Only one external connection can be set per repository. see External Connections.
	ExternalConnections RepositoryExternalConnectionsPtrInput
	// The name of the repository to create.
	Repository pulumi.StringPtrInput
	// Key-value map of resource tags.
	Tags pulumi.StringMapInput
	// A list of upstream repositories to associate with the repository. The order of the upstream repositories in the list determines their priority order when AWS CodeArtifact looks for a requested package version. see Upstream
	Upstreams RepositoryUpstreamArrayInput
}

func (RepositoryState) ElementType 

func (RepositoryState) ElementType() reflect.Type

type RepositoryUpstream 

type RepositoryUpstream struct {
	// The name of an upstream repository.
	RepositoryName string `pulumi:"repositoryName"`
}

type RepositoryUpstreamArgs 

type RepositoryUpstreamArgs struct {
	// The name of an upstream repository.
	RepositoryName pulumi.StringInput `pulumi:"repositoryName"`
}

func (RepositoryUpstreamArgs) ElementType 

func (RepositoryUpstreamArgs) ElementType() reflect.Type

func (RepositoryUpstreamArgs) ToRepositoryUpstreamOutput 

func (i RepositoryUpstreamArgs) ToRepositoryUpstreamOutput() RepositoryUpstreamOutput

func (RepositoryUpstreamArgs) ToRepositoryUpstreamOutputWithContext 

func (i RepositoryUpstreamArgs) ToRepositoryUpstreamOutputWithContext(ctx context.Context) RepositoryUpstreamOutput

type RepositoryUpstreamArray 

type RepositoryUpstreamArray []RepositoryUpstreamInput

func (RepositoryUpstreamArray) ElementType 

func (RepositoryUpstreamArray) ElementType() reflect.Type

func (RepositoryUpstreamArray) ToRepositoryUpstreamArrayOutput 

func (i RepositoryUpstreamArray) ToRepositoryUpstreamArrayOutput() RepositoryUpstreamArrayOutput

func (RepositoryUpstreamArray) ToRepositoryUpstreamArrayOutputWithContext 

func (i RepositoryUpstreamArray) ToRepositoryUpstreamArrayOutputWithContext(ctx context.Context) RepositoryUpstreamArrayOutput

type RepositoryUpstreamArrayInput 

type RepositoryUpstreamArrayInput interface {
	pulumi.Input

	ToRepositoryUpstreamArrayOutput() RepositoryUpstreamArrayOutput
	ToRepositoryUpstreamArrayOutputWithContext(context.Context) RepositoryUpstreamArrayOutput
}

RepositoryUpstreamArrayInput is an input type that accepts RepositoryUpstreamArray and RepositoryUpstreamArrayOutput values. You can construct a concrete instance of `RepositoryUpstreamArrayInput` via: 

RepositoryUpstreamArray{ RepositoryUpstreamArgs{...} }

type RepositoryUpstreamArrayOutput 

type RepositoryUpstreamArrayOutput struct{ *pulumi.OutputState }

func (RepositoryUpstreamArrayOutput) ElementType 

func (RepositoryUpstreamArrayOutput) ElementType() reflect.Type

func (RepositoryUpstreamArrayOutput) Index 

func (o RepositoryUpstreamArrayOutput) Index(i pulumi.IntInput) RepositoryUpstreamOutput

func (RepositoryUpstreamArrayOutput) ToRepositoryUpstreamArrayOutput 

func (o RepositoryUpstreamArrayOutput) ToRepositoryUpstreamArrayOutput() RepositoryUpstreamArrayOutput

func (RepositoryUpstreamArrayOutput) ToRepositoryUpstreamArrayOutputWithContext 

func (o RepositoryUpstreamArrayOutput) ToRepositoryUpstreamArrayOutputWithContext(ctx context.Context) RepositoryUpstreamArrayOutput

type RepositoryUpstreamInput 

type RepositoryUpstreamInput interface {
	pulumi.Input

	ToRepositoryUpstreamOutput() RepositoryUpstreamOutput
	ToRepositoryUpstreamOutputWithContext(context.Context) RepositoryUpstreamOutput
}

RepositoryUpstreamInput is an input type that accepts RepositoryUpstreamArgs and RepositoryUpstreamOutput values. You can construct a concrete instance of `RepositoryUpstreamInput` via: 

RepositoryUpstreamArgs{...}

type RepositoryUpstreamOutput 

type RepositoryUpstreamOutput struct{ *pulumi.OutputState }

func (RepositoryUpstreamOutput) ElementType 

func (RepositoryUpstreamOutput) ElementType() reflect.Type

func (RepositoryUpstreamOutput) RepositoryName 

func (o RepositoryUpstreamOutput) RepositoryName() pulumi.StringOutput

The name of an upstream repository.

func (RepositoryUpstreamOutput) ToRepositoryUpstreamOutput 

func (o RepositoryUpstreamOutput) ToRepositoryUpstreamOutput() RepositoryUpstreamOutput

func (RepositoryUpstreamOutput) ToRepositoryUpstreamOutputWithContext 

func (o RepositoryUpstreamOutput) ToRepositoryUpstreamOutputWithContext(ctx context.Context) RepositoryUpstreamOutput

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.