pulumi-gcp-kotlin/com.pulumi.gcp.networkservices.kotlin/GrpcRoute

GrpcRoute

class GrpcRoute : KotlinCustomResource

GrpcRoute is the resource defining how gRPC traffic routed by a Mesh or Gateway resource is routed. To get more information about GrpcRoute, see:

Example Usage

Network Services Grpc Route Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.networkservices.GrpcRoute("default", {
    name: "my-grpc-route",
    labels: {
        foo: "bar",
    },
    description: "my description",
    hostnames: ["example"],
    rules: [{
        matches: [{
            headers: [{
                key: "key",
                value: "value",
            }],
        }],
        action: {
            retryPolicy: {
                retryConditions: ["cancelled"],
                numRetries: 1,
            },
        },
    }],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.networkservices.GrpcRoute("default",
    name="my-grpc-route",
    labels={
        "foo": "bar",
    },
    description="my description",
    hostnames=["example"],
    rules=[{
        "matches": [{
            "headers": [{
                "key": "key",
                "value": "value",
            }],
        }],
        "action": {
            "retry_policy": {
                "retry_conditions": ["cancelled"],
                "num_retries": 1,
            },
        },
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.NetworkServices.GrpcRoute("default", new()
    {
        Name = "my-grpc-route",
        Labels =
        {
            { "foo", "bar" },
        },
        Description = "my description",
        Hostnames = new[]
        {
            "example",
        },
        Rules = new[]
        {
            new Gcp.NetworkServices.Inputs.GrpcRouteRuleArgs
            {
                Matches = new[]
                {
                    new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchArgs
                    {
                        Headers = new[]
                        {
                            new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchHeaderArgs
                            {
                                Key = "key",
                                Value = "value",
                            },
                        },
                    },
                },
                Action = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionArgs
                {
                    RetryPolicy = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionRetryPolicyArgs
                    {
                        RetryConditions = new[]
                        {
                            "cancelled",
                        },
                        NumRetries = 1,
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networkservices"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkservices.NewGrpcRoute(ctx, "default", &networkservices.GrpcRouteArgs{
			Name: pulumi.String("my-grpc-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.GrpcRouteRuleArray{
				&networkservices.GrpcRouteRuleArgs{
					Matches: networkservices.GrpcRouteRuleMatchArray{
						&networkservices.GrpcRouteRuleMatchArgs{
							Headers: networkservices.GrpcRouteRuleMatchHeaderArray{
								&networkservices.GrpcRouteRuleMatchHeaderArgs{
									Key:   pulumi.String("key"),
									Value: pulumi.String("value"),
								},
							},
						},
					},
					Action: &networkservices.GrpcRouteRuleActionArgs{
						RetryPolicy: &networkservices.GrpcRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("cancelled"),
							},
							NumRetries: pulumi.Int(1),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.networkservices.GrpcRoute;
import com.pulumi.gcp.networkservices.GrpcRouteArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionRetryPolicyArgs;
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 default_ = new GrpcRoute("default", GrpcRouteArgs.builder()
            .name("my-grpc-route")
            .labels(Map.of("foo", "bar"))
            .description("my description")
            .hostnames("example")
            .rules(GrpcRouteRuleArgs.builder()
                .matches(GrpcRouteRuleMatchArgs.builder()
                    .headers(GrpcRouteRuleMatchHeaderArgs.builder()
                        .key("key")
                        .value("value")
                        .build())
                    .build())
                .action(GrpcRouteRuleActionArgs.builder()
                    .retryPolicy(GrpcRouteRuleActionRetryPolicyArgs.builder()
                        .retryConditions("cancelled")
                        .numRetries(1)
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  default:
    type: gcp:networkservices:GrpcRoute
    properties:
      name: my-grpc-route
      labels:
        foo: bar
      description: my description
      hostnames:
        - example
      rules:
        - matches:
            - headers:
                - key: key
                  value: value
          action:
            retryPolicy:
              retryConditions:
                - cancelled
              numRetries: 1
Content copied to clipboard

Network Services Grpc Route Matches And Actions

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.networkservices.GrpcRoute("default", {
    name: "my-grpc-route",
    labels: {
        foo: "bar",
    },
    description: "my description",
    hostnames: ["example"],
    rules: [{
        matches: [
            {
                headers: [{
                    key: "key",
                    value: "value",
                }],
            },
            {
                headers: [{
                    key: "key",
                    value: "value",
                }],
                method: {
                    grpcService: "foo",
                    grpcMethod: "bar",
                    caseSensitive: true,
                },
            },
        ],
        action: {
            faultInjectionPolicy: {
                delay: {
                    fixedDelay: "1s",
                    percentage: 1,
                },
                abort: {
                    httpStatus: 500,
                    percentage: 1,
                },
            },
            retryPolicy: {
                retryConditions: ["cancelled"],
                numRetries: 1,
            },
        },
    }],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.networkservices.GrpcRoute("default",
    name="my-grpc-route",
    labels={
        "foo": "bar",
    },
    description="my description",
    hostnames=["example"],
    rules=[{
        "matches": [
            {
                "headers": [{
                    "key": "key",
                    "value": "value",
                }],
            },
            {
                "headers": [{
                    "key": "key",
                    "value": "value",
                }],
                "method": {
                    "grpc_service": "foo",
                    "grpc_method": "bar",
                    "case_sensitive": True,
                },
            },
        ],
        "action": {
            "fault_injection_policy": {
                "delay": {
                    "fixed_delay": "1s",
                    "percentage": 1,
                },
                "abort": {
                    "http_status": 500,
                    "percentage": 1,
                },
            },
            "retry_policy": {
                "retry_conditions": ["cancelled"],
                "num_retries": 1,
            },
        },
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.NetworkServices.GrpcRoute("default", new()
    {
        Name = "my-grpc-route",
        Labels =
        {
            { "foo", "bar" },
        },
        Description = "my description",
        Hostnames = new[]
        {
            "example",
        },
        Rules = new[]
        {
            new Gcp.NetworkServices.Inputs.GrpcRouteRuleArgs
            {
                Matches = new[]
                {
                    new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchArgs
                    {
                        Headers = new[]
                        {
                            new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchHeaderArgs
                            {
                                Key = "key",
                                Value = "value",
                            },
                        },
                    },
                    new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchArgs
                    {
                        Headers = new[]
                        {
                            new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchHeaderArgs
                            {
                                Key = "key",
                                Value = "value",
                            },
                        },
                        Method = new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchMethodArgs
                        {
                            GrpcService = "foo",
                            GrpcMethod = "bar",
                            CaseSensitive = true,
                        },
                    },
                },
                Action = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionArgs
                {
                    FaultInjectionPolicy = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionFaultInjectionPolicyArgs
                    {
                        Delay = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionFaultInjectionPolicyDelayArgs
                        {
                            FixedDelay = "1s",
                            Percentage = 1,
                        },
                        Abort = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionFaultInjectionPolicyAbortArgs
                        {
                            HttpStatus = 500,
                            Percentage = 1,
                        },
                    },
                    RetryPolicy = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionRetryPolicyArgs
                    {
                        RetryConditions = new[]
                        {
                            "cancelled",
                        },
                        NumRetries = 1,
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networkservices"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkservices.NewGrpcRoute(ctx, "default", &networkservices.GrpcRouteArgs{
			Name: pulumi.String("my-grpc-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.GrpcRouteRuleArray{
				&networkservices.GrpcRouteRuleArgs{
					Matches: networkservices.GrpcRouteRuleMatchArray{
						&networkservices.GrpcRouteRuleMatchArgs{
							Headers: networkservices.GrpcRouteRuleMatchHeaderArray{
								&networkservices.GrpcRouteRuleMatchHeaderArgs{
									Key:   pulumi.String("key"),
									Value: pulumi.String("value"),
								},
							},
						},
						&networkservices.GrpcRouteRuleMatchArgs{
							Headers: networkservices.GrpcRouteRuleMatchHeaderArray{
								&networkservices.GrpcRouteRuleMatchHeaderArgs{
									Key:   pulumi.String("key"),
									Value: pulumi.String("value"),
								},
							},
							Method: &networkservices.GrpcRouteRuleMatchMethodArgs{
								GrpcService:   pulumi.String("foo"),
								GrpcMethod:    pulumi.String("bar"),
								CaseSensitive: pulumi.Bool(true),
							},
						},
					},
					Action: &networkservices.GrpcRouteRuleActionArgs{
						FaultInjectionPolicy: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyArgs{
							Delay: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyDelayArgs{
								FixedDelay: pulumi.String("1s"),
								Percentage: pulumi.Int(1),
							},
							Abort: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyAbortArgs{
								HttpStatus: pulumi.Int(500),
								Percentage: pulumi.Int(1),
							},
						},
						RetryPolicy: &networkservices.GrpcRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("cancelled"),
							},
							NumRetries: pulumi.Int(1),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.networkservices.GrpcRoute;
import com.pulumi.gcp.networkservices.GrpcRouteArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionFaultInjectionPolicyArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionFaultInjectionPolicyDelayArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionFaultInjectionPolicyAbortArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionRetryPolicyArgs;
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 default_ = new GrpcRoute("default", GrpcRouteArgs.builder()
            .name("my-grpc-route")
            .labels(Map.of("foo", "bar"))
            .description("my description")
            .hostnames("example")
            .rules(GrpcRouteRuleArgs.builder()
                .matches(
                    GrpcRouteRuleMatchArgs.builder()
                        .headers(GrpcRouteRuleMatchHeaderArgs.builder()
                            .key("key")
                            .value("value")
                            .build())
                        .build(),
                    GrpcRouteRuleMatchArgs.builder()
                        .headers(GrpcRouteRuleMatchHeaderArgs.builder()
                            .key("key")
                            .value("value")
                            .build())
                        .method(GrpcRouteRuleMatchMethodArgs.builder()
                            .grpcService("foo")
                            .grpcMethod("bar")
                            .caseSensitive(true)
                            .build())
                        .build())
                .action(GrpcRouteRuleActionArgs.builder()
                    .faultInjectionPolicy(GrpcRouteRuleActionFaultInjectionPolicyArgs.builder()
                        .delay(GrpcRouteRuleActionFaultInjectionPolicyDelayArgs.builder()
                            .fixedDelay("1s")
                            .percentage(1)
                            .build())
                        .abort(GrpcRouteRuleActionFaultInjectionPolicyAbortArgs.builder()
                            .httpStatus(500)
                            .percentage(1)
                            .build())
                        .build())
                    .retryPolicy(GrpcRouteRuleActionRetryPolicyArgs.builder()
                        .retryConditions("cancelled")
                        .numRetries(1)
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  default:
    type: gcp:networkservices:GrpcRoute
    properties:
      name: my-grpc-route
      labels:
        foo: bar
      description: my description
      hostnames:
        - example
      rules:
        - matches:
            - headers:
                - key: key
                  value: value
            - headers:
                - key: key
                  value: value
              method:
                grpcService: foo
                grpcMethod: bar
                caseSensitive: true
          action:
            faultInjectionPolicy:
              delay:
                fixedDelay: 1s
                percentage: 1
              abort:
                httpStatus: 500
                percentage: 1
            retryPolicy:
              retryConditions:
                - cancelled
              numRetries: 1
Content copied to clipboard

Network Services Grpc Route Actions

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.networkservices.GrpcRoute("default", {
    name: "my-grpc-route",
    labels: {
        foo: "bar",
    },
    description: "my description",
    hostnames: ["example"],
    rules: [{
        action: {
            faultInjectionPolicy: {
                delay: {
                    fixedDelay: "1s",
                    percentage: 1,
                },
                abort: {
                    httpStatus: 500,
                    percentage: 1,
                },
            },
            retryPolicy: {
                retryConditions: ["cancelled"],
                numRetries: 1,
            },
        },
    }],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.networkservices.GrpcRoute("default",
    name="my-grpc-route",
    labels={
        "foo": "bar",
    },
    description="my description",
    hostnames=["example"],
    rules=[{
        "action": {
            "fault_injection_policy": {
                "delay": {
                    "fixed_delay": "1s",
                    "percentage": 1,
                },
                "abort": {
                    "http_status": 500,
                    "percentage": 1,
                },
            },
            "retry_policy": {
                "retry_conditions": ["cancelled"],
                "num_retries": 1,
            },
        },
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.NetworkServices.GrpcRoute("default", new()
    {
        Name = "my-grpc-route",
        Labels =
        {
            { "foo", "bar" },
        },
        Description = "my description",
        Hostnames = new[]
        {
            "example",
        },
        Rules = new[]
        {
            new Gcp.NetworkServices.Inputs.GrpcRouteRuleArgs
            {
                Action = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionArgs
                {
                    FaultInjectionPolicy = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionFaultInjectionPolicyArgs
                    {
                        Delay = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionFaultInjectionPolicyDelayArgs
                        {
                            FixedDelay = "1s",
                            Percentage = 1,
                        },
                        Abort = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionFaultInjectionPolicyAbortArgs
                        {
                            HttpStatus = 500,
                            Percentage = 1,
                        },
                    },
                    RetryPolicy = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionRetryPolicyArgs
                    {
                        RetryConditions = new[]
                        {
                            "cancelled",
                        },
                        NumRetries = 1,
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networkservices"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkservices.NewGrpcRoute(ctx, "default", &networkservices.GrpcRouteArgs{
			Name: pulumi.String("my-grpc-route"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.GrpcRouteRuleArray{
				&networkservices.GrpcRouteRuleArgs{
					Action: &networkservices.GrpcRouteRuleActionArgs{
						FaultInjectionPolicy: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyArgs{
							Delay: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyDelayArgs{
								FixedDelay: pulumi.String("1s"),
								Percentage: pulumi.Int(1),
							},
							Abort: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyAbortArgs{
								HttpStatus: pulumi.Int(500),
								Percentage: pulumi.Int(1),
							},
						},
						RetryPolicy: &networkservices.GrpcRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("cancelled"),
							},
							NumRetries: pulumi.Int(1),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.networkservices.GrpcRoute;
import com.pulumi.gcp.networkservices.GrpcRouteArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionFaultInjectionPolicyArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionFaultInjectionPolicyDelayArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionFaultInjectionPolicyAbortArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionRetryPolicyArgs;
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 default_ = new GrpcRoute("default", GrpcRouteArgs.builder()
            .name("my-grpc-route")
            .labels(Map.of("foo", "bar"))
            .description("my description")
            .hostnames("example")
            .rules(GrpcRouteRuleArgs.builder()
                .action(GrpcRouteRuleActionArgs.builder()
                    .faultInjectionPolicy(GrpcRouteRuleActionFaultInjectionPolicyArgs.builder()
                        .delay(GrpcRouteRuleActionFaultInjectionPolicyDelayArgs.builder()
                            .fixedDelay("1s")
                            .percentage(1)
                            .build())
                        .abort(GrpcRouteRuleActionFaultInjectionPolicyAbortArgs.builder()
                            .httpStatus(500)
                            .percentage(1)
                            .build())
                        .build())
                    .retryPolicy(GrpcRouteRuleActionRetryPolicyArgs.builder()
                        .retryConditions("cancelled")
                        .numRetries(1)
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  default:
    type: gcp:networkservices:GrpcRoute
    properties:
      name: my-grpc-route
      labels:
        foo: bar
      description: my description
      hostnames:
        - example
      rules:
        - action:
            faultInjectionPolicy:
              delay:
                fixedDelay: 1s
                percentage: 1
              abort:
                httpStatus: 500
                percentage: 1
            retryPolicy:
              retryConditions:
                - cancelled
              numRetries: 1
Content copied to clipboard

Network Services Grpc Route Location

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.networkservices.GrpcRoute("default", {
    name: "my-grpc-route",
    location: "global",
    hostnames: ["example"],
    rules: [{
        matches: [{
            headers: [{
                key: "key",
                value: "value",
            }],
        }],
        action: {
            retryPolicy: {
                retryConditions: ["cancelled"],
                numRetries: 1,
            },
        },
    }],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.networkservices.GrpcRoute("default",
    name="my-grpc-route",
    location="global",
    hostnames=["example"],
    rules=[{
        "matches": [{
            "headers": [{
                "key": "key",
                "value": "value",
            }],
        }],
        "action": {
            "retry_policy": {
                "retry_conditions": ["cancelled"],
                "num_retries": 1,
            },
        },
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.NetworkServices.GrpcRoute("default", new()
    {
        Name = "my-grpc-route",
        Location = "global",
        Hostnames = new[]
        {
            "example",
        },
        Rules = new[]
        {
            new Gcp.NetworkServices.Inputs.GrpcRouteRuleArgs
            {
                Matches = new[]
                {
                    new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchArgs
                    {
                        Headers = new[]
                        {
                            new Gcp.NetworkServices.Inputs.GrpcRouteRuleMatchHeaderArgs
                            {
                                Key = "key",
                                Value = "value",
                            },
                        },
                    },
                },
                Action = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionArgs
                {
                    RetryPolicy = new Gcp.NetworkServices.Inputs.GrpcRouteRuleActionRetryPolicyArgs
                    {
                        RetryConditions = new[]
                        {
                            "cancelled",
                        },
                        NumRetries = 1,
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networkservices"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkservices.NewGrpcRoute(ctx, "default", &networkservices.GrpcRouteArgs{
			Name:     pulumi.String("my-grpc-route"),
			Location: pulumi.String("global"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.GrpcRouteRuleArray{
				&networkservices.GrpcRouteRuleArgs{
					Matches: networkservices.GrpcRouteRuleMatchArray{
						&networkservices.GrpcRouteRuleMatchArgs{
							Headers: networkservices.GrpcRouteRuleMatchHeaderArray{
								&networkservices.GrpcRouteRuleMatchHeaderArgs{
									Key:   pulumi.String("key"),
									Value: pulumi.String("value"),
								},
							},
						},
					},
					Action: &networkservices.GrpcRouteRuleActionArgs{
						RetryPolicy: &networkservices.GrpcRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("cancelled"),
							},
							NumRetries: pulumi.Int(1),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.networkservices.GrpcRoute;
import com.pulumi.gcp.networkservices.GrpcRouteArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionArgs;
import com.pulumi.gcp.networkservices.inputs.GrpcRouteRuleActionRetryPolicyArgs;
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 default_ = new GrpcRoute("default", GrpcRouteArgs.builder()
            .name("my-grpc-route")
            .location("global")
            .hostnames("example")
            .rules(GrpcRouteRuleArgs.builder()
                .matches(GrpcRouteRuleMatchArgs.builder()
                    .headers(GrpcRouteRuleMatchHeaderArgs.builder()
                        .key("key")
                        .value("value")
                        .build())
                    .build())
                .action(GrpcRouteRuleActionArgs.builder()
                    .retryPolicy(GrpcRouteRuleActionRetryPolicyArgs.builder()
                        .retryConditions("cancelled")
                        .numRetries(1)
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  default:
    type: gcp:networkservices:GrpcRoute
    properties:
      name: my-grpc-route
      location: global
      hostnames:
        - example
      rules:
        - matches:
            - headers:
                - key: key
                  value: value
          action:
            retryPolicy:
              retryConditions:
                - cancelled
              numRetries: 1
Content copied to clipboard

Import

GrpcRoute can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/grpcRoutes/{{name}}

  • {{project}}/{{location}}/{{name}}

  • {{location}}/{{name}} When using the pulumi import command, GrpcRoute can be imported using one of the formats above. For example:

$ pulumi import gcp:networkservices/grpcRoute:GrpcRoute default projects/{{project}}/locations/{{location}}/grpcRoutes/{{name}}
Content copied to clipboard
$ pulumi import gcp:networkservices/grpcRoute:GrpcRoute default {{project}}/{{location}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:networkservices/grpcRoute:GrpcRoute default {{location}}/{{name}}
Content copied to clipboard

Properties

Link copied to clipboard
val createTime: Output<String>

Time the GrpcRoute was created in UTC.

Link copied to clipboard
val description: Output<String>?

A free-text description of the resource. Max length 1024 characters.

Link copied to clipboard
val effectiveLabels: Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

Link copied to clipboard
val gateways: Output<List<String>>?

List of gateways this GrpcRoute is attached to, as one of the routing rules to route the requests served by the gateway.

Link copied to clipboard
val hostnames: Output<List<String>>

Required. Service hostnames with an optional port for which this route describes traffic.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val labels: Output<Map<String, String>>?

Set of label tags associated with the GrpcRoute resource. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field 'effective_labels' for all of the labels present on the resource.

Link copied to clipboard
val location: Output<String>?

Location (region) of the GRPCRoute resource to be created. Only the value 'global' is currently allowed; defaults to 'global' if omitted.

Link copied to clipboard
val meshes: Output<List<String>>?

List of meshes this GrpcRoute is attached to, as one of the routing rules to route the requests served by the mesh.

Link copied to clipboard
val name: Output<String>

Name of the GrpcRoute resource.

Link copied to clipboard
val project: Output<String>
Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
val pulumiLabels: Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val rules: Output<List<GrpcRouteRule>>

Rules that define how traffic is routed and handled. Structure is documented below.

Link copied to clipboard
val selfLink: Output<String>

Server-defined URL of this resource.

Link copied to clipboard
val updateTime: Output<String>

Time the GrpcRoute was updated in UTC.

Link copied to clipboard
val urn: Output<String>