veadk-python 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

veadk/integrations/ve_faas/ve_faas.py

@@ -13,10 +13,10 @@
 # limitations under the License.
 
 import json
+import os
 import time
 
 import requests
-import typer
 import volcenginesdkcore
 import volcenginesdkvefaas
 from volcenginesdkvefaas.models.env_for_create_function_input import (
@@ -118,6 +118,7 @@ class VeFaaS:
                 runtime="native-python3.10/v1",
                 request_timeout=1800,
                 envs=envs,
+                memory_mb=2048,
             )
         )
 
@@ -141,6 +142,8 @@ class VeFaaS:
         upstream_name: str,
         service_name: str,
     ):
+        enable_key_auth = os.getenv("VEFAAS_ENABLE_KEY_AUTH", "true").lower() == "true"
+
         response = ve_request(
             request_body={
                 "Name": application_name,
@@ -152,6 +155,8 @@ class VeFaaS:
                     "GatewayName": gateway_name,
                     "ServiceName": service_name,
                     "UpstreamName": upstream_name,
+                    "EnableKeyAuth": enable_key_auth,
+                    "EnableMcpSession": True,
                 },
                 "TemplateId": self.template_id,
             },
@@ -189,16 +194,27 @@ class VeFaaS:
             time.sleep(10)
             status, full_response = self._get_application_status(app_id)
 
-        assert status == "deploy_success", (
-            f"Release application failed. Response: {full_response}"
-        )
-
-        cloud_resource = full_response["Result"]["CloudResource"]
-        cloud_resource = json.loads(cloud_resource)
-
-        url = cloud_resource["framework"]["url"]["system_url"]
-
-        return url
+        if status == "deploy_success":
+            cloud_resource = full_response["Result"]["CloudResource"]
+            cloud_resource = json.loads(cloud_resource)
+            url = cloud_resource["framework"]["url"]["system_url"]
+            return url
+        else:
+            logger.error(
+                f"Release application failed. Application ID: {app_id}, Status: {status}"
+            )
+            import re
+
+            logs = "\n".join(self._get_application_logs(app_id=app_id))
+            log_text = re.sub(
+                r'([{"\']?(key|secret|token|pass|auth|credential|access|api|ak|sk|doubao|volces|coze)[^"\'\s]*["\']?\s*[:=]\s*)(["\']?)([^"\'\s]+)(["\']?)|([A-Za-z0-9+/=]{20,})',
+                lambda m: f"{m.group(1)}{m.group(3)}******{m.group(5)}"
+                if m.group(1)
+                else "******",
+                logs,
+                flags=re.IGNORECASE,
+            )
+            raise Exception(f"Release application failed. Logs:\n{log_text}")
 
     def _get_application_status(self, app_id: str):
         response = ve_request(
@@ -213,18 +229,51 @@ class VeFaaS:
         )
         return response["Result"]["Status"], response
 
-    def _list_application(self):
-        response = ve_request(
-            request_body={},
-            action="ListApplications",
-            ak=self.ak,
-            sk=self.sk,
-            service="vefaas",
-            version="2021-03-03",
-            region="cn-beijing",
-            host="open.volcengineapi.com",
-        )
-        return response["Result"]["Items"]
+    def _list_application(self, app_id: str = None, app_name: str = None):
+        # firt match app_id. if app_id is None,then match app_name and remove app_id
+        request_body = {
+            "OrderBy": {"Key": "CreateTime", "Ascend": False},
+            "FunctionId": app_id if app_id else None,
+            "Filters": [{"Item": {"Key": "Name", "Value": [app_name]}}]
+            if app_name and not app_id
+            else None,
+        }
+        # remove None
+        request_body = {k: v for k, v in request_body.items() if v is not None}
+
+        page_size = 50
+        page_number = 1
+        all_items = []
+        total_page = None
+        while True:
+            try:
+                request_body.update({"PageNumber": page_number, "PageSize": page_size})
+                response = ve_request(
+                    request_body=request_body,
+                    action="ListApplications",
+                    ak=self.ak,
+                    sk=self.sk,
+                    service="vefaas",
+                    version="2021-03-03",
+                    region="cn-beijing",
+                    host="open.volcengineapi.com",
+                )
+                result = response.get("Result", {})
+                items = result.get("Items", [])
+                all_items.extend(items)
+
+                if total_page is None:
+                    total = result.get("Total", 0)
+                    total_page = (total + page_size - 1) // page_size
+
+                if page_number >= total_page or not items:
+                    break
+                page_number += 1
+            except Exception as e:
+                raise ValueError(
+                    f"List application failed. Error: {str(e)}. Response: {response}."
+                )
+        return all_items
 
     def _update_function_code(
         self,
@@ -253,10 +302,6 @@ class VeFaaS:
 
         # Get application status and extract function info
         status, full_response = self._get_application_status(app_id)
-        if status == "deploy_fail":
-            raise ValueError(
-                f"Cannot update failed application. Current status: {status}"
-            )
 
         # Extract function name from application config
         cloud_resource = full_response["Result"]["CloudResource"]
@@ -300,7 +345,7 @@ class VeFaaS:
     def get_application_details(self, app_id: str = None, app_name: str = None):
         if not app_id and not app_name:
             raise ValueError("app_id and app_name cannot be both empty.")
-        apps = self._list_application()
+        apps = self._list_application(app_id=app_id, app_name=app_name)
         if app_id:
             for app in apps:
                 if app["Id"] == app_id:
@@ -312,7 +357,7 @@ class VeFaaS:
                     return app
 
     def find_app_id_by_name(self, name: str):
-        apps = self._list_application()
+        apps = self._list_application(app_name=name)
         for app in apps:
             if app["Name"] == name:
                 return app["Id"]
@@ -332,12 +377,7 @@ class VeFaaS:
                 host="open.volcengineapi.com",
             )
         except Exception as e:
-            typer.echo(
-                typer.style(
-                    f"Delete application failed. Response: {e}",
-                    fg=typer.colors.BRIGHT_RED,
-                )
-            )
+            logger.error(f"Delete application failed. Response: {e}")
 
     def deploy(
         self,
@@ -409,3 +449,280 @@ class VeFaaS:
         logger.info(f"VeFaaS application {name} with ID {app_id} deployed on {url}.")
 
         return url, app_id, function_id
+
+    def _create_image_function(self, function_name: str, image: str):
+        """Create function using container image instead of code upload."""
+        # Read environment variables from veadk configuration
+        envs = []
+        for key, value in veadk.config.veadk_environments.items():
+            envs.append(EnvForCreateFunctionInput(key=key, value=value))
+        logger.info(
+            f"Fetch {len(envs)} environment variables for image function.",
+        )
+
+        # Create function with container image source configuration
+        res = self.client.create_function(
+            volcenginesdkvefaas.CreateFunctionRequest(
+                command="bash ./run.sh",  # Custom startup command
+                name=function_name,
+                description="Created by VeADK (Volcengine Agent Development Kit)",
+                tags=[TagForCreateFunctionInput(key="provider", value="veadk")],
+                runtime="native/v1",  # Native runtime required for container images
+                source_type="image",  # Set source type to container image
+                source=image,  # Container image URL
+                request_timeout=1800,  # Request timeout in seconds
+                envs=envs,  # Environment variables from configuration
+            )
+        )
+
+        # Log function creation success without exposing sensitive information
+        logger.debug(
+            f"Function creation in {res.project_name} project with ID {res.id}"
+        )
+
+        function_id = res.id
+        logger.info(
+            f"Function {function_name} created with image {image} and ID {function_id}"
+        )
+
+        return function_name, function_id
+
+    def query_user_cr_vpc_tunnel(
+        self, registry_name: str, max_attempts: int = 6
+    ) -> bool:
+        """Query and enable CR VPC tunnel for user registry access."""
+        logger.info(f"Setting up CR VPC tunnel for registry: {registry_name}")
+        waiting_times = 30
+
+        try:
+            for attempt in range(max_attempts):
+                # Check current status
+                logger.info(
+                    f"Checking tunnel status (attempt {attempt + 1}/{max_attempts})"
+                )
+                query_resp = ve_request(
+                    request_body={"Registry": registry_name},
+                    action="QueryUserCrVpcTunnel",
+                    ak=self.ak,
+                    sk=self.sk,
+                    service="vefaas",
+                    version="2021-03-03",
+                    region="cn-beijing",
+                    host="open.volcengineapi.com",
+                )
+
+                current_status = query_resp.get("Result", {}).get("Ready", False)
+                logger.info(f"Current tunnel status: {current_status}")
+
+                # Always try to enable
+                logger.info("Enable VPC tunnel")
+                enable_resp = ve_request(
+                    request_body={"Registry": registry_name},
+                    action="EnableUserCrVpcTunnel",
+                    ak=self.ak,
+                    sk=self.sk,
+                    service="vefaas",
+                    version="2021-03-03",
+                    region="cn-beijing",
+                    host="open.volcengineapi.com",
+                )
+
+                # Handle EnableUserCrVpcTunnel response correctly
+                enable_result = enable_resp.get("Result", {})
+                enable_status = enable_result.get("Status", "")
+                enable_message = enable_result.get("Message", "")
+
+                if enable_status == "success":
+                    logger.info("Enable tunnel succeeded")
+                elif enable_status == "failed":
+                    logger.warning(f"Enable tunnel failed: {enable_message}")
+                else:
+                    logger.warning(f"Enable tunnel unknown status: {enable_status}")
+
+                # Verify final status
+                logger.info("Verifying tunnel status")
+                verify_resp = ve_request(
+                    request_body={"Registry": registry_name},
+                    action="QueryUserCrVpcTunnel",
+                    ak=self.ak,
+                    sk=self.sk,
+                    service="vefaas",
+                    version="2021-03-03",
+                    region="cn-beijing",
+                    host="open.volcengineapi.com",
+                )
+
+                final_status = verify_resp.get("Result", {}).get("Ready", False)
+                logger.info(f"Final tunnel status: {final_status}")
+
+                if final_status:
+                    logger.info(
+                        f"CR VPC tunnel successfully enabled for {registry_name}"
+                    )
+                    return True
+
+                # If not ready and not last attempt, wait and retry
+                if attempt < max_attempts - 1:
+                    logger.warning(
+                        f"Tunnel not ready, waiting {waiting_times}s before retry"
+                    )
+                    time.sleep(waiting_times)
+
+        except Exception as e:
+            raise ValueError(f"Failed to setup CR VPC tunnel: {str(e)}")
+
+        return False
+
+    def _create_image_function(self, function_name: str, image: str):
+        """Create function using container image instead of code upload."""
+        # Read environment variables from veadk configuration
+        envs = []
+        for key, value in veadk.config.veadk_environments.items():
+            envs.append(EnvForCreateFunctionInput(key=key, value=value))
+        logger.info(
+            f"Fetch {len(envs)} environment variables for image function.",
+        )
+
+        # Create function with container image source configuration
+        res = self.client.create_function(
+            volcenginesdkvefaas.CreateFunctionRequest(
+                command="bash ./run.sh",  # Custom startup command
+                name=function_name,
+                description="Created by VeADK (Volcengine Agent Development Kit)",
+                tags=[TagForCreateFunctionInput(key="provider", value="veadk")],
+                runtime="native/v1",  # Native runtime required for container images
+                source_type="image",  # Set source type to container image
+                source=image,  # Container image URL
+                request_timeout=1800,  # Request timeout in seconds
+                envs=envs,  # Environment variables from configuration
+            )
+        )
+
+        # Log function creation success without exposing sensitive information
+        logger.debug(
+            f"Function creation in {res.project_name} project with ID {res.id}"
+        )
+
+        function_id = res.id
+        logger.info(
+            f"Function {function_name} created with image {image} and ID {function_id}"
+        )
+
+        return function_name, function_id
+
+    def deploy_image(
+        self,
+        name: str,
+        image: str,
+        registry_name: str,
+        gateway_name: str = "",
+        gateway_service_name: str = "",
+        gateway_upstream_name: str = "",
+    ) -> tuple[str, str, str]:
+        """Deploy application using container image.
+
+        Args:
+            name (str): Application name.
+            image (str): Container image URL.
+            gateway_name (str, optional): Gateway name. Defaults to "".
+            gateway_service_name (str, optional): Gateway service name. Defaults to "".
+            gateway_upstream_name (str, optional): Gateway upstream name. Defaults to "".
+
+        Returns:
+            tuple[str, str, str]: (url, app_id, function_id)
+        """
+        # Validate application name format
+        is_ready = self.query_user_cr_vpc_tunnel(registry_name)
+        if not is_ready:
+            raise ValueError("CR VPC tunnel is not ready")
+
+        if "_" in name:
+            raise ValueError("Function or Application name cannot contain '_'.")
+
+        # Generate default gateway names with timestamp if not provided
+        if not gateway_name:
+            gateway_name = f"{name}-gw-{formatted_timestamp()}"
+
+            # Check for existing serverless gateways to reuse
+            existing_gateways = self.apig_client.list_gateways()
+            for gateway_instance in existing_gateways.items:
+                if (
+                    gateway_instance.type == "serverless"
+                    and gateway_instance.name != gateway_name
+                ):
+                    logger.warning(
+                        f"You have at least one serverless gateway {gateway_instance.name}, but not {gateway_name}. Using {gateway_instance.name} instead."
+                    )
+                    gateway_name = gateway_instance.name
+                    break
+
+        # Set default gateway service and upstream names
+        if not gateway_service_name:
+            gateway_service_name = f"{name}-gw-svr-{formatted_timestamp()}"
+        if not gateway_upstream_name:
+            gateway_upstream_name = f"{name}-gw-us-{formatted_timestamp()}"
+
+        function_name = f"{name}-fn"
+
+        # Log deployment start with image information
+        logger.info(
+            f"Start to create VeFaaS function {function_name} with image {image}. Gateway: {gateway_name}, Gateway Service: {gateway_service_name}, Gateway Upstream: {gateway_upstream_name}."
+        )
+
+        # Create function using container image method
+        function_name, function_id = self._create_image_function(function_name, image)
+        logger.info(f"VeFaaS function {function_name} with ID {function_id} created.")
+
+        # Create application using existing application creation logic
+        logger.info(f"Start to create VeFaaS application {name}.")
+        app_id = self._create_application(
+            name,
+            function_name,
+            gateway_name,
+            gateway_upstream_name,
+            gateway_service_name,
+        )
+
+        # Release application and get deployment URL
+        logger.info(f"VeFaaS application {name} with ID {app_id} created.")
+        logger.info(f"Start to release VeFaaS application {app_id}.")
+        # Release application with retry
+        max_attempts = 5
+        attempt = 0
+        while True:
+            try:
+                url = self._release_application(app_id)
+                logger.info(f"VeFaaS application {name} with ID {app_id} released.")
+                break
+            except Exception:
+                attempt += 1
+                if attempt < max_attempts:
+                    wait_time = 30 * attempt
+                    logger.info(
+                        f"Image sync still in progress. Waiting {wait_time} seconds before retry {attempt}/{max_attempts}."
+                    )
+                    time.sleep(wait_time)
+                else:
+                    raise
+
+        logger.info(f"VeFaaS application {name} with ID {app_id} deployed on {url}.")
+
+        return url, app_id, function_id
+
+    def _get_application_logs(self, app_id: str) -> list[str]:
+        response = _ = ve_request(
+            request_body={"Id": app_id, "Limit": 99999, "RevisionNumber": 1},
+            action="GetApplicationRevisionLog",
+            ak=self.ak,
+            sk=self.sk,
+            service="vefaas",
+            version="2021-03-03",
+            region="cn-beijing",
+            host="open.volcengineapi.com",
+        )
+
+        try:
+            logs = response["Result"]["LogLines"]
+            return logs
+        except Exception as _:
+            raise ValueError(f"Get application log failed. Response: {response}")

veadk/integrations/ve_faas/web_template/cookiecutter.json

@@ -0,0 +1,17 @@
+{
+  "local_dir_name": "veadk_vefaas_web_proj",
+  "app_name": "simple-blog",
+  "vefaas_application_name": "simple-blog",
+  "veapig_instance_name": "",
+  "veapig_service_name": "",
+  "veapig_upstream_name": "",
+  "use_adk_web": false,
+  "veadk_version": "",
+  "_copy_without_render": [
+    "*.html",
+    "*.css",
+    "*.js",
+    "static/**/*",
+    "templates/**/*"
+  ]
+}

veadk/integrations/ve_faas/web_template/{{cookiecutter.local_dir_name}}/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

veadk/integrations/ve_faas/web_template/{{cookiecutter.local_dir_name}}/clean.py

@@ -0,0 +1,23 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from veadk.cloud.cloud_app import CloudApp
+
+def main() -> None:
+    cloud_app = CloudApp(vefaas_application_name="{{cookiecutter.vefaas_application_name}}")
+    cloud_app.delete_self()
+
+
+if __name__ == "__main__":
+    main()

veadk/integrations/ve_faas/web_template/{{cookiecutter.local_dir_name}}/config.yaml.example

@@ -0,0 +1,2 @@
+VOLCENGINE_ACCESS_KEY:
+VOLCENGINE_SECRET_KEY:

veadk/integrations/ve_faas/web_template/{{cookiecutter.local_dir_name}}/deploy.py

@@ -0,0 +1,41 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+from pathlib import Path
+
+from veadk.cloud.cloud_agent_engine import CloudAgentEngine
+
+async def main():
+    engine = CloudAgentEngine()
+
+    cloud_app = engine.deploy(
+        path=str(Path(__file__).parent / "src"),
+        application_name="{{cookiecutter.vefaas_application_name}}",
+        gateway_name="{{cookiecutter.veapig_instance_name}}",
+        gateway_service_name="{{cookiecutter.veapig_service_name}}",
+        gateway_upstream_name="{{cookiecutter.veapig_upstream_name}}",
+        use_adk_web={{cookiecutter.use_adk_web}},
+        local_test=False,  # Set to True for local testing before deploy to VeFaaS
+    )
+    print(f"VeFaaS application ID: {cloud_app.vefaas_application_id}")
+
+    if {{cookiecutter.use_adk_web}}:
+        print(f"Web is running at: {cloud_app.vefaas_endpoint}")
+    else:
+        print(f"Web template does not support use_adk_web=False")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

veadk/integrations/ve_faas/web_template/{{cookiecutter.local_dir_name}}/src/Dockerfile

@@ -0,0 +1,23 @@
+# 使用官方Python镜像作为基础镜像
+FROM python:3.9-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制依赖文件并安装依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 复制项目文件
+COPY . .
+
+# 设置环境变量
+ENV FLASK_APP=app.py
+ENV FLASK_ENV=production
+ENV PYTHONUNBUFFERED=1
+
+# 暴露端口
+EXPOSE 8000
+
+# 启动命令
+CMD ["bash", "run.sh"]