# Primeiros passos com a Azion CLI

Este guia orienta você no seu primeiro deploy com a Azion CLI.

- Instale a CLI e salve o seu personal token nela.
- Crie um projeto de function em JavaScript com `azion init`.
- Execute a function na sua máquina com `azion dev`.
- Faça o deploy da function com `azion deploy` e faça uma requisição a ela por HTTPS.

O comando `azion deploy` cria cinco objetos a partir do projeto, e cada um se liga ao seguinte:

1. A **function** guarda o código em `src/function/index.js`.
2. A **function instance** vincula a function à aplicação.
3. A [aplicação](/pt-br/documentacao/plataforma/applications/) tem uma regra de requisição, `Execute Function`, que executa a instância em todos os caminhos.
4. O [workload](/pt-br/documentacao/plataforma/workloads/) atende a aplicação em um domínio.
5. O **deployment** conecta o workload à aplicação.

Para mais informações sobre functions, consulte [Functions](/pt-br/documentacao/plataforma/functions/).

---

## Pré-requisitos

- Uma conta Azion. Para criar uma, consulte [Criar uma conta](/pt-br/documentacao/fundamentos/criar-uma-conta/).
- Um personal token. Para criar um, consulte [Como criar um personal token](/pt-br/documentacao/guias/plataforma/conta-e-billing/personal-tokens/). A CLI também gerencia tokens com [Azion CLI personal-token](/pt-br/documentacao/devtools/cli/recursos/personal-token/).
- Node.js e npm. A CLI executa o Azion bundler com `npx` para fazer o build do projeto.

---

## Instale a CLI e faça login

Instale a Azion CLI com o script de instalação:

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

Se você usa Homebrew, instale a fórmula `azion`:

```bash
brew install azion
```

Os dois comandos colocam o binário `azion` no seu path. Confirme a versão instalada:

```bash
azion version
```

O comando imprime a versão:

```text
Azion CLI 4.23.0
```

Salve o seu personal token na CLI. Substitua `[TOKEN VALUE]` pelo seu token:

```bash
azion -t [TOKEN VALUE]
```

A CLI guarda o token localmente, e os comandos seguintes o usam sem a flag. Confirme a conta que a CLI usa:

```bash
azion whoami
```

O comando imprime o client ID e o email da conta, e o perfil ativo:

```text
 Client ID: 1234u
 Email: you@example.com
 Active Profile: default
```

A CLI está instalada e autorizada na sua conta.

---

## Crie o projeto

O comando `azion init` cria o projeto a partir de um preset e de um template. Crie um projeto chamado `my-function`:

```bash
azion init --name my-function
```

Sem `--name`, o comando pergunta o nome e sugere um nome aleatório. Em seguida, o comando faz cinco perguntas. Responda nesta ordem:

1. **Selecione o preset Javascript**

   Em `? Choose a preset:`, use as setas do teclado para selecionar *Javascript*.

2. **Selecione o template Hello World**

   Em `? Choose a template:`, selecione *Hello World*.

3. **Instale as dependências**

   Em `Do you want to install project dependencies?`, digite `Y`.

4. **Pule o servidor de desenvolvimento local**

   Em `Do you want to start a local development server?`, digite `n`. O `azion dev` o inicia depois.

5. **Pule o deploy**

   Em `Do you want to deploy your project?`, digite `n`. O `azion deploy` faz o deploy dele depois.

O comando busca o template, instala as dependências e confirma o projeto:

```text
? Choose a preset: Javascript
? Choose a template: Hello World

Fetching selected template...

Template successfully fetched
Template successfully configured
🤔 Do you want to install project dependencies? This may be required to generate initial configuration file (Y/n) Y
Installing application dependencies
up to date, audited 1 package in 399ms
found 0 vulnerabilities
…
[Azion] [Build] › ℹ  info      Using preset: javascript
[Azion] [Build] › ✔  success   Build completed successfully with only azion.config
[Azion] [IaC] › ✔  success   Manifest generated successfully at <project-dir>/.edge/manifest.json
🤔 Do you want to start a local development server? (y/N) n
If you want to start a local development server later, run 'azion dev'
Make sure to change to the new working directory before running building or deploying your project
🤔 Do you want to deploy your project? (y/N) n
If you want to deploy your application later, run 'azion deploy'
Make sure to change to the new working directory before running building or deploying your project
Your application my-function was initialized successfully
```

O projeto fica em um novo diretório `my-function`, com estes arquivos:

```text
.
./.edge
./.edge/manifest.json
./.gitignore
./azion
./azion.config.mjs
./azion/azion.json
./index.js
./info.json
./package-lock.json
./package.json
./README.md
./src
./src/function
./src/function/index.js
```

O template grava a function em `src/function/index.js`. Ela responde a todas as requisições com `Hello World!`:

```javascript
/**
 * Handle Request
 * This is the input function where you can perform your implementation.
 * @param {Request} request https://developer.mozilla.org/en-US/docs/Web/API/Request
 * @param {*} args function args e.g args.my_secret
 * @returns {Response} https://developer.mozilla.org/en-US/docs/Web/API/Response
 */
async function handleRequest(request, args) {
  const message = `Hello World!`;

  return new Response(message, {
    headers: {
      "content-type": "text/plain;charset=UTF-8",
    },
    status: 200,
  });
}

export { handleRequest };
```

Substitua o conteúdo de `src/function/index.js` pelo código a seguir. A function passa a retornar o caminho e o método de cada requisição em JSON:

```javascript
/**
 * Handle Request
 * This is the input function where you can perform your implementation.
 * @param {Request} request https://developer.mozilla.org/en-US/docs/Web/API/Request
 * @param {*} args function args e.g args.my_secret
 * @returns {Response} https://developer.mozilla.org/en-US/docs/Web/API/Response
 */
async function handleRequest(request, args) {
  const url = new URL(request.url);
  const body = { message: "Hello from my-function", path: url.pathname, method: request.method };

  return new Response(JSON.stringify(body), {
    headers: {
      "content-type": "application/json;charset=UTF-8",
    },
    status: 200,
  });
}

export { handleRequest };
```

O projeto `my-function` guarda o código da function e está pronto para ser executado.

---

## Execute a function localmente

Os comandos `dev`, `build` e `deploy` são executados de dentro do diretório do projeto. Vá para o diretório `my-function`:

```bash
cd my-function
```

Inicie o servidor de desenvolvimento local:

```bash
azion dev
```

O comando faz o build da function e a serve na porta 3333:

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

O servidor ocupa o terminal. Em um segundo terminal, faça uma requisição a um caminho do servidor:

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

A function responde com um corpo JSON:

```text
HTTP/1.1 200 OK
content-type: application/json;charset=UTF-8
Date: Thu, 01 Jan 2026 12:00:00 GMT
Connection: keep-alive
Keep-Alive: timeout=5
Transfer-Encoding: chunked

{"message":"Hello from my-function","path":"/hello","method":"GET"}
```

A function é executada na sua máquina e retorna o caminho e o método da requisição.

---

## Faça o deploy da function

O comando `azion deploy` envia o projeto, faz o build dele e cria a function, a aplicação e o workload. No diretório `my-function`, faça o deploy do projeto:

```bash
azion deploy
```

O comando imprime o domínio do workload:

```text
Running deploy command
Uploading source files

Upload completed successfully!
Please 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
Your Application was deployed successfully

To visualize your application access the Domain: https://xxxxxxxxxx.map.azionedge.net
Your application is being deployed to all Azion Locations and it might take a few minutes.
```

O deploy registra o ID de cada objeto que criou em `azion/azion.json`. Os deploys seguintes leem esse arquivo para atualizar os mesmos objetos:

```json
{
  "name": "my-function",
  "preset": "javascript",
  …
  "function": [
    {
      "id": 12360,
      "name": "my-function",
      …
      "instance-id": 12363,
      …
    }
  ],
  "application": {
    "id": 1234567893,
    "name": "my-function"
  },
  …
  "rules-engine": {
    …
    "rules": [
      {
        "id": 123461,
        "name": "Execute Function",
        "phase": "request"
      }
    ]
  },
  …
  "workloads": {
    "id": 1234567903,
    "name": "my-function",
    …
    "url": "https://xxxxxxxxxx.map.azionedge.net",
    "deployment_id": [
      {
        "id": 123473,
        "name": "my-function"
      }
    ]
  },
  …
}
```

O primeiro deploy pode levar vários minutos para responder em todas as localidades. Enquanto uma localidade não tem a function, ela responde `404` com uma página intitulada `There's nothing here yet`. Aguarde e tente de novo antes de diagnosticar o deploy.

---

## Verifique a function após o deploy

Faça uma requisição ao mesmo caminho no domínio que `azion deploy` imprimiu. Substitua `<your-azion-domain>` por esse domínio:

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

A function responde com o mesmo corpo JSON que retornou na sua máquina:

```text
HTTP/2 200 
date: Thu, 01 Jan 2026 12:00:00 GMT
content-type: application/json;charset=UTF-8
x-azion-request-id: 0123456789abcdef0123456789abcdef
x-azion-edge-location: <edge-location>
alt-svc: h3=":443"; ma=86400

{"message":"Hello from my-function","path":"/hello","method":"GET"}
```

A function é executada na infraestrutura distribuída da Azion e responde no domínio do workload.

Para alterar a function, edite `src/function/index.js` e execute `azion deploy` de novo no diretório `my-function`. Os deploys seguintes levam cerca de dois minutos para responder em todas as localidades.

---

## Próximos passos

- [Como a Azion CLI funciona](/pt-br/documentacao/devtools/cli/como-funciona.md): Os presets, o build, o arquivo azion.json, os perfis e como a CLI encontra o seu token.
- [Comandos de recursos](/pt-br/documentacao/devtools/cli/recursos.md): Crie, liste, descreva, atualize e exclua recursos da plataforma pelo terminal.
- [Desenvolva com um framework](/pt-br/documentacao/devtools/cli/guias.md): Faça o deploy de um site ou de uma aplicação criada com um framework, como Next.js, Astro ou Vue.
- [Functions](/pt-br/documentacao/plataforma/functions.md): O runtime, os limites e as configurações das functions das quais a CLI faz o deploy.
