171 lines
7.0 KiB
Python
171 lines
7.0 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 target pools."""
|
|
|
|
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 as calliope_exceptions
|
|
from googlecloudsdk.command_lib.compute import flags as compute_flags
|
|
from googlecloudsdk.command_lib.compute.backend_services import (
|
|
flags as backend_services_flags)
|
|
from googlecloudsdk.command_lib.compute.http_health_checks import (
|
|
flags as http_health_check_flags)
|
|
from googlecloudsdk.command_lib.compute.target_pools import flags
|
|
from googlecloudsdk.core import log
|
|
|
|
|
|
class Create(base.CreateCommand):
|
|
"""Define a load-balanced pool of virtual machine instances.
|
|
|
|
*{command}* is used to create a target pool. A target pool resource
|
|
defines a group of instances that can receive incoming traffic
|
|
from forwarding rules. When a forwarding rule directs traffic to a
|
|
target pool, Compute Engine picks an instance from the
|
|
target pool based on a hash of the source and
|
|
destination IP addresses and ports. For more
|
|
information on load balancing, see
|
|
[](https://cloud.google.com/compute/docs/load-balancing-and-autoscaling/)
|
|
|
|
To add instances to a target pool, use 'gcloud compute
|
|
target-pools add-instances'.
|
|
"""
|
|
|
|
BACKUP_POOL_ARG = None
|
|
HTTP_HEALTH_CHECK_ARG = None
|
|
TARGET_POOL_ARG = None
|
|
|
|
@classmethod
|
|
def Args(cls, parser):
|
|
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
|
|
cls.BACKUP_POOL_ARG = flags.BackupPoolArgument(required=False)
|
|
cls.HTTP_HEALTH_CHECK_ARG = (
|
|
http_health_check_flags.HttpHealthCheckArgumentForTargetPoolCreate(
|
|
required=False))
|
|
cls.HTTP_HEALTH_CHECK_ARG.AddArgument(parser)
|
|
cls.TARGET_POOL_ARG = flags.TargetPoolArgument()
|
|
cls.TARGET_POOL_ARG.AddArgument(parser, operation_type='create')
|
|
parser.display_info.AddCacheUpdater(flags.TargetPoolsCompleter)
|
|
|
|
parser.add_argument(
|
|
'--backup-pool',
|
|
help="""\
|
|
Together with ``--failover-ratio'', this flag defines the fallback
|
|
behavior of the target pool (primary pool) to be created by this
|
|
command. If the ratio of the healthy instances in the primary pool
|
|
is at or below the specified ``--failover-ratio value'', then traffic
|
|
arriving at the load-balanced IP address will be directed to the
|
|
backup pool. If this flag is provided, then ``--failover-ratio'' is
|
|
required.
|
|
""")
|
|
|
|
parser.add_argument(
|
|
'--description',
|
|
help='An optional description of this target pool.')
|
|
|
|
parser.add_argument(
|
|
'--failover-ratio',
|
|
type=float,
|
|
help="""\
|
|
Together with ``--backup-pool'', defines the fallback behavior of the
|
|
target pool (primary pool) to be created by this command. If the
|
|
ratio of the healthy instances in the primary pool is at or below this
|
|
number, traffic arriving at the load-balanced IP address will be
|
|
directed to the backup pool. For example, if 0.4 is chosen as the
|
|
failover ratio, then traffic will fail over to the backup pool if
|
|
more than 40% of the instances become unhealthy.
|
|
If not set, the traffic will be directed the
|
|
instances in this pool in the ``force'' mode, where traffic will be
|
|
spread to the healthy instances with the best effort, or to all
|
|
instances when no instance is healthy.
|
|
If this flag is provided, then ``--backup-pool'' is required.
|
|
""")
|
|
|
|
parser.add_argument(
|
|
'--health-check',
|
|
metavar='HEALTH_CHECK',
|
|
help="""\
|
|
DEPRECATED, use --http-health-check.
|
|
Specifies an HTTP health check resource to use to determine the health
|
|
of instances in this pool. If no health check is specified, traffic will
|
|
be sent to all instances in this target pool as if the instances
|
|
were healthy, but the health status of this pool will appear as
|
|
unhealthy as a warning that this target pool does not have a health
|
|
check.
|
|
""")
|
|
|
|
backend_services_flags.AddSessionAffinity(parser, target_pools=True)
|
|
|
|
def Run(self, args):
|
|
"""Issues requests necessary for adding a target pool."""
|
|
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
|
|
client = holder.client
|
|
|
|
if ((args.backup_pool and not args.IsSpecified('failover_ratio')) or
|
|
(args.failover_ratio and not args.IsSpecified('backup_pool'))):
|
|
raise calliope_exceptions.BadArgumentException(
|
|
'--failover-ratio',
|
|
'Either both or neither of [--failover-ratio] and [--backup-pool] '
|
|
'must be provided.')
|
|
|
|
if args.failover_ratio is not None:
|
|
if args.failover_ratio < 0 or args.failover_ratio > 1:
|
|
raise calliope_exceptions.InvalidArgumentException(
|
|
'--failover-ratio',
|
|
'[--failover-ratio] must be a number between 0 and 1, inclusive.')
|
|
|
|
if args.health_check:
|
|
args.http_health_check = args.health_check
|
|
log.warning('The --health-check flag is deprecated. Use equivalent '
|
|
'--http-health-check=%s flag.', args.health_check)
|
|
|
|
if args.http_health_check:
|
|
http_health_check = [self.HTTP_HEALTH_CHECK_ARG.ResolveAsResource(
|
|
args, holder.resources).SelfLink()]
|
|
|
|
else:
|
|
http_health_check = []
|
|
|
|
target_pool_ref = self.TARGET_POOL_ARG.ResolveAsResource(
|
|
args,
|
|
holder.resources,
|
|
scope_lister=compute_flags.GetDefaultScopeLister(client))
|
|
|
|
if args.backup_pool:
|
|
args.backup_pool_region = target_pool_ref.region
|
|
backup_pool_uri = self.BACKUP_POOL_ARG.ResolveAsResource(
|
|
args, holder.resources).SelfLink()
|
|
else:
|
|
backup_pool_uri = None
|
|
|
|
request = client.messages.ComputeTargetPoolsInsertRequest(
|
|
targetPool=client.messages.TargetPool(
|
|
backupPool=backup_pool_uri,
|
|
description=args.description,
|
|
failoverRatio=args.failover_ratio,
|
|
healthChecks=http_health_check,
|
|
name=target_pool_ref.Name(),
|
|
sessionAffinity=(
|
|
client.messages.TargetPool.SessionAffinityValueValuesEnum(
|
|
args.session_affinity))),
|
|
region=target_pool_ref.region,
|
|
project=target_pool_ref.project)
|
|
|
|
return client.MakeRequests([(client.apitools_client.targetPools, 'Insert',
|
|
request)])
|