pulumi-aws-kotlin/com.pulumi.aws.worklink.kotlin/Fleet

Fleet

class Fleet : KotlinCustomResource

Example Usage

Basic usage:

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.worklink.Fleet("example", {name: "example"});

import pulumi
import pulumi_aws as aws
example = aws.worklink.Fleet("example", name="example")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.WorkLink.Fleet("example", new()
    {
        Name = "example",
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/worklink"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := worklink.NewFleet(ctx, "example", &worklink.FleetArgs{
			Name: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.worklink.Fleet;
import com.pulumi.aws.worklink.FleetArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Fleet("example", FleetArgs.builder()
            .name("example")
            .build());
    }
}

resources:
  example:
    type: aws:worklink:Fleet
    properties:
      name: example

Network Configuration Usage:

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.worklink.Fleet("example", {
    name: "example",
    network: {
        vpcId: testAwsVpc.id,
        subnetIds: [testAwsSubnet&#46;map(__item => __item&#46;id)],
        securityGroupIds: [test&#46;id],
    },
});

import pulumi
import pulumi_aws as aws
example = aws.worklink.Fleet("example",
    name="example",
    network=aws.worklink.FleetNetworkArgs(
        vpc_id=test_aws_vpc["id"],
        subnet_ids=[[__item["id"] for __item in test_aws_subnet]],
        security_group_ids=[test["id"]],
    ))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.WorkLink.Fleet("example", new()
    {
        Name = "example",
        Network = new Aws.WorkLink.Inputs.FleetNetworkArgs
        {
            VpcId = testAwsVpc.Id,
            SubnetIds = new[]
            {
                testAwsSubnet.Select(__item => __item.Id).ToList(),
            },
            SecurityGroupIds = new[]
            {
                test.Id,
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/worklink"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := worklink.NewFleet(ctx, "example", &worklink.FleetArgs{
Name: pulumi.String("example"),
Network: &worklink.FleetNetworkArgs{
VpcId: pulumi.Any(testAwsVpc.Id),
SubnetIds: pulumi.StringArray{
%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:4,25-44),
},
SecurityGroupIds: pulumi.StringArray{
test.Id,
},
},
})
if err != nil {
return err
}
return nil
})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.worklink.Fleet;
import com.pulumi.aws.worklink.FleetArgs;
import com.pulumi.aws.worklink.inputs.FleetNetworkArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Fleet("example", FleetArgs.builder()
            .name("example")
            .network(FleetNetworkArgs.builder()
                .vpcId(testAwsVpc.id())
                .subnetIds(testAwsSubnet.stream().map(element -> element.id()).collect(toList()))
                .securityGroupIds(test.id())
                .build())
            .build());
    }
}

Identity Provider Configuration Usage:

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as std from "@pulumi/std";
const test = new aws.worklink.Fleet("test", {
    name: "tf-worklink-fleet",
    identityProvider: {
        type: "SAML",
        samlMetadata: std.file({
            input: "saml-metadata.xml",
        }).then(invoke => invoke.result),
    },
});

import pulumi
import pulumi_aws as aws
import pulumi_std as std
test = aws.worklink.Fleet("test",
    name="tf-worklink-fleet",
    identity_provider=aws.worklink.FleetIdentityProviderArgs(
        type="SAML",
        saml_metadata=std.file(input="saml-metadata.xml").result,
    ))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var test = new Aws.WorkLink.Fleet("test", new()
    {
        Name = "tf-worklink-fleet",
        IdentityProvider = new Aws.WorkLink.Inputs.FleetIdentityProviderArgs
        {
            Type = "SAML",
            SamlMetadata = Std.File.Invoke(new()
            {
                Input = "saml-metadata.xml",
            }).Apply(invoke => invoke.Result),
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/worklink"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "saml-metadata.xml",
		}, nil)
		if err != nil {
			return err
		}
		_, err = worklink.NewFleet(ctx, "test", &worklink.FleetArgs{
			Name: pulumi.String("tf-worklink-fleet"),
			IdentityProvider: &worklink.FleetIdentityProviderArgs{
				Type:         pulumi.String("SAML"),
				SamlMetadata: invokeFile.Result,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.worklink.Fleet;
import com.pulumi.aws.worklink.FleetArgs;
import com.pulumi.aws.worklink.inputs.FleetIdentityProviderArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var test = new Fleet("test", FleetArgs.builder()
            .name("tf-worklink-fleet")
            .identityProvider(FleetIdentityProviderArgs.builder()
                .type("SAML")
                .samlMetadata(StdFunctions.file(FileArgs.builder()
                    .input("saml-metadata.xml")
                    .build()).result())
                .build())
            .build());
    }
}

resources:
  test:
    type: aws:worklink:Fleet
    properties:
      name: tf-worklink-fleet
      identityProvider:
        type: SAML
        samlMetadata:
          fn::invoke:
            Function: std:file
            Arguments:
              input: saml-metadata.xml
            Return: result

Import

Using pulumi import, import WorkLink using the ARN. For example:

$ pulumi import aws:worklink/fleet:Fleet test arn:aws:worklink::123456789012:fleet/example

Properties

arn

val arn: Output<String>

The ARN of the created WorkLink Fleet.

auditStreamArn

val auditStreamArn: Output<String>?

The ARN of the Amazon Kinesis data stream that receives the audit events. Kinesis data stream name must begin with "AmazonWorkLink-".

companyCode

val companyCode: Output<String>

The identifier used by users to sign in to the Amazon WorkLink app.

createdTime

val createdTime: Output<String>

The time that the fleet was created.

deviceCaCertificate

val deviceCaCertificate: Output<String>?

The certificate chain, including intermediate certificates and the root certificate authority certificate used to issue device certificates.

displayName

val displayName: Output<String>?

The name of the fleet.

val id: Output<String>

identityProvider

val identityProvider: Output<FleetIdentityProvider>?

Provide this to allow manage the identity provider configuration for the fleet. Fields documented below.

lastUpdatedTime

val lastUpdatedTime: Output<String>

The time that the fleet was last updated.

name

val name: Output<String>

A region-unique name for the AMI.

network

val network: Output<FleetNetwork>?

Provide this to allow manage the company network configuration for the fleet. Fields documented below.

optimizeForEndUserLocation

val optimizeForEndUserLocation: Output<Boolean>?

The option to optimize for better performance by routing traffic through the closest AWS Region to users, which may be outside of your home Region. Defaults to true. network requires the following:

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

urn

val urn: Output<String>