Azure Queue & Table Storage

Azure Queue Storage

• Azure Queue Storage is a messaging service that allows applications to communicate asynchronously by sending and receiving messages via queues.

Key Concepts

Concept	Description
Queue	A container that holds messages
Message	A unit of data, up to 64 KB in size
Visibility Timeout	Time a message is hidden after being read
TTL (Time-to-Live)	How long a message lives (default: 7 days, max: 7 days)
Dequeue Count	How many times a message has been read
Poison Message	A message that repeatedly fails processing

How Queue Storage Works

Producer App  →  [Send Message]  →  Queue  →  [Receive Message]  →  Consumer App
                                                      ↓
                                          [Process & Delete Message]

1. Producer sends a message to the queue
2. Consumer receives the message (hidden from others during visibility timeout)
3. Consumer processes the message
4. Consumer deletes the message after successful processing
5. If not deleted → message reappears after timeout (retry)

Queue Storage Features

• Simple FIFO (approximate ordering)
• Up to 500 TB per storage account
• Millions of messages supported
• REST API, SDKs (.NET, Python, Java, JS)
• Trigger Azure Functions automatically
• Supports SAS (Shared Access Signatures) for security

Common Use Cases

• Decoupling microservices
• Email/notification job queues
• Image/video processing pipelines
• Order processing systems
• Background task scheduling
• Retry logic with dead-letter handling

---

Azure Table Storage

• Azure Table Storage is a NoSQL key-value store for storing large amounts of structured, schema-less data in tables.

Key Concepts

Concept	Description
Table	A collection of entities (like a database table)
Entity	A single row with up to 255 properties
PartitionKey	Groups related entities; drives scalability
RowKey	Unique identifier within a partition
Primary Key	PartitionKey + RowKey (must be unique)
Property	A name-value pair (column) in an entity
Timestamp	Auto-managed last-modified time

Data Model

Table: Users
┌──────────────┬──────────┬────────────┬──────────┬─────────┐
│ PartitionKey │ RowKey   │ Name       │ Age      │ City    │
├──────────────┼──────────┼────────────┼──────────┼─────────┤
│ India        │ user001  │ Ravi       │ 30       │ Hyderabad│
│ India        │ user002  │ Priya      │ 28       │ Mumbai  │
│ USA          │ user003  │ John       │ 35       │ New York│
│ USA          │ user004  │ Sarah      │ 26       │ Chicago │
└──────────────┴──────────┴────────────┴──────────┴─────────┘

Supported Data Types

Type	Example
String	"Hyderabad"
Int32 / Int64	30, 1000000
Double	3.14
Boolean	true / false
DateTime	2025-01-01T00:00:00Z
Binary	Raw byte data
Guid	550e8400-e29b-41d4-a716-...

Table Storage Features

• Schema-less (each entity can have different properties)
• Petabyte-scale storage
• OData protocol query support
• Automatic load balancing by PartitionKey
• Strong consistency within a partition
• REST API and multiple SDK support
• Low cost (~$0.045 per GB/month)

Common Use Cases

• User profiles and preferences
• Application metadata and configuration
• Audit logs and event history
• Game leaderboards and player data
• IoT device telemetry data
• Product catalogs and inventory

Azure CLI Commands

Create storage account

az storage account create
–name mystorageaccount
–resource-group MyResourceGroup
–location eastus
–sku Standard_LRS

Get connection string

az storage account show-connection-string
–name mystorageaccount
–resource-group MyResourceGroup

### Queue Storage CLI

```bash
# Create queue
az storage queue create \
  --name my-queue \
  --account-name mystorageaccount

# Send message
az storage message put \
  --queue-name my-queue \
  --content "Hello, Azure Queue!" \
  --account-name mystorageaccount

# Peek messages (don't remove)
az storage message peek \
  --queue-name my-queue \
  --num-messages 5 \
  --account-name mystorageaccount

# Receive messages (makes them invisible)
az storage message get \
  --queue-name my-queue \
  --account-name mystorageaccount

# Delete a message
az storage message delete \
  --queue-name my-queue \
  --id <message-id> \
  --pop-receipt <pop-receipt> \
  --account-name mystorageaccount

# Delete queue
az storage queue delete \
  --name my-queue \
  --account-name mystorageaccount

Table Storage CLI

# Create table
az storage table create \
  --name Users \
  --account-name mystorageaccount

# Insert entity
az storage entity insert \
  --table-name qtdemo \
  --entity PartitionKey=India RowKey=user001 Name=Ravi Age=30 City=Hyderabad \
  --account-name demo2220596

# Query all entities
az storage entity query \
  --table-name qtdemo \
  --account-name demo2220596

# Query with filter
az storage entity query \
  --table-name Users \
  --filter "PartitionKey eq 'India'" \
  --account-name mystorageaccount

# Show one entity
az storage entity show \
  --table-name Users \
  --partition-key India \
  --row-key user001 \
  --account-name mystorageaccount

# Delete entity
az storage entity delete \
  --table-name Users \
  --partition-key India \
  --row-key user001 \
  --account-name mystorageaccount

# Delete table
az storage table delete \
  --name Users \
  --account-name mystorageaccount

Code Examples

Python — Queue Storage

from azure.storage.queue import QueueServiceClient

connection_string = "DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=mykey;"
queue_service = QueueServiceClient.from_connection_string(connection_string)

# Create a queue
queue_client = queue_service.create_queue("my-queue")

# Send a message
queue_client.send_message("Process order #1234")

# Peek (view without removing)
peeked = queue_client.peek_messages(max_messages=5)
for msg in peeked:
    print(f"Peeked: {msg.content}")

#  Receive and process
messages = queue_client.receive_messages(max_messages=10, visibility_timeout=30)
for msg in messages:
    print(f"Processing: {msg.content}")
    queue_client.delete_message(msg)  # Delete after processing

# Delete the queue
queue_client.delete_queue()

Python — Table Storage

from azure.data.tables import TableServiceClient, TableEntity

connection_string = "DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=mykey;"
table_service = TableServiceClient.from_connection_string(connection_string)

# Create table
table_client = table_service.create_table_if_not_exists("Users")

# Insert entity
entity = {
    "PartitionKey": "India",
    "RowKey": "user001",
    "Name": "Ravi",
    "Age": 30,
    "City": "Hyderabad"
}
table_client.upsert_entity(entity)

# Get a specific entity
user = table_client.get_entity(partition_key="India", row_key="user001")
print(user["Name"])  # Ravi

# Query with filter
entities = table_client.query_entities("PartitionKey eq 'India'")
for e in entities:
    print(e["Name"], e["City"])

# Delete entity
table_client.delete_entity(partition_key="India", row_key="user001")