Azure-Tabellen (Wie es für Entwickler funktioniert)

In der weiten Landschaft des Cloud Computing spielt die Datenspeicherung eine zentrale Rolle bei der Gestaltung der Architektur und Skalierbarkeit moderner Anwendungen. Azure Table Storage, ein vollständig verwalteter NoSQL-Datenspeicher, der von Microsoft Azure bereitgestellt wird, bietet Entwicklern eine vielseitige Lösung zum Speichern von strukturierten Daten in der Cloud. Begeben wir uns auf eine Reise, um die Fähigkeiten, Anwendungsfälle und Vorteile von Azure Table Storage zu erkunden.

Verstehen von Azure Table Storage

Azure Table Storage ist ein Cloud-basierter NoSQL-Datenbankdienst, der eine schemafreie Speicherung von strukturierten Daten ermöglicht. Azure Tables bieten ein auf Schlüssel-Wert-Paaren basierendes Datenmodell, bei dem jede Entität eindeutig durch einen Partitionsschlüssel und einen Zeilenschlüssel identifiziert wird. Dieses Design ermöglicht die effiziente Abfrage und den Abruf von Daten und ist daher ideal für Szenarien, die einen schnellen Zugriff auf große Datenmengen erfordern.

Wenn Sie versuchen, sich zwischen Azure Table Storage und einer relationalen Datenbank für die Verwaltung Ihrer strukturierten Daten zu entscheiden, macht die Fähigkeit von Azure Table Storage, große Datensätze zu verarbeiten, und die Integration in das Azure-Ökosystem Azure Table Storage zu einem praktischen Toolkit für Ihre Entwickler.

Hauptmerkmale und Funktionen

1. Schema-loses Design: Im Gegensatz zu traditionellen relationalen Datenbanken erzwingt Azure Table Storage kein Schema auf die Daten. Diese Flexibilität ermöglicht es den Entwicklern, Entitäten mit unterschiedlichen Strukturen in ein und derselben Tabelle zu speichern, was die agile Entwicklung erleichtert und den sich ändernden Datenanforderungen Rechnung trägt.

2. Skalierbarkeit und Leistung: Azure Table Storage ist für Skalierbarkeit ausgelegt und in der Lage, enorme Datenmengen mühelos zu verarbeiten. Die Software skaliert automatisch, um steigende Arbeitslasten zu bewältigen, und bietet eine vorhersehbare Leistung, wodurch sie sich für Anwendungen mit hohem Durchsatz und Szenarien eignet, die einen Datenzugriff mit geringer Latenz erfordern.

3. Partitionierung und Lastverteilung: Daten in Azure Table Storage werden basierend auf dem Partitionsschlüssel partitioniert, wodurch eine effiziente Verteilung der Daten über mehrere Speicherknoten ermöglicht wird. Diese Partitionierungsstrategie ermöglicht horizontale Skalierbarkeit und Lastausgleich, wodurch eine optimale Leistung und Ressourcennutzung gewährleistet wird.

4. Sekundäre Indizes: Während Azure Table Storage hauptsächlich den Partitionsschlüssel und den Zeilenschlüssel für die Datenabfrage verwendet, unterstützt es auch sekundäre Indizes durch die Verwendung von zusammengesetzten Schlüsseln und Abfrageprojektionen. Diese Funktion ermöglicht es Entwicklern, effiziente Bereichsabfragen durchzuführen und Daten auf der Grundlage sekundärer Attribute zu filtern, wodurch die Flexibilität von Datenzugriffsmustern erhöht wird.

5. Integration mit dem Azure-Ökosystem: Azure Table Storage integriert sich nahtlos mit anderen Azure-Diensten wie Azure Functions, Azure Cosmos DB und Azure Logic Apps, sodass Entwickler mit Leichtigkeit End-to-End-Lösungen erstellen können. Ob es um die Verarbeitung von Datenströmen mit serverlosen Funktionen oder die Analyse von Daten mit fortschrittlichen Analysetools geht, Azure Table Storage dient als grundlegende Komponente für die Erstellung skalierbarer und robuster Anwendungen.

Anwendungsfälle

Azure Table Storage deckt eine Vielzahl von Anwendungsfällen in verschiedenen Branchen ab, darunter:

1. Internet der Dinge (IoT): Azure Table Storage eignet sich hervorragend zum Speichern von Telemetriedaten von IoT-Geräten und ermöglicht die Echtzeitdatenerfassung, -analyse und -visualisierung. Aufgrund seiner Skalierbarkeit und Leistung eignet es sich ideal für die Verarbeitung der großen Datenmengen, die durch IoT-Implementierungen erzeugt werden.

2. Content-Management: Für Anwendungen, die eine strukturierte Speicherung von Content-Metadaten erfordern, wie Blogs, Artikel und nutzergenerierte Inhalte, bietet Azure Table Storage eine kostengünstige und skalierbare Lösung. Das schemafreie Design ermöglicht eine flexible Schemaentwicklung, um Änderungen der Inhaltsstruktur im Laufe der Zeit zu berücksichtigen.

3. Sitzungsstatusverwaltung: Azure Table Storage kann verwendet werden, um Sitzungsstatusdaten für Webanwendungen zu speichern und eine verteilte und skalierbare Sitzungsverwaltungslösung bereitzustellen. Durch die Auslagerung des Sitzungsstatus in Azure Table Storage können Entwickler eine verbesserte Skalierbarkeit, Fehlertoleranz und Sitzungsaffinität in Umgebungen mit Lastverteilung erreichen.

4. Verteilte Systeme: In Architekturen verteilter Systeme dient Azure Table Storage als grundlegender Datenspeicher zur Aufrechterhaltung des gemeinsamen Zustands und der Koordination zwischen den Komponenten. Dank seiner Partitionierungs- und Skalierungsfunktionen eignet es sich gut für Szenarien, die verteiltes Caching, Konfigurationsmanagement und Koordination zwischen Microservices erfordern.

Einführung in IronPDF

IronPDF ist eine C# PDF-Bibliothek, die es ermöglicht, PDF-Dokumente in .NET-Projekten zu erstellen, zu verwalten und Inhalte daraus zu extrahieren. Hier sind einige der wichtigsten Merkmale:

1. HTML-zu-PDF-Konvertierung:

   • Konvertieren Sie HTML-, CSS- und JavaScript-Inhalte in PDF-Dokumente.

   • Chrome Rendering Engine für pixelgenaue PDFs.
   • Erzeugen Sie PDFs aus URLs, HTML-Dateien oder HTML-Strings als Eingabe.

2. Bild- und Inhaltskonvertierung:

   • Konvertieren Sie Bilder in und aus PDF-Dateien.

   • Extrahieren Sie Text und Bilder aus vorhandenen PDF-Dokumenten.
   • Unterstützung für verschiedene Bildformate wie JPG, PNG, etc.

3. Bearbeitung und Manipulation:

   • Legen Sie Eigenschaften, Sicherheit und Berechtigungen für PDFs fest.

   • Digitale Signaturen hinzufügen.
   • Bearbeiten Sie die Metadaten und den Revisionsverlauf.

4. Plattformübergreifende Unterstützung:

   • Funktioniert mit .NET Core (8, 7, 6, 5 und 3.1+), .NET Standard (2.0+) und .NET Framework (4.6.2+).

   • Kompatibel mit Windows, Linux und macOS.
   • Verfügbar über NuGet für eine einfache Installation.

Erzeugen eines PDF-Dokuments mit IronPDF und Azure-Tabellen

Erstellen Sie zunächst eine Konsolenanwendung mit Visual Studio (siehe unten):

Geben Sie den Projektnamen an:

Stellen Sie die .NET-Version bereit:

Installieren Sie das IronPDF-Paket über den NuGet-Paket-Manager:

Für den Zugriff auf die Azure-Tabellen-Bibliothek werden wir die Azure-Tabellen-Client-Bibliothek namens Azure.Data.Tables verwenden, die im NuGet Package Manager zu finden ist.

Erstellen Sie ein Azure Storage-Konto, um mit Azure Tables zu beginnen:

Klicken Sie auf Überprüfen und Erstellen.

Geben Sie den unten stehenden Code in Ihr Programm ein, um mit Azure Tables ein PDF-Dokument zu generieren.

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 Erläuterung

Der Code zeigt, wie man mit Azure Table Storage interagiert und mit IronPDF ein PDF erzeugt:

1. Azure Table Storage-Interaktion:

   • Es verwendet das Azure SDK für .NET (Azure.Data.Tables), um eine Verbindung zu Azure Table Storage herzustellen.

   • Anschließend wird geprüft, ob eine Tabelle mit dem Namen "IronDemo" existiert; wenn nicht, schafft sie es.

   • Fügt der Tabelle eine neue Entität hinzu (ähnlich einer Datenbankzeile), indem Eigenschaften wie "Buch", "Preis" und "Menge" angegeben werden.
   • Fragt die Tabelle ab, um Entitäten basierend auf einer Filterbedingung abzurufen.

2. PDF-Generierung mit IronPDF:

   • Verwendet den ChromePdfRenderer von IronPDF, um HTML-Inhalte in eine PDF-Datei zu übertragen.
   • Generiert die PDF-Datei aus dynamischen HTML-Inhalten, die Details zu Azure Table Storage-Vorgängen enthalten.

   

PDF

IronPDF-Lizenzierung

Das IronPDF-Paket erfordert eine Lizenz zur Ausführung. Fügen Sie den folgenden Code am Anfang der Anwendung ein, bevor das Paket aufgerufen wird

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Eine Testlizenz ist hier verfügbar.

Schlussfolgerung

Azure Table Storage ist ein Beweis für Microsofts Engagement, Entwicklern skalierbare, flexible und kostengünstige Datenspeicherlösungen in der Cloud zur Verfügung zu stellen. Mit seinem schemafreien Design, der horizontalen Skalierbarkeit und der nahtlosen Integration in das Azure-Ökosystem ermöglicht Azure Table Storage Entwicklern die Erstellung belastbarer und flexibler Anwendungen, die sich an die dynamischen Anforderungen moderner Geschäftsumgebungen anpassen können.

Ob es um die Verwaltung von IoT-Datenströmen, die Speicherung von Inhaltsmetadaten oder die Orchestrierung verteilter Systeme geht, Azure Table Storage bietet eine vielseitige Plattform, um das volle Potenzial von Cloud-nativen Anwendungen zu erschließen. Da Unternehmen weiterhin Initiativen zur digitalen Transformation ergreifen und in die Cloud migrieren, bleibt Azure Table Storage ein Eckpfeiler moderner Datenspeicherarchitekturen, der Innovationen vorantreibt und es Unternehmen ermöglicht, in einer zunehmend datengesteuerten Welt erfolgreich zu sein.

IronPDF ist eine .NET-Bibliothek, die verwendet wird, um PDF-Dokumente programmatisch zu erstellen und zu bearbeiten. Es ermöglicht Entwicklern, HTML, ASPX-Seiten, Bilder und Text in PDF-Dateien zu konvertieren. Zu den wichtigsten Funktionen gehören die Konvertierung von HTML in PDF, PDF-Bearbeitungsfunktionen und die Unterstützung verschiedener .NET-Umgebungen, was es zu einem vielseitigen Werkzeug für die Erstellung und Bearbeitung von PDF-Dokumenten in .NET-Anwendungen macht.