Sanic 'Hello World'

Antes de mergulhar no Sanic, certifique-se de ter Python 3.7 ou mais recente e o pip (o instalador de pacotes do Python) instalados em seu sistema. Sanic depende fortemente de recursos modernos do Python para suas capacidades assíncronas.

Você pode verificar sua versão do Python executando este comando em seu terminal:

python3 --version

Você deve ver uma saída como Python 3.x.x. Se precisar instalar ou atualizar o Python, visite python.org para a versão mais recente.

Usar um ambiente virtual é crucial para gerenciar dependências de projetos de forma eficaz. Ele garante que os pacotes do seu projeto Sanic não entrem em conflito com outros projetos Python ou com suas instalações globais.

Primeiro, crie um novo diretório para o seu projeto Sanic e navegue até ele:

mkdir sanic-hello-world
cd sanic-hello-world

Em seguida, crie um ambiente virtual dentro do diretório do seu projeto:

python3 -m venv .venv

Por fim, ative seu ambiente virtual:

# No macOS/Linux
source .venv/bin/activate

# No Windows (use Prompt de Comando)
.venv\Scripts\activate

Seu prompt de terminal agora deve mostrar (.venv), indicando que o ambiente virtual está ativo.

Com seu ambiente virtual ativo, você agora pode instalar Sanic e suas dependências usando pip.

pip install sanic

Este comando instalará Sanic e todos os seus componentes necessários, incluindo uvloop e httptools para desempenho máximo, se disponíveis em seu sistema.

Agora, vamos criar nossa primeira aplicação "Hello World" com Sanic. No diretório do seu projeto (sanic-hello-world), crie um novo arquivo chamado main.py.

Abra main.py em seu editor de código favorito e adicione o seguinte código Python:

from sanic import Sanic, response

# Cria uma instância da aplicação Sanic
app = Sanic("HelloWorldSanicApp")

# Define uma rota para a URL raiz ("/")
# Esta rota lida com requisições GET
@app.get("/")
async def hello_world(request):
    """
    Lida com requisições GET para a URL raiz e retorna uma mensagem "Hello, Sanic!".
    """
    return response.text("Hello, Sanic!")

# Ponto de entrada para executar a aplicação
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, dev=True)

Vamos detalhar o arquivo main.py linha por linha para entender como sua aplicação Sanic funciona:

• from sanic import Sanic, response

  Esta linha importa os componentes necessários da biblioteca Sanic: Sanic para criar a instância da aplicação e response para gerar respostas HTTP.

• app = Sanic("HelloWorldSanicApp")

  Aqui, criamos uma instância da aplicação Sanic. A string "HelloWorldSanicApp" é o nome da sua aplicação, que pode ser útil para depuração ou logging.

• @app.get("/")

  Este é um decorador que diz ao Sanic para associar a função logo abaixo dele ao caminho da URL raiz ("/") para requisições HTTP GET. Sanic também oferece @app.post(), @app.put(), @app.delete(), etc., para outros métodos HTTP.

• async def hello_world(request):

  Isso define uma função assíncrona chamada hello_world. A palavra-chave async é crucial para Sanic, permitindo que ele lide com requisições concorrentes sem bloqueio. A função recebe um objeto request como argumento, que contém detalhes sobre a requisição HTTP recebida.

• return response.text("Hello, Sanic!")

  Dentro do nosso manipulador de rota, usamos response.text() para criar uma resposta HTTP com o tipo de conteúdo text/plain e a string "Hello, Sanic!" como corpo. Sanic também oferece response.json() para respostas JSON, response.html() para HTML, e mais.

• if __name__ == "__main__":

  Esta construção padrão do Python garante que o código dentro deste bloco só seja executado quando o script for executado diretamente (e não quando importado como um módulo).

• app.run(host="0.0.0.0", port=8000, dev=True)

  Esta linha inicia o servidor web Sanic.

  • host="0.0.0.0" torna o servidor acessível de qualquer interface de rede, útil para Docker ou acesso externo. Para desenvolvimento local, `127.0.0.1` ou `localhost` também podem ser usados.
  • port=8000 especifica que o servidor escutará na porta 8000.
  • dev=True habilita o modo de desenvolvimento, que inclui recursos como recarregamento automático do servidor em alterações de código e mensagens de erro detalhadas.

Agora que seu arquivo main.py está pronto, você pode iniciar seu servidor Sanic. Certifique-se de estar no diretório sanic-hello-world e que seu ambiente virtual esteja ativo.

Execute sua aplicação usando a CLI do Sanic:

python main.py

Você também pode usar a ferramenta de linha de comando `sanic`, que é mais idiomática, especialmente para configurações mais avançadas. Como incluímos `if __name__ == "__main__": app.run(...)`, o comando `python main.py` é suficiente para este exemplo simples. Se você estivesse executando com `sanic main.app --dev`, a instância da aplicação precisaria ser nomeada `app` para que fosse descoberta automaticamente. Para este guia, `python main.py` é mais simples e funciona diretamente.

[INFO] Goin' Fast @ http://0.0.0.0:8000
[INFO] To stop: CTRL+C
                            

Com sua aplicação Sanic em execução, é hora de testar se ela responde corretamente. Abra seu navegador web e navegue para:

http://127.0.0.1:8000/

Você deve ver o texto "Hello, Sanic!" exibido em seu navegador. Alternativamente, você pode usar uma ferramenta de linha de comando como curl:

curl http://127.0.0.1:8000/

A saída em seu terminal deve ser simplesmente:

Hello, Sanic!

Parabéns! Você criou e executou com sucesso sua primeira aplicação Sanic.

Sua aplicação Sanic continuará em execução em seu terminal até que você a pare manualmente. Para parar o servidor, basta voltar ao terminal onde o Sanic está em execução e pressionar:

CTRL + C

Isso enviará um sinal de interrupção para o processo do servidor, fazendo com que ele seja desligado graciosamente.

Você completou com sucesso sua primeira aplicação "Hello World" com Sanic! Este conhecimento fundamental abre um mundo de possibilidades para construir serviços web assíncronos de alto desempenho com Python.

Aqui estão algumas ideias para seus próximos passos com Sanic:

• Rotas Dinâmicas: Aprenda como criar rotas com parâmetros de caminho (por exemplo, /users/<user_id>) para construir APIs mais flexíveis.
• Respostas JSON: Retorne dados estruturados usando response.json({"message": "Hello from Sanic!"}).
• Dados de Requisição: Acesse parâmetros de consulta (request.args), dados de formulário (request.form) e corpos JSON (request.json).
• Middleware: Implemente funções que são executadas antes ou depois de cada requisição para lidar com autenticação, logging ou modificação de dados.
• Blueprints: Organize seu aplicativo em componentes modulares para projetos maiores.
• Bancos de Dados: Integre Sanic com drivers de banco de dados assíncronos (como asyncpg para PostgreSQL ou aiomysql para MySQL) para operações de banco de dados.
• WebSockets: Explore o suporte integrado do Sanic para comunicação WebSocket em tempo real.
• Implantação: Aprenda como implantar sua aplicação Sanic em ambientes de produção usando Docker, Gunicorn com workers Uvicorn, ou o servidor nativo do Sanic.

A documentação oficial do Sanic é um excelente recurso para mergulhar em todos esses recursos e muito mais.