> 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/aprender/readme.md).

# Quickstart C# .NET (10 minutos)

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.

## Pré-requisitos

* .NET 8.0 ou superior ([download](https://dotnet.microsoft.com/en-us/download)).
* Visual Studio, Rider ou VS Code.
* 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.
* Acesso ao pacote `Skail.Platform.Runtime`.

Ao final de cada passo está escrito o que você deve ver. Se não viu, pare e confira antes de seguir.

{% 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://4236258508-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIkEv091ItXQcCrn2HgUd%2Fuploads%2FVfBe6JANyRxDmzX8JMTv%2FZight%202026-05-17%20at%2010.33.11%20AM.jpg?alt=media&amp;token=809b987c-ef03-470f-bdfb-f4e7ec6eafd5" 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://4236258508-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIkEv091ItXQcCrn2HgUd%2Fuploads%2FSNwRiOBAHGLbstpyAna2%2FZight%202026-05-17%20at%2010.54.41%20AM.jpg?alt=media&amp;token=17971296-fccd-4d18-8706-31ac10c26212" 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://4236258508-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FIkEv091ItXQcCrn2HgUd%2Fuploads%2FzkSIrE8pgodvjrBilVQG%2FZight%202026-05-17%20at%2010.56.05%20AM.jpg?alt=media&amp;token=35fedb4f-cabe-4b27-ba19-e10f48cf43e8" alt=""><figcaption></figcaption></figure>

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.
{% endstep %}

{% step %}

### Crie o projeto .NET a partir do template

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:

```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();
```

Agora a função. Crie `HelloWorldFunctions.cs`:

```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);
    }
}
```

Quatro regras que o build cobra, pelo analyzer do skail: o método é `public`, de instância (não `static`), `async` e retorna `SkailTask` (não `Task`). A classe e o método precisam ter nomes diferentes. O nome do método, `HelloWorld`, é o que aparece na URL de disparo.

O que você deve ver: `dotnet 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.
{% endstep %}

{% step %}

### Configure as variáveis de ambiente

O runtime lê a configuração de variáveis de ambiente com prefixo `SKAIL_` (ou 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](/construir/configurar-e-hospedar/como-configurar-o-runtime.md).

O que você deve ver: nada ainda. É o próximo passo que valida.
{% endstep %}

{% step %}

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

```bash
dotnet run
```

O que você deve ver: a aplicação sobe sem erro e fica em espera por trabalho. Deixe rodando.

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.

O que você deve ver: resposta 2xx no cURL e, no terminal do `dotnet run`, 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`.
{% 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.

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.
{% endstep %}
{% endstepper %}

## Próximos passos

[Próximo nível: Command, evento externo e Monitor](/aprender/readme/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](/aprender/fundamentos/modelo-de-programacao.md). Para colocar algo real em produção, [Como configurar o runtime](/construir/configurar-e-hospedar/como-configurar-o-runtime.md).