The application management page provides access to all settings and runtime data for a deployed FastEdge application in one place.
To open the management page:
1. In the [Gcore Customer Portal](https://portal.gcore.com/accounts/reports/dashboard), navigate to **FastEdge** and select either **HTTP Applications** or **CDN Applications**. 2. On the **Applications** page, click the three-dot icon next to the application and select **Manage**.
The following tabs are available on the management page:
* **Metrics**: response status counts and runtime duration charts. * **Logs**: enable log collection and filter log entries. * **Response headers**: add HTTP headers to every application response. * **Environment variables**: define configuration values the application reads at runtime. * **Secrets**: link encrypted secrets from Secrets Manager to the application. * **Edge Storage**: link key-value stores to the application.The table below describes when to use each configuration option:
| Feature | Use for | | --------------------- | --------------------------------------------------------------------------------------- | | Response headers | HTTP headers added to every response — CORS, cache control, security headers | | Environment variables | Configuration values available to the application at runtime, up to 64 KB each | | Secrets | API keys, credentials, and other sensitive values encrypted at rest | | Edge Storage | Shared mutable key-value data the application reads at runtime | | Dictionary | Parameters over 64 KB and read-only edge node metadata — accessed from application code | ## Application lifecycleUse the **Actions** button in the page header to control the application lifecycle — stop or restart it, deploy a new binary, save its configuration as a reusable template, or delete it entirely.
* **Stop** — pause the application. Stopped applications don't process requests. * **Start** — resume a stopped application. * **Edit application** — update the application name or description. * **Update binary** — upload a new compiled Wasm binary. * **Create template** — save the current configuration as a reusable template. * **Delete** — permanently remove the application.
An application may also stop automatically if payment for the product fails. In that case, it can't be restarted until payment is completed.
## MetricsThe **Metrics** tab shows two charts: **Response Status** groups completed requests by HTTP status code, and **Runtime Duration (ms)** shows execution time per request in milliseconds. Use the time-range dropdown and the interval control in the chart header to adjust the view.
## LogsLogging is disabled by default. After enabling, the application records logs for 30 minutes, then stops automatically.
To enable logging:
1. Select the **Logs** tab. 2. Turn on the **Enable logging** toggle.
The remaining logging time appears next to the toggle as **Minutes remaining: N**. To extend logging, turn the toggle off and on again.
Log entries appear in the table with the following columns:
* **Client IP address** — IP of the client that sent the request. * **Timestamp (UTC)** — time the request was received. * **Edge name** — identifier of the edge node that handled the request. * **Request ID** — unique identifier assigned to the request. * **Logs** — application log output for that request.Use the text search field above the table to filter by log content, or select a date range. The **Refresh rate** dropdown controls how often the table updates — it defaults to 10 seconds when logging is active.
## Application configurationThe **Response headers**, **Environment variables**, **Secrets**, and **Edge Storage** tabs each control a different aspect of how the application receives configuration and accesses external data at runtime. Click **Save changes** to apply any edits. The dictionary is a separate read-only data source that the application accesses directly from code.
### Response headersUse response headers to add CORS, cache-control, security, or custom headers to every application response.
To add a header, click **Add response header**, enter the header name in the **Key** field and the value in the **Value** field, then click **Save changes**.
### Environment variablesEnvironment variables pass configuration values to the application at runtime. Each variable can store up to 64 KB of data; for larger values, define the parameter here and read it from code through the [dictionary](#dictionary) using the same key name.
To add a variable, click **Add environment variable**, enter the variable name in the **Key** field and its value in the **Value** field, then click **Save changes**.
Access environment variables in code using the [JavaScript SDK](https://g-core.github.io/FastEdge-sdk-js/reference/fastedge/env/) or standard Rust `std::env::var("KEY_NAME")`.
### SecretsUse environment variables for ordinary configuration values. When a value is sensitive — an API key, access token, or password — store it as a secret instead.
Secrets let an application access sensitive values without storing them directly in its configuration. Each secret is stored in [Secrets Manager](/fastedge/secrets-manager/manage-secrets) and linked to the application under a local key name that the code uses to retrieve the value at runtime.
To link a secret:
1. Click **Add secret**. 2. In the **Key** field, enter the name the application will use to reference the secret. 3. In the second field, select a secret from Secrets Manager. To create a new secret first, select **Add secret** in the dropdown. 4. Click **Save changes**.Access the secret in code using `secret::get("KEY_NAME")` in the [Rust SDK](https://docs.rs/fastedge/latest/fastedge/secret/index.html), or [`getSecret`](https://g-core.github.io/FastEdge-sdk-js/reference/fastedge/secret/get-secret/) in the JavaScript SDK.
### Edge StorageEdge Storage provides a shared key-value store that applications can read and update at runtime. Link a store under a local key name, and the code uses that name to open and query it.
To link a store:
1. Click **Add Edge Storage**. 2. In the **Key** field, enter the name the application will use to open the store. 3. In the second field, select a store from [Edge Storage](/fastedge/kv-stores/manage-kv-store). To create a new store first, select **Add Edge Storage** in the dropdown. 4. Click **Save changes**.Access the store in code using `Store::open("KEY_NAME")` in the [Rust SDK](https://docs.rs/fastedge/latest/fastedge/key_value/struct.Store.html), or [`open`](https://g-core.github.io/FastEdge-sdk-js/reference/fastedge/kv/open/) in the JavaScript SDK.
### DictionaryThe dictionary gives application code read-only access to edge node metadata that FastEdge populates automatically on every node, and to application parameters that exceed the 64 KB environment variable limit.
**Edge node metadata**FastEdge automatically populates the following keys on every edge node. These values reflect the physical node handling each request:
| Key | Description | | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | `hostname` | Hostname of the edge node | | `env` | Deployment environment: `prod` or `preprod` | | `role` | Node role: `edge` or `shield` | | `region` | Geographic region of the edge node: `africa`, `asia`, `au`, `cis`, `eu`, `latam`, `me`, `na`. Additional values may be returned for reseller networks. | | `country` | Full name of the country where the node is located | | `country2char` | ISO 3166-1 alpha-2 country code | | `city` | City where the node is located | | `dc` | Point of Presence (PoP) identifier | | `ipv4_addr_ip` | IPv4 address of the edge node | | `ipv6_addr_ip` | IPv6 address of the edge node | | `ipv6_enabled` | Whether IPv6 is enabled on the node: `true` or `false` |Built-in keys take priority over application parameters with the same name. To avoid unexpected behavior, don't use built-in key names as environment variable names.
**Large application parameters**Standard environment variable access is limited to 64 KB per value. For parameters that exceed this limit, define them on the **Environment variables** tab and read them through the dictionary using the same key name.
**Read dictionary values in code**In Rust, use the [`dictionary` module](https://docs.rs/fastedge/latest/fastedge/dictionary/index.html):
```rust theme={null} use fastedge::dictionary; if let Some(value) = dictionary::get("country") { // use value } ```In JavaScript, dictionary values are exposed through `getEnv()` from the [`fastedge::env`](https://g-core.github.io/FastEdge-sdk-js/reference/fastedge/env/) module:
```js theme={null} import { getEnv } from 'fastedge::env'; const country = getEnv('country'); ```All management operations use the [https://api.gcore.com/fastedge/v1/apps/\{id}](https://api.gcore.com/fastedge/v1/apps/\{id}) endpoint, where `id` is the numeric application identifier returned by GET /fastedge/v1/apps.
All requests authenticate with an [API token](/account-settings/api-tokens). Set it as an environment variable before running the examples:
```bash theme={null} export GCORE_API_KEY="{YOUR_API_KEY}" ``` ## Application lifecycleTo retrieve the current application state, including its configuration fields and binary ID:
```bash theme={null} curl -X GET "https://api.gcore.com/fastedge/v1/apps/APP_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" ```The response includes all fields needed for subsequent PUT requests: `id`, `binary`, `name`, `status`, `rsp_headers`, `env`, `secrets`, and `stores`.
To stop the application, send a PUT request with `"status": 0`. To start it again, use `"status": 1`. The PUT body must include all current field values — use the GET response as the base and update only the fields that change.
```bash theme={null} curl -X PUT "https://api.gcore.com/fastedge/v1/apps/APP_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "id": APP_ID, "binary": BINARY_ID, "name": "app-name", "status": 0 }' ```To delete the application permanently:
```bash theme={null} curl -X DELETE "https://api.gcore.com/fastedge/v1/apps/APP_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" ``` ## MetricsResponse Status and Runtime Duration are exposed through separate endpoints. **Response Status** groups completed requests by HTTP status code; **Runtime Duration** shows execution time per request in milliseconds. Both accept the same time-range parameters.
```bash theme={null} # Response status counts curl "https://api.gcore.com/fastedge/v1/stats/calls?from=2026-06-17T00:00:00Z&to=2026-06-17T23:59:59Z&step=3600&id=APP_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" # Runtime duration curl "https://api.gcore.com/fastedge/v1/stats/app_duration?from=2026-06-17T00:00:00Z&to=2026-06-17T23:59:59Z&step=3600&id=APP_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" ```The `step` parameter specifies the aggregation interval in seconds. The `from` and `to` parameters use ISO 8601 UTC format.
## LogsLogging is disabled by default and runs for 30 minutes after being enabled, then turns off automatically. Enable it by setting `"debug": true` in a PUT request.
```bash theme={null} curl -X PUT "https://api.gcore.com/fastedge/v1/apps/APP_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "id": APP_ID, "binary": BINARY_ID, "name": "app-name", "status": 1, "debug": true }' ```The response includes a `debug_until` field with the UTC timestamp when logging will stop. To read log entries:
```bash theme={null} curl "https://api.gcore.com/fastedge/v1/apps/APP_ID/logs?from=2026-06-17T00:00:00Z&to=2026-06-17T23:59:59Z&offset=0&limit=50" \ -H "Authorization: APIKey $GCORE_API_KEY" ``` ## Application configurationResponse headers, environment variables, secrets, and Edge Storage are all updated with a single PUT /fastedge/v1/apps/{id} request. The body replaces the entire configuration — fields omitted from the request are cleared. Read the current state with GET first and use it as the base.
Set headers in the `rsp_headers` object:
```json theme={null} "rsp_headers": { "Access-Control-Allow-Origin": "*", "Cache-Control": "public, max-age=3600" } ``` **Environment variables**Set variables in the `env` object:
```json theme={null} "env": { "API_BASE_URL": "https://api.example.com", "MAX_RETRIES": "3" } ``` **Secrets**To link a secret, get its numeric ID from GET /fastedge/v1/secrets, then reference it in the `secrets` object:
To link a key-value store, get its numeric ID from GET /fastedge/v1/kv, then reference it in the `stores` object:
The following example updates all four configuration areas in one request:
```bash theme={null} curl -X PUT "https://api.gcore.com/fastedge/v1/apps/APP_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "id": APP_ID, "binary": BINARY_ID, "name": "app-name", "status": 1, "rsp_headers": { "Access-Control-Allow-Origin": "*" }, "env": { "API_BASE_URL": "https://api.example.com" }, "secrets": { "MY_API_KEY": {"id": 636} }, "stores": { "MY_STORE": {"id": 126} } }' ``` ## Runtime data ### DictionaryThe dictionary is populated automatically by FastEdge on every edge node and is not configurable through the API. Access it from application code using the SDK — see the Customer Portal tab for the full key reference and code examples.