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

# Consumo e pubblicazione di pacchetti Swift
<a name="swift-publish-consume"></a>

## Consumo di pacchetti Swift da CodeArtifact
<a name="consume-swift-packages"></a>

Usa la seguente procedura per consumare pacchetti Swift da un AWS CodeArtifact repository.

**Per utilizzare pacchetti Swift da un repository CodeArtifact**

1. In caso contrario, segui i passaggi indicati [Configura Swift Package Manager con CodeArtifact](configure-swift.md) per configurare Swift Package Manager per utilizzare il tuo CodeArtifact repository con le credenziali corrette.
**Nota**  
Il token di autorizzazione generato è valido per 12 ore. Dovrai crearne uno nuovo se sono trascorse 12 ore dalla creazione del token.

1. Modifica il `Package.swift` file nella cartella del progetto dell'applicazione per aggiornare le dipendenze dei pacchetti che verranno utilizzate dal progetto.

   1. Se il `Package.swift` file non contiene una `dependencies` sezione, aggiungine una.

   1. Nella `dependencies` sezione del `Package.swift` file, aggiungi il pacchetto che desideri utilizzare aggiungendo il relativo identificatore del pacchetto. L'identificatore del pacchetto è costituito dall'ambito e dal nome del pacchetto separati da un punto. Per un esempio, vedi il frammento di codice che segue un passaggio successivo.
**Suggerimento**  
Per trovare l'identificatore del pacchetto, puoi usare la console. CodeArtifact Trova la versione specifica del pacchetto che desideri utilizzare e consulta le istruzioni **rapide di installazione nella** pagina della versione del pacchetto.

   1. Se il `Package.swift` file non contiene una `targets` sezione, aggiungine una.

   1. Nella `targets` sezione, aggiungi gli obiettivi che dovranno utilizzare la dipendenza.

      Il frammento seguente è un frammento di esempio che mostra le sezioni configurate `dependencies` e `targets` le sezioni in un file: `Package.swift`

      ```
      ...
          ],
          dependencies: [
              .package(id: "my_scope.package_name", from: "1.0.0")
          ],
          targets: [
            .target(
               name: "MyApp",
               dependencies: ["package_name"]
            ),...
          ],
      ...
      ```

1. Ora che tutto è configurato, usate il seguente comando per scaricare le dipendenze del pacchetto da. CodeArtifact

   ```
   swift package resolve
   ```

## Consumo di pacchetti Swift da Xcode CodeArtifact
<a name="consume-swift-packages-xcode"></a>

Usa la seguente procedura per consumare pacchetti Swift da un CodeArtifact repository in Xcode.

**Per utilizzare pacchetti Swift da un repository in Xcode CodeArtifact**

1. In caso contrario, segui i passaggi indicati [Configura Swift Package Manager con CodeArtifact](configure-swift.md) per configurare Swift Package Manager per utilizzare il tuo CodeArtifact repository con le credenziali corrette.
**Nota**  
Il token di autorizzazione generato è valido per 12 ore. Dovrai crearne uno nuovo se sono trascorse 12 ore dalla creazione del token.

1. Aggiungi i pacchetti come dipendenza nel tuo progetto in Xcode.

   1. Scegli **File > Aggiungi pacchetti**.

   1. Cerca il tuo pacchetto utilizzando la barra di ricerca. La tua ricerca deve essere inserita nel modulo`package_scope.package_name`.

   1. Una volta trovato, scegli il pacchetto e scegli **Aggiungi pacchetto**.

   1. Una volta verificato il pacchetto, scegli i prodotti del pacchetto che desideri aggiungere come dipendenza e scegli **Aggiungi pacchetto**.

Se riscontri problemi nell'utilizzo del tuo CodeArtifact repository con Xcode, consulta i problemi più comuni e [Risoluzione dei problemi Swift](swift-troubleshooting.md) le possibili correzioni.

## Pubblicazione di pacchetti Swift su CodeArtifact
<a name="publish-swift-packages"></a>

CodeArtifact consiglia Swift 5.9 o versione successiva e utilizza il `swift package-registry publish` comando per pubblicare pacchetti Swift. Se stai usando una versione precedente, devi usare un comando Curl per pubblicare i pacchetti Swift su. CodeArtifact

### Pubblicazione di CodeArtifact pacchetti con il comando `swift package-registry publish`
<a name="publish-swift-packages-publish-command"></a>

Usa la seguente procedura con Swift 5.9 o versione successiva per pubblicare pacchetti Swift in un CodeArtifact repository con Swift Package Manager.

1. In caso contrario, segui i passaggi indicati [Configura Swift Package Manager con CodeArtifact](configure-swift.md) per configurare Swift Package Manager per utilizzare il tuo CodeArtifact repository con le credenziali corrette.
**Nota**  
Il token di autorizzazione generato è valido per 12 ore. Dovrai crearne uno nuovo se sono trascorse 12 ore dalla sua creazione.

1. Vai alla directory del progetto Swift che contiene il `Package.swift` file del tuo pacchetto.

1. Esegui il `swift package-registry publish` comando seguente per pubblicare il pacchetto. Il comando crea un archivio sorgente del pacchetto e lo pubblica nel tuo CodeArtifact repository.

   ```
   swift package-registry publish packageScope.packageName packageVersion
   ```

   Esempio:

   ```
   swift package-registry publish myScope.myPackage 1.0.0
   ```

1. È possibile confermare che il pacchetto è stato pubblicato ed esiste nel repository effettuando il check-in nella console o utilizzando il `aws codeartifact list-packages` comando seguente:

   ```
   aws codeartifact list-packages --domain my_domain --repository my_repo
   ```

   È possibile elencare la versione singola del pacchetto utilizzando il `aws codeartifact list-package-versions` comando seguente:

   ```
   aws codeartifact list-package-versions --domain my_domain --repository my_repo \
   --format swift --namespace my_scope --package package_name
   ```

### Pubblicazione di CodeArtifact pacchetti con Curl
<a name="publish-swift-packages-curl"></a>

Sebbene sia consigliabile utilizzare il `swift package-registry publish` comando fornito con Swift 5.9 o versioni successive, puoi anche usare Curl per pubblicare pacchetti Swift su. CodeArtifact

Usa la seguente procedura per pubblicare pacchetti Swift in un repository con Curl. AWS CodeArtifact 

1. In caso contrario, crea e aggiorna le `CODEARTIFACT_AUTH_TOKEN` variabili e di `CODEARTIFACT_REPO` ambiente seguendo i passaggi riportati di seguito. [Configura Swift Package Manager con CodeArtifact](configure-swift.md)
**Nota**  
Il token di autorizzazione è valido per 12 ore. Dovrai aggiornare la variabile di `CODEARTIFACT_AUTH_TOKEN` ambiente con nuove credenziali se sono trascorse 12 ore dalla sua creazione.

1. Innanzitutto, se non hai creato un pacchetto Swift, puoi farlo eseguendo i seguenti comandi:

   ```
   mkdir testDir && cd testDir
   swift package init
   git init .
   swift package archive-source
   ```

1. Usa il seguente comando Curl per pubblicare il tuo pacchetto Swift su: CodeArtifact

------
#### [ macOS and Linux ]

   ```
   curl -X PUT  --user "aws:$CODEARTIFACT_AUTH_TOKEN" \
   -H "Accept: application/vnd.swift.registry.v1+json" \
   -F source-archive="@test_dir_package_name.zip" \
   "${CODEARTIFACT_REPO}my_scope/package_name/packageVersion"
   ```

------
#### [ Windows ]

   ```
   curl -X PUT  --user "aws:%CODEARTIFACT_AUTH_TOKEN%" \
   -H "Accept: application/vnd.swift.registry.v1+json" \
   -F source-archive="@test_dir_package_name.zip" \
   "%CODEARTIFACT_REPO%my_scope/package_name/packageVersion"
   ```

------

1. Puoi confermare che il pacchetto è stato pubblicato ed esiste nel repository effettuando il check-in nella console o utilizzando il `aws codeartifact list-packages` comando seguente:

   ```
   aws codeartifact list-packages --domain my_domain --repository my_repo
   ```

   È possibile elencare la versione singola del pacchetto utilizzando il `aws codeartifact list-package-versions` comando seguente:

   ```
   aws codeartifact list-package-versions --domain my_domain --repository my_repo \
   --format swift --namespace my_scope --package package_name
   ```

## Recupero di pacchetti Swift GitHub e ripubblicazione su CodeArtifact
<a name="publish-swift-packages-from-github"></a>

Usa la seguente procedura per recuperare un pacchetto Swift da GitHub e ripubblicarlo in un repository. CodeArtifact 

**Per recuperare un pacchetto Swift da e ripubblicarlo in GitHub CodeArtifact**

1. In caso contrario, segui i passaggi indicati [Configura Swift Package Manager con CodeArtifact](configure-swift.md) per configurare Swift Package Manager per utilizzare il tuo CodeArtifact repository con le credenziali corrette.
**Nota**  
Il token di autorizzazione generato è valido per 12 ore. Dovrai crearne uno nuovo se sono trascorse 12 ore dalla creazione del token.

1. Clona il repository git del pacchetto Swift che desideri recuperare e ripubblicare usando il seguente comando. `git clone` [Per informazioni sulla clonazione dei repository, consulta Clonazione di un GitHub repository nei Documenti.](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) GitHub 

   ```
   git clone repoURL
   ```

1. Passa al repository che hai appena clonato:

   ```
   cd repoName
   ```

1. Crea il pacchetto e pubblicalo su. CodeArtifact

   1. **Consigliato:** se utilizzi Swift 5.9 o versioni successive, puoi usare il seguente `swift package-registry publish` comando per creare il pacchetto e pubblicarlo nel tuo repository configurato CodeArtifact .

      ```
      swift package-registry publish packageScope.packageName versionNumber
      ```

      Esempio:

      ```
      swift package-registry publish myScope.myPackage 1.0.0
      ```

   1. Se utilizzi una versione di Swift precedente alla 5.9, devi usare il `swift archive-source` comando per creare il pacchetto e poi usare un comando Curl per pubblicarlo.

      1. Se non hai configurato le variabili `CODEARTIFACT_AUTH_TOKEN` e di `CODEARTIFACT_REPO` ambiente, o sono passate più di 12 ore da quando l'hai fatto, segui i passaggi indicati. [Configura Swift senza il comando di login](configure-swift.md#configure-swift-without-login-command)

      1. Crea il pacchetto Swift usando il `swift package archive-source` comando:

         ```
         swift package archive-source
         ```

         In caso di successo, lo vedrai `Created package_name.zip` nella riga di comando.

      1. Usa il seguente comando Curl per pubblicare il pacchetto Swift su: CodeArtifact

------
#### [ macOS and Linux ]

         ```
         curl -X PUT  --user "aws:$CODEARTIFACT_AUTH_TOKEN" \
         -H "Accept: application/vnd.swift.registry.v1+json" \
         -F source-archive="@package_name.zip" \
         "${CODEARTIFACT_REPO}my_scope/package_name/packageVersion"
         ```

------
#### [ Windows ]

         ```
         curl -X PUT  --user "aws:%CODEARTIFACT_AUTH_TOKEN%" \
         -H "Accept: application/vnd.swift.registry.v1+json" \
         -F source-archive="@package_name.zip" \
         "%CODEARTIFACT_REPO%my_scope/package_name/packageVersion"
         ```

------

1. Puoi confermare che il pacchetto è stato pubblicato ed esiste nel repository effettuando il check-in nella console o utilizzando il `aws codeartifact list-packages` comando seguente:

   ```
   aws codeartifact list-packages --domain my_domain --repository my_repo
   ```

   È possibile elencare la versione singola del pacchetto utilizzando il `aws codeartifact list-package-versions` comando seguente:

   ```
   aws codeartifact list-package-versions --domain my_domain --repository my_repo \
   --format swift --namespace my_scope --package package_name
   ```