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à.
# Memorizzazione nella cache delle chiamate per le esecuzioni HealthOmics
AWS HealthOmics supporta la memorizzazione nella cache delle chiamate, nota anche come resume, per flussi di lavoro privati. La memorizzazione nella cache delle chiamate salva gli output delle attività del flusso di lavoro completate al termine di un'esecuzione. Le esecuzioni successive possono utilizzare gli output delle attività dalla cache, anziché calcolare nuovamente gli output delle attività. La memorizzazione nella cache delle chiamate riduce l'utilizzo delle risorse di elaborazione, il che si traduce in durate di esecuzione più brevi e risparmi sui costi di elaborazione.
È possibile accedere ai file di output delle attività memorizzati nella cache al termine dell'esecuzione. Per eseguire il debug avanzato e la risoluzione dei problemi delle attività, è possibile memorizzare nella cache i file di attività intermedi specificando tali file come output delle attività nella definizione del flusso di lavoro.
È possibile utilizzare la memorizzazione nella cache delle chiamate per salvare i risultati delle attività completate dalle esecuzioni non riuscite. L'esecuzione successiva inizia dall'ultima attività completata con successo, anziché calcolare nuovamente le attività completate.
Se HealthOmics non trova una voce della cache corrispondente per un'attività, l'esecuzione non ha esito negativo. HealthOmics ricalcola l'attività e le relative attività dipendenti.
Per informazioni sulla risoluzione dei problemi relativi alla memorizzazione nella cache delle chiamate, vedere. [Risoluzione dei problemi relativi alla memorizzazione nella cache delle chiamate](troubleshooting.md#workflow-cache-troubleshooting)
**Topics**
+ [Come funziona la memorizzazione nella cache delle chiamate](how-run-cache.md)
+ [Creazione di una cache di esecuzione](workflow-cache-create.md)
+ [Aggiornamento di una cache di esecuzione](workflow-cache-update.md)
+ [Eliminazione di una cache di esecuzione](workflow-cache-delete.md)
+ [Contenuto di una cache di esecuzione](workflow-cache-contents.md)
+ [Funzionalità di memorizzazione nella cache specifiche del motore](workflow-cache-per-engine.md)
+ [Utilizzo della cache di esecuzione](workflow-cache-startrun.md)
# Come funziona la memorizzazione nella cache delle chiamate
Per utilizzare la memorizzazione nella cache delle chiamate, devi creare una cache di esecuzione e configurarla per avere una posizione Amazon S3 associata per i dati memorizzati nella cache. Quando avvii un'esecuzione, specifichi la cache di esecuzione. Una cache di esecuzione non è dedicata a un unico flusso di lavoro. Le esecuzioni da più flussi di lavoro possono utilizzare la stessa cache.
Durante la fase di esportazione di un'esecuzione, il sistema esporta gli output delle attività completate nella posizione Amazon S3. Per esportare file di attività intermedi, dichiarali come output delle attività nella definizione del flusso di lavoro. La memorizzazione nella cache delle chiamate salva inoltre internamente i metadati e crea hash unici per ogni voce della cache.
Per ogni attività in esecuzione, il motore di workflow rileva se esiste una voce della cache corrispondente per questa attività. Se non esiste una voce di cache corrispondente, HealthOmics calcola l'operazione. Se è presente una voce della cache corrispondente, il motore recupera i risultati memorizzati nella cache.
Per abbinare le voci della cache, HealthOmics utilizza il meccanismo di hashing incluso nei motori di flusso di lavoro nativi. HealthOmicsestende queste implementazioni hash esistenti per tenere conto di HealthOmics variabili, come S3 ETags e container digest ECR.
HealthOmics supporta la memorizzazione nella cache delle chiamate per queste versioni linguistiche del flusso di lavoro:
+ versioni WDL 1.0, 1.1 e versione di sviluppo
+ Nextflow versione 23.10 e 24.10
+ Tutte le versioni CWL
**Nota**
HealthOmics non supporta la memorizzazione nella cache delle chiamate per i flussi di lavoro Ready2Run.
**Topics**
+ [Modello di responsabilità condivisa](#run-cache-srm)
+ [Requisiti di memorizzazione nella cache per le attività](#workflow-cache-task-prereqs)
+ [Esegui le prestazioni della cache](#run-cache-performance)
+ [Eventi di conservazione e invalidazione dei dati della cache](#workflow-cache-data)
## Modello di responsabilità condivisa
Esiste una responsabilità condivisa tra gli utenti e consiste nel determinare se le attività e AWS le esecuzioni siano idonee per la memorizzazione nella cache delle chiamate. La memorizzazione nella cache delle chiamate consente di ottenere i migliori risultati quando tutte le attività sono idempotenti (le esecuzioni ripetute di un'attività utilizzando gli stessi input producono gli stessi risultati).
Tuttavia, se un'attività include elementi non deterministici (come generazioni di numeri casuali o l'ora del sistema), le esecuzioni ripetute dell'attività utilizzando gli stessi input possono generare output diversi. Ciò può influire sull'efficacia della memorizzazione nella cache delle chiamate nei seguenti modi:
+ Se HealthOmics utilizza una voce della cache (creata da un'esecuzione precedente) che non è identica all'output che l'esecuzione dell'attività produrrebbe per l'esecuzione corrente, l'esecuzione potrebbe produrre risultati diversi rispetto alla stessa esecuzione senza memorizzazione nella cache.
+ HealthOmics potrebbe non trovare una voce della cache corrispondente per un'attività che dovrebbe corrispondere, a causa degli output dell'attività non deterministici. Se non trova la voce di cache valida, run ricalcola inutilmente l'operazione, con conseguente riduzione dei vantaggi in termini di costi derivanti dall'utilizzo della memorizzazione nella cache delle chiamate.
Di seguito sono riportati i comportamenti noti delle attività che possono causare risultati non deterministici che influiscono sui risultati della memorizzazione nella cache delle chiamate:
+ Utilizzo di generatori di numeri casuali.
+ Dipendenza dall'ora del sistema.
+ Utilizzo della concorrenza (le condizioni di gara possono causare variazioni nell'output).
+ Recupero di file locali o remoti oltre a quanto specificato nei parametri di input dell'attività.
Per altri scenari che possono causare comportamenti non deterministici, consulta [Input di processo non deterministici](https://www.nextflow.io/docs/latest/cache-and-resume.html#non-deterministic-process-inputs) nel sito di documentazione di Nextflow.
Se sospetti che un'attività produca output non deterministici, prendi in considerazione l'utilizzo delle funzionalità del motore di workflow per evitare di memorizzare nella cache attività specifiche non deterministiche. Per istruzioni su come disattivare la memorizzazione nella cache per singole attività in ogni lingua del flusso di lavoro supportata, consulta. [Funzionalità di memorizzazione nella cache specifiche del motore](workflow-cache-per-engine.md)
Ti consigliamo di esaminare attentamente i requisiti specifici del flusso di lavoro e delle attività prima di abilitare la memorizzazione nella cache delle chiamate in qualsiasi ambiente in cui una memorizzazione inefficace delle chiamate o output diversi dal previsto possono comportare rischi. Ad esempio, è necessario considerare attentamente le potenziali limitazioni della memorizzazione nella cache delle chiamate per determinare se la memorizzazione nella cache delle chiamate sia appropriata per i casi d'uso clinico.
## Requisiti di memorizzazione nella cache per le attività
HealthOmics memorizza nella cache gli output delle attività che soddisfano i seguenti requisiti:
+ L'attività deve definire un contenitore. HealthOmics non memorizzerà nella cache gli output di un'attività senza contenitore.
+ L'attività deve produrre uno o più output. Gli output delle attività vengono specificati nella definizione del flusso di lavoro.
+ La definizione del flusso di lavoro non deve utilizzare valori dinamici. Ad esempio, se si passa un parametro a un'attività con un valore che aumenta ad ogni esecuzione, HealthOmics non memorizza nella cache gli output dell'attività.
**Nota**
Se più attività in un'esecuzione utilizzano la stessa immagine del contenitore, HealthOmics fornisce la stessa versione dell'immagine a tutte queste attività. Dopo aver HealthOmics estratto l'immagine, ignora eventuali aggiornamenti all'immagine del contenitore per tutta la durata dell'esecuzione. Questo approccio offre un'esperienza prevedibile e coerente e previene i potenziali problemi che potrebbero derivare dagli aggiornamenti dell'immagine del contenitore distribuiti durante l'esecuzione.
## Esegui le prestazioni della cache
Quando attivi la memorizzazione nella cache delle chiamate per una corsa, potresti notare i seguenti impatti sulle prestazioni di esecuzione:
+ Durante la prima esecuzione, HealthOmics salva i dati della cache per le attività in esecuzione. È possibile che si verifichino tempi di esportazione più lunghi per questa esecuzione, poiché la memorizzazione nella cache delle chiamate aumenta la quantità di dati di esportazione.
+ Nelle esecuzioni successive, quando si riprende un'esecuzione dalla cache, è possibile ridurre il numero di fasi di elaborazione e ridurre il tempo di esecuzione.
+ Se scegli di dichiarare anche i file intermedi come output, i tempi di esportazione potrebbero essere ancora più lunghi, poiché questi dati possono essere più dettagliati.
## Eventi di conservazione e invalidazione dei dati della cache
Lo scopo principale di una cache di esecuzione è ottimizzare il calcolo delle attività in esecuzione. Se esiste una voce di cache valida corrispondente per un'attività, HealthOmics utilizza la voce della cache anziché ricalcolare l'attività. In caso contrario, HealthOmics torna al comportamento predefinito del servizio, che consiste nel ricalcolare l'attività e le attività da essa dipendenti. Utilizzando questo approccio, gli errori nella cache non causano il fallimento dell'esecuzione.
Ti consigliamo di gestire la dimensione della cache di esecuzione. Nel tempo, le voci della cache potrebbero non essere più valide a causa degli aggiornamenti del motore del flusso di lavoro o del HealthOmics servizio o a causa delle modifiche apportate durante l'esecuzione o le attività di esecuzione. Le seguenti sezioni forniscono ulteriori dettagli.
**Topics**
+ [Aggiornamenti della versione manifesto e aggiornamento dei dati](#workflow-cache-data-versions)
+ [Comportamento della cache di esecuzione](#run-cache-behavior)
+ [Controlla la dimensione della cache di esecuzione](#workflow-cache-manage)
### Aggiornamenti della versione manifesto e aggiornamento dei dati
Periodicamente, il HealthOmics servizio può introdurre nuove funzionalità o aggiornamenti del motore di flusso di lavoro che invalidano alcune o tutte le voci della cache di esecuzione. In questa situazione, è possibile che si verifichi un'unica perdita della cache nelle esecuzioni.
HealthOmics crea un [file manifest JSON](workflow-cache-contents.md) per ogni voce della cache. Per le esecuzioni iniziate dopo il 12 febbraio 2025, il file manifest include un parametro di versione. Se un aggiornamento del servizio invalida qualsiasi voce della cache, HealthOmics incrementa il numero di versione in modo da poter identificare le voci della cache legacy da rimuovere.
L'esempio seguente mostra un file manifesto con la versione impostata su 2:
```
{
"arn": "arn:aws:omics:us-west-2:12345678901:runCache/0123456/cacheEntry/1234567-195f-3921-a1fa-ffffcef0a6a4",
"s3uri": "s3://example/1234567-d0d1-e230-d599-10f1539f4a32/1348677/4795326/7e8c69b1-145f-3991-a1fa-ffffcef0a6a4",
"taskArn": "arn:aws:omics:us-west-2:12345678901:task/4567891",
"workDir": "/mnt/workflow/1234567-d0d1-e230-d599-10f1539f4a32/workdir/call-TxtFileCopyTask/5w6tn5feyga7noasjuecdeoqpkltrfo3/wxz2fuddlo6hc4uh5s2lreaayczduxdm",
"files": [
{
"name": "output_txt_file",
"path": "out/output_txt_file/outfile.txt",
"etag": "ajdhyg9736b9654673b9fbb486753bc8"
}
],
"nextflowContext": {},
"otherOutputs": {},
"version": 2,
}
```
Per le esecuzioni con voci della cache che non sono più valide, ricostruisci la cache per creare nuove voci valide. Eseguite i seguenti passaggi per ogni esecuzione:
1. Avvia l'esecuzione una sola volta con la conservazione della cache impostata su CACHE ALWAYS. Questa esecuzione crea le nuove voci della cache.
1. Per le esecuzioni successive, imposta la conservazione della cache sull'impostazione precedente (CACHE ALWAYS o CACHE ON FAILURE).
Per pulire le voci della cache che non sono più valide, puoi eliminare queste voci dalla cache del bucket Amazon S3. HealthOmics non riutilizza mai queste voci della cache. Se scegli di conservare le voci non valide, non vi è alcun impatto sulle tue esecuzioni.
**Nota**
La memorizzazione nella cache delle chiamate salva i dati di output delle attività nella posizione Amazon S3 specificata per la cache, il che comporta costi a carico dell'utente. Account AWS
### Comportamento della cache di esecuzione
È possibile impostare il comportamento di esecuzione della cache per salvare gli output delle attività per le esecuzioni che non riescono (cache in caso di errore) o per tutte le esecuzioni (cache sempre). Quando si crea una cache di esecuzione, si imposta il comportamento predefinito della cache per tutte le esecuzioni che utilizzano tale cache. È possibile sovrascrivere il comportamento predefinito quando si avvia un'esecuzione.
**Cache on failure**è utile se si esegue il debug di un flusso di lavoro che non riesce dopo che diverse attività sono state completate correttamente. L'esecuzione successiva riprende dall'ultima attività completata con successo se tutte le variabili univoche considerate dall'hash sono identiche all'esecuzione precedente.
**Cache always**è utile se si aggiorna un'attività in un flusso di lavoro completato correttamente. Ti consigliamo di seguire questi passaggi:
1. Crea una nuova corsa. Imposta **sempre il **comportamento** della cache** su Cache e avvia l'esecuzione.
1. Al termine dell'esecuzione, aggiorna l'attività nel flusso di lavoro e avvia una nuova esecuzione con il comportamento impostato su **Cache always**. Questa esecuzione elabora l'attività aggiornata e tutte le attività successive che dipendono dall'attività aggiornata. Tutte le altre attività utilizzano i risultati memorizzati nella cache.
1. Ripetere il passaggio 2 come richiesto, fino al completamento dello sviluppo dell'attività aggiornata.
1. Usa l'attività aggiornata secondo necessità per le esecuzioni future. Ricorda di passare alla **cache le esecuzioni successive in caso di errore** se prevedi di utilizzare input nuovi o diversi per queste esecuzioni.
**Nota**
Consigliamo la modalità **Cache always** quando si utilizza lo stesso set di dati di test, ma non per un batch di esecuzioni. Se imposti questa modalità per un grande batch di esecuzioni, il sistema può esportare grandi quantità di dati su Amazon S3, con conseguente aumento dei tempi di esportazione e dei costi di storage.
### Controlla la dimensione della cache di esecuzione
HealthOmics non elimina o archivia automaticamente i dati di esecuzione della cache né applica le regole di pulizia di Amazon S3 per la gestione dei dati della cache. Ti consigliamo di eseguire regolarmente la pulizia della cache per risparmiare sui costi di storage di Amazon S3 e per mantenere gestibili le dimensioni della cache di esecuzione. Puoi eliminare i file direttamente o impostare retention/replication politiche relative ai dati nel bucket run cache.
Ad esempio, puoi configurare una policy del ciclo di vita di Amazon S3 per far scadere gli oggetti dopo 90 giorni oppure puoi pulire manualmente i dati della cache alla fine di ogni progetto di sviluppo.
Le seguenti informazioni possono aiutarti a gestire le dimensioni dei dati della cache:
+ Puoi visualizzare la quantità di dati presenti nella cache controllando Amazon S3. HealthOmics non monitora né segnala le dimensioni della cache.
+ Se si elimina una voce di cache valida, l'esecuzione successiva non ha esito negativo. HealthOmics ricalcola l'attività e le relative attività dipendenti.
+ Se modificate i nomi della cache o le strutture di directory in modo tale da non HealthOmics trovare una voce corrispondente per un'attività, HealthOmics ricalcola l'attività.
Se devi verificare se una voce della cache è ancora valida, controlla il numero di versione del manifesto della cache. Per ulteriori informazioni, consulta [Aggiornamenti della versione manifesto e aggiornamento dei dati](#workflow-cache-data-versions).
# Creazione di una cache di esecuzione
Quando crei una cache di esecuzione, specifichi una posizione Amazon S3 per i dati della cache. Questi dati devono essere immediatamente accessibili. Il caching delle chiamate non recupera gli oggetti archiviati in Glacier (come le classi di archiviazione GFR e GDA).
Se il bucket Amazon S3 per i dati della cache è di proprietà di un altro Account AWS, fornisci quell'ID account quando crei la cache di esecuzione.
## Creazione di una cache di esecuzione utilizzando la console
Dalla console, segui questi passaggi per creare una cache di esecuzione.
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il pannello di navigazione a sinistra (≡). Scegli **Esegui cache.**
1. Dalla pagina **Esegui cache**, scegli **Crea cache di esecuzione**.
1. Nel pannello dei **dettagli della cache di esecuzione** della pagina **Crea cache di esecuzione**, configura questi campi:
1. Immettete un nome per la cache di esecuzione.
1. (Opzionale) Immettere una descrizione.
1. Inserisci una posizione S3 per l'output memorizzato nella cache. Scegli un bucket nella stessa regione del tuo flusso di lavoro.
1. (Facoltativo) Inserisci il nome Account AWS del proprietario del bucket per verificare la proprietà del bucket. Se non inserisci un valore, il valore predefinito è l'ID del tuo account.
1. In **Comportamento della cache**, configura il comportamento predefinito (se memorizzare nella cache gli output per le esecuzioni non riuscite o per tutte le esecuzioni). Quando avvii un'esecuzione, puoi opzionalmente sovrascrivere il comportamento predefinito.
1. (Facoltativo) Associate uno o più tag alla cache di esecuzione.
1. Scegli **Crea cache di esecuzione**. La console visualizza la nuova cache di esecuzione nella tabella **Run caches**.
## Creazione di una cache di esecuzione utilizzando la CLI
Usa il comando **create-run-cache**CLI per creare una cache di esecuzione. Il comportamento predefinito della cache è`CACHE_ON_FAILURE`.
```
aws omics create-run-cache \
--name "workflow 123 run cache" \
--description "my run cache" \
--cache-s3-location "s3://amzn-s3-demo-bucket" \
--cache-behavior "CACHE_ALWAYS" \
--cache-bucket-owner-id "111122223333"
```
Se la creazione ha esito positivo, riceverai una risposta con i seguenti campi.
```
{
"arn": "string",
"id": "string",
"status": "ACTIVE"
"tags": {}
}
```
# Aggiornamento di una cache di esecuzione
Puoi modificare il nome, la descrizione, i tag o il comportamento della cache, ma non la posizione S3 della cache.
## Aggiornamento di una cache di esecuzione tramite la console
Dalla console, segui questi passaggi per aggiornare una cache di esecuzione.
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il pannello di navigazione a sinistra (≡). Scegli **Esegui cache.**
1. **Nella tabella **Esegui cache**, scegli la cache di esecuzione da aggiornare, quindi scegli Modifica.**
1. Nel pannello dei **dettagli di Run cache**, puoi aggiornare i campi del nome, della descrizione e del comportamento della cache di esecuzione.
1. (Facoltativo) Associa uno o più nuovi tag alla cache di esecuzione o rimuovi i tag esistenti.
1. Scegliete **Salva cache di esecuzione**.
## Aggiornamento di una cache di esecuzione utilizzando la CLI
Usa il comando **update-run-cache**CLI per aggiornare una cache di esecuzione.
```
aws omics update-run-cache \
--name "workflow 123 run cache" \
--id "workflow id" \
--description "my run cache" \
--cache-behavior "CACHE_ALWAYS"
```
Se l'aggiornamento ha esito positivo, riceverai una risposta senza campi di dati.
# Eliminazione di una cache di esecuzione
Puoi eliminare una cache di esecuzione se nessuna esecuzione attiva la utilizza. Se alcune esecuzioni utilizzano la cache di esecuzione, attendi il completamento delle esecuzioni oppure puoi annullare le esecuzioni.
L'eliminazione di una cache di esecuzione rimuove la risorsa e i relativi metadati, ma non elimina i dati in Amazon S3. Dopo aver eliminato la cache, non puoi ricollegarla o utilizzarla per le esecuzioni successive.
I dati memorizzati nella cache rimangono in Amazon S3 per l'ispezione. Puoi rimuovere i vecchi dati della cache utilizzando le operazioni standard di **Delete** S3. In alternativa, crea una policy sul ciclo di vita di Amazon S3 per far scadere i dati memorizzati nella cache che non usi più.
## Eliminazione di una cache di esecuzione tramite la console
Dalla console, segui questi passaggi per eliminare una cache di esecuzione.
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il pannello di navigazione a sinistra (≡). Scegli **Esegui cache.**
1. Dalla tabella **Run caches**, scegli la cache di esecuzione da eliminare.
1. **Dal menu della tabella **Esegui cache**, scegli Elimina.**
1. Dalla finestra di dialogo modale, salva il link dati della cache Amazon S3 per riferimenti futuri, quindi conferma che desideri eliminare la cache di esecuzione.
Puoi utilizzare il link Amazon S3 per ispezionare i dati memorizzati nella cache, ma non puoi ricollegare i dati a un'altra cache di esecuzione. Elimina i dati della cache al termine dell'ispezione.
## Eliminazione di una cache di esecuzione utilizzando la CLI
Usa il comando **delete-run-cache**CLI per eliminare una cache di esecuzione.
```
aws omics delete-run-cache \
--id "my cache id"
```
Se l'eliminazione ha esito positivo, riceverai una risposta senza campi di dati.
# Contenuto di una cache di esecuzione
HealthOmics organizza la cache di esecuzione con la seguente struttura nel bucket S3:
```
s3://{cache.S3location}/{cache.uuid}/runID/taskID/{cacheentry.uuid}/
```
Il cache.uuid è l'id univoco globale per la cache. Il cacheentry.uuid è l'uuid unico a livello globale per un'operazione memorizzata nella cache. HealthOmics assegna gli uuid alle cache e alle attività.
Per tutti i motori di workflow, la cache contiene i seguenti file:
+ Il **\$1cacheentryuuid\$1.json** file: HealthOmics crea questo file manifesto, che contiene informazioni sulla cache, incluso un elenco di tutti gli elementi presenti nella cache e la [versione della cache](how-run-cache.md#workflow-cache-data-versions).
+ File di output delle attività: l'output di ogni attività è costituito da uno o più file, come definito dall'attività.
Per un flusso di lavoro che utilizza Nextflow, il motore Nextflow crea questi file aggiuntivi nella cache:
+ Il **command.out** file: questo file contiene il contenuto dello stdout per l'esecuzione dell'attività.
+ Il **.exitcode** file: questo file contiene il codice di uscita dell'attività (un numero intero).
**Nota**
Se desideri accedere ai file di attività intermedi nella cache di esecuzione per una risoluzione avanzata dei problemi, dichiara questi file come output delle attività nella definizione del flusso di lavoro.
# Funzionalità di memorizzazione nella cache specifiche del motore
HealthOmics cerca di fornire un'implementazione coerente della memorizzazione nella cache delle chiamate nei motori di flusso di lavoro. Esistono alcune differenze in base al modo in cui ogni motore di workflow gestisce casi specifici:
+ Nextflow
+ La memorizzazione nella cache tra diverse versioni di Nextflow non è garantita. Ad esempio, se esegui un'attività nella v23.10.0 e successivamente esegui la stessa attività nella v24.10.8, HealthOmics potresti considerare la seconda esecuzione come un errore nella cache.
+ È possibile disattivare la memorizzazione nella cache per singole attività utilizzando la direttiva cache. **false** Per informazioni su questa direttiva, consulta la specifica [Processi](https://www.nextflow.io/docs/latest/process.html#process-cache) nella specifica Nextflow.
+ HealthOmics utilizza la modalità clemente di Nextflow, ma non supporta la modalità deep caching.
+ La memorizzazione nella cache valuta ogni singolo oggetto S3 se si utilizza un pattern a glob nel percorso S3 degli input per un'attività. Se aggiungi un nuovo oggetto, HealthOmics ricalcola solo le attività che utilizzano il nuovo oggetto.
+ HealthOmics non memorizza nella cache i nuovi tentativi di attività. Questo comportamento è coerente con il comportamento predefinito di Nextflow.
+ WDL
+ HealthOmics supporta il nuovo tipo di «directory» per gli input quando si utilizza la versione di sviluppo del flusso di lavoro WDL. Per la memorizzazione nella cache delle chiamate, se un oggetto nella directory cambia, HealthOmics ricalcola tutte le attività che entrano nella directory.
+ HealthOmics supporta la memorizzazione nella cache a livello di attività, ma non la memorizzazione nella cache a livello di flusso di lavoro.
+ **È possibile disabilitare la memorizzazione nella cache per singole attività utilizzando l'attributo volatile.** Per ulteriori informazioni, consulta [Disattiva la memorizzazione nella cache a livello di attività con l'attributo volatile](workflow-languages-wdl.md#workflow-wdl-volatile-attribute).
+ CWL
+ I risultati costanti delle attività non sono esplicitamente visibili nei manifesti. HealthOmics memorizza nella cache gli output costanti come file intermedi.
+ È possibile controllare la memorizzazione nella cache per singole attività utilizzando la funzione. [WorkReuse](https://www.commonwl.org/v1.1/Workflow.html#WorkReuse)
# Utilizzo della cache di esecuzione
Per impostazione predefinita, le esecuzioni non utilizzano una cache di esecuzione. Per utilizzare una cache per l'esecuzione, è necessario specificare la cache di esecuzione e il comportamento della cache di esecuzione all'avvio dell'esecuzione.
Al termine di un'esecuzione, puoi utilizzare la console, CloudWatch i registri o le operazioni API per tenere traccia degli accessi alla cache o risolvere i problemi relativi alla cache. Per informazioni dettagliate, consulta [Monitoraggio delle informazioni relative alla memorizzazione delle chiamate](#workflow-cache-track) e [Risoluzione dei problemi relativi alla memorizzazione nella cache delle chiamate](troubleshooting.md#workflow-cache-troubleshooting).
Se una o più attività in un'esecuzione generano output non deterministici, ti consigliamo vivamente di non utilizzare la memorizzazione nella cache delle chiamate per l'esecuzione o di disattivare queste attività specifiche dalla memorizzazione nella cache. Per ulteriori informazioni, consulta [Modello di responsabilità condivisa](how-run-cache.md#run-cache-srm).
**Nota**
Fornisci un ruolo di servizio IAM quando avvii un'esecuzione. Per utilizzare la memorizzazione nella cache delle chiamate, il ruolo di servizio necessita dell'autorizzazione per accedere alla posizione di esecuzione della cache di Amazon S3. Per ulteriori informazioni, consulta [Ruoli di servizio per AWS HealthOmics](permissions-service.md).
Puoi utilizzare [Amazon Q CLI](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/what-is.html) per analizzare e gestire i dati della cache di esecuzione. Per ulteriori informazioni, consulta le [istruzioni di esempio per la CLI di Amazon Q](getting-started.md#omics-q-prompts) e il tutorial sull'intelligenza artificiale generativa [HealthOmics Agentic](https://github.com/aws-samples/aws-healthomics-tutorials/tree/main/generative-ai) su. GitHub
**Topics**
+ [Configurazione di un run with run cache utilizzando la console](#workflow-cache-startrun-console)
+ [Configurazione di un'esecuzione con cache di esecuzione utilizzando la CLI](#workflow-cache-startrun-api)
+ [Casi di errore per le cache di esecuzione](#workflow-cache-errors)
+ [Monitoraggio delle informazioni relative alla memorizzazione delle chiamate](#workflow-cache-track)
## Configurazione di un run with run cache utilizzando la console
Dalla console, si configura la cache di esecuzione per un'esecuzione all'avvio dell'esecuzione.
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il pannello di navigazione a sinistra (≡). Scegli **Runs**.
1. Nella pagina **Esecuzioni**, scegli la corsa da iniziare.
1. Scegli **Avvia esecuzione** e completa i passaggi 1 e 2 di **Avvia corsa** come descritto in[Avvio di una corsa utilizzando la console](starting-a-run.md#starting-a-run-console).
1. Nel passaggio 3 di **Avvia esecuzione**, scegli **Seleziona una cache di esecuzione esistente**.
1. Seleziona la cache dall'elenco a discesa **Run cache ID**.
1. Per ignorare il comportamento predefinito di esecuzione della cache, scegli il comportamento della **cache** per l'esecuzione. Per ulteriori informazioni, consulta [Comportamento della cache di esecuzione](how-run-cache.md#run-cache-behavior).
1. Continuate con il passaggio 4 di **Start run**.
## Configurazione di un'esecuzione con cache di esecuzione utilizzando la CLI
**Per avviare un'esecuzione che utilizza una cache di esecuzione, aggiungi il parametro cache-id al comando CLI start-run.** Facoltativamente, utilizzate il `cache-behavior` parametro per sovrascrivere il comportamento predefinito configurato per la cache di esecuzione. L'esempio seguente mostra solo i campi della cache per il comando:
```
aws omics start-run \
...
--cache-id "xxxxxx" \
--cache-behavior CACHE_ALWAYS
```
Se l'operazione ha esito positivo, si riceve una risposta senza campi di dati.
## Casi di errore per le cache di esecuzione
Nei seguenti scenari, non è HealthOmics possibile memorizzare nella cache gli output delle attività, anche nel caso di un'esecuzione con il comportamento della cache impostato su **Cache** always.
+ Se l'esecuzione rileva un errore prima che la prima attività venga completata correttamente, non ci sono output della cache da esportare.
+ Se il processo di esportazione fallisce, HealthOmics non salva gli output delle attività nella posizione cache di Amazon S3.
+ Se l'esecuzione fallisce a causa di un **filesystem out of space** errore, la memorizzazione nella cache delle chiamate non salva alcun output dell'attività.
+ Se si annulla un'esecuzione, la memorizzazione nella cache delle chiamate non salva alcun output dell'attività.
+ Se l'esecuzione presenta un timeout di esecuzione, la memorizzazione nella cache delle chiamate non salva alcun output dell'attività, anche se l'esecuzione è stata configurata per utilizzare la cache in caso di errore.
## Monitoraggio delle informazioni relative alla memorizzazione delle chiamate
È possibile tenere traccia degli eventi di memorizzazione nella cache delle chiamate (come gli accessi alla cache di esecuzione) utilizzando la console, la CLI o i registri. CloudWatch
**Topics**
+ [Tieni traccia degli accessi alla cache utilizzando la console](#workflow-cache-track-console)
+ [Tieni traccia della memorizzazione nella cache delle chiamate utilizzando la CLI](#workflow-cache-track-cli)
+ [Tieni traccia della memorizzazione nella cache delle chiamate utilizzando Logs CloudWatch](#workflow-cache-track-cwl)
### Tieni traccia degli accessi alla cache utilizzando la console
Nella pagina dei dettagli di esecuzione di un'esecuzione, la tabella **Esegui attività** visualizza le informazioni sugli **accessi alla cache** per ogni attività. La tabella include anche un collegamento alla voce della cache associata. Utilizzare la procedura seguente per visualizzare le informazioni relative agli accessi alla cache durante un'esecuzione.
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, aprite il pannello di navigazione a sinistra (≡). Scegli **Runs**.
1. Nella pagina **Esecuzioni**, scegli la corsa da ispezionare.
1. Nella pagina dei dettagli dell'esecuzione, scegli la scheda **Esegui attività** per visualizzare la tabella delle attività.
1. Se un'attività ha un accesso alla cache, la colonna **Cache hit** contiene un collegamento alla posizione di accesso alla cache di esecuzione in Amazon S3.
1. Scegli il link per controllare la voce di run cache.
### Tieni traccia della memorizzazione nella cache delle chiamate utilizzando la CLI
Utilizza il comando **CLI get-run** per confermare se l'esecuzione ha utilizzato una cache delle chiamate.
```
aws omics get-run --id 1234567
```
Nella risposta, se il `cacheId` campo è impostato, l'esecuzione utilizza quella cache.
Utilizza il comando **list-run-tasks**CLI per recuperare la posizione dei dati della cache per ogni attività memorizzata nella cache in esecuzione.
```
aws omics list-run-tasks --id 1234567
```
Nella risposta, se il campo CacheHit per un'attività è vero, il campo Caches3URI fornisce la posizione dei dati della cache per quell'attività.
Puoi anche utilizzare il comando **get-run-task**CLI per recuperare la posizione dei dati della cache per un'attività specifica:
```
aws omics get-run-task --id 1234567 --task-id
```
### Tieni traccia della memorizzazione nella cache delle chiamate utilizzando Logs CloudWatch
HealthOmics crea registri delle attività della cache nel gruppo di registri. `/aws/omics/WorkflowLog` CloudWatch Esiste un flusso di log per ogni cache di esecuzione: **runCache//**.
Per le esecuzioni che utilizzano la memorizzazione nella cache delle chiamate, HealthOmics genera voci di CloudWatch registro per questi eventi:
+ creazione di una voce nella cache (CACHE\$1ENTRY\$1CREATED)
+ corrispondente a una voce della cache (CACHE\$1HIT)
+ non riesce a far corrispondere una voce della cache (CACHE\$1MISS)
Per ulteriori informazioni su questi registri, vedere. [Effettua il login CloudWatch](monitoring-cloudwatch-logs.md#cloudwatch-logs)
Utilizza la seguente query CloudWatch Insights sul gruppo di `/aws/omics/WorkflowLog` log per restituire il numero di accessi alla cache per esecuzione per questa cache:
```
filter @logStream like 'runCache//'
fields @timestamp, @message
filter logMessage like 'CACHE_HIT'
parse "run: *," as run
stats count(*) as cacheHits by run
```
Utilizzate la seguente query per restituire il numero di voci della cache create da ogni esecuzione:
```
filter @logStream like 'runCache//'
fields @timestamp, @message
filter logMessage like 'CACHE_ENTRY_CREATED'
parse "run: *," as run
stats count(*) as cacheEntries by run
```