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 to generate, manage, and extract 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 with 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;
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");
            Installation.EnableWebSecurity = true;
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo IronPDF with Azure.Data.Tables</h1>";
            content += "<h2>Create TableServiceClient</h2>";
            content += "<p></p>";
            var serviceClient = new TableServiceClient(connectionString);
            content += "<p>var serviceClient = new TableServiceClient(connectionString);</p>";
            content += "<h2>Create CreateTableIfNotExists</h2>";
            TableItem table = await serviceClient.CreateTableIfNotExistsAsync(tableName);
            Console.WriteLine($"Created table: {table.Name}.");
            content += $"<p>Created table: {table.Name}.</p>";
            content += "<h2>Deletes If Required</h2>";
            // Deletes the table made previously.
            // serviceClient.DeleteTable(tableName);
            content += "<p>serviceClient.DeleteTable(tableName);</p>";
            content += "<h2>GetTableClient</h2>";
            var tableClient = serviceClient.GetTableClient(tableName);
            content += "<p>var tableClient = serviceClient.GetTableClient(tableName);</p>";
            content += "<h2>Add Table Entity</h2>";
            // Make a dictionary entity by defining a <see cref="TableEntity">.
            var tableEntity = new TableEntity() { { "Book", "Awesome IronPDF Package" }, { "Price", 5.00 }, { "Quantity", 21 } };
            content += "<p>new TableEntity() { { \"Book\", \"Awesome IronPDF\" }, { \"Price\", 5.00 }, { \"Quantity\", 21 } };</p>";
            tableEntity.PartitionKey = tableEntity["Book"].ToString();
            tableEntity.RowKey = tableEntity["Price"].ToString();
            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 newly created entity.
            tableClient.AddEntity(tableEntity);
            content += "<p></p>";
            content += "<h2>Query Table</h2>";
            Pageable<TableEntity> queryResultsFilter = tableClient.Query<TableEntity>(filter: $"PartitionKey eq '{tableEntity.PartitionKey}'");
            content += "<p>Using tableClient.Query<TableEntity></p>";
            // Iterate the <see cref="Pageable"> to access all 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>";
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("AwesomeAzureDataTables.pdf");
        }
    }
}

using Azure;
using Azure.Data.Tables;
using Azure.Data.Tables.Models;
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");
            Installation.EnableWebSecurity = true;
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo IronPDF with Azure.Data.Tables</h1>";
            content += "<h2>Create TableServiceClient</h2>";
            content += "<p></p>";
            var serviceClient = new TableServiceClient(connectionString);
            content += "<p>var serviceClient = new TableServiceClient(connectionString);</p>";
            content += "<h2>Create CreateTableIfNotExists</h2>";
            TableItem table = await serviceClient.CreateTableIfNotExistsAsync(tableName);
            Console.WriteLine($"Created table: {table.Name}.");
            content += $"<p>Created table: {table.Name}.</p>";
            content += "<h2>Deletes If Required</h2>";
            // Deletes the table made previously.
            // serviceClient.DeleteTable(tableName);
            content += "<p>serviceClient.DeleteTable(tableName);</p>";
            content += "<h2>GetTableClient</h2>";
            var tableClient = serviceClient.GetTableClient(tableName);
            content += "<p>var tableClient = serviceClient.GetTableClient(tableName);</p>";
            content += "<h2>Add Table Entity</h2>";
            // Make a dictionary entity by defining a <see cref="TableEntity">.
            var tableEntity = new TableEntity() { { "Book", "Awesome IronPDF Package" }, { "Price", 5.00 }, { "Quantity", 21 } };
            content += "<p>new TableEntity() { { \"Book\", \"Awesome IronPDF\" }, { \"Price\", 5.00 }, { \"Quantity\", 21 } };</p>";
            tableEntity.PartitionKey = tableEntity["Book"].ToString();
            tableEntity.RowKey = tableEntity["Price"].ToString();
            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 newly created entity.
            tableClient.AddEntity(tableEntity);
            content += "<p></p>";
            content += "<h2>Query Table</h2>";
            Pageable<TableEntity> queryResultsFilter = tableClient.Query<TableEntity>(filter: $"PartitionKey eq '{tableEntity.PartitionKey}'");
            content += "<p>Using tableClient.Query<TableEntity></p>";
            // Iterate the <see cref="Pageable"> to access all 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>";
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("AwesomeAzureDataTables.pdf");
        }
    }
}

Imports Azure
Imports Azure.Data.Tables
Imports Azure.Data.Tables.Models
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")
			Installation.EnableWebSecurity = True
			' Instantiate Renderer
			Dim renderer = New ChromePdfRenderer()
			Dim content = "<h1>Demo IronPDF with Azure.Data.Tables</h1>"
			content &= "<h2>Create TableServiceClient</h2>"
			content &= "<p></p>"
			Dim serviceClient = New TableServiceClient(connectionString)
			content &= "<p>var serviceClient = new TableServiceClient(connectionString);</p>"
			content &= "<h2>Create CreateTableIfNotExists</h2>"
			Dim table As TableItem = Await serviceClient.CreateTableIfNotExistsAsync(tableName)
			Console.WriteLine($"Created table: {table.Name}.")
			content &= $"<p>Created table: {table.Name}.</p>"
			content &= "<h2>Deletes If Required</h2>"
			' Deletes the table made previously.
			' serviceClient.DeleteTable(tableName);
			content &= "<p>serviceClient.DeleteTable(tableName);</p>"
			content &= "<h2>GetTableClient</h2>"
			Dim tableClient = serviceClient.GetTableClient(tableName)
			content &= "<p>var tableClient = serviceClient.GetTableClient(tableName);</p>"
			content &= "<h2>Add Table Entity</h2>"
			' Make a dictionary entity by defining a <see cref="TableEntity">.
			Dim tableEntity() As New TableEntity() From {
				{ "Book", "Awesome IronPDF Package" },
				{ "Price", 5.00 },
				{ "Quantity", 21 }
			}
			content &= "<p>new TableEntity() { { ""Book"", ""Awesome IronPDF"" }, { ""Price"", 5.00 }, { ""Quantity"", 21 } };</p>"
			tableEntity.PartitionKey = tableEntity("Book").ToString()
			tableEntity.RowKey = tableEntity("Price").ToString()
			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 newly created entity.
			tableClient.AddEntity(tableEntity)
			content &= "<p></p>"
			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 the <see cref="Pageable"> to access all 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>"
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			' Export to a file or Stream
			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.

PDF

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.