Skip to main content
AIDevOps
  • Learn
  • Learning Paths
  • Practice
  • Open Source
  • Books
  • Engineering

    AI DevOpsThe full map of building and operating AI servicesLLMOpsLLM deployment · evaluation · observabilityHands-on ProjectsBuild AI Agent projects

    Knowledge

    DocsTechnical documentationBlogEngineering articlesPloggerDevelopment log feed

    Validate

    Certification3-level skills certification · coming soon
AI Models
LlamaTutorial|MistralTutorial|GemmaTutorial|DeepSeekTutorial|QwenTutorial
☁️ Cloud
Cloud Intro & RoadmapAWSGCPAzureNCPCloudflare
🤖 AI Applied Development
Applied AI Intro & RoadmapHugging FaceLangChainLlamaIndexLLMOps|LangGraphMCPMulti-AgentAgent Evaluation
🧠 AI Core
AI Intro & RoadmapML FundamentalsLLM Fundamentals|Python AIC++|PyTorchTensorFlowJAX
🧠 AI Agent Development
Finance AI AgentLLM API ServerStock Investing AgentAIOps AI AgentEducation AI AgentCoding AI Agent
🌱 Spring Cloud
Spring Intro & RoadmapSpring Cloud GatewaySpring BootJava|Spring AISpring SecuritySpring BatchSpring JPA
🐳 DevOps
DevOps Intro & RoadmapLinuxDockerCI/CD|Kubernetes BasicsK8s AdvancedPrometheusGrafana
🧱 Infrastructure
Infrastructure Intro & RoadmapNginxRedis
🎨 Frontend
Frontend Intro & RoadmapJavaScriptTypeScript|ReactNext.js|VueNuxt|Electron
📱 Mobile
Mobile Intro & RoadmapKotlinAndroidFlutter
⚙️ Backend
Backend Intro & RoadmapPython BasicsFastAPIDjangoFlask|CGoGinNode.js
💾 Database
DB Intro & RoadmapCore SQLOracleMySQLPostgreSQL|MongoDBVector DB
🧪 Testing
k6JMeternGrinder
AIDevOps

Engineering AI. From Code to Production.
An engineering learning platform for building and operating AI and AI Agents

Learn

  • All Guides
  • Learning Paths
  • AI Tutorial
  • Practice
  • Books

Resources

  • AI DevOps
  • LLMOps
  • Hands-on Projects
  • Docs
  • Blog
  • Plogger
  • Open Source
  • Certification (coming soon)

Start Here

  • AI Core Roadmap
  • AI Applied Development Roadmap
  • Spring Cloud Roadmap
  • DevOps Roadmap
  • Infrastructure Roadmap

 

  • Cloud Roadmap
  • Frontend Roadmap
  • Mobile Roadmap
  • Backend Roadmap
  • Database Roadmap
© 2026 AIDevOps. All rights reserved.
Terms of ServicePrivacy PolicySitemaptestforge.kr
  1. Home
  2. Learn
  3. Cloud
  4. GCP
Guide to the Google Cloud Platform cloud

☁️ GCP Complete Guide

Visitors

Learn the core services of Google Cloud Platform and DevOps automation. Covers GKE (Google Kubernetes Engine) hybrid operations, deploying serverless containers on Cloud Run, VPC firewall design, IAM service account authentication, and the gcloud CLI.

  • Intermediate
  • Updated Oct 1, 2026
  • ~3 min read
  • 8 sections
  • 5 code examples

Learning Paths that include this guide

This guide is one step in the paths below. Study it together with the steps before and after.

  • Cloud Native Engineer →
Operating Kubernetes on GKECloud Run serverlessVPC & firewall designgcloud CLI automation

Contents

0 / 11
  1. How to use this guide
  2. Architecture diagrams
  3. Operating Kubernetes on GKE
  4. Serverless deployment on Cloud Run
  5. IAM service accounts
  6. Cloud Monitoring & Logging
  7. gcloud CLI commands
  8. GCP design
  9. Operating standards
  10. Verification strategy
  11. Frequently asked questions
Contents 11 sections
  1. How to use this guide
  2. Architecture diagrams
  3. Operating Kubernetes on GKE
  4. Serverless deployment on Cloud Run
  5. IAM service accounts
  6. Cloud Monitoring & Logging
  7. gcloud CLI commands
  8. GCP design
  9. Operating standards
  10. Verification strategy
  11. Frequently asked questions

How to use this guide

How to read it

Understanding GCP as a real-world workflow

Learn the core services of Google Cloud Platform and DevOps automation. Covers GKE (Google Kubernetes Engine) hybrid operations, deploying serverless containers on Cloud Run, VPC firewall design, IAM service account authentication, and the gcloud CLI. Rather than listing concepts, this guide is organized so you can follow the content in the order you have to make decisions on a real project.

Key perspective

Infrastructure / operations

Rather than memorizing install commands, understand the order in which traffic, runtime, observability, and incident response connect.

Operating Kubernetes on GKECloud Run serverlessVPC & firewall designgcloud CLI automation

Architecture diagrams

To make what you read stick, it helps to capture the flow as a picture first. The two diagrams below are reference maps you can keep coming back to while learning GCP.

Learning flow

Rendering diagram…

Architecture view

Rendering diagram…

Operating Kubernetes on GKE

When you first open GCP, the big picture matters more than individual commands. This section starts with the problems the concepts ahead were created to solve.

GKE (Google Kubernetes Engine) provides a managed Kubernetes service. With support for autoscaling, automatic upgrades, and Cloud Logging integration, it greatly lowers the overhead of operating microservices.
BASH
# Example of creating a GKE cluster
gcloud container clusters create "gke-dev-cluster" \\
  --region "us-central1" \\
  --num-nodes "3" \\
  --enable-autoscaling --min-nodes "1" --max-nodes "5" \\
  --enable-ip-alias

# Fetch the cluster credentials
gcloud container clusters get-credentials gke-dev-cluster --region us-central1

Serverless deployment on Cloud Run

Here you look at Serverless deployment on Cloud Run alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

Cloud Run is a serverless container runtime that scales instances fully automatically from 0 according to requests. It is very well suited to deploying stateless HTTP APIs and AI Agent API facades.
BASH
# Build the container from source and deploy it in one step
gcloud run deploy my-api-service \\
  --source . \\
  --region us-central1 \\
  --allow-unauthenticated \\
  --set-env-vars="ENV=production,MODEL=gpt-4o-mini"

IAM service account security

Here you look at IAM service account security alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

GCP uses Service Accounts for calls between services and for application access. Create one on a least-privilege policy, then either inject the JSON key file through a secure volume or use Workload Identity to map permissions directly to pods.
BASH
# Create a service account
gcloud iam service-accounts create my-app-sa \\
  --description="App Service Account" \\
  --display-name="my-app-sa"

# Grant the admin role for S3-compatible Storage
gcloud projects add-iam-policy-binding my-project-id \\
  --member="serviceAccount:my-app-sa@my-project-id.iam.gserviceaccount.com" \\
  --role="roles/storage.admin"

Cloud Monitoring & Logging

Here you look at Cloud Monitoring & Logging alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

GKE and Cloud Run send logs to Cloud Logging and resource metrics to Cloud Monitoring automatically, with no extra setup. But for "getting an alert when the error rate jumps", you have to create an Alert Policy yourself, and it needs to be managed as code rather than by clicking in the console so the alert setup is reproduced along with every deployment.
BASH
# Create a notification channel (email)
gcloud alpha monitoring channels create \
  --display-name="oncall-email" \
  --type=email \
  --channel-labels=email_address=oncall@example.com

# Create an alert policy for the Cloud Run 5xx ratio (references a policy JSON file)
gcloud alpha monitoring policies create --policy-from-file=cloudrun-5xx-policy.json

# View recent ERROR logs
gcloud logging read "resource.type=cloud_run_revision AND severity>=ERROR" \
  --limit 20 --format="table(timestamp, textPayload)"
MetricMeaningWhy it matters
run.googleapis.com/request_count (5xx)The number of times Cloud Run returned 5xxThe most direct signal of an application failure
container/cpu/core_usage_timeCPU usage of GKE podsThe basis for HPA scaling decisions and adjusting resource requests
logging.googleapis.com severity=ERRORCount of logs at severity ERROR or aboveWire it to alerts to detect failures early

Tip

Do not stop at creating alert policies in the console; download the JSON with gcloud policies describe and commit it to Git — that way you can restore the previous state even if a policy is deleted or changed by mistake.

gcloud CLI automation

Here you look at gcloud CLI automation alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

The gcloud CLI is very powerful for manipulating Google Cloud resources from the shell and automating deployment scripts.
BASH
# Set the active project and default zone
gcloud config set project my-project-id
gcloud config set compute/zone us-central1-a

# List virtual machines (GCE)
gcloud compute instances list

GCP practical design

GCP practical design is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

GCP design puts first the precise mapping of VPC firewalls to IAM service accounts, a dedicated network layout for GKE clusters, and mitigating cold starts of serverless resources such as Cloud Run.
Decision pointQuestion to askPractical guideline
BoundariesWhich parts of the GCP code are most likely to change?Separate input/output, configuration, external integrations, and the core rules.
StateWhere is state created and where does it go away?Make the owner and lifecycle of state visible in the code.
FailureWhat does the caller receive on failure?Decide the timeout, fallback, and error contract first.

GCP operating standards

This section covers GCP operating standards from a practical perspective. Instead of memorizing the concept, focus on the situations in which you would reach for it.

Monitor the unified Cloud Logging & Monitoring dashboards, the state of GKE node auto-provisioning, IAM service account key expiry dates, and Cloud Storage costs.

Tip

  • GKE VPC-native routing
  • Service Account min permissions
  • Cloud Run min-instances
  • Cloud Logging alerts

GCP verification strategy

GCP verification strategy is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Go through gcloud CLI dry-runs, Service Account permission audits, Terraform infrastructure validation, and Kubernetes manifest linter checks.
Quality axisHow to verifyDefinition of done
CorrectnessAutomate the normal/failure cases.The core scenarios pass reproducibly.
Regression preventionWhen fixing a bug, leave the same case behind as a test.The same failure is not deployed again.
OperabilityCheck the logs, metrics, and alerts.There is a path for tracing the cause when a problem occurs.

GCP: frequently asked questions

What is a project in GCP?

A project is the basic unit that groups resources, permissions, and billing in GCP. Every resource belongs to one project. Separating development and production into projects cleanly divides permissions and costs.

When do I use Cloud Run and when GKE?

Cloud Run is serverless: upload a container image and it scales with request volume, down to zero when there are no requests. GKE is managed Kubernetes with fine-grained control but more to operate. Start an ordinary web API on Cloud Run and look at GKE when you need what Kubernetes offers.

Is it acceptable to use service account key files?

Avoid them where you can. A leaked key file can be used by anyone until it expires. Attach a service account directly to resources running inside GCP, and for access from external CI use workload identity federation, which authenticates without keys.

← Previous guideAWSNext guide →Azure