Claude Code GCP Google Cloud Setup and Deployment Guide

Google Cloud Platform provides reliable, scalable infrastructure for deploying applications Integrating Claude Code into your GCP workflow enables intelligent automation, from generating deployment configurations to managing multi-service architectures. This guide walks through practical setups for deploying to Cloud Run, Cloud Functions, and using GCP services alongside Claude Code skills.

Prerequisites and Environment Setup

Before integrating Claude Code with GCP, ensure you have the Google Cloud SDK installed and authenticated:

# Install Google Cloud SDK
brew install google-cloud-sdk

# Authenticate with GCP
gcloud auth login

# Set your project
gcloud config set project YOUR_PROJECT_ID

Claude Code should be installed locally. Verify the installation:

claude --version

The integration relies on Claude Code’s ability to execute shell commands, which means your local environment communicates with GCP through the gcloud CLI. This approach keeps sensitive credentials on your local machine while enabling powerful cloud automation.

Deploying to Cloud Run with Claude Code

Cloud Run is GCP’s serverless container platform. Claude Code can generate Dockerfiles, build container images, and deploy directly to Cloud Run. Use the /tdd skill for testing your containerized application before deployment.

Automated Dockerfile Generation

Ask Claude Code to generate a production-ready Dockerfile:

Generate a multi-stage Dockerfile for a Node.js Express API. Use node:18-alpine as the base, install dependencies with npm ci, set NODE_ENV=production, and expose port 3000.

Claude Code produces optimized Dockerfiles that follow security best practices. The output typically includes multi-stage builds to minimize image size and reduce attack surface.

Deployment Command Pattern

Once your container is ready, deploy to Cloud Run:

gcloud run deploy my-service \
  --image gcr.io/PROJECT_ID/my-service \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated

Create a custom skill at ~/.claude/skills/gcp-deploy.md that combines build, push, and deploy steps:

---
description: "Build and deploy to Google Cloud Run"
---

# GCP Cloud Run Deploy Skill

1. Run `gcloud builds submit --tag gcr.io/$PROJECT_ID/$SERVICE_NAME` to build and push
2. Run `gcloud run deploy $SERVICE_NAME --image gcr.io/$PROJECT_ID/$SERVICE_NAME --platform managed --region $REGION`
3. Report the deployed URL from the command output

Invoke it with:

/gcp-deploy
Deploy the current project as SERVICE_NAME=my-api to region us-central1

Cloud Functions Deployment Patterns

For event-driven serverless functions, Cloud Functions (2nd gen) runs on Cloud Run under the hood but offers a quicker deployment model for simple workloads. Claude Code excels at generating function templates and handling deployment orchestration.

Generating Function Code

Claude Code can scaffold Cloud Functions with proper structure:

Create a Google Cloud Function (2nd gen) in Python that triggers on Cloud Storage bucket changes. The function should resize images uploaded to the bucket and save thumbnails to a processed/ folder. Use the google-cloud-storage and Pillow libraries.

This generates the complete function code with proper imports, event handling, and error management.

Deploying Cloud Functions

The deployment uses the gcloud functions deploy command:

gcloud functions deploy my-function \
  --runtime python312 \
  --trigger-resource my-bucket \
  --trigger-event google.storage.object.finalize \
  --entry-point handle_upload

Pair this with the /pdf skill if your function processes PDF documents, or use the /frontend-design skill for generating static site deployment functions to Cloud Storage.

Using GCP Services with Claude Code Skills

Claude Code integrates naturally with GCP services through shell commands. Here are practical patterns for common integrations.

Cloud Storage Operations

Manage Cloud Storage buckets for static hosting or data pipelines:

# Upload files to a bucket
gsutil rsync -R ./dist gs://my-bucket-name

# Set proper caching headers
gsutil setmeta -h "Cache-Control: public, max-age=31536000" \
  gs://my-bucket-name/**.{js,css,ico,png,jpg,jpeg,svg}

Create a skill at ~/.claude/skills/gcp-static-deploy.md:

---
description: "Deploy static site to Google Cloud Storage"
---

# GCP Static Deploy Skill

1. Run `gsutil rsync -R ./build gs://$BUCKET_NAME` to sync files
2. Run `gsutil setmeta -h "Cache-Control: public, max-age=0" gs://$BUCKET_NAME/**.{html,htm}` for HTML files
3. Report the public URL

Secret Manager Integration

Never hardcode credentials. Use Secret Manager with your deployments:

# Access a secret in your application
gcloud secrets versions access latest --secret=API_KEY

Claude Code can help generate code that retrieves secrets at runtime, ensuring your deployment follows security best practices.

Automated CI/CD with GitHub Actions and GCP

Combine Claude Code with GitHub Actions for continuous deployment to GCP. This pipeline builds your application, runs tests (using the /tdd skill for test generation), and deploys to Cloud Run on every push.

name: Deploy to Cloud Run
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Authenticate to GCP
        uses: google-github-actions/auth@v2
        with:
          credentials_json: ${{ secrets.GCP_SA_KEY }}

      - name: Deploy to Cloud Run
        run: |
          gcloud run deploy service-name \
            --image gcr.io/$PROJECT_ID/image \
            --platform managed \
            --region us-central1

State Management with Cloud SQL

For applications requiring persistent state, integrate Cloud SQL with your deployed services. Use /supermemory to track deployment context across sessions:

/supermemory
Store: Production deployment 2026-03-13 — Cloud Run service my-api deployed to us-central1.
Cloud SQL instance: myapp-db. Service account: deploy-sa@project.iam.gserviceaccount.com.

Query Cloud SQL from your local development environment:

gcloud sql connect my-instance --user=root

Best Practices for GCP Deployments

Organize your GCP resources with proper naming conventions and labels. Use separate projects for development and production environments. Always specify region explicitly in deployment commands to avoid unexpected cross-region costs.

Implement proper IAM roles for your deployment service account. The principle of least privilege applies: grant only the permissions necessary for deployment, such as roles/run.admin for Cloud Run deployments or roles/storage.objectAdmin for Cloud Storage operations.

Monitor your deployments with Cloud Logging and Cloud Monitoring. Claude Code can help generate monitoring dashboards or parse log exports, but the actual observability stack should be configured within GCP for production reliability.

Conclusion

Claude Code transforms GCP deployment workflows from manual processes into automated, intelligent pipelines. Whether deploying containers to Cloud Run, functions to Cloud Functions, or static assets to Cloud Storage, Claude Code acts as your development partner — generating configs, debugging issues, and optimizing deployments.

The key is treating Claude Code as a local development tool that interfaces with GCP through the gcloud CLI. This maintains security while unlocking significant automation potential. Start with simple deployments and incrementally add complexity as your workflow matures.

Best Claude Skills for DevOps and Deployment — Skills tailored for cloud deployments and infrastructure automation
Best Claude Skills for Developers 2026 — Start with the foundational developer skills before adding cloud-specific ones
Claude Skills Token Optimization: Reduce API Costs — Keep cloud automation sessions cost-effective

Built by theluckystrike — More at zovo.one