LicenseConfiguration

Provides a License Manager license configuration resource.

Note: Removing the license_count attribute is not supported by the License Manager API - recreate the resource instead.
Rules

License rules should be in the format of #RuleType=RuleValue. Supported rule types:

minimumVcpus - Resource must have minimum vCPU count in order to use the license. Default: 1
maximumVcpus - Resource must have maximum vCPU count in order to use the license. Default: unbounded, limit: 10000
minimumCores - Resource must have minimum core count in order to use the license. Default: 1
maximumCores - Resource must have maximum core count in order to use the license. Default: unbounded, limit: 10000
minimumSockets - Resource must have minimum socket count in order to use the license. Default: 1
maximumSockets - Resource must have maximum socket count in order to use the license. Default: unbounded, limit: 10000
allowedTenancy - Defines where the license can be used. If set, restricts license usage to selected tenancies. Specify a comma delimited list of EC2-Default, EC2-DedicatedHost, EC2-DedicatedInstance

Example Usage

using Pulumi;
using Aws = Pulumi.Aws;

class MyStack : Stack
{
    public MyStack()
    {
        var example = new Aws.LicenseManager.LicenseConfiguration("example", new Aws.LicenseManager.LicenseConfigurationArgs
        {
            Description = "Example",
            LicenseCount = 10,
            LicenseCountHardLimit = true,
            LicenseCountingType = "Socket",
            LicenseRules = 
            {
                "#minimumSockets=2",
            },
            Tags = 
            {
                { "foo", "barr" },
            },
        });
    }

}

package main

import (
    "github.com/pulumi/pulumi-aws/sdk/v2/go/aws/licensemanager"
    "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        _, err := licensemanager.NewLicenseConfiguration(ctx, "example", &licensemanager.LicenseConfigurationArgs{
            Description:           pulumi.String("Example"),
            LicenseCount:          pulumi.Int(10),
            LicenseCountHardLimit: pulumi.Bool(true),
            LicenseCountingType:   pulumi.String("Socket"),
            LicenseRules: pulumi.StringArray{
                pulumi.String("#minimumSockets=2"),
            },
            Tags: pulumi.StringMap{
                "foo": pulumi.String("barr"),
            },
        })
        if err != nil {
            return err
        }
        return nil
    })
}

import pulumi
import pulumi_aws as aws

example = aws.licensemanager.LicenseConfiguration("example",
    description="Example",
    license_count=10,
    license_count_hard_limit=True,
    license_counting_type="Socket",
    license_rules=["#minimumSockets=2"],
    tags={
        "foo": "barr",
    })

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.licensemanager.LicenseConfiguration("example", {
    description: "Example",
    licenseCount: 10,
    licenseCountHardLimit: true,
    licenseCountingType: "Socket",
    licenseRules: ["#minimumSockets=2"],
    tags: {
        foo: "barr",
    },
});

Create a LicenseConfiguration Resource

new LicenseConfiguration(name: string, args: LicenseConfigurationArgs, opts?: CustomResourceOptions);

def LicenseConfiguration(resource_name, opts=None, description=None, license_count=None, license_count_hard_limit=None, license_counting_type=None, license_rules=None, name=None, tags=None, __props__=None);

func NewLicenseConfiguration(ctx *Context, name string, args LicenseConfigurationArgs, opts ...ResourceOption) (*LicenseConfiguration, error)

public LicenseConfiguration(string name, LicenseConfigurationArgs args, CustomResourceOptions? opts = null)

name string: The unique name of the resource.
args LicenseConfigurationArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
opts ResourceOptions: A bag of options that control this resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args LicenseConfigurationArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args LicenseConfigurationArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

LicenseConfiguration Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Programming Model docs.

Inputs

The LicenseConfiguration resource accepts the following input properties:

LicenseCountingType string: Dimension to use to track license inventory. Specify either vCPU, Instance, Core or Socket.
Description string: Description of the license configuration.
LicenseCount int: Number of licenses managed by the license configuration.
LicenseCountHardLimit bool: Sets the number of available licenses as a hard limit.
LicenseRules List<string>: Array of configured License Manager rules.
Name string: Name of the license configuration.
Tags Dictionary<string, string>: A map of tags to assign to the resource.

LicenseCountingType string: Dimension to use to track license inventory. Specify either vCPU, Instance, Core or Socket.
Description string: Description of the license configuration.
LicenseCount int: Number of licenses managed by the license configuration.
LicenseCountHardLimit bool: Sets the number of available licenses as a hard limit.
LicenseRules []string: Array of configured License Manager rules.
Name string: Name of the license configuration.
Tags map[string]string: A map of tags to assign to the resource.

licenseCountingType string: Dimension to use to track license inventory. Specify either vCPU, Instance, Core or Socket.
description string: Description of the license configuration.
licenseCount number: Number of licenses managed by the license configuration.
licenseCountHardLimit boolean: Sets the number of available licenses as a hard limit.
licenseRules string[]: Array of configured License Manager rules.
name string: Name of the license configuration.
tags {[key: string]: string}: A map of tags to assign to the resource.

license_counting_type str: Dimension to use to track license inventory. Specify either vCPU, Instance, Core or Socket.
description str: Description of the license configuration.
license_count float: Number of licenses managed by the license configuration.
license_count_hard_limit bool: Sets the number of available licenses as a hard limit.
license_rules List[str]: Array of configured License Manager rules.
name str: Name of the license configuration.
tags Dict[str, str]: A map of tags to assign to the resource.

Outputs

All input properties are implicitly available as output properties. Additionally, the LicenseConfiguration resource produces the following output properties:

Id string: The provider-assigned unique ID for this managed resource.

Id string: The provider-assigned unique ID for this managed resource.

id string: The provider-assigned unique ID for this managed resource.

id str: The provider-assigned unique ID for this managed resource.

Look up an Existing LicenseConfiguration Resource

Get an existing LicenseConfiguration resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: LicenseConfigurationState, opts?: CustomResourceOptions): LicenseConfiguration

static get(resource_name, id, opts=None, description=None, license_count=None, license_count_hard_limit=None, license_counting_type=None, license_rules=None, name=None, tags=None, __props__=None);

func GetLicenseConfiguration(ctx *Context, name string, id IDInput, state *LicenseConfigurationState, opts ...ResourceOption) (*LicenseConfiguration, error)

public static LicenseConfiguration Get(string name, Input<string> id, LicenseConfigurationState? state, CustomResourceOptions? opts = null)

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

resource_name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

name: The unique name of the resulting resource.
id: The unique provider ID of the resource to lookup.
state: Any extra arguments used during the lookup.
opts: A bag of options that control this resource's behavior.

The following state arguments are supported:

Description string: Description of the license configuration.
LicenseCount int: Number of licenses managed by the license configuration.
LicenseCountHardLimit bool: Sets the number of available licenses as a hard limit.
LicenseCountingType string: Dimension to use to track license inventory. Specify either vCPU, Instance, Core or Socket.
LicenseRules List<string>: Array of configured License Manager rules.
Name string: Name of the license configuration.
Tags Dictionary<string, string>: A map of tags to assign to the resource.

Description string: Description of the license configuration.
LicenseCount int: Number of licenses managed by the license configuration.
LicenseCountHardLimit bool: Sets the number of available licenses as a hard limit.
LicenseCountingType string: Dimension to use to track license inventory. Specify either vCPU, Instance, Core or Socket.
LicenseRules []string: Array of configured License Manager rules.
Name string: Name of the license configuration.
Tags map[string]string: A map of tags to assign to the resource.

description string: Description of the license configuration.
licenseCount number: Number of licenses managed by the license configuration.
licenseCountHardLimit boolean: Sets the number of available licenses as a hard limit.
licenseCountingType string: Dimension to use to track license inventory. Specify either vCPU, Instance, Core or Socket.
licenseRules string[]: Array of configured License Manager rules.
name string: Name of the license configuration.
tags {[key: string]: string}: A map of tags to assign to the resource.

description str: Description of the license configuration.
license_count float: Number of licenses managed by the license configuration.
license_count_hard_limit bool: Sets the number of available licenses as a hard limit.
license_counting_type str: Dimension to use to track license inventory. Specify either vCPU, Instance, Core or Socket.
license_rules List[str]: Array of configured License Manager rules.
name str: Name of the license configuration.
tags Dict[str, str]: A map of tags to assign to the resource.

Package Details

Repository: https://github.com/pulumi/pulumi-aws
License: Apache-2.0
Notes: This Pulumi package is based on the aws Terraform Provider.

The Pulumi Platform

Get Started

Migrate to Pulumi

Solutions for All Teams and Engineers

Any Code

Any Cloud