> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/comece-aqui/quickstart.md).

# Quickstart (10 min)

Em cinco passos você cria sua conta no portal, roda um Hello World durável na sua máquina, dispara a função pela API e vê a execução no Monitor.

Os passos com código estão em abas, uma por linguagem.

<figure><img src="https://1898946878-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FsJmS5ILPG5x2x5j0WyiV%2Fuploads%2FAVxtc1FgBa33bLTQscgH%2Fap-quickstart.svg?alt=media" alt="Os cinco passos do Quickstart no lugar onde cada um acontece: no portal, o projeto HelloWorld com o environment dev, o workload primeiroapp v0.0.1 (passo 1) e o Monitor, que mostra HelloWorld concluída (passo 5). Na sua máquina, a aplicação tem a function HelloWorld, que escreve no log (passo 2), e as variáveis SKAIL_WORKLOAD, SKAIL_NAMESPACE, SKAIL_KEY e SKAIL_SIDECAR (passo 3). A aplicação busca trabalho no workload, e outro terminal dispara POST /trigger/primeiroapp/v0.0.1/HelloWorld/{id} com os headers skail-key e Skail-namespace (passo 4)."><figcaption></figcaption></figure>

## Pré-requisitos

* Conta no skail. Por enquanto a criação de conta é feita pelo time de parcerias: escreva para <parcerias@skailhq.com> pedindo uma conta de teste.

{% tabs %}
{% tab title="C#" %}

* .NET 8.0 ou superior ([download](https://dotnet.microsoft.com/en-us/download)).
* Visual Studio, Rider ou VS Code.
* Acesso ao pacote `Skail.Platform.Runtime`.
  {% endtab %}

{% tab title="TypeScript" %}

* Node.js ([download](https://nodejs.org/)).
* Um editor com suporte a TypeScript, como o VS Code.
* Acesso aos pacotes `@skail/runtime` e `@skail/build`.
  {% endtab %}
  {% endtabs %}

{% hint style="info" %}
Ao final de cada passo está escrito o que você deve ver. Se não viu, pare e confira antes de seguir.
{% endhint %}

{% stepper %}
{% step %}

### Crie projeto, environment e workload no portal

Entre em [app.skailhq.com](https://app.skailhq.com/).

Projeto: é onde você agrupa suas aplicações. Em [Projetos](https://app.skailhq.com/projects), clique em Novo projeto e chame de `HelloWorld`.

<figure><img src="https://1898946878-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FsJmS5ILPG5x2x5j0WyiV%2Fuploads%2FFoURMvfcwPLGyUnJIpMa%2FZight%202026-05-17%20at%2010.33.11%20AM.jpg?alt=media" alt=""><figcaption></figcaption></figure>

Environment: é onde o código roda (dev, homologação, produção). Cada environment tem a própria chave e o próprio namespace. No menu Environment, clique em Novo Environment e chame de `dev`.

<figure><img src="https://1898946878-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FsJmS5ILPG5x2x5j0WyiV%2Fuploads%2Fs8G7UsLVnUWvlDc9wnYp%2FZight%202026-05-17%20at%2010.54.41%20AM.jpg?alt=media" alt=""><figcaption></figcaption></figure>

Workload: é a sua aplicação dentro do skail, identificada por nome e versão. Deixe as opções padrão e chame de `primeiroapp`. A versão inicial é `v0.0.1`.

<figure><img src="https://1898946878-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FsJmS5ILPG5x2x5j0WyiV%2Fuploads%2F7azxqGewMApDoCj5BlYQ%2FZight%202026-05-17%20at%2010.56.05%20AM.jpg?alt=media" alt=""><figcaption></figcaption></figure>

{% hint style="success" %}
O que você deve ver: o workload `primeiroapp` listado no environment `dev`, e na tela do environment a chave (`SKAIL_KEY`), o namespace (`SKAIL_NAMESPACE`) e a URL base da API. Tenha também o endereço do skail, fornecido para o environment. Chave, namespace e endereço do skail você usa no passo 3; a URL base, no passo 4.
{% endhint %}
{% endstep %}

{% step %}

### Crie o projeto

{% tabs %}
{% tab title="C#" %}
Baixe o template em [github.com/skaildev](https://github.com/skaildev/.github/tree/main/Templates/DotNet) e instale:

```bash
dotnet new install SkailHQ.ApplicationTemplate.CSharp.1.0.0.nupkg
dotnet new skail -n HelloWorld
cd HelloWorld
```

O template já traz o pacote `Skail.Platform.Runtime`, o `[assembly: VisibleToSkailPlatform]` e o `builder.UseSkail()` no `Program.cs`. Se você preferir partir de um Worker Service seu, é isto que precisa existir:

{% code lineNumbers="true" %}

```csharp
// Program.cs
using Microsoft.Extensions.Hosting;
using Skail.Platform.Runtime.Hosting;
using Skail.Platform.Runtime.Standard;

[assembly: VisibleToSkailPlatform]

var builder = Host.CreateApplicationBuilder(args);
builder.UseSkail();

await builder.Build().RunAsync();
```

{% endcode %}
{% endtab %}

{% tab title="TypeScript" %}
Crie um projeto Node.js com TypeScript e adicione os pacotes `@skail/runtime` e `@skail/build`. O host da aplicação é o `main.ts`: ele carrega o bundle gerado pelo build e fica buscando trabalho no skail.

{% code lineNumbers="true" %}

```typescript
// main.ts
import { createSkailPlatform } from "@skail/runtime";

const controller = new AbortController();
for (const signal of ["SIGINT", "SIGTERM"] as const) {
  process.once(signal, () => controller.abort());
}

const platform = createSkailPlatform({
  bundle: ".skail/skail-functions.mjs",
  manifest: ".skail/manifest.json",
});

await platform.run(controller.signal);
```

{% endcode %}
{% endtab %}
{% endtabs %}

Agora crie a function:

{% tabs %}
{% tab title="C#" %}
{% code lineNumbers="true" %}

```csharp
using Microsoft.Extensions.Logging;
using Skail.Platform.Runtime.Standard;
using Skail.Platform.Runtime.Standard.Threading;
using Skail.Platform.Runtime.Threading;

public class HelloWorldFunctions
{
    private readonly ILogger<HelloWorldFunctions> _logger;

    public HelloWorldFunctions(ILogger<HelloWorldFunctions> logger)
    {
        _logger = logger;
    }

    [SkailFunction]
    public async SkailTask HelloWorld()
    {
        _logger.LogInformation("Hello World na execução {TaskId}", SkailContext.Current.TaskId);
    }
}
```

{% endcode %}
{% endtab %}

{% tab title="TypeScript" %}
{% code lineNumbers="true" %}

```typescript
// hello.ts
import { SkailContext, SkailFunction } from "@skail/runtime";

export class HelloWorldFunctions {
  @SkailFunction()
  async HelloWorld(): Promise<void> {
    console.info(`Hello World na execução ${SkailContext.current.taskId}`);
  }
}
```

{% endcode %}
{% endtab %}
{% endtabs %}

O método é público, de instância (não `static`) e `async`, e o build confere essas regras. Em C#, o analyzer do skail cobra também o retorno `SkailTask` (não `Task`), e a classe e o método precisam ter nomes diferentes. O nome do método, `HelloWorld`, é o que aparece na URL de disparo.

Gere o build:

{% tabs %}
{% tab title="C#" %}

```bash
dotnet build
```

{% hint style="success" %}
O que você deve ver: o build sem erros. O aviso CS1998 (método `async` sem `await`) é esperado aqui e some no próximo tutorial, quando a function passa a chamar commands.
{% endhint %}
{% endtab %}

{% tab title="TypeScript" %}
O entry point exporta as classes com functions e commands. A partir dele, o `skail build` gera o bundle e o manifest que o `main.ts` carrega.

{% code lineNumbers="true" %}

```typescript
// src/entries/app.ts
export { HelloWorldFunctions } from "../hello.js";
```

{% endcode %}

```bash
node_modules/.bin/skail build src/entries/app.ts --workload primeiroapp:v0.0.1 \
  --out .skail/skail-functions.mjs --manifest .skail/manifest.json
```

{% hint style="success" %}
O que você deve ver: o build sem erros, com os arquivos `.skail/skail-functions.mjs` e `.skail/manifest.json` criados.
{% endhint %}
{% endtab %}
{% endtabs %}
{% endstep %}

{% step %}

### Configure as variáveis de ambiente

O runtime lê a configuração de variáveis de ambiente com prefixo `SKAIL_` (em C#, também da seção `skail` do `appsettings.json`). Use os valores do environment `dev` anotados no passo 1, no mesmo terminal em que você vai rodar a aplicação no passo 4. No bash:

```bash
export SKAIL_WORKLOAD=primeiroapp:v0.0.1
export SKAIL_NAMESPACE=<namespace do environment>
export SKAIL_KEY=<chave do environment>
export SKAIL_SIDECAR=<endereço do skail, fornecido para o environment>
```

No PowerShell:

```powershell
$env:SKAIL_WORKLOAD="primeiroapp:v0.0.1"
$env:SKAIL_NAMESPACE="<namespace do environment>"
$env:SKAIL_KEY="<chave do environment>"
$env:SKAIL_SIDECAR="<endereço do skail, fornecido para o environment>"
```

`SKAIL_WORKLOAD` é `nome:versao` e precisa bater com o workload criado no portal: o skail usa esse valor para montar o endereço de cada função. `SKAIL_KEY` é segredo; não a coloque em arquivos versionados.

As quatro variáveis estão explicadas em [Como configurar o runtime](/opere/configurar-e-hospedar/configurar-o-runtime.md).

{% hint style="success" %}
O que você deve ver: nada ainda. É o próximo passo que valida.
{% endhint %}
{% endstep %}

{% step %}

### Rode a aplicação e dispare a função

{% tabs %}
{% tab title="C#" %}

```bash
dotnet run
```

{% endtab %}

{% tab title="TypeScript" %}
Rode o host (`main.ts`) a partir da pasta do projeto.
{% endtab %}
{% endtabs %}

{% hint style="success" %}
O que você deve ver: a aplicação sobe sem erro e fica em espera por trabalho. Deixe rodando.
{% endhint %}

Em outro terminal, dispare a função pela API HTTP. O caminho é `/trigger/{workload}/{versao}/{funcao}/{id}` e o corpo é um array com os argumentos da função (vazio, porque `HelloWorld` não recebe nada):

```bash
curl -X POST "https://SEU_SKAIL_BASE_URL/trigger/primeiroapp/v0.0.1/HelloWorld/00000000-0000-0000-0000-000000000001" \
  -H "Content-Type: application/json" \
  -H "skail-key: SUA_SKAIL_KEY" \
  -H "Skail-namespace: SEU_NAMESPACE" \
  -d '[]'
```

O último segmento é o identificador da execução: use um id de negócio (o id do pedido, da fatura) quando tiver um. Os headers `skail-key` e `Skail-namespace` são os mesmos valores das variáveis de ambiente.

{% hint style="success" %}
O que você deve ver: resposta 2xx no cURL e, no terminal da aplicação, o log da execução de `HelloWorld`. Se recebeu 401 ou 403, confira chave e namespace; se a execução não apareceu, confira se `SKAIL_WORKLOAD` é exatamente `primeiroapp:v0.0.1`.
{% endhint %}
{% endstep %}

{% step %}

### Veja a execução no Monitor

No portal, abra o environment `dev` e clique em Monitor. A execução que você disparou aparece com o TaskId (o id que você passou na URL), o estado (concluída), a função (`HelloWorld`) e a linha do tempo.

Cada `await` de uma function vira um ponto nessa linha do tempo. Como `HelloWorld` ainda não tem nenhum `await`, ela tem só início e fim. No próximo tutorial você adiciona um command e um evento externo e vê os checkpoints aparecerem.

{% hint style="success" %}
O que você deve ver: uma execução concluída no Monitor. Se não apareceu, o disparo não chegou ao environment certo: confira a URL base e o namespace.
{% endhint %}
{% endstep %}
{% endstepper %}

## Próximos passos

[Próximo nível: Command, evento externo e Monitor](/comece-aqui/quickstart/proximo-nivel-command-evento-externo-e-monitor-20-minutos.md) continua deste projeto e mostra os três conceitos que sustentam o skail, em 20 minutos. Se preferir entender antes de codar, [Modelo de programação](/construa/conceitos/functions-e-commands.md). Para colocar algo real em produção, [Como configurar o runtime](/opere/configurar-e-hospedar/configurar-o-runtime.md).