elasticstack.ElasticsearchSecurityApiKey

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

const apiKeyElasticsearchSecurityApiKey = new elasticstack.ElasticsearchSecurityApiKey("apiKeyElasticsearchSecurityApiKey", {
    roleDescriptors: JSON.stringify({
        "role-a": {
            cluster: ["all"],
            indices: [{
                names: ["index-a*"],
                privileges: ["read"],
            }],
        },
    }),
    expiration: "1d",
    metadata: JSON.stringify({
        env: "testing",
        open: false,
        number: 49,
    }),
});
// restriction on a role descriptor for an API key is supported since Elastic 8.9
const apiKeyWithRestriction = new elasticstack.ElasticsearchSecurityApiKey("apiKeyWithRestriction", {
    roleDescriptors: JSON.stringify({
        "role-a": {
            cluster: ["all"],
            indices: [{
                names: ["index-a*"],
                privileges: ["read"],
            }],
            restriction: {
                workflows: ["search_application_query"],
            },
        },
    }),
    expiration: "1d",
    metadata: JSON.stringify({
        env: "testing",
        open: false,
        number: 49,
    }),
});
export const apiKey = apiKeyElasticsearchSecurityApiKey;

import pulumi
import json
import pulumi_elasticstack as elasticstack

api_key_elasticsearch_security_api_key = elasticstack.ElasticsearchSecurityApiKey("apiKeyElasticsearchSecurityApiKey",
    role_descriptors=json.dumps({
        "role-a": {
            "cluster": ["all"],
            "indices": [{
                "names": ["index-a*"],
                "privileges": ["read"],
            }],
        },
    }),
    expiration="1d",
    metadata=json.dumps({
        "env": "testing",
        "open": False,
        "number": 49,
    }))
# restriction on a role descriptor for an API key is supported since Elastic 8.9
api_key_with_restriction = elasticstack.ElasticsearchSecurityApiKey("apiKeyWithRestriction",
    role_descriptors=json.dumps({
        "role-a": {
            "cluster": ["all"],
            "indices": [{
                "names": ["index-a*"],
                "privileges": ["read"],
            }],
            "restriction": {
                "workflows": ["search_application_query"],
            },
        },
    }),
    expiration="1d",
    metadata=json.dumps({
        "env": "testing",
        "open": False,
        "number": 49,
    }))
pulumi.export("apiKey", api_key_elasticsearch_security_api_key)

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/elasticstack/elasticstack"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"role-a": map[string]interface{}{
				"cluster": []string{
					"all",
				},
				"indices": []map[string]interface{}{
					map[string]interface{}{
						"names": []string{
							"index-a*",
						},
						"privileges": []string{
							"read",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"env":    "testing",
			"open":   false,
			"number": 49,
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		apiKeyElasticsearchSecurityApiKey, err := elasticstack.NewElasticsearchSecurityApiKey(ctx, "apiKeyElasticsearchSecurityApiKey", &elasticstack.ElasticsearchSecurityApiKeyArgs{
			RoleDescriptors: pulumi.String(json0),
			Expiration:      pulumi.String("1d"),
			Metadata:        pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		tmpJSON2, err := json.Marshal(map[string]interface{}{
			"role-a": map[string]interface{}{
				"cluster": []string{
					"all",
				},
				"indices": []map[string]interface{}{
					map[string]interface{}{
						"names": []string{
							"index-a*",
						},
						"privileges": []string{
							"read",
						},
					},
				},
				"restriction": map[string]interface{}{
					"workflows": []string{
						"search_application_query",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json2 := string(tmpJSON2)
		tmpJSON3, err := json.Marshal(map[string]interface{}{
			"env":    "testing",
			"open":   false,
			"number": 49,
		})
		if err != nil {
			return err
		}
		json3 := string(tmpJSON3)
		// restriction on a role descriptor for an API key is supported since Elastic 8.9
		_, err = elasticstack.NewElasticsearchSecurityApiKey(ctx, "apiKeyWithRestriction", &elasticstack.ElasticsearchSecurityApiKeyArgs{
			RoleDescriptors: pulumi.String(json2),
			Expiration:      pulumi.String("1d"),
			Metadata:        pulumi.String(json3),
		})
		if err != nil {
			return err
		}
		ctx.Export("apiKey", apiKeyElasticsearchSecurityApiKey)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Elasticstack = Pulumi.Elasticstack;

return await Deployment.RunAsync(() => 
{
    var apiKeyElasticsearchSecurityApiKey = new Elasticstack.ElasticsearchSecurityApiKey("apiKeyElasticsearchSecurityApiKey", new()
    {
        RoleDescriptors = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["role-a"] = new Dictionary<string, object?>
            {
                ["cluster"] = new[]
                {
                    "all",
                },
                ["indices"] = new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["names"] = new[]
                        {
                            "index-a*",
                        },
                        ["privileges"] = new[]
                        {
                            "read",
                        },
                    },
                },
            },
        }),
        Expiration = "1d",
        Metadata = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["env"] = "testing",
            ["open"] = false,
            ["number"] = 49,
        }),
    });

    // restriction on a role descriptor for an API key is supported since Elastic 8.9
    var apiKeyWithRestriction = new Elasticstack.ElasticsearchSecurityApiKey("apiKeyWithRestriction", new()
    {
        RoleDescriptors = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["role-a"] = new Dictionary<string, object?>
            {
                ["cluster"] = new[]
                {
                    "all",
                },
                ["indices"] = new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["names"] = new[]
                        {
                            "index-a*",
                        },
                        ["privileges"] = new[]
                        {
                            "read",
                        },
                    },
                },
                ["restriction"] = new Dictionary<string, object?>
                {
                    ["workflows"] = new[]
                    {
                        "search_application_query",
                    },
                },
            },
        }),
        Expiration = "1d",
        Metadata = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["env"] = "testing",
            ["open"] = false,
            ["number"] = 49,
        }),
    });

    return new Dictionary<string, object?>
    {
        ["apiKey"] = apiKeyElasticsearchSecurityApiKey,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.elasticstack.ElasticsearchSecurityApiKey;
import com.pulumi.elasticstack.ElasticsearchSecurityApiKeyArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 apiKeyElasticsearchSecurityApiKey = new ElasticsearchSecurityApiKey("apiKeyElasticsearchSecurityApiKey", ElasticsearchSecurityApiKeyArgs.builder()
            .roleDescriptors(serializeJson(
                jsonObject(
                    jsonProperty("role-a", jsonObject(
                        jsonProperty("cluster", jsonArray("all")),
                        jsonProperty("indices", jsonArray(jsonObject(
                            jsonProperty("names", jsonArray("index-a*")),
                            jsonProperty("privileges", jsonArray("read"))
                        )))
                    ))
                )))
            .expiration("1d")
            .metadata(serializeJson(
                jsonObject(
                    jsonProperty("env", "testing"),
                    jsonProperty("open", false),
                    jsonProperty("number", 49)
                )))
            .build());

        // restriction on a role descriptor for an API key is supported since Elastic 8.9
        var apiKeyWithRestriction = new ElasticsearchSecurityApiKey("apiKeyWithRestriction", ElasticsearchSecurityApiKeyArgs.builder()
            .roleDescriptors(serializeJson(
                jsonObject(
                    jsonProperty("role-a", jsonObject(
                        jsonProperty("cluster", jsonArray("all")),
                        jsonProperty("indices", jsonArray(jsonObject(
                            jsonProperty("names", jsonArray("index-a*")),
                            jsonProperty("privileges", jsonArray("read"))
                        ))),
                        jsonProperty("restriction", jsonObject(
                            jsonProperty("workflows", jsonArray("search_application_query"))
                        ))
                    ))
                )))
            .expiration("1d")
            .metadata(serializeJson(
                jsonObject(
                    jsonProperty("env", "testing"),
                    jsonProperty("open", false),
                    jsonProperty("number", 49)
                )))
            .build());

        ctx.export("apiKey", apiKeyElasticsearchSecurityApiKey);
    }
}

resources:
  apiKeyElasticsearchSecurityApiKey:
    type: elasticstack:ElasticsearchSecurityApiKey
    properties:
      # Set the role descriptors
      roleDescriptors:
        fn::toJSON:
          role-a:
            cluster:
              - all
            indices:
              - names:
                  - index-a*
                privileges:
                  - read
      # Set the expiration for the API key
      expiration: 1d
      # Set the custom metadata for this user
      metadata:
        fn::toJSON:
          env: testing
          open: false
          number: 49
  # restriction on a role descriptor for an API key is supported since Elastic 8.9
  apiKeyWithRestriction:
    type: elasticstack:ElasticsearchSecurityApiKey
    properties:
      # Set the role descriptors
      roleDescriptors:
        fn::toJSON:
          role-a:
            cluster:
              - all
            indices:
              - names:
                  - index-a*
                privileges:
                  - read
            restriction:
              workflows:
                - search_application_query
      # Set the expiration for the API key
      expiration: 1d
      # Set the custom metadata for this user
      metadata:
        fn::toJSON:
          env: testing
          open: false
          number: 49
outputs:
  apiKey: ${apiKeyElasticsearchSecurityApiKey}

var elasticsearchSecurityApiKeyResource = new Elasticstack.ElasticsearchSecurityApiKey("elasticsearchSecurityApiKeyResource", new()
{
    Expiration = "string",
    Metadata = "string",
    Name = "string",
    RoleDescriptors = "string",
});

example, err := elasticstack.NewElasticsearchSecurityApiKey(ctx, "elasticsearchSecurityApiKeyResource", &elasticstack.ElasticsearchSecurityApiKeyArgs{
	Expiration:      pulumi.String("string"),
	Metadata:        pulumi.String("string"),
	Name:            pulumi.String("string"),
	RoleDescriptors: pulumi.String("string"),
})

var elasticsearchSecurityApiKeyResource = new ElasticsearchSecurityApiKey("elasticsearchSecurityApiKeyResource", ElasticsearchSecurityApiKeyArgs.builder()
    .expiration("string")
    .metadata("string")
    .name("string")
    .roleDescriptors("string")
    .build());

elasticsearch_security_api_key_resource = elasticstack.ElasticsearchSecurityApiKey("elasticsearchSecurityApiKeyResource",
    expiration="string",
    metadata="string",
    name="string",
    role_descriptors="string")

const elasticsearchSecurityApiKeyResource = new elasticstack.ElasticsearchSecurityApiKey("elasticsearchSecurityApiKeyResource", {
    expiration: "string",
    metadata: "string",
    name: "string",
    roleDescriptors: "string",
});

type: elasticstack:ElasticsearchSecurityApiKey
properties:
    expiration: string
    metadata: string
    name: string
    roleDescriptors: string