自己寫的go程式放到線上本來編譯成二進位制扔上去就行啦，但是懷著一顆docker的心，最終還是將它放到docker容器中執行起來了，執行起來也ok，一個最小容器64M，統一管理起來也方便，但是畢竟是個線上長駐記憶體的服務程式，萬一跑掛了怎麼辦，如何才能監控它，直接上go程式碼,網上程式碼，略微做了下注釋，但實測過，真實有效：

package main
import (
 "encoding/json"
 "errors"
 "flag"
 "fmt"
 "io/ioutil"
 "log"
 "net"
 "os"
 "strings"
 "time"
)
// 映象結構
type Image struct {
 Created uint64
 Id string
 ParentId string
 RepoTags []string
 Size uint64
 VirtualSize uint64
}
// 容器結構
type Container struct {
 Id string `json:"Id"`
 Names []string `json:"Names"`
 Image string `json:"Image"`
 ImageID string `json:"ImageID"`
 Command string `json:"Command"`
 Created uint64 `json:"Created"`
 State string `json:"State"`
 Status string `json:"Status"`
 Ports []Port `json:"Ports"`
 Labels map[string]string `json:"Labels"`
 HostConfig map[string]string `json:"HostConfig"`
 NetworkSettings map[string]interface{} `json:"NetworkSettings"`
 Mounts []Mount `json:"Mounts"`
}
// docker 埠對映
type Port struct {
 IP string `json:"IP"`
 PrivatePort int `json:"PrivatePort"`
 PublicPort int `json:"PublicPort"`
 Type string `json:"Type"`
}
// docker 掛載
type Mount struct {
 Type string `json:"Type"`
 Source string `json:"Source"`
 Destination string `json:"Destination"`
 Mode string `json:"Mode"`
 RW bool `json:"RW"`
 Propatation string `json:"Propagation"`
}
// 連線列表
var SockAddr = "/var/run//docker.sock" //這可不是隨便寫的，是docker官網文件的套接字預設值，當然守護程序通訊方式還有tcp,fd等方式，各自都有適用場景。。。
var imagesSock = "GET /images/json HTTP/1.0\r\n\r\n" //docker對外的映象api操作
var containerSock = "GET /containers/json?all=true HTTP/1.0\r\n\r\n"  //docker對外的容器檢視api
var startContainerSock = "POST /containers/%s/start HTTP/1.0\r\n\r\n" //docker對外的容器啟動api
// 白名單
var whiteList []string
func main() {
 // 讀取命令列引數
 // 白名單列表
 list := flag.String("list","","docker white list to restart,eg: token,explorer")
 // 輪詢的時間間隔，單位秒
 times := flag.Int64("time",10,"time interval to set read docker containers [second],default is 10 second")
 flag.Parse()
 // 解析list => whiteList
 whiteList = strings.Split(*list,",") //將我們命令列中list引數的容器列表解析到程式碼中
 log.SetOutput(os.Stdout)
 log.Println("start docker watching...")
 log.Printf("Your whiteList: %v\n",*list)
 log.Printf("Your shedule times: %ds\n",*times)
  //接下來的這個for迴圈就是每隔一定時間監控docker容器是否正常執行，不正常就重新啟動它
 for {
  // 輪詢docker
  err := listenDocker() 
  if err != nil {
   log.Println(err.Error())
  }
  time.Sleep(time.Duration(*times)*time.Second)
 }
}
func listenDocker() error {
 // 獲取容器列表,拿到所有的容器資訊
 containers,err := readContainer() 
 if err != nil {
  return errors.New("read container error: " + err.Error())
 }
 // 先遍歷白名單快，次數少
 for _,name := range whiteList {
 Name:
  for _,container := range containers {
   for _,cname := range container.Names {
    // 如果匹配到白名單
    if cname[1:] == name {
     // 關心一下容器狀態
     log.Printf("id=%s,name=%s,state=%s",container.Id[:12],container.Names,container.Status)
     if strings.Contains(container.Status,"Exited") {
      // 如果出現異常退出的容器，啟動它
      log.Printf("find container: [%s] has exited,ready to start it. ",name)
      e := startContainer(container.Id)
      if e != nil {
       log.Println("start container error: ",e.Error())
      }
      break Name
     }
    }
   }
  }
 }
 return nil
}
// 獲取 unix sock 連線
func connectDocker() (*net.UnixConn,error) {
 addr := net.UnixAddr{SockAddr,"unix"}  // SockAddr 這個變數的值被設定為docker的/var/run/docker 套接字路徑值，也就是說此處就是撥通與docker的daemon通訊建立的關鍵處,其他處的程式碼就是些正常的邏輯處理了
 return net.DialUnix("unix",nil,&addr)
}
// 啟動容器
func startContainer(id string) error {
 conn,err := connectDocker()
 if err != nil {
  return errors.New("connect error: " + err.Error())
 }
 start := fmt.Sprintf(startContainerSock,id)
 fmt.Println(start)
 cmd := []byte(start)
 code,err := conn.Write(cmd)
 if err != nil {
  return err
 }
 log.Println("start container response code: ",code)
 // 啟動容器等待20秒，防止資料重發
 time.Sleep(20*time.Second)
 return nil
}
// 獲取容器列表
func readContainer() ([]Container,error) {
 conn,err := connectDocker() //建立一個unix連線,這其實是一個關鍵點，需要你瞭解unix 套接字 建立連線
 if err != nil {
  return nil,errors.New("connect error: " + err.Error())
 }
 _,err = conn.Write([]byte(containerSock))
 if err != nil {
  return nil,err
 }
 result,err := ioutil.ReadAll(conn)
 if err != nil {
  return nil,err
 }
 body := getBody(result)
 var containers []Container
 err = json.Unmarshal(body,&containers)
 if err != nil {
  return nil,err
 }
 log.Println("len of containers: ",len(containers))
 if len(containers) == 0 {
  return nil,errors.New("no containers")
 }
 return containers,nil
}
// 獲取映象列表
func readImage(conn *net.UnixConn) ([]Image,error) {
 _,err := conn.Write([]byte(imagesSock))
 if err != nil {
  return nil,err
 }
 body := getBody(result[:])
 var images []Image
 err = json.Unmarshal(body,&images)
 if err != nil {
  return nil,err
 }
 return images,nil
}
// 從返回的 http 響應中提取 body
func getBody(result []byte) (body []byte) {
 for i:=0; i<=len(result)-4; i++ {
  if result[i] == 13 && result[i+1] == 10 && result[i+2] == 13 && result[i+3] == 10 {
   body = result[i+4:]
   break
  }
 }
 return
}
/*
error log :
 1、write unix @->/var/run/docker.sock: write: broken pipe
  建立的tcp連線不能複用，每次操作都建立連線
 */

使用方法

1.編譯

go build -o main main.go

2.linux下直接當可執行檔案執行便可

./main -list="容器名稱1,容器名稱2..."

思路分析:

原來docker這個軟體對外是提供了一些列api用來管理容器的增刪該查的官方api文件,既然提供了api了那麼任何語言都能實現對其的管理控制及動態部署了。

但其實這裡面真要弄明白還是有很多話要講了

docker這個服務已經已程序的形式執行在linux的系統中了，為什麼我們輸入docker有關的命令能夠與之互動，這好像是一個習以為常的行為，貌似理應如此，但是要知道我們是在與一個正在執行的程序發生通訊，若仍不以為然，請接以下問：

1.程序間都是如何通訊的？程序通訊間方式

在明白了程序之間的通訊方式之後，我明白了docker的這個daemon通訊原理，瞬間就打通了之前對k8管理docker的疑惑(老實講只知道kubernetes很強大,卻沒想明白它是如何能動態增容我的容器配置,負載等等等),套接字(socket) /var/run/docker 這個我們使用起來不會接觸到，理解起來卻必須打通的關鍵點請務必瞭解它。

總結

以上所述是小編給大家介紹的golang實現對docker容器心跳監控功能,希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回覆大家的。在此也非常感謝大家對我們網站的支援！
如果你覺得本文對你有幫助，歡迎轉載，煩請註明出處，謝謝！