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-Tabelle Storage, ein vollständig verwalteter NoSQL-Datenspeicher, der von Microsoft Azure bereitgestellt wird, bietet Entwicklern eine vielseitige Lösung für die Speicherung strukturierter 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. Schemaloses Design: Im Gegensatz zu herkömmlichen relationalen Datenbanken erzwingt Azure Table Storage kein Schema für 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 auf Skalierbarkeit ausgelegt und kann problemlos große Datenmengen 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 Lastausgleich: Daten in Azure Table Storage werden auf der Grundlage des Partitionsschlüssels partitioniert, was eine effiziente Verteilung der Daten auf mehrere Speicherknoten ermöglicht. Diese Partitionierungsstrategie ermöglicht horizontale Skalierbarkeit und Lastausgleich, wodurch eine optimale Leistung und Ressourcennutzung gewährleistet wird.

4. Sekundärindizes: Während Azure Table Storage in erster Linie den Partitionsschlüssel und den Zeilenschlüssel zum Abrufen von Daten verwendet, unterstützt es auch Sekundärindizes 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 in das Azure-Ökosystem: Azure Table Storage lässt sich nahtlos in andere Azure-Dienste wie Azure Functions, Azure Cosmos DB und Azure Logic Apps integrieren, sodass Entwickler problemlos 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 gut für die Speicherung von Telemetriedaten von IoT-Geräten und ermöglicht die Erfassung, Analyse und Visualisierung von Daten in Echtzeit. 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 Inhaltsmetadaten erfordern, wie z. B. 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. Session State Management: Azure Table Storage kann zum Speichern von Sitzungsstatusdaten für Webanwendungen verwendet werden und bietet eine verteilte und skalierbare Lösung für das Sitzungsmanagement. 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 verteilten Systemarchitekturen dient Azure Table Storage als grundlegender Datenspeicher für die Aufrechterhaltung des gemeinsamen Zustands und der Koordination zwischen 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, Inhalte aus PDF-Dokumenten in .NET-Projekten zu erzeugen, zu verwalten und 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:

   • Arbeitet 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 dieIronPDF paket aus dem NuGet Package 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 Interaction:

   • Es wird das Azure SDK für .NET verwendet(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 eine neue Entität hinzu(ähnlich wie eine Datenbankzeile) in die Tabelle ein und geben Eigenschaften wie "Buch", "Preis" und "Menge" an.
   • Fragt die Tabelle ab, um Entitäten basierend auf einer Filterbedingung abzurufen.

2. PDF-Erstellung 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 verfügbarhier.

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, mit der PDF-Dokumente programmatisch erstellt und bearbeitet werden können. 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.