Self-hosting on Blog do Aquasp

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 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 rodar o seu próprio nó de Monero

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

Introdução

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

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

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

1. Escolha uma VPS ou monte em casa

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

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

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

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

2. Protegendo a VPS

Antes de tudo, desative o login por senha.

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

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

3. Criando um usuário dedicado

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

adduser monerouser

Defina uma senha e aperte Enter no resto das perguntas.

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

Troque para o novo usuário:

su monerouser
cd ~

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

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

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

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

cd monero
./monerod

Agora edite o arquivo de configuração:

nano ~/.bitmonero/bitmonero.conf

Cole as configurações recomendadas a seguir:

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

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

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

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

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

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

./monerod --detach

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

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

./monerod status

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

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

Conclusão e créditos

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

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

Obrigado pela leitura! 🙂

Como hospedar sua própria instância do Piped

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

Introdução

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

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

Requisitos

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

Ótimos provedores baratos em 2025:

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

Passo 1: Proteja e prepare sua VPS

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

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

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

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

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

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

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

Durante o script:

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

Passo 3: Aponte o DNS para sua VPS

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

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

Passo 4: Suba tudo

docker compose up -d

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

https://piped.yourdomain.com

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

Passo 5: (Opcional) Confira os logs

Bash

# See what Caddy is doing
docker logs -f caddy

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

Dicas bônus

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

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

Obrigado pela leitura!

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

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

Introdução

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

Vamos lá.

Passo 0: Proteja e atualize sua VPS

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

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

Passo 1: Instale a stack principal

# Nginx
apt install nginx -y
systemctl enable nginx

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

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

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

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

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

mysql_secure_installation

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

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

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

Substitua:

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

systemctl restart php8.3-fpm

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

Passo 4: Otimize o PHP e ative o OPcache

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

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

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

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

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

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

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

 client_max_body_size 10G;

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

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

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

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

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

su yoursiteuser
cd ~/public_html

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

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

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

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

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

Passo 9: Ative o cache de objetos com Redis

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

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

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

Pronto!

Agora você tem:

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

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

Próximos passos:

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

Aproveite o seu WordPress privado e ultrarrápido!

Obrigado pela leitura! 😊

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

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

Introdução

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

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

Passo 0: Arrume uma VPS barata

Bons provedores com promoções frequentes:

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

Requisitos:

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

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

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

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

Troque a senha de root:

passwd

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

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

Agora desative o login por senha:

nano /etc/ssh/sshd_config

Altere:

PasswordAuthentication no
UsePAM no

Depois:

systemctl restart sshd

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

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

apt install curl nginx python3-certbot-nginx -y

Aponte estes registros DNS para o IP da sua VPS:

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

Rode o script do Luke:

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

Siga as perguntas:

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

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

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

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

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

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

Passo 4: Crie sua primeira caixa de e-mail

useradd -G mail -m yourusername
passwd yourusername

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

Teste no Thunderbird/cliente IMAP:

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

Passo 5: Instale o webmail Roundcube

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

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

Proteja o MySQL:

mysql_secure_installation

Crie o banco de dados do Roundcube:

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

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

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

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

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

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

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

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

Teste e recarregue o Nginx, depois obtenha o SSL:

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

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

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

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

Ao terminar, apague o instalador:

rm -rf /var/www/roundcube/installer

Passo 6: Ajustes de qualidade de vida

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

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

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

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

Aumente o tamanho dos anexos:

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

upload_max_filesize = 50M
post_max_size = 50M

Depois:

systemctl restart php8.0-fpm

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

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

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

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

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

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

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

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

Reinicie:

systemctl restart fail2ban php8.0-fpm

Pronto! Agora o seu webmail está protegido.

Resultado final

Agora você tem:

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

Bem-vindo à verdadeira liberdade no e-mail.

Obrigado pela leitura! 😊

Self-hosting on Blog do Aquasp

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

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

Observações adicionais sobre o Jellyfin 10.11.x

Créditos

Como exportar e importar volumes do Docker com facilidade

Passo 1: Liste seus volumes

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

Passo 3: Importe no servidor novo

Bônus: usando volumes externos com o Docker Compose

Casos de uso reais

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

Introdução

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

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

Configuração passo a passo

1. No seu servidor de casa (o potente)

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

3. Crie o script que gerencia os túneis

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

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

Vantagens desta configuração

Palavras finais

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

Introdução

Passo 1: Instale o Rclone

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

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

Passo 4: Crie o script de backup

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

O que entra no backup?

Bônus: restaure em caso de desastre

Créditos e agradecimentos

Como instalar o NextCloud com OpenLiteSpeed (stack LOMP)

Introdução

Passo 1: Proteja sua VPS primeiro

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

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

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

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

Configuração do Virtual Host

Passo 6: Emita o SSL do Let’s Encrypt

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

Passo 8: Instale e proteja o MariaDB/MySQL

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

Passo 10: Configure o Redis como socket Unix

Passo 11: Configuração final do NextCloud

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

Edite o config.php (depois do primeiro login)

Configure as tarefas em segundo plano (cron)

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

Pronto!

Como rodar o seu próprio nó de Monero

Introdução

1. Escolha uma VPS ou monte em casa

2. Protegendo a VPS

3. Criando um usuário dedicado

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

Conclusão e créditos

Como hospedar sua própria instância do Piped

Introdução

Requisitos

Passo 1: Proteja e prepare sua VPS

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

Passo 3: Aponte o DNS para sua VPS

Passo 4: Suba tudo

Passo 5: (Opcional) Confira os logs

Dicas bônus

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

Introdução

Passo 0: Proteja e atualize sua VPS

Passo 1: Instale a stack principal

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

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

Passo 4: Otimize o PHP e ative o OPcache

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

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

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

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

Passo 9: Ative o cache de objetos com Redis