Merge pull request #3 from vhvb1989/fix-mixed-files

fix mixed files

workshop/5-components.md

@@ -1,102 +1,105 @@
-# Componentes .NET Aspire
+# .NET Aspire Components
 
-Los componentes .NET Aspire son un conjunto curado de paquetes NuGet seleccionados específicamente para facilitar la integración de aplicaciones nativas de la nube con servicios y plataformas destacados, incluidos, entre otros, Redis y PostgreSQL. Cada componente proporciona funcionalidades esenciales para aplicaciones nativas de la nube a través de la provisión automática o patrones de configuración estandarizados. Los componentes .NET Aspire se pueden usar sin un proyecto de host de aplicación (orquestador), pero están diseñados para funcionar mejor con el host de aplicaciones .NET Aspire.
+.NET Aspire components are a curated suite of NuGet packages specifically selected to facilitate the integration of cloud-native applications with prominent services and platforms, including but not limited to Redis and PostgreSQL. Each component furnishes essential cloud-native functionalities through either automatic provisioning or standardized configuration patterns. .NET Aspire components can be used without an app host (orchestrator) project, but they're designed to work best with the .NET Aspire app host.
 
-Los componentes .NET Aspire no deben confundirse con los paquetes de alojamiento .NET Aspire, ya que sirven para propósitos diferentes. Los paquetes de alojamiento se utilizan para modelar y configurar varios recursos en una aplicación .NET Aspire, mientras que los componentes se utilizan para mapear la configuración a varias bibliotecas de clientes.
+.NET Aspire components should not be confused with .NET Aspire hosting packages, as they serve different purposes. Hosting packages are used to model and configure various resources in a .NET Aspire app, while components are used to map configuration to various client libraries.
 
-Existe una lista en constante crecimiento de [Componentes .NET Aspire](https://learn.microsoft.com/dotnet/aspire/fundamentals/components-overview?tabs=dotnet-cli#available-components) creados y distribuidos por Microsoft y la comunidad. .NET Aspire es flexible y cualquiera puede crear su propio componente para integrarse con sus propios servicios.
+There is an ever growing list [.NET Aspire Components](https://learn.microsoft.com/dotnet/aspire/fundamentals/components-overview?tabs=dotnet-cli#available-components) created and shipped by Microsoft and the community. .NET Aspire is flexible and anyone can create their own component to integrate with their own services.
 
 
-Mejoremos nuestra aplicación añadiendo un componente. Vamos a añadir un componente que nos ayudará a conectarnos a una caché de Redis para mejorar el rendimiento de nuestra API.
+Let's improve our application by adding a component to it. We will add a component that will help us to connect to a Redis cache to improve our API performance.
 
-## Añadir el Componente Redis al Host de la Aplicación
+## Add Redis Component to App Host
 
-Existen dos tipos de caché que podríamos integrar en nuestra aplicación, incluyendo:
+There are two types of caching that we could integrate into our application including:
 
-- **Caché de salida**: Un método de caché configurable y extensible para almacenar respuestas HTTP completas para futuras solicitudes.
-- **Caché distribuido**: Una caché compartida por varios servidores de aplicaciones que permite cachear piezas específicas de datos. Una caché distribuida se mantiene típicamente como un servicio externo a los servidores de aplicaciones que acceden a ella y puede mejorar el rendimiento y la escalabilidad de una aplicación ASP.NET Core.
+- **Output caching**: A configurable, extensible caching method for storing entire HTTP responses for future requests.
+- **Distributed caching**: A cache shared by multiple app servers that allows you to cache specific pieces of data. A distributed cache is typically maintained as an external service to the app servers that access it and can improve the performance and scalability of an ASP.NET Core app.
 
-Integraremos el componente de _Caché de salida_ en nuestro host de la aplicación. Este componente nos ayudará a cachear la respuesta de nuestra API en la caché de Redis.
+We will integrate the _Output caching_ component to our app host. This component will help us to cache the response of our API in Redis cache. 
 
-Para añadir el componente Redis a nuestro host de la aplicación, necesitamos instalar el paquete NuGet `Aspire.Hosting.Redis`. Este paquete proporciona los componentes necesarios para configurar el servicio en el Host de la Aplicación. Redis se proporciona a través de una imagen de contenedor en este taller, y cuando iniciamos el Host de la Aplicación .NET Aspire, automáticamente descargará la imagen del contenedor de Redis y empezará el servidor de Redis.
+To add the Redis component to our app host, we need to install the `Aspire.Hosting.Redis` NuGet package. This package provides the necessary components to configure the service in the App Host. Redis is provided through a container image in this workshop, and when we start the .NET Aspire App Host, it will automatically download the Redis container image and start the Redis server.
 
-Con el NuGet instalado, podemos configurarlo.
+With the NuGet installed we can configure it.
 
-1. Abre el archivo `Program.cs` en el proyecto `AppHost`.
-1. Añade el siguiente código debajo de `var builder = DistributedApplication.CreateBuilder(args);`
+1. Open the `Program.cs` file in the `AppHost` project.
+1. Add the following code under `var builder = DistributedApplication.CreateBuilder(args);`
 
 	```csharp
 	var cache = builder.AddRedis("cache")
 	```
-	Aquí, hemos configurado la caché de Redis con el nombre `cache`. Este nombre se utiliza para identificar la caché en `Api` o `MyWeatherHub`.
-1. Actualiza el `api` en el Host de la Aplicación con una referencia a la caché.
+	Here, we have configured the Redis cache with the name `cache`. This name is used to identify the cache in the `Api` or `MyWeatherHub`.
+1. Update the `api` in the App Host with a reference to the cache.
 
 	```csharp
 	var api = builder.AddProject<Projects.Api>("api")
 			.WithReference(cache);
 	```
 
-1. Adicionalmente, podríamos configurar [Redis Commander](https://joeferner.github.io/redis-commander/), una herramienta de gestión para Redis. Como parte del paquete `Aspire.Hosting.Redis`, Redis Commander está disponible en el mismo componente. Para añadir Redis Commander, agrega el siguiente código debajo de la nueva configuración de Redis añadida.
+1. Additionally, we could configure [Redis Commander](https://joeferner.github.io/redis-commander/), a Redis management tool. As part of the `Aspire.Hosting.Redis` package,  Redis Commander is available in the same component. To add Redis Commander, add the following code under to the newly added Redis configuration.
 
 	```csharp
 	var cache = builder.AddRedis("cache")
 			.WithRedisCommander();
 	```
 
-## Ejecutar la aplicación
+## Run the application
 
-No hemos realizado cambios en los proyectos `Api` o `MyWeatherHub`, pero podemos ver el inicio de la caché de Redis cuando iniciamos el Host de la Aplicación.
+We haven't made any changes to the `Api` or `MyWeatherHub` projects, but we can see the Redis cache start when we start the App Host. 
 
-> [!IMPORTANTE]
-> Dado que Redis se ejecuta en un contenedor, necesitarás asegurarte de que Docker esté funcionando en tu máquina.
+> [!IMPORTANT]
+> Since Redis runs in a container you will need to ensure that Docker is running on your machine.
 
-1. Inicia Docker Desktop o Podman.
-1. Inicia el proyecto del Host de la Aplicación.
-1. Verás tanto el contenedor de Redis como el contenedor de Redis Commander descargarse e iniciar tanto en el dashboard como en Docker Desktop.
+1. Start Docker Desktop or Podman
+1. Start the App Host project.
+1. You will see both the Redis container and Redis Commander container download and start in both the dashboard and in Docker Desktop.
 
-	![Redis ejecutándose en el dashboard y en el desktop](./media/redis-started.png)
+	![Redis running in dashboard and desktop](./media/redis-started.png)
 
-## Integrar Caché de Salida en la API
+## Integrate Output Caching in API
 
-1. Instala el paquete NuGet `Aspire.StackExchange.Redis.OutputCaching` en el proyecto `Api` para obtener acceso a las APIs de Redis.
-1. Abre el archivo `Program.cs` en el proyecto `Api`.
-1. Añade el siguiente código debajo de `var builder = WebApplication.CreateBuilder(args);` en la parte superior del archivo:
+1. Install the `Aspire.StackExchange.Redis.OutputCaching` NuGet package in the `Api` project to get access to the Redis APIs.
+1. Open the `Program.cs` file in the `Api` project.
+1. Add the following code under the `var builder = WebApplication.CreateBuilder(args);` at the top of the file:
 
 	```csharp
 	var cache = builder.AddRedisOutputCache("cache");
 	```
 
-	> Ten en cuenta que estamos usando el nombre "cache" para referenciar la caché de Redis que configuramos en el Host de la Aplicación.
-1. El `NwsManager` ya ha sido configurado para usar caché de salida, pero con una caché en memoria. Lo actualizaremos para usar la caché de Redis. Abre el archivo `NwsManager.cs` en la carpeta `Data`.
-1. En la clase `NwsManagerExtensions` encontrarás un método `AddNwsManager`.
-1. **ELIMINA** el siguiente código:
+	> Note that we are using the "cache" name to reference the Redis cache that we configured in the App Host.
+1. The `NwsManager` has already been configured to use Output caching, but with a memory cache. We will update it to use the Redis cache. Open the `NwsManager.cs` file in the `Data` folder.
+1. In the `NwsManagerExtensions` class you will find a `AddNwsManager` method.
+1. **DELETE** the following code:
 
 	```csharp
-	// Añadir caché de salida predeterminada
+	// Add default output caching
 	services.AddOutputCache(options =>
 	{
 		options.AddBasePolicy(builder => builder.Cache());
 	});
 	```
 
-	Debido a que configuramos la aplicación para usar la caché de Redis en el archivo `Program.cs`, ya no necesitamos añadir la política de caché de salida predeterminada.
+	Because we configured the application to use Redis cache in the `Program.cs` file, we no longer need to add the default output caching policy.
 
-## Ejecutar la aplicación
-1. Inicia el proyecto Host de la Aplicación y abre el proyecto `MyWeatherHub` desde el dashboard.
-1. Haz clic en una ciudad y luego haz clic de nuevo. Verás que la respuesta está cacheada y la segunda solicitud es mucho más rápida que la primera bajo la pestaña `Traces`.
 
-	![Caché de salida en acción](./media/output-caching.png)
+## Run the application
+1. Start the App Host project and open the `MyWeatherHub` project from the dashboard
+1. Click on a city and then click on it again. You will see that the response is cached and the second request is much faster than the first one under the `Traces` tab.
 
-1. También puedes ver la respuesta cacheada en el Redis Commander. Abre el Redis Commander haciendo clic en el endpoint `Redis Commander` en el dashboard. Bajo estadísticas verás conexiones y comandos procesados.
+	![Output caching in action](./media/output-caching.png)
+
+
+1. You can also see the cached response in the Redis Commander. Open the Redis Commander by clicking on the `Redis Commander` endpoint in the dashboard. Under stats you will see connections and commands processed.
 
 	![Redis Commander](./media/redis-commander.png)
-1. Además, puedes ver los registros de la caché de Redis y del Redis Commander en la pestaña `Console`.
+1. In addition, you can see logs for the Redis cache and Redis Commander in the `Console` tab.
+
+	![Redis logs](./media/redis-logs.png)
 
-	![Registros de Redis](./media/redis-logs.png)
 
-## Contenedores Redis Personalizados
+## Custom Redis Containers
 
-Los componentes de .NET Aspire son flexibles y personalizables. Por defecto, el componente Redis utiliza una imagen de contenedor de Redis de Docker Hub. Sin embargo, puedes usar tu propia imagen de contenedor de Redis proporcionando el nombre de la imagen y la etiqueta después del método `AddRedis`. Por ejemplo, si tienes una imagen de contenedor de Redis personalizada como [Garnet](https://github.com/microsoft/garnet), puedes proporcionar el nombre de la imagen y la etiqueta en el Host de la Aplicación de la siguiente manera:
+.NET Aspire components are flexible and customizable. By default, the Redis component uses a Redis container image from Docker Hub. However, you can use your own Redis container image by providing the image name and tag after the `AddRedis` method. For example, if you have a custom Redis container image such as [Garnet](https://github.com/microsoft/garnet), you can provide the image name and tag in the App Host as follows:
 
 ```csharp
 var cache = builder.AddRedis("cache")
@@ -105,17 +108,17 @@ var cache = builder.AddRedis("cache")
 	.WithRedisCommander();
 ```
 
-1. Ejecuta la aplicación y ahora verás Garnet ejecutándose en el dashboard y en Docker Desktop.
+1. Run the application and you will now see Garnet running in the dashboard and in Docker Desktop.
 
-	![Garnet ejecutándose en el dashboard y en el desktop](./media/garnet-started.png)
-1. También puedes ver los registros de Garnet en la pestaña `Consola`.
+	![Garnet running in dashboard and desktop](./media/garnet-started.png)
+1. You can also see the logs for Garnet in the `Console` tab.
 
-	![Registros de Garnet](./media/garnet-logs.png)
+	![Garnet logs](./media/garnet-logs.png)
 
 
-## Resumen
-En esta sección, añadimos un componente Redis al Host de la Aplicación e integramos la caché de salida en la API. Vimos cómo la respuesta fue cacheada en la caché de Redis y cómo la segunda solicitud fue mucho más rápida que la primera. También vimos cómo usar Redis Commander para gestionar la caché de Redis.
+## Summary
+In this section, we added a Redis component to the App Host and integrated output caching in the API. We saw how the response was cached in the Redis cache and how the second request was much faster than the first one. We also saw how to use Redis Commander to manage the Redis cache.
 
-Hay muchos más componentes disponibles que puedes usar para integrar con tus servicios. Puedes encontrar la lista de componentes disponibles [en la documentación de .NET Aspire](https://learn.microsoft.com/dotnet/aspire/fundamentals/components-overview?tabs=dotnet-cli#available-components).
+There are many more components available that you can use to integrate with your services. You can find the list of available components [in the .NET Aspire documentation](https://learn.microsoft.com/dotnet/aspire/fundamentals/components-overview?tabs=dotnet-cli#available-components).
 
-Un siguiente paso natural sería integrar una base de datos o aprovechar Azure Redis Cache como una solución alojada. Componentes para estos y más están disponibles en NuGet.
+A natural next step would be to integrate a database or leverage Azure Redis Cache as a hosted solution. Components for these and more are available on NuGet.