从集群内部触发 Agent Sandbox 快照

本教程将向您介绍如何从 Google Kubernetes Engine (GKE) 集群 内部 部署和测试 Agent Sandbox 快照功能。您将了解如何在集群内运行客户端应用，以通过编程方式创建、暂停和恢复沙盒环境。

如需详细了解如何截取 Pod 快照，请参阅 通过 Pod 快照进行恢复。

费用

Agent Sandbox 在 GKE 中免费提供。 GKE 定价 适用于您创建的资源。

准备工作

  1. 在 Cloud de Confiance 控制台的项目选择器页面上， 选择或创建 Cloud de Confiance 项目。

    选择或创建项目所需角色

    • 选择项目：选择项目不需要特定的 IAM 角色，您可以选择已获授角色的任何项目。
    • 创建项目：如需创建项目，您需要拥有 Project Creator 角色 (roles/resourcemanager.projectCreator)，该角色包含 resourcemanager.projects.create 权限。了解如何授予 角色。

    转到“项目选择器”

  2. 验证是否已为您的 Cloud de Confiance 项目启用结算功能。

  3. 启用 Artifact Registry 和 Kubernetes Engine API。

    启用 API 所需的角色

    如需启用 API，您需要拥有 Service Usage Admin IAM 角色 (roles/serviceusage.serviceUsageAdmin)，该角色包含 serviceusage.services.enable 权限。了解如何授予 角色。

    启用 API

  4. 在 Cloud de Confiance 控制台中，激活 Cloud Shell。

    激活 Cloud Shell

  5. 验证您是否拥有完成本教程所需的权限 。

所需角色

如需获得创建和管理沙盒所需的权限，请让您的管理员为您授予项目的Kubernetes Engine Admin (roles/container.admin) IAM 角色。如需详细了解如何授予角色，请参阅管理对项目、文件夹和组织的访问权限。

您也可以通过自定义角色或其他预定义角色来获取所需的权限。

限制

在区域级集群中，不同可用区中的节点可能具有不同的 CPU 微架构。由于快照会捕获 CPU 状态，因此在缺少 CPU 功能的节点上恢复快照会失败（例如，出现 OCI runtime restore failed: incompatible FeatureSet 错误）。

为避免此问题，请为您的环境使用适当的配置：

  • 生产环境：如需在整个集群中保持高可用性，请勿 将工作负载固定到特定可用区。相反，请指定满足最低要求的 CPU 平台，以帮助确保所有可用区中的 CPU 功能一致。如需了解详情，请参阅 选择满足最低要求的 CPU 平台。
  • 测试环境：如需简化设置并避免初始 CPU 不匹配错误，您 可以在 nodeSelector 清单中使用 SandboxTemplate 字段将 Pod 固定到特定可用区，例如 us-central1-a。本教程中的示例使用了此测试配置。

定义环境变量

如需简化您在本教程中运行的命令，您可以在 Cloud Shell 中设置环境变量。在 Cloud Shell 中，运行以下命令来定义以下有用的环境变量：

export PROJECT_ID=$(gcloud config get project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
export CLUSTER_NAME="test-snapshot"
export LOCATION="us-central1"
export BUCKET_LOCATION="us"
export MACHINE_TYPE="n2-standard-2"
export REPOSITORY_NAME="agent-sandbox"
export BUCKET_NAME="${PROJECT_ID}_snapshots"
export CLOUDBUILD_BUCKET_NAME="${PROJECT_ID}_cloudbuild"

以下是这些环境变量的说明：

  • PROJECT_ID：当前项目的 ID。 Cloud de Confiance by S3NS 定义此变量有助于确保所有资源都在正确的项目中创建。
  • PROJECT_NUMBER：当前项目的项目编号。 Cloud de Confiance by S3NS
  • CLUSTER_NAME：GKE 集群的名称，例如 test-snapshot。
  • LOCATION：GKE 集群和 Artifact Registry 仓库所在的区域，例如 us-central1。 Cloud de Confiance by S3NS
  • BUCKET_LOCATION：Cloud Storage 存储分区的位置，例如 us。
  • BUCKET_NAME：用于快照的 Cloud Storage 存储桶的名称。
  • CLOUDBUILD_BUCKET_NAME：用于 Cloud Build 日志的 Cloud Storage 存储桶的名称。
  • MACHINE_TYPE：用于集群节点的机器类型，例如 e2-standard-8。
  • REPOSITORY_NAME：Artifact Registry 仓库的名称，例如 agent-sandbox。

配置步骤概览

如需从集群内部启用和测试 Agent Sandbox 环境的 Pod 快照，您需要执行多个配置步骤。如需了解这些步骤，首先了解整个工作流中涉及的组件会很有帮助。

关键组件

本教程使用以下两个 Python 应用来测试快照流程：

  • 客户端应用：在您的 集群的标准 Pod 中运行的 Python 脚本。此应用管理沙盒生命周期：它以编程方式创建沙盒、暂停沙盒以触发快照、恢复沙盒，并验证状态是否已保留。在本教程中，您将创建一个名为 agent-sandbox-client-sa 的 Kubernetes 服务帐号，并向其授予 RBAC 权限，以便客户端应用 Pod 可以使用 Kubernetes API 管理沙盒自定义资源和快照触发器对象。
  • 沙盒应用：一个 Python 脚本，每秒递增并打印一个 计数器。此应用在隔离的沙盒环境中安全运行，以生成客户端应用可以验证的更改状态。在本教程中，您将创建一个名为 snapshot-sa 的专用 Kubernetes 服务账号，并配置 Workload Identity 以授权沙盒 Pod 安全地读取和写入 Cloud Storage 中的快照对象。

配置和测试流程

以下列表总结了您需要执行的步骤，以设置环境并运行测试：

  1. 创建集群：创建启用了 Pod 快照和 Agent Sandbox 功能的 Autopilot 或 Standard 集群。
  2. 创建 Artifact Registry 仓库： 创建一个 Docker 仓库，以存储客户端应用的容器映像。
  3. 安装 Agent Sandbox：在集群上安装核心 agent-sandbox 组件和扩展程序。
  4. 配置存储和权限： 创建一个 Cloud Storage 存储桶并配置 Workload Identity 权限，以允许安全地保存快照。
  5. 配置 Pod 快照：创建并应用 快照存储配置、快照政策和沙盒 模板。
  6. 构建客户端应用：为客户端应用构建 容器映像，并将其推送到 Artifact Registry 仓库。
  7. 运行测试：部署客户端应用 Pod，该 Pod 会 创建沙盒、暂停沙盒以捕获快照、恢复沙盒，并 验证计数器的状态是否已成功恢复。

创建集群

创建一个启用了 Pod 快照的新 GKE 集群。如需实现完整的功能兼容性，请指定快速发布渠道。

Autopilot

创建具有所需功能的 Autopilot 集群：

gcloud beta container clusters create-auto ${CLUSTER_NAME} \
   --enable-pod-snapshots \
   --release-channel=rapid \
   --location=${LOCATION}

标准版

创建具有所需功能的 Standard 集群：

gcloud beta container clusters create ${CLUSTER_NAME} \
   --enable-pod-snapshots \
   --release-channel=rapid \
   --machine-type=${MACHINE_TYPE} \
   --workload-pool=${PROJECT_ID}.svc.id.goog \
   --workload-metadata=GKE_METADATA \
   --num-nodes=1 \
   --location=${LOCATION}

创建启用了 gVisor 的节点池：

gcloud container node-pools create gvisor-pool \
   --cluster ${CLUSTER_NAME} \
   --num-nodes=1 \
   --location=${LOCATION} \
   --project=${PROJECT_ID} \
   --sandbox type=gvisor

创建 Artifact Registry 仓库

在 Artifact Registry 中创建一个 Docker 仓库，以存储客户端应用（用于创建和管理沙盒的应用）的容器映像：

gcloud artifacts repositories create ${REPOSITORY_NAME} \
   --repository-format=docker \
   --location=${LOCATION} \
   --description="Docker repository for Agent Sandbox"

安装 Agent Sandbox

在集群上安装 Agent Sandbox 核心组件和扩展程序（以版本 v0.4.6 为例）：

# Install the core agent-sandbox components
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.4.6/manifest.yaml

# Install the extensions (e.g., Warm Pools, Claims)
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.4.6/extensions.yaml

配置存储和权限

配置 Cloud Storage 存储桶以存储 Pod 快照，并向 snapshot-sa 服务帐号和 GKE 服务代理授予所需的 Workload Identity 权限。这样，沙盒工作负载就可以安全地保存和检索快照对象：

  1. 创建新的 Cloud Storage 存储桶：

    gcloud storage buckets create "gs://${BUCKET_NAME}" \
    --uniform-bucket-level-access \
    --enable-hierarchical-namespace \
    --soft-delete-duration=0d \
    --location="${BUCKET_LOCATION}"

  2. 在 default 命名空间中创建 Kubernetes 服务帐号。沙盒应用（Python 计数器脚本）使用此身份向外部 API 进行身份验证，并安全地访问存储在 Cloud Storage 中的快照对象：

    kubectl create serviceaccount "snapshot-sa" \
    --namespace "default"

  3. 使用 Workload Identity 将 storage.bucketViewer 角色绑定到您的服务帐号。此角色允许沙盒工作负载列出存储桶内容并找到特定快照：

    gcloud storage buckets add-iam-policy-binding "gs://${BUCKET_NAME}" \
    --member="principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/default/sa/snapshot-sa" \
    --role="roles/storage.bucketViewer"

  4. 使用 Workload Identity 将 storage.objectUser 角色绑定到您的服务帐号。此角色提供在存储桶中读取、保存和删除快照二进制对象的权限：

    gcloud storage buckets add-iam-policy-binding "gs://${BUCKET_NAME}" \
    --member="principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/default/sa/snapshot-sa" \
    --role="roles/storage.objectUser"

  5. 授予 GKE 服务代理在存储桶中管理（创建、列出、读取和删除）快照对象的权限：

    gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:service-${PROJECT_NUMBER}@container-engine-robot.iam.gserviceaccount.com" \
    --role="roles/storage.objectUser" \
    --condition="expression=resource.name.startsWith(\"projects/_/buckets/${BUCKET_NAME}\"),title=restrict_to_bucket,description=Restricts access to one bucket only"

配置 Pod 快照

创建并应用配置文件以安装所需的 Kubernetes 自定义资源。这些资源定义了集群如何存储和管理 Pod 快照：

  • PodSnapshotStorageConfig：指定用于存储快照二进制对象的 Cloud Storage 存储桶 。
  • PodSnapshotPolicy：定义如何手动触发快照、快照的分组频率以及快照的保留政策。
  • SandboxTemplate：定义用于运行隔离的沙盒工作负载的基础容器、节点选择器和 服务账号。

  1. 创建一个名为 test_client/snapshot_storage_config.yaml 的文件。此配置指定了集群在其中保存二进制 Pod 快照状态的目标 Cloud Storage 存储桶：

    apiVersion: podsnapshot.gke.io/v1
kind: PodSnapshotStorageConfig
metadata:
  name: example-pod-snapshot-storage-config
spec:
  snapshotStorageConfig:
    gcs:
      bucket: "$BUCKET_NAME"

  2. 替换配置文件中的环境变量占位符：

    sed -i "s/\$BUCKET_NAME/$BUCKET_NAME/g" test_client/snapshot_storage_config.yaml

  3. 应用存储配置清单：

    kubectl apply -f test_client/snapshot_storage_config.yaml

  4. 等待存储配置就绪：

    kubectl wait --for=condition=Ready podsnapshotstorageconfig/example-pod-snapshot-storage-config --timeout=60s

  5. 创建一个名为 test_client/snapshot_policy.yaml 的文件。此配置建立了一个保留规则，该规则最多保留两个沙盒工作负载的快照。触发器类型设置为 manual：这允许客户端应用按需控制快照：

    apiVersion: podsnapshot.gke.io/v1
kind: PodSnapshotPolicy
metadata:
  name: example-pod-snapshot-policy
  namespace: default
spec:
  storageConfigName: example-pod-snapshot-storage-config
  selector:
    matchLabels:
      app: agent-sandbox-workload
  triggerConfig:
    type: manual
    postCheckpoint: resume
  snapshotGroupingRules:
    groupByLabelValue:
      labels: ["agents.x-k8s.io/sandbox-name-hash", "tenant-id", "user-id"]
      groupRetentionPolicy:
        maxSnapshotCountPerGroup: 2

  6. 应用快照政策清单：

    kubectl apply -f test_client/snapshot_policy.yaml

  7. 创建一个名为 test_client/python-counter-template.yaml 的文件。此配置定义了沙盒 Pod，并为其分配了 snapshot-sa 服务帐号身份。此分配有助于确保沙盒安全运行。在该 Pod 中，沙盒应用（Python 脚本）会不断向容器日志打印递增的计数器：

    apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxTemplate
metadata:
  name: python-counter-template
  namespace: default
spec:
  podTemplate:
    metadata:
      labels:
        app: agent-sandbox-workload
    spec:
      serviceAccountName: snapshot-sa
      runtimeClassName: gvisor
      nodeSelector:
        topology.kubernetes.io/zone: us-central1-a # Pin to a zone to avoid CPU mismatch during restore
      containers:
      - name: python-counter
        image: python:3.13-slim
        command: ["python3", "-c"]
        args:
          - |
            import time
            i = 0
            while True:
              print(f"Count: {i}", flush=True)
              i += 1
              time.sleep(1)

  8. 应用沙盒模板清单：

    kubectl apply -f test_client/python-counter-template.yaml

构建客户端应用

为客户端应用创建容器映像，并将其上传到 Artifact Registry。

  1. 创建一个名为 test_client/Dockerfile.client 的文件。此文件定义了客户端应用的 Python 运行时环境和依赖项：

    FROM python:3.13-slim

WORKDIR /app

RUN pip install "k8s-agent-sandbox[tracing]==0.4.6"

# Copy test script
COPY client_test.py /app/client_test.py

CMD ["python", "/app/client_test.py"]

  2. 创建一个名为 test_client/client_test.py 的文件。此脚本管理沙盒生命周期，并验证在截取快照后状态是否成功恢复：

    import time
import logging
import re
from kubernetes import config, client
from k8s_agent_sandbox.gke_extensions.snapshots import PodSnapshotSandboxClient

logging.basicConfig(level=logging.INFO)

def get_last_count(pod_name, namespace):
    v1 = client.CoreV1Api()
    try:
        logs = v1.read_namespaced_pod_log(name=pod_name, namespace=namespace)
        counts = re.findall(r"Count: (\d+)", logs)
        if counts:
            return int(counts[-1])
        return None
    except Exception as e:
        logging.error(f"Failed to read logs for pod {pod_name}: {e}")
        return None

def get_current_pod_name(sandbox_id, namespace):
    custom_api = client.CustomObjectsApi()
    try:
        sandbox_cr = custom_api.get_namespaced_custom_object(
            group="agents.x-k8s.io",
            version="v1alpha1",
            namespace=namespace,
            plural="sandboxes",
            name=sandbox_id
        )
        metadata = sandbox_cr.get("metadata", {})
        annotations = metadata.get("annotations", {})
        return annotations.get("agents.x-k8s.io/pod-name")
    except Exception as e:
        logging.error(f"Failed to get sandbox CR: {e}")
        return None

def get_current_count(sandbox_id, namespace="default"):
    pod_name = get_current_pod_name(sandbox_id, namespace)
    if not pod_name:
        logging.error(f"Could not determine pod name for sandbox {sandbox_id}")
        return None
    return get_last_count(pod_name, namespace)

def suspend_sandbox(sandbox):
    logging.info("Pausing sandbox (using snapshots)...")
    try:
        suspend_resp = sandbox.suspend(snapshot_before_suspend=True)
        if suspend_resp.success:
            logging.info("Sandbox paused successfully.")
            if suspend_resp.snapshot_response:
                logging.info(f"Snapshot created: {suspend_resp.snapshot_response.snapshot_uid}")
            return suspend_resp
        else:
            logging.error(f"Failed to pause: {suspend_resp.error_reason}")
            exit(1)
    except Exception as e:
        logging.error(f"Failed to pause sandbox: {e}")
        exit(1)

def resume_sandbox(sandbox):
    logging.info("Resuming sandbox (using snapshots)...")
    try:
        resume_resp = sandbox.resume()
        if resume_resp.success:
            logging.info("Sandbox resumed successfully.")
            if resume_resp.restored_from_snapshot:
                logging.info(f"Restored from snapshot: {resume_resp.snapshot_uid}")
            return resume_resp
        else:
            logging.error(f"Failed to resume: {resume_resp.error_reason}")
            exit(1)
    except Exception as e:
        logging.error(f"Failed to resume sandbox: {e}")
        exit(1)

def verify_continuity(count_before, count_after):
    if count_before is not None and count_after is not None:
        logging.info(f"Verification: Count before={count_before}, Count after={count_after}")
        if count_after >= count_before:
            logging.info("SUCCESS: Sandbox resumed from where it left off (or later).")
        else:
            logging.error("FAIL: Sandbox counter reset or went backwards!")
    else:
        logging.warning("Could not verify counter continuity.")

def main():
    try:
        config.load_incluster_config()
    except config.ConfigException:
        config.load_kube_config()

    client_reg = PodSnapshotSandboxClient()

    logging.info("Creating sandbox...")
    sandbox = client_reg.create_sandbox(template="python-counter-template", namespace="default")
    logging.info(f"Sandbox created with ID: {sandbox.sandbox_id}")

    logging.info("Waiting for sandbox to run...")
    time.sleep(10)

    count_before = get_current_count(sandbox.sandbox_id)
    logging.info(f"Count before suspend: {count_before}")

    suspend_sandbox(sandbox)

    logging.info("Waiting 10 seconds...")
    time.sleep(10)

    resume_sandbox(sandbox)

    logging.info("Waiting for sandbox to be ready again...")
    time.sleep(10)

    count_after = get_current_count(sandbox.sandbox_id)
    logging.info(f"Count after resume: {count_after}")

    verify_continuity(count_before, count_after)

    logging.info("Snapshot test completed successfully.")

if __name__ == "__main__":
    main()

  3. 构建客户端容器映像并将其上传到 Artifact Registry。如果您的环境（例如 Cloud Shell）安装了 Docker，则可以使用 Docker 在本地构建映像。如果您在没有 Docker 的环境中工作，则可以使用 Cloud Build 远程构建和推送映像：

    Docker

    1. 为 Artifact Registry 配置 Docker 身份验证：

      gcloud auth configure-docker "${LOCATION}-docker.pkg.dev"

    2. 在本地构建并推送客户端容器映像：

      docker build -t "${LOCATION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/sandbox-client:latest" -f test_client/Dockerfile.client test_client
docker push "${LOCATION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/sandbox-client:latest"

    Cloud Build

    1. 创建一个名为 test_client/cloudbuild.yaml 的文件：

      steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', '$LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY_NAME/sandbox-client:latest', '-f', 'test_client/Dockerfile.client', 'test_client']
images:
- '$LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY_NAME/sandbox-client:latest'

    2. 替换配置文件中的环境变量占位符：

      sed -i "s/\$REPOSITORY_NAME/$REPOSITORY_NAME/g" test_client/cloudbuild.yaml
sed -i "s/\$LOCATION/$LOCATION/g" test_client/cloudbuild.yaml
sed -i "s/\$PROJECT_ID/$PROJECT_ID/g" test_client/cloudbuild.yaml

    3. 向 Cloud Build 服务帐号授予必要的权限：

      gcloud projects add-iam-policy-binding $PROJECT_ID \
   --member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
   --role="roles/artifactregistry.writer"

gcloud projects add-iam-policy-binding $PROJECT_ID \
   --member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
   --role="roles/logging.logWriter"

gcloud storage buckets add-iam-policy-binding "gs://$CLOUDBUILD_BUCKET_NAME" \
   --member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
   --role="roles/storage.objectAdmin"

    4. 使用 Cloud Build 运行构建：

      gcloud builds submit --config test_client/cloudbuild.yaml

运行测试

部署客户端应用以创建沙盒、触发快照，并验证内部计数器是否从其保存的状态成功恢复。

  1. 创建一个名为 test_client/client_sa.yaml 的文件。此清单定义了 agent-sandbox-client-sa 服务帐号及其管理沙盒自定义资源所需的 RBAC 权限：

    apiVersion: v1
kind: ServiceAccount
metadata:
  name: agent-sandbox-client-sa
  namespace: default
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: agent-sandbox-client-role
  namespace: default
rules:
- apiGroups: ["agents.x-k8s.io"]
  resources: ["sandboxes"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
- apiGroups: ["extensions.agents.x-k8s.io"]
  resources: ["sandboxclaims"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
- apiGroups: ["podsnapshot.gke.io"]
  resources: ["podsnapshotmanualtriggers", "podsnapshots"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
- apiGroups: [""]
  resources: ["pods", "pods/log"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: agent-sandbox-client-rolebinding
  namespace: default
subjects:
- kind: ServiceAccount
  name: agent-sandbox-client-sa
  namespace: default
roleRef:
  kind: Role
  name: agent-sandbox-client-role
  apiGroup: rbac.authorization.k8s.io

  2. 应用客户端服务帐号和 RBAC 清单：

    kubectl apply -f test_client/client_sa.yaml

  3. 创建一个名为 test_client/client_pod.yaml 的文件。此清单使用预构建的容器映像创建客户端应用 Pod：

    apiVersion: v1
kind: Pod
metadata:
  name: agent-sandbox-client-pod
  namespace: default
spec:
  serviceAccountName: agent-sandbox-client-sa
  containers:
  - name: client
    image: $LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY_NAME/sandbox-client:latest
    imagePullPolicy: Always
  restartPolicy: Never

  4. 替换清单中的环境变量占位符：

    sed -i "s/\$REPOSITORY_NAME/$REPOSITORY_NAME/g" test_client/client_pod.yaml
sed -i "s/\$LOCATION/$LOCATION/g" test_client/client_pod.yaml
sed -i "s/\$PROJECT_ID/$PROJECT_ID/g" test_client/client_pod.yaml

  5. 应用客户端应用 Pod 清单：

    kubectl apply -f test_client/client_pod.yaml

  6. 流式传输 Pod 日志以验证执行流程：

    kubectl logs -f agent-sandbox-client-pod

当测试正确运行时，输出类似于以下内容（此处为便于阅读而缩短）：

2026-04-21 23:02:39,030 - INFO - Creating sandbox...
...
2026-04-21 23:02:51,755 - INFO - Count before suspend: 23
2026-04-21 23:02:51,755 - INFO - Pausing sandbox (using snapshots)...
...
2026-04-21 23:03:07,115 - INFO - Resuming sandbox (using snapshots)...
...
2026-04-21 23:03:21,329 - INFO - Count after resume: 38
2026-04-21 23:03:21,329 - INFO - Verification: Count before=23, Count after=38
2026-04-21 23:03:21,329 - INFO - SUCCESS: Sandbox resumed from where it left off (or later).

输出显示，沙盒在暂停和恢复时成功保留了其状态。当沙盒暂停（暂停并缩放为零）时，计数器停止递增；当沙盒恢复时，计数器恢复递增。如果不暂停，计数器会在暂停期间继续递增，并且计数会明显更高。

清理资源

为避免系统向您的 Cloud de Confiance by S3NS 账号收取费用，请删除您创建的资源 ：

  1. 删除 GKE 集群。这也会删除节点池及其中的所有 Kubernetes 服务账号：

    gcloud beta container clusters delete test-snapshot --location="${LOCATION}" --quiet

  2. 删除 Artifact Registry 仓库，以移除您为测试映像创建的 Docker 仓库：

    gcloud artifacts repositories delete ${REPOSITORY_NAME} --location="${LOCATION}" --quiet

  3. 删除 Cloud Storage 存储桶及其中的所有快照。 这会自动移除应用于该存储桶的存储桶级 Workload Identity IAM 绑定：

    gcloud storage rm --recursive "gs://${BUCKET_NAME}"

  4. 移除 GKE 服务代理的项目级 IAM 绑定：

    gcloud projects remove-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:service-${PROJECT_NUMBER}@container-engine-robot.iam.gserviceaccount.com" \
    --role="roles/storage.objectUser" \
    --condition="expression=resource.name.startsWith(\"projects/_/buckets/${BUCKET_NAME}\"),title=restrict_to_bucket,description=Restricts access to one bucket only"

  5. 如果您使用 Cloud Build 而不是 Docker 来构建和推送容器映像，请删除日志存储桶并移除服务帐号权限：

    gcloud storage rm --recursive "gs://${CLOUDBUILD_BUCKET_NAME}"

gcloud projects remove-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
    --role="roles/artifactregistry.writer"

gcloud projects remove-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
    --role="roles/logging.logWriter"

后续步骤