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 analisi
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
HealthOmics l'analisi supporta l'archiviazione e l'analisi di varianti e annotazioni genomiche. Analytics fornisce due tipi di risorse di archiviazione: gli archivi di varianti e gli archivi di annotazioni. Queste risorse vengono utilizzate per archiviare, trasformare e interrogare i dati delle varianti genomiche e i dati di annotazione. Dopo aver importato i dati in un datastore, puoi utilizzare Athena per eseguire analisi avanzate sui dati.
Puoi utilizzare la HealthOmics console o l'API per creare e gestire archivi, importare dati e condividere i dati degli archivi analitici con i collaboratori.
Gli archivi Variant supportano i dati nei formati VCF e gli archivi di annotazione supportano il supporto e i formati. TSV/CSV GFF3 Le coordinate genomiche sono rappresentate come intervalli a base zero, semichiusi e semiaperti. Quando i dati si trovano nell'archivio dati di HealthOmics analisi, l'accesso ai file VCF viene gestito tramite. AWS Lake Formation Puoi quindi interrogare i file VCF utilizzando Amazon Athena. Le interrogazioni devono utilizzare il motore di interrogazione Athena versione 3. Per ulteriori informazioni sulle versioni del motore di query Athena, consulta la documentazione di [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/engine-versions-changing.html).
**Topics**
+ [
# Creazione di negozi di HealthOmics varianti
](creating-variant-stores.md)
+ [
# Creazione di processi di importazione di HealthOmics varianti di store
](parsing-annotation-stores.md)
+ [
# Creazione di HealthOmics archivi di annotazioni
](creating-and-managing-annotation-store.md)
+ [
# Creazione di processi di importazione per gli HealthOmics archivi di annotazioni
](annotation-store-import-jobs.md)
+ [
# Creazione di HealthOmics versioni dell'Annotation Store
](annotation-store-versioning.md)
+ [
# Eliminazione degli archivi di HealthOmics analisi
](deleting-a-store-examples.md)
+ [
# Interrogazione dei HealthOmics dati di analisi
](analytics-query-data.md)
+ [
# Condivisione di archivi HealthOmics di analisi
](cross-account-sharing.md)
# Creazione di negozi di HealthOmics varianti
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
I seguenti argomenti descrivono come creare negozi di HealthOmics varianti utilizzando la console e l'API.
**Topics**
+ [
## Creazione di un archivio di varianti utilizzando la console
](#gs-console-analytics)
+ [
## Creazione di un negozio di varianti utilizzando l'API
](#gs-api-analytics)
## Creazione di un archivio di varianti utilizzando la console
Puoi creare un negozio di varianti utilizzando la HealthOmics console.
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il riquadro di navigazione a sinistra (≡). Scegli **Variant stores**.
1. Nella pagina **Crea negozio di varianti**, fornisci le seguenti informazioni
+ **Nome del negozio di varianti**: un nome univoco per questo negozio.
+ **Descrizione** (opzionale): una descrizione di questo negozio di varianti.
+ **Genoma di riferimento**: il genoma di riferimento per questo archivio di varianti.
+ **Crittografia dei dati**: scegli se desideri che la crittografia dei dati sia di proprietà e gestita da te AWS o da solo.
+ **Tag** (opzionale): fornisci fino a 50 tag per questo negozio di varianti.
1. Scegli **Crea negozio di varianti**.
## Creazione di un negozio di varianti utilizzando l'API
Utilizza l'operazione HealthOmics `CreateVariantStore` API per creare archivi di varianti. È possibile eseguire questa operazione anche con AWS CLI.
Per creare un negozio di varianti, fornisci un nome per il negozio e l'ARN di un negozio di riferimento. L'archivio delle varianti è pronto per l'inserimento dei dati quando il relativo stato passa a READY.
L'esempio seguente utilizza il AWS CLI per creare un negozio di varianti.
```
aws omics create-variant-store --name myvariantstore \
--reference referenceArn="arn:aws:omics:us-west-2:555555555555:referenceStore/123456789/reference/5987565360"
```
Per confermare la creazione del tuo negozio di varianti, riceverai la seguente risposta.
```
{
"creationTime": "2022-11-03T18:19:52.296368+00:00",
"id": "45aeb91d5678",
"name": "myvariantstore",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/123456789/reference/5987565360"
},
"status": "CREATING"
}
```
Per saperne di più su un negozio di varianti, utilizza l'**get-variant-store**API.
```
aws omics get-variant-store --name myvariantstore
```
Riceverai la seguente risposta.
```
{
"id": "45aeb91d5678",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/123456789/reference/5987565360"
},
"status": "ACTIVE",
"storeArn": "arn:aws:omics:us-west-2:555555555555:variantStore/myvariantstore",
"name": "myvariantstore",
"creationTime": "2022-11-03T18:19:52.296368+00:00",
"updateTime": "2022-11-03T18:30:56.272792+00:00",
"tags": {},
"storeSizeBytes": 0
}
```
Per visualizzare tutti i negozi di varianti associati a un account, utilizza l'**list-variant-stores**API.
```
aws omics list-variant-stores
```
Riceverai una risposta che elenca tutti gli store di varianti IDs, insieme ai relativi stati e ad altri dettagli, come mostrato nella risposta di esempio seguente.
```
{
"variantStores": [
{
"id": "45aeb91d5678",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:55555555555:referenceStore/5506874698"
},
"status": "ACTIVE",
"storeArn": "arn:aws:omics:us-west-2:55555555555:variantStore/new_variant_store",
"name": "variantstore",
"creationTime": "2022-11-03T18:19:52.296368+00:00",
"updateTime": "2022-11-03T18:30:56.272792+00:00",
"statusMessage": "",
"storeSizeBytes": 141526
}
]
}
```
Puoi anche filtrare le risposte per l'**list-variant-stores**API in base agli stati o ad altri criteri.
I file VCF importati negli archivi analitici creati il o dopo il 15 maggio 2023 hanno schemi definiti per le annotazioni Variant Effect Predictor (VEP). Ciò semplifica l'interrogazione e l'analisi dei dati VCF importati. La modifica non ha alcun impatto sui negozi creati prima del 15 maggio 2023, a meno che il `annotation fields` parametro non sia incluso nella chiamata API o CLI. Per questi negozi, l'utilizzo del `annotation fields` parametro causerà l'esito negativo della richiesta.
# Creazione di processi di importazione di HealthOmics varianti di store
**Importante**
AWS HealthOmics i negozi di varianti e gli archivi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
L'esempio seguente mostra come utilizzare per AWS CLI creare un processo di importazione per un negozio di varianti.
```
aws omics start-variant-import-job \
--destination-name myvariantstore \
--runLeftNormalization false \
--role-arn arn:aws:iam::55555555555:role/roleName \
--items source=s3://my-omics-bucket/sample.vcf.gz source=s3://my-omics-bucket/sample2.vcf.gz
```
```
{
"destinationName": "store_a",
"roleArn": "....",
"runLeftNormalization": false,
"items": [
{"source": "s3://my-omics-bucket/sample.vcf.gz"},
{"source": "s3://my-omics-bucket/sample2.vcf.gz"}
]
}
```
Per i negozi creati dopo il 15 maggio 2023, l'esempio seguente mostra come aggiungere il `--annotation-fields` parametro. I campi di annotazione vengono definiti con l'importazione.
```
aws omics start-variant-import-job \
--destination-name annotationparsingvariantstore \
--role-arn arn:aws:iam::123456789012:role/ \
--items source=s3://pathToS3/sample.vcf
--annotation-fields '{"VEP": "CSQ"}'
```
```
{
"jobId": "981e2286-e954-4391-8a97-09aefc343861"
}
```
**get-variant-import-job**Usare per controllare lo stato.
```
aws omics get-variant-import-job --job-id 08279950-a9e3-4cc3-9a3c-a574f9c9e229
```
Riceverai una risposta JSON che mostra lo stato del tuo processo di importazione. Le annotazioni VEP nel VCF vengono analizzate alla ricerca di informazioni memorizzate nella colonna INFO in coppia. ID/Value L'ID predefinito per la colonna INFO delle annotazioni di [Ensembl Variant Effect Predictor](https://useast.ensembl.org/info/docs/tools/vep/index.html/#vcf) è CSQ, ma è possibile utilizzare il `--annotation-fields` parametro per indicare un valore personalizzato utilizzato nella colonna INFO. L'analisi è attualmente supportata per le annotazioni VEP.
Per un negozio creato prima del 15 maggio 2023 o per i file VCF che non includono l'annotazione VEP, la risposta non include alcun campo di annotazione.
```
{
"creationTime": "2023-04-11T17:52:37.241958+00:00",
"destinationName": "annotationparsingvariantstore",
"id": "7a1c67e3-b7f9-434d-817b-9c571fd63bea",
"items": [
{
"jobStatus": "COMPLETED",
"source": "s3://amzn-s3-demo-bucket/NA12878.2k.garvan.vcf"
}
],
"roleArn": "arn:aws:iam::555555555555:role/",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T17:58:22.676043+00:00",
}
```
Le annotazioni VEP che fanno parte dei file VCF vengono archiviate come schema predefinito con la seguente struttura. Il campo extras può essere utilizzato per memorizzare eventuali campi VEP aggiuntivi non inclusi nello schema predefinito.
```
annotations struct<
vep: array,
impact:string,
symbol:string,
gene:string,
`feature_type`: string,
feature: string,
biotype: string,
exon: struct,
intron: struct,
hgvsc: string,
hgvsp: string,
`cdna_position`: string,
`cds_position`: string,
`protein_position`: string,
`amino_acids`: struct,
codons: struct,
`existing_variation`: array,
distance: string,
strand: string,
flags: array,
symbol_source: string,
hgnc_id: string,
`extras`: map
>>
>
```
L'analisi viene eseguita con il massimo impegno. Se la voce VEP non segue le [specifiche dello standard VEP](https://useast.ensembl.org/info/docs/tools/vep/vep_formats.html#vcf), non verrà analizzata e la riga dell'array sarà vuota.
Per un nuovo archivio di varianti, la risposta per **get-variant-import-job**includerebbe i campi di annotazione, come mostrato.
```
aws omics get-variant-import-job --job-id 08279950-a9e3-4cc3-9a3c-a574f9c9e229
```
Riceverai una risposta JSON che mostra lo stato del tuo processo di importazione.
```
{
"creationTime": "2023-04-11T17:52:37.241958+00:00",
"destinationName": "annotationparsingvariantstore",
"id": "7a1c67e3-b7f9-434d-817b-9c571fd63bea",
"items": [
{
"jobStatus": "COMPLETED",
"source": "s3://amzn-s3-demo-bucket/NA12878.2k.garvan.vcf"
}
],
"roleArn": "arn:aws:iam::123456789012:role/",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T17:58:22.676043+00:00",
"annotationFields" : {"VEP": "CSQ"}
}
}
```
Puoi usarla **list-variant-import-jobs**per vedere tutti i lavori di importazione e i relativi stati.
```
aws omics list-variant-import-jobs --ids 7a1c67e3-b7f9-434d-817b-9c571fd63bea
```
La risposta contiene le seguenti informazioni.
```
{
"variantImportJobs": [
{
"creationTime": "2023-04-11T17:52:37.241958+00:00",
"destinationName": "annotationparsingvariantstore",
"id": "7a1c67e3-b7f9-434d-817b-9c571fd63bea",
"roleArn": "arn:aws:iam::55555555555:role/roleName",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T17:58:22.676043+00:00",
"annotationFields" : {"VEP": "CSQ"}
}
]
}
}
```
Se necessario, è possibile annullare un processo di importazione con il comando seguente.
```
aws omics cancel-variant-import-job
--job-id edd7b8ce-xmpl-47e2-bc99-258cac95a508
```
# Creazione di HealthOmics archivi di annotazioni
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
Un archivio di annotazioni è un archivio dati che rappresenta un database di annotazioni, ad esempio uno proveniente da un file TSV, VCF o GFF. Se viene specificato lo stesso genoma di riferimento, gli archivi di annotazioni vengono mappati sullo stesso sistema di coordinate degli archivi di varianti durante l'importazione. I seguenti argomenti mostrano come utilizzare la HealthOmics console e creare e AWS CLI gestire archivi di annotazioni.
**Topics**
+ [
## Creazione di un archivio di annotazioni utilizzando la console
](#gs-console-create-annotation-store)
+ [
## Creazione di un archivio di annotazioni utilizzando l'API
](#create-manage-annotation-store-api)
## Creazione di un archivio di annotazioni utilizzando la console
Utilizzare la procedura seguente per creare archivi di annotazioni con la HealthOmics console.
**Per creare un archivio di annotazioni**
1. Apri la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Se necessario, apri il riquadro di navigazione a sinistra (≡). Scegliete **Annotation stores**.
1. Nella pagina **Archivi di annotazioni**, scegli **Crea archivio di annotazioni**.
1. Nella pagina **Crea archivio di annotazioni**, fornisci le seguenti informazioni
+ Nome **dell'archivio di annotazioni: un nome** univoco per questo negozio.
+ **Descrizione** (opzionale): una descrizione di questo genoma di riferimento.
+ **Dettagli sul formato dei dati e sullo schema**: seleziona il formato del file di dati e carica la definizione dello schema per questo archivio.
+ **Genoma di riferimento**: il genoma di riferimento per questa annotazione.
+ **Crittografia dei dati**: scegli se desideri che la crittografia dei dati sia di proprietà e gestita da te AWS o da solo.
+ **Tag** (opzionale): fornisci fino a 50 tag per questo archivio di annotazioni.
1. Scegli **Crea archivio di annotazioni.**
## Creazione di un archivio di annotazioni utilizzando l'API
L'esempio seguente mostra come creare un archivio di annotazioni utilizzando. AWS CLI Per tutte le operazioni AWS CLI e le API, è necessario specificare il formato dei dati.
```
aws omics create-annotation-store --name my_annotation_store \
--store-format GFF \
--reference referenceArn="arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/5987565360"
--version-name new_version
```
Riceverai la seguente risposta per confermare la creazione del tuo archivio di annotazioni.
```
{
"creationTime": "2022-08-24T20:34:19.229500Z",
"id": "3b93cdef69d2",
"name": "my_annotation_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/5987565360"
},
"status": "CREATING"
"versionName": "my_version"
}
```
Per saperne di più su un archivio di annotazioni, utilizza l'**get-annotation-store**API.
```
aws omics get-annotation-store --name my_annotation_store
```
Riceverai la seguente risposta.
```
{
"id": "eeb019ac79c2",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/5638433913/reference/5871590330“
},
"status": "ACTIVE",
"storeArn": "arn:aws:omics:us-west-2:555555555555:annotationStore/gffstore",
"name": "my_annotation_store",
"creationTime": "2022-11-05T00:05:19.136131+00:00",
"updateTime": "2022-11-05T00:10:36.944839+00:00",
"tags": {},
"storeFormat": "GFF",
"statusMessage": "",
"storeSizeBytes": 0,
"numVersions": 1
}
```
Per visualizzare tutti gli archivi di annotazioni associati a un account, utilizza l'operazione **list-annotation-stores**API.
```
aws omics list-annotation-stores
```
Riceverai una risposta che elenca tutti gli archivi di annotazioni IDs, insieme ai relativi stati e ad altri dettagli, come mostrato nella risposta di esempio seguente.
```
{
"annotationStores": [
{
"id": "4d8f3eada259",
"reference":
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/5638433913/reference/5871590330"
},
"status": "CREATING",
"name": "gffstore",
"creationTime": "2022-09-27T17:30:52.182990+00:00",
"updateTime": "2022-09-27T17:30:53.025362+00:00"
}
]
}
```
È inoltre possibile filtrare le risposte in base allo stato o ad altri criteri.
# Creazione di processi di importazione per gli HealthOmics archivi di annotazioni
**Importante**
AWS HealthOmics gli store di varianti e gli archivi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
**Topics**
+ [
## Creazione di un processo di importazione delle annotazioni utilizzando l'API
](#create-annotation-import-api)
+ [
## Parametri aggiuntivi per i formati TSV e VCF
](#annotation-import-tsv-vcf)
+ [
## Creazione di archivi di annotazioni in formato TSV
](#annotation-import-tsv-vcftsv-annotation-store-examples-tsv)
+ [
## Avvio di processi di importazione in formato VCF
](#vcf-annotation-store-examples)
## Creazione di un processo di importazione delle annotazioni utilizzando l'API
L'esempio seguente mostra come utilizzare per avviare un AWS CLI processo di importazione di annotazioni.
```
aws omics start-annotation-import-job \
--destination-name myannostore \
--version-name myannostore \
--role-arn arn:aws:iam::123456789012:role/roleName \
--items source=s3://my-omics-bucket/sample.vcf.gz
--annotation-fields '{"VEP": "CSQ"}'
```
Gli archivi di annotazioni creati prima del 15 maggio 2023 restituiscono un messaggio di errore se i campi di **annotazione** sono inclusi. Non restituiscono l'output per le operazioni API coinvolte nei processi di importazione di annotation store.
È quindi possibile utilizzare l'operazione **get-annotation-import-job**API e il `job ID` parametro per ottenere maggiori dettagli sul processo di importazione delle annotazioni.
```
aws omics get-annotation-import-job --job-id 9e4198fb-fa85-446c-9301-9b823a1a8ba8
```
Riceverai la seguente risposta, inclusi i campi di annotazione.
```
{
"creationTime": "2023-04-11T19:09:25.049767+00:00",
"destinationName": "parsingannotationstore",
"versionName": "parsingannotationstore",
"id": "9e4198fb-fa85-446c-9301-9b823a1a8ba8",
"items": [
{
"jobStatus": "COMPLETED",
"source": "s3://my-omics-bucket/sample.vep.vcf"
}
],
"roleArn": "arn:aws:iam::55555555555:role/roleName",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T19:13:09.110130+00:00",
"annotationFields" : {"VEP": "CSQ"}
}
```
Per visualizzare tutti i lavori di importazione di Annotation Store, utilizzare. **list-annotation-import-jobs**
```
aws omics list-annotation-import-jobs --ids 9e4198fb-fa85-446c-9301-9b823a1a8ba8
```
La risposta include i dettagli e lo stato dei lavori di importazione dell'archivio di annotazioni.
```
{
"annotationImportJobs": [
{
"creationTime": "2023-04-11T19:09:25.049767+00:00",
"destinationName": "parsingannotationstore",
"versionName": "parsingannotationstore",
"id": "9e4198fb-fa85-446c-9301-9b823a1a8ba8",
"roleArn": "arn:aws:iam::55555555555:role/roleName",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T19:13:09.110130+00:00",
"annotationFields" : {"VEP": "CSQ"}
}
]
}
```
## Parametri aggiuntivi per i formati TSV e VCF
Per i formati TSV e VCF, esistono parametri aggiuntivi che informano l'API su come analizzare l'input.
**Importante**
I dati di annotazione CSV esportati con i motori di query restituiscono direttamente le informazioni dall'importazione del set di dati. Se i dati importati contengono formule o comandi, il file potrebbe essere soggetto all'iniezione di file CSV. Pertanto, i file esportati con i motori di query possono richiedere avvisi di sicurezza. Per evitare attività dannose, disattivate i link e le macro durante la lettura dei file di esportazione.
Il parser TSV esegue anche operazioni bioinformatiche di base, come la normalizzazione sinistra e la standardizzazione delle coordinate genomiche, elencate nella tabella seguente.
| Tipo di formato | Description |
| --- | --- |
| Generico | File di testo generico. Nessuna informazione genomica. |
| CHR\$1POS | Posizione iniziale - 1, Aggiungi posizione finale, che è la stessa di. POS |
| CHR\$1POS\$1REF\$1ALT | Contiene informazioni sugli alleli contig, 1-base position, ref e alt. |
| CHR\$1START\$1END\$1REF\$1ALT\$1ONE\$1BASE | Contiene informazioni sugli alleli contig, start, end, ref e alt. Le coordinate sono a base 1. |
| CHR\$1START\$1END\$1ZERO\$1BASE | Contiene le posizioni contig, iniziale e finale. Le coordinate sono basate su 0. |
| CHR\$1START\$1END\$1ONE\$1BASE | Contiene le posizioni contig, iniziale e finale. Le coordinate sono a base 1. |
| CHR\$1START\$1END\$1REF\$1ALT\$1ZERO\$1BASE | Contiene informazioni sugli alleli contig, start, end, ref e alt. Le coordinate sono basate su 0. |
Una richiesta di archiviazione delle annotazioni di importazione TSV è simile all'esempio seguente.
```
aws omics start-annotation-import-job \
--destination-name tsv_anno_example \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items source=s3://demodata/genomic_data.bed.gz \
--format-options '{ "tsvOptions": {
"readOptions": {
"header": false,
"sep": "\t"
}
}
}'
```
## Creazione di archivi di annotazioni in formato TSV
L'esempio seguente crea un archivio di annotazioni utilizzando un file con limiti di tabulazioni che contiene un'intestazione, righe e commenti. Le coordinate sono `CHR_START_END_ONE_BASED` e contiene la mappa HG19 genica della [Synopsis of the Human Gene Map dell'OMIM](https://www.omim.org/downloads).
```
aws omics create-annotation-store --name mimgenemap \
--store-format TSV \
--reference=referenceArn=arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/2310864158 \
--store-options=tsvStoreOptions='{
annotationType=CHR_START_END_ONE_BASE,
formatToHeader={CHR=chromosome, START=genomic_position_start, END=genomic_position_end},
schema=[
{chromosome=STRING},
{genomic_position_start=LONG},
{genomic_position_end=LONG},
{cyto_location=STRING},
{computed_cyto_location=STRING},
{mim_number=STRING},
{gene_symbols=STRING},
{gene_name=STRING},
{approved_gene_name=STRING},
{entrez_gene_id=STRING},
{ensembl_gene_id=STRING},
{comments=STRING},
{phenotypes=STRING},
{mouse_gene_symbol=STRING}]}'
```
È possibile importare file con o senza un'intestazione. Per indicarlo in una richiesta CLI, utilizzare`header=false`, come mostrato nel seguente esempio di processo di importazione.
```
aws omics start-annotation-import-job \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items=source=s3://amzn-s3-demo-bucket/annotation-examples/hg38_genemap2.txt \
--destination-name output-bucket \
--format-options=tsvOptions='{readOptions={sep="\t",header=false,comment="#"}}'
```
L'esempio seguente crea un archivio di annotazioni per un file bed. Un file bed è un semplice file delimitato da tabulazioni. In questo esempio, le colonne sono cromosoma, inizio, fine e nome della regione. Le coordinate sono a base zero e i dati non hanno un'intestazione.
```
aws omics create-annotation-store \
--name cexbed --store-format TSV \
--reference=referenceArn=arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/2310864158 \
--store-options=tsvStoreOptions='{
annotationType=CHR_START_END_ZERO_BASE,
formatToHeader={CHR=chromosome, START=start, END=end},
schema=[{chromosome=STRING}, {start=LONG}, {end=LONG}, {name=STRING}]}'
```
È quindi possibile importare il file bed nell'archivio di annotazioni utilizzando il seguente comando CLI.
```
aws omics start-annotation-import-job \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items=source=s3://amzn-s3-demo-bucket/TruSeq_Exome_TargetedRegions_v1.2.bed \
--destination-name cexbed \
--format-options=tsvOptions='{readOptions={sep="\t",header=false,comment="#"}}'
```
L'esempio seguente crea un archivio di annotazioni per un file delimitato da tabulazioni che contiene le prime colonne di un file VCF, seguite da colonne con informazioni sulle annotazioni. Contiene le posizioni del genoma con informazioni sul cromosoma, sugli alleli iniziali, di riferimento e alternativi e contiene un'intestazione.
```
aws omics create-annotation-store --name gnomadchrx --store-format TSV \
--reference=referenceArn=arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/2310864158 \
--store-options=tsvStoreOptions='{
annotationType=CHR_POS_REF_ALT,
formatToHeader={CHR=chromosome, POS=start, REF=ref, ALT=alt},
schema=[
{chromosome=STRING},
{start=LONG},
{ref=STRING},
{alt=STRING},
{filters=STRING},
{ac_hom=STRING},
{ac_het=STRING},
{af_hom=STRING},
{af_het=STRING},
{an=STRING},
{max_observed_heteroplasmy=STRING}]}'
```
È quindi necessario importare il file nell'archivio di annotazioni utilizzando il seguente comando CLI.
```
aws omics start-annotation-import-job \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items=source=s3://amzn-s3-demo-bucket/gnomad.genomes.v3.1.sites.chrM.reduced_annotations.tsv \
--destination-name gnomadchrx \
--format-options=tsvOptions='{readOptions={sep="\t",header=true,comment="#"}}'
```
L'esempio seguente mostra come un cliente può creare un archivio di annotazioni per un file mim2gene. Un file mim2gene fornisce i collegamenti tra i geni in OMIM e un altro identificatore genico. È delimitato da tabulazioni e contiene commenti.
```
aws omics create-annotation-store \
--name mim2gene \
--store-format TSV \
--reference=referenceArn=arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/2310864158 \
--store-options=tsvStoreOptions='
{annotationType=GENERIC,
formatToHeader={},
schema=[
{mim_gene_id=STRING},
{mim_type=STRING},
{entrez_id=STRING},
{hgnc=STRING},
{ensembl=STRING}]}'
```
Puoi quindi importare i dati nel tuo negozio come segue.
```
aws omics start-annotation-import-job \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items=source=s3://xquek-dev-aws/annotation-examples/mim2gene.txt \
--destination-name mim2gene \
--format-options=tsvOptions='{readOptions={sep="\t",header=false,comment="#"}}'
```
## Avvio di processi di importazione in formato VCF
Per i file VCF, sono disponibili due input aggiuntivi che ignorano o includono tali parametri come mostrato. `ignoreQualField` `ignoreFilterField`
```
aws omics start-annotation-import-job --destination-name annotation_example\
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items source=s3://demodata/example.garvan.vcf \
--format-options '{ "vcfOptions": {
"ignoreQualField": false,
"ignoreFilterField": false
}
}'
```
È inoltre possibile annullare l'importazione di un archivio di annotazioni, come illustrato. Se l'annullamento ha esito positivo, non riceverai una risposta a questa AWS CLI chiamata. Tuttavia, se l'ID del processo di importazione non viene trovato o il processo di importazione è completato, viene visualizzato un messaggio di errore.
```
aws omics cancel-annotation-import-job --job-id edd7b8ce-xmpl-47e2-bc99-258cac95a508
```
**Nota**
I metadati importano la cronologia dei lavori per **get-annotation-import-job**, **get-variant-import-job**list-annotation-import-jobs****, e **list-variant-import-jobs**vengono eliminati automaticamente dopo due anni. I dati di varianti e annotazioni importati non vengono eliminati automaticamente e rimangono nei tuoi archivi dati.
# Creazione di HealthOmics versioni dell'Annotation Store
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
È possibile creare nuove versioni degli archivi di annotazioni per raccogliere diverse versioni dei database di annotazioni. In questo modo è possibile organizzare i dati delle annotazioni, che vengono aggiornati regolarmente.
Per creare una nuova versione di un archivio di annotazioni esistente, utilizza l'**create-annotation-store-version**API come mostrato nell'esempio seguente.
```
aws omics create-annotation-store-version \
--name my_annotation_store \
--version-name my_version
```
Riceverai la seguente risposta con l'ID della versione dell'Annotation Store, che conferma che è stata creata una nuova versione dell'annotazione.
```
{
"creationTime": "2023-07-21T17:15:49.251040+00:00",
"id": "3b93cdef69d2",
"name": "my_annotation_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/5987565360"
},
"status": "CREATING",
"versionName": "my_version"
}
```
Per aggiornare la descrizione di una versione dell'archivio di annotazioni, puoi utilizzare **update-annotation-store-version**per aggiungere aggiornamenti a una versione dell'archivio di annotazioni.
```
aws omics update-annotation-store-version \
--name my_annotation_store \
--version-name my_version \
--description "New Description"
```
Riceverai la seguente risposta, che conferma che la versione dell'annotation store è stata aggiornata.
```
{
"storeId": "4934045d1c6d",
"id": "2a3f4a44aa7b",
"description":"New Description",
"status": "ACTIVE",
"name": "my_annotation_store",
"versionName": "my_version",
"creation Time": "2023-07-21T17:20:59.380043+00:00",
"updateTime": "2023-07-21T17:26:17.892034+00:00"
}
```
Per visualizzare i dettagli di una versione dell'Annotation Store, usa. **get-annotation-store-version**
```
aws omics get-annotation-store-version --name my_annotation_store --version-name my_version
```
Riceverai una risposta con il nome della versione, lo stato e altri dettagli.
```
{
"storeId": "4934045d1c6d",
"id": "2a3f4a44aa7b",
"status": "ACTIVE",
"versionArn": "arn:aws:omics:us-west-2:555555555555:annotationStore/my_annotation_store/version/my_version",
"name": "my_annotation_store",
"versionName": "my_version",
"creationTime": "2023-07-21T17:15:49.251040+00:00",
"updateTime": "2023-07-21T17:15:56.434223+00:00",
"statusMessage": "",
"versionSizeBytes": 0
}
```
Per visualizzare tutte le versioni di un archivio di annotazioni, è possibile utilizzare **list-annotation-store-versions**, come illustrato nell'esempio seguente.
```
aws omics list-annotation-store-versions --name my_annotation_store
```
Riceverai una risposta con le seguenti informazioni
```
{
"annotationStoreVersions": [
{
"storeId": "4934045d1c6d",
"id": "2a3f4a44aa7b",
"status": "CREATING",
"versionArn": "arn:aws:omics:us-west-2:555555555555:annotationStore/my_annotation_store/version/my_version_2",
"name": "my_annotation_store",
"versionName": "my_version_2",
"creation Time": "2023-07-21T17:20:59.380043+00:00",
"versionSizeBytes": 0
},
{
"storeId": "4934045d1c6d",
"id": "4934045d1c6d",
"status": "ACTIVE",
"versionArn": "arn:aws:omics:us-west-2:555555555555:annotationStore/my_annotation_store/version/my_version_1",
"name": "my_annotation_store",
"versionName": "my_version_1",
"creationTime": "2023-07-21T17:15:49.251040+00:00",
"updateTime": "2023-07-21T17:15:56.434223+00:00",
"statusMessage": "",
"versionSizeBytes": 0
}
}
```
Se non è più necessaria una versione dell'archivio di annotazioni, è possibile utilizzare **delete-annotation-store-versions**per eliminare una versione dell'archivio di annotazioni, come illustrato nell'esempio seguente.
```
aws omics delete-annotation-store-versions --name my_annotation_store --versions my_version
```
Se la versione dello store viene eliminata senza errori, riceverai la seguente risposta.
```
{
"errors": []
}
```
In caso di errori, riceverai una risposta con i dettagli degli errori, come mostrato.
```
{
"errors": [
{
"versionName": "my_version",
"message": "Version with versionName: my_version was not found."
}
]
}
```
Se tenti di eliminare una versione di Annotation Store con un processo di importazione attivo, riceverai una risposta con un errore, come mostrato.
```
{
"errors": [
{
"versionName": "my_version",
"message": "version has an inflight import running"
}
]
}
```
In questo caso, è possibile forzare l'eliminazione della versione dell'annotation store, come mostrato nell'esempio seguente.
```
aws omics delete-annotation-store-versions --name my_annotation_store --versions my_version --force
```
# Eliminazione degli archivi di HealthOmics analisi
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
Quando si elimina una variante o un archivio di annotazioni, il sistema elimina anche tutti i dati importati in quell'archivio e tutti i tag associati.
L'esempio seguente mostra come eliminare un archivio di varianti utilizzando. AWS CLI Se l'azione ha esito positivo, lo stato dell'archivio delle varianti passa a`DELETING`.
```
aws omics delete-variant-store --id
```
L'esempio seguente mostra come eliminare un archivio di annotazioni. Se l'azione ha esito positivo, lo stato dell'archivio di annotazioni passa a. `DELETING` Gli archivi di annotazioni non possono essere eliminati se esiste più di una versione.
```
aws omics delete-annotation-store --id
```
# Interrogazione dei HealthOmics dati di analisi
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
Puoi eseguire query sui tuoi negozi di varianti utilizzando AWS Lake Formation Amazon Athena o Amazon EMR. Prima di eseguire qualsiasi query, completa le procedure di configurazione (descritte nelle sezioni seguenti) per Lake Formation e Amazon Athena.
Per informazioni su Amazon EMR, consulta il [Tutorial: Guida introduttiva ad Amazon](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html) EMR
Per gli store di varianti creati dopo il 26 settembre 2024, HealthOmics partiziona il negozio in base all'ID di esempio. Questo partizionamento significa che HealthOmics utilizza l'ID di esempio per ottimizzare la memorizzazione delle informazioni sulle varianti. Le query che utilizzano informazioni di esempio come filtri restituiranno risultati più rapidamente, poiché la query analizza meno dati.
HealthOmics utilizza esempi IDs come nomi di file di partizione. Prima di importare i dati, controllate se l'ID di esempio contiene dati PHI. In caso affermativo, modificate l'ID del campione prima di importare i dati. Per ulteriori informazioni sui contenuti da includere e da non includere nell'esempio IDs, consulta le linee guida sulla pagina web sulla [conformità AWS HIPAA](https://aws.amazon.com/compliance/hipaa-compliance).
**Topics**
+ [
# Configurazione di Lake Formation per l'uso HealthOmics
](setting-up-lf.md)
+ [
# Configurazione di Athena per le interrogazioni
](analytics-setting-up-athena.md)
+ [
# Esecuzione di interrogazioni sugli store di HealthOmics varianti
](analytics-run-queries.md)
# Configurazione di Lake Formation per l'uso HealthOmics
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
Prima di utilizzare Lake Formation per gestire gli archivi HealthOmics dati, esegui le seguenti procedure di configurazione di Lake Formation.
**Topics**
+ [
## Creazione o verifica degli amministratori di Lake Formation
](#create-lf-admins)
+ [
## Creazione di collegamenti alle risorse utilizzando la console Lake Formation
](#create-resource-links)
+ [
## Configurazione delle autorizzazioni per le condivisioni di risorse AWS RAM
](#configure-lf-permissions)
## Creazione o verifica degli amministratori di Lake Formation
Prima di poter creare un data lake in Lake Formation, devi definire uno o più amministratori.
Gli amministratori sono utenti e ruoli con le autorizzazioni per creare collegamenti alle risorse. Gli amministratori del data lake vengono configurati per account per regione.
**Crea un utente amministratore nella console di Lake Formation**
1. Apri la console AWS Lake Formation: console [Lake Formation](https://console.aws.amazon.com//lakeformation)
1. Se la console visualizza il pannello **Welcome to Lake Formation**, scegli **Inizia**.
Lake Formation ti aggiunge alla tabella degli **amministratori di Data lake**.
1. Altrimenti, dal menu a sinistra, scegli **Ruoli e attività amministrative**.
1. Aggiungi eventuali amministratori aggiuntivi, se necessario.
## Creazione di collegamenti alle risorse utilizzando la console Lake Formation
Per creare una risorsa condivisa su cui gli utenti possano interrogare, i controlli di accesso predefiniti devono essere disabilitati. Per ulteriori informazioni sulla disabilitazione dei controlli di accesso predefiniti, consulta [Modifica delle impostazioni di sicurezza predefinite per il tuo data lake](https://docs.aws.amazon.com/lake-formation/latest/dg/change-settings.html) nella documentazione di Lake Formation. Puoi creare collegamenti alle risorse individualmente o come gruppo, in modo da poter accedere ai dati in Amazon Athena o in altri AWS servizi (come Amazon EMR).
**Creazione di collegamenti alle risorse nella console AWS Lake Formation e condivisione con gli utenti HealthOmics di Analytics**
1. Apri la console AWS Lake Formation: console [Lake Formation](https://console.aws.amazon.com//lakeformation)
1. Nella barra di navigazione principale, scegli **Database**.
1. Nella tabella **Database**, seleziona il database desiderato.
1. Dal menu **Crea**, scegli **Resource link**.
1. Immettete il **nome di un link alla risorsa**. Se prevedi di accedere al database da Athena, inserisci un nome utilizzando solo lettere minuscole (fino a 256 caratteri).
1. Scegli **Create** (Crea).
1. **Il nuovo collegamento alla risorsa è ora elencato in Database.**
### Concedi l'accesso alla risorsa condivisa utilizzando la console Lake Formation
Un amministratore del database Lake Formation può concedere l'accesso alla risorsa condivisa utilizzando la seguente procedura.
1. Apri la console AWS Lake Formation: [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com//lakeformation)
1. Nella barra di navigazione principale, scegli **Database**.
1. Nella pagina **Database**, seleziona il collegamento alla risorsa creato in precedenza.
1. Dal menu **Azioni**, scegli **Concedi all'obiettivo**.
1. Nella pagina **Concedi le autorizzazioni per i dati** sotto **Principali**, scegli **utenti o ruoli IAM**.
1. Dal menu a discesa **Utenti o ruoli IAM**, trova l'utente a cui desideri concedere l'accesso.
1. Successivamente, nella sezione **LF-Tags o nella scheda delle risorse del catalogo**, seleziona l'opzione **Named data** catalog resources.
1. Dal menu a discesa **Tables (opzionale)**, selezionate **Tutte le tabelle** o la tabella creata in precedenza.
1. ****Nella scheda **Autorizzazioni della tabella, in Autorizzazioni** della **tabella scegli Descrivi e seleziona**.****
1. **Quindi, scegli Concedi.**
Per visualizzare le autorizzazioni di Lake Formation, scegli **Autorizzazioni Data lake** dal pannello di navigazione principale. La tabella mostra i database e i link alle risorse disponibili.
## Configurazione delle autorizzazioni per le condivisioni di risorse AWS RAM
Nella console AWS Lake Formation, visualizza le autorizzazioni scegliendo Autorizzazioni **Data lake** nella barra di navigazione principale. Nella pagina delle **autorizzazioni relative ai dati**, puoi visualizzare una tabella che mostra i **tipi di risorse**, i **database** e **ARN** che è correlata a una risorsa condivisa in **RAM** Resource Share. Se devi accettare una condivisione di risorse AWS Resource Access Manager (AWS RAM), ti AWS Lake Formation avvisa nella console.
HealthOmics può accettare implicitamente le condivisioni di AWS RAM risorse durante la creazione del negozio. Per accettare la condivisione di AWS RAM risorse, l'utente o il ruolo IAM che chiama le operazioni `CreateVariantStore` o l'`CreateAnnotationStore`API deve consentire le seguenti azioni:
+ `ram:GetResourceShareInvitations`- Questa azione consente di HealthOmics trovare gli inviti.
+ `ram:AcceptResourceShareInvitation`- Questa azione consente di HealthOmics accettare l'invito utilizzando un token FAS.
Senza queste autorizzazioni, viene visualizzato un errore di autorizzazione durante la creazione del negozio.
Ecco un esempio di politica che include queste azioni. Aggiungi questa policy all'utente o al ruolo IAM che accetta la condivisione di AWS RAM risorse.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"omics:*",
"ram:AcceptResourceShareInvitation",
"ram:GetResourceShareInvitations"
],
"Resource": "*"
}
]
}
```
------
# Configurazione di Athena per le interrogazioni
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
Puoi usare Athena per interrogare varianti e annotazioni. Prima di eseguire qualsiasi interrogazione, esegui le seguenti attività di configurazione:
**Topics**
+ [
## Configurare la posizione dei risultati di una query utilizzando la console Athena
](#configure-athena-query)
+ [
## Configurare un gruppo di lavoro con il motore Athena v3
](#configure-athena-workgroup)
## Configurare la posizione dei risultati di una query utilizzando la console Athena
Per configurare la posizione dei risultati di una query, segui questi passaggi.
1. [Apri la console Athena: Console Athena](https://console.aws.amazon.com//athena)
1. Nella barra di navigazione principale, scegli **Query** editor.
1. Nell'editor di query, scegli la scheda **Impostazioni**, quindi scegli **Gestisci**.
1. Inserisci il prefisso S3 di una posizione per salvare il risultato della query.
## Configurare un gruppo di lavoro con il motore Athena v3
Per configurare un gruppo di lavoro, segui questi passaggi.
1. [Apri la console Athena: Console Athena](https://console.aws.amazon.com//athena)
1. **Nella barra di navigazione principale, scegli **Gruppi di lavoro**, quindi Crea gruppo di lavoro.**
1. Inserisci un nome per il gruppo di lavoro.
1. Seleziona **Athena SQL** come tipo di motore.
1. In **Aggiorna motore di interrogazione**, seleziona **Manuale**.
1. In **Query version engine**, seleziona **Athena versione 3**.
1. Selezionare **Create workgroup (Crea gruppo di lavoro)**.
# Esecuzione di interrogazioni sugli store di HealthOmics varianti
**Importante**
AWS HealthOmics i negozi di varianti e i negozi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
Puoi eseguire query sul tuo negozio di varianti utilizzando Amazon Athena. Tieni presente che le coordinate genomiche negli archivi di varianti e annotazioni sono rappresentate come intervalli semichiusi, semichiusi e semiaperti.
## Esegui una semplice query utilizzando la console Athena
L'esempio seguente mostra come eseguire una query semplice.
1. [Aprire l'editor Athena Query: Athena Query editor](https://console.aws.amazon.com//athena)
1. In **Gruppo di lavoro**, seleziona il gruppo di lavoro creato durante l'installazione.
1. Verifica che l'**origine dati** sia. **AwsDataCatalog**
1. Per **Database**, seleziona il link alle risorse del database che hai creato durante la configurazione di Lake Formation.
1. Copia la seguente query nel **Query Editor** nella scheda **Query 1**:
```
SELECT * from omicsvariants limit 10
```
1. Per eseguire la query, scegli **Esegui**. La console popola la tabella dei risultati con le prime 10 righe della **omicsvariants** tabella.
## Esegui una query complessa utilizzando la console Athena
L'esempio seguente mostra come eseguire una query complessa. Per eseguire questa query, importala `ClinVar` nell'archivio delle annotazioni.
**Esegui un'interrogazione complessa**
1. [Aprire l'editor Athena Query: Athena Query editor](https://console.aws.amazon.com//athena)
1. In **Gruppo di lavoro**, seleziona il gruppo di lavoro creato durante l'installazione.
1. Verifica che l'**origine dati** sia. **AwsDataCatalog**
1. Per **Database**, seleziona il link alle risorse del database che hai creato durante la configurazione di Lake Formation.
1. Scegli l'opzione in alto **\$1** a destra per creare una nuova scheda di interrogazione denominata **Query 2**.
1. Copia la seguente query nel **Query Editor** nella scheda **Query 2**:
```
SELECT variants.sampleid,
variants.contigname,
variants.start,
variants."end",
variants.referenceallele,
variants.alternatealleles,
variants.attributes AS variant_attributes,
clinvar.attributes AS clinvar_attributes
FROM omicsvariants as variants
INNER JOIN omicsannotations as clinvar ON
variants.contigname=CONCAT('chr',clinvar.contigname)
AND variants.start=clinvar.start
AND variants."end"=clinvar."end"
AND variants.referenceallele=clinvar.referenceallele
AND variants.alternatealleles=clinvar.alternatealleles
WHERE clinvar.attributes['CLNSIG']='Likely_pathogenic'
```
1. Scegli **Esegui** per iniziare a eseguire la query.
# Condivisione di archivi HealthOmics di analisi
**Importante**
AWS HealthOmics i negozi di varianti e gli archivi di annotazioni non sono più aperti a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni](variant-store-availability-change.md).
In qualità di proprietario di un negozio di varianti o di un negozio di annotazioni, puoi condividere lo store con altri account AWS. Il proprietario può revocare l'accesso alla risorsa condivisa eliminando la condivisione.
In qualità di abbonato a un negozio condiviso, devi prima accettare la condivisione. Puoi quindi definire flussi di lavoro che utilizzano l'archivio condiviso. I dati vengono visualizzati sotto forma di tabella sia AWS Glue in Lake Formation che in Lake Formation.
Quando non hai più bisogno di accedere allo store, elimini la condivisione.
[Condivisione di risorse tra account in AWS HealthOmics](resource-sharing.md)Per ulteriori informazioni sulla condivisione delle risorse, consulta.
## Creazione di una condivisione in negozio
Per creare una condivisione dello store, utilizza l'operazione API **create-share**. Il sottoscrittore principale è l' Account AWS utente che sottoscriverà la condivisione. L'esempio seguente crea una condivisione per un negozio di varianti. Per condividere un negozio con più di un account, crei più condivisioni dello stesso negozio.
```
aws omics create-share \
--resource-arn "arn:aws:omics:us-west-2:555555555555:variantStore/omics_dev_var_store" \
--principal-subscriber "123456789012" \
--name "my_Share-123"
```
Se la creazione ha esito positivo, riceverai una risposta con l'ID e lo stato della condivisione.
```
{
"shareId": "495c21bedc889d07d0ab69d710a6841e-dd75ab7a1a9c384fa848b5bd8e5a7e0a",
"name": "my_Share-123",
"status": "PENDING"
}
```
La condivisione rimane in sospeso fino a quando il sottoscrittore non la accetta utilizzando l'operazione API accept-share.