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à.
# Pubblica pacchetti su un canale conda Amazon S3
Puoi pubblicare pacchetti conda su un bucket Amazon Simple Storage Service (Amazon S3) in modo che gli operatori di AWS Deadline Cloud (Deadline Cloud) possano installarli per eseguire lavori. Il `rattler-build publish` comando funziona con Amazon S3 allo stesso modo di un canale di filesystem locale. Il comando può creare una ricetta e pubblicare il risultato oppure pubblicare un file di pacchetto già creato. In entrambi i casi, il comando carica il pacchetto nel bucket e indicizza il canale in un unico passaggio.
Il `rattler-build publish` comando si autentica AWS utilizzando la catena di credenziali standard, quindi utilizza la configurazione come qualsiasi altro strumento. AWS AWS *Per ulteriori informazioni sulla configurazione delle credenziali, consultate Configurazione [e impostazioni dei file di credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) nella Guida per l'utente ().AWS Command Line Interface AWS CLI*
## Prerequisiti
Prima di pubblicare pacchetti su Amazon S3, completa i seguenti prerequisiti:
+ **pixi e rattler-build**[: installa pixi da pixi.sh, quindi installa.](https://pixi.sh) `rattler-build`
```
pixi global install rattler-build
```
+ **git** — Necessario per clonare il repository degli esempi. OnWindows, [git for](https://gitforwindows.org/) fornisce Windows anche una `bash` shell, richiesta da alcune ricette di Windows esempio.
+ Bucket **Amazon S3: un bucket** Amazon S3 da utilizzare come canale conda. Puoi utilizzare il bucket Job Attachments della tua Deadline Cloud farm o creare un bucket separato.
+ **AWS credenziali**: configura le credenziali sulla tua workstation utilizzando il comando o il comando. `aws configure` `aws login` Per ulteriori informazioni, consulta [Configurazione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html) nella *Guida per l'utente di AWS Command Line Interface *.
+ **Autorizzazioni IAM** — (Facoltativo) Per ridurre l'ambito delle autorizzazioni a disposizione delle tue credenziali, puoi utilizzare una policy AWS Identity and Access Management (IAM) che concede solo le seguenti autorizzazioni sul bucket Amazon S3 e sul prefisso di canale che utilizzi (ad esempio,): `/Conda/*`
+ `s3:GetObject`
+ `s3:PutObject`
+ `s3:DeleteObject`
+ `s3:ListBucket`
+ `s3:GetBucketLocation`
## Pubblicazione di un pacchetto su un canale Amazon S3
Usalo `rattler-build publish` con un `s3://` target per pubblicare un pacchetto sul tuo canale Amazon S3 conda. Se il canale non esiste nel bucket, `rattler-build` inizializza automaticamente il canale. [Prima di iniziare, assicuratevi di aver completato i prerequisiti.](#publish-s3-prereqs)
L'esempio seguente pubblica la ricetta di esempio Blender 4.5 dal repository di [esempi di Deadline Cloud su](https://github.com/aws-deadline/deadline-cloud-samples). GitHub È possibile sostituire una ricetta diversa dall'archivio degli esempi o utilizzare una ricetta personalizzata.
**Nota**
Le applicazioni di grandi dimensioni possono richiedere decine di GB di spazio libero su disco per l'archivio di origine, i file estratti e l'output di compilazione. Assicurati di utilizzare un disco con spazio disponibile sufficiente per l'output di compilazione del pacchetto.
**Per pubblicare un pacchetto su un canale Amazon S3**
1. Clona l'archivio di esempi di Deadline Cloud.
```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Passare alla directory `conda_recipes`.
```
cd deadline-cloud-samples/conda_recipes
```
1. Eseguire il seguente comando seguente. Sostituiscilo {{amzn-s3-demo-bucket}} con il nome del tuo bucket.
```
rattler-build publish blender-4.5/recipe/recipe.yaml --to s3://amzn-s3-demo-bucket/Conda/Default --build-number=+1
```
Il `/Conda/Default` prefisso organizza il canale all'interno del bucket. È possibile utilizzare un prefisso diverso, ma il prefisso deve essere coerente in tutti i comandi e le configurazioni di coda che fanno riferimento al canale.
**Informazioni sui numeri di build**
L'`--build-number=+1`opzione seleziona automaticamente il numero di build successivo in base a ciò che già esiste nel canale di destinazione. La migliore pratica è quella di non sovrascrivere mai un pacchetto in un canale. Crea sempre con un nuovo numero di build se altrimenti il pacchetto avrebbe lo stesso nome di file. Using `--build-number=+1` consente di raggiungere questo obiettivo quando si passa a un canale di produzione o a un canale di staging che rispecchia la produzione.
Se desideri controllare direttamente il numero di build, puoi impostarlo con un valore specifico come. `--build-number=7` Se ometti l'opzione, `rattler-build` utilizza il numero di build definito nel `recipe.yaml` file.
Se la ricetta del pacchetto dipende dai pacchetti di un canale particolare, come [conda-forge](https://conda-forge.org/), `-c conda-forge` aggiungila al comando.
Puoi anche pubblicare un file di pacchetto che hai già creato, ad esempio un `.conda` file da una build locale. {{amzn-s3-demo-bucket}}Sostituiscilo con il nome del tuo bucket.
```
rattler-build publish output/linux-64/blender-4.5.0-hb0f4dca_0.conda \
--to s3://amzn-s3-demo-bucket/Conda/Default
```
## Inizializzazione o reindicizzazione di un canale
Quando si utilizza `rattler-build publish` per pubblicare un pacchetto, il comando inizializza automaticamente il canale se il canale non esiste già. Nella maggior parte dei casi, non è necessario inizializzare o reindicizzare il canale manualmente.
Potrebbe essere necessario inizializzare o reindicizzare manualmente un canale nelle seguenti situazioni:
+ Desideri creare un canale vuoto prima di pubblicare qualsiasi pacchetto, ad esempio per verificare che l'ambiente di coda di Deadline Cloud possa connettersi al canale.
+ Hai caricato o eliminato `.conda` file direttamente con gli strumenti di Amazon S3 anziché utilizzarli `rattler-build publish` e l'indice dei canali non è aggiornato.
### Inizializzazione di un canale vuoto
Per inizializzare un canale vuoto, create un `repodata.json` file e caricatelo `noarch` nella sottodirectory del prefisso del canale. Sostituiscilo {{amzn-s3-demo-bucket}} con il nome del tuo bucket.
```
echo '{"info":{"subdir":"noarch"},"packages":{},"packages.conda":{},"removed":[],"repodata_version":1}' > empty_channel_repodata.json
aws s3api put-object --body empty_channel_repodata.json --key Conda/Default/noarch/repodata.json --bucket {{amzn-s3-demo-bucket}}
```
Il `/Conda/Default` prefisso deve corrispondere al prefisso del canale utilizzato dall'ambiente di coda. Dopo aver inizializzato il canale, è possibile pubblicare pacchetti sul canale utilizzando. `rattler-build publish`
### Reindicizzazione di un canale
Se l'indice del canale non è aggiornato, utilizzalo `rattler-index` per ricostruire l'indice dai file del pacchetto nel canale. Innanzitutto, installa`rattler-index`.
```
pixi global install rattler-index
```
Quindi reindicizza il canale. {{amzn-s3-demo-bucket}}Sostituiscilo con il nome del tuo bucket.
```
rattler-index s3 s3://amzn-s3-demo-bucket/Conda/Default
```
## Test del pacchetto
Dopo aver pubblicato il pacchetto, create un progetto pixi temporaneo per verificare che il pacchetto funzioni correttamente. Il progetto installa il pacchetto dal canale Amazon S3.
**Per testare il pacchetto**
1. Crea una directory di test temporanea e inizializza un progetto pixi con il canale Amazon S3. Sostituiscilo {{amzn-s3-demo-bucket}} con il nome del tuo bucket.
```
mkdir package-test-env
cd package-test-env
pixi init --channel s3://amzn-s3-demo-bucket/Conda/Default
```
1. Aggiungi il pacchetto al progetto.
```
pixi add blender=4.5
```
1. Verifica che il pacchetto funzioni correttamente.
```
pixi run blender --version
```
Il [https://pixi.sh/latest/reference/cli/pixi/run/](https://pixi.sh/latest/reference/cli/pixi/run/)comando attiva l'ambiente conda per la directory del progetto ed esegue il comando specificato al suo interno. L'ambiente persiste nella directory del progetto, quindi è possibile utilizzare lo stesso `pixi run` comando da altri terminali.
## Rimozione dei pacchetti dal canale
Evitate di rimuovere i pacchetti dai canali utilizzati per la produzione, perché i lockfile fanno riferimento a pacchetti specifici tramite hash. La rimozione di un pacchetto impedisce di ricreare ambienti da quei file di blocco. Per i canali di sviluppo e test, è possibile rimuovere un pacchetto specifico eliminando il `.conda` file dal bucket e quindi reindicizzando il canale.
Eliminate il file del pacchetto e quindi reindicizzate il canale. {{amzn-s3-demo-bucket}}Sostituiscilo con il nome del tuo bucket.
```
aws s3 rm s3://amzn-s3-demo-bucket/Conda/Default/linux-64/blender-4.5.0-hb0f4dca_1.conda
```
Dopo aver eliminato il file, reindicizza il canale per aggiornare i metadati del canale. Per istruzioni, consultate [Reindicizzazione](#publish-s3-reindex) di un canale.
I file del pacchetto vengono archiviati in sottodirectory specifiche della piattaforma come, o. `linux-64` `win-64` `osx-arm64` Per elencare i pacchetti in una sottodirectory, esegui il comando seguente.
```
aws s3 ls s3://amzn-s3-demo-bucket/Conda/Default/linux-64/
```
## Pulizia
Dopo il test, rimuovete la directory del progetto di test.
**Per ripulire le risorse di test**
+ Rimuovi la directory del progetto di test.
Su Linux emacOS, esegui il seguente comando.
```
rm -rf package-test-env
```
Su Windows (cmd), esegui il comando seguente.
```
rmdir /s /q package-test-env
```
## Compilazioni di debug
Se una compilazione fallisce, `rattler-build` conserva la directory di compilazione in modo da poter indagare. Esegui il comando seguente per aprire una shell interattiva nell'ambiente di compilazione con tutte le variabili di ambiente impostate com'erano durante la compilazione.
```
rattler-build debug shell
```
Dalla shell di debug, puoi modificare i file, eseguire singoli comandi di compilazione e aggiungere dipendenze per isolare il problema. Per ulteriori informazioni, consulta [Debugging](https://rattler-build.prefix.dev/latest/debugging_builds/) build nella documentazione di rattler-build.
## Creazione di pacchetti per altre piattaforme
Il `rattler-build publish` comando crea pacchetti per il sistema operativo della workstation su cui viene eseguito il comando. Se la tua flotta Deadline Cloud utilizza un sistema operativo diverso dalla tua workstation o se il tuo pacchetto ha altri requisiti di host, hai le seguenti opzioni:
+ Esegui `rattler-build publish` su un host che corrisponde al sistema operativo di destinazione. Ad esempio, usa un'istanza Amazon Elastic Compute Cloud (Amazon EC2) in Linux esecuzione per creare pacchetti per una flotta. Linux
+ Usa una coda di creazione di pacchetti Deadline Cloud per automatizzare le build sulla piattaforma di destinazione. Vedi [Creare una coda per la creazione di pacchetti](automate-package-builds.md#s3-channel-create-queue).
+ (Avanzato) Usa la compilazione incrociata per creare pacchetti per una piattaforma diversa dalla tua workstation. Per ulteriori informazioni, consulta la [compilazione incrociata](https://rattler-build.prefix.dev/latest/compilers/#cross-compilation) nella documentazione di rattler-build.
## Fasi successive
Dopo aver pubblicato i pacchetti sul tuo canale Amazon S3 conda, configura le code di Deadline Cloud per utilizzare il canale:
+ [Configura le autorizzazioni della coda di produzione per pacchetti conda personalizzati](configure-jobs-s3-channel.md#s3-channel-configure-permissions): concedi alle tue code di produzione l'accesso in sola lettura al canale conda di Amazon S3.
+ [Aggiungi un canale conda a un ambiente di coda: configura l'ambiente](configure-jobs-s3-channel.md#s3-channel-add-channel) di coda per installare i pacchetti dal canale conda di Amazon S3.