QrRapido/DOCKER_SECRETS_SETUP.md

# Docker Secrets Setup - QR Rapido

Este documento descreve como configurar Docker Secrets para o QR Rapido em ambiente de produção.

## Por que usar Docker Secrets?

- Credenciais sensíveis não ficam expostas no código ou em arquivos de configuração
- Secrets são criptografados em repouso e em trânsito
- Apenas containers autorizados têm acesso
- Facilita rotação de credenciais sem rebuild de imagens

## Secrets Necessários

| Secret Name | Descrição | Exemplo |
|-------------|-----------|---------|
| `stripe_secret_key` | Stripe API Secret Key | `sk_live_xxx` |
| `stripe_webhook_secret` | Stripe Webhook Signing Secret | `whsec_xxx` |
| `mongodb_connection_string` | String de conexão MongoDB completa | `mongodb://user:pass@host:port/db?options` |
| `google_client_id` | Google OAuth Client ID | `xxx.apps.googleusercontent.com` |
| `google_client_secret` | Google OAuth Client Secret | `GOCSPX-xxx` |
| `microsoft_client_id` | Microsoft OAuth Client ID | `guid` |
| `microsoft_client_secret` | Microsoft OAuth Client Secret | `xxx` |

## Criando os Secrets (Uma única vez)

Conecte no servidor manager do Swarm e execute os comandos abaixo.

### Opção 1: Via linha de comando (menos seguro - fica no histórico)

```bash
# Stripe
echo "sk_live_SUBSTITUA_PELA_SUA_CHAVE" | docker secret create stripe_secret_key -
echo "whsec_SUBSTITUA_PELO_SEU_SECRET" | docker secret create stripe_webhook_secret -

# MongoDB
echo "mongodb://admin:SENHA@129.146.116.218:27017,141.148.162.114:27017/QrRapido?replicaSet=rs0&authSource=admin" | docker secret create mongodb_connection_string -

# Google OAuth
echo "SEU_GOOGLE_CLIENT_ID.apps.googleusercontent.com" | docker secret create google_client_id -
echo "GOCSPX-SEU_CLIENT_SECRET" | docker secret create google_client_secret -

# Microsoft OAuth
echo "SEU_MICROSOFT_CLIENT_ID" | docker secret create microsoft_client_id -
echo "SEU_MICROSOFT_CLIENT_SECRET" | docker secret create microsoft_client_secret -
```

### Opção 2: Via arquivo (mais seguro)

```bash
# Cria arquivo temporário, insere o valor, cria o secret, e remove o arquivo
nano /tmp/stripe_secret && docker secret create stripe_secret_key /tmp/stripe_secret && rm /tmp/stripe_secret
```

Repita para cada secret.

## Verificando Secrets Criados

```bash
# Lista todos os secrets
docker secret ls

# Deve mostrar:
# ID                          NAME                        CREATED
# xxx                         stripe_secret_key           X minutes ago
# xxx                         stripe_webhook_secret       X minutes ago
# xxx                         mongodb_connection_string   X minutes ago
# xxx                         google_client_id            X minutes ago
# xxx                         google_client_secret        X minutes ago
# xxx                         microsoft_client_id         X minutes ago
# xxx                         microsoft_client_secret     X minutes ago
```

## Recriando o Service com Secrets

Se o service já existe sem os secrets, você precisa recriá-lo:

```bash
# Remove o service existente
docker service rm qrrapido-prod

# O próximo deploy vai criar o service com os secrets automaticamente
```

Ou manualmente:

```bash
docker service create \
  --name qrrapido-prod \
  --replicas 2 \
  --network qrrapido-network \
  --publish published=5001,target=8080 \
  --mount type=bind,source=/app/keys,target=/app/keys \
  --secret stripe_secret_key \
  --secret stripe_webhook_secret \
  --secret mongodb_connection_string \
  --secret google_client_id \
  --secret google_client_secret \
  --secret microsoft_client_id \
  --secret microsoft_client_secret \
  --env ASPNETCORE_ENVIRONMENT=Production \
  --env ASPNETCORE_URLS=http://+:8080 \
  --update-delay 30s \
  --update-parallelism 1 \
  --update-order start-first \
  --restart-condition on-failure \
  --restart-max-attempts 3 \
  registry.redecarneir.us/qrrapido:latest
```

## Atualizando um Secret

Docker Secrets são imutáveis. Para atualizar:

```bash
# 1. Cria novo secret com nome diferente
echo "novo_valor" | docker secret create stripe_secret_key_v2 -

# 2. Atualiza o service para usar o novo secret
docker service update \
  --secret-rm stripe_secret_key \
  --secret-add stripe_secret_key_v2 \
  qrrapido-prod

# 3. Remove o secret antigo
docker secret rm stripe_secret_key

# 4. (Opcional) Renomeia o novo secret
# Infelizmente não é possível renomear, então mantenha a convenção de versões
# ou recrie o service com o nome correto
```

## Verificando se os Secrets estão funcionando

No rodapé da página, você verá:

- **QR Rapido v1.0.0 | Production ✓** - Secrets carregados corretamente
- **QR Rapido v1.0.0 | Production ✗** - Secrets NÃO carregados (problema!)

Você também pode verificar os logs:

```bash
docker service logs qrrapido-prod --tail 50 | grep -i secret
```

## Como funciona internamente

1. O Docker monta cada secret como arquivo em `/run/secrets/<nome_do_secret>`
2. O `DockerSecretsConfigurationProvider` lê esses arquivos na inicialização
3. Os valores sobrescrevem as configurações do `appsettings.json`
4. A variável `App:SecretsLoaded` é definida como `true` quando pelo menos um secret é carregado

## Testando Localmente

Para simular Docker Secrets localmente (sem Swarm):

```bash
# Cria diretório de secrets
mkdir -p /tmp/secrets

# Cria arquivos de teste
echo "sk_test_xxx" > /tmp/secrets/stripe_secret_key
echo "whsec_test" > /tmp/secrets/stripe_webhook_secret

# Executa o container com os secrets montados
docker run -d \
  -v /tmp/secrets:/run/secrets:ro \
  -p 5001:8080 \
  -e ASPNETCORE_ENVIRONMENT=Development \
  qrrapido:latest
```

## Troubleshooting

### Secret não está sendo lido

1. Verifique se o container tem acesso ao secret:
   ```bash
   docker exec -it $(docker ps -q -f name=qrrapido) ls -la /run/secrets/
   ```

2. Verifique o conteúdo (apenas para debug):
   ```bash
   docker exec -it $(docker ps -q -f name=qrrapido) cat /run/secrets/stripe_secret_key
   ```

### Service não inicia

Verifique se todos os secrets existem antes de criar o service:
```bash
docker secret ls
```

### Erro "secret not found"

O secret precisa existir ANTES de criar/atualizar o service que o usa.