Planification dynamique des charges de travail Tekton à l'aide de déclencheurs

Mettez à niveau votre pipeline CI/CD avec cette application native Kubernetes.

Tekton est un framework d'intégration et de livraison continues (CI/CD) natif de Kubernetes. Il vous permet de créer des charges de travail conteneurisées, composables et configurables de manière déclarative via les définitions de ressources personnalisées (CRD) Kubernetes.

Tekton Triggers est un composant Tekton qui vous permet de détecter et d'extraire des informations d'événements provenant de diverses sources et d'exécuter des TaskRuns et PipelineRuns en fonction de ces informations. Il permet également de transmettre les informations extraites aux TaskRuns et PipelineRuns à partir des événements.

Cet article montre comment Tekton Triggers s'intègre à des services externes, tels qu'un référentiel Git, en utilisant GitLab comme exemple.

Conditions préalables

Si vous souhaitez suivre les étapes de cet article, vous devez disposer d'un cluster Kubernetes exécutant Kubernetes 1.18 ou supérieur avec un contrôleur d'entrée installé pouvant vous fournir une adresse IP externe. Vous devez également avoir installé Tekton Pipelines et Tekton Triggers.

Déclenche le flux

Tekton Trigger vous permet de créer une ressource spéciale appelée EventListener, qui est un service Kubernetes qui écoute les requêtes HTTP entrantes provenant de différentes sources, généralement un référentiel Git, y compris celles hébergées sur GitLab, GitHub et autres. Sur la base de ces événements, le pod EventListener effectue des actions et crée des ressources Tekton, telles que TaskRun ou PipelineRun.

Savita Ashture, CC BY-SA 4.0

Toutes les définitions de ressources Triggers sont créées en YAML, le format de configuration le plus couramment utilisé dans Kubernetes. Cependant, avant d'écrire des fichiers YAML pour définir un déclencheur, il est important de comprendre la terminologie des déclencheurs Tekton.

Écouteur d'événements

Un EventListener est un service Kubernetes qui écoute les requêtes HTTP entrantes et exécute un déclencheur. Par exemple, après avoir reçu une requête entrante spécifique, cette définition exécute le déclencheur gitlab-listener-trigger :

apiVersion: triggers.tekton.dev/v1beta1
kind: EventListener
metadata:
  name: gitlab-event-listener
spec:
  serviceAccountName: gitlab-listener-sa
  triggers:
    - triggerRef: gitlab-listener-trigger
  resources:
    kubernetesResource:
      serviceType: NodePort

Déclenchement

Un déclencheur décide quoi faire avec un événement reçu. Il définit également un TriggerBinding, un TriggerTemplate et des intercepteurs facultatifs à exécuter. Les déclencheurs utilisent des intercepteurs pour valider ou modifier les demandes entrantes avant de continuer.

apiVersion: triggers.tekton.dev/v1beta1
kind: Trigger
metadata:
  name: gitlab-listener-trigger
spec:
  interceptors:
    - name: "verify-gitlab-payload"
      ref:
        name: "gitlab"
        kind: ClusterInterceptor
      params:
        - name: secretRef
          value:
            secretName: "gitlab-secret"
            secretKey: "secretToken"
        - name: eventTypes
          value:
            - "Push Hook"
  bindings:
    - ref: binding
  template:
    ref: template

Intercepteur

Un intercepteur est un processeur d'événements qui s'exécute avant le TriggerBinding. Il effectue également le filtrage, la vérification (à l'aide d'un secret) et la transformation des charges utiles ; définit et teste les conditions de déclenchement ; et implémente d'autres traitements utiles.

Par défaut, quatre intercepteurs principaux sont installés lors de l'installation des déclencheurs : GitHub, GitLab, Bitbucket et CEL. L'installation comprend également un intercepteur Webhook pour implémenter une logique métier personnalisée.

Intercepteurs GitLab

Les intercepteurs GitLab aident à valider et filtrer les webhooks GitLab et à filtrer les événements entrants par type d'événement. L'intercepteur GitLab nécessite un jeton secret. Ce jeton est défini lors de la création du webhook dans GitLab et est validé par l'intercepteur GitLab lorsque la requête arrive.

apiVersion: v1
kind: Secret
metadata:
  name: gitlab-secret
type: Opaque
stringData:
  secretToken: "1234567"

Liaison de déclenchement

Après avoir validé et modifié la requête entrante, vous devez extraire les valeurs de la requête et les lier à des variables que vous pourrez ensuite utiliser dans un TriggerTemplate pour transmettre notre Pipeline.

Pour notre exemple, vous avez juste besoin d'une URL et d'une révision.

apiVersion: triggers.tekton.dev/v1beta1
kind: TriggerBinding
metadata:
  name: binding
spec:
  params:
    - name: gitrevision
      value: $(body.checkout_sha)
    - name: gitrepositoryurl
      value: $(body.repository.git_http_url)

Modèle de déclencheur

Le TriggerTemplate est un modèle qui instancie TaskRun ou PipelineRun lorsque EventListener détecte un événement.

apiVersion: triggers.tekton.dev/v1beta1
kind: TriggerTemplate
metadata:
  name: template
spec:
  params:
    - name: gitrevision
    - name: gitrepositoryurl
  resourcetemplates:
    - apiVersion: tekton.dev/v1beta1
      kind: TaskRun
      metadata:
        generateName: gitlab-run-
      spec:
        taskSpec:
          resources:
            inputs:
              - name: source
                type: git
          steps:
            - image: ubuntu
              script: |
                #! /bin/bash
                ls -al $(inputs.resources.source.path)
        resources:
          inputs:
            - name: source
              resourceSpec:
                type: git
                params:
                  - name: revision
                    value: $(tt.params.gitrevision)
                  - name: url
                    value: $(tt.params.gitrepositoryurl)

Notez que le module de ressources de pipeline est, au moment de la rédaction, obsolète et sera remplacé par des tâches git-clone, de tektoncd/catalog.

Planifiez dynamiquement les charges de travail en configurant un webhook

Tout d'abord, créez un nouvel espace de noms, demo :

$ kubectl create ns demo

Ensuite, avant d'appliquer la ressource Déclencheurs, configurez le contrôle d'accès basé sur les rôles (RBAC) requis :

$ kubectl -n demo apply -f \
"https://gist.githubusercontent.com/savitaashture/596bc4d93ff6b7606fe52aa20ba1ba14/raw/158a5ed0dc30fd1ebdac461147a4079cd6187eac/triggers-rbac.yaml"

Remarque : les configurations RBAC varient en fonction des autorisations.

Appliquer les ressources des déclencheurs :

$ kubectl -n demo apply -f \
"https://gist.githubusercontent.com/savitaashture/8aa013db1cb87f5dd1f2f96b0e121363/raw/f4f592d8c1332938878c5ab9641e350c6411e2b0/triggers-resource.yaml"

Après l'application, vérifiez la création réussie de l'objet et du pod EventListener :

L’état READY de l’objet EventListener doit être True.

$ kubectl get el -n demo
NAME                    ADDRESS                                                     AVAILABLE REASON              READY             REASON                                                                                                             
gitlab-event-listener   http://el-gitlab-event-listener.demo.svc.cluster.local:8080   True                 MinimumReplicasAvailable   True

L'état du pod EventListener doit être En cours d'exécution.

$ kubectl get pods -n demo
NAME                                       READY          STATUS    RESTARTS              AGE
el-gitlab-event-listener-fb77ff8f7-p5wnv   1/1            Running   0                     4m22s

Créez une entrée pour obtenir l'adresse IP externe à configurer dans le webhook GitLab :

$ kubectl -n demo apply -f \
"https://gist.githubusercontent.com/savitaashture/3b3554810e391477feae21bb8a9af93a/raw/56665b0a31c7a537f9acbb731b68a519be260808/triggers-ingress.yaml"

Obtenez l'adresse IP d'entrée :

$ kubectl get ingress triggers-ingress-resource -n demo

NAME               CLASS    HOSTS     ADDRESS                             PORTS   AGE
ingress-resource   <none>   *         <address>                            80      6s

Configurez un webhook dans GitLab. Dans votre référentiel GitLab, accédez à Paramètres -> Webhooks.

Définissez ensuite les champs ci-dessous :

URL : adresse IP externe de l'entrée avec le chemin /
Jeton secret : 1234567, qui doit correspondre à la valeur secrète créée ci-dessus à partir du fichier triggers-resource.yaml

Choisissez le type d'événement dans la section Déclencheur, puis sélectionnez simplement Événements push, décochez Activer la vérification SSL et cliquez sur Ajouter un webhook.

^{Savita Ashture, CC BY-SA 4.0}

Tester les événements GitLab en poussant les relations publiques

Clonez votre propre référentiel GitLab, apportez des modifications et effectuez le push. Par exemple:

$ git clone https://gitlab.com/savitaashture1/gitlabtest-triggers
$ cd gitlabtest-triggers
               $ git commit -m "empty-commit" --allow-empty && git push origin main
[main 934ecba] empty-commit
Username for 'https://gitlab.com': savitaashture
Password for 'https://savitaashture@gitlab.com': 
warning: redirecting to https://gitlab.com/savitaashture1/gitlabtest-triggers.git/
Enumerating objects: 1, done.
Counting objects: 100% (1/1), done.
Writing objects: 100% (1/1), 183 bytes | 183.00 KiB/s, done.
Total 1 (delta 0), reused 0 (delta 0)
To https://gitlab.com/savitaashture1/gitlabtest-triggers
   ff1d11e..934ecba  main -> main

Les événements seront générés et envoyés au pod EventListener. Vous pouvez le vérifier en faisant :

kubectl get pods -n demo
kubectl logs -f <pod_name> -n demo

Vérifiez la livraison réussie des événements en effectuant une opération get pour TaskRun.

$ kubectl  -n demo get taskruns | grep gitlab-run-

gitlab-run-hvtll   True        Succeeded   95s         87s

Nettoyez toutes les ressources créées par les déclencheurs en supprimant l'espace de noms demo :

$kubectl supprimer la démo ns

Conclusion

Tekton Triggers est l'un des modules les plus utiles qui permettent de planifier les charges de travail de manière dynamique en réponse à un ensemble d'événements défini par l'utilisateur. Grâce à ce module, mon équipe a pu réaliser du CI/CD de bout en bout.