使用带身份验证和 RBAC 的 MLflow Python SDK
在 Alauda AI Platform 上,MLflow Tracking Server 运行在单点登录和多租户环境之后:OAuth proxy 会对每个调用方进行身份验证,而服务器会将每次运行记录在调用用户名下,并根据 Kubernetes RBAC 对其进行授权。本指南通过该 OAuth proxy 使用您自己的身份运行原生的 MLflow Python SDK,整个过程无需浏览器,通过针对平台登录流程编写脚本来使用 OAuth2 authorization code 流程(带 PKCE)——不使用密码授权,且绝不使用 MLflow 容器端口。
有两种无需浏览器即可提供身份信息的方式;请选择其中一种:
- Bearer token(推荐)。通过 CLI 或 Python 获取 Dex id token,并将其作为
MLFLOW_TRACKING_TOKEN 传递;使用 refresh token 续期。operator 默认启用此方法(请参阅下方的设置验证)。
- Session cookie(无需更改平台)。执行 proxy 自身的登录流程以获取其
_oauth2_proxy cookie,并将其附加到请求中。任何安装均可直接使用(见下文)。
身份验证的工作原理
您的运行前面有两层组件:
- OAuth proxy(
oauth2-proxy)对请求进行身份验证——可以使用作为 Authorization: Bearer … 发送的 Dex id token(令牌方式),也可以使用其 _oauth2_proxy session cookie(cookie 方式)。
- MLflow 服务器的
kubernetes-auth plugin 从该凭证中读取您的身份,将其记录为运行的所有者,并根据您在工作区中的 Kubernetes 权限对其进行授权。
客户端始终通过 OAuth proxy 访问——绝不要直接连接到 MLflow 容器端口。
前提条件
mlflow 3.13.0(pip install "mlflow==3.13.0"),这是针对此版本验证过的客户端版本。工作区选择(mlflow.set_workspace)在此版本中可用。Python token helper 还使用 requests 和 cryptography。
- 具有访问目标工作区权限的平台用户名和密码(请参阅 MLflow 工作区和访问控制)。这是普通的平台登录凭证——不是 Kubernetes ServiceAccount,普通用户帐户即可使用。对于共享或自动化使用场景(流水线、无头作业),建议使用专用的非个人帐户,而不是个人登录信息,因为凭证/token 会存储在
Secret 中,并且每次运行都会记录在您进行身份验证所使用的帐户名下。
- 平台的 OAuth client id 和 secret——即 MLflow proxy 使用的客户端(由管理员提供)。在 Alauda 上,这是平台身份验证客户端,例如
alauda-auth;其 secret 存储在 Kubernetes Secret 中(例如 cpaas-oidc-secret)。
从 MLflow Operator v3.13.0 开始,业务集群 OAuth proxy 默认接受 Dex id token。请验证 MLflow 自定义资源仍启用此设置:
apiVersion: mlflow.alauda.io/v1alpha1
kind: MLflow
spec:
auth:
oauth:
skipJwtBearerTokens: true
这是业务集群上的 MLflow proxy,不是平台的全局身份验证服务器。无需更改 Dex 或 global-auth:下面的登录使用平台客户端已允许的 authorization_code 授权。若您从较旧版本升级,或替换了默认 OAuth 配置,请恢复 skipJwtBearerTokens: true。cookie 方式完全无需设置。
从命令行获取令牌(无需浏览器)
平台登录页面是 SSO 页面,但其 API 支持带 PKCE 的标准 OAuth authorization code 流程,因此您可以通过脚本完成登录——无需浏览器重定向。密码会使用登录服务的公钥(/dex/pubkey)进行 RSA 加密,过程与登录页面完全相同,然后交换为 id token(以及用于无头续期的 refresh token)。
Python helper
import base64, hashlib, json, os, secrets
from urllib.parse import urlparse, parse_qs
import requests
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.serialization import load_pem_public_key
PLATFORM = os.environ["PLATFORM_ADDRESS"].rstrip("/") # https://<platform>
CLIENT_ID = os.environ["DEX_CLIENT_ID"] # the MLflow proxy's client, e.g. alauda-auth
CLIENT_SECRET = os.environ["DEX_CLIENT_SECRET"]
USERNAME = os.environ["MLFLOW_USERNAME"]
PASSWORD = os.environ["MLFLOW_PASSWORD"]
REDIRECT_URI = f"{PLATFORM}/oauth2/callback" # any URI the client has registered
VERIFY_TLS = os.environ.get("PLATFORM_CA", False) # CA bundle path, or False to skip (lab only)
s = requests.Session(); s.verify = VERIFY_TLS
_b64url = lambda b: base64.urlsafe_b64encode(b).rstrip(b"=").decode()
def get_tokens() -> dict:
"""Run the authorization-code + PKCE flow headlessly. Returns the Dex token response."""
verifier = _b64url(secrets.token_bytes(48))
challenge = _b64url(hashlib.sha256(verifier.encode()).digest())
# 1) start the flow -> auth-request id
req = s.get(f"{PLATFORM}/dex/api/v1/authorize", params={
"client_id": CLIENT_ID, "redirect_uri": REDIRECT_URI, "response_type": "code",
"scope": "openid email groups offline_access", "state": "cli",
"code_challenge": challenge, "code_challenge_method": "S256"}).json()["req"]
# 2) RSA-encrypt the password, then log in via the local connector -> auth code
pk = s.get(f"{PLATFORM}/dex/pubkey").json() # {"ts": ..., "pubkey": "<PEM>"}
payload = json.dumps({"ts": pk["ts"], "password": PASSWORD}, separators=(",", ":")).encode()
enc = base64.b64encode(load_pem_public_key(pk["pubkey"].encode()).encrypt(payload, padding.PKCS1v15())).decode()
redirect = s.post(f"{PLATFORM}/dex/api/v1/authorize/local", params={"req": req},
json={"account": USERNAME, "password": enc}).json()["redirect_url"]
code = parse_qs(urlparse(redirect).query)["code"][0]
# 3) exchange the code (with the PKCE verifier) -> id_token + refresh_token
return s.post(f"{PLATFORM}/dex/token", data={
"grant_type": "authorization_code", "code": code, "redirect_uri": REDIRECT_URI,
"code_verifier": verifier, "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET}).json()
def refresh(refresh_token: str) -> str:
"""Mint a fresh id token from a refresh token — no login, no browser."""
return s.post(f"{PLATFORM}/dex/token", data={
"grant_type": "refresh_token", "refresh_token": refresh_token,
"client_id": CLIENT_ID, "client_secret": CLIENT_SECRET,
"scope": "openid email groups"}).json()["id_token"]
Shell 等效方式(curl + openssl,无 Python 依赖)
PLATFORM=https://<platform>; CLIENT_ID=<client>; CLIENT_SECRET=<secret>
USERNAME='<user>'; PASSWORD='<password>'; REDIRECT_URI="$PLATFORM/oauth2/callback"
V=$(openssl rand -base64 48 | tr '+/' '-_' | tr -d '=' | cut -c1-64) # PKCE verifier
C=$(printf %s "$V" | openssl dgst -sha256 -binary | openssl base64 -A | tr '+/' '-_' | tr -d '=')
RU=$(jq -rn --arg u "$REDIRECT_URI" '$u|@uri'); SC=$(jq -rn '"openid email groups offline_access"|@uri')
REQ=$(curl -sk "$PLATFORM/dex/api/v1/authorize?client_id=$CLIENT_ID&redirect_uri=$RU&response_type=code&scope=$SC&state=cli&code_challenge=$C&code_challenge_method=S256" | jq -r .req)
PK=$(curl -sk "$PLATFORM/dex/pubkey"); TS=$(echo "$PK"|jq -r .ts); echo "$PK"|jq -r .pubkey >/tmp/dex_pub.pem
ENC=$(printf '{"ts":"%s","password":"%s"}' "$TS" "$PASSWORD" | openssl pkeyutl -encrypt -pubin -inkey /tmp/dex_pub.pem -pkeyopt rsa_padding_mode:pkcs1 | openssl base64 -A)
CODE=$(curl -sk -X POST "$PLATFORM/dex/api/v1/authorize/local?req=$REQ" -H 'Content-Type: application/json' \
--data "$(jq -nc --arg a "$USERNAME" --arg p "$ENC" '{account:$a,password:$p}')" | jq -r .redirect_url | sed -E 's/.*code=([^&]+).*/\1/')
curl -sk "$PLATFORM/dex/token" -d grant_type=authorization_code -d code="$CODE" \
--data-urlencode redirect_uri="$REDIRECT_URI" -d code_verifier="$V" \
-d client_id="$CLIENT_ID" --data-urlencode client_secret="$CLIENT_SECRET" | jq -r .id_token
连接 SDK
import os, mlflow
tok = get_tokens()
os.environ["MLFLOW_TRACKING_TOKEN"] = tok["id_token"].strip() # → Authorization: Bearer
mlflow.set_tracking_uri("http://mlflow-tracking-server.kubeflow:5000") # in-cluster Service (fronted by the OAuth proxy)
mlflow.set_workspace("team-a") # workspace namespace → X-MLFLOW-WORKSPACE
mlflow.set_experiment("my-experiment")
with mlflow.start_run(run_name="sdk-quickstart") as run:
mlflow.log_param("learning_rate", 2e-4)
mlflow.log_metric("loss", 0.123)
print("run:", run.info.run_id)
运行会显示在 Alauda AI Platform → Tools → MLFlow 下,其所有者为您进行身份验证时使用的用户。(已在安全安装环境中完成端到端验证:运行所有者是令牌中的用户身份。)
当客户端在集群内部运行时(流水线组件、Workbench notebook),请使用集群内 Service URL http://mlflow-tracking-server.kubeflow:5000。从集群外部运行时,请改为指向平台路由 https://<platform>/clusters/<cluster>/mlflow——两者都会访问同一个 OAuth proxy(如果您的计算机不信任平台证书,请设置 MLFLOW_TRACKING_INSECURE_TLS=true)。
WARNING
对于共享或无头使用场景,请优先使用专用的非个人帐户(普通平台登录帐户,而不是 Kubernetes ServiceAccount),并将其凭证和客户端 secret 存储在 Kubernetes Secret 中,绝不要写入代码。始终对令牌执行 .strip() 操作(末尾换行符会产生 Invalid … character(s) in header value: 'Bearer …\n')。id token 默认在 24 小时后过期;对于长时间运行的作业,请使用 refresh(tok["refresh_token"]) 续期,而不要重新登录。
选择工作区
运行记录在您选择的工作区中;如果未选择工作区,则使用服务器的默认工作区。以下任一方式都可以设置工作区(SDK 会将其转换为 X-MLFLOW-WORKSPACE 标头):
- 在代码中使用
mlflow.set_workspace("team-a"),
- 使用
MLFLOW_WORKSPACE=team-a 环境变量。
您只能使用帐户有权访问的工作区;请参阅 MLflow Workspaces and Access Control。
注册模型
模型注册表的作用域为工作区,并且使用相同的方式进行授权,因此连接后即可使用常规 SDK 调用:
mlflow.set_workspace("team-a")
with mlflow.start_run():
mlflow.sklearn.log_model(sk_model, name="model", registered_model_name="fraud-detector")
从 MLflow UI 将注册的版本提升为 Staging 或 Production。
备选方案:会话 cookie(无需更改平台)
如果无法启用 spec.auth.oauth.skipJwtBearerTokens,可以驱动 proxy 自身的登录流程来获取其 _oauth2_proxy cookie,并将其附加到请求中——此方式适用于任何未经修改的安装。proxy 会为您启动 OAuth 流程(包括其自身的 PKCE 和 redirect_uri);您只需通过相同的脚本化登录流程重放该流程,并将代码传回 proxy 回调:
PLATFORM=https://<platform>; CLUSTER=<cluster>
USERNAME='<user>'; PASSWORD='<password>'
JAR=$(mktemp)
# 1) start the MLflow proxy login -> the Dex auth query it wants
LOC=$(curl -sk -c "$JAR" -D - -o /dev/null "$PLATFORM/clusters/$CLUSTER/mlflow/" \
| awk 'BEGIN{IGNORECASE=1}/^location:/{print $2}' | tr -d '\r')
QS=${LOC#*\?}
# 2) authorize -> req, then 3) scripted local login -> the proxy callback URL
REQ=$(curl -sk -b "$JAR" -c "$JAR" "$PLATFORM/dex/api/v1/authorize?$QS" | jq -r .req)
PK=$(curl -sk "$PLATFORM/dex/pubkey"); TS=$(echo "$PK"|jq -r .ts); echo "$PK"|jq -r .pubkey >/tmp/dex_pub.pem
ENC=$(printf '{"ts":"%s","password":"%s"}' "$TS" "$PASSWORD" | openssl pkeyutl -encrypt -pubin -inkey /tmp/dex_pub.pem -pkeyopt rsa_padding_mode:pkcs1 | openssl base64 -A)
CB=$(curl -sk -b "$JAR" -c "$JAR" -X POST "$PLATFORM/dex/api/v1/authorize/local?req=$REQ" -H 'Content-Type: application/json' \
--data "$(jq -nc --arg a "$USERNAME" --arg p "$ENC" '{account:$a,password:$p}')" | jq -r .redirect_url)
# 4) the proxy callback exchanges the code and sets the _oauth2_proxy cookie
curl -sk -b "$JAR" -c "$JAR" -o /dev/null "$CB"
COOKIE=$(awk -F'\t' '$6 ~ /^_oauth2_proxy/{printf "%s=%s; ",$6,$7}' "$JAR" | sed 's/; $//') # includes any _oauth2_proxy_N chunks
echo "$COOKIE"
然后使用标头提供程序附加 cookie(该 cookie 携带您的身份——无需令牌,也无需平台设置):
import os, mlflow
from mlflow.tracking.request_header.abstract_request_header_provider import RequestHeaderProvider
from mlflow.tracking.request_header.registry import _request_header_provider_registry
class ProxySessionHeader(RequestHeaderProvider):
def in_context(self):
return bool(os.environ.get("MLFLOW_PROXY_COOKIE")) # export MLFLOW_PROXY_COOKIE='_oauth2_proxy=<value>'
def request_headers(self):
return {"Cookie": os.environ["MLFLOW_PROXY_COOKIE"]}
_request_header_provider_registry.register(ProxySessionHeader)
mlflow.set_tracking_uri("https://<platform>/clusters/<cluster>/mlflow")
mlflow.set_workspace("team-a")
从集群内部运行时,请改为指向集群内 Service URL http://mlflow-tracking-server.kubeflow:5000(不存在 TLS 问题)。在外部 https://<platform>/… 路由上,平台证书是自签名证书,因此请设置 MLFLOW_TRACKING_INSECURE_TLS=true(或将 REQUESTS_CA_BUNDLE 指向平台 CA)。
您还可以从浏览器会话中复制 _oauth2_proxy cookie(DevTools → Application/Storage → Cookies)。会话 cookie 会过期——当调用开始返回登录重定向时,请重新生成该 cookie。
故障排除