Lightbug 🔥🐝- O primeiro framework Mojo HTTP

Mojo é uma linguagem que combina a legibilidade do Python com a velocidade do C++.

É útil para diferentes coisas, desde código de baixo nível próximo ao hardware, passando pelo design da API de back-end, até o mundo do Front-End e da Web. Mojo é poderoso o suficiente para escalar toda a pilha moderna. A linguagem também foi projetada tendo em mente a IA e o aprendizado de máquina – portanto, será particularmente útil para desenvolvedores de IA e cientistas de dados.

Mojo ainda é jovem. O ecossistema tem perdido as ferramentas para o desenvolvimento diário de software, como redes ou operações HTTP básicas.

É aqui que o Lightbug 🔥🐝 entra voando.

Lightbug 🔥🐝 é um framework HTTP simples escrito em Mojo puro, sem dependências externas por padrão. Ele serve de base para projetos mais complexos e permite desenvolver serviços Web como APIs, configurar roteamento básico ou até mesmo servir páginas HTML com Mojo, aproveitando os recursos dessa linguagem, como digitação estática e ótimo desempenho. .

Para começar, basta instalar o Mojo e o Git e clonar o repositório Lightbug Github:

 git clone https://github.com/saviorand/lightbug_http.git

Depois de clonado, mude para o diretório na linha de comando:

 cd lightbug_http

Em seguida, execute o servidor (sim, essa é a extensão do arquivo Mojo! 🔥):

 mojo lightbug.🔥

Você deverá ver a seguinte linha impressa no console:

 🔥🐝 Lightbug is listening on 0.0.0.0:8080 Ready to accept connections...

Agora, você pode começar a fazer solicitações ao seu servidor ou tentar abrir localhost:8080 ou 0.0.0.0:8080 no navegador – você deverá ver a tela de introdução. Bem-vindo à Web, estilo Mojo! Agora, vamos passar para a codificação real.

Embora o Lightbug ainda seja jovem, a funcionalidade central que as pessoas esperam poder desenvolver para a Web moderna já existe.

Observe que como ainda não existe um gerenciador de pacotes, você deve simplesmente incluir lightbug_http como uma subpasta dentro do seu próprio projeto. Isso funcionará como um pacote Mojo e permitirá importar ferramentas como web primitivas, servidores e muito mais do Lightbug.

Por exemplo, adicione isto ao topo do seu arquivo para importar o servidor:

 from lightbug_http.sys.server import SysServer

Isto irá importar uma implementação de servidor em Mojo puro. Se você quiser usar a implementação do Python, importe o PythonServer . Funcionará da mesma maneira.

Para criar um serviço HTTP, basta criar uma estrutura que satisfaça o traço HTTPService , o que significa que possui um método func com a seguinte assinatura:

 trait HTTPService: fn func(self, req: HTTPRequest) raises -> HTTPResponse: ...

Isso usa os primitivos integrados para receber um HTTPRequest , executar qualquer lógica personalizada que você escrever em Mojo ou Python e retornar um objeto HTTPResponse com alguns dados de volta ao consumidor da API.

Vamos fazer um serviço que imprima todas as solicitações enviadas para 0.0.0.0:8080 para o console. Para fazer isso, crie um arquivo chamado my_awesome_service.🔥 e cole o seguinte:

 from lightbug_http import * @value struct Printer(HTTPService): fn func(self, req: HTTPRequest) raises -> HTTPResponse: let body = req.body_raw print(String(body)) return OK(body) fn main() raises: var server = SysServer() let handler = Printer() server.listen_and_serve("0.0.0.0:8080", handler)

Execute mojo my_awesome_service.🔥 e envie a solicitação para 0.0.0.0:8080 de seus clientes de API favoritos, como Insomnia ou Bruno . Você deverá ver alguns detalhes sobre a solicitação impressa no console.

Parabéns! Você é oficialmente um desenvolvedor web Mojo agora 🔥.

No exemplo, inicializamos uma variável chamada handler com let (o que significa que ela não pode ser reatribuída) e a passamos para listen_and_serve como um segundo parâmetro para maior clareza.

Adicionar um decorador @value é opcional: se você for um Mojiciano avançado, poderá adicionar um método construtor __init__ . Funcionará da mesma forma; @value apenas gera este e outros métodos úteis automaticamente.

 struct Printer(HTTPService): fn __init__(inout self): print("Printer initialized!") fn func(self, req: HTTPRequest) raises -> HTTPResponse: let body = req.body_raw print(String(body)) return OK(body)

Você pode dizer, mas esse é apenas um caminho! As APIs modernas exigem muito mais do que isso.

Lightbug também pode fazer alguns roteamentos básicos:

 @value struct ExampleRouter(HTTPService): fn func(self, req: HTTPRequest) raises -> HTTPResponse: let body = req.body_raw let uri = req.uri() if uri.path() == "/": print("I'm on the index path!") if uri.path() == "/first": print("I'm on /first!") elif uri.path() == "/second": print("I'm on /second!") return OK(body)

Adicione isso ao seu my_awesome_service.🔥 e passe-o como um manipulador para o servidor:

 fn main() raises: var server = SysServer() let handler = ExampleRouter() server.listen_and_serve("0.0.0.0:8080", handler)

Agora você pode abrir seu navegador e ir para localhost:8080/first , localhost:8080/second para ver as alterações.

Essa funcionalidade deve fornecer uma base para desenvolver seus próprios aplicativos, bibliotecas e serviços que fazem uso de HTTP, aproveitando ao mesmo tempo a flexibilidade e as opções de personalização que uma estrutura/kit de ferramentas leve que é o lightbug_http pode fornecer.

Planejamos tornar o roteamento, bem como outras tarefas como autoria e geração de APIs a partir de uma especificação OpenAPI, projetar seu modelo de dados e construir aplicativos da web ainda mais agradáveis no futuro, construindo pacotes lightbug_api e lightbug_web . Confira nosso Roteiro para obter detalhes.

É isso para uma introdução ao Lightbug 🔥🐝 ! Espero que tenha sido útil.

Este é um projeto comunitário de código aberto e não comercial.

Marque ⭐ nosso repositório no Github , entre no Discord e veja como contribuir com seu código, para que possamos torná-lo ainda melhor para os colegas Mojicianos.

Até a próxima!