# 🐧 Guia Completo - Configuração no Ubuntu Linux

## 📋 Pré-requisitos

1. Acesso SSH ao servidor Ubuntu
2. PHP 8.1+ instalado
3. Composer instalado
4. Laravel configurado e funcionando
5. Permissões de sudo (para configurar cron)

## 🚀 Passo a Passo Completo

### 1. Conectar ao Servidor

```bash
ssh usuario@seu-servidor.com
cd /caminho/para/seu/projeto/backend
```

### 2. Verificar Configurações do Laravel

```bash
# Verificar se o .env está configurado corretamente
cat .env | grep -E "APP_ENV|APP_TIMEZONE|QUEUE_CONNECTION"

# Deve mostrar:
# APP_ENV=production
# APP_TIMEZONE=UTC
# APP_USER_TIMEZONE=America/Sao_Paulo
# QUEUE_CONNECTION=database
```

Se não estiver configurado, edite o `.env`:

```bash
nano .env
```

### 3. Criar Scripts de Execução

#### 3.1. Script do Scheduler

Os scripts já existem no projeto! Você só precisa ajustar o caminho do PHP.

```bash
# Verificar se os scripts existem
ls -la run-scheduler.sh run-queue.sh

# Se não existirem, crie-os:
nano run-scheduler.sh
```

Cole o seguinte conteúdo (ou use o arquivo existente):

```bash
#!/bin/bash

# Script para executar o scheduler do Laravel
# Este script será executado pelo cron a cada minuto

# Obter o diretório do script
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
cd "$SCRIPT_DIR"

# Carregar variáveis de ambiente do .env (sem sobrescrever APP_ENV se já estiver definido)
if [ -f .env ]; then
    set -a
    source .env
    set +a
    # Não sobrescrever APP_ENV se já estiver definido
    if [ -z "$APP_ENV" ]; then
        export APP_ENV=production
    fi
fi

# Encontrar PHP (tenta vários caminhos comuns)
PHP_BIN=$(which php 2>/dev/null || echo "/usr/bin/php")

# Executar o scheduler
$PHP_BIN artisan schedule:run >> storage/logs/scheduler.log 2>&1
```

Tornar o script executável:

```bash
chmod +x run-scheduler.sh
```

#### 3.2. Script do Queue Worker

```bash
nano run-queue.sh
```

Cole o seguinte conteúdo (ou use o arquivo existente):

```bash
#!/bin/bash

# Script para executar o queue worker do Laravel
# Este script será executado como serviço systemd

# Obter o diretório do script
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
cd "$SCRIPT_DIR"

# Carregar variáveis de ambiente do .env (sem sobrescrever APP_ENV se já estiver definido)
if [ -f .env ]; then
    set -a
    source .env
    set +a
    # Não sobrescrever APP_ENV se já estiver definido
    if [ -z "$APP_ENV" ]; then
        export APP_ENV=production
    fi
fi

# Encontrar PHP (tenta vários caminhos comuns)
PHP_BIN=$(which php 2>/dev/null || echo "/usr/bin/php")

# Executar o queue worker
$PHP_BIN artisan queue:work --tries=3 --timeout=90 --sleep=3
```

Tornar o script executável:

```bash
chmod +x run-queue.sh
```

### 4. Encontrar o Caminho do PHP

```bash
which php
# Exemplo de saída: /usr/bin/php

# Verificar versão
php -v
```

Se o caminho for diferente de `/usr/bin/php`, atualize os scripts acima.

### 5. Configurar o Cron para o Scheduler

```bash
# Editar o crontab
crontab -e
```

Adicione a seguinte linha (escolha uma opção):

#### Opção 1: Executar a cada minuto (Recomendado)

```bash
* * * * * /caminho/para/seu/projeto/backend/run-scheduler.sh
```

#### Opção 2: Executar a cada minuto com log adicional

```bash
* * * * * /caminho/para/seu/projeto/backend/run-scheduler.sh >> /caminho/para/seu/projeto/backend/storage/logs/cron.log 2>&1
```

**IMPORTANTE:** Substitua `/caminho/para/seu/projeto/backend` pelo caminho real do seu projeto!

Salve e saia (no nano: `Ctrl+X`, depois `Y`, depois `Enter`)

### 6. Criar Serviço Systemd para o Queue Worker

#### 6.1. Criar arquivo de serviço

```bash
sudo nano /etc/systemd/system/laravel-queue.service
```

Cole o seguinte conteúdo:

```ini
[Unit]
Description=Laravel Queue Worker
After=network.target

[Service]
Type=simple
User=www-data
Group=www-data
WorkingDirectory=/caminho/para/seu/projeto/backend
ExecStart=/usr/bin/php artisan queue:work --tries=3 --timeout=90 --sleep=3
Restart=always
RestartSec=10

# Variáveis de ambiente
Environment="APP_ENV=production"
EnvironmentFile=/caminho/para/seu/projeto/backend/.env

[Install]
WantedBy=multi-user.target
```

**IMPORTANTE:** 
- Substitua `/caminho/para/seu/projeto/backend` pelo caminho real
- Substitua `www-data` pelo usuário que executa o PHP (pode ser `apache`, `nginx`, ou seu usuário)

#### 6.2. Recarregar systemd e iniciar o serviço

```bash
# Recarregar configurações do systemd
sudo systemctl daemon-reload

# Habilitar o serviço para iniciar automaticamente no boot
sudo systemctl enable laravel-queue.service

# Iniciar o serviço
sudo systemctl start laravel-queue.service

# Verificar status
sudo systemctl status laravel-queue.service
```

### 7. Verificar se Está Funcionando

#### 7.1. Verificar o Scheduler

```bash
# Ver logs do scheduler
tail -f storage/logs/scheduler.log

# Ou verificar se o cron está executando
tail -f storage/logs/cron.log

# Verificar se o cron está configurado
crontab -l
```

#### 7.2. Verificar o Queue Worker

```bash
# Ver status do serviço
sudo systemctl status laravel-queue.service

# Ver logs do serviço
sudo journalctl -u laravel-queue.service -f

# Verificar se está processando jobs
php artisan queue:work --once
```

#### 7.3. Testar Manualmente

```bash
# Testar o scheduler manualmente
php artisan schedule:run

# Verificar jobs na fila
php artisan queue:work --once

# Ver diagnóstico completo
php artisan alerts:diagnose
```

### 8. Comandos Úteis

#### Gerenciar o Queue Worker

```bash
# Parar o serviço
sudo systemctl stop laravel-queue.service

# Iniciar o serviço
sudo systemctl start laravel-queue.service

# Reiniciar o serviço
sudo systemctl restart laravel-queue.service

# Ver status
sudo systemctl status laravel-queue.service

# Ver logs em tempo real
sudo journalctl -u laravel-queue.service -f
```

#### Verificar Logs

```bash
# Logs do Laravel
tail -f storage/logs/laravel.log

# Logs do scheduler
tail -f storage/logs/scheduler.log

# Logs do cron
tail -f storage/logs/cron.log
```

#### Testar o Sistema

```bash
# Criar job de teste
php artisan clients:check-expiring --force

# Processar jobs manualmente
php artisan queue:work --once

# Ver diagnóstico
php artisan alerts:diagnose
```

### 9. Troubleshooting

#### Problema: Cron não está executando

```bash
# Verificar se o cron está rodando
sudo systemctl status cron

# Verificar logs do cron
sudo tail -f /var/log/syslog | grep CRON

# Testar o script manualmente
./run-scheduler.sh
```

#### Problema: Queue Worker não está processando

```bash
# Verificar se o serviço está rodando
sudo systemctl status laravel-queue.service

# Ver logs de erro
sudo journalctl -u laravel-queue.service -n 50

# Verificar se há jobs na fila
php artisan queue:work --once
```

#### Problema: Permissões

```bash
# Dar permissões corretas
sudo chown -R www-data:www-data storage/
sudo chmod -R 775 storage/
sudo chown -R www-data:www-data bootstrap/cache/
sudo chmod -R 775 bootstrap/cache/
```

#### Problema: PHP não encontrado

```bash
# Encontrar o PHP
which php

# Ou
whereis php

# Atualizar os scripts com o caminho correto
```

### 10. Configuração Final

#### 10.1. Verificar Timezone

```bash
# No .env
APP_TIMEZONE=UTC
APP_USER_TIMEZONE=America/Sao_Paulo
```

#### 10.2. Verificar Queue Connection

```bash
# No .env
QUEUE_CONNECTION=database
```

#### 10.3. Criar Tabela de Jobs (se necessário)

```bash
php artisan queue:table
php artisan migrate
```

### 11. Teste Completo

Execute este teste para verificar se tudo está funcionando:

```bash
# 1. Verificar scheduler
php artisan schedule:list

# 2. Executar scheduler manualmente
php artisan schedule:run

# 3. Criar job de teste
php artisan clients:check-expiring --force

# 4. Verificar se job foi criado
php artisan alerts:diagnose

# 5. Processar job manualmente
php artisan queue:work --once

# 6. Verificar se foi enviado
php artisan alerts:diagnose
```

### 12. Monitoramento

#### Criar script de monitoramento

```bash
nano monitor.sh
```

```bash
#!/bin/bash

echo "=== Status do Sistema ==="
echo ""
echo "Scheduler:"
php artisan schedule:list
echo ""
echo "Queue Worker:"
sudo systemctl status laravel-queue.service --no-pager
echo ""
echo "Jobs na Fila:"
php artisan alerts:diagnose
```

```bash
chmod +x monitor.sh
```

## ✅ Checklist Final

- [ ] Scripts criados e executáveis
- [ ] Cron configurado e rodando
- [ ] Serviço systemd criado e rodando
- [ ] Permissões corretas
- [ ] Timezone configurado
- [ ] Queue connection configurado
- [ ] Testes manuais funcionando
- [ ] Logs sendo gerados

## 🎯 Próximos Passos

1. Configure tudo conforme este guia
2. Execute os testes
3. Monitore os logs por algumas horas
4. Verifique se as mensagens estão sendo enviadas

## 📞 Suporte

Se algo não funcionar:
1. Verifique os logs
2. Execute os testes manuais
3. Verifique as permissões
4. Verifique se os serviços estão rodando