Google Cloud Platform (GCP)¶

Google's cloud infrastructure platform. Born from Google's internal systems (Kubernetes, Borg, BigTable). Strong in data analytics, ML/AI, and container orchestration. Generally cheaper than AWS, better per-core performance. Smaller market share (10%) but solid engineering. IAM is more sensible than AWS. Kubernetes runs best here (they invented it).

Quick Hits¶

# Compute Engine - VMs (like AWS EC2)
gcloud compute instances create my-instance \
  --machine-type=e2-micro \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --zone=us-central1-a # (1)!

# Cloud Storage - Object storage (like AWS S3)
gsutil cp file.txt gs://my-bucket/
gsutil mb gs://my-new-bucket  # Make bucket
gsutil rsync -r ./local gs://bucket/path # (2)!

# Cloud Run - Serverless containers (easiest deployment ever)
gcloud run deploy my-service \
  --image gcr.io/project/image:tag \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated # (3)!

# GKE - Kubernetes (Google invented it)
gcloud container clusters create my-cluster \
  --num-nodes=3 \
  --enable-autoscaling \
  --min-nodes=1 \
  --max-nodes=5 \
  --zone=us-central1-a # (4)!

gcloud container clusters get-credentials my-cluster  # Configure kubectl

# Cloud SQL - Managed databases
gcloud sql instances create my-db \
  --database-version=POSTGRES_15 \
  --tier=db-f1-micro \
  --region=us-central1 # (5)!

gcloud sql connect my-db --user=postgres

# BigQuery - Serverless analytics (unique to GCP, no AWS equivalent)
bq query --use_legacy_sql=false \
  'SELECT name, COUNT(*) as cnt FROM `project.dataset.table` GROUP BY name' # (6)!

# Cloud Functions - Serverless functions (like AWS Lambda)
gcloud functions deploy my-function \
  --runtime=python312 \
  --trigger-http \
  --entry-point=main \
  --allow-unauthenticated # (7)!

# IAM - Identity and Access Management
gcloud iam service-accounts create my-sa
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:my-sa@project.iam.gserviceaccount.com \
  --role=roles/storage.objectViewer # (8)!

# Logging - View logs
gcloud logging read "resource.type=cloud_run_revision" --limit 50
gcloud logging read "severity>=ERROR" --limit 100 # (9)!

# Cloud Storage client library (Python)
from google.cloud import storage

def upload_to_gcs(bucket_name, source_file, destination_blob):
    """Upload file to GCS bucket."""
    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob)

    blob.upload_from_filename(source_file)  # (1)!

    # Make public (if needed)
    blob.make_public()
    return blob.public_url

# Cloud Function handler (Python)
import functions_framework

@functions_framework.http
def main(request):
    """HTTP Cloud Function handler."""
    # Parse JSON request
    request_json = request.get_json(silent=True)

    # Business logic
    name = request_json.get('name', 'World')

    return {'message': f'Hello, {name}!'}, 200  # (2)!

# Cloud Run service (FastAPI)
from fastapi import FastAPI
import uvicorn

app = FastAPI()

@app.get("/health")
def health_check():
    return {"status": "healthy"}

@app.get("/api/data")
def get_data():
    # Cloud SQL connection using Cloud SQL Proxy
    # Or use public IP with Cloud SQL IAM auth
    return {"data": [1, 2, 3]}

if __name__ == "__main__":
    import os
    port = int(os.environ.get("PORT", 8080))  # (3)!
    uvicorn.run(app, host="0.0.0.0", port=port)

# BigQuery query (Python)
from google.cloud import bigquery

def query_bigquery():
    """Query BigQuery dataset."""
    client = bigquery.Client()

    query = """
        SELECT name, COUNT(*) as count
        FROM `project.dataset.users`
        WHERE created_at > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 DAY)
        GROUP BY name
        ORDER BY count DESC
        LIMIT 10
    """  # (4)!

    query_job = client.query(query)
    results = query_job.result()

    return [dict(row) for row in results]

# Firestore (NoSQL document database)
from google.cloud import firestore

def write_to_firestore():
    """Write document to Firestore."""
    db = firestore.Client()

    doc_ref = db.collection('users').document('user123')
    doc_ref.set({
        'name': 'Alice',
        'email': 'alice@example.com',
        'created_at': firestore.SERVER_TIMESTAMP
    })  # (5)!

    # Query documents
    users = db.collection('users').where('name', '==', 'Alice').stream()
    return [doc.to_dict() for doc in users]

# Cloud Run service definition (YAML)
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-service
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/minScale: "0"  # (1)!
        autoscaling.knative.dev/maxScale: "100"
    spec:
      containerConcurrency: 80  # (2)!
      containers:
      - image: gcr.io/project/image:tag
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: url  # (3)!
        resources:
          limits:
            memory: 512Mi
            cpu: "1"  # (4)!

# Deployment via gcloud
# gcloud run services replace service.yaml --region=us-central1

# Terraform for GCP infrastructure
terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 5.0"
    }
  }
}

provider "google" {
  project = "my-project"
  region  = "us-central1"
}

# Cloud Run service
resource "google_cloud_run_service" "api" {
  name     = "api-service"
  location = "us-central1"

  template {
    spec {
      containers {
        image = "gcr.io/my-project/api:latest"

        resources {
          limits = {
            memory = "512Mi"
            cpu    = "1"
          }
        }
      }
    }
  }

  traffic {
    percent         = 100
    latest_revision = true  # (1)!
  }
}

# Make service public
resource "google_cloud_run_service_iam_member" "public" {
  service  = google_cloud_run_service.api.name
  location = google_cloud_run_service.api.location
  role     = "roles/run.invoker"
  member   = "allUsers"  # (2)!
}

# Cloud Storage bucket
resource "google_storage_bucket" "data" {
  name          = "my-data-bucket"
  location      = "US"
  force_destroy = false  # (3)!

  lifecycle_rule {
    action {
      type = "Delete"
    }
    condition {
      age = 365  # Delete after 1 year
    }
  }
}

Learning Paths¶

Free Resources¶

• Google Cloud Skills Boost - Official training with labs
• GCP Free Tier - Always free products + $300 credit (3 months)
• Coursera GCP Specializations - Google-created courses
• GCP Documentation - Excellent docs, better than AWS
• Qwiklabs - Hands-on labs in real GCP (some free)
• GCP Podcast - Weekly podcast with product teams

Certifications Worth It¶

• Associate Cloud Engineer - $125, most valuable for engineers
• Professional Cloud Architect - $200, design and manage solutions
• Professional Data Engineer - $200, BigQuery, Dataflow, ML
• Professional Cloud Developer - $200, application development

Reality check:

• GCP certs are hands-on (no multiple choice like AWS)
• Cloud Architect is harder than AWS Solutions Architect
• Study 2-3 months with hands-on practice
• Use Official Practice Exams ($20)
• Join r/googlecloud for tips

Projects to Build¶

Architecture Patterns¶

Common GCP architecture patterns for modern cloud-native applications.

Serverless Microservices¶

graph TB
    subgraph "Client Layer"
        Users[Users/Apps]
    end

    subgraph "Google Cloud"
        subgraph "Edge & Gateway"
            CDN[Cloud CDN]
            LB[Cloud Load Balancer]
            API[API Gateway]
        end

        subgraph "Compute Layer"
            CR1[Cloud Run<br/>Service 1]
            CR2[Cloud Run<br/>Service 2]
            CR3[Cloud Run<br/>Service 3]
            CF[Cloud Functions]
        end

        subgraph "Data Layer"
            FS[Firestore<br/>NoSQL]
            SQL[Cloud SQL<br/>PostgreSQL]
            GCS[Cloud Storage<br/>Objects]
        end

        subgraph "Integration"
            PS[Pub/Sub<br/>Messaging]
            SEC[Secret Manager]
        end
    end

    Users -->|HTTPS| CDN
    CDN --> LB
    LB --> API
    API --> CR1
    API --> CR2
    API --> CR3
    CR1 --> FS
    CR2 --> SQL
    CR3 --> GCS
    CR1 -.->|async| PS
    CR2 -.->|async| PS
    PS --> CF
    CR1 -.->|credentials| SEC
    CR2 -.->|credentials| SEC

    style CDN fill:#4285F4,stroke:#333,color:#fff
    style API fill:#34A853,stroke:#333,color:#fff
    style CR1 fill:#FBBC04,stroke:#333
    style CR2 fill:#FBBC04,stroke:#333
    style CR3 fill:#FBBC04,stroke:#333
    style FS fill:#EA4335,stroke:#333,color:#fff
    style SQL fill:#4285F4,stroke:#333,color:#fff
    style PS fill:#34A853,stroke:#333,color:#fff

Why this works:

• Cloud Run scales to zero (no idle costs)
• API Gateway handles auth, rate limiting, versioning
• Pub/Sub decouples services (async processing)
• Firestore for real-time, Cloud SQL for relational
• Secret Manager eliminates hardcoded credentials

Data Analytics Pipeline¶

graph LR
    subgraph "Data Sources"
        APP[Applications]
        IOT[IoT Devices]
        LOGS[Application Logs]
    end

    subgraph "Ingestion Layer"
        PS[Pub/Sub]
        DF[Dataflow<br/>Streaming]
    end

    subgraph "Storage Layer"
        GCS[Cloud Storage<br/>Data Lake]
        BQ[BigQuery<br/>Warehouse]
    end

    subgraph "Processing"
        DPROC[Dataproc<br/>Spark]
        COMP[Composer<br/>Airflow]
    end

    subgraph "Analytics & ML"
        LA[Looker<br/>BI]
        VA[Vertex AI<br/>ML Models]
    end

    APP --> PS
    IOT --> PS
    LOGS --> PS
    PS --> DF
    DF --> GCS
    DF --> BQ
    GCS --> DPROC
    DPROC --> BQ
    COMP -.->|orchestrates| DPROC
    COMP -.->|orchestrates| DF
    BQ --> LA
    BQ --> VA

    style PS fill:#34A853,stroke:#333,color:#fff
    style GCS fill:#FBBC04,stroke:#333
    style BQ fill:#4285F4,stroke:#333,color:#fff
    style VA fill:#EA4335,stroke:#333,color:#fff

Real talk:

• Pub/Sub handles millions of events/sec (auto-scaling)
• Dataflow is managed Apache Beam (no infrastructure)
• BigQuery queries petabytes in seconds (columnar storage)
• Looker replaces Tableau/PowerBI (Google acquired it)
• Vertex AI simplifies ML pipeline (training, deployment, monitoring)

Multi-Region Web Application¶

graph TB
    subgraph "Global Edge"
        CF[Cloud CDN<br/>Anycast IP]
        GCLB[Global Load Balancer<br/>HTTP(S)]
    end

    subgraph "Region: us-central1"
        CR_US[Cloud Run<br/>US]
        SPAN_US[(Cloud Spanner<br/>US Primary)]
    end

    subgraph "Region: europe-west1"
        CR_EU[Cloud Run<br/>EU]
        SPAN_EU[(Cloud Spanner<br/>EU Replica)]
    end

    subgraph "Region: asia-east1"
        CR_ASIA[Cloud Run<br/>Asia]
        SPAN_ASIA[(Cloud Spanner<br/>Asia Replica)]
    end

    subgraph "Shared Services"
        MEM[Memorystore<br/>Redis]
        GCS[Cloud Storage<br/>Multi-Region]
        PS[Pub/Sub<br/>Global]
    end

    CF --> GCLB
    GCLB -->|geo-routing| CR_US
    GCLB -->|geo-routing| CR_EU
    GCLB -->|geo-routing| CR_ASIA

    CR_US --> SPAN_US
    CR_EU --> SPAN_EU
    CR_ASIA --> SPAN_ASIA

    SPAN_US -.->|sync replication| SPAN_EU
    SPAN_EU -.->|sync replication| SPAN_ASIA
    SPAN_ASIA -.->|sync replication| SPAN_US

    CR_US --> MEM
    CR_US --> GCS
    CR_US --> PS

    style CF fill:#4285F4,stroke:#333,color:#fff
    style GCLB fill:#34A853,stroke:#333,color:#fff
    style SPAN_US fill:#EA4335,stroke:#333,color:#fff
    style SPAN_EU fill:#EA4335,stroke:#333,color:#fff
    style SPAN_ASIA fill:#EA4335,stroke:#333,color:#fff

Why Cloud Spanner:

• Globally distributed SQL (strong consistency)
• 99.999% SLA (five 9s uptime)
• Automatic replication across regions
• No manual sharding (scales horizontally)
• More expensive than Cloud SQL but worth it for global apps

Well-Architected Framework¶

Google Cloud's Architecture Framework covers six pillars.

Security¶

# Grant minimal permissions
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:sa@project.iam.gserviceaccount.com \
  --role=roles/storage.objectViewer  # Read-only

# Use predefined roles (not custom unless necessary)
# roles/viewer - Read-only access
# roles/editor - Modify but not IAM
# roles/owner - Full control

# Enable Workload Identity (GKE)
gcloud container clusters update CLUSTER \
  --workload-pool=PROJECT_ID.svc.id.goog

Reliability¶

# Cloud Run with gradual rollout
gcloud run deploy SERVICE --image=IMAGE:v2 \
  --traffic latest=20,previous=80  # Canary deployment

# GKE regional cluster (multi-zone)
gcloud container clusters create CLUSTER \
  --region=us-central1 \
  --num-nodes=1 \
  --enable-autoscaling \
  --min-nodes=1 \
  --max-nodes=10

# Cloud SQL with HA configuration
gcloud sql instances create INSTANCE \
  --database-version=POSTGRES_15 \
  --tier=db-custom-2-8192 \
  --region=us-central1 \
  --availability-type=REGIONAL  # Multi-zone HA

Performance Efficiency¶

graph TD
    START{What's the workload?}
    START -->|Web app| COMPUTE
    START -->|Batch job| BATCH
    START -->|Container| CONTAINER
    START -->|Database| DB

    COMPUTE{Traffic pattern?}
    COMPUTE -->|Steady| CE[Compute Engine<br/>Sustained use discounts]
    COMPUTE -->|Spiky| CR[Cloud Run<br/>Auto-scale to zero]

    BATCH{Duration?}
    BATCH -->|<15 min| CF[Cloud Functions<br/>Event-driven]
    BATCH -->|>15 min| DF[Dataflow<br/>Managed pipeline]

    CONTAINER{Management level?}
    CONTAINER -->|Full control| GKE[GKE Standard<br/>Node pools]
    CONTAINER -->|Hands-off| AUTO[GKE Autopilot<br/>No nodes]

    DB{Data model?}
    DB -->|Relational| SQL[Cloud SQL<br/>Regional HA]
    DB -->|NoSQL| FS[Firestore<br/>Real-time]
    DB -->|Analytics| BQ[BigQuery<br/>Serverless]
    DB -->|Global| SPAN[Cloud Spanner<br/>Multi-region]

# Cloud CDN for static assets
gcloud compute backend-buckets create BUCKET_BACKEND \
  --gcs-bucket-name=BUCKET \
  --enable-cdn

# Memorystore Redis for session/cache
gcloud redis instances create CACHE \
  --size=1 \
  --region=us-central1 \
  --tier=basic  # Or standard for HA

Cost Optimization¶

# Use recommender API for cost savings
gcloud recommender recommendations list \
  --project=PROJECT_ID \
  --location=us-central1 \
  --recommender=google.compute.instance.MachineTypeRecommender

# Check cost breakdown
gcloud billing accounts list
gcloud billing projects describe PROJECT_ID

# Set budget alerts
gcloud billing budgets create \
  --billing-account=ACCOUNT_ID \
  --display-name="Monthly Budget" \
  --budget-amount=1000 \
  --threshold-rule=percent=50 \
  --threshold-rule=percent=90

# Automatically archive old data
gsutil lifecycle set lifecycle.json gs://BUCKET

# lifecycle.json:
{
  "lifecycle": {
    "rule": [
      {
        "action": {"type": "SetStorageClass", "storageClass": "NEARLINE"},
        "condition": {"age": 30}
      },
      {
        "action": {"type": "SetStorageClass", "storageClass": "COLDLINE"},
        "condition": {"age": 90}
      },
      {
        "action": {"type": "Delete"},
        "condition": {"age": 365}
      }
    ]
  }
}

Operational Excellence¶

# Cloud Logging (aggregates all logs)
gcloud logging read "resource.type=cloud_run_revision" \
  --limit=50 \
  --format=json

# Cloud Monitoring (metrics, alerts)
gcloud alpha monitoring dashboards create \
  --config-from-file=dashboard.json

# Cloud Trace (distributed tracing)
# Automatically enabled for Cloud Run, App Engine

# Cloud Profiler (CPU/memory profiling)
# Add google-cloud-profiler to application

# Terraform for GCP (preferred)
terraform init
terraform plan
terraform apply

# Deployment Manager (GCP native, but Terraform better)
gcloud deployment-manager deployments create DEPLOYMENT \
  --config=config.yaml

# Cloud Build for CI/CD
gcloud builds submit --config=cloudbuild.yaml

Community Pulse¶

Who to Follow¶

Twitter/X:

• @gcpcloud - Official GCP account
• @kelseyhightower - Kubernetes legend, Google staff
• @gregsramblings - GCP Developer Advocate
• @steren - Cloud Run PM
• @bretmcg - VP Engineering, runs GCP

YouTube:

• Google Cloud Tech - Official channel, product deep dives
• GCP Podcast - Weekly interviews with product teams

Active Communities¶

• r/googlecloud - 50k+ members, helpful community
• GCP Slack - Active community Slack workspace
• Stack Overflow [google-cloud-platform] - Quick answers
• Google Cloud Community - Official forums
• Dev.to #gcp - Tutorials and case studies

Events¶

• Google Cloud Next - Annual conference, April, free virtual
• Google I/O - May, consumer + cloud products
• GDG Cloud - Local meetups worldwide

Worth Checking¶

Last Updated: 2026-02-02 | Vibe Check: Smart Choice - GCP is cheaper and faster than AWS for most workloads. Cloud Run is the best serverless platform. BigQuery is unmatched for analytics. GKE Autopilot removes Kubernetes pain. Smaller market share but solid engineering. If you're starting fresh, GCP is compelling.

Tags: gcp, google-cloud, cloud