Huawei Cloud Functiongraph Function Create

FunctionGraph Function Creation Skill

Overview

This skill creates FunctionGraph functions on Huawei Cloud based on user-provided parameters including function name, runtime, and code content.

Architecture: Uses Huawei Cloud FunctionGraph Python SDK to interact with FunctionGraph service.

Applicable Scenarios:

• Quickly create cloud functions without manual console login
• Batch creation of multiple functions
• Foundation component for workflow deployment
• CI/CD integration for function deployment

Typical Use Cases:

1. "Create a Python function named my_handler" 2. "Deploy this code to FunctionGraph" 3. "Batch create 10 functions from template"

Prerequisites

1. Python Environment

• Python 3.9+
• Verify: python --version

2. SDK Installation

pip install huaweicloudsdkfunctiongraph

3. Authentication Configuration

• Valid Huawei Cloud credentials (AK/SK mode)
• Configure via environment variables:

export HUAWEI_AK="your-access-key"
export HUAWEI_SK="your-secret-key"
export HUAWEI_REGION="cn-north-4"
export HUAWEI_PROJECT_ID="your-project-id"

Security Rules:

• NEVER expose AK/SK values in code or logs
• NEVER let users input AK/SK directly in conversation
• ALWAYS use environment variables for credentials
• Recommend using IAM user instead of main account

4. IAM Permission Requirements

• functiongraph:function:create - Create function
• functiongraph:function:get - Query function details
• functiongraph:function:list - List functions

See IAM Policies for detailed permission configuration.

Usage

Command

cd scripts
python create_function.py   --name <function_name>   --runtime <runtime>   --han
dler <handler>   --code <code_content>   --memory <memory_size>   --timeout <timeout>

Parameter Confirmation

|| Parameter | Required/Optional | Description | Default || || ----------- | ------------------ | ------------- | --------- || || function_name | Required | Function name, must follow naming rules | - || || runtime | Required | Runtime environment (Python3.9, etc.) | - || || code_content | Required | Function code content | - || || handler | Required | Function entry point (e.g., index.handler) | - || || memory_size | Optional | Memory size in MB | 128 || || timeout | Optional | Timeout in seconds | 3 || || description | Optional | Function description | - ||

Runtime Options

|| Runtime | Handler Format | Example || || --------- | ---------------- | --------- || || Python3.9 | index.handler | def handler(event, context): || || Node.js14.18 | index.handler | exports.handler = (event, context) => {} || || Java8 | com.example.Handler::handleRequest | Java class method || || Go1.x | handler | Go function name ||

Verification Method

See Verification Method for detailed procedures.

Quick Verification

## Verify function exists using SDK

from huaweicloudsdkfunctiongraph.v2.functiongraph_client import FunctionGraphClient
from huaweicloudsdkfunctiongraph.v2.model import ListFunctionsRequest

# List functions to verify creation
client = FunctionGraphClient.new_builder().build()
request = ListFunctionsRequest()
response = client.list_functions(request)
print(f"Total functions: {len(response.functions)}")

Output Format

The skill returns a structured JSON object with the following fields:

• function_urn: Unique resource identifier of the created function
• function_name: Name of the created function
• runtime: Runtime environment
• memory_size: Allocated memory in MB
• timeout: Function timeout in seconds
• handler: Function entry point
• description: Function description (if provided)

Example output:

{
  "function_urn": "urn:fss:cn-north-4:project_id:function:default:my_function",
  "function_name": "my_function",
  "runtime": "Python3.9",
  "memory_size": 128,
  "timeout": 3,
  "handler": "index.handler",
  "description": "Test function created by skill"
}

Best Practices

1. Test before production: Always test in a development environment first 2. Monitor resources: Set up monitoring for function invocations and errors 3. Use environment variables: Store sensitive data in environment variables 4. Implement error handling: Add proper error handling in function code 5. Set appropriate timeouts: Configure timeout based on function logic

Error Handling

|| Error Code | Description | Resolution || || ------------ | ------------- | ------------ || || InvalidParameter | Invalid input parameters | Check parameter format and valu es || || InsufficientPermission | Insufficient permissions | Check IAM permissions || || QuotaExceeded | Resource quota exceeded | Request quota increase or delete un used functions || || FunctionAlreadyExists | Function with same name exists | Use different functi on name or delete existing function ||

References

• FunctionGraph Documentation
• Python SDK Documentation
• IAM Policies Guide
• Verification Method

Acceptance Criteria

This document defines the acceptance criteria, test cases, and success standards for the FunctionGraph function creation workflow.

Overview

Scope

Test Categories

Test Cases

TC-001: Basic Function Creation

Preconditions:

• KooCLI is installed and configured
• IAM permissions are granted
• Valid runtime code is prepared

Test Steps:

# Step 1: Create function
hcloud FunctionGraph function create \
  --func_name=test-function-001 \
  --package_type=Zip \
  --runtime=Python3.9 \
  --handler=index.handler \
  --memory_size=128 \
  --timeout=10 \
  --code_url=https://obs-bucket.obs.cn-north-4.myhuaweicloud.com/code.zip

# Step 2: Verify creation
hcloud FunctionGraph function show \
  --func_urn=urn:fg:cn-north-4:PROJECT_ID:function:test-function-001:latest

Expected Results:

• Function is created successfully
• Status is ACTIVE
• All configuration matches input parameters

Pass Criteria:

• [ ] Function exists in function list
• [ ] Status equals ACTIVE
• [ ] func_name matches specification
• [ ] runtime matches specification
• [ ] memory_size matches specification
• [ ] timeout matches specification

---

TC-002: Function with VPC Configuration

Test Steps:

hcloud FunctionGraph function create \
  --func_name=test-function-vpc \
  --package_type=Zip \
  --runtime=Python3.9 \
  --handler=index.handler \
  --memory_size=256 \
  --timeout=30 \
  --vpc_id=VPC_ID \
  --subnet_id=SUBNET_ID \
  --security_group_id=SECURITY_GROUP_ID

Expected Results:

• Function is created with VPC configuration
• VPC connectivity is established
• Network isolation is verified

Pass Criteria:

• [ ] VPC configuration is saved
• [ ] Function can access VPC resources
• [ ] Network connectivity is verified

---

TC-003: Function with Environment Variables

Test Steps:

hcloud FunctionGraph function create \
  --func_name=test-function-env \
  --package_type=Zip \
  --runtime=Python3.9 \
  --handler=index.handler \
  --memory_size=128 \
  --timeout=10 \
  --environment_variables='{"DB_HOST": "localhost", "DB_PORT": "3306", "DEBUG": "false"}'

Expected Results:

• Environment variables are set correctly
• Variables are accessible in function execution

Pass Criteria:

• [ ] All environment variables are saved
• [ ] Variables are accessible at runtime
• [ ] Sensitive variables are masked in output

---

TC-004: Function with Layers

Test Steps:

# Create layer first
hcloud FunctionGraph layer create \
  --layer_name=my-layer \
  --runtime=Python3.9 \
  --code_url=https://obs-bucket/layer.zip

# Create function with layer
hcloud FunctionGraph function create \
  --func_name=test-function-layer \
  --package_type=Zip \
  --runtime=Python3.9 \
  --handler=index.handler \
  --layers='[{"urn": "urn:fg:cn-north-4:PROJECT_ID:layer:my-layer:1"}]'

Expected Results:

• Layer is attached to function
• Layer dependencies are available

Pass Criteria:

• [ ] Layer is associated with function
• [ ] Layer packages are accessible
• [ ] Function executes with layer dependencies

---

TC-005: Function Invocation

Test Steps:

# Create test event
cat > test-event.json << EOF
{
  "key1": "value1",
  "key2": 100,
  "source": "acceptance-test"
}
EOF

# Invoke function
hcloud FunctionGraph function invoke \
  --func_urn=FUNCTION_URN \
  --body=@test-event.json

Expected Results:

• Function executes successfully
• Returns expected response
• Execution logs are captured

Pass Criteria:

• [ ] Invocation returns success status
• [ ] Response matches expected format
• [ ] Execution time is within limits
• [ ] No errors in execution logs

---

TC-006: Trigger Creation

Test Steps:

# Create API trigger
hcloud FunctionGraph trigger create \
  --func_urn=FUNCTION_URN \
  --trigger_type=apig \
  --trigger_data='{
    "group_id": "API_GROUP_ID",
    "env_id": "DEFAULT_ENV",
    "auth": "IAM"
  }'

# Verify trigger
hcloud FunctionGraph trigger list --func_urn=FUNCTION_URN

# Test via HTTP
curl -X POST https://API_ENDPOINT/invoke \
  -H "Content-Type: application/json" \
  -H "X-Auth-Token: TOKEN" \
  -d '{"test": "http"}'

Expected Results:

• Trigger is created successfully
• HTTP endpoint is accessible
• Function is invoked via trigger

Pass Criteria:

• [ ] Trigger appears in trigger list
• [ ] HTTP endpoint is valid
• [ ] Function invocation succeeds via trigger

---

TC-007: Error Handling

Test Cases:

Pass Criteria:

• [ ] Appropriate error messages returned
• [ ] No resource created on validation failure
• [ ] Error codes match API documentation

---

TC-008: Update Function

Test Steps:

# Update memory size
hcloud FunctionGraph function update \
  --func_urn=FUNCTION_URN \
  --memory_size=512

# Verify update
hcloud FunctionGraph function show \
  --func_urn=FUNCTION_URN \
  --cli-query="memory_size"

Expected Results:

• Configuration is updated
• New configuration is active

Pass Criteria:

• [ ] Memory size updated to 512
• [ ] Other configurations unchanged
• [ ] Status remains ACTIVE

Success Standards

Functional Requirements

Performance Requirements

Security Requirements

Reliability Requirements

Test Execution Matrix

Environment Coverage

Test Suite Execution

#!/bin/bash
# run_acceptance_tests.sh

echo "=== FunctionGraph Acceptance Test Suite ==="

# Test execution tracking
TOTAL=0
PASSED=0
FAILED=0

run_test() {
  local test_id=$1
  local test_name=$2
  TOTAL=$((TOTAL + 1))
  
  echo ""
  echo "Running $test_id: $test_name"
  
  if execute_test $test_id; then
    PASSED=$((PASSED + 1))
    echo "✓ PASSED"
  else
    FAILED=$((FAILED + 1))
    echo "✗ FAILED"
  fi
}

# Execute test cases
run_test "TC-001" "Basic Function Creation"
run_test "TC-002" "Function with VPC Configuration"
run_test "TC-003" "Function with Environment Variables"
run_test "TC-004" "Function with Layers"
run_test "TC-005" "Function Invocation"
run_test "TC-006" "Trigger Creation"
run_test "TC-007" "Error Handling"
run_test "TC-008" "Update Function"

# Summary
echo ""
echo "=== Test Summary ==="
echo "Total:  $TOTAL"
echo "Passed: $PASSED"
echo "Failed: $FAILED"
echo "Pass Rate: $(awk "BEGIN {printf \"%.1f\", ($PASSED/$TOTAL)*100}")%"

# Exit code
if [ $FAILED -gt 0 ]; then
  exit 1
fi

Acceptance Sign-off

Approval Criteria

Sign-off Checklist

• [ ] All critical test cases passed
• [ ] All high-priority test cases passed
• [ ] Performance requirements met
• [ ] Security requirements verified
• [ ] Documentation complete
• [ ] No critical defects remaining
• [ ] Test coverage ≥ 80%
• [ ] Success rate ≥ 95%

Defect Classification

Reporting

Test Report Template

Test Execution Report
=====================
Date: YYYY-MM-DD
Environment: Production/Staging
Region: cn-north-4

Summary:
- Total Tests: XX
- Passed: XX
- Failed: XX
- Skipped: XX

Details:
[Detailed results for each test case]

Defects:
[List of identified defects]

Recommendations:
[Go/No-Go recommendation]

Related Documentation

• Test Automation Guide
• Performance Tuning
• Security Best Practices

IAM Policies for FunctionGraph

This document defines the required IAM (Identity and Access Management) policies for creating and managing Huawei Cloud FunctionGraph functions.

Required Permissions

Core Permissions for Function Creation

Additional Permissions for Deployment

Policy Templates

Full Access Policy

{
  "Version": "1.1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "functiongraph:*:*"
      ],
      "Resource": "*"
    }
  ]
}

Function Creation Policy (Minimum Required)

{
  "Version": "1.1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "functiongraph:function:create",
        "functiongraph:function:list",
        "functiongraph:function:get",
        "functiongraph:function:update"
      ],
      "Resource": [
        "urn:fg:*:*:function:*"
      ]
    }
  ]
}

Resource-Specific Policy

{
  "Version": "1.1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "functiongraph:function:create",
        "functiongraph:function:get",
        "functiongraph:function:update",
        "functiongraph:function:invoke"
      ],
      "Resource": [
        "urn:fg:cn-north-4:*:function:my-function-*"
      ],
      "Condition": {
        "StringEquals": {
          "fg:app_id": "app-12345678"
        }
      }
    }
  ]
}

Policy Application Methods

Method 1: Console-Based Configuration

1. Log in to Huawei Cloud Console 2. Navigate to Identity and Access Management > Policies 3. Click Create Custom Policy 4. Select JSON view and paste policy document 5. Click OK to create the policy 6. Attach policy to user or group

Method 2: KooCLI-Based Configuration

# Create custom policy
hcloud IAM policy create \
  --cli-region=cn-north-4 \
  --body='{
    "policy": {
      "name": "FunctionGraphCreatePolicy",
      "description": "Policy for creating FunctionGraph functions",
      "policy_document": {
        "Version": "1.1",
        "Statement": [
          {
            "Effect": "Allow",
            "Action": [
              "functiongraph:function:create",
              "functiongraph:function:list",
              "functiongraph:function:get"
            ],
            "Resource": "*"
          }
        ]
      }
    }
  }'

# Attach policy to user
hcloud IAM user attach-policy \
  --user_id=USER_ID \
  --policy_id=POLICY_ID

Cross-Service Permissions

FunctionGraph may require permissions for other services:

Cross-Service Policy Example

{
  "Version": "1.1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "functiongraph:function:*",
        "obs:bucket:get",
        "obs:object:get",
        "vpc:vpc:get",
        "vpc:subnet:get"
      ],
      "Resource": "*"
    }
  ]
}

Permission Verification

Verify Current User Permissions

# List attached policies
hcloud IAM user list-policies --user_name=YOUR_USERNAME

# Test FunctionGraph access
hcloud FunctionGraph function list --cli-region=cn-north-4

# Attempt to create test function (dry-run)
hcloud FunctionGraph function create \
  --cli-region=cn-north-4 \
  --func_name=permission-test \
  --package_type=Zip \
  --runtime=Python3.9 \
  --handler=index.handler \
  --memory_size=128 \
  --timeout=10

Permission Scopes

Project-Level Scope

Policies applied at project level only affect resources within that project:

{
  "Version": "1.1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "functiongraph:function:*"
      ],
      "Resource": "*",
      "Scope": {
        "Project": [
          "cn-north-4"
        ]
      }
    }
  ]
}

Domain-Level Scope

Policies applied at domain level affect all projects:

{
  "Version": "1.1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "functiongraph:function:*"
      ],
      "Resource": "*"
    }
  ]
}

Security Best Practices

Troubleshooting Permission Issues

Common Errors

Diagnostic Steps

# Check user information
hcloud IAM user show --user_name=YOUR_USERNAME

# Verify policy attachments
hcloud IAM policy list-attachments --policy_id=POLICY_ID

# Enable debug mode for detailed error
hcloud --debug FunctionGraph function create --func_name=test

Related Documentation

• Huawei Cloud IAM Documentation
• FunctionGraph API Permissions
• Custom Policy Syntax

SDK Installation Guide

This guide provides step-by-step instructions for installing the Huawei Cloud FunctionGraph Python SDK.

Prerequisites

Python Installation

Windows

# Download from python.org
# Or use chocolatey
choco install python

# Verify
python --version
pip --version

Linux

# Ubuntu/Debian
sudo apt update
sudo apt install python3.9 python3-pip

# CentOS/RHEL
sudo yum install python39 python39-pip

# Verify
python3 --version
pip3 --version

macOS

# Using Homebrew
brew install python@3.9

# Verify
python3 --version
pip3 --version

SDK Installation

# Install FunctionGraph SDK
pip install huaweicloudsdkfunctiongraph

# Verify installation
python -c "from huaweicloudsdkfunctiongraph.v2.functiongraph_client import FunctionGraphClient; print('SDK installed successfully')"

Authentication Configuration

Environment Variables (Recommended)

# Linux/macOS
export HUAWEI_AK="your-access-key"
export HUAWEI_SK="your-secret-key"
export HUAWEI_REGION="cn-north-4"
export HUAWEI_PROJECT_ID="your-project-id"

# Windows (Command Prompt)
set HUAWEI_AK=your-access-key
set HUAWEI_SK=your-secret-key
set HUAWEI_REGION=cn-north-4
set HUAWEI_PROJECT_ID=your-project-id

# Windows (PowerShell)
$env:HUAWEI_AK="your-access-key"
$env:HUAWEI_SK="your-secret-key"
$env:HUAWEI_REGION="cn-north-4"
$env:HUAWEI_PROJECT_ID="your-project-id"

Security Best Practices

• 🚫 NEVER commit AK/SK to version control
• 🚫 NEVER hardcode credentials in source code
• ✅ ALWAYS use environment variables or configuration files
• ✅ Recommend using IAM user with minimal permissions
• ✅ Enable MFA for production accounts

Common Regions

Verification Script

#!/usr/bin/env python3
import os
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkfunctiongraph.v2.functiongraph_client import FunctionGraphClient
from huaweicloudsdkfunctiongraph.v2.region.functiongraph_region import FunctionGraphRegion

# Get credentials from environment
ak = os.environ.get('HUAWEI_AK')
sk = os.environ.get('HUAWEI_SK')
region = os.environ.get('HUAWEI_REGION', 'cn-north-4')
project_id = os.environ.get('HUAWEI_PROJECT_ID')

if not all([ak, sk, project_id]):
    print("❌ Missing credentials. Please set HUAWEI_AK, HUAWEI_SK, and HUAWEI_PROJECT_ID")
    exit(1)

# Create credentials
credentials = BasicCredentials(ak, sk, project_id)

# Create client
client = FunctionGraphClient.new_builder() \
    .with_credentials(credentials) \
    .with_region(FunctionGraphRegion.value_of(region)) \
    .build()

print(f"✅ SDK configured successfully for region: {region}")

Troubleshooting

ImportError

# If import fails, reinstall SDK
pip uninstall huaweicloudsdkfunctiongraph
pip install huaweicloudsdkfunctiongraph

# Or upgrade pip first
pip install --upgrade pip
pip install huaweicloudsdkfunctiongraph

Authentication Error

• Verify AK/SK are correct
• Check if IAM user has required permissions
• Confirm project_id matches the region

Network Error

• Check internet connectivity
• Verify firewall allows HTTPS (443) to Huawei Cloud endpoints
• Try using a different region

Additional Resources

• Huawei Cloud FunctionGraph Documentation
• Python SDK Reference

Verification Methods

This document provides comprehensive verification methods for FunctionGraph function creation, status checking, and functional testing.

Function Creation Verification

Step 1: Verify Function Existence

# List all functions
hcloud FunctionGraph function list \
  --cli-region=cn-north-4 \
  --cli-query="functions[?func_name=='YOUR_FUNCTION_NAME']"

# Get specific function details
hcloud FunctionGraph function show \
  --func_urn=urn:fg:cn-north-4:PROJECT_ID:function:FUNCTION_NAME:latest

Expected Output

{
  "func_urn": "urn:fg:cn-north-4:project-123:function:my-function:latest",
  "func_name": "my-function",
  "runtime": "Python3.9",
  "handler": "index.handler",
  "memory_size": 256,
  "timeout": 30,
  "code_type": "Zip",
  "code_url": "https://obs.bucket/code.zip",
  "status": "ACTIVE"
}

Step 2: Verify Function Configuration

Status Checking

Function Status Values

Status Check Commands

# Get function status
hcloud FunctionGraph function show \
  --func_urn=FUNCTION_URN \
  --cli-query="status"

# Monitor status with retry
for i in {1..10}; do
  status=$(hcloud FunctionGraph function show --func_urn=FUNCTION_URN --cli-query="status")
  if [ "$status" == '"ACTIVE"' ]; then
    echo "Function is ACTIVE"
    break
  fi
  echo "Status: $status, retrying... ($i/10)"
  sleep 5
done

Version and Alias Status

# List function versions
hcloud FunctionGraph version list \
  --func_urn=FUNCTION_URN

# List function aliases
hcloud FunctionGraph alias list \
  --func_urn=FUNCTION_URN

# Verify alias points to correct version
hcloud FunctionGraph alias show \
  --func_urn=FUNCTION_URN \
  --alias_name=prod

Functional Testing

Test Method 1: Synchronous Invocation

# Invoke function with test event
hcloud FunctionGraph function invoke \
  --func_urn=FUNCTION_URN \
  --body='{
    "test": "data",
    "source": "verification"
  }'

# Invoke with file input
hcloud FunctionGraph function invoke \
  --func_urn=FUNCTION_URN \
  --body=@test-event.json

Test Method 2: Asynchronous Invocation

# Invoke asynchronously
hcloud FunctionGraph function invoke \
  --func_urn=FUNCTION_URN \
  --invocation_type=Async \
  --body='{"async": true}'

# Check invocation result
# Note: Requires OBS or DIS for async result storage

Test Method 3: API Gateway Trigger

# Create test API trigger
hcloud FunctionGraph trigger create \
  --func_urn=FUNCTION_URN \
  --trigger_type=apig \
  --trigger_data='{
    "group_id": "API_GROUP_ID",
    "env_id": "ENV_ID",
    "auth": "NONE"
  }'

# Test via HTTP request
curl -X POST https://API_ENDPOINT/path \
  -H "Content-Type: application/json" \
  -d '{"test": "http"}'

Verification Checklist

Pre-Creation Verification

Post-Creation Verification

Integration Verification

Automated Verification Script

#!/bin/bash
# verify_function.sh - Automated function verification

FUNC_URN=$1
REGION=${2:-"cn-north-4"}

echo "=== Function Verification Script ==="
echo "Function URN: $FUNC_URN"
echo "Region: $REGION"
echo ""

# Check 1: Function exists
echo "[1/6] Checking function existence..."
result=$(hcloud FunctionGraph function show --func_urn=$FUNC_URN --cli-region=$REGION 2>&1)
if echo "$result" | grep -q "func_name"; then
  echo "✓ Function exists"
else
  echo "✗ Function not found"
  exit 1
fi

# Check 2: Status is ACTIVE
echo "[2/6] Checking function status..."
status=$(hcloud FunctionGraph function show --func_urn=$FUNC_URN --cli-region=$REGION --cli-query="status")
if [ "$status" == '"ACTIVE"' ]; then
  echo "✓ Function is ACTIVE"
else
  echo "✗ Function status: $status"
  exit 1
fi

# Check 3: Runtime verification
echo "[3/6] Verifying runtime..."
runtime=$(hcloud FunctionGraph function show --func_urn=$FUNC_URN --cli-region=$REGION --cli-query="runtime")
echo "✓ Runtime: $runtime"

# Check 4: Memory and timeout
echo "[4/6] Verifying configuration..."
memory=$(hcloud FunctionGraph function show --func_urn=$FUNC_URN --cli-region=$REGION --cli-query="memory_size")
timeout=$(hcloud FunctionGraph function show --func_urn=$FUNC_URN --cli-region=$REGION --cli-query="timeout")
echo "✓ Memory: $memory MB, Timeout: $timeout seconds"

# Check 5: Test invocation
echo "[5/6] Testing function invocation..."
invocation=$(hcloud FunctionGraph function invoke --func_urn=$FUNC_URN --body='{"verification": true}' 2>&1)
if echo "$invocation" | grep -q "error"; then
  echo "✗ Invocation failed: $invocation"
else
  echo "✓ Invocation successful"
fi

# Check 6: Version info
echo "[6/6] Checking version information..."
version=$(hcloud FunctionGraph function show --func_urn=$FUNC_URN --cli-region=$REGION --cli-query="version")
echo "✓ Version: $version"

echo ""
echo "=== Verification Complete ==="

Performance Verification

Cold Start Performance

# Measure cold start time
start_time=$(date +%s%N)
hcloud FunctionGraph function invoke --func_urn=FUNCTION_URN --body='{"test": "cold"}'
end_time=$(date +%s%N)
cold_start_ms=$(( (end_time - start_time) / 1000000 ))
echo "Cold start time: ${cold_start_ms}ms"

Warm Invocation Performance

# Measure warm invocation time (after initial invocation)
for i in {1..10}; do
  start=$(date +%s%N)
  hcloud FunctionGraph function invoke --func_urn=FUNCTION_URN --body='{"test": "warm"}' > /dev/null
  end=$(date +%s%N)
  echo "Invocation $i: $(( (end - start) / 1000000 ))ms"
done

Performance Benchmarks

Logging and Debugging

View Function Logs

# Query recent function logs via LTS
hcloud LTS logs query \
  --log_group_id=LOG_GROUP_ID \
  --log_stream_id=LOG_STREAM_ID \
  --start_time="2024-01-01 00:00:00" \
  --end_time="2024-01-01 23:59:59"

Enable Debug Logging

# Invoke with environment variable for debug
hcloud FunctionGraph function update \
  --func_urn=FUNCTION_URN \
  --environment_variables='{"DEBUG": "true", "LOG_LEVEL": "debug"}'

Related Documentation

• FunctionGraph API Reference
• Function Testing Guide
• Performance Optimization