---
# System prepended metadata

title: TP Introduction à la sécurité dans un pipeline CI/CD GitLab

---

# TP – Introduction à la sécurité dans un pipeline CI/CD GitLab

## Objectifs pédagogiques

- Comprendre pourquoi il est important d'intégrer la sécurité dans les outils de développement modernes.
- Découvrir les grandes étapes d’un pipeline CI/CD (intégration et déploiement continu).
- Apprendre à utiliser GitLab CI/CD pour automatiser l’analyse de code, le scan de dépendances et la gestion des images Docker.
- Identifier des vulnérabilités simples et comprendre comment les corriger.

## Préparation de l’environnement (via GitLab.com ou Docker local simplifié)

**Option 1 – GitLab.com (recommandée)**

- Créez un compte sur https://gitlab.com
- Créez un nouveau projet vide et clonez-le en local.
- Installez Node.js (si besoin) et initialisez un petit projet avec un fichier `app.js`, `package.json` et `Dockerfile`.

**Option 2 – Docker local (si GitLab.com indisponible)**

- Installer Docker Desktop sur votre machine.
- On vous fournira une archive contenant GitLab CE et un runner à lancer avec Docker.
- Cette méthode est plus complexe et peut nécessiter de l’aide en lab.

## Étapes du TP (à faire par ordre)

### Étape 1 : Initialisation d’un pipeline GitLab simple

- Créez un fichier `.gitlab-ci.yml` avec :
```yaml
stages:
  - build

build:
  stage: build
  image: node:18-alpine
  script:
    - npm install
    - echo "Build terminé"
```

- Commitez et poussez le fichier sur GitLab.
- Observez si le pipeline se déclenche correctement.

### Étape 2 : Analyse de code simple (SAST)

- Ajoutez cette ligne en haut du fichier `.gitlab-ci.yml` :
```yaml
include:
  - template: Security/SAST.gitlab-ci.yml
```

- Re-poussez le fichier pour relancer le pipeline.
- Allez dans l’onglet **Security > Vulnerabilities** de GitLab et observez les failles détectées.

### Étape 3 : Scan des dépendances (SCA)

- Ajoutez cette ligne dans `include` :
```yaml
  - template: Security/Dependency-Scanning.gitlab-ci.yml
```

- Ajoutez une vieille dépendance vulnérable (ex : lodash@4.17.4) dans `package.json` pour générer des vulnérabilités visibles.
- Poussez les modifications, observez les résultats dans **Security Dashboard**.

### Étape 4 : Scanner une image Docker (optionnel si temps)

- Fourniture d’un `Dockerfile` de base :
```dockerfile
FROM node:18-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["node", "app.js"]
```

- Ajoutez le template GitLab :
```yaml
  - template: Security/Container-Scanning.gitlab-ci.yml
```

- Le job construira l’image et la scannera pour des failles connues.

>npm install devrait idéalement être fait après le COPY package.json package-lock.json ./ et avant le COPY . . pour optimiser les couches Docker et profiter du cache, mais pour ce niveau, le COPY . . puis npm install est suffisant. C'est plus une optimisation qu'une erreur fonctionnelle.

### Étape 5 (bonus) : Lire un secret depuis GitLab CI

- Dans **Settings > CI/CD > Variables**, ajoutez :
  - `DB_PASSWORD` = `SuperSecret123` (protégée, masquée)

- Ajoutez dans `.gitlab-ci.yml` :
```yaml
show_secret:
  stage: build
  script:
    - echo "Le mot de passe est : $DB_PASSWORD"
```

- Observez que GitLab masque automatiquement la variable dans les logs.

## Attendus du livrable

- Le `.gitlab-ci.yml` avec les includes et jobs fonctionnels.
- Une capture d’écran de l’onglet Security avec au moins 2 failles visibles.
- Une explication simple : quelles failles ont été détectées ? Que signifient-elles ?
- (Bonus) Extrait d’un job utilisant une variable protégée.

livrable à envoyer sur: [efrei-devsecops@barry-thien.fr](https://youtu.be/xvFZjo5PgG0?si=_EdLvwebDqel7CEH)

## Barème indicatif (sur 10)

- Pipeline de base fonctionnel : 2 pts
- SAST intégré et compris : 2 pts
- SCA intégré + dépendance vulnérable visible : 2 pts
- Interprétation correcte d’au moins 1 vulnérabilité : 2 pts
- Présentation claire (captures, explications, structure) : 2 pts

> Ce TP a pour but de vous initier aux bonnes pratiques DevSecOps sans entrer dans la complexité d’un environnement complet de production.
