← Back to Skills Marketplace
geri4

Gcore FastEdge

by Andrey Gerasimov · GitHub ↗ · v1.0.1 · MIT-0
cross-platform ✓ Security Clean
73
Downloads
0
Stars
0
Active Installs
2
Versions
Install in OpenClaw
/install gcore-fastedge
Description
Build and deploy WebAssembly applications to Gcore FastEdge edge computing platform. Use when creating, building, or deploying FastEdge HTTP apps with Rust S...
README (SKILL.md)

FastEdge Skill

Build and deploy WebAssembly HTTP applications to Gcore FastEdge.

Quick Start

1. Create a new FastEdge app

Initialize a Rust project with the FastEdge SDK:

mkdir myapp && cd myapp

Create .cargo/config.toml:

[build]
target = "wasm32-wasip1"

Create Cargo.toml:

[package]
name = "myapp"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
fastedge = "0.2"

Create src/lib.rs:

use fastedge::{
    body::Body,
    http::{Request, Response, StatusCode, Error},
};

#[fastedge::http]
fn main(_req: Request\x3CBody>) -> Result\x3CResponse\x3CBody>, Error> {
    Response::builder()
        .status(StatusCode::OK)
        .header("content-type", "text/plain")
        .body(Body::from("Hello from FastEdge!"))
}

2. Build the Wasm binary

Requires Rust and wasm32-wasip1 target:

rustup target add wasm32-wasip1
cargo build --release

Binary location: target/wasm32-wasip1/release/myapp.wasm

3. Deploy via CLI

Set your API key (get from https://accounts.gcore.com/account-settings/api-tokens):

export GCORE_API_KEY="your_api_token"

Upload binary:

curl -X POST \
  'https://api.gcore.com/fastedge/v1/binaries/raw' \
  -H 'accept: application/json' \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  -H 'Content-Type: application/octet-stream' \
  --data-binary '@./target/wasm32-wasip1/release/myapp.wasm'

Save the id from response (binary_id).

Create app:

curl -X POST \
  'https://api.gcore.com/fastedge/v1/apps' \
  -H 'accept: application/json' \
  -H 'client_id: 0' \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "my-app-name",
    "binary": BINARY_ID,
    "status": 1
  }'

Your app will be at: https://my-app-name-XXXX.fastedge.app

Useful Patterns

HTML Response

Response::builder()
    .status(StatusCode::OK)
    .header("content-type", "text/html; charset=utf-8")
    .body(Body::from(html_string))

Access Request Headers

let ip = req.headers()
    .get("x-real-ip")
    .and_then(|v| v.to_str().ok())
    .unwrap_or("unknown");

Common headers provided by FastEdge:

  • x-real-ip - Client IP address
  • x-forwarded-for - Proxied client IP
  • geoip-country-code - Country code
  • geoip-city - City name
  • host - Request host

Update Existing App

curl -X PUT \
  'https://api.gcore.com/fastedge/v1/apps/APP_ID' \
  -H 'accept: application/json' \
  -H "Authorization: APIKey $GCORE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "binary": NEW_BINARY_ID,
    "status": 1,
    "name": "app-name"
  }'

Resources

  • Template project: See assets/rust-template/ for a starter template
  • Build script: See scripts/build_rust.py for automated build/upload
  • API Docs: https://gcore.com/docs/fastedge
Usage Guidance
This skill appears to do exactly what it says: build a Rust Wasm target and upload it to Gcore FastEdge. Before using it, keep these points in mind: 1) Protect your GCORE_API_KEY — the script will send it to api.gcore.com to create/update apps. Use a token with minimal scope where possible. 2) The build script runs rustup and cargo commands which will change or install toolchain targets on your machine. Review the Python script and the SKILL.md if you need to ensure the upload behavior fits your workflow. 3) The skill requires network access to Gcore; verify you trust api.gcore.com endpoints. If you need higher assurance, run the build step locally and inspect the output wasm before running deploy.
Capability Analysis
Type: OpenClaw Skill Name: gcore-fastedge Version: 1.0.1 The skill provides legitimate tools and instructions for building and deploying WebAssembly applications to the Gcore FastEdge platform. It includes a Rust project template and a Python helper script (scripts/build_rust.py) that interacts with the official Gcore API (api.gcore.com) using a user-provided API key. All actions, including the use of subprocesses for building and requests for deployment, are transparent and align with the stated purpose.
Capability Tags
requires-sensitive-credentials
Capability Assessment
Purpose & Capability
Name/description (build & deploy FastEdge Wasm apps) match the required binaries (rustup, cargo, python3), the single declared env var GCORE_API_KEY, and included build/deploy helper code.
Instruction Scope
SKILL.md and scripts only describe building a wasm binary and calling Gcore FastEdge APIs. The included Python script uses rustup/cargo and posts to api.gcore.com; it reads only GCORE_API_KEY and local filesystem build artifacts.
Install Mechanism
Install spec uses 'uv' to install the Python requests package — a small, reasonable dependency for the included Python deploy script. No arbitrary downloads, extract steps, or external binary installers are present.
Credentials
Only one credential is required (GCORE_API_KEY) and it is actually used by the deployment commands and the Python script. No unrelated secrets, config paths, or multiple tokens are requested.
Persistence & Privilege
Skill is not forced-always, does not modify other skills, and requests no elevated persistent system privileges. Autonomous invocation is allowed by default (expected) but not combined with other red flags.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install gcore-fastedge
  3. After installation, invoke the skill by name or use /gcore-fastedge
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.0.1
- Added metadata describing required binaries (rustup, cargo, python3), the required environment variable (GCORE_API_KEY), and instructions to install the "requests" Python package using uv. - No changes to skill functionality or usage documentation.
v1.0.0
Initial release of the FastEdge skill. - Enables building and deploying WebAssembly HTTP applications to the Gcore FastEdge platform using the Rust SDK. - Provides step-by-step instructions for project setup, building, and deployment via CLI. - Includes useful Rust code patterns for FastEdge apps, such as sending HTML and accessing request headers. - Offers guidance for updating existing apps and links to additional resources like templates and documentation.
Metadata
Slug gcore-fastedge
Version 1.0.1
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 2
Frequently Asked Questions

What is Gcore FastEdge?

Build and deploy WebAssembly applications to Gcore FastEdge edge computing platform. Use when creating, building, or deploying FastEdge HTTP apps with Rust S... It is an AI Agent Skill for Claude Code / OpenClaw, with 73 downloads so far.

How do I install Gcore FastEdge?

Run "/install gcore-fastedge" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Gcore FastEdge free?

Yes, Gcore FastEdge is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does Gcore FastEdge support?

Gcore FastEdge is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Gcore FastEdge?

It is built and maintained by Andrey Gerasimov (@geri4); the current version is v1.0.1.

💬 Comments