Aller au contenu

Exemples de pipelines

Note

Dans ce tutoriel, remplacez les valeurs suivantes comme suit :

  • ZONE_NAME à remplacer par le nom de votre zone d'administration (commence par ocb-).
  • TEAM_NAME à remplacer par le nom de l'équipe utilisée pour le déploiement.

Construire et publier une image Docker

Nous souhaitons construire une image Docker avec un Dockerfile dans un référentiel git. Une fois l'image construite, nous voulons la publier dans le registre Docker Quay.

Etape 1: définir les ressources

Pour ce pipeline, il nous faut définir deux ressources :

  • git-master: il s'agit de la référence au référentiel git où se trouve votre Dockerfile.
  • latest-image: le type registry-image represente un registre Docker. Si vous souhaitez utiliser Quay, nous vous recommandons de créer un robot account et de l'utiliser pour pousser votre image.
resources:
  - name: git-master
    type: git
    icon: git
    source:
      uri: https://git.ZONE_NAME.caascad.com/myorg/myrepo.git
      username: ((git-username))
      password: ((git-password))
      branch: master

  - name: latest-image
    type: registry-image
    icon: docker
    source:
      repository: docker-registry.ZONE_NAME.caascad.com/myorg/myimage
      username: ((quay-robot-username))
      password: ((quay-robot-password))
      tag: latest

Toutes les valeurs entre parenthèses (( et )), sont des variables. Les valeurs de ces variables sont affectées avec la commande fly set-pipeline.

Etape 2: récupérer le référentiel Git

Récupérez le référentiel git. L'option trigger déclenchera ce job à chaque fois qu'il y aura un nouveau commit sur master.

jobs:
  - name: build
    plan:
      - get: git-master
        trigger: true

Etape 3: générer le fichier de credentials

Le fichier yaml ci-dessous sera utilisé par la tâche qui construit l'image. Cette étape n'est utile que si l'image de base de votre Dockerfile est située sur un registre Docker privé.

      - task: generate-docker-creds
        config:
          platform: linux
          image_resource:
            type: registry-image
            source:
              repository: docker-registry.ZONE_NAME.caascad.com/myorg/alpine
              username: ((quay-robot-username))
              password: ((quay-robot-password))
          outputs:
            - name: docker-creds
          run:
            path: ash
            args:
              - -c
              -  |
                 AUTH="$(echo -n "((quay-robot-username)):((quay-robot-password))" | base64 | tr -d '\n')"
                 echo '{"auths": {"docker-registry.ZONE_NAME.caascad.com": {"auth": "'$AUTH'", "email": ""}}}' > docker-creds/config.json

Le fichier résultant est situé dans docker-creds/config.json. Il contient une structure JSON avec le nom d'utilisateur et le mot de passe du robot Quay encodés en base64. Cette structure est la même que celle utilisée par le client officiel de Docker.

Etape 4: construire l'image

Pour construire l'image Docker, nous utilisons une tâche utilisant l'image vito/oci-build-task. Elle utilisera le Dockerfile disponible dans le référentiel git et exportera l'image dans image/image.tar.

      - task: build-docker-image
        privileged: true
        config:
          platform: linux
          image_resource:
            type: registry-image
            source:
              repository: vito/oci-build-task
          caches:
            - path: cache
          inputs:
            - name: git-master
            - name: docker-creds
          outputs:
            - name: image
          params:
            CONTEXT: git-master
            DOCKER_CONFIG: docker-creds
          run:
            path: build

Cette tâche utilise deux entrées :

  • git-master: il contient le contenu du référentiel Git.
  • docker-creds: il contient le fichier JSON avec les informations d'identification de Docker que nous avons générées précédemment.

La clé params contient des variables d'environnement pour configurer les tâches. Vous pouvez vous référer à la documentation pour connaître les valeurs acceptées.

Etape 5: publier l'image

Cette étape prend le fichier image et le pousse vers le référentiel défini dans la ressource avec le nom latest-image.

      - put: latest-image
        params:
          image: image/image.tar

Etape 6: appliquer le pipeline

Vous pouvez copier le pipeline complet et le placer dans un fichier :

Pipeline complet 
resources:
  - name: latest-image
    type: registry-image
    icon: docker
    source:
      repository: docker-registry.ZONE_NAME.caascad.com/myorg/myimage
      username: ((quay-robot-username))
      password: ((quay-robot-password))
      tag: latest

  - name: git-master
    type: git
    icon: git
    source:
      uri: https://git.ZONE_NAME.caascad.com/myorg/myrepo.git
      username: ((git-username))
      password: ((git-password))
      branch: master

jobs:
  - name: build
    plan:
      - get: git-master
        trigger: true

      # Create a file with the credentials used to authenticate to the docker registry
      # This step is mandatory only if you need to fetch an image from a private registry
      - task: generate-docker-creds
        config:
          platform: linux
          image_resource:
            type: registry-image
            source:
              repository: docker-registry.ZONE_NAME.caascad.com/myorg/alpine
              username: ((quay-robot-username))
              password: ((quay-robot-password))
          outputs:
            - name: docker-creds
          run:
            path: ash
            args:
              - -c
              -  |
                 AUTH="$(echo -n "((quay-robot-username)):((quay-robot-password))" | base64 | tr -d '\n')"
                 echo '{"auths": {"docker-registry.ZONE_NAME.caascad.com": {"auth": "'$AUTH'", "email": ""}}}' > docker-creds/config.json

      # Build the docker image using the credentials we previously forged
      - task: build-docker-image
        privileged: true
        config:
          platform: linux
          image_resource:
            type: registry-image
            source:
              repository: vito/oci-build-task
          caches:
            - path: cache
          inputs:
            - name: git-master
            - name: docker-creds
          outputs:
            - name: image
          params:
            CONTEXT: git-master
            DOCKER_CONFIG: docker-creds
          run:
            path: build

      - put: latest-image
        params:
          image: image/image.tar

Vous pouvez appliquer le pipeling en utilisant fly:

fly -t caascad set-pipeline -p pipeline-name -c pipeline.yaml \
    -v quay-robot-username=ROBOTUSERNAME \
    -v quay-robot-password=ROBOTPASSWORD \
    -v git-username=USERNAME \
    -v git-password=PASSWORD

Deployer sur K8s en utilisant Rancher

Ce pipeline récupère une charte Helm à partir d'un dépôt git et la déploie sur le cluster Kubernetes en utilisant Rancher.

Etape 1: définir les ressources

Pour ce pipeline, nous devons définir une ressource :

  • git-master: c'est la référence au référentiel git dans lequel se trouve notre Dockerfile.
resources:
  - name: git-master
    type: git
    icon: git
    source:
      uri: https://git.ZONE_NAME.caascad.com/myorg/myrepo.git
      username: ((git-username))
      password: ((git-password))
      branch: master

Etape 2: récupérer le référentiel Git

Récupèrez le dépôt git. L'option trigger déclenchera ce job à chaque fois qu'il y aura un nouveau commit sur master.

jobs:
  - name: deploy
    plan:
      - get: git-master
        trigger: true

Etape 3: appliquer la charte Helm

Utilisez une tâche pour déployer la charte Helm à partir une image contenant Helm et un shell appelé dtzar/helm-kubectl.

      - task: deploy manifest
        config:
          platform: linux
          inputs:
            - name: git-master
          image_resource:
            type: registry-image
            source:
              repository: dtzar/helm-kubectl
              tag: 3.2.1
          run:
            path: bash
            dir: git-master
            args:
              - -ec
              - |
                echo "((caascad-kubernetes-TEAM_NAME.kubeconfig))" > /tmp/kubeconfig
                export KUBECONFIG="/tmp/kubeconfig"
                helm upgrade --install --wait --create-namespace -n demo release-name ./helm/demo

La chaîne ((caascad-kubernetes-TEAM_NAME.kubeconfig)) sera remplacée automatiquement par Concourse. Cette variable a déjà été créée pour vous en tant que secret. Elle vous permettra de récupérer le kubeconfig utilisé pour configurer la commande kubectl et helm. Elle contient les informations d'identification pour se connecter à Kubernetes en utilisant Rancher.

Etape 4 : appliquer le pipeline

Vous pouvez copier le pipeline complet et l'enregistrer dans un fichier :

Pipeline complet 
resources:
  - name: git-master
    type: git
    icon: git
    source:
      uri: https://git.ZONE_NAME.caascad.com/myorg/myrepo.git
      username: ((git-username))
      password: ((git-password))
      branch: master

jobs:
  - name: deploy
    plan:
      - get: git-master
        trigger: true

      - task: deploy manifest
        config:
          platform: linux
          inputs:
            - name: git-master
          image_resource:
            type: registry-image
            source:
              repository: dtzar/helm-kubectl
              tag: 3.2.1
          run:
            path: bash
            dir: git-master
            args:
              - -ec
              # The secret "caascad-kubernetes-TEAM_NAME.kubeconfig" has already been created for you
              - |
                echo "((caascad-kubernetes-TEAM_NAME.kubeconfig))" > /tmp/kubeconfig
                export KUBECONFIG="/tmp/kubeconfig"
                helm upgrade --install --wait --create-namespace -n demo release-name ./helm/demo

Vous pouvez appliquer le pipeling en utilisant fly:

fly -t caascad set-pipeline -p pipeline-rancher -c pipeline-rancher.yaml \
    -v git-username=USERNAME \
    -v git-password=PASSWORD

Création du secret Kubernetes pour la récupération des images d'un registre privé

Ce pipeline montre comment obtenir les informations d'identification du registre Docker à partir de Vault et les déployer en tant que secret Kubernetes afin de pouvoir télécharger des images Docker depuis un registre privé.

Les identifiants du registre d'image Docker (au format d'authentification Docker JSON) devront être ajouter au préalable dans un secret Vault.

Note

Les secrets Vault qui seront utilisés dans les pipelines Concourse devront être placés dans le KV store Vault à des endroits précis suivant l'utilisation souhaitée.

Exemple :

  • kv/concourse/TEAM_NAME/

Le secret sera accessible et utilisable dans tout les pipelines Concourse de la TEAM_NAME

Vous pouvez copier le code du pipeline qui suit dans un fichier (ex: pipeline-regcred.yaml):

jobs:
- name: add-regcred-to-k8s
  plan:
  - task: push-regcred
    config:
      platform: linux

      image_resource:
        type: registry-image
        source:
          repository: dtzar/helm-kubectl
      run:
        path: /bin/sh
        args:
          - -cx
          - |
            # delete secret first and ignore if not found
            kubectl --server="((caascad-kubernetes-TEAM_NAME.url))" --token="((caascad-kubernetes-TEAM_NAME.token))" -n ((namespace)) delete secret regcred --ignore-not-found=true
            # create secret
            kubectl --server="((caascad-kubernetes-TEAM_NAME.url))" --token="((caascad-kubernetes-TEAM_NAME.token))" -n ((namespace)) create secret generic regcred --from-literal=.dockerconfigjson='((YOUR_SECRET.KEY))' --type=kubernetes.io/dockerconfigjson

Remplacez TEAM_NAME avec le nom d'équipe Concourse correspondante, et remplacez YOUR_SECRET.KEY avec votre secret.key Vault.

A présent, vous pouvez appliquer le pipeline en utilisant l'outil en ligne de commande fly et spécifier le namespace dans lequel vous voulez déployer le secret :

fly -t caascad set-pipeline -p pipeline-regcred -c pipeline-regcred.yaml \
    -v namespace=default