Prepare and test your skills
Prepare and test your skills
Advising development and operations teams means making application and infrastructure releases automated, repeatable, and safe across regions and environments. Code flows from development through continuous integration and continuous delivery (CI/CD) pipelines into regional stacks, while infrastructure flows from versioned definitions into identical environments. The sections below show how networking, progressive rollout, API management, testing, migration, and AI assistance fit together.
Shared and dedicated service access controls how broadly a managed service can be reached from Virtual Private Cloud (VPC) networks. A service access VPC hosts shared consumer access points with transitive connectivity to other VPCs and external networks, while an application VPC hosts dedicated access points reachable only inside that same VPC. A VPC that holds both application resources and shared access points must be treated as a service access VPC because transitive routing changes its firewall duties.
| Access mode | Deployment location | Reachability |
|---|---|---|
| Shared consumer access points | Service access VPC | Reachable from any other VPC or external network |
| Dedicated consumer access points | Application VPC | Reachable only inside that application VPC |
Traffic flows from application VPCs and external networks to forwarding rules in the service access VPC for shared access, so shared deployments depend on correct route advertisements and firewall rules. For high availability virtual private network (HA VPN), the Cloud Router advertises the consumer subnet as a custom route. For serverless access, the VPC Access connector needs a dedicated /28 subnet with ingress rules opened toward the application VPCs. Dedicated access is simpler because traffic stays inside one VPC, but the rule and firewall entries must be repeated in every VPC that needs the service.
Exam tip: Shared access points live in a service access VPC and are reachable broadly, while dedicated access points live in an application VPC and are reachable only inside that VPC.
A regional application stack is a chain of service layers that all run in the same region, such as a web layer calling an application layer calling a database layer. Each layer uses load balancers to spread traffic across endpoints in three or more zones, and each service URL resolves through Domain Name System (DNS) to the regional IP address of its layer load balancer. The same stack pattern is repeated in each region across Google Cloud, other clouds, and on-premises centers.
Repetition enables active-standby resiliency across regions. Out-of-band monitoring watches every layer, and when it reports a failure in any layer, the frontend is re-anchored to the complete backup stack in another region. Automated deployment must keep regional stacks identical, or failover will behave differently from normal operation.
Progressive delivery moves new versions to users in small steps so problems appear before full rollout. Cloud Deploy automates this with a delivery pipeline that holds canary configuration, a release that represents the new container image, and a rollout that moves the release through ordered phases such as canary-50 followed by stable. Traffic flows first to the small canary population and only after approval flows to the stable population. Cloud Deploy skips the canary phase and runs only stable on the very first deployment because there is no prior version for comparison or fallback.
A process flow showing a Cloud Deploy release moving through a rollout into the canary-50 phase, an approval gate, and then the stable phase, with the load balancer splitting traffic between a small canary population and the stable population, plus a note that the very first deployment skips canary and runs stable only.
Load balancing protects availability during rollouts. Traffic flows from the load balancer to backends such as instance groups, Google Kubernetes Engine (GKE) pods, or managed endpoints, and the load balancer depends on health checks to decide where traffic can go. When a check marks a backend unhealthy, the load balancer stops sending it traffic and sends traffic only to healthy resources. Separate production, staging, testing, development, and canary environments plus regional or multi-regional redundancy further isolate validation from live traffic.
API management with Apigee places a proxy layer between client applications and backend services to enforce security, control traffic, and keep public interfaces stable. Traffic flows from clients to the Apigee proxy and then from the proxy to backends, so producers can change hosts, databases, or code without breaking consumers. Policies for authentication, quotas, caching, and mediation execute at the proxy, which shields backends from direct load.
Security and traffic control at the proxy decides who can call and how much load reaches backends. API key validation checks request.queryparam.apikey against an API product, and only valid keys flow to the backend. Quotas cap requests over time to protect against malicious distributed denial-of-service traffic, client errors, and billing spikes. Throttling supports graceful degradation by slowing replicas under policy, dropping excess requests early at the frontend, and monitoring spikes before they escalate. The developer portal supports onboarding by letting client developers discover APIs, read documentation, and register without direct coordination with backend teams.
Mediation and routing control performance and residency. A request follows an ordered path from client to gateway ingress, through distributed policy processing, then to the backend, with the response returning back through the gateway to the client. Because the response traverses the gateway in both directions, a slow or undersized backend directly increases latency and failures. Response caching reduces load by serving repeated reads from the gateway. Global routing uses Layer 7 global external load balancing with automatic failover across regions, while Regional routing restricts balancing to the Apigee instance region for data residency.
Testing frameworks validate reliability, performance, and scalability by simulating real load and checking every change before promotion. Validating autoscaling means measuring successful responses and latency, not just infrastructure size, because virtual machines (VMs) can be in the RUNNING state while application software on them has crashed. Cloud Load Balancing health checks ensure traffic flows only to responsive backends, and for managed instance groups (MIGs) autohealing deletes unavailable VMs and creates replacements. In a 3-tier stack, an internal load balancer carries web-to-app traffic, so tests must stress internal paths as well as external paths.
Environment parity makes test results valid by keeping test and production identical. Infrastructure as Code with tools such as Terraform defines networks and baselines in code, so test environments can be created on demand and torn down after use. Cloud Build runs automated unit, integration, and end-to-end tests on each change, and Cloud Deploy promotes only validated artifacts through ordered targets. The network path must also match production: Premium Tier carries traffic on the Google backbone from the point of presence closest to the sender to the one closest to the destination, while Standard Tier uses the public internet at lower cost.
Data and system migration tooling moves files, warehouses, servers, and delivery processes to Google Cloud with controlled downtime. Large-scale data flows from source staging to Cloud Storage and then from Cloud Storage to BigQuery, where schema and data become queryable tables. The staging order is fixed: first extract schema and data to vendor-neutral files, then upload to a bucket closest to the source, then load to BigQuery. Avro, ORC, and Parquet embed schema with data, while CSV needs separate schema or auto-detection.
| Source and condition | Choice |
|---|---|
| Another cloud to Google Cloud or bucket to bucket | Storage Transfer Service online |
| Private data center with enough bandwidth | gcloud storage for small to medium, Storage Transfer Service for large scale |
| Private data center without enough bandwidth | Transfer Appliance offline by shipping hardware |
BigQuery Data Transfer Service (BigQuery DTS) then loads into BigQuery tables directly or on schedule. Provisioning uses Infrastructure as Code in order: build organization, folder, and project hierarchy, then configure Identity and Access Management (IAM), then billing, then connectivity, then security hardening, then logging and monitoring. Migration execution follows assess, plan in waves of related applications, and repeatable deploy-test-optimize sprints with rollback plans. Migrate to Virtual Machines lifts VMs to Compute Engine, VMware HCX extends VMware to Google Cloud VMware Engine, and Migrate to Containers replatforms servers to GKE and Cloud Run.
Gemini Cloud Assist is an AI collaborator that helps design, troubleshoot, secure, and optimize Google Cloud solutions. Diagnostic and cost data flows from resources and APIs into Gemini Cloud Assist, and guidance flows back as answers, hypotheses, and fixes. It reasons with live context, remembers conversation history, and acts with the same permissions as the requesting user, so incomplete results often mean missing roles such as Cloud Asset Viewer.
Investigations compare current logs, metrics, and performance against baseline behavior. Bigtable investigations analyze cluster performance for a selected cluster and time range using latency, CPU, disk, and request signals, starting from System insights. Managed Service for Apache Spark investigations analyze failed or slow batches using logs and metrics, starting from the Batches List or Batch Details page. Results separate observations from ranked hypotheses with recommended actions. Cost and architecture help includes chat-based optimization, FinOps Hub summaries, anomaly analysis, rightsizing, and flow analysis, powered by APIs for assets, monitoring, logging, and topology.
Interacting with Google Cloud programmatically means using shells, CLIs, libraries, emulators, and declarative files instead of manual console steps. The same code and configuration moves from local development to automated pipelines to production runtimes. The sections below show how interactive shells, command-line tools, local emulators, Infrastructure as Code, and API access connect.
Cloud Shell is a browser-based shell and editor for managing and deploying cloud-native applications without local setup. Cloud Shell runs on a temporary VM that terminates after 40 minutes of inactivity, and the session can disconnect after about 20 minutes. Only files under $HOME flow to a free 5 GB per-user persistent disk shared across projects, while any change outside $HOME stays on the ephemeral VM disk and is lost on termination.
Starting a new session provisions a fresh VM and reattaches the existing home directory, so scripts and files like .bashrc survive while system state resets. Default persistent mode keeps $HOME files but takes up to 25 seconds on first connect, while ephemeral mode connects faster but loses all files on exit. A no space left on device error means the 5 GB limit is full. Resetting requires inspecting $HOME, running sudo rm -rf $HOME, then choosing Restart from the menu.
Exam tip: Files inside $HOME persist between sessions, while any modification outside $HOME is lost when the VM terminates after 40 minutes of inactivity.
Secure connectivity from Cloud Shell is an authenticated tunnel that reaches a private VM without giving that VM a public address. Traffic flows from the Cloud Shell client through Identity-Aware Proxy (IAP) to the internal IP address of the destination VM, so IAP sits in the middle as the identity and trust boundary. The one-step command gcloud compute ssh VM-NAME --tunnel-through-iap creates both the tunnel and the SSH session, and this path is chosen when the target has only an internal IP.
Reusable access extends the same IAP path to local tools such as VS Code and OpenSSH. Setup follows an ordered workflow: first generate keys with gcloud compute ssh --tunnel-through-iap and verify, then open the local SSH config, then append a Host block whose ProxyCommand runs gcloud compute start-iap-tunnel, then connect with ssh VM_NAME so traffic flows from the local client through IAP to the VM. The host entry must name the VM name, key path, project ID, zone, and username.
Cloud-native development with Cloud Code is the in-editor workflow for building container images and deploying to GKE or Cloud Run. Cloud Code works in Cloud Shell Editor, Visual Studio Code, and supported JetBrains IDEs, and it supports Go, Java, Node.js, Python, and .NET Core. Cloud Code builds source into an image, pushes that image to a registry such as Artifact Registry, and then traffic flows from the registry image to the running workload.
GKE development starts from a template with app code, Deployment and Service YAML, and skaffold.yaml, created through Cloud Code: New Application by type, language, and location. Run on Kubernetes enables watch mode where saved changes trigger automatic rebuild and redeploy, while the Kubernetes view shows Namespaces, Services, and External IPs. Cloud Run development adds local debugging in the built-in emulator with progress in Cloud Run Explorer, but production changes should use automated CI/CD rather than editor deploy.
The Google Cloud CLI is the command-line toolchain for creating and automating resources, including gcloud for administration, gcloud storage and gsutil for Cloud Storage, and bq for BigQuery. gcloud storage is the recommended tool with automatic parallel processing and current features, while gsutil is legacy, minimally maintained, and will no longer ship with the CLI after March 2027. At least one side of a gcloud storage transfer must be a gs:// URI, so local-to-local copies are not allowed.
Core configuration is a named collection of properties for project and identity. A typical setup runs in order: first update with gcloud components update, then run gcloud init to sign in and pick defaults, then set the project, then verify with gcloud config list and gcloud info. User authorization with gcloud init fits single-operator work, while service-account authorization with gcloud auth activate-service-account fits automation. Script output flows from the API response through --filter to --format such as json or table, with --quiet suppressing prompts. Parallel execution of multiple gcloud commands is not supported, so automated calls must run sequentially.
BigQuery orchestration chains loading, transformation, and reporting so event and scheduled jobs run in order. Event-driven scheduling starts work when state changes, such as a file landing in Cloud Storage, while time-driven scheduling starts work on a clock, such as daily loads. Both can combine, for example by loading in real time but reporting daily.
| Tool | Focus | User profile |
|---|---|---|
| Dataform | Data transformation with SQL and JavaScript | Data analyst or administrator |
| Workflows | Microservices with YAML or JSON | Data architect |
| Managed Service for Apache Airflow | ETL or ELT with Python | Data engineer |
| Vertex AI Pipelines | Machine learning with Python | Data analyst |
Jobs can be submitted in the console, with bq query, with REST methods, or with client libraries. Scheduled queries suit straightforward, time-driven GoogleSQL chains with no external dependencies. Choose Dataform, Workflows, Managed Airflow, or Vertex AI Pipelines when the workload combines services or runs parallel jobs.
Local emulators are localhost simulations that let applications be tested without creating cloud resources or touching production. The SDK provides emulators for Bigtable, Datastore in Firestore in Datastore mode, Firestore, Pub/Sub, and Spanner. Traffic flows from the application through the same Cloud Client Libraries to either the local endpoint or the production API, depending on environment configuration.
| Emulator | Local endpoint | Environment variable |
|---|---|---|
| Bigtable emulator | localhost:8086 | BIGTABLE_EMULATOR_HOST=localhost:8086 |
| Pub/Sub emulator | Port 8085 | PUBSUB_EMULATOR_HOST |
| Spanner emulator | localhost:9010 for gRPC, localhost:9020 for REST | SPANNER_EMULATOR_HOST=localhost:9010 |
Emulators remove production controls for identity, durability, and scale. The Bigtable emulator works with client libraries for tables and reads and writes, but it provides no admin APIs, accepts any project and instance name, supports no secure connection, and keeps data only in memory so restart returns it to an empty state. A passing local test therefore proves logic but does not prove IAM roles, network security, durability, or throughput. Variables must be set on the application machine and unset after stopping so later calls return to production.
Infrastructure as Code (IaC) declares infrastructure in versioned files so development, test, and production stay consistent. Terraform describes desired end state, compares state to real resources, previews differences, and actuates changes. Infrastructure Manager is the managed Google Cloud service that deploys Terraform configurations, called blueprints, without a separate toolchain.
The execution lifecycle runs in fixed order: terraform init to initialize providers, then terraform validate to check syntax, then terraform plan to generate a reviewable plan, then terraform apply to create or update through APIs, or terraform destroy to delete. The Terraform state file is the JSON mapping of last-known infrastructure, so Terraform creates what is missing, updates what differs, and leaves what matches unchanged. Reuse uses modules, where a root module provisions tested resources together and input variables customize the same module for each environment. A GitOps promotion runs plan on a feature branch without applying, applies on merge to dev, then merges dev to prod after testing.
State management chooses where shared state lives. A Cloud Storage backend with Cloud Build shares state for GitOps automation, Infrastructure Manager stores state per deployment and revision for managed history, and Terraform Cloud stores state remotely for full change management. Infrastructure Manager blueprints must include a valid root module and should not define backend blocks, and sensitive values must not be placed in configuration.
Secure and efficient API access combines private paths, perimeter controls, fast interfaces, and correct authentication. Private Google Access is a subnet feature that lets VMs with only private IPs reach Google APIs while staying within Google's network, and Private Service Connect endpoints provide an alternative private path. VPC Service Controls creates a logical perimeter around projects and services to block data movement outside authorized boundaries. Every request passes ordered checks from the Google Front End through authentication, IAM, quota, billing, logging, and perimeter checks before reaching backends, so a request from outside the perimeter is denied even with valid credentials.
Application Default Credentials (ADC) lets client libraries discover credentials automatically. The flow runs from workload code to the client library to ADC to the configured source, then to the API. The same code uses user credentials locally after gcloud auth application-default login and uses the attached service account on Google Cloud, with no key file in code. Cloud Client Libraries are the recommended idiomatic suite, while Google API Client Libraries provide broader coverage or Discovery-built clients when no idiomatic package exists. For reliability, reuse one session client so the access token, typically valid for one hour, is shared, pin library versions, and monitor with the API Dashboard and Cloud Monitoring. Service-account impersonation lets a caller with Token Creator permission act temporarily as a service account without downloading keys.
Continue with this study guide: Interacting with Google Cloud programmatically
$HOME persist on the 5 GB disk.terraform init, then terraform validate, then terraform plan, then terraform apply, with state stored as a shared JSON mapping.gcloud commands.Shared consumer access points live in a service access VPC and are reachable from any other VPC or external network, while dedicated consumer access points live in an application VPC and are reachable only inside that VPC. A VPC that holds both application resources and shared access points must be treated as a service access VPC because transitive routing changes its firewall duties. Shared deployments depend on correct route advertisements and firewall rules, while dedicated access entries must be repeated in every VPC that needs the service.
Cloud Deploy runs only the stable phase on the very first deployment to a runtime. There is no prior version for comparison or fallback, so traffic flows directly to the stable population instead of moving first through canary phases such as canary-50. Later releases move through ordered canary and stable phases, with traffic flowing first to the small canary population and only after approval to the stable population.
Cloud Shell runs on a temporary virtual machine (VM) that terminates after 40 minutes of inactivity. Only files under $HOME persist on the free 5 GB per-user persistent disk shared across projects, while any change outside $HOME is lost on termination. Starting a new session provisions a fresh VM and reattaches the existing home directory, so scripts and files survive while system state resets.
The Terraform execution order is terraform init to initialize providers, then terraform validate to check syntax, then terraform plan to generate a reviewable plan, then terraform apply to create or update through APIs. Terraform compares desired end state to real resources using a JSON state file mapping of last-known infrastructure, creating what is missing, updating what differs, and leaving what matches unchanged.
Last updated