Project 11: Azure Storage Deep Dive

Overview

Master Azure Storage including blob services, file shares, access tiers, lifecycle management, and the new soft delete for blobs and containers (added in April 2025 exam update). This covers critical AZ-104 storage objectives.

Difficulty: Intermediate
Duration: 4-5 hours
Cost: ~$10-30/month (storage costs)
Exam Weight: Storage domain (15-20%)

April 2025 Exam Update

The AZ-104 exam now includes "Configure soft delete for blobs and containers" as a new objective. This project covers this topic in detail.

Architecture Diagram

┌─────────────────────────────────────────────────────────────────────────────────┐
│                        AZURE STORAGE ACCOUNT                                     │
│                        (stdeepdivedemo12345)                                     │
│                                                                                  │
│  Account Kind: StorageV2 (General Purpose v2)                                   │
│  Performance: Standard / Premium                                                 │
│  Replication: LRS / ZRS / GRS / GZRS / RA-GRS / RA-GZRS                         │
│                                                                                  │
│  ┌───────────────────────────────────────────────────────────────────────────┐  │
│  │                         BLOB SERVICE                                       │  │
│  │                                                                            │  │
│  │  ┌────────────────────────────────────────────────────────────────────┐   │  │
│  │  │                    SOFT DELETE PROTECTION                           │   │  │
│  │  │                    (NEW in April 2025 Exam)                         │   │  │
│  │  │                                                                     │   │  │
│  │  │  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐  │   │  │
│  │  │  │  Blob Soft       │  │  Container Soft  │  │  Blob Versioning │  │   │  │
│  │  │  │  Delete          │  │  Delete          │  │                  │  │   │  │
│  │  │  │                  │  │                  │  │                  │  │   │  │
│  │  │  │  Retention: 7d   │  │  Retention: 7d   │  │  Automatic       │  │   │  │
│  │  │  │  Recover deleted │  │  Recover deleted │  │  version         │  │   │  │
│  │  │  │  blobs           │  │  containers      │  │  tracking        │  │   │  │
│  │  │  └──────────────────┘  └──────────────────┘  └──────────────────┘  │   │  │
│  │  └────────────────────────────────────────────────────────────────────┘   │  │
│  │                                                                            │  │
│  │  ┌─────────────────────────────────────────────────────────────────────┐  │  │
│  │  │                       CONTAINERS                                     │  │  │
│  │  │                                                                      │  │  │
│  │  │  ┌────────────────┐  ┌────────────────┐  ┌────────────────────────┐ │  │  │
│  │  │  │  hot-data      │  │  cool-data     │  │  archive-data          │ │  │  │
│  │  │  │                │  │                │  │                        │ │  │  │
│  │  │  │  Access: Hot   │  │  Access: Cool  │  │  Access: Archive       │ │  │  │
│  │  │  │  Frequent      │  │  Infrequent    │  │  Rare access           │ │  │  │
│  │  │  │  access        │  │  access        │  │  (hours to rehydrate)  │ │  │  │
│  │  │  │                │  │                │  │                        │ │  │  │
│  │  │  │  Cost: $$$     │  │  Cost: $$      │  │  Cost: $               │ │  │  │
│  │  │  └────────────────┘  └────────────────┘  └────────────────────────┘ │  │  │
│  │  └─────────────────────────────────────────────────────────────────────┘  │  │
│  │                                                                            │  │
│  │  ┌─────────────────────────────────────────────────────────────────────┐  │  │
│  │  │                    LIFECYCLE MANAGEMENT                              │  │  │
│  │  │                                                                      │  │  │
│  │  │   Day 0      Day 30        Day 90         Day 365                   │  │  │
│  │  │     │          │             │               │                      │  │  │
│  │  │     ▼          ▼             ▼               ▼                      │  │  │
│  │  │   [Hot] ────▶ [Cool] ────▶ [Archive] ────▶ [Delete]                │  │  │
│  │  │                                                                      │  │  │
│  │  │   Rules:                                                            │  │  │
│  │  │   - Move to Cool after 30 days without access                       │  │  │
│  │  │   - Move to Archive after 90 days                                   │  │  │
│  │  │   - Delete after 365 days                                           │  │  │
│  │  └─────────────────────────────────────────────────────────────────────┘  │  │
│  └───────────────────────────────────────────────────────────────────────────┘  │
│                                                                                  │
│  ┌───────────────────────────────────────────────────────────────────────────┐  │
│  │                         FILE SERVICE                                       │  │
│  │                                                                            │  │
│  │  ┌──────────────────────┐  ┌──────────────────────────────────────────┐   │  │
│  │  │  File Share:         │  │  Mounting:                                │   │  │
│  │  │  company-files       │  │                                           │   │  │
│  │  │                      │  │  Windows: net use Z: \\storage\share      │   │  │
│  │  │  Quota: 100 GB       │  │  Linux: mount -t cifs //storage/share     │   │  │
│  │  │  Protocol: SMB 3.0   │  │  macOS: mount_smbfs //storage/share       │   │  │
│  │  │                      │  │                                           │   │  │
│  │  │  Soft Delete: 14 days│  │  Azure File Sync: Hybrid scenarios        │   │  │
│  │  └──────────────────────┘  └──────────────────────────────────────────┘   │  │
│  └───────────────────────────────────────────────────────────────────────────┘  │
│                                                                                  │
│  ┌───────────────────────────────────────────────────────────────────────────┐  │
│  │                         SECURITY                                           │  │
│  │                                                                            │  │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐   │  │
│  │  │  Access Keys │  │  SAS Tokens  │  │  Azure AD    │  │  Private     │   │  │
│  │  │              │  │              │  │  Auth        │  │  Endpoints   │   │  │
│  │  │  key1, key2  │  │  Account SAS │  │              │  │              │   │  │
│  │  │  Rotate      │  │  Service SAS │  │  RBAC roles: │  │  No public   │   │  │
│  │  │  regularly   │  │  User SAS    │  │  - Blob Data │  │  access      │   │  │
│  │  │              │  │              │  │    Owner     │  │              │   │  │
│  │  │  Store in    │  │  Time-limited│  │  - Blob Data │  │  Private     │   │  │
│  │  │  Key Vault   │  │  permissions │  │    Reader    │  │  DNS zone    │   │  │
│  │  └──────────────┘  └──────────────┘  └──────────────┘  └──────────────┘   │  │
│  └───────────────────────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────────────────────┘

Storage Redundancy Options:
┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│    LRS      │  │    ZRS      │  │    GRS      │  │   RA-GRS    │
│  3 copies   │  │  3 copies   │  │  6 copies   │  │  6 copies   │
│  1 region   │  │  3 zones    │  │  2 regions  │  │  2 regions  │
│  1 DC       │  │  1 region   │  │             │  │  Read access│
│             │  │             │  │             │  │  secondary  │
│  99.9999999%│  │ 99.9999999% │  │ 99.9999999  │  │ 99.9999999  │
│  (11 9's)   │  │ (12 9's)    │  │ (16 9's)    │  │ (16 9's)    │
└─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘

Access Tier Comparison

Tier	Storage Cost	Access Cost	Min Retention	Use Case
Hot	High	Low	None	Frequent access
Cool	Medium	Medium	30 days	Infrequent access
Cold	Low	Higher	90 days	Rare access
Archive	Lowest	Highest	180 days	Long-term backup

What You'll Learn

Configure storage account redundancy
Enable and test soft delete (NEW)
Configure blob versioning
Set up lifecycle management policies
Create and mount Azure file shares
Generate and use SAS tokens
Configure private endpoints

Phase 1: Create Storage Account

Step 1.1: Create Resource Group

bash

# Set variables
LOCATION="eastus"
RG_NAME="rg-storage-deepdive"
STORAGE_NAME="stdeepd$(date +%s | tail -c 8)"

# Create resource group
az group create \
  --name $RG_NAME \
  --location $LOCATION \
  --tags Project=StorageDeepDive Environment=Lab

echo "Resource group created"

Step 1.2: Create Storage Account with GRS

bash

# Create storage account with Geo-Redundant Storage
az storage account create \
  --resource-group $RG_NAME \
  --name $STORAGE_NAME \
  --location $LOCATION \
  --sku Standard_GRS \
  --kind StorageV2 \
  --access-tier Hot \
  --min-tls-version TLS1_2 \
  --allow-blob-public-access false \
  --https-only true

# Get storage key
STORAGE_KEY=$(az storage account keys list \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --query "[0].value" -o tsv)

echo "Storage account created: $STORAGE_NAME"

Phase 2: Configure Soft Delete (NEW Exam Objective)

Important for AZ-104

Soft delete for blobs and containers is a new exam objective added in April 2025. Make sure you understand how to configure and test it.

Step 2.1: Enable Blob Soft Delete

bash

# Enable blob soft delete with 7-day retention
az storage account blob-service-properties update \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --enable-delete-retention true \
  --delete-retention-days 7

# Verify soft delete is enabled
az storage account blob-service-properties show \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --query "deleteRetentionPolicy"

echo "Blob soft delete enabled: 7 days retention"

Step 2.2: Enable Container Soft Delete

bash

# Enable container soft delete with 7-day retention
az storage account blob-service-properties update \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --enable-container-delete-retention true \
  --container-delete-retention-days 7

# Verify container soft delete
az storage account blob-service-properties show \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --query "containerDeleteRetentionPolicy"

echo "Container soft delete enabled: 7 days retention"

Step 2.3: Enable Blob Versioning

bash

# Enable blob versioning
az storage account blob-service-properties update \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --enable-versioning true

# Verify versioning
az storage account blob-service-properties show \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --query "isVersioningEnabled"

echo "Blob versioning enabled"

Step 2.4: Test Blob Soft Delete

bash

# Create a test container
az storage container create \
  --name test-softdelete \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY

# Upload a test file
echo "Important data - version 1" > testfile.txt
az storage blob upload \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name test-softdelete \
  --name testfile.txt \
  --file testfile.txt

# Verify file exists
az storage blob list \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name test-softdelete \
  --output table

# DELETE the blob
az storage blob delete \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name test-softdelete \
  --name testfile.txt

echo "Blob deleted"

# List deleted blobs (soft deleted)
az storage blob list \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name test-softdelete \
  --include d \
  --output table

# RECOVER the deleted blob
az storage blob undelete \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name test-softdelete \
  --name testfile.txt

echo "Blob recovered from soft delete!"

# Verify recovery
az storage blob list \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name test-softdelete \
  --output table

Step 2.5: Test Container Soft Delete

bash

# DELETE the container
az storage container delete \
  --name test-softdelete \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY

echo "Container deleted"

# List deleted containers
az storage container list \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --include-deleted \
  --query "[?deleted==true]" \
  --output table

# RECOVER the deleted container
# Note: You need the version ID of the deleted container
DELETED_VERSION=$(az storage container list \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --include-deleted \
  --query "[?name=='test-softdelete'].version" -o tsv)

az storage container restore \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --name test-softdelete \
  --deleted-version $DELETED_VERSION

echo "Container recovered from soft delete!"

# Verify container and its blobs are restored
az storage container list \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --output table

Phase 3: Configure Access Tiers

Step 3.1: Create Containers for Different Tiers

bash

# Create containers
az storage container create \
  --name hot-data \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY

az storage container create \
  --name cool-data \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY

az storage container create \
  --name archive-data \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY

echo "Containers created"

Step 3.2: Upload Blobs with Different Tiers

bash

# Create test files
echo "Hot tier data - accessed frequently" > hot-data.txt
echo "Cool tier data - accessed monthly" > cool-data.txt
echo "Archive tier data - long-term storage" > archive-data.txt

# Upload with Hot tier (default)
az storage blob upload \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name hot-data \
  --name hot-data.txt \
  --file hot-data.txt \
  --tier Hot

# Upload with Cool tier
az storage blob upload \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name cool-data \
  --name cool-data.txt \
  --file cool-data.txt \
  --tier Cool

# Upload with Archive tier
az storage blob upload \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name archive-data \
  --name archive-data.txt \
  --file archive-data.txt \
  --tier Archive

echo "Blobs uploaded with different access tiers"

Step 3.3: Change Blob Access Tier

bash

# Change blob from Hot to Cool
az storage blob set-tier \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name hot-data \
  --name hot-data.txt \
  --tier Cool

# Verify tier change
az storage blob show \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name hot-data \
  --name hot-data.txt \
  --query "properties.blobTier" -o tsv

Step 3.4: Rehydrate from Archive

bash

# Rehydrate archive blob to Hot tier
# Note: This takes hours to complete
az storage blob set-tier \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name archive-data \
  --name archive-data.txt \
  --tier Hot \
  --rehydrate-priority High

# Check rehydration status
az storage blob show \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name archive-data \
  --name archive-data.txt \
  --query "properties.rehydrationStatus" -o tsv

echo "Rehydration initiated - this takes hours to complete"

Phase 4: Lifecycle Management

Step 4.1: Create Lifecycle Policy

bash

# Create lifecycle policy JSON
cat > lifecycle-policy.json << 'EOF'
{
  "rules": [
    {
      "enabled": true,
      "name": "move-to-cool",
      "type": "Lifecycle",
      "definition": {
        "actions": {
          "baseBlob": {
            "tierToCool": {
              "daysAfterModificationGreaterThan": 30
            }
          }
        },
        "filters": {
          "blobTypes": ["blockBlob"],
          "prefixMatch": ["hot-data/"]
        }
      }
    },
    {
      "enabled": true,
      "name": "move-to-archive",
      "type": "Lifecycle",
      "definition": {
        "actions": {
          "baseBlob": {
            "tierToArchive": {
              "daysAfterModificationGreaterThan": 90
            }
          }
        },
        "filters": {
          "blobTypes": ["blockBlob"],
          "prefixMatch": ["cool-data/"]
        }
      }
    },
    {
      "enabled": true,
      "name": "delete-old-data",
      "type": "Lifecycle",
      "definition": {
        "actions": {
          "baseBlob": {
            "delete": {
              "daysAfterModificationGreaterThan": 365
            }
          }
        },
        "filters": {
          "blobTypes": ["blockBlob"],
          "prefixMatch": ["archive-data/"]
        }
      }
    },
    {
      "enabled": true,
      "name": "delete-old-versions",
      "type": "Lifecycle",
      "definition": {
        "actions": {
          "version": {
            "delete": {
              "daysAfterCreationGreaterThan": 90
            }
          }
        },
        "filters": {
          "blobTypes": ["blockBlob"]
        }
      }
    },
    {
      "enabled": true,
      "name": "delete-old-snapshots",
      "type": "Lifecycle",
      "definition": {
        "actions": {
          "snapshot": {
            "delete": {
              "daysAfterCreationGreaterThan": 30
            }
          }
        },
        "filters": {
          "blobTypes": ["blockBlob"]
        }
      }
    }
  ]
}
EOF

# Apply lifecycle policy
az storage account management-policy create \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --policy @lifecycle-policy.json

echo "Lifecycle management policy applied"

Step 4.2: View Lifecycle Policy

bash

# Get current policy
az storage account management-policy show \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --output json

Phase 5: Azure File Shares

bash

# Create file share with 100 GB quota
az storage share create \
  --name company-files \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --quota 100

# Enable soft delete for file shares
az storage account file-service-properties update \
  --resource-group $RG_NAME \
  --account-name $STORAGE_NAME \
  --enable-delete-retention true \
  --delete-retention-days 14

echo "File share created with 14-day soft delete"

Step 5.2: Upload Files

bash

# Create directory
az storage directory create \
  --share-name company-files \
  --name "documents" \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY

# Upload file
echo "Company document content" > company-doc.txt
az storage file upload \
  --share-name company-files \
  --source company-doc.txt \
  --path "documents/company-doc.txt" \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY

echo "File uploaded to Azure Files"

Step 5.3: Generate Mount Commands

bash

# Generate mount script for Windows
echo "=== Windows Mount Command ==="
echo "cmdkey /add:$STORAGE_NAME.file.core.windows.net /user:AZURE\\$STORAGE_NAME /pass:$STORAGE_KEY"
echo "net use Z: \\\\$STORAGE_NAME.file.core.windows.net\\company-files /persistent:yes"

echo ""
echo "=== Linux Mount Command ==="
echo "sudo mkdir /mnt/company-files"
echo "sudo mount -t cifs //$STORAGE_NAME.file.core.windows.net/company-files /mnt/company-files -o vers=3.0,username=$STORAGE_NAME,password=$STORAGE_KEY,dir_mode=0777,file_mode=0777"

echo ""
echo "=== macOS Mount Command ==="
echo "mkdir ~/company-files"
echo "mount_smbfs //AZURE\\;$STORAGE_NAME:$STORAGE_KEY@$STORAGE_NAME.file.core.windows.net/company-files ~/company-files"

Phase 6: Security - SAS Tokens

Step 6.1: Generate Account SAS

bash

# Generate account SAS with limited permissions
EXPIRY=$(date -u -d "+1 day" +%Y-%m-%dT%H:%MZ)

ACCOUNT_SAS=$(az storage account generate-sas \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --services b \
  --resource-types sco \
  --permissions rl \
  --expiry $EXPIRY \
  --https-only \
  -o tsv)

echo "Account SAS Token (valid for 1 day, read-only):"
echo "?$ACCOUNT_SAS"

Step 6.2: Generate Container SAS

bash

# Generate container SAS
CONTAINER_SAS=$(az storage container generate-sas \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --name hot-data \
  --permissions rl \
  --expiry $EXPIRY \
  --https-only \
  -o tsv)

echo "Container SAS Token:"
echo "https://$STORAGE_NAME.blob.core.windows.net/hot-data?$CONTAINER_SAS"

Step 6.3: Generate Blob SAS

bash

# Generate blob SAS with download permission
BLOB_SAS=$(az storage blob generate-sas \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name hot-data \
  --name hot-data.txt \
  --permissions r \
  --expiry $EXPIRY \
  --https-only \
  --full-uri \
  -o tsv)

echo "Blob SAS URL (direct download link):"
echo "$BLOB_SAS"

# Test SAS token
curl -o downloaded.txt "$BLOB_SAS"
cat downloaded.txt

Step 6.4: Create Stored Access Policy

bash

# Create stored access policy (allows revoking SAS tokens)
az storage container policy create \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name hot-data \
  --name read-policy \
  --permissions r \
  --expiry $EXPIRY

# Generate SAS from policy (can be revoked by deleting policy)
POLICY_SAS=$(az storage blob generate-sas \
  --account-name $STORAGE_NAME \
  --account-key $STORAGE_KEY \
  --container-name hot-data \
  --name hot-data.txt \
  --policy-name read-policy \
  --full-uri \
  -o tsv)

echo "Policy-based SAS URL:"
echo "$POLICY_SAS"

Phase 7: Private Endpoint for Storage

Step 7.1: Create VNet

bash

# Create VNet
az network vnet create \
  --resource-group $RG_NAME \
  --name vnet-storage \
  --address-prefix 10.0.0.0/16 \
  --subnet-name snet-private \
  --subnet-prefix 10.0.1.0/24 \
  --location $LOCATION

# Disable private endpoint network policies
az network vnet subnet update \
  --resource-group $RG_NAME \
  --vnet-name vnet-storage \
  --name snet-private \
  --disable-private-endpoint-network-policies true

Step 7.2: Create Private Endpoint

bash

# Get storage account ID
STORAGE_ID=$(az storage account show \
  --resource-group $RG_NAME \
  --name $STORAGE_NAME \
  --query id -o tsv)

# Create private endpoint for blob service
az network private-endpoint create \
  --resource-group $RG_NAME \
  --name pe-storage-blob \
  --vnet-name vnet-storage \
  --subnet snet-private \
  --private-connection-resource-id $STORAGE_ID \
  --group-id blob \
  --connection-name StorageBlobConnection \
  --location $LOCATION

echo "Private endpoint created for blob storage"

Step 7.3: Disable Public Access

bash

# Disable public blob access
az storage account update \
  --resource-group $RG_NAME \
  --name $STORAGE_NAME \
  --default-action Deny

echo "Public access disabled - storage only accessible via private endpoint"

Exam Summary: Key Concepts

Topic	Key Points
Soft Delete	Blob: 1-365 days, Container: 1-365 days, recoverable
Versioning	Automatic version tracking, restore previous versions
Access Tiers	Hot > Cool > Cold > Archive (cost vs access)
Lifecycle	Automated tier transitions and deletion
SAS Types	Account, Service, User Delegation
Redundancy	LRS < ZRS < GRS < GZRS (durability)

Cleanup

bash

# Cleanup local files
rm -f testfile.txt hot-data.txt cool-data.txt archive-data.txt
rm -f company-doc.txt downloaded.txt lifecycle-policy.json

# Delete resource group
az group delete --name $RG_NAME --yes --no-wait

echo "Cleanup initiated"

Key Takeaways

Soft Delete: Essential for data protection, now on exam
Versioning: Complements soft delete for full protection
Lifecycle Management: Automate tier transitions
SAS Tokens: Time-limited, scoped access
Private Endpoints: Secure, private access to storage
File Shares: SMB-compatible, mountable storage

Project 11: Azure Storage Deep Dive ​

Overview ​

Architecture Diagram ​

Access Tier Comparison ​

What You'll Learn ​

Phase 1: Create Storage Account ​

Step 1.1: Create Resource Group ​

Step 1.2: Create Storage Account with GRS ​

Phase 2: Configure Soft Delete (NEW Exam Objective) ​

Step 2.1: Enable Blob Soft Delete ​

Step 2.2: Enable Container Soft Delete ​

Step 2.3: Enable Blob Versioning ​

Step 2.4: Test Blob Soft Delete ​

Step 2.5: Test Container Soft Delete ​

Phase 3: Configure Access Tiers ​

Step 3.1: Create Containers for Different Tiers ​

Step 3.2: Upload Blobs with Different Tiers ​

Step 3.3: Change Blob Access Tier ​

Step 3.4: Rehydrate from Archive ​

Phase 4: Lifecycle Management ​

Step 4.1: Create Lifecycle Policy ​

Step 4.2: View Lifecycle Policy ​

Phase 5: Azure File Shares ​

Step 5.1: Create File Share ​

Step 5.2: Upload Files ​

Step 5.3: Generate Mount Commands ​

Phase 6: Security - SAS Tokens ​

Step 6.1: Generate Account SAS ​

Step 6.2: Generate Container SAS ​

Step 6.3: Generate Blob SAS ​

Step 6.4: Create Stored Access Policy ​

Phase 7: Private Endpoint for Storage ​

Step 7.1: Create VNet ​

Step 7.2: Create Private Endpoint ​

Step 7.3: Disable Public Access ​

Exam Summary: Key Concepts ​

Cleanup ​

Key Takeaways ​

Project 11: Azure Storage Deep Dive

Overview

Architecture Diagram

Access Tier Comparison

What You'll Learn

Phase 1: Create Storage Account

Step 1.1: Create Resource Group

Step 1.2: Create Storage Account with GRS

Phase 2: Configure Soft Delete (NEW Exam Objective)

Step 2.1: Enable Blob Soft Delete

Step 2.2: Enable Container Soft Delete

Step 2.3: Enable Blob Versioning

Step 2.4: Test Blob Soft Delete

Step 2.5: Test Container Soft Delete

Phase 3: Configure Access Tiers

Step 3.1: Create Containers for Different Tiers

Step 3.2: Upload Blobs with Different Tiers

Step 3.3: Change Blob Access Tier

Step 3.4: Rehydrate from Archive

Phase 4: Lifecycle Management

Step 4.1: Create Lifecycle Policy

Step 4.2: View Lifecycle Policy

Phase 5: Azure File Shares

Step 5.1: Create File Share

Step 5.2: Upload Files

Step 5.3: Generate Mount Commands

Phase 6: Security - SAS Tokens

Step 6.1: Generate Account SAS

Step 6.2: Generate Container SAS

Step 6.3: Generate Blob SAS

Step 6.4: Create Stored Access Policy

Phase 7: Private Endpoint for Storage

Step 7.1: Create VNet

Step 7.2: Create Private Endpoint

Step 7.3: Disable Public Access

Exam Summary: Key Concepts

Cleanup

Key Takeaways