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

Clonez des dépôts Git privés dans les pipelines CI ACK One à l'aide d'artefacts Git ou de variables d'environnement.

Trois méthodes sont disponibles.

Prérequis

Assurez-vous de disposer des éléments suivants :

Un pipeline CI Argo Workflows pour Golang configuré dans un cluster de workflows ACK One.
Les identifiants du dépôt Git privé : un nom d'utilisateur et un mot de passe (ou jeton), ou une clé SSH.

Choisir une méthode

Méthode	Authentification	Quand l'utiliser
Cloner avec des artefacts Git (nom d'utilisateur et mot de passe)	Nom d'utilisateur + mot de passe ou jeton	Dépôts HTTPS ; identifiants déjà gérés sous forme de jetons
Cloner avec des artefacts Git (clé SSH)	Clé privée SSH	URLs de dépôt au format SSH ; authentification par clé privilégiée
Cloner avec des identifiants via des variables d'environnement	Nom d'utilisateur + mot de passe ou jeton via des variables d'environnement	Configuration plus simple sans tâche DAG ; workflows à tâche unique

Toutes les méthodes nécessitent un Secret Kubernetes nommé git-creds pour les identifiants du dépôt. Créez d'abord le Secret, puis appliquez le modèle choisi.

Stocker les identifiants dans le cluster de workflows

Créez un Secret nommé git-creds dans votre cluster de workflows pour y stocker le nom d'utilisateur, le mot de passe (ou jeton) et la clé SSH du dépôt.

Remplacez les espaces réservés par vos valeurs réelles :

Espace réservé	Description	Exemple
`${username}`	Votre nom d'utilisateur pour le dépôt Git	`demo`
`${password or token}`	Votre mot de passe ou jeton d'accès personnel. GitHub et d'autres fournisseurs similaires exigent des jetons plutôt que des mots de passe.	`ghp_GePB****************d407`
`${ssh private key path}`	Chemin local vers votre fichier de clé privée 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

Pour l'authentification SSH, générez une paire de clés et ajoutez la clé publique à votre dépôt Git. Consultez la documentation de votre fournisseur Git : GitHub | GitLab .

Cloner avec des artefacts Git (nom d'utilisateur et mot de passe)

Le modèle ajoute une tâche git-clone qui lit username et password depuis le Secret git-creds. Cette tâche est une dépendance de git-checkout-pr.

Toutes les méthodes ne conservent que la tâche git-checkout-pr issue du modèle de workflow prédéfini. Le script shell défini dans le paramètre command de git-checkout-pr reste inchangé.

Appliquer le modèle de workflow

Appliquez le ClusterWorkflowTemplate suivant à votre cluster de workflows :

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

Soumettre le workflow

Définissez les paramètres du workflow pour qu'ils correspondent à la configuration de votre pipeline CI, puis soumettez le workflow.

Cloner avec des artefacts Git (clé SSH)

Cette méthode est similaire à la précédente, avec deux différences :

La tâche git-clone lit uniquement ssh-private-key depuis le Secret git-creds.
Le paramètre repo_url doit être au format SSH. Exemple : git@github.com:ivan-cai/gitops-demo-private.git.

Appliquer le modèle de workflow

Appliquez le ClusterWorkflowTemplate suivant à votre cluster de workflows :

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

Soumettre le workflow

Définissez repo_url au format SSH. Exemple : git@github.com:ivan-cai/gitops-demo-private.git .

Cloner avec des identifiants via des variables d'environnement

Aucune tâche DAG git-clone distincte n'est nécessaire. La tâche git-checkout-pr intègre les identifiants via des variables d'environnement :

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

La tâche lit les identifiants depuis le Secret git-creds à l'aide de deux variables d'environnement :

Variable d'environnement	Champ du Secret
`GIT_USER`	`username`
`GIT_TOKEN`	`password`

Appliquer le modèle de workflow

Appliquez le ClusterWorkflowTemplate suivant à votre cluster de workflows :

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

Soumettre le workflow

Fournissez l'URL brute du dépôt pour repo_url . Omettez le préfixe https:// — le modèle l'ajoute automatiquement.

Étapes suivantes

Créer des pipelines CI pour les projets Golang dans les clusters de workflows