@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/ai-dlc-skill/providers/aliyun/services/overview.md

@@ -0,0 +1,163 @@
+# Aliyun Platform Overview
+
+## What is Alibaba Cloud (Aliyun)
+
+Aliyun is Alibaba Cloud's comprehensive cloud computing platform offering 200+ cloud products and services globally. For serverless development, the key services are Function Compute, Serverless App Engine, OSS, RDS, and CDN.
+
+## Core Services
+
+| Service | Type | Description | Limits |
+|---------|------|-------------|--------|
+| Function Compute (FC) | FaaS | Event-driven serverless functions | 600s timeout, 3GB memory |
+| Serverless App Engine (SAE) | CaaS | Container-based hosting | 86400s timeout, 32GB memory |
+| RDS MySQL | RDBMS | Relational database | 200GB storage, 32GB memory |
+| RDS PostgreSQL | RDBMS | Relational database | 200GB storage, 32GB memory |
+| TableStore | NoSQL | Wide-column NoSQL | Unlimited, petabyte scale |
+| OSS | Object Storage | File storage | Unlimited, 48TB per object |
+| CDN | CDN | Global content delivery | 200+ edge nodes |
+
+## Agent Decision Guide
+
+### When to Use Each Service
+
+```
+Need to run code in response to events?
+├── Yes → Function Compute (FC)
+└── No → Continue
+
+Need long-running process or persistent state?
+├── Yes → Serverless App Engine (SAE)
+└── No → Continue
+
+Need to store structured data?
+├── SQL queries, relations → RDS MySQL/PostgreSQL
+├── Massive scale, wide columns → TableStore
+└── JSON-like documents → TableStore (OTS)
+
+Need to store files?
+└── OSS (Object Storage Service)
+
+Need to host a website?
+└── OSS + CDN (static website hosting)
+```
+
+### Service Comparison
+
+| Criteria | Function Compute | Serverless App Engine |
+|----------|------------------|----------------------|
+| Billing | Per invocation + traffic | Per resource usage |
+| Cold start | 500ms-2s | 3-10s (if not warm) |
+| Max timeout | 600s | 86400s |
+| Memory | 128-3GB | Up to 32GB |
+| Stateless | Yes (encouraged) | Yes (persistence optional) |
+| WebSocket | Yes | Full support |
+| Persistent connection | No | Yes |
+| Custom runtime | Yes (custom container) | Yes |
+
+### Database Selection
+
+| Criteria | RDS (MySQL/PG) | TableStore |
+|----------|---------------|------------|
+| Schema | Fixed schema | Schema-less (wide columns) |
+| Query language | SQL | SQL-like (Select/Filter) |
+| Transactions | Full ACID | Limited |
+| Joins | Yes | No (denormalize) |
+| Scaling | Vertical + Read replicas | Horizontal auto-split |
+| Use when | Traditional RDBMS needs | Massive data, time-series |
+
+## Environment Architecture
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│                    Aliyun Account                             │
+├──────────────────────────────────────────────────────────────┤
+│  ┌────────────────────────────────────────────────────────┐  │
+│  │                   Region: cn-shanghai                   │  │
+│  ├────────────────────────────────────────────────────────┤  │
+│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │  │
+│  │  │    FC       │  │    SAE      │  │    RDS      │    │  │
+│  │  │  Services   │  │  Instances  │  │  Instances  │    │  │
+│  │  └─────────────┘  └─────────────┘  └─────────────┘    │  │
+│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │  │
+│  │  │    OSS      │  │ TableStore  │  │    CDN      │    │  │
+│  │  │  Buckets    │  │  Instances  │  │  Domains    │    │  │
+│  │  └─────────────┘  └─────────────┘  └─────────────┘    │  │
+│  └────────────────────────────────────────────────────────┘  │
+└──────────────────────────────────────────────────────────────┘
+```
+
+## Region Selection
+
+| Region ID | Region Name | Use Case |
+|-----------|-------------|----------|
+| `cn-shanghai` | Shanghai | China mainland (default) |
+| `cn-beijing` | Beijing | China mainland alternative |
+| `cn-hangzhou` | Hangzhou | China mainland alternative |
+| `ap-southeast-1` | Singapore | Southeast Asia, global access |
+
+## Pricing Model
+
+| Service | Billing | Notes |
+|---------|---------|-------|
+| Function Compute | Per invocation + CPU-time | Free tier: 1M invocations/month |
+| SAE | Per CPU-second + memory | Pay-as-you-go |
+| RDS | Per hour + storage | Backup storage extra |
+| TableStore | Per request + storage | Reserved capacity cheaper |
+| OSS | Per GB stored + traffic | First 50GB free |
+| CDN | Per GB transferred | Traffic volume discount |
+
+## Agent Interaction Patterns
+
+### Pattern 1: Event-Driven Function
+```javascript
+// FC function triggered by HTTP or event
+module.exports.handler = async (event, context) => {
+  // event contains request data
+  // context contains FC info
+  return { message: "Hello" };
+};
+```
+
+### Pattern 2: API Gateway + Function
+```javascript
+// Deployed as HTTP function
+// Accessible at: https://{service}.{region}.fc.devs.com/{path}
+```
+
+### Pattern 3: Full-Stack with OSS+CDN
+```
+Browser → CDN (cached) → OSS (origin)
+                      ↓
+              Function Compute (API)
+                      ↓
+                    RDS/OTS
+```
+
+## Common Architectures
+
+### Architecture 1: Serverless Web App
+```
+Browser → CDN → OSS (static) → Function Compute (API) → RDS
+                                                        ↓
+                                                    OSS (files)
+```
+
+### Architecture 2: Event-Driven Processing
+```
+OSS Upload → Event Trigger → Function Compute → TableStore
+                                    ↓
+                              OSS (processed files)
+```
+
+### Architecture 3: Containerized Microservices
+```
+Internet → SAE (Load Balancer) → Container Apps → RDS + OSS
+```
+
+## Next Steps
+
+- For function development → `services/function-compute.md`
+- For container workloads → `services/serverless-app-engine.md`
+- For data storage → `services/database.md`
+- For file storage → `services/storage.md`
+- For static hosting → `services/cdn-hosting.md`

package/ai-dlc-skill/providers/aliyun/services/serverless-app-engine.md

@@ -0,0 +1,266 @@
+# Serverless App Engine (SAE)
+
+## When to Use SAE
+
+**Use SAE when:**
+- Long-running processes (> 600s timeout)
+- Need persistent state or connections
+- Require large memory (> 3GB)
+- Custom runtime or framework not supported by FC
+- Container-based microservices architecture
+- WebSocket connections that persist
+- Java Spring Boot / PHP / Python applications
+
+**Do NOT use SAE when:**
+- Short, stateless functions → Use Function Compute (cheaper)
+- Event-driven, bursty workloads → Use Function Compute
+- Simple HTTP endpoints → Use Function Compute (cheaper)
+
+## Agent Decision Guide
+
+```
+Need compute?
+├── Short tasks (<600s), stateless → Function Compute
+├── Long-running (>600s) → SAE
+├── Custom container image → SAE or FC (custom runtime)
+├── JVM-based app (Spring Boot) → SAE
+└── WebSocket server → SAE
+```
+
+## SAE vs Function Compute
+
+| Criteria | Function Compute | SAE |
+|----------|------------------|-----|
+| Max timeout | 600s | 86400s |
+| Max memory | 3GB | 32GB |
+| Cold start | 500ms-2s | 3-10s |
+| Pricing | Per invocation | Per CPU-second + memory |
+| Container | Custom runtime | Full Docker support |
+| SSH/Debug | No | Yes (via logs) |
+| Persistent disk | No | Yes (NAS) |
+| WebSocket | Yes | Yes |
+| JVM support | Limited | Full |
+| PHP/Python/Go | Supported | Full support |
+
+## Application Deployment
+
+### Java/Spring Boot
+
+```dockerfile
+FROM openjdk:8-jdk-alpine
+VOLUME /tmp
+ARG JAR_FILE
+COPY ${JAR_FILE} app.jar
+ENTRYPOINT ["java","-jar","/app.jar"]
+```
+
+### PHP
+
+```dockerfile
+FROM php:7.4-apache
+COPY . /var/www/html/
+```
+
+### Python
+
+```dockerfile
+FROM python:3.9-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+COPY . .
+CMD ["gunicorn", "app:app"]
+```
+
+## Deployment
+
+### Using serverless devs
+
+```yaml
+edition: 1.0.0
+services:
+  my-app:
+    component: sae
+    props:
+      region: cn-shanghai
+      app:
+        appName: my-sae-app
+        namespaceId: cn-shanghai
+        packageType: image
+        imageUrl: registry.cn-shanghai.aliyuncs.com/ns/image:latest
+        instances: 1-10  # auto-scaling
+        cpu: 1
+        memory: 2
+        envVars:
+          NODE_ENV: production
+```
+
+```bash
+s deploy
+```
+
+### Using Console
+
+1. Create application in SAE console
+2. Upload container image or code package
+3. Configure scaling rules
+4. Deploy
+
+## CLI Reference
+
+| Command | Description |
+|---------|-------------|
+| `s cli sae deploy --app-name my-app` | Deploy application |
+| `s cli sae list-apps` | List applications |
+| `s cli sae update --instances 3` | Scale application |
+| `s cli sae logs --app-name my-app` | View logs |
+
+## Scaling Configuration
+
+### Auto-scaling
+
+```yaml
+app:
+  scaling:
+    minInstances: 1
+    maxInstances: 10
+    cpuThreshold: 70  # scale up when CPU > 70%
+    memoryThreshold: 70
+```
+
+### Manual Scaling
+
+```bash
+s cli sae update --app-name my-app --instances 5
+```
+
+## Access Patterns
+
+### HTTP Endpoint
+
+```bash
+# Get application URL
+curl https://my-sae-app.cn-shanghai.p.sae.dev/health
+```
+
+### WebSocket
+
+```javascript
+const ws = new WebSocket('wss://my-sae-app.cn-shanghai.p.sae.dev/ws');
+```
+
+### Internal Communication
+
+Applications in same VPC can communicate internally:
+
+```javascript
+// From FC function to SAE application
+const response = await fetch('http://my-sae-app:8080/api/internal', {
+  method: 'POST',
+  headers: {
+    'X-Internal-Token': process.env.INTERNAL_TOKEN
+  },
+  body: JSON.stringify({ data })
+});
+```
+
+## Persistent Storage (NAS)
+
+SAE supports NAS for persistent storage:
+
+```yaml
+app:
+  nasConfig:
+    mountDir: /app/data
+    accessMode: ReadWriteMany
+```
+
+```javascript
+// Write to persistent storage
+const fs = require('fs');
+const data = fs.readFileSync('/app/data/cache.json', 'utf8');
+```
+
+## Limits and Quotas
+
+| Limit | Value |
+|-------|-------|
+| Max timeout | 86400s |
+| Max CPU | 16 cores |
+| Max memory | 32GB |
+| Max instances | 100 |
+| Min instances | 0 (scale to zero) |
+| Max concurrent requests | 10000 per instance |
+| Max container size | 4GB |
+
+## Best Practices
+
+1. **Graceful shutdown** - Handle SIGTERM for clean shutdown
+2. **Health checks** - Implement `/health` endpoint
+3. **Logging** - Use structured JSON logging
+4. **Environment variables** - Don't hardcode secrets
+5. **Connection pooling** - Reuse DB connections
+6. **Startup time** - Keep container startup under 60s
+7. **Stateless design** - Use external storage for state
+
+### Graceful Shutdown Example
+
+```javascript
+const http = require('http');
+let isShuttingDown = false;
+
+const server = http.createServer((req, res) => {
+  if (isShuttingDown) {
+    res.statusCode = 503;
+    res.end('Service is restarting');
+    return;
+  }
+  // Handle request
+});
+
+process.on('SIGTERM', () => {
+  console.log('SIGTERM received, starting graceful shutdown');
+  isShuttingDown = true;
+  server.close(() => {
+    console.log('Server closed');
+    process.exit(0);
+  });
+});
+```
+
+## Cost Optimization
+
+### Scale to Zero
+
+For services not always needed:
+
+```bash
+s cli sae update --app-name my-app --min-instances 0
+```
+
+### Right-size Resources
+
+- Monitor actual CPU/memory usage
+- Don't over-provision for peak
+- Use auto-scaling to handle spikes
+
+### Cost Comparison
+
+| Service | Use Case | Approximate Cost |
+|---------|----------|------------------|
+| Function Compute | 100k invocations, 128MB, 100ms | ~$0.02/day |
+| SAE | 1 core, 1GB, 24h | ~$0.50/day |
+
+SAE is more predictable but can be more expensive for sporadic workloads.
+
+## Troubleshooting
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Container fails to start | Image error, port issue | Check logs in SAE console |
+| 503 errors | Container overloaded | Scale up instances |
+| Slow response | Cold start, resource limits | Increase memory, enable min instances |
+| Out of memory | Memory limit exceeded | Increase memory allocation |
+| Deployment failed | Build or image issue | Check build logs |
+
+For detailed troubleshooting → `../best-practices/troubleshooting.md`

package/ai-dlc-skill/providers/aliyun/services/storage.md

@@ -0,0 +1,269 @@
+# OSS (Object Storage Service)
+
+## When to Use OSS
+
+**Use OSS when:**
+- Store files (images, videos, documents)
+- Host static assets for CDN delivery
+- Store user-generated content
+- Backup and archive data
+- Store function deployment packages
+- Store function compute code packages
+
+**Do NOT use OSS when:**
+- Need database-like queries → Use TableStore or RDS
+- Need to store < 1KB metadata → Use TableStore field
+- Hot data requiring instant retrieval → Consider Redis
+
+## Agent Decision Guide
+
+```
+Need to store files?
+├── User uploads (images, videos) → OSS
+├── Function code packages → OSS (automatic with FC)
+├── Static website assets → OSS + CDN
+└── Temporary files during processing → OSS with lifecycle policy
+```
+
+## Storage Structure
+
+```
+Bucket: my-bucket-{region}
+├── /uploads/           # User uploaded files
+├── /avatars/           # User profile images
+├── /documents/         # Document storage
+└── /backups/           # Database backups
+```
+
+## File Operations
+
+### Upload File
+
+```bash
+ossutil cp ./file.txt oss://my-bucket/uploads/file.txt
+```
+
+### Download File
+
+```bash
+ossutil cp oss://my-bucket/uploads/file.txt ./download.txt
+```
+
+### List Files
+
+```bash
+ossutil ls oss://my-bucket/uploads/
+```
+
+### Delete File
+
+```bash
+ossutil rm oss://my-bucket/uploads/file.txt
+```
+
+### Get File URL
+
+```bash
+ossutil stat oss://my-bucket/uploads/file.txt
+# Returns object URL and metadata
+```
+
+## CLI Reference (ossutil)
+
+| Command | Description |
+|---------|-------------|
+| `ossutil ls oss://bucket/` | List objects |
+| `ossutil cp localfile oss://bucket/path/` | Upload file |
+| `ossutil cp oss://bucket/path localfile` | Download file |
+| `ossutil rm oss://bucket/path` | Delete object |
+| `ossutil stat oss://bucket/path` | Object metadata |
+| `ossutil mkdir oss://bucket/dir/` | Create directory |
+| `ossutil cp -r ./dir oss://bucket/dir/` | Upload directory |
+| `ossutil sync oss://bucket1/ oss://bucket2/` | Sync between buckets |
+| `ossutil sign oss://bucket/path` | Generate signed URL |
+
+## Access Control
+
+### Bucket Policies
+
+| Type | Access | Use Case |
+|------|--------|----------|
+| public-read | Anyone with URL | Static assets, public downloads |
+| private | Requires signature | User uploads, private documents |
+
+### Signed URLs (for private buckets)
+
+```bash
+# Generate signed URL (valid for 1 hour)
+ossutil sign oss://my-bucket/private.pdf --timeout 3600
+```
+
+### RAM Policy for Functions
+
+```json
+{
+  "Version": "1",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": ["oss:GetObject", "oss:PutObject"],
+      "Resource": "acs:oss:*:*:my-bucket/*"
+    }
+  ]
+}
+```
+
+## Upload from Functions
+
+### Direct Upload (Node.js)
+
+```javascript
+const OSS = require('ali-oss');
+
+const client = new OSS({
+  region: process.env.ALICLOUD_REGION,
+  accessKeyId: process.env.ALICLOUD_ACCESS_KEY,
+  accessKeySecret: process.env.ALICLOUD_SECRET_KEY,
+  bucket: 'my-bucket'
+});
+
+async function uploadFile(fileName, fileContent) {
+  const result = await client.put(fileName, fileContent);
+  return result.url;
+}
+```
+
+### Server-Side Upload (recommended for large files)
+
+```javascript
+// Get upload credentials from STS
+const STM = require('aliyun-sdk').STS;
+
+const sts = new STM({
+  accessKeyId: process.env.ALICLOUD_ACCESS_KEY,
+  accessKeySecret: process.env.ALICLOUD_SECRET_KEY,
+  region: process.env.ALICLOUD_REGION
+});
+
+const token = await sts.assumeRole({
+  RoleArn: 'acs:ram::xxx:role/oss-uploader',
+  RoleSessionName: 'uploader-session'
+});
+
+// Return credentials to client for direct upload
+return {
+  AccessKeyId: token.credentials.AccessKeyId,
+  AccessKeySecret: token.credentials.AccessKeySecret,
+  SecurityToken: token.credentials.SecurityToken,
+  bucket: 'my-bucket',
+  endpoint: `oss-${process.env.ALICLOUD_REGION}.aliyuncs.com`
+};
+```
+
+### Frontend Upload Example
+
+```javascript
+const client = new OSS({
+  region: 'oss-cn-shanghai',
+  accessKeyId: uploadData.AccessKeyId,
+  accessKeySecret: uploadData.AccessKeySecret,
+  stsToken: uploadData.SecurityToken,
+  bucket: uploadData.bucket
+});
+
+const file = document.querySelector('#file-input').files[0];
+const result = await client.put(`uploads/${Date.now()}_${file.name}`, file);
+```
+
+## Static Website Hosting
+
+### Enable Static Website
+
+```bash
+ossutil website oss://my-bucket --index index.html --error 404.html
+```
+
+### Set Cache-Control
+
+```bash
+ossutil set-meta oss://my-bucket/path -h "Cache-Control:max-age=31536000"
+```
+
+### CDN Integration
+
+```bash
+# Add CDN domain
+aliyun cdn AddCdnDomain \
+  --DomainName example.com \
+  --CdnType web \
+  --SourceType oss \
+  --SourceDomain my-bucket.oss-cn-shanghai.aliyuncs.com
+```
+
+## Lifecycle Policies
+
+### Configure Lifecycle
+
+```bash
+# Delete temp files after 7 days
+ossutil lifecycle --bucket my-bucket --lifecycle-file lifecycle.xml
+```
+
+### lifecycle.xml Example
+
+```xml
+<LifecycleConfiguration>
+  <Rule>
+    <ID>delete-temp</ID>
+    <Prefix>temp/</Prefix>
+    <Status>Enabled</Status>
+    <Expiration>
+      <Days>7</Days>
+    </Expiration>
+  </Rule>
+  <Rule>
+    <ID>archive-logs</ID>
+    <Prefix>logs/</Prefix>
+    <Status>Enabled</Status>
+    <Transition>
+      <Days>30</Days>
+      <StorageClass>Archive</StorageClass>
+    </Transition>
+  </Rule>
+</LifecycleConfiguration>
+```
+
+## Limits and Quotas
+
+| Limit | Value |
+|-------|-------|
+| Max file size | 48.8TB (single object) |
+| Max bucket size | Unlimited |
+| Max buckets per account | 100 |
+| Max objects per bucket | Unlimited |
+| PUT/COPY/POST requests | 5GB max |
+| Multipart upload | 48.8TB max |
+| Upload speed | Limited by function memory |
+
+## Best Practices
+
+1. **Use meaningful object keys** - `uploads/{userId}/{timestamp}_{filename}`
+2. **Implement cleanup** - Delete old temporary files with lifecycle
+3. **Use content type** - Set correct Content-Type for browser display
+4. **Compress images** - Resize on upload to save storage
+5. **Use CDN** - Enable CDN for frequently accessed files
+6. **Handle duplicates** - Check if file exists before upload
+7. **Secure uploads** - Validate file types, scan for malware
+8. **Use multipart** - For files > 5GB
+
+## Troubleshooting
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Upload fails | File too large | Use multipart upload |
+| 403 Forbidden | Private bucket | Use signed URL |
+| File not found | Wrong path | Check path is case-sensitive |
+| Slow download | Not cached | Enable CDN caching |
+| Upload timeout | Slow connection | Increase function timeout |
+
+For detailed troubleshooting → `../best-practices/troubleshooting.md`