diff --git a/pkg/cloudprovider/providers/gce/gce_backendservice.go b/pkg/cloudprovider/providers/gce/gce_backendservice.go
index cbbc5db7d79..8ec1a9d8250 100644
--- a/pkg/cloudprovider/providers/gce/gce_backendservice.go
+++ b/pkg/cloudprovider/providers/gce/gce_backendservice.go
@@ -17,10 +17,14 @@ limitations under the License.
 package gce
 
 import (
+	"context"
 	"net/http"
 
 	computealpha "google.golang.org/api/compute/v0.alpha"
 	compute "google.golang.org/api/compute/v1"
+
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta"
 )
 
 func newBackendServiceMetricContext(request, region string) *metricContext {
@@ -34,150 +38,113 @@ func newBackendServiceMetricContextWithVersion(request, region, version string)
 // GetGlobalBackendService retrieves a backend by name.
 func (gce *GCECloud) GetGlobalBackendService(name string) (*compute.BackendService, error) {
 	mc := newBackendServiceMetricContext("get", "")
-	v, err := gce.service.BackendServices.Get(gce.projectID, name).Do()
+	v, err := gce.c.BackendServices().Get(context.Background(), meta.GlobalKey(name))
 	return v, mc.Observe(err)
 }
 
 // GetAlphaGlobalBackendService retrieves alpha backend by name.
 func (gce *GCECloud) GetAlphaGlobalBackendService(name string) (*computealpha.BackendService, error) {
 	mc := newBackendServiceMetricContextWithVersion("get", "", computeAlphaVersion)
-	v, err := gce.serviceAlpha.BackendServices.Get(gce.projectID, name).Do()
+	v, err := gce.c.AlphaBackendServices().Get(context.Background(), meta.GlobalKey(name))
 	return v, mc.Observe(err)
 }
 
-// UpdateGlobalBackendService applies the given BackendService as an update to an existing service.
+// UpdateGlobalBackendService applies the given BackendService as an update to
+// an existing service.
 func (gce *GCECloud) UpdateGlobalBackendService(bg *compute.BackendService) error {
 	mc := newBackendServiceMetricContext("update", "")
-	op, err := gce.service.BackendServices.Update(gce.projectID, bg.Name, bg).Do()
-	if err != nil {
-		return mc.Observe(err)
-	}
-
-	return gce.waitForGlobalOp(op, mc)
+	return mc.Observe(gce.c.BackendServices().Update(context.Background(), meta.GlobalKey(bg.Name), bg))
 }
 
-// UpdateAlphaGlobalBackendService applies the given alpha BackendService as an update to an existing service.
+// UpdateAlphaGlobalBackendService applies the given alpha BackendService as an
+// update to an existing service.
 func (gce *GCECloud) UpdateAlphaGlobalBackendService(bg *computealpha.BackendService) error {
-	mc := newBackendServiceMetricContextWithVersion("update", "", computeAlphaVersion)
-	op, err := gce.serviceAlpha.BackendServices.Update(gce.projectID, bg.Name, bg).Do()
-	if err != nil {
-		return mc.Observe(err)
-	}
-
-	return gce.waitForGlobalOp(op, mc)
+	mc := newBackendServiceMetricContext("update", "")
+	return mc.Observe(gce.c.AlphaBackendServices().Update(context.Background(), meta.GlobalKey(bg.Name), bg))
 }
 
 // DeleteGlobalBackendService deletes the given BackendService by name.
 func (gce *GCECloud) DeleteGlobalBackendService(name string) error {
 	mc := newBackendServiceMetricContext("delete", "")
-	op, err := gce.service.BackendServices.Delete(gce.projectID, name).Do()
-	if err != nil {
-		if isHTTPErrorCode(err, http.StatusNotFound) {
-			return nil
-		}
-		return mc.Observe(err)
+	err := gce.c.BackendServices().Delete(context.Background(), meta.GlobalKey(name))
+	if isHTTPErrorCode(err, http.StatusNotFound) {
+		return nil
 	}
-
-	return gce.waitForGlobalOp(op, mc)
+	return mc.Observe(err)
 }
 
 // CreateGlobalBackendService creates the given BackendService.
 func (gce *GCECloud) CreateGlobalBackendService(bg *compute.BackendService) error {
 	mc := newBackendServiceMetricContext("create", "")
-	op, err := gce.service.BackendServices.Insert(gce.projectID, bg).Do()
-	if err != nil {
-		return mc.Observe(err)
-	}
-
-	return gce.waitForGlobalOp(op, mc)
+	return mc.Observe(gce.c.BackendServices().Insert(context.Background(), meta.GlobalKey(bg.Name), bg))
 }
 
 // CreateAlphaGlobalBackendService creates the given alpha BackendService.
 func (gce *GCECloud) CreateAlphaGlobalBackendService(bg *computealpha.BackendService) error {
-	mc := newBackendServiceMetricContextWithVersion("create", "", computeAlphaVersion)
-	op, err := gce.serviceAlpha.BackendServices.Insert(gce.projectID, bg).Do()
-	if err != nil {
-		return mc.Observe(err)
-	}
-
-	return gce.waitForGlobalOp(op, mc)
+	mc := newBackendServiceMetricContext("create", "")
+	return mc.Observe(gce.c.AlphaBackendServices().Insert(context.Background(), meta.GlobalKey(bg.Name), bg))
 }
 
 // ListGlobalBackendServices lists all backend services in the project.
-func (gce *GCECloud) ListGlobalBackendServices() (*compute.BackendServiceList, error) {
+func (gce *GCECloud) ListGlobalBackendServices() ([]*compute.BackendService, error) {
 	mc := newBackendServiceMetricContext("list", "")
-	// TODO: use PageToken to list all not just the first 500
-	v, err := gce.service.BackendServices.List(gce.projectID).Do()
+	v, err := gce.c.BackendServices().List(context.Background(), filter.None)
 	return v, mc.Observe(err)
 }
 
-// GetGlobalBackendServiceHealth returns the health of the BackendService identified by the given
-// name, in the given instanceGroup. The instanceGroupLink is the fully
-// qualified self link of an instance group.
+// GetGlobalBackendServiceHealth returns the health of the BackendService
+// identified by the given name, in the given instanceGroup. The
+// instanceGroupLink is the fully qualified self link of an instance group.
 func (gce *GCECloud) GetGlobalBackendServiceHealth(name string, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) {
 	mc := newBackendServiceMetricContext("get_health", "")
 	groupRef := &compute.ResourceGroupReference{Group: instanceGroupLink}
-	v, err := gce.service.BackendServices.GetHealth(gce.projectID, name, groupRef).Do()
+	v, err := gce.c.BackendServices().GetHealth(context.Background(), meta.GlobalKey(name), groupRef)
 	return v, mc.Observe(err)
 }
 
 // GetRegionBackendService retrieves a backend by name.
 func (gce *GCECloud) GetRegionBackendService(name, region string) (*compute.BackendService, error) {
 	mc := newBackendServiceMetricContext("get", region)
-	v, err := gce.service.RegionBackendServices.Get(gce.projectID, region, name).Do()
+	v, err := gce.c.RegionBackendServices().Get(context.Background(), meta.RegionalKey(name, region))
 	return v, mc.Observe(err)
 }
 
-// UpdateRegionBackendService applies the given BackendService as an update to an existing service.
+// UpdateRegionBackendService applies the given BackendService as an update to
+// an existing service.
 func (gce *GCECloud) UpdateRegionBackendService(bg *compute.BackendService, region string) error {
 	mc := newBackendServiceMetricContext("update", region)
-	op, err := gce.service.RegionBackendServices.Update(gce.projectID, region, bg.Name, bg).Do()
-	if err != nil {
-		return mc.Observe(err)
-	}
-
-	return gce.waitForRegionOp(op, region, mc)
+	return mc.Observe(gce.c.RegionBackendServices().Update(context.Background(), meta.RegionalKey(bg.Name, region), bg))
 }
 
 // DeleteRegionBackendService deletes the given BackendService by name.
 func (gce *GCECloud) DeleteRegionBackendService(name, region string) error {
 	mc := newBackendServiceMetricContext("delete", region)
-	op, err := gce.service.RegionBackendServices.Delete(gce.projectID, region, name).Do()
-	if err != nil {
-		if isHTTPErrorCode(err, http.StatusNotFound) {
-			return nil
-		}
-		return mc.Observe(err)
+	err := gce.c.RegionBackendServices().Delete(context.Background(), meta.RegionalKey(name, region))
+	if isHTTPErrorCode(err, http.StatusNotFound) {
+		err = nil
 	}
-
-	return gce.waitForRegionOp(op, region, mc)
+	return mc.Observe(err)
 }
 
 // CreateRegionBackendService creates the given BackendService.
 func (gce *GCECloud) CreateRegionBackendService(bg *compute.BackendService, region string) error {
 	mc := newBackendServiceMetricContext("create", region)
-	op, err := gce.service.RegionBackendServices.Insert(gce.projectID, region, bg).Do()
-	if err != nil {
-		return mc.Observe(err)
-	}
-
-	return gce.waitForRegionOp(op, region, mc)
+	return mc.Observe(gce.c.RegionBackendServices().Insert(context.Background(), meta.RegionalKey(bg.Name, region), bg))
 }
 
 // ListRegionBackendServices lists all backend services in the project.
-func (gce *GCECloud) ListRegionBackendServices(region string) (*compute.BackendServiceList, error) {
+func (gce *GCECloud) ListRegionBackendServices(region string) ([]*compute.BackendService, error) {
 	mc := newBackendServiceMetricContext("list", region)
-	// TODO: use PageToken to list all not just the first 500
-	v, err := gce.service.RegionBackendServices.List(gce.projectID, region).Do()
+	v, err := gce.c.RegionBackendServices().List(context.Background(), region, filter.None)
 	return v, mc.Observe(err)
 }
 
-// GetRegionalBackendServiceHealth returns the health of the BackendService identified by the given
-// name, in the given instanceGroup. The instanceGroupLink is the fully
-// qualified self link of an instance group.
+// GetRegionalBackendServiceHealth returns the health of the BackendService
+// identified by the given name, in the given instanceGroup. The
+// instanceGroupLink is the fully qualified self link of an instance group.
 func (gce *GCECloud) GetRegionalBackendServiceHealth(name, region string, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) {
 	mc := newBackendServiceMetricContext("get_health", region)
-	groupRef := &compute.ResourceGroupReference{Group: instanceGroupLink}
-	v, err := gce.service.RegionBackendServices.GetHealth(gce.projectID, region, name, groupRef).Do()
+	ref := &compute.ResourceGroupReference{Group: instanceGroupLink}
+	v, err := gce.c.RegionBackendServices().GetHealth(context.Background(), meta.RegionalKey(name, region), ref)
 	return v, mc.Observe(err)
 }