pulumi-aws-kotlin/com.pulumi.aws.lightsail.kotlin/KeyPairArgs

KeyPairArgs

data class KeyPairArgs(val name: Output<String>? = null, val namePrefix: Output<String>? = null, val pgpKey: Output<String>? = null, val publicKey: Output<String>? = null, val tags: Output<Map<String, String>>? = null) : ConvertibleToJava<KeyPairArgs>

Provides a Lightsail Key Pair, for use with Lightsail Instances. These key pairs are separate from EC2 Key Pairs, and must be created or imported for use with Lightsail.

Note: Lightsail is currently only supported in a limited number of AWS Regions, please see "Regions and Availability Zones in Amazon Lightsail" for more details

Example Usage

Create New Key Pair

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// Create a new Lightsail Key Pair
const lgKeyPair = new aws.lightsail.KeyPair("lg_key_pair", {name: "lg_key_pair"});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
# Create a new Lightsail Key Pair
lg_key_pair = aws.lightsail.KeyPair("lg_key_pair", name="lg_key_pair")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // Create a new Lightsail Key Pair
    var lgKeyPair = new Aws.LightSail.KeyPair("lg_key_pair", new()
    {
        Name = "lg_key_pair",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lightsail"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a new Lightsail Key Pair
		_, err := lightsail.NewKeyPair(ctx, "lg_key_pair", &lightsail.KeyPairArgs{
			Name: pulumi.String("lg_key_pair"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lightsail.KeyPair;
import com.pulumi.aws.lightsail.KeyPairArgs;
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) {
        // Create a new Lightsail Key Pair
        var lgKeyPair = new KeyPair("lgKeyPair", KeyPairArgs.builder()
            .name("lg_key_pair")
            .build());
    }
}
Content copied to clipboard
resources:
  # Create a new Lightsail Key Pair
  lgKeyPair:
    type: aws:lightsail:KeyPair
    name: lg_key_pair
    properties:
      name: lg_key_pair
Content copied to clipboard

Create New Key Pair with PGP Encrypted Private Key

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const lgKeyPair = new aws.lightsail.KeyPair("lg_key_pair", {
    name: "lg_key_pair",
    pgpKey: "keybase:keybaseusername",
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
lg_key_pair = aws.lightsail.KeyPair("lg_key_pair",
    name="lg_key_pair",
    pgp_key="keybase:keybaseusername")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var lgKeyPair = new Aws.LightSail.KeyPair("lg_key_pair", new()
    {
        Name = "lg_key_pair",
        PgpKey = "keybase:keybaseusername",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lightsail"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lightsail.NewKeyPair(ctx, "lg_key_pair", &lightsail.KeyPairArgs{
			Name:   pulumi.String("lg_key_pair"),
			PgpKey: pulumi.String("keybase:keybaseusername"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lightsail.KeyPair;
import com.pulumi.aws.lightsail.KeyPairArgs;
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 lgKeyPair = new KeyPair("lgKeyPair", KeyPairArgs.builder()
            .name("lg_key_pair")
            .pgpKey("keybase:keybaseusername")
            .build());
    }
}
Content copied to clipboard
resources:
  lgKeyPair:
    type: aws:lightsail:KeyPair
    name: lg_key_pair
    properties:
      name: lg_key_pair
      pgpKey: keybase:keybaseusername
Content copied to clipboard

Existing Public Key Import

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as std from "@pulumi/std";
const lgKeyPair = new aws.lightsail.KeyPair("lg_key_pair", {
    name: "importing",
    publicKey: std.file({
        input: "~/.ssh/id_rsa.pub",
    }).then(invoke => invoke.result),
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
import pulumi_std as std
lg_key_pair = aws.lightsail.KeyPair("lg_key_pair",
    name="importing",
    public_key=std.file(input="~/.ssh/id_rsa.pub").result)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var lgKeyPair = new Aws.LightSail.KeyPair("lg_key_pair", new()
    {
        Name = "importing",
        PublicKey = Std.File.Invoke(new()
        {
            Input = "~/.ssh/id_rsa.pub",
        }).Apply(invoke => invoke.Result),
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lightsail"
	"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: "~/.ssh/id_rsa.pub",
		}, nil)
		if err != nil {
			return err
		}
		_, err = lightsail.NewKeyPair(ctx, "lg_key_pair", &lightsail.KeyPairArgs{
			Name:      pulumi.String("importing"),
			PublicKey: pulumi.String(invokeFile.Result),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lightsail.KeyPair;
import com.pulumi.aws.lightsail.KeyPairArgs;
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 lgKeyPair = new KeyPair("lgKeyPair", KeyPairArgs.builder()
            .name("importing")
            .publicKey(StdFunctions.file(FileArgs.builder()
                .input("~/.ssh/id_rsa.pub")
                .build()).result())
            .build());
    }
}
Content copied to clipboard
resources:
  lgKeyPair:
    type: aws:lightsail:KeyPair
    name: lg_key_pair
    properties:
      name: importing
      publicKey:
        fn::invoke:
          function: std:file
          arguments:
            input: ~/.ssh/id_rsa.pub
          return: result
Content copied to clipboard

Import

You cannot import Lightsail Key Pairs because the private and public key are only available on initial creation.

Constructors

Link copied to clipboard
constructor(name: Output<String>? = null, namePrefix: Output<String>? = null, pgpKey: Output<String>? = null, publicKey: Output<String>? = null, tags: Output<Map<String, String>>? = null)

Properties

Link copied to clipboard
val name: Output<String>? = null

The name of the Lightsail Key Pair. If omitted, a unique name will be generated by this provider

Link copied to clipboard
val namePrefix: Output<String>? = null
Link copied to clipboard
val pgpKey: Output<String>? = null

An optional PGP key to encrypt the resulting private key material. Only used when creating a new key pair

Link copied to clipboard
val publicKey: Output<String>? = null

The public key material. This public key will be imported into Lightsail

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

A map of tags to assign to the collection. To create a key-only tag, use an empty string as the value. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Functions

Link copied to clipboard
open override fun toJava(): KeyPairArgs