input:
path input_file
val name
val threshold
output:
path 'results.txt', emit: results
script:
"""
my_tool --name ${name} --threshold ${threshold} ${input_file}
"""
}
workflow MY_WORKFLOW {
my_task(
params.input_file,
params.name,
params.threshold
)
}
workflow {
MY_WORKFLOW()
}
```
------
#### [ CWL ]
```
cwlVersion: v1.2
class: Workflow
requirements:
InlineJavascriptRequirement: {}
inputs:
input_file: File
name: string
threshold: int
outputs:
result:
type: ...
outputSource: ...
steps:
my_task:
run:
class: CommandLineTool
baseCommand: my_tool
requirements:
...
inputs:
name:
type: string
inputBinding:
prefix: "--name"
threshold:
type: int
inputBinding:
prefix: "--threshold"
input_file:
type: File
inputBinding: {}
outputs:
results:
type: File
outputBinding:
glob: results.txt
```
------
# File template parameter untuk HealthOmics alur kerja
Template parameter menentukan parameter input untuk alur kerja. Anda dapat menentukan parameter input untuk membuat alur kerja Anda lebih fleksibel dan serbaguna. Misalnya, Anda dapat menentukan parameter untuk lokasi Amazon S3 dari file genom referensi. Template parameter dapat disediakan melalui layanan repositori berbasis Git atau drive lokal Anda. Pengguna kemudian dapat menjalankan alur kerja menggunakan berbagai set data.
Anda dapat membuat template parameter untuk alur kerja Anda, atau HealthOmics dapat menghasilkan template parameter untuk Anda.
Template parameter adalah file JSON. Dalam file, setiap parameter input adalah objek bernama yang harus cocok dengan nama input alur kerja. Saat Anda memulai proses, jika Anda tidak memberikan nilai untuk semua parameter yang diperlukan, proses gagal.
Objek parameter masukan mencakup atribut berikut:
+ **description**— Atribut wajib ini adalah string yang ditampilkan konsol di halaman **Mulai jalankan**. Deskripsi ini juga dipertahankan sebagai run metadata.
+ **optional**— Atribut opsional ini menunjukkan apakah parameter input adalah opsional. Jika Anda tidak menentukan **optional** bidang, parameter input diperlukan.
Contoh template parameter berikut menunjukkan bagaimana menentukan parameter masukan.
```
{
"myRequiredParameter1": {
"description": "this parameter is required",
},
"myRequiredParameter2": {
"description": "this parameter is also required",
"optional": false
},
"myOptionalParameter": {
"description": "this parameter is optional",
"optional": true
}
}
```
## Menghasilkan templat parameter
HealthOmics menghasilkan template parameter dengan mengurai definisi alur kerja untuk mendeteksi parameter input. Jika Anda menyediakan file template parameter untuk alur kerja, parameter dalam file Anda akan mengganti parameter yang terdeteksi dalam definisi alur kerja.
Ada sedikit perbedaan antara logika parsing mesin CWL, WDL, dan Nextflow, seperti yang dijelaskan di bagian berikut.
**Topics**
+ [Deteksi parameter untuk CWL](#parameter-parsing-cwl)
+ [Deteksi parameter untuk WDL](#parameter-parsing-wdl)
+ [Deteksi parameter untuk Nextflow](#parameter-parsing-nextflow)
### Deteksi parameter untuk CWL
Di mesin alur kerja CWL, logika parsing membuat asumsi berikut:
+ Tipe yang didukung nullable ditandai sebagai parameter input opsional.
+ Tipe yang didukung non-null ditandai sebagai parameter input yang diperlukan.
+ Setiap parameter dengan nilai default ditandai sebagai parameter input opsional.
+ Deskripsi diekstraksi dari `label` bagian dari definisi `main` alur kerja. Jika tidak `label` ditentukan, deskripsi akan kosong (string kosong).
Tabel berikut menunjukkan contoh interpolasi CWL. Untuk setiap contoh, nama parameternya adalah`x`. Jika parameter diperlukan, Anda harus memberikan nilai untuk parameter. Jika parameternya opsional, Anda tidak perlu memberikan nilai.
Tabel ini menunjukkan contoh interpolasi CWL untuk tipe primitif.
| Input | Contoh input/output | Wajib |
| --- | --- | --- |
| x:
type: int
| 1 atau 2 atau... | Ya |
| x:
type: int
default: 2
| Nilai default adalah 2. Masukan yang valid adalah 1 atau 2 atau... | Tidak |
| x:
type: int?
| Masukan yang valid adalah None atau 1 atau 2 atau... | Tidak |
| x:
type: int?
default: 2
| Nilai default adalah 2. Masukan yang valid adalah None atau 1 atau 2 atau... | Tidak |
Tabel berikut menunjukkan contoh interpolasi CWL untuk tipe kompleks. Tipe kompleks adalah kumpulan tipe primitif.
| Input | Contoh input/output | Wajib |
| --- | --- | --- |
| x:
type: array
items: int
| [] atau [1,2,3] | Ya |
| x:
type: array?
items: int
| Tidak ada atau [] atau [1,2,3] | Tidak |
| x:
type: array
items: int?
| [] atau [Tidak ada, 3, tidak ada] | Ya |
| x:
type: array?
items: int?
| [Tidak] atau Tidak ada atau [1,2,3] atau [Tidak ada, 3] tetapi tidak [] | Tidak |
### Deteksi parameter untuk WDL
Di mesin alur kerja WDL, logika parsing membuat asumsi berikut:
+ Tipe yang didukung nullable ditandai sebagai parameter input opsional.
+ Untuk tipe yang didukung yang tidak dapat dibatalkan:
+ Setiap variabel input dengan penetapan literal atau ekspresi ditandai sebagai parameter opsional. Misalnya:
```
Int x = 2
Float f0 = 1.0 + f1
```
+ Jika tidak ada nilai atau ekspresi yang ditetapkan ke parameter input, mereka akan ditandai sebagai parameter yang diperlukan.
+ Deskripsi diekstraksi dari `parameter_meta` dalam definisi `main` alur kerja. Jika tidak `parameter_meta` ditentukan, deskripsi akan kosong (string kosong). Untuk informasi lebih lanjut, lihat spesifikasi WDL untuk metadata [Parameter](https://github.com/openwdl/wdl/blob/wdl-1.2/SPEC.md#metadata-sections).
Tabel berikut menunjukkan contoh interpolasi WDL. Untuk setiap contoh, nama parameternya adalah`x`. Jika parameter diperlukan, Anda harus memberikan nilai untuk parameter. Jika parameternya opsional, Anda tidak perlu memberikan nilai.
Tabel ini menunjukkan contoh interpolasi WDL untuk tipe primitif.
| Input | Contoh input/output | Wajib |
| --- | --- | --- |
| Int x | 1 atau 2 atau... | Ya |
| Int x = 2 | 2 | Tidak |
| Int x = 1\$12 | 3 | Tidak |
| Int x = y\$1z | y\$1z | Tidak |
| Int? x | Tidak ada atau 1 atau 2 atau... | Ya |
| Int? x = 2 | Tidak ada atau 2 | Tidak |
| Int? x = 1\$12 | Tidak ada atau 3 | Tidak |
| Int? x = y\$1z | Tidak ada atau y\$1z | Tidak |
Tabel berikut menunjukkan contoh interpolasi WDL untuk tipe kompleks. Tipe kompleks adalah kumpulan tipe primitif.
| Input | Contoh input/output | Wajib |
| --- | --- | --- |
| Array [Int] x | [1,2,3] atau [] | Ya |
| Array [Int] \$1 x | [1], tetapi tidak [] | Ya |
| Array [Int]? x | Tidak ada atau [] atau [1,2,3] | Tidak |
| Array [Int?] x | [] atau [Tidak ada, 3, tidak ada] | Ya |
| Array [Int?] =? x | [Tidak] atau Tidak ada atau [1,2,3] atau [Tidak ada, 3] tetapi tidak [] | Tidak |
| Contoh struktur \$1String a, Int y\$1 nanti di input: Contoh MySample | String a = mySample.a
Int y = mySample.y
| Ya |
| Contoh struktur \$1String a, Int y\$1 nanti di input: Sampel? MySample | if (defined(mySample)) {
String a = mySample.a
Int y = mySample.y
} | Tidak |
### Deteksi parameter untuk Nextflow
Untuk Nextflow, HealthOmics buat template parameter dengan mengurai file. `nextflow_schema.json` Jika definisi alur kerja tidak menyertakan file skema, HealthOmics parsing file definisi alur kerja utama.
**Topics**
+ [Mengurai file skema](#parameter-parsing-nextflow-schema)
+ [Mengurai file utama](#parameter-parsing-nextflow-main)
+ [Parameter bersarang](#parameter-parsing-nextflow-nested)
+ [Contoh interpolasi Nextflow](#parameter-parsing-nextflow-examples)
#### Mengurai file skema
Agar parsing berfungsi dengan benar, pastikan file skema memenuhi persyaratan berikut:
+ File skema diberi nama `nextflow_schema.json` dan terletak di direktori yang sama dengan file alur kerja utama.
+ File skema adalah JSON valid seperti yang didefinisikan dalam salah satu skema berikut:
+ [skema json. org/draft/2020-12/schema](https://json-schema.org/draft/2020-12/schema).
+ [skema json. org/draft-07/schema](https://json-schema.org/draft-07/schema).
HealthOmics `nextflow_schema.json`mem-parsing file untuk menghasilkan template parameter:
+ Ekstrak semua **properties** yang didefinisikan dalam skema.
+ Termasuk properti **description** jika tersedia untuk properti.
+ Mengidentifikasi apakah setiap parameter opsional atau wajib, berdasarkan **required** bidang properti.
Contoh berikut menunjukkan file definisi dan file parameter yang dihasilkan.
```
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"$defs": {
"input_options": {
"title": "Input options",
"type": "object",
"required": ["input_file"],
"properties": {
"input_file": {
"type": "string",
"format": "file-path",
"pattern": "^s3://[a-z0-9.-]{3,63}(?:/\\S*)?$",
"description": "description for input_file"
},
"input_num": {
"type": "integer",
"default": 42,
"description": "description for input_num"
}
}
},
"output_options": {
"title": "Output options",
"type": "object",
"required": ["output_dir"],
"properties": {
"output_dir": {
"type": "string",
"format": "file-path",
"description": "description for output_dir",
}
}
}
},
"properties": {
"ungrouped_input_bool": {
"type": "boolean",
"default": true
}
},
"required": ["ungrouped_input_bool"],
"allOf": [
{ "$ref": "#/$defs/input_options" },
{ "$ref": "#/$defs/output_options" }
]
}
```
Template parameter yang dihasilkan:
```
{
"input_file": {
"description": "description for input_file",
"optional": False
},
"input_num": {
"description": "description for input_num",
"optional": True
},
"output_dir": {
"description": "description for output_dir",
"optional": False
},
"ungrouped_input_bool": {
"description": None,
"optional": False
}
}
```
#### Mengurai file utama
Jika definisi alur kerja tidak menyertakan `nextflow_schema.json` file, HealthOmics parsing file definisi alur kerja utama.
HealthOmics menganalisis `params` ekspresi yang ditemukan di file definisi alur kerja utama dan dalam file. `nextflow.config` Semua `params` dengan nilai default ditandai sebagai opsional.
Agar parsing berfungsi dengan benar, perhatikan persyaratan berikut:
+ HealthOmics hanya mem-parsing file definisi alur kerja utama. Untuk memastikan semua parameter ditangkap, kami sarankan Anda menghubungkan semua **params** submodul dan alur kerja yang diimpor.
+ File konfigurasi adalah opsional. Jika Anda mendefinisikannya, beri nama `nextflow.config` dan letakkan di direktori yang sama dengan file definisi alur kerja utama.
Contoh berikut menunjukkan file definisi dan template parameter yang dihasilkan.
```
params.input_file = "default.txt"
params.threads = 4
params.memory = "8GB"
workflow {
if (params.version) {
println "Using version: ${params.version}"
}
}
```
Template parameter yang dihasilkan:
```
{
"input_file": {
"description": None,
"optional": True
},
"threads": {
"description": None,
"optional": True
},
"memory": {
"description": None,
"optional": True
},
"version": {
"description": None,
"optional": False
}
}
```
Untuk nilai default yang didefinisikan dalam nextflow.config, HealthOmics mengumpulkan `params` tugas dan parameter yang dideklarasikan dalam`params {}`, seperti yang ditunjukkan pada contoh berikut. Dalam pernyataan penugasan, `params` harus muncul di sisi kiri pernyataan.
```
params.alpha = "alpha"
params.beta = "beta"
params {
gamma = "gamma"
delta = "delta"
}
env {
// ignored, as this assignment isn't in the params block
VERSION = "TEST"
}
// ignored, as params is not on the left side
interpolated_image = "${params.cli_image}"
```
Template parameter yang dihasilkan:
```
{
// other params in your main workflow defintion
"alpha": {
"description": None,
"optional": True
},
"beta": {
"description": None,
"optional": True
},
"gamma": {
"description": None,
"optional": True
},
"delta": {
"description": None,
"optional": True
}
}
```
#### Parameter bersarang
Keduanya `nextflow_schema.json` dan `nextflow.config` memungkinkan parameter bersarang. Namun, template HealthOmics parameter hanya membutuhkan parameter tingkat atas. Jika alur kerja Anda menggunakan parameter bersarang, Anda harus menyediakan objek JSON sebagai input untuk parameter tersebut.
##### Parameter bersarang dalam file skema
HealthOmics melewatkan bersarang **params** saat mengurai file. `nextflow_schema.json` Misalnya, jika Anda mendefinisikan `nextflow_schema.json` file berikut:
```
{
"properties": {
"input": {
"properties": {
"input_file": { ... },
"input_num": { ... }
}
},
"input_bool": { ... }
}
}
```
HealthOmics mengabaikan `input_file` dan `input_num` ketika menghasilkan template parameter:
```
{
"input": {
"description": None,
"optional": True
},
"input_bool": {
"description": None,
"optional": True
}
}
```
Saat Anda menjalankan alur kerja ini, HealthOmics mengharapkan `input.json` file yang mirip dengan berikut ini:
```
{
"input": {
"input_file": "s3://bucket/obj",
"input_num": 2
},
"input_bool": false
}
```
##### Parameter bersarang dalam file konfigurasi
HealthOmics tidak mengumpulkan bersarang **params** dalam `nextflow.config` file, dan melewatkannya selama penguraian. Misalnya, jika Anda mendefinisikan `nextflow.config` file berikut:
```
params.alpha = "alpha"
params.nested.beta = "beta"
params {
gamma = "gamma"
group {
delta = "delta"
}
}
```
HealthOmics mengabaikan `params.nested.beta` dan `params.group.delta` ketika menghasilkan template parameter:
```
{
"alpha": {
"description": None,
"optional": True
},
"gamma": {
"description": None,
"optional": True
}
}
```
#### Contoh interpolasi Nextflow
Tabel berikut menunjukkan contoh interpolasi Nextflow untuk params di file utama.
| Parameter | Wajib |
| --- | --- |
| params.input\$1file | Ya |
| params.input\$1file = "s3://bucket/data.json” | Tidak |
| params.nested.input\$1file | N/A |
| params.nested.input\$1file = "s3://bucket/data.json” | N/A |
Tabel berikut menunjukkan contoh interpolasi Nextflow untuk params dalam file. `nextflow.config`
| Parameter | Wajib |
| --- | --- |
| params.input_file = "s3://bucket/data.json"
| Tidak |
| params {
input_file = "s3://bucket/data.json"
} | Tidak |
| params {
nested {
input_file = "s3://bucket/data.json"
}
} | N/A |
| input_file = params.input_file
| N/A |
# Gambar kontainer untuk alur kerja pribadi
HealthOmics mendukung gambar kontainer yang dihosting di repositori pribadi Amazon ECR. Anda dapat membuat gambar kontainer dan mengunggahnya ke repositori pribadi. Anda juga dapat menggunakan registri pribadi Amazon ECR Anda sebagai cache tarik untuk menyinkronkan konten pendaftar hulu.
Repositori Amazon ECR Anda harus berada di AWS Wilayah yang sama dengan akun yang memanggil layanan. Yang berbeda Akun AWS dapat memiliki gambar kontainer, selama repositori gambar sumber memberikan izin yang sesuai. Untuk informasi selengkapnya, lihat [Kebijakan untuk akses ECR Amazon lintas akun](permissions-ecr.md#permissions-cross-account).
Sebaiknya tentukan image container Amazon ECR URIs sebagai parameter dalam alur kerja sehingga akses dapat diverifikasi sebelum proses dimulai. Ini juga mempermudah menjalankan alur kerja di Wilayah baru dengan mengubah parameter Region.
**catatan**
HealthOmics tidak mendukung kontainer ARM dan tidak mendukung akses ke repositori publik.
Untuk informasi tentang mengonfigurasi izin IAM untuk HealthOmics mengakses Amazon ECR, lihat. [HealthOmics Izin sumber daya](permissions-resource.md)
**Topics**
+ [Sinkronisasi dengan pendaftar kontainer pihak ketiga](#ecr-pull-through)
+ [Pertimbangan umum untuk gambar kontainer Amazon ECR](#ecr-considerations)
+ [Variabel lingkungan untuk HealthOmics alur kerja](#ecr-env-vars)
+ [Menggunakan Java di gambar kontainer Amazon ECR](#ecr-java-considerations)
+ [Tambahkan input tugas ke gambar wadah Amazon ECR](#ecr-tasks)
## Sinkronisasi dengan pendaftar kontainer pihak ketiga
Anda dapat menggunakan aturan cache pull through Amazon ECR untuk menyinkronkan repositori di registri upstream yang didukung dengan repositori pribadi Amazon ECR Anda. Untuk informasi selengkapnya, lihat [Menyinkronkan registri upstream](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache.html) di *Panduan Pengguna Amazon ECR*.
Pull through cache secara otomatis membuat repositori gambar di registri pribadi Anda saat Anda membuat cache, dan secara otomatis menyinkronkan dengan gambar yang di-cache ketika ada perubahan pada gambar upstream.
HealthOmics mendukung pull through cache untuk registri hulu berikut:
+ Amazon ECR Public
+ Registri gambar kontainer Kubernetes
+ dermaga
+ Hub Docker
+ Registri Kontainer Microsoft Azure
+ GitHub Registri Kontainer
+ GitLab Registri Kontainer
HealthOmics tidak mendukung penarikan cache untuk repositori pribadi Amazon ECR hulu.
Manfaat menggunakan Amazon ECR pull through cache meliputi:
1. Anda menghindari keharusan memigrasikan gambar kontainer secara manual ke Amazon ECR atau untuk menyinkronkan pembaruan dari repositori pihak ketiga.
1. Alur kerja mengakses gambar kontainer yang disinkronkan di repositori pribadi Anda, yang lebih andal daripada mengunduh konten saat dijalankan dari registri publik.
1. Karena Amazon ECR menarik cache menggunakan struktur URI yang dapat diprediksi, HealthOmics layanan dapat secara otomatis memetakan URI pribadi Amazon ECR dengan URI registri hulu. Anda tidak perlu memperbarui dan mengganti nilai URI dalam definisi alur kerja.
**Topics**
+ [Mengkonfigurasi pull through cache](#ecr-pull-through-configure)
+ [Pemetaan registri](#ecr-pull-through-registry-mapping)
+ [Pemetaan gambar](#ecr-pull-through-mapping-format)
### Mengkonfigurasi pull through cache
Amazon ECR menyediakan registri untuk Anda Akun AWS di setiap Wilayah. Pastikan Anda membuat konfigurasi Amazon ECR di wilayah yang sama tempat Anda berencana menjalankan alur kerja.
Bagian berikut menjelaskan tugas konfigurasi untuk pull through cache.
**Topics**
+ [Buat aturan cache tarik](#create-ecr-ptc)
+ [Izin registri untuk registri hulu](#reg-ecr-ptc)
+ [Templat pembuatan repositori](#repo-create-templates-ptc)
+ [Membuat alur kerja](#reg-mapping-ecr-ptc)
#### Buat aturan cache tarik
Buat aturan cache pull through Amazon ECR untuk setiap registri upstream yang memiliki gambar yang ingin Anda cache. Aturan menentukan pemetaan antara registri upstream dan repositori pribadi Amazon ECR.
Untuk registri upstream yang memerlukan autentikasi, Anda memberikan kredensialnya menggunakan AWS Secrets Manager.
**catatan**
Jangan mengubah aturan pull through cache saat run aktif menggunakan repositori pribadi. Proses berjalan bisa gagal atau, yang lebih kritis, menghasilkan pipeline Anda menggunakan gambar yang tidak terduga.
Untuk informasi selengkapnya, lihat [Membuat aturan cache tarik melalui](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html) di *Panduan Pengguna Amazon Elastic Container Registry*.
##### Buat aturan cache tarik menggunakan konsol
Untuk mengonfigurasi cache tarik melalui, ikuti langkah-langkah ini menggunakan konsol Amazon ECR:
1. Buka konsol Amazon ECR: https://console.aws.amazon.com /ecr
1. Dari menu kiri, di bawah **Registri pribadi**, perluas **Fitur & Pengaturan**. Lalu pilih **Tarik melalui cache**.
1. Dari halaman **Tarik melalui cache**, pilih **Tambahkan aturan**.
1. **Di panel **registri Upstream, pilih registri** upstream untuk disinkronkan dengan registri pribadi Anda, lalu pilih Berikutnya.**
1. Jika registri upstream memerlukan otentikasi, konsol akan membuka halaman baru tempat Anda menentukan rahasia SageMaker AI yang berisi kredensyal Anda. Pilih **Berikutnya**.
1. Di bawah **Tentukan ruang nama**, di panel **namespace Cache**, pilih apakah akan membuat repositori pribadi menggunakan awalan repositori tertentu atau tanpa awalan. Jika Anda memilih untuk menggunakan awalan, tentukan nama awalan di awalan **repositori Cache**.
1. Di panel **namespace Upstream**, pilih apakah akan menarik dari repositori upstream menggunakan awalan repositori tertentu atau tanpa awalan. Jika Anda memilih untuk menggunakan awalan, tentukan nama awalan di awalan repositori **Upstream**.
Panel **contoh Namespace** menunjukkan contoh permintaan tarik, URL hulu, dan URL repositori cache yang dibuat.
1. Pilih **Berikutnya**.
1. Tinjau konfigurasi dan pilih **Buat** untuk membuat aturan.
Untuk informasi selengkapnya, lihat [Membuat aturan cache tarik (AWS Management Console)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html#pull-through-cache-creating-rule-console).
##### Buat aturan cache tarik melalui menggunakan CLI
Gunakan **create-pull-through-cache-rule** perintah Amazon ECR untuk membuat aturan cache pull through. Untuk registrasi upstream yang memerlukan otentikasi, simpan kredensialnya dalam rahasia Secrets Manager.
Bagian berikut memberikan contoh untuk setiap registri upstream yang didukung.
##### Untuk Amazon ECR Publik
Contoh berikut membuat aturan cache pull through untuk registri Publik Amazon ECR. Ini menentukan awalan repositori`ecr-public`, yang menghasilkan setiap repositori yang dibuat menggunakan aturan pull through cache untuk memiliki skema penamaan. `ecr-public/upstream-repository-name`
```
aws ecr create-pull-through-cache-rule \
--ecr-repository-prefix ecr-public \
--upstream-registry-url public.ecr.aws \
--region us-east-1
```
##### Untuk Registri Kontainer Kubernetes
Contoh berikut membuat aturan pull through cache untuk registri publik Kubernetes. Ini menentukan awalan repositori`kubernetes`, yang menghasilkan setiap repositori yang dibuat menggunakan aturan pull through cache untuk memiliki skema penamaan. `kubernetes/upstream-repository-name`
```
aws ecr create-pull-through-cache-rule \
--ecr-repository-prefix kubernetes \
--upstream-registry-url registry.k8s.io \
--region us-east-1
```
##### Untuk Quay
Contoh berikut membuat aturan pull through cache untuk registri publik Quay. Ini menentukan awalan repositori`quay`, yang menghasilkan setiap repositori yang dibuat menggunakan aturan pull through cache untuk memiliki skema penamaan. `quay/upstream-repository-name`
```
aws ecr create-pull-through-cache-rule \
--ecr-repository-prefix quay \
--upstream-registry-url quay.io \
--region us-east-1
```
##### Untuk Docker Hub
Contoh berikut membuat aturan pull through cache untuk registri Docker Hub. Ini menentukan awalan repositori`docker-hub`, yang menghasilkan setiap repositori yang dibuat menggunakan aturan pull through cache untuk memiliki skema penamaan. `docker-hub/upstream-repository-name` Anda harus menentukan Nama Sumber Daya Amazon (ARN) lengkap dari rahasia yang berisi kredenal Docker Hub Anda.
```
aws ecr create-pull-through-cache-rule \
--ecr-repository-prefix docker-hub \
--upstream-registry-url registry-1.docker.io \
--credential-arn arn:aws:secretsmanager:us-east-1:111122223333:secret:ecr-pullthroughcache/example1234 \
--region us-east-1
```
##### Untuk Registri GitHub Kontainer
Contoh berikut membuat aturan pull through cache untuk GitHub Container Registry. Ini menentukan awalan repositori`github`, yang menghasilkan setiap repositori yang dibuat menggunakan aturan pull through cache untuk memiliki skema penamaan. `github/upstream-repository-name` Anda harus menentukan Nama Sumber Daya Amazon (ARN) lengkap dari rahasia yang berisi kredensyal Registri GitHub Penampung Anda.
```
aws ecr create-pull-through-cache-rule \
--ecr-repository-prefix github \
--upstream-registry-url ghcr.io \
--credential-arn arn:aws:secretsmanager:us-east-1:111122223333:secret:ecr-pullthroughcache/example1234 \
--region us-east-1
```
##### Untuk Microsoft Azure Container Registry
Contoh berikut membuat aturan pull through cache untuk Microsoft Azure Container Registry. Ini menentukan awalan repositori`azure`, yang menghasilkan setiap repositori yang dibuat menggunakan aturan pull through cache untuk memiliki skema penamaan. `azure/upstream-repository-name` Anda harus menentukan Nama Sumber Daya Amazon (ARN) lengkap dari rahasia yang berisi kredensyal Microsoft Azure Container Registry Anda.
```
aws ecr create-pull-through-cache-rule \
--ecr-repository-prefix azure \
--upstream-registry-url myregistry.azurecr.io \
--credential-arn arn:aws:secretsmanager:us-east-1:111122223333:secret:ecr-pullthroughcache/example1234 \
--region us-east-1
```
##### Untuk Registri GitLab Kontainer
Contoh berikut membuat aturan pull through cache untuk GitLab Container Registry. Ini menentukan awalan repositori`gitlab`, yang menghasilkan setiap repositori yang dibuat menggunakan aturan pull through cache untuk memiliki skema penamaan. `gitlab/upstream-repository-name` Anda harus menentukan Nama Sumber Daya Amazon (ARN) lengkap dari rahasia yang berisi kredensyal Registri GitLab Penampung Anda.
```
aws ecr create-pull-through-cache-rule \
--ecr-repository-prefix gitlab \
--upstream-registry-url registry.gitlab.com \
--credential-arn arn:aws:secretsmanager:us-east-1:111122223333:secret:ecr-pullthroughcache/example1234 \
--region us-east-1
```
Untuk informasi selengkapnya, lihat [Membuat aturan cache tarik (CLI) di Panduan](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html#pull-through-cache-creating-rule-cli) Pengguna *Amazon ECR*.
Anda dapat menggunakan perintah **get-run-task** CLI untuk mengambil informasi tentang gambar kontainer yang digunakan untuk tugas tertentu:
```
aws omics get-run-task --id 1234567 --task-id
```
Outputnya mencakup informasi berikut tentang gambar kontainer:
```
"imageDetails": {
"image": "string",
"imageDigest": "string",
"sourceImage": "string",
...
}
```
#### Izin registri untuk registri hulu
Gunakan izin registri HealthOmics untuk memungkinkan penggunaan cache pull through dan untuk menarik gambar kontainer ke dalam registri pribadi Amazon ECR. Tambahkan kebijakan Amazon ECR Registry ke registri yang menyediakan kontainer yang digunakan dalam proses.
Kebijakan berikut memberikan izin kepada HealthOmics layanan untuk membuat repositori dengan awalan pull through cache yang ditentukan dan untuk memulai penarikan upstream ke dalam repositori ini.
1. Dari konsol Amazon ECR, buka menu kiri, di bawah **Registri pribadi**, perluas **izin Registry**. Lalu pilih **Hasilkan** pernyataan.
1. Di sisi kanan atas, pilih JSON. Masukkan kebijakan yang mirip dengan berikut ini:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowPTCinRegPermissions",
"Effect": "Allow",
"Principal": {
"Service": "omics.amazonaws.com"
},
"Action": [
"ecr:CreateRepository",
"ecr:BatchImportUpstreamImage"
],
"Resource": [
"arn:aws:ecr:us-east-1:123456789012:repository/ecr-public/*",
"arn:aws:ecr:us-east-1:123456789012:repository/docker-hub/*"
]
}
]
}
```
------
#### Templat pembuatan repositori
Untuk menggunakan pull through caching in HealthOmics, repositori Amazon ECR harus memiliki template pembuatan repositori. Template mendefinisikan pengaturan konfigurasi saat Anda atau Amazon ECR membuat repositori pribadi untuk registri upstream.
Setiap template berisi awalan namespace repositori, yang digunakan Amazon ECR untuk mencocokkan repositori baru dengan templat tertentu. Template menentukan konfigurasi untuk semua setelan repositori termasuk kebijakan akses berbasis sumber daya, kekekalan tag, enkripsi, dan kebijakan siklus hidup.
Untuk informasi selengkapnya, lihat [Templat pembuatan repositori](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-creation-templates.html) di *Panduan Pengguna Amazon Elastic Container Registry*.
Cara membuat template pembuatan repositori:
1. Dari konsol Amazon ECR, buka menu kiri, di bawah **Registri pribadi**, perluas **Fitur dan pengaturan**. Lalu pilih Template **pembuatan repositori**.
1. Pilih **Buat templat**.
1. Dalam **rincian Template**, pilih **Tarik melalui cache**.
1. Pilih apakah akan menerapkan template ini ke awalan tertentu atau ke semua repositori yang tidak cocok dengan template lain.
**Jika Anda memilih **awalan tertentu, masukkan nilai awalan** namespace di Awalan.** Anda menentukan awalan ini ketika Anda membuat aturan PTC.
1. Pilih **Berikutnya**.
1. Di halaman **konfigurasi pembuatan repositori**, masukkan izin **Repositori**. Gunakan salah satu contoh pernyataan kebijakan, atau masukkan yang mirip dengan contoh berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "PTCRepoCreationTemplate",
"Effect": "Allow",
"Principal": {
"Service": "omics.amazonaws.com"
},
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "*"
}
]
}
```
------
1. Secara opsional, Anda dapat menambahkan pengaturan repositori seperti kebijakan siklus hidup dan tag. Amazon ECR menerapkan aturan ini untuk semua gambar kontainer yang dibuat untuk menarik cache yang menggunakan awalan yang ditentukan.
1. Pilih **Berikutnya**.
1. Tinjau konfigurasi dan pilih **Berikutnya**.
#### Membuat alur kerja
Saat Anda membuat alur kerja atau alur kerja baru, tinjau pemetaan registri dan perbarui jika diperlukan. Lihat perinciannya di [Buat alur kerja pribadi](create-private-workflow.md).
### Pemetaan registri
Anda menentukan pemetaan registri untuk memetakan antara awalan di registri ECR Amazon pribadi Anda dan nama registri hulu.
Untuk informasi selengkapnya tentang pemetaan registri Amazon ECR, lihat [Membuat aturan cache tarik melalui di Amazon](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html) ECR.
Contoh berikut menunjukkan pemetaan registri ke Docker Hub, Quay, dan Amazon ECR Public.
```
{
"registryMappings": [
{
"upstreamRegistryUrl": "registry-1.docker.io",
"ecrRepositoryPrefix": "docker-hub"
},
{
"upstreamRegistryUrl": "quay.io",
"ecrRepositoryPrefix": "quay"
},
{
"upstreamRegistryUrl": "public.ecr.aws",
"ecrRepositoryPrefix": "ecr-public"
}
]
}
```
### Pemetaan gambar
Anda menentukan pemetaan gambar untuk memetakan antara nama gambar seperti yang didefinisikan dalam alur kerja Amazon ECR pribadi Anda dan nama gambar di registri hulu.
Anda dapat menggunakan pemetaan gambar dengan registri yang mendukung penarikan cache. Anda juga dapat menggunakan pemetaan gambar dengan registri hulu yang HealthOmics tidak mendukung penarikan cache. Anda perlu menyinkronkan registri hulu secara manual dengan repositori pribadi Anda.
Untuk informasi selengkapnya tentang pemetaan gambar Amazon ECR, lihat [Membuat aturan cache tarik melalui di Amazon](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html) ECR.
Contoh berikut menunjukkan pemetaan dari gambar ECR Amazon pribadi ke gambar genomik publik dan gambar Ubuntu terbaru.
```
{
"imageMappings": [
{
"sourceImage": "public.ecr.aws/aws-genomics/broadinstitute/gatk:4.6.0.2",
"destinationImage": "123456789012.dkr.ecr.us-east-1.amazonaws.com/broadinstitute/gatk:4.6.0.2"
},
{
"sourceImage": "ubuntu:latest",
"destinationImage": "123456789012.dkr.ecr.us-east-1.amazonaws.com/custom/ubuntu:latest",
}
]
}
```
## Pertimbangan umum untuk gambar kontainer Amazon ECR
+ Arsitektur
HealthOmics mendukung wadah x86\$164. Jika mesin lokal Anda berbasis ARM, seperti Apple Mac, gunakan perintah seperti berikut ini untuk membuat image container x86\$164:
```
docker build --platform amd64 -t my_tool:latest .
```
+ Entrypoint dan shell
HealthOmics mesin alur kerja menyuntikkan skrip bash sebagai penggantian perintah ke gambar kontainer yang digunakan oleh tugas alur kerja. Dengan demikian, gambar kontainer harus dibangun tanpa ENTRYPOINT yang ditentukan sehingga shell bash adalah default.
+ Jalur yang dipasang
Sistem file bersama dipasang ke tugas kontainer di /tmp. Setiap data atau perkakas yang dibangun ke dalam gambar kontainer di lokasi ini akan diganti.
Definisi alur kerja tersedia untuk tugas melalui mount hanya-baca di /mnt/workflow.
+ Ukuran gambar
Lihat [HealthOmics alur kerja kuota ukuran tetap](fixed-quotas.md#fixed-quotas-workflows) untuk ukuran gambar kontainer maksimum.
## Variabel lingkungan untuk HealthOmics alur kerja
HealthOmics menyediakan variabel lingkungan yang memiliki informasi tentang alur kerja yang berjalan di wadah. Anda dapat menggunakan nilai variabel-variabel ini dalam logika tugas alur kerja Anda.
Semua variabel HealthOmics alur kerja dimulai dengan `AWS_WORKFLOW_` awalan. Awalan ini adalah awalan variabel lingkungan yang dilindungi. Jangan gunakan awalan ini untuk variabel Anda sendiri dalam wadah alur kerja.
HealthOmics menyediakan variabel lingkungan alur kerja berikut:
**AWS\$1REGION**
Variabel ini adalah wilayah tempat penampung berjalan.
**AWS\$1WORKFLOW\$1JALANKAN**
Variabel ini adalah nama run saat ini.
**AWS\$1WORKFLOW\$1RUN\$1ID**
Variabel ini adalah pengidentifikasi run dari run saat ini.
**AWS\$1WORKFLOW\$1RUN\$1UUID**
Variabel ini adalah UUID run dari run saat ini.
**AWS\$1WORKFLOW\$1TUGAS**
Variabel ini adalah nama tugas saat ini.
**AWS\$1WORKFLOW\$1TASK\$1ID**
Variabel ini adalah pengidentifikasi tugas dari tugas saat ini.
**AWS\$1WORKFLOW\$1TUGAS\$1UUID**
Variabel ini adalah tugas UUID dari tugas saat ini.
Contoh berikut menunjukkan nilai-nilai khas untuk setiap variabel lingkungan:
```
AWS Region: us-east-1
Workflow Run: arn:aws:omics:us-east-1:123456789012:run/6470304
Workflow Run ID: 6470304
Workflow Run UUID: f4d9ed47-192e-760e-f3a8-13afedbd4937
Workflow Task: arn:aws:omics:us-east-1:123456789012:task/4192063
Workflow Task ID: 4192063
Workflow Task UUID: f0c9ed49-652c-4a38-7646-60ad835e0a2e
```
## Menggunakan Java di gambar kontainer Amazon ECR
Jika tugas alur kerja menggunakan aplikasi Java seperti GATK, pertimbangkan persyaratan memori berikut untuk wadah:
+ Aplikasi Java menggunakan memori tumpukan dan memori heap. Secara default, memori heap maksimum adalah persentase dari total memori yang tersedia dalam wadah. Default ini tergantung pada distribusi JVM tertentu dan versi JVM, jadi konsultasikan dokumentasi yang relevan untuk JVM Anda atau secara eksplisit atur memori heap maksimum menggunakan opsi baris perintah Java (seperti `-Xmx`).
+ Jangan mengatur memori heap maksimum menjadi 100% dari alokasi memori kontainer, karena tumpukan JVM juga membutuhkan memori. Memori juga diperlukan untuk pengumpul sampah JVM dan proses sistem operasi lainnya yang berjalan di wadah.
+ Beberapa aplikasi Java, seperti GATK, dapat menggunakan pemanggilan metode asli atau pengoptimalan lain seperti file pemetaan memori. Teknik-teknik ini memerlukan alokasi memori yang dilakukan “off heap”, yang tidak dikendalikan oleh parameter heap maksimum JVM.
Jika Anda tahu (atau mencurigai) bahwa aplikasi Java Anda mengalokasikan memori off-heap, pastikan alokasi memori tugas Anda mencakup persyaratan memori off-heap.
Jika alokasi off-heap ini menyebabkan wadah kehabisan memori, Anda biasanya tidak akan melihat **OutOfMemory** kesalahan Java, karena JVM tidak mengontrol memori ini.
## Tambahkan input tugas ke gambar wadah Amazon ECR
Tambahkan semua executable, library, dan skrip yang diperlukan untuk menjalankan tugas alur kerja ke dalam image Amazon ECR yang digunakan untuk menjalankan tugas.
Ini adalah praktik terbaik untuk menghindari penggunaan skrip, binari, dan pustaka yang berada di luar gambar wadah tugas. Hal ini sangat penting ketika menggunakan `nf-core` alur kerja yang menggunakan `bin` direktori sebagai bagian dari paket alur kerja. Sementara direktori ini akan tersedia untuk tugas alur kerja, itu dipasang sebagai direktori read-only. Sumber daya yang diperlukan dalam direktori ini harus disalin ke dalam gambar tugas dan tersedia saat runtime atau saat membuat gambar kontainer yang digunakan untuk tugas tersebut.
Lihat [HealthOmics alur kerja kuota ukuran tetap](fixed-quotas.md#fixed-quotas-workflows) untuk ukuran maksimum gambar kontainer yang HealthOmics mendukung.
# HealthOmics Alur kerja file README
Anda dapat mengunggah file README.md yang berisi instruksi, diagram, dan informasi penting untuk alur kerja Anda. Setiap versi alur kerja mendukung satu file README, yang dapat Anda perbarui kapan saja.
**Persyaratan README meliputi:**
+ File README harus dalam format markdown (.md)
+ Ukuran file maksimal: 500 KiB
**Topics**
+ [Gunakan README yang ada](#workflows-add-readme)
+ [Kondisi rendering](#workflows-rendering-readme)
## Gunakan README yang ada
READMEs diekspor dari repositori Git berisi tautan relatif yang biasanya tidak berfungsi di luar repositori. HealthOmics Integrasi Git secara otomatis mengonversinya menjadi tautan absolut untuk rendering yang tepat di konsol, menghilangkan kebutuhan akan pembaruan URL manual.
Untuk READMEs diimpor dari Amazon S3 atau drive lokal, gambar dan tautan harus menggunakan publik URLs atau jalur relatifnya diperbarui untuk rendering yang tepat.
**catatan**
Gambar harus di-host secara publik untuk ditampilkan di HealthOmics konsol. Gambar yang disimpan GitHub Enterprise Server atau GitLab Self-Managed repositori tidak dapat dirender.
## Kondisi rendering
HealthOmics Konsol menginterpolasi gambar dan tautan yang dapat diakses publik menggunakan jalur absolut. Untuk merender URLs dari repositori pribadi, pengguna harus memiliki akses ke repositori. Untuk GitHub Enterprise Server atau GitLab Self-Managed repositori, yang menggunakan domain khusus, HealthOmics tidak dapat menyelesaikan tautan relatif atau merender gambar yang disimpan di repositori pribadi ini.
Tabel berikut menunjukkan elemen penurunan harga yang didukung oleh tampilan README AWS konsol.
| Elemen | AWS konsol |
| --- | --- |
| Pemberitahuan | Ya, tetapi tanpa ikon |
| Lencana | Ya |
| Pemformatan teks dasar | Ya |
| [Blok kode](https://www.markdownguide.org/basic-syntax/#code-blocks) | Ya, tetapi tidak memiliki [sorotan sintaks](https://www.markdownguide.org/extended-syntax/#syntax-highlighting) dan fungsi tombol salin |
| Bagian yang dapat dilipat | Ya |
| [Judul](https://www.markdownguide.org/basic-syntax/#headings) | Ya |
| [Format gambar](https://www.markdownguide.org/basic-syntax/#images-1) | Ya |
| [Gambar (dapat diklik)](https://www.markdownguide.org/basic-syntax/#linking-images) | Ya |
| [Jeda baris](https://www.markdownguide.org/basic-syntax/#line-breaks) | Ya |
| Diagram putri duyung | Hanya dapat membuka grafik, memindahkan posisi grafik, dan menyalin kode |
| Kutipan | Ya |
| [https://www.markdownguide.org/extended-syntax/#subscript](https://www.markdownguide.org/extended-syntax/#subscript) | Ya |
| [Tabel](https://www.markdownguide.org/extended-syntax/#tables) | Ya, tetapi tidak mendukung perataan teks |
| Penjajaran teks | Ya |
### Menggunakan gambar dan tautan URLs
Bergantung pada penyedia sumber Anda, struktur basis Anda URLs untuk halaman dan gambar dalam format berikut.
+ `{username}`: Nama pengguna tempat repositori di-host.
+ `{repo}`: Nama repositori.
+ `{ref}`: Referensi sumber (cabang, tag, dan ID komit).
+ `{path}`: Jalur file ke halaman atau gambar di repositori.
| Penyedia sumber | URL Halaman | URL gambar |
| --- | --- | --- |
| GitHub | https://github.com/\$1username\$1/\$1repo\$1/blob/\$1ref\$1/\$1path\$1 | `https://github.com/{username}/{repo}/blob/{ref}/{path}?raw=true` `https://raw.githubusercontent.com/{username}/{repo}/{ref}/{path}` |
| GitLab | https://gitlab.com/\$1username\$1/\$1repo\$1/-/blob/\$1ref\$1/\$1path\$1 | https://gitlab.com/\$1username\$1/\$1repo\$1/-/raw/\$1ref\$1/\$1path\$1 |
| Bitbucket | https://bitbucket.org/\$1username\$1/\$1repo\$1/src/\$1ref\$1/\$1path\$1 | https://bitbucket.org/\$1username\$1/\$1repo\$1/raw/\$1ref\$1/\$1path\$1 |
GitHub,GitLab, dan Bitbucket mendukung halaman dan gambar URLs yang terhubung ke repositori publik. Tabel berikut menunjukkan dukungan masing-masing penyedia sumber untuk merender gambar dan tautan URLs untuk repositori pribadi.
| Dukungan repositori pribadi | Penyedia sumber | URL Halaman | URL gambar |
| --- | --- | --- | --- |
| GitHub | Hanya dengan akses ke repositori | Tidak |
| GitLab | Hanya dengan akses ke repositori | Tidak |
| Bitbucket | Hanya dengan akses ke repositori | Tidak |
# Meminta lisensi Sentieon untuk alur kerja pribadi
Jika alur kerja pribadi Anda menggunakan perangkat lunak Sentieon, Anda memerlukan lisensi Senieon. Ikuti langkah-langkah berikut untuk meminta dan menyiapkan lisensi untuk perangkat lunak Sentieon:
+ Minta lisensi Sentieon
+ Kirim email ke grup dukungan Sentieon (support@sentieon.com) untuk meminta lisensi perangkat lunak.
+ Berikan ID Pengguna AWS Canonical Anda di email.
+ Temukan ID Pengguna AWS Canonical Anda dengan mengikuti petunjuk [ini](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html#FindCanonicalId).
+ Perbarui peran HealthOmics layanan Anda untuk memberinya akses ke proxy server lisensi Sentieon dan bucket Sentieon Omics di Wilayah Anda. Contoh berikut memberikan akses masuk`us-east-1`. Jika diperlukan, ganti teks ini dengan Wilayah Anda.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObjectAcl",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::omics-ap-us-east-1/*",
"arn:aws:s3:::sentieon-omics-license-us-east-1/*"
]
}
]
}
```
------
+ Hasilkan kasus AWS dukungan untuk mendapatkan akses ke proxy server lisensi Sentieon.
+ Untuk membuat kasus dukungan, navigasikan ke [support.console.aws.amazon.com](https://support.console.aws.amazon.com).
+ Berikan Anda Akun AWS dan Wilayah dalam kasus dukungan. Akun Anda ditambahkan ke daftar yang diizinkan untuk proxy server lisensi.
+ Bangun alur kerja pribadi Anda menggunakan wadah Sentieon dan skrip lisensi Sentieon.
+ Untuk petunjuk tambahan tentang penggunaan alat Sentieon di dalam alur kerja pribadi, lihat [Sentieon-Amazon-Omics](https://github.com/Sentieon/sentieon-amazon-omics) di. GitHub
+ Versi perangkat lunak Sentieon 202112.07 dan yang lebih tinggi mendukung proxy server lisensi. HealthOmics Untuk menggunakan versi perangkat lunak Sentieon lebih awal dari 202112.07, hubungi dukungan Sentieon.
# Linter alur kerja di HealthOmics
Setelah membuat alur kerja, sebaiknya jalankan linter pada alur kerja sebelum memulai proses pertama. Linter mendeteksi kesalahan yang dapat menyebabkan run gagal.
Untuk WDL, HealthOmics secara otomatis menjalankan linter saat Anda membuat alur kerja. Output linter tersedia di `statusMessage` bidang **get-workflow** respons. Gunakan perintah CLI berikut untuk mengambil output status (gunakan ID alur kerja dari alur kerja WDL yang Anda buat):
```
aws omics get-workflow
—id 123456
—query 'statusMessage'
```
HealthOmics menyediakan linter yang dapat Anda jalankan pada pembelahan alur kerja sebelum Anda membuat alur kerja. Jalankan linter ini pada pipeline yang ada tempat Anda bermigrasi. HealthOmics
+ **WDL**— Gambar ECR Amazon publik untuk menjalankan linter [WDL](https://gallery.ecr.aws/aws-genomics/healthomics-linter).
+ **Nextflow**— Gambar ECR Amazon publik untuk menjalankan [aturan Linter]( https://gallery.ecr.aws/aws-genomics/linter-rules-for-nextflow) untuk Nextflow. Anda dapat mengakses kode sumber untuk linter ini dari [GitHub](https://github.com/awslabs/linter-rules-for-nextflow).
+ **CWL**— tidak tersedia
# HealthOmics operasi alur kerja
Untuk membuat alur kerja pribadi, Anda perlu:
+ **Workflow definition file:**File definisi alur kerja yang ditulis dalamWDL,Nextflow, atauCWL. Definisi alur kerja menentukan input dan output untuk menjalankan yang menggunakan alur kerja. Ini juga mencakup spesifikasi untuk menjalankan dan menjalankan tugas untuk alur kerja Anda, termasuk persyaratan komputasi dan memori. File definisi alur kerja harus dalam `.zip` format. Untuk informasi selengkapnya, lihat [File definisi alur kerja](workflow-definition-files.md) di HealthOmics.
+ Anda dapat menggunakan [Amazon Q CLI](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/what-is.html) untuk membangun dan memvalidasi file definisi alur kerja Anda di WDL, Nextflow, dan CWL. Untuk informasi selengkapnya, lihat [Contoh prompt untuk Amazon Q CLI](getting-started.md#omics-q-prompts) dan tutorial AI [HealthOmics generatif Agentic](https://github.com/aws-samples/aws-healthomics-tutorials/tree/main/generative-ai). GitHub
+ **(Optional) Parameter template file:**File template parameter yang ditulis dalam fileJSON. Buat file untuk menentukan parameter run, atau HealthOmics buat template parameter untuk Anda. Untuk informasi selengkapnya, lihat [File templat parameter untuk HealthOmics alur kerja](parameter-templates.md).
+ **Amazon ECR container images:**Buat repositori Amazon ECR pribadi untuk setiap kontainer yang digunakan dalam alur kerja. Buat gambar kontainer untuk alur kerja dan simpan di repositori pribadi, atau sinkronkan konten registri upstream yang didukung dengan repositori pribadi ECR Anda.
+ **(Optional) Sentieon licenses:**Minta Sentieon lisensi untuk menggunakan Sentieon perangkat lunak dalam alur kerja pribadi.
Untuk file definisi alur kerja yang lebih besar dari 4 MiB (zip), pilih salah satu opsi ini selama pembuatan alur kerja:
+ Unggah ke folder Amazon Simple Storage Service dan tentukan lokasinya.
+ Unggah ke repositori eksternal (ukuran maksimal 1 GiB) dan tentukan detail repositori.
Setelah membuat alur kerja, Anda dapat memperbarui informasi alur kerja berikut dengan operasi: `UpdateWorkflow`
+ Nama
+ Deskripsi
+ Jenis penyimpanan default
+ Kapasitas penyimpanan default (dengan ID alur kerja)
+ Berkas README.md
Untuk mengubah informasi lain dalam alur kerja, buat alur kerja atau versi alur kerja baru.
Gunakan pembuatan versi alur kerja untuk mengatur dan menyusun alur kerja Anda. Versi juga membantu Anda mengelola pengenalan pembaruan alur kerja berulang. Untuk informasi selengkapnya tentang versi, lihat[Buat versi alur kerja](workflows-version-create.md).
**Topics**
+ [Buat alur kerja pribadi](create-private-workflow.md)
+ [Memperbarui alur kerja pribadi](update-private-workflow.md)
+ [Menghapus alur kerja pribadi](delete-private-workflow.md)
+ [Verifikasi status alur kerja](using-get-workflow.md)
+ [Mereferensikan file genom dari definisi alur kerja](create-ref-files.md)
# Buat alur kerja pribadi
Buat alur kerja menggunakan HealthOmics konsol, perintah AWS CLI, atau salah satu. AWS SDKs
**catatan**
Jangan sertakan informasi identitas pribadi (PII) apa pun dalam nama alur kerja. Nama-nama ini terlihat di CloudWatch log.
Saat Anda membuat alur kerja, HealthOmics tetapkan pengenal unik universal (UUID) ke alur kerja. UUID alur kerja adalah Pengenal Unik Global (panduan) yang unik di seluruh alur kerja dan versi alur kerja. Untuk tujuan asal data, kami menyarankan Anda menggunakan UUID alur kerja untuk mengidentifikasi alur kerja secara unik.
Jika tugas alur kerja Anda menggunakan alat eksternal (executable, pustaka, atau skrip), Anda membuat alat ini menjadi gambar kontainer. Anda memiliki opsi berikut untuk menghosting gambar kontainer:
+ Host gambar kontainer di registri pribadi ECR. Prasyarat untuk opsi ini:
+ Buat repositori pribadi ECR, atau pilih repositori yang ada.
+ Konfigurasikan kebijakan sumber daya ECR seperti yang dijelaskan dalam[Izin Amazon ECR](permissions-ecr.md).
+ Unggah gambar kontainer Anda ke repositori pribadi.
+ Sinkronkan gambar kontainer dengan konten registri pihak ketiga yang didukung. Prasyarat untuk opsi ini:
+ Dalam registri pribadi ECR, konfigurasikan aturan pull through cache untuk setiap registri upstream. Untuk informasi selengkapnya, lihat [Pemetaan gambar](workflows-ecr.md#ecr-pull-through-mapping-format).
+ Konfigurasikan kebijakan sumber daya ECR seperti yang dijelaskan dalam[Izin Amazon ECR](permissions-ecr.md).
+ Buat template pembuatan repositori. Template menentukan pengaturan saat Amazon ECR membuat repositori pribadi untuk registri upstream.
+ Buat pemetaan awalan untuk memetakan ulang referensi gambar kontainer dalam definisi alur kerja ke ruang nama cache ECR.
Saat membuat alur kerja, Anda memberikan definisi alur kerja yang berisi informasi tentang alur kerja, proses, dan tugas. HealthOmics dapat mengambil definisi alur kerja sebagai arsip.zip yang disimpan secara lokal atau di bucket Amazon S3, atau dari repositori berbasis Git yang didukung.
**Topics**
+ [Membuat alur kerja menggunakan konsol](#console-create-workflows)
+ [Membuat alur kerja menggunakan CLI](#api-create-workflows)
+ [Membuat alur kerja menggunakan SDK](#sdk-create-workflows)
## Membuat alur kerja menggunakan konsol
**Langkah-langkah untuk membuat alur kerja**
1. Buka [konsol HealthOmics ](https://console.aws.amazon.com/omics/).
1. Jika diperlukan, buka panel navigasi kiri (≡). Pilih **Alur kerja pribadi**.
1. Pada halaman **alur kerja pribadi**, pilih **Buat alur kerja**.
1. Pada halaman **Tentukan alur kerja**, berikan informasi berikut:
1. **Nama alur kerja: Nama** khas untuk alur kerja ini. Sebaiknya setel nama alur kerja untuk mengatur proses Anda di AWS HealthOmics konsol dan CloudWatch log.
1. **Deskripsi** (opsional): Deskripsi alur kerja ini.
1. Di panel **definisi Alur Kerja**, berikan informasi berikut:
1. **Bahasa alur kerja** (opsional): Pilih bahasa spesifikasi alur kerja. Jika tidak, HealthOmics tentukan bahasa dari definisi alur kerja.
1. Untuk **sumber definisi Alur Kerja**, pilih untuk mengimpor folder definisi dari repositori berbasis Git, lokasi Amazon S3, atau dari drive lokal.
1. Untuk **Impor dari layanan repositori**:
**catatan**
HealthOmics mendukung repositori publik dan pribadi untukGitHub,,, GitLabBitbucket,GitHub self-managed. GitLab self-managed
1. Pilih **Koneksi** untuk menghubungkan AWS sumber daya Anda ke repositori eksternal. Untuk membuat koneksi, lihat[Connect dengan repositori kode eksternal](setting-up-new.md#setting-up-omics-repository).
**catatan**
Pelanggan di TLV wilayah tersebut perlu membuat koneksi di wilayah IAD (us-east-1) untuk membuat alur kerja.
1. Dalam ID **repositori lengkap, masukkan ID repositori** Anda sebagai nama pengguna/repo-nama. Verifikasi bahwa Anda memiliki akses ke file di repositori ini.
1. Dalam **referensi Sumber** (opsional), masukkan referensi sumber repositori (cabang, tag, atau ID komit). HealthOmics menggunakan cabang default jika tidak ada referensi sumber yang ditentukan.
1. Di **Kecualikan pola file**, masukkan pola file untuk mengecualikan folder, file, atau ekstensi tertentu. Ini membantu mengelola ukuran data saat mengimpor file repositori. Ada maksimal 50 pola, dan pola harus mengikuti sintaks [pola glob](https://fossil-scm.org/home/doc/tip/www/globs.md). Contoh:
1. `tests/`
1. `*.jpeg`
1. `large_data.zip`
1. Untuk **Pilih folder definisi dari S3**:
1. Masukkan lokasi Amazon S3 yang berisi folder definisi alur kerja zip. Bucket Amazon S3 harus berada di wilayah yang sama dengan alur kerja.
1. Jika akun Anda tidak memiliki bucket Amazon S3, masukkan ID akun pemilik bucket di ID AWS akun **pemilik bucket S3**. Informasi ini diperlukan agar HealthOmics dapat memverifikasi kepemilikan bucket.
1. Untuk **Pilih folder definisi dari sumber lokal**:
1. Masukkan lokasi drive lokal dari folder definisi alur kerja zip.
1. **Jalur file definisi alur kerja utama** (opsional): Masukkan jalur file dari folder definisi alur kerja zip atau repositori ke file. `main` Parameter ini tidak diperlukan jika hanya ada satu file di folder definisi alur kerja, atau jika file utama diberi nama “main”.
1. Di panel **file README** (opsional), pilih **Sumber file README** dan berikan informasi berikut:
+ Untuk **Impor dari layanan repositori**, di **jalur file README, masukkan path** ke file README dalam repositori.
+ Untuk **Pilih file dari S3**, dalam **file README di S3**, masukkan URI Amazon S3 untuk file README.
+ Untuk **Pilih file dari sumber lokal**: di **README - opsional**, **pilih Pilih file untuk memilih file** penurunan harga (.md) yang akan diunggah.
1. Di panel **konfigurasi penyimpanan run default**, berikan tipe penyimpanan run default dan kapasitas untuk menjalankan yang menggunakan alur kerja ini:
1. **Jalankan jenis penyimpanan**: Pilih apakah akan menggunakan penyimpanan statis atau dinamis sebagai default untuk penyimpanan berjalan sementara. Defaultnya adalah penyimpanan statis.
1. **Jalankan kapasitas penyimpanan** (opsional): Untuk jenis penyimpanan run statis, Anda dapat memasukkan jumlah default penyimpanan run yang diperlukan untuk alur kerja ini. Nilai default untuk parameter ini adalah 1200 GiB. Anda dapat mengganti nilai default ini saat memulai proses.
1. **Tag** (opsional): Anda dapat mengaitkan hingga 50 tag dengan alur kerja ini.
1. Pilih **Berikutnya**.
1. Pada halaman **Tambahkan parameter alur kerja** (opsional), pilih **sumber Parameter:**
1. Untuk **Parse dari file definisi alur kerja**, secara otomatis HealthOmics akan mengurai parameter alur kerja dari file definisi alur kerja.
1. Untuk **menyediakan template parameter dari repositori** Git, gunakan path ke file template parameter dari repositori Anda.
1. Untuk **Pilih file JSON dari sumber lokal**, unggah JSON file dari sumber lokal yang menentukan parameter.
1. Untuk **Masukkan parameter alur kerja secara** manual, masukkan nama dan deskripsi parameter secara manual.
1. Di panel **pratinjau Parameter**, Anda dapat meninjau atau mengubah parameter untuk versi alur kerja ini. Jika Anda mengembalikan JSON file, Anda kehilangan perubahan lokal yang Anda buat.
1. Pilih **Berikutnya**.
1. Pada halaman **pemetaan ulang URI Container**, di panel **aturan Pemetaan, Anda dapat menentukan aturan** pemetaan URI untuk alur kerja Anda.
Untuk **Sumber file pemetaan**, pilih salah satu opsi berikut:
+ **Tidak ada** - Tidak ada aturan pemetaan yang diperlukan.
+ **Pilih file JSON dari S3** - Tentukan lokasi S3 untuk file pemetaan.
+ **Pilih file JSON dari sumber lokal** - Tentukan lokasi file pemetaan di perangkat lokal Anda.
+ **Masukkan pemetaan secara manual** **- masukkan pemetaan registri dan pemetaan gambar di panel Pemetaan.**
1. Konsol menampilkan panel **Pemetaan.** Jika Anda memilih file sumber pemetaan, konsol menampilkan nilai dari file.
1. Dalam **pemetaan Registry**, Anda dapat mengedit pemetaan atau menambahkan pemetaan (maksimum 20 pemetaan registri).
Setiap pemetaan registri berisi bidang-bidang berikut:
+ **URL registri hulu** — URI dari registri hulu.
+ **Awalan repositori ECR - Awalan** repositori untuk digunakan dalam repositori pribadi Amazon ECR.
+ (Opsional) **Awalan repositori hulu - Awalan** repositori di registri hulu.
+ (Opsional) **ID akun ECR** — ID akun akun yang memiliki gambar kontainer hulu.
1. Dalam **pemetaan Gambar**, Anda dapat mengedit pemetaan gambar atau menambahkan pemetaan (maksimum 100 pemetaan gambar).
Setiap pemetaan gambar berisi bidang-bidang berikut:
+ **Gambar sumber** - Menentukan URI gambar sumber di registri hulu.
+ **Gambar tujuan** - Menentukan URI gambar yang sesuai di registri ECR Amazon pribadi.
1. Pilih **Berikutnya**.
1. Tinjau konfigurasi alur kerja, lalu pilih **Buat alur kerja**.
## Membuat alur kerja menggunakan CLI
Jika file alur kerja Anda dan file template parameter ada di mesin lokal Anda, Anda dapat membuat alur kerja menggunakan perintah CLI berikut.
```
aws omics create-workflow \
--name "my_workflow" \
--definition-zip fileb://my-definition.zip \
--parameter-template file://my-parameter-template.json
```
`create-workflow`Operasi mengembalikan respon berikut:
```
{
"arn": "arn:aws:omics:us-west-2:....",
"id": "1234567",
"status": "CREATING",
"tags": {
"resourceArn": "arn:aws:omics:us-west-2:...."
},
"uuid": "64c9a39e-8302-cc45-0262-2ea7116d854f"
}
```
### Parameter opsional untuk digunakan saat membuat alur kerja
Anda dapat menentukan salah satu parameter opsional saat membuat alur kerja. Untuk detail sintaks, lihat [CreateWorkflow](https://docs.aws.amazon.com/omics/latest/api/API_CreateWorkflow.html)di AWS HealthOmics API Referensi.
**Topics**
+ [Tentukan definisi alur kerja lokasi Amazon S3](#create-defn-uri-parameter)
+ [Menggunakan definisi alur kerja dari repositori berbasis Git](#create-defn-uri-git)
+ [Tentukan file Readme](#specify-readme-file)
+ [Tentukan file **main** definisi](#create-main-parameter)
+ [Tentukan jenis penyimpanan run](#create-run-storage-parameter)
+ [Tentukan konfigurasi GPU](#create-accelerator-parameter)
+ [Konfigurasikan parameter pemetaan cache pull through](#create-prefix-mapping-parameters)
#### Tentukan definisi alur kerja lokasi Amazon S3
Jika file definisi alur kerja Anda terletak di folder Amazon S3, tentukan lokasi menggunakan parameter, seperti `definition-uri` yang ditunjukkan pada contoh berikut. Jika akun Anda tidak memiliki bucket Amazon S3, berikan ID pemiliknya. Akun AWS
```
aws omics create-workflow \
--name Test \
--definition-uri s3://omics-bucket/workflow-definition/ \
--owner-id 123456789012
...
```
#### Menggunakan definisi alur kerja dari repositori berbasis Git
Untuk menggunakan definisi alur kerja dari repositori berbasis Git yang didukung, gunakan parameter dalam `definition-repository` permintaan Anda. Jangan berikan `definition` parameter lain, karena permintaan gagal jika menyertakan lebih dari satu sumber input.
`definition-respository`Parameter berisi bidang-bidang berikut:
+ **connectionArn**— ARN dari Koneksi Kode yang menghubungkan sumber daya AWS Anda ke repositori eksternal.
+ **fullRepositoryId**— Masukkan ID repositori sebagai. `owner-name/repo-name` Verifikasi bahwa Anda memiliki akses ke file di repositori ini.
+ **sourceReference**(Opsional) — Masukkan tipe referensi repositori (BRANCH, TAG, atau COMMIT) dan nilai.
HealthOmics menggunakan komit terbaru di cabang default jika Anda tidak menentukan referensi sumber.
+ **excludeFilePatterns**(Opsional) - Masukkan pola file untuk mengecualikan folder, file, atau ekstensi tertentu. Ini membantu mengelola ukuran data saat mengimpor file repositori. Berikan maksimal 50 pola. pola harus mengikuti sintaks pola [glob](https://fossil-scm.org/home/doc/tip/www/globs.md). Contoh:
+ `tests/`
+ `*.jpeg`
+ `large_data.zip`
Saat Anda menentukan definisi alur kerja dari repositori berbasis Git, gunakan `parameter-template-path` untuk menentukan file template parameter. Jika Anda tidak memberikan parameter ini, HealthOmics buat alur kerja tanpa templat parameter.
Contoh berikut menunjukkan parameter yang terkait dengan konten dari repositori pribadi berbasis Git:
```
aws omics create-workflow \
--name custom-variant \
--description "Custom variant calling pipeline" \
--engine "WDL" \
--definition-repository '{
"connectionArn": "arn:aws:codeconnections:us-east-1:123456789012:connection/abcd1234-5678-90ab-cdef-1234567890ab",
"fullRepositoryId": "myorg/my-genomics-workflows",
"sourceReference": {
"type": "BRANCH",
"value": "main"
},
"excludeFilePatterns": ["tests/**", "*.log"]
}' \
--main "workflows/variant-calling/main.wdl" \
--parameter-template-path "parameters/variant-calling-params.json" \
--readme-path "docs/variant-calling-README.md" \
--storage-type "DYNAMIC" \
```
Untuk contoh lainnya, lihat posting blog [Cara Membuat HealthOmics Alur Kerja AWS dari Konten di Git](https://repost.aws/articles/ARCEN7AjhaRSmteczRoc_QsA/how-to-create-an-aws-healthomics-workflows-from-content-in-git).
#### Tentukan file Readme
Anda dapat menentukan lokasi file README menggunakan salah satu parameter berikut:
+ **readme-markdown**— Input string atau file di mesin lokal Anda.
+ **readme-uri**— URI file yang disimpan di S3.
+ **readme-path **— Jalur ke file README di repositori.
**Gunakan readme-path hanya dalam hubungannya dengan definition-respositori.** Jika Anda tidak menentukan parameter README apa pun, HealthOmics impor file README.md tingkat root di repositori (jika ada).
Contoh berikut menunjukkan bagaimana menentukan lokasi file README menggunakan readme-path dan readme-uri.
```
# Using README from repository
aws omics create-workflow \
--name "documented-workflow" \
--definition-repository '...' \
--readme-path "docs/workflow-guide.md"
# Using README from S3
aws omics create-workflow \
--name "s3-readme-workflow" \
--definition-repository '...' \
--readme-uri "s3://my-bucket/workflow-docs/readme.md"
```
Untuk informasi selengkapnya, lihat [HealthOmics Alur kerja file README](workflows-readme.md).
#### Tentukan file **main** definisi
Jika Anda menyertakan beberapa file definisi alur kerja, gunakan `main` parameter untuk menentukan file definisi utama untuk alur kerja Anda.
```
aws omics create-workflow \
--name Test \
--main multi_workflow/workflow2.wdl \
...
```
#### Tentukan jenis penyimpanan run
Anda dapat menentukan jenis penyimpanan run default (DYNAMIC atau STATIC) dan menjalankan kapasitas penyimpanan (diperlukan untuk penyimpanan statis). Untuk informasi selengkapnya tentang menjalankan jenis penyimpanan, lihat[Jalankan jenis penyimpanan dalam HealthOmics alur kerja](workflows-run-types.md).
```
aws omics create-workflow \
--name my_workflow \
--definition-zip fileb://my-definition.zip \
--parameter-template file://my-parameter-template.json \
--storage-type 'STATIC' \
--storage-capacity 1200 \
```
#### Tentukan konfigurasi GPU
Gunakan parameter akselerator untuk membuat alur kerja yang berjalan pada instance komputasi yang dipercepat. Contoh berikut menunjukkan bagaimana menggunakan `accelerators` parameter. Anda menentukan konfigurasi GPU dalam definisi alur kerja. Lihat [Instans komputasi yang dipercepat](memory-and-compute-tasks.md#workflow-task-accelerated-computing-instances).
```
aws omics create-workflow --name workflow name \
--definition-uri s3://amzn-s3-demo-bucket1/GPUWorkflow.zip \
--accelerators GPU
```
#### Konfigurasikan parameter pemetaan cache pull through
Jika Anda menggunakan fitur pemetaan cache Amazon ECR pull through, Anda dapat mengganti pemetaan default. Untuk informasi selengkapnya tentang parameter penyiapan kontainer, lihat[Gambar kontainer untuk alur kerja pribadi](workflows-ecr.md).
Dalam contoh berikut, file `mappings.json` berisi konten ini:
```
{
"registryMappings": [
{
"upstreamRegistryUrl": "registry-1.docker.io",
"ecrRepositoryPrefix": "docker-hub"
},
{
"upstreamRegistryUrl": "quay.io",
"ecrRepositoryPrefix": "quay",
"accountId": "123412341234"
},
{
"upstreamRegistryUrl": "public.ecr.aws",
"ecrRepositoryPrefix": "ecr-public"
}
],
"imageMappings": [{
"sourceImage": "docker.io/library/ubuntu:latest",
"destinationImage": "healthomics-docker-2/custom/ubuntu:latest",
"accountId": "123412341234"
},
{
"sourceImage": "nvcr.io/nvidia/k8s/dcgm-exporter",
"destinationImage": "healthomics-nvidia/k8s/dcgm-exporter"
}
]
}
```
Tentukan parameter pemetaan dalam perintah create-workflow:
```
aws omics create-workflow \
...
--container-registry-map-file file://mappings.json
...
```
Anda juga dapat menentukan lokasi S3 dari file parameter pemetaan:
```
aws omics create-workflow \
...
--container-registry-map-uri s3://amzn-s3-demo-bucket1/test.zip
...
```
## Membuat alur kerja menggunakan SDK
Anda dapat membuat alur kerja menggunakan salah satu. SDKs Contoh berikut menunjukkan cara membuat alur kerja menggunakan Python SDK
```
import boto3
omics = boto3.client('omics')
with open('definition.zip', 'rb') as f:
definition = f.read()
response = omics.create_workflow(
name='my_workflow',
definitionZip=definition,
parameterTemplate={ ... }
)
```
# Memperbarui alur kerja pribadi
Anda dapat memperbarui alur kerja menggunakan HealthOmics konsol, perintah AWS CLI, atau salah satu. AWS SDKs
**catatan**
Jangan sertakan informasi identitas pribadi (PII) apa pun dalam nama alur kerja. Nama-nama ini terlihat di CloudWatch log.
**Topics**
+ [Memperbarui alur kerja menggunakan konsol](#console-update-workflows)
+ [Memperbarui alur kerja menggunakan CLI](#api-update-workflows)
+ [Memperbarui alur kerja menggunakan SDK](#sdk-update-workflows)
## Memperbarui alur kerja menggunakan konsol
**Langkah-langkah untuk memperbarui alur kerja**
1. Buka [konsol HealthOmics ](https://console.aws.amazon.com/omics/).
1. Jika diperlukan, buka panel navigasi kiri (≡). Pilih **Alur kerja pribadi**.
1. Pada halaman **Alur kerja pribadi**, pilih alur kerja yang akan diperbarui.
1. Pada halaman **Workflow**:
+ Jika alur kerja memiliki versi, pastikan Anda memilih **versi Default**.
+ Pilih **Edit yang dipilih** dari daftar **Tindakan**.
1. Pada halaman **Edit alur kerja**, Anda dapat mengubah salah satu nilai berikut:
+ **Nama alur kerja**.
+ **Deskripsi alur kerja**.
+ **Jenis penyimpanan Jalankan** default untuk alur kerja.
+ **Kapasitas penyimpanan Jalankan** default (jika jenis penyimpanan run adalah penyimpanan statis). Untuk informasi selengkapnya tentang konfigurasi penyimpanan run default, lihat[Membuat alur kerja menggunakan konsol](create-private-workflow.md#console-create-workflows).
1. Pilih **Simpan perubahan** untuk menerapkan perubahan.
## Memperbarui alur kerja menggunakan CLI
Seperti yang ditunjukkan pada contoh berikut, Anda dapat memperbarui nama alur kerja dan deskripsi. Anda juga dapat mengubah jenis penyimpanan run default (STATIC atau DYNAMIC) dan menjalankan kapasitas penyimpanan (untuk tipe penyimpanan statis). Untuk informasi selengkapnya tentang menjalankan jenis penyimpanan, lihat[Jalankan jenis penyimpanan dalam HealthOmics alur kerja](workflows-run-types.md).
```
aws omics update-workflow \
--id 1234567 \
--name my_workflow \
--description "updated workflow" \
--storage-type 'STATIC' \
--storage-capacity 1200
```
Anda tidak menerima tanggapan atas `update-workflow` permintaan tersebut.
## Memperbarui alur kerja menggunakan SDK
Anda dapat memperbarui alur kerja menggunakan salah satu file. SDKs
Contoh berikut menunjukkan cara memperbarui alur kerja menggunakan Python SDK
```
import boto3
omics = boto3.client('omics')
response = omics.update_workflow(
name='my_workflow',
description='updated workflow'
)
```
# Menghapus alur kerja pribadi
Ketika Anda tidak lagi membutuhkan alur kerja, Anda dapat menghapusnya menggunakan HealthOmics konsol, perintah AWS CLI, atau salah satu. AWS SDKs Anda dapat menghapus alur kerja yang memenuhi kriteria berikut:
+ Statusnya AKTIF atau GAGAL.
+ Tidak memiliki saham aktif.
+ Anda telah menghapus semua versi alur kerja.
Menghapus alur kerja tidak memengaruhi proses yang sedang berlangsung yang menggunakan alur kerja.
**Topics**
+ [Menghapus alur kerja menggunakan konsol](#console-delete-workflows)
+ [Menghapus alur kerja menggunakan CLI](#api-delete-workflows)
+ [Menghapus alur kerja menggunakan SDK](#sdk-delete-workflows)
## Menghapus alur kerja menggunakan konsol
**Untuk menghapus alur kerja**
1. Buka [konsol HealthOmics ](https://console.aws.amazon.com/omics/).
1. Jika diperlukan, buka panel navigasi kiri (≡). Pilih **Alur kerja pribadi**.
1. Pada halaman **alur kerja pribadi**, pilih alur kerja yang akan dihapus.
1. Pada halaman **Alur Kerja**, pilih **Hapus yang dipilih** dari daftar **Tindakan**.
1. Dalam modal **Hapus alur kerja**, masukkan “konfirmasi” untuk mengonfirmasi penghapusan.
1. Pilih **Hapus**.
## Menghapus alur kerja menggunakan CLI
Contoh berikut menunjukkan bagaimana Anda dapat menggunakan AWS CLI perintah untuk menghapus alur kerja. Untuk menjalankan contoh, ganti `workflow id` dengan ID alur kerja yang ingin Anda hapus.
```
aws omics delete-workflow
--id workflow id
```
HealthOmics tidak mengirimkan tanggapan atas `delete-workflow` permintaan tersebut.
## Menghapus alur kerja menggunakan SDK
Anda dapat menghapus alur kerja menggunakan salah satu file. SDKs
Contoh berikut menunjukkan cara menghapus alur kerja menggunakan Python SDK.
```
import boto3
omics = boto3.client('omics')
response = omics.delete_workflow(
id='1234567'
)
```
# Verifikasi status alur kerja
Setelah membuat alur kerja, Anda dapat memverifikasi status dan melihat detail alur kerja lainnya menggunakan **get-workflow**, seperti yang ditunjukkan.
```
aws omics get-workflow --id 1234567
```
Respons mencakup detail alur kerja, termasuk status, seperti yang ditunjukkan.
```
{
"arn": "arn:aws:omics:us-west-2:....",
"creationTime": "2022-07-06T00:27:05.542459"
"id": "1234567",
"engine": "WDL",
"status": "ACTIVE",
"type": "PRIVATE",
"main": "workflow-crambam.wdl",
"name": "workflow_name",
"storageType": "STATIC",
"storageCapacity": "1200",
"uuid": "64c9a39e-8302-cc45-0262-2ea7116d854f"
}
```
Anda dapat memulai proses menggunakan alur kerja ini setelah transisi status ke. `ACTIVE`
# Mereferensikan file genom dari definisi alur kerja
Objek penyimpanan HealthOmics referensi dapat dirujuk dengan URI seperti berikut ini. Gunakan milik Anda sendiri`account ID`,`reference store ID`, dan `reference ID` di mana ditunjukkan.
```
omics://account ID.storage.us-west-2.amazonaws.com/reference store id/reference/id
```
Beberapa alur kerja akan memerlukan `INDEX` file `SOURCE` dan file untuk genom referensi. URI sebelumnya adalah bentuk pendek default dan akan default ke file SOURCE. Untuk menentukan salah satu file, Anda dapat menggunakan formulir URI panjang, sebagai berikut.
```
omics://account ID.storage.us-west-2.amazonaws.com/reference store id/reference/id/source
omics://account ID.storage.us-west-2.amazonaws.com/reference store id/reference/id/index
```
Menggunakan set baca urutan akan memiliki pola yang sama, seperti yang ditunjukkan.
```
aws omics create-workflow \
--name workflow name \
--main sample workflow.wdl \
--definition-uri omics://account ID.storage.us-west-2.amazonaws.com/sequence_store_id/readSet/id \
--parameter-template file://parameters_sample_description.json
```
Beberapa set baca, seperti yang didasarkan pada FASTQ, dapat berisi pembacaan berpasangan. Dalam contoh berikut, mereka disebut sebagai SOURCE1 dan SOURCE2. Format seperti BAM dan CRAM hanya akan memiliki SOURCE1 file. Beberapa set baca akan berisi file INDEX seperti `bai` atau `crai` file. URI sebelumnya adalah bentuk pendek default dan akan default ke file. SOURCE1 Untuk menentukan file atau indeks yang tepat, Anda dapat menggunakan formulir URI panjang, sebagai berikut.
```
omics://123456789012.storage.us-west-2.amazonaws.com//readSet//source1
omics://123456789012.storage.us-west-2.amazonaws.com//readSet//source2
omics://123456789012.storage.us-west-2.amazonaws.com//readSet//index
```
Berikut ini adalah contoh file JSON input yang menggunakan dua Omics Storage. URIs
```
{
"input_fasta": "omics://123456789012.storage.us-west-2.amazonaws.com//reference/",
"input_cram": "omics://123456789012.storage.us-west-2.amazonaws.com//readSet/"
}
```
Referensikan file JSON input di AWS CLI dengan menambahkan permintaan `--inputs file://` **start-run** Anda.