Consul v3.12.1, Aug 23 24

Consul v3.12.1 published on Friday, Aug 23, 2024 by Pulumi

consul.ConfigEntry

Explore with Pulumi AI

Consul v3.12.1 published on Friday, Aug 23, 2024 by Pulumi

Example Usage

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

const proxyDefaults = new consul.ConfigEntry("proxy_defaults", {
    kind: "proxy-defaults",
    name: "global",
    configJson: JSON.stringify({
        Config: {
            local_connect_timeout_ms: 1000,
            handshake_timeout_ms: 10000,
        },
    }),
});
const web = new consul.ConfigEntry("web", {
    name: "web",
    kind: "service-defaults",
    configJson: JSON.stringify({
        Protocol: "http",
    }),
});
const admin = new consul.ConfigEntry("admin", {
    name: "admin",
    kind: "service-defaults",
    configJson: JSON.stringify({
        Protocol: "http",
    }),
});
const serviceResolver = new consul.ConfigEntry("service_resolver", {
    kind: "service-resolver",
    name: web.name,
    configJson: JSON.stringify({
        DefaultSubset: "v1",
        Subsets: {
            v1: {
                Filter: "Service.Meta.version == v1",
            },
            v2: {
                Filter: "Service.Meta.version == v2",
            },
        },
    }),
});
const serviceSplitter = new consul.ConfigEntry("service_splitter", {
    kind: "service-splitter",
    name: serviceResolver.name,
    configJson: JSON.stringify({
        Splits: [
            {
                Weight: 90,
                ServiceSubset: "v1",
            },
            {
                Weight: 10,
                ServiceSubset: "v2",
            },
        ],
    }),
});
const serviceRouter = new consul.ConfigEntry("service_router", {
    kind: "service-router",
    name: "web",
    configJson: JSON.stringify({
        Routes: [{
            Match: {
                HTTP: {
                    PathPrefix: "/admin",
                },
            },
            Destination: {
                Service: "admin",
            },
        }],
    }),
});
const ingressGateway = new consul.ConfigEntry("ingress_gateway", {
    name: "us-east-ingress",
    kind: "ingress-gateway",
    configJson: JSON.stringify({
        TLS: {
            Enabled: true,
        },
        Listeners: [{
            Port: 8000,
            Protocol: "http",
            Services: [{
                Name: "*",
            }],
        }],
    }),
});
const terminatingGateway = new consul.ConfigEntry("terminating_gateway", {
    name: "us-west-gateway",
    kind: "terminating-gateway",
    configJson: JSON.stringify({
        Services: [{
            Name: "billing",
        }],
    }),
});

import pulumi
import json
import pulumi_consul as consul

proxy_defaults = consul.ConfigEntry("proxy_defaults",
    kind="proxy-defaults",
    name="global",
    config_json=json.dumps({
        "Config": {
            "local_connect_timeout_ms": 1000,
            "handshake_timeout_ms": 10000,
        },
    }))
web = consul.ConfigEntry("web",
    name="web",
    kind="service-defaults",
    config_json=json.dumps({
        "Protocol": "http",
    }))
admin = consul.ConfigEntry("admin",
    name="admin",
    kind="service-defaults",
    config_json=json.dumps({
        "Protocol": "http",
    }))
service_resolver = consul.ConfigEntry("service_resolver",
    kind="service-resolver",
    name=web.name,
    config_json=json.dumps({
        "DefaultSubset": "v1",
        "Subsets": {
            "v1": {
                "Filter": "Service.Meta.version == v1",
            },
            "v2": {
                "Filter": "Service.Meta.version == v2",
            },
        },
    }))
service_splitter = consul.ConfigEntry("service_splitter",
    kind="service-splitter",
    name=service_resolver.name,
    config_json=json.dumps({
        "Splits": [
            {
                "Weight": 90,
                "ServiceSubset": "v1",
            },
            {
                "Weight": 10,
                "ServiceSubset": "v2",
            },
        ],
    }))
service_router = consul.ConfigEntry("service_router",
    kind="service-router",
    name="web",
    config_json=json.dumps({
        "Routes": [{
            "Match": {
                "HTTP": {
                    "PathPrefix": "/admin",
                },
            },
            "Destination": {
                "Service": "admin",
            },
        }],
    }))
ingress_gateway = consul.ConfigEntry("ingress_gateway",
    name="us-east-ingress",
    kind="ingress-gateway",
    config_json=json.dumps({
        "TLS": {
            "Enabled": True,
        },
        "Listeners": [{
            "Port": 8000,
            "Protocol": "http",
            "Services": [{
                "Name": "*",
            }],
        }],
    }))
terminating_gateway = consul.ConfigEntry("terminating_gateway",
    name="us-west-gateway",
    kind="terminating-gateway",
    config_json=json.dumps({
        "Services": [{
            "Name": "billing",
        }],
    }))

package main

import (
	"encoding/json"

	"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 {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Config": map[string]interface{}{
				"local_connect_timeout_ms": 1000,
				"handshake_timeout_ms":     10000,
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = consul.NewConfigEntry(ctx, "proxy_defaults", &consul.ConfigEntryArgs{
			Kind:       pulumi.String("proxy-defaults"),
			Name:       pulumi.String("global"),
			ConfigJson: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"Protocol": "http",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		web, err := consul.NewConfigEntry(ctx, "web", &consul.ConfigEntryArgs{
			Name:       pulumi.String("web"),
			Kind:       pulumi.String("service-defaults"),
			ConfigJson: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		tmpJSON2, err := json.Marshal(map[string]interface{}{
			"Protocol": "http",
		})
		if err != nil {
			return err
		}
		json2 := string(tmpJSON2)
		_, err = consul.NewConfigEntry(ctx, "admin", &consul.ConfigEntryArgs{
			Name:       pulumi.String("admin"),
			Kind:       pulumi.String("service-defaults"),
			ConfigJson: pulumi.String(json2),
		})
		if err != nil {
			return err
		}
		tmpJSON3, err := json.Marshal(map[string]interface{}{
			"DefaultSubset": "v1",
			"Subsets": map[string]interface{}{
				"v1": map[string]interface{}{
					"Filter": "Service.Meta.version == v1",
				},
				"v2": map[string]interface{}{
					"Filter": "Service.Meta.version == v2",
				},
			},
		})
		if err != nil {
			return err
		}
		json3 := string(tmpJSON3)
		serviceResolver, err := consul.NewConfigEntry(ctx, "service_resolver", &consul.ConfigEntryArgs{
			Kind:       pulumi.String("service-resolver"),
			Name:       web.Name,
			ConfigJson: pulumi.String(json3),
		})
		if err != nil {
			return err
		}
		tmpJSON4, err := json.Marshal(map[string]interface{}{
			"Splits": []interface{}{
				map[string]interface{}{
					"Weight":        90,
					"ServiceSubset": "v1",
				},
				map[string]interface{}{
					"Weight":        10,
					"ServiceSubset": "v2",
				},
			},
		})
		if err != nil {
			return err
		}
		json4 := string(tmpJSON4)
		_, err = consul.NewConfigEntry(ctx, "service_splitter", &consul.ConfigEntryArgs{
			Kind:       pulumi.String("service-splitter"),
			Name:       serviceResolver.Name,
			ConfigJson: pulumi.String(json4),
		})
		if err != nil {
			return err
		}
		tmpJSON5, err := json.Marshal(map[string]interface{}{
			"Routes": []map[string]interface{}{
				map[string]interface{}{
					"Match": map[string]interface{}{
						"HTTP": map[string]interface{}{
							"PathPrefix": "/admin",
						},
					},
					"Destination": map[string]interface{}{
						"Service": "admin",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json5 := string(tmpJSON5)
		_, err = consul.NewConfigEntry(ctx, "service_router", &consul.ConfigEntryArgs{
			Kind:       pulumi.String("service-router"),
			Name:       pulumi.String("web"),
			ConfigJson: pulumi.String(json5),
		})
		if err != nil {
			return err
		}
		tmpJSON6, err := json.Marshal(map[string]interface{}{
			"TLS": map[string]interface{}{
				"Enabled": true,
			},
			"Listeners": []map[string]interface{}{
				map[string]interface{}{
					"Port":     8000,
					"Protocol": "http",
					"Services": []map[string]interface{}{
						map[string]interface{}{
							"Name": "*",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json6 := string(tmpJSON6)
		_, err = consul.NewConfigEntry(ctx, "ingress_gateway", &consul.ConfigEntryArgs{
			Name:       pulumi.String("us-east-ingress"),
			Kind:       pulumi.String("ingress-gateway"),
			ConfigJson: pulumi.String(json6),
		})
		if err != nil {
			return err
		}
		tmpJSON7, err := json.Marshal(map[string]interface{}{
			"Services": []map[string]interface{}{
				map[string]interface{}{
					"Name": "billing",
				},
			},
		})
		if err != nil {
			return err
		}
		json7 := string(tmpJSON7)
		_, err = consul.NewConfigEntry(ctx, "terminating_gateway", &consul.ConfigEntryArgs{
			Name:       pulumi.String("us-west-gateway"),
			Kind:       pulumi.String("terminating-gateway"),
			ConfigJson: pulumi.String(json7),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var proxyDefaults = new Consul.ConfigEntry("proxy_defaults", new()
    {
        Kind = "proxy-defaults",
        Name = "global",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Config"] = new Dictionary<string, object?>
            {
                ["local_connect_timeout_ms"] = 1000,
                ["handshake_timeout_ms"] = 10000,
            },
        }),
    });

    var web = new Consul.ConfigEntry("web", new()
    {
        Name = "web",
        Kind = "service-defaults",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Protocol"] = "http",
        }),
    });

    var admin = new Consul.ConfigEntry("admin", new()
    {
        Name = "admin",
        Kind = "service-defaults",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Protocol"] = "http",
        }),
    });

    var serviceResolver = new Consul.ConfigEntry("service_resolver", new()
    {
        Kind = "service-resolver",
        Name = web.Name,
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["DefaultSubset"] = "v1",
            ["Subsets"] = new Dictionary<string, object?>
            {
                ["v1"] = new Dictionary<string, object?>
                {
                    ["Filter"] = "Service.Meta.version == v1",
                },
                ["v2"] = new Dictionary<string, object?>
                {
                    ["Filter"] = "Service.Meta.version == v2",
                },
            },
        }),
    });

    var serviceSplitter = new Consul.ConfigEntry("service_splitter", new()
    {
        Kind = "service-splitter",
        Name = serviceResolver.Name,
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Splits"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Weight"] = 90,
                    ["ServiceSubset"] = "v1",
                },
                new Dictionary<string, object?>
                {
                    ["Weight"] = 10,
                    ["ServiceSubset"] = "v2",
                },
            },
        }),
    });

    var serviceRouter = new Consul.ConfigEntry("service_router", new()
    {
        Kind = "service-router",
        Name = "web",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Routes"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Match"] = new Dictionary<string, object?>
                    {
                        ["HTTP"] = new Dictionary<string, object?>
                        {
                            ["PathPrefix"] = "/admin",
                        },
                    },
                    ["Destination"] = new Dictionary<string, object?>
                    {
                        ["Service"] = "admin",
                    },
                },
            },
        }),
    });

    var ingressGateway = new Consul.ConfigEntry("ingress_gateway", new()
    {
        Name = "us-east-ingress",
        Kind = "ingress-gateway",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["TLS"] = new Dictionary<string, object?>
            {
                ["Enabled"] = true,
            },
            ["Listeners"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Port"] = 8000,
                    ["Protocol"] = "http",
                    ["Services"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["Name"] = "*",
                        },
                    },
                },
            },
        }),
    });

    var terminatingGateway = new Consul.ConfigEntry("terminating_gateway", new()
    {
        Name = "us-west-gateway",
        Kind = "terminating-gateway",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Services"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Name"] = "billing",
                },
            },
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.consul.ConfigEntry;
import com.pulumi.consul.ConfigEntryArgs;
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 proxyDefaults = new ConfigEntry("proxyDefaults", ConfigEntryArgs.builder()
            .kind("proxy-defaults")
            .name("global")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Config", jsonObject(
                        jsonProperty("local_connect_timeout_ms", 1000),
                        jsonProperty("handshake_timeout_ms", 10000)
                    ))
                )))
            .build());

        var web = new ConfigEntry("web", ConfigEntryArgs.builder()
            .name("web")
            .kind("service-defaults")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Protocol", "http")
                )))
            .build());

        var admin = new ConfigEntry("admin", ConfigEntryArgs.builder()
            .name("admin")
            .kind("service-defaults")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Protocol", "http")
                )))
            .build());

        var serviceResolver = new ConfigEntry("serviceResolver", ConfigEntryArgs.builder()
            .kind("service-resolver")
            .name(web.name())
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("DefaultSubset", "v1"),
                    jsonProperty("Subsets", jsonObject(
                        jsonProperty("v1", jsonObject(
                            jsonProperty("Filter", "Service.Meta.version == v1")
                        )),
                        jsonProperty("v2", jsonObject(
                            jsonProperty("Filter", "Service.Meta.version == v2")
                        ))
                    ))
                )))
            .build());

        var serviceSplitter = new ConfigEntry("serviceSplitter", ConfigEntryArgs.builder()
            .kind("service-splitter")
            .name(serviceResolver.name())
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Splits", jsonArray(
                        jsonObject(
                            jsonProperty("Weight", 90),
                            jsonProperty("ServiceSubset", "v1")
                        ), 
                        jsonObject(
                            jsonProperty("Weight", 10),
                            jsonProperty("ServiceSubset", "v2")
                        )
                    ))
                )))
            .build());

        var serviceRouter = new ConfigEntry("serviceRouter", ConfigEntryArgs.builder()
            .kind("service-router")
            .name("web")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Routes", jsonArray(jsonObject(
                        jsonProperty("Match", jsonObject(
                            jsonProperty("HTTP", jsonObject(
                                jsonProperty("PathPrefix", "/admin")
                            ))
                        )),
                        jsonProperty("Destination", jsonObject(
                            jsonProperty("Service", "admin")
                        ))
                    )))
                )))
            .build());

        var ingressGateway = new ConfigEntry("ingressGateway", ConfigEntryArgs.builder()
            .name("us-east-ingress")
            .kind("ingress-gateway")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("TLS", jsonObject(
                        jsonProperty("Enabled", true)
                    )),
                    jsonProperty("Listeners", jsonArray(jsonObject(
                        jsonProperty("Port", 8000),
                        jsonProperty("Protocol", "http"),
                        jsonProperty("Services", jsonArray(jsonObject(
                            jsonProperty("Name", "*")
                        )))
                    )))
                )))
            .build());

        var terminatingGateway = new ConfigEntry("terminatingGateway", ConfigEntryArgs.builder()
            .name("us-west-gateway")
            .kind("terminating-gateway")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Services", jsonArray(jsonObject(
                        jsonProperty("Name", "billing")
                    )))
                )))
            .build());

    }
}

resources:
  proxyDefaults:
    type: consul:ConfigEntry
    name: proxy_defaults
    properties:
      kind: proxy-defaults
      name: global
      configJson:
        fn::toJSON:
          Config:
            local_connect_timeout_ms: 1000
            handshake_timeout_ms: 10000
  web:
    type: consul:ConfigEntry
    properties:
      name: web
      kind: service-defaults
      configJson:
        fn::toJSON:
          Protocol: http
  admin:
    type: consul:ConfigEntry
    properties:
      name: admin
      kind: service-defaults
      configJson:
        fn::toJSON:
          Protocol: http
  serviceResolver:
    type: consul:ConfigEntry
    name: service_resolver
    properties:
      kind: service-resolver
      name: ${web.name}
      configJson:
        fn::toJSON:
          DefaultSubset: v1
          Subsets:
            v1:
              Filter: Service.Meta.version == v1
            v2:
              Filter: Service.Meta.version == v2
  serviceSplitter:
    type: consul:ConfigEntry
    name: service_splitter
    properties:
      kind: service-splitter
      name: ${serviceResolver.name}
      configJson:
        fn::toJSON:
          Splits:
            - Weight: 90
              ServiceSubset: v1
            - Weight: 10
              ServiceSubset: v2
  serviceRouter:
    type: consul:ConfigEntry
    name: service_router
    properties:
      kind: service-router
      name: web
      configJson:
        fn::toJSON:
          Routes:
            - Match:
                HTTP:
                  PathPrefix: /admin
              Destination:
                Service: admin
  ingressGateway:
    type: consul:ConfigEntry
    name: ingress_gateway
    properties:
      name: us-east-ingress
      kind: ingress-gateway
      configJson:
        fn::toJSON:
          TLS:
            Enabled: true
          Listeners:
            - Port: 8000
              Protocol: http
              Services:
                - Name: '*'
  terminatingGateway:
    type: consul:ConfigEntry
    name: terminating_gateway
    properties:
      name: us-west-gateway
      kind: terminating-gateway
      configJson:
        fn::toJSON:
          Services:
            - Name: billing

`service-intentions` config entry

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

const serviceIntentions = new consul.ConfigEntry("service_intentions", {
    name: "api-service",
    kind: "service-intentions",
    configJson: JSON.stringify({
        Sources: [
            {
                Action: "allow",
                Name: "frontend-webapp",
                Precedence: 9,
                Type: "consul",
            },
            {
                Action: "allow",
                Name: "nightly-cronjob",
                Precedence: 9,
                Type: "consul",
            },
        ],
    }),
});

import pulumi
import json
import pulumi_consul as consul

service_intentions = consul.ConfigEntry("service_intentions",
    name="api-service",
    kind="service-intentions",
    config_json=json.dumps({
        "Sources": [
            {
                "Action": "allow",
                "Name": "frontend-webapp",
                "Precedence": 9,
                "Type": "consul",
            },
            {
                "Action": "allow",
                "Name": "nightly-cronjob",
                "Precedence": 9,
                "Type": "consul",
            },
        ],
    }))

package main

import (
	"encoding/json"

	"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 {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Sources": []map[string]interface{}{
				map[string]interface{}{
					"Action":     "allow",
					"Name":       "frontend-webapp",
					"Precedence": 9,
					"Type":       "consul",
				},
				map[string]interface{}{
					"Action":     "allow",
					"Name":       "nightly-cronjob",
					"Precedence": 9,
					"Type":       "consul",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = consul.NewConfigEntry(ctx, "service_intentions", &consul.ConfigEntryArgs{
			Name:       pulumi.String("api-service"),
			Kind:       pulumi.String("service-intentions"),
			ConfigJson: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var serviceIntentions = new Consul.ConfigEntry("service_intentions", new()
    {
        Name = "api-service",
        Kind = "service-intentions",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Sources"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Action"] = "allow",
                    ["Name"] = "frontend-webapp",
                    ["Precedence"] = 9,
                    ["Type"] = "consul",
                },
                new Dictionary<string, object?>
                {
                    ["Action"] = "allow",
                    ["Name"] = "nightly-cronjob",
                    ["Precedence"] = 9,
                    ["Type"] = "consul",
                },
            },
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.consul.ConfigEntry;
import com.pulumi.consul.ConfigEntryArgs;
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 serviceIntentions = new ConfigEntry("serviceIntentions", ConfigEntryArgs.builder()
            .name("api-service")
            .kind("service-intentions")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Sources", jsonArray(
                        jsonObject(
                            jsonProperty("Action", "allow"),
                            jsonProperty("Name", "frontend-webapp"),
                            jsonProperty("Precedence", 9),
                            jsonProperty("Type", "consul")
                        ), 
                        jsonObject(
                            jsonProperty("Action", "allow"),
                            jsonProperty("Name", "nightly-cronjob"),
                            jsonProperty("Precedence", 9),
                            jsonProperty("Type", "consul")
                        )
                    ))
                )))
            .build());

    }
}

resources:
  serviceIntentions:
    type: consul:ConfigEntry
    name: service_intentions
    properties:
      name: api-service
      kind: service-intentions
      configJson:
        fn::toJSON:
          Sources:
            - Action: allow
              Name: frontend-webapp
              Precedence: 9
              Type: consul
            - Action: allow
              Name: nightly-cronjob
              Precedence: 9
              Type: consul

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

const sd = new consul.ConfigEntry("sd", {
    name: "fort-knox",
    kind: "service-defaults",
    configJson: JSON.stringify({
        Protocol: "http",
    }),
});
const jwtProvider = new consul.ConfigEntry("jwt_provider", {
    name: "test-provider",
    kind: "jwt-provider",
    configJson: JSON.stringify({
        Issuer: "test-issuer",
        JSONWebKeySet: {
            Remote: {
                URI: "https://127.0.0.1:9091",
                FetchAsynchronously: true,
            },
        },
        Forwarding: {
            HeaderName: "test-token",
        },
    }),
});
const serviceIntentions = new consul.ConfigEntry("service_intentions", {
    name: sd.name,
    kind: "service-intentions",
    configJson: pulumi.jsonStringify({
        Sources: [
            {
                Name: "contractor-webapp",
                Permissions: [{
                    Action: "allow",
                    HTTP: {
                        Methods: [
                            "GET",
                            "HEAD",
                        ],
                        PathExact: "/healtz",
                    },
                    JWT: {
                        Providers: [{
                            Name: jwtProvider.name,
                        }],
                    },
                }],
                Precedence: 9,
                Type: "consul",
            },
            {
                Name: "admin-dashboard-webapp",
                Permissions: [
                    {
                        Action: "deny",
                        HTTP: {
                            PathPrefix: "/debugz",
                        },
                    },
                    {
                        Action: "allow",
                        HTTP: {
                            PathPrefix: "/",
                        },
                    },
                ],
                Precedence: 9,
                Type: "consul",
            },
        ],
    }),
});

import pulumi
import json
import pulumi_consul as consul

sd = consul.ConfigEntry("sd",
    name="fort-knox",
    kind="service-defaults",
    config_json=json.dumps({
        "Protocol": "http",
    }))
jwt_provider = consul.ConfigEntry("jwt_provider",
    name="test-provider",
    kind="jwt-provider",
    config_json=json.dumps({
        "Issuer": "test-issuer",
        "JSONWebKeySet": {
            "Remote": {
                "URI": "https://127.0.0.1:9091",
                "FetchAsynchronously": True,
            },
        },
        "Forwarding": {
            "HeaderName": "test-token",
        },
    }))
service_intentions = consul.ConfigEntry("service_intentions",
    name=sd.name,
    kind="service-intentions",
    config_json=pulumi.Output.json_dumps({
        "Sources": [
            {
                "Name": "contractor-webapp",
                "Permissions": [{
                    "Action": "allow",
                    "HTTP": {
                        "Methods": [
                            "GET",
                            "HEAD",
                        ],
                        "PathExact": "/healtz",
                    },
                    "JWT": {
                        "Providers": [{
                            "Name": jwt_provider.name,
                        }],
                    },
                }],
                "Precedence": 9,
                "Type": "consul",
            },
            {
                "Name": "admin-dashboard-webapp",
                "Permissions": [
                    {
                        "Action": "deny",
                        "HTTP": {
                            "PathPrefix": "/debugz",
                        },
                    },
                    {
                        "Action": "allow",
                        "HTTP": {
                            "PathPrefix": "/",
                        },
                    },
                ],
                "Precedence": 9,
                "Type": "consul",
            },
        ],
    }))

package main

import (
	"encoding/json"

	"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 {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Protocol": "http",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		sd, err := consul.NewConfigEntry(ctx, "sd", &consul.ConfigEntryArgs{
			Name:       pulumi.String("fort-knox"),
			Kind:       pulumi.String("service-defaults"),
			ConfigJson: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"Issuer": "test-issuer",
			"JSONWebKeySet": map[string]interface{}{
				"Remote": map[string]interface{}{
					"URI":                 "https://127.0.0.1:9091",
					"FetchAsynchronously": true,
				},
			},
			"Forwarding": map[string]interface{}{
				"HeaderName": "test-token",
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		jwtProvider, err := consul.NewConfigEntry(ctx, "jwt_provider", &consul.ConfigEntryArgs{
			Name:       pulumi.String("test-provider"),
			Kind:       pulumi.String("jwt-provider"),
			ConfigJson: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		_, err = consul.NewConfigEntry(ctx, "service_intentions", &consul.ConfigEntryArgs{
			Name: sd.Name,
			Kind: pulumi.String("service-intentions"),
			ConfigJson: jwtProvider.Name.ApplyT(func(name string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON2, err := json.Marshal(map[string]interface{}{
					"Sources": []interface{}{
						map[string]interface{}{
							"Name": "contractor-webapp",
							"Permissions": []map[string]interface{}{
								map[string]interface{}{
									"Action": "allow",
									"HTTP": map[string]interface{}{
										"Methods": []string{
											"GET",
											"HEAD",
										},
										"PathExact": "/healtz",
									},
									"JWT": map[string]interface{}{
										"Providers": []map[string]interface{}{
											map[string]interface{}{
												"Name": name,
											},
										},
									},
								},
							},
							"Precedence": 9,
							"Type":       "consul",
						},
						map[string]interface{}{
							"Name": "admin-dashboard-webapp",
							"Permissions": []map[string]interface{}{
								map[string]interface{}{
									"Action": "deny",
									"HTTP": map[string]interface{}{
										"PathPrefix": "/debugz",
									},
								},
								map[string]interface{}{
									"Action": "allow",
									"HTTP": map[string]interface{}{
										"PathPrefix": "/",
									},
								},
							},
							"Precedence": 9,
							"Type":       "consul",
						},
					},
				})
				if err != nil {
					return _zero, err
				}
				json2 := string(tmpJSON2)
				return pulumi.String(json2), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var sd = new Consul.ConfigEntry("sd", new()
    {
        Name = "fort-knox",
        Kind = "service-defaults",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Protocol"] = "http",
        }),
    });

    var jwtProvider = new Consul.ConfigEntry("jwt_provider", new()
    {
        Name = "test-provider",
        Kind = "jwt-provider",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Issuer"] = "test-issuer",
            ["JSONWebKeySet"] = new Dictionary<string, object?>
            {
                ["Remote"] = new Dictionary<string, object?>
                {
                    ["URI"] = "https://127.0.0.1:9091",
                    ["FetchAsynchronously"] = true,
                },
            },
            ["Forwarding"] = new Dictionary<string, object?>
            {
                ["HeaderName"] = "test-token",
            },
        }),
    });

    var serviceIntentions = new Consul.ConfigEntry("service_intentions", new()
    {
        Name = sd.Name,
        Kind = "service-intentions",
        ConfigJson = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["Sources"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Name"] = "contractor-webapp",
                    ["Permissions"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["Action"] = "allow",
                            ["HTTP"] = new Dictionary<string, object?>
                            {
                                ["Methods"] = new[]
                                {
                                    "GET",
                                    "HEAD",
                                },
                                ["PathExact"] = "/healtz",
                            },
                            ["JWT"] = new Dictionary<string, object?>
                            {
                                ["Providers"] = new[]
                                {
                                    new Dictionary<string, object?>
                                    {
                                        ["Name"] = jwtProvider.Name,
                                    },
                                },
                            },
                        },
                    },
                    ["Precedence"] = 9,
                    ["Type"] = "consul",
                },
                new Dictionary<string, object?>
                {
                    ["Name"] = "admin-dashboard-webapp",
                    ["Permissions"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["Action"] = "deny",
                            ["HTTP"] = new Dictionary<string, object?>
                            {
                                ["PathPrefix"] = "/debugz",
                            },
                        },
                        new Dictionary<string, object?>
                        {
                            ["Action"] = "allow",
                            ["HTTP"] = new Dictionary<string, object?>
                            {
                                ["PathPrefix"] = "/",
                            },
                        },
                    },
                    ["Precedence"] = 9,
                    ["Type"] = "consul",
                },
            },
        })),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.consul.ConfigEntry;
import com.pulumi.consul.ConfigEntryArgs;
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 sd = new ConfigEntry("sd", ConfigEntryArgs.builder()
            .name("fort-knox")
            .kind("service-defaults")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Protocol", "http")
                )))
            .build());

        var jwtProvider = new ConfigEntry("jwtProvider", ConfigEntryArgs.builder()
            .name("test-provider")
            .kind("jwt-provider")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Issuer", "test-issuer"),
                    jsonProperty("JSONWebKeySet", jsonObject(
                        jsonProperty("Remote", jsonObject(
                            jsonProperty("URI", "https://127.0.0.1:9091"),
                            jsonProperty("FetchAsynchronously", true)
                        ))
                    )),
                    jsonProperty("Forwarding", jsonObject(
                        jsonProperty("HeaderName", "test-token")
                    ))
                )))
            .build());

        var serviceIntentions = new ConfigEntry("serviceIntentions", ConfigEntryArgs.builder()
            .name(sd.name())
            .kind("service-intentions")
            .configJson(jwtProvider.name().applyValue(name -> serializeJson(
                jsonObject(
                    jsonProperty("Sources", jsonArray(
                        jsonObject(
                            jsonProperty("Name", "contractor-webapp"),
                            jsonProperty("Permissions", jsonArray(jsonObject(
                                jsonProperty("Action", "allow"),
                                jsonProperty("HTTP", jsonObject(
                                    jsonProperty("Methods", jsonArray(
                                        "GET", 
                                        "HEAD"
                                    )),
                                    jsonProperty("PathExact", "/healtz")
                                )),
                                jsonProperty("JWT", jsonObject(
                                    jsonProperty("Providers", jsonArray(jsonObject(
                                        jsonProperty("Name", name)
                                    )))
                                ))
                            ))),
                            jsonProperty("Precedence", 9),
                            jsonProperty("Type", "consul")
                        ), 
                        jsonObject(
                            jsonProperty("Name", "admin-dashboard-webapp"),
                            jsonProperty("Permissions", jsonArray(
                                jsonObject(
                                    jsonProperty("Action", "deny"),
                                    jsonProperty("HTTP", jsonObject(
                                        jsonProperty("PathPrefix", "/debugz")
                                    ))
                                ), 
                                jsonObject(
                                    jsonProperty("Action", "allow"),
                                    jsonProperty("HTTP", jsonObject(
                                        jsonProperty("PathPrefix", "/")
                                    ))
                                )
                            )),
                            jsonProperty("Precedence", 9),
                            jsonProperty("Type", "consul")
                        )
                    ))
                ))))
            .build());

    }
}

resources:
  sd:
    type: consul:ConfigEntry
    properties:
      name: fort-knox
      kind: service-defaults
      configJson:
        fn::toJSON:
          Protocol: http
  jwtProvider:
    type: consul:ConfigEntry
    name: jwt_provider
    properties:
      name: test-provider
      kind: jwt-provider
      configJson:
        fn::toJSON:
          Issuer: test-issuer
          JSONWebKeySet:
            Remote:
              URI: https://127.0.0.1:9091
              FetchAsynchronously: true
          Forwarding:
            HeaderName: test-token
  serviceIntentions:
    type: consul:ConfigEntry
    name: service_intentions
    properties:
      name: ${sd.name}
      kind: service-intentions
      configJson:
        fn::toJSON:
          Sources:
            - Name: contractor-webapp
              Permissions:
                - Action: allow
                  HTTP:
                    Methods:
                      - GET
                      - HEAD
                    PathExact: /healtz
                  JWT:
                    Providers:
                      - Name: ${jwtProvider.name}
              Precedence: 9
              Type: consul
            - Name: admin-dashboard-webapp
              Permissions:
                - Action: deny
                  HTTP:
                    PathPrefix: /debugz
                - Action: allow
                  HTTP:
                    PathPrefix: /
              Precedence: 9
              Type: consul

`exported-services` config entry

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

const exportedServices = new consul.ConfigEntry("exported_services", {
    name: "test",
    kind: "exported-services",
    configJson: JSON.stringify({
        Services: [{
            Name: "test",
            Namespace: "default",
            Consumers: [{
                Partition: "default",
            }],
        }],
    }),
});

import pulumi
import json
import pulumi_consul as consul

exported_services = consul.ConfigEntry("exported_services",
    name="test",
    kind="exported-services",
    config_json=json.dumps({
        "Services": [{
            "Name": "test",
            "Namespace": "default",
            "Consumers": [{
                "Partition": "default",
            }],
        }],
    }))

package main

import (
	"encoding/json"

	"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 {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Services": []map[string]interface{}{
				map[string]interface{}{
					"Name":      "test",
					"Namespace": "default",
					"Consumers": []map[string]interface{}{
						map[string]interface{}{
							"Partition": "default",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = consul.NewConfigEntry(ctx, "exported_services", &consul.ConfigEntryArgs{
			Name:       pulumi.String("test"),
			Kind:       pulumi.String("exported-services"),
			ConfigJson: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var exportedServices = new Consul.ConfigEntry("exported_services", new()
    {
        Name = "test",
        Kind = "exported-services",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Services"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Name"] = "test",
                    ["Namespace"] = "default",
                    ["Consumers"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["Partition"] = "default",
                        },
                    },
                },
            },
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.consul.ConfigEntry;
import com.pulumi.consul.ConfigEntryArgs;
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 exportedServices = new ConfigEntry("exportedServices", ConfigEntryArgs.builder()
            .name("test")
            .kind("exported-services")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Services", jsonArray(jsonObject(
                        jsonProperty("Name", "test"),
                        jsonProperty("Namespace", "default"),
                        jsonProperty("Consumers", jsonArray(jsonObject(
                            jsonProperty("Partition", "default")
                        )))
                    )))
                )))
            .build());

    }
}

resources:
  exportedServices:
    type: consul:ConfigEntry
    name: exported_services
    properties:
      name: test
      kind: exported-services
      configJson:
        fn::toJSON:
          Services:
            - Name: test
              Namespace: default
              Consumers:
                - Partition: default

`mesh` config entry

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

const mesh = new consul.ConfigEntry("mesh", {
    name: "mesh",
    kind: "mesh",
    partition: "default",
    configJson: JSON.stringify({
        TransparentProxy: {
            MeshDestinationsOnly: true,
        },
    }),
});

import pulumi
import json
import pulumi_consul as consul

mesh = consul.ConfigEntry("mesh",
    name="mesh",
    kind="mesh",
    partition="default",
    config_json=json.dumps({
        "TransparentProxy": {
            "MeshDestinationsOnly": True,
        },
    }))

package main

import (
	"encoding/json"

	"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 {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"TransparentProxy": map[string]interface{}{
				"MeshDestinationsOnly": true,
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = consul.NewConfigEntry(ctx, "mesh", &consul.ConfigEntryArgs{
			Name:       pulumi.String("mesh"),
			Kind:       pulumi.String("mesh"),
			Partition:  pulumi.String("default"),
			ConfigJson: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var mesh = new Consul.ConfigEntry("mesh", new()
    {
        Name = "mesh",
        Kind = "mesh",
        Partition = "default",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["TransparentProxy"] = new Dictionary<string, object?>
            {
                ["MeshDestinationsOnly"] = true,
            },
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.consul.ConfigEntry;
import com.pulumi.consul.ConfigEntryArgs;
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 mesh = new ConfigEntry("mesh", ConfigEntryArgs.builder()
            .name("mesh")
            .kind("mesh")
            .partition("default")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("TransparentProxy", jsonObject(
                        jsonProperty("MeshDestinationsOnly", true)
                    ))
                )))
            .build());

    }
}

resources:
  mesh:
    type: consul:ConfigEntry
    properties:
      name: mesh
      kind: mesh
      partition: default
      configJson:
        fn::toJSON:
          TransparentProxy:
            MeshDestinationsOnly: true

`jwt-provider` config entry

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

const jwtProvider = new consul.ConfigEntry("jwt_provider", {
    name: "provider-name",
    kind: "jwt-provider",
    configJson: JSON.stringify({
        Issuer: "https://your.issuer.com",
        JSONWebKeySet: {
            Remote: {
                URI: "https://your-remote.jwks.com",
                FetchAsynchronously: true,
                CacheDuration: "10s",
            },
        },
        Forwarding: {
            HeaderName: "test-token",
        },
    }),
});

import pulumi
import json
import pulumi_consul as consul

jwt_provider = consul.ConfigEntry("jwt_provider",
    name="provider-name",
    kind="jwt-provider",
    config_json=json.dumps({
        "Issuer": "https://your.issuer.com",
        "JSONWebKeySet": {
            "Remote": {
                "URI": "https://your-remote.jwks.com",
                "FetchAsynchronously": True,
                "CacheDuration": "10s",
            },
        },
        "Forwarding": {
            "HeaderName": "test-token",
        },
    }))

package main

import (
	"encoding/json"

	"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 {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Issuer": "https://your.issuer.com",
			"JSONWebKeySet": map[string]interface{}{
				"Remote": map[string]interface{}{
					"URI":                 "https://your-remote.jwks.com",
					"FetchAsynchronously": true,
					"CacheDuration":       "10s",
				},
			},
			"Forwarding": map[string]interface{}{
				"HeaderName": "test-token",
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = consul.NewConfigEntry(ctx, "jwt_provider", &consul.ConfigEntryArgs{
			Name:       pulumi.String("provider-name"),
			Kind:       pulumi.String("jwt-provider"),
			ConfigJson: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var jwtProvider = new Consul.ConfigEntry("jwt_provider", new()
    {
        Name = "provider-name",
        Kind = "jwt-provider",
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Issuer"] = "https://your.issuer.com",
            ["JSONWebKeySet"] = new Dictionary<string, object?>
            {
                ["Remote"] = new Dictionary<string, object?>
                {
                    ["URI"] = "https://your-remote.jwks.com",
                    ["FetchAsynchronously"] = true,
                    ["CacheDuration"] = "10s",
                },
            },
            ["Forwarding"] = new Dictionary<string, object?>
            {
                ["HeaderName"] = "test-token",
            },
        }),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.consul.ConfigEntry;
import com.pulumi.consul.ConfigEntryArgs;
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 jwtProvider = new ConfigEntry("jwtProvider", ConfigEntryArgs.builder()
            .name("provider-name")
            .kind("jwt-provider")
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("Issuer", "https://your.issuer.com"),
                    jsonProperty("JSONWebKeySet", jsonObject(
                        jsonProperty("Remote", jsonObject(
                            jsonProperty("URI", "https://your-remote.jwks.com"),
                            jsonProperty("FetchAsynchronously", true),
                            jsonProperty("CacheDuration", "10s")
                        ))
                    )),
                    jsonProperty("Forwarding", jsonObject(
                        jsonProperty("HeaderName", "test-token")
                    ))
                )))
            .build());

    }
}

resources:
  jwtProvider:
    type: consul:ConfigEntry
    name: jwt_provider
    properties:
      name: provider-name
      kind: jwt-provider
      configJson:
        fn::toJSON:
          Issuer: https://your.issuer.com
          JSONWebKeySet:
            Remote:
              URI: https://your-remote.jwks.com
              FetchAsynchronously: true
              CacheDuration: 10s
          Forwarding:
            HeaderName: test-token

Create ConfigEntry Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new ConfigEntry(name: string, args: ConfigEntryArgs, opts?: CustomResourceOptions);

@overload
def ConfigEntry(resource_name: str,
                args: ConfigEntryArgs,
                opts: Optional[ResourceOptions] = None)

@overload
def ConfigEntry(resource_name: str,
                opts: Optional[ResourceOptions] = None,
                kind: Optional[str] = None,
                config_json: Optional[str] = None,
                name: Optional[str] = None,
                namespace: Optional[str] = None,
                partition: Optional[str] = None)

func NewConfigEntry(ctx *Context, name string, args ConfigEntryArgs, opts ...ResourceOption) (*ConfigEntry, error)

public ConfigEntry(string name, ConfigEntryArgs args, CustomResourceOptions? opts = null)

public ConfigEntry(String name, ConfigEntryArgs args)
public ConfigEntry(String name, ConfigEntryArgs args, CustomResourceOptions options)

type: consul:ConfigEntry
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

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

resource_name str: The unique name of the resource.
args ConfigEntryArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

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

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

name String: The unique name of the resource.
args ConfigEntryArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var configEntryResource = new Consul.ConfigEntry("configEntryResource", new()
{
    Kind = "string",
    ConfigJson = "string",
    Name = "string",
    Namespace = "string",
    Partition = "string",
});

example, err := consul.NewConfigEntry(ctx, "configEntryResource", &consul.ConfigEntryArgs{
	Kind:       pulumi.String("string"),
	ConfigJson: pulumi.String("string"),
	Name:       pulumi.String("string"),
	Namespace:  pulumi.String("string"),
	Partition:  pulumi.String("string"),
})

var configEntryResource = new ConfigEntry("configEntryResource", ConfigEntryArgs.builder()
    .kind("string")
    .configJson("string")
    .name("string")
    .namespace("string")
    .partition("string")
    .build());

config_entry_resource = consul.ConfigEntry("configEntryResource",
    kind="string",
    config_json="string",
    name="string",
    namespace="string",
    partition="string")

const configEntryResource = new consul.ConfigEntry("configEntryResource", {
    kind: "string",
    configJson: "string",
    name: "string",
    namespace: "string",
    partition: "string",
});

type: consul:ConfigEntry
properties:
    configJson: string
    kind: string
    name: string
    namespace: string
    partition: string

ConfigEntry Resource Properties

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

Inputs

The ConfigEntry resource accepts the following input properties:

Kind string: The kind of configuration entry to register.
ConfigJson string: An arbitrary map of configuration values.
Name string: The name of the configuration entry being registered.
Namespace string: The namespace to create the config entry within.
Partition string: The partition the config entry is associated with.

Kind string: The kind of configuration entry to register.
ConfigJson string: An arbitrary map of configuration values.
Name string: The name of the configuration entry being registered.
Namespace string: The namespace to create the config entry within.
Partition string: The partition the config entry is associated with.

kind String: The kind of configuration entry to register.
configJson String: An arbitrary map of configuration values.
name String: The name of the configuration entry being registered.
namespace String: The namespace to create the config entry within.
partition String: The partition the config entry is associated with.

kind string: The kind of configuration entry to register.
configJson string: An arbitrary map of configuration values.
name string: The name of the configuration entry being registered.
namespace string: The namespace to create the config entry within.
partition string: The partition the config entry is associated with.

kind str: The kind of configuration entry to register.
config_json str: An arbitrary map of configuration values.
name str: The name of the configuration entry being registered.
namespace str: The namespace to create the config entry within.
partition str: The partition the config entry is associated with.

kind String: The kind of configuration entry to register.
configJson String: An arbitrary map of configuration values.
name String: The name of the configuration entry being registered.
namespace String: The namespace to create the config entry within.
partition String: The partition the config entry is associated with.

Outputs

All input properties are implicitly available as output properties. Additionally, the ConfigEntry 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 string: The provider-assigned unique ID for this managed resource.

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

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

Look up Existing ConfigEntry Resource

Get an existing ConfigEntry 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?: ConfigEntryState, opts?: CustomResourceOptions): ConfigEntry

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        config_json: Optional[str] = None,
        kind: Optional[str] = None,
        name: Optional[str] = None,
        namespace: Optional[str] = None,
        partition: Optional[str] = None) -> ConfigEntry

func GetConfigEntry(ctx *Context, name string, id IDInput, state *ConfigEntryState, opts ...ResourceOption) (*ConfigEntry, error)

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

public static ConfigEntry get(String name, Output<String> id, ConfigEntryState state, CustomResourceOptions options)

Resource lookup is not supported in YAML

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.

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:

ConfigJson string: An arbitrary map of configuration values.
Kind string: The kind of configuration entry to register.
Name string: The name of the configuration entry being registered.
Namespace string: The namespace to create the config entry within.
Partition string: The partition the config entry is associated with.

ConfigJson string: An arbitrary map of configuration values.
Kind string: The kind of configuration entry to register.
Name string: The name of the configuration entry being registered.
Namespace string: The namespace to create the config entry within.
Partition string: The partition the config entry is associated with.

configJson String: An arbitrary map of configuration values.
kind String: The kind of configuration entry to register.
name String: The name of the configuration entry being registered.
namespace String: The namespace to create the config entry within.
partition String: The partition the config entry is associated with.

configJson string: An arbitrary map of configuration values.
kind string: The kind of configuration entry to register.
name string: The name of the configuration entry being registered.
namespace string: The namespace to create the config entry within.
partition string: The partition the config entry is associated with.

config_json str: An arbitrary map of configuration values.
kind str: The kind of configuration entry to register.
name str: The name of the configuration entry being registered.
namespace str: The namespace to create the config entry within.
partition str: The partition the config entry is associated with.

configJson String: An arbitrary map of configuration values.
kind String: The kind of configuration entry to register.
name String: The name of the configuration entry being registered.
namespace String: The namespace to create the config entry within.
partition String: The partition the config entry is associated with.

Import

consul_config_entry can be imported using the syntax <kind>/<name> if the config entry is in the default partition and default namespace, or <partition>/<namespace>/<kind>/<name> for config entries in a non-default partition or namespace:

$ pulumi import consul:index/configEntry:ConfigEntry service_splitter 816a195f-6cb1-2e8d-92af-3011ae706318

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository: HashiCorp Consul pulumi/pulumi-consul
License: Apache-2.0
Notes: This Pulumi package is based on the consul Terraform Provider.

Consul v3.12.1 published on Friday, Aug 23, 2024 by Pulumi

pulumi/pulumi-consul

consul.ConfigEntry

On this page

On this page

Example Usage

`service-intentions` config entry

`exported-services` config entry

`mesh` config entry

`jwt-provider` config entry

Create ConfigEntry Resource

Constructor syntax

Parameters

Constructor example

ConfigEntry Resource Properties

Inputs

Outputs

Look up Existing ConfigEntry Resource

Import

Package Details

On this page

On this page

consul.ConfigEntry

On this page

On this page

Example Usage

service-intentions config entry

exported-services config entry

mesh config entry

jwt-provider config entry

Create ConfigEntry Resource

Constructor syntax

Parameters

Constructor example

ConfigEntry Resource Properties

Inputs

Outputs

Look up Existing ConfigEntry Resource

Import

Package Details

On this page

On this page

`service-intentions` config entry

`exported-services` config entry

`mesh` config entry

`jwt-provider` config entry