tye .NET (Funktionsweise für Entwickler)

1. Dienstentdeckung und Abhängigkeitsmanagement

Tye erkennt und verwaltet automatisch Abhängigkeiten zwischen Diensten innerhalb einer .NET-Anwendung. Es nutzt Projektdaten und Docker-Container, um Dienstbeziehungen abzuleiten, wodurch die Kommunikation und Orchestrierung zwischen Microservices erleichtert wird. Dies macht die Entwicklung von Microservices mit mehreren Projekten einfacher.

2. Integrierte Entwicklungserfahrung

Tye integriert sich nahtlos in Visual Studio und Visual Studio Code und bietet eine vertraute Entwicklungsumgebung für .NET-Entwickler. Es bietet Werkzeuge zum Debuggen, Protokollieren und Überwachen von Anwendungsmodulen, die eine schnelle Iteration und Fehlerbehebung während der Entwicklung ermöglichen.

3. Docker-Containerisierung

Dies sind einige Beispiele der verfügbaren Konfigurationsoptionen. Es generiert automatisch Dockerfiles für jeden Dienst basierend auf den Projekteinstellungen, was konsistente und reproduzierbare Containerbuilds in Entwicklungs- und Produktionsumgebungen erleichtert, was das Testen und Bereitstellen von Microservices einfach macht.

4. Lokale Entwicklungsumgebung

Tye vereinfacht die lokale Entwicklung, indem es Abhängigkeiten und Dienste innerhalb einer einzigen Umgebung orchestriert. Entwickler können den gesamten Anwendungsstapel mit einem einzigen Befehl starten, wodurch die Notwendigkeit einer manuellen Einrichtung und Konfiguration von Abhängigkeiten entfällt.

5. Bereitstellung in Kubernetes

Tye bietet integrierte Unterstützung für die Bereitstellung von .NET-Anwendungen in Kubernetes-Clustern. Es generiert Kubernetes-Manifeste und Helm-Charts basierend auf den Projektspezifikationen, vereinfacht den Bereitstellungsprozess und fördert Best Practices für die Container-Orchestrierung in Cloud-nativen Umgebungen.

6. Überwachung und Beobachtbarkeit

Tye integriert sich mit populären Observabilitäts-Tools wie Prometheus und Grafana, um Einblicke in die Anwendungsleistung und -gesundheit zu gewähren. Es bietet Metriken und Protokolle von Anwendungsmodulen, die es Entwicklern ermöglichen, die Ressourcennutzung zu überwachen, Engpässe zu identifizieren und Probleme in Echtzeit zu diagnostizieren.

Lassen Sie uns einige praktische Szenarien erkunden, in denen Tye die Entwicklung und Bereitstellung von .NET-Anwendungen vereinfachen kann:

1. Lokale Entwicklungsumgebung

# Start Tye in local development mode with the tye run command
tye run

# Start Tye in local development mode with the tye run command
tye run

2. Docker-Containerisierung

# Build Docker images for Tye services with the available solution file
tye build

# Build Docker images for Tye services with the available solution file
tye build

3. Bereitstellung in Kubernetes

# Deploy Tye application to Kubernetes cluster 
tye deploy --interactive # deploy microservices and distributed applications

# Deploy Tye application to Kubernetes cluster 
tye deploy --interactive # deploy microservices and distributed applications

Tye's Konfigurationsschema

Tye verfügt über eine optionale Konfigurationsdatei, tye.yaml, die die Anpassung der Einstellungen ermöglicht. Diese YAML-Datei enthält all Ihre Projekte und externen Abhängigkeiten. Wenn Sie eine vorhandene Lösung haben, wird Tye sie automatisch mit all Ihren aktuellen Projekten füllen.

Um diese YAML-Datei zu initialisieren, navigieren Sie zum Microservices-Verzeichnis und führen Sie den folgenden Befehl aus, um eine Standarddatei tye.yaml zu generieren:

tye init

tye init

Eine tye.yaml-Datei wird wie unten dargestellt erstellt:

name: myawesomeapplication
services:
- name: backendtest
  project: backend/backend.csproj
  bindings:
  - port: 7000
- name: frontendtest
  project: frontend/frontend.csproj
  replicas: 2
  bindings:
  - port: 8000
- name: workertest
  project: worker/worker.csproj
- name: rabbit
  image: rabbitmq:3-management
  bindings:
    - port: 5672
      protocol: rabbitmq

name: myawesomeapplication
services:
- name: backendtest
  project: backend/backend.csproj
  bindings:
  - port: 7000
- name: frontendtest
  project: frontend/frontend.csproj
  replicas: 2
  bindings:
  - port: 8000
- name: workertest
  project: worker/worker.csproj
- name: rabbit
  image: rabbitmq:3-management
  bindings:
    - port: 5672
      protocol: rabbitmq

Hauptfunktionen von IronPDF

Erstellen wir zunächst eine Visual Studio Razor-Anwendung. Öffnen Sie Visual Studio, erstellen Sie ein neues Projekt und wählen Sie die Razor-App wie unten gezeigt aus.

Geben Sie den Projektnamen und den Speicherort an.

Wählen Sie im nächsten Schritt die .NET Framework-Version aus und klicken Sie auf Erstellen. Da Tye nur auf .NET 3.1 funktioniert, wählen wir dasselbe aus.

Installieren Sie IronPDF aus dem NuGet-Package aus dem Visual Studio-Paket-Manager.

Öffnen Sie als Nächstes den Datei-Explorer und navigieren Sie zum Lösungordner. Öffnen Sie die CMD-Eingabeaufforderung.

Installieren Sie Tye mit dem folgenden Befehl:

dotnet tool install -g Microsoft.Tye --version "0.11.0-alpha.22111.1"

dotnet tool install -g Microsoft.Tye --version "0.11.0-alpha.22111.1"

ODER, wenn Sie Tye bereits installiert haben und es aktualisieren möchten, verwenden Sie den folgenden Befehl:

dotnet tool update -g Microsoft.Tye --version "0.11.0-alpha.22111.1"

dotnet tool update -g Microsoft.Tye --version "0.11.0-alpha.22111.1"

Initialisieren Sie Tye mit dem folgenden Befehl:

tye init

tye init

Dies erstellt eine Vorlage für eine YAML-Datei wie unten gezeigt:

# tye application configuration file
# read all about it at https://github.com/dotnet/tye
#
# when you've given us a try, we'd love to know what you think:
#    https://aka.ms/AA7q20u
#
# define global settings here
# name: exampleapp # application name
# registry: exampleuser # dockerhub username or container registry hostname
# define multiple services here
services:
- name: frontend
  project: Frontend\Frontend.csproj # msbuild project path (relative to this file)
  # executable: app.exe # path to an executable (relative to this file)
    args: -f=netcoreapp3.1 # arguments to pass to the process
  # replicas: 5 # number of times to launch the application
  # env: # array of environment variables
  #  - name: key
  #    value: value
  # bindings: # optional array of bindings (ports, connection strings)
    # - port: 8080 # number port of the binding

# tye application configuration file
# read all about it at https://github.com/dotnet/tye
#
# when you've given us a try, we'd love to know what you think:
#    https://aka.ms/AA7q20u
#
# define global settings here
# name: exampleapp # application name
# registry: exampleuser # dockerhub username or container registry hostname
# define multiple services here
services:
- name: frontend
  project: Frontend\Frontend.csproj # msbuild project path (relative to this file)
  # executable: app.exe # path to an executable (relative to this file)
    args: -f=netcoreapp3.1 # arguments to pass to the process
  # replicas: 5 # number of times to launch the application
  # env: # array of environment variables
  #  - name: key
  #    value: value
  # bindings: # optional array of bindings (ports, connection strings)
    # - port: 8080 # number port of the binding

Führen Sie Tye mit dem folgenden Befehl aus:

tye run frontend

tye run frontend

Dadurch wird das Tye-Dashboard unter der URL: http://127.0.0.1:8000/ geöffnet, um die laufende App zu sehen.

Tye Dashboard

Fügen Sie den folgenden Code ein, um ein PDF von einer Website-URL mit einem Klick zu erzeugen.

Fügen Sie den folgenden Code zur Datei Index.cshtml hinzu:

@page
@model IndexModel
@{
    ViewData["Title"] = "Generate PDF";
}
<form method="post" class="text-center flex-row">
    <h1 class="display-4">Welcome To URL To PDF Generator</h1>
    <p>Enter Website URL:</p>
    <input type="text" asp-for="UrlInput" />
    <button type="submit">Generate PDF</button>
    @if (Model.Message != null)
    {
        <p>@Model.Message</p>
    }
</form>

Fügen Sie dann den folgenden Code zu Index.cshtml.cs hinzu:

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;

namespace Frontend.Pages
{
    public class IndexModel : PageModel
    {
        public string Message { get; set; }

        [BindProperty]
        public string UrlInput { get; set; }

        private readonly ILogger<IndexModel> _logger;

        public IndexModel(ILogger<IndexModel> logger)
        {
            _logger = logger;
        }

        public void OnGet()
        {
        }

        public IActionResult OnPost()
        {
            if (string.IsNullOrEmpty(UrlInput))
            {
                ModelState.AddModelError("UrlInput", "Please enter a URL.");
                return Page();
            }

            // Create a PDF from the given URL using ChromePdfRenderer
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderUrlAsPdf(UrlInput);

            // Return the PDF as a file result
            var pdfBytes = pdf.BinaryData;
            return File(pdfBytes, "application/pdf", "GeneratedDocument.pdf");
        }
    }
}

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;

namespace Frontend.Pages
{
    public class IndexModel : PageModel
    {
        public string Message { get; set; }

        [BindProperty]
        public string UrlInput { get; set; }

        private readonly ILogger<IndexModel> _logger;

        public IndexModel(ILogger<IndexModel> logger)
        {
            _logger = logger;
        }

        public void OnGet()
        {
        }

        public IActionResult OnPost()
        {
            if (string.IsNullOrEmpty(UrlInput))
            {
                ModelState.AddModelError("UrlInput", "Please enter a URL.");
                return Page();
            }

            // Create a PDF from the given URL using ChromePdfRenderer
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderUrlAsPdf(UrlInput);

            // Return the PDF as a file result
            var pdfBytes = pdf.BinaryData;
            return File(pdfBytes, "application/pdf", "GeneratedDocument.pdf");
        }
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.AspNetCore.Mvc.RazorPages
Imports Microsoft.Extensions.Logging

Namespace Frontend.Pages
	Public Class IndexModel
		Inherits PageModel

		Public Property Message() As String

		<BindProperty>
		Public Property UrlInput() As String

		Private ReadOnly _logger As ILogger(Of IndexModel)

		Public Sub New(ByVal logger As ILogger(Of IndexModel))
			_logger = logger
		End Sub

		Public Sub OnGet()
		End Sub

		Public Function OnPost() As IActionResult
			If String.IsNullOrEmpty(UrlInput) Then
				ModelState.AddModelError("UrlInput", "Please enter a URL.")
				Return Page()
			End If

			' Create a PDF from the given URL using ChromePdfRenderer
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderUrlAsPdf(UrlInput)

			' Return the PDF as a file result
			Dim pdfBytes = pdf.BinaryData
			Return File(pdfBytes, "application/pdf", "GeneratedDocument.pdf")
		End Function
	End Class
End Namespace

Führen Sie Tye wie folgt aus:

Dies wird das Tye-Dashboard starten.

Klicken Sie nun auf einen der Links im Bindungsbereich, um die PDF-Generator-App zu öffnen und eine Beispiel-URL zur PDF-Erzeugung einzugeben.

Klicken Sie auf die Schaltfläche Erzeugen, um das folgende PDF als Ausgabe zu erhalten:

Code-Erklärung

1. Index.cshtml enthält das Eingabefeld und die Schaltfläche zum Erfassen der Website-URL und zum Auslösen der PDF-Generierung.
2. Index.cshtml.cs ist die Code-Behind-Datei, die die Logik zum Generieren des PDF-Dokuments mit IronPDF enthält.
3. Die Klasse ChromePdfRenderer und die Methode RenderUrlAsPdf() werden verwendet, um das PDF aus der URL zu generieren.
4. Die generierte URL wird als Antwort auf die POST-Methode zurückgegeben.
5. Mit dem Befehl tye run wird das Tye-Dashboard gestartet, auf dem Sie alle laufenden Dienste einsehen können.
6. Klicken Sie im Tye-Dashboard auf den Frontend-Dienst, um die Anwendung zu öffnen und PDF-Dokumente zu generieren.