321 lines
11 KiB
Python
321 lines
11 KiB
Python
# -*- coding: utf-8 -*- #
|
|
# Copyright 2015 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.
|
|
"""Upgrade cluster command."""
|
|
|
|
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import unicode_literals
|
|
|
|
from apitools.base.py import exceptions as apitools_exceptions
|
|
|
|
from googlecloudsdk.api_lib.container import api_adapter
|
|
from googlecloudsdk.api_lib.container import util
|
|
from googlecloudsdk.calliope import base
|
|
from googlecloudsdk.calliope import exceptions
|
|
from googlecloudsdk.command_lib.container import container_command_util
|
|
from googlecloudsdk.command_lib.container import flags
|
|
from googlecloudsdk.core import log
|
|
from googlecloudsdk.core import properties
|
|
from googlecloudsdk.core.console import console_attr
|
|
from googlecloudsdk.core.console import console_io
|
|
from googlecloudsdk.core.util import iso_duration
|
|
from googlecloudsdk.core.util import times
|
|
from googlecloudsdk.core.util.semver import SemVer
|
|
|
|
|
|
class UpgradeHelpText(object):
|
|
"""Upgrade available help text messages."""
|
|
UPGRADE_AVAILABLE = """
|
|
* - There is an upgrade available for your cluster(s).
|
|
"""
|
|
|
|
SUPPORT_ENDING = """
|
|
** - The current version of your cluster(s) will soon be out of support, please upgrade.
|
|
"""
|
|
|
|
UNSUPPORTED = """
|
|
*** - The current version of your cluster(s) is unsupported, please upgrade.
|
|
"""
|
|
|
|
UPGRADE_COMMAND = """
|
|
To upgrade nodes to the latest available version, run
|
|
$ gcloud container clusters upgrade {name}"""
|
|
|
|
|
|
class VersionVerifier(object):
|
|
"""Compares the cluster and master versions for upgrade availablity."""
|
|
UP_TO_DATE = 0
|
|
UPGRADE_AVAILABLE = 1
|
|
SUPPORT_ENDING = 2
|
|
UNSUPPORTED = 3
|
|
|
|
def Compare(self, current_master_version, current_cluster_version):
|
|
"""Compares the cluster and master versions and returns an enum."""
|
|
if current_master_version == current_cluster_version:
|
|
return self.UP_TO_DATE
|
|
master_version = SemVer(current_master_version)
|
|
cluster_version = SemVer(current_cluster_version)
|
|
major, minor, _ = master_version.Distance(cluster_version)
|
|
if major != 0 or minor > 2:
|
|
return self.UNSUPPORTED
|
|
elif minor > 1:
|
|
return self.SUPPORT_ENDING
|
|
else:
|
|
return self.UPGRADE_AVAILABLE
|
|
|
|
|
|
def ParseUpgradeOptionsBase(args):
|
|
"""Parses the flags provided with the cluster upgrade command."""
|
|
opts = api_adapter.UpdateClusterOptions(
|
|
version=args.cluster_version,
|
|
update_master=args.master,
|
|
update_nodes=(not args.master),
|
|
node_pool=args.node_pool,
|
|
image_type=args.image_type,
|
|
image=args.image,
|
|
image_project=args.image_project,
|
|
)
|
|
if args.control_plane_soak_duration:
|
|
opts.control_plane_soak_duration = times.FormatDurationForJson(
|
|
iso_duration.Duration(seconds=args.control_plane_soak_duration)
|
|
)
|
|
return opts
|
|
|
|
|
|
def _Args(parser):
|
|
"""Register flags for this command.
|
|
|
|
Args:
|
|
parser: An argparse.ArgumentParser-like object. It is mocked out in order to
|
|
capture some information, but behaves like an ArgumentParser.
|
|
"""
|
|
parser.add_argument(
|
|
'name', metavar='NAME', help='The name of the cluster to upgrade.')
|
|
flags.AddClusterVersionFlag(
|
|
parser,
|
|
help="""\
|
|
The GKE release version to which to upgrade the cluster's node pools or master.
|
|
|
|
If desired cluster version is omitted, *node pool* upgrades default to the current
|
|
*master* version and *master* upgrades default to the default cluster version,
|
|
which can be found in the server config.
|
|
|
|
You can find the list of allowed versions for upgrades by running:
|
|
|
|
$ gcloud container get-server-config
|
|
""")
|
|
parser.add_argument('--node-pool', help='The node pool to upgrade.')
|
|
parser.add_argument(
|
|
'--master',
|
|
help=(
|
|
"Upgrade the cluster's master. Node pools cannot be upgraded at the "
|
|
' same time as the master.'
|
|
),
|
|
action='store_true',
|
|
)
|
|
# Timeout in seconds for the operation, default 3600 seconds (60 minutes)
|
|
parser.add_argument(
|
|
'--timeout',
|
|
type=int,
|
|
default=3600,
|
|
hidden=True,
|
|
help='Timeout (seconds) for waiting on the operation to complete.')
|
|
flags.AddAsyncFlag(parser)
|
|
flags.AddImageTypeFlag(parser, 'cluster/node pool')
|
|
flags.AddImageFlag(parser, hidden=True)
|
|
flags.AddImageProjectFlag(parser, hidden=True)
|
|
|
|
|
|
def MaybeLog122UpgradeWarning(cluster):
|
|
"""Logs deprecation warning for GKE v1.22 upgrades."""
|
|
if cluster is not None:
|
|
cmv = SemVer(cluster.currentMasterVersion)
|
|
if cmv >= SemVer('1.22.0-gke.0'):
|
|
return
|
|
|
|
log.status.Print(
|
|
'Upcoming breaking change: Starting with v1.22, Kubernetes has removed '
|
|
'several v1beta1 APIs for more stable v1 APIs. Read more about this '
|
|
'change - '
|
|
'https://cloud.google.com/kubernetes-engine/docs/deprecations/apis-1-22. '
|
|
'Please ensure that your cluster is not using any deprecated v1beta1 '
|
|
'APIs prior to upgrading to GKE 1.22.')
|
|
|
|
|
|
@base.DefaultUniverseOnly
|
|
@base.ReleaseTracks(base.ReleaseTrack.GA)
|
|
class Upgrade(base.Command):
|
|
"""Upgrade the Kubernetes version of an existing container cluster."""
|
|
|
|
@staticmethod
|
|
def Args(parser):
|
|
_Args(parser)
|
|
flags.AddControlPlaneSoakDurationFlag(parser, hidden=True)
|
|
|
|
def ParseUpgradeOptions(self, args):
|
|
return ParseUpgradeOptionsBase(args)
|
|
|
|
def Run(self, args):
|
|
"""This is what gets called when the user runs this command.
|
|
|
|
Args:
|
|
args: an argparse namespace. All the arguments that were provided to this
|
|
command invocation.
|
|
|
|
Returns:
|
|
Some value that we want to have printed later.
|
|
"""
|
|
adapter = self.context['api_adapter']
|
|
location_get = self.context['location_get']
|
|
location = location_get(args)
|
|
cluster_ref = adapter.ParseCluster(args.name, location)
|
|
project_id = properties.VALUES.core.project.Get(required=True)
|
|
|
|
try:
|
|
cluster = adapter.GetCluster(cluster_ref)
|
|
except (exceptions.HttpException, apitools_exceptions.HttpForbiddenError,
|
|
util.Error) as error:
|
|
log.warning(('Problem loading details of cluster to upgrade:\n\n{}\n\n'
|
|
'You can still attempt to upgrade the cluster.\n').format(
|
|
console_attr.SafeText(error)))
|
|
cluster = None
|
|
|
|
try:
|
|
server_conf = adapter.GetServerConfig(project_id, location)
|
|
except (exceptions.HttpException, apitools_exceptions.HttpForbiddenError,
|
|
util.Error) as error:
|
|
log.warning(('Problem loading server config:\n\n{}\n\n'
|
|
'You can still attempt to upgrade the cluster.\n').format(
|
|
console_attr.SafeText(error)))
|
|
server_conf = None
|
|
|
|
if args.control_plane_soak_duration and not args.master:
|
|
raise exceptions.InvalidArgumentException(
|
|
'--control-plane-soak-duration',
|
|
'--control-plane-soak-duration can only be specified with --master')
|
|
|
|
upgrade_message = container_command_util.ClusterUpgradeMessage(
|
|
name=args.name,
|
|
server_conf=server_conf,
|
|
cluster=cluster,
|
|
master=args.master,
|
|
control_plane_soak_duration=args.control_plane_soak_duration,
|
|
node_pool_name=args.node_pool,
|
|
new_version=args.cluster_version,
|
|
new_image_type=args.image_type)
|
|
|
|
if args.master:
|
|
MaybeLog122UpgradeWarning(cluster)
|
|
|
|
console_io.PromptContinue(
|
|
message=upgrade_message, throw_if_unattended=True, cancel_on_no=True)
|
|
|
|
options = self.ParseUpgradeOptions(args)
|
|
|
|
try:
|
|
op_ref = adapter.UpdateCluster(cluster_ref, options)
|
|
except apitools_exceptions.HttpError as error:
|
|
raise exceptions.HttpException(error, util.HTTP_ERROR_FORMAT)
|
|
|
|
if not args.async_:
|
|
adapter.WaitForOperation(
|
|
op_ref,
|
|
'Upgrading {0}'.format(cluster_ref.clusterId),
|
|
timeout_s=args.timeout)
|
|
|
|
try:
|
|
cluster = adapter.GetCluster(cluster_ref)
|
|
for node_pool in cluster.nodePools:
|
|
util.CheckForCgroupModeV1(node_pool)
|
|
except (exceptions.HttpException, apitools_exceptions.HttpForbiddenError,
|
|
util.Error) as error:
|
|
log.warning(
|
|
util.CGROUPV1_CHECKING_FAILURE_MSG.format(
|
|
console_attr.SafeText(error)
|
|
)
|
|
)
|
|
log.UpdatedResource(cluster_ref)
|
|
|
|
|
|
Upgrade.detailed_help = {
|
|
'DESCRIPTION':
|
|
"""\
|
|
Upgrades the Kubernetes version of an existing container cluster.
|
|
|
|
This command upgrades the Kubernetes version of the *node pools* or *master* of
|
|
a cluster. Note that the Kubernetes version of the cluster's *master* is
|
|
also periodically upgraded automatically as new releases are available.
|
|
|
|
If desired cluster version is omitted, *node pool* upgrades default to the
|
|
current *master* version and *master* upgrades default to the default
|
|
cluster version, which can be found in the server config.
|
|
|
|
*During node pool upgrades, nodes will be deleted and recreated.* While
|
|
persistent Kubernetes resources, such as
|
|
Pods backed by replication controllers, will be rescheduled onto new
|
|
nodes, a small cluster may experience a few minutes where there are
|
|
insufficient nodes available to run all of the scheduled Kubernetes
|
|
resources.
|
|
|
|
*Please ensure that any data you wish to keep is stored on a persistent*
|
|
*disk before upgrading the cluster.* Ephemeral Kubernetes resources--in
|
|
particular, Pods without replication controllers--will be lost, while
|
|
persistent Kubernetes resources will get rescheduled.
|
|
""",
|
|
'EXAMPLES':
|
|
"""\
|
|
Upgrade the node pool `pool-1` of `sample-cluster` to the Kubernetes
|
|
version of the cluster's master.
|
|
|
|
$ {command} sample-cluster --node-pool=pool-1
|
|
|
|
Upgrade the node pool `pool-1` of `sample-cluster` to Kubernetes version
|
|
1.14.7-gke.14:
|
|
|
|
$ {command} sample-cluster --node-pool=pool-1 --cluster-version="1.14.7-gke.14"
|
|
|
|
Upgrade the master of `sample-cluster` to the default cluster version:
|
|
|
|
$ {command} sample-cluster --master
|
|
""",
|
|
}
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.BETA)
|
|
class UpgradeBeta(Upgrade):
|
|
"""Upgrade the Kubernetes version of an existing container cluster."""
|
|
|
|
@staticmethod
|
|
def Args(parser):
|
|
_Args(parser)
|
|
flags.AddControlPlaneSoakDurationFlag(parser, hidden=False)
|
|
|
|
|
|
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
|
|
class UpgradeAlpha(Upgrade):
|
|
"""Upgrade the Kubernetes version of an existing container cluster."""
|
|
|
|
@staticmethod
|
|
def Args(parser):
|
|
_Args(parser)
|
|
flags.AddControlPlaneSoakDurationFlag(parser, hidden=False)
|
|
flags.AddSecurityProfileForUpgradeFlags(parser)
|
|
|
|
def ParseUpgradeOptions(self, args):
|
|
ops = ParseUpgradeOptionsBase(args)
|
|
ops.security_profile = args.security_profile
|
|
ops.security_profile_runtime_rules = args.security_profile_runtime_rules
|
|
return ops
|