Build a Golang CI pipeline on a workflow cluster - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

Os clusters de workflow são um service Argo Workflows totalmente gerenciado, desenvolvido com base no projeto open source Argo Workflows. Eles oferecem dimensionamento elástico e zero sobrecarga de O&M, permitindo pipelines de CI mais simples, econômicos e eficientes. Este tópico descreve como criar um pipeline de CI Golang em um workflow cluster utilizando cache do BuildKit e cache de módulos Go armazenado no NAS.

Visão geral da solução

Em um workflow cluster, o pipeline utiliza o BuildKit para compilar e enviar imagens de contêiner, o BuildKit Cache para acelerar as compilações e o cache de módulos Go no NAS para agilizar os comandos go test e go build.

Modelo de workflow predefinido

Um workflow cluster inclui um modelo de workflow de CI predefinido (ClusterWorkflowTemplate) chamado ci-go-v1. Esse modelo usa o BuildKit Cache e o cache de módulos Go no NAS para acelerar o pipeline de CI.

Use o modelo predefinido diretamente ou personalize-o conforme a necessidade do seu workflow de CI.

O modelo predefinido inclui as seguintes etapas:

Git clone & checkout
- Clona um repositório git e faz o checkout da branch de destino.
- Obtém o ID do commit e o anexa à tag da imagem.
Execute go test
- Executa todos os casos de teste no projeto Go por padrão.
- Utilize enable_test para controlar a execução desta etapa.
- Armazena o cache de módulos Go em /pkg/mod no NAS, acelerando o go test e o go build.
Build & push image
- Compila e envia a imagem de contêiner com o BuildKit, usando cache do tipo registry para acelerar as compilações.
- Formato padrão da tag da imagem: {container_tag}-{commit_id}. Um parâmetro do workflow controla se o ID do commit será anexado.
- Envia também uma imagem com a tag latest, substituindo a anterior.

Conteúdo completo do modelo de workflow de CI predefinido

apiVersion: argoproj.io/v1alpha1
kind: ClusterWorkflowTemplate
metadata:
  name: ci-go-v1
spec:
  entrypoint: main
  volumes:
  - name: run-test
    emptyDir: {}
  - name: workdir
    persistentVolumeClaim:
      claimName: pvc-nas
  - name: docker-config
    secret:
      secretName: docker-config
  arguments:
    parameters:
    - name: repo_url
      value: ""
    - name: repo_name
      value: ""
    - name: target_branch
      value: "main"
    - name: container_image
      value: ""
    - name: container_tag
      value: "v1.0.0"
    - name: dockerfile
      value: "./Dockerfile"
    - name: enable_suffix_commitid
      value: "true"
    - name: enable_test
      value: "true"
  templates:
    - name: main
      dag:
        tasks:
          - name: git-checkout-pr
            inline:
              container:
                image: alpine:latest
                command:
                  - sh
                  - -c
                  - |
                    set -eu
                    
                    apk --update add git
          
                    cd /workdir
                    echo "Start to Clone " {{workflow.parameters.repo_url}}
                    git -C "{{workflow.parameters.repo_name}}" pull || git clone {{workflow.parameters.repo_url}} 
                    cd {{workflow.parameters.repo_name}}
          
                    echo "Start to Checkout target branch" {{workflow.parameters.target_branch}}
                    git checkout --track origin/{{workflow.parameters.target_branch}} || git checkout {{workflow.parameters.target_branch}}
                    git pull
                    
                    echo "Get commit id" 
                    git rev-parse --short origin/{{workflow.parameters.target_branch}} > /workdir/{{workflow.parameters.repo_name}}-commitid.txt
                    commitId=$(cat /workdir/{{workflow.parameters.repo_name}}-commitid.txt)
                    echo "Commit id is got: "$commitId
                                        
                    echo "Git Clone and Checkout Complete."
                volumeMounts:
                - name: "workdir"
                  mountPath: /workdir
                resources:
                  requests:
                    memory: 1Gi
                    cpu: 1
              activeDeadlineSeconds: 1200
          - name: run-test
            when: "{{workflow.parameters.enable_test}} == true"
            inline: 
              container:
                image: golang:1.22-alpine
                command:
                  - sh
                  - -c
                  - |
                    set -eu
                    
                    if [ ! -d "/workdir/pkg/mod" ]; then
                      mkdir -p /workdir/pkg/mod
                      echo "GOMODCACHE Directory /pkg/mod is created"
                    fi
                    
                    export GOMODCACHE=/workdir/pkg/mod
                    
                    cp -R /workdir/{{workflow.parameters.repo_name}} /test/{{workflow.parameters.repo_name}} 
                    echo "Start Go Test..."
                    
                    cd /test/{{workflow.parameters.repo_name}}
                    go test -v ./...
                    
                    echo "Go Test Complete."
                volumeMounts:
                - name: "workdir"
                  mountPath: /workdir
                - name: run-test
                  mountPath: /test
                resources:
                  requests:
                    memory: 4Gi
                    cpu: 2
              activeDeadlineSeconds: 1200
            depends: git-checkout-pr    
          - name: build-push-image
            inline: 
              container:
                image: moby/buildkit:v0.13.0-rootless
                command:
                  - sh
                  - -c
                  - |         
                    set -eu
                     
                    tag={{workflow.parameters.container_tag}}
                    if [ {{workflow.parameters.enable_suffix_commitid}} == "true" ]
                    then
                      commitId=$(cat /workdir/{{workflow.parameters.repo_name}}-commitid.txt)
                      tag={{workflow.parameters.container_tag}}-$commitId
                    fi
                    
                    echo "Image Tag is: "$tag
                    echo "Start to Build And Push Container Image"
                    
                    cd /workdir/{{workflow.parameters.repo_name}}
                    
                    buildctl-daemonless.sh build \
                    --frontend \
                    dockerfile.v0 \
                    --local \
                    context=. \
                    --local \
                    dockerfile=. \
                    --opt filename={{workflow.parameters.dockerfile}} \
                    --opt build-arg:GOPROXY=http://goproxy.cn,direct \
                    --output \
                    type=image,\"name={{workflow.parameters.container_image}}:${tag},{{workflow.parameters.container_image}}:latest\",push=true,registry.insecure=true \
                    --export-cache mode=max,type=registry,ref={{workflow.parameters.container_image}}:buildcache \
                    --import-cache type=registry,ref={{workflow.parameters.container_image}}:buildcache
                    
                    echo "Build And Push Container Image {{workflow.parameters.container_image}}:${tag} and {{workflow.parameters.container_image}}:latest Complete."
                env:
                  - name: BUILDKITD_FLAGS
                    value: --oci-worker-no-process-sandbox
                  - name: DOCKER_CONFIG
                    value: /.docker
                volumeMounts:
                  - name: workdir
                    mountPath: /workdir
                  - name: docker-config
                    mountPath: /.docker
                securityContext:
                  seccompProfile:
                    type: Unconfined
                  runAsUser: 1000
                  runAsGroup: 1000
                resources:
                  requests:
                    memory: 4Gi
                    cpu: 2
              activeDeadlineSeconds: 1200
            depends: run-test

A tabela a seguir descreve os parâmetros do modelo.

Parâmetro	Descrição	Exemplo
entrypoint	O template de entrypoint.	main
repo_url	URL do repositório git.	https://github.com/ivan-cai/echo-server.git
repo_name	Nome do repositório.	echo-server
target_branch	Branch de destino. Padrão: main.	main
container_image	Imagem a ser compilada. Formato: <domínio ACR EE>/<namespace ACR EE>/<nome do repositório>.	test-registry.cn-hongkong.cr.aliyuncs.com/acs/echo-server
container_tag	Tag da imagem. Padrão: v1.0.0.	v1.0.0
dockerfile	Caminho do Dockerfile relativo à raiz do projeto. Padrão: `./Dockerfile`.	`./Dockerfile`
enable_suffix_commitid	Define se o ID do commit deve ser anexado à tag da imagem. true: Anexa o ID do commit. false: Não anexa o ID do commit. Padrão: true.	true
enable_test	Define se a etapa Go Test deve ser executada. true: Executa a etapa. false: Não executa a etapa. Padrão: true.	true

Pré-requisitos

Crie um Container Argo Workflow Cluster.
Crie um sistema de arquivos NAS.
Crie uma instância do Container Registry Enterprise Edition (ACR EE).
Para repositórios git privados, configure the workflow to clone the repository.

Etapa 1: Criar uma credencial de acesso ao Container Registry

Obtain the kubeconfig file for the cluster and use kubectl to connect to the cluster.
Configure the access credential para a instância do ACR EE. Para acesso via domínio de Virtual Private Cloud (VPC), garanta que o cluster e o registro estejam na mesma VPC. Para acesso via domínio público, configure public access control.
Substitua USER_NAME:PASSWORD pela sua credencial de acesso ao ACR EE e execute o comando para criar um Secret no workflow cluster destinado ao BuildKit.kubectl create secret generic docker-config --from-literal="config.json={\"auths\": {\"$repositoryDomain\": {\"auth\": \"$(echo -n USER_NAME:PASSWORD|base64)\"}}}"

O Secret e o volume NAS devem estar no mesmo namespace do workflow que você enviar.

Etapa 2: Montar um volume NAS

Um volume NAS compartilha dados entre as tarefas do workflow, como os dados clonados do repositório, e armazena o cache de módulos Go para acelerar o go test e o go build.

Faça login no NAS console.
No painel de navegação à esquerda, escolha File System > File System List.
Na barra de navegação superior, selecione o grupo de recursos e a região onde seu sistema de arquivos está localizado.
Na página File System List, localize o sistema de arquivos desejado e clique em Manage na coluna Actions.
Na página de detalhes do sistema de arquivos, clique na aba Mount Targets. Na seção Mount Target, anote o ponto de montagem do NAS.
Salve o YAML abaixo como pv-nas.yaml, substitua MOUNT_POINT pelo seu ponto de montagem do NAS e execute kubectl apply -f pv-nas.yaml para criar o volume.apiVersion: v1

kind: PersistentVolume

metadata:

name: pv-nas

labels:

alicloud-pvname: pv-nas

spec:

capacity:

storage: 100Gi

accessModes:
- ReadWriteMany
csi:

driver: nasplugin.csi.alibabacloud.com

volumeHandle: pv-nas # Must be the same as the PV name.

volumeAttributes:

server: MOUNT_POINT

path: "/"

mountOptions:
- nolock,tcp,noresvport
- vers=3
---

kind: PersistentVolumeClaim

apiVersion: v1

metadata:

name: pvc-nas

spec:

accessModes:
- ReadWriteMany
resources:

requests:

storage: 100Gi

selector:

matchLabels:

alicloud-pvname: pv-nas

Etapa 3: Iniciar um workflow

Console

Faça login no Argo Workflow Clusters console.
Na página Cluster Information, clique na aba Basic Information. Na seção Common Operations, clique em Workflow Console (Argo).
No painel de navegação à esquerda da interface do Argo, clique em Cluster Workflow Templates e, em seguida, clique em ci-go-v1.
Na página de detalhes do modelo, clique em + SUBMIT. Insira os parâmetros necessários no painel e clique em + SUBMIT.

Defina os parâmetros com base no parameter description.

No painel Submit Workflow, defina Entrypoint como main e especifique os seguintes parâmetros:
- repo_url: a URL do repositório git, por exemplo https://github.com/ivan-cai/echo-server.git.
- repo_name: o nome do repositório, por exemplo echo-server.
- target_branch: a branch de destino, por exemplo main.
- container_image: a URL da imagem de contêiner.
- container_tag: a tag da imagem, por exemplo v1.0.0.
- dockerfile: o caminho para o Dockerfile, por exemplo ./Dockerfile.
- enable_suffix_commitid: define se o ID do commit deve ser anexado à tag da imagem, por exemplo true.
- enable_test: define se a etapa de teste deve ser executada, por exemplo true.
Após especificar os parâmetros, clique em +SUBMIT na parte inferior do painel para enviar o workflow.

Após o envio, visualize o status do workflow na página Workflows:

Depois que o workflow for enviado, o DAG do workflow será exibido na página de detalhes de Workflows. Os nós das etapas, de cima para baixo, são git-checkout-pr, run-test e build-push-image. Uma marca de verificação verde em cada nó indica que o workflow foi concluído com sucesso.

Argo CLI

Instale o Argo CLI.

Atualize os valores dos parâmetros com base no parameter description. Salve o YAML abaixo como workflow.yaml e execute argo submit workflow.yaml para enviar o workflow.

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: ci-go-v1-
  labels:
    workflows.argoproj.io/workflow-template: ackone-ci
spec:
  arguments:
    parameters:
    - name: repo_url
      value: https://github.com/ivan-cai/echo-server.git
    - name: repo_name
      value: echo-server
    - name: target_branch
      value: main
    - name: container_image
      value: "test-registry.cn-hongkong.cr.aliyuncs.com/acs/echo-server"
    - name: container_tag
      value: "v1.0.0"
    - name: dockerfile
      value: ./Dockerfile
    - name: enable_suffix_commitid
      value: "true"
    - name: enable_test
      value: "true"
  workflowTemplateRef:
    name: ci-go-v1
    clusterScope: true