Blogs & Technical Articles by Darren Lester (Dazbo)
Technical articles, tutorials, and deep-dive blog posts on Google Cloud, Agentic AI, Gemini, Google Agent Development Kit (ADK), Model Context Protocol (MCP), and enterprise cloud architecture published by Darren Lester (Dazbo) on Medium and Dev.to.
Blogs & Technical Articles by Darren Lester
Spec-Driven Development For-the-Win: Disposable Code, Living Blueprints, and Building Like a Boss [Medium (2026-10-20)] — Part 3 of the series “Beyond Vibe Coding: The Engineering Blueprint for Reliable AI Agents”🗺️ The Series Roadmap: Beyond Vibe CodingIn 2026, software development is drowning in fragmented buzzwords: H... [Tags: Spec-Driven Development, AI Agents, Harness Engineering, Software Architecture, Behaviour-Driven Development]
Automated GitHub Code Reviews Using Google Gemini Update: Enterprise-Ready, Multimodal, and… [Medium (2026-10-19)] — Automated GitHub Code Reviews Using Google Gemini Update: Enterprise-Ready, Multimodal, and Battle-HardenedGemini PR Review & TriageYou are in Part 2 of the series "Automated GitHub Code Revi... [Tags: GitHub Actions, Google Gemini, Code Review, CI/CD, FinOps]
Loop Engineering in the Harness: Autonomous, Self-Correcting Systems [Dev.to (2026-10-12)] — You are in Part 2 of the series "Beyond Vibe Coding: The Engineering Blueprint for Reliable AI... [Tags: Loop Engineering, Harness Engineering, Agentic AI, LLM Evaluation, Software Architecture]
Loop Engineering in the Harness: Autonomous, Self-Correcting Systems [Medium (2026-10-08)] — Part 2 of the series “Beyond Vibe Coding: The Engineering Blueprint for Reliable AI Agents”🗺️ The Series Roadmap: Beyond Vibe CodingIn 2026, software development is drowning in fragmented buzzwords: H... [Tags: AI Agents, Loop Engineering, Harness Engineering, LLM Evaluation, Model Context Protocol]
From Vibing Chaos to Reliable Agents: The What, Why, and How of Harness Engineering [Medium (2026-09-28)] — You are in Part 1 of the series “Beyond Vibe Coding: The Engineering Blueprint for Reliable AI Agents”🗺️ The Series Roadmap: Beyond Vibe CodingAgentic software development is drowning in fragmented bu... [Tags: AI Agents, Harness Engineering, Software Architecture, Agentic AI, LLM Ops]
Meet the Antigravity Extension: Gemini Code Assist on Steroids, in Whatever IDE You Love [Medium (2026-08-21)] — Google Antigravity (or Agy) was first launched as an agent-first development environment in late 2025. Then, in May 2026, Google released the new Antigravity suite, comprising four surfaces:Antigravit... [Tags: Google Antigravity, Gemini Code Assist, VS Code Extensions, AI Agents, Model Context Protocol]
Skills Sprawl: When Too Much of a Good Thing Confuses Your AI Agent [Medium (2026-08-17)] — Skills Sprawl: When Too Much of a Good Thing Confuses Your AI AgentIntroductionIn this post, we’re going to look at the problem of Skills Sprawl.What happens if you have too many skills?We’ll understa... [Tags: AI Agents, Large Language Models, Token Optimization, Tool Calling, Google Antigravity]
Skills Sprawl: When Too Much of a Good Thing Confuses Your AI Agent [Dev.to (2026-08-17)] — Introduction In this post, we're going to look at the problem of Skills Sprawl. What... [Tags: agentic-ai, google-antigravity, progressive-disclosure, tool-calling, llm-optimization]
Finally — Hard Caps to Limit Your Google Cloud Spend [Medium (2026-07-29)] — Finally — Hard Caps to Limit Your Google Cloud SpendTL;DRFor years, Google Cloud budget alerts were purely informational. They sent an email while your project quietly burned through your savings.I bu... [Tags: Google Cloud Platform, Cloud Billing, FinOps, Google Cloud Budgets, Cloud Security]
Finally — Hard Caps to Limit Your Google Cloud Spend [Dev.to (2026-07-29)] — TL;DR For years, Google Cloud budget alerts were purely informational. They sent an email... [Tags: gcp, cloud-billing, finops, spend-management, cloud-security]
Automated GitHub Code Reviews Using Google Gemini [Medium (2026-07-16)] — I Built a Thing!TL;DR — Google Gemini-based Pull Request reviews and Issue Triaging for all your GitHub repositories and CI/CD pipelines.Automatic code review and issues triageWhat’s the Big Deal?If y... [Tags: GitHub Actions, Google Gemini, CI-CD, Automated Code Review, LLM Integration]
Automated GitHub Code Reviews Using Google Gemini [Dev.to (2026-07-16)] — I Built a Thing! TL;DR — Google Gemini-based Pull Request reviews and Issue Triaging for... [Tags: githubactions, pullrequest, cicdpipeline, googlegemini]
FinSavant Part 2: Building an Agentic FinOps Platform — Development Environment Setup, Google… [Medium (2026-07-13)] — FinSavant Part 2: Building an Agentic FinOps Platform — Development Environment Setup, Google Antigravity, MCPs and Skills, and ADK Bootstrapping with Agents CLIBoostrapping with Agents-CLI and Skills... [Tags: Google-ADK, Antigravity-IDE, Model-Context-Protocol, Agents-CLI, FinOps]
FinSavant Part 1: Building an Agentic FinOps Platform with Google ADK, A2UI and Gemini Enterprise… [Medium (2026-07-01)] — FinSavant Part 1: Building an Agentic FinOps Platform with Google ADK, A2UI and Gemini Enterprise Agent Platform — Goals, Architecture, and Tech StackWelcomeHello folks, Dazbo here. I’m on holiday, wh... [Tags: Google Cloud Platform, FinOps, Agent Development Kit, Model Context Protocol, Serverless Architecture]
Dialling Our Agents to 11: Agent Skills You Need to be Using! [Medium (2026-06-15)] — What This Article Is AboutHowdy friends!Recently I wrote an article called Dialling Our Agents to 11: My Favourite MCP Servers. It talked about how MCP servers and skills are essential components in t... [Tags: AI Agents, Model Context Protocol, Google Cloud Platform, Software Development Lifecycle, Command Line Interface]
Resolving WSL Friction with Google Antigravity: the Agy 2.0 and Agy IDE Edition [Medium (2026-06-12)] — Agy and WSLResolving FrictionLast year when the very cool Google Antigravity (Agy) was first launched, there were some teething issues when working with the Windows Subsystem for Linux (WSL) environme... [Tags: WSL, Google Antigravity, Bash, Networking, Software Development]
Dialling Our Agents to 11: My Favourite MCP Servers [Medium (2026-06-08)] — Amping up your agent to 11What This Article Is AboutI’d like to tell you about a few of the MCP servers and agent skills that I use most often. I’ll tell you what they do, how I use them, and how to i... [Tags: Model Context Protocol, AI Agents, Google Antigravity, Software Development Tools, Generative AI]
Dialling Our Agents to 11: My Favourite MCP Servers [Dev.to (2026-06-08)] — What This Article Is About I’d like to tell you about a few of the MCP servers and agent... [Tags: mcpserver, agenticai, googleantigravity, agentharness]
Configuring MCP Servers and Skills for Antigravity CLI and IDE [Medium (2026-05-24)] — Configuring MCP and Skills in the Agy EcosystemIntroductionWe had a few big announcements from Google I/O 2026 in the AI space. One was the announcement of Gemini Flash 3.5, which went straight to gen... [Tags: Google Antigravity, Model Context Protocol, AI Agents, Antigravity CLI, Gemini]
Upgrading Your Microsoft Surface Laptop Hard Disk — Easier Than You Think! [Medium (2026-05-23)] — Upgrading Your Microsoft Surface Laptop Hard Disk — Easier Than You Think!Upgrading the Surface Laptop SSDOverviewOlder generations of Microsoft Surface devices were not upgradeable. You made your cho... [Tags: Surface Laptop 7, SSD Upgrade, M.2 2230, UEFI Secure Boot, Windows 11 Recovery]
My Incredible Google Cloud Next 26 Experience as a GDE [Medium (2026-04-28)] — Hello friends! I landed back in the UK this evening, after spending the last few days in Vegas for Google Cloud Next ’26. This was my 4th in-person Next event, and my second time as a speaker.Those th... [Tags: Google Cloud, Generative AI, Gemini Enterprise, AI Agents, Model Context Protocol]
My Incredible Google Cloud Next 26 Experience as a GDE [Dev.to (2026-04-28)] — Hello friends! I landed back in the UK this evening, after spending the last few days in Vegas for... [Tags: googlecloud, googlecloudnext, gde, vegas]
Documentation as Context: A Skill to Automate Your Blueprints for the Agentic Era [Medium (2026-03-30)] — OverviewIn this blog I’ll show you an agent skill that empowers your agent with the ability to create awesome documentation for your software project. I’ll cover:Why documentation is even more importa... [Tags: AI Agents, LLM Skills, Gemini CLI, Software Documentation, Agentic Workflows]
Agentic Firestore: Smarter Agents with ADK and Google Remote Firestore MCP [Medium (2026-03-24)] — OverviewHere I’ll demonstrate how we can implement the Google Managed Remote MCP Server for Firestore from an ADK agent.Specifically, I’ll be adding the MCP server to the chatbot of my portfolio appli... [Tags: Model Context Protocol, Google Cloud Firestore, ADK, Gemini Flash, Generative AI]
Confused About Where to Put Your Agent Skills? [Medium (2026-03-10)] — This is going to be a very quick blog!What’s the Problem?Different agentic tools — like Gemini CLI and Google Antigravity — look in different locations for agent skills. This can be confusing. What sh... [Tags: AI Agents, Gemini CLI, LLM Tooling, Google Antigravity, Automation]
Confused About Where to Put Your Agent Skills? [Dev.to (2026-03-10)] — This is going to be a very quick blog! What’s the Problem? Different agentic tools — like... [Tags: agentskills, agenticai, googleantigravity, gemini]
Integrate NotebookLM with Gemini CLI, Google Antigravity or Other Agents with MCP [Medium (2026-03-02)] — NotebookLM is awesome. Before we jump into the integration, I’m going to give you a quick overview of NotebookLM, in case you’re not familiar with it. But before I drop this overview, here’s an import... [Tags: NotebookLM, Model Context Protocol, Gemini, AI Agents, LLM Integration]
Helping Your Agent Understand Google: Trying the Developer Knowledge API and MCP Server [Medium (2026-02-07)] — The Developer Knowledge API and its associated MCP Server were released yesterday! Check out the Google blog here.Google Developer Knowledge API & MCP ServerWhy is this a big deal? Well, it empowe... [Tags: Google Developer Knowledge API, Model Context Protocol, Gemini SDK, Vertex AI, RAG]
Using Gemini File Search Tool for RAG (a Rickbot Blog) [Medium (2026-01-07)] — Wubba Lubba Dub Dub! Welcome to another installment of Rickbot! You don’t need to have read the rest of the series to benefit from this latest article.Today I’m going to show you the cool Gemini File ... [Tags: Gemini API, RAG, Vector Databases, LLM Grounding, Google Cloud Gen AI]
Using Gemini File Search Tool for RAG (a Rickbot Blog) [Dev.to (2026-01-07)] — Wubba Lubba Dub Dub! Welcome to another installment of Rickbot! You don’t need to have read the rest... [Tags: geminifilesearch, rag, rickbot, gemini]
Introducing Google ADK Artifacts for Multi-Modal File Handling (a Rickbot Blog) [Medium (2026-01-05)] — Hello and welcome to another installment of Rickbot! You don’t need to have read the rest of the series to benefit from this latest article.Today I’m going to show you how to make use of Google Agent ... [Tags: Google ADK, Generative AI, FastAPI, Context Engineering, LLM Optimization]
Trying Out the New Conductor Extension in Gemini CLI — We’re Gonna Add Auth to Our Full Stack [Medium (2025-12-29)] — Picture this: you’re deep in the zone, pair-programming with your AI agent. You ask it to refactor a some code and it cheerfully agrees. Five minutes later? It’s hallucinated a dependency that doesn’t... [Tags: Gemini CLI, Context-Driven Development, AI Agents, Software Architecture, Markdown]
The Unwritten Rules of IT Architecture: From Imposter to Impact [Medium (2025-12-01)] — IT architecture is often misunderstood due to vague expectations and diverse professional backgrounds. Effective architects prioritize quality attributes—such as scalability, security, and performance—over implementation details, balancing trade-offs through conscious decision-making. Unlike "uber engineers," architects must shift focus from daily coding to broader organizational goals, strategic alignment, and governance. Documentation serves as a critical tool for design rigor and capturing architectural rationale, ensuring decisions are defensible yet adaptable to new data. Success in the role requires high emotional intelligence (EQ) to navigate organizational politics and manage stakeholder relationships effectively. Architects must tailor communication to their audience, utilizing elevator pitches for executives while maintaining technical depth for engineers. Finally, architecture is fundamentally tied to business value; considerations of Total Cost of Ownership (TCO) and Return on Investment (ROI) are essential for creating compelling technology strategies. By embracing "strong opinions, loosely held," architects can avoid stagnation and deliver impactful solutions that align technical excellence with business objectives. [Tags: IT Architecture, Quality Attributes, Total Cost of Ownership, Decision Records, Stakeholder Management]
Working with Google Antigravity in WSL [Medium (2025-11-24)] — Google Antigravity with WSLThis will be about getting Antigravity up and running in WSL. It will be very short, I promise!Context: The What and Why of WSLFor years, engineers had to pick a lane. You e... [Tags: Google Antigravity, WSL, Code OSS, Cloud-Native Development, DevOps]
Working with Google Antigravity in WSL [Dev.to (2025-11-24)] — This will be about getting Antigravity up and running in WSL. It will be very short, I promise! ... [Tags: agenticai, aidevelopment, vscode, googleantigravity]
Get Schwifty with the FastAPI: Adding a REST API to our Agentic Application (with Google ADK) [Medium (2025-11-04)] — Get Schwifty with FastAPI!IntroductionWelcome back to the Rickbot Series!In this part we’re going to look at how to add an API to our Google ADK-based agentic application, using the awesome Python Fas... [Tags: FastAPI, Google Cloud, Python, Generative AI, REST API]
Using the Loop Pattern to Make My Multi-Agent Solution More Robust (with Google ADK) [Medium (2025-10-29)] — In a previous series of articles, I introduced LLMs-Generator: a multi-agent solution built with the Google Agent Development Kit (ADK) to create llms.txt files.As a recap:I first covered the overall ... [Tags: Google ADK, Agentic Design Patterns, Multi-Agent Systems, LLM Context Window, Batch Processing]
Power-Up Your Gemini CLI with Your Own FastMCP Server Extension [Medium (2025-10-18)] — A Quick Recap: What is Gemini CLI?Gemini CLI gives you the power of Google’s multi-modal Gemini directly from your terminal. Invoke multi-step workflows with complex reasoning, all from natural langua... [Tags: Gemini CLI, Model Context Protocol, FastMCP, Python, LLM Extensions]
How to Avoid an Unexpected Cloud Bill — Fully Automated [Medium (2025-10-05)] — How to Avoid an Unexpected Cloud Bill — Fully AutomatedDo These Headlines Scare You?“Student hit with a $55,444.78 Google Cloud bill after Gemini API key leaked on GitHub”“How a 4-Hour Overnight Fine-... [Tags: Google Cloud Platform, FinOps, Cloud Run Functions, Pub/Sub, Cloud Billing API]
Give Your AI Agents Deep Understanding — Coding the Multi-Agent ADK Solution [Medium (2025-09-28)] — Details the implementation of a multi-agent system using the Google Agent Development Kit (ADK) to generate llms.txt files for repository understanding. The architecture centers on a generate_llms_coordinator agent that orchestrates specialized sub-agents and tools. A discover_files tool utilizes os.walk and ToolContext to scan repositories, storing file paths in a shared session state. This session state facilitates communication between the coordinator and the document_summariser_agent, a SequentialAgent composed of a file_reader_agent and a content_summariser_agent. The system leverages Gemini 2.5 Flash to produce concise file-level summaries and high-level project overviews, formatted as structured JSON. Key technical features include the use of AgentTool for agent delegation, explicit prompt engineering to manage tool arguments, and the integration of the ADK Web UI for debugging and tracing. The solution addresses challenges like output schema consistency and rate limiting while providing a framework for deep AI understanding of local codebases. [Tags: Google ADK, Multi-Agent Systems, Gemini API, LLM Orchestration, Prompt Engineering]
Give Your AI Agents Deep Understanding — Creating a Multi-Agent ADK Solution: Design Phase [Medium (2025-09-27)] — Details the design phase of a multi-agent solution built with the Google Agent Development Kit (ADK) to automate the creation of llms.txt files. These files provide structured summaries of code repositories, enhancing LLM context-awareness during development. The architecture utilizes an orchestrator agent to manage sub-agents for file discovery and summarization. Key technical choices include using Gemini 2.5 Flash for its large context window and cost-efficiency, and Typer for building a robust CLI. The solution implements Pydantic for schema validation and exponential backoff to handle API rate limits. Development is streamlined using the uv package manager and a pyproject.toml configuration. A notable workflow enhancement involves using a TODO.md file to guide both the human developer and the AI coding assistant. The design emphasizes modularity, extensibility, and a sequential processing flow where files are read before being summarized to ensure data integrity. [Tags: Google ADK, Multi-Agent Systems, Gemini 2.5 Flash, LLMS-TXT, Python Development]
Give Your AI Agents Deep Understanding With LLMS.txt [Medium (2025-09-23)] — Addresses the limitation of AI agents having superficial repository knowledge by leveraging the llms.txt standard. This markdown-based index provides LLMs with a structured map of links and summaries, enabling precise information retrieval during inference. Demonstrates implementation using the Model Context Protocol (MCP) LLMS-TXT Doc Server from LangChain, integrated into Gemini CLI via custom extensions. While the standard facilitates deep understanding, real-world applications like the Google Agent Development Kit (ADK) documentation reveal challenges: some llms.txt files lack actionable links, while full versions can exceed context window efficiency by consuming excessive tokens. To resolve these discrepancies, the author proposes an agentic solution built with the Google ADK to automate the creation of compliant llms.txt files. This tool crawls repositories, identifies markdown and source code, and generates AI-driven summaries to produce a functional index. This approach ensures agents can navigate complex codebases reliably without overwhelming context limits or relying on outdated internal knowledge. [Tags: llms.txt, Model Context Protocol, Gemini CLI, Google ADK, AI Agents]
Productionising the Rickbot ADK Application and More Gemini CLI Tips [Medium (2025-09-05)] — Details the transition of the Rickbot ADK application from staging to production using Google Cloud tools. Demonstrates leveraging Gemini CLI to audit CI/CD pipelines and Terraform configurations, identifying missing environment variables and inconsistent IAP settings. Implements infrastructure management through a custom Makefile target for Terraform execution. Establishes a security model where staging is restricted via Identity-Aware Proxy (IAP) while production utilizes Google Auth Platform for public-facing OIDC/OAuth authentication. Includes cost-optimization techniques for Cloud Run, such as enabling startup CPU boost and configuring CPU throttling (cpu_idle) to reduce overhead. Outlines the configuration of authorized domains and redirect URIs within the Google Auth Platform to support custom subdomains. Shows how to use GEMINI.md and TODO.md to provide persistent context for agentic development workflows. [Tags: Google Cloud Platform, Terraform, CI/CD, Cloud Run, Gemini CLI]
Guided Implementation of Agent Development Kit (ADK) with the Rickbot Multi-Personality Application [Medium (2025-08-30)] — Details the implementation of a multi-personality agentic application using the Google Agent Development Kit (ADK) and Gemini CLI. Evaluates hosting architectures, favoring Google Cloud Run over Agent Engine for its faster deployment cycles, cost-effective scale-to-zero capabilities, and simplified co-location of the Streamlit UI and agent logic. Demonstrates project management optimization by utilizing TODO.md and GEMINI.md files to provide persistent context for Gemini CLI, enabling the LLM to track task progress and automate documentation updates. Includes a comprehensive environment configuration script for managing Google Cloud project switching, authentication, and dependency syncing via the uv package manager. Provides a technical walkthrough of the rickbot_agent construction, defining an Agent instance configured with the Gemini 1.5 Flash model, specialized system instructions for character personalities, and integrated tools like Google Search. Highlights the use of ADK’s built-in FastAPI server for exposing agent endpoints and the integration of Google Application Default Credentials (ADC) for secure cloud resource access. [Tags: Google Cloud Run, Agent Development Kit, Gemini CLI, Generative AI, Python]
Creating an Automated UI Test of Your Web App in Seconds, with Gemini CLI and BrowserMCP [Medium (2025-08-14)] — Demonstrates how to automate web UI testing using Gemini CLI and BrowserMCP. Configuration involves adding the MCP server to settings.json and installing a Chrome extension to enable Multi-Modal MCP Tool Responses. This setup allows Gemini CLI to interpret and act on browser-based modalities beyond simple text. The workflow involves launching a local web application, connecting the BrowserMCP extension, and issuing natural language prompts to perform complex UI sequences—such as selecting dropdown options, interacting with specific elements, and verifying responses. This approach significantly reduces the time required to create regression tests by eliminating manual scripting in traditional frameworks. The integration highlights the utility of the Model Context Protocol (MCP) in bridging generative AI with live browser environments for seamless agentic automation and data extraction. [Tags: Gemini CLI, BrowserMCP, Model Context Protocol, Automated UI Testing, Generative AI]
Using Gemini CLI to Create a Gemini CLI Config Repo [Medium (2025-08-12)] — Details how to manage Gemini CLI configurations across multiple devices by creating a private GitHub repository. Uses Gemini Code Assist in Agent Mode to automate development workflows through natural language prompts. The configuration includes a GEMINI.md for global context, a settings.json for Model Context Protocol (MCP) server definitions, and custom slash commands. Key MCP integrations include GitHub, media generation tools like Veo and Imagen, and local environment management using uv. Demonstrates automating Git tasks such as initializing repositories, creating .gitignore and README files, and resolving branch naming conflicts without manual CLI commands. Provides a workflow for synchronizing configurations onto new machines by initializing Git in the /.gemini directory and performing a hard reset against the remote origin. Emphasizes the transition from deprecated google-generativeai packages to the newer Google Gen AI SDK and ADK for agent development. [Tags: Gemini CLI, Model Context Protocol, Google Code Assist, Git Automation, LLM Configuration]
Updating the Rickbot Multi-Personality Agentic Application Part 2 — Integrate Agent Development… [Medium (2025-08-11)] — Details the migration of the Rickbot generative AI application to the Google Agent Development Kit (ADK) leveraging Gemini CLI for automated refactoring and code generation. Covers the configuration of Gemini CLI using project-specific settings and the /init command to establish project context via GEMINI.md. Explains the process of using the Agent-Starter-Pack to provision Google Cloud resources via Terraform and establish CI/CD pipelines with Cloud Build. Key technical workflows include utilizing Gemini CLI to manage git branches, update dependencies with uv, and refactor legacy code into ADK-compliant modules. Demonstrates the use of the ADK developer web UI for local testing and debugging of agent logic. Addresses practical implementation challenges such as porting Streamlit frontends to the ADK backend, maintaining conversation state in session memory, and integrating Google Secret Manager for secure system instructions. Highlights the efficiency gains of AI-assisted development while emphasizing the necessity of manual verification for complex logic, session handling, and asset management. Provides a structural overview of the resulting project architecture, including the separation of agent logic, media assets, and deployment configurations within the Vertex AI ecosystem. [Tags: Google Agent Development Kit, Gemini CLI, Vertex AI, Generative AI Agents, Google Cloud Platform]
Building the Rickbot Multi-Personality Agentic Application using Gemini CLI, Google… [Medium (2025-08-08)] — Explores the migration of a multi-personality chatbot, Rickbot, to a professional agentic architecture using the Google Agent Development Kit (ADK) and Agent-Starter-Pack. The workflow leverages the Agent-Starter-Pack to automate project scaffolding, including Terraform for Infrastructure as Code (IaC), Cloud Build for CI/CD, and standardized project structures. Key technical components include the ADK for modular agent orchestration, model-agnostic development, and built-in support for tools like Google Search and Model Context Protocol (MCP). The application transitions from basic Cloud Run hosting to Vertex AI Agent Engine, a serverless runtime that manages scaling and session memory natively. Development efficiency is enhanced using the Gemini CLI, which utilizes a GEMINI.md context file to provide specialized assistance for ADK-specific tasks. The setup emphasizes production readiness through multi-environment deployment strategies and the use of 'uv' for high-performance Python package management. Key architectural decisions include separating the React-based UI on Cloud Run from the agent logic on Agent Engine, while managing secrets via Google Secret Manager and implementing robust CI/CD pipelines. [Tags: Google Cloud Platform, Agent Development Kit, Vertex AI Agent Engine, Generative AI, CI/CD]
Give Gemini CLI the Ability to Generate Images and Video, Work with GitHub Repos, and Use Other… [Medium (2025-07-10)] — Explores the capabilities of Gemini CLI, a terminal-based interface for Google’s Gemini models. Installation requires Node.js (v20+) via npm, providing a local-aware environment for file operations and Google Search. Persistent behavior is managed through hierarchical GEMINI.md context files that define personas and coding standards. A core technical focus is the Model Context Protocol (MCP), which enables standardized integration with external services. The guide details configuring MCP servers within settings.json to enable GitHub repository management and Vertex AI media generation tools, including Imagen for images and Veo for video. It highlights the use of environment variable substitution for secure credential management and the choice between local Docker-based or remote MCP server implementations. By extending the CLI with MCP, developers can automate complex workflows that bridge local file systems with cloud-based APIs and external developer tools. [Tags: Gemini CLI, Model Context Protocol, Vertex AI, Node.js, GitHub API]
Adding Authentication and Authorisation to our Rickbot Streamlit Chatbot with OAuth and the Google… [Medium (2025-06-26)] — Integrates OAuth 2.0 and OpenID Connect (OIDC) into Streamlit applications using the Google Auth Platform to manage user authentication and authorization. The implementation utilizes the Python Authlib package alongside Streamlit's native st.login() and st.logout() functions to handle user sessions. Configuration involves setting up OAuth clients in the Google Cloud Console, defining redirect URIs for local and Cloud Run environments, and implementing a toggleable AUTH_REQUIRED variable for deployment flexibility. To maintain high security standards, OAuth credentials are stored in Google Secret Manager rather than local configuration files. A custom Python script retrieves these secrets at runtime to dynamically generate the .streamlit/secrets.toml configuration within the container environment. The workflow concludes with deploying the containerized application to Google Cloud Run, leveraging Cloud Build for CI/CD and Secret Manager for secure credential injection. This architecture replaces manual user database management with a scalable, industry-standard identity provider solution while ensuring sensitive credentials are never committed to version control or hardcoded in container images. [Tags: Streamlit, OAuth 2.0, Google Cloud Platform, Google Secret Manager, Cloud Run]
Creating a Rick & Morty Chatbot with Google Cloud and the Gen AI SDK [Medium (2025-06-23)] — Implements a Rick Sanchez-themed chatbot utilizing the Google Gen AI SDK and Gemini 2.5 Flash on Vertex AI. The development workflow begins with meta-prompting to define a cynical, nihilistic system persona and incorporates grounding via Google Search to mitigate hallucinations and provide real-time information. The technical implementation leverages the google-genai Python library, which offers a unified interface for Vertex AI and Gemini APIs. Key architectural features include: - Model Selection: Utilizing Gemini 2.5 Flash for cost-effective, low-latency performance. - Grounding: Integrating the GoogleSearch tool within the GenerateContentConfig to enable external knowledge retrieval. - UI Development: Building a responsive frontend using Streamlit to handle chat history and streaming responses. - Performance Optimization: Employing Python’s lru_cache to manage Vertex AI client initialization and model configuration efficiently. - Multimodal Support: Processing diverse input types including images and PDFs by passing byte data through Part.from_bytes. - Deployment: Containerizing the application with Docker and hosting on Google Cloud Run for scalable, serverless execution. The project also highlights modern Python tooling, specifically using uv for environment management and git-crypt for sensitive configuration handling. [Tags: Google Cloud Platform, Gemini AI, Vertex AI, Streamlit, Python SDK]
Using Google Identity-Aware Proxy (IAP) with Cloud Run — Without a Load Balancer! [Medium (2025-05-24)] — Demonstrates how to secure Google Cloud Run applications using Identity-Aware Proxy (IAP) without the overhead and cost of a Google Cloud Load Balancer. Previously, IAP required a load balancer, adding significant monthly costs for small-scale or demo applications. This direct integration enforces authentication and authorization even when using the default run.app URL. Implementation involves enabling the Cloud Identity API and activating 'Advanced authentication with Identity-Aware Proxy' within the Cloud Run service security settings. Access control is managed by granting the roles/iap.httpsResourceAccessor IAM role to specific users or groups. For automated deployments, the gcloud beta run deploy command supports the --iap flag, allowing for seamless CI/CD integration. This approach provides a cost-effective, serverless method for securing internal applications while maintaining robust identity-based access control. [Tags: Google Cloud Run, Identity-Aware Proxy, Cloud IAM, Serverless Security, gcloud CLI]
NotebookLM is Google’s INSANELY COOL Personal AI Research Assistant [Medium (2025-05-05)] — NotebookLM is a Google AI research assistant powered by the Gemini multimodal model. It utilizes Retrieval-Augmented Generation (RAG) to ground responses in user-specified sources, significantly reducing hallucinations. Supported inputs include Google Docs, Slides, PDFs, Markdown, web URLs, YouTube videos, and audio files up to 200MB. The tool extracts text and visual data from images and tables within documents. Key technical outputs include automated summaries with inline citations, FAQs, study guides with glossaries, and briefing documents. A standout feature is the Audio Overview, which generates natural-sounding, two-person podcasts based on the source material, with options for custom prompting to influence the conversation's focus. Users can interact via a chat interface to perform deep-dive analysis, generate quizzes, or draft documents like RFI responses. The platform facilitates collaborative research by allowing notebooks to be shared across teams, making it a versatile tool for knowledge management, academic study, and enterprise documentation synthesis. [Tags: NotebookLM, Generative AI, Gemini AI, Retrieval-Augmented Generation, Multimodal AI]
Integrating our Application CI/CD Pipelines and Terraform GitOps with Cloud Build [Medium (2025-05-01)] — Details the transition from manual Terraform execution to an automated GitOps workflow using Google Cloud Build. Implements a dual-configuration strategy to separate infrastructure management from application deployment. The first configuration automates building, pushing to Artifact Registry, and deploying containerized services to Cloud Run, triggered by changes in source or test directories. The second configuration handles the Terraform lifecycle—initialization, planning, and application—using a dedicated YAML file triggered by modifications in the deployment directory. Key technical implementations include path-based filtering via 'included_files' to prevent redundant builds, Google Cloud Storage for remote state management, and Secret Manager for secure GitHub integration. The setup utilizes substitution variables to manage environment-specific parameters across multiple GCP projects. By leveraging dedicated service accounts and modular Cloud Build triggers, the architecture ensures a secure, scalable CI/CD pipeline that distinguishes between application logic and underlying infrastructure changes. [Tags: Google Cloud Build, Terraform, GitOps, CI/CD, Google Cloud Run]
Deploying our Video Intelligence Cloud Run Appication with Terraform and Cloud Build [Medium (2025-04-28)] — Implements a GitOps-based CI/CD pipeline for a Video Intelligence application using Terraform and Google Cloud Build. The architecture utilizes separate Google Cloud projects for development and production environments, triggered by pushes to dev and main GitHub branches respectively. Terraform manages the underlying infrastructure, including IAM roles, APIs, and service accounts, while application deployment to Cloud Run is handled via gcloud commands within Cloud Build. Key technical components include storing Terraform state in versioned Google Cloud Storage buckets to support collaboration and recovery, and using Google Secret Manager to securely store GitHub Personal Access Tokens for repository integration. The workflow emphasizes security through custom service accounts and branch protection for production merges. By adopting a declarative infrastructure-as-code approach, the solution ensures repeatable deployments across environments. The pipeline automates container image builds, pushes to Artifact Registry, and service updates, streamlining the transition from local development to a managed serverless environment. [Tags: Terraform, Google Cloud Build, Cloud Run, CI/CD, Infrastructure as Code]
Sequencing Cloud Migration to Reduce Cost: What to Migrate and When [Medium (2025-03-24)] — Achieving positive ROI in cloud migration requires a strategic sequence that prioritizes the elimination of commercially licensed software, which typically accounts for 75% of on-premises hosting spend. Standard lift-and-shift approaches often fail to reduce TCO because enterprise license agreements and sunk infrastructure costs prevent immediate savings. To maximize value, organizations must transition from proprietary stacks to cloud-native managed services built on open-source foundations, such as Google Kubernetes Engine, Cloud SQL, and AlloyDB. A critical technical hurdle is double-run costs, where on-premises expenses persist until entire multi-tenant platforms are fully decommissioned. Effective migration sequencing involves mapping application dependencies to high-cost hosting contracts and aligning migration timelines with contract expiry dates. This ensures that infrastructure can be retired before renewal cycles. Additionally, technical teams should implement FinOps best practices, including Infrastructure-as-Code (IaC) for on-demand environments, spot VMs, storage lifecycle management, and rightsizing workloads to prevent inefficient cloud utilization. By focusing on platform-level decommissioning rather than individual application moves, enterprises can effectively eliminate on-premises footprints and realize the elasticity and operational efficiency of public cloud. [Tags: Cloud Migration, TCO Optimization, FinOps, Managed Services, Infrastructure as Code]
Tips for Passing (or Repassing!) the Google Professional Data Engineer (PCDE) Exam [Medium (2025-03-16)] — Focuses on core competencies for the Google Professional Data Engineer (PCDE) exam, emphasizing BigQuery optimization through partitioning, clustering, slot reservations, and an understanding of BigQuery Editions. Data ingestion and messaging strategies prioritize Pub/Sub features like exactly-once delivery, message ordering, and retention. Storage management highlights GCS Autoclass for automated lifecycle management and BigLake for unified data lake governance. For large-scale processing, Dataflow concepts such as the Shuffle Service, Streaming Engine, and windowing (tumbling, hopping, session) are critical, alongside handling late data via watermarks. Bigtable is positioned as the primary choice for high-volume IoT ingestion, necessitating strategic row key design. Security requirements involve Identity and Access Management (IAM), Customer-Managed Encryption Keys (CMEK), and Cloud EKM for regulatory compliance. The exam evaluates the ability to select architectures based on cost-efficiency, maintenance overhead, and latency requirements. Notably, machine learning content has shifted to the dedicated ML Engineer exam. Successful candidates must distinguish between managed services and identify the 'best' solution under specific constraints like 'simplest' or 'lowest latency'. [Tags: Google Cloud Platform, Data Engineering, BigQuery, Dataflow, Cloud Certification]
Accelerating Cloud Migration with the Migration Factory and Migration Tools [Medium (2025-02-05)] — Defines the Migration Factory as a centralized team specializing in repeatable migration use cases to offload technical complexity from application teams. Focuses on two primary Google Cloud migration paths: rehosting and replatforming. For rehosting, Migrate to Virtual Machines facilitates low-downtime transfers from VMware, AWS, or Azure to Google Compute Engine (GCE), featuring automatic OS adaptation and background data replication. For replatforming, Migrate to Containers (M2C) automates the extraction of VM-based workloads—such as Tomcat, WebSphere, and IIS—into container images for GKE or Cloud Run. M2C utilizes a CLI or Console-based workflow to generate migration plans, assessment reports, and deployment artifacts via Skaffold. Technical benefits include the ability to split monolithic co-located services into independent containers and rightsizing GCE instances post-migration to optimize TCO. Strategy emphasizes transitioning from proprietary application servers to open-source container images to eliminate licensing overhead. This centralized approach ensures consistency, leverages specialized tooling, and accelerates enterprise-scale transitions by standardizing migration patterns across the organization. [Tags: Google Cloud Platform, Cloud Migration, Google Kubernetes Engine, Compute Engine, Containerization]
Optimising the Cost of our Video Intelligence Service on Google Cloud Run, Aided with Billing… [Medium (2025-02-03)] — Analyzes cost optimization for a Video Intelligence service on Google Cloud Run by identifying that 96% of expenses originated from Cloud Load Balancing forwarding rules rather than compute or AI services. To eliminate the $18/month minimum charge, the architecture was modified to remove the external Load Balancer. Key technical adjustments included updating Cloud Run ingress settings to "All" and setting IAM policy bindings to allow "allUsers" access. Domain management transitioned from Load Balancer-based A records to Cloud Run's native domain mapping feature using CNAME records and Google-managed SSL certificates. The shift necessitates moving authentication logic from Identity Aware Proxy (IAP) into the application code using OAuth 2.0. Further cost-containment strategies involve setting max-instances to 1 to limit autoscaling and configuring billing alerts with Pub/Sub-triggered Cloud Functions for automated budget enforcement. This approach leverages Google’s free usage tiers to achieve near-zero hosting costs for low-traffic applications while accepting trade-offs in enterprise-grade security features. [Tags: Google Cloud Run, Cloud Load Balancing, Cost Optimization, Serverless Architecture, Cloud Billing]
Should You Switch to a Windows ARM Laptop? My Experience of the Surface Laptop 7 [Medium (2025-01-06)] — Analyzes the transition from x86-64 Intel-based laptops to the ARM-based Microsoft Surface Laptop 7 featuring the Qualcomm Snapdragon X Elite processor. Highlights the architectural shift from CISC-based x86 to power-efficient ARM, noting significant improvements in multithreaded performance and battery life, which reaches up to 15 hours. Details the maturity of the Windows on ARM ecosystem, specifically the Prism emulation layer in Windows 11 24H2, which allows x86-64 applications to run with high efficiency. Covers the availability of native ARM64 binaries for essential development tools like VS Code, Python, Docker, and Git. Recommends using the winget package manager to automatically resolve architecture-specific dependencies. Notes that while most software runs natively or via emulation, certain kernel-level applications like third-party antivirus may still face compatibility hurdles. Confirms that WSL (Windows Subsystem for Linux) seamlessly supports ARM-based distributions, making the device a viable workstation for developers and cloud engineers. [Tags: Windows on ARM, Snapdragon X Elite, ARM64, Prism Emulation, Surface Laptop 7]
Python SymPy to Solve Linear Equations [Medium (2024-12-18)] — Explores using the Python SymPy library to solve systems of linear equations within the context of an Advent of Code challenge. The problem involves calculating the optimal number of button presses to reach a target coordinate at minimum cost. By defining variables as SymPy symbols and constructing equality objects with sympy.Eq, developers can solve for unknowns without manual algebraic rearrangement. This approach proves robust even when handling the extremely large integers introduced in the challenge's second part. While SymPy simplifies implementation, a manual mathematical approach using substitution offers significantly better performance, reducing execution time from nearly a second to approximately 14 milliseconds. Demonstrates parsing input with regular expressions, structuring data with Python dataclasses, and implementing both the SymPy-based and the direct algebraic solvers. [Tags: Python, SymPy, Linear Equations, Advent of Code, Algebraic Solvers]
Building and Running an AI YouTube and Video Processing in Python, and Running on Cloud Run with… [Medium (2024-12-03)] — Details the transition of an AI-driven video processing tool from Jupyter notebooks to a production-ready Streamlit web application. Employs Streamlit for the frontend to enable pure-Python UI development, bypassing the need for HTML/CSS. The application is containerized with Docker and deployed to Google Cloud Run, providing a serverless runtime that scales to zero for cost-efficiency. The architecture utilizes Google Artifact Registry for image management and Google Cloud Build to establish a CI/CD pipeline integrated with GitHub. Security is implemented via an External Application Load Balancer and Identity-Aware Proxy (IAP), enforcing a zero-trust access model to restrict the service to authorized users. For its core intelligence, the application leverages the Gemini 1.5 Flash multimodal model via Vertex AI to perform video transcription, translation, and summarization. Technical implementation highlights include using BytesIO for in-memory video handling to optimize performance and Streamlit’s caching mechanisms to reduce redundant API calls and processing overhead. [Tags: Streamlit, Google Cloud Run, Gemini 1.5 Flash, Docker, Vertex AI]
YouTube Video Downloader with Generative AI and Python: Run Anywhere, Transcribe and Translate [Medium (2024-11-25)] — Details an enhanced YouTube downloader and transcription pipeline leveraging Google Cloud AI services. Key technical components include the Google Video Intelligence API for high-accuracy speech-to-text and Google Gemini Generative AI for automated translation and summarization. The workflow utilizes the pytubefix library for video acquisition and audio extraction. The implementation provides a cross-platform Jupyter notebook compatible with three distinct environments: local machines, Google Colab, and Vertex AI Workbench. Technical setup involves configuring Google Cloud Platform (GCP) projects, enabling specific APIs (Cloud Storage, Video Intelligence, and Vertex AI), and implementing Application Default Credentials (ADC) for seamless authentication. For enterprise deployments, it explores Vertex AI Workbench configuration, including VPC networking, Private Google Access, and Cloud NAT. The solution addresses limitations of basic transcription tools by offering language detection and multi-language translation. It further demonstrates managing Google Cloud Storage (GCS) buckets and lifecycle policies directly from Python. This approach provides a scalable, AI-driven framework for processing video content across various hosting tiers, from free cloud-based options to managed enterprise infrastructure. [Tags: Google Cloud Platform, Generative AI, Vertex AI, Python, Speech-to-Text]
How to Accelerate Cloud Migrations at Scale [Medium (2024-11-11)] — Outlines strategies for scaling enterprise cloud migrations by balancing centralized core migration factory activities with federated tasks handled by application teams. Recommends centralizing one-off, high-complexity tasks like database schema conversions while federating educational activities such as infrastructure-as-code development and design documentation. Highlights the Cloud Center of Excellence (CCoE) as a critical function for providing standardized artifacts, including Solution Design Document (SDD) and Migration Design Document (MDD) templates. These templates prioritize architecturally significant requirements (ASRs), non-functional requirements (NFRs), and clear decision rationales. Proposes the use of opinionated decision trees to streamline technology selection for databases, storage, and data pipelines, ensuring consistency and alignment with organizational standards. By pre-baking considerations like performance, availability, and cost into these flowcharts, organizations can reduce architectural divergence and accelerate governance reviews. Key CCoE outputs include reusable blueprints, a repository of proven solutions, and streamlined architectural governance processes that focus on exceptions rather than standard patterns. This approach minimizes technical debt and ensures that cloud adoption remains efficient and scalable across large estates. [Tags: Cloud Migration, Cloud Center of Excellence (CCoE), Architecture Governance, Google Cloud Platform, Infrastructure as Code (IaC)]
Tips for Passing the Google Professional Developer (PCD) Exam [Medium (2024-11-02)] — Outlines preparation strategies for the Google Cloud Professional Cloud Developer (PCD) exam, emphasizing technical domains such as compute, security, and CI/CD. Highlights the importance of the Principle of Least Privilege in IAM and the dominance of Cloud Run for serverless deployments, specifically regarding VPC connectors and Cloud SQL integration. Details GKE management, focusing on PersistentVolumeClaims, Autopilot constraints, and node scheduling via taints and tolerations. Explains service coordination patterns, distinguishing between orchestration using Cloud Workflows and event-driven choreography with Pub/Sub. Covers deployment strategies like Canary and Blue/Green rollouts across Cloud Run and GKE, alongside service discovery via Service Directory. Addresses security mechanisms including Binary Authorization, Artifact Scanning, and the distinction between Workload and Workforce Identity Federation. Provides insights into performance optimization using Memorystore and handling HTTP 429 errors with exponential backoff. Finally, notes the relevance of developer tools like Skaffold and Cloud Code for local emulation and pipeline integration. [Tags: Google Cloud Platform, Cloud Run, Google Kubernetes Engine, CI/CD, Identity and Access Management]
Downloading YouTube Videos, Extracting Audio, and Generating Transcripts with Python and Jupyter… [Medium (2024-10-25)] — Outlines a Phase 1 MVP for a YouTube downloader and processor using Python and Jupyter Notebooks. Covers three distinct technical approaches for downloading videos and extracting audio. Utilizes pytubefix for high-speed downloads and basic audio extraction. Combines pytubefix with moviepy to ensure correct MP3 header encoding and provide advanced media manipulation capabilities. Implements yt-dlp, a robust fork of youtube-dl, leveraging FFmpeg for high-quality audio extraction. Demonstrates running these workflows in Google Colab for a zero-setup cloud experience and local Python virtual environments using Jupyter Lab or VS Code. Key technical steps include cleaning filenames to avoid filesystem errors, managing streams for highest resolution, and configuring post-processors for specific codecs. Aims to eventually incorporate AI-driven transcription and translation, moving from a notebook-based MVP to a hosted Google Cloud Run web application. [Tags: Python, Jupyter Notebook, yt-dlp, MoviePy, Google Colab]
Develop Serverless Applications on Cloud Run: Google Cloud Challenge Lab Walkthrough [Medium (2024-10-20)] — Provides a technical walkthrough for deploying serverless applications on Google Cloud Run, focusing on containerization, deployment workflows, and secure service-to-service communication. Key takeaways include utilizing Google Cloud Build to create container images from source and hosting them in Google Container Registry. The guide emphasizes the implementation of IAM Service Accounts to establish secure identities for Cloud Run services, moving away from default compute identities. It details the process of securing a backend 'Billing Service' by disabling unauthenticated access via the '--no-allow-unauthenticated' flag and granting the 'roles/run.invoker' permission to a specific frontend service account. This ensures that only authorized callers can trigger private endpoints. Practical steps involve using the gcloud CLI for building images (gcloud builds submit), deploying services (gcloud run deploy), and managing IAM policy bindings. The architecture demonstrates a transition from staging to production environments, illustrating how to orchestrate a public-facing frontend that securely communicates with a private backend in a serverless ecosystem. [Tags: Google Cloud Run, Serverless, IAM, Google Cloud Build, Containerization]
Develop Serverless Apps with Firebase : Google Cloud Challenge Lab Walkthrough [Medium (2024-10-15)] — Provides a technical walkthrough for completing the Google Cloud Challenge Lab 'Develop Serverless Apps with Firebase.' The architecture involves building a serverless frontend and a REST API backend, both hosted on Cloud Run, which interact with a Cloud Firestore NoSQL database. Key technical steps include initializing a Firestore database in native mode and populating it with CSV data via a Node.js script. It details using Cloud Build to containerize applications and push images to Google Container Registry. The process covers deploying multiple revisions of Cloud Run services, configuring public access with the --allow-unauthenticated flag, and managing service-to-service communication. Practical advice is offered regarding the use of environment variables for service discovery and the specific requirement to use Google Container Registry over Artifact Registry for lab completion. The walkthrough emphasizes a programmatic approach using the gcloud CLI within Cloud Shell for repeatable deployments. [Tags: Cloud Run, Firestore, Serverless, Google Cloud Platform, Cloud Build]
Deploy Kubernetes Applications on Google Cloud: Google Cloud Challenge Lab Walkthrough [Medium (2024-10-15)] — Provides a technical walkthrough for completing the 'Deploy Kubernetes Applications on Google Cloud' challenge lab. Focuses on containerizing a Go application, managing images via Artifact Registry, and orchestrating deployments on Google Kubernetes Engine (GKE). Key technical steps include cloning source code from Cloud Source Repositories, authoring a Dockerfile, and performing local container testing. Demonstrates the transition from local Docker builds to automated image management using 'gcloud builds submit' and Google Artifact Registry (GAR). Detailed instructions cover configuring gcloud authentication for Docker, retrieving GKE cluster credentials, and modifying Kubernetes manifest files. Final stages involve deploying the application using kubectl and exposing it through a LoadBalancer service. Emphasizes a programmatic approach using Cloud Shell and the gcloud CLI to automate infrastructure tasks and ensure repeatable deployment patterns. [Tags: Google Cloud Platform, Kubernetes, Docker, Google Kubernetes Engine, Artifact Registry]
Create a CI/CD Pipeline using GitHub Actions and Google Cloud [Medium (2024-09-16)] — Details the implementation of a CI/CD pipeline using GitHub Actions to automate the testing, building, and deployment of a Python-based application to Google Cloud Run and Cloud Functions. Utilizes Google Artifact Registry for binary management and GitHub Secrets for secure credential storage, specifically employing base64-encoded service account keys for authentication. The workflow integrates automated linting via flake8 and unit testing with pytest, triggered by code pushes or pull requests to the main branch. Employs a matrix strategy within GitHub Actions to concurrently process multiple application components, such as the UI and backend functions. Highlights best practices for service account permissions, including roles for Cloud Build, Storage, and Cloud Run administration. While the guide focuses on service account keys for simplicity, it notes Workload Identity Federation as a superior alternative for OIDC-based authentication. This setup ensures rapid feedback loops and reduces manual toil by maintaining a deployable state for the application across development cycles. [Tags: GitHub Actions, Google Cloud Platform, CI/CD, Python, Cloud Run]
Develop GenAI Apps with Gemini and Streamlit: Google Cloud Challenge Lab Walkthrough [Medium (2024-08-15)] — Demonstrates building a generative AI application using Gemini Pro and Streamlit on Google Cloud. Utilizes Vertex AI Workbench for API testing via cURL and Jupyter notebooks to validate prompt engineering. The workflow involves developing a Python-based UI with Streamlit, integrating multimodal foundation models to generate dynamic content. Technical execution includes managing Python virtual environments, containerizing the application with Docker, and pushing images to Google Artifact Registry (GAR). Final deployment leverages Cloud Run for serverless container hosting, utilizing gcloud CLI for automated provisioning and environment variable management. Key technical components include Gemini Pro's multimodal capabilities, Streamlit's rapid prototyping framework, and Google Cloud’s serverless ecosystem for scalable AI deployment. This walkthrough bridges the gap between local development and production-ready cloud architecture. [Tags: Gemini Pro, Streamlit, Google Cloud Run, Vertex AI, Docker]
Cloud Adoption: Enabling Your Consumers and Tenants, and the Project Factory [Medium (2024-08-08)] — Addresses the scalability challenges of managing hundreds of Google Cloud projects through the implementation of a Terraform-based Project Factory. Utilizes Google Cloud Foundation Fabric (CFF) to enable a YAML-driven GitOps workflow for provisioning tenant folders, projects, billing associations, and IAM roles. Key technical components include a centralized Seed project for privileged execution, GCS for remote state management, and the automation of service account creation for tenant-specific infrastructure pipelines. Demonstrates how to structure YAML configurations for resource hierarchies, API enablement, and billing budgets. Extends the automation framework by integrating ITSM tools like ServiceNow to trigger CI/CD pipelines for self-service tenant onboarding. Highlights the strategic importance of developer sandboxes as isolated, self-service environments to facilitate experimentation within organizational guardrails, reducing the friction caused by environmental constraints. [Tags: Google Cloud Platform, Terraform, GitOps, Infrastructure as Code, Cloud Foundation Fabric]
Optimise Costs for Google Kubernetes Engine: Google Cloud Challenge Lab Walkthrough [Medium (2024-07-30)] — Provides a technical walkthrough for optimizing Google Kubernetes Engine (GKE) costs through resource management and multi-dimensional autoscaling. Key procedures include creating zonal clusters with specific machine types and managing environments via namespaces. Demonstrates node pool optimization by migrating workloads from default pools to custom-sized pools using cordon and drain operations to minimize resource waste. Covers application maintenance through rolling updates, Pod Disruption Budgets (PDB) to ensure availability, and ImagePullPolicy configurations. Implements 4-way autoscaling strategies by combining Horizontal Pod Autoscalers (HPA) for workload spikes and Cluster Autoscalers (CA) for infrastructure flexibility. Includes performance validation using the Locust open-source load testing framework to simulate traffic surges and verify scaling responsiveness. Highlights advanced cost-saving techniques such as Node Autoprovisioning (NAP), Vertical Pod Autoscaling (VPA), and the use of pause pods to mitigate autoscaling latency. [Tags: Google Kubernetes Engine, Autoscaling, Kubernetes Administration, Cloud Cost Optimization, Load Testing]
Building a Serverless Image Text Extractor and Translator Using Google Cloud Pre-Trained AI [Medium (2024-06-28)] — Details the architecture and deployment of a serverless image-to-text translation application on Google Cloud Platform. The solution utilizes a Python Flask frontend hosted on Cloud Run for containerized web serving and Cloud Functions for backend logic. Integration with Google Cloud Vision API enables optical character recognition (OCR), while the Translation API processes multilingual text. The architecture prioritizes predictive AI models over generative alternatives like Gemini Pro to minimize costs and latency for specific tasks. Technical implementation involves local development using Visual Studio Code, WSL, and the Google Cloud Code plugin. The setup process emphasizes security through the principle of least privilege, utilizing dedicated service accounts and IAM roles. Key components include gcloud CLI configuration, API enablement for Cloud Build and Artifact Registry, and local testing via the functions-framework. This end-to-end workflow demonstrates how to decouple UI from processing logic while maintaining a scalable, zero-to-N serverless footprint. [Tags: Google Cloud Platform, Serverless, Cloud Functions, Cloud Run, Computer Vision]
I Deleted A Bunch of Org Policies! Here’s What Google Cloud Told Me… [Medium (2024-06-10)] — Demonstrates Google Cloud's native security alerting capabilities when performing sensitive administrative actions, such as bulk deletion of organizational policies. During a Landing Zone (LZ) reconstruction using Terraform, a conflict arose where previous policies remained after a state file deletion. To resolve this, a Bash script utilizing gcloud org-policies commands was used to programmatically list and delete all constraints at the organization level. This action triggered immediate 'Sensitive Action' notifications via email and the Google Cloud Console. These alerts are integrated into the Security Command Center (SCC) and Advisory Notifications, where the bulk deletion was classified as a 'Defense evasion' finding. The process highlights the importance of Terraform state management and the efficacy of SCC's basic tier in monitoring for potentially malicious activity. Key technical takeaways include the use of the gcloud CLI for policy management and the automated detection of administrative anomalies within the Google Cloud ecosystem. [Tags: Google Cloud Platform, Terraform, Security Command Center, Organization Policies, Infrastructure as Code]