

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à.

# Come migrare il codice da AWS SDK per Java 1.x a 2.x
<a name="migration-howto"></a>

È possibile migrare le applicazioni SDK for Java 1.x esistenti in due modi.

1. [Approccio automatizzato utilizzando lo strumento di migrazione.](migration-tool.md)

1. [Approccio manuale](migration-steps.md) che sostituisce in modo incrementale le importazioni 1.x con le importazioni 2.x.

Ti consigliamo di iniziare utilizzando lo strumento di migrazione. Automatizza gran parte del lavoro sostitutivo di routine dal codice 1.x al 2.x. 

Poiché lo strumento [non migra tutte le funzionalità](migration-tool.md#migration-tool-limitations), dovrai cercare il codice v1 rimanente dopo aver eseguito lo strumento. Quando trovi del codice che non è stato migrato dallo strumento, segui le [step-by-step istruzioni](migration-steps.md) (approccio manuale) e utilizza [gli articoli della guida alla migrazione](migration-whats-different.md) per completare la migrazione.

**Topics**
+ [strumento di migrazione](migration-tool.md)
+ [Step-by-step istruzioni](migration-steps.md)

# AWS SDK per Java strumento di migrazione
<a name="migration-tool"></a>

 AWS SDK per Java Fornisce uno strumento di migrazione che aiuta ad automatizzare la migrazione del codice SDK for Java 1.x (V1) a 2.x (V2). Lo strumento utilizza, uno strumento open source di [OpenRewrite](https://docs.openrewrite.org/)refactoring del codice sorgente, per eseguire la migrazione. OpenRewrite utilizza regole di modifica del codice (chiamate «ricette») per aggiornare automaticamente il codice sorgente dalla sintassi e dai modelli da V1 a V2.

Lo strumento supporta le regole di modifica del codice per i client del servizio SDK e la libreria di alto livello [S3](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/transfer/TransferManager.html) Transfer Manager. Le regole di modifica del codice per altre API DynamoDB Enhanced Client di alto livello, [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html)ad APIs esempio dalla V1 alla V2, non sono [supportate](dynamodb-enhanced-client.md). 

[Per maggiori dettagli sulle limitazioni, consulta la fine di questa pagina.](#migration-tool-limitations) Per esempi dettagliati di modelli di codice comuni non supportati con passaggi di migrazione manuale, consulta Modelli di [codice non supportati.](migration-tool-unsupported-patterns.md)

## Utilizza lo strumento di migrazione
<a name="migration-tool-use"></a>

### Migra un progetto Maven
<a name="migration-tool-use-maven"></a>

[Segui le istruzioni riportate di seguito per migrare il tuo progetto SDK for Java 1.x basato su Maven utilizzando lo strumento plug-in Maven. OpenRewrite](https://docs.openrewrite.org/reference/rewrite-maven-plugin)

1. Vai alla directory principale del tuo progetto Maven

   Apri una finestra di terminale (riga di comando) e vai alla directory principale dell'applicazione basata su Maven.

1. Esegui il comando del plugin `rewrite-maven-plugin`

   Puoi scegliere tra due modalità (obiettivi Maven): `dryRun` e. `run`

   **Modalità `dryRun`******

   In questa `dryRun` modalità, il plugin genera i diff log nell'output della console e un file di patch denominato `rewrite.patch` nella cartella. `target/rewrite` Questa modalità consente di visualizzare in anteprima le modifiche che verranno apportate, poiché non vengono apportate modifiche ai file del codice sorgente. 

   L'esempio seguente mostra come richiamare il plugin in `dryRun` modalità.

   ```
   mvn org.openrewrite.maven:rewrite-maven-plugin:<rewrite-plugin-version>*:dryRun \
     -Drewrite.recipeArtifactCoordinates=software.amazon.awssdk:v2-migration:<sdkversion>** \
     -Drewrite.activeRecipes=software.amazon.awssdk.v2migration.AwsSdkJavaV1ToV2
   ```

   \$1Sostituisci *<rewrite-plugin-version>* con il `rewriteMavenPluginVersion` valore che vedi in questo file di [test](https://github.com/aws/aws-sdk-java-v2/blob/3a01289246f1f4ac814a354051d00030e53ef968/test/v2-migration-tests/src/test/java/software/amazon/awssdk/v2migrationtests/MavenTestBase.java#L54).

   \$1\$1Sostituisci *<sdkversion>* con una versione SDK 2.x. Visita [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/v2-migration) per verificare la versione più recente. 
**Importante**  
Assicurati di utilizzare la versione `rewrite-maven-plugin` mostrata nel [file di test](https://github.com/aws/aws-sdk-java-v2/blob/3a01289246f1f4ac814a354051d00030e53ef968/test/v2-migration-tests/src/test/java/software/amazon/awssdk/v2migrationtests/MavenTestBase.java#L54) perché altre versioni potrebbero non funzionare.

   L'output della console proveniente dalla `dryRun` modalità dovrebbe essere simile al seguente.

   ```
   [WARNING] These recipes would make changes to project/src/test/resources/maven/before/pom.xml:
   [WARNING]     software.amazon.awssdk.v2migration.AwsSdkJavaV1ToV2
   [WARNING]         software.amazon.awssdk.v2migration.UpgradeSdkDependencies
   [WARNING]             org.openrewrite.java.dependencies.AddDependency: {groupId=software.amazon.awssdk, artifactId=apache-client, version=2.27.0, onlyIfUsing=com.amazonaws.ClientConfiguration}
   [WARNING]             org.openrewrite.java.dependencies.AddDependency: {groupId=software.amazon.awssdk, artifactId=netty-nio-client, version=2.27.0, onlyIfUsing=com.amazonaws.ClientConfiguration}
   [WARNING]             org.openrewrite.java.dependencies.ChangeDependency: {oldGroupId=com.amazonaws, oldArtifactId=aws-java-sdk-bom, newGroupId=software.amazon.awssdk, newArtifactId=bom, newVersion=2.27.0}
   [WARNING]             org.openrewrite.java.dependencies.ChangeDependency: {oldGroupId=com.amazonaws, oldArtifactId=aws-java-sdk-s3, newGroupId=software.amazon.awssdk, newArtifactId=s3, newVersion=2.27.0}
   [WARNING]             org.openrewrite.java.dependencies.ChangeDependency: {oldGroupId=com.amazonaws, oldArtifactId=aws-java-sdk-sqs, newGroupId=software.amazon.awssdk, newArtifactId=sqs, newVersion=2.27.0}
   [WARNING] These recipes would make changes to project/src/test/resources/maven/before/src/main/java/foo/bar/Application.java:
   [WARNING]     software.amazon.awssdk.v2migration.AwsSdkJavaV1ToV2
   [WARNING]         software.amazon.awssdk.v2migration.S3GetObjectConstructorToFluent
   [WARNING]             software.amazon.awssdk.v2migration.ConstructorToFluent
   [WARNING]         software.amazon.awssdk.v2migration.S3StreamingResponseToV2
   [WARNING]         software.amazon.awssdk.v2migration.ChangeSdkType
   [WARNING]         software.amazon.awssdk.v2migration.ChangeSdkCoreTypes
   [WARNING]             software.amazon.awssdk.v2migration.ChangeExceptionTypes
   [WARNING]                 org.openrewrite.java.ChangeType: {oldFullyQualifiedTypeName=com.amazonaws.AmazonClientException, newFullyQualifiedTypeName=software.amazon.awssdk.core.exception.SdkException}
   [WARNING]                 org.openrewrite.java.ChangeMethodName: {methodPattern=com.amazonaws.AmazonServiceException getRequestId(), newMethodName=requestId}
   [WARNING]                 org.openrewrite.java.ChangeMethodName: {methodPattern=com.amazonaws.AmazonServiceException getErrorCode(), newMethodName=awsErrorDetails().errorCode}
   [WARNING]                 org.openrewrite.java.ChangeMethodName: {methodPattern=com.amazonaws.AmazonServiceException getServiceName(), newMethodName=awsErrorDetails().serviceName}
   [WARNING]                 org.openrewrite.java.ChangeMethodName: {methodPattern=com.amazonaws.AmazonServiceException getErrorMessage(), newMethodName=awsErrorDetails().errorMessage}
   [WARNING]                 org.openrewrite.java.ChangeMethodName: {methodPattern=com.amazonaws.AmazonServiceException getRawResponse(), newMethodName=awsErrorDetails().rawResponse().asByteArray}
   [WARNING]                 org.openrewrite.java.ChangeMethodName: {methodPattern=com.amazonaws.AmazonServiceException getRawResponseContent(), newMethodName=awsErrorDetails().rawResponse().asUtf8String}
   [WARNING]                 org.openrewrite.java.ChangeType: {oldFullyQualifiedTypeName=com.amazonaws.AmazonServiceException, newFullyQualifiedTypeName=software.amazon.awssdk.awscore.exception.AwsServiceException}
   [WARNING]         software.amazon.awssdk.v2migration.NewClassToBuilderPattern
   [WARNING]             software.amazon.awssdk.v2migration.NewClassToBuilder
   [WARNING]             software.amazon.awssdk.v2migration.V1SetterToV2
   [WARNING]         software.amazon.awssdk.v2migration.V1GetterToV2
   ...
   [WARNING]         software.amazon.awssdk.v2migration.V1BuilderVariationsToV2Builder
   [WARNING]         software.amazon.awssdk.v2migration.NewClassToBuilderPattern
   [WARNING]             software.amazon.awssdk.v2migration.NewClassToBuilder
   [WARNING]             software.amazon.awssdk.v2migration.V1SetterToV2
   [WARNING]         software.amazon.awssdk.v2migration.HttpSettingsToHttpClient
   [WARNING]         software.amazon.awssdk.v2migration.WrapSdkClientBuilderRegionStr
   [WARNING] Patch file available:
   [WARNING]     project/src/test/resources/maven/before/target/rewrite/rewrite.patch
   [WARNING] Estimate time saved: 20m
   [WARNING] Run 'mvn rewrite:run' to apply the recipes.
   ```

   **Modalità `run`******

   Quando esegui il plugin in `run` modalità, modifica il codice sorgente sul disco per applicare le modifiche. Assicurati di avere un backup del codice sorgente prima di eseguire il comando.

   L'esempio seguente mostra come richiamare il plugin in `run` modalità.

   ```
   mvn org.openrewrite.maven:rewrite-maven-plugin:<rewrite-plugin-version>*:run \
     -Drewrite.recipeArtifactCoordinates=software.amazon.awssdk:v2-migration:<sdkversion>** \
     -Drewrite.activeRecipes=software.amazon.awssdk.v2migration.AwsSdkJavaV1ToV2
   ```

   *<rewrite-plugin-version>*\$1Sostituiscilo con `rewriteMavenPluginVersionvalue` quello che vedi in questo file di [test](https://github.com/aws/aws-sdk-java-v2/blob/3a01289246f1f4ac814a354051d00030e53ef968/test/v2-migration-tests/src/test/java/software/amazon/awssdk/v2migrationtests/MavenTestBase.java#L54).

   \$1\$1Sostituisci *<sdkversion>* con una versione SDK 2.x. Visita [Maven Central](https://central.sonatype.com/artifact/software.amazon.awssdk/v2-migration) per verificare la versione più recente. 

   Dopo aver eseguito il comando, compila l'applicazione ed esegui dei test per verificare le modifiche. 

### Migra un progetto Gradle
<a name="migration-tool-use-gradle"></a>

[Segui le istruzioni seguenti per migrare il tuo progetto SDK for Java 1.x basato su Gradle utilizzando lo strumento plug-in Gradle. OpenRewrite](https://docs.openrewrite.org/reference/gradle-plugin-configuration)

1. Vai alla directory principale del tuo progetto Gradle

   Apri una finestra di terminale (riga di comando) e vai alla directory principale dell'applicazione basata su Gradle.

1. Crea uno script di init Gradle

   Crea un `init.gradle` file con il seguente contenuto nella directory.

   ```
   initscript {
       repositories {
           maven { url "https://plugins.gradle.org/m2" }
       }
       dependencies {
           classpath("org.openrewrite:plugin:<rewrite-plugin-version>*")
       }
   }
   
   rootProject {
       plugins.apply(org.openrewrite.gradle.RewritePlugin)
       dependencies {
           rewrite("software.amazon.awssdk:v2-migration:latest.release")
       }
   
       afterEvaluate {
           if (repositories.isEmpty()) {
               repositories {
                   mavenCentral()
               }
           }
       }
   }
   ```

   \$1Sostituiscilo *<rewrite-plugin-version>* con la versione che vedi in questo [file di test](https://github.com/aws/aws-sdk-java-v2/blob/master/test/v2-migration-tests/src/test/resources/software/amazon/awssdk/v2migrationtests/gradle/before/init.gradle#L6).

1. Esegui il `rewrite` comando

   Come con il plug-in Maven, puoi eseguire il plug-in Gradle in `dryRun` modalità o. `run`

   **Modalità `dryRun`**

   L'esempio seguente mostra come richiamare il plugin in modalità. `dryRun`

   ```
   gradle rewriteDryRun --init-script init.gradle \
     -Drewrite.activeRecipes=software.amazon.awssdk.v2migration.AwsSdkJavaV1ToV2
   ```

   **Modalità `run`**

   L'esempio seguente mostra come richiamare il plugin in `run` modalità.

   ```
   gradle rewriteRun --init-script init.gradle \
     -Drewrite.activeRecipes=software.amazon.awssdk.v2migration.AwsSdkJavaV1ToV2
   ```

## Limitazioni attuali
<a name="migration-tool-limitations"></a>

Sebbene la migrazione supporti la maggior parte del codice V1 tramite regole di modifica del codice che si aggiornano all'equivalente V2, alcune classi e metodi non sono coperti. Per queste classi e metodi, segui le [step-by-step istruzioni](migration-steps.md) per migrare manualmente il codice.

Per alcune regole di modifica del codice non supportate, lo strumento di migrazione può aggiungere un commento che inizia con:

```
/*AWS SDK for Java v2 migration: Transform for ...
```

Dopo il commento, lo strumento restituisce uno stub generico della versione V2 del metodo o della classe. Ad esempio, nel seguente output, lo strumento di migrazione ha tentato di migrare il metodo del client V1 S3: `setBucketLifecycleConfiguration`

```
/*AWS SDK for Java v2 migration: Transform for setBucketLifecycleConfiguration method not supported. 
Please manually migrate your code by using builder pattern, update from BucketLifecycleConfiguration.Rule 
to LifecycleRule, StorageClass to TransitionStorageClass, and adjust imports and names.*/
s3.putBucketLifecycleConfiguration(
        PutBucketLifecycleConfigurationRequest.builder()
            .bucket(bucketName)
            .lifecycleConfiguration(BucketLifecycleConfiguration.builder()
                .build())
            .build());
```

I collegamenti nell'elenco seguente rimandano alle informazioni sulla migrazione per aiutarti a migrare manualmente il codice.
+ [Differenze del client S3 tra la versione 1 e la versione 2 di AWS SDK per Java](migration-s3-client.md)
+ [S3 Transfer Manager](migration-s3-transfer-manager.md) () TransferManager
+ [Mappatura degli oggetti DynamoDB (](migration-ddb-mapper.md)Dynamo) DBMapper
+ [EC2 utilità per i](migration-imds.md) metadati EC2 MetadataUtils ()
+ [Camerieri (](migration-waiters.md)) AmazonDynamo DBWaiters
+ [IAM Policy Builder](migration-iam-policy-builder.md) (politica)
+ [CloudFront preassegnazione](migration-cloudfront-presigning.md) (,) CloudFrontUrlSigner CloudFrontCookieSigner
+ [Notifiche di eventi S3](migration-s3-event-notification.md) (S3) EventNotification
+ [Pubblicazione delle metriche SDK (documentazione [1.x, documentazione 2.x](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/generating-sdk-metrics.html))](metrics.md)
+ Modelli di [codice non supportati: esempi dettagliati di modelli](migration-tool-unsupported-patterns.md) di codice comuni che richiedono la migrazione manuale

# Modelli di codice non supportati dello strumento di migrazione
<a name="migration-tool-unsupported-patterns"></a>

Lo strumento di migrazione converte automaticamente la maggior parte del codice v1 in v2. Tuttavia, alcuni modelli di codice richiedono la migrazione manuale. Questo argomento fornisce esempi dettagliati dei pattern non supportati più comuni e mostra come convertirli manualmente.

Il seguente elenco di modelli non è esaustivo. Se il codice non viene compilato dopo aver eseguito lo strumento di migrazione, segui le [istruzioni di step-by-step migrazione](migration-steps.md) per migrare manualmente il codice v1 rimanente.

## Richiedi costruttori di oggetti con parametri
<a name="request-pojo-constructors"></a>

Su richiesta POJOs (escluso Amazon S3), lo strumento di migrazione trasforma solo i metodi setter. Lo strumento non supporta costruttori con parametri.

**Pattern supportato: richiedi l'oggetto utilizzando i setter (nessun parametro del costruttore)**

Prima (codice v1 originale):

```
import com.amazonaws.services.sqs.model.SendMessageRequest;

SendMessageRequest request = new SendMessageRequest().withMessageBody("Hello World");
request.setQueueUrl("https://sqs.us-west-2.amazonaws.com/0123456789012/demo-queue");
```

Dopo (risultato dello strumento di migrazione):

```
import software.amazon.awssdk.services.sqs.model.SendMessageRequest;

SendMessageRequest request = SendMessageRequest.builder()
    .messageBody("Hello World").build();
request = request.toBuilder()
    .queueUrl("https://sqs.us-west-2.amazonaws.com/0123456789012/demo-queue").build();
```

**Pattern non supportato: richiedi il costruttore di oggetti con parametri**

Lo strumento di migrazione non può convertire costruttori con parametri:

Prima della migrazione manuale, ma dopo lo strumento di migrazione:

```
import software.amazon.awssdk.services.sqs.model.SendMessageRequest; // Import updated to v2.

// This pattern requires manual migration.
SendMessageRequest request = new SendMessageRequest(
    "https://sqs.us-west-2.amazonaws.com/0123456789012/demo-queue", 
    "Hello World");
```

Lo strumento di migrazione trasforma l'importazione in v2, ma il codice del costruttore rimane invariato e richiede aggiornamenti manuali per utilizzare il pattern builder.

Dopo la migrazione manuale:

```
import software.amazon.awssdk.services.sqs.model.SendMessageRequest;

SendMessageRequest request = SendMessageRequest.builder()
    .messageBody("Hello World")
    .queueUrl("https://sqs.us-west-2.amazonaws.com/0123456789012/demo-queue")
    .build();
```

## Metodi client di assistenza con parametri individuali
<a name="service-client-method-overloads"></a>

Lo strumento di migrazione non è in grado di convertire i metodi dei client di servizio che utilizzano parametri individuali anziché oggetti di richiesta (escluso Amazon S3).

Prima (codice v1):

```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClient;

AmazonSQS sqs = new AmazonSQSClient();
// The following v1 method takes individual parameters.
sqs.sendMessage("https://sqs.us-west-2.amazonaws.com/0123456789012/demo-queue", "Hello World");
```

Dopo (risultato dello strumento di migrazione: non viene compilato):

```
import software.amazon.awssdk.services.sqs.SqsClient;  // Import updated to v2.
// No import statement for the v2 request POJO.

SqsClient sqs = SqsClient.builder().build();

// Does not compile–v2 methods only accept request POJOs.
sqs.sendMessage("https://sqs.us-west-2.amazonaws.com/0123456789012/demo-queue", "Hello World");
```

È necessario aggiornare manualmente gli argomenti del metodo per utilizzare un oggetto di richiesta:

```
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.SendMessageRequest; // Add manually.

SqsClient sqs = SqsClient.builder().build();

// Corrected v2 code.
SendMessageRequest request = SendMessageRequest.builder()
    .queueUrl("https://sqs.us-west-2.amazonaws.com/0123456789012/demo-queue")
    .messageBody("Hello World")
    .build();
sqs.sendMessage(request);
```

## Metodi di timeout della richiesta
<a name="request-pojo-timeout-configuration"></a>

Lo strumento di migrazione non converte i metodi che impostano i timeout sugli oggetti di richiesta.

Prima (codice v1):

```
import com.amazonaws.services.sqs.model.SendMessageRequest;

SendMessageRequest request = new SendMessageRequest();
request.setSdkRequestTimeout(7);
```

Dopo (risultato dello strumento di migrazione: non viene compilato):

```
import software.amazon.awssdk.services.sqs.model.SendMessageRequest;  // Import updated to v2.

SendMessageRequest request = SendMessageRequest.builder().build();

// Does not compile.
request.setSdkRequestTimeout(7);
```

È necessario migrare manualmente per utilizzare il metodo della v2: `overrideConfiguration`

```
import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
import java.time.Duration;

SendMessageRequest request = SendMessageRequest.builder().build();

// Corrected v2 code.
request = request.toBuilder()
    .overrideConfiguration(o -> o.apiCallTimeout(Duration.ofSeconds(7)))
    .build();
```

## Fornisci assistenza ai costruttori dei client con parametri
<a name="service-client-constructors-with-args"></a>

Lo strumento di migrazione converte i costruttori di client di servizio vuoti ma non può convertire i costruttori che accettano parametri come credenziali o configurazioni.

Prima (codice v1):

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClient;

AWSCredentials awsCredentials = new BasicAWSCredentials("akid", "skid");
AmazonSQS sqs = new AmazonSQSClient(awsCredentials);
```

Dopo (risultato dello strumento di migrazione: non viene compilato):

```
import software.amazon.awssdk.auth.credentials.AwsCredentials;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.services.sqs.SqsClient;  // Import updated to v2.

AwsCredentials awsCredentials = AwsBasicCredentials.create("akid", "skid");

// Does not compile.
SqsClient sqs = new SqsClient(awsCredentials);
```

È necessario aggiornare manualmente il costruttore del client di servizio per utilizzare il pattern builder:

```
import software.amazon.awssdk.auth.credentials.AwsCredentials;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;  // Add manually.
import software.amazon.awssdk.services.sqs.SqsClient;

AwsCredentials awsCredentials = AwsBasicCredentials.create("akid", "skid");

// Corrected v2 code.
SqsClient sqs = SqsClient.builder()
    .credentialsProvider(StaticCredentialsProvider.create(awsCredentials))
    .build();
```

# step-by-stepIstruzioni di migrazione con esempio
<a name="migration-steps"></a>

Questa sezione fornisce una step-by-step guida per migrare l'applicazione che attualmente utilizza l'SDK for Java v1.x all'SDK for Java 2.x. La prima parte presenta una panoramica dei passaggi seguiti da un esempio dettagliato di migrazione.

I passaggi qui descritti descrivono la migrazione di un caso d'uso normale, in cui l'applicazione chiama Servizi AWS utilizzando client di servizi basati su modelli. Se devi migrare codice che utilizza un livello superiore APIs come [S3 Transfer Manager](migration-s3-transfer-manager.md) o la [CloudFrontprefirma](migration-cloudfront-presigning.md), consulta la sezione sotto il sommario. [Cosa c'è di diverso tra AWS SDK per Java 1.x e 2.x](migration-whats-different.md)



L'approccio qui descritto è un suggerimento. Puoi utilizzare altre tecniche e sfruttare le funzionalità di modifica del codice del tuo IDE per ottenere lo stesso risultato. 

## Panoramica delle fasi
<a name="migration-steps-overview"></a>

### 1. Inizia aggiungendo l'SDK for Java 2.x BOM
<a name="migration-steps-overview-step1"></a>

Aggiungendo l'elemento Maven BOM (Bill of Materials) per l'SDK for Java 2.x al file POM, ti assicuri che tutte le dipendenze v2 necessarie provengano dalla stessa versione. Il tuo POM può contenere dipendenze v1 e v2. Ciò consente di migrare il codice in modo incrementale anziché modificarlo tutto in una volta.

#### SDK per Java 2.x BOM
<a name="drt_b5n_q1c"></a>

```
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>bom</artifactId>
      <version>2.27.21</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
```

Puoi trovare l'[ultima versione](https://central.sonatype.com/artifact/software.amazon.awssdk/bom) sul Maven Central Repository.

### 2. Cerca nei file le istruzioni di importazione della classe v1
<a name="migration-steps-overview-step2"></a>

Scansionando i file dell'applicazione alla ricerca di SERVICE\$1 IDs utilizzato nelle importazioni v1, troverete l'unico SERVICE\$1 utilizzato. IDs Un SERVICE\$1ID è un nome breve e univoco per un. Servizio AWS Ad esempio `cognitoidentity` è SERVICE\$1ID per Amazon Cognito Identity.

### 3. Determina le dipendenze di Maven v2 dalle istruzioni di importazione v1
<a name="migration-steps-overview-step3"></a>

Dopo aver trovato tutte le versioni univoche di V1 SERVICE\$1IDs, è possibile determinare l'artefatto Maven corrispondente per la dipendenza v2 facendo riferimento a. [Nome del pacchetto per le mappature ArtifactID di Maven](#migration-serviceid-artifactid-mapping)

### 4. Aggiungi elementi di dipendenza v2 al file POM
<a name="migration-steps-overview-step4"></a>

Aggiorna il file Maven POM con gli elementi di dipendenza determinati nel passaggio 3.

### 5. Nei file Java, passa in modo incrementale dalle classi v1 alle classi v2
<a name="migration-steps-overview-step5"></a>

Quando sostituite le classi v1 con le classi v2, apportate le modifiche necessarie per supportare l'API v2, ad esempio utilizzando builder anziché costruttori e utilizzando getter e setter fluenti.

### 6. Rimuovi le dipendenze v1 Maven dalle importazioni POM e v1 dai file
<a name="migration-steps-overview-step6"></a>

Dopo aver migrato il codice per utilizzare le classi v2, rimuovi tutte le importazioni v1 rimanenti dai file e tutte le dipendenze dal file di build.

### 7. Rifattorizza il codice per utilizzare i miglioramenti dell'API v2
<a name="migration-steps-overview-step7"></a>

Dopo che il codice è stato compilato e superato con successo i test, puoi sfruttare i miglioramenti della v2, come l'utilizzo di un client HTTP o di impaginatori diversi per semplificare il codice. Questa fase è opzionale.

## Esempio di migrazione
<a name="migration-steps-example"></a>

In questo esempio, eseguiamo la migrazione di un'applicazione che utilizza l'SDK for Java v1 e accede a diversi. Servizi AWS Esaminiamo in dettaglio il seguente metodo v1 nel passaggio 5. Questo è un metodo in una classe che contiene otto metodi e nell'applicazione sono presenti 32 classi.

### metodo v1 per migrare
<a name="v1-snippet-collapsed"></a>

Di seguito sono elencate solo le importazioni dell'SDK v1 dal file Java.

```
import com.amazonaws.ClientConfiguration;
import com.amazonaws.regions.Region;
import com.amazonaws.regions.RegionUtils;
import com.amazonaws.services.ec2.AmazonEC2Client;
import com.amazonaws.services.ec2.model.AmazonEC2Exception;
import com.amazonaws.services.ec2.model.CreateTagsRequest;
import com.amazonaws.services.ec2.model.DescribeInstancesRequest;
import com.amazonaws.services.ec2.model.DescribeInstancesResult;
import com.amazonaws.services.ec2.model.Instance;
import com.amazonaws.services.ec2.model.InstanceStateName;
import com.amazonaws.services.ec2.model.Reservation;
import com.amazonaws.services.ec2.model.Tag;
import com.amazonaws.services.ec2.model.TerminateInstancesRequest;
...
private static List<Instance> getRunningInstances(AmazonEC2Client ec2, List<String> instanceIds) {
    List<Instance> runningInstances = new ArrayList<>();
    try {
        DescribeInstancesRequest request = new DescribeInstancesRequest()
                .withInstanceIds(instanceIds);
        DescribeInstancesResult result;
        do {
            // DescribeInstancesResponse is a paginated response, so use tokens with multiple requests.
            result = ec2.describeInstances(request);
            request.setNextToken(result.getNextToken());   // Prepare request for next page.
            for (final Reservation r : result.getReservations()) {
                for (final Instance instance : r.getInstances()) {
                    LOGGER.info("Examining instanceId: "+ instance.getInstanceId());
                    // if instance is in a running state, add it to runningInstances list.
                    if (RUNNING_STATES.contains(instance.getState().getName())) {
                        runningInstances.add(instance);
                    }
                }
            }
        } while (result.getNextToken() != null);
    } catch (final AmazonEC2Exception exception) {
        // if instance isn't found, assume its terminated and continue.
        if (exception.getErrorCode().equals(NOT_FOUND_ERROR_CODE)) {
            LOGGER.info("Instance probably terminated; moving on.");
        } else {
            throw exception;
        }
    }
    return runningInstances;
}
```

### 1. Aggiungi v2 Maven BOM
<a name="migration-steps-example-step1"></a>

Aggiungi la BOM Maven per l'SDK for Java 2.x al POM insieme a tutte le altre dipendenze nella sezione. `dependencyManagement` Se il tuo file POM contiene la BOM per la versione 1 dell'SDK, lasciala per ora. Verrà rimosso in una fase successiva.

#### Gestione delle dipendenze POM fin dall'inizio
<a name="migration-example-boms"></a>

```
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.example</groupId>             <!--Existing dependency in POM. -->
      <artifactId>bom</artifactId>
      <version>1.3.4</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
    ...
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>aws-java-sdk-bom</artifactId>  <!--Existing v1 BOM dependency. -->
      <version>1.11.1000</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
    ...
    <dependency>
      <groupId>software.amazon.awssdk</groupId>  <!--Add v2 BOM dependency. -->
      <artifactId>bom</artifactId>
      <version>2.27.21</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
```

### 2. Cerca nei file le istruzioni di importazione della classe v1
<a name="migration-steps-example-step2"></a>

Cerca nel codice dell'applicazione le occorrenze uniche di. `import com.amazonaws.services` Questo ci aiuta a determinare le dipendenze v1 utilizzate dal progetto. Se la tua applicazione ha un file Maven POM con le dipendenze v1 elencate, puoi invece utilizzare queste informazioni. 

Per questo esempio utilizziamo il comando [`ripgrep`(rg)](https://github.com/BurntSushi/ripgrep) per cercare nella base di codice.

Dalla radice della tua base di codice, esegui il seguente `ripgrep` comando. Dopo aver `ripgrep` trovato le istruzioni di importazione, queste vengono reindirizzate a `cut``sort`, e `uniq` i comandi per isolare SERVICE\$1. IDs 

```
rg --no-filename 'import\s+com\.amazonaws\.services' | cut -d '.' -f 4 | sort | uniq
```

Per questa applicazione, i seguenti SERVICE\$1 IDs sono registrati nella console.

```
autoscaling
cloudformation
ec2
identitymanagement
```

Ciò indica che c'è stata almeno un'occorrenza di ciascuno dei seguenti nomi di pacchetto utilizzati nelle istruzioni. `import` Per i nostri scopi, i nomi delle singole classi non contano. Abbiamo solo bisogno di trovare i SERVICE\$1 IDs che vengono utilizzati.

```
com.amazonaws.services.autoscaling.*
com.amazonaws.services.cloudformation.*
com.amazonaws.services.ec2.*
com.amazonaws.services.identitymanagement.*
```

### 3. Determina le dipendenze di Maven v2 dalle istruzioni di importazione v1
<a name="migration-steps-example-step3"></a>

Il SERVICE\$1 IDs per la v1 che abbiamo isolato dalla Fase 2, ad esempio `autoscaling` e, `cloudformation` può essere mappato sullo stesso SERVICE\$1ID v2 per la maggior parte. Poiché nella maggior parte dei casi l'ArtifactID di Maven v2 corrisponde al SERVICE\$1ID, hai le informazioni necessarie per aggiungere blocchi di dipendenza al tuo file POM.

La tabella seguente mostra come possiamo determinare le dipendenze v2.


| v1 SERVICE\$1ID è mappato a...nome del pacchetto | v2 SERVICE\$1ID mappa su...nome del pacchetto | dipendenza da Maven v2 | 
| --- | --- | --- | 
|  **ec2** `com.amazonaws.services.ec2.*`  |  **ec2** `software.amazon.awssdk.services.ec2.*`  |  <pre><dependency><br />  <groupId>software.amazon.awssdk</groupId><br />  <artifactId>ec2</artifactId><br /></dependency></pre>  | 
|  **scalabilità automatica** `com.amazonaws.services.autoscaling.*`  |  **scalabilità automatica** `software.amazon.awssdk.services.autoscaling.*`  |  <pre><dependency><br />  <groupId>software.amazon.awssdk</groupId><br />  <artifactId>autoscaling</artifactId><br /></dependency></pre>  | 
| cloudformation`com.amazonaws.services.cloudformation.*` | cloudformation`software.amazon.awssdk.cloudformation.*` |  <pre><dependency><br />  <groupId>software.amazon.awssdk</groupId><br />  <artifactId>cloudformation</artifactId><br /></dependency></pre>  | 
| gestione dell'identità\$1`com.amazonaws.services.identitymanagement.*` | sono\$1`software.amazon.awssdk.iam.*` |  <pre><dependency><br />  <groupId>software.amazon.awssdk</groupId><br />  <artifactId>iam</artifactId><br /></dependency></pre>  | 

\$1 La `iam` mappatura `identitymanagement` to è un'eccezione in cui il SERVICE\$1ID differisce tra le versioni. Fai riferimento a [Nome del pacchetto per le mappature ArtifactID di Maven](#migration-serviceid-artifactid-mapping) per le eccezioni se Maven o Gradle non sono in grado di risolvere la dipendenza v2.

### 4. Aggiungi elementi di dipendenza v2 al file POM
<a name="migration-steps-example-step4"></a>

Nel passaggio 3, abbiamo determinato i quattro blocchi di dipendenza che devono essere aggiunti al file POM. Non è necessario aggiungere una versione perché abbiamo specificato la BOM nel passaggio 1. Dopo aver aggiunto le importazioni, il nostro file POM presenta i seguenti elementi di dipendenza.

```
    ...
  <dependencies>
    ...
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>autoscaling</artifactId>
    </dependency>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>iam</artifactId>
    </dependency>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>cloudformation</artifactId>
    </dependency>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>ec2</artifactId>
    </dependency>
    ...
  </dependencies>
    ...
```

### 5. Nei file Java, passa in modo incrementale dalle classi v1 alle classi v2
<a name="migration-steps-example-step5"></a>

Nel metodo che stiamo migrando, vediamo
+ Un client di servizio EC2 di. `com.amazonaws.services.ec2.AmazonEC2Client`
+ Sono state utilizzate diverse classi di modelli EC2. Ad esempio `DescribeInstancesRequest` e. `DescribeInstancesResult`

```
import com.amazonaws.ClientConfiguration;
import com.amazonaws.regions.Region;
import com.amazonaws.regions.RegionUtils;
import com.amazonaws.services.ec2.AmazonEC2Client;
import com.amazonaws.services.ec2.model.AmazonEC2Exception;
import com.amazonaws.services.ec2.model.CreateTagsRequest;
import com.amazonaws.services.ec2.model.DescribeInstancesRequest;
import com.amazonaws.services.ec2.model.DescribeInstancesResult;
import com.amazonaws.services.ec2.model.Instance;
import com.amazonaws.services.ec2.model.InstanceStateName;
import com.amazonaws.services.ec2.model.Reservation;
import com.amazonaws.services.ec2.model.Tag;
import com.amazonaws.services.ec2.model.TerminateInstancesRequest;
...
private static List<Instance> getRunningInstances(AmazonEC2Client ec2, List<String> instanceIds)
    List<Instance> runningInstances = new ArrayList<>();
    try {
        DescribeInstancesRequest request = new DescribeInstancesRequest()
                .withInstanceIds(instanceIds);
        DescribeInstancesResult result;
        do {
            // DescribeInstancesResponse is a paginated response, so use tokens with multiple re
            result = ec2.describeInstances(request);
            request.setNextToken(result.getNextToken());   // Prepare request for next page.
            for (final Reservation r : result.getReservations()) {
                for (final Instance instance : r.getInstances()) {
                    LOGGER.info("Examining instanceId: "+ instance.getInstanceId());
                    // if instance is in a running state, add it to runningInstances list.
                    if (RUNNING_STATES.contains(instance.getState().getName())) {
                        runningInstances.add(instance);
                    }
                }
            }
        } while (result.getNextToken() != null);
    } catch (final AmazonEC2Exception exception) {
        // if instance isn't found, assume its terminated and continue.
        if (exception.getErrorCode().equals(NOT_FOUND_ERROR_CODE)) {
            LOGGER.info("Instance probably terminated; moving on.");
        } else {
            throw exception;
        }
    }
    return runningInstances;
}
...
```

Il nostro obiettivo è sostituire tutte le importazioni v1 con le importazioni v2. Procediamo una lezione alla volta.

#### a. Sostituisci l'istruzione di importazione o il nome della classe
<a name="migration-example-step5-substep1"></a>

Vediamo che il primo parametro del `describeRunningInstances` metodo è un'`AmazonEC2Client`istanza v1. Esegui una delle seguenti operazioni:
+ Sostituisci l'importazione per `com.amazonaws.services.ec2.AmazonEC2Client` con `software.amazon.awssdk.services.ec2.Ec2Client` e passa `AmazonEC2Client` a`Ec2Client`.
+ Cambia il tipo di parametro in `Ec2Client` e lascia che l'IDE ci richieda l'importazione corretta. Il nostro IDE ci chiederà di importare la classe v2 perché i nomi dei client sono diversi: e. `AmazonEC2Client` `Ec2Client` Questo approccio non funziona se il nome della classe è lo stesso in entrambe le versioni.

#### b. Sostituisci le classi del modello v1 con gli equivalenti v2
<a name="migration-example-step5-substep2"></a>

Dopo la modifica alla v2`Ec2Client`, se utilizziamo un IDE, vediamo errori di compilazione nella seguente dichiarazione.

```
                    result = ec2.describeInstances(request);
```

L'errore di compilazione deriva dall'utilizzo di un'istanza di v1 `DescribeInstancesRequest` come parametro del metodo v2. `Ec2Client` `describeInstances` Per risolvere il problema, effettuate le seguenti istruzioni di sostituzione o importazione.


| replace | con | 
| --- | --- | 
|  <pre>import com.amazonaws.services.ec2.model.DescribeInstancesRequest</pre>  |  <pre>import software.amazon.awssdk.services.ec2.model.DescribeInstancesRequest</pre>  | 

#### c. Cambia i costruttori v1 in v2 builder.
<a name="migration-example-step5-substep3"></a>

Vediamo ancora errori di compilazione perché [non ci](migration-whats-different.md#immutable-classes) sono costruttori nelle classi v2. Per risolvere il problema, apporta la seguente modifica.


| modifica | in | 
| --- | --- | 
|  <pre>final DescribeInstancesRequest request = new DescribeInstancesRequest()<br />        .withInstanceIds(instanceIdsCopy);</pre>  |  <pre>final DescribeInstancesRequest request = DescribeInstancesRequest.builder()<br />        .instanceIds(instanceIdsCopy)<br />        .build();</pre>  | 

#### d. Sostituisci gli oggetti di `*Result` risposta v1 con gli equivalenti `*Response` v2
<a name="migration-example-step5-substep4"></a>

Una differenza consistente tra v1 e v2 è che tutti [gli oggetti di risposta in v2](migration-whats-different.md#model-classname-changes) terminano con invece di. `*Response` `*Result` Sostituisci l'importazione v1 con `DescribeInstancesResult` l'importazione v2,. `DescribeInstancesResponse`

#### d. Apporta modifiche all'API
<a name="migration-example-step5-substep5"></a>

La seguente dichiarazione richiede alcune modifiche.

```
request.setNextToken(result.getNextToken());
```

Nella v2, [i metodi setter](migration-whats-different.md#setter-getter-methods) non utilizzano `set` o with. `prefix` I metodi Getter con prefisso `get` sono presenti anche nell'SDK for Java 2.x

Le classi del modello, come l'`request`istanza, sono immutabili nella v2, quindi dobbiamo crearne una nuova con un builder. `DescribeInstancesRequest`

Nella v2, l'istruzione diventa la seguente.

```
request = DescribeInstancesRequest.builder()
        .nextToken(result.nextToken())
        .build();
```

#### d. Ripetere l'operazione fino alla compilazione del metodo con le classi v2
<a name="migration-example-step5-substep6"></a>

Continua con il resto del codice. Sostituisci le importazioni v1 con le importazioni v2 e correggi gli errori di compilazione. Se necessario, consulta il riferimento all'[API v2 e il riferimento](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/ec2/package-summary.html) [What's different](migration-whats-different.md).

Dopo aver migrato questo singolo metodo, abbiamo il seguente codice v2.

```
import com.amazonaws.ClientConfiguration;
import com.amazonaws.regions.Region;
import com.amazonaws.regions.RegionUtils;
import com.amazonaws.services.ec2.AmazonEC2Client;
import com.amazonaws.services.ec2.model.AmazonEC2Exception;
import com.amazonaws.services.ec2.model.CreateTagsRequest;
import com.amazonaws.services.ec2.model.InstanceStateName;
import com.amazonaws.services.ec2.model.Tag;
import com.amazonaws.services.ec2.model.TerminateInstancesRequest;

import software.amazon.awssdk.services.ec2.Ec2Client;
import software.amazon.awssdk.services.ec2.model.DescribeInstancesRequest;
import software.amazon.awssdk.services.ec2.model.DescribeInstancesResponse;
import software.amazon.awssdk.services.ec2.model.Ec2Exception;
import software.amazon.awssdk.services.ec2.model.Instance;
import software.amazon.awssdk.services.ec2.model.Reservation;
...
private static List<Instance> getRunningInstances(Ec2Client ec2, List<String> instanceIds) {
    List<Instance> runningInstances = new ArrayList<>();
        try {
            DescribeInstancesRequest request = DescribeInstancesRequest.builder()
                    .instanceIds(instanceIds)
                    .build();
            DescribeInstancesResponse result;
            do {
                // DescribeInstancesResponse is a paginated response, so use tokens with multiple re
                result = ec2.describeInstances(request);
                request = DescribeInstancesRequest.builder()   // Prepare request for next page.
                        .nextToken(result.nextToken())
                        .build();
                for (final Reservation r : result.reservations()) {
                    for (final Instance instance : r.instances()) {
                        // if instance is in a running state, add it to runningInstances list.
                        if (RUNNING_STATES.contains(instance.state().nameAsString())) {
                            runningInstances.add(instance);
                        }
                    }
                }
            } while (result.nextToken() != null);
        } catch (final Ec2Exception exception) {
            // if instance isn't found, assume its terminated and continue.
            if (exception.awsErrorDetails().errorCode().equals(NOT_FOUND_ERROR_CODE)) {
                    LOGGER.info("Instance probably terminated; moving on.");
            } else {
                throw exception;
            }
        }
        return runningInstances;
    }
...
```

Poiché stiamo migrando un singolo metodo in un file Java con otto metodi, abbiamo un mix di importazioni v1 e v2 mentre elaboriamo il file. Abbiamo aggiunto le ultime sei istruzioni di importazione man mano che eseguivamo i passaggi. 

Dopo aver migrato tutto il codice, non ci saranno più istruzioni di importazione v1.

### 6. Rimuovi le dipendenze v1 Maven dalle importazioni POM e v1 dai file
<a name="migration-steps-example-step6"></a>

Dopo aver migrato tutto il codice v1 nel file, abbiamo le seguenti istruzioni di importazione dell'SDK v2.

```
import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.regions.ServiceMetadata;
import software.amazon.awssdk.services.ec2.Ec2Client;
import software.amazon.awssdk.services.ec2.model.CreateTagsRequest;
import software.amazon.awssdk.services.ec2.model.DescribeInstancesRequest;
import software.amazon.awssdk.services.ec2.model.DescribeInstancesResponse;
import software.amazon.awssdk.services.ec2.model.Ec2Exception;
import software.amazon.awssdk.services.ec2.model.Instance;
import software.amazon.awssdk.services.ec2.model.InstanceStateName;
import software.amazon.awssdk.services.ec2.model.Reservation;
import software.amazon.awssdk.services.ec2.model.Tag;
import software.amazon.awssdk.services.ec2.model.TerminateInstancesRequest;
```

Dopo aver migrato *tutti* i file nella nostra applicazione, non abbiamo più bisogno delle dipendenze v1 nel nostro file POM. Rimuovi la BOM v1 dalla `dependencyManagement` sezione, se in uso, e tutti i blocchi di dipendenza v1.

### 7. Rifattorizza il codice per utilizzare i miglioramenti dell'API v2
<a name="migration-steps-example-step7"></a>

Per lo snippet che stiamo migrando, possiamo opzionalmente utilizzare un impaginatore v2 e lasciare che l'SDK gestisca le richieste basate su token per ulteriori dati.

Possiamo sostituire l'intera clausola con la seguente. `do`

```
                DescribeInstancesIterable responses = ec2.describeInstancesPaginator(request);

                responses.reservations().stream()
                        .forEach(reservation -> reservation.instances()
                                .forEach(instance -> {
                                    if (RUNNING_STATES.contains(instance.state().nameAsString())) {
                                        runningInstances.put(instance.instanceId(), instance);
                                    }
                                }));
```

## Nome del pacchetto per le mappature ArtifactID di Maven
<a name="migration-serviceid-artifactid-mapping"></a>

Quando migri il tuo progetto Maven o Gradle dalla v1 dell'SDK for Java alla v2, devi capire quali dipendenze aggiungere al tuo file di build. L'approccio descritto nel [step-by-stepIstruzioni di migrazione con esempio](#migration-steps) (passaggio 3) utilizza i nomi dei pacchetti nelle istruzioni di importazione come punto di partenza per determinare le dipendenze (come ArtifactID) da aggiungere al file di build. 

È possibile utilizzare le informazioni in questo argomento per mappare i nomi dei pacchetti v1 agli artifactID v2.

### Convenzione di denominazione comune utilizzata nei nomi dei pacchetti e nei Maven ArtifactID
<a name="migration-naming-convention"></a>

La tabella seguente mostra la convenzione di denominazione comune SDKs utilizzata per un determinato SERVICE\$1ID. Un SERVICE\$1ID è un identificatore univoco per un. Servizio AWS Ad esempio, il SERVICE\$1ID per il servizio Amazon S3 è `s3` ed `cognitoidentity` è il SERVICE\$1ID per Amazon Cognito Identity.


| nome del pacchetto v1 (dichiarazione di importazione) | artifactID v1 | artifactID v2 | nome del pacchetto v2 (istruzione di importazione) | 
| --- | --- | --- | --- | 
| com.amazonaws.services.service\$1id | aws-java-sdk-ID\$1SERVIZIO | ID\$1SERVIZIO | software.amazon.awssdk.services.service\$1id | 
|   | 
| Esempio di Amazon Cognito Identity (SERVICE\$1ID:) cognitoidentity | 
| com.amazonaws.services. identità cognitiva | aws-java-sdk- identità cognitiva | identità cognitiva | software.amazon.awssdk.services. identità cognitiva | 

### differenze SERVICE\$1ID
<a name="migration-serviceid-diffs"></a>

#### All'interno della v1
<a name="migration-serviceid-diffs-withinv1"></a>

In alcuni casi il SERVICE\$1ID differisce tra il nome del pacchetto e l'artifactID per lo stesso servizio. Ad esempio, la riga CloudWatch Metrics della tabella seguente mostra che `metrics` è il SERVICE\$1ID nel nome del pacchetto ma è il SERVICE\$1ID dell'ArtifactID. `cloudwatchmetrics`

#### All'interno della v2
<a name="migration-serviceid-diffs-withinv2"></a>

Non ci sono differenze nel SERVICE\$1ID utilizzato nei nomi dei pacchetti e negli ArtifactID.

#### Tra v1 e v2
<a name="migration-serviceid-diffs-btwv1v2"></a>

Per la maggior parte dei servizi, il SERVICE\$1ID nella v2 è lo stesso del SERVICE\$1ID della v1 sia nei nomi dei pacchetti che negli ArtifactID. Un esempio di ciò è il SERVICE\$1ID, come mostrato nella tabella precedente. `cognitoedentity` Tuttavia, alcuni SERVICE\$1 IDs differiscono tra quelli mostrati nella SDKs tabella seguente.

Un **SERVICE\$1ID in grassetto** in una delle colonne v1 indica che è diverso dal SERVICE\$1ID utilizzato nella v2.


| Nome del servizio | nome del pacchetto v1 | artifactID v1 | artifactID v2 | nome del pacchetto v2 | 
| --- | --- | --- | --- | --- | 
|  |  Tutti i nomi dei pacchetti iniziano con `com.amazonaws.services` quello mostrato nella prima riga.  |  Tutti gli ArtifactID sono racchiusi tra tag, come mostrato nella prima riga.  |  Tutti gli ArtifactID sono racchiusi tra tag, come mostrato nella prima riga.  |  Tutti i nomi dei pacchetti iniziano con `software.amazon.awssdk` quello mostrato nella prima riga.  | 
|  | 
| Gateway API | com.amazonaws.services.apigateway | <artifactId>aws-java-sdk- gateway API</artifactId> | <artifactId>una porta d'accesso</artifactId> | software.amazon.awssdk.services.apigateway | 
| Registro delle app | registro delle app | apprendistato | registro del catalogo dei servizi | registro del catalogo dei servizi | 
| Application Discovery | scoperta delle applicazioni | scoperta | scoperta delle applicazioni | scoperta delle applicazioni | 
| Runtime AI Augmented | autonomia aerea aumentata | durata dell'aria aumentata | runtime sagemaker a2i | runtime sagemakera2i | 
| Certificate Manager | gestore dei certificati | acm | acm | acm | 
| CloudControl API | API di controllo cloud | API di controllo cloud | controllo cloud | controllo del cloud | 
| CloudSearch | cloudsearch v2 | cloudsearch | cloudsearch | cloudsearch | 
| CloudSearch Dominio | dominio cloudsearch | ricerca nel cloud | dominio cloudsearch | dominio cloudsearch | 
| CloudWatch Eventi | eventi cloudwatch | eventi | eventi cloudwatch | eventi cloudwatch | 
| CloudWatch Evidentemente | Cloudwatch evidentemente | cloudwatch evidentemente | evidently | evidently | 
| CloudWatch Registri | logs | logs | log di cloudwatch | cloudwatchlogs | 
| CloudWatch Metriche | metriche | metriche cloudwatch | cloudwatch | cloudwatch | 
| CloudWatch rum | cloudwatch rum | cloudwatchrum | rum | rum | 
| Provider di identità Cognito | cognitoidp | cognitoidp | provider di cognitoidentity | provider di cognitoidentity | 
| Campagna Connect | connetti la campagna | connetti la campagna | collegare le campagne | collegare le campagne | 
| Connect Wisdom | connetti la saggezza | connettere la saggezza | wisdom | wisdom | 
| Database Migration Service | servizio di migrazione del database | dms | migrazione del database | migrazione del database | 
| DataZone | zona dati | zona dati esterna | zona dati | zona dati | 
| DynamoDB | dinamo dbv2 | dynamodb | dynamodb | dynamodb | 
| File system elastico | file system elastico | efs | efs | efs | 
| Riduzione elastica della mappa | elasticmapreduce | emr | emr | emr | 
| Glue DataBrew | incolla databrew | incollare databrew | databrew | databrew | 
| IAM Roles Anywhere | I miei ruoli sono ovunque | sono ruoli ovunque | rolesanywhere | rolesanywhere | 
| Gestione di identità | gestione dell'identità | iam | iam | iam | 
| Dati IoT | dati IoT | iot | piano dati IoT | piano dati iot | 
| Analisi Kinesis | kinesisanalytics | kinesis | kinesisanalytics | kinesisanalytics | 
| Kinesis Firehose | manichetta antincendio kinesis | kinesis | firehose | firehose | 
| Canali di segnalazione video Kinesis | canali di segnalazione video kinesis | canali di segnalazione video kinesis | segnalazione video kinesis | segnalazione video kinesis | 
| Lex | runtime lex | lex | runtime lex | lexruntime | 
| Attenzione a Vision | fai attenzione alla visione | attenzione alla visione | lookoutvision | lookoutvision | 
| Modernizzazione del mainframe | modernizzazione del mainframe | modernizzazione del mainframe | m2 | m2 | 
| Misurazione del Marketplace | misurazione del mercato | servizio di marketplacemetering | misurazione del marketplace | misurazione del marketplace | 
| Grafana gestita | grafana gestito | grafana gestita | grafana | grafana | 
| Mechanical Turk | mturk | richiedente turco meccanico | mturk | mturk | 
| Suggerimenti di strategia dell'Hub di migrazione | raccomandazioni sulla strategia dell'hub di migrazione | raccomandazioni strategiche di migrationhub | strategia migrationhubs | strategia migrationhub | 
| Nimble Studio | studio agile | studio agile | nimble | nimble | 
| 5G privato | 5g privato | 5g privato | reti private | reti private | 
| Prometheus | prometeo | prometeo | amp | amp | 
| Cestino di riciclaggio | bidone per riciclare | pattumiera | rbin | rbin | 
| API dati di Redshift | redshift data api | redshiftdataapi | dati redshift | dati redshift | 
| Route 53 | domini route53 | route53 | domini route53 | domini route53 | 
| Sage Maker Edge Manager | sagemaker edgemanager | sagemakedgemanager | sagemakeredge | sagemaker edge | 
| Token di sicurezza | token di sicurezza | sts | sts | sts | 
| Migrazione dei server | migrazione del server | migrazione del server | sms | sms | 
| Email semplice | email semplice | ses | ses | ses | 
| Email semplice V2 | email semplice v2 | ses v2 | sesv2 | sesv2 | 
| Gestione semplice dei sistemi | gestione semplice dei sistemi | ssm | ssm | ssm | 
| Flusso di lavoro semplice | flusso di lavoro semplice | flusso di lavoro semplice | swf | swf | 
| Step Functions | funzioni step | funzioni step | sfn | sfn | 