scaleway.keymanager.Key

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

// Create an asymmetric encryption key with RSA-4096.
const rsa4096 = new scaleway.keymanager.Key("rsa_4096", {
    name: "rsa-4096-key",
    region: "fr-par",
    usage: "asymmetric_encryption",
    algorithm: "rsa_oaep_4096_sha256",
    description: "Key for encrypting large files with RSA-4096",
    unprotected: true,
});

import pulumi
import pulumiverse_scaleway as scaleway

# Create an asymmetric encryption key with RSA-4096.
rsa4096 = scaleway.keymanager.Key("rsa_4096",
    name="rsa-4096-key",
    region="fr-par",
    usage="asymmetric_encryption",
    algorithm="rsa_oaep_4096_sha256",
    description="Key for encrypting large files with RSA-4096",
    unprotected=True)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/keymanager"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create an asymmetric encryption key with RSA-4096.
		_, err := keymanager.NewKey(ctx, "rsa_4096", &keymanager.KeyArgs{
			Name:        pulumi.String("rsa-4096-key"),
			Region:      pulumi.String("fr-par"),
			Usage:       pulumi.String("asymmetric_encryption"),
			Algorithm:   pulumi.String("rsa_oaep_4096_sha256"),
			Description: pulumi.String("Key for encrypting large files with RSA-4096"),
			Unprotected: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    // Create an asymmetric encryption key with RSA-4096.
    var rsa4096 = new Scaleway.Keymanager.Key("rsa_4096", new()
    {
        Name = "rsa-4096-key",
        Region = "fr-par",
        Usage = "asymmetric_encryption",
        Algorithm = "rsa_oaep_4096_sha256",
        Description = "Key for encrypting large files with RSA-4096",
        Unprotected = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.keymanager.Key;
import com.pulumi.scaleway.keymanager.KeyArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 an asymmetric encryption key with RSA-4096.
        var rsa4096 = new Key("rsa4096", KeyArgs.builder()
            .name("rsa-4096-key")
            .region("fr-par")
            .usage("asymmetric_encryption")
            .algorithm("rsa_oaep_4096_sha256")
            .description("Key for encrypting large files with RSA-4096")
            .unprotected(true)
            .build());

    }
}

resources:
  # Create an asymmetric encryption key with RSA-4096.
  rsa4096:
    type: scaleway:keymanager:Key
    name: rsa_4096
    properties:
      name: rsa-4096-key
      region: fr-par
      usage: asymmetric_encryption
      algorithm: rsa_oaep_4096_sha256
      description: Key for encrypting large files with RSA-4096
      unprotected: true

pulumi {
  required_providers {
    scaleway = {
      source = "pulumi/scaleway"
    }
  }
}

# Create an asymmetric encryption key with RSA-4096.
resource "scaleway_keymanager_key" "rsa_4096" {
  name        = "rsa-4096-key"
  region      = "fr-par"
  usage       = "asymmetric_encryption"
  algorithm   = "rsa_oaep_4096_sha256"
  description = "Key for encrypting large files with RSA-4096"
  unprotected = true
}

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

// Create an asymmetric signing key.
const signing = new scaleway.keymanager.Key("signing", {
    name: "signing-key",
    region: "fr-par",
    usage: "asymmetric_signing",
    algorithm: "rsa_pss_2048_sha256",
    description: "Key for signing documents",
    unprotected: true,
});

import pulumi
import pulumiverse_scaleway as scaleway

# Create an asymmetric signing key.
signing = scaleway.keymanager.Key("signing",
    name="signing-key",
    region="fr-par",
    usage="asymmetric_signing",
    algorithm="rsa_pss_2048_sha256",
    description="Key for signing documents",
    unprotected=True)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/keymanager"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create an asymmetric signing key.
		_, err := keymanager.NewKey(ctx, "signing", &keymanager.KeyArgs{
			Name:        pulumi.String("signing-key"),
			Region:      pulumi.String("fr-par"),
			Usage:       pulumi.String("asymmetric_signing"),
			Algorithm:   pulumi.String("rsa_pss_2048_sha256"),
			Description: pulumi.String("Key for signing documents"),
			Unprotected: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    // Create an asymmetric signing key.
    var signing = new Scaleway.Keymanager.Key("signing", new()
    {
        Name = "signing-key",
        Region = "fr-par",
        Usage = "asymmetric_signing",
        Algorithm = "rsa_pss_2048_sha256",
        Description = "Key for signing documents",
        Unprotected = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.keymanager.Key;
import com.pulumi.scaleway.keymanager.KeyArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 an asymmetric signing key.
        var signing = new Key("signing", KeyArgs.builder()
            .name("signing-key")
            .region("fr-par")
            .usage("asymmetric_signing")
            .algorithm("rsa_pss_2048_sha256")
            .description("Key for signing documents")
            .unprotected(true)
            .build());

    }
}

resources:
  # Create an asymmetric signing key.
  signing:
    type: scaleway:keymanager:Key
    properties:
      name: signing-key
      region: fr-par
      usage: asymmetric_signing
      algorithm: rsa_pss_2048_sha256
      description: Key for signing documents
      unprotected: true

pulumi {
  required_providers {
    scaleway = {
      source = "pulumi/scaleway"
    }
  }
}

# Create an asymmetric signing key.
resource "scaleway_keymanager_key" "signing" {
  name        = "signing-key"
  region      = "fr-par"
  usage       = "asymmetric_signing"
  algorithm   = "rsa_pss_2048_sha256"
  description = "Key for signing documents"
  unprotected = true
}

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

// Create a basic key
const main = new scaleway.keymanager.Key("main", {
    name: "my-kms-key",
    usage: "symmetric_encryption",
    algorithm: "aes_256_gcm",
    unprotected: true,
});

import pulumi
import pulumiverse_scaleway as scaleway

# Create a basic key
main = scaleway.keymanager.Key("main",
    name="my-kms-key",
    usage="symmetric_encryption",
    algorithm="aes_256_gcm",
    unprotected=True)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/keymanager"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a basic key
		_, err := keymanager.NewKey(ctx, "main", &keymanager.KeyArgs{
			Name:        pulumi.String("my-kms-key"),
			Usage:       pulumi.String("symmetric_encryption"),
			Algorithm:   pulumi.String("aes_256_gcm"),
			Unprotected: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    // Create a basic key
    var main = new Scaleway.Keymanager.Key("main", new()
    {
        Name = "my-kms-key",
        Usage = "symmetric_encryption",
        Algorithm = "aes_256_gcm",
        Unprotected = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.keymanager.Key;
import com.pulumi.scaleway.keymanager.KeyArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 basic key
        var main = new Key("main", KeyArgs.builder()
            .name("my-kms-key")
            .usage("symmetric_encryption")
            .algorithm("aes_256_gcm")
            .unprotected(true)
            .build());

    }
}

resources:
  # Create a basic key
  main:
    type: scaleway:keymanager:Key
    properties:
      name: my-kms-key
      usage: symmetric_encryption
      algorithm: aes_256_gcm
      unprotected: true

pulumi {
  required_providers {
    scaleway = {
      source = "pulumi/scaleway"
    }
  }
}

# Create a basic key
resource "scaleway_keymanager_key" "main" {
  name        = "my-kms-key"
  usage       = "symmetric_encryption"
  algorithm   = "aes_256_gcm"
  unprotected = true
}

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

// Create a symmetric encryption key with a rotation policy of 30 days.
const symmetric = new scaleway.keymanager.Key("symmetric", {
    name: "my-kms-key",
    region: "fr-par",
    projectId: "your-project-id",
    usage: "symmetric_encryption",
    algorithm: "aes_256_gcm",
    description: "Key for encrypting secrets",
    tags: [
        "env:prod",
        "kms",
    ],
    unprotected: true,
    rotationPolicy: {
        rotationPeriod: "720h",
    },
});

import pulumi
import pulumiverse_scaleway as scaleway

# Create a symmetric encryption key with a rotation policy of 30 days.
symmetric = scaleway.keymanager.Key("symmetric",
    name="my-kms-key",
    region="fr-par",
    project_id="your-project-id",
    usage="symmetric_encryption",
    algorithm="aes_256_gcm",
    description="Key for encrypting secrets",
    tags=[
        "env:prod",
        "kms",
    ],
    unprotected=True,
    rotation_policy={
        "rotation_period": "720h",
    })

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/keymanager"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a symmetric encryption key with a rotation policy of 30 days.
		_, err := keymanager.NewKey(ctx, "symmetric", &keymanager.KeyArgs{
			Name:        pulumi.String("my-kms-key"),
			Region:      pulumi.String("fr-par"),
			ProjectId:   pulumi.String("your-project-id"),
			Usage:       pulumi.String("symmetric_encryption"),
			Algorithm:   pulumi.String("aes_256_gcm"),
			Description: pulumi.String("Key for encrypting secrets"),
			Tags: pulumi.StringArray{
				pulumi.String("env:prod"),
				pulumi.String("kms"),
			},
			Unprotected: pulumi.Bool(true),
			RotationPolicy: &keymanager.KeyRotationPolicyArgs{
				RotationPeriod: pulumi.String("720h"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    // Create a symmetric encryption key with a rotation policy of 30 days.
    var symmetric = new Scaleway.Keymanager.Key("symmetric", new()
    {
        Name = "my-kms-key",
        Region = "fr-par",
        ProjectId = "your-project-id",
        Usage = "symmetric_encryption",
        Algorithm = "aes_256_gcm",
        Description = "Key for encrypting secrets",
        Tags = new[]
        {
            "env:prod",
            "kms",
        },
        Unprotected = true,
        RotationPolicy = new Scaleway.Keymanager.Inputs.KeyRotationPolicyArgs
        {
            RotationPeriod = "720h",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.keymanager.Key;
import com.pulumi.scaleway.keymanager.KeyArgs;
import com.pulumi.scaleway.keymanager.inputs.KeyRotationPolicyArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 symmetric encryption key with a rotation policy of 30 days.
        var symmetric = new Key("symmetric", KeyArgs.builder()
            .name("my-kms-key")
            .region("fr-par")
            .projectId("your-project-id")
            .usage("symmetric_encryption")
            .algorithm("aes_256_gcm")
            .description("Key for encrypting secrets")
            .tags(            
                "env:prod",
                "kms")
            .unprotected(true)
            .rotationPolicy(KeyRotationPolicyArgs.builder()
                .rotationPeriod("720h")
                .build())
            .build());

    }
}

resources:
  # Create a symmetric encryption key with a rotation policy of 30 days.
  symmetric:
    type: scaleway:keymanager:Key
    properties:
      name: my-kms-key
      region: fr-par
      projectId: your-project-id
      usage: symmetric_encryption
      algorithm: aes_256_gcm
      description: Key for encrypting secrets
      tags:
        - env:prod
        - kms
      unprotected: true
      rotationPolicy:
        rotationPeriod: 720h

pulumi {
  required_providers {
    scaleway = {
      source = "pulumi/scaleway"
    }
  }
}

# Create a symmetric encryption key with a rotation policy of 30 days.
resource "scaleway_keymanager_key" "symmetric" {
  name        = "my-kms-key"
  region      = "fr-par"
  project_id  = "your-project-id"
  usage       = "symmetric_encryption"
  algorithm   = "aes_256_gcm"
  description = "Key for encrypting secrets"
  tags        = ["env:prod", "kms"]
  unprotected = true
  rotation_policy = {
    rotation_period = "720h"
  }
}

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

// Create a key with a dedicated protection level.
// In the example below, the key's cryptographic operations are performed within a dedicated Hardware Security Module (HSM).
const hsm = new scaleway.keymanager.Key("hsm", {
    name: "my-kms-key-hsm",
    usage: "symmetric_encryption",
    algorithm: "aes_256_gcm",
    protectionLevel: "hsm",
    unprotected: true,
});

import pulumi
import pulumiverse_scaleway as scaleway

# Create a key with a dedicated protection level.
# In the example below, the key's cryptographic operations are performed within a dedicated Hardware Security Module (HSM).
hsm = scaleway.keymanager.Key("hsm",
    name="my-kms-key-hsm",
    usage="symmetric_encryption",
    algorithm="aes_256_gcm",
    protection_level="hsm",
    unprotected=True)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway/keymanager"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a key with a dedicated protection level.
		// In the example below, the key's cryptographic operations are performed within a dedicated Hardware Security Module (HSM).
		_, err := keymanager.NewKey(ctx, "hsm", &keymanager.KeyArgs{
			Name:            pulumi.String("my-kms-key-hsm"),
			Usage:           pulumi.String("symmetric_encryption"),
			Algorithm:       pulumi.String("aes_256_gcm"),
			ProtectionLevel: pulumi.String("hsm"),
			Unprotected:     pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    // Create a key with a dedicated protection level.
    // In the example below, the key's cryptographic operations are performed within a dedicated Hardware Security Module (HSM).
    var hsm = new Scaleway.Keymanager.Key("hsm", new()
    {
        Name = "my-kms-key-hsm",
        Usage = "symmetric_encryption",
        Algorithm = "aes_256_gcm",
        ProtectionLevel = "hsm",
        Unprotected = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.keymanager.Key;
import com.pulumi.scaleway.keymanager.KeyArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 key with a dedicated protection level.
        // In the example below, the key's cryptographic operations are performed within a dedicated Hardware Security Module (HSM).
        var hsm = new Key("hsm", KeyArgs.builder()
            .name("my-kms-key-hsm")
            .usage("symmetric_encryption")
            .algorithm("aes_256_gcm")
            .protectionLevel("hsm")
            .unprotected(true)
            .build());

    }
}

resources:
  # Create a key with a dedicated protection level.
  # In the example below, the key's cryptographic operations are performed within a dedicated Hardware Security Module (HSM).
  hsm:
    type: scaleway:keymanager:Key
    properties:
      name: my-kms-key-hsm
      usage: symmetric_encryption
      algorithm: aes_256_gcm
      protectionLevel: hsm
      unprotected: true

pulumi {
  required_providers {
    scaleway = {
      source = "pulumi/scaleway"
    }
  }
}

# Create a key with a dedicated protection level.
# In the example below, the key's cryptographic operations are performed within a dedicated Hardware Security Module (HSM).
resource "scaleway_keymanager_key" "hsm" {
  name             = "my-kms-key-hsm"
  usage            = "symmetric_encryption"
  algorithm        = "aes_256_gcm"
  protection_level = "hsm"
  unprotected      = true
}

var scalewayKeyResource = new Scaleway.Keymanager.Key("scalewayKeyResource", new()
{
    Algorithm = "string",
    Usage = "string",
    Description = "string",
    Name = "string",
    Origin = "string",
    ProjectId = "string",
    ProtectionLevel = "string",
    Region = "string",
    RotationPolicy = new Scaleway.Keymanager.Inputs.KeyRotationPolicyArgs
    {
        RotationPeriod = "string",
        NextRotationAt = "string",
    },
    Tags = new[]
    {
        "string",
    },
    Unprotected = false,
});

example, err := keymanager.NewKey(ctx, "scalewayKeyResource", &keymanager.KeyArgs{
	Algorithm:       pulumi.String("string"),
	Usage:           pulumi.String("string"),
	Description:     pulumi.String("string"),
	Name:            pulumi.String("string"),
	Origin:          pulumi.String("string"),
	ProjectId:       pulumi.String("string"),
	ProtectionLevel: pulumi.String("string"),
	Region:          pulumi.String("string"),
	RotationPolicy: &keymanager.KeyRotationPolicyArgs{
		RotationPeriod: pulumi.String("string"),
		NextRotationAt: pulumi.String("string"),
	},
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
	Unprotected: pulumi.Bool(false),
})

resource "scaleway_keymanager_key" "scalewayKeyResource" {
  lifecycle {
    create_before_destroy = true
  }
  algorithm        = "string"
  usage            = "string"
  description      = "string"
  name             = "string"
  origin           = "string"
  project_id       = "string"
  protection_level = "string"
  region           = "string"
  rotation_policy = {
    rotation_period  = "string"
    next_rotation_at = "string"
  }
  tags        = ["string"]
  unprotected = false
}

var scalewayKeyResource = new com.pulumi.scaleway.keymanager.Key("scalewayKeyResource", com.pulumi.scaleway.keymanager.KeyArgs.builder()
    .algorithm("string")
    .usage("string")
    .description("string")
    .name("string")
    .origin("string")
    .projectId("string")
    .protectionLevel("string")
    .region("string")
    .rotationPolicy(KeyRotationPolicyArgs.builder()
        .rotationPeriod("string")
        .nextRotationAt("string")
        .build())
    .tags("string")
    .unprotected(false)
    .build());

scaleway_key_resource = scaleway.keymanager.Key("scalewayKeyResource",
    algorithm="string",
    usage="string",
    description="string",
    name="string",
    origin="string",
    project_id="string",
    protection_level="string",
    region="string",
    rotation_policy={
        "rotation_period": "string",
        "next_rotation_at": "string",
    },
    tags=["string"],
    unprotected=False)

const scalewayKeyResource = new scaleway.keymanager.Key("scalewayKeyResource", {
    algorithm: "string",
    usage: "string",
    description: "string",
    name: "string",
    origin: "string",
    projectId: "string",
    protectionLevel: "string",
    region: "string",
    rotationPolicy: {
        rotationPeriod: "string",
        nextRotationAt: "string",
    },
    tags: ["string"],
    unprotected: false,
});

type: scaleway:keymanager:Key
properties:
    algorithm: string
    description: string
    name: string
    origin: string
    projectId: string
    protectionLevel: string
    region: string
    rotationPolicy:
        nextRotationAt: string
        rotationPeriod: string
    tags:
        - string
    unprotected: false
    usage: string