Standarisasi penandaan layanan DLC DSW EAS di PAI - Platform For AI

Aturan tag memungkinkan administrator ruang kerja menerapkan penandaan yang konsisten di seluruh DLC, DSW, dan EAS. Administrator menentukan kunci tag wajib, nilai yang telah ditentukan sebelumnya, deskripsi, serta cakupan produk yang berlaku. Saat aturan aktif, pengembang ML harus memberi tag pada pekerjaan DLC, instans DSW, dan layanan EAS saat pembuatan—tag tersebut divalidasi secara otomatis. Penandaan yang konsisten mendukung alokasi biaya, analisis distribusi pekerjaan, dan pelaporan konsumsi sumber daya.

Tentukan aturan tag

Catatan

Hanya pemilik dan administrator ruang kerja yang dapat mengedit aturan tag.

Buka halaman detail ruang kerja, lalu di pojok kanan atas, klik Configure Workspace > General Configurations.
Gulir ke bawah ke bagian Tag Configuration, lalu klik Modify Configuration untuk masuk ke mode edit.
Tambahkan aturan tag sesuai kebutuhan, lalu klik Save. Aturan yang dikonfigurasi berlaku untuk cakupan produk yang dipilih. Di halaman sub-produk terkait, tag ini wajib diisi secara default. Jika tag tidak ada atau tidak sesuai, pengiriman akan gagal. Pengembang ML juga dapat menambahkan tag kustom selama persyaratan kunci tag dan nilai tag terpenuhi.
- Tag Key requirements: Tidak boleh diawali dengan aliyun atau acs:, tidak boleh mengandung http:// atau https://, dan panjangnya maksimal 128 karakter. Hanya huruf, angka, tanda hubung (-), karakter Tionghoa, dan titik (.) yang diperbolehkan; garis bawah (_) tidak diperbolehkan.
- Value requirements: Tidak boleh mengandung http:// atau https://, dan panjangnya maksimal 256 karakter. Pisahkan beberapa nilai yang dihitung dengan koma.
- Value Constraints: Jika diaktifkan, pengguna harus memilih dari nilai yang telah ditentukan sebelumnya dan tidak dapat memasukkan nilai kustom. Aktifkan opsi ini untuk menegakkan penandaan yang konsisten di seluruh tim.
- Applicable Services: Pilih sub-produk mana (DLC, DSW, atau EAS) yang berlaku untuk aturan ini. Setidaknya satu harus dipilih.

Terapkan tag

Terapkan tag sesuai aturan tag ruang kerja saat mengirimkan pekerjaan DLC atau membuat instans DSW atau EAS. Langkah-langkah berikut menggunakan pengiriman pekerjaan DLC sebagai contoh:

Buka konsol DLC dan klik Create Job.
Di halaman konfigurasi pekerjaan, temukan bagian Tag, lalu isi pasangan kunci-nilai sesuai aturan tag ruang kerja.
Anda juga dapat menambahkan tag kustom saat pembuatan pekerjaan, seperti tag self-define-key pada tangkapan layar.
Setelah mengisi semua tag yang wajib, kirimkan pekerjaan tersebut.

Penting

Aturan tag divalidasi saat pengiriman. Jika tag wajib tidak ada atau nilainya tidak sesuai aturan, pengiriman akan gagal dengan pesan error.

Filter pekerjaan berdasarkan tag

Gunakan filter berbasis tag pada daftar pekerjaan DLC untuk menganalisis distribusi pekerjaan dan penggunaan sumber daya berdasarkan skenario, jenis model, atau kriteria lainnya.

Buka halaman daftar pekerjaan di konsol DLC.
Di bilah pencarian, pilih Tag sebagai kondisi filter, masukkan kunci tag dan nilainya, lalu klik pencarian. Daftar hanya menampilkan pekerjaan yang sesuai kriteria.
Daftar diperbarui untuk hanya menampilkan pekerjaan yang sesuai tag yang ditentukan:

Lampiran

Referensi API

Untuk mengonfigurasi aturan tag secara massal atau mengintegrasikannya ke dalam pipeline otomatisasi, gunakan contoh kode berikut. Ganti wilayah, ID ruang kerja, serta nilai ID AccessKey dan Secret sebelum menjalankan kode.

Konfigurasi aturan tag secara massal

API UpdateConfigs mendukung konfigurasi massal aturan tag yang telah ditentukan sebelumnya dan cocok untuk menerapkan konfigurasi tag yang sama di beberapa ruang kerja.

Struktur contoh badan permintaan:

{
  "Configs": [
    {
      "ConfigKey": "predefinedTags",
      "ConfigValue": "[{\"Type\":\"Tag\",\"Key\":\"scenario\",\"Value\":\"{\\\"Products\\\":\\\"DLC,DSW,EAS\\\",\\\"Values\\\":\\\"train,evluate,inference\\\",\\\"ValueFlexible\\\":false,\\\"Description\\\":\\\"select scenario\\\"}\"}]",
      "Labels": [
        {
          "Key": "system.categoryName",
          "Value": "CommonTagConfig"
        }
      ]
    }
  ]
}

Kode contoh Python: konfigurasi aturan tag secara massal

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
PAI Workspace - Batch create/update predefined tag rules (CommonTagConfig)
API: PUT /api/v1/workspaces/{WorkspaceId}/configs
Before use, fill in ACCESS_KEY_ID, ACCESS_KEY_SECRET, REGION_ID, and WORKSPACE_ID,
and define tag rules in the TAGS list.
"""

import json, sys, hashlib, hmac, datetime, requests

ACCESS_KEY_ID     = "your-AccessKeyId"
ACCESS_KEY_SECRET = "your-AccessKeySecret"
REGION_ID         = "cn-hangzhou"
WORKSPACE_ID      = "your-workspace-ID"

ENDPOINT = f"aiworkspace.{REGION_ID}.aliyuncs.com"
API_PATH = f"/api/v1/workspaces/{WORKSPACE_ID}/configs"

# Tag definition: key-tag name, products-applicable products, values-allowed values, flexible-whether custom values are allowed, desc-description
TAGS = [
    {"key": "Scene",      "products": "DLC,DSW,EAS", "values": "Training,Evaluation,Inference",         "flexible": False, "desc": "Select the current use scenario"},
    {"key": "ModelType",  "products": "DLC,DSW",     "values": "NLP-Text,CV-Image,Multimodal",          "flexible": False, "desc": "Select the model type"},
    {"key": "ExpDirection","products": "DLC",         "values": "LR-Schedule,DataAugmentation,Distillation", "flexible": True, "desc": "Customize the experiment direction"},
]

def build_config_value(tags):
    arr = []
    for t in tags:
        inner = {"Products": t["products"], "Values": t["values"],
                 "ValueFlexible": t.get("flexible", False), "Description": t.get("desc", "")}
        arr.append({"Type": "Tag", "Key": t["key"], "Value": json.dumps(inner, ensure_ascii=False)})
    return json.dumps(arr, ensure_ascii=False)

def sign_request(method, path, headers, body):
    now = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
    headers.update({"x-acs-date": now, "x-acs-version": "2021-02-04",
                    "x-acs-action": "UpdateConfigs",
                    "x-acs-signature-nonce": hashlib.md5((now + body).encode()).hexdigest()})
    signed_keys = sorted(k for k in headers if k.startswith("x-acs-") or k in ("host", "content-type"))
    canonical_headers = "".join(f"{k}:{headers[k]}\n" for k in signed_keys)
    hashed_body = hashlib.sha256(body.encode("utf-8")).hexdigest()
    canonical_request = f"{method}\n{path}\n\n{canonical_headers}\n{';'.join(signed_keys)}\n{hashed_body}"
    string_to_sign = f"ACS3-HMAC-SHA256\n{hashlib.sha256(canonical_request.encode()).hexdigest()}"
    signature = hmac.new(ACCESS_KEY_SECRET.encode(), string_to_sign.encode(), hashlib.sha256).hexdigest()
    headers["Authorization"] = (f"ACS3-HMAC-SHA256 Credential={ACCESS_KEY_ID},"
                                 f"SignedHeaders={';'.join(signed_keys)},Signature={signature}")
    return headers

def main():
    config_value = build_config_value(TAGS)
    request_body = json.dumps({"Configs": [{"ConfigKey": "predefinedTags", "ConfigValue": config_value,
                                            "Labels": [{"Key": "system.categoryName", "Value": "CommonTagConfig"}]}]},
                              ensure_ascii=False)
    url = f"https://{ENDPOINT}{API_PATH}"
    headers = sign_request("PUT", API_PATH, {"host": ENDPOINT, "content-type": "application/json"}, request_body)
    resp = requests.put(url, headers=headers, data=request_body.encode("utf-8"), timeout=30)
    print(f"HTTP {resp.status_code}: {resp.text}")
    if resp.status_code != 200:
        sys.exit(1)

if __name__ == "__main__":
    main()

Tentukan tag saat mengirimkan pekerjaan DLC

Saat mengirimkan pekerjaan DLC melalui API CreateJob, tentukan tag di bidang Settings.Tags. Semua tag wajib harus diisi. Nilai harus dipilih dari opsi yang telah ditentukan, kecuali untuk tag yang memiliki ValueFlexible bernilai true, yang menerima input kustom.

Kode contoh Python: tentukan tag saat mengirimkan pekerjaan DLC

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
PAI-DLC Submit training job (with predefined tags)
API: POST /api/v1/jobs (API version 2020-12-03)
Tags are placed in Settings.Tags as a dictionary {"tag-name": "tag-value"}.
"""

import json, sys, hashlib, hmac, datetime, time, requests

ACCESS_KEY_ID     = "your-AccessKeyId"
ACCESS_KEY_SECRET = "your-AccessKeySecret"
REGION_ID         = "cn-hangzhou"
WORKSPACE_ID      = "your-workspace-ID"
RESOURCE_ID       = ""  # Resource quota ID; leave empty to use public resources

DLC_ENDPOINT = f"pai-dlc.{REGION_ID}.aliyuncs.com"
DLC_API_PATH = "/api/v1/jobs"

# Fill in according to the workspace predefined tags; all predefined tags must be provided
TAGS = {
    "Scene":        "Training",
    "ModelType":    "NLP-Text",
    "ExpDirection": "Fine-grained-DataProcessing",
}

def sign_request(method, path, headers, body, action="CreateJob"):
    now = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
    headers.update({"x-acs-date": now, "x-acs-version": "2020-12-03", "x-acs-action": action,
                    "x-acs-signature-nonce": hashlib.md5((now + body).encode()).hexdigest()})
    signed_keys = sorted(k for k in headers if k.startswith("x-acs-") or k in ("host", "content-type"))
    canonical_headers = "".join(f"{k}:{headers[k]}\n" for k in signed_keys)
    hashed_body = hashlib.sha256(body.encode("utf-8")).hexdigest()
    canonical_request = f"{method}\n{path}\n\n{canonical_headers}\n{';'.join(signed_keys)}\n{hashed_body}"
    string_to_sign = f"ACS3-HMAC-SHA256\n{hashlib.sha256(canonical_request.encode()).hexdigest()}"
    signature = hmac.new(ACCESS_KEY_SECRET.encode(), string_to_sign.encode(), hashlib.sha256).hexdigest()
    headers["Authorization"] = (f"ACS3-HMAC-SHA256 Credential={ACCESS_KEY_ID},"
                                 f"SignedHeaders={';'.join(signed_keys)},Signature={signature}")
    return headers

def main():
    job = {
        "DisplayName": f"my-training-job-{int(time.time())}",
        "JobType": "PyTorchJob",
        "WorkspaceId": WORKSPACE_ID,
        "UserCommand": "echo hello && sleep 5",
        "JobSpecs": [{"Type": "Worker",
                      "Image": "registry.cn-hangzhou.aliyuncs.com/pai-dlc/pytorch-training:1.12-gpu-py39-cu116-ubuntu20.04",
                      "PodCount": 1, "EcsSpec": "ecs.g6.large"}],
        "Settings": {"Tags": TAGS},  # Tags are placed in Settings.Tags
    }
    if RESOURCE_ID:
        job["ResourceId"] = RESOURCE_ID
    request_body = json.dumps(job, ensure_ascii=False)
    url = f"https://{DLC_ENDPOINT}{DLC_API_PATH}"
    headers = sign_request("POST", DLC_API_PATH, {"host": DLC_ENDPOINT, "content-type": "application/json"}, request_body)
    resp = requests.post(url, headers=headers, data=request_body.encode("utf-8"), timeout=30)
    print(f"HTTP {resp.status_code}: {resp.text}")
    if resp.status_code != 200:
        sys.exit(1)

if __name__ == "__main__":
    main()

Filter pekerjaan DLC berdasarkan tag

API ListJobs mendukung filter berbasis tag melalui parameter kueri Tags (format string JSON). Beberapa tag menggunakan logika AND—semua tag yang ditentukan harus cocok agar pekerjaan muncul dalam hasil.

Kode contoh Python: filter pekerjaan DLC berdasarkan tag

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import json
import sys
import hashlib
import hmac
import datetime
import requests
from urllib.parse import urlencode

ACCESS_KEY_ID     = "your-AccessKeyId"
ACCESS_KEY_SECRET = "your-AccessKeySecret"
REGION_ID         = "cn-hangzhou"
WORKSPACE_ID      = "your-workspace-ID"

ENDPOINT = f"pai-dlc.{REGION_ID}.aliyuncs.com"
API_PATH = "/api/v1/jobs"

def build_query_params(workspace_id, filter_tags, page_size=50, page_number=1):
    query_params = {
        "WorkspaceId": workspace_id,
        "PageSize": str(page_size),
        "PageNumber": str(page_number),
        "SortBy": "GmtCreateTime",
        "Order": "desc",
    }

    if filter_tags:
        query_params["Tags"] = json.dumps(
            filter_tags, ensure_ascii=False, separators=(",", ":")
        )

    return query_params

def sign_request(method, path, query_string, headers, body=""):
    now = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
    headers.update({
        "x-acs-date": now,
        "x-acs-version": "2020-12-03",
        "x-acs-action": "ListJobs",
        "x-acs-signature-nonce": hashlib.md5((now + query_string + body).encode()).hexdigest(),
    })

    normalized_headers = {k.lower(): v for k, v in headers.items()}
    signed_keys = sorted(
        k for k in normalized_headers
        if k.startswith("x-acs-") or k in ("host", "content-type")
    )

    canonical_headers = "".join(f"{k}:{normalized_headers[k]}\n" for k in signed_keys)
    hashed_body = hashlib.sha256(body.encode("utf-8")).hexdigest()

    canonical_request = (
        f"{method}\n"
        f"{path}\n"
        f"{query_string}\n"
        f"{canonical_headers}\n"
        f"{';'.join(signed_keys)}\n"
        f"{hashed_body}"
    )

    string_to_sign = f"ACS3-HMAC-SHA256\n{hashlib.sha256(canonical_request.encode()).hexdigest()}"
    signature = hmac.new(
        ACCESS_KEY_SECRET.encode(),
        string_to_sign.encode(),
        hashlib.sha256
    ).hexdigest()

    headers["Authorization"] = (
        f"ACS3-HMAC-SHA256 Credential={ACCESS_KEY_ID},"
        f"SignedHeaders={';'.join(signed_keys)},"
        f"Signature={signature}"
    )
    return headers

def list_jobs_by_tags(filter_tags, page_size=50, page_number=1):
    query_params = build_query_params(WORKSPACE_ID, filter_tags, page_size, page_number)
    query_string = urlencode(sorted(query_params.items()))
    url = f"https://{ENDPOINT}{API_PATH}?{query_string}"

    headers = {
        "host": ENDPOINT,
        "content-type": "application/json",
    }
    headers = sign_request("GET", API_PATH, query_string, headers, body="")

    resp = requests.get(url, headers=headers, timeout=30)
    print(f"HTTP {resp.status_code}")
    print(resp.text)

    if resp.status_code != 200:
        sys.exit(1)

    return resp.json()

def main():
    filter_tags = {"Scene": "Training"}
    list_jobs_by_tags(filter_tags)

if __name__ == "__main__":
    main()

Lihat riwayat perubahan tag

ActionTrail mencatat semua perubahan pada aturan tag, termasuk operator, cap waktu, dan detail perubahan.

Login ke Konsol ActionTrail, buka Advanced query, atur nama layanan menjadi PAI dan nama event menjadi UpdateConfigs, lalu filter catatan di mana ConfigKey adalah predefinedTags untuk melihat riwayat perubahan aturan tag.