Hi community! I have forgotten my old Kong settings, and I cant get my WS to work thru Kong.

[Jensileus]

So I had WS work thru Kong before, but I dont remember the Kong settings. I use Kong Konnect. Now we have some problems, and the only change i have done is that my WS server is now running on localhost instead of public 0.0.0.0 so localhost is now 127.0.0.1 port 5004.  Under is my xcode settings for gateway and for router. I have also added my first page for the Go ws that worked before but the only change is the local 127.0.0.1 instead of nothing so it was public 0.0.0.0.
I have also added my nginx settings.I have cloudflare a record sat to my server.This worked before, but i guess somethings in my settings is off - but i cant really understand what it is? i have tried with postman.If i try direct to the localhost:5004 it works. So it runs and is connectable but i cant reach it thru Kong.I have turned on development settings i cloudflare - of course - and my other routes works. 

Here is the settings:

{
  "hosts": [
    "xx.xx.one"
  ],
  "https_redirect_status_code": 426,
  "id": "caa6bfb6-f8e9-4610-8a95-c5e16ae6eb1b",
  "name": "wsroute",
  "path_handling": "v0",
  "paths": [
    "/ws"
  ],
  "preserve_host": true,
  "protocols": [
    "wss"
  ],
  "regex_priority": 0,
  "request_buffering": false,
  "response_buffering": false,
  "service": {
    "id": "9d685fa0-a411-4629-b3d4-41f39cb1e4b7"
  },
  "snis": [
    "xx.xx.one"
  ],
  "strip_path": false
}

And the gateway

{
  "connect_timeout": 660000,
  "enabled": true,
  "host": "127.0.0.1",
  "id": "9d685fa0-a411-4629-b3d4-41f39cb1e4b7",
  "name": "wsgateway",
  "port": 5004,
  "protocol": "ws",
  "read_timeout": 660000,
  "retries": 5,
  "write_timeout": 660000

} and here is also my ws server "first page" with the connection part eg. //websocket server in Go for eventdriven system.

//Folder structure is xxxxx
//xxxxx
//xxxxx

package main

import (
"log"
"net/http"
"os"
"os/signal"
"strconv"
"sync"
"syscall"
"time"

"github.com/gorilla/websocket"
)

// WebSocket upgrader to upgrade HTTP to WebSocket
var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true // Allow connections from any origin
},
}

// Client struct to hold WebSocket connection and userId
type Client struct {
conn *websocket.Conn
userId int
mu sync.Mutex
}

// Global map to store connected clients by userId
var clients = make(map[int]*Client)
var mu sync.Mutex

// Log current active connections
func logActiveConnections() {
mu.Lock()
defer mu.Unlock()
log.Printf("Active connections: %d", len(clients))
for userId := range clients {
log.Printf("UserId: %d is connected", userId)
}
}

// Set connection timeouts and pong handler
func (client *Client) setConnectionTimeouts() {
client.conn.SetReadDeadline(time.Now().Add(60 * time.Second))
client.conn.SetPongHandler(func(appData string) error {
client.conn.SetReadDeadline(time.Now().Add(60 * time.Second)) // Reset deadline on pong
log.Printf("Pong received from user %d", client.userId)
return nil
})
}

// Handler for WebSocket connections
func handleConnections(w http.ResponseWriter, r *http.Request) {
log.Println("New WebSocket connection attempt")

// Extract userId from query parameters
userIdStr := r.URL.Query().Get("userId")
if userIdStr == "" {
log.Println("No userId provided in connection URL")
http.Error(w, "userId is required", http.StatusBadRequest)
return
}

// Convert userId to integer
userId, err := strconv.Atoi(userIdStr)
if err != nil {
log.Printf("Invalid userId provided: %s\n", userIdStr)
http.Error(w, "Invalid userId", http.StatusBadRequest)
return
}

// Upgrade the HTTP connection to a WebSocket
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println("Error upgrading connection:", err)
return
}
defer conn.Close()

log.Printf("WebSocket connection upgraded successfully for userId: %d\n", userId)

// Clean up previous connections for the same user
mu.Lock()
if client, exists := clients[userId]; exists {
log.Printf("User %d already connected, closing previous connection.\n", userId)
client.conn.Close() // Close old connection
delete(clients, userId)
}

client := &Client{
conn: conn,
userId: userId,
}
clients[userId] = client
mu.Unlock()

// Log active connections
logActiveConnections()

// Set connection timeouts and pong handler
client.setConnectionTimeouts()

// Start Ping-Pong mechanism after connection stabilization
go keepConnectionAlive(client)

// Handle disconnection
defer func() {
log.Printf("User disconnected: %d\n", userId)
mu.Lock()
delete(clients, userId)
mu.Unlock()
logActiveConnections()
}()

// Handle incoming messages from user
for {
_, msg, err := conn.ReadMessage()
if err != nil {
log.Printf("Error reading message from user %d: %v\n", userId, err)
break
}
log.Printf("Message from user %d: %s\n", userId, string(msg))
}
}

func keepConnectionAlive(client *Client) {
log.Printf("Waiting for connection to stabilize for user %d before pinging\n", client.userId)
time.Sleep(5 * time.Second) // Stabilization time

ticker := time.NewTicker(20 * time.Second) // Ping interval (20 seconds)
defer ticker.Stop()

for {
select {
case <-ticker.C:
client.mu.Lock()
log.Printf("Sending ping to user %d\n", client.userId)

// Send the ping message and handle potential error
err := client.conn.WriteMessage(websocket.PingMessage, nil)
if err != nil {
log.Printf("Error sending ping to user %d: %v\n", client.userId, err)
client.conn.Close() // Close the connection on error
client.mu.Unlock()
return
}
client.mu.Unlock()
}
}
}

// Main function to start WebSocket server and handle graceful shutdown
func main() {
http.HandleFunc("/ws", handleConnections)

// Start WebSocket server on port 5004
server := &http.Server{Addr: "127.0.0.1:5004"}

go func() {
log.Println("WebSocket server started on port 5004")
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf("ListenAndServe error: %v\n", err)
}
}()

// Graceful shutdown handling
gracefulShutdown(server)
}

// Handle graceful shutdown
func gracefulShutdown(server *http.Server) {
quit := make(chan os.Signal, 1)
signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
<-quit
log.Println("Shutting down server...")

// Attempt graceful shutdown
if err := server.Shutdown(nil); err != nil {
log.Fatalf("Server forced to shutdown: %v", err)
}
log.Println("Server exiting")
}

Here is my nginx settings

server {    listen 80;    listen [::]:80;    server_name xx.xx.one www.xx.xx.one;
    return 301 https://$host$request_uri;}
# HTTPS server block for xx.xx.oneserver {    listen 443 ssl;    listen [::]:443 ssl;    server_name xx.xx.one;        ssl_certificate /etc/nginx/cxxxxxx    ssl_certificate_key /etc/xxxxx


    ssl_session_cache shared:SSL:10m;    ssl_session_timeout 10m;    ssl_protocols TLSv1.2 TLSv1.3;    ssl_ciphers HIGH:!aNULL:!MD5;    ssl_prefer_server_ciphers on;
    location / {        proxy_pass https://127.0.0.1:8443;        proxy_set_header Host $host;        proxy_set_header X-Real-IP $remote_addr;        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;        # proxy_ssl_verify on;        #proxy_ssl_trusted_certificate xxxxx        #proxy_ssl_verify_depth 2;            proxy_set_header Upgrade $http_upgrade;        proxy_set_header Connection "upgrade";        proxy_cache_bypass $http_upgrade;        proxy_http_version 1.1;        proxy_set_header X-Forwarded-Proto $scheme;               proxy_cookie_path / "/; secure; HttpOnly";
            proxy_pass_header ETag;          proxy_hide_header Cache-Control;          proxy_hide_header Expires; #Same as above
	#proxy_set_header If-None-Match $http_if_none_match; 
        }    location /uploads/profile_pictures/ {        alias /var/www/uploads/profile_picture/;        autoindex off;    }    location /upload/ {        proxy_pass http://127.0.0.1:3050;          proxy_set_header Host $host;        proxy_set_header X-Real-IP $remote_addr;        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;        proxy_set_header X-Forwarded-Proto $scheme;        # Important for file uploads        client_max_body_size 10M;         client_body_timeout 300s;          proxy_read_timeout 300s;        proxy_connect_timeout 300s;        # Disable buffering for uploads        proxy_request_buffering off;}
     location /uploads/ {        alias /var/www/uploads/;        autoindex off;}

    location /phpmyadmin {  # phpMyAdmin location block        alias /var/www/html/phpmyadmin/;        index index.php;        try_files $uri $uri/ /index.php =404;  # Added /index.php
        location ~ \.php$ {            try_files $uri =404;            include fastcgi_params;            fastcgi_pass unix:/run/php/php8.3-fpm.sock;            fastcgi_index index.php;            fastcgi_param SCRIPT_FILENAME $request_filename;        }
	       location ~* \.(js|css|png|jpg|gif|ico|svg)$ {            try_files $uri $uri/ =404;        }    }}

[Water-Melon]

Hi @Jensileus,
When you use 0.0.0.0 as the listening address, all packets sent to port 5004 on any network interface will be delivered to your service. However, if you listen on 127.0.0.1, only packets whose destination address is 127.0.0.1:5004 will be forwarded to your service, and 127.0.0.1 is reserved for local communication within the same host. Therefore, please ensure—based on the above explanation—that Kong and your upstream service are able to communicate with each other over the network.