Browse skills

Investigate interruptions affecting GPU and TPU workloads on GKE using maintenance labels, monitoring queries, logs, and node scheduling restrictions. The skill helps determine whether host maintenance caused a disruption and recommends workload protection measures when maintenance is confirmed or expected.

• Investigating unexpected GPU or TPU workload interruptions
• Checking upcoming host maintenance on GKE nodes
• Tracking maintenance interruptions with PromQL

Plan and configure security across Google Kubernetes Engine clusters. Review access permissions, enable Secret Manager integration, and configure protections such as Shielded Nodes and Binary Authorization to strengthen the platform supporting your applications.

• Review cluster access permissions
• Enable Secret Manager integration
• Configure Shielded Nodes and GKE Sandbox

Helps build AI features in Go with Genkit, including text generation, structured data output, streaming, tool calls, and conversational agents. Guides HTTP serving and trace inspection to check model responses and tool execution.

• Adding text generation or structured output to a Go app
• Building a chatbot that retains conversation state
• Connecting model responses to tool calls

Diagnose failures in GKE HorizontalPodAutoscaler (HPA), which adjusts Pod counts automatically. Investigate missing metrics, unexpected scaling behavior, and slow reactions, then receive proposed configuration fixes or commands for review before deployment.

• Investigating unknown metrics and HPA errors
• Diagnosing workloads that will not scale up or down
• Troubleshooting scaling to and from zero

Set up Firebase command-line tools, sign in, and create or switch projects. Retrieve Android and iOS app configuration files through commands, including guidance for signing in from remote environments.

• Set up Firebase tools and sign in
• Create or switch Firebase projects
• Retrieve Android or iOS configuration files

Build Gemini API integrations on Google Cloud’s Agent Platform using the Google Gen AI SDK. Get guidance on authentication, text and media processing, structured JSON responses, function calls, caching, batch processing, and real-time voice or video interactions.

• Adding Gemini to enterprise applications
• Processing images, audio, and documents
• Generating JSON in a specified format

Build conversations and workflows with the Gemini Interactions API on Gemini Enterprise Agent Platform. Follow Python or JavaScript examples for server-stored conversation history, streaming responses, structured JSON output, function calls, and background agent tasks.

• Building chats that retain conversation context
• Displaying responses as they stream
• Returning JSON in a specified format

Investigate crashes, out-of-memory errors, and device initialization failures on GKE TPU v6e nodes. The skill checks logs and custom metrics collection for conflicting operations, then guides temporary mitigation by disabling an identified collector.

• Investigate vbar_control_agent crashes and memory exhaustion
• Check tpu-device-plugin metrics checksum errors
• Inspect conflicts with custom TPU metrics collectors

Generate a client in your chosen language for live, two-way communication with Gemini Enterprise LiveAPI. Includes token renewal, session recovery, tests, and a demo interface for trying text, audio, video, and transcription.

• Build a client for live conversations with Gemini
• Add token renewal and session recovery
• Test audio and video input through a demo interface

Diagnose interrupted or repeatedly restarting AI training jobs managed by JobSet on GKE. Correlate restart metrics, node events, host health, and worker logs to distinguish Spot VM preemptions, infrastructure failures, and application crashes, then recommend responses.

• Investigating repeated JobSet restarts
• Checking whether Spot VM preemptions interrupted training
• Tracing recurring failures to a physical host

Inspect GKE TPU Dynamic Slices, diagnose provisioning failures, and validate workload configuration for single slices or JobSet workloads spanning multiple slices. Get cleanup commands, with confirmation required before destructive changes.

• Checking TPU slice lifecycle states
• Diagnosing TPU slice provisioning failures
• Validating single-slice and multi-slice JobSet manifests

Set up a managed Kubernetes environment on Google Cloud, from choosing Autopilot or Standard to creating a GKE cluster, obtaining kubectl connection credentials, and deploying workloads. Includes guidance on private clusters and resource requests.

• Choosing between Autopilot and Standard
• Creating a private GKE cluster
• Obtaining kubectl credentials for a cluster

Configure GKE ComputeClasses, which define preferred computing resources for workloads. Set fallback options between Spot and on-demand VMs, target GPUs or machine families, control class usage, and investigate pods waiting for suitable nodes.

• Configuring fallback from Spot VMs to on-demand capacity
• Selecting GPUs, TPUs, or machine families
• Restricting ComputeClass editing and workload usage

Answers questions about GKE spending using BigQuery billing exports and live cluster metrics. It breaks down costs by project, namespace, or workload and compares requested computing resources with actual usage to investigate cost increases.

• Comparing GKE costs across projects
• Finding the most expensive namespace or workload
• Investigating a sudden increase in cluster costs

Reduce Google Kubernetes Engine costs by adjusting CPU and memory requests, setting resource quotas, and choosing Spot VMs or committed use discounts. Match spending decisions to steady usage, variable demand, and workloads that tolerate interruptions.

• Reduce excessive CPU and memory requests
• Set resource quotas for teams sharing a cluster
• Move interruption-tolerant batch jobs to Spot VMs

Finds the base image needed to create a custom GKE node image. It translates requirements such as GKE version, operating system, processor architecture, accelerators, and sandbox settings into a matching image name.

• Finding a base image for custom GKE nodes
• Looking up images for GPU or TPU configurations
• Matching images to COS, Ubuntu, ARM64, or X86_64

Create or update Kubernetes YAML configuration files for GKE Autopilot and Standard. Translates application requirements into manifests covering container permissions, CPU and memory allocation, health checks, storage, external routing, and GPU resources for AI model serving.

• Creating GKE application deployment manifests
• Reviewing container security and resource settings
• Configuring external routes with GKE Gateway API

Configure how GKE applications receive traffic from the internet or internal networks. The skill provides configuration templates for routing, load balancing, certificates, and access protection, and guides diagnosis of failed health checks, dropped requests, and TLS connection problems.

• Expose a GKE application through Gateway API or Ingress
• Split traffic between application versions during a rollout
• Configure Cloud Armor protection and HTTPS certificates

Design production GKE clusters, which run containerized applications on Google Cloud, using recommended Autopilot settings. Review networking, security, monitoring, and upgrade choices, then compare existing clusters against the configuration and identify deviations and remedies.

• Design a production GKE cluster
• Review network choices before cluster creation
• Audit cluster settings against the recommended configuration

Build AI applications with Genkit in Node.js and TypeScript, including conversational agents, generation workflows, and tools. Use documentation, type checks, and execution traces—records of model inputs and tool calls—to verify behavior and troubleshoot errors.

• Set up a new Genkit project
• Build a conversational agent with persistent sessions
• Manage prompts in separate .prompt files

Build AI applications in Python with Genkit, including conversational agents, generation workflows, streaming responses, and tool use. The skill also guides setup and debugging through traces, recorded details of model inputs, outputs, and actions.

• Build a chatbot that keeps conversation history
• Implement streaming responses and tool calls
• Investigate Genkit import and API errors

Diagnoses storage failures in GKE, Google's managed Kubernetes service, including stuck Pods, disk attachment errors, storage pressure, and missing volume expansion. It provides diagnostic commands and reviewable configuration patches for deployment through GitOps.

• Diagnose Pods stuck in ContainerCreating
• Investigate slow disks and node storage pressure
• Find why expanded storage is missing inside a container

Create and connect to managed MySQL, PostgreSQL, or SQL Server databases on Google Cloud. This skill guides instance setup, database creation, access permissions, and connection steps, with references for backups, security, and Terraform configuration.

• Create a PostgreSQL database on Google Cloud
• Connect to a database through Cloud SQL Auth Proxy
• Review database permissions and backup options

Convert Snowflake dbt SQL models to BigQuery through a bulk migration workflow. Preserve Jinja template logic while adapting configuration, explicit type conversions, JSON access, and deduplication patterns, with translated files saved in their directory structure.

• Migrating Snowflake dbt models to BigQuery in bulk
• Preserving dbt references and incremental processing logic
• Adapting JSON, array, and STRUCT access during migration