service

package
v0.0.0-...-0514e62 Latest Latest
Warning

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

 Go to latest Published: Jul 1, 2023 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PkgVersion 

func PkgVersion() (semver.Version, error)

PkgVersion uses reflection to determine the version of the current package. If a version cannot be determined, v1 will be assumed. The second return value is always nil.

Types

type Ami 

type Ami struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables AmiVariableArrayOutput `pulumi:"variables"`
}

Resource for creating an AMI service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewAmi(ctx, "exampleAmi", &service.AmiArgs{
			AppId:       exampleApplication.ID(),
			Description: pulumi.String("Service for deploying AMI's"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/ami:Ami example <app_id>/<svc_id>

```

func GetAmi 

func GetAmi(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AmiState, opts ...pulumi.ResourceOption) (*Ami, error)

GetAmi gets an existing Ami 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 NewAmi 

func NewAmi(ctx *pulumi.Context,
	name string, args *AmiArgs, opts ...pulumi.ResourceOption) (*Ami, error)

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

func (*Ami) ElementType 

func (*Ami) ElementType() reflect.Type

func (*Ami) ToAmiOutput 

func (i *Ami) ToAmiOutput() AmiOutput

func (*Ami) ToAmiOutputWithContext 

func (i *Ami) ToAmiOutputWithContext(ctx context.Context) AmiOutput

type AmiArgs 

type AmiArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables AmiVariableArrayInput
}

The set of arguments for constructing a Ami resource.

func (AmiArgs) ElementType 

func (AmiArgs) ElementType() reflect.Type

type AmiArray 

type AmiArray []AmiInput

func (AmiArray) ElementType 

func (AmiArray) ElementType() reflect.Type

func (AmiArray) ToAmiArrayOutput 

func (i AmiArray) ToAmiArrayOutput() AmiArrayOutput

func (AmiArray) ToAmiArrayOutputWithContext 

func (i AmiArray) ToAmiArrayOutputWithContext(ctx context.Context) AmiArrayOutput

type AmiArrayInput 

type AmiArrayInput interface {
	pulumi.Input

	ToAmiArrayOutput() AmiArrayOutput
	ToAmiArrayOutputWithContext(context.Context) AmiArrayOutput
}

AmiArrayInput is an input type that accepts AmiArray and AmiArrayOutput values. You can construct a concrete instance of `AmiArrayInput` via: 

AmiArray{ AmiArgs{...} }

type AmiArrayOutput 

type AmiArrayOutput struct{ *pulumi.OutputState }

func (AmiArrayOutput) ElementType 

func (AmiArrayOutput) ElementType() reflect.Type

func (AmiArrayOutput) Index 

func (o AmiArrayOutput) Index(i pulumi.IntInput) AmiOutput

func (AmiArrayOutput) ToAmiArrayOutput 

func (o AmiArrayOutput) ToAmiArrayOutput() AmiArrayOutput

func (AmiArrayOutput) ToAmiArrayOutputWithContext 

func (o AmiArrayOutput) ToAmiArrayOutputWithContext(ctx context.Context) AmiArrayOutput

type AmiInput 

type AmiInput interface {
	pulumi.Input

	ToAmiOutput() AmiOutput
	ToAmiOutputWithContext(ctx context.Context) AmiOutput
}

type AmiMap 

type AmiMap map[string]AmiInput

func (AmiMap) ElementType 

func (AmiMap) ElementType() reflect.Type

func (AmiMap) ToAmiMapOutput 

func (i AmiMap) ToAmiMapOutput() AmiMapOutput

func (AmiMap) ToAmiMapOutputWithContext 

func (i AmiMap) ToAmiMapOutputWithContext(ctx context.Context) AmiMapOutput

type AmiMapInput 

type AmiMapInput interface {
	pulumi.Input

	ToAmiMapOutput() AmiMapOutput
	ToAmiMapOutputWithContext(context.Context) AmiMapOutput
}

AmiMapInput is an input type that accepts AmiMap and AmiMapOutput values. You can construct a concrete instance of `AmiMapInput` via: 

AmiMap{ "key": AmiArgs{...} }

type AmiMapOutput 

type AmiMapOutput struct{ *pulumi.OutputState }

func (AmiMapOutput) ElementType 

func (AmiMapOutput) ElementType() reflect.Type

func (AmiMapOutput) MapIndex 

func (o AmiMapOutput) MapIndex(k pulumi.StringInput) AmiOutput

func (AmiMapOutput) ToAmiMapOutput 

func (o AmiMapOutput) ToAmiMapOutput() AmiMapOutput

func (AmiMapOutput) ToAmiMapOutputWithContext 

func (o AmiMapOutput) ToAmiMapOutputWithContext(ctx context.Context) AmiMapOutput

type AmiOutput 

type AmiOutput struct{ *pulumi.OutputState }

func (AmiOutput) AppId 

func (o AmiOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (AmiOutput) Description 

func (o AmiOutput) Description() pulumi.StringPtrOutput

Description of th service

func (AmiOutput) ElementType 

func (AmiOutput) ElementType() reflect.Type

func (AmiOutput) Name 

func (o AmiOutput) Name() pulumi.StringOutput

Name of the service

func (AmiOutput) ToAmiOutput 

func (o AmiOutput) ToAmiOutput() AmiOutput

func (AmiOutput) ToAmiOutputWithContext 

func (o AmiOutput) ToAmiOutputWithContext(ctx context.Context) AmiOutput

func (AmiOutput) Variables 

func (o AmiOutput) Variables() AmiVariableArrayOutput

Variables to be used in the service

type AmiState 

type AmiState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables AmiVariableArrayInput
}

func (AmiState) ElementType 

func (AmiState) ElementType() reflect.Type

type AmiVariable 

type AmiVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type AmiVariableArgs 

type AmiVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (AmiVariableArgs) ElementType 

func (AmiVariableArgs) ElementType() reflect.Type

func (AmiVariableArgs) ToAmiVariableOutput 

func (i AmiVariableArgs) ToAmiVariableOutput() AmiVariableOutput

func (AmiVariableArgs) ToAmiVariableOutputWithContext 

func (i AmiVariableArgs) ToAmiVariableOutputWithContext(ctx context.Context) AmiVariableOutput

type AmiVariableArray 

type AmiVariableArray []AmiVariableInput

func (AmiVariableArray) ElementType 

func (AmiVariableArray) ElementType() reflect.Type

func (AmiVariableArray) ToAmiVariableArrayOutput 

func (i AmiVariableArray) ToAmiVariableArrayOutput() AmiVariableArrayOutput

func (AmiVariableArray) ToAmiVariableArrayOutputWithContext 

func (i AmiVariableArray) ToAmiVariableArrayOutputWithContext(ctx context.Context) AmiVariableArrayOutput

type AmiVariableArrayInput 

type AmiVariableArrayInput interface {
	pulumi.Input

	ToAmiVariableArrayOutput() AmiVariableArrayOutput
	ToAmiVariableArrayOutputWithContext(context.Context) AmiVariableArrayOutput
}

AmiVariableArrayInput is an input type that accepts AmiVariableArray and AmiVariableArrayOutput values. You can construct a concrete instance of `AmiVariableArrayInput` via: 

AmiVariableArray{ AmiVariableArgs{...} }

type AmiVariableArrayOutput 

type AmiVariableArrayOutput struct{ *pulumi.OutputState }

func (AmiVariableArrayOutput) ElementType 

func (AmiVariableArrayOutput) ElementType() reflect.Type

func (AmiVariableArrayOutput) Index 

func (o AmiVariableArrayOutput) Index(i pulumi.IntInput) AmiVariableOutput

func (AmiVariableArrayOutput) ToAmiVariableArrayOutput 

func (o AmiVariableArrayOutput) ToAmiVariableArrayOutput() AmiVariableArrayOutput

func (AmiVariableArrayOutput) ToAmiVariableArrayOutputWithContext 

func (o AmiVariableArrayOutput) ToAmiVariableArrayOutputWithContext(ctx context.Context) AmiVariableArrayOutput

type AmiVariableInput 

type AmiVariableInput interface {
	pulumi.Input

	ToAmiVariableOutput() AmiVariableOutput
	ToAmiVariableOutputWithContext(context.Context) AmiVariableOutput
}

AmiVariableInput is an input type that accepts AmiVariableArgs and AmiVariableOutput values. You can construct a concrete instance of `AmiVariableInput` via: 

AmiVariableArgs{...}

type AmiVariableOutput 

type AmiVariableOutput struct{ *pulumi.OutputState }

func (AmiVariableOutput) ElementType 

func (AmiVariableOutput) ElementType() reflect.Type

func (AmiVariableOutput) Name 

func (o AmiVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (AmiVariableOutput) ToAmiVariableOutput 

func (o AmiVariableOutput) ToAmiVariableOutput() AmiVariableOutput

func (AmiVariableOutput) ToAmiVariableOutputWithContext 

func (o AmiVariableOutput) ToAmiVariableOutputWithContext(ctx context.Context) AmiVariableOutput

func (AmiVariableOutput) Type 

func (o AmiVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (AmiVariableOutput) Value 

func (o AmiVariableOutput) Value() pulumi.StringOutput

Value of the variable

type Codedeploy 

type Codedeploy struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables CodedeployVariableArrayOutput `pulumi:"variables"`
}

Resource for creating an AWS CodeDeploy service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewCodedeploy(ctx, "exampleCodedeploy", &service.CodedeployArgs{
			AppId:       exampleApplication.ID(),
			Description: pulumi.String("Service for AWS codedeploy applications."),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/codedeploy:Codedeploy example <app_id>/<svc_id>

```

func GetCodedeploy 

func GetCodedeploy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *CodedeployState, opts ...pulumi.ResourceOption) (*Codedeploy, error)

GetCodedeploy gets an existing Codedeploy 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 NewCodedeploy 

func NewCodedeploy(ctx *pulumi.Context,
	name string, args *CodedeployArgs, opts ...pulumi.ResourceOption) (*Codedeploy, error)

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

func (*Codedeploy) ElementType 

func (*Codedeploy) ElementType() reflect.Type

func (*Codedeploy) ToCodedeployOutput 

func (i *Codedeploy) ToCodedeployOutput() CodedeployOutput

func (*Codedeploy) ToCodedeployOutputWithContext 

func (i *Codedeploy) ToCodedeployOutputWithContext(ctx context.Context) CodedeployOutput

type CodedeployArgs 

type CodedeployArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables CodedeployVariableArrayInput
}

The set of arguments for constructing a Codedeploy resource.

func (CodedeployArgs) ElementType 

func (CodedeployArgs) ElementType() reflect.Type

type CodedeployArray 

type CodedeployArray []CodedeployInput

func (CodedeployArray) ElementType 

func (CodedeployArray) ElementType() reflect.Type

func (CodedeployArray) ToCodedeployArrayOutput 

func (i CodedeployArray) ToCodedeployArrayOutput() CodedeployArrayOutput

func (CodedeployArray) ToCodedeployArrayOutputWithContext 

func (i CodedeployArray) ToCodedeployArrayOutputWithContext(ctx context.Context) CodedeployArrayOutput

type CodedeployArrayInput 

type CodedeployArrayInput interface {
	pulumi.Input

	ToCodedeployArrayOutput() CodedeployArrayOutput
	ToCodedeployArrayOutputWithContext(context.Context) CodedeployArrayOutput
}

CodedeployArrayInput is an input type that accepts CodedeployArray and CodedeployArrayOutput values. You can construct a concrete instance of `CodedeployArrayInput` via: 

CodedeployArray{ CodedeployArgs{...} }

type CodedeployArrayOutput 

type CodedeployArrayOutput struct{ *pulumi.OutputState }

func (CodedeployArrayOutput) ElementType 

func (CodedeployArrayOutput) ElementType() reflect.Type

func (CodedeployArrayOutput) Index 

func (o CodedeployArrayOutput) Index(i pulumi.IntInput) CodedeployOutput

func (CodedeployArrayOutput) ToCodedeployArrayOutput 

func (o CodedeployArrayOutput) ToCodedeployArrayOutput() CodedeployArrayOutput

func (CodedeployArrayOutput) ToCodedeployArrayOutputWithContext 

func (o CodedeployArrayOutput) ToCodedeployArrayOutputWithContext(ctx context.Context) CodedeployArrayOutput

type CodedeployInput 

type CodedeployInput interface {
	pulumi.Input

	ToCodedeployOutput() CodedeployOutput
	ToCodedeployOutputWithContext(ctx context.Context) CodedeployOutput
}

type CodedeployMap 

type CodedeployMap map[string]CodedeployInput

func (CodedeployMap) ElementType 

func (CodedeployMap) ElementType() reflect.Type

func (CodedeployMap) ToCodedeployMapOutput 

func (i CodedeployMap) ToCodedeployMapOutput() CodedeployMapOutput

func (CodedeployMap) ToCodedeployMapOutputWithContext 

func (i CodedeployMap) ToCodedeployMapOutputWithContext(ctx context.Context) CodedeployMapOutput

type CodedeployMapInput 

type CodedeployMapInput interface {
	pulumi.Input

	ToCodedeployMapOutput() CodedeployMapOutput
	ToCodedeployMapOutputWithContext(context.Context) CodedeployMapOutput
}

CodedeployMapInput is an input type that accepts CodedeployMap and CodedeployMapOutput values. You can construct a concrete instance of `CodedeployMapInput` via: 

CodedeployMap{ "key": CodedeployArgs{...} }

type CodedeployMapOutput 

type CodedeployMapOutput struct{ *pulumi.OutputState }

func (CodedeployMapOutput) ElementType 

func (CodedeployMapOutput) ElementType() reflect.Type

func (CodedeployMapOutput) MapIndex 

func (o CodedeployMapOutput) MapIndex(k pulumi.StringInput) CodedeployOutput

func (CodedeployMapOutput) ToCodedeployMapOutput 

func (o CodedeployMapOutput) ToCodedeployMapOutput() CodedeployMapOutput

func (CodedeployMapOutput) ToCodedeployMapOutputWithContext 

func (o CodedeployMapOutput) ToCodedeployMapOutputWithContext(ctx context.Context) CodedeployMapOutput

type CodedeployOutput 

type CodedeployOutput struct{ *pulumi.OutputState }

func (CodedeployOutput) AppId 

func (o CodedeployOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (CodedeployOutput) Description 

func (o CodedeployOutput) Description() pulumi.StringPtrOutput

Description of th service

func (CodedeployOutput) ElementType 

func (CodedeployOutput) ElementType() reflect.Type

func (CodedeployOutput) Name 

func (o CodedeployOutput) Name() pulumi.StringOutput

Name of the service

func (CodedeployOutput) ToCodedeployOutput 

func (o CodedeployOutput) ToCodedeployOutput() CodedeployOutput

func (CodedeployOutput) ToCodedeployOutputWithContext 

func (o CodedeployOutput) ToCodedeployOutputWithContext(ctx context.Context) CodedeployOutput

func (CodedeployOutput) Variables 

func (o CodedeployOutput) Variables() CodedeployVariableArrayOutput

Variables to be used in the service

type CodedeployState 

type CodedeployState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables CodedeployVariableArrayInput
}

func (CodedeployState) ElementType 

func (CodedeployState) ElementType() reflect.Type

type CodedeployVariable 

type CodedeployVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type CodedeployVariableArgs 

type CodedeployVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (CodedeployVariableArgs) ElementType 

func (CodedeployVariableArgs) ElementType() reflect.Type

func (CodedeployVariableArgs) ToCodedeployVariableOutput 

func (i CodedeployVariableArgs) ToCodedeployVariableOutput() CodedeployVariableOutput

func (CodedeployVariableArgs) ToCodedeployVariableOutputWithContext 

func (i CodedeployVariableArgs) ToCodedeployVariableOutputWithContext(ctx context.Context) CodedeployVariableOutput

type CodedeployVariableArray 

type CodedeployVariableArray []CodedeployVariableInput

func (CodedeployVariableArray) ElementType 

func (CodedeployVariableArray) ElementType() reflect.Type

func (CodedeployVariableArray) ToCodedeployVariableArrayOutput 

func (i CodedeployVariableArray) ToCodedeployVariableArrayOutput() CodedeployVariableArrayOutput

func (CodedeployVariableArray) ToCodedeployVariableArrayOutputWithContext 

func (i CodedeployVariableArray) ToCodedeployVariableArrayOutputWithContext(ctx context.Context) CodedeployVariableArrayOutput

type CodedeployVariableArrayInput 

type CodedeployVariableArrayInput interface {
	pulumi.Input

	ToCodedeployVariableArrayOutput() CodedeployVariableArrayOutput
	ToCodedeployVariableArrayOutputWithContext(context.Context) CodedeployVariableArrayOutput
}

CodedeployVariableArrayInput is an input type that accepts CodedeployVariableArray and CodedeployVariableArrayOutput values. You can construct a concrete instance of `CodedeployVariableArrayInput` via: 

CodedeployVariableArray{ CodedeployVariableArgs{...} }

type CodedeployVariableArrayOutput 

type CodedeployVariableArrayOutput struct{ *pulumi.OutputState }

func (CodedeployVariableArrayOutput) ElementType 

func (CodedeployVariableArrayOutput) ElementType() reflect.Type

func (CodedeployVariableArrayOutput) Index 

func (o CodedeployVariableArrayOutput) Index(i pulumi.IntInput) CodedeployVariableOutput

func (CodedeployVariableArrayOutput) ToCodedeployVariableArrayOutput 

func (o CodedeployVariableArrayOutput) ToCodedeployVariableArrayOutput() CodedeployVariableArrayOutput

func (CodedeployVariableArrayOutput) ToCodedeployVariableArrayOutputWithContext 

func (o CodedeployVariableArrayOutput) ToCodedeployVariableArrayOutputWithContext(ctx context.Context) CodedeployVariableArrayOutput

type CodedeployVariableInput 

type CodedeployVariableInput interface {
	pulumi.Input

	ToCodedeployVariableOutput() CodedeployVariableOutput
	ToCodedeployVariableOutputWithContext(context.Context) CodedeployVariableOutput
}

CodedeployVariableInput is an input type that accepts CodedeployVariableArgs and CodedeployVariableOutput values. You can construct a concrete instance of `CodedeployVariableInput` via: 

CodedeployVariableArgs{...}

type CodedeployVariableOutput 

type CodedeployVariableOutput struct{ *pulumi.OutputState }

func (CodedeployVariableOutput) ElementType 

func (CodedeployVariableOutput) ElementType() reflect.Type

func (CodedeployVariableOutput) Name 

func (o CodedeployVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (CodedeployVariableOutput) ToCodedeployVariableOutput 

func (o CodedeployVariableOutput) ToCodedeployVariableOutput() CodedeployVariableOutput

func (CodedeployVariableOutput) ToCodedeployVariableOutputWithContext 

func (o CodedeployVariableOutput) ToCodedeployVariableOutputWithContext(ctx context.Context) CodedeployVariableOutput

func (CodedeployVariableOutput) Type 

func (o CodedeployVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (CodedeployVariableOutput) Value 

func (o CodedeployVariableOutput) Value() pulumi.StringOutput

Value of the variable

type Ecs 

type Ecs struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables EcsVariableArrayOutput `pulumi:"variables"`
}

Resource for creating an AWS ECS service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewEcs(ctx, "exampleEcs", &service.EcsArgs{
			AppId:       exampleApplication.ID(),
			Description: pulumi.String("Service for deploying AWS ECS tasks."),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/ecs:Ecs example <app_id>/<svc_id>

```

func GetEcs 

func GetEcs(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EcsState, opts ...pulumi.ResourceOption) (*Ecs, error)

GetEcs gets an existing Ecs 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 NewEcs 

func NewEcs(ctx *pulumi.Context,
	name string, args *EcsArgs, opts ...pulumi.ResourceOption) (*Ecs, error)

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

func (*Ecs) ElementType 

func (*Ecs) ElementType() reflect.Type

func (*Ecs) ToEcsOutput 

func (i *Ecs) ToEcsOutput() EcsOutput

func (*Ecs) ToEcsOutputWithContext 

func (i *Ecs) ToEcsOutputWithContext(ctx context.Context) EcsOutput

type EcsArgs 

type EcsArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables EcsVariableArrayInput
}

The set of arguments for constructing a Ecs resource.

func (EcsArgs) ElementType 

func (EcsArgs) ElementType() reflect.Type

type EcsArray 

type EcsArray []EcsInput

func (EcsArray) ElementType 

func (EcsArray) ElementType() reflect.Type

func (EcsArray) ToEcsArrayOutput 

func (i EcsArray) ToEcsArrayOutput() EcsArrayOutput

func (EcsArray) ToEcsArrayOutputWithContext 

func (i EcsArray) ToEcsArrayOutputWithContext(ctx context.Context) EcsArrayOutput

type EcsArrayInput 

type EcsArrayInput interface {
	pulumi.Input

	ToEcsArrayOutput() EcsArrayOutput
	ToEcsArrayOutputWithContext(context.Context) EcsArrayOutput
}

EcsArrayInput is an input type that accepts EcsArray and EcsArrayOutput values. You can construct a concrete instance of `EcsArrayInput` via: 

EcsArray{ EcsArgs{...} }

type EcsArrayOutput 

type EcsArrayOutput struct{ *pulumi.OutputState }

func (EcsArrayOutput) ElementType 

func (EcsArrayOutput) ElementType() reflect.Type

func (EcsArrayOutput) Index 

func (o EcsArrayOutput) Index(i pulumi.IntInput) EcsOutput

func (EcsArrayOutput) ToEcsArrayOutput 

func (o EcsArrayOutput) ToEcsArrayOutput() EcsArrayOutput

func (EcsArrayOutput) ToEcsArrayOutputWithContext 

func (o EcsArrayOutput) ToEcsArrayOutputWithContext(ctx context.Context) EcsArrayOutput

type EcsInput 

type EcsInput interface {
	pulumi.Input

	ToEcsOutput() EcsOutput
	ToEcsOutputWithContext(ctx context.Context) EcsOutput
}

type EcsMap 

type EcsMap map[string]EcsInput

func (EcsMap) ElementType 

func (EcsMap) ElementType() reflect.Type

func (EcsMap) ToEcsMapOutput 

func (i EcsMap) ToEcsMapOutput() EcsMapOutput

func (EcsMap) ToEcsMapOutputWithContext 

func (i EcsMap) ToEcsMapOutputWithContext(ctx context.Context) EcsMapOutput

type EcsMapInput 

type EcsMapInput interface {
	pulumi.Input

	ToEcsMapOutput() EcsMapOutput
	ToEcsMapOutputWithContext(context.Context) EcsMapOutput
}

EcsMapInput is an input type that accepts EcsMap and EcsMapOutput values. You can construct a concrete instance of `EcsMapInput` via: 

EcsMap{ "key": EcsArgs{...} }

type EcsMapOutput 

type EcsMapOutput struct{ *pulumi.OutputState }

func (EcsMapOutput) ElementType 

func (EcsMapOutput) ElementType() reflect.Type

func (EcsMapOutput) MapIndex 

func (o EcsMapOutput) MapIndex(k pulumi.StringInput) EcsOutput

func (EcsMapOutput) ToEcsMapOutput 

func (o EcsMapOutput) ToEcsMapOutput() EcsMapOutput

func (EcsMapOutput) ToEcsMapOutputWithContext 

func (o EcsMapOutput) ToEcsMapOutputWithContext(ctx context.Context) EcsMapOutput

type EcsOutput 

type EcsOutput struct{ *pulumi.OutputState }

func (EcsOutput) AppId 

func (o EcsOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (EcsOutput) Description 

func (o EcsOutput) Description() pulumi.StringPtrOutput

Description of th service

func (EcsOutput) ElementType 

func (EcsOutput) ElementType() reflect.Type

func (EcsOutput) Name 

func (o EcsOutput) Name() pulumi.StringOutput

Name of the service

func (EcsOutput) ToEcsOutput 

func (o EcsOutput) ToEcsOutput() EcsOutput

func (EcsOutput) ToEcsOutputWithContext 

func (o EcsOutput) ToEcsOutputWithContext(ctx context.Context) EcsOutput

func (EcsOutput) Variables 

func (o EcsOutput) Variables() EcsVariableArrayOutput

Variables to be used in the service

type EcsState 

type EcsState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables EcsVariableArrayInput
}

func (EcsState) ElementType 

func (EcsState) ElementType() reflect.Type

type EcsVariable 

type EcsVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type EcsVariableArgs 

type EcsVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (EcsVariableArgs) ElementType 

func (EcsVariableArgs) ElementType() reflect.Type

func (EcsVariableArgs) ToEcsVariableOutput 

func (i EcsVariableArgs) ToEcsVariableOutput() EcsVariableOutput

func (EcsVariableArgs) ToEcsVariableOutputWithContext 

func (i EcsVariableArgs) ToEcsVariableOutputWithContext(ctx context.Context) EcsVariableOutput

type EcsVariableArray 

type EcsVariableArray []EcsVariableInput

func (EcsVariableArray) ElementType 

func (EcsVariableArray) ElementType() reflect.Type

func (EcsVariableArray) ToEcsVariableArrayOutput 

func (i EcsVariableArray) ToEcsVariableArrayOutput() EcsVariableArrayOutput

func (EcsVariableArray) ToEcsVariableArrayOutputWithContext 

func (i EcsVariableArray) ToEcsVariableArrayOutputWithContext(ctx context.Context) EcsVariableArrayOutput

type EcsVariableArrayInput 

type EcsVariableArrayInput interface {
	pulumi.Input

	ToEcsVariableArrayOutput() EcsVariableArrayOutput
	ToEcsVariableArrayOutputWithContext(context.Context) EcsVariableArrayOutput
}

EcsVariableArrayInput is an input type that accepts EcsVariableArray and EcsVariableArrayOutput values. You can construct a concrete instance of `EcsVariableArrayInput` via: 

EcsVariableArray{ EcsVariableArgs{...} }

type EcsVariableArrayOutput 

type EcsVariableArrayOutput struct{ *pulumi.OutputState }

func (EcsVariableArrayOutput) ElementType 

func (EcsVariableArrayOutput) ElementType() reflect.Type

func (EcsVariableArrayOutput) Index 

func (o EcsVariableArrayOutput) Index(i pulumi.IntInput) EcsVariableOutput

func (EcsVariableArrayOutput) ToEcsVariableArrayOutput 

func (o EcsVariableArrayOutput) ToEcsVariableArrayOutput() EcsVariableArrayOutput

func (EcsVariableArrayOutput) ToEcsVariableArrayOutputWithContext 

func (o EcsVariableArrayOutput) ToEcsVariableArrayOutputWithContext(ctx context.Context) EcsVariableArrayOutput

type EcsVariableInput 

type EcsVariableInput interface {
	pulumi.Input

	ToEcsVariableOutput() EcsVariableOutput
	ToEcsVariableOutputWithContext(context.Context) EcsVariableOutput
}

EcsVariableInput is an input type that accepts EcsVariableArgs and EcsVariableOutput values. You can construct a concrete instance of `EcsVariableInput` via: 

EcsVariableArgs{...}

type EcsVariableOutput 

type EcsVariableOutput struct{ *pulumi.OutputState }

func (EcsVariableOutput) ElementType 

func (EcsVariableOutput) ElementType() reflect.Type

func (EcsVariableOutput) Name 

func (o EcsVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (EcsVariableOutput) ToEcsVariableOutput 

func (o EcsVariableOutput) ToEcsVariableOutput() EcsVariableOutput

func (EcsVariableOutput) ToEcsVariableOutputWithContext 

func (o EcsVariableOutput) ToEcsVariableOutputWithContext(ctx context.Context) EcsVariableOutput

func (EcsVariableOutput) Type 

func (o EcsVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (EcsVariableOutput) Value 

func (o EcsVariableOutput) Value() pulumi.StringOutput

Value of the variable

type Helm 

type Helm struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables HelmVariableArrayOutput `pulumi:"variables"`
}

Resource for creating a Kubernetes Helm service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewHelm(ctx, "exampleHelm", &service.HelmArgs{
			AppId:       exampleApplication.ID(),
			Description: pulumi.String("Service for deploying native Helm application.s"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/helm:Helm example <app_id>/<svc_id>

```

func GetHelm 

func GetHelm(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *HelmState, opts ...pulumi.ResourceOption) (*Helm, error)

GetHelm gets an existing Helm 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 NewHelm 

func NewHelm(ctx *pulumi.Context,
	name string, args *HelmArgs, opts ...pulumi.ResourceOption) (*Helm, error)

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

func (*Helm) ElementType 

func (*Helm) ElementType() reflect.Type

func (*Helm) ToHelmOutput 

func (i *Helm) ToHelmOutput() HelmOutput

func (*Helm) ToHelmOutputWithContext 

func (i *Helm) ToHelmOutputWithContext(ctx context.Context) HelmOutput

type HelmArgs 

type HelmArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables HelmVariableArrayInput
}

The set of arguments for constructing a Helm resource.

func (HelmArgs) ElementType 

func (HelmArgs) ElementType() reflect.Type

type HelmArray 

type HelmArray []HelmInput

func (HelmArray) ElementType 

func (HelmArray) ElementType() reflect.Type

func (HelmArray) ToHelmArrayOutput 

func (i HelmArray) ToHelmArrayOutput() HelmArrayOutput

func (HelmArray) ToHelmArrayOutputWithContext 

func (i HelmArray) ToHelmArrayOutputWithContext(ctx context.Context) HelmArrayOutput

type HelmArrayInput 

type HelmArrayInput interface {
	pulumi.Input

	ToHelmArrayOutput() HelmArrayOutput
	ToHelmArrayOutputWithContext(context.Context) HelmArrayOutput
}

HelmArrayInput is an input type that accepts HelmArray and HelmArrayOutput values. You can construct a concrete instance of `HelmArrayInput` via: 

HelmArray{ HelmArgs{...} }

type HelmArrayOutput 

type HelmArrayOutput struct{ *pulumi.OutputState }

func (HelmArrayOutput) ElementType 

func (HelmArrayOutput) ElementType() reflect.Type

func (HelmArrayOutput) Index 

func (o HelmArrayOutput) Index(i pulumi.IntInput) HelmOutput

func (HelmArrayOutput) ToHelmArrayOutput 

func (o HelmArrayOutput) ToHelmArrayOutput() HelmArrayOutput

func (HelmArrayOutput) ToHelmArrayOutputWithContext 

func (o HelmArrayOutput) ToHelmArrayOutputWithContext(ctx context.Context) HelmArrayOutput

type HelmInput 

type HelmInput interface {
	pulumi.Input

	ToHelmOutput() HelmOutput
	ToHelmOutputWithContext(ctx context.Context) HelmOutput
}

type HelmMap 

type HelmMap map[string]HelmInput

func (HelmMap) ElementType 

func (HelmMap) ElementType() reflect.Type

func (HelmMap) ToHelmMapOutput 

func (i HelmMap) ToHelmMapOutput() HelmMapOutput

func (HelmMap) ToHelmMapOutputWithContext 

func (i HelmMap) ToHelmMapOutputWithContext(ctx context.Context) HelmMapOutput

type HelmMapInput 

type HelmMapInput interface {
	pulumi.Input

	ToHelmMapOutput() HelmMapOutput
	ToHelmMapOutputWithContext(context.Context) HelmMapOutput
}

HelmMapInput is an input type that accepts HelmMap and HelmMapOutput values. You can construct a concrete instance of `HelmMapInput` via: 

HelmMap{ "key": HelmArgs{...} }

type HelmMapOutput 

type HelmMapOutput struct{ *pulumi.OutputState }

func (HelmMapOutput) ElementType 

func (HelmMapOutput) ElementType() reflect.Type

func (HelmMapOutput) MapIndex 

func (o HelmMapOutput) MapIndex(k pulumi.StringInput) HelmOutput

func (HelmMapOutput) ToHelmMapOutput 

func (o HelmMapOutput) ToHelmMapOutput() HelmMapOutput

func (HelmMapOutput) ToHelmMapOutputWithContext 

func (o HelmMapOutput) ToHelmMapOutputWithContext(ctx context.Context) HelmMapOutput

type HelmOutput 

type HelmOutput struct{ *pulumi.OutputState }

func (HelmOutput) AppId 

func (o HelmOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (HelmOutput) Description 

func (o HelmOutput) Description() pulumi.StringPtrOutput

Description of th service

func (HelmOutput) ElementType 

func (HelmOutput) ElementType() reflect.Type

func (HelmOutput) Name 

func (o HelmOutput) Name() pulumi.StringOutput

Name of the service

func (HelmOutput) ToHelmOutput 

func (o HelmOutput) ToHelmOutput() HelmOutput

func (HelmOutput) ToHelmOutputWithContext 

func (o HelmOutput) ToHelmOutputWithContext(ctx context.Context) HelmOutput

func (HelmOutput) Variables 

func (o HelmOutput) Variables() HelmVariableArrayOutput

Variables to be used in the service

type HelmState 

type HelmState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables HelmVariableArrayInput
}

func (HelmState) ElementType 

func (HelmState) ElementType() reflect.Type

type HelmVariable 

type HelmVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type HelmVariableArgs 

type HelmVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (HelmVariableArgs) ElementType 

func (HelmVariableArgs) ElementType() reflect.Type

func (HelmVariableArgs) ToHelmVariableOutput 

func (i HelmVariableArgs) ToHelmVariableOutput() HelmVariableOutput

func (HelmVariableArgs) ToHelmVariableOutputWithContext 

func (i HelmVariableArgs) ToHelmVariableOutputWithContext(ctx context.Context) HelmVariableOutput

type HelmVariableArray 

type HelmVariableArray []HelmVariableInput

func (HelmVariableArray) ElementType 

func (HelmVariableArray) ElementType() reflect.Type

func (HelmVariableArray) ToHelmVariableArrayOutput 

func (i HelmVariableArray) ToHelmVariableArrayOutput() HelmVariableArrayOutput

func (HelmVariableArray) ToHelmVariableArrayOutputWithContext 

func (i HelmVariableArray) ToHelmVariableArrayOutputWithContext(ctx context.Context) HelmVariableArrayOutput

type HelmVariableArrayInput 

type HelmVariableArrayInput interface {
	pulumi.Input

	ToHelmVariableArrayOutput() HelmVariableArrayOutput
	ToHelmVariableArrayOutputWithContext(context.Context) HelmVariableArrayOutput
}

HelmVariableArrayInput is an input type that accepts HelmVariableArray and HelmVariableArrayOutput values. You can construct a concrete instance of `HelmVariableArrayInput` via: 

HelmVariableArray{ HelmVariableArgs{...} }

type HelmVariableArrayOutput 

type HelmVariableArrayOutput struct{ *pulumi.OutputState }

func (HelmVariableArrayOutput) ElementType 

func (HelmVariableArrayOutput) ElementType() reflect.Type

func (HelmVariableArrayOutput) Index 

func (o HelmVariableArrayOutput) Index(i pulumi.IntInput) HelmVariableOutput

func (HelmVariableArrayOutput) ToHelmVariableArrayOutput 

func (o HelmVariableArrayOutput) ToHelmVariableArrayOutput() HelmVariableArrayOutput

func (HelmVariableArrayOutput) ToHelmVariableArrayOutputWithContext 

func (o HelmVariableArrayOutput) ToHelmVariableArrayOutputWithContext(ctx context.Context) HelmVariableArrayOutput

type HelmVariableInput 

type HelmVariableInput interface {
	pulumi.Input

	ToHelmVariableOutput() HelmVariableOutput
	ToHelmVariableOutputWithContext(context.Context) HelmVariableOutput
}

HelmVariableInput is an input type that accepts HelmVariableArgs and HelmVariableOutput values. You can construct a concrete instance of `HelmVariableInput` via: 

HelmVariableArgs{...}

type HelmVariableOutput 

type HelmVariableOutput struct{ *pulumi.OutputState }

func (HelmVariableOutput) ElementType 

func (HelmVariableOutput) ElementType() reflect.Type

func (HelmVariableOutput) Name 

func (o HelmVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (HelmVariableOutput) ToHelmVariableOutput 

func (o HelmVariableOutput) ToHelmVariableOutput() HelmVariableOutput

func (HelmVariableOutput) ToHelmVariableOutputWithContext 

func (o HelmVariableOutput) ToHelmVariableOutputWithContext(ctx context.Context) HelmVariableOutput

func (HelmVariableOutput) Type 

func (o HelmVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (HelmVariableOutput) Value 

func (o HelmVariableOutput) Value() pulumi.StringOutput

Value of the variable

type Kubernetes 

type Kubernetes struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The version of Helm to use. Options are `V2` and `V3`. Defaults to 'V2'. Only used when `type` is `KUBERNETES` or `HELM`.
	HelmVersion pulumi.StringPtrOutput `pulumi:"helmVersion"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables KubernetesVariableArrayOutput `pulumi:"variables"`
}

Resource for creating a Kubernetes service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewKubernetes(ctx, "exampleKubernetes", &service.KubernetesArgs{
			AppId:       exampleApplication.ID(),
			HelmVersion: pulumi.String("V3"),
			Description: pulumi.String("Service for deploying Kubernetes manifests"),
			Variables: service.KubernetesVariableArray{
				&service.KubernetesVariableArgs{
					Name:  pulumi.String("test"),
					Value: pulumi.String("test_value"),
					Type:  pulumi.String("TEXT"),
				},
				&service.KubernetesVariableArgs{
					Name:  pulumi.String("test2"),
					Value: pulumi.String("test_value2"),
					Type:  pulumi.String("TEXT"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/kubernetes:Kubernetes example <app_id>/<svc_id>

```

func GetKubernetes 

func GetKubernetes(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *KubernetesState, opts ...pulumi.ResourceOption) (*Kubernetes, error)

GetKubernetes gets an existing Kubernetes 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 NewKubernetes 

func NewKubernetes(ctx *pulumi.Context,
	name string, args *KubernetesArgs, opts ...pulumi.ResourceOption) (*Kubernetes, error)

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

func (*Kubernetes) ElementType 

func (*Kubernetes) ElementType() reflect.Type

func (*Kubernetes) ToKubernetesOutput 

func (i *Kubernetes) ToKubernetesOutput() KubernetesOutput

func (*Kubernetes) ToKubernetesOutputWithContext 

func (i *Kubernetes) ToKubernetesOutputWithContext(ctx context.Context) KubernetesOutput

type KubernetesArgs 

type KubernetesArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// The version of Helm to use. Options are `V2` and `V3`. Defaults to 'V2'. Only used when `type` is `KUBERNETES` or `HELM`.
	HelmVersion pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables KubernetesVariableArrayInput
}

The set of arguments for constructing a Kubernetes resource.

func (KubernetesArgs) ElementType 

func (KubernetesArgs) ElementType() reflect.Type

type KubernetesArray 

type KubernetesArray []KubernetesInput

func (KubernetesArray) ElementType 

func (KubernetesArray) ElementType() reflect.Type

func (KubernetesArray) ToKubernetesArrayOutput 

func (i KubernetesArray) ToKubernetesArrayOutput() KubernetesArrayOutput

func (KubernetesArray) ToKubernetesArrayOutputWithContext 

func (i KubernetesArray) ToKubernetesArrayOutputWithContext(ctx context.Context) KubernetesArrayOutput

type KubernetesArrayInput 

type KubernetesArrayInput interface {
	pulumi.Input

	ToKubernetesArrayOutput() KubernetesArrayOutput
	ToKubernetesArrayOutputWithContext(context.Context) KubernetesArrayOutput
}

KubernetesArrayInput is an input type that accepts KubernetesArray and KubernetesArrayOutput values. You can construct a concrete instance of `KubernetesArrayInput` via: 

KubernetesArray{ KubernetesArgs{...} }

type KubernetesArrayOutput 

type KubernetesArrayOutput struct{ *pulumi.OutputState }

func (KubernetesArrayOutput) ElementType 

func (KubernetesArrayOutput) ElementType() reflect.Type

func (KubernetesArrayOutput) Index 

func (o KubernetesArrayOutput) Index(i pulumi.IntInput) KubernetesOutput

func (KubernetesArrayOutput) ToKubernetesArrayOutput 

func (o KubernetesArrayOutput) ToKubernetesArrayOutput() KubernetesArrayOutput

func (KubernetesArrayOutput) ToKubernetesArrayOutputWithContext 

func (o KubernetesArrayOutput) ToKubernetesArrayOutputWithContext(ctx context.Context) KubernetesArrayOutput

type KubernetesInput 

type KubernetesInput interface {
	pulumi.Input

	ToKubernetesOutput() KubernetesOutput
	ToKubernetesOutputWithContext(ctx context.Context) KubernetesOutput
}

type KubernetesMap 

type KubernetesMap map[string]KubernetesInput

func (KubernetesMap) ElementType 

func (KubernetesMap) ElementType() reflect.Type

func (KubernetesMap) ToKubernetesMapOutput 

func (i KubernetesMap) ToKubernetesMapOutput() KubernetesMapOutput

func (KubernetesMap) ToKubernetesMapOutputWithContext 

func (i KubernetesMap) ToKubernetesMapOutputWithContext(ctx context.Context) KubernetesMapOutput

type KubernetesMapInput 

type KubernetesMapInput interface {
	pulumi.Input

	ToKubernetesMapOutput() KubernetesMapOutput
	ToKubernetesMapOutputWithContext(context.Context) KubernetesMapOutput
}

KubernetesMapInput is an input type that accepts KubernetesMap and KubernetesMapOutput values. You can construct a concrete instance of `KubernetesMapInput` via: 

KubernetesMap{ "key": KubernetesArgs{...} }

type KubernetesMapOutput 

type KubernetesMapOutput struct{ *pulumi.OutputState }

func (KubernetesMapOutput) ElementType 

func (KubernetesMapOutput) ElementType() reflect.Type

func (KubernetesMapOutput) MapIndex 

func (o KubernetesMapOutput) MapIndex(k pulumi.StringInput) KubernetesOutput

func (KubernetesMapOutput) ToKubernetesMapOutput 

func (o KubernetesMapOutput) ToKubernetesMapOutput() KubernetesMapOutput

func (KubernetesMapOutput) ToKubernetesMapOutputWithContext 

func (o KubernetesMapOutput) ToKubernetesMapOutputWithContext(ctx context.Context) KubernetesMapOutput

type KubernetesOutput 

type KubernetesOutput struct{ *pulumi.OutputState }

func (KubernetesOutput) AppId 

func (o KubernetesOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (KubernetesOutput) Description 

func (o KubernetesOutput) Description() pulumi.StringPtrOutput

Description of th service

func (KubernetesOutput) ElementType 

func (KubernetesOutput) ElementType() reflect.Type

func (KubernetesOutput) HelmVersion 

func (o KubernetesOutput) HelmVersion() pulumi.StringPtrOutput

The version of Helm to use. Options are `V2` and `V3`. Defaults to 'V2'. Only used when `type` is `KUBERNETES` or `HELM`.

func (KubernetesOutput) Name 

func (o KubernetesOutput) Name() pulumi.StringOutput

Name of the service

func (KubernetesOutput) ToKubernetesOutput 

func (o KubernetesOutput) ToKubernetesOutput() KubernetesOutput

func (KubernetesOutput) ToKubernetesOutputWithContext 

func (o KubernetesOutput) ToKubernetesOutputWithContext(ctx context.Context) KubernetesOutput

func (KubernetesOutput) Variables 

func (o KubernetesOutput) Variables() KubernetesVariableArrayOutput

Variables to be used in the service

type KubernetesState 

type KubernetesState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// The version of Helm to use. Options are `V2` and `V3`. Defaults to 'V2'. Only used when `type` is `KUBERNETES` or `HELM`.
	HelmVersion pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables KubernetesVariableArrayInput
}

func (KubernetesState) ElementType 

func (KubernetesState) ElementType() reflect.Type

type KubernetesVariable 

type KubernetesVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type KubernetesVariableArgs 

type KubernetesVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (KubernetesVariableArgs) ElementType 

func (KubernetesVariableArgs) ElementType() reflect.Type

func (KubernetesVariableArgs) ToKubernetesVariableOutput 

func (i KubernetesVariableArgs) ToKubernetesVariableOutput() KubernetesVariableOutput

func (KubernetesVariableArgs) ToKubernetesVariableOutputWithContext 

func (i KubernetesVariableArgs) ToKubernetesVariableOutputWithContext(ctx context.Context) KubernetesVariableOutput

type KubernetesVariableArray 

type KubernetesVariableArray []KubernetesVariableInput

func (KubernetesVariableArray) ElementType 

func (KubernetesVariableArray) ElementType() reflect.Type

func (KubernetesVariableArray) ToKubernetesVariableArrayOutput 

func (i KubernetesVariableArray) ToKubernetesVariableArrayOutput() KubernetesVariableArrayOutput

func (KubernetesVariableArray) ToKubernetesVariableArrayOutputWithContext 

func (i KubernetesVariableArray) ToKubernetesVariableArrayOutputWithContext(ctx context.Context) KubernetesVariableArrayOutput

type KubernetesVariableArrayInput 

type KubernetesVariableArrayInput interface {
	pulumi.Input

	ToKubernetesVariableArrayOutput() KubernetesVariableArrayOutput
	ToKubernetesVariableArrayOutputWithContext(context.Context) KubernetesVariableArrayOutput
}

KubernetesVariableArrayInput is an input type that accepts KubernetesVariableArray and KubernetesVariableArrayOutput values. You can construct a concrete instance of `KubernetesVariableArrayInput` via: 

KubernetesVariableArray{ KubernetesVariableArgs{...} }

type KubernetesVariableArrayOutput 

type KubernetesVariableArrayOutput struct{ *pulumi.OutputState }

func (KubernetesVariableArrayOutput) ElementType 

func (KubernetesVariableArrayOutput) ElementType() reflect.Type

func (KubernetesVariableArrayOutput) Index 

func (o KubernetesVariableArrayOutput) Index(i pulumi.IntInput) KubernetesVariableOutput

func (KubernetesVariableArrayOutput) ToKubernetesVariableArrayOutput 

func (o KubernetesVariableArrayOutput) ToKubernetesVariableArrayOutput() KubernetesVariableArrayOutput

func (KubernetesVariableArrayOutput) ToKubernetesVariableArrayOutputWithContext 

func (o KubernetesVariableArrayOutput) ToKubernetesVariableArrayOutputWithContext(ctx context.Context) KubernetesVariableArrayOutput

type KubernetesVariableInput 

type KubernetesVariableInput interface {
	pulumi.Input

	ToKubernetesVariableOutput() KubernetesVariableOutput
	ToKubernetesVariableOutputWithContext(context.Context) KubernetesVariableOutput
}

KubernetesVariableInput is an input type that accepts KubernetesVariableArgs and KubernetesVariableOutput values. You can construct a concrete instance of `KubernetesVariableInput` via: 

KubernetesVariableArgs{...}

type KubernetesVariableOutput 

type KubernetesVariableOutput struct{ *pulumi.OutputState }

func (KubernetesVariableOutput) ElementType 

func (KubernetesVariableOutput) ElementType() reflect.Type

func (KubernetesVariableOutput) Name 

func (o KubernetesVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (KubernetesVariableOutput) ToKubernetesVariableOutput 

func (o KubernetesVariableOutput) ToKubernetesVariableOutput() KubernetesVariableOutput

func (KubernetesVariableOutput) ToKubernetesVariableOutputWithContext 

func (o KubernetesVariableOutput) ToKubernetesVariableOutputWithContext(ctx context.Context) KubernetesVariableOutput

func (KubernetesVariableOutput) Type 

func (o KubernetesVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (KubernetesVariableOutput) Value 

func (o KubernetesVariableOutput) Value() pulumi.StringOutput

Value of the variable

type Lambda 

type Lambda struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables LambdaVariableArrayOutput `pulumi:"variables"`
}

Resource for creating an AWS Lambda service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewLambda(ctx, "exampleLambda", &service.LambdaArgs{
			AppId:       exampleApplication.ID(),
			Description: pulumi.String("Service for deploying AWS Lambda functions."),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/lambda:Lambda example <app_id>/<svc_id>

```

func GetLambda 

func GetLambda(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LambdaState, opts ...pulumi.ResourceOption) (*Lambda, error)

GetLambda gets an existing Lambda 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 NewLambda 

func NewLambda(ctx *pulumi.Context,
	name string, args *LambdaArgs, opts ...pulumi.ResourceOption) (*Lambda, error)

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

func (*Lambda) ElementType 

func (*Lambda) ElementType() reflect.Type

func (*Lambda) ToLambdaOutput 

func (i *Lambda) ToLambdaOutput() LambdaOutput

func (*Lambda) ToLambdaOutputWithContext 

func (i *Lambda) ToLambdaOutputWithContext(ctx context.Context) LambdaOutput

type LambdaArgs 

type LambdaArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables LambdaVariableArrayInput
}

The set of arguments for constructing a Lambda resource.

func (LambdaArgs) ElementType 

func (LambdaArgs) ElementType() reflect.Type

type LambdaArray 

type LambdaArray []LambdaInput

func (LambdaArray) ElementType 

func (LambdaArray) ElementType() reflect.Type

func (LambdaArray) ToLambdaArrayOutput 

func (i LambdaArray) ToLambdaArrayOutput() LambdaArrayOutput

func (LambdaArray) ToLambdaArrayOutputWithContext 

func (i LambdaArray) ToLambdaArrayOutputWithContext(ctx context.Context) LambdaArrayOutput

type LambdaArrayInput 

type LambdaArrayInput interface {
	pulumi.Input

	ToLambdaArrayOutput() LambdaArrayOutput
	ToLambdaArrayOutputWithContext(context.Context) LambdaArrayOutput
}

LambdaArrayInput is an input type that accepts LambdaArray and LambdaArrayOutput values. You can construct a concrete instance of `LambdaArrayInput` via: 

LambdaArray{ LambdaArgs{...} }

type LambdaArrayOutput 

type LambdaArrayOutput struct{ *pulumi.OutputState }

func (LambdaArrayOutput) ElementType 

func (LambdaArrayOutput) ElementType() reflect.Type

func (LambdaArrayOutput) Index 

func (o LambdaArrayOutput) Index(i pulumi.IntInput) LambdaOutput

func (LambdaArrayOutput) ToLambdaArrayOutput 

func (o LambdaArrayOutput) ToLambdaArrayOutput() LambdaArrayOutput

func (LambdaArrayOutput) ToLambdaArrayOutputWithContext 

func (o LambdaArrayOutput) ToLambdaArrayOutputWithContext(ctx context.Context) LambdaArrayOutput

type LambdaInput 

type LambdaInput interface {
	pulumi.Input

	ToLambdaOutput() LambdaOutput
	ToLambdaOutputWithContext(ctx context.Context) LambdaOutput
}

type LambdaMap 

type LambdaMap map[string]LambdaInput

func (LambdaMap) ElementType 

func (LambdaMap) ElementType() reflect.Type

func (LambdaMap) ToLambdaMapOutput 

func (i LambdaMap) ToLambdaMapOutput() LambdaMapOutput

func (LambdaMap) ToLambdaMapOutputWithContext 

func (i LambdaMap) ToLambdaMapOutputWithContext(ctx context.Context) LambdaMapOutput

type LambdaMapInput 

type LambdaMapInput interface {
	pulumi.Input

	ToLambdaMapOutput() LambdaMapOutput
	ToLambdaMapOutputWithContext(context.Context) LambdaMapOutput
}

LambdaMapInput is an input type that accepts LambdaMap and LambdaMapOutput values. You can construct a concrete instance of `LambdaMapInput` via: 

LambdaMap{ "key": LambdaArgs{...} }

type LambdaMapOutput 

type LambdaMapOutput struct{ *pulumi.OutputState }

func (LambdaMapOutput) ElementType 

func (LambdaMapOutput) ElementType() reflect.Type

func (LambdaMapOutput) MapIndex 

func (o LambdaMapOutput) MapIndex(k pulumi.StringInput) LambdaOutput

func (LambdaMapOutput) ToLambdaMapOutput 

func (o LambdaMapOutput) ToLambdaMapOutput() LambdaMapOutput

func (LambdaMapOutput) ToLambdaMapOutputWithContext 

func (o LambdaMapOutput) ToLambdaMapOutputWithContext(ctx context.Context) LambdaMapOutput

type LambdaOutput 

type LambdaOutput struct{ *pulumi.OutputState }

func (LambdaOutput) AppId 

func (o LambdaOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (LambdaOutput) Description 

func (o LambdaOutput) Description() pulumi.StringPtrOutput

Description of th service

func (LambdaOutput) ElementType 

func (LambdaOutput) ElementType() reflect.Type

func (LambdaOutput) Name 

func (o LambdaOutput) Name() pulumi.StringOutput

Name of the service

func (LambdaOutput) ToLambdaOutput 

func (o LambdaOutput) ToLambdaOutput() LambdaOutput

func (LambdaOutput) ToLambdaOutputWithContext 

func (o LambdaOutput) ToLambdaOutputWithContext(ctx context.Context) LambdaOutput

func (LambdaOutput) Variables 

func (o LambdaOutput) Variables() LambdaVariableArrayOutput

Variables to be used in the service

type LambdaState 

type LambdaState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables LambdaVariableArrayInput
}

func (LambdaState) ElementType 

func (LambdaState) ElementType() reflect.Type

type LambdaVariable 

type LambdaVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type LambdaVariableArgs 

type LambdaVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (LambdaVariableArgs) ElementType 

func (LambdaVariableArgs) ElementType() reflect.Type

func (LambdaVariableArgs) ToLambdaVariableOutput 

func (i LambdaVariableArgs) ToLambdaVariableOutput() LambdaVariableOutput

func (LambdaVariableArgs) ToLambdaVariableOutputWithContext 

func (i LambdaVariableArgs) ToLambdaVariableOutputWithContext(ctx context.Context) LambdaVariableOutput

type LambdaVariableArray 

type LambdaVariableArray []LambdaVariableInput

func (LambdaVariableArray) ElementType 

func (LambdaVariableArray) ElementType() reflect.Type

func (LambdaVariableArray) ToLambdaVariableArrayOutput 

func (i LambdaVariableArray) ToLambdaVariableArrayOutput() LambdaVariableArrayOutput

func (LambdaVariableArray) ToLambdaVariableArrayOutputWithContext 

func (i LambdaVariableArray) ToLambdaVariableArrayOutputWithContext(ctx context.Context) LambdaVariableArrayOutput

type LambdaVariableArrayInput 

type LambdaVariableArrayInput interface {
	pulumi.Input

	ToLambdaVariableArrayOutput() LambdaVariableArrayOutput
	ToLambdaVariableArrayOutputWithContext(context.Context) LambdaVariableArrayOutput
}

LambdaVariableArrayInput is an input type that accepts LambdaVariableArray and LambdaVariableArrayOutput values. You can construct a concrete instance of `LambdaVariableArrayInput` via: 

LambdaVariableArray{ LambdaVariableArgs{...} }

type LambdaVariableArrayOutput 

type LambdaVariableArrayOutput struct{ *pulumi.OutputState }

func (LambdaVariableArrayOutput) ElementType 

func (LambdaVariableArrayOutput) ElementType() reflect.Type

func (LambdaVariableArrayOutput) Index 

func (o LambdaVariableArrayOutput) Index(i pulumi.IntInput) LambdaVariableOutput

func (LambdaVariableArrayOutput) ToLambdaVariableArrayOutput 

func (o LambdaVariableArrayOutput) ToLambdaVariableArrayOutput() LambdaVariableArrayOutput

func (LambdaVariableArrayOutput) ToLambdaVariableArrayOutputWithContext 

func (o LambdaVariableArrayOutput) ToLambdaVariableArrayOutputWithContext(ctx context.Context) LambdaVariableArrayOutput

type LambdaVariableInput 

type LambdaVariableInput interface {
	pulumi.Input

	ToLambdaVariableOutput() LambdaVariableOutput
	ToLambdaVariableOutputWithContext(context.Context) LambdaVariableOutput
}

LambdaVariableInput is an input type that accepts LambdaVariableArgs and LambdaVariableOutput values. You can construct a concrete instance of `LambdaVariableInput` via: 

LambdaVariableArgs{...}

type LambdaVariableOutput 

type LambdaVariableOutput struct{ *pulumi.OutputState }

func (LambdaVariableOutput) ElementType 

func (LambdaVariableOutput) ElementType() reflect.Type

func (LambdaVariableOutput) Name 

func (o LambdaVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (LambdaVariableOutput) ToLambdaVariableOutput 

func (o LambdaVariableOutput) ToLambdaVariableOutput() LambdaVariableOutput

func (LambdaVariableOutput) ToLambdaVariableOutputWithContext 

func (o LambdaVariableOutput) ToLambdaVariableOutputWithContext(ctx context.Context) LambdaVariableOutput

func (LambdaVariableOutput) Type 

func (o LambdaVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (LambdaVariableOutput) Value 

func (o LambdaVariableOutput) Value() pulumi.StringOutput

Value of the variable

type Ssh 

type Ssh struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// The type of artifact to deploy.
	ArtifactType pulumi.StringOutput `pulumi:"artifactType"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables SshVariableArrayOutput `pulumi:"variables"`
}

Resource for creating an SSH service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewSsh(ctx, "exampleSsh", &service.SshArgs{
			AppId:        exampleApplication.ID(),
			ArtifactType: pulumi.String("TAR"),
			Description:  pulumi.String("Service for deploying applications with SSH."),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/ssh:Ssh example <app_id>/<svc_id>

```

func GetSsh 

func GetSsh(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *SshState, opts ...pulumi.ResourceOption) (*Ssh, error)

GetSsh gets an existing Ssh 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 NewSsh 

func NewSsh(ctx *pulumi.Context,
	name string, args *SshArgs, opts ...pulumi.ResourceOption) (*Ssh, error)

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

func (*Ssh) ElementType 

func (*Ssh) ElementType() reflect.Type

func (*Ssh) ToSshOutput 

func (i *Ssh) ToSshOutput() SshOutput

func (*Ssh) ToSshOutputWithContext 

func (i *Ssh) ToSshOutputWithContext(ctx context.Context) SshOutput

type SshArgs 

type SshArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// The type of artifact to deploy.
	ArtifactType pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables SshVariableArrayInput
}

The set of arguments for constructing a Ssh resource.

func (SshArgs) ElementType 

func (SshArgs) ElementType() reflect.Type

type SshArray 

type SshArray []SshInput

func (SshArray) ElementType 

func (SshArray) ElementType() reflect.Type

func (SshArray) ToSshArrayOutput 

func (i SshArray) ToSshArrayOutput() SshArrayOutput

func (SshArray) ToSshArrayOutputWithContext 

func (i SshArray) ToSshArrayOutputWithContext(ctx context.Context) SshArrayOutput

type SshArrayInput 

type SshArrayInput interface {
	pulumi.Input

	ToSshArrayOutput() SshArrayOutput
	ToSshArrayOutputWithContext(context.Context) SshArrayOutput
}

SshArrayInput is an input type that accepts SshArray and SshArrayOutput values. You can construct a concrete instance of `SshArrayInput` via: 

SshArray{ SshArgs{...} }

type SshArrayOutput 

type SshArrayOutput struct{ *pulumi.OutputState }

func (SshArrayOutput) ElementType 

func (SshArrayOutput) ElementType() reflect.Type

func (SshArrayOutput) Index 

func (o SshArrayOutput) Index(i pulumi.IntInput) SshOutput

func (SshArrayOutput) ToSshArrayOutput 

func (o SshArrayOutput) ToSshArrayOutput() SshArrayOutput

func (SshArrayOutput) ToSshArrayOutputWithContext 

func (o SshArrayOutput) ToSshArrayOutputWithContext(ctx context.Context) SshArrayOutput

type SshInput 

type SshInput interface {
	pulumi.Input

	ToSshOutput() SshOutput
	ToSshOutputWithContext(ctx context.Context) SshOutput
}

type SshMap 

type SshMap map[string]SshInput

func (SshMap) ElementType 

func (SshMap) ElementType() reflect.Type

func (SshMap) ToSshMapOutput 

func (i SshMap) ToSshMapOutput() SshMapOutput

func (SshMap) ToSshMapOutputWithContext 

func (i SshMap) ToSshMapOutputWithContext(ctx context.Context) SshMapOutput

type SshMapInput 

type SshMapInput interface {
	pulumi.Input

	ToSshMapOutput() SshMapOutput
	ToSshMapOutputWithContext(context.Context) SshMapOutput
}

SshMapInput is an input type that accepts SshMap and SshMapOutput values. You can construct a concrete instance of `SshMapInput` via: 

SshMap{ "key": SshArgs{...} }

type SshMapOutput 

type SshMapOutput struct{ *pulumi.OutputState }

func (SshMapOutput) ElementType 

func (SshMapOutput) ElementType() reflect.Type

func (SshMapOutput) MapIndex 

func (o SshMapOutput) MapIndex(k pulumi.StringInput) SshOutput

func (SshMapOutput) ToSshMapOutput 

func (o SshMapOutput) ToSshMapOutput() SshMapOutput

func (SshMapOutput) ToSshMapOutputWithContext 

func (o SshMapOutput) ToSshMapOutputWithContext(ctx context.Context) SshMapOutput

type SshOutput 

type SshOutput struct{ *pulumi.OutputState }

func (SshOutput) AppId 

func (o SshOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (SshOutput) ArtifactType 

func (o SshOutput) ArtifactType() pulumi.StringOutput

The type of artifact to deploy.

func (SshOutput) Description 

func (o SshOutput) Description() pulumi.StringPtrOutput

Description of th service

func (SshOutput) ElementType 

func (SshOutput) ElementType() reflect.Type

func (SshOutput) Name 

func (o SshOutput) Name() pulumi.StringOutput

Name of the service

func (SshOutput) ToSshOutput 

func (o SshOutput) ToSshOutput() SshOutput

func (SshOutput) ToSshOutputWithContext 

func (o SshOutput) ToSshOutputWithContext(ctx context.Context) SshOutput

func (SshOutput) Variables 

func (o SshOutput) Variables() SshVariableArrayOutput

Variables to be used in the service

type SshState 

type SshState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// The type of artifact to deploy.
	ArtifactType pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables SshVariableArrayInput
}

func (SshState) ElementType 

func (SshState) ElementType() reflect.Type

type SshVariable 

type SshVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type SshVariableArgs 

type SshVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (SshVariableArgs) ElementType 

func (SshVariableArgs) ElementType() reflect.Type

func (SshVariableArgs) ToSshVariableOutput 

func (i SshVariableArgs) ToSshVariableOutput() SshVariableOutput

func (SshVariableArgs) ToSshVariableOutputWithContext 

func (i SshVariableArgs) ToSshVariableOutputWithContext(ctx context.Context) SshVariableOutput

type SshVariableArray 

type SshVariableArray []SshVariableInput

func (SshVariableArray) ElementType 

func (SshVariableArray) ElementType() reflect.Type

func (SshVariableArray) ToSshVariableArrayOutput 

func (i SshVariableArray) ToSshVariableArrayOutput() SshVariableArrayOutput

func (SshVariableArray) ToSshVariableArrayOutputWithContext 

func (i SshVariableArray) ToSshVariableArrayOutputWithContext(ctx context.Context) SshVariableArrayOutput

type SshVariableArrayInput 

type SshVariableArrayInput interface {
	pulumi.Input

	ToSshVariableArrayOutput() SshVariableArrayOutput
	ToSshVariableArrayOutputWithContext(context.Context) SshVariableArrayOutput
}

SshVariableArrayInput is an input type that accepts SshVariableArray and SshVariableArrayOutput values. You can construct a concrete instance of `SshVariableArrayInput` via: 

SshVariableArray{ SshVariableArgs{...} }

type SshVariableArrayOutput 

type SshVariableArrayOutput struct{ *pulumi.OutputState }

func (SshVariableArrayOutput) ElementType 

func (SshVariableArrayOutput) ElementType() reflect.Type

func (SshVariableArrayOutput) Index 

func (o SshVariableArrayOutput) Index(i pulumi.IntInput) SshVariableOutput

func (SshVariableArrayOutput) ToSshVariableArrayOutput 

func (o SshVariableArrayOutput) ToSshVariableArrayOutput() SshVariableArrayOutput

func (SshVariableArrayOutput) ToSshVariableArrayOutputWithContext 

func (o SshVariableArrayOutput) ToSshVariableArrayOutputWithContext(ctx context.Context) SshVariableArrayOutput

type SshVariableInput 

type SshVariableInput interface {
	pulumi.Input

	ToSshVariableOutput() SshVariableOutput
	ToSshVariableOutputWithContext(context.Context) SshVariableOutput
}

SshVariableInput is an input type that accepts SshVariableArgs and SshVariableOutput values. You can construct a concrete instance of `SshVariableInput` via: 

SshVariableArgs{...}

type SshVariableOutput 

type SshVariableOutput struct{ *pulumi.OutputState }

func (SshVariableOutput) ElementType 

func (SshVariableOutput) ElementType() reflect.Type

func (SshVariableOutput) Name 

func (o SshVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (SshVariableOutput) ToSshVariableOutput 

func (o SshVariableOutput) ToSshVariableOutput() SshVariableOutput

func (SshVariableOutput) ToSshVariableOutputWithContext 

func (o SshVariableOutput) ToSshVariableOutputWithContext(ctx context.Context) SshVariableOutput

func (SshVariableOutput) Type 

func (o SshVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (SshVariableOutput) Value 

func (o SshVariableOutput) Value() pulumi.StringOutput

Value of the variable

type Tanzu 

type Tanzu struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables TanzuVariableArrayOutput `pulumi:"variables"`
}

Resource for creating a Tanzu (PCF) service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewTanzu(ctx, "exampleTanzu", &service.TanzuArgs{
			AppId:       exampleApplication.ID(),
			Description: pulumi.String("A service for deploying Tanzu applications."),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/tanzu:Tanzu example <app_id>/<svc_id>

```

func GetTanzu 

func GetTanzu(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TanzuState, opts ...pulumi.ResourceOption) (*Tanzu, error)

GetTanzu gets an existing Tanzu 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 NewTanzu 

func NewTanzu(ctx *pulumi.Context,
	name string, args *TanzuArgs, opts ...pulumi.ResourceOption) (*Tanzu, error)

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

func (*Tanzu) ElementType 

func (*Tanzu) ElementType() reflect.Type

func (*Tanzu) ToTanzuOutput 

func (i *Tanzu) ToTanzuOutput() TanzuOutput

func (*Tanzu) ToTanzuOutputWithContext 

func (i *Tanzu) ToTanzuOutputWithContext(ctx context.Context) TanzuOutput

type TanzuArgs 

type TanzuArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables TanzuVariableArrayInput
}

The set of arguments for constructing a Tanzu resource.

func (TanzuArgs) ElementType 

func (TanzuArgs) ElementType() reflect.Type

type TanzuArray 

type TanzuArray []TanzuInput

func (TanzuArray) ElementType 

func (TanzuArray) ElementType() reflect.Type

func (TanzuArray) ToTanzuArrayOutput 

func (i TanzuArray) ToTanzuArrayOutput() TanzuArrayOutput

func (TanzuArray) ToTanzuArrayOutputWithContext 

func (i TanzuArray) ToTanzuArrayOutputWithContext(ctx context.Context) TanzuArrayOutput

type TanzuArrayInput 

type TanzuArrayInput interface {
	pulumi.Input

	ToTanzuArrayOutput() TanzuArrayOutput
	ToTanzuArrayOutputWithContext(context.Context) TanzuArrayOutput
}

TanzuArrayInput is an input type that accepts TanzuArray and TanzuArrayOutput values. You can construct a concrete instance of `TanzuArrayInput` via: 

TanzuArray{ TanzuArgs{...} }

type TanzuArrayOutput 

type TanzuArrayOutput struct{ *pulumi.OutputState }

func (TanzuArrayOutput) ElementType 

func (TanzuArrayOutput) ElementType() reflect.Type

func (TanzuArrayOutput) Index 

func (o TanzuArrayOutput) Index(i pulumi.IntInput) TanzuOutput

func (TanzuArrayOutput) ToTanzuArrayOutput 

func (o TanzuArrayOutput) ToTanzuArrayOutput() TanzuArrayOutput

func (TanzuArrayOutput) ToTanzuArrayOutputWithContext 

func (o TanzuArrayOutput) ToTanzuArrayOutputWithContext(ctx context.Context) TanzuArrayOutput

type TanzuInput 

type TanzuInput interface {
	pulumi.Input

	ToTanzuOutput() TanzuOutput
	ToTanzuOutputWithContext(ctx context.Context) TanzuOutput
}

type TanzuMap 

type TanzuMap map[string]TanzuInput

func (TanzuMap) ElementType 

func (TanzuMap) ElementType() reflect.Type

func (TanzuMap) ToTanzuMapOutput 

func (i TanzuMap) ToTanzuMapOutput() TanzuMapOutput

func (TanzuMap) ToTanzuMapOutputWithContext 

func (i TanzuMap) ToTanzuMapOutputWithContext(ctx context.Context) TanzuMapOutput

type TanzuMapInput 

type TanzuMapInput interface {
	pulumi.Input

	ToTanzuMapOutput() TanzuMapOutput
	ToTanzuMapOutputWithContext(context.Context) TanzuMapOutput
}

TanzuMapInput is an input type that accepts TanzuMap and TanzuMapOutput values. You can construct a concrete instance of `TanzuMapInput` via: 

TanzuMap{ "key": TanzuArgs{...} }

type TanzuMapOutput 

type TanzuMapOutput struct{ *pulumi.OutputState }

func (TanzuMapOutput) ElementType 

func (TanzuMapOutput) ElementType() reflect.Type

func (TanzuMapOutput) MapIndex 

func (o TanzuMapOutput) MapIndex(k pulumi.StringInput) TanzuOutput

func (TanzuMapOutput) ToTanzuMapOutput 

func (o TanzuMapOutput) ToTanzuMapOutput() TanzuMapOutput

func (TanzuMapOutput) ToTanzuMapOutputWithContext 

func (o TanzuMapOutput) ToTanzuMapOutputWithContext(ctx context.Context) TanzuMapOutput

type TanzuOutput 

type TanzuOutput struct{ *pulumi.OutputState }

func (TanzuOutput) AppId 

func (o TanzuOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (TanzuOutput) Description 

func (o TanzuOutput) Description() pulumi.StringPtrOutput

Description of th service

func (TanzuOutput) ElementType 

func (TanzuOutput) ElementType() reflect.Type

func (TanzuOutput) Name 

func (o TanzuOutput) Name() pulumi.StringOutput

Name of the service

func (TanzuOutput) ToTanzuOutput 

func (o TanzuOutput) ToTanzuOutput() TanzuOutput

func (TanzuOutput) ToTanzuOutputWithContext 

func (o TanzuOutput) ToTanzuOutputWithContext(ctx context.Context) TanzuOutput

func (TanzuOutput) Variables 

func (o TanzuOutput) Variables() TanzuVariableArrayOutput

Variables to be used in the service

type TanzuState 

type TanzuState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables TanzuVariableArrayInput
}

func (TanzuState) ElementType 

func (TanzuState) ElementType() reflect.Type

type TanzuVariable 

type TanzuVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type TanzuVariableArgs 

type TanzuVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (TanzuVariableArgs) ElementType 

func (TanzuVariableArgs) ElementType() reflect.Type

func (TanzuVariableArgs) ToTanzuVariableOutput 

func (i TanzuVariableArgs) ToTanzuVariableOutput() TanzuVariableOutput

func (TanzuVariableArgs) ToTanzuVariableOutputWithContext 

func (i TanzuVariableArgs) ToTanzuVariableOutputWithContext(ctx context.Context) TanzuVariableOutput

type TanzuVariableArray 

type TanzuVariableArray []TanzuVariableInput

func (TanzuVariableArray) ElementType 

func (TanzuVariableArray) ElementType() reflect.Type

func (TanzuVariableArray) ToTanzuVariableArrayOutput 

func (i TanzuVariableArray) ToTanzuVariableArrayOutput() TanzuVariableArrayOutput

func (TanzuVariableArray) ToTanzuVariableArrayOutputWithContext 

func (i TanzuVariableArray) ToTanzuVariableArrayOutputWithContext(ctx context.Context) TanzuVariableArrayOutput

type TanzuVariableArrayInput 

type TanzuVariableArrayInput interface {
	pulumi.Input

	ToTanzuVariableArrayOutput() TanzuVariableArrayOutput
	ToTanzuVariableArrayOutputWithContext(context.Context) TanzuVariableArrayOutput
}

TanzuVariableArrayInput is an input type that accepts TanzuVariableArray and TanzuVariableArrayOutput values. You can construct a concrete instance of `TanzuVariableArrayInput` via: 

TanzuVariableArray{ TanzuVariableArgs{...} }

type TanzuVariableArrayOutput 

type TanzuVariableArrayOutput struct{ *pulumi.OutputState }

func (TanzuVariableArrayOutput) ElementType 

func (TanzuVariableArrayOutput) ElementType() reflect.Type

func (TanzuVariableArrayOutput) Index 

func (o TanzuVariableArrayOutput) Index(i pulumi.IntInput) TanzuVariableOutput

func (TanzuVariableArrayOutput) ToTanzuVariableArrayOutput 

func (o TanzuVariableArrayOutput) ToTanzuVariableArrayOutput() TanzuVariableArrayOutput

func (TanzuVariableArrayOutput) ToTanzuVariableArrayOutputWithContext 

func (o TanzuVariableArrayOutput) ToTanzuVariableArrayOutputWithContext(ctx context.Context) TanzuVariableArrayOutput

type TanzuVariableInput 

type TanzuVariableInput interface {
	pulumi.Input

	ToTanzuVariableOutput() TanzuVariableOutput
	ToTanzuVariableOutputWithContext(context.Context) TanzuVariableOutput
}

TanzuVariableInput is an input type that accepts TanzuVariableArgs and TanzuVariableOutput values. You can construct a concrete instance of `TanzuVariableInput` via: 

TanzuVariableArgs{...}

type TanzuVariableOutput 

type TanzuVariableOutput struct{ *pulumi.OutputState }

func (TanzuVariableOutput) ElementType 

func (TanzuVariableOutput) ElementType() reflect.Type

func (TanzuVariableOutput) Name 

func (o TanzuVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (TanzuVariableOutput) ToTanzuVariableOutput 

func (o TanzuVariableOutput) ToTanzuVariableOutput() TanzuVariableOutput

func (TanzuVariableOutput) ToTanzuVariableOutputWithContext 

func (o TanzuVariableOutput) ToTanzuVariableOutputWithContext(ctx context.Context) TanzuVariableOutput

func (TanzuVariableOutput) Type 

func (o TanzuVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (TanzuVariableOutput) Value 

func (o TanzuVariableOutput) Value() pulumi.StringOutput

Value of the variable

type Winrm 

type Winrm struct {
	pulumi.CustomResourceState

	// The id of the application the service belongs to
	AppId pulumi.StringOutput `pulumi:"appId"`
	// The type of artifact to deploy.
	ArtifactType pulumi.StringOutput `pulumi:"artifactType"`
	// Description of th service
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Name of the service
	Name pulumi.StringOutput `pulumi:"name"`
	// Variables to be used in the service
	Variables WinrmVariableArrayOutput `pulumi:"variables"`
}

Resource for creating an WinRM service. This resource uses the config-as-code API's. When updating the `name` or `path` of this resource you should typically also set the `createBeforeDestroy = true` lifecycle setting.

## Example Usage

```go package main

import ( 

"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
"github.com/lbrlabs/pulumi-harness/sdk/go/harness/service"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleApplication, err := harness.NewApplication(ctx, "exampleApplication", nil)
		if err != nil {
			return err
		}
		_, err = service.NewWinrm(ctx, "exampleWinrm", &service.WinrmArgs{
			AppId:        exampleApplication.ID(),
			ArtifactType: pulumi.String("IIS_APP"),
			Description:  pulumi.String("Service for deploying IIS appliactions using winrm."),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Import using the Harness application id and service id

```sh 

$ pulumi import harness:service/winrm:Winrm example <app_id>/<svc_id>

```

func GetWinrm 

func GetWinrm(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *WinrmState, opts ...pulumi.ResourceOption) (*Winrm, error)

GetWinrm gets an existing Winrm 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 NewWinrm 

func NewWinrm(ctx *pulumi.Context,
	name string, args *WinrmArgs, opts ...pulumi.ResourceOption) (*Winrm, error)

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

func (*Winrm) ElementType 

func (*Winrm) ElementType() reflect.Type

func (*Winrm) ToWinrmOutput 

func (i *Winrm) ToWinrmOutput() WinrmOutput

func (*Winrm) ToWinrmOutputWithContext 

func (i *Winrm) ToWinrmOutputWithContext(ctx context.Context) WinrmOutput

type WinrmArgs 

type WinrmArgs struct {
	// The id of the application the service belongs to
	AppId pulumi.StringInput
	// The type of artifact to deploy.
	ArtifactType pulumi.StringInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables WinrmVariableArrayInput
}

The set of arguments for constructing a Winrm resource.

func (WinrmArgs) ElementType 

func (WinrmArgs) ElementType() reflect.Type

type WinrmArray 

type WinrmArray []WinrmInput

func (WinrmArray) ElementType 

func (WinrmArray) ElementType() reflect.Type

func (WinrmArray) ToWinrmArrayOutput 

func (i WinrmArray) ToWinrmArrayOutput() WinrmArrayOutput

func (WinrmArray) ToWinrmArrayOutputWithContext 

func (i WinrmArray) ToWinrmArrayOutputWithContext(ctx context.Context) WinrmArrayOutput

type WinrmArrayInput 

type WinrmArrayInput interface {
	pulumi.Input

	ToWinrmArrayOutput() WinrmArrayOutput
	ToWinrmArrayOutputWithContext(context.Context) WinrmArrayOutput
}

WinrmArrayInput is an input type that accepts WinrmArray and WinrmArrayOutput values. You can construct a concrete instance of `WinrmArrayInput` via: 

WinrmArray{ WinrmArgs{...} }

type WinrmArrayOutput 

type WinrmArrayOutput struct{ *pulumi.OutputState }

func (WinrmArrayOutput) ElementType 

func (WinrmArrayOutput) ElementType() reflect.Type

func (WinrmArrayOutput) Index 

func (o WinrmArrayOutput) Index(i pulumi.IntInput) WinrmOutput

func (WinrmArrayOutput) ToWinrmArrayOutput 

func (o WinrmArrayOutput) ToWinrmArrayOutput() WinrmArrayOutput

func (WinrmArrayOutput) ToWinrmArrayOutputWithContext 

func (o WinrmArrayOutput) ToWinrmArrayOutputWithContext(ctx context.Context) WinrmArrayOutput

type WinrmInput 

type WinrmInput interface {
	pulumi.Input

	ToWinrmOutput() WinrmOutput
	ToWinrmOutputWithContext(ctx context.Context) WinrmOutput
}

type WinrmMap 

type WinrmMap map[string]WinrmInput

func (WinrmMap) ElementType 

func (WinrmMap) ElementType() reflect.Type

func (WinrmMap) ToWinrmMapOutput 

func (i WinrmMap) ToWinrmMapOutput() WinrmMapOutput

func (WinrmMap) ToWinrmMapOutputWithContext 

func (i WinrmMap) ToWinrmMapOutputWithContext(ctx context.Context) WinrmMapOutput

type WinrmMapInput 

type WinrmMapInput interface {
	pulumi.Input

	ToWinrmMapOutput() WinrmMapOutput
	ToWinrmMapOutputWithContext(context.Context) WinrmMapOutput
}

WinrmMapInput is an input type that accepts WinrmMap and WinrmMapOutput values. You can construct a concrete instance of `WinrmMapInput` via: 

WinrmMap{ "key": WinrmArgs{...} }

type WinrmMapOutput 

type WinrmMapOutput struct{ *pulumi.OutputState }

func (WinrmMapOutput) ElementType 

func (WinrmMapOutput) ElementType() reflect.Type

func (WinrmMapOutput) MapIndex 

func (o WinrmMapOutput) MapIndex(k pulumi.StringInput) WinrmOutput

func (WinrmMapOutput) ToWinrmMapOutput 

func (o WinrmMapOutput) ToWinrmMapOutput() WinrmMapOutput

func (WinrmMapOutput) ToWinrmMapOutputWithContext 

func (o WinrmMapOutput) ToWinrmMapOutputWithContext(ctx context.Context) WinrmMapOutput

type WinrmOutput 

type WinrmOutput struct{ *pulumi.OutputState }

func (WinrmOutput) AppId 

func (o WinrmOutput) AppId() pulumi.StringOutput

The id of the application the service belongs to

func (WinrmOutput) ArtifactType 

func (o WinrmOutput) ArtifactType() pulumi.StringOutput

The type of artifact to deploy.

func (WinrmOutput) Description 

func (o WinrmOutput) Description() pulumi.StringPtrOutput

Description of th service

func (WinrmOutput) ElementType 

func (WinrmOutput) ElementType() reflect.Type

func (WinrmOutput) Name 

func (o WinrmOutput) Name() pulumi.StringOutput

Name of the service

func (WinrmOutput) ToWinrmOutput 

func (o WinrmOutput) ToWinrmOutput() WinrmOutput

func (WinrmOutput) ToWinrmOutputWithContext 

func (o WinrmOutput) ToWinrmOutputWithContext(ctx context.Context) WinrmOutput

func (WinrmOutput) Variables 

func (o WinrmOutput) Variables() WinrmVariableArrayOutput

Variables to be used in the service

type WinrmState 

type WinrmState struct {
	// The id of the application the service belongs to
	AppId pulumi.StringPtrInput
	// The type of artifact to deploy.
	ArtifactType pulumi.StringPtrInput
	// Description of th service
	Description pulumi.StringPtrInput
	// Name of the service
	Name pulumi.StringPtrInput
	// Variables to be used in the service
	Variables WinrmVariableArrayInput
}

func (WinrmState) ElementType 

func (WinrmState) ElementType() reflect.Type

type WinrmVariable 

type WinrmVariable struct {
	// Name of the variable
	Name string `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type string `pulumi:"type"`
	// Value of the variable
	Value string `pulumi:"value"`
}

type WinrmVariableArgs 

type WinrmVariableArgs struct {
	// Name of the variable
	Name pulumi.StringInput `pulumi:"name"`
	// Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'
	Type pulumi.StringInput `pulumi:"type"`
	// Value of the variable
	Value pulumi.StringInput `pulumi:"value"`
}

func (WinrmVariableArgs) ElementType 

func (WinrmVariableArgs) ElementType() reflect.Type

func (WinrmVariableArgs) ToWinrmVariableOutput 

func (i WinrmVariableArgs) ToWinrmVariableOutput() WinrmVariableOutput

func (WinrmVariableArgs) ToWinrmVariableOutputWithContext 

func (i WinrmVariableArgs) ToWinrmVariableOutputWithContext(ctx context.Context) WinrmVariableOutput

type WinrmVariableArray 

type WinrmVariableArray []WinrmVariableInput

func (WinrmVariableArray) ElementType 

func (WinrmVariableArray) ElementType() reflect.Type

func (WinrmVariableArray) ToWinrmVariableArrayOutput 

func (i WinrmVariableArray) ToWinrmVariableArrayOutput() WinrmVariableArrayOutput

func (WinrmVariableArray) ToWinrmVariableArrayOutputWithContext 

func (i WinrmVariableArray) ToWinrmVariableArrayOutputWithContext(ctx context.Context) WinrmVariableArrayOutput

type WinrmVariableArrayInput 

type WinrmVariableArrayInput interface {
	pulumi.Input

	ToWinrmVariableArrayOutput() WinrmVariableArrayOutput
	ToWinrmVariableArrayOutputWithContext(context.Context) WinrmVariableArrayOutput
}

WinrmVariableArrayInput is an input type that accepts WinrmVariableArray and WinrmVariableArrayOutput values. You can construct a concrete instance of `WinrmVariableArrayInput` via: 

WinrmVariableArray{ WinrmVariableArgs{...} }

type WinrmVariableArrayOutput 

type WinrmVariableArrayOutput struct{ *pulumi.OutputState }

func (WinrmVariableArrayOutput) ElementType 

func (WinrmVariableArrayOutput) ElementType() reflect.Type

func (WinrmVariableArrayOutput) Index 

func (o WinrmVariableArrayOutput) Index(i pulumi.IntInput) WinrmVariableOutput

func (WinrmVariableArrayOutput) ToWinrmVariableArrayOutput 

func (o WinrmVariableArrayOutput) ToWinrmVariableArrayOutput() WinrmVariableArrayOutput

func (WinrmVariableArrayOutput) ToWinrmVariableArrayOutputWithContext 

func (o WinrmVariableArrayOutput) ToWinrmVariableArrayOutputWithContext(ctx context.Context) WinrmVariableArrayOutput

type WinrmVariableInput 

type WinrmVariableInput interface {
	pulumi.Input

	ToWinrmVariableOutput() WinrmVariableOutput
	ToWinrmVariableOutputWithContext(context.Context) WinrmVariableOutput
}

WinrmVariableInput is an input type that accepts WinrmVariableArgs and WinrmVariableOutput values. You can construct a concrete instance of `WinrmVariableInput` via: 

WinrmVariableArgs{...}

type WinrmVariableOutput 

type WinrmVariableOutput struct{ *pulumi.OutputState }

func (WinrmVariableOutput) ElementType 

func (WinrmVariableOutput) ElementType() reflect.Type

func (WinrmVariableOutput) Name 

func (o WinrmVariableOutput) Name() pulumi.StringOutput

Name of the variable

func (WinrmVariableOutput) ToWinrmVariableOutput 

func (o WinrmVariableOutput) ToWinrmVariableOutput() WinrmVariableOutput

func (WinrmVariableOutput) ToWinrmVariableOutputWithContext 

func (o WinrmVariableOutput) ToWinrmVariableOutputWithContext(ctx context.Context) WinrmVariableOutput

func (WinrmVariableOutput) Type 

func (o WinrmVariableOutput) Type() pulumi.StringOutput

Type of the variable. Options are 'TEXT' and 'ENCRYPTED_TEXT'

func (WinrmVariableOutput) Value 

func (o WinrmVariableOutput) Value() pulumi.StringOutput

Value of the variable

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.