Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

AWS HealthOmics modifica della disponibilità dell'archivio delle varianti e dell'archivio delle annotazioni

Dopo un'attenta valutazione, abbiamo deciso di chiudere i negozi di AWS HealthOmics varianti e i negozi di annotazioni a nuovi clienti a partire dal 7 novembre 2025. I clienti esistenti possono continuare a utilizzare il servizio normalmente.

La sezione seguente descrive le opzioni di migrazione per aiutarti a spostare i tuoi negozi di varianti e i negozi di analisi verso nuove soluzioni. Per qualsiasi domanda o dubbio, crea una richiesta di supporto all'indirizzo support.console.aws.amazon.com.

Panoramica delle opzioni di migrazione

Le seguenti opzioni di migrazione offrono un'alternativa all'utilizzo degli archivi di varianti e degli archivi di annotazioni:

Opzioni di migrazione per la logica ETL

Considerate le seguenti opzioni di migrazione per la logica ETL:

Opzioni di migrazione per lo storage

In sostituzione dell'archivio dati ospitato nel servizio, puoi utilizzare i bucket di tabella Amazon S3 per definire uno schema di tabella personalizzato. Per ulteriori informazioni sui table bucket, consulta Table bucket nella Amazon S3 User Guide.

Puoi usare i table bucket per tabelle Iceberg completamente gestite in Amazon S3.

Puoi presentare una richiesta di supporto per richiedere al HealthOmics team di migrare i dati dalla tua variante o dall'archivio di annotazioni al bucket di tabelle Amazon S3 che hai configurato.

Dopo aver inserito i dati nel bucket di tabelle Amazon S3, puoi eliminare gli archivi di varianti e gli archivi di annotazioni. Per ulteriori informazioni, consulta Eliminazione degli archivi di analisi. HealthOmics

Analisi

Per l'analisi dei dati, continua a utilizzare servizi di AWS analisi come Amazon Athena, Amazon EMR, Amazon Redshift o Amazon Quick Suite.

AWS Partner

Puoi collaborare con un AWS partner che fornisce ETL personalizzabili, schemi di tabelle, strumenti di query e analisi integrati e interfacce utente per l'interazione con i dati.

Esempi

Gli esempi seguenti mostrano come creare tabelle adatte alla memorizzazione di dati VCF e GVCF.

Athena DDL

È possibile utilizzare il seguente esempio DDL in Athena per creare una tabella adatta alla memorizzazione di dati VCF e GVCF in un'unica tabella. Questo esempio non è l'esatto equivalente della struttura dell'archivio delle varianti, ma funziona bene per un caso d'uso generico.

Crea i tuoi valori per DATABASE_NAME e TABLE_NAME quando crei la tabella.

 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'
);    
      

Crea tabelle usando Python (senza Athena)

Il seguente esempio di codice Python mostra come creare le tabelle senza usare 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)