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

KeyPair

class KeyPair : KotlinCustomResource

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.

Properties

Link copied to clipboard
val arn: Output<String>

The ARN of the Lightsail key pair.

Link copied to clipboard
val encryptedFingerprint: Output<String>

The MD5 public key fingerprint for the encrypted private key.

Link copied to clipboard
val encryptedPrivateKey: Output<String>

the private key material, base 64 encoded and encrypted with the given pgp_key. This is only populated when creating a new key and pgp_key is supplied.

Link copied to clipboard
val fingerprint: Output<String>

The MD5 public key fingerprint as specified in section 4 of RFC 4716.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val name: Output<String>

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>
Link copied to clipboard
val pgpKey: Output<String>?

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

Link copied to clipboard
val privateKey: Output<String>

the private key, base64 encoded. This is only populated when creating a new key, and when no pgp_key is provided.

Link copied to clipboard
val publicKey: Output<String>

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

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val tags: Output<Map<String, String>>?

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.

Link copied to clipboard
val tagsAll: Output<Map<String, String>>
Link copied to clipboard
val urn: Output<String>