1. Packages
  2. HashiCorp Consul
  3. API Docs
  4. ConfigEntry
Consul v3.11.0 published on Monday, Nov 20, 2023 by Pulumi

consul.ConfigEntry

Explore with Pulumi AI

consul logo
Consul v3.11.0 published on Monday, Nov 20, 2023 by Pulumi

    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
    

    Example Usage

    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("proxyDefaults", new()
        {
            Kind = "proxy-defaults",
            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()
        {
            Kind = "service-defaults",
            ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["Protocol"] = "http",
            }),
        });
    
        var admin = new Consul.ConfigEntry("admin", new()
        {
            Kind = "service-defaults",
            ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["Protocol"] = "http",
            }),
        });
    
        var serviceResolver = new Consul.ConfigEntry("serviceResolver", new()
        {
            Kind = "service-resolver",
            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("serviceSplitter", new()
        {
            Kind = "service-splitter",
            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("serviceRouter", new()
        {
            Kind = "service-router",
            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("ingressGateway", new()
        {
            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("terminatingGateway", new()
        {
            Kind = "terminating-gateway",
            ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["Services"] = new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["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, "proxyDefaults", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("proxy-defaults"),
    			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)
    		_, err = consul.NewConfigEntry(ctx, "web", &consul.ConfigEntryArgs{
    			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{
    			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)
    		_, err = consul.NewConfigEntry(ctx, "serviceResolver", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("service-resolver"),
    			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, "serviceSplitter", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("service-splitter"),
    			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, "serviceRouter", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("service-router"),
    			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, "ingressGateway", &consul.ConfigEntryArgs{
    			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, "terminatingGateway", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("terminating-gateway"),
    			ConfigJson: pulumi.String(json7),
    		})
    		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.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")
                .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()        
                .kind("service-defaults")
                .configJson(serializeJson(
                    jsonObject(
                        jsonProperty("Protocol", "http")
                    )))
                .build());
    
            var admin = new ConfigEntry("admin", ConfigEntryArgs.builder()        
                .kind("service-defaults")
                .configJson(serializeJson(
                    jsonObject(
                        jsonProperty("Protocol", "http")
                    )))
                .build());
    
            var serviceResolver = new ConfigEntry("serviceResolver", ConfigEntryArgs.builder()        
                .kind("service-resolver")
                .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")
                .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")
                .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()        
                .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()        
                .kind("terminating-gateway")
                .configJson(serializeJson(
                    jsonObject(
                        jsonProperty("Services", jsonArray(jsonObject(
                            jsonProperty("Name", "billing")
                        )))
                    )))
                .build());
    
        }
    }
    
    import pulumi
    import json
    import pulumi_consul as consul
    
    proxy_defaults = consul.ConfigEntry("proxyDefaults",
        kind="proxy-defaults",
        config_json=json.dumps({
            "Config": {
                "local_connect_timeout_ms": 1000,
                "handshake_timeout_ms": 10000,
            },
        }))
    web = consul.ConfigEntry("web",
        kind="service-defaults",
        config_json=json.dumps({
            "Protocol": "http",
        }))
    admin = consul.ConfigEntry("admin",
        kind="service-defaults",
        config_json=json.dumps({
            "Protocol": "http",
        }))
    service_resolver = consul.ConfigEntry("serviceResolver",
        kind="service-resolver",
        config_json=json.dumps({
            "DefaultSubset": "v1",
            "Subsets": {
                "v1": {
                    "Filter": "Service.Meta.version == v1",
                },
                "v2": {
                    "Filter": "Service.Meta.version == v2",
                },
            },
        }))
    service_splitter = consul.ConfigEntry("serviceSplitter",
        kind="service-splitter",
        config_json=json.dumps({
            "Splits": [
                {
                    "Weight": 90,
                    "ServiceSubset": "v1",
                },
                {
                    "Weight": 10,
                    "ServiceSubset": "v2",
                },
            ],
        }))
    service_router = consul.ConfigEntry("serviceRouter",
        kind="service-router",
        config_json=json.dumps({
            "Routes": [{
                "Match": {
                    "HTTP": {
                        "PathPrefix": "/admin",
                    },
                },
                "Destination": {
                    "Service": "admin",
                },
            }],
        }))
    ingress_gateway = consul.ConfigEntry("ingressGateway",
        kind="ingress-gateway",
        config_json=json.dumps({
            "TLS": {
                "Enabled": True,
            },
            "Listeners": [{
                "Port": 8000,
                "Protocol": "http",
                "Services": [{
                    "Name": "*",
                }],
            }],
        }))
    terminating_gateway = consul.ConfigEntry("terminatingGateway",
        kind="terminating-gateway",
        config_json=json.dumps({
            "Services": [{
                "Name": "billing",
            }],
        }))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as consul from "@pulumi/consul";
    
    const proxyDefaults = new consul.ConfigEntry("proxyDefaults", {
        kind: "proxy-defaults",
        configJson: JSON.stringify({
            Config: {
                local_connect_timeout_ms: 1000,
                handshake_timeout_ms: 10000,
            },
        }),
    });
    const web = new consul.ConfigEntry("web", {
        kind: "service-defaults",
        configJson: JSON.stringify({
            Protocol: "http",
        }),
    });
    const admin = new consul.ConfigEntry("admin", {
        kind: "service-defaults",
        configJson: JSON.stringify({
            Protocol: "http",
        }),
    });
    const serviceResolver = new consul.ConfigEntry("serviceResolver", {
        kind: "service-resolver",
        configJson: JSON.stringify({
            DefaultSubset: "v1",
            Subsets: {
                v1: {
                    Filter: "Service.Meta.version == v1",
                },
                v2: {
                    Filter: "Service.Meta.version == v2",
                },
            },
        }),
    });
    const serviceSplitter = new consul.ConfigEntry("serviceSplitter", {
        kind: "service-splitter",
        configJson: JSON.stringify({
            Splits: [
                {
                    Weight: 90,
                    ServiceSubset: "v1",
                },
                {
                    Weight: 10,
                    ServiceSubset: "v2",
                },
            ],
        }),
    });
    const serviceRouter = new consul.ConfigEntry("serviceRouter", {
        kind: "service-router",
        configJson: JSON.stringify({
            Routes: [{
                Match: {
                    HTTP: {
                        PathPrefix: "/admin",
                    },
                },
                Destination: {
                    Service: "admin",
                },
            }],
        }),
    });
    const ingressGateway = new consul.ConfigEntry("ingressGateway", {
        kind: "ingress-gateway",
        configJson: JSON.stringify({
            TLS: {
                Enabled: true,
            },
            Listeners: [{
                Port: 8000,
                Protocol: "http",
                Services: [{
                    Name: "*",
                }],
            }],
        }),
    });
    const terminatingGateway = new consul.ConfigEntry("terminatingGateway", {
        kind: "terminating-gateway",
        configJson: JSON.stringify({
            Services: [{
                Name: "billing",
            }],
        }),
    });
    
    resources:
      proxyDefaults:
        type: consul:ConfigEntry
        properties:
          kind: proxy-defaults
          configJson:
            fn::toJSON:
              Config:
                local_connect_timeout_ms: 1000
                handshake_timeout_ms: 10000
      web:
        type: consul:ConfigEntry
        properties:
          kind: service-defaults
          configJson:
            fn::toJSON:
              Protocol: http
      admin:
        type: consul:ConfigEntry
        properties:
          kind: service-defaults
          configJson:
            fn::toJSON:
              Protocol: http
      serviceResolver:
        type: consul:ConfigEntry
        properties:
          kind: service-resolver
          configJson:
            fn::toJSON:
              DefaultSubset: v1
              Subsets:
                v1:
                  Filter: Service.Meta.version == v1
                v2:
                  Filter: Service.Meta.version == v2
      serviceSplitter:
        type: consul:ConfigEntry
        properties:
          kind: service-splitter
          configJson:
            fn::toJSON:
              Splits:
                - Weight: 90
                  ServiceSubset: v1
                - Weight: 10
                  ServiceSubset: v2
      serviceRouter:
        type: consul:ConfigEntry
        properties:
          kind: service-router
          configJson:
            fn::toJSON:
              Routes:
                - Match:
                    HTTP:
                      PathPrefix: /admin
                  Destination:
                    Service: admin
      ingressGateway:
        type: consul:ConfigEntry
        properties:
          kind: ingress-gateway
          configJson:
            fn::toJSON:
              TLS:
                Enabled: true
              Listeners:
                - Port: 8000
                  Protocol: http
                  Services:
                    - Name: '*'
      terminatingGateway:
        type: consul:ConfigEntry
        properties:
          kind: terminating-gateway
          configJson:
            fn::toJSON:
              Services:
                - Name: billing
    

    service-intentions config entry

    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("serviceIntentions", new()
        {
            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 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, "serviceIntentions", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("service-intentions"),
    			ConfigJson: pulumi.String(json0),
    		})
    		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.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()        
                .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());
    
        }
    }
    
    import pulumi
    import json
    import pulumi_consul as consul
    
    service_intentions = consul.ConfigEntry("serviceIntentions",
        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",
                },
            ],
        }))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as consul from "@pulumi/consul";
    
    const serviceIntentions = new consul.ConfigEntry("serviceIntentions", {
        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",
                },
            ],
        }),
    });
    
    resources:
      serviceIntentions:
        type: consul:ConfigEntry
        properties:
          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
    
    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()
        {
            Kind = "service-defaults",
            ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["Protocol"] = "http",
            }),
        });
    
        var jwtProvider = new Consul.ConfigEntry("jwtProvider", new()
        {
            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("serviceIntentions", new()
        {
            Kind = "service-intentions",
            ConfigJson = jwtProvider.Name.Apply(name => JsonSerializer.Serialize(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"] = 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 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)
    		_, err = consul.NewConfigEntry(ctx, "sd", &consul.ConfigEntryArgs{
    			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, "jwtProvider", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("jwt-provider"),
    			ConfigJson: pulumi.String(json1),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = consul.NewConfigEntry(ctx, "serviceIntentions", &consul.ConfigEntryArgs{
    			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
    	})
    }
    
    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()        
                .kind("service-defaults")
                .configJson(serializeJson(
                    jsonObject(
                        jsonProperty("Protocol", "http")
                    )))
                .build());
    
            var jwtProvider = new ConfigEntry("jwtProvider", ConfigEntryArgs.builder()        
                .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()        
                .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());
    
        }
    }
    
    import pulumi
    import json
    import pulumi_consul as consul
    
    sd = consul.ConfigEntry("sd",
        kind="service-defaults",
        config_json=json.dumps({
            "Protocol": "http",
        }))
    jwt_provider = consul.ConfigEntry("jwtProvider",
        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("serviceIntentions",
        kind="service-intentions",
        config_json=jwt_provider.name.apply(lambda name: json.dumps({
            "Sources": [
                {
                    "Name": "contractor-webapp",
                    "Permissions": [{
                        "Action": "allow",
                        "HTTP": {
                            "Methods": [
                                "GET",
                                "HEAD",
                            ],
                            "PathExact": "/healtz",
                        },
                        "JWT": {
                            "Providers": [{
                                "Name": name,
                            }],
                        },
                    }],
                    "Precedence": 9,
                    "Type": "consul",
                },
                {
                    "Name": "admin-dashboard-webapp",
                    "Permissions": [
                        {
                            "Action": "deny",
                            "HTTP": {
                                "PathPrefix": "/debugz",
                            },
                        },
                        {
                            "Action": "allow",
                            "HTTP": {
                                "PathPrefix": "/",
                            },
                        },
                    ],
                    "Precedence": 9,
                    "Type": "consul",
                },
            ],
        })))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as consul from "@pulumi/consul";
    
    const sd = new consul.ConfigEntry("sd", {
        kind: "service-defaults",
        configJson: JSON.stringify({
            Protocol: "http",
        }),
    });
    const jwtProvider = new consul.ConfigEntry("jwtProvider", {
        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("serviceIntentions", {
        kind: "service-intentions",
        configJson: jwtProvider.name.apply(name => JSON.stringify({
            Sources: [
                {
                    Name: "contractor-webapp",
                    Permissions: [{
                        Action: "allow",
                        HTTP: {
                            Methods: [
                                "GET",
                                "HEAD",
                            ],
                            PathExact: "/healtz",
                        },
                        JWT: {
                            Providers: [{
                                Name: name,
                            }],
                        },
                    }],
                    Precedence: 9,
                    Type: "consul",
                },
                {
                    Name: "admin-dashboard-webapp",
                    Permissions: [
                        {
                            Action: "deny",
                            HTTP: {
                                PathPrefix: "/debugz",
                            },
                        },
                        {
                            Action: "allow",
                            HTTP: {
                                PathPrefix: "/",
                            },
                        },
                    ],
                    Precedence: 9,
                    Type: "consul",
                },
            ],
        })),
    });
    
    resources:
      sd:
        type: consul:ConfigEntry
        properties:
          kind: service-defaults
          configJson:
            fn::toJSON:
              Protocol: http
      jwtProvider:
        type: consul:ConfigEntry
        properties:
          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
        properties:
          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

    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("exportedServices", new()
        {
            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 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, "exportedServices", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("exported-services"),
    			ConfigJson: pulumi.String(json0),
    		})
    		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.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()        
                .kind("exported-services")
                .configJson(serializeJson(
                    jsonObject(
                        jsonProperty("Services", jsonArray(jsonObject(
                            jsonProperty("Name", "test"),
                            jsonProperty("Namespace", "default"),
                            jsonProperty("Consumers", jsonArray(jsonObject(
                                jsonProperty("Partition", "default")
                            )))
                        )))
                    )))
                .build());
    
        }
    }
    
    import pulumi
    import json
    import pulumi_consul as consul
    
    exported_services = consul.ConfigEntry("exportedServices",
        kind="exported-services",
        config_json=json.dumps({
            "Services": [{
                "Name": "test",
                "Namespace": "default",
                "Consumers": [{
                    "Partition": "default",
                }],
            }],
        }))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as consul from "@pulumi/consul";
    
    const exportedServices = new consul.ConfigEntry("exportedServices", {
        kind: "exported-services",
        configJson: JSON.stringify({
            Services: [{
                Name: "test",
                Namespace: "default",
                Consumers: [{
                    Partition: "default",
                }],
            }],
        }),
    });
    
    resources:
      exportedServices:
        type: consul:ConfigEntry
        properties:
          kind: exported-services
          configJson:
            fn::toJSON:
              Services:
                - Name: test
                  Namespace: default
                  Consumers:
                    - Partition: default
    

    mesh config entry

    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()
        {
            Kind = "mesh",
            Partition = "default",
            ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["TransparentProxy"] = new Dictionary<string, object?>
                {
                    ["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{
    			Kind:       pulumi.String("mesh"),
    			Partition:  pulumi.String("default"),
    			ConfigJson: pulumi.String(json0),
    		})
    		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.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()        
                .kind("mesh")
                .partition("default")
                .configJson(serializeJson(
                    jsonObject(
                        jsonProperty("TransparentProxy", jsonObject(
                            jsonProperty("MeshDestinationsOnly", true)
                        ))
                    )))
                .build());
    
        }
    }
    
    import pulumi
    import json
    import pulumi_consul as consul
    
    mesh = consul.ConfigEntry("mesh",
        kind="mesh",
        partition="default",
        config_json=json.dumps({
            "TransparentProxy": {
                "MeshDestinationsOnly": True,
            },
        }))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as consul from "@pulumi/consul";
    
    const mesh = new consul.ConfigEntry("mesh", {
        kind: "mesh",
        partition: "default",
        configJson: JSON.stringify({
            TransparentProxy: {
                MeshDestinationsOnly: true,
            },
        }),
    });
    
    resources:
      mesh:
        type: consul:ConfigEntry
        properties:
          kind: mesh
          partition: default
          configJson:
            fn::toJSON:
              TransparentProxy:
                MeshDestinationsOnly: true
    

    jwt-provider config entry

    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("jwtProvider", new()
        {
            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 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, "jwtProvider", &consul.ConfigEntryArgs{
    			Kind:       pulumi.String("jwt-provider"),
    			ConfigJson: pulumi.String(json0),
    		})
    		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.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()        
                .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());
    
        }
    }
    
    import pulumi
    import json
    import pulumi_consul as consul
    
    jwt_provider = consul.ConfigEntry("jwtProvider",
        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",
            },
        }))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as consul from "@pulumi/consul";
    
    const jwtProvider = new consul.ConfigEntry("jwtProvider", {
        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",
            },
        }),
    });
    
    resources:
      jwtProvider:
        type: consul:ConfigEntry
        properties:
          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

    new ConfigEntry(name: string, args: ConfigEntryArgs, opts?: CustomResourceOptions);
    @overload
    def ConfigEntry(resource_name: 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)
    @overload
    def ConfigEntry(resource_name: str,
                    args: ConfigEntryArgs,
                    opts: Optional[ResourceOptions] = 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.
    
    
    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.

    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.

    Package Details

    Repository
    HashiCorp Consul pulumi/pulumi-consul
    License
    Apache-2.0
    Notes

    This Pulumi package is based on the consul Terraform Provider.

    consul logo
    Consul v3.11.0 published on Monday, Nov 20, 2023 by Pulumi