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 esempi utilizzando AWS CLI
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS Command Line Interface with HealthOmics.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `abort-multipart-read-set-upload`
Il seguente esempio di codice mostra come utilizzare`abort-multipart-read-set-upload`.
**AWS CLI**
**Come arrestare un caricamento dei set di lettura in più parti**
L'`abort-multipart-read-set-upload`esempio seguente interrompe il caricamento di un set di lettura in più parti nel vostro archivio di HealthOmics sequenze.
```
aws omics abort-multipart-read-set-upload \
--sequence-store-id 0123456789 \
--upload-id 1122334455
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consultate [Caricamento diretto su un archivio di sequenze nella Guida per](https://docs.aws.amazon.com/omics/latest/dev/synchronous-uploads.html) *l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [AbortMultipartReadSetUpload AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/abort-multipart-read-set-upload.html)*Command Reference*.
### `accept-share`
Il seguente esempio di codice mostra come utilizzare`accept-share`.
**AWS CLI**
**Come accettare una condivisione dei dati dell’archivio di analisi**
L'`accept-share`esempio seguente accetta una condivisione di dati dell'archivio di HealthOmics analisi.
```
aws omics accept-share \
----share-id "495c21bedc889d07d0ab69d710a6841e-dd75ab7a1a9c384fa848b5bd8e5a7e0a"
```
Output:
```
{
"status": "ACTIVATING"
}
```
Per ulteriori informazioni, consulta [Condivisione tra account](https://docs.aws.amazon.com/omics/latest/dev/cross-account-sharing.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [AcceptShare AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/accept-share.html)*Command Reference.*
### `batch-delete-read-set`
Il seguente esempio di codice mostra come utilizzare`batch-delete-read-set`.
**AWS CLI**
**Come eliminare più set di lettura**
L’esempio `batch-delete-read-set` seguente elimina due set di lettura.
```
aws omics batch-delete-read-set \
--sequence-store-id 1234567890 \
--ids 1234567890 0123456789
```
Se si verifica un errore durante l’eliminazione di uno dei set di lettura specificati, il servizio restituisce un elenco di errori.
```
{
"errors": [
{
"code": "",
"id": "0123456789",
"message": "The specified readset does not exist."
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [BatchDeleteReadSet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/batch-delete-read-set.html)*Command Reference*.
### `cancel-annotation-import-job`
Il seguente esempio di codice mostra come utilizzare`cancel-annotation-import-job`.
**AWS CLI**
**Come annullare un processo di importazione di annotazioni**
L’esempio `cancel-annotation-import-job` seguente annulla un processo di importazione di annotazioni con ID `04f57618-xmpl-4fd0-9349-e5a85aefb997`.
```
aws omics cancel-annotation-import-job \
--job-id 04f57618-xmpl-4fd0-9349-e5a85aefb997
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [CancelAnnotationImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/cancel-annotation-import-job.html)*Command Reference*.
### `cancel-run`
Il seguente esempio di codice mostra come utilizzare`cancel-run`.
**AWS CLI**
**Come annullare un’esecuzione**
L’esempio `cancel-run` seguente annulla un’esecuzione con ID `1234567`.
```
aws omics cancel-run \
--id 1234567
```
Per ulteriori informazioni, consulta [Esegui il ciclo di vita in un flusso di lavoro nella Guida](https://docs.aws.amazon.com/omics/latest/dev/monitoring-runs.html) per l'*AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [CancelRun](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/cancel-run.html)Reference*.
### `cancel-variant-import-job`
Il seguente esempio di codice mostra come utilizzare`cancel-variant-import-job`.
**AWS CLI**
**Come annullare un processo di importazione di varianti**
L’esempio `cancel-variant-import-job` seguente annulla un processo di importazione di varianti con ID `69cb65d6-xmpl-4a4a-9025-4565794b684e`.
```
aws omics cancel-variant-import-job \
--job-id 69cb65d6-xmpl-4a4a-9025-4565794b684e
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [CancelVariantImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/cancel-variant-import-job.html)*Command Reference*.
### `complete-multipart-read-set-upload`
Il seguente esempio di codice mostra come utilizzare`complete-multipart-read-set-upload`.
**AWS CLI**
**Come concludere un caricamento in più parti una volta caricati tutti i componenti.**
L’esempio `complete-multipart-read-set-upload` seguente conclude un caricamento in più parti in un archivio di sequenze dopo il caricamento di tutti i componenti.
```
aws omics complete-multipart-read-set-upload \
--sequence-store-id 0123456789 \
--upload-id 1122334455 \
--parts '[{"checksum":"gaCBQMe+rpCFZxLpoP6gydBoXaKKDA/Vobh5zBDb4W4=","partNumber":1,"partSource":"SOURCE1"}]'
```
Output:
```
{
"readSetId": "0000000001"
"readSetId": "0000000002"
"readSetId": "0000000003"
}
```
Per ulteriori informazioni, consulta [Caricamento diretto su un archivio di sequenze](https://docs.aws.amazon.com/omics/latest/dev/synchronous-uploads.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [CompleteMultipartReadSetUpload AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/complete-multipart-read-set-upload.html)*Command Reference*.
### `create-annotation-store-version`
Il seguente esempio di codice mostra come utilizzare`create-annotation-store-version`.
**AWS CLI**
**Come creare una nuova versione di un archivio di annotazioni**
L’esempio `create-annotation-store-version` seguente crea una nuova versione di un archivio di annotazioni.
```
aws omics create-annotation-store-version \
--name my_annotation_store \
--version-name my_version
```
Output:
```
{
"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 ulteriori informazioni, vedere [Creazione di nuove versioni di archivi di annotazioni](https://docs.aws.amazon.com/omics/latest/dev/annotation-store-versioning.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [CreateAnnotationStoreVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-annotation-store-version.html)*Command Reference.*
### `create-annotation-store`
Il seguente esempio di codice mostra come utilizzare`create-annotation-store`.
**AWS CLI**
**Esempio 1: come creare un archivio di annotazioni VCF**
L’esempio `create-annotation-store` seguente crea un archivio di annotazioni in formato VCF.
```
aws omics create-annotation-store \
--name my_ann_store \
--store-format VCF \
--reference referenceArn=arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890
```
Output:
```
{
"creationTime": "2022-11-23T22:48:39.226492Z",
"id": "0a91xmplc71f",
"name": "my_ann_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "CREATING",
"storeFormat": "VCF"
}
```
**Esempio 2: come creare un archivio di annotazioni TSV**
L’esempio `create-annotation-store` seguente crea un archivio di annotazioni in formato TSV.
```
aws omics create-annotation-store \
--name tsv_ann_store \
--store-format TSV \
--reference referenceArn=arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890 \
--store-options file://tsv-store-options.json
```
Le opzioni di formato per le annotazioni sono configurate mediante `tsv-store-options.json`.
```
{
"tsvStoreOptions": {
"annotationType": "CHR_START_END_ZERO_BASE",
"formatToHeader": {
"CHR": "chromosome",
"START": "start",
"END": "end"
},
"schema": [
{
"chromosome": "STRING"
},
{
"start": "LONG"
},
{
"end": "LONG"
},
{
"name": "STRING"
}
]
}
}
```
Output:
```
{
"creationTime": "2022-11-30T01:28:08.525586Z",
"id": "861cxmpl96b0",
"name": "tsv_ann_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "CREATING",
"storeFormat": "TSV",
"storeOptions": {
"tsvStoreOptions": {
"annotationType": "CHR_START_END_ZERO_BASE",
"formatToHeader": {
"CHR": "chromosome",
"END": "end",
"START": "start"
},
"schema": [
{
"chromosome": "STRING"
},
{
"start": "LONG"
},
{
"end": "LONG"
},
{
"name": "STRING"
}
]
}
}
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella Guida per gli sviluppatori di Amazon Omics.
+ Per i dettagli sull'API, consulta [CreateAnnotationStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-annotation-store.html)*Command Reference*.
### `create-multipart-read-set-upload`
Il seguente esempio di codice mostra come utilizzare`create-multipart-read-set-upload`.
**AWS CLI**
**Come avviare un caricamento di un set di lettura in più parti.**
L’esempio `create-multipart-read-set-upload` seguente avvia un caricamento di un set di lettura in più parti.
```
aws omics create-multipart-read-set-upload \
--sequence-store-id 0123456789 \
--name HG00146 \
--source-file-type FASTQ \
--subject-id mySubject\
--sample-id mySample\
--description "FASTQ for HG00146"\
--generated-from "1000 Genomes"
```
Output:
```
{
"creationTime": "2022-07-13T23:25:20Z",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes",
"name": "HG00146",
"sampleId": "mySample",
"sequenceStoreId": "0123456789",
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"uploadId": "1122334455"
}
```
Per ulteriori informazioni, consulta [Caricamento diretto su un archivio di sequenze](https://docs.aws.amazon.com/omics/latest/dev/synchronous-uploads.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [CreateMultipartReadSetUpload AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-multipart-read-set-upload.html)*Command Reference*.
### `create-reference-store`
Il seguente esempio di codice mostra come utilizzare`create-reference-store`.
**AWS CLI**
**Come creare un archivio di riferimenti**
L’esempio `create-reference-store` seguente crea un archivio di riferimenti `my-ref-store`.
```
aws omics create-reference-store \
--name my-ref-store
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890",
"creationTime": "2022-11-22T22:13:25.947Z",
"id": "1234567890",
"name": "my-ref-store"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [CreateReferenceStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-reference-store.html)*Command Reference*.
### `create-run-group`
Il seguente esempio di codice mostra come utilizzare`create-run-group`.
**AWS CLI**
**Come creare un gruppo di esecuzione**
L’esempio `create-run-group` seguente crea un gruppo di esecuzione denominato `cram-converter`.
```
aws omics create-run-group \
--name cram-converter \
--max-cpus 20 \
--max-gpus 10 \
--max-duration 600 \
--max-runs 5
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:runGroup/1234567",
"id": "1234567",
"tags": {}
}
```
Per ulteriori informazioni, vedere [Creazione di gruppi di esecuzione](https://docs.aws.amazon.com/omics/latest/dev/creating-run-groups.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [CreateRunGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-run-group.html)*Command Reference*.
### `create-sequence-store`
Il seguente esempio di codice mostra come utilizzare`create-sequence-store`.
**AWS CLI**
**Come creare un archivio di sequenze**
L’esempio `create-sequence-store` seguente crea un archivio di sequenze.
```
aws omics create-sequence-store \
--name my-seq-store
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/1234567890",
"creationTime": "2022-11-23T01:24:33.629Z",
"id": "1234567890",
"name": "my-seq-store"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [CreateSequenceStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-sequence-store.html)*Command Reference*.
### `create-share`
Il seguente esempio di codice mostra come utilizzare`create-share`.
**AWS CLI**
**Per creare una condivisione di un archivio di HealthOmics analisi**
L'`create-share`esempio seguente mostra come creare una condivisione di un negozio di HealthOmics analisi che possa essere accettata da un abbonato esterno all'account.
```
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"
```
Output:
```
{
"shareId": "495c21bedc889d07d0ab69d710a6841e-dd75ab7a1a9c384fa848b5bd8e5a7e0a",
"name": "my_Share-123",
"status": "PENDING"
}
```
*Per ulteriori informazioni, consulta [Condivisione tra account](https://docs.aws.amazon.com/omics/latest/dev/cross-account-sharing.html) nella Guida per l'AWS HealthOmics utente.*
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateShare](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-share.html)Reference*.
### `create-variant-store`
Il seguente esempio di codice mostra come utilizzare`create-variant-store`.
**AWS CLI**
**Come creare un archivio di varianti**
L’esempio `create-variant-store` seguente crea un archivio di varianti denominato `my_var_store`.
```
aws omics create-variant-store \
--name my_var_store \
--reference referenceArn=arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890
```
Output:
```
{
"creationTime": "2022-11-23T22:09:07.534499Z",
"id": "02dexmplcfdd",
"name": "my_var_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "CREATING"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [CreateVariantStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-variant-store.html)*Command Reference*.
### `create-workflow`
Il seguente esempio di codice mostra come utilizzare`create-workflow`.
**AWS CLI**
**Come creare un flusso di lavoro**
L’esempio `create-workflow` seguente crea un flusso di lavoro WDL.
```
aws omics create-workflow \
--name cram-converter \
--engine WDL \
--definition-zip fileb://workflow-crambam.zip \
--parameter-template file://workflow-params.json
```
`workflow-crambam.zip` è un archivio ZIP contenente una definizione del flusso di lavoro. I parametri di runtime per il flusso di lavoro sono definiti in `workflow-params.json`.
```
{
"ref_fasta" : {
"description": "Reference genome fasta file",
"optional": false
},
"ref_fasta_index" : {
"description": "Index of the reference genome fasta file",
"optional": false
},
"ref_dict" : {
"description": "dictionary file for 'ref_fasta'",
"optional": false
},
"input_cram" : {
"description": "The Cram file to convert to BAM",
"optional": false
},
"sample_name" : {
"description": "The name of the input sample, used to name the output BAM",
"optional": false
}
}
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:workflow/1234567",
"id": "1234567",
"status": "CREATING",
"tags": {}
}
```
Per ulteriori informazioni, consulta [Creazione di flussi di lavoro privati](https://docs.aws.amazon.com/omics/latest/dev/workflows-setup.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [CreateWorkflow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/create-workflow.html)*Command Reference.*
### `delete-annotation-store-versions`
Il seguente esempio di codice mostra come utilizzare`delete-annotation-store-versions`.
**AWS CLI**
**Come eliminare una versione dell’archivio di annotazioni**
L’esempio `delete-annotation-store-versions` seguente elimina una versione dell’archivio di annotazioni.
```
aws omics delete-annotation-store-versions \
--name my_annotation_store \
--versions my_version
```
Output:
```
{
"errors": []
}
```
Per ulteriori informazioni, vedere [Creazione di nuove versioni di archivi di annotazioni](https://docs.aws.amazon.com/omics/latest/dev/annotation-store-versioning.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [DeleteAnnotationStoreVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-annotation-store-versions.html)*Command Reference.*
### `delete-annotation-store`
Il seguente esempio di codice mostra come utilizzare`delete-annotation-store`.
**AWS CLI**
**Come eliminare un archivio di annotazioni**
L’esempio `delete-annotation-store` seguente elimina un archivio di annotazioni denominato `my_vcf_store`.
```
aws omics delete-annotation-store \
--name my_vcf_store
```
Output:
```
{
"status": "DELETING"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [DeleteAnnotationStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-annotation-store.html)*Command Reference*.
### `delete-reference-store`
Il seguente esempio di codice mostra come utilizzare`delete-reference-store`.
**AWS CLI**
**Come eliminare un archivio di riferimenti**
L’esempio `delete-reference-store` seguente elimina un archivio di riferimenti con ID `1234567890`.
```
aws omics delete-reference-store \
--id 1234567890
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [DeleteReferenceStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-reference-store.html)*Command Reference*.
### `delete-reference`
Il seguente esempio di codice mostra come utilizzare`delete-reference`.
**AWS CLI**
**Come eliminare un riferimento**
L’esempio `delete-reference` seguente elimina un riferimento.
```
aws omics delete-reference \
--reference-store-id 1234567890 \
--id 1234567890
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [DeleteReference AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-reference.html)*Command Reference*.
### `delete-run-group`
Il seguente esempio di codice mostra come utilizzare`delete-run-group`.
**AWS CLI**
**Come eliminare un gruppo di esecuzione**
L’esempio `delete-run-group` seguente elimina un gruppo di esecuzione con ID `1234567`.
```
aws omics delete-run-group \
--id 1234567
```
Per ulteriori informazioni, vedere [Eliminazione di esecuzioni e gruppi di esecuzioni](https://docs.aws.amazon.com/omics/latest/dev/deleting-workflows-and-runs.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [DeleteRunGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-run-group.html)*Command Reference.*
### `delete-run`
Il seguente esempio di codice mostra come utilizzare`delete-run`.
**AWS CLI**
**Come eliminare un’esecuzione del flusso di lavoro**
L’esempio `delete-run` seguente elimina un’esecuzione con ID `1234567`.
```
aws omics delete-run \
--id 1234567
```
Per ulteriori informazioni, vedere [Eliminazione di esecuzioni e gruppi di esecuzioni](https://docs.aws.amazon.com/omics/latest/dev/deleting-workflows-and-runs.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [DeleteRun AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-run.html)*Command Reference.*
### `delete-sequence-store`
Il seguente esempio di codice mostra come utilizzare`delete-sequence-store`.
**AWS CLI**
**Come eliminare un archivio di sequenze**
L’esempio `delete-sequence-store` seguente elimina un archivio di sequenze con ID `1234567890`.
```
aws omics delete-sequence-store \
--id 1234567890
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [DeleteSequenceStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-sequence-store.html)*Command Reference*.
### `delete-share`
Il seguente esempio di codice mostra come utilizzare`delete-share`.
**AWS CLI**
**Per eliminare una condivisione di dati di HealthOmics analisi**
L’esempio `delete-share` seguente elimina una condivisione di dati di analisi tra più account.
```
aws omics delete-share \
--share-id "495c21bedc889d07d0ab69d710a6841e-dd75ab7a1a9c384fa848b5bd8e5a7e0a"
```
Output:
```
{
"status": "DELETING"
}
```
Per ulteriori informazioni, consulta [Condivisione tra account](https://docs.aws.amazon.com/omics/latest/dev/cross-account-sharing.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [DeleteShare AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-share.html)*Command Reference.*
### `delete-variant-store`
Il seguente esempio di codice mostra come utilizzare`delete-variant-store`.
**AWS CLI**
**Come eliminare un archivio di varianti**
L’esempio `delete-variant-store` seguente elimina un archivio di varianti denominato `my_var_store`.
```
aws omics delete-variant-store \
--name my_var_store
```
Output:
```
{
"status": "DELETING"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [DeleteVariantStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-variant-store.html)*Command Reference*.
### `delete-workflow`
Il seguente esempio di codice mostra come utilizzare`delete-workflow`.
**AWS CLI**
**Come eliminare un flusso di lavoro**
L’esempio `delete-workflow` seguente elimina un flusso di lavoro con ID `1234567`.
```
aws omics delete-workflow \
--id 1234567
```
Per ulteriori informazioni, consulta [Eliminare un flusso di lavoro privato](https://docs.aws.amazon.com/omics/latest/dev/delete-private-workflow.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [DeleteWorkflow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/delete-workflow.html)*Command Reference*.
### `get-annotation-import-job`
Il seguente esempio di codice mostra come utilizzare`get-annotation-import-job`.
**AWS CLI**
**Come visualizzare un processo di importazione di annotazioni**
L’esempio `get-annotation-import-job` seguente ottiene i dettagli relativi a un processo di importazione di annotazioni.
```
aws omics get-annotation-import-job \
--job-id 984162c7-xmpl-4d23-ab47-286f7950bfbf
```
Output:
```
{
"creationTime": "2022-11-30T01:40:11.017746Z",
"destinationName": "tsv_ann_store",
"id": "984162c7-xmpl-4d23-ab47-286f7950bfbf",
"items": [
{
"jobStatus": "COMPLETED",
"source": "s3://omics-artifacts-01d6xmpl4e72dd32/targetedregions.bed.gz"
}
],
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2022-11-30T01:42:39.134009Z"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetAnnotationImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-annotation-import-job.html)*Command Reference*.
### `get-annotation-store-version`
Il seguente esempio di codice mostra come utilizzare`get-annotation-store-version`.
**AWS CLI**
**Come recuperare i metadati per una versione dell’archivio di annotazioni**
L’esempio `get-annotation-store-version` seguente recupera i metadati per la versione dell’archivio di annotazioni richiesto.
```
aws omics get-annotation-store-version \
--name my_annotation_store \
--version-name my_version
```
Output:
```
{
"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 ulteriori informazioni, vedere [Creazione di nuove versioni di archivi di annotazioni](https://docs.aws.amazon.com/omics/latest/dev/annotation-store-versioning.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [GetAnnotationStoreVersion AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-annotation-store-version.html)*Command Reference.*
### `get-annotation-store`
Il seguente esempio di codice mostra come utilizzare`get-annotation-store`.
**AWS CLI**
**Come visualizzare un archivio di annotazioni**
L’esempio `get-annotation-store` seguente ottiene i dettagli relativi a un archivio di annotazioni denominato `my_ann_store`.
```
aws omics get-annotation-store \
--name my_ann_store
```
Output:
```
{
"creationTime": "2022-11-23T22:48:39.226492Z",
"id": "0a91xmplc71f",
"name": "my_ann_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "CREATING",
"storeArn": "arn:aws:omics:us-west-2:123456789012:annotationStore/my_ann_store",
"storeFormat": "VCF",
"storeSizeBytes": 0,
"tags": {}
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetAnnotationStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-annotation-store.html)*Command Reference*.
### `get-read-set-activation-job`
Il seguente esempio di codice mostra come utilizzare`get-read-set-activation-job`.
**AWS CLI**
**Come visualizzare un processo di attivazione di set di lettura**
L’esempio `get-read-set-activation-job` seguente ottiene i dettagli relativi a un processo di attivazione di set di lettura.
```
aws omics get-read-set-activation-job \
--sequence-store-id 1234567890 \
--id 1234567890
```
Output:
```
{
"completionTime": "2022-12-06T22:33:42.828Z",
"creationTime": "2022-12-06T22:32:45.213Z",
"id": "1234567890",
"sequenceStoreId": "1234567890",
"sources": [
{
"readSetId": "1234567890",
"status": "FINISHED",
"statusMessage": "No activation needed as read set is already in ACTIVATING or ACTIVE state."
}
],
"status": "COMPLETED",
"statusMessage": "The job completed successfully."
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReadSetActivationJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-read-set-activation-job.html)*Command Reference*.
### `get-read-set-export-job`
Il seguente esempio di codice mostra come utilizzare`get-read-set-export-job`.
**AWS CLI**
**Come visualizzare un processo di esportazione di set di lettura**
L’esempio `get-read-set-export-job` seguente ottiene i dettagli relativi a un processo di esportazione di set di lettura.
```
aws omics get-read-set-export-job \
--sequence-store-id 1234567890 \
--id 1234567890
```
Output:
```
{
"completionTime": "2022-12-06T22:39:14.491Z",
"creationTime": "2022-12-06T22:37:18.612Z",
"destination": "s3://omics-artifacts-01d6xmpl4e72dd32/read-set-export/",
"id": "1234567890",
"sequenceStoreId": "1234567890",
"status": "COMPLETED",
"statusMessage": "The job is submitted and will start soon."
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReadSetExportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-read-set-export-job.html)*Command Reference*.
### `get-read-set-import-job`
Il seguente esempio di codice mostra come utilizzare`get-read-set-import-job`.
**AWS CLI**
**Come visualizzare un processo di importazione di set di lettura**
L’esempio `get-read-set-import-job` seguente ottiene i dettagli relativi a un processo di importazione di set di lettura.
```
aws omics get-read-set-import-job \
--sequence-store-id 1234567890 \
--id 1234567890
```
Output:
```
{
"creationTime": "2022-11-23T01:36:38.158Z",
"id": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"sequenceStoreId": "1234567890",
"sources": [
{
"name": "HG00100",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890",
"sampleId": "bam-sample",
"sourceFileType": "BAM",
"sourceFiles": {
"source1": "s3://omics-artifacts-01d6xmpl4e72dd32/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam",
"source2": ""
},
"status": "IN_PROGRESS",
"statusMessage": "The source job is currently in progress.",
"subjectId": "bam-subject",
"tags": {
"aws:omics:sampleId": "bam-sample",
"aws:omics:subjectId": "bam-subject"
}
},
{
"name": "HG00146",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890",
"sampleId": "fastq-sample",
"sourceFileType": "FASTQ",
"sourceFiles": {
"source1": "s3://omics-artifacts-01d6xmpl4e72dd32/SRR233106_1.filt.fastq.gz",
"source2": "s3://omics-artifacts-01d6xmpl4e72dd32/SRR233106_2.filt.fastq.gz"
},
"status": "IN_PROGRESS",
"statusMessage": "The source job is currently in progress.",
"subjectId": "fastq-subject",
"tags": {
"aws:omics:sampleId": "fastq-sample",
"aws:omics:subjectId": "fastq-subject"
}
},
{
"name": "HG00096",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890",
"sampleId": "cram-sample",
"sourceFileType": "CRAM",
"sourceFiles": {
"source1": "s3://omics-artifacts-01d6xmpl4e72dd32/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram",
"source2": ""
},
"status": "IN_PROGRESS",
"statusMessage": "The source job is currently in progress.",
"subjectId": "cram-subject",
"tags": {
"aws:omics:sampleId": "cram-sample",
"aws:omics:subjectId": "cram-subject"
}
}
],
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReadSetImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-read-set-import-job.html)*Command Reference*.
### `get-read-set-metadata`
Il seguente esempio di codice mostra come utilizzare`get-read-set-metadata`.
**AWS CLI**
**Come visualizzare un set di lettura**
L’esempio `get-read-set-metadata` seguente ottiene i dettagli relativi ai file di un set di lettura.
```
aws omics get-read-set-metadata \
--sequence-store-id 1234567890 \
--id 1234567890
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/1234567890/readSet/1234567890",
"creationTime": "2022-11-23T21:55:00.515Z",
"fileType": "FASTQ",
"files": {
"source1": {
"contentLength": 310054739,
"partSize": 104857600,
"totalParts": 3
},
"source2": {
"contentLength": 307846621,
"partSize": 104857600,
"totalParts": 3
}
},
"id": "1234567890",
"name": "HG00146",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890",
"sampleId": "fastq-sample",
"sequenceInformation": {
"alignment": "UNALIGNED",
"totalBaseCount": 677717384,
"totalReadCount": 8917334
},
"sequenceStoreId": "1234567890",
"status": "ACTIVE",
"subjectId": "fastq-subject"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReadSetMetadata AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-read-set-metadata.html)*Command Reference*.
### `get-read-set`
Il seguente esempio di codice mostra come utilizzare`get-read-set`.
**AWS CLI**
**Come scaricare un set di lettura**
L’esempio `get-read-set` seguente scarica la parte 3 di un set di lettura come `1234567890.3.bam`.
```
aws omics get-read-set \
--sequence-store-id 1234567890 \
--id 1234567890 \
--part-number 3 1234567890.3.bam
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReadSet AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-read-set.html)*Command Reference*.
### `get-reference-import-job`
Il seguente esempio di codice mostra come utilizzare`get-reference-import-job`.
**AWS CLI**
**Come visualizzare un processo di importazione di riferimenti**
L’esempio `get-reference-import-job` seguente ottiene i dettagli relativi a un processo di importazione di riferimenti.
```
aws omics get-reference-import-job \
--reference-store-id 1234567890 \
--id 1234567890
```
Output:
```
{
"creationTime": "2022-11-22T22:25:41.124Z",
"id": "1234567890",
"referenceStoreId": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"sources": [
{
"name": "assembly-38",
"sourceFile": "s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.fasta",
"status": "IN_PROGRESS",
"statusMessage": "The source job is currently in progress."
}
],
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReferenceImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-reference-import-job.html)*Command Reference*.
### `get-reference-metadata`
Il seguente esempio di codice mostra come utilizzare`get-reference-metadata`.
**AWS CLI**
**Come visualizzare un riferimento**
L’esempio `get-reference-metadata` seguente ottiene i dettagli relativi a un riferimento.
```
aws omics get-reference-metadata \
--reference-store-id 1234567890 \
--id 1234567890
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890",
"creationTime": "2022-11-22T22:27:09.033Z",
"files": {
"index": {
"contentLength": 160928,
"partSize": 104857600,
"totalParts": 1
},
"source": {
"contentLength": 3249912778,
"partSize": 104857600,
"totalParts": 31
}
},
"id": "1234567890",
"md5": "7ff134953dcca8c8997453bbb80b6b5e",
"name": "assembly-38",
"referenceStoreId": "1234567890",
"status": "ACTIVE",
"updateTime": "2022-11-22T22:27:09.033Z"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReferenceMetadata AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-reference-metadata.html)*Command Reference*.
### `get-reference-store`
Il seguente esempio di codice mostra come utilizzare`get-reference-store`.
**AWS CLI**
**Come visualizzare un archivio di riferimenti**
L’esempio `get-reference-store` seguente ottiene i dettagli relativi a un archivio di riferimenti.
```
aws omics get-reference-store \
--id 1234567890
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890",
"creationTime": "2022-09-23T23:27:20.364Z",
"id": "1234567890",
"name": "my-rstore-0"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReferenceStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-reference-store.html)*Command Reference*.
### `get-reference`
Il seguente esempio di codice mostra come utilizzare`get-reference`.
**AWS CLI**
**Come scaricare un riferimento genomico**
L’esempio `get-reference` seguente scarica la parte 1 di un genoma come `hg38.1.fa`.
```
aws omics get-reference \
--reference-store-id 1234567890 \
--id 1234567890 \
--part-number 1 hg38.1.fa
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetReference AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-reference.html)*Command Reference*.
### `get-run-group`
Il seguente esempio di codice mostra come utilizzare`get-run-group`.
**AWS CLI**
**Come visualizzare un gruppo di esecuzione**
L’esempio `get-run-group` seguente ottiene i dettagli relativi a un gruppo di esecuzione.
```
aws omics get-run-group \
--id 1234567
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:runGroup/1234567",
"creationTime": "2022-12-01T00:58:42.915219Z",
"id": "1234567",
"maxCpus": 20,
"maxDuration": 600,
"name": "cram-convert",
"tags": {}
}
```
Per ulteriori informazioni, vedere [Creazione di gruppi di esecuzione](https://docs.aws.amazon.com/omics/latest/dev/creating-run-groups.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [GetRunGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-run-group.html)*Command Reference*.
### `get-run-task`
Il seguente esempio di codice mostra come utilizzare`get-run-task`.
**AWS CLI**
**Come visualizzare un’attività**
L’esempio `get-run-task` seguente ottiene i dettagli relativi a un’attività di un flusso di lavoro.
```
aws omics get-run-task \
--id 1234567 \
--task-id 1234567
```
Output:
```
{
"cpus": 1,
"creationTime": "2022-11-30T23:13:00.718651Z",
"logStream": "arn:aws:logs:us-west-2:123456789012:log-group:/aws/omics/WorkflowLog:log-stream:run/1234567/task/1234567",
"memory": 15,
"name": "CramToBamTask",
"startTime": "2022-11-30T23:17:47.016Z",
"status": "COMPLETED",
"stopTime": "2022-11-30T23:18:21.503Z",
"taskId": "1234567"
}
```
Per ulteriori informazioni, consulta [Task lifecycle in a HealthOmics run nella Guida](https://docs.aws.amazon.com/omics/latest/dev/workflow-run-tasks.html) per l'*AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [GetRunTask](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-run-task.html)Reference*.
### `get-run`
Il seguente esempio di codice mostra come utilizzare`get-run`.
**AWS CLI**
**Come visualizzare un’esecuzione del flusso di lavoro**
L’esempio `get-run` seguente ottiene i dettagli relativi a un’esecuzione del flusso di lavoro.
```
aws omics get-run \
--id 1234567
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:run/1234567",
"creationTime": "2022-11-30T22:58:22.615865Z",
"digest": "sha256:c54bxmpl742dcc26f7fa1f10e37550ddd8f251f418277c0a58e895b801ed28cf",
"id": "1234567",
"name": "cram-to-bam",
"outputUri": "s3://omics-artifacts-01d6xmpl4e72dd32/workflow-output/",
"parameters": {
"ref_dict": "s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.dict",
"ref_fasta_index": "s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.fasta.fai",
"ref_fasta": "s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.fasta",
"sample_name": "NA12878",
"input_cram": "s3://omics-artifacts-01d6xmpl4e72dd32/NA12878.cram"
},
"resourceDigests": {
"s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.fasta.fai": "etag:f76371b113734a56cde236bc0372de0a",
"s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.dict": "etag:3884c62eb0e53fa92459ed9bff133ae6",
"s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.fasta": "etag:e307d81c605fb91b7720a08f00276842-388",
"s3://omics-artifacts-01d6xmpl4e72dd32/NA12878.cram": "etag:a9f52976381286c6143b5cc681671ec6"
},
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"startedBy": "arn:aws:iam::123456789012:user/laptop-2020",
"status": "STARTING",
"tags": {},
"workflowId": "1234567",
"workflowType": "PRIVATE"
}
```
Per ulteriori informazioni, consulta [Esegui il ciclo di vita in un flusso di lavoro nella Guida](https://docs.aws.amazon.com/omics/latest/dev/monitoring-runs.html) per l'*AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [GetRun](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-run.html)Reference*.
### `get-sequence-store`
Il seguente esempio di codice mostra come utilizzare`get-sequence-store`.
**AWS CLI**
**Come visualizzare un archivio di sequenze**
L’esempio `get-sequence-store` seguente ottiene i dettagli relativi a un archivio di sequenze con ID `1234567890`.
```
aws omics get-sequence-store \
--id 1234567890
```
Output:
```
{
"arn": "arn:aws:omics:us-east-1:123456789012:sequenceStore/1234567890",
"creationTime": "2022-11-23T19:55:48.376Z",
"id": "1234567890",
"name": "my-seq-store"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetSequenceStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-sequence-store.html)*Command Reference*.
### `get-share`
Il seguente esempio di codice mostra come utilizzare`get-share`.
**AWS CLI**
**Per recuperare i metadati relativi a una condivisione di dati di analisi HealthOmics **
L’esempio `get-share` seguente recupera i metadati relativi a una condivisione di dati di analisi tra più account.
```
aws omics get-share \
--share-id "495c21bedc889d07d0ab69d710a6841e-dd75ab7a1a9c384fa848b5bd8e5a7e0a"
```
Output:
```
{
"share": {
"shareId": "495c21bedc889d07d0ab69d710a6841e-dd75ab7a1a9c384fa848b5bd8e5a7e0a",
"name": "my_Share-123",
"resourceArn": "arn:aws:omics:us-west-2:555555555555:variantStore/omics_dev_var_store",
"principalSubscriber": "123456789012",
"ownerId": "555555555555",
"status": "PENDING"
}
}
```
*Per ulteriori informazioni, consulta [Condivisione tra account](https://docs.aws.amazon.com/omics/latest/dev/cross-account-sharing.html) nella Guida per l'AWS HealthOmics utente.*
+ Per i dettagli sull'API, consulta [GetShare AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-share.html)*Command Reference.*
### `get-variant-import-job`
Il seguente esempio di codice mostra come utilizzare`get-variant-import-job`.
**AWS CLI**
**Come visualizzare un processo di importazione di varianti**
L’esempio `get-variant-import-job` seguente ottiene i dettagli relativi a un processo di importazione di varianti.
```
aws omics get-variant-import-job \
--job-id edd7b8ce-xmpl-47e2-bc99-258cac95a508
```
Output:
```
{
"creationTime": "2022-11-23T22:42:50.037812Z",
"destinationName": "my_var_store",
"id": "edd7b8ce-xmpl-47e2-bc99-258cac95a508",
"items": [
{
"jobStatus": "IN_PROGRESS",
"source": "s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.known_indels.vcf.gz"
}
],
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"runLeftNormalization": false,
"status": "IN_PROGRESS",
"updateTime": "2022-11-23T22:43:05.898309Z"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetVariantImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-variant-import-job.html)*Command Reference*.
### `get-variant-store`
Il seguente esempio di codice mostra come utilizzare`get-variant-store`.
**AWS CLI**
**Come visualizzare un archivio di varianti**
L’esempio `get-variant-store` seguente ottiene i dettagli relativi a un archivio di varianti.
```
aws omics get-variant-store \
--name my_var_store
```
Output:
```
{
"creationTime": "2022-11-23T22:09:07.534499Z",
"id": "02dexmplcfdd",
"name": "my_var_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "CREATING",
"storeArn": "arn:aws:omics:us-west-2:123456789012:variantStore/my_var_store",
"storeSizeBytes": 0,
"tags": {},
"updateTime": "2022-11-23T22:09:24.931711Z"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [GetVariantStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-variant-store.html)*Command Reference*.
### `get-workflow`
Il seguente esempio di codice mostra come utilizzare`get-workflow`.
**AWS CLI**
**Come visualizzare un flusso di lavoro**
L’esempio `get-workflow` seguente ottiene i dettagli relativi a un flusso di lavoro con ID `1234567`.
```
aws omics get-workflow \
--id 1234567
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:workflow/1234567",
"creationTime": "2022-11-30T22:33:16.225368Z",
"digest": "sha256:c54bxmpl742dcc26f7fa1f10e37550ddd8f251f418277c0a58e895b801ed28cf",
"engine": "WDL",
"id": "1234567",
"main": "workflow-crambam.wdl",
"name": "cram-converter",
"parameterTemplate": {
"ref_dict": {
"description": "dictionary file for 'ref_fasta'"
},
"ref_fasta_index": {
"description": "Index of the reference genome fasta file"
},
"ref_fasta": {
"description": "Reference genome fasta file"
},
"input_cram": {
"description": "The Cram file to convert to BAM"
},
"sample_name": {
"description": "The name of the input sample, used to name the output BAM"
}
},
"status": "ACTIVE",
"statusMessage": "workflow-crambam.wdl\n workflow CramToBamFlow\n call CramToBamTask\n call ValidateSamFile\n task CramToBamTask\n task ValidateSamFile\n",
"tags": {},
"type": "PRIVATE"
}
```
Per ulteriori informazioni, consulta [Creazione di flussi di lavoro privati](https://docs.aws.amazon.com/omics/latest/dev/workflows-setup.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [GetWorkflow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/get-workflow.html)*Command Reference.*
### `list-annotation-import-jobs`
Il seguente esempio di codice mostra come utilizzare`list-annotation-import-jobs`.
**AWS CLI**
**Come ottenere un elenco di processi di importazione di annotazioni**
L’esempio `list-annotation-import-jobs` seguente ottiene un elenco di processi di importazione di annotazioni.
```
aws omics list-annotation-import-jobs
```
Output:
```
{
"annotationImportJobs": [
{
"creationTime": "2022-11-30T01:39:41.478294Z",
"destinationName": "gff_ann_store",
"id": "18a9e792-xmpl-4869-a105-e5b602900444",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2022-11-30T01:47:09.145178Z"
},
{
"creationTime": "2022-11-30T00:45:58.007838Z",
"destinationName": "my_ann_store",
"id": "4e9eafc8-xmpl-431e-a0b2-3bda27cb600a",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"runLeftNormalization": false,
"status": "FAILED",
"updateTime": "2022-11-30T00:47:01.706325Z"
}
]
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListAnnotationImportJobs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-annotation-import-jobs.html)*Command Reference*.
### `list-annotation-store-versions`
Il seguente esempio di codice mostra come utilizzare`list-annotation-store-versions`.
**AWS CLI**
**Come elencare tutte le versioni di un archivio di annotazioni.**
L’esempio `list-annotation-store-versions` seguente elenca tutte le versioni esistenti di un archivio di annotazioni.
```
aws omics list-annotation-store-versions \
--name my_annotation_store
```
Output:
```
{
"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
}
}
```
Per ulteriori informazioni, vedere [Creazione di nuove versioni di archivi di annotazioni](https://docs.aws.amazon.com/omics/latest/dev/annotation-store-versioning.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [ListAnnotationStoreVersions AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-annotation-store-versions.html)*Command Reference.*
### `list-annotation-stores`
Il seguente esempio di codice mostra come utilizzare`list-annotation-stores`.
**AWS CLI**
**Come ottenere un elenco di archivi di annotazioni**
L’esempio `list-annotation-stores` seguente ottiene un elenco di archivi di annotazioni.
```
aws omics list-annotation-stores
```
Output:
```
{
"annotationStores": [
{
"creationTime": "2022-11-23T22:48:39.226492Z",
"id": "0a91xmplc71f",
"name": "my_ann_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "ACTIVE",
"statusMessage": "",
"storeArn": "arn:aws:omics:us-west-2:123456789012:annotationStore/my_ann_store",
"storeFormat": "VCF",
"storeSizeBytes": 0,
"updateTime": "2022-11-23T22:53:27.372840Z"
}
]
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListAnnotationStores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-annotation-stores.html)*Command Reference*.
### `list-multipart-read-set-uploads`
Il seguente esempio di codice mostra come utilizzare`list-multipart-read-set-uploads`.
**AWS CLI**
**Come elencare tutti i caricamenti di set di lettura in più parti e i relativi stati.**
L’esempio `list-multipart-read-set-uploads` seguente elenca tutti i caricamenti di set di lettura in più parti e i relativi stati.
```
aws omics list-multipart-read-set-uploads \
--sequence-store-id 0123456789
```
Output:
```
{
"uploads":
[
{
"sequenceStoreId": "0123456789",
"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": "0123456789",
"uploadId": "5290538638",
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"referenceArn": "arn:aws:omics:us-west-2:845448930428:referenceStore/8168613728/reference/2190697383",
"name": "HG00146",
"description": "BAM for HG00146",
"creationTime": "2023-11-29T19:23:33.116516+00:00"
},
{
"sequenceStoreId": "0123456789",
"uploadId": "4174220862",
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"referenceArn": "arn:aws:omics:us-west-2:845448930428:referenceStore/8168613728/reference/2190697383",
"name": "HG00147",
"description": "BAM for HG00147",
"creationTime": "2023-11-29T19:23:47.007866+00:00"
}
]
}
```
Per ulteriori informazioni, consulta [Caricamento diretto su un archivio di sequenze](https://docs.aws.amazon.com/omics/latest/dev/synchronous-uploads.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [ListMultipartReadSetUploads AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-multipart-read-set-uploads.html)*Command Reference*.
### `list-read-set-activation-jobs`
Il seguente esempio di codice mostra come utilizzare`list-read-set-activation-jobs`.
**AWS CLI**
**Come ottenere un elenco di processi di attivazione di set di lettura**
L’esempio `list-read-set-activation-jobs` seguente ottiene un elenco di processi di attivazione per un archivio di sequenze con ID `1234567890`.
```
aws omics list-read-set-activation-jobs \
--sequence-store-id 1234567890
```
Output:
```
{
"activationJobs": [
{
"completionTime": "2022-12-06T22:33:42.828Z",
"creationTime": "2022-12-06T22:32:45.213Z",
"id": "1234567890",
"sequenceStoreId": "1234567890",
"status": "COMPLETED"
},
{
"creationTime": "2022-12-06T22:35:10.100Z",
"id": "1234567890",
"sequenceStoreId": "1234567890",
"status": "IN_PROGRESS"
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListReadSetActivationJobs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-read-set-activation-jobs.html)*Command Reference*.
### `list-read-set-export-jobs`
Il seguente esempio di codice mostra come utilizzare`list-read-set-export-jobs`.
**AWS CLI**
**Come ottenere un elenco di processi di esportazione di set di lettura**
L’esempio `list-read-set-export-jobs` seguente ottiene un elenco di processi di esportazione per un archivio di sequenze con ID `1234567890`.
```
aws omics list-read-set-export-jobs \
--sequence-store-id 1234567890
```
Output:
```
{
"exportJobs": [
{
"completionTime": "2022-12-06T22:39:14.491Z",
"creationTime": "2022-12-06T22:37:18.612Z",
"destination": "s3://omics-artifacts-01d6xmpl4e72dd32/read-set-export/",
"id": "1234567890",
"sequenceStoreId": "1234567890",
"status": "COMPLETED"
},
{
"creationTime": "2022-12-06T22:38:04.871Z",
"destination": "s3://omics-artifacts-01d6xmpl4e72dd32/read-set-export/",
"id": "1234567890",
"sequenceStoreId": "1234567890",
"status": "IN_PROGRESS"
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListReadSetExportJobs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-read-set-export-jobs.html)*Command Reference*.
### `list-read-set-import-jobs`
Il seguente esempio di codice mostra come utilizzare`list-read-set-import-jobs`.
**AWS CLI**
**Come ottenere un elenco di processi di importazione di set di lettura**
L’esempio `list-read-set-import-jobs` seguente ottiene un elenco di processi di importazione per un archivio di sequenze con ID `1234567890`.
```
aws omics list-read-set-import-jobs \
--sequence-store-id 1234567890
```
Output:
```
{
"importJobs": [
{
"completionTime": "2022-11-29T18:17:49.244Z",
"creationTime": "2022-11-29T17:32:47.700Z",
"id": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"sequenceStoreId": "1234567890",
"status": "COMPLETED"
},
{
"completionTime": "2022-11-23T22:01:34.090Z",
"creationTime": "2022-11-23T21:52:43.289Z",
"id": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"sequenceStoreId": "1234567890",
"status": "COMPLETED_WITH_FAILURES"
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListReadSetImportJobs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-read-set-import-jobs.html)*Command Reference*.
### `list-read-set-upload-parts`
Il seguente esempio di codice mostra come utilizzare`list-read-set-upload-parts`.
**AWS CLI**
**Come elencare tutte le parti in un processo di caricamento in più parti richiesto per un archivio di sequenze.**
L’esempio `list-read-set-upload-parts` seguente elenca tutte le parti in un processo di caricamento in più parti richiesto per un archivio di sequenze.
```
aws omics list-read-set-upload-parts \
--sequence-store-id 0123456789 \
--upload-id 1122334455 \
--part-source SOURCE1
```
Output:
```
{
"parts": [
{
"partNumber": 1,
"partSize": 94371840,
"file": "SOURCE1",
"checksum": "984979b9928ae8d8622286c4a9cd8e99d964a22d59ed0f5722e1733eb280e635",
"lastUpdatedTime": "2023-02-02T20:14:47.533000+00:00"
}
{
"partNumber": 2,
"partSize": 10471840,
"file": "SOURCE1",
"checksum": "984979b9928ae8d8622286c4a9cd8e99d964a22d59ed0f5722e1733eb280e635",
"lastUpdatedTime": "2023-02-02T20:14:47.533000+00:00"
}
]
}
```
Per ulteriori informazioni, consulta [Caricamento diretto su un archivio di sequenze](https://docs.aws.amazon.com/omics/latest/dev/synchronous-uploads.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [ListReadSetUploadParts AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-read-set-upload-parts.html)*Command Reference*.
### `list-read-sets`
Il seguente esempio di codice mostra come utilizzare`list-read-sets`.
**AWS CLI**
**Come ottenere un elenco di set di lettura**
L’esempio `list-read-sets` seguente ottiene un elenco di set di lettura per un archivio di sequenze con ID `1234567890`.
```
aws omics list-read-sets \
--sequence-store-id 1234567890
```
Output:
```
{
"readSets": [
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/1234567890/readSet/1234567890",
"creationTime": "2022-11-23T21:55:00.515Z",
"fileType": "FASTQ",
"id": "1234567890",
"name": "HG00146",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890",
"sampleId": "fastq-sample",
"sequenceStoreId": "1234567890",
"status": "ACTIVE",
"subjectId": "fastq-subject"
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListReadSets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-read-sets.html)*Command Reference*.
### `list-reference-import-jobs`
Il seguente esempio di codice mostra come utilizzare`list-reference-import-jobs`.
**AWS CLI**
**Come ottenere un elenco di processi di importazione di riferimenti**
L’esempio `list-reference-import-jobs` seguente ottiene un elenco di processi di importazione di riferimenti per un archivio di riferimenti con ID `1234567890`.
```
aws omics list-reference-import-jobs \
--reference-store-id 1234567890
```
Output:
```
{
"importJobs": [
{
"completionTime": "2022-11-23T19:54:58.204Z",
"creationTime": "2022-11-23T19:53:20.729Z",
"id": "1234567890",
"referenceStoreId": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"status": "COMPLETED"
},
{
"creationTime": "2022-11-23T20:34:03.250Z",
"id": "1234567890",
"referenceStoreId": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"status": "IN_PROGRESS"
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListReferenceImportJobs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-reference-import-jobs.html)*Command Reference*.
### `list-reference-stores`
Il seguente esempio di codice mostra come utilizzare`list-reference-stores`.
**AWS CLI**
**Come ottenere un elenco di archivi di riferimenti**
L’esempio `list-reference-stores` seguente ottiene un elenco di archivi di riferimenti.
```
aws omics list-reference-stores
```
Output:
```
{
"referenceStores": [
{
"arn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890",
"creationTime": "2022-11-22T22:13:25.947Z",
"id": "1234567890",
"name": "my-ref-store"
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListReferenceStores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-reference-stores.html)*Command Reference*.
### `list-references`
Il seguente esempio di codice mostra come utilizzare`list-references`.
**AWS CLI**
**Come ottenere un elenco di riferimenti**
L’esempio `list-references` seguente ottiene un elenco di riferimenti genomici a per un archivio di riferimenti con ID `1234567890`.
```
aws omics list-references \
--reference-store-id 1234567890
```
Output:
```
{
"references": [
{
"arn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890",
"creationTime": "2022-11-22T22:27:09.033Z",
"id": "1234567890",
"md5": "7ff134953dcca8c8997453bbb80b6b5e",
"name": "assembly-38",
"referenceStoreId": "1234567890",
"status": "ACTIVE",
"updateTime": "2022-11-22T22:27:09.033Z"
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListReferences AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-references.html)*Command Reference*.
### `list-run-groups`
Il seguente esempio di codice mostra come utilizzare`list-run-groups`.
**AWS CLI**
**Come ottenere un elenco di gruppi di esecuzione**
L’esempio `list-run-groups` seguente ottiene un elenco di gruppi di esecuzione.
```
aws omics list-run-groups
```
Output:
```
{
"items": [
{
"arn": "arn:aws:omics:us-west-2:123456789012:runGroup/1234567",
"creationTime": "2022-12-01T00:58:42.915219Z",
"id": "1234567",
"maxCpus": 20,
"maxDuration": 600,
"name": "cram-convert"
}
]
}
```
Per ulteriori informazioni, vedere [Creazione di gruppi di esecuzione](https://docs.aws.amazon.com/omics/latest/dev/creating-run-groups.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [ListRunGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-run-groups.html)*Command Reference*.
### `list-run-tasks`
Il seguente esempio di codice mostra come utilizzare`list-run-tasks`.
**AWS CLI**
**Come ottenere un elenco di attività**
L’esempio `list-run-tasks` seguente ottiene un elenco di attività per un’esecuzione del flusso di lavoro.
```
aws omics list-run-tasks \
--id 1234567
```
Output:
```
{
"items": [
{
"cpus": 1,
"creationTime": "2022-11-30T23:13:00.718651Z",
"memory": 15,
"name": "CramToBamTask",
"startTime": "2022-11-30T23:17:47.016Z",
"status": "COMPLETED",
"stopTime": "2022-11-30T23:18:21.503Z",
"taskId": "1234567"
},
{
"cpus": 1,
"creationTime": "2022-11-30T23:18:32.315606Z",
"memory": 4,
"name": "ValidateSamFile",
"startTime": "2022-11-30T23:23:40.165Z",
"status": "COMPLETED",
"stopTime": "2022-11-30T23:24:14.766Z",
"taskId": "1234567"
}
]
}
```
Per ulteriori informazioni, consulta [Task lifecycle in a HealthOmics run nella Guida](https://docs.aws.amazon.com/omics/latest/dev/workflow-run-tasks.html) per l'*AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ListRunTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-run-tasks.html)Reference*.
### `list-runs`
Il seguente esempio di codice mostra come utilizzare`list-runs`.
**AWS CLI**
**Come ottenere un elenco di esecuzioni del flusso di lavoro**
L’esempio `list-runs` seguente ottiene un elenco di esecuzioni del flusso di lavoro.
```
aws omics list-runs
```
Output:
```
{
"items": [
{
"arn": "arn:aws:omics:us-west-2:123456789012:run/1234567",
"creationTime": "2022-12-02T23:20:01.202074Z",
"id": "1234567",
"name": "cram-to-bam",
"priority": 1,
"startTime": "2022-12-02T23:29:18.115Z",
"status": "COMPLETED",
"stopTime": "2022-12-02T23:57:54.428812Z",
"storageCapacity": 10,
"workflowId": "1234567"
},
{
"arn": "arn:aws:omics:us-west-2:123456789012:run/1234567",
"creationTime": "2022-12-03T00:16:57.180066Z",
"id": "1234567",
"name": "cram-to-bam",
"priority": 1,
"startTime": "2022-12-03T00:26:50.233Z",
"status": "FAILED",
"stopTime": "2022-12-03T00:37:21.451340Z",
"storageCapacity": 10,
"workflowId": "1234567"
},
{
"arn": "arn:aws:omics:us-west-2:123456789012:run/1234567",
"creationTime": "2022-12-05T17:57:08.444817Z",
"id": "1234567",
"name": "cram-to-bam",
"status": "STARTING",
"workflowId": "1234567"
}
]
}
```
Per ulteriori informazioni, consulta [Esegui il ciclo di vita in un flusso di lavoro nella Guida](https://docs.aws.amazon.com/omics/latest/dev/monitoring-runs.html) per l'*AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [ListRuns](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-runs.html)Reference*.
### `list-sequence-stores`
Il seguente esempio di codice mostra come utilizzare`list-sequence-stores`.
**AWS CLI**
**Come ottenere un elenco di archivi di sequenze**
L’esempio `list-sequence-stores` seguente ottiene un elenco di archivi di sequenze.
```
aws omics list-sequence-stores
```
Output:
```
{
"sequenceStores": [
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/1234567890",
"creationTime": "2022-11-23T01:24:33.629Z",
"id": "1234567890",
"name": "my-seq-store"
}
]
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListSequenceStores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-sequence-stores.html)*Command Reference*.
### `list-shares`
Il seguente esempio di codice mostra come utilizzare`list-shares`.
**AWS CLI**
**Per elencare le condivisioni disponibili di un dato di HealthOmics analisi**
L’esempio `list-shares` seguente elenca tutte le condivisioni che sono state create per il proprietario di una risorsa.
```
aws omics list-shares \
--resource-owner SELF
```
Output:
```
{
"shares": [
{
"shareId": "595c1cbd-a008-4eca-a887-954d30c91c6e",
"name": "myShare",
"resourceArn": "arn:aws:omics:us-west-2:555555555555:variantStore/store_1",
"principalSubscriber": "123456789012",
"ownerId": "555555555555",
"status": "PENDING"
}
{
"shareId": "39b65d0d-4368-4a19-9814-b0e31d73c10a",
"name": "myShare3456",
"resourceArn": "arn:aws:omics:us-west-2:555555555555:variantStore/store_2",
"principalSubscriber": "123456789012",
"ownerId": "555555555555",
"status": "ACTIVE"
},
{
"shareId": "203152f5-eef9-459d-a4e0-a691668d44ef",
"name": "myShare4",
"resourceArn": "arn:aws:omics:us-west-2:555555555555:variantStore/store_3",
"principalSubscriber": "123456789012",
"ownerId": "555555555555",
"status": "ACTIVE"
}
]
}
```
Per ulteriori informazioni, consulta [Condivisione tra account](https://docs.aws.amazon.com/omics/latest/dev/cross-account-sharing.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [ListShares AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-shares.html)*Command Reference.*
### `list-tags-for-resource`
Il seguente esempio di codice mostra come utilizzare`list-tags-for-resource`.
**AWS CLI**
**Come ottenere un elenco di tag**
L’esempio `list-tags-for-resource` seguente ottiene un elenco di tag per un flusso di lavoro con ID `1234567`.
```
aws omics list-tags-for-resource \
--resource-arn arn:aws:omics:us-west-2:123456789012:workflow/1234567
```
Output:
```
{
"tags": {
"department": "analytics"
}
}
```
Per ulteriori informazioni, consulta [Tagging di risorse in Amazon Omics](https://docs.aws.amazon.com/omics/latest/dev/workflows.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListTagsForResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-tags-for-resource.html)*Command Reference*.
### `list-variant-import-jobs`
Il seguente esempio di codice mostra come utilizzare`list-variant-import-jobs`.
**AWS CLI**
**Come ottenere un elenco di processi di importazione di varianti**
L’esempio `list-variant-import-jobs` seguente ottiene un elenco di processi di importazione di varianti.
```
aws omics list-variant-import-jobs
```
Output:
```
{
"variantImportJobs": [
{
"creationTime": "2022-11-23T22:47:02.514002Z",
"destinationName": "my_var_store",
"id": "69cb65d6-xmpl-4a4a-9025-4565794b684e",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2022-11-23T22:49:17.976597Z"
},
{
"creationTime": "2022-11-23T22:42:50.037812Z",
"destinationName": "my_var_store",
"id": "edd7b8ce-xmpl-47e2-bc99-258cac95a508",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2022-11-23T22:45:26.009880Z"
}
]
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListVariantImportJobs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-variant-import-jobs.html)*Command Reference*.
### `list-variant-stores`
Il seguente esempio di codice mostra come utilizzare`list-variant-stores`.
**AWS CLI**
**Come ottenere un elenco di archivi di varianti**
L’esempio `list-variant-stores` seguente ottiene un elenco di archivi di varianti.
```
aws omics list-variant-stores
```
Output:
```
{
"variantStores": [
{
"creationTime": "2022-11-23T22:09:07.534499Z",
"id": "02dexmplcfdd",
"name": "my_var_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "CREATING",
"storeArn": "arn:aws:omics:us-west-2:123456789012:variantStore/my_var_store",
"storeSizeBytes": 0,
"updateTime": "2022-11-23T22:09:24.931711Z"
},
{
"creationTime": "2022-09-23T23:00:09.140265Z",
"id": "8777xmpl1a24",
"name": "myvstore0",
"status": "ACTIVE",
"storeArn": "arn:aws:omics:us-west-2:123456789012:variantStore/myvstore0",
"storeSizeBytes": 0,
"updateTime": "2022-09-23T23:03:26.013220Z"
}
]
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [ListVariantStores AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-variant-stores.html)*Command Reference*.
### `list-workflows`
Il seguente esempio di codice mostra come utilizzare`list-workflows`.
**AWS CLI**
**Come ottenere un elenco di flussi di lavoro**
L’esempio `list-workflows` seguente ottiene un elenco di flussi di lavoro.
```
aws omics list-workflows
```
Output:
```
{
"items": [
{
"arn": "arn:aws:omics:us-west-2:123456789012:workflow/1234567",
"creationTime": "2022-09-23T23:08:22.041227Z",
"digest": "nSCNo/qMWFxmplXpUdokXJnwgneOaxyyc2YOxVxrJTE=",
"id": "1234567",
"name": "my-wkflow-0",
"status": "ACTIVE",
"type": "PRIVATE"
},
{
"arn": "arn:aws:omics:us-west-2:123456789012:workflow/1234567",
"creationTime": "2022-11-30T22:33:16.225368Z",
"digest": "sha256:c54bxmpl742dcc26f7fa1f10e37550ddd8f251f418277c0a58e895b801ed28cf",
"id": "1234567",
"name": "cram-converter",
"status": "ACTIVE",
"type": "PRIVATE"
}
]
}
```
Per ulteriori informazioni, consulta [Creazione di flussi di lavoro privati](https://docs.aws.amazon.com/omics/latest/dev/workflows-setup.html) nella *Guida per l'AWS HealthOmics utente*.
+ Per i dettagli sull'API, consulta [ListWorkflows AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/list-workflows.html)*Command Reference.*
### `start-annotation-import-job`
Il seguente esempio di codice mostra come utilizzare`start-annotation-import-job`.
**AWS CLI**
**Come importare annotazioni**
L’esempio `start-annotation-import-job` seguente importa le annotazioni da Amazon S3.
```
aws omics start-annotation-import-job \
--destination-name tsv_ann_store \
--no-run-left-normalization \
--role-arn arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ \
--items source=s3://omics-artifacts-01d6xmpl4e72dd32/targetedregions.bed.gz
```
Output:
```
{
"jobId": "984162c7-xmpl-4d23-ab47-286f7950bfbf"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [StartAnnotationImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/start-annotation-import-job.html)*Command Reference*.
### `start-read-set-activation-job`
Il seguente esempio di codice mostra come utilizzare`start-read-set-activation-job`.
**AWS CLI**
**Come attivare un set di lettura archiviato**
L’esempio `start-read-set-activation-job` seguente attiva due set di lettura.
```
aws omics start-read-set-activation-job \
--sequence-store-id 1234567890 \
--sources readSetId=1234567890 readSetId=1234567890
```
Output:
```
{
"creationTime": "2022-12-06T22:35:10.100Z",
"id": "1234567890",
"sequenceStoreId": "1234567890",
"status": "SUBMITTED"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [StartReadSetActivationJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/start-read-set-activation-job.html)*Command Reference*.
### `start-read-set-export-job`
Il seguente esempio di codice mostra come utilizzare`start-read-set-export-job`.
**AWS CLI**
**Come esportare un set di lettura**
L’esempio `start-read-set-export-job` seguente esporta due set di lettura in Amazon S3.
```
aws omics start-read-set-export-job \
--sequence-store-id 1234567890 \
--sources readSetId=1234567890 readSetId=1234567890 \
--role-arn arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ
\
--destination s3://omics-artifacts-01d6xmpl4e72dd32/read-set-export/
```
Output:
```
{
"creationTime": "2022-12-06T22:37:18.612Z",
"destination": "s3://omics-artifacts-01d6xmpl4e72dd32/read-set-export/",
"id": "1234567890",
"sequenceStoreId": "1234567890",
"status": "SUBMITTED"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [StartReadSetExportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/start-read-set-export-job.html)*Command Reference*.
### `start-read-set-import-job`
Il seguente esempio di codice mostra come utilizzare`start-read-set-import-job`.
**AWS CLI**
**Come importare un set di lettura**
L’esempio `start-read-set-import-job` seguente importa un set di lettura.
```
aws omics start-read-set-import-job \
--sequence-store-id 1234567890 \
--role-arn arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ \
--sources file://readset-sources.json
```
readset-sources.json è un documento JSON con il seguente contenuto.
```
[
{
"sourceFiles":
{
"source1": "s3://omics-artifacts-01d6xmpl4e72dd32/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"subjectId": "bam-subject",
"sampleId": "bam-sample",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890",
"name": "HG00100"
}
]
```
Output:
```
{
"creationTime": "2022-11-23T01:36:38.158Z",
"id": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"sequenceStoreId": "1234567890",
"status": "SUBMITTED"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [StartReadSetImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/start-read-set-import-job.html)*Command Reference*.
### `start-reference-import-job`
Il seguente esempio di codice mostra come utilizzare`start-reference-import-job`.
**AWS CLI**
**Come importare un genoma di riferimento**
L’esempio `start-reference-import-job` seguente importa un genoma di riferimento da Amazon S3.
```
aws omics start-reference-import-job \
--reference-store-id 1234567890 \
--role-arn arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ \
--sources sourceFile=s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.fasta,name=assembly-38
```
Output:
```
{
"creationTime": "2022-11-22T22:25:41.124Z",
"id": "1234567890",
"referenceStoreId": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ",
"status": "SUBMITTED"
}
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/sequence-stores.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [StartReferenceImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/start-reference-import-job.html)*Command Reference*.
### `start-run`
Il seguente esempio di codice mostra come utilizzare`start-run`.
**AWS CLI**
**Come eseguire un flusso di lavoro**
L’esempio `start-run` seguente esegue un flusso di lavoro con ID `1234567`.
```
aws omics start-run \
--workflow-id 1234567 \
--role-arn arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ \
--name 'cram-to-bam' \
--output-uri s3://omics-artifacts-01d6xmpl4e72dd32/workflow-output/ \
--run-group-id 1234567 \
--priority 1 \
--storage-capacity 10 \
--log-level ALL \
--parameters file://workflow-inputs.json
```
workflow-inputs.json è un documento JSON con il seguente contenuto.
```
{
"sample_name": "NA12878",
"input_cram": "s3://omics-artifacts-01d6xmpl4e72dd32/NA12878.cram",
"ref_dict": "s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.dict",
"ref_fasta": "s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.fasta",
"ref_fasta_index": "omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.fasta.fai"
}
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:run/1234567",
"id": "1234567",
"status": "PENDING",
"tags": {}
}
```
Per ulteriori informazioni, vedere [Avvio di una corsa](https://docs.aws.amazon.com/omics/latest/dev/starting-a-run.html) nella *Guida AWS HealthOmics per l'utente*.
**Come caricare file di origine da Amazon Omics**
Puoi anche caricare file sorgente dallo storage Amazon Omics, utilizzando servizi URIs specifici. Il seguente file workflow-inputs.json di esempio utilizza Amazon URIs Omics per i set di lettura e le fonti genomiche di riferimento.
```
{
"sample_name": "NA12878",
"input_cram": "omics://123456789012.storage.us-west-2.amazonaws.com/1234567890/readSet/1234567890/source1",
"ref_dict": "s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.dict",
"ref_fasta": "omics://123456789012.storage.us-west-2.amazonaws.com/1234567890/reference/1234567890",
"ref_fasta_index": "omics://123456789012.storage.us-west-2.amazonaws.com/1234567890/reference/1234567890/index"
}
```
+ *Per i dettagli sull'API, consulta Command Reference. [StartRun](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/start-run.html)AWS CLI *
### `start-variant-import-job`
Il seguente esempio di codice mostra come utilizzare`start-variant-import-job`.
**AWS CLI**
**Come importare un file di varianti**
L’esempio `start-variant-import-job` seguente importa un file di varianti in formato VCF.
```
aws omics start-variant-import-job \
--destination-name my_var_store \
--no-run-left-normalization \
--role-arn arn:aws:iam::123456789012:role/omics-service-role-serviceRole-W8O1XMPL7QZ \
--items source=s3://omics-artifacts-01d6xmpl4e72dd32/Homo_sapiens_assembly38.known_indels.vcf.gz
```
Output:
```
{
"jobId": "edd7b8ce-xmpl-47e2-bc99-258cac95a508"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [StartVariantImportJob AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/start-variant-import-job.html)*Command Reference*.
### `tag-resource`
Il seguente esempio di codice mostra come utilizzare`tag-resource`.
**AWS CLI**
**Come taggare a una risorsa**
L’esempio `tag-resource` seguente aggiunge un tag `department` a un flusso di lavoro con ID `1234567`.
```
aws omics tag-resource \
--resource-arn arn:aws:omics:us-west-2:123456789012:workflow/1234567 \
--tags department=analytics
```
Per ulteriori informazioni, consulta [Tagging di risorse in Amazon Omics](https://docs.aws.amazon.com/omics/latest/dev/workflows.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [TagResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/tag-resource.html)*Command Reference*.
### `untag-resource`
Il seguente esempio di codice mostra come utilizzare`untag-resource`.
**AWS CLI**
**Come rimuovere un tag da una risorsa**
L’esempio `untag-resource` seguente rimuove il tag `department` da un flusso di lavoro.
```
aws omics untag-resource \
--resource-arn arn:aws:omics:us-west-2:123456789012:workflow/1234567 \
--tag-keys department
```
Per ulteriori informazioni, consulta [Archiviazione Omics](https://docs.aws.amazon.com/omics/latest/dev/tagging.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [UntagResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/untag-resource.html)*Command Reference*.
### `update-annotation-store`
Il seguente esempio di codice mostra come utilizzare`update-annotation-store`.
**AWS CLI**
**Come aggiornare un archivio di annotazioni**
L’esempio `update-annotation-store` seguente aggiorna la descrizione di un archivio di annotazioni denominato `my_vcf_store`.
```
aws omics update-annotation-store \
--name my_vcf_store \
--description "VCF annotation store"
```
Output:
```
{
"creationTime": "2022-12-05T18:00:56.101860Z",
"description": "VCF annotation store",
"id": "bd6axmpl2444",
"name": "my_vcf_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "ACTIVE",
"storeFormat": "VCF",
"updateTime": "2022-12-05T18:13:16.100051Z"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [UpdateAnnotationStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/update-annotation-store.html)*Command Reference*.
### `update-run-group`
Il seguente esempio di codice mostra come utilizzare`update-run-group`.
**AWS CLI**
**Come aggiornare un gruppo di esecuzione**
L’esempio `update-run-group` seguente aggiorna le impostazioni di un gruppo di esecuzione con ID `1234567`.
```
aws omics update-run-group \
--id 1234567 \
--max-cpus 10
```
Output:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:runGroup/1234567",
"creationTime": "2022-12-01T00:58:42.915219Z",
"id": "1234567",
"maxCpus": 10,
"maxDuration": 600,
"name": "cram-convert",
"tags": {}
}
```
Per ulteriori informazioni, consulta [Flussi di lavoro Omics](https://docs.aws.amazon.com/omics/latest/dev/workflows.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [UpdateRunGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/update-run-group.html)*Command Reference*.
### `update-variant-store`
Il seguente esempio di codice mostra come utilizzare`update-variant-store`.
**AWS CLI**
**Come aggiornare un archivio di varianti**
L’esempio `update-variant-store` seguente aggiorna la descrizione di un archivio di varianti denominato `my_var_store`.
```
aws omics update-variant-store \
--name my_var_store \
--description "variant store"
```
Output:
```
{
"creationTime": "2022-11-23T22:09:07.534499Z",
"description": "variant store",
"id": "02dexmplcfdd",
"name": "my_var_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/1234567890/reference/1234567890"
},
"status": "ACTIVE",
"updateTime": "2022-12-05T18:23:37.686402Z"
}
```
Per ulteriori informazioni, consulta [Omics Analytics](https://docs.aws.amazon.com/omics/latest/dev/omics-analytics.html) nella *Guida per gli sviluppatori di Amazon Omics*.
+ Per i dettagli sull'API, consulta [UpdateVariantStore AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/update-variant-store.html)*Command Reference*.
### `update-workflow`
Il seguente esempio di codice mostra come utilizzare`update-workflow`.
**AWS CLI**
**Come aggiornare un flusso di lavoro**
L’esempio `1234567` seguente aggiorna la descrizione di un flusso di lavoro con ID `update-workflow`.
```
aws omics update-workflow \
--id 1234567 \
--description "copy workflow"
```
Per ulteriori informazioni, vedere [Creazione o aggiornamento di un flusso di lavoro](https://docs.aws.amazon.com/omics/latest/dev/creating-private-workflows.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [UpdateWorkflow AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/update-workflow.html)*Command Reference*.
### `upload-read-set-part`
Il seguente esempio di codice mostra come utilizzare`upload-read-set-part`.
**AWS CLI**
**Come caricare una parte di un set di lettura.**
L’esempio `upload-read-set-part` seguente carica una parte specificata di un set di lettura.
```
aws omics upload-read-set-part \
--sequence-store-id 0123456789 \
--upload-id 1122334455 \
--part-source SOURCE1 \
--part-number 1 \
--payload /path/to/file/read_1_part_1.fastq.gz
```
Output:
```
{
"checksum": "984979b9928ae8d8622286c4a9cd8e99d964a22d59ed0f5722e1733eb280e635"
}
```
Per ulteriori informazioni, consulta [Caricamento diretto su un archivio di sequenze](https://docs.aws.amazon.com/omics/latest/dev/synchronous-uploads.html) nella *Guida AWS HealthOmics per l'utente*.
+ Per i dettagli sull'API, consulta [UploadReadSetPart AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/omics/upload-read-set-part.html)*Command Reference*.