598 lines
23 KiB
Python
598 lines
23 KiB
Python
# -*- coding: utf-8 -*- #
|
|
# Copyright 2014 Google LLC. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""Command for creating backend services.
|
|
|
|
There are separate alpha, beta, and GA command classes in this file.
|
|
"""
|
|
|
|
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import unicode_literals
|
|
|
|
from googlecloudsdk.api_lib.compute import base_classes
|
|
from googlecloudsdk.calliope import base
|
|
from googlecloudsdk.calliope import exceptions
|
|
from googlecloudsdk.command_lib.compute import cdn_flags_utils as cdn_flags
|
|
from googlecloudsdk.command_lib.compute import exceptions as compute_exceptions
|
|
from googlecloudsdk.command_lib.compute import flags as compute_flags
|
|
from googlecloudsdk.command_lib.compute import reference_utils
|
|
from googlecloudsdk.command_lib.compute import resource_manager_tags_utils
|
|
from googlecloudsdk.command_lib.compute import signed_url_flags
|
|
from googlecloudsdk.command_lib.compute.backend_services import backend_services_utils
|
|
from googlecloudsdk.command_lib.compute.backend_services import flags
|
|
from googlecloudsdk.core import log
|
|
|
|
|
|
def _ResolvePortName(args):
|
|
"""Determine port name if one was not specified."""
|
|
if args.port_name:
|
|
return args.port_name
|
|
|
|
def _LogAndReturn(port_name):
|
|
log.status.Print('Backend-services\' port_name automatically resolved to '
|
|
'{} based on the service protocol.'.format(port_name))
|
|
return port_name
|
|
|
|
if args.protocol == 'HTTPS':
|
|
return _LogAndReturn('https')
|
|
if args.protocol == 'HTTP2':
|
|
return _LogAndReturn('http2')
|
|
if args.protocol == 'SSL':
|
|
return _LogAndReturn('ssl')
|
|
if args.protocol == 'TCP':
|
|
return _LogAndReturn('tcp')
|
|
|
|
return 'http'
|
|
|
|
|
|
def _ResolveProtocol(messages, args, default='HTTP'):
|
|
valid_options = messages.BackendService.ProtocolValueValuesEnum.names()
|
|
if args.protocol and args.protocol not in valid_options:
|
|
raise ValueError('{} is not a supported option. See the help text of '
|
|
'--protocol for supported options.'.format(args.protocol))
|
|
return messages.BackendService.ProtocolValueValuesEnum(args.protocol or
|
|
default)
|
|
|
|
|
|
def AddIapFlag(parser):
|
|
# TODO(b/34479878): It would be nice if the auto-generated help text were
|
|
# a bit better so we didn't need to be quite so verbose here.
|
|
flags.AddIap(
|
|
parser,
|
|
help="""\
|
|
Configure Identity Aware Proxy (IAP) for external HTTP(S) load balancing.
|
|
You can configure IAP to be `enabled` or `disabled` (default). If enabled,
|
|
you can provide values for `oauth2-client-id` and `oauth2-client-secret`.
|
|
For example, `--iap=enabled,oauth2-client-id=foo,oauth2-client-secret=bar`
|
|
turns IAP on, and `--iap=disabled` turns it off. For more information, see
|
|
https://cloud.google.com/iap/.
|
|
""")
|
|
|
|
|
|
class CreateHelper(object):
|
|
"""Helper class to create a backend service."""
|
|
|
|
HEALTH_CHECK_ARG = None
|
|
HTTP_HEALTH_CHECK_ARG = None
|
|
HTTPS_HEALTH_CHECK_ARG = None
|
|
|
|
@classmethod
|
|
def Args(
|
|
cls,
|
|
parser,
|
|
support_subsetting_subset_size,
|
|
support_ip_port_dynamic_forwarding,
|
|
support_zonal_affinity,
|
|
support_allow_multinetwork,
|
|
support_identity,
|
|
):
|
|
"""Add flags to create a backend service to the parser."""
|
|
|
|
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
|
|
flags.GLOBAL_REGIONAL_BACKEND_SERVICE_ARG.AddArgument(
|
|
parser, operation_type='create')
|
|
flags.AddDescription(parser)
|
|
cls.HEALTH_CHECK_ARG = flags.HealthCheckArgument()
|
|
cls.HEALTH_CHECK_ARG.AddArgument(parser, cust_metavar='HEALTH_CHECK')
|
|
cls.HTTP_HEALTH_CHECK_ARG = flags.HttpHealthCheckArgument()
|
|
cls.HTTP_HEALTH_CHECK_ARG.AddArgument(
|
|
parser, cust_metavar='HTTP_HEALTH_CHECK')
|
|
cls.HTTPS_HEALTH_CHECK_ARG = flags.HttpsHealthCheckArgument()
|
|
cls.HTTPS_HEALTH_CHECK_ARG.AddArgument(
|
|
parser, cust_metavar='HTTPS_HEALTH_CHECK')
|
|
flags.AddServiceLoadBalancingPolicy(parser)
|
|
flags.AddBackendServiceTlsSettings(
|
|
parser, support_identity=support_identity
|
|
)
|
|
flags.AddServiceBindings(parser)
|
|
flags.AddTimeout(parser)
|
|
flags.AddPortName(parser)
|
|
flags.AddProtocol(parser, default=None)
|
|
flags.AddEnableCdn(parser)
|
|
flags.AddSessionAffinity(parser, support_stateful_affinity=True)
|
|
flags.AddAffinityCookie(parser, support_stateful_affinity=True)
|
|
flags.AddConnectionDrainingTimeout(parser)
|
|
flags.AddLoadBalancingScheme(parser)
|
|
flags.AddCustomRequestHeaders(parser, remove_all_flag=False)
|
|
flags.AddCacheKeyIncludeProtocol(parser, default=True)
|
|
flags.AddCacheKeyIncludeHost(parser, default=True)
|
|
flags.AddCacheKeyIncludeQueryString(parser, default=True)
|
|
flags.AddCacheKeyQueryStringList(parser)
|
|
flags.AddCacheKeyExtendedCachingArgs(parser)
|
|
AddIapFlag(parser)
|
|
parser.display_info.AddCacheUpdater(flags.BackendServicesCompleter)
|
|
signed_url_flags.AddSignedUrlCacheMaxAge(parser, required=False)
|
|
|
|
flags.AddSubsettingPolicy(parser)
|
|
if support_subsetting_subset_size:
|
|
flags.AddSubsettingSubsetSize(parser)
|
|
|
|
flags.AddConnectionDrainOnFailover(parser, default=None)
|
|
flags.AddDropTrafficIfUnhealthy(parser, default=None)
|
|
flags.AddFailoverRatio(parser)
|
|
flags.AddEnableLogging(parser)
|
|
flags.AddLoggingSampleRate(parser)
|
|
flags.AddLoggingOptional(parser)
|
|
flags.AddLoggingOptionalFields(parser)
|
|
flags.AddNetwork(parser)
|
|
flags.AddLocalityLbPolicy(parser)
|
|
|
|
cdn_flags.AddCdnPolicyArgs(parser, 'backend service')
|
|
|
|
flags.AddConnectionTrackingPolicy(parser)
|
|
flags.AddCompressionMode(parser)
|
|
flags.AddIpAddressSelectionPolicy(parser)
|
|
flags.AddBackendServiceCustomMetrics(parser)
|
|
if support_ip_port_dynamic_forwarding:
|
|
flags.AddIpPortDynamicForwarding(parser)
|
|
if support_zonal_affinity:
|
|
flags.AddZonalAffinity(parser)
|
|
if support_allow_multinetwork:
|
|
flags.AddAllowMultinetwork(parser)
|
|
flags.AddResourceManagerTags(parser)
|
|
|
|
def __init__(
|
|
self,
|
|
support_subsetting_subset_size,
|
|
release_track,
|
|
support_ip_port_dynamic_forwarding,
|
|
support_zonal_affinity,
|
|
support_allow_multinetwork,
|
|
support_identity,
|
|
):
|
|
self._support_subsetting_subset_size = support_subsetting_subset_size
|
|
self._support_ip_port_dynamic_forwarding = (
|
|
support_ip_port_dynamic_forwarding
|
|
)
|
|
self._support_zonal_affinity = support_zonal_affinity
|
|
self._support_allow_multinetwork = support_allow_multinetwork
|
|
self._release_track = release_track
|
|
self._support_identity = support_identity
|
|
|
|
def _CreateGlobalRequests(self, holder, args, backend_services_ref):
|
|
"""Returns a global backend service create request."""
|
|
|
|
if args.load_balancing_scheme == 'INTERNAL':
|
|
raise exceptions.RequiredArgumentException(
|
|
'--region', 'Must specify --region for internal load balancer.')
|
|
if backend_services_utils.HasFailoverPolicyArgs(args):
|
|
raise exceptions.InvalidArgumentException(
|
|
'--global',
|
|
'failover policy parameters are only for regional passthrough '
|
|
'Network Load Balancers.')
|
|
backend_service = self._CreateBackendService(holder, args,
|
|
backend_services_ref)
|
|
|
|
client = holder.client
|
|
if args.connection_draining_timeout is not None:
|
|
backend_service.connectionDraining = (
|
|
client.messages.ConnectionDraining(
|
|
drainingTimeoutSec=args.connection_draining_timeout))
|
|
|
|
if args.enable_cdn is not None:
|
|
backend_service.enableCDN = args.enable_cdn
|
|
|
|
backend_services_utils.ApplyCdnPolicyArgs(
|
|
client,
|
|
args,
|
|
backend_service,
|
|
is_update=False,
|
|
apply_signed_url_cache_max_age=True)
|
|
|
|
if args.service_lb_policy is not None:
|
|
backend_service.serviceLbPolicy = reference_utils.BuildServiceLbPolicyUrl(
|
|
project_name=backend_services_ref.project,
|
|
location='global',
|
|
policy_name=args.service_lb_policy,
|
|
release_track=self._release_track,
|
|
)
|
|
if args.tls_settings is not None or (
|
|
self._support_identity and hasattr(args, 'identity') and args.identity
|
|
):
|
|
backend_services_utils.ApplyTlsSettingsArgs(
|
|
client,
|
|
args,
|
|
backend_service,
|
|
backend_services_ref.project,
|
|
'global',
|
|
self._release_track,
|
|
)
|
|
if args.service_bindings is not None:
|
|
backend_service.serviceBindings = [
|
|
reference_utils.BuildServiceBindingUrl(backend_services_ref.project,
|
|
'global', binding_name)
|
|
for binding_name in args.service_bindings
|
|
]
|
|
if args.compression_mode is not None:
|
|
backend_service.compressionMode = (
|
|
client.messages.BackendService.CompressionModeValueValuesEnum(
|
|
args.compression_mode))
|
|
|
|
backend_services_utils.ApplySubsettingArgs(
|
|
client, args, backend_service, self._support_subsetting_subset_size
|
|
)
|
|
if args.session_affinity is not None:
|
|
backend_service.sessionAffinity = (
|
|
client.messages.BackendService.SessionAffinityValueValuesEnum(
|
|
args.session_affinity))
|
|
backend_services_utils.ApplyAffinityCookieArgs(
|
|
client, args, backend_service
|
|
)
|
|
if args.custom_request_header is not None:
|
|
backend_service.customRequestHeaders = args.custom_request_header
|
|
if args.custom_response_header is not None:
|
|
backend_service.customResponseHeaders = args.custom_response_header
|
|
if (backend_service.cdnPolicy is not None and
|
|
backend_service.cdnPolicy.cacheMode and args.enable_cdn is not False): # pylint: disable=g-bool-id-comparison
|
|
backend_service.enableCDN = True
|
|
|
|
if args.locality_lb_policy is not None:
|
|
backend_service.localityLbPolicy = (
|
|
client.messages.BackendService.LocalityLbPolicyValueValuesEnum(
|
|
args.locality_lb_policy))
|
|
|
|
if args.resource_manager_tags is not None:
|
|
backend_service.params = self._CreateBackendServiceParams(
|
|
client.messages, args.resource_manager_tags)
|
|
|
|
self._ApplyIapArgs(client.messages, args.iap, backend_service)
|
|
|
|
if args.load_balancing_scheme != 'EXTERNAL':
|
|
backend_service.loadBalancingScheme = (
|
|
client.messages.BackendService.LoadBalancingSchemeValueValuesEnum(
|
|
args.load_balancing_scheme))
|
|
|
|
backend_services_utils.ApplyLogConfigArgs(
|
|
client.messages,
|
|
args,
|
|
backend_service,
|
|
)
|
|
|
|
backend_services_utils.ApplyIpAddressSelectionPolicyArgs(
|
|
client, args, backend_service
|
|
)
|
|
|
|
backend_services_utils.ApplyCustomMetrics(args, backend_service)
|
|
|
|
if self._support_ip_port_dynamic_forwarding:
|
|
backend_services_utils.IpPortDynamicForwarding(
|
|
client, args, backend_service
|
|
)
|
|
|
|
if self._support_allow_multinetwork:
|
|
backend_service.allowMultinetwork = args.allow_multinetwork
|
|
|
|
request = client.messages.ComputeBackendServicesInsertRequest(
|
|
backendService=backend_service, project=backend_services_ref.project
|
|
)
|
|
|
|
return [(client.apitools_client.backendServices, 'Insert', request)]
|
|
|
|
def _CreateRegionalRequests(self, holder, args, backend_services_ref):
|
|
"""Returns a regional backend service create request."""
|
|
|
|
if (
|
|
not args.cache_key_include_host
|
|
or not args.cache_key_include_protocol
|
|
or not args.cache_key_include_query_string
|
|
or args.cache_key_query_string_blacklist is not None
|
|
or args.cache_key_query_string_whitelist is not None
|
|
):
|
|
raise compute_exceptions.ArgumentError(
|
|
'Custom cache key flags cannot be used for regional requests.'
|
|
)
|
|
|
|
if args.IsSpecified('network') and args.load_balancing_scheme != 'INTERNAL':
|
|
raise exceptions.InvalidArgumentException(
|
|
'--network', 'can only specify network for INTERNAL backend service.'
|
|
)
|
|
|
|
backend_service = self._CreateRegionBackendService(
|
|
holder, args, backend_services_ref
|
|
)
|
|
client = holder.client
|
|
|
|
if args.connection_draining_timeout is not None:
|
|
backend_service.connectionDraining = client.messages.ConnectionDraining(
|
|
drainingTimeoutSec=args.connection_draining_timeout
|
|
)
|
|
if args.custom_request_header is not None:
|
|
backend_service.customRequestHeaders = args.custom_request_header
|
|
if args.custom_response_header is not None:
|
|
backend_service.customResponseHeaders = args.custom_response_header
|
|
backend_services_utils.ApplyFailoverPolicyArgs(
|
|
client.messages, args, backend_service
|
|
)
|
|
if args.service_lb_policy is not None:
|
|
raise compute_exceptions.ArgumentError(
|
|
'--service-lb-policy flag cannot be used for regional backend'
|
|
' service.'
|
|
)
|
|
|
|
if args.tls_settings is not None or (
|
|
self._support_identity and hasattr(args, 'identity') and args.identity
|
|
):
|
|
backend_services_utils.ApplyTlsSettingsArgs(
|
|
client,
|
|
args,
|
|
backend_service,
|
|
backend_services_ref.project,
|
|
backend_services_ref.region,
|
|
self._release_track,
|
|
)
|
|
|
|
if args.service_bindings is not None:
|
|
backend_service.serviceBindings = [
|
|
reference_utils.BuildServiceBindingUrl(
|
|
backend_services_ref.project,
|
|
backend_services_ref.region,
|
|
binding_name,
|
|
)
|
|
for binding_name in args.service_bindings
|
|
]
|
|
|
|
backend_services_utils.ApplySubsettingArgs(
|
|
client, args, backend_service, self._support_subsetting_subset_size
|
|
)
|
|
backend_services_utils.ApplyConnectionTrackingPolicyArgs(
|
|
client, args, backend_service)
|
|
|
|
self._ApplyIapArgs(client.messages, args.iap, backend_service)
|
|
|
|
if args.session_affinity is not None:
|
|
backend_service.sessionAffinity = (
|
|
client.messages.BackendService.SessionAffinityValueValuesEnum(
|
|
args.session_affinity))
|
|
|
|
if args.port_name is not None:
|
|
backend_service.portName = args.port_name
|
|
|
|
if args.IsSpecified('network'):
|
|
backend_service.network = flags.NETWORK_ARG.ResolveAsResource(
|
|
args, holder.resources).SelfLink()
|
|
|
|
if args.locality_lb_policy is not None:
|
|
backend_service.localityLbPolicy = (
|
|
client.messages.BackendService.LocalityLbPolicyValueValuesEnum(
|
|
args.locality_lb_policy))
|
|
|
|
if args.resource_manager_tags is not None:
|
|
backend_service.params = self._CreateBackendServiceParams(
|
|
client.messages, args.resource_manager_tag)
|
|
|
|
backend_services_utils.ApplyAffinityCookieArgs(
|
|
client, args, backend_service
|
|
)
|
|
|
|
backend_services_utils.ApplyLogConfigArgs(
|
|
client.messages,
|
|
args,
|
|
backend_service,
|
|
)
|
|
|
|
backend_services_utils.ApplyIpAddressSelectionPolicyArgs(
|
|
client, args, backend_service
|
|
)
|
|
|
|
backend_services_utils.ApplyCustomMetrics(args, backend_service)
|
|
|
|
if self._support_ip_port_dynamic_forwarding:
|
|
backend_services_utils.IpPortDynamicForwarding(
|
|
client, args, backend_service
|
|
)
|
|
|
|
if self._support_zonal_affinity:
|
|
backend_services_utils.ZonalAffinity(client, args, backend_service)
|
|
|
|
if self._support_allow_multinetwork:
|
|
backend_service.allowMultinetwork = args.allow_multinetwork
|
|
|
|
request = client.messages.ComputeRegionBackendServicesInsertRequest(
|
|
backendService=backend_service,
|
|
region=backend_services_ref.region,
|
|
project=backend_services_ref.project)
|
|
|
|
return [(client.apitools_client.regionBackendServices, 'Insert', request)]
|
|
|
|
def _CreateBackendService(self, holder, args, backend_services_ref):
|
|
health_checks = flags.GetHealthCheckUris(args, self, holder.resources)
|
|
enable_cdn = True if args.enable_cdn else None
|
|
|
|
return holder.client.messages.BackendService(
|
|
description=args.description,
|
|
name=backend_services_ref.Name(),
|
|
healthChecks=health_checks,
|
|
portName=_ResolvePortName(args),
|
|
protocol=_ResolveProtocol(holder.client.messages, args),
|
|
timeoutSec=args.timeout,
|
|
enableCDN=enable_cdn)
|
|
|
|
def _CreateRegionBackendService(self, holder, args, backend_services_ref):
|
|
"""Creates a regional backend service."""
|
|
|
|
health_checks = flags.GetHealthCheckUris(args, self, holder.resources)
|
|
messages = holder.client.messages
|
|
|
|
return messages.BackendService(
|
|
description=args.description,
|
|
name=backend_services_ref.Name(),
|
|
healthChecks=health_checks,
|
|
loadBalancingScheme=(
|
|
messages.BackendService.LoadBalancingSchemeValueValuesEnum(
|
|
args.load_balancing_scheme)),
|
|
protocol=_ResolveProtocol(messages, args, default='TCP'),
|
|
timeoutSec=args.timeout)
|
|
|
|
def _ApplyIapArgs(self, messages, iap_arg, backend_service):
|
|
if iap_arg is not None:
|
|
backend_service.iap = backend_services_utils.GetIAP(iap_arg, messages)
|
|
if backend_service.iap.enabled:
|
|
log.warning(backend_services_utils.IapBestPracticesNotice())
|
|
if (backend_service.iap.enabled and backend_service.protocol
|
|
is not messages.BackendService.ProtocolValueValuesEnum.HTTPS):
|
|
log.warning(backend_services_utils.IapHttpWarning())
|
|
|
|
def Run(self, args, holder):
|
|
"""Issues request necessary to create Backend Service."""
|
|
|
|
client = holder.client
|
|
ref = flags.GLOBAL_REGIONAL_BACKEND_SERVICE_ARG.ResolveAsResource(
|
|
args,
|
|
holder.resources,
|
|
scope_lister=compute_flags.GetDefaultScopeLister(client))
|
|
if ref.Collection() == 'compute.backendServices':
|
|
requests = self._CreateGlobalRequests(holder, args, ref)
|
|
elif ref.Collection() == 'compute.regionBackendServices':
|
|
requests = self._CreateRegionalRequests(holder, args, ref)
|
|
|
|
return client.MakeRequests(requests)
|
|
|
|
def _CreateBackendServiceParams(self, messages, resource_manager_tags):
|
|
resource_manager_tags_map = (
|
|
resource_manager_tags_utils.GetResourceManagerTags(
|
|
resource_manager_tags
|
|
)
|
|
)
|
|
params = messages.BackendServiceParams
|
|
additional_properties = [
|
|
params.ResourceManagerTagsValue.AdditionalProperty(key=key, value=value)
|
|
for key, value in sorted(resource_manager_tags_map.items())
|
|
]
|
|
return params(
|
|
resourceManagerTags=params.ResourceManagerTagsValue(
|
|
additionalProperties=additional_properties
|
|
)
|
|
)
|
|
|
|
|
|
@base.UniverseCompatible
|
|
@base.ReleaseTracks(base.ReleaseTrack.GA)
|
|
class CreateGA(base.CreateCommand):
|
|
"""Create a backend service.
|
|
|
|
*{command}* creates a backend service for a Google Cloud load balancer or
|
|
Traffic Director. A backend service defines how to distribute traffic to
|
|
backends. Depending on the load balancing scheme of the backend service,
|
|
backends can be instance groups (managed or unmanaged), zonal network endpoint
|
|
groups (zonal NEGs), serverless NEGs, or an internet NEG. For more
|
|
information, see the [backend services
|
|
overview](https://cloud.google.com/load-balancing/docs/backend-service).
|
|
|
|
After you create a backend service, you add backends by using `gcloud
|
|
compute backend-services add-backend` or `gcloud compute backend-services
|
|
edit`.
|
|
|
|
"""
|
|
|
|
_support_subsetting_subset_size = False
|
|
_support_ip_port_dynamic_forwarding = False
|
|
_support_zonal_affinity = False
|
|
_support_allow_multinetwork = False
|
|
_support_identity = False
|
|
|
|
@classmethod
|
|
def Args(cls, parser):
|
|
CreateHelper.Args(
|
|
parser,
|
|
support_subsetting_subset_size=cls._support_subsetting_subset_size,
|
|
support_ip_port_dynamic_forwarding=cls._support_ip_port_dynamic_forwarding,
|
|
support_zonal_affinity=cls._support_zonal_affinity,
|
|
support_allow_multinetwork=cls._support_allow_multinetwork,
|
|
support_identity=cls._support_identity,
|
|
)
|
|
|
|
def Run(self, args):
|
|
"""Issues request necessary to create Backend Service."""
|
|
|
|
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
|
|
return CreateHelper(
|
|
support_subsetting_subset_size=self._support_subsetting_subset_size,
|
|
support_ip_port_dynamic_forwarding=self._support_ip_port_dynamic_forwarding,
|
|
support_zonal_affinity=self._support_zonal_affinity,
|
|
support_allow_multinetwork=self._support_allow_multinetwork,
|
|
release_track=self.ReleaseTrack(),
|
|
support_identity=self._support_identity,
|
|
).Run(args, holder)
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.BETA)
|
|
class CreateBeta(CreateGA):
|
|
"""Create a backend service.
|
|
|
|
*{command}* creates a backend service. A backend service defines how Cloud
|
|
Load Balancing distributes traffic. The backend service configuration contains
|
|
a set of values, such as the protocol used to connect to backends, various
|
|
distribution and session settings, health checks, and timeouts. These settings
|
|
provide fine-grained control over how your load balancer behaves. Most of the
|
|
settings have default values that allow for easy configuration if you need to
|
|
get started quickly.
|
|
|
|
After you create a backend service, you add backends by using `gcloud
|
|
compute backend-services add-backend`.
|
|
|
|
For more information about the available settings, see
|
|
https://cloud.google.com/load-balancing/docs/backend-service.
|
|
"""
|
|
_support_subsetting_subset_size = True
|
|
_support_ip_port_dynamic_forwarding = True
|
|
_support_zonal_affinity = True
|
|
_support_allow_multinetwork = False
|
|
_support_identity = True
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
|
|
class CreateAlpha(CreateBeta):
|
|
"""Create a backend service.
|
|
|
|
*{command}* creates a backend service. A backend service defines how Cloud
|
|
Load Balancing distributes traffic. The backend service configuration contains
|
|
a set of values, such as the protocol used to connect to backends, various
|
|
distribution and session settings, health checks, and timeouts. These settings
|
|
provide fine-grained control over how your load balancer behaves. Most of the
|
|
settings have default values that allow for easy configuration if you need to
|
|
get started quickly.
|
|
|
|
After you create a backend service, you add backends by using `gcloud
|
|
compute backend-services add-backend`.
|
|
|
|
For more information about the available settings, see
|
|
https://cloud.google.com/load-balancing/docs/backend-service.
|
|
"""
|
|
_support_subsetting_subset_size = True
|
|
_support_ip_port_dynamic_forwarding = True
|
|
_support_zonal_affinity = True
|
|
_support_allow_multinetwork = True
|
|
_support_identity = True
|