It may take a few minutes for GKE to allocate an external IP address and set up forwarding rules until the load balancer is ready to serve your application.

LoadBalancer

const helloWorldDeployment = new k8s.apps.v1.Deployment(
    `${name}-${region}`,
    {
      metadata: {
        name: "hello-kubernetes"
      },
      spec: {
        replicas: 3,
        selector: {
          matchLabels: appLabels
        },
        template: {
          metadata: {
            labels: appLabels
          },
          spec: {
            containers: [
              {
                name: name,
                image: "paulbouwer/hello-kubernetes:1.5"
                ],
                ports: [
                  {
                    containerPort: 8080
                  }
                ]
              }
            ]
          }
        }
      }
    },
    { provider: k8sProvider }
  );

  const helloWorldService = new k8s.core.v1.Service(
    `${name}-${region}`,
    {
      metadata: {
        name: name
      },
      spec: {
        selector: appLabels,
        ports: [
          {
            port: 8080
          }
        ]
      }
    },
    { provider: k8sProvider }
  );

  const helloWorldFrontend = new k8s.extensions.v1beta1.Ingress(
    `${name}-${region}`,
    {
      metadata: {
        name: name
      },
      spec: {
        rules: [
          {
            http: {
              paths: [
                {
                  path: "/",
                  backend: {
                    serviceName: name,
                    servicePort: 8080
                  }
                }
              ]
            }
          }
        ]
        // ports: [{ port: 80, targetPort: 8080, protocol: "TCP" }],
        // selector: appLabels,
      }
    },
    { provider: k8sProvider }
  );

// Default values for constructing the `Cluster` object.
  const defaultClusterOptions = {
    nodeCount: 1,
    nodeMachineType: "n1-standard-1",
    minMasterVersion: kubeVersion,
    masterUsername: "",
    masterPassword: ""
  };

  const cluster = new gcp.container.Cluster(`${name}-${region}`, {
    project,
    region: region,
    initialNodeCount: config.nodeCount || defaultClusterOptions.nodeCount,
    minMasterVersion: defaultClusterOptions.minMasterVersion,
    removeDefaultNodePool: true,
    network: network.name,
    subnetwork: subnet.name,
    masterAuth: {
      username: defaultClusterOptions.masterUsername,
      password: defaultClusterOptions.masterPassword
    }
  });

  const poolName = `${name}-${region}-default-pool`;
  const defaultNodePool = new gcp.container.NodePool(poolName, {
    name: poolName,
    cluster: cluster.name,
    version: kubeVersion,
    initialNodeCount: 1,
    location: region,
    nodeConfig: {
      machineType:
        config.nodeMachineType || defaultClusterOptions.nodeMachineType,
      oauthScopes: [
        "<https://www.googleapis.com/auth/compute>",
        "<https://www.googleapis.com/auth/devstorage.read_only>",
        "<https://www.googleapis.com/auth/logging.write>",
        "<https://www.googleapis.com/auth/monitoring>"
      ]
    },
    management: {
      autoUpgrade: false,
      autoRepair: true
    }
  });

LoadBalancer

<http://kubernetes.io/ingress.class|kubernetes.io/ingress.class>

LoadBalancer

kubectl port-forward

targetPort

port