Dans le paysage moderne du développement logiciel, créer et déployer des applications distribuées peut être complexe et difficile. Gérer plusieurs services, dépendances et environnements de déploiement nécessite souvent un effort et une coordination considérables. Pour relever ces défis, Microsoft a introduit Project Tye, un outil pour développeurs conçu pour simplifier le développement, les tests et le déploiement d'applications .NET. Dans cet article, nous allons plonger dans le monde de Tye, en explorant ses fonctionnalités, ses avantages et ses applications pratiques pour les développeurs .NET. Nous allons également découvrir IronPDF, une bibliothèque de génération de PDF de Iron Software, et utiliser Tye et IronPDF dans un exemple pratique.

Comprendre Project Tye .NET

Tye est un outil de développement expérimental open-source qui simplifie le processus de construction, de test et de déploiement des applications de projet .NET avec une configuration minimale. Développé par l'équipe d'ingénierie de Microsoft, Tye vise à simplifier le flux de travail du développement en offrant une approche cohérente et guidée pour gérer les microservices et leurs dépendances. Au cœur, Tye adopte les principes de la conteneurisation, de l'orchestration et de la productivité des développeurs pour permettre un développement et un déploiement d'applications sans faille.

Caractéristiques principales de Tye .NET

1. Découverte de services et gestion des dépendances

Tye détecte et gère automatiquement les dépendances entre les services au sein d'une application .NET. Il utilise les métadonnées du projet et les conteneurs Docker pour inférer les relations entre services, facilitant ainsi la coordination de la communication et de l'orchestration entre les microservices. Cela simplifie le développement de microservices avec plusieurs projets.

2. Expérience de développement intégrée

Tye s'intègre parfaitement à Visual Studio et Visual Studio Code, offrant un environnement de développement familier pour les développeurs .NET. Il offre des outils pour le débogage, la journalisation et la surveillance des composants de l'application, permettant une itération rapide et une résolution des problèmes pendant le développement.

3. Conteneurisation Docker

Tye adopte les conteneurs Docker comme unité de déploiement pour les applications .NET. Il génère des Dockerfiles automatiquement pour chaque service selon les configurations de projet, assurant des constructions cohérentes et reproductibles.

4. Environnement de développement local

Tye simplifie le développement local en orchestrant les dépendances et les services au sein d'un seul environnement. Les développeurs peuvent lancer l'ensemble de la pile applicative avec une seule commande, éliminant ainsi le besoin de configuration et de définition manuelles des dépendances.

5. Déploiement sur Kubernetes

Tye offre un support intégré pour le déploiement des applications .NET dans des clusters Kubernetes. Il génère des manifestes Kubernetes et des graphiques Helm basés sur les spécifications du projet, rationalisant le processus de déploiement et promouvant les meilleures pratiques pour l'orchestration des conteneurs dans les environnements cloud-native.

6. Surveillance et observabilité

Tye s'intègre avec des outils d'observabilité populaires tels que Prometheus et Grafana pour fournir des informations sur les performances et la santé de l'application. Il expose des métriques et des journaux des composants de l'application, permettant aux développeurs de surveiller l'utilisation des ressources, d'identifier les goulets d'étranglement et de diagnostiquer les problèmes en temps réel.

Applications pratiques avec Tye

Explorons quelques scénarios pratiques où Tye peut simplifier le développement et le déploiement d'applications .NET :

1. Environnement de développement local

# 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. Conteneurisation Docker

# 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. Déploiement sur 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

Commencer avec Tye

Pour commencer avec Tye :

1. Installez .NET Core 3.1 (non pris en charge pour les versions supérieures) sur votre machine.

2. Installez Tye comme outil global en utilisant :

dotnet tool install -g Microsoft.Tye --version "0.2.0-alpha.20258.3"

dotnet tool install -g Microsoft.Tye --version "0.2.0-alpha.20258.3"

3. Créez un nouveau dossier pour vos microservices.

4. Naviguez jusqu'au dossier et créez un projet frontend (par exemple, Pages Razor) :

mkdir microservices
cd microservices
dotnet new razor -n frontend  # frontend service

mkdir microservices
cd microservices
dotnet new razor -n frontend  # frontend service

5. Exécutez le projet frontend, en lançant le tableau de bord Tye :

tye run frontend  # run frontend project

tye run frontend  # run frontend project

Cela construira, exécutera et surveillera l'application frontend. Vous pouvez accéder au tableau de bord Tye à http://localhost:8000 pour voir l'état de vos services.

Schéma de Configuration de Tye

Tye dispose d'un fichier de configuration optionnel, tye.yaml, qui permet de personnaliser les paramètres. Ce fichier YAML inclut tous vos projets et dépendances externes. Si vous avez une solution existante, Tye la remplira automatiquement avec tous vos projets actuels.

Pour initialiser ce fichier YAML, naviguez vers le répertoire des microservices et exécutez la commande suivante pour générer un fichier tye.yaml par défaut :

tye init

tye init

Un fichier tye.yaml est créé comme indiqué ci-dessous :

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

Avantages de l'utilisation de Tye

1. Flux de travail de développement simplifié : Tye simplifie le flux de travail de développement en fournissant un ensemble d'outils unifié pour la création, le test et le débogage local des applications .NET .
2. Accélération de la mise sur le marché : en automatisant les tâches courantes telles que la découverte de services, la gestion des dépendances et la conteneurisation, Tye réduit le temps et les efforts nécessaires au déploiement d'applications dans des environnements de production.
3. Collaboration améliorée : Tye favorise la collaboration entre les équipes de développement, d'exploitation et DevOps en fournissant une plateforme commune pour la gestion des dépendances des applications et des configurations de déploiement.
4. Préparation au cloud natif : Tye fournit aux applications .NET les outils et les pratiques nécessaires pour s'exécuter dans des environnements cloud natifs, tels que Kubernetes, permettant ainsi aux organisations d'adopter en toute confiance les paradigmes d'infrastructure modernes.
5. Soutien et contribution de la communauté : En tant que projet open source soutenu par Microsoft, Tye bénéficie d'une communauté dynamique de contributeurs et d'utilisateurs qui contribuent activement à son développement, à sa documentation et à son écosystème.

Licence du projet Tye

Project Tye est fourni avec une License MIT qui est gratuite pour une utilisation à des fins de développement et commerciales.

Présentation d'IronPDF

IronPDF est une puissante bibliothèque C# conçue pour créer, éditer et signer des PDFs à partir de HTML, CSS, images et JavaScript. Elle offre des performances de qualité commerciale avec une empreinte mémoire faible.

Caractéristiques clés d'IronPDF

1. Conversion de HTML en PDF

Convertissez des fichiers HTML, des chaînes HTML et des URLs en PDFs. Par exemple, vous pouvez rendre une page web en PDF en utilisant le moteur de rendu Chrome PDF.

2. Support multiplateforme

Compatible avec diverses plateformes .NET, y compris .NET Core, .NET Standard et .NET Framework. Il prend en charge Windows, Linux et macOS.

3. Édition et signature

Définissez des propriétés, ajoutez de la sécurité avec des mots de passe et des permissions, et appliquez des signatures numériques à vos PDFs.

4. Modèles de page et paramètres

Personnalisez les PDFs avec des en-têtes, des pieds de page, des numéros de page et des marges ajustables. Prend en charge les mises en page adaptatives et les formats de papier personnalisés.

5. Conformité aux standards

Respecte les normes PDF telles que PDF/A et PDF/UA. Prend en charge l'encodage de caractères UTF-8 et gère les ressources comme les images, CSS et polices.

Voyons maintenant un exemple pratique en utilisant ces deux bibliothèques.

Générer un document PDF avec IronPDF et Tye pour exécuter

Tout d'abord, créons une application Razor dans Visual Studio. Ouvrez Visual Studio et créez un nouveau projet et sélectionnez l'application Razor comme illustré ci-dessous.

Fournissez le nom et l'emplacement du projet.

Dans l'étape suivante, sélectionnez la version du Framework .NET et cliquez sur Create. Étant donné que Tye fonctionne uniquement sur .NET 3.1, nous sélectionnerons le même.

Installez IronPDF depuis le Package NuGet à partir du Gestionnaire de packages Visual Studio.

Ensuite, ouvrez l'Explorateur de fichiers et naviguez jusqu'au dossier de la solution. Puis ouvrez l'invite de commandes CMD.

Installez Tye en utilisant la commande suivante :

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"

OU si vous avez déjà installé Tye et souhaitez le mettre à jour, utilisez la commande ci-dessous :

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"

Initialisez Tye en utilisant la commande suivante :

tye init

tye init

Cela créera un modèle de fichier YAML comme ci-dessous :

# 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

Exécutez Tye avec la commande suivante :

tye run frontend

tye run frontend

Cela ouvrira le tableau de bord Tye à l'URL : http://127.0.0.1:8000/ pour voir l'application en cours d'exécution.

Tableau de bord Tye

Ensuite, ajoutez le code ci-dessous au projet pour générer un document PDF à partir de n'importe quelle URL de site web d'un simple clic de bouton.

Ajoutez le code ci-dessous au fichier Index.cshtml :

@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>

@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>

Ensuite, ajoutez le code ci-dessous à Index.cshtml.cs :

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(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

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(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

Exécutez maintenant Tye comme ci-dessous :

Cela lancera le tableau de bord Tye.

Maintenant, cliquez sur n'importe lequel des liens dans la section des liaisons pour ouvrir l'application de génération de PDF et entrer une URL d'exemple pour la génération de PDF.

Cliquez sur le bouton générer pour obtenir le PDF suivant en sortie :

Explication du code

1. Index.cshtml contient le champ de saisie et le bouton pour capturer l'URL du site Web et déclencher la génération de PDF.
2. Index.cshtml.cs est le fichier code-behind contenant la logique pour générer le document PDF avec IronPDF.
3. La classe ChromePdfRenderer et la méthode RenderUrlAsPdf() sont utilisées pour générer le PDF à partir de l'URL.
4. L'URL générée est renvoyée comme réponse à la méthode POST.
5. La commande tye run lancera le tableau de bord Tye où vous pouvez voir tous les services en cours d'exécution.
6. Cliquez sur le service Frontend dans le tableau de bord Tye pour ouvrir l'application et générer les documents PDF.

Licence IronPDF

Visitez la page IronPDF Licensing.

Placez la clé de licence dans le fichier appSettings.json comme indiqué ci-dessous :

{
  "IronPdf.License.LicenseKey": "The Key Here"
}

{
  "IronPdf.License.LicenseKey": "The Key Here"
}

Conclusion

En conclusion, Tye représente une avancée significative dans l'écosystème .NET, offrant une approche rationalisée pour la construction, les tests et le déploiement d'applications distribuées. Que vous soyez un développeur .NET chevronné ou novice en conteneurisation et microservices, Tye fournit une plateforme conviviale pour adopter les pratiques de développement modernes et accélérer votre parcours vers une architecture cloud-native.

IronPDF est une bibliothèque .NET qui permet aux développeurs de créer, manipuler et rendre facilement des documents PDF à partir de contenu HTML. Elle prend en charge la conversion de HTML en PDF, la fusion et la séparation de PDFs, ainsi que l'ajout d'en-têtes, de pieds de page et de filigranes. IronPDF est réputée pour sa facilité d'utilisation, son rendu de haute qualité et sa compatibilité avec les applications .NET Core et .NET Framework. Connaissant à la fois la bibliothèque IronPDF et l'outil de construction Tye, les développeurs peuvent acquérir des compétences avancées pour développer des applications modernes avec des capacités de génération de PDF.