This chapter covers Google Cloud Storage classes (Standard, Nearline, Coldline, Archive) and lifecycle management rules, a critical topic for the ACE exam. Understanding storage classes directly impacts cost optimization and data management decisions, appearing in roughly 10-15% of exam questions, often integrated with lifecycle rules. You will learn the specific characteristics, pricing models, minimum storage durations, and how to configure lifecycle policies to automate transitions. Mastery of this topic allows you to design cost-effective storage solutions while meeting access requirements.
Jump to a section
Imagine a large warehouse where you rent shelf space to store your items. The warehouse offers several pricing plans. The 'Standard' plan is like a shelf right at the front of the warehouse — you can grab any item in seconds, but you pay a high monthly rent for that prime space. The 'Nearline' plan is a shelf further back — retrieval takes a few minutes, but the monthly rent is lower. The 'Coldline' plan is in a remote corner of the warehouse — you can still get your items, but it might take hours because a forklift must bring them forward, and there's a fee each time you retrieve something. The 'Archive' plan is like storing items in a deep, off-site vault — retrieval takes days and costs a significant fee per item, but the monthly rent is nearly zero. The warehouse manager (lifecycle rules) can automatically move your items from one shelf to another over time — for example, after 30 days on the front shelf, move them to the back shelf, and after a year, send them to the off-site vault. You set the rules, and the manager executes them daily. This mirrors how Google Cloud Storage classes work: Standard (high availability, low latency, higher cost), Nearline (lower cost, 30-day minimum storage duration), Coldline (even lower cost, 90-day minimum), and Archive (lowest cost, 365-day minimum, retrieval fees). Lifecycle rules automate transitions between classes based on object age, creation date, or storage class.
What Are Cloud Storage Classes?
Google Cloud Storage offers four primary storage classes, each designed for different access patterns and cost profiles. The classes differ in availability, latency, minimum storage duration, early deletion charges, and per-operation costs. The ACE exam expects you to know the exact values and trade-offs.
Standard: Default class. Offers 99.99% availability for multi-regional and dual-regional buckets, 99.9% for regional buckets. No minimum storage duration. No retrieval fees. Best for frequently accessed data.
Nearline: For data accessed less than once a month. 99.99% availability for multi-regional/dual-regional, 99.9% for regional. Minimum storage duration: 30 days. Early deletion penalty applies if objects are deleted before 30 days. Retrieval cost: $0.01 per GB.
Coldline: For data accessed less than once a quarter. Same availability as Nearline. Minimum storage duration: 90 days. Retrieval cost: $0.02 per GB.
Archive: For data accessed less than once a year. 99.99% availability for multi-regional/dual-regional, 99.9% for regional. Minimum storage duration: 365 days. Retrieval cost: $0.05 per GB. Note: Archive class has no availability SLA for data retrieval — it is designed for backup and archival.
How Storage Classes Work Internally
When you upload an object, you can specify its storage class. If not specified, it inherits the bucket's default storage class. The class is stored as object metadata and determines the underlying storage infrastructure used. Standard uses high-performance SSDs or HDDs with replication. Nearline and Coldline use lower-cost media with slightly higher latency. Archive uses nearline tape or optical media, resulting in retrieval times typically measured in hours.
Objects can transition between classes manually or via lifecycle rules. Each transition may incur a cost: moving from Standard to Nearline is free, but moving from Coldline to Standard incurs a retrieval fee. The exam often tests that transitions are only allowed in one direction without penalty: from hot to cold is free; from cold to hot incurs the retrieval cost.
Lifecycle Management Rules
Lifecycle management allows you to automate object transitions or deletions based on conditions. Rules are defined at the bucket level using JSON or XML. Each rule consists of a condition and an action.
Conditions:
- age: Number of days since object creation (when the object was uploaded).
- createdBefore: Date in RFC 3339 format (e.g., 2025-01-01). Objects created before this date match.
- isLive: Boolean. true for live objects, false for noncurrent versions (versioning must be enabled).
- matchesStorageClass: Array of storage class names (e.g., ["STANDARD", "NEARLINE"]).
- numNewerVersions: Integer. Matches objects with at least this many newer versions (versioning enabled).
Actions:
- SetStorageClass: Changes the object's storage class to one of: STANDARD, NEARLINE, COLDLINE, ARCHIVE.
- Delete: Deletes the object.
- AbortIncompleteMultipartUpload: Aborts incomplete multipart uploads after a specified number of days.
Defaults and Important Values
Minimum storage durations: Nearline 30 days, Coldline 90 days, Archive 365 days.
Early deletion charge: If you delete an object (or overwrite it) before the minimum duration, you are charged for the remaining days at the retrieval rate. For example, deleting a Nearline object after 10 days incurs a charge for 20 days of retrieval.
Retrieval fees: Nearline $0.01/GB, Coldline $0.02/GB, Archive $0.05/GB.
Storage costs per GB per month (approximate, vary by region): Standard ~$0.020, Nearline ~$0.010, Coldline ~$0.004, Archive ~$0.001.
Lifecycle rules are evaluated once per day (24-hour cycle). Changes may take up to 24 hours to take effect.
Maximum of 100 lifecycle rules per bucket.
Configuration and Verification Commands
Using gsutil:
To set a lifecycle configuration on a bucket:
gsutil lifecycle set lifecycle-config.json gs://my-bucketExample lifecycle-config.json:
{
"rule": [
{
"action": {
"type": "SetStorageClass",
"storageClass": "NEARLINE"
},
"condition": {
"age": 30
}
},
{
"action": {
"type": "SetStorageClass",
"storageClass": "COLDLINE"
},
"condition": {
"age": 90
}
},
{
"action": {
"type": "SetStorageClass",
"storageClass": "ARCHIVE"
},
"condition": {
"age": 365
}
},
{
"action": {
"type": "Delete"
},
"condition": {
"age": 730
}
}
]
}To view the lifecycle configuration:
gsutil lifecycle get gs://my-bucketTo change an object's storage class manually:
gsutil rewrite -s NEARLINE gs://my-bucket/my-objectUsing gcloud:
gcloud storage buckets update gs://my-bucket --lifecycle-file=lifecycle-config.jsonInteraction with Related Technologies
Versioning: Lifecycle rules can target noncurrent versions using isLive and numNewerVersions. For example, you can delete old versions after 30 days.
Object holds: Lifecycle rules will not delete objects that have a retention policy or hold applied. The rule is skipped for those objects.
Requester pays: Lifecycle rules still execute on requester-pays buckets, but the bucket owner pays for any operations.
Object notifications: Lifecycle actions can trigger Cloud Pub/Sub notifications if configured.
Exam Tips
Know the minimum storage durations: 30 days for Nearline, 90 for Coldline, 365 for Archive.
Understand that lifecycle conditions use age (days since creation) or createdBefore (date). age is relative to upload time; createdBefore is an absolute date.
Lifecycle rules are evaluated once per day. If you set a rule with age: 30, objects become eligible on the 31st day (after 30 full days).
You cannot set a lifecycle rule to transition to a warmer class (e.g., from Archive to Standard) automatically. That must be done manually.
Early deletion charges apply only if the object is deleted or overwritten before the minimum duration. Lifecycle transitions do not trigger early deletion charges.
The Delete action can also be used to delete incomplete multipart uploads older than a specified number of days.
Common Pitfalls
Confusing age with createdBefore: age is relative to object creation; createdBefore is an absolute date. The exam may test that age is calculated from the object's creation time, not the rule's creation time.
Forgetting that lifecycle rules apply to all objects in the bucket unless conditions filter them. Use matchesStorageClass to target specific classes.
Assuming lifecycle transitions happen instantly: they occur once per day, so expect up to 24 hours delay.
Believing that Archive class has the same availability SLA: Archive has no retrieval SLA; Standard has 99.99% availability.
Identify Data Access Patterns
Begin by analyzing how often your data will be accessed. For data accessed multiple times per day, Standard is appropriate. For data accessed less than once a month, consider Nearline. For less than once a quarter, Coldline. For less than once a year, Archive. This analysis determines the optimal storage class for initial upload and the lifecycle transition schedule. Document the access frequency for each dataset, noting that some data may start hot and cool over time.
Create Bucket with Default Class
Create a Cloud Storage bucket and set the default storage class to the class that matches the initial access pattern. For example, if data is frequently accessed initially, set default to Standard. Use the gsutil mb command: gsutil mb -c STANDARD -l us-central1 gs://my-bucket. The default class applies to all objects uploaded without an explicit class. You can also set the default class via the Cloud Console under bucket settings.
Define Lifecycle Rules JSON
Create a JSON file that specifies lifecycle rules. Each rule has a condition (e.g., age >= 30) and an action (e.g., SetStorageClass to NEARLINE). Use the example in core_explanation as a template. Ensure conditions are mutually exclusive to avoid conflicts. For example, if you have rules for age 30, 90, 365, each object will only match the first applicable rule because rules are evaluated in order. The maximum number of rules is 100.
Apply Lifecycle Configuration
Apply the lifecycle configuration to the bucket using: gsutil lifecycle set lifecycle-config.json gs://my-bucket. Verify with: gsutil lifecycle get gs://my-bucket. The configuration takes effect immediately, but actions are evaluated once per day. Objects already in the bucket will be evaluated on the next daily cycle. New objects are evaluated from their creation date.
Monitor and Adjust Rules
Monitor the storage costs and access patterns using Cloud Monitoring and billing reports. If data is accessed more frequently than expected, you may need to adjust lifecycle rules to keep it in a warmer class longer. If data is rarely accessed, you can shorten the transition times. Use gsutil lifecycle set to update the configuration. Note that changes to rules affect only future evaluations; objects already transitioned remain in their current class.
Enterprise Scenario 1: Media Archival
A media company stores raw video footage after editing. Initially, footage is accessed frequently for review (first 30 days). After 30 days, it is accessed occasionally (maybe once a month) for re-edits. After 90 days, it is rarely accessed (once a quarter). After one year, it is archived for compliance. The company sets up a bucket with Standard default, then lifecycle rules: at age 30 transition to Nearline, at age 90 to Coldline, at age 365 to Archive. This reduces storage costs by ~80% compared to keeping all data in Standard. They also set a rule to delete objects after 730 days (2 years) to comply with data retention policies. Common issues: if editors need to access older footage unexpectedly, they face retrieval fees and latency. They mitigate by using manual rewrites to Standard for specific objects. Scale: 500 TB of data, lifecycle rules reduce monthly cost from $10,000 to $2,000.
Enterprise Scenario 2: Backup and Disaster Recovery
A financial institution backs up databases daily. Backups are retained for 7 days in Standard for quick restore, then moved to Coldline for 30 days for compliance, then to Archive for 1 year. They use lifecycle rules with createdBefore conditions to match backup dates. For example, backups older than 7 days move to Coldline. They also enable versioning to keep multiple backup versions. Lifecycle rules clean up old versions: delete noncurrent versions after 90 days. A misconfiguration once caused all backups to be deleted because the Delete action accidentally matched live objects due to a missing isLive condition. They now test rules on a small subset first. Performance: retrieval from Archive can take hours, so they maintain a separate Standard bucket for the most recent 7 days.
Enterprise Scenario 3: IoT Data Ingestion
An IoT company ingests sensor data every minute. Data is hot for 1 day (real-time dashboards), then warm for 7 days (trend analysis), then cold for 90 days (historical reporting), then archived for 3 years. They use lifecycle rules to transition from Standard to Nearline at age 1, to Coldline at age 7, to Archive at age 90. They also delete objects after 1095 days (3 years). Because data volume is high (10 TB/day), they use multiple buckets partitioned by date to avoid hitting the 100-rule limit per bucket. A common mistake is forgetting that lifecycle rules evaluate once per day, so a 1-day transition may take up to 48 hours to execute. They mitigate by using a separate script to manually transition objects that need immediate cost savings.
What the ACE Tests
Objective 2.2 (Planning Solutions) focuses on selecting appropriate storage classes and configuring lifecycle rules. The exam expects you to:
Identify the correct storage class based on access frequency and cost requirements.
Calculate cost implications of early deletion, retrieval fees, and storage duration.
Write or interpret lifecycle rule JSON.
Understand the order of rule evaluation and the once-per-day execution.
Recognize that lifecycle rules cannot transition to warmer classes automatically.
Common Wrong Answers
Choosing Coldline for data accessed monthly: Candidates often pick Coldline because it's cheaper, but the minimum storage duration is 90 days. If data is accessed monthly, Nearline (30-day minimum) is more appropriate. The exam tests that Nearline is for data accessed less than once a month, Coldline for less than once a quarter.
Assuming lifecycle transitions happen instantly: Many candidates think rules execute immediately upon condition match. The correct understanding is that they are evaluated once per day, so there can be up to a 24-hour delay.
Confusing `age` with `createdBefore`: A question might ask: 'An object was created on July 1. A lifecycle rule with condition age: 30 is applied on July 15. When will the object be eligible?' The incorrect answer is July 15 + 30 days; the correct answer is July 1 + 30 days = July 31.
Thinking that Archive class has the same retrieval latency as Standard: Archive can take hours to retrieve, and there is no SLA. The exam may test that Archive is not suitable for data that needs immediate access.
Specific Numbers and Terms
Minimum storage durations: Nearline 30, Coldline 90, Archive 365 days.
Retrieval fees: Nearline $0.01/GB, Coldline $0.02/GB, Archive $0.05/GB.
Lifecycle evaluation: once per day.
Maximum rules per bucket: 100.
Storage class names in API: STANDARD, NEARLINE, COLDLINE, ARCHIVE.
Edge Cases
Objects with retention policies or holds are exempt from lifecycle deletion.
If a bucket has versioning enabled, lifecycle rules can target noncurrent versions using isLive: false and numNewerVersions.
Lifecycle rules can also abort incomplete multipart uploads using AbortIncompleteMultipartUpload action with condition age (days since upload initiation).
How to Eliminate Wrong Answers
If a question mentions 'data accessed less than once a year', eliminate Standard, Nearline, Coldline — only Archive fits.
If a question says 'automatic transition to a warmer class', that's impossible — eliminate any answer suggesting automatic transition to Standard.
If a question involves cost optimization and mentions 'no retrieval fees', only Standard has no retrieval fees; all others charge.
If a question asks about 'minimum storage duration', recall the specific numbers: 30, 90, 365.
Four storage classes: Standard, Nearline, Coldline, Archive — each with different cost, latency, and minimum duration.
Nearline minimum duration: 30 days; Coldline: 90 days; Archive: 365 days.
Lifecycle rules are evaluated once per day; conditions use `age` (days since creation) or `createdBefore` (absolute date).
Lifecycle actions: SetStorageClass (to colder class only) and Delete.
Early deletion charges apply only on manual deletion/overwrite, not lifecycle transitions.
Archive has no retrieval SLA; retrieval can take hours.
Maximum 100 lifecycle rules per bucket.
Use `matchesStorageClass` to target specific classes for transitions.
These come up on the exam all the time. Here's how to tell them apart.
Standard
No minimum storage duration
No retrieval fee
Highest storage cost per GB (~$0.020/GB/month)
Best for data accessed frequently (multiple times per day)
99.99% availability (multi-regional)
Nearline
30-day minimum storage duration
$0.01/GB retrieval fee
Lower storage cost (~$0.010/GB/month)
Best for data accessed less than once a month
99.99% availability (multi-regional)
Coldline
90-day minimum storage duration
$0.02/GB retrieval fee
Storage cost ~$0.004/GB/month
Best for data accessed less than once a quarter
Retrieval typically within minutes to hours
Archive
365-day minimum storage duration
$0.05/GB retrieval fee
Lowest storage cost ~$0.001/GB/month
Best for data accessed less than once a year (backup/archival)
Retrieval typically takes hours; no SLA
Mistake
Lifecycle rules execute immediately when an object meets the condition.
Correct
Lifecycle rules are evaluated once per day, typically within 24 hours of the condition being met. There is no real-time execution.
Mistake
All storage classes have the same availability SLA.
Correct
Standard, Nearline, and Coldline have 99.99% availability for multi-regional/dual-regional and 99.9% for regional. Archive has no retrieval SLA; its availability is for storage only.
Mistake
Lifecycle rules can automatically move objects to a warmer storage class.
Correct
Lifecycle rules only support transitions to colder classes (Standard -> Nearline -> Coldline -> Archive) and deletion. Moving to a warmer class must be done manually.
Mistake
Early deletion charges apply when lifecycle rules transition objects before the minimum duration.
Correct
Early deletion charges apply only when you manually delete or overwrite an object before its minimum storage duration. Lifecycle transitions do not incur early deletion charges.
Mistake
The `age` condition in lifecycle rules is based on the number of days since the rule was created.
Correct
`age` is based on the object's creation time (when it was uploaded), not the rule's creation time. For example, an object created on Jan 1 with a rule using `age: 30` will be eligible on Jan 31.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
No. Lifecycle rules only support transitions to colder storage classes (Standard -> Nearline -> Coldline -> Archive) and deletion. To move objects to a warmer class, you must do so manually using gsutil rewrite or the Cloud Console. This is a common exam trap.
`age` is a number of days since the object was created. For example, `age: 30` matches objects that are at least 30 days old. `createdBefore` is an absolute date in RFC 3339 format (e.g., '2025-01-01'). Objects created before that date match. Use `age` for relative time from creation; use `createdBefore` for a fixed cutoff date.
Yes. Lifecycle rules apply to all objects in the bucket that match the conditions, including existing objects. The rules are evaluated once per day, so existing objects will be evaluated on the next daily cycle. For example, if you add a rule to delete objects older than 30 days, existing objects that are already 30+ days old will be deleted in the next evaluation.
You will incur an early deletion charge. For Nearline, if you delete an object after 10 days, you are charged for the remaining 20 days at the retrieval rate ($0.01/GB). For Coldline, the charge is for the remaining days at $0.02/GB. For Archive, the charge is for the remaining days at $0.05/GB. Lifecycle transitions do not incur this charge.
Yes, but only the first matching rule's action is executed per evaluation cycle. Rules are evaluated in the order they appear in the configuration. If two rules have the same condition, the first one in the list takes effect. To avoid conflicts, ensure conditions are mutually exclusive or order them appropriately.
Use the `isLive` condition set to `false` to target noncurrent versions. You can also use `numNewerVersions` to match objects with at least a certain number of newer versions. For example, to delete noncurrent versions older than 30 days: condition: `age: 30, isLive: false` action: `Delete`. Versioning must be enabled on the bucket.
Transitioning to a colder class (e.g., Standard to Nearline) is free. Transitioning to a warmer class (manual) incurs a retrieval fee equal to the cost of reading the data from the current class. There are no additional charges for the lifecycle operation itself, but standard operation costs for reading metadata may apply.
You've just covered Cloud Storage Classes and Lifecycle Rules — now see how well it sticks with free ACE practice questions. Full explanations included, no account needed.
Done with this chapter?