Get in touch
or send us a question?
CONTACT

DevOps Project: CI/CD Pipeline cho Microservices-Based Application dựa trên Kubernetes

Tổng quan về Project này

Project này sẽ hướng dẫn bạn cách để thiết lập CI/CD Pipeline đầu cuối cho ứng dụng dựa trên dịch vụ vi mô (Microservices – Based Application). Bạn sẽ học cách xây dựng, triển khai, giám sát và ghi nhật ký kiến trúc Microservices bằng Jenkins, Docker, Kubernetes, Prometheus, Grafana và ELK Stack.

Kiến trúc của Project

Dự án bao gồm các thành phần sau:

  • Dịch vụ vi mô (Microservices): Bao gồm Dịch vụ người dùng, Dịch vụ đặt hàng, Dịch vụ thanh toán.
  • Jenkins: Dùng để tích hợp và triển khai liên tục.
  • Docker: Dùng để chứa các dịch vụ.
  • Kubernetes: Để điều phối việc triển khai.
  • Prometheus & Grafana: Để giám sát và quan sát.
  • ELK Stack: Để ghi nhật ký và quản lý nhật ký.

Bước 1: Thiết lập kho lưu trữ Microservices

1. Tạo kho lưu trữ

Bạn cần tạo ba kho lưu trữ Git riêng biệt cho mỗi một Microservices:

  • Dịch vụ người dùng (user-services)
  • Dịch vụ đặt hàng (order-services)
  • Dịch vụ thanh toán (payment-services)

2. Cấu trúc kho lưu trữ

Mỗi kho lưu trữ phải có cấu trúc thư mục sau:

- src/
  - main/
    - java/
    - resources/
- Dockerfile
- Jenkinsfile
- pom.xml (for Maven projects) or package.json (for Node.js projects)

Cấu trúc này đảm bảo tính nhất quán giữa các dịch vụ và tạo điều kiện thuận lợi cho quy trình CI/CD sau này.

3. Sao chép kho lưu trữ

Để bắt đầu, hãy sao chép từng kho lưu trữ vào máy cục bộ của bạn:

git clone https://github.com/SelimHorri/ecommerce-microservice-backend-app/user-service
git clone https://github.com/SelimHorri/ecommerce-microservice-backend-app/order-service
git clone https://github.com/SelimHorri/ecommerce-microservice-backend-app/payment-service

Bước 2: Triển khai CI/CD với Jenkins

1. Thiết lập Jenkins

Jenkins là thành phần chính trong quy trình CI/CD của Project này. Bạn hãy thực hiện theo các bước sau để thiết lập:

Cài đặt Jenkin:

 wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
   sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
   sudo apt-get update
   sudo apt-get install jenkins

Khởi động Jenkins:

   sudo systemctl start jenkins

Truy cập Jenkins: Mở http://localhost:8080 trong trình duyệt của bạn để truy cập bảng điều khiển Jenkins.

Cài đặt các plugin cần thiết:

  • Điều hướng đến Jenkins Manage > Plugin Manage.
  • Cài đặt các plugin sau:
  • Plugin Docker Pipeline
  • Kubernetes Plugin
  • Git Plugin

2. Tạo JenkinsFile cho CI/CD

Mỗi một Microservices sẽ có một JenkinsFile để xác định quy trình CI/CD.

Ví dụ JenkinsFile:

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git 'https://github.com/yourusername/user-service.git'
            }
        }
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Docker Build & Push') {
            steps {
                script {
                    dockerImage = docker.build("yourdockerhub/user-service:${env.BUILD_ID}")
                    docker.withRegistry('https://index.docker.io/v1/', 'dockerhub-credentials') {
                        dockerImage.push("${env.BUILD_ID}")
                        dockerImage.push("latest")
                    }
                }
            }
        }
        stage('Deploy to Kubernetes') {
            steps {
                sh 'kubectl apply -f kubernetes/deployment.yaml'
            }
        }
    }
}

Tính năng JenkinsFile này sẽ tự động hóa quá trình xây dựng, tạo hình ảnh Docker và triển khai lên Kubernetes.

Bước 3: Container hóa các Microservices bằng Docker

1. Tạo Dockerfile cho từng dịch vụ

Mỗi một Microservices đều yêu cầu có một Dockerfile giúp xác định cách xây dựng hình ảnh container.

Ví dụ về Dockerfile dựa trên Java:

# Use an official Java runtime as a parent image
FROM openjdk:11-jre-slim

# Set the working directory in the container
WORKDIR /app

# Copy the jar file into the container
COPY target/user-service.jar /app/user-service.jar

# Run the jar file
ENTRYPOINT ["java", "-jar", "/app/user-service.jar"]

# Expose the port the application runs on
EXPOSE 8080

2. Xây dựng và đẩy hình ảnh Docker

Sau khi tạo Dockerfile, hãy xây dựng và đẩy hình ảnh Docker lên Docker Hub.

docker build -t yourdockerhub/user-service:latest .
docker push yourdockerhub/user-service:latest

Lặp lại quá trình này cho order-service và payment-service.

Bước 4: Triển khai lên Kubernetes

1. Thiết lập cụm Kubernetes (Cluster)

Bạn có thể chọn triển khai ứng dụng trên cụm Kubernetes cục bộ bằng Minikube hoặc trên AWS EKS cho môi trường sản xuất.

Cài đặt Minikube:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
minikube start

Thiết lập EKS (yêu cầu AWS CLI):

aws eks --region us-west-2 create-cluster --name DevOpsCluster --role-arn arn:aws:iam::YOUR_ACCOUNT_ID:role/EKSRole --resources-vpc-config subnetIds=subnet-0123456789abcdef0,subnet-abcdef0123456789

2. Tạo Kubernetes Manifest

Tạo bản kê khai dịch vụ và triển khai cho từng Microservices.

Ví dụ về bản kê khai triển khai (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: yourdockerhub/user-service:latest
        ports:
        - containerPort: 8080

Ví dụ về Service Manifest (service.yaml):

apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  type: NodePort
  selector:
    app: user-service
  ports:
    - port: 8080
      targetPort: 8080


 nodePort: 30001

3. Áp dụng Manifest

Triển khai các Microservices vào cụm Kubernetes bằng các lệnh sau:

kubectl apply -f kubernetes/deployment.yaml
kubectl apply -f kubernetes/service.yaml

Lặp lại quá trình này cho order-service và payment-service.

Bước 5: Triển khai giám sát bằng Prometheus và Grafana

1. Cài đặt Prometheus và Grafana

Để cài đặt Prometheus và Grafana, hãy sử dụng Helm, trình quản lý gói cho Kubernetes.

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo add grafana https://grafana.github.io/helm-charts
helm install prometheus prometheus-community/prometheus
helm install grafana grafana/grafana

2. Cấu hình Prometheus để thu thập số liệu Kubernetes

Cấu hình Prometheus để thu thập số liệu từ cụm Kubernetes bằng cách chỉnh sửa tệp prometheus.yml:

scrape_configs:
  - job_name: 'kubernetes'
    kubernetes_sd_configs:
      - role: node

3. Truy cập bảng điều khiển Grafana

Truy cập Grafana tại http://localhost:3000 và đăng nhập bằng thông tin đăng nhập mặc định admin/admin. Nhập Prometheus làm nguồn dữ liệu và tạo bảng thông tin để trực quan hóa số liệu.

Bước 6: Triển khai ghi nhật ký với ELK Stack

1. Triển khai ELK Stack trên Kubernetes

Triển khai ELK Stack bằng Helm:

helm repo add elastic https://helm.elastic.co
helm install elasticsearch elastic/elasticsearch
helm install kibana elastic/kibana
helm install logstash elastic/logstash

2. Cấu hình Logstash để thu thập Nhật ký Kubernetes

Tạo tệp cấu hình Logstash để thu thập nhật ký từ Kubernetes:

input {
  beats {
    port => 5044
  }
}

output {
  elasticsearch {
    hosts => ["http://elasticsearch:9200"]
    index => "%{[@metadata][beat]}-%{+YYYY.MM.dd}"
  }
}

3. Truy cập Bảng điều khiển Kibana

Truy cập Kibana tại http://localhost:5601 và trực quan hóa các bản ghi được thu thập từ Kubernetes.

Kết luận

Vậy là trong Project này, bạn đã học được cách thiết lập một CI/CD Pipeline đầu cuối cho một ứng dụng dựa trên Microservices, triển khai nó lên Kubernetes và giám sát nó bằng Prometheus, Grafana và ELK Stack. Thiết lập này có khả năng mở rộng cao và cung cấp nền tảng vững chắc cho bất kỳ kiến trúc Microservices nào. Cảm ơn các bạn đã theo dõi bài viết vừa rồi.

Nguồn: https://viblo.asia/p/devops-project-cicd-pipeline-cho-microservices-based-application-dua-tren-kubernetes-aAY4q1d54Pw