Ressources · Intégration Make

Intégration GitLab MakeAutomatiser GitLab avec Make.

Chaque merge request, chaque pipeline, chaque ticket peut lancer du travail ailleurs. L'intégration GitLab Make met 105 modules à ta portée, dont 10 déclencheurs. Utile si tu tiens un dépôt et que tu veux voir tickets, releases et alertes se gérer sans code. Tu repars avec une automatisation en place.

Essayer l'intégration GitLab sur MakeVoir les 105 modules

Avis vérifiés sur Trustpilot · Agence IA, automatisation & growth

Ce que tu peux automatiser

Que fait vraiment l'intégration GitLab Make ?

Elle relie ton compte GitLab à Make, l'outil d'automatisation sans code, pour que ce qui se passe dans tes dépôts déclenche des actions ailleurs. Tu construis un scénario, c'est-à-dire l'automatisation elle-même : une suite de modules, chaque module étant une brique qui surveille, agit ou cherche. La connexion, ton compte GitLab relié à Make une fois pour toutes, sert ensuite à tous les modules GitLab du scénario.

Trois formes reviennent sans arrêt. Le commentaire qui devient une tâche : Watch Issue Notes attrape une note postée sur un ticket, et Create a Todo la pose sur la liste de quelqu'un. La revue qui ne traîne plus : Watch Merge Requests suit la merge request d'un bout à l'autre, et Create a Merge Request Note y publie la checklist que l'équipe oublie une fois sur deux.

Le projet neuf déjà rangé : Watch Projects repère le dépôt qu'on vient de te confier, Create a Label pose le jeu d'étiquettes maison, Create a Milestone ouvre le premier jalon. Aucun de ces montages ne demande une ligne de code, et quand un scénario refuse de tourner, le Dépannage Make reprend les cas classiques.

Ce que couvrent les 105 modules est large sans être infini : projets, tickets, merge requests, pipelines, jobs, branches, tags, releases, jalons, labels, variables, snippets et todos. Au-delà, Make an API Call et Execute a GraphQL Query tapent directement dans l'API GitLab avec la même connexion. Un point d'honnêteté : la documentation GitLab de Make est générée à partir de la doc officielle de GitLab et peut contenir des erreurs, donc vérifie chez GitLab ce qui compte avant de passer en production.

GitLab existe aussi comme nœud dans n8n, et le choix mérite mieux qu'un coup de dé. L'Intégration GitLab n8n raconte l'autre côté, le comparatif n8n vs Make aligne les critères.

Connexion

Comment connecter GitLab à Make ?

  1. 01

    Ajoute un module GitLab

    Il te faut un compte GitLab actif et un jeton d'accès, la liste des prérequis s'arrête là. Dans Make, pose n'importe quel module GitLab dans ton scénario, puis clique sur Create a connection. C'est le seul endroit où Make réclame des identifiants.

  2. 02

    Nomme la connexion

    Le champ Connection name est facultatif, et il mérite quand même trente secondes. Quand on jongle entre le GitLab des clients et celui de l'interne, un nom clair évite de brancher le mauvais compte au module suivant.

  3. 03

    Colle tes identifiants

    Reporte les identifiants copiés depuis ton compte GitLab, ou suis les instructions affichées à l'écran. En OAuth2, GitLab les fabrique depuis ton avatar : Edit profile, Applications, Add new application, avec l'URI de rappel https://www.integromat.com/oauth/cb/gitlab3.

Premier scénario

Ton premier scénario : la release qui s'écrit toute seule

ObjectifQuand un tag est poussé dans GitLab, Make publie la release qui va avec.

  1. 01

    Crée le scénario

    Depuis la page Scenarios de Make, crée un nouveau scénario et clique sur le + pour poser le premier module. Un cercle vide apparaît, en attente d'une app. Tout part de ce cercle.

  2. 02

    Choisis Watch Tags

    Cherche GitLab par son nom, prends Watch Tags, puis clique sur Create a webhook et Create a connection. Le module affiche un badge éclair : instantané, GitLab prévient Make dès qu'un tag part.

  3. 03

    Vise le bon projet

    Remplis les champs du module. Une fois la connexion créée, Make lit ton compte et te propose les projets qu'il trouve, tu choisis donc dans une liste au lieu de courir après un identifiant.

  4. 04

    Ajoute Create a Release

    Clique sur le + à droite du déclencheur et ajoute Create a Release. Reprends le nom du tag depuis le premier module : c'est ça, le mapping, la sortie d'un module qui alimente le suivant.

  5. 05

    Teste avec Run once

    Clique sur Run once, le bouton qui exécute le scénario une seule fois, puis pousse un tag d'essai. Chaque module montre les bundles reçus, un bundle étant un élément qui passe d'un module à l'autre.

  6. 06

    Planifie et active

    Ouvre la planification sur le premier module. Un déclencheur planifié, celui que Make interroge lui-même, tourne à ce rythme, toutes les 15 minutes par défaut. Le tien est instantané et attend l'appel. Dans les deux cas, active le scénario, sinon rien ne tourne.

Déclencheurs

Ce qui démarre un scénario GitLab

10 modules démarrent un scénario quand quelque chose se passe dans GitLab. Un déclencheur planifié est vérifié par Make au rythme du scénario ; un déclencheur instantané est appelé par GitLab dès que ça se passe.

GitLab1Watch Issue Notes

Watch Issue Notes

Déclencheur instantané

Dans Make“Triggers on note events.”

Les notes, ce sont les commentaires laissés sur les tickets, les merge requests, les commits et les snippets. Ce déclencheur part sur les événements de note, et un simple commentaire devient matière à automatiser.

Comment il se déclenche
instantané, GitLab prévient Make par webhook dès que ça se passe.
Quand l'utiliser
un dépôt ouvert où un commentaire contenant un mot-clé doit créer une tâche pour le support.
Attention
chaque note est une opération, c'est-à-dire un module qui tourne sur un élément, un dépôt bavard consomme donc vite.
GitLab2Watch Issues

Watch Issues

Déclencheur instantané

Dans Make“Triggers when a new issue is created or an existing issue was updated/closed/reopened.”

Un seul déclencheur couvre toute la vie d'un ticket : créé, mis à jour, fermé, rouvert. Le ticket arrive dans le scénario comme un bundle, prêt pour le module suivant.

Comment il se déclenche
instantané, GitLab prévient Make par webhook dès que ça se passe.
Quand l'utiliser
une équipe produit qui veut chaque nouveau bug sur le tableau de sprint sans recopie manuelle.
Attention
les quatre événements passent par la même porte, regarde lequel arrive avant d'agir, sinon un ticket rouvert sera traité comme un neuf.
GitLab3Watch Jobs

Watch Jobs

Déclencheur instantané

Dans Make“Triggers on status change of a job.”

Un job est une unité de travail dans un pipeline, et ce déclencheur suit ses changements de statut. Le scénario apprend le moment où un build démarre, passe ou casse.

Comment il se déclenche
instantané, GitLab prévient Make par webhook dès que ça se passe.
Quand l'utiliser
une agence qui veut le build en échec annoncé là où les développeurs regardent vraiment.
Attention
les changements de statut s'enchaînent, le même job peut donc réveiller le scénario plusieurs fois en cours de route.
GitLab4Watch Merge Requests

Watch Merge Requests

Déclencheur instantané

Dans Make“Triggers when a new merge request is created, an existing merge request was updated/merged/closed or a commit is added in the source branch.”

Tout ce qui arrive à une merge request atterrit ici : création, mise à jour, fusion, fermeture, et même un commit ajouté sur la branche source. Un déclencheur, tout le cycle de revue.

Comment il se déclenche
instantané, GitLab prévient Make par webhook dès que ça se passe.
Quand l'utiliser
un responsable technique qui veut un tableau de revue à jour sans lire ses notifications.
Attention
un commit poussé sur la branche source compte aussi, une branche active fait donc partir ce déclencheur souvent.
GitLab5Watch Pipelines

Watch Pipelines

Déclencheur instantané

Dans Make“Triggers on pipeline events.”

Les événements de pipeline, ces exécutions qui construisent et livrent un projet, réveillent le scénario. Le bundle transporte le pipeline, le module suivant peut donc le lire.

Comment il se déclenche
instantané, GitLab prévient Make par webhook dès que ça se passe.
Quand l'utiliser
la personne qui tient les mises en production et veut le journal écrit à chaque mouvement de pipeline.
Attention
tu reçois le pipeline, pas le détail de chaque job, ça se récupère avec un autre module.
GitLab6Watch Projects

Watch Projects

Déclencheur planifié

Dans Make“Triggers when a new project is added of which the authenticated user is a member.”

Le module guette l'apparition d'un nouveau projet où le compte de ta connexion figure comme membre. Pratique pour tenir un inventaire honnête de ce sur quoi l'équipe travaille.

Comment il se déclenche
planifié, Make interroge GitLab au rythme du scénario.
Quand l'utiliser
un responsable informatique qui veut chaque nouveau projet livré avec les mêmes labels et le même jalon.
Attention
c'est l'appartenance qui commande, un projet créé sans ton compte dessus reste invisible pour le scénario.
GitLab7Watch Push Events

Watch Push Events

Déclencheur instantané

Dans Make“Triggers on push events.”

Chaque poussée sur le dépôt arrive jusqu'à Make. Les commits remontent au fil de l'eau, ce qui en fait le plus brut des déclencheurs GitLab.

Comment il se déclenche
instantané, GitLab prévient Make par webhook dès que ça se passe.
Quand l'utiliser
un site de documentation qui doit se reconstruire quand quelqu'un pousse sur la branche principale.
Attention
la poussée est l'événement le plus fréquent d'un dépôt, c'est la façon la plus rapide de brûler des opérations si la suite du scénario travaille beaucoup.
GitLab8Watch Tags

Watch Tags

Déclencheur instantané

Dans Make“Triggers on tag push events.”

Un tag poussé sur le dépôt met ce déclencheur en route. Comme un tag marque en général une version, le scénario sait qu'une release existe avant l'annonce.

Comment il se déclenche
instantané, GitLab prévient Make par webhook dès que ça se passe.
Quand l'utiliser
sortir une version et vouloir que le changelog, l'annonce et le ménage des tickets suivent tout seuls.
Attention
il voit le tag, pas ce qui a changé dedans, accompagne-le d'un module qui lit les commits quand il te faut le détail.
GitLab9Watch Todos

Watch Todos

Déclencheur planifié

Dans Make“Triggers when a new todo is added. When no filter is applied, the trigger is run when a new pending todo is added.”

Les todos sont la liste de rappels propre à GitLab, et un nouveau todo démarre le scénario. Sans filtre, il part sur chaque todo en attente du compte.

Comment il se déclenche
planifié, Make interroge GitLab au rythme du scénario.
Quand l'utiliser
quelqu'un qui veut ses demandes de revue reflétées dans son gestionnaire de tâches plutôt que rangées à deux endroits.
Attention
les todos appartiennent au compte de la connexion, le scénario voit ta liste, jamais celle de l'équipe.
GitLab10Watch Wiki Pages

Watch Wiki Pages

Déclencheur instantané

Dans Make“Triggers when a wiki page is created or edited.”

Le wiki compte aussi : créer une page et la modifier font partir ce déclencheur de la même façon. C'est là que vit le savoir qui ne tient pas dans un README.

Comment il se déclenche
instantané, GitLab prévient Make par webhook dès que ça se passe.
Quand l'utiliser
une équipe support qui veut son centre d'aide à jour quand le wiki interne bouge.
Attention
création et modification passent par le même déclencheur, une page corrigée deux fois envoie deux bundles.
Modules

Ce que GitLab sait faire dans un scénario

GitLab te donne 95 modules. Pour chacun : ce qu'il fait pour toi, le moment où tu le choisis, et ce qu'il faut surveiller.

GitLab1

Accept a Merge Request

Action

Dans Make“Merges changes submitted with merge request.”

Le module fusionne les changements portés par une merge request, exactement le clic que ferait un relecteur.

Quand l'utiliser
une chaîne de release où la fusion part une fois les contrôles passés et les approbations posées.
Attention
une fusion modifie la branche pour tout le monde, place-le en bout d'un scénario déjà testé avec Run once, jamais sur un premier jet.
GitLab2

Cancel a Job

Action

Dans Make“Cancels a single build of a project.”

Il coupe un build d'un projet avant qu'il n'aille au bout.

Quand l'utiliser
un correctif poussé dans la foulée, qui rend inutile le build lancé deux commits plus tôt.
Attention
le job garde son statut annulé dans GitLab, l'historique montre donc ce que le scénario a décidé.
GitLab3

Cancel a Pipeline's Jobs

Action

Dans Make“Cancels a pipeline's builds.”

Un seul appel, et tous les builds du pipeline s'arrêtent. Plus large que l'annulation d'un job, et plus rapide que de cliquer un par un.

Quand l'utiliser
une branche abandonnée en pleine exécution, où plus rien ne mérite d'aller au bout.
Attention
ça touche tout le pipeline, une erreur d'identifiant de projet coûte donc une exécution à l'équipe d'à côté.
GitLab4

Cancel Merge When Pipeline Succeeds

Action

Dans Make“Cancels a merge request when the pipeline succeeds.”

Il annule la fusion que GitLab devait faire dès le pipeline au vert. La merge request reste entre les mains des gens.

Quand l'utiliser
un relecteur repère un détail après avoir approuvé, alors que le pipeline est sur le point de fusionner.
Attention
le scénario doit passer avant la fin du pipeline, sinon la fusion a déjà eu lieu.
GitLab5

Cherry Pick a Commit

Action

Dans Make“Cherry picks a commit to a given branch.”

Il recopie un commit sur une autre branche sans traîner l'historique derrière lui.

Quand l'utiliser
un correctif validé sur la branche principale qui doit aussi atterrir sur la branche de maintenance.
Attention
le commit arrive comme un nouveau commit sur la branche cible, les deux branches portent donc deux fois le même changement.
GitLab6

Create a File in a Repository

Action

Dans Make“Creates a file in a repository.”

Il écrit un nouveau fichier dans le dépôt, commit compris. Ton scénario produit du contenu, il ne fait plus que lire.

Quand l'utiliser
un rapport fabriqué ailleurs qui doit vivre à côté du code, ou un fichier de configuration créé pour chaque nouveau projet.
Attention
le fichier arrive sous forme de commit, il traverse donc tes pipelines comme n'importe quel autre.
GitLab7

Create a Group

Action

Dans Make“Creates a group.”

Il monte un groupe GitLab, le contenant qui rassemble les projets et les gens autorisés dessus.

Quand l'utiliser
une agence qui ouvre un groupe par client et n'a pas envie de refaire la manipulation à la main.
Attention
le module crée le groupe et rien d'autre, les membres, les labels et le premier projet restent à ajouter par les modules suivants.
GitLab8

Create a Label

Action

Dans Make“Creates a new label for the given repository with the given name and color.”

Il ajoute un label au dépôt, avec le nom et la couleur que tu lui donnes. Les labels servent à trier tickets et merge requests.

Quand l'utiliser
uniformiser le même jeu d'étiquettes sur tous les projets qu'une équipe ouvre.
Attention
la couleur fait partie de l'appel, choisis ta palette une fois et réutilise-la partout.
GitLab9

Create a Merge Request

Action

Dans Make“Creates a new merge request.”

Il ouvre une merge request depuis le scénario, branche source et branche cible comprises.

Quand l'utiliser
une branche de traduction poussée par un outil, où la merge request doit exister avant que quiconque remarque la branche.
Attention
la revue reste humaine, automatiser l'ouverture n'automatise pas l'approbation.
GitLab10

Create a Merge Request Note

Action

Dans Make“Creates a new note for a single merge request.”

Il poste un commentaire sur une merge request. Le moyen le plus simple pour un scénario de parler là où la discussion existe déjà.

Quand l'utiliser
une checklist publiée dès que la merge request touche au code de facturation.
Attention
un commentaire notifie tous les abonnés, garde les messages du scénario courts et rares.
GitLab11

Create a Milestone

Action

Dans Make“Creates a project milestone.”

Il crée un jalon de projet, le paquet dont GitLab se sert pour regrouper des tickets autour d'une date ou d'une version.

Quand l'utiliser
un nouveau sprint qui doit exister dans chaque dépôt sans ouvrir les projets un par un.
Attention
un jalon vit dans un projet, un scénario qui couvre plusieurs dépôts demande donc un appel par projet.
GitLab12

Create an Issue

Action

Dans Make“Creates a new project issue.”

Il dépose un ticket dans le projet choisi, avec le titre et la description que fabrique ton scénario. Beaucoup de premiers scénarios s'arrêtent là.

Quand l'utiliser
une réponse de formulaire ou une alerte qui doit devenir un ticket suivi, pas une note dans un coin de tête.
Attention
rien ne vérifie les doublons, un déclencheur qui part deux fois dépose deux tickets.
GitLab13

Create an Issue Note

Action

Dans Make“Creates a new note to a single project issue.”

Il ajoute un commentaire sous un ticket existant. Le fil reste au même endroit et gagne ce que le scénario a trouvé.

Quand l'utiliser
un déploiement terminé, que le ticket demandeur doit annoncer sans que personne tape quoi que ce soit.
Attention
l'identifiant du ticket est nécessaire, un module qui le lit ou le crée passe donc avant dans le flux.
GitLab14

Create a Pipeline

Action

Dans Make“Creates a new pipeline for a given project.”

Il lance un pipeline sur un projet, la même exécution que depuis la page CI.

Quand l'utiliser
un contenu publié dans un CMS découplé, qui doit reconstruire le site tout seul.
Attention
le pipeline tourne comme si une personne l'avait lancé, un scénario qui en démarre un à chaque poussée empile les exécutions.
GitLab15

Create a Release

Action

Dans Make“Adds release notes to the existing git tag.”

Il accroche des notes de version à un tag git qui existe déjà. Le tag devient une page lisible plutôt qu'un nom dans une liste.

Quand l'utiliser
au moment où la version est taguée et le changelog prêt à sortir.
Attention
le tag doit exister avant, le module de tag ou une vraie poussée passe donc en premier.
GitLab16

Create a Repository Branch

Action

Dans Make“Creates a single project repository branch.”

Il taille une branche dans le projet à partir de la référence que tu indiques.

Quand l'utiliser
un ticket accepté en développement, où la branche attend déjà sous le bon nom.
Attention
les noms de branche servent à s'y retrouver, construis-les depuis les données du ticket plutôt que depuis un compteur.
GitLab17

Create a Snippet Note

Action

Dans Make“Creates a new note for a single snippet.”

Il commente un snippet, ce bout de code isolé que GitLab stocke hors dépôt.

Quand l'utiliser
une requête partagée que tout le monde retouche, où le scénario note qui a changé quoi.
Attention
un snippet sort vite du champ de vision, une note posée là touche moins de monde qu'une note sur un ticket.
GitLab18

Create a Tag

Action

Dans Make“Creates a new tag in the repository that points to the supplied ref.”

Il pose un tag sur la référence fournie, c'est ainsi qu'une version reçoit son nom.

Quand l'utiliser
un scénario de sortie qui tague le commit une fois le pipeline au vert.
Attention
un tag est une marque publique du dépôt, une faute de frappe reste visible tant que personne ne la supprime.
GitLab19

Create a Todo

Action

Dans Make“Manually creates a todo for the current user on an issue.”

Il pose un ticket sur la liste de todos du compte relié à ta connexion. Le pense-bête maison de GitLab, créé par le scénario.

Quand l'utiliser
un ticket qui correspond à un mot-clé et ne doit pas attendre la prochaine revue de backlog.
Attention
le todo tombe sur ton compte seulement, c'est un rappel personnel, pas une façon d'assigner du travail.
GitLab20

Create a Todo on Merge Request

Action

Dans Make“Manually creates a todo for the current user on a merge request.”

Même rappel, braqué sur une merge request au lieu d'un ticket. La revue apparaît dans tes todos GitLab.

Quand l'utiliser
une merge request posée sur un dossier sensible. Celle-là ne doit jamais passer sous ton radar, même un jour chargé où tout arrive en même temps.
Attention
ça rappelle, ça n'assigne pas, la merge request a toujours besoin d'un relecteur nommé dans GitLab.
GitLab21

Create a Variable

Action

Dans Make“Creates a build variable.”

Il ajoute une variable de build au projet, la valeur que les pipelines lisent pendant qu'ils tournent.

Quand l'utiliser
un nouveau projet qui a besoin des mêmes clés que les autres avant son premier pipeline.
Attention
les variables portent souvent des secrets, demande-toi qui peut ouvrir le scénario Make qui les écrit.
GitLab22

Delete a File in a Repository

Action

Dans Make“Deletes an existing file in a repository.”

Il supprime un fichier existant du dépôt, et comme la création, il passe par un commit.

Quand l'utiliser
un fichier généré qui doit disparaître quand sa source est retirée.
Attention
pas de brouillon, aucun module pour revenir en arrière, teste avec Run once sur une branche dont personne ne dépend.
GitLab23

Delete a Label

Action

Dans Make“Deletes a project label.”

Il sort un label du projet pour de bon.

Quand l'utiliser
une convention de nommage qui a changé, et les anciens labels ne doivent plus traîner dans la liste.
Attention
le label disparaît pour tout le projet, mets toute l'équipe d'accord sur la convention avant d'automatiser le ménage.
GitLab24

Delete a Merge Request

Action

Dans Make“Only for admins and project owners. Soft deletes the merge request.”

Une merge request se supprime en douceur ici, et seuls les administrateurs et les propriétaires de projet y ont droit.

Quand l'utiliser
des merge requests ouvertes par un robot qui ont rempli la liste de bruit.
Attention
le droit se vérifie sur le compte de ta connexion, un scénario bâti sur un compte ordinaire échouera simplement à cette étape.
GitLab25

Delete a Milestone

Action

Dans Make“Deletes a project milestone.”

Il nettoie un jalon de projet une fois le sprint ou la version derrière toi.

Quand l'utiliser
un scénario d'entretien qui retire les jalons qu'une équipe a cessé d'utiliser.
Attention
le regroupement part avec le jalon, décide du sort des tickets qu'il tenait avant de lancer le scénario.
GitLab26

Delete an Issue

Action

Dans Make“Deletes an issue.”

Il efface un ticket au lieu de le fermer. Fermer masque, supprimer enlève.

Quand l'utiliser
du spam ouvert sur un dépôt public, où la fermeture ne suffit pas.
Attention
aucun module ne le ramène, une suppression pilotée par un déclencheur mérite un contrôle humain avant.
GitLab27

Delete a Repository Branch

Action

Dans Make“Deletes a single project repository branch.”

Il retire une branche du projet, une seule à la fois.

Quand l'utiliser
le ménage de branches qui suit une fusion, pour garder une liste lisible.
Attention
vise la branche que la merge request a utilisée, jamais un nom deviné par le scénario, sinon tu effaces du travail encore ouvert.
GitLab28

Delete a Tag

Action

Dans Make“Deletes a tag.”

Il enlève un tag du dépôt.

Quand l'utiliser
une version taguée par erreur, avant que quelqu'un construise quoi que ce soit dessus.
Attention
tags et releases sont liés, regarde ce qui dépend du tag avant que le scénario le fasse disparaître.
GitLab29

Delete a Variable

Action

Dans Make“Removes a project's build variable.”

Il retire une variable de build des réglages du projet.

Quand l'utiliser
un service dont tu t'es séparé, et dont la clé n'a plus rien à faire là.
Attention
un pipeline qui attend cette variable échouera à sa prochaine exécution, retire l'étape correspondante en même temps.
GitLab30

Erase a Job

Action

Dans Make“Erases a single build of a project (remove build artifacts and a build trace).”

Effacer un job supprime ses artefacts et sa trace. Le compte rendu de l'exécution part, l'espace de stockage revient.

Quand l'utiliser
un job qui a journalisé ce qu'il n'aurait jamais dû journaliser.
Attention
la trace est justement ce qu'on lit pour comprendre un échec, efface après l'enquête, pas avant.
GitLab31

Execute a GraphQL Query

Action

Dans Make“Performs an arbitrary authorized GraphQL query.”

Il exécute une requête GraphQL autorisée sur GitLab avec la connexion déjà en place. La porte de sortie pour les données que les autres modules n'exposent pas.

Quand l'utiliser
un rapport qui a besoin de champs venant de plusieurs objets d'un coup.
Attention
la requête, c'est toi qui l'écris, ce module suppose donc quelqu'un à l'aise avec l'API GitLab.
GitLab32

Get a Commit

Action

Dans Make“Returns a specific commit identified by the commit hash or name of a branch or tag.”

Un commit revient, retrouvé à partir d'un hash, d'un nom de branche ou d'un nom de tag.

Quand l'utiliser
une poussée de tag qui doit révéler ce qui se cache vraiment derrière la version.
Attention
il rend le commit, pas les fichiers modifiés, c'est un tout autre module.
GitLab33

Get a Deployment

Action

Dans Make“Returns a specific deployment of a project.”

Il va chercher un déploiement précis d'un projet, pour que le scénario sache ce qui est parti et où.

Quand l'utiliser
une chronologie d'incident qui doit aligner les déploiements sur le moment où ça a cassé.
Attention
l'identifiant du déploiement est indispensable, quelque chose en amont doit le fournir.
GitLab34

Get a File from Repository

Action

Dans Make“Allows you to receive information about a file in the repository like name, size, content.”

Il lit un fichier du dépôt et te rend ses informations, nom, taille et contenu compris.

Quand l'utiliser
un fichier de version ou un manifeste que la suite du scénario doit lire avant de décider.
Attention
c'est la version descriptive, le module de fichier brut convient mieux quand seul le contenu compte.
GitLab35

Get a Job

Action

Dans Make“Retrieves a single build of a project.”

Il récupère un build d'un projet, avec son statut et ses détails.

Quand l'utiliser
un déclencheur de pipeline qui annonce qu'il s'est passé quelque chose, sans dire quel job ni comment ça s'est terminé.
Attention
un job n'est qu'une partie d'un pipeline, une exécution chargée veut dire beaucoup d'appels, et chaque appel est une opération.
GitLab36

Get a Label

Action

Dans Make“Returns details about a label.”

Il répond avec le détail d'un label. Petit module, utile quand un scénario doit décider à partir d'un label plutôt qu'à l'aveugle.

Quand l'utiliser
un aiguillage où le label du ticket désigne l'équipe à prévenir.
Attention
les labels sont nommés par des humains, un renommage en amont casse en silence le scénario qui cherche l'ancien nom.
GitLab37

Get a Merge Request

Action

Dans Make“Shows information about a single merge request.”

Il montre une merge request en entier : titre, état, branches et le reste.

Quand l'utiliser
un événement de note qui donne un commentaire, quand le scénario a besoin de la merge request autour avant de réagir.
Attention
les identifiants appartiennent à un projet, transporte le projet dans ton mapping, pas seulement le numéro.
GitLab38

Get a Merge Request Note

Action

Dans Make“Returns a single note for a given merge request.”

Il ramène un seul commentaire de merge request, par son identifiant.

Quand l'utiliser
un scénario qui a gardé la note qu'il a postée et veut la relire avant de la modifier.
Attention
une note à la fois, prends le module de liste quand il te faut toute la discussion.
GitLab39

Get a Milestone

Action

Dans Make“Returns a single project milestone.”

Il rend un jalon de projet avec ses dates et son état.

Quand l'utiliser
un rapport qui vérifie que le jalon en cours est encore ouvert avant d'y ajouter quoi que ce soit.
Attention
il répond sur le jalon lui-même, jamais sur les tickets qu'il contient.
GitLab40

Get an Issue

Action

Dans Make“Returns a single project issue.”

Il lit un ticket du projet, c'est ainsi qu'un scénario récupère les détails d'un ticket qu'il n'a pas créé.

Quand l'utiliser
une note postée sur un ticket, quand le scénario a besoin de son état et de son responsable avant de trancher.
Attention
relis le ticket au moment où tu en as besoin, une valeur lue tôt dans un long scénario peut déjà être périmée.
GitLab41

Get an Issue Note

Action

Dans Make“Returns a single note for a specific project issue.”

Récupère un commentaire précis posé sur un ticket, avec son texte et son auteur, prêt pour la suite du scénario.

Quand l'utiliser
un ticket client dont la réponse utile tient dans un seul commentaire, à recopier dans l'outil de suivi du support.
Attention
il lit un commentaire que tu désignes à l'avance, donc un fil entier passe plutôt par le module de liste.
GitLab42

Get a Pipeline

Action

Dans Make“Returns a single pipeline for a given project.”

Lit l'état d'un pipeline d'un projet pour que ton scénario sache quoi en faire.

Quand l'utiliser
juste avant d'annoncer une mise en production dans le canal de l'équipe, pour vérifier que tout est bien passé.
Attention
la réponse est une photo prise à la seconde où le module tourne, et un pipeline encore en cours paraîtra inachevé.
GitLab43

Get a Project

Action

Dans Make“Retrieves a specific project owned by the user and identified by name, ID or namespace.”

Va chercher les informations d'un projet. Tu le désignes par son nom, son identifiant ou son espace de noms, selon ce que ton scénario a déjà sous la main.

Quand l'utiliser
un scénario qui démarre sur une ligne de tableur, où un nom de projet écrit à la main doit devenir quelque chose que GitLab reconnaît.
Attention
il cherche parmi les projets que possède le compte connecté, donc un projet appartenant à quelqu'un d'autre peut ne rien renvoyer.
GitLab44

Get a Raw File from Repository

Action

Dans Make“Returns content from a repository.”

Renvoie le contenu d'un fichier tel que le dépôt le stocke, sans rien autour.

Quand l'utiliser
un fichier de traduction versionné qu'une autre app doit relire à chaque passage.
Attention
tu obtiens le contenu et rien d'autre, donc quand le nom ou la taille du fichier comptent aussi, l'autre module de fichier répond mieux.
GitLab45

Get a Repository Branch

Action

Dans Make“Returns a single project repository branch.”

Interroge GitLab sur une branche d'un projet et ramène ses informations dans le scénario.

Quand l'utiliser
avant de lancer un déploiement automatique, pour confirmer que la branche de recette existe toujours.
Attention
il répond pour la seule branche que tu nommes ; pour voir tout ce qui vit dans le projet, c'est la recherche de branches qu'il faut poser.
GitLab46

Get a Snippet Note

Action

Dans Make“Returns a single note for a given snippet.”

Un commentaire laissé sous un snippet, repris tel quel et posé dans le scénario.

Quand l'utiliser
la remarque d'un relecteur sur un bout de code partagé, qui doit arriver dans la documentation interne sans copier-coller.
Attention
les commentaires de snippet et ceux de ticket sont deux objets différents chez GitLab, et ce module ne lit que le côté snippet.
GitLab47

Get a Tag

Action

Dans Make“Returns a specific repository tag determined by its name.”

Retrouve un tag du dépôt à partir de son nom et renvoie ce que GitLab en sait.

Quand l'utiliser
un scénario de livraison qui relit le tag qu'il vient de créer avant de rédiger la note de version.
Attention
le nom doit correspondre caractère par caractère, donc une version écrite autrement ailleurs dans le scénario ne trouvera rien.
GitLab48

Get a User

Action

Dans Make“Returns a single user.”

Transforme l'utilisateur qu'un module précédent a transmis en informations lisibles, nom compris.

Quand l'utiliser
un message dans le canal de l'équipe où la personne assignée doit apparaître avec son nom, pas avec un identifiant.
Attention
il répond pour un utilisateur que tu connais déjà ; retrouver quelqu'un à partir d'un morceau de texte, c'est le travail du module de recherche.
GitLab49

Get a Variable

Action

Dans Make“Retrieves the details of a project's specific build variable.”

Une variable de build du projet, lue sans ouvrir les réglages à la main.

Quand l'utiliser
un contrôle avant livraison, pour confirmer qu'une variable pointe bien vers l'environnement que l'équipe imagine.
Attention
ces variables transportent souvent des secrets, donc réfléchis à deux fois au module que tu places derrière.
GitLab50

Get My Info

Action

Dans Make“Returns details about an account.”

Affiche le compte GitLab qui se trouve derrière la connexion, sans rien toucher dans un projet.

Quand l'utiliser
comme tout premier module après Create a connection, testé avec Run once, pour voir le compte répondre avant de construire quoi que ce soit dessus.
GitLab51

Keep Artifacts

Action

Dans Make“Prevents artifacts from being deleted when expiration is set.”

Demande à GitLab de conserver les artefacts d'un job au lieu de les laisser disparaître à l'expiration.

Quand l'utiliser
une compilation de nuit dont le rapport doit tenir jusqu'à la réunion du lundi quand les tests virent au rouge.
Attention
il agit sur un job à la fois, donc place-le juste après ce qui te donne ce job.
GitLab52

Make an API Call

Action

Dans Make“Performs an arbitrary authorized API call.”

La porte de sortie du catalogue. Ce module appelle n'importe quel point d'entrée de l'API de GitLab, l'interface par laquelle deux logiciels échangent, avec la connexion déjà créée.

Quand l'utiliser
une chose que GitLab sait faire et qu'aucun module de cette page ne couvre.
Attention
rien n'est préparé ici, tu écris l'appel et tu lis la réponse brute, d'où l'intérêt d'essayer d'abord les modules tout faits.
GitLab53

Mark a Todo as Done

Action

Dans Make“Marks a single pending todo given by its ID for the current user as done.”

Coche une tâche en attente sur la liste du compte connecté, comme un clic dans GitLab l'aurait fait.

Quand l'utiliser
une demande de relecture que le scénario a déjà transférée ailleurs, retirée pour que la liste reste crédible.
Attention
il n'atteint que la liste du compte posé derrière la connexion, jamais celle d'un collègue.
GitLab54

Play a Job

Action

Dans Make“Triggers a manual action to start a build.”

Lance un job resté en attente d'une action manuelle et laisse le pipeline repartir, sans que personne ouvre GitLab.

Quand l'utiliser
une étape de déploiement laissée en manuel volontairement, déclenchée dès que la validation arrive de l'outil où se prennent les décisions, et pas le lendemain matin.
GitLab55

Post a Comment to Commit

Action

Dans Make“Adds a comment to a commit.”

Écrit un commentaire directement sur un commit, là où le trouvera la personne qui relit l'historique.

Quand l'utiliser
le verdict d'un contrôle qui tourne hors de GitLab et qui a sa place à côté du commit qui l'a provoqué.
Attention
chaque passage ajoute un commentaire de plus, donc un scénario qui se déclenche deux fois sur le même commit en laisse deux.
GitLab56

Retry Failed Jobs in a Pipeline

Action

Dans Make“Retries failed builds in a pipeline.”

Relance les jobs tombés dans un pipeline et laisse tranquilles ceux qui sont passés.

Quand l'utiliser
une étape qui trébuche sur un incident passager, à qui tu laisses une seconde chance avant de réveiller quelqu'un.
Attention
un job qui a échoué pour une vraie raison échouera encore, donc un scénario qui relance sans limite tourne en rond.
GitLab57

Update a Label

Action

Dans Make“Updates a label.”

Modifie une étiquette que le projet possède déjà, son nom ou sa couleur, depuis le scénario plutôt qu'à la main.

Quand l'utiliser
le jour où l'équipe revoit ses niveaux de priorité et où le même changement doit atterrir dans plusieurs projets.
Attention
l'étiquette doit exister au préalable, puisqu'en créer une revient au module de création.
GitLab58

Update a Merge Request

Action

Dans Make“Updates an existing merge request. You can change the target branch, title, or even close the merge request.”

Change une demande de fusion ouverte : son titre, sa branche cible, et la fermer compte aussi comme une modification.

Quand l'utiliser
une période de gel où la branche cible bouge pour tout le monde en même temps.
Attention
la fermeture passe par ce même module, donc une donnée mal reliée peut clore un travail que personne ne voulait clore.
GitLab59

Update a Merge Request Note

Action

Dans Make“Modifies an existing note of a merge request.”

Réécrit un commentaire déjà publié sous une demande de fusion, pour garder un seul message au lieu d'une pile.

Quand l'utiliser
une ligne de suivi tenue à jour par un scénario qui tourne plusieurs fois par jour sur la même demande.
Attention
le scénario a besoin de la référence de ce commentaire, donnée par le module qui l'a créé ou par la liste des notes, avant de pouvoir y toucher.
GitLab60

Update a Milestone

Action

Dans Make“Updates an existing project milestone.”

Garde un jalon aligné sur un planning qui a bougé ailleurs.

Quand l'utiliser
un trimestre qui change de forme après un comité tenu en dehors de GitLab.
Attention
un jalon appartient à un projet, donc un scénario qui en parcourt plusieurs doit viser le bon à chaque passage.
GitLab61

Update an Issue

Action

Dans Make“Updates an existing project issue. This call is also used to mark an issue as closed.”

Met à jour un ticket existant, et c'est aussi ce module qui le ferme.

Quand l'utiliser
un ticket qui se ferme dans GitLab dès que le service client le clôture de son côté.
Attention
la fermeture vit ici, donc teste le scénario avec Run once sur un ticket d'essai avant de l'activer.
GitLab62

Update an Issue Note

Action

Dans Make“Modifies an existing note of an issue.”

Remplace le texte d'un commentaire déjà posé sur un ticket.

Quand l'utiliser
un message publié trop tôt par un scénario, corrigé dès que le chiffre définitif arrive.
Attention
le nouveau texte prend la place de l'ancien et Make n'en garde aucune copie, donc range l'original quelque part quand il compte.
GitLab63

Update a Release

Action

Dans Make“Updates the release notes of a given release.”

Complète après coup les notes d'une release, pour qu'une annonce ne reste pas figée sur son premier jet.

Quand l'utiliser
un récapitulatif rédigé dans un autre outil et versé dans la release une fois qu'il se lit bien.
Attention
la release doit déjà exister, et ce qui change ici c'est le texte, pas le tag qui se trouve dessous.
GitLab64

Update a Snippet Note

Action

Dans Make“Modifies an existing note of a snippet.”

Corrige sur place une remarque laissée sous un snippet, au lieu d'y répondre par une autre.

Quand l'utiliser
une remarque qui a cessé d'être vraie le jour où le code partagé a changé.
Attention
trois modules distincts réécrivent des commentaires, un par objet, et seul celui du snippet sera accepté pour un snippet.
GitLab65

Update a Variable

Action

Dans Make“Updates a project's build variable.”

Pousse une nouvelle valeur dans une variable de build du projet, à la place de celle qui s'y trouvait.

Quand l'utiliser
une clé renouvelée chaque trimestre, écrite dans le projet par le scénario qui la génère.
Attention
l'ancienne valeur disparaît dès que le module tourne, donc lis la variable d'abord si tu risques d'en avoir besoin.
GitLab66

Get a Diff of a Commit

Recherche

Dans Make“Returns the diff of a commit in a project.”

Ouvre un commit et ramène la modification elle-même dans le scénario, pas seulement sa référence.

Quand l'utiliser
un résumé envoyé dans le canal de relecture, pour des gens qui veulent voir ce qui a bougé sans ouvrir GitLab.
Attention
un commit qui touche beaucoup de fichiers revient chargé, donc garde simple le module placé derrière.
GitLab67

Get a Merge Request Commits

Recherche

Dans Make“Get a list of merge request commits.”

Rassemble les commits que porte une demande de fusion, chacun arrivant séparément, ce qui permet d'écrire une ligne par commit.

Quand l'utiliser
une note de version construite sur ce que la demande contient vraiment, plutôt que sur son titre.
Attention
une longue demande envoie beaucoup d'éléments dans la suite du scénario, et chaque élément traité par un module compte comme une opération sur ton plan.
GitLab68

List a Project's Users

Recherche

Dans Make“Retrieves the repository contributors list.”

La liste des contributeurs d'un projet, nom par nom.

Quand l'utiliser
une revue d'accès qui part de ceux qui apparaissent vraiment sur le projet, plutôt que d'un tableur oublié.
Attention
ce qui revient est la liste des contributeurs du dépôt, ce qui n'est pas la même chose que les personnes disposant d'un accès aujourd'hui.
GitLab69

List Commit Comments

Recherche

Dans Make“Returns the comments of a commit in a project.”

Récolte les commentaires laissés sous un commit et les transmet l'un après l'autre.

Quand l'utiliser
une trace de relecture recopiée dans le ticket qui avait demandé la modification, pour qu'elle ne reste pas enfouie dans l'historique.
Attention
un commit que personne n'a commenté ne renvoie rien du tout, et les modules placés derrière ne tournent tout simplement pas.
GitLab70

List Deployments

Recherche

Dans Make“Returns a list of deployments in a project.”

Dresse la liste des déploiements d'un projet, pour que la trace vive ailleurs que dans la mémoire de la personne qui a appuyé sur le bouton.

Quand l'utiliser
un récapitulatif hebdomadaire des mises en production, préparé le matin de la réunion d'équipe.
GitLab71

List Issue Notes

Recherche

Dans Make“Returns a list of all notes for a single issue.”

Tous les commentaires d'un ticket, la conversation entière plutôt qu'un message isolé.

Quand l'utiliser
un ticket qui se ferme et dont l'échange doit être classé dans la fiche du client.
Attention
le module travaille ticket par ticket, donc le ticket doit être identifié avant qu'il ne tourne.
GitLab72

List Issues that close on Merge

Recherche

Dans Make“Get issues that would be closed by merging the provided merge request.”

Regarde à l'avance quels tickets se fermeraient si cette demande de fusion était fusionnée.

Quand l'utiliser
un message dans le canal de relecture, pour que les personnes qui ont ouvert ces tickets l'apprennent en premier.
Attention
c'est une intention, pas un fait, et rien ne se ferme tant que personne n'a fusionné.
GitLab73

List Jobs

Recherche

Dans Make“Returns a list of builds in a project.”

Parcourt les jobs d'un projet et les envoie dans le scénario.

Quand l'utiliser
un résumé du matin sur ce qui a tourné la nuit, pour une équipe qui préfère éviter l'écran des pipelines.
Attention
il couvre tout le projet, donc quand seule la dernière exécution compte, lire le pipeline reste plus léger.
GitLab74

List Labels

Recherche

Dans Make“Returns all labels for a given project.”

Vérifie quelles étiquettes existent dans un projet, ce qui indique au scénario ce qu'il a le droit de poser.

Quand l'utiliser
en étape juste avant le module qui étiquette un ticket, pour être sûr que l'étiquette est bien là.
Attention
les étiquettes appartiennent à un projet, donc un nom présent ici peut manquer dans le projet d'à côté.
GitLab75

List Merge Request Changes

Recherche

Dans Make“Retrieves the list of changes for a specified merge request.”

Mesure l'ampleur d'une demande de fusion en listant ce qu'elle change, sans que personne ne l'ouvre.

Quand l'utiliser
le choix d'un relecteur, puisqu'une petite modification et une grosse ne partent pas chez la même personne.
Attention
ce module répond avec les modifications elles-mêmes, là où le module de commits répond avec l'historique qui les a produites.
GitLab76

List Merge Request Notes

Recherche

Dans Make“Returns a list of all notes for a single merge request.”

Ramasse les commentaires d'une demande de fusion et laisse le scénario en faire quelque chose.

Quand l'utiliser
une relecture archivée hors de GitLab le jour où la fusion est faite.
Attention
tes propres scénarios peuvent écrire ici par les modules de note, donc lis l'auteur avant de transmettre un message comme une remarque humaine.
GitLab77

List Merge Requests closing an Issue

Recherche

Dans Make“Retrieves all merge requests that will close a specified issue when merged.”

Répond, côté ticket, à une question simple : est-ce qu'une demande de fusion est en train de le refermer ?

Quand l'utiliser
avant d'assigner un ticket, pour voir si quelqu'un a déjà du travail en cours dessus.
Attention
rien ne revient quand aucune demande n'est reliée, et ce silence est une réponse ; le module miroir lit le même lien en partant de la demande de fusion.
GitLab78

List Milestone Issues

Recherche

Dans Make“Retrieves all issues assigned to a single project milestone.”

Réunit les tickets rattachés à un jalon pour que son état se lise en dehors de GitLab.

Quand l'utiliser
un point de fin de sprint préparé le matin même, sans compter les cartes à la main.
Attention
un jalon à la fois, identifié au préalable, ce à quoi sert justement la liste des jalons.
GitLab79

List Milestones

Recherche

Dans Make“Returns a list of project milestones.”

Passe en revue les jalons d'un projet avec ce que GitLab sait de chacun.

Quand l'utiliser
retrouver le jalon en cours avant d'y ranger un nouveau ticket.
Attention
plusieurs jalons peuvent être ouverts en même temps, donc le scénario a besoin d'une règle pour choisir plutôt que de prendre le premier venu.
GitLab80

List Owned Projects

Recherche

Dans Make“Returns the user's list of projects.”

Sort la liste des projets que détient le compte connecté, bonne façon de démarrer un scénario censé travailler sur tous.

Quand l'utiliser
un inventaire versé dans un tableur une fois par mois, pour que personne ne débatte de ce qui existe.
Attention
la réponse dépend de la connexion posée derrière le module, donc deux connexions donnent deux listes différentes.
GitLab81

List Project Issues

Recherche

Dans Make“Returns a list of a project's issues.”

Les tickets d'un projet arrivent ici un par un, chacun formant un bundle, l'élément qui passe d'un module au suivant.

Quand l'utiliser
une revue hebdomadaire qui dépose les tickets ouverts du dépôt principal dans un tableau partagé avec le client.
Attention
chaque ticket remonté fait tourner une fois les modules placés derrière, et chaque tour compte une opération sur ton plan.
GitLab82

List Repository Contributors

Recherche

Dans Make“Retrieves repository contributors list.”

Qui travaille vraiment sur ce dépôt ? List Repository Contributors renvoie la liste des contributeurs du projet, prête à alimenter un rapport ou une ligne par personne dans un tableur.

Quand l'utiliser
une agence qui facture au dépôt et doit dire au client qui est intervenu le mois dernier.
Attention
List a Project's Users renvoie cette même liste de contributeurs, garde l'un des deux dans tes scénarios et laisse l'autre de côté.
GitLab83

List Repository Tags

Recherche

Dans Make“Returns a list of repository tags from a project, sorted by name in reverse alphabetical order.”

Les tags marquent les points d'un dépôt sur lesquels on revient, et le module les remonte tous, triés par nom en ordre alphabétique inverse.

Quand l'utiliser
un éditeur de logiciel qui prépare ses notes de version à partir des tags déjà posés.
Attention
alphabétique inverse ne veut pas dire du plus récent au plus ancien, v9 passe devant v10.
GitLab84

List Repository Tree

Recherche

Dans Make“Returns a list of repository files and directories in a project.”

List Repository Tree déplie l'arborescence d'un projet et renvoie ses fichiers et ses dossiers, une entrée par bundle.

Quand l'utiliser
vérifier qu'un fichier de configuration attendu est bien présent dans chacun des dépôts d'une équipe.
Attention
tu obtiens la carte, pas le contenu, envoie chaque entrée vers Get a Raw File from Repository pour lire ce qu'il y a dedans.
GitLab85

List Snippet Notes

Recherche

Dans Make“Returns a list of all notes for a single snippet. Snippet notes are comments users can post to a snippet.”

Ce que GitLab appelle notes de snippet, ce sont les commentaires laissés sur un bout de code partagé ; le module les rassemble toutes pour un snippet donné.

Quand l'utiliser
un responsable technique qui relit les remarques d'un snippet avant de le réécrire.
Attention
le module traite un snippet à la fois, désigne-le d'abord, puis recommence pour le suivant.
GitLab86

List Todos

Recherche

Dans Make“Returns a list of todos. When no filter is applied, it returns all pending todos for the current user.”

List Todos remonte les todos du compte connecté, et quand aucun filtre n'est posé, ce sont celles qui attendent encore.

Quand l'utiliser
un rappel de fin de journée qui t'envoie ce qui reste en attente avant de terminer.
Attention
les todos suivent le compte de la connexion, pas l'équipe entière, une connexion partagée change donc ce qui revient.
GitLab87

List Variables

Recherche

Dans Make“Returns a list of a project's build variables.”

Les variables de build d'un projet passent dans le scénario avec List Variables, une par bundle, sans que personne aille les vérifier à la main.

Quand l'utiliser
un audit avant de confier un dépôt à un prestataire, pour voir ce qui y est déclaré.
Attention
le module regarde un projet à la fois, place Search Projects devant lui pour balayer un groupe entier.
GitLab88

Search Groups

Recherche

Dans Make“Returns a list of groups.”

Les groupes chapeautent les projets, et Search Groups les renvoie un par un, ce qui donne au scénario son point de départ avant de descendre dans les dépôts.

Quand l'utiliser
une direction technique qui veut la cartographie de ses groupes avant de décider lesquels archiver.
GitLab89

Search Issues

Recherche

Dans Make“Returns all issues created by the authenticated user.”

Search Issues ne se limite pas à un projet : il renvoie les tickets créés par le compte de la connexion, où qu'ils se trouvent.

Quand l'utiliser
un chef de projet qui retrouve en fin de sprint tout ce qu'il a ouvert lui-même.
Attention
le critère porte sur qui a créé le ticket, celui qu'une autre personne a ouvert puis confié au compte reste en dehors.
GitLab90

Search Merge Requests

Recherche

Dans Make“Retrieves all merge requests for a project.”

Toutes les merge requests d'un projet remontent d'un coup, une par bundle, sans avoir à les ouvrir une à une.

Quand l'utiliser
un tableau de bord interne alimenté chaque matin avec les merge requests du dépôt principal.
Attention
quand tu sais déjà quelle merge request t'intéresse, Get a Merge Request va droit dessus, celui-ci sert à balayer le projet.
GitLab91

Search Pipelines

Recherche

Dans Make“Retrieves all pipelines for a given project.”

Search Pipelines donne l'historique des pipelines d'un projet, exécution par exécution, de quoi suivre un dépôt sans ouvrir l'interface.

Quand l'utiliser
alimenter la rétrospective de fin de sprint avec l'historique du dépôt principal.
Attention
ce module lit ce qui a déjà tourné, pour en lancer un nouveau c'est Create a Pipeline.
GitLab92

Search Projects

Recherche

Dans Make“Returns a list of projects of which the authenticated user is a member.”

Avant de traiter plusieurs dépôts d'un coup, il faut leur liste. Search Projects la donne : les projets dont le compte connecté est membre, un par bundle.

Quand l'utiliser
une équipe qui gère plusieurs dizaines de dépôts et veut leur appliquer le même contrôle.
Attention
c'est l'appartenance qui décide, un dépôt où le compte n'a pas été ajouté n'apparaîtra jamais.
GitLab93

Search Repository Branches

Recherche

Dans Make“Returns a list of repository branches from a project.”

Une photo des branches d'un projet, c'est ce que rend Search Repository Branches, une branche par bundle.

Quand l'utiliser
vérifier qu'une branche de correctif existe bien avant de lancer la suite du scénario.
Attention
supprimer est un autre geste, Delete a Repository Branch s'en charge, et une branche effacée par un scénario ne revient pas.
GitLab94

Search Repository Commits

Recherche

Dans Make“Returns a list of repository commits in a project.”

Un changelog se construit à partir des commits. Search Repository Commits renvoie ceux d'un projet, un par bundle, que le module suivant peut mettre en forme.

Quand l'utiliser
publier les notes de version sur le wiki interne à chaque fin de sprint.
Attention
le détail de ce qui a changé n'est pas dans le résultat, Get a Diff of a Commit va le chercher.
GitLab95

Search Users

Recherche

Dans Make“Searches for users or lists them all.”

Search Users met un compte GitLab en face d'un nom, et quand tu ne lui donnes aucun critère, il remonte tous les utilisateurs.

Quand l'utiliser
une fiche d'arrivée qui vérifie que le compte du nouveau développeur existe avant la suite du scénario.
Attention
une recherche vide parcourt tout le monde, ça fait beaucoup de bundles pour une seule vérification, donne-lui toujours un critère.
Besoin d'aide

Besoin d'aide pour automatiser GitLab avec Make ?

Une personne lit chaque message.

FAQ

Les questions qui viennent ensuite

01L'intégration GitLab Make est-elle gratuite ?
Oui. GitLab est une app standard, disponible dès le plan Free. Ce plan donne 2 scénarios actifs, 15 minutes minimum entre deux exécutions planifiées, 5 minutes d'exécution par passage, des fichiers jusqu'à 5 Mo et 512 Mo de transfert. Les plans payants descendent l'intervalle à 1 minute, lèvent la limite de scénarios actifs et poussent l'exécution à 40 minutes. La consommation se compte en crédits, c'est-à-dire en opérations, une opération étant un module qui tourne sur un élément. Le tarif de GitLab lui-même se règle chez GitLab, pas ici.
02Que faut-il pour brancher GitLab sur Make ?
Un compte GitLab actif et un jeton d'accès. La doc n'exige rien d'autre. Sans compte, tu en crées un chez GitLab, où se règle aussi la question de l'abonnement. Côté Make, tu ajoutes un module GitLab, tu cliques sur Create a connection, tu nommes la connexion dans le champ Connection name si ça t'arrange, puis tu colles les identifiants copiés depuis GitLab ou tu suis les instructions affichées. En OAuth2, GitLab fabrique un Client ID et un Client secret depuis la section Applications de ton profil, avec l'URI de rappel attendue par Make.
03Les déclencheurs GitLab réagissent-ils en temps réel ?
La plupart, oui. Huit des dix déclencheurs sont instantanés : GitLab prévient Make par webhook dès que ça se passe, pour les notes, les tickets, les jobs, les merge requests, les pipelines, les poussées, les tags et les pages de wiki. Deux sont planifiés, Watch Projects et Watch Todos, et là Make interroge GitLab au rythme du scénario. Un nouveau scénario est réglé sur 15 minutes par défaut, et le plan Free ne descend pas sous cet intervalle ; les plans payants vont jusqu'à 1 minute. Les modules instantanés demandent en plus de cliquer sur Create a webhook avant Create a connection.
04Que faire s'il manque un module GitLab dans Make ?
Passer par Make an API Call. GitLab dispose de ce module, donc n'importe quel point d'entrée de l'API GitLab s'appelle depuis le scénario avec la connexion déjà créée. Execute a GraphQL Query rend le même service côté GraphQL quand il faut plusieurs objets en une requête. Une réserve à connaître : la documentation GitLab de Make est générée à partir de la documentation officielle de GitLab et peut contenir des erreurs. Avant de bâtir un scénario de production dessus, vérifie le point qui compte directement chez GitLab.
05Make ou n8n pour GitLab ?
Ça dépend de l'équipe qui va vivre avec le scénario. Make se pilote depuis un canevas visuel : tu poses des modules, tu lis ce que ton compte connecté propose, et chaque opération se compte sur ton plan, un choix confortable pour construire sans toucher au code. Si l'équipe préfère au contraire mettre les mains dans le code, ou héberger l'outil elle-même, n8n couvre la même app par ce chemin-là. Aucun des deux n'a raison sur le papier : ce qui tranche, c'est qui réparera le scénario dans six mois et l'éditeur où cette personne se sent à l'aise.
Hack'celeration Lab

Reçois nos astuces d'automatisation chaque semaine.

Pas de spam. Désinscription en un clic.

Même plateforme

Autres docs utiles sur ce stack.

Voir toutes les intégrations