tye .NET (How It Works For Developers)

1. Service Discovery and Dependency Management

Tye automatically detects and manages dependencies between services within a .NET application. It leverages project metadata and Docker containers to infer service relationships, making it easier to coordinate communication and orchestration between microservices. This makes developing microservices easier with multiple projects.

2. Integrated Development Experience

Tye integrates seamlessly with Visual Studio and Visual Studio Code, providing a familiar development environment for .NET developers. It offers tools for debugging, logging, and monitoring application components, enabling rapid iteration and troubleshooting during development.

3. Docker Containerization

Tye embraces Docker containers as the unit of deployment for .NET applications. It automatically generates Dockerfiles for each service based on project configurations, facilitating consistent and reproducible container builds across development and production environments, making testing and deploying microservices easy.

4. Local Development Environment

Tye simplifies local development by orchestrating dependencies and services within a single environment. Developers can spin up the entire application stack with a single command, eliminating the need for manual setup and configuration of dependencies.

5. Deployment to Kubernetes

Tye provides built-in support for deploying .NET applications to Kubernetes clusters. It generates Kubernetes manifests and Helm charts based on project specifications, streamlining the deployment process and promoting best practices for container orchestration in cloud-native environments.

6. Monitoring and Observability

Tye integrates with popular observability tools such as Prometheus and Grafana to provide insights into application performance and health. It exposes metrics and logs from application components, enabling developers to monitor resource utilization, identify bottlenecks, and diagnose issues in real-time.

Let's explore some practical scenarios where Tye can streamline .NET application development and deployment:

1. Local Development Environment

# 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 Containerization

# 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. Deployment to 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 Configuration Schema

Tye has an optional configuration file, tye.yaml, that allows for customization of settings. This YAML file includes all of your projects and external dependencies. If you have an existing solution, Tye will automatically populate it with all of your current projects.

To initialize this YAML file, navigate to the microservices directory and run the following command to generate a default tye.yaml file:

tye init

tye init

A tye.yaml file is created as shown below:

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

Key Features of IronPDF

First, let's create a Visual Studio Razor application. Open Visual Studio and create a new project and select the Razor app as shown below.

Provide the project name and location.

In the next step, select the .NET Framework version and click on Create. Since Tye works only on .NET 3.1, we will select the same.

Install IronPDF from NuGet Package from Visual Studio Package Manager.

Next, open the File Browser and navigate to the solution folder. Then open the CMD prompt.

Install Tye using the following command:

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"

OR if you already have Tye installed and want to update it, use the below command:

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"

Initialize Tye using the following command:

tye init

tye init

This will create a template YAML file as below:

# 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

Run Tye with the following command:

tye run frontend

tye run frontend

This will open the Tye dashboard at URL: http://127.0.0.1:8000/ to see the app running.

Tye Dashboard

Next, add the below code to the project to generate a PDF document from any website URL with a click of a button.

Add the below code to the Index.cshtml file:

@page
@model IndexModel
@{
    ViewData["Title"] = "Generate PDF";
}
<form method="post" class="text-center flex-row">
    <h1>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>

Then add the below code to 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");
        }
    }
}

Now run Tye as below:

This will launch the Tye dashboard.

Now click on any of the links in the bindings section to open the PDF generator app and enter a sample URL for PDF generation.

Click the generate button to get the following PDF as output:

Code Explanation

1. Index.cshtml contains the input field and button to capture the website URL and trigger the PDF generation.
2. Index.cshtml.cs is the code-behind file containing logic for generating the PDF document using IronPDF.
3. The ChromePdfRenderer class and RenderUrlAsPdf() method are used to generate the PDF from the URL.
4. The generated URL is returned as a response to the POST method.
5. The tye run command will launch the Tye dashboard where you can view all running services.
6. Click on the Frontend service in the Tye dashboard to open the app and generate the PDF documents.