# SSL grátis em VPS sem painel, do DNS à renovação

Validação, emissão, vhost e renovação em VPS sem painel, com os comandos de verificação que provam cada etapa e a reversão quando o plugin quebra a configuração.

> em VPS sem painel, a emissão ACME só passa se três coisas baterem antes do certbot rodar: A/AAAA apontando para o servidor, porta 80 aberta de fora e /.well-known/acme-challenge/ servido sem redirecionamento. Falhas de validação repetidas travam novas tentativas por um período, então depurar em staging é obrigatório.

João Rizzon · 2026-11-04 · Servidores

---

## Provar que o DNS resolve e a porta 80 responde de fora

A emissão ACME falha quase sempre por motivo externo ao cliente. O servidor da autoridade certificadora resolve o seu nome, abre a porta 80 e pede um arquivo em `/.well-known/acme-challenge/`. Se qualquer um desses três passos não fechar, nenhuma flag do certbot resolve.

Rode isto antes de instalar o cliente ACME, no próprio VPS e, de preferência, também de fora dele:

```bash
# 1) O A aponta para este servidor?
dig +short A exemplo.com.br
dig +short A www.exemplo.com.br

# 2) Existe AAAA? Se existe, o IPv6 TEM que responder na 80.
dig +short AAAA exemplo.com.br

# 3) A porta 80 está aberta de fora (teste a partir de outra máquina)
curl -sI http://exemplo.com.br | head -n1

# 4) Existe CAA que proíba a CA escolhida?
dig +short CAA exemplo.com.br
dig +short CAA com.br
```

Três checagens merecem comentário.

**AAAA órfão.** O validador tenta o endereço IPv6 primeiro e, em erro de conexão, pode cair para IPv4, então um AAAA morto nem sempre derruba a ordem. O caso silencioso é pior: se o IPv6 responde, mas é outro servidor (ou outro vhost, sem o diretório de desafio), a validação quebra sem que o teste em IPv4 mostre nada. O diagnóstico é brutalmente simples: `curl -6 -sI http://exemplo.com.br`. Compare o corpo e o status com `curl -4`. Se divergirem, remova o AAAA ou faça o IPv6 servir exatamente o mesmo conteúdo.

**CAA.** Um registro `CAA` com `issue "digicert.com"` impede emissão por outra CA. Sem registro CAA, qualquer CA pode emitir. Com registro, só as listadas. Verifique também o domínio pai, porque a busca sobe na árvore.

**Porta 80 aberta de fora.** Testar com `curl localhost` não prova nada. Firewall de nuvem (security group) é camada separada do `ufw`/`nftables` da máquina.

```bash
# quem está escutando na 80 e na 443
ss -lntp '( sport = :80 or sport = :443 )'
```

## certbot por snap ou acme.sh, e quando cada um compensa

Três rotas defensáveis em VPS sem painel.

| Critério | certbot (snap) | certbot (apt/dnf da distro) | acme.sh |
|---|---|---|---||
| Atualização | automática pelo snapd | presa ao ciclo da distro | `acme.sh --upgrade` |
| Dependências | nenhuma no sistema | Python do sistema | shell + curl/socat |
| Plugins de servidor | `--apache`, `--nginx` | idem, versão antiga | `--nginx`, `--apache` (modo deploy) |
| Roda sem root | não | não | sim, com usuário dedicado |
| Renovação | `systemd` timer do próprio pacote | timer/cron do pacote | cron instalado pelo `--install-cronjob` |

Snap, em Debian/Ubuntu:

```bash
sudo apt update && sudo apt install -y snapd
sudo snap install core && sudo snap refresh core
sudo snap install --classic certbot
sudo ln -sf /snap/bin/certbot /usr/bin/certbot
certbot --version
```

acme.sh, sem root no sistema todo:

```bash
curl https://get.acme.sh | sh -s email=admin@exemplo.com.br
source ~/.acme.sh/acme.sh.env
acme.sh --set-default-ca --server letsencrypt
```

O `--set-default-ca` importa: o acme.sh usa outra CA por padrão. Se você quer Let's Encrypt, diga isso explicitamente.

## Plugin do servidor ou webroot, e o que cada um edita no vhost

O plugin (`--nginx`, `--apache`) lê a configuração, injeta o bloco de validação, recarrega o serviço, emite e reescreve o vhost com `ssl_certificate` e redirecionamento. É rápido e é invasivo: ele edita arquivos que você escreveu.

O modo `--webroot` só escreve o arquivo de desafio em um diretório e não toca em configuração nenhuma. Você aponta o `ssl_certificate` à mão. É o modo que eu uso quando o vhost tem lógica própria (proxy reverso, mapas, `include` de fragmentos) e não quero um editor automático passando por cima.

Regra prática:

- Vhost simples, recém-criado, servidor padrão da distro: plugin.
- Vhost com proxy_pass, headers, rate limit, múltiplos `server_name`: webroot.
- Serviço que não é Apache nem NGINX na frente (um binário Go, por exemplo): webroot servido por um NGINX mínimo, ou modo DNS-01.

Emissão por webroot:

```bash
sudo mkdir -p /var/www/letsencrypt
sudo certbot certonly --webroot -w /var/www/letsencrypt \
  -d exemplo.com.br -d www.exemplo.com.br \
  --agree-tos -m admin@exemplo.com.br --no-eff-email
```

E o bloco que garante que o desafio seja servido, antes de qualquer redirecionamento:

```nginx
server {
    listen 80;
    listen [::]:80;
    server_name exemplo.com.br www.exemplo.com.br;

    location ^~ /.well-known/acme-challenge/ {
        root /var/www/letsencrypt;
        default_type "text/plain";
    }

    location / { return 301 https://$host$request_uri; }
}
```

O `^~` não é decoração. Sem ele, um `location ~ \.php$` ou um `location /` com `return 301` pode capturar o caminho do desafio antes, e a CA recebe um 301 em vez do token. É o erro que mais trava emissão em servidor que já tinha HTTPS funcionando um dia.

Em Apache, o equivalente:

```apache
Alias /.well-known/acme-challenge/ /var/www/letsencrypt/.well-known/acme-challenge/
<Directory "/var/www/letsencrypt">
    Require all granted
</Directory>
RedirectMatch 301 ^/(?!\.well-known/acme-challenge/)(.*)$ https://exemplo.com.br/$1
```

## Apontar fullchain e privkey sem quebrar na próxima renovação

O certbot grava em `/etc/letsencrypt/live/<domínio>/`, e os arquivos ali são symlinks para `../../archive/<domínio>/`. Aponte sempre para `live`, nunca para `archive` com número de versão: na renovação o número muda e o vhost fica apontando para o certificado velho.

| Arquivo | O que é | Onde usar |
|---|---|---||
| `fullchain.pem` | folha + intermediária(s) | `ssl_certificate` (NGINX), `SSLCertificateFile` (Apache 2.4.8+) |
| `privkey.pem` | chave privada | `ssl_certificate_key` / `SSLCertificateKeyFile` |
| `cert.pem` | só a folha | Apache antigo, com `SSLCertificateChainFile` |
| `chain.pem` | só a cadeia | OCSP stapling, Apache antigo |

NGINX:

```nginx
server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name exemplo.com.br www.exemplo.com.br;

    ssl_certificate     /etc/letsencrypt/live/exemplo.com.br/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/exemplo.com.br/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
}
```

Apache:

```apache
SSLCertificateFile    /etc/letsencrypt/live/exemplo.com.br/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/exemplo.com.br/privkey.pem
```

A diretiva `http2 on;` existe a partir do NGINX 1.25.1. Em versões anteriores ela não é reconhecida, `nginx -t` falha e o serviço não recarrega: nesses casos use `listen 443 ssl http2;` na própria linha de `listen`. Confira com `nginx -v` antes de colar o bloco.

Teste antes de recarregar: `nginx -t` ou `apachectl configtest`. Recarregue com `systemctl reload nginx`, não `restart`: reload não derruba conexão em andamento.

## Três comandos que provam que a instalação está correta

### Por que o servidor deve enviar 2 certificados, e não 1

```bash
openssl s_client -connect exemplo.com.br:443 -servername exemplo.com.br -showcerts </dev/null \
  | grep -c 'BEGIN CERTIFICATE'
```

Com `fullchain.pem` de uma CA que usa uma intermediária, o esperado é **2** blocos: folha e intermediária. O certificado raiz não é enviado pelo servidor, ele já está no cliente. Se vier **1**, você apontou `cert.pem` por engano e clientes sem cache de intermediária vão falhar (Android antigo, curl em container mínimo, Java).

Para ler o que de fato está lá:

```bash
openssl s_client -connect exemplo.com.br:443 -servername exemplo.com.br </dev/null 2>/dev/null \
  | openssl x509 -noout -subject -issuer -dates -ext subjectAltName
```

Confira que todos os nomes que você pediu aparecem no `subjectAltName`. É aqui que se descobre que o `www` ficou de fora.

### Um único 301, sem salto intermediário entre domínio e www

```bash
curl -sI http://exemplo.com.br | head -n5
curl -s -o /dev/null -w '%{http_code} %{num_redirects} %{url_effective}\n' -L http://exemplo.com.br
```

O ideal é `301` para `https://exemplo.com.br/` direto e `num_redirects` igual a 1. Dois saltos (`http://dominio` → `https://dominio` → `https://www.dominio`) custam um handshake TLS extra em cada visita de primeira vez. Resolva escolhendo o host canônico já no redirecionamento da porta 80.

### Conferir o timer e testar a renovação com --dry-run

```bash
systemctl list-timers | grep -i certbot
sudo certbot renew --dry-run
```

O `--dry-run` usa o ambiente de staging da CA, não consome cota de emissão e exercita o mesmo caminho da renovação real, inclusive os hooks. Se ele passa e a renovação real falha, o problema é cota ou rede, não configuração.

Hook de reload, em `/etc/letsencrypt/renewal-hooks/deploy/reload.sh` (`chmod +x`):

```bash
#!/bin/sh
systemctl reload nginx
```

A mesma lógica de forçar HTTPS depois de emitir aparece na documentação de outras plataformas, como o guia de [Let's Encrypt e Force HTTPS da LiteSpeed](https://docs.litespeedtech.com/shared/cloud/OPT-LETSHTTPS/): emitir é metade; a outra metade é o redirecionamento e o reload automático após cada renovação.

## O que cada erro de emissão diz e como consertar

| Sintoma no log | Causa provável | Conserto |
|---|---|---||
| `Timeout during connect` | porta 80 fechada no firewall de nuvem, ou AAAA órfão | liberar 80 em IPv4 e IPv6, ou remover o AAAA |
| `404` no token | redirecionamento engolindo `/.well-known/acme-challenge/` | `location ^~` ou `RedirectMatch` com negative lookahead |
| `CAA record ... prohibits issuance` | CAA do domínio ou do pai não lista a CA | ajustar o CAA e esperar o TTL |
| `DNS problem: NXDOMAIN` | nome ainda não propagado, ou typo no `-d` | `dig +short` em cada nome pedido |
| `too many failed authorizations` | falhas repetidas em sequência | parar de tentar e usar `--dry-run` até acertar |
| `unauthorized` com conteúdo errado | outro vhost responde pelo nome (default server) | conferir `server_name` e qual bloco é o `default_server` |

Sobre a cota de falhas: validações que falham em sequência para o mesmo nome travam novas tentativas por um período, e o número exato depende da política vigente da CA, que muda com o tempo (confira na documentação da autoridade que você usa antes de assumir qualquer valor). É o limite mais fácil de estourar em VPS novo, porque o reflexo é repetir o comando. Repetir não conserta DNS nem firewall. Conserte a causa, valide com `curl` de fora e só então emita. Durante a depuração, use `--dry-run` ou `--test-cert`: o staging tem limites muito mais folgados e não queima a cota de produção.

Para ler o erro completo:

```bash
sudo tail -n 80 /var/log/letsencrypt/letsencrypt.log
```

## Reverter o vhost quando o plugin do certbot quebrar o site

O plugin do certbot faz backup antes de editar. Em vez de reescrever a mão, use o caminho oficial:

```bash
sudo certbot rollback --checkpoints 1
sudo nginx -t && sudo systemctl reload nginx
```

Se você editou à mão, a reversão é manual e previsível desde que exista cópia. Faça a cópia antes, sempre:

```bash
sudo cp -a /etc/nginx/sites-available/exemplo.com.br{,.bak-$(date +%F)}
```

E para remover um certificado que não será mais usado (evita que o timer tente renovar um nome que já não aponta para o servidor, gerando falha recorrente):

```bash
sudo certbot certificates          # lista o que existe
sudo certbot delete --cert-name exemplo.com.br
```

Depois de deletar, confira que nenhum vhost ainda referencia o caminho removido. NGINX se recusa a iniciar com `ssl_certificate` apontando para arquivo inexistente, e aí o site inteiro cai, não só o HTTPS.

## Checklist de dez itens antes de dar o HTTPS por pronto

- `dig` resolve A (e AAAA, se existir) para o IP correto deste VPS.
- `curl -sI http://dominio` responde de fora, em IPv4 e IPv6.
- `dig CAA` não proíbe a CA escolhida.
- `/.well-known/acme-challenge/` é servido antes de qualquer `return 301`.
- Vhost aponta para `live/<dominio>/fullchain.pem` e `privkey.pem`.
- `openssl s_client ... -showcerts | grep -c 'BEGIN CERTIFICATE'` retorna 2.
- `curl -L -w '%{num_redirects}'` retorna 1.
- `systemctl list-timers` mostra o timer do certbot ativo e `certbot renew --dry-run` passa.
- Hook de deploy recarrega o servidor web.
- Existe backup datado do vhost antes de qualquer edição automática.

Se os dez estiverem verdes, a renovação daqui a 60 dias vai acontecer sem você. Se algum estiver vermelho, ele vai falhar exatamente nele, e em um horário em que ninguém está olhando.

