# Migration de Jenkins vers GitHub Actions

GitHub Actions et Jenkins partagent plusieurs similitudes, ce qui rend la migration vers GitHub Actions relativement simple.

## Introduction

Jenkins et GitHub Actions les deux vous permettent de créer automatiquement des flux de travail qui créent, testent, publient, publient et déploient du code. Jenkins et GitHub Actions partagez certaines similitudes dans la configuration du flux de travail :

* Jenkins crée des flux de travail à l’aide de *pipelines déclaratifs*, qui sont similaires aux GitHub Actions fichiers de flux de travail.
* Jenkins utilise des *stages* pour exécuter un ensemble d’étapes, tandis que GitHub Actions utilise des tâches pour regrouper une ou plusieurs étapes ou des commandes individuelles.
* Jenkins et GitHub Actions prennent en charge les compilations basées sur des conteneurs. Pour plus d’informations, consultez « [Création d’une action de conteneur Docker](/fr/actions/tutorials/use-containerized-services/create-a-docker-container-action) ».
* Les étapes ou les tâches peuvent être réutilisées et partagées avec la communauté.

Pour plus d’informations, consultez « [Présentation des GitHub Actions](/fr/actions/get-started/understand-github-actions) ».

## Différences clés

* Jenkins a deux types de syntaxe pour créer des pipelines : pipeline déclaratif et pipeline scripté.
  GitHub Actions utilise YAML pour créer des flux de travail et des fichiers de configuration. Pour plus d’informations, consultez « [Syntaxe de flux de travail pour GitHub Actions](/fr/actions/reference/workflows-and-actions/workflow-syntax) ».
* Les déploiements Jenkins sont généralement auto-hébergés, avec des utilisateurs qui conservent les serveurs dans leurs propres centres de données.
  GitHub Actions adopte une approche de cloud hybride en hébergeant ses propres runners, que vous pouvez utiliser pour exécuter des tâches, tout en prenant également en charge les runners autohébergés. Pour plus d’informations, consultez « [Exécuteurs auto-hébergés](/fr/actions/concepts/runners/self-hosted-runners) ».

## Comparaison des fonctionnalités

### Distribution de vos builds

Jenkins vous permet d’envoyer des builds à un seul agent de build ou de les répartir entre plusieurs agents. Vous pouvez également classifier ces agents en fonction de différents attributs, tels que les types de systèmes d’exploitation.

De même, GitHub Actions peut envoyer des tâches à des exécuteurs GitHub hébergés ou auto-hébergés, et vous pouvez utiliser des étiquettes pour classer les exécuteurs selon différents attributs. Pour plus d’informations, consultez « [Présentation des GitHub Actions](/fr/actions/get-started/understand-github-actions#runners) » et « [Exécuteurs auto-hébergés](/fr/actions/concepts/runners/self-hosted-runners) ».

### Utilisation de sections pour organiser les pipelines

Jenkins divise ses pipelines déclaratifs en plusieurs sections. De même, GitHub Actions organise ses flux de travail en sections distinctes. Le tableau ci-dessous compare les sections Jenkins au GitHub Actions flux de travail.

| Directives Jenkins                                              | GitHub Actions                                                                                                                                                                                                             |
| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`agent`](https://jenkins.io/doc/book/pipeline/syntax/#agent)   | [`jobs.<job_id>.runs-on`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idruns-on) <br> [`jobs.<job_id>.container`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idcontainer) |
| [`post`](https://jenkins.io/doc/book/pipeline/syntax/#post)     | None                                                                                                                                                                                                                       |
| [`stages`](https://jenkins.io/doc/book/pipeline/syntax/#stages) | [`jobs`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobs)                                                                                                                                                 |
| [`steps`](https://jenkins.io/doc/book/pipeline/syntax/#steps)   | [`jobs.<job_id>.steps`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps)                                                                                                                       |

## Utilisation de directives

Jenkins utilise des directives pour gérer les *pipelines déclaratifs*. Ces directives définissent les caractéristiques de votre workflow et son exécution. Le tableau ci-dessous montre comment ces directives correspondent aux concepts dans GitHub Actions.

| Directives Jenkins                                                                                                                                 | GitHub Actions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`environment`](https://jenkins.io/doc/book/pipeline/syntax/#environment)                                                                          | [`jobs.<job_id>.env`](/fr/actions/reference/workflows-and-actions/workflow-syntax#env) <br> [`jobs.<job_id>.steps[*].env`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsenv)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [`options`](https://jenkins.io/doc/book/pipeline/syntax/#options)                                                                                  | [`jobs.<job_id>.strategy`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategy) <br> [`jobs.<job_id>.strategy.fail-fast`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategyfail-fast) <br> [`jobs.<job_id>.timeout-minutes`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idtimeout-minutes)                                                                                                                                                                                                                                                                                                                       |
| [`parameters`](https://jenkins.io/doc/book/pipeline/syntax/#options)                                                                               | [`inputs`](/fr/actions/reference/workflows-and-actions/metadata-syntax#inputs) <br> [`outputs`](/fr/actions/reference/workflows-and-actions/metadata-syntax#outputs-for-docker-container-and-javascript-actions)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [`triggers`](https://jenkins.io/doc/book/pipeline/syntax/#triggers)                                                                                | [`on`](/fr/actions/reference/workflows-and-actions/workflow-syntax#on) <br> [`on.<event_name>.types`](/fr/actions/reference/workflows-and-actions/workflow-syntax#onevent_nametypes) <br> [<code>on.\<push>.\<branches\|tags></code>](/fr/actions/reference/workflows-and-actions/workflow-syntax#onpushbranchestagsbranches-ignoretags-ignore) <br> [<code>on.\<pull\_request>.\<branches></code>](/fr/actions/reference/workflows-and-actions/workflow-syntax#onpull_requestpull_request_targetbranchesbranches-ignore) <br> [<code>on.\<push\|pull\_request>.paths</code>](/fr/actions/reference/workflows-and-actions/workflow-syntax#onpushpull_requestpull_request_targetpathspaths-ignore) |
| [`triggers { upstreamprojects() }`](https://jenkins.io/doc/book/pipeline/syntax/#triggers)                                                         | [`jobs.<job_id>.needs`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idneeds)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [Syntaxe cron Jenkins](https://jenkins.io/doc/book/pipeline/syntax/#cron-syntax)                                                                   | [`on.schedule`](/fr/actions/reference/workflows-and-actions/workflow-syntax#onschedule)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [`stage`](https://jenkins.io/doc/book/pipeline/syntax/#stage)                                                                                      | [`jobs.<job_id>`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_id) <br> [`jobs.<job_id>.name`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idname)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [`tools`](https://jenkins.io/doc/book/pipeline/syntax/#tools)                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [Spécifications des runners hébergés sur GitHub](/fr/actions/concepts/runners/github-hosted-runners#preinstalled-software-for-github-owned-images) |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [`input`](https://jenkins.io/doc/book/pipeline/syntax/#input)                                                                                      | [`inputs`](/fr/actions/reference/workflows-and-actions/metadata-syntax#inputs)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [`when`](https://jenkins.io/doc/book/pipeline/syntax/#when)                                                                                        | [`jobs.<job_id>.if`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idif)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |

## Utilisation de phases séquentielles

### Traitement parallèle des travaux

Jenkins peut exécuter `stages` et `steps` en parallèle.
GitHub Actions exécute des tâches en parallèle et peut également exécuter des étapes en parallèle au sein d’une tâche à l’aide de la syntaxe au niveau des étapes. Pour plus d’informations, consultez [Syntaxe de flux de travail pour GitHub Actions](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsbackground).

| Exécution parallèle dans Jenkins                                    | GitHub Actions                                                                                                                      |
| ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| [`parallel`](https://jenkins.io/doc/book/pipeline/syntax/#parallel) | [`jobs.<job_id>.strategy.max-parallel`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstrategymax-parallel) |

### Matrix

Les deux GitHub Actions et Jenkins vous permettent d’utiliser une matrice pour définir différentes combinaisons système.

| Jenkins                                                                  | GitHub Actions                                                                                                                                                                                      |
| ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`axis`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-axes)       | [`strategy/matrix`](/fr/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations#about-matrix-strategies) <br> [`context`](/fr/actions/reference/workflows-and-actions/contexts) |
| [`stages`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-stages)   | [`steps-context`](/fr/actions/reference/workflows-and-actions/contexts#steps-context)                                                                                                               |
| [`excludes`](https://jenkins.io/doc/book/pipeline/syntax/#matrix-stages) | None                                                                                                                                                                                                |

### Utilisation des étapes pour exécuter des tâches

Jenkins regroupe des `steps` en `stages`. Chacune de ces étapes peut être un script, une fonction ou une commande, entre autres. De même, GitHub Actions utilise `jobs` pour exécuter des groupes spécifiques de `steps`.

| Jenkins                                                       | GitHub Actions                                                                                       |
| ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| [`steps`](https://jenkins.io/doc/book/pipeline/syntax/#steps) | [`jobs.<job_id>.steps`](/fr/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idsteps) |

## Exemples de tâches courantes

### Planification d’un pipeline à exécuter avec `cron`

#### Pipeline Jenkins avec `cron`

```yaml
pipeline {
  agent any
  triggers {
    cron('H/15 * * * 1-5')
  }
}
```

#### GitHub Actions flux de travail avec `cron`

```yaml
on:
  schedule:
    - cron: '*/15 * * * 1-5'
```

Pour plus d’informations sur les événements `schedule` et la syntaxe cron acceptée, consultez [Événements qui déclenchent des flux de travail](/fr/actions/reference/workflows-and-actions/events-that-trigger-workflows#schedule).

### Configuration des variables d’environnement dans un pipeline

#### Pipeline Jenkins avec une variable d’environnement

```yaml
pipeline {
  agent any
  environment {
    MAVEN_PATH = '/usr/local/maven'
  }
}
```

#### GitHub Actions workflow avec une variable d’environnement

```yaml
jobs:
  maven-build:
    env:
      MAVEN_PATH: '/usr/local/maven'
```

### Construction à partir de projets en amont

#### Pipeline Jenkins généré à partir d’un projet amont

```yaml
pipeline {
  triggers {
    upstream(
      upstreamProjects: 'job1,job2',
      threshold: hudson.model.Result.SUCCESS
    )
  }
}
```

#### GitHub Actions flux de travail qui s’appuie sur un projet en amont

```yaml
jobs:
  job1:
  job2:
    needs: job1
  job3:
    needs: [job1, job2]
```

### Construction avec plusieurs systèmes d'exploitation

#### Pipeline Jenkins généré avec plusieurs systèmes d’exploitation

```yaml
pipeline {
  agent none
  stages {
    stage('Run Tests') {
      matrix {
        axes {
          axis {
            name: 'PLATFORM'
            values: 'macos', 'linux'
          }
        }
        agent { label "${PLATFORM}" }
        stages {
          stage('test') {
            tools { nodejs "node-20" }
            steps {
              dir("scripts/myapp") {
                sh(script: "npm install -g bats")
                sh(script: "bats tests")
              }
            }
          }
        }
      }
    }
  }
}
```

#### GitHub Actions workflow qui compile sur plusieurs systèmes d’exploitation

```yaml
name: demo-workflow
on:
  push:
jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [macos-latest, ubuntu-latest]
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-node@v7
        with:
          node-version: 20
      - run: npm install -g bats
      - run: bats tests
        working-directory: ./scripts/myapp
```