O problema

Imagine que você está desenvolvendo uma aplicação que precisa de categorias predefinidas. Criar essas categorias manualmente toda vez que você configura um novo ambiente pode ser tedioso e propenso a erros.

A solução

Django nos oferece uma maneira elegante de resolver isso usando signals, especificamente o signail post_migrate. Este signal é disparado após todas as migrações serem aplicadas, tornando-o o momento perfeito para inserir nossos dados iniciais.

Veja como podemos implementar um seed para uma tabela categorias e como é simples:

# meu_app/signals.py
from django.db.models.signals import post_migrate
from django.dispatch import receiver
from django.apps import apps

@receiver(post_migrate)
def create_default_categories(sender, **kwargs):
    Categoria = apps.get_model('meu_app', 'Category')
    categories = [
        {"nome": "Tecnologia", "descricao": "Artigos e notícias sobre tecnologia."},
        {"nome": "Esportes", "descricao": "Novidades do mundo dos esportes."},
        {"nome": "Culinária", "descricao": "Receitas e dicas de culinária."},
        {"nome": "Viagens", "descricao": "Destinos e dicas para viajantes."},
    ]
    for cat_data in categories:
        category, created = Category.objects.get_or_create(
            name=cat_data["nome"],
            defaults={"description": cat_data.get("descricao", "")}
        )
        if created:
            print(f"Categoria '{category.name}' criada.")
        else:
            print(f"Categoria '{category.name}' já existe.")
    print("Criação de categorias padrão concluída.")

Este código define uma função que será executada após as migrações, ou seja, após o comando migrate. Dentro dela, definimos uma lista de categorias que queremos criar.

Não esquece de garantir que o Django saiba sobre nosso arquivo signals.py. A maneira recomendade de registrar signals é no método ready() da configuração do seu aplicativo AppConfig.

# meu_app/apps.py
from django.apps import AppConfig

class MeuAppConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'meu_app'

    def ready(self):
        # Importar os sinais aqui para que sejam registrados quando o app estiver pronto
        import meu_app.signals

Benefícios:

1. Consistência: Garante que todos os ambientes (desenvolvimento, teste, produção) tenham os mesmos dados iniciais.

2. Automação: Elimina a necessidade de inserção manual de dados.

3. Versionamento: As seeds podem ser versionadas junto com o código, facilitando o rastreamento de mudanças.

Melhores práticas:

1. Use get_or_create() para evitar duplicatas.

2. Mantenha suas seeds em um arquivo separado para melhor organização.

3. Considere usar fixtures para dados mais complexos.

Conclusão

Implementar seeds no Django é uma prática poderosa que pode economizar tempo e garantir consistência em seus projetos. Ao automatizar a criação de dados iniciais, você simplifica o processo de configuração e manutenção de sua aplicação Django. Existe outras formas de fazer seeds no Django, se você conhece comenta aqui em baixo quais são e não esquece de ir ler o meu post sobre o poder de uma boa documentação em Python para melhorar as suas aplicações no Django.

A diferença entre documentação e comentários

Uma documentação é a receita de bolo do seu projeto. Ela diz para o usuário como usar a sua ferramenta sem que seja necessário acessar e entender o seu código. Comentários, por outro lado, são notas para você e outros desenvolvedores que estarão olhando o código-fonte. Eles explicam o porquê de uma determinada lógica, um workaround específico, ou marcam TODOs.

A documentação é voltada para o usuário da sua biblioteca, API ou framework. Os comentários são para os mantenedores e contribuidores do código.

Documentando no Python

Agora que você já entendeu que documentar é uma parte importante do processo. E você que é menos experiente deve estar se perguntando, como fazer isso e o custo de uma boa documentação. Eu trago boas notícias, uma documentação pode ser gerada automaticamente, e neste artigo vou te mostrar como e até o final da leitura você será um expert.

Antes de qualquer coisa eu gostaria de explicar o porquê da minha escolha por Python, já que a maioria das linguagens possui ferramentas para gerar documentações. A resposta é bem simples, primeiro, é a linguagem que eu mais tenho domínio, e fica mais fácil para mim abordar esse tema considerado tão importante, segundo, é uma das melhores linguagens quando se trata de documentação.

Docstrings

O coração da documentação em Python são as docstrings. Podem ser encontradas na PEP-257 Docstring Conventions ou na documentação do Python em 4.8.7. Documentation Strings. Resumindo a documentação, uma docstring é uma string literal que precede a primeira declaração em um módulo, função, classe ou método, tornando-se o atributo especial __doc__ (ou como chamamos dunder __doc__) desse objeto.

Existem dois formatos de docstrings:

One-line vs Multi-line docstrings

O primeiro caso é usado para descrições mais óbvias e resumos e tudo deve estar na mesma linha, a abertura e fechamento de aspas triplas e o texto. Veja esse exemplo tirado da própria documentação:

def kos_root():
    """Return the pathname of the KOS root directory."""
    global kos_root
    # ...

O segundo caso deve-se quebrar uma linha após a abertura de aspas triplas e o texto pode ser mais elaborado tendo o fechamento das aspas triplas na próxima linha.

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword arguments:
    real -- the real part (default 0.0)
    imag -- the imaginary part (default 0.0)
    """
    if real == 0.0 and imag == 0.0:
        return complex_zero
    # ...

Agora que você já entendeu como funciona, vamos ver como a mágica acontece.

Gerando documentação com Python

Eu vou criar um exemplo de uma biblioteca de código de um mensageiro fictício e vamos gerar a documentação desse exemplo com Sphinx. Mas antes vamos entender as:

Convenções de documentação e formatadores de docstrings

Não existem muitos critérios e nem regras para a escolha da convenção ou o formatador, fica por sua escolha mas é importante que você escolha um formato que seja compatível com a ferramenta que irá gerar o site da sua documentação. Segue uma lista com os principais formatadores e todos são compatíveis com Sphinx:

• Numpydoc

• reStructured Text

• Google Docstrings

• Epytext

Eu deixei o link para você estudar essas convenções no futuro, mas por enquanto não precisa focar nisso, todas são muito parecidas, com algumas pequenas diferenças. Nesse exemplo usaremos o reStructured Text pois é o padrão do Sphinx e é muito parecido com Markdown.

Gerando uma documentação com Sphinx

Como mencionei anteriormente, vou criar um exemplo de uma biblioteca de código de um mensageiro fictício e vamos gerar a documentação desse exemplo com Sphinx. Mas antes de botar a mão na massa, vamos entender o que é o Sphinx e por que ele é tão popular na comunidade Python.

O que é o Sphinx?

Sphinx é uma ferramenta poderosa que transforma arquivos de texto simples em diversos formatos de saída, como HTML, PDF, ePub e mais. Ele foi originalmente criado para a documentação da linguagem Python e, desde então, tornou-se a escolha padrão para muitos projetos Python e até mesmo para projetos em outras linguagens. Sua principal força reside na capacidade de processar reStructuredText (e Markdown, com extensões), uma linguagem de marcação fácil de ler, e integrá-lo perfeitamente com o código Python para extrair docstrings automaticamente.

Por que escolher o Sphinx?

• Automação: Ele pode extrair automaticamente a documentação das docstrings do seu código Python usando a extensão autodoc. Isso significa que sua documentação e seu código permanecem sincronizados com mais facilidade.

• Formatos de saída múltiplos: Precisa de um site HTML? Um PDF para impressão? O Sphinx cuida disso.

• Referências cruzadas extensivas: Crie links facilmente entre diferentes partes da sua documentação, módulos, classes e funções.

• Temas e extensibilidade: Customize a aparência da sua documentação com temas (como o popular sphinx_rtd_theme usado pelo Read the Docs) e adicione funcionalidades com uma vasta gama de extensões.

• Suporte a reStructuredText e Markdown: Embora o reStructuredText seja o padrão e ofereça mais funcionalidades, o Sphinx também pode lidar com Markdown através de extensões, oferecendo flexibilidade.

• Ampla adoção: Muitos projetos grandes utilizam o Sphinx, o que significa uma comunidade grande, muitos recursos e tutoriais disponíveis.

Mãos à obra: configurando o Sphinx

1. Instalação:

   Primeiro, você precisará instalar o Sphinx. Recomendo também instalar o sphinx_rtd_theme para um visual moderno:

    pip install sphinx sphinx-rtd-theme
   

2. Iniciando o projeto de documentação:

   Navegue até o diretório raiz do seu projeto Python e execute o assistente de configuração do Sphinx:

    sphinx-quickstart
   

   Este comando fará uma série de perguntas para configurar seu projeto de documentação. Algumas das opções importantes:

   • Nome do projeto: O nome da sua biblioteca ou aplicação.

   • Nome do autor: Seu nome ou o nome da sua organização.

   • Versão do projeto: A versão atual do seu projeto.

   • Extensões: Aqui é crucial habilitar algumas extensões. Pressione 'y' para:

     • sphinx.ext.autodoc: Para incluir documentação de docstrings.

     • sphinx.ext.napoleon: Se você planeja usar docstrings no estilo Google ou NumPy.

     • sphinx.ext.viewcode: Para adicionar links para o código fonte.

     • sphinx.ext.githubpages: Se você planeja hospedar no GitHub Pages.

Após responder a todas as perguntas, o sphinx-quickstart criará um diretório docs (ou o nome que você escolheu) com vários arquivos, incluindo:

• conf.py: O arquivo de configuração principal do Sphinx. É aqui que você define o tema, ativa extensões, e mais importante, informa ao Sphinx onde encontrar seu código Python.

• index.rst: A página inicial da sua documentação.

• Makefile (ou make.bat no Windows): Arquivos de utilidade para construir sua documentação.

3. Configurando o conf.py:

   Abra o arquivo docs/conf.py e faça algumas edições essenciais:

   • Descomente e ajuste o sys.path: Para que o autodoc encontre seus módulos Python, você precisa adicionar o diretório do seu código ao sys.path. Se sua estrutura de projeto for algo como:

       meu_projeto/
       ├── docs/
       │   └── conf.py
       └── src/
           └── meu_mensageiro/
               └── __init__.py
               └── core.py
     

     Você adicionaria:

       import os
       import sys
       sys.path.insert(0, os.path.abspath('../src')) # Ajuste conforme sua estrutura
     

   • Defina o tema HTML: Para usar o tema Read the Docs:

       html_theme = 'sphinx_rtd_theme'
     

   • Verifique as extensões: Garanta que sphinx.ext.autodoc está na lista extensions.

Exemplo prático: Documentando nossa biblioteca de mensageiro fictício

Vamos supor que temos um módulo core.py dentro de src/meu_mensageiro/ com o seguinte conteúdo:

# src/meu_mensageiro/core.py

"""
Módulo principal do Mensageiro Fictício.

Este módulo contém as funcionalidades centrais para enviar e receber mensagens.
"""

MAX_MESSAGE_LENGTH = 1024
"""Constante que define o tamanho máximo de uma mensagem."""

class Message:
    """
    Representa uma mensagem no sistema.

    :param sender: O remetente da mensagem.
    :type sender: str
    :param content: O conteúdo da mensagem.
    :type content: str
    :raises ValueError: Se o conteúdo da mensagem exceder `MAX_MESSAGE_LENGTH`.
    """
    def __init__(self, sender: str, content: str):
        if len(content) > MAX_MESSAGE_LENGTH:
            raise ValueError("Conteúdo da mensagem muito longo.")
        self.sender = sender
        self.content = content
        self.is_sent = False

    def send(self) -> bool:
        """
        Envia a mensagem.

        Simula o envio de uma mensagem. Em um cenário real, isso se conectaria
        a um serviço de mensageria.

        :return: True se a mensagem foi enviada com sucesso, False caso contrário.
        :rtype: bool
        """
        print(f"Mensagem de {self.sender} enviada: {self.content}")
        self.is_sent = True
        return True

def receive_message(user: str) -> Message | None:
    """
    Simula o recebimento de uma nova mensagem para um usuário.

    :param user: O nome do usuário para verificar mensagens.
    :type user: str
    :return: Um objeto :class:`Message` se houver uma nova mensagem, ou None caso contrário.
    :rtype: Message or None
    """
    # Em um sistema real, haveria uma lógica para buscar mensagens
    if user == "ricardo":
        return Message("servidor_central", "Bem-vindo ao Mensageiro Fictício!")
    return None

Neste exemplo, usamos o formato reStructuredText para as docstrings, como discutido. Observe como descrevemos parâmetros (:param:), tipos (:type:), o que é retornado (:return:, :rtype:) e exceções (:raises:). Informações detalhadas sobre como escrever docstrings podem ser encontradas em tutoriais como o do DataCamp sobre docstrings em Python.

4. Criando arquivos .rst para o autodoc:

   Agora, vamos dizer ao Sphinx para gerar documentação para o nosso módulo core. Crie um arquivo chamado meu_mensageiro.rst dentro do diretório docs/ com o seguinte conteúdo:

    .. automodule:: meu_mensageiro.core
       :members:
       :undoc-members:
       :show-inheritance:
   

   • .. automodule:: meu_mensageiro.core: Diz ao Sphinx para documentar o módulo meu_mensageiro.core.

   • :members:: Inclui todos os membros públicos (funções, classes, variáveis) do módulo.

   • :undoc-members:: Inclui membros que não têm docstrings (use com cautela, o ideal é documentar tudo).

   • :show-inheritance:: Mostra as classes base para as classes documentadas.

Agora, adicione este novo arquivo ao seu toctree principal no arquivo docs/index.rst:

    .. toctree::
       :maxdepth: 2
       :caption: Conteúdo:

       meu_mensageiro

5. Gerando a documentação:

   Volte para o diretório docs/ no seu terminal e execute:

    make html
   

   Se tudo estiver configurado corretamente, o Sphinx processará seus arquivos .rst e as docstrings do seu código, gerando a documentação em HTML no diretório docs/_build/html/. Abra o arquivo index.html nesse diretório para ver sua documentação em ação!

   Você verá uma página bem formatada com a descrição do seu módulo, a constante MAX_MESSAGE_LENGTH, a classe Message com seus métodos, e a função receive_message, tudo extraído das docstrings que você escreveu.

Dicas para uma documentação de qualidade com Sphinx:

• Seja consistente: Escolha um estilo de docstring (reStructuredText, Google, NumPy) e mantenha-o em todo o projeto. A consistência é fundamental para a legibilidade.

• Documente a API pública: Foque em documentar a interface que outros desenvolvedores (ou você mesmo no futuro) usarão. Uma boa documentação de API é crucial.

• Inclua exemplos de uso: Docstrings são um ótimo lugar para pequenos exemplos. Para exemplos mais complexos, considere criar seções separadas na sua documentação ou até mesmo um diretório examples/.

• Mantenha atualizado: Documentação desatualizada é pior do que nenhuma documentação. Faça da atualização da documentação parte do seu processo de desenvolvimento.

• Use referências cruzadas: Sphinx facilita a criação de links para outras partes da sua documentação usando roles como :mod:, :func:, :class:. Isso torna a navegação muito mais fluida.

• Explore extensões: O ecossistema de extensões do Sphinx é vasto. Precisa de diagramas? Suporte a Jupyter Notebooks? Provavelmente existe uma extensão para isso.

A documentação é uma parte vital de qualquer projeto de software, grande ou pequeno. Mesmo que você esteja trabalhando em projetos mais simples, como explorar a criação de um site com Python puro, sem framework (usando CGI), entender como articular a funcionalidade do seu código é uma habilidade valiosa que se reflete na qualidade da sua documentação.

Conclusão

Dominar ferramentas como o Sphinx e adotar boas práticas de escrita de docstrings pode parecer um esforço extra inicialmente, mas os benefícios a longo prazo são imensos. Uma documentação clara, concisa e abrangente economiza tempo, reduz a frustração, facilita a colaboração e, em última análise, contribui significativamente para o sucesso e a adoção do seu projeto Python.

Lembre-se: um código bem documentado não é apenas um presente para os outros, é um presente para o seu eu futuro. Invista tempo em documentar seu trabalho, e você colherá os frutos.

Espero que este guia tenha convencido você do poder de uma boa documentação em Python e o tenha preparado para começar a documentar seus próprios projetos como um verdadeiro expert!

O FastAPI é uma ferramenta moderna e super eficiente, com uma comunidade que não para de crescer, conquistou seu espaço, principalmente em projetos que envolvem IA. A performance e a facilidade de uso são incríveis!

Mas, como nem tudo são flores, esse sucesso todo traz alguns desafios. Com muitas empresas começando a usar, algumas implementações podem acabar tropeçando em armadilhas comuns, simplesmente pela falta de experiência dos desenvolvedores com a ferramenta ou por seguirmos o caminho que parece mais fácil de início.

Esse post nasceu justamente de uma situação real que enfrentei num projeto e de uma thread bem interessante que acompanhei lá no GitHub do FastAPI. Vamos falar sobre como gerenciar o cliente da OpenAI (ou qualquer outro recurso similar) do jeito certo dentro do FastAPI usando o lifespan.

O cenário

Imagine que estamos construindo o backend para um chat, tipo um ChatGPT mais simples. Poderia ser para uma interface customizada, para consumo sob demanda, ou até para usar modelos open-source compatíveis com a biblioteca openai do Python.

E para essa missão, claro, vamos usar o FastAPI, já que até as SPAs eu estou substituindo pelo FastAPI.

Pra você que está lendo, não ficar perdido. Eu vou mostrar primeiro a forma como muita gente começa: o jeito simples, que funciona na hora, mas que esconde alguns riscos e pode trazer muita dor de cabeça lá na frente.

Depois, vamos mergulhar na solução usando o lifespan do FastAPI. O foco desse artigo é mostrar como usar o lifespan especificamente para integrar o cliente da biblioteca openai de forma correta. O lifespan tem mais utilidades, mas não vamos nos aprofundar em todas elas hoje, talvez em um post futuro!

O jeito ruim de fazer: Instânciando o cliente no topo do arquivo

Quando estamos começando um projeto, a intuição (e muitos exemplos por aí) nos leva a fazer algo assim: instanciar o cliente assíncrono da openai diretamente no escopo global do nosso arquivo principal. É simples, né?

# main.py
from fastapi import FastAPI
from openai import AsyncOpenAI
import os

client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))

app = FastAPI()

@app.post("/chat")
async def chat(prompt: str):
    # Usando o cliente global diretamente
    response = await client.chat.completions.create(
        model="..."
        messages=[{"role": "user", "content": prompt}]
    )
    return {"reply": response.choices[0].message.content}

Bom, como eu disse, isso funciona. Você roda o Uvicorn e consegue fazer chamadas. Mas por baixo dos panos, vários problemas estão se acumulando:

1. Instanciação prematura: O cliente é criado antes mesmo do servidor FastAPI estar totalmente pronto para receber requisições. Se você precisasse carregar alguma configuração assíncrona antes de criar o cliente, já não daria certo.

2. Gerenciamento de recursos falhos: Essa instância cliente fica "viva" durante todo o tempo que o processo do servidor rodar. Mais importante: ela não é fechada corretamente quando o servidor termina. O AsyncOpenAI usa o httpx.AsyncClient por baixo, que mantém um pool de conexões HTTP. Sem chamar await client.aclose(), essas conexões ficam abertas, vazando recursos (sockets, memória).

3. Dificuldade em testes: Testar endpoints que dependem de estado global é um pé no saco. Mockar ou substituir essa instância cliente para testes unitários ou de integração fica bem mais complicado.

4. Replicação por worker: Se você rodar sua aplicação com múltiplos workers (como o Gunicorn faz em produção), cada worker vai criar sua própria instância global do cliente, multiplicando o desperdício de recursos e os problemas de conexão.

“O jeito certo”: Usando o lifespan do FastAPI

Eu coloquei entre aspas pois existem outras formas de fazer, como o before ou on_event e outras formas que também pode funcionar e ao mesmo tempo seguir as boas práticas. Cagar regra na nossa área definitivamente não é uma boa prática.

Voltando ao assunto. Felizmente, o FastAPI oferece uma solução elegante para gerenciar o ciclo de vida de recursos como nosso cliente openai: o parâmetro lifespan.

Ele utiliza um async context manager (gerenciador de contexto assíncrono) para garantir que seu recurso seja inicializado depois que a aplicação começa e finalizado antes que ela termine completamente.

Veja como fica bem mais interessante:

# main.py
import os
from openai import AsyncOpenAI
from fastapi import FastAPI, Request
from contextlib import asynccontextmanager

# O gerenciador de contexto para o ciclo de vida
@asynccontextmanager
async def lifespan(app: FastAPI):
    # Setup: Roda antes da aplicação iniciar
    print("Iniciando cliente OpenAI...")
    app.state.openai_client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    print("Cliente OpenAI pronto!")

    yield # Essa função congela nesse momento e aplicação entra em ação

    # Teardown: A mágica acontece aqui, depois que voc6e para a aplicação esse código é executado
    print("Fechando cliente OpenAI...")
    await app.state.openai_client.close()
    print("Cliente OpenAI fechado.")

app = FastAPI(lifespan=lifespan)

@app.post("/chat")
async def chat(request: Request, prompt: str): # Simplificado para receber só o prompt
    # Acessa o cliente via app.state
    client: AsyncOpenAI = request.app.state.openai_client

    response = await client.chat.completions.create(c
        model="...",
        messages=[{"role": "user", "content": prompt}]
    )
    return {"reply": response.choices[0].message.content}

Entendendo a mágica: asynccontextmanager e yield

O decorador @asynccontextmanager (da biblioteca contextlib do Python) é a chave aqui. Ele transforma nossa função lifespan em um gerenciador de contexto assíncrono especial.

1. Antes do yield: Todo o código antes da linha yield é a fase de setup. O FastAPI executa isso durante a inicialização (aqui eu imagino que você já entendeu o lance). É aqui que criamos nosso cliente AsyncOpenAI e o guardamos em app.state.openai_client. O app.state é um objeto tipo dicionário feito exatamente para guardar recursos que precisam viver junto com a aplicação.

2. O yield: A palavra yield é o ponto de "pausa". A função lifespan fica congelada aqui, e o controle volta para o FastAPI, que finalmente começa a aceitar e processar requisições. Enquanto a aplicação está rodando, nossos endpoints (como /chat) podem acessar o cliente via request.app.state.openai_client.

3. Depois do yield: Quando o FastAPI recebe um sinal para desligar (por exemplo, quando você pressiona Ctrl+C no terminal), ele "descongela" a função lifespan depois do yield. Essa é a fase de teardown. Aqui, executamos a limpeza: await client.close(), garantindo que as conexões HTTP sejam fechadas corretamente.

Conclusão

Sim, instanciar o cliente globalmente vai funcionar no começo. O FastAPI é robusto e vai saber lidar com isso. Mas essa abordagem não escala bem e esconde problemas que vão te assombrar em produção ou em aplicações maiores.

E pra ser honesto, eu usei a openai para chamar a sua atenção mas a minha verdadeira intenção era te mostrar o uso do lifespan.

No mundo do desenvolvimento web moderno, frameworks JavaScript como React, Vue e Angular (SPAs - Single Page Applications) dominam muitas discussões. Eles são incrivelmente poderosos, mas será que são sempre a ferramenta certa para todas as tarefas? E se você precisar de uma página dinâmica, um dashboard interno, ou uma interface administrativa simples e não quiser lidar com a complexidade de um build frontend separado, gerenciamento de estado no cliente e APIs dedicadas apenas para buscar dados?

FastAPI, conhecido por sua velocidade e facilidade na criação de APIs, oferece uma solução elegante: a renderização de templates HTML diretamente no servidor usando a popular engine Jinja2. Embora não seja seu foco principal (que é a criação de APIs), essa capacidade é extremamente útil e surpreendentemente simples de implementar.

Neste post, vamos explorar passo a passo como configurar o FastAPI para renderizar páginas HTML dinâmicas, passando dados do seu backend Python diretamente para o navegador. Vamos construir um exemplo prático que exibe informações da requisição recebida.

Por que renderizar HTML no servidor com FastAPI?

Antes de mergulhar no código, vamos entender por que essa abordagem pode ser vantajosa:

1. Simplicidade: Para muitos casos de uso (dashboards, páginas de conteúdo, formulários simples), gerenciar um projeto frontend completo é um exagero. Renderizar no servidor elimina a necessidade de um processo de build frontend, roteamento no cliente complexo e gerenciamento de estado separado.

2. Velocidade de Desenvolvimento: Você pode prototipar e construir interfaces funcionais rapidamente usando apenas Python e HTML com Jinja2.

3. Desempenho: Para a primeira carga, o HTML já chega renderizado ao navegador, o que pode ser percebido como mais rápido em algumas situações (Time to First Contentful Paint).

4. SEO: Páginas renderizadas no servidor são geralmente mais fáceis para os motores de busca indexarem (embora o Google tenha melhorado muito na indexação de SPAs).

5. Menos JavaScript: Reduz a quantidade de JavaScript que precisa ser baixado, parseado e executado no cliente.

Claro, SPAs têm seu lugar, especialmente para aplicações altamente interativas e complexas. Mas para muitos cenários, a renderização server-side com FastAPI + Jinja2 é uma alternativa pragmática e eficiente.

Configuração inicial do projeto FastAPI

Vamos começar com uma aplicação FastAPI mínima. Se você ainda não tem o FastAPI e o Uvicorn (servidor ASGI) instalados, instale-os:

É altamente recomendável usar um ambiente virtual para gerenciar as dependências do seu projeto:

# Crie um ambiente virtual (se ainda não tiver)
python -m venv .venv

# Ative o ambiente (Linux/macOS)
source .venv/bin/activate
# Ou (Windows - Command Prompt)
# .venv\Scripts\activate.bat
# Ou (Windows - PowerShell)
# .venv\Scripts\Activate.ps1

# Agora instale as bibliotecas dentro do ambiente ativado
pip install fastapi uvicorn

Crie um arquivo chamado main.py:

# main.py
from fastapi import FastAPI, Request

app = FastAPI()

@app.get('/')
async def root(request: Request):
    # Nossa lógica de renderização virá aqui em breve
    return {"message": "API está funcionando, mas ainda não renderiza HTML"}

# Para rodar: uvicorn main:app --reload

Neste ponto, se você executar uvicorn main:app --reload e acessar http://127.0.0.1:8000/ no navegador, verá a resposta JSON.

Instalando e configurando Jinja2

O FastAPI não inclui um motor de templates por padrão, mas se integra perfeitamente com o Jinja2. Vamos instalar a biblioteca:

pip install jinja2

Agora, precisamos informar ao FastAPI como usar o Jinja2. Modifique seu main.py:

# main.py
from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates

app = FastAPI()

# Crie uma instância de Jinja2Templates, especificando o diretório dos templates
templates = Jinja2Templates(directory="templates")

@app.get('/')
async def root(request: Request):
    # Em breve, substituiremos isso pela renderização do template
    return {"message": "Jinja2 configurado, mas ainda não usado"}

# Não se esqueça de criar um diretório chamado 'templates'
# na raiz do seu projeto!
# Estrutura do Projeto:
# .
# ├── main.py
# └── templates/
#     └── (Aqui ficarão nossos arquivos .html)

Criamos uma instância templates da classe Jinja2Templates. O parâmetro directory="templates" diz ao Jinja onde procurar pelos nossos arquivos HTML. Certifique-se de criar essa pasta templates no mesmo nível do seu main.py.

Criando o template HTML (index.html)

Dentro da pasta templates, crie um arquivo chamado index.html. Este será o nosso template base. Vamos usar a sintaxe do Jinja2 ({{ variavel }} e {% logica %}) para inserir dados dinamicamente. Para deixar visualmente mais agradável, incluiremos links para TailwindCSS e DaisyUI via CDN.

<!-- templates/index.html -->
<!DOCTYPE html>
<html lang="pt-BR" data-theme=cupcake>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Detalhes da Requisição - FastAPI</title>
    <link href="https://cdn.jsdelivr.net/npm/daisyui@4/dist/full.min.css" rel="stylesheet" type="text/css" />
    <script src="https://cdn.tailwindcss.com"></script>
</head>
<body>
    <div class="container mx-auto p-4 min-h-screen">
        <h1 class="text-2xl font-bold mb-6">Informações da Sua Requisição</h1>

        <div class="overflow-x-auto shadow-md rounded-lg">
            <table class="table table-zebra w-full">
                <!-- head -->
                <thead>
                    <tr>
                        <th class="w-1/3">Item</th>
                        <th>Valor</th>
                    </tr>
                </thead>
                <tbody>
                    <!-- Linhas da tabela serão preenchidas com dados do context -->
                    <tr>
                        <td>User Agent</td>
                        <td>{{ user_agent }}</td>
                    </tr>
                    <tr>
                        <td>Seu IP (Host)</td>
                        <td>{{ client_host }}</td>
                    </tr>
                    <tr>
                        <td>Método HTTP</td>
                        <td>{{ request_method }}</td>
                    </tr>
                    <tr>
                        <td>URL Solicitada</td>
                        <td>{{ request_url }}</td>
                    </tr>
                    <tr>
                        <td>Cookies Enviados</td>
                        <td>
                            <pre class="bg-gray-100 p-2 rounded text-sm whitespace-pre-wrap">{{ cookies | tojson(indent=2) }}</pre>
                        </td>
                    </tr>
                     <tr>
                        <td>Caminho da URL (via objeto request)</td>
                        <td>{{ request.url.path }}</td> {# Exemplo de acesso direto ao request no template #}
                    </tr>
                    <!-- Seção de Query Parameters -->
                    <tr>
                        <td class="font-semibold pt-4" colspan="2">Query Parameters:</td>
                    </tr>
                    {% if query_params %}
                        {% for key, value in query_params.items() %}
                        <tr>
                            <td class="pl-8">{{ key }}</td>
                            <td>{{ value }}</td>
                        </tr>
                        {% endfor %}
                    {% else %}
                    <tr>
                        <td class="pl-8 italic" colspan="2">Nenhum query parameter encontrado.</td>
                    </tr>
                    {% endif %}
                </tbody>
            </table>
        </div>
    </div>
</body>
</html>

Explicação do Template:

• {{ variavel }}: Renderiza o valor de uma variável passada no contexto (veremos isso a seguir). Ex: {{ user_agent }}.

• {% if query_params %} ... {% else %} ... {% endif %}: Bloco condicional. Exibe o conteúdo interno dependendo se query_params existe e não está vazio.

• {% for key, value in query_params.items() %} ... {% endfor %}: Loop que itera sobre os itens do dicionário query_params.

• {{ cookies | tojson(indent=2) }}: Usa um filtro Jinja (tojson) para formatar o dicionário de cookies como uma string JSON legível.

• {{ request.url.path }}: Mostra que, como passamos o objeto request no contexto, podemos acessar seus atributos diretamente no template.

Coletando dados e renderizando o template na rota

Agora, vamos modificar nossa rota root em main.py para coletar os dados da requisição e usar a instância templates para renderizar o index.html.

# main.py
from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates

app = FastAPI()

templates = Jinja2Templates(directory="templates")

@app.get('/')
async def root(request: Request):
    # 1. Coletar dados da requisição
    user_agent = request.headers.get('user-agent', 'N/A')
    client_host = request.client.host if request.client else 'N/A'
    request_method = request.method
    request_url = str(request.url)
    cookies = request.cookies
    # dict() converte o MultiDict para um dicionário simples
    query_params = dict(request.query_params)

    # 2. Criar o dicionário de contexto
    # Este dicionário passa os dados do Python para o Jinja2
    context = {
        "request": request,
        "user_agent": user_agent,
        "client_host": client_host,
        "request_method": request_method,
        "request_url": request_url,
        "cookies": cookies,
        "query_params": query_params
    }

    # 3. Renderizar o template com o contexto
    return templates.TemplateResponse("index.html", context)

# Para rodar: uvicorn main:app --reload

Explicação do Código da Rota:

1. Coleta de Dados: Extraímos várias informações úteis do objeto request (tipo Request), como headers, IP do cliente, método, URL completa, cookies e query parameters.

2. Context: Este é o ponto chave. O context é um dicionário Python que mapeia nomes de variáveis (chaves) para valores que você quer disponibilizar dentro do template Jinja2.

3. "request": request - É fundamental incluir a chave "request" no contexto, mapeando para o objeto request original. O TemplateResponse e muitas funcionalidades do Jinja2 (como a função url_for, não usada aqui, mas comum) dependem disso para funcionar corretamente.

4. templates.TemplateResponse("index.html", context): Esta é a função que faz a mágica:

   • Encontra o arquivo index.html no diretório templates.

   • Usa o motor Jinja2 para processar o template.

   • Substitui as variáveis e executa a lógica ({{ ... }}, {% ... %}) usando os dados do dicionário context.

   • Retorna uma resposta HTTP com o HTML renderizado e o Content-Type definido como text/html.

Executando e testando

Certifique-se de que o uvicorn esteja rodando com o reload ativado:

uvicorn main:app --reload

1. Acesso sem query parameters:
   Abra seu navegador e acesse: http://127.0.0.1:8000/
   Você deverá ver a página HTML renderizada, mostrando os detalhes da sua requisição (User Agent, IP, etc.). Na seção "Query Parameters", você verá a mensagem "Nenhum query parameter encontrado.", pois a condição {% if query_params %} no template será falsa.

1. Acesso com query parameters:
   Agora, tente acessar a mesma URL, mas adicione alguns parâmetros na query string:
   http://127.0.0.1:8000/?message=hello,%20world!
   Desta vez, a página será renderizada dinamicamente! Na seção "Query Parameters", você verá as chaves e valores que passou (message, user, debug) listados na tabela, pois agora query_params no contexto contém esses dados e o loop {% for %} no template foi executado.

Conclusão

Como vimos, integrar FastAPI com Jinja2 para renderizar HTML dinâmico é um processo direto e poderoso. Com apenas algumas linhas de configuração e a criação de um template HTML, você pode gerar páginas web diretamente do seu backend Python, passando dados da sua lógica de aplicação para a interface do usuário.

Esta abordagem é ideal para:

• Dashboards internos e painéis administrativos.

• Páginas de conteúdo que precisam de dados dinâmicos.

• Prototipagem rápida de interfaces.

• Situações onde a complexidade de um framework SPA não se justifica.

Lembre-se que o Jinja2 oferece muitos outros recursos, como herança de templates (para criar layouts base), macros (funções reutilizáveis), filtros mais avançados e muito mais, permitindo construir interfaces server-side bastante sofisticadas.

Gostou deste tutorial? Tem dúvidas ou sugestões? Deixe seu comentário abaixo!

O WordPress é a ferramenta mais popular para criação de sites. Porém, essa popularidade também o torna alvo de ataques e injeção de códigos maliciosos. Relatórios da Sucuri comprovam essa vulnerabilidade, e minha experiência com inúmeros serviços de remoção de malware reforça essa realidade.

Mas isso não significa que o WordPress seja ruim. A questão é que sua flexibilidade exige cuidados que muitos negligenciam. Muitos usuários contratam uma VPS barata, instalam o WordPress com um auto-installer e deixam o site sem manutenção.

Vamos mudar isso. Quero compartilhar algumas medidas eficazes que tenho aplicado com sucesso para meus clientes. Mesmo que você não seja técnico, você deve ler esse post pois algumas medidas não necessitam de aplicações técnicas e você pode enviar este post para quem cuida do seu site.

1 - Use a Cloudflare

Quando o assunto é segurança, a Cloudflare é uma das melhores opções. Ela combina diversas ferramentas de infraestrutura e segurança, como o Fail2Ban por exemplo, e será extremamente útil para proteger seu site.

2 - Invista em manutenção

Se for usar uma VPS, contrate alguém qualificado para fazer as configurações iniciais ou use a ferramenta que criei: SetupNewVPSWithAnsible. Também é importante contratar periodicamente um profissional para a manutenção da máquina, garantindo as atualizações de segurança do sistema operacional. Esse serviço é acessível e evitará custos maiores com remoção de malware no futuro.

3 - Evite painéis de controle como Cpanel ou Aapanel

Entendo que você está acostumado com esse tipo de ferramenta e talvez não saiba como o Linux funciona sem ela. O problema é que esses painéis são apenas interfaces gráficas para o sistema, ao serem instalados no servidor, adicionam muitas coisas desnecessárias. Se não forem atualizados, podem causar problemas de segurança. Se for indispensável usá-los, prefira uma opção remota.

Esse tipo de ferramenta pode incentivar tanto a negligência com a devida manutenção do sistema quanto a realização de alterações desnecessárias ou arriscadas. Embora ofereça uma interface clicável, ela não substitui o conhecimento necessário para lidar com o Linux de forma adequada. Se você não tem experiência com o sistema, o ideal é não mexer em configurações que você não entende, mesmo com a aparente facilidade do painel.

4 - Use criptografia na transferência de dados (SFTP e não FTP)

O File Transfer Protocol (FTP) é muito popular, especialmente com o uso do FileZilla, mas é inseguro. Ele transfere arquivos em texto simples, o que permite que um atacante intercepte a transferência. Por exemplo, no WordPress, a senha do banco de dados é armazenada no arquivo wp-config.php e isso é um puta risco nesse caso. Com SFTP (Secure File Transfer Protocol), a transferência é encriptada, protegendo as informações. Além disso, a maioria das distribuições Linux não vem com FTP instalado, enquanto o SFTP usa o protocolo SSH, e quase todas as distros vêm com o OpenSSH instalado por padrão. Portanto, SFTP só tem vantagens.

5 - Faça o bloqueio de execução de scripts dentro da pasta de uploads

Essa dica é muito importante pois na maioria dos casos de infecção por malware em sites Wordpress, os scripts maliciosos são camuflados entre os arquivos de imagens que ficam dentro da pasta wp-content/uploads eu falo mais sobre isso e te ensino como fazer esse bloqueio no post:
As imagens do seu site WordPress pode ter um malware! Aprenda como remover e prevenir.

6 - Desative o XML-RPC

Esse arquivinho do core do WordPress permite a interação remota com o site e faz a ponte para aplicativos de terceiros. Hoje em dia, a API REST do WordPress já cobre muitas funções do XML-RPC, então, se você tem certeza de que não usa, desativar ele pode dar uma camada extra de segurança.

Existem 3 formas bem simples de desativar esse arquivo:

1. Desativar no functions.php

Adicione este código no arquivo functions.php do seu tema:

add_filter('xmlrpc_enabled', '__return_false')

2. Bloquear o acesso via .htaccess Se estiver usando um servidor Apache, você pode bloquear diretamente o acesso adicionando esta regra ao arquivo .htaccess

<Files xmlrpc.php>
    Order Deny,Allow
    Deny from all
</Files>

3. E também é possível bloquear pelo Cloudflare e na minha opinião é a forma mais simples. Vá até Security → WAF → Custom rules e adiciona a regra como na imagem abaixo clicando em Deploy para finalizar:

7 - Desative o WP-Cron

O wp-cron é o carinha que cuida das tarefas agendadas no WordPress, como postagens programadas e atualizações automáticas. Ele é acionado pelas visitas, já que não usa o sistema de agendamento do SO, o que pode sobrecarregar o site com muito tráfego ou atrasar os agendamentos em casos de pouco acesso.

Se o seu WordPress está em uma VPS com SSH, recomendo trocar o wp-cron pelo cronjob real do sistema. É simples de fazer, olha só:

1. Desative o wp-cron adicionando a linha abaixo no arquivo wp-config.php:

define('DISABLE_WP_CRON', true);

2. Crie um cron job no sistema para acessar o wp-cron em intervalos regulares (exemplo, a cada 5 minutos):

*/5 * * * * curl -s https://seusite.com/wp-cron.php?doing_wp_cron > /dev/null 2>&1

8 - Plugins são perigosos!

Eu sempre passo uma regrinha básica pros meus clientes: “se você não sabe ao certo o que o plugin faz, desinstale”.

Os plugins são os maiores vilões quando se fala em invasão de sites WordPress. Ter muitos plugins aumenta as chances de problemas nas atualizações, o que leva muita gente a não atualizar. E quando esses plugins ficam sem atualização, as falhas de segurança descobertas não são corrigidas, deixando o site vulnerável.

Outro ponto importante é que muitos plugins registram dados no banco, e se o desenvolvedor não cuidou bem disso, seu site pode sofrer com problemas de performance.

Por isso, o ideal é manter o mínimo de plugins possível.

9 - Desative o endpoint /user

Como mencionado anteriormente, o WordPress conta com a REST API, que permite diversas integrações e recursos. No entanto, muita gente acaba não aproveitando essa ferramenta, o que pode deixá-la esquecida.

Um dos métodos mais comuns de ataque em sites WordPress é o de força bruta, que consiste em inúmeras tentativas de adivinhar combinações de usuário e senha para invadir o painel de controle.

Para reforçar a segurança do seu site, é uma boa ideia desativar o endpoint /wp-json/wp/v2/users. Esse recurso pode expor informações como o ID dos usuários, facilitando ataques. Caso você não precise dele, desativá-lo é uma forma simples de reduzir vulnerabilidades.

Você pode bloquear esse endpoint aplicando as configurações mencionadas anteriormente, como ajustar o arquivo .htaccess ou usar ferramentas como a Cloudflare.

10 - Faça backups

Esse ponto não pode ser ignorado. É impressionante como a negligência em relação aos backups ainda é tão comum entre donos de sites WordPress. Embora isso muitas vezes acabe gerando trabalho para desenvolvedores como eu, é triste ver pessoas perderem anos de esforço simplesmente por não terem tomado precauções básicas.

Não transfira essa responsabilidade para terceiros. Assim que o seu site estiver no ar, implemente uma solução de backup confiável. Isso pode ser feito contratando um desenvolvedor para automatizar o processo ou investindo em um bom plugin especializado. Mas lembre-se: nunca dependa apenas do backup da sua hospedagem.

Uma estratégia eficiente de backup precisa ser confiável, automática e redundante. Isso significa garantir que seus dados sejam salvos regularmente, em mais de um local, para que estejam acessíveis em caso de qualquer imprevisto.

Evite aprender essa lição da pior forma.

Conclusão

Reconheço que algumas partes deste post podem ter soado um pouco duras demais, mas minha intenção é ajudar. Trabalhando há anos com WordPress, já vi de tudo e, na maioria das vezes, os problemas surgem por negligência ou falta de atenção dos próprios usuários.

Existem muitas outras dicas que poderiam ser incluídas aqui, mas acredito que estas são as mais importantes para quem está começando a trabalhar com o WordPress. São práticas simples, mas que podem evitar grandes dores de cabeça no futuro.

O que achou das sugestões? Caso tenha dúvidas ou queira que eu explore algum dos tópicos mais a fundo, sinta-se à vontade para me enviar uma mensagem no LinkedIn ou me segue no Threads, eu estou bastante ativo por lá.

Eu poderia listar vários pontos negativos do WordPress, mas não dá para criticar uma ferramenta que ajuda tantas pessoas a realizar seus sonhos. Então, vamos deixar isso para outro dia.

O maior problema do WordPress são seus usuários, muitas vezes agências ou pessoas inexperientes de outras áreas. Isso é um sinal de sucesso da ferramenta, mas também resulta em muitos incidentes de infecção por malwares e perda de dados.

Os malwares costumam ser obfuscados e camuflados entre os arquivos legítimos do WordPress. Neste post, vou mostrar como identificar esses arquivos maliciosos e evitar que eles sejam injetados no seu site.

1. Faça uma busca por scripts maliciosos entre as mídias do seu site

   Abra o terminal do seu servidor e execute o seguinte comando:

find wp-content/uploads/ -type f \( -name "*.php" \)

Este comando utiliza a ferramenta find do Linux para buscar arquivos ou pastas. Se você estiver utilizando o cPanel ou alguma ferramenta similar, pode ser ainda mais fácil, bastando utilizar a barra de pesquisa de diretórios.

Se for encontrado algum arquivo com a extensão .php pode ter certeza de que é um script malicioso, então basta usar o comando rm para remover. No entanto, certifique-se de que ele está entre as imagens.

2. Faça o bloqueio preventivo a scripts maliciosos

Uma das técnicas mais utilizadas nessas infecções é a proliferação do vírus através de requisições nesses scripts. Ou seja, o atacante injeta um script que cria mais dois ao ser executado. Nesse caso, a melhor prevenção é bloquear esse tipo de requisição nas pastas onde você sabe que esses arquivos não deveriam estar. A seguir, vou mostrar como fazer isso de duas formas.

Bloqueando scripts maliciosos entre as imagens do Wordpress através do Proxy Reverso (Nginx)

Se você ainda não sabe como funciona um proxy reverso, leia o meu post Proxy x Proxy Reverso. Entenda de uma vez por todas a diferença.

server {
    listen 80;
    server_name exemplo.com;

    location /wp-content/uploads {
        # Bloqueia arquivos .php
        if ($request_uri ~* \.(php)$) {
            return 403;  # Retorna erro 403 Forbidden
        }

        proxy_pass http://backend_servidor;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Não esqueça de reiniciar o Nginx para aplicar a nova regra:

sudo systemctl restart nginx

Bloqueando scripts maliciosos entre as imagens do Wordpress através do Cloudflare.

O Cloudflare é uma plataforma que melhora a segurança e o desempenho de sites e aplicações online, protegendo contra ataques DDoS e otimizando a velocidade com caching e uma rede de distribuição de conteúdo (CDN). Ele também oferece firewall e proteção contra bots, garantindo mais segurança e eficiência para sites e APIs.

Vamos utilizar de uma dessas ferramentas para prevenir a injeção de scripts maliciosos dentro das imagens do seu site.

Ao entrar no painel do seu domínio, no menu lateral esquerdo, vá em Security → WAF → Custom rules e adicione a seguinte regra:

(http.request.uri.path contains "/wp-content/uploads/" and ends_with(http.request.uri.path, ".php"))

Após isso, sempre que o atacante tentar acessar o endpoint que executa o script injetado, ele verá uma tela como esta:

Conclusão

Proteger seu site WordPress contra malwares é uma tarefa contínua, especialmente com a facilidade com que esses scripts maliciosos podem se esconder entre as mídias. Ao seguir os passos deste post, você estará garantindo que seu site fique mais seguro, bloqueando vulnerabilidades comuns. Não se esqueça: a segurança é uma maratona, não uma corrida de 100 metros. Continuar monitorando e adotando boas práticas vai fazer toda a diferença para evitar futuras infecções. Afinal, ninguém quer um site comprometido, certo? 💻🔒

Para profissionais de tecnologia, o uso de proxies e proxies reversos é essencial em ambientes de rede e infraestrutura de servidores. Ambos os tipos desempenham papéis específicos na mediação de conexões, mas com finalidades distintas e localizações diferentes na cadeia de comunicação. Eu vou abordar as características técnicas de cada um e como são utilizados em práticas de segurança, otimização de desempenho e controle de acesso em redes corporativas e ambientes de produção.

O que é um Forward Proxy (ou apenas Proxy)?

Um Forward Proxy é um servidor intermediário que atua entre o cliente e os servidores da internet. Localizado "do lado do cliente", ele intercepta e redireciona requisições de saída, aplicando políticas de controle e segurança antes que cheguem ao destino. Esse tipo de proxy é frequentemente implementado para:

• Controle de Acesso: Permite bloquear ou restringir o acesso a determinados sites ou serviços com base em políticas da organização. Por exemplo, o acesso a redes sociais ou conteúdo inapropriado pode ser filtrado no proxy.

• Registro e Monitoramento: Todas as requisições são registradas, facilitando a auditoria e o rastreamento de atividades na rede. Esse log detalha o endereço IP de origem, o conteúdo acessado e os horários das requisições.

• Anônimato e Bypass de Restrições: Em alguns casos, o Forward Proxy pode ser utilizado para contornar restrições geográficas. Isso ocorre quando um usuário se conecta a um proxy localizado em uma região permitida, que realiza a requisição em nome do cliente, mascarando a origem da solicitação.

Usos Comuns do Forward Proxy:

• Segurança: Bloqueio de conteúdo malicioso ou sites não autorizados.

• Filtragem de Conteúdo: Restrição de acesso com base em categorias de sites.

• Anonimização: Ocultação de IPs de origem, especialmente em redes públicas.

• Bypass de Geolocalização: Acesso a conteúdo restrito em determinadas regiões.

O que é um Reverse Proxy (Proxy Reverso)?

Um Reverse Proxy opera do lado do servidor e age como um intermediário entre os clientes e um ou mais servidores back-end. Diferentemente do Forward Proxy, o Reverse Proxy é transparente para o cliente e sua função principal é gerenciar e otimizar as requisições que chegam aos servidores de aplicação.

O Reverse Proxy recebe as requisições do cliente e, dependendo da configuração, distribui essas requisições para diferentes servidores. Ele também pode desempenhar funções adicionais, como:

• Balanceamento de Carga: O Reverse Proxy distribui o tráfego entre vários servidores back-end, evitando sobrecarga em um único servidor e aumentando a disponibilidade e a resiliência da aplicação.

• Cache: Implementar cache de conteúdo no Reverse Proxy permite que ele responda a requisições com dados previamente armazenados, reduzindo a carga nos servidores back-end e melhorando o tempo de resposta.

• Proteção contra Ataques DDoS: Como o Reverse Proxy atua como uma camada entre o cliente e o servidor, ele pode mitigar ataques de negação de serviço distribuída (DDoS), filtrando requisições maliciosas antes que cheguem ao servidor principal.

• SSL Offloading: O Reverse Proxy pode gerenciar a criptografia SSL/TLS, descarregando o processamento criptográfico dos servidores de aplicação, o que libera recursos de CPU para outras tarefas.

Usos Comuns do Reverse Proxy:

• Balanceamento de Carga: Redistribuição de tráfego entre múltiplos servidores.

• Cache: Melhoria no desempenho e redução da carga nos servidores.

• Proteção Anti-DDoS: Filtragem de requisições maliciosas e limitação de taxa.

• Criptografia e Descriptografia: SSL offloading para reduzir a carga de trabalho dos servidores back-end.

• Segurança: Controle de acesso e proteção contra ameaças ao ocultar a infraestrutura de servidores.

Conclusão

Se você é desenvolvedor, compreender profundamente os conceitos de Forward Proxy e Reverse Proxy é essencial, pois ambos desempenham papéis importantes em arquiteturas de rede e sistemas distribuídos. No seu dia a dia, você provavelmente usará essas soluções para otimizar o desempenho de aplicações, implementar medidas de segurança e resolver problemas complexos relacionados a controle de acesso e distribuição de carga. Dominar esses conceitos permitirá que você enfrente desafios técnicos com maior eficiência, facilitando a tomada de decisões estratégicas em diversas situações, como na proteção de servidores, balanceamento de tráfego e escalabilidade de serviços.

CGI (Common Gateway Interface) é uma especificação padrão que permite a um servidor web transferir dados para e de aplicações externas. Na prática, CGI permite a execução de scripts que geram conteúdo dinâmico em um servidor web.

Funcionamento

Quando uma requisição atende uma diretiva configurada no servidor, ele cria um processo adicional e passa as informações da requisição via stdin para o script configurado. Este script, que pode ser escrito em diversas linguagens como Python, processa os dados e gera o conteúdo dinâmico que é devolvido ao servidor e, por fim, ao cliente (navegador).

Cenário Prático

Imagine que você precisa criar um formulário para coletar dados rapidamente e só tem um servidor virtual com Python disponível. Usando CGI, você pode configurar um servidor web rapidamente sem precisar de frameworks como Flask ou Django.

"Mas Ricardo, por que não usar algo como FastAPI?" Porque você tem pouco tempo para cumprir essa tarefa e não pode criar mais um serviço para o SRE da sua empresa monitorar.

Vou pular a parte de configurar a máquina e supor que você já leu o artigo como configurar uma nova VPS Linux com segurança usando o Ansible e já tem acesso seguro à máquina fornecida.

E se você ainda não tem acesso à uma VPS você pode começar com $200 de créditos usando meu link da DigitalOcean.

Passos para Implementação

1. Instale o Apache

sudo apt-get install apache2

Use o comando python3 --version para verificar se a máquina já tem o Python instalado, na maioria das distribuições Linux ele já vem instalado por padrão.

2. Ative o módulo CGI no Apache:

sudo a2enmod cgi

3. Configure o Apache:

Adicione a seguinte diretiva no arquivo de configuração do Apache para permitir a execução de scripts CGI:

<Directory "/var/www/html/">
    AllowOverride None
    Options +ExecCGI
    AddHandler cgi-script .py
    Require all granted
</Directory>

Neste exemplo, qualquer arquivo dentro do diretório /var/www/html/ com a extensão .py será tratado como um script CGI e executado como tal.

4. Crie e configure um script Python:

cd /var/www/html
touch hello.py
chmod +x hello.py

Conteúdo do hello.py:

#!/usr/bin/python3

import os

print("Content-type: text/html\n")
print("<html><head><title>CGI Info</title></head><body>")
print("<h1>CGI Info</h1>")

for key, value in os.environ.items():
    print(f"<p><strong>{key}:</strong> {value}</p>")

print("</body></html>")

A simplicidade desse script é notável: o servidor web utiliza o shebang para identificar o interpretador a ser usado e passa várias variáveis de ambiente definidas pelo Apache no processo CGI atual. Essas variáveis podem variar com novas solicitações no mesmo endereço, refletindo diferentes dados da requisição. Isso permite que o script CGI responda dinamicamente com base nas informações da requisição.

Agora basta acessar a porta 80 do servidor, por exemplo, http://146.190.78.111/hello.py e se você ver algo como a imagem abaixo, é porque já está funcionando.

Eu poderia encerrar aqui, pois você já aprendeu como o CGI funciona e como servir um site em Python sem um framework web. No entanto, vamos dar um passo adiante: criar um formulário, coletar os dados e ver tudo funcionando na prática.

Criação de um Formulário

Crie um formulário HTML que coleta dados e os envia para um script CGI Python que processa esses dados e os salva em um arquivo CSV.

1. Formulário HTML formulario.py:

#!/usr/bin/python3

print("Content-type: text/html\n")
print("""
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Formulário CGI</title>
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Formulário de Sugestões</h1>
        <form method="post" action="/process_form.py">
            <div class="form-group">
                <label for="nome">Nome</label>
                <input type="text" class="form-control" id="nome" name="name" required>
            </div>
            <div class="form-group">
                <label for="sobrenome">Sobrenome</label>
                <input type="text" class="form-control" id="sobrenome" name="surname" required>
            </div>
            <div class="form-group">
                <label for="cargo">Cargo</label>
                <select class="form-control" id="cargo" name="office" required>
                    <option value="Desenvolvedor">Desenvolvedor</option>
                    <option value="Designer">Designer</option>
                    <option value="Gerente">Gerente</option>
                </select>
            </div>
            <div class="form-group">
                <label for="sugestao">Sugestão</label>
                <textarea class="form-control" id="sugestao" name="suggestion" rows="4" required></textarea>
            </div>
            <button type="submit" class="btn btn-primary">Enviar</button>
        </form>
    </div>
</body>
</html>
""")

Veja só, que interessante, o que esse script faz é apenas printar um código HTML e o navegador renderiza isso para o usuário como uma página, veja como ficou:

Mas por que isso acontece? O CGI envia os dados do stdout para o servidor web, que os renderiza para o cliente. Quando usamos print, estamos enviando dados para o stdout. A primeira linha após o shebang define o tipo de conteúdo que o servidor deve renderizar, como HTML, mas poderia ser JSON, por exemplo.

E vamos para a parte mais interessante, quando esse formulário é preenchido e enviado, ele faz uma requisição POST para outro script, proccess_form.py que também será servido como CGI. Vamos criar o script que processará essa requisição, salvando os dados em um arquivo CSV no servidor. Esse script aceitará apenas requisições do tipo POST.

Para começar, importamos as bibliotecas necessárias. Em seguida, configuramos o tipo de conteúdo que será enviado para a saída padrão stdout e implementamos uma condição para permitir somente requisições do tipo POST. Caso uma requisição do tipo GET seja feita no script, uma mensagem de erro será retornada.

#!/usr/bin/python3

import csv
import os
import sys

print("Content-type: text/html\n")

if os.environ['REQUEST_METHOD'] == 'POST':

else:
    print("<html><body><h1>Método não permitido. Use POST.</h1></body></html>")

Agora precisamos recuperar algumas variáveis de ambiente criadas pelo servidor, assim como fizemos com REQUEST_METHOD. Vamos usar esse método para acessar o conteúdo do corpo da requisição. Poderíamos usar uma biblioteca Python chamada cgi, mas neste caso, vamos fazer manualmente para facilitar o entendimento de como isso funciona.

#!/usr/bin/python3

import csv
import os
import sys

print("Content-type: text/html\n")

if os.environ['REQUEST_METHOD'] == 'POST':
    content_length = int(os.environ['CONTENT_LENGTH']
    post_data = sys.stdin.read(content_length)

else:
    print("<html><body><h1>Método não permitido. Use POST.</h1></body></html>")

O que estamos fazendo nesse trecho é pegar o comprimento dos dados do corpo da requisição. Como já sabemos, uma variável de ambiente é uma string, então a convertemos para inteiro. Com o comprimento em mãos, pegamos exatamente os dados que queremos no stdin. Assim, teremos armazenado em post_data algo como name=Ricardo&surname=Santos&office=Developer&suggestion=Mais+café.

E então, parseamos esses dados para usá-los mais adiante.

#!/usr/bin/python3

import csv
import os
import sys

print("Content-type: text/html\n")

if os.environ['REQUEST_METHOD'] == 'POST':
    content_length = int(os.environ['CONTENT_LENGTH']
    post_data = sys.stdin.read(content_length)

    params = post_data.split('&')
    form_data = {}

    for param in params:
        key, value = param.split('=')
        form_data[key] = value

    name = form_data['name']
    surname = form_data['surname']
    office = form_data['office']
    suggestion = form_data['suggestion']
else:
    print("<html><body><h1>Método não permitido. Use POST.</h1></body></html>")

E por último vamos salvar os dados desse formulário em uma planilha no formato csv.

#!/usr/bin/python3

import csv
import os
import sys

print("Content-type: text/html\n")

if os.environ['REQUEST_METHOD'] == 'POST':
    content_length = int(os.environ['CONTENT_LENGTH']
    post_data = sys.stdin.read(content_length)

    params = post_data.decode('utf-8').split('&')
    form_data = {}

    for param in params:
        key, value = param.split('=')
        form_data[key] = value

    name = form_data['name']
    surname = form_data['surname']
    office = form_data['office']
    suggestion = form_data['suggestion']

     with open('/var/www/html/sugestoes.csv', 'a', newline='') as csvfile:
        fieldnames = ['Nome', 'Sobrenome', 'Cargo', 'Sugestao']
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

        if csvfile.tell() == 0:
            writer.writeheader()

        writer.writerow({'Nome': name, 'Sobrenome': surname, 'Cargo': office, 'Sugestao': suggestion})
        print("<html><body><h1>Obrigado pela sua sugestão!</h1></body></html>")
else:
    print("<html><body><h1>Método não permitido. Use POST.</h1></body></html>")

Antes de testar, não se esqueça de converter o script em um executável. Se você tiver algum problema de permissões, execute o comando abaixo para conceder essas permissões ao Apache.

sudo chmod +x /var/www/html/process_form.py
sudo chown -R www-data:www-data /var/www/html/
sudo chmod -R 775 /var/www/html/

Conclusão

O CGI foi amplamente utilizado no passado, mas hoje em dia não é recomendado para tarefas complexas. Isso ocorre porque o padrão CGI consome muitos recursos, já que um novo processo é aberto para cada requisição. Atualmente, existem métodos mais eficientes para gerar conteúdo dinâmico. Pretendo escrever novas versões deste post para abordar essas formas mais modernas e eficientes.

Embora este método seja bastante simples, ele é essencial para quem deseja aprender e trabalhar com arquiteturas de micro-serviços. Compreender os fundamentos do CGI pode fornecer uma base sólida para entender como as requisições e respostas funcionam na web. Além disso, ao dominar esses conceitos básicos, você estará melhor preparado para avançar para tecnologias mais avançadas e eficientes, como FastCGI, WSGI, ou até mesmo frameworks modernos como Flask e Django, que são amplamente utilizados para desenvolver aplicações web robustas e escaláveis.

Portanto, mesmo que o CGI não seja a melhor escolha para projetos complexos, aprender sobre ele pode ser um passo importante na sua jornada como desenvolvedor.

No último ano, deparei-me com um artigo de David Hansson criador do Ruby On Rails e um grande empresário, cujo link compartilharei ao final deste texto. Nele, Hansson revela sua decisão de migrar seu principal produto para uma infraestrutura própria, o que me inspirou a refletir sobre os diversos aspectos que serão abordados ao longo deste artigo.

Vale a pena hospedar uma aplicação em uma Cloud pública?

Para iniciar essa discussão, recomendo assistir a um vídeo do Fireship, no qual é sugerido que as clouds públicas podem ser comparadas a uma droga: viciantes e difíceis de abandonar.

Adicionalmente, um comentário interessante surgiu em um vídeo de ThePrimeagen, que reagia ao vídeo mencionado acima:

Nos últimos tempos, conversei com vários clientes que iniciaram seus empreendimentos na nuvem. Alguns expressaram arrependimento, especialmente após o término dos créditos de teste, momento em que se depararam com as primeiras faturas elevadas. E, como muitos já perceberam, seja através do vídeo ou da própria experiência, a estratégia de negócios desses provedores de cloud parece tornar a migração para infraestruturas mais alinhadas ao faturamento da empresa um desafio bastante "doloroso".

No artigo mencionado, Hansson discute o que ele considera uma das maiores ilusões do mercado de software: a crença de que a hospedagem em cloud seria menos complexa e mais econômica do que manter uma infraestrutura própria. Contrariando essa percepção, Hansson argumenta que gerenciar serviços em cloud pode ser tão complexo quanto manter uma infraestrutura própria. E eu destaco, por exemplo, a complexidade da interface web da AWS e a necessidade de aprender e dominar ferramentas não tão intuitivas, como o Terraform, para automatizar tarefas.

Em um artigo subsequente (link abaixo), Hansson compartilha sua experiência pós-migração, revelando uma economia significativa de aproximadamente 1 milhão de dólares por ano. Esse dado reforça a ideia de que, embora a migração para uma infraestrutura própria possa apresentar desafios iniciais, os benefícios financeiros a longo prazo podem ser consideráveis.

Diante dos diversos indícios, torna-se evidente que a adoção de uma cloud pública não deve ser uma escolha automática ou padrão, como tem sido prática comum atualmente. Essa decisão necessita de uma avaliação criteriosa, considerando a complexidade e o alto custo envolvidos.

Existem situações específicas em que a hospedagem em cloud pública se justifica plenamente. Por exemplo, quando há exigências rigorosas de compliance que precisam ser atendidas ou quando o modelo de negócio está alinhado com investidores de perfil mais conservador, que veem na cloud uma forma de garantir maior segurança e estabilidade para a aplicação. Nestes casos, a escolha pela cloud pode ser não apenas apropriada, mas também necessária.

Dominar uma cloud deveria ser um critério essencial para contratação?

Após a leitura desse artigo citado anteriormente, e o consequente desligamento da minha posição como DevOps/SRE, deparei-me com a necessidade de buscar uma nova oportunidade no mercado. Foi então que percebi uma tendência nas vagas para essa especialidade: a exigência de anos de experiência com a AWS, critério com o qual eu não me enquadrava devido à minha experiência em um ambiente onde desenvolvíamos nossas próprias soluções. Essa experiência, embora enriquecedora e fundamental para o meu entendimento prático do conceito de cloud sem a intermediação de camadas de abstração, foi um dos fatores que me levaram a reconsiderar minha carreira na especialidade. Afinal, sempre tive mais interesse em criar soluções do que em manter sistemas operando.

Atualmente, tenho grande apreço pela AWS, misturo no arroz e feijão e como no almoço e na janta 😂. E reconheço que, ao compreender os mecanismos internos de funcionamento das clouds, tudo se torna mais acessível.

Contudo, questiono a relevância de tornar essa habilidade um requisito tão decisivo na contratação. Ao fazer isso, uma empresa pode acabar limitando sua operação à dependência de um único fornecedor. Se estivesse em posição de contratar especialistas hoje, valorizaria o conhecimento em conceitos fundamentais como Serverless Functions, CI/CD, VPC, VPN, clusterização, além da habilidade em orquestrar containers e máquinas virtuais na unha. Essas competências permitem a um profissional adaptar-se com facilidade a ambientes híbridos ou multi-cloud. Inclusive, se um candidato possuísse experiência em outra cloud, como o GCP, eu consideraria sua candidatura para posições relacionadas à AWS, dado que as ferramentas, embora variem em quantidade, são essencialmente as mesmas em diferentes plataformas. Naturalmente, para negócios já profundamente integrados a uma cloud específica, faz sentido buscar profissionais com experiência direta nessa plataforma. No entanto, é curioso observar empresas on-premise que estabelecem a AWS como um requisito, o que pode refletir uma compreensão limitada das necessidades reais do negócio.

Conclusão

O futuro das infraestruturas de TI permanece uma incógnita. Não está claro se as clouds públicas dominarão completamente o cenário ou se as empresas buscarão alternativas, nem se haverá intervenção governamental frente ao crescente monopólio dessas plataformas. O que é certo, porém, é o aumento contínuo no faturamento dessas empresas, um indicador que pode muito bem sinalizar as tendências futuras.

Para você, microempreendedor, deixo uma sugestão valiosa: desenvolva suas aplicações utilizando containers desde o início, mesmo que seu projeto seja um monolito na fase inicial de validação do negócio. Essa abordagem oferece flexibilidade significativa, permitindo que sua aplicação seja hospedada em diversos ambientes sem a necessidade de alterações estruturais. Seja através do ECS da Amazon com EC2 ou Fargate, Kubernetes em serverless na Digital Ocean ou GCP, em sua própria VPS, ou até mesmo em um computador em sua casa, a utilização de containers assegura que você possa migrar ou expandir sua infraestrutura conforme necessário, mantendo abertas múltiplas opções para o futuro.

Conhecendo um pouco do Ansible

O Ansible é uma ferramenta de automação de TI desenvolvida para configurar sistemas, implantar software e orquestrar tarefas mais complexas de forma simplificada, utilizando a linguagem de marcação YAML o primo bonito do HTML que é bem simples. A ideia por trás de sua criação foi proporcionar uma solução de automação mais simples e acessível em comparação com as ferramentas existentes como Puppet e Chef. Ele opera de forma agent-less, significando que não requer instalação de software adicional nos sistemas que estão sendo gerenciados, comunicando-se com eles via SSH e o melhor, é desenvolvido em Python. 💛💙 🐍

Este projeto está disponível no GitHub clicando aqui, para você usar como uma ferramenta, mas se desejar replicá-lo localmente e aprender mais sobre Ansible, continue a leitura:

Instalando o Ansible

Se você ainda não possui o Ansible instalado em sua máquina local, siga as etapas abaixo executando os comandos no seu terminal:

Instale o pacote software-properties-common para adicionar repositórios facilmente:

sudo apt install software-properties-common

Adicione o repositório PPA do Ansible:

sudo add-apt-repository ppa:ansible/ansible

Após adicionar o repositório, atualize a lista de pacotes:

sudo apt update

Agora você pode instalar o Ansible: 😀

sudo apt install ansible

Verifique se o Ansible foi instalado corretamente, exibindo a sua versão:

ansible --version

No Fedora é mais simples:

sudo dnf install ansible

A estrutura de um repositório Ansible

A estrutura de um projeto em Ansible geralmente é direta. No nosso cenário, incluímos apenas três componentes: o arquivo "hosts" um arquivo "readme" com instruções sobre como utilizar o projeto e o playbook, que, na verdade, é um script Ansible.

setupvps/
├─ hosts
├─ playbook.yml
├─ README.md

Criando o playbook Ansible

Antes de iniciar o playbook, crie um arquivo de texto chamado "hosts" e insira o seguinte conteúdo nele:

[all]
# Substitua ESSA linha com o IP da sua VPS

O arquivo "hosts" no Ansible, normalmente chamado de inventário, desempenha um papel fundamental na definição dos nós ou "hosts" nos quais você deseja que o Ansible atue. Este arquivo identifica os nós de máquina, que podem ser servidores, desktops, entre outros, e os grupos de nós aos quais tarefas ou comandos Ansible serão direcionados.

No nosso exemplo, temos apenas um grupo de hosts definido: "all," e esse grupo inclui apenas um host. No entanto, é importante destacar que poderiam existir vários grupos ou vários hosts dentro desse grupo.

Agora, vamos finalmente criar o playbook. Começe pelo cabeçalho:

- name: Configurando uma nova VPS
  hosts: all
  become: true

Este trecho de script Ansible, intitulado "Configurando uma nova VPS", define uma tarefa que será executada em todos os hosts listados no inventário. O comando become: true indica que as tarefas serão executadas com privilégios elevados, geralmente como superusuário. Essa abordagem permite a configuração inicial da VPS com as ações necessárias para personalização e ajustes.

Trabalhando com variáveis no Ansible

No Ansible, as variáveis desempenham um papel crucial ao lidar com valores que podem variar a cada execução do playbook. Elas proporcionam uma forma de gerenciar dinamicamente as configurações e a execução do playbook, resultando em código mais reutilizável e flexível. As variáveis no Ansible podem ser definidas de diversas maneiras e em vários contextos, seja no playbook, nos arquivos de inventário, em arquivos de variáveis externas, ou até mesmo na linha de comando.

Variáveis no Ansible: Aprenda a tirar o máximo proveito dessa funcionalidade

Este comando cria uma variável que nos permite especificar o nome do usuário que desejamos criar na máquina. Esse usuário será configurado de forma segura e utilizado para operar a VPS.

  vars:
    new_username: "john_doe"

O nome de usuário padrão é "John Doe," mas você pode alterá-lo para o nome de sua escolha. Além disso, lembre-se de que esse nome pode ser modificado a qualquer momento durante a execução do playbook, e vamos realizar isso facilmente no modo inline, diretamente pelo terminal, quando formos executar o playbook.

Criando tasks no Ansible

Agora vamos criar a primeira task.

tasks:
    - name: Criar usuário sem senha
      user:
        name: "{{ new_username }}"
        shell: /bin/bash
        password: ""
        generate_ssh_key: yes

Este trecho cria um usuário sem senha no sistema. O nome do usuário é fornecido pela variável new_username que criamos anteriormente, o shell é configurado como "/bin/bash", e uma chave SSH é gerada para permitir autenticação sem senha. Essa abordagem é útil quando a autenticação por chave SSH é preferida sobre senha e é bem mais seguro.

Permitindo comandos em sudo sem o uso de senha

Neste bloco de tarefa, uma configuração é realizada para permitir que um usuário possa executar comandos sudo sem ser solicitado a fornecer uma senha.

    - name: Permitir sudo sem senha
      lineinfile:
        dest: /etc/sudoers
        line: "{{ new_username }} ALL=(ALL) NOPASSWD: ALL"
        validate: "visudo -cf %s"
      become: true
      become_user: root

Ativando autenticação SSH

Este bloco incorpora uma chave SSH pública específica ao usuário definido, possibilitando que o usuário realize login ou execute comandos via SSH sem a necessidade de uma senha.

    - name: Ativar autenticação SSH para o usuário
      authorized_key:
        user: "{{ new_username }}"
        state: present
        key: "{{ lookup('file', '~/.ssh/id_ed25519.pub') }}"

Desabilitando login no root

Este bloco desativa o login SSH direto como usuário root. Utiliza o módulo "lineinfile" para modificar o arquivo de configuração do SSH, adicionando ou alterando a linha "PermitRootLogin no". Após a alteração, notifica o serviço SSH para reiniciar, assegurando que as mudanças entrem em vigor.

   - name: Desativar login SSH como root
      lineinfile:
        path: /etc/ssh/sshd_config
        regex: '^#?PermitRootLogin'
        line: 'PermitRootLogin no'
        state: present
      notify:
        - restart ssh

Disparando um evento no Ansible

  handlers:
    - name: restart ssh
      service:
        name: ssh
        state: restarted

O bloco handlers define ações que só são executadas se notificadas por outras tarefas. No contexto fornecido, ele especifica o que deve acontecer quando uma tarefa notifica o handler restart ssh.

Então, se uma tarefa no playbook fizer mudanças que necessitem de uma reinicialização do serviço SSH (por exemplo, a tarefa que altera o arquivo /etc/ssh/sshd_config para desativar o login do root), ela notificará esse handler, e o serviço SSH será reiniciado, aplicando as novas configurações.

Agora, vem à etapa mais esperada: a execução desse playbook por meio de um comando.

Antes de prosseguir, certifique-se de que a máquina na qual você pretende executar o playbook possui acesso à VPS. Caso o acesso seja feito por meio de senha, é recomendável adicionar sua chave SSH.

ansible-playbook playbook.yml -i hosts -u root -e "new_username=ricardotenv"

Ao executar este comando, utilizamos o arquivo hosts como parâmetro de -i. Como há apenas um grupo no inventário, não é necessário especificar o nome do grupo. Além disso, fornecemos o nome de usuário com -u, que o Ansible usará para configurar a máquina. Como se trata de uma máquina nova, o usuário é root. Por fim, como mencionado anteriormente, especificamos o nome de usuário que desejamos criar, no meu caso, o meu próprio.

Diante desse desafio, ativei meu modo de sobrevivência e mergulhei na batalha, oferecendo meus serviços como freelancer. Ao longo desse período, apliquei estratégias diversas, aprendi lições valiosas e decidi compartilhar minhas experiências neste post na esperança de auxiliar outras pessoas que enfrentam circunstâncias semelhantes e quero deixar claro que este post não visa ser um case de sucesso, mas sim ajudar aqueles que precisam "se virar".

Seguindo essas dicas, nos últimos meses, fiz uma entrega para um empreendedor indiano, e recebi em dólar. Pintaram duas propostas de sociedade, e ainda firmei um contrato de exclusividade. E, no mês de Dezembro, meu faturamento deu um salto, ultrapassando meu antigo salário trabalhando para uma empresa.

1. Pare de reclamar agora!

Então, você está em busca de uma recolocação no mercado e depara-se com posts no LinkedIn sobre o uso do selo #OpenToWork. Surgem dúvidas sobre se deve ou não usar, e no post seguinte, alguém reclama da Gupy e seu algoritmo não humanizado. Esse tipo de situação pode criar inseguranças, fazendo com que, sem perceber, você culpe o governo, os recém-chegados na sua área e até o recrutador da última entrevista que não deu feedback. É fácil cair nesse ciclo de atribuir a fase difícil a todos, sem tomar medidas para melhorar. Pior ainda, reclamar se torna satisfatório e viciante.

Lembre-se de todas as superações que te trouxeram até aqui, como um profissional preparado e dedicado que ama o que faz. Você enfrentou diversos desafios, e este momento é apenas uma fase. Você vai superar, então não precisa passar o tempo reclamando. Embora pareça discurso de coach, focar apenas nas reclamações realmente não ajuda.

2. Aprenda a prospectar clientes

A maneira mais fácil e acessível de encontrar clientes é se cadastrando em plataformas de freelancers. O cliente apresenta o problema na plataforma, e você tem a oportunidade de oferecer seus serviços para resolvê-lo. Existem várias plataformas no Brasil e no mundo para isso. Deixo aqui o link das que já utilizei e recomendo:

• Upwork

• 99Freelas

3. Utilize o ChatGPT para desenvolver sua abordagem e vender os seus serviços

"As máquinas podem superar o homem, mas não podem superar o homem com outra máquina". Apesar de não saber quem é o autor, eu adoro essa frase.

Enviar propostas e se apresentar para clientes pode demandar muito tempo pois para conseguir alguma coisa você terá que enviar várias propostas. Eu tive que otimizar meu tempo utilizando o ChatGPT.

Nas plataformas de freelancer o clientes sempre colocam uma descrição do seu problema e serviço que precisam então eu pedi a ajuda do ChatGPT, disse para ele agir como um vendedor e aplicar o método AIDA em cima dos textos dos potenciais clientes que eu enviasse despertando o interesse e curiosidade deles e funcionou muito bem para mim.

4. Call estratégica

Marque uma call para compreender os desafios do cliente. Demonstre empatia, mergulhe no negócio dele e pense em como suas habilidades podem impulsionar o crescimento. Neste momento tente focar no cliente, deixe-o à vontade e confiante de que você irá ajudá-lo.

5. Cobre justo: valorize seu trabalho mas não seja ganancioso

No início, é difícil atingir o valor de mercado. O que fiz foi calcular meus custos básicos, incluindo alimentação, internet, aluguel, água, luz, entre outros. Considerei também o DAS do MEI (se você não tem, abra um) e as taxas cobradas pelas plataformas de freelancers. Defini uma margem pequena de lucro para cobrir algumas regalias e, somando todos esses custos, dividi pelo valor da minha hora ou dia de trabalho. Em alguns casos, acrescento um percentual com base no risco e no retorno da entrega para o cliente, levando em consideração também o nível de gestão. Por exemplo, se o cliente possui pouco conhecimento na área, não segue uma metodologia definida e não tem uma visão clara do que deseja, minha taxa pode ser mais elevada. Por outro lado, se o projeto já conta com um especialista conduzindo, a taxa pode ser mais acessível. Em projetos nos quais o cliente está disposto a oferecer mais prazo, aplico um percentual de desconto. Essa abordagem permite que eu gerencie diferentes projetos de forma consecutiva, proporcionando uma maior flexibilidade na agenda.

6. Melhore suas habilidades de comunicação

Em muitos casos, os clientes podem ter dificuldade em expressar suas necessidades. Aprenda a fazer as perguntas certas, evitando termos técnicos, especialmente se você for um desenvolvedor.

7. Construa confiança

Após fechar o serviço, mantenha uma comunicação diária com o cliente. Marque na agenda com ele um horário diário de até 15 minutos. Relate o progresso do projeto, e revise os requisitos, fortalecendo a confiança e demonstrando seu comprometimento.

8. Tenha controle financeiro

Trabalhar em uma empresa oferece a comodidade de saber exatamente quanto será o salário no próximo mês, permitindo gastos sem preocupações, desde que estejam dentro do limite salarial, e a empresa cuida dos descontos de impostos no holerite. No entanto, como freelancer, essa tranquilidade acaba. Você não tem certeza sobre quanto receberá e quanto terá disponível para despesas mensais. Portanto, é crucial assumir o controle das suas finanças, especialmente ao lidar com valores variáveis por projeto ou diárias. Aqui estão três dicas essenciais:

1. Pense como uma empresa: Considere tudo o que entra como seu faturamento mensal.

2. Gastos Fixos Essenciais: Liste e priorize seus gastos fixos para sobreviver e trabalhar, como aluguel e mercado.

3. Observe os indicadores: Crie indicadores para saber onde você gasta mais, ou qual projeto te dá mais retorno.

Você pode aplicar essas três dicas utilizando uma planilha. Eu particularmente utilizo uma ferramenta chamada Mobills, onde registro meus ganhos e gastos. Essa ferramenta permite gerar gráficos e indicadores, além de capturar notificações no celular, o que facilita o registro das transações. Essa abordagem proporciona um maior controle financeiro, tornando a gestão de finanças mais eficiente.

9. Descubra seu diferencial

Percebi que muitos freelancers fazem ofertas muito baixas e depois abandonam projetos por propostas mais lucrativas. Então, criei meu diferencial baseando-se nisso: foco em soluções menos exploradas, que recebem menos propostas. Meu compromisso é o que me destaca, garanto a entrega para o cliente me baseando em metodologias Àgil, mas sem me aprofundar.

10. Aprenda a treinar pessoas

Você só tem 24 horas/dia e em algum momento você irá precisar escalar seus serviços e em algum lugar tem alguém que pode mudar de vida através do seu conhecimento.

Boa sorte!

É isso, pessoal! Tudo que compartilhei aqui foi testado e aprovado por mim. Escrevi com as melhores intenções, esperando que alcance e ajude alguém. Se você tiver dúvidas, precisar de mais dicas ou quiser deixar seu contato para possíveis trabalhos, é só me chamar no privado. Estamos juntos nessa jornada! 🚀

Embora eu geralmente não me apegue a ferramentas devido a experiências passadas, o Ansible é uma exceção notável. A economia de tempo que essa ferramenta poderosa me proporcionou é imensurável, e posso afirmar que devo a ela boa parte dos meus momentos produtivos e tempo de vida. 😅

Hoje vamos explorar o uso das variáveis no Ansible para tornar os nossos playbooks mais flexíveis e dinâmicos.

Começando com Variáveis Básicas

Inicialmente, vamos entender a definição básica de uma variável no contexto do Ansible. O exemplo abaixo ilustra um playbook simples que define uma variável para criar um usuário.

---
- hosts: your_target
  vars:
    username: user
  tasks:
    - name: Criando um novo usuário
      user:
        name: "{{ username }}"
        state: present

Neste trecho, username é definido como user e é usado para criar um novo usuário em todos os hosts definidos em your_target.

Expandindo com Variáveis Externas

Mas e se quisermos modificar o username sem alterar o playbook? As variáveis externas entram em cena para proporcionar essa flexibilidade:

ansible-playbook -i your_inventory_file playbook.yml -e "username=newuser"

Aqui, o valor de username é sobrescrito para newuser durante essa execução específica do playbook, proporcionando um alto grau de reusabilidade para nossos scripts.

Explorando Fatos do Ansible

Fatos ou Facts no Ansible são informações sobre os hosts remotos que o Ansible adquire antes de executar tarefas. Eles podem ser usados para implementar lógicas condicionais nos playbooks. Confira o exemplo a seguir:

---
- hosts: your_target
  tasks:
    - name: Exibindo o hostname
      debug:
        msg: "O hostname é {{ ansible_hostname }}"

O valor {{ ansible_hostname }} é um fato que exibirá o nome do host durante a execução do playbook.

Utilizando Registros

O Ansible permite armazenar os resultados de uma tarefa em uma variável para usar em tarefas futuras. Vamos ver como isso funciona:

---
- hosts: your_target
  tasks:
    - name: Criando usuário
      user:
        name: another_user
        state: present
      register: user_creation_result

    - name: Exibindo resultado da criação do usuário
      debug:
        msg: "A saída da tarefa anterior é: {{ user_creation_result }}"

O output da tarefa de criação do usuário é armazenado na variável user_creation_result e pode ser usado em tarefas subsequentes.

Este post é dedicado a guiá-lo na utilização de variáveis no Ansible, garantindo que você esteja bem preparado para acompanhar minhas próximas publicações, que explorarão cenários mais práticos.

Referências:

https://docs.ansible.com/ansible/latest/playbook_guide/playbooks_variables.html
https://spacelift.io/blog/ansible-variables

Configurar uma VPN em um servidor VPS pode parecer uma tarefa desafiadora para muitos, mas não precisa ser uma dor de cabeça. Com algumas etapas simples, você pode ter seu servidor teoricamente no Brasil, pelo menos é o que as pessoas vão pensar 😅.

Este artigo parte do pressuposto de que o leitor já conhece os termos VPS e VPN, porém, mesmo assim, farei um breve resumo. Uma VPS é uma instância de um servidor físico, enquanto uma VPN é um software que protege sua conexão através de criptografia, assegurando a segurança do tráfego de dados e a privacidade.

Por que usamos uma VPN nessa solução?

Uma VPN pode ser utilizada em diversos cenários e pode ser facilmente substituída por um servidor proxy, caso seja necessário por exemplo fazer requisições em um site que permita apenas IP brasileiro. Embora pudesse ter optado por um proxy, alguns fatores externos me impediram de fazê-lo. No meu caso eu precisava de uma solução completa de disparos de E-mail, que obrigatoriamente demandava um IP brasileiro. Neste post, vamos focar no uso da VPN para alterar o IP da rede do servidor.

Instalando e configurando uma VPN no Linux com OpenVPN e NordVPN

Vamos ao que realmente interessa! Primeiro, escolha um servidor VPS confiável. Neste caso, utilizaremos o serviço da NordVPN e uma VPS com Ubuntu 22, e estarei logado na máquina via SSH.

Abaixo, eu fiz uma requisição para o site ipinfo.io com o cURL. Acho esse site muito interessante, pois ele reconhece que é uma requisição Headless e me responde com um JSON, como o exemplo abaixo, onde é possível visualizar o IP e a localização da minha VPS:

{
  "ip": "143.198.69.202",
  "city": "Santa Clara",
  "region": "California",
  "country": "US",
  "loc": "37.3924,-121.9623",
  "org": "AS14061 DigitalOcean, LLC",
  "postal": "95054",
  "timezone": "America/Los_Angeles",
  "readme": "https://ipinfo.io/missingauth"
}

Agora vamos iniciar a instalação da VPN na máquina, obviamente vamos precisar de um cliente VPN, e vamos usar o OpenVPN.

Primeiro faça a instalação do OpenVPN:

sudo apt update
sudo apt-get install openvpn

Entre na pasta de configuração do OpenVPN e faça o download dos arquivos de configuração, a vantagem aqui é que a NordVPN já oferece esses arquivos prontos.

cd /etc/openvpn && sudo wget https://downloads.nordcdn.com/configs/archives/servers/ovpn.zip

Descompacte o arquivo baixado e, caso não tenha o unzip instalado, instale-o com o comando abaixo:

sudo apt-get install unzip

E finalmente faça a extração dos arquivos:

sudo unzip ovpn.zip

Ao acessar o conteúdo baixado, você encontrará duas pastas: "ovpn_tcp" e "ovpn_udp". Para este caso específico, vamos utilizar o protocolo TCP, presente na primeira pasta.

Escolhendo um IP brasileiro

Para obter o endereço IP que você precisa, basta abrir o link: https://nordvpn.com/pt-br/servers/tools/. Neste site, eles irão te recomendar um servidor, mas você também pode escolher a localização que mais lhe convém.

Configurando a VPS

Antes de prosseguir, é importante fazer algumas configurações na rede da VPS. Caso contrário, você corre o risco de perder a conexão e seu terminal poderá travar, deixando-o preso do lado de fora, incapaz de realizar qualquer ação. Nessa situação, a única solução seria reiniciar sua VPS através do console do provedor.

Para evitar esse problema, execute os seguintes comandos em sua VPS:

sudo apt-get install net-tools ipcalc

Esse comando é fundamental para instalar duas ferramentas importantes que serão essenciais para seguir os próximos passos.

Este comando adiciona uma regra de roteamento na tabela 128 para pacotes originados do endereço IP principal da máquina e também cria uma rota padrão na tabela 128, utilizando o gateway padrão.

sudo ip rule add from $(hostname -I | awk '{print $1}') table 128 && \
sudo ip route add table 128 default via $(ip route show default | awk '/default/ {print $3}')

Agora vamos pegar a subnet mask para também incluí-la nas configurações:

ipcalc $(ip addr show dev eth0 | awk '/inet / {print $2}' | head -n 1) | awk -F': ' '/Netmask/ {print $2}' | head -n 1

Esse comando mostrará uma saída como essa:

255.255.240.0 = 20   11111111.11111111.1111 0000.00000000

Então minha subnet mask é 255.255.240.0/20.

Agora adicione...

sudo ip route add table 128 to 255.255.240.0/20 dev eth0

Conectando-se na VPN

Agora copie o endereço fornecido pela NordVPN, adicione o protocolo e .ovpn na frente e execute o arquivo de configuração com o OpenVPN.

sudo openvpn --config br53.nordvpn.com.tcp.ovpn --daemon

Nesse exemplo, estamos executando o arquivo de configuração da NordVPN, mas poderia ser um arquivo de outro provedor ou do seu próprio servidor VPN.

Autenticando-se na VPN

Reparou que foi solicitado usuário e senha para autenticação? Vamos obter essas credenciais diretamente na NordVPN.

Clique no menu lateral esquerdo e vá para "Serviços" ➡️ "NordVPN" ➡️ "Configurar a NordVPN manualmente". Faça a verificação usando o código enviado para o seu e-mail e, finalmente, encontre suas credenciais de usuário e senha.

Está pronto. 🚀 Agora ao executar o comando curl ipinfo.io você terá uma saída confirmando a localização.

{
  "ip": "177.54.151.190",
  "city": "São Paulo",
  "region": "São Paulo",
  "country": "BR",
  "loc": "-23.5475,-46.6361",
  "org": "AS262287 Latitude.sh LTDA",
  "postal": "01000-000",
  "timezone": "America/Sao_Paulo",
  "readme": "https://ipinfo.io/missingauth"
}

Resumo

Certamente! É importante lembrar que essa é uma solução para problemas específicos, e dependendo das circunstâncias, podem ser necessárias configurações adicionais para atender às suas necessidades específicas.

Compartilhar experiências e conhecimentos é fundamental para aprimorar soluções e ajudar uns aos outros. Se você conhece uma solução melhor ou se essa solução funcionou para você, compartilhe nos comentários! Isso pode beneficiar outros usuários e enriquecer a discussão.

Referências:

https://support.nordvpn.com/Connectivity/Linux/1047409422/Connect-to-NordVPN-using-Linux-Terminal.htm

O MongoDB é uma ferramenta poderosa, mas como todo banco de dados, ele precisa ser configurado corretamente para garantir que os dados sejam protegidos adequadamente. Algumas das medidas que aprendi incluem a configuração adequada de senhas fortes e a utilização de autenticação para evitar acessos não autorizados.

Mas hoje vou focar em um aspecto importante do MongoDB: a gestão de usuários e permissões/privilégios. Essa prática é fundamental para garantir o controle de acesso e a segurança dos dados.

E como posso aplicar isso no meu dia a dia?

Imagine uma EdTech fictícia que utiliza uma instância do Mongo como seu banco de dados principal para armazenar informações de alunos e servir dados em sua ferramenta de Business Intelligence (BI).

Nesse caso, quem terá acesso a esses dados será a própria ferramenta de BI, um administrador de banco de dados (DBA) ou assim como eu, um DevOps e o painel de controle que alimenta e controla esses dados.

Primeiro vamos se logar ao banco, estou considerando que estamos montando um novo banco de dados porém esse tutorial também pode servir para bancos já existentes, então vamos do princípio. Nessa caso iremos usar uma instância do tipo standalone, mas também serve para clusters. Após ter uma máquina com o Mongo instalado, vamos fazer o primeiro acesso. Execute o camando abaixo em seu terminal:

mongo --host localhost

Criando um usuário no MongoDB

Vamos executar o comando abaixo debtro do Mongo para criar o nosso primeiro usuário que será o root:

use admin
db.createUser({
    user: "root",
    pwd: "password",
    roles: [
        { "role": "root", "db": "admin" }
    ]
})

Este comando cria um usuário com privilégios de "root" (superusuário) no banco de dados "admin".

O comando começa selecionando o banco de dados "admin" com o comando "use admin". Em seguida, é utilizado o método "createUser" para criar um novo usuário com nome de usuário "username" e senha "password". A propriedade "roles" é usada para especificar as funções ou papéis que o usuário terá no banco de dados.

No exemplo acima, o usuário tem apenas uma função, que é o papel de "root" no banco de dados "admin". Isso significa que o usuário terá privilégios de superusuário para realizar tarefas administrativas, como criar e excluir bancos de dados, criar e excluir usuários e configurar as configurações do servidor.

Suponhamos que este usuário foi o primeiro a ser criado imediatamente após a implementação do banco de dados, com o objetivo de garantir que operações não sejam realizadas sem autenticação, e que este usuário será atribuído ao nosso DBA ou DevOps, mas tome muito cuidado esse usuário tem os privilégios máximos e a senha deve ser armazenada em um local seguro.

Essa conta root será guardada para momentos críticos e pouquíssimas pessoas terão aceosso. Criei um usuário de administrador chamado "lossMan", não se importe com a escolha do nome, mas tenha em mente que eu não usei algo como "admin" apenas para dificultar a vida de "crackers" que usam bot de força bruta ou algo do tipo. Também não se preocupe por enquanto com a role que eu dei para esse usuário, falaremos disso mais à frente.

use admin
db.createUser(
  {
    user: "myUserAdmin",
    pwd: "password",
    roles: [
      { role: "userAdminAnyDatabase", db: "admin" },
      { role: "readWriteAnyDatabase", db: "admin" }
    ]
  }
)

Ativando a autenticação no MongoDB

Para garantir a segurança do seu banco de dados, é importante configurar o Mongo para aceitar apenas acesso por autenticação. Se você está seguindo este tutorial em um banco de dados existente, pode pular esta etapa.

Para começar, abra o arquivo de configuração do Mongo e faça as alterações necessárias para permitir apenas o acesso autenticado:

sudo nano /etc/mongod.conf

Adicione a seguinte linha ao arquivo de configuração

security:
    authorization: enabled

Essa linha de configuração garante que o Mongo só permitirá o acesso autenticado ao banco de dados, proporcionando maior segurança aos dados. Certifique-se de salvar as alterações no arquivo e reiniciar o serviço do Mongo para que as mudanças tenham efeito.

Autenticando-se no MongoDB

Agora, o acesso ao seu banco de dados só será possível através da autenticação com o usuário criado anteriormente. O usuário "lossMan" se autentica na base "admin" e tem os seguintes privilégios:

• userAdminAnyDatabase: Permite que o usuário crie, adicione ou remova roles, bem como crie e modifique roles personalizadas para qualquer base de dados.

• readWriteAnyDatabase: Permite que o usuário faça modificações em qualquer base de dados.

Tendo isso em mente irel logar com meu usuário administrador:

mongo --host localhost -u lossMan --authenticationDatabase admin -p

Agora que já me autentiquei no banco de dados podemos criar a base da "edetch" e os usuários que terão acesso.

Para começar, vamos criar um usuário para a ferramenta de Business Intelligence com acesso restrito ao tipo "somente leitura":

use admin
db.createUser({
    user: "dataAnalysis",
    pwd: "password",
    roles: [
        { "role": "read", "db": "edtech" }
    ]
})

Por questões de segurança, o usuário foi criado na base "admin", mas seu acesso está restrito apenas à base "edtech" e com permissão somente de leitura. Caso ele tente realizar operações de escrita nessa base, receberá uma mensagem de erro.

Por fim, criamos o usuário "controlPanel" com a role "readWrite", que permite que ele leia e escreva na base "edtech".

Adicionando privilégios a um usuário no MongoDB

Suponha que, por algum motivo, o usuário "dataAnalysis" da ferramenta de BI precise de privilégios de escrita para registrar na nossa base e, talvez, cadastrar métricas de alunos no banco para que sejam visualizadas pelos próprios alunos. Para conceder a ele permissão de escrita na base, precisaremos adicionar o privilégio de escrita.

use admin
db.grantRolesToUser(
    "dataAnalysis",
    [
      { role: "readWrite", db: "edtech" }
    ]
)

Execute o seguinte comando para verificar os privilégios que esse usuário agora possui:

db.getUser("dataAnalysis")

A saída será como essa:

{
    "_id" : "admin.dataAnalysis",
    "user" : "dataAnalysis",
    "db" : "admin",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "edtech"
        },
        {
            "role" : "read",
            "db" : "edtech"
        }
    ],
    "mechanisms" : [
        "SCRAM-SHA-1",
        "SCRAM-SHA-256"
    ]
}

Observe que agora temos privilégios redundantes, pois ambas as roles concedem privilégios de leitura na base. Portanto, vamos remover a role de somente leitura.

Revogando privilégios no MongoDB

O próximo comando irá remover a role de "somente leitura" deixando apenas a role de "leitura e escrita":

db.revokeRolesFromUser(
    "dataAnalysis",
    [
      { role: "read", db: "edtech" }
    ]
)

Pronto! Agora execute novamente o comando db.getUser() para garantir que a redundância foi eliminada:

{
    "_id" : "admin.dataAnalysis",
    "user" : "dataAnalysis",
    "db" : "admin",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "edtech"
        }
    ],
    "mechanisms" : [
        "SCRAM-SHA-1",
        "SCRAM-SHA-256"
    ]
}

Se esta for a saída, então está tudo certo. Neste caso, utilizamos a revogação de privilégios apenas para eliminar a redundância, mas este comando pode ser usado para controlar acessos temporários e outras situações semelhantes.

Se você é um desenvolvedor ou está começando uma empresa, a segurança dos dados é fundamental. Nesse sentido, o uso de técnicas como a atribuição de privilégios em usuários MongoDB pode ser uma ótima maneira de garantir a integridade das informações.

Embora este post se concentre nas Built-In roles, é importante lembrar que a utilização dessas roles é um caminho para um controle ainda mais refinado de privilégios. Não deixe de conferir futuras postagens do blog pois falarei sobre as roles customizadas, para aqueles que desejam ter um controle de privilégios mais avançado.

Referências:

https://www.mongodb.com/docs/manual/tutorial/manage-users-and-roles/#modify-access-for-an-existing-user

https://www.mongodb.com/docs/manual/reference/built-in-roles/

https://www.mongodb.com/docs/manual/tutorial/configure-scram-client-authentication/

Preparado para dar um toque especial ao seu terminal? Vamos explorar as ferramentas Oh My Bash e Gogh para personalizar o prompt de comando e deixá-lo cheio de cores. Neste tutorial, iremos nos concentrar no Bash, o interpretador shell mais popular, e no gerenciador de pacotes APT. No entanto, fique à vontade para adaptar as instruções para outros interpretadores e gerenciadores de pacotes. Vamos começar a transformação do seu terminal e deixá-lo único e incrível!

Para não prolongar demais este post, vou resumir a explicação sobre essas ferramentas. Com o Oh My Bash, você poderá personalizar o prompt de comando do seu terminal, deixando-o com a sua cara. Já com o Gogh, você poderá colorir o fundo e as fontes do console, trazendo mais vida e estilo ao seu ambiente de trabalho.

Instalando o Oh My Bash

Podemos utilizar o Wget ou o cURL, duas ferramentas populares para transferência de dados via linha de comando mas nesse tutorial eu irei utilizar o cURL, escolha a que mais lhe agrada e vamos começar!

Execute o seguinte comando para instalar o Oh My Bash:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/ohmybash/oh-my-bash/master/tools/install.sh)"

O OMB substitui seu arquivo .bashrc por um arquivo template e modifica a variável PS1 com o tema padrão.

Observe a saída do comando no meu terminal e repare na mudança do prompt:

Alterando o tema do Oh My Bash

Como ainda não está com o estilo ideal para o meu gosto, vamos buscar por um tema no link abaixo:

https://github.com/ohmybash/oh-my-bash/wiki/Themes

Eu testei vários temas e escolhi o rr, para alterar o tema abra o arquivo .bashrc, encontre a variável OS_THEME que fica nas primeiras linhas do arquivo e substitua o seu valor com o nome do tema escolhido.

# Set name of the theme to load. Optionally, if you set this to "random"
# it'll load a random theme each time that oh-my-bash is loaded.
OSH_THEME="rr"

Para surgir efeito execute o comando abaixo:

source ~/.bashrc

Pronto! Com o OMB você também pode instalar plugins para git, linguagens de programação e frameworks, mas falarei sobre isso em um outro dia.

Instalando o Gogh

Agora que temos o nosso prompt personalizado, vamos dar cor ao terminal!

bash -c  "$(curl -sLo- https://git.io/vQgMr)"

Ao executar o comando, o Gogh irá listar todos os temas de cores disponíveis e solicitará que você digite o valor correspondente ao tema escolhido. No meu caso, eu escolhi o tema Wryan, que possui o número 242. Você pode conferir todos os temas disponíveis no link abaixo:

https://gogh-co.github.io/Gogh/

Caso surja algum problema com o dconf, uma solução simples é reiniciar o terminal. Além disso, para ativar o tema escolhido na configuração de perfil do terminal, você pode seguir as instruções no gif abaixo:

Lembrando que o Gogh instala um pacote de cores que pode ser personalizado de acordo com suas preferências então você terá que configurar manualmente as cores da fonte.

Eu fiz algumas alterações no meu e o resultado final foi esse.

Este tutorial tem como objetivo auxiliar iniciantes em Linux a superarem o receio da linha de comando, pois entendemos que, no início, uma tela preta com diversos comandos pode parecer assustadora e confusa.

O registrar desse tutorial será o Google Domains pois foi onde registrei esse meu domínio, na época se bem me lembro somente o Google registrava domínios .dev, o processo é muito simples, mas mesmo assim vou tentar facilitar mais ainda.

Adicionando seu domínio próprio

Assim que fazemos um deploy na Vercel recebemos um endereço completamente aleatório para acessarmos nosso site, não queremos isso, queremos acessar através do nosso domínio bonitinho 🥰, para isso precisamos dentro da plataforma da Vercel fazer os seguintes passos:

➡️ 1. Selecione seu projeto

➡️ 2. Navegue para Settings

➡️ 3. Selecione o ítem Domains no menu ao canto esquerdo

➡️ 4. Adicione seu domínio

➡️ 5. Configure o redirecionamento

Você verá um pop-up como esse:

No meu caso como eu quero que o domínio sem o alias www seja o padrão do meu site eu escolhi a segunda opção, você também pode escolher a terceira opção e decidir isso mais tarde.

➡️ 6. Configurando os nameservers

Você verá uma tela como essa:

clique na aba Nameservers e copie os endereços fornecidos.

Caso seu domínio seja novo você verá algo parecido com isso:

clique em Usar servidores personalizados de nome. Cole no campo os dois endereços fornecidos pela Vercel e clique em Salvar.

➡️ Conclusão

Foi tudo muito simples né? Depois desses passos você vai perceber que a Vercel fica atualizando a verificação do seu domínio, quando você perceber a frase Valid Configuration significa que deu tudo certo e seu domínio está configurado, possa ser que ele demore um pouco para propagar o que é comum, o meu levou várias horas para propagar no Brasil, eu usei a ferramenta whatsmydns.net para fazer as verificações, mas não precisa ser ansioso como eu, deixa rolar, se você seguiu todos os passos em breve seu site estará no ar com o seu domínio próprio.

Referências:

• Custom Domains - Vercel Documentation