Standardize DLC DSW EAS service tagging in PAI - Platform For AI: Central de Documentação do Alibaba Cloud

As regras de tag permitem que os administradores do workspace garantam a consistência das tags em DLC, DSW e EAS. Os administradores definem chaves de tag obrigatórias, valores predefinidos, descrições e o escopo de product aplicável. Quando uma regra está ativa, os desenvolvedores de ML devem aplicar tags aos jobs do DLC, às instâncias do DSW e aos services do EAS no momento da criação — a validação das tags ocorre automaticamente. Tags consistentes facilitam a alocação de custos, a análise de distribuição de jobs e os relatórios de consumo de recursos.

Definir regras de tag

Nota

Apenas owners e administrators do workspace podem editar regras de tag.

Acesse a página de detalhes do workspace e, no canto superior direito, clique em Configure Workspace > General Configurations.
Role até a seção Tag Configuration e clique em Modify Configuration para entrar no modo de edição.
Adicione as regras de tag conforme necessário e clique em Save. As regras configuradas entram em vigor para o escopo de product selecionado. Nas páginas dos subprodutos correspondentes, essas tags tornam-se obrigatórias por padrão. Se uma tag estiver ausente ou em desacordo com as regras, o envio falhará. Os desenvolvedores de ML também podem adicionar tags personalizadas além das obrigatórias, desde que atendam aos requisitos de chave e valor da tag.
- Requisitos da Tag Key: Não pode começar com aliyun ou acs:, não pode conter http:// ou https:// e deve ter no máximo 128 caracteres. São permitidas apenas letras, dígitos, hifens (-), caracteres chineses e pontos (.); underscores (_) não são permitidos.
- Requisitos de valor: Não pode conter http:// ou https:// e deve ter no máximo 256 caracteres. Separe múltiplos valores enumerados com vírgulas.
- Value Constraints: Quando ativada, os usuários devem selecionar um dos valores predefinidos e não podem inserir valores personalizados. Ative esta opção para impor a consistência das tags em toda a equipe.
- Applicable Services: Selecione a quais subprodutos (DLC, DSW ou EAS) esta regra se aplica. Pelo menos um deve ser selecionado.

Aplicar tags

Aplique as tags de acordo com as regras do workspace ao enviar um job do DLC ou criar uma instância do DSW ou EAS. O exemplo a seguir utiliza o envio de um job do DLC:

Acesse o console do DLC e clique em Create Job.
Na página de configuração do job, localize a seção Tag e preencha os pares chave-valor conforme as regras de tag do workspace.

Você também pode adicionar tags personalizadas durante a criação do job.
Após preencher todas as tags obrigatórias, envie o job.

Importante

A validação das regras de tag ocorre no momento do envio. Se uma tag obrigatória estiver ausente ou se o valor não corresponder à regra, o envio falhará com uma mensagem de erro.

Filtrar jobs por tag

Use a filtragem baseada em tags na lista de jobs do DLC para detalhar a distribuição de jobs e o uso de recursos por cenário, tipo de modelo ou outros critérios.

Acesse a página da lista de jobs no console do DLC.
Na barra de pesquisa, selecione Tag como condição de filtro, insira a chave e o valor da tag e clique em pesquisar. A lista exibirá apenas os jobs que correspondem aos critérios.

Apêndice

Referência de API

Para configurar regras de tag em massa ou integrar com pipelines de automação, use os exemplos de código a seguir. Substitua os valores de região, ID do workspace, AccessKey ID e Secret antes de executar o código.

Configurar regras de tag em massa

A API UpdateConfigs suporta a configuração em massa de regras de tag predefinidas e é adequada para aplicar a mesma configuração de tags em vários workspaces.

Estrutura do corpo da requisição de exemplo:

{
  "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"
        }
      ]
    }
  ]
}

Código de exemplo em Python: configurar regras de tag em massa

#!/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()

Especificar tags ao enviar um job do DLC

Ao enviar um job do DLC via API CreateJob, especifique as tags no campo Settings.Tags. Preencha todas as tags obrigatórias. Selecione os valores entre as opções predefinidas, exceto para tags onde ValueFlexible é true, que aceitam entrada personalizada.

Código de exemplo em Python: especificar tags ao enviar um job do 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()

Filtrar jobs do DLC por tag

A API ListJobs suporta filtragem baseada em tags por meio do parâmetro de consulta Tags (formato de string JSON). Múltiplas tags usam lógica AND — todas as tags especificadas devem corresponder para que um job apareça nos resultados.

Código de exemplo em Python: filtrar jobs do DLC por 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()

Visualizar histórico de alterações de tags

O ActionTrail registra todas as alterações nas regras de tag, incluindo o operador, o carimbo de data/hora e o que foi modificado.

Faça login no console do ActionTrail, acesse Advanced query, defina o nome do service como PAI e o nome do evento como UpdateConfigs; em seguida, filtre pelos registros onde ConfigKey é predefinedTags para visualizar o histórico de alterações das regras de tag.