Criando uma aplicação distribuída com ASP.NET Core e o Microsoft Orleans \| TreinaWeb               Promoção no ar   Matricule-se agora e garanta **54% de desconto**  

  Termina em   Tempo restante da oferta: 15 Horas 

 32 Min 

 02 Seg 

   Tempo restante da oferta: 15 32 02 

  [Assinar →](https://www.treinaweb.com.br/checkout/pagamento/plano/anual?cupom=TW-SCLIENTE26) 

   [                ](https://www.treinaweb.com.br)  Explorar  

 [ Quanto custa? ](#assinatura) [ FAQ ](https://www.treinaweb.com.br#faq) [Matricule-se](#assinatura) [ Entrar ](https://www.treinaweb.com.br/login) 

     [ Início ](https://www.treinaweb.com.br) [ Artigos ](https://www.treinaweb.com.br/blog) Criando uma aplicação distribuída com ASP.NET Core e o Microsoft Orleans  [ C# ](https://www.treinaweb.com.br/blog/categoria/csharp) [ ASP .NET ](https://www.treinaweb.com.br/blog/categoria/asp-net) [ .NET Core ](https://www.treinaweb.com.br/blog/categoria/net-core) 

# Criando uma aplicação distribuída com ASP.NET Core e o Microsoft Orleans

 Veja o exemplo de uma aplicação ASP.NET Core acessando os dados de um servidor cluster definido com o Microsoft Orleans.

 [ Wladimilson M. Nascimento ](https://www.treinaweb.com.br/blog/autor/wladimilson-m-nascimento) 9 anos atrás

  ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2018/04/05114901/ORLEANS-NET-CORE.png)  

Este é mais um artigo de uma série sobre o [Microsoft Orleans](https://dotnet.github.io/orleans/). Caso não tenha visto o primeiro, recomendo que o leia: [Conhecendo o Microsoft Orleans](https://www.treinaweb.com.br/blog/conhecendo-o-microsoft-orleans/ "Conhecendo o Microsoft Orleans").

Como dito no [artigo passado](https://www.treinaweb.com.br/blog/conhecendo-o-microsoft-orleans/ "artigo passado"), o Orleans está na segunda versão e uma das novidades dela é o suporte ao .NET Standard 2.0, desta forma, como o título indica, a aplicação demonstrada aqui utilizará este framework.

[  ![C# (C Sharp) - Introdução ao ASP.NET Core](https://d2knvm16wkt3ia.cloudfront.net/assets/svg-icon/csharp.svg)   Curso C# (C Sharp) - Introdução ao ASP.NET Core Conhecer o curso ](https://www.treinaweb.com.br/curso/csharp-avancado-introducao-ao-aspnet-core)

## Estrutura da solução

Antes de colocarmos a mão na massa, é importante entender como funciona a solução do Orleans. Esta biblioteca recomenda que um projeto que a implemente seja estruturado com no mínimo quatro projetos:

- **OrleansHost**: Este projeto irá criar um executável que iniciará os silos, os hosts do Orleans que conterá as instâncias dos grãos. É possível iniciar vários silos, que irão trabalhar em conjunto e compartilhar a carga.
- **GrainsInterfaces**: Este projeto contém as interfaces que definem todos os grãos contido nos silos.
- **Grains**: Este projeto contém a implementação de todos os grãos definidos em GrainsInterfaces. Por isso, ele é implementado em conjunto com o **OrleansHost**.
- **Inteface**: Este projeto pode ser qualquer projeto de interface, mas geralmente trata-se de API. Ele irá se conectar ao **OrleansHost**, por TCP, para ter acesso aos grãos.

Durante o desenvolvimento, o projeto interface e o **OrleansHost** podem ser executados em conjunto na mesma máquina. Mas em produção, geralmente eles são executados separadamente. O **OrleansHost** é implementado em um cluster e a interface em um servidor web.

Neste artigo, a solução será feita em uma máquina Mac OSX, utilizando a versão 2.1.4, em conjunto com o Visual Studio Code, pois amo este ambiente. Mas o Orleans fornece um [plugin](https://marketplace.visualstudio.com/items?itemName=sbykov.MicrosoftOrleansToolsforVisualStudio) de templates para o Visual Studio, que facilita a criação de projetos com esta biblioteca. Desta forma, caso esteja utilizando esta IDE recomendo que instale este plugin.

## Criando o projeto GrainsInterfaces

Como o projeto **Grains** necessita do **GrainsInterfaces** e o **OrleansHost** fará uso do **Grains**, o primeiro projeto que precisa ser criado é o **GrainsInterfaces**.

Caso esteja utilizando o Visual Studio com o plugin do Orleans instalado, crie um projeto com base no template “**Orleans Grain Interface Collection**. No meu ambiente, incialmente irei criar uma pasta chamada **OrleansDotNet**, e dentro dela uma solução:

```dos
dotnet new sln -n OrleansDotNet

```

Em seguida, um projeto **Class Library**:

```dos
dotnet new classlib -n GraosInterfaces

```

Neste projeto adicione a biblioteca `Microsoft.Orleans.OrleansCodeGenerator.Build`:

```dos
dotnet add package Microsoft.Orleans.OrleansCodeGenerator.Build

```

E adicione nele a interface abaixo:

```csharp
using System;
using Orleans;
using System.Threading.Tasks;

namespace OrleansDotNet.GraosInterfaces
{
    public interface IGraoContador: IGrainWithStringKey
    {
        Task Incremento(int incremento);
        Task GetContador();
    }
}

```

As interfaces grãos devem definir a implementação de uma das interfaces “`GrainWith*`” do Orleans e definir métodos que retornem uma `Task`, para métodos `void`, ou `Task`, caso o método retorne algum valor.

A interface implementada acima, `IGrainWithStringKey`, é utilizada para indicar que o código de identificação do grão será definido com uma string. Infelizmente a documentação do Orleans ainda não documenta bem todas as interfaces disponíveis, mas em um artigo futuro abordo todas.

## Criando o projeto Grains

Com a interface definida podemos implementá-la um um projeto *Grains*. Caso esteja utilizando o Visual Studio, crie um projeto com o template **Orleans Grain Class Collection**. No meu ambiente, irei criar um projeto *Class Library* chamado **Graos**:

```dos
dotnet new classlib -n Graos

```

E este projeto também precisa da referência abaixo:

```dos
dotnet add package Microsoft.Orleans.OrleansCodeGenerator.Build

```

Em seguida, referencie o projeto de interface:

```dos
dotnet add Graos.csproj reference ../GraosInterfaces/GraosInterfaces.csproj

```

Agora podemos implementar o nosso grão:

```csharp
using System;
using Orleans;
using System.Threading.Tasks;
using OrleansDotNet.GraosInterfaces;

namespace OrleansDotNet.Graos
{
    public class GraoContador: Grain, IGraoContador
    {
        private int _contador;

        public Task Incremento(int incremento)
        {
            _contador += incremento;
            return Task.CompletedTask;
        }

        public Task GetContador()
        {
            return Task.FromResult(_contador);
        }
    }
}

```

Esta classe não tem segredo, o importante é implementar a nossa interface grão e herdar a classe `Grain`. Dentro dela é definido um contador simples.

## Criando o projeto OrleansHost

Com o grão definido, podemos definir o nosso silo (host). Caso esteja utilizando o Visual Studio, crie um projeto com base no template “**Orleans Dev/Test Host**”.

No meu ambiente irei criar uma aplicação console chamada **Silo**:

```dos
dotnet new console -n Silo

```

Nele adicione adicione uma referência para a biblioteca `Microsoft.Orleans.Server`:

```dos
dotnet add package Microsoft.Orleans.Server

```

Como iremos registrar o log do silo do console, adicione a referencia abaixo:

```dos
dotnet add package Microsoft.Extensions.Logging.Console

```

Por fim, adicione a referencia do projeto **Graos**:

```dos
dotnet add Silo.csproj reference ../Graos/Graos.csproj

```

E na classe `Program` adicione o código abaixo:

```csharp
using System;
using Orleans;
using Orleans.Runtime.Configuration;
using Orleans.Hosting;
using Orleans.Configuration;
using System.Threading.Tasks;
using OrleansDotNet.Graos;
using Microsoft.Extensions.Logging;
using System.Runtime.Loader;
using System.Threading;
using System.Net;

namespace OrleansDotNet.Silo
{
    class Program
    {
        private static ISiloHost silo;
        private static readonly ManualResetEvent siloStopped = new ManualResetEvent(false);

        static void Main(string[] args)
        {

            silo = new SiloHostBuilder()
                .UseLocalhostClustering()
                .Configure(options =>
                {
                    options.ClusterId = "OrleansDotNet-cluster";
                    options.ServiceId = "OrleansDotNet";
                })
                .Configure(options => options.AdvertisedIPAddress = IPAddress.Loopback)
                .ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(GraoContador).Assembly).WithReferences())
                .ConfigureLogging(logging => logging.AddConsole())
                .Build();

            Task.Run(StartSilo);

            AssemblyLoadContext.Default.Unloading += context =>
            {
                Task.Run(StopSilo);
                siloStopped.WaitOne();
            };

            siloStopped.WaitOne();

        }

        private static async Task StartSilo()
        {
            await silo.StartAsync();
            Console.WriteLine("Silo iniciado");
        }

        private static async Task StopSilo()
        {
            await silo.StopAsync();
            Console.WriteLine("Silo parado");
            siloStopped.Set();
        }
    }
}

```

Nesta classe, estamos definindo que o Silo irá utilizar as configurações de um cluster local (`UseLocalhostClustering()`), também é definido as identificações do cluster, bem com o seu IP (`Configure()`). Por fim, se define o grão que será adicionado ao silo e onde o seu log deve ser exibido.

Com o silo definido, ele é iniciado. Ele só irá parar em caso de algum erro ou quando o usuário forçar a sua parada.

## Criando o projeto Interface

Com o Silo definido podemos criar a nossa aplicação interface. Neste projeto vou criar uma aplicação WebAPI chamada **InterfaceAPI**:

```dos
dotnet new webapi -n InterfaceApi

```

Aproveite e já vincule os projetos a solução:

```dos
dotnet sln OrleansDotNet.sln add **/*.csproj

```

Na api é necessário adicionar a referência `Microsoft.Orleans.Client`:

```dos
dotnet add package Microsoft.Orleans.Client

```

E referenciar o projeto **GraosInterfaces**:

```dos
dotnet add InterfaceApi.csproj reference ../GraosInterfaces/GraosInterfaces.csproj

```

Para trabalhar com “*dependency injection*”, vamos configurar o cliente do Orleans na classe `Startup` conforme o código abaixo:

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Orleans;
using Orleans.Runtime.Configuration;
using Orleans.Hosting;
using System.Net;
using Orleans.Configuration;
using OrleansDotNet.GraosInterfaces;

namespace InterfaceApi
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();

            services.AddSingleton(provider =>
            {
                var client = new ClientBuilder()
                            .UseLocalhostClustering()
                            .Configure(options =>
                            {
                                options.ClusterId = "OrleansDotNet-cluster";
                                options.ServiceId = "OrleansDotNet";
                            })
                            .ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(IGraoContador).Assembly).WithReferences())
                            .ConfigureLogging(logging => logging.AddConsole())
                            .Build();

                StartClientWithRetries(client).Wait();

                return client;
            });
        }

        private static async Task StartClientWithRetries(IClusterClient client)
        {
            for (var i=0; i
            {
                options.ClusterId = "OrleansDotNet-cluster";
                options.ServiceId = "OrleansDotNet";
            })
            .ConfigureApplicationParts(parts => parts.AddApplicationPart(typeof(IGraoContador).Assembly).WithReferences())
            .ConfigureLogging(logging => logging.AddConsole())
            .Build();

```

As diferenças é que agora estamos utilizando a classe `ClientBuilder` e se adiciona a interface `IGraoContador` (em detrimento a ` GraoContador` definida no host.

Nesta classe também foi definido o método `StartClientWithRetries` que tenta se conectar ao host 5 vezes antes de desistir. Quando a conexão for obtida, o objeto `client` é retornado.

Este cliente será obtido no controller, conforme o código abaixo:

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Orleans;
using OrleansDotNet.GraosInterfaces;

namespace InterfaceApi.Controllers
{
    [Route("api/[controller]")]
    public class ContadorController : Controller
    {
        private IClusterClient client;

        public ContadorController(IClusterClient client){
            this.client = client;
        }

        [HttpGet]
        public async Task Get()
        {
            var contador = client.GetGrain("TW-1");

            return await contador.GetContador();
        }

        [HttpPost]
        public async Task Post()
        {
            var contador = client.GetGrain("TW-1");
            await contador.Incremento(1);
        }
    }
}

```

Para obter o grão, utilizamos o método ` GetGrain`. A este método deve ser passado a chave do grão:

```csharp
var contador = client.GetGrain("TW-1");

```

Como definimos que a chave dele será uma string, acima estou passando uma string arbitrária. A partir da instância obtida os métodos do grão são chamados, como o `GetContador()`:

```csharp
return await contador.GetContador();

```

Com isso, nós estamos obtendo informações do nosso grão contido no silo.

Para finalizar, criei dentro da pasta `wwwroot` um arquivo HTML, onde os métodos da api são chamados:

```html

    Exemplo de Orleans, no ASP.NET Core *.*

                Contador: 0

                Incrementar

        $(document).ready(function () {
            $.get("api/contador/", function (value) {
                console.log('GET contador=' + value);

                $('#countValor').html(value);
            });

            $('#btnIncrement').click(function () {
                $.post("api/contador/", function () {
                    $.get("api/contador/", function (value) {
                        console.log('GET contador=' + value);

                        $('#countValor').html(value);
                    });
                });
                return false;
            });
        });

```

Pronto, a nossa aplicação está finalizada. Para testá-la, primeiro é necessário iniciar o Silo:

![](https://dkrn4sk0rn31v.cloudfront.net/2018/04/03142113/silo-start.png)

Em seguida a aplicação web:

![](https://dkrn4sk0rn31v.cloudfront.net/2018/04/03142943/api-start-e1522776688959.png)

No navegador teremos o resultado abaixo:

![](https://dkrn4sk0rn31v.cloudfront.net/2018/04/03142112/browser-zero.png)

Ao clicar em “*Incrementar*”, veremos o valor do contador ser incrementado:

![](https://dkrn4sk0rn31v.cloudfront.net/2018/04/03142111/broser-increment.png)

## Conclusão

Este é um exemplo simples, porém funcional, que nos dá uma noção do poder do Orleans. Em artigos futuros mostrarei mais detalhes dele.

Caso queria executar a aplicação demostrada aqui no curso, você pode vê-la aqui no [GitHub](https://github.com/wladimilson/OrleansDotNet "GitHub").

[  ![C# (C Sharp) - Introdução ao ASP.NET Core](https://d2knvm16wkt3ia.cloudfront.net/assets/svg-icon/csharp.svg)   Curso C# (C Sharp) - Introdução ao ASP.NET Core Conhecer o curso ](https://www.treinaweb.com.br/curso/csharp-avancado-introducao-ao-aspnet-core)

- [ #C# ](https://www.treinaweb.com.br/blog/tag/csharp)
- [ #.NET Core ](https://www.treinaweb.com.br/blog/tag/net-core)
- [ #Orleans ](https://www.treinaweb.com.br/blog/tag/orleans)
- [ #Web API ](https://www.treinaweb.com.br/blog/tag/web-api)

Autor

 ![Wladimilson M. Nascimento](//secure.gravatar.com/avatar/f0dd442f156a3eacd2880e9cd0eafbd1?d=mm)

## Wladimilson M. Nascimento

 Instrutor, nerd, cinéfilo e desenvolvedor nas horas vagas. Graduado em Ciências da Computação pela Universidade Metodista de São Paulo. 

 [Todos os artigos](https://www.treinaweb.com.br/blog/autor/wladimilson-m-nascimento)  

## Continue estudando

 Transforme leitura em prática com os cursos e formações da TreinaWeb.

 [Ver cursos](https://www.treinaweb.com.br/cursos)   

  Continue lendo

## Artigos relacionados

- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2019/08/14131229/HEALTH-CHECKS-400x280.png)  [ C# ](https://www.treinaweb.com.br/blog/categoria/csharp) 

     7 anos atrás

    ##  [ Verificando a integridade da aplicação ASP.NET Core com Health Checks ](https://www.treinaweb.com.br/blog/verificando-a-integridade-da-aplicacao-asp-net-core-com-health-checks) 

     Verificar e monitorar a integridade de uma aplicação web é algo essencial, principalmente em ambientes distribuídos. O ASP.NET Core facilita esta tarefa através de Health Checks, como você verá neste artigo.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2019/08/01172547/NET-CORE-3-400x280.png)  [ C# ](https://www.treinaweb.com.br/blog/categoria/csharp) 

     7 anos atrás

    ##  [ .NET Core 3.0 - Criando tarefas de segundo plano com Worker Service ](https://www.treinaweb.com.br/blog/net-core-3-0-criando-tarefas-de-segundo-plano-com-worker-service) 

     Você já quis criar tarefas em segundo plano com o .NET Core? Na versão 3.0 foi introduzido o template Worker Service que facilita a criação deste tipo de aplicação. Caso tenha passado por uma situação assim, neste artigo mostramos como você pode aproveitar este novo recurso do .NET Core 3.0.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2020/10/deploy-asp-net-core-linux-nginx-400x280.png)  [ ASP .NET ](https://www.treinaweb.com.br/blog/categoria/asp-net) 

     6 anos atrás

    ##  [ Publicando uma aplicação ASP.NET Core no Linux com o Nginx ](https://www.treinaweb.com.br/blog/publicando-uma-aplicacao-asp-net-core-no-linux-com-o-nginx) 

     Veja todo o processo de publicação de deploy de uma aplicação ASP.NET Core no Linux utilizando o Nginx.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2022/08/asp-net-conhecendo-as-minimal-api-400x280.png)  [ C# ](https://www.treinaweb.com.br/blog/categoria/csharp) 

     4 anos atrás

    ##  [ ASP.NET - Conhecendo a Minimal API ](https://www.treinaweb.com.br/blog/asp-net-conhecendo-as-minimal-api) 

     Neste artigo vamos conhecer um dos recursos que foram adicionados no .NET 6/ASP.NET 6, que é um novo template de aplicações Web, a Minimal API.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2019/11/04160959/instalador-aplicacoes-windows-400x280.png)  [ Desenvolvimento Back-end ](https://www.treinaweb.com.br/blog/categoria/desenvolvimento-back-end) 

     7 anos atrás

    ##  [ Criando um instalador para distribuir suas aplicações Windows ](https://www.treinaweb.com.br/blog/criando-um-instalador-para-distribuir-suas-aplicacoes-windows) 

     Existe uma gama de ferramentas que permitem a criação de um instalador do Windows. Neste artigo veja como criar um de forma simples utilizando o Inno Setup.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2021/03/criando-interfaces-graficas-no-c-com-gtk-400x280.png)  [ C ](https://www.treinaweb.com.br/blog/categoria/c) 

     6 anos atrás

    ##  [ Criando interfaces gráficas no C com GTK ](https://www.treinaweb.com.br/blog/criando-interfaces-graficas-no-c-com-gtk) 

     Aplicações Desktop ainda são muito utilizadas. Neste artigo aprenda como utilizar o GTK para criar interfaces gráficas no C.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2019/07/03181535/WINDOWS-PHP-400x280.png)  [ PHP ](https://www.treinaweb.com.br/blog/categoria/php) 

     7 anos atrás

    ##  [ Criando um ambiente de desenvolvimento PHP com WSL ](https://www.treinaweb.com.br/blog/criando-um-ambiente-de-desenvolvimento-php-com-wsl) 

     Nesse artigo vamos criar um ambiente de desenvolvimento PHP completo, com MySQL e Nginx dentro do WSL.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2021/04/utilizando-o-mysql-em-uma-aplicacao-c-400x280.png)  [ Desenvolvimento Back-end ](https://www.treinaweb.com.br/blog/categoria/desenvolvimento-back-end) 

     6 anos atrás

    ##  [ Utilizando o MySQL em uma aplicação C ](https://www.treinaweb.com.br/blog/utilizando-o-mysql-em-uma-aplicacao-c) 

     Veja as configurações necessárias para utilizar o MySQL em uma aplicação C.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2019/04/23151422/ARQUITETURA-FLUX-400x280.png)  [ Arquitetura de Software ](https://www.treinaweb.com.br/blog/categoria/arquitetura-de-software) 

     8 anos atrás

    ##  [ Flux - descubra o motivo do sucesso dessa arquitetura em grandes empresas ](https://www.treinaweb.com.br/blog/flux-descubra-o-motivo-do-sucesso-dessa-arquitetura-em-grandes-empresas) 

     Conheça a Arquitetura Flux e entenda o motivo dela estar se tornando cada vez mais requisitada no mercado de trabalho ao se desenvolver sistemas.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2018/04/05114857/ORLEANS-400x280.png)  [ Infraestrutura e Sistemas Operacionais ](https://www.treinaweb.com.br/blog/categoria/infraestrutura-e-sistemas-operacionais) 

     9 anos atrás

    ##  [ Conhecendo o Microsoft Orleans ](https://www.treinaweb.com.br/blog/conhecendo-o-microsoft-orleans) 

     Conheça o framework Microsoft Orleans e veja como ele tenta resolver o "problema" dos sistemas distribuídos.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2019/11/02163514/vscode-remote-400x280.png)  [ Desenvolvimento ](https://www.treinaweb.com.br/blog/categoria/desenvolvimento) 

     7 anos atrás

    ##  [ Desenvolvendo seus projetos com o VS Code Remote Development ](https://www.treinaweb.com.br/blog/desenvolvendo-seus-projetos-com-o-vs-code-remote-development) 

     Preparar nosso ambiente local de desenvolvimento pode ser uma tarefa bastante demorada. Pode levar horas, ou até dias para configurar todo o ambiente. Uma alternativa é utilizar um ambiente remoto para o desenvolvimento, porém sua experiência pode não ser a mesma que ao trabalhar em ambiente local. Isso tudo pode mudar com o VS Code Remote Development. Vamos entender nesse artigo como ele funciona.

     Ler artigo
- ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2021/03/TWELVE-FACTOR-APP-400x280.png)  [ Engenharia de Software ](https://www.treinaweb.com.br/blog/categoria/engenharia-de-software) 

     6 anos atrás

    ##  [ O que são os 12 factor app? - Parte 3 ](https://www.treinaweb.com.br/blog/o-que-sao-os-12-factor-app-parte-3) 

     Nesta terceira parte, iremos abordar mais três dos 12 princípios: port binding, concurrency e disposability.

     Ler artigo

## Um ano de acesso total para você viver de programação.

 Todos os cursos e formações da TreinaWeb numa única assinatura, com professores que atuam no mercado, suporte direto e certificados. Do primeiro `console.log` ao mercado de trabalho.

- **1 ano** de acesso a **todos os cursos**
- Cursos novos **toda semana**
- Suporte **direto com professores**
- Plano de carreira **personalizado**
- **Certificados digitais** inclusos
- **Aplicativos** para Android e iOS, com **acesso offline**

    **Garantia incondicional de satisfação** 

 Teste por 7 dias e, se não fizer sentido para você, devolvemos seu dinheiro.

### Acesso completo a todos os cursos e dezenas de Formações.

 12 meses 

  Economize R$ 840,00  54% OFF 

 de 12x R$ 129,00 por apenas

 12x  R$ 59,00

 sem juros no cartão de crédito ou R$ 599,00 à vista

  Oferta termina em  **15h 32min 02s**

- Acesso imediato e ilimitado durante 1 ano.
- Plano de carreira personalizado.
- Suporte direto com professores.
- E muito mais!

 [Matricule-se agora](https://www.treinaweb.com.br/checkout/pagamento/plano/anual?cupom=TW-SCLIENTE26)

     [                ](https://www.treinaweb.com.br)

 Escola online de programação, tecnologia e IA.

- [  ](https://www.facebook.com/TreinaWeb/)
- [  ](https://www.instagram.com/treinaweb/)
- [  ](https://www.youtube.com/user/TreinaWeb)
- [  ](https://twitter.com/treinaweb)
- [  ](https://www.linkedin.com/company/treinaweb)
- [  ](https://github.com/treinaweb)

## Inscreva-se em nossa newsletter

Receba lançamentos, promoções e novidades.

   Seu nome     Seu WhatsApp     Seu melhor e-mail   Inscrever-se 

## Cursos

- [ Base para Devs ](https://www.treinaweb.com.br/categoria/base-para-devs)
- [ Front-end ](https://www.treinaweb.com.br/categoria/desenvolvimento-front-end)
- [ Back-end ](https://www.treinaweb.com.br/categoria/desenvolvimento-back-end)
- [ Mobile ](https://www.treinaweb.com.br/categoria/desenvolvimento-mobile)
- [ Bancos de Dados ](https://www.treinaweb.com.br/categoria/bancos-de-dados)
- [ Cloud ](https://www.treinaweb.com.br/categoria/cloud-computing)
- [ IA ](https://www.treinaweb.com.br/categoria/ia)
- [ E mais ](https://www.treinaweb.com.br/categoria/e-mais)
- [ Ver todos os cursos ](https://www.treinaweb.com.br/cursos)

## Conteúdo

- [ Formações ](https://www.treinaweb.com.br/formacoes)
- [ Projetos práticos ](https://www.treinaweb.com.br/projetos-praticos)
- [ Direto ao ponto ](https://www.treinaweb.com.br/direto-ao-ponto)
- [ Planos ](https://www.treinaweb.com.br#assinatura)
- [ Depoimentos ](https://www.treinaweb.com.br#depoimentos)
- [ Comunidade ](https://www.treinaweb.com.br#comunidade)
- [ Corpo docente ](https://www.treinaweb.com.br#docente)

## A empresa

- [ Sobre a TreinaWeb ](https://www.treinaweb.com.br#sobre)
- [ Perguntas frequentes ](https://www.treinaweb.com.br#faq)
- [ Vantagens de estudar na TreinaWeb ](https://www.treinaweb.com.br/vantagens-de-estudar-na-treinaweb)
- [ Cursos para empresas ](https://www.treinaweb.com.br/empresas)
- [ Sugira um novo curso ](https://www.treinaweb.com.br/sugerir-curso)
- [ Trabalhe conosco ](https://www.treinaweb.com.br/trabalhe-conosco)
- [ Artigos ](https://www.treinaweb.com.br/blog)
- [ Desenvolvedores e agentes ](https://www.treinaweb.com.br/developers)
- [ Contato ](https://www.treinaweb.com.br/contato)
- [ Política de privacidade ](https://www.treinaweb.com.br/politica-de-privacidade)
- [ Termos de uso ](https://www.treinaweb.com.br/termos-de-uso)

## Baixe nosso aplicativo

 [   Disponível na **App Store**  ](https://apps.apple.com/us/app/treinaweb/id1322729447) [   Disponível no **Google Play**  ](https://play.google.com/store/apps/details?id=br.com.treinaweb.mobile) 

  Av. Paulista, 1765, Conj 71 e 72 · Bela Vista · São Paulo · SP · 01311-200   © 2004 – 2026 TreinaWeb Tecnologia LTDA · CNPJ 06.156.637/0001-58