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

# Configura il AWS SDK per Kotlin
<a name="setup"></a>

Per effettuare richieste di Servizi AWS utilizzo di AWS SDK per Kotlin, è necessario quanto segue:
+ La possibilità di accedere al portale di AWS accesso
+ Autorizzazione a utilizzare le AWS risorse necessarie all'applicazione
+ Un ambiente di sviluppo con i seguenti elementi:
  + [File di configurazione condivisi](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) configurati con almeno uno dei seguenti modi:
    + Il `config` file contiene le impostazioni delle credenziali di IAM Identity Center in modo che l'SDK possa ottenere le credenziali AWS 
    + Il `credentials` file contiene credenziali temporanee
  + [Uno strumento di automazione delle build come [Gradle](https://gradle.org/install/) o Maven](https://maven.apache.org/download.cgi) 
+ Una sessione attiva del portale di AWS accesso quando si è pronti per eseguire l'applicazione

**Topics**
+ [Configurazione di base](setup-basic-onetime-setup.md)
+ [Crea file di build del progetto](setup-create-project-file.md)
+ [Codifica il tuo progetto Kotlin usando l'SDK per Kotlin](code-project.md)

# Configurazione di base
<a name="setup-basic-onetime-setup"></a>

## Panoramica di
<a name="setup-overview"></a>

Per sviluppare correttamente applicazioni che consentano l'accesso Servizi AWS tramite AWS SDK per Kotlin, è necessario soddisfare i seguenti requisiti.
+ È necessario essere in grado di [AWS accedere al portale di accesso](#setup-awsaccount) disponibile in AWS IAM Identity Center.
+ Le [autorizzazioni del ruolo IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) configurato per l'SDK devono consentire l'accesso a Servizi AWS ciò che l'applicazione richiede. Le autorizzazioni associate alla policy **PowerUserAccess** AWS gestita sono sufficienti per la maggior parte delle esigenze di sviluppo.
+ Un ambiente di sviluppo con i seguenti elementi:
  + [File di configurazione condivisi](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) configurati in almeno uno dei seguenti modi:
    + Il `config` file contiene le [impostazioni Single Sign-On di IAM Identity Center in](#setup-sso-access) modo che l'SDK possa ottenere le credenziali. AWS 
    + Il `credentials` file contiene credenziali temporanee.
  + Un'[installazione di Java 8 o versione successiva](#setup-envtools).
  + [Uno [strumento di automazione delle build](#setup-envtools) come [Maven o Gradle](https://maven.apache.org/download.cgi).](https://gradle.org/install/)
  + Un editor di testo per lavorare con il codice.
  + [(Facoltativo, ma consigliato) Un IDE (ambiente di sviluppo integrato) come [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows) o Eclipse.](https://www.eclipse.org/ide/)

    Quando usi un IDE, puoi anche integrarlo con Kit di strumenti AWS s per lavorare più facilmente. Servizi AWS I [Kit di strumenti AWS per IntelliJ](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)e [AWS Toolkit for Eclipse](https://docs.aws.amazon.com/toolkit-for-eclipse/v1/user-guide/welcome.html)sono due toolkit che puoi usare.
+ Una sessione attiva del portale di AWS accesso quando si è pronti per eseguire l'applicazione. La usi AWS Command Line Interface per [avviare la procedura di accesso al portale di accesso](#setup-login-sso) di IAM Identity Center. AWS 

**Importante**  
Le istruzioni in questa sezione di configurazione presuppongono che tu o l'organizzazione utilizzi IAM Identity Center. Se la tua organizzazione utilizza un provider di identità esterno che funziona indipendentemente da IAM Identity Center, scopri come ottenere credenziali temporanee da utilizzare nell'SDK per Kotlin. Segui queste istruzioni per aggiungere credenziali temporanee al file. `~/.aws/credentials`  
Se il tuo provider di identità aggiunge automaticamente credenziali temporanee al `~/.aws/credentials` file, assicurati che il nome del profilo sia `[default]` tale da non dover fornire un nome di profilo all'SDK o. AWS CLI

## Capacità di accesso al portale di accesso AWS
<a name="setup-awsaccount"></a>

Il portale di AWS accesso è il luogo web in cui è possibile accedere manualmente allo IAM Identity Center. Il formato dell'URL è `d-xxxxxxxxxx.awsapps.com/start` o`your_subdomain.awsapps.com/start`. 

Se non conosci il portale di AWS accesso, segui le linee guida per l'accesso all'account nell'argomento sull'[autenticazione di IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) nella AWS SDKs and Tools Reference Guide.

## Configura l'accesso Single Sign-On per l'SDK
<a name="setup-sso-access"></a>

Dopo aver completato il passaggio 2 della [sezione sull'accesso programmatico](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted) affinché l'SDK utilizzi l'autenticazione IAM Identity Center, il sistema deve contenere i seguenti elementi.
+ Il AWS CLI, che viene utilizzato per avviare una [sessione del portale di AWS accesso](#setup-login-sso) prima di eseguire l'applicazione.
+ Un `~/.aws/config` file che contiene un [profilo predefinito](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile). L'SDK per Kotlin utilizza la configurazione del provider di token SSO del profilo per acquisire le credenziali prima di inviare richieste a. AWS Il valore `sso_role_name`, che è un ruolo IAM connesso a un set di autorizzazioni di IAM Identity Center, dovrebbe consentire l'accesso ai Servizi AWS utilizzati nell'applicazione.

  Il seguente `config` file di esempio mostra un profilo predefinito impostato con la configurazione del provider di token SSO. L'impostazione `sso_session` del profilo si riferisce alla sezione `sso-session` denominata. La `sso-session` sezione contiene le impostazioni per avviare una sessione del portale di AWS accesso.

  ```
  [default]
  sso_session = my-sso
  sso_account_id = 111122223333
  sso_role_name = SampleRole
  region = us-east-1
  output = json
  
  [sso-session my-sso]
  sso_region = us-east-1
  sso_start_url = https://provided-domain.awsapps.com/start
  sso_registration_scopes = sso:account:access
  ```

Per maggiori dettagli sulle impostazioni utilizzate nella configurazione del provider di token SSO, consulta Configurazione del provider di [token SSO nella AWS SDKs and Tools Reference](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) Guide.

Se l'ambiente di sviluppo non è configurato per l'accesso programmatico come mostrato in precedenza, segui il [passaggio 2 della SDKs Guida di riferimento](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted).

## Effettuate l'accesso utilizzando il AWS CLI
<a name="setup-login-sso"></a>

Prima di eseguire un'applicazione che consente l'accesso Servizi AWS, è necessaria una sessione attiva del portale di AWS accesso affinché l'SDK utilizzi l'autenticazione IAM Identity Center per risolvere le credenziali. Esegui il seguente comando in AWS CLI per accedere al portale di accesso. AWS 

```
aws sso login
```

Poiché si dispone di una configurazione predefinita del profilo, non è necessario chiamare il comando con un'`--profile`opzione. Se la configurazione del provider di token SSO utilizza un profilo denominato, il comando è`aws sso login --profile named-profile`.

Per verificare se hai già una sessione attiva, esegui il seguente comando AWS CLI .

```
aws sts get-caller-identity
```

La risposta a questo comando dovrebbe restituire l'account IAM Identity Center e il set di autorizzazioni configurati nel file `config` condiviso.

**Nota**  
Se hai già una sessione attiva del portale di accesso AWS e hai già eseguito `aws sso login`, non ti verrà richiesto di fornire credenziali.   
Tuttavia, verrà visualizzata una finestra di dialogo che richiede l'autorizzazione per accedere `botocore` alle informazioni. `botocore`è la base per AWS CLI .   
Seleziona **Consenti** per autorizzare l'accesso alle tue informazioni per AWS CLI e SDK per Kotlin.

## Installa Java e uno strumento di compilazione
<a name="setup-envtools"></a>

Il tuo ambiente di sviluppo richiede quanto segue:
+ JDK 8 o versione successiva. AWS SDK per Kotlin [Funziona con l'[Oracle Java SE Development Kit](https://www.oracle.com/java/technologies/javase-downloads.html) e con le distribuzioni di Open Java Development Kit (OpenJDK) come [Amazon Corretto](https://aws.amazon.com/corretto/)[Red](https://developers.redhat.com/products/openjdk) Hat OpenJDK e JDK. AdoptOpen](https://adoptopenjdk.net/)
+ Uno strumento di compilazione o IDE che supporta Maven Central come Apache Maven, Gradle o IntelliJ.
  + [Per informazioni su come installare e utilizzare Maven, consulta http://maven.apache.org/.](http://maven.apache.org/)
  + [Per informazioni su come installare e usare Gradle, vedi https://gradle.org/.](https://gradle.org/)
  + Per informazioni su come installare e utilizzare IntelliJ IDEA, vedere. [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/)

## Utilizzo di credenziali temporanee
<a name="setup-use-temporary-creds"></a>

In alternativa alla [configurazione dell'accesso Single Sign-On di IAM Identity Center per l'](#setup-sso-access)SDK, puoi configurare il tuo ambiente di sviluppo con credenziali temporanee.

**Configura un file di credenziali locale per credenziali temporanee**

1. [Crea un file di credenziali condiviso](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html)

1. Nel file delle credenziali, incolla il seguente testo segnaposto finché non incolli le credenziali temporanee funzionanti:

   ```
   [default]
   aws_access_key_id=<value from AWS access portal>
   aws_secret_access_key=<value from AWS access portal>
   aws_session_token=<value from AWS access portal>
   ```

1. Salvare il file. Il file `~/.aws/credentials` dovrebbe ora esistere sul tuo sistema di sviluppo locale. Questo file contiene il [profilo [predefinito]](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) che l'SDK per Kotlin utilizza se non viene specificato un profilo denominato specifico. 

1. [Accedi al portale di accesso AWS](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html)

1. Segui queste istruzioni sotto l'intestazione [Aggiornamento manuale delle credenziali](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) per copiare le credenziali del ruolo IAM dal AWS portale di accesso.

   1. Per la fase 4 delle istruzioni collegate, scegli il nome del ruolo IAM che concede l'accesso per le tue esigenze di sviluppo. Questo ruolo in genere ha un nome simile **PowerUserAccess**a **Developer**.

   1. Per il passaggio 7, seleziona l'opzione **Aggiungi manualmente un profilo al file delle AWS credenziali** e copia il contenuto.

1. Incolla le credenziali copiate nel `credentials` file locale e rimuovi il nome del profilo generato. Il file dovrebbe essere simile al seguente:

   ```
   [default]
   aws_access_key_id=AKIAIOSFODNN7EXAMPLE
   aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
   ```

1. Salva il file `credentials`

L'SDK per Kotlin accederà a queste credenziali temporanee quando creerà un client di servizio e le utilizzerà per ogni richiesta. Le impostazioni per il ruolo IAM scelto nella fase 5a determinano per [quanto tempo sono valide le](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html) credenziali temporanee. La durata massima è di dodici ore.

Dopo la scadenza delle credenziali temporanee, ripeti i passaggi da 4 a 7.

# Crea file di build del progetto
<a name="setup-create-project-file"></a>

Dopo aver configurato l'accesso Single Sign-On e il tuo ambiente di sviluppo, crea un progetto Kotlin utilizzando il tuo strumento di compilazione preferito. Nel file di build, specifica le dipendenze a Servizi AWS cui l'applicazione deve accedere.

[Per visualizzare l'elenco di tutti i possibili nomi di artefatti Maven, consulta la documentazione di riferimento dell'API.](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/index.html) [Per trovare la versione più recente dell'SDK, controlla l'ultima versione su. GitHub](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)

I seguenti file di build di esempio forniscono gli elementi necessari per iniziare a codificare un progetto con sette. Servizi AWS

------
#### [ Gradle ]

 AWS SDK per Kotlin Pubblica un [catalogo di versioni di Gradle](https://docs.gradle.org/current/userguide/version_catalogs.html) e una distinta base (BOM) che possono aiutarti a scoprire i nomi delle dipendenze e a mantenere i numeri di versione sincronizzati tra più artefatti. 

Nota che i cataloghi delle versioni sono una funzionalità di anteprima di Gradle prima della versione 8. [A seconda della versione di Gradle utilizzata, potrebbe essere necessario effettuare l'attivazione tramite l'API Feature Preview.](https://docs.gradle.org/current/userguide/feature_lifecycle.html#feature_preview)

**Per utilizzare un catalogo di versioni Gradle**

1. Nel tuo `settings.gradle.kts` file, aggiungi un `versionCatalogs` blocco all'interno del `dependencyResolutionManagement` blocco.

   Il seguente file di esempio configura il catalogo delle AWS SDK per Kotlin versioni. È possibile accedere al *X.Y.Z* collegamento per visualizzare l'ultima versione disponibile.

   ```
   plugins {
       id("org.gradle.toolchains.foojay-resolver-convention") version "[https://plugins.gradle.org/plugin/org.gradle.toolchains.foojay-resolver-convention](https://plugins.gradle.org/plugin/org.gradle.toolchains.foojay-resolver-convention)"
   }
   rootProject.name = "your-project-name"
   
   dependencyResolutionManagement {
       repositories {
           mavenCentral()
       }
   
       versionCatalogs {
           create("awssdk") {
               from("aws.sdk.kotlin:version-catalog:[https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)")
           }
       }
   }
   ```

1. Dichiara le dipendenze `build.gradle.kts` utilizzando gli identificatori type-safe resi disponibili dal catalogo delle versioni.

   Il seguente file di esempio dichiara le dipendenze per sette. Servizi AWS

   ```
   plugins {
       kotlin("jvm") version "[X.Y.Z](https://plugins.gradle.org/plugin/org.jetbrains.kotlin.jvm)"
       application
   }
   
   group = "org.example"
   version = "1.0-SNAPSHOT"
   
   repositories {
       mavenCentral()
   }
   
   dependencies {
       implementation(platform(awssdk.bom))
       implementation(platform("org.apache.logging.log4j:log4j-bom:[https://search.maven.org/#search|gav|1|g:org.apache.logging.log4j%20AND%20a:log4j-bom](https://search.maven.org/#search|gav|1|g:org.apache.logging.log4j%20AND%20a:log4j-bom)"))
   
       implementation(awssdk.services.s3)
       implementation(awssdk.services.dynamodb)
       implementation(awssdk.services.iam)
       implementation(awssdk.services.cloudwatch)
       implementation(awssdk.services.cognitoidentityprovider)
       implementation(awssdk.services.sns)
       implementation(awssdk.services.pinpoint)
       implementation("org.apache.logging.log4j:log4j-slf4j2-impl")
   
       // Test dependency.
       testImplementation(kotlin("test"))
   }
   
   tasks.test {
       useJUnitPlatform()
   }
   
   java {
       toolchain {
           languageVersion = JavaLanguageVersion.of(X*)
       }
   }
   
   application {
       mainClass = "org.example.AppKt"
   }
   ```

   \$1 Versione Java, ad esempio `17` o. `21`

------
#### [ Maven ]

Il seguente `pom.xml` file di esempio ha dipendenze per sette Servizi AWS. È possibile accedere al *X.Y.Z* collegamento per visualizzare l'ultima versione disponibile.

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>setup</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <aws.sdk.kotlin.version>[https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)</aws.sdk.kotlin.version>
        <kotlin.version>[X.Y.Z](https://kotlinlang.org/docs/releases.html#release-details)</kotlin.version>
        <log4j.version>[https://search.maven.org/#search|gav|1|g:org.apache.logging.log4j%20AND%20a:log4j-bom](https://search.maven.org/#search|gav|1|g:org.apache.logging.log4j%20AND%20a:log4j-bom)</log4j.version>
        <junit.jupiter.version>[https://search.maven.org/#search|gav|1|g:org.junit.jupiter%20AND%20a:junit-jupiter](https://search.maven.org/#search|gav|1|g:org.junit.jupiter%20AND%20a:junit-jupiter)</junit.jupiter.version>
        <jvm.version>X*</jvm.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>aws.sdk.kotlin</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.sdk.kotlin.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-bom</artifactId>
                <version>${log4j.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>s3-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>dynamodb-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>iam-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>cloudwatch-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>cognitoidentityprovider-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>sns-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>aws.sdk.kotlin</groupId>
            <artifactId>pinpoint-jvm</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j2-impl</artifactId>
        </dependency>

        <!-- Test dependencies -->
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-test-junit</artifactId>
            <version>${kotlin.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit.jupiter.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <sourceDirectory>src/main/kotlin</sourceDirectory>
        <testSourceDirectory>src/test/kotlin</testSourceDirectory>

        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <version>${kotlin.version}</version>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <jvmTarget>${jvm.version}</jvmTarget>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
```

\$1 Versione Java, ad esempio `17` o`21`.

------

# Codifica il tuo progetto Kotlin usando l'SDK per Kotlin
<a name="code-project"></a>

Ora inizia il divertimento. Durante lo sviluppo dell'applicazione, puoi fare riferimento all'[AWS SDK per Kotlin API Reference](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/index.html) per informazioni complete sulle operazioni dell'API. Utilizza i seguenti link per informazioni generali sull'API Kotlin:
+ [Riferimento all'API della libreria standard](https://kotlinlang.org/api/latest/jvm/stdlib/)
+ [Panoramica di Coroutines](https://kotlinlang.org/docs/coroutines-overview.html)
+ [API Coroutines](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/)

## Effettua il login utilizzando il AWS CLI
<a name="code-project-login-cli"></a>

Ogni volta che si esegue un programma che accede Servizi AWS, è necessaria una sessione attiva del portale di AWS accesso. A tale scopo, eseguire questo comando :

```
aws sso login
```

Poiché disponi di una configurazione predefinita del profilo, non devi chiamare il comando con un'opzione `--profile`. Se la configurazione Single Sign-On di IAM Identity Center utilizza un profilo denominato, il comando è. `aws sso login --profile named-profile`

Per verificare se hai già una sessione attiva, esegui il comando seguente AWS CLI .

```
aws sts get-caller-identity
```

La risposta a questo comando dovrebbe restituire l'account IAM Identity Center e il set di autorizzazioni configurati nel file `config` condiviso.