Amalan go-zero dan Kubernetes: membina seni bina perkhidmatan mikro dalam kontena dengan ketersediaan tinggi, prestasi tinggi dan berskala tinggi

Dengan pengembangan berterusan skala Internet dan keperluan pengguna yang semakin meningkat, kelebihan seni bina perkhidmatan mikro semakin mendapat perhatian. Selepas itu, seni bina perkhidmatan mikro kontena telah menjadi sangat penting, yang dapat memenuhi keperluan ketersediaan tinggi, prestasi tinggi, berskala tinggi dan aspek lain dengan lebih baik. Di bawah aliran ini, go-zero dan Kubernetes telah menjadi rangka kerja mikro perkhidmatan bekas paling popular.

Artikel ini akan memperkenalkan cara menggunakan rangka kerja go-zero dan alat orkestrasi kontena Kubernetes untuk membina seni bina perkhidmatan mikro bekas dengan ketersediaan tinggi, berprestasi tinggi dan berskala tinggi. Mula-mula, mari kita fahami secara ringkas konsep asas go-zero dan Kubernetes.

go-zero ialah rangka kerja mikroperkhidmatan yang dibangunkan berdasarkan Golang Ia mempunyai kelebihan ringan, prestasi tinggi, kesederhanaan dan kemudahan penggunaan. Ia menampilkan sokongan untuk penjanaan kod automatik, penyepaduan dengan pelbagai perpustakaan komponen, dan pembinaan pantas perkhidmatan mikro berprestasi tinggi.

Kubernetes ialah alat orkestrasi kontena sumber terbuka yang mudah alih, boleh diperluaskan kecekapan.

Kini kami mula memperkenalkan cara menggabungkan kedua-dua alatan ini untuk membina seni bina perkhidmatan mikro kontena yang tersedia tinggi, berprestasi tinggi dan berskala tinggi.

Langkah 1: Mereka bentuk aplikasi perkhidmatan mikro

Sebelum menggunakan go-zero dan Kubernetes untuk membina aplikasi perkhidmatan mikro, anda perlu mereka bentuk aplikasi itu terlebih dahulu. Oleh kerana ciri rangka kerja go-zero ialah keupayaan untuk menjana kod secara automatik berdasarkan spesifikasi reka bentuk input, spesifikasi reka bentuk aplikasi perlu sejelas mungkin.

Apabila mereka bentuk aplikasi, anda boleh mempertimbangkan aspek berikut:

1. Pembahagian perkhidmatan mikro: Bahagikan aplikasi kepada berbilang perkhidmatan mikro berdasarkan logik perniagaan aplikasi.
2. Tanggungjawab perkhidmatan mikro: Tentukan fungsi dan tanggungjawab setiap perkhidmatan mikro.
3. Reka bentuk antara muka: Tentukan antara muka setiap perkhidmatan mikro, termasuk input, output, dsb.
4. Reka bentuk pangkalan data: Reka bentuk struktur jadual pangkalan data yang diperlukan oleh aplikasi.

Langkah 2: Gunakan rangka kerja go-zero untuk menjana kod perkhidmatan mikro

Rangka kerja go-zero menyokong penjanaan kod mikroperkhidmatan berasaskan gRPC secara automatik berdasarkan model domain, yang sangat boleh mengurangkan kerja manual Masa dan usaha yang terlibat dalam menulis kod.

Apabila memilih rangka kerja go-zero untuk aplikasi, anda perlu memastikan aplikasi itu mempunyai ciri-ciri berikut:

1. Komunikasi perkhidmatan mikro berasaskan GRPC: gRPC ialah prestasi tinggi , merentas bahasa, merentas platform Rangka kerja RPC platform adalah cekap, selamat dan boleh dipercayai.
2. Sokong reka bentuk API perisytiharan: tentukan spesifikasi API melalui Swagger2, jana dokumen API dan SDK.
3. Penjanaan kod automatik: Menjana kod mikro perkhidmatan berasaskan gRPC secara automatik berdasarkan model domain.

Dengan menggunakan alat goctl untuk menjana kod perkhidmatan mikro, kecekapan pembangunan boleh dipertingkatkan dengan ketara. Katakan kita ingin membangunkan pesanan mikroperkhidmatan bernama Perintah kod yang dihasilkan adalah seperti berikut:

$ goctl api new -o order

Struktur fail yang dihasilkan adalah seperti berikut:

order
├── api
│   └── order.api
├── etc
└── internal
    ├── config
    │   └── config.go
    └── logic
        ├── orderlogic.go
        └── orderlogic_test.go

Antaranya, order.api mentakrifkan spesifikasi API daripada microservice. orderlogic.go melaksanakan logik perniagaan pesanan microservice dan config.go mentakrifkan maklumat konfigurasi perkhidmatan mikro.

Langkah 3: Menyimpan perkhidmatan mikro

Menyimpan perkhidmatan mikro ialah proses yang diperlukan untuk menggunakan aplikasi go-zero ke gugusan Kubernetes. Aplikasi dalam kontena boleh digunakan dan diuruskan dengan lebih fleksibel, berskala dan cekap. Seterusnya kami akan mencipta imej bekas untuk perkhidmatan mikro pesanan.

1. Buat fail Docker dalam direktori akar aplikasi untuk membina imej kontena.

# 基于golang的官方镜像构建
FROM golang:1.13.8-alpine

# 在容器中创建一个工作目录
RUN mkdir -p /go/src/order
WORKDIR /go/src/order

# 将当前目录下的所有文件复制到容器中的 /go/src/order 目录下
COPY . /go/src/order

# 安装go-zero框架和依赖项
RUN cd /go/src/order && 
    go get -u github.com/tal-tech/go-zero && 
    go mod download

# 构建容器镜像
RUN cd /go/src/order && 
    CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo

# 启动容器时运行的命令
CMD ["/go/src/order/order"]

2. Bina imej bekas

$ docker build -t order:v1.0.0 .

3. Jalankan bekas

$ docker run -d -p 8080:8080 order:v1.0.0

Anda boleh menguji pesanan mikro melalui arahan curl secara setempat sama ada perkhidmatan berjalan dengan betul.

Langkah 4: Gunakan Kubernetes untuk menggunakan perkhidmatan mikro

Sebelum menggunakan Kubernetes untuk menggunakan perkhidmatan mikro kontena, anda perlu menolak perkhidmatan mikro ke gudang Docker.

1. Tolak imej ke Docker Hub

$ docker tag order:v1.0.0 <dockerhub-username>/order:v1.0.0
$ docker push <dockerhub-username>/order:v1.0.0

2. Buat Deployment

Deployment digunakan untuk mengurus set replika Pod dan boleh mengawal kuantiti Pod, peningkatan keselamatan, penarikan balik, dsb.

Anda boleh membuat susunan bernama Deployment melalui fail YAML Deployment berikut.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order
spec:
  replicas: 2
  selector:
    matchLabels:
      app: order
  template:
    metadata:
      labels:
        app: order
    spec:
      containers:
      - name: order
        image: <dockerhub-username>/order:v1.0.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8080

Fail ini mentakrifkan pesanan bernama Deployment, yang merangkumi bilangan salinan, nama bekas, alamat cermin dan maklumat lain.

3. Buat Perkhidmatan

Perkhidmatan digunakan untuk menghalakan permintaan rangkaian luaran ke bekas yang sepadan dengan Pod dan menyediakan IP statik dan nama DNS untuk Pod mengakses Pod.

Anda boleh membuat pesanan bernama Perkhidmatan melalui fail YAML Perkhidmatan berikut.

apiVersion: v1
kind: Service
metadata:
  name: order
spec:
  selector:
    app: order
  ports:
  - name: http
    port: 8080
    protocol: TCP
    targetPort: 8080
  type: ClusterIP

Fail ini mentakrifkan pesanan bernama Perkhidmatan, yang termasuk nama Perkhidmatan, tetapan port, protokol akses dan maklumat lain.

4. Letakkan aplikasi

Laksanakan arahan berikut untuk menggunakan aplikasi.

$ kubectl apply -f order.yaml

Arahan ini akan membaca maklumat konfigurasi Deployment dan Service daripada fail order.yaml dan mencipta objek Deployment dan Service yang sepadan.

Kemudian gunakan arahan berikut untuk menyemak status Pod.

$ kubectl get pod -l app=order

Arahan ini akan memaparkan senarai Pod yang sedang berjalan dan statusnya.

Langkah 5: Laksanakan pengimbangan beban dan penskalaan automatik

Untuk meningkatkan kebolehskalaan dan kebolehpercayaan perkhidmatan mikro, kami perlu melaksanakan penskalaan automatik dan pengimbangan beban. Dalam Kubernetes, Penskala Auto dan Perkhidmatan Pod Horizontal digunakan untuk melaksanakan kedua-dua fungsi ini.

1. 实现负载均衡

在使用Kubernetes部署微服务时，Service用于将外部网络请求路由到Pod对应的容器中，可以提供均衡负载的功能。可以使用loadBalancer配置实现负载均衡。

可以通过下面的Service YAML文件的loadBalancer配置实现负载均衡。

apiVersion: v1
kind: Service
metadata:
  name: order
spec:
  selector:
    app: order
  ports:
  - name: http
    port: 8080
    protocol: TCP
    targetPort: 8080
  type: LoadBalancer

2. 实现自动伸缩

在Kubernetes中，使用Horizontal Pod Autoscaler（HPA）可以实现自动伸缩。HPA使用指标来监控Pod的CPU利用率和其他资源使用情况，并根据阈值进行自动扩展或缩小。

可以通过下面的HPA YAML文件来实现自动伸缩。

apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: order
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: order
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60

该文件定义了一个名为order的HPA，其中包括目标Deployment、最少Pod副本数、最多Pod副本数、监控指标等信息。

第六步：应用调试和监控

在微服务应用部署后，需要对应用进行调试和监控。这可以帮助检测和解决应用中出现的问题，并对应用进行优化调整。

对于go-zero框架，可以使用goctl工具生成API文档和Swagger接口文档。由于Swagger定义了API规范，因此可以使用Swagger UI来可视化展示API接口。

对于Kubernetes，可以使用Prometheus、Grafana和ELK等工具进行集群监控和日志分析。Kubernetes还支持Ingress对象来管理HTTP/HTTPS路由，可以用Ingress-Nginx实现日志收集和代理。

结论

go-zero与Kubernetes是构建容器化微服务架构的最佳组合之一，能够提供高可用性、高性能、高扩展性等优势。在实践中，需要进行应用设计、go-zero代码生成、容器化、Kubernetes部署、负载均衡和自动伸缩等步骤，并对应用进行调试和监控。通过这些步骤，可以构建出一个高度可靠、安全、高效的微服务应用程序。

Atas ialah kandungan terperinci Amalan go-zero dan Kubernetes: membina seni bina perkhidmatan mikro dalam kontena dengan ketersediaan tinggi, prestasi tinggi dan berskala tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!