¡Se AWS SDK para .NET ha publicado la versión 4 (V4) del\$1

Para obtener información sobre los cambios más importantes y la migración de sus aplicaciones, consulte el [tema sobre migración](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html).

 [https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html)

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.

# Comience con el marco de procesamiento de AWS mensajes para.NET
<a name="msg-proc-fw-get-started"></a>

Antes de empezar, asegúrese de haber [configurado su entorno](net-dg-config.md) [y su proyecto](configuring-the-sdk.md). Revise también la información en [Uso del 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 la aplicación deben tener los permisos adecuados para el servicio de mensajería y las operaciones que 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) y [SNS](https://docs.aws.amazon.com/sns/latest/dg/security-iam.html) y sus respectivas [EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-iam.html)guías para desarrolladores. [Consulte también la parte del archivo [README](https://github.com/aws/aws-dotnet-messaging/) GitHub que trata sobre los permisos específicos.](https://github.com/aws/aws-dotnet-messaging/blob/main/README.md#permissions)
+ Para usar el marco de procesamiento de AWS mensajes para .NET, debe agregar el [https://www.nuget.org/packages/AWS.Messaging](https://www.nuget.org/packages/AWS.Messaging) NuGetpaquete 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) de](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection) .NET. Puede configurar el marco durante el inicio de la aplicación llamándolo `AddAWSMessageBus` para agregarlo al contenedor 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>

En este tutorial se muestra cómo utilizar el marco de procesamiento de AWS mensajes para.NET. Crea dos aplicaciones: una API mínima de ASP.NET Core que envía mensajes a una cola de Amazon SQS cuando recibe una solicitud en un punto final de la API, y una aplicación de consola de larga ejecución que sondea estos mensajes y los gestiona. 
+ Las instrucciones de este tutorial favorecen la CLI de.NET, pero puede realizar este tutorial mediante herramientas multiplataforma, como la CLI de.NET o Microsoft Visual Studio. Para obtener información acerca de las herramientas, consulte[Instalación y configuración de la cadena de herramientas para AWS SDK para .NET](net-dg-dev-env.md).
+ En este tutorial se da por sentado que está utilizando su `[default]` perfil como credenciales. También supone que las credenciales de corta duración están disponibles con los permisos adecuados para enviar y recibir mensajes de Amazon SQS. Para obtener más información, consulte [Autenticar el con AWS SDK para .NET AWS](creds-idc.md) los temas de seguridad de [SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html).

**nota**  
Si ejecuta este tutorial, podría incurrir en costes por la mensajería de SQS.

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

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

Este tutorial requiere una cola SQS para enviar y recibir mensajes. Se puede crear una cola mediante uno de los siguientes comandos para el o el AWS CLI . Herramientas de AWS para PowerShell Tome nota de la URL de la cola que se devuelve para poder especificarla en la siguiente configuración estructural.

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

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

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

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

------

### Cree y ejecute 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 una línea de comandos 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. Navega hasta la carpeta del nuevo proyecto. Agregue una dependencia al marco de procesamiento de AWS mensajes para .NET.

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

1. Sustituya el código `Program.cs` por el siguiente código.

   ```
   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. Esto debería 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. Abre el `/greeting` punto final y elige **Pruébalo**.

1. Especifique `senderName` los `greeting` valores del mensaje y elija **Ejecutar**. Esto invoca su API, que envía el mensaje SQS.

### Cree y ejecute la aplicación de manejo
<a name="mpf-tutorial-handle"></a>

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

1. Abra una línea de comandos 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. Navega hasta la carpeta del nuevo proyecto. Agregue una dependencia al marco de procesamiento de AWS mensajes para .NET. Agregue también el `Microsoft.Extensions.Hosting` paquete, que le permite configurar el marco a través del [host genérico.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 lo utiliza AWS IAM Identity Center para la autenticación, asegúrese de añadir también `AWSSDK.SSO` y`AWSSDK.SSOOIDC`.

1. Sustituya el código `Program.cs` por el siguiente código.

   ```
   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 sondeo de larga duración.

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

   Poco después del inicio, 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 sondeo.

### Limpieza
<a name="mpf-tutorial-cleanup"></a>

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

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

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

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

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

------