1. Packages
  2. Google Cloud (GCP) Classic
  3. API Docs
  4. compute
  5. TargetGrpcProxy
Google Cloud Classic v7.29.0 published on Wednesday, Jun 26, 2024 by Pulumi

gcp.compute.TargetGrpcProxy

Explore with Pulumi AI

gcp logo
Google Cloud Classic v7.29.0 published on Wednesday, Jun 26, 2024 by Pulumi

    Represents a Target gRPC Proxy resource. A target gRPC proxy is a component of load balancers intended for load balancing gRPC traffic. Global forwarding rules reference a target gRPC proxy. The Target gRPC Proxy references a URL map which specifies how traffic routes to gRPC backend services.

    To get more information about TargetGrpcProxy, see:

    Example Usage

    Target Grpc Proxy Basic

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const defaultHealthCheck = new gcp.compute.HealthCheck("default", {
        name: "healthcheck",
        timeoutSec: 1,
        checkIntervalSec: 1,
        grpcHealthCheck: {
            portName: "health-check-port",
            portSpecification: "USE_NAMED_PORT",
            grpcServiceName: "testservice",
        },
    });
    const home = new gcp.compute.BackendService("home", {
        name: "backend",
        portName: "grpc",
        protocol: "GRPC",
        timeoutSec: 10,
        healthChecks: defaultHealthCheck.id,
        loadBalancingScheme: "INTERNAL_SELF_MANAGED",
    });
    const urlmap = new gcp.compute.URLMap("urlmap", {
        name: "urlmap",
        description: "a description",
        defaultService: home.id,
        hostRules: [{
            hosts: ["mysite.com"],
            pathMatcher: "allpaths",
        }],
        pathMatchers: [{
            name: "allpaths",
            defaultService: home.id,
            routeRules: [{
                priority: 1,
                headerAction: {
                    requestHeadersToRemoves: ["RemoveMe2"],
                    requestHeadersToAdds: [{
                        headerName: "AddSomethingElse",
                        headerValue: "MyOtherValue",
                        replace: true,
                    }],
                    responseHeadersToRemoves: ["RemoveMe3"],
                    responseHeadersToAdds: [{
                        headerName: "AddMe",
                        headerValue: "MyValue",
                        replace: false,
                    }],
                },
                matchRules: [{
                    fullPathMatch: "a full path",
                    headerMatches: [{
                        headerName: "someheader",
                        exactMatch: "match this exactly",
                        invertMatch: true,
                    }],
                    ignoreCase: true,
                    metadataFilters: [{
                        filterMatchCriteria: "MATCH_ANY",
                        filterLabels: [{
                            name: "PLANET",
                            value: "MARS",
                        }],
                    }],
                    queryParameterMatches: [{
                        name: "a query parameter",
                        presentMatch: true,
                    }],
                }],
                urlRedirect: {
                    hostRedirect: "A host",
                    httpsRedirect: false,
                    pathRedirect: "some/path",
                    redirectResponseCode: "TEMPORARY_REDIRECT",
                    stripQuery: true,
                },
            }],
        }],
        tests: [{
            service: home.id,
            host: "hi.com",
            path: "/home",
        }],
    });
    const _default = new gcp.compute.TargetGrpcProxy("default", {
        name: "proxy",
        urlMap: urlmap.id,
        validateForProxyless: true,
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default_health_check = gcp.compute.HealthCheck("default",
        name="healthcheck",
        timeout_sec=1,
        check_interval_sec=1,
        grpc_health_check=gcp.compute.HealthCheckGrpcHealthCheckArgs(
            port_name="health-check-port",
            port_specification="USE_NAMED_PORT",
            grpc_service_name="testservice",
        ))
    home = gcp.compute.BackendService("home",
        name="backend",
        port_name="grpc",
        protocol="GRPC",
        timeout_sec=10,
        health_checks=default_health_check.id,
        load_balancing_scheme="INTERNAL_SELF_MANAGED")
    urlmap = gcp.compute.URLMap("urlmap",
        name="urlmap",
        description="a description",
        default_service=home.id,
        host_rules=[gcp.compute.URLMapHostRuleArgs(
            hosts=["mysite.com"],
            path_matcher="allpaths",
        )],
        path_matchers=[gcp.compute.URLMapPathMatcherArgs(
            name="allpaths",
            default_service=home.id,
            route_rules=[gcp.compute.URLMapPathMatcherRouteRuleArgs(
                priority=1,
                header_action=gcp.compute.URLMapPathMatcherRouteRuleHeaderActionArgs(
                    request_headers_to_removes=["RemoveMe2"],
                    request_headers_to_adds=[gcp.compute.URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs(
                        header_name="AddSomethingElse",
                        header_value="MyOtherValue",
                        replace=True,
                    )],
                    response_headers_to_removes=["RemoveMe3"],
                    response_headers_to_adds=[gcp.compute.URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs(
                        header_name="AddMe",
                        header_value="MyValue",
                        replace=False,
                    )],
                ),
                match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
                    full_path_match="a full path",
                    header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
                        header_name="someheader",
                        exact_match="match this exactly",
                        invert_match=True,
                    )],
                    ignore_case=True,
                    metadata_filters=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs(
                        filter_match_criteria="MATCH_ANY",
                        filter_labels=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs(
                            name="PLANET",
                            value="MARS",
                        )],
                    )],
                    query_parameter_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
                        name="a query parameter",
                        present_match=True,
                    )],
                )],
                url_redirect=gcp.compute.URLMapPathMatcherRouteRuleUrlRedirectArgs(
                    host_redirect="A host",
                    https_redirect=False,
                    path_redirect="some/path",
                    redirect_response_code="TEMPORARY_REDIRECT",
                    strip_query=True,
                ),
            )],
        )],
        tests=[gcp.compute.URLMapTestArgs(
            service=home.id,
            host="hi.com",
            path="/home",
        )])
    default = gcp.compute.TargetGrpcProxy("default",
        name="proxy",
        url_map=urlmap.id,
        validate_for_proxyless=True)
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		defaultHealthCheck, err := compute.NewHealthCheck(ctx, "default", &compute.HealthCheckArgs{
    			Name:             pulumi.String("healthcheck"),
    			TimeoutSec:       pulumi.Int(1),
    			CheckIntervalSec: pulumi.Int(1),
    			GrpcHealthCheck: &compute.HealthCheckGrpcHealthCheckArgs{
    				PortName:          pulumi.String("health-check-port"),
    				PortSpecification: pulumi.String("USE_NAMED_PORT"),
    				GrpcServiceName:   pulumi.String("testservice"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		home, err := compute.NewBackendService(ctx, "home", &compute.BackendServiceArgs{
    			Name:                pulumi.String("backend"),
    			PortName:            pulumi.String("grpc"),
    			Protocol:            pulumi.String("GRPC"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        defaultHealthCheck.ID(),
    			LoadBalancingScheme: pulumi.String("INTERNAL_SELF_MANAGED"),
    		})
    		if err != nil {
    			return err
    		}
    		urlmap, err := compute.NewURLMap(ctx, "urlmap", &compute.URLMapArgs{
    			Name:           pulumi.String("urlmap"),
    			Description:    pulumi.String("a description"),
    			DefaultService: home.ID(),
    			HostRules: compute.URLMapHostRuleArray{
    				&compute.URLMapHostRuleArgs{
    					Hosts: pulumi.StringArray{
    						pulumi.String("mysite.com"),
    					},
    					PathMatcher: pulumi.String("allpaths"),
    				},
    			},
    			PathMatchers: compute.URLMapPathMatcherArray{
    				&compute.URLMapPathMatcherArgs{
    					Name:           pulumi.String("allpaths"),
    					DefaultService: home.ID(),
    					RouteRules: compute.URLMapPathMatcherRouteRuleArray{
    						&compute.URLMapPathMatcherRouteRuleArgs{
    							Priority: pulumi.Int(1),
    							HeaderAction: &compute.URLMapPathMatcherRouteRuleHeaderActionArgs{
    								RequestHeadersToRemoves: pulumi.StringArray{
    									pulumi.String("RemoveMe2"),
    								},
    								RequestHeadersToAdds: compute.URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArray{
    									&compute.URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs{
    										HeaderName:  pulumi.String("AddSomethingElse"),
    										HeaderValue: pulumi.String("MyOtherValue"),
    										Replace:     pulumi.Bool(true),
    									},
    								},
    								ResponseHeadersToRemoves: pulumi.StringArray{
    									pulumi.String("RemoveMe3"),
    								},
    								ResponseHeadersToAdds: compute.URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArray{
    									&compute.URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs{
    										HeaderName:  pulumi.String("AddMe"),
    										HeaderValue: pulumi.String("MyValue"),
    										Replace:     pulumi.Bool(false),
    									},
    								},
    							},
    							MatchRules: compute.URLMapPathMatcherRouteRuleMatchRuleArray{
    								&compute.URLMapPathMatcherRouteRuleMatchRuleArgs{
    									FullPathMatch: pulumi.String("a full path"),
    									HeaderMatches: compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArray{
    										&compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs{
    											HeaderName:  pulumi.String("someheader"),
    											ExactMatch:  pulumi.String("match this exactly"),
    											InvertMatch: pulumi.Bool(true),
    										},
    									},
    									IgnoreCase: pulumi.Bool(true),
    									MetadataFilters: compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArray{
    										&compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs{
    											FilterMatchCriteria: pulumi.String("MATCH_ANY"),
    											FilterLabels: compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArray{
    												&compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs{
    													Name:  pulumi.String("PLANET"),
    													Value: pulumi.String("MARS"),
    												},
    											},
    										},
    									},
    									QueryParameterMatches: compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArray{
    										&compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs{
    											Name:         pulumi.String("a query parameter"),
    											PresentMatch: pulumi.Bool(true),
    										},
    									},
    								},
    							},
    							UrlRedirect: &compute.URLMapPathMatcherRouteRuleUrlRedirectArgs{
    								HostRedirect:         pulumi.String("A host"),
    								HttpsRedirect:        pulumi.Bool(false),
    								PathRedirect:         pulumi.String("some/path"),
    								RedirectResponseCode: pulumi.String("TEMPORARY_REDIRECT"),
    								StripQuery:           pulumi.Bool(true),
    							},
    						},
    					},
    				},
    			},
    			Tests: compute.URLMapTestArray{
    				&compute.URLMapTestArgs{
    					Service: home.ID(),
    					Host:    pulumi.String("hi.com"),
    					Path:    pulumi.String("/home"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewTargetGrpcProxy(ctx, "default", &compute.TargetGrpcProxyArgs{
    			Name:                 pulumi.String("proxy"),
    			UrlMap:               urlmap.ID(),
    			ValidateForProxyless: pulumi.Bool(true),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var defaultHealthCheck = new Gcp.Compute.HealthCheck("default", new()
        {
            Name = "healthcheck",
            TimeoutSec = 1,
            CheckIntervalSec = 1,
            GrpcHealthCheck = new Gcp.Compute.Inputs.HealthCheckGrpcHealthCheckArgs
            {
                PortName = "health-check-port",
                PortSpecification = "USE_NAMED_PORT",
                GrpcServiceName = "testservice",
            },
        });
    
        var home = new Gcp.Compute.BackendService("home", new()
        {
            Name = "backend",
            PortName = "grpc",
            Protocol = "GRPC",
            TimeoutSec = 10,
            HealthChecks = defaultHealthCheck.Id,
            LoadBalancingScheme = "INTERNAL_SELF_MANAGED",
        });
    
        var urlmap = new Gcp.Compute.URLMap("urlmap", new()
        {
            Name = "urlmap",
            Description = "a description",
            DefaultService = home.Id,
            HostRules = new[]
            {
                new Gcp.Compute.Inputs.URLMapHostRuleArgs
                {
                    Hosts = new[]
                    {
                        "mysite.com",
                    },
                    PathMatcher = "allpaths",
                },
            },
            PathMatchers = new[]
            {
                new Gcp.Compute.Inputs.URLMapPathMatcherArgs
                {
                    Name = "allpaths",
                    DefaultService = home.Id,
                    RouteRules = new[]
                    {
                        new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleArgs
                        {
                            Priority = 1,
                            HeaderAction = new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleHeaderActionArgs
                            {
                                RequestHeadersToRemoves = new[]
                                {
                                    "RemoveMe2",
                                },
                                RequestHeadersToAdds = new[]
                                {
                                    new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs
                                    {
                                        HeaderName = "AddSomethingElse",
                                        HeaderValue = "MyOtherValue",
                                        Replace = true,
                                    },
                                },
                                ResponseHeadersToRemoves = new[]
                                {
                                    "RemoveMe3",
                                },
                                ResponseHeadersToAdds = new[]
                                {
                                    new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs
                                    {
                                        HeaderName = "AddMe",
                                        HeaderValue = "MyValue",
                                        Replace = false,
                                    },
                                },
                            },
                            MatchRules = new[]
                            {
                                new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleMatchRuleArgs
                                {
                                    FullPathMatch = "a full path",
                                    HeaderMatches = new[]
                                    {
                                        new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs
                                        {
                                            HeaderName = "someheader",
                                            ExactMatch = "match this exactly",
                                            InvertMatch = true,
                                        },
                                    },
                                    IgnoreCase = true,
                                    MetadataFilters = new[]
                                    {
                                        new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs
                                        {
                                            FilterMatchCriteria = "MATCH_ANY",
                                            FilterLabels = new[]
                                            {
                                                new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs
                                                {
                                                    Name = "PLANET",
                                                    Value = "MARS",
                                                },
                                            },
                                        },
                                    },
                                    QueryParameterMatches = new[]
                                    {
                                        new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs
                                        {
                                            Name = "a query parameter",
                                            PresentMatch = true,
                                        },
                                    },
                                },
                            },
                            UrlRedirect = new Gcp.Compute.Inputs.URLMapPathMatcherRouteRuleUrlRedirectArgs
                            {
                                HostRedirect = "A host",
                                HttpsRedirect = false,
                                PathRedirect = "some/path",
                                RedirectResponseCode = "TEMPORARY_REDIRECT",
                                StripQuery = true,
                            },
                        },
                    },
                },
            },
            Tests = new[]
            {
                new Gcp.Compute.Inputs.URLMapTestArgs
                {
                    Service = home.Id,
                    Host = "hi.com",
                    Path = "/home",
                },
            },
        });
    
        var @default = new Gcp.Compute.TargetGrpcProxy("default", new()
        {
            Name = "proxy",
            UrlMap = urlmap.Id,
            ValidateForProxyless = true,
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.compute.HealthCheck;
    import com.pulumi.gcp.compute.HealthCheckArgs;
    import com.pulumi.gcp.compute.inputs.HealthCheckGrpcHealthCheckArgs;
    import com.pulumi.gcp.compute.BackendService;
    import com.pulumi.gcp.compute.BackendServiceArgs;
    import com.pulumi.gcp.compute.URLMap;
    import com.pulumi.gcp.compute.URLMapArgs;
    import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
    import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
    import com.pulumi.gcp.compute.inputs.URLMapTestArgs;
    import com.pulumi.gcp.compute.TargetGrpcProxy;
    import com.pulumi.gcp.compute.TargetGrpcProxyArgs;
    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 defaultHealthCheck = new HealthCheck("defaultHealthCheck", HealthCheckArgs.builder()
                .name("healthcheck")
                .timeoutSec(1)
                .checkIntervalSec(1)
                .grpcHealthCheck(HealthCheckGrpcHealthCheckArgs.builder()
                    .portName("health-check-port")
                    .portSpecification("USE_NAMED_PORT")
                    .grpcServiceName("testservice")
                    .build())
                .build());
    
            var home = new BackendService("home", BackendServiceArgs.builder()
                .name("backend")
                .portName("grpc")
                .protocol("GRPC")
                .timeoutSec(10)
                .healthChecks(defaultHealthCheck.id())
                .loadBalancingScheme("INTERNAL_SELF_MANAGED")
                .build());
    
            var urlmap = new URLMap("urlmap", URLMapArgs.builder()
                .name("urlmap")
                .description("a description")
                .defaultService(home.id())
                .hostRules(URLMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("allpaths")
                    .build())
                .pathMatchers(URLMapPathMatcherArgs.builder()
                    .name("allpaths")
                    .defaultService(home.id())
                    .routeRules(URLMapPathMatcherRouteRuleArgs.builder()
                        .priority(1)
                        .headerAction(URLMapPathMatcherRouteRuleHeaderActionArgs.builder()
                            .requestHeadersToRemoves("RemoveMe2")
                            .requestHeadersToAdds(URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs.builder()
                                .headerName("AddSomethingElse")
                                .headerValue("MyOtherValue")
                                .replace(true)
                                .build())
                            .responseHeadersToRemoves("RemoveMe3")
                            .responseHeadersToAdds(URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs.builder()
                                .headerName("AddMe")
                                .headerValue("MyValue")
                                .replace(false)
                                .build())
                            .build())
                        .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .fullPathMatch("a full path")
                            .headerMatches(URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs.builder()
                                .headerName("someheader")
                                .exactMatch("match this exactly")
                                .invertMatch(true)
                                .build())
                            .ignoreCase(true)
                            .metadataFilters(URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs.builder()
                                .filterMatchCriteria("MATCH_ANY")
                                .filterLabels(URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs.builder()
                                    .name("PLANET")
                                    .value("MARS")
                                    .build())
                                .build())
                            .queryParameterMatches(URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                                .name("a query parameter")
                                .presentMatch(true)
                                .build())
                            .build())
                        .urlRedirect(URLMapPathMatcherRouteRuleUrlRedirectArgs.builder()
                            .hostRedirect("A host")
                            .httpsRedirect(false)
                            .pathRedirect("some/path")
                            .redirectResponseCode("TEMPORARY_REDIRECT")
                            .stripQuery(true)
                            .build())
                        .build())
                    .build())
                .tests(URLMapTestArgs.builder()
                    .service(home.id())
                    .host("hi.com")
                    .path("/home")
                    .build())
                .build());
    
            var default_ = new TargetGrpcProxy("default", TargetGrpcProxyArgs.builder()
                .name("proxy")
                .urlMap(urlmap.id())
                .validateForProxyless(true)
                .build());
    
        }
    }
    
    resources:
      default:
        type: gcp:compute:TargetGrpcProxy
        properties:
          name: proxy
          urlMap: ${urlmap.id}
          validateForProxyless: true
      urlmap:
        type: gcp:compute:URLMap
        properties:
          name: urlmap
          description: a description
          defaultService: ${home.id}
          hostRules:
            - hosts:
                - mysite.com
              pathMatcher: allpaths
          pathMatchers:
            - name: allpaths
              defaultService: ${home.id}
              routeRules:
                - priority: 1
                  headerAction:
                    requestHeadersToRemoves:
                      - RemoveMe2
                    requestHeadersToAdds:
                      - headerName: AddSomethingElse
                        headerValue: MyOtherValue
                        replace: true
                    responseHeadersToRemoves:
                      - RemoveMe3
                    responseHeadersToAdds:
                      - headerName: AddMe
                        headerValue: MyValue
                        replace: false
                  matchRules:
                    - fullPathMatch: a full path
                      headerMatches:
                        - headerName: someheader
                          exactMatch: match this exactly
                          invertMatch: true
                      ignoreCase: true
                      metadataFilters:
                        - filterMatchCriteria: MATCH_ANY
                          filterLabels:
                            - name: PLANET
                              value: MARS
                      queryParameterMatches:
                        - name: a query parameter
                          presentMatch: true
                  urlRedirect:
                    hostRedirect: A host
                    httpsRedirect: false
                    pathRedirect: some/path
                    redirectResponseCode: TEMPORARY_REDIRECT
                    stripQuery: true
          tests:
            - service: ${home.id}
              host: hi.com
              path: /home
      home:
        type: gcp:compute:BackendService
        properties:
          name: backend
          portName: grpc
          protocol: GRPC
          timeoutSec: 10
          healthChecks: ${defaultHealthCheck.id}
          loadBalancingScheme: INTERNAL_SELF_MANAGED
      defaultHealthCheck:
        type: gcp:compute:HealthCheck
        name: default
        properties:
          name: healthcheck
          timeoutSec: 1
          checkIntervalSec: 1
          grpcHealthCheck:
            portName: health-check-port
            portSpecification: USE_NAMED_PORT
            grpcServiceName: testservice
    

    Create TargetGrpcProxy Resource

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

    Constructor syntax

    new TargetGrpcProxy(name: string, args?: TargetGrpcProxyArgs, opts?: CustomResourceOptions);
    @overload
    def TargetGrpcProxy(resource_name: str,
                        args: Optional[TargetGrpcProxyArgs] = None,
                        opts: Optional[ResourceOptions] = None)
    
    @overload
    def TargetGrpcProxy(resource_name: str,
                        opts: Optional[ResourceOptions] = None,
                        description: Optional[str] = None,
                        name: Optional[str] = None,
                        project: Optional[str] = None,
                        url_map: Optional[str] = None,
                        validate_for_proxyless: Optional[bool] = None)
    func NewTargetGrpcProxy(ctx *Context, name string, args *TargetGrpcProxyArgs, opts ...ResourceOption) (*TargetGrpcProxy, error)
    public TargetGrpcProxy(string name, TargetGrpcProxyArgs? args = null, CustomResourceOptions? opts = null)
    public TargetGrpcProxy(String name, TargetGrpcProxyArgs args)
    public TargetGrpcProxy(String name, TargetGrpcProxyArgs args, CustomResourceOptions options)
    
    type: gcp:compute:TargetGrpcProxy
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args TargetGrpcProxyArgs
    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 TargetGrpcProxyArgs
    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 TargetGrpcProxyArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args TargetGrpcProxyArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args TargetGrpcProxyArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

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

    var targetGrpcProxyResource = new Gcp.Compute.TargetGrpcProxy("targetGrpcProxyResource", new()
    {
        Description = "string",
        Name = "string",
        Project = "string",
        UrlMap = "string",
        ValidateForProxyless = false,
    });
    
    example, err := compute.NewTargetGrpcProxy(ctx, "targetGrpcProxyResource", &compute.TargetGrpcProxyArgs{
    	Description:          pulumi.String("string"),
    	Name:                 pulumi.String("string"),
    	Project:              pulumi.String("string"),
    	UrlMap:               pulumi.String("string"),
    	ValidateForProxyless: pulumi.Bool(false),
    })
    
    var targetGrpcProxyResource = new TargetGrpcProxy("targetGrpcProxyResource", TargetGrpcProxyArgs.builder()
        .description("string")
        .name("string")
        .project("string")
        .urlMap("string")
        .validateForProxyless(false)
        .build());
    
    target_grpc_proxy_resource = gcp.compute.TargetGrpcProxy("targetGrpcProxyResource",
        description="string",
        name="string",
        project="string",
        url_map="string",
        validate_for_proxyless=False)
    
    const targetGrpcProxyResource = new gcp.compute.TargetGrpcProxy("targetGrpcProxyResource", {
        description: "string",
        name: "string",
        project: "string",
        urlMap: "string",
        validateForProxyless: false,
    });
    
    type: gcp:compute:TargetGrpcProxy
    properties:
        description: string
        name: string
        project: string
        urlMap: string
        validateForProxyless: false
    

    TargetGrpcProxy 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 TargetGrpcProxy resource accepts the following input properties:

    Description string
    An optional description of this resource.
    Name string
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    UrlMap string
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    ValidateForProxyless bool
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    Description string
    An optional description of this resource.
    Name string
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    UrlMap string
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    ValidateForProxyless bool
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    description String
    An optional description of this resource.
    name String
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    urlMap String
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    validateForProxyless Boolean
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    description string
    An optional description of this resource.
    name string
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    urlMap string
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    validateForProxyless boolean
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    description str
    An optional description of this resource.
    name str
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    url_map str
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    validate_for_proxyless bool
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    description String
    An optional description of this resource.
    name String
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    urlMap String
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    validateForProxyless Boolean
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to

    Outputs

    All input properties are implicitly available as output properties. Additionally, the TargetGrpcProxy resource produces the following output properties:

    CreationTimestamp string
    Creation timestamp in RFC3339 text format.
    Fingerprint string
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    Id string
    The provider-assigned unique ID for this managed resource.
    SelfLink string
    The URI of the created resource.
    SelfLinkWithId string
    Server-defined URL with id for the resource.
    CreationTimestamp string
    Creation timestamp in RFC3339 text format.
    Fingerprint string
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    Id string
    The provider-assigned unique ID for this managed resource.
    SelfLink string
    The URI of the created resource.
    SelfLinkWithId string
    Server-defined URL with id for the resource.
    creationTimestamp String
    Creation timestamp in RFC3339 text format.
    fingerprint String
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    id String
    The provider-assigned unique ID for this managed resource.
    selfLink String
    The URI of the created resource.
    selfLinkWithId String
    Server-defined URL with id for the resource.
    creationTimestamp string
    Creation timestamp in RFC3339 text format.
    fingerprint string
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    id string
    The provider-assigned unique ID for this managed resource.
    selfLink string
    The URI of the created resource.
    selfLinkWithId string
    Server-defined URL with id for the resource.
    creation_timestamp str
    Creation timestamp in RFC3339 text format.
    fingerprint str
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    id str
    The provider-assigned unique ID for this managed resource.
    self_link str
    The URI of the created resource.
    self_link_with_id str
    Server-defined URL with id for the resource.
    creationTimestamp String
    Creation timestamp in RFC3339 text format.
    fingerprint String
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    id String
    The provider-assigned unique ID for this managed resource.
    selfLink String
    The URI of the created resource.
    selfLinkWithId String
    Server-defined URL with id for the resource.

    Look up Existing TargetGrpcProxy Resource

    Get an existing TargetGrpcProxy 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?: TargetGrpcProxyState, opts?: CustomResourceOptions): TargetGrpcProxy
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            creation_timestamp: Optional[str] = None,
            description: Optional[str] = None,
            fingerprint: Optional[str] = None,
            name: Optional[str] = None,
            project: Optional[str] = None,
            self_link: Optional[str] = None,
            self_link_with_id: Optional[str] = None,
            url_map: Optional[str] = None,
            validate_for_proxyless: Optional[bool] = None) -> TargetGrpcProxy
    func GetTargetGrpcProxy(ctx *Context, name string, id IDInput, state *TargetGrpcProxyState, opts ...ResourceOption) (*TargetGrpcProxy, error)
    public static TargetGrpcProxy Get(string name, Input<string> id, TargetGrpcProxyState? state, CustomResourceOptions? opts = null)
    public static TargetGrpcProxy get(String name, Output<String> id, TargetGrpcProxyState 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:
    CreationTimestamp string
    Creation timestamp in RFC3339 text format.
    Description string
    An optional description of this resource.
    Fingerprint string
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    Name string
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    SelfLink string
    The URI of the created resource.
    SelfLinkWithId string
    Server-defined URL with id for the resource.
    UrlMap string
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    ValidateForProxyless bool
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    CreationTimestamp string
    Creation timestamp in RFC3339 text format.
    Description string
    An optional description of this resource.
    Fingerprint string
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    Name string
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    SelfLink string
    The URI of the created resource.
    SelfLinkWithId string
    Server-defined URL with id for the resource.
    UrlMap string
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    ValidateForProxyless bool
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    creationTimestamp String
    Creation timestamp in RFC3339 text format.
    description String
    An optional description of this resource.
    fingerprint String
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    name String
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    selfLink String
    The URI of the created resource.
    selfLinkWithId String
    Server-defined URL with id for the resource.
    urlMap String
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    validateForProxyless Boolean
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    creationTimestamp string
    Creation timestamp in RFC3339 text format.
    description string
    An optional description of this resource.
    fingerprint string
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    name string
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    selfLink string
    The URI of the created resource.
    selfLinkWithId string
    Server-defined URL with id for the resource.
    urlMap string
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    validateForProxyless boolean
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    creation_timestamp str
    Creation timestamp in RFC3339 text format.
    description str
    An optional description of this resource.
    fingerprint str
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    name str
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    self_link str
    The URI of the created resource.
    self_link_with_id str
    Server-defined URL with id for the resource.
    url_map str
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    validate_for_proxyless bool
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to
    creationTimestamp String
    Creation timestamp in RFC3339 text format.
    description String
    An optional description of this resource.
    fingerprint String
    Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a TargetGrpcProxy. An up-to-date fingerprint must be provided in order to patch/update the TargetGrpcProxy; otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the TargetGrpcProxy. A base64-encoded string.
    name String
    Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.


    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    selfLink String
    The URI of the created resource.
    selfLinkWithId String
    Server-defined URL with id for the resource.
    urlMap String
    URL to the UrlMap resource that defines the mapping from URL to the BackendService. The protocol field in the BackendService must be set to GRPC.
    validateForProxyless Boolean
    If true, indicates that the BackendServices referenced by the urlMap may be accessed by gRPC applications without using a sidecar proxy. This will enable configuration checks on urlMap and its referenced BackendServices to not allow unsupported features. A gRPC application must use "xds:///" scheme in the target URI of the service it is connecting to. If false, indicates that the BackendServices referenced by the urlMap will be accessed by gRPC applications via a sidecar proxy. In this case, a gRPC application must not use "xds:///" scheme in the target URI of the service it is connecting to

    Import

    TargetGrpcProxy can be imported using any of these accepted formats:

    • projects/{{project}}/global/targetGrpcProxies/{{name}}

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

    • {{name}}

    When using the pulumi import command, TargetGrpcProxy can be imported using one of the formats above. For example:

    $ pulumi import gcp:compute/targetGrpcProxy:TargetGrpcProxy default projects/{{project}}/global/targetGrpcProxies/{{name}}
    
    $ pulumi import gcp:compute/targetGrpcProxy:TargetGrpcProxy default {{project}}/{{name}}
    
    $ pulumi import gcp:compute/targetGrpcProxy:TargetGrpcProxy default {{name}}
    

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

    Package Details

    Repository
    Google Cloud (GCP) Classic pulumi/pulumi-gcp
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the google-beta Terraform Provider.
    gcp logo
    Google Cloud Classic v7.29.0 published on Wednesday, Jun 26, 2024 by Pulumi