Setting Up TCP Proxy Load Balancing

Google Cloud Platform (GCP) TCP Proxy Load Balancing allows you to use a single IP address for all users around the world. GCP TCP proxy load balancing automatically routes traffic to the instances that are closest to the user.

This guide contains instructions for setting up TCP Proxy Load Balancing. Before you start, read TCP Proxy Load Balancing Concepts for information on how TCP Proxy Load Balancing works.

Overview

This example demonstrates setting up global TCP Proxy Load Balancing for a simple service that exists in two regions: us-central1 and us-east1. For purposes of the example, the service is a set of Apache servers configured to respond on port 110. Many browsers do not allow port 110, so the testing section uses curl.

In this example, you configure the following:

  1. Four instances distributed between two regions
  2. Instance groups, which contain the instances
  3. A health check for verifying instance health
  4. A backend service, which monitors the instances and prevents them from exceeding configured usage
  5. The target TCP proxy
  6. An external static IPv4 address and forwarding rule that sends user traffic to the proxy
  7. An external static IPv6 address and forwarding rule that sends user traffic to the proxy
  8. A firewall rule that allows traffic from the load balancer and health checker to reach the instances

After the load balancer is configured, you test the configuration.

Configuring instances and instance groups

This section shows how to create simple instance groups, add instances to them, then add those instances to a backend service with a health check. A production system would normally use managed instance groups based on instance templates, but this configuration is quicker for initial testing.

Configuring instances

For testing purposes, install Apache on four instances, two in each of two instance groups. Typically, TCP Proxy Load Balancing isn't used for HTTP traffic, but Apache is commonly-used software and is easy to set up for testing.

In this example, the instances are created with the tag tcp-lb. This tag is used later by the firewall rule.

Console


Create instances

  1. Go to the VM instances page in the Google Cloud Console.
    Go to the VM instances page
  2. Click Create instance.
  3. Set Name to ig-us-central1-1.
  4. Set the Region to us-central1.
  5. Set the Zone to us-central1-b.
  6. Click Management, security, disks, networking, sole tenancy to reveal advanced settings.
  7. Under Management, click Networking and populate the Tags field with tcp-lb.
  8. Click Management and enter the following script in the Startup script field: 
    sudo apt-get update
sudo apt-get install apache2 -y
sudo sed -i '/Listen 80/c\Listen 110' /etc/apache2/ports.conf
sudo sed -i '/<VirtualHost *:80>/c\' /etc/apache2/sites-enabled/000-default.conf
sudo service apache2 restart
echo '<!doctype html><html><body><h1>ig-us-central1-1</h1></body></html>' | sudo tee /var/www/html/index.html
  9. Leave the default values for rest of the fields.
  10. Click Create.
  11. Create ig-us-central1-2 with the same settings, except with the following script in the Startup script field: 
    sudo apt-get update
sudo apt-get install apache2 -y
sudo sed -i '/Listen 80/c\Listen 110' /etc/apache2/ports.conf
sudo sed -i '/<VirtualHost *:80>/c\' /etc/apache2/sites-enabled/000-default.conf
sudo service apache2 restart
echo '<!doctype html><html><body><h1>ig-us-central1-2</h1></body></html>' | sudo tee /var/www/html/index.html
  12. Create ig-us-east1-1 with the same settings, except with Region set to us-east1 and Zone set to us-east1-b. Enter the following script in the Startup script field: 
    sudo apt-get update
sudo apt-get install apache2 -y
sudo sed -i '/Listen 80/c\Listen 110' /etc/apache2/ports.conf
sudo sed -i '/<VirtualHost *:80>/c\' /etc/apache2/sites-enabled/000-default.conf
sudo service apache2 restart
echo '<!doctype html><html><body><h1>ig-us-east1-1</h1></body></html>' | sudo tee /var/www/html/index.html
  13. Create ig-us-east1-2 with the same settings, except with Region set to us-east1 and Zone set to us-east1-b. Enter the following script in the Startup script field: 
    sudo apt-get update
sudo apt-get install apache2 -y
sudo sed -i '/Listen 80/c\Listen 110' /etc/apache2/ports.conf
sudo sed -i '/<VirtualHost *:80>/c\' /etc/apache2/sites-enabled/000-default.conf
sudo service apache2 restart
echo '<!doctype html><html><body><h1>ig-us-east1-2</h1></body></html>' | sudo tee /var/www/html/index.html

gcloud


  1. Create ig-us-central1-1 in zone us-central1-b

    gcloud compute instances create ig-us-central1-1 \
    --image-family debian-9 \
    --image-project debian-cloud \
    --tags tcp-lb \
    --zone us-central1-b \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install apache2 -y
      sudo sed -i '/Listen 80/c\Listen 110' /etc/apache2/ports.conf
      sudo sed -i '/\/c\\' /etc/apache2/sites-enabled/000-default.conf
      sudo service apache2 restart
      echo '<!doctype html><html><body><h1>ig-us-central1-1</h1></body></html>' | tee /var/www/html/index.html
      EOF"

    Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-central1-b/instances/ig-us-central1-1].
NAME             ZONE          MACHINE_TYPE  PREEMPTIBLE INTERNAL_IP EXTERNAL_IP    STATUS
ig-us-central1-1 us-central1-b n1-standard-1             10.240.0.8  23.251.150.133 RUNNING

  2. Create ig-us-central1-2 in zone us-central1-b

    gcloud compute instances create ig-us-central1-2 \
    --image-family debian-9 \
    --image-project debian-cloud \
    --tags tcp-lb \
    --zone us-central1-b \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install apache2 -y
      sudo sed -i '/Listen 80/c\Listen 110' /etc/apache2/ports.conf
      sudo sed -i '/\/c\\' /etc/apache2/sites-enabled/000-default.conf
      sudo service apache2 restart
      echo '<!doctype html><html><body><h1>ig-us-central1-2</h1></body></html>' | tee /var/www/html/index.html
      EOF"

    Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-central1-b/instances/ig-us-central1-2].
NAME             ZONE          MACHINE_TYPE  PREEMPTIBLE INTERNAL_IP EXTERNAL_IP    STATUS
ig-us-central1-2 us-central1-b n1-standard-1             10.240.0.11 23.251.148.160 RUNNING

  3. Create ig-us-east1-1 in zone us-east1-b

    gcloud compute instances create ig-us-east1-1 \
    --image-family debian-9 \
    --image-project debian-cloud \
    --tags tcp-lb \
    --zone us-east1-b \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install apache2 -y
      sudo sed -i '/Listen 80/c\Listen 110' /etc/apache2/ports.conf
      sudo sed -i '/\/c\\' /etc/apache2/sites-enabled/000-default.conf
      sudo service apache2 restart
      echo '<!doctype html><html><body><h1>ig-us-east1-1</h1></body></html>' | tee /var/www/html/index.html
          EOF"

    Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-east1-b/instances/ig-us-east1-1].
NAME          ZONE       MACHINE_TYPE  PREEMPTIBLE INTERNAL_IP EXTERNAL_IP    STATUS
ig-us-east1-1 us-east1-b n1-standard-1             10.240.0.12 104.196.31.214 RUNNING

  4. Create ig-us-east1-2 in zone us-east1-b

    gcloud compute instances create ig-us-east1-2 \
    --image-family debian-9 \
    --image-project debian-cloud \
    --tags tcp-lb \
    --zone us-east1-b \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install apache2 -y
      sudo sed -i '/Listen 80/c\Listen 110' /etc/apache2/ports.conf
      sudo sed -i '/\/c\\' /etc/apache2/sites-enabled/000-default.conf
      sudo service apache2 restart
      echo '<!doctype html><html><body><h1>ig-us-east1-2</h1></body></html>' | tee /var/www/html/index.html
      EOF"

    Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-east1-b/instances/ig-us-east1-2].
NAME          ZONE       MACHINE_TYPE  PREEMPTIBLE INTERNAL_IP EXTERNAL_IP    STATUS
ig-us-east1-2 us-east1-b n1-standard-1             10.240.0.13 104.196.25.101 RUNNING

Creating an instance group for each zone and adding instances

Console


  1. Go to the Instance groups page in the Cloud Console.
    Go to the Instance groups page
  2. Click Create instance group.
  3. Set the Name to us-ig1.
  4. Set the Zone to us-central1-b.
  5. Click Specify port name mapping.
    1. Set Port name to tcp110.
    2. Set Port numbers to 110.
  6. Under Group type, select Unmanaged instance group.
  7. Under VM instances, select ig-us-central1-1 and ig-us-central1-2.
  8. Leave the other settings as they are.
  9. Click Create.
  10. Repeat the steps, but set the following values:
    • Name: us-ig2
    • Region: us-east1
    • Zone: us-east1-b
    • Port name: tcp110
    • Port numbers: 110
    • Instances: ig-us-east1-1 and ig-us-east1-2.

gcloud


  1. Create the us-ig1 instance group.

    gcloud compute instance-groups unmanaged create us-ig1 \
    --zone us-central1-b

    Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-central1-b/instanceGroups/us-ig1].
NAME    LOCATION       SCOPE  NETWORK  MANAGED  INSTANCES
us-ig1  us-central1-b  zone                     0

  2. Create a named port for the instance group.

    gcloud compute instance-groups set-named-ports us-ig1 \
    --named-ports tcp110:110 \
    --zone us-central1-b

    Updated [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-east1-b/instanceGroups/us-ig2].

  3. Add ig-us-central1-1 and ig-us-central1-2 to us-ig1

    gcloud compute instance-groups unmanaged add-instances us-ig1 \
    --instances ig-us-central1-1,ig-us-central1-2 \
    --zone us-central1-b

    Updated [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-central1-b/instanceGroups/us-ig1].

  4. Create the us-ig2 instance group.

    gcloud compute instance-groups unmanaged create us-ig2 \
    --zone us-east1-b

    Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-east1-b/instanceGroups/us-ig2].
NAME    LOCATION    SCOPE  NETWORK  MANAGED  INSTANCES
us-ig2  us-east1-b  zone                     0

  5. Create a named port for the instance group.

    gcloud compute instance-groups set-named-ports us-ig2 \
    --named-ports tcp110:110 \
    --zone us-east1-b

    Updated [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-east1-b/instanceGroups/us-ig2].

  6. Add ig-us-east1-1 and ig-us-east1-2 to us-ig2

    gcloud compute instance-groups unmanaged add-instances us-ig2 \
    --instances ig-us-east1-1,ig-us-east1-2 \
    --zone us-east1-b

    Updated [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/us-east1-b/instanceGroups/us-ig2].

You now have one instance group per region. Each instance group has two VM instances.

Configuring the load balancer

Console


Create the load balancer and configure a backend service

  1. Go to the Load balancing page in the Google Cloud Console.
    Go to the Load balancing page
  2. Click Create load balancer.
  3. Under TCP load balancing, click Start configuration.
  4. Set Internet facing or internal only to From Internet to my VMs.
  5. Set Multiple regions or single region to Multiple regions.
  6. Click Continue.
  7. Set the Name to my-tcp-lb.
  8. Click Backend configuration.
  9. The Name of the backend service appears as my-tcp-lb.
  10. Set Protocol to TCP.
  11. Under New backend, select instance group us-ig1.
  12. In the Instance group has a named port dialog, click Use existing port name.
  13. Leave other settings as they are.
  14. Click Add backend.
  15. Select instance group us-ig2.
  16. Set Port numbers to 110.
  17. Under Health check, select Create health check.
    1. Set the health check Name to my-tcp-health-check.
    2. Set Protocol to TCP.
    3. Set Port to 110.
    4. Leave the other settings the same.
    5. Click Save and continue.
  18. Verify that there is a check mark next to Backend configuration in the Google Cloud Console. If not, double-check that you have completed all the steps above.

Configure frontend services

  1. Click Frontend configuration.
  2. Enter a Name of my-tcp-lb-forwarding-rule.
  3. Set Protocol to TCP.
  4. Under IP, select Create IP address:
    1. Enter a Name of tcp-lb-static-ip.
    2. Click Reserve.
  5. Set Port to 110.
  6. Turn on Proxy protocol if desired.
  7. Click Done.
  8. Click Add frontend IP and port.
  9. Enter a Name of my-tcp-lb-ipv6-forwarding-rule.
  10. Select a protocol of TCP.
  11. Set IP version to IPv6.
  12. Under IP address, click Create IP address.
    1. Enter a name of tcp-lb-ipv6-static-ip.
    2. Click Reserve.
  13. Set Port to 110.
  14. Turn on Proxy protocol if desired.
  15. Click Done.
  16. Verify that there is a check mark next to Frontend configuration in the Google Cloud Console. If not, double-check that you have completed all the steps above.

Review and finalize

  1. Click Review and finalize.
  2. Double-check your settings.
  3. Click Create.

gcloud


Create a health check

gcloud compute health-checks create tcp my-tcp-health-check --port 110

Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/healthChecks/my-tcp-health-check].
NAME                PROTOCOL
my-tcp-health-check TCP

Create a backend service

gcloud compute backend-services create my-tcp-lb \
    --global \
    --protocol TCP \
    --health-checks my-tcp-health-check \
    --timeout 5m \
    --port-name tcp110

Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/my-tcp-lb].
NAME      BACKENDS PROTOCOL
my-tcp-lb          TCP

Alternatively, you can configure encrypted communication from the load balancer to the instances with --protocol SSL.

Add instance groups to your backend service

gcloud compute backend-services add-backend my-tcp-lb \
    --global \
    --instance-group us-ig1 \
    --instance-group-zone us-central1-b \
    --balancing-mode UTILIZATION \
    --max-utilization 0.8

Updated [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/my-tcp-lb].

gcloud compute backend-services add-backend my-tcp-lb \
    --global \
    --instance-group us-ig2 \
    --instance-group-zone us-east1-b \
    --balancing-mode UTILIZATION \
    --max-utilization 0.8

Updated [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/my-tcp-lb].

Configure a target TCP proxy

If you want to turn on the proxy header, set it to PROXY_V1 instead of none.

gcloud compute target-tcp-proxies create my-tcp-lb-target-proxy \
    --backend-service my-tcp-lb \
    --proxy-header NONE

Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/targetTcpProxies/my-tcp-lb-target-proxy].
NAME                   PROXY_HEADER SERVICE
my-tcp-lb-target-proxy NONE         my-tcp-lb

Reserve global static IPv4 and IPv6 addresses

Your customers can use these IP addresses to reach your load balanced service.

gcloud compute addresses create tcp-lb-static-ipv4 \
    --ip-version=IPV4 \
    --global

Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/addresses/tcp-lb-static-ipv4].
NAME                 REGION ADDRESS                 STATUS
tcp-lb-static-ip            [LB_STATIC_IPV4]        RESERVED
gcloud compute addresses create tcp-lb-static-ipv6 \
    --ip-version=IPV6 \
    --global

Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/addresses/tcp-lb-static-ipv6].
NAME                   REGION ADDRESS                 STATUS
tcp-lb-static-ip-ipv6         [LB_STATIC_IPV6]        RESERVED

Configure global forwarding rules for the two addresses

In place of [LB_STATIC_IPV4] and [LB_STATIC_IPV4], enter the relevant IP addresses. You can use gcloud compute addresses list to find them.

gcloud beta compute forwarding-rules create my-tcp-lb-ipv4-forwarding-rule \
    --global \
    --target-tcp-proxy my-tcp-lb-target-proxy \
    --address [LB_STATIC_IPV4] \
    --ports 110

Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/forwardingRules/my-tcp-lb-ipv4-forwarding-rule].
NAME                           REGION IP_ADDRESS       IP_PROTOCOL TARGET
my-tcp-lb-ipv4-forwarding-rule        [LB_STATIC_IPV4] TCP         my-tcp-lb-target-proxy

gcloud beta compute forwarding-rules create my-tcp-lb-ipv6-forwarding-rule \
    --global \
    --target-tcp-proxy my-tcp-lb-target-proxy \
    --address [LB_STATIC_IPV6] \
    --ports 110

Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/forwardingRules/my-tcp-lb-ipv6-forwarding-rule].
NAME                           REGION IP_ADDRESS       IP_PROTOCOL TARGET
my-tcp-lb-ipv6-forwarding-rule        [LB_STATIC_IPV6] TCP         my-tcp-lb-target-proxy

Creating a firewall rule for the TCP load balancer

Configure the firewall to allow traffic from the load balancer and health checker to the instances. In this case, we will open TCP port 110. The health check will use the same port. Since the traffic between the load balancer and your instances uses IPv4, only IPv4 ranges need be opened.

Console


  1. Go to the Firewall rules page in the Google Cloud Console.
    Go to the Firewalls rules page
  2. Click Create firewall rule.
  3. Enter a Name of allow-tcp-lb-and-health.
  4. Under Network, select default.
  5. Under Targets, select Specified target tags.
  6. Set Target tags to tcp-lb.
  7. Set Source filter to IP ranges.
  8. Set Source IP ranges to 130.211.0.0/22and 35.191.0.0/16.
  9. Set Allowed protocols and ports to tcp:110.
  10. Click Create.

gcloud 


 gcloud compute firewall-rules create allow-tcplb-and-health \
     --source-ranges 130.211.0.0/22,35.191.0.0/16 \
     --target-tags tcp-lb \
     --allow tcp:110

Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/firewalls/allow-tcp110-130-211-0-0-22].
NAME                     NETWORK SRC_RANGES                   RULES      SRC_TAGS TARGET_TAGS
allow-tcplb-and-health   default 130.211.0.0/22,35.191.0.0/16 tcp:110             tcp-lb

Testing your load balancer

After replacing lb_ip with your load balancer's IPv4 or IPv6 address from the IP:Port field, your load balancer can be accessed by running the following command:

curl lb_ip:110

PROXY protocol for retaining client connection information

TCP Proxy Load Balancing terminates TCP connections from the client and creates new connections to the instances. By default, the original client IP and port information is not preserved.

To preserve and send the original connection information to your instances, enable PROXY protocol (version 1). This protocol sends an additional header that contains the source IP address, destination IP address, and port numbers to the instance as a part of the request.

If you set the PROXY protocol for user traffic, you must also set it for health checks if you are serving traffic and checking health on the same port.

The PROXY protocol header will typically be a single line of user-readable text with the following format:

PROXY TCP4 <client IP> <load balancing IP> <source port> <dest port>\r\n

An example of the PROXY protocol is shown below:

PROXY TCP4 192.0.2.1 198.51.100.1 15221 110\r\n

Where client IP is 192.0.2.1, load balancing IP is 198.51.100.1, client port is 15221 and the destination port is 110.

In cases where the client IP is not known, the load balancer will generate a PROXY protocol header in the following format:

PROXY UNKNOWN\r\n

If you are checking health and serving content on the same port, you can set your health check --proxy-header to match your load balancer setting. This tutorial uses port 110 for health checking and serving content. If you are using different ports, you can set this for your health check or not, as appropriate.

Creating Health Checks

Health checks determine which instances can receive new connections. You can configure a TCP, SSL, HTTP, or HTTPS health check for determining the health of your instances.

  • If the service running on your backend instances is based on HTTP, use an HTTP health check.
  • If the service running on your backend instances is based on HTTPS, use an HTTPS health check.
  • If the service running on your backend instances is based on HTTP/2, use an HTTP/2 health check.
  • If the service running on your backend instances uses SSL, use an SSL health check.
  • Unless you have an explicit reason to use a different kind of health check, use a TCP health check.

Health check firewall rules

Health check probes to your load balanced instances come from addresses in the ranges 130.211.0.0/22 and 35.191.0.0/16. These are IP address ranges that the load balancer uses to connect to backend instances. Your firewall rules must allow these connections on the relevant port.

Note that Google Cloud Platform uses a large range of IP addresses, which change over time. If you need to determine external IP addresses at a particular time, use the instructions in the Google Compute Engine FAQ.

See the Health Checks page for details on health checks.

Connection draining

You can enable connection draining on backend services to ensure minimal interruption to your users when an instance that is serving traffic is terminated, removed manually, or removed by an autoscaler. To learn more about connection draining, read the Enabling Connection Draining documentation.

TCP Proxy Load Balancing and GCP firewalls

Unlike Network Load Balancing, access to TCP Proxy Load Balancing cannot be controlled by using firewall rules. This is because TCP Proxy Load Balancing is implemented at the edge of the Google Cloud and firewall rules are implemented on instances in the datacenter.

Monitoring

For information on monitoring TCP Proxy Load Balancing, see TCP/SSL Proxy Monitoring.

Troubleshooting

Pages fail to load from load balancer IP

Because port 110 is a restricted port for many browsers, you must use a tool such as curl to test your load balancer. If you cannot reach your pages by using curl, the rest of this section offers some troubleshooting steps.

Verify the health of instances

Verify that the instances are HEALTHY.

gcloud compute backend-services get-health [BACKEND-SERVICE]

Confirm that your firewall rule is correct

  • Both the health checker and the load balancer need 130.211.0.0/22 and 35.191.0.0/16 to be open.
  • If you are leveraging instance tags, make sure the tag is listed as under TARGET_TAGS in the firewall rule, and make sure all of your instances have that tag. In this example, instances are tagged with tcp-lb.
gcloud compute firewall-rules list

NAME                      NETWORK SRC_RANGES                    RULES          SRC_TAGS TARGET_TAGS
allow-tcplb-and-health    default 130.211.0.0/22,35.191.0.0/16  tcp:110                 tcp-lb

Try to reach individual instances

Temporarily set a firewall rule that allows you to access your instances individually, then try to load a page from a specific instance.

  1. Open the firewall to allow traffic from any source to the tagged instances.

    gcloud compute firewall-rules create allow-tcp110-0-0-0-0   \
    --source-ranges 0.0.0.0/0   \
    --target-tags tcp-lb    \
    --allow tcp:110

    Created [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/firewalls/allow-tcp110-0-0-0-0].
NAME                 NETWORK SRC_RANGES RULES   SRC_TAGS TARGET_TAGS
allow-tcp110-0-0-0-0 default 0.0.0.0/0  tcp:110          tcp-lb

  2. Look up the EXTERNAL_IP address of one of the instances.

    gcloud compute instances list

    NAME             ZONE           MACHINE_TYPE  PREEMPTIBLE INTERNAL_IP EXTERNAL_IP    STATUS
ig-us-central1-1 us-central1-b  n1-standard-1             10.240.0.8  EXTERNAL_IP RUNNING
ig-us-central1-2 us-central1-b  n1-standard-1             10.240.0.11 EXTERNAL_IP RUNNING
ig-us-east1-1    us-east1-b     n1-standard-1             10.240.0.12 EXTERNAL_IP RUNNING
ig-us-east1-2    us-east1-b     n1-standard-1             10.240.0.13 EXTERNAL_IP RUNNING

  3. Then access one or more of your instances directly from your browser.

    curl [EXTERNAL_IP]:110

  4. If your instances are not accessible by this method, make sure that your software is running correctly. If your instances are accessible individually, make sure your load balancer firewall rule is correct.

    gcloud compute firewall-rules describe allow-tcp-lb-and-health

    allowed:
  IPProtocol: tcp
    ports:
    '110'
creationTimestamp: '2017-03-16T15:21:34.119-07:00'
description: ''
id: '8144207668574597377'
kind: compute#firewall
name: allow-tcp-lb-and-health
network: https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/networks/default
selfLink: https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/firewalls/allow-tcp-lb-and-health
sourceRanges:
  130.211.0.0/22
  35.191.0.0/16
targetTags:
  tcp-lb

  5. When you're sure the instances are working, remove the "from anywhere" firewall rule.

    gcloud compute firewall-rules delete allow-tcp110-0-0-0-0

    The following firewalls will be deleted:
   [allow-tcp110-0-0-0-0]
Do you want to continue (Y/n)?  y
Deleted [https://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/firewalls/allow-tcp110-0-0-0-0].

What's next

Apakah halaman ini membantu? Beri tahu kami pendapat Anda:

Kirim masukan tentang...

Halaman ini
Masukan dokumentasi
Load Balancing
Masukan produk