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 rangement
Utilisez le HealthOmics stockage pour stocker, récupérer, organiser et partager les données génomiques de manière efficace et à moindre coût. HealthOmics le stockage comprend les relations entre les différents objets de données, de sorte que vous pouvez définir quels ensembles de lecture proviennent des mêmes données sources. Cela vous indique la provenance des données.
Les données stockées dans `ACTIVE` l'état sont immédiatement récupérables. Les données qui n'ont pas été consultées depuis 30 jours ou plus sont stockées dans leur `ARCHIVE` état actuel. Pour accéder aux données archivées, vous pouvez les réactiver via les opérations ou la console de l'API.
HealthOmics les magasins de séquences sont conçus pour préserver l'intégrité du contenu des fichiers. Toutefois, l'équivalence au niveau du bit entre les fichiers de données importés et les fichiers exportés n'est pas préservée en raison de la compression lors de la hiérarchisation active et de la hiérarchisation des archives.
Lors de l'ingestion, HealthOmics génère une balise d'entité ou *HealthOmics ETag*permet de valider l'intégrité du contenu de vos fichiers de données. Les parties de séquençage sont identifiées et capturées ETag au niveau de la source d'un ensemble de lecture. Le ETag calcul ne modifie pas le fichier réel ni les données génomiques. Une fois qu'un jeu de lecture est créé, il ETag ne devrait pas changer tout au long du cycle de vie de la source du jeu de lecture. Cela signifie que la réimportation du même fichier entraîne le calcul de la même ETag valeur.
**Topics**
+ [HealthOmics ETags et provenance des données](etags-and-provenance.md)
+ [Création d'un magasin HealthOmics de référence](create-reference-store.md)
+ [Création d'un magasin HealthOmics de séquences](create-sequence-store.md)
+ [Suppression des HealthOmics référentiels et des magasins de séquences](deleting-reference-and-sequence-stores.md)
+ [Importation de jeux de lecture dans un magasin de HealthOmics séquences](import-sequence-store.md)
+ [Téléchargement direct vers un magasin de HealthOmics séquences](synchronous-uploads.md)
+ [Exporter HealthOmics des ensembles de lectures vers un compartiment Amazon S3](read-set-exports.md)
+ [Accès aux ensembles de HealthOmics lecture avec Amazon S3 URIs](s3-access.md)
+ [L'activation de la lecture s'installe dans HealthOmics](activating-read-sets.md)
# HealthOmics ETags et provenance des données
Une HealthOmics ETag (étiquette d'entité) est un hachage du contenu ingéré dans un magasin de séquences. Cela simplifie la récupération et le traitement des données tout en préservant l'intégrité du contenu des fichiers de données ingérés. Cela ETag reflète les modifications apportées au contenu sémantique de l'objet, et non à ses métadonnées. Le type d'ensemble de lecture et l'algorithme spécifiés déterminent le ETag mode de calcul. Le ETag calcul ne modifie pas le fichier réel ni les données génomiques. Lorsque le schéma de type de fichier de l'ensemble de lecture le permet, le magasin de séquences met à jour les champs liés à la provenance des données.
Les fichiers ont une identité binaire et une identité sémantique. L'identité binaire signifie que les bits d'un fichier sont identiques, et l'identité sémantique signifie que le contenu d'un fichier est identique. L'identité sémantique résiste aux modifications des métadonnées et aux modifications de compression car elle capture l'intégrité du contenu du fichier.
Les ensembles de lecture placés dans des magasins de HealthOmics séquences sont soumis à compression/decompression des cycles et à un suivi de la provenance des données tout au long du cycle de vie d'un objet. Au cours de ce traitement, l'identité binaire d'un fichier ingéré peut changer et devrait changer chaque fois qu'un fichier est activé ; toutefois, l'identité sémantique du fichier est conservée. L'identité sémantique est capturée sous forme de balise d' HealthOmics entité, ou ETag calculée lors de l'ingestion du magasin de séquences et disponible sous forme de métadonnées d'ensemble de lecture.
Lorsque le schéma de type de fichier de l'ensemble de lecture le permet, les champs de mise à jour du magasin de séquences sont liés à la provenance des données. Pour les fichiers uBam, BAM et CRAM, une nouvelle `Comment` balise `@CO` or est ajoutée à l'en-tête. Le commentaire contient l'identifiant du magasin de séquences et l'horodatage d'ingestion.
## Amazon S3 ETags
Lorsque vous accédez à un fichier à l'aide de l'URI Amazon S3, les opérations de l'API Amazon S3 peuvent également renvoyer des valeurs Amazon S3 ETag et des valeurs de somme de contrôle. Les valeurs d'Amazon S3 ETag et de checksum diffèrent de celles-ci HealthOmics ETags car elles représentent l'identité binaire du fichier. Pour en savoir plus sur les métadonnées descriptives et les objets, consultez la [documentation de l'API Amazon S3 Object](https://docs.aws.amazon.com/AmazonS3/latest/API/API_Object.html). ETag Les valeurs Amazon S3 peuvent changer à chaque cycle d'activation d'un ensemble de lecture et vous pouvez les utiliser pour valider la lecture d'un fichier. Cependant, ne mettez pas en cache ETag les valeurs Amazon S3 à utiliser pour la validation de l'identité du fichier pendant le cycle de vie du fichier, car elles ne restent pas cohérentes. En revanche, ils HealthOmics ETag restent cohérents tout au long du cycle de vie du jeu de lecture.
## Comment HealthOmics calcule ETags
Le ETag est généré à partir d'un hachage du contenu du fichier ingéré. La famille d' ETag algorithmes est définie sur MD5up par défaut, mais elle peut être configurée différemment lors de la création du magasin de séquences. Lorsque le ETag est calculé, l'algorithme et les hachages calculés sont ajoutés à l'ensemble de lecture. Les MD5 algorithmes pris en charge pour les types de fichiers sont les suivants.
+ *FASTQ\$1 MD5up* — Calcule le MD5 hachage d'une source d'ensemble de lecture FASTQ complète et non compressée.
+ *BAM\$1 MD5up* — Calcule le MD5 hachage de la section d'alignement d'une source de jeu de lecture BAM ou UbAM non compressée telle que représentée dans le SAM, sur la base de la référence liée, le cas échéant.
+ *CRAM\$1 MD5up* — Calcule le MD5 hachage de la section d'alignement de la source du jeu de lecture CRAM non compressée telle que représentée dans le SAM, sur la base de la référence liée.
**Note**
MD5 le hachage est connu pour être vulnérable aux collisions. De ce fait, deux fichiers différents peuvent avoir les mêmes caractéristiques ETag s'ils ont été fabriqués pour exploiter la collision connue.
Les algorithmes suivants sont pris en charge pour la SHA256 famille. Les algorithmes sont calculés comme suit :
+ *FASTQ\$1 SHA256up* — Calcule le hachage SHA-256 d'une source de jeu de lecture FASTQ complète et non compressée.
+ *BAM\$1 SHA256up* — Calcule le hachage SHA-256 de la section d'alignement d'un ensemble de lecture BAM ou UbAM non compressé tel que représenté dans le SAM, sur la base de la référence liée, le cas échéant.
+ *CRAM\$1 SHA256up* — Calcule le hachage SHA-256 de la section d'alignement d'une source de jeu de lecture CRAM non compressée telle que représentée dans le SAM, sur la base de la référence liée.
Les algorithmes suivants sont pris en charge pour la SHA512 famille. Les algorithmes sont calculés comme suit :
+ *FASTQ\$1 SHA512up* — Calcule le hachage SHA-512 d'une source de jeu de lecture FASTQ complète et non compressée.
+ *BAM\$1 SHA512up* — Calcule le hachage SHA-512 de la section d'alignement d'un ensemble de lecture BAM ou UbAM non compressé tel que représenté dans le SAM, sur la base de la référence liée, le cas échéant.
+ *CRAM\$1 SHA512up * — Calcule le hachage SHA-512 de la section d'alignement d'une source de jeu de lecture CRAM non compressée telle que représentée dans le SAM, sur la base de la référence liée.
# Création d'un magasin HealthOmics de référence
Un magasin de référence dans HealthOmics est un magasin de données destiné au stockage de génomes de référence. Vous pouvez avoir un seul magasin de référence dans chaque Compte AWS région. Vous pouvez créer un magasin de référence à l'aide de la console ou de la CLI.
**Topics**
+ [Création d'un magasin de référence à l'aide de la console](#console-create-reference-store)
+ [Création d'un magasin de référence à l'aide de la CLI](#api-create-reference-store)
## Création d'un magasin de référence à l'aide de la console
**Pour créer un magasin de références**
1. Ouvrez la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Si nécessaire, ouvrez le volet de navigation de gauche (≡). Choisissez **Reference store**.
1. Choisissez **Génomes de référence dans les** options de stockage des données génomiques.
1. Vous pouvez soit choisir un génome de référence précédemment importé, soit en importer un nouveau. Si vous n'avez pas importé de génome de référence, choisissez **Importer le génome de référence** en haut à droite.
1. Sur la page **Créer une tâche d'importation du génome de référence**, choisissez l'option **Création rapide** **ou Création manuelle** pour créer un magasin de référence, puis fournissez les informations suivantes.
+ **Nom du génome de référence** : nom unique pour ce magasin.
+ **Description** (facultatif) : description de ce magasin de référence.
+ **Rôle IAM** - Sélectionnez un rôle ayant accès à votre génome de référence.
+ **Référence provenant d'Amazon S3** : sélectionnez votre fichier de séquence de référence dans un compartiment Amazon S3.
+ **Balises** (facultatif) - Fournissez jusqu'à 50 balises pour ce magasin de référence.
## Création d'un magasin de référence à l'aide de la CLI
L'exemple suivant montre comment créer un magasin de référence à l'aide du AWS CLI. Vous pouvez avoir un magasin de référence par AWS région.
Les magasins de référence prennent en charge le stockage de fichiers FASTA avec les extensions `.fasta` `.fa``.fas`,`.fsa`,,`.faa`,`.fna`,`.ffn`,`.frn`,, `.mpfa``.seq`,`.txt`. La `bgzip` version de ces extensions est également prise en charge.
Dans l'exemple suivant, remplacez `reference store name` par le nom que vous avez choisi pour votre boutique de référence.
```
aws omics create-reference-store --name "reference store name"
```
Vous recevez une réponse JSON avec l'ID et le nom du magasin de référence, l'ARN et l'horodatage de la création de votre magasin de référence.
```
{
"id": "3242349265",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/3242349265",
"name": "MyReferenceStore",
"creationTime": "2022-07-01T20:58:42.878Z"
}
```
Vous pouvez utiliser l'ID du magasin de référence dans des AWS CLI commandes supplémentaires. Vous pouvez récupérer la liste des magasins de référence IDs liés à votre compte à l'aide de la **list-reference-stores**commande, comme illustré dans l'exemple suivant.
```
aws omics list-reference-stores
```
En réponse, vous recevez le nom du magasin de référence que vous venez de créer.
```
{
"referenceStores": [
{
"id": "3242349265",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/3242349265",
"name": "MyReferenceStore",
"creationTime": "2022-07-01T20:58:42.878Z"
}
]
}
```
Après avoir créé un magasin de référence, vous pouvez créer des tâches d'importation pour y charger des fichiers de référence génomiques. Pour ce faire, vous devez utiliser ou créer un rôle IAM pour accéder aux données. Voici un exemple de politique .
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
------
Vous devez également disposer d'une politique de confiance similaire à celle décrite dans l'exemple suivant.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"omics.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Vous pouvez désormais importer un génome de référence. Cet exemple utilise Human Build 38 (hg38) du Genome Reference Consortium, qui est en libre accès et disponible [sur AWS le registre des données ouvertes](https://registry.opendata.aws/) le. Le bucket qui héberge ces données est basé dans l'est des États-Unis (Ohio). Pour utiliser des compartiments dans d'autres AWS régions, vous pouvez copier les données dans un compartiment Amazon S3 hébergé dans votre région. Utilisez la AWS CLI commande suivante pour copier le génome dans votre compartiment Amazon S3.
```
aws s3 cp s3://broad-references/hg38/v0/Homo_sapiens_assembly38.fasta s3://amzn-s3-demo-bucket
```
Vous pouvez ensuite commencer votre tâche d'importation. Remplacez `reference store ID``role ARN`, et `source file path` par votre propre entrée.
```
aws omics start-reference-import-job --reference-store-id reference store ID --role-arn role ARN --sources source file path
```
Une fois les données importées, vous recevez la réponse suivante au format JSON.
```
{
"id": "7252016478",
"referenceStoreId": "3242349265",
"roleArn": "arn:aws:iam::111122223333:role/OmicsReferenceImport",
"status": "CREATED",
"creationTime": "2022-07-01T21:15:13.727Z"
}
```
Vous pouvez contrôler l'état d'une tâche à l'aide de la commande suivante. Dans l'exemple suivant, remplacez `reference store ID` et `job ID` par votre identifiant de magasin de référence et l'identifiant de tâche sur lesquels vous souhaitez en savoir plus.
```
aws omics get-reference-import-job --reference-store-id reference store ID --id job ID
```
En réponse, vous recevez une réponse contenant les détails de ce magasin de référence et son statut.
```
{
"id": "7252016478",
"referenceStoreId": "3242349265",
"roleArn": "arn:aws:iam::555555555555:role/OmicsReferenceImport",
"status": "RUNNING",
"creationTime": "2022-07-01T21:15:13.727Z",
"sources": [
{
"sourceFile": "s3://amzn-s3-demo-bucket/Homo_sapiens_assembly38.fasta",
"status": "IN_PROGRESS",
"name": "MyReference"
}
]
}
```
Vous pouvez également trouver la référence importée en répertoriant vos références et en les filtrant en fonction du nom de la référence. `reference store ID`Remplacez-le par l'identifiant de votre boutique de référence et ajoutez un filtre facultatif pour affiner la liste.
```
aws omics list-references --reference-store-id reference store ID --filter name=MyReference
```
En réponse, vous recevez les informations suivantes.
```
{
"references": [
{
"id": "1234567890",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/1234567890/reference/1234567890",
"referenceStoreId": "12345678",
"md5": "7ff134953dcca8c8997453bbb80b6b5e",
"status": "ACTIVE",
"name": "MyReference",
"creationTime": "2022-07-02T00:15:19.787Z",
"updateTime": "2022-07-02T00:15:19.787Z"
}
]
}
```
Pour en savoir plus sur les métadonnées de référence, utilisez l'opération **get-reference-metadata**API. Dans l'exemple suivant, remplacez-le `reference store ID` par l'ID de votre boutique de référence et `reference ID` par l'ID de référence sur lequel vous souhaitez en savoir plus.
```
aws omics get-reference-metadata --reference-store-id reference store ID --id reference ID
```
Vous recevez les informations suivantes en réponse.
```
{
"id": "1234567890",
"arn": "arn:aws:omics:us-west-2:555555555555:referenceStore/referencestoreID/reference/referenceID",
"referenceStoreId": "1234567890",
"md5": "7ff134953dcca8c8997453bbb80b6b5e",
"status": "ACTIVE",
"name": "MyReference",
"creationTime": "2022-07-02T00:15:19.787Z",
"updateTime": "2022-07-02T00:15:19.787Z",
"files": {
"source": {
"totalParts": 31,
"partSize": 104857600,
"contentLength": 3249912778
},
"index": {
"totalParts": 1,
"partSize": 104857600,
"contentLength": 160928
}
}
}
```
Vous pouvez également télécharger des parties du fichier de référence à l'aide de **get-reference**. Dans l'exemple suivant, remplacez-le `reference store ID` par l'ID de votre magasin de référence et `reference ID` par l'ID de référence à partir duquel vous souhaitez effectuer le téléchargement.
```
aws omics get-reference --reference-store-id reference store ID --id reference ID --part-number 1 outfile.fa
```
# Création d'un magasin HealthOmics de séquences
HealthOmics les magasins de séquences prennent en charge le stockage de fichiers génomiques dans les formats non alignés `FASTQ` (gzip uniquement) et. `uBAM` Il prend également en charge les formats alignés de `BAM` et`CRAM`.
Les fichiers importés sont stockés sous forme de jeux de lecture. Vous pouvez ajouter des balises aux ensembles de lecture et utiliser les politiques IAM pour contrôler l'accès aux ensembles de lecture. Les ensembles de lecture alignés nécessitent un génome de référence pour aligner les séquences génomiques, mais c'est facultatif pour les ensembles de lecture non alignés.
Pour stocker des ensembles de lecture, vous devez d'abord créer un magasin de séquences. Lorsque vous créez un magasin de séquences, vous pouvez spécifier un compartiment Amazon S3 facultatif comme emplacement de secours et comme emplacement de stockage des journaux d'accès S3. L'emplacement de secours est utilisé pour stocker tous les fichiers qui ne parviennent pas à créer un ensemble de lecture lors d'un téléchargement direct. Des emplacements de secours sont disponibles pour les magasins de séquences créés après le 15 mai 2023. Vous spécifiez l'emplacement de secours lorsque vous créez le magasin de séquences.
Vous pouvez spécifier jusqu'à cinq clés de balise Read Set. Lorsque vous créez ou mettez à jour un ensemble de lecture avec une clé de balise correspondant à l'une de ces clés, les balises d'ensemble de lecture sont propagées à l'objet Amazon S3 correspondant. Les balises système créées par HealthOmics sont propagées par défaut.
**Topics**
+ [Création d'un magasin de séquences à l'aide de la console](#console-create-sequence-store)
+ [Création d'un magasin de séquences à l'aide de la CLI](#api-create-sequence-store)
+ [Mettre à jour un magasin de séquences](#update-sequence-store)
+ [Mise à jour des balises de jeu de lecture pour un magasin de séquences](#sequence-store-manage-tags)
+ [Importation de fichiers génomiques](#import-genomic-files)
## Création d'un magasin de séquences à l'aide de la console
**Pour créer un magasin de séquences**
1. Ouvrez la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Si nécessaire, ouvrez le volet de navigation de gauche (≡). Choisissez **Sequence stores**.
1. Sur la page **Créer un magasin de séquences**, fournissez les informations suivantes
+ **Nom du magasin de séquences** : nom unique pour ce magasin.
+ **Description** (facultatif) : description de ce magasin de séquences.
1. Pour l'**emplacement de secours dans S3**, spécifiez un emplacement Amazon S3. HealthOmics utilise l'emplacement de secours pour stocker tous les fichiers qui ne parviennent pas à créer un ensemble de lectures lors d'un téléchargement direct. Vous devez accorder au HealthOmics service un accès en écriture à l'emplacement de secours d'Amazon S3. Pour un exemple de politique, consultez [Configuration d'un emplacement de secours](synchronous-uploads.md#synchronous-uploads-fallback).
Les emplacements de secours ne sont pas disponibles pour les magasins de séquences créés avant le 16 mai 2023.
1. (Facultatif) Pour **les clés de balise Read Set pour la propagation S3**, vous pouvez entrer jusqu'à cinq clés de lecture à propager d'un ensemble de lectures aux objets S3 sous-jacents. En propageant les balises d'un ensemble de lecture vers l'objet S3, vous pouvez accorder des autorisations d'accès à S3 en fonction des balises. Les utilisateurs and/or finaux peuvent ainsi voir les balises propagées via l'opération d' getObjectTagging API Amazon S3.
1. Entrez une valeur clé dans la zone de texte. La console crée une nouvelle zone de texte pour ajouter la touche suivante.
1. (Facultatif) Choisissez **Supprimer** pour supprimer toutes les clés.
1. Sous **Chiffrement des données**, indiquez si vous souhaitez que le chiffrement des données soit détenu et géré par AWS ou qu'il utilise une clé CMK gérée par le client.
1. (Facultatif) Sous **Accès aux données S3**, indiquez si vous souhaitez créer un nouveau rôle et une nouvelle politique pour accéder au magasin de séquences via Amazon S3.
1. (Facultatif) Pour la **journalisation des accès S3**, indiquez `Enabled` si vous souhaitez qu'Amazon S3 collecte les enregistrements des journaux d'accès.
Pour **l'emplacement de journalisation des accès dans S3**, spécifiez un emplacement Amazon S3 pour stocker les journaux. Ce champ n'est visible que si vous avez activé la journalisation des accès S3.
1. **Balises** (facultatif) - Fournissez jusqu'à 50 balises pour ce magasin de séquences. Ces balises sont distinctes des balises d'ensemble de lecture définies lors de la mise à import/tag jour de l'ensemble de lecture
Une fois que vous avez créé le magasin, il est prêt pour[Importation de fichiers génomiques](#import-genomic-files).
## Création d'un magasin de séquences à l'aide de la CLI
Dans l'exemple suivant, remplacez `sequence store name` par le nom que vous avez choisi pour votre magasin de séquences.
```
aws omics create-sequence-store --name sequence store name --fallback-location "s3://amzn-s3-demo-bucket"
```
Vous recevez la réponse suivante au format JSON, qui inclut le numéro d'identification du magasin de séquences que vous venez de créer.
```
{
"id": "3936421177",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/3936421177",
"name": "sequence_store_example_name",
"creationTime": "2022-07-13T20:09:26.038Z"
"fallbackLocation" : "s3://amzn-s3-demo-bucket"
}
```
Vous pouvez également afficher tous les magasins de séquences associés à votre compte à l'aide de la **list-sequence-stores**commande, comme indiqué ci-dessous.
```
aws omics list-sequence-stores
```
Vous recevez la réponse suivante.
```
{
"sequenceStores": [
{
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/3936421177",
"id": "3936421177",
"name": "MySequenceStore",
"creationTime": "2022-07-13T20:09:26.038Z",
"updatedTime": "2024-09-13T04:11:31.242Z",
"fallbackLocation" : "s3://amzn-s3-demo-bucket",
"status": "Active"
}
]
}
```
Vous pouvez utiliser **get-sequence-store**pour en savoir plus sur un magasin de séquences en utilisant son identifiant, comme illustré dans l'exemple suivant :
```
aws omics get-sequence-store --id sequence store ID
```
Vous recevez la réponse suivante :
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/sequencestoreID",
"creationTime": "2024-01-12T04:45:29.857Z",
"updatedTime": "2024-09-13T04:11:31.242Z",
"description": null,
"fallbackLocation": null,
"id": "2015356892",
"name": "MySequenceStore",
"s3Access": {
"s3AccessPointArn": "arn:aws:s3:us-west-2:123456789012:accesspoint/592761533288-2015356892",
"s3Uri": "s3://592761533288-2015356892-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/",
"accessLogLocation": "s3://IAD-seq-store-log/2015356892/"
},
"sseConfig": {
"keyArn": "arn:aws:kms:us-west-2:123456789012:key/eb2b30f5-635d-4b6d-b0f9-d3889fe0e648",
"type": "KMS"
},
"status": "Active",
"statusMessage": null,
"setTagsToSync": ["withdrawn","protocol"],
}
```
Après la création, plusieurs paramètres de la boutique peuvent également être mis à jour. Cela peut être effectué via la console ou l'`updateSequenceStore`opération API.
## Mettre à jour un magasin de séquences
Pour mettre à jour un magasin de séquences, procédez comme suit :
1. Ouvrez la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Si nécessaire, ouvrez le volet de navigation de gauche (≡). Choisissez **Sequence stores**.
1. Choisissez le magasin de séquences à mettre à jour.
1. Dans le panneau **Détails**, choisissez **Modifier**.
1. Sur la page **Modifier les détails**, vous pouvez mettre à jour les champs suivants :
+ **Nom du magasin de séquences** : nom unique pour ce magasin.
+ **Description** : description de ce magasin de séquences.
+ **Emplacement de secours dans S3**, spécifiez un emplacement Amazon S3. HealthOmics utilise l'emplacement de secours pour stocker tous les fichiers qui ne parviennent pas à créer un ensemble de lectures lors d'un téléchargement direct.
+ **Clés de balise Read Set pour la propagation dans S3** Vous pouvez saisir jusqu'à cinq clés de lecture à propager vers Amazon S3.
+ (Facultatif) Pour la **journalisation des accès S3**, indiquez `Enabled` si vous souhaitez qu'Amazon S3 collecte les enregistrements des journaux d'accès.
Pour **l'emplacement de journalisation des accès dans S3**, spécifiez un emplacement Amazon S3 pour stocker les journaux. Ce champ n'est visible que si vous avez activé la journalisation des accès S3.
+ **Balises** (facultatif) - Fournissez jusqu'à 50 balises pour ce magasin de séquences.
## Mise à jour des balises de jeu de lecture pour un magasin de séquences
Pour mettre à jour les balises de jeu de lecture ou les autres champs d'un magasin de séquences, procédez comme suit :
1. Ouvrez la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Si nécessaire, ouvrez le volet de navigation de gauche (≡). Choisissez **Sequence stores**.
1. Choisissez le magasin de séquences que vous souhaitez mettre à jour.
1. Cliquez sur l’onglet **Détails**.
1. Choisissez **Modifier**.
1. Ajoutez de nouvelles balises readset ou supprimez des balises existantes, selon les besoins.
1. Mettez à jour le nom, la description, l'emplacement de secours ou l'accès aux données S3, selon les besoins.
1. Sélectionnez **Enregistrer les modifications**.
## Importation de fichiers génomiques
Pour importer des fichiers génomiques dans un magasin de séquences, procédez comme suit :
**Pour importer un fichier génomique**
1. Ouvrez la [HealthOmics console](https://console.aws.amazon.com/omics/).
1. Si nécessaire, ouvrez le volet de navigation de gauche (≡). Choisissez Choisissez **Sequence stores**.
1. Sur la page **Magasins** de séquences, choisissez le magasin de séquences dans lequel vous souhaitez importer vos fichiers.
1. Sur la page du magasin de séquences individuelles, choisissez **Importer des fichiers génomiques**.
1. Sur la page **Spécifier les détails de l'importation**, fournissez les informations suivantes
+ Rôle **IAM : rôle** IAM qui peut accéder aux fichiers génomiques sur Amazon S3.
+ **Génome de référence** - Le génome de référence pour ces données génomiques.
1. Sur la page **Spécifier le manifeste d'importation**, spécifiez le **fichier manifeste** d'informations suivant. Le fichier manifeste est un fichier JSON ou YAML qui décrit les informations essentielles de vos données génomiques. Pour plus d'informations sur le fichier manifeste, consultez[Importation de jeux de lecture dans un magasin de HealthOmics séquences](import-sequence-store.md).
1. Cliquez sur **Créer une tâche d'importation**.
# Suppression des HealthOmics référentiels et des magasins de séquences
Les magasins de référence et de séquences peuvent être supprimés. Les magasins de séquences ne peuvent être supprimés que s'ils ne contiennent pas de jeux de lecture, et les magasins de référence ne peuvent être supprimés que s'ils ne contiennent pas de références. La suppression d'une séquence ou d'un magasin de référence supprime également toutes les balises associées à ce magasin.
L'exemple suivant montre comment supprimer un magasin de référence à l'aide du AWS CLI. Si l'action aboutit, vous ne recevrez pas de réponse. Dans l'exemple suivant, remplacez par `reference store ID` l'ID de votre boutique de référence.
```
aws omics delete-reference-store --id reference store ID
```
L'exemple suivant montre comment supprimer un magasin de séquences. Vous ne recevez pas de réponse si l'action aboutit. Dans l'exemple suivant, remplacez-le `sequence store ID` par votre identifiant de magasin de séquences.
```
aws omics delete-sequence-store --id sequence store ID
```
Vous pouvez également supprimer une référence dans un magasin de références, comme indiqué dans l'exemple suivant. Les références ne peuvent être supprimées que si elles ne sont pas utilisées dans un ensemble de lectures, un magasin de variantes ou un magasin d'annotations. Dans l'exemple suivant, remplacez `reference store ID` par l'ID de votre magasin de référence et remplacez `reference ID` par l'ID de la référence que vous souhaitez supprimer.
```
aws omics delete-reference --id reference ID --reference-store-id reference store ID
```
# Importation de jeux de lecture dans un magasin de HealthOmics séquences
Après avoir créé votre magasin de séquences, créez des tâches d'importation pour télécharger des ensembles de lectures dans le magasin de données. Vous pouvez charger vos fichiers depuis un compartiment Amazon S3, ou vous pouvez les télécharger directement à l'aide des opérations d'API synchrones. Votre compartiment Amazon S3 doit se trouver dans la même région que votre magasin de séquences.
Vous pouvez télécharger n'importe quelle combinaison d'ensembles de lecture alignés et non alignés dans votre magasin de séquences. Toutefois, si l'un des ensembles de lecture de votre importation est aligné, vous devez inclure un génome de référence.
Vous pouvez réutiliser la politique d'accès IAM que vous avez utilisée pour créer le magasin de référence.
Les rubriques suivantes décrivent les principales étapes à suivre pour importer un jeu de lectures dans votre magasin de séquences, puis obtenir des informations sur les données importées.
**Topics**
+ [Charger des fichiers sur Amazon S3](#upload-files-to-s3)
+ [Création d’un fichier manifeste](#create-manifest-file)
+ [Démarrage de la tâche d'importation](#start-import-job)
+ [Surveiller la tâche d'importation](#monitor-import-job)
+ [Trouvez les fichiers de séquence importés](#list-read-sets)
+ [Obtenir des informations sur un kit de lecture](#get-read-set-metadata)
+ [Téléchargez les fichiers de données du jeu de lecture](#get-read-set-data)
## Charger des fichiers sur Amazon S3
L'exemple suivant montre comment déplacer des fichiers dans votre compartiment Amazon S3.
```
aws s3 cp s3://1000genomes/phase1/data/HG00100/alignment/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam s3://your-bucket
aws s3 cp s3://1000genomes/phase3/data/HG00146/sequence_read/SRR233106_1.filt.fastq.gz s3://your-bucket
aws s3 cp s3://1000genomes/phase3/data/HG00146/sequence_read/SRR233106_2.filt.fastq.gz s3://your-bucket
aws s3 cp s3://1000genomes/data/HG00096/alignment/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram s3://your-bucket
aws s3 cp s3://gatk-test-data/wgs_ubam/NA12878_20k/NA12878_A.bam s3://your-bucket
```
L'échantillon `BAM` `CRAM` utilisé dans cet exemple nécessite des références génomiques différentes, `Hg19` et`Hg38`. Pour en savoir plus ou pour accéder à ces références, voir [The Broad Genome References](https://registry.opendata.aws/broad-references/) dans le registre des données ouvertes sur AWS.
## Création d’un fichier manifeste
Vous devez également créer un fichier manifeste au format JSON pour modéliser la tâche d'importation `import.json` (voir l'exemple suivant). Si vous créez un magasin de séquences dans la console, il n'est pas nécessaire de spécifier le `sequenceStoreId` ou`roleARN`. Votre fichier manifeste commence donc par l'`sources`entrée.
------
#### [ API manifest ]
L'exemple suivant importe trois ensembles de lecture à l'aide de l'API : un `FASTQ``BAM`, un et un`CRAM`.
```
{
"sequenceStoreId": "3936421177",
"roleArn": "arn:aws:iam::555555555555:role/OmicsImport",
"sources":
[
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
// NOTE: there is no reference arn required here
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"subjectId": "mySubject",
"sampleId": "mySample",
// NOTE: there is no reference arn required here
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data"
}
]
}
```
------
#### [ Console manifest ]
Cet exemple de code est utilisé pour importer un seul ensemble de lectures à l'aide de la console.
```
[
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://your-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data"
}
]
```
------
Vous pouvez également télécharger le fichier manifeste au format YAML.
## Démarrage de la tâche d'importation
Pour démarrer la tâche d'importation, utilisez la AWS CLI commande suivante.
```
aws omics start-read-set-import-job --cli-input-json file://import.json
```
Vous recevez la réponse suivante, qui indique une création d'emploi réussie.
```
{
"id": "3660451514",
"sequenceStoreId": "3936421177",
"roleArn": "arn:aws:iam::111122223333:role/OmicsImport",
"status": "CREATED",
"creationTime": "2022-07-13T22:14:59.309Z"
}
```
## Surveiller la tâche d'importation
Une fois la tâche d'importation lancée, vous pouvez suivre sa progression à l'aide de la commande suivante. Dans l'exemple suivant, remplacez `sequence store id` par l'ID de votre magasin de séquences et remplacez `job import ID` par l'ID d'importation.
```
aws omics get-read-set-import-job --sequence-store-id sequence store id --id job import ID
```
Voici les statuts de toutes les tâches d'importation associées à l'ID de magasin de séquences spécifié.
```
{
"id": "1234567890",
"sequenceStoreId": "1234567890",
"roleArn": "arn:aws:iam::111122223333:role/OmicsImport",
"status": "RUNNING",
"statusMessage": "The job is currently in progress.",
"creationTime": "2022-07-13T22:14:59.309Z",
"sources": [
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00100.chrom20.ILLUMINA.bwa.GBR.low_coverage.20101123.bam"
},
"sourceFileType": "BAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/3242349265/reference/8625408453",
"name": "HG00100",
"description": "BAM for HG00100",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/SRR233106_1.filt.fastq.gz",
"source2": "s3://amzn-s3-demo-bucket/SRR233106_2.filt.fastq.gz"
},
"sourceFileType": "FASTQ",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "HG00146",
"description": "FASTQ for HG00146",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/HG00096.alt_bwamem_GRCh38DH.20150718.GBR.low_coverage.cram"
},
"sourceFileType": "CRAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/3242349265/reference/1234568870",
"name": "HG00096",
"description": "CRAM for HG00096",
"generatedFrom": "1000 Genomes",
"readSetID": "1234567890"
},
{
"sourceFiles":
{
"source1": "s3://amzn-s3-demo-bucket/NA12878_A.bam"
},
"sourceFileType": "UBAM",
"status": "IN_PROGRESS",
"statusMessage": "The job is currently in progress."
"subjectId": "mySubject",
"sampleId": "mySample",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"generatedFrom": "GATK Test Data",
"readSetID": "1234567890"
}
]
}
```
## Trouvez les fichiers de séquence importés
Une fois le travail terminé, vous pouvez utiliser l'opération **list-read-sets**API pour rechercher les fichiers de séquence importés. Dans l'exemple suivant, remplacez-le `sequence store id` par votre identifiant de magasin de séquences.
```
aws omics list-read-sets --sequence-store-id sequence store id
```
Vous recevez la réponse suivante.
```
{
"readSets": [
{
"id": "0000000001",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/01234567890/readSet/0000000001",
"sequenceStoreId": "1234567890",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00100",
"description": "BAM for HG00100",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/01234567890/reference/0000000001",
"fileType": "BAM",
"sequenceInformation": {
"totalReadCount": 9194,
"totalBaseCount": 928594,
"generatedFrom": "1000 Genomes",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:25:20Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "d1d65429212d61d115bb19f510d4bd02"
}
},
{
"id": "0000000002",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000002",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00146",
"description": "FASTQ for HG00146",
"fileType": "FASTQ",
"sequenceInformation": {
"totalReadCount": 8000000,
"totalBaseCount": 1184000000,
"generatedFrom": "1000 Genomes",
"alignment": "UNALIGNED"
},
"creationTime": "2022-07-13T23:26:43Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "FASTQ_MD5up",
"source1": "ca78f685c26e7cc2bf3e28e3ec4d49cd"
}
},
{
"id": "0000000003",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000003",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00096",
"description": "CRAM for HG00096",
"referenceArn": "arn:aws:omics:us-west-2:111122223333:referenceStore/0123456789/reference/0000000001",
"fileType": "CRAM",
"sequenceInformation": {
"totalReadCount": 85466534,
"totalBaseCount": 24000004881,
"generatedFrom": "1000 Genomes",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:30:41Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "CRAM_MD5up",
"source1": "66817940f3025a760e6da4652f3e927e"
}
},
{
"id": "0000000004",
"arn": "arn:aws:omics:us-west-2:111122223333:sequenceStore/0123456789/readSet/0000000004",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "NA12878_A",
"description": "uBAM for NA12878",
"fileType": "UBAM",
"sequenceInformation": {
"totalReadCount": 20000,
"totalBaseCount": 5000000,
"generatedFrom": "GATK Test Data",
"alignment": "ALIGNED"
},
"creationTime": "2022-07-13T23:30:41Z"
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "640eb686263e9f63bcda12c35b84f5c7"
}
}
]
}
```
## Obtenir des informations sur un kit de lecture
Pour afficher plus de détails sur un ensemble de lectures, utilisez l'opération **GetReadSetMetadata**API. Dans l'exemple suivant, remplacez `sequence store id` par votre identifiant de magasin de séquences et remplacez `read set id` par votre identifiant de jeu de lecture.
```
aws omics get-read-set-metadata --sequence-store-id sequence store id --id read set id
```
Vous recevez la réponse suivante.
```
{
"arn": "arn:aws:omics:us-west-2:123456789012:sequenceStore/2015356892/readSet/9515444019",
"creationTime": "2024-01-12T04:50:33.548Z",
"creationType": "IMPORT",
"creationJobId": "33222111",
"description": null,
"etag": {
"algorithm": "FASTQ_MD5up",
"source1": "00d0885ba3eeb211c8c84520d3fa26ec",
"source2": "00d0885ba3eeb211c8c84520d3fa26ec"
},
"fileType": "FASTQ",
"files": {
"index": null,
"source1": {
"contentLength": 10818,
"partSize": 104857600,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
"totalParts": 1
},
"source2": {
"contentLength": 10818,
"partSize": 104857600,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
"totalParts": 1
}
},
"id": "9515444019",
"name": "paired-fastq-import",
"sampleId": "sampleId-paired-fastq-import",
"sequenceInformation": {
"alignment": "UNALIGNED",
"generatedFrom": null,
"totalBaseCount": 30000,
"totalReadCount": 200
},
"sequenceStoreId": "2015356892",
"status": "ACTIVE",
"statusMessage": null,
"subjectId": "subjectId-paired-fastq-import"
}
```
## Téléchargez les fichiers de données du jeu de lecture
Vous pouvez accéder aux objets d'un ensemble de lecture actif à l'aide de l'opération d'**GetObject**API Amazon S3. L'URI de l'objet est renvoyé dans la réponse de l'**GetReadSetMetadata**API. Pour de plus amples informations, veuillez consulter [Accès aux ensembles de HealthOmics lecture avec Amazon S3 URIs](s3-access.md).
Vous pouvez également utiliser l'opération HealthOmics **GetReadSet** API. Vous pouvez **GetReadSet** utiliser le téléchargement en parallèle en téléchargeant des parties individuelles. Ces composants sont similaires aux composants Amazon S3. Voici un exemple de téléchargement de la partie 1 à partir d'un jeu de lecture. Dans l'exemple suivant, remplacez `sequence store id` par votre identifiant de magasin de séquences et remplacez `read set id` par votre identifiant de jeu de lecture.
```
aws omics get-read-set --sequence-store-id sequence store id --id read set id --part-number 1 outfile.bam
```
Vous pouvez également utiliser le gestionnaire de HealthOmics transfert pour télécharger des fichiers à des fins de HealthOmics référence ou de lecture. Vous pouvez télécharger le gestionnaire HealthOmics de transferts [ici](https://pypi.org/project/amazon-omics-tools/). Pour plus d'informations sur l'utilisation et la configuration du gestionnaire de transfert, consultez ce [GitHubréférentiel](https://github.com/awslabs/amazon-omics-tools/).
# Téléchargement direct vers un magasin de HealthOmics séquences
Nous vous recommandons d'utiliser le gestionnaire HealthOmics de transfert pour ajouter des fichiers à votre magasin de séquences. Pour plus d'informations sur l'utilisation de Transfer Manager, consultez ce [GitHubréférentiel](https://github.com/awslabs/amazon-omics-tools/). Vous pouvez également télécharger vos ensembles de lecture directement dans un magasin de séquences via les opérations d'API de téléchargement direct.
Les ensembles de lecture à téléchargement direct existent en `PROCESSING_UPLOAD` premier. Cela signifie que les parties du fichier sont en cours de téléchargement et que vous pouvez accéder aux métadonnées du jeu de lecture. Une fois les parties téléchargées et les checksums validés, le jeu de lecture devient `ACTIVE` et se comporte de la même manière qu'un jeu de lecture importé.
Si le téléchargement direct échoue, l'état du jeu de lecture est affiché sous la forme`UPLOAD_FAILED`. Vous pouvez configurer un compartiment Amazon S3 comme emplacement de secours pour les fichiers qui ne parviennent pas à être chargés. Des emplacements de secours sont disponibles pour les magasins de séquences créés après le 15 mai 2023.
**Topics**
+ [Téléchargement direct vers un magasin de séquences à l'aide du AWS CLI](#synchronous-uploads-api)
+ [Configuration d'un emplacement de secours](#synchronous-uploads-fallback)
## Téléchargement direct vers un magasin de séquences à l'aide du AWS CLI
Pour commencer, lancez un téléchargement en plusieurs parties. Vous pouvez le faire en utilisant le AWS CLI, comme indiqué dans l'exemple suivant.
**Pour effectuer un téléchargement direct à l'aide de AWS CLI commandes**
1. Créez les parties en séparant vos données, comme indiqué dans l'exemple suivant.
```
split -b 100MiB SRR233106_1.filt.fastq.gz source1_part_
```
1. Une fois que vos fichiers source sont divisés en plusieurs parties, créez un téléchargement de jeux de lecture en plusieurs parties, comme indiqué dans l'exemple suivant. Remplacez `sequence store ID` les autres paramètres par votre identifiant de magasin de séquences et d'autres valeurs.
```
aws omics create-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--name upload name \
--source-file-type FASTQ \
--subject-id subject ID \
--sample-id sample ID \
--description "FASTQ for HG00146" "description of upload" \
--generated-from "1000 Genomes""source of imported files"
```
Vous obtenez les métadonnées `uploadID` et les autres dans la réponse. Utilisez le `uploadID` pour l'étape suivante du processus de téléchargement.
```
{
"sequenceStoreId": "1504776472",
"uploadId": "7640892890",
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"name": "HG00146",
"description": "FASTQ for HG00146",
"creationTime": "2023-11-20T23:40:47.437522+00:00"
}
```
1. Ajoutez vos ensembles de lecture au téléchargement. Si votre fichier est suffisamment petit, vous ne devez effectuer cette étape qu'une seule fois. Pour les fichiers plus volumineux, vous devez effectuer cette étape pour chaque partie du fichier. Si vous chargez une nouvelle pièce en utilisant un numéro de pièce déjà utilisé, il remplace la pièce précédemment téléchargée.
Dans l'exemple suivant, remplacez `sequence store ID``upload ID`, et les autres paramètres par vos valeurs.
```
aws omics upload-read-set-part \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--part-source SOURCE1 \
--part-number part number \
--payload source1/source1_part_aa.fastq.gz
```
La réponse est un identifiant que vous pouvez utiliser pour vérifier que le fichier téléchargé correspond au fichier que vous vouliez.
```
{
"checksum": "984979b9928ae8d8622286c4a9cd8e99d964a22d59ed0f5722e1733eb280e635"
}
```
1. Poursuivez le téléchargement des parties de votre fichier, si nécessaire. Pour vérifier que vos ensembles de lecture ont été téléchargés, utilisez l'opération d'API **list-read-set-upload-parts**, comme indiqué ci-dessous. Dans l'exemple suivant, remplacez `sequence store ID ``upload ID`, et `part source` par votre propre entrée.
```
aws omics list-read-set-upload-parts \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--part-source SOURCE1
```
La réponse renvoie le nombre d'ensembles de lecture, la taille et l'horodatage de la dernière mise à jour.
```
{
"parts": [
{
"partNumber": 1,
"partSize": 104857600,
"partSource": "SOURCE1",
"checksum": "MVMQk+vB9C3Ge8ADHkbKq752n3BCUzyl41qEkqlOD5M=",
"creationTime": "2023-11-20T23:58:03.500823+00:00",
"lastUpdatedTime": "2023-11-20T23:58:03.500831+00:00"
},
{
"partNumber": 2,
"partSize": 104857600,
"partSource": "SOURCE1",
"checksum": "keZzVzJNChAqgOdZMvOmjBwrOPM0enPj1UAfs0nvRto=",
"creationTime": "2023-11-21T00:02:03.813013+00:00",
"lastUpdatedTime": "2023-11-21T00:02:03.813025+00:00"
},
{
"partNumber": 3,
"partSize": 100339539,
"partSource": "SOURCE1",
"checksum": "TBkNfMsaeDpXzEf3ldlbi0ipFDPaohKHyZ+LF1J4CHk=",
"creationTime": "2023-11-21T00:09:11.705198+00:00",
"lastUpdatedTime": "2023-11-21T00:09:11.705208+00:00"
}
]
}
```
1. Pour afficher tous les téléchargements de sets de lecture partitionnés actifs, utilisez **list-multipart-read-set-uploads,** comme indiqué ci-dessous. `sequence store ID`Remplacez-le par l'ID de votre propre magasin de séquences.
```
aws omics list-multipart-read-set-uploads --sequence-store-id
sequence store ID
```
Cette API renvoie uniquement les téléchargements de jeux de lecture partitionnés en cours. Une fois les ensembles de lecture ingérés`ACTIVE`, ou si le téléchargement a échoué, le téléchargement ne sera pas renvoyé dans la réponse à l'API **list-multipart-read-set-uploads**. Pour afficher les ensembles de lecture actifs, utilisez l'**list-read-sets**API. Un exemple de réponse pour **list-multipart-read-set-uploads** est présenté ci-dessous.
```
{
"uploads": [
{
"sequenceStoreId": "1234567890",
"uploadId": "8749584421",
"sourceFileType": "FASTQ",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"name": "HG00146",
"description": "FASTQ for HG00146",
"creationTime": "2023-11-29T19:22:51.349298+00:00"
},
{
"sequenceStoreId": "1234567890",
"uploadId": "5290538638",
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/8168613728/reference/2190697383",
"name": "HG00146",
"description": "BAM for HG00146",
"creationTime": "2023-11-29T19:23:33.116516+00:00"
},
{
"sequenceStoreId": "1234567890",
"uploadId": "4174220862",
"sourceFileType": "BAM",
"subjectId": "mySubject",
"sampleId": "mySample",
"generatedFrom": "1000 Genomes",
"referenceArn": "arn:aws:omics:us-west-2:123456789012:referenceStore/8168613728/reference/2190697383",
"name": "HG00147",
"description": "BAM for HG00147",
"creationTime": "2023-11-29T19:23:47.007866+00:00"
}
]
}
```
1. Après avoir chargé toutes les parties de votre fichier, utilisez **complete-multipart-read-set-upload** pour terminer le processus de téléchargement, comme indiqué dans l'exemple suivant. Remplacez `sequence store ID``upload ID`, et le paramètre des pièces par vos propres valeurs.
```
aws omics complete-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--upload-id upload ID \
--parts '[{"checksum":"gaCBQMe+rpCFZxLpoP6gydBoXaKKDA/Vobh5zBDb4W4=","partNumber":1,"partSource":"SOURCE1"}]'
```
La réponse pour **complete-multipart-read-set-upload** est le jeu de lecture IDs pour vos ensembles de lecture importés.
```
{
"readSetId": "0000000001"
}
```
1. Pour arrêter le téléchargement, utilisez **abort-multipart-read-set-upload** avec l'ID de téléchargement pour terminer le processus de téléchargement. Remplacez `sequence store ID` et `upload ID` par vos propres valeurs de paramètres.
```
aws omics abort-multipart-read-set-upload \
--sequence-store-id sequence store ID \
--upload-id upload ID
```
1. Une fois le téléchargement terminé, récupérez vos données depuis le set de lecture en utilisant **get-read-set**, comme indiqué ci-dessous. Si le téléchargement est toujours en cours de traitement, **get-read-set**renvoie des métadonnées limitées et les fichiers d'index générés ne sont pas disponibles. Remplacez `sequence store ID` les autres paramètres par vos propres données.
```
aws omics get-read-set
--sequence-store-id sequence store ID \
--id read set ID \
--file SOURCE1 \
--part-number 1 myfile.fastq.gz
```
1. Pour vérifier les métadonnées, y compris le statut de votre téléchargement, utilisez l'opération **get-read-set-metadata**API.
```
aws omics get-read-set-metadata --sequence-store-id sequence store ID --id read set ID
```
La réponse inclut des détails de métadonnées tels que le type de fichier, l'ARN de référence, le nombre de fichiers et la longueur des séquences. Il inclut également le statut. Les statuts possibles sont `PROCESSING_UPLOAD``ACTIVE`, et. `UPLOAD_FAILED`
```
{
"id": "0000000001",
"arn": "arn:aws:omics:us-west-2:555555555555:sequenceStore/0123456789/readSet/0000000001",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "PROCESSING_UPLOAD",
"name": "HG00146",
"description": "FASTQ for HG00146",
"fileType": "FASTQ",
"creationTime": "2022-07-13T23:25:20Z",
"files": {
"source1": {
"totalParts": 5,
"partSize": 123456789012,
"contentLength": 6836725,
},
"source2": {
"totalParts": 5,
"partSize": 123456789056,
"contentLength": 6836726
}
},
'creationType": "UPLOAD"
}
```
## Configuration d'un emplacement de secours
Lorsque vous créez ou mettez à jour un magasin de séquences, vous pouvez configurer un compartiment Amazon S3 comme emplacement de secours pour les fichiers qui ne parviennent pas à être chargés. Les parties du fichier correspondant à ces ensembles de lecture sont transférées vers l'emplacement de secours. Des emplacements de secours sont disponibles pour les magasins de séquences créés après le 15 mai 2023.
Créez une politique de compartiment Amazon S3 pour accorder un accès en HealthOmics écriture à l'emplacement de secours d'Amazon S3, comme illustré dans l'exemple suivant :
```
{
"Effect": "Allow",
"Principal": {
"Service": "omics.amazonaws.com"
},
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
```
Si le compartiment Amazon S3 pour les journaux de secours ou d'accès utilise une clé gérée par le client, ajoutez les autorisations suivantes à la politique en matière de clés :
```
{
"Sid": "Allow use of key",
"Effect": "Allow",
"Principal": {
"Service": "omics.amazonaws.com"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey*"
],
"Resource": "*"
}
```
# Exporter HealthOmics des ensembles de lectures vers un compartiment Amazon S3
Vous pouvez exporter des ensembles de lectures sous forme de tâche d'exportation par lots vers un compartiment Amazon S3. Pour ce faire, créez d'abord une stratégie IAM dotée d'un accès en écriture au bucket, comme dans l'exemple de stratégie IAM suivant.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
------
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"omics.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Une fois la politique IAM en place, commencez votre travail d'exportation du set de lecture. L'exemple suivant montre comment procéder à l'aide de l'opération **start-read-set-exportd'API -job**. Dans l'exemple suivant, remplacez tous les paramètres, tels que `sequence store ID``destination`,`role ARN`, et`sources`, par votre entrée.
```
aws omics start-read-set-export-job
--sequence-store-id sequence store id \
--destination valid s3 uri \
--role-arn role ARN \
--sources readSetId=read set id_1 readSetId=read set id_2
```
Vous recevez la réponse suivante contenant des informations sur le magasin de séquences d'origine et le compartiment Amazon S3 de destination.
```
{
"id": ,
"sequenceStoreId": ,
"destination": ,
"status": "SUBMITTED",
"creationTime": "2022-10-22T01:33:38.079000+00:00"
}
```
Une fois la tâche démarrée, vous pouvez déterminer son statut à l'aide de l'opération **get-read-set-exportd'API -job**, comme indiqué ci-dessous. Remplacez le `sequence store ID` et `job ID` par votre identifiant de magasin de séquences et votre identifiant de tâche, respectivement.
```
aws omics get-read-set-export-job --id job-id --sequence-store-id sequence store ID
```
Vous pouvez afficher toutes les tâches d'exportation initialisées pour un magasin de séquences à l'aide de l'opération ** list-read-set-exportd'API -jobs**, comme illustré ci-dessous. Remplacez le `sequence store ID` par votre identifiant de magasin de séquences.
```
aws omics list-read-set-export-jobs --sequence-store-id sequence store ID.
```
```
{
"exportJobs": [
{
"id": ,
"sequenceStoreId": ,
"destination": ,
"status": "COMPLETED",
"creationTime": "2022-10-22T01:33:38.079000+00:00",
"completionTime": "2022-10-22T01:34:28.941000+00:00"
}
]
}
```
En plus d'exporter vos ensembles de lecture, vous pouvez également les partager en utilisant l'accès Amazon S3 URIs. Pour en savoir plus, consultez [Accès aux ensembles de HealthOmics lecture avec Amazon S3 URIs](s3-access.md).
# Accès aux ensembles de HealthOmics lecture avec Amazon S3 URIs
Vous pouvez utiliser les chemins d'URI Amazon S3 pour accéder aux ensembles de lecture de votre magasin de séquences actif.
Avec le chemin d'URI Amazon S3, vous pouvez utiliser les opérations Amazon S3 pour répertorier, partager et télécharger vos ensembles de lectures. L'accès via le S3 APIs accélère la collaboration et l'intégration des outils étant donné que de nombreux outils du secteur sont déjà conçus pour lire depuis S3. En outre, vous pouvez partager l'accès au S3 APIs avec d'autres comptes et fournir un accès en lecture aux données entre les régions.
HealthOmics ne prend pas en charge l'accès par URI Amazon S3 aux ensembles de lecture archivés. Lorsque vous activez un ensemble de lecture, il est restauré dans le même chemin d'URI à chaque fois.
Lorsque les données sont chargées dans HealthOmics les magasins, étant donné que l'URI Amazon S3 est basée sur les points d'accès Amazon S3, vous pouvez l'intégrer directement aux outils standard du secteur qui lisent Amazon S3 URIs, tels que les suivants :
+ Applications d'analyse visuelle telles que Integrative Genomics Viewer (IGV) ou UCSC Genome Browser.
+ Workflows courants avec les extensions Amazon S3 telles que CWL, WDL et Nextflow.
+ Tout outil capable d'authentifier et de lire depuis le point d'accès Amazon S3 URIs ou de lire un Amazon S3 présigné. URIs
+ Utilitaires Amazon S3 tels que Mountpoint ou. CloudFront
Amazon S3 Mountpoint vous permet d'utiliser un compartiment Amazon S3 comme système de fichiers local. Pour en savoir plus sur Mountpoint et pour l'installer en vue de son utilisation, consultez [Mountpoint pour Amazon S3](https://github.com/awslabs/mountpoint-s3).
Amazon CloudFront est un service de réseau de diffusion de contenu (CDN) conçu pour optimiser les performances, la sécurité et le confort des développeurs. Pour en savoir plus sur l'utilisation d'Amazon CloudFront, consultez [la CloudFront documentation Amazon](https://docs.aws.amazon.com/cloudfront/). Pour configurer CloudFront un magasin de séquences, contactez l' AWS HealthOmics équipe.
Le compte root du propriétaire des données est activé pour les actions S3 :GetObject, S3 : GetObjectTagging et S3:List Bucket sur le préfixe du magasin de séquences. Pour qu'un utilisateur du compte puisse accéder aux données, vous devez créer une politique IAM et l'associer à l'utilisateur ou au rôle. Pour un exemple de politique, consultez [Autorisations d'accès aux données à l'aide d'Amazon S3 URIs](s3-sharing.md).
Vous pouvez utiliser les opérations d'API Amazon S3 suivantes sur les ensembles de lecture actifs pour répertorier et récupérer vos données. Vous pouvez accéder aux ensembles de lecture archivés via Amazon S3 une URIs fois qu'ils ont été activés.
+ [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)— Récupère un objet depuis Amazon S3.
+ [HeadObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html.html)— L'opération HEAD récupère les métadonnées d'un objet sans renvoyer l'objet lui-même. Cette opération est utile si vous souhaitez uniquement les métadonnées d'un objet.
+ [ListObjects et ListObject v2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html) — Renvoie une partie ou la totalité (jusqu'à 1 000) des objets d'un compartiment.
+ [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)— Crée une copie d'un objet déjà stocké dans Amazon S3. HealthOmicsprend en charge la copie vers un point d'accès Amazon S3, mais pas l'écriture sur un point d'accès.
HealthOmics les magasins de séquences conservent l'identité sémantique des fichiers via ETags. Tout au long du cycle de vie d'un fichier, l'Amazon S3 ETag, qui est basé sur l'identité bit à bit, peut changer, mais cela HealthOmics ETag reste le même. Pour en savoir plus, veuillez consulter la section [HealthOmics ETags et provenance des données](etags-and-provenance.md).
**Topics**
+ [Structure d'URI Amazon S3 dans le HealthOmics stockage](#s3-uri-structure)
+ [Utilisation d'un IGV hébergé ou local pour accéder aux ensembles de lecture](#s3-access-igv)
+ [À l'aide de Samtools ou HTSlib dans HealthOmics](#s3-access-Samtools)
+ [Utilisation de Mountpoint HealthOmics](#s3-access-Mountpoint)
+ [Utilisation CloudFront avec HealthOmics](#s3-access-CloudFront)
## Structure d'URI Amazon S3 dans le HealthOmics stockage
Tous les fichiers associés à Amazon S3 URIs possèdent `omics:subjectId` des balises de `omics:sampleId` ressource. Vous pouvez utiliser ces balises pour partager l'accès en utilisant des politiques IAM via un modèle tel que`"s3:ExistingObjectTag/omics:subjectId": "pattern desired"`.
La structure du fichier est la suivante :
`.../account_id/sequenceStore/seq_store_id/readSet/read_set_id/files.`
Pour les fichiers importés dans des magasins de séquences depuis Amazon S3, le magasin de séquences tente de conserver le nom de source d'origine. En cas de conflit entre les noms, le système ajoute des informations relatives aux ensembles de lecture pour garantir que les noms de fichiers sont uniques. Par exemple, pour les ensembles de lecture fastq, si les deux noms de fichiers sont identiques, afin de rendre les noms uniques, ils sont insérés avant `sourceX` .fastq.gz ou .fq.gz. Pour un téléchargement direct, les noms de fichiers suivent les modèles suivants :
+ Pour FASTQ— *read\$1set\$1name* \$1 *sourcex* .fastq.gz
+ Pour uBAM/BAM/CRAM —*read\$1set\$1name*. *file extension*avec des extensions de `.bam` ou`.cram`. Par exemple : `NA193948.bam`.
Pour les ensembles de lecture BAM ou CRAM, les fichiers d'index sont automatiquement générés pendant le processus d'ingestion. Pour les fichiers d'index générés, l'extension d'index appropriée à la fin du nom de fichier est appliquée. Il a le modèle *..* Les extensions d'index sont `.bai` ou`.crai`.
## Utilisation d'un IGV hébergé ou local pour accéder aux ensembles de lecture
IGV est un navigateur génomique utilisé pour analyser les fichiers BAM et CRAM. Il nécessite à la fois le fichier et l'index car il n'affiche qu'une partie du génome à la fois. L'IGV peut être téléchargé et utilisé localement, et il existe des guides pour créer un IGV hébergé par AWS. La version Web publique n'est pas prise en charge car elle nécessite CORS.
L'IGV local s'appuie sur la AWS configuration locale pour accéder aux fichiers. Assurez-vous que le rôle utilisé dans cette configuration est associé à une politique qui active les GetObject autorisations kms: Decrypt et s3 : sur l'URI s3 des ensembles de lecture auxquels vous accédez. Ensuite, dans IGV, vous pouvez utiliser « Fichier > charger à partir de l'URL » et coller l'URI pour la source et l'index. Sinon, le pré-signé URLs peut être généré et utilisé de la même manière, ce qui permettra de contourner la configuration AWS. Notez que CORS n'est pas pris en charge avec l'accès aux URI Amazon S3. Les demandes basées sur CORS ne sont donc pas prises en charge.
L'exemple AWS Hosted IGV s'appuie sur AWS Cognito pour créer les configurations et les autorisations appropriées au sein de l'environnement. Assurez-vous de créer une politique qui active les autorisations KMS:Decrypt et s3 : sur GetObject l'URI Amazon S3 des ensembles de lecture auxquels vous accédez, et ajoutez cette politique au rôle attribué au groupe d'utilisateurs Cognito. Ensuite, dans IGV, vous pouvez utiliser « Fichier > charger à partir de l'URL » et saisir l'URI de la source et de l'index. Sinon, le pré-signé URLs peut être généré et utilisé de la même manière, sans passer par la configuration AWS.
Notez que le magasin de séquences n'apparaîtra pas sous l'onglet « Amazon » car il affiche uniquement les buckets dont vous êtes propriétaire dans la région dans laquelle le AWS profil est configuré.
## À l'aide de Samtools ou HTSlib dans HealthOmics
HTSlib est la bibliothèque principale partagée par plusieurs outils tels que Samtools, RSAMTools et autres PySam. Utilisez HTSlib la version 1.20 ou ultérieure pour bénéficier d'une prise en charge fluide des points d'accès Amazon S3. Pour les anciennes versions de la HTSlib bibliothèque, vous pouvez utiliser les solutions suivantes :
+ Définissez la variable d'environnement pour l'hôte HTS Amazon S3 avec :`export HTS_S3_HOST="s3.region.amazonaws.com"`.
+ Générez une URL présignée pour les fichiers que vous souhaitez utiliser. Si un BAM ou un CRAM est utilisé, assurez-vous qu'une URL présignée est générée à la fois pour le fichier et pour l'index. Ensuite, les deux fichiers peuvent être utilisés avec les bibliothèques.
+ Utilisez Mountpoint pour monter le magasin de séquences ou le préfixe du set de lecture dans le même environnement que celui dans lequel vous utilisez des bibliothèques. HTSlib À partir de là, les fichiers sont accessibles en utilisant les chemins de fichiers locaux.
## Utilisation de Mountpoint HealthOmics
Mountpoint pour Amazon S3 est un client de fichiers simple à haut débit permettant de monter un compartiment [Amazon S3 en tant que](https://aws.amazon.com/blogs/storage/the-inside-story-on-mountpoint-for-amazon-s3-a-high-performance-open-source-file-client/) système de fichiers local. Avec Mountpoint pour Amazon S3, vos applications peuvent accéder aux objets stockés dans Amazon S3 par le biais d'opérations de fichier telles que l'ouverture et la lecture. Mountpoint for Amazon S3 traduit automatiquement ces opérations en appels d'API d'objets Amazon S3, permettant ainsi à vos applications d'accéder au stockage et au débit élastiques d'Amazon S3 via une interface de fichier.
Mountpoint peut être installé à l'aide des instructions d'installation [de Mountpoint](https://github.com/awslabs/mountpoint-s3/blob/main/doc/INSTALL.md). Mountpoint utilise le profil AWS local à l'installation et fonctionne au niveau du préfixe Amazon S3. Assurez-vous que le profil utilisé dispose d'une politique qui active les autorisations s3 :GetObject, s3 : ListBucket et kms: Decrypt sur le préfixe d'URI Amazon S3 du ou des ensembles de lecture ou du magasin de séquences auxquels vous accédez. Ensuite, le godet peut être monté en utilisant le chemin suivant :
```
mount-s3 access point arn local path to mount --prefix prefix to sequence store or read set --region region
```
## Utilisation CloudFront avec HealthOmics
Amazon CloudFront est un service de réseau de diffusion de contenu (CDN) conçu pour optimiser les performances, la sécurité et le confort des développeurs. Les clients qui souhaitent l'utiliser CloudFront doivent contacter l'équipe du service pour activer la CloudFront distribution. Collaborez avec l'équipe chargée de votre compte pour impliquer l'équipe HealthOmics de service.
# L'activation de la lecture s'installe dans HealthOmics
Vous pouvez activer les ensembles de lecture archivés à l'aide de l'opération **start-read-set-activationd'API -job** ou via le AWS CLI, comme indiqué dans l'exemple suivant. Remplacez le `sequence store ID` et `read set id` par votre identifiant de magasin de séquences et votre ensemble de lecture IDs.
```
aws omics start-read-set-activation-job
--sequence-store-id sequence store ID \
--sources readSetId=read set ID readSetId=read set id_1 read set id_2
```
Vous recevez une réponse contenant les informations relatives à la tâche d'activation, comme indiqué ci-dessous.
```
{
"id": "12345678",
"sequenceStoreId": "1234567890",
"status": "SUBMITTED",
"creationTime": "2022-10-22T00:50:54.670000+00:00"
}
```
Une fois la tâche d'activation lancée, vous pouvez suivre sa progression à l'aide de l'opération **get-read-set-activationd'API -job**. Voici un exemple d'utilisation du pour vérifier le statut AWS CLI de votre tâche d'activation. Remplacez `job ID` et `sequence store ID` par votre identifiant de magasin de séquences et votre tâche IDs, respectivement.
```
aws omics get-read-set-activation-job --id job ID --sequence-store-id sequence store ID
```
La réponse résume la tâche d'activation, comme indiqué ci-dessous.
```
{
"id": 123567890,
"sequenceStoreId": 123467890,
"status": "SUBMITTED",
"statusUpdateReason": "The job is submitted and will start soon.",
"creationTime": "2022-10-22T00:50:54.670000+00:00",
"sources": [
{
"readSetId": ,
"status": "NOT_STARTED",
"statusUpdateReason": "The source is queued for the job."
},
{
"readSetId": ,
"status": "NOT_STARTED",
"statusUpdateReason": "The source is queued for the job."
}
]
}
```
Vous pouvez vérifier l'état d'une tâche d'activation à l'aide de l'opération **get-read-set-metadata**API. Les statuts possibles sont `ACTIVE``ACTIVATING`, et. `ARCHIVED` Dans l'exemple suivant, remplacez `sequence store ID` par votre identifiant de magasin de séquences et remplacez `read set ID` par votre identifiant de jeu de lecture.
```
aws omics get-read-set-metadata --sequence-store-id sequence store ID --id read set ID
```
La réponse suivante indique que le set de lecture est actif.
```
{
"id": "12345678",
"arn": "arn:aws:omics:us-west-2:555555555555:sequenceStore/1234567890/readSet/12345678",
"sequenceStoreId": "0123456789",
"subjectId": "mySubject",
"sampleId": "mySample",
"status": "ACTIVE",
"name": "HG00100",
"description": "HG00100 aligned to HG38 BAM",
"fileType": "BAM",
"creationTime": "2022-07-13T23:25:20Z",
"sequenceInformation": {
"totalReadCount": 1513467,
"totalBaseCount": 163454436,
"generatedFrom": "Pulled from SRA",
"alignment": "ALIGNED"
},
"referenceArn": "arn:aws:omics:us-west-2:555555555555:referenceStore/0123456789/reference/0000000001",
"files": {
"source1": {
"totalParts": 2,
"partSize": 10485760,
"contentLength": 17112283,
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
},
"index": {
"totalParts": 1,
"partSize": 53216,
"contentLength": 10485760
"s3Access": {
"s3Uri": "s3://accountID-sequence store ID-ajdpi90jdas90a79fh9a8ja98jdfa9jf98-s3alias/592761533288/sequenceStore/2015356892/readSet/9515444019/import_source1.fastq.gz"
},
}
},
"creationType": "IMPORT",
"etag": {
"algorithm": "BAM_MD5up",
"source1": "d1d65429212d61d115bb19f510d4bd02"
}
}
```
Vous pouvez afficher toutes les tâches d'activation des ensembles de lecture à l'aide de **list-read-set-activation-jobs**, comme illustré dans l'exemple suivant. Dans l'exemple suivant, remplacez-le `sequence store ID` par votre identifiant de magasin de séquences.
```
aws omics list-read-set-activation-jobs --sequence-store-id sequence store ID
```
Vous recevez la réponse suivante.
```
{
"activationJobs": [
{
"id": 1234657890,
"sequenceStoreId": "1234567890",
"status": "COMPLETED",
"creationTime": "2022-10-22T01:33:38.079000+00:00",
"completionTime": "2022-10-22T01:34:28.941000+00:00"
}
]
}
```