

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

# Caricamento diretto su un archivio HealthOmics di sequenze
<a name="synchronous-uploads"></a>

Ti consigliamo di utilizzare HealthOmics Transfer Manager per aggiungere file al tuo archivio di sequenze. Per ulteriori informazioni sull'utilizzo di Transfer Manager, consultate questo [GitHubRepository](https://github.com/awslabs/amazon-omics-tools/). Puoi anche caricare i tuoi set di lettura direttamente in un archivio di sequenze tramite le operazioni dell'API di caricamento diretto. 

I set di lettura per il caricamento diretto esistono per primi nello `PROCESSING_UPLOAD` stato. Ciò significa che le parti del file sono attualmente in fase di caricamento ed è possibile accedere ai metadati del set di lettura. Dopo il caricamento delle parti e la convalida dei checksum, il set di lettura diventa `ACTIVE` e si comporta come un set di lettura importato. 

Se il caricamento diretto fallisce, lo stato del set di lettura viene visualizzato come. `UPLOAD_FAILED` Puoi configurare un bucket Amazon S3 come posizione di riserva per i file che non vengono caricati. Le posizioni di riserva sono disponibili per i sequence store creati dopo il 15 maggio 2023.

**Topics**
+ [Caricamento diretto in un archivio di sequenze utilizzando AWS CLI](#synchronous-uploads-api)
+ [Configura una posizione di fallback](#synchronous-uploads-fallback)

## Caricamento diretto in un archivio di sequenze utilizzando AWS CLI
<a name="synchronous-uploads-api"></a>

Per iniziare, avvia un caricamento in più parti. È possibile eseguire questa operazione utilizzando AWS CLI, come illustrato nell'esempio seguente.

**Per il caricamento diretto utilizzando AWS CLI i comandi**

1. Create le parti separando i dati, come illustrato nell'esempio seguente.

   ```
    split -b 100MiB SRR233106_1.filt.fastq.gz source1_part_ 
   ```

1. Dopo che i file sorgente sono stati suddivisi in parti, create un caricamento del set di lettura in più parti, come illustrato nell'esempio seguente. Sostituite `sequence store ID` e gli altri parametri con l'ID del vostro archivio di sequenza e altri valori.

   ```
   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"
   ```

   Ottieni i metadati `uploadID` e gli altri metadati nella risposta. Utilizza il `uploadID` per la fase successiva del processo di caricamento.

   ```
   {
   "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. Aggiungi i tuoi set di lettura al caricamento. Se il file è sufficientemente piccolo, è sufficiente eseguire questo passaggio una sola volta. Per file di grandi dimensioni, esegui questo passaggio per ogni parte del file. Se si carica una nuova parte utilizzando un numero di parte utilizzato in precedenza, la parte caricata in precedenza viene sovrascritta.

   Nell'esempio seguente `sequence store ID``upload ID`, sostituite e gli altri parametri con i vostri valori.

   ```
   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 risposta è un ID che potete utilizzare per verificare che il file caricato corrisponda al file desiderato.

   ```
   {
   "checksum": "984979b9928ae8d8622286c4a9cd8e99d964a22d59ed0f5722e1733eb280e635"
   }
   ```

1. Continua a caricare le parti del file, se necessario. Per verificare che i set di lettura siano stati caricati, utilizzate l'operazione API **list-read-set-upload-parts**, come illustrato di seguito. Nell'esempio seguente `sequence store ID ``upload ID`, sostituisci «e» `part source` con il tuo input.

   ```
   aws omics list-read-set-upload-parts \
    --sequence-store-id sequence store ID \
    --upload-id upload ID \
    --part-source SOURCE1
   ```

   La risposta restituisce il numero di set di lettura, la dimensione e il timestamp dell'ultimo aggiornamento.

   ```
   {
   "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. Per visualizzare tutti i caricamenti attivi di set di lettura multiparte, utilizzate **list-multipart-read-set-uploads,** come illustrato di seguito. `sequence store ID`Sostituitelo con l'ID del vostro archivio di sequenze.

   ```
   aws omics list-multipart-read-set-uploads --sequence-store-id 
                sequence store ID
   ```

   Questa API restituisce solo caricamenti di set di lettura multiparte in corso. **Dopo che i set di lettura sono stati inseriti`ACTIVE`, o se il caricamento non è riuscito, il caricamento non verrà restituito nella risposta all'API -uploads. list-multipart-read-set** Per visualizzare i set di lettura attivi, utilizza l'API. **list-read-sets** Di seguito è riportato un esempio di risposta per **list-multipart-read-set-uploads**. 

   ```
   {
   "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. Dopo aver caricato tutte le parti del file, usa **complete-multipart-read-set-upload** per concludere il processo di caricamento, come mostrato nell'esempio seguente. Sostituisci `sequence store ID` e il parametro per le parti con i tuoi valori. `upload ID`

   ```
   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 risposta per **complete-multipart-read-set-upload** è il set di lettura IDs per i set di lettura importati. 

   ```
   {
   "readSetId": "0000000001"
   }
   ```

1. Per interrompere il caricamento, usa **abort-multipart-read-set-upload** con l'ID di caricamento per terminare il processo di caricamento. Sostituisci `sequence store ID` e `upload ID` con i tuoi valori di parametro.

   ```
   aws omics abort-multipart-read-set-upload \
   --sequence-store-id sequence store ID \
   --upload-id upload ID
   ```

1. Una volta completato il caricamento, recuperate i dati dal set di lettura utilizzando **get-read-set**, come illustrato di seguito. Se il caricamento è ancora in fase di elaborazione, **get-read-set**restituisce metadati limitati e i file indice generati non sono disponibili. Sostituisci `sequence store ID` e gli altri parametri con il tuo input.

   ```
   aws omics get-read-set 
    --sequence-store-id sequence store ID \
    --id read set ID \
    --file SOURCE1 \
    --part-number 1 myfile.fastq.gz
   ```

1. Per controllare i metadati, incluso lo stato del caricamento, utilizza l'operazione **get-read-set-metadata**API.

   ```
   aws omics get-read-set-metadata --sequence-store-id sequence store ID --id read set ID    
   ```

   La risposta include dettagli sui metadati come il tipo di file, l'ARN di riferimento, il numero di file e la lunghezza delle sequenze. Include anche lo stato. Gli stati possibili sono `PROCESSING_UPLOAD``ACTIVE`, e`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"
   }
   ```

## Configura una posizione di fallback
<a name="synchronous-uploads-fallback"></a>

Quando crei o aggiorni un archivio di sequenze, puoi configurare un bucket Amazon S3 come posizione di riserva per i file che non vengono caricati. Le parti dei file per quei set di lettura vengono trasferite nella posizione di fallback. Le posizioni di riserva sono disponibili per i sequence store creati dopo il 15 maggio 2023. 

Crea una policy per i bucket di Amazon S3 per concedere l'accesso in HealthOmics scrittura alla posizione di fallback di Amazon S3, come illustrato nell'esempio seguente:

```
{
    "Effect": "Allow",
    "Principal": {
        "Service": "omics.amazonaws.com"
    },
    "Action": "s3:PutObject",
    "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
```

Se il bucket Amazon S3 per i fallback o i log di accesso utilizza una chiave gestita dal cliente, aggiungi le seguenti autorizzazioni alla policy chiave:

```
 {
    "Sid": "Allow use of key",
    "Effect": "Allow",
    "Principal": {
        "Service": "omics.amazonaws.com"
    },
    "Action": [
        "kms:Decrypt",
        "kms:GenerateDataKey*"
    ],
    "Resource": "*"
}
```