AWS HealthOmics Variant Stores und Annotation Stores werden ab dem 7. November 2025 nicht mehr für Neukunden geöffnet sein. Wenn Sie Variantenspeicher oder Annotationsspeicher nutzen möchten, melden Sie sich vor diesem Datum an. Bestandskunden können den Service weiterhin wie gewohnt nutzen. Weitere Informationen finden Sie unter Änderung der Verfügbarkeit von AWS HealthOmics Variant Store und Annotation Store.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

AWS HealthOmics Änderung der Verfügbarkeit von Variantenspeicher und Annotationsspeicher

Nach reiflicher Überlegung haben wir beschlossen, AWS HealthOmics Variantengeschäfte und Annotations-Stores ab dem 7. November 2025 für Neukunden zu schließen. Wenn Sie Variantenspeicher und Annotationsspeicher nutzen möchten, melden Sie sich vor diesem Datum an. Bestandskunden können den Service weiterhin wie gewohnt nutzen.

Im folgenden Abschnitt werden Migrationsoptionen beschrieben, mit denen Sie Ihre Variantenshops und Analytics-Stores auf neue Lösungen umstellen können. Wenn Sie Fragen oder Bedenken haben, erstellen Sie unter support.console.aws.amazon.com eine Support-Anfrage.

Überblick über die Migrationsoptionen

Die folgenden Migrationsoptionen bieten eine Alternative zur Verwendung von Variantenspeichern und Annotationsspeichern:

Migrationsoptionen für ETL-Logik

Beachten Sie die folgenden Migrationsoptionen für die ETL-Logik:

Migrationsoptionen für Speicher

Als Ersatz für einen vom Service gehosteten Datenspeicher können Sie Amazon S3 S3-Tabellen-Buckets verwenden, um ein benutzerdefiniertes Tabellenschema zu definieren. Weitere Informationen zu Tabellen-Buckets finden Sie unter Tabellen-Buckets im Amazon S3 S3-Benutzerhandbuch.

Sie können Tabellen-Buckets für vollständig verwaltete Iceberg-Tabellen in Amazon S3 verwenden.

Sie können eine Support-Anfrage stellen und das HealthOmics Team bitten, die Daten aus Ihrem Varianten- oder Annotationsspeicher in den von Ihnen konfigurierten Amazon S3 S3-Tabellen-Bucket zu migrieren.

Nachdem Ihre Daten in den Amazon S3 S3-Tabellen-Bucket gefüllt wurden, können Sie Ihre Variantenspeicher und Annotationsspeicher löschen. Weitere Informationen finden Sie unter HealthOmics Analytics-Stores löschen.

Analysen

Verwenden Sie für Datenanalysen weiterhin AWS Analysedienste wie Amazon Athena, Amazon EMR, Amazon Redshift oder Amazon Quick Suite.

AWS Partner

Sie können mit einem AWS Partner zusammenarbeiten, der anpassbares ETL, Tabellenschemas, integrierte Abfrage- und Analysetools sowie Benutzeroberflächen für die Interaktion mit Daten bereitstellt.

Beispiele

Die folgenden Beispiele zeigen, wie Sie Tabellen erstellen, die sich zum Speichern von VCF- und GVCF-Daten eignen.

Athena DDL

Sie können das folgende DDL-Beispiel in Athena verwenden, um eine Tabelle zu erstellen, die zum Speichern von VCF- und GVCF-Daten in einer einzigen Tabelle geeignet ist. Dieses Beispiel entspricht nicht exakt der Variantenspeicherstruktur, eignet sich aber gut für einen generischen Anwendungsfall.

Erstellen Sie Ihre eigenen Werte für DATABASE_NAME und TABLE_NAME, wenn Sie die Tabelle erstellen.

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

Erstellen Sie Tabellen mit Python (ohne Athena)

Das folgende Python-Codebeispiel zeigt, wie die Tabellen ohne Verwendung von Athena erstellt werden.

 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)