Bina perkhidmatan mikro menggunakan rangka kerja web Golang rangka kerja Iris dan Docker

Dengan pembangunan berterusan aplikasi Internet, seni bina perkhidmatan mikro menjadi model seni bina yang semakin popular. Seni bina Microservices mereka bentuk aplikasi ke dalam perkhidmatan kecil yang bebas antara satu sama lain dan boleh dikemas kini dan digunakan dengan kerap. Dengan pembangunan pengkomputeran awan, data besar dan Internet of Things, aplikasi seni bina perkhidmatan mikro akan menjadi lebih dan lebih meluas.

Artikel ini akan memperkenalkan cara menggunakan rangka kerja web Golang Iris dan Docker untuk membina perkhidmatan mikro.

1. Pengenalan kepada Iris

Iris ialah rangka kerja web yang ditulis dalam Go. Ia dicipta dan diselenggara oleh pasukan Kataras. Kod Iris ringkas dan mudah dibaca, mempunyai prestasi cemerlang, menyokong gaya pengaturcaraan tak segerak dan segerak, serta menyokong seni bina MVC dan RESTful. Iris ialah rangka kerja web baru muncul yang bertujuan untuk menjadi "rangka kerja web generasi seterusnya".

2. Pengenalan kepada Docker

Docker ialah platform kontena sumber terbuka yang membolehkan pembangun membuat, menggunakan dan menjalankan aplikasi dengan cepat. Menggunakan Docker, anda boleh memasukkan aplikasi anda dan semua kebergantungannya dalam satu bekas, menjadikan penggunaan aplikasi lebih mudah dan lebih dipercayai. Docker bukan sahaja meningkatkan kemudahalihan aplikasi tetapi juga mengurangkan penggunaan sumber masa jalan dan konflik.

3. Gunakan Iris dan Docker untuk membina perkhidmatan mikro

Dalam artikel ini, kami akan memperkenalkan cara menggunakan Iris dan Docker untuk membina perkhidmatan mikro yang mudah. Perkhidmatan ini akan menyediakan dua titik akhir API: /hello dan /time . Titik akhir /hello akan mengembalikan mesej "Hello, World, dan titik akhir /time akan mengembalikan masa semasa.

1. Buat projek Golang

Pertama, buat projek Golang. Cipta projek Iris menggunakan arahan berikut:

$ go get -u github.com/kataras/iris/v12

Pastikan pembolehubah persekitaran ditetapkan dalam ruang kerja Go.

Buat fail main.go dan tambah kod berikut:

package main

import (
    "github.com/kataras/iris/v12"
    "time"
)

func main() {
    app := iris.New()
    app.Get("/hello", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"message": "Hello, World!"})
    })
    app.Get("/time", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"time": time.Now().Format(time.RFC3339)})
    })
    app.Run(iris.Addr(":8080"))
}

Dalam main.go, kami menggunakan iris.New() untuk mencipta contoh aplikasi Iris baharu dan menggunakan kaedah app.Get() untuk menentukan dua penghala berbeza . Titik akhir /hello penghala akan mengembalikan "Hello, World" dan titik akhir /time akan mengembalikan masa semasa. Akhir sekali, jalankan kaedah app.Run() untuk memulakan perkhidmatan dan dengar sambungan pada port lalai 8080.

2. Buat Dockerfile

Seterusnya, buat fail bernama Dockerfile. Fail Docker ialah fail teks yang mengandungi satu siri arahan untuk membina imej Docker.

Tambah kod berikut dalam fail Docker:

FROM golang:1.16.3-alpine3.13 AS build

RUN apk update && apk upgrade && 
    apk add --no-cache bash git openssh

WORKDIR /go/src/app
COPY . .

RUN go get -d -v ./...
RUN go install -v ./...
RUN go build -o /usr/local/bin/app

FROM alpine:3.13
COPY --from=build /usr/local/bin/app /usr/local/bin/app
ENTRYPOINT ["/usr/local/bin/app"]

Fail Docker ini akan membina aplikasi kami berdasarkan imej Golang 1.16.3-alpine3.13. Kami mula-mula mengemas kini pakej pemasangan Alpine3.13 dan menambah pakej bash, git dan openssh yang diperlukan. Seterusnya, kami akan mentakrifkan direktori kerja, menyalin kod aplikasi kami ke dalam direktori kerja, dan memuat turun kebergantungan. Akhir sekali, kami menjalankan arahan go build untuk membina fail boleh laku binari dan menyalin fail boleh laku binari ke dalam imej Alpine3.13 untuk mencipta imej Docker terakhir.

3. Bina dan jalankan bekas

Dalam direktori Dockerfile, gunakan arahan berikut untuk membina imej Docker:

$ docker build -t my-app .

Arahan ini akan mencipta imej Docker bernama my-app. Kita boleh menggunakan arahan berikut untuk menjalankan bekas Docker:

$ docker run -p 8080:8080 my-app

Arahan ini akan memulakan bekas dan memetakan port lalai 8080 ke port 8080 hos menggunakan bendera -p. Dengan API awam aplikasi berjalan dalam bekas, kami boleh menguji API ini menggunakan arahan berikut:

$ curl http://localhost:8080/hello
{"message":"Hello, World!"}
$ curl http://localhost:8080/time
{"time":"2021-05-27T14:14:22+08:00"}

Kini, kami telah berjaya mencipta perkhidmatan mikro ringkas menggunakan Iris dan Docker. Dalam aplikasi sebenar, kami boleh membahagikan perkhidmatan kepada berbilang perkhidmatan mikro untuk mengurus dan menskalakan aplikasi dengan lebih baik.

Atas ialah kandungan terperinci Bina perkhidmatan mikro menggunakan rangka kerja web Golang rangka kerja Iris dan Docker. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!