Preparando a aplicação | Integração Contínua: pipelines e testes automatizados com GitHub Actions

Ola Diego.
Tudo bem.
Vou tentar lhe ajudar com as informações que descreveu:

Você está usando a imagem golang:1.22 para rodar um servidor Go via go run main.go.
O diretório do projeto (presumivelmente com o código Go) é montado no contêiner em /app.
O PostgreSQL está funcionando normalmente (estado healthy).
O servidor deveria estar disponível em http://localhost:8080, mas nenhuma rota está sendo encontrada.
Logs indicam que o container inicia sem erros.
Vamos focar primeiro no problema principal: "o container roda, mas nenhuma rota HTTP é encontrada".
Verifique se no seu main.go o servidor realmente está escutando na porta 8080:
```
http.ListenAndServe(":8080", nil)
```
Ou se está usando algum roteador (como Gorilla Mux, Gin, etc.), certifique-se que ele está passando corretamente.
Se você estiver usando docker run, lembre-se de mapear a porta corretamente:
```
docker run -p 8080:8080 ...
```
Em um docker-compose.yml, isso deve estar incluído:
```
ports:
  - "8080:8080"
```
Se você estiver usando um framework como Gin, Echo, ou Mux, verifique se as rotas estão realmente registradas:
```
router := gin.Default()
router.GET("/ping", func(c *gin.Context) {
    c.JSON(200, gin.H{"message": "pong"})
})
router.Run(":8080")
```
Caso não registre nenhuma rota, ou se estiver com um router.Run() sem passar a porta correta, o servidor pode estar rodando mas sem nenhuma rota exposta.

Pode haver algum panic() silencioso ou erro ignorado no seu main.go. Tente rodar localmente com mais logs de debug:

err := http.ListenAndServe(":8080", nil)
if err != nil {
    log.Fatalf("Erro ao iniciar servidor: %v", err)
}

Tente acessar via:

curl http://localhost:8080

Se você estiver no host e o contêiner está isolado, pode precisar rodar:

curl http://localhost:8080 -v

Ou, se estiver rodando o container em outro lugar (ex: em um pipeline ou ambiente CI/CD), certifique-se de que há acesso de rede adequado.

No caso de Integração Contínua com GitHub Actions, aqui está como esse problema poderia impactar o pipeline:

Build da aplicação Go: go build
Execução de testes unitários: go test ./...
Testes de integração que checam se o servidor responde HTTP (falhando, talvez, porque o servidor não sobe corretamente ou não responde nas rotas esperadas)
Exemplo:

# .github/workflows/ci.yml
name: Go CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:13
        env:
          POSTGRES_USER: user
          POSTGRES_PASSWORD: pass
          POSTGRES_DB: db
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
    - uses: actions/checkout@v3

    - name: Set up Go
      uses: actions/setup-go@v4
      with:
        go-version: 1.22

    - name: Install dependencies
      run: go mod tidy

    - name: Run tests
      run: go test ./...

    - name: Build
      run: go build -v ./...

    - name: Start server and test endpoint
      run: |
        go run main.go &
        sleep 3
        curl -f http://localhost:8080 || (echo "Servidor não respondeu" && exit 1)

Este último passo (curl -f) garante que o servidor esteja respondendo e que as rotas estão funcionando.
Recapitulando:

Confirme se o servidor está escutando corretamente na porta 8080.
Verifique se há rotas realmente registradas no seu código.
Garanta que a porta 8080 esteja mapeada no contêiner.
Adicione logs para garantir que o servidor está inicializando corretamente.
No GitHub Actions, valide o endpoint HTTP com um curl.**
Teste ai e me envie os resultados.
Qualquer duvida pode perguntar.
Bons estudos.
Até...
:)

Garanta sua matrícula hoje e ganhe + 2 meses grátis