La AWS SDK para .NET V3 ha entrado en modo de mantenimiento.

Le recomendamos que migre a la [AWS SDK para .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html). Para obtener información y detalles adicionales sobre cómo migrar, consulta nuestro [anuncio sobre el modo de mantenimiento](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/).

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Introducción al Marco de procesamiento de mensajes de AWS para .NET
<a name="msg-proc-fw-get-started"></a>

Antes de comenzar, asegúrese de que ha [configurado el entorno y el proyecto](net-dg-config.md). Revise también la información en [Características de SDK](net-dg-sdk-features.md).

En este tema se proporciona información que le ayudará a empezar a utilizar el Marco de procesamiento de mensajes. Además de la información sobre los requisitos previos y la configuración, se proporciona un tutorial que muestra cómo implementar un escenario común.

## Requisitos previos y configuración
<a name="mpf-get-started-prereq"></a>
+ Las credenciales que proporcione para su aplicación deben tener los permisos adecuados para el servicio de mensajería y las operaciones que este utilice. Para obtener más información, consulte los temas de seguridad de [SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html), [SNS](https://docs.aws.amazon.com/sns/latest/dg/security-iam.html) y [EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-iam.html) en sus respectivas guías para desarrolladores. Consulte también la parte del archivo [README](https://github.com/aws/aws-dotnet-messaging/) en GitHub donde se explican los [permisos](https://github.com/aws/aws-dotnet-messaging/blob/main/README.md#permissions) específicos.
+ Para usar el Marco de procesamiento de mensajes de AWS para.NET, debe añadir el paquete [https://www.nuget.org/packages/AWS.Messaging](https://www.nuget.org/packages/AWS.Messaging) de NuGet a su proyecto. Por ejemplo:

  ```
  dotnet add package AWS.Messaging
  ```
+ El marco se integra con el [contenedor de servicios de inyección de dependencias (DI)](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection) de .NET. Puede configurar el marco durante el inicio de la aplicación llamando a `AddAWSMessageBus` para añadirlo al contenedor de DI.

  ```
  var builder = WebApplication.CreateBuilder(args);
  
  // Register the AWS Message Processing Framework for .NET
  builder.Services.AddAWSMessageBus(builder =>
  {
      // Register that you'll publish messages of type ChatMessage to an existing queue
      builder.AddSQSPublisher<ChatMessage>("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd");
  });
  ```

## Tutorial
<a name="mpf-get-started-tutorial"></a>

Este tutorial muestra cómo utilizar el Marco de procesamiento de mensajes de AWS para .NET. Crea dos aplicaciones: una API mínima ASP.NET Core que envía mensajes a una cola de Amazon SQS cuando recibe una solicitud en un punto de conexión de la API, y una aplicación de consola de larga duración que sondea estos mensajes y los gestiona. 
+ Las instrucciones de este tutorial se centran en la CLI de .NET, pero puede aplicarlas tanto con herramientas multiplataforma como con la CLI de .NET o Microsoft Visual Studio. Para obtener más información sobre estas herramientas, consulte [Instalación y configuración de la cadena de herramientas](net-dg-dev-env.md).
+ En este tutorial se da por supuesto que utiliza su perfil `[default]` para las credenciales. Asimismo, se presupone que dispone de credenciales a corto plazo con los permisos adecuados para enviar y recibir mensajes de Amazon SQS. Para obtener más información, consulte [Configure la autenticación del SDK con AWS](creds-idc.md) y los temas de seguridad de [SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html).

**nota**  
Al ejecutar este tutorial, puede incurrir en costes de mensajería de SQS.

### Pasos
<a name="mpf-tutorial-steps"></a>
+ [Creación de una cola de SQS](#mpf-tutorial-queue)
+ [Creación y ejecución de la aplicación de publicación](#mpf-tutorial-publish)
+ [Creación y ejecución de la aplicación de procesamiento](#mpf-tutorial-handle)
+ [Eliminación](#mpf-tutorial-cleanup)

### Creación de una cola de SQS
<a name="mpf-tutorial-queue"></a>

Este tutorial requiere una cola de SQS para enviar y recibir mensajes. Se puede crear una cola utilizando uno de los siguientes comandos para la AWS CLI o las Herramientas de AWS para PowerShell. Anote la URL de la cola que se devuelve para poder especificarla en la configuración del marco que se indica a continuación.

------
#### [ AWS CLI ]

```
aws sqs create-queue --queue-name DemoQueue
```

------
#### [ Herramientas de AWS para PowerShell ]

```
New-SQSQueue -QueueName DemoQueue
```

------

### Creación y ejecución de la aplicación de publicación
<a name="mpf-tutorial-publish"></a>

Utilice el siguiente procedimiento para crear y ejecutar la aplicación de publicación.

1. Abra un símbolo del sistema o un terminal. Busque o cree una carpeta del sistema operativo en la que pueda crear un proyecto .NET.

1. En esa carpeta, ejecute el siguiente comando para crear el proyecto .NET.

   ```
   dotnet new webapi --name Publisher
   ```

1. Acceda a la carpeta del proyecto nuevo. Añada una dependencia en el Marco de procesamiento de mensajes de AWS para .NET.

   ```
   cd Publisher
   dotnet add package AWS.Messaging
   ```
**nota**  
Si utiliza AWS IAM Identity Center para la autenticación, no olvide añadir también `AWSSDK.SSO` y `AWSSDK.SSOOIDC`.

1. Reemplace el código de `Program.cs` con lo siguiente:

   ```
   using AWS.Messaging;
   using Microsoft.AspNetCore.Mvc;
   using Publisher;
   
   var builder = WebApplication.CreateBuilder(args);
   
   // Add services to the container.
   // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle.
   builder.Services.AddEndpointsApiExplorer();
   builder.Services.AddSwaggerGen();
   
   
   // Configure the AWS Message Processing Framework for .NET.
   builder.Services.AddAWSMessageBus(builder =>
   {
       // Check for input SQS URL.
       // The SQS URL should be passed as a command line argument or set in the Debug launch profile.
       if ((args.Length == 1) && (args[0].Contains("https://sqs.")))
       {
           // Register that you'll publish messages of type GreetingMessage:
           // 1. To a specified queue.
           // 2. Using the message identifier "greetingMessage", which will be used
           //    by handlers to route the message to the appropriate handler.
           builder.AddSQSPublisher<GreetingMessage>(args[0], "greetingMessage");
       }
       // You can map additional message types to queues or topics here as well.
   });
   var app = builder.Build();
   
   
   // Configure the HTTP request pipeline.
   if (app.Environment.IsDevelopment())
   {
       app.UseSwagger();
       app.UseSwaggerUI();
   }
   
   app.UseHttpsRedirection();
   
   // Create an API Endpoint that receives GreetingMessage objects
   // from the caller and then sends them as an SQS message.
   app.MapPost("/greeting", async ([FromServices] IMessagePublisher publisher, Publisher.GreetingMessage message) =>
       {
           return await PostGreeting(message, publisher);
       })
   .WithName("SendGreeting")
   .WithOpenApi();
   
   app.Run();
   
   public partial class Program
   {
       /// <summary>
       /// Endpoint for posting a greeting message.
       /// </summary>
       /// <param name="greetingMessage">The greeting message.</param>
       /// <param name="messagePublisher">The message publisher.</param>
       /// <returns>Async task result.</returns>
       public static async Task<IResult> PostGreeting(GreetingMessage greetingMessage,
           IMessagePublisher messagePublisher)
       {
           if (greetingMessage.SenderName == null || greetingMessage.Greeting == null)
           {
               return Results.BadRequest();
           }
   
           // Publish the message to the queue configured above.
           await messagePublisher.PublishAsync(greetingMessage);
   
           return Results.Ok();
       }
   }
   
   namespace Publisher
   {
       /// <summary>
       /// This class represents the message contents.
       /// </summary>
       public class GreetingMessage
       {
           public string? SenderName { get; set; }
           public string? Greeting { get; set; }
       }
   }
   ```

1. Ejecute el siguiente comando. Se abrirá una ventana del navegador con la interfaz de usuario de Swagger, que le permitirá explorar y probar su API.

   ```
   dotnet watch run <queue URL created earlier>
   ```

1. Abra el punto de conexión de `/greeting` y seleccione **Pruébelo**.

1. Especifique los valores `senderName` y `greeting` para el mensaje y seleccione **Ejecutar**. Esto invocará a su API, que enviará el mensaje de SQS.

### Creación y ejecución de la aplicación de procesamiento
<a name="mpf-tutorial-handle"></a>

Utilice el siguiente procedimiento para crear y ejecutar la aplicación de procesamiento.

1. Abra un símbolo del sistema o un terminal. Busque o cree una carpeta del sistema operativo en la que pueda crear un proyecto .NET.

1. En esa carpeta, ejecute el siguiente comando para crear el proyecto .NET.

   ```
   dotnet new console --name Handler
   ```

1. Acceda a la carpeta del proyecto nuevo. Añada una dependencia en el Marco de procesamiento de mensajes de AWS para .NET. Añada también el paquete `Microsoft.Extensions.Hosting`, que le permite configurar el marco a través del [host genérico de .NET](https://learn.microsoft.com/en-us/dotnet/core/extensions/generic-host).

   ```
   cd Handler
   dotnet add package AWS.Messaging
   dotnet add package Microsoft.Extensions.Hosting
   ```
**nota**  
Si utiliza AWS IAM Identity Center para la autenticación, no olvide añadir también `AWSSDK.SSO` y `AWSSDK.SSOOIDC`.

1. Reemplace el código de `Program.cs` con lo siguiente:

   ```
   using AWS.Messaging;
   using Handler;
   using Microsoft.Extensions.DependencyInjection;
   using Microsoft.Extensions.Hosting;
   
   var builder = Host.CreateDefaultBuilder(args);
   
   builder.ConfigureServices(services =>
   {
       // Register the AWS Message Processing Framework for .NET.
       services.AddAWSMessageBus(builder =>
       {
           // Check for input SQS URL.
           // The SQS URL should be passed as a command line argument or set in the Debug launch profile.
           if ((args.Length == 1) && (args[0].Contains("https://sqs.")))
           {
               // Register you'll poll the following queue.
               builder.AddSQSPoller(args[0]);
   
               // And that messages of type "greetingMessage" should be:
               // 1. Deserialized as GreetingMessage objects.
               // 2. Which are then passed to GreetingMessageHandler.
               builder.AddMessageHandler<GreetingMessageHandler, GreetingMessage>("greetingMessage");
   
           }
           // You can add additional message handlers here, using different message types. 
       });
   });
   
   var host = builder.Build();
   await host.RunAsync();
   
   namespace Handler
   {
       /// <summary>
       /// This class represents the message contents.
       /// </summary>
       public class GreetingMessage
       {
           public string? SenderName { get; set; }
           public string? Greeting { get; set; }
       }
   
       /// <summary>
       /// This handler is invoked each time you receive the message.
       /// </summary>
       public class GreetingMessageHandler : IMessageHandler<GreetingMessage>
       {
           public Task<MessageProcessStatus> HandleAsync(
               MessageEnvelope<GreetingMessage> messageEnvelope,
               CancellationToken token = default)
           {
               Console.WriteLine(
                   $"Received message {messageEnvelope.Message.Greeting} from {messageEnvelope.Message.SenderName}");
               return Task.FromResult(MessageProcessStatus.Success());
           }
       }
   }
   ```

1. Ejecute el siguiente comando. Esto inicia un sondeador de larga duración.

   ```
   dotnet run <queue URL created earlier>
   ```

   Poco después de iniciarse, la aplicación recibirá el mensaje que se envió en la primera parte de este tutorial y registrará el siguiente mensaje:

   ```
   Received message {greeting} from {senderName}
   ```

1. Pulse `Ctrl+C` para detener el sondeador.

### Eliminación
<a name="mpf-tutorial-cleanup"></a>

Utilice uno de los siguientes comandos para la AWS CLI o las Herramientas de AWS para PowerShell para eliminar la cola.

------
#### [ AWS CLI ]

```
aws sqs delete-queue --queue-url "<queue URL created earlier>"
```

------
#### [ Herramientas de AWS para PowerShell ]

```
Remove-SQSQueue -QueueUrl "<queue URL created earlier>"
```

------