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 armazenamento
Use o HealthOmics armazenamento para armazenar, recuperar, organizar e compartilhar dados genômicos com eficiência e baixo custo. HealthOmics o armazenamento compreende as relações entre diferentes objetos de dados, para que você possa definir quais conjuntos de leitura se originaram dos mesmos dados de origem. Isso fornece a proveniência dos dados.
Os dados armazenados no `ACTIVE` estado podem ser recuperados imediatamente. Os dados que não foram acessados por 30 dias ou mais são armazenados no `ARCHIVE` estado. Para acessar os dados arquivados, você pode reativá-los por meio das operações da API ou do console.
HealthOmics os armazenamentos de sequências são projetados para preservar a integridade do conteúdo dos arquivos. No entanto, a equivalência bit a bit dos arquivos de dados importados e dos arquivos exportados não é preservada devido à compactação durante a classificação em camadas ativa e de arquivamento.
Durante a ingestão, HealthOmics gera uma tag de entidade ou *HealthOmics ETag*, para possibilitar a validação da integridade do conteúdo de seus arquivos de dados. As partes de sequenciamento são identificadas e capturadas ETag no nível da fonte de um conjunto de leitura. O ETag cálculo não altera o arquivo real nem os dados genômicos. Depois que um conjunto de leitura é criado, ele não ETag deve mudar durante todo o ciclo de vida da fonte do conjunto de leitura. Isso significa que a reimportação do mesmo arquivo resulta no cálculo do mesmo ETag valor.
**Topics**
+ [HealthOmics ETags e proveniência dos dados](etags-and-provenance.md)
+ [Criando uma loja HealthOmics de referência](create-reference-store.md)
+ [Criando um armazenamento HealthOmics de sequências](create-sequence-store.md)
+ [Excluindo repositórios HealthOmics de referências e sequências](deleting-reference-and-sequence-stores.md)
+ [Importação de conjuntos de leitura para um armazenamento de HealthOmics sequências](import-sequence-store.md)
+ [Upload direto para um armazenamento HealthOmics de sequências](synchronous-uploads.md)
+ [Exportação de conjuntos de HealthOmics leitura para um bucket do Amazon S3](read-set-exports.md)
+ [Acessando conjuntos de HealthOmics leitura com o Amazon S3 URIs](s3-access.md)
+ [Ativando conjuntos de leitura em HealthOmics](activating-read-sets.md)
# HealthOmics ETags e proveniência dos dados
A HealthOmics ETag (tag de entidade) é um hash do conteúdo ingerido em um armazenamento de sequências. Isso simplifica a recuperação e o processamento de dados, mantendo a integridade do conteúdo dos arquivos de dados ingeridos. ETag Isso reflete as alterações no conteúdo semântico do objeto, não em seus metadados. O tipo de conjunto de leitura e o algoritmo especificados determinam como o ETag é calculado. O ETag cálculo não altera o arquivo real nem os dados genômicos. Quando o esquema de tipo de arquivo do conjunto de leitura permite, o armazenamento de sequências atualiza os campos vinculados à proveniência dos dados.
Os arquivos têm uma identidade bit a bit e uma identidade semântica. A identidade bit a bit significa que os bits de um arquivo são idênticos, e uma identidade semântica significa que o conteúdo de um arquivo é idêntico. A identidade semântica é resistente a alterações de metadados e alterações de compressão, pois captura a integridade do conteúdo do arquivo.
Os conjuntos de leitura em armazenamentos HealthOmics sequenciais passam por compression/decompression ciclos e rastreamento de proveniência de dados durante todo o ciclo de vida de um objeto. Durante esse processamento, a identidade bit a bit de um arquivo ingerido pode mudar e espera-se que mude sempre que um arquivo for ativado; no entanto, a identidade semântica do arquivo é mantida. A identidade semântica é capturada como uma tag de HealthOmics entidade ou calculada durante ETag a ingestão do armazenamento de sequências e está disponível como metadados do conjunto de leitura.
Quando o esquema de tipo de arquivo do conjunto de leitura permite, os campos de atualizações do armazenamento de sequências são vinculados à proveniência dos dados. Para arquivos uBAM, BAM e CRAM, uma nova `Comment` tag `@CO` ou tag é adicionada ao cabeçalho. O comentário contém o ID do armazenamento da sequência e o carimbo de data/hora da ingestão.
## Amazon S3 ETags
Ao acessar um arquivo usando o URI do Amazon S3, as operações da API do Amazon S3 também podem retornar valores do Amazon S3 e da soma de verificação. ETag Os valores do Amazon S3 ETag e da soma de verificação diferem do HealthOmics ETags porque representam a identidade bit a bit do arquivo. Para saber mais sobre metadados descritivos e objetos, consulte a documentação da API de objetos do Amazon [S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_Object.html). ETag Os valores do Amazon S3 podem mudar com cada ciclo de ativação de um conjunto de leitura e você pode usá-los para validar a leitura de um arquivo. No entanto, não armazene em cache ETag os valores do Amazon S3 para usar na validação da identidade do arquivo durante o ciclo de vida do arquivo, pois eles não permanecem consistentes. Em contraste, o HealthOmics ETag permanece consistente durante todo o ciclo de vida do conjunto de leitura.
## Como HealthOmics calcula ETags
O ETag é gerado a partir de um hash do conteúdo do arquivo ingerido. A família de ETag algoritmos é definida como padrão, mas pode ser configurada de forma diferente durante a criação do armazenamento de sequências. MD5up Quando o ETag é calculado, o algoritmo e os hashes calculados são adicionados ao conjunto de leitura. Os MD5 algoritmos suportados para tipos de arquivo são os seguintes.
+ *FASTQ\$1 MD5up* — Calcula o MD5 hash de uma fonte de conjunto de leitura FASTQ completa e não compactada.
+ *BAM\$1 MD5up* — Calcula o MD5 hash da seção de alinhamento de uma fonte de conjunto de leitura BAM ou UBAM não compactada, conforme representada no SAM, com base na referência vinculada, se houver uma disponível.
+ *CRAM\$1 MD5up* — Calcula o MD5 hash da seção de alinhamento da fonte do conjunto de leitura CRAM não compactada, conforme representada no SAM, com base na referência vinculada.
**nota**
MD5 sabe-se que o hashing é vulnerável a colisões. Por causa disso, dois arquivos diferentes poderiam ter o mesmo ETag se tivessem sido fabricados para explorar a colisão conhecida.
Os algoritmos a seguir são compatíveis com a SHA256 família. Os algoritmos são calculados da seguinte forma:
+ *FASTQ\$1 SHA256up* — Calcula o hash SHA-256 de uma fonte de conjunto de leitura FASTQ completa e não compactada.
+ *BAM\$1 SHA256up* — Calcula o hash SHA-256 da seção de alinhamento de uma fonte de conjunto de leitura BAM ou UBAM não compactada, conforme representada no SAM, com base na referência vinculada, se houver uma disponível.
+ *CRAM\$1 SHA256up* — Calcula o hash SHA-256 da seção de alinhamento de uma fonte de conjunto de leitura CRAM não compactada, conforme representada no SAM, com base na referência vinculada.
Os algoritmos a seguir são compatíveis com a SHA512 família. Os algoritmos são calculados da seguinte forma:
+ *FASTQ\$1 SHA512up* — Calcula o hash SHA-512 de uma fonte de conjunto de leitura FASTQ completa e não compactada.
+ *BAM\$1 SHA512up* — Calcula o hash SHA-512 da seção de alinhamento de uma fonte de conjunto de leitura BAM ou UBAM não compactada, conforme representada no SAM, com base na referência vinculada, se houver uma disponível.
+ *CRAM\$1 SHA512up * — Calcula o hash SHA-512 da seção de alinhamento de uma fonte de conjunto de leitura CRAM não compactada, conforme representada no SAM, com base na referência vinculada.
# Criando uma loja HealthOmics de referência
Um armazenamento de referência em HealthOmics é um armazenamento de dados para o armazenamento de genomas de referência. Você pode ter uma única loja de referência em Conta da AWS cada região. Você pode criar um repositório de referência usando o console ou a CLI.
**Topics**
+ [Criando um repositório de referência usando o console](#console-create-reference-store)
+ [Criando um repositório de referência usando a CLI](#api-create-reference-store)
## Criando um repositório de referência usando o console
**Para criar um repositório de referências**
1. Abra o [console do HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **Loja de referência**.
1. Escolha **genomas de referência** nas opções de armazenamento de dados genômicos.
1. Você pode escolher um genoma de referência importado anteriormente ou importar um novo. Se você não importou um genoma de referência, escolha **Importar genoma de referência** no canto superior direito.
1. Na página **Criar tarefa de importação de genoma de referência**, escolha a opção Criação **rápida ou Criação** **manual para criar** um repositório de referência e, em seguida, forneça as seguintes informações.
+ **Nome do genoma de referência** - Um nome exclusivo para esta loja.
+ **Descrição** (opcional) - Uma descrição dessa loja de referência.
+ **Função do IAM** - Selecione uma função com acesso ao seu genoma de referência.
+ **Referência do Amazon S3** - Selecione seu arquivo de sequência de referência em um bucket do Amazon S3.
+ **Tags** (opcional) - forneça até 50 tags para esse repositório de referência.
## Criando um repositório de referência usando a CLI
O exemplo a seguir mostra como criar um repositório de referência usando AWS CLI o. Você pode ter uma loja de referência por AWS região.
Os repositórios de referência suportam o armazenamento de arquivos FASTA com as extensões `.fasta``.fa`,`.fas`,`.fsa`,`.faa`,`.fna`,`.ffn`,,`.frn`, `.mpfa``.seq`,`.txt`. A `bgzip` versão dessas extensões também é suportada.
No exemplo a seguir, `reference store name` substitua pelo nome que você escolheu para sua loja de referência.
```
aws omics create-reference-store --name "reference store name"
```
Você recebe uma resposta JSON com o ID e o nome da loja de referência, o ARN e a data e hora de quando sua loja de referência foi criada.
```
{
"id": "3242349265",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/3242349265",
"name": "MyReferenceStore",
"creationTime": "2022-07-01T20:58:42.878Z"
}
```
Você pode usar o ID do repositório de referência em AWS CLI comandos adicionais. Você pode recuperar a lista de repositórios de referência IDs vinculados à sua conta usando o **list-reference-stores**comando, conforme mostrado no exemplo a seguir.
```
aws omics list-reference-stores
```
Em resposta, você recebe o nome da sua loja de referência recém-criada.
```
{
"referenceStores": [
{
"id": "3242349265",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/3242349265",
"name": "MyReferenceStore",
"creationTime": "2022-07-01T20:58:42.878Z"
}
]
}
```
Depois de criar um repositório de referência, você pode criar trabalhos de importação para carregar arquivos de referência genômica nele. Para fazer isso, você deve usar ou criar uma função do IAM para acessar os dados. Veja abaixo um exemplo de política .
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
------
Você também deve ter uma política de confiança semelhante ao exemplo a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"omics.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Agora você pode importar um genoma de referência. [Este exemplo usa o Genome Reference Consortium Human Build 38 (hg38), que é de acesso aberto e está disponível no Registry of Open Data em. AWS](https://registry.opendata.aws/) O bucket que hospeda esses dados está localizado no Leste dos EUA (Ohio). Para usar buckets em outras AWS regiões, você pode copiar os dados para um bucket do Amazon S3 hospedado em sua região. Use o AWS CLI comando a seguir para copiar o genoma para seu bucket do Amazon S3.
```
aws s3 cp s3://broad-references/hg38/v0/Homo_sapiens_assembly38.fasta s3://amzn-s3-demo-bucket
```
Em seguida, você pode começar seu trabalho de importação. Substitua `reference store ID``role ARN`, e `source file path` com sua própria entrada.
```
aws omics start-reference-import-job --reference-store-id reference store ID --role-arn role ARN --sources source file path
```
Depois que os dados forem importados, você receberá a seguinte resposta em JSON.
```
{
"id": "7252016478",
"referenceStoreId": "3242349265",
"roleArn": "arn:aws:iam::111122223333:role/OmicsReferenceImport",
"status": "CREATED",
"creationTime": "2022-07-01T21:15:13.727Z"
}
```
Você pode monitorar o status de um trabalho usando o comando a seguir. No exemplo a seguir, substitua `reference store ID` e `job ID` pelo ID da loja de referência e pelo ID do trabalho sobre o qual você deseja saber mais.
```
aws omics get-reference-import-job --reference-store-id reference store ID --id job ID
```
Em resposta, você recebe uma resposta com os detalhes dessa loja de referência e seu status.
```
{
"id": "7252016478",
"referenceStoreId": "3242349265",
"roleArn": "arn:aws:iam::555555555555:role/OmicsReferenceImport",
"status": "RUNNING",
"creationTime": "2022-07-01T21:15:13.727Z",
"sources": [
{
"sourceFile": "s3://amzn-s3-demo-bucket/Homo_sapiens_assembly38.fasta",
"status": "IN_PROGRESS",
"name": "MyReference"
}
]
}
```
Você também pode encontrar a referência que foi importada listando suas referências e filtrando-as com base no nome da referência. `reference store ID`Substitua pelo ID da loja de referência e adicione um filtro opcional para restringir a lista.
```
aws omics list-references --reference-store-id reference store ID --filter name=MyReference
```
Em resposta, você recebe as seguintes informações.
```
{
"references": [
{
"id": "1234567890",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/1234567890/reference/1234567890",
"referenceStoreId": "12345678",
"md5": "7ff134953dcca8c8997453bbb80b6b5e",
"status": "ACTIVE",
"name": "MyReference",
"creationTime": "2022-07-02T00:15:19.787Z",
"updateTime": "2022-07-02T00:15:19.787Z"
}
]
}
```
Para saber mais sobre os metadados de referência, use a operação da **get-reference-metadata**API. No exemplo a seguir, `reference store ID` substitua pelo ID da loja de referência e `reference ID` pelo ID de referência sobre o qual você deseja saber mais.
```
aws omics get-reference-metadata --reference-store-id reference store ID --id reference ID
```
Você recebe as seguintes informações em resposta.
```
{
"id": "1234567890",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/referencestoreID/reference/referenceID",
"referenceStoreId": "1234567890",
"md5": "7ff134953dcca8c8997453bbb80b6b5e",
"status": "ACTIVE",
"name": "MyReference",
"creationTime": "2022-07-02T00:15:19.787Z",
"updateTime": "2022-07-02T00:15:19.787Z",
"files": {
"source": {
"totalParts": 31,
"partSize": 104857600,
"contentLength": 3249912778
},
"index": {
"totalParts": 1,
"partSize": 104857600,
"contentLength": 160928
}
}
}
```
Você também pode baixar partes do arquivo de referência usando **get-reference**. No exemplo a seguir, `reference store ID` substitua pelo ID da loja de referência e `reference ID` pelo ID de referência do qual você deseja fazer o download.
```
aws omics get-reference --reference-store-id reference store ID --id reference ID --part-number 1 outfile.fa
```
# Criando um armazenamento HealthOmics de sequências
HealthOmics os armazenamentos de sequências suportam o armazenamento de arquivos genômicos nos formatos não alinhados de `FASTQ` (somente gzip) e. `uBAM` Ele também suporta os formatos alinhados de `BAM` e. `CRAM`
Os arquivos importados são armazenados como conjuntos de leitura. Você pode adicionar tags aos conjuntos de leitura e usar políticas do IAM para controlar o acesso aos conjuntos de leitura. Os conjuntos de leitura alinhados exigem um genoma de referência para alinhar as sequências genômicas, mas é opcional para conjuntos de leitura não alinhados.
Para armazenar conjuntos de leitura, primeiro você cria um armazenamento de sequências. Ao criar um armazenamento de sequências, você pode especificar um bucket opcional do Amazon S3 como um local alternativo e o local onde os registros de acesso do S3 são armazenados. O local alternativo é usado para armazenar todos os arquivos que não conseguem criar um conjunto de leitura durante um upload direto. Os locais alternativos estão disponíveis para lojas de sequências criadas após 15 de maio de 2023. Você especifica o local de fallback ao criar o armazenamento de sequências.
Você pode especificar até cinco chaves de tag do conjunto de leitura. Quando você cria ou atualiza um conjunto de leitura com uma chave de tag que corresponde a uma dessas chaves, as tags do conjunto de leitura são propagadas para o objeto Amazon S3 correspondente. As tags do sistema criadas por HealthOmics são propagadas por padrão.
**Topics**
+ [Criando um armazenamento de sequências usando o console](#console-create-sequence-store)
+ [Criando um armazenamento de sequências usando a CLI](#api-create-sequence-store)
+ [Atualizando um armazenamento de sequências](#update-sequence-store)
+ [Atualizando as tags do conjunto de leitura para um armazenamento de sequências](#sequence-store-manage-tags)
+ [Importação de arquivos genômicos](#import-genomic-files)
## Criando um armazenamento de sequências usando o console
**Para criar um repositório de sequências**
1. Abra o [console de HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **Armazenamentos de sequências**.
1. Na página **Criar armazenamento de sequências**, forneça as seguintes informações
+ **Nome da loja de sequências** - Um nome exclusivo para essa loja.
+ **Descrição** (opcional) - Uma descrição desse armazenamento de sequências.
1. Para a **localização do Fallback no S3**, especifique uma localização do Amazon S3. HealthOmics usa o local de fallback para armazenar qualquer arquivo que falhe na criação de um conjunto de leitura durante um upload direto. Você precisa conceder ao HealthOmics serviço acesso de gravação ao local de fallback do Amazon S3. Para visualizar um exemplo de política, consulte [Configurar um local de fallback](synchronous-uploads.md#synchronous-uploads-fallback).
Os locais alternativos não estão disponíveis para lojas de sequências criadas antes de 16 de maio de 2023.
1. (Opcional) Para **chaves de tag do conjunto de leitura para propagação do S3**, você pode inserir até cinco chaves do conjunto de leitura para propagar de um conjunto de leitura para os objetos do S3 subjacentes. Ao propagar tags de um conjunto de leitura para o objeto do S3, você pode conceder permissões de acesso ao S3 com base nas tags aos usuários and/or finais para ver as tags propagadas por meio da operação da API do Amazon S3. getObjectTagging
1. Insira um valor-chave na caixa de texto. O console cria uma nova caixa de texto para adicionar a próxima chave.
1. (Opcional) Escolha **Remover** para remover todas as chaves.
1. Em **Criptografia de dados**, selecione se você deseja que a criptografia de dados seja de propriedade e gerenciada por AWS ou use uma CMK gerenciada pelo cliente.
1. (Opcional) Em **Acesso aos dados do S3**, selecione se deseja criar uma nova função e política para acessar o armazenamento de sequências por meio do Amazon S3.
1. (Opcional) Para o **registro de acesso do S3**, selecione `Enabled` se você deseja que o Amazon S3 colete registros do registro de acesso.
Para o **local de registro de acesso no S3**, especifique um local do Amazon S3 para armazenar os registros. Esse campo fica visível somente se você habilitou o registro de acesso do S3.
1. **Tags** (opcional) - forneça até 50 tags para esse armazenamento de sequências. Essas tags são separadas das tags do conjunto de leitura que são definidas durante a import/tag atualização do conjunto de leitura.
Depois de criar a loja, ela estará pronta para[Importação de arquivos genômicos](#import-genomic-files).
## Criando um armazenamento de sequências usando a CLI
No exemplo a seguir, `sequence store name` substitua pelo nome que você escolheu para seu armazenamento de sequências.
```
aws omics create-sequence-store --name sequence store name --fallback-location "s3://amzn-s3-demo-bucket"
```
Você recebe a seguinte resposta em JSON, que inclui o número de identificação do seu armazenamento de sequências recém-criado.
```
{
"id": "3936421177",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/3936421177",
"name": "sequence_store_example_name",
"creationTime": "2022-07-13T20:09:26.038Z"
"fallbackLocation" : "s3://amzn-s3-demo-bucket"
}
```
Você também pode visualizar todos os armazenamentos de sequências associados à sua conta usando o **list-sequence-stores**comando, conforme mostrado a seguir.
```
aws omics list-sequence-stores
```
Você recebe a seguinte resposta.
```
{
"sequenceStores": [
{
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/3936421177",
"id": "3936421177",
"name": "MySequenceStore",
"creationTime": "2022-07-13T20:09:26.038Z",
"updatedTime": "2024-09-13T04:11:31.242Z",
"fallbackLocation" : "s3://amzn-s3-demo-bucket",
"status": "Active"
}
]
}
```
Você pode usar **get-sequence-store**para saber mais sobre um armazenamento de sequências usando seu ID, conforme mostrado no exemplo a seguir:
```
aws omics get-sequence-store --id sequence store ID
```
Você recebe a seguinte resposta:
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/sequencestoreID",
"creationTime": "2024-01-12T04:45:29.857Z",
"updatedTime": "2024-09-13T04:11:31.242Z",
"description": null,
"fallbackLocation": null,
"id": "2015356892",
"name": "MySequenceStore",
"s3Access": {
"s3AccessPointArn": "arn:aws:s3:us-west-2:123456789012:accesspoint/592761533288-2015356892",
"s3Uri": "s3://592761533288-2015356892-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/",
"accessLogLocation": "s3://IAD-seq-store-log/2015356892/"
},
"sseConfig": {
"keyArn": "arn:aws:kms:us-west-2:123456789012:key/eb2b30f5-635d-4b6d-b0f9-d3889fe0e648",
"type": "KMS"
},
"status": "Active",
"statusMessage": null,
"setTagsToSync": ["withdrawn","protocol"],
}
```
Após a criação, vários parâmetros da loja também podem ser atualizados. Isso pode ser feito por meio do console ou da `updateSequenceStore` operação da API.
## Atualizando um armazenamento de sequências
Para atualizar um armazenamento de sequências, siga estas etapas:
1. Abra o [console de HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **Armazenamentos de sequências**.
1. Escolha o armazenamento de sequências a ser atualizado.
1. No painel **Detalhes**, escolha **Editar**.
1. Na página **Editar detalhes**, você pode atualizar os seguintes campos:
+ **Nome da loja de sequências** - Um nome exclusivo para essa loja.
+ **Descrição** - Uma descrição desse armazenamento de sequências.
+ **Local de fallback no S3**, especifique um local do Amazon S3. HealthOmics usa o local de fallback para armazenar qualquer arquivo que falhe na criação de um conjunto de leitura durante um upload direto.
+ **Chaves de tag do conjunto de leitura para propagação do S3** Você pode inserir até cinco chaves do conjunto de leitura para propagar para o Amazon S3.
+ (Opcional) Para o **registro de acesso do S3**, selecione `Enabled` se você deseja que o Amazon S3 colete registros do registro de acesso.
Para o **local de registro de acesso no S3**, especifique um local do Amazon S3 para armazenar os registros. Esse campo fica visível somente se você habilitou o registro de acesso do S3.
+ **Tags** (opcional) - forneça até 50 tags para esse armazenamento de sequências.
## Atualizando as tags do conjunto de leitura para um armazenamento de sequências
Para atualizar as tags do conjunto de leitura ou outros campos para um armazenamento de sequências, siga estas etapas:
1. Abra o [console de HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha **Armazenamentos de sequências**.
1. Escolha o repositório de sequências que você deseja atualizar.
1. Escolha a guia **Detalhes**.
1. Escolha **Editar**.
1. Adicione novas tags do conjunto de leitura ou exclua as tags existentes, conforme necessário.
1. Atualize o nome, a descrição, o local alternativo ou o acesso aos dados do S3, conforme necessário.
1. Escolha **Salvar alterações**.
## Importação de arquivos genômicos
Para importar arquivos genômicos para um armazenamento de sequências, siga estas etapas:
**Para importar um arquivo genômico**
1. Abra o [console de HealthOmics ](https://console.aws.amazon.com/omics/).
1. Se necessário, abra o painel de navegação esquerdo (≡). Escolha escolher **Armazenamentos de sequências**.
1. Na página **Armazenamentos de sequências**, escolha o repositório de sequências para o qual você deseja importar seus arquivos.
1. Na página de armazenamento de sequências individuais, escolha **Importar arquivos genômicos**.
1. Na página **Especificar detalhes da importação**, forneça as seguintes informações
+ **Função do IAM** - A função do IAM que pode acessar os arquivos genômicos no Amazon S3.
+ **Genoma de referência** - O genoma de referência para esses dados genômicos.
1. Na página **Especificar manifesto de importação**, especifique as informações a seguir: **Arquivo de manifesto**. O arquivo de manifesto é um arquivo JSON ou YAML que descreve informações essenciais de seus dados genômicos. Para obter informações sobre o arquivo de manifesto, consulte[Importação de conjuntos de leitura para um armazenamento de HealthOmics sequências](import-sequence-store.md).
1. Clique em **Criar tarefa de importação**.
# Excluindo repositórios HealthOmics de referências e sequências
Tanto os armazenamentos de referência quanto os de sequência podem ser excluídos. Os armazenamentos de sequências só podem ser excluídos se não contiverem conjuntos de leitura, e os armazenamentos de referência só poderão ser excluídos se não contiverem referências. A exclusão de uma sequência ou armazenamento de referência também exclui todas as tags associadas a essa loja.
O exemplo a seguir mostra como excluir um repositório de referência usando AWS CLI o. Se a ação for bem-sucedida, você não receberá uma resposta. No exemplo a seguir, `reference store ID` substitua pelo ID da loja de referência.
```
aws omics delete-reference-store --id reference store ID
```
O exemplo a seguir mostra como excluir um armazenamento de sequências. Você não receberá uma resposta se a ação for bem-sucedida. No exemplo a seguir, `sequence store ID` substitua pelo seu ID de armazenamento de sequências.
```
aws omics delete-sequence-store --id sequence store ID
```
Você também pode excluir uma referência em um repositório de referência, conforme mostrado no exemplo a seguir. As referências só podem ser excluídas se não estiverem sendo usadas em um conjunto de leitura, armazenamento de variantes ou armazenamento de anotações. No exemplo a seguir, `reference store ID` substitua pelo ID da loja de referência e `reference ID` substitua pelo ID da referência que você deseja excluir.
```
aws omics delete-reference --id reference ID --reference-store-id reference store ID
```
# Importação de conjuntos de leitura para um armazenamento de HealthOmics sequências
Depois de criar seu armazenamento de sequências, crie trabalhos de importação para carregar conjuntos de leitura no armazenamento de dados. Você pode carregar seus arquivos de um bucket do Amazon S3 ou pode fazer upload diretamente usando as operações síncronas da API. Seu bucket do Amazon S3 deve estar na mesma região do seu armazenamento de sequências.
Você pode carregar qualquer combinação de conjuntos de leitura alinhados e não alinhados em seu armazenamento de sequências. No entanto, se algum dos conjuntos de leitura em sua importação estiver alinhado, você deverá incluir um genoma de referência.
Você pode reutilizar a política de acesso do IAM que você usou para criar o repositório de referência.
Os tópicos a seguir descrevem as principais etapas que você segue para importar um conjunto de leitura para seu armazenamento de sequências e, em seguida, obter informações sobre os dados importados.
**Topics**
+ [Faça upload de arquivos para o Amazon S3](#upload-files-to-s3)
+ [Criar um arquivo de manifesto](#create-manifest-file)
+ [Iniciando o trabalho de importação](#start-import-job)
+ [Monitore o trabalho de importação](#monitor-import-job)
+ [Encontre os arquivos de sequência importados](#list-read-sets)
+ [Obtenha detalhes sobre um conjunto de leitura](#get-read-set-metadata)
+ [Baixe os arquivos de dados do conjunto de leitura](#get-read-set-data)
## Faça upload de arquivos para o Amazon S3
O exemplo a seguir mostra como mover arquivos para o bucket do Amazon S3.
```
aws s3 cp s3://1000genomes/phase1/data/HG00100/alignment/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam s3://your-bucket
aws s3 cp s3://1000genomes/phase3/data/HG00146/sequence_read/SRR233106_1.filt.fastq.gz s3://your-bucket
aws s3 cp s3://1000genomes/phase3/data/HG00146/sequence_read/SRR233106_2.filt.fastq.gz s3://your-bucket
aws s3 cp s3://1000genomes/data/HG00096/alignment/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram s3://your-bucket
aws s3 cp s3://gatk-test-data/wgs_ubam/NA12878_20k/NA12878_A.bam s3://your-bucket
```
A amostra `BAM` e a `CRAM` usada neste exemplo requerem referências de genoma diferentes, `Hg19` e. `Hg38` Para saber mais ou acessar essas referências, consulte [The Broad Genome References](https://registry.opendata.aws/broad-references/) no Registro de Dados Abertos em AWS.
## Criar um arquivo de manifesto
Você também deve criar um arquivo de manifesto em JSON para modelar o trabalho de importação `import.json` (veja o exemplo a seguir). Se você criar um armazenamento de sequências no console, não precisará especificar `sequenceStoreId` ou`roleARN`, portanto, seu arquivo de manifesto começa com a `sources` entrada.
------
#### [ API manifest ]
O exemplo a seguir importa três conjuntos de leitura usando a API: um `FASTQ``BAM`, um e um`CRAM`.
```
{
"sequenceStoreId": "3936421177",
"roleArn": "arn:aws:iam::555555555555:role/OmicsImport",
"sources":
[
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
// NOTE: there is no reference arn required here
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"subjectId": "mySubject",
"sampleId": "mySample",
// NOTE: there is no reference arn required here
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data"
}
]
}
```
------
#### [ Console manifest ]
Esse código de exemplo é usado para importar um único conjunto de leitura usando o console.
```
[
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://your-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data"
}
]
```
------
Como alternativa, você pode carregar o arquivo de manifesto no formato YAML.
## Iniciando o trabalho de importação
Para iniciar o trabalho de importação, use o AWS CLI comando a seguir.
```
aws omics start-read-set-import-job --cli-input-json file://import.json
```
Você recebe a seguinte resposta, que indica uma criação de emprego bem-sucedida.
```
{
"id": "3660451514",
"sequenceStoreId": "3936421177",
"roleArn": "arn:aws:iam::111122223333:role/OmicsImport",
"status": "CREATED",
"creationTime": "2022-07-13T22:14:59.309Z"
}
```
## Monitore o trabalho de importação
Depois que o trabalho de importação for iniciado, você poderá monitorar seu progresso com o comando a seguir. No exemplo a seguir, `sequence store id` substitua pela ID do armazenamento de sequências e `job import ID` substitua pela ID de importação.
```
aws omics get-read-set-import-job --sequence-store-id sequence store id --id job import ID
```
A seguir, são mostrados os status de todos os trabalhos de importação associados à ID de armazenamento de sequência especificada.
```
{
"id": "1234567890",
"sequenceStoreId": "1234567890",
"roleArn": "arn:aws:iam::111122223333:role/OmicsImport",
"status": "RUNNING",
"statusMessage": "The job is currently in progress.",
"creationTime": "2022-07-13T22:14:59.309Z",
"sources": [
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/3242349265/reference/8625408453",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/3242349265/reference/1234568870",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data",
"readSetID": "1234567890"
}
]
}
```
## Encontre os arquivos de sequência importados
Depois que o trabalho for concluído, você poderá usar a operação da **list-read-sets**API para encontrar os arquivos de sequência importados. No exemplo a seguir, `sequence store id` substitua pelo seu ID de armazenamento de sequências.
```
aws omics list-read-sets --sequence-store-id sequence store id
```
Você recebe a seguinte resposta.
```
{
"readSets": [
{
"id": "0000000001",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/01234567890/readSet/0000000001",
"sequenceStoreId": "1234567890",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00100",
"description": "BAM for HG00100",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/01234567890/reference/0000000001",
"fileType": "BAM",
"sequenceInformation": {
"totalReadCount": 9194,
"totalBaseCount": 928594,
"generatedFrom": "1000 Genomes",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:25:20Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "d1d65429212d61d115bb19f510d4bd02"
}
},
{
"id": "0000000002",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000002",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00146",
"description": "FASTQ for HG00146",
"fileType": "FASTQ",
"sequenceInformation": {
"totalReadCount": 8000000,
"totalBaseCount": 1184000000,
"generatedFrom": "1000 Genomes",
"alignment": "UNALIGNED"
},
"creationTime": "2022-07-13T23:26:43Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "FASTQ_MD5up",
"source1": "ca78f685c26e7cc2bf3e28e3ec4d49cd"
}
},
{
"id": "0000000003",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000003",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00096",
"description": "CRAM for HG00096",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/0123456789/reference/0000000001",
"fileType": "CRAM",
"sequenceInformation": {
"totalReadCount": 85466534,
"totalBaseCount": 24000004881,
"generatedFrom": "1000 Genomes",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:30:41Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "CRAM_MD5up",
"source1": "66817940f3025a760e6da4652f3e927e"
}
},
{
"id": "0000000004",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000004",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"fileType": "UBAM",
"sequenceInformation": {
"totalReadCount": 20000,
"totalBaseCount": 5000000,
"generatedFrom": "GATK Test Data",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:30:41Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "640eb686263e9f63bcda12c35b84f5c7"
}
}
]
}
```
## Obtenha detalhes sobre um conjunto de leitura
Para ver mais detalhes sobre um conjunto de leitura, use a operação **GetReadSetMetadata**da API. No exemplo a seguir, `sequence store id` substitua pela ID do armazenamento de sequências e `read set id` substitua pela ID do conjunto de leitura.
```
aws omics get-read-set-metadata --sequence-store-id sequence store id --id read set id
```
Você recebe a seguinte resposta.
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/2015356892/readSet/9515444019",
"creationTime": "2024-01-12T04:50:33.548Z",
"creationType": "IMPORT",
"creationJobId": "33222111",
"description": null,
"etag": {
"algorithm": "FASTQ_MD5up",
"source1": "00d0885ba3eeb211c8c84520d3fa26ec",
"source2": "00d0885ba3eeb211c8c84520d3fa26ec"
},
"fileType": "FASTQ",
"files": {
"index": null,
"source1": {
"contentLength": 10818,
"partSize": 104857600,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
"totalParts": 1
},
"source2": {
"contentLength": 10818,
"partSize": 104857600,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
"totalParts": 1
}
},
"id": "9515444019",
"name": "paired-fastq-import",
"sampleId": "sampleId-paired-fastq-import",
"sequenceInformation": {
"alignment": "UNALIGNED",
"generatedFrom": null,
"totalBaseCount": 30000,
"totalReadCount": 200
},
"sequenceStoreId": "2015356892",
"status": "ACTIVE",
"statusMessage": null,
"subjectId": "subjectId-paired-fastq-import"
}
```
## Baixe os arquivos de dados do conjunto de leitura
Você pode acessar os objetos de um conjunto de leitura ativo usando a operação de **GetObject** API do Amazon S3. O URI do objeto é retornado na resposta **GetReadSetMetadata**da API. Para obter mais informações, consulte [Acessando conjuntos de HealthOmics leitura com o Amazon S3 URIs](s3-access.md).
Como alternativa, use a operação HealthOmics **GetReadSet** da API. Você pode usar **GetReadSet** para baixar paralelamente baixando partes individuais. Essas peças são semelhantes às peças do Amazon S3. Veja a seguir um exemplo de como baixar a parte 1 de um conjunto de leitura. No exemplo a seguir, `sequence store id` substitua pela ID do armazenamento de sequências e `read set id` substitua pela ID do conjunto de leitura.
```
aws omics get-read-set --sequence-store-id sequence store id --id read set id --part-number 1 outfile.bam
```
Você também pode usar o Gerenciador HealthOmics de Transferências para baixar arquivos para um conjunto de HealthOmics referência ou leitura. Você pode baixar o HealthOmics Transfer Manager [aqui](https://pypi.org/project/amazon-omics-tools/). Para obter mais informações sobre como usar e configurar o Gerenciador de Transferências, consulte este [GitHubRepositório](https://github.com/awslabs/amazon-omics-tools/).
# Upload direto para um armazenamento HealthOmics de sequências
Recomendamos que você use o Gerenciador HealthOmics de Transferências para adicionar arquivos ao seu armazenamento de sequências. Para obter mais informações sobre como usar o Transfer Manager, consulte este [GitHubRepositório.](https://github.com/awslabs/amazon-omics-tools/) Você também pode carregar seus conjuntos de leitura diretamente para um armazenamento de sequências por meio das operações da API de upload direto.
Os conjuntos de leitura de upload direto existem primeiro no `PROCESSING_UPLOAD` estado. Isso significa que as partes do arquivo estão sendo carregadas no momento e você pode acessar os metadados do conjunto de leitura. Depois que as peças são carregadas e as somas de verificação são validadas, o conjunto de leitura se torna `ACTIVE` e se comporta da mesma forma que um conjunto de leitura importado.
Se o upload direto falhar, o status do conjunto de leitura será mostrado como`UPLOAD_FAILED`. Você pode configurar um bucket do Amazon S3 como um local alternativo para arquivos que falham no upload. Os locais alternativos estão disponíveis para lojas de sequências criadas após 15 de maio de 2023.
**Topics**
+ [Upload direto para um armazenamento de sequências usando o AWS CLI](#synchronous-uploads-api)
+ [Configurar um local de fallback](#synchronous-uploads-fallback)
## Upload direto para um armazenamento de sequências usando o AWS CLI
Para começar, inicie um upload de várias partes. Você pode fazer isso usando o AWS CLI, conforme mostrado no exemplo a seguir.
**Para direcionar o upload usando AWS CLI comandos**
1. Crie as partes separando seus dados, conforme mostrado no exemplo a seguir.
```
split -b 100MiB SRR233106_1.filt.fastq.gz source1_part_
```
1. Depois que os arquivos de origem estiverem divididos em partes, crie um upload de conjunto de leitura com várias partes, conforme mostrado no exemplo a seguir. Substitua `sequence store ID` e os outros parâmetros pelo ID do armazenamento de sequências e outros valores.
```
aws omics create-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--name upload name \
--source-file-type FASTQ \
--subject-id subject ID \
--sample-id sample ID \
--description "FASTQ for HG00146" "description of upload" \
--generated-from "1000 Genomes""source of imported files"
```
Você obtém os `uploadID` e outros metadados na resposta. Use o `uploadID` para a próxima etapa do processo de upload.
```
{
"sequenceStoreId": "1504776472",
"uploadId": "7640892890",
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"name": "HG00146",
"description": "FASTQ for HG00146",
"creationTime": "2023-11-20T23:40:47.437522+00:00"
}
```
1. Adicione seus conjuntos de leitura ao upload. Se o arquivo for pequeno o suficiente, você só precisará executar essa etapa uma vez. Para arquivos maiores, você executa essa etapa para cada parte do seu arquivo. Se você fizer o upload de uma nova peça usando um número de peça usado anteriormente, ele substituirá a peça carregada anteriormente.
No exemplo a seguir, substitua `sequence store ID``upload ID`, e os outros parâmetros pelos seus valores.
```
aws omics upload-read-set-part \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--part-source SOURCE1 \
--part-number part number \
--payload source1/source1_part_aa.fastq.gz
```
A resposta é uma ID que você pode usar para verificar se o arquivo carregado corresponde ao arquivo pretendido.
```
{
"checksum": "984979b9928ae8d8622286c4a9cd8e99d964a22d59ed0f5722e1733eb280e635"
}
```
1. Continue carregando as partes do seu arquivo, se necessário. Para verificar se seus conjuntos de leitura foram carregados, use a operação de API **list-read-set-upload-parts**, conforme mostrado a seguir. No exemplo a seguir, substitua `sequence store ID ``upload ID`, e o `part source` por sua própria entrada.
```
aws omics list-read-set-upload-parts \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--part-source SOURCE1
```
A resposta retorna o número de conjuntos de leitura, o tamanho e a data e hora de quando foi atualizada mais recentemente.
```
{
"parts": [
{
"partNumber": 1,
"partSize": 104857600,
"partSource": "SOURCE1",
"checksum": "MVMQk+vB9C3Ge8ADHkbKq752n3BCUzyl41qEkqlOD5M=",
"creationTime": "2023-11-20T23:58:03.500823+00:00",
"lastUpdatedTime": "2023-11-20T23:58:03.500831+00:00"
},
{
"partNumber": 2,
"partSize": 104857600,
"partSource": "SOURCE1",
"checksum": "keZzVzJNChAqgOdZMvOmjBwrOPM0enPj1UAfs0nvRto=",
"creationTime": "2023-11-21T00:02:03.813013+00:00",
"lastUpdatedTime": "2023-11-21T00:02:03.813025+00:00"
},
{
"partNumber": 3,
"partSize": 100339539,
"partSource": "SOURCE1",
"checksum": "TBkNfMsaeDpXzEf3ldlbi0ipFDPaohKHyZ+LF1J4CHk=",
"creationTime": "2023-11-21T00:09:11.705198+00:00",
"lastUpdatedTime": "2023-11-21T00:09:11.705208+00:00"
}
]
}
```
1. Para visualizar todos os uploads ativos de conjuntos de leitura de várias partes, use **list-multipart-read-set-uploads,** conforme mostrado a seguir. `sequence store ID`Substitua pelo ID do seu próprio armazenamento de sequências.
```
aws omics list-multipart-read-set-uploads --sequence-store-id
sequence store ID
```
Essa API retorna apenas uploads de conjuntos de leitura em várias partes que estão em andamento. Depois que os conjuntos de leitura ingeridos `ACTIVE` terminarem, ou se o upload falhar, o upload não será retornado na resposta à API **list-multipart-read-set-uploads**. Para visualizar conjuntos de leitura ativos, use a **list-read-sets**API. Um exemplo de resposta para **list-multipart-read-set-uploads** é mostrado a seguir.
```
{
"uploads": [
{
"sequenceStoreId": "1234567890",
"uploadId": "8749584421",
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"name": "HG00146",
"description": "FASTQ for HG00146",
"creationTime": "2023-11-29T19:22:51.349298+00:00"
},
{
"sequenceStoreId": "1234567890",
"uploadId": "5290538638",
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/8168613728/reference/2190697383",
"name": "HG00146",
"description": "BAM for HG00146",
"creationTime": "2023-11-29T19:23:33.116516+00:00"
},
{
"sequenceStoreId": "1234567890",
"uploadId": "4174220862",
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/8168613728/reference/2190697383",
"name": "HG00147",
"description": "BAM for HG00147",
"creationTime": "2023-11-29T19:23:47.007866+00:00"
}
]
}
```
1. Depois de carregar todas as partes do seu arquivo, use **complete-multipart-read-set-upload** para concluir o processo de upload, conforme mostrado no exemplo a seguir. Substitua `sequence store ID``upload ID`,, e o parâmetro para peças com seus próprios valores.
```
aws omics complete-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--parts '[{"checksum":"gaCBQMe+rpCFZxLpoP6gydBoXaKKDA/Vobh5zBDb4W4=","partNumber":1,"partSource":"SOURCE1"}]'
```
A resposta para **complete-multipart-read-set-upload** é o conjunto de leitura IDs para seus conjuntos de leitura importados.
```
{
"readSetId": "0000000001"
}
```
1. Para interromper o upload, use **abort-multipart-read-set-upload** com o ID de upload para finalizar o processo de upload. Substitua `sequence store ID` e `upload ID` por seus próprios valores de parâmetros.
```
aws omics abort-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--upload-id upload ID
```
1. Depois que o upload for concluído, recupere seus dados do conjunto de leitura usando **get-read-set**, conforme mostrado a seguir. Se o upload ainda estiver sendo processado, **get-read-set**retornará metadados limitados e os arquivos de índice gerados não estarão disponíveis. Substitua `sequence store ID` e os outros parâmetros por sua própria entrada.
```
aws omics get-read-set
--sequence-store-id sequence store ID \
--id read set ID \
--file SOURCE1 \
--part-number 1 myfile.fastq.gz
```
1. Para verificar os metadados, incluindo o status do seu upload, use a operação da **get-read-set-metadata**API.
```
aws omics get-read-set-metadata --sequence-store-id sequence store ID --id read set ID
```
A resposta inclui detalhes de metadados, como o tipo de arquivo, o ARN de referência, o número de arquivos e o tamanho das sequências. Também inclui o status. Os status possíveis são `PROCESSING_UPLOAD``ACTIVE`, e. `UPLOAD_FAILED`
```
{
"id": "0000000001",
"arn": "arn:aws:omics:us-west-2:555555555555:sequenceStore/0123456789/readSet/0000000001",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "PROCESSING_UPLOAD",
"name": "HG00146",
"description": "FASTQ for HG00146",
"fileType": "FASTQ",
"creationTime": "2022-07-13T23:25:20Z",
"files": {
"source1": {
"totalParts": 5,
"partSize": 123456789012,
"contentLength": 6836725,
},
"source2": {
"totalParts": 5,
"partSize": 123456789056,
"contentLength": 6836726
}
},
'creationType": "UPLOAD"
}
```
## Configurar um local de fallback
Ao criar ou atualizar um armazenamento de sequências, você pode configurar um bucket do Amazon S3 como local alternativo para arquivos que falham no upload. As partes do arquivo desses conjuntos de leitura são transferidas para o local de fallback. Os locais alternativos estão disponíveis para lojas de sequências criadas após 15 de maio de 2023.
Crie uma política de bucket do Amazon S3 para conceder acesso de HealthOmics gravação ao local de fallback do Amazon S3, conforme mostrado no exemplo a seguir:
```
{
"Effect": "Allow",
"Principal": {
"Service": "omics.amazonaws.com"
},
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
```
Se o bucket do Amazon S3 para registros de fallback ou de acesso usar uma chave gerenciada pelo cliente, adicione as seguintes permissões à política de chaves:
```
{
"Sid": "Allow use of key",
"Effect": "Allow",
"Principal": {
"Service": "omics.amazonaws.com"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey*"
],
"Resource": "*"
}
```
# Exportação de conjuntos de HealthOmics leitura para um bucket do Amazon S3
Você pode exportar conjuntos de leitura como um trabalho de exportação em lote para um bucket do Amazon S3. Para fazer isso, primeiro crie uma política do IAM que tenha acesso de gravação ao bucket, semelhante ao exemplo de política do IAM a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
------
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"omics.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Depois que a política do IAM estiver em vigor, comece seu trabalho de exportação do conjunto de leitura. O exemplo a seguir mostra como fazer isso usando a operação da API **start-read-set-export-job**. No exemplo a seguir, substitua todos os parâmetros`sequence store ID`, como`destination`,`role ARN`, e`sources`, pela sua entrada.
```
aws omics start-read-set-export-job
--sequence-store-id sequence store id \
--destination valid s3 uri \
--role-arn role ARN \
--sources readSetId=read set id_1 readSetId=read set id_2
```
Você recebe a seguinte resposta com informações sobre o armazenamento da sequência de origem e o bucket Amazon S3 de destino.
```
{
"id": ,
"sequenceStoreId": ,
"destination": ,
"status": "SUBMITTED",
"creationTime": "2022-10-22T01:33:38.079000+00:00"
}
```
Após o início do trabalho, você pode determinar seu status usando a operação da API **get-read-set-export-job**, conforme mostrado a seguir. Substitua o `sequence store ID` e `job ID` por seu ID de armazenamento de sequências e ID do trabalho, respectivamente.
```
aws omics get-read-set-export-job --id job-id --sequence-store-id sequence store ID
```
Você pode visualizar todos os trabalhos de exportação inicializados para um armazenamento de sequências usando a operação da API ** list-read-set-export-jobs**, conforme mostrado a seguir. `sequence store ID`Substitua o pelo seu ID de armazenamento de sequências.
```
aws omics list-read-set-export-jobs --sequence-store-id sequence store ID.
```
```
{
"exportJobs": [
{
"id": ,
"sequenceStoreId": ,
"destination": ,
"status": "COMPLETED",
"creationTime": "2022-10-22T01:33:38.079000+00:00",
"completionTime": "2022-10-22T01:34:28.941000+00:00"
}
]
}
```
Além de exportar seus conjuntos de leitura, você também pode compartilhá-los usando o acesso ao Amazon URIs S3. Para saber mais, consulte [Acessando conjuntos de HealthOmics leitura com o Amazon S3 URIs](s3-access.md).
# Acessando conjuntos de HealthOmics leitura com o Amazon S3 URIs
Você pode usar caminhos de URI do Amazon S3 para acessar seus conjuntos de leitura do armazenamento de sequências ativas.
Com o caminho de URI do Amazon S3, você pode usar as operações do Amazon S3 para listar, compartilhar e baixar seus conjuntos de leitura. O acesso por meio do S3 APIs acelera a colaboração e a integração de ferramentas, já que muitas ferramentas do setor já foram criadas para serem lidas a partir do S3. Além disso, você pode compartilhar o acesso ao S3 APIs com outras contas e fornecer acesso de leitura entre regiões aos dados.
HealthOmics não oferece suporte ao acesso URI do Amazon S3 a conjuntos de leitura arquivados. Quando você ativa um conjunto de leitura, ele é restaurado sempre para o mesmo caminho de URI.
Com os dados carregados nas HealthOmics lojas, como o URI do Amazon S3 é baseado nos pontos de acesso do Amazon S3, você pode se integrar diretamente às ferramentas padrão do setor que leem o Amazon S3, como as URIs seguintes:
+ Aplicativos de análise visual, como o Integrative Genomics Viewer (IGV) ou o UCSC Genome Browser.
+ Fluxos de trabalho comuns com extensões do Amazon S3, como CWL, WDL e Nextflow.
+ Qualquer ferramenta que possa autenticar e ler a partir do ponto de acesso Amazon URIs S3 ou ler o Amazon S3 pré-assinado. URIs
+ Utilitários do Amazon S3, como Mountpoint ou. CloudFront
O Amazon S3 Mountpoint possibilita que você use um bucket do Amazon S3 como um sistema de arquivos local. Para saber mais sobre o Mountpoint e instalá-lo para uso, consulte [Mountpoint para Amazon S3](https://github.com/awslabs/mountpoint-s3).
CloudFront A Amazon é um serviço de rede de entrega de conteúdo (CDN) criado para alto desempenho, segurança e conveniência para desenvolvedores. Para saber mais sobre como usar a Amazon CloudFront, consulte [a CloudFront documentação da Amazon](https://docs.aws.amazon.com/cloudfront/). Para configurar um armazenamento CloudFront de sequências, entre em contato com a AWS HealthOmics equipe.
A conta raiz do proprietário dos dados está habilitada para as ações S3:GetObject, S3: e S3:List Bucket no prefixo de armazenamento de sequência. GetObjectTagging Para que um usuário na conta acesse os dados, você cria uma política do IAM e a anexa ao usuário ou à função. Para visualizar um exemplo de política, consulte [Permissões para acesso a dados usando o Amazon S3 URIs](s3-sharing.md).
Você pode usar as seguintes operações de API do Amazon S3 nos conjuntos de leitura ativos para listar e recuperar seus dados. Você pode acessar conjuntos de leitura arquivados por meio do Amazon URIs S3 depois que eles forem ativados.
+ [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)— Recupera um objeto do Amazon S3.
+ [HeadObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html.html)— A operação HEAD recupera metadados de um objeto sem retornar o objeto em si. Essa operação é útil se você quiser apenas os metadados de um objeto.
+ [ListObjects e ListObject v2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html) — Retorna alguns ou todos (até 1.000) dos objetos em um bucket.
+ [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)— Cria uma cópia de um objeto que já está armazenado no Amazon S3. HealthOmicssuporta a cópia em um ponto de acesso do Amazon S3, mas não a gravação em um ponto de acesso.
HealthOmics os armazenamentos de sequências mantêm a identidade semântica dos arquivos por meio ETags de. Durante todo o ciclo de vida de um arquivo, o Amazon ETag S3, que é baseado na identidade bit a bit, pode mudar, HealthOmics ETag mas permanece o mesmo. Para saber mais, consulte [HealthOmics ETags e proveniência dos dados](etags-and-provenance.md).
**Topics**
+ [Estrutura de URI do Amazon S3 em armazenamento HealthOmics](#s3-uri-structure)
+ [Usando IGV hospedado ou local para acessar conjuntos de leitura](#s3-access-igv)
+ [Usando Samtools ou HTSlib em HealthOmics](#s3-access-Samtools)
+ [Usando Mountpoint HealthOmics](#s3-access-Mountpoint)
+ [Usando CloudFront com HealthOmics](#s3-access-CloudFront)
## Estrutura de URI do Amazon S3 em armazenamento HealthOmics
Todos os arquivos com o Amazon S3 URIs têm tags `omics:subjectId` de `omics:sampleId` recursos. Você pode usar essas tags para compartilhar o acesso usando políticas do IAM por meio de um padrão como`"s3:ExistingObjectTag/omics:subjectId": "pattern desired"`.
A estrutura do arquivo é a seguinte:
`.../account_id/sequenceStore/seq_store_id/readSet/read_set_id/files.`
Para arquivos importados para armazenamentos de sequências do Amazon S3, o armazenamento de sequências tenta manter o nome da fonte original. Quando os nomes entram em conflito, o sistema anexa as informações do conjunto de leitura para garantir que os nomes dos arquivos sejam exclusivos. Por exemplo, para conjuntos de leitura fastq, se os dois nomes de arquivo forem iguais, para tornar os nomes exclusivos, `sourceX` é inserido antes de .fastq.gz ou .fq.gz. Para um upload direto, os nomes dos arquivos seguem os seguintes padrões:
+ Para FASTQ— *read\$1set\$1name* \$1 .fastq.gz *sourcex*
+ Para uBAM/BAM/CRAM —*read\$1set\$1name*. *file extension*com extensões de `.bam` ou`.cram`. Um exemplo é `NA193948.bam`.
Para conjuntos de leitura que são BAM ou CRAM, os arquivos de índice são gerados automaticamente durante o processo de ingestão. Para os arquivos de índice gerados, a extensão de índice adequada no final do nome do arquivo é aplicada. Tem o padrão *..* As extensões do índice são `.bai` ou`.crai`.
## Usando IGV hospedado ou local para acessar conjuntos de leitura
IGV é um navegador de genoma usado para analisar arquivos BAM e CRAM. Ele requer o arquivo e o índice porque exibe apenas uma parte do genoma por vez. O IGV pode ser baixado e usado localmente, e há guias para criar um IGV hospedado na AWS. A versão pública da web não é suportada porque requer CORS.
O IGV local depende da AWS configuração local para acessar arquivos. Certifique-se de que a função usada nessa configuração tenha uma política anexada que habilite as GetObject permissões kms: Decrypt e s3: para o URI s3 dos conjuntos de leitura que estão sendo acessados. Depois disso, no IGV, você pode usar “Arquivo > carregar do URL” e colar o URI da fonte e do índice. Como alternativa, o presigned URLs pode ser gerado e usado da mesma maneira, o que ignorará a configuração da AWS. Observe que o CORS não é compatível com o acesso ao URI do Amazon S3, portanto, solicitações que dependem do CORS não são suportadas.
O exemplo do AWS Hosted IGV depende do AWS Cognito para criar as configurações e permissões corretas dentro do ambiente. Certifique-se de que seja criada uma política que habilite as permissões KMS:DECRYPT e s3: GetObject para o URI do Amazon S3 dos conjuntos de leitura que estão sendo acessados e adicione essa política à função atribuída ao grupo de usuários do Cognito. Depois disso, no IGV, você pode usar “Arquivo > carregar do URL” e inserir o URI da fonte e do índice. Como alternativa, o presigned URLs pode ser gerado e usado da mesma maneira, o que ignora a configuração da AWS.
Observe que o armazenamento de sequências não aparecerá na guia “Amazon” porque ela exibe apenas buckets de sua propriedade na região em que o AWS perfil está configurado.
## Usando Samtools ou HTSlib em HealthOmics
HTSlib é a biblioteca principal compartilhada por várias ferramentas, como Samtools, RSAMtools e outras. PySam Use a HTSlib versão 1.20 ou posterior para obter suporte contínuo para pontos de acesso do Amazon S3. Para versões mais antigas da HTSlib biblioteca, você pode usar as seguintes soluções alternativas:
+ Defina a variável de ambiente para o host HTS Amazon S3 com:. `export HTS_S3_HOST="s3.region.amazonaws.com"`
+ Gere uma URL pré-assinada para os arquivos que você deseja usar. Se um BAM ou CRAM estiver sendo usado, certifique-se de que um URL pré-assinado seja gerado tanto para o arquivo quanto para o índice. Depois disso, os dois arquivos podem ser usados com as bibliotecas.
+ Use Mountpoint para montar o armazenamento de sequências ou ler o prefixo do conjunto no mesmo ambiente em que você está usando bibliotecas. HTSlib A partir daqui, os arquivos podem ser acessados usando caminhos de arquivo locais.
## Usando Mountpoint HealthOmics
O Mountpoint for Amazon S3 é um cliente de arquivos simples e de alto rendimento para montar [um bucket do Amazon S3 como um sistema de arquivos local](https://aws.amazon.com/blogs/storage/the-inside-story-on-mountpoint-for-amazon-s3-a-high-performance-open-source-file-client/). Com o Mountpoint for Amazon S3, seus aplicativos podem acessar objetos armazenados no Amazon S3 por meio de operações de arquivo, como abrir e ler. O Mountpoint for Amazon S3 traduz automaticamente essas operações em chamadas de API de objetos do Amazon S3, dando aos seus aplicativos acesso ao armazenamento elástico e à taxa de transferência do Amazon S3 por meio de uma interface de arquivo.
O Mountpoint pode ser instalado usando as instruções de instalação [do Mountpoint](https://github.com/awslabs/mountpoint-s3/blob/main/doc/INSTALL.md). O Mountpoint usa o perfil da AWS que é local para a instalação e funciona em um nível de prefixo do Amazon S3. Certifique-se de que o perfil que está sendo usado tenha uma política que habilite as permissões s3:GetObject, s3: ListBucket e kms: Decrypt para o prefixo URI do Amazon S3 do (s) conjunto (s) de leitura ou armazenamento de sequências que está sendo acessado. Depois disso, o bucket pode ser montado usando o seguinte caminho:
```
mount-s3 access point arn local path to mount --prefix prefix to sequence store or read set --region region
```
## Usando CloudFront com HealthOmics
CloudFront A Amazon é um serviço de rede de entrega de conteúdo (CDN) criado para oferecer alto desempenho, segurança e conveniência para desenvolvedores. Os clientes que desejam usar CloudFront devem trabalhar com a equipe de serviços para ativar a CloudFront distribuição. Trabalhe com sua equipe de contas para engajar a equipe HealthOmics de atendimento.
# Ativando conjuntos de leitura em HealthOmics
Você pode ativar conjuntos de leitura que são arquivados com a operação da API **start-read-set-activation-job** ou por meio do AWS CLI, conforme mostrado no exemplo a seguir. Substitua o `sequence store ID` e `read set id` pelo ID do armazenamento de sequências e pelo conjunto de leitura IDs.
```
aws omics start-read-set-activation-job
--sequence-store-id sequence store ID \
--sources readSetId=read set ID readSetId=read set id_1 read set id_2
```
Você recebe uma resposta que contém as informações do trabalho de ativação, conforme mostrado a seguir.
```
{
"id": "12345678",
"sequenceStoreId": "1234567890",
"status": "SUBMITTED",
"creationTime": "2022-10-22T00:50:54.670000+00:00"
}
```
Depois que o trabalho de ativação for iniciado, você poderá monitorar seu progresso com a operação da API **get-read-set-activation-job**. Veja a seguir um exemplo de como usar o AWS CLI para verificar o status do seu trabalho de ativação. Substitua `job ID` e `sequence store ID` por seu ID de armazenamento de sequências e trabalho IDs, respectivamente.
```
aws omics get-read-set-activation-job --id job ID --sequence-store-id sequence store ID
```
A resposta resume o trabalho de ativação, conforme mostrado a seguir.
```
{
"id": 123567890,
"sequenceStoreId": 123467890,
"status": "SUBMITTED",
"statusUpdateReason": "The job is submitted and will start soon.",
"creationTime": "2022-10-22T00:50:54.670000+00:00",
"sources": [
{
"readSetId": ,
"status": "NOT_STARTED",
"statusUpdateReason": "The source is queued for the job."
},
{
"readSetId": ,
"status": "NOT_STARTED",
"statusUpdateReason": "The source is queued for the job."
}
]
}
```
Você pode verificar o status de um trabalho de ativação com a operação **get-read-set-metadata**da API. Os status possíveis são `ACTIVE``ACTIVATING`, e. `ARCHIVED` No exemplo a seguir, `sequence store ID` substitua pela ID do armazenamento de sequências e `read set ID` substitua pela ID do conjunto de leitura.
```
aws omics get-read-set-metadata --sequence-store-id sequence store ID --id read set ID
```
A resposta a seguir mostra que o conjunto de leitura está ativo.
```
{
"id": "12345678",
"arn": "arn:aws:omics:us-west-2:555555555555:sequenceStore/1234567890/readSet/12345678",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00100",
"description": "HG00100 aligned to HG38 BAM",
"fileType": "BAM",
"creationTime": "2022-07-13T23:25:20Z",
"sequenceInformation": {
"totalReadCount": 1513467,
"totalBaseCount": 163454436,
"generatedFrom": "Pulled from SRA",
"alignment": "ALIGNED"
},
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"files": {
"source1": {
"totalParts": 2,
"partSize": 10485760,
"contentLength": 17112283,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
},
"index": {
"totalParts": 1,
"partSize": 53216,
"contentLength": 10485760
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
}
},
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "d1d65429212d61d115bb19f510d4bd02"
}
}
```
Você pode visualizar todos os trabalhos de ativação do conjunto de leitura usando **list-read-set-activation-jobs**, conforme mostrado no exemplo a seguir. No exemplo a seguir, `sequence store ID` substitua pelo seu ID de armazenamento de sequências.
```
aws omics list-read-set-activation-jobs --sequence-store-id sequence store ID
```
Você recebe a seguinte resposta.
```
{
"activationJobs": [
{
"id": 1234657890,
"sequenceStoreId": "1234567890",
"status": "COMPLETED",
"creationTime": "2022-10-22T01:33:38.079000+00:00",
"completionTime": "2022-10-22T01:34:28.941000+00:00"
}
]
}
```