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à.
# HealthOmics archiviazione
Utilizza HealthOmics lo storage per archiviare, recuperare, organizzare e condividere i dati genomici in modo efficiente e a basso costo. HealthOmics lo storage comprende le relazioni tra diversi oggetti di dati, in modo da poter definire quali set di lettura hanno avuto origine dalla stessa fonte di dati. Ciò fornisce la provenienza dei dati.
I dati archiviati nello `ACTIVE` stato sono recuperabili immediatamente. I dati a cui non si accede da 30 giorni o più vengono archiviati nello `ARCHIVE` stato. Per accedere ai dati archiviati, puoi riattivarli tramite le operazioni o la console dell'API.
HealthOmics gli archivi di sequenze sono progettati per preservare l'integrità del contenuto dei file. Tuttavia, l'equivalenza bit per bit dei file di dati importati e dei file esportati non viene preservata a causa della compressione durante il tiering attivo e di archiviazione.
Durante l'ingestione, HealthOmics genera un tag di entità o *HealthOmics ETag*consente di convalidare l'integrità del contenuto dei file di dati. Le porzioni di sequenziamento vengono identificate e acquisite ETag a livello di origine di un set di lettura. Il ETag calcolo non altera il file effettivo o i dati genomici. Dopo la creazione di un set di lettura, non ETag dovrebbe cambiare durante il ciclo di vita della sorgente del set di lettura. Ciò significa che la reimportazione dello stesso file comporta il calcolo dello stesso ETag valore.
**Topics**
+ [HealthOmics ETags e provenienza dei dati](etags-and-provenance.md)
+ [Creazione di un negozio HealthOmics di riferimento](create-reference-store.md)
+ [Creazione di un archivio HealthOmics di sequenze](create-sequence-store.md)
+ [Eliminazione di archivi HealthOmics di riferimenti e sequenze](deleting-reference-and-sequence-stores.md)
+ [Importazione di set di lettura in un archivio di HealthOmics sequenze](import-sequence-store.md)
+ [Caricamento diretto su un archivio HealthOmics di sequenze](synchronous-uploads.md)
+ [Esportazione di set di HealthOmics lettura in un bucket Amazon S3](read-set-exports.md)
+ [Accesso ai set di HealthOmics lettura con Amazon S3 URIs](s3-access.md)
+ [Attivazione dei set di lettura in HealthOmics](activating-read-sets.md)
# HealthOmics ETags e provenienza dei dati
Un HealthOmics ETag (tag di entità) è un hash del contenuto acquisito in un archivio di sequenze. Ciò semplifica il recupero e l'elaborazione dei dati mantenendo al contempo l'integrità dei contenuti dei file di dati acquisiti. ETag Riflette le modifiche al contenuto semantico dell'oggetto, non ai suoi metadati. Il tipo di set di lettura e l'algoritmo specificati determinano la modalità di calcolo ETag . Il ETag calcolo non altera il file effettivo o i dati genomici. Quando lo schema del tipo di file del set di lettura lo consente, l'archivio delle sequenze aggiorna i campi collegati alla provenienza dei dati.
I file hanno un'identità bit per bit e un'identità semantica. L'identità bit per bit significa che i bit di un file sono identici e un'identità semantica significa che i contenuti di un file sono identici. L'identità semantica è resistente alle modifiche dei metadati e alle modifiche di compressione poiché acquisisce l'integrità del contenuto del file.
I set di lettura negli archivi di HealthOmics sequenza sono sottoposti a compression/decompression cicli e al monitoraggio della provenienza dei dati durante tutto il ciclo di vita di un oggetto. Durante questa elaborazione, l'identità bit per bit di un file ingerito può cambiare e dovrebbe cambiare ogni volta che viene attivato un file; tuttavia, l'identità semantica del file viene mantenuta. L'identità semantica viene acquisita come tag di HealthOmics entità, oppure ETag viene calcolata durante l'inserimento del Sequence Store e disponibile come metadati del set di lettura.
Quando lo schema dei tipi di file del set di lettura lo consente, i campi degli aggiornamenti dell'archivio delle sequenze sono collegati alla provenienza dei dati. Per i file UBam, BAM e CRAM, viene aggiunto un nuovo `@CO` tag or all'intestazione. `Comment` Il commento contiene l'ID dell'archivio della sequenza e il timestamp di inserimento.
## Amazon S3 ETags
Quando si accede a un file utilizzando l'URI di Amazon S3, le operazioni API di Amazon S3 possono anche restituire valori Amazon S3 e valori di checksum. ETag I valori di Amazon S3 ETag e checksum differiscono da quelli HealthOmics ETags perché rappresentano l'identità bit per bit del file. Per ulteriori informazioni sui metadati e sugli oggetti descrittivi, consulta la documentazione dell'API Amazon [S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_Object.html) Object. ETag I valori di Amazon S3 possono cambiare con ogni ciclo di attivazione di un set di lettura e puoi utilizzarli per convalidare la lettura di un file. Tuttavia, non memorizzare nella cache ETag i valori di Amazon S3 da utilizzare per la convalida dell'identità dei file durante il ciclo di vita del file perché non rimangono coerenti. Al contrario, HealthOmics ETag rimane coerente per tutto il ciclo di vita del set di lettura.
## Come calcola HealthOmics ETags
ETag Viene generato da un hash del contenuto del file ingerito. La famiglia di ETag algoritmi è impostata come impostazione MD5up predefinita, ma può essere configurata in modo diverso durante la creazione dell'archivio di sequenze. Quando ETag viene calcolato, l'algoritmo e gli hash calcolati vengono aggiunti al set di lettura. MD5 Gli algoritmi supportati per i tipi di file sono i seguenti.
+ *FASTQ\$1 MD5up* — Calcola l' MD5hash di una sorgente di lettura FASTQ completa e non compressa.
+ *BAM\$1 MD5up* — Calcola l' MD5 hash della sezione di allineamento di una sorgente non compressa del set di lettura BAM o UBam rappresentata nel SAM, in base al riferimento collegato, se disponibile.
+ *CRAM\$1 MD5up* — Calcola l' MD5 hash della sezione di allineamento della sorgente non compressa del set di lettura CRAM rappresentata nel SAM, in base al riferimento collegato.
**Nota**
MD5 è noto che l'hashing è vulnerabile alle collisioni. Per questo motivo, due file diversi potrebbero avere le stesse caratteristiche ETag se fossero stati prodotti per sfruttare la collisione nota.
I seguenti algoritmi sono supportati per la famiglia. SHA256 Gli algoritmi vengono calcolati come segue:
+ *FASTQ\$1 SHA256up* — Calcola l'hash SHA-256 di una sorgente di set di lettura FASTQ completa e non compressa.
+ *BAM\$1 SHA256up* — Calcola l'hash SHA-256 della sezione di allineamento di una sorgente non compressa del set di lettura BAM o UBam rappresentata nel SAM, in base al riferimento collegato, se disponibile.
+ *CRAM\$1 SHA256up* — Calcola l'hash SHA-256 della sezione di allineamento di una sorgente del set di lettura CRAM non compressa rappresentata nel SAM, in base al riferimento collegato.
I seguenti algoritmi sono supportati per la famiglia. SHA512 Gli algoritmi vengono calcolati come segue:
+ *FASTQ\$1 SHA512up* — Calcola l'hash SHA-512 di una sorgente di set di lettura FASTQ completa e non compressa.
+ *BAM\$1 SHA512up* — Calcola l'hash SHA-512 della sezione di allineamento di una sorgente non compressa del set di lettura BAM o UBam rappresentata nel SAM, in base al riferimento collegato, se disponibile.
+ *CRAM\$1 SHA512up * — Calcola l'hash SHA-512 della sezione di allineamento di una sorgente del set di lettura CRAM non compressa rappresentata nel SAM, in base al riferimento collegato.
# Creazione di un negozio HealthOmics di riferimento
Un archivio di riferimento in HealthOmics è un archivio dati per l'archiviazione dei genomi di riferimento. È possibile disporre di un unico archivio di riferimento in ciascuna Account AWS regione. È possibile creare un archivio di riferimento utilizzando la console o la CLI.
**Topics**
+ [Creazione di un archivio di riferimento utilizzando la console](#console-create-reference-store)
+ [Creazione di un archivio di riferimento utilizzando la CLI](#api-create-reference-store)
## Creazione di un archivio di riferimento utilizzando la console
**Come creare un archivio di riferimenti**
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il riquadro di navigazione a sinistra (≡). Scegli **Reference store**.
1. Scegli **Reference genomes** tra le opzioni di archiviazione dei dati Genomics.
1. Puoi scegliere un genoma di riferimento importato in precedenza o importarne uno nuovo. Se non hai importato un genoma di riferimento, scegli **Importa genoma di riferimento in alto** a destra.
1. Nella pagina **Crea processo di importazione del genoma di riferimento**, scegli l'opzione **Creazione rapida** o **Creazione manuale** per creare un archivio di riferimento, quindi fornisci le seguenti informazioni.
+ Nome del **genoma di riferimento: un nome** univoco per questo negozio.
+ **Descrizione** (opzionale): una descrizione di questo archivio di riferimento.
+ **Ruolo IAM**: seleziona un ruolo con accesso al tuo genoma di riferimento.
+ **Riferimento da Amazon S3**: seleziona il file di sequenza di riferimento in un bucket Amazon S3.
+ **Tag** (opzionale): fornisci fino a 50 tag per questo negozio di riferimento.
## Creazione di un archivio di riferimento utilizzando la CLI
L'esempio seguente mostra come creare un archivio di riferimento utilizzando. AWS CLIÈ possibile disporre di un archivio di riferimento per AWS regione.
Gli archivi di riferimento supportano l'archiviazione di file FASTA con le estensioni `.fasta``.fa`,`.fas`,`.fsa`,`.faa`,`.fna`,`.ffn`,,`.frn`, `.mpfa``.seq`,`.txt`. È supportata anche la `bgzip` versione di queste estensioni.
Nell'esempio seguente, sostituiscilo `reference store name` con il nome che hai scelto per il tuo negozio di riferimento.
```
aws omics create-reference-store --name "reference store name"
```
Riceverai una risposta JSON con l'ID e il nome dell'archivio di riferimento, l'ARN e il timestamp di quando è stato creato il tuo negozio di riferimento.
```
{
"id": "3242349265",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/3242349265",
"name": "MyReferenceStore",
"creationTime": "2022-07-01T20:58:42.878Z"
}
```
È possibile utilizzare l'ID dell'archivio di riferimento in comandi aggiuntivi. AWS CLI È possibile recuperare l'elenco degli store di riferimento IDs collegati al proprio account utilizzando il **list-reference-stores**comando, come illustrato nell'esempio seguente.
```
aws omics list-reference-stores
```
In risposta, riceverai il nome del tuo negozio di riferimento appena creato.
```
{
"referenceStores": [
{
"id": "3242349265",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/3242349265",
"name": "MyReferenceStore",
"creationTime": "2022-07-01T20:58:42.878Z"
}
]
}
```
Dopo aver creato un archivio di riferimento, potete creare processi di importazione per caricare file di riferimento genomici al suo interno. A tale scopo, è necessario utilizzare o creare un ruolo IAM per accedere ai dati. Di seguito è riportata una policy di esempio.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
------
È inoltre necessario disporre di una politica di fiducia simile all'esempio seguente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"omics.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Ora puoi importare un genoma di riferimento. [Questo esempio utilizza Genome Reference Consortium Human Build 38 (hg38), che è ad accesso aperto e disponibile nel Registry of Open Data su. AWS](https://registry.opendata.aws/) Il bucket che ospita questi dati ha sede negli Stati Uniti orientali (Ohio). Per utilizzare i bucket in altre AWS regioni, puoi copiare i dati in un bucket Amazon S3 ospitato nella tua regione. Usa il seguente AWS CLI comando per copiare il genoma nel tuo bucket Amazon S3.
```
aws s3 cp s3://broad-references/hg38/v0/Homo_sapiens_assembly38.fasta s3://amzn-s3-demo-bucket
```
Puoi quindi iniziare il processo di importazione. Sostituisci `reference store ID` e `source file path` con il tuo input. `role ARN`
```
aws omics start-reference-import-job --reference-store-id reference store ID --role-arn role ARN --sources source file path
```
Dopo l'importazione dei dati, riceverai la seguente risposta in JSON.
```
{
"id": "7252016478",
"referenceStoreId": "3242349265",
"roleArn": "arn:aws:iam::111122223333:role/OmicsReferenceImport",
"status": "CREATED",
"creationTime": "2022-07-01T21:15:13.727Z"
}
```
È possibile monitorare lo stato di un lavoro utilizzando il comando seguente. Nell'esempio seguente, sostituisci `reference store ID` e `job ID` con il tuo ID del negozio di riferimento e l'ID del lavoro su cui desideri saperne di più.
```
aws omics get-reference-import-job --reference-store-id reference store ID --id job ID
```
In risposta, riceverai una risposta con i dettagli relativi all'archivio di riferimento e al relativo stato.
```
{
"id": "7252016478",
"referenceStoreId": "3242349265",
"roleArn": "arn:aws:iam::555555555555:role/OmicsReferenceImport",
"status": "RUNNING",
"creationTime": "2022-07-01T21:15:13.727Z",
"sources": [
{
"sourceFile": "s3://amzn-s3-demo-bucket/Homo_sapiens_assembly38.fasta",
"status": "IN_PROGRESS",
"name": "MyReference"
}
]
}
```
Puoi anche trovare il riferimento che è stato importato elencando i riferimenti e filtrandoli in base al nome del riferimento. Sostituiscilo `reference store ID` con il tuo ID del negozio di riferimento e aggiungi un filtro opzionale per restringere l'elenco.
```
aws omics list-references --reference-store-id reference store ID --filter name=MyReference
```
In risposta, riceverai le seguenti informazioni.
```
{
"references": [
{
"id": "1234567890",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/1234567890/reference/1234567890",
"referenceStoreId": "12345678",
"md5": "7ff134953dcca8c8997453bbb80b6b5e",
"status": "ACTIVE",
"name": "MyReference",
"creationTime": "2022-07-02T00:15:19.787Z",
"updateTime": "2022-07-02T00:15:19.787Z"
}
]
}
```
Per saperne di più sui metadati di riferimento, utilizza l'operazione **get-reference-metadata**API. Nell'esempio seguente, sostituiscilo `reference store ID` con il tuo ID del negozio di riferimento e `reference ID` con l'ID di riferimento su cui desideri saperne di più.
```
aws omics get-reference-metadata --reference-store-id reference store ID --id reference ID
```
Riceverai le seguenti informazioni in risposta.
```
{
"id": "1234567890",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/referencestoreID/reference/referenceID",
"referenceStoreId": "1234567890",
"md5": "7ff134953dcca8c8997453bbb80b6b5e",
"status": "ACTIVE",
"name": "MyReference",
"creationTime": "2022-07-02T00:15:19.787Z",
"updateTime": "2022-07-02T00:15:19.787Z",
"files": {
"source": {
"totalParts": 31,
"partSize": 104857600,
"contentLength": 3249912778
},
"index": {
"totalParts": 1,
"partSize": 104857600,
"contentLength": 160928
}
}
}
```
È inoltre possibile scaricare parti del file di riferimento utilizzando **get-reference**. Nell'esempio seguente, sostituiscilo `reference store ID` con il tuo ID del negozio di riferimento e `reference ID` con l'ID di riferimento da cui desideri effettuare il download.
```
aws omics get-reference --reference-store-id reference store ID --id reference ID --part-number 1 outfile.fa
```
# Creazione di un archivio HealthOmics di sequenze
HealthOmics gli archivi di sequenze supportano l'archiviazione di file genomici nei formati non allineati di `FASTQ` (solo gzip) e. `uBAM` Supporta anche i formati allineati di e. `BAM` `CRAM`
I file importati vengono archiviati come set di lettura. Puoi aggiungere tag ai set di lettura e utilizzare le policy IAM per controllare l'accesso ai set di lettura. I set di lettura allineati richiedono un genoma di riferimento per allineare le sequenze genomiche, ma è facoltativo per i set di lettura non allineati.
Per memorizzare i set di lettura, devi prima creare un archivio di sequenze. Quando crei un archivio di sequenze, puoi specificare un bucket Amazon S3 opzionale come posizione di riserva e la posizione in cui vengono archiviati i log di accesso S3. La posizione di fallback viene utilizzata per archiviare tutti i file che non riescono a creare un set di lettura durante un caricamento diretto. Le posizioni di riserva sono disponibili per i sequence store creati dopo il 15 maggio 2023. La posizione di fallback viene specificata quando si crea l'archivio delle sequenze.
È possibile specificare fino a cinque chiavi di tag read set. Quando crei o aggiorni un set di lettura con una chiave di tag che corrisponde a una di queste chiavi, i tag del set di lettura vengono propagati all'oggetto Amazon S3 corrispondente. I tag di sistema creati da HealthOmics vengono propagati per impostazione predefinita.
**Topics**
+ [Creazione di un archivio di sequenze utilizzando la console](#console-create-sequence-store)
+ [Creazione di un archivio di sequenze utilizzando la CLI](#api-create-sequence-store)
+ [Aggiornamento di un archivio di sequenze](#update-sequence-store)
+ [Aggiornamento dei tag di lettura per un archivio di sequenze](#sequence-store-manage-tags)
+ [Importazione di file genomici](#import-genomic-files)
## Creazione di un archivio di sequenze utilizzando la console
**Per creare un archivio di sequenze**
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, aprite il pannello di navigazione a sinistra (≡). Scegli i **negozi Sequence**.
1. Nella pagina **Crea archivio sequenze**, fornisci le seguenti informazioni
+ **Sequence Store name**: un nome univoco per questo negozio.
+ **Descrizione** (opzionale): una descrizione di questo archivio di sequenze.
1. Per una **posizione di fallback in S3**, specifica una posizione Amazon S3. HealthOmics utilizza la posizione di fallback per archiviare tutti i file che non riescono a creare un set di lettura durante un caricamento diretto. È necessario concedere al HealthOmics servizio l'accesso in scrittura alla posizione di fallback di Amazon S3. Per un esempio di policy, consulta [Configura una posizione di fallback](synchronous-uploads.md#synchronous-uploads-fallback).
Le posizioni di riserva non sono disponibili per i sequence store creati prima del 16 maggio 2023.
1. (Facoltativo) Per **le chiavi dei tag Read set per la propagazione S3**, puoi inserire fino a cinque chiavi di lettura per propagarle da un set di lettura agli oggetti S3 sottostanti. Propagando i tag da un set di lettura all'oggetto S3, puoi concedere autorizzazioni di accesso a S3 basate sui tag agli utenti and/or finali per visualizzare i tag propagati tramite l'operazione dell'API Amazon S3. getObjectTagging
1. Inserisci un valore chiave nella casella di testo. La console crea una nuova casella di testo per aggiungere la chiave successiva.
1. (Facoltativo) Scegliete **Rimuovi** per rimuovere tutte le chiavi.
1. In **Crittografia dei dati**, seleziona se desideri che la crittografia dei dati sia di proprietà e gestita da AWS o utilizzi una CMK gestita dal cliente.
1. (Facoltativo) In **S3 Data access**, seleziona se creare un nuovo ruolo e una nuova policy per accedere al Sequence Store tramite Amazon S3.
1. (Facoltativo) Per la **registrazione degli accessi S3**, seleziona `Enabled` se desideri che Amazon S3 raccolga i record dei log di accesso.
Per la **posizione di registrazione di Access in S3**, specifica una posizione Amazon S3 in cui archiviare i log. Questo campo è visibile solo se hai abilitato la registrazione degli accessi S3.
1. **Tag** (opzionale): fornisci fino a 50 tag per questo archivio di sequenze. Questi tag sono separati dai tag del set di lettura che vengono impostati durante l' import/tag aggiornamento del set di lettura
Dopo aver creato il negozio, è pronto per[Importazione di file genomici](#import-genomic-files).
## Creazione di un archivio di sequenze utilizzando la CLI
Nell'esempio seguente, sostituiscilo `sequence store name` con il nome che hai scelto per il tuo archivio di sequenze.
```
aws omics create-sequence-store --name sequence store name --fallback-location "s3://amzn-s3-demo-bucket"
```
Riceverai la seguente risposta in JSON, che include il numero ID del tuo sequence store appena creato.
```
{
"id": "3936421177",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/3936421177",
"name": "sequence_store_example_name",
"creationTime": "2022-07-13T20:09:26.038Z"
"fallbackLocation" : "s3://amzn-s3-demo-bucket"
}
```
È inoltre possibile visualizzare tutti gli archivi di sequenze associati al proprio account utilizzando il **list-sequence-stores**comando, come illustrato di seguito.
```
aws omics list-sequence-stores
```
Riceverai la seguente risposta.
```
{
"sequenceStores": [
{
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/3936421177",
"id": "3936421177",
"name": "MySequenceStore",
"creationTime": "2022-07-13T20:09:26.038Z",
"updatedTime": "2024-09-13T04:11:31.242Z",
"fallbackLocation" : "s3://amzn-s3-demo-bucket",
"status": "Active"
}
]
}
```
È possibile utilizzarla **get-sequence-store**per saperne di più su un archivio di sequenze utilizzando il relativo ID, come illustrato nell'esempio seguente:
```
aws omics get-sequence-store --id sequence store ID
```
Riceverai la seguente risposta:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/sequencestoreID",
"creationTime": "2024-01-12T04:45:29.857Z",
"updatedTime": "2024-09-13T04:11:31.242Z",
"description": null,
"fallbackLocation": null,
"id": "2015356892",
"name": "MySequenceStore",
"s3Access": {
"s3AccessPointArn": "arn:aws:s3:us-west-2:123456789012:accesspoint/592761533288-2015356892",
"s3Uri": "s3://592761533288-2015356892-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/",
"accessLogLocation": "s3://IAD-seq-store-log/2015356892/"
},
"sseConfig": {
"keyArn": "arn:aws:kms:us-west-2:123456789012:key/eb2b30f5-635d-4b6d-b0f9-d3889fe0e648",
"type": "KMS"
},
"status": "Active",
"statusMessage": null,
"setTagsToSync": ["withdrawn","protocol"],
}
```
Dopo la creazione, è possibile aggiornare anche diversi parametri del negozio. Questa operazione può essere eseguita tramite la console o l'`updateSequenceStore`operazione API.
## Aggiornamento di un archivio di sequenze
Per aggiornare un archivio di sequenze, effettuate le seguenti operazioni:
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, aprite il riquadro di navigazione a sinistra (≡). Scegli i **negozi Sequence**.
1. Scegli l'archivio delle sequenze da aggiornare.
1. Nel pannello **Dettagli**, scegliete **Modifica**.
1. Nella pagina **Modifica dettagli**, puoi aggiornare i seguenti campi:
+ **Nome del negozio in sequenza**: un nome univoco per questo negozio.
+ **Descrizione**: una descrizione di questo archivio di sequenze.
+ **Posizione di fallback in S3**, specifica una posizione Amazon S3. HealthOmics utilizza la posizione di fallback per archiviare tutti i file che non riescono a creare un set di lettura durante un caricamento diretto.
+ **Leggi le chiavi dei tag del set di lettura per la propagazione S3**, puoi inserire fino a cinque chiavi del set di lettura da propagare su Amazon S3.
+ (Facoltativo) Per la **registrazione degli accessi S3**, seleziona `Enabled` se desideri che Amazon S3 raccolga i record dei log di accesso.
Per la **posizione di registrazione di Access in S3**, specifica una posizione Amazon S3 in cui archiviare i log. Questo campo è visibile solo se hai abilitato la registrazione degli accessi S3.
+ **Tag** (opzionale): fornisci fino a 50 tag per questo archivio di sequenze.
## Aggiornamento dei tag di lettura per un archivio di sequenze
Per aggiornare i tag del set di lettura o altri campi per un archivio di sequenze, procedi nel seguente modo:
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il pannello di navigazione a sinistra (≡). Scegli i **negozi Sequence**.
1. Scegli l'archivio di sequenze che desideri aggiornare.
1. Seleziona la scheda **Details** (Dettagli).
1. Scegli **Modifica**.
1. Aggiungi nuovi tag di lettura o elimina i tag esistenti, se necessario.
1. Aggiorna il nome, la descrizione, la posizione di riserva o l'accesso ai dati S3, come richiesto.
1. Scegli **Save changes** (Salva modifiche).
## Importazione di file genomici
Per importare file genomici in un archivio di sequenze, procedi nel seguente modo:
**Per importare un file genomico**
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il pannello di navigazione a sinistra (≡). Scegli **Sequence stores**.
1. Nella pagina **Sequence stores**, scegli l'archivio di sequenze in cui vuoi importare i tuoi file.
1. Nella pagina dell'archivio delle singole sequenze, scegli **Importa file genomici**.
1. Nella pagina **Specificare i dettagli di importazione**, fornite le seguenti informazioni
+ **Ruolo IAM**: il ruolo IAM che può accedere ai file genomici su Amazon S3.
+ Genoma **di riferimento: il genoma** di riferimento per questi dati genomici.
1. **Nella pagina **Specificare il manifesto di importazione**, specificare il seguente file manifesto di informazioni.** Il file manifest è un file JSON o YAML che descrive le informazioni essenziali dei dati genomici. Per informazioni sul file manifest, vedere. [Importazione di set di lettura in un archivio di HealthOmics sequenze](import-sequence-store.md)
1. Fate clic su **Crea processo di importazione**.
# Eliminazione di archivi HealthOmics di riferimenti e sequenze
È possibile eliminare sia gli archivi di riferimento che quelli di sequenza. Gli archivi di sequenze possono essere eliminati solo se non contengono set di lettura e gli archivi di riferimento possono essere eliminati solo se non contengono riferimenti. L'eliminazione di una sequenza o di un archivio di riferimenti elimina anche tutti i tag associati a tale archivio.
L'esempio seguente mostra come eliminare un archivio di riferimenti utilizzando. AWS CLI Se l'azione ha esito positivo, non riceverai alcuna risposta. Nell'esempio seguente, sostituiscilo `reference store ID` con il tuo ID del negozio di riferimento.
```
aws omics delete-reference-store --id reference store ID
```
L'esempio seguente mostra come eliminare un archivio di sequenze. Non si riceve una risposta se l'azione ha esito positivo. Nell'esempio seguente, sostituiscilo `sequence store ID` con il tuo Sequence Store ID.
```
aws omics delete-sequence-store --id sequence store ID
```
È inoltre possibile eliminare un riferimento in un archivio di riferimenti, come illustrato nell'esempio seguente. I riferimenti possono essere eliminati solo se non vengono utilizzati in un set di lettura, in un archivio di varianti o in un archivio di annotazioni. Nell'esempio seguente, sostituiscilo `reference store ID` con l'ID del tuo negozio di riferimento e sostituiscilo `reference ID` con l'ID del riferimento che desideri eliminare.
```
aws omics delete-reference --id reference ID --reference-store-id reference store ID
```
# Importazione di set di lettura in un archivio di HealthOmics sequenze
Dopo aver creato l'archivio delle sequenze, create processi di importazione per caricare i set di lettura nell'archivio dati. Puoi caricare i tuoi file da un bucket Amazon S3 oppure caricarli direttamente utilizzando le operazioni API sincrone. Il tuo bucket Amazon S3 deve trovarsi nella stessa regione del tuo Sequence Store.
Puoi caricare qualsiasi combinazione di set di lettura allineati e non allineati nel tuo archivio di sequenze, tuttavia, se uno dei set di lettura nell'importazione è allineato, devi includere un genoma di riferimento.
Puoi riutilizzare la policy di accesso IAM che hai usato per creare l'archivio di riferimento.
I seguenti argomenti descrivono i passaggi principali da seguire per importare un set di lettura nel proprio Sequence Store e quindi ottenere informazioni sui dati importati.
**Topics**
+ [Caricare file su Amazon S3](#upload-files-to-s3)
+ [Creazione di un file manifesto](#create-manifest-file)
+ [Avvio del processo di importazione](#start-import-job)
+ [Monitora il processo di importazione](#monitor-import-job)
+ [Trovate i file di sequenza importati](#list-read-sets)
+ [Ottieni dettagli su un set di lettura](#get-read-set-metadata)
+ [Scarica i file di dati del set di lettura](#get-read-set-data)
## Caricare file su Amazon S3
L'esempio seguente mostra come spostare i file nel bucket Amazon S3.
```
aws s3 cp s3://1000genomes/phase1/data/HG00100/alignment/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam s3://your-bucket
aws s3 cp s3://1000genomes/phase3/data/HG00146/sequence_read/SRR233106_1.filt.fastq.gz s3://your-bucket
aws s3 cp s3://1000genomes/phase3/data/HG00146/sequence_read/SRR233106_2.filt.fastq.gz s3://your-bucket
aws s3 cp s3://1000genomes/data/HG00096/alignment/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram s3://your-bucket
aws s3 cp s3://gatk-test-data/wgs_ubam/NA12878_20k/NA12878_A.bam s3://your-bucket
```
L'esempio `BAM` e quello `CRAM` utilizzato in questo esempio richiedono riferimenti genomici diversi, e. `Hg19` `Hg38` Per saperne di più o per accedere a questi riferimenti, vedere [The Broad Genome References](https://registry.opendata.aws/broad-references/) nel Registry of Open Data su. AWS
## Creazione di un file manifesto
È inoltre necessario creare un file manifest in JSON in cui modellare il processo di importazione `import.json` (vedere l'esempio seguente). Se create un archivio di sequenze nella console, non è necessario specificare `sequenceStoreId` o`roleARN`, quindi il file manifest inizia con l'`sources`input.
------
#### [ API manifest ]
L'esempio seguente importa tre set di lettura utilizzando l'API: uno `FASTQ``BAM`, uno e uno`CRAM`.
```
{
"sequenceStoreId": "3936421177",
"roleArn": "arn:aws:iam::555555555555:role/OmicsImport",
"sources":
[
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
// NOTE: there is no reference arn required here
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"subjectId": "mySubject",
"sampleId": "mySample",
// NOTE: there is no reference arn required here
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data"
}
]
}
```
------
#### [ Console manifest ]
Questo codice di esempio viene utilizzato per importare un singolo set di lettura utilizzando la console.
```
[
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://your-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data"
}
]
```
------
In alternativa, puoi caricare il file manifest in formato YAML.
## Avvio del processo di importazione
Per avviare il processo di importazione, utilizzare il AWS CLI comando seguente.
```
aws omics start-read-set-import-job --cli-input-json file://import.json
```
Riceverai la seguente risposta, che indica che la creazione di posti di lavoro è riuscita.
```
{
"id": "3660451514",
"sequenceStoreId": "3936421177",
"roleArn": "arn:aws:iam::111122223333:role/OmicsImport",
"status": "CREATED",
"creationTime": "2022-07-13T22:14:59.309Z"
}
```
## Monitora il processo di importazione
Dopo l'avvio del processo di importazione, è possibile monitorarne l'avanzamento con il seguente comando. Nell'esempio seguente, sostituitelo `sequence store id` con il vostro Sequence Store ID e sostituitelo `job import ID` con l'ID di importazione.
```
aws omics get-read-set-import-job --sequence-store-id sequence store id --id job import ID
```
Di seguito vengono illustrati gli stati di tutti i lavori di importazione associati all'ID dell'archivio delle sequenze specificato.
```
{
"id": "1234567890",
"sequenceStoreId": "1234567890",
"roleArn": "arn:aws:iam::111122223333:role/OmicsImport",
"status": "RUNNING",
"statusMessage": "The job is currently in progress.",
"creationTime": "2022-07-13T22:14:59.309Z",
"sources": [
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/3242349265/reference/8625408453",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/3242349265/reference/1234568870",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data",
"readSetID": "1234567890"
}
]
}
```
## Trovate i file di sequenza importati
Una volta completato il lavoro, potete utilizzare l'operazione **list-read-sets**API per trovare i file di sequenza importati. Nell'esempio seguente, sostituiscilo `sequence store id` con il tuo Sequence Store ID.
```
aws omics list-read-sets --sequence-store-id sequence store id
```
Riceverai la seguente risposta.
```
{
"readSets": [
{
"id": "0000000001",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/01234567890/readSet/0000000001",
"sequenceStoreId": "1234567890",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00100",
"description": "BAM for HG00100",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/01234567890/reference/0000000001",
"fileType": "BAM",
"sequenceInformation": {
"totalReadCount": 9194,
"totalBaseCount": 928594,
"generatedFrom": "1000 Genomes",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:25:20Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "d1d65429212d61d115bb19f510d4bd02"
}
},
{
"id": "0000000002",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000002",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00146",
"description": "FASTQ for HG00146",
"fileType": "FASTQ",
"sequenceInformation": {
"totalReadCount": 8000000,
"totalBaseCount": 1184000000,
"generatedFrom": "1000 Genomes",
"alignment": "UNALIGNED"
},
"creationTime": "2022-07-13T23:26:43Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "FASTQ_MD5up",
"source1": "ca78f685c26e7cc2bf3e28e3ec4d49cd"
}
},
{
"id": "0000000003",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000003",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00096",
"description": "CRAM for HG00096",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/0123456789/reference/0000000001",
"fileType": "CRAM",
"sequenceInformation": {
"totalReadCount": 85466534,
"totalBaseCount": 24000004881,
"generatedFrom": "1000 Genomes",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:30:41Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "CRAM_MD5up",
"source1": "66817940f3025a760e6da4652f3e927e"
}
},
{
"id": "0000000004",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000004",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"fileType": "UBAM",
"sequenceInformation": {
"totalReadCount": 20000,
"totalBaseCount": 5000000,
"generatedFrom": "GATK Test Data",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:30:41Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "640eb686263e9f63bcda12c35b84f5c7"
}
}
]
}
```
## Ottieni dettagli su un set di lettura
Per visualizzare maggiori dettagli su un set di lettura, utilizza l'operazione **GetReadSetMetadata**API. Nell'esempio seguente, sostituiscilo `sequence store id` con il tuo Sequence Store ID e sostituiscilo `read set id` con il tuo ID del set di lettura.
```
aws omics get-read-set-metadata --sequence-store-id sequence store id --id read set id
```
Riceverai la seguente risposta.
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/2015356892/readSet/9515444019",
"creationTime": "2024-01-12T04:50:33.548Z",
"creationType": "IMPORT",
"creationJobId": "33222111",
"description": null,
"etag": {
"algorithm": "FASTQ_MD5up",
"source1": "00d0885ba3eeb211c8c84520d3fa26ec",
"source2": "00d0885ba3eeb211c8c84520d3fa26ec"
},
"fileType": "FASTQ",
"files": {
"index": null,
"source1": {
"contentLength": 10818,
"partSize": 104857600,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
"totalParts": 1
},
"source2": {
"contentLength": 10818,
"partSize": 104857600,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
"totalParts": 1
}
},
"id": "9515444019",
"name": "paired-fastq-import",
"sampleId": "sampleId-paired-fastq-import",
"sequenceInformation": {
"alignment": "UNALIGNED",
"generatedFrom": null,
"totalBaseCount": 30000,
"totalReadCount": 200
},
"sequenceStoreId": "2015356892",
"status": "ACTIVE",
"statusMessage": null,
"subjectId": "subjectId-paired-fastq-import"
}
```
## Scarica i file di dati del set di lettura
Puoi accedere agli oggetti per un set di lettura attivo utilizzando l'operazione dell'**GetObject**API Amazon S3. L'URI dell'oggetto viene restituito nella risposta dell'**GetReadSetMetadata**API. Per ulteriori informazioni, consulta [Accesso ai set di HealthOmics lettura con Amazon S3 URIs](s3-access.md).
In alternativa, utilizzate l'operazione HealthOmics **GetReadSet** API. È possibile **GetReadSet** utilizzare il download in parallelo scaricando singole parti. Queste parti sono simili alle parti di Amazon S3. Di seguito è riportato un esempio di come scaricare la parte 1 da un set di lettura. Nell'esempio seguente, sostituiscilo `sequence store id` con il tuo Sequence Store ID e sostituiscilo `read set id` con il tuo ID del set di lettura.
```
aws omics get-read-set --sequence-store-id sequence store id --id read set id --part-number 1 outfile.bam
```
È inoltre possibile utilizzare HealthOmics Transfer Manager per scaricare file da utilizzare come HealthOmics riferimento o come set di lettura. Puoi scaricare il HealthOmics Transfer Manager [qui](https://pypi.org/project/amazon-omics-tools/). Per ulteriori informazioni sull'uso e la configurazione di Transfer Manager, consulta questo [GitHubRepository](https://github.com/awslabs/amazon-omics-tools/).
# Caricamento diretto su un archivio HealthOmics di sequenze
Ti consigliamo di utilizzare HealthOmics Transfer Manager per aggiungere file al tuo archivio di sequenze. Per ulteriori informazioni sull'utilizzo di Transfer Manager, consultate questo [GitHubRepository](https://github.com/awslabs/amazon-omics-tools/). Puoi anche caricare i tuoi set di lettura direttamente in un archivio di sequenze tramite le operazioni dell'API di caricamento diretto.
I set di lettura per il caricamento diretto esistono per primi nello `PROCESSING_UPLOAD` stato. Ciò significa che le parti del file sono attualmente in fase di caricamento ed è possibile accedere ai metadati del set di lettura. Dopo il caricamento delle parti e la convalida dei checksum, il set di lettura diventa `ACTIVE` e si comporta come un set di lettura importato.
Se il caricamento diretto fallisce, lo stato del set di lettura viene visualizzato come. `UPLOAD_FAILED` Puoi configurare un bucket Amazon S3 come posizione di riserva per i file che non vengono caricati. Le posizioni di riserva sono disponibili per i sequence store creati dopo il 15 maggio 2023.
**Topics**
+ [Caricamento diretto in un archivio di sequenze utilizzando AWS CLI](#synchronous-uploads-api)
+ [Configura una posizione di fallback](#synchronous-uploads-fallback)
## Caricamento diretto in un archivio di sequenze utilizzando AWS CLI
Per iniziare, avvia un caricamento in più parti. È possibile eseguire questa operazione utilizzando AWS CLI, come illustrato nell'esempio seguente.
**Per il caricamento diretto utilizzando AWS CLI i comandi**
1. Create le parti separando i dati, come illustrato nell'esempio seguente.
```
split -b 100MiB SRR233106_1.filt.fastq.gz source1_part_
```
1. Dopo che i file sorgente sono stati suddivisi in parti, create un caricamento del set di lettura in più parti, come illustrato nell'esempio seguente. Sostituite `sequence store ID` e gli altri parametri con l'ID del vostro archivio di sequenza e altri valori.
```
aws omics create-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--name upload name \
--source-file-type FASTQ \
--subject-id subject ID \
--sample-id sample ID \
--description "FASTQ for HG00146" "description of upload" \
--generated-from "1000 Genomes""source of imported files"
```
Ottieni i metadati `uploadID` e gli altri metadati nella risposta. Utilizza il `uploadID` per la fase successiva del processo di caricamento.
```
{
"sequenceStoreId": "1504776472",
"uploadId": "7640892890",
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"name": "HG00146",
"description": "FASTQ for HG00146",
"creationTime": "2023-11-20T23:40:47.437522+00:00"
}
```
1. Aggiungi i tuoi set di lettura al caricamento. Se il file è sufficientemente piccolo, è sufficiente eseguire questo passaggio una sola volta. Per file di grandi dimensioni, esegui questo passaggio per ogni parte del file. Se si carica una nuova parte utilizzando un numero di parte utilizzato in precedenza, la parte caricata in precedenza viene sovrascritta.
Nell'esempio seguente `sequence store ID``upload ID`, sostituite e gli altri parametri con i vostri valori.
```
aws omics upload-read-set-part \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--part-source SOURCE1 \
--part-number part number \
--payload source1/source1_part_aa.fastq.gz
```
La risposta è un ID che potete utilizzare per verificare che il file caricato corrisponda al file desiderato.
```
{
"checksum": "984979b9928ae8d8622286c4a9cd8e99d964a22d59ed0f5722e1733eb280e635"
}
```
1. Continua a caricare le parti del file, se necessario. Per verificare che i set di lettura siano stati caricati, utilizzate l'operazione API **list-read-set-upload-parts**, come illustrato di seguito. Nell'esempio seguente `sequence store ID ``upload ID`, sostituisci «e» `part source` con il tuo input.
```
aws omics list-read-set-upload-parts \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--part-source SOURCE1
```
La risposta restituisce il numero di set di lettura, la dimensione e il timestamp dell'ultimo aggiornamento.
```
{
"parts": [
{
"partNumber": 1,
"partSize": 104857600,
"partSource": "SOURCE1",
"checksum": "MVMQk+vB9C3Ge8ADHkbKq752n3BCUzyl41qEkqlOD5M=",
"creationTime": "2023-11-20T23:58:03.500823+00:00",
"lastUpdatedTime": "2023-11-20T23:58:03.500831+00:00"
},
{
"partNumber": 2,
"partSize": 104857600,
"partSource": "SOURCE1",
"checksum": "keZzVzJNChAqgOdZMvOmjBwrOPM0enPj1UAfs0nvRto=",
"creationTime": "2023-11-21T00:02:03.813013+00:00",
"lastUpdatedTime": "2023-11-21T00:02:03.813025+00:00"
},
{
"partNumber": 3,
"partSize": 100339539,
"partSource": "SOURCE1",
"checksum": "TBkNfMsaeDpXzEf3ldlbi0ipFDPaohKHyZ+LF1J4CHk=",
"creationTime": "2023-11-21T00:09:11.705198+00:00",
"lastUpdatedTime": "2023-11-21T00:09:11.705208+00:00"
}
]
}
```
1. Per visualizzare tutti i caricamenti attivi di set di lettura multiparte, utilizzate **list-multipart-read-set-uploads,** come illustrato di seguito. `sequence store ID`Sostituitelo con l'ID del vostro archivio di sequenze.
```
aws omics list-multipart-read-set-uploads --sequence-store-id
sequence store ID
```
Questa API restituisce solo caricamenti di set di lettura multiparte in corso. **Dopo che i set di lettura sono stati inseriti`ACTIVE`, o se il caricamento non è riuscito, il caricamento non verrà restituito nella risposta all'API -uploads. list-multipart-read-set** Per visualizzare i set di lettura attivi, utilizza l'API. **list-read-sets** Di seguito è riportato un esempio di risposta per **list-multipart-read-set-uploads**.
```
{
"uploads": [
{
"sequenceStoreId": "1234567890",
"uploadId": "8749584421",
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"name": "HG00146",
"description": "FASTQ for HG00146",
"creationTime": "2023-11-29T19:22:51.349298+00:00"
},
{
"sequenceStoreId": "1234567890",
"uploadId": "5290538638",
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/8168613728/reference/2190697383",
"name": "HG00146",
"description": "BAM for HG00146",
"creationTime": "2023-11-29T19:23:33.116516+00:00"
},
{
"sequenceStoreId": "1234567890",
"uploadId": "4174220862",
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/8168613728/reference/2190697383",
"name": "HG00147",
"description": "BAM for HG00147",
"creationTime": "2023-11-29T19:23:47.007866+00:00"
}
]
}
```
1. Dopo aver caricato tutte le parti del file, usa **complete-multipart-read-set-upload** per concludere il processo di caricamento, come mostrato nell'esempio seguente. Sostituisci `sequence store ID` e il parametro per le parti con i tuoi valori. `upload ID`
```
aws omics complete-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--parts '[{"checksum":"gaCBQMe+rpCFZxLpoP6gydBoXaKKDA/Vobh5zBDb4W4=","partNumber":1,"partSource":"SOURCE1"}]'
```
La risposta per **complete-multipart-read-set-upload** è il set di lettura IDs per i set di lettura importati.
```
{
"readSetId": "0000000001"
}
```
1. Per interrompere il caricamento, usa **abort-multipart-read-set-upload** con l'ID di caricamento per terminare il processo di caricamento. Sostituisci `sequence store ID` e `upload ID` con i tuoi valori di parametro.
```
aws omics abort-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--upload-id upload ID
```
1. Una volta completato il caricamento, recuperate i dati dal set di lettura utilizzando **get-read-set**, come illustrato di seguito. Se il caricamento è ancora in fase di elaborazione, **get-read-set**restituisce metadati limitati e i file indice generati non sono disponibili. Sostituisci `sequence store ID` e gli altri parametri con il tuo input.
```
aws omics get-read-set
--sequence-store-id sequence store ID \
--id read set ID \
--file SOURCE1 \
--part-number 1 myfile.fastq.gz
```
1. Per controllare i metadati, incluso lo stato del caricamento, utilizza l'operazione **get-read-set-metadata**API.
```
aws omics get-read-set-metadata --sequence-store-id sequence store ID --id read set ID
```
La risposta include dettagli sui metadati come il tipo di file, l'ARN di riferimento, il numero di file e la lunghezza delle sequenze. Include anche lo stato. Gli stati possibili sono `PROCESSING_UPLOAD``ACTIVE`, e`UPLOAD_FAILED`.
```
{
"id": "0000000001",
"arn": "arn:aws:omics:us-west-2:555555555555:sequenceStore/0123456789/readSet/0000000001",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "PROCESSING_UPLOAD",
"name": "HG00146",
"description": "FASTQ for HG00146",
"fileType": "FASTQ",
"creationTime": "2022-07-13T23:25:20Z",
"files": {
"source1": {
"totalParts": 5,
"partSize": 123456789012,
"contentLength": 6836725,
},
"source2": {
"totalParts": 5,
"partSize": 123456789056,
"contentLength": 6836726
}
},
'creationType": "UPLOAD"
}
```
## Configura una posizione di fallback
Quando crei o aggiorni un archivio di sequenze, puoi configurare un bucket Amazon S3 come posizione di riserva per i file che non vengono caricati. Le parti dei file per quei set di lettura vengono trasferite nella posizione di fallback. Le posizioni di riserva sono disponibili per i sequence store creati dopo il 15 maggio 2023.
Crea una policy per i bucket di Amazon S3 per concedere l'accesso in HealthOmics scrittura alla posizione di fallback di Amazon S3, come illustrato nell'esempio seguente:
```
{
"Effect": "Allow",
"Principal": {
"Service": "omics.amazonaws.com"
},
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
```
Se il bucket Amazon S3 per i fallback o i log di accesso utilizza una chiave gestita dal cliente, aggiungi le seguenti autorizzazioni alla policy chiave:
```
{
"Sid": "Allow use of key",
"Effect": "Allow",
"Principal": {
"Service": "omics.amazonaws.com"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey*"
],
"Resource": "*"
}
```
# Esportazione di set di HealthOmics lettura in un bucket Amazon S3
Puoi esportare i set di lettura come processo di esportazione in batch in un bucket Amazon S3. Per farlo, crea innanzitutto una policy IAM con accesso in scrittura al bucket, simile al seguente esempio di policy IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
------
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"omics.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Una volta stabilita la policy IAM, inizia il processo di esportazione read set. L'esempio seguente mostra come eseguire questa operazione utilizzando l'operazione API **start-read-set-export-job**. Nell'esempio seguente, sostituisci tutti i parametri, come`sequence store ID`,`destination`, e `role ARN``sources`, con il tuo input.
```
aws omics start-read-set-export-job
--sequence-store-id sequence store id \
--destination valid s3 uri \
--role-arn role ARN \
--sources readSetId=read set id_1 readSetId=read set id_2
```
Riceverai la seguente risposta con informazioni sull'archivio della sequenza di origine e sul bucket Amazon S3 di destinazione.
```
{
"id": ,
"sequenceStoreId": ,
"destination": ,
"status": "SUBMITTED",
"creationTime": "2022-10-22T01:33:38.079000+00:00"
}
```
Dopo l'avvio del processo, puoi determinarne lo stato utilizzando l'operazione API **get-read-set-export-job**, come illustrato di seguito. Sostituisci `sequence store ID` e `job ID` con il tuo Sequence Store ID e Job ID, rispettivamente.
```
aws omics get-read-set-export-job --id job-id --sequence-store-id sequence store ID
```
È possibile visualizzare tutti i lavori di esportazione inizializzati per un archivio di sequenze utilizzando l'operazione API ** list-read-set-export-jobs**, come illustrato di seguito. Sostituisci il `sequence store ID` con il tuo Sequence Store ID.
```
aws omics list-read-set-export-jobs --sequence-store-id sequence store ID.
```
```
{
"exportJobs": [
{
"id": ,
"sequenceStoreId": ,
"destination": ,
"status": "COMPLETED",
"creationTime": "2022-10-22T01:33:38.079000+00:00",
"completionTime": "2022-10-22T01:34:28.941000+00:00"
}
]
}
```
Oltre a esportare i set di lettura, puoi anche condividerli utilizzando l'accesso Amazon URIs S3. Per ulteriori informazioni, consulta [Accesso ai set di HealthOmics lettura con Amazon S3 URIs](s3-access.md).
# Accesso ai set di HealthOmics lettura con Amazon S3 URIs
Puoi utilizzare i percorsi URI di Amazon S3 per accedere ai set di lettura del tuo archivio di sequenze attivo.
Con il percorso URI di Amazon S3, puoi utilizzare le operazioni di Amazon S3 per elencare, condividere e scaricare i tuoi set di lettura. L'accesso tramite S3 APIs accelera la collaborazione e l'integrazione degli strumenti, dato che molti strumenti del settore sono già progettati per essere letti da S3. Inoltre, puoi condividere l'accesso a S3 APIs con altri account e fornire l'accesso in lettura ai dati in più regioni.
HealthOmics non supporta l'accesso URI di Amazon S3 ai set di lettura archiviati. Quando attivi un set di lettura, viene ripristinato ogni volta sullo stesso percorso URI.
Con i dati caricati negli HealthOmics store, poiché l'URI di Amazon S3 è basato sui punti di accesso Amazon S3, puoi integrarti direttamente con strumenti standard del settore che leggono Amazon S3, come i URIs seguenti:
+ Applicazioni di analisi visiva come Integrative Genomics Viewer (IGV) o UCSC Genome Browser.
+ Flussi di lavoro comuni con estensioni Amazon S3 come CWL, WDL e Nextflow.
+ Qualsiasi strumento in grado di autenticare e leggere dal punto di accesso Amazon URIs S3 o leggere Amazon S3 prefirmato. URIs
+ Utilità Amazon S3 come Mountpoint o. CloudFront
Amazon S3 Mountpoint consente di utilizzare un bucket Amazon S3 come file system locale. Per ulteriori informazioni su Mountpoint e per installarlo per l'uso, consulta [Mountpoint per Amazon S3](https://github.com/awslabs/mountpoint-s3).
Amazon CloudFront è un servizio di rete per la distribuzione di contenuti (CDN) creato per prestazioni elevate, sicurezza e praticità per gli sviluppatori. Per ulteriori informazioni sull'uso di Amazon CloudFront, consulta [la CloudFront documentazione di Amazon](https://docs.aws.amazon.com/cloudfront/). Per configurare CloudFront un Sequence Store, contatta il AWS HealthOmics team.
L'account root del proprietario dei dati è abilitato per le azioni S3:GetObject, S3: e S3:List Bucket sul prefisso del Sequence Store. GetObjectTagging Per consentire a un utente dell'account di accedere ai dati, devi creare una policy IAM e collegarla all'utente o al ruolo. Per un esempio di policy, consulta [Autorizzazioni per l'accesso ai dati tramite Amazon S3 URIs](s3-sharing.md).
Puoi utilizzare le seguenti operazioni API di Amazon S3 sui set di lettura attivi per elencare e recuperare i tuoi dati. Puoi accedere ai set di lettura archiviati tramite Amazon URIs S3 dopo che sono stati attivati.
+ [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)— Recupera un oggetto da Amazon S3.
+ [HeadObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html.html)— L'operazione HEAD recupera i metadati da un oggetto senza restituire l'oggetto stesso. Questa operazione è utile se desiderate solo i metadati di un oggetto.
+ [ListObjects e ListObject v2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html) — Restituisce alcuni o tutti (fino a 1.000) gli oggetti in un bucket.
+ [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)— Crea una copia di un oggetto già archiviato in Amazon S3. HealthOmicssupporta la copia su un punto di accesso Amazon S3, ma non la scrittura su un punto di accesso.
HealthOmics gli archivi di sequenze mantengono l'identità semantica dei file tramite. ETags Nel corso del ciclo di vita di un file, Amazon ETag S3, che si basa sull'identità bit per bit, può cambiare, HealthOmics ETag ma rimane lo stesso. Per ulteriori informazioni, consulta [HealthOmics ETags e provenienza dei dati](etags-and-provenance.md).
**Topics**
+ [Struttura URI Amazon S3 nello storage HealthOmics](#s3-uri-structure)
+ [Utilizzo di IGV ospitato o locale per accedere ai set di lettura](#s3-access-igv)
+ [Utilizzando Samtools o in HTSlib HealthOmics](#s3-access-Samtools)
+ [Usare Mountpoint HealthOmics](#s3-access-Mountpoint)
+ [Usando con CloudFront HealthOmics](#s3-access-CloudFront)
## Struttura URI Amazon S3 nello storage HealthOmics
Tutti i file con Amazon S3 URIs dispongono di tag `omics:subjectId` di `omics:sampleId` risorsa. Puoi utilizzare questi tag per condividere l'accesso utilizzando le policy IAM attraverso un modello come`"s3:ExistingObjectTag/omics:subjectId": "pattern desired"`.
La struttura del file è la seguente:
`.../account_id/sequenceStore/seq_store_id/readSet/read_set_id/files.`
Per i file importati negli archivi di sequenza da Amazon S3, l'archivio di sequenze tenta di mantenere il nome sorgente originale. Quando i nomi sono in conflitto, il sistema aggiunge le informazioni sui set di lettura per garantire che i nomi dei file siano univoci. Ad esempio, per i set di lettura fastq, se entrambi i nomi di file sono uguali, per renderli unici, `sourceX` viene inserito prima di .fastq.gz o .fq.gz. Per un caricamento diretto, i nomi dei file seguono i seguenti schemi:
+ Per FASTQ— *read\$1set\$1name* \$1 .fastq.gz *sourcex*
+ uBAM/BAM/CRAMPer *read\$1set\$1name* —. *file extension*con estensioni di `.bam` o`.cram`. Un esempio è `NA193948.bam`.
Per i set di lettura che sono BAM o CRAM, i file di indice vengono generati automaticamente durante il processo di ingestione. Per i file di indice generati, viene applicata l'estensione di indice corretta alla fine del nome del file. Ha lo schema *..* Le estensioni dell'indice sono `.bai` o`.crai`.
## Utilizzo di IGV ospitato o locale per accedere ai set di lettura
IGV è un browser genomico utilizzato per analizzare i file BAM e CRAM. Richiede sia il file che l'indice perché mostra solo una parte del genoma alla volta. IGV può essere scaricato e utilizzato localmente e sono disponibili guide per creare un IGV ospitato in AWS. La versione web pubblica non è supportata perché richiede CORS.
IGV locale si basa sulla AWS configurazione locale per accedere ai file. Assicurati che al ruolo utilizzato in quella configurazione sia associata una policy che kms: abiliti Decrypt e s3: GetObject autorizzazioni all'URI s3 dei set di lettura a cui si accede. Dopodiché, in IGV, puoi usare «File > carica da URL» e incollare l'URI per il codice sorgente e l'indice. In alternativa, presigned URLs può essere generato e utilizzato nello stesso modo, ignorando la configurazione AWS. Tieni presente che CORS non è supportato con l'accesso URI di Amazon S3, quindi le richieste che si basano su CORS non sono supportate.
L'esempio AWS Hosted IGV si affida ad AWS Cognito per creare le configurazioni e le autorizzazioni corrette all'interno dell'ambiente. Assicurati che venga creata una policy che abiliti le autorizzazioni KMS:Decrypt e s3: GetObject per l'URI Amazon S3 dei set di lettura a cui si accede e aggiungi questa policy al ruolo assegnato al pool di utenti Cognito. Dopodiché, in IGV, puoi usare «File > carica da URL» e inserire l'URI per l'origine e l'indice. In alternativa, presigned URLs può essere generato e utilizzato nello stesso modo, ignorando la configurazione AWS.
Tieni presente che l'archivio delle sequenze non verrà visualizzato nella scheda «Amazon» perché mostra solo i bucket di tua proprietà nella regione in cui è configurato il AWS profilo.
## Utilizzando Samtools o in HTSlib HealthOmics
HTSlib è la libreria principale condivisa da diversi strumenti come Samtools, RSAMTools e altri. PySam Usa HTSlib la versione 1.20 o successiva per ottenere un supporto senza interruzioni per Amazon S3 Access Point. Per le versioni precedenti della HTSlib libreria, puoi utilizzare le seguenti soluzioni alternative:
+ Imposta la variabile di ambiente per l'host HTS Amazon S3 con:. `export HTS_S3_HOST="s3.region.amazonaws.com"`
+ Genera un URL predefinito per i file che desideri utilizzare. Se utilizzi un BAM o un CRAM, assicurati che venga generato un URL predefinito sia per il file che per l'indice. Dopodiché, entrambi i file possono essere utilizzati con le librerie.
+ Usa Mountpoint per montare l'archivio di sequenze o leggere il prefisso set nello stesso ambiente in cui stai usando HTSlib le librerie. Da qui, è possibile accedere ai file utilizzando i percorsi dei file locali.
## Usare Mountpoint HealthOmics
Mountpoint per Amazon S3 è un client di file semplice e ad alta velocità per il montaggio di [un bucket Amazon S3 come file system locale](https://aws.amazon.com/blogs/storage/the-inside-story-on-mountpoint-for-amazon-s3-a-high-performance-open-source-file-client/). Con Mountpoint per Amazon S3, le tue applicazioni possono accedere agli oggetti archiviati in Amazon S3 tramite operazioni sui file come apertura e lettura. Mountpoint per Amazon S3 traduce automaticamente queste operazioni in chiamate API di oggetti Amazon S3, offrendo alle applicazioni l'accesso allo storage elastico e al throughput di Amazon S3 tramite un'interfaccia di file.
[Mountpoint può essere installato utilizzando le istruzioni di installazione di Mountpoint.](https://github.com/awslabs/mountpoint-s3/blob/main/doc/INSTALL.md) Mountpoint utilizza il profilo AWS locale per l'installazione e funziona a livello di prefisso Amazon S3. Assicurati che il profilo utilizzato abbia una policy che abiliti le autorizzazioni s3:GetObject, s3: ListBucket e kms: Decrypt per il prefisso URI Amazon S3 dei set di lettura o dell'archivio di sequenze a cui si accede. Successivamente, il bucket può essere montato utilizzando il seguente percorso:
```
mount-s3 access point arn local path to mount --prefix prefix to sequence store or read set --region region
```
## Usando con CloudFront HealthOmics
Amazon CloudFront è un servizio di rete per la distribuzione di contenuti (CDN) progettato per prestazioni elevate, sicurezza e praticità per gli sviluppatori. I clienti che lo desiderano CloudFront devono collaborare con il team di assistenza per attivare la CloudFront distribuzione. Collabora con il team del tuo account per coinvolgere il team HealthOmics di assistenza.
# Attivazione dei set di lettura in HealthOmics
È possibile attivare i set di lettura archiviati con l'operazione API **start-read-set-activation-job** o tramite AWS CLI, come illustrato nell'esempio seguente. Sostituisci `sequence store ID` e `read set id` con il tuo sequence store ID e read set. IDs
```
aws omics start-read-set-activation-job
--sequence-store-id sequence store ID \
--sources readSetId=read set ID readSetId=read set id_1 read set id_2
```
Riceverai una risposta che contiene le informazioni sul processo di attivazione, come illustrato di seguito.
```
{
"id": "12345678",
"sequenceStoreId": "1234567890",
"status": "SUBMITTED",
"creationTime": "2022-10-22T00:50:54.670000+00:00"
}
```
Dopo l'avvio del processo di attivazione, puoi monitorarne l'avanzamento con l'operazione API **get-read-set-activation-job**. Di seguito è riportato un esempio di come utilizzare il per AWS CLI verificare lo stato del processo di attivazione. Sostituisci `job ID` e `sequence store ID` con il tuo Sequence Store ID e Job IDs, rispettivamente.
```
aws omics get-read-set-activation-job --id job ID --sequence-store-id sequence store ID
```
La risposta riassume il processo di attivazione, come illustrato di seguito.
```
{
"id": 123567890,
"sequenceStoreId": 123467890,
"status": "SUBMITTED",
"statusUpdateReason": "The job is submitted and will start soon.",
"creationTime": "2022-10-22T00:50:54.670000+00:00",
"sources": [
{
"readSetId": ,
"status": "NOT_STARTED",
"statusUpdateReason": "The source is queued for the job."
},
{
"readSetId": ,
"status": "NOT_STARTED",
"statusUpdateReason": "The source is queued for the job."
}
]
}
```
È possibile verificare lo stato di un processo di attivazione tramite l'operazione **get-read-set-metadata**API. Gli stati possibili sono `ACTIVE``ACTIVATING`, e`ARCHIVED`. Nell'esempio seguente, sostituitelo `sequence store ID` con il vostro Sequence Store ID e sostituitelo `read set ID` con il vostro Read Set ID.
```
aws omics get-read-set-metadata --sequence-store-id sequence store ID --id read set ID
```
La risposta seguente mostra che il set di lettura è attivo.
```
{
"id": "12345678",
"arn": "arn:aws:omics:us-west-2:555555555555:sequenceStore/1234567890/readSet/12345678",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00100",
"description": "HG00100 aligned to HG38 BAM",
"fileType": "BAM",
"creationTime": "2022-07-13T23:25:20Z",
"sequenceInformation": {
"totalReadCount": 1513467,
"totalBaseCount": 163454436,
"generatedFrom": "Pulled from SRA",
"alignment": "ALIGNED"
},
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"files": {
"source1": {
"totalParts": 2,
"partSize": 10485760,
"contentLength": 17112283,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
},
"index": {
"totalParts": 1,
"partSize": 53216,
"contentLength": 10485760
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
}
},
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "d1d65429212d61d115bb19f510d4bd02"
}
}
```
È possibile visualizzare tutti i processi di attivazione del set di lettura utilizzando **list-read-set-activation-jobs**, come mostrato nell'esempio seguente. Nell'esempio seguente, sostituiscilo `sequence store ID` con il tuo Sequence Store ID.
```
aws omics list-read-set-activation-jobs --sequence-store-id sequence store ID
```
Riceverai la seguente risposta.
```
{
"activationJobs": [
{
"id": 1234657890,
"sequenceStoreId": "1234567890",
"status": "COMPLETED",
"creationTime": "2022-10-22T01:33:38.079000+00:00",
"completionTime": "2022-10-22T01:34:28.941000+00:00"
}
]
}
```