Menggunakan rangka kerja Gin untuk melaksanakan fungsi penggunaan dan pengurusan kontena

Dalam era pengkomputeran awan hari ini, kontena telah menjadi kaedah penggunaan dan pengurusan aplikasi yang sangat popular. Rangka kerja Gin ialah rangka kerja web ringan bagi bahasa GO Ia mempunyai ciri prestasi tinggi, penggunaan memori yang rendah, dan penyelenggaraan yang mudah, ia telah menjadi salah satu rangka kerja pilihan untuk pembangunan web menggunakan bahasa GO. Artikel ini akan memperkenalkan cara menggunakan rangka kerja Gin untuk melaksanakan fungsi penggunaan dan pengurusan dalam kontena Mari kita belajar tentangnya bersama-sama.

1. Pengenalan kepada Docker

Pada masa ini, Docker ialah teknologi kontena paling popular, yang boleh membungkus aplikasi dan kebergantungan mereka ke dalam bekas supaya ia boleh dijalankan dengan mudah di mana-mana sahaja. Docker ialah sumber terbuka dan telah menjadi penyelesaian kontena standard de facto dalam industri.

2. Contoh pembungkusan Docker bagi rangka kerja Gin

Berikut ialah contoh mudah menggunakan Docker untuk membungkus rangka kerja Gin:

1. Buat dan masukkan direktori projek :

mkdir docker-gin && cd docker-gin

2. Cipta Fail Docker:

DARI golang:1.13

tetapan Direktori kerja

WORKDIR /go/src/app

Pasang rangka kerja Gin

RUN go get github.com/gin-gonic/gin

Tambahkan semua Fail ke direktori kerja

TAMBAH ./go/src/app

Arahan Jalankan

CMD ["go", "run", "main.go"]

3. Buat fail main.go:

utama pakej

import "github.com/gin-gonic/gin"

func main() {
r := gin.Default()
r.GET("/", func (c *gin.Context) {

c.JSON(200, gin.H{
  "message": "Hello World",
})

})
r .Run (":8080")
}

4. Bina imej dan jalankan bekas:

docker build -t docker-gin .
docker run -p 8080 :8080 docker-gin

Kini anda boleh mengakses aplikasi kami melalui http://localhost:8080.

Tetapi selepas itu, kami selanjutnya menulis beberapa logik untuk mencapai tujuan penempatan dan pengurusan kami.

3. Penetapan dan pengurusan kontena

Berdasarkan contoh di atas, kami menambah dua API berikut untuk melaksanakan fungsi penggunaan dan pengurusan kontena:

1. POST / deployment : Laksanakan fungsi penggunaan kontena

dengan memuat naik fail zip, menyahmampat dan membina imej baharu, dan akhirnya menggunakan bekas baharu melalui penjadualan Kubernetes.

Berikut ialah pelaksanaan yang dipermudahkan:

func handleDeploy(c *gin.Context) {
fail, pengepala, err := c.Request.FormFile("file")
if err != nil {

c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return

}
tangguh fail.Close()

// Simpan fail yang dimuat naik ke local
nama fail := "deploy/" + pengepala .Nama fail
keluar, err := os.Create(filename)
if err != nil {

c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return

}
tangguh keluar.Close()
_, err = io .Copy(out, file)
if err != nil {

c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return

}

// Nyahmampat fail yang dimuat naik
zipReader, err := zip.OpenReader(nama fail )
if err != nil {

c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return

}
tangguhkan zipReader.Close()
untuk _, zipFail := julat zipReader.Fail {

srcObj, err := zipFile.Open()
if err != nil {
  c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
  return
}
defer srcObj.Close()

dstPath := "deploy/" + zipFile.Name
if !strings.HasPrefix(dstPath, "deploy/") {
  c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file"})
  return
}
if zipFile.FileInfo().IsDir() {
  os.MkdirAll(dstPath, zipFile.Mode())
} else {
  dstObj, err := os.Create(dstPath)
  if err != nil {
    c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
    return
  }
  defer dstObj.Close()

  _, err = io.Copy(dstObj, srcObj)
  if err != nil {
    c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
    return
  }
}

}

// Bina imej baharu dan panggil kerahan Kubernetes
cmd := exec.Command("bash", "-c", "docker build -t docker-gin-"+strconv.FormatInt(time .Now ().Unix(), 10)+" . && kubectl apply -f deploy.yml")
cmd.Dir = "./deploy"
out, err = cmd.CombinedOutput()
if err != nil {

c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return

}
c.JSON(http.StatusOK, gin.H{"message": string(out)})
}

2. PADAM /berhenti: Tutup bekas semasa

Berikut ialah pelaksanaan yang dipermudahkan:

func handleStop(c *gin.Context) {
// Dapatkan ID bekas semasa
nama hos, err := os.Hostname()
if err != nil {

c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return

}
cmd := exec.Command("bash", "-c ", "kubectl get pod -o jsonpath='{.items[0].metadata.name}'")
cmdOutput, err := cmd.Output()
if err != nil {

c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return

}
podName := strings.TrimSpace(string(cmdOutput))

// Tutup bekas semasa
cmd = exec.Command("bash", "-c", "kubectl delete pod " +podName)
cmdOutput, err = cmd.CombinedOutput()
if err != nil {

c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return

}
c.JSON(http.StatusOK, gin. H{"message" : string(cmdOutput)})
}

Pelaksanaan kedua-dua API di atas adalah berdasarkan Kubernetes untuk pengurusan kontena Penggunaan Kubernetes tidak akan diperkenalkan secara terperinci di sini.

4. Ringkasan

Artikel ini memperkenalkan cara menggunakan Docker untuk merangkum rangka kerja Gin dan melaksanakan fungsi penggunaan dan pengurusan dalam kontena. Dalam amalan, kita boleh melaksanakan pelaksanaan yang lebih terperinci berdasarkan keperluan sebenar. Berikut adalah contoh mudah. Ringkasnya, menggunakan teknologi kontena untuk penggunaan dan pengurusan aplikasi boleh meningkatkan kecekapan pembangunan, mengelakkan masalah konfigurasi persekitaran, dan mengurangkan kesukaran operasi dan penyelenggaraan. Ia adalah pendekatan yang sangat disyorkan.

Atas ialah kandungan terperinci Menggunakan rangka kerja Gin untuk melaksanakan fungsi penggunaan dan pengurusan kontena. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!