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.
# HealthOmics analyses
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
HealthOmics analytics prend en charge le stockage et l'analyse des variantes génomiques et des annotations. Analytics fournit deux types de ressources de stockage : les magasins de variantes et les magasins d'annotations. Vous utilisez ces ressources pour stocker, transformer et interroger des données de variants génomiques et des données d'annotation. Après avoir importé des données dans une banque de données, vous pouvez utiliser Athena pour effectuer des analyses avancées sur les données.
Vous pouvez utiliser la HealthOmics console ou l'API pour créer et gérer des boutiques, importer des données et partager des données analytiques de boutique avec des collaborateurs.
Variant stocke les données de support au format VCF, tandis que les annotations stockent le support TSV/CSV et les GFF3 formats. Les coordonnées génomiques sont représentées sous forme d'intervalles de base zéro, semi-fermés, semi-ouverts. Lorsque vos données se trouvent dans le magasin de données HealthOmics d'analyse, l'accès aux fichiers VCF est géré via AWS Lake Formation. Vous pouvez ensuite interroger les fichiers VCF à l'aide d'Amazon Athena. Les requêtes doivent utiliser le moteur de requêtes Athena version 3. Pour en savoir plus sur les versions du moteur de requête Athena, consultez la documentation [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/engine-versions-changing.html).
**Topics**
+ [Création de boutiques de HealthOmics variantes](creating-variant-stores.md)
+ [Création de tâches d'importation de magasins de HealthOmics variantes](parsing-annotation-stores.md)
+ [Création de magasins HealthOmics d'annotations](creating-and-managing-annotation-store.md)
+ [Création de tâches d'importation pour les magasins HealthOmics d'annotations](annotation-store-import-jobs.md)
+ [Création de versions de magasin HealthOmics d'annotations](annotation-store-versioning.md)
+ [Supprimer des magasins HealthOmics d'analyse](deleting-a-store-examples.md)
+ [Interrogation de HealthOmics données analytiques](analytics-query-data.md)
+ [Partage de magasins HealthOmics d'analyse](cross-account-sharing.md)
# Création de boutiques de HealthOmics variantes
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
Les rubriques suivantes décrivent comment créer des magasins de HealthOmics variantes à l'aide de la console et de l'API.
**Topics**
+ [Création d'un magasin de variantes à l'aide de la console](#gs-console-analytics)
+ [Création d'un magasin de variantes à l'aide de l'API](#gs-api-analytics)
## Création d'un magasin de variantes à l'aide de la console
Vous pouvez créer un magasin de variantes à l'aide de la HealthOmics console.
1. Ouvrez la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Si nécessaire, ouvrez le volet de navigation de gauche (≡). Choisissez **Variant stores**.
1. Sur la page **Créer un magasin de variantes**, fournissez les informations suivantes
+ **Variante du nom de la boutique** : nom unique pour cette boutique.
+ **Description** (facultatif) : description de ce magasin de variantes.
+ **Génome de référence** - Le génome de référence pour cette banque de variants.
+ **Chiffrement des données** - Choisissez si vous souhaitez que le chiffrement des données soit détenu et géré par vous-même AWS ou par vous-même.
+ **Balises** (facultatif) - Fournissez jusqu'à 50 balises pour cette variante de boutique.
1. Choisissez **Créer un magasin de variantes**.
## Création d'un magasin de variantes à l'aide de l'API
Utilisez le fonctionnement de l' HealthOmics `CreateVariantStore`API pour créer des magasins de variantes. Vous pouvez également effectuer cette opération avec le AWS CLI.
Pour créer un magasin de variantes, vous devez fournir un nom au magasin et l'ARN d'un magasin de référence. Le magasin de variantes est prêt à ingérer des données lorsque son statut passe à READY.
L'exemple suivant utilise le AWS CLI pour créer un magasin de variantes.
```
aws omics create-variant-store --name myvariantstore \
--reference referenceArn="arn:aws:omics:us-west-2:555555555555:referenceStore/123456789/reference/5987565360"
```
Pour confirmer la création de votre boutique de variantes, vous recevez la réponse suivante.
```
{
"creationTime": "2022-11-03T18:19:52.296368+00:00",
"id": "45aeb91d5678",
"name": "myvariantstore",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/123456789/reference/5987565360"
},
"status": "CREATING"
}
```
Pour en savoir plus sur un magasin de variantes, utilisez l'**get-variant-store**API.
```
aws omics get-variant-store --name myvariantstore
```
Vous recevez la réponse suivante.
```
{
"id": "45aeb91d5678",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/123456789/reference/5987565360"
},
"status": "ACTIVE",
"storeArn": "arn:aws:omics:us-west-2:555555555555:variantStore/myvariantstore",
"name": "myvariantstore",
"creationTime": "2022-11-03T18:19:52.296368+00:00",
"updateTime": "2022-11-03T18:30:56.272792+00:00",
"tags": {},
"storeSizeBytes": 0
}
```
Pour afficher toutes les variantes de magasins associées à un compte, utilisez l'**list-variant-stores**API.
```
aws omics list-variant-stores
```
Vous recevez une réponse répertoriant toutes les variantes de magasins, ainsi que leurs IDs statuts et autres informations, comme indiqué dans l'exemple de réponse suivant.
```
{
"variantStores": [
{
"id": "45aeb91d5678",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:55555555555:referenceStore/5506874698"
},
"status": "ACTIVE",
"storeArn": "arn:aws:omics:us-west-2:55555555555:variantStore/new_variant_store",
"name": "variantstore",
"creationTime": "2022-11-03T18:19:52.296368+00:00",
"updateTime": "2022-11-03T18:30:56.272792+00:00",
"statusMessage": "",
"storeSizeBytes": 141526
}
]
}
```
Vous pouvez également filtrer les réponses pour l'**list-variant-stores**API en fonction des statuts ou d'autres critères.
Les fichiers VCF importés dans des magasins d'analyse créés le 15 mai 2023 ou après cette date ont défini des schémas pour les annotations VEP (Variant Effect Predictor). Cela facilite l'interrogation et l'analyse des données VCF importées. La modification n'a aucun impact sur les magasins créés avant le 15 mai 2023, sauf si le `annotation fields` paramètre est inclus dans l'appel d'API ou de CLI. Pour ces magasins, l'utilisation du `annotation fields` paramètre entraînera l'échec de la demande.
# Création de tâches d'importation de magasins de HealthOmics variantes
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
L'exemple suivant montre comment utiliser le AWS CLI pour créer une tâche d'importation pour un magasin de variantes.
```
aws omics start-variant-import-job \
--destination-name myvariantstore \
--runLeftNormalization false \
--role-arn arn:aws:iam::55555555555:role/roleName \
--items source=s3://my-omics-bucket/sample.vcf.gz source=s3://my-omics-bucket/sample2.vcf.gz
```
```
{
"destinationName": "store_a",
"roleArn": "....",
"runLeftNormalization": false,
"items": [
{"source": "s3://my-omics-bucket/sample.vcf.gz"},
{"source": "s3://my-omics-bucket/sample2.vcf.gz"}
]
}
```
Pour les boutiques créées après le 15 mai 2023, l'exemple suivant montre comment ajouter le `--annotation-fields` paramètre. Les champs d'annotation sont définis lors de l'importation.
```
aws omics start-variant-import-job \
--destination-name annotationparsingvariantstore \
--role-arn arn:aws:iam::123456789012:role/ \
--items source=s3://pathToS3/sample.vcf
--annotation-fields '{"VEP": "CSQ"}'
```
```
{
"jobId": "981e2286-e954-4391-8a97-09aefc343861"
}
```
**get-variant-import-job**À utiliser pour vérifier le statut.
```
aws omics get-variant-import-job --job-id 08279950-a9e3-4cc3-9a3c-a574f9c9e229
```
Vous recevrez une réponse JSON indiquant le statut de votre tâche d'importation. Les annotations VEP dans le VCF sont analysées pour les informations stockées dans la colonne INFO sous forme de paire. ID/Value L'ID par défaut pour la colonne INFO des annotations d'[Ensembl Variant Effect Predictor](https://useast.ensembl.org/info/docs/tools/vep/index.html/#vcf) est CSQ, mais vous pouvez utiliser le `--annotation-fields` paramètre pour indiquer une valeur personnalisée utilisée dans la colonne INFO. L'analyse syntaxique est actuellement prise en charge pour les annotations VEP.
Pour une boutique créée avant le 15 mai 2023 ou pour les fichiers VCF qui n'incluent pas d'annotation VEP, la réponse n'inclut aucun champ d'annotation.
```
{
"creationTime": "2023-04-11T17:52:37.241958+00:00",
"destinationName": "annotationparsingvariantstore",
"id": "7a1c67e3-b7f9-434d-817b-9c571fd63bea",
"items": [
{
"jobStatus": "COMPLETED",
"source": "s3://amzn-s3-demo-bucket/NA12878.2k.garvan.vcf"
}
],
"roleArn": "arn:aws:iam::555555555555:role/",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T17:58:22.676043+00:00",
}
```
Les annotations VEP qui font partie des fichiers VCF sont stockées sous forme de schéma prédéfini avec la structure suivante. Le champ extras peut être utilisé pour stocker tous les champs VEP supplémentaires qui ne sont pas inclus dans le schéma par défaut.
```
annotations struct<
vep: array,
impact:string,
symbol:string,
gene:string,
`feature_type`: string,
feature: string,
biotype: string,
exon: struct,
intron: struct,
hgvsc: string,
hgvsp: string,
`cdna_position`: string,
`cds_position`: string,
`protein_position`: string,
`amino_acids`: struct,
codons: struct,
`existing_variation`: array,
distance: string,
strand: string,
flags: array,
symbol_source: string,
hgnc_id: string,
`extras`: map
>>
>
```
L'analyse est effectuée selon une approche basée sur le meilleur effort. Si l'entrée VEP ne respecte pas les [spécifications standard VEP](https://useast.ensembl.org/info/docs/tools/vep/vep_formats.html#vcf), elle ne sera pas analysée et la ligne du tableau sera vide.
Pour un nouveau magasin de variantes, la réponse pour **get-variant-import-job**inclurait les champs d'annotation, comme indiqué.
```
aws omics get-variant-import-job --job-id 08279950-a9e3-4cc3-9a3c-a574f9c9e229
```
Vous recevez une réponse JSON qui indique le statut de votre tâche d'importation.
```
{
"creationTime": "2023-04-11T17:52:37.241958+00:00",
"destinationName": "annotationparsingvariantstore",
"id": "7a1c67e3-b7f9-434d-817b-9c571fd63bea",
"items": [
{
"jobStatus": "COMPLETED",
"source": "s3://amzn-s3-demo-bucket/NA12878.2k.garvan.vcf"
}
],
"roleArn": "arn:aws:iam::123456789012:role/",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T17:58:22.676043+00:00",
"annotationFields" : {"VEP": "CSQ"}
}
}
```
Vous pouvez l'utiliser **list-variant-import-jobs**pour voir toutes les tâches d'importation et leur statut.
```
aws omics list-variant-import-jobs --ids 7a1c67e3-b7f9-434d-817b-9c571fd63bea
```
La réponse contient les informations suivantes.
```
{
"variantImportJobs": [
{
"creationTime": "2023-04-11T17:52:37.241958+00:00",
"destinationName": "annotationparsingvariantstore",
"id": "7a1c67e3-b7f9-434d-817b-9c571fd63bea",
"roleArn": "arn:aws:iam::55555555555:role/roleName",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T17:58:22.676043+00:00",
"annotationFields" : {"VEP": "CSQ"}
}
]
}
}
```
Si nécessaire, vous pouvez annuler une tâche d'importation à l'aide de la commande suivante.
```
aws omics cancel-variant-import-job
--job-id edd7b8ce-xmpl-47e2-bc99-258cac95a508
```
# Création de magasins HealthOmics d'annotations
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
Un magasin d'annotations est un magasin de données représentant une base de données d'annotations, telle qu'une base de données provenant d'un fichier TSV, VCF ou GFF. Si le même génome de référence est spécifié, les magasins d'annotations sont mappés sur le même système de coordonnées que les magasins de variantes lors d'une importation. Les rubriques suivantes expliquent comment utiliser la HealthOmics console et comment créer et AWS CLI gérer des magasins d'annotations.
**Topics**
+ [Création d'un magasin d'annotations à l'aide de la console](#gs-console-create-annotation-store)
+ [Création d'un magasin d'annotations à l'aide de l'API](#create-manage-annotation-store-api)
## Création d'un magasin d'annotations à l'aide de la console
Pour créer des banques d'annotations avec la HealthOmics console, procédez comme suit.
**Pour créer un magasin d'annotations**
1. Ouvrez la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Si nécessaire, ouvrez le volet de navigation de gauche (≡). Choisissez **Annotation Stores**.
1. Sur la page **Stockages d'annotations**, choisissez **Créer un magasin d'annotations**.
1. Sur la page **Créer un magasin d'annotations**, fournissez les informations suivantes
+ **Nom du magasin d'annotations** : nom unique pour ce magasin.
+ **Description** (facultatif) - Description de ce génome de référence.
+ **Format des données et détails du schéma** : sélectionnez le format du fichier de données et téléchargez la définition du schéma pour ce magasin.
+ **Génome** de référence - Le génome de référence pour cette annotation.
+ **Chiffrement des données** : choisissez si vous souhaitez que le chiffrement des données soit détenu et géré par vous-même AWS ou par vous-même.
+ **Balises** (facultatif) : fournissez jusqu'à 50 balises pour ce magasin d'annotations.
1. Choisissez **Créer un magasin d'annotations**.
## Création d'un magasin d'annotations à l'aide de l'API
L'exemple suivant montre comment créer un magasin d'annotations à l'aide du AWS CLI. Pour toutes les opérations AWS CLI et les opérations d'API, vous devez spécifier le format de vos données.
```
aws omics create-annotation-store --name my_annotation_store \
--store-format GFF \
--reference referenceArn="arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/5987565360"
--version-name new_version
```
Vous recevez la réponse suivante pour confirmer la création de votre magasin d'annotations.
```
{
"creationTime": "2022-08-24T20:34:19.229500Z",
"id": "3b93cdef69d2",
"name": "my_annotation_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/5987565360"
},
"status": "CREATING"
"versionName": "my_version"
}
```
Pour en savoir plus sur un magasin d'annotations, utilisez l'**get-annotation-store**API.
```
aws omics get-annotation-store --name my_annotation_store
```
Vous recevez la réponse suivante.
```
{
"id": "eeb019ac79c2",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/5638433913/reference/5871590330“
},
"status": "ACTIVE",
"storeArn": "arn:aws:omics:us-west-2:555555555555:annotationStore/gffstore",
"name": "my_annotation_store",
"creationTime": "2022-11-05T00:05:19.136131+00:00",
"updateTime": "2022-11-05T00:10:36.944839+00:00",
"tags": {},
"storeFormat": "GFF",
"statusMessage": "",
"storeSizeBytes": 0,
"numVersions": 1
}
```
Pour afficher tous les magasins d'annotations associés à un compte, utilisez l'opération **list-annotation-stores**API.
```
aws omics list-annotation-stores
```
Vous recevez une réponse répertoriant tous les magasins d'annotations IDs, ainsi que leurs statuts et autres informations, comme indiqué dans l'exemple de réponse suivant.
```
{
"annotationStores": [
{
"id": "4d8f3eada259",
"reference":
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/5638433913/reference/5871590330"
},
"status": "CREATING",
"name": "gffstore",
"creationTime": "2022-09-27T17:30:52.182990+00:00",
"updateTime": "2022-09-27T17:30:53.025362+00:00"
}
]
}
```
Vous pouvez également filtrer les réponses en fonction du statut ou d'autres critères.
# Création de tâches d'importation pour les magasins HealthOmics d'annotations
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
**Topics**
+ [Création d'une tâche d'importation d'annotations à l'aide de l'API](#create-annotation-import-api)
+ [Paramètres supplémentaires pour les formats TSV et VCF](#annotation-import-tsv-vcf)
+ [Création de magasins d'annotations au format TSV](#annotation-import-tsv-vcftsv-annotation-store-examples-tsv)
+ [Démarrage de tâches d'importation au format VCF](#vcf-annotation-store-examples)
## Création d'une tâche d'importation d'annotations à l'aide de l'API
L'exemple suivant montre comment utiliser le AWS CLI pour démarrer une tâche d'importation d'annotations.
```
aws omics start-annotation-import-job \
--destination-name myannostore \
--version-name myannostore \
--role-arn arn:aws:iam::123456789012:role/roleName \
--items source=s3://my-omics-bucket/sample.vcf.gz
--annotation-fields '{"VEP": "CSQ"}'
```
Les magasins d'annotations créés avant le 15 mai 2023 renvoient un message d'erreur si les **champs d'annotation sont inclus**. Ils ne renvoient aucun résultat pour les opérations d'API impliquées dans les tâches d'importation de magasins d'annotations.
Vous pouvez ensuite utiliser l'opération **get-annotation-import-job**d'API et le `job ID` paramètre pour en savoir plus sur la tâche d'importation d'annotations.
```
aws omics get-annotation-import-job --job-id 9e4198fb-fa85-446c-9301-9b823a1a8ba8
```
Vous recevez la réponse suivante, y compris les champs d'annotation.
```
{
"creationTime": "2023-04-11T19:09:25.049767+00:00",
"destinationName": "parsingannotationstore",
"versionName": "parsingannotationstore",
"id": "9e4198fb-fa85-446c-9301-9b823a1a8ba8",
"items": [
{
"jobStatus": "COMPLETED",
"source": "s3://my-omics-bucket/sample.vep.vcf"
}
],
"roleArn": "arn:aws:iam::55555555555:role/roleName",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T19:13:09.110130+00:00",
"annotationFields" : {"VEP": "CSQ"}
}
```
Pour afficher toutes les tâches d'importation du magasin d'annotations, utilisez **list-annotation-import-jobs**.
```
aws omics list-annotation-import-jobs --ids 9e4198fb-fa85-446c-9301-9b823a1a8ba8
```
La réponse inclut les détails et les statuts des tâches d'importation de votre magasin d'annotations.
```
{
"annotationImportJobs": [
{
"creationTime": "2023-04-11T19:09:25.049767+00:00",
"destinationName": "parsingannotationstore",
"versionName": "parsingannotationstore",
"id": "9e4198fb-fa85-446c-9301-9b823a1a8ba8",
"roleArn": "arn:aws:iam::55555555555:role/roleName",
"runLeftNormalization": false,
"status": "COMPLETED",
"updateTime": "2023-04-11T19:13:09.110130+00:00",
"annotationFields" : {"VEP": "CSQ"}
}
]
}
```
## Paramètres supplémentaires pour les formats TSV et VCF
Pour les formats TSV et VCF, des paramètres supplémentaires indiquent à l'API comment analyser votre entrée.
**Important**
Les données d'annotation CSV exportées à l'aide de moteurs de requête renvoient directement les informations issues de l'importation du jeu de données. Si les données importées contiennent des formules ou des commandes, le fichier peut être soumis à une injection CSV. Par conséquent, les fichiers exportés à l'aide de moteurs de requête peuvent provoquer des avertissements de sécurité. Pour éviter toute activité malveillante, désactivez les liens et les macros lors de la lecture des fichiers d'exportation.
L'analyseur TSV effectue également des opérations bioinformatiques de base, telles que la normalisation à gauche et la standardisation des coordonnées génomiques, répertoriées dans le tableau suivant.
| Type de format | Description |
| --- | --- |
| Générique | Fichier texte générique. Aucune information génomique. |
| CHR\$1POS | Position de départ - 1, ajouter une position de fin, qui est identique àPOS. |
| CHR\$1POS\$1REF\$1ALT | Contient des informations sur les allèles contig, 1 base, ref et alt. |
| CHR\$1START\$1END\$1REF\$1ALT\$1ONE\$1BASE | Contient des informations sur les allèles contig, start, end, ref et alt. Les coordonnées sont basées sur 1. |
| CHR\$1START\$1END\$1ZERO\$1BASE | Contient les positions contig, de début et de fin. Les coordonnées sont basées sur 0. |
| CHR\$1START\$1END\$1ONE\$1BASE | Contient les positions contig, de début et de fin. Les coordonnées sont basées sur 1. |
| CHR\$1START\$1END\$1REF\$1ALT\$1ZERO\$1BASE | Contient des informations sur les allèles contig, start, end, ref et alt. Les coordonnées sont basées sur 0. |
Une demande de magasin d'annotations d'importation TSV ressemble à l'exemple suivant.
```
aws omics start-annotation-import-job \
--destination-name tsv_anno_example \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items source=s3://demodata/genomic_data.bed.gz \
--format-options '{ "tsvOptions": {
"readOptions": {
"header": false,
"sep": "\t"
}
}
}'
```
## Création de magasins d'annotations au format TSV
L'exemple suivant crée un magasin d'annotations à l'aide d'un fichier limité à onglets contenant un en-tête, des lignes et des commentaires. Les coordonnées sont`CHR_START_END_ONE_BASED`, et elle contient la carte HG19 génétique tirée du [synopsis de la carte des gènes humains de l'OMIM](https://www.omim.org/downloads).
```
aws omics create-annotation-store --name mimgenemap \
--store-format TSV \
--reference=referenceArn=arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/2310864158 \
--store-options=tsvStoreOptions='{
annotationType=CHR_START_END_ONE_BASE,
formatToHeader={CHR=chromosome, START=genomic_position_start, END=genomic_position_end},
schema=[
{chromosome=STRING},
{genomic_position_start=LONG},
{genomic_position_end=LONG},
{cyto_location=STRING},
{computed_cyto_location=STRING},
{mim_number=STRING},
{gene_symbols=STRING},
{gene_name=STRING},
{approved_gene_name=STRING},
{entrez_gene_id=STRING},
{ensembl_gene_id=STRING},
{comments=STRING},
{phenotypes=STRING},
{mouse_gene_symbol=STRING}]}'
```
Vous pouvez importer des fichiers avec ou sans en-tête. Pour l'indiquer dans une demande CLI, utilisez`header=false`, comme indiqué dans l'exemple de tâche d'importation suivant.
```
aws omics start-annotation-import-job \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items=source=s3://amzn-s3-demo-bucket/annotation-examples/hg38_genemap2.txt \
--destination-name output-bucket \
--format-options=tsvOptions='{readOptions={sep="\t",header=false,comment="#"}}'
```
L'exemple suivant crée un magasin d'annotations pour un fichier bed. Un fichier bed est un simple fichier délimité par des tabulations. Dans cet exemple, les colonnes sont le chromosome, le début, la fin et le nom de la région. Les coordonnées sont basées sur zéro et les données n'ont pas d'en-tête.
```
aws omics create-annotation-store \
--name cexbed --store-format TSV \
--reference=referenceArn=arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/2310864158 \
--store-options=tsvStoreOptions='{
annotationType=CHR_START_END_ZERO_BASE,
formatToHeader={CHR=chromosome, START=start, END=end},
schema=[{chromosome=STRING}, {start=LONG}, {end=LONG}, {name=STRING}]}'
```
Vous pouvez ensuite importer le fichier bed dans le magasin d'annotations à l'aide de la commande CLI suivante.
```
aws omics start-annotation-import-job \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items=source=s3://amzn-s3-demo-bucket/TruSeq_Exome_TargetedRegions_v1.2.bed \
--destination-name cexbed \
--format-options=tsvOptions='{readOptions={sep="\t",header=false,comment="#"}}'
```
L'exemple suivant crée un magasin d'annotations pour un fichier délimité par des tabulations qui contient les premières colonnes d'un fichier VCF, suivies de colonnes contenant des informations d'annotation. Il contient les positions du génome ainsi que des informations sur le chromosome, les allèles de départ, de référence et alternatifs, et il contient un en-tête.
```
aws omics create-annotation-store --name gnomadchrx --store-format TSV \
--reference=referenceArn=arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/2310864158 \
--store-options=tsvStoreOptions='{
annotationType=CHR_POS_REF_ALT,
formatToHeader={CHR=chromosome, POS=start, REF=ref, ALT=alt},
schema=[
{chromosome=STRING},
{start=LONG},
{ref=STRING},
{alt=STRING},
{filters=STRING},
{ac_hom=STRING},
{ac_het=STRING},
{af_hom=STRING},
{af_het=STRING},
{an=STRING},
{max_observed_heteroplasmy=STRING}]}'
```
Vous devez ensuite importer le fichier dans le magasin d'annotations à l'aide de la commande CLI suivante.
```
aws omics start-annotation-import-job \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items=source=s3://amzn-s3-demo-bucket/gnomad.genomes.v3.1.sites.chrM.reduced_annotations.tsv \
--destination-name gnomadchrx \
--format-options=tsvOptions='{readOptions={sep="\t",header=true,comment="#"}}'
```
L'exemple suivant montre comment un client peut créer un magasin d'annotations pour un fichier mim2gene. Un fichier mim2gene fournit les liens entre les gènes d'OMIM et un autre identifiant de gène. Il est délimité par des tabulations et contient des commentaires.
```
aws omics create-annotation-store \
--name mim2gene \
--store-format TSV \
--reference=referenceArn=arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/2310864158 \
--store-options=tsvStoreOptions='
{annotationType=GENERIC,
formatToHeader={},
schema=[
{mim_gene_id=STRING},
{mim_type=STRING},
{entrez_id=STRING},
{hgnc=STRING},
{ensembl=STRING}]}'
```
Vous pouvez ensuite importer des données dans votre boutique comme suit.
```
aws omics start-annotation-import-job \
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items=source=s3://xquek-dev-aws/annotation-examples/mim2gene.txt \
--destination-name mim2gene \
--format-options=tsvOptions='{readOptions={sep="\t",header=false,comment="#"}}'
```
## Démarrage de tâches d'importation au format VCF
Pour les fichiers VCF, il existe deux entrées supplémentaires qui ignorent ou incluent ces paramètres`ignoreFilterField`, comme indiqué. `ignoreQualField`
```
aws omics start-annotation-import-job --destination-name annotation_example\
--role-arn arn:aws:iam::555555555555:role/demoRole \
--items source=s3://demodata/example.garvan.vcf \
--format-options '{ "vcfOptions": {
"ignoreQualField": false,
"ignoreFilterField": false
}
}'
```
Vous pouvez également annuler l'importation d'un magasin d'annotations, comme indiqué. Si l'annulation aboutit, vous ne recevrez pas de réponse à cet AWS CLI appel. Toutefois, si l'ID de la tâche d'importation est introuvable ou si la tâche d'importation est terminée, vous recevez un message d'erreur.
```
aws omics cancel-annotation-import-job --job-id edd7b8ce-xmpl-47e2-bc99-258cac95a508
```
**Note**
L'historique de vos tâches d'importation de métadonnées pour **get-annotation-import-job**get-variant-import-job****, **list-annotation-import-jobs**, et **list-variant-import-jobs**est automatiquement supprimé au bout de deux ans. Les données de variante et d'annotation importées ne sont pas supprimées automatiquement et restent dans vos magasins de données.
# Création de versions de magasin HealthOmics d'annotations
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
Vous pouvez créer de nouvelles versions de magasins d'annotations pour collecter différentes versions de vos bases de données d'annotations. Cela vous permet d'organiser vos données d'annotation, qui sont mises à jour régulièrement.
Pour créer une nouvelle version d'un magasin d'annotations existant, utilisez l'**create-annotation-store-version**API comme indiqué dans l'exemple suivant.
```
aws omics create-annotation-store-version \
--name my_annotation_store \
--version-name my_version
```
Vous recevrez la réponse suivante avec l'ID de version du magasin d'annotations, confirmant qu'une nouvelle version de votre annotation a été créée.
```
{
"creationTime": "2023-07-21T17:15:49.251040+00:00",
"id": "3b93cdef69d2",
"name": "my_annotation_store",
"reference": {
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/6505293348/reference/5987565360"
},
"status": "CREATING",
"versionName": "my_version"
}
```
Pour mettre à jour la description d'une version du magasin d'annotations, vous pouvez l'utiliser **update-annotation-store-version**pour ajouter des mises à jour à une version du magasin d'annotations.
```
aws omics update-annotation-store-version \
--name my_annotation_store \
--version-name my_version \
--description "New Description"
```
Vous recevrez la réponse suivante, confirmant que la version du magasin d'annotations a été mise à jour.
```
{
"storeId": "4934045d1c6d",
"id": "2a3f4a44aa7b",
"description":"New Description",
"status": "ACTIVE",
"name": "my_annotation_store",
"versionName": "my_version",
"creation Time": "2023-07-21T17:20:59.380043+00:00",
"updateTime": "2023-07-21T17:26:17.892034+00:00"
}
```
Pour afficher les détails d'une version du magasin d'annotations, utilisez **get-annotation-store-version**.
```
aws omics get-annotation-store-version --name my_annotation_store --version-name my_version
```
Vous recevrez une réponse avec le nom de la version, le statut et d'autres détails.
```
{
"storeId": "4934045d1c6d",
"id": "2a3f4a44aa7b",
"status": "ACTIVE",
"versionArn": "arn:aws:omics:us-west-2:555555555555:annotationStore/my_annotation_store/version/my_version",
"name": "my_annotation_store",
"versionName": "my_version",
"creationTime": "2023-07-21T17:15:49.251040+00:00",
"updateTime": "2023-07-21T17:15:56.434223+00:00",
"statusMessage": "",
"versionSizeBytes": 0
}
```
Pour afficher toutes les versions d'un magasin d'annotations, vous pouvez utiliser **list-annotation-store-versions**, comme indiqué dans l'exemple suivant.
```
aws omics list-annotation-store-versions --name my_annotation_store
```
Vous recevrez une réponse contenant les informations suivantes
```
{
"annotationStoreVersions": [
{
"storeId": "4934045d1c6d",
"id": "2a3f4a44aa7b",
"status": "CREATING",
"versionArn": "arn:aws:omics:us-west-2:555555555555:annotationStore/my_annotation_store/version/my_version_2",
"name": "my_annotation_store",
"versionName": "my_version_2",
"creation Time": "2023-07-21T17:20:59.380043+00:00",
"versionSizeBytes": 0
},
{
"storeId": "4934045d1c6d",
"id": "4934045d1c6d",
"status": "ACTIVE",
"versionArn": "arn:aws:omics:us-west-2:555555555555:annotationStore/my_annotation_store/version/my_version_1",
"name": "my_annotation_store",
"versionName": "my_version_1",
"creationTime": "2023-07-21T17:15:49.251040+00:00",
"updateTime": "2023-07-21T17:15:56.434223+00:00",
"statusMessage": "",
"versionSizeBytes": 0
}
}
```
Si vous n'avez plus besoin d'une version du magasin d'annotations, vous pouvez l'utiliser **delete-annotation-store-versions**pour supprimer une version du magasin d'annotations, comme indiqué dans l'exemple suivant.
```
aws omics delete-annotation-store-versions --name my_annotation_store --versions my_version
```
Si la version du magasin est supprimée sans erreur, vous recevrez la réponse suivante.
```
{
"errors": []
}
```
S'il y a des erreurs, vous recevrez une réponse avec les détails des erreurs, comme indiqué.
```
{
"errors": [
{
"versionName": "my_version",
"message": "Version with versionName: my_version was not found."
}
]
}
```
Si vous essayez de supprimer une version du magasin d'annotations pour laquelle une tâche d'importation est active, vous recevrez une réponse contenant une erreur, comme indiqué.
```
{
"errors": [
{
"versionName": "my_version",
"message": "version has an inflight import running"
}
]
}
```
Dans ce cas, vous pouvez forcer la suppression de la version du magasin d'annotations, comme illustré dans l'exemple suivant.
```
aws omics delete-annotation-store-versions --name my_annotation_store --versions my_version --force
```
# Supprimer des magasins HealthOmics d'analyse
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
Lorsque vous supprimez un magasin de variantes ou d'annotations, le système supprime également toutes les données importées dans ce magasin et toutes les balises associées.
L'exemple suivant montre comment supprimer un magasin de variantes à l'aide du AWS CLI. Si l'action est réussie, le statut du magasin de variantes passe à`DELETING`.
```
aws omics delete-variant-store --id
```
L'exemple suivant montre comment supprimer un magasin d'annotations. Si l'action aboutit, le statut du magasin d'annotations passe à`DELETING`. Les magasins d'annotations ne peuvent pas être supprimés s'il existe plusieurs versions.
```
aws omics delete-annotation-store --id
```
# Interrogation de HealthOmics données analytiques
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
Vous pouvez effectuer des requêtes sur vos variantes de boutiques à l'aide AWS Lake Formation d'Amazon Athena ou d'Amazon EMR. Avant d'exécuter des requêtes, suivez les procédures de configuration (décrites dans les sections suivantes) pour Lake Formation et Amazon Athena.
Pour plus d'informations sur Amazon EMR, consultez [Tutoriel : Getting started with Amazon](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html) EMR
Pour les variantes de magasins créées après le 26 septembre 2024, HealthOmics partitionnez le magasin par ID d'échantillon. Ce partitionnement signifie qu'il HealthOmics utilise l'identifiant de l'échantillon pour optimiser le stockage des informations sur les variantes. Les requêtes qui utilisent des exemples d'informations comme filtres renvoient des résultats plus rapidement, car elles analysent moins de données.
HealthOmics utilise un échantillon IDs comme nom de fichier de partition. Avant d'ingérer des données, vérifiez si l'identifiant d'échantillon contient des données PHI. Si c'est le cas, modifiez l'identifiant de l'échantillon avant d'ingérer les données. Pour plus d'informations sur le contenu à inclure et à ne pas inclure dans l'échantillon IDs, consultez les instructions sur la page Web de [conformité à la loi AWS HIPAA](https://aws.amazon.com/compliance/hipaa-compliance).
**Topics**
+ [Configuration de Lake Formation à utiliser HealthOmics](setting-up-lf.md)
+ [Configuration d'Athena pour les requêtes](analytics-setting-up-athena.md)
+ [Exécution de requêtes sur des magasins de HealthOmics variantes](analytics-run-queries.md)
# Configuration de Lake Formation à utiliser HealthOmics
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
Avant d'utiliser Lake Formation pour gérer les magasins de HealthOmics données, effectuez les procédures de configuration de Lake Formation suivantes.
**Topics**
+ [Création ou vérification des administrateurs de Lake Formation](#create-lf-admins)
+ [Création de liens vers des ressources à l'aide de la console Lake Formation](#create-resource-links)
+ [Configuration des autorisations pour les partages AWS RAM de ressources](#configure-lf-permissions)
## Création ou vérification des administrateurs de Lake Formation
Avant de créer un lac de données dans Lake Formation, vous devez définir un ou plusieurs administrateurs.
Les administrateurs sont des utilisateurs et des rôles autorisés à créer des liens vers des ressources. Vous configurez les administrateurs de data lake par compte et par région.
**Créez un utilisateur administrateur dans la console Lake Formation**
1. Ouvrez la console AWS Lake Formation : console [Lake Formation](https://console.aws.amazon.com//lakeformation)
1. Si la console affiche le panneau **Welcome to Lake Formation**, choisissez **Get started**.
Lake Formation vous ajoute à la table des **administrateurs du Data Lake**.
1. Sinon, dans le menu de gauche, sélectionnez **Rôles et tâches** d'administration.
1. Ajoutez des administrateurs supplémentaires si nécessaire.
## Création de liens vers des ressources à l'aide de la console Lake Formation
Pour créer une ressource partagée que les utilisateurs peuvent interroger, les contrôles d'accès par défaut doivent être désactivés. Pour en savoir plus sur la désactivation des contrôles d'accès par défaut, consultez [la section Modification des paramètres de sécurité par défaut pour votre lac de données](https://docs.aws.amazon.com/lake-formation/latest/dg/change-settings.html) dans la documentation de Lake Formation. Vous pouvez créer des liens vers des ressources individuellement ou en groupe, afin d'accéder aux données d'Amazon Athena ou d'autres AWS services (tels qu'Amazon EMR).
**Création de liens vers des ressources dans la console AWS Lake Formation et partage de ces liens avec les utilisateurs HealthOmics d'Analytics**
1. Ouvrez la console AWS Lake Formation : console [Lake Formation](https://console.aws.amazon.com//lakeformation)
1. Dans la barre de navigation principale, sélectionnez **Bases de données**.
1. Dans le tableau **Bases de données**, sélectionnez la base de données souhaitée.
1. Dans le menu **Créer**, choisissez **Lien vers la ressource**.
1. Entrez le **nom du lien vers la ressource**. Si vous prévoyez d'accéder à la base de données depuis Athéna, entrez un nom en minuscules uniquement (256 caractères maximum).
1. Choisissez **Créer**.
1. Le nouveau lien vers la ressource est désormais répertorié sous **Bases de données**.
### Accorder l'accès à la ressource partagée à l'aide de la console Lake Formation
Un administrateur de base de données Lake Formation peut accorder l'accès à la ressource partagée en suivant la procédure suivante.
1. Ouvrez la console AWS Lake Formation : [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com//lakeformation)
1. Dans la barre de navigation principale, sélectionnez **Bases de données**.
1. Sur la page **Bases de données**, sélectionnez le lien de ressource que vous avez créé précédemment.
1. Dans le menu **Actions**, choisissez **Grant on target**.
1. Sur la page **Accorder les autorisations relatives aux données**, sous **Principaux**, sélectionnez **Utilisateurs ou rôles IAM**.
1. Dans le menu déroulant **Utilisateurs ou rôles IAM**, recherchez l'utilisateur auquel vous souhaitez accorder l'accès.
1. Ensuite, sous **Étiquettes LF ou carte de ressources de catalogue**, sélectionnez l'option **Ressources de catalogue de données nommées**.
1. Dans le menu déroulant **Tables (facultatif)**, sélectionnez **Toutes les tables** ou la table que vous avez créée précédemment.
1. Dans la fiche **Autorisations du tableau**, sous **Autorisations du tableau**, choisissez **Décrire** et **sélectionner**.
1. Ensuite, choisissez **Grant**.
Pour consulter les autorisations de Lake Formation, choisissez **Data Lake Permissions** dans le volet de navigation principal. Le tableau indique les bases de données et les liens vers les ressources disponibles.
## Configuration des autorisations pour les partages AWS RAM de ressources
Dans la console AWS Lake Formation, consultez les autorisations en choisissant Autorisations du **lac de données** dans la barre de navigation principale. Sur la page **Autorisations relatives aux données**, vous pouvez consulter un tableau qui indique les **types de ressources**, les **bases de données**, ainsi **ARN** que les informations relatives à une ressource partagée dans le cadre du **partage des ressources RAM**. Si vous devez accepter un partage de ressources AWS Resource Access Manager (AWS RAM), vous en AWS Lake Formation informe dans la console.
HealthOmics peut accepter implicitement les partages de AWS RAM ressources lors de la création du magasin. Pour accepter le partage de AWS RAM ressources, l'utilisateur ou le rôle IAM qui appelle les opérations `CreateVariantStore` ou `CreateAnnotationStore` API doit autoriser les actions suivantes :
+ `ram:GetResourceShareInvitations`- Cette action permet HealthOmics de retrouver les invitations.
+ `ram:AcceptResourceShareInvitation`- Cette action permet d' HealthOmics accepter l'invitation en utilisant un jeton FAS.
Sans ces autorisations, une erreur d'autorisation s'affiche lors de la création de la boutique.
Voici un exemple de politique qui inclut ces actions. Ajoutez cette politique à l'utilisateur ou au rôle IAM qui accepte le partage de AWS RAM ressources.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"omics:*",
"ram:AcceptResourceShareInvitation",
"ram:GetResourceShareInvitations"
],
"Resource": "*"
}
]
}
```
------
# Configuration d'Athena pour les requêtes
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
Vous pouvez utiliser Athena pour interroger des variantes et des annotations. Avant d'exécuter des requêtes, effectuez les tâches de configuration suivantes :
**Topics**
+ [Configuration de l'emplacement des résultats d'une requête à l'aide de la console Athena](#configure-athena-query)
+ [Configuration d'un groupe de travail avec le moteur Athena v3](#configure-athena-workgroup)
## Configuration de l'emplacement des résultats d'une requête à l'aide de la console Athena
Pour configurer l'emplacement des résultats d'une requête, procédez comme suit.
1. [Ouvrez la console Athena : Athena console](https://console.aws.amazon.com//athena)
1. Dans la barre de navigation principale, choisissez l'**éditeur de requêtes**.
1. Dans l'éditeur de requêtes, choisissez l'onglet **Paramètres**, puis sélectionnez **Gérer**.
1. Entrez le préfixe S3 d'un emplacement pour enregistrer le résultat de la requête.
## Configuration d'un groupe de travail avec le moteur Athena v3
Pour configurer un groupe de travail, procédez comme suit.
1. [Ouvrez la console Athena : Athena console](https://console.aws.amazon.com//athena)
1. Dans la barre de navigation principale, choisissez **Groupes de travail**, puis **Créer un groupe de travail**.
1. Entrez un nom pour le groupe de travail.
1. Sélectionnez **Athena SQL** comme type de moteur.
1. Sous **Mettre à niveau le moteur de requête**, sélectionnez **Manuel**.
1. Sous **Query version engine**, sélectionnez **Athena version 3**.
1. Choisissez **Créer un groupe de travail**.
# Exécution de requêtes sur des magasins de HealthOmics variantes
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
Vous pouvez effectuer des requêtes sur votre boutique de variantes à l'aide d'Amazon Athena. Notez que les coordonnées génomiques dans les magasins de variants et d'annotations sont représentées sous forme d'intervalles de base zéro, mi-fermés, mi-ouverts.
## Exécutez une requête simple à l'aide de la console Athena
L'exemple suivant montre comment exécuter une requête simple.
1. [Ouvrez l'éditeur de requêtes Athena : éditeur de requêtes Athena](https://console.aws.amazon.com//athena)
1. Sous **Groupe de travail**, sélectionnez le groupe de travail que vous avez créé lors de la configuration.
1. Vérifiez que la **source de données** est **AwsDataCatalog**.
1. Pour **Base de données**, sélectionnez le lien de ressource de base de données que vous avez créé lors de la configuration de Lake Formation.
1. Copiez la requête suivante dans l'**éditeur de requêtes** sous l'onglet **Requête 1** :
```
SELECT * from omicsvariants limit 10
```
1. Choisissez **Exécuter** pour exécuter la requête. La console remplit le tableau des résultats avec les 10 premières lignes du **omicsvariants** tableau.
## Exécuter une requête complexe à l'aide de la console Athena
L'exemple suivant montre comment exécuter une requête complexe. Pour exécuter cette requête, importez-la `ClinVar` dans le magasin d'annotations.
**Exécuter une requête complexe**
1. [Ouvrez l'éditeur de requêtes Athena : éditeur de requêtes Athena](https://console.aws.amazon.com//athena)
1. Sous **Groupe de travail**, sélectionnez le groupe de travail que vous avez créé lors de la configuration.
1. Vérifiez que la **source de données** est **AwsDataCatalog**.
1. Pour **Base de données**, sélectionnez le lien de ressource de base de données que vous avez créé lors de la configuration de Lake Formation.
1. Cliquez **\$1** sur le bouton en haut à droite pour créer un nouvel onglet de **requête nommé Requête 2**.
1. Copiez la requête suivante dans l'**éditeur de requêtes** sous l'onglet **Requête 2** :
```
SELECT variants.sampleid,
variants.contigname,
variants.start,
variants."end",
variants.referenceallele,
variants.alternatealleles,
variants.attributes AS variant_attributes,
clinvar.attributes AS clinvar_attributes
FROM omicsvariants as variants
INNER JOIN omicsannotations as clinvar ON
variants.contigname=CONCAT('chr',clinvar.contigname)
AND variants.start=clinvar.start
AND variants."end"=clinvar."end"
AND variants.referenceallele=clinvar.referenceallele
AND variants.alternatealleles=clinvar.alternatealleles
WHERE clinvar.attributes['CLNSIG']='Likely_pathogenic'
```
1. Choisissez **Exécuter** pour démarrer l'exécution de la requête.
# Partage de magasins HealthOmics d'analyse
**Important**
AWS HealthOmics les magasins de variantes et les magasins d'annotations ne sont plus ouverts aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [AWS HealthOmics modification de la disponibilité du magasin de variantes et du magasin d'annotations](variant-store-availability-change.md).
En tant que propriétaire d'un magasin de variantes ou d'un magasin d'annotations, vous pouvez partager le magasin avec d'autres comptes AWS. Le propriétaire peut révoquer l'accès à la ressource partagée en supprimant le partage.
En tant qu'abonné à une boutique partagée, vous devez d'abord accepter le partage. Vous pouvez ensuite définir des flux de travail utilisant le magasin partagé. Les données apparaissent sous forme de tableau à la fois dans Lake Formation AWS Glue et dans Lake Formation.
Lorsque vous n'avez plus besoin d'accéder à la boutique, vous supprimez le partage.
Consultez [Partage de ressources entre comptes dans AWS HealthOmics](resource-sharing.md) pour plus d'informations sur le partage des ressources.
## Création d'un partage de boutique
Pour créer un partage de boutique, utilisez l'opération d'API **create-share**. L'abonné principal est celui Compte AWS de l'utilisateur qui va souscrire au partage. L'exemple suivant crée un partage pour un magasin de variantes. Pour partager une boutique avec plusieurs comptes, vous devez créer plusieurs partages de la même boutique.
```
aws omics create-share \
--resource-arn "arn:aws:omics:us-west-2:555555555555:variantStore/omics_dev_var_store" \
--principal-subscriber "123456789012" \
--name "my_Share-123"
```
Si la création est réussie, vous recevez une réponse avec l'ID et le statut du partage.
```
{
"shareId": "495c21bedc889d07d0ab69d710a6841e-dd75ab7a1a9c384fa848b5bd8e5a7e0a",
"name": "my_Share-123",
"status": "PENDING"
}
```
Le partage reste en attente jusqu'à ce que l'abonné l'accepte à l'aide de l'opération d'API accept-share.