Functions@Edge (Deprecated)

Functions@Edge is undergoing end-of-life. We recommend using Edge Functions instead. Before you can get started with Edge Functions, you will need to create an Edgio Applications v7 account.

Functions@Edge, which is a Function as a Service (FaaS) solution, builds, distributes, and runs your applications on our globally distributed network. Use this solution to create serverless applications for new or existing code. Computing on the edge of our network instead of your web servers improves performance, ensures availability, allows for rapid development, and reduces your server load. Additionally, we secure your code by running it within the Deno V8 runtime.

Quickly build and deploy your applications to the edge of our network:

Use Functions@Edge to satisfy all of your computing requirements, such as:

• A/B testing (aka split testing). Conduct marketing campaigns and test new user experiences.
• Dynamic content generation. Create web pages on the fly using templates, data points, and outputs from multiple backend services.
• Data processing and enrichment. Filter, enhance, and format data and logs to gain richer insights.
• Content personalization. Personalize content by location or device type.
• Video manifest manipulation. Dynamically manipulate HLS or DASH manifest files to personalize video experiences.
• API orchestration. Expose easy-to-use APIs by orchestrating requests and responses across microservices.
• URL redirects and rewrites. Redirect requests according to a mapping defined within a static asset (e.g., CSV or JSON).

How Does It Work?

Once you have installed our CLI and created a credentials file, you will need to initialize your project, develop, deploy your code, and then call your function from a client application (e.g., web browser). This workflow is illustrated below.

The recommended method for iterating on code running on production traffic varies according to whether your existing client application(s) are compatible with your changes.

• If your existing client application(s) are compatible with your changes, then you should test the changes to your function locally. Once it is ready for release, redeploy your function.
• If your changes require an update to your existing client application(s), then you should initialize a new project, develop, test on your local machine, deploy your code, and then validate your implementation. If no issues are found, then you should release an updated client application that calls the new endpoint.

Requirements and Restrictions

Functions@Edge's requirements and restrictions are provided below.

• Operating System: Our command-line interface (CLI) application requires either macOS or Linux.

• Language: JavaScript

  Functions@Edge does not support the use of callbacks within your function. However, you may request your function's endpoint through a callback.

• Timeout: A request times out when a function takes longer than 30 seconds.
• Bundle Size: Your project's bundle size cannot exceed 20 MB.

• Active Functions: You may have up to 10 functions in the Deployed state.

  Use the stop command to temporarily disable a function. Functions in the stopped state do not count towards this limit.
  Alternatively, use the rm command to remove obsolete functions.

• Memory: Each function is restricted to 128 MB per container.

We recommend that you store your Functions@Edge projects within a source control repository. Developing your functions within this type of environment allows for collaboration, tracking changes, and disaster recovery. Functions@Edge does not have any special requirements for use with a source control repository.

Quick Start

Get started by performing the following steps:

1. Activate Functions@Edge.

   Contact your CDN account manager for information on how to activate Functions@Edge.

2. Submit the following curl request to download and install our macOS or Linux command-line interface (CLI) application:

   curl -sLo - 'https://developer.edgecast.com/download/edgecompute/install-edge-cli.sh' | sh

   The above installation script installs the edge CLI application to $HOME/.edge/bin. Verify that this directory is defined in your system path. Alternatively, you may run the edge CLI application using the following command: $HOME/.edge/bin/edge (e.g., $HOME/.edge/bin/edge fn ps).

3. Create an API client from within the Identity dashboard.
4. Define your API client's credentials within a .edge.yaml file in your home directory.

5. Initialize your project by issuing the following command and then add your code within src/main.js.

   edge fn init Project

6. Navigate to the project's home directory and then deploy your code to our network by issuing the following command:

   edge fn up
7. Wait a few seconds for the deployment to complete and then run your function by requesting the endpoint generated for it.

Installation

You must activate Functions@Edge prior to installation. Contact your CDN account manager for activation information.

Perform the following steps to install the Functions@Edge CLI application:

1. Submit the following curl request to download and install our macOS or Linux command-line interface (CLI) application:

   curl -sLo - 'https://developer.edgecast.com/download/edgecompute/install-edge-cli.sh' | sh
   Learn how to manually install the edge CLI application.

   An alternative to using the installation script is to manually download and install our CLI application.

   Perform the following steps:

   1. Download the CLI application.

      • macOS CLI application (SHA)

      • Linux CLI application (SHA)

   2. macOS Only

      Perform the following steps to add the Functions@Edge CLI application as an exception to your security settings:

      1. From Finder, select the Functions@Edge CLI application.
      2. Control-click it and then select Open.

   3. Move our CLI application to a directory in your system path.

      Sample Directory:

      /usr/local/bin

   4. From the terminal, navigate to the above directory and then run the following command to allow our CLI application to execute as a file:

      chmod +x edge

2. Optional. Add the following installation directory to your system path:

   $HOME/.edge/bin

   Alternatively, you may run the edge CLI application using the following command: $HOME/.edge/bin/edge (e.g., $HOME/.edge/bin/edge fn ps).

   Bash Example:

   echo 'export PATH="$PATH:/Users/jsmith/.edge/bin"' >> /Users/jsmith/.bashrc

   source /Users/jsmith/.bashrc

3. Create an API client for Functions@Edge.

   1. From the Identity dashboard, navigate to the Clients tab.
   2. From the Assigned to Tenant option, verify that your customer account is selected.
   3. Click Create New Client.
   4. From the Name option, assign a name to this client.
   5. From the Permissions section, mark the ec.ef scope.
   6. Click Create.

   7. You will need the following information when setting up your credentials file:

      • Client ID: The ID for this client is provided from within the Client ID option on the Settings tab.
      • Secret Key: Copy this client's secret key by navigating to the Client Secrets tab and then clicking .

4. Update the credentials file in your home directory with your credentials:

   1. From the terminal, navigate to your home directory by typing:

      cd $HOME

   2. Update .edge.yaml to include your OAuth 2.0 credentials.

      You should create this file if it does not already exist.

      Syntax:

      identity:

        id: Client IDA value that uniquely identifies this client application and your customer account.

        secret: SecretThis value authenticates the client application identified above.

      Example:

      identity:

        id: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee

        secret: 1234567890Abcdefghijklmnopqrstuv

   Our CLI application will be unable to authorize your requests if the .edge.yaml file is missing, improperly formatted, or contains inaccurate OAuth 2.0 credentials.

5. Verify that our CLI application has been properly installed by running the following command:

   edge fn ps

To update the Functions@Edge CLI to the latest version

Type the following in your terminal:

Learn how to manually upgrade the CLI application.

1. Download the CLI application.

   • macOS CLI application (SHA)

   • Linux CLI application (SHA)

2. macOS Only

   Perform the following steps to add the Functions@Edge CLI application as an exception to your security settings:

   1. From Finder, select the Functions@Edge CLI application.
   2. Control-click it and then select Open.

3. Move our CLI application to a directory in your system path.

   Sample Directory:

   /usr/local/bin

4. From the terminal, navigate to the above directory and then run the following command to allow our CLI application to execute as a file:

   chmod +x edge

5. Verify that you have properly installed the latest version of our CLI application by running the following command:

   edge version

   Verify that the client and server report the same version (e.g., 1.8.2).

                Version     SHA                                          Built                    
   Client:      v1.8.2     512be5614f64668750029da631a49e03d3493294     2022-07-01T17:08:39Z
   Server:      v1.8.2     512be5614f64668750029da631a49e03d3493294     2022-07-01T17:55:39Z

Basic CLI Functionality

Use our macOS or Linux command-line interface (CLI) application to:

• Initialize a project.

  edge fn init Project

• Deploy your functions.

  edge fn up

• Stop or resume a function.

  edge fn stop Project
  edge fn start Project

• Remove previously deployed functions.

  edge fn rm Project

• View status information for each function.

  edge fn ps

• View a function's log data.

  edge fn logs Project

Projects

A project defines key properties and it provides a centralized location for your code and supporting libraries. Initialize your project via the init command to:

• Copy a sample project to your project's directory.

• Generate a configuration file called edge-function.yaml. Its core properties are described below.

  Property	Description
  entryPoint	Identifies a function within your main.js file that will act as the entry point. This property's value and the name of your function may only consist of alphanumeric characters.
  jsConfig	Reserved for future use.
  language	Identifies the programming language in which your code was written. The only valid value is: js
  name	Identifies your project by name.
  runtime	Set to default.
  srcFolder	Identifies the relative path to the directory that contains your main.js file.

  Sample configuration file:

  entryPoint: myEdgeFunction
  jsConfig: {}
  language: js
  name: GetStatus
  runtime: default
  srcFolder: ./src

To set up a project

1. Initialize your project by navigating to the desired directory and then typing the following in a terminal:

   edge fn init ProjectReplace this variable with the name of your project. This name may only consist of alphanumeric characters.

2. Replace the code in the main.js file with your code. Include a line that exports the function that will act as the entry point.

   By default, this function will use the name defined in step 1. If you would like to use a different alphanumeric name, update the entryPoint property within the project's edge-function.yaml file.

   Sample code excerpt:

   export default function myEdgeFunction() {

3. Optional. Import a function from a module.

4. Optional. Test your function on your local machine.

5. Deploy your code by typing the following command from your project's home directory:

   edge fn up

Using Functions from our Catalog

An alternative to setting up a new project is to use a function from our catalog. These functions are ready for use or you may customize them as needed.

Common actions:

• Retrieve a list of all functions in our catalog:

  edge fn catalog

• Download a function from our catalog into the current directory:

  edge fn catalog init Function

• Deploy a catalog function:

  1. Download the desired function to the desired directory.
  2. Optional. Modify the code as needed.

  3. Deploy the function by issuing the following command from the directory that contains the edge-function.yaml file:

     edge fn up

  4. Check deployment status by issuing the following command:

     edge fn ps
  5. Once it has been deployed, validate your function by requesting the corresponding endpoint.

Libraries

You can import an object or value from:

• Your own custom module.

• An included library.

  Our included libraries (e.g., jsx-html/react.js and djwt/djwt.js) are limited to the objects leveraged in our sample projects. Download our sample projects from our catalog.

Import an object or value from a module via an import statement.

Sample code excerpt (local module):

The following statement imports the cube object from src/lib/math.js:

Sample code excerpts (included library):

The following statement imports the create, getNumericDate, and verify objects from djwt/djwt.js:

The following statement imports the React object from jsx-html/react.js:

Request

Use the req object to retrieve data from the request.

Response

Use the res object to retrieve and manipulate the response.

Chaining Response Methods

You may chain:

• Status and send methods.
• Redirect and send methods.

Status and Send Example:

export default function myEdgeFunction(req, res) {
   console.log(req.headers.get("x-header"));
   console.log(req.query.get("id"));
   console.log(req.query.getAll("env"));
   const result = cube(Math.PI);
   res.headers.set("info", "Functions@Edge");
   res.status('404').send(`Welcome to Functions@Edge! PI Cubed: ${result}`);
}

Static Assets

Your function may read assets (e.g., CSV, JSON, and JS) stored within your project's static directory.

Key information:

• You must store all of your static assets within the following directory:

  srcFolder/static

  Your project's srcFolder is defined within its configuration file (edge-function.yaml).

  Default Path:

  src/static
• Your project's total file size cannot exceed 20 MB.
• All static assets are read-only. You may not write to a static asset.

• Resolve the path to a static asset using resolveStatic. Absolute or relative paths are unsupported.

  An absolute or relative path may work when testing locally. However, absolute or relative paths will not resolve correctly for deployed functions.

Reading Static Assets

Before your function may read static assets, you must first resolve the path to where they are stored by including the following import statement:

import { resolveStatic } from "edgecompute.lib/static.js"

After which, you may read an asset using a Deno namespace method.

Learn more.

Examples

Read an asset's content as an array of bytes:

const path = resolveStatic("picture.png");
const data = Deno.readFileSync(path);

Read an asset's content as a UTF-8 encoded string:

const path = resolveStatic("example.txt");
Deno.readTextFileSync(path);

Parsing a JSON file into an object:

const path = resolveStatic("sample.json");
const jsonString = Deno.readTextFileSync(path);
const myData = JSON.parse(jsonString);

Download the static-assets function from our catalog to view a sample implementation.

Testing Functions

You may test your functions:

• On your local machine. This allows you to test code prior to its deployment.

• After deployment by requesting the function's endpoint through a tool, such as curl, Postman, or a web browser.

  An alternative to using one of the above tools is to submit GET, POST, and DELETE requests to your function's endpoint from within the MCC. Test your function from within the MCC by navigating to the Functions page (How?From the main menu, navigate to Edge Compute | Functions@Edge.), clicking on your function, and then clicking on the Test tab.

Local Machine

Test your code locally by issuing the run command. This command serves your project's main.js file and any modules referenced by an import statement to a web server on your local machine.

Key information:

• Automatically compile and restart your function's local web server whenever you update your source code by passing the --watch flag.
• By default, our web server runs on port 8080. Use the --port flag to run it on a different port.

• If an error occurs while compiling your function, then it will be reported within the terminal. Review and update your code. After which, reissue this command.

  Example:

  running helloworld locally, watch: true, port: 8080 
  ⣾ uploading for compilation ✓
  ⢿ compiling function ✗
  ------------
  main.js: 14:3  'fres' is not defined.
  12     console.log(req.headers.get("x-header"));
  13     res.headers.set('x-set', 'wow')
  14     fres.headers.append("x-append", "foo");
         ^^^^
  15     res.headers.append("x-append", "bar");
  

• Allow our application to accept incoming network connections if prompted upon starting your function's local web server.

  macOS example:

  Do you want the application "helloworld-local" to accept incoming network connections?
• The run command does not support static assets. You may test your function using an absolute path instead of resolveStatic. However, you will need to manually revert this change before deploying this function.

• Submit a GET request to your local machine to test your function.

  Example:

  http://localhost:8080

• The terminal displays the result for each request to your function.

  Example:

  null                         
  []
  null
  GET localhost:8080 / 200
  User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36
  Client IP: null
  {
    headers: { "x-append": "foo, bar", "x-set": "wow" },
    status: 200,
    type: "string",
    result: "Welcome to the Edge! PI Cubed: 31.006276680299816"
  }

To test a function on your local machine

1. Navigate to your project's home directory.

2. Type the following command from within a terminal:

   edge fn run --watch
3. Once Functions@Edge successfully compiles and starts your function's local web server, you may be prompted to allow our application to accept incoming network connect. Click Allow.
4. Test your function by requesting http://localhost:8080 from a web browser.
5. Review the result within your terminal.

Deploying Functions

Deploy the code associated with your project via the up command. This deployment includes your project's main.js file and any modules referenced by an import statement.

You may deploy up to 10 projects to our network. Remove outdated functions to make room for new functions.

Your code will be fully propagated after a few seconds

To deploy your code

1. Navigate to your project's home directory.

2. Type the following command from within a terminal:

   edge fn up

3. Check your function's deployment status by typing the following command:

   edge fn ps

   Sample output:

   $ edge fn ps
   NAME     ENDPOINT     RUNTIME   LANGUAGE   STATUS    VERSION  CREATED         UPDATED
   myFE     https://...  default   js         deployed  v1       8 seconds ago   8 seconds ago
   

4. Once your function's status is set to deployed, you may validate your code by requesting the endpoint associated with your function.

Listing Functions and Endpoints

Once your code has been deployed to our network, Functions@Edge will assign an endpoint to it. Use this endpoint to call your function. List all of your functions and their endpoints by performing either of the following steps:

• Command Line: Type the following command in the terminal:

  edge fn ps

  Quickly test your function by pasting your function's endpoint in a browser's address bar and then pressing ENTER.

  Sample output:

  $ edge fn ps
  NAME     ENDPOINT     RUNTIME   LANGUAGE   STATUS    VERSION  CREATED         UPDATED
  myFE     https://...  default   js         deployed  v1       8 seconds ago   8 seconds ago
  

• MCC: Navigate to the Functions page. (How?From the main menu, navigate to Edge Compute | Functions@Edge.) This page lists all of your functions and key information, such as version information, their current status, and when they were last updated.

  Click on a function to manage, test, or view detailed function information. View reports on function usage from within the Reports tab.

Starting and Stopping Functions

Functions are automatically active upon their deployment. You may temporarily disable a function by issuing the following command:

Once you have stopped a function, its endpoint will return a 503 Service Unavailable. Restart the function in order to reactivate the endpoint.

Start a function by issuing the following command:

You may also start and stop a function from within the MCC by navigating to the Functions page (How?From the main menu, navigate to Edge Compute | Functions@Edge.), clicking on the desired function, clicking on the Actions tab, and then clicking either Start or Stop.

Removing Functions

Remove a previously deployed function from our network by issuing the following command:

Alternatively, you may temporarily disable a function by issuing stop and start commands.

You may also remove a function from within the MCC by navigating to the Functions page (How?From the main menu, navigate to Edge Compute | Functions@Edge.), clicking on the desired function, clicking on the Actions tab, and then clicking Remove.

Updating Functions

The workflow for updating a previously deployed function is described below.

1. Update the code in your project's src folder as needed.

2. Optional. Test your function on your local machine by requesting http://localhost:8080 after issuing the following command from within your project's home directory:

   edge fn run

   Learn more.

3. Deploy the new function by issuing the following command from within your project's home directory:

   edge fn up

4. Check deployment status by issuing the following command:

   edge fn ps
5. Once it has been deployed, validate your updated function by requesting the corresponding endpoint.

Setting up a Function as a Serverless Origin

Deployed functions run on Functions@Edge servers. You may add a CDN layer on top of our Functions@Edge infrastructure to improve performance by caching your function's response for a short time period.

By default, our CDN caches your function's response for 7 days. Define a caching policy for your function's response by setting response headers or a Rules Engine policy.

Requirements

Serving your function through our CDN requires:

• A function in the Deployed state.

• A CDN account that supports customer origin groups.

  If your account has not been updated to use customer origin groups, contact your CDN account manager to upgrade.

  Find out whether your account supports customer origin groups.

• End-to-end HTTPS encryption with Server Name Indication (SNI) enabled.

  HTTPS encryption requires requesting a TLS certificate, setting up an edge CNAME configuration, and defining a CNAME record.

To set up a function as a serverless origin

1. Issue the following command to verify that the desired function is in the Deployed state:

   edge fn ps

2. Set up a customer origin group for your function.

   1. Verify that your account supports customer origin groups.

      Learn more.

   2. From within the MCC, navigate to the Origins page corresponding to the desired platform. How?From the MCC's main menu, navigate to [HTTP Large, HTTP Small, or ADN] | Customer Origin.
   3. Click Create.
   4. Click Customer Origin.

   5. Click within the Group option and then perform the following steps:

      1. Type the nameUse the following characters when defining this name: alphanumeric, hyphens, periods, and underscores. that will be assigned to the new customer origin group.
      2. Click + Add "Customer Origin Group Name".
   6. In the Name option, type the nameUse the following characters when defining this name: alphanumeric, hyphens, periods, and underscores. by which you will identify this function.

   7. From the Edge Function option, select the function identified in step 1.

      If you do not see the Edge Function option, perform step 1 again to verify that you have at least one function in the Deployed state.

   8. Optional. Click Origin TLS from the Group Settings section. Verify that the Use SNI for HTTPS Origin Requests option is enabled.

   9. Click Save to save your customer origin group.

3. Use the Certificate Provisioning System to request a DV, OV, or EV certificate for the hostname through which your function will be requested.

   Learn more.

   Sample hostnames:

   function.edgecast.com | myfunction.example.com | optimize.example.com

4. Create an edge CNAME configuration that points the hostname identified in step 3Sample hostnames: cdn.example.com, function.example.com, and function.edgecast.com to the customer origin group created in step 2 (e.g., /800001/myfunction).

   Learn more.

5. Optional. Define a caching policy for your function's response by setting response headers or a Rules Engine policy.

   • Response Headers: Set the Cache-Control header, Expires header, or both within your function.

     Redeploy your function to apply your changes to production.

     Example:

     res.headers.set('Cache-Control', 'max-age=5')
     

   • Rules Engine: Deploy a policy that defines how your function's response will be cached by our CDN.

     By default, the External Max-Age feature overwrites Cache-Control and Expires headers defined within your function.

     Learn more.

     Example:

     The following rule caches requests to a function for 5 seconds:

     

6. Wait until you can verify that your certificate is live.

   Learn more.

7. Create or update a CNAME record within your DNS zone to point the hostname identified in step 3 to your certificate's target CNAME.

8. Verify that your function can now be served through our CDN by submitting a HTTPS request for the hostname identified in step 3.

   Example:

   If you requested a certificate for functions.edgecast.com, then you should request this URL:

   https://functions.edgecast.com

Reports

Use our reports to gain insights into your function's usage. We offer the following types of reports:

• Requests (RPS)

  This line graph measures the rate at which this function was requested.

  Formula:

  Each data point is calculated using the following formula:

  RequestsRepresents the number of times that this function was requested within a single time interval. / Time IntervalRepresents the time interval's duration in seconds. A time interval's duration varies according to the report's time period.

  Example:

  If you generate a report for the Last Hour, then the time interval for each data point is 300 seconds. If your function was requested 900 times within one of those time intervals, then the rate for that data point is 3 requests per second.

  900 / 300 = 3

• HTTP Status Code (RPS)

  This line graph measures the frequency (requests per second) at which our service responds with specific HTTP status codes (e.g., 200, 400, and 500) for this function.

  Formula:

  Each data point is calculated using the following formula:

  Status Code-specific ResponsesRepresents the number of times that our service responded with a specific HTTP status code (e.g., 200 OK) for this function within a single time interval. / Time IntervalRepresents the time interval's duration in seconds. A time interval's duration varies according to the report's time period.

  Example:

  If you generate a report for the Last Hour, then the time interval for each data point is 300 seconds. If our service returned a 200 OK 900 times within one of those time intervals, then the rate of 200 OK responses for that data point is 3 per second.

  900 / 300 = 3

• Average Response Time (Milliseconds)

  This line graph measures the average response time, in milliseconds, for this function.

  Formula:

  Each data point is calculated using the following formula:

  Response TimeRepresents the total amount of time, in milliseconds, that our service spent processing this function witihin a single time interval. / Time IntervalRepresents the time interval's duration in seconds. A time interval's duration varies according to the report's time period.

  Example:

  If you generate a report for the Last Hour, then the time interval for each data point is 300 seconds. If our service spent 900,000 milliseconds processing this function within one of those time intervals, then the average response time for that data point is 3,000 milliseconds.

  900000 / 300 = 3000

• Data Transferred (BPS)

  This line graph measures the rate, in bytes per second, for the data that our service received (ingress) or delivered (egress) as a result of this function.

  Formula:

  Each data point is calculated using the following formula:

  Data TransferredRepresents the total amount of data, in bytes, that our service received or delivered as a result of this function witihin a single time interval. / Time IntervalRepresents the time interval's duration in seconds. A time interval's duration varies according to the report's time period.

  Example:

  If you generate a report for the Last Hour, then the time interval for each data point is 300 seconds. If 9,000 bytes were received or delivered as a result of this function within one of those time intervals, then the data transferred rate for that data point is 30 bytes per second.

  9000 / 300 = 30

To view reports for your function

1. From within the MCC, navigate to the Functions page. (How?From the main menu, navigate to Edge Compute | Functions@Edge.)
2. Click on the desired function.
3. Click on the Reports tab.

4. From the top of the Reports page, select one of the following time periods:

   Time Period	Start Date/Time	End Date/Time	Time Interval
   Last hour	An hour ago at the current time (UTC)	Today at the current time (UTC)	5 minutes (300 seconds)
   Last 24 hours	24 hours ago at the current time (UTC)	Today at the current time (UTC)	5 minutes (300 seconds)
   Last 7 days	A week ago at the current time (UTC)	Today at the current time (UTC)	1 day (86,400 seconds)
   Last 30 days	30 days ago at the current time (UTC)	Today at the current time (UTC)	1 day (86,400 seconds)
   Last 90 days	90 days ago at the current time (UTC)	Today at the current time (UTC)	1 day (86,400 seconds)

   A request will be included in the report when the response is sent at or after the start date/time and before the end date/time.

Troubleshooting

Basic troubleshooting information is provided below.

begin processing: myFunction
------------
main.js: Line #:Column #Error Message

begin processing: myFunction
------------
main.js: 4:14  'myUndefinedVar' is not defined.
2    console.log(req.headers.get("x-header"));
3
4    console.log(myUndefinedVar);
                 ^^^^^^^^^^^^^^

Log Data

If you are still experiencing issues, view log data for that project by issuing the following command:

Verify Installation

If you cannot identify the issue from the log data, issue the following command to update your client to the latest version:

Verify that you are using the latest Functions@Edge build by issuing the following command:

Reference

Reference information for commands, flags, and Functions@Edge locations is provided below.

Commands

Functions@Edge commands are described below.

Function-Specific Subcommands

Use the following syntax to pass a function-specific subcommand:

Function-specific subcommands are described below.

Flags

Our CLI supports the following flags:

Regions

Functions are automatically deployed to North America, Europe, and Asia.