.NET (Como funciona para desenvolvedores)

1. Descoberta de Serviços e Gerenciamento de Dependências

O Tye detecta e gerencia automaticamente as dependências entre serviços dentro de uma aplicação .NET . Ele utiliza metadados do projeto e contêineres Docker para inferir relações entre serviços, facilitando a coordenação da comunicação e a orquestração entre microsserviços. Isso facilita o desenvolvimento de microsserviços em múltiplos projetos.

2. Experiência de Desenvolvimento Integrado

O Tye integra-se perfeitamente com o Visual Studio e o Visual Studio Code, proporcionando um ambiente de desenvolvimento familiar para desenvolvedores .NET . Oferece ferramentas para depuração, registro e monitoramento de componentes de aplicativos, permitindo iteração rápida e solução de problemas durante o desenvolvimento.

3. Containerização com Docker

A Tye adota contêineres Docker como unidade de implantação para aplicativos .NET . Ele gera automaticamente Dockerfiles para cada serviço com base nas configurações do projeto, facilitando a criação de contêineres consistentes e reproduzíveis em ambientes de desenvolvimento e produção, simplificando os testes e a implantação de microsserviços.

4. Ambiente de Desenvolvimento Local

Tye simplifica o desenvolvimento local ao orquestrar dependências e serviços em um único ambiente. Os desenvolvedores podem iniciar toda a pilha de aplicativos com um único comando, eliminando a necessidade de configuração manual de dependências.

5. Implantação no Kubernetes

O Tye oferece suporte integrado para a implantação de aplicativos .NET em clusters Kubernetes. Ele gera manifestos do Kubernetes e gráficos do Helm com base nas especificações do projeto, simplificando o processo de implantação e promovendo as melhores práticas para orquestração de contêineres em ambientes nativos da nuvem.

6. Monitoramento e Observabilidade

O Tye se integra a ferramentas populares de observabilidade, como Prometheus e Grafana, para fornecer informações sobre o desempenho e a integridade do aplicativo. Ele expõe métricas e registros de componentes de aplicativos, permitindo que os desenvolvedores monitorem a utilização de recursos, identifiquem gargalos e diagnostiquem problemas em tempo real.

Vamos explorar alguns cenários práticos onde o Tye pode simplificar o desenvolvimento e a implantação de aplicações .NET :

1. Ambiente de Desenvolvimento 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. Containerização com 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. Implantação no 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

Esquema de Configuração de Tye

Tye possui um arquivo de configuração opcional, tye.yaml, que permite a personalização das configurações. Este arquivo YAML inclui todos os seus projetos e dependências externas. Se você já possui uma solução, o Tye a preencherá automaticamente com todos os seus projetos atuais.

Para inicializar este arquivo YAML, navegue até o diretório de microsserviços e execute o seguinte comando para gerar um arquivo padrão tye.yaml:

tye init

tye init

Um arquivo tye.yaml é criado conforme mostrado abaixo:

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

Principais características do IronPDF

Primeiro, vamos criar um aplicativo Razor no Visual Studio. Abra o Visual Studio, crie um novo projeto e selecione o aplicativo Razor , conforme mostrado abaixo.

Forneça o nome e a localização do projeto.

Na próxima etapa, selecione a versão do .NET Framework e clique em Criar. Como o Tye funciona apenas no .NET 3.1, selecionaremos essa versão.

Instale o IronPDF a partir do pacote NuGet no Gerenciador de Pacotes do Visual Studio.

Em seguida, abra o Explorador de Arquivos e navegue até a pasta da solução. Em seguida, abra o prompt de comando (CMD).

Instale o Tye usando o seguinte comando:

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, se você já tiver o Tye instalado e quiser atualizá-lo, use o comando abaixo:

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"

Inicialize o Tye usando o seguinte comando:

tye init

tye init

Isso criará um arquivo YAML de modelo como o seguinte:

# 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

Execute o Tye com o seguinte comando:

tye run frontend

tye run frontend

Isso abrirá o painel de controle do Tye no endereço URL: http://127.0.0.1:8000/ para visualizar o aplicativo em execução.

Painel de controle Tye

Em seguida, adicione o código abaixo ao projeto para gerar um documento PDF a partir de qualquer URL de site com um clique de um botão.

Adicione o código abaixo ao arquivo 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>

Em seguida, adicione o código abaixo a 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

Agora execute o Tye conforme abaixo:

Isso abrirá o painel de controle do Tye.

Agora, clique em qualquer um dos links na seção de vinculações para abrir o aplicativo gerador de PDF e insira um URL de exemplo para a geração do PDF.

Clique no botão "Gerar" para obter o seguinte PDF como resultado:

Explicação do código

1. Index.cshtml contém o campo de entrada e o botão para capturar o URL do site e acionar a geração do PDF.
2. Index.cshtml.cs é o arquivo de código subjacente que contém a lógica para gerar o documento PDF usando o IronPDF.
3. A classe ChromePdfRenderer e o método RenderUrlAsPdf() são usados ​​para gerar o PDF a partir da URL.
4. A URL gerada é retornada como resposta ao método POST.
5. O comando tye run abrirá o painel de controle do Tye, onde você poderá visualizar todos os serviços em execução.
6. Clique no serviço Frontend no painel de controle do Tye para abrir o aplicativo e gerar os documentos PDF.