As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# HealthOmics análises
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
HealthOmics a análise suporta o armazenamento e a análise de variantes e anotações genômicas. O Analytics fornece dois tipos de recursos de armazenamento: lojas de variantes e lojas de anotações. Você usa esses recursos para armazenar, transformar e consultar dados de variantes genômicas e dados de anotação. Depois de importar dados para um armazenamento de dados, você pode usar o Athena para realizar análises avançadas sobre os dados.
Você pode usar o HealthOmics console ou a API para criar e gerenciar lojas, importar dados e compartilhar dados analíticos da loja com colaboradores.
A variante armazena dados de suporte em formatos VCF, e a anotação armazena suporte TSV/CSV e formatos. GFF3 As coordenadas genômicas são representadas como intervalos semiabertos semicerrados baseados em zero. Quando seus dados estão no armazenamento de dados HealthOmics analíticos, o acesso aos arquivos VCF é gerenciado por meio AWS Lake Formation de. Em seguida, você pode consultar os arquivos VCF usando o Amazon Athena. As consultas devem usar o mecanismo de consulta Athena versão 3. Para ler mais sobre as versões do mecanismo de consulta do Athena, consulte a documentação do [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/engine-versions-changing.html).
**Topics**
+ [Criação de lojas HealthOmics variantes](creating-variant-stores.md)
+ [Criação de trabalhos de importação de lojas HealthOmics variantes](parsing-annotation-stores.md)
+ [Criação de HealthOmics lojas de anotações](creating-and-managing-annotation-store.md)
+ [Criação de trabalhos de importação para lojas de HealthOmics anotações](annotation-store-import-jobs.md)
+ [Criação de HealthOmics versões de armazenamento de anotações](annotation-store-versioning.md)
+ [Excluindo lojas de HealthOmics análise](deleting-a-store-examples.md)
+ [Consultando HealthOmics dados analíticos](analytics-query-data.md)
+ [Compartilhamento HealthOmics de lojas de análise](cross-account-sharing.md)
# Criação de lojas HealthOmics variantes
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Os tópicos a seguir descrevem como criar armazenamentos de HealthOmics variantes usando o console e a API.
**Topics**
+ [Criação de um armazenamento de variantes usando o console](#gs-console-analytics)
+ [Criação de um armazenamento de variantes usando a API](#gs-api-analytics)
## Criação de um armazenamento de variantes usando o console
Você pode criar um armazenamento de variantes usando o HealthOmics console.
1. Abra o [console de HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **lojas Variant**.
1. Na página **Criar loja de variantes**, forneça as seguintes informações
+ **Nome da loja variante**: um nome exclusivo para essa loja.
+ **Descrição** (opcional) - Uma descrição desse armazenamento de variantes.
+ **Genoma de referência** - O genoma de referência para esse armazenamento de variantes.
+ **Criptografia de dados** - Escolha se você deseja que a criptografia de dados seja de propriedade e gerenciada por você AWS ou por você mesmo.
+ **Tags** (opcional) - forneça até 50 tags para esse armazenamento de variantes.
1. Escolha **Criar loja de variantes**.
## Criação de um armazenamento de variantes usando a API
Use a operação de HealthOmics `CreateVariantStore` API para criar lojas de variantes. Você também pode realizar essa operação com AWS CLI o.
Para criar uma loja de variantes, você fornece um nome para a loja e o ARN de uma loja de referência. O armazenamento de variantes está pronto para ingerir dados quando seu status muda para PRONTO.
O exemplo a seguir usa o AWS CLI para criar um armazenamento de variantes.
```
aws omics create-variant-store --name myvariantstore \
--reference referenceArn="arn:aws:omics:us-west-2:555555555555:referenceStore/123456789/reference/5987565360"
```
Para confirmar a criação do seu armazenamento de variantes, você recebe a seguinte resposta.
```
{
"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"
}
```
Para saber mais sobre um armazenamento de variantes, use a **get-variant-store**API.
```
aws omics get-variant-store --name myvariantstore
```
Você recebe a seguinte resposta.
```
{
"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
}
```
Para ver todos os armazenamentos de variantes associados a uma conta, use a **list-variant-stores**API.
```
aws omics list-variant-stores
```
Você recebe uma resposta que lista todos os armazenamentos de variantes IDs, junto com seus status e outros detalhes, conforme mostrado no exemplo de resposta a seguir.
```
{
"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
}
]
}
```
Você também pode filtrar as respostas da **list-variant-stores**API com base em status ou outros critérios.
Os arquivos VCF importados para repositórios analíticos criados em ou após 15 de maio de 2023 definiram esquemas para anotações do Variant Effect Predictor (VEP). Isso facilita a consulta e a análise de dados VCF importados. A alteração não afeta as lojas criadas antes de 15 de maio de 2023, exceto se o `annotation fields` parâmetro estiver incluído na chamada da API ou da CLI. Para esses armazenamentos, o uso do `annotation fields` parâmetro fará com que a solicitação falhe.
# Criação de trabalhos de importação de lojas HealthOmics variantes
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
O exemplo a seguir mostra como usar o AWS CLI para criar um trabalho de importação para um armazenamento de variantes.
```
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"}
]
}
```
Para lojas criadas após 15 de maio de 2023, o exemplo a seguir mostra como adicionar o `--annotation-fields` parâmetro. Os campos de anotação são definidos com a importação.
```
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"
}
```
Use **get-variant-import-job**para verificar o status.
```
aws omics get-variant-import-job --job-id 08279950-a9e3-4cc3-9a3c-a574f9c9e229
```
Você receberá uma resposta JSON que mostra o status do seu trabalho de importação. As anotações VEP no VCF são analisadas em busca de informações armazenadas na coluna INFO como um par. ID/Value O ID padrão da coluna INFO de anotações do [Ensembl Variant Effect Predictor](https://useast.ensembl.org/info/docs/tools/vep/index.html/#vcf) é CSQ, mas você pode usar o `--annotation-fields` parâmetro para indicar um valor personalizado usado na coluna INFO. Atualmente, a análise é suportada para anotações VEP.
Para uma loja criada antes de 15 de maio de 2023 ou para arquivos VCF que não incluem a anotação VEP, a resposta não inclui nenhum campo de anotação.
```
{
"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",
}
```
As anotações VEP que fazem parte dos arquivos VCF são armazenadas como um esquema predefinido com a estrutura a seguir. O campo extras pode ser usado para armazenar quaisquer campos VEP adicionais que não estejam incluídos no esquema padrão.
```
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
>>
>
```
A análise é executada com a abordagem de melhor esforço. Se a entrada do VEP não seguir as [especificações padrão do VEP](https://useast.ensembl.org/info/docs/tools/vep/vep_formats.html#vcf), ela não será analisada e a linha na matriz ficará vazia.
Para um novo armazenamento de variantes, a resposta para **get-variant-import-job**incluiria os campos de anotação, conforme mostrado.
```
aws omics get-variant-import-job --job-id 08279950-a9e3-4cc3-9a3c-a574f9c9e229
```
Você recebe uma resposta JSON que mostra o status do seu trabalho de importação.
```
{
"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"}
}
}
```
Você pode usar **list-variant-import-jobs**para ver todos os trabalhos de importação e seus status.
```
aws omics list-variant-import-jobs --ids 7a1c67e3-b7f9-434d-817b-9c571fd63bea
```
A resposta contém as informações a seguir.
```
{
"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 necessário, você pode cancelar um trabalho de importação com o comando a seguir.
```
aws omics cancel-variant-import-job
--job-id edd7b8ce-xmpl-47e2-bc99-258cac95a508
```
# Criação de HealthOmics lojas de anotações
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Um armazenamento de anotações é um armazenamento de dados que representa um banco de dados de anotações, como um de um arquivo TSV, VCF ou GFF. Se o mesmo genoma de referência for especificado, os armazenamentos de anotações serão mapeados para o mesmo sistema de coordenadas dos armazenamentos de variantes durante uma importação. Os tópicos a seguir mostram como usar o HealthOmics console e AWS CLI criar e gerenciar repositórios de anotações.
**Topics**
+ [Criando um repositório de anotações usando o console](#gs-console-create-annotation-store)
+ [Criação de um armazenamento de anotações usando a API](#create-manage-annotation-store-api)
## Criando um repositório de anotações usando o console
Use o procedimento a seguir para criar repositórios de anotações com o HealthOmics console.
**Para criar um repositório de anotações**
1. Abra o [console do HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **Lojas de anotações.**
1. Na página **Armazenamentos de anotações**, escolha **Criar repositório de anotações**.
1. Na página **Criar repositório de anotações**, forneça as seguintes informações
+ **Nome da loja de anotações** - Um nome exclusivo para essa loja.
+ **Descrição** (opcional) - Uma descrição desse genoma de referência.
+ **Formato de dados e detalhes do esquema** - Selecione o formato do arquivo de dados e faça o upload da definição do esquema para essa loja.
+ **Genoma de referência** - O genoma de referência para esta anotação.
+ **Criptografia de dados** - Escolha se você deseja que a criptografia de dados seja de propriedade e gerenciada por você AWS ou por você mesmo.
+ **Tags** (opcional) - forneça até 50 tags para esse repositório de anotações.
1. Escolha **Criar repositório de anotações.**
## Criação de um armazenamento de anotações usando a API
O exemplo a seguir mostra como criar um armazenamento de anotações usando o. AWS CLI Para todas as operações AWS CLI e de API, você deve especificar o formato dos seus dados.
```
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
```
Você recebe a seguinte resposta para confirmar a criação do seu repositório de anotações.
```
{
"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"
}
```
Para saber mais sobre um armazenamento de anotações, use a **get-annotation-store**API.
```
aws omics get-annotation-store --name my_annotation_store
```
Você recebe a seguinte resposta.
```
{
"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
}
```
Para ver todos os repositórios de anotações associados a uma conta, use a operação da **list-annotation-stores**API.
```
aws omics list-annotation-stores
```
Você recebe uma resposta que lista todos os repositórios de anotações, junto com seus IDs status e outros detalhes, conforme mostrado no exemplo de resposta a seguir.
```
{
"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"
}
]
}
```
Você também pode filtrar as respostas com base no status ou em outros critérios.
# Criação de trabalhos de importação para lojas de HealthOmics anotações
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
**Topics**
+ [Criação de um trabalho de importação de anotações usando a API](#create-annotation-import-api)
+ [Parâmetros adicionais para formatos TSV e VCF](#annotation-import-tsv-vcf)
+ [Criação de armazenamentos de anotações formatados em TSV](#annotation-import-tsv-vcftsv-annotation-store-examples-tsv)
+ [Iniciando trabalhos de importação formatados em VCF](#vcf-annotation-store-examples)
## Criação de um trabalho de importação de anotações usando a API
O exemplo a seguir mostra como usar o AWS CLI para iniciar um trabalho de importação de anotações.
```
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"}'
```
Os repositórios de anotações criados antes de 15 de maio de 2023 retornarão uma mensagem de erro se os campos de **anotação** forem incluídos. Eles não retornam a saída de nenhuma operação de API envolvida com trabalhos de importação do armazenamento de anotações.
Em seguida, você pode usar a operação da **get-annotation-import-job**API e o `job ID` parâmetro para saber mais detalhes sobre o trabalho de importação de anotações.
```
aws omics get-annotation-import-job --job-id 9e4198fb-fa85-446c-9301-9b823a1a8ba8
```
Você recebe a seguinte resposta, incluindo os campos de anotação.
```
{
"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"}
}
```
Para ver todos os trabalhos de importação do repositório de anotações, use. **list-annotation-import-jobs**
```
aws omics list-annotation-import-jobs --ids 9e4198fb-fa85-446c-9301-9b823a1a8ba8
```
A resposta inclui os detalhes e os status dos trabalhos de importação da loja de anotações.
```
{
"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"}
}
]
}
```
## Parâmetros adicionais para formatos TSV e VCF
Para os formatos TSV e VCF, há parâmetros adicionais que informam a API sobre como analisar sua entrada.
**Importante**
Os dados de anotação CSV exportados com mecanismos de consulta retornam diretamente as informações da importação do conjunto de dados. Se os dados importados contiverem fórmulas ou comandos, o arquivo poderá estar sujeito à injeção de CSV. Portanto, arquivos exportados com mecanismos de consulta podem solicitar avisos de segurança. Para evitar atividades maliciosas, desative links e macros ao ler arquivos de exportação.
O analisador TSV também realiza operações básicas de bioinformática, como normalização à esquerda e padronização das coordenadas genômicas, listadas na tabela a seguir.
| Tipo de formato | Description |
| --- | --- |
| Genérico | Arquivo de texto genérico. Sem informações genômicas. |
| CHR\$1POS | Posição inicial - 1, Adicione a posição final, que é igual POS a. |
| CHR\$1POS\$1REF\$1ALT | Contém informações de contagem, posição de 1 base, alelos ref e alt. |
| CHR\$1START\$1END\$1REF\$1ALT\$1ONE\$1BASE | Contém informações dos alelos contig, start, end, ref e alt. As coordenadas são baseadas em 1. |
| CHR\$1START\$1END\$1ZERO\$1BASE | Contém as posições inicial, inicial e final. As coordenadas são baseadas em 0. |
| CHR\$1START\$1END\$1ONE\$1BASE | Contém as posições inicial, inicial e final. As coordenadas são baseadas em 1. |
| CHR\$1START\$1END\$1REF\$1ALT\$1ZERO\$1BASE | Contém informações dos alelos contig, start, end, ref e alt. As coordenadas são baseadas em 0. |
Uma solicitação de armazenamento de anotações de importação de TSV se parece com o exemplo a seguir.
```
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"
}
}
}'
```
## Criação de armazenamentos de anotações formatados em TSV
O exemplo a seguir cria um armazenamento de anotações usando um arquivo limitado por abas que contém um cabeçalho, linhas e comentários. As coordenadas são `CHR_START_END_ONE_BASED` e contêm o mapa HG19 genético da [Sinopse do Mapa do Gene Humano do 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}]}'
```
Você pode importar arquivos com ou sem cabeçalho. Para indicar isso em uma solicitação de CLI, use`header=false`, conforme mostrado no exemplo de tarefa de importação a seguir.
```
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="#"}}'
```
O exemplo a seguir cria um armazenamento de anotações para um arquivo de cama. Um arquivo bed é um arquivo simples delimitado por tabulações. Neste exemplo, as colunas são cromossomo, início, fim e nome da região. As coordenadas são baseadas em zero e os dados não têm um cabeçalho.
```
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}]}'
```
Em seguida, você pode importar o arquivo bed para o armazenamento de anotações usando o seguinte comando da 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="#"}}'
```
O exemplo a seguir cria um armazenamento de anotações para um arquivo delimitado por abas que contém as primeiras colunas de um arquivo VCF, seguidas por colunas com informações de anotação. Ele contém as posições do genoma com informações sobre o cromossomo, alelos iniciais, de referência e alternativos, e contém um cabeçalho.
```
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}]}'
```
Em seguida, você importaria o arquivo para o armazenamento de anotações usando o seguinte comando da 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="#"}}'
```
O exemplo a seguir mostra como um cliente pode criar um repositório de anotações para um arquivo mim2gene. Um arquivo mim2gene fornece os links entre os genes no OMIM e outro identificador de gene. É delimitado por abas e contém comentários.
```
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}]}'
```
Em seguida, você pode importar dados para sua loja da seguinte maneira.
```
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="#"}}'
```
## Iniciando trabalhos de importação formatados em VCF
Para arquivos VCF, há duas entradas adicionais `ignoreQualField` e`ignoreFilterField`, que ignoram ou incluem esses parâmetros, conforme mostrado.
```
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
}
}'
```
Você também pode cancelar a importação de um repositório de anotações, conforme mostrado. Se o cancelamento for bem-sucedido, você não receberá uma resposta para essa AWS CLI chamada. No entanto, se o ID do trabalho de importação não for encontrado ou o trabalho de importação for concluído, você receberá uma mensagem de erro.
```
aws omics cancel-annotation-import-job --job-id edd7b8ce-xmpl-47e2-bc99-258cac95a508
```
**nota**
Seus metadados importam o histórico de trabalhos para **get-annotation-import-job**, **get-variant-import-job**list-annotation-import-jobs****, e **list-variant-import-jobs**são excluídos automaticamente após dois anos. Os dados da variante e da anotação importados não são excluídos automaticamente e permanecem nos seus armazenamentos de dados.
# Criação de HealthOmics versões de armazenamento de anotações
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Você pode criar novas versões de repositórios de anotações para coletar diferentes versões de seus bancos de dados de anotações. Isso ajuda você a organizar seus dados de anotação, que são atualizados regularmente.
Para criar uma nova versão de um repositório de anotações existente, use a **create-annotation-store-version**API conforme mostrado no exemplo a seguir.
```
aws omics create-annotation-store-version \
--name my_annotation_store \
--version-name my_version
```
Você receberá a seguinte resposta com o ID da versão do armazenamento de anotações, confirmando que uma nova versão da sua anotação foi criada.
```
{
"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"
}
```
Para atualizar a descrição de uma versão do armazenamento de anotações, você pode usar **update-annotation-store-version**para adicionar atualizações a uma versão do armazenamento de anotações.
```
aws omics update-annotation-store-version \
--name my_annotation_store \
--version-name my_version \
--description "New Description"
```
Você receberá a seguinte resposta, confirmando que a versão do armazenamento de anotações foi atualizada.
```
{
"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"
}
```
Para ver os detalhes de uma versão do armazenamento de anotações, use. **get-annotation-store-version**
```
aws omics get-annotation-store-version --name my_annotation_store --version-name my_version
```
Você receberá uma resposta com o nome da versão, status e outros detalhes.
```
{
"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
}
```
Para visualizar todas as versões de um repositório de anotações, você pode usar **list-annotation-store-versions**, conforme mostrado no exemplo a seguir.
```
aws omics list-annotation-store-versions --name my_annotation_store
```
Você receberá uma resposta com as seguintes informações
```
{
"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 você não precisar mais de uma versão do armazenamento de anotações, poderá usá-la **delete-annotation-store-versions**para excluir uma versão do armazenamento de anotações, conforme mostrado no exemplo a seguir.
```
aws omics delete-annotation-store-versions --name my_annotation_store --versions my_version
```
Se a versão da loja for excluída sem erros, você receberá a seguinte resposta.
```
{
"errors": []
}
```
Se houver erros, você receberá uma resposta com os detalhes dos erros, conforme mostrado.
```
{
"errors": [
{
"versionName": "my_version",
"message": "Version with versionName: my_version was not found."
}
]
}
```
Se você tentar excluir uma versão do armazenamento de anotações que tenha um trabalho de importação ativo, você receberá uma resposta com um erro, conforme mostrado.
```
{
"errors": [
{
"versionName": "my_version",
"message": "version has an inflight import running"
}
]
}
```
Nesse caso, você pode forçar a exclusão da versão do armazenamento de anotações, conforme mostrado no exemplo a seguir.
```
aws omics delete-annotation-store-versions --name my_annotation_store --versions my_version --force
```
# Excluindo lojas de HealthOmics análise
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Quando você exclui uma variante ou um repositório de anotações, o sistema também exclui todos os dados importados nesse armazenamento e todas as tags associadas.
O exemplo a seguir mostra como excluir um armazenamento de variantes usando AWS CLI o. Se a ação for bem-sucedida, o status do armazenamento de variantes mudará para`DELETING`.
```
aws omics delete-variant-store --id
```
O exemplo a seguir mostra como excluir um repositório de anotações. Se a ação for bem-sucedida, o status do armazenamento de anotações mudará para. `DELETING` Os repositórios de anotações não podem ser excluídos se houver mais de uma versão.
```
aws omics delete-annotation-store --id
```
# Consultando HealthOmics dados analíticos
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Você pode realizar consultas em seus armazenamentos de variantes usando o AWS Lake Formation Amazon Athena ou o Amazon EMR. Antes de executar qualquer consulta, conclua os procedimentos de configuração (descritos nas seções a seguir) para Lake Formation e Amazon Athena.
Para obter informações sobre o Amazon EMR, consulte [Tutorial: Introdução ao Amazon](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html) EMR
Para lojas de variantes criadas após 26 de setembro de 2024, HealthOmics particiona a loja por ID de amostra. Esse particionamento significa que HealthOmics usa o ID de amostra para otimizar o armazenamento das informações da variante. As consultas que usam informações de amostra como filtros retornarão os resultados mais rapidamente, pois a consulta digitaliza menos dados.
HealthOmics usa amostra IDs como nomes de arquivo de partição. Antes de ingerir dados, verifique se o ID da amostra contém dados de PHI. Se isso acontecer, altere a ID da amostra antes de ingerir os dados. Para obter mais informações sobre qual conteúdo incluir e não incluir na amostra IDs, consulte as orientações na página da web de [conformidade com a AWS HIPAA](https://aws.amazon.com/compliance/hipaa-compliance).
**Topics**
+ [Configurando o Lake Formation para usar HealthOmics](setting-up-lf.md)
+ [Configurando o Athena para consultas](analytics-setting-up-athena.md)
+ [Executando consultas em lojas de HealthOmics variantes](analytics-run-queries.md)
# Configurando o Lake Formation para usar HealthOmics
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Antes de usar o Lake Formation para gerenciar armazenamentos de HealthOmics dados, execute os seguintes procedimentos de configuração do Lake Formation.
**Topics**
+ [Criando ou verificando administradores do Lake Formation](#create-lf-admins)
+ [Criação de links de recursos usando o console Lake Formation](#create-resource-links)
+ [Configurando permissões para compartilhamentos AWS RAM de recursos](#configure-lf-permissions)
## Criando ou verificando administradores do Lake Formation
Antes de criar um data lake no Lake Formation, você define um ou mais administradores.
Os administradores são usuários e funções com permissões para criar links de recursos. Você configura administradores de data lake por conta por região.
**Crie um usuário administrador no console do Lake Formation**
1. Abra o console do AWS Lake Formation: console [do Lake Formation](https://console.aws.amazon.com//lakeformation)
1. Se o console exibir o painel **Welcome to Lake Formation**, escolha **Começar**.
O Lake Formation adiciona você à tabela de **administradores do Data Lake**.
1. Caso contrário, no menu à esquerda, escolha **Funções e tarefas administrativas**.
1. Adicione outros administradores conforme necessário.
## Criação de links de recursos usando o console Lake Formation
Para criar um recurso compartilhado que os usuários possam consultar, os controles de acesso padrão devem estar desativados. Para saber mais sobre como desativar os controles de acesso padrão, consulte [Alteração das configurações de segurança padrão do seu data lake](https://docs.aws.amazon.com/lake-formation/latest/dg/change-settings.html) na documentação do Lake Formation. Você pode criar links de recursos individualmente ou em grupo, para poder acessar dados no Amazon Athena ou em outros AWS serviços (como o Amazon EMR).
**Criar links de recursos no console do AWS Lake Formation e compartilhá-los com os usuários do HealthOmics Analytics**
1. Abra o console do AWS Lake Formation: console [do Lake Formation](https://console.aws.amazon.com//lakeformation)
1. Na barra de navegação principal, escolha **Bancos de dados**.
1. Na tabela **Bancos de dados**, selecione o banco de dados desejado.
1. No menu **Criar**, escolha **Link do recurso**.
1. Insira o **nome do link do recurso**. Se você planeja acessar o banco de dados a partir do Athena, insira um nome usando somente letras minúsculas (até 256 caracteres).
1. Escolha **Criar**.
1. O novo link do recurso agora está listado em **Bancos de dados**.
### Conceda acesso ao recurso compartilhado usando o console do Lake Formation
Um administrador de banco de dados do Lake Formation pode conceder acesso ao recurso compartilhado usando o procedimento a seguir.
1. Abra o console do AWS Lake Formation: [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com//lakeformation)
1. Na barra de navegação principal, escolha **Bancos de dados**.
1. Na página **Bancos de dados**, selecione o link do recurso que você criou anteriormente.
1. No menu **Ações**, escolha **Conceder no alvo**.
1. Na página **Conceder permissões de dados**, em **Diretores**, escolha **usuários ou funções do IAM**.
1. No menu suspenso **Usuários ou funções do IAM**, encontre o usuário ao qual você deseja conceder acesso.
1. Em seguida, em **LF-Tags ou cartão de recursos do catálogo**, selecione a opção Recursos do **catálogo de dados nomeados**.
1. No menu suspenso **Tabelas opcionais**, selecione **Todas as tabelas** ou a tabela que você criou anteriormente.
1. No cartão **Permissões da tabela**, em **Permissões da tabela**, escolha **Descrever** e **selecionar**.
1. Em seguida, escolha **Grant**.
Para visualizar as permissões do Lake Formation, escolha **Permissões do Data lake** no painel de navegação principal. A tabela mostra os bancos de dados e links de recursos disponíveis.
## Configurando permissões para compartilhamentos AWS RAM de recursos
No console do AWS Lake Formation, visualize as permissões escolhendo **Permissões do Data lake** na barra de navegação principal. Na página **Permissões de dados**, você pode ver uma tabela que mostra os **tipos de recursos**, **bancos** de dados e **ARN** que está relacionada a um recurso compartilhado em **Compartilhamento de recursos de RAM**. Se você precisar aceitar um compartilhamento de recursos AWS Resource Access Manager (AWS RAM), AWS Lake Formation notificará você no console.
HealthOmics pode aceitar implicitamente os compartilhamentos AWS RAM de recursos durante a criação da loja. Para aceitar o compartilhamento AWS RAM de recursos, o usuário ou a função do IAM que chama as operações da `CreateAnnotationStore` API `CreateVariantStore` ou da API deve permitir as seguintes ações:
+ `ram:GetResourceShareInvitations`- Esta ação permite HealthOmics encontrar os convites.
+ `ram:AcceptResourceShareInvitation`- Esta ação permite HealthOmics aceitar o convite usando um token FAS.
Sem essas permissões, você vê um erro de autorização durante a criação da loja.
Aqui está um exemplo de política que inclui essas ações. Adicione essa política ao usuário ou função do IAM que aceita o compartilhamento AWS RAM de recursos.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"omics:*",
"ram:AcceptResourceShareInvitation",
"ram:GetResourceShareInvitations"
],
"Resource": "*"
}
]
}
```
------
# Configurando o Athena para consultas
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Você pode usar o Athena para consultar variantes e anotações. Antes de executar qualquer consulta, execute as seguintes tarefas de configuração:
**Topics**
+ [Configurar um local de resultados de consulta usando o console Athena](#configure-athena-query)
+ [Configurar um grupo de trabalho com o Athena engine v3](#configure-athena-workgroup)
## Configurar um local de resultados de consulta usando o console Athena
Para configurar a localização dos resultados da consulta, siga estas etapas.
1. [Abra o console Athena: console Athena](https://console.aws.amazon.com//athena)
1. Na barra de navegação principal, escolha **Editor de consultas**.
1. No editor de consultas, escolha a guia **Configurações** e, em seguida, escolha **Gerenciar**.
1. Insira um prefixo S3 de um local para salvar o resultado da consulta.
## Configurar um grupo de trabalho com o Athena engine v3
Para configurar um grupo de trabalho, siga estas etapas.
1. [Abra o console Athena: console Athena](https://console.aws.amazon.com//athena)
1. Na barra de navegação principal, escolha **Grupos de trabalho** e, em seguida, **Criar grupo de trabalho**.
1. Insira um nome para o grupo de trabalho.
1. Selecione **Athena SQL** como o tipo de mecanismo.
1. Em **Atualizar mecanismo de consulta**, selecione **Manual**.
1. Em **Mecanismo de versão do Query**, selecione **Athena versão 3**.
1. Escolha **Create workgroup (Criar grupo de trabalho)**.
# Executando consultas em lojas de HealthOmics variantes
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Você pode realizar consultas na sua loja de variantes usando o Amazon Athena. Observe que as coordenadas genômicas nos armazenamentos de variantes e anotações são representadas como intervalos semiabertos semifechados com base em zero.
## Execute uma consulta simples usando o console Athena
O exemplo a seguir mostra como executar uma consulta simples.
1. [Abra o editor Athena Query: editor Athena Query](https://console.aws.amazon.com//athena)
1. Em **Grupo de trabalho**, selecione o grupo de trabalho que você criou durante a configuração.
1. Verifique se a **fonte de dados** é **AwsDataCatalog**.
1. Em **Database**, selecione o link do recurso de banco de dados que você criou durante a configuração do Lake Formation.
1. Copie a consulta a seguir no **Editor** de **consultas na guia Consulta 1**:
```
SELECT * from omicsvariants limit 10
```
1. Para executar a consulta, escolha **Executar**. O console preenche a tabela de resultados com as primeiras 10 linhas da **omicsvariants** tabela.
## Execute uma consulta complexa usando o console Athena
O exemplo a seguir mostra como executar uma consulta complexa. Para executar essa consulta, importe `ClinVar` para o armazenamento de anotações.
**Execute uma consulta complexa**
1. [Abra o editor Athena Query: editor Athena Query](https://console.aws.amazon.com//athena)
1. Em **Grupo de trabalho**, selecione o grupo de trabalho que você criou durante a configuração.
1. Verifique se a **fonte de dados** é **AwsDataCatalog**.
1. Em **Database**, selecione o link do recurso de banco de dados que você criou durante a configuração do Lake Formation.
1. Escolha a opção **\$1** no canto superior direito para criar uma nova guia de **consulta chamada Consulta 2**.
1. Copie a consulta a seguir no **Editor** de **consultas na guia Consulta 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. Escolha **Executar** para começar a executar a consulta.
# Compartilhamento HealthOmics de lojas de análise
**Importante**
AWS HealthOmics lojas de variantes e lojas de anotações não estão mais abertas a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações](variant-store-availability-change.md).
Como proprietário de uma loja de variantes ou de uma loja de anotações, você pode compartilhar a loja com outras contas da AWS. O proprietário pode revogar o acesso ao recurso compartilhado excluindo o compartilhamento.
Como assinante de uma loja compartilhada, você primeiro aceita o compartilhamento. Em seguida, você pode definir fluxos de trabalho que usam a loja compartilhada. Os dados aparecem como uma tabela em Lake Formation AWS Glue e em Lake Formation.
Quando você não precisa mais acessar a loja, você exclui o compartilhamento.
Consulte [Compartilhamento de recursos entre contas em AWS HealthOmics](resource-sharing.md) para obter informações adicionais sobre compartilhamento de recursos.
## Criação de um compartilhamento na loja
Para criar um compartilhamento de loja, use a operação da API **create-share**. O assinante principal é Conta da AWS o usuário que assinará o compartilhamento. O exemplo a seguir cria um compartilhamento para um armazenamento de variantes. Para compartilhar uma loja com mais de uma conta, você cria vários compartilhamentos da mesma loja.
```
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 a criação for bem-sucedida, você receberá uma resposta com o ID e o status do compartilhamento.
```
{
"shareId": "495c21bedc889d07d0ab69d710a6841e-dd75ab7a1a9c384fa848b5bd8e5a7e0a",
"name": "my_Share-123",
"status": "PENDING"
}
```
O compartilhamento permanece em estado pendente até que o assinante o aceite usando a operação da API accept-share.