Clone a private Git repository in a CI pipeline - Container Service for Kubernetes

Clone repositorios Git privados en pipelines de CI de ACK One mediante artefactos de Git o variables de entorno.

Existen tres métodos disponibles.

Requisitos previos

Asegúrese de contar con lo siguiente:

Un pipeline de CI de Argo Workflows para Golang configurado en un clúster de flujos de trabajo de ACK One.
Credenciales para el repositorio Git privado: nombre de usuario y contraseña (o token), o bien una clave SSH.

Elegir un método

Método	Autenticación	Cuándo utilizarlo
Clone with Git artifacts (username and password)	Nombre de usuario + contraseña o token	Repositorios HTTPS; credenciales ya gestionadas como tokens
Clone with Git artifacts (SSH key)	Clave privada SSH	URL de repositorio en formato SSH; se prefiere autenticación basada en claves
Clone with environment variable credentials	Nombre de usuario + contraseña o token mediante variables de entorno	Configuración más sencilla sin tarea DAG; flujos de trabajo de una sola tarea

Todos los métodos requieren un Secret de Kubernetes llamado git-creds para almacenar las credenciales del repositorio. Cree primero el Secret y luego aplique la plantilla elegida.

Almacenar credenciales en el clúster de flujos de trabajo

Cree un Secret llamado git-creds en su clúster de flujos de trabajo para guardar el nombre de usuario, la contraseña (o token) y la clave SSH del repositorio.

Reemplace los marcadores de posición con sus valores reales:

Marcador de posición	Descripción	Ejemplo
`${username}`	Su nombre de usuario del repositorio Git	`demo`
`${password or token}`	Su contraseña o token de acceso personal. GitHub y proveedores similares requieren tokens en lugar de contraseñas.	`ghp_GePB****************d407`
`${ssh private key path}`	Ruta local a su archivo de clave privada SSH	`$HOME/.ssh/id_rsa`

kubectl create secret generic git-creds \
  --from-literal="username=${username}" \
  --from-literal="password=${password or token}" \
  --from-file=ssh-private-key=${ssh private key path}

# Example:
# kubectl create secret generic git-creds \
#   --from-literal="username=demo" \
#   --from-literal="password=ghp_GePB****************d407" \
#   --from-file=ssh-private-key=$HOME/.ssh/id_rsa

Para la autenticación SSH, genere un par de claves y agregue primero la clave pública a su repositorio Git. Consulte la documentación de su proveedor de Git: GitHub | GitLab .

Clonar con artefactos de Git (nombre de usuario y contraseña)

La plantilla agrega una tarea git-clone que lee username y password del Secret git-creds, como dependencia de git-checkout-pr.

Todos los métodos conservan únicamente la tarea git-checkout-pr de predefined workflow template. El script de shell en el parámetro command de git-checkout-pr permanece sin cambios.

Aplicar la plantilla de flujo de trabajo

Aplique el siguiente ClusterWorkflowTemplate a su clúster de flujos de trabajo:

apiVersion: argoproj.io/v1alpha1
kind: ClusterWorkflowTemplate
metadata:
  name: ci-git-artifact
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"
  templates:
    - name: main
      dag:
        tasks:
          - name: git-clone
            arguments:
              artifacts:
              - name: git-repo
                path: /workdir
                git:
                  repo: "{{arguments.parameters.repo_url}}"
                  revision: main
                  usernameSecret:
                    name: git-creds
                    key: username
                  passwordSecret:
                    name: git-creds
                    key: password
                  sshPrivateKeySecret:
                    name: git-creds
                    key: ssh-private-key
            inline:
              container:
                image: golang:1.10
                command:
                - sh
                - -c
                - |
                  cd {{workflow.parameters.repo_name}}
                  git status && ls
                workingDir: /workdir
                volumeMounts:
                - name: "workdir"
                  mountPath: /workdir
          - 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 {{workflow.parameters.target_branch}}

                    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
            depends: git-clone

Enviar el flujo de trabajo

Establezca los parámetros del flujo de trabajo para que coincidan con la configuración de su pipeline de CI y, a continuación, envíe el flujo de trabajo.

Clonar con artefactos de Git (clave SSH)

Este método es similar al anterior, con dos diferencias:

La tarea git-clone lee únicamente ssh-private-key del Secret git-creds.
El parámetro repo_url debe estar en formato SSH. Ejemplo: git@github.com:ivan-cai/gitops-demo-private.git.

Aplicar la plantilla de flujo de trabajo

Aplique el siguiente ClusterWorkflowTemplate a su clúster de flujos de trabajo:

apiVersion: argoproj.io/v1alpha1
kind: ClusterWorkflowTemplate
metadata:
  name: ci-git-artifact-sshkey
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"
  templates:
    - name: main
      dag:
        tasks:
          - name: git-clone
            arguments:
              artifacts:
              - name: git-repo
                path: /workdir
                git:
                  repo: "{{arguments.parameters.repo_url}}"
                  revision: main
                  sshPrivateKeySecret:
                    name: git-creds
                    key: ssh-private-key
            inline:
              container:
                image: golang:1.10
                command:
                - sh
                - -c
                - |
                  cd {{workflow.parameters.repo_name}}
                  git status && ls
                workingDir: /workdir
                volumeMounts:
                - name: "workdir"
                  mountPath: /workdir
          - 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 {{workflow.parameters.target_branch}}

                    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
            depends: git-clone

Enviar el flujo de trabajo

Establezca repo_url en formato SSH. Ejemplo: git@github.com:ivan-cai/gitops-demo-private.git .

Clonar con credenciales de variables de entorno

No se requiere una tarea DAG git-clone por separado. La tarea git-checkout-pr integra las credenciales desde variables de entorno:

git clone https://${GIT_USER}:${GIT_TOKEN}@github.com/${GITHUB_REPOSITORY}

La tarea lee las credenciales del Secret git-creds mediante dos variables de entorno:

Variable de entorno	Campo del Secret
`GIT_USER`	`username`
`GIT_TOKEN`	`password`

Aplicar la plantilla de flujo de trabajo

Aplique el siguiente ClusterWorkflowTemplate a su clúster de flujos de trabajo:

apiVersion: argoproj.io/v1alpha1
kind: ClusterWorkflowTemplate
metadata:
  name: ci-git
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"
  templates:
    - name: main
      dag:
        tasks:
          - name: git-checkout-pr
            inline:
              container:
                image: alpine:latest
                env:
                - name: GIT_USER
                  valueFrom:
                    secretKeyRef:
                      name: git-creds
                      key: username
                - name: GIT_TOKEN
                  valueFrom:
                    secretKeyRef:
                      name: git-creds
                      key: password
                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 https://$GIT_USER:$GIT_TOKEN@{{workflow.parameters.repo_url}}
                    cd {{workflow.parameters.repo_name}}

                    echo "Start to Checkout target branch" {{workflow.parameters.target_branch}}
                    git checkout {{workflow.parameters.target_branch}}

                    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

Enviar el flujo de trabajo

Proporcione la URL directa del repositorio para repo_url . Omita el prefijo https:// , ya que la plantilla lo antepone automáticamente.

Siguientes pasos

Crear pipelines de CI para proyectos Golang en clústeres de flujos de trabajo