Introdução

Neste tutorial, vamos explorar como construir sistemas resilientes utilizando Erlang, um dos paradigmas mais comuns no desenvolvimento de aplicações escaláveis e tolerantes a falhas. Usaremos o framework Cowboy para gerenciar servidores HTTP e o banco de dados Mnesia para armazenar dados em memória e em disco, oferecendo um acesso rápido e confiável. Este guia está voltado para desenvolvedores que desejam implementar soluções robustas e escaláveis, aproveitando as características únicas de Erlang, como a concorrência e a resiliência inherente. Ao final, você terá uma aplicação básica, capaz de lidar com diferentes cenários de carga e recuperação de falhas com eficiência.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter Erlang instalado em sua máquina. Você pode fazer o download a partir do site oficial do Erlang/OTP. Após a instalação, verifique a versão do Erlang utilizando o comando `erl -version`. Para este tutorial, utilizaremos um editor de texto como Visual Studio Code ou qualquer outro de sua escolha para programar.

    commands
    # Verificar versão do Erlang
    erl -version

  2. Criação do Projeto com Cowboy e Mnesia

    Crie uma nova pasta para o seu projeto. Dentro dela, crie um arquivo chamado `rebar.config` para iniciar seu projeto Erlang com Cowboy e Mnesia. O Rebar é uma ferramenta de construção para Erlang que facilita a gestão de dependências e a construção de projetos.

    rebar.config
    {deps, [{cowboy, '2.9.0'}, {mnesia, '1.0.0'}]}.

  3. Implementação do Servidor HTTP com Cowboy

    Crie um módulo chamado `my_app_http.erl`, onde configuraremos o servidor Cowboy para escutar requisições. Este módulo conterá as rotas e o tratamento das requisições HTTP básicas.

    my_app_http.erl
    -module(my_app_http).
-export([start/0]).

start() ->
    {ok, _} = cowboy:start_clear(my_http, 100,
        [{port, 8080}],
        #{env => #{dispatch => cowboy_router:compile([
            {'_', [{<<"/hello">>, hello_handler, []}]}])}}).
    ok.

  4. Criação do Handler para as Requisições

    Implemente o `hello_handler.erl`, que responderá a requisições HTTP e irá interagir com o banco de dados Mnesia para armazenar algum estado, como mensagens ou contadores.

    hello_handler.erl
    -module(hello_handler).
-export([init/2, handle/2, terminate/3]).

init(_Para, _Req) ->
    {ok, Req, #{}}.

handle(Req, State) ->
    {ok, Response} = cowboy:reply(200, #{<<"content-type">> => <<"text/plain">>}, <<"Hello, world!">>),
    {ok, Response, State}.

terminate(_Reason, _Req, _State) ->
    ok.

  5. Configuração do Banco de Dados Mnesia

    Crie um módulo chamado `my_app_mnesia.erl` para configuração e inicialização do banco de dados Mnesia. Configure suas tabelas e inicie o sistema de banco de dados no início da aplicação.

    my_app_mnesia.erl
    -module(my_app_mnesia).
-export([start/0, create_tables/0]).

start() ->
    mnesia:start(),
    create_tables().

create_tables() ->
    mnesia:create_table(my_table, [{attributes, record_info(fields, my_record)}]).

  6. Interação com Mnesia

    Implemente funcionalidades para armazenar e recuperar dados usando Mnesia. Por exemplo, crie funções para adicionar mensagens no banco de dados.

    my_app_mnesia.erl
    add_message(Message) ->
    mnesia:transaction(fun() ->
        mnesia:write({my_record, Message})
    end).

  7. Testando a Aplicação

    Após implementar as funcionalidades, use a ferramenta `curl` para testar os endpoints. Você pode iniciar o servidor e fazer requisições como a seguir.

    commands
    # Iniciando o servidor
    erl -pa ebin -s my_app_http
    # Realizando uma requisição
    curl http://localhost:8080/hello

  8. Verificação de Resiliência

    Implemente testes de resiliência através de simulações de falhas. Você pode usar ferramentas como `erl -eval` para testar a recuperação após uma falha de processo.

    commands
    # Testando resiliência
    erl -eval 'my_app_resilience:test()', halt().

Conclusão

Neste tutorial, você aprendeu a construir uma aplicação básica usando Erlang, Cowboy e Mnesia. Vimos como configurar um servidor HTTP, criar manipuladores para requisições e interagir com um banco de dados em memória. Esses conceitos são fundamentais para criar sistemas escaláveis e resilientes, que podem se recuperar rapidamente de falhas. Com esta base, você está preparado para desenvolver aplicações mais complexas, tirando pleno proveito da robustez que Erlang oferece.

Hashtags

#Erlang #Cowboy #Mnesia #DesenvolvimentoDeSoftware #SistemasResilientes