fufu-cloud-cli 0.5.0__tar.gz → 0.7.0__tar.gz

{fufu_cloud_cli-0.5.0/src/fufu_cloud_cli.egg-info → fufu_cloud_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fufu-cloud-cli
-Version: 0.5.0
+Version: 0.7.0
 Summary: FUFU Cloud CLI for tenant-scoped mock cloud development and deployment
 License-Expression: LicenseRef-Proprietary
 Requires-Python: >=3.10
@@ -69,7 +69,8 @@ credential 內含 FUFU endpoint。`FUFU_ENDPOINT` 可明確覆寫目的地：僅
 一般命令交換短期權杖並在結束時嘗試撤銷。`fufu auth assume-role`
 可建立受限 session 檔，檔案以排他方式建立且權限為 `0600`；請勿提交。
 FUFU credential 與 session 檔仍屬秘密，必須由作業系統和 CI 控制存取。
-原生雲端的 GitHub auth actions、OIDC、SigV4 和 OAuth 不直接相容。
+原生雲端的 GitHub auth actions、OIDC 和 OAuth 不直接相容。
+Lambda Function URL 的 AWS_IAM 支援長效 FUFU access key 的 SigV4 header signing；管理 API 仍使用 FUFU token。
 
 ## 部署與支援範圍
 
@@ -77,21 +78,32 @@ FUFU credential 與 session 檔仍屬秘密，必須由作業系統和 CI 控制
 fufu capabilities
 fufu capabilities --remote --provider gcp --require cloud-run-http
 gcloud-fufu run deploy example --image approved-image:tag
+gcloud-fufu run deploy example --source ./prepared-asgi.zip --entry-point main:app
 gcloud-fufu functions deploy example-function --gen2 \
   --runtime python312 --source ./function --entry-point handler --trigger-http
 aws-fufu lambda list-functions
 ```
 
-映像需先由 FUFU 管理者準備及核准。Function 來源會上傳指定目錄中的
+自訂映像需先由 FUFU 管理者準備及核准。API 模式的 Cloud Run `--source`
+接受已封裝 Uvicorn 與相依套件的 Python 3.12 ASGI ZIP／乾淨目錄，自動離線建置、
+檢查映像並核准到目前租戶；不需要主機 SSH 或每次人工核准。
+`--entry-point module:app` 是 FUFU 擴充旗標，預設 `main:app`。
+來源上限為 ZIP 6 MiB、解壓縮 32 MiB、2000 個檔案；不接受隱藏檔、Dockerfile、
+自訂安裝設定或非空 requirements.txt。相依套件需在 CI 封裝，服務端不執行安裝 hook。
+這是固定 ASGI 配方，不提供完整 Cloud Build 或 registry API。
+成功回應包含 `build.status`、`imageDigest` 與來源包雜湊；自動核准映像
+僅供該租戶目前服務使用，取代或刪除最後一個引用後不再開放重用。
+
+Function 來源會上傳指定目錄中的
 Python 與 requirements 檔；Lambda 會上傳指定的 ZIP。請使用只含必要程式碼的
 目錄或 ZIP，先移除硬編碼秘密、個人資料與不需要的檔案。
 CLI 無法判斷任意原始碼或 ZIP 內的資料是否可以分享。
 
 | 服務 | 可用範圍與主要限制 |
 | --- | --- |
-| Cloud Run | 單一已核准 HTTP 容器；無 autoscaling、traffic splitting、Jobs 或公開 ingress |
+| Cloud Run | 已核准 HTTP 容器或 API 自動建置 Python ASGI 來源；支援配置後的 HTTPS 入口、Invoker policy；無 autoscaling、traffic splitting、Jobs |
 | Cloud Run functions / Functions Gen 1 | Python 3.12 HTTP 函式；Gen 1 為相同 HTTP runtime 的模擬子集，無背景事件 |
-| AWS Lambda | Python 3.10 / 3.12 ZIP、同步 invoke、程式碼更新；遠端 ZIP 上限 6 MiB |
+| AWS Lambda | Python 3.10 / 3.12 ZIP、同步 invoke、程式碼更新、BUFFERED Function URL；遠端 ZIP 上限 6 MiB |
 | GCS / S3 | bucket 與 object 操作子集；單一 object 上限 6 MiB，無 versioning / signed URL |
 | DynamoDB / SQS / SSM | 明列資料操作；無完整交易、Streams、FIFO 或 KMS / SecureString |
 | AWS IAM / GCP IAM | 租戶內 role / service account / policy 子集；default deny、限定 session；無原生雲端全量 IAM 語義 |
@@ -107,11 +119,34 @@ CLI 無法判斷任意原始碼或 ZIP 內的資料是否可以分享。
 
 Cloud Run manifest 支援 `serving.knative.dev/v1`、`kind: Service`、
 `metadata.name`、單一 container 的 image / port / env，以及明列的 service account。
+服務 metadata.annotations 支援 `run.googleapis.com/ingress`（all／internal）與
+`run.googleapis.com/invoker-iam-disabled`（字串 true／false）。
 `fufu plan --file service.yaml` 可在不部署的情況下檢查設定；plan 僅列出環境變數名稱。
 相同設定可用 JSON。其他正式雲端欄位需要顯式調整，不能宣稱所有設定無痛相容。
 
 ## 隱私與執行邊界
 
+0.7.0 新增服務公開存取。需由平台配置 DNS、HTTPS 入口與 WAF 放行，
+`publicAccess.status=ready` 表示入口已配置；仍應由 CI 實際 HTTP 呼叫確認外部可達。
+
+```bash
+gcloud-fufu run services update example --allow-unauthenticated --ingress all
+gcloud-fufu run services get-iam-policy example
+gcloud-fufu run services update example --no-allow-unauthenticated
+gcloud-fufu auth print-identity-token --audiences https://app-SERVICE_ID.example.com
+aws-fufu lambda create-function-url-config --function-name example --auth-type AWS_IAM
+aws-fufu lambda get-function-url-config --function-name example
+```
+
+UI 與 CLI 共用同一份服務政策。Cloud Run 與 HTTP Functions 的匿名政策使用
+`allUsers` 與對應 Invoker 角色。Lambda `NONE` 必須另加 `lambda:InvokeFunctionUrl`
+（`--function-url-auth-type NONE`）和 `lambda:InvokeFunction`
+（`--invoked-via-function-url`）兩項資源權限；只設定 NONE 不會自動開放呼叫。
+入口支援有界限的普通 HTTP：請求與回應各 6 MiB、執行 15 秒，每服務每分鐘 120 次。
+不支援 SSE、WebSocket、串流、STS 暫時金鑰、presigned URL 或真實 VPC。
+GCP ID token 由 FUFU 的 RS256 issuer 簽發，綁定精確 audience，15 分鐘後過期；不接受 Google ID token。
+`print-identity-token` 明確輸出秘密，應直接放入受控變數，避免 CI 日誌或 shell tracing。
+
 - 套件沒有遙測、廣告、背景更新或安裝時網路腳本。
 - API 請求只使用明確提供的 FUFU endpoint 和 credential；不掃描使用者家目錄。
 - `whoami` 會輸出目前租戶、provider 與 scope；查詢／invoke 會輸出所要求的資料。

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/README.md

@@ -56,7 +56,8 @@ credential 內含 FUFU endpoint。`FUFU_ENDPOINT` 可明確覆寫目的地：僅
 一般命令交換短期權杖並在結束時嘗試撤銷。`fufu auth assume-role`
 可建立受限 session 檔，檔案以排他方式建立且權限為 `0600`；請勿提交。
 FUFU credential 與 session 檔仍屬秘密，必須由作業系統和 CI 控制存取。
-原生雲端的 GitHub auth actions、OIDC、SigV4 和 OAuth 不直接相容。
+原生雲端的 GitHub auth actions、OIDC 和 OAuth 不直接相容。
+Lambda Function URL 的 AWS_IAM 支援長效 FUFU access key 的 SigV4 header signing；管理 API 仍使用 FUFU token。
 
 ## 部署與支援範圍
 
@@ -64,21 +65,32 @@ FUFU credential 與 session 檔仍屬秘密，必須由作業系統和 CI 控制
 fufu capabilities
 fufu capabilities --remote --provider gcp --require cloud-run-http
 gcloud-fufu run deploy example --image approved-image:tag
+gcloud-fufu run deploy example --source ./prepared-asgi.zip --entry-point main:app
 gcloud-fufu functions deploy example-function --gen2 \
   --runtime python312 --source ./function --entry-point handler --trigger-http
 aws-fufu lambda list-functions
 ```
 
-映像需先由 FUFU 管理者準備及核准。Function 來源會上傳指定目錄中的
+自訂映像需先由 FUFU 管理者準備及核准。API 模式的 Cloud Run `--source`
+接受已封裝 Uvicorn 與相依套件的 Python 3.12 ASGI ZIP／乾淨目錄，自動離線建置、
+檢查映像並核准到目前租戶；不需要主機 SSH 或每次人工核准。
+`--entry-point module:app` 是 FUFU 擴充旗標，預設 `main:app`。
+來源上限為 ZIP 6 MiB、解壓縮 32 MiB、2000 個檔案；不接受隱藏檔、Dockerfile、
+自訂安裝設定或非空 requirements.txt。相依套件需在 CI 封裝，服務端不執行安裝 hook。
+這是固定 ASGI 配方，不提供完整 Cloud Build 或 registry API。
+成功回應包含 `build.status`、`imageDigest` 與來源包雜湊；自動核准映像
+僅供該租戶目前服務使用，取代或刪除最後一個引用後不再開放重用。
+
+Function 來源會上傳指定目錄中的
 Python 與 requirements 檔；Lambda 會上傳指定的 ZIP。請使用只含必要程式碼的
 目錄或 ZIP，先移除硬編碼秘密、個人資料與不需要的檔案。
 CLI 無法判斷任意原始碼或 ZIP 內的資料是否可以分享。
 
 | 服務 | 可用範圍與主要限制 |
 | --- | --- |
-| Cloud Run | 單一已核准 HTTP 容器；無 autoscaling、traffic splitting、Jobs 或公開 ingress |
+| Cloud Run | 已核准 HTTP 容器或 API 自動建置 Python ASGI 來源；支援配置後的 HTTPS 入口、Invoker policy；無 autoscaling、traffic splitting、Jobs |
 | Cloud Run functions / Functions Gen 1 | Python 3.12 HTTP 函式；Gen 1 為相同 HTTP runtime 的模擬子集，無背景事件 |
-| AWS Lambda | Python 3.10 / 3.12 ZIP、同步 invoke、程式碼更新；遠端 ZIP 上限 6 MiB |
+| AWS Lambda | Python 3.10 / 3.12 ZIP、同步 invoke、程式碼更新、BUFFERED Function URL；遠端 ZIP 上限 6 MiB |
 | GCS / S3 | bucket 與 object 操作子集；單一 object 上限 6 MiB，無 versioning / signed URL |
 | DynamoDB / SQS / SSM | 明列資料操作；無完整交易、Streams、FIFO 或 KMS / SecureString |
 | AWS IAM / GCP IAM | 租戶內 role / service account / policy 子集；default deny、限定 session；無原生雲端全量 IAM 語義 |
@@ -94,11 +106,34 @@ CLI 無法判斷任意原始碼或 ZIP 內的資料是否可以分享。
 
 Cloud Run manifest 支援 `serving.knative.dev/v1`、`kind: Service`、
 `metadata.name`、單一 container 的 image / port / env，以及明列的 service account。
+服務 metadata.annotations 支援 `run.googleapis.com/ingress`（all／internal）與
+`run.googleapis.com/invoker-iam-disabled`（字串 true／false）。
 `fufu plan --file service.yaml` 可在不部署的情況下檢查設定；plan 僅列出環境變數名稱。
 相同設定可用 JSON。其他正式雲端欄位需要顯式調整，不能宣稱所有設定無痛相容。
 
 ## 隱私與執行邊界
 
+0.7.0 新增服務公開存取。需由平台配置 DNS、HTTPS 入口與 WAF 放行，
+`publicAccess.status=ready` 表示入口已配置；仍應由 CI 實際 HTTP 呼叫確認外部可達。
+
+```bash
+gcloud-fufu run services update example --allow-unauthenticated --ingress all
+gcloud-fufu run services get-iam-policy example
+gcloud-fufu run services update example --no-allow-unauthenticated
+gcloud-fufu auth print-identity-token --audiences https://app-SERVICE_ID.example.com
+aws-fufu lambda create-function-url-config --function-name example --auth-type AWS_IAM
+aws-fufu lambda get-function-url-config --function-name example
+```
+
+UI 與 CLI 共用同一份服務政策。Cloud Run 與 HTTP Functions 的匿名政策使用
+`allUsers` 與對應 Invoker 角色。Lambda `NONE` 必須另加 `lambda:InvokeFunctionUrl`
+（`--function-url-auth-type NONE`）和 `lambda:InvokeFunction`
+（`--invoked-via-function-url`）兩項資源權限；只設定 NONE 不會自動開放呼叫。
+入口支援有界限的普通 HTTP：請求與回應各 6 MiB、執行 15 秒，每服務每分鐘 120 次。
+不支援 SSE、WebSocket、串流、STS 暫時金鑰、presigned URL 或真實 VPC。
+GCP ID token 由 FUFU 的 RS256 issuer 簽發，綁定精確 audience，15 分鐘後過期；不接受 Google ID token。
+`print-identity-token` 明確輸出秘密，應直接放入受控變數，避免 CI 日誌或 shell tracing。
+
 - 套件沒有遙測、廣告、背景更新或安裝時網路腳本。
 - API 請求只使用明確提供的 FUFU endpoint 和 credential；不掃描使用者家目錄。
 - `whoami` 會輸出目前租戶、provider 與 scope；查詢／invoke 會輸出所要求的資料。

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fufu-cloud-cli"
-version = "0.5.0"
+version = "0.7.0"
 description = "FUFU Cloud CLI for tenant-scoped mock cloud development and deployment"
 readme = "README.md"
 requires-python = ">=3.10"

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/src/fufu_cloud_cli/__init__.py

@@ -1,3 +1,3 @@
 """FUFU CLI 與本機部署工具；相容範圍見 capabilities.json。"""
 
-__version__ = "0.5.0"
+__version__ = "0.7.0"

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/src/fufu_cloud_cli/capabilities.json

@@ -11,6 +11,8 @@
       "status": "implemented",
       "operations": [
         "deploy-image",
+        "deploy-python312-asgi-source-api",
+        "automatic-tenant-image-admission",
         "replace-service-subset",
         "describe",
         "list",
@@ -19,13 +21,16 @@
       ],
       "limitations": [
         "single-approved-container",
+        "source-prepackaged-dependencies-6MiB",
+        "source-fixed-recipe-no-custom-Dockerfile",
+        "source-approval-current-tenant-services-only",
         "GCP-service-account-subset",
         "explicit-GCS-workload-helper",
         "no-registry-upload",
         "no-autoscaling",
         "no-traffic-splitting",
         "no-jobs",
-        "no-public-ingress"
+        "public-ingress-requires-configured-api-gateway"
       ],
       "backends": [
         "local-docker",
@@ -77,6 +82,13 @@
         "api"
       ]
     },
+    "public-http-access": {
+      "status": "implemented",
+      "backend": "api",
+      "mode": "simplified",
+      "operations": ["stable-service-https-url", "enable-disable", "service-invoker-policy", "cloud-run-ingress-annotation", "audience-bound-id-token", "lambda-function-url-config", "lambda-url-resource-policy", "aws-sigv4-header-auth"],
+      "limitations": ["operator-DNS-TLS-WAF-required", "Cloud-Run-and-HTTP-Functions-and-Lambda-only", "buffered-6MiB-15s", "no-WebSocket-or-SSE", "no-STS-or-presigned-URL", "FUFU-ID-token-issuer-not-Google", "internal-means-platform-not-VPC", "120-requests-per-minute-per-service", "no-custom-domain-or-CORS-management", "no-full-cloud-IAM-equivalence"]
+    },
     "serverless-framework": {
       "status": "unsupported",
       "reason": "未實作原生 Framework provider/plugins/CloudFormation；可改用明確的 serverless-profile-adapter 子集。"

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/src/fufu_cloud_cli/cli.py

@@ -12,7 +12,8 @@ from .docker_backend import (Backend, FUNCTIONS_IMAGE, INGRESS_IMAGE, KINDS, LAM
                              inspect_image, prepare_runtime)
 from .errors import FufuError, require
 from .api_backend import ApiClient, api_selected, remote_command
-from .remote_compute import RemoteBackend, source_archive, lambda_archive
+from .remote_compute import RemoteBackend, source_archive, lambda_archive, cloud_run_archive
+from .public_access import deployment_flags, run_iam_flags, configuration, configure_gcp, configure_manifest
 
 
 class Parser(argparse.ArgumentParser):
@@ -177,9 +178,10 @@ def fufu_command(argv):
                 "images": available, "auth": "local-docker-permission", "remote_cloud": False}
     if a.action == "deploy":
         spec = manifest.load(a.file)
+        configure_manifest(spec)
         spec["env"].update(env_from_names(a.env))
-        return compute_backend('cloud-run-http').deploy(kind="cloud-run-http", service=spec["name"], image=spec["image"],
-                                port=spec["port"], env=spec["env"], startup_timeout=a.startup_timeout, **({'role': spec['role']} if spec.get('role') else {}))
+        return configure_manifest(spec, compute_backend('cloud-run-http').deploy(kind="cloud-run-http", service=spec["name"], image=spec["image"],
+                                port=spec["port"], env=spec["env"], startup_timeout=a.startup_timeout, **({'role': spec['role']} if spec.get('role') else {})))
     if a.action == "down":
         require(not api_selected(), 'UNSUPPORTED_ARGUMENT', 'API 模式請逐一刪除指定服務；不提供整個租戶清空。')
         return Backend().down()
@@ -204,10 +206,14 @@ def gcloud_command(argv):
     run_sub = run_p.add_subparsers(dest="action", required=True)
     d = run_sub.add_parser("deploy")
     d.add_argument("name")
-    d.add_argument("--image", required=True)
+    source = d.add_mutually_exclusive_group(required=True)
+    source.add_argument('--image')
+    source.add_argument('--source', help='已封裝相依的 Python 3.12 ASGI ZIP／目錄；API 自動建置及核准')
+    d.add_argument('--entry-point', default='main:app', help='FUFU ASGI 來源子集，預設 main:app')
     d.add_argument("--port", type=int, default=8080)
     d.add_argument('--service-account')
     deployment_options(d)
+    deployment_flags(d); run_iam_flags(d)
     services = run_sub.add_parser("services").add_subparsers(dest="service_action", required=True)
     replace = services.add_parser("replace")
     replace.add_argument("file")
@@ -225,6 +231,7 @@ def gcloud_command(argv):
     generation_options(d)
     d.add_argument("--trigger-http", required=True, action="store_true")
     deployment_options(d)
+    deployment_flags(d)
     for action in ("describe", "delete", "call"):
         q = fn.add_parser(action)
         q.add_argument("name")
@@ -237,18 +244,28 @@ def gcloud_command(argv):
     action = a.service_action if a.action == "services" else a.action
     if action == "replace":
         spec = manifest.load(a.file)
+        configure_manifest(spec)
         spec["env"].update(env_from_names(a.env))
-        return compute_backend(kind).deploy(kind=kind, service=spec["name"], image=spec["image"], port=spec["port"],
-                                env=spec["env"], startup_timeout=a.startup_timeout, **({'role': spec['role']} if spec.get('role') else {}))
+        return configure_manifest(spec, compute_backend(kind).deploy(kind=kind, service=spec["name"], image=spec["image"], port=spec["port"],
+                                env=spec["env"], startup_timeout=a.startup_timeout, **({'role': spec['role']} if spec.get('role') else {})))
     if action == "deploy":
         manifest.name(a.name)
+        configuration(a, kind)
+        finish = lambda deployed: configure_gcp(a, kind, a.name, deployed)
         env = env_from_names(a.env)
+        if a.service == 'run' and a.source:
+            require(api_selected(), 'API_BACKEND_REQUIRED', 'Cloud Run --source 自動核准需要 FUFU API 模式。')
+            return finish(RemoteBackend(kind).deploy(kind=kind, service=a.name, env=env, port=a.port,
+                archive=cloud_run_archive(a.source), runtime='python312', handler=a.entry_point,
+                startup_timeout=a.startup_timeout, role=a.service_account))
+        if a.service == 'run':
+            require(a.entry_point == 'main:app', 'UNSUPPORTED_ARGUMENT', '--entry-point 只用於 --source。')
         if a.service == 'functions' and api_selected():
-            return RemoteBackend(kind).deploy(kind=kind, service=a.name, env=env,
-                archive=source_archive(a.source), runtime=a.runtime, handler=a.entry_point, startup_timeout=a.startup_timeout, role=a.service_account)
+            return finish(RemoteBackend(kind).deploy(kind=kind, service=a.name, env=env,
+                archive=source_archive(a.source), runtime=a.runtime, handler=a.entry_point, startup_timeout=a.startup_timeout, role=a.service_account))
         image = a.image if a.service == "run" else build_function(a.source, a.entry_point)
-        return compute_backend(kind).deploy(kind=kind, service=a.name, image=image, port=getattr(a, "port", 8080),
-                                env=env, startup_timeout=a.startup_timeout, **({'role': a.service_account} if a.service_account else {}))
+        return finish(compute_backend(kind).deploy(kind=kind, service=a.name, image=image, port=getattr(a, "port", 8080),
+                                env=env, startup_timeout=a.startup_timeout, **({'role': a.service_account} if a.service_account else {})))
     b = compute_backend(kind)
     if action == "describe":
         return b.describe(kind, a.name)
@@ -361,6 +378,18 @@ def entry(provider, argv=None):
                     require('=' not in argv[i], 'UNSUPPORTED_ARGUMENT', '布林旗標不接受額外值。'); i += 1
                 else: rest.append(argv[i]); i += 1
             argv = rest
+        from . import public_access
+        public_command = None
+        if provider == 'aws-fufu' and len(argv) > 1 and argv[0] == 'lambda' and argv[1] in public_access.AWS_ACTIONS:
+            public_command = public_access.aws_command
+        if provider == 'gcloud-fufu' and (argv[:2] == ['auth', 'print-identity-token']
+                or len(argv) > 2 and argv[:2] == ['run', 'services'] and argv[2] in public_access.GCP_POLICY_ACTIONS | {'update'}
+                or len(argv) > 1 and argv[0] == 'functions' and argv[1] in public_access.GCP_POLICY_ACTIONS):
+            public_command = public_access.gcp_command
+        if public_command:
+            result = public_command(argv, Parser)
+            if type(result) is int: raise SystemExit(result)
+            emit(result); return
         if provider == 'aws-fufu' and argv and argv[0] == 'serverless':
             from .serverless import command
             emit(command(argv[1:], Parser)); return

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/src/fufu_cloud_cli/docker_backend.py

@@ -228,15 +228,19 @@ class Backend:
         require(len(ports) == 1 and ports[0]["HostIp"] == "127.0.0.1", "PORT_MISMATCH", "服務必須只綁定 loopback。")
         return f"http://127.0.0.1:{int(ports[0]['HostPort'])}"
 
+    def service_id(self, r):
+        return r.get('serviceId') or hashlib.sha256(json.dumps(
+            [self.workspace, r['kind'], r['name'], r['revision']]).encode()).hexdigest()[:32]
+
     def public(self, r):
         return {"name": r["name"], "kind": r["kind"], "workspace": self.workspace,
-                "revision": r["revision"], "url": self.url(r), "readiness": "tcp",
-                **{k: r[k] for k in ("runtime", "handler", "role", "sdkTransport", "iamEnforced") if k in r},
+                "revision": r["revision"], "serviceId": self.service_id(r), "url": self.url(r), "readiness": "tcp",
+                **{k: r[k] for k in ("runtime", "handler", "role", "sdkTransport", "iamEnforced", "build") if k in r},
                 "status": "running", "backend": "local-docker"}
 
     def deploy(self, *, kind, service, image, port=8080, env=None, command=None,
                startup_timeout=30, replace=True, require_existing=False, runtime=None, handler=None, preserve_environment=False,
-               runtime_env=None, role=None, gateway_container=None):
+               runtime_env=None, role=None, gateway_container=None, build=None):
         name(service)
         require(kind in KINDS, "UNSUPPORTED_SERVICE", "未支援此服務。")
         require(type(port) is int and 1024 <= port <= 65535, "INVALID_PORT", "無效的容器 port。")
@@ -298,10 +302,11 @@ class Backend:
                 # 環境值經子程序環境注入，不出現在命令列、狀態或部署輸出。
                 candidate = docker(*args, env=supplied)
                 record = {"name": service, "kind": kind, "container_id": candidate,
-                          "port": port, "revision": revision,
+                          "port": port, "revision": revision, "serviceId": self.service_id(old) if old else uuid.uuid4().hex,
                           **({'network': network, 'gateway_id': gateway['id']} if gateway else {}),
                           **({'role': role, 'sdkTransport': 'fufu-workload-token', 'iamEnforced': True} if role else {}),
-                          **({"environment_names": sorted(env)} if kind != 'cloud-run-http' else {}),
+                          **({'build': build} if build else {}),
+                          "environment_names": sorted(env),
                           **({"runtime": runtime, "handler": handler} if runtime is not None else {})}
                 deadline = time.monotonic() + startup_timeout
                 while True:
@@ -422,12 +427,14 @@ class Backend:
                     docker("network", "rm", network)
             return {"workspace": self.workspace, "removed_containers": len(ids)}
 
-    def invoke(self, kind, service, payload, *, path="/", timeout=15):
+    def invoke(self, kind, service, payload, *, path="/", timeout=15, expected_service_id=None):
         require(1 <= timeout <= 120, "INVALID_TIMEOUT", "請求期限須介於 1–120 秒。")
         require(len(payload) <= MAX_PAYLOAD, "PAYLOAD_LIMIT", "Payload 超過 6 MiB。")
         require(isinstance(path, str) and path.startswith("/") and not path.startswith("//")
                 and "\r" not in path and "\n" not in path, "INVALID_PATH", "只能使用本機服務相對路徑。")
         data = self.describe(kind, service)
+        require(expected_service_id is None or data.get('serviceId') == expected_service_id,
+                'NOT_FOUND', '應用網址已失效。')
         route = "/2015-03-31/functions/function/invocations" if kind == "aws-lambda-sync" else path
 
         class NoRedirect(request.HTTPRedirectHandler):
@@ -576,3 +583,54 @@ def build_lambda(archive, runtime, handler):
         sdk.chmod(0o644)
         (dst / "Dockerfile").write_text(f"FROM {base}\nENV FUFU_HANDLER={handler}\nCOPY --chown=10001:10001 app/ ${{LAMBDA_TASK_ROOT}}/\nCMD " + json.dumps(["_fufu_runtime_adapter.handler"]) + "\n")
         return build_image(dst, f"fufu-cli-lambda:{uuid.uuid4().hex}")
+
+
+def build_cloud_run(archive, handler, port, tag):
+    """固定 Python ASGI 配方；不執行使用者 Dockerfile、安裝程式或建置 hook。"""
+    require(isinstance(handler, str) and re.fullmatch(r"[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*:[A-Za-z_]\w*", handler),
+            'INVALID_HANDLER', 'ASGI entry point 必須是 module:app。')
+    require(type(port) is int and 1024 <= port <= 65535, 'INVALID_PORT', '容器 port 範圍為 1024–65535。')
+    require(re.fullmatch(r'fufu-source:[a-f0-9]{64}', tag), 'INVALID_IMAGE', '來源映像名稱無效。')
+    inspect_image(PYTHON_IMAGE)
+    base = PYTHON_IMAGE
+    with tempfile.TemporaryDirectory(prefix='fufu-asgi-') as tmp:
+        context = Path(tmp)
+        app = context / 'app'
+        app.mkdir()
+        # Validate before extraction to bound disk use and reject silent build omissions.
+        try:
+            with zipfile.ZipFile(archive) as z:
+                entries = z.infolist()
+                require(len(entries) <= 2000 and sum(i.file_size for i in entries) <= 32 * 1024**2,
+                        'SOURCE_LIMIT', 'ASGI 來源上限為 2000 個檔案、解壓縮後 32 MiB。')
+                require(all(not any(v.startswith('.') or v in {'__pycache__', 'node_modules'}
+                                    for v in PurePosixPath(i.filename).parts) for i in entries),
+                        'UNSUPPORTED_SOURCE', 'ASGI 來源包不可包含隱藏檔或開發快取。')
+                require(not {'Dockerfile', 'docker-compose.yml', 'compose.yaml', 'Procfile', 'pyproject.toml', 'setup.py'}.intersection(z.namelist()),
+                        'UNSUPPORTED_SOURCE', '來源部署使用固定 ASGI 配方；不接受自訂 Dockerfile、安裝或啟動設定。')
+        except (zipfile.BadZipFile, OSError):
+            raise FufuError('INVALID_ZIP', '來源必須是有效的 ZIP。') from None
+        extract_zip(Path(archive), app)
+        module = handler.split(':')[0].replace('.', '/')
+        require((app / (module + '.py')).is_file() or (app / module / '__init__.py').is_file(),
+                'INVALID_HANDLER', '來源包缺少指定 ASGI 模組。')
+        require((app / 'uvicorn/__main__.py').is_file(), 'DEPENDENCIES_NOT_PREPARED', '請將 Uvicorn 與所有 Linux Python 3.12 相依套件打入來源包。')
+        requirements = app / 'requirements.txt'
+        require(not requirements.exists() or not requirements.read_text().strip(),
+                'DEPENDENCIES_NOT_PREPARED', '來源模式不執行 requirements.txt；請先封裝相依套件。')
+        sdk = app / '_fufu_runtime_sdk.py'
+        require(not sdk.exists(), 'RESERVED_FILE', '來源與 FUFU SDK 保留檔名衝突。')
+        shutil.copyfile(Path(__file__).with_name('runtime_sdk.py'), sdk)
+        sdk.chmod(0o644)
+        command = ['python', '-m', 'uvicorn', handler, '--host', '0.0.0.0', '--port', str(port)]
+        (context / 'Dockerfile').write_text(
+            f'FROM {base}\nCOPY --chown=10001:10001 app/ /app/\nWORKDIR /app\n'
+            'ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1\nUSER 10001:10001\n'
+            'CMD ' + json.dumps(command) + '\n')
+        digest = build_image(context, tag, network='none')
+        policy = object_json(docker('image', 'inspect', digest, '--format',
+            '{"user":{{json .Config.User}},"size":{{json .Size}},"volumes":{{json .Config.Volumes}},"cmd":{{json .Config.Cmd}}}'))
+        require(policy.get('user') == '10001:10001' and type(policy.get('size')) is int
+                and 0 < policy['size'] <= 512 * 1024**2 and not policy.get('volumes') and policy.get('cmd') == command,
+                'IMAGE_POLICY_REJECTED', '建置映像未通過執行身分、大小或啟動設定檢查。')
+        return digest

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/src/fufu_cloud_cli/manifest.py

@@ -83,8 +83,16 @@ def parse(d):
     fields(d, {"apiVersion", "kind", "metadata", "spec"}, "root")
     require(d.get("apiVersion") == "serving.knative.dev/v1" and d.get("kind") == "Service",
             "UNSUPPORTED_CONFIG", "目前只支援 serving.knative.dev/v1 Service 的明列子集。")
-    metadata = fields(d.get("metadata"), {"name"}, "metadata")
+    metadata = fields(d.get("metadata"), {"name", "annotations"}, "metadata")
     service = name(metadata.get("name"))
+    annotations = fields(metadata.get('annotations', {}), {'run.googleapis.com/ingress', 'run.googleapis.com/invoker-iam-disabled'}, 'metadata.annotations')
+    access = {}
+    if 'run.googleapis.com/ingress' in annotations:
+        require(annotations['run.googleapis.com/ingress'] in {'all', 'internal'}, 'UNSUPPORTED_CONFIG', 'Ingress 僅支援 all 或 FUFU 平台 internal。')
+        access['ingress'] = annotations['run.googleapis.com/ingress']
+    if 'run.googleapis.com/invoker-iam-disabled' in annotations:
+        require(annotations['run.googleapis.com/invoker-iam-disabled'] in {'true', 'false'}, 'UNSUPPORTED_CONFIG', 'Invoker IAM annotation 必須為字串 true 或 false。')
+        access['invokerIamDisabled'] = annotations['run.googleapis.com/invoker-iam-disabled'] == 'true'
     spec = fields(d.get("spec"), {"template"}, "spec")
     template = fields(spec.get("template"), {"spec"}, "spec.template")
     pod = fields(template.get("spec"), {"containers", 'serviceAccountName'}, "spec.template.spec")
@@ -111,10 +119,10 @@ def parse(d):
         require(isinstance(k, str) and k not in env, "INVALID_ENV", "環境變數名稱重複或無效。")
         env[k] = item.get("value")
     environment(env)
-    return {"name": service, "image": image, "port": port, "env": env, **({'role': role} if role else {})}
+    return {"name": service, "image": image, "port": port, "env": env, **({'role': role} if role else {}), **({'publicAccess': access} if access else {})}
 
 
 def public_plan(spec):
     return {"backend": "local-docker", "kind": "cloud-run-http", "name": spec["name"],
             "port": spec["port"], "environment_names": sorted(spec["env"]),
-            "checks": "strict-supported-subset", "image_resolution": "at-deploy"}
+            "checks": "strict-supported-subset", "image_resolution": "at-deploy", **({'publicAccess': spec['publicAccess']} if spec.get('publicAccess') else {})}

fufu_cloud_cli-0.7.0/src/fufu_cloud_cli/public_access.py

@@ -0,0 +1,171 @@
+"""Provider-shaped commands over the shared service access API."""
+import json
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+from .api_backend import ApiClient, api_selected, segment
+from .errors import FufuError, require
+
+AWS_ACTIONS = {'create-function-url-config', 'get-function-url-config', 'update-function-url-config',
+               'delete-function-url-config', 'add-permission', 'remove-permission', 'get-policy'}
+GCP_POLICY_ACTIONS = {'get-iam-policy', 'set-iam-policy', 'add-iam-policy-binding', 'remove-iam-policy-binding'}
+
+
+def configure_manifest(spec, deployed=None):
+    config = spec.get('publicAccess', {})
+    args = SimpleNamespace(anonymous=None, ingress=config.get('ingress'),
+                           invoker_iam=not config['invokerIamDisabled'] if 'invokerIamDisabled' in config else None)
+    configuration(args, 'cloud-run-http')
+    if deployed is None: return
+    return configure_gcp(args, 'cloud-run-http', spec['name'], deployed)
+
+
+def access_path(kind, name):
+    return '/compute/services/' + segment(kind) + '/' + segment(name) + '/access'
+
+
+def deployment_flags(parser):
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--allow-unauthenticated', dest='anonymous', action='store_true')
+    group.add_argument('--no-allow-unauthenticated', dest='anonymous', action='store_false')
+    parser.set_defaults(anonymous=None)
+    parser.add_argument('--ingress', choices=['all', 'internal'])
+
+
+def run_iam_flags(parser):
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--invoker-iam-check', dest='invoker_iam', action='store_true')
+    group.add_argument('--no-invoker-iam-check', dest='invoker_iam', action='store_false')
+    parser.set_defaults(invoker_iam=None)
+
+
+def configuration(args, kind):
+    anonymous, invoker = getattr(args, 'anonymous', None), getattr(args, 'invoker_iam', None)
+    require(anonymous is None or invoker is None, 'CONFLICTING_ARGUMENTS',
+            '請選擇 allUsers policy 或 Invoker IAM check 其中一種設定方式。')
+    config = {}
+    if getattr(args, 'ingress', None) is not None: config['ingress'] = args.ingress
+    if invoker is not None: config['invokerIamDisabled'] = not invoker
+    if config or anonymous is not None:
+        require(api_selected(), 'API_BACKEND_REQUIRED', '公開入口與 IAM 設定需要 FUFU API 模式；本機 Docker 不會假裝發布公網。')
+    return config
+
+
+def configure_gcp(args, kind, name, deployed=None):
+    config = configuration(args, kind)
+    anonymous = getattr(args, 'anonymous', None)
+    if not config and anonymous is None:
+        return deployed
+    path = access_path(kind, name)
+    try:
+        with ApiClient('gcp') as api:
+            current = api.request('GET', path)
+            if anonymous is not None:
+                # One CAS update makes anonymous permission and ingress visible together.
+                config['allowUnauthenticated'] = anonymous
+            config['enabled'] = True
+            updated = api.request('PATCH', path, {**config, 'etag': current['etag']})
+            result = api.request('GET', path.removesuffix('/access'))
+            result['publicAccess'] = updated
+            return result
+    except FufuError as exc:
+        if deployed is not None:
+            raise FufuError('DEPLOYED_ACCESS_UPDATE_FAILED',
+                '程式部署已完成，但入口設定未完成；請 describe 確認目前狀態，再更新存取設定。') from exc
+        raise
+
+
+def gcp_command(argv, Parser):
+    if argv[:2] == ['auth', 'print-identity-token']:
+        p = Parser(prog='gcloud-fufu auth print-identity-token', description='輸出 FUFU issuer、15 分鐘且綁定 audience 的 ID token。')
+        p.add_argument('--audiences', required=True)
+        a = p.parse_args(argv[2:])
+        with ApiClient('gcp') as api:
+            result = api.request('POST', '/compute/auth/identity-token', {'audience': a.audiences})
+            require(isinstance(result.get('token'), str), 'INVALID_RESPONSE', 'ID token 回應無效。')
+            sys.stdout.write(result['token'] + '\n')
+        return 0
+    run = argv[:2] == ['run', 'services']
+    args = argv[2:] if run else argv[1:]
+    action = args[0]
+    p = Parser(prog='gcloud-fufu ' + ('run services ' if run else 'functions ') + action)
+    p.add_argument('name')
+    if not run:
+        group = p.add_mutually_exclusive_group()
+        group.add_argument('--gen2', dest='gen2', action='store_true')
+        group.add_argument('--no-gen2', dest='gen2', action='store_false')
+        p.set_defaults(gen2=True)
+    if action == 'update':
+        deployment_flags(p); run_iam_flags(p)
+    elif action in {'add-iam-policy-binding', 'remove-iam-policy-binding'}:
+        p.add_argument('--member', required=True); p.add_argument('--role', required=True)
+    elif action == 'set-iam-policy':
+        p.add_argument('policy_file')
+    a = p.parse_args(args[1:])
+    kind = 'cloud-run-http' if run else 'cloud-run-functions-http' if a.gen2 else 'cloud-functions-gen1-http'
+    if action == 'update':
+        require(configuration(a, kind) or a.anonymous is not None, 'MISSING_CONFIGURATION', '至少提供一個存取設定旗標。')
+        return configure_gcp(a, kind, a.name)
+    path = access_path(kind, a.name)
+    with ApiClient('gcp', read_only=action == 'get-iam-policy') as api:
+        current = api.request('GET', path)
+        if action == 'set-iam-policy':
+            file = Path(a.policy_file)
+            require(file.is_file() and file.stat().st_size <= 65536, 'INVALID_POLICY', 'Policy JSON 上限為 64 KiB。')
+            policy = json.loads(file.read_text())
+            require(isinstance(policy, dict) and not (policy.keys() - {'bindings', 'etag', 'version'})
+                    and policy.get('version', 1) == 1, 'UNSUPPORTED_POLICY', '僅支援無條件 Invoker bindings；其他欄位不會被忽略。')
+            current = api.request('POST', path + '/policy', {'operation': 'set-bindings', 'bindings': policy.get('bindings', []),
+                                                          'etag': policy.get('etag', current['etag'])})
+        elif action != 'get-iam-policy':
+            current = api.request('POST', path + '/policy', {'operation': 'add-binding' if action.startswith('add-') else 'remove-binding',
+                'role': a.role, 'member': a.member, 'etag': current['etag']})
+        return {'version': 1, 'bindings': current['bindings'], 'etag': current['etag'], 'Fufu': metadata(current)}
+
+
+def metadata(access):
+    return {'mode': 'simplified', 'visibility': access['visibility'], 'authenticationScheme': access['authenticationScheme'],
+            'limits': access['limits'], 'serviceId': access['serviceId']}
+
+
+def aws_command(argv, Parser):
+    action = argv[1]
+    p = Parser(prog='aws-fufu lambda ' + action, description='Function URL BUFFERED 子集；AWS_IAM 支援長效 FUFU access key 的 SigV4 header signing。')
+    p.add_argument('--function-name', required=True)
+    if action in {'create-function-url-config', 'update-function-url-config'}:
+        p.add_argument('--auth-type', choices=['NONE', 'AWS_IAM'], required=action.startswith('create-'))
+        p.add_argument('--invoke-mode', choices=['BUFFERED'], default='BUFFERED')
+    if action in {'add-permission', 'remove-permission'}: p.add_argument('--statement-id', required=True)
+    if action == 'add-permission':
+        p.add_argument('--action', dest='permission_action', required=True)
+        p.add_argument('--principal', required=True)
+        p.add_argument('--function-url-auth-type', choices=['NONE', 'AWS_IAM'])
+        p.add_argument('--invoked-via-function-url', action='store_true')
+    p.add_argument('--revision-id')
+    a = p.parse_args(argv[2:])
+    path = access_path('aws-lambda-sync', a.function_name)
+    with ApiClient('aws', read_only=action.startswith('get-')) as api:
+        access = api.request('GET', path)
+        etag = a.revision_id or access['etag']
+        if action in {'create-function-url-config', 'update-function-url-config', 'delete-function-url-config'}:
+            body = {'operation': action.split('-')[0], 'etag': etag}
+            if getattr(a, 'auth_type', None) is not None: body['authType'] = a.auth_type
+            access = api.request('PATCH', path, body)
+            if action.startswith('delete-'): return {}
+        if action == 'get-function-url-config':
+            require(access['enabled'], 'RESOURCE_NOT_FOUND', 'Function URL 尚未建立或已刪除。')
+        if action in {'add-permission', 'remove-permission'}:
+            body = {'operation': action, 'statementId': a.statement_id, 'etag': etag}
+            if action == 'add-permission':
+                body.update(action=a.permission_action, principal=a.principal)
+                if a.function_url_auth_type is not None: body['functionUrlAuthType'] = a.function_url_auth_type
+                if a.invoked_via_function_url: body['invokedViaFunctionUrl'] = True
+            access = api.request('POST', path + '/policy', body)
+            return {'Statement': json.dumps(next(s for s in access['statements'] if s['Sid'] == a.statement_id)),
+                    'Fufu': metadata(access)} if action == 'add-permission' else {}
+        if action == 'get-policy':
+            return {'Policy': json.dumps({'Version': '2012-10-17', 'Statement': access['statements']}), 'RevisionId': access['etag'], 'Fufu': metadata(access)}
+        who = api.whoami()
+        return {'FunctionUrl': access['url'], 'FunctionArn': f"arn:aws:lambda:{who['region']}:{who['accountId']}:function:{a.function_name}",
+                'AuthType': access['authType'], 'InvokeMode': 'BUFFERED', 'LastModifiedTime': access['updatedAt'], 'Fufu': metadata(access)}

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/src/fufu_cloud_cli/remote_compute.py

@@ -43,6 +43,33 @@ def lambda_archive(path):
     return base64.b64encode(p.read_bytes()).decode()
 
 
+def cloud_run_archive(source):
+    """Upload an explicitly prepared ZIP or directory, without dependency execution."""
+    root = Path(source)
+    require(not root.is_symlink(), 'INVALID_SOURCE', '來源不可為符號連結。')
+    if root.is_file():
+        return lambda_archive(root)
+    require(root.is_dir(), 'INVALID_SOURCE', '請指定已封裝相依套件的 ASGI ZIP 或目錄。')
+    data = io.BytesIO()
+    total = count = 0
+    with zipfile.ZipFile(data, 'w', zipfile.ZIP_DEFLATED) as archive:
+        for path in sorted(root.rglob('*')):
+            relative = path.relative_to(root)
+            require(not path.is_symlink(), 'INVALID_SOURCE', '來源不可含符號連結。')
+            require(not any(v.startswith('.') or v in {'__pycache__', 'node_modules'} for v in relative.parts),
+                    'UNSUPPORTED_SOURCE', '請使用只含應用及相依套件的目錄，不可含隱藏檔或快取。')
+            if path.is_dir():
+                continue
+            require(path.is_file(), 'INVALID_SOURCE', '來源只接受一般檔案。')
+            total += path.stat().st_size
+            count += 1
+            require(count <= 2000 and total <= 32 * 1024**2, 'SOURCE_LIMIT', 'ASGI 來源超過上限。')
+            archive.write(path, relative.as_posix())
+            require(data.tell() <= MAX_ARCHIVE, 'SOURCE_LIMIT', '遠端 ASGI ZIP 上限為 6 MiB。')
+    require(0 < data.tell() <= MAX_ARCHIVE, 'SOURCE_LIMIT', '遠端 ASGI ZIP 上限為 6 MiB。')
+    return base64.b64encode(data.getvalue()).decode()
+
+
 class RemoteBackend:
     def __init__(self, kind):
         require(kind in KIND_PROVIDER, "CAPABILITY_NOT_SUPPORTED", "此類型尚無遠端 compute。")

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0/src/fufu_cloud_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fufu-cloud-cli
-Version: 0.5.0
+Version: 0.7.0
 Summary: FUFU Cloud CLI for tenant-scoped mock cloud development and deployment
 License-Expression: LicenseRef-Proprietary
 Requires-Python: >=3.10
@@ -69,7 +69,8 @@ credential 內含 FUFU endpoint。`FUFU_ENDPOINT` 可明確覆寫目的地：僅
 一般命令交換短期權杖並在結束時嘗試撤銷。`fufu auth assume-role`
 可建立受限 session 檔，檔案以排他方式建立且權限為 `0600`；請勿提交。
 FUFU credential 與 session 檔仍屬秘密，必須由作業系統和 CI 控制存取。
-原生雲端的 GitHub auth actions、OIDC、SigV4 和 OAuth 不直接相容。
+原生雲端的 GitHub auth actions、OIDC 和 OAuth 不直接相容。
+Lambda Function URL 的 AWS_IAM 支援長效 FUFU access key 的 SigV4 header signing；管理 API 仍使用 FUFU token。
 
 ## 部署與支援範圍
 
@@ -77,21 +78,32 @@ FUFU credential 與 session 檔仍屬秘密，必須由作業系統和 CI 控制
 fufu capabilities
 fufu capabilities --remote --provider gcp --require cloud-run-http
 gcloud-fufu run deploy example --image approved-image:tag
+gcloud-fufu run deploy example --source ./prepared-asgi.zip --entry-point main:app
 gcloud-fufu functions deploy example-function --gen2 \
   --runtime python312 --source ./function --entry-point handler --trigger-http
 aws-fufu lambda list-functions
 ```
 
-映像需先由 FUFU 管理者準備及核准。Function 來源會上傳指定目錄中的
+自訂映像需先由 FUFU 管理者準備及核准。API 模式的 Cloud Run `--source`
+接受已封裝 Uvicorn 與相依套件的 Python 3.12 ASGI ZIP／乾淨目錄，自動離線建置、
+檢查映像並核准到目前租戶；不需要主機 SSH 或每次人工核准。
+`--entry-point module:app` 是 FUFU 擴充旗標，預設 `main:app`。
+來源上限為 ZIP 6 MiB、解壓縮 32 MiB、2000 個檔案；不接受隱藏檔、Dockerfile、
+自訂安裝設定或非空 requirements.txt。相依套件需在 CI 封裝，服務端不執行安裝 hook。
+這是固定 ASGI 配方，不提供完整 Cloud Build 或 registry API。
+成功回應包含 `build.status`、`imageDigest` 與來源包雜湊；自動核准映像
+僅供該租戶目前服務使用，取代或刪除最後一個引用後不再開放重用。
+
+Function 來源會上傳指定目錄中的
 Python 與 requirements 檔；Lambda 會上傳指定的 ZIP。請使用只含必要程式碼的
 目錄或 ZIP，先移除硬編碼秘密、個人資料與不需要的檔案。
 CLI 無法判斷任意原始碼或 ZIP 內的資料是否可以分享。
 
 | 服務 | 可用範圍與主要限制 |
 | --- | --- |
-| Cloud Run | 單一已核准 HTTP 容器；無 autoscaling、traffic splitting、Jobs 或公開 ingress |
+| Cloud Run | 已核准 HTTP 容器或 API 自動建置 Python ASGI 來源；支援配置後的 HTTPS 入口、Invoker policy；無 autoscaling、traffic splitting、Jobs |
 | Cloud Run functions / Functions Gen 1 | Python 3.12 HTTP 函式；Gen 1 為相同 HTTP runtime 的模擬子集，無背景事件 |
-| AWS Lambda | Python 3.10 / 3.12 ZIP、同步 invoke、程式碼更新；遠端 ZIP 上限 6 MiB |
+| AWS Lambda | Python 3.10 / 3.12 ZIP、同步 invoke、程式碼更新、BUFFERED Function URL；遠端 ZIP 上限 6 MiB |
 | GCS / S3 | bucket 與 object 操作子集；單一 object 上限 6 MiB，無 versioning / signed URL |
 | DynamoDB / SQS / SSM | 明列資料操作；無完整交易、Streams、FIFO 或 KMS / SecureString |
 | AWS IAM / GCP IAM | 租戶內 role / service account / policy 子集；default deny、限定 session；無原生雲端全量 IAM 語義 |
@@ -107,11 +119,34 @@ CLI 無法判斷任意原始碼或 ZIP 內的資料是否可以分享。
 
 Cloud Run manifest 支援 `serving.knative.dev/v1`、`kind: Service`、
 `metadata.name`、單一 container 的 image / port / env，以及明列的 service account。
+服務 metadata.annotations 支援 `run.googleapis.com/ingress`（all／internal）與
+`run.googleapis.com/invoker-iam-disabled`（字串 true／false）。
 `fufu plan --file service.yaml` 可在不部署的情況下檢查設定；plan 僅列出環境變數名稱。
 相同設定可用 JSON。其他正式雲端欄位需要顯式調整，不能宣稱所有設定無痛相容。
 
 ## 隱私與執行邊界
 
+0.7.0 新增服務公開存取。需由平台配置 DNS、HTTPS 入口與 WAF 放行，
+`publicAccess.status=ready` 表示入口已配置；仍應由 CI 實際 HTTP 呼叫確認外部可達。
+
+```bash
+gcloud-fufu run services update example --allow-unauthenticated --ingress all
+gcloud-fufu run services get-iam-policy example
+gcloud-fufu run services update example --no-allow-unauthenticated
+gcloud-fufu auth print-identity-token --audiences https://app-SERVICE_ID.example.com
+aws-fufu lambda create-function-url-config --function-name example --auth-type AWS_IAM
+aws-fufu lambda get-function-url-config --function-name example
+```
+
+UI 與 CLI 共用同一份服務政策。Cloud Run 與 HTTP Functions 的匿名政策使用
+`allUsers` 與對應 Invoker 角色。Lambda `NONE` 必須另加 `lambda:InvokeFunctionUrl`
+（`--function-url-auth-type NONE`）和 `lambda:InvokeFunction`
+（`--invoked-via-function-url`）兩項資源權限；只設定 NONE 不會自動開放呼叫。
+入口支援有界限的普通 HTTP：請求與回應各 6 MiB、執行 15 秒，每服務每分鐘 120 次。
+不支援 SSE、WebSocket、串流、STS 暫時金鑰、presigned URL 或真實 VPC。
+GCP ID token 由 FUFU 的 RS256 issuer 簽發，綁定精確 audience，15 分鐘後過期；不接受 Google ID token。
+`print-identity-token` 明確輸出秘密，應直接放入受控變數，避免 CI 日誌或 shell tracing。
+
 - 套件沒有遙測、廣告、背景更新或安裝時網路腳本。
 - API 請求只使用明確提供的 FUFU endpoint 和 credential；不掃描使用者家目錄。
 - `whoami` 會輸出目前租戶、provider 與 scope；查詢／invoke 會輸出所要求的資料。

{fufu_cloud_cli-0.5.0 → fufu_cloud_cli-0.7.0}/src/fufu_cloud_cli.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/fufu_cloud_cli/docker_backend.py
 src/fufu_cloud_cli/errors.py
 src/fufu_cloud_cli/lambda_adapter.py
 src/fufu_cloud_cli/manifest.py
+src/fufu_cloud_cli/public_access.py
 src/fufu_cloud_cli/remote_compute.py
 src/fufu_cloud_cli/runtime_sdk.py
 src/fufu_cloud_cli/serverless.py