consul.getAclTokenSecretId

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Consul = Pulumi.Consul;

return await Deployment.RunAsync(() => 
{
    var testAclPolicy = new Consul.AclPolicy("testAclPolicy", new()
    {
        Rules = "node \"\" { policy = \"read\" }",
        Datacenters = new[]
        {
            "dc1",
        },
    });

    var testAclToken = new Consul.AclToken("testAclToken", new()
    {
        Description = "test",
        Policies = new[]
        {
            testAclPolicy.Name,
        },
        Local = true,
    });

    var read = Consul.GetAclTokenSecretId.Invoke(new()
    {
        AccessorId = testAclToken.Id,
        PgpKey = "keybase:my_username",
    });

    return new Dictionary<string, object?>
    {
        ["consulAclTokenSecretId"] = read.Apply(getAclTokenSecretIdResult => getAclTokenSecretIdResult.EncryptedSecretId),
    };
});

package main

import (
	"github.com/pulumi/pulumi-consul/sdk/v3/go/consul"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testAclPolicy, err := consul.NewAclPolicy(ctx, "testAclPolicy", &consul.AclPolicyArgs{
			Rules: pulumi.String("node \"\" { policy = \"read\" }"),
			Datacenters: pulumi.StringArray{
				pulumi.String("dc1"),
			},
		})
		if err != nil {
			return err
		}
		testAclToken, err := consul.NewAclToken(ctx, "testAclToken", &consul.AclTokenArgs{
			Description: pulumi.String("test"),
			Policies: pulumi.StringArray{
				testAclPolicy.Name,
			},
			Local: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		read := consul.GetAclTokenSecretIdOutput(ctx, consul.GetAclTokenSecretIdOutputArgs{
			AccessorId: testAclToken.ID(),
			PgpKey:     pulumi.String("keybase:my_username"),
		}, nil)
		ctx.Export("consulAclTokenSecretId", read.ApplyT(func(read consul.GetAclTokenSecretIdResult) (*string, error) {
			return &read.EncryptedSecretId, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.consul.AclPolicy;
import com.pulumi.consul.AclPolicyArgs;
import com.pulumi.consul.AclToken;
import com.pulumi.consul.AclTokenArgs;
import com.pulumi.consul.ConsulFunctions;
import com.pulumi.consul.inputs.GetAclTokenSecretIdArgs;
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 testAclPolicy = new AclPolicy("testAclPolicy", AclPolicyArgs.builder()        
            .rules("node \"\" { policy = \"read\" }")
            .datacenters("dc1")
            .build());

        var testAclToken = new AclToken("testAclToken", AclTokenArgs.builder()        
            .description("test")
            .policies(testAclPolicy.name())
            .local(true)
            .build());

        final var read = ConsulFunctions.getAclTokenSecretId(GetAclTokenSecretIdArgs.builder()
            .accessorId(testAclToken.id())
            .pgpKey("keybase:my_username")
            .build());

        ctx.export("consulAclTokenSecretId", read.applyValue(getAclTokenSecretIdResult -> getAclTokenSecretIdResult).applyValue(read -> read.applyValue(getAclTokenSecretIdResult -> getAclTokenSecretIdResult.encryptedSecretId())));
    }
}

import pulumi
import pulumi_consul as consul

test_acl_policy = consul.AclPolicy("testAclPolicy",
    rules="node \"\" { policy = \"read\" }",
    datacenters=["dc1"])
test_acl_token = consul.AclToken("testAclToken",
    description="test",
    policies=[test_acl_policy.name],
    local=True)
read = consul.get_acl_token_secret_id_output(accessor_id=test_acl_token.id,
    pgp_key="keybase:my_username")
pulumi.export("consulAclTokenSecretId", read.encrypted_secret_id)

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

const testAclPolicy = new consul.AclPolicy("testAclPolicy", {
    rules: "node \"\" { policy = \"read\" }",
    datacenters: ["dc1"],
});
const testAclToken = new consul.AclToken("testAclToken", {
    description: "test",
    policies: [testAclPolicy.name],
    local: true,
});
const read = consul.getAclTokenSecretIdOutput({
    accessorId: testAclToken.id,
    pgpKey: "keybase:my_username",
});
export const consulAclTokenSecretId = read.apply(read => read.encryptedSecretId);

resources:
  testAclPolicy:
    type: consul:AclPolicy
    properties:
      rules: node "" { policy = "read" }
      datacenters:
        - dc1
  testAclToken:
    type: consul:AclToken
    properties:
      description: test
      policies:
        - ${testAclPolicy.name}
      local: true
variables:
  read:
    fn::invoke:
      Function: consul:getAclTokenSecretId
      Arguments:
        accessorId: ${testAclToken.id}
        pgpKey: keybase:my_username
outputs:
  consulAclTokenSecretId: ${read.encryptedSecretId}