Guias on Blog do Aquasp

Como configurar o Flutter para desenvolvimento no Ubuntu 24.04

Tue, 14 Apr 2026 01:15:39 +0000

O jeito mais rápido e fácil, com a versão mais recente do Flutter.

Passo 1: Instale o Flutter usando Snap

sudo snap install flutter --classic

Passo 2: Instale o OpenJDK

sudo apt install openjdk-17-jdk -y

Passo 3: Baixe as Android CLI Tools

Acesse este link e baixe a versão mais recente para Linux.

Crie a pasta:

mkdir ~/Android/Sdk

Garanta que você está usando exatamente esta estrutura:

~/Android/Sdk/cmdline-tools/latest/bin/ ← sdkmanager

Passo 4: Adicione ao ~/.bashrc

export ANDROID_SDK_ROOT=$HOME/Android/Sdkexport ANDROID_HOME=$ANDROID_SDK_ROOTexport
PATH=$PATH:$ANDROID_SDK_ROOT/cmdline-tools/latest/binexport PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools # Nextexport JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64export PATH=$PATH:$JAVA_HOME/binexport CHROME_EXECUTABLE=/usr/bin/brave-browser

Passo 5: Instale o sdkmanager

sdkmanager "platform-tools" "platforms;android-36" "build-tools;36.0.0"
sdkmanager --update

Passo 6: Configuração do Flutter

flutter config --android-sdk ~/Android/Sdkflutter doctor --android-licenses # Accept all

Passo 7: Verifique

flutter doctor -v

Agora você tem uma instalação limpa do Flutter sem Android Studio.

Obrigado — e bora programar! 🚀

Largue o app oficial: use sua Mi Band com privacidade usando alternativas de código aberto

Tue, 23 Dec 2025 20:23:05 +0000

Se você adora usar um vestível como a Mi Band, mas quer proteger sua privacidade (como eu), existe um ótimo jeito de fazer isso!

Primeiro, confira a compatibilidade do dispositivo

O primeiro passo é verificar se o seu dispositivo é suportado. Dispositivos da Xiaomi e da Huawei geralmente têm a melhor compatibilidade. Recomendo conferir duas alternativas populares:

GadgetBridge: totalmente de código aberto e muito focado em privacidade. Funciona de forma confiável, embora a interface não seja a mais moderna nem a mais bonita.
Notify for Mi Band: tem uma interface bem mais bonita e caprichada (na minha opinião), mas não é de código aberto, e a versão Pro (sem anúncios) custa cerca de US$ 3.

Em termos de privacidade, as duas opções são muito superiores ao app oficial da Xiaomi — sem compartilhamento constante de dados com servidores.

É quase irônico que dispositivos de marcas chinesas acabem oferecendo opções de privacidade melhores do que muitas marcas ocidentais quando usados com essas alternativas. Provavelmente é só um efeito colateral da popularidade e dos preços competitivos delas.

Extraia o token de autenticação

Infelizmente, você vai precisar do app oficial por um tempo. Baixe o app Xiaomi Mi Fitness, pareie sua pulseira, crie uma conta Xiaomi e atualize o firmware para a versão mais recente*.

Feito isso, você precisa extrair o token de autenticação (auth) da Xiaomi. O método mais fácil hoje é usar o app Notify for Mi Band.

Baixe o Notify for Mi Band na Google Play Store (existem duas versões; garanta que você está baixando a correta para o seu dispositivo)
Comece o processo de configuração no app.
Você verá duas opções para obter o token: Offline e Online.

O método offline exige exportar os logs do app oficial Mi Fitness e extrair o token deles. Tentei várias vezes, mas nunca funcionou para mim — não consegui nem encontrar os logs certos manualmente.

Por isso, recomendo fortemente o método online:

Entre com o e-mail e a senha da sua conta Xiaomi.
A Xiaomi vai mandar um código de verificação para o seu e-mail.
Digite o código, e o app vai buscar o token automaticamente para você.

Últimos passos: faça a troca e desinstale o app oficial

Depois de obter o token:

Digite-o no Notify for Mi Band (ou no GadgetBridge, se for o que você usa).
Conceda todas as permissões necessárias.
Desinstale o app oficial Mi Fitness imediatamente.

A pulseira só consegue se conectar e sincronizar com um app por vez. Manter o app oficial instalado vai causar problemas de conexão ou impedir a sincronização correta com a alternativa que você escolheu.

Pronto, está tudo configurado! Personalize as notificações, ative/desative recursos como quiser, encontre seu celular ou sua pulseira, instale mostradores gratuitos e acompanhe passos, calorias e frequência cardíaca — tudo em uma interface limpa e bonita, sem abrir mão da privacidade.

Um probleminha que notei: o monitoramento do sono não está sincronizando direito. Não sei se é algo específico da Mi Band 10, uma peculiaridade do firmware ou alguma configuração que eu mudei. Os dados continuam aparecendo corretamente na própria pulseira, então é só um problema de sincronização. Pessoalmente, não ligo — uso minha Mi Band principalmente como relógio prático, lanterna, para checar rapidamente a frequência cardíaca nos treinos e para trocar a música numa caixinha de som Bluetooth.

Pelo menos na Mi Band 10, o firmware mais recente (em dezembro de 2025) não quebrou a compatibilidade com o Notify for Mi Band.

Como ativar a decodificação de vídeo acelerada por hardware no Brave no Linux: reprodução mais fluida e mais bateria

Sun, 14 Dec 2025 01:35:15 +0000

A decodificação de vídeo acelerada por hardware tira a reprodução da CPU e passa para a GPU, o que melhora o desempenho, reduz o aquecimento e aumenta a duração da bateria — principalmente em vídeos de alta resolução. No Linux, isso funciona em navegadores baseados no Chromium, como o Brave, mas muitas vezes exige flags. Chega de depender de extensões como o h264ify ou de baixar vídeos para assistir no MPV!

Benefícios

Reprodução mais fluida em alta resolução (1080p ou mais)
Menor uso de CPU
Mais duração de bateria em notebooks

Pré-requisitos (distros baseadas no Ubuntu, como o Mint)

Para GPUs Intel (comuns em notebooks):

sudo apt update
sudo apt install intel-media-va-driver-non-free vainfo

Confira com o vainfo (ele deve listar perfis suportados, como VP9/H.264).

AMD/NVIDIA: garanta que os drivers Mesa/proprietários estejam instalados.

Ativando o suporte a flags em distros baseadas no Ubuntu

O pacote Debian do Brave não lê o brave-flags.conf por padrão (ao contrário do pacote do AUR no Arch). Crie um wrapper:

Corrija as permissões:

sudo chown --reference=/usr/bin/brave-browser-stable.original /usr/bin/brave-browser-stable
sudo chmod --reference=/usr/bin/brave-browser-stable.original /usr/bin/brave-browser-stable

Crie o novo inicializador (Bash):

sudo nano /usr/bin/brave-browser-stable

Cole:

#!/bin/sh
: $$ {XDG_CONFIG_HOME=" $${HOME}/.config"}
unset -v flags_conf
flags_conf="${XDG_CONFIG_HOME}/brave-flags.conf"
if [ -f "${flags_conf}" ]
then
 unset -v flags
 flags="$$ (sed 's/#.*//' < " $${flags_conf}" | tr '\n' ' ')"
 set -- $$ {flags} " $$@"
fi
exec /usr/bin/brave-browser-stable.original "$@"

Desvie o inicializador original:

sudo dpkg-divert --add --rename --divert /usr/bin/brave-browser-stable.original /usr/bin/brave-browser-stable

Agora crie/edite o ~/.config/brave-flags.conf para as flags.

Flags recomendadas

Adicione ao ~/.config/brave-flags.conf (em uma linha só e reinicie o Brave):

Wayland (geralmente o padrão/a melhor opção):

--enable-features=AcceleratedVideoDecodeLinuxGL,AcceleratedVideoDecodeLinuxZeroCopyGL,AcceleratedVideoEncoder

Xorg/X11 (ou como alternativa):

--enable-features=VaapiVideoDecoder,VaapiIgnoreDriverChecks,Vulkan,DefaultANGLEVulkan,VulkanFromANGLE

Verificação

Reproduza um vídeo (por exemplo, no YouTube em 1080p ou mais).
Ctrl + Shift + I → três pontos → More tools → Media.
Veja o nome do decodificador (Decoder name): VaapiVideoDecoder = acelerado pela GPU (evite o FFmpegVideoDecoder).

Créditos

Este comentário incrível no GitHub: https://github.com/brave/brave-browser/issues/2300#issuecomment-2718755680

Como sempre, a Arch Wiki é um recurso valiosíssimo para tudo relacionado a Linux. Se a aceleração de vídeo por hardware ainda não funcionar, consulte a wiki diretamente para ver as flags mais recentes e dicas de solução de problemas. https://wiki.archlinux.org/title/Chromium#Hardware_video_acceleration

7 coisas que você deve fazer depois de instalar o WordPress

Tue, 09 Dec 2025 01:45:24 +0000

Introdução

Vai começar um site WordPress do zero em 2026? Seja um blog, uma loja virtual ou um portfólio, estes ajustes vão turbinar a velocidade, reforçar a segurança e garantir um desempenho lisinho desde o primeiro dia.

Sem ferramentas pagas — só plugins gratuitos e configurações rápidas. Vamos lá!

1. Redimensione e comprima imagens automaticamente no upload

Imagens são a principal assassina de banda. Não suba uma foto de 10 MB torcendo para dar certo — automatize a compressão para manter seu site enxuto.

Plugin recomendado: Resize Image After Upload (gratuito, mais de 90 mil instalações ativas, nota 4,8/5)

Instale e ative logo de cara.
Defina a largura/altura máxima (por exemplo, 1920px de largura) e o nível de compressão (a qualidade JPEG padrão de 82% é boa).
Ele redimensiona JPEG/PNG/GIF automaticamente no upload, corta o tamanho dos arquivos em 50–80% e melhora o SEO com carregamentos mais rápidos.

Dica de mestre: para otimizar em massa as imagens que já existem, use junto com o Smush (o plano gratuito processa 50 imagens/mês).

Resultado: páginas carregam 2–3x mais rápido, menos carga no servidor e o Google mais feliz com o seu site.

2. Corte o excesso desnecessário

O WordPress vem com “extras” de que você talvez não precise — como blocos do Gutenberg, XML-RPC ou scripts de emoji. Corte a gordura para ter um núcleo mais leve.

Plugin recomendado: Unbloater (gratuito, mais de 10 mil instalações ativas, nota 5/5)

Painel simples em Configurações > Unbloater.
Opções recomendadas:
- Backend: desative as atualizações automáticas (se você faz isso manualmente), limite as revisões de posts a 3, esconda os avisos de atualização para quem não é administrador, desative o XML-RPC.
- Frontend: remova os manifestos RSD/WLW, os links curtos, os links de feed, o jQuery Migrate e os scripts de emoji.
- Editor de blocos: desative totalmente o Gutenberg (se você usa o Editor Clássico) ou remova os blocos que não usa.
- Extras: bloqueie o DNS prefetch para o WordPress.org e remova a meta tag generator.

Tudo é reversível — desative se aparecer algum problema. Isso reduz as consultas ao banco de dados e o excesso de JS/CSS em 20–30%.

3. Dome a Heartbeat API

A Heartbeat API do WordPress faz requisições ao seu servidor a cada 15–60 segundos para salvamento automático, presença de usuários etc. Ótimo para colaboração, mas faz a CPU disparar em hospedagem compartilhada.

Plugin recomendado: Heartbeat Control (gratuito, mais de 90 mil instalações ativas, nota 4,1/5)

Vá em Configurações > Heartbeat Control.
Defina os intervalos: 60 segundos (frontend), 120 segundos (painel/editor).
Ou desative totalmente no frontend se você não precisa de pré-visualizações ao vivo.

O Unbloater também resolve isso. Espere uma economia de 10–20% de CPU em sessões ociosas.

4. Limite as revisões de posts

Por padrão, o WordPress salva 25 revisões por post — inchando seu banco de dados com o tempo (por exemplo, um site com 1.000 posts = mais de 25 mil registros).

Adicione ao wp-config.php (antes de “That’s all, stop editing!”):

// Limit to 3 revisions (or false to disable)
define('WP_POST_REVISIONS', 3);

O Unbloater tem uma opção para isso. Limpe as revisões antigas com o WP-Optimize (gratuito).

Resultado: banco de dados menor = consultas e backups mais rápidos.

5. Desative o XML-RPC (a menos que você precise)

O XML-RPC permite publicar remotamente e usar apps, mas é um ímã de ataques de força bruta (a maioria dos bots mira nele).

Se você usa o Jetpack/apps de celular: mantenha, mas libere só o seu IP.
Caso contrário: bloqueie via .htaccess (Apache/LiteSpeed):

<Files xmlrpc.php>
Order Deny,Allow
Deny from all
# Allow from YOUR.IP.ADDRESS (uncomment if needed)
</Files>

O Unbloater ou o Loginizer (gratuito, mais de 1 milhão de instalações) também podem desativá-lo.

6. Proteja os logins com limite de tentativas

Os bots martelam o /wp-login.php 24/7. Limite as tentativas para barrar os ataques de força bruta de vez.

Melhor escolha: Limit Login Attempts Reloaded (gratuito, mais de 2 milhões de instalações, nota 4,9/5)

Padrão: 3 tentativas falhas → bloqueio de 15 min (que sobe para 24h).
Cobre o wp-admin, o XML-RPC, o WooCommerce e logins personalizados.
Inclui logs + notificações.

Alternativa: BruteGuard (gratuito, bloqueio de botnets na nuvem através de uma rede compartilhada).

O Loginizer (mais de 1 milhão de instalações) adiciona 2FA + reCAPTCHA como camadas extras.

Teste: tente logins errados — você verá os bloqueios na hora.

7. Avalie os plugins antes de instalar

Nem todos os plugins são iguais — alguns incham o seu site com mais de 1 MB de uso de RAM ou com erros de JS. Sempre confira:

WP Hive: extensão do Chrome + site com testes automatizados (memória, impacto na velocidade da página, compatibilidade com PHP/WordPress, espaço no banco de dados). Por exemplo, Yoast SEO 20.1: +0,1 s no carregamento, 1 MB de RAM (mais pesado que a média).
PluginTests.com: testes básicos de compatibilidade/fumaça para 98% dos plugins do WP.org (erros de ativação, quebras óbvias).

Exemplo rápido (benchmarks de 2025):

Yoast SEO: sólido, mas pesado (+0,1 s no carregamento, 1 MB de RAM). Ótimo para legibilidade.
Rank Math SEO: mais leve (sem impacto no carregamento, <250 KB de RAM), mais recursos gratuitos. Muitas vezes 4x mais rápido nos testes.

Prefira as opções leves — só adicione as “pesadas” se forem essenciais.

Resumindo

Aplique isso hoje, e o seu site vai estrear 2–3x mais rápido, mais seguro e preparado para o futuro. Tempo total: ~30 minutos. Sem desculpas!

Obrigado pela leitura! 🚀

Como evitar quedas por inatividade quando você está conectado via SSH

Tue, 09 Dec 2025 01:41:02 +0000

Introdução

Uma das coisas mais frustrantes quando se trabalha em um servidor?

Sua sessão SSH cai por causa de uma oscilação rápida no Wi-Fi, de um tempo limite por inatividade ou de uma conexão instável.

Resolva isso de vez em 30 segundos.

A solução universal: edite sua configuração do SSH

Isso funciona no Linux, macOS e Windows — e aguenta falhas de rede de até ~4–5 minutos.

Passo 1: Crie ou edite o arquivo de configuração do SSH

No Linux / macOS:

mkdir -p ~/.ssh
nano ~/.ssh/config

No Windows (PowerShell):

# Replace YourUsername with your actual Windows username
mkdir "$HOME\.ssh" -Force
notepad "$HOME\.ssh\config"

Passo 2: Adicione estas linhas

sshHost *
 ServerAliveInterval 120
 ServerAliveCountMax 3
 TCPKeepAlive yes

Salve e saia.

Pronto. É só isso.

O que isso faz de verdade

Configuração	Significado
`Host *`	Aplica estas regras a todas as conexões SSH
`ServerAliveInterval 120`	A cada 2 minutos, seu computador envia um pacotinho de “ainda estou aqui”
`ServerAliveCountMax 3`	Só se 3 pacotes seguidos falharem → aí a conexão é fechada (~6 min)
`TCPKeepAlive yes`	Keepalive extra no nível do sistema operacional (ajuda com alguns roteadores/firewalls)

Resultado: agora sua sessão SSH sobrevive a:

Troca de rede Wi-Fi
Notebook entrando e saindo da suspensão
Quedas rápidas de internet
Reconexões de VPN

…sem travar nem cair.

Agora você é inabalável

De agora em diante, quando sua internet piscar, sua sessão SSH simplesmente… espera com paciência.

Chega de “Connection reset by peer” Chega de perder sessões do tmux Chega de raiva

Você oficialmente subiu de nível.

Obrigado pela leitura — e continue conectado!

Como verificar o uso de disco por arquivo ou diretório no Linux

Tue, 09 Dec 2025 01:34:27 +0000

Introdução

Seja para investigar uma VPS lotada, fazer uma limpeza no servidor de casa ou só por curiosidade — aqui estão os comandos mais rápidos e úteis para entender o que está comendo o seu espaço em disco.

1. Encontre os maiores arquivos e pastas no diretório atual

du -shc * | sort -rh | head -15

du -shc * → mostra o tamanho de tudo na pasta atual (em formato legível, com o total)
sort -rh → ordena do maior para o menor
head -15 → mostra só os 15 maiores culpados (mude o número se precisar)

Perfeito para achar rapidinho aquele arquivo de log enorme ou aquela pasta de backup.

Dica de mestre: rode em /var, /home ou / para caçar o que está ocupando espaço.

2. Verifique o uso geral do disco (todas as partições)

df -h

Mostra:

Espaço total/usado/disponível
Porcentagem de uso
Ponto de montagem

Procure a linha com / (raiz) ou o seu disco principal. Exemplo: 64G usados / 226G no total → 28% ocupado

Adicione –exclude-type=tmpfs para esconder os sistemas de arquivos temporários:

df -h --exclude-type=tmpfs --exclude-type=devtmpfs

3. Verifique o uso de inodes (quando aparece “disco cheio”, mas o df mostra espaço livre)

Às vezes o seu disco está cheio de milhões de arquivinhos (logs, cache, sessões etc.). Cada arquivo usa um inode.

Veja os inodes por pasta no diretório atual:

du --inodes --max-depth=1 . | sort -nr

Ou no sistema todo:

df -i

Se o “IUsed” estiver perto de 100%, acabaram os inodes — hora de limpar os arquivos pequenos!

Comandos bônus de uma linha

# Top 10 biggest directories in /home
du -h /home | sort -rh | head -10

# Find files bigger than 1GB
find / -type f -size +1G 2>/dev/null

# Show only real disks (clean output)
df -h -x squashfs -x tmpfs -x devtmpfs

É só isso!

Agora você tem o kit definitivo para nunca mais ser pego de surpresa por um disco cheio.

Obrigado pela leitura!

Como exportar e importar volumes do Docker com facilidade

Tue, 09 Dec 2025 01:22:26 +0000

Se você é como eu, prefere rodar tudo em contêineres Docker. Eles são rápidos, isolados e perfeitos para rodar vários apps em uma única VPS.

Mas o que acontece quando você quer:

Mover um contêiner para um servidor novo?
Fazer backup de um volume de banco de dados (NextCloud, PhotoPrism, Vaultwarden etc.)?
Restaurar dados depois de uma pane?

O Docker não tem um botão de “exportar volume” — mas existe um truque superssimples e confiável usando um contêiner Ubuntu temporário.

Vamos lá!

Passo 1: Liste seus volumes

docker volume ls

Exemplo de saída:

DRIVER VOLUME NAME
local nextcloud_data
local photoprism_storage
local vaultwarden_data

Escolha o que você quer exportar (por exemplo, nextcloud_data).

Passo 2: Exporte um volume → backup.tar.gz

Rode este comando de uma linha (troque nextcloud_data pelo nome do seu volume):

docker run --rm -v nextcloud_data:/data -v "$(pwd)":/backup ubuntu \
 tar -czf /backup/nextcloud-data-backup.tar.gz -C /data ./

O que ele faz:

Monta o seu volume em /data dentro de um contêiner temporário
Monta a sua pasta atual em /backup
Cria um arquivo compactado com o volume inteiro

Quando terminar, você terá um arquivo como: nextcloud-data-backup.tar.gz ← pronto para baixar ou mover!

Dica de mestre: adicione a data para ficar mais claro

docker run --rm -v nextcloud_data:/data -v "$(pwd)":/backup ubuntu \
 tar -czf "/backup/nextcloud-data-$(date +%Y-%m-%d).tar.gz" -C /data ./

Passo 3: Importe no servidor novo

Copie o arquivo backup.tar.gz para o servidor novo (via scp, rsync etc.)

Depois, crie o volume vazio (importante!):

docker volume create nextcloud_data

Rode o comando de importação (a partir da pasta que contém o arquivo de backup):

docker run --rm -v nextcloud_data:/data -v "$(pwd)":/backup ubuntu \
 tar -xzf /backup/nextcloud-data-2025-04-05.tar.gz -C /data

Pronto! Seu volume foi totalmente restaurado.

Nunca deixe o Docker criar o volume automaticamente durante a importação — isso pode causar problemas de permissão ou de mistura de dados.

Bônus: usando volumes externos com o Docker Compose

Se você usa docker-compose.yml, avise o Docker que o volume é externo (já existe):

services:
 nextcloud:
 image: nextcloud:latest
 volumes:
 - nextcloud_data:/var/www/html

volumes:
 nextcloud_data:
 external: true

A indentação importa — use exatamente dois espaços.

Casos de uso reais

Migrar o NextCloud para uma VPS nova
Fazer backup do Vaultwarden antes de atualizar
Mover a biblioteca do PhotoPrism para um servidor maior
Recuperação de desastres

Este método é 100% confiável, funciona com qualquer volume e não exige nenhuma ferramenta extra.

Agora você tem uma estratégia de backup de volumes Docker à prova de balas.

Boa conteinerização! 🐳

Obrigado pela leitura!

Como hospedar em casa com facilidade e colocar seus projetos online mesmo atrás de CGNAT

Tue, 09 Dec 2025 01:13:41 +0000

Introdução

Quer rodar serviços pesados em um servidor potente em casa, mesmo com o seu provedor te colocando atrás de CGNAT? Este guia mostra exatamente como colocá-los online — do jeito clássico e à prova de balas, usando túneis SSH reversos.

Sem Cloudflare Tunnel. Sem Ngrok. Só SSH + systemd.

As desvantagens (e por que dá para lidar com elas)

Internet de casa não tem a qualidade de um datacenter (quedas acontecem)
A maioria dos provedores usa CGNAT → não dá para abrir portas do jeito normal

Solução: use uma VPS barata como “ponte” pública. Seu servidor pesado fica em casa. A VPS só encaminha as portas.

Como funciona – a mágica dos túneis SSH reversos (-R)

Internet → Cheap VPS (public IP) → SSH reverse tunnel → Your home server (behind CGNAT)

O seu servidor de casa abre uma conexão SSH de saída até a VPS e diz: “Tudo o que chegar na sua porta 8096 → mande para o meu Jellyfin local na 8096”

Nenhuma porta aberta no roteador de casa. Nenhuma exposição.

Configuração passo a passo

1. No seu servidor de casa (o potente)

# Create folder for tunnel configs
sudo mkdir -p /etc/sshtunnels

# Example: expose Jellyfin (port 8096)
sudo nano /etc/sshtunnels/jellyfin.conf

Conteúdo do arquivo:

8096:8096 # remote_port:local_port
443:8443 # optional: HTTPS reverse proxy on VPS → your local 8443
80:8080

Uma linha por serviço. O primeiro número = porta na VPS, o segundo = porta no seu servidor de casa.

2. Gere uma chave SSH (se você ainda não tiver uma)

ssh-keygen -t ed25519 -C "home-server-tunnel"

Copie a chave pública para a sua VPS:

ssh-copy-id user@your-vps-ip

3. Crie o script que gerencia os túneis

sudo nano /usr/local/bin/sshtunnel.sh

#!/bin/bash

# === EDIT THESE ===
REMOTE_USER="root" # or your VPS user
REMOTE_HOST="123.45.67.89" # your VPS public IP
SSH_KEY="/home/youruser/.ssh/id_ed25519"
SSH_PORT="22" # change if you use a non-standard port
# ==================

INSTANCE="$1"
CONFIG_FILE="/etc/sshtunnels/${INSTANCE}.conf"

if [[ ! -f "$CONFIG_FILE" ]]; then
 echo "Error: Config file $CONFIG_FILE not found!"
 exit 1
fi

# Build -R arguments
FORWARD_OPTS=""
while IFS=: read -r remote_port local_port; do
 [[ -z "$remote_port" || "$remote_port" =~ ^# ]] && continue
 # Clean any old process using the remote port
 ssh -p "$SSH_PORT" "$REMOTE_USER@$REMOTE_HOST" \
 "lsof -i :$remote_port -t | xargs -r kill -9" 2>/dev/null
 FORWARD_OPTS="$FORWARD_OPTS -R $remote_port:localhost:$local_port"
done < "$CONFIG_FILE"

echo "Starting tunnel $INSTANCE → $REMOTE_HOST ($FORWARD_OPTS)"

exec ssh -o StrictHostKeyChecking=no \
 -o ServerAliveInterval=30 \
 -o ServerAliveCountThreshold=3 \
 -o ExitOnForwardFailure=yes \
 -o GatewayPorts=yes \
 -N -T \
 -i "$SSH_KEY" \
 -p "$SSH_PORT" \
 $FORWARD_OPTS \
 "$REMOTE_USER@$REMOTE_HOST"

Torne-o executável:

sudo chmod +x /usr/local/bin/sshtunnel.sh

4. Crie um serviço do systemd (início e reconexão automáticos)

sudo nano /etc/systemd/system/sshtunnel@.service

[Unit]
Description=SSH Reverse Tunnel for %i
After=network-online.target
Wants=network-online.target

[Service]
User=youruser # ← change to your home user (not root!)
Group=youruser
ExecStart=/usr/local/bin/sshtunnel.sh %i
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Recarregue e ative:

sudo systemctl daemon-reload

# Start a tunnel (example: jellyfin)
sudo systemctl enable --now sshtunnel@jellyfin.service

Confira o status:

sudo systemctl status sshtunnel@jellyfin.service

5. No lado da VPS (opcional, mas recomendado)

Instale um servidor web pequeno ou o Caddy/nginx para cuidar do TLS e fazer proxy para as portas encaminhadas.

Exemplo com o Caddy (HTTPS automático):

# On the VPS
apt install caddy

# /etc/caddy/Caddyfile
jellyfin.yourdomain.com {
 reverse_proxy localhost:8096
}

Agora jellyfin.yourdomain.com → o seu Jellyfin de casa, totalmente criptografado.

Tudo rodando no meu servidor parrudo de casa, atrás de CGNAT.

Vantagens desta configuração

Funciona atrás de qualquer CGNAT / bloqueio do provedor
Nenhuma dependência de terceiros (sem Cloudflare, sem Ngrok)
Criptografia completa possível
Sobrevive a reinicializações (systemd + Restart=always)
Custa quase nada

Palavras finais

Este é o jeito realmente bacana que encontrei para hospedar serviços pesados em casa em 2025.

O seu hardware potente fica em casa. A sua VPS de US$ 1/mês é só uma guarda de trânsito.

Obrigado pela leitura — agora vá montar o seu home lab imbatível!

Como fazer backup automático do seu blog Ghost auto-hospedado

Tue, 09 Dec 2025 01:05:55 +0000

Introdução

O Ghost é uma plataforma de blog incrivelmente rápida e elegante. Mas, ao contrário do WordPress, ele não tem plugins de backup com um clique.

Isso muda hoje.

Neste guia, você vai configurar um sistema de backup diário totalmente automatizado que:

Faz o dump do seu banco de dados MySQL
Faz backup de todos os temas, imagens e conteúdos
Compacta tudo em um único .zip
Envia o arquivo com segurança para o seu armazenamento na nuvem (pCloud, NextCloud, Google Drive, Dropbox etc.)

Tudo usando ferramentas gratuitas: rclone + um script bash simples + cron.

Vamos começar.

Passo 1: Instale o Rclone

sudo apt update && sudo apt install -y rclone

O Rclone é o canivete suíço do armazenamento na nuvem — ele suporta mais de 70 provedores.

Lista completa: https://rclone.org/overview/

Passo 2: Configure o Rclone (conecte seu armazenamento na nuvem)

Rode:

rclone config

Siga as perguntas:

n → novo remote
Dê um nome como ghost-backup ou pcloud
Escolha seu provedor (por exemplo, webdav para NextCloud, pcloud, google drive etc.)
Informe suas credenciais/URL quando for pedido

Teste se funciona:

rclone ls ghost-backup:

Você deve ver os arquivos do seu remote (ou uma pasta vazia, se for novo).

Digite q para sair.

Passo 3: Pegue as credenciais do banco de dados do Ghost

Entre com o usuário do Ghost (não o root):

su - yourghostuser
cd /var/www/ghost # or wherever you installed Ghost
cat config.production.json

Procure a seção do banco de dados. Você verá algo assim:

"database": {
 "client": "mysql",
 "connection": {
 "host": "localhost",
 "user": "ghost_db_user",
 "password": "yoursecretpassword",
 "database": "ghost_prod"
 }
}

Anote:

Nome do banco de dados (ghost_prod)
Usuário (ghost_db_user)
Senha

Passo 4: Crie o script de backup

Crie o script como root:

nano /root/backup-ghost.sh

Cole isto (depois edite as variáveis abaixo):

#!/bin/bash

# === EDIT THESE VALUES ===
GHOST_USER="yourghostuser" # e.g. ghost
GHOST_PATH="/var/www/ghost" # path to your Ghost install
DB_NAME="ghost_prod" # from config.production.json
DB_USER="ghost_db_user" # from config.production.json
DB_PASS="yoursecretpassword" # from config.production.json
BACKUP_NAME="theselfhostingart-blog" # name for your backup zip
RCLONE_REMOTE="ghost-backup" # name you gave in rclone config
RCLONE_PATH="/" # folder in your cloud (use / for root)
# =========================

DATE=$(date +'%Y-%m-%d_%H-%M')
BACKUP_DIR="/home/$GHOST_USER/backups/$DATE"
ZIP_FILE="$BACKUP_DIR/$BACKUP_NAME-$DATE.zip"

echo "Starting Ghost backup: $DATE"

# Create backup directory
mkdir -p "$BACKUP_DIR"

# Backup database
echo "Backing up database..."
mysqldump -u "$DB_USER" -p"$DB_PASS" --add-drop-table "$DB_NAME" | gzip > "$BACKUP_DIR/db.sql.gz"

# Backup content folder (themes, images, etc.)
echo "Backing up content folder..."
rsync -av --exclude='logs' --exclude='cache' "$GHOST_PATH/content/" "$BACKUP_DIR/content/"

# Compress everything
echo "Compressing backup..."
zip -r "$ZIP_FILE" "$BACKUP_DIR/content" "$BACKUP_DIR/db.sql.gz" > /dev/null

# Upload to cloud
echo "Uploading to cloud storage..."
rclone copy "$ZIP_FILE" "$RCLONE_REMOTE:$RCLONE_PATH"

# Cleanup: remove local backups older than 1 day (optional but recommended)
echo "Cleaning up old local backups..."
find /home/$GHOST_USER/backups -type d -mtime +1 -exec rm -rf {} +

echo "Backup complete: $ZIP_FILE → $RCLONE_REMOTE:$RCLONE_PATH"

Torne-o executável:

chmod +x /root/backup-ghost.sh

Teste manualmente primeiro:

/root/backup-ghost.sh

Confira seu armazenamento na nuvem — você deve ver um arquivo como: theselfhostingart-blog-2025-04-05_03-22.zip

Passo 5: Automatize com o cron (backups diários)

crontab -e

Adicione esta linha para um backup diário às 2h da manhã:

cron0 2 * * * /usr/bin/bash /root/backup-ghost.sh >> /var/log/ghost-backup.log 2>&1

Salve e saia.

Agora o seu blog Ghost tem backup automático todos os dias.

O que entra no backup?

Banco de dados completo (posts, usuários, configurações)
Todas as imagens enviadas
Temas personalizados
Tudo o que é preciso para restaurar ou migrar

Você pode até mandar esse .zip para o suporte do Ghost(Pro) — eles conseguem importá-lo diretamente.

Bônus: restaure em caso de desastre

Para restaurar:

Instale um Ghost novo
Descompacte o backup
Importe o banco: gunzip < db.sql.gz | mysql -u user -p dbname
Substitua a pasta content/
Rode ghost restart

Créditos e agradecimentos

Este método foi inspirado e aprimorado a partir deste excelente post: How to Automatically Backup Ghost Blogs – Kenton Vizdos

Obrigado, Kenton!

Agora o seu blog auto-hospedado dorme mais tranquilo à noite. 😴💾

Obrigado pela leitura!

Como instalar o NextCloud com OpenLiteSpeed (stack LOMP)

Tue, 09 Dec 2025 00:59:45 +0000

Introdução

Hoje vou mostrar como montar o que eu sinceramente acredito ser a stack de NextCloud mais rápida disponível em 2025:

OpenLiteSpeed – o servidor web mais rápido, com cache embutido
LSPHP 8.1/8.2 – a implementação ultrarrápida de PHP da LiteSpeed
Redis + APCu – para cache e travamento (locking) ultrarrápidos
Roda totalmente sem root, com o seu próprio usuário
Protegido com cabeçalhos de segurança adequados, HSTS e pasta de dados isolada

Mesmo que o NextCloud seja comprometido, o invasor ainda não consegue mexer no resto do seu servidor.

Vamos lá!

Passo 1: Proteja sua VPS primeiro

Antes de tudo, proteja o seu servidor. Siga o meu guia completo aqui: Como deixar sua VPS segura

Passo 2: Instale o OpenLiteSpeed, o LSPHP, o Redis e as ferramentas

Rode como root:

# Update system
apt update && apt upgrade -y

# Add OpenLiteSpeed repository
wget -O - https://repo.litespeed.sh | bash

# Install essentials
apt install -y curl gnupg2 imagemagick ffmpeg redis openlitespeed lsphp81* lsphp82* zip unzip mariadb-server mariadb-client

Observação: no Ubuntu 22.04+, o pacote do ImageMagick pode ser libmagickwand-dev + imagemagick. O comando acima funciona na maioria das versões recentes do Debian/Ubuntu.

Ative e reinicie o Redis:

systemctl enable --now redis-server

Passo 3: Crie um usuário de sistema dedicado para o NextCloud

adduser --shell /bin/bash files
usermod -aG redis files # Allow access to Redis socket

Passo 4: Baixe e extraia o NextCloud como o usuário “files”

su - files
mkdir -p ~/public_html
cd ~/public_html

wget https://download.nextcloud.com/server/releases/latest.zip
unzip latest.zip
rsync -av nextcloud/ ./
rm -rf nextcloud latest.zip .htaccess .user.ini
exit

Passo 5: Configure o painel web de administração do OpenLiteSpeed (porta 7080)

Defina uma senha de administrador:

/usr/local/lsws/admin/misc/admpass.sh

Agora acesse: https://your-vps-ip:7080 e entre.

Configuração do Virtual Host

Apague o virtual host padrão “Example”
Adicione um novo Virtual Host:

Virtual Host Name: yourdomain.com
Virtual Host Root: /home/files/
Config File: $SERVER_ROOT/conf/vhosts/$VH_NAME/vhconf.conf
Document Root: $VH_ROOT/public_html

Script Handler → Add:

Suffix: php
Handler Type: LiteSpeed LVE
Handler: lsphp81 (ou lsphp82, se preferir o PHP 8.2)

Rewrite Rules (forçar HTTPS):

RewriteEngine On
RewriteCond %{HTTPS} !=on
RewriteRule ^(.*)$ https://%{HTTP_HOST}$1 [R=301,L]

Cabeçalhos de segurança (Context → Static → adicione um novo context /):

Strict-Transport-Security "max-age=63072000; includeSubDomains; preload"
Content-Security-Policy "upgrade-insecure-requests"

External App → LSPHP → Edit:

Run as User/Group: files
PHP_LSAPI_CHILDREN = 100
LSAPI_AVOID_FORK = 0

Listeners:

Apague os listeners padrão
Adicione HTTP → porta 80
Adicione HTTPS → porta 443 (Secure = Yes)
Associe o seu domínio aos dois listeners

Reinício suave (graceful restart) → OpenLiteSpeed → Graceful Restart

Passo 6: Emita o SSL do Let’s Encrypt

apt install -y certbot
certbot certonly --webroot -w /home/files/public_html -d yourdomain.com

Anote os caminhos (você vai precisar deles):

Fullchain: /etc/letsencrypt/live/yourdomain.com/fullchain.pem
Privkey: /etc/letsencrypt/live/yourdomain.com/privkey.pem

Adicione-os em:

Virtual Host → aba SSL
Listener HTTPS → aba SSL
Chained Certificate = Yes

Faça o graceful restart de novo.

Passo 7: Renovação automática do SSL

crontab -e

Adicione:

cron0 3 * * * /usr/bin/certbot renew --quiet

Passo 8: Instale e proteja o MariaDB/MySQL

mysql_secure_installation

Depois, crie o banco de dados e o usuário:

mysql -u root -p
CREATE DATABASE nextcloud CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
CREATE USER 'ncuser'@'localhost' IDENTIFIED BY 'strong-password-here';
GRANT ALL PRIVILEGES ON nextcloud.* TO 'ncuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Passo 9: Otimize o PHP e ative o OPCache + APCu

# Edit the correct php.ini (adjust path if using lsphp82)
sed -i '/usr/local/lsws/lsphp81/etc/php/8.1/litespeed/php.ini' \
 -e 's/memory_limit = .*/memory_limit = 1024M/' \
 -e 's/upload_max_filesize = .*/upload_max_filesize = 10G/' \
 -e 's/post_max_size = .*/post_max_size = 10G/' \
 -e 's/max_execution_time = .*/max_execution_time = 3600/' \
 -e 's/opcache.enable=.*/opcache.enable=1/' \
 -e 's/;opcache.memory_consumption=.*/opcache.memory_consumption=512/' \
 -e 's/;opcache.interned_strings_buffer=.*/opcache.interned_strings_buffer=64/' \
 -e 's/;opcache.max_accelerated_files=.*/opcache.max_accelerated_files=20000/'

# Enable APCu CLI
echo "apc.enable_cli = 1" >> /usr/local/lsws/lsphp81/etc/php/8.1/litespeed/php.ini

pkill -f lsphp
systemctl restart lsws

Passo 10: Configure o Redis como socket Unix

sed -i 's/port 6379/port 0/' /etc/redis/redis.conf
sed -i 's|# unixsocket /var/run/redis/redis-server.sock|unixsocket /var/run/redis/redis-server.sock|' /etc/redis/redis.conf
sed -i 's/# unixsocketperm 700/unixsocketperm 770/' /etc/redis/redis.conf
sed -i 's/# maxmemory .*/maxmemory 1gb/' /etc/redis/redis.conf

systemctl restart redis-server

Passo 11: Configuração final do NextCloud

Mova a pasta de dados para fora da raiz web (essencial!)

Durante a instalação, defina o diretório de dados como: /home/files/data

su - files
nano /home/files/public_html/config/config.php

Adicione logo depois de ‘installed’ => true,:

'memcache.local' => '\\OC\\Memcache\\APCu',
 'memcache.distributed' => '\\OC\\Memcache\\Redis',
 'memcache.locking' => '\\OC\\Memcache\\Redis',
 'redis' => [
 'host' => '/var/run/redis/redis-server.sock',
 'port' => 0,
 ],

Configure as tarefas em segundo plano (cron)

su - files
crontab -e

Adicione:

cron*/5 * * * * /usr/local/lsws/lsphp81/bin/php -f /home/files/public_html/cron.php

Depois, no NextCloud, vá em Administração → Configurações básicas → Tarefas em segundo plano → selecione Cron (recomendado).

Bônus: deixe o occ fácil de usar para sempre

su - files
echo "alias occ='/usr/local/lsws/lsphp81/bin/php /home/files/public_html/occ'" >> ~/.bashrc
source ~/.bashrc

Agora, de qualquer lugar dentro de ~/public_html:

cd ~/public_html
occ status
occ maintenance:repair
occ db:add-missing-indices

Pronto!

Agora você tem:

A stack de NextCloud mais rápida (OpenLiteSpeed + Redis + APCu)
Totalmente sem root e isolada
Renovação automática do SSL
Cabeçalhos de segurança reforçados
Proteção adequada da pasta de dados

Aproveite a sua nuvem privada e ultrarrápida!

Obrigado pela leitura! 🚀

Como deixar sua VPS mais segura contra exclusões acidentais

Tue, 09 Dec 2025 00:31:57 +0000

Introdução

Você já apagou um arquivo ou uma pasta sem querer em uma VPS? Essa sensação é horrível. Às vezes você está trabalhando rápido e apaga um arquivo/pasta muito importante. Isso já aconteceu comigo. Hoje quero compartilhar com vocês uma ferramenta incrível: o trash-cli . Ele adiciona uma lixeira na linha de comando para evitar esses erros humanos.

Instalando o trash-cli

O trash-cli é uma ferramenta de linha de comando leve, disponível nos repositórios do Debian, o que a torna ideal para VPSs com poucos recursos.

Passos da instalação

Atualize a sua lista de pacotes:

sudo apt update

Instale o trash-cli:

sudo apt install trash-cli

Confira a instalação:

trash --version

Se tudo foi instalado corretamente, você verá as informações da versão.

O processo é rápido e quase não pesa na sua VPS.

Usando o trash-cli para apagar com mais segurança

Depois de instalado, o trash-cli oferece comandos para gerenciar arquivos com segurança. Ele move os itens para ~/.local/share/Trash/ em vez de apagá-los.

Comandos básicos

Mandar um arquivo ou diretório para a lixeira: trash file.txt ou trash directory.
Listar os itens na lixeira: trash-list (mostra os arquivos com as datas de exclusão).
Restaurar itens: trash-restore (menu interativo para escolher e recuperar arquivos).
Esvaziar a lixeira: trash-empty (apaga permanentemente todos os itens da lixeira).
Esvaziar itens antigos: trash-empty 30 (apaga itens com mais de 30 dias).

Exemplo de fluxo de trabalho:

trash important_file.txt # Move to trash
trash-list # Check what's there
trash-restore # Recover if needed

Isso substitui o uso arriscado do rm no dia a dia.

Criando um alias do rm para usar o trash-cli

Para deixar o rm mais seguro por padrão, crie um alias dele para o trash na configuração do seu shell. Assim, a maioria das exclusões vai para a lixeira.

Configurando o alias

Edite o seu arquivo ~/.bashrc:

nano ~/.bashrc

Adicione esta linha no final:

alias rm='trash'

Salve e saia (Ctrl+X, Y, Enter).
Recarregue a configuração:

source ~/.bashrc

Agora, rm file.txt vai usar o trash em vez de apagar permanentemente.

Automatizando o esvaziamento da lixeira com o cron

Para a lixeira não acumular indefinidamente, automatize o esvaziamento com uma tarefa no cron.

Configurando o esvaziamento semanal

Edite o seu crontab:

crontab -e

Adicione esta linha para a exclusão semanal (por exemplo, todo domingo às 2h da manhã):

0 2 * * 0 /usr/bin/trash-empty

0 2 * * 0: domingo às 2h da manhã.
/usr/bin/trash-empty: limpa toda a lixeira.

Salve e saia.
Confira:

crontab -l

Ajuste o agendamento como precisar (por exemplo, troque 0 por 1-6 para os dias de semana). Para esvaziar só uma parte, use trash-empty 30 para apagar os itens com mais de 30 dias.

Conclusão

Instalando o trash-cli, criando um alias do rm para o trash e configurando o esvaziamento automático, você deixa sua VPS muito mais segura contra exclusões acidentais. Essa abordagem adiciona uma camada recuperável sem sacrificar o desempenho. Lembre-se de combiná-la com backups regulares e cuidado ao usar comandos. Se você é novo na administração de VPS, comece aos poucos e teste bem. Para configurações mais avançadas, explore a integração com ferramentas de monitoramento. Fique seguro por aí!

Como deixar sua VPS segura

Tue, 09 Dec 2025 00:30:29 +0000

Introdução

Se você acabou de comprar uma VPS e está começando a hospedar seus próprios serviços, esta é uma das melhorias de segurança mais importantes que você pode fazer.

Ao trocar para autenticação por chave SSH e desativar o login por senha, seu servidor fica praticamente imune a ataques de força bruta — mesmo que alguém descubra sua senha ou que você ainda esteja usando a porta padrão 22.

Passo 1: Gere um par de chaves SSH na sua máquina local

Linux e macOS

Abra um terminal e rode:

ssh-keygen -t rsa -b 4096

ou (formato mais novo, recomendado):

Bash

ssh-keygen -t ed25519

Aperte Enter para aceitar o local padrão do arquivo e deixe a senha da chave (passphrase) em branco (é só apertar Enter duas vezes).

Suas chaves serão salvas como:

Chave privada: ~/.ssh/id_rsa ou ~/.ssh/id_ed25519
Chave pública: ~/.ssh/id_rsa.pub ou ~/.ssh/id_ed25519.pub

Nunca compartilhe a chave privada!

Windows (PowerShell)

Abra o PowerShell e rode:

ssh-keygen.exe -t ed25519

(ou -t rsa -b 4096 se o ed25519 não for suportado)

Aperte Enter em todas as perguntas (sem passphrase). As chaves serão criadas em C:\Users\YourUser.ssh\

Passo 2: Copie sua chave pública para a VPS

Linux e macOS (método mais fácil)

ssh-copy-id user@your-vps-ip

Troque user e your-vps-ip pelo seu nome de usuário e pelo IP do servidor.

Windows

Cole sua chave pública (é uma linha longa que começa com ssh-ed25519 ou ssh-rsa) → salve com Ctrl+O → Enter → Ctrl+X
Teste: abra um terminal/PowerShell novo e tente entrar. Deve funcionar sem pedir senha.

Edite o arquivo: (Bash)

nano ~/.ssh/authorized_keys

Crie a pasta .ssh e o arquivo authorized_keys (se ainda não existirem): (Bash)

mkdir -p ~/.ssh
chmod 700 ~/.ssh
touch ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Entre na sua VPS normalmente (com senha): (PowerShell)

ssh user@your-vps-ip

Copie sua chave pública para a área de transferência: (PowerShell)

Get-Content $HOME\.ssh\id_ed25519.pub | Set-Clipboard

(ou id_rsa.pub se você usou RSA)

Passo 3: Desative a autenticação por senha

Agora que o login com chave funciona, desative completamente o login por senha.

Entre na sua VPS (usando sua chave) e edite a configuração do SSH:

sudo nano /etc/ssh/sshd_config

Encontre e altere (ou adicione) estas linhas:

PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM no
PubkeyAuthentication yes

Salve e saia.

Reinicie o serviço SSH:

sudo systemctl restart sshd

(ou sudo service ssh restart em sistemas mais antigos)

Teste final: tente entrar a partir de um terminal novo. Só deve funcionar com a sua chave privada — tentativas com senha serão recusadas na hora.

Pronto!

Agora sua VPS está protegida contra:

Ataques de força bruta
Credential stuffing (uso de senhas vazadas em massa)
Senhas fracas ou vazadas

Mesmo que um invasor saiba seu usuário e sua senha, ele não consegue entrar sem o arquivo da sua chave privada.

Dica de mestre: guarde um backup da sua chave privada em local seguro e considere adicionar uma passphrase depois, usando ssh-keygen -p.

Obrigado pela leitura! 😊

Como remover os limites de upload do All In One WP Migration

Tue, 09 Dec 2025 00:25:04 +0000

Introdução

Infelizmente, muitas hospedagens impõem limites de upload bem baixos (às vezes só 2–50 MB), e a Unlimited Extension oficial custa US$ 69.

Se você está nessa situação e precisa de um jeito gratuito de enviar backups enormes (10 GB, 40 GB ou mais), este truque simples vai ajudar.

A solução: use o plugin “Big File Uploads”

A versão gratuita do All-in-One WP Migration não limita os uploads artificialmente — ela só respeita o limite que a sua hospedagem ou servidor impõe. A Unlimited Extension paga funciona dividindo o arquivo .wpress em pedaços menores durante o upload.

A boa notícia: existe um plugin totalmente gratuito que faz exatamente o mesmo truque de dividir em pedaços!

Guia passo a passo

Instale e ative o plugin chamado Big File Uploads → Link direto: https://wordpress.org/plugins/tuxedo-big-file-uploads/
Depois de ativar, vá em: Configurações → Big File Uploads (ou encontre na página de Plugins → link “Configurações” embaixo do nome do plugin)
Você verá o tamanho máximo de upload atual (no começo, ele será igual ao limite padrão da sua hospedagem).
Mude para o valor que quiser:

1 GB = 1024 MB
10 GB = 10240 MB
40 GB = 40960 MB (Basta digitar o número em megabytes — não precisa colocar “MB” nem “GB”)

Clique em Salvar alterações

Pronto! O novo limite vale na hora.

Agora, quando você voltar em All-in-One WP Migration → Importar, o tamanho máximo de arquivo vai mostrar o novo valor (até 40 GB ou mais funciona perfeitamente).

Conclusão

Isto não é um ataque à ServMask — eles criaram um plugin incrível e merecem todo o apoio. Se você puder pagar, compre a Unlimited Extension oficial.

Mas, se o orçamento estiver apertado e você só precisa migrar ou restaurar um site enorme uma ou duas vezes, o plugin Big File Uploads é uma alternativa 100% gratuita e confiável, que funciona perfeitamente com a versão gratuita do All-in-One WP Migration.

Obrigado pela leitura! 🙂

Como rodar o seu próprio nó de Monero

Tue, 09 Dec 2025 00:07:50 +0000

Introdução

Na minha opinião, o Monero é uma das criptomoedas mais importantes. Ele não tem a mesma participação de mercado que o Bitcoin, mas é bem único em um aspecto: privacidade. O Monero é igualzinho a dinheiro vivo — ninguém precisa saber quanto Monero foi enviado nem quem enviou. Nesse ponto, ele é o oposto do Bitcoin. Na verdade, quando o assunto é privacidade, o Bitcoin é pior que o dinheiro fiduciário.

Você pode ler mais detalhes aqui: https://lukesmith.xyz/articles/monero-maximalism-or-how-bitcoin-is-a-coin/

Obs.: eu NÃO estou recomendando que ninguém invista em Monero. O Monero foi feito para ser uma moeda, mas, como as criptomoedas ainda são extremamente voláteis, muita gente o trata como investimento. Faça sua própria pesquisa — não me responsabilizo por nenhum investimento que você fizer.

1. Escolha uma VPS ou monte em casa

Antes de tudo, você vai precisar de um servidor. Pode usar o seu próprio PC de casa, se preferir, ou uma VPS. A VPS é mais fácil, porque fica online 24/7 e você sempre consegue abrir as portas necessárias.

Em casa, muitos provedores bloqueiam as portas de entrada, então o seu nó não seria público (ele ainda ajudaria a rede, mas você não conseguiria se conectar a ele de fora com facilidade sem algo como o ngrok).

Eu, pessoalmente, recomendo a Contabo para rodar um nó de Monero, porque eles têm ótimos preços nos planos de VPS de armazenamento. Veja os preços aqui: Contabo Storage VPS

A Storage VPS S é mais que suficiente. Hoje a blockchain do Monero ocupa cerca de 175 GB, usa menos de 2 GB de RAM e quase nada de CPU depois de totalmente sincronizada (~3 % de uso).

2. Protegendo a VPS

Antes de tudo, desative o login por senha.

Depois, instale e configure o UFW (se ainda não estiver configurado):

sudo apt install ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 18080
sudo ufw allow 18089
sudo ufw enable

3. Criando um usuário dedicado

Por segurança, nunca rode o Monero como root. Em vez disso, crie um usuário normal:

adduser monerouser

Defina uma senha e aperte Enter no resto das perguntas.

4. Mudando as configurações e sincronizando o nó

Troque para o novo usuário:

su monerouser
cd ~

Baixe os binários oficiais do Monero CLI (Linux 64 bits):

wget -c https://downloads.getmonero.org/cli/monero-linux-x64-v0.18.3.4.tar.bz2
mkdir monero
tar -xjvf monero-linux-x64-v0.18.3.4.tar.bz2 -C monero --strip-components=1

(Se precisar, troque a versão na URL/no nome do arquivo pela mais recente em https://getmonero.org.)

Entre na pasta e inicie o monerod uma vez só para criar os arquivos de configuração (pare depois de alguns segundos com Ctrl+C):

cd monero
./monerod

Agora edite o arquivo de configuração:

nano ~/.bitmonero/bitmonero.conf

Cole as configurações recomendadas a seguir:

# P2P full node
public-node=true # Advertises the RPC-restricted port over p2p

# RPC settings
rpc-restricted-bind-ip=0.0.0.0
rpc-restricted-bind-port=18089

# Node settings
enforce-dns-checkpointing=true
db-sync-mode=safe # Slow but reliable db writes
enable-dns-blocklist=true # Block known-malicious nodes
no-igd=true # Disable UPnP
no-zmq=true

# Bandwidth settings (much faster sync + better contribution)
out-peers=32
in-peers=32
limit-rate-up=1048576 # 1 GB/s upload
limit-rate-down=1048576 # 1 GB/s download

Salve com Ctrl+O → Enter → Ctrl+X.

Inicie o nó em modo destacado (em segundo plano):

./monerod --detach

Pronto! Agora é só esperar ele sincronizar por completo.

Confira o status da sincronização quando quiser com:

./monerod status

A sincronização inicial costuma levar algumas horas, dependendo da sua conexão e da velocidade da VPS.

Depois de totalmente sincronizado, você pode conectar qualquer carteira Monero (Cake Wallet, Monero GUI, Feather etc.) ao seu próprio nó usando o IP da sua VPS e a porta 18089.

Conclusão e créditos

É só isso! A comunidade do Monero incentiva muito que cada um rode o próprio nó completo. Isso deixa a rede mais descentralizada e dá a você o máximo de privacidade.

Este guia não teria sido possível sem estes excelentes materiais:

Obrigado pela leitura! 🙂

Como hospedar sua própria instância do Piped

Mon, 08 Dec 2025 23:58:10 +0000

Introdução

O Piped é um front-end alternativo e de código aberto para o YouTube, focado em privacidade. Sem rastreamento do Google, sem anúncios (nem nos vídeos que normalmente têm anúncios que não dá para pular), e funciona perfeitamente com o SponsorBlock e o DeArrow.

Hospedar sua própria instância com Docker é incrivelmente fácil e leva menos de 20 minutos.

Requisitos

Um domínio (ou subdomínio)
Uma VPS KVM barata com suporte a Docker (evite OpenVZ — kernel antigo)
~US$ 3–6/mês é mais que suficiente (1 CPU, 1–2 GB de RAM)

Ótimos provedores baratos em 2025:

RackNerd
Hostinger (meu link de afiliado, se quiser apoiar: https://hostinger.com.br?REFERRALCODE=waterdownfall)
Cloudcone, Hetzner Cloud, BuyVM etc.

Passo 1: Proteja e prepare sua VPS

(Só chaves SSH, firewall etc. — faça isso primeiro!)

Depois, instale o Docker (exemplo para Ubuntu/Debian):

apt update && apt upgrade -y
apt install -y ca-certificates curl gnupg lsb-release

# Add Docker repo
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" > /etc/apt/sources.list.d/docker.list

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Passo 2: Implante o Piped com a configuração oficial em Docker

cd /opt
git clone https://github.com/TeamPiped/Piped-Docker
cd Piped-Docker
./configure-instance.sh

Durante o script:

Escolha o Caddy como proxy reverso (o mais fácil, com SSL automático)
Informe seu domínio e os subdomínios:
- Frontend → piped.yourdomain.com
- API do backend → pipedapi.yourdomain.com
- Proxy → pipedproxy.yourdomain.com

Passo 3: Aponte o DNS para sua VPS

Crie três registros A no seu provedor de DNS:

piped.yourdomain.com → VPS_IP
pipedapi.yourdomain.com → VPS_IP
pipedproxy.yourdomain.com → VPS_IP

Passo 4: Suba tudo

docker compose up -d

Pronto! Depois que o DNS propagar (normalmente em menos de 10 minutos), o seu YouTube privado estará no ar em:

https://piped.yourdomain.com

O Caddy cuida automaticamente do SSL gratuito do Let’s Encrypt — sem precisar mexer no certbot manualmente.

Passo 5: (Opcional) Confira os logs

Bash

# See what Caddy is doing
docker logs -f caddy

# Or any other container
docker logs -f piped-frontend

Dicas bônus

Quer deixar pública? É só compartilhar a URL — qualquer pessoa pode usar a sua instância.
Quer deixar privada? Bloqueie com regras de firewall do Cloudflare ou com autenticação básica no Caddy.
Use junto com o app LibreTube (Android) para ter a experiência completa sem Google.

Agora você tem o seu próprio YouTube sem anúncios, sem rastreamento e com SponsorBlock — totalmente sob o seu controle.

Obrigado pela leitura!

Como instalar o WordPress em LEMP com Redis e WP-CLI no Debian 11

Mon, 08 Dec 2025 23:47:36 +0000

Introdução

Este é o jeito mais rápido, mais seguro e que mais economiza recursos para hospedar o WordPress por conta própria em 2025. Vamos usar uma stack LEMP de verdade (Linux + Nginx + MySQL/MariaDB + PHP-FPM) com isolamento de PHP por site, cache de objetos com Redis, SSL automático e WP-CLI — tudo ajustado para velocidade e segurança.

Vamos lá.

Passo 0: Proteja e atualize sua VPS

(Se ainda não fez isso, siga primeiro um guia de proteção de VPS — só chaves SSH, firewall, fail2ban etc.)

apt update && apt upgrade -y
apt autoremove --purge
reboot

Passo 1: Instale a stack principal

# Nginx
apt install nginx -y
systemctl enable nginx

# MariaDB (better than MySQL on Debian)
apt install mariadb-server -y
systemctl enable mariadb

# PHP 8.3 + all needed extensions (using ondrej/sury repo)
apt install ca-certificates apt-transport-https lsb-release -y
wget -qO- https://packages.sury.org/php/apt.gpg | gpg --dearmor > /usr/share/keyrings/sury-php.gpg
echo "deb [signed-by=/usr/share/keyrings/sury-php.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/sury-php.list
apt update
apt install php8.3-fpm php8.3-mysql php8.3-curl php8.3-gd php8.3-mbstring php8.3-xml php8.3-zip php8.3-intl php8.3-imagick php8.3-redis -y
systemctl enable php8.3-fpm

# Redis
curl -fsSL https://packages.redis.io/gpg | gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" > /etc/apt/sources.list.d/redis.list
apt update && apt install redis-server -y
systemctl enable redis-server

# Certbot + WP-CLI
apt install python3-certbot-nginx -y
curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar
chmod +x wp-cli.phar && mv wp-cli.phar /usr/local/bin/wp

Passo 2: Proteja o MariaDB e crie o banco de dados

mysql_secure_installation

mysql -u root -p
CREATE DATABASE wp_yoursite;
CREATE USER 'wp_yoursite'@'localhost' IDENTIFIED BY 'strongpassword';
GRANT ALL ON wp_yoursite.* TO 'wp_yoursite'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Passo 3: Isole o PHP-FPM por site (segurança + estabilidade)

cd /etc/php/8.3/fpm/pool.d/
cp www.conf yoursite.conf
nano yoursite.conf

Substitua:

[www] → [yoursite]
user = www-data → user = yoursiteuser (vamos criar esse usuário daqui a pouco)
group = www-data → group = yoursiteuser
listen = /run/php/php8.3-fpm.sock → listen = /run/php/php8.3-fpm-yoursite.sock
Mude o gerenciador de processos de dynamic → ondemand (economiza RAM)

systemctl restart php8.3-fpm

(Vai falhar até o usuário existir — tudo bem.)

Passo 4: Otimize o PHP e ative o OPcache

sed -i "s/memory_limit = .*/memory_limit = 1024M/" /etc/php/8.3/fpm/php.ini
sed -i "s/upload_max_filesize = .*/upload_max_filesize = 10240M/" /etc/php/8.3/fpm/php.ini
sed -i "s/post_max_size = .*/post_max_size = 10240M/" /etc/php/8.3/fpm/php.ini
sed -i "s/max_execution_time = .*/max_execution_time = 600/" /etc/php/8.3/fpm/php.ini
sed -i "s/;opcache.enable=1/opcache.enable=1/" /etc/php/8.3/fpm/php.ini
sed -i "s/;opcache.memory_consumption=.*/opcache.memory_consumption=512/" /etc/php/8.3/fpm/php.ini
sed -i "s/;opcache.max_accelerated_files=.*/opcache.max_accelerated_files=20000/" /etc/php/8.3/fpm/php.ini
sed -i "s/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/" /etc/php/8.3/fpm/php.ini

Passo 5: Crie o usuário do sistema e o diretório do site

adduser yoursiteuser --shell /bin/bash
su yoursiteuser
mkdir ~/public_html && cd ~/public_html
echo "cd ~/public_html" >> ~/.bashrc
exit

Passo 6: Configuração do Nginx (rápida e segura)

nano /etc/nginx/sites-available/yoursite.conf

upstream php-yoursite {
 server unix:/run/php/php8.3-fpm-yoursite.sock;
}

server {
 listen 80;
 listen [::]:80;
 server_name yourdomain.com www.yourdomain.com;
 root /home/yoursiteuser/public_html;
 index index.php index.html;

 client_max_body_size 10G;

 location / {
 try_files $uri $uri/ /index.php?$args;
 }

 location ~ \.php$ {
 include fastcgi_params;
 fastcgi_pass php-yoursite;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 }

 location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff2?|ttf|eot)$ {
 expires max;
 log_not_found off;
 }
}

ln -s /etc/nginx/sites-available/yoursite.conf /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx

Passo 7: Instale o WordPress via WP-CLI (como o usuário do site)

su yoursiteuser
cd ~/public_html

wp core download
wp config create --dbname=wp_yoursite --dbuser=wp_yoursite --dbpass='strongpassword' --locale=en_US
wp core install --url=https://yourdomain.com --title="Your Site" --admin_user=admin --admin_password='strongpass' --admin_email=you@domain.com

Passo 8: SSL com Let’s Encrypt (renovação automática)

certbot --nginx -d yourdomain.com -d www.yourdomain.com
# Choose redirect to HTTPS when asked

Adicione o cron de renovação automática:

crontab -e
# Add:
0 0 * * 0 certbot renew --quiet

Passo 9: Ative o cache de objetos com Redis

# As root
usermod -aG redis yoursiteuser
chmod 770 /var/run/redis/redis-server.sock

# Optimize Redis config
sed -i 's/port 6379/port 0/' /etc/redis/redis.conf
sed -i 's|# unixsocket /run/redis/redis-server.sock|unixsocket /var/run/redis/redis-server.sock|' /etc/redis/redis.conf
sed -i 's/# unixsocketperm 700/unixsocketperm 770/' /etc/redis/redis.conf
sed -i 's/# maxmemory .*/maxmemory 1024mb/' /etc/redis/redis.conf
systemctl restart redis-server

# As yoursiteuser
cd ~/public_html
wp plugin install redis-cache --activate
wp config set WP_REDIS_SCHEME unix
wp config set WP_REDIS_PATH '/var/run/redis/redis-server.sock'
wp redis enable

Pronto!

Agora você tem:

Pool do PHP-FPM totalmente isolado (1 usuário = 1 site = nenhum estrago entre sites)
Cache de objetos com Redis via socket Unix
OPcache + limites de upload enormes
Renovação automática do SSL
O roteamento mais rápido possível no Nginx
WP-CLI pronto para usar

O seu wp-admin vai parecer instantâneo, e o site vai aguentar o tráfego como um campeão — mesmo numa VPS de US$ 5/mês.

Próximos passos:

Instale um plugin de cache de página (qualquer um gratuito serve)
Configure o Cloudflare (opcional, mas recomendado)
Backups regulares

Aproveite o seu WordPress privado e ultrarrápido!

Obrigado pela leitura! 😊

Como montar o seu próprio servidor de e-mail

Mon, 08 Dec 2025 23:35:02 +0000

Introdução

Quer ter o seu próprio e-mail ultraprivado, como name@yourdomain.com, com uma interface de webmail bonita? Este guia mostra como montar um servidor de e-mail completo em menos de uma hora usando o lendário script EmailWiz do Luke Smith + o webmail Roundcube — tudo numa VPS de US$ 2–3/mês.

Tudo é gratuito, de código aberto e 100% sob o seu controle.

Passo 0: Arrume uma VPS barata

Bons provedores com promoções frequentes:

Contabo
Seção “Offers” do LowEndTalk
Hostinger (meu link de afiliado, se quiser me apoiar -> https://hostinger.com.br?REFERRALCODE=waterdownfall)

Requisitos:

Qualquer localização (EUA funciona bem)
Debian 10 ou 11 (vamos usar o Debian 10 neste guia)
Pelo menos 1 GB de RAM (2 GB ou mais recomendado)
Defina o hostname no cadastro como o seu domínio (por exemplo, sobremail.com)

Espere a implantação → pegue a senha de root no e-mail → entre via SSH.

Passo 1: Proteção básica da VPS

ssh root@your-vps-ip
apt update && apt upgrade -y

Troque a senha de root:

passwd

Crie e envie uma chave SSH (faça isso a partir da sua máquina local):

ssh-copy-id root@your-vps-ip

Agora desative o login por senha:

nano /etc/ssh/sshd_config

Altere:

PasswordAuthentication no
UsePAM no

Depois:

systemctl restart sshd

Agora só a sua chave SSH funciona — muito mais seguro.

Passo 2: Instale o EmailWiz (o script mágico)

apt install curl nginx python3-certbot-nginx -y

Aponte estes registros DNS para o IP da sua VPS:

yourdomain.com → IP da VPS (registro A)
mail.yourdomain.com → IP da VPS (registro A)

Rode o script do Luke:

curl -LO lukesmith.xyz/emailwiz.sh
sh emailwiz.sh

Siga as perguntas:

Responda Yes/Y para tudo
Quando pedir o “System mail name” → digite SÓ yourdomain.com (NÃO mail.yourdomain.com!)

Espere ~5–10 minutos. Quando terminar, ele te dá três registros DNS para adicionar:

Registro TXT do DKIM (mail._domainkey.yourdomain.com)
Registro TXT do DMARC (_dmarc.yourdomain.com)
Registro TXT do SPF (domínio raiz)

Adicione-os no seu provedor de DNS (Cloudflare, Namecheap etc.).

Passo 3: Configure o DNS reverso (essencial para a entregabilidade!)

No painel da Cloudcone → Networking → rDNS → defina como yourdomain.com NÃO ative o IPv6 (a Cloudcone ainda não suporta rDNS em IPv6 — isso vai prejudicar a entregabilidade).

Passo 4: Crie sua primeira caixa de e-mail

useradd -G mail -m yourusername
passwd yourusername

Agora o seu e-mail é: yourusername@yourdomain.com

Teste no Thunderbird/cliente IMAP:

IMAP: mail.yourdomain.com (porta 993, SSL/TLS)
SMTP: mail.yourdomain.com (porta 465, SSL/TLS)

Passo 5: Instale o webmail Roundcube

Adicione o backports + o repositório do PHP 8.x:

apt install -y lsb-release ca-certificates apt-transport-https software-properties-common gnupg2
echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | tee /etc/apt/sources.list.d/sury-php.list
wget -qO - https://packages.sury.org/php/apt.gpg | apt-key add -
apt update
apt install -y php8.0-fpm php8.0-common php8.0-gd php8.0-imap php8.0-mysql php8.0-curl php8.0-zip php8.0-xml php8.0-mbstring php8.0-intl mariadb-server

Proteja o MySQL:

mysql_secure_installation

Crie o banco de dados do Roundcube:

mysql -u root -p
CREATE DATABASE roundcube;
CREATE USER 'roundcubeuser'@'localhost' IDENTIFIED BY 'strongpassword';
GRANT ALL ON roundcube.* TO 'roundcubeuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Baixe e extraia o Roundcube (a versão completa mais recente):

cd /var/www
wget https://github.com/roundcube/roundcubemail/releases/download/1.6.9/roundcubemail-1.6.9-complete.tar.gz
tar xvf roundcubemail-1.6.9-complete.tar.gz
mv roundcubemail-1.6.9 roundcube
rm roundcubemail-1.6.9-complete.tar.gz
chown -R www-data:www-data /var/www/roundcube/temp /var/www/roundcube/logs
mysql roundcube < /var/www/roundcube/SQL/mysql.initial.sql

Configuração do Nginx para o Roundcube (/etc/nginx/sites-enabled/roundcube):

server {
 listen 80;
 listen [::]:80;
 server_name yourdomain.com;
 root /var/www/roundcube;
 index index.php;

 location / {
 try_files $uri $uri/ /index.php;
 }

 location ~ \.php$ {
 include fastcgi_params;
 fastcgi_pass unix:/run/php/php8.0-fpm.sock;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 }

 location ~* \.(jpg|jpeg|gif|png|webp|svg|woff|woff2|ttf|css|js|ico|xml)$ {
 expires 360d;
 access_log off;
 }
}

Teste e recarregue o Nginx, depois obtenha o SSL:

nginx -t && systemctl reload nginx
certbot --nginx -d yourdomain.com

Acesse https://yourdomain.com/installer → siga o assistente:

Banco de dados: roundcube, usuário roundcubeuser, a senha que você definiu
Host IMAP: localhost
Host SMTP: localhost
Host padrão: mail.yourdomain.com

Ative todos os plugins menos o Enigma (ele quebra as identidades em versões mais antigas).

Ao terminar, apague o instalador:

rm -rf /var/www/roundcube/installer

Passo 6: Ajustes de qualidade de vida

Edite /var/www/roundcube/config/config.inc.php:

// Login with just username (no need to type @domain.com)
$config['username_domain'] = 'yourdomain.com';

// Stay logged in for 6 months
$config['session_lifetime'] = 259200;

// Disable Enigma if you enabled it
// Remove 'enigma' from $config['plugins'] array

Aumente o tamanho dos anexos:

nano /etc/php/8.0/fpm/php.ini

upload_max_filesize = 50M
post_max_size = 50M

Depois:

systemctl restart php8.0-fpm

Passo 7: Proteção contra força bruta com o Fail2Ban

apt install fail2ban -y
cd /var/www/roundcube/plugins
wget https://github.com/texxasrulez/roundcube_fail2ban/archive/refs/tags/1.4.zip
unzip 1.4.zip
mv roundcube_fail2ban-1.4 fail2ban
rm 1.4.zip

Ative na configuração do Roundcube (config.inc.php):

$config['plugins'][] = 'fail2ban';

Adicione a jail (/etc/fail2ban/jail.local – crie se não existir):

[roundcube]
enabled = true
port = http,https
filter = roundcube
action = iptables-multiport[name=roundcube, port="http,https"]
logpath = /var/www/roundcube/logs/errors.log
maxretry = 5
bantime = 3600

Crie o filtro (/etc/fail2ban/filter.d/roundcube.conf):

[Definition]
failregex = IMAP Error: Login failed for .* from <HOST>
ignoreregex =

Reinicie:

systemctl restart fail2ban php8.0-fpm

Pronto! Agora o seu webmail está protegido.

Resultado final

Agora você tem:

Servidor de e-mail completo com DKIM, SPF e DMARC
Webmail Roundcube bonito e rápido
Zero envolvimento do Google/Microsoft
Login uma vez a cada 6 meses
Proteção contra força bruta
Tudo por ~US$ 50/ano

Bem-vindo à verdadeira liberdade no e-mail.

Obrigado pela leitura! 😊

Como usar IA com privacidade no navegador Brave (2 métodos)

Mon, 08 Dec 2025 23:15:59 +0000

Introdução

O Brave Browser 1.69 trouxe um recurso revolucionário: agora você pode conectar o Leo (o assistente de IA integrado do Brave) a qualquer modelo que quiser — inclusive modelos totalmente locais ou APIs de terceiros. Isso significa ter uma barra lateral de IA sempre disponível, sem assinatura e com controle total sobre privacidade e custo.

Aqui estão os dois melhores métodos que testei (um ultraprivado e outro mais inteligente, porém na nuvem).

Método 1 – Privacidade máxima: rode um modelo local com o Ollama (sem precisar de GPU)

Dá para rodar um modelo surpreendentemente capaz totalmente offline, mesmo em um hardware bem modesto. O ponto ideal hoje é o Gemma 2 2B, do Google — ele é minúsculo (~1,4 GB), roda muito bem na CPU e funciona perfeitamente mesmo com só 4–6 GB de RAM livres.

Passo 1: Instale o Ollama

Baixe e instale o Ollama pelo site oficial: https://ollama.com (Ele tem pacotes nativos para Windows, macOS e Linux.)

Passo 2: Baixe o Gemma 2 2B

Abra um terminal e rode:

ollama pull gemma2:2b

(Se você usa Docker: docker exec -it ollama ollama pull gemma2:2b)

Passo 3: Confira se está rodando

Abra http://localhost:11434 no seu navegador. Você deve ver “Ollama is running” — é só disso que você precisa.

Passo 4: Adicione o modelo ao Brave Leo

Abra o Brave → Configurações → Leo
Clique em Adicionar novo modelo
Preencha os detalhes exatamente assim:

Label → o que você quiser (por exemplo, “Gemma 2 2B Local”)
Model Request Name → gemma2:2b
Server Endpoint → http://localhost:11434/v1/chat/completions
API Key → deixe em branco

(Opcional, mas recomendado) Defina este modelo como padrão para novas conversas.

Pronto! Agora você tem uma IA totalmente privada e offline dentro do Brave, que quase não usa recursos.

Método 2 – Respostas mais inteligentes (nuvem): use o CryptoTalks.ai (pague pelo uso, sem assinatura)

Se você quer acesso aos melhores modelos (GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Flash, Llama 3.1 405B etc.) sem criar contas na OpenAI/Anthropic/Google, o CryptoTalks.ai é hoje a melhor opção. Você paga só pelo que usa e pode colocar saldo na conta com Bitcoin ou Lightning.

Passo 1: Crie uma conta e pegue seu token

Acesse https://cryptotalks.ai/signup → cadastre-se → copie seu token de API (guarde-o em segurança!).

Passo 2: Coloque um pouquinho de crédito

Deposite qualquer valor via Bitcoin ou Lightning. Mesmo US$ 1–2 duram muito tempo para uso pessoal.

Passo 3: Adicione o(s) modelo(s) ao Brave Leo

Mesmo processo de antes, só com valores diferentes:

Label → por exemplo, “Claude 3.5 Sonnet”, “GPT-4o” etc.
Model Request Name → o ID exato do modelo na documentação deles, por exemplo:
- openai/chatgpt-4o-latest
- anthropic/claude-3.5-sonnet
- google/gemini-flash-1.5
- meta-llama/llama-3.1-405b-instruct
Server Endpoint → https://cryptotalks.ai/v1/chat/completions/
API Key → cole o seu token

Você pode adicionar quantos modelos quiser e alternar entre eles na hora pela barra lateral do Leo.

Dica de mestre: confira os rankings atuais de modelos em https://artificialanalysis.ai/models para escolher o melhor para o que você precisa.

Uso no dia a dia

Com o Leo + o seu próprio modelo, você pode:

Resumir artigos longos ou vídeos do YouTube com um clique
Explicar trechos de código complexos
Escrever rascunhos de e-mails ou mensagens
Traduzir na hora
Tudo sem sair do navegador e sem mandar dados para as big techs

Quando estou na bateria e não quero nenhum consumo extra de energia → mudo para o Gemma 2 2B local. Quando preciso do máximo de inteligência → mudo para o Claude 3.5 Sonnet ou o GPT-4o via CryptoTalks.

Conclusão

O Brave acabou de transformar cada navegador em uma estação de trabalho de IA privada e personalizável. Escolha o Método 1 para 100% de privacidade e custo zero, ou o Método 2 quando quiser as melhores respostas disponíveis hoje.

De um jeito ou de outro — bem-vindo ao futuro da navegação.

Obrigado pela leitura! 😊

Cache de página, cache de objetos e cache de CDN – entendendo todos os tipos de cache

Mon, 08 Dec 2025 23:13:04 +0000

Entendendo os diferentes tipos de cache (principalmente para escalar sites com CMS)

Se você já se perguntou o que as pessoas querem dizer quando falam em “cache de página”, “cache de objetos” ou “cache de CDN”, este post é para você. Essas são as três principais camadas de cache, que fazem uma diferença enorme na hora de escalar o WordPress, o WooCommerce ou qualquer outro CMS.

O que é cache de página?

O cache de página (também chamado de cache de página inteira ou cache de HTML) é exatamente o que o nome diz: a página HTML inteira já renderizada é salva como um arquivo estático.

Em um site realmente estático (HTML + CSS + JS puros), não há necessidade de cache de página, porque todos os arquivos já são estáticos. Mas, com um CMS como o WordPress, cada requisição normalmente dispara PHP → tema → plugins → consultas ao banco de dados → saída em HTML. Esse processo consome CPU e leva tempo.

O cache de página inteira pula tudo isso. O primeiro visitante dispara o processo completo de PHP+MySQL, o HTML resultante é salvo, e todos os visitantes seguintes recebem na hora o HTML estático já gerado — sem PHP, sem consultas ao banco de dados, com quase zero de CPU.

Resultado: carga no servidor de 10 a 100× menor e páginas carregando muito mais rápido.

O que é cache de objetos?

O cache de objetos guarda os resultados de consultas caras ao banco de dados (ou de qualquer processamento lento) em uma memória rápida (geralmente Redis ou Memcached).

Pense nele como um intermediário superrápido entre o seu código PHP e o banco de dados.

Exemplo com o WordPress:

O WordPress precisa da lista de posts publicados → ele pergunta ao MySQL.
Primeira requisição: o MySQL faz o trabalho e devolve os dados, e o cache de objetos os salva na RAM.
As próximas 10 000 requisições: o cache de objetos devolve na hora os mesmos dados direto da memória → o MySQL dorme em paz.

O cache de objetos é esperto — ele se invalida sozinho quando os dados mudam (por exemplo, quando você publica um post novo).

Por que você ainda precisa dele, mesmo com o cache de página inteira:

Usuários logados (incluindo o painel do WordPress, as páginas de conta do WooCommerce etc.) não podem ter a página inteira em cache para todo mundo.
Essas páginas ainda passam pelo PHP e pelo MySQL → o cache de objetos as deixa toleráveis, em vez de dolorosamente lentas.

Cache de objetos + cache de página inteira juntos formam a combinação clássica para tráfego alto.

O que é cache de CDN?

Uma CDN (Content Delivery Network, ou rede de distribuição de conteúdo) copia seus arquivos estáticos (CSS, JS, imagens, fontes) — e, se você quiser, também suas páginas HTML inteiras — para servidores “PoP” espalhados pelo mundo.

Sem CDN: um visitante no Japão baixa tudo do seu servidor de origem que fica, digamos, no Brasil → latência alta.

Com CDN:

Os arquivos estáticos são entregues pelo PoP mais próximo (muitas vezes a menos de 30 ms).
Se você também ativar o cache de página inteira na CDN, a página HTML inteira também é entregue por esse PoP próximo → o servidor de origem nem é tocado nas páginas em cache.

É por isso que alguns sites carregam instantaneamente de qualquer lugar do planeta.

Exemplo real: o fluxo de tráfego do WordPress

Sem nenhum cache

Visitante → servidor web → PHP → dezenas de arquivos de plugins → consultas ao MySQL → HTML → visitante → CPU alta, TTFB lento, bate fácil nos limites de recursos.

Só com cache de página inteira

Primeiro visitante: o mesmo caminho lento de cima (mas o HTML é salvo). Os próximos 10 000 visitantes: o servidor web entrega na hora o HTML pronto → quase zero de CPU.

Só com cache de objetos

Toda requisição ainda roda PHP + plugins, mas as consultas ao banco são respondidas pela RAM em vez do disco → mais rápido que sem cache, mas ainda pesado.

Com cache de página inteira + cache de objetos

Visitantes anônimos → HTML estático (superrápido, quase sem carga)
Usuários logados → o PHP roda, mas o cache de objetos deixa as consultas ao banco instantâneas → carga administrável

Adicione por cima uma CDN com cache de página inteira

Agora até o HTML estático é entregue a partir de pontos de borda no mundo todo. O seu servidor de origem pode basicamente tirar um cochilo até que algo realmente precise de PHP (por exemplo, envio de formulários, invalidação de cache).

Conclusão

Aqui está a hierarquia, do mais impactante para o menos (para a maioria dos sites com CMS):

Cache de página inteira na CDN → o mais rápido para os visitantes, escala para milhões de acessos com quase nenhuma carga na origem.
Cache de página inteira na origem → ainda é um ganho enorme se você não puder fazer cache na CDN.
Cache de objetos (Redis/Memcached) → obrigatório para usuários logados, WooCommerce, painéis etc.
Todo o resto (OPcache, cache do navegador etc.) → bom de ter, geralmente já vem ativado por padrão.

Se você for fazer uma coisa só: ative um cache de página inteira decente (e leve-o para a sua CDN, se possível). Se você tem tráfego de usuários logados ou uma loja: adicione o cache de objetos com Redis/Memcached.

É isso — as três camadas de cache que movem basicamente todo site WordPress com tráfego alto no planeta.

Espero que isso tenha esclarecido as coisas!

Obrigado pela leitura! 😊

7 coisas que você deve fazer depois de instalar o Xubuntu 22.04

Mon, 08 Dec 2025 22:24:22 +0000

Introdução

Recentemente fiz uma análise do Pop!_OS 22.04 depois de usá-lo por bastante tempo. Adorei, mas queria experimentar outra coisa a longo prazo e acabei escolhendo o Ubuntu 22.04 — mais especificamente o sabor Xubuntu, com XFCE.

Sempre que instalo um sistema do zero, faço algumas coisas para garantir que ele fique ágil, rode bem os jogos e (em notebooks) tenha a melhor duração de bateria possível.

Antes de começar qualquer um dos passos abaixo, recomendo fortemente fazer uma atualização completa do sistema

Instale o kernel Liquorix

O Liquorix é um kernel Linux para entusiastas, otimizado para a responsividade no desktop, para trabalhos de áudio/vídeo de baixa latência e para reduzir as variações no tempo de quadro nos jogos.

O kernel padrão do Ubuntu é de uso geral e precisa funcionar bem tanto em desktops quanto em servidores. O Liquorix pega o mesmo código-fonte do kernel Linux e aplica patches e opções de compilação voltados para o desktop. O resultado é visivelmente mais ágil, principalmente sob carga pesada ou ao alternar rápido entre janelas (alt-tab) nos jogos.

Instalar no Ubuntu/Debian é um comando só:

Bash

curl 'https://liquorix.net/install-liquorix.sh' | sudo bash

Reinicie depois e você já estará usando o kernel novo.

Instale os drivers gráficos mais recentes

Para quem usa Nvidia:

Bash

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo dpkg --add-architecture i386
sudo apt update
sudo apt install -y nvidia-driver-560 libvulkan1 libvulkan1:i386

Para quem usa AMD ou Intel (PPA do Kisak – Mesa mais recente):

Bash

sudo add-apt-repository ppa:kisak/kisak-mesa
sudo dpkg --add-architecture i386
sudo apt update && sudo apt upgrade
sudo apt install libgl1-mesa-dri:i386 mesa-vulkan-drivers mesa-vulkan-drivers:i386

Mesmo em uma versão LTS mais antiga, isso traz os drivers de código aberto mais novos e o suporte a Vulkan.

Reduza o swappiness

O Pop!_OS define vm.swappiness=10 por padrão (o swap só é usado quando a RAM está ~90% cheia). O Ubuntu/Xubuntu vem com 60, o que é agressivo demais para uso em desktop.

Mude de forma permanente:

Bash

sudo nano /etc/sysctl.conf

Adicione esta linha no final:

text

vm.swappiness=10

Salve e saia. A mudança vale na hora ou na próxima reinicialização.

Instale utilitários essenciais

Estas são as ferramentas que instalo em toda instalação nova:

Redshift – filtro de luz azul
Flameshot – a melhor ferramenta de captura de tela
AppImageLauncher – integra AppImages ao seu menu
Gamemode – ganhos enormes de FPS em muitos jogos
TLP – essencial para notebooks (muitas vezes dobra a duração da bateria)

Bash

sudo apt install redshift flameshot appimagelauncher gamemode tlp tlp-rdw

(Ative o TLP se precisar: sudo tlp start)

Instale seus apps favoritos do dia a dia

Minhas escolhas pessoais:

Brave Browser (Chromium focado em privacidade)
VLC (de preferência via AppImage/Flatpak/Snap, para evitar dependências pesadas do Qt no XFCE)
LibreOffice

Crie aliases úteis

Abra o seu .bashrc:

Bash

nano ~/.bashrc

Adicione alguns aliases úteis no final, por exemplo:

Bash

alias apply_filter='redshift -O 1900'
alias update='sudo apt update && sudo apt upgrade -y'
alias please='sudo $(history -p !!)' # rerun last command with sudo

Recarregue o arquivo:

Bash

source ~/.bashrc

Personalize a aparência (opcional)

O Xubuntu + XFCE é extremamente personalizável. Uso uma configuração bem minimalista e controlo quase tudo com atalhos de teclado. Você pode configurá-los em Configurações → Gerenciador de janelas e Configurações → Teclado → Atalhos de aplicativos.

Conclusão

Os três maiores ganhos de desempenho — kernel Liquorix, drivers gráficos mais recentes e swappiness baixo — fazem uma diferença enorme. Exemplo real: Life is Strange: True Colors saltou de ~23 FPS com travadas nas configurações padrão para 40+ FPS estáveis depois de aplicar essas mudanças.

Se você está tendo lentidões ou travamentos aleatórios no Xubuntu/Ubuntu, tente estes passos primeiro. Eles resolvem uma quantidade surpreendente de problemas.

Obrigado pela leitura!