Google Cloud Platform Guide 2026 — Cloud Run, BigQuery, Firebase, and GKE

# Deploy from image
gcloud run deploy my-app \
  --image gcr.io/my-project/my-app:latest \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated \
  --memory 512Mi \
  --cpu 1 \
  --min-instances 0 \
  --max-instances 100 \
  --concurrency 80
 
# Deploy directly from source (builds with Buildpacks)
gcloud run deploy my-app \
  --source . \
  --region us-central1
 
# Set secrets from Secret Manager
gcloud run services update my-app \
  --set-secrets DATABASE_URL=my-db-url:latest \
  --region us-central1

# .github/workflows/cloud-run.yml
name: Deploy to Cloud Run
 
on:
  push:
    branches: [main]
 
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - uses: google-github-actions/auth@v2
        with:
          credentials_json: ${{ secrets.GCP_SA_KEY }}
 
      - name: Build and push image
        run: |
          gcloud builds submit \
            --tag gcr.io/my-project/my-app:${{ github.sha }} .
 
      - uses: google-github-actions/deploy-cloudrun@v2
        with:
          service: my-app
          image: gcr.io/my-project/my-app:${{ github.sha }}
          region: us-central1

// Firebase Admin SDK for server-side operations
import { initializeApp, cert } from 'firebase-admin/app'
import { getFirestore, FieldValue, Timestamp } from 'firebase-admin/firestore'
import { getAuth } from 'firebase-admin/auth'
 
const app = initializeApp({
  credential: cert(JSON.parse(process.env.FIREBASE_SERVICE_ACCOUNT!)),
})
 
const db = getFirestore(app)
const auth = getAuth(app)
 
// CRUD operations
async function createPost(data: { title: string; body: string; userId: string }) {
  const ref = await db.collection('posts').add({
    ...data,
    createdAt: FieldValue.serverTimestamp(),
    views: 0,
    published: false,
  })
  return ref.id
}
 
async function getPostsByTag(tag: string) {
  const snapshot = await db.collection('posts')
    .where('tags', 'array-contains', tag)
    .where('published', '==', true)
    .orderBy('createdAt', 'desc')
    .limit(20)
    .get()
  return snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }))
}
 
// Verify Firebase Auth token in API endpoints
async function verifyToken(token: string) {
  const decoded = await auth.verifyIdToken(token)
  return { uid: decoded.uid, email: decoded.email }
}

// Firebase Client SDK — real-time listener
import { initializeApp } from 'firebase/app'
import { getFirestore, onSnapshot, collection, query, where, orderBy } from 'firebase/firestore'
import { useState, useEffect } from 'react'
 
const db = getFirestore(initializeApp({
  apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
  projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID,
}))
 
function useRealtimePosts(tag: string) {
  const [posts, setPosts] = useState<any[]>([])
 
  useEffect(() => {
    const q = query(
      collection(db, 'posts'),
      where('tags', 'array-contains', tag),
      where('published', '==', true),
      orderBy('createdAt', 'desc')
    )
 
    const unsubscribe = onSnapshot(q, (snapshot) => {
      setPosts(snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() })))
    })
 
    return unsubscribe
  }, [tag])
 
  return posts
}

-- Partition + cluster for cost efficiency
CREATE OR REPLACE TABLE myapp.events
PARTITION BY DATE(event_time)
CLUSTER BY event_type, user_id
AS SELECT
  user_id,
  event_type,
  JSON_EXTRACT_SCALAR(metadata, '$.page') AS page,
  TIMESTAMP_MILLIS(timestamp) AS event_time
FROM raw_events;
 
-- Daily Active Users over last 30 days
SELECT
  DATE(event_time)       AS date,
  COUNT(DISTINCT user_id) AS dau,
  COUNT(*)               AS total_events
FROM myapp.events
WHERE event_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
GROUP BY date
ORDER BY date DESC;
 
-- Conversion funnel
WITH funnel AS (
  SELECT user_id,
    COUNTIF(event_type = 'signup')       > 0 AS signed_up,
    COUNTIF(event_type = 'first_post')   > 0 AS created_post,
    COUNTIF(event_type = 'subscription') > 0 AS subscribed
  FROM myapp.events
  GROUP BY user_id
)
SELECT
  COUNT(*)                                             AS total_users,
  COUNTIF(signed_up)                                   AS step1_signup,
  COUNTIF(created_post)                                AS step2_post,
  COUNTIF(subscribed)                                  AS step3_subscribe,
  ROUND(100 * COUNTIF(created_post) / COUNT(*), 1)    AS signup_to_post_pct,
  ROUND(100 * COUNTIF(subscribed) / COUNT(*), 1)      AS signup_to_paid_pct
FROM funnel;

# Create autopilot cluster (Google manages node scaling)
gcloud container clusters create-auto my-cluster \
  --region us-central1
 
# Standard cluster with node auto-scaling
gcloud container clusters create my-cluster \
  --num-nodes=3 \
  --zone=us-central1-a \
  --machine-type=e2-standard-2 \
  --enable-autoscaling \
  --min-nodes=1 \
  --max-nodes=10 \
  --enable-autorepair \
  --enable-autoupgrade \
  --workload-pool=my-project.svc.id.goog
 
# Get credentials and deploy
gcloud container clusters get-credentials my-cluster --zone=us-central1-a
kubectl apply -f k8s/

import vertexai
from vertexai.generative_models import GenerativeModel, Part
 
vertexai.init(project="my-project", location="us-central1")
model = GenerativeModel("gemini-1.5-pro")
 
# Text generation
response = model.generate_content("Summarize this article: ...")
print(response.text)
 
# Multimodal — analyze image + text
image_part = Part.from_uri(
    uri="gs://my-bucket/image.jpg",
    mime_type="image/jpeg"
)
response = model.generate_content([image_part, "Describe this image"])
 
# Text embeddings for vector search
from vertexai.language_models import TextEmbeddingModel
embed_model = TextEmbeddingModel.from_pretrained("text-embedding-004")
embeddings = embed_model.get_embeddings(["my search query"])
vector = embeddings[0].values  # 768-dimensional float array