AWS HealthOmics lojas variantes e lojas de anotações não estarão mais abertas a novos clientes a partir de 7 de novembro de 2025. Se você quiser usar lojas de variantes ou lojas de anotações, cadastre-se antes dessa data. Os clientes existentes podem continuar usando o serviço normalmente. Para obter mais informações, consulte Alteração de disponibilidade da loja de AWS HealthOmics variantes e da loja de anotações.

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á.

AWS HealthOmics alteração na disponibilidade da loja de variantes e da loja de anotações

Após uma análise cuidadosa, decidimos fechar lojas de AWS HealthOmics variantes e lojas de anotações para novos clientes a partir de 7 de novembro de 2025. Se você quiser usar lojas de variantes e lojas de anotações, cadastre-se antes dessa data. Os clientes existentes podem continuar usando o serviço normalmente.

A seção a seguir descreve as opções de migração para ajudar você a migrar seus repositórios de variantes e de análises para novas soluções. Para qualquer dúvida ou preocupação, crie um caso de suporte em support.console.aws.amazon.com.

Visão geral das opções de migração

As opções de migração a seguir oferecem uma alternativa ao uso de armazenamentos de variantes e de anotações:

Opções de migração para a lógica ETL

Considere as seguintes opções de migração para a lógica ETL:

Opções de migração para armazenamento

Como substituto do armazenamento de dados hospedado em serviços, você pode usar buckets de tabela do Amazon S3 para definir um esquema de tabela personalizado.Para obter mais informações sobre compartimentos de tabela, consulte Buquetes de tabela no Guia do usuário do Amazon S3.

Você pode usar baldes de mesa para tabelas Iceberg totalmente gerenciadas no Amazon S3.

Você pode criar um caso de suporte para solicitar que a HealthOmics equipe migre os dados do seu armazenamento de variantes ou anotações para o bucket de tabelas do Amazon S3 que você configurou.

Depois que seus dados forem preenchidos no bucket de tabelas do Amazon S3, você poderá excluir seus armazenamentos de variantes e de anotações. Para obter mais informações, consulte Excluindo lojas de HealthOmics análise.

Analytics

Para análise de dados, continue usando serviços de AWS análise, como Amazon Athena, Amazon EMR, Amazon Redshift ou Amazon Quick Suite.

AWS Parceiros

Você pode trabalhar com um AWS parceiro que fornece ETL personalizável, esquemas de tabela, ferramentas integradas de consulta e análise e interfaces de usuário para interagir com dados.

Exemplos

Os exemplos a seguir mostram como criar tabelas adequadas para armazenar dados VCF e GVCF.

Athena DDL

Você pode usar o exemplo de DDL a seguir no Athena para criar uma tabela adequada para armazenar dados VCF e GVCF em uma única tabela. Esse exemplo não é o equivalente exato da estrutura de armazenamento de variantes, mas funciona bem para um caso de uso genérico.

Crie seus próprios valores para DATABASE_NAME e TABLE_NAME ao criar a tabela.

 CREATE TABLE <DATABASE_NAME>. <TABLE_NAME> (
  sample_name string,
  variant_name string COMMENT 'The ID field in VCF files, '.' indicates no name',
  chrom string,
  pos bigint,
  ref string,
  alt array <string>,
  qual double,
  filter string,
  genotype string,
  info map <string, string>,
  attributes map <string, string>,
  is_reference_block boolean COMMENT 'Used in GVCF for non-variant sites')
PARTITIONED BY (bucket(128, sample_name), chrom)
LOCATION '{URL}/'
TBLPROPERTIES (
  'table_type'='iceberg',
  'write_compression'='zstd'
);    
      

Crie tabelas usando Python (sem Athena)

O exemplo de código Python a seguir mostra como criar as tabelas sem usar o Athena.

 import boto3
from pyiceberg.catalog import Catalog, load_catalog
from pyiceberg.schema import Schema
from pyiceberg.table import Table
from pyiceberg.table.sorting import SortOrder, SortField, SortDirection, NullOrder
from pyiceberg.partitioning import PartitionSpec, PartitionField
from pyiceberg.transforms import IdentityTransform, BucketTransform
from pyiceberg.types import (
    NestedField,
    StringType,
    LongType,
    DoubleType,
    MapType,
    BooleanType,
    ListType
)


def load_s3_tables_catalog(bucket_arn: str) -> Catalog:
    session = boto3.session.Session()
    region = session.region_name or 'us-east-1'
    
    catalog_config = {
        "type": "rest",
        "warehouse": bucket_arn,
        "uri": f"https://s3tables.{region}.amazonaws.com/iceberg",
        "rest.sigv4-enabled": "true",
        "rest.signing-name": "s3tables",
        "rest.signing-region": region
    }
    
    return load_catalog("s3tables", **catalog_config)


def create_namespace(catalog: Catalog, namespace: str) -> None:
    try:
        catalog.create_namespace(namespace)
        print(f"Created namespace: {namespace}")
    except Exception as e:
        if "already exists" in str(e):
            print(f"Namespace {namespace} already exists.")
        else:
            raise e


def create_table(catalog: Catalog, namespace: str, table_name: str, schema: Schema, 
                partition_spec: PartitionSpec = None, sort_order: SortOrder = None) -> Table:
    if catalog.table_exists(f"{namespace}.{table_name}"):
        print(f"Table {namespace}.{table_name} already exists.")
        return catalog.load_table(f"{namespace}.{table_name}")
    
    create_table_args = {
        "identifier": f"{namespace}.{table_name}",
        "schema": schema,
        "properties": {"format-version": "2"}
    }
    
    if partition_spec is not None:
        create_table_args["partition_spec"] = partition_spec
    if sort_order is not None:
        create_table_args["sort_order"] = sort_order
    
    table = catalog.create_table(**create_table_args)
    print(f"Created table: {namespace}.{table_name}")
    return table


def main(bucket_arn: str, namespace: str, table_name: str):
    # Schema definition
    genomic_variants_schema = Schema(
        NestedField(1, "sample_name", StringType(), required=True),
        NestedField(2, "variant_name", StringType(), required=True),
        NestedField(3, "chrom", StringType(), required=True),
        NestedField(4, "pos", LongType(), required=True),
        NestedField(5, "ref", StringType(), required=True),
        NestedField(6, "alt", ListType(element_id=1000, element_type=StringType(), element_required=True), required=True),
        NestedField(7, "qual", DoubleType()),
        NestedField(8, "filter", StringType()),
        NestedField(9, "genotype", StringType()),
        NestedField(10, "info", MapType(key_type=StringType(), key_id=1001, value_type=StringType(), value_id=1002)),
        NestedField(11, "attributes", MapType(key_type=StringType(), key_id=2001, value_type=StringType(), value_id=2002)),
        NestedField(12, "is_reference_block", BooleanType()),
        identifier_field_ids=[1, 2, 3, 4]
    )
    
    # Partition and sort specifications
    partition_spec = PartitionSpec(
        PartitionField(source_id=1, field_id=1001, transform=BucketTransform(128), name="sample_bucket"),
        PartitionField(source_id=3, field_id=1002, transform=IdentityTransform(), name="chrom")
    )
    
    sort_order = SortOrder(
        SortField(source_id=3, transform=IdentityTransform(), direction=SortDirection.ASC, null_order=NullOrder.NULLS_LAST),
        SortField(source_id=4, transform=IdentityTransform(), direction=SortDirection.ASC, null_order=NullOrder.NULLS_LAST)
    )
    
    # Connect to catalog and create table
    catalog = load_s3_tables_catalog(bucket_arn)
    create_namespace(catalog, namespace)
    table = create_table(catalog, namespace, table_name, genomic_variants_schema, partition_spec, sort_order)
    
    return table


if __name__ == "__main__":
    bucket_arn = 'arn:aws:s3tables:<REGION>:<ACCOUNT_ID>:bucket/<TABLE_BUCKET_NAME'
    namespace = "variant_db"
    table_name = "genomic_variants"
    
    main(bucket_arn, namespace, table_name)