È stata rilasciata la versione 4 (V4) di\$1 AWS SDK per .NET 

Per informazioni su come apportare modifiche e migrare le applicazioni, consulta l'argomento sulla [migrazione](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)

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Inizia a usare il AWS Message Processing Framework per .NET
<a name="msg-proc-fw-get-started"></a>

Prima di iniziare, assicurati di aver [configurato l'ambiente](net-dg-config.md) e [configurato il progetto](configuring-the-sdk.md). Consulta anche le informazioni contenute in[Utilizzo di SDK](net-dg-sdk-features.md).

Questo argomento fornisce informazioni utili per iniziare a utilizzare il Message Processing Framework. Oltre alle informazioni sui prerequisiti e sulla configurazione, viene fornito un tutorial che mostra come implementare uno scenario comune.

## Prerequisiti e configurazione
<a name="mpf-get-started-prereq"></a>
+ Le credenziali fornite per l'applicazione devono disporre delle autorizzazioni appropriate per il servizio di messaggistica e le operazioni utilizzate. Per ulteriori informazioni, consulta gli argomenti sulla sicurezza per [SQS, [SNS](https://docs.aws.amazon.com/sns/latest/dg/security-iam.html)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html) e [EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-iam.html)nelle rispettive guide per sviluppatori. [Consultate anche la parte del file [README](https://github.com/aws/aws-dotnet-messaging/) dedicata alle autorizzazioni GitHub specifiche.](https://github.com/aws/aws-dotnet-messaging/blob/main/README.md#permissions)
+ Per utilizzare il AWS Message Processing Framework per .NET, è necessario aggiungere il [https://www.nuget.org/packages/AWS.Messaging](https://www.nuget.org/packages/AWS.Messaging) NuGetpacchetto al progetto. Per esempio:

  ```
  dotnet add package AWS.Messaging
  ```
+ Il framework si integra con il contenitore di [servizi di dependency injection (DI)](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection) di.NET. È possibile configurare il framework durante l'avvio dell'applicazione chiamando `AddAWSMessageBus` per aggiungerlo al contenitore 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>

Questo tutorial dimostra come utilizzare il AWS Message Processing Framework per.NET. Crea due applicazioni: un'API ASP.NET Core Minimal che invia messaggi a una coda Amazon SQS quando riceve una richiesta su un endpoint API e un'applicazione console di lunga durata che esegue il polling di questi messaggi e li gestisce. 
+ Le istruzioni di questo tutorial privilegiano l'interfaccia della riga di comando .NET, ma è possibile eseguire questo tutorial utilizzando strumenti multipiattaforma, come.NET CLI o Microsoft Visual Studio. Per informazioni sugli strumenti, consulta. [Installazione e configurazione della toolchain per AWS SDK per .NET](net-dg-dev-env.md)
+ Questo tutorial presuppone che tu stia utilizzando il tuo `[default]` profilo per le credenziali. Si presuppone inoltre che le credenziali a breve termine siano disponibili con le autorizzazioni appropriate per l'invio e la ricezione di messaggi Amazon SQS. [Per ulteriori informazioni, consulta gli argomenti sulla [Autenticazione con AWS SDK per .NET AWS](creds-idc.md) sicurezza per SQS.](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-authentication-and-access-control.html)

**Nota**  
Eseguendo questo tutorial, potresti incorrere in costi per la messaggistica SQS.

### Fasi
<a name="mpf-tutorial-steps"></a>
+ [Crea una coda SQS](#mpf-tutorial-queue)
+ [Crea ed esegui l'applicazione di pubblicazione](#mpf-tutorial-publish)
+ [Crea ed esegui l'applicazione di gestione](#mpf-tutorial-handle)
+ [Rimozione](#mpf-tutorial-cleanup)

### Crea una coda SQS
<a name="mpf-tutorial-queue"></a>

Questo tutorial richiede una coda SQS per inviare e ricevere messaggi. È possibile creare una coda utilizzando uno dei seguenti comandi per il o il AWS CLI . AWS Strumenti per PowerShell Prendi nota dell'URL della coda che viene restituito in modo da poterlo specificare nella configurazione del framework che segue.

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

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

------
#### [ AWS Strumenti per PowerShell ]

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

------

### Crea ed esegui l'applicazione di pubblicazione
<a name="mpf-tutorial-publish"></a>

Utilizzate la procedura seguente per creare ed eseguire l'applicazione di pubblicazione.

1. Aprire un prompt dei comandi o un terminale. Trovare o creare una cartella del sistema operativo in cui è possibile creare un progetto.NET.

1. In tale cartella, eseguire il seguente comando per creare il progetto.NET.

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

1. Naviga nella cartella del nuovo progetto. Aggiungi una dipendenza dal AWS Message Processing Framework per .NET.

   ```
   cd Publisher
   dotnet add package AWS.Messaging
   ```
**Nota**  
Se lo utilizzi AWS IAM Identity Center per l'autenticazione, assicurati di aggiungere anche `AWSSDK.SSO` e`AWSSDK.SSOOIDC`.

1. Sostituisci il codice `Program.cs` con il codice seguente.

   ```
   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. Esegui il comando seguente. Questo dovrebbe aprire una finestra del browser con l'interfaccia utente di Swagger, che ti permetterà di esplorare e testare la tua API.

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

1. Apri l'`/greeting`endpoint e scegli **Try** it out.

1. `senderName`Specificate `greeting` i valori per il messaggio e scegliete **Esegui**. Questo richiama la tua API, che invia il messaggio SQS.

### Crea ed esegui l'applicazione di gestione
<a name="mpf-tutorial-handle"></a>

Utilizzare la procedura seguente per creare ed eseguire l'applicazione di gestione.

1. Aprire un prompt dei comandi o un terminale. Trovare o creare una cartella del sistema operativo in cui è possibile creare un progetto.NET.

1. In tale cartella, eseguire il seguente comando per creare il progetto.NET.

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

1. Naviga nella cartella del nuovo progetto. Aggiungi una dipendenza dal AWS Message Processing Framework per .NET. Aggiungi anche il `Microsoft.Extensions.Hosting` pacchetto, che consente di configurare il framework tramite l'[host generico.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**  
Se lo utilizzi AWS IAM Identity Center per l'autenticazione, assicurati di aggiungere anche `AWSSDK.SSO` e`AWSSDK.SSOOIDC`.

1. Sostituisci il codice `Program.cs` con il codice seguente.

   ```
   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. Esegui il comando seguente. Questo avvia un sondaggio di lunga durata.

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

   Poco dopo l'avvio, l'applicazione riceverà il messaggio inviato nella prima parte di questo tutorial e registrerà il seguente messaggio:

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

1. Premi `Ctrl+C` per interrompere il sondaggio.

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

Utilizzate uno dei seguenti comandi per AWS CLI o per AWS Strumenti per PowerShell eliminare la coda.

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

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

------
#### [ AWS Strumenti per PowerShell ]

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

------