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: 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
fun KeyPairArgs(name: Output<String>? = null, namePrefix: Output<String>? = null, pgpKey: Output<String>? = null, publicKey: Output<String>? = null, tags: Output<Map<String, String>>? = null)

Functions

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

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. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.