Go websocket 聊天室demo以及k8s 部署

​本來打算練習go websocket  做一個示例，結果在網上找了一個聊天室的示例【Go websocket 聊天室的詳細實現和詳細分析_上官二狗的博客-CSDN博客_go websocket 聊天室】，感覺不錯就拿來用一下。

介紹

首先需要有一個客戶端 client 的 manager ，manager 里應該保存所有的client 信息
所以在我們的程序里定義了 ClientManager 這個結構體
用 clients 這個 map 結構來保存所有的連接信息
遍歷 clients 通過使用 broadcast 這個 channel 把 web 端傳送來的消息分發給所有的客戶端client
其次每個成功建立長連接的 client 開一個 read 協程和 wrtie 協程
read 協程不斷讀取 web 端輸入的 meaasge，並把 message 傳遞給 boradcast ，讓 manager 遍歷 clients 把 message 通過 broadcast channel ，傳遞給各個客戶端 client 的 send channel
write 協程不斷的將 send channel 里的消息發送給 web 端

結構圖大致如下：

​

服務代碼

main.go

package main

import (
    "encoding/json"
    "fmt"
    "net"
    "net/http"

    "github.com/gorilla/websocket"
    uuid "github.com/satori/go.uuid"
)

//客戶端管理
type ClientManager struct {
    //客戶端 map 儲存並管理所有的長連接client，在線的為true，不在的為false
    clients map[*Client]bool
    //web端發送來的的message我們用broadcast來接收，並最后分發給所有的client
    broadcast chan []byte
    //新創建的長連接client
    register chan *Client
    //新注銷的長連接client
    unregister chan *Client
}

//客戶端 Client
type Client struct {
    //用戶id
    id string
    //連接的socket
    socket *websocket.Conn
    //發送的消息
    send chan []byte
}

//會把Message格式化成json
type Message struct {
    //消息struct
    Sender    string `json:"sender,omitempty"`    //發送者
    Recipient string `json:"recipient,omitempty"` //接收者
    Content   string `json:"content,omitempty"`   //內容
    ServerIP  string `json:"serverIp,omitempty"`  //實際不需要 驗證k8s
    SenderIP  string `json:"senderIp,omitempty"`  //實際不需要 驗證k8s
}

//創建客戶端管理者
var manager = ClientManager{
    broadcast:  make(chan []byte),
    register:   make(chan *Client),
    unregister: make(chan *Client),
    clients:    make(map[*Client]bool),
}

func (manager *ClientManager) start() {
    for {
        select {
        //如果有新的連接接入,就通過channel把連接傳遞給conn
        case conn := <-manager.register:
            //把客戶端的連接設置為true
            manager.clients[conn] = true
            //把返回連接成功的消息json格式化
            jsonMessage, _ := json.Marshal(&Message{Content: "/A new socket has connected. ", ServerIP: LocalIp(), SenderIP: conn.socket.RemoteAddr().String()})
            //調用客戶端的send方法，發送消息
            manager.send(jsonMessage, conn)
            //如果連接斷開了
        case conn := <-manager.unregister:
            //判斷連接的狀態，如果是true,就關閉send，刪除連接client的值
            if _, ok := manager.clients[conn]; ok {
                close(conn.send)
                delete(manager.clients, conn)
                jsonMessage, _ := json.Marshal(&Message{Content: "/A socket has disconnected. ", ServerIP: LocalIp(), SenderIP: conn.socket.RemoteAddr().String()})
                manager.send(jsonMessage, conn)
            }
            //廣播
        case message := <-manager.broadcast:
            //遍歷已經連接的客戶端，把消息發送給他們
            for conn := range manager.clients {
                select {
                case conn.send <- message:
                default:
                    close(conn.send)
                    delete(manager.clients, conn)
                }
            }
        }
    }
}

//定義客戶端管理的send方法
func (manager *ClientManager) send(message []byte, ignore *Client) {
    for conn := range manager.clients {
        //不給屏蔽的連接發送消息
        if conn != ignore {
            conn.send <- message
        }
    }
}

//定義客戶端結構體的read方法
func (c *Client) read() {
    defer func() {
        manager.unregister <- c
        _ = c.socket.Close()
    }()

    for {
        //讀取消息
        _, message, err := c.socket.ReadMessage()
        //如果有錯誤信息，就注銷這個連接然后關閉
        if err != nil {
            manager.unregister <- c
            _ = c.socket.Close()
            break
        }
        //如果沒有錯誤信息就把信息放入broadcast
        jsonMessage, _ := json.Marshal(&Message{Sender: c.id, Content: string(message), ServerIP: LocalIp(), SenderIP: c.socket.RemoteAddr().String()})
        manager.broadcast <- jsonMessage
    }
}

func (c *Client) write() {
    defer func() {
        _ = c.socket.Close()
    }()

    for {
        select {
        //從send里讀消息
        case message, ok := <-c.send:
            //如果沒有消息
            if !ok {
                _ = c.socket.WriteMessage(websocket.CloseMessage, []byte{})
                return
            }
            //有消息就寫入，發送給web端
            _ = c.socket.WriteMessage(websocket.TextMessage, message)
        }
    }
}

func main() {
    fmt.Println("Starting application...")
    //開一個goroutine執行開始程序
    go manager.start()
    //注冊默認路由為 /ws ，並使用wsHandler這個方法
    http.HandleFunc("/ws", wsHandler)
    http.HandleFunc("/health", healthHandler)
    //監聽本地的8011端口
    fmt.Println("chat server start.....")
    _ = http.ListenAndServe(":8080", nil)
}

func wsHandler(res http.ResponseWriter, req *http.Request) {
    //將http協議升級成websocket協議
    conn, err := (&websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}).Upgrade(res, req, nil)
    if err != nil {
        http.NotFound(res, req)
        return
    }

    //每一次連接都會新開一個client，client.id通過uuid生成保證每次都是不同的
    client := &Client{id: uuid.Must(uuid.NewV4(), nil).String(), socket: conn, send: make(chan []byte)}
    //注冊一個新的鏈接
    manager.register <- client

    //啟動協程收web端傳過來的消息
    go client.read()
    //啟動協程把消息返回給web端
    go client.write()
}

func healthHandler(res http.ResponseWriter, _ *http.Request) {
    _, _ = res.Write([]byte("ok"))
}

func LocalIp() string {
    address, _ := net.InterfaceAddrs()
    var ip = "localhost"
    for _, address := range address {
        if ipAddress, ok := address.(*net.IPNet); ok && !ipAddress.IP.IsLoopback() {
            if ipAddress.IP.To4() != nil {
                ip = ipAddress.IP.String()
            }
        }
    }
    return ip
}

我這里還要驗證k8s， 所以加了IP信息，圖簡單 只有server端部署到k8s，客服端可以通過go程序，html頁面訪問

Dockerfile

FROM golang:1.15.6

RUN mkdir -p /app

WORKDIR /app
 
ADD main /app/main

EXPOSE 8080
 
CMD ["./main"]

build.sh【我這里就不走jenkins， 直接把代碼 拖到 k8s master上 運行build文件 編譯  推鏡像到harbor】

#!/bin/bash
#cd $WORKSPACE
export GOPROXY=https://goproxy.io

#根據 go.mod 文件來處理依賴關系。
go mod tidy

# linux環境編譯
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o main

# 構建docker鏡像，項目中需要在當前目錄下有dockerfile，否則構建失敗

docker build -t chatserver .
docker tag chatserver 192.168.100.30:8080/go/chatserver:2022

docker login -u admin -p '123456' 192.168.100.30:8080
docker push 192.168.100.30:8080/go/chatserver:2022

docker rmi chatserver
docker rmi 192.168.100.30:8080/go/chatserver:2022

deploy.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: chatserver
  namespace: go
  labels:
    app: chatserver
    version: v1
spec:
  replicas: 1
  minReadySeconds: 10 
  selector:
    matchLabels:
      app: chatserver
      version: v1
  template:
    metadata:
      labels:
        app: chatserver
        version: v1
    spec:
      imagePullSecrets:
      - name: regsecret
      containers:
      - name: chatserver
        image: 192.168.100.30:8080/go/chatserver:2022
        ports:
        - containerPort: 8080
        imagePullPolicy: Always

---
apiVersion: v1 
kind: Service 
metadata:
  name: chatserver
  namespace: go 
  labels:
    app: chatserver
    version: v1
spec:
  ports:
    - port: 8080 
      targetPort: 8080 
      name: grpc-port
      protocol: TCP
  selector:
    app: chatserver


---
apiVersion: extensions/v1beta1     
kind: Ingress    
metadata:           
  name: chatserver
  namespace: go
  annotations:           
    #ingress使用那種軟件 
    kubernetes.io/ingress.class: nginx
    #配置websocket 需要的配置   
    nginx.ingress.kubernetes.io/configuration-snippet: |
       proxy_set_header Upgrade "websocket";
       proxy_set_header Connection "Upgrade";
spec:      
  rules: 
  - host: chatserver.go.com
    http:
      paths: 
        #代理websocket服務
      - path: /
        backend:
          serviceName: chatserver
          servicePort: 8080

客服端

main.go

package main

import (
    "flag"
    "fmt"
    "net/url"

    "github.com/gorilla/websocket"
)

//定義連接的服務端的網址
var addr = flag.String("addr", "chatserver.go.com", "http service address")

func main() {
    u := url.URL{Scheme: "ws", Host: *addr, Path: "/ws"}
    var dialer *websocket.Dialer

    //通過Dialer連接websocket服務器
    conn, _, err := dialer.Dial(u.String(), nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    //go timeWriter(conn)
    //打印接收到的消息或者錯誤

    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            fmt.Println("read:", err)
            return
        }
        fmt.Printf("received: %s\n", message)
    }
}

chatroom.html  【可以用 bee server   提供靜態文件服務器】

<html>
<head>
    <title>Golang Chat</title>
    <script type="application/javascript" src="jquery-1.12.4.js"></script>
    <script type="text/javascript">
        $(function() {
            var conn;
            var msg = $("#msg");
            var log = $("#log");

            function appendLog(msg) {
                var d = log[0]
                var doScroll = d.scrollTop == d.scrollHeight - d.clientHeight;
                msg.appendTo(log)
                if (doScroll) {
                    d.scrollTop = d.scrollHeight - d.clientHeight;
                }
            }

            $("#form").submit(function() {
                if (!conn) {
                    return false;
                }
                if (!msg.val()) {
                    return false;
                }
                conn.send(msg.val());
                msg.val("");
                return false
            });

            if (window["WebSocket"]) {
                conn = new WebSocket("ws://chatserver.go.com/ws");
                conn.onclose = function(evt) {
                    appendLog($("<div><b>Connection Closed.</b></div>"))
                }
                conn.onmessage = function(evt) {
                    appendLog($("<div/>").text(evt.data))
                }
            } else {
                appendLog($("<div><b>WebSockets Not Support.</b></div>"))
            }
        });
    </script>
    <style type="text/css">
        html {
            overflow: hidden;
        }

        body {
            overflow: hidden;
            padding: 0;
            margin: 0;
            width: 100%;
            height: 100%;
            background: gray;
        }

        #log {
            background: white;
            margin: 0;
            padding: 0.5em 0.5em 0.5em 0.5em;
            position: absolute;
            top: 0.5em;
            left: 0.5em;
            right: 0.5em;
            bottom: 3em;
            overflow: auto;
        }

        #form {
            padding: 0 0.5em 0 0.5em;
            margin: 0;
            position: absolute;
            bottom: 1em;
            left: 0px;
            width: 100%;
            overflow: hidden;
        }

    </style>
</head>
<body>
<div id="log"></div>
<form id="form">
    <input type="submit" value="發送" />
    <input type="text" id="msg" size="64"/>
</form>
</body>
</html>

運行效果

確認鏈接是長連接，不同的客服端鏈接到不同的服務器上，但是也留下了一個問題待處理，比如A給B發送消息，A鏈接到服務器1，B鏈接到服務2，之間消息如何簡單方便處理了？

 下載地址 https://github.com/dz45693/gochat.git