Home/FastEdge/Create apps/Rust

Create a FastEdge app

This guide describes how to create a FastEdge app. Check out our FastEdge overview article to learn more about the product.

You can create a FastEdge app in two ways: from a custom binary file or a pre-configured template. If you chose the last option, skip the Stage 1.

Stage 1. Create a Wasm binary file

To get started, you need to create a .wasm file that you will later upload to the Gcore Customer Portal.

Step 1. Set up the environment

1. Install the Rust compiler and cargo (package manager):

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

2. Add the Wasm compilation target to Rust compiler:

rustup target add wasm32-wasi

Step 2. Prepare directory structure and a configuration file

1. Initialize the directory structure:

cargo new myapp --lib

2. Create a directory:

mkdir myapp/.cargo

3. Set the Wasm compilation target for the project by creating a config file myapp/.cargo/config.toml with the following content:

[build]
target = "wasm32-wasi"

4. Create the project manifest file myapp/Cargo.toml with the following content:

[package]
name = "myapp"
version = "0.1.0"
edition = "2021"
 
[lib]
crate-type = ["cdylib"]
 
[dependencies]
fastedge = "0.1"

Step 3. Create a source

For illustration, we’ll create a simple app that responds with "HTTP 200" and the text “Hello world!” in the response’s body.

Create a main source file src/lib.rs with the following content:

use fastedge::{
    body::Body,
    http::{Request, Response, StatusCode, Error},
};
 
#[fastedge::http]
fn main(_req: Request<Body>) -> Result<Response<Body>, Error> {
    Response::builder()
        .status(StatusCode::OK)
        .body(Body::from("Hello world!\n"))
}

Step 4. Compile a Wasm file

Produce the Wasm binary:

cargo build --release

The resulting Wasm code will be written to the myapp/target/wasm32-wasi/release/myapp.wasm file.

Stage 2. Deploy an application

Deploy an app from a binary

1. In the Gcore Customer Portal, navigate to FastEdge > Create application.

2. Click Upload binary.

Create an app page with highlighted Upload binary section

3. Choose your custom binary file.

4. Click Save binary to upload it.

5. Enter a name for your application and provide a description if needed.

6. (Optional) Add fixed headers to the responses. For example, you may include CORS (Cross-Origin Resource Sharing) headers in each response to ensure secure communication between origins.

7. (Optional) If you want to add metadata to the configuration, click Add parameters and enter metadata as key-value pairs.

8. In the top-right corner of the screen, click Save and deploy.

Your application has been successfully deployed. You can now test its configuration and adjust it as described in the following steps.

A page with a link to an app and its configuration

Deploy an app from a template

1. In the Gcore Customer Portal, navigate to FastEdge > Create application.

2. In the Launch from a template section, select the preferred template.

Section with Github and Markdown templates

3. Enter a name for your application and update a description if needed.

Open page with empty name and description fields

4. Provide required environment variables for the application:

If you selected a GitHub template, enter the repository name and add your personal access token.
If you selected a Markdown template, enter the base part of the origin URL and add content from the <head> section of an HTML document.

5. (Optional) Add metadata as key-value pairs.

6. Click Save and deploy.

Your application has been successfully deployed. You can now test its configuration and adjust it as described in the following steps.

Stage 3. Test an application

You can test the application after its deployment by clicking the application link on the deployment confirmation screen:

You can also inspect and adjust the configuration from the Dashboards page:

1. In the Gcore Customer Portal, navigate to FastEdge > Dashboard.

Metrics tab with the list of FastEdge apps

2. Find the app you want to test and click its name to open it.

3. Click the app link next to the app status to view the response.

For example, for the application configured in the Stage 1, the response will be “Hello world!”

Stage 4 (Optional). Add more functionality

You can add more functionality to your app. For example, instead of printing “Hello world!”, the app can print all request headers and set a custom response header from the environment settings. Let’s see how to do that.

Step 1. Change the source

To print all request headers and develop a custom response header, replace the current content of the myapp/src/lib.rs file with the following:

use fastedge::{
    body::Body,
    http::{Request, Response, StatusCode, Error},
};
use std::env;
 
#[fastedge::http]
fn main(req: Request<Body>) -> Result<Response<Body>, Error> {
    // print headers
    let mut body: String = "".to_string();
    for (h, v) in req.headers() {
        body.push_str(h.as_str());
        body.push_str(": ");
        match v.to_str() {
            Err(_) => body.push_str("not a valid text"),
            Ok(a) => body.push_str(a),
        }
        body.push_str("\n");
    }
 
    // get value for custom header from the env var
    let value = match env::var("CUSTOM_HEADER").ok() {
        None => return Response::builder()
                    .status(StatusCode::INTERNAL_SERVER_ERROR)
                    .body(Body::from("App misconfigured\n")),
        Some(val) => val
    };
 
    // build response with body and custom header
    Response::builder()
        .status(StatusCode::OK)
        .header("Custom-Header", value)
        .body(Body::from(body))
}

The headers listed in the following step are passed to the FastEdge application, which uses the header content for functionalities like geolocation-aware redirects.

Step 2. Compile and upload the binary file

Update the application on the edge servers:

1. Compile a new Wasm file as described in step 4.

2. Upload it to the Customer Portal as a custom binary file.

When you open the app, you’ll see all request headers from the environment settings. It will be similar to the following output:

HTTP/2 200 server: nginx date: Thu, 19 Oct 2023 22:17:46 GMT content-length: 616 custom-header: foo access-control-allow-origin: * cache-control: no-store x-id: ed-hw-edge-preprod-gc39 cache: MISS accept-ranges: bytes dc: ed geoip-asn: 7922 geoip-lat: 37.75580 geoip-long: -121.95270 geoip-reg: CA geoip-city: San Ramon geoip-continent: NA geoip-country-name: United States geoip-country-code: US server_addr: 92.223.112.26 server_name: mistake-globe-6396.fastedge.gcore.dev connection: upgrade x-real-ip: 1.2.3.4 x-forwarded-for: 1.2.3.4 host: fastedge.gcore.dev x-forwarded-proto: https user-agent: curl/7.88.1 accept: */* cdn-loop: nb1d2; c=11 pop-long: 6.1294 pop-lat: 49.6113 pop-reg: LU pop-continent: EU pop-city: Luxembourg pop-country-code: LU pop-country-name: Luxembourg

custom-header: Added custom header
dc: Data center
geoip-*: Client GeoIP data, such as asn, latitude, longitude, region, city, continent, country name, and country code
server_addr: PoP IP address
server_name: Application's hostname
x-forwarded-for: Client IP address
pop-*: PoP GeoIP data, such as asn, latitude, longitude, region, city, continent, country name, and country code

Troubleshoot an application

If you’re having issues with your FastEdge application, check out the following sections for helpful tips and troubleshooting suggestions.

HTTP status codes

If your application is correctly configured and works as expected, FastEdge will return the expected status code like "200 OK".

However, in some exceptional situations, you might get the following status codes. Check out the description to understand the root cause and how to fix it.

Status code	Description
530	Internal FastEdge error.
531	Application has exceeded the allowed memory limit.
532	Application has timed out.
533	Application has crashed.

Was this article helpful?