Azure Tables (How It Works For Developers)

In the vast landscape of cloud computing, data storage plays a pivotal role in shaping the architecture and scalability of modern applications. Azure Table Storage, a fully managed NoSQL data store provided by Microsoft Azure, offers developers a versatile solution for storing structured data in the cloud. Let's embark on a journey to explore the capabilities, use cases, and benefits of Azure Table Storage.

Understanding Azure Table Storage

Azure Table Storage is a cloud-based NoSQL database service that provides schema-less storage of structured data. Azure Tables offer a key-value pair-based data model, where each entity is uniquely identified by a partition key and a row key. This design enables efficient querying and retrieval of data, making it ideal for scenarios requiring fast access to large datasets.

If you're trying to decide between either Azure Table Storage or a relational database for managing your structured data, Azure Table Storage's ability to handle large datasets and integration with the Azure Ecosystem makes Azure Table Storage handy to have in your developer's toolkit.

Key Features and Capabilities

1. Schema-less Design: Unlike traditional relational databases, Azure Table Storage does not enforce a schema on the data. This flexibility allows developers to store entities with varying structures within the same table, facilitating agile development and accommodating evolving data requirements.

2. Scalability and Performance: Azure Table Storage is designed for scalability, capable of handling massive amounts of data with ease. It automatically scales to accommodate increasing workloads and provides predictable performance, making it suitable for high-throughput applications and scenarios requiring low-latency data access.

3. Partitioning and Load Balancing: Data in Azure Table Storage is partitioned based on the partition key, allowing for efficient distribution of data across multiple storage nodes. This partitioning strategy enables horizontal scalability and load balancing, ensuring optimal performance and resource utilization.

4. Secondary Indexes: While Azure Table Storage primarily uses the partition key and row key for data retrieval, it also supports secondary indexes through the use of composite keys and query projections. This feature enables developers to perform efficient range queries and filter data based on secondary attributes, enhancing the flexibility of data access patterns.

5. Integration with Azure Ecosystem: Azure Table Storage seamlessly integrates with other Azure services, such as Azure Functions, Azure Cosmos DB, and Azure Logic Apps, enabling developers to build end-to-end solutions with ease. Whether it's processing data streams with serverless functions or analyzing data with advanced analytics tools, Azure Table Storage serves as a foundational component for building scalable and resilient applications.

Use Cases

Azure Table Storage caters to a wide range of use cases across various industries, including:

1. Internet of Things (IoT): Azure Table Storage is well-suited for storing telemetry data from IoT devices, enabling real-time data ingestion, analysis, and visualization. Its scalability and performance make it ideal for handling the massive volumes of data generated by IoT deployments.

2. Content Management: For applications requiring structured storage of content metadata, such as blogs, articles, and user-generated content, Azure Table Storage provides a cost-effective and scalable solution. Its schema-less design allows for flexible schema evolution, accommodating changes in content structure over time.

3. Session State Management: Azure Table Storage can be used to store session state data for web applications, providing a distributed and scalable session management solution. By offloading the session state to Azure Table Storage, developers can achieve improved scalability, fault tolerance, and session affinity in load-balanced environments.

4. Distributed Systems: In distributed systems architectures, Azure Table Storage serves as a foundational data store for maintaining shared state and coordination between components. Its partitioning and scalability features make it well-suited for scenarios requiring distributed caching, configuration management, and coordination among microservices.

Introduction to IronPDF

IronPDF is a C# PDF library that allows generating, managing, and extracting content from PDF documents in .NET projects. Here are some key features:

1. HTML to PDF Conversion:

   • Convert HTML, CSS, and JavaScript content to PDF Documents.
   • Chrome Rendering Engine for pixel-perfect PDFs.
   • Generate PDFs from URLs, HTML files, or HTML strings as input.

2. Image and Content Conversion:

   • Convert images to and from PDFs.
   • Extract text and images from existing PDF documents.
   • Support for various image formats like JPG, PNG, etc.

3. Editing and Manipulation:

   • Set properties, security, and permissions for PDFs.
   • Add digital signatures.
   • Edit metadata and revision history.
4. Cross-Platform Support:
   • Works with .NET Core (8, 7, 6, 5, and 3.1+), .NET Standard (2.0+), and .NET Framework (4.6.2+).
   • Compatible with Windows, Linux, and macOS.
   • Available on NuGet for easy installation.

Generate a PDF Document Using IronPDF And Azure Tables

To start, create a console application using Visual Studio as below:

Provide Project Name:

Provide .NET Version:

Install the IronPDF package from the NuGet Package Manager:

For accessing the Azure Tables library, we will use the Azure Tables client library called Azure.Data.Tables, which can be found in the NuGet Package Manager. The Azure Table Service client provides functionality for interacting with Azure Table Storage.

Create an Azure Storage account to get started with Azure Tables:

Click review and create. Enter the code below into your program to use Azure Tables to generate a PDF document.

using Azure;
using Azure.Data.Tables;
using Azure.Data.Tables.Models;
using IronPdf;
using System;
using System.Linq;
using System.Threading.Tasks;

namespace CodeSample
{
    public static class AzureTableDemo
    {
        public static async Task Execute()
        {
            var tableName = "IronDemo";
            var connectionString = "DefaultEndpointsProtocol=https;AccountName=irondemo;AccountKey=9Pe6LJlkjA721VgWvSuRCMk+WJR5/kFoyPtR1ewjRsNbGJNJOmWYhCB32fakANmWeAcfyIg++iHl+AStDNYlGw==;EndpointSuffix=core.windows.net";
            Console.WriteLine("Demo IronPDF with Azure.Data.Tables");

            // Enable web security for PDF rendering
            Installation.EnableWebSecurity = true;

            // Instantiate PDF renderer
            var renderer = new ChromePdfRenderer();

            // HTML content for the PDF
            var content = "<h1>Demo IronPDF with Azure.Data.Tables</h1>";

            // Create a TableServiceClient using the connection string
            content += "<h2>Create TableServiceClient</h2>";
            var serviceClient = new TableServiceClient(connectionString);
            content += "<p>var serviceClient = new TableServiceClient(connectionString);</p>";

            // Create the table if it does not exist
            content += "<h2>Create Table</h2>";
            TableItem table = await serviceClient.CreateTableIfNotExistsAsync(tableName);
            Console.WriteLine($"Created table: {table.Name}.");
            content += $"<p>Created table: {table.Name}.</p>";

            // Placeholder for delete table logic
            content += "<h2>Deletes If Required</h2>";
            // serviceClient.DeleteTable(tableName);
            content += "<p>serviceClient.DeleteTable(tableName);</p>";

            // Get a client reference to interact with the table
            content += "<h2>Get Table Client</h2>";
            var tableClient = serviceClient.GetTableClient(tableName);
            content += "<p>var tableClient = serviceClient.GetTableClient(tableName);</p>";

            // Define and add a new entity to the table
            content += "<h2>Add Table Entity</h2>";
            var tableEntity = new TableEntity { { "Book", "Awesome IronPDF Package" }, { "Price", 5.00 }, { "Quantity", 21 } };
            tableEntity.PartitionKey = tableEntity["Book"].ToString();
            tableEntity.RowKey = tableEntity["Price"].ToString();
            content += "<p>new TableEntity() { { \"Book\", \"Awesome IronPDF Package\" }, { \"Price\", 5.00 }, { \"Quantity\", 21 } }</p>";

            content += $"<p>tableEntity.PartitionKey = {tableEntity["Book"]}</p>";
            content += $"<p>tableEntity.RowKey = {tableEntity["Price"]}</p>";

            Console.WriteLine($"{tableEntity.RowKey}: {tableEntity["Book"]} costs ${tableEntity.GetDouble("Price")}.");
            content += $"<p>{tableEntity.RowKey}: {tableEntity["Book"]} costs ${tableEntity.GetDouble("Price")}</p>";

            // Add the entity to the table
            tableClient.AddEntity(tableEntity);
            content += "<p>Entity added.</p>";

            // Query the table
            content += "<h2>Query Table</h2>";
            Pageable<TableEntity> queryResultsFilter = tableClient.Query<TableEntity>(filter: $"PartitionKey eq '{tableEntity.PartitionKey}'");
            content += "<p>Using tableClient.Query<TableEntity></p>";

            // Iterate and display queried entities
            foreach (TableEntity qEntity in queryResultsFilter)
            {
                content += $"<p>{qEntity.GetString("Book")}: {qEntity.GetDouble("Price")}</p>";
                Console.WriteLine($"{qEntity.GetString("Book")}: {qEntity.GetDouble("Price")}");
            }
            Console.WriteLine($"The query returned {queryResultsFilter.Count()} entities.");
            content += $"<p>The query returned {queryResultsFilter.Count()} entities.</p>";

            // Render HTML content as PDF
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Save the PDF to a file
            pdf.SaveAs("AwesomeAzureDataTables.pdf");
        }
    }
}

using Azure;
using Azure.Data.Tables;
using Azure.Data.Tables.Models;
using IronPdf;
using System;
using System.Linq;
using System.Threading.Tasks;

namespace CodeSample
{
    public static class AzureTableDemo
    {
        public static async Task Execute()
        {
            var tableName = "IronDemo";
            var connectionString = "DefaultEndpointsProtocol=https;AccountName=irondemo;AccountKey=9Pe6LJlkjA721VgWvSuRCMk+WJR5/kFoyPtR1ewjRsNbGJNJOmWYhCB32fakANmWeAcfyIg++iHl+AStDNYlGw==;EndpointSuffix=core.windows.net";
            Console.WriteLine("Demo IronPDF with Azure.Data.Tables");

            // Enable web security for PDF rendering
            Installation.EnableWebSecurity = true;

            // Instantiate PDF renderer
            var renderer = new ChromePdfRenderer();

            // HTML content for the PDF
            var content = "<h1>Demo IronPDF with Azure.Data.Tables</h1>";

            // Create a TableServiceClient using the connection string
            content += "<h2>Create TableServiceClient</h2>";
            var serviceClient = new TableServiceClient(connectionString);
            content += "<p>var serviceClient = new TableServiceClient(connectionString);</p>";

            // Create the table if it does not exist
            content += "<h2>Create Table</h2>";
            TableItem table = await serviceClient.CreateTableIfNotExistsAsync(tableName);
            Console.WriteLine($"Created table: {table.Name}.");
            content += $"<p>Created table: {table.Name}.</p>";

            // Placeholder for delete table logic
            content += "<h2>Deletes If Required</h2>";
            // serviceClient.DeleteTable(tableName);
            content += "<p>serviceClient.DeleteTable(tableName);</p>";

            // Get a client reference to interact with the table
            content += "<h2>Get Table Client</h2>";
            var tableClient = serviceClient.GetTableClient(tableName);
            content += "<p>var tableClient = serviceClient.GetTableClient(tableName);</p>";

            // Define and add a new entity to the table
            content += "<h2>Add Table Entity</h2>";
            var tableEntity = new TableEntity { { "Book", "Awesome IronPDF Package" }, { "Price", 5.00 }, { "Quantity", 21 } };
            tableEntity.PartitionKey = tableEntity["Book"].ToString();
            tableEntity.RowKey = tableEntity["Price"].ToString();
            content += "<p>new TableEntity() { { \"Book\", \"Awesome IronPDF Package\" }, { \"Price\", 5.00 }, { \"Quantity\", 21 } }</p>";

            content += $"<p>tableEntity.PartitionKey = {tableEntity["Book"]}</p>";
            content += $"<p>tableEntity.RowKey = {tableEntity["Price"]}</p>";

            Console.WriteLine($"{tableEntity.RowKey}: {tableEntity["Book"]} costs ${tableEntity.GetDouble("Price")}.");
            content += $"<p>{tableEntity.RowKey}: {tableEntity["Book"]} costs ${tableEntity.GetDouble("Price")}</p>";

            // Add the entity to the table
            tableClient.AddEntity(tableEntity);
            content += "<p>Entity added.</p>";

            // Query the table
            content += "<h2>Query Table</h2>";
            Pageable<TableEntity> queryResultsFilter = tableClient.Query<TableEntity>(filter: $"PartitionKey eq '{tableEntity.PartitionKey}'");
            content += "<p>Using tableClient.Query<TableEntity></p>";

            // Iterate and display queried entities
            foreach (TableEntity qEntity in queryResultsFilter)
            {
                content += $"<p>{qEntity.GetString("Book")}: {qEntity.GetDouble("Price")}</p>";
                Console.WriteLine($"{qEntity.GetString("Book")}: {qEntity.GetDouble("Price")}");
            }
            Console.WriteLine($"The query returned {queryResultsFilter.Count()} entities.");
            content += $"<p>The query returned {queryResultsFilter.Count()} entities.</p>";

            // Render HTML content as PDF
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Save the PDF to a file
            pdf.SaveAs("AwesomeAzureDataTables.pdf");
        }
    }
}

Imports Azure
Imports Azure.Data.Tables
Imports Azure.Data.Tables.Models
Imports IronPdf
Imports System
Imports System.Linq
Imports System.Threading.Tasks

Namespace CodeSample
	Public Module AzureTableDemo
		Public Async Function Execute() As Task
			Dim tableName = "IronDemo"
			Dim connectionString = "DefaultEndpointsProtocol=https;AccountName=irondemo;AccountKey=9Pe6LJlkjA721VgWvSuRCMk+WJR5/kFoyPtR1ewjRsNbGJNJOmWYhCB32fakANmWeAcfyIg++iHl+AStDNYlGw==;EndpointSuffix=core.windows.net"
			Console.WriteLine("Demo IronPDF with Azure.Data.Tables")

			' Enable web security for PDF rendering
			Installation.EnableWebSecurity = True

			' Instantiate PDF renderer
			Dim renderer = New ChromePdfRenderer()

			' HTML content for the PDF
			Dim content = "<h1>Demo IronPDF with Azure.Data.Tables</h1>"

			' Create a TableServiceClient using the connection string
			content &= "<h2>Create TableServiceClient</h2>"
			Dim serviceClient = New TableServiceClient(connectionString)
			content &= "<p>var serviceClient = new TableServiceClient(connectionString);</p>"

			' Create the table if it does not exist
			content &= "<h2>Create Table</h2>"
			Dim table As TableItem = Await serviceClient.CreateTableIfNotExistsAsync(tableName)
			Console.WriteLine($"Created table: {table.Name}.")
			content &= $"<p>Created table: {table.Name}.</p>"

			' Placeholder for delete table logic
			content &= "<h2>Deletes If Required</h2>"
			' serviceClient.DeleteTable(tableName);
			content &= "<p>serviceClient.DeleteTable(tableName);</p>"

			' Get a client reference to interact with the table
			content &= "<h2>Get Table Client</h2>"
			Dim tableClient = serviceClient.GetTableClient(tableName)
			content &= "<p>var tableClient = serviceClient.GetTableClient(tableName);</p>"

			' Define and add a new entity to the table
			content &= "<h2>Add Table Entity</h2>"
			Dim tableEntity As New TableEntity From {
				{ "Book", "Awesome IronPDF Package" },
				{ "Price", 5.00 },
				{ "Quantity", 21 }
			}
			tableEntity.PartitionKey = tableEntity("Book").ToString()
			tableEntity.RowKey = tableEntity("Price").ToString()
			content &= "<p>new TableEntity() { { ""Book"", ""Awesome IronPDF Package"" }, { ""Price"", 5.00 }, { ""Quantity"", 21 } }</p>"

			content &= $"<p>tableEntity.PartitionKey = {tableEntity("Book")}</p>"
			content &= $"<p>tableEntity.RowKey = {tableEntity("Price")}</p>"

			Console.WriteLine($"{tableEntity.RowKey}: {tableEntity("Book")} costs ${tableEntity.GetDouble("Price")}.")
			content &= $"<p>{tableEntity.RowKey}: {tableEntity("Book")} costs ${tableEntity.GetDouble("Price")}</p>"

			' Add the entity to the table
			tableClient.AddEntity(tableEntity)
			content &= "<p>Entity added.</p>"

			' Query the table
			content &= "<h2>Query Table</h2>"
			Dim queryResultsFilter As Pageable(Of TableEntity) = tableClient.Query(Of TableEntity)(filter:= $"PartitionKey eq '{tableEntity.PartitionKey}'")
			content &= "<p>Using tableClient.Query<TableEntity></p>"

			' Iterate and display queried entities
			For Each qEntity As TableEntity In queryResultsFilter
				content &= $"<p>{qEntity.GetString("Book")}: {qEntity.GetDouble("Price")}</p>"
				Console.WriteLine($"{qEntity.GetString("Book")}: {qEntity.GetDouble("Price")}")
			Next qEntity
			Console.WriteLine($"The query returned {queryResultsFilter.Count()} entities.")
			content &= $"<p>The query returned {queryResultsFilter.Count()} entities.</p>"

			' Render HTML content as PDF
			Dim pdf = renderer.RenderHtmlAsPdf(content)

			' Save the PDF to a file
			pdf.SaveAs("AwesomeAzureDataTables.pdf")
		End Function
	End Module
End Namespace

Code Explanation

The code demonstrates how to interact with Azure Table Storage and generate a PDF using IronPDF:

1. Azure Table Storage Interaction:

   • It uses the Azure SDK for .NET (Azure.Data.Tables) to connect to Azure Table Storage.
   • It then checks if a table named "IronDemo" exists; if not, it creates it.
   • Adds a new entity (similar to a database row) to the table, specifying properties like "Book", "Price", and "Quantity".
   • Queries the table to retrieve entities based on a filter condition.
2. PDF Generation with IronPDF:
   • Uses IronPDF's ChromePdfRenderer to render HTML content into a PDF file.
   • Generates the PDF from dynamic HTML content that includes details about Azure Table Storage operations.

IronPDF Licensing

IronPDF package requires a license to run. Add below code at the start of the application before the package is accessed

IronPdf.License.LicenseKey = "IRONPDF-KEY";

IronPdf.License.LicenseKey = "IRONPDF-KEY";

IRON VB CONVERTER ERROR developers@ironsoftware.com

A trial License is available here.

Conclusion

Azure Table Storage stands as a testament to Microsoft's commitment to providing developers with scalable, flexible, and cost-effective data storage solutions in the cloud. With its schema-less design, horizontal scalability, and seamless integration with the Azure ecosystem, Azure Table Storage empowers developers to build resilient and agile applications that can adapt to the dynamic demands of modern business environments.

Whether it's managing IoT data streams, storing content metadata, or orchestrating distributed systems, Azure Table Storage offers a versatile platform for unlocking the full potential of cloud-native applications. As organizations continue to embrace digital transformation initiatives and migrate to the cloud, Azure Table Storage remains a cornerstone of modern data storage architectures, driving innovation and enabling businesses to thrive in an increasingly data-driven world.

IronPDF is a .NET library used for creating and manipulating PDF documents programmatically. It allows developers to convert HTML, ASPX pages, images, and text into PDF files. Key features include HTML to PDF conversion, PDF editing capabilities, and support for various .NET environments, making it a versatile tool for generating and handling PDF documents within .NET applications.