Microservices Engine:Implementar uma liberação canary de ponta a ponta com pipelines de CI/CD do Jenkins

Etapa 1: Criar as implantações

1. Faça login no console ACK. No painel de navegação à esquerda, clique em Clusters.

2. Na página Clusters, localize e clique no nome do seu cluster.

3. No painel de navegação à esquerda, escolha Workloads > Deployments.

4. Clique em Create from YAML e aplique os seguintes arquivos YAML.

spring-cloud-zuul (gateway de entrada)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-cloud-zuul
spec:
  replicas: 1
  selector:
    matchLabels:
      app: spring-cloud-zuul
  template:
    metadata:
      labels:
        app: spring-cloud-zuul
        msePilotCreateAppName: spring-cloud-zuul
    spec:
      containers:
        - name: spring-cloud-zuul
          image: registry.cn-shanghai.aliyuncs.com/yizhan/spring-cloud-zuul:1.0.1
          imagePullPolicy: Always
          ports:
            - containerPort: 20000

spring-cloud-a (versão base)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-cloud-a
spec:
  replicas: 2
  selector:
    matchLabels:
      app: spring-cloud-a
  template:
    metadata:
      labels:
        app: spring-cloud-a
        msePilotCreateAppName: spring-cloud-a
    spec:
      containers:
      - name: spring-cloud-a
        image: registry.cn-shanghai.aliyuncs.com/yizhan/spring-cloud-a:0.1-SNAPSHOT
        imagePullPolicy: Always
        ports:
        - containerPort: 20001
        livenessProbe:
          tcpSocket:
            port: 20001
          initialDelaySeconds: 10
          periodSeconds: 30

spring-cloud-b (versão base)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-cloud-b
spec:
  replicas: 2
  selector:
    matchLabels:
      app: spring-cloud-b
  strategy:
  template:
    metadata:
      labels:
        app: spring-cloud-b
        msePilotCreateAppName: spring-cloud-b
    spec:
      containers:
      - name: spring-cloud-b
        image: registry.cn-shanghai.aliyuncs.com/yizhan/spring-cloud-b:0.1-SNAPSHOT
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
        livenessProbe:
          tcpSocket:
            port: 20002
          initialDelaySeconds: 10
          periodSeconds: 30

spring-cloud-c (versão base)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-cloud-c
spec:
  replicas: 1
  selector:
    matchLabels:
      app: spring-cloud-c
  template:
    metadata:
      labels:
        app: spring-cloud-c
        msePilotCreateAppName: spring-cloud-c
    spec:
      containers:
      - name: spring-cloud-c
        image: registry.cn-shanghai.aliyuncs.com/yizhan/spring-cloud-c:0.1-SNAPSHOT
        imagePullPolicy: Always
        ports:
        - containerPort: 20003
        livenessProbe:
          tcpSocket:
            port: 20003
          initialDelaySeconds: 10
          periodSeconds: 30

nacos-server (registro de serviço) e serviço SLB

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nacos-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nacos-server
  template:
    metadata:
      labels:
        app: nacos-server
    spec:
      containers:
      - env:
        - name: MODE
          value: standalone
        image: nacos/nacos-server:v2.2.0
        imagePullPolicy: Always
        name: nacos-server
      dnsPolicy: ClusterFirst
      restartPolicy: Always

# SLB service for the spring-cloud-zuul gateway
---
apiVersion: v1
kind: Service
metadata:
  annotations:
    service.beta.kubernetes.io/alibaba-cloud-loadbalancer-spec: slb.s1.small
  name: zuul-slb
spec:
  ports:
    - port: 80
      protocol: TCP
      targetPort: 20000
  selector:
    app: spring-cloud-zuul
  type: LoadBalancer

Etapa 2: Verificar a implantação

Após implantar todas as aplicações, abra o console MSE e verifique o tráfego da Aplicação A. Todo o tráfego deve fluir para os nós untagged, sem tráfego nos nós canary.

Etapa 1: Criar um grupo de rotas

1. Faça login no console MSE e selecione uma região na barra de navegação superior.

2. No painel de navegação à esquerda, escolha Microservices Governance > Full link grayscale.

3. Clique em Create Lane Group and Lane. Se já existir um grupo de rotas no seu namespace de microsserviços, clique em + Create Lane Group.

4. Configure o grupo de rotas:

   Parâmetro	Valor
   Lane Group Name	Um nome descritivo para o grupo de rotas.
   Ingress Type	Selecione Java Microservice Gateway.
   Lane Group Traffic Entry	Selecione sua aplicação de entrada (spring-cloud-zuul).
   Lane Group Application	Selecione todas as aplicações na cadeia de chamadas.

5. Clique em OK.

Após a criação, verifique se a aplicação de entrada e as aplicações relacionadas aparecem na seção applications involved in the lane group na página Full link grayscale. Para modificar o grupo de rotas, clique em .

Etapa 2: Criar uma rota

1. Na página Full link grayscale, selecione o mesmo namespace de microsserviços do seu grupo de rotas.

2. Clique em Click to Create First Split Lane. Se já existir uma rota, clique em Create Lane.

   Importante

   Depois de configurar uma liberação canary de ponta a ponta para as aplicações, elas não oferecerão mais suporte a recursos como liberação canary e roteamento baseado em tags.

3. Configure os parâmetros da rota. As condições de roteamento aceitam os seguintes tipos de parâmetros:

   Importante

   O tráfego que não corresponder a nenhuma condição de roteamento canary será direcionado para nós sem tag na versão base.

   Parâmetro	Descrição
   Add Node Tag	Adicione uma tag (por exemplo, gray) para identificar os nós canary.
   Enter lane information	Defina a Lane Tag e use Confirm Matching Relationship para verificar a contagem de nós com tag.
   Configure Routing and Canary Release Rules	Defina as condições de roteamento (consulte a tabela a seguir).

   Tipo de parâmetro	Descrição
   Parameter	Parâmetro de requisição
   Header	Cabeçalho de requisição
   Cookie	Cookie HTTP
   Body Content	Corpo da requisição formatado em JSON

4. Clique em OK.

Após a configuração, o gateway roteia o tráfego da seguinte forma:

• O tráfego que não corresponde às regras canary vai para a versão base.

• O tráfego que corresponde às regras canary vai para a versão canary.

Etapa 1: Configurar credenciais do registro de imagens

Crie um Kubernetes Secret para que o Jenkins possa enviar imagens ao seu registro de contêiner. Após gerar um arquivo config.json com suas credenciais de registro, execute:

kubectl create secret generic jenkins-docker-cfg -n jenkins --from-file=/root/.docker/config.json

Para obter detalhes, consulte Configurar o Jenkins para criar um pipeline de entrega de aplicações.

Etapa 2: Criar o pipeline

1. No painel do Jenkins, clique em New Item no painel de navegação à esquerda.

2. Insira o nome do pipeline, selecione pipeline como tipo e clique em OK.

3. Na página de configuração, clique na aba Pipeline e defina o seguinte:

   • Definition: Selecione Pipeline script from SCM.

   • SCM: Selecione Git.

   • Repository URL: Insira a URL do seu repositório Git. Este tutorial usa https://github.com/aliyun/alibabacloud-microservice-demo/tree/master/mse-simple-demo. > Nota: Se sua instância do Jenkins não conseguir acessar o GitHub, use um espelho no Gitee.

   • Script Path: Insira Jenkinsfile.

4. Clique em Save.

O Jenkinsfile define quatro estágios de pipeline:

#!groovy
pipeline {

    // Build agent label
    agent{
        node{
          label 'slave-pipeline'
        }
    }

    // Image registry path, assembled from parameters
    environment{
        IMAGE = sh(returnStdout: true,script: 'echo registry.$image_region.aliyuncs.com/$image_namespace/$image_reponame:$image_tag').trim()
        BRANCH =  sh(returnStdout: true,script: 'echo $branch').trim()
    }
    options {
        // Keep a maximum of 10 builds
        buildDiscarder(logRotator(numToKeepStr: '10'))
    }

    parameters {
        string(name: 'image_region', defaultValue: 'cn-shanghai')
        string(name: 'image_namespace', defaultValue: 'yizhan')
        string(name: 'image_reponame', defaultValue: 'spring-cloud-a')
        string(name: 'image_tag', defaultValue: 'gray')
        string(name: 'branch', defaultValue: 'master')
        string(name: 'number_of_pods', defaultValue: '2')
    }

    stages {

        stage('Code packaging') {
            steps{
                container("maven") {
                    echo "Image building......"
                    sh "cd A && mvn clean package"
                }

            }
        }

        stage('Image building and releasing'){
          steps{
              container("kaniko") {
                  sh "kaniko -f `pwd`/A/Dockerfile -c `pwd`/A --destination=${IMAGE} --skip-tls-verify"
              }
          }
        }

        stage('Canary deployment') {
            steps{
                container('kubectl') {
                    echo "Canary deployment......"
                    sh "cd A && sed -i -E \"s/${env.image_reponame}:.+/${env.image_reponame}:${env.image_tag}/\" A-gray-deployment.yaml"
                    sh "cd A && sed -i -E \"s/replicas:.+/replicas: ${env.number_of_pods}/\" A-gray-deployment.yaml"
                    sh "kubectl apply -f A/A-gray-deployment.yaml -n default"
                }
            }
        }

        stage('Completing canary deployment') {
            input {
                message "Are you sure that you want to enable a full release"
                ok "OK"
                parameters {
                    string(name: 'continue', defaultValue: 'true', description: 'true indicates a full release, and false indicates a rollback')
                }
            }
            steps{
                script {
                    env.continue = sh (script: 'echo ${continue}', returnStdout: true).trim()
                    if (env.continue.equals('true')) {
                        container('kubectl') {
                            echo "Full releasing......"
                            sh "cd A && sed -i -E \"s/${env.image_reponame}:.+/${env.image_reponame}:${env.image_tag}/\" A-deployment.yaml"
                            sh "cd A && sed -i -E \"s/replicas:.+/replicas: ${env.number_of_pods}/\" A-deployment.yaml"
                            sh "kubectl apply -f A/A-deployment.yaml -n default"
                        }
                    } else {
                        echo 'Rolling back'
                    }
                    container('kubectl') {
                        sh "kubectl delete -f A/A-gray-deployment.yaml -n default"
                    }
                }
            }
        }
    }
}

Estágios do pipeline:

Parâmetros do pipeline:

Etapa 1: Compilar o pipeline

1. No painel do Jenkins, clique em ao lado do nome do pipeline.

2. Clique em Build.

   Nota

   A primeira compilação extrai a configuração do repositório Git e inicializa o pipeline. Se ocorrer um erro, clique em Build with Parameters, configure os parâmetros e compile novamente.

3. Aguarde a conclusão dos estágios Code packaging, Image building and releasing e Canary deployment. O pipeline pausa no estágio Completing canary deployment, aguardando sua confirmação.

Etapa 2: Verificar a implantação canary

1. Faça login no console ACK. Acesse o seu cluster e escolha Workloads > Deployments.

2. Confirme se a implantação spring-cloud-a-gray existe e usa a imagem spring-cloud-a:gray.

3. Acesse Network > Services, selecione seu namespace e clique no public endpoint do serviço zuul-slb.

4. Teste o roteamento de tráfego: Tráfego normal (sem cabeçalho canary) -- roteado para a versão base: Saída esperada: Tráfego canary (com tag canary) -- roteado para o nó canary: Saída esperada:

      curl http://<zuul-slb-public-endpoint>/A/a

      A[10.4.XX.XX] -> B[10.4.XX.XX] -> C[10.4.XX.XX]%

      curl http://<zuul-slb-public-endpoint>/A/a?name=xiaoming

      Agray[10.4.XX.XX] -> B[10.4.XX.XX] -> C[10.4.XX.XX]%

5. No console MSE, abra a página de detalhes da aplicação e confirme se o tráfego canary está sendo roteado para o nó canary.