Microsoft AZ-104: Azure Storage Account Decisions
The difficult storage decisions happen before the first blob is uploaded: failure-domain coverage, network paths, identity-based access, account capabilities, data lifecycle, and an owner who can explain each choice. A storage configuration that is convenient during development can become expensive or risky when access patterns, redundancy needs, and retention change. Make each account choice traceable to a workload requirement, including the identity permitted to read the data.
On this page
- Begin with the data’s actual promises
- Select redundancy for the outage you must survive
- Treat network access as a deliberate design choice
- Prefer identity-based authorization over account-key sprawl
- Know which account capabilities the workload requires
- Make data protection separate from replication
- Align access tiers and lifecycle actions with use
- Rehearse incident response before handing over the account
Begin with the data’s actual promises
A design review that asks only whether Azure Storage is durable misses several different promises a service may be expected to keep. One workload needs uploaded files to remain available during a zonal outage. Another needs to protect legal records from accidental deletion. A third has to serve an application in a second region after a larger disaster. Each requires different controls. Account redundancy is important, but it cannot substitute for authorization, retention policy, or an application recovery plan. A defensible Microsoft AZ-104 storage configuration checks access, redundancy, retention and restoration against the actual workload rather than treating durability as the only requirement.
Start by describing the data set and its consumers. How much may be lost after a destructive incident? How quickly must service resume? Do users write to the account continuously, or is it mostly an archive? Is the workload tied to a local region or permitted to fail over? A storage design is defensible when its settings can be traced back to these answers rather than to a copied checklist of premium features.
An illustrative example is a document-processing application with an ingestion queue, immutable customer records, and temporary transformed images. All three might initially be placed in one account, but their retention, authorization, and recovery policies differ. Separating them may reduce unintended access and avoid applying expensive availability or retention choices to data that does not need them. An account is both a billing and a security boundary; choosing that boundary deliberately is a useful first step.
Select redundancy for the outage you must survive
Local redundancy replicates data within the primary region’s storage infrastructure. Zone redundancy distributes copies across availability zones where supported. Geographic redundancy adds a secondary-region dimension, but replication and failover semantics matter: having geo-replicated data is not the same as an application automatically serving healthy traffic from the secondary region after an incident.
For a production dataset, ask whether the dominant risk is hardware failure, a zonal interruption, a whole-region event, or operator error. Redundancy addresses particular infrastructure failures; it generally does not protect against an authorized user overwriting or deleting data. Versioning, soft delete, backups, and immutability controls may be needed for logical damage. Verify the service and regional availability of the chosen redundancy option rather than treating all storage types as identical.
Geo-redundant configurations can have asynchronous replication implications, including a potential recovery-point gap. A primary-region failover plan should state what data might not be present in the secondary and which clients must be reconfigured. The application team needs to rehearse those dependencies. The difference between data redundancy and an operational failover procedure also appears in Backup and Site Recovery, where different recovery mechanisms serve different failure modes.
Treat network access as a deliberate design choice
An Azure Storage account can expose a public endpoint even when its application consumers operate privately. Allowing every network to attempt a connection does not mean the requests are authorized, but it expands the network path to that authorization gate. Storage firewall rules limit sources to the public endpoint; private endpoints create private-IP paths for supported services. Microsoft’s storage network security guidance distinguishes these models and warns that allowed network sources still require valid authentication.
For a workload living entirely in a VNet, a private endpoint may make the traffic path easier to explain to reviewers, provided private DNS, subnet policies, and any required on-premises resolution are designed correctly. Creating a private endpoint object by itself does not cause every client to resolve the public storage hostname to the private address. Test name resolution from the actual application network, not only from an administrator’s workstation.
During migration, disabling a public endpoint abruptly can break backup tooling, build agents, monitoring systems, or hybrid clients that were never included in the original network map. Inventory the consumers, arrange alternative routes, test from each relevant network, and then enforce the intended rule. Do not compensate for a missing private DNS record by granting broad identity roles; network troubleshooting and authorization require different evidence.
Prefer identity-based authorization over account-key sprawl
A Shared Key can authorize operations across a storage account, which is convenient but difficult to limit to one application’s exact job. When a key is copied into many services, rotating it becomes an organizational change event; every consumer must be found and updated. A leaked key may also expose more capability than the requesting workload required. Microsoft recommends moving suitable data access to Microsoft Entra authorization and explains how to prevent Shared Key access after dependent clients have been migrated.
Use data-plane roles at a justifiable scope and distinguish them from Azure management roles. A person allowed to change account networking or redundancy is not necessarily meant to enumerate confidential blobs. Some management roles can retrieve access keys and thereby indirectly bypass this separation when Shared Key is permitted. If an application uses a managed identity, verify the identity and exact data role rather than assuming that enabling the identity on its compute host completes the configuration.
Temporary delegation can be appropriate, but a signed access token is not a substitute for a documented lifetime and intended operation. Compare user-delegation SAS and service/account SAS restrictions when the application needs delegated storage access, and record who may issue them. On an inherited application, inspect current authentication methods before changing allowSharedKeyAccess; the safe sequence is visibility, migration, controlled enforcement, then proof of continuing operations.
Know which account capabilities the workload requires
A general-purpose v2 storage account supports many common blob, file, queue, and table scenarios, but not every capability or performance tier behaves the same way. Account kind, redundancy, access tier, hierarchical namespace, and service-specific features may influence what can be enabled now and what future migration will require. These are not merely billing switches. Enabling hierarchical namespace, for example, has distinct data-lake semantics and compatibility considerations that deserve a workload-specific review.
If an analytics team wants directory-aware operations on a large object store, confirm whether Azure Data Lake Storage features and access controls align with its processing tools. If a file-sharing workload expects SMB clients and directory-integrated authentication, evaluate Azure Files requirements rather than choosing a generic blob pattern because both products use storage accounts. A queue used for application messaging has different service limits and operational concerns from a blob repository containing media assets.
The practical design record can be short: account type, required service, geographic location, redundancy choice, public/private access, identity model, data protection settings, cost owner, and known consumer systems. It should state unsupported options or planned migrations explicitly. Naming a storage account prodcritical does not prove that the configuration supports any particular objective.
Make data protection separate from replication
Replication can faithfully copy a destructive operation. If an authorized process overwrites the wrong blob, redundancy by itself does not restore the earlier content. Soft delete, versioning, point-in-time recovery where supported, backup, and immutable retention each address different kinds of loss. Choose controls according to the risk of mistakes, malicious deletion, legal retention, and recovery-time expectations.
Consider a shared report repository. The business may tolerate a short infrastructure interruption but cannot tolerate a compromised service account deleting historical invoices. Object version history and suitably protected retention policy could be more important than adding a second region without a restore exercise. A separate backup or recovery design might still be necessary when entire account access or permissions are compromised. Test the restoration procedure with the actual data type and permissions before reporting the controls as operationally proven.
Storage protection settings often have cost and governance implications. Versions, snapshots, retained deletes, and cross-region copies consume capacity. A policy that keeps every old version forever can create an expensive compliance problem rather than a sound retention design. Coordinate recovery periods, legal obligations, and defensible deletion conditions with the owner of the data, not just the infrastructure team.
Align access tiers and lifecycle actions with use
Data temperature changes over time. New uploads may be accessed frequently during a processing window, while old output sits idle until an audit or customer request. Azure Blob lifecycle management can move qualifying blobs to cooler tiers or delete them based on policy rules, with feature limitations and timing that must be reviewed for the account. Microsoft’s Blob lifecycle guidance documents the available policy behaviors and filters.
The low headline price of a cooler tier is not the complete cost of that data. Retrieval, early deletion, read operations, and access patterns can materially change economics. Applying an archive-style policy to objects that a search workflow repeatedly reads may save on resting capacity and spend much more on retrieval or produce unacceptable delays. Estimate cost from observed usage rather than classifying every file older than 30 days as cold.
A practical pilot uses a small representative dataset and a policy in reportable form. Observe how many objects meet the rule, check exceptions such as legal holds or recently modified objects, and compare projected savings with required restore speed. Confirm that policy actions have not deleted a retained version or interfered with an application’s expectation that a URL stays immediately usable.
Rehearse incident response before handing over the account
An account can pass a deployment checklist yet be difficult to operate because nobody knows who owns a network change, rotation, cost anomaly, or restoration. Record the identity that performs the workload’s normal operations and the administrator path for recovering access if that identity is compromised. Assign alerts to people who can interpret the service signals, not simply to a generic mailbox that receives every notification.
Build a small failure drill: deny network access to a disposable client, observe the connection symptom, restore the permitted path, then remove a data-role assignment and observe the authorization error. Finally restore a test blob version or deleted item with the configured protection feature. Document what changed and how each recovery was proven. These tests distinguish a reliable storage design from an account that merely has several security boxes checked.
Before approving a storage account, ask the service owner to state the expected read/write availability, permitted network paths, authorization method, retention period, and acceptable recovery window. Each of those promises should point to a concrete setting or operational control. A design that can answer those questions is easier to maintain and far safer to change than one built around a single claim that the data is “in Azure.”