Skip to content
Get packs

Guide · Agent skill

How to use the GKE App Onboarding agent skill

Updated · written with AI from the project's own documentation and checked against our catalogue data

The gke-app-onboarding skill is a set of instructions that an AI agent follows to take an application and get it running on Google Kubernetes Engine (GKE) for the first time. It is useful if you are deploying an app to GKE for the first time, or if your team wants a production-ready baseline for new workloads. After this guide you will know what the skill does, how to install it, how to ask for it in plain language, and what to review before anything reaches a live cluster.

GKE App Onboardinggoogle/skills · Apache-2.0

Quick start

  1. 1Install the skill. Download the ZIP from this page and unzip it into ~/.claude/skills/ or a project's .claude/skills/ folder, or upload it under Settings, Capabilities, Skills.
  2. 2Check prerequisites. Confirm gcloud is installed and authenticated to your Google Cloud project, and that Docker or pack and kubectl are available. Set up the MCP server if you want the preferred deployment path.
  3. 3Ask for the onboarding. Describe the app and the goal in plain language, including the language, port, health endpoints and target cluster.
  4. 4Review the build and manifest. Read the Dockerfile or buildpack command, the image tag, and the Deployment and Service the agent drafts before any push or apply.
  5. 5Deploy and verify. Let the agent apply the manifest, then check rollout status and pod state. Use the kubectl fallback if the MCP server is not available.

What a agent skill is and what this one does

An agent skill is a folder with a SKILL.md file and optional scripts, reference notes and sample files. When it is installed, the agent reads it and follows its workflow when a task matches the skill's description.

This skill covers the first deployment of an app to GKE. The agent assesses the app's language, dependencies, configuration, statefulness, networking and health endpoints. It then drafts a container build using either a Dockerfile or Cloud Native Buildpacks, pushes the image to Artifact Registry, and writes a Kubernetes Deployment and Service. The generated pod spec is meant to include non-root users, probes, resource requests and limits, and at least two replicas.

  • Assess the app: language, dependencies, configuration, statefulness, networking, health endpoints
  • Containerize: Dockerfile (multi-stage recommended) or Cloud Native Buildpacks
  • Image management: push to Artifact Registry and optionally review vulnerability scan results
  • Write a hardened Deployment and ClusterIP Service
  • Deploy through an MCP server (preferred) or kubectl

How do you install the gke-app-onboarding skill?

Download the skill ZIP from this page and unzip it. For a personal setup, place the folder in ~/.claude/skills/. To scope it to one project, place it in that project's .claude/skills/ folder.

If you use the Claude apps instead, upload the ZIP under Settings, then Capabilities, then Skills.

  • Personal install: unzip into ~/.claude/skills/
  • Project install: unzip into .claude/skills/ inside your project
  • Claude apps: Settings → Capabilities → Skills, then upload the ZIP
~/.claude/skills/gke-app-onboarding/SKILL.md

What do you need before using it?

The skill assumes a working Google Cloud setup. The workflow calls gcloud, Docker or Cloud Native Buildpacks, and kubectl for its fallback path. The preferred deployment path uses an MCP server that provides the tools apply_k8s_manifest, get_k8s_resource, get_k8s_rollout_status, get_k8s_logs and describe_k8s_resource.

Node.js is only needed if you want to run the sample app in the assets folder.

  • Google Cloud SDK (gcloud) and an authenticated Google Cloud project
  • Docker, or Cloud Native Buildpacks (pack), for building images
  • kubectl, for the fallback deployment path
  • An MCP server with the tools listed above (preferred path)
  • Node.js, only to run the sample app

How do you trigger the skill with a natural request?

You do not need a special command. Describe what you want in plain language that matches the skill's purpose: onboarding or deploying an app to GKE for the first time, or containerizing an app for GKE. The agent should pick up the skill when the request fits.

Give the agent context it cannot infer, such as the app's language, the port it listens on, whether it has a health endpoint, and the target project, region and cluster names.

  • 'Containerize this Node.js service and get it running on GKE for the first time.'
  • 'Assess this app for GKE onboarding and tell me what config and health endpoints it needs.'
  • 'Write a production-ready Deployment and Service for this app on our GKE cluster.'
  • 'Build this app with Cloud Native Buildpacks and push it to Artifact Registry.'

What does the agent do with its tools and commands?

The skill tells the agent to read its attribution reference before running any gcloud, REST or MCP command. For commands run directly in a terminal, the agent prefixes gcloud with a metrics environment variable that tags the skill and its version. The source says to set this inline on each command rather than with gcloud config set, so the tag does not persist into unrelated work.

Deployment follows a preferred MCP path, with kubectl as the fallback. The workflow also checks the rollout status and pod state after applying.

  • Attribution tag is set inline on each gcloud command
  • Verification uses rollout status and resource listing after apply
  • kubectl apply, rollout status and get pods are the fallback sequence
CLOUDSDK_METRICS_REQUEST_ATTRIBUTION="agent-skills/1.0 (skill:gke-app-onboarding)" \ gcloud <command> [flags]

What should you check before anything is deployed?

The skill can apply manifests to live infrastructure. Review every generated command and manifest before running it, especially against production. Check the image name, the target project, region and cluster, and the replica count.

The skill also runs scripts and uses the network, because it calls Google Cloud and the MCP server. Confirm that you are comfortable with those calls and that your credentials point at the intended project.

  • Review every apply command and manifest before it runs against a production cluster
  • Confirm the project, region and cluster in the parameters
  • Make sure gcloud is authenticated to the right account
  • Note that the skill runs scripts and uses the network

What is not covered by this skill?

This skill is for first-time onboarding, not general cluster administration or upgrades. The skill itself points to gke-basics or gke-upgrades for those tasks. For scaling, observability, security hardening and reliability, it points to gke-workload-scaling, gke-observability, gke-workload-security and gke-reliability. For advanced manifest work such as Gateway API routes, GCS FUSE volumes or Spot VM targeting, it points to gke-manifest-generation.

  • Cluster administration or upgrades: use gke-basics or gke-upgrades
  • Autoscaling: gke-workload-scaling
  • Observability: gke-observability
  • Security hardening: gke-workload-security
  • Reliability (PDBs, topology spread): gke-reliability

What people use it for

  • Moving a Node.js or Go web service onto GKE for the first time with a hardened Deployment
  • Standardising a baseline Deployment and Service for new workloads across a team
  • Generating a Kubernetes manifest that follows security practices such as non-root users and probes
  • Building an image with Cloud Native Buildpacks when the team does not want to maintain a Dockerfile

Frequently asked questions

Is the GKE App Onboarding skill free to use?

The skill is published under the Apache-2.0 licence. Using it does not cost anything by itself, but the Google Cloud resources it creates, such as GKE clusters, Artifact Registry storage and images, are billed under your own Google Cloud account.

What do I need to install before using gke-app-onboarding?

You need the Google Cloud SDK (gcloud) with an authenticated project, Docker or Cloud Native Buildpacks for builds, and kubectl for the fallback path. The preferred path also needs an MCP server providing the apply, get, rollout status, logs and describe tools. Node.js is only needed to run the sample app.

Where do I put the skill folder for Claude?

For a personal install, unzip it into ~/.claude/skills/. For a single project, unzip it into that project's .claude/skills/ folder. In the Claude apps, upload the ZIP under Settings, then Capabilities, then Skills.

Can this skill deploy to my production cluster?

It can apply manifests to live infrastructure, so it should not be run against production without reviewing the generated commands and manifests first. Check the project, region, cluster and image before anything is applied.

Does this skill handle cluster upgrades or general GKE administration?

No. The skill is for first-time onboarding. For cluster administration or upgrades, the skill itself says to use gke-basics or gke-upgrades instead.

What security settings does the generated manifest include?

The skill's checklist calls for non-root users, read-only root filesystem, no privilege escalation, dropped Linux capabilities, the RuntimeDefault seccomp profile, a digest-pinned image, resource requests, and a ClusterIP Service. It also says to disable automounting the service account token unless the pod needs it.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Use this skill if you are deploying an app to GKE for the first time and want an agent to follow a consistent baseline with security settings and probes. Pick something else if you mainly need cluster administration or upgrades, or if you cannot set up gcloud, a container build tool and an authenticated project, since the workflow depends on them.

Download the skill