Prepare and test your skills
Prepare and test your skills
Zonal and regional block storage allocation is the choice of where disk data lives and how it survives a zone outage. Persistent Disk (opens in a new tab) is durable network storage that stays independent from a virtual machine (VM), so it can be detached, reattached, and kept after the VM is deleted. A zonal disk stores data in one zone with built-in redundancy against equipment failure, while Regional Persistent Disk (opens in a new tab) replicates every write synchronously across two zones in the same region. If the primary zone fails, a backup VM in the surviving zone can force-attach the regional disk and continue serving data with near-zero recovery point objective (RPO).
A primary VM in Zone A attaches to a Regional Persistent Disk replica while a backup VM in Zone B can force-attach the second replica after a zone outage; every write is synchronously replicated between the two zone replicas, and snapshots are stored in Cloud Storage for cross-region recovery.
| Option | Replication scope | Behavior during zone outage |
|---|---|---|
| Zonal Persistent Disk | Data stored in one zone | Disk is unavailable; restore from snapshot or backup |
| Regional Persistent Disk | Writes replicated synchronously between two zones | Backup VM can force-attach the disk in surviving zone |
| Hyperdisk Balanced High Availability | Data replicated synchronously between two zones | Volume remains available during single-zone outage |
Exam tip: Regional Persistent Disk protects against a zone outage by synchronous replication between two zones, while snapshots protect against data loss and region outage by storing a copy that can be copied across regions.
Hyperdisk performance tuning is the ability to set speed separately from size for Compute Engine workloads. Google Cloud Hyperdisk (opens in a new tab) provides higher performance and flexibility than Persistent Disk, and Hyperdisk Balanced lets input/output operations per second (IOPS) and throughput be provisioned separately and changed dynamically. One volume can therefore be tuned for transaction-heavy, throughput-heavy, or mixed work, while Hyperdisk Balanced High Availability adds synchronous replication between two zones for zone-level resilience. Hyperdisk Storage Pools share pre-provisioned capacity, throughput, and IOPS across many volumes and use thin provisioning and deduplication to lower cost. The pool tries to add capacity automatically to keep utilization at or below 80% of provisioned capacity, so uneven demand across volumes does not cause outages.
Local SSDs, snapshots, and database provisioning divide storage by durability, speed, and recovery needs. Local SSDs are physically attached drives that give high throughput to a single VM, but data lasts only until the instance is stopped or deleted. Choose Local SSDs for temporary caches and scratch data that can be rebuilt, and choose Persistent Disk or Hyperdisk for data that must survive VM deletion or host failure. Snapshots (opens in a new tab) capture point-in-time copies of Persistent Disk volumes, are incremental by default, can be taken from running instances, and can be copied across regions for disaster recovery.
Provisioning for databases adds protection settings that are configured together with performance. With Hyperdisk Balanced, an administrator can raise IOPS for transaction spikes or raise throughput for scans without enlarging disk size, but requests can fail if provisioned capacity is exceeded. Peer settings include deployment region and zone, disk type and size, synchronous replication inside a region or asynchronous replication across regions, encryption keys, and snapshot schedules. Availability as data grows comes from the same replication pattern: Spanner multi-region configurations replicate across zones and regions, AlloyDB for PostgreSQL uses automatic failover between two zones, and Cloud Storage regional buckets replicate synchronously across zones.
Cloud Storage allocation is the combined choice of bucket location for availability and storage class for cost. Cloud Storage (opens in a new tab) regional buckets replicate data synchronously across multiple zones in one region, so they survive a zone outage but not a region outage. Dual-region and multi-region buckets store data in at least two geographic locations, where metadata is written synchronously and object data is replicated asynchronously, and turbo replication on dual-region buckets tightens that copy to a 15-minute RPO. Regional buckets cost less and help meet residency rules, while dual-region or multi-region buckets protect backups against region loss at higher storage and transfer cost.
Storage class and lifecycle rules control cost as access cools:
Object lifecycle management moves objects from Standard to Nearline, Coldline, or Archive as they age, while Soft Delete preserves deleted objects for a period and Object holds block deletion.
Continue with this study guide: Data storage allocation
Managed data processing services run batch and streaming work without managing servers or clusters. Managed Service for Apache Spark (opens in a new tab) runs Apache Hadoop and Apache Spark jobs on ephemeral clusters that exist only for the workload, which preserves existing APIs, libraries, and connectors. Data flows from on-premises or Hadoop sources through Spark transforms into sinks such as Cloud Storage and BigQuery. Hive warehouse data can use Cloud Storage by setting hive.metastore.warehouse.dir to a bucket, and Sqoop output can move with DistCp or the Cloud Storage connector.
Dataflow runs unified batch and streaming pipelines written with Apache Beam. A pipeline is a directed acyclic graph where immutable collections called PCollections flow from a source through PTransforms into a sink, and each PTransform uses a DoFn that acts on one element at a time. The Dataflow runner distributes that graph to parallel workers and autoscales as data moves through stages. A typical highly parallel workflow runs in order: first ingest raw bounded or unbounded data, then pre-process it into usable encoding, then distribute calculations to many workers, then post-analyze results into final output. Choose Managed Service for Apache Spark when the workload must stay on Hadoop, Spark, HiveQL, or Sqoop, and choose Dataflow when the workload can use Beam for unified batch and streaming.
Dataflow storage integration connects workers to services that absorb high-concurrency reads and large fan-out writes. Data flows from the source service through Beam transforms on Dataflow workers to the destination service, and large driving elements are passed by Cloud Storage uniform resource identifier (URI) rather than embedded in the PCollection. Pub/Sub feeds streaming ingest, Bigtable serves low-latency key-value lookups inside processing, Cloud Storage holds binaries and staging files, and BigQuery serves as batch source and analytical sink. Small driving elements travel directly in the PCollection, while gigabyte-scale elements stay in Cloud Storage with only the URI passed.
BigQuery reads and writes carry quota tradeoffs that affect pipeline design:
| Method | How data flows | Quota and timing effect |
|---|---|---|
| EXPORT | BigQuery writes table data to temporary Cloud Storage, then pipeline reads it | Consumes export quotas and adds run time |
| DIRECT_READ | Pipeline reads rows directly through BigQuery Storage API over gRPC | Avoids export quotas and can decrease run time |
Batch writes with load jobs consume table- and project-level load quotas, while streaming pipelines use streaming inserts or the Storage Write API for near real-time appends. Reads from Cloud Storage with TextIO or AvroIO gain parallelism because separate files are read by separate workers.
Resource optimization matches machine shape, purchase model, and scaling to actual workload needs. Compute Engine (opens in a new tab) analyzes VM utilization to recommend a better machine type, and custom machine types let CPU cores be provisioned independently of memory to avoid paying for unneeded cores or licenses. Spot VMs are excess capacity sold at discounts up to 91% on vCPUs, memory, graphics processing units (GPUs), and Local SSDs, with the same performance as standard VMs but with preemption at any time. On preemption, Compute Engine either stops the VM by default or deletes it, so Spot VMs fit fault-tolerant batch, analytics, simulation, and encoding work.
Assured capacity uses different models for time-bound and critical work. Flex-start requests densely packed GPUs for up to seven days through managed instance group resize, with discounts up to 53% on A4, A3, A2, and G4 series. On-demand standard VMs start immediately and run until stopped, while standard reservations hold zonal VMs with very high assurance for the reservation period and can attach committed use discounts. Future reservations and Dynamic Workload Scheduler queue future GPU needs to avoid stock-outs without holding idle reservations.
| Model | Choose when | Capacity behavior |
|---|---|---|
| Spot VMs | Fault-tolerant batch work | Best-effort, can be preempted at any time |
| Flex-start | Dense GPUs needed up to 7 days | Best-effort request, densely packed once granted |
| On-demand VMs | Immediate start with no fixed duration | Best-effort based on zone capacity |
| Standard reservations | Critical production cannot stock out | Very high assurance, exclusive reserved VMs |
Exam tip: Use Spot VMs for batch jobs that tolerate preemption with no service level agreement (SLA), and use standard reservations for critical workloads that require very high capacity assurance.
Compute selection matches control, orchestration, and scaling needs to the right environment. Compute Engine is Infrastructure as a Service for configurable VM and bare metal instances where the user manages the guest operating system while Google manages virtualization, servers, storage, and networking. Google Kubernetes Engine (GKE) (opens in a new tab) is the managed Kubernetes environment where Google manages the control plane and the user deploys containers, with Autopilot managing nodes automatically and Standard leaving node pools to the user. Cloud Run is fully managed serverless containers that scale on requests or CPU without managing servers, while Batch schedules queued asynchronous jobs on provisioned Compute Engine resources without managing VMs directly.
| Compute option | OS control | Scaling trigger |
|---|---|---|
| Compute Engine | Self-managed | Manual or automatic with managed instance groups |
| Google Kubernetes Engine (GKE) | Google-managed in Autopilot | Automatic pod and node scaling |
| Cloud Run | Google-managed | Automatic on requests or CPU |
| Batch | Google-managed | Automatic on queued jobs |
Only stateless managed instance groups support autoscaling, because stateful groups must preserve persistent disks during repair. Choose Compute Engine for full operating system control, GKE for container orchestration, Cloud Run for event-driven serving, and Batch for large jobs that run to completion.
Continue with this study guide: Data processing and compute provisioning
Data encryption and key management controls how data at rest is protected and who controls the unlock keys. Google default encryption uses Google-owned keys with no customer action, while Customer-managed encryption keys (CMEK) (opens in a new tab) are customer-controlled key encryption keys in Cloud Key Management Service (Cloud KMS) used through envelope encryption. The storage service calls Cloud KMS to encrypt and decrypt its data keys, so the customer key never leaves Cloud KMS but still governs access. Control covers protection level with software, hardware security module, or external keys, key location matching data residency, rotation schedules, Identity and Access Management (IAM) permissions, audit dashboards, and lifecycle actions to disable or destroy versions.
Configuring CMEK links a key to the resource and authorizes the service to use it. The key ring and key must be in the same location as the data, even if in a different project, and the storage service depends on its Google-managed service account holding the CryptoKey Encrypter/Decrypter role or requests fail. A typical order is first create the key ring and key, then identify the service account, then grant encrypt and decrypt access, then assign admin rights to the configurator, then attach the key ID when creating the resource, then verify completion. Some services require CMEK at creation and do not allow adding it later or reverting to Google default encryption. Disabling or destroying the active key blocks access within minutes to hours, and data is automatically deleted if the key stays unavailable for more than 30 days.
Exam tip: A disabled or destroyed CMEK key blocks data access first and causes permanent loss after 30 days — restore the key or its permissions within that window to recover access.
Network security perimeters and temporary access keep private services from sending data to untrusted places. VPC Service Controls (opens in a new tab) creates a service perimeter around projects and explicitly restricted services, so resources inside can communicate but API calls that copy data outside are denied. The boundary applies to all user and service account identities, which limits exfiltration even if credentials are compromised. Changes can take up to 30 minutes to propagate and may return Error 403 during that window.
| Control | What it protects | Which identities it checks |
|---|---|---|
| Chrome Enterprise Premium | User API traffic against per-request conditions | User identities only |
| VPC Service Controls | Resources and data inside perimeter | All user and service account identities |
A perimeter is built by first selecting protected projects, then creating the perimeter, then adding instances, then adding restricted APIs such as Compute Engine, Cloud Storage, Cloud KMS, and analytics APIs in the same boundary. Access levels permit limited outside-to-inside requests that meet conditions such as IP or certificate rules. Traffic from inside to outside cannot be authorized by an access level and remains blocked, so exports to outside buckets still fail. The perimeter enforces the network boundary while IAM still governs who can act inside, so both the perimeter admin role and data-level IAM roles are required.
Identity and Access Management (IAM) controls who can create, view, edit, or delete storage resources. Every API request requires the calling principal to have the required permission, where a principal can be a user, group, or service account. An IAM policy binds a principal, a role, and a resource together, and permissions are never granted directly but only through a role. Project-level bindings apply by default to all instances in the project, while instance- and repository-level bindings narrow scope.
Least privilege means granting only needed roles at the smallest scope:
roles/storage.admin grants full control of buckets and objects.roles/storage.objectAdmin grants full control of objects without bucket management.roles/storage.objectCreator allows creating objects without viewing or deleting them.roles/storage.objectViewer allows read-only viewing of objects.roles/cloudsql.admin, roles/cloudsql.editor, roles/cloudsql.client, roles/cloudsql.instanceUser, and roles/cloudsql.viewer separate database administration, connection, and read-only work.Centralized management grants roles once to a Cloud Identity (opens in a new tab) group, so adding a user grants login and data privileges and removing the user revokes them, while each user still authenticates individually for audit. Cloud SQL supports built-in password authentication plus IAM authentication with short-lived tokens and required SSL, where group authentication automatically grants login through group membership without updating each account.
Continue with this study guide: Security and access management
Data migration tool selection chooses how to move data into Cloud Storage without changing it. Storage Transfer Service (opens in a new tab) handles online transfers over the network, the gcloud storage command handles small online uploads, and Transfer Appliance handles offline moves with shipped hardware. Online transfer flows from the source over Cloud Interconnect or the internet to a bucket, while offline transfer flows from the data center to the appliance and then after shipping from the appliance to Cloud Storage. Transfer time grows with dataset size, shrinks with bandwidth, and includes planning and retry overhead.
| Transfer scenario | Size or bandwidth condition | Recommendation |
|---|---|---|
| Another cloud to Cloud Storage | Any size | Storage Transfer Service |
| Bucket to bucket | More than 1 TB | Storage Transfer Service |
| On-premises to Cloud Storage | Less than 1 TB | gcloud storage command |
| On-premises to Cloud Storage | More than 1 TB with enough bandwidth | Storage Transfer Service for on-premises |
| On-premises to Cloud Storage | More than 1 TB without enough bandwidth | Transfer Appliance |
The gcloud storage command fits interactive work, a few files, streaming program output, or syncing a moderate directory, but large objects are more likely to fail. Storage Transfer Service automates cloud and bucket transfers without scripts, uses seed plus sync copies to avoid downtime, and does not lock reads or writes. For on-premises Network File System data, Docker-based agents in a pool move data in parallel, and more agents increase speed when bandwidth allows. Transfer Appliance fits remote sites or deadlines where 100 TB over 1 Gbps takes over 10 days online but over 100 Mbps takes over 100 days, while 300 TB can be captured in under 25 days plus about 10 business days before access.
Performance tuning for high-throughput transfers finds whether a job is limited by request rate or network bandwidth. Jobs with billions of small files are typically QPS-bound by per-object request rate, while jobs with large objects are bandwidth-bound by network throughput fairly shared at the region level. When source and destination share location, storage class, and encryption key, the service creates a new metadata entry pointing to source data instead of copying bytes, so the copy completes very quickly. Storage Transfer Service can complete around 1000 tasks per transfer job per second when bandwidth allows.
Splitting a transfer divides one large job into multiple smaller jobs that run at the same time. Each job adds its own task throughput, so combined jobs can exceed the single-job limit when bandwidth allows, using include and exclude prefixes to divide files. This helps most for QPS-bound work with many small files, and transfers are incremental by default so follow-ups move only changes. Estimation should include dataset size, available bandwidth, management time, and bandwidth efficiency, where 1 GB ideally takes eight seconds over 1 Gbps. The interval between jobs must not exceed the RPO, Pub/Sub notifications track completion, and the service provides no SLA for transfer speed.
Exam tip: Use gcloud for transfers of less than 1 TB between Cloud Storage buckets, and use Storage Transfer Service for transfers of more than 1 TB.
Network latency and regional placement place data close to compute and route traffic over the fastest path. Total latency sums four segments: last-mile from device to internet service provider, Google frontend and edge point of presence (POP) where sessions terminate and cache serves, Compute Engine region latency from edge to region over Google's network, and app processing time in the region. Architects can optimize app time and region distance but cannot control last-mile or distance to the edge. Region choice matters most for wired users and less when slow 3G last-mile dominates.
Network Service Tiers controls the path between the internet and Google Cloud. Premium Tier (opens in a new tab) is the default performance tier over Google's global fiber with over 200 POPs, where inbound enters at the POP closest to the user and outbound exits closest to the destination. Standard Tier is cost-optimized over transit internet service providers, where traffic enters near the resource region and exits near the sending region. Premium Tier supports global IPs and multi-region backends, while Standard Tier uses regional IPs and requires a bucket backend to match the load balancer forwarding rule region.
Common patterns trade latency against complexity: single region for simplicity with a second region only for backup, distributed frontends with a single backend when caching absorbs requests, fully distributed frontends and backends for lowest latency with global replication such as Spanner, and parallel apps for separate user groups. Co-locating buckets and VMs in the same region keeps reads on the internal network, and adding global load balancing with Cloud CDN serves repeats from the edge.
Continue with this study guide: Configuration for data transfer and latency
Analytical expiration controls how long data stays queryable and how recoverable copies are kept. BigQuery (opens in a new tab) partition expiration deletes aging partitions independently from each partition boundary in UTC, such as daily partitions expiring at 06:00 UTC the next day for a 6-hour setting. A dataset default can set expiration, a table setting overrides it, and integer-range partitioned tables do not support partition expiration. Table expiration deletes the entire table and all partitions and takes precedence, so a 5-day table expiration wins over a 7-day partition expiration. Partition expiration can be updated anytime, older partitions expire immediately, and deletion after marking is not instant.
Automated backup at scale creates recurrent copies by snapshot inside BigQuery or export to Cloud Storage. Each table gets a table-level policy or a fallback policy, with retries through Pub/Sub and spreading across projects to avoid concurrency limits. Work flows in order: first Cloud Scheduler triggers a dispatcher on Cloud Run, then the dispatcher lists tables and fans out one message per table, then a configurator selects the policy, then a snapshot or export service runs the backup, then logging and a tagger track completion in metadata.
Exam tip: Table expiration wins over partition expiration, and integer-range partitioned tables cannot use partition expiration at all.
Bigtable backup retention keeps schema and data copies for recovery without unbounded growth. Cloud Bigtable backups can be daily automated, on-demand from console or gcloud, or copies of existing backups, and they are incremental so a backup is never larger than its source table. Up to 150 backups can exist per table per cluster, and backup storage does not count toward node limits. Automated backup defaults to seven days and policies can keep backups up to 90 days, while on-demand backups can be kept up to 90 days in Enterprise or 365 days in Enterprise Plus, and copies up to 30 days. A cluster with backups or a backup policy cannot be deleted until backups expire or the policy changes.
| Backup type | Optimized for | Restore behavior |
|---|---|---|
| Standard backup | Long-term retention | Restore to SSD needs extra optimization |
| Hot backup | Low-latency recovery | Most efficient restoration to production performance |
Compliance governance defines what can be stored and where copies rest. Secret Manager carries assessments including Criminal Justice Information Services (CJIS), FedRAMP Moderate and High, Health Insurance Portability and Accountability Act (HIPAA), and General Data Protection Regulation (GDPR). BigQuery Lakehouse caching pulls remote blocks over the internet into the target Google Cloud region, so European Union source data queried with US compute creates a US data-at-rest copy that the connection owner must govern. Lakehouse cache uses Google-managed keys only, so enforcing constraints/gcp.restrictNonCmekServices disables caching while queries still succeed. Service account key governance limits creation, upload, and lifetime with constraints for disabling keys and setting expiry in hours.
Cloud Storage lifecycle implementation automates movement and deletion when objects meet conditions. Object Lifecycle Management (OLM) configuration lives on the bucket, the service evaluates each object, and only after all conditions are met does it apply the transition or delete action. Storage class transitions lower cost without leaving the chosen location boundary, moving data from Standard to Nearline, Coldline, or Archive as access drops. Locked retention policies enforce compliance: Bucket Lock applies one minimum duration to every object, Object Retention Lock sets an individual retain-until time, and Object holds block deletion with metadata flags. Once locked, the period cannot be shortened even by the owner.
| Use case | Method | Recommended tool |
|---|---|---|
| Delete one or few objects | Single-object deletion | Console, gcloud storage rm, libraries, or REST APIs |
| Delete up to 1,000 objects in one request | Bulk deletion | Multi-object delete XML API |
| Delete objects sharing a prefix | Bulk deletion | gcloud storage rm --recursive |
| Delete automatically on age or class | Bulk deletion | Object Lifecycle Management |
Object Versioning preserves an overwritten live object as a noncurrent version, so lifecycle rules must handle both live and noncurrent states. Soft delete guards against accidental deletion and Cloud Asset Inventory tracks bucket changes for audit.
Continue with this study guide: Data retention and data lifecycle management
Storage scalability is the ability to handle growing volume and speed without loss of performance. BigQuery (opens in a new tab) separates analytical storage in Colossus from query execution in Dremel, storing compressed columnar Capacitor data while slots bundling CPU and RAM execute queries. Storage grows as data is consumed and shrinks when tables are dropped, so dozens of petabytes can be stored, while projects are limited by default to 2,000 slots under on-demand pricing. Bigtable production instances require at least two clusters in unique zones with automatic replication, and traffic can fail over to another cluster in the same instance. Spanner throughput depends on configured compute nodes, with consistent backups up to 1 year, point-in-time recovery up to 7 days, and commit timestamps for incremental selection.
Block, file, and object ceilings determine when re-architecture is needed:
| Service | Capacity limit | Scaling behavior |
|---|---|---|
| Persistent Disk | 10 GiB to 64 TiB per disk, up to 257 TiB per VM | Scale up, add disks, autoscale |
| Google Cloud Hyperdisk | 4 GiB to 64 TiB per disk, up to 512 TiB per VM, 10 TiB to 1 PiB per pool | Scale up with dynamic resizing |
| Local SSD | 375 GiB per disk, up to 12 TiB per VM | Not scalable, fixed at creation |
Filestore provides 1 TiB to 100 TiB per instance, Managed Lustre provides 18 TiB to 80 PiB for parallel AI, and NetApp Volumes provides 1 TiB to 10 PiB per pool. Cloud Storage (opens in a new tab) has no lower or upper limit and scales automatically, which fits unpredictable growth, static content, backups, and data lakes.
Exam tip: Cloud Storage scales automatically with no capacity limit, while Local SSD is fixed at creation and cannot be scaled.
Data lifecycle and tiering keeps fresh data in fast storage while aging data moves to cheaper tiers. BigQuery partitioning divides large tables by date, timestamp, or integer column so queries scan only matching partitions, and clustering on up to four columns sorts data inside partitions to skip blocks. For an append-only orders table, backup or export needs only the current plus recently changeable partitions, such as the last 7 days when returns allow updates. Reclustering is automatic without using slots, so maintenance does not compete with queries.
Cloud Storage classes store BigQuery exports cheaper as access drops, with Autoclass moving objects automatically when patterns are unknown and explicit classes plus lifecycle deletion when patterns are known. Standard fits frequent analytics, Nearline fits 30-day backups, Coldline fits 90-day recovery copies, and Archive fits 365-day regulatory archives, with Parquet and ORC adding compression and engine compatibility. A date-partitioned backup runs in order: first copy required partitions to a new table, then run the export job to a bucket, then transfer files to the backup location, then apply the lifecycle rule to transition and delete. Logical billing charges uncompressed size by default while Physical billing charges compressed size, and shortening time travel lowers physical cost.
Capacity planning sizes storage, memory, and compute for current plus future growth and expands before limits hit. The workload baseline covers data volume plus indexes, Write-Ahead Log, backups, and growth, transaction rate of reads and writes, concurrency of users, and acceptable response times. AlloyDB Omni sizing starts from source CPU, RAM, and disk and reduces only after testing, with 8 GB RAM per vCPU and storage type matched to performance. Cloud Monitoring trends then drive additions of disk, memory, vCPU, shards, or replicas.
Cloud SQL needs at least 20% free space for maintenance, fewer than 10,000 tables to limit upgrade time, and enough room for log retention, where 4 TB or larger disks and higher vCPU raise throughput and IOPS. Growth controls set autogrow in megabytes, manage growth before thresholds, and enable automatic storage increases. Relief flows in order: first scale up disk, vCPU, and RAM, then defragment indexes and update statistics, then tune queries, then scale reads to replicas, then re-architect with partitioning or sharding. Memorystore for Redis Cluster (opens in a new tab) scales on memory thresholds of 65% for very high write loads and 85% for moderately high loads, with 1.5 times used memory required for lossless scale-down and up to five replicas protecting CPU during zone loss. Omni persistent nodes require durable ext4 or xfs disks sized at twice data size, with Spanner Omni needing 500 GB, 500 IOPS, and 30 MB per second per vCPU.
Continue with this study guide: Data growth planning
Disaster recovery planning designs storage to resume within a Recovery Time Objective (RTO) and lose no more than a Recovery Point Objective (RPO). RTO is maximum acceptable time to restore service, while RPO is maximum acceptable data loss in time. Live replication across zones or regions keeps a current second copy for fast failover with low RPO, while backups protect against corruption and deletion but define longer RTO for restore. Transfer speed, change rate, and restore method must be sized and tested to those targets.
Cloud Storage (opens in a new tab) dual-region and multi-region buckets store objects in at least two places for 99.99% availability during large disruptions. Standard replication is asynchronous with no promised completion time, so stricter RPO needs stronger controls. Turbo replication on dual-region buckets replicates 100% of new objects within 15 minutes for a 15-minute RPO, while cross-bucket replication copies to a separate bucket in another location. Dual-write to two single-region buckets or copy after write provides proof when locality allows only one Google Cloud region for primary data.
Exam tip: Standard dual-region storage replicates asynchronously with no fixed RPO, while Turbo replication guarantees a 15-minute RPO; use Turbo replication or dual-write to two single-region buckets when a strict RPO must be proven.
Persistent Disk and managed database protection creates restorable copies for deletion, corruption, or regional outages. Backup and DR Service moves data from Compute Engine VM to Persistent Disk snapshot to Cloud Storage bucket, where centralized monitoring and ransomware insights support compliance. Snapshots provide consistent restore points without keeping recovery data on the failed disk, which fits fleets needing central management over one-off snapshots. Cloud SQL protection requires automated backups plus binary logging, then recovery replays logs onto a fresh instance that applications must be pointed to after restore.
| Service | Backup retention | Restore behavior |
|---|---|---|
| Cloud SQL | Automated backups plus binary logs | Restores to a fresh instance |
| Spanner | Consistent backups up to 1 year | Mounts backup without copying data |
| Firestore in Datastore mode | Scheduled backups up to 14 weeks | Restores to a new database in same project |
High availability configuration handles zonal failure for Cloud SQL, cross-region replicas handle regional failure, and Enterprise Plus advanced disaster recovery enables zero data loss failover and fallback. Firestore and Spanner support point-in-time recovery up to 7 days, where Firestore can read at 1-minute granularity with RTO of 0 and RPO of 1 minute for surgical write-back. Validation proves the path by restoring to new databases, cloning for tests, and running trial failovers to confirm reconnects.
Cloud Storage resiliency and compliance keeps objects durable, available, and immutable when required. Durability reaches at least 99.999999999% through erasure coding, redundant pieces, and checksum revalidation regardless of class. Regional buckets store redundantly in at least two zones and confirm writes only after redundant storage, so they tolerate one zone loss. Dual-region and multi-region buckets store in at least two geographic places and stay available during region loss, where dual-regions use a chosen pair and multi-regions use centers at least 100 miles apart.
Recovery from deletion moves objects through ordered states. First an application overwrites or deletes a live object, then Object Versioning converts it to a noncurrent version while soft delete holds deleted objects in a soft-deleted state for seven days by default. Only after retention expires or explicit removal is data permanently gone, while Object holds block deletion with metadata flags. Retention for compliance uses Bucket Lock (opens in a new tab) for one minimum duration on every object and Object Retention Lock for individual retain-until times, both unchangeable once locked. Lifecycle Management and Autoclass then move Standard to Nearline for 30-day data, Coldline for 90-day data, and Archive for 365-day data, or expire noncurrent versions.
Continue with this study guide: Data protection (e.g., backup and recovery)
Zonal Persistent Disk stores data in one zone and becomes unavailable during a zone outage, requiring restore from a snapshot or backup. Regional Persistent Disk replicates every write synchronously across two zones in the same region, so a backup virtual machine (VM) in the surviving zone can force-attach the disk and continue serving data with near-zero Recovery Point Objective (RPO).
Local SSDs should be used for temporary caches and scratch data that can be rebuilt because they are physically attached drives that give high throughput to a single virtual machine (VM) but data lasts only until the instance is stopped or deleted. Persistent Disk or Google Cloud Hyperdisk should be used for data that must survive VM deletion or host failure.
The gcloud storage command handles small online uploads under 1 TB, Storage Transfer Service handles online transfers over 1 TB, and Transfer Appliance handles offline moves with shipped hardware. For on-premises moves over 1 TB, choose Storage Transfer Service for on-premises when there is enough bandwidth and Transfer Appliance when there is not enough bandwidth.
Cloud Storage regional buckets replicate data synchronously across multiple zones in one region, so they survive a zone outage but not a region outage, while dual-region and multi-region buckets store data in at least two geographic locations to protect against region loss at higher storage and transfer cost. Standard is for high-frequency access with higher storage cost and no retrieval penalty, Nearline is for backups read at most once a month, Coldline has lower storage cost but higher retrieval cost, and Archive has the lowest storage cost and highest retrieval cost, with object lifecycle management moving objects to cooler classes as they age.
Last updated