Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. tye .NET
.NET AIDE

tye .NET (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

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. We will also learn about IronPDF, a PDF generation library from Iron Software, and use Tye and IronPDF in a practical example.

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 automatiquement des Dockerfiles pour chaque service basé sur les configurations de projet, facilitant ainsi des constructions de conteneurs cohérentes et reproductibles dans les environnements de développement et de production, rendant les tests et le déploiement des microservices faciles.

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
SHELL

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
SHELL

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
SHELL

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"
SHELL

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

  2. 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
SHELL
  1. 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
SHELL

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 la personnalisation des 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 jusqu'au 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
SHELL

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
YAML

Avantages de l'utilisation de Tye

  1. Simplification du flux de travail de développement : Tye simplifie le flux de travail de développement en offrant un ensemble d'outils unifiés pour construire, tester et déboguer des applications .NET localement.
  2. Accélération du temps de mise sur le marché : En automatisant les tâches courantes telles que la découverte des services, la gestion des dépendances et la conteneurisation, Tye réduit le temps et les efforts nécessaires pour déployer des applications dans les environnements de production.
  3. Amélioration de la collaboration : Tye favorise la collaboration entre les équipes de développement, d'exploitation et de DevOps en offrant une plateforme commune pour gérer les dépendances et les configurations de déploiement des applications.
  4. Préparation au cloud-native : Tye dote les applications .NET des outils et pratiques nécessaires pour fonctionner dans des environnements cloud-native, tels que Kubernetes, permettant aux organisations d'adopter les paradigmes d'infrastructure moderne en toute confiance.
  5. Support communautaire et contribution : En tant que projet open-source soutenu par Microsoft, Tye bénéficie d'une communauté dynamique de contributeurs et d'utilisateurs qui participent 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

tye .NET (How It Works For Developers) : Figure 1 - IronPDF for .NET : La bibliothèque PDF C#

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 utilisant ces deux bibliothèques.

Générer un document PDF en utilisant 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.

tye .NET (How It Works For Developers) : Figure 2 - Ouvrir Visual Studio et créer une nouvelle application Web ASP.NET Core (Pages Razor).

Fournissez le nom et l'emplacement du projet.

tye .NET (How It Works For Developers) : Figure 3 - Configurer le projet en spécifiant le nom du projet et l'emplacement. Puis cliquez sur Next.

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.

tye .NET (How It Works For Developers) : Figure 4 - Sélectionnez le framework .NET Core 3.1, puis cliquez sur Create.

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

tye .NET (How It Works For Developers) : Figure 5 - Installez IronPDF en utilisant Gérer le Package NuGet pour Solution en recherchant IronPDF dans la barre de recherche du Gestionnaire de Packages NuGet, puis sélectionnez le projet et cliquez sur le bouton Installer.

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"
SHELL

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"
SHELL

Initialisez Tye en utilisant la commande suivante :

tye init
tye init
SHELL

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
YAML

Exécutez Tye avec la commande suivante :

tye run frontend
tye run frontend
SHELL

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

tye .NET (How It Works For Developers) : Figure 6 - Application Razor exécutée à l'aide de Tye sur localhost

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 dans le 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>

Puis ajoutez le code ci-dessous dans 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(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
$vbLabelText   $csharpLabel

Exécutez maintenant Tye comme ci-dessous :

tye .NET (How It Works For Developers) : Figure 7 - Exécutez tye en utilisant la commande : tye run frontend

Cela lancera le tableau de bord Tye.

tye .NET (How It Works For Developers) : Figure 8 - 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.

tye .NET (How It Works For Developers) : Figure 9 - URL vers Générateur de PDF utilisant IronPDF

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

tye .NET (How It Works For Developers) : Figure 10 - Conversion d'URL HTML en PDF utilisant IronPDF

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 en utilisant 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"
}

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. Knowing both the IronPDF library and the Tye build tool, developers can gain advanced skills to develop modern applications with PDF generation capabilities.

Questions Fréquemment Posées

Comment Tye peut-il simplifier le développement d'applications .NET ?

Tye simplifie le développement d'applications .NET en gérant les microservices et leurs dépendances avec une configuration minimale. Il utilise des outils de conteneurisation et d'orchestration tels que Docker et Kubernetes pour rationaliser les processus de construction, de test et de déploiement.

Quels sont les avantages d'utiliser Tye pour la découverte de services dans les applications .NET ?

Tye améliore la découverte de services dans les applications .NET en détectant automatiquement les dépendances entre les microservices, en utilisant les métadonnées du projet et les conteneurs Docker pour faciliter une communication et une orchestration transparentes.

Comment Tye s'intègre-t-il avec Visual Studio et Visual Studio Code ?

Tye s'intègre avec Visual Studio et Visual Studio Code, offrant aux développeurs des outils de débogage, de journalisation et de surveillance, qui améliorent l'expérience de développement et la productivité des applications .NET.

Comment les conteneurs Docker peuvent-ils être utilisés avec Tye ?

Tye utilise des conteneurs Docker pour déployer des applications .NET. Il crée automatiquement des Dockerfiles pour chaque service en fonction des paramètres du projet, garantissant que les constructions de conteneurs sont cohérentes et reproductibles dans différents environnements.

Quelles étapes sont impliquées dans le déploiement d'applications .NET sur Kubernetes avec Tye ?

Pour déployer des applications .NET sur Kubernetes avec Tye, l'outil génère des manifestes Kubernetes et des charts Helm à partir des spécifications du projet. Cela rationalise le processus de déploiement en automatisant la création des ressources nécessaires pour un cluster Kubernetes.

Comment IronPDF peut-il améliorer les applications .NET avec des fonctionnalités PDF ?

IronPDF améliore les applications .NET en fournissant des capacités pour créer, manipuler et rendre des PDF à partir de contenu HTML. Il prend en charge la conversion de HTML en PDF, l'édition de PDF et l'ajout d'éléments tels que des en-têtes et pieds de page, élargissant ainsi les fonctionnalités des applications.

Qu'est-ce qui rend Tye adapté au développement d'applications cloud-native ?

Tye est adapté au développement d'applications cloud-native car il équipe les applications .NET d'outils et de pratiques essentiels pour fonctionner dans des environnements tels que Kubernetes, facilitant l'adoption des infrastructures modernes et des paradigmes de déploiement.

Comment les développeurs peuvent-ils rapidement commencer avec Tye ?

Les développeurs peuvent commencer avec Tye en installant .NET Core 3.1, en configurant Tye comme outil global, et en utilisant des commandes telles que tye run pour exécuter des applications. Le tableau de bord de Tye aide à surveiller et à gérer les services efficacement.

Quels sont les termes de licence applicables à l'utilisation de Project Tye ?

Project Tye est distribué sous la licence MIT, permettant une utilisation gratuite à des fins de développement et commerciales, facilitant une large adoption dans divers projets.

Comment Tye favorise-t-il un temps de mise sur le marché plus rapide pour les applications .NET ?

Tye accélère le temps de mise sur le marché en automatisant les tâches de développement courantes, en améliorant la collaboration en équipe et en renforçant l'état de préparation cloud-native, ce qui rationalise collectivement le flux de travail de développement et réduit les frais généraux.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit