Exemplo 1: Navegação e Exploração Básica

1. Verificar diretório atual: pwd
2. Listar conteúdo detalhado: ls -lha
3. Navegar para raiz: cd /
4. Explorar estrutura: ls -l
5. Ir para /etc: cd /etc
6. Ver arquivos de configuração: ls | head -20
7. Voltar para home: cd ~
8. Verificar espaço em disco: df -h

Exemplo 2: Criação de Estrutura de Diretórios

1. Navegar para /tmp: cd /tmp
2. Criar estrutura complexa: mkdir -p projeto/{src,docs,tests}/{linux,asterisk}
3. Verificar estrutura criada: tree projeto (ou find projeto -type d)
4. Criar arquivos de exemplo:
   touch projeto/src/linux/main.c touch projeto/src/asterisk/dialplan.conf touch projeto/docs/README.md touch projeto/tests/test_suite.sh
5. Listar tudo recursivamente: find projeto -type f

Exemplo 3: Manipulação Avançada de Arquivos

1. Criar arquivo com conteúdo:
   cat > exemplo.txt << EOF Esta é a linha 1 Esta é a linha 2 Esta é a linha 3 EOF
2. Visualizar de diferentes formas:
   cat exemplo.txt # Conteúdo completo head -2 exemplo.txt # Primeiras 2 linhas tail -1 exemplo.txt # Última linha wc -l exemplo.txt # Contar linhas
3. Fazer cópias com diferentes opções:
   cp exemplo.txt backup1.txt # Cópia simples cp -p exemplo.txt backup2.txt # Preserva atributos cp exemplo.txt backup_$(date +%Y%m%d).txt # Com timestamp
4. Criar link simbólico: ln -s exemplo.txt link_exemplo.txt
5. Verificar links: ls -l *exemplo*

Exemplo 4: Trabalhando com Permissões

1. Criar script de exemplo:
   cat > meu_script.sh << 'EOF' #!/bin/bash echo "Olá, mundo!" date EOF
2. Verificar permissões: ls -l meu_script.sh
3. Tentar executar: ./meu_script.sh (deve dar erro)
4. Dar permissão de execução: chmod +x meu_script.sh
5. Executar: ./meu_script.sh
6. Alterar permissões numericamente: chmod 754 meu_script.sh
7. Verificar mudança: ls -l meu_script.sh

Exemplo 1: Configuração Completa de Rede Estática

1. Verificar interfaces disponíveis: ip link show
2. Verificar configuração atual: ip addr show
3. Listar conexões NetworkManager: nmcli con show
4. Configurar IP estático:
   nmcli con modify "System eth0" ipv4.addresses 192.168.1.100/24 nmcli con modify "System eth0" ipv4.gateway 192.168.1.1 nmcli con modify "System eth0" ipv4.dns "8.8.8.8,8.8.4.4" nmcli con modify "System eth0" ipv4.method manual
5. Ativar configuração: nmcli con up "System eth0"
6. Verificar conectividade: ping -c 4 8.8.8.8
7. Testar DNS: nslookup google.com
8. Verificar rota padrão: ip route show

Exemplo 2: Configuração Avançada de Firewall para Asterisk

1. Verificar zona ativa: firewall-cmd --get-active-zones
2. Listar configuração atual: firewall-cmd --list-all
3. Configurar portas para Asterisk:
   # Porta SIP firewall-cmd --zone=public --add-port=5060/udp --permanent firewall-cmd --zone=public --add-port=5060/tcp --permanent # Faixa RTP para áudio firewall-cmd --zone=public --add-port=10000-20000/udp --permanent # Porta para AMI (Asterisk Manager Interface) firewall-cmd --zone=public --add-port=5038/tcp --permanent
4. Criar regra para rede interna:
   firewall-cmd --zone=public --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port protocol="tcp" port="5038" accept' --permanent
5. Recarregar firewall: firewall-cmd --reload
6. Verificar regras aplicadas: firewall-cmd --list-all
7. Testar portas abertas: ss -tuln | grep -E "(5060|5038)"

Exemplo 3: Criação de Usuário Asterisk com Segurança

1. Criar usuário de sistema para Asterisk:
   sudo useradd -r -d /var/lib/asterisk -s /sbin/nologin -c "Asterisk PBX" asterisk
2. Criar grupo para usuários PBX: sudo groupadd pbx-users
3. Criar usuário administrativo:
   sudo useradd -m -s /bin/bash -c "Administrador PBX" -G pbx-users pbxadmin sudo passwd pbxadmin
4. Configurar sudo para pbxadmin:
   echo "pbxadmin ALL=(asterisk) NOPASSWD: /usr/sbin/asterisk" | sudo tee /etc/sudoers.d/pbxadmin
5. Criar diretórios necessários:
   sudo mkdir -p /var/lib/asterisk/{agi-bin,keys,mohmp3,sounds,images} sudo mkdir -p /var/log/asterisk/cdr-csv sudo mkdir -p /var/spool/asterisk/{dictate,meetme,monitor,outgoing,tmp,voicemail} sudo chown -R asterisk:asterisk /var/lib/asterisk /var/log/asterisk /var/spool/asterisk
6. Verificar criação: id asterisk && id pbxadmin

Exemplo 4: Configuração e Monitoramento de Serviços

1. Verificar serviços essenciais:
   systemctl status sshd systemctl status firewalld systemctl status NetworkManager
2. Criar serviço customizado para monitoramento:
   sudo tee /etc/systemd/system/network-monitor.service << 'EOF' [Unit] Description=Network Connectivity Monitor After=network.target [Service] Type=simple ExecStart=/bin/bash -c 'while true; do ping -c 1 8.8.8.8 > /dev/null || logger "Network connectivity lost"; sleep 60; done' Restart=always User=nobody [Install] WantedBy=multi-user.target EOF
3. Habilitar e iniciar o serviço:
   sudo systemctl daemon-reload sudo systemctl enable network-monitor.service sudo systemctl start network-monitor.service
4. Monitorar logs: journalctl -u network-monitor -f
5. Verificar serviços com falha: systemctl --failed

Exemplo 1: Instalação Completa via Repositório (Método Profissional)

1. Preparar sistema base:
   # Atualizar sistema sudo dnf update -y # Instalar repositórios necessários sudo dnf install -y epel-release sudo dnf config-manager --set-enabled powertools # Verificar versão do sistema cat /etc/os-release
2. Instalar dependências completas:
   # Ferramentas de desenvolvimento sudo dnf groupinstall -y "Development Tools" # Bibliotecas essenciais sudo dnf install -y libxml2-devel sqlite-devel ncurses-devel \ openssl-devel libuuid-devel readline-devel zlib-devel \ speex-devel speexdsp-devel opus-devel
3. Configurar usuário e diretórios:
   # Criar usuário asterisk se não existir sudo useradd -r -d /var/lib/asterisk -s /sbin/nologin asterisk # Criar estrutura de diretórios sudo mkdir -p /var/lib/asterisk/{agi-bin,keys,mohmp3,sounds,images} sudo mkdir -p /var/log/asterisk/cdr-csv sudo mkdir -p /var/spool/asterisk/{dictate,meetme,monitor,outgoing,tmp,voicemail} sudo mkdir -p /etc/asterisk # Definir permissões sudo chown -R asterisk:asterisk /var/lib/asterisk /var/log/asterisk /var/spool/asterisk sudo chown -R asterisk:asterisk /etc/asterisk
4. Instalar Asterisk:
   # Instalar via repositório EPEL sudo dnf install -y asterisk asterisk-configs asterisk-sounds-core-en # Ou compilar from source (método avançado) cd /usr/src sudo wget http://downloads.asterisk.org/pub/telephony/asterisk/asterisk-18-current.tar.gz sudo tar -xzf asterisk-18-current.tar.gz cd asterisk-18.* sudo ./configure --with-pjproject-bundled sudo make menuselect # Selecionar módulos desejados sudo make && sudo make install && sudo make samples
5. Configurar e iniciar serviços:
   # Configurar systemd sudo systemctl daemon-reload sudo systemctl enable asterisk sudo systemctl start asterisk # Verificar status sudo systemctl status asterisk sudo asterisk -rx "core show version"

Exemplo 2: Configuração de Segurança e Performance

1. Implementar hardening de segurança:
   # Configurar SELinux para Asterisk sudo setsebool -P asterisk_can_network_connect 1 sudo semanage port -a -t asterisk_port_t -p udp 5060 sudo semanage port -a -t asterisk_port_t -p udp 10000-20000 # Configurar firewall específico sudo firewall-cmd --new-zone=asterisk --permanent sudo firewall-cmd --zone=asterisk --add-port=5060/udp --permanent sudo firewall-cmd --zone=asterisk --add-port=5060/tcp --permanent sudo firewall-cmd --zone=asterisk --add-port=10000-20000/udp --permanent sudo firewall-cmd --reload
2. Otimizar performance do sistema:
   # Configurar limites de recursos sudo tee /etc/systemd/system/asterisk.service.d/limits.conf << 'EOF' [Service] LimitNOFILE=65536 LimitNPROC=32768 LimitMEMLOCK=infinity Nice=-10 IOSchedulingClass=1 IOSchedulingPriority=4 EOF # Aplicar configurações de kernel sudo tee -a /etc/sysctl.d/99-asterisk.conf << 'EOF' # Otimizações para VoIP net.core.rmem_default = 262144 net.core.rmem_max = 16777216 net.core.wmem_default = 262144 net.core.wmem_max = 16777216 net.ipv4.udp_rmem_min = 8192 net.ipv4.udp_wmem_min = 8192 EOF sudo sysctl -p /etc/sysctl.d/99-asterisk.conf
3. Configurar monitoramento:
   # Instalar ferramentas de monitoramento sudo dnf install -y htop iotop nethogs tcpdump # Configurar logrotate para Asterisk sudo tee /etc/logrotate.d/asterisk << 'EOF' /var/log/asterisk/*.log { daily rotate 30 compress delaycompress missingok notifempty create 0640 asterisk asterisk postrotate /usr/sbin/asterisk -rx "logger reload" > /dev/null 2>&1 || true endscript } EOF

Exemplo 3: Configuração Inicial e Validação

1. Configurar arquivos básicos do Asterisk:
   # Backup das configurações originais sudo cp -r /etc/asterisk /etc/asterisk.backup.$(date +%Y%m%d) # Configuração mínima do asterisk.conf sudo tee /etc/asterisk/asterisk.conf << 'EOF' [directories] astetcdir => /etc/asterisk astmoddir => /usr/lib64/asterisk/modules astvarlibdir => /var/lib/asterisk astdbdir => /var/lib/asterisk astkeydir => /var/lib/asterisk astdatadir => /var/lib/asterisk astagidir => /var/lib/asterisk/agi-bin astspooldir => /var/spool/asterisk astrundir => /var/run/asterisk astlogdir => /var/log/asterisk [options] verbose = 3 debug = 1 runuser = asterisk rungroup = asterisk EOF
2. Configurar logging detalhado:
   # Configurar logger.conf sudo tee /etc/asterisk/logger.conf << 'EOF' [general] dateformat=%F %T [logfiles] console => notice,warning,error,debug,verbose messages => notice,warning,error full => notice,warning,error,debug,verbose,dtmf,fax security => security EOF
3. Validar instalação completa:
   # Reiniciar Asterisk com nova configuração sudo systemctl restart asterisk # Conectar à CLI e verificar sudo asterisk -rvvv # Na CLI do Asterisk: core show version core show uptime module show core show channels logger show channels # Verificar logs sudo tail -f /var/log/asterisk/full # Verificar recursos do sistema sudo ss -tuln | grep -E "(5060|5038)" sudo ps aux | grep asterisk sudo systemctl status asterisk

Exemplo 4: Implementação de Backup e Recovery

1. Criar script de backup automatizado:
   # Criar script de backup sudo tee /usr/local/bin/asterisk-backup.sh << 'EOF' #!/bin/bash BACKUP_DIR="/var/backups/asterisk" DATE=$(date +%Y%m%d_%H%M%S) BACKUP_FILE="asterisk_backup_${DATE}.tar.gz" mkdir -p $BACKUP_DIR # Backup das configurações tar -czf ${BACKUP_DIR}/${BACKUP_FILE} \ /etc/asterisk \ /var/lib/asterisk \ /var/spool/asterisk/voicemail \ --exclude=/var/lib/asterisk/sounds/en \ --exclude=/var/lib/asterisk/moh # Manter apenas os últimos 7 backups find $BACKUP_DIR -name "asterisk_backup_*.tar.gz" -mtime +7 -delete echo "Backup criado: ${BACKUP_DIR}/${BACKUP_FILE}" EOF sudo chmod +x /usr/local/bin/asterisk-backup.sh
2. Configurar backup automático:
   # Adicionar ao crontab echo "0 2 * * * /usr/local/bin/asterisk-backup.sh" | sudo crontab -u root - # Testar backup manual sudo /usr/local/bin/asterisk-backup.sh

Exemplo 1: Setup Completo de Estrutura e Backup

1. Análise inicial da estrutura:
   # Verificar estrutura atual sudo find /etc/asterisk -name "*.conf" | wc -l sudo ls -la /etc/asterisk/ | grep -E "\.(conf|inc)$" # Verificar espaço disponível df -h /etc /var/log /var/lib /var/spool # Verificar permissões atuais sudo ls -la /etc/asterisk/asterisk.conf sudo ls -la /var/log/asterisk/
2. Criar estrutura de backup:
   # Criar diretórios de backup sudo mkdir -p /var/backups/asterisk/{config,logs,data} sudo mkdir -p /var/backups/asterisk/config/{daily,weekly,monthly} # Configurar permissões adequadas sudo chown -R asterisk:asterisk /var/backups/asterisk/ sudo chmod 750 /var/backups/asterisk/
3. Implementar backup inicial:
   # Backup completo inicial sudo tar -czf /var/backups/asterisk/config/initial-backup-$(date +%Y%m%d).tar.gz /etc/asterisk/ # Backup de dados críticos sudo cp -r /var/lib/asterisk/astdb /var/backups/asterisk/data/ sudo cp -r /var/spool/asterisk/voicemail /var/backups/asterisk/data/ # Verificar integridade sudo tar -tzf /var/backups/asterisk/config/initial-backup-*.tar.gz | head -10
4. Configurar versionamento Git:
   # Inicializar repositório cd /etc/asterisk sudo git init sudo git config user.name "Asterisk Admin" sudo git config user.email "admin@empresa.com" # Adicionar arquivos principais sudo git add asterisk.conf extensions.conf sip.conf pjsip.conf sudo git add logger.conf modules.conf manager.conf sudo git commit -m "Initial Asterisk configuration setup"

Exemplo 2: Configuração Avançada de Logs e Monitoramento

1. Configurar logger.conf avançado:
   # Editar configuração de logs sudo nano /etc/asterisk/logger.conf # Conteúdo sugerido: [general] dateformat=%F %T.%3q use_callids=yes [logfiles] console => notice,warning,error,debug,verbose messages => notice,warning,error full => notice,warning,error,debug,verbose,dtmf,fax security => security errors => error debug => debug verbose => verbose
2. Configurar logrotate personalizado:
   # Criar configuração de rotação sudo nano /etc/logrotate.d/asterisk # Conteúdo: /var/log/asterisk/*.log /var/log/asterisk/messages { daily missingok rotate 30 compress delaycompress notifempty create 0640 asterisk asterisk postrotate /usr/sbin/asterisk -rx 'logger reload' > /dev/null 2>&1 || true endscript }
3. Implementar monitoramento de mudanças:
   # Instalar inotify-tools sudo dnf install -y inotify-tools # Criar script de monitoramento sudo nano /usr/local/bin/asterisk-config-monitor.sh # Script básico: #!/bin/bash inotifywait -m -r -e modify,create,delete /etc/asterisk/ | while read path action file; do echo "$(date): $action detected on $path$file" >> /var/log/asterisk/config-changes.log cd /etc/asterisk && git add . && git commit -m "Auto-commit: $action on $file" done

Exemplo 3: Análise e Otimização de Performance de Arquivos

1. Análise de performance de I/O:
   # Monitorar I/O de arquivos do Asterisk sudo iotop -a -o -d 1 | grep asterisk # Verificar arquivos mais acessados sudo lsof -p $(pgrep asterisk) | grep -E "\.(conf|log)$" # Análise de fragmentação sudo filefrag /var/log/asterisk/full sudo filefrag /etc/asterisk/*.conf
2. Otimizar configurações de sistema:
   # Configurar noatime para logs (em /etc/fstab) # /var/log ext4 defaults,noatime 0 2 # Configurar tmpfs para arquivos temporários echo "tmpfs /var/spool/asterisk/tmp tmpfs defaults,size=100M 0 0" | sudo tee -a /etc/fstab # Aplicar otimizações sudo mount -o remount /var/log sudo mount /var/spool/asterisk/tmp
3. Implementar cache de configurações:
   # Verificar cache do Asterisk sudo asterisk -rx "core show settings" | grep -i cache # Configurar cache de DNS echo "nameserver 8.8.8.8" | sudo tee -a /etc/resolv.conf echo "nameserver 8.8.4.4" | sudo tee -a /etc/resolv.conf # Otimizar acesso a arquivos de som sudo find /var/lib/asterisk/sounds -name "*.wav" -exec chmod 644 {} \;

Exemplo 4: Recovery e Disaster Recovery

1. Criar script de backup automatizado:
   # Criar script de backup completo sudo nano /usr/local/bin/asterisk-full-backup.sh #!/bin/bash BACKUP_DIR="/var/backups/asterisk" DATE=$(date +%Y%m%d-%H%M%S) # Parar Asterisk temporariamente systemctl stop asterisk # Backup de configurações tar -czf "$BACKUP_DIR/config/asterisk-config-$DATE.tar.gz" /etc/asterisk/ # Backup de dados tar -czf "$BACKUP_DIR/data/asterisk-data-$DATE.tar.gz" /var/lib/asterisk/ /var/spool/asterisk/ # Backup de logs recentes tar -czf "$BACKUP_DIR/logs/asterisk-logs-$DATE.tar.gz" /var/log/asterisk/ # Reiniciar Asterisk systemctl start asterisk # Limpar backups antigos (manter 30 dias) find "$BACKUP_DIR" -name "*.tar.gz" -mtime +30 -delete
2. Testar procedimento de recovery:
   # Simular falha (backup de segurança primeiro) sudo cp -r /etc/asterisk /etc/asterisk.backup # Restaurar de backup sudo systemctl stop asterisk sudo rm -rf /etc/asterisk/* sudo tar -xzf /var/backups/asterisk/config/asterisk-config-*.tar.gz -C / sudo systemctl start asterisk # Verificar integridade sudo asterisk -rx "core show version" sudo asterisk -rx "dialplan show"

Exemplo 1: Configuração de Softphones Profissionais e Testes de Qualidade

1. Configurar softphones com parâmetros avançados:
   # Parâmetros recomendados para softphones profissionais: # Zoiper (arquivo de configuração) [Account1] Username=100 Password=Str0ng_P@ssw0rd_100 Domain=192.168.1.100 Proxy=192.168.1.100:5060 Transport=UDP DTMF=RFC2833 Codec1=PCMU Codec2=PCMA Codec3=GSM VAD=No CNG=No EchoCancellation=Yes NoiseReduction=Yes AGC=Yes # Configurações de QoS DSCP=46 RTPTimeout=30 SIPTimeout=32 KeepAlive=25 # Linphone (linphonerc) [sip] default_proxy=0 register_only_when_network_is_up=1 register_only_when_upnp_is_ok=1 [proxy_0] reg_proxy=sip:192.168.1.100:5060 reg_identity=sip:100@192.168.1.100 reg_password=Str0ng_P@ssw0rd_100 reg_expires=3600 quality_reporting_enabled=1 quality_reporting_interval=5
2. Implementar testes automatizados de qualidade:
   # Script de teste de qualidade de chamadas sudo nano /usr/local/bin/call-quality-test.sh #!/bin/bash # Teste automatizado de qualidade de chamadas LOG_FILE="/var/log/asterisk/quality-test.log" DATE=$(date '+%Y-%m-%d %H:%M:%S') # Função para log log_test() { echo "[$DATE] $1" >> $LOG_FILE } # Teste 1: Conectividade SIP log_test "=== INICIANDO TESTE DE QUALIDADE ===" SIP_STATUS=$(asterisk -rx "sip show peers" | grep "100" | awk '{print $6}') log_test "Status SIP Ramal 100: $SIP_STATUS" # Teste 2: Qualificação de ramais QUALIFY_100=$(asterisk -rx "sip qualify peer 100" 2>&1) log_test "Qualificação 100: $QUALIFY_100" # Teste 3: Chamada de teste automatizada log_test "Iniciando chamada de teste..." asterisk -rx "originate SIP/100 extension *43@interno" & CALL_PID=$! sleep 10 # Teste 4: Análise de qualidade RTP RTP_STATS=$(asterisk -rx "rtp show stats" | grep -A 10 -B 2 "100") log_test "Estatísticas RTP: $RTP_STATS" # Teste 5: Verificar canais ativos ACTIVE_CHANNELS=$(asterisk -rx "core show channels" | grep "active call") log_test "Canais ativos: $ACTIVE_CHANNELS" # Finalizar chamada de teste kill $CALL_PID 2>/dev/null asterisk -rx "soft hangup SIP/100-*" 2>/dev/null log_test "=== TESTE CONCLUÍDO ==="
3. Configurar monitoramento contínuo:
   # Script de monitoramento contínuo sudo nano /usr/local/bin/continuous-quality-monitor.sh #!/bin/bash # Monitor contínuo de qualidade while true; do # Coletar métricas de qualidade TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S') # Métricas de sistema CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1) MEM_USAGE=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100.0}') # Métricas de Asterisk ACTIVE_CALLS=$(asterisk -rx "core show channels" | grep "active call" | awk '{print $1}') SIP_PEERS=$(asterisk -rx "sip show peers" | grep "OK" | wc -l) # Log das métricas echo "$TIMESTAMP,CPU:$CPU_USAGE,MEM:$MEM_USAGE,CALLS:$ACTIVE_CALLS,PEERS:$SIP_PEERS" >> /var/log/asterisk/quality-metrics.csv # Alertas automáticos if (( $(echo "$CPU_USAGE > 80" | bc -l) )); then echo "$TIMESTAMP - ALERTA: CPU alta - $CPU_USAGE%" >> /var/log/asterisk/alerts.log fi if [ "$ACTIVE_CALLS" -gt 50 ]; then echo "$TIMESTAMP - ALERTA: Muitas chamadas ativas - $ACTIVE_CALLS" >> /var/log/asterisk/alerts.log fi sleep 30 done

Exemplo 2: Troubleshooting Sistemático de Problemas de Áudio

1. Diagnóstico de problemas de áudio unidirecional:
   # Script de diagnóstico de áudio sudo nano /usr/local/bin/audio-troubleshoot.sh #!/bin/bash # Diagnóstico sistemático de problemas de áudio echo "=== DIAGNÓSTICO DE ÁUDIO ===" echo "Data/Hora: $(date)" echo # Passo 1: Verificar configuração de NAT echo "1. Verificando configuração de NAT..." grep -E "(externip|localnet|nat)" /etc/asterisk/sip.conf echo # Passo 2: Verificar portas RTP echo "2. Verificando configuração de portas RTP..." grep -E "rtpstart|rtpend" /etc/asterisk/rtp.conf echo # Passo 3: Verificar firewall echo "3. Verificando regras de firewall..." sudo firewall-cmd --list-ports | grep -E "(5060|10000-20000)" sudo iptables -L | grep -E "(5060|10000:20000)" echo # Passo 4: Testar conectividade RTP echo "4. Testando conectividade RTP..." sudo netstat -tuln | grep -E ":1[0-9]{4}" echo # Passo 5: Verificar codecs em uso echo "5. Verificando codecs..." asterisk -rx "core show translation" echo # Passo 6: Análise de tráfego em tempo real echo "6. Iniciando captura de tráfego (30 segundos)..." timeout 30 sudo tcpdump -i any -n portrange 10000-20000 -c 100 > /tmp/rtp-analysis.txt 2>&1 & echo "Faça uma chamada de teste agora..." wait echo "Pacotes RTP capturados:" wc -l /tmp/rtp-analysis.txt
2. Análise avançada de qualidade RTP:
   # Script de análise de qualidade RTP sudo nano /usr/local/bin/rtp-quality-analysis.sh #!/bin/bash # Análise detalhada de qualidade RTP echo "=== ANÁLISE DE QUALIDADE RTP ===" # Capturar estatísticas RTP durante chamada ativa if asterisk -rx "core show channels" | grep -q "active call"; then echo "Chamada ativa detectada. Coletando estatísticas..." # Coletar estatísticas múltiplas vezes for i in {1..5}; do echo "--- Coleta $i/5 ---" asterisk -rx "rtp show stats" | grep -A 20 -B 5 "SSRC" sleep 2 done # Análise de RTCP echo "=== Relatórios RTCP ===" asterisk -rx "rtcp show stats" # Verificar transcodificação echo "=== Verificação de Transcodificação ===" asterisk -rx "core show translation" | grep -E "(ulaw|alaw|gsm)" else echo "Nenhuma chamada ativa. Iniciando chamada de teste..." asterisk -rx "originate SIP/100 extension *43@interno" & sleep 5 # Repetir análise $0 fi
3. Implementar correções automáticas:
   # Script de correções automáticas sudo nano /usr/local/bin/audio-auto-fix.sh #!/bin/bash # Correções automáticas para problemas de áudio echo "=== APLICANDO CORREÇÕES AUTOMÁTICAS ===" # Correção 1: Otimizar configuração de NAT echo "1. Otimizando configuração de NAT..." if ! grep -q "nat=force_rport,comedia" /etc/asterisk/sip.conf; then sudo sed -i '/\[general\]/a nat=force_rport,comedia' /etc/asterisk/sip.conf echo " - Configuração NAT adicionada" fi # Correção 2: Configurar externip automaticamente EXTERNAL_IP=$(curl -s ifconfig.me) if [ ! -z "$EXTERNAL_IP" ]; then if ! grep -q "externip=" /etc/asterisk/sip.conf; then sudo sed -i "/\[general\]/a externip=$EXTERNAL_IP" /etc/asterisk/sip.conf echo " - IP externo configurado: $EXTERNAL_IP" fi fi # Correção 3: Otimizar portas RTP echo "2. Otimizando configuração RTP..." sudo tee /etc/asterisk/rtp.conf > /dev/null << EOF [general] rtpstart=10000 rtpend=20000 rtpchecksums=no dtmftimeout=3000 rtphold=yes EOF # Correção 4: Aplicar configurações echo "3. Aplicando configurações..." asterisk -rx "sip reload" asterisk -rx "rtp reload" echo "=== CORREÇÕES APLICADAS ===" echo "Teste uma chamada para verificar a melhoria."

Exemplo 3: Monitoramento Avançado com Alertas Inteligentes

1. Configurar coleta de métricas avançadas:
   # Script de coleta de métricas sudo nano /usr/local/bin/advanced-metrics-collector.sh #!/bin/bash # Coletor avançado de métricas do Asterisk METRICS_DIR="/var/log/asterisk/metrics" mkdir -p $METRICS_DIR # Timestamp TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S') EPOCH=$(date +%s) # Métricas de sistema CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1) MEM_USAGE=$(free | grep Mem | awk '{printf "%.2f", $3/$2 * 100.0}') DISK_USAGE=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//') LOAD_AVG=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//') # Métricas de Asterisk ACTIVE_CALLS=$(asterisk -rx "core show channels" | grep "active call" | awk '{print $1}') SIP_PEERS_OK=$(asterisk -rx "sip show peers" | grep -c "OK") SIP_PEERS_TOTAL=$(asterisk -rx "sip show peers" | grep -c "^[0-9]") PJSIP_ENDPOINTS=$(asterisk -rx "pjsip show endpoints" | grep -c "Avail") # Métricas de qualidade if [ "$ACTIVE_CALLS" -gt 0 ]; then RTP_PACKETS_LOST=$(asterisk -rx "rtp show stats" | grep -o "Lost: [0-9]*" | awk '{sum+=$2} END {print sum+0}') RTP_JITTER=$(asterisk -rx "rtp show stats" | grep -o "Jitter: [0-9.]*" | awk '{sum+=$2; count++} END {if(count>0) print sum/count; else print 0}') else RTP_PACKETS_LOST=0 RTP_JITTER=0 fi # Salvar métricas em formato CSV echo "$EPOCH,$TIMESTAMP,$CPU_USAGE,$MEM_USAGE,$DISK_USAGE,$LOAD_AVG,$ACTIVE_CALLS,$SIP_PEERS_OK,$SIP_PEERS_TOTAL,$PJSIP_ENDPOINTS,$RTP_PACKETS_LOST,$RTP_JITTER" >> $METRICS_DIR/metrics.csv # Salvar métricas em formato JSON para APIs cat > $METRICS_DIR/current-metrics.json << EOF { "timestamp": "$TIMESTAMP", "epoch": $EPOCH, "system": { "cpu_usage": $CPU_USAGE, "memory_usage": $MEM_USAGE, "disk_usage": $DISK_USAGE, "load_average": $LOAD_AVG }, "asterisk": { "active_calls": $ACTIVE_CALLS, "sip_peers_ok": $SIP_PEERS_OK, "sip_peers_total": $SIP_PEERS_TOTAL, "pjsip_endpoints": $PJSIP_ENDPOINTS }, "quality": { "rtp_packets_lost": $RTP_PACKETS_LOST, "rtp_jitter": $RTP_JITTER } } EOF
2. Implementar sistema de alertas inteligentes:
   # Sistema de alertas inteligentes sudo nano /usr/local/bin/intelligent-alerts.sh #!/bin/bash # Sistema de alertas inteligentes ALERTS_LOG="/var/log/asterisk/alerts.log" METRICS_FILE="/var/log/asterisk/metrics/current-metrics.json" # Função para enviar alerta send_alert() { local severity=$1 local message=$2 local timestamp=$(date '+%Y-%m-%d %H:%M:%S') echo "[$timestamp] [$severity] $message" >> $ALERTS_LOG # Enviar por email (configurar sendmail/postfix) # echo "$message" | mail -s "Asterisk Alert [$severity]" admin@empresa.com # Enviar para syslog logger -p local0.$severity "Asterisk: $message" # Webhook para sistemas de monitoramento # curl -X POST -H "Content-Type: application/json" \ # -d "{\"severity\":\"$severity\",\"message\":\"$message\"}" \ # http://monitoring-system/webhook } # Ler métricas atuais if [ -f "$METRICS_FILE" ]; then CPU_USAGE=$(jq -r '.system.cpu_usage' $METRICS_FILE) MEM_USAGE=$(jq -r '.system.memory_usage' $METRICS_FILE) ACTIVE_CALLS=$(jq -r '.asterisk.active_calls' $METRICS_FILE) SIP_PEERS_OK=$(jq -r '.asterisk.sip_peers_ok' $METRICS_FILE) RTP_PACKETS_LOST=$(jq -r '.quality.rtp_packets_lost' $METRICS_FILE) RTP_JITTER=$(jq -r '.quality.rtp_jitter' $METRICS_FILE) else echo "Arquivo de métricas não encontrado!" exit 1 fi # Alertas de sistema if (( $(echo "$CPU_USAGE > 80" | bc -l) )); then send_alert "warning" "CPU usage high: ${CPU_USAGE}%" fi if (( $(echo "$MEM_USAGE > 90" | bc -l) )); then send_alert "critical" "Memory usage critical: ${MEM_USAGE}%" fi # Alertas de telefonia if [ "$SIP_PEERS_OK" -eq 0 ]; then send_alert "critical" "No SIP peers registered!" fi if [ "$ACTIVE_CALLS" -gt 100 ]; then send_alert "warning" "High call volume: $ACTIVE_CALLS active calls" fi # Alertas de qualidade if (( $(echo "$RTP_JITTER > 50" | bc -l) )); then send_alert "warning" "High RTP jitter detected: ${RTP_JITTER}ms" fi if [ "$RTP_PACKETS_LOST" -gt 100 ]; then send_alert "warning" "RTP packet loss detected: $RTP_PACKETS_LOST packets" fi # Verificar tendências (últimas 5 medições) RECENT_CPU=$(tail -5 /var/log/asterisk/metrics/metrics.csv | awk -F',' '{sum+=$3; count++} END {print sum/count}') if (( $(echo "$RECENT_CPU > 70" | bc -l) )); then send_alert "info" "CPU usage trending high: average ${RECENT_CPU}% over last 5 measurements" fi
3. Configurar dashboard de monitoramento:
   # Script para gerar dashboard HTML sudo nano /usr/local/bin/generate-dashboard.sh #!/bin/bash # Gerador de dashboard HTML DASHBOARD_FILE="/var/www/html/asterisk-dashboard.html" METRICS_FILE="/var/log/asterisk/metrics/current-metrics.json" # Criar diretório se não existir sudo mkdir -p /var/www/html # Gerar HTML cat > $DASHBOARD_FILE << 'EOF'

   Asterisk Monitoring Dashboard

   Last Update:

   EOF # Copiar métricas para servir via web sudo cp $METRICS_FILE /var/www/html/asterisk-metrics.json echo "Dashboard gerado em: $DASHBOARD_FILE"

Exemplo 4: Testes de Carga e Performance

1. Configurar ambiente de teste de carga:
   # Script de teste de carga sudo nano /usr/local/bin/load-test.sh #!/bin/bash # Teste de carga do Asterisk CONCURRENT_CALLS=${1:-10} CALL_DURATION=${2:-30} TEST_EXTENSION="*43" # Echo test echo "=== TESTE DE CARGA ASTERISK ===" echo "Chamadas simultâneas: $CONCURRENT_CALLS" echo "Duração por chamada: $CALL_DURATION segundos" echo "Iniciando em 5 segundos..." sleep 5 # Criar arquivo de log para o teste TEST_LOG="/var/log/asterisk/load-test-$(date +%Y%m%d-%H%M%S).log" echo "Log do teste: $TEST_LOG" # Função para iniciar uma chamada start_call() { local call_id=$1 local start_time=$(date +%s) echo "[$call_id] Iniciando chamada..." >> $TEST_LOG # Originar chamada asterisk -rx "originate Local/100@interno extension $TEST_EXTENSION@interno" >> $TEST_LOG 2>&1 & local pid=$! # Aguardar duração da chamada sleep $CALL_DURATION # Finalizar chamada asterisk -rx "soft hangup Local/100@interno-*" >> $TEST_LOG 2>&1 local end_time=$(date +%s) local duration=$((end_time - start_time)) echo "[$call_id] Chamada finalizada após $duration segundos" >> $TEST_LOG } # Iniciar chamadas simultâneas echo "Iniciando $CONCURRENT_CALLS chamadas simultâneas..." for i in $(seq 1 $CONCURRENT_CALLS); do start_call $i & sleep 0.5 # Pequeno delay entre chamadas done # Monitorar durante o teste echo "Monitorando sistema durante o teste..." for i in $(seq 1 $CALL_DURATION); do ACTIVE_CALLS=$(asterisk -rx "core show channels" | grep "active call" | awk '{print $1}') CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1) MEM_USAGE=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100.0}') echo "[$i/$CALL_DURATION] Calls: $ACTIVE_CALLS, CPU: $CPU_USAGE%, MEM: $MEM_USAGE%" | tee -a $TEST_LOG sleep 1 done # Aguardar finalização de todas as chamadas wait echo "=== TESTE CONCLUÍDO ===" echo "Verifique o log: $TEST_LOG" # Gerar relatório echo "=== RELATÓRIO DO TESTE ===" >> $TEST_LOG echo "Chamadas configuradas: $CONCURRENT_CALLS" >> $TEST_LOG echo "Duração configurada: $CALL_DURATION segundos" >> $TEST_LOG echo "Pico de CPU: $(grep "CPU:" $TEST_LOG | awk -F'CPU: ' '{print $2}' | awk -F'%' '{print $1}' | sort -n | tail -1)%" >> $TEST_LOG echo "Pico de Memória: $(grep "MEM:" $TEST_LOG | awk -F'MEM: ' '{print $2}' | awk -F'%' '{print $1}' | sort -n | tail -1)%" >> $TEST_LOG
2. Implementar teste de stress com SIPp:
   # Instalar SIPp para testes avançados sudo dnf install -y epel-release sudo dnf install -y sipp # Script de teste com SIPp sudo nano /usr/local/bin/sipp-stress-test.sh #!/bin/bash # Teste de stress com SIPp ASTERISK_IP="127.0.0.1" CALLS_PER_SECOND=${1:-1} MAX_CONCURRENT=${2:-10} DURATION=${3:-60} echo "=== TESTE DE STRESS COM SIPP ===" echo "Servidor: $ASTERISK_IP" echo "Chamadas/segundo: $CALLS_PER_SECOND" echo "Máximo simultâneo: $MAX_CONCURRENT" echo "Duração: $DURATION segundos" # Criar cenário SIPp básico cat > /tmp/uac_scenario.xml << 'EOF' ;tag=[pid]SIPpTag00[call_number] To: 100 Call-ID: [call_id] CSeq: 1 INVITE Contact: sip:sipp@[local_ip]:[local_port] Max-Forwards: 70 Subject: Performance Test Content-Type: application/sdp Content-Length: [len] v=0 o=user1 53655765 2353687637 IN IP[local_ip_type] [local_ip] s=- c=IN IP[local_ip_type] [local_ip] t=0 0 m=audio [auto_media_port] RTP/AVP 0 a=rtpmap:0 PCMU/8000 ]]> ;tag=[pid]SIPpTag00[call_number] To: 100 [peer_tag_param] Call-ID: [call_id] CSeq: 1 ACK Contact: sip:sipp@[local_ip]:[local_port] Max-Forwards: 70 Subject: Performance Test Content-Length: 0 ]]> ;tag=[pid]SIPpTag00[call_number] To: 100 [peer_tag_param] Call-ID: [call_id] CSeq: 2 BYE Contact: sip:sipp@[local_ip]:[local_port] Max-Forwards: 70 Subject: Performance Test Content-Length: 0 ]]> EOF # Executar teste SIPp echo "Iniciando teste SIPp..." sipp -sf /tmp/uac_scenario.xml \ -i $ASTERISK_IP \ -p 5061 \ -r $CALLS_PER_SECOND \ -l $MAX_CONCURRENT \ -d $DURATION \ -trace_msg \ -trace_stat \ $ASTERISK_IP:5060 echo "Teste SIPp concluído!" echo "Verifique os arquivos de trace gerados."

Cenário: Configurar proteção completa para servidor Asterisk em produção

1. Configurar firewall avançado com rate limiting:

   #!/bin/bash
   # advanced-firewall-setup.sh
   echo "Configurando firewall avançado para Asterisk..."
   
   # Limpar regras existentes
   iptables -F
   iptables -X
   
   # Políticas padrão
   iptables -P INPUT DROP
   iptables -P FORWARD DROP
   iptables -P OUTPUT ACCEPT
   
   # Permitir loopback
   iptables -A INPUT -i lo -j ACCEPT
   
   # Permitir conexões estabelecidas
   iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
   
   # SSH com rate limiting
   iptables -A INPUT -p tcp --dport 22 -m state --state NEW -m recent --set --name SSH_ATTEMPTS
   iptables -A INPUT -p tcp --dport 22 -m recent --update --seconds 60 --hitcount 4 --name SSH_ATTEMPTS -j DROP
   iptables -A INPUT -p tcp --dport 22 -j ACCEPT
   
   # SIP com proteção contra scanning
   iptables -A INPUT -p udp --dport 5060 -m string --string "friendly-scanner" --algo bm -j DROP
   iptables -A INPUT -p udp --dport 5060 -m string --string "sipcli" --algo bm -j DROP
   iptables -A INPUT -p udp --dport 5060 -m recent --set --name SIP_ATTEMPTS
   iptables -A INPUT -p udp --dport 5060 -m recent --update --seconds 60 --hitcount 10 --name SIP_ATTEMPTS -j DROP
   iptables -A INPUT -p udp --dport 5060:5061 -j ACCEPT
   
   # RTP range
   iptables -A INPUT -p udp --dport 10000:20000 -j ACCEPT
   
   # Salvar regras
   iptables-save > /etc/iptables/rules.v4
   echo "Firewall configurado com sucesso!"

2. Configurar Fail2ban personalizado:

   # /etc/fail2ban/filter.d/asterisk-security.conf
   [Definition]
   failregex = SECURITY.* .*: failed to authenticate as '.*'@.*
               SECURITY.* .*: Registration from '.*' failed for '.*' - Wrong password
               SECURITY.* .*: Host .* failed to authenticate as .*
               SECURITY.* .*: No matching peer found
   ignoreregex =
   
   # /etc/fail2ban/jail.d/asterisk-custom.conf
   [asterisk-security]
   enabled = true
   filter = asterisk-security
   action = iptables-allports[name=ASTERISK-SEC]
            sendmail-whois[name=ASTERISK, dest=admin@empresa.com]
   logpath = /var/log/asterisk/security
   maxretry = 3
   bantime = 7200
   findtime = 600

3. Implementar autenticação forte:

   # Configuração de extensão segura em pjsip.conf
   [1001]
   type=endpoint
   context=internal
   disallow=all
   allow=alaw,ulaw,g722
   auth=1001
   aors=1001
   direct_media=no
   ice_support=yes
   media_encryption=sdes
   rtp_symmetric=yes
   
   [1001]
   type=auth
   auth_type=userpass
   password=Str0ng!P@ssw0rd#2024
   username=1001
   
   [1001]
   type=aor
   max_contacts=2
   qualify_frequency=30
   remove_existing=yes

4. Configurar TLS/SRTP:

   # Gerar certificados SSL
   openssl req -new -x509 -days 365 -nodes -out /etc/asterisk/keys/asterisk.pem -keyout /etc/asterisk/keys/asterisk.key
   
   # Configuração TLS em pjsip.conf
   [transport-tls]
   type=transport
   protocol=tls
   bind=0.0.0.0:5061
   cert_file=/etc/asterisk/keys/asterisk.pem
   priv_key_file=/etc/asterisk/keys/asterisk.key
   method=tlsv1_2

Cenário: Implementar monitoramento proativo com alertas automáticos

1. Script de coleta de métricas avançadas:

   #!/bin/bash
   # advanced-metrics-collector.sh
   TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
   METRICS_DIR="/var/log/asterisk/metrics"
   mkdir -p $METRICS_DIR
   
   # Métricas de sistema
   CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
   MEM_USAGE=$(free | grep Mem | awk '{printf "%.2f", $3/$2 * 100.0}')
   DISK_USAGE=$(df -h / | awk 'NR==2{print $5}' | cut -d'%' -f1)
   LOAD_AVG=$(uptime | awk -F'load average:' '{print $2}' | cut -d',' -f1 | xargs)
   
   # Métricas do Asterisk
   ACTIVE_CALLS=$(asterisk -rx "core show calls" | grep "active call" | awk '{print $1}')
   SIP_PEERS=$(asterisk -rx "pjsip show endpoints" | grep -c "Endpoint:")
   REGISTERED_PEERS=$(asterisk -rx "pjsip show endpoints" | grep -c "Available")
   UPTIME=$(asterisk -rx "core show uptime" | grep "System uptime" | awk '{print $3,$4}')
   
   # Métricas de qualidade RTP
   RTP_STATS=$(asterisk -rx "rtp show stats" 2>/dev/null || echo "0 0 0")
   PACKET_LOSS=$(echo $RTP_STATS | awk '{print $1}')
   JITTER=$(echo $RTP_STATS | awk '{print $2}')
   
   # Salvar em CSV
   echo "$TIMESTAMP,$CPU_USAGE,$MEM_USAGE,$DISK_USAGE,$LOAD_AVG,$ACTIVE_CALLS,$SIP_PEERS,$REGISTERED_PEERS,$PACKET_LOSS,$JITTER" >> $METRICS_DIR/system_metrics.csv
   
   # Salvar em JSON para APIs
   cat > $METRICS_DIR/current_metrics.json << EOF
   {
     "timestamp": "$TIMESTAMP",
     "system": {
       "cpu_usage": $CPU_USAGE,
       "memory_usage": $MEM_USAGE,
       "disk_usage": $DISK_USAGE,
       "load_average": $LOAD_AVG
     },
     "asterisk": {
       "active_calls": ${ACTIVE_CALLS:-0},
       "sip_peers": ${SIP_PEERS:-0},
       "registered_peers": ${REGISTERED_PEERS:-0},
       "uptime": "$UPTIME"
     },
     "rtp_quality": {
       "packet_loss": ${PACKET_LOSS:-0},
       "jitter": ${JITTER:-0}
     }
   }
   EOF
   
   echo "Métricas coletadas: $TIMESTAMP"

2. Sistema de alertas inteligentes:

   #!/bin/bash
   # intelligent-alerts.sh
   source /etc/asterisk/scripts/config.conf
   
   # Thresholds configuráveis
   CPU_THRESHOLD=${CPU_THRESHOLD:-80}
   MEM_THRESHOLD=${MEM_THRESHOLD:-85}
   DISK_THRESHOLD=${DISK_THRESHOLD:-90}
   CALLS_THRESHOLD=${CALLS_THRESHOLD:-100}
   PEERS_DOWN_THRESHOLD=${PEERS_DOWN_THRESHOLD:-5}
   
   # Função para enviar alertas
   send_alert() {
       local severity=$1
       local message=$2
       local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
       
       # Log local
       echo "[$timestamp] $severity: $message" >> /var/log/asterisk/alerts.log
       
       # Email (se configurado)
       if [[ -n "$ALERT_EMAIL" ]]; then
           echo "$message" | mail -s "Asterisk Alert [$severity]" $ALERT_EMAIL
       fi
       
       # Webhook (se configurado)
       if [[ -n "$WEBHOOK_URL" ]]; then
           curl -X POST -H "Content-Type: application/json" \
                -d "{\"severity\":\"$severity\",\"message\":\"$message\",\"timestamp\":\"$timestamp\"}" \
                $WEBHOOK_URL
       fi
   }
   
   # Verificar métricas atuais
   CURRENT_METRICS="/var/log/asterisk/metrics/current_metrics.json"
   if [[ -f $CURRENT_METRICS ]]; then
       CPU_USAGE=$(jq -r '.system.cpu_usage' $CURRENT_METRICS)
       MEM_USAGE=$(jq -r '.system.memory_usage' $CURRENT_METRICS)
       DISK_USAGE=$(jq -r '.system.disk_usage' $CURRENT_METRICS)
       ACTIVE_CALLS=$(jq -r '.asterisk.active_calls' $CURRENT_METRICS)
       REGISTERED_PEERS=$(jq -r '.asterisk.registered_peers' $CURRENT_METRICS)
       SIP_PEERS=$(jq -r '.asterisk.sip_peers' $CURRENT_METRICS)
       
       # Verificar alertas
       if (( $(echo "$CPU_USAGE > $CPU_THRESHOLD" | bc -l) )); then
           send_alert "CRITICAL" "CPU usage is ${CPU_USAGE}% (threshold: ${CPU_THRESHOLD}%)"
       fi
       
       if (( $(echo "$MEM_USAGE > $MEM_THRESHOLD" | bc -l) )); then
           send_alert "CRITICAL" "Memory usage is ${MEM_USAGE}% (threshold: ${MEM_THRESHOLD}%)"
       fi
       
       if (( DISK_USAGE > DISK_THRESHOLD )); then
           send_alert "CRITICAL" "Disk usage is ${DISK_USAGE}% (threshold: ${DISK_THRESHOLD}%)"
       fi
       
       if (( ACTIVE_CALLS > CALLS_THRESHOLD )); then
           send_alert "WARNING" "High call volume: ${ACTIVE_CALLS} active calls (threshold: ${CALLS_THRESHOLD})"
       fi
       
       PEERS_DOWN=$((SIP_PEERS - REGISTERED_PEERS))
       if (( PEERS_DOWN > PEERS_DOWN_THRESHOLD )); then
           send_alert "WARNING" "${PEERS_DOWN} SIP peers are down (threshold: ${PEERS_DOWN_THRESHOLD})"
       fi
   fi

3. Dashboard HTML dinâmico:

   #!/bin/bash
   # generate-dashboard.sh
   DASHBOARD_FILE="/var/www/html/asterisk-dashboard.html"
   METRICS_FILE="/var/log/asterisk/metrics/current_metrics.json"
   
   if [[ -f $METRICS_FILE ]]; then
       # Extrair dados do JSON
       TIMESTAMP=$(jq -r '.timestamp' $METRICS_FILE)
       CPU_USAGE=$(jq -r '.system.cpu_usage' $METRICS_FILE)
       MEM_USAGE=$(jq -r '.system.memory_usage' $METRICS_FILE)
       DISK_USAGE=$(jq -r '.system.disk_usage' $METRICS_FILE)
       ACTIVE_CALLS=$(jq -r '.asterisk.active_calls' $METRICS_FILE)
       REGISTERED_PEERS=$(jq -r '.asterisk.registered_peers' $METRICS_FILE)
       
       # Gerar HTML
       cat > $DASHBOARD_FILE << EOF
   
   
   
       
       
       
   
   
       
   Asterisk System Dashboard
       
   Last Update: $TIMESTAMP
       
       
   
           
   CPU Usage
           
   ${CPU_USAGE}%
       
       
       
   
           
   Memory Usage
           
   ${MEM_USAGE}%
       
       
       
   
           
   Disk Usage
           
   ${DISK_USAGE}%
       
       
       
   
           
   Active Calls
           
   $ACTIVE_CALLS
       
       
       
   
           
   Registered Peers
           
   $REGISTERED_PEERS
       
   
   
   EOF
       
       echo "Dashboard atualizado: $DASHBOARD_FILE"
   fi

Cenário: Otimizar sistema para suportar 500+ chamadas simultâneas

1. Script de otimização automática:

   #!/bin/bash
   # performance-optimization.sh
   echo "Iniciando otimização de performance para Asterisk..."
   
   # Backup das configurações atuais
   cp /etc/sysctl.conf /etc/sysctl.conf.backup
   cp /etc/security/limits.conf /etc/security/limits.conf.backup
   
   # Otimizações de kernel
   cat >> /etc/sysctl.conf << 'EOF'
   # === Asterisk Performance Optimizations ===
   
   # Network buffer sizes
   net.core.rmem_default = 262144
   net.core.rmem_max = 16777216
   net.core.wmem_default = 262144
   net.core.wmem_max = 16777216
   net.core.netdev_max_backlog = 5000
   net.core.netdev_budget = 600
   
   # UDP optimizations
   net.ipv4.udp_mem = 102400 873800 16777216
   net.ipv4.udp_rmem_min = 8192
   net.ipv4.udp_wmem_min = 8192
   
   # TCP optimizations
   net.ipv4.tcp_rmem = 4096 87380 16777216
   net.ipv4.tcp_wmem = 4096 65536 16777216
   net.ipv4.tcp_congestion_control = bbr
   
   # Connection tracking
   net.netfilter.nf_conntrack_max = 1048576
   net.netfilter.nf_conntrack_tcp_timeout_established = 7200
   
   # File system
   fs.file-max = 2097152
   fs.nr_open = 2097152
   
   # Virtual memory
   vm.swappiness = 10
   vm.dirty_ratio = 15
   vm.dirty_background_ratio = 5
   
   # Process scheduling
   kernel.sched_migration_cost_ns = 5000000
   kernel.sched_autogroup_enabled = 0
   EOF
   
   # Aplicar otimizações
   sysctl -p
   
   # Limites de processo para Asterisk
   cat >> /etc/security/limits.conf << 'EOF'
   # Asterisk limits
   asterisk soft nofile 65536
   asterisk hard nofile 65536
   asterisk soft nproc 32768
   asterisk hard nproc 32768
   asterisk soft memlock unlimited
   asterisk hard memlock unlimited
   EOF
   
   # Configuração de CPU affinity
   echo "Configurando CPU affinity para Asterisk..."
   ASTERISK_PID=$(pgrep asterisk)
   if [[ -n $ASTERISK_PID ]]; then
       taskset -cp 1-3 $ASTERISK_PID
       echo "CPU affinity configurada para CPUs 1-3"
   fi
   
   # Otimizações específicas do Asterisk
   cat > /etc/asterisk/asterisk.conf << 'EOF'
   [options]
   verbose = 3
   debug = 1
   maxcalls = 1000
   maxload = 0.9
   runuser = asterisk
   rungroup = asterisk
   cache_record_files = yes
   record_cache_dir = /tmp
   transmit_silence = yes
   silence_threshold = 128
   maxfiles = 65536
   
   [compat]
   pbx_realtime=1.6
   res_agi=1.6
   app_set=1.6
   EOF
   
   echo "Otimização concluída! Reinicie o sistema para aplicar todas as mudanças."

2. Teste de carga automatizado:

   #!/bin/bash
   # load-test-advanced.sh
   CONCURRENT_CALLS=${1:-100}
   TEST_DURATION=${2:-300}
   RESULTS_DIR="/var/log/asterisk/load-tests"
   mkdir -p $RESULTS_DIR
   
   echo "Iniciando teste de carga: $CONCURRENT_CALLS chamadas por ${TEST_DURATION}s"
   
   # Função para monitorar recursos
   monitor_resources() {
       local test_id=$1
       local output_file="$RESULTS_DIR/resources_${test_id}.csv"
       
       echo "timestamp,cpu_usage,memory_usage,active_calls,rtp_packets" > $output_file
       
       while [[ -f "/tmp/load_test_running" ]]; do
           timestamp=$(date '+%Y-%m-%d %H:%M:%S')
           cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
           memory_usage=$(free | grep Mem | awk '{printf "%.2f", $3/$2 * 100.0}')
           active_calls=$(asterisk -rx "core show calls" | grep "active call" | awk '{print $1}')
           rtp_packets=$(netstat -su | grep "packets received" | awk '{print $1}')
           
           echo "$timestamp,$cpu_usage,$memory_usage,$active_calls,$rtp_packets" >> $output_file
           sleep 5
       done
   }
   
   # Iniciar monitoramento em background
   TEST_ID=$(date +%Y%m%d_%H%M%S)
   touch /tmp/load_test_running
   monitor_resources $TEST_ID &
   MONITOR_PID=$!
   
   # Executar teste com SIPp
   sipp -sn uac -d 30000 -s 1001 -r $CONCURRENT_CALLS -m $((CONCURRENT_CALLS * 10)) \
        -trace_msg -trace_stat -stf $RESULTS_DIR/sipp_stats_${TEST_ID}.csv \
        127.0.0.1:5060 &
   SIPP_PID=$!
   
   # Aguardar conclusão do teste
   sleep $TEST_DURATION
   
   # Finalizar processos
   kill $SIPP_PID 2>/dev/null
   rm -f /tmp/load_test_running
   kill $MONITOR_PID 2>/dev/null
   
   # Gerar relatório
   cat > $RESULTS_DIR/report_${TEST_ID}.html << EOF
   
   
   
   
       
   Load Test Report
       
   Test ID: $TEST_ID
       
   Concurrent Calls: $CONCURRENT_CALLS
       
   Duration: ${TEST_DURATION}s
       
   Results: Check CSV files for detailed metrics
   
   
   EOF
   
   echo "Teste concluído! Resultados em: $RESULTS_DIR"

Cenário: Implementar backup completo e procedimentos de recuperação

1. Sistema de backup inteligente:

   #!/bin/bash
   # enterprise-backup.sh
   BACKUP_BASE="/backup/asterisk"
   RETENTION_DAYS=30
   REMOTE_BACKUP="user@backup-server:/backups/asterisk"
   NOTIFICATION_EMAIL="admin@empresa.com"
   
   # Criar estrutura de backup
   mkdir -p $BACKUP_BASE/{daily,weekly,monthly}
   TIMESTAMP=$(date +%Y%m%d_%H%M%S)
   BACKUP_DIR="$BACKUP_BASE/daily/backup_$TIMESTAMP"
   mkdir -p $BACKUP_DIR
   
   echo "Iniciando backup completo do Asterisk - $TIMESTAMP"
   
   # Função para log
   log_message() {
       echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $BACKUP_DIR/backup.log
   }
   
   # Backup de configurações
   log_message "Fazendo backup das configurações..."
   tar -czf $BACKUP_DIR/configs.tar.gz /etc/asterisk/ 2>/dev/null
   if [[ $? -eq 0 ]]; then
       log_message "✓ Configurações salvas"
   else
       log_message "✗ Erro no backup de configurações"
   fi
   
   # Backup de dados do sistema
   log_message "Fazendo backup dos dados do sistema..."
   tar -czf $BACKUP_DIR/system_data.tar.gz \
       /var/lib/asterisk/ \
       /var/spool/asterisk/ \
       /var/log/asterisk/ 2>/dev/null
   
   # Backup do banco de dados (se usando)
   if command -v mysql &> /dev/null; then
       log_message "Fazendo backup do banco de dados MySQL..."
       mysqldump --all-databases --single-transaction --routines --triggers > $BACKUP_DIR/mysql_dump.sql
   fi
   
   # Backup de certificados e chaves
   log_message "Fazendo backup de certificados..."
   if [[ -d /etc/asterisk/keys ]]; then
       tar -czf $BACKUP_DIR/certificates.tar.gz /etc/asterisk/keys/
   fi
   
   # Informações do sistema
   log_message "Coletando informações do sistema..."
   cat > $BACKUP_DIR/system_info.txt << EOF
   Backup Date: $(date)
   Hostname: $(hostname)
   OS Version: $(cat /etc/os-release | grep PRETTY_NAME)
   Asterisk Version: $(asterisk -V)
   Kernel Version: $(uname -r)
   Uptime: $(uptime)
   Disk Usage: $(df -h)
   Memory Info: $(free -h)
   Network Interfaces: $(ip addr show)
   EOF
   
   # Verificar integridade dos backups
   log_message "Verificando integridade dos backups..."
   cd $BACKUP_DIR
   for file in *.tar.gz; do
       if tar -tzf "$file" >/dev/null 2>&1; then
           log_message "✓ $file - OK"
       else
           log_message "✗ $file - CORRUPTED"
       fi
   done
   
   # Calcular checksums
   find $BACKUP_DIR -type f -exec sha256sum {} \; > $BACKUP_DIR/checksums.sha256
   
   # Sincronizar com backup remoto
   if [[ -n "$REMOTE_BACKUP" ]]; then
       log_message "Sincronizando com backup remoto..."
       rsync -avz --progress $BACKUP_DIR/ $REMOTE_BACKUP/backup_$TIMESTAMP/
       if [[ $? -eq 0 ]]; then
           log_message "✓ Backup remoto concluído"
       else
           log_message "✗ Erro no backup remoto"
       fi
   fi
   
   # Limpeza de backups antigos
   log_message "Limpando backups antigos (>$RETENTION_DAYS dias)..."
   find $BACKUP_BASE/daily -type d -name "backup_*" -mtime +$RETENTION_DAYS -exec rm -rf {} \;
   
   # Relatório final
   BACKUP_SIZE=$(du -sh $BACKUP_DIR | cut -f1)
   log_message "Backup concluído! Tamanho: $BACKUP_SIZE"
   
   # Enviar notificação
   if [[ -n "$NOTIFICATION_EMAIL" ]]; then
       mail -s "Asterisk Backup Completed - $TIMESTAMP" $NOTIFICATION_EMAIL < $BACKUP_DIR/backup.log
   fi

2. Script de recuperação automatizada:

   #!/bin/bash
   # disaster-recovery.sh
   BACKUP_DIR=${1:-"/backup/asterisk/daily"}
   RECOVERY_MODE=${2:-"full"}  # full, config-only, data-only
   
   if [[ ! -d "$BACKUP_DIR" ]]; then
       echo "Erro: Diretório de backup não encontrado: $BACKUP_DIR"
       exit 1
   fi
   
   echo "=== ASTERISK DISASTER RECOVERY ==="
   echo "Backup Source: $BACKUP_DIR"
   echo "Recovery Mode: $RECOVERY_MODE"
   echo "=================================="
   
   # Função de confirmação
   confirm_action() {
       read -p "Esta operação irá sobrescrever dados existentes. Continuar? (yes/no): " confirm
       if [[ $confirm != "yes" ]]; then
           echo "Operação cancelada."
           exit 0
       fi
   }
   
   # Parar serviços
   echo "Parando serviços do Asterisk..."
   systemctl stop asterisk
   systemctl stop fail2ban
   
   # Backup dos dados atuais (segurança)
   CURRENT_BACKUP="/tmp/current_asterisk_$(date +%Y%m%d_%H%M%S)"
   mkdir -p $CURRENT_BACKUP
   echo "Fazendo backup dos dados atuais em: $CURRENT_BACKUP"
   cp -r /etc/asterisk $CURRENT_BACKUP/
   cp -r /var/lib/asterisk $CURRENT_BACKUP/
   
   confirm_action
   
   # Recuperação baseada no modo
   case $RECOVERY_MODE in
       "full")
           echo "Executando recuperação completa..."
           
           # Restaurar configurações
           if [[ -f "$BACKUP_DIR/configs.tar.gz" ]]; then
               echo "Restaurando configurações..."
               tar -xzf $BACKUP_DIR/configs.tar.gz -C /
           fi
           
           # Restaurar dados do sistema
           if [[ -f "$BACKUP_DIR/system_data.tar.gz" ]]; then
               echo "Restaurando dados do sistema..."
               tar -xzf $BACKUP_DIR/system_data.tar.gz -C /
           fi
           
           # Restaurar certificados
           if [[ -f "$BACKUP_DIR/certificates.tar.gz" ]]; then
               echo "Restaurando certificados..."
               tar -xzf $BACKUP_DIR/certificates.tar.gz -C /
           fi
           
           # Restaurar banco de dados
           if [[ -f "$BACKUP_DIR/mysql_dump.sql" ]]; then
               echo "Restaurando banco de dados..."
               mysql < $BACKUP_DIR/mysql_dump.sql
           fi
           ;;
           
       "config-only")
           echo "Restaurando apenas configurações..."
           if [[ -f "$BACKUP_DIR/configs.tar.gz" ]]; then
               tar -xzf $BACKUP_DIR/configs.tar.gz -C /
           fi
           ;;
           
       "data-only")
           echo "Restaurando apenas dados..."
           if [[ -f "$BACKUP_DIR/system_data.tar.gz" ]]; then
               tar -xzf $BACKUP_DIR/system_data.tar.gz -C /
           fi
           ;;
   esac
   
   # Verificar integridade dos arquivos restaurados
   echo "Verificando integridade dos arquivos..."
   if [[ -f "$BACKUP_DIR/checksums.sha256" ]]; then
       cd /
       sha256sum -c $BACKUP_DIR/checksums.sha256 --quiet
       if [[ $? -eq 0 ]]; then
           echo "✓ Integridade verificada"
       else
           echo "⚠ Alguns arquivos podem estar corrompidos"
       fi
   fi
   
   # Ajustar permissões
   echo "Ajustando permissões..."
   chown -R asterisk:asterisk /etc/asterisk/
   chown -R asterisk:asterisk /var/lib/asterisk/
   chown -R asterisk:asterisk /var/spool/asterisk/
   chown -R asterisk:asterisk /var/log/asterisk/
   
   # Reiniciar serviços
   echo "Reiniciando serviços..."
   systemctl start asterisk
   systemctl start fail2ban
   
   # Verificar status
   sleep 5
   if systemctl is-active --quiet asterisk; then
       echo "✓ Asterisk iniciado com sucesso"
       asterisk -rx "core show version"
   else
       echo "✗ Erro ao iniciar Asterisk"
       echo "Logs de erro:"
       tail -20 /var/log/asterisk/messages
   fi
   
   echo "Recuperação concluída!"
   echo "Backup dos dados anteriores: $CURRENT_BACKUP"