Edge Compute Quick Start

Tutorial Objectives

This tutorial covers learning the basic Edge Compute development workflow.

Prerequisites

A Telnyx account with API access - Sign up here if needed.
Command line familiarity - Requires Terminal (macOS/Linux) or Command Prompt (Windows).
Time requirement - This guide takes approximately 5 minutes to complete.

Install the CLI

Download Binary

Check out the edge-compute repo and download the latest release from the releases page. Extract the archive and add the binary to your PATH: Example for Linux/macOS:

# Download and extract
tar -xzf telnyx-edge-*.tar.gz

# Install to system PATH
sudo mv telnyx-edge /usr/local/bin/

# Verify installation
telnyx-edge --help

Authenticate

Option 1: OAuth (Recommended)

Authenticate using OAuth with your Telnyx account:

telnyx-edge auth login

This will open your browser to complete authentication.

Option 2: API Key

Alternatively, authenticate with a Telnyx API key:

telnyx-edge auth api-key set YOUR_API_KEY

Verify Authentication

Check your authentication status:

telnyx-edge auth status

Create a Function

Create a simple “Hello World” function. Choose your preferred language:

JavaScript
Go
Python
Java

telnyx-edge new-func --language=javascript --name=hello-world

This creates a new directory with the function:

hello-world/
├── index.js     # Your function code
├── package.json # Node.js dependencies
└── func.toml    # Function configuration

Function Code

The generated index.js contains a basic HTTP handler:

export async function handler(request) {
    const response = {
        message: "Hello from Telnyx Edge Compute!",
        status: "success"
    };

    return new Response(JSON.stringify(response), {
        headers: { "Content-Type": "application/json" }
    });
}

telnyx-edge new-func --language=go --name=hello-world

This creates a new directory with the function:

hello-world/
├── handler.go   # Your function code
├── go.mod       # Go dependencies
└── func.toml    # Function configuration

Function Code

The generated handler.go contains a basic HTTP handler:

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

type Response struct {
    Message string `json:"message"`
    Status  string `json:"status"`
}

func handler(w http.ResponseWriter, r *http.Request) {
    response := Response{
        Message: "Hello from Telnyx Edge Compute!",
        Status:  "success",
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

func main() {
    http.HandleFunc("/", handler)

    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    fmt.Printf("Server starting on port %s\n", port)
    http.ListenAndServe(":"+port, nil)
}

telnyx-edge new-func --language=python --name=hello-world

This creates a new directory with the function:

hello-world/
├── app.py            # Your function code
├── requirements.txt  # Python dependencies
└── func.toml         # Function configuration

Function Code

The generated app.py contains a basic HTTP handler:

import json
import os
from http.server import HTTPServer, BaseHTTPRequestHandler

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        response = {
            "message": "Hello from Telnyx Edge Compute!",
            "status": "success"
        }
        
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(json.dumps(response).encode())

    def do_POST(self):
        content_length = int(self.headers.get('Content-Length', 0))
        body = self.rfile.read(content_length)
        data = json.loads(body) if body else {}
        
        response = {
            "message": "Hello from Telnyx Edge Compute!",
            "received": data,
            "status": "success"
        }
        
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(json.dumps(response).encode())

if __name__ == "__main__":
    port = int(os.environ.get("PORT", 8080))
    server = HTTPServer(("", port), Handler)
    print(f"Server starting on port {port}")
    server.serve_forever()

telnyx-edge new-func --language=quarkus --name=hello-world

This creates a new directory with the function:

hello-world/
├── src/main/java/    # Your function code
├── pom.xml           # Maven dependencies
└── func.toml         # Function configuration

Function Code

The generated HelloResource.java contains a basic HTTP handler:

package com.telnyx.edge;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import java.util.Map;

@Path("/")
public class HelloResource {

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Response hello() {
        return Response.ok(Map.of(
            "message", "Hello from Telnyx Edge Compute!",
            "status", "success"
        )).build();
    }

    @POST
    @Produces(MediaType.APPLICATION_JSON)
    public Response handlePost(Map<String, Object> body) {
        return Response.ok(Map.of(
            "message", "Hello from Telnyx Edge Compute!",
            "received", body,
            "status", "success"
        )).build();
    }
}

Deploy the Function

Navigate to the function directory and deploy:

cd hello-world
telnyx-edge ship

The CLI will:

Validate your function structure.
Check authentication.
Package your function files.
Upload to Telnyx Edge infrastructure.
Deploy across edge locations.

You’ll see output like:

Deploying function 'hello-world'...
✓ Function validated successfully
✓ Authentication verified
✓ Files packaged (2.3 KB)
✓ Upload complete
✓ Function deployed successfully

Function ID: func-abc123def456
Status: Active

Test the Function

Your function is now deployed and accessible via HTTP. Functions are accessible at URLs following this pattern: https://{funcName}-{orgId}.telnyxcompute.com Test your deployed function:

curl https://hello-world-abc123.telnyxcompute.com \
  -H "Content-Type: application/json" \
  -d '{"test": "data"}'

Response:

{
  "message": "Hello from Telnyx Edge Compute!",
  "status": "success"
}

Success! The Function is Live

Your function is now running and ready to handle HTTP requests. Functions automatically scale based on demand.

Function Anatomy

Every Telnyx Edge Compute function consists of three essential components:

Function Code

The main application code that handles HTTP requests and responses:

# Python example
import json

async def handler(request):
    data = await request.json()
    
    return Response(
        json.dumps({
            "message": "Hello from the edge",
            "received": data
        }),
        headers={"Content-Type": "application/json"}
    )

// Go example  
func handler(w http.ResponseWriter, r *http.Request) {
    response := map[string]string{
        "message": "Hello from the edge",
        "method":  r.Method,
        "path":    r.URL.Path,
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(response)
}

// Java (Quarkus) example
@Path("/")
public class EdgeResource {
    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public Response handler(Map<String, Object> data) {
        return Response.ok(Map.of(
            "message", "Hello from the edge",
            "received", data
        )).build();
    }
}

Runtime Dependencies

Language-specific dependency files that define required packages:

# requirements.txt (Python)
telnyx>=2.0.0
requests>=2.28.0

// go.mod (Go)
module my-edge-function

go 1.21

<!-- pom.xml (Java/Quarkus) -->
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-resteasy-reactive-jackson</artifactId>
</dependency>

Function Configuration

The func.toml file that defines deployment and runtime configuration:

[edge_compute]
func_id = "func-abc123def456"
func_name = "hello-world"

[env_vars]
MY_KEY = "VAL"

Next Steps

Now that your function is deployed, explore these topics to go deeper:

Runtime APIs - Request/response patterns and the platform interface.
Execution Model - Function lifecycle, cold starts, and container behavior.
Configuration - Environment variables, secrets, and bindings.
Local Development - Build, test, and debug functions locally.
CLI Reference - All available CLI commands.

Overview

Getting Started

Examples

To Develop

To Test

To Deploy

To Monitor

Reference

Tutorial Objectives

Prerequisites

Install the CLI

Download Binary

Authenticate

Option 1: OAuth (Recommended)

Option 2: API Key

Verify Authentication

Create a Function

Function Code

Function Code

Function Code

Function Code

Deploy the Function

Test the Function

Success! The Function is Live

Function Anatomy

Function Code

Runtime Dependencies

Function Configuration

Next Steps

Overview

Getting Started

Examples

To Develop

To Test

To Deploy

To Monitor

Reference

​Tutorial Objectives

​Prerequisites

​Install the CLI

​Download Binary

​Authenticate

​Option 1: OAuth (Recommended)

​Option 2: API Key

​Verify Authentication

​Create a Function

​Function Code

​Function Code

​Function Code

​Function Code

​Deploy the Function

​Test the Function

​Success! The Function is Live

​Function Anatomy

​Function Code

​Runtime Dependencies

​Function Configuration

​Next Steps

Tutorial Objectives

Prerequisites

Install the CLI

Download Binary

Authenticate

Option 1: OAuth (Recommended)

Option 2: API Key

Verify Authentication

Create a Function

Function Code

Function Code

Function Code

Function Code

Deploy the Function

Test the Function

Success! The Function is Live

Function Anatomy

Function Code

Runtime Dependencies

Function Configuration

Next Steps