# Solucao de Problemas

Este guia cobre problemas comuns e suas solucoes ao executar o STA Connector.

## Diagnostico Rapido

### Health Check

```bash
# Saude da API de Saida
curl http://localhost:8080/api/v1/health

# Saude da API Admin
curl -u admin:senha http://localhost:8081/admin/health

# Saude da aplicacao Phoenix
curl http://localhost:4000/api/health
```

### Ver Logs

```bash
# Docker
docker logs sta-connector -f

# Kubernetes
kubectl logs -f deployment/sta-connector -n sta-connector

# Binario
./sta-connector --config config.yaml 2>&1 | tee connector.log

# Phoenix (desenvolvimento)
mix phx.server

# Phoenix (producao com logs)
MIX_ENV=prod elixir --erl "-kernel logger_level info" -S mix phx.server
```

### Verificar Metricas

```bash
curl -u admin:senha http://localhost:8081/admin/metrics
```

---

## Problemas de Inicializacao

### Arquivo de Configuracao Nao Encontrado

**Sintoma:**
```
Error: config file not found: /app/configs/config.yaml
```

**Solucao:**
1. Verifique o caminho do arquivo de config:
   ```bash
   ls -la /app/configs/config.yaml
   ```
2. Verifique montagens de volume (Docker):
   ```yaml
   volumes:
     - ./config.yaml:/app/configs/config.yaml:ro
   ```
3. Verifique argumento de caminho da config:
   ```bash
   ./sta-connector --config /caminho/correto/config.yaml
   ```

### Configuracao Invalida

**Sintoma:**
```
Error: config validation failed: STA username cannot be empty
```

**Solucao:**
1. Verifique se as variaveis de ambiente estao definidas:
   ```bash
   echo $STA_USERNAME
   ```
2. Verifique se o arquivo `.env` foi carregado (Docker):
   ```bash
   docker-compose config
   ```
3. Verifique a sintaxe das variaveis na config:
   ```yaml
   sta:
     username: "${STA_USERNAME}"  # Deve usar aspas
   ```

### Conexao com Banco de Dados Falhou

**Sintoma:**
```
Error: failed to open database: unable to open database file
```

**Solucao:**
1. Certifique-se de que o diretorio de dados existe:
   ```bash
   mkdir -p ./data
   chmod 755 ./data
   ```
2. Verifique as permissoes do arquivo:
   ```bash
   ls -la ./data/state.db
   ```
3. Para Docker, verifique o volume:
   ```bash
   docker volume inspect deployments_connector-data
   ```

### Porta Ja em Uso

**Sintoma:**
```
Error: listen tcp :8080: bind: address already in use
```

**Solucao:**
1. Encontre o processo usando a porta:
   ```bash
   lsof -i :8080
   ```
2. Mate o processo ou use uma porta diferente:
   ```yaml
   outbound_api:
     port: 8082  # Porta diferente
   ```

### Porta 4000 em Uso (Phoenix)

**Sintoma:**
```
** (RuntimeError) could not start the transport: :eaddrinuse
```

**Solucao:**
1. Encontre o processo usando a porta 4000:
   ```bash
   lsof -i :4000
   ```
2. Mate o processo:
   ```bash
   kill -9 $(lsof -t -i:4000)
   ```
3. Ou configure uma porta diferente:
   ```elixir
   # config/dev.exs
   config :sta_connector, StaConnectorWeb.Endpoint,
     http: [port: 4001]
   ```
4. Ou via variavel de ambiente:
   ```bash
   PORT=4001 mix phx.server
   ```

### SECRET_KEY_BASE Nao Definido (Phoenix)

**Sintoma:**
```
** (ArgumentError) cannot access environment variable "SECRET_KEY_BASE" because it is not set
```

**Solucao:**
1. Gere uma chave secreta:
   ```bash
   mix phx.gen.secret
   ```
2. Exporte a variavel de ambiente:
   ```bash
   export SECRET_KEY_BASE="sua_chave_secreta_gerada_aqui"
   ```
3. Ou adicione ao arquivo `.env`:
   ```bash
   SECRET_KEY_BASE=sua_chave_secreta_gerada_aqui
   ```
4. Para producao, defina no sistema:
   ```bash
   # /etc/environment ou ~/.bashrc
   export SECRET_KEY_BASE="chave_de_producao_muito_longa_e_segura"
   ```

---

## Problemas de Banco de Dados (Ecto/PostgreSQL)

### Migracao Ecto Falhou

**Sintoma:**
```
** (Postgrex.Error) ERROR 42P01 (undefined_table) relation "table_name" does not exist
```

**Solucao:**
1. Execute as migracoes pendentes:
   ```bash
   mix ecto.migrate
   ```
2. Verifique o status das migracoes:
   ```bash
   mix ecto.migrations
   ```
3. Crie o banco de dados se nao existir:
   ```bash
   mix ecto.create
   ```
4. Para reset completo (desenvolvimento):
   ```bash
   mix ecto.reset  # CUIDADO: apaga todos os dados
   ```

### Conexao PostgreSQL Recusada

**Sintoma:**
```
** (DBConnection.ConnectionError) tcp connect (localhost:5432): connection refused
```

**Solucao:**
1. Verifique se o PostgreSQL esta rodando:
   ```bash
   # macOS
   brew services list | grep postgresql

   # Linux
   sudo systemctl status postgresql
   ```
2. Inicie o servico se necessario:
   ```bash
   # macOS
   brew services start postgresql

   # Linux
   sudo systemctl start postgresql
   ```
3. Verifique a configuracao em `config/dev.exs`:
   ```elixir
   config :sta_connector, StaConnector.Repo,
     username: "postgres",
     password: "postgres",
     hostname: "localhost",
     database: "sta_connector_dev",
     port: 5432
   ```

### Credenciais PostgreSQL Invalidas

**Sintoma:**
```
** (Postgrex.Error) FATAL 28P01 (invalid_password) password authentication failed
```

**Solucao:**
1. Verifique o usuario e senha no config:
   ```elixir
   # config/dev.exs
   config :sta_connector, StaConnector.Repo,
     username: "seu_usuario",
     password: "sua_senha"
   ```
2. Ou use variaveis de ambiente:
   ```bash
   export DATABASE_URL="ecto://usuario:senha@localhost/sta_connector_dev"
   ```
3. Crie o usuario no PostgreSQL se necessario:
   ```sql
   CREATE USER seu_usuario WITH PASSWORD 'sua_senha' CREATEDB;
   ```

### Migracao com Conflito de Schema

**Sintoma:**
```
** (Postgrex.Error) ERROR 42701 (duplicate_column) column "field" already exists
```

**Solucao:**
1. Verifique se a migracao ja foi aplicada:
   ```bash
   mix ecto.migrations
   ```
2. Rollback a migracao problematica:
   ```bash
   mix ecto.rollback --step 1
   ```
3. Corrija o arquivo de migracao e re-execute:
   ```bash
   mix ecto.migrate
   ```
4. Para forccar uma versao especifica:
   ```bash
   mix ecto.rollback --to 20260101000000
   ```

### Pool de Conexoes Esgotado

**Sintoma:**
```
** (DBConnection.ConnectionError) connection not available and request was dropped from queue
```

**Solucao:**
1. Aumente o pool size:
   ```elixir
   # config/prod.exs
   config :sta_connector, StaConnector.Repo,
     pool_size: 20  # Padrao e 10
   ```
2. Verifique queries lentas:
   ```elixir
   # Adicione ao Repo
   config :sta_connector, StaConnector.Repo,
     log: :debug
   ```
3. Otimize queries com muitas conexoes simultaneas

---

## Problemas de Conexao STA

### Autenticacao Falhou

**Sintoma:**
```
Error: STA authentication failed: invalid credentials
```

**Solucao:**
1. Verifique se as credenciais Sisbacen estao corretas
2. Verifique erros de digitacao no usuario/senha
3. Certifique-se de que caracteres especiais nao precisam de escape
4. Teste as credenciais diretamente com o BCB

### Timeout de Conexao

**Sintoma:**
```
Error: STA request timeout: context deadline exceeded
```

**Solucao:**
1. Verifique a conectividade de rede:
   ```bash
   curl -I https://sta-h.bcb.gov.br/staws
   ```
2. Verifique se o firewall permite HTTPS de saida
3. Aumente o timeout:
   ```yaml
   sta:
     timeout_seconds: 60
   ```
4. Verifique a pagina de status do BCB para indisponibilidades

### Erro de Certificado

**Sintoma:**
```
Error: x509: certificate signed by unknown authority
```

**Solucao:**
1. Certifique-se de que os certificados CA estao instalados:
   ```bash
   # Alpine
   apk add ca-certificates

   # Ubuntu
   apt-get install ca-certificates
   ```
2. Atualize os certificados CA:
   ```bash
   update-ca-certificates
   ```

### Rate Limited

**Sintoma:**
```
Error: STA rate limit exceeded (429)
```

**Solucao:**
1. Reduza a frequencia de polling:
   ```yaml
   poller:
     interval_seconds: 60  # Aumente de 30
     batch_size: 5         # Reduza de 10
   ```
2. Aguarde a janela de rate limit resetar (1 minuto)
3. Monitore o rate limit nas metricas:
   ```bash
   curl -u admin:senha http://localhost:8081/admin/metrics | jq '.sta_client.rate_limit_remaining'
   ```

---

## Problemas de Processamento de Arquivos

### Arquivos Nao Estao Sendo Descobertos

**Sintoma:** O poller executa mas nenhum arquivo e encontrado.

**Solucao:**
1. Verifique se o poller esta habilitado:
   ```yaml
   poller:
     enabled: true
   ```
2. Verifique se os IDs de sistema estao corretos:
   ```yaml
   poller:
     systems:
       - "CCS"
       - "SPI"  # Deve corresponder aos codigos BCB
   ```
3. Dispare um poll manual:
   ```bash
   curl -u admin:senha -X POST http://localhost:8081/admin/poller/trigger
   ```
4. Verifique a conectividade STA nos logs

### Download de Arquivo Falhou

**Sintoma:**
```
Error: failed to download file: protocol not found
```

**Solucao:**
1. Verifique se o numero de protocolo e valido
2. Verifique se o arquivo ja foi baixado (duplicata)
3. Revise a resposta STA nos logs de debug
4. Certifique-se de que a instituicao tem acesso ao arquivo

### Erro de Parsing de Arquivo

**Sintoma:**
```
Error: failed to parse file: unexpected format
```

**Solucao:**
1. Verifique se o tipo de arquivo corresponde ao formato esperado
2. Verifique se houve download corrompido
3. Revise a configuracao do parser para o sistema
4. Habilite o logging de debug para ver o conteudo bruto

### Entrega Falhou

**Sintoma:**
```
Error: failed to deliver file: connection refused
```

**Solucao:**
1. Verifique se a URL de destino esta correta:
   ```yaml
   routes:
     CCS:
       url: "https://staapi-planner.monetarie.com.br/api/v1/ccs"
   ```
2. Teste se o destino esta acessivel:
   ```bash
   curl -I https://staapi-planner.monetarie.com.br/api/v1/ccs
   ```
3. Verifique se o token de autenticacao e valido
4. Aumente o timeout se o destino for lento:
   ```yaml
   routes:
     CCS:
       timeout_seconds: 60
   ```

### Arquivo Preso em Retrying

**Sintoma:** Arquivo permanece no status `retrying` indefinidamente.

**Solucao:**
1. Verifique a contagem de retry na API Admin:
   ```bash
   curl -u admin:senha "http://localhost:8081/admin/files?status=retrying"
   ```
2. Revise a mensagem de erro para encontrar a causa raiz
3. Corrija o problema subjacente (rede, auth, etc.)
4. Retente manualmente ou pule o arquivo

---

## Problemas de WebSocket (Phoenix Channels)

### Conexao WebSocket Falhou

**Sintoma:**
```javascript
// No console do navegador
WebSocket connection to 'ws://localhost:4000/socket/websocket' failed
```

**Solucao:**
1. Verifique se o endpoint esta configurado:
   ```elixir
   # lib/sta_connector_web/endpoint.ex
   socket "/socket", StaConnectorWeb.UserSocket,
     websocket: true,
     longpoll: false
   ```
2. Verifique a configuracao CORS:
   ```elixir
   # config/config.exs
   config :sta_connector, StaConnectorWeb.Endpoint,
     check_origin: ["//localhost", "//seu-dominio.com"]
   ```
3. Para desenvolvimento, desabilite a verificacao de origem:
   ```elixir
   # config/dev.exs
   config :sta_connector, StaConnectorWeb.Endpoint,
     check_origin: false
   ```

### Canal Nao Encontrado

**Sintoma:**
```
[error] Could not join channel "room:lobby". Reason: :unmatched_topic
```

**Solucao:**
1. Verifique o mapeamento de canais no socket:
   ```elixir
   # lib/sta_connector_web/channels/user_socket.ex
   channel "room:*", StaConnectorWeb.RoomChannel
   ```
2. Verifique se o topico esta correto no cliente:
   ```javascript
   let channel = socket.channel("room:lobby", {})
   ```
3. Verifique a funcao `join/3` no canal:
   ```elixir
   def join("room:" <> _room_id, _payload, socket) do
     {:ok, socket}
   end
   ```

### Autorizacao de Canal Falhou

**Sintoma:**
```
[error] Could not join channel. Reason: :unauthorized
```

**Solucao:**
1. Verifique a logica de autorizacao no `join/3`:
   ```elixir
   def join("room:" <> room_id, payload, socket) do
     if authorized?(socket.assigns.user_id, room_id) do
       {:ok, socket}
     else
       {:error, %{reason: "unauthorized"}}
     end
   end
   ```
2. Verifique se o token esta sendo enviado corretamente:
   ```javascript
   let socket = new Socket("/socket", {params: {token: userToken}})
   ```
3. Verifique a verificacao de token no socket:
   ```elixir
   def connect(%{"token" => token}, socket, _connect_info) do
     case Phoenix.Token.verify(socket, "user auth", token, max_age: 86400) do
       {:ok, user_id} ->
         {:ok, assign(socket, :user_id, user_id)}
       {:error, _reason} ->
         :error
     end
   end
   ```

### Mensagens Nao Estao Sendo Recebidas

**Sintoma:** Broadcast funciona mas clientes nao recebem mensagens.

**Solucao:**
1. Verifique se o cliente esta inscrito no evento:
   ```javascript
   channel.on("new_msg", payload => {
     console.log("Received:", payload)
   })
   ```
2. Verifique se o broadcast esta correto:
   ```elixir
   broadcast!(socket, "new_msg", %{body: message})
   ```
3. Verifique se o PubSub esta configurado:
   ```elixir
   # config/config.exs
   config :sta_connector, StaConnectorWeb.Endpoint,
     pubsub_server: StaConnector.PubSub
   ```
4. Verifique se o PubSub esta iniciado na supervision tree:
   ```elixir
   # lib/sta_connector/application.ex
   children = [
     {Phoenix.PubSub, name: StaConnector.PubSub},
     # ...
   ]
   ```

### Conexao WebSocket Caindo

**Sintoma:** Conexao WebSocket desconecta frequentemente.

**Solucao:**
1. Configure o heartbeat no cliente:
   ```javascript
   let socket = new Socket("/socket", {
     heartbeatIntervalMs: 30000
   })
   ```
2. Aumente o timeout do socket:
   ```elixir
   # lib/sta_connector_web/endpoint.ex
   socket "/socket", StaConnectorWeb.UserSocket,
     websocket: [timeout: 45_000]
   ```
3. Verifique configuracoes de proxy/load balancer para WebSocket

---

## Depuracao (Elixir/Phoenix)

### Usando o Logger

**Configuracao basica:**
```elixir
# config/config.exs
config :logger, :console,
  format: "$time $metadata[$level] $message\n",
  metadata: [:request_id, :user_id]
```

**Niveis de log:**
```elixir
require Logger

Logger.debug("Mensagem de debug")
Logger.info("Informacao geral")
Logger.warning("Aviso importante")
Logger.error("Erro critico")
```

**Log com metadados:**
```elixir
Logger.info("Processando arquivo", file_id: file.id, system: file.system)
```

**Alterar nivel de log em runtime:**
```elixir
# No IEx
Logger.configure(level: :debug)
```

### Usando o Observer

**Iniciar o Observer:**
```elixir
# No IEx
:observer.start()
```

**O Observer mostra:**
- Uso de memoria por processo
- Filas de mensagens
- Estado da supervision tree
- Informacoes de ETS
- Graficos de CPU e memoria

**Conectar a um no remoto:**
```bash
# No servidor de producao
iex --name app@server --cookie secret -S mix

# Na sua maquina
iex --name debug@local --cookie secret
Node.connect(:"app@server")
:observer.start()
```

### Usando :sys.get_state/1

**Inspecionar estado de um GenServer:**
```elixir
# Por nome registrado
:sys.get_state(StaConnector.FileProcessor)

# Por PID
pid = Process.whereis(StaConnector.FileProcessor)
:sys.get_state(pid)
```

**Inspecionar estado de um processo de Agent:**
```elixir
:sys.get_state(StaConnector.ConfigAgent)
```

**Obter estatisticas do processo:**
```elixir
:sys.statistics(StaConnector.FileProcessor, true)  # Habilitar
# ... aguarde algum tempo ...
:sys.statistics(StaConnector.FileProcessor, :get)  # Obter stats
```

**Rastrear chamadas de funcao:**
```elixir
:sys.trace(StaConnector.FileProcessor, true)  # Habilitar trace
# Logs mostrarao todas as mensagens recebidas
:sys.trace(StaConnector.FileProcessor, false) # Desabilitar
```

### Depuracao com IEx.pry

**Adicionar breakpoint no codigo:**
```elixir
def process_file(file) do
  require IEx
  IEx.pry()  # Execucao pausa aqui

  # resto do codigo
end
```

**Executar com pry habilitado:**
```bash
iex -S mix phx.server
```

**Comandos no pry:**
- `respawn()` - continuar execucao
- `binding()` - ver variaveis locais
- `__ENV__` - ver ambiente atual

### Depuracao de Ecto Queries

**Habilitar log de queries:**
```elixir
# config/dev.exs
config :sta_connector, StaConnector.Repo,
  log: :debug
```

**Ver query SQL gerada:**
```elixir
import Ecto.Query

query = from f in File, where: f.status == "pending"
StaConnector.Repo.to_sql(:all, query)
# => {"SELECT f.* FROM files AS f WHERE f.status = $1", ["pending"]}
```

**Explain query:**
```elixir
StaConnector.Repo.explain(:all, query)
```

---

## Problemas de API

### 401 Nao Autorizado

**Sintoma:**
```json
{"error": "Unauthorized"}
```

**Solucao:**
1. Verifique a chave API para a API de Saida:
   ```bash
   curl -H "Authorization: Bearer ${API_KEY}" http://localhost:8080/api/v1/health
   ```
2. Verifique as credenciais para a API Admin:
   ```bash
   curl -u admin:senha http://localhost:8081/admin/health
   ```
3. Verifique a configuracao de auth:
   ```yaml
   outbound_api:
     auth:
       type: "api_key"
       api_key: "${OUTBOUND_API_KEY}"
   ```

### 400 Requisicao Invalida

**Sintoma:**
```json
{"error": "validation_error", "message": "..."}
```

**Solucao:**
1. Revise a mensagem de erro para o campo especifico
2. Verifique o formato do corpo da requisicao:
   ```bash
   curl -X POST http://localhost:8080/api/v1/files \
     -H "Content-Type: application/json" \
     -d '{"system": "CCS", ...}'
   ```
3. Valide a codificacao base64 do conteudo
4. Certifique-se de que os campos obrigatorios estao presentes

### 429 Muitas Requisicoes

**Sintoma:**
```json
{"error": "rate_limited", "retry_after": 30}
```

**Solucao:**
1. Implemente backoff no seu cliente
2. Reduza a frequencia de requisicoes
3. Aguarde `retry_after` segundos antes de retentar

### 502 Bad Gateway

**Sintoma:**
```json
{"error": "sta_error", "message": "..."}
```

**Solucao:**
1. Verifique o status da conexao STA
2. Revise a mensagem de erro do STA
3. Verifique se os sistemas BCB estao operacionais
4. Verifique a conectividade de rede

---

## Problemas de Desempenho

### Alto Uso de Memoria

**Sintoma:** Memoria do container continua crescendo.

**Solucao:**
1. Reduza o batch size:
   ```yaml
   poller:
     batch_size: 5
   ```
2. Verifique se ha memory leaks nos logs
3. Aumente o limite de memoria:
   ```yaml
   resources:
     limits:
       memory: 1Gi
   ```
4. Reinicie o container para limpar a memoria

### Alto Uso de CPU

**Sintoma:** CPU consistentemente em 100%.

**Solucao:**
1. Reduza a frequencia de polling:
   ```yaml
   poller:
     interval_seconds: 60
   ```
2. Verifique se ha goroutines travadas nos logs
3. Aumente o limite de CPU:
   ```yaml
   resources:
     limits:
       cpu: "2"
   ```

### Tempos de Resposta Lentos

**Sintoma:** Respostas da API levam varios segundos.

**Solucao:**
1. Verifique o desempenho do banco de dados
2. Verifique a latencia do STA:
   ```bash
   curl -u admin:senha http://localhost:8081/admin/metrics | jq '.sta_client.avg_latency_ms'
   ```
3. Reduza operacoes concorrentes
4. Use PostgreSQL em vez de SQLite para producao

### Profundidade da Fila Crescendo

**Sintoma:** Arquivos pendentes continuam aumentando.

**Solucao:**
1. Aumente o batch size se estiver abaixo do rate limit:
   ```yaml
   poller:
     batch_size: 20
   ```
2. Verifique se ha erros de processamento
3. Verifique se os endpoints de destino estao saudaveis
4. Escale replicas (com PostgreSQL)

---

## Problemas de Banco de Dados

### SQLite Bloqueado

**Sintoma:**
```
Error: database is locked
```

**Solucao:**
1. Execute apenas uma instancia do connector com SQLite
2. Mude para PostgreSQL para multiplas instancias:
   ```yaml
   state_store:
     type: "postgres"
   ```
3. Verifique se ha processos travados:
   ```bash
   lsof ./data/state.db
   ```

### Pool de Conexoes PostgreSQL Esgotado

**Sintoma:**
```
Error: too many connections
```

**Solucao:**
1. Aumente max connections no PostgreSQL
2. Reduza replicas do connector
3. Adicione um pooler de conexoes (PgBouncer)
4. Revise o uso de conexoes da aplicacao

### Migracao Falhou

**Sintoma:**
```
Error: failed to run migrations
```

**Solucao:**
1. Verifique as permissoes do banco de dados
2. Verifique se a string de conexao esta correta
3. Execute as migracoes manualmente se necessario
4. Verifique se ha conflitos de schema

---

## Problemas Docker

### Container Continua Reiniciando

**Sintoma:** Container reinicia repetidamente.

**Solucao:**
1. Verifique os logs para o erro:
   ```bash
   docker logs sta-connector
   ```
2. Verifique se a configuracao e valida
3. Verifique se o health check nao esta muito rigoroso:
   ```yaml
   healthcheck:
     start_period: 30s
   ```

### Permissao Negada em Volume

**Sintoma:**
```
Error: permission denied opening file
```

**Solucao:**
1. Corrija as permissoes do diretorio no host:
   ```bash
   sudo chown -R 1000:1000 ./data
   ```
2. Ou use volumes nomeados:
   ```yaml
   volumes:
     - connector-data:/app/data
   ```

### Problemas de Rede

**Sintoma:** Containers nao conseguem se comunicar.

**Solucao:**
1. Verifique se a rede existe:
   ```bash
   docker network ls
   ```
2. Verifique se os servicos estao na mesma rede
3. Use nomes de servico, nao localhost:
   ```yaml
   DB_HOST: postgres  # Nao localhost
   ```

---

## Problemas Kubernetes

### Pod CrashLoopBackOff

**Sintoma:** Pod continua crashando e reiniciando.

**Solucao:**
1. Verifique os logs:
   ```bash
   kubectl logs deployment/sta-connector -n sta-connector --previous
   ```
2. Descreva o pod para ver eventos:
   ```bash
   kubectl describe pod -l app=sta-connector -n sta-connector
   ```
3. Verifique se ConfigMap e Secrets existem
4. Verifique se os limites de recursos nao estao muito baixos

### Readiness Probe Falhando

**Sintoma:** Pod nunca fica pronto.

**Solucao:**
1. Teste o endpoint de saude:
   ```bash
   kubectl exec deployment/sta-connector -n sta-connector -- wget -qO- http://localhost:8080/api/v1/health
   ```
2. Aumente o delay inicial:
   ```yaml
   readinessProbe:
     initialDelaySeconds: 30
   ```
3. Verifique os logs da aplicacao para erros de inicializacao

### Servico Nao Acessivel

**Sintoma:** Nao consegue conectar ao servico.

**Solucao:**
1. Verifique se o servico existe:
   ```bash
   kubectl get svc -n sta-connector
   ```
2. Verifique os endpoints:
   ```bash
   kubectl get endpoints sta-connector -n sta-connector
   ```
3. Faca port forward para testar:
   ```bash
   kubectl port-forward svc/sta-connector 8080:8080 -n sta-connector
   ```

---

## Modo Debug

Habilite o logging de debug para mais informacoes:

```yaml
service:
  log_level: "debug"
```

Ou via API Admin:

```bash
curl -u admin:senha -X PATCH http://localhost:8081/admin/config \
  -H "Content-Type: application/json" \
  -d '{"service": {"log_level": "debug"}}'
```

Logs de debug incluem:
- Request/response STA completos
- Passos de processamento de arquivos
- Tentativas de retry
- Mudancas de configuracao

---

## Obtendo Ajuda

Se voce nao conseguir resolver um problema:

1. **Verifique issues existentes** no GitHub
2. **Pesquise a documentacao** para problemas similares
3. **Habilite logging de debug** e colete logs
4. **Abra uma nova issue** com:
   - Versao do connector
   - Configuracao (oculte secrets)
   - Mensagem de erro completa
   - Passos para reproduzir
   - Logs de debug

---

## Proximos Passos

- [Configuracao](/pt/guide/configuration) - Referencia de configuracao
- [API Admin](/pt/api/admin) - API para gerenciamento
- [Implantacao Kubernetes](/pt/deployment/kubernetes) - Configuracao Kubernetes