Azion CLI quickstart

Install the Azion CLI, create a JavaScript function project, run it locally, and deploy it to Azion from your terminal.

Last updated

View as Markdown Agent setup

This guide instructs you through your first deployment with the Azion CLI.

  • Install the CLI and save your personal token in it.
  • Create a JavaScript function project with azion init.
  • Run the function on your machine with azion dev.
  • Deploy the function with azion deploy and request it over HTTPS.

The azion deploy command creates five objects from the project, and each one links to the next:

  1. The function holds the code in src/function/index.js.
  2. The function instance binds the function to the application.
  3. The application carries a request rule, Execute Function, that runs the instance on every path.
  4. The workload serves the application on a domain.
  5. The deployment connects the workload to the application.

For more information about functions, refer to Functions.

Prerequisites

Install the CLI and log in

Install the Azion CLI with the install script:

curl -fsSL https://cli.azion.app/install.sh | bash

If you use Homebrew, install the azion formula instead:

brew install azion

Either command puts the azion binary on your path. Confirm the installed version:

azion version

The command prints the version:

Azion CLI 4.23.0

Save your personal token in the CLI. Replace [TOKEN VALUE] with your token:

azion -t [TOKEN VALUE]

The CLI stores the token locally, and later commands use it without the flag. Confirm the account the CLI uses:

azion whoami

The command prints the client ID and email of the account, and the active profile:

Text
01 Client ID: 1234u
02 Email: you@example.com
03 Active Profile: default

The CLI is installed and authorized on your account.

Create the project

The azion init command creates the project from a preset and a template. Create a project named my-function:

azion init --name my-function

Without --name, the command asks for the name and suggests a random one. The command then asks five questions. Answer them in this order:

Select the Javascript preset

At ? Choose a preset:, use the arrow keys to select Javascript.

Select the Hello World template

At ? Choose a template:, select Hello World.

Install the dependencies

At Do you want to install project dependencies?, enter Y.

Skip the local development server

At Do you want to start a local development server?, enter n. azion dev starts it later.

Skip the deploy

At Do you want to deploy your project?, enter n. azion deploy deploys it later.

The command fetches the template, installs the dependencies, and confirms the project:

Text
01? Choose a preset: Javascript
02? Choose a template: Hello World
03
04Fetching selected template...
05
06Template successfully fetched
07Template successfully configured
08🤔 Do you want to install project dependencies? This may be required to generate initial configuration file (Y/n) Y
09Installing application dependencies
10up to date, audited 1 package in 399ms
11found 0 vulnerabilities
12…
13[Azion] [Build] › ℹ info Using preset: javascript
14[Azion] [Build] › ✔ success Build completed successfully with only azion.config
15[Azion] [IaC] › ✔ success Manifest generated successfully at <project-dir>/.edge/manifest.json
16🤔 Do you want to start a local development server? (y/N) n
17If you want to start a local development server later, run 'azion dev'
18Make sure to change to the new working directory before running building or deploying your project
19🤔 Do you want to deploy your project? (y/N) n
20If you want to deploy your application later, run 'azion deploy'
21Make sure to change to the new working directory before running building or deploying your project
22Your application my-function was initialized successfully

The project is in a new my-function directory, with these files:

Text
01.
02./.edge
03./.edge/manifest.json
04./.gitignore
05./azion
06./azion.config.mjs
07./azion/azion.json
08./index.js
09./info.json
10./package-lock.json
11./package.json
12./README.md
13./src
14./src/function
15./src/function/index.js

The template writes the function to src/function/index.js. It answers every request with Hello World!:

JavaScript
01/**
02 * Handle Request
03 * This is the input function where you can perform your implementation.
04 * @param {Request} request https://developer.mozilla.org/en-US/docs/Web/API/Request
05 * @param {*} args function args e.g args.my_secret
06 * @returns {Response} https://developer.mozilla.org/en-US/docs/Web/API/Response
07 */
08async function handleRequest(request, args) {
09 const message = `Hello World!`;
10
11 return new Response(message, {
12 headers: {
13 "content-type": "text/plain;charset=UTF-8",
14 },
15 status: 200,
16 });
17}
18
19export { handleRequest };

Replace the contents of src/function/index.js with the following code. The function then returns the path and method of each request as JSON:

JavaScript
01/**
02 * Handle Request
03 * This is the input function where you can perform your implementation.
04 * @param {Request} request https://developer.mozilla.org/en-US/docs/Web/API/Request
05 * @param {*} args function args e.g args.my_secret
06 * @returns {Response} https://developer.mozilla.org/en-US/docs/Web/API/Response
07 */
08async function handleRequest(request, args) {
09 const url = new URL(request.url);
10 const body = { message: "Hello from my-function", path: url.pathname, method: request.method };
11
12 return new Response(JSON.stringify(body), {
13 headers: {
14 "content-type": "application/json;charset=UTF-8",
15 },
16 status: 200,
17 });
18}
19
20export { handleRequest };

The my-function project holds the function code and is ready to run.

Run the function locally

The dev, build, and deploy commands run from inside the project directory. Go to the my-function directory:

cd my-function

Start the local development server:

azion dev

The command builds the function and serves it on port 3333:

Text
01…
02[Azion] [Build] › ℹ info Using preset: javascript
03[Azion] [Pre-Build] › ℹ info Starting pre-build...
04[Azion] [Pre-Build] › ℹ info Pre-build completed successfully
05[Azion] [Build] › ℹ info Using preset default entry: index.js
06[Azion] [Build] › ⚠ warning DEPRECATED: Migrate handler to → export default { fetch: (request, env, ctx) => {...} }
07[Azion] [Build] › ℹ info Starting build...
08[Azion] [Build] › ✔ success Build completed successfully
09[Azion] [Post-Build] › ℹ info Starting post-build...
10[Azion] [Post-Build] › ✔ success Post-build completed successfully
11[Azion] [Server] › ✔ success Function running on port 0.0.0.0:3333, url: http://localhost:3333
12[Azion] [Server] › ℹ info Initial scan complete. Ready for changes.

The server keeps the terminal busy. In a second terminal, request a path from the server:

curl -s -i 'http://localhost:3333/hello?x=1'

The function answers with a JSON body:

Text
01HTTP/1.1 200 OK
02content-type: application/json;charset=UTF-8
03Date: Thu, 01 Jan 2026 12:00:00 GMT
04Connection: keep-alive
05Keep-Alive: timeout=5
06Transfer-Encoding: chunked
07
08{"message":"Hello from my-function","path":"/hello","method":"GET"}

The function runs on your machine and returns the path and method of the request.

Deploy the function

The azion deploy command uploads the project, builds it, and creates the function, the application, and the workload. From the my-function directory, deploy the project:

azion deploy

The command prints the domain of the workload:

Text
01Running deploy command
02Uploading source files
03
04Upload completed successfully!
05Please visit https://console.azion.com/create/deploy/00000000-0000-0000-0000-000000000001 in case it did not open automatically, to follow up the full deploy process
06Your Application was deployed successfully
07
08To visualize your application access the Domain: https://xxxxxxxxxx.map.azionedge.net
09Your application is being deployed to all Azion Locations and it might take a few minutes.

The deploy records the ID of each object it created in azion/azion.json. Later deploys read this file to update the same objects:

JSON
01{
02 "name": "my-function",
03 "preset": "javascript",
04 …
05 "function": [
06 {
07 "id": 12360,
08 "name": "my-function",
09 …
10 "instance-id": 12363,
11 …
12 }
13 ],
14 "application": {
15 "id": 1234567893,
16 "name": "my-function"
17 },
18 …
19 "rules-engine": {
20 …
21 "rules": [
22 {
23 "id": 123461,
24 "name": "Execute Function",
25 "phase": "request"
26 }
27 ]
28 },
29 …
30 "workloads": {
31 "id": 1234567903,
32 "name": "my-function",
33 …
34 "url": "https://xxxxxxxxxx.map.azionedge.net",
35 "deployment_id": [
36 {
37 "id": 123473,
38 "name": "my-function"
39 }
40 ]
41 },
42 …
43}

The first deploy can take several minutes to answer from every location. Until a location has the function, it answers 404 with a page titled There's nothing here yet. Wait and retry before you diagnose the deploy.

Check the deployed function

Request the same path from the domain that azion deploy printed. Replace <your-azion-domain> with that domain:

curl -s -i 'https://<your-azion-domain>/hello'

The function answers with the same JSON body it returned on your machine:

Text
01HTTP/2 200
02date: Thu, 01 Jan 2026 12:00:00 GMT
03content-type: application/json;charset=UTF-8
04x-azion-request-id: 0123456789abcdef0123456789abcdef
05x-azion-edge-location: <edge-location>
06alt-svc: h3=":443"; ma=86400
07
08{"message":"Hello from my-function","path":"/hello","method":"GET"}

The function runs on Azion’s distributed infrastructure and answers on the workload domain.

To change the function, edit src/function/index.js and run azion deploy again from the my-function directory. Later deploys take about two minutes to answer from every location.

Next steps

How Azion CLI worksPresets, the build, the azion.json file, profiles, and how the CLI finds your token.Resource commandsCreate, list, describe, update, and delete platform resources from the terminal.Build with a frameworkDeploy a site or an application built with a framework, such as Next.js, Astro, or Vue.FunctionsThe runtime, limits, and settings of the functions the CLI deploys.