Huawei Cloud Functiongraph Trigger Create

Overview

This skill enables the creation and configuration of scheduled triggers (TIMER type) for Huawei Cloud FunctionGraph functions. It supports Quartz Cron expression format for flexible scheduling configurations.

The trigger allows automatic execution of serverless functions at specified time intervals, making it ideal for:

• Periodic data processing tasks
• Scheduled backup operations
• Regular monitoring and health checks
• Time-based notification systems

Prerequisites

Before using this skill, ensure the following requirements are met:

1. Python Environment: Python 3.9+ installed 2. SDK Installation: Install FunctionGraph SDK: pip install huaweicloudsdkfunctiongraph 3. Environment Variables: Configure the following environment variables:

• HUAWEI_AK: Huawei Cloud Access Key
• HUAWEI_SK: Huawei Cloud Secret Key
• HUAWEI_REGION: Target region (e.g., cn-north-4)
• HUAWEI_PROJECT_ID: Project ID

4. FunctionGraph Function: Target function must already exist in the specified region 5. Network Access: Stable network connection to Huawei Cloud API endpoints

Usage

Basic Command Structure

cd scripts
python create_trigger.py \
    --function-urn "urn:fss:cn-north-4:project_id:function:default:my-function:latest" \
    --name "daily-trigger" \
    --schedule "0 0 2 * * ?" \
    --schedule-type "Cron" \
    --status "ACTIVE"

Examples

Cron Expression Trigger

cd scripts
python create_trigger.py \
    --function-urn "urn:fss:cn-north-4:project_id:function:default:my-function:latest" \
    --name "daily-trigger" \
    --schedule "0 0 8 * * ?" \
    --schedule-type "Cron"

Fixed Rate Trigger

cd scripts
python create_trigger.py \
    --function-urn "urn:fss:cn-north-4:project_id:function:default:my-function:latest" \
    --name "every-5min" \
    --schedule "5m" \
    --schedule-type "Rate"

Cron Expression Format

FunctionGraph uses Quartz Cron format with 6 or 7 fields:

┌───────────── second (0-59)
│ ┌───────────── minute (0-59)
│ │ ┌───────────── hour (0-23)
│ │ │ ┌───────────── day of month (1-31)
│ │ │ │ ┌───────────── month (1-12)
│ │ │ │ │ ┌───────────── day of week (1-7, 1=Sunday)
│ │ │ │ │ │
* * * * * ?

For detailed Cron expression reference including special characters and common examples, see Cron Expression Reference.

Parameters Confirmation

Before creating the trigger, confirm the following parameters:

Confirmation Checklist

• [ ] Function URN is correct and function exists
• [ ] Cron expression has been validated
• [ ] Trigger name follows naming conventions
• [ ] IAM permissions are sufficient
• [ ] Region matches the function location

Output Format

Success Response

{
    "status": "success",
    "trigger_id": "timer-xxx-xxx-xxx",
    "trigger_name": "daily-trigger",
    "trigger_type": "TIMER",
    "schedule": "0 0 2 * * ?",
    "enable_status": "ACTIVE",
    "message": "Trigger created successfully"
}

Error Response

{
    "status": "failed",
    "error_code": "TriggerAlreadyExists",
    "message": "Trigger with the same name already exists"
}

For complete error codes and troubleshooting information, see Cron Expression Reference.

Verification Method

After creating the trigger, verify the configuration:

1. List Function Triggers

Navigate to FunctionGraph console → Function details → Triggers tab to view all triggers

2. Check Trigger Details

Navigate to FunctionGraph console → Function details → Triggers → View trigger details

3. Monitor Trigger Execution

Navigate to FunctionGraph console → Function details → Triggers → View execution history

Expected indicators:

• Trigger status: Active
• Next execution time: Correctly calculated
• Execution history: No failed invocations

Best Practices

Cron Expression Best Practices

1. Avoid frequent executions: Use intervals ≥ 5 minutes unless necessary 2. Consider timezone: FunctionGraph uses UTC by default 3. Use `?` for unused day field: Either day-of-month or day-of-week should use ? 4. Validate before creation: Test expressions using online Cron validators

Naming Conventions

• Use descriptive names: daily-data-sync, hourly-health-check
• Follow pattern: [frequency]-[purpose]
• Maximum 64 characters
• Use lowercase with hyphens

Security Considerations

1. Least privilege: Grant minimal IAM permissions 2. Enable encryption: Use KMS for sensitive function inputs 3. Monitor executions: Set up Cloud Eye alarms for failures 4. Rate limiting: Configure appropriate retry parameters

Operational Recommendations

1. Start with disabled status for testing 2. Document trigger purpose in description field 3. Set appropriate retries for transient failures 4. Monitor first executions after enabling

Reference Documents

For detailed information, refer to:

• SDK Installation Guide
• IAM Policies
• Verification Method
• Acceptance Criteria
• Cron Expression Reference

Important Notes

Compatibility Notes

This skill is designed to work with Huawei Cloud FunctionGraph API. The tags field helps with skill discovery and categorization, while the version field follows semantic versioning for skill updates.

Limitations

1. Maximum triggers: Each function supports up to 10 triggers by default 2. Cron precision: Second-level scheduling may have minor delays 3. Timeout handling: Function timeout should be less than trigger interval 4. Cold start: First executions may have additional latency

Cost Implications

• No additional cost for trigger configuration
• Function execution billed per invocation
• Consider execution frequency for cost optimization

Common Pitfalls

1. Wrong timezone: Remember FunctionGraph uses UTC 2. Overlapping schedules: Multiple triggers may cause concurrent executions 3. Long-running functions: Ensure function completes before next trigger 4. Cron syntax errors: Validate expression format before deployment

For troubleshooting and error codes, refer to Cron Expression Reference.

---

Related Skills:

• huawei-cloud-functiongraph-function-create
• huawei-cloud-functiongraph-deploy

Acceptance Criteria

Overview

This document defines the acceptance criteria for FunctionGraph scheduled trigger configuration. All criteria must be met for successful deployment.

Functional Requirements

FR-01: Trigger Creation

Criterion: Trigger must be successfully created with correct type

Validation:

• [ ] API returns success status (HTTP 201)
• [ ] Response contains valid trigger_id
• [ ] trigger_type equals TIMER
• [ ] Trigger appears in function trigger list

Test Command:

hcloud functiongraph v2 list-function-triggers \
    --function-urn "urn:fss:..." | grep -A 5 "TIMER"

FR-02: Cron Expression Configuration

Criterion: Cron expression must be correctly stored and parsed

Validation:

• [ ] trigger_config.schedule matches input expression
• [ ] Expression is valid Quartz Cron format
• [ ] All 6-7 fields are present
• [ ] Next execution time is calculable

Test Cases:

FR-03: Trigger Activation

Criterion: Trigger activation status must match configuration

Validation:

• [ ] enable_status equals input value
• [ ] Active triggers execute per schedule
• [ ] Disabled triggers do not execute

Test Steps:

1. Create trigger with status=active 2. Verify enable_status is active 3. Wait for one scheduled execution 4. Confirm execution in history

FR-04: Function Association

Criterion: Trigger must be correctly associated with target function

Validation:

• [ ] Trigger is linked to correct function URN
• [ ] Function exists and is accessible
• [ ] Trigger appears in function's trigger list

FR-05: Naming Conventions

Criterion: Trigger name must follow naming standards

Validation:

• [ ] Name length: 1-64 characters
• [ ] Name is unique within function
• [ ] Name follows pattern: [frequency]-[purpose]

Valid Examples:

• daily-backup
• hourly-health-check
• weekly-report-generation

Invalid Examples:

• `` (empty)
• a * 65 (65 characters)
• Daily Backup (contains spaces, though allowed)

Non-Functional Requirements

NFR-01: Response Time

Criterion: Trigger creation must complete within acceptable time

Threshold: < 5 seconds for API response

Measurement:

time hcloud functiongraph v2 create-function-trigger ...

NFR-02: Error Handling

Criterion: All errors must return meaningful messages

Validation:

• [ ] Invalid Cron returns InvalidParameter with details
• [ ] Missing function returns FunctionNotFound
• [ ] Duplicate name returns TriggerAlreadyExists
• [ ] Permission denied returns AccessDenied

NFR-03: Idempotency

Criterion: Re-running with same parameters should not cause errors

Validation:

• [ ] Duplicate creation returns TriggerAlreadyExists
• [ ] Existing trigger is not modified
• [ ] No duplicate triggers created

NFR-04: Security

Criterion: Operations must enforce IAM permissions

Validation:

• [ ] Operations fail without required permissions
• [ ] Audit logs capture trigger operations
• [ ] No credential exposure in logs

Integration Requirements

IR-01: Cloud Eye Integration

Criterion: Function must have monitoring capability

Validation:

• [ ] Executions appear in Cloud Eye metrics
• [ ] Alarm rules can be configured
• [ ] Error notifications are sent

IR-02: LTS Integration

Criterion: Function logs must be accessible

Validation:

• [ ] Execution logs appear in LTS
• [ ] Log stream exists for function
• [ ] Logs are queryable

IR-03: Event Flow

Criterion: Trigger-to-function event flow must work

Validation:

• [ ] Trigger event reaches function
• [ ] Event payload contains trigger metadata
• [ ] Function receives correct event structure

Operational Requirements

OR-01: Documentation

Criterion: Trigger must have adequate documentation

Validation:

• [ ] Description field is populated
• [ ] Purpose is clearly stated
• [ ] Cron expression is documented

OR-02: Monitoring

Criterion: Trigger execution must be monitorable

Validation:

• [ ] Execution history is available
• [ ] Success/failure metrics exist
• [ ] Alerting is configured

OR-03: Backup/Recovery

Criterion: Trigger configuration must be recoverable

Validation:

• [ ] Trigger details are retrievable via API
• [ ] Configuration can be exported
• [ ] Recreation from backup works

Acceptance Test Procedure

Pre-Test Setup

# Set environment variables
export HUAWEI_AK="your-ak"
export HUAWEI_SK="your-sk"
export HUAWEI_REGION="cn-north-4"
export HUAWEI_PROJECT_ID="your-project-id"

# Verify CLI is working
hcloud functiongraph v2 list-functions --limit 1

Test Suite

#!/usr/bin/env python3
"""Acceptance test suite for FunctionGraph trigger creation"""

import unittest
import json

class TestTriggerAcceptance(unittest.TestCase):
    
    def setUp(self):
        # Initialize test client
        pass
    
    def test_fr01_trigger_creation(self):
        """FR-01: Trigger must be created successfully"""
        # Create trigger
        # Verify trigger_id is returned
        # Verify trigger_type is TIMER
        pass
    
    def test_fr02_cron_configuration(self):
        """FR-02: Cron expression must be valid"""
        # Test valid expressions
        # Test invalid expressions
        pass
    
    def test_fr03_trigger_activation(self):
        """FR-03: Trigger status must match configuration"""
        # Create with active status
        # Verify status
        pass
    
    def test_fr04_function_association(self):
        """FR-04: Trigger must be linked to function"""
        # Verify function URN
        # Check trigger list
        pass
    
    def test_fr05_naming_conventions(self):
        """FR-05: Name must follow conventions"""
        # Test valid names
        # Test invalid names
        pass
    
    def test_nfr01_response_time(self):
        """NFR-01: Response must be timely"""
        # Measure response time
        # Assert < 5 seconds
        pass
    
    def test_nfr02_error_handling(self):
        """NFR-02: Errors must be meaningful"""
        # Test various error conditions
        # Verify error messages
        pass

if __name__ == '__main__':
    unittest.main()

Post-Test Cleanup

# Remove test triggers
hcloud functiongraph v2 delete-function-trigger \
    --function-urn "..." \
    --trigger-id "test-trigger-id"

# Verify removal
hcloud functiongraph v2 list-function-triggers \
    --function-urn "..."

Acceptance Sign-off

Approval Checklist

Final Approval

• Test Date: _______________
• Tester: _______________
• Approver: _______________
• Status: ☐ PASS / ☐ FAIL
• Sign-off Date: _______________

Regression Test Triggers

Perform regression testing when:

1. FunctionGraph API version changes 2. Huawei Cloud SDK updates 3. IAM policy modifications 4. Network configuration changes 5. Function code updates

Related Documentation

• Verification Method
• IAM Policies
• CLI Installation Guide

Cron Expression Reference

Special Characters

Common Examples

Parameter Reference

Common Error Codes

Troubleshooting

Cron Expression Format

FunctionGraph uses Quartz Cron format with 6 or 7 fields:

┌───────────── second (0-59)
│ ┌───────────── minute (0-59)
│ │ ┌───────────── hour (0-23)
│ │ │ ┌───────────── day of month (1-31)
│ │ │ │ ┌───────────── month (1-12)
│ │ │ │ │ ┌───────────── day of week (1-7, 1=Sunday)
│ │ │ │ │ │
* * * * * ?

IAM Policies for FunctionGraph Trigger Management

Overview

This document specifies the minimum IAM (Identity and Access Management) permissions required to create and manage FunctionGraph scheduled triggers.

Required Permissions

Minimum Policy for Trigger Creation

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

Full Trigger Management Policy

For complete trigger lifecycle management, use this policy:

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

Permission Actions Reference

Policy Assignment Methods

Method 1: Through Console

1. Navigate to IAM Console → Policies 2. Click Create Custom Policy 3. Select JSON view 4. Paste the policy JSON 5. Click OK to create 6. Attach policy to user/group/role

Method 2: Using KooCLI

# Create policy
hcloud iam v3 create-custom-policy \
    --body '{
        "policy": {
            "name": "FunctionGraphTriggerManager",
            "description": "Policy for managing FunctionGraph triggers",
            "policy_document": {
                "Version": "1.1",
                "Statement": [
                    {
                        "Effect": "Allow",
                        "Action": ["functiongraph:trigger:create"],
                        "Resource": ["urn:fss:*:*:function:*"]
                    }
                ]
            }
        }
    }'

Method 3: Assign to User

# Attach policy to user
hcloud iam v3 attach-user-policy \
    --user-id "user-xxx" \
    --policy-id "policy-xxx"

Resource Scoping

All Functions in All Regions

"Resource": ["urn:fss:*:*:function:*"]

Specific Region

"Resource": ["urn:fss:cn-north-4:*:function:*"]

Specific Function

"Resource": [
    "urn:fss:cn-north-4:project-id:function:default:my-function:*"
]

Multiple Specific Functions

"Resource": [
    "urn:fss:cn-north-4:project-id:function:default:backup-function:*",
    "urn:fss:cn-north-4:project-id:function:default:cleanup-function:*"
]

Condition Keys

Use conditions to further restrict access:

Time-based Restriction

{
    "Effect": "Allow",
    "Action": ["functiongraph:trigger:create"],
    "Resource": ["*"],
    "Condition": {
        "DateLessThan": {
            "g:CurrentTime": "2024-12-31T23:59:59Z"
        }
    }
}

Source IP Restriction

{
    "Effect": "Allow",
    "Action": ["functiongraph:trigger:create"],
    "Resource": ["*"],
    "Condition": {
        "IpAddress": {
            "g:SourceIp": ["192.168.1.0/24", "10.0.0.0/8"]
        }
    }
}

Role-Based Access Control (RBAC)

Built-in Roles

Custom Role for Automation

For CI/CD pipelines and automation:

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

Verifying Permissions

Check User Permissions

# List user's policies
hcloud iam v3 list-user-permissions --user-id "user-xxx"

# Check specific permission
hcloud functiongraph v2 list-functions --limit 1

Permission Testing Script

import os
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkfunctiongraph.v2 import FunctionGraphClient

def test_permission():
    credentials = BasicCredentials(
        ak=os.environ.get('HUAWEI_AK'),
        sk=os.environ.get('HUAWEI_SK'),
        project_id=os.environ.get('HUAWEI_PROJECT_ID')
    )
    
    client = FunctionGraphClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(FunctionGraphRegion.value_of(os.environ.get('HUAWEI_REGION'))) \
        .build()
    
    try:
        # Test list functions (requires functiongraph:function:list)
        response = client.list_functions(limit=1)
        print("✓ Has function list permission")
        
        # Additional tests can be added here
        
    except Exception as e:
        print(f"✗ Permission denied: {e}")

test_permission()

Permission Troubleshooting

Error: 403 Forbidden

Cause: Missing required IAM permission

Solution:

1. Check if functiongraph:trigger:create is in policy 2. Verify policy is attached to user/role 3. Check resource scope matches target function

Error: Unauthorized

Cause: Invalid or expired credentials

Solution:

1. Verify AK/SK are correct 2. Check if credentials have been rotated 3. Re-configure KooCLI authentication

Security Best Practices

1. Principle of Least Privilege: Grant only required permissions 2. Use Resource Restrictions: Limit to specific functions/regions 3. Add Conditions: Restrict by IP, time, or MFA 4. Separate Environments: Use different policies for dev/prod 5. Regular Audits: Review and remove unused permissions 6. Temporary Credentials: Use STS for short-lived access

Policy Examples by Use Case

Development Environment

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

Production Environment (Restricted)

{
    "Version": "1.1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "functiongraph:function:get",
                "functiongraph:trigger:get",
                "functiongraph:trigger:list"
            ],
            "Resource": ["urn:fss:cn-north-4:*:function:prod-*:*"]
        }
    ]
}

CI/CD Pipeline

{
    "Version": "1.1",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "functiongraph:function:get",
                "functiongraph:trigger:create",
                "functiongraph:trigger:update",
                "functiongraph:trigger:delete"
            ],
            "Resource": ["urn:fss:*:*:function:*"],
            "Condition": {
                "StringEquals": {
                    "g:UserName": "cicd-service-account"
                }
            }
        }
    ]
}

Related Documentation

• IAM Policy Syntax
• FunctionGraph Permissions
• Best Practices

Python SDK Installation Guide

Overview

This guide covers installation and configuration of the Huawei Cloud FunctionGraph Python SDK for creating and managing FunctionGraph triggers.

Prerequisites

• Python 3.9 or higher
• pip package manager
• Huawei Cloud account with Access Key (AK) and Secret Key (SK)

Installation

1. Install FunctionGraph SDK

# Install FunctionGraph SDK (includes core dependencies)
pip install huaweicloudsdkfunctiongraph

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

2. Install Additional Dependencies (Optional)

# For enhanced functionality
pip install huaweicloudsdkcore

Environment Configuration

Configure authentication using environment variables:

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 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"

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

Verify Configuration

Create a test script to verify your configuration:

import os
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkfunctiongraph.v2 import FunctionGraphClient

# Load credentials from environment
ak = os.environ.get("HUAWEI_AK")
sk = os.environ.get("HUAWEI_SK")
region = os.environ.get("HUAWEI_REGION")
project_id = os.environ.get("HUAWEI_PROJECT_ID")

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

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

print("Configuration verified successfully!")

Common Regions

Virtual Environment Setup (Recommended)

Create Virtual Environment

# Create virtual environment
python -m venv venv

# Activate virtual environment
# Linux/macOS:
source venv/bin/activate

# Windows:
venv\Scripts\activate

Install SDK in Virtual Environment

pip install huaweicloudsdkfunctiongraph

Troubleshooting

Issue 1: Module Not Found

# Ensure SDK is installed
pip install huaweicloudsdkfunctiongraph

# Verify Python path
python -c "import sys; print(sys.path)"

Issue 2: Authentication Failed

# Verify environment variables are set
# Linux/macOS:
echo $HUAWEI_AK
echo $HUAWEI_SK

# Windows PowerShell:
$env:HUAWEI_AK
$env:HUAWEI_SK

Issue 3: SSL Certificate Error

# Disable SSL verification (not recommended for production)
from huaweicloudsdkcore.http.http_config import HttpConfig

config = HttpConfig.get_default_http_config()
config.ignore_ssl_verification = True

client = FunctionGraphClient.new_builder() \
    .with_http_config(config) \
    .with_credentials(credentials) \
    .with_region(region) \
    .build()

Issue 4: Region Not Found

Check that the region code is correct and matches your FunctionGraph function location.

Security Best Practices

1. Never commit credentials to version control 2. Use environment variables for all credential storage 3. Rotate AK/SK regularly 4. Use IAM temporary credentials when possible 5. Restrict IAM permissions to minimum required 6. Use virtual environments to isolate dependencies

SDK Version Management

# Check installed version
pip show huaweicloudsdkfunctiongraph

# Upgrade to latest version
pip install --upgrade huaweicloudsdkfunctiongraph

# List all Huawei Cloud SDKs
pip list | grep huaweicloudsdk

Uninstallation

# Uninstall SDK
pip uninstall huaweicloudsdkfunctiongraph

# Uninstall core SDK
pip uninstall huaweicloudsdkcore

Next Steps

After installation, proceed to:

• IAM Policies Configuration
• Verification Method

Verification Method

Overview

This document provides comprehensive methods to verify that FunctionGraph scheduled triggers have been correctly configured and are functioning as expected.

Verification Steps

Step 1: Confirm Trigger Creation

Using KooCLI

# List all triggers for the function
hcloud functiongraph v2 list-function-triggers \
    --function-urn "urn:fss:cn-north-4:project-id:function:default:my-function:latest"

Expected output structure:

{
    "triggers": [
        {
            "trigger_id": "timer-xxx-xxx-xxx",
            "trigger_type": "TIMER",
            "trigger_name": "daily-trigger",
            "trigger_config": "{\"name\":\"daily-trigger\",\"schedule\":\"0 0 2 * * ?\",\"scheduleType\":\"Rate\"}",
            "enable_status": "active",
            "created_at": "2024-01-15T10:00:00Z",
            "updated_at": "2024-01-15T10:00:00Z"
        }
    ]
}

Using Python SDK

from huaweicloudsdkfunctiongraph.v2 import FunctionGraphClient

def verify_trigger(client, function_urn, trigger_name):
    from huaweicloudsdkfunctiongraph.v2.model.list_function_triggers_request import ListFunctionTriggersRequest
    
    request = ListFunctionTriggersRequest(function_urn=function_urn)
    response = client.list_function_triggers(request)
    
    for trigger in response.triggers:
        if trigger.trigger_name == trigger_name:
            print(f"✓ Trigger found: {trigger.trigger_id}")
            print(f"  Type: {trigger.trigger_type}")
            print(f"  Status: {trigger.enable_status}")
            return trigger
    
    print("✗ Trigger not found")
    return None

Step 2: Validate Trigger Configuration

Check Trigger Properties

# Query specific trigger type
hcloud functiongraph v2 show-function-trigger \
    --function-urn "urn:fss:cn-north-4:project-id:function:default:my-function:latest" \
    --trigger-type-codes "TIMER"

Validation checklist:

Step 3: Validate Cron Expression

Cron Expression Parser

import json
from datetime import datetime

def validate_cron_config(trigger_config):
    config = json.loads(trigger_config)
    cron = config.get('schedule')
    
    print(f"Cron Expression: {cron}")
    
    # Parse and display schedule
    parts = cron.split()
    fields = ['Second', 'Minute', 'Hour', 'Day', 'Month', 'Weekday']
    
    for field, value in zip(fields, parts):
        print(f"  {field}: {value}")
    
    # Additional validation logic here
    return True

Step 4: Test Trigger Execution

Option A: Manual Trigger Invocation

# Invoke function manually to verify execution path
hcloud functiongraph v2 invoke-function \
    --function-urn "urn:fss:cn-north-4:project-id:function:default:my-function:latest" \
    --body '{"test": true}'

Option B: Wait for Scheduled Execution

For triggers with long intervals, temporarily update to a shorter schedule:

# Temporarily set to 1-minute interval for testing
hcloud functiongraph v2 update-function-trigger \
    --function-urn "..." \
    --trigger-id "timer-xxx" \
    --body '{
        "trigger_config": "{\"schedule\":\"0 */1 * * * ?\",\"scheduleType\":\"Rate\"}"
    }'

# Monitor for 1-2 executions
# Then restore original schedule

Step 5: Monitor Execution History

Via Console

1. Navigate to FunctionGraph Console 2. Select Functions → Click function name 3. Go to Triggers tab 4. Click Execution History for the trigger 5. Verify recent executions

Via API

def get_execution_history(client, function_urn, limit=10):
    from huaweicloudsdkfunctiongraph.v2.model.list_function_statistics_request import ListFunctionStatisticsRequest
    
    request = ListFunctionStatisticsRequest(
        function_urn=function_urn,
        period='1h'  # Last hour
    )
    response = client.list_function_statistics(request)
    
    print(f"Executions in last hour: {len(response.statistic)}")
    
    for stat in response.statistic:
        print(f"  Duration: {stat.duration}ms")
        print(f"  Status: {stat.status}")

Step 6: Verify Alarm Configuration

Ensure Cloud Eye alarms are configured:

# Check alarm rules for the function
hcloud ces v2 list-alarms \
    --namespace "SYS.FunctionGraph" \
    --dimensions "name=function_urn,value=urn:fss:..."

Automated Verification Script

#!/usr/bin/env python3
import os
import json
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkfunctiongraph.v2 import FunctionGraphClient, FunctionGraphRegion

class TriggerVerifier:
    def __init__(self, ak, sk, project_id, region):
        credentials = BasicCredentials(ak=ak, sk=sk, project_id=project_id)
        self.client = FunctionGraphClient.new_builder() \
            .with_credentials(credentials) \
            .with_region(FunctionGraphRegion.value_of(region)) \
            .build()
    
    def verify(self, function_urn, trigger_name, expected_cron):
        results = []
        
        # 1. List triggers
        triggers = self._list_triggers(function_urn)
        trigger = next((t for t in triggers if t.trigger_name == trigger_name), None)
        
        if not trigger:
            return {"status": "failed", "error": "Trigger not found"}
        
        # 2. Verify properties
        results.append(("trigger_type", trigger.trigger_type == "TIMER"))
        results.append(("enable_status", trigger.enable_status == "active"))
        
        # 3. Verify cron
        config = json.loads(trigger.trigger_config)
        results.append(("cron_match", config.get("schedule") == expected_cron))
        
        # 4. Summary
        all_passed = all(r[1] for r in results)
        
        return {
            "status": "passed" if all_passed else "failed",
            "trigger_id": trigger.trigger_id,
            "checks": [{"name": n, "passed": p} for n, p in results]
        }
    
    def _list_triggers(self, function_urn):
        from huaweicloudsdkfunctiongraph.v2.model.list_function_triggers_request import ListFunctionTriggersRequest
        request = ListFunctionTriggersRequest(function_urn=function_urn)
        response = self.client.list_function_triggers(request)
        return response.triggers

# Usage
if __name__ == "__main__":
    verifier = TriggerVerifier(
        ak=os.environ.get("HUAWEI_AK"),
        sk=os.environ.get("HUAWEI_SK"),
        project_id=os.environ.get("HUAWEI_PROJECT_ID"),
        region=os.environ.get("HUAWEI_REGION", "cn-north-4")
    )
    
    result = verifier.verify(
        function_urn="urn:fss:cn-north-4:xxx:function:default:my-function:latest",
        trigger_name="daily-trigger",
        expected_cron="0 0 2 * * ?"
    )
    
    print(json.dumps(result, indent=2))

Verification Checklist

Pre-Deployment

• [ ] Cron expression validated
• [ ] Function exists in target region
• [ ] IAM permissions confirmed
• [ ] Network connectivity verified

Post-Deployment

• [ ] Trigger appears in function trigger list
• [ ] Trigger type is TIMER
• [ ] Enable status is correct
• [ ] Cron expression matches specification
• [ ] Trigger ID returned from API

Post-Execution

• [ ] Function execution logs present
• [ ] No execution errors in history
• [ ] Execution duration within limits
• [ ] Memory usage acceptable

Troubleshooting Verification Failures

Trigger Not Found

Symptoms: Trigger not in list output

Checks:

1. Verify function URN is correct 2. Check if creation request succeeded 3. Verify trigger name spelling 4. Check region alignment

Trigger Not Executing

Symptoms: No execution history entries

Checks:

1. Confirm trigger status is active 2. Verify function is deployed (not failed state) 3. Check Cron expression validity 4. Review function timeout settings

Execution Failures

Symptoms: Execution history shows failures

Checks:

1. Review function code logs 2. Verify function has correct runtime 3. Check function timeout settings 4. Validate function input/output

Monitoring Commands

Real-time Monitoring

# Stream function logs
hcloud lts v2 list-logs \
    --log-group-id "functiongraph-logs" \
    --log-stream-id "my-function-logs" \
    --start-time $(date -d '5 minutes ago' +%s)000

Statistics Summary

# Get function statistics
hcloud functiongraph v2 list-function-statistics \
    --function-urn "..." \
    --period "1d"

Related Documentation

• FunctionGraph Console Guide
• Trigger Management
• Execution Monitoring