Connecting GCP Budget Alerts to AppSheet: A Step-by-Step Guide

Have you ever woken up to a massive Google Cloud bill because a developer accidentally left a cluster running, or an API got stuck in an infinite loop? Cloud "bill shock" is a rite of passage for many builders, but it can be avoided to a large extent. While Google Cloud allows you to set budget alerts that send you an email when you cross a threshold, an email doesn't stop the bleeding. By the time you see the email, log into your laptop, authenticate, navigate the Google Cloud console, and find the offending resource, you could be out hundreds or thousands of dollars. What if, instead of an email, you got a push notification on your phone with a big red "Kill Resources" button? In this comprehensive tutorial, we are going to bridge the gap between enterprise Google Cloud infrastructure and Google Workspace. We will build a serverless architecture using **Cloud Functions**, **Pub/Sub**, **Google Sheets**, and **AppSheet** to create a custom mobile app that gives you absolute, instant control over your cloud spend. Whether you are a beginner looking to understand Event-Driven Architecture, or a seasoned architect looking for a rapid Low-Code internal tool, this guide will walk you through every single click and line of code. ## The Architecture: How It All Connects Before we write code, let's understand the flow of data. Event-driven architecture means one system yells into the void, and another system is waiting to catch it.  1. Google Cloud Billing detects a budget anomaly and publishes a payload to a Pub/Sub topic. Think of Pub/Sub as a massive post office. 2. An Ingest Cloud Function (Python) is subscribed to that post office. It catches the payload, parses the metrics, and uses the Google Sheets API to write a row to a Google Sheet. 3. AppSheet (a low-code platform) reads the sheet and instantly generates a mobile UI, sending a Push Notification to your phone. When you tap the "Kill Resources" button in AppSheet, an AppSheet Automation Bot fires a Webhook. 4. A Remediation Cloud Function receives the webhook and executes a secure shutdown command against the target resource using the Google Compute API. Let's build it step-by-step! ### Step 1: Setting up the Database (Google Sheets) Why Google Sheets? Because for rapid prototyping and internal tools, a spreadsheet is the easiest database to visually debug. 1. Open Google Sheets and create a new blank spreadsheet. Name it "Google Cloud Budget Alerts". 2. In the first row, create the following headers exactly as written: `alert_id`, `budget_name`, `budget_amount`, `current_spend`, `threshold_percent`, `timestamp`, `status`, `project_id` Keep this tab open, we will need the Sheet ID from the URL later.  ### Step 2: The Ingest Pipeline (Pub/Sub & Cloud Functions) Now we need Google Cloud to send data to our sheet whenever you spend too much money. #### 1. Create the Pub/Sub Topic 1. Open the Google Cloud Console and search for Pub/Sub. 2. Click Create Topic and name it budget-alerts. Uncheck "Add a default subscription" (our Cloud Function will create one automatically).  #### 2. Connect Google Cloud Billing to Pub/Sub This is the most critical link in the chain. We have to tell the Google Cloud Billing system to actually use the post office we just built. 1. In the Google Cloud Console, navigate to **Billing -> Budgets & alerts**. 2. Click **Create Budget**. Name it "development-budget". 3. Under **Amount**, set your target budget (e.g., $100). 4. Under **Actions** (this is the secret sauce), scroll down to the **Manage notifications** section. 5. Check the box for "**Connect a Pub/Sub topic to this budget**". 6. Select your Google Cloud Project and choose the `budget-alerts` topic we just created from the dropdown. Save the budget.  #### 3. Deploy the Ingest Cloud Function This Python script is the "glue" between the Google Cloud Billing alerts and Google Sheets. 1. Search for Cloud Functions in the Google Cloud console and click Create Function. 2. Select Gen 2. Name it `ingest-budget-alert`. 3. In the Trigger section, select **Cloud Pub/Sub** and choose your `budget-alerts` topic. 4. Expand the Runtime, build, connections and security settings, and add an Environment Variable named `SPREADSHEET_ID`. Paste the ID found in your Google Sheet's URL. 5. Click Next. Change the Runtime to Python 3.11. In your `requirements.txt`, add these libraries so GCP knows what packages to install: ```plaintext functions-framework==3.* google-api-python-client==2.* google-auth==2.* ``` In your main.py, paste this code. ```python import base64 import json import os import datetime import uuid import functions_framework from googleapiclient.discovery import build import google.auth # 1. Initialize Google Sheets client securely credentials, project = google.auth.default(scopes=['https://www.googleapis.com/auth/spreadsheets']) sheets_service = build('sheets', 'v4', credentials=credentials) @functions_framework.cloud_event def ingest_budget_alert(cloud_event): SPREADSHEET_ID = os.environ.get('SPREADSHEET_ID') # 2. Decode the incoming message from Pub/Sub pubsub_message = base64.b64decode(cloud_event.data['message']['data']).decode('utf-8') alert_data = json.loads(pubsub_message) # 3. Extract the exact metrics we care about cost_amount = float(alert_data.get('costAmount', 0.0)) budget_amount = float(alert_data.get('budgetAmount', 1.0)) budget_name = alert_data.get('budgetDisplayName', 'Unknown Budget') threshold_percent = cost_amount / budget_amount alert_id = str(uuid.uuid4())[:8] timestamp = datetime.datetime.utcnow().isoformat() project_id = os.environ.get('GCP_PROJECT', 'my-test-project') # 4. Format the row and push to Google Sheets row_data = [ alert_id, budget_name, cost_amount, cost_amount, threshold_percent, timestamp, "PENDING", project_id ] body = {'values': [row_data]} sheets_service.spreadsheets().values().append( spreadsheetId=SPREADSHEET_ID, range="Sheet1!A:H", valueInputOption="USER_ENTERED", body=body ).execute() print(f"✅ Appended alert to Google Sheet.") ``` **Crucial Step:** When the function deploys, go to its "Details" page and find the **Service Account** email it is using (usually looks like `123456789-compute@developer.gserviceaccount.com`). You must go to your Google Sheet, click the "Share" button, and add this email as an Editor! Otherwise, the script will get a Permission Denied error. ### Step 3: Building the Low-Code Mobile App We have data flowing into a spreadsheet. Now let's turn that spreadsheet into a mobile app in under 60 seconds without writing a single line of iOS or Android code. 1. Go to **AppSheet.com** and log in with your Google account. 2. Click **Create -> App -> Start with your own data**. 3. Select the "Google Cloud Budget Alerts" Google Sheet. AppSheet will analyze your columns and instantly generate a working mobile app on your screen!  ### Creating the "Kill Switch" Action We need a giant red button to press when disaster strikes. 1. In the left-hand menu, click on the Actions icon (the lightning bolt). 2. Click + New Action. 3. Configure it exactly like this: - Action Name: Kill Resources - For a record of this table: alerts - Do this: Data: set the values of some columns in this row - Set these columns: Choose status from the dropdown, and type "SHUTDOWN_REQUESTED" in the formula box. 4.Go to Appearance, choose a stop sign icon.  ### Step 4: The Remediation Engine (The Webhook) Pressing a button in an app doesn't magically turn off a server on Google Cloud. We need Google Cloud to listen to AppSheet. We will deploy a second Cloud Function, this time with an **HTTP Trigger**, that acts as our Remediation Engine. 1. Go back to Cloud Functions and Create a new Function. 2. Name it `remediate-budget-alert`. 3. For the trigger, select **HTTPS** and choose "Allow unauthenticated invocations" (for this tutorial). 4. **Copy the Trigger URL** shown on the screen! You will need this for AppSheet. Here is the Python code for `main.py`. This script listens for the HTTP request, verifies you actually pressed the button, and uses the Compute API to forcefully stop a virtual machine. ```python import os import functions_framework from googleapiclient.discovery import build from google.auth import default credentials, project = default() compute = build('compute', 'v1', credentials=credentials) @functions_framework.http def remediate_resource(request): # 1. Parse the JSON sent by AppSheet request_json = request.get_json(silent=True) status = request_json.get("status") project_id = request_json.get("project_id") # 2. Security Check: Ensure the button was actually pressed if status != "SHUTDOWN_REQUESTED": return 'Ignoring status', 200 print(f"🚨 SHUTDOWN AUTHORIZED. Commencing remediation...") # 3. The Kill Command! # (Hardcoded for this tutorial, but can be dynamic based on the payload) ZONE = 'us-central1-a' INSTANCE_NAME = 'demo-kill-switch-vm' request = compute.instances().stop( project=project_id, zone=ZONE, instance=INSTANCE_NAME ) request.execute() return 'Shutdown successful', 200 ``` ### Step 5: Closing the Loop (The Automation Bot) Finally, we tell AppSheet to hit that HTTP URL whenever you press the red Kill Switch button. 1. In AppSheet, go to the Automation tab (the robot icon). 2. Click Create my first Bot -> Create a new Bot. Name it "Trigger Kill Switch". 3. **Event**: Select Data Change -> Updates Only on the alerts table. 4. **Condition**: Type exactly [status] = "SHUTDOWN_REQUESTED". 5. **Action Step**: Select Call a webhook. 6. Paste your Cloud Function HTTP URL from Step 4. Set the HTTP Verb to POST. In the JSON Body, paste this: ```json { "status": "<<[status]>>", "project_id": "<<YOUR_PROJECT_ID>>", "alert_id": "<<[alert_id]>>" } ```  ### Step 6: Testing the End-to-End System (The Demo) A tutorial isn't complete until we prove that it works! We don't want to actually wait for our cloud bill to skyrocket to test this, so we will simulate a mock billing alert. #### 1. Send a Mock Payload Open your terminal or Google Cloud Shell and create a script named `test_alert.sh`. Paste the following code, replacing `YOUR_PROJECT_ID` with your actual Project ID: ```shell #!/bin/bash PROJECT_ID="YOUR_PROJECT_ID" TOPIC_NAME="budget-alerts" PAYLOAD='{ "budgetDisplayName": "development-budget", "alertThresholdExceeded": 1.0, "costAmount": 150.00, "budgetAmount": 100.00 }' ENCODED_PAYLOAD=$(echo -n "$PAYLOAD" | base64) gcloud pubsub topics publish $TOPIC_NAME \ --project=$PROJECT_ID \ --message="$ENCODED_PAYLOAD" ``` Run the script. This instantly fires a "100% budget exceeded" alert into our architecture. #### 2. Watch the Data Flow Immediately check your Google Sheet. You will see a brand new row pop up instantly with the alert data and a status of `PENDING`. Check your phone or browser where AppSheet is open. Within seconds, a Push Notification will arrive: "**🚨 GCP Budget Alert!**". #### 3. Hit the Kill Switch Open the AppSheet app. You will see the new `development-budget` alert in the UI. Tap the alert, and smash that red Kill Resources button we built in Step 3. #### 4. Verify the Shutdown The moment you press that button, AppSheet fires the webhook to our Remediation Cloud Function. Navigate to **Compute Engine -> VM Instances** in your Google Cloud Console. You will see your target test VM's status transition from `RUNNING` to `TERMINATED`. ## Conclusion You have successfully built an event-driven, zero-latency cloud control system. By combining the robustness of Google Cloud Functions with the rapid UI generation of AppSheet and Google Sheets, you've created a powerful internal tool. This architecture is incredibly extensible: in the future, you could modify the Python code to dynamically revoke IAM permissions, disable billing accounts entirely, or integrate with Cloud Monitoring for sub-minute predictive alerting. The next time your cloud bill starts to spike, you won't need to scramble for your laptop. You just need to reach into your pocket.