Storage account
What it is
A storage account is the Azure resource that provides a named home for Azure Storage data services. It can contain blob containers, file shares, queues, and tables, while applying key settings such as redundancy, network access, encryption, and performance to the account or its supported services. Think of it as a securely managed storage facility, not as one folder or one hard disk.
Why it exists
Instead of managing disks or servers for data, a storage account is wholly managed: you choose a name, kind, redundancy, and these apply consistently across every data service inside it. It is the unit you deploy, secure, and pay for.
Key ideas
- The account name is globally unique in Azure Storage and appears in endpoints such as
accountname.blob.core.windows.net. It is not an Azure user account. - Standard general-purpose v2 is the common general-purpose account. Other account types target specific performance or service needs; choose from current service documentation rather than assuming every feature works with every type.
- The account is a shared boundary for important choices. For example, redundancy applies across storage services in an account, so resources with different recovery needs may need separate accounts.
- A blob container is inside a storage account. A file share, queue, and table are different Azure Storage services, not other names for the same thing.
- Access can use Microsoft Entra ID, shared keys, or narrowly scoped tokens depending on the service and scenario. Restrict network access separately through network rules or private connectivity.
Northwind example
Northwind creates northwindordersprod for order receipts. It stores uploaded receipt images in a blob container, chooses a redundancy option based on recovery needs, and limits access to the application identity and approved network path. It creates a separate account for disposable test data because test data has different cost, retention, and recovery needs.
Common confusion
- A storage account is a control-plane resource; a blob, file share, queue, or table is the data stored through it.
- An account’s redundancy copies data for infrastructure failures. It does not undo an application overwriting or deleting data.
- “Private storage account” normally describes its network-access design, not a different storage-account product.
How it fits (diagram)
Design tradeoffs
- Consolidating data in one account simplifies administration but couples its redundancy and networking choices.
- Separating accounts can improve isolation and fit different requirements, but adds operational overhead.
- Availability, supported regions, access tiers, and performance vary by account type and service. Verify the proposed combination before a production deployment.
Related
redundancy-lrs-zrs-grs · access-tier · storage-performance · blob-storage · azure-files · storage-network-rule · storage-access-keys · sas-token · northwind-traders-case-study
📘 Source: Microsoft Learn — Storage account overview, checked 2026-09-16.
Storage redundancy & replication
What it is
Azure Storage redundancy keeps multiple infrastructure copies of data in a storage account. It helps the service survive hardware, datacenter, or regional failures, depending on the option. It is not a point-in-time backup: a deletion or corrupt change can be copied too.
Why it exists
Redundancy is a tradeoff between cost, in-region availability, and geographic recovery. Its behavior depends on the account type, Azure region, and service. Choose it before assuming a workload can survive a particular failure.
The options in plain language
| Option | Where Azure keeps copies | Main protection | Important limit |
|---|---|---|---|
| LRS (locally redundant) | One datacenter in the primary region | Drive, server, and rack failures | A datacenter-scale disaster can affect every copy. |
| ZRS (zone-redundant) | Three or more availability zones in the primary region | A single-zone failure | It remains a single-region design. |
| GRS (geo-redundant) | Primary region plus asynchronous copies in a secondary region | Regional recovery capability | Secondary data is not normally readable before failover. |
| GZRS (geo-zone-redundant) | ZRS in the primary region plus asynchronous secondary-region copies | Zone resilience plus regional recovery capability | Geographic replication is asynchronous. |
| RA-GRS / RA-GZRS | The corresponding geo-redundant design | The above, plus read access to the secondary endpoint | Read access does not make the secondary writable or make failover automatic. |
Azure Storage uses at least three copies for LRS and synchronous copying across zones for ZRS. GRS and GZRS replicate to the secondary region asynchronously, so recent writes can be absent during a regional recovery. Service support and change paths vary; verify them for the account type and region rather than treating this table as a migration guarantee.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: storage/common/storage-redundancy
Northwind example
Northwind stores live order receipts in a zone-enabled region. It selects ZRS when keeping the service available through a single-zone failure matters and regional recovery is handled elsewhere. If its recovery design requires a second-region copy, it evaluates GZRS and a documented failover plan. For accidental deletion, it also enables appropriate data-protection features and tests restoration. ZRS and GZRS copy healthy or unhealthy changes; neither is a substitute for backup.
Common confusion
- Zone-redundant means copies across zones in one region; geo-redundant means copies in a second region. They solve different failure scopes.
- Durability (“copies are unlikely to be lost”) is different from availability (“clients can reach the data now”).
- RA means read access to the secondary endpoint. It is not a second writable production account.
- Choosing a region pair does not enable GRS or GZRS. The storage-account redundancy setting does.
Related
storage-account · storage-performance · blob-storage · azure-files · availability-zones · zone-redundant · azure-backup · northwind-traders-case-study
📘 Source: Microsoft Learn — Azure Storage redundancy, checked 2026-09-16.
Storage performance tier (Standard vs Premium)
What it is
Together with kind, the performance tier chooses the backing hardware. Standard = magnetic/HDD-class (cost-effective, GB on-the-fly) and Premium = SSD-backed (high IOPS + throughput, low latency, priced higher). Standard is also called general-purpose; premium comes in account kinds like Premium block blobs and Premium file shares.
Why it exists
Not all workloads need SSD. Tiered per account = the sweet spot between cost and IO performance so you don’t overpay for a backup archive on premium SSD, nor starve a transactional database on HDD.
Key ideas
- Standard general-purpose v2 — the common default; supports blobs, files, tables, queues; auto access tiers.
- Premium block blob storage (PA_BLOB) — high performance for high-throughput block blobs (e.g., analytics, IoT); no access tiers.
- Premium file shares — SMB/NFS on SSD; for database/file workloads needing consistent low latency. Backed by premium SSD-managed data.
- Premium page blobs — foundation for unmanaged VM disks and premium SSD-powered managed disks (also used by VMs).
- Premium accounts generally have higher per-GB cost but better IOPS/latency; Standard is elastic.
How it fits (diagram)
Exam notes
- Performance = hardware (SSD vs magnetic); Kind = which services & features. Pick both at creation.
- Premium block blobs have no access tiers (hot-only).
- Premium file shares enable low-latency consistent IOPS for file workloads.
- VM disks: page blobs = unmanaged attached disks; premium = SSD-backed.
Related
storage-account · blob-storage · azure-files · redundancy-lrs-zrs-grs
📘 Source: Microsoft Learn — Storage Performance
Blob access tiers
What it is
Blob access tiers optimize Block Blob cost by expected access frequency. Hot is for frequent use; cool and cold are online tiers for less frequent use; archive is offline long-term storage. The tier trades storage cost against access cost, availability, and—in archive—retrieval delay.
Why it exists
Most data (‘unstructured/marketing/backup/compliance’) is accessed rarely once written. Paying full hot-tier price for it wastes money. Tiers align cost with access patterns.
The tiers
- Hot: online tier for frequent reads or writes; highest storage cost and lowest access cost. It is the default for a new general-purpose v2 account.
- Cool: online tier for infrequent access; 30-day minimum storage duration.
- Cold: online tier for rare but still fast retrieval; 90-day minimum storage duration.
- Archive: offline tier for very rarely accessed data; 180-day minimum. Rehydrate to hot, cool, or cold before reading or downloading. Rehydration can take up to 15 hours.
- Smart tier: automatically moves eligible data among hot, cool, and cold tiers based on usage patterns. It does not include archive.
Tier can be set at the storage-account default for new blobs (hot, cool, or cold) or explicitly per blob. A lifecycle policy can automate rules-based tier changes; archive rehydration cannot be performed by lifecycle policy.
Northwind example
Northwind keeps current product images in hot storage, completed monthly exports in cold storage, and legal archives in archive. If a legal request arrives, the archive copy is not ready immediately; Priya starts rehydration and plans for the delay. The team does not move a file into cold for a week and delete it—early deletion charges still apply before the 90-day period.
How it fits (diagram)
Exam notes
- Archive is offline; it requires rehydration before content can be read or changed.
- Cool, cold, and archive can incur early-deletion charges when deleted, overwritten, or moved before their minimum duration.
- Access tier is a cost-and-availability choice, not a backup, retention, or authorization policy.
Related
blob-storage · storage-account · storage-performance · immutable-storage
Azure Blob Storage
What it is
Azure Blob Storage is Azure’s object storage service for unstructured data: images, documents, video, application logs, backups, and other files. It stores each item as a blob inside a container in a storage account. A blob is accessed by its endpoint and name, not mounted as a traditional disk by default.
Why it exists
Applications need cheap, massively scalable storage for binary/unstructured payloads that isn’t tied to a filesystem or a database schema. Blobs support trillions of objects and PB-scale, with tiered pricing.
Key ideas
- The practical hierarchy is storage account → container → blob. Slashes in a blob name can look like folders, but a normal blob namespace is flat unless you enable a hierarchical namespace for a supported scenario.
- Block blobs are the usual choice for documents and media. Append blobs are designed for append-heavy log-like data. Page blobs support random read/write patterns and are used for VHD scenarios such as unmanaged disks.
- Access tiers and lifecycle rules can move or remove data to manage cost. Changing a tier does not create a safety copy.
- Versioning, soft delete, snapshots, and immutability can help protect data from different kinds of mistakes. Select and test the controls that match the recovery requirement.
Northwind example
Northwind puts customer receipt images in an receipts container. Each receipt is a block blob whose name includes an order reference. The ordering app uses its workload identity to write new images; staff do not receive a shared storage key. Northwind uses lifecycle rules for older receipts and data-protection features for accidental deletion. The images are objects in Blob Storage, not files on the web server’s disk.
Common confusion
- A container is an organization and access boundary inside a storage account; it is not a Windows folder or an Azure resource group.
- Blob Storage can expose public access only when deliberately configured. A guessable URL is not an access-control design.
- Storage redundancy handles infrastructure copies. Object versioning, soft delete, immutability, and backup address different data-loss risks.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: storage/blobs/storage-blobs-introduction
Where it appears in the route
Start with storage-account and redundancy-lrs-zrs-grs, then use access-tier and storage-network-rule to design cost and access.
Related
storage-account · access-tier · storage-performance · azure-tables · azure-queues · immutable-storage · redundancy-lrs-zrs-grs · northwind-traders-case-study
📘 Source: Microsoft Learn — Introduction to Azure Blob Storage, checked 2026-09-16. Re-audit when Blob Storage resource types, access tiers, or authorization guidance changes.
Azure Files
What it is
Azure Files provides fully managed cloud file shares. A machine can mount a share and use folders and files much like a familiar network drive, rather than treating each file as a separate web object. Azure Files supports SMB, NFS, and programmatic REST access.
Why it exists
Some existing applications expect a shared directory: several servers may open files by a path, use file-system APIs, and share folders. Azure Files supplies that model without running and patching a file-server VM.
Key ideas
- A file share lives in a storage account. The account’s performance, redundancy, network, and identity choices affect the share.
- SMB works with Windows, Linux, and macOS and suits general-purpose shares and Azure File Sync. NFS supports Linux workloads, containers, and HPC scenarios. Choose the protocol from client and workload requirements.
- Azure File Sync can cache an Azure file share on Windows Servers for a hybrid design. It is not a general file-cache service for every operating system.
- Identity-based access and shared-key access are different models. Grant the least privileges needed, and protect network access as well as credentials.
- Snapshots and soft delete can support recovery, but they are not a substitute for a recovery plan that defines retention, restore testing, and accidental-overwrite handling.
How it fits (diagram)
Northwind example
Northwind has a legacy label-printing application that expects a shared \\server\labels folder. Rather than rewriting it immediately, Luis mounts an Azure Files share on the application VMs. Warehouse Windows Servers use Azure File Sync to keep the working set close to local users. The team limits access to the application’s identity and approved network paths, then tests restoring a deleted file before relying on snapshots or soft delete in an incident.
Azure Files versus Blob Storage
| Need | Start by considering |
|---|---|
| A mountable shared directory and file-system-style access | Azure Files |
| Object storage for application data, images, documents, or large unstructured content | [[blob-storage |
Both are Azure Storage services, but a blob container is not a folder share that an operating system mounts in the same way.
Common confusion
- A successful mount proves a network and authentication path at that moment; it does not prove every user or application has the right file permission.
- The share path is an address, not an authorization decision. Access requires a supported credential and permission model.
- A shared file store can create concurrency and overwrite problems. Applications must coordinate writes when two clients may change the same file.
Related
storage-account · file-sync · blob-storage · azure-tables
Sources and re-audit
- Microsoft Learn — What is Azure Files?, checked 2026-09-16.
Azure File Sync
What it is
Azure File Sync keeps an on-premises Windows Server file server in sync with a cloud Azure file share. It centralizes your files in Azure while keeping a high-performance cache on the local server — a hybrid pattern for preferring cloud while staying on-prem.
Why it exists
You want cloud durability/central access but your line-of-business apps still need a local Windows file server mount + latency. File Sync gives one identity across local cloud-copied shares and enables the “primary data in Azure, cache on-prem” model.
Key ideas (the three pieces)
- Storage Sync Service — the top-level Azure resource that orchestrates sync.
- Sync group — defines what syncs to where (one cloud endpoint + one or more server endpoints).
- Cloud endpoint / Server endpoint — an Azure file share (cloud) and a folder on a registered Windows Server (server).
- Cloud tiering: files can be tiered to the cloud — only a local pointer/heat-based stubs remain; cold files stay cloud-only and hydrate on demand, saving local disk.
- Windows Server Failover Clustering, Distributed File System (DFS), Azure Backup integrate with it.
How it fits (diagram)
Exam notes
- File Sync requires Windows Server server agents; it is not for Linux.
- Cloud tiering offloads cold files to Azure → local space is reclaimed, files recall on access.
- One sync group = one cloud endpoint + multiple server endpoints; many-to-one, one-to-many, multi-site.
- Purpose: centralize in Azure Files while caching locally — you do NOT need a second manual copy job.
Related
azure-files · storage-account · storage-browser
📘 Source: Microsoft Learn — File Sync
Azure Table storage
What it is
Azure Table storage is a NoSQL key-and-attribute store for large amounts of structured, non-relational data. Instead of rigid database columns and relationships, each record (an entity) contains named properties. Every entity has a PartitionKey and RowKey that together identify it.
Why it exists
Use it for flexible data such as user preferences, device metadata, address books, or application lookup data when you do not need relational joins, foreign keys, or stored procedures. It favors simple, planned key-based access over the free-form relationships of a relational database.
Key ideas
- Entity is like a row; property is like a named column value. A table does not enforce every entity having the same property set.
- PartitionKey groups related entities. Queries and insert/update operations are efficient for entities sharing a partition key. Plan this key around how the application reads and writes data.
- RowKey identifies the entity within its partition.
PartitionKey + RowKeyis the composite primary key; the service also records a timestamp. - It is non-relational. Design data around the queries you need. If a feature requires joins, foreign keys, complex transactions, or rich relational querying, start by evaluating a relational database instead.
- It lives in a storage account. The endpoint form is
https://<account>.table.core.windows.net/<table>. - Cosmos DB for Table is related but distinct. It uses the Table API concepts while offering features such as higher performance, availability, global distribution, and automatic secondary indexes. Assess the documented feature and cost differences before treating it as a drop-in equivalent.
Northwind example
Northwind stores delivery-zone configuration in a table. An entity might use PartitionKey = "UK" and RowKey = "M1", with properties such as DeliveryFee and NextDayAvailable. Looking up the rules for a UK postcode prefix is fast because the app knows both keys. The team does not put orders and customers there expecting SQL-style joins; its order database remains the system of record for that relationship-heavy data.
How it fits (diagram)
Exam notes
PartitionKey + RowKeyidentifies an entity; design keys to match access patterns.- Table Storage is schemaless structured data, not a relational database.
- Compare with Queue Storage for work messages and Blob Storage for files and unstructured objects.
Related
storage-account · queue-storage · blob-storage
Azure Queue storage
Canonical explanation
This legacy title is retained so existing links continue to work. Read Azure Queue Storage for the complete beginner explanation, Northwind example, delivery caveats, and current source record.
What it is
Azure Queue Storage holds messages that describe work waiting for a worker. A sender can add a small message and continue; a worker processes it later. This is called asynchronous processing.
Why it exists
A queue absorbs a temporary burst of work, such as “make a receipt” or “resize an image,” so the customer-facing application does not wait for the slow task to finish.
Key ideas
- A queue belongs to a storage account and holds messages up to 64 KB.
- A worker receives a message, processes it, and deletes it only after success. A visibility timeout can make an unfinished message available again for retry.
- Do not assume exactly-once or strict FIFO delivery. Workers must tolerate duplicate delivery and monitor repeated failures.
- Use Azure Service Bus when the requirement needs richer broker capabilities such as topics or sessions.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: storage/queues/storage-queues-introduction
Exam notes
- Queue Storage is for durable work messages, not a business-data archive.
- Receiving is not deleting: delete only after successful processing.
- See queue-storage for the full decision and implementation explanation.
Related
storage-account · azure-tables · blob-storage · queue-storage
📘 Source: Microsoft Learn — Azure Queue Storage
Storage access keys & connection strings
What it is
Each storage account has two 512-bit access keys: key1 and key2. A key authorizes broad access to the account’s storage data and can create account-key-signed SAS tokens. Software can use a key through Shared Key authorization or a connection string.
Why it exists
Keys support applications and tools that still need Shared Key authorization. Two independent keys make a planned rotation possible: clients move to the unused key before the current key is regenerated.
Key ideas
- A connection string is a credential container — it commonly contains the account name, key, and endpoint information. Treat the whole string as secret.
- Regenerating a key immediately invalidates that key. Update every dependent client to the other working key before regenerating the current one; then update clients to the newly regenerated key and regenerate the second key.
- Account-key-signed SAS is affected too. Regenerating the signing key invalidates service SAS and account SAS made with that key. It does not invalidate a user delegation SAS.
- Prefer identity-based access where supported. Microsoft Entra ID plus data-plane RBAC and managed identities avoids distributing an account key. You can also disallow Shared Key authorization after testing the workloads that rely on it.
Northwind example
Northwind discovers an old integration using key1. Maya changes that integration to key2 and verifies it works, then regenerates key1. She switches the integration to the new key1, verifies it again, and only then regenerates key2. If a client used a SAS signed with the regenerated key, it must receive a replacement SAS.
How it fits (diagram)
Exam notes
- Two keys enable a staged rotation, but clients must be changed and tested.
- Keys are broad credentials; use Entra ID and data-plane RBAC where possible.
- Regenerating an account key invalidates service and account SAS signed with it, not user delegation SAS.
Related
storage-account · sas-token · storage-network-rule · rbac · entraid
📘 Source: Microsoft Learn — Storage Access Keys
Shared Access Signature (SAS)
What it is
A shared access signature (SAS) is a signed token appended to an Azure Storage URL. It delegates only the resource, permissions, and time period encoded in the token, without giving the recipient the storage account key.
Why it exists
Use a SAS when a client needs direct, limited access to storage but does not otherwise have that permission. A SAS is a bearer token: anyone who obtains a valid URL can use it as allowed until it expires or is otherwise invalidated.
Types (compare)
- User delegation SAS — supported for Blob Storage (including Data Lake Storage endpoints), and signed using a Microsoft Entra user delegation key. Microsoft recommends it when possible because code need not hold an account key.
- Service SAS — signed with a storage account key and delegates access to a resource in one storage service: Blob, Queue, Table, or Azure Files.
- Account SAS — also signed with an account key, and can cover resources in one or more storage services and some service-level operations.
- Stored access policy — a reusable constraint set on a container, table, queue, or file share for a service SAS. It is not available for user delegation or account SAS.
What params a SAS URI carries
- Permissions, resource scope, start and expiry time, and optionally allowed IP address and protocol.
- A signature created from the issuing identity or account key. Azure Storage checks the parameters and signature on each request.
Revocation and containment
Azure Storage does not track every SAS token that has been generated, so an ad hoc SAS cannot simply be looked up and individually revoked. Plan for a leak before issuing one:
- Give the least possible permission to the fewest resources, require HTTPS, and use a short lifetime.
- A service SAS that uses a stored access policy can have that policy changed or removed to revoke its permissions.
- Regenerating the relevant storage account key invalidates service SAS and account SAS signed with that key, but may disrupt other clients. It does not invalidate a user delegation SAS.
- Monitor failures and unexpected access. For higher-risk operations, use an application service that authenticates, validates, and audits the request instead of handing out a SAS.
Northwind example
Northwind’s customer app asks its API for permission to upload one receipt. After authenticating the customer, the API issues a short-lived, HTTPS-only user delegation SAS allowing upload to that customer’s specific blob path. It does not issue read, delete, or account-wide permission. If the URL leaks, the recipient can upload during its lifetime, so Northwind investigates and replaces the token rather than assuming it can discover every copy of the URL.
How it fits (diagram)
Diagrams courtesy of Microsoft Learn / Azure docs: storage/common/storage-sas-overview
Exam notes
- A SAS is delegated, scoped access — and a bearer token.
- Prefer user delegation SAS when possible; it uses Entra credentials rather than an account key.
- Stored access policies can control service SAS only. Do not promise individual revocation for an ad hoc SAS.
- Short expiry, HTTPS, narrow scope, and least privilege reduce the damage from a leak.
Related
storage-access-keys · storage-account · storage-network-rule
📘 Source: Microsoft Learn — Sas Token
Storage firewall & network access (network rules)
What it is
Storage network rules control which network sources may reach a storage account’s public endpoint. By default, storage accounts allow connections from any network. A team can restrict the public endpoint to selected sources or disable public network access and use a private design instead.
Why it exists
Storage can hold sensitive data. Restricting the network surface reduces exposure by requiring a request to originate from an approved network source. The request must still meet its authorization requirements.
Key ideas
- Virtual-network rules: allow selected subnets through the public endpoint. The subnet needs the appropriate Storage service endpoint; use
Microsoft.Storagefor same-region storage andMicrosoft.Storage.Globalwhen cross-region access is needed, not both on the same subnet. - IP network rules: allow selected public IP ranges, commonly an on-premises egress address. They are not a substitute for identity authorization.
- Resource-instance rules: allow certain Azure resource instances that cannot be isolated through VNet or IP rules.
- Trusted-service exceptions: allow specific supported Azure services outside the configured network boundary. Enable only the exception a design needs; do not treat it as a general bypass for every Azure tool.
- Private Endpoints: create a private IP for a specific storage subresource such as Blob or File. They are a different connectivity path from public-endpoint firewall rules.
- Pair network rules with SAS, access keys, or data-plane RBAC. A request from an allowed network can still be denied for lack of authorization.
Northwind example
Northwind’s app subnet uses a Storage service endpoint, and Maya adds a virtual-network rule for that subnet on the order-document storage account. The account’s public endpoint now rejects other sources unless another rule allows them. Its warehouse system, which is outside Azure, uses an IP rule for its known egress address. Luis’s app still needs a correctly authorized identity to write a blob. For a stricter private-only architecture, the team uses a Private Endpoint and designs its private DNS resolution.
Exam notes
- Network rules are separate from authentication — they filter who can reach the endpoint, not what they may do.
- Private Endpoint gives a storage subresource a private IP; a service endpoint continues to use the storage public endpoint but limits it to allowed subnets.
- Test every dependency before restricting network access. Do not broadly enable trusted-service exceptions as a shortcut.
Related
storage-account · sas-token · storage-access-keys
📘 Source: Microsoft Learn — Azure Storage firewall rules and network access
Immutable storage (WORM) for Azure Blob
What it is
Immutable storage makes blobs write-once, read-many (WORM): data can be created and read but cannot be modified or deleted for the configured period. It’s the Azure Storage compliance feature for regulatory retention (e.g., SEC 17a-4, FINRA, HIPAA).
Why it exists
Regulators require that certain records be stored unalterable and undeletable for a fixed time (to prevent tampering or malicious deletion). Immutability guarantees even a compromised admin account can’t purge the evidence during the retention window.
Key ideas
- Two forms of policy (applied at container or account-versioning level):
- Time-based retention — hold for N days; you can extend but NOT shorten/remove until expiry.
- Legal hold — no set duration; holds until explicitly cleared (applies to all blobs in scope).
- Modes:
- Governance — enabled/disabled by privileged users (still “live” admin overrides allowed with
Set-StorageBlobImmutabilityPolicy). - Compliance — irreversible; once locked, no one (even Microsoft) can reduce or remove it. Required to meet strict regulations.
- Governance — enabled/disabled by privileged users (still “live” admin overrides allowed with
- Works on top of blob versions/snapshots: blobs within scope can’t be overwritten/deleted until the policy lifts.
- Scope: container-level policy or account-level versioning immutability.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: storage/blobs/immutable-storage-overview
Exam notes
- WORM = immutable/unalterable during retention.
- Compliance-locked is bulletproof (cannot be undone); governance allows limited privileged overrides.
- Support via time-based retention and legal hold.
- Not for file shares by default — this is a blob (and account-versioning) capability.
Related
blob-storage · storage-account · access-tier
📘 Source: Microsoft Learn — Immutable Storage
AzCopy
What it is
AzCopy is a command-line utility for copying data to/from Azure Storage — blobs, files, and tables. It’s the primary tool for migrating/copying data at scale into and between storage accounts.
azcopy copy \\path\\file.txt https://<account>.blob.core.windows.net/<container>/ --sas-token=<...>
Why it exists
The portal and Storage Explorer are fine interactively, but migrations, ETL, and synchronization need a scriptable, high-throughput, resumable CLI — AzCopy is exactly that.
Key ideas
- Copy in any direction: on-prem ↔ storage, blob ↔ blob (same or different account), across tiers/containers, file shares.
- Auth options: SAS tokens, connection strings/keys, or Microsoft Entra ID (managed identity/
--login). Best practice = Entra/Azure AD. azcopy copy(copy) vsazcopy sync(one-way mirror / incremental) —synccopies only differences (compare by name + last-modified/hash).- Features: resumable/large-file parallel transfer, recursive
--recursive,--include-pattern/--exclude, snapshot support, server-side copy vs local streaming. - Runs on Windows, Linux, macOS; also available as AzCopy in the Storage browser and in
azcopycontainer/Docker. - Used heavily with SAS and paired with Storage Explorer for GUI operations.
How it fits (diagram)
Exam notes
azcopy sync= mirror (incremental, only diffs);azcopy copy= overwrite copy. Choose sync for ongoing one-way sync.- Auth with SAS or Azure AD (Entra); keys/SAS in URI.
- For data migration into one storage account, AzCopy is the exam’s headline tool (with
azcopy sync/copy), and Storage Explorer is the GUI companion.
Related
blob-storage · azure-files · storage-access-keys · sas-token · storage-browser
📘 Source: Microsoft Learn — Azcopy
Azure Storage browser & Storage Explorer
What it is
Storage browser is the graphical way to manage storage — available in the Azure portal (storage account → Storage browser) and as the standalone Azure Storage Explorer desktop app (and in VS Code / Azure CLI). It gives a point-and-click UI over blobs, file shares, queues, and tables.
Why it exists
For interactive/one-off data management (upload a file, create a share, inspect a queue) a GUI is faster and less error-prone than scripting. Storage Explorer is the desktop tool when you need it outside the portal.
Key ideas
- Portal Storage browser: browse/save blobs (containers), file shares, queues, and tables inside any storage account — upload/download/delete, view properties, generate SAS.
- Azure Storage Explorer (desktop app): standalone cross-platform client connecting to all storage services + emulator; supports AzCopy integration for large/bulk transfers, SAS-based access, cross-account copy.
- Works alongside azcopy (CLI/bulk) — Storage Explorer = graphical, AzCopy = scriptable.
- Sign in with Azure AD / Microsoft account or via connection strings / SAS.
How it fits (diagram)
Exam notes
- Storage browser (portal) and Storage Explorer are the GUI tools; AzCopy is the CLI bulk tool.
- Check “Use Azure Storage Explorer” unit — it’s how you visually manage shares/blobs.
- Both log in with Azure AD or a SAS/connection string.
Related
storage-account · blob-storage · azure-files · azure-queues · azcopy
📘 Source: Microsoft Learn — Storage Browser