pulumi-nomad-kotlin/com.pulumi.nomad.kotlin/AclTokenArgs

AclTokenArgs

data class AclTokenArgs(val expirationTtl: Output<String>? = null, val global: Output<Boolean>? = null, val name: Output<String>? = null, val policies: Output<List<String>>? = null, val roles: Output<List<AclTokenRoleArgs>>? = null, val type: Output<String>? = null) : ConvertibleToJava<AclTokenArgs>

Example Usage

Creating a token with limited policies:

import * as pulumi from "@pulumi/pulumi";
import * as nomad from "@pulumi/nomad";
const dakota = new nomad.AclToken("dakota", {
    name: "Dakota",
    type: "client",
    policies: [
        "dev",
        "qa",
    ],
});

import pulumi
import pulumi_nomad as nomad
dakota = nomad.AclToken("dakota",
    name="Dakota",
    type="client",
    policies=[
        "dev",
        "qa",
    ])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Nomad = Pulumi.Nomad;
return await Deployment.RunAsync(() =>
{
    var dakota = new Nomad.AclToken("dakota", new()
    {
        Name = "Dakota",
        Type = "client",
        Policies = new[]
        {
            "dev",
            "qa",
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-nomad/sdk/v2/go/nomad"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := nomad.NewAclToken(ctx, "dakota", &nomad.AclTokenArgs{
			Name: pulumi.String("Dakota"),
			Type: pulumi.String("client"),
			Policies: pulumi.StringArray{
				pulumi.String("dev"),
				pulumi.String("qa"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nomad.AclToken;
import com.pulumi.nomad.AclTokenArgs;
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 dakota = new AclToken("dakota", AclTokenArgs.builder()
            .name("Dakota")
            .type("client")
            .policies(
                "dev",
                "qa")
            .build());
    }
}

resources:
  dakota:
    type: nomad:AclToken
    properties:
      name: Dakota
      type: client
      policies:
        - dev
        - qa

Creating a global token that will be replicated to all regions:

import * as pulumi from "@pulumi/pulumi";
import * as nomad from "@pulumi/nomad";
const dakota = new nomad.AclToken("dakota", {
    name: "Dakota",
    type: "client",
    policies: [
        "dev",
        "qa",
    ],
    global: true,
});

import pulumi
import pulumi_nomad as nomad
dakota = nomad.AclToken("dakota",
    name="Dakota",
    type="client",
    policies=[
        "dev",
        "qa",
    ],
    global_=True)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Nomad = Pulumi.Nomad;
return await Deployment.RunAsync(() =>
{
    var dakota = new Nomad.AclToken("dakota", new()
    {
        Name = "Dakota",
        Type = "client",
        Policies = new[]
        {
            "dev",
            "qa",
        },
        Global = true,
    });
});

package main
import (
	"github.com/pulumi/pulumi-nomad/sdk/v2/go/nomad"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := nomad.NewAclToken(ctx, "dakota", &nomad.AclTokenArgs{
			Name: pulumi.String("Dakota"),
			Type: pulumi.String("client"),
			Policies: pulumi.StringArray{
				pulumi.String("dev"),
				pulumi.String("qa"),
			},
			Global: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nomad.AclToken;
import com.pulumi.nomad.AclTokenArgs;
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 dakota = new AclToken("dakota", AclTokenArgs.builder()
            .name("Dakota")
            .type("client")
            .policies(
                "dev",
                "qa")
            .global(true)
            .build());
    }
}

resources:
  dakota:
    type: nomad:AclToken
    properties:
      name: Dakota
      type: client
      policies:
        - dev
        - qa
      global: true

Creating a token with full access to the cluster:

import * as pulumi from "@pulumi/pulumi";
import * as nomad from "@pulumi/nomad";
const iman = new nomad.AclToken("iman", {
    name: "Iman",
    type: "management",
});

import pulumi
import pulumi_nomad as nomad
iman = nomad.AclToken("iman",
    name="Iman",
    type="management")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Nomad = Pulumi.Nomad;
return await Deployment.RunAsync(() =>
{
    var iman = new Nomad.AclToken("iman", new()
    {
        Name = "Iman",
        Type = "management",
    });
});

package main
import (
	"github.com/pulumi/pulumi-nomad/sdk/v2/go/nomad"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := nomad.NewAclToken(ctx, "iman", &nomad.AclTokenArgs{
			Name: pulumi.String("Iman"),
			Type: pulumi.String("management"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nomad.AclToken;
import com.pulumi.nomad.AclTokenArgs;
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 iman = new AclToken("iman", AclTokenArgs.builder()
            .name("Iman")
            .type("management")
            .build());
    }
}

resources:
  iman:
    type: nomad:AclToken
    properties:
      name: Iman
      type: management

Accessing the token:

import * as pulumi from "@pulumi/pulumi";
import * as nomad from "@pulumi/nomad";
const token = new nomad.AclToken("token", {
    type: "client",
    policies: ["dev"],
});
export const nomadToken = token.secretId;

import pulumi
import pulumi_nomad as nomad
token = nomad.AclToken("token",
    type="client",
    policies=["dev"])
pulumi.export("nomadToken", token.secret_id)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Nomad = Pulumi.Nomad;
return await Deployment.RunAsync(() =>
{
    var token = new Nomad.AclToken("token", new()
    {
        Type = "client",
        Policies = new[]
        {
            "dev",
        },
    });
    return new Dictionary<string, object?>
    {
        ["nomadToken"] = token.SecretId,
    };
});

package main
import (
	"github.com/pulumi/pulumi-nomad/sdk/v2/go/nomad"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		token, err := nomad.NewAclToken(ctx, "token", &nomad.AclTokenArgs{
			Type: pulumi.String("client"),
			Policies: pulumi.StringArray{
				pulumi.String("dev"),
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("nomadToken", token.SecretId)
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nomad.AclToken;
import com.pulumi.nomad.AclTokenArgs;
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 token = new AclToken("token", AclTokenArgs.builder()
            .type("client")
            .policies("dev")
            .build());
        ctx.export("nomadToken", token.secretId());
    }
}

resources:
  token:
    type: nomad:AclToken
    properties:
      type: client
      policies:
        - dev
outputs:
  nomadToken: ${token.secretId}

Constructors

AclTokenArgs

constructor(expirationTtl: Output<String>? = null, global: Output<Boolean>? = null, name: Output<String>? = null, policies: Output<List<String>>? = null, roles: Output<List<AclTokenRoleArgs>>? = null, type: Output<String>? = null)

Properties

expirationTtl

val expirationTtl: Output<String>? = null

(string: "") - Provides a TTL for the token in the form of a time duration such as "5m" or "1h". In addition to the above arguments, the following attributes are exported and can be referenced:

global

val global: Output<Boolean>? = null

(bool: false) - Whether the token should be replicated to all regions, or if it will only be used in the region it was created in.

name

val name: Output<String>? = null

(string: "") - A human-friendly name for this token.

policies

val policies: Output<List<String>>? = null

(set: []) - A set of policy names to associate with this token. Must be set on client-type tokens, must not be set on management-type tokens. Policies do not need to exist before being used here.

roles

val roles: Output<List<AclTokenRoleArgs>>? = null

(set: []) - The list of roles attached to the token. Each entry has name and id attributes. It may be used multiple times.

type

val type: Output<String>? = null

(string: <required>) - The type of token this is. Use client for tokens that will have policies associated with them. Use management for tokens that can perform any action.

Functions

toJava

open override fun toJava(): AclTokenArgs