Study guide

11.3 Managing GKE Clusters: Node Pools, Workloads & Artifact Registry Access

Google Cloud Associate Cloud Engineer ACE

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Introduction & Exam Overview

1.1 About the GCP Associate Cloud Engineer Exam 1.2 How to Use This Study Guide & Build a Study Plan

2 Chapter 2: Resource Hierarchy, IAM Basics & Cloud Identity

2.1 The GCP Resource Hierarchy: Organizations, Folders & Projects 2.2 Organization Policies & Granting IAM Roles 2.3 Cloud Identity: Managing Users and Groups

3 Chapter 3: APIs, Quotas & Billing Configuration

3.1 Enabling APIs and Provisioning Cloud Operations Suite 3.2 Assessing and Requesting Quota Increases 3.3 Billing Accounts, Project Linking & Billing Exports 3.4 Billing Budgets and Alerts

4 Chapter 4: Planning Compute & Storage Resources

4.1 Choosing the Right Compute Option: GCE vs. GKE vs. Cloud Run vs. Cloud Functions 4.2 Spot VMs, Custom Machine Types & Cost-Optimized Compute Planning 4.3 Choosing a Data Storage Product: Cloud SQL, BigQuery, Firestore, Spanner & Bigtable 4.4 Cloud Storage Classes & Persistent Disk Types

5 Chapter 5: Planning Network Resources

5.1 Load Balancing Options and Use Cases 5.2 Regional Resource Placement & High Availability Planning 5.3 Network Service Tiers: Premium vs. Standard

6 Chapter 6: Deploying Compute Engine Workloads

6.1 Launching Compute Engine Instances: Disks, SSH Keys & Availability Policies 6.2 Managed Instance Groups, Instance Templates & Autoscaling 6.3 OS Login and VM Manager for Fleet Configuration

7 Chapter 7: Deploying Google Kubernetes Engine Workloads

7.1 Installing and Configuring kubectl 7.2 Deploying GKE Clusters: Autopilot, Regional, Private & GKE Enterprise 7.3 Deploying Containerized Applications to GKE

8 Chapter 8: Deploying Serverless & Event-Driven Applications

8.1 Deploying Applications to Cloud Run and Cloud Functions 8.2 Event-Driven Architectures: Pub/Sub, Cloud Storage Triggers & Eventarc

9 Chapter 9: Deploying Data Solutions

9.1 Deploying Data Products: Cloud SQL, Firestore, Spanner, BigQuery & AlloyDB 9.2 Deploying Pub/Sub, Dataflow & Loading Data into Google Cloud

10 Chapter 10: Deploying Networking Resources & Infrastructure as Code

10.1 Creating VPCs, Subnets & Shared VPC 10.2 Firewall Rules, Cloud VPN & VPC Network Peering 10.3 Infrastructure as Code: Terraform, Config Connector, Cloud Foundation Toolkit & Helm

11 Chapter 11: Managing Compute Engine & GKE in Production

11.1 Connecting to and Managing Running Compute Engine Instances 11.2 Working with Snapshots and Custom Images 11.3 Managing GKE Clusters: Node Pools, Workloads & Artifact Registry Access 11.4 Horizontal and Vertical Pod Autoscaling in GKE

12 Chapter 12: Managing Cloud Run, Storage & Database Operations

12.1 Managing Cloud Run Revisions, Traffic Splitting & Scaling 12.2 Managing and Securing Cloud Storage Objects & Lifecycle Policies 12.3 Querying, Estimating Costs, Backup & Job Monitoring for Databases (Cloud SQL, BigQuery, Spanner, Dataflow)

13 Chapter 13: Networking Operations, Monitoring & Logging

13.1 Networking Operations: Subnets, Static IPs, Cloud DNS & Cloud NAT 13.2 Cloud Monitoring: Alerts, Custom Metrics & Dashboards 13.3 Cloud Logging: Buckets, Log Analytics, Routers & Filtering 13.4 Diagnostics, Ops Agent, Managed Service for Prometheus & Audit Logs

14 Chapter 14: IAM Policies & Role Types

14.1 IAM Policies: Structure, Bindings & Policy Hierarchy 14.2 IAM Role Types: Basic, Predefined & Custom Roles

15 Chapter 15: Service Accounts & Security Configuration

15.1 Creating Service Accounts & Assigning Least-Privilege Permissions 15.2 Assigning Service Accounts to Resources & Managing SA IAM Policies 15.3 Service Account Impersonation & Short-Lived Credentials

16 Chapter 16: Exam Readiness — Scenarios & Test-Day Strategy

16.1 Common ACE Exam Scenarios & Decision Frameworks 16.2 Test-Day Logistics, Time Management & Final Review Checklist

11.3 Managing GKE Clusters: Node Pools, Workloads & Artifact Registry Access

Key Takeaways Explain This Topic AI

A node pool is a group of nodes within a cluster sharing identical configuration (machine type, image, disk, taints); every node in a pool carries the cloud.google.com/gke-nodepool label.

A Standard cluster's default node pool uses 3 nodes per zone with general-purpose machine types on the cos_containerd image; specialized workloads (GPU, Spot, high-memory) get their own dedicated node pool.

Node pools can be resized, upgraded, and deleted independently of one another — an upgrade to one pool does not force-upgrade any other pool in the same cluster.

For GKE nodes to pull images from Artifact Registry in the same project, the node's service account needs roles/artifactregistry.reader ; cross-project pulls require the same role granted explicitly in the target project.

kubectl manages Kubernetes-level objects (Pods, Deployments, Services, StatefulSets); gcloud container manages GKE/cluster-level infrastructure (clusters, node pools) — the exam tests knowing which tool owns which layer.

Last updated: July 2026

Why This Topic Matters

Exam Domain 4's Google Kubernetes Engine (GKE) bullets — viewing running cluster inventory, working with node pools, working with Kubernetes resources, and configuring GKE access to Artifact Registry — are some of the densest in the whole ACE guide, and they cut across three distinct layers of the platform: cluster infrastructure, Kubernetes workload objects, and IAM. ACE scenario questions routinely combine all three in a single stem ("a Pod in a new node pool can't pull its image — why?"), so this section builds the mental model that keeps them straight.

Node Pools: The Infrastructure Layer

A node pool is a group of nodes within a cluster that all share the same configuration — machine type, boot disk, image, and any taints/labels. Every node is automatically tagged with the Kubernetes label cloud.google.com/gke-nodepool identifying which pool it belongs to, which lets you target scheduling decisions at a pool.

When you create a Standard cluster, GKE provisions a default node pool — 3 nodes per zone, general-purpose machine type, running the cos_containerd (Container-Optimized OS) image. Almost every real-world cluster grows beyond that default by adding purpose-built node pools:

  • Node pool use case What you customize
  • GPU/ML training workloads Accelerator-attached machine types, taints so only GPU-tolerant Pods land there
  • Cost-optimized batch jobs Spot VMs as the underlying node type
  • Compute-intensive workloads A specific minimum CPU platform
  • Storage-heavy workloads Local SSDs attached to each node
  • Isolated tenants or workload classes Custom network interfaces, dedicated node images
  • Key gcloud Commands

Task Command

Create a node pool gcloud container node-pools create POOL_NAME --cluster=CLUSTER_NAME --machine-type=e2-standard-4

  • List node pools in a cluster gcloud container node-pools list --cluster=CLUSTER_NAME
  • Resize a node pool gcloud container clusters resize CLUSTER_NAME --node-pool=POOL_NAME --num-nodes=N
  • Upgrade a specific pool gcloud container clusters upgrade CLUSTER_NAME --node-pool=POOL_NAME
  • Delete a node pool gcloud container node-pools delete POOL_NAME --cluster=CLUSTER_NAME

Node pools upgrade and resize independently : upgrading one pool's Kubernetes version does not touch any other pool in the cluster, which is exactly how teams stage a rolling GKE version upgrade one pool at a time. Deleting a pool triggers a graceful node drain (capped at a one-hour termination period, and it can be configured to honor PodDisruptionBudgets ). One rule the exam likes to test directly: at least one node pool must remain without restrictive taints , because core system Pods (like kube-dns ) need somewhere untainted to schedule, or the cluster becomes unstable.

GKE Autopilot clusters remove this layer almost entirely — Google manages node provisioning and sizing for you, and billing is per-Pod-resource-request rather than per-node, trading node-pool control for zero node management overhead. On the exam, if a scenario says "we don't want to manage nodes at all," that's an Autopilot signal, not a node-pool-tuning signal.

Working with Kubernetes Resources (the Workload Layer)

Once nodes exist, kubectl — not gcloud — is the tool for the Kubernetes objects that actually run your application:

Pods — the smallest deployable unit; kubectl get pods , kubectl describe pod POD_NAME .

Deployments — declarative management of replica sets of stateless Pods; kubectl get deployments , kubectl rollout status deployment/NAME .

Services — stable network endpoints (ClusterIP, NodePort, LoadBalancer) in front of a set of Pods; kubectl get services .

StatefulSets — like Deployments but for workloads needing stable network identity and persistent storage per replica (databases, brokers); kubectl get statefulsets .

A recurring exam distinction: gcloud container commands operate on the cluster/node-pool infrastructure , while kubectl commands operate on the Kubernetes API objects running inside that infrastructure . A question describing "view all running Pods across the cluster" wants kubectl get pods --all-namespaces , not a gcloud command — there is no gcloud equivalent for Kubernetes-object-level inventory.

Configuring GKE Access to Artifact Registry

This is the IAM layer, and it's where ACE candidates most often go wrong because the node , not the developer running kubectl apply , is what authenticates the image pull.

Same-project pulls : if nodes run under the Compute Engine default service account , GKE provisions them with default access scopes that typically include read-only storage access, which is often sufficient. The robust, explicit answer the exam wants is granting the node's service account roles/artifactregistry.reader on the Artifact Registry repository (or project).

Cross-project pulls : when the cluster lives in Project A but the image sits in an Artifact Registry repository in Project B, you must explicitly grant the node service account roles/artifactregistry.reader in Project B — same-project default scopes do nothing across a project boundary.

Workload Identity does not change this : even when Pods use Workload Identity to assume a Kubernetes-service-account-mapped IAM identity for application API calls, the underlying image pull itself still authenticates as the node pool's own service account , not the Pod's Workload Identity. This is a frequently-tested nuance — don't assume Workload Identity automatically fixes an image-pull permission error.

Local development/build auth : gcloud auth configure-docker LOCATION-docker.pkg.dev configures Docker's credential helper so a developer's own gcloud credentials can push/pull manually, but this is unrelated to how the cluster authenticates at runtime.

Realistic Exam Scenario

An ML team adds a new GPU node pool to an existing GKE Standard cluster to run training jobs, tainting the pool so only GPU-tolerant Pods schedule there. The training image lives in an Artifact Registry repository in a separate, centralized "images" project . Pods on the new node pool fail with ImagePullBackOff . The ACE-correct diagnosis: this is a cross-project Artifact Registry access gap — grant the GPU node pool's service account roles/artifactregistry.reader on the images project's repository (not the developer's own IAM identity, and not a Workload Identity binding, since image pulls use the node's identity).