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.

Corrigindo a tela em branco/cinza nas páginas de álbum do Finamp (player de música do Jellyfin)

Mon, 15 Dec 2025 15:02:30 +0000

Se você usa o Finamp para ouvir ou baixar músicas do seu servidor Jellyfin e está dando de cara com uma tela em branco (ou cinza) ao abrir a página de um álbum — em que nenhuma faixa carrega e às vezes é preciso forçar o fechamento do app —, esse é um problema comum, principalmente depois de atualizar o Jellyfin para a versão 10.11.x.

Esse problema costuma acontecer por causa de mudanças na forma como as versões mais novas do Jellyfin lidam com os metadados de música, o que faz o Finamp não conseguir carregar as faixas do álbum corretamente.

A solução: atualizar os metadados no Jellyfin (buscar metadados ausentes)

A alternativa mais confiável é forçar o Jellyfin a atualizar os metadados da sua biblioteca de música:

Entre no painel web do Jellyfin (de preferência com uma conta de administrador).
Vá em Painel > Bibliotecas.
Selecione sua biblioteca de Música.
Clique no menu de três pontos (…) ao lado do nome da biblioteca.
Escolha Atualizar metadados.
Nas opções de atualização:

Marque Buscar metadados ausentes.
Se precisar, ative também outras opções, como “Substituir imagens existentes” ou “Substituir todos os metadados”.

Clique em Atualizar (ou OK) para iniciar a varredura.

Observação: esse processo pode levar vários minutos, dependendo do tamanho da sua biblioteca. Quando terminar, reinicie o Finamp e tente abrir os álbuns de novo — agora as faixas devem carregar normalmente.

Observações adicionais sobre o Jellyfin 10.11.x

A equipe do Finamp e alguns usuários relataram perdas de desempenho no Jellyfin 10.11.x, principalmente em bibliotecas de música (carregamento mais lento, maior uso de recursos).
Se possível, considere continuar no Jellyfin 10.10.x (ou voltar para ele) para ter um desempenho melhor, até as correções chegarem por completo nos próximos patches da 10.11.
No meu caso, posso confirmar que, mesmo na 10.11.x mais recente, a atualização de metadados resolve o problema do álbum em branco, e depois disso tudo funciona bem.

Créditos

Issue no GitHub: https://github.com/jmshrv/finamp/issues/1412

Se o problema continuar depois da varredura, veja se há atualizações do Finamp ou relate o problema no repositório do Finamp no GitHub. Boa música! :)

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

Solução rápida: impeça o Ubuntu 24.04 de suspender/dormir automaticamente

Fri, 12 Dec 2025 19:58:45 +0000

Se o seu Ubuntu 24.04 (principalmente um que começou como instalação de servidor) suspende ou entra em modo de espera do nada, mesmo devendo ser um servidor sem monitor, você não está sozinho.

Isso parece acontecer quando uma instalação de servidor acaba sendo convertida, parcial ou totalmente, em um ambiente “desktop” em algum momento — mesmo que você nunca tenha instalado um desktop de propósito. No meu caso, instalei o Ubuntu Server 24.04 direto com o balenaEtcher em um NVMe/SSD e tive esse comportamento estranho (meu servidor N100 suspendia depois de 15 minutos).

A solução simples em uma linha

Rode este único comando e as suspensões aleatórias param na hora (e continuam desativadas depois de reiniciar):

sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

É só isso!

Qual é a carteira Monero mais rápida no Android em 2025? Cronometrei as três com meu próprio nó

Wed, 10 Dec 2025 22:46:43 +0000

Introdução

Um dos maiores pontos fracos do Monero é restaurar uma carteira antiga. Hoje, vou comparar a velocidade de três carteiras Monero populares para ver qual delas é a mais rápida na restauração.

Dados do teste

Data do teste: 2025-12-10 Aparelho: Samsung Galaxy A56 (Exynos 1580, 8 GB de RAM, celular intermediário de 2025) Conexão: nó completo local de Monero via Wi-Fi (mesma rede local, usando um Deco S7) Carteira: seed legada de 25 palavras criada em dezembro de 2024 (~1 ano, histórico de transações moderado) Objetivo: restauração completa + sincronização a partir da minha altura de restauração em cada carteira, para ver o desempenho real em uma configuração self-hosted típica em 2025.

As concorrentes

Carteira	Versão	Método de altura de restauração	Observações
Cake Wallet	5.6.2	25 palavras (legado)	Carteira oficial multimoedas
Stack Wallet	2.4.2	25 palavras (legado)	Focada em privacidade, prioriza o Bitcoin, mas tem bom suporte a XMR
Monerujo	4.1.7 (build da Exolix)	25 palavras (legado)	Favorita de longa data para Monero, só para Android

Resultados

Carteira	Tempo total até sincronizar	Comportamento entre 90–100%	Mantém a tela ligada?	Terminou?	Observações
Monerujo	21 minutos e 45 segundos	Velocidade constante, sem desacelerar	Não	Sim	Arrasou completamente
Cake Wallet	40 minutos e 13 segundos	Muito lenta depois de ~90%, estimativa de tempo quebrada	Sim (ponto enorme a favor)	Sim	Chegou lá, mas foi meio lenta
Stack Wallet	Desisti depois de ~1 hora e 16 minutos	Se arrastou depois de 98%, ressincronizar não ajudou	Não	Não	Travada para sempre por volta de 98–99%

Observações detalhadas

Monerujo 4.1.7 – A vencedora clara

Começou a escanear na hora
O progresso foi suave e previsível o tempo todo
Nunca desacelerou, nem nos 10% finais
Simplesmente funcionou. 21min45s desde digitar a 25ª palavra até “sincronizada”.
NÃO impede que a tela apague → o Android ficava suspendendo o processo

Cake Wallet 5.6.2 – Chega lá… uma hora

A restauração começou bem
O contador de tempo estimado não era preciso (mostrou 2 minutos durante 30 minutos)
Desacelerou muito depois de ~90%
Manteve a tela ligada o tempo todo ← só isso provavelmente impediu que a sincronização morresse
Terminou, no fim das contas

Stack Wallet 2.4.2 – Decepcionante

Na verdade, foi a que começou mais rápido das três
Voou até 98% em ~25 minutos… e aí morreu
A velocidade despencou
Reiniciar o app retomou em 98,49%, mas não resolveu a lentidão
Tentei usar o botão “Resync” – nenhuma melhora
NÃO impede que a tela apague → o Android ficava suspendendo o processo
Abandonei depois de mais de 1 hora sem nenhum progresso significativo

Conclusão: a Monerujo é a mais rápida em 2025

Se você quer restaurar uma carteira Monero antiga no celular usando seu próprio nó em 2025, a resposta é cristalina:

A Monerujo joga em outra liga.

A Cake Wallet ainda é bem usável e tem uma interface/acabamento incríveis, mas a lentidão na sincronização é real. Infelizmente, a Stack Wallet parece quebrada/superlenta para restaurações grandes no momento

Um salve para o(s) dev(s) da Monerujo — seja lá qual feitiçaria vocês fizeram no motor de escaneamento, obrigado. A privacidade no celular acabou de ficar mais rápida.

Testado em 2025-12-10 com um nó local. Seus resultados podem variar conforme a quantidade de transações, mas a ordem relativa deve se manter.

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 configurar o GRUB para dual boot no Ubuntu 23.10 (solução)

Mon, 08 Dec 2025 23:53:06 +0000

Introdução

Menu do GRUB não aparece → Windows não aparece na inicialização

Acabou de instalar o Xubuntu (ou Ubuntu) 23.10 junto com o Windows e agora ele entra direto no Linux sem mostrar o menu do GRUB? Calma — esse é o novo comportamento padrão. A partir das versões recentes do Ubuntu, o GRUB_TIMEOUT_STYLE vem definido como hidden e o tempo de espera é de 0 segundos, então o menu é pulado por completo, a menos que você segure Shift durante a inicialização.

Aqui está a solução definitiva em duas linhas.

A solução (leva 30 segundos)

Abra um terminal e edite a configuração do GRUB:

sudo nano /etc/default/grub

Garanta que estas linhas estejam presentes e exatamente assim (adicione-as se estiverem faltando):

GRUB_TIMEOUT_STYLE=menu
GRUB_TIMEOUT=10

Opcional, mas recomendado — deixe o menu mais bonito e 100% confiável:

GRUB_TERMINAL=console

Exemplo completo da seção relevante:

# Show the GRUB menu every time
GRUB_TIMEOUT_STYLE=menu
GRUB_TIMEOUT=10 # seconds to wait before auto-booting the default entry
GRUB_TERMINAL=console

Salve (Ctrl+O → Enter → Ctrl+X) e atualize o GRUB:

sudo update-grub

Reinicie e agora você verá o menu completo do GRUB, com o Ubuntu/Xubuntu e o Windows listados. Você pode trocar o 10 por qualquer número que quiser (ou até -1 para esperar indefinidamente até você escolher uma opção).

Por que isso acontece

A Canonical decidiu esconder o menu por padrão para ter uma inicialização “mais limpa” em máquinas com um único sistema operacional. Para quem usa dual boot, isso só atrapalha — esta solução restaura o comportamento clássico de forma permanente.

É só isso — aproveite de novo o acesso fácil aos dois sistemas operacionais!

(Solução original da comunidade do AskUbuntu)

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! 😊

Análise do Pop!_OS 22.04 depois de 6 meses de uso

Mon, 08 Dec 2025 22:28:25 +0000

Introdução

O Pop!_OS é uma das distros Linux mais usadas. Ele também é uma recomendação para iniciantes, gamers e até para usuários experientes.

Mas será que vale a pena? No post de hoje, vou contar a minha experiência usando ele, da instalação até o uso no dia a dia.

Instalação

O Pop tem um dos melhores instaladores que existem, tenho que admitir. Ele é simples, bonito e tem cara de moderno. A instalação é bem simples: você só clica em alguns botões para configurar o idioma e algumas outras opções. Também dá para criptografar o disco durante a instalação, o que ajuda se você viaja muito e guarda informações confidenciais no notebook (como senhas pessoais, documentos, fotos etc.).

Pelo processo de instalação, dou nota 9/10 ao Pop. Por que não 10? Bom, ele não tem uma opção para fazer dual boot automaticamente. Se você usa o Windows, por exemplo, precisa fazer isso manualmente. Fora isso, funciona muito bem e faz um ótimo trabalho para te dar uma experiência agradável.

Primeira inicialização

A primeira inicialização do Pop também é uma ótima experiência. Você cria o seu usuário e a sua senha e entra normalmente no seu novo ambiente Gnome. O Pop te ajuda a personalizar algumas opções (modo escuro, posição da dock e contas online). São todas ótimas opções para iniciantes.

Os apps padrão também são bem integrados ao sistema, e tudo parece estar no lugar certo.

No geral, dou nota 10/10 para a pós-instalação; não vejo nada para melhorar aqui, eles simplesmente mandaram muito bem.

Detalhes que tornam o Pop!_OS especial

Esta provavelmente é a melhor parte do Pop, e é o que faz dele uma escolha muito, muito sólida. Estas são algumas características que são raras de encontrar em outras distros:

System76 Scheduler - Você sabia que o Pop vem com otimizações de CPU por padrão? Isso mesmo. Por padrão, o Pop reduz a latência e melhora o desempenho dos apps, principalmente quando o notebook está carregando. Isso também é ótimo para jogos, já que você não precisa mais do gamemode.
System76-Power - Por padrão, o Pop oferece três modos de bateria: Economia, Equilibrado e Alto desempenho. Isso é incrível, porque no Pop as otimizações de bateria já vêm aplicadas por padrão. Você não precisa do TLP e tem uma interface gráfica fácil para controlar o modo da bateria. Simplesmente sensacional.
O swappiness vem definido como 10. Na maioria das distros Linux que já usei, o swappiness vem em 60. Isso significa que a sua distro começa a usar o swap quando o uso de RAM chega a 40%. No Pop, o swap só é usado quando você está usando cerca de 90% da RAM. Isso é incrível e deixa tudo muito mais fluido, já que o swap é bem lento, mesmo em um SSD NVMe.
O kernel não é o mesmo do Ubuntu 22.04. O Pop faz um ótimo trabalho em manter o kernel atualizado. Isso é ótimo principalmente se você usa um desktop/notebook mais novo. Até onde sei, o Ubuntu 22.04 está entregando o kernel 5.15.x. O Pop!_OS já está no 6.1.x
Atalhos personalizados. No começo, eu odiei, mas depois de experimentar o “jeito Pop”, adorei e hoje até mudo os atalhos padrão de outras distros! Por exemplo, em vez de alt + f4 (que normalmente exige as duas mãos), o Pop usa “windows + q”, que é mais acessível e fácil de usar. Em vez de ctrl + alt + t para abrir o terminal, no Pop você pode usar “windows + t”. Isso é muito bom e ajuda quando você trabalha com muita multitarefa (praticamente qualquer pessoa que trabalha com CS vai adorar).
Atualizações de firmware fáceis. O Pop vem com uma opção dentro das configurações do Gnome para fazer atualizações de hardware. Isso é ótimo, porque te dá mais controle e mais detalhes sobre essas atualizações.
Recuperação como opção. No Pop, você pode ter uma “cópia da ISO” nas configurações e “renovar o sistema” se um dia precisar. Pode ser útil se você quebrar alguma coisa e quiser restaurar o sistema sem usar um pendrive.
systemd-boot em vez do GRUB. Para mim, isso não faz diferença, mas muita gente parece elogiar o systemd-boot. Acho que ele proporciona uma inicialização mais rápida e é “mais simples de configurar” (estou acostumado com o GRUB, então para mim o GRUB é mais fácil, mas quase não personalizo nada na inicialização).
PipeWire em vez de PulseAudio. Durante anos, um dos softwares de que as pessoas mais reclamavam era o PulseAudio. Ele travava, dava pau, não reconhecia dispositivos etc. O PipeWire é o novato, mais enxuto e com latência menor. Muita gente também o elogia. Eu também prefiro o PipeWire, porque ele parece mais simples e melhor de usar do que o PulseAudio.
Temas do Flatpak funcionando direito, e nada de Snap. Os Snaps estão sendo “empurrados” pelas distros Ubuntu, mas muita gente não gosta deles. Alguns não gostam do fato de o servidor não ser de código aberto, outros reclamam dos bugs, do espaço usado, e outros das atualizações automáticas (que não dá para desativar). Eu também prefiro os Flatpaks, e é ótimo ver que, no Pop, os Flatpaks parecem aplicativos nativos e o Flathub vem adicionado por padrão. Também é bom ver que a Pop_Shop se integra bem com os Flatpaks.
O Pop criou o Popsicle. Isso provavelmente não recebe a atenção que merece, mas, cara! É MARAVILHOSO ter um gravador de ISO por padrão. E este é tão bonito e se integra tão bem com o Pop. Gosto mais dele do que do Balena Etcher e de outros softwares comuns no Linux para criar pendrives inicializáveis.

Pontos negativos do Pop

Embora o Pop seja incrível, também vejo alguns pontos negativos nele. A maioria é pessoal, então talvez você nem os veja como pontos negativos.

Gnome. Eu simplesmente não gosto nada do Gnome. Parece pesado e muda o tempo todo com as atualizações grandes, quebrando extensões e a experiência do usuário. A parte boa é que o Pop está desenvolvendo o seu próprio ambiente desktop em Rust, que vai ser SENSACIONAL quando for lançado.
A Pop_Shop usa 0,5 GB de RAM parada. Isso talvez não seja um problema em computadores com mais RAM, mas, quando você tem menos, é meio ruim. Se você tem 4 GB de RAM, por exemplo (o que ainda é comum em países de terceiro mundo), vai sentir a diferença. Dá para desativar a Pop_Shop, mas, sinceramente, o uso parada deveria ser menor.
O tracker-miner-fs pode sugar sua CPU se você baixar pastas com muitas subpastas. Uma vez, baixei o backup de um site WordPress e o extraí. Ele tinha muitas subpastas. Notei o notebook mais lento, mas não sabia o que estava acontecendo. Quando olhei o gerenciador de tarefas, o tracker-miner estava em ação, sugando toda a CPU para tentar indexar aquelas subpastas. Tentei resetar o tracker-miner, limpar, ver o status, mas ele não respondia. No fim, desativei, já que um desenvolvedor do Pop disse que era 100% seguro.

Desempenho geral depois de 6 meses

Depois de 6 meses usando o Pop, posso dizer que fiquei bem satisfeito com o desempenho. Tive um problema em que, por alguns segundos, o mouse ficava lento e o áudio travava, mas provavelmente foi por algo que eu fiz (ou talvez porque meu hardware não lida bem com a criptografia. Estou num notebook com Ryzen 5 5500U, 12 GB de RAM e SSD NVMe de 256 GB).

Por causa dos problemas com o tracker-miner e desse travamento, decidi deixar o Pop e experimentar o Linux Mint XFCE por um tempo (adoro o XFCE e o Mint é estável o suficiente, então resolvi dar uma chance). Provavelmente vou fazer uma análise dele também depois de usar por um tempo.

No geral, usar o Pop foi um prazer, e consegui fazer muito trabalho bom nele. Trabalho com CS/DevOps, então na maior parte do tempo eu estava conversando com clientes ou usando scripts bash no servidor, e para isso o Pop funcionou bem. Para jogos, também funcionou bem, então não tenho do que reclamar e com certeza recomendaria para a maioria das pessoas. O Pop tem os melhores padrões que já vi. É a distro que menos precisei ajustar, porque ela já vem com tudo o que preciso e uso.

Conclusão

O Pop é incrível! Se você gosta do Gnome, experimente. Ele vai te dar um ótimo desempenho, e todas as otimizações que importam já vêm prontas de fábrica. A bateria vai durar bem em notebooks, e os drivers provavelmente estarão otimizados para jogos. O Vulkan também vem ativado por padrão.

Meu pai usa o Pop no notebook dele (eu que instalei) e adora.

Com certeza vou experimentar o Pop de novo quando lançarem o novo ambiente desktop deles. Enquanto isso, vou aproveitar a minha experiência com o XFCE.

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!

A Zcash está perdendo

Mon, 08 Dec 2025 22:11:49 +0000

A Zcash NÃO é o projeto mais importante do mundo, e está perdendo.

A Zcash nasceu como um projeto para corrigir a maior falha do Bitcoin: a privacidade. Mas lançar uma moeda nova não é fácil, e não se trata só dos aspectos técnicos.

Uma criptomoeda séria deveria ser dinheiro, e ela precisa ser melhor do que o que temos hoje com os governos; caso contrário, era melhor continuar usando o dólar. Isso significa que, embora os aspectos técnicos de qualquer criptomoeda sejam importantes, ela também deve ser confiável, digna de confiança e o mais estável possível. A principal falha do dinheiro do governo é a inflação. Os governos normalmente adoram gastar dinheiro e podem cobrar um imposto oculto imprimindo mais. Quando se imprime dinheiro, a quantidade de bens e serviços na sociedade continua a mesma, mas há mais dinheiro em circulação.

Isso significa que o seu dinheiro passa a valer menos. Quem ganha nesse caso é o governo, ou quem gastar primeiro o dinheiro recém-impresso, porque o mercado vai se ajustar, levando a preços mais altos de serviços e bens.

O problema da Zcash

A Zcash parece boa. Ela usa a tecnologia zk-SNARKs para comprovar transações e armazená-las de forma privada, o que significa que, quando você envia transações, tudo fica oculto (ninguém consegue ver quem enviou, o valor enviado nem quem recebeu). Parece incrível, né? Então vamos comprar Zcash!!

Não. E por que não?

1. A Zcash foi lançada com uma configuração confiável (trusted setup)

Isso mesmo. Quando a Zcash foi lançada, ela usou uma configuração confiável para dar o pontapé inicial na rede. Nesse evento, vários participantes criaram juntos os parâmetros criptográficos, sem que nenhuma parte tivesse controle total. Partia-se do pressuposto de que pelo menos um participante destruiria a sua parte das chaves secretas, para garantir a privacidade. Se os participantes juntassem os seus parâmetros, poderiam, em teoria, criar Zcash ilimitada e rastrear transações blindadas.

Agora, preciso ser justo. Hoje a Zcash roda no NU5 (Network Upgrade 5). Essa atualização removeu a configuração confiável, garantindo que, depois de maio de 2022, a Zcash não dependa de confiar em mais ninguém.

Mas, ao mesmo tempo, até onde sei, não há como provar que todos destruíram os seus parâmetros e que nenhuma Zcash foi gerada ou rastreada.

2. A Zcash não é privada por padrão.

Considerando as atualizações mais recentes (sem usar Sprout nem Sapling), os usuários podem deixar a Zcash em um endereço público (t-address) ou em um endereço blindado (de preferência Orchard). Então, se alguns usuários quiserem usar a Zcash igualzinho ao Bitcoin, eles podem.

A Zcash tenta resolver isso recomendando carteiras que respeitam a privacidade. Por exemplo, a carteira Zashi tenta blindar os seus fundos por padrão. O problema disso? A Zcash não é muito usada, então comprar Zcash de pessoa para pessoa ou em uma exchange descentralizada como a Bisq ou a Haveno Reto é muito difícil.

Então você precisa comprar em uma exchange que não respeita a privacidade, como a Binance ou a Coinbase. E, claro, essas exchanges não suportam endereços blindados. Você precisa usar o seu endereço transparente para receber a Zcash antes de blindá-la.

De alguma forma, a Zcash acredita que consegue oferecer privacidade total e, ao mesmo tempo, obedecer aos governos e às leis contra a privacidade. A comunidade e os usuários da Zcash estão acostumados a comprar as suas moedas por meios não privados. Se o governo decidir que blindar a sua Zcash é ilegal, você não vai conseguir comprar e blindar as suas moedas, porque o governo sabe que o t-address está ligado a você, e, se você fizer uma transação de blindagem, acabou de cometer um crime.

Eles podem até bloquear moedas “contaminadas”: se uma Zcash já foi blindada alguma vez, ela pode ser considerada “contaminada” e bloqueada nas exchanges. Durante o protesto do comboio no Canadá, o governo tentou apreender Bitcoin, mas, como a carteira não era custodial, não conseguiu. Eles logo perceberam que podiam pedir a todas as exchanges para recusar esses Bitcoins “sujos”.

Agora você deve estar se perguntando em que o Monero é diferente. Bom, o Monero é privado por padrão, o que significa que os usuários não precisam se preocupar em blindar e “desblindar” moedas. E toda loja que aceita Monero faz isso pela privacidade, ao contrário da Zcash, em que lojistas e exchanges podem aceitar Zcash só em endereços transparentes.

E sim, como você deve ter pensado, alguns governos e exchanges baniram o Monero, o que na verdade foi bom para ele. Por quê? Porque agora ele está anos-luz à frente da Zcash. O Monero tem um ecossistema de verdade. Você pode comprar bens e serviços diretamente com Monero, pode comprar Monero sem nenhuma exchange, e o Monero sabe sobreviver em um ambiente sem aprovação legal.

Por exemplo, você pode comprar gift cards na Coinsbee ou na Cake Pay diretamente com Monero, vender serviços e produtos por Monero diretamente no XMRBazaar, encontrar vários tipos de serviços que aceitam Monero no Monerica, usar IA com privacidade pagando com Monero no Nano-GPT ou negociar Monero com privacidade e sem KYC na RetoSwap.

E isso é só o começo. O uso do Monero vem crescendo, e o objetivo é conseguir viver totalmente com Monero para alcançar a liberdade financeira.

Então, ser privado por padrão é definitivamente a escolha superior. O dinheiro vivo é privado por padrão, igualzinho ao Monero.

3. A Zcash é muito centralizada

Isso mesmo. Talvez você não saiba, mas um único pool de mineração da Zcash, a ViaBTC, tem quase 70% do poder de mineração.

Isso significa que, se a ViaBTC começar a agir de má-fé, ela poderia, em teoria, gastar a mesma ZEC duas vezes ou censurar transações.

A Zcash tem um plano para resolver isso, mas, por enquanto, é uma promessa e não algo que já está no ar. Eles querem criar uma camada de PoS (proof-of-stake, prova de participação) para garantir que os usuários tenham mais controle sobre a validação das transações.

Ainda não tenho uma opinião formada sobre essa camada de PoS, então vou evitar falar dela.

O ponto continua válido, porém: a Zcash é muito centralizada. E não só por causa do pool de mineração. Dá para ver claramente que a comunidade no Reddit não é muito ativa; você não vê pessoas promovendo e rodando nós de Zcash como vê na comunidade do Monero. Os grupos da comunidade normalmente são formados por instituições ligadas à Zcash.

A Zcash precisa se esforçar em marketing para convencer as pessoas a usá-la, enquanto o Monero tem adoção natural, e os usuários espalham a palavra de graça. Existem vários sites e podcasts da comunidade, e você realmente vê pessoas usando a moeda, em vez de só comprar e torcer por uma alta enorme de preço.

Existem vários guias sobre como usar uma carteira Monero, como rodar um nó, como gastar etc. Com a Zcash, o que você normalmente encontra são promessas de que “a tecnologia é incrível e vai valer mais que o Bitcoin”.

4. A Zcash tem uma taxa para os desenvolvedores

Se você estivesse propondo um dinheiro global para ser usado por todo mundo, acharia justo destinar 20% do dinheiro minerado para pagar o desenvolvimento?

Eu acho que não, e a maioria das pessoas também acha que não. A Zcash fez exatamente isso. 20% das moedas mineradas vão diretamente para instituições da Zcash que, em tese, desenvolvem e divulgam a Zcash.

Com essa proposta, os desenvolvedores e a governança da moeda não precisam conquistar a confiança dos usuários. Eles são remunerados por padrão e obviamente vão vender a Zcash por moeda fiduciária, já que esse é basicamente o salário deles, e eles têm contas para pagar.

Com isso em mente, possíveis investidores e usuários sempre vão temer uma venda em massa da criptomoeda quando o preço disparar.

5. A experiência de uso da Zcash ainda é péssima

A Zcash ainda é meio complexa para o usuário comum. Para resolver isso, o jeito recomendado de usar a Zcash hoje é com a Zashi, que tenta blindar as transações por padrão.

A Zashi tem alguns problemas sérios, porém. O primeiro é o idioma. Só o inglês é suportado. Sério mesmo? A carteira mais recomendada só suporta inglês? A Zcash foi feita para ser usada só nos EUA/Reino Unido? É uma pena que um projeto com taxa de desenvolvimento não consiga fazer uma carteira multilíngue. A Cake Wallet, a Stack Wallet e a Monerujo não tinham nenhuma taxa de desenvolvimento, mas suportam vários idiomas. Qual é a sua desculpa, Zashi?

O segundo problema é que a Zashi não parece ser estável, principalmente com quantias maiores de Zcash. Recentemente, um usuário relatou que não consegue gastar a sua Zcash. Isso acontece porque a Zashi só deixa você gastar Zcash blindada, e a carteira não consegue blindar a Zcash dele.

Sei que isso não é especificamente falta de habilidade, porque não faz muito tempo, quando eu estava testando a Zcash, tive um problema parecido. Recebi Zcash na Zashi, mas não consegui blindá-la. Não lembro exatamente o que fiz para resolver (eu estava testando a Ywallet e a Nighthawk), mas com certeza não foi uma boa primeira impressão da Zcash. Lembro de testar o recebimento de Zcash em um celular mais antigo e em um mais novo (os dois usando a Zashi), e o celular mais novo conseguiu receber e blindar as moedas com facilidade, mas o mais antigo sofreu.

Não sei se foi coincidência, mas pareceu que a Zashi é pesada no celular. Nunca tive esse problema com o Monero.

Claro, sincronizar o Monero leva um tempo, mas funciona em segundo plano sem problemas na Monerujo, é só esperar. Fica ainda mais rápido se você tiver um nó de Monero local rodando em casa, o que eu suspeito que 99% dos usuários de Zcash não têm.

Hoje, a Zashi também precisa estar sincronizada para ser usada direito, e isso leva muito tempo e exige que você deixe a tela ligada.

As duas moedas precisam ser mais fáceis de usar, mas o Monero ainda é melhor que a Zcash em interface. Os usuários não precisam se preocupar com pools Sapling ou Orchard nem ter problemas para “blindar” as suas moedas.

6. Comportamento do preço

Por causa do lançamento com configuração confiável e da taxa de desenvolvimento, a Zcash provavelmente está destinada a ser uma moeda de pump. Sem adoção no mundo real, o preço dela pode ser manipulado para subir, mas é pouco provável que esses ganhos durem.

Os entusiastas de criptomoedas estão de olho na Zcash agora por causa de uma alta enorme de preço, mas duvido que isso se sustente. Se você olhar o gráfico de preço da Zcash num período maior, ele ainda parece ridículo. Já no Monero, um período maior mostra um crescimento constante e lento ao longo do tempo.

Conclusão

A Zcash é péssima. Depois de estudá-la melhor, chamá-la de Ztrash é o certo a fazer. Fazer diferente não seria honesto.

Créditos

https://lukesmith.xyz/articles/monero-and-other-privacy-coins/