Build a Golang CI pipeline on a workflow cluster - Container Service for Kubernetes

Los clústeres de flujo de trabajo son un servicio de Argo Workflows completamente administrado. Están basados en el proyecto de código abierto Argo Workflows y ofrecen escalado elástico sin sobrecarga de operación y mantenimiento. Esto permite crear pipelines de CI más sencillos, económicos y eficientes. Este tema describe cómo compilar un pipeline de CI de Golang en un clúster de flujo de trabajo mediante la caché de BuildKit y una caché de módulos de Go almacenada en NAS.

Descripción general de la solución

En un clúster de flujo de trabajo, el pipeline utiliza BuildKit para compilar y enviar imágenes de contenedor. Además, emplea BuildKit Cache para acelerar las compilaciones y una caché de Go mod almacenada en NAS para agilizar go test y go build.

Plantilla de flujo de trabajo preconfigurada

Un clúster de flujo de trabajo incluye una plantilla de flujo de trabajo de CI preconfigurada (ClusterWorkflowTemplate) llamada ci-go-v1. Esta plantilla usa BuildKit Cache y una caché de Go mod almacenada en NAS para acelerar el pipeline de CI.

Utilice la plantilla preconfigurada directamente o personalícela según su flujo de trabajo de CI.

La plantilla preconfigurada incluye los siguientes pasos:

Git clone & checkout
- Clona un repositorio de Git y extrae la rama de destino.
- Obtiene el ID del commit y lo agrega a la etiqueta de la imagen.
Run go test
- De forma predeterminada, ejecuta todos los casos de prueba del proyecto de Go.
- Use enable_test para controlar si se ejecuta este paso.
- Almacena la caché de Go mod en /pkg/mod dentro de NAS para acelerar go test y go build.
Build & push image
- Compila y envía la imagen de contenedor con BuildKit. Utiliza una caché de tipo registro para acelerar las compilaciones.
- Formato predeterminado de la etiqueta de imagen: {container_tag}-{commit_id}. Un parámetro del flujo de trabajo controla si se agrega el ID del commit.
- También envía una imagen con la etiqueta latest y sobrescribe la anterior.

Contenido completo de la plantilla de flujo de trabajo de CI preconfigurada

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 continuación se describen los parámetros de la plantilla.

Parámetro	Descripción	Ejemplo
entrypoint	La plantilla de punto de entrada.	main
repo_url	URL del repositorio de Git.	https://github.com/ivan-cai/echo-server.git
repo_name	Nombre del repositorio.	echo-server
target_branch	Rama de destino. Valor predeterminado: main.	main
container_image	Imagen que se va a compilar. Formato: <dominio de ACR EE>/<espacio de nombres de ACR EE>/<nombre del repositorio>.	test-registry.cn-hongkong.cr.aliyuncs.com/acs/echo-server
container_tag	Etiqueta de la imagen. Valor predeterminado: v1.0.0.	v1.0.0
dockerfile	Ruta del Dockerfile relativa a la raíz del proyecto. Valor predeterminado: `./Dockerfile`.	`./Dockerfile`
enable_suffix_commitid	Indica si se agrega el ID del commit a la etiqueta de la imagen. true: agrega el ID del commit. false: no agrega el ID del commit. Valor predeterminado: true.	true
enable_test	Indica si se ejecuta el paso Go Test. true: ejecuta el paso. false: no ejecuta el paso. Valor predeterminado: true.	true

Requisitos previos

Create a Container Argo Workflow Cluster.
Create a NAS file system.
Create a Container Registry Enterprise Edition instance (ACR EE).
Para los repositorios privados de Git, configure the workflow to clone the repository.

Paso 1: Crear una credencial de acceso de Container Registry

Obtain the kubeconfig file for the cluster and use kubectl to connect to the cluster.
Configure the access credential para la instancia de ACR EE. Para acceder mediante el dominio de Virtual Private Cloud (VPC), asegúrese de que el clúster y el registro estén en la misma VPC. Para acceder mediante el dominio público, configure public access control.
Reemplace USER_NAME:PASSWORD con su credencial de acceso de ACR EE. Luego, ejecute el comando para crear un Secret en el clúster de flujo de trabajo destinado a BuildKit.kubectl create secret generic docker-config --from-literal="config.json={\"auths\": {\"$repositoryDomain\": {\"auth\": \"$(echo -n USER_NAME:PASSWORD|base64)\"}}}"

El Secret y el volumen de NAS deben estar en el mismo espacio de nombres que el flujo de trabajo que envíe.

Paso 2: Montar un volumen de NAS

Un volumen de NAS comparte datos entre las tareas del flujo de trabajo, como los datos del repositorio clonado. También almacena la caché de Go mod para acelerar go test y go build.

Inicie sesión en la consola de NAS.
En el panel de navegación izquierdo, seleccione File System > File System List.
En la barra de navegación superior, seleccione el resource group y la región donde se encuentra su sistema de archivos.
En la página File System List, busque el sistema de archivos de destino y haga clic en Manage en la columna Actions.
En la página de detalles del sistema de archivos, haga clic en la pestaña Mount Targets. En la sección Mount Target, registre el punto de montaje de NAS.
Guarde el siguiente YAML como pv-nas.yaml, reemplace MOUNT_POINT con su punto de montaje de NAS y ejecute kubectl apply -f pv-nas.yaml para crear el volumen.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

Paso 3: Iniciar un flujo de trabajo

Console

Inicie sesión en la consola de Argo Workflow Clusters.
En la página Cluster Information, haga clic en la pestaña Basic Information. En la sección Common Operations, haga clic en Workflow Console (Argo).
En el panel de navegación izquierdo de la interfaz de Argo, haga clic en Cluster Workflow Templates y luego en ci-go-v1.
En la página de detalles de la plantilla, haga clic en + SUBMIT. Introduzca los parámetros obligatorios en el panel y haga clic en + SUBMIT.

Establezca los parámetros según parameter description.

En el panel Submit Workflow, establezca Entrypoint en main y especifique los siguientes parámetros:
- repo_url: la URL del repositorio de Git, por ejemplo, https://github.com/ivan-cai/echo-server.git.
- repo_name: el nombre del repositorio, por ejemplo, echo-server.
- target_branch: la rama de destino, por ejemplo, main.
- container_image: la URL de la imagen de contenedor.
- container_tag: la etiqueta de la imagen, por ejemplo, v1.0.0.
- dockerfile: la ruta del Dockerfile, por ejemplo, ./Dockerfile.
- enable_suffix_commitid: indica si se agrega el ID del commit a la etiqueta de la imagen, por ejemplo, true.
- enable_test: indica si se ejecuta el paso de prueba, por ejemplo, true.
Después de especificar los parámetros, haga clic en +SUBMIT en la parte inferior del panel para enviar el flujo de trabajo.

Una vez enviado, consulte el estado del flujo de trabajo en la página Workflows:

Tras enviar el flujo de trabajo, se muestra el DAG en la página de detalles de Workflows. Los nodos de los pasos, de arriba hacia abajo, son git-checkout-pr, run-test y build-push-image. Una marca de verificación verde en cada nodo indica que el flujo de trabajo se completó correctamente.

Argo CLI

Install the Argo CLI.

Actualice los valores de los parámetros según parameter description. Guarde el siguiente YAML como workflow.yaml y ejecute argo submit workflow.yaml para enviar el flujo de trabajo.

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