AWS HealthOmics les magasins de variantes et les magasins d'annotations ne seront plus ouverts aux nouveaux clients à compter du 7 novembre 2025. Si vous souhaitez utiliser des magasins de variantes ou des magasins d'annotations, inscrivez-vous avant cette date. Les clients existants peuvent continuer à utiliser le service normalement. Pour plus d'informations, voir Modification de la disponibilité du magasin de AWS HealthOmics variantes et du magasin d'annotations.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations

Après mûre réflexion, nous avons décidé de fermer les magasins de AWS HealthOmics variantes et les magasins d'annotations aux nouveaux clients à compter du 7 novembre 2025. Si vous souhaitez utiliser les magasins de variantes et les magasins d'annotations, inscrivez-vous avant cette date. Les clients existants peuvent continuer à utiliser le service normalement.

La section suivante décrit les options de migration qui vous aideront à déplacer vos magasins de variantes et vos magasins d'analyse vers de nouvelles solutions. Pour toute question ou préoccupation, créez un dossier d'assistance sur support.console.aws.amazon.com.

Vue d'ensemble des options de migration

Les options de migration suivantes constituent une alternative à l'utilisation de magasins de variantes et de magasins d'annotations :

Options de migration pour la logique ETL

Envisagez les options de migration suivantes pour la logique ETL :

Options de migration pour le stockage

En remplacement du magasin de données hébergé par un service, vous pouvez utiliser des compartiments de table Amazon S3 pour définir un schéma de table personnalisé. Pour plus d'informations sur les compartiments de table, consultez les compartiments de table dans le guide de l'utilisateur Amazon S3.

Vous pouvez utiliser des compartiments de table pour les tables Iceberg entièrement gérées dans Amazon S3.

Vous pouvez présenter un dossier d'assistance pour demander à l' HealthOmics équipe de migrer les données de votre magasin de variantes ou d'annotations vers le compartiment de table Amazon S3 que vous avez configuré.

Une fois que vos données sont renseignées dans le compartiment de table Amazon S3, vous pouvez supprimer vos magasins de variantes et vos magasins d'annotations. Pour plus d'informations, consultez la section Suppression de magasins HealthOmics d'analyses.

Analyse

Pour l'analyse des données, continuez à utiliser des services AWS d'analyse tels qu'Amazon Athena, Amazon EMR, AmazonRedshift ou Amazon Quick Suite.

AWS Les partenaires

Vous pouvez travailler avec un AWS partenaire qui fournit un ETL personnalisable, des schémas de table, des outils de requête et d'analyse intégrés, ainsi que des interfaces utilisateur pour interagir avec les données.

Exemples

Les exemples suivants montrent comment créer des tables adaptées au stockage de données VCF et GVCF.

Athéna DDL

Vous pouvez utiliser l'exemple DDL suivant dans Athena pour créer une table adaptée au stockage des données VCF et GVCF dans une seule table. Cet exemple n'est pas l'équivalent exact de la structure de magasin variant, mais il fonctionne bien pour un cas d'utilisation générique.

Créez vos propres valeurs pour DATABASE_NAME et TABLE_NAME lorsque vous créez la table.

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

Création de tables en Python (sans Athena)

L'exemple de code Python suivant montre comment créer les tables sans utiliser 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)