Membangunkan saluran paip pada Apl Web Golang dengan Gitops dan Kubernetes

Dalam catatan blog ini, saya akan membimbing anda melalui perjalanan mengautomasikan penggunaan apl web dalam golang dengan saluran paip CI/CD dan menggunakan pendekatan Gitops.

Kami akan melalui kontena aplikasi kami untuk menggunakan ia pada kubernetes untuk menggunakan ArgoCD untuk penggunaan.

Keperluan

1. Sekelompok kubernetes Anda boleh menggunakan mana-mana perkhidmatan terurus daripada pembekal awan untuk kubernetes atau jika sistem anda mempunyai sumber yang mencukupi untuk menyediakan kluster kubernetes anda boleh menyediakan kluster kubernetes tempatan menggunakan Minikube/kind
2. Akaun github Akaun percuma sudah memadai kerana kami akan menggunakan Github Actions for Continuous Integration (CI)
3. Akaun dockerhub Kami akan menggunakan dockerhub untuk menarik imej bekas
4. Keinginan untuk belajar
5. Tidak berputus asa Ini adalah yang penting anda akan menghadapi masalah dan anda sepatutnya dapat menyelesaikan masalah dan menyelesaikannya. Saya terpaksa menyelesaikan masalah berkali-kali sebelum saya dapat menyiapkan projek ini.

Mari mulakan

Membekalkan apl dengan binaan docker berbilang peringkat

Untuk apl web tersedia pada semua mesin, kami perlu memasukkannya ke dalam bekas dan apabila kontena adalah perkataan yang terbaik daripada buruh pelabuhan.
Saya mencipta fail Docker untuk menjalankan apl tetapi saya telah menggunakan format berbilang peringkat

Mengapa binaan berbilang peringkat?

Alasannya mudah jika saya mencipta imej dalam satu peringkat ia akan menggunakan lebih banyak ruang pada mesin manakala dengan menggunakan binaan berbilang peringkat kami mengoptimumkan saiz akhir imej dengan memisahkan persekitaran binaan dan masa jalan serta mengurangkan serangan permukaan imej kami untuk keselamatan yang lebih baik

Begini cara anda boleh melakukannya

1. Buat fail docker
2. Kompilasi aplikasi dalam peringkat binaan
3. Salin binari yang disusun kepada imej asas yang minimum
4. Bina imej dan tolaknya ke dockerhub supaya imej boleh digunakan oleh Github Actions dalam CI

# Start with a base image
FROM golang:1.22 as base
WORKDIR /app
COPY go.mod ./
RUN go mod download
COPY . .
RUN go build -o main .

#######################################################
# Reduce the image size using multi-stage builds
# We will use a distroless image to run the application
FROM gcr.io/distroless/base

# Copy the binary from the previous stage
COPY --from=base /app/main .

# Copy the static files from the previous stage
COPY --from=base /app/static ./static

# Expose the port on which the application will run
EXPOSE 8080

# Command to run the application
CMD ["./main"]

Sekarang kita mempunyai fail docker, mari kita bina dan gunakannya ke dockerhub

docker build -t pankaj892/webapp:v1 .

Kami cuba menyemak sama ada apl berfungsi seperti yang diharapkan pada mesin tempatan
larian buruh pelabuhan -p 8080:8080 pankaj892-webapp:v1

Mari tolak ke dockerhub
docker push pankaj892/webapp:v1 .

Penciptaan kelompok Kubernetes

Anda boleh membuat kluster secara tempatan menggunakan mininkube/kind atau menggunakan mana-mana penyelesaian terurus di awan. Saya akan menggunakan Elastic Kubernetes Service(EKS) daripada AWS.

Anda boleh melancarkan kluster dalam EKS menggunakan konsol atau daripada baris arahan. Saya akan menggunakan baris arahan

eksctl create cluster--instance-selector-vcpus=2 --instance-selector-memory=4 --name <name-of-cluster> --region <region-code> 

Ini hanya akan memilih jenis mesin untuk kumpulan nod yang mempunyai 2 vCPU dan memori 4gb

Penciptaan dan konfigurasi carta helm

Kami boleh menggunakan semua sumber satu demi satu tetapi sukar untuk menguruskannya kerana ia berskala di sinilah Helm hadir dan bertindak sebagai pengurus pakej untuk menguruskan semua sumber kami dengan menggunakan carta

Buat carta helm

# Start with a base image
FROM golang:1.22 as base
WORKDIR /app
COPY go.mod ./
RUN go mod download
COPY . .
RUN go build -o main .

#######################################################
# Reduce the image size using multi-stage builds
# We will use a distroless image to run the application
FROM gcr.io/distroless/base

# Copy the binary from the previous stage
COPY --from=base /app/main .

# Copy the static files from the previous stage
COPY --from=base /app/static ./static

# Expose the port on which the application will run
EXPOSE 8080

# Command to run the application
CMD ["./main"]

Helm akan membuat fail untuk kegunaan kami tetapi kami tidak memerlukan kebanyakan fail untuk projek kami.

Buat fail berikut dan tambahkannya dalam direktori pimpinan

Pengerahan

eksctl create cluster--instance-selector-vcpus=2 --instance-selector-memory=4 --name <name-of-cluster> --region <region-code> 

Perkhidmatan

helm create web-app

Masuk

# This is a sample deployment manifest file for a simple web application.
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app
        image: {{ .Values.image.repository }}:{{ .Values.image.tag }}
        ports:
        - containerPort: 8080

Kemas kini fail nilai kepada ini

# Service for the application
apiVersion: v1
kind: Service
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP
  selector:
    app: web-app
  type: ClusterIP

Bahagian helm selesai sekarang mari kita teruskan untuk menggunakan CI kami

Integrasi Berterusan (CI) dengan Tindakan Github

Tindakan Github membolehkan kami mengautomasikan proses binaan apl kami berdasarkan beberapa acara dalam repo kami seperti tolak, tarik.

Mari buat fail saluran paip kami
Fail aliran kerja disimpan dalam (.github/workflows/cicd.yml)

# Ingress resource for the application
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-app
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: web-app.local
    http:
      paths: 
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-app
            port:
              number: 80

Fail aliran kerja ini mula-mula membina imej kami daripada fail docker, kemudian menolaknya ke dockerhub dan kemudian mengemas kini teg imej dalam fail charts.yaml kami.

Menyediakan ArgoCD untuk Penghantaran Berterusan

Kami akan menggunakan argocd untuk saluran paip Cd kami kerana argocd akan dapat mengambil perubahan daripada repo git kami dan mengemas kininya dalam apl.

Mari pasang argocd pada kluster kami

kubectl mencipta ruang nama argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Untuk mengakses pelayan argocd kita perlu menukar perkhidmatan kepada jenis loadbalancer

kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'

Untuk tetingkap ini akan menjadi
kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'

Jika ia tidak berfungsi cuma edit perkhidmatan melalui kubectl dan tukar jenis kepada LoadBalancer ia sepatutnya berfungsi

Sekarang dapatkan ip perkhidmatan

kubectl dapatkan svc argocd-server -n argocd

Kami mendapat ip tetapi kami memerlukan kata laluan untuk log masuk ke argocd

kubectl dapatkan rahsia argocd-initial-admin-secret -n argocd -o jsonpath="{.data.password}" | base64 --nyahkod

Arahan ini akan mendapatkan kata laluan dan menyahkod kata laluan kerana kata laluan dikodkan dalam format base64

Selepas log masuk, klik pada Projek Baharu > Tambahkan nama untuk projek anda > Tambahkan repo supaya argocd boleh menyegerakkan repo argocd secara automatik akan mencari fail nilai dan mengambilnya selepas itu klik pada hantar

Ingress dan Pemetaan DNS

Kami membina saluran paip kami tetapi bagaimana kami mengakses aplikasi kami, anda tidak boleh meletakkan url kluster daripada EKS setiap kali untuk mengaksesnya, kami perlu menggunakan kemasukan untuk ini

Saya menggunakan Nginx Ingress daripada AWS supaya saya boleh mengakses apl

Sebarkan kemasukan pada kluster kami

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.11.1/deploy/static/provider/aws/deploy.yaml

Kini ingress digunakan dan kami perlu menambah ip kluster kami daripada EKS dalam fail hos tempatan kami untuk linux /etc/hosts untuk windows ia berada dalam C:WindowsSystem32etchosts

# Start with a base image
FROM golang:1.22 as base
WORKDIR /app
COPY go.mod ./
RUN go mod download
COPY . .
RUN go build -o main .

#######################################################
# Reduce the image size using multi-stage builds
# We will use a distroless image to run the application
FROM gcr.io/distroless/base

# Copy the binary from the previous stage
COPY --from=base /app/main .

# Copy the static files from the previous stage
COPY --from=base /app/static ./static

# Expose the port on which the application will run
EXPOSE 8080

# Command to run the application
CMD ["./main"]

Kini kami boleh mengakses apl kami di web-app.local

Kami telah melakukan semua langkah, mari menguji apl kami

Seperti yang anda lihat, url di bahagian atas ialah perkara yang kami takrifkan dalam fail hos kami

Kami telah menjalankan apl, mari tambahkan sesuatu dan komited pada repo kami supaya argocd boleh mengambil perubahan itu dan menggunakan aplikasi

Saya membuat perubahan kepada repo saya dan ini sepatutnya mencetuskan saluran paip

Saluran paip telah bermula dan selepas siap, mari lihat sama ada argocd mengambil perubahan itu

Ya, kami melihat perubahan dalam apl kami, argocd telah mengambil perubahan dan menyegerakkan apl kami dengan perubahan terkini

Jika anda berjaya sejauh ini maka tahniah!!!

Projek ini telah menjadi pengalaman pembelajaran yang hebat untuk saya terus daripada menggunakan kubernet pada AWS kepada membuat saluran paip dan penempatan saya serta menyelesaikan masalahnya. Projek ini membantu saya membuat saluran paip devops hujung ke hujung untuk aplikasi go dan ia boleh berskala berdasarkan keperluan. Saya bercadang untuk meneroka lebih banyak lagi seperti mungkin menggunakan eks clutser menggunakan susunan terraform atau cloudformation dan memperhalusi lebih banyak lagi.

Jika anda terperangkap di suatu tempat, anda boleh merujuk repo ini

Beri tahu saya dalam ulasan bagaimana pengalaman anda membina saluran paip ini.

Atas ialah kandungan terperinci Membangunkan saluran paip pada Apl Web Golang dengan Gitops dan Kubernetes. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!