azure-native.servicefabricmesh.Gateway

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

return await Deployment.RunAsync(() => 
{
    var gateway = new AzureNative.ServiceFabricMesh.Gateway("gateway", new()
    {
        Description = "Service Fabric Mesh sample gateway.",
        DestinationNetwork = new AzureNative.ServiceFabricMesh.Inputs.NetworkRefArgs
        {
            Name = "helloWorldNetwork",
        },
        GatewayResourceName = "sampleGateway",
        Http = new[]
        {
            new AzureNative.ServiceFabricMesh.Inputs.HttpConfigArgs
            {
                Hosts = new[]
                {
                    new AzureNative.ServiceFabricMesh.Inputs.HttpHostConfigArgs
                    {
                        Name = "contoso.com",
                        Routes = new[]
                        {
                            new AzureNative.ServiceFabricMesh.Inputs.HttpRouteConfigArgs
                            {
                                Destination = new AzureNative.ServiceFabricMesh.Inputs.GatewayDestinationArgs
                                {
                                    ApplicationName = "httpHelloWorldApp",
                                    EndpointName = "indexHttpEndpoint",
                                    ServiceName = "indexService",
                                },
                                Match = new AzureNative.ServiceFabricMesh.Inputs.HttpRouteMatchRuleArgs
                                {
                                    Headers = new[]
                                    {
                                        new AzureNative.ServiceFabricMesh.Inputs.HttpRouteMatchHeaderArgs
                                        {
                                            Name = "accept",
                                            Type = AzureNative.ServiceFabricMesh.HeaderMatchType.Exact,
                                            Value = "application/json",
                                        },
                                    },
                                    Path = new AzureNative.ServiceFabricMesh.Inputs.HttpRouteMatchPathArgs
                                    {
                                        Rewrite = "/",
                                        Type = AzureNative.ServiceFabricMesh.PathMatchType.Prefix,
                                        Value = "/index",
                                    },
                                },
                                Name = "index",
                            },
                        },
                    },
                },
                Name = "contosoWebsite",
                Port = 8081,
            },
        },
        Location = "EastUS",
        ResourceGroupName = "sbz_demo",
        SourceNetwork = new AzureNative.ServiceFabricMesh.Inputs.NetworkRefArgs
        {
            Name = "Open",
        },
        Tags = null,
        Tcp = new[]
        {
            new AzureNative.ServiceFabricMesh.Inputs.TcpConfigArgs
            {
                Destination = new AzureNative.ServiceFabricMesh.Inputs.GatewayDestinationArgs
                {
                    ApplicationName = "helloWorldApp",
                    EndpointName = "helloWorldListener",
                    ServiceName = "helloWorldService",
                },
                Name = "web",
                Port = 80,
            },
        },
    });

});

package main

import (
	servicefabricmesh "github.com/pulumi/pulumi-azure-native-sdk/servicefabricmesh/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := servicefabricmesh.NewGateway(ctx, "gateway", &servicefabricmesh.GatewayArgs{
			Description: pulumi.String("Service Fabric Mesh sample gateway."),
			DestinationNetwork: &servicefabricmesh.NetworkRefArgs{
				Name: pulumi.String("helloWorldNetwork"),
			},
			GatewayResourceName: pulumi.String("sampleGateway"),
			Http: servicefabricmesh.HttpConfigArray{
				&servicefabricmesh.HttpConfigArgs{
					Hosts: servicefabricmesh.HttpHostConfigArray{
						&servicefabricmesh.HttpHostConfigArgs{
							Name: pulumi.String("contoso.com"),
							Routes: servicefabricmesh.HttpRouteConfigArray{
								&servicefabricmesh.HttpRouteConfigArgs{
									Destination: &servicefabricmesh.GatewayDestinationArgs{
										ApplicationName: pulumi.String("httpHelloWorldApp"),
										EndpointName:    pulumi.String("indexHttpEndpoint"),
										ServiceName:     pulumi.String("indexService"),
									},
									Match: &servicefabricmesh.HttpRouteMatchRuleArgs{
										Headers: servicefabricmesh.HttpRouteMatchHeaderArray{
											&servicefabricmesh.HttpRouteMatchHeaderArgs{
												Name:  pulumi.String("accept"),
												Type:  pulumi.String(servicefabricmesh.HeaderMatchTypeExact),
												Value: pulumi.String("application/json"),
											},
										},
										Path: &servicefabricmesh.HttpRouteMatchPathArgs{
											Rewrite: pulumi.String("/"),
											Type:    pulumi.String(servicefabricmesh.PathMatchTypePrefix),
											Value:   pulumi.String("/index"),
										},
									},
									Name: pulumi.String("index"),
								},
							},
						},
					},
					Name: pulumi.String("contosoWebsite"),
					Port: pulumi.Int(8081),
				},
			},
			Location:          pulumi.String("EastUS"),
			ResourceGroupName: pulumi.String("sbz_demo"),
			SourceNetwork: &servicefabricmesh.NetworkRefArgs{
				Name: pulumi.String("Open"),
			},
			Tags: nil,
			Tcp: servicefabricmesh.TcpConfigArray{
				&servicefabricmesh.TcpConfigArgs{
					Destination: &servicefabricmesh.GatewayDestinationArgs{
						ApplicationName: pulumi.String("helloWorldApp"),
						EndpointName:    pulumi.String("helloWorldListener"),
						ServiceName:     pulumi.String("helloWorldService"),
					},
					Name: pulumi.String("web"),
					Port: pulumi.Int(80),
				},
			},
		})
		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.azurenative.servicefabricmesh.Gateway;
import com.pulumi.azurenative.servicefabricmesh.GatewayArgs;
import com.pulumi.azurenative.servicefabricmesh.inputs.NetworkRefArgs;
import com.pulumi.azurenative.servicefabricmesh.inputs.HttpConfigArgs;
import com.pulumi.azurenative.servicefabricmesh.inputs.TcpConfigArgs;
import com.pulumi.azurenative.servicefabricmesh.inputs.GatewayDestinationArgs;
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 gateway = new Gateway("gateway", GatewayArgs.builder()
            .description("Service Fabric Mesh sample gateway.")
            .destinationNetwork(NetworkRefArgs.builder()
                .name("helloWorldNetwork")
                .build())
            .gatewayResourceName("sampleGateway")
            .http(HttpConfigArgs.builder()
                .hosts(HttpHostConfigArgs.builder()
                    .name("contoso.com")
                    .routes(HttpRouteConfigArgs.builder()
                        .destination(GatewayDestinationArgs.builder()
                            .applicationName("httpHelloWorldApp")
                            .endpointName("indexHttpEndpoint")
                            .serviceName("indexService")
                            .build())
                        .match(HttpRouteMatchRuleArgs.builder()
                            .headers(HttpRouteMatchHeaderArgs.builder()
                                .name("accept")
                                .type("exact")
                                .value("application/json")
                                .build())
                            .path(HttpRouteMatchPathArgs.builder()
                                .rewrite("/")
                                .type("prefix")
                                .value("/index")
                                .build())
                            .build())
                        .name("index")
                        .build())
                    .build())
                .name("contosoWebsite")
                .port(8081)
                .build())
            .location("EastUS")
            .resourceGroupName("sbz_demo")
            .sourceNetwork(NetworkRefArgs.builder()
                .name("Open")
                .build())
            .tags()
            .tcp(TcpConfigArgs.builder()
                .destination(GatewayDestinationArgs.builder()
                    .applicationName("helloWorldApp")
                    .endpointName("helloWorldListener")
                    .serviceName("helloWorldService")
                    .build())
                .name("web")
                .port(80)
                .build())
            .build());

    }
}

import pulumi
import pulumi_azure_native as azure_native

gateway = azure_native.servicefabricmesh.Gateway("gateway",
    description="Service Fabric Mesh sample gateway.",
    destination_network=azure_native.servicefabricmesh.NetworkRefArgs(
        name="helloWorldNetwork",
    ),
    gateway_resource_name="sampleGateway",
    http=[azure_native.servicefabricmesh.HttpConfigArgs(
        hosts=[azure_native.servicefabricmesh.HttpHostConfigArgs(
            name="contoso.com",
            routes=[azure_native.servicefabricmesh.HttpRouteConfigArgs(
                destination=azure_native.servicefabricmesh.GatewayDestinationArgs(
                    application_name="httpHelloWorldApp",
                    endpoint_name="indexHttpEndpoint",
                    service_name="indexService",
                ),
                match=azure_native.servicefabricmesh.HttpRouteMatchRuleArgs(
                    headers=[azure_native.servicefabricmesh.HttpRouteMatchHeaderArgs(
                        name="accept",
                        type=azure_native.servicefabricmesh.HeaderMatchType.EXACT,
                        value="application/json",
                    )],
                    path=azure_native.servicefabricmesh.HttpRouteMatchPathArgs(
                        rewrite="/",
                        type=azure_native.servicefabricmesh.PathMatchType.PREFIX,
                        value="/index",
                    ),
                ),
                name="index",
            )],
        )],
        name="contosoWebsite",
        port=8081,
    )],
    location="EastUS",
    resource_group_name="sbz_demo",
    source_network=azure_native.servicefabricmesh.NetworkRefArgs(
        name="Open",
    ),
    tags={},
    tcp=[azure_native.servicefabricmesh.TcpConfigArgs(
        destination=azure_native.servicefabricmesh.GatewayDestinationArgs(
            application_name="helloWorldApp",
            endpoint_name="helloWorldListener",
            service_name="helloWorldService",
        ),
        name="web",
        port=80,
    )])

import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const gateway = new azure_native.servicefabricmesh.Gateway("gateway", {
    description: "Service Fabric Mesh sample gateway.",
    destinationNetwork: {
        name: "helloWorldNetwork",
    },
    gatewayResourceName: "sampleGateway",
    http: [{
        hosts: [{
            name: "contoso.com",
            routes: [{
                destination: {
                    applicationName: "httpHelloWorldApp",
                    endpointName: "indexHttpEndpoint",
                    serviceName: "indexService",
                },
                match: {
                    headers: [{
                        name: "accept",
                        type: azure_native.servicefabricmesh.HeaderMatchType.Exact,
                        value: "application/json",
                    }],
                    path: {
                        rewrite: "/",
                        type: azure_native.servicefabricmesh.PathMatchType.Prefix,
                        value: "/index",
                    },
                },
                name: "index",
            }],
        }],
        name: "contosoWebsite",
        port: 8081,
    }],
    location: "EastUS",
    resourceGroupName: "sbz_demo",
    sourceNetwork: {
        name: "Open",
    },
    tags: {},
    tcp: [{
        destination: {
            applicationName: "helloWorldApp",
            endpointName: "helloWorldListener",
            serviceName: "helloWorldService",
        },
        name: "web",
        port: 80,
    }],
});

resources:
  gateway:
    type: azure-native:servicefabricmesh:Gateway
    properties:
      description: Service Fabric Mesh sample gateway.
      destinationNetwork:
        name: helloWorldNetwork
      gatewayResourceName: sampleGateway
      http:
        - hosts:
            - name: contoso.com
              routes:
                - destination:
                    applicationName: httpHelloWorldApp
                    endpointName: indexHttpEndpoint
                    serviceName: indexService
                  match:
                    headers:
                      - name: accept
                        type: exact
                        value: application/json
                    path:
                      rewrite: /
                      type: prefix
                      value: /index
                  name: index
          name: contosoWebsite
          port: 8081
      location: EastUS
      resourceGroupName: sbz_demo
      sourceNetwork:
        name: Open
      tags: {}
      tcp:
        - destination:
            applicationName: helloWorldApp
            endpointName: helloWorldListener
            serviceName: helloWorldService
          name: web
          port: 80