Configure GCP Region Target HTTP Proxies

The gcp:compute/regionTargetHttpProxy:RegionTargetHttpProxy resource, part of the Pulumi GCP provider, defines the HTTP routing layer for regional load balancers: it connects forwarding rules to URL maps that route requests to backend services. This guide focuses on three capabilities: URL map routing to backends, connection keep-alive tuning, and HTTPS redirect configuration.

HTTP proxies sit between forwarding rules (which define IP/port listeners) and URL maps (which route to backends). The examples create URL maps and backend services but assume forwarding rules exist separately. The examples are intentionally small. Combine them with your own forwarding rules and network configuration.

Route HTTP traffic to backend services

Regional load balancers connect an HTTP proxy to a URL map that routes requests to backend services based on host and path patterns.

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

const defaultRegionHealthCheck = new gcp.compute.RegionHealthCheck("default", {
    region: "us-central1",
    name: "http-health-check",
    httpHealthCheck: {
        port: 80,
    },
});
const defaultRegionBackendService = new gcp.compute.RegionBackendService("default", {
    region: "us-central1",
    name: "backend-service",
    protocol: "HTTP",
    timeoutSec: 10,
    loadBalancingScheme: "INTERNAL_MANAGED",
    healthChecks: defaultRegionHealthCheck.id,
});
const defaultRegionUrlMap = new gcp.compute.RegionUrlMap("default", {
    region: "us-central1",
    name: "url-map",
    defaultService: defaultRegionBackendService.id,
    hostRules: [{
        hosts: ["mysite.com"],
        pathMatcher: "allpaths",
    }],
    pathMatchers: [{
        name: "allpaths",
        defaultService: defaultRegionBackendService.id,
        pathRules: [{
            paths: ["/*"],
            service: defaultRegionBackendService.id,
        }],
    }],
});
const _default = new gcp.compute.RegionTargetHttpProxy("default", {
    region: "us-central1",
    name: "test-proxy",
    urlMap: defaultRegionUrlMap.id,
});

import pulumi
import pulumi_gcp as gcp

default_region_health_check = gcp.compute.RegionHealthCheck("default",
    region="us-central1",
    name="http-health-check",
    http_health_check={
        "port": 80,
    })
default_region_backend_service = gcp.compute.RegionBackendService("default",
    region="us-central1",
    name="backend-service",
    protocol="HTTP",
    timeout_sec=10,
    load_balancing_scheme="INTERNAL_MANAGED",
    health_checks=default_region_health_check.id)
default_region_url_map = gcp.compute.RegionUrlMap("default",
    region="us-central1",
    name="url-map",
    default_service=default_region_backend_service.id,
    host_rules=[{
        "hosts": ["mysite.com"],
        "path_matcher": "allpaths",
    }],
    path_matchers=[{
        "name": "allpaths",
        "default_service": default_region_backend_service.id,
        "path_rules": [{
            "paths": ["/*"],
            "service": default_region_backend_service.id,
        }],
    }])
default = gcp.compute.RegionTargetHttpProxy("default",
    region="us-central1",
    name="test-proxy",
    url_map=default_region_url_map.id)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultRegionHealthCheck, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
			Region: pulumi.String("us-central1"),
			Name:   pulumi.String("http-health-check"),
			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
				Port: pulumi.Int(80),
			},
		})
		if err != nil {
			return err
		}
		defaultRegionBackendService, err := compute.NewRegionBackendService(ctx, "default", &compute.RegionBackendServiceArgs{
			Region:              pulumi.String("us-central1"),
			Name:                pulumi.String("backend-service"),
			Protocol:            pulumi.String("HTTP"),
			TimeoutSec:          pulumi.Int(10),
			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
			HealthChecks:        defaultRegionHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		defaultRegionUrlMap, err := compute.NewRegionUrlMap(ctx, "default", &compute.RegionUrlMapArgs{
			Region:         pulumi.String("us-central1"),
			Name:           pulumi.String("url-map"),
			DefaultService: defaultRegionBackendService.ID(),
			HostRules: compute.RegionUrlMapHostRuleArray{
				&compute.RegionUrlMapHostRuleArgs{
					Hosts: pulumi.StringArray{
						pulumi.String("mysite.com"),
					},
					PathMatcher: pulumi.String("allpaths"),
				},
			},
			PathMatchers: compute.RegionUrlMapPathMatcherArray{
				&compute.RegionUrlMapPathMatcherArgs{
					Name:           pulumi.String("allpaths"),
					DefaultService: defaultRegionBackendService.ID(),
					PathRules: compute.RegionUrlMapPathMatcherPathRuleArray{
						&compute.RegionUrlMapPathMatcherPathRuleArgs{
							Paths: pulumi.StringArray{
								pulumi.String("/*"),
							},
							Service: defaultRegionBackendService.ID(),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewRegionTargetHttpProxy(ctx, "default", &compute.RegionTargetHttpProxyArgs{
			Region: pulumi.String("us-central1"),
			Name:   pulumi.String("test-proxy"),
			UrlMap: defaultRegionUrlMap.ID(),
		})
		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 defaultRegionHealthCheck = new Gcp.Compute.RegionHealthCheck("default", new()
    {
        Region = "us-central1",
        Name = "http-health-check",
        HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
        {
            Port = 80,
        },
    });

    var defaultRegionBackendService = new Gcp.Compute.RegionBackendService("default", new()
    {
        Region = "us-central1",
        Name = "backend-service",
        Protocol = "HTTP",
        TimeoutSec = 10,
        LoadBalancingScheme = "INTERNAL_MANAGED",
        HealthChecks = defaultRegionHealthCheck.Id,
    });

    var defaultRegionUrlMap = new Gcp.Compute.RegionUrlMap("default", new()
    {
        Region = "us-central1",
        Name = "url-map",
        DefaultService = defaultRegionBackendService.Id,
        HostRules = new[]
        {
            new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
            {
                Hosts = new[]
                {
                    "mysite.com",
                },
                PathMatcher = "allpaths",
            },
        },
        PathMatchers = new[]
        {
            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
            {
                Name = "allpaths",
                DefaultService = defaultRegionBackendService.Id,
                PathRules = new[]
                {
                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                    {
                        Paths = new[]
                        {
                            "/*",
                        },
                        Service = defaultRegionBackendService.Id,
                    },
                },
            },
        },
    });

    var @default = new Gcp.Compute.RegionTargetHttpProxy("default", new()
    {
        Region = "us-central1",
        Name = "test-proxy",
        UrlMap = defaultRegionUrlMap.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.gcp.compute.RegionUrlMap;
import com.pulumi.gcp.compute.RegionUrlMapArgs;
import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
import com.pulumi.gcp.compute.RegionTargetHttpProxy;
import com.pulumi.gcp.compute.RegionTargetHttpProxyArgs;
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 defaultRegionHealthCheck = new RegionHealthCheck("defaultRegionHealthCheck", RegionHealthCheckArgs.builder()
            .region("us-central1")
            .name("http-health-check")
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());

        var defaultRegionBackendService = new RegionBackendService("defaultRegionBackendService", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .name("backend-service")
            .protocol("HTTP")
            .timeoutSec(10)
            .loadBalancingScheme("INTERNAL_MANAGED")
            .healthChecks(defaultRegionHealthCheck.id())
            .build());

        var defaultRegionUrlMap = new RegionUrlMap("defaultRegionUrlMap", RegionUrlMapArgs.builder()
            .region("us-central1")
            .name("url-map")
            .defaultService(defaultRegionBackendService.id())
            .hostRules(RegionUrlMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(defaultRegionBackendService.id())
                .pathRules(RegionUrlMapPathMatcherPathRuleArgs.builder()
                    .paths("/*")
                    .service(defaultRegionBackendService.id())
                    .build())
                .build())
            .build());

        var default_ = new RegionTargetHttpProxy("default", RegionTargetHttpProxyArgs.builder()
            .region("us-central1")
            .name("test-proxy")
            .urlMap(defaultRegionUrlMap.id())
            .build());

    }
}

resources:
  default:
    type: gcp:compute:RegionTargetHttpProxy
    properties:
      region: us-central1
      name: test-proxy
      urlMap: ${defaultRegionUrlMap.id}
  defaultRegionUrlMap:
    type: gcp:compute:RegionUrlMap
    name: default
    properties:
      region: us-central1
      name: url-map
      defaultService: ${defaultRegionBackendService.id}
      hostRules:
        - hosts:
            - mysite.com
          pathMatcher: allpaths
      pathMatchers:
        - name: allpaths
          defaultService: ${defaultRegionBackendService.id}
          pathRules:
            - paths:
                - /*
              service: ${defaultRegionBackendService.id}
  defaultRegionBackendService:
    type: gcp:compute:RegionBackendService
    name: default
    properties:
      region: us-central1
      name: backend-service
      protocol: HTTP
      timeoutSec: 10
      loadBalancingScheme: INTERNAL_MANAGED
      healthChecks: ${defaultRegionHealthCheck.id}
  defaultRegionHealthCheck:
    type: gcp:compute:RegionHealthCheck
    name: default
    properties:
      region: us-central1
      name: http-health-check
      httpHealthCheck:
        port: 80

The proxy references a URL map via the urlMap property. The URL map defines routing rules: hostRules match incoming hostnames, pathMatchers define path-based routing, and pathRules map URL patterns to specific backend services. The backend service connects to health-checked instances. This configuration uses the INTERNAL_MANAGED load balancing scheme for private, regional traffic.

Configure connection keep-alive for persistent clients

Applications with long-lived client connections benefit from custom keep-alive timeouts to balance connection reuse against resource consumption.

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

const defaultRegionHealthCheck = new gcp.compute.RegionHealthCheck("default", {
    region: "us-central1",
    name: "http-health-check",
    httpHealthCheck: {
        port: 80,
    },
});
const defaultRegionBackendService = new gcp.compute.RegionBackendService("default", {
    region: "us-central1",
    name: "backend-service",
    portName: "http",
    protocol: "HTTP",
    timeoutSec: 10,
    loadBalancingScheme: "INTERNAL_MANAGED",
    healthChecks: defaultRegionHealthCheck.id,
});
const defaultRegionUrlMap = new gcp.compute.RegionUrlMap("default", {
    region: "us-central1",
    name: "url-map",
    defaultService: defaultRegionBackendService.id,
    hostRules: [{
        hosts: ["mysite.com"],
        pathMatcher: "allpaths",
    }],
    pathMatchers: [{
        name: "allpaths",
        defaultService: defaultRegionBackendService.id,
        pathRules: [{
            paths: ["/*"],
            service: defaultRegionBackendService.id,
        }],
    }],
});
const _default = new gcp.compute.RegionTargetHttpProxy("default", {
    region: "us-central1",
    name: "test-http-keep-alive-timeout-proxy",
    httpKeepAliveTimeoutSec: 600,
    urlMap: defaultRegionUrlMap.id,
});

import pulumi
import pulumi_gcp as gcp

default_region_health_check = gcp.compute.RegionHealthCheck("default",
    region="us-central1",
    name="http-health-check",
    http_health_check={
        "port": 80,
    })
default_region_backend_service = gcp.compute.RegionBackendService("default",
    region="us-central1",
    name="backend-service",
    port_name="http",
    protocol="HTTP",
    timeout_sec=10,
    load_balancing_scheme="INTERNAL_MANAGED",
    health_checks=default_region_health_check.id)
default_region_url_map = gcp.compute.RegionUrlMap("default",
    region="us-central1",
    name="url-map",
    default_service=default_region_backend_service.id,
    host_rules=[{
        "hosts": ["mysite.com"],
        "path_matcher": "allpaths",
    }],
    path_matchers=[{
        "name": "allpaths",
        "default_service": default_region_backend_service.id,
        "path_rules": [{
            "paths": ["/*"],
            "service": default_region_backend_service.id,
        }],
    }])
default = gcp.compute.RegionTargetHttpProxy("default",
    region="us-central1",
    name="test-http-keep-alive-timeout-proxy",
    http_keep_alive_timeout_sec=600,
    url_map=default_region_url_map.id)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultRegionHealthCheck, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
			Region: pulumi.String("us-central1"),
			Name:   pulumi.String("http-health-check"),
			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
				Port: pulumi.Int(80),
			},
		})
		if err != nil {
			return err
		}
		defaultRegionBackendService, err := compute.NewRegionBackendService(ctx, "default", &compute.RegionBackendServiceArgs{
			Region:              pulumi.String("us-central1"),
			Name:                pulumi.String("backend-service"),
			PortName:            pulumi.String("http"),
			Protocol:            pulumi.String("HTTP"),
			TimeoutSec:          pulumi.Int(10),
			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
			HealthChecks:        defaultRegionHealthCheck.ID(),
		})
		if err != nil {
			return err
		}
		defaultRegionUrlMap, err := compute.NewRegionUrlMap(ctx, "default", &compute.RegionUrlMapArgs{
			Region:         pulumi.String("us-central1"),
			Name:           pulumi.String("url-map"),
			DefaultService: defaultRegionBackendService.ID(),
			HostRules: compute.RegionUrlMapHostRuleArray{
				&compute.RegionUrlMapHostRuleArgs{
					Hosts: pulumi.StringArray{
						pulumi.String("mysite.com"),
					},
					PathMatcher: pulumi.String("allpaths"),
				},
			},
			PathMatchers: compute.RegionUrlMapPathMatcherArray{
				&compute.RegionUrlMapPathMatcherArgs{
					Name:           pulumi.String("allpaths"),
					DefaultService: defaultRegionBackendService.ID(),
					PathRules: compute.RegionUrlMapPathMatcherPathRuleArray{
						&compute.RegionUrlMapPathMatcherPathRuleArgs{
							Paths: pulumi.StringArray{
								pulumi.String("/*"),
							},
							Service: defaultRegionBackendService.ID(),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewRegionTargetHttpProxy(ctx, "default", &compute.RegionTargetHttpProxyArgs{
			Region:                  pulumi.String("us-central1"),
			Name:                    pulumi.String("test-http-keep-alive-timeout-proxy"),
			HttpKeepAliveTimeoutSec: pulumi.Int(600),
			UrlMap:                  defaultRegionUrlMap.ID(),
		})
		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 defaultRegionHealthCheck = new Gcp.Compute.RegionHealthCheck("default", new()
    {
        Region = "us-central1",
        Name = "http-health-check",
        HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
        {
            Port = 80,
        },
    });

    var defaultRegionBackendService = new Gcp.Compute.RegionBackendService("default", new()
    {
        Region = "us-central1",
        Name = "backend-service",
        PortName = "http",
        Protocol = "HTTP",
        TimeoutSec = 10,
        LoadBalancingScheme = "INTERNAL_MANAGED",
        HealthChecks = defaultRegionHealthCheck.Id,
    });

    var defaultRegionUrlMap = new Gcp.Compute.RegionUrlMap("default", new()
    {
        Region = "us-central1",
        Name = "url-map",
        DefaultService = defaultRegionBackendService.Id,
        HostRules = new[]
        {
            new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
            {
                Hosts = new[]
                {
                    "mysite.com",
                },
                PathMatcher = "allpaths",
            },
        },
        PathMatchers = new[]
        {
            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
            {
                Name = "allpaths",
                DefaultService = defaultRegionBackendService.Id,
                PathRules = new[]
                {
                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                    {
                        Paths = new[]
                        {
                            "/*",
                        },
                        Service = defaultRegionBackendService.Id,
                    },
                },
            },
        },
    });

    var @default = new Gcp.Compute.RegionTargetHttpProxy("default", new()
    {
        Region = "us-central1",
        Name = "test-http-keep-alive-timeout-proxy",
        HttpKeepAliveTimeoutSec = 600,
        UrlMap = defaultRegionUrlMap.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.gcp.compute.RegionUrlMap;
import com.pulumi.gcp.compute.RegionUrlMapArgs;
import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
import com.pulumi.gcp.compute.RegionTargetHttpProxy;
import com.pulumi.gcp.compute.RegionTargetHttpProxyArgs;
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 defaultRegionHealthCheck = new RegionHealthCheck("defaultRegionHealthCheck", RegionHealthCheckArgs.builder()
            .region("us-central1")
            .name("http-health-check")
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());

        var defaultRegionBackendService = new RegionBackendService("defaultRegionBackendService", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .name("backend-service")
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .loadBalancingScheme("INTERNAL_MANAGED")
            .healthChecks(defaultRegionHealthCheck.id())
            .build());

        var defaultRegionUrlMap = new RegionUrlMap("defaultRegionUrlMap", RegionUrlMapArgs.builder()
            .region("us-central1")
            .name("url-map")
            .defaultService(defaultRegionBackendService.id())
            .hostRules(RegionUrlMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(defaultRegionBackendService.id())
                .pathRules(RegionUrlMapPathMatcherPathRuleArgs.builder()
                    .paths("/*")
                    .service(defaultRegionBackendService.id())
                    .build())
                .build())
            .build());

        var default_ = new RegionTargetHttpProxy("default", RegionTargetHttpProxyArgs.builder()
            .region("us-central1")
            .name("test-http-keep-alive-timeout-proxy")
            .httpKeepAliveTimeoutSec(600)
            .urlMap(defaultRegionUrlMap.id())
            .build());

    }
}

resources:
  default:
    type: gcp:compute:RegionTargetHttpProxy
    properties:
      region: us-central1
      name: test-http-keep-alive-timeout-proxy
      httpKeepAliveTimeoutSec: 600
      urlMap: ${defaultRegionUrlMap.id}
  defaultRegionUrlMap:
    type: gcp:compute:RegionUrlMap
    name: default
    properties:
      region: us-central1
      name: url-map
      defaultService: ${defaultRegionBackendService.id}
      hostRules:
        - hosts:
            - mysite.com
          pathMatcher: allpaths
      pathMatchers:
        - name: allpaths
          defaultService: ${defaultRegionBackendService.id}
          pathRules:
            - paths:
                - /*
              service: ${defaultRegionBackendService.id}
  defaultRegionBackendService:
    type: gcp:compute:RegionBackendService
    name: default
    properties:
      region: us-central1
      name: backend-service
      portName: http
      protocol: HTTP
      timeoutSec: 10
      loadBalancingScheme: INTERNAL_MANAGED
      healthChecks: ${defaultRegionHealthCheck.id}
  defaultRegionHealthCheck:
    type: gcp:compute:RegionHealthCheck
    name: default
    properties:
      region: us-central1
      name: http-health-check
      httpHealthCheck:
        port: 80

The httpKeepAliveTimeoutSec property controls how long the proxy keeps idle connections open after completing a response. The default is 600 seconds; this example sets the same value explicitly. Regional HTTP load balancers accept values between 5 and 600 seconds. Longer timeouts reduce connection overhead for clients that send frequent requests; shorter timeouts free resources faster.

Redirect HTTP requests to HTTPS

Security policies often require redirecting all HTTP traffic to HTTPS without processing requests through backend services.

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

const defaultRegionUrlMap = new gcp.compute.RegionUrlMap("default", {
    region: "us-central1",
    name: "url-map",
    defaultUrlRedirect: {
        httpsRedirect: true,
        stripQuery: false,
    },
});
const _default = new gcp.compute.RegionTargetHttpProxy("default", {
    region: "us-central1",
    name: "test-https-redirect-proxy",
    urlMap: defaultRegionUrlMap.id,
});

import pulumi
import pulumi_gcp as gcp

default_region_url_map = gcp.compute.RegionUrlMap("default",
    region="us-central1",
    name="url-map",
    default_url_redirect={
        "https_redirect": True,
        "strip_query": False,
    })
default = gcp.compute.RegionTargetHttpProxy("default",
    region="us-central1",
    name="test-https-redirect-proxy",
    url_map=default_region_url_map.id)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultRegionUrlMap, err := compute.NewRegionUrlMap(ctx, "default", &compute.RegionUrlMapArgs{
			Region: pulumi.String("us-central1"),
			Name:   pulumi.String("url-map"),
			DefaultUrlRedirect: &compute.RegionUrlMapDefaultUrlRedirectArgs{
				HttpsRedirect: pulumi.Bool(true),
				StripQuery:    pulumi.Bool(false),
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewRegionTargetHttpProxy(ctx, "default", &compute.RegionTargetHttpProxyArgs{
			Region: pulumi.String("us-central1"),
			Name:   pulumi.String("test-https-redirect-proxy"),
			UrlMap: defaultRegionUrlMap.ID(),
		})
		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 defaultRegionUrlMap = new Gcp.Compute.RegionUrlMap("default", new()
    {
        Region = "us-central1",
        Name = "url-map",
        DefaultUrlRedirect = new Gcp.Compute.Inputs.RegionUrlMapDefaultUrlRedirectArgs
        {
            HttpsRedirect = true,
            StripQuery = false,
        },
    });

    var @default = new Gcp.Compute.RegionTargetHttpProxy("default", new()
    {
        Region = "us-central1",
        Name = "test-https-redirect-proxy",
        UrlMap = defaultRegionUrlMap.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionUrlMap;
import com.pulumi.gcp.compute.RegionUrlMapArgs;
import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultUrlRedirectArgs;
import com.pulumi.gcp.compute.RegionTargetHttpProxy;
import com.pulumi.gcp.compute.RegionTargetHttpProxyArgs;
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 defaultRegionUrlMap = new RegionUrlMap("defaultRegionUrlMap", RegionUrlMapArgs.builder()
            .region("us-central1")
            .name("url-map")
            .defaultUrlRedirect(RegionUrlMapDefaultUrlRedirectArgs.builder()
                .httpsRedirect(true)
                .stripQuery(false)
                .build())
            .build());

        var default_ = new RegionTargetHttpProxy("default", RegionTargetHttpProxyArgs.builder()
            .region("us-central1")
            .name("test-https-redirect-proxy")
            .urlMap(defaultRegionUrlMap.id())
            .build());

    }
}

resources:
  default:
    type: gcp:compute:RegionTargetHttpProxy
    properties:
      region: us-central1
      name: test-https-redirect-proxy
      urlMap: ${defaultRegionUrlMap.id}
  defaultRegionUrlMap:
    type: gcp:compute:RegionUrlMap
    name: default
    properties:
      region: us-central1
      name: url-map
      defaultUrlRedirect:
        httpsRedirect: true
        stripQuery: false

The URL map’s defaultUrlRedirect property redirects all HTTP requests to HTTPS. Setting httpsRedirect to true changes the scheme; stripQuery preserves query parameters during the redirect. This configuration doesn’t reference backend services because the proxy never forwards traffic to them. You need a separate HTTPS load balancer to handle the redirected traffic.

Beyond these examples

These snippets focus on specific HTTP proxy features: URL map routing to backends, connection keep-alive tuning, and HTTPS redirect configuration. They’re intentionally minimal rather than complete load balancing deployments.

The examples may reference pre-existing infrastructure such as GCP project and region, and forwarding rules that reference the proxy. They focus on configuring the proxy rather than provisioning the entire load balancing stack.

To keep things focused, common proxy patterns are omitted, including:

Forwarding rule configuration (connects proxy to IP/port)
SSL certificate management (handled by HTTPS proxies)
Advanced URL map patterns (weighted backends, header-based routing)
Cross-region failover and traffic steering

These omissions are intentional: the goal is to illustrate how each proxy feature is wired, not provide drop-in load balancing modules. See the RegionTargetHttpProxy resource reference for all available configuration options.

Let's configure GCP Region Target HTTP Proxies

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Configuration & Setup

What does the urlMap property do and is it required?

The urlMap property is required and references a RegionUrlMap resource that defines the mapping from URLs to backend services. This is the core routing configuration for the proxy.

What happens if I don't specify region or project?

Both region and project are required properties, but they default to the provider’s configured region and project if not explicitly specified.

Naming & Constraints

What are the naming rules for RegionTargetHttpProxy?

The name must be 1-63 characters long and match the regex a-z?. This means it must start with a lowercase letter, contain only lowercase letters, digits, or dashes, and cannot end with a dash.

Connection Settings

What are the keep-alive timeout limits?

The httpKeepAliveTimeoutSec property defaults to 600 seconds if not specified. For Regional HTTP(S) load balancers, the minimum is 5 seconds and the maximum is 600 seconds.

Resource Management

What properties can't I change after creation?

The following properties are immutable and require resource recreation if changed: name, region, project, description, and httpKeepAliveTimeoutSec. Only urlMap can be updated in place.

Use Cases

Can I use this for HTTPS redirect without a backend service?

Yes, you can configure the urlMap with a defaultUrlRedirect setting to redirect HTTP traffic to HTTPS without needing a backend service, as shown in the HTTPS redirect example.

Using a different cloud?

Explore networking guides for other cloud providers:

AWS Guides Azure Guides