{"meta":{"title":"Migration à partir de Bamboo avec GitHub Actions Importer","intro":"Découvrez comment utiliser GitHub Actions Importer pour automatiser la migration de vos pipelines Bamboo vers GitHub Actions.","product":"GitHub Actions","breadcrumbs":[{"href":"/fr/actions","title":"GitHub Actions"},{"href":"/fr/actions/tutorials","title":"Tutoriels"},{"href":"/fr/actions/tutorials/migrate-to-github-actions","title":"Migrer vers GitHub Actions"},{"href":"/fr/actions/tutorials/migrate-to-github-actions/automated-migrations","title":"Migrations automatisées"},{"href":"/fr/actions/tutorials/migrate-to-github-actions/automated-migrations/bamboo-migration","title":"Migration de Bamboo"}],"documentType":"article"},"body":"# Migration à partir de Bamboo avec GitHub Actions Importer\n\nDécouvrez comment utiliser GitHub Actions Importer pour automatiser la migration de vos pipelines Bamboo vers GitHub Actions.\n\n## À propos de la migration à partir de Bamboo avec GitHub Actions Importer\n\nLes instructions ci-dessous vous guident tout au long de la configuration de votre environnement pour utiliser GitHub Actions Importer afin de migrer des pipelines Bamboo vers GitHub Actions.\n\n### Prérequis\n\n* Un compte ou une organisation Bamboo avec des projets et des pipelines que vous souhaitez convertir en workflows GitHub Actions.\n* Version de Bamboo 7.1.1 ou ultérieure.\n* Accès pour créer un personal access token Bamboo pour votre compte ou organisation.\n* Un environnement dans lequel vous pouvez exécuter des conteneurs basés sur Linux et installer les outils nécessaires.\n * Docker est [installé](https://docs.docker.com/get-docker/) et en cours d’exécution.\n\n * L’[interface CLI GitHub](https://cli.github.com) est installée.\n > \\[!NOTE]\n > Le conteneur GitHub Actions Importer et l’interface CLI n’ont pas besoin d’être installés sur le même serveur que votre plateforme CI.\n\n### Limites\n\nIl existe certaines limitations lors de la migration de Bamboo vers GitHub Actions avec GitHub Actions Importer :\n\n* GitHub Actions Importer s’appuie sur la spécification YAML générée par Bamboo Server pour effectuer les migrations. Lorsque Bamboo ne prend pas en charge l’exportation vers YAML, les informations manquantes ne sont pas migrées.\n* Les conditions de déclencheur ne sont pas prises en charge. Lorsque GitHub Actions Importer rencontre un déclencheur avec une condition, la condition est exposée sous la forme d’un commentaire, et le déclencheur est transformé sans elle.\n* Les plans Bamboo avec des paramètres personnalisés pour le stockage des artefacts ne sont pas transformés. Au lieu de cela, les artefacts sont stockés et récupérés à l’aide des actions [`upload-artifact`](https://github.com/actions/upload-artifact) et [`download-artifact`](https://github.com/actions/download-artifact).\n* Les plans désactivés doivent être désactivés manuellement dans l’interface utilisateur GitHub. Pour plus d’informations, consultez « [Désactivation et activation d’un workflow](/fr/actions/using-workflows/disabling-and-enabling-a-workflow) ».\n* Les travaux désactivés sont transformés avec une condition `if: false` qui les empêche de s’exécuter. Vous devez le supprimer pour réactiver l'emploi.\n* Les tâches désactivées ne sont pas transformées, car elles ne sont pas incluses dans le plan exporté lors de l’utilisation de l’API Bamboo.\n* Bamboo fournit des options pour nettoyer les espaces de travail de construction une fois la construction terminée. Ceux-ci ne sont pas modifiés, car il est supposé que les exécuteurs hébergés par GitHub ou les exécuteurs auto-hébergés éphémères géreront automatiquement cela.\n* Les options de détection de builds suspendues ne sont pas transformées, car il n’existe pas d’équivalent dans GitHub Actions. L’option la plus proche est `timeout-minutes` sur un travail, qui peut être utilisé pour définir le nombre maximal de minutes autorisées pour l’exécution d’un travail. Pour plus d’informations, consultez « [Syntaxe de flux de travail pour GitHub Actions](/fr/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idtimeout-minutes) ».\n* L'étiquetage des correspondances de modèles ne subit aucune transformation car il n'existe pas d'équivalent dans GitHub Actions.\n* Tous les artefacts sont transformés en `actions/upload-artifact`, qu’ils soient `shared` ou non, de sorte qu’ils peuvent être téléchargés à partir de n’importe quel travail dans le workflow.\n* Les autorisations ne sont pas transformées, car il n’existe pas d’équivalent approprié dans GitHub Actions.\n* Si la version Bamboo est comprise entre 7.1.1 et 8.1.1, les variables de projet et de plan ne sont pas migrées.\n\n#### Tâches manuelles\n\nCertaines constructions Bamboo doivent être migrées manuellement. Il s’agit notamment des paramètres suivants :\n\n* Variables masquées\n* Paramètres d’expiration d’artefact\n\n## Installation de l’extension CLI GitHub Actions Importer\n\n1. Installez l’extension CLI GitHub Actions Importer :\n\n ```bash copy\n gh extension install github/gh-actions-importer\n ```\n\n2. Vérifiez que l’extension est installée :\n\n ```bash\n $ gh actions-importer -h\n Options:\n -?, -h, --help Show help and usage information\n\n Commands:\n update Update to the latest version of GitHub Actions Importer.\n version Display the version of GitHub Actions Importer.\n configure Start an interactive prompt to configure credentials used to authenticate with your CI server(s).\n audit Plan your CI/CD migration by analyzing your current CI/CD footprint.\n forecast Forecast GitHub Actions usage from historical pipeline utilization.\n dry-run Convert a pipeline to a GitHub Actions workflow and output its yaml file.\n migrate Convert a pipeline to a GitHub Actions workflow and open a pull request with the changes.\n ```\n\n## Configuration des informations d’identification\n\nLa commande CLI `configure` est utilisée pour définir les informations d’identification et les options requises pour GitHub Actions Importer lors de l’utilisation de Bamboo et de GitHub.\n\n1. Créez un GitHub personal access token (classic). Pour plus d’informations, consultez « [Gestion de vos jetons d’accès personnels](/fr/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-personal-access-token-classic) ».\n\n Votre jeton doit avoir l’étendue `workflow`.\n\n Après avoir créé le jeton, copiez-le et enregistrez-le en lieu sûr en vue de l’utiliser ultérieurement.\n\n2. Créer un personal access token Bamboo. Pour plus d’informations, consultez [Personal Access Tokens](https://confluence.atlassian.com/bamboo/personal-access-tokens-976779873.html) dans la documentation Bamboo.\n\n Votre jeton doit disposer des autorisations suivantes, selon les ressources qui seront transformées.\n\n | Type de ressource | Affichage | Afficher la configuration | Modifier |\n | :--------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |\n | Plan de construction | | | |\n | Projet de déploiement | | | |\n | Environnement de déploiement | | | |\n\n Après avoir créé le jeton, copiez-le et enregistrez-le en lieu sûr en vue de l’utiliser ultérieurement.\n\n3. Dans votre terminal, exécutez la commande CLI GitHub Actions Importer `configure` :\n\n ```shell\n gh actions-importer configure\n ```\n\n La commande `configure` vous invite à entrer les informations suivantes :\n\n * Pour « Quels fournisseurs CI configurez-vous ? », utilisez les touches de direction pour sélectionner `Bamboo`, appuyez sur Space pour le sélectionner, puis appuyez sur Enter.\n * Pour « Personal access token pour GitHub », entrez la valeur du personal access token (classic) que vous avez créée précédemment, puis appuyez sur Enter.\n * Pour « URL de base de l’instance de GitHub », appuyez sur Enter pour accepter la valeur par défaut (`https://github.com`).\n * Pour « Personal access token pour Bamboo », entrez la valeur du Bamboo personal access token que vous avez créée précédemment, puis appuyez sur Entrée.\n * Pour « URL de base de l’instance Bamboo », entrez l’URL de votre instance Bamboo Server ou Bamboo Data Center, puis appuyez sur Entrée.\n\n Voici un exemple de la commande `configure` :\n\n ```shell\n $ gh actions-importer configure\n ✔ Which CI providers are you configuring?: Bamboo\n Enter the following values (leave empty to omit):\n ✔ Personal access token for GitHub: ***************\n ✔ Base url of the GitHub instance: https://github.com\n ✔ Personal access token for Bamboo: ********************\n ✔ Base url of the Bamboo instance: https://bamboo.example.com\n Environment variables successfully updated.\n ```\n\n4. Dans votre terminal, exécutez la commande CLI GitHub Actions Importer `update` pour vous connecter au GitHub Packages Container registry et vérifier que l’image conteneur est mise à jour vers la dernière version :\n\n ```shell\n gh actions-importer update\n ```\n\n La sortie de la commande devrait ressembler à la sortie ci-dessous :\n\n ```shell\n Updating ghcr.io/actions-importer/cli:latest...\n ghcr.io/actions-importer/cli:latest up-to-date\n ```\n\n## Effectuer un audit de Bamboo\n\nVous pouvez utiliser la commande `audit` pour obtenir une vue d’ensemble de tous les projets d’une organisation Bamboo.\n\nLa commande `audit` effectue les étapes suivantes :\n\n1. Extrait tous les projets définis dans une organisation Bamboo.\n2. Convertit chaque pipeline en son workflow GitHub Actions équivalent.\n3. Génère un rapport qui résume la complexité et l'étendue potentielles d'une migration réalisable avec GitHub Actions Importer.\n\n### Exécution de la commande d'audit\n\nPour effectuer un audit d’une instance Bamboo, exécutez la commande suivante dans votre terminal :\n\n```shell\ngh actions-importer audit bamboo --output-dir tmp/audit\n```\n\n### Inspection des résultats de l’audit\n\nLes fichiers dans le répertoire de sortie spécifié contiennent les résultats de l’audit. Consultez le fichier `audit_summary.md` pour obtenir un résumé des résultats de l’audit.\n\nLe résumé de l’audit comporte les sections suivantes.\n\n#### Pipelines\n\nLa section « Pipelines » contient des statistiques générales concernant le taux de conversion effectué par GitHub Actions Importer.\n\nVous trouverez ci-dessous quelques termes clés qui peuvent apparaître dans la section « Pipelines » :\n\n* Les pipelines **réussis** sont ceux dont 100 % des constructions de pipeline et des éléments individuels ont été convertis automatiquement en leur équivalent GitHub Actions.\n* Les pipelines **partiellement réussis** sont ceux dont la totalité des constructions de pipeline ont été converties ; toutefois, certains éléments individuels n’ont pas été convertis automatiquement en leur équivalent GitHub Actions.\n* Les pipelines **non pris en charge** sont des types de définition qui ne sont pas pris en charge par GitHub Actions Importer.\n* Les pipelines **ayant échoué** sont ceux qui ont rencontré une erreur irrécupérable lors de la conversion. Cela peut se produire pour l’une des trois raisons suivantes :\n * Le pipeline a été mal configuré à l’origine et n’était pas valide.\n * GitHub Actions Importer a rencontré une erreur interne lors de sa conversion.\n * Une réponse réseau infructueuse a rendu le pipeline inaccessible, ce qui est souvent dû à des informations d’identification non valides.\n\n#### Étapes de génération\n\nLa section « Étapes de génération » contient une vue d’ensemble des étapes de génération individuelles utilisées dans tous les pipelines ainsi que le nombre d’étapes converties automatiquement par GitHub Actions Importer.\n\nVous trouverez ci-dessous quelques termes clés qui peuvent apparaître dans la section « Étapes de génération » :\n\n* Une étape de génération **connue** est une étape qui a été automatiquement convertie en action équivalente.\n* Une étape de génération **inconnue** est une étape qui n’a pas été automatiquement convertie en action équivalente.\n* Une étape de génération **non prise en charge** est une étape qui est :\n * Fondamentalement non prise en charge par GitHub Actions.\n * Configuré d’une manière incompatible avec GitHub Actions.\n* Une **action** est une liste des actions qui ont été utilisées dans les workflows convertis. Cela peut être important pour :\n * Rassembler la liste des actions à synchroniser avec votre instance, si vous utilisez GitHub Enterprise Server.\n * Définir une liste d’autorisation au niveau de l’organisation des actions utilisées. Cette liste d’actions est une liste complète d’actions que vos équipes de sécurité ou de conformité peuvent avoir besoin d’examiner.\n\n#### Tâches manuelles\n\nLa section « Tâches manuelles » contient une vue d’ensemble des tâches que GitHub Actions Importer ne peut pas accomplir automatiquement et que vous devez effectuer manuellement.\n\nVous trouverez ci-dessous quelques termes clés qui peuvent apparaître dans la section « Tâches manuelles » :\n\n* Un **secret** est un secret au niveau de l’organisation ou du dépôt qui est utilisé dans les pipelines convertis. Ces secrets doivent être créés manuellement dans GitHub Actions pour que ces pipelines fonctionnent correctement. Pour plus d’informations, consultez « [Utilisation de secrets dans GitHub Actions](/fr/actions/security-guides/using-secrets-in-github-actions) ».\n* Un **exécuteur auto-hébergé** fait référence à une étiquette d’un exécuteur référencé dans un pipeline converti qui n’est pas un exécuteur hébergé par GitHub. Vous devez définir manuellement ces exécuteurs pour que ces pipelines fonctionnent correctement.\n\n#### Fichiers\n\nLa dernière section du rapport d’audit fournit un manifeste de tous les fichiers qui ont été écrits sur le disque pendant l’audit.\n\nÀ chaque fichier de pipeline correspond une série de fichiers inclus dans l’audit, notamment :\n\n* Le pipeline d’origine tel qu’il a été défini dans GitHub.\n* Toutes les réponses réseau utilisées pour convertir le pipeline.\n* Le fichier de workflow converti.\n* Les traces de pile qui peuvent être utilisées pour résoudre les problèmes liés à une conversion de pipeline ayant échoué.\n\nDe plus, le fichier `workflow_usage.csv` contient une liste séparée par des virgules de l’ensemble des actions, secrets et exécuteurs qui sont utilisés par chaque pipeline converti avec succès. Cela peut être utile pour déterminer quels workflows utilisent quelles actions, quels secrets ou quels exécuteurs, et pour effectuer des révisions de sécurité.\n\n## Prévision de l’utilisation\n\nVous pouvez utiliser la commande `forecast` pour prévoir l’utilisation potentielle de GitHub Actions en calculant des métriques à partir des exécutions de pipeline terminées sur votre instance Bamboo.\n\n### Exécution de la commande de prévisions\n\nPour faire une prévision de l’utilisation potentielle de GitHub Actions, exécutez la commande suivante dans votre terminal. Par défaut, GitHub Actions Importer inclut les sept jours précédents dans le rapport de prévision.\n\n```shell\ngh actions-importer forecast bamboo --output-dir tmp/forecast_reports\n```\n\n### Prévision d’un projet\n\nPour limiter la prévision aux environnements de plans et de déploiements associés à un projet, vous pouvez utiliser l’option `--project`, où la valeur est définie sur une clé de projet de build.\n\nPar exemple :\n\n```shell\ngh actions-importer forecast bamboo --project PAN --output-dir tmp/forecast_reports\n```\n\n### Inspection du rapport de prévision\n\nLe fichier `forecast_report.md` dans le répertoire de sortie spécifié contient les résultats de la prévision.\n\nVoici quelques termes clés qui peuvent apparaître dans le rapport de prévision :\n\n* Le **nombre de travaux** correspond au nombre total de travaux terminés.\n* Le **nombre de pipelines** correspond au nombre de pipelines uniques utilisés.\n* ```\n Le **temps d’exécution** décrit le temps passé par un exécuteur sur un travail. Cette métrique peut être utilisée pour planifier le coût des exécuteurs hébergés par GitHub.\n ```\n * Cette métrique est corrélée au montant que vous devez vous attendre à dépenser dans GitHub Actions. Cela varie en fonction du matériel utilisé pendant ces minutes. Vous pouvez utiliser la [calculatrice de prix GitHub Actions](https://github.com/pricing/calculator) pour estimer les coûts.\n* Les métriques de **temps de file d’attente** décrivent le temps passé par un travail à attendre qu’un exécuteur soit disponible pour l’exécuter.\n* Les métriques de **travaux simultanés** décrivent le nombre de travaux en cours d’exécution à un moment donné. Cette métrique peut être utilisée pour\n\n## Effectuer une migration test d’un pipeline Bamboo\n\nVous pouvez utiliser la commande `dry-run` pour convertir un pipeline Bamboo en workflow GitHub Actions équivalent. Une exécution test crée les fichiers de sortie dans un répertoire spécifié, mais n’ouvre pas de demande de tirage pour migrer le pipeline.\n\n### Exécution d’une migration test pour un plan de build\n\nPour effectuer une exécution test de migration de votre plan de build Bamboo vers GitHub Actions, exécutez la commande suivante dans votre terminal, en remplaçant `:my_plan_slug` par le projet de plan et la clé de plan au format `-` (par exemple : `PAN-SCRIP`).\n\n```shell\ngh actions-importer dry-run bamboo build --plan-slug :my_plan_slug --output-dir tmp/dry-run\n```\n\n### Exécution d’une migration test pour un projet de déploiement\n\nPour effectuer un test de migration de votre projet de déploiement Bamboo vers GitHub Actions, exécutez la commande suivante dans votre terminal, en remplaçant `:my_deployment_project_id` par l’ID du projet de déploiement que vous convertissez.\n\n```shell\ngh actions-importer dry-run bamboo deployment --deployment-project-id :my_deployment_project_id --output-dir tmp/dry-run\n```\n\nVous pouvez afficher les journaux du test et les fichiers de workflow convertis dans le répertoire de sortie spécifié.\n\nPour tout ce que GitHub Actions Importer n’a pas pu convertir automatiquement, comme des étapes de génération inconnues ou un pipeline partiellement réussi, vous pouvez créer des transformateurs personnalisés pour personnaliser davantage le processus de conversion. Pour plus d’informations, consultez « [Extension de GitHub Actions Importer avec des transformateurs personnalisés](/fr/actions/migrating-to-github-actions/automated-migrations/extending-github-actions-importer-with-custom-transformers) ».\n\n## Effectuer une migration de production d’un pipeline Bamboo\n\nVous pouvez utiliser la commande `migrate` pour convertir un pipeline Bamboo et ouvrir une pull request avec le workflow GitHub Actions équivalent.\n\n### Exécution de la commande migrate pour un plan de build\n\nPour migrer un plan de build Bamboo vers GitHub Actions, exécutez la commande suivante dans votre terminal, en remplaçant la valeur `target-url` par l’URL de votre dépôt GitHub et `:my_plan_slug` par le projet de plan et la clé de plan au format `-`.\n\n```shell\ngh actions-importer migrate bamboo build --plan-slug :my_plan_slug --target-url :target_url --output-dir tmp/migrate\n```\n\nLa sortie de la commande inclut l'URL du pull request qui ajoute le workflow converti à votre référentiel. Voici un exemple de sortie réussie :\n\n```shell\n$ gh actions-importer migrate bamboo build --plan-slug :PROJECTKEY-PLANKEY --target-url https://github.com/octo-org/octo-repo --output-dir tmp/migrate\n[2022-08-20 22:08:20] Logs: 'tmp/migrate/log/actions-importer-20220916-014033.log'\n[2022-08-20 22:08:20] Pull request: 'https://github.com/octo-org/octo-repo/pull/1'\n```\n\n### Exécution de la commande migrate pour un projet de déploiement\n\nPour migrer un projet de déploiement Bamboo DevOps vers GitHub Actions, exécutez la commande suivante dans votre terminal, en remplaçant la valeur `target-url` par l’URL de votre dépôt GitHub et `:my_deployment_project_id` par l’ID du projet de déploiement que vous convertissez.\n\n```shell\ngh actions-importer migrate bamboo deployment --deployment-project-id :my_deployment_project_id --target-url :target_url --output-dir tmp/migrate\n```\n\nLa sortie de la commande inclut l'URL du pull request qui ajoute le workflow converti à votre référentiel. Voici un exemple de sortie réussie :\n\n```shell\n$ gh actions-importer migrate bamboo deployment --deployment-project-id 123 --target-url https://github.com/octo-org/octo-repo --output-dir tmp/migrate\n[2023-04-20 22:08:20] Logs: 'tmp/migrate/log/actions-importer-20230420-014033.log'\n[2023-04-20 22:08:20] Pull request: 'https://github.com/octo-org/octo-repo/pull/1'\n```\n\n### Inspection de la demande de tirage\n\nLa sortie d’une exécution réussie de la commande `migrate` contient un lien vers la nouvelle demande de tirage qui ajoute le workflow converti à votre dépôt.\n\nVoici quelques éléments importants de la demande de tirage :\n\n* Dans la description de la demande de tirage, une section appelée **Étapes manuelles**, qui liste les étapes que vous devez effectuer manuellement avant de pouvoir terminer la migration de vos pipelines vers GitHub Actions. Par exemple, cette section peut vous indiquer de créer des secrets utilisés dans vos workflows.\n* Fichier de workflows converti. Sélectionnez l’onglet **Fichiers changés** dans la demande de tirage pour afficher le fichier de flux de travail à ajouter à votre référentiel GitHub.\n\nUne fois que vous avez terminé d’inspecter la demande de tirage, vous pouvez la fusionner pour ajouter le flux de travail à votre référentiel GitHub.\n\n## Informations de référence\n\nCette section contient des informations de référence sur les variables d’environnement, les arguments facultatifs et la syntaxe prise en charge lors de l’utilisation de GitHub Actions Importer pour effectuer une migration à partir de Bamboo.\n\n### Utilisation de variables d’environnement\n\nGitHub Actions Importer utilise des variables d’environnement pour sa configuration d’authentification. Ces variables sont définies lors du processus de configuration au moyen de la commande `configure`. Pour plus d’informations, consultez la section [Configuration des informations d’identification](#configuring-credentials).\n\nGitHub Actions Importer utilise les variables d’environnement suivantes pour se connecter à votre instance Bamboo :\n\n* `GITHUB_ACCESS_TOKEN` : personal access token (classic) utilisé pour créer des demandes de tirage avec un workflow converti (nécessite les étendues `repo` et `workflow`).\n* `GITHUB_INSTANCE_URL` : URL de l’instance GitHub cible (par exemple, `https://github.com`).\n* `BAMBOO_ACCESS_TOKEN` : personal access token Bamboo utilisé pour vous authentifier auprès de votre instance Bamboo.\n* `BAMBOO_INSTANCE_URL` : URL de l’instance Bamboo (par exemple, `https://bamboo.example.com`).\n\nCes variables d’environnement peuvent être spécifiées dans un fichier `.env.local` chargé par GitHub Actions Importer lors de son exécution.\n\n### Arguments facultatifs\n\nVous pouvez utiliser des arguments facultatifs avec les sous-commandes GitHub Actions Importer pour personnaliser votre migration.\n\n#### `--source-file-path`\n\nVous pouvez utiliser l’argument `--source-file-path` avec les sous-commandes `dry-run` ou `migrate`.\n\nPar défaut, GitHub Actions Importer récupère le contenu du pipeline à partir de l’instance Bamboo. L’argument `--source-file-path` indique à GitHub Actions Importer d’utiliser le chemin du fichier source spécifié à la place.\n\nPar exemple :\n\n```shell\ngh actions-importer dry-run bamboo build --plan-slug IN-COM -o tmp/bamboo --source-file-path ./path/to/my/bamboo/file.yml\n```\n\n#### `--config-file-path`\n\nVous pouvez utiliser l’argument `--config-file-path` avec les sous-commandes `audit`, `dry-run` et `migrate`.\n\nPar défaut, GitHub Actions Importer récupère le contenu du pipeline à partir de l’instance Bamboo. L’argument `--config-file-path` indique à GitHub Actions Importer d’utiliser les fichiers sources spécifiés à la place.\n\n##### Exemple d'Audit\n\nDans cet exemple, GitHub Actions Importer utilise le fichier de configuration YAML spécifié pour effectuer un audit.\n\n```bash\ngh actions-importer audit bamboo -o tmp/bamboo --config-file-path \"./path/to/my/bamboo/config.yml\"\n```\n\nPour auditer une instance Bamboo avec un fichier config, celui-ci doit être au format suivant et chaque `repository_slug` doit être unique :\n\n```yaml\nsource_files:\n - repository_slug: IN/COM\n path: path/to/one/source/file.yml\n - repository_slug: IN/JOB\n path: path/to/another/source/file.yml\n```\n\n##### Exemple d’exécution test\n\nDans cet exemple, GitHub Actions Importer utilise le fichier de configuration YAML spécifié comme fichier source pour effectuer une exécution test.\n\nLe slug du dépôt est généré à l’aide de l’option `--plan-slug`. Le chemin du fichier source est mis en correspondance et extrait du fichier source spécifié.\n\n```bash\ngh actions-importer dry-run bamboo build --plan-slug IN-COM -o tmp/bamboo --config-file-path \"./path/to/my/bamboo/config.yml\"\n```\n\n### Syntaxe supportée pour les pipelines Bamboo\n\nLe tableau suivant montre le type de propriétés que GitHub Actions Importer peut actuellement convertir.\n\n| Bambou | Actions GitHub | État |\n| :---------------------------------- | :---------------------------------------------- | ------------------------: |\n| `environments` | `jobs` | Pris en charge |\n| `environments.` | `jobs.` | Pris en charge |\n| `.artifacts` | `jobs..steps.actions/upload-artifact` | Pris en charge |\n| `.artifact-subscriptions` | `jobs..steps.actions/download-artifact` | Pris en charge |\n| `.docker` | `jobs..container` | Pris en charge |\n| `.final-tasks` | `jobs..steps.if` | Pris en charge |\n| `.requirements` | `jobs..runs-on` | Pris en charge |\n| `.tasks` | `jobs..steps` | Pris en charge |\n| `.variables` | `jobs..env` | Pris en charge |\n| `stages` | `jobs..needs` | Pris en charge |\n| `stages..final` | `jobs..if` | Pris en charge |\n| `stages..jobs` | `jobs` | Pris en charge |\n| `stages..jobs.` | `jobs.` | Pris en charge |\n| `stages..manual` | `jobs..environment` | Pris en charge |\n| `triggers` | `on` | Pris en charge |\n| `dependencies` | `jobs..steps.` | Prise en charge partielle |\n| `branches` | Non applicable | Non pris en charge |\n| `deployment.deployment-permissions` | Non applicable | Non pris en charge |\n| `environment-permissions` | Non applicable | Non pris en charge |\n| `notifications` | Non applicable | Non pris en charge |\n| `plan-permissions` | Non applicable | Non pris en charge |\n| `release-naming` | Non applicable | Non pris en charge |\n| `repositories` | Non applicable | Non pris en charge |\n\nPour plus d’informations sur les mappages de concept et de plugin Bamboo pris en charge, consultez le référentiel [`github/gh-actions-importer`](https://github.com/github/gh-actions-importer/blob/main/docs/bamboo/index.md).\n\n### Correspondances des variables d’environnement\n\nGitHub Actions Importer utilise le mappage dans le tableau ci-dessous pour convertir les variables d’environnement Bamboo par défaut en l’équivalent le plus proche dans GitHub Actions.\n\n| Bambou | Actions GitHub |\n| :----------------------------------------------- | :------------------------------------------------------------------------------------ |\n| `bamboo.agentId` | `${{ github.runner_name }}` |\n| `bamboo.agentWorkingDirectory` | `${{ github.workspace }}` |\n| `bamboo.buildKey` | `${{ github.workflow }}-${{ github.job }}` |\n| `bamboo.buildNumber` | `${{ github.run_id }}` |\n| `bamboo.buildPlanName` | `${{ github.repository }}-${{ github.workflow }}-${{ github.job }` |\n| `bamboo.buildResultKey` | `${{ github.workflow }}-${{ github.job }}-${{ github.run_id }}` |\n| `bamboo.buildResultsUrl` | `${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}` |\n| `bamboo.build.working.directory` | `${{ github.workspace }}` |\n| `bamboo.deploy.project` | `${{ github.repository }}` |\n| `bamboo.ManualBuildTriggerReason.userName` | `${{ github.actor }}` |\n| `bamboo.planKey` | `${{ github.workflow }}` |\n| `bamboo.planName` | `${{ github.repository }}-${{ github.workflow }}` |\n| `bamboo.planRepository.branchDisplayName` | `${{ github.ref }}` |\n| `bamboo.planRepository..branch` | `${{ github.ref }}` |\n| `bamboo.planRepository..branchName` | `${{ github.ref }}` |\n| `bamboo.planRepository..name` | `${{ github.repository }}` |\n| `bamboo.planRepository..repositoryUrl` | `${{ github.server }}/${{ github.repository }}` |\n| `bamboo.planRepository..revision` | `${{ github.sha }}` |\n| `bamboo.planRepository..username` | `${{ github.actor}}` |\n| `bamboo.repository.branch.name` | `${{ github.ref }}` |\n| `bamboo.repository.git.branch` | `${{ github.ref }}` |\n| `bamboo.repository.git.repositoryUrl` | `${{ github.server }}/${{ github.repository }}` |\n| `bamboo.repository.pr.key` | `${{ github.event.pull_request.number }}` |\n| `bamboo.repository.pr.sourceBranch` | `${{ github.event.pull_request.head.ref }}` |\n| `bamboo.repository.pr.targetBranch` | `${{ github.event.pull_request.base.ref }}` |\n| `bamboo.resultsUrl` | `${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}` |\n| `bamboo.shortJobKey` | `${{ github.job }}` |\n| `bamboo.shortJobName` | `${{ github.job }}` |\n| `bamboo.shortPlanKey` | `${{ github.workflow }}` |\n| `bamboo.shortPlanName` | `${{ github.workflow }}` |\n\n> \\[!NOTE]\n> Les variables inconnues sont transformées en `${{ env. }}` et doivent être remplacées ou ajoutées `env` pour fonctionner correctement. Par exemple, `${bamboo.jira.baseUrl}` deviendra `${{ env.jira_baseUrl }}`.\n\n### Variables système\n\nLes variables système utilisées dans les tâches sont transformées en variable d’interpréteur de commandes bash équivalente et sont supposées être disponibles. Par exemple, `${system.}` sera transformé en `$variable_name`. Nous vous recommandons de vérifier cela pour garantir le bon fonctionnement du workflow.\n\n## Mentions légales\n\nCertaines parties ont été adaptées à partir de sous la licence MIT :\n\n```text\nMIT License\n\nCopyright (c) 2022 GitHub\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n```"}